Terms used and their definitions
One must understand the terms: Presentation-template or (or online GUI-API class or GUI-Component Code Generator or “CCG”), CF (or Component Factory) and ‘Application Component’ to understand the CBSF’ and other documents. The objective of this document is to briefly define the terms with simple examples. Please notice the subtle differences between these terms.
Online-GUI-API or Presentation-templates: A library of Java Classes for various presentation-components (Ex: charts, and menus etc.) and presentation-concepts (Ex: rotate-components and shopping-cart etc.). For example, online-GUI-API class for pie chart is a Java-class, which could generate SVG/Jscript code to present a pie chart. To use a GUI-class, the developers may just instantiate the CCG Class-object and supply the rum-time data, using class-methods, to the object. Now, the Java-Object could generate the browser specific code (Ex: SVG, XHTML, DOM and Jscript etc.) to present the application-component, using the data supplied to it at run-time.
For Example, the following sample code demonstrates a method to use the online-GUI-Class for the pie-chart component to generate SVG-code to present the pie chart:
 

Pseudo-code listing#1

// The Data variables; which could be initialized at run-time.
// (i.e. this data may be calculated at run-time, from the user data obtained from databases)

Double        val[] = { 10000, 12000, 14000, 16000, 18000};
String          names[] = {“Sun”, “Microsoft”, “IBM”, “Intel”, “Oracle”};

//Example For Presentation Template:: ATPie is a Java Class that contains presentation logic to
//present the pie-chart. Sample code below, illustrates how to use the GUI-class for pie chart.
ATPie      Pie1 = new ATPie(“ Portfolio at the end of 2dn Quarter”); // Set Title.
             Pie1.setData(5, val, names); // Use Pie-class method to set Data.
             Pie1.buildWC( ati, out); // This method writes SVG-code for the AC to the ‘out’ stream.

Where: ‘ati’ is an Object; which may contain information about the requesting User (Ex: preferences, privileges or authentication etc.) and Browser (type and version etc.). The ‘ati’ is a simple and very useful object. This Object will be passed to all sub-components (or sub-CF); hence the information in it is available to all the ‘component code generators’ (Ex: CF and online GUI-Objects etc.). Please refer to Agile-Templates documentation, If you wish to learn more about the default-contents, functionality, how to retrieve and save information in the Object etc.
‘Component Factory (CF)’ & ‘Application Component (AC)’: The CF is a ‘Java-Class’ build by application developers using simple CBSDF framework. For Example, the following ‘PortifolioCF’ Java-Class code is a simple example of a CF, which creates pie chart of requesting-user portfolio:
Pseudo-code listing#2
public class PortfolioCF extends AgileTemplates {
// The Data variables; which could be initialized at run-time.
           Float     val[];
           String   names[];
           int   count = 0, account_number = 0;

           void buildWC (ATInfo ati, PrintWriter out) {
                 InitPortifolioData(ati); // This function initializes val[] & names[]

                  //Sample code; which illustrates how to use Agile-Templates for Pie-chart.
                  
ATPie Pie1 = New ATPie(“ Portfolio at the end of 2nd Quarter”);
                  
Pie1.setData(count, val, names); // Use Pie-class method to set Data.
          
        Pie1.buildWC( ati, out); // This may write SVG-code to the ‘out’ stream.
         
}

         // Constructor that initializes the user account jumber
         
PortfolioCF (int number) { account_number = number;}

         void InitPortifolioData(ATInfo ati) {
                  // Write code to access data for the user using the “account_number”
                  // and init the following Class-variables:
                  // vals[] is an array of net-value of each company in his portifolio.
                  // names[] is an array of company names in his portifolio.
                  // Note: The ATInfo contatins references to session-object,
                  // user-preferences, identity and database-connection etc.
                  // The “ati” may contain user preferences & DB-Connection objects etc.
        }
}

  // The CF encapsulates and hides both application-logic and presentation-logic,
 // and usually needs no more than one line initialization. For example:
  PortfolioCF user_portifolio = New PortfolioCF (user_account_number); // Create & init
                   user_portifolio.buildWC(Ati, out); // Generate code for the AC
