SAP Library - SAP NetWeaver Composition Environment Library

SAP NetWeaver Composition Environment Library

What's New in Enhancement Package 1 for SAP NetWeaver CE 7.1

What's New in Enhancement Package 1 SP1 (Ramp-Up Start)

Application Server Java

Application Server Java Runtime

Config Tool

Java EE Development Services

SAP NetWeaver Administrator

System Landscape Directory

Web Dynpro for Java

Web Services

Development Infrastructure

NWDI Development

Composition

Enterprise Services Repository and Registry

Modeling and Design

Composite Application Framework

Business Process Management

Business Rules Management

Portal

Portal Usage and Administration

Running Content in a Remote Portal

Portal Content Modeling

Visual Composer in SAP NetWeaver Developer Studio

Guided Procedures

Security

User Authentication and Single Sign-On

Web Services Security

System Security

What's New in Enhancement Package 1 SP2

What's New in Enhancement Package 1 SP3

What's New in Enhancement Package 1 SP4

What's New in Enhancement Package 1 SP5

What's New in Enhancement Package 1 SP6

What's New in Enhancement Package 1 SP7

What's New in Enhancement Package 1 SP8

Administrator's Guide

Architecture of AS Java

Configuration of SAP NetWeaver CE

Administration of SAP NetWeaver CE

SAP NetWeaver CE Security Guide

Developer's Guide

Guidelines for Developing Composite Applications

Composite Application Layers

Prerequisites

Set Up Your Development System

Set Up Your Development Project for the Composite Application

Model Business Processes

Find and Validate Enterprise Services for Reuse

Develop User Interfaces for the BPM Layer

Integrate Online Interactive Forms by Adobe (Optional)

Adapt, Simplify and Join Existing Services using CAF

Provide New Data Objects (Optional)

Develop and Expose New Business Logic

Assemble and Configure Process Execution

SAP NetWeaver - Demo Model

SAP NetWeaver Developer Studio Basics

Starting the Developer Studio

Setting Workspace Using the -data Parameter

Setting the Java VM Using the -vm Parameter

Changing the Default Workspace

Starting the Developer Studio Using a Batch File

Using Other Start Parameters

Update Manager

Viewing the Error Log File

Working with the Developer Studio

SAP's Component Model

Creating and Modifying Projects

Using Different Java Runtime Environment Versions

Referencing Libraries

Testing Java Applications with JLin

Creating and Editing Variants

Executing JLin Tests

Displaying JLin Results

Executing JLinEE Tests

Testing Web Dynpro Applications

Test Scripts and Test Results

Recording a Test Script in the Developer Studio

Replaying a Test Script in the Developer Studio

Comparing Scripts and Results

Administering the AS Java from the Developer Studio

Starting and Stopping SAP Systems

Viewing and Configuring the Communication Ports

Monitoring the Application Server with the SAP MC

Log Viewing with the SAP MC

Launching Deployed Applications from the SAP MC

Enabling and Disabling the Debug Mode

Reference

Layout of the SAP MC

Context Menus and Settings of the SAP MC

Administration Using Telnet

Maintaining Composite Applications Using the Composite Designer

Concepts

Tasks

Importing Existing Composite Applications

Creating Composite Applications

Creating New Development Objects

Managing Relations

Configuring Composite Designer in the Developer Studio

Using the Development and Production Infrastructure

Modeling Processes with Process Composer

Getting Started

Modeling My First Process

Modeling the Process

Creating a Project

Creating a Process

Creating Flow Objects

Creating Artifacts

Creating Flow Controls

Defining Business Logic

Importing and Assigning Service Interface Definitions

Creating and Assigning Tasks

Importing and Assigning Data Types

Building and Deploying the Business Process Model

Concepts

Processes

Projects and Processes in the Process Composer

Granularity of a Process Model

Process Roles

Process Context

Process Modeling Approaches

Top-Down Approach

Bottom-Up Approach

Inside-Out Approach

Using BPMN Process Models

Working with Sub-Processes

Process and Sub-Process Versioning

Defining Process Participants Using Pools

Defining Pool User Texts

Defining Roles in the Process Using Lanes

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Modeling Events

Importing Service Interface Definitions

Creating Service Interface Definitions

Defining Data Mappings

Modeling Automated Activities

Importing Service Interface Definitions

