|
|
|
| |
|
Proof that it is possible to build a viable online-GUI-API
|
|
|
Software
developers have been building graphics intensive Rich
Desktop Applications (or “RDA”) for more
than 2 and half decades on PCs and on UNIX Workstations.
Millions of developers know how to build 2D/3D RDA for
the traditional GUI platform, such as, Microsoft’s
Windows-OS, Apple’s Mac, UNIX/X11 or Java/Swing.
|
|
|
Experts
know that the technologies that enabled those millions
of developers to build the RDA are the GUI API-frameworks
supported by the respective platforms. There is no mystery
that the GUI API-framework essentially comprises of
two parts:
|
|
|
A base set of reusable GUI-Classes (e.g. Dropdown lists, Radio Buttons, Check Boxes, Menus and Buttons etc.)
|
|
A simple Process (see appendix below) to build custom reusable GUI classes, for the developers to build: (a). Custom application
specific components (e.g. Airplanes for Air Traffic
control or simulation applications or for war games, Wafer-maps/Bit-maps for the semiconductor applications
etc.) or (b). Specialized reusable components, such as,
charts, grids/spread-sheets, maps and trees by hundreds
of component vendors. |
|
|
The
GUI components must support only two capabilities to
use them to build online applications: (i). We must
be able to use them in component hierarchy (e.g. to
use them as subcomponents to build large components)
and (ii). We must be able to integrate the components,
so that, they could exchange data and collaborate with
other components in the applications and with remote
servers (e.g. for AJAX style real time updates). |
|
Can you prove that you that it is possible to build online-GUI-API? |
|
YES!
Proof By Induction: Lets
assume, we can create complex highly interactive online-GUI-Class,
for example, a pie-chat, which has many subcomponents,
which further has following characteristics: |
|
| |
It
can be used as a subcomponent, anywhere in a long chain
of component hierarchy. |
|
It
supports methods to integrate the pie chart with other
components in the application, for example, to exchange
data, notify events or to collaborate. |
|
If
we can create a pie-chart class, we can create GUI-classes
for line chart, bar chart, Dials and Meters etc. If
we can create Charts, we can create interactive characters,
such as, Airplanes and Cars, for example, to build online
simulations, multi-player online games or for the online GIS/GPS applications. Therefore,
we can create a GUI-class for just about any component
for any graphics applications. |
|
We
will demonstrate few large GUI components & component-hierarchies.
Later documents in this web site explain, how one could
build online GUI-Classes (also referred to as Raju’s
GUI-Classes). For example, few documents provide detailed
description for building reusable-GUI-Class for an Airplane
and using it to build a simple application. Please inspect
some sample components and component-hierarchy: |
|
|
|
|
Caution:
Please download Adobe's
SVG viewer to view the SVG to verify
the poof. Although, we have developed and tested the DHTML
components on both Netscape and Internet
Explorer 4+. They were only small sample of many test
components created in year 2000 to conclusively prove the GUI
Class can dynamically generate browser specific code. Since,
have no plans to build API for DTHML, I haven't put any effort
to port them to support newer browses such as Firefox.
|
|
|
Appendix:
A Brief Background for
the Traditional GUI Platforms
All the traditional GUI-platforms support a base set of prefabricated reusable GUI components such as Push-buttons, Radio-buttons, Pull-down lists, Menus, Scroll-bars,
Text and Check boxes. Also support container components such as Canvas and Drawing areas.
Usually they
(e.g. Windows or Swing GUI) first build a primitive Graphics library to draw primitives
elements such as lines, arcs, polygons, poly-lines and ellipses. Then they use
a process and the library to build the prefabricated reusable GUI classes for the components (e.g. Pull-down lists and Menus). Other GUI component vendors
could also use the same process and primitive Graphics library
to build certain reusable components such as Charts, Trees Dials and Scales.
Most GUI applications need custom reusable GUI Classes.
For example, an Air traffic control system needs a GUI Class, which can be used to instantiate multiple GUI Objects, where each Object presents an Airplane.
Likewise, a City-taxi operator could build an application that displays moving taxis on a vector based city map; or power-plant may build a GUI dashboard
containing many GUI components (e.g. Dials, Sensors, Meters and Scales) to control the
power plant. The developers of this kind of applications also
use the same process and primitive Graphics library
for building
custom reusable GUI Classes for the necessary GUI components.
However, online platforms
(e.g. HTML-Browsers, XAML/Flash players) have taken different approach. They support
very few components
(e.g. Drop-down list or Radio-buttons) as built-in GUI components. For example, such built-in components may be
included in the webpage by using respective HTML tags/instructions. In case of the HTML, there is no a primitive
Graphics library (e.g. tags) and has no known process for building any other reusable GUI
classes. In case of Vector Graphics, although primitive Graphics instructions/tags are available, no one else has invented or
even think that it is possible to invent a process for building custom reusable GUI classes, which are comparable or better than the reusable GUI classes for the desktop platforms.
Therefore Pioneer-soft invented a simple process
for building the reusable GUI Classes.
|
|
|
|
|
|
