DataWindow Programmers Guide
DataWindow and DataStore basics

There are two names to be aware of when you are working with a DataWindow:

The DataWindow control name

When you place a DataWindow control in a window or form, it gets a default name. You should change the name to be something meaningful for your application.

In PowerBuilder, the name of the control has traditionally had a prefix of dw_. This is a useful convention to observe in any development environment. For example, if the DataWindow control lists customers, you might want to name it dw_customer.

The DataWindow object name

To avoid confusion, you should use different prefixes for DataWindow objects and DataWindow controls. The prefix d_ is commonly used for DataWindow objects. For example, if the name of the DataWindow control is dw_customer, you might want to name the corresponding DataWindow object d_customer.

Specifying a DataWindow object

After placing the DataWindow control, you associate a DataWindow object with the control.

Changing the DataWindow object

In PowerBuilder, set the DataObject property to one of the DataWindow objects built into the application.

Setting the transaction object when you change the DataWindow object

When you change the DataWindow object during execution, you might need to call setTrans or setTransObject again.

For more information, see Setting the transaction object for the DataWindow control.

Dynamically creating a DataWindow object

You can also create a new DataWindow object during execution and associate it with a control.

For more information, see Dynamically Changing DataWindow Objects.

dw_emp.DataObject = "d_emp_hist"

dw_emp.DataObject = "d_emp_hist"
dw_emp.SetRedraw(FALSE)

There are two ways to handle database connections and transactions for the DataWindow control. You can use:

The two methods provide different levels of control over database transactions.

SQLCA.DBMS = ProfileString("myapp.ini", &
"database", "DBMS", " ")
... // Set more connection parameters
dw_employee.SetTrans(SQLCA)
dw_employee.Retrieve( )

// Set connection parameters in the transaction object
SQLCA.DBMS = ...
SQLCA.database = ...
CONNECT USING SQLCA;
dw_emp.SetTransObject(SQLCA)
dw_emp.Retrieve( )

transaction trans_customer
trans_customer = CREATE transaction
// Set connection parameters in the transaction object
trans_customer.DBMS = ...
trans_customer.database = ...
CONNECT USING trans_customer;
dw_customer.SetTransObject(trans_customer)
dw_customer.Retrieve( )

You call the following two methods to access a database through a DataWindow control:

dw_emp.Retrieve( )

SELECT Name, emp.sal FROM Employee 
WHERE emp.sal > :Salary

dw_emp.Retrieve( 50000 )

dw_emp.Update()

// Connect to the database specified in the
// transaction object EmpSQL
CONNECT USING EmpSQL;

// Set EmpSQL as the transaction object for dw_emp
dw_emp.SetTransObject(EmpSQL)

// Retrieve data from the database specified in
// EmpSQL into dw_emp
dw_emp.Retrieve( )

// Make changes to the data...
...

// Update the database
IF dw_emp.Update( ) > 0 THEN
      COMMIT USING EmpSQL;
ELSE   
      ROLLBACK USING EmpSQL;
END IF

// Disconnect from the database
DISCONNECT USING EmpSQL;

As users add or change data, the data is first handled as text in an edit control. If the data is accepted, it is then stored as an item in a buffer.

About the DataWindow buffers

A DataWindow uses three buffers to store data:

About the edit control

As the user moves around the DataWindow control, the DataWindow places an edit control over the current cell (row and column):

About text

The contents of the edit control are called text. Text is data that has not yet been accepted by the DataWindow control. Data entered in the edit control is not in a DataWindow buffer yet; it is simply text in the edit control.

About items

When the user changes the contents of the edit control and presses Enter or leaves the cell (by tabbing, using the mouse, or pressing up arrow or down arrow), the DataWindow processes the data and either accepts or rejects it, depending on whether it meets the requirements specified for the column. If the data is accepted, the text is moved to the current row and column in the DataWindow Primary buffer. The data in the Primary buffer for a particular column is referred to as an item.