Creating Service Interface Definitions

Working with Service Groups

Defining Data Mappings

Modeling Human Activities

Working with Tasks

Preparing Web Dynpro DC to be used in BPM

Supported Data Types and Limitations for Web Dynpro in BPM

Assigning a User Interface to a Task

Troubleshooting on Web Dynpro Components in BPM

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Defining Task Administrators

Defining Time Constraints of a Task

Defining an Activation Time of a Task

Defining a Default Start Deadline of a Task

Defining a Default Completion Deadline of a Task

Defining a Default Expiration Deadline of a Task

Overriding Task Attributes on Human Activity Level

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Defining Data Mappings

Transforming Complex Data to Simple Data with Mapping Activities

Controlling the Process Flow with Gateways

Creating Data Objects

Importing XSD files

Creating and Editing XSD Files

Using Annotations in the Process Model

Connecting Flow Objects in a Process

Connecting Separate Process Participants with Message Flow

Modeling Exceptions and Exceptions Handling

Performing Complex Data Transformation with Functions

Formatting the Process Model

Building and Deploying a Process

Starting a Process

Debugging Processes

Managing the Debugged Process

Debugging Processes in the Process Instances View

Reference

Modeling Your Business Process

Data Type Compatibility

Tips and Tricks

Accelerated Modeling with Speed Buttons

Modeling Defaults and Specials

Quick and Easy Mapping

Copying and Pasting Objects in the Process Model

Undoing Process Modeling Steps

Modeling Rules with Rules Composer

Getting Started

The Rules Composer Interface

Typical Workflow

Quick Start Tutorial

Writing Rules on XML Schema

Creating the Rules Composer DC

Creating the XML Schema

Creating the Ruleset

Creating the Decision Table

Creating the Rule

Deploying the Rules

Executing the Rules

Writing Rules on Java Classes

Creating the Rules Composer DC

Evaluate Decision Table Action

Dynamic Invocation of Decision Tables

Firing Queue

Handling Exceptions

Tasks

Creating and Configuring a Rules Composer DC

Creating a Rules Composer DC

Creating a Definition

Deleting a Definition

Creating and Editing an If-Then Rule

Creating an If-Then Rule

Adding a Condition

List of Return Types and Comparator Choices for Conditions

Adding a Nested Condition

Adding an Action

Deleting Conditions and Actions

Adding a Precondition

Setting a Rule Priority

Copying an If-Then Rule

Renaming an If-Then Rule

Deleting an If-Then Rule

Creating and Editing a Decision Table

Creating a Decision Table

Adding a Condition

Adding Other Conditions

Adding Condition and Action Values

List of Comparator Choices for a Decision Table

Using a Decision Table in a Rule

Setting Decision Table Properties

Changing the Layout of a Decision Table

Copying a Decision Table

Renaming a Decision Table

Deleting a Decision Table

Viewing Usage of Aliases

Creating and Editing Compound Expressions

Deploying Rules

Executing Rules

Looking Up the Rules Engine

Invoking a Ruleset

Rules on XML

Configuring Rule Engine Parameters

Designing Composite Processes with Guided Procedures

Getting Started

Setting Up Portal Roles

Getting Started with Guided Procedures Design Time

Launching Guided Procedures (GP) Design Time

Gallery

Managing Folders and Objects in the Gallery

Copying GP Content

Object Design Time

Getting Started with Guided Procedures Runtime

Getting Familiar with the GP Runtime

Core Elements of the Runtime

Getting Familiar with the GP Runtime Work Center

GP Generic Views

Getting Familiar with the Process Instance Work Center

Process Instance Generic Views

Other Elements

Concepts

Guided Procedures Architecture Overview

Process Roles

Callable Object

Callable Object Parameters

Process Modeling

Tasks

Exposing Applications as Callable Objects

Creating Callable Objects in the GP Design Time

Exposing Web Dynpros as Callable Objects

Creating Web Dynpro Form Callable Objects

Exposing WD4VC Applications as Callable Objects

Exposing Web Services as Callable Objects

Exposing RFCs as Callable Objects

Exposing BSPs as Callable Objects

Creating Portal Callable Objects

Exposing Web Pages as Callable Objects

Creating Callable Objects for Background Execution

Creating Business Logic Callable Objects

