Oracle® Configurator
`
`Oracle Configuration Interface Object (CIO) Developer’s Guide
`
`Release 11i
`
`March 2000
`Part No. A81001-03
`
`This document describes Functional Companions, which augment the
`functionality of an Oracle SellingPoint application, and the Oracle
`Configuration Interface Object (CIO), which is used by Functional Companions
`to access the Oracle Configurator Active Model.
`
`CONFIGIT 1004
`
`1
`
`

`

`Oracle Configuration Interface Object (CIO) Developer’s Guide, Release 11i
`
`Part No. A81001-03
`
`Copyright © 1996, 2000, Oracle Corporation. All rights reserved.
`
`Primary Author: Mark Sawtelle
`
`Contributors: Brent Benson, Jim Carlson, Ivan Lazarov, Marty Plotkin, Brian Ross
`
`The Programs (which include both the software and documentation) contain proprietary information of
`Oracle Corporation; they are provided under a license agreement containing restrictions on use and
`disclosure and are also protected by copyright, patent, and other intellectual and industrial property
`laws. Reverse engineering, disassembly, or decompilation of the Programs is prohibited.
`
`Program Documentation is licensed for use solely to support the deployment of the Programs and not for
`any other purpose.
`
`The information contained in this document is subject to change without notice. If you find any problems
`in the documentation, please report them to us in writing. Oracle Corporation does not warrant that this
`document is error free. Except as may be expressly permitted in your license agreement for these
`Programs, no part of these Programs may be reproduced or transmitted in any form or by any means,
`electronic or mechanical, for any purpose, without the express written permission of Oracle Corporation.
`
`If the Programs are delivered to the U.S. Government or anyone licensing or using the programs on
`behalf of the U.S. Government, the following notice is applicable:
`
`Restricted Rights Notice Programs delivered subject to the DOD FAR Supplement are "commercial
`computer software" and use, duplication, and disclosure of the Programs, including documentation,
`shall be subject to the licensing restrictions set forth in the applicable Oracle license agreement.
`Otherwise, Programs delivered subject to the Federal Acquisition Regulations are "restricted computer
`software" and use, duplication, and disclosure of the Programs shall be subject to the restrictions in FAR
`52.227-19, Commercial Computer Software - Restricted Rights (June, 1987). Oracle Corporation, 500
`Oracle Parkway, Redwood City, CA 94065.
`
`The Programs are not intended for use in any nuclear, aviation, mass transit, medical, or other inherently
`dangerous applications. It shall be the licensee's responsibility to take all appropriate fail-safe, backup,
`redundancy, and other measures to ensure the safe use of such applications if the Programs are used for
`such purposes, and Oracle Corporation disclaims liability for any damages caused by such use of the
`Programs.
`
`Oracle is a registered trademark, and Oracle SellingPoint Configurator is a trademark or registered
`trademark of Oracle Corporation. All other company or product names mentioned are used for
`identification purposes only and may be trademarks of their respective owners.
`
`2
`
`

`

`Contents
`
`List of Examples
`List of Figures
`List of Tables
`
`Send Us Your Comments ................................................................................................................... xi
`
`Preface........................................................................................................................................................... xiii
`Intended Audience ............................................................................................................................... xiii
`Structure................................................................................................................................................ xiv
`Related Documents.............................................................................................................................. xiv
`Conventions.......................................................................................................................................... xiv
`
`1 Functional Companions
`1.1
`What Are Functional Companions? ................................................................................... 1–1
`1.1.1
`Types of Functional Companions................................................................................ 1–1
`1.1.2
`Background to Building Functional Companions..................................................... 1–3
`1.2
`Functional Companions and the CIO................................................................................. 1–4
`1.2.1
`Using the CIO Interface................................................................................................. 1–4
`1.2.2
`Implementing Standard Interface Methods ............................................................... 1–5
`1.3
`Building Functional Companions in Java.......................................................................... 1–5
`1.3.1
`Procedure for Building Functional Companions in Java ......................................... 1–5
`1.3.2
`Installation Requirements for Java Functional Companions................................... 1–8
`1.3.2.1
`Requirements for Developing Functional Companions ................................... 1–8
`1.3.2.2
`Requirements for Running Functional Companions......................................... 1–8
`1.3.2.3
`Requirements for Testing Java Functional Companions .................................. 1–9
`1.3.3
`Minimal Example of a Java Functional Companion ................................................. 1–9
`1.4
`Building Functional Companions in COM..................................................................... 1–11
`
` iii
`
`3
`
`

`