Events for changing text and items

When data is changed in the edit control, several events occur.

How text is processed in the edit control

When the data in a column in a DataWindow has been changed and the column loses focus (for example, because the user tabs to the next column), the following sequence of events occurs:

Figure 2-2: How text is processed in edit controls

Action/return codes for events

You can affect the outcome of events by specifying numeric values in the event's program code. For example, step 3 above describes how you can force data to be rejected with a code of 1 in the ItemChanged event.

To specify action/return codes:

For information about codes for individual events, see DataWindow Reference.

Using methods

The following methods allow you to access the text in the edit control:

In event code

In addition to these methods, the following events provide access to the text in the edit control:

Use the Data parameter, which is passed into the event, to access the text of the edit control. In your code for these events, you can test the text value and perform special processing depending on that value.

For an example, see Coding the ItemChanged event.

When you want to further manipulate the contents of the edit control within your DataWindow control, you can use any of these methods:

For more information about these methods, see DataWindow Reference.

If data passes conversion and validation, the ItemChanged event is triggered. By default, the ItemChanged event accepts the data value and allows focus to change. You can write code for the ItemChanged event to do some additional processing. For example, you could perform some tests, set a code to reject the data, have the column regain focus, and trigger the ItemError event.

Example

The following sample code for the ItemChanged event for a DataWindow control called dw_Employee sets the return code in dw_Employee to reject data that is less than the employee's age, which is specified in a SingleLineEdit text box control in the window.

This is the PowerBuilder version of the code:

int a, age
age = Integer(sle_age.text)
a = Integer(data)

// Set the return code to 1 in the ItemChanged
// event to tell PowerBuilder to reject the data
// and not change the focus.
IF a < age THEN RETURN 1

The ItemError event is triggered if there is a problem with the data. By default, it rejects the data value and displays a message box. You can write code for the ItemError event to do some other processing. For example, you can set a code to accept the data value, or reject the data value but allow focus to change.

For more information about the events of the DataWindow control, see DataWindow Reference.

You can access data values in a DataWindow by using methods or DataWindow data expressions. Both methods allow you to access data in any buffer and to get original or current values.

The method you use depends on how much data you are accessing and whether you know the names of the DataWindow columns when the script is compiled.

For guidelines on deciding which method to use, see Accessing Data in Code in DataWindow Reference.

Using methods

There are several methods for manipulating data in a DataWindow control.

These methods obtain the data in a specified row and column in a specified buffer:

This method sets the value of a specified row and column:

For example, the following statement, using PowerBuilder syntax, assigns the value from the empname column of the first row to the variable ls_Name in the Primary buffer:

ls_Name = dw_1.GetItemString (1, "empname")

This PowerBuilder statement sets the value of the empname column in the first row to the string Waters:

dw_1.SetItem(1, "empname", "Waters")

Uses

You call the GetItem methods to obtain the data that has been accepted into a specific row and column. You can also use them to check the data in a specific buffer before you update the database. You must use the method appropriate for the column's datatype.

For more information about the methods listed above, see Methods for the DataWindow Control in DataWindow Reference.

Using expressions

DataWindow data expressions refer to single items, columns, blocks of data, selected data, or the whole DataWindow.

In PowerBuilder, you construct data expressions using dot notation.

Expressions in PowerBuilder

The Object property of the DataWindow control lets you specify expressions that refer directly to the data of the DataWindow object in the control. This direct data manipulation allows you to access small and large amounts of data in a single statement, without calling methods:

dw_1.Object.jobtitle[3] = "Programmer"

The next statement sets the value of the first column in the first row in the DataWindow to Smith:

dw_1.Object.Data[1,1] = "Smith"

For complete instructions on how to construct DataWindow data expressions, see Accessing Data in Code in DataWindow Reference.

There are many more methods you can use to perform activities in DataWindow controls. Here are some of the more common ones:

For complete information on DataWindow methods, see Methods for the DataWindow Control in DataWindow Reference.

Retrieve and update testing

When using the Retrieve or Update method in a DataWindow control, you should test the method's return code to see whether the activity succeeded.

Example

PowerBuilder

If you want to commit changes to the database only if an update succeeds, you can code:

IF dw_emp.Update() > 0 THEN
      COMMIT USING EmpSQL;
ELSE
      ROLLBACK USING EmpSQL;
END IF

Using the DBError event

The DataWindow control triggers its DBError event whenever there is an error following a retrieval or update; that is, if the Retrieve or Update methods return -1. For example, if you try to insert a row that does not have values for all columns that have been defined as not allowing NULL, the DBMS rejects the row and the DBError event is triggered.

By default, the DataWindow control displays a message box describing the error message from the DBMS, as shown here:

In many cases you might want to code your own processing in the DBError event and suppress the default message box. Here are some tips for doing this:

Example

PowerBuilder

Here is a sample script for the DBError event:

// Database error -195 means that some of the
// required values are missing
IF sqldbcode = -195 THEN
      MessageBox("Missing Information",  &   
         "You have not supplied values for all " &
         +"the required fields.")
END IF
// Return code suppresses default message box
RETURN 1

During execution, the user would see the following message box after the error:

A DataWindow control's Error event is triggered whenever an error occurs in a data or property expression at execution time. These expressions that refer to data and properties of a DataWindow object might be valid under some execution-time conditions but not others. The Error event allows you to respond with error recovery logic when an expression is not valid.

PowerBuilder syntax checking

In PowerBuilder, when you use a data or property expression, the PowerScript compiler checks the syntax only as far as the Object property. Everything following the Object property is evaluated at execution time. For example, in the following expression, the column name emp_name and the property Visible are not checked until execution time:

dw_1.Object.emp_name.Visible = "0"

If the emp_name column did not exist in the DataWindow, or if you had misspelled the property name, the compiler would not detect the error. However, at execution time, PowerBuilder would trigger the DataWindow control's Error event.

Using a Try-Catch block

The Error event is triggered even if you have surrounded an error-producing data or property expression in a Try-Catch block. The catch statement is executed after the Error event is triggered, but only if you do not code the Error event or do not change the default Error event action from ExceptionFail!. The following example shows a property expression in a Try-Catch block:

TRY
   dw_1.Object.emp_name.Visible = "0"
CATCH (dwruntimeerror dw_e)
   MessageBox ("DWRuntimeError", dw_e.text)
END TRY

Determining the cause of the error

The Error event has several arguments that provide information about the error condition. You can check the values of the arguments to determine the cause of the error. For example, you can obtain the internal error number and error text, the name of the object whose script caused the error, and the full text of the script where the error occurred. The information provided by the Error event's arguments can be helpful in debugging expressions that are not checked by the compiler.

If you catch a DWRuntimeError error, you can use the properties of that class instead of the Error event arguments to provide information about the error condition. The following table displays the correspondences between the Error event arguments and the DWRuntimeError properties.

Controlling the outcome of the event

When the Error event is triggered, you can have the application ignore the error and continue processing, substitute a different return value, or escalate the error by triggering the SystemError event. In the Error event, you can set two arguments passed by reference to control the outcome of the event.

For a complete description of the arguments of the Error event, see the section called “Error” in DataWindow Reference.

When updating the database, the DataWindow control determines the type of SQL statements to generate by looking at the status of each of the rows in the DataWindow buffers.

There are four DataWindow item statuses, two of which apply only to rows:

How statuses are set

When data is retrieved

When data is retrieved into a DataWindow, all rows and columns initially have a status of NotModified!.

After data has changed in a column in a particular row, either because the user changed the data or the data was changed programmatically, such as through the SetItem method, the column status for that column changes to DataModified!. Once the status for any column in a retrieved row changes to DataModified!, the row status also changes to DataModified!.