Creating Content Packages

Creating Decision Dialogs

Creating Object Views

Creating Pass Through Form Callable Objects

Predefined Callable Objects

Testing Callable Objects

Checking Callable Object Consistency

Modeling and Configuring Workflows

Action Design

Creating Actions

Attaching Callable Objects

Ad-Hoc Items

Customizing Titles of Tasks

Block Design

Creating Blocks

Defining Block Flow

Configuring Exception Handling

Parallel Dynamic Block

Process Design

Creating Process Templates

Customizing a Process Instance Title

Defining Process Flow

Configuring Process Roles

Defining Restrictions

Defining Runtime Views

Configuring Process Control Items

Composite Forms

Configuring Process Instantiation

Searching in the Parameter List

Configuring Parameters

Consolidating Parameters

Consolidating Roles

Granting Permissions

Granting View Permissions

Defining and Configuring Notifications

Attachments

Info Callable Objects

Integrating Offline and Form-Based Activities

Concepts of the Composite Forms in Guided Procedures

Guided Procedures Forms Use Types

Form Context

Logical Criteria

Creating and Configuring Forms

Enabling Form Submission Using HTTP

Enabling Form Submission Using SMTP

Creating Logical Criteria

Creating Form Objects in the GP Design Time

Building and Using a Form Context

Enabling Form Input Validation

Configuring Post-Processing Services

Adding Content to Field-Based Templates

Adding Content to Schema-Based Templates

Configuring Form Use and Data Processing Options

Designing Dynamic Forms

Exposing Composite Forms as Callable Objects

Using a Display Callable Object for Forms

Instantiating and Testing Guided Procedure Forms

Activating and Maintaining Guided Procedures Content

Activating Guided Procedures Content

Comparing and Restoring Object Versions

Customizing and Updating SAP Content

Managing GP Content Using the Developer Studio

Starting and Terminating Processes Within a Composite

Starting (Initiating) a New Process

Granting Substitution Permissions

Consuming the GPProcessDiscovery Web Services

Starting a Process Using Web Services

Completing Actions Within a Composite

Consuming the GPActionDiscoveryWSIL Web Service

Completing a Step Using Web Services

Using the GP APIs

Setting Up Your Project

Implementing and Registering Callable Object Types

Implementing the Design Time for a New Callable Object Type

Implementing the Runtime for a New Callable Object Type

Registering a New Callable Object Type

Implementing Additional Callable Objects

Implementing Web Dynpro Callable Objects

Implementing Callable Objects for Background Execution

Implementing BSP Callable Objects

Modeling and Configuring Workflows Using the GP API

Instantiating the Design Time Manager

Creating GP Development Objects

Creating Callable Objects

Implementing Exception Handling

Implementing Parameter Mapping

Defining Activity Mappings

Defining Callable Object Mappings

Implementing Role Consolidation

Editing GP Development Objects

Deleting GP Development Objects

Exposing Business Object Data in the GP Context

Constructing a KM Document Template and Provider

Including Additional Functionality

Using the Forms API

Accessing the Forms Java API

Retrieving Process Template Details

Creating Form Instances

Creating Custom Runtime Views Using the GP API

Runtime View Component Interfaces

Interface Methods for Component Initialization

Registering Web Dynpro Components and Runtime Views

Registering Runtime Views Using Servlets

Scheduling Process Initiation Using the GP API

Implementing a Post-Processing Class with Callback

Starting and Terminating Processes Using the GP API

Managing Runtime Activities Using the GP API

Completing Actions Using the GP API

Managing Process Notifications Using the GP API

Retrieving Process Notification Instances

Updating Notification Processing Time and Status

Creating Deadlines and Durations

Managing Runtime Attachments Using the GP API

Attachment Attributes

Reference

Tutorials

Developing Your First Process

Creating a Folder

Creating an HTML Start Page

Creating an Input Data Form

Setting Up Mail Templates

Replacements

Creating an Approval Callable Object

Creating a Simple Process

Initiating a Process

Exposing an RFC-Enabled Function Module as a Callable Object

Configuring an RFC Destination

Importing a BAPI in Guided Procedures

Testing and Activating an RFC Callable Object

Importing a Web Service in Guided Procedures

Testing and Activating a Web Service Callable Object

Developing Your First Composite Form Process

