6 Overview of Oracle ADF Data Binding in View Technologies

6.2.1 Differences Between JSP Pages and UIX XML Documents

UIX XML is an XML language for defining the user interface of a web application using a rich set of Oracle ADF UIX components. A UIX XML document has the file extension .uix, and the file contains a declarative description of the UIX components that define the layout, navigation, and content of a single web application page. At runtime, the UIX servlet interprets the UIX XML documents and renders the appropriate output for the browser or device that requested the page.

In JDeveloper you can use the UIX Visual Editor to visually create your UIX web pages by adding and arranging UIX user interface components, and then test and run your application. JDeveloper also provides wizards to help you build individual UIX pages, and it provides UIX XML template (UIT) files for quicker development. Additionally, because UIX is part of Oracle ADF, it supports data binding of diverse business sources.

JavaServer Pages (JSP) technology is based on Java servlets and, like Java servlets, JSP is a server-side technology. A key difference between JSP pages and servlets is that JSP pages keep static page presentation and dynamic content generation separate. JSP web page designers use:

• HTML tags to design and format the dynamically generated web page

• JSP standard tags or Java-based scriptlets to call other components that generate the dynamic content on the page

• JSP tags from custom tag libraries that generate the dynamic content on the page

UIX JSP provides a tag library that invokes UIX components via a set of tags from a JSP 1.2–compliant tag library. The JSP tags generate the HTML to render tabs, buttons, tables, headers, and other layout and navigational components.

A JSP page has the extension .jsp. This extension notifies the web server that the page should be processed by a JSP container. The JSP container interprets the JSP tags and scriptlets, generates the content required, and sends the results back to the client as an HTML or XML page.

JDeveloper provides data binding, tag insight, and other editing features for both technologies.

Some of the key differences are:

• UIX XML exposes a larger set of functionality, as the UIX JSPs are a JSP interface to a subset of the UIX UI components. The JSP tags implement only a subset of the UIX elements and only a subset of the attributes.

• UIX XML provides more powerful templating mechanisms. You can create your own templates in JDeveloper and then build your application pages based on these templates.

6.3.1 Overview of Data Control Palette Usage

In the case of client documents, the hierarchical structure of the business services displayed is determined by:

• Which business services you have registered with the data controls in your model project. The palette displays a separate root node for each business service that you register:

  • Oracle Business Components application modules

  • EJB session beans

  • TopLink mappings–based beans

  • Standard JavaBeans classes

  • Web services

• A bean design time description that is generated in an .xml definition file when you create the data control for the bean. The bean's XML definition classifies the bean's property accessors and methods into various categories described below.

  
  

  Note: In the case of Oracle ADF BC, the Oracle ADF BC application modules in your model project are automatically published as a data control. Their XML metadata file already contains the information needed by the Oracle ADF BC data control and no additional XML definition files are required when you create the model project. In the case of web services, no bean is involved and the XML definition describes only methods exposed by the web service.

  
  

At design time, the Data Control Palette provides the first step to lay out the client user interface and prepare the Oracle ADF bindings. The task of selecting a business object, choosing a visual element for the service, and dropping it into the page generates these items:

• A visual element, which is defined by source code to access the bindings in the client document (HTML and tags for JSP pages, UIX components for UIX XML pages, or Java method calls for JClient-generated panels and forms).

• A binding container when one does not yet exist for the page. The binding container is an XML file that appears in the directory corresponding to the package currently set to the project's default package. (To modify the default package, select the project node in the Application Navigator and display the Property Inspector, where you can set the defaultPackage property.)

• An appropriate binding definition to support the visual element. The binding definition is added to the binding container.

Note that, as an alternative, you can also create bindings in the JDeveloper Structure window, which you later reference in your source code, without dragging and dropping from the Data Control Palette.

The code that the Data Control Palette generates in your client document and the bindings that it creates depend on:

• The type of document displayed in the visual editor (must be a JSP page, UIX page, or JClient-generated panel or form)

• The combination of business service and visual element you select and drop into the open document

After you have completed laying out the client document with the Data Control Palette, you can view and customize the individual binding definitions.

6.3.2 Overview of the Data Control Business Objects

The root node of the Data Control Palette represents the data control registered for the business service. While the data control itself is not an item you can select, you may select among the operations it supports. All data control–specific operations appear in the Operations folder of the root node. You can work with this type of operation when you want to perform an operation that applies across the Oracle ADF binding context, such as the commit and rollback operations provided by the data control for Oracle ADF BC.