When rows are inserted

When a row is inserted into a DataWindow, it initially has a row status of New!, and all columns in that row initially have a column status of NotModified!. After data has changed in a column in the row, either because the user changed the data or the data was changed programmatically, such as through the SetItem method, the column status changes to DataModified!. Once the status for any column in the inserted row changes to DataModified!, the row status changes to NewModified!.

When a DataWindow column has a default value, the column's status does not change to DataModified! until the user makes at least one actual change to a column in that row.

When Update is called

For rows in the Primary and Filter buffers

When the Update method is called, the DataWindow control generates SQL INSERT and UPDATE statements for rows in the Primary and/or Filter buffers based upon the following row statuses:

A column is included in an UPDATE statement only if the following two conditions are met:

The DataWindow control includes all columns in INSERT statements it generates. If a column has no value, the DataWindow attempts to insert a NULL. This causes a database error if the database does not allow NULLs in that column.

For rows in the Delete buffer

The DataWindow control generates SQL DELETE statements for any rows that were moved into the Delete buffer using the DeleteRow method. (But if a row has a row status of New! or NewModified! before DeleteRow is called, no DELETE statement is issued for that row.)

You might need to change the status of a row or column programmatically. Typically, you do this to prevent the default behavior from taking place. For example, you might copy a row from one DataWindow to another; and after the user modifies the row, you might want to issue an UPDATE statement instead of an INSERT statement.

You use the SetItemStatus method to programmatically change a DataWindow's row or column status information. Use the GetItemStatus method to determine the status of a specific row or column.

Changing column status

You use SetItemStatus to change the column status from DataModified! to NotModified!, or the reverse.

Changing row status

Changing row status is a little more complicated. The following table illustrates the effect of changing from one row status to another:

In the preceding table, Yes means the change is valid. For example, issuing SetItemStatus on a row that has the status NotModified! to change the status to New! does change the status to New!. No means that the change is not valid and the status is not changed.

Issuing SetItemStatus to change a row status from NewModified! to NotModified! actually changes the status to New!. Issuing SetItemStatus to change a row status from DataModified! to New! actually changes the status to NewModified!.

Changing a row's status to NotModified! or New! causes all columns in that row to be assigned a column status of NotModified!. Change the column's status to DataModified! to ensure that an update results in a SQL Update.

To design the report, you create a DataWindow object. You select the data source and presentation style and then:

After you build the DataWindow object and fill in print specifications, you can place it in a DataWindow control on a window or form, as described in Putting a DataWindow object into a control.

To allow users to print the report, your application needs code that performs the printing logic. For example, you can place a button on the window or form, then write code that is run when the user clicks the button.

To print the contents of a single DataWindow control or DataStore, call the Print method. For example, this PowerBuilder statement prints the report in the DataWindow control dw_Sales:

dw_Sales.Print(TRUE)

For information about the Print method, see the DataWindow Reference. For information about using nested reports to print multiple DataWindows, see Using nested reports.

Separate DataWindow controls in a single print job

For PowerBuilder applications only

If the window has multiple DataWindow controls, you can use multiple PrintDataWindow method calls in a script to print the contents of all the DataWindow controls in one print job.

These statements print the contents of three DataWindow controls in a single print job:

int job
job = PrintOpen("Employee Reports")
// Each DataWindow starts printing on a new page.
PrintDataWindow(job, dw_EmpHeader)
PrintDataWindow(job, dw_EmpDetail)
PrintDataWindow(job, dw_EmpDptSum)
PrintClose(job)

For information about PowerBuilder system functions for printing, see the section called “PowerScript Functions” in PowerScript Reference.

If you want users to be able to see the raw data as well as the cross-tabulated data, you can do one of two things:

For more about composite DataWindows, see Users Guide.

With the CrosstabDialog method, you can allow users to redefine which columns in the retrieved data are associated with the crosstab's columns, rows, and values during execution.