Modeling the Composite Form Activity

Configuring Pre-Filling Services

Creating the Composite Form

Designing the Form Template Layout

Exposing the Composite Form as a Callable Object

Modeling the Form Approval Activity

Modeling the Notification Activity

Creating Notification E-Mail Templates

Designing the Process Template

Implementing and Exposing a Web Dynpro as a Callable Object

Creating and Configuring the Web Dynpro Project

Implementing a Web Dynpro Component

Creating an Instance of the Callable Object

Testing and Activating the Callable Object

Implementing and Exposing a Background Callable Object

Creating a Java Development Component

Implementing a Background Callable Object

UserDetailsCallableObject

Creating and Deploying a Java Enterprise Application

Exposing a Java Class as a Callable Object

Testing and Activating the Background Callable Object

Configuring Exception Handling

Creating a Data Input Form

Creating an Action to Handle the Exception

Creating a Data Display Form

Creating an Exception Block

Creating an Exception Process

Implementing a BSP Callable Object

Sample BSP Application

Creating a Start Page

Creating a Completion Page

Creating an Instance of a BSP Callable Object

Scenario: Order Office Material

Web Dynpro Component Implementation

WDCODisplaySelectItems

WDCOSelectedItems

WDCOOrderItems

WDCOApproveItems

Defining Fine-Grained Process Components

Decision List or Order Number

Display List and Select

Decision Order Another Item

Display Selected Items

Order Items

Approve Items

Send Order Confirmation

Order Confirmation

E-Catalog

Defining Blocks

Display List and Select Loop Body

Display List and Select Loop

Order with Order Number

Order From List

Order Office Material

Process Definition: Putting It All Together

Providing, Discovering and Consuming Services

Developing User Interfaces with Web Dynpro for Java

Getting Started

Developing Your First Web Dynpro Application

Creating a Web Dynpro Development Component (DC)

Creating a Web Dynpro Application

Creating the Second View

Specifying the Navigation

Creating the Controller Context

Mapping View Contexts to the Component Controller Context

Creating Actions and Implementing Navigation

Designing a View Layout

Deploying and Running Your Application

Concepts

Web Dynpro and the Model View Controller Design

Applications

Components

Constituent Parts of a Component

Interfaces of Components

Faceless Component

Lifespan of a Component

Models

Controllers

Controllers Having No Visual Interface

Controllers Having A Visual Interface

Arranging Multiple Views in a Window

Arranging Multiple Windows in a Component

View Navigation Plugs and Navigation Links

Window Navigation Plugs

Events and Actions

Tasks

Choosing the Client

Integrating WD Applications into SAP NetWeaver Portal

Developing Mobile Always Connected Applications

UI Elements for Mobile Always Connected Applications

Specifics of Nokia Series 80 and 60 Devices

Specifics of BlackBerry Wireless Handhelds

Specifics of Pocket PCs

Mobile Add-On Library

BarCodeReader

Using the BarCodeReader

FunctionKey

Using the FunctionKey

RFIDReader

Using the RFIDReader

Setting Up the Web Dynpro Development Component (DC)

Web Dynpro Development Component (DC)

Creating a Web Dynpro DC

Sharing Local Web Dynpro DCs in the NWDI

Refactoring Web Dynpro Objects

Repairing Web Dynpro DCs

Integrating Services

Importing Enterprise Services Models

Adjusting Port Matches

Maintaining Object and Interface References

Web Dynpro as Provider for Role-Based Access Management

Using Business Objects from the Enterprise Services Framework

Importing Adaptive Web Service Models

Adaptive Web Service Model

Destination Service (Enhanced)

Re-importing Adaptive Web Service Models

Migrating to the Adaptive Web Service Model Type

Enabling Service Group Configuration for AWS Models

Viewing and Creating Service Groups in Web Dynpro Explorer

Importing Enterprise JavaBean (EJB) Models

Enterprise JavaBean (EJB) Model

Importing Adaptive Remote Function Call (RFC) Models

Defining Adaptive RFC Models

Invalidating Metadata Caches

Importing Adaptive Remote Function Call (RFC 2 ) Models

Migrating Adaptive RFC Model to Adaptive RFC 2 Model

Importing JavaBean Models for DC Projects

Importing JavaBean Models for Local Projects

Using JavaBean Logic for WD

