Feature Benefits
Component Model

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.

Easy deployment and integration into your existing environment. Leverage existing tools and investments.

Usable in Java Servlets and through JSP tags

TICL can be used through a comprehensive and straightforward API from within Java servlets and/or through the tag library interfaces in JSP pages.

Provides the choice of using the appropriate technology depending on your current practices, requirements and developer skills.

Smart Component State Management
  • No server state is maintained for user sessions by default.
  • Information stored in the request/response flow is minimized by decoupling the components' interaction state from their transient, hard-coded properties
  • A custom serialization mechanism significantly reduces serialization response footprint.
  • 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.


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.

Reduces unnecessary markup code complexity and improves productivity through encapsulation and reuse of layout UI logic.

Struts Integration

An integration module for the popular Struts framework is provided.

Leverage your existing Struts-based architecture and Struts' application framework while still taking advantage of TICL's rich functionality.

Tool Support

WebFaces, our IDE plugin fully automates and simplifies many common TICL programming tasks.

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.