The CrossTabDialog method displays the Crosstab Definition dialog box for the user to define the data for the crosstab's columns, rows, and values (using the same techniques you use in the DataWindow painter). When the user clicks OK in the dialog box, the DataWindow control rebuilds the crosstab with the new specifications.

Displaying informational messages

You can display informational messages when a crosstab is rebuilt during execution as a result of the call to CrosstabDialog. (The messages are the same ones you see when building a crosstab in the DataWindow painter, such as Retrieving data and Building crosstab.) You might want to do this if you are working with a very large number of rows and rebuilding the crosstab could take a long time.

PowerBuilder

In PowerBuilder, you use a user event to display the crosstab's informational messages.

Examples

PowerBuilder

In the example, code for the DataWindow control's user event for pbm_dwnmessagetext displays informational messages in a static text control in the window containing the crosstab:

st_message.Text = text

With that script in place, after CrosstabDialog has been called and the user has redefined the crosstab, as the crosstab is being rebuilt, your application dynamically displays the informational messages in the static text control st_message. (You might want to reset st_message.Text to be the empty string in the line following the CrosstabDialog call.)

In this example, code in the user event for pbm_dwnmessagetext displays informational messages as MicroHelp in an MDI application (w_crosstab is an MDI frame window):

w_crosstab.SetMicroHelp(text)

The informational messages are displayed in the MDI application's MicroHelp as the crosstab is rebuilt.

For more information

For more about user events in PowerBuilder, see the section called “Working with User Events” in Users Guide.

For more about the CrosstabDialog method and MessageText event, see the section called “CrosstabDialog” in DataWindow Reference and the section called “MessageText” in DataWindow Reference.

As with other DataWindow objects, you can modify the properties of a crosstab during execution using the Modify method. Some changes require the DataWindow control to dynamically rebuild the crosstab; others do not. (If the original crosstab was static, it becomes a dynamic crosstab when it is rebuilt.)

Changes that do not force a rebuild

You can change the following properties without forcing the DataWindow control to rebuild the crosstab:

Changes that force a rebuild

If you change any other properties, the DataWindow control rebuilds the structure of the crosstab when Modify is called. You should combine all needed expressions into one Modify call so that the DataWindow control has to rebuild the crosstab only once.

Default values for properties

For computations derived from existing columns, the DataWindow control by default uses the properties from the existing columns. For completely new columns, properties (such as font, color, and so on) default to the first column of the preexisting crosstab. Properties for text in headers default to the properties of the first text control in the preexisting crosstab's first header line.

For more about the Modify method, see Dynamically Changing DataWindow Objects. For details on the DataWindow object properties, see DataWindow Object Properties in DataWindow Reference.

You control table display and style sheet usage through the HTMLTable.GenerateCSS property. The HTMLTable.GenerateCSS property controls the downward compatibility of the HTML found in the HTMLTable property. If HTMLTable.GenerateCSS is FALSE, formatting (style sheet references) is not referenced in the HTMLTable property; if it is TRUE, the HTMLTable property includes elements that reference the cascading style sheet saved in HTML.StyleSheet.

This screen shows an HTML table in a browser using custom display features:

HTMLTable.GenerateCSS is TRUE

If the HTMLTable.GenerateCSS property is TRUE, the HTMLTable element in the HTMLTable property uses additional properties to customize table display. For example, suppose you specify the following properties:

HTMLTable.NoWrap=Yes
HTMLTable.Border=5
HTMLTable.Width=5
HTMLTable.CellPadding=2
HTMLTable.CellSpacing=2

The HTML syntax in the HTMLTable property includes table formatting information and class references for use with the style sheet:

<table cellspacing=2 cellpadding=2 border=5 width=5>
 <tr>
 <td CLASS=0 ALIGN=center>Employee ID
 <td CLASS=0 ALIGN=center>First Name
 <td CLASS=0 ALIGN=center>Last Name
 <tr>
 <td CLASS=6 ALIGN=right>102
 <td CLASS=7>Fran
 <td CLASS=7>Whitney
</table>

HTMLTable.GenerateCSS is FALSE

If HTMLTable.GenerateCSS is FALSE, the DataWindow does not use HTMLTable properties to create the Table element. For example, if GenerateCSS is FALSE, the HTML syntax for the HTMLTable property might look like this:

<table>
 <tr>
 <th ALIGN=center>Employee ID
 <th ALIGN=center>First Name
 <th ALIGN=center>Last Name
 <tr>
 <td ALIGN=right>102
 <td>Fran
 <td>Whitney
</table>

Merging HTMLTable with the style sheet

The HTML syntax contained in the HTMLTable property is incomplete: it is not wrapped in <HTML></HTML> elements and does not contain the style sheet. You can write code in your application to build a string representing a complete HTML page.

PowerBuilder example

This example sets DataWindow properties, creates an HTML string, and returns it to the browser:

String ls_html
 ds_1.Modify  &
 ("datawindow.HTMLTable.GenerateCSS='yes'")
 ds_1.Modify("datawindow.HTMLTable.NoWrap='yes'")
 ds_1.Modify("datawindow.HTMLTable.width=5")
 ds_1.Modify("datawindow.HTMLTable.border=5")
 ds_1.Modify("datawindow.HTMLTable.CellSpacing=2")
 ds_1.Modify("datawindow.HTMLTable.CellPadding=2")
 ls_html = "<HTML>"
 ls_html +=  &
       ds_1.Object.datawindow.HTMLTable.StyleSheet
 ls_html += "<BODY>"
 ls_html += "<H1>DataWindow with StyleSheet</H1>"
 ls_html += ds_1.Object.DataWindow.data.HTMLTable
 ls_html += "</BODY>"
 ls_html += "</HTML>"
 return ls_html

This technique provides control over HTML page content. Use this technique as an alternative to calling the SaveAs method with the HTMLTable! Enumeration.

As an alternative to creating HTML pages dynamically, you can call the SaveAs method with the HTMLTable! Enumeration:

ds_1.SaveAs  &
       ("C:\TEMP\HTMLTemp.htm", HTMLTable!, TRUE)

This creates an HTML file with the proper elements, including the style sheet:

<STYLE TYPE="text/css">
 <!--
 .2 {COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:9pt "Arial", sans-serif;TEXT-DECORATION:none}
  
 .3{COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:8pt "MS Sans Serif", sans-serif;TEXT-DECORATION:none}
  
 .3{COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:8pt "MS Sans Serif", sans-serif;TEXT-DECORATION:none}
 -->
 </STYLE>
  
 <TABLE nowrap cellspacing=2 cellpadding=2 border=5 width=5>
 <tr>
       <td CLASS=2 ALIGN=right>Employee ID:
       <td CLASS=3 ALIGN=right>501
 <tr>
       <td CLASS=2 ALIGN=right>Last Name:
       <td CLASS=3>Scott
 <tr>
       <td CLASS=2 ALIGN=right>First Name:
       <td CLASS=3>David
 <tr>
       <td CLASS=2 ALIGN=right>Status:
       <td CLASS=3>Active
 </TABLE>

The GenerateHTMLForm method creates HTML form syntax for DataWindow objects. You can create an HTML form that displays a specified number of columns for a specified number of rows. Note the following:

Presentation styles

Although the GenerateHTMLForm method generates syntax for all presentation styles, the only styles that create usable forms are Freeform and Tabular.

The following HTML page shows a freeform DataWindow object converted into a form using syntax generated by the GenerateHTMLForm method:

Edit style conversion

The GenerateHTMLForm method converts column edit styles into the appropriate HTML elements:

Generating syntax

