HAHTsite IDE Programming Guide

Transcription

1 HAHTsite IDE Programming Guide

2 IDE Programming Guide release 4.0

3 Notice Copyright 1999 HAHT Software, Inc. All Rights Reserved May 1999 MN07-C No part of this publication may be copied, photocopied, reproduced, transmitted, transcribed, or reduced to any electronic medium or machine-readable form without the prior written consent of HAHT Software, Inc. Information in this document is subject to change without notice. Names and information used in examples are fictitious. U.S. GOVERNMENT RESTRICTED RIGHTS. It is acknowledged that the Software and the Documentation were developed at private expense, that no part is in the public domain, and that the Software and Documentation are Commercial Computer Software provided with RESTRICTED RIGHTS under Federal Acquisition Regulations and agency supplements to them. Use, duplication, or disclosure by the U.S. Government is subject to restrictions as set forth in subparagraph (c)(1)(ii) of The Rights in Technical Data and Computer Software clause at DFAR et. seq. or subparagraph (c)(1) and (2) of the Commercial Computer Software 96 Restricted Rights at FAR , as applicable. Contractor is HAHT Software, Inc., 4200 Six Forks Road, Raleigh, NC Rights are reserved under copyright laws of the United States with respect to unpublished portions of the Software. Trademarks HAHT, HAHT Software, HAHTsite, e-scenario, and e-nable your enterprise are trademarks or U.S. registered trademarks of HAHT Software, Inc. Portions Copyright Summit Software Company. This product includes software developed by the Apache Group for use in the Apache HTTP server project ( Any other corporate names, product names, tradenames, trademarks, service marks, or service names owned or registered by any other company and mentioned herein are the property of their respective companies. Specifications subject to change without notice. HAHT Software, Inc Six Forks Road Raleigh, NC USA (919) (888) (in the USA) (919) (Technical Support)

4 Contents About This Book Who is this book for? xvii Conventions xvii Other HAHTsite documentation xviii Other HAHTsite products xix HAHT Software s commitment to you xix 1 Introduction Overview HAHTsite Server Object Model The project package The datamanager package The form package The access package The corba package Data-management API ActiveX Data Objects classes Relationship between ADO and SOM classes Data management in HAHTtalk Basic projects Client-side scripting CORBA capabilities Access to COM/DCOM objects Remote debugging Working with Java Projects What s in this chapter Adding server-side code to a Java project iii

5 Contents HAHTsite Server Object Model External logic In-line code Invoking an expression or a method from a dialog box Adding code in Server-side Code view What s in a Java page? Editing HahtApplication.java and HahtSession.java Adding Java files to a project Naming conventions for Java projects Naming conventions for dynamic pages Calling a dynamic page from Java Event handling in a Java project Editing and compiling Java code Using the code editor Compiling a Java application Finding compile-time errors Debugging a Java application Working with application directories Java options Changing the Java file type Overriding Java compiler options Overriding options for JAR, CAB, and ZIP files Working with HAHTtalk Basic Projects What s in this chapter Adding server-side code to a HAHTtalk Basic project HAHTsite Server Object Model External logic In-line code Invoking an expression or a subroutine from a dialog box Adding code in Server-side Code view What s in a HAHTtalk Basic page? Adding HAHTtalk Basic files to a project Naming conventions for HAHTtalk Basic projects Include files and Globals.hbs iv

6 Contents Project and external includes Declaring public variables with Globals.hbs Precompiler directives Calling dynamic pages from HAHTtalk Basic Event handling in a HAHTtalk Basic project Editing and compiling HAHTtalk Basic code Using the code editor Compiling a HAHTtalk Basic application Finding compile-time errors Debugging a HAHTtalk Basic application Working with application directories Comparing HAHTtalk Basic and Visual Basic HAHTtalk Basic data types Subroutines and functions File I/O Error handling Code page properties Calling Server-side Java from HAHTtalk Basic Introduction Using Java objects with HAHTtalk Basic CreateJavaObject GetJavaClass CreateTypedJavaNull Differences between HAHTtalk Basic and Java Java is strongly typed Parameter passing Java is case sensitive Locating objects Mapping HAHTtalk Basic types to Java parameter types Mapping Java types to HAHTtalk Basic types Troubleshooting: Java runtime errors v

7 Contents 5 HAHTsite Server Object Model Introduction Built-in objects Getting references to the built-in objects From a Java project From a HAHTtalk Basic project The Application object Application object methods Application object variables Multiple processes and application-level variables Retrieving Application object properties Summary of Application object methods The Session object Session state Session timeout Event handling Creating a dynamic URL Creating a static URL Identification methods Summary of Session object methods The Request object Retrieving field values Retrieving cookie values Retrieving attachments Retrieving environment variables Summary of Request object methods The Response object Writing headers Setting cookies Writing the HTML output Summary of Response object methods Forms-Related Programming What s in this chapter Calling a subroutine from a form vi

8 Contents Writing the subroutine Associating the subroutine with a form Attaching a file to a form Adding a File Upload control to a page Working with a file attachment Custom Form Handler widgets Writing the form-handler function Creating the custom form-handler widget Form Fields Programming What s in this chapter Setting form-field properties Examples of setting form-field properties Setting and getting form-field properties FormField properties Button properties Checkbox properties Combo properties FileUpload properties ListElement and Listbox classes Radiobutton properties StaticText properties TextArea properties Textbox properties Calculating form-field values Calling user code from a button Code associated with a button versus code associated with a form Configuring a button to call user code Data-Agent Programming Data agents and command handlers Calling data-agent methods at runtime Setting a data agent s command Performing a data-agent action Getting and setting the values of a data agent s fields vii

9 Contents Getting a reference to a data agent s connection Dealing with recordsets Getting parameters to stored procedures Refreshing a data agent s data Sorting records Filtering records Handling errors Enabling tracing The structure of a command handler Modifying a command handler Where to add code to a command handler Examples of adding code to a command handler Changing the flow of control in a command handler Example of changing the flow of control Programming with the Connection Manager The DMConnectionManager class Opening a connection Opening a shared connection Opening a private connection Closing a connection Connections in HAHTtalk Basic projects Working with Client-side Scripts Introduction to client-side scripts Types of client-side scripts Choosing a scripting language Client-side scripts and the HTML editor Browsing the object model Configuring the Client Scripts view Writing in-line scripts Writing script functions HTML tags for client-side scripts viii

10 Contents About event handlers Scripting event handlers Browser compatibility issues The browser object model Strategies for handling browser incompatibilities About Dynamic HTML Moving objects using DTHML Why use Netscape Layers for positioning? JavaScript example for browser-independent DHTML Scripts with server-side expressions Using HtmlOut Routines or the HtmlOut Class Creating HTML at runtime The HAHTtalk Basic HtmlOut library Using the HAHTtalk Basic HtmlOut library HAHTtalk Basic example The HtmlOut Java class Java example Access Control What is access control? Granting privileges: the basics Controlling access to a page Controlling access to part of a page Displaying a custom error page Granting privileges to logged-in users Authenticating users with the Login widget Authenticating users with the Authentication interface Letting the Web server authenticate users Granting privileges on a user-name basis Using a Login widget and a database privilege repository Using a Login widget and a nondatabase privilege repository Using the Server Object Model ix

11 Contents Server Object Model methods Session class Privileges class Application class Authentication interface UserProfile interface Connecting to COM Objects Introduction Calling DLLs Declaring a DLL in HAHTtalk Basic Example DLL declarations Mapping HAHTtalk Basic types to DLL data types Using COM objects with HAHTtalk Basic The CreateObject function A COM Server example Background HAHTMem methods HAHTsite CORBA Capabilities Overview What is CORBA? What does HAHTsite/CORBA interoperation mean? Using CORBA with the HAHTsite IDE Handling CORBA projects Setting options for CORBA HAHTsite as a CORBA client Example: Building a HAHTsite CORBA client HAHTsite as a traditional CORBA server Example: Using CORBA to hold HAHTsite global state CORBA and the HAHTsite Server Object Model Using the HAHTsite Server Object Model in a HAHTsite CORBA server x

12 Contents Accessing the HAHTsite Server Object Model from a CORBA client Client/server communication Example: Using CORBA in a session initiated via HTTP Example: Initiating a HAHTsite application session with CORBA.327 Other Information Interoperability with other ORBS Using CORBA with HAHTtalk Basic VisiBroker installation and configuration VisiBroker SmartAgent and the CORBA Naming Service VisiBroker GateKeeper References Debugging Server-side Code Introduction Requirements for debugging A special case: debugging HAHTtalk Basic stand-alone programs.333 Starting a debugging session Debugging a code page Executing code in the debugger Single-stepping Procedure-stepping Using breakpoints The debug windows Debug output panel Variable window Watch window Call Stack window Threads window A HAHTsite 3.x WebApp Methods and Properties Introduction WebApp properties WebApp methods xi

13 Contents Pseudo-methods B HAHTsite 3.x Data Management Introduction DataSets and data agents Accessing and changing DataSet properties at runtime DataSet control functions Writing user-defined DataSet functions Accessing and changing form-control properties at runtime Connection-manager functions C Code Examples Calling a subroutine as a form action Modifying a command handler Writing a custom authentication class D ADO Primer What s in this appendix Connections Opening a connection Executing a command against a connection Closing a connection Recordsets Creating a recordset Iterating through the records in a recordset Finding a specific record in a recordset Reading a record Updating a record Inserting a record Deleting a record Closing a recordset E ADO Extensions What s in this appendix xii

14 Contents Extensions to the Java interface ADO tracing in Java projects Additional appendchunk methods The Variant data type Extensions to the HAHTtalk Basic interface ADO tracing in HAHTtalk Basic projects Functions for managing connections xiii

15 Contents xiv

16 About This Book The HAHTsite IDE Programming Guide explains how to extend your HAHTsite applications programmatically. Chapter 1, Introduction, gives you an overview of the programming capabilities available within HAHTsite. If you re developing a Java application, continue with Chapter 2, Working with Java Projects. If you re developing a HAHTtalk Basic application, look at the corresponding chapter, Chapter 3, Working with HAHTtalk Basic Projects. Then read Chapter 5, HAHTsite Server Object Model, which describes the programming model that underlies a HAHTsite application, including the Application, Session, Page, Request, and Response objects. This chapter, and all the chapters that follow, contain both HAHTtalk Basic and Java examples. However, the functionality is the same, regardless of which language you use. The table below lists each chapter in the HAHTsite IDE Programming Guide, along with its contents. Chapter/Appendix Chapter 1, Introduction Chapter 2, Working with Java Projects Chapter 3, Working with HAHTtalk Basic Projects Chapter 4, Calling Server-side Java from HAHTtalk Basic Chapter 5, HAHTsite Server Object Model Chapter 6, Forms-Related Programming Chapter 7, Form Fields Programming Contents A high-level introduction to the IDE s Server Object Model, data management model, and COM, CORBA, and client-scripting capabilities. Information for developers who are adding server-side code to a Java project. Information for developers who are adding server-side code to a HAHTtalk Basic project. How to call Java from a HAHTtalk Basic project. Explanation of the built-in objects in HAHTsite s Server Object Model. Customizing your application s form-handling capabilities. For HAHTtalk Basic projects, adding a custom form handler. Writing code that affects form fields and using a button to call user-written code. xv

17 About This Book Chapter/Appendix Chapter 8, Data-Agent Programming Chapter 9, Programming with the Connection Manager Chapter 10, Working with Client-side Scripts Chapter 11, Using HtmlOut Routines or the HtmlOut Class Chapter 12, Access Control Chapter 13, Connecting to COM Objects Chapter 14, HAHTsite CORBA Capabilities Chapter 15, Debugging Server-side Code Appendix A, HAHTsite 3.x WebApp Methods and Properties Appendix B, HAHTsite 3.x Data Management Appendix C, Code Examples Appendix D, ADO Primer Appendix E, ADO Extensions Contents Calling data-agent methods at runtime; customizing HAHTsite s command handlers. Opening and closing shared and private connections using the DMConnectionManager class. Adding JavaScript or VBScript to your application. Using HAHTsite functions/methods to create HTML at runtime. Controlling access to HAHTsite project items by assigning a set of required privileges to the items. Accessing DLLs and COM/DCOM objects from HAHTsite applications. Building HAHTsite applications that are CORBA clients or servers. Using HAHTsite s remote debugger to inspect code running on the Application Server. How WebApp properties and methods (from HAHTsite 3.x) relate to objects in the Server Object Model. How programming database applications differs between HAHTsite 3.x and HAHTsite 4.0. A set of sample functions/methods that supplement those in the text. How to perform basic operations using ADO connections and recordsets. The few ways in which HAHTsite s ADO implementation differs from the standard. xvi

18 Who is this book for? About This Book This book is written for use by HAHTsite programmers. It assumes that you: know how to use the HAHTsite IDE to create Web applications. have an understanding of how the HAHTsite IDE creates Web applications, how HAHTsite applications are structured, and how applications interact with the HAHTsite Application Server. know how to use either the Visual Basic or Java programming language. are familiar with HTML. Prerequisites In order to build a Java project that contains dynamic pages, or a HAHTtalk Basic project that calls server-side Java, you must have a Java compiler installed (not included with the HAHTsite software). See the ReadMe file for information on downloading a Java compiler. Conventions This book uses several conventions, which are described here. HAHTsite installation directory The directory into which you install the HAHTsite IDE is called the HAHTsite installation directory. This book uses the variable HAHTsiteInstallDir as a placeholder for the HAHTsite installation directory for example, C:\HAHTsite. When you see this variable, you should replace it with the name of the HAHTsite installation directory on your system. Continuation characters in sample code Some lines of sample code are too long to fit on one line. For HAHTtalk Basic code, this book uses the line-continuation character ( _ ) at the end of a line. For example: Function Create (instancehandle As Long, createtime As Integer, _ scopecount As Long) As Integer xvii

19 About This Book Screen images The HAHTsite IDE/IP runs on Windows 95, Windows 98, and Windows NT. Depending on which operating system you are using, the look of the screens might be slightly different from what you see in this book. However, the screens contents are the same. Other HAHTsite documentation The HAHTsite IDE includes this additional documentation: HAHTsite IDE and IP User s Guide HAHTsite IDE and IP Installation Guide HAHTsite Widget Programming Guide Getting Started The HAHTsite IDE/IP also includes an introduction to HAHTsite, lessons in using HAHTsite, and sample (HAHT_Intro) projects in Java and HAHTtalk Basic. Choose Getting Started from the Help menu. Online documentation In addition to the printed books, you can use the IDE/IP s online help system. As well as context-sensitive help for each of the dialogs, the online help system includes: Overview information about the IDE/IP. Step-by-step instructions on how to use the IDE/IP s features. Reference pages for the HAHTtalk Basic language, HAHTsite s Server Object Model, and the SQL Assistant. Information about using HAHTtalk Basic s Dialog Editor (used in building widgets). To open the help system, choose Contents and Index from the Help menu. xviii

20 About This Book HAHTsite OLE Interface Guide The HAHTsite IDE provides an OLE interface that you can access from your custom widgets. The OLE objects and methods are described in the HAHTsite OLE Interface Guide, which you can access from the IDE s Help menu. The HAHTsite OLE Interface Guide is an HTML document. The HAHTsite OLE Interface Guide is also installed as a HAHTsite project (in HAHTsiteInstallDir\sdk\oleapi). This enables you to add comments to the guide or to copy the guide s examples into the HAHTsite IDE and test them. Other HAHTsite products In addition to the IDE and the IP, the HAHTsite family of products includes the HAHTsite Application Server, which works with any Web server to execute HAHTsite applications. The Application Server runs on the Windows NT, HP/UX, Solaris, and AIX operating systems. It executes application logic, enables complete access to multiple data sources, maintains session information, and dynamically generates HTML pages. HAHT Software s commitment to you We want you to be completely satisfied with your HAHT Software products. If you have questions about HAHTsite, the HAHTsite IDE, the HAHTsite IP, or the HAHTsite Application Server, you can contact HAHT Software in the following ways: Telephone (919) Technical Support (Voice) (919) Technical Support (FAX) (888) Sales (Voice in the USA) (919) Office (Voice) (919) Office (FAX) xix

21 About This Book General Information Sales Support World Wide Web xx

22 Introduction 1 Overview...2 HAHTsite Server Object Model...3 The project package...3 The datamanager package...4 The form package...4 The access package...5 The corba package...5 Data-management API...5 ActiveX Data Objects classes...6 Relationship between ADO and SOM classes...6 Data management in HAHTtalk Basic projects...7 Client-side scripting...8 CORBA capabilities...9 Access to COM/DCOM objects...9 Remote debugging

23 Chapter 1: Introduction Overview Using HAHTsite s Integrated Development Environment (IDE), you can create many Web applications without writing any code. You describe your application s requirements using the IDE s graphical user interface, and HAHTsite s code generator creates the code for your application. Of course, code generators can t account for every contingency. Therefore, HAHTsite makes it easy for you to add your own code to this generated code as needed. In HAHTsite, you can add such code using either Java or HAHTtalk Basic (which is syntax compatible with Visual Basic). A Java virtual machine (either Microsoft or Sun) and a Basic virtual machine are embedded in the Application Server for the execution of code written in these languages. Being able to add Java or HAHTtalk Basic code to HAHTsite pages is useful in itself, but the real power of this language support lies in the fact that you can use these languages to call a tremendous amount of existing code. For instance, from either Java or HAHTtalk Basic, your Web application can call other code in DLLs, UNIX shared libraries, Java classes, or practically anything else that has a callable API. Of particular importance are the Java packages and Basic libraries supplied with HAHTsite. First, HAHTsite includes a set of Java packages that make up what is called its Server Object Model. The classes in these packages can be called from both Java and HAHTtalk Basic projects and enable you to: obtain information about the Application Server, about your application and individual user sessions, and about the data being passed back and forth between the Application Server and the Web server establish connections with relational and nonrelational data sources and to manage the ActiveX Data Objects (ADO) recordsets obtained via those connections control the form fields in your application s forms provide access control for the pages in your application make your application a CORBA server HAHTsite also includes a Java package and a Basic library that enable you to use the ActiveX Data Objects API for data management. 2

24 HAHTsite Server Object Model Chapter 1: Introduction The classes in the HAHTsite Server Object Model (SOM) are implemented in Java. At runtime, Java projects access SOM objects as real Java objects, and can subclass SOM classes and override SOM methods. You can also access the SOM from HAHTtalk Basic projects using HAHTtalk Basic syntax. However, some limitations apply; for example, SOM objects cannot be subclassed in a HAHTtalk Basic project. The classes in the SOM give you many capabilities, including the ability to examine requests sent from a Web browser, to manage data sources, and to protect information from unauthorized access. The principal packages in the SOM are: com.haht.project com.haht.project.datamanager com.haht.project.form com.haht.access com.haht.corba The project package The project package contains a number of built-in objects, which are available in every HAHTsite application. These objects are similar to the built-in objects in Microsoft s Active Server Pages. They let you control the data passed to and from a Web browser client and to get information about the application, the Web server, and the Application Server. When you run a HAHTsite application, each instance of a dynamic page is a Page object. You can also create dynamic pages programmatically, by implementing the HAHTPage interface in a Java project, or by implementing a Basic subroutine that generates HTML in a HAHTtalk Basic project. In addition to Page objects, each HAHTsite application contains these built-in objects: The Server object contains methods for storing variables that may be shared among multiple applications (as long as they are running in the same process on the Application Server). The Application object has information about the current application, as well as event handlers that are triggered when an application or session starts or ends. The Session object has information about the current session, which is defined as a browser client using the application. There is a separate Session object for each client. It also has two event handlers, called when a session is created and just before it s destroyed. 3

25 Chapter 1: Introduction The Request object s methods retrieve data the client browser sends to the Web server for example, form data or cookies. The Response object s methods generate HTML that the Web server sends to the browser. For further information about the project package, see Chapter 5, HAHTsite Server Object Model. The datamanager package The most important classes in the datamanager package are: DataAgent DMConnectionManager The DataAgent class represents an ADO recordset and enables you perform a variety of actions against that recordset. For example, you can use this class s methods to set the command that returns the recordset, to perform an action such as updating a record, or to get or set the value of a field in the recordset s current record. The DMConnectionManager class includes methods for opening ADO connections to relational or nonrelational data sources. These connections can be shared by two or more data agents within a session to lessen the amount of time your application spends establishing connections. Or they can be private so that you can perform transactions on the connection. The DataAgent and DMConnectionManager classes are discussed in detail in Chapter 8, Data-Agent Programming and Chapter 9, Programming with the Connection Manager, respectively. The form package The form package contains classes that represent the different types of form fields that you can place in a form, such as text boxes, combo boxes, and submit buttons. The methods of these classes enable you to perform tasks such as: setting a form field s value setting a text box s width setting the selected status of a list-box element Basically, all the form-field attributes that you can set in the IDE, you can also set at runtime. 4

26 Chapter 1: Introduction For further information about the form package, see Chapter 7, Form Fields Programming. The access package The access package includes classes that enable you to control access to HAHTsite pages. A Privileges class provides a container for a set of user-defined privileges, and each session contains a Privileges object. In addition, HAHTsite pages have associated with them a set of privileges. At runtime, the Application Server determines whether a session has access to a particular page in an application by comparing the privileges in the session s Privileges object with the page s privileges. The session can access a page only if all of that page s required privileges are contained in its Privileges object. This package also contains classes that enable you to: authenticate a user login retrieve a set of privileges from a repository by user name Chapter 12, Access Control, provides a complete explanation of how to use the classes in this package. The corba package The corba package enables you to create a HAHTsite application that plays the role of a CORBA server. Using the CORBA interface, clients can create sessions and invoke Java object methods. This CORBA interface enables applets running in a browser to communicate directly with the Application Server, bypassing the Web server. It also enables other CORBA applications in the corporate IT infrastructure to invoke services from the HAHTsite Application Server. A HAHTsite application can also function as a CORBA client. For further information about creating CORBA clients and servers, see Chapter 14, HAHTsite CORBA Capabilities. Data-management API In addition to the Server Object Model, HAHTsite includes both a Java package and a Basic library that provide a data-management API based on Microsoft s ActiveX Data Objects (ADO) 2.0. Java projects use the Java classes, and 5

27 Chapter 1: Introduction HAHTtalk Basic projects use the Basic classes. You can find documentation for both interfaces on Microsoft s Web site ( msdnlib.idc?theurl=/library/sdkdoc/dasdk/mdwe7i0f.htm). The ADO interface has the benefit of being well known and widely used by developers and, thus, is preferable to yet another proprietary data-access model. In addition, ADO is not tied to SQL, but allows access to both relational and nonrelational data sources. ActiveX Data Objects classes As mentioned earlier, HAHTsite s ADO interfaces are based on those of Microsoft ADO 2.0. If you re familiar with ADO programming, you know that the principal classes in the ADO object model are: Connection Command Recordset The Connection class represents a connection to a data source. An object of this type enables you to open and close a connection to a data source, to execute a command that returns a recordset from the data source, and to manage transactions on the connection. A Command object represents a command that queries a data source and returns a recordset. This command may be a SQL statement or some other textual command, the name of a database table, or the name of a stored procedure. A Recordset object contains the records returned over a connection following the execution of a query. Using a Recordset s methods, you can navigate the records in the recordset, add a new row to the recordset or delete an existing record, update a record, and so on. For information on how these ADO classes relate to the Server Object Model s DataAgent and DMConnectionManager classes, see Relationship between ADO and SOM classes on page 6. Relationship between ADO and SOM classes As you ve probably noticed, there s some overlap between the ADO object model and the Server Object Model s DMConnectionManager and DataAgent classes. You can use either or a combination of both for your data-management programming. Basically, the classes in the Server Object Model (SOM) provide a layer on top of the ADO classes that makes programming easier. The DMConnectionManager 6

28 Chapter 1: Introduction class enables you to create an ADO connection, and the DataAgent class not only represents an ADO recordset, but knows about the connection and the command used to retrieve that recordset. If you use the IDE to create connections to data sources and to create data agents, HAHTsite calls methods of the DMConnectionManager class and the DataAgent class in its generated code. So some of your data-management programming can be as simple as describing your requirements in the IDE. For situations where you need to perform tasks that aren t supported by the IDE, you can supplement the IDE s generated code with your own code that uses the DMConnectionManager and DataAgent classes, or you can use the ADO interface directly. Data management in HAHTtalk Basic projects In HAHTtalk Basic projects, you have two options when it comes to ADO programming. You can create Basic objects by making calls like this: Dim myconn As New ADODB.Connection myconn.open "..." Or you can create Java objects by using the classes defined in the package com.haht.ado, like this: Dim myconn As Object myconn = CreateJavaObject("com.haht.ado.Connection"...) myconn.open "..." Although both approaches are perfectly acceptable, the assumption is that Basic programmers will prefer to use Basic objects (the first approach). If you do use the Basic library for your ADO programming, make sure you understand that a Basic object and its Java counterpart are not type compatible. That is, a Basic recordset and a Java recordset do not have the same data type. Therefore, the following code will result in a type-mismatch error: Dim myrs As ADODB.Recordset... Set myrs = dataagent.getrecordset() The DataAgent class is a Java class, and the getrecordset method returns a Java object. A reference to this object cannot be assigned to myrs. One other note. The Java classes DMConnectionManager and DataAgent which are not part of the ADO object model, but define methods that return ADO objects do not have Basic counterparts. HAHTsite does include Basic 7

29 Chapter 1: Introduction functions that give you much of the functionality of the DMConnectionManager class. (These functions are discussed in Appendix E, ADO Extensions. ) However, to work with data agents, you must work with Java objects. Client-side scripting Most code in a HAHTsite application is executed by the Application Server; however, HAHTsite also provides support for writing client-side scripts to be executed in the user s browser. You can write these scripts in either JavaScript or VBScript. To help you develop scripts more easily, the HAHTsite IDE provides a Client Scripts view of each HTML page. In this view, you see a tree representation of the Document Object Model for the page. By navigating this tree, you can select specific objects that you want to associate event handlers with. For instance, you can navigate to a text box in a form and select the text box s onchange event. You can then use a script editor window to write a script that will be executed when this event occurs. The Document Object Model window also displays properties of the currently selected object and methods that may be applied to that object. If you drag one of these properties from the Document Object Model window to the editing window, HAHTsite constructs the appropriate reference, including correct capitalization and syntax. This drag-and-drop feature makes it easier to write client scripts. One other point. The task of writing client scripts and Dynamic HTML is complicated by variations in the Document Object Models in different browsers and different browser revisions. In general, the Document Object Model has become much more sophisticated and robust in later browser revisions, but pages that use the new browser features do not work in older browsers. The HAHTsite client-script editor enables you to view a particular Document Object Model. Thus, if you select the Internet Explorer 3.0 Document Object Model, HAHTsite will not display the new events and scriptable objects introduced in later versions of Internet Explorer and Netscape Navigator. This feature makes it easy to write scripts that work when the browser revision of your end users varies. For additional information about using JavaScript and VBScript in your applications, see Chapter 10, Working with Client-side Scripts. 8

30 CORBA capabilities Chapter 1: Introduction The software bundled with HAHTsite includes Inprise (formerly Visigenic) VisiBroker for Java, a suite of tools for building distributed-object applications. HAHTsite applications written using the HAHTsite Server Object Model can incorporate calls to the VisiBroker interfaces and thereby act as standard CORBA objects. Using CORBA s built-in capabilities, they can communicate with and become part of an enterprise built of distributed CORBA objects. Information from remote CORBA systems, such as mainframes, can be obtained by these CORBA-enhanced HAHTsite applications. This data can then be used in any manner within the HAHTsite application, providing a flexible, complete method to present enterprise information on the Web. In addition, there are several extensions to the HAHTsite Server Object Model that provide CORBA interfaces, allowing CORBA systems to operate directly on some HAHTsite server objects. This level of integration allows an external, non-hahtsite application to connect as a CORBA client to a CORBA-enabled HAHTsite application acting as a CORBA server. Such a client can initiate and control a HAHTsite session, making use of session capabilities such as automatic timeout. CORBA can also provide a Java applet running in a browser the ability to communicate with a HAHTsite application without the overhead of the HTTP protocol. For applets requiring substantial or very dynamic data from the server, this can be very beneficial. Access to COM/DCOM objects In a Microsoft environment, HAHTsite also provides full access to COM/DCOM objects. This access is native and does not depend on bridges from CORBA or other distributed object systems. From HAHTtalk Basic code, COM/DCOM servers are instantiated using the standard CreateObject call. Both in-process and out-of-process servers are supported. From Java code, COM/DCOM objects can be accessed via Java wrapper classes created using tools provided with the Microsoft SDK for Java. HAHTsite s ability to naturally and directly access COM/DCOM objects makes it easy to interface your HAHTsite application to other software products or custom code written for the Microsoft environment. For additional information, see Chapter 13, Connecting to COM Objects. 9

31 Chapter 1: Introduction Remote debugging HAHTsite supports remote debugging of both Java and HAHTtalk Basic code running in the Application Server (but not both in the same debug session). The Java and HAHTtalk Basic debuggers share the same IDE interface and have equivalent function except that Java code must be published with the debug option so that debug symbols are included. (HAHTtalk Basic code can be debugged without the debug option.) Debugging HAHTsite applications is discussed in detail in Chapter 15, Debugging Server-side Code. 10

32 Working with Java Projects 2 What s in this chapter...12 Adding server-side code to a Java project...12 In-line code...13 Invoking an expression or a method from a dialog box...15 Adding code in Server-side Code view...17 What s in a Java page?...18 Editing HahtApplication.java and HahtSession.java...25 Adding Java files to a project...26 Naming conventions for Java projects...30 Calling a dynamic page from Java...30 Event handling in a Java project...31 Editing and compiling Java code...37 Using the code editor...37 Compiling a Java application...38 Finding compile-time errors...39 Debugging a Java application...39 Working with application directories...39 Java options...41 Changing the Java file type...41 Overriding Java compiler options...42 Overriding options for JAR, CAB, and ZIP files

33 Chapter 2: Working with Java Projects What s in this chapter The first half of this chapter explains how to add server-side code that is, code that runs on the Application Server to a Java project. The second half of the chapter explains the mechanics of working with the code editor and compiling the code. Later chapters in this book give detailed explanations, with examples, of ways you can extend your HAHTsite application programmatically. For complete information about specific Java classes and methods, refer to the online help for the Server Object Model. In addition, if you are interested in further customizing your application with client-side scripts and applets, then be sure to look at Chapter 10, Working with Client-side Scripts, and the HAHTsite IDE and IP User s Guide, Chapter 20, Applets and Multimedia Objects. Note - The examples throughout this book assume the appropriate import statements and invoke Java methods without qualifying them with the full package name for example, they call Haht.getRequest() instead of com.haht.haht.getrequest(). HAHTsite s generated code uses the full qualification, to eliminate the possibility that a HAHTsite class might have the same name as another (non- HAHTsite) package you have imported. You may wish to do the same. Adding server-side code to a Java project With Java, you can easily extend the functionality of your HAHTsite Web applications beyond what you can do with HTML or CGI programs. In a HAHTsite Java project, you can use Java in these ways: 1 You can add in-line code to a page, intermixed with other HAHTsite elements such as text, pictures, and forms. The code can be a simple expression, a single line, or a complete block of code. See In-line code on page You can insert expressions and method calls in many of the dialogs in the IDE for example, a text box can be initialized with the value of an expression, and a form s action can be a call to a Java method. See Invoking an expression or a method from a dialog box on page

34 Chapter 2: Working with Java Projects 3 You can insert code in predefined places within the Java source for a page, using the HTML editor s Server-side Code view. See Adding code in Server-side Code view on page You can modify or add to the source code for the HahtApplication and HahtSession classes. See Editing HahtApplication.java and HahtSession.java on page You can create or import separate Java source files, with classes and methods that can be shared by all of the pages in an project and that can be reused in other projects. In addition, you can import Java class files as well as JAR, CAB, and ZIP files. See Adding Java files to a project on page 26. HAHTsite Server Object Model Much of this book describes classes and methods in HAHTsite s Server Object Model, which controls the structure of a HAHTsite Web application. With the Server Object Model, you can perform tasks such as reading data passed on the URL, writing HTML data, and controlling session timeout, as well as managing data source connections, setting form field values, and controlling access to dynamic pages. The Server Object Model is implemented in Java. However, it is equally accessible from HAHTtalk Basic projects, and the online help for the Server Object Model shows both the Java and HAHTtalk Basic syntax to call each method. External logic From your Java code, you also have access to Java classes outside the project and to capabilities such as CORBA, COM objects, and native methods. For more information, see Chapter 13, Connecting to COM Objects and Chapter 14, HAHTsite CORBA Capabilities. In-line code The ability to intermix Java code with other elements (such as text, pictures, widgets, and form elements) gives you a powerful tool for dynamically changing the content of Web pages. You can use this technique for many purposes for example: to control the flow of logic on the page 13