Retrieving Bean Classes from .jar Files

Retrieving Bean Classes from Source Directories

Conditions and Naming Conventions for Import Beans

Editing Model Classes

Structuring Web Dynpro Components

Creating Components

Defining Controllers

Adding Custom Controllers

Referencing Custom Controllers

Wrapping Services in Controllers

Implementing Components with Their Controllers and Interfaces

Implementing Component Controllers

Implementing View Controllers

Implementing Window Controllers

Controller Concept

Controller Class and Interface Reference

Controller Interface Concept

Defining Controller Relations

Adding Model References

Adding Windows

Defining Window Properties

Navigating Between WD Java Applications and Other Web Applicatio

Suspend and Resume Plug

Specifying Dataflow

Binding Context to the Model

Defining Controller Relations

Creating Context Trees Manually

Data Binding

Bindable Data Types

Binding UI Element Properties to Dictionary Types

Bringing Files To Context

Binding Tables

Binding Trees

Designing User Interfaces

Creating Views

Arranging Views in a Window

Arranging UI Elements in a View

Choosing the Layout

Adding UI Elements Manually

Adding UI Elements Using View Templates

Creating Buttons, Events, and Plugs

Creating Tables With Direct Controller Access

Creating Forms Using Context Data

Adding UI Elements Programmatically

Assigning UI Element Properties

Common UI Element Properties

Methods of the UI Element APIs

Displaying and Formatting Core Data Types

Specifying the Image Source

Enabling User Interaction

Implementing Hot Keys

Enabling Access Keys

Creating Actions

Mapping Event Parameters to Action Parameters

Mapping the Generic Event Parameter nodeElement

Implementing Parameter Mapping

Implementing Drag and Drop

Modeling Navigation Between Views

Creating Plugs

Creating Navigation Links

Checking View Design

Providing Help

Offering Input Help

Providing Short Value Lists (SVS)

Providing Long Value Lists (EVS)

Providing Search Result Value Lists (OVS)

Modifying Helper UI

Showing Messages After User Interaction

User Messages

Defining User Messages

Displaying User Messages

Internationalizing Applications

Translating UI Texts

Sequence of Language Display

Running Web Dynpro Applications

Creating Applications

Configuring the Web Dynpro Runtime Environment

Configuring Applications

Deploying Applications

Starting Applications

Adding WD-Specific Parameters to URL

Stopping Applications

Redirecting Clients to Other Servers

Ensuring Quality

Debugging Web Dynpro Applications

Debugging Web Dynpro Implementations

Debugging Contexts

Testing Web Dynpro Applications

Checking Monitoring Availability

Minimizing Byte Code

Web Dynpro Class File Minimizer

Reference

Controller Class and Interface Reference

Common Controller Class Reference

Common Controller Interface Reference

Component Controller Class Reference

Component Controller Interface Reference

Custom Controller Class Reference

Custom Controller Interface Reference

View Controller Class Reference

View Controller Interface Reference

Window Controller Class Reference

Window Controller Interface Reference

UI Element Guide

Common UI Element Properties

WDTableCellDesign

Specifying the Image Source

Choosing the Layout

ColumnLayout

ColumnLayoutData and ColumnLayoutHeadData

MatrixData and MatrixHeadData

RowLayout API

RowData and RowHeadData

Defining PageLayout

Implementing Drag and Drop

BIApplicationFrame: Integrating BEx Web Applications

BIMethods API: Access to Actions of a BEx Web Application

Breadcrumb Navigation

BreadCrumb

BreadCrumbStep

MultipleBreadCrumbStep API

HierarchicalCalendarMonthView

DateNavigatorLegend API

DropDownByIndex

DropDownByKey

Explanation

FileUpload and FileDownload: Data Transfer

FileUpload

FileDownload

Binding resource Property

Loading the InputStream at FileDownload on Demand

Implementing Adobe Flash Islands for Web Dynpro Java

Displaying and Editing Formatted Text

Supported XHTML Tags for FormattedText

FormattedTextEdit

FormattedTextView

SimpleFormattedTextField

Implementing a SimpleFormattedTextField

Creating Formatted Text

Gantt

GeoMap

Code Example of the Use of a Geographical Map

Example for Displaying a Route

Implementing a Combo Box

Enabling AutoComplete for InputFields

