Release 10.1A: OpenEdge Development:
Open Client Introduction and Programming

> ## Preface

> This Preface contains the following sections:

> - Purpose

> - Audience

> - Organization

> - Typographical conventions

> - Examples of syntax descriptions

> ### Purpose

> The AppServer™ for OpenEdge® applications excels at encapsulating business functions written in the Progress® 4GL and making them available to 4GL client applications anywhere on an enterprise network. With the Open Client Toolkit (a component of Progress OpenEdge Studio), you can now extend your departmental applications (for example, written in .NET) or your Web-enabled applications written in Java™ to work with the same business functions used by your Progress enterprise applications.

> Using the Open Client Toolkit, you can create Open Client interfaces to a Java or .NET application or a Web service definition, to access the business functions on an AppServer. This guide describes how to use the tools provided with the Open Client Toolkit to accomplish this task.

> ### Audience

> This guide assumes that you are experienced in programming Java applications and applets, .NET applications, or Web services for your development and deployment environment, and that you have access to documentation on OpenEdge Release 10, especially OpenEdge Application Server: Developing AppServer Applications and its prerequisites.

> Before building an application with the help of the Open Client Toolkit, you should be familiar with the information provided by the first two chapters of OpenEdge Application Server: Developing AppServer Applications .

> ### Organization

> Chapter 1 "Overview"

> Describes the basic mechanisms provided to access AppServer functionality from a non-Progress (Open Client) application.

> Chapter 2 "Configuration"

> Details the configuration requirements for developing Open Client applications.

> Chapter 3 "Generating Proxies and Web Service Definitions"

> Explains how to use the Open Client Proxy Generator (ProxyGen) to encapsulate any 4GL API available on an AppServer for access by an Open Client application, and how to manage the result for the application environment.

> Chapter 4 "Programming Concepts"

> Describes the mechanisms and techniques available to access the functionality encapsulated by ProxyGen from all Open Client applications.

> ### Typographical conventions

> This manual uses the following typographical conventions:

> Convention | Description
> --- | ---
> Bold | Bold typeface indicates commands or characters the user types, provides emphasis, or the names of user interface elements.
> Italic | Italic typeface indicates the title of a document, or signifies new terms.
> SMALL, BOLD CAPITAL LETTERS | Small, bold capital letters indicate OpenEdge® key functions and generic keyboard keys; for example, GET and CTRL.
> KEY1+KEY2 | A plus sign between key names indicates a simultaneous key sequence: you press and hold down the first key while pressing the second key. For example, CTRL+X.
> KEY1 KEY2 | A space between key names indicates a sequential key sequence: you press and release the first key, then press another key. For example, ESCAPE H.
> Syntax:
> `Fixed width` | A fixed-width font is used in syntax statements, code examples, system output, and filenames.
> `Fixed-width italics` | Fixed-width italics indicate variables in syntax statements.
> `Fixed-width bold` | Fixed-width bold indicates variables with special emphasis.
>     UPPERCASE
>     fixed width
> | Uppercase words are Progress® 4GL language keywords. Although these are always shown in uppercase, you can type them in either uppercase or lowercase in a procedure.
> | This icon (three arrows) introduces a multi-step procedure.
> | This icon (one arrow) introduces a single-step procedure.
> Period (.) or colon (:) | All statements except `DO`, `FOR`, `FUNCTION`, `PROCEDURE`, and `REPEAT` end with a period. `DO`, `FOR`, `FUNCTION`, `PROCEDURE`, and `REPEAT` statements can end with either a period or a colon.
> [ ] | Large brackets indicate the items within them are optional.
> [ ] | Small brackets are part of the Progress 4GL language.
> { } | Large braces indicate the items within them are required. They are used to simplify complex syntax diagrams.
> { } | Small braces are part of the Progress 4GL language. For example, a called external procedure must use braces when referencing arguments passed by a calling procedure.
> | | A vertical bar indicates a choice.
> ... | Ellipses indicate repetition: you can choose one or more of the preceding items.

> ### Examples of syntax descriptions

> In this example, `ACCUM` is a keyword, and `aggregate` and `expression` are variables:

> Syntax
>     ACCUM aggregate expression

> `FOR` is one of the statements that can end with either a period or a colon, as in this example:

>     FOR EACH Customer:
>       DISPLAY Name.
>     END.

> In this example, `STREAM` `stream`, `UNLESS-HIDDEN`, and `NO-ERROR` are optional:

> Syntax
>     DISPLAY [ STREAM stream ] [ UNLESS-HIDDEN ] [ NO-ERROR ]

> In this example, the outer (small) brackets are part of the language, and the inner (large) brackets denote an optional item:

> Syntax
>     INITIAL [ constant [ , constant ] ]

> A called external procedure must use braces when referencing compile-time arguments passed by a calling procedure, as shown in this example:

> Syntax
>     { &argument-name }

> In this example, `EACH`, `FIRST`, and `LAST` are optional, but you can choose only one of them:

> Syntax
>     PRESELECT [ EACH | FIRST | LAST ] record-phrase

> In this example, you must include two expressions, and optionally you can include more. Multiple expressions are separated by commas:

> Syntax
>     MAXIMUM ( expression , expression [ , expression ] ... )

> In this example, you must specify `MESSAGE` and at least one `expression` or `SKIP` [ (`n`) ], and any number of additional `expression` or `SKIP` [ ( `n` ) ] is allowed:

> Syntax
>     MESSAGE { expression | SKIP [ ( n ) ] } ...

> In this example, you must specify {`include-file`, then optionally any number of `argument` or `&argument-name = "argument-value"`, and then terminate with }:

> Syntax
>     { include-file
>         [ argument | &argument-name = "argument-value" ] ... }

> #### Long syntax descriptions split across lines

> Some syntax descriptions are too long to fit on one line. When syntax descriptions are split across multiple lines, groups of optional and groups of required items are kept together in the required order.

> In this example, `WITH` is followed by six optional items:

> Syntax
>     WITH [ ACCUM max-length ] [ expression DOWN ]
>       [ CENTERED ] [ n COLUMNS ] [ SIDE-LABELS ]
>       [ STREAM-IO ]

> #### Complex syntax descriptions with both required and optional elements

> Some syntax descriptions are too complex to distinguish required and optional elements by bracketing only the optional elements. For such syntax, the descriptions include both braces (for required elements) and brackets (for optional elements).

> In this example, `ASSIGN` requires either one or more `field` entries or one `record`. Options available with `field` or `record` are grouped with braces and brackets:

> Syntax
>     ASSIGN   { [ FRAME frame ] { field [ = expression ] }
>                 [ WHEN expression ] } ...
>            | { record [ EXCEPT field ... ] }

Copyright © 2005 Progress Software Corporation www.progress.com Voice: (781) 280-4000 Fax: (781) 280-4095