This Getting Started Guide provides an overview of TIBCO General Interface 3.1 Framework and Builder. Chapters include: Introduction, Installation, TIBCO General Interface Basics, Creating an Application, Communicating with Data Services, Deploying Applications, Adding Custom Code.

Release Notes for TIBCO General Interface 3.1

Release Notes for TIBCO General Interface 3.1.1

These streaming video tutorials focus on the many visual authoring utilities in TIBCO General Interface that make creating powerful web applications faster and easier. View any topic, or do them in order to create and deploy a simple application.

The attached WebEx recording will walk you through how to use the XML Mapping Utilityr, new in GI 3.1.0, to create a Common Transfer Format (CXF) mapping rule to transform arbitrary XML into the Common Data Format (CDF) which is used by all GI GUI elements for rendering information.

The specific example is to take an XML document and render it into a GI List control.

This sample application demonstrates a number of ways to create and instantiate dialogs.

This sample application demonstrates drag and drop between GUI components in two scenarios: Move and Copy.

This sample application demonstrates "Drag and Drop from a Tree" and "Dynamically add a CDF s to a tree."

This sample application shows how to connect to a simple SOAP service for address validation, along with mapping between the GUI and the request and response messages. Enter a zip code in the text box and click the button.

This sample application demonstrates the two-step process for rendering repeating structures: 1) mapping repeating structures from WSDL to CDF; and 2) associating CDF documents and attributes with GUI components.

This sample application expands on WSDL 2 sample to demonstrate the means to specify SOAP message inputs with code.

This sample application shows several different approaches to add and remove rows from the Model (CDF Document) and the View (jsx3.gui.Grid).

This example demonstrates the conversion of an arbitrary XML document into a GI CDF document in cache. This example also demonstrates spyglass behavior in a List.

This example demonstrates master-detail drill down in a List.The CDF document (source_list.xml) data loaded into master list. 2x-click on a master list row opens the applicant details dialog. Many detail dialogs can be opened as cascade to compare the data.

This sample application demonstrates how to page data from a server process into a GI data control, in this case a jsx3.gui.List. The browser is very efficient at managing large XML documents, N > 25,000 records, and less efficient at painting huge amounts of HTML, for example a list with N > 500 rows.

This example shows how the publish/subscribe mechanism for EventDispatcher can be used for asynchronous messaging.

This sample application demonstrates how to change grid cell colors at run time using a XSL. Also shows how to update Grid's view and corresponding CDF data dynamically.

This sample application expands on Dynamic Cell Colors 1 to demonstrate the means to binds an XSL document (as string) as a property on the object, so that when the object is serialized the XSL is contained within. When this object is live, the XSL will be parsed and used to generate the on-screen VIEW for the object.

This application shows how to POST data to a server (file upload in particular) using the class, jsx3.net.Form. There is also a simple validation example which shows how to perform client-side validations, triggered as soon as the user tries to leave the textbox. This sample app needs to be deployed to a JSP server to actually work.

This sample application demonstrates best practices for adding and repainting complex applications. The rendering of HTML onscreen is often the slowest aspect of browser-based applications. Ensuring efficient repaints will make your applications snappier and more responsive to user input.

This sample application demonstrates the use of jsx3.net.Request to acquire legacy HTML and store in a local hash for later display within a GI GUI control. Pre-caching of a PDF document in the browser's own cache is also shown.

This application demonstrates how to generate printable pages from GI applications with large information in scrollable lists.

This sample application demonstrates drag and drop between GUI components in two scenarios: Move and Copy. It is important to keep in mind that, although the user interacts with the View, the real activity is in the Model. Dragging grid rows is a visual metaphor for moving s in CDF documents.

This sample application provides two simple application canvases. Follow these examples to understand how to use the Layout Grid components, and design applications that gently resize for different browsers and environments.

This sample application demonstrates a simple means to add and remove a column from a List or Grid. A column prototype was created and saved to the components directory. When the checkbox is toggled, this column is efficiently loaded or unloaded as the last child of the application, without painting the entire list. This same technique would work for many columns, each added as the rightmost column in the list.

This sample application demonstrates the use of GI Dynamic Property (.jss) files for localization. This is accomplished by loading a new .jss resource file into the GI cache. The GUI components specify certain properties, like the Text/HTML property of the stack object, as Dynamic Properties.

This sample application demonstrates how to embed a simple Java GUI applet in a GI jsx3.gui.Block object. The same basic techniques will work for Flash and other plug-ins.

This sample application demonstrates three different means to split a single CDF document into 2 CDF documents in the GI cache, based on the value of an attribute in the original document.