Proceeding down the hierarchy from the root data control node, the palette represents bean-based business services as either:

• Attributes, such as bean properties, which can define simple scalar value objects, structured objects (beans), or collections

  OR

• Operations, such as bean methods, which may or may not return a value or take method parameters

An exception to this hierarchy is the web services, for which the Data Control Palette displays only operations.

In the Data Control Palette, attributes and operations are represented by the following specific icons. Note that icons which appear more than once represent various accessor return types and may be supported by a different set of visual elements, as shown in the following table:

Icon	Description	Visual Element Choices
	An attribute that represents a scalar value (such as simple Integer or String objects).	The full list of attribute-bound visual elements, such as text input, checkbox, choice list, and radio buttons. These choices vary depending on the document type you create.
	An accessor attribute that represents a collection of scalar values (such as ones that provide an array of Integers or a list of Strings).	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.
	An accessor attribute that represents a collection of structured objects that contain attributes and operations (such as a collection of employee objects)	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.
	An accessor attribute that represents a collection of structured objects that contain only operations and no attributes (such as a collection of service beans).	Read-only dynamic table and navigation buttons for JSP, more choices for UIX, and the full list of collection-bound controls for JClient.
	An accessor attribute that returns a structured object that contains attributes and operations (such as an address object).	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.
	An accessor attribute that returns a structured object that contains only operations and no attributes (such as a service bean).	Read-only dynamic table and navigation buttons for JSP, more choices for UIX, and the full list of collection-bound controls for JClient.
	An operation which may or may not take parameter values (such as a Java method on a bean).	Button or a button with form (JSP), submit button (UIX), button (JClient).
	Built-in operations (such as navigate to row and execute).	Button or a button with form (JSP), submit button (UIX), button (JClient).
	Built-in operations to pass the primary key value of a row set (such as set current row with key)	Button or a button with form (JSP), submit button (UIX), button (JClient).

In the Data Control Palette, operations that specify return values are represented by the following specific icons. The specific object returned determines which visual elements are available as shown in the following table:

Icon	Description	Visual Element Choices
	An operation that returns a scalar value (such as simple Integer or String objects).	Show result read-only visual element for JSP and UIX. The full list of attribute-bound controls for JClient
	An operation that returns a collection of scalar values (such as ones that provide an array of Integers or a list of Strings).	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.
	An operation that returns a collection of structured objects that contain attributes and operations (such as a collection of employee objects).	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.
	An operation that returns a collection of structured objects that contain only operations and no attributes (such as a collection of service beans).	Read-only dynamic table and navigation buttons for JSP, more choices for UIX, and the full list of collection-bound controls for JClient.
	An operation that returns a structured object that contains only operations and no attributes (such as a service bean).	Read-only dynamic table and navigation buttons for JSP, more choices for UIX, and the full list of collection-bound controls for JClient.
	An operation that returns a structured object that contains attributes and operations (such as an address object).	The full list of collection-bound visual elements, such as table, graph, navigation buttons, and forms. These choices vary depending on the document type you create.

Note that, depending on the business service definition, method returns which appear in the Data Control Palette may be redundant with the data control attributes defined for the business service. When a choice is available, it is preferable to select the attribute and accessor nodes rather than method returns. Only data control attributes and accessors provide full support for the Oracle ADF bindings. Iterator bindings, for example, are not available for method returns.

6.3.3 Overview of Oracle ADF Project Files

When you build an Oracle ADF–based application using the JDeveloper design time tools, JDeveloper generates project files specific to Oracle ADF, as shown in the following figure:

<DataControlConfigs
   id="DataControls"
   xmlns="http://xmlns.oracle.com/adfm" >
   <Contents>
      <DataControl
            id="ClassNameDataControl | AppModuleDataControl |
                PXWebServiceNameDataControl"
         
            <!-- Indicates for the ADF design time the class to use to represent
                  the data control on the Data Control Palette. -->
                  SubType="DCBC4J | DCJavaBean | DCWebService"
         
            <!-- Indicates whether the data control for the business service 
               supports query-by-example. This enables the find operation choice 
              in the Data Control Palette for this data control and the
              associated services. Not used by ADF. -->
                  SupportsFindMode="true | false"
         
            <!-- Indicates whether the data control for the business service
                supports transaction semantics. This enables commit and rollback
                  operations on the data control. -->
                  SupportsTransactions="true | false"
             <!-- Oracle ADF Business Components definitions, including the
                package, the bc4j.xcfg configuration, and the factory class. -->
                  Package="model"
                  Configuration="AppModuleLocal" 
                  FactoryClass="oracle.adf.model.bc4j.DataControlFactoryImpl"

             <!-- Standard Bean definitions, including the factory class,
                  the XML definition file, and the bean class file. -->
                  FactoryClass="oracle.adf.model.generic.DataControlFactoryImpl"
                  Definition="model.Class1"
                  BeanClass="model.Class1" >
      </DataControl>
   </Contents>
