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.
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
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,
|Ready Made Components
- Standard forms and form fields.
- Pull-down menus.
- TableView (Grid) component.
- 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.
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
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
|Flexible Event Model
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.
TICL, the framework
and all predefined functionality, have been tested to work with all major
Uniform user experience regardless of her
environment and with no additional development overhead.
|User Agent Capabilities Management
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.
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
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
|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,
- A custom serialization mechanism significantly reduces serialization
- Rendering objects are pre-initalized and reused throughout
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
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
|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
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.
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
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
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.