MultipleLegendItem API

Implementing Menus: ContextMenu, MenuBar and PopupMenu

Utilizing ContextMenus

Implementing IWDIOSFactory

HorizontalContextualPanel

PatternExpandFunction

RadioButtonGroupByKey

RadioButtonGroupByIndex

Filtering and Sorting in a Table

Adding New Rows

TableColumnGroup API

TableColumn API

TableScrollTipProvider

TableRowGrouping API

Implementing TableRowGrouping

TreeByNestingTableColumn API

Cell Variants

TableStandardCell API

TableSingleMarkableCell API

Defining Cell Variants

TablePopin API

TablePopinToggleCell API

ToolBarDropDownByIndex

Data Binding of a Tree UI Element

Code Example for Creation of a Tree UI Element

Controller/Context Editor

Metadata Comparison Tool for WD Projects

Metadata Comparison Tool

Web Dynpro Metamodel Object Search

Navigation Modeler

View Designer

Web Dynpro Explorer

SAP Interactive Forms By Adobe for Web Dynpro

Adobe Library

InteractiveForm API

Web Dynpro Form UI Element CheckFields

Web Dynpro Form UI Element EnumeratedDropDownList

Web Dynpro Form UI Element EnumeratedDropDownListNoSelect

SAP NetWeaver Composition Environment Library

Web Dynpro Form UI Element SubmitToSAP

Web Dynpro Form UI Element ValueHelpDropDownList

Example of the Use of an Interactive PDF Form

Setting Up Basic Authentication in a Java Environment

Tutorials

Integrating EJB 3.0 into Web Dynpro Using the EJB Model Importer

Creating an EJB Development Component (DC)

Developing the Business Logic

Creating an Enterprise Application DC

Preparing DC’s for Use by Other Components

Developing a Web Dynpro Application

Setting Up the Web Dynpro Development Component (DC)

Creating the EJB Model

Creating the Context

Instancing, Registering and Executing the Model

Specifying the View Layout and the Data Binding

Deploying and Running the Sample Application

Creating a Web Dynpro Application using the Adaptive RFC2 Model

Using Service Classes

Deployment Service

Configuration Service

Internationalization Service

URL Generation Service

User Management Service

Naming Conventions

General Rules

Recommendations and Restrictions

Tips and Tricks

Hiding default messages in the problem list

Providing Documentation for Developers

Naming Rules to Ensure Personalization

Problem Analysis: All Web Dynpro Applications Have Status STOPPE

Problem Analysis: Application Ends With Runtime Exception Error

Problem Analysis: Deployed Web Dynpro Application Does Not Run

Modeling Composite Views with Visual Composer

Getting Started

Introducing Visual Composer

Visual Composer Overview

Visual Composer Architecture

Architecture of Visual Composer in a Web Browser

Architecture of Visual Composer in the Developer Studio

Prerequisites

Accessing Visual Composer in a Web Browser

Introducing the Storyboard Desktop

Typical Workflow

Creating a Model

Locating the Data Services

Designing the Component Logic and Flow

Designing the User Interface

Deploying the Model

Modeling Your First Application with Visual Composer

Tutorial 1: Modeling a Simple Application

Creating the Base Model for Retrieving Product Information

Modeling the Currency Converter Application

Adding a Currency Converter Popup

Tutorial 2: Modeling an Advanced Application

Creating the Base Model for Retrieving Buyer Information

Adding a Second Data Service and Preparing for Reuse

Reusing a Model and Enabling Personalization

Tutorial 3: Enhancing the Advanced Application

Creating an Entry List

Checking That a Field Value is Entered

Displaying Information in a Popup Window

Adding a Product Image

Creating a Model and Development Component

Opening a Model

Saving a Model

Saving a Copy of a Model or Development Component

Closing a Model

Importing a Model

Exporting a Model

Creating a New Software Component

Managing Models

Working with Source Control

Adding a Development Component or a Model to Source Control

Checking In a Model

Checking Out a Model

Reverting to the Last Checked-In Version of a Model

Synchronizing a Model

Designing the Composite View

Discovering Data Services

Discovering Services in the Services Registry

Working with Stored Procedures

Reusing Components

Modifying Referenced Components

Composing the Composite View

Introducing the Compose Task Panel

Connecting Model Elements