`1.5
`1.5.1
`1.5.2
`1.5.2.1
`1.5.2.2
`1.5.2.3
`
`Incorporating Functional Companions in your Application ....................................... 1–13
`Associating Functional Companions with your Model......................................... 1–13
`Testing Functional Companions in the Oracle SellingPoint Application ........... 1–17
`Testing from the Windows Start Menu............................................................. 1–18
`Testing from Oracle Configurator Developer.................................................. 1–18
`Test Functionality in the Oracle SellingPoint Application............................. 1–18
`
`2 The Configuration Interface Object (CIO)
`2.1
`Background ........................................................................................................................... 2–1
`2.1.1
`What is the CIO?............................................................................................................ 2–1
`2.1.2
`The CIO and Functional Companions........................................................................ 2–2
`2.2
`The CIO’s Runtime Node Interface Classes...................................................................... 2–2
`2.3
`Initializing the CIO............................................................................................................... 2–4
`2.4
`Access to Configurations..................................................................................................... 2–6
`2.4.1
`Creating and Deleting Configurations....................................................................... 2–6
`2.4.2
`Saving and Restoring Configurations ........................................................................ 2–7
`2.4.3
`Access to Configuration Parameters .......................................................................... 2–8
`2.4.4
`Logic Transactions......................................................................................................... 2–8
`2.5
`Access to Nodes of the Model at Runtime........................................................................ 2–9
`2.5.1
`Accessing Components .............................................................................................. 2–10
`2.5.2
`Adding and Deleting Optional Components.......................................................... 2–10
`2.5.3
`Accessing Features ...................................................................................................... 2–10
`2.5.4
`Getting and Setting Logic States ............................................................................... 2–11
`2.5.5
`Getting and Setting Numeric Values........................................................................ 2–12
`2.5.6
`Accessing Properties ................................................................................................... 2–14
`2.5.7
`Access to Options ........................................................................................................ 2–14
`2.5.7.1
`Example for IOption ............................................................................................ 2–14
`2.6
`Introspection through IRuntimeNode............................................................................. 2–15
`2.7
`Handling Logical Contradictions..................................................................................... 2–17
`2.7.1
`Generating Error Messages from Contradictions................................................... 2–18
`2.7.2
`Overriding Contradictions......................................................................................... 2–18
`2.8
`Validating Configurations................................................................................................. 2–20
`2.9
`Standard Interface Methods for Functional Companions ............................................ 2–21
`2.9.1
`The initialize() Interface Method............................................................................... 2–22
`2.9.2
`The autoConfigure() Interface Method .................................................................... 2–24
`
`iv
`
`4
`
`

`

`2.9.3
`2.9.4
`2.9.5
`
`The validate() Interface Method................................................................................ 2–24
`The generateOutput() Interface Method.................................................................. 2–25
`The terminate() Interface Method............................................................................. 2–26
`
`3 Reference Documentation for the CIO
`
`4 Examples
`4.1
`Initializing the CIO................................................................................................................ 4–1
`4.2
`Basic Java Functional Companion ...................................................................................... 4–2
`4.3
`Thin-Client generateOutput() Functional Companion.................................................... 4–9
`
`Glossary
`
`Glossary of Acronyms
`
`A CIO Package and Related Classes
`
`B Package oracle.apps.cz.cio
`
`C Package oracle.apps.cz.common
`
`D Package oracle.apps.cz.utilities
`Index
`
`v
`
`5
`
`

