TICL stands for Tag Interface Component
Library. It is a JSP tag library of WEB interface components. The product
was developed in 2001 after a disappointed with the predominant technologies
at the time (Struts et al.). A major goal of TICL is to bring RAD-like development to the WEB
platform. Programmers can concentrate on logical functionality and build JSP
pages by placing TICL components through tags and responding to user events. Every
component is self-contained and manages interaction with the end-user with little
or no assistance on the programmer's part. Visual appearance of components is
abstracted into a high-level styles framework.
TICL enjoyed a short success and was purchased by companies such as Oracle and
Goldman Sachs. It was reportedly used to teach high-school students about web
programming and in many academic projects.
A technology founded on similar architecture is JavaServer(tm) Faces, a standartized
web UI component framework that has gained a fair share of popularity. Our recent
experience with that technology has resulted in a serious disappointment as well, so we've
decided to keep TICL around and perhaps revive it if there is interest.
What you will find in TICL
Here is an overview of what TICL has to offer:
||A powerful, flexible and extensible server-side event model.|
The server-side event model in TICL encompasses what in mainstream, MVC-based JSP programming
is referred to as the controller logic. Each HTTP request is transformed into
a sequence of server-side events representing user actions, which are then
processed by programmer defined event listeners. Even the predefined behaviour
of all TICL components is implemented through default event listeners of standard
TICL events. The event model is architected similarly to the Java Beans event
model. However, due to the paradigm differences between conventional desktop
application development and browser-based WEB development, several other abstractions
such as event factories, event brokers and event dispatchers have been added in
order to provide more flexibility in terms of design choices.
You can define event listeners for all TICL component related events. You can
control the event engine by inserting new events in the event queue during
processing and/or by cancelling the handling of current events. You can also define
your own event types and have them processed by the event engine, thus plugging
your business logic into the TICL event model.
||Tabbed pane, table view, tree view, panel, menu components and more...|
| ||details |
||Smart browser handling|
A complete framework for dealing with browser
(user agent) capabilities. You can define different user agents based on name,
vendor, platform and version. You can associate static or dynamic properties with
user agents (of boolean, integer or string types). Dynamic browser properties, such
as available plugins, screen resolution, connection speed, cookies, enabled
features in a particular browser etc., are detected also. The framework is fully
customizable allowing you to define your own properties, either statically in a
configuration file or dynamically by providing client-side code (VBScript or
of the HTTP user-agent header and thus handle browsers not known to TICL.
||A high-level styles framework for complete customization of the look&feel of components.|
Visual appearance of GUI elements in TICL is defined through a flexible styling
framework that lets you completely customize their HTML/DHTML rendering. To
each GUI element, there is an associated renderer Java interface that you can
implement to provide your own HTML generation. Renderers are parametrized by a
set of high-level structured parameters called the skin. A renderer and
a skin together make the style of a component. You can specify default
styles for components, or apply different styles to individual instances of
components. You can group styles into themes and apply them to whole
pages. Styles and skins can also be defined inline, within a JSP page, through
special purpose tags. Naturally, there is an API supporting all that and with
which you can work directly.
The framework allows for a clean separation between look&feel and functional
behaviour of GUI elements. No more copy&paste, no more code cluttering with
tedious, browser-specific HTML details - consistency of look&feel can be
easily achieved by maintaining a single TICL style sheet, a simple XML
file, that is applied to all pages in your WEB application.
You can define different styles for a component based on user agent
(browser). TICL will automatically select the approriate rendering based on the
current user agent thus allowing you to handle browser differences with 0 code in JSP pages.
||Full encapsulation of HTML forms, augmented with things such as server-side command handlers, labels and DHTML tooltips.|
HTML forms are the cornerstone of browser-based programming. In TICL, every
standard HTML form field is mapped to a server-side component and encapsulated
into a custom tag providing various extensions reflecting common WEB programming
practices. For instance, a label attribute lets you attach a label and
position it anywhere around the form field, and a tooltip attribute lets you
associate a classical tooltip to a field, appearing when the mouse goes over it.
As another example, you can associated a redirect URL with individual items of a
select dropdown control and server-side command handling functions (invoked
through Java reflection) with buttons and form submitting links.
In addition, since every form field is a TICL component, you can process
form submits by working with the TICL forms component API which provides a clean
conceptual layer on top of the plain text HTTP request parameters.
TICL comes with a file upload component taking care of all multipart
form processing and managing uploaded files for you.
Because form field are high-level components, you can create custom form
fields by composing the standard HTML form fields into meaningful, functional
units. An example of this is the DateTime TICL component that allows
an end-user to enter dates in a flexible manner (e.g. through several drop down
For complete code samples illustrating the form tags and API, please visit the
TICL examples page (select Examples from the TICL menu).
||A very powerful and incredibly easy to use declarative form validation mechanism (both client and server-side).|
Form validation is one of the cumbersome tasks related to WEB programming. As
with any other error checking and reporting, it is something programmers tend to
avoid and postpone until it becomes absolutely necessary.
TICL comes with
a form validation mechanism that allows you to concisely and easily
specify the conditions under which a given form field or a group of inter-dependent
fields is valid, all in purely declarative contextual way. A set of special
purpose tags lets you declare validation rules and instruct TICL to evaluate them
either at the server, once the form has been submitted, or at the browser before
the form is submitted, or even while the end-user is typing her input! The
validation rules are extremely general and flexible - they allow you to define
dependencies between form field values by specifying things like "apply this
validation rule when the value of that field is A and the value of that
other field is not empty", for example.
Error reporting is done in a similar fashion, namely by declaring rules triggered
by TICL when a given field or form becomes invalid or in general when a validation
error of a certain type occurs. A form is never processed, i.e. button command
handlers are not invoked and a form submit event is not generated, whenever there is
an invalid field in the form. All this allows to completely isolate form
validation from the form specification and from the form processing.
For examples and to see the validation mechanism in action, please go to the
TICL examples page (select Examples (from) the TICL menu).
||A Data Objects framework integrated with TICL forms|
The Data Objects framework and related tags allows you to work with arbitrary
data structures (e.g. Java Beans, SQL records, EJBs) in a transperant
manner in your JSP pages. The data object related tags let you manipulate
structured fields, both nested and indexed, by providing a clean scoping
mechanism as well as an extended syntax for accessing fields of arbitrary types
anywhere in a data structure.
Data Objects can be associated with TICL forms where data fields are automatically
mapped to/from form fields. This is similar to other frameworks with funcionality
that allows you to populate an HTML from a Java bean and then populate the bean
from the form submit values. However, TICL has several notable advantages:
- TICL comes with a customizable typing framework where form fields, being
typed server-side component, can be mapped to arbitrary Java types. Common type
conversions come predefined with TICL, but you can customize them and add new ones.
- Data Objects in TICL are based on a generic framework that can work not only
with Java beans, but with arbitrary structured data, as long as a few interfaces
- The association even goes as far as to allow you to link GUI commands (like
buttons, menu items and links) to data object (bean) methods!
A complete reference guide can be found from the downloads below. In addition,
the following are available:
The latest production release is TICL 1.1, as of Feb 2002. It is available
You can also get the source code from our Subversion repository at:
Use your favorite Subversion client to access it.