The web was
originally designed as a text-oriented distributed hypertext environment.
Providing rich interactive graphics on this platform is much in demand.
However, this demand has not yet been met with a satisfying, simple,
and unified solution.
Three approaches compete to provide rich interactive
graphics on the web:
Proprietary plug-ins and extensions
to the web protocols, such as Flash®
, Java™
applets,
and Silverlight™
.
Newer standards for web graphics, such
as the Canvas HTML tag.
Thin-client technologies, where the
web server generates the graphics and sends them as images. This is
the approach on which JViews web
technologies are based.
The main
drawback of the thin-client approach is the limited interactivity
it provides. Each time the user clicks or performs a graphical interaction,
a round trip to the web server has to be made to provide an updated
representation of the display. JViews introduces
the Hitmap technology to improve this situation.
In the context
of graphical thin-client web applications, Hitmap technology performs
fast hit testing on arbitrary graphic objects, thereby enabling the
application to associate application-related information to a point
or an area designated on the screen.
For example,
the following thin-client web application screen displays a user-editable
workflow network:
The image
in the center is a bitmap generated by the server and displaying some
network data. Without the Hitmap technology, clicking or hovering
over a node to highlight this node and display related information
requires sending to the server the coordinate of the point clicked,
having the server compute the object that corresponds to this point,
and returning a newly computed image representing the highlighted
object (in orange), as well as the application data associated to
this object (here, the phrase IlvSDMCompositeNode
).
This greatly reduces the interactivity and the responsiveness of the
thin-client solution.
What would
be preferable instead is a means to retrieve, inside the client web
browser, the semantic data associated to the object and the boundaries
of the object to highlight, and then to execute local scripts to perform
the highlighting and tooltip display, or any appropriate feedback,
locally.
The natural
(trivial) approach to implementing such graphics-to-application domain
mapping in graphical applications is to maintain a data structure
of graphic objects (polygons, text areas, rectangles, icons, and so
on) and to associate to each of those objects a pointer to application
domain objects. Hence, when the mouse is pointed at a region of the
application display, traversing this data structure allows the application
to retrieve the intersecting objects and from them to retrieve the
semantic data associated with them. While this approach is easy to
implement and use in regular graphical user interfaces, it suffers
some drawbacks in thin-client applications, which Hitmap technology
resolves.
With Hitmap
technology, the application defines a buffered and raster data structure
that allows the application to reduce the computation cost when doing
hit tests. The “color indices” in the associated bitmap
do not represent real colors to display, but instead indices in an
array of application data objects sent separately. Hence, this raster
map embeds both the geometry of the graphic representations and the
mapping to the related application objects. Because there are a limited
number of objects that are useful to represent on the screen, the
total number of “colors” used is very low and these
images are highly compressible and very fast to generate. Thus, you
can minimize the client-server bandwidth and extra server-side computation,
while providing precise geometric description and application object
mappings.
With Hitmap
technology, the hit test and also the highlighting can be performed
offline and do not cost a round-trip to the server. This gives JViews web applications excellent responsiveness and
has a number of useful applications.