</DataControlConfigs>

<DCContainer
   id="PageNameUIModel"
   xmlns="http://xmlns.oracle.com/adfm"
   Package="view"
   
   <!-- Indicates whether find mode should be enabled for the page. -->
        FindMode="false | true"
   
   <!-- Indicates whether to check the currency of the bound collection.
        This ensures that row updates will be applied to the correct row. -->
        EnableTokenValidation="true | false" >
   
   <Contents >
      <DCIterator
         id="MyDataCollection1Iterator"
         Binds="BusinessServiceDataControl.MyDataCollection"
         <!-- Indicates the number of rows to display from bound collection. -->
         RangeSize="10"
      </DCIterator>
      <DCControl
         id="MyBusinessServiceName"
         Subtype="DCBindingType"
         IterBinding="MyDataCollection1Iterator" >
         <AttrNames>
            <Item Value="MyAttribute1" />
            <Item Value="MyAttribute2" />
         </AttrNames>
      </DCControl>
 </DCContainer>

<JboProject
   id="DataBindings"
   xmlns="http://xmlns.oracle.com/adfm"
   
   <!-- Indicates that the components of this project may appear 
         in separate XML files. Not used by ADF. -->
         SeparateXMLFiles="false"
   
   <!-- Used by JClient applications to locate a bc4j.xcfg file. For backwards 
        compatibility. -->
        Package=""
   
   <!-- Indicates whether the ADF bindings use generic classes or   
        JClient-specific classes. -->
        ClientType="Generic | JClient" >
   
   <Contents>
      <DataControl
         id="ClassNameDataControl | AppModuleDataControl | 
                           PXWebServiceNameDataControl"

             <!-- Indicates for the ADF design time the class to use to
                  represent the data control on the Data Control Palette. -->
                  Subtype="DCBC4J | DCJavaBean | DCWebService"
         
             <!-- Indicates whether the data control for the business service 
                  supports query-by-example. This enables the find operation
                  choice in the Data Control Palette for this data control and
                  the associated services. Not used by ADF. -->
                  SupportsFindMode="true | false"
         
             <!-- Indicates whether the data control for the business service
                  supports transaction semantics. This enables commit and
                  rollback operations on the data control. -->
                  SupportsTransactions="true | false"


             <!-- Oracle ADF Business Components definitions, including the
                  package, the bc4j.xcfg configuration, and the factory
                  class.-->
                  Package="model"
                  Configuration="AppModuleLocal" >
                  FactoryClass="oracle.adf.model.bc4j.DataControlFactoryImpl"

             <!-- Standard Bean definitions, including the factory class,
                  the XML definition file, and the bean class file. -->
                  FactoryClass="oracle.adf.model.generic.DataControlFactoryImpl"
                  Definition="model.Class1"
                  BeanClass="model.Class1" >
         
             <!-- Indicates whether the Application Module synchronization will
                  use Batch mode or Immediate mode. -->
                  <Parameters >
                    <Parameter
                       name="Sync"
                       value="Batch" >
                    </Parameter>
                  </Parameters>
      </DataControl>
      
      <!-- References the binding containers to create from the UI Model
           definition files. This allows the .cpx file to create the binding 
           context for the application at runtime. -->
           <Containee
               id="MyPage1UIModel"
               ObjectType="BindingContainerReference"
               FullName="view.MyPage1UIModel" >
           </Containee>
           <Containee
               id="MyPage2UIModel"
               ObjectType="BindingContainerReference"
               FullName="view.MyPage2UIModel" >
           </Containee>
              ...
   </Contents>
</JboProject>

6.5.1 About Data Binding in JClient

Data binding in JClient is the ability to create Swing containers and components that are bound to data in back-end business services. To enable data binding, JClient provides a small API that works with the Oracle ADF model layer. The API is exposed in the application source code through a combination of JClient bootstrap code:

• Call loadCpx() to load the application metadata (specified in the DataBindings.cpx file), which specifies a connection to the business service implementation instance (for example, a Business Components application module instance) through the Oracle ADF data control and the Oracle ADF binding context.

• Call setBindingContext() to make the Oracle ADF binding context available to the frame or panel.

• Call createPanelBinding() to create an object that will access the business service's contained data collections through Swing component models.

• Call bindUIControl() on the panel binding to set the Oracle ADF model for the individual components of the JClient form or panel.

The ADF binding context, established in the bootstrap code of the root JClient frame, is shared among subsequent called JClient panels and sets the transactional context and the environment for the application's classes. The panel binding itself is created from the metadata of the UIModel.xml file, which exposes a subset of the data controls available in the ADF binding context:

• If you want to create independent branches of the business services views, then your application should open a frame that sets a new panel binding.

• If you want to maintain the same view along a continuous branch of your application (say a master and detail branch, for example), then secondary containers all "share" the panel binding object created by the initial frame.

6.5.2 Generated JClient Containers

The easiest way to create databound containers is to use the JClient wizards (see the Swing/JClient for Oracle ADF folder in the JDeveloper New Gallery). Specifically, if you use these two JClient wizards, then the source code will contain the bootstrap code and constructors needed to create the panel binding:

• Use the Create JClient Empty Form wizard to generate an empty frame that creates a JClient panel binding with a connection to the business service used by your application, for example ADF Business Components.

• Use the Create JClient Empty Panel wizard to generate an empty panel with constructors to create a new panel binding or to share one from its parent frame.

