Bambookit GUI White Papers

Today, the Web provides an infrastructure that enables centralized application management and universal delivery of applications via HTML and standard browsers. This model lowers development, deployment and maintenance costs, and eliminates the need to install the software on multiple desktops and devices. However, HTML is not a good substitute for Client/Server technologies. There are fundamental flaws in the HTML approach:

User interface limitations:
HTML was designed for publishing documents. It lacks the rich user interface functionality that client/server applications possess.

Poor performance:
The "click-wait-refresh" model associated with HTML requires a new page to travel from the server to the browser upon every user click. This refresh process can take precious seconds, and often minutes and significantly frustrates end user productivity. In addition, this approach also weighs heavily on the network infrastructure, with each page occupying a footprint of kilobytes - most of which is redundant

Flawed network communications model:
The Web communication model is based on a "request/response" model, which does not support two-way, real-time communications. For many enterprise applications, real-time, two-way communications are needed to meet business unit requirements.

In order to effectively solve these problems that impact an enterprise's effectiveness and profitability so profoundly, a new and comprehensive approach is required. The new approach has to meet the following requirements:

Rich user experience:
For a new approach to have value for end-users, it must deliver an end user experience that is similar to Client/Server applications. Included in these requirements are a rich GUI, responsive performance and rich functionality.

Lightweight and universally accessible:
It must be lightweight in size and operation, and accessible from any desktop and device environment, and on any network.

Centrally managed:
It must allow applications to be centrally managed, with application changes reflected instantly across the enterprise - without requiring desktop support personnel to touch each and every desktop.

Device agnostic:
It must be change-ready and easily adapted - in a cost-effective manner - for use with new client devices, such as PDAs, tablets and even cell phones.

The idea is simply to remove the page-based structure of the Web, and replace it with something more dynamic and interactive that has the look, feel and capabilities of a desktop environment. When the Web was conceived by Tim Berners-Lee back in 1993, it was seen as a way of presenting text and image-based information in an easy-to-use format. The Web was not designed for e-commerce applications or business-to-business exchanges. In order to get benefits of the Internet, the companies are forced to trade off the richness of the application. What Bambookit is trying to accomplish is to provide the richness of a traditional desktop application, but delivered over an Internet or Intranet environment with all its inherent benefits.

Bambookit platform have been designed to transform an inefficient multi-page environment into a dynamic, single page interactive experience. Bambookit gives Web applications rich functionality and high performance similar to locally installed software, over any network connection, from any device, while significantly lowering development, deployment and maintenance costs. Bambookit is designed to be usable by anyone, irrespective of computer system, browser, or applications software and is aimed at the large Internet community.

Bambookit GUI Platform

Bambookit framework is in essence a simple, secure, thin, robust and interactive solution for creating the next generation of the real-time x-Internet applications. Bambookit provides a software platform that gives web applications the power and performance of desktop applications.

This is an ultra lightweight user interface framework, utilizing its own paint and event threads, itís own layout manager, itís XML scriptable, utilizing extremely few system resources, and is a cross platform and secure solution. It is compatible with personal java thus able to run on a web pads, wireless applications as well as well desktop environments in a truly write once and run anywhere solution.

XML scriptable GUI (Graphical User Interface)

User interfaces (UIs) are the most visible and, consequently, the most frequently changed part of any application. Tracking these changes makes client GUI development one of the most labor-intensive parts of system development and maintenance. This is compounded by the industry trend toward personalization, which drastically increases the complexity of GUI development as users may require different views based on preferences or role.

XML is a new player in the GUI technology. It is easy to write, easy to change, and it is perfectly suited to the changing nature of GUI development. Also, because XML is crossover technology, it has a huge potential user-base. GUI is highly visible output, and it is usually tie to a particular technology that it is based on. That is why it is usually very difficult to unbundling the GUI from the product infrastructure.

Bambookit will render XML data into an open graphical user interface (GUI) environment. The applet is loaded a standard-based XML schema, which allows for the complete customization of web applications. Your application would be scripted in an XML script generating greater interoperability across various architectures already deployed in the marketplace.

Bambookit controls are completely scriptable via the XML tags. The controls are created real-time from the XML scripts. The XML scripts can be decomposed into smaller sections to create a complete application. So when a web application loads (created from Bambookit elements), it is assembled from many XML subscripts. They are loaded only when required and the average sizes of these scripts are ONLY 5k. The view is created in real time, so as each control is read from the an XML script it appears in the view. The view remains disabled until the complete XML script is loaded to prevent accidental data corruption.