`

`vivi
`
`6
`
`

`

`List of Examples
`1–1
`Elementary Java Functional Companion: MyClass.java ................................................. 1–9
`1–2
`COM Functional Companion ........................................................................................... 1–12
`2–1
`Initializing the CIO (Short Example).................................................................................. 2–5
`2–2
`Creating New Configuration Objects................................................................................. 2–7
`2–3
`Getting the state of a node ................................................................................................ 2–12
`2–4
`Setting the state of a node ................................................................................................. 2–12
`2–5
`Setting a numeric value ..................................................................................................... 2–13
`2–6
`Testing whether a node is selected, or satisfied............................................................. 2–16
`2–7
`Getting a child node by name........................................................................................... 2–16
`2–8
`Collecting all child nodes by type.................................................................................... 2–17
`2–9
`Handling and overriding Logical Exceptions ................................................................ 2–19
`4–1
`Initializing the CIO (Long Example) .................................................................................. 4–1
`4–2
`Basic Functional Companion: FuncCompTest1................................................................ 4–3
`4–3
`Thin-client Output Functional Companion.................................................................... 4–10
`
`vii
`
`7
`
`

`

`List of Figures
`1–1
`Associating a Component with a Functional Companion ........................................... 1–16
`1–2
`Functional Companion Rule: Detail of the Attributes view......................................... 1–17
`1–3
`Testing Functional Companions in the Oracle SellingPoint application. .................. 1–19
`1–4
`Modifying Functional Companion Buttons.................................................................... 1–20
`
`viii
`
`8
`
`

`

`List of Tables
`1–1
`Types of Functional Companions ...................................................................................... 1–2
`1–2
`Required Software for Functional Companions .............................................................. 1–8
`2–1
`Runtime node interface classes for the CIO .................................................................... 2–2
`2–2
`Methods of the Interface Class IOption ......................................................................... 2–14
`2–3
`Methods of the interface class IRuntimeNode.............................................................. 2–15
`2–4
`Standard methods of the IFunctionalCompanion interface........................................ 2–22
`
`ix
`
`9
`
`

`

`x
`
`10
`
`10
`
`

`

`Send Us Your Comments
`
`Oracle Configuration Interface Object (CIO) Developer’s Guide, Release 11i
`Part No. A81001-03
`
`Oracle Corporation welcomes your comments and suggestions on the quality and usefulness of this
`publication. Your input is an important part of the information used for revision.
` Did you find any errors?
`Is the information clearly presented?
` Do you need more information? If so, where?
` Are the examples correct? Do you need more examples?
` What features did you like most about this manual?
`
`
`
`If you find any errors or have any other suggestions for improvement, please indicate the chapter,
`section, and page number (if available). You can send comments through your call to Oracle Support
`Services or by sending them to:
` Oracle Configurator
` Oracle Corporation
` Documentation
` 21 North Avenue
` Burlington, MA 01803
` USA
`
`If you would like a reply, please give your name, address, and telephone number below.
`
`
`
`If you have problems with the software, please contact your local Oracle Support Services.
`
`xi
`
`11
`
`

`

`xiixii
`
`12
`
`12
`
`

`

`Preface
`
`You can use Functional Companions to augment the functionality of your Oracle
`SellingPoint application beyond what is provided by Oracle Configurator
`Developer. You create Functional Companion objects, which use the Configuration
`Interface Object (CIO) to perform various tasks, including accessing the Model,
`setting and getting logic states, and adding optional components. You can also use
`the CIO in your own applications, to interact with the Model.
`
`Intended Audience
`This manual is intended primarily for software developers writing Functional
`Companions. The language recommended for developing Functional Companions
`is Java.
`This manual assumes that you are an experienced programmer and that you
`understand Oracle databases, the SQL and Java programming languages, and the
`principles of JDBC.
`
`Note: For specialized purposes, Functional Companions can be
`written in Oracle’s GSL (Generative Specification Language), and
`by using COM with the Microsoft Java Virtual Machine. This is
`only possible on Windows 95/98 and Windows NT 4.0.
`
`This manual also provides background and reference information on the CIO,
`which is needed by developers of applications having customized user interfaces
`that need access to the Oracle Configurator Active Model.
`
`xiii
`
`13
`
`

`

