HTML for use in web browsers or as WML for use in mobile devices.

Classes for UIX Components are in the oracle.cabo.ui package.

uiXML: This is an XML language for programming UIX applications.

uiXML provides a declarative way of creating web applications
programmatically using UIX Java APIs. The pages, events, and any
other items defined with uiXML elements are all transformed into Java
objects behind the scenes. Below is an example of a uiXML element
(button):
<button destination=http://www.abc.com/index disabled=false
text=goBtn>
</button>
uiXML documents are written in a text format, where document
represents page or a region.
Classes supporting uiXML are located
in oracle.cabo.ui.xml andoracle.cabo.servlet.xml packages.
Pages in UIX
===================
On the browser, page is just collection of HTML elements. However,
while in developing phase, concept of page can be more complex,
depending upon the declarative way used to create the page and
renderers used.
A UIX page consists of a hierarchical set of components known as UI
nodes. Some nodes define visible components, such as buttons,
images, text fields, while others organize the layout and appearance of
other nodes.
Nodes can have parents and children, and multiple nodes together
form a tree-like structure used to represent a pages logical

structure.For example, left part below figure shows a logical hierarchy

of UI nodes and right part shows the same hierarchy rendered as an
HTML page.

Now in UIX, there is a java class for each UI nodes. These classes
implement the UINode interface in the oracle.cabo.ui package. The
UINode interface contains methods for the characteristics of nodes,
such as:
public int getIndexedChildCount(RenderingContext context);
public UINode getIndexedChild(RenderingContext context, int
childIndex);
public Enumeration getAttributeNames(RenderingContext context);
public Object getAttributeValue(RenderingContext context,
AttributeKey attrKey);

Oracle Application Framework Training Material

1 OAF ARCHITECTURE
OA Framework is based on the industry-standard J2EE MVC Design Pattern.
M Model

V - View
C - Controller
Developers manipulate the applications metadata using Oracle 9i JDeveloper
OA Extension, while OA Framework uses the most efficient manner to
execute the application.
The MVC architecture is a component-based design pattern with clean
interfaces between the Model, View and Controller.
The Model is where the application implements its business logic.
The View is where the application implements its user interface.
The Controller is where the application handles user interaction and directs
business flow.
Find the following MVC diagram to understand relationship between Model,
View and Controller.
1.1

About Model

The OA Framework Model

Components for Java (BC4J).

is

implemented

using

Oracle

Business

BC4J provides optimized, ready-to-use implementations of the J2EE design

patterns.
Development teams can focus immediately and only, on writing business
logic and user interfaces instead of designing, coding, and debugging
handcrafted application plumbing code.
1.2

About View

The OA Framework View is implemented using UI XML (UIX).

UIX uses XML to describe the components and hierarchy that make up an
application page.
UIX provides runtime capabilities to translate that metadata into HTML
output so that it can be shown on a Browser.
The metadata used to describe the UI is loaded into a database repository,
called Meta Data Services (MDS), at deployment time and optionally at
design time as well.
1.3

About Controller

User and Application-driven interactions are handled by the OA Controller,

which is pure Java Class implementation.

Within the Model-View-Controller architecture, the OA Framework draws a

clear distinction between client and server classes.
Client classes (View and Controller) drive the HTML user interface.
Server classes (Model code) can support any client (not just OA
Framework user interfaces)
2. Key Features

Integrated Development Environment

Durable Personalizations and Extensions
Consistent and Compelling User Interface
Object Oriented Reuse

2.1 Integrated Development Environment (IDE)

Oracle 9i JDeveloper with OA Extension is a world-class J2EE-based
integrated development environment. Oracle customers and third party
consultants have access to the same tools used by Oracle E-Business Suite
developers to build complementary applications as well as extend the Oracle
E-Business Suite applications.
2.2 Durable Personalizations and Extensions
Personalization is about declaratively tailoring the UI look-and-feel, layout or
visibility of page content to suit a business need or a user preference.
Personalization can be done at several levels by one of three authors:
Application Developer
Application Administrator
End User
Examples:
Tailoring the color scheme of UI (UI means User Interface)
Tailoring the order in which table columns are displayed.
Tailoring a query result
Extensibility is about extending the functionality of an application beyond
what can be done through personalization.
Examples:
Adding new functional flows
Extending or overriding existing functional flows
Extending or overriding existing business logic

2.3 Consistent and Compelling User Interface

OA Framework offers developers a wide range of user interface components
that make the building of applications into a more assembly process, freeing
developers from the repetitive composition of common user interface
constructs.
OA Framework user interface components range from simple widgets such as
buttons and fields to compound components such as tables-in-tables and
hierarchical grids.
2.4 Object Oriented Reuse
OA Framework applications can be abstracted into a series of concentric
layers, like an onion.
(Note: Describe the objects mentioned in diagram in the following pages)

Each layer only knows about the layers below it.

This encapsulation allows reuse at any of the layer boundaries.

On User Interface Side, reusable components can be saved as Shared

regions in the MDS repository and reused across several pages.
Example for Shared region is LOV (list of values).
It is independent object. We can attach the same LOV to text item in several
pages.