Your application would be scripted in XML generating greater interoperability across various architectures already deployed in the marketplace. Any middleware product adhering to Bambookit's XML syntax can enable real-time processing on their website. Bambookit functions along with the companyís existing web infrastructure to offer dynamic web. Bambookit is XML scriptable thus allowing for an interoperable solution to many existing architectures (.Net or J2EE). It allows to load multi-screen views via a dynamically generated XML User Interface. These views can be generated by a wide range of middle ware products including JSP, ASP, PHP or CGI-BIN files that in turn access Databases, Web Services or other data sources to generate a view (a view can be of any granular size desired, gone are the days of full page refreshes in order to update a single cell). This is also an order of magnitude smaller than past static html page displays, at least a ten fold size reduction.
See Architecture

Unlike typical browser-based applications that require multiple round-trips between Web server and client PCís or devices to render screens, Bambookit GUI uses the devices local processing power to execute code within a single screen and without multiple client downloads or weighty proprietary plug-in. By replacing the user interface portions of JSP, ASP or PHP code with XML, Bambookit applications can achieve a desktop-like performance over even thin network connections and speeds. Bambookit GUI works with existing infrastructures and will lower operations costs associated with developing and managing Web-based applications.


It is an ultra lightweight package of Bamboo's java-based library that occupies only 100Kb. It contains the previously mentioned lightweight controls, an XML parser, an object enabler, event handling routines, and its own paint and event handling threads. Bambookit GUI runs from on any java-enabled device.


Bambookit GUI applications java's sandbox security model. The application has no access to the users resources printers or other potentially sensitive and personal documents. In this day and age of ever increasing security threats, viruses, trojan horses and unauthorized attempts at accessing client resources the arguments for a secure system and the peace of mind that provides is stronger then ever. This feature cannot be stressed enough in its importance when building enterprise wide or even Internet wide applications. Since it is Java enabled all deployment issues are handled by the web without having an IT staff install software across thousands of client machines, a single server holding a single jar file of 100k suffices.

SSL enabled

Bambookit's communication is only HTTP driven (Also known as HTTP-tunneling or HTTP piggybacking). A large portion of the world is trapped behind a corporate proxy or firewall. For those people, HTTP is All there is. By being HTTP driven, Bambookit is then guaranteed to work in those environments. By piggybacking on the HTTP connection, we are automatically SSL enabled. All that is required is to place the web page containing the Bambookit GUI onto an SSL server. No further changes will be required.

Cross platform

Bambookit sits in top of Java 1.1, currently available on all major Operating Systems, allowing users to create secure and interactive applications in a cross platform environment. Bambookit is based on the Personal Java specification which is equivalent to Java 1.1. Java has already established a strong market presence across multiple platforms All major browsers universally support it. Java is a secure means of enabling the next generation of web applications (coined the X-Internet by Forrester Research). Although Bambookit is based on personal java, it was built to be compatible with the latest java versions including java 1.3 and java 1.4, thus allow running Bambookit applications on any java-enabled browser.

Bambookit applications was tested on the browsers Netscape 4.06+, IE 4.0+, tested with Personal Java, tested on various OS platforms, Windows 98, Windows 2000, Windows NT 4.0, Windows XP, Mac OS 9, Mac OS 10.1, Linux Redhat v8.0, and tested with various Java VM versions. Java VM from Microsoft version 1.1, from Sun version 1.1.7, 1.2, 1.3.1, 1.3.1_06, 1.4.

No downloads

No downloads, plug-ins or client side installations are required to view Internet applications built with Bambookit. Since it sits on top of Java 1.1, no java plug-ins required to view Bambookit applications. Bambookit GUI loads dynamically within standard browsers by simply typing a URL address. With Bambookit, administrators can run applications from a central server and make adjustments without having to touch every desktop or device. What the end-user receives has the same level of interactivity and flexibility as a downloaded or installed product.


It is a lightweight package of 100k library that contains the full widgets set, an XML parser and an object enabler. As measured to AWT, the Bambookit controls take up less system resources, a smaller memory footprint and are faster to execute.
It's Ability to subdivide your application into multiple XML based file fragments for quicker downloads and increased component reusability. Each XML file can be loaded into separate views within the same application. No longer would the client have to wait for a 50k scripted application to download all at once, the main page can take up as little as 1k in size and be viewed instantly while other views can be loaded later as needed.

Easy to use

Easy to develop. XML-based environment enables existing web developers to quickly build Bambookit applications. PHP/JSP/ASP developers can start using Bambookit GUI immidiatelly by replacing user interface portions of their files with Bambookit GUI XML scripts. No compilation required. Run your xml files directly in web browser by calling them from your web page. Do small changes and run it in browser again. You can run your Bambookit applications on any environment, it starts up quickly, executes quickly and reacts responsively to user interaction. In case of error consult your Java Console or run XML file in browser to see the line and positions of the error. Bambookit user interfaces are simpler to build than HTML, cost less to maintain, and offer enhanced usability features.