Configuring the Composite View

Working with Dynamic Expressions

Dynamic Expression Editor Dialog Box

Messages in the Dynamic Expression Editor Dialog Box

Defining Dynamic Expressions

Tables of Functions

Text Functions

Text Type Classifications

Numeric Functions

Number Formatting Mask

Conditional Functions

Scientific Functions

Dynamic Expression Operators

Defining Data

Mapping Data

Laying Out the UI

Defining Layout Options

Adding Controls

Controls Overview

Adding Controls in a Melting Group

Configuring Controls

Defining Actions

Creating Entry Lists

Defining Control Styles

Defining Images

Creating Toolbars

Defining Table Styles

Performing Advanced Modeling Tasks

Finding and Modifying References

Storing Data in a Data Store

Replacing Components

Creating a Multi-Selection Table

Enabling Customization of Table Views at Runtime

Defining Popups

Creating Service Components

Creating a Service Using the Service Component Wizard

Using Eventing to Transfer Data between Components

Transferring Data Using a Data Share

Defining Validation Rules

Managing System Aliases

Preparing Models for Translation

Modeling Composite Views for Use in Guided Procedures

Creating an Error Report

Migrating Models to Visual Composer for CE

Table of Conversions

Compiling and Deploying Models

Viewing Log Files

Working with Visual Composer in SAP NetWeaver Developer Studio

Launching Visual Composer

Getting Started with Visual Composer in Developer Studio

Creating a Local Development Component

Creating RFC Destinations

Creating Web Service Destinations

Creating a JDBC Connection Profile

Configuring Systems for Deployment

Using the CMI EJB Service in Visual Composer

Enabling the Service Group in Visual Composer

Working with the Model Browser

Working with Source Control

Importing a Development Configuration

Creating a Development Component in Source Control

Synchronizing a Development Component in the Model Browser

Adding a Local Development Component to Source Control

Checking In a Model

Checking Out a Model

Reverting to the Last Checked In Version of a Model

Resolving Conflicts in the Component Definition File

Using Web Dynpro Components in Visual Composer

Understanding the Visual Composer DC Structure

Modeling Composite Views Using BI Data Services

Designing Composite Views Using BI Data Services

Designing Composite Views Using BI Integrated Planning

Structure of a BI Data Service

Visual Composer Reference Guide

Main Workspace Elements

Configuration Dialog Boxes

Manage Services Dialog Box

Options Pane

Options Pane - Model Group

Options Pane - Design Group

Options Pane - Performance Group

Options Pane - Compiler Group

Options Pane - Embedded Support Group

View Runtime Configuration Dialog Box

Model Menu Dialog Boxes

Create New Model Dialog Box

Export Model Dialog Box

Import Dialog Box

Save As Local Copy Dialog Box

Task Panels

Get Started Task Panel

Manage Models Task Panel

Add Model to Source Control Dialog Box

Add to Source Control Dialog Box

Activity Description Dialog Box

Create New Development Component Dialog Box

Create New Software Component Dialog Box

Browse Task Panel

Compose Model Task Panel

Compose Model Task Panel (Design Board)

Compose Model Task Panel (Layout Board)

Configure <Element> Task Panel

Configure Button Task Panel

Configure Calendar Task Panel

Configure Chart View Task Panel

Configure Checkbox Task Panel

Configure Combo Box Task Panel

Configure Composite View Task Panel

Configure <Connecting Line> Task Panel

Configure <Connector> Task Panel

Configure Data Source Task Panel

Configure Date Picker Task Panel

Configure DateTime Picker Task Panel

Configure Dropdown List Task Panel

Configure Form View Task Panel

Configure Horizontal Separator Task Panel

Configure HTML View Task Panel

Configure Hyperlink Task Panel

Configure Image Task Panel

Configure Input Field Task Panel

Configure Layer Task Panel

Configure Melting Group Task Panel

Configure Nested View Task Panel

Configure Note Task Panel

Configure <Operator> Task Panel

Configure Panel Task Panel

Configure Plain Text Task Panel

Configure Popup Task Panel

Configure Progress Bar Task Panel

Configure Radio Group Task Panel

Configure Service Component Task Panel

Configure Table View Task Panel

Configure Tabstrip Task Panel

Configure Text Editor Task Panel

Configure Toggle Button Task Panel