`Structure
`
`
`
`This manual contains:
`Chapter 1, "Functional Companions"
`Chapter 2, "The Configuration Interface Object (CIO)"
`Chapter 3, "Reference Documentation for the CIO"
`
`
`
`
`
`
`
`Chapter 4, "Examples"
`
`Related Documents
`For more information, see the following manuals in Release 11i of the Oracle
`Configurator documentation set:
`
` Oracle SellingPoint Configurator Administration Guide
`
` Oracle Configurator Developer User’s Guide
`
` Oracle SellingPoint CompanionBuilder Help
`
` Oracle Configurator Developer Tutorial
`The following documents are also relevant:
`
` Oracle8i JDBC Developer's Guide and Reference
` Oracle White Paper: “Using COM with Oracle SellingPoint 4.2” (Available
`through Products Online, http://products.us.oracle.com. Look under “Supply
`Chain”, “SellingPoint”, “Collateral”.)
`
`Conventions
`In examples, an implied carriage return occurs at the end of each line, unless
`otherwise noted. You must press the Return key at the end of a line of input.
`The following conventions are also used in this manual:
`
`Convention
`
`Meaning
`
` .
` .
` .
`
`Vertical ellipsis points in an example mean that information not
`directly related to the example has been omitted.
`
`xiv
`
`14
`
`

`

`Convention
`
`Meaning
`
`. . .
`
`Horizontal ellipsis points in statements or commands mean that
`parts of the statement orcommand not directly related to the example
`have been omitted
`
`boldface text
`
`Boldface type in text indicates a term defined in the text, the glossary,
`or in both locations.
`
`< >
`[ ]
`
`>
`
`Angle brackets enclose user-supplied names.
`
`Brackets enclose optional clauses from which you can choose one or
`none.
`
`The left bracket alone sign represents the MS DOS prompt.
`
`xv
`
`15
`
`

`

`xvi
`
`16
`
`16
`
`

`

`1
`Functional Companions
`
`Functional Companions extend your Oracle SellingPoint application by attaching
`custom code through established interfaces.
`
`1.1 What Are Functional Companions?
`A Functional Companion is a programming object that you attach to your Model in
`order to extend the functionality of your Oracle SellingPoint application in ways
`that are not provided by Oracle Configurator Developer.
`You can write a Functional Companion object in several languages, depending on
`the functionality needed by your application. The Functional Companion
`communicates with your Model through an API (application programming
`interface) called the Configuration Interface Object (CIO). The Oracle Configuration
`Interface Object is written in Java. See Chapter 2, "The Configuration Interface
`Object (CIO)".
`You connect Functional Companions to specific nodes in your Model using Oracle
`Configurator Developer. You also specify the type of action that you want the
`specified Functional Companion to perform when your end users select its
`associated node. Then you generate the logic and user interface, as you normally do
`for your Oracle SellingPoint application. This action associates the Functional
`Companion with your application so that when your end users select a node in the
`Model, the Functional Companion on that node is automatically invoked.
`
`1.1.1 Types of Functional Companions
`You can assign a Functional Companion to perform any or all of these three types of
`actions:
`
`Functional Companions 1-1
`
`17
`
`

`