Easy to deploy and maintain. It is an ultra thin client that easy to deploy from a central server and easy to upgrade and maintain. No client-side installations are required. Applications are loaded simply by typing in a URL address. The applications are managed centrally, which allows them to reflect all needed changes from the single entry point without the need to reinstall on every desktop.

Bambookit GUI application will save you in bandwidth costs (Up to 90 percent less bandwidth usage). It transfers only the amount of XML needed to update the page, minimizing network bandwidth requirements. Bambookit eliminate the "click-wait-refresh" model associated with HTML that requires a new page to travel from the server to the browser upon every user click. It weighs heavy on the network infrastructure, with each page occupying a footprint of kilobytes - most of which is redundant.

Interface to Web Services

Bambookit can provide the much-needed XML-based user interface layer for web services making them usable and more functional. Bambookit can solve one of the challenges in delivering Web Services by greatly simplifying interface development and easy integration RSS, XML-RPC, SOAP and middleware scripts (JSP, ASP, PHP, and CGI).


Bambookit is based on Java applet technology. Java applets are self-contained programs written in Java that can be placed on a web page just like a graphic. Java is an object-oriented programming language developed by Sun Microsystems. It should be noticed that it is not related to JavaScript, which is a scripting language developed by Netscape Navigator to run within an HTML document in a browser. Because Java is a full programming language, it can be used to create the whole applications, for example, in form of java applet, a self-contained mini-executable program. This program, named with .class suffix, can be placed right on the web page.

Java applet also requires the library, a jar file, which Bambookit has exclusively produced. Bambookit jar file incorporates the result of a few years of effort rewriting java classes from ground-up to provide a lightweight (an ultra lightweight package of 85k library that contains the previously mentioned lightweight controls, an XML parser and an object enabler) framework for building real-time, interactive Internet applications that brings desktop functionality into browser windows.

Bambookit applet based on Bambookit jar file will load the XML file in which the XML GUI is stored. The XML file possess the ability to call other XML files in which XML GUI for other screen views are stored. XML commands can be included in PHP, ASP, or JSP scripts to dynamically set data. Bambookit able to integrate to any middleware infrastructure (.NET, J2EE, Cold Fusion, PHP, etc...) that provides the output in XML that the Bambookit GUI understands.

Bambookit GUI is based on Personal Java, which is compatible with java 1.1, java 1.2, java 1.3, and java 1.4.

Anyone, on any platform, with any version of any operating system can run the application immedeately, without installing anything. The Bambookit GUI allows you to create applications that are accessible from browsers, desktops, and via any web enabled device.

System Resources

Java has a fundamental flaw in its paint thread that made it very difficult to build extremely large applications without getting severe performance and resource penalties (This affects both AWT and Swing based applications). Itís main repaint queue\thread when assigning paint regions to various controls uses the Graphics objects to Ďclipí them. On a Sun Solaris machine this does not cause any problems, however on a windows machine each Graphics object consumes a system resource/handle, (a limit of around 16,000 exists on Win 95 and Win 98 machines). Each Bitmap image, each font object, each icon consumes a single system resource or handle. If a full repaint is performed on an application containing 1000 controls, it would consume at LEAST 1000 system resource handles. If the application was updated many times a second, lets say 10 times a second, then that equates to 10,000 handles a second. This is not taking into account labels within controls, the various fonts styles and sizes created, the various images that get loaded. This could easily exceed 20,000 system resource requests a second. Bambookit on the other hand utilizes the clip routines and passes along a SINGLE Graphics objects to all its various controls. This alone is a HUGE savings in system resources and performance.

Bambookit GUI Features

Bambookit User Interface offers application functionality with a full widget set that includes drag & drop, real-time data display, scrolling, moving between windows, dynamic table sorting with resizable columns, containerís resize, an intuitive Layout Manager, customized colors, rollovers, highlights, popup menus, tree, and more. A consistent desktop-like user interface for all applications is maintained, no matter their underlying architecture.

Bambookit provides a rich graphical user interface (GUI), which consists of the following controls and functions:
Widget   Button   Checkbox   Radio   Combobox   Calendar   Menu   Listbox   Splitter   Tabs   Table   Edit   Tree   Collapsible Panel Bar   Windows   Gradient Color Fill   Color Picker   Layout   Drag-and-Drop   Zooming Box   Popups   Real Time Data Display  

Real-Time Communication

Bambookit real-time communication currently is based on the polling mechanism. Each widget can individually be set to retrieve updates at set intervals. The XML file UPDATES the existing XML, no NEW XML elements are added. The 'named' widgets are matched and the attributes are updated. Thus the amount of data that gets transferred is kept to a minimum.