This sample application demonstrates how to instantiate two GI application instances in a single HTML page, and communicate between them.

This sample application demonstrates the manipulation of data in a CDF document.

This sample project demonstrates the use of new Mapper Tool to load RSS feeds.

This sample application integrates GI with Google Maps. It allows the user to instance multiple GI dialogs, each containing it's own map.

This sample application shows how to enable a right-click context menu to copy a jsx3.gui.

This sample application demonstrates different ways to launch a dialog from a list or a grid.

This sample application demonstrates how to search for a text in a CDF document and to highlight the matched record. This method can be used for any jsx3.gui component that has a CDF Record as input like list or grid.

This sample application demonstrates how the Repeat When field of the XML Mapping Utility can be used to apply a branch of the rules tree multiple times in a non-CDF mappings situation.

This sample application demonstrates how to represent large CDF/XML data as GI Tree component. Instead of loading the large data from server during startup, the children of a node are loaded "expanded" on demand on user click event on that node.

General Interface provides an advanced logging system, defined in the jsx3.util.Logger class. The logging system is designed to be an integral part of the development process. It can be used both in General Interface Builder and in a running application to trace activity and diagnose errors. Logging messages can be sent to a variety of locations – on screen or to memory with built-in functionality, or conceivably to a web service or local file with custom logging handlers. Which messages are displayed and where can be configured declaratively in an XML file without modifying source code.

This document describes how to assign keyboard shortcuts to button and menu components in TIBCO General Interface 3.1 applications. Keyboard shortcuts allow end users to interact with these components in applications without using a mouse.

This document describes TIBCO General Interface extensions to the JavaScript class and inheritance model. With these extensions TIBCO General Interface provides a richer programming environment that is better suited to building complex object-oriented applications.

This document describes features and benefits of the Common Data Format (CDF). The CDF is an XML schema that provides an abstraction layer for client data. It allows components of an application to use a single data format. Benefits include the ability to share data among components, reliably transfer data between client controls using drag and drop, and perform data mapping. Component data can be inserted or updated without using XSLT. The jsx3.xml.CDF interface also defines common set of methods for manipulating data.

This document describes the Common Exchange Format (CXF). The CXF is an interface definition schema that describes how to interact with XML data within General Interface. By using CXF, General Interface is able to connect to disparate systems and services without being tied to a specific exchange format. At runtime, the CXF is used by the class jsx3.net.Service to perform the actual interactions.

This document describes how to create, customize, and reuse GUI components in TIBCO General Interface Builder. The use of custom components offers many advantages in application development — component reusability, consistency of look and feel across applications, faster development time, and reduction in repetitive, time-consuming component development.

After you’ve created customized components, you can add them to your user component library and access them from any project, as well as share them with the development team.

This document describes TIBCO General Interface extensions to JavaScript exception handling and how to leverage these extensions to write code that is more robust and easier to maintain.

This document describes how to send, receive and cache data. TIBCO General Interface provides an in-memory XML Cache where developers can store XML/XSL documents needed by the application. Some documents in the Cache are placed there automatically by the system. The developer also has the option to set their own documents in the Cache. Having a centralized cache provides easier object cleanup as well as a standardized method for sharing data across multiple components. The XML Cache is a critical aspect of a stateful rich client experience when used in conjunction with asynchronous data access.

When you deploy a General Interface application to an Microsoft IIS6 Server you may find the General Interface application does not initialize correctly when a client loads the application. This issue is caused by IIS not handling the .jss file extension correctly. This can be resolved by adding a new Mime Type for the “.jss” file extension.

This document provides an overview of using the TIBCO General Interface JavaScript Debugger and details on other debugging services in TIBCO General Interface Builder, including:

- Using the debugger to step though code

- Setting breakpoints in JavaScript code

- Inspecting variables and values during debugging

- Formatting code appropriate to the debugger

This document describes how to migrate General Interface 3.0 applications to version 3.1

Every effort has been made to provide backward compatibility from General Interface 3.1 to 3.0. In most cases, applications will work with no changes.

This document contains a complete list of tasks necessary for migrating a 3.0 application to 3.1. This document does not describe features and APIs from 3.0 that have been deprecated in 3.1 but are nonetheless completely backward compatible.

This document describes model events in General Interface 3.1, the changes to model events between versions 3.0 and 3.1, and how to upgrade project code written for the 3.0 model event protocol to the 3.1 model event protocol.

This document describes how to design TIBCO General Interface applications so that they work properly in multi-application environments, such as a portal deployment.