`What Are Functional Companions?
`
`Table 1–1
`Type
`
`Types of Functional Companions
`Description
`
`Auto-configuration
`
`Validation
`
`Output
`
`Configures the state of the Model. You can use this to modify
`the shape of the Model tree, and the state of its nodes. For
`instance, your application might gather initial needs
`assessment information and use it to set up the appropriate set
`of choices for your end user to make.
`In your Oracle SellingPoint application, your end user will
`explicitly choose to run an auto-configuration Functional
`Companion
`See Section 2.9.2, "The autoConfigure() Interface Method".
`
`Validates the logical choice that the end user has just made.
`The Functional Companion can perform complex operations
`beyond the scope of what you can develop in Oracle
`Configurator Developer. For instance, you can perform
`sophisticated numeric comparisons.
`A Java Functional Companion returns null if the validation is
`successful. If the validation fails, it returns a List of
`CompanionValidationFailure objects. A COM Functional
`Companion returns true if the validation is successful. If the
`validation fails, it returns a COM Array of Strings.
`In your Oracle SellingPoint application, all validation
`Functional Companions are run every time your end user
`chooses an Option. After each action, the end user gets the
`collection of strings returned by each Functional Companion
`that failed.
`Validation companions query the model to determine validity,
`but should not modify the model. Modifying the model in a
`validation Functional Companion can cause unexpected
`application failures.
`See Section 2.9.3, "The validate() Interface Method".
`
`Generates some form of output from the configuration. This
`output might be a report, a performance graph, a geometric
`rendering, or a graphical representation of the configuration.
`In your Oracle SellingPoint application, your end user will
`explicitly choose to run an output Functional Companion.
`See Section 2.9.4, "The generateOutput() Interface Method".
`
`1-2 Oracle Configuration Interface Object (CIO) Developer’s Guide
`
`18
`
`

`

`What Are Functional Companions?
`
`1.1.2 Background to Building Functional Companions
`To build a Functional Companion, you implement an object class in the language
`that you choose as being most appropriate for the operation that you want to
`perform. The language choices are:
`
`Java
`
`GSL
`
`COM
`
`This is the recommended choice for developing Functional
`Companions. Java Functional Companions can run on any
`platform supported by Java. The other language choices are
`recommended only for special purposes.
`GSL (Generative Specification Language) is an Oracle
`proprietary object-oriented dynamic language recommended
`primarily for geometric visualization and modeling. Using it
`requires CompanionBuilder, which is only available on
`Windows 95/98 and Windows NT 4.0. The resultant
`Functional Companions can only be used in a “fat client”
`deployment, not, for example, in a web browser.
`Functional Companions can be written to the Microsoft COM
`standard (using Visual Basic, for instance), but are restricted to
`Windows 95/98 and Windows NT 4.0, and require the
`Microsoft Java Virtual Machine.
`
`When an Oracle SellingPoint application runs, it creates an instance of the CIO,
`which creates runtime instances of all the Components in the Model. If you used
`Oracle Configurator Developer to associate a Functional Companion with a
`Component, then the application creates, for each instance of that Component, an
`instance of the class that you defined for your Functional Companion and attaches
`the Functional Companion instance to the Component.
`You can associate more than one Functional Companion with a particular
`Component; the CIO will create instances of all of them.
`If any Functional Companions cannot be loaded when you create a new
`configuration (for instance, due to internal errors or an incorrect CLASSPATH), the
`configuration will fail to open.
`You can also associate Functional Companions with Products.
`For Functional Companions built with Java, you implement a class that extends
`oracle.apps.cz.cio.FunctionalCompanion. See Section 1.3, "Building
`Functional Companions in Java".
`
`
`
`Functional Companions 1-3
`
`19
`
`