In the next releases we will be providing a live connection. There is a good reason why we have built a real-time polling first. We wanted our clients to have a choice between poll mechanism or a live connection for the following reasons. A live HTTP connection between the client and the server is accomplished by requesting a file from the middleware. Like query.php, this 'file' is an Observer that gets notified of changes to the data set, if any changes occurs all 'open connections' gets updated with an XML file (closing the connection). The client would immediately reopen the connection requesting the same file, keeping it open until the next live update. Also every time the HTTP connection times out the client immediately re-establishes the connection.

There is one MAJOR problem with this type of live connectivity. There is a limit to the number of simultaneous HTTP connections that can be made from the client machine. Usually they are limited to 2 or 3 live connections at a time (you can test this by trying to download an 'x' number of large files). Once these connections are 'taken' all other HTTP communications are queued until a connection is made available. So if more than ONE live connection is made, the application will appear to 'hang' on other remaining web operations. Although we will be adding a live connection in the future releases, HOWEVER, this comes with a warning. Do NOT make more than ONE live connection across all running applications for that client session. Otherwise the application's responsiveness will be severely downgraded.


A user can start dragging by holding down the mouse button and moving the mouse. The drag stops when the user releases the mouse. Bambookit's event handler is called when the user ends dragging. There are three types of drag-and -drop in Bambookit:
  • Data, or widget's content or attributes are dropped to a Drop target.
  • Widget is copied to a Drop target.
  • Widget is moved to a Drop target.
    Any Bambookit Widget can be set to accept a Dragable object.

    Image Preload

    Ability to preload images during run time on a separate thread, keeping your XML files small, and allowing for crisp animation and rollover effects. It would seamlessly switch images for smooth and snappy transitions creating a much better experience for the end user.

    'dot crop' Feature

    Visual cues to an applications behavior leaves subtle signals to its implied robustness, an example: Text in all controls are usually cropped by their contained widgets is they exceed their allotted size, however in our suite they are instead replaced with trailing dots which is used as a suitable metaphor for overextended text. That way the view in the Edit, Buttons and other controls will always look professional at all times without ever having to contend with overlapping elements paint over one another. A common lament among programmers was how text views could suddenly appear cropped and ill placed when switching between languages, font styles or point sizes. Without this behavior, the application lacked a sense elegance and robustness that pervaded into the end user experience of the application. Now however, all this work is done behind the scenes, freeing the programmer of the more mundane tasks of redoing layouts.


    Bambookit adheres to the principle of feedback through visual cues on any control that can manipulate the user interface environment. All controls that can be acted upon would highlight on a mouse rollover, mouse click and mouse release. If a control is keyboard traversable then it also visually indicate this fact by displaying a focus rect around the control.

    Layout Manager

    Most user interface engines either have cumbersome layout managers or are non-existent as is the case with Visual Basic. One of the driving principles behind Bambookit is a simple solution that lends itself to solving complex problems. Here is an intuitive Layout Manager that implements the concept of anchors applied to all controls. A control has 4 anchors, left, top, right and bottom. If a control is Ďanchoredí on all 4 sides then when its parent is resized so is the child control resized accordingly. Dynamically resize your applications with an intuitive internal layout manager handled using the simple concept of anchors. Example: by attaching anchors on the left and right sides of the control, they would grow and shrink whenever the objects expand and contract. It is that simple. No longer would you have to write lines and lines of layout functionality, (in some cases it accounts for as much as 25% of all the lines of code written, leading to buggy systems and inconsistent layouts) but directly place them where you want your widgets and controls to be viewed and anchor them to control HOW they behave whenever the windows they reside in get resized. Read more in the Layout Conundrum in Bambookit Blueprints

    The autolayout system is used to simplify the addition of multiple controls without the need to specify each items location and size. It is most commonly used in the Listbox control when adding children. There are 3 main types of layouts, iconic view, list view and fill view.

    Attach to Widget is the most useful layout when creating prebuilt controls at the XML level like the Collapsible Panel Bars. Whenever the top panel is collapsed all the panels attached below should move up the same displacement as of the resized control.

    Attach To Container is the most useful layout when creating prebuilt controls at the XML level like the Table control to create a chained link of columns (Listboxes).

    Advanced Tree Control Functionality

    Advanced tree control functionality. Its flexibility rivals the best of the breed in its adaptability and speed. It is a natural metaphor for navigation and information access but what really sets it apart is the ability to embed any bamboo widget into the leaf of a tree. Akin to some of Microsoft's more powerful tree installer controls you would be able to place checkboxes and radio controls in its leaf elements, however this control is much more powerful than simply embedding one single class of controls. You have ability to add containers as well as controls; this would include embedding tabs, trees and panels.
    See Vision
  • [Home]