At the core of TICL stands a simple component model that can be
extended by leveraging existing components and the various sub-frameworks.

Enables developers to encapsulate UI
functionality into well-defined components, thus promoting reuse, speeding
up development and easily presenting a uniform end-user experience without
any code duplication in the main application logic.

Component-Level MVC

TICL implements the
widely known Model-View-Controller design pattern at the level of a single
component, as opposed to the commonly used rigid Model 2 architecture where
MVC is at the page level.

Provides a finer-grained control and decoupling
of UI logic. This enables construction of self-contained components reusable
in various places through composition. Moreover, this architecture is
synergetic and complimentary with Model 2 - hence TICL is usable in
existing Model 2 applications.

Client-Side Managed Interaction

Components can provide a client-side version (e.g. through DHTML)
where all interaction happens on the client device. Most predefined TICL
components do.

A much better end-user experience in a
transparent to a developer way. Eliminates the need of writing convoluted
DHTML code in pages, thus separating concerns and resulting in a cleaner,
maintainable code.

Ready Made Components

Standard forms and form fields.

Pull-down menus.

TableView (Grid) component.

TreeView.

Panels and tabbed sheets.

The out-of-the-box plug and play components
allow one to jump start UI development in a matter of hours. Common and
redundant UI programming tasks are virtually eliminated.

Styling Framework

TICL comes with an
elaborate styling and rendering framework. Look&feel of components is
defined through customizable renderers and skins. Themes can be defined for
the whole web application or at the level of a single page. Styles and
renderers can be targeted towards specific user agent devices.

Promotes encapsulation and reuse of visual
rendering. Enables separation of concerns between UI developers and web
designers. Significantly reduces code overhead and duplication in
pages and servlets. Provides a virtually unlimited flexibility and
configurability of the rendering.

Powerful Form Components

Standard HTML form field and more elaborate composite fields are implemented
as high-level, strongly type components, and decorated with additional
functionality such as labels and tooltips.

Leads to more robust code resulting from static
type checking. Improves productivity through encapsulation and reuse of
common data entry scenarios.

Declarative Form Validation

A very
elaborate form validation framework enables you to declare validation rules
and handle them also in a clean declarative way. Validation can be performed
at various times - at the server, while the user is entering input, just
before a form is submitted - through the same API and custom tag
syntax. There are declarative facilities to deal of field value
interdependencies as well!

Improves productivity through a simplified
high-level interface for performing form validation. Promotes encapsulation
of validation logic into pre-defined reusable rules and conditions. Reduces
coupling by separating business logic from presentation from UI validation
logic. Improves user experience by signaling data entry error at the
appropriate time and as soon as possible.

Automatic Business Object <-> Form Mapping

Populating a TICL form from business object values and vice-versa is
performed automatically with arbitrary customizable type mappings. Business
objects are represented by a data objects abstraction layer that
includes a standard Java beans implementation and opens possibilities for
other implementations such as direct SQL access or an XML representation.

Greatly improves productivity and application
stability by reducing the possible programming mistakes. Promotes
low-coupling between the underlying business model and the user interface
logic.

Flexible Event Model

The comprehensive,
hierarchical event model in TICL encapsulates all controller and
component interaction logic. Custom events and event factories can be
defined. Listeners can be registered per event type or component ID or URI
pattern. The event queue is accessible and can be manipulated from
listeners. Events can be triggered at any point during request processing.

Provides tremendous flexibility and a true
separation of concerns between the application logic and the presentation
layer. Lays a strong foundation for building application logic by
promoting encapsulation and low-coupling between the various aspects and
layers of an application.

Browser Agnostic

TICL, the framework
and all predefined functionality, have been tested to work with all major
browsers.

Uniform user experience regardless of her
environment and with no additional development overhead.

User Agent Capabilities Management

A
complete flexible framework for defining statically as well as detecting at
run-time the capabilities of various user agents (browsers). User
agents are identified by their name, version number and platform. One can
associate a set of static and dynamic properties with a user agent.

The user agent capabilities abstraction layer
enables handling of multiple browsers in a structured, clean way thus
reducing code complexity and duplication while providing an uniform and
pleasant end-user experience targeted to her particular environment.

Standards Based

TICL is based on the
open Java standards for JSP(TM) 1.1 and Java Servlets(TM) 2.2. An
implementation of the upcoming JavaServer Faces standard is under way and
will be part of future releases of the product when that specification is
complete.

Rendering objects are pre-initalized and reused throughout
simultaneous requests.

Scalability! All high-level, self-contained
functionality in the toolkit comes with minimal performance impact. Use TICL
in large scale web application without worrying about any unexpected server
resource load.

Internationalization

TICL supports the standard Java
mechanism for internationalized content through resource bundle. All
tag attributes in the tag library accept values from a resource bundle and
all locale-sensitive components support i18n settings.

Build internationalized web application with
minimal development and maintenance effort. No need for complicated
templates, simply set tag attributes by providing keys to locale specific
bundles.

JSTL EL Support

All tag attributes in
TICL support the expression language (EL) standardized in the Java Standarad
Tag Library (JSTL) and in the JSP 2.0 specification. However, TICL still
only requires a JSP 1.1 capable server.

Eliminates completely the need for "scriplets"
in JSP pages reducing code complexity and improving readability and
maintainability. Leverage knowledge and use of the JSTL standard.

Simplified Layout Handling

High-level
layout managers offer an easier and cleaner alternative to the conventional
HTML table-based layout construction. Special handling of form fields
provides automatic positioning and alignment of form fields labels.

True rapid application development environment
with tremendous increase in productivity, easy of use and deployment.

Shared Source License

Our shared source
licensing model gives full access to all source code with permissions for
modifications.

The shared source model provides enhanced security, independence and reduced
risk of ownership.
Having source code means full independence for software corrections so
you don't have to wait for a next release. It also means that should any
question marks regarding the documentation or how the library actually works
arise, they also can be resolved in an independent way.