`

`Functional Companions and the CIO
`
`
`
`
`
`For Functional Companions built with COM, you implement an object that
`supports IDispatch. See Section 1.4, "Building Functional Companions in COM".
`For details and more background, see the Oracle White Paper “Using COM
`with Oracle SellingPoint 4.2”.
`For Functional Companions built with (GSL) (the Generative Specification
`Language), you implement a library object to be used as the basis of the
`companion instances. See the Oracle SellingPoint CompanionBuilder Help for
`details.
`For all language choices, you also implement one or more of the standard
`interface methods of oracle.apps.cz.cio.IFunctionalCompanion,
`which are described in Section 2.9, "Standard Interface Methods for Functional
`Companions".
`In order to communicate with the Model of your application, the Functional
`Companion uses Oracle’s CIO API. The CIO can also be used to develop a custom
`user interface for an Oracle SellingPoint application, in order to access the Model.
`As a point of information, both Oracle Configurator Developer and the default user
`interface for the Oracle SellingPoint application communicate in just this way with
`the Model, using the Oracle Configurator Database to store structure, rules, and
`user interface information (in addition to your end user’s data).
`
`
`
`1.2 Functional Companions and the CIO
`Functional Companions are invoked by the CIO through the Oracle SellingPoint
`application, and Functional Companions call the CIO to get information from the
`Active Model. The CIO is like a broker for the Active Model, in that it passes
`information both ways. Programmers writing Functional Companions need to
`know how to use the CIO.
`Each Functional Companion is an object class. For every Component instance in
`your Model that is associated with a Functional Companion, the CIO creates an
`instance of this class.
`
`1.2.1 Using the CIO Interface
`Your Functional Companion is a client of the CIO. When you program against the
`CIO, you create instances of a set of public interface objects, which are defined in
`oracle.apps.cz.cio.
`Your code should refer only to these public interface objects. See Section 2.2, "The
`CIO’s Runtime Node Interface Classes".
`
`1-4 Oracle Configuration Interface Object (CIO) Developer’s Guide
`
`20
`
`

`

`Building Functional Companions in Java
`
`Reference
`For reference documentation, see: Package oracle.apps.cz.cio.
`
`1.2.2 Implementing Standard Interface Methods
`You provide functionality for your Functional Companion by implementing body
`code for the methods:
`initialize
`
`
`
`
`
`
`
`
`
`
`
`autoConfigure
`
`validate
`
`generateOutput
`
`terminate
`
`These methods are described in Section 2.9, "Standard Interface Methods for
`Functional Companions".
`For particulars that apply to the languages currently supported by the CIO, and
`examples, see Section 1.3, "Building Functional Companions in Java", and the
`Oracle SellingPoint CompanionBuilder Help.
`
`1.3 Building Functional Companions in Java
`
`1.3.1 Procedure for Building Functional Companions in Java
`Here is an overview of the tasks for Building Functional Companions in Java. See
`also Section 1.3.2, "Installation Requirements for Java Functional Companions".
`1. Use a Java development environment or text editor to create a .java file in which
`to define a Java class.
`Import the classes for the CIO (oracle.apps.cz.cio.*).
`
`2.
`
`import oracle.apps.cz.cio.*;
`
`3. Define a class in which to determine the behavior of your Functional
`Companion.
`Here is the relevant line from Example 1–1:
`
`public class MyClass extends FunctionalCompanion // line 6
`
`Functional Companions 1-5
`
`21
`
`

`

`Building Functional Companions in Java
`
`When you define your Functional Companion class, you can do one of the
`following:
` Normally: Extend the base class for Functional Companions—
`oracle.apps.cz.cio.FunctionalCompanion—and override just the
`particular methods that you need. In this case, you gain the functionality of
`the FunctionalCompanion base class. This functionality includes: saving
`references to the runtime node with which the Functional Companion is
`associated (with the FunctionalCompanion.getRuntimeNode()
`method), and returning the name of the Functional Companion (with the
`FunctionalCompanion.getName() method). See the reference for:
`FunctionalCompanion.
` More rarely: Implement the interface class for Functional
`Companions—oracle.apps.cz.cio.IFunctionalCompanion—and
`implement all its methods. You do not extend
`oracle.apps.cz.cio.FunctionalCompanion. In this case, you lose
`the functionality of the FunctionalCompanion base class. See the
`reference for: FunctionalCompanion.
`4. You may want to override
`oracle.apps.cz.cio.FunctionalCompanion.initialize(). (See
`Section 2.9.1, "The initialize() Interface Method".)
`You should ordinarily never directly call
`FunctionalCompanion.initialize(), since the CIO does that for you.
`However, if your Functional Companion overrides FunctionalCompanion
`as its base class, then the initialize() method of your class should call
`super.initialize(). This passes some necessary variables to the superclass
`(oracle.apps.cz.cio.FunctionalCompanion) so that its methods will
`work.
`For an example in context, see Line 35 in Example 4–2, "Basic Functional
`Companion: FuncCompTest1" on page 4-2, which is shown below:
`
`public void initialize(IRuntimeNode comp_node, String name, String
`description, int id)
`
`{ t
`
`his.comp_node = comp_node;
`super.initialize(comp_node, name, description, id); // line 35
`}
`5. Override one or more of the other interface methods of
`oracle.apps.cz.cio.IFunctionalCompanion (see Section 2.9, "Standard
`Interface Methods for Functional Companions"):
`
`1-6 Oracle Configuration Interface Object (CIO) Developer’s Guide
`
`22
`
`

`

`Building Functional Companions in Java
`
`autoConfigure
`validate
`generateOutput
`terminate
`
`For examples in context, see Example 4–2, "Basic Functional Companion:
`FuncCompTest1" on page 4-2:
`
`public void autoConfigure()
`
`public List validate()
`
`public String generateOutput()
`
`6. Optionally, call the methods of the other interface classes of the CIO (see
`Section 2.2, "The CIO’s Runtime Node Interface Classes").
`
`Note: Basic Functional Companions, ones that only use the
`standard interface methods listed in step 5, do not need to use the
`interface classes of the CIO.
`
`7. Compile the .java file into a .class file for example, with JDK 1.1.x:
`javac FuncCompTest1.java
`
`8. Put the resulting .class file in your classpath, or into a JAR file in your classpath.
`For example:
`
`jar cvf FuncComps.jar FuncCompTest1.class
`
`set CLASSPATH=%CLASSPATH%;D:\companions\FuncComps.jar
`
`9. Run Oracle Configurator Developer with this classpath. Associate your
`Functional Companion with a Component in your Model. See Section 1.5,
`"Incorporating Functional Companions in your Application" on page 1-13.
`Generate the Active Model and User Interface.
`10. To test your Functional Companion, click the Test button in Oracle Configurator
`Developer. When the Oracle SellingPoint application runs, click the buttons that
`have been generated in the UI for activating your Functional Companions. See
`Section 1.5.2, "Testing Functional Companions in the Oracle SellingPoint
`Application" on page 1-17.
`
`Functional Companions 1-7
`
`23
`
`

`

`Building Functional Companions in Java
`
`1.3.2 Installation Requirements for Java Functional Companions
`
`1.3.2.1 Requirements for Developing Functional Companions
`In order to develop Java Functional Companions, you must install a Java
`development environment that enables you to compile Java classes, such as:
` Oracle JDeveloper
`Sun JDK 1.1.x or JDK 1.2.x (JDK 1.1.x is recommended for compatibility with
`Oracle Applications Release 11i)
` Microsoft Visual J++
`You do not need JDBC drivers or database access to compile a Functional
`Companion, although these are required to run one.
`
`
`
`
`
`1.3.2.2 Requirements for Running Functional Companions
`At runtime, an Oracle SellingPoint application using Functional Companions
`requires:
`The Microsoft Java Virtual Machine (JVM)
` Microsoft JDBC/ODBC drivers
` An ODBC datasource
`The Oracle SellingPoint application automatically sets up a JDBC database
`connection for use by the CIO. Custom user interfaces that take the place of the
`Oracle SellingPoint application must perform this task. See Section 2.3, "Initializing
`the CIO" for details.
`In order to run Java Functional Companions, the software described in Table 1–2
`must be installed and recognized by your operating system environment in the
`indicated locations.
`
`Table 1–2 Required Software for Functional Companions
`File name
`Location
`Required for
`Source
`
`config.jar
`
`CLASSPATH Any use of CIO.
`
`Oracle Configurator (OC)
`installation.
`
`confw32.jar
`
`CLASSPATH Functional Companions
`using