An additional benefit to using these two wizards is their support for easy drag-and-drop UI design within JDeveloper. Because they are generated with the bootstrap code for a specific data control object (which contains the business service's collections, structured objects, attributes, and methods), all of the Swing components that you insert from the Data Control Palette in JDeveloper will have access to any business service that the data control object contains.

6.5.3 Process for Creating and Using the Panel Binding

To understand how the panel binding is created and used by the databound panels, consider what happens when you run the application, starting with the JClient frame, and the following JClient code is executed:

1. The main() method bootstraps the application. It starts a binding context and loads the Oracle ADF data control, based on entries in the DataBindings.cpx file. Then it passes the binding context with initialized Oracle ADF model objects to the panel binding to create the Oracle ADF data bindings.

2. The frame is initialized (FrameDeptViewEmpView1, in the example above) through a constructor that takes an application object. Initialization of the frame results in a panel binding object (JUPanelBinding), based on an Oracle ADF model definition that may have components that are bound to data from more than one data control. The creation of the panel binding is an important part of the JClient functionality, which enables data binding for Swing components and chaining of data panels.

3. The frame or applet class initializes a layout panel (MDPanelDeptViewEmpView1, in the example above) and sets the panel binding on the new layout panel, using the setBindingContext() method.

4. In the layout panel's jbInit() method, the data browsing (children) panels are created. For this, JClient uses the shared binding context for binding the child data panels (PanelDeptView and PanelEmpView1, in the example above).

5. A control-to-attribute data binding occurs using the control's specified JClient model. (This binding information is stored in the binding container XML metadata.)

6. The control binding handles events to populate and update data for the UI control.

6.5.4 About the Frame Class in JClient

// bootstrap application

JUMetaObjectManager.setBaseErrorHandler(new JUErrorHandlerDlg());

// Lookup the *.cpx file and create all data controls listed in this file.

JUMetaObjectManager mgr = JUMetaObjectManager.getJUMom();

// Use the definition classes provided by JClient. Change only if you do not
   want to use custom DefClasses.

mgr.setJClientDefFactory(null);

// Create a new binding context that extends java.util.Hashtable.

BindingContext ctx = new BindingContext();

// Get user connection information if available. If not, display logon dialog.


ctx.put(DataControlFactory.APP_PARAM_ENV_INFO, new JUEnvInfoProvider());
// Set locale to the default locale of the JVM.

ctx.setLocaleContext(new DefLocaleContext(null));
// Load data binding container data binding file.

HashMap map = new HashMap(4); map.put(DataControlFactory.APP_PARAMS_BINDING
   _CONTEXT, ctx);
mgr.loadCpx("DataBindings.cpx", map);
// Get handle to the Business Components application module.

DCDataControl app = (DCDataControl)ctx.get("model_AppModuleDataControl");

app.setClientApp(DCDataControl.JCLIENT);

// Despite the following line of code, attribute sets and fetches are normally 
// performed in one batch operation. This requires only one network round 
// trip. Attributes that aren't needed are not loaded to the client. The code 
// line below is added only when using the JClient Form wizard. Declaratively 
// creating the frame, starting with an empty form wizard does not add the 
// following lines.

app.getApplicationModule().fetchAttributeProperties(new String[]
  {"DepartmentsView1", "EmployeesView3"}, new String[][] {{"DepartmentId",
   "DepartmentName" }, {"EmployeeId", "FirstName", "LastName" "DepartmentId" }},  
   null);

// Initialize application root class.

FormDepartmentsView1EmployeesView3 frame = new FormDepartmentsView1EmployeesView3();

// Set binding context to the frame.

frame.setBindingContext(ctx); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = frame.getSize();

6.5.5 About the Layout Panel in JClient

When you use the Create JClient Form wizard to generate a JClient application with master and detail panels based on an Oracle ADF Business Components data model, the wizard generates a container panel within a JClient frame. This panel is known as the layout panel because it groups several data panels together. In addition to functioning as a UI container for one or more data browsing panels, the layout panel is able to maintain the data context for the contained data panels through its shared binding context.

The binding context from the application frame can be passed to its contained JClient panels by a call to the panel's setBindingContext() method:

// get the binding context from the frame

   BindingContext _bctx = panelBinding.getBindingContext();

// pass the context to the first child panel

   dataPanel.setBindingContext(_bctx); 

//alternatively you can use

   dataPanel.setBindingContext(panelBinding.getBindingContext());

6.5.6 About Data Panels in JClient

A data browsing panel contains controls through which the user can view and edit data. Thus, it has a set of controls declared and instantiated as fields. The data browsing panel receives its panel binding from the parent frame or panel (through a setBindingContext() call):

panel.setBindingContext(panelBinding.getBindingContext());

After the parent container creates the data browsing panel and its panel binding, jbInit() is called. In the jbInit() method, the control is bound to attributes. Examine the following code:

textFieldDeptName.setDocument((Document)panelBinding.bindUIControl
       ("DepartmentName, "mDepartmentName"));

In the above code line, mDepartmentName is a JTextField component that is bound to the DepartmentName attribute of the underlying business service, where the identifier DepartmentName is a reference to a definition in the UIModel.xml file (the file defines the binding container). The binding container keeps a list of iterator bindings. Each iterator binding specifies the view object instance and (optionally) the row set iterator.

Thus, at runtime when setDocument() is called, JClient looks for a control binding by the specified name (DepartmentName). If one is found in the binding context for the form, JClient uses that control binding's associated iterator binding to access the value.

6.5.7 About Control Binding in JClient

6.6.1 Customizing the Oracle ADF Iterator Binding for UI Access

You can set the number of data objects in a range to fetch from the bound data collection when you do not want to work with an entire set or when you want to display a certain number of data objects on the page. The range defines a window you can use to access a subset of the data objects in the collection. By default, the range size is set to a range that fetches just ten data objects.

Tip: In general, it is recommended that all iterator bindings referred to by multiple binding containers in one application should utilize the same range size. Utilizing the same range size prevents the binding container from generating unnecessary fetch operations against the same data collection. When your application requires different range sizes and you are using Oracle ADF Business Components, you can create a secondary row set iterator declaratively by creating an iterator binding against a given collection and providing a unique name (within the view object's row set iterators).

To set the range size for an iterator binding:

1. With the document open in the visual editor, choose View | Structure to open the Structure window.

1. Click UI Model in the Structure window toolbar and expand the node to display the list of bindings.

2. Select the iterator binding for which you wish to set a range size and choose View | Property Inspector to open the Property Inspector.

3. In the Range Size field of the Property Inspector, edit the value and press Enter. The default value is 10.

Note that the values -1 and 0 have specific meaning: the value -1 returns all available objects from the collection, while the value 0 will return the same number of objects as the collection retrieves from its data source.

When you use the Data Control Palette to drop next set or previous set operations (displayed as a button component when you work with Oracle ADF Business Components) onto your page, the range size for the iterator will be set by default to fetch ten data objects at a time. This behavior will override any previous setting you may have made for the iterator. To maintain a unique range size with Oracle ADF Business Components, you can specify a row set iterator name for the iterator binding in the Property Inspector.

To specify a secondary row set iterator for a collection (supported by Oracle ADF Business Components only):

1. With the UI Model icon displayed in the Structure window, select the iterator binding for which you wish to supply a unique row set iterator name.

   Supplying a unique name for the row set iterator for which the binding operates ensures that another page's iterator binding will not reset the range size on the binding container.

2. Locate the Rowset Iterator field of the Property Inspector, which initially has no value.

3. Type a unique identifying name for the property of the selected iterator binding and press Enter.

At runtime, the binding container will create a unique row set iterator corresponding to the customized iterator binding.

6.6.2 Creating a Search Criteria Form Using Oracle ADF Find Mode

When you create Oracle ADF–enabled web pages, you can support parameterized queries against Oracle ADF Business Components by using an input form and setting the find mode for the page's binding container to enabled. The Oracle ADF binding container supports find operations by executing a parameterized query using the search criteria specified in the form against the view object specified by an Oracle ADF iterator binding.

Once the find operation is executed, the binding container is taken out of find mode and the web page functions as an input entry form. In this way, the binding container toggles the find mode between enabled and disabled for a specific web page.

SELECT ename, job, mgr FROM emp WHERE sal < :min_salary

6.7.1 Value Bindings for the Entire Collection or Row Set

The Data Control Palette provides UI components for web pages that you can use to bind an entire data collection (which consists of a data object that comprise a row set), as shown in the following table:

6.7.2 Value Bindings for Individual Data Object Attribute Values

The Data Control Palette provides UI components that you can use to bind a single data object attribute, as shown in the following table:

UI Component	Drag and Drop into a JSP Page As	Drag and Drop into a UIX Page As
Hello	Value	not available
For Oracle ADF Business Components, displays label control hint, all other services display the attribute value as a label	Label Note that the label can be defined by Control Hints in the case of Oracle ADF Business Components	not available
not visible	Input Render Note that custom renders can be defined in the case of Oracle ADF Business Components	not available
Displays the attribute value, using a custom renderer	Render Value Note that custom renders can be defined in the case of Oracle ADF Business Components	not available
	Input Field	TextInput MessageTextInput
	Text Area	MessageStyledText
Renders a hidden field bound to a model object	Hidden Field	encodedparameter
not visible	File Input Field	not available
	Password Field	textinput (secret)
not visible	Render Value	not available
	Single Select List Static Single Select Field	List MessageList (Select One), MessageList (Select Many)
	List of Values	MessageLovInput
	Radio Button Group	RadioSet MessageRadioSet
	not available	CheckBox MessageCheckBox

6.7.3 Action Bindings for Business Object Methods and Data Control Operations

The Data Control Palette provides UI components that you can use to bind a method or operation, as shown in the following table:

UI Component	Drag and Drop into a JSP Page As	Drag and Drop into a UIX Page As
	Button	SubmitButton
	Button with Form	not available
ActionRequestURI	Link (Strut-based applications only)	not available

6.8.1 Value Bindings for the Entire Collection or Data Object

The Data Control Palette provides UI components that you can use to bind an entire data collection (which consists of data objects that comprise a row set), as shown in the following table:

UI Component	Drag and Drop As	ADF Binding Type
	Table	Table binding
	Combo Box	List binding in navigation mode
	List (inside a ScrollPane)	List binding in navigation mode
	Spinner	List binding in navigation mode
	Radio Button Group	List binding in navigation mode
	NavigationBar	Iterator binding
	Tree	Tree binding
	Graph	Graph binding
	Slider	Scroll binding
	ScrollBar	Scroll binding

6.8.2 Value Bindings for Individual Data Object Attribute Values

The Data Control Palette provides UI components that you can use to bind a single data object attribute, as shown in the following table:

UI Component	Drag and Drop As	ADF Binding Type
	TextField	Attribute binding
	Edit Pane	Attribute binding
	JULabel	Attribute binding
	Label For Used with Oracle ADF Business Components to display attribute's label control hint	Attribute binding
	Password Field	Attribute binding
	Text Area	Attribute binding
	Text Pane	Attribute binding
	Button LOV	LOV binding
	Check Box	Boolean binding
	Formatted Edit Field	Formatted text binding
	Combo Box	List binding in enumeration mode
	List	List binding in enumeration mode
	Spinner	List binding in enumeration mode
	Radio Button Group	List binding in enumeration mode
	Progress Bar	Bounded range binding
	Scroll Bar	Bounded range binding
	Slider	Bounded range binding