Notice, the minimum requirements for the Java-Class for ‘Component Factory’ (or CF) are: extend the ‘Agile-Templates-class’ and implement the abstract Class-method ‘buildWC(ATInfo ati, PrintWriter out)’. The CF reads required data from data-sources and may access user identity/preferences from session-object. It generates the code (Ex: SVG, XHTML, DOM and Jscript etc.) to present the ‘application-component’. This ‘code’ that renders the component in the viewer/browser. The CF generates code for the ‘application-component’
The design objective of the CF is to be highly cohesive Java-class, and able to create custom ‘Application Component’ at run-time as per each requesting client’s identity and/or preferences etc. The application developers may partition each web page (or application) into multiple ACs and design and develop CFs to generate code for the ACs. We will show later that the ACs created this way: offer excellent plug-and-play flexibility, and could be independently refined to easily accommodate evolving functional needs of the users. The CFs could be used with out any custom integration code, as assembling parts, to generate larger components/CFs or web pages.
Code for the Application Component: is a block of code to present a component in the web page. Usually the CF generates the code for the AC. However, also all the online-GUI-classes could generate the code for the application components, if the developer instantiates an object and properly initializes (.e.g. please see the code listing#1). The code for the AC contains instruction of various presentation markup languages (XHTML, SVG X3D, SMIL, CSS and DOM etc.), script-functions (Ex: Jscript, VBscript etc.) and variable-declarations to present the component.
It is critical to understand the basic differences between the characteristics of these two components: CF and AC. The CF is a Java class runs on the web-server, which generates code-block for the AC. The code block is component-presentation code (Ex: XML, SVG, DOM and Jscript etc.) runs in the browser/viewer; which contains SVG-elements to displays the component and contains DOM/Jscript methods to handle user interactions and animation etc.
For example, if the above pie-chart (Figure#1) is presented on the web page using SVG. The code-block for the AC is nothing but the SVG/DOM/Jscript code created by the PortfolioCF Java-class. This code contains SVG-instructions to render the PIE-chart and DOM/Jscript functions to provide interactive feature like pop-up tool-tips etc. The ‘code-block’ for the AC is generated by ‘online-GUI-class’ for the pie chart, such that, it encapsulates presentation, animation and interactivity of the component in single contiguous block of code.
An examples for Component Factory: Example#1 and Example#2
Summary:
Application Component: An SVG/DOM/Jscript code that runs at client in a viewer/browser and presents a component (Ex: charts, maps, GUI-components like menus, selection-lists etc.). The code for the AC is generated at server and embedded in to an SVG-document. It contains SVG elements to display the component and DOM/Jscript code to handle user interaction etc.
Online-GUI-class: A reusable Java class that can be used by the application developers to generate code for an AC. Ex: Java classes for Pie chart, drop-down selection list etc. The application developer must provide all the data for the class-object, before the Object could generate the AC. He may use the Templates to develop CF or Servlet,/JSP-file. The GUI-class only encapsulates (or hides) presentation-logic and relies on the developer to supply all the data.
Component factory (or CF): An independent component (a Java class) developed by the application developer; and generates AC. The CF (a Java class) contains both application-logic to gather the data and business-intelligence to personalize the AC. The AC could be used as sub-components to develop Servlets/JSP-files; or plugged-in to build larger AC with little or no integration code. The CF encapsulates (or hides) both application-logic and presentation-logic. (You would learn in the future that, this ability to encapsulate or hide both the manufacturing process from the users of the AC, is the basis for the invention of the Ideal component paradigm.)
 
 
Miscellaneous Documents Privacy Policy | Site Map | Services
Designed By SINDHU SYNERGY
Copy Right © 2006 Pioneer Soft, LLC. All Rights Reserved.