To generate HTML form syntax, you call the GenerateHTMLForm method:

instancename.GenerateHTMLForm ( syntax, style, action { , startrow, endrow, startcolumn, endcolumn { , buffer } } )

The method places the Form element syntax into the syntax argument and the HTML style sheet into the style argument, both of which are passed by reference.

Here is an example of the GenerateHTMLForm method:

String   ls_syntax, ls_style, ls_action
 String   ls_html
 Integer li_return
 ls_action =  &
       "/cgi-bin/pbcgi60.exe/myapp/uo_webtest/f_emplist"
 li_return = ds_1.GenerateHTMLForm  &
       (ls_syntax, ls_style, ls_action)
 IF li_return = -1 THEN
       MessageBox("HTML", "GenerateHTMLForm failed")
 ELSE
       // of_MakeHTMLPage is an object method,
       // described in the next section.
       ls_html = this.of_MakeHTMLPage  &
          (ls_syntax, ls_style) 
 END IF

After calling the GenerateHTMLForm method, the ls_syntax variable contains a Form element. Here is an example:

<FORM ACTION=
       "/cgi-bin/pbcgi60.exe/myapp/uo_webtest/f_emplist" 
       METHOD=POST>
 <P>
 <P><FONT CLASS=2>Employee ID:</FONT>
 <INPUT TYPE=TEXT NAME="emp_id_1" VALUE="501">
  
 <P><FONT CLASS=2>Last Name:</FONT>
 <INPUT TYPE=TEXT NAME="emp_lname_1" MAXLENGTH=20 VALUE="Scott">
  
 <P><FONT CLASS=2>First Name:</FONT>
 <INPUT TYPE=TEXT NAME="emp_fname_1" MAXLENGTH=20 VALUE="David">
  
 <P><FONT CLASS=2>Status:</FONT>
 <INPUT TYPE="RADIO" NAME="status_1" CHECKED CLASS=5 ><FONT CLASS=5 >Active
  
 <P>
 <INPUT TYPE="RADIO" NAME="status_1" CLASS=5 >
 <FONT CLASS=5 >Terminated
  
 <P>
 <INPUT TYPE="RADIO" NAME="status_1" CLASS=5 >
 <FONT CLASS=5 >On Leave
 <P>
 <P>
 <BR>
 <INPUT TYPE=SUBMIT NAME=SAMPLE VALUE="OK">
 </FORM>

The ls_stylesheet variable from the previous example contains a Style element, an example of which is shown below:

<STYLE TYPE="text/css">
 <!--
 .2{COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:9pt "Arial", sans-serif;TEXT-DECORATION:none}
  
 .3{COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:8pt "MS Sans Serif", sans-serif;TEXT-DECORATION:none}
  
 .5{COLOR:#000000;BACKGROUND:#ffffff;FONT-STYLE:normal;FONT-WEIGHT:normal;FONT:8pt "MS Sans Serif", sans-serif;TEXT-DECORATION:none}
 -->
 </STYLE>

Creating an HTML page

To use the syntax and style sheet returned by the GenerateHTMLForm method, you must write code to merge them into an HTML page. A complete HTML page requires <HTML> and <BODY> elements to contain the style sheet and syntax.

One way to do this is to create a global or object function that returns a complete HTML page, taking as arguments the Form and Style elements generated by the GenerateHTMLForm method. Such a function might contain the following code:

 // Function Name: of_MakeHTMLPage
 // Arguments: String as_syntax, String as_style
 // Returns: String
 //***********************************
 String    ls_html
 IF as_syntax = "" THEN
       RETURN ""
 END IF
  
 IF as_style = "" THEN
       RETURN ""
 END IF

 ls_html = "<HTML>"
 ls_html += as_style
 ls_html += "<BODY>"
 ls_html += "<H1>Employee Information</H1>"
 ls_html += as_syntax
 ls_html += "</BODY></HTML>"
 RETURN ls_html