Developers Guide
Developing Mobile Applications
Defining Data Objects and Distribution for Mobile Applications
Getting Started
Tutorial: Modeling a Service Order Application
Introduction
Creating the SWCV
Defining Data Objects
Definitions of Data Objects
Modeling the Data Objects
Adding Associations Between Data Objects
Defining Distribution Logic
Distribution Logic
Customizing the Receiver Meta Model
Defining the Distribution Model
Defining a Data Completeness Group
Back-End Adapters
Creating a Back-End Adapter
Concepts
Data Orchestration Workbench
Data Object Concepts
What is a Data Object
Data Object Categories
Associations Between Data Objects
Dependency Scenarios
Correlation
Concepts of Distribution
Distribution Logic
Distribution Model
Distribution Rule
Effects of Distribution Rules
Distribution Dependency
Data Completeness Group
Line Item Filtering
Data Processing and Back-End Integration
Flow Definition
Available Flow Blueprints
Custom Service
Back-End Adapter
Keys Used in DOE
Key Mapping Between Associated Data Objects
Data Object-Internal Key Mapping
Automatic Key Mapping
Explicit Key Mapping
Tasks
Creating a Software Component Version
Creating References Between SWCVs
Deleting References Between SWCVs
Creating Data Objects
Creating a New Data Object
Creating a Copy of a Data Object
Creating a Data Object by Importing an MI SyncBO
Importing BAPI Wrappers as Data Objects
Processing Data Objects
Creating a Data Object Node
Creating a Copy of a Data Object Node
Defining Data Object Node Attributes
Processing Data Object Nodes
Defining an Association Between Data Objects
Defining Correlation
Defining Explicit Key Mapping
Creating Distribution Models
Creating a Distribution Model
Processing a Distribution Model
Creating a Distribution Dependency
Processing Distribution Dependencies
Defining a Data Completeness Group
Adding Rules to a Distribution Model
Operators Used in Defining Rules
Processing Distribution Rules
Adding a Bulk Rule to a Distribution Model
Filtering Line Items
Defining Filters at Data Object Nodes
Creating a Back-End Integration
Creating BAPI Wrappers Using the Wizard
Creating a Back-End Adapter
Comparing DOE and Back-End Field Mapping
Modifying a Back-End Adapter
Customizing the Data Processing Activities
Displaying a Flow Definition
Adding a Custom Service to a Flow Blueprint
Reference
Sample Distribution Logic Scenarios
Distribution by Value Range
Distribution by Type and Dependency
Distribution by Type and Dependency - Scenario 2
Distribution by Static Value and Date Range
Developing Mobile Applications for Laptops
Getting Started
Mobile-Specific Software Units
Installing Mobile-Specific Software Units
Downloading Mobile-Specific Software Units
Hardware and Software Requirements
Installing Mobile Plug-Ins in the IDE
Installing the Mobile Client
Uninstalling the Mobile Client
Configuring the Development Workstation
Configuring Connections to the DOE
Configuring Client Settings
Using Mobile Client for Laptops
Logging on to Mobile Client for Laptops
Logging on to Mobile Client Using Single Sign On
Changing the Logon Password
Resetting the Local Logon Password
Personalizing Mobile Client for Laptops
Configuring User Settings
Configuring Synchronization Settings
Registering the Client Device
Enabling Secure Data Exchange with the DOE
Processing Agent Configurations sent from the DOE
Enabling Tracing in the Mobile Client for Laptops
Reassigning the Client Device
Synchronizing Applications and Data
Enabling Automatic Synchronization
Using Data Carrier Synchronization
Configuring the Data Carrier Synchronization Settings
Exporting data to the Storage Device
Importing data from the Storage Device
Changing the Synchronization Password
Resetting Application Data on the Client
Viewing System Messages sent from the DOE
Status Monitor for the Mobile Client
Reference
Elements of the Client Screen
Page Title Bar
Concepts
Mobile Applications for Laptop Perspective
Laptop UI Explorer
Data Object Model
Technical System Landscape
Tasks
Enabling the Laptop Perspective in NWDS
Creating a Mobile Development Component
Importing Data Objects
Creating an Authorization Definition File
Mapping an Authorization Object to a Business Object
Creating a Query Model Class
Modeling a Query Model Class
Modeling a Composite Model Class
Designing the Application
Creating a Component
Creating a View
Embedding a View in the View Set
Designing a View Layout
Defining Navigation Between Views
Creating an Action
Processing an Action
Sharing Data Between Views
Creating a Component Context
Mapping a Context
Creating a View Context
Binding a UI Element to a Context
Creating Mobile Applications for Laptop
Testing Mobile Applications for Laptop
Building Mobile Projects
Creating a Project Archive
Deploying Mobile Applications for Laptop
Running Mobile Applications for Laptop
Debugging Mobile Applications for Laptop
Deleting Mobile Projects
Reimporting Data Objects
Implementing Security Interface on the Client
Tutorial: Creating a Service Order Application
Introduction
User Interfaces
Process Diagram
Defining Data Objects and Distribution
Creating Development Components
Importing Data Objects from the DOE
Defining the Model Classes as Public
Defining the Queries
Creating the Laptop Application
Defining Context Binding
Defining Supply Functions for the Node Elements
Defining the Method for Calling the Query
Specifying the Navigation Schema
Specifying Navigation Schema for the Exit Button
Customizing the Views
Customizing the Customer Details View
Customizing the Order Details View
Building, Deploying and Running the Application
Reference
Example: Data Object Mapping
Query Language Reference
API Reference
Developing Mobile Applications for Handhelds
Getting Started
Configuring the Development Workstation
Starting the Mobile Client for Handhelds
Using the Mobile Client for Handhelds
Starting and Logging onto the Mobile Client for Handhelds
Creating a New User
Changing Your Logon Password
Configuring the Mobile Client for Handhelds
Configuring the Regional Settings
Configuring the Connection Settings
Configuring the Sync Settings
Synchronizing Applications and Data
Launching Applications
Troubleshooting
Concepts
Development Scenarios for Handheld Applications
Composite Development Scenario
Compact Development Scenario
Mobile Applications for Handhelds Perspective
NetWeaver Development Infrastructure Integration
Design Time Repository
Technical System Landscape
Mobile Client for Handhelds
Tasks
Collaborating on Handheld Application Development
Creating a Handheld Application Project
Creating a Mobile Service Component
Creating the Data Model
Creating Client Data Objects
Reimporting Client Data Objects
Creating Data Structures
Including Value Help
Creating Queries and Custom Operations
Creating a Service
Modeling a Query
Modeling a Custom Operation
Handling Exceptions
Creating a Mobile UI Component
Creating a Web Dynpro Application
Applying Controller Templates
Creating a Web Dynpro Model
Defining the UI and Navigation
Composing and Testing the Mobile Application
Building the Mobile Application
Deploying the Mobile Application
Running the Mobile Application
Debugging the Mobile Application
Creating Development Components
Defining Dependencies Between Components
Reference
Tutorial: Developing an Order Application for Handhelds
Starting a New Project
Defining the Data Model and Business Logic
Creating Client Data Objects
Creating a Service
Creating a Query
Defining the Custom Methods
Defining the User Interface
Creating the Mobile UI Component
Creating the Web Dynpro Model and Application
Applying the Component Controller Template
Designing the View Layout
Composing and Testing the Application
Deploying and Running Your Application
Handheld Applications Glossary
Supported UI Elements in the Developer Studio
API Overview
Query Editor Reference
API Reference
Peripheral Input/Output Services
Peripheral Input/Output Services Architecture
PIOS Getting Started Example
PIOS API Core
Printer API
PIOS Printer API Features Description
PIOS Printer API Guidelines
Printer API Examples
Print Left-Justified Text
Print Centered Text in Line Mode
Print Right-Justified Text
Print Text as Left-Justified Graphic
Print Text as Centered Graphic
Print Text as Right-Justified Graphic
Print Graphic as Two-Page Report
Print Image in Line Mode
Print Barcode in Line Mode
Rotate and Print Text
Rotate and Print an Image
Rotate and Print Barcode
Configure Printer Parameters
Add/Remove a Font Using the Client API
Scanner API
PIOS Scanner API Features Description
PIOS Scanner API Guidelines
Scanner API Examples
Add / Remove Symbologies
Beep Options
Determine Symbology
Preamble and Postamble
Soft Trigger
Wedge Mode
Using the Scanner Attributes
RFID API
PIOS RFID API Features Description
PIOS RFID API Guidelines
RFID API Examples
Identify All
Identify by Tag Type
Read
Write
List Tag Types
Tag Configuration Manager
Program and Lock a Tag ID
Reset a Tag ID
PIOS Mobile Driver Components
Installing a Mobile Driver Component
Driver Configuration
Peripheral Support Emulator Actions
Peripheral Support Emulator Actions Toolbar
Emulator Launch Configurations Manager
Open the Emulator Launch Configurations Manager
Create a new Eclipse launch configuration with Emulator support
Launching the Peripheral I/O Emulator
Additional tasks to add support on OCA applications
Peripheral Input/Output Emulator
PIOS Emulator Menu Options
File Menu
Edit Menu
View Menu
Peripheral Options Menu
Help Menu
Printer Peripheral Panel
Edit Menu for Printer Peripheral Type
Peripheral Options Menu for Printer Peripheral Type
Emulator Configuration
Property Files for Printer Peripheral Type
Installing a Font in the Emulator Printer
Uninstalling a Font from the Emulator Printer
Installing New Media to the Emulator Printer
Uninstalling Media from the Emulator Printer
Installing a Font Configuration
Uninstalling a Font Configuration
Using the PIOS Emulator for the Printer Peripheral Type
Using the Measuring String
Scanner Peripheral Panel
Edit Menu for Scanner Peripheral Type
Peripheral Options Menu for Scanner Peripheral Type
Using the PIOS Emulator for the Scanner Peripheral Type
Creating Barcode Data
Scanning Existing Barcode Data
RFID Peripheral Panel
Edit Menu for the RFID Peripheral Type
Peripheral Options Menu for RFID Peripheral Type
Using the RFID Emulator
Adding RFID Tag Types
Editing RFID Tag Types
Deleting RFID Tag Types
Creating RFID Tags
Editing RFID Tags
Deleting RFID Tags
Cloning RFID Tags
Reference
Developing Applications Using ABAP
Getting Involved
The Origins of ABAP an Overview
ABAP and Its Infrastructure
ABAP and the SAP NW Application Server
Go and Create
Creating a Database Table and Data Elements
Defining the Basic Attributes of a Global Class
Methods, Types, and Attributes of a Global Class
Core Development Tasks
UI Technology
Web Dynpro for ABAP
Business Server Pages
Advantages of ABAP Objects
Why You Should Use ABAP Objects
Using ABAP Objects - Best Practices
Sharing Data
Shared Objects - Basic Features
Shared Objects - Advanced Features
Best Practices
Exception Handling
Class-Based Exceptions in ABAP
Basic Features
Planning Exception Handling and Delegating Exceptions
The Three Exception Classes in ABAP
Defining an Exception Class
New Exceptions and Former Concepts of Error Handling
Developing Persistence
The Standard Path to Persistence
Other Persistence Options
All or Nothing Database and SAP Transactions
Exclusive Database Access - Lock Concept of the SAP NW AS
Restricting Access - Authorization Concept of the SAP NW AS
Using Connectivity and Interoperability
The Integration Strategy of SAP
Generating Interfaces and Proxies The Outside-In Approach
XML-Based Process Integration with the Exchange Infrastructure
Making Enhancements
How Do Modification-Free Enhancements Work?
Enhancement Framework Details Based on an Example
What Are Explicit and Implicit Enhancement Options?
Explicit Enhancement Options
Implicit Enhancement Options
Source Code Plug-Ins in Detail
In Which Structure Are Source Code Plug-Ins Embedded?
New BAdIs
Features of New BAdIs
BAdIs - Typical Example
The Switch Framework
Motivation
Basic Concepts of the Switch Framework
What Objects Can You Switch and How?
Switchable Objects
Switching
Conflict Switches
Ensuring Quality
ABAP Unit Tests
Effective Testing with ABAP Unit
The Philosophy of Unit Tests
Unit Tests and Transports
Advantages of ABAP Unit Tests
Developing User Interfaces with Web Dynpro for Java
Getting Started
Developing Your First Web Dynpro Application
Concepts
Web Dynpro Component
View
View Set
Plugs and Navigation Links
Web Dynpro Window
Window Plugs
Controller
Context
Data Binding and Mapping
Event
Action
Interfaces of Web Dynpro Components
Web Dynpro Application
Web Dynpro Model
Tasks
Choosing the Client
Integrating WD Applications into SAP NetWeaver Portal
Web Dynpro Client for Windows
Defining a Link to a Web Dynpro Application
URL of the Web Dynpro Application
Client-Side URL Parameters
Launching Web Dynpro Applications in the Windows Client
Functions of the Top-Level Toolbar
Mobile Web Dynpro Online
UI Elements for Mobile Web Dynpro 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 Project
Web Dynpro Development Component (DC)
Web Dynpro Project
Creating a Web Dynpro DC
Creating a WD Project
Migrating Web Dynpro Projects into the NWDI
Repairing Projects
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
Web Service Invocation Object
Destination Service (Enhanced)
Migrating to the Adaptive Web Service Model Type
Importing Enterprise JavaBean (EJB) Models
Enterprise JavaBean (EJB) Model
Importing Adaptive Remote Function Call (RFC) Models
Defining Adaptive RFC Models
Invalidating Metadata Caches
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
Specifying Components
Creating Components
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
Adding Custom Controllers
Wrapping Services in Controllers
Adding Model References
Adding Windows
Defining Window Properties
Defining Views
Creating Layout Views
Applying View Templates
Creating Buttons, Events, and Plugs
Creating Tables With Direct Controller Access
Creating Forms Using Context Data
Checking View Design
Defining User Messages
Navigation Modeling
Creating Plugs
Navigating Between WD Java Applications and Other Web Applicatio
Suspend and Resume Plug
Creating Navigation Links
Defining Controllers
Defining Controller Relations
Creating Actions
Handling Events
Mapping Event Parameters to Action Parameters
Mapping the Generic Event Parameter nodeElement
Implementing Parameter Mapping
Creating Context Trees Manually
Specifying Dataflow
Binding Context to the Model
Data Binding
Bindable Data Types
Binding UI Element Properties to Dictionary Types
Bringing Files To Context
Binding Tables
Binding Trees
Designing View Layouts
Choosing the Layout
Adding UI Elements
Programming UI Dynamically
Methods of the UI Element APIs
Creating Mobile Web Dynpro Online Applications
UI Elements for Mobile Web Dynpro Applications
Specifying Common UI Element Properties
Specifying the Image Source
Displaying and Formatting Core Data Types
Internationalizing Applications
Sequence of Language Display
Getting Language-Specific Resources
Translating UI Strings
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
Ensuring Quality
Debugging Applications
Enabling Servers for Debugging
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
Specifying Common UI Element Properties
WDTableCellDesign
Specifying the Image Source
Choosing the Layout
ColumnLayout
ColumnLayoutData and ColumnLayoutHeadData
FlowLayout API
FlowData API
GridLayout API
GridData API
MatrixLayout API
MatrixData and MatrixHeadData
RowLayout API
RowData and RowHeadData
Defining PageLayout
Containers
ScrollContainer
Group
TransparentContainer
Tray
BIApplicationFrame: Integrating BEx Web Applications
BIMethods API: Access to Actions of a BEx Web Application
Breadcrumb Navigation
BreadCrumb
BreadCrumbStep
MultipleBreadCrumbStep API
BusinessGraphics
Category API
Series API
Point API
SimpleSeries API
NumericValue API
TimeValue API
Button - ButtonRow
ButtonChoice
Calendar
CalendarYearView
CalendarMonthView
HierarchicalCalendarMonthView
CalendarWeekView
CalendarDayView
CalendarEntry
CalendarPaginator
Day Patterns
DayPattern
WeekDayPattern
WorkingTime
Caption
CheckBox
CheckBoxGroup
DateNavigator
DateNavigator
DateNavigatorMarking
DateNavigatorLegend API
DropDownByIndex
DropDownByKey
Explanation
FileUpload and FileDownload: Data Transfer
FileUpload
FileDownload
Binding resource Property
Loading the InputStream at FileDownload on Demand
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
HorizontalGutter
IFrame API
Image
InputField
Implementing a Combo Box
Enabling AutoComplete for InputFields
ItemListBox
Label
Legend
LegendItem API
MultipleLegendItem API
FrameworkLegendItem
LinkToAction
LinkToURL
MeltingGroup
Implementing Menus: ContextMenu, MenuBar and PopupMenu
Utilizing ContextMenus
MenuBar
Menu
MenuActionItem
MenuCheckBox
MenuRadioButton
MessageBasedTrigger
Network
OfficeControl
Using OfficeControl
IWDIOSFactory
Implementing IWDIOSFactory
Pattern UI Elements
PageLayout
PageHeader
PageHeaderArea
HorizontalContextualPanel
ContextualPanel
ViewSwitch
FreeContextualArea
NavigationList
ExpandableTitle
PatternTabStrip
PatternTab
PatternTray
PatternContentArea
PatternExpandFunction
Shuttle
MessageArea
PhaseIndicator
PhaseIndicator
Phase
MultiPhase
ProgressIndicator
RadioButton
RadioButtonGroupByKey
RadioButtonGroupByIndex
RoadMap
RoadMapStep
MultipleRoadMapStep
RowRepeater
SectionHeader
Table
Table API
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
TextBar API
Tabstrip
TabStrip
Tab
TextEdit
TextView
TimedTrigger
ToggleButton
ToggleLink
Toolbar
ToolBar
ToolBarButton
ToolBarButtonChoice
ToolBarDropDownByIndex
ToolBarDropDownByKey API
ToolBarInputField
ToolBarLinkToAction
ToolBarLinkToURL
ToolBarSeparator
ToolBarToggleButton
Tree
TreeNodeType
TreeItemType
Data Binding of a Tree UI Element
Code Example for Creation of a Tree UI Element
TriStateCheckBox
ValueComparison
Web Dynpro Tools
Component Modeler
Controller/Context Editor
Data Modeler
Java Editor
Message 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
Web Dynpro Form UI Element HideReaderToolbar
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 DCs for Use by Other Components
Developing a Web Dynpro Client Application
Setting Up the Web Dynpro DC Project
Creating the EJB Model
Creating the Context
Specifying the View Layout and the Data Binding
Adding Java Code for the Controller
Deploying and Running the Sample Application
Using Service Classes
Deployment Service
Configuration Service
Internationalization Service
URL Generation Service
User Management Service
Logging Tracing Service
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
Providing Java Dictionary Tables and Data Types
Modifying Dictionary Preferences
Development Process
Creating Data Types
Initial Values
Creating Structures
Reference Fields
Tables
Creating Tables
Buffering Type
Creating Indexes
Deploying Tables
Editing Table Definitions
Creating Views
Working with the Development Infrastructure
Getting Started
Development Infrastructure (DI) Architecture
First Steps in Development Infrastructure
Importing a Development Configuration
Creating a Development Component (DC)
Working with Development Component Projects
Working with Development Infrastructure - Basic Operations
Extending the Archive Pool
Concepts
Component Model
Development Components
Public Parts
Dependencies
Nesting
Naming
Access Control Lists
Development Component Types
Public Part Entities
Folder Structure
Structure of the GEN Folder
Software Components
Naming
Development Configurations
Development Scenarios with Development Infrastructure
Java Development with a Central Storage for the Source Files
Components Development with the NWDI
Development Steps in Component Development with the NWDI
Development Configurations
Using Third Party Development Infrastructure
Development Resources Share
Build Integration
File System Layout
Structure of the GEN Folder
Production Delivery
Activity
Tasks
Setting Up a Track for Composition Environment Development
Setting Up the Developer Studio for Development Within a Track
Managing Development Configurations
Migrating Standard Projects into Development Components
Migrating J2EE Library DC to Enterprise Application DC
Working with Development Components
Creating Development Components
Synchronizing a DC in a Local File System
Editing Development Components
Managing Public Parts
Nesting Development Components
Building Using Different JDK Versions
Build Options
Exporting Software Component Archives
Enabling Usage of a DC Archive Cache
Adding Transport Packages to NWDI
Reference
Glossary
Tutorials
How to Perform Non-NWDI Development of Web Dynpro Application
How to Perform Team-Oriented Development
Preparing the System
Granting Initial Privileges
Creating Users and Assigning Groups Using UME
Creating New Projects
Enhancing the Projects
Starting the Application
Composition Environment Command Line Tool
Archive Packaging Attributes
Batch Processing
Commands of the CECLT
buildalldcs
builddc
buildlist
buildusingdcs
createsda
dcwrap
displaysca
exec
exit
exportproductversiondescription
exportscversiondescription
exportforassembly
help
importconfig
importsca
listavailabledcs
listbuildorder
listbuildresults
listuseddcs
listusingdcs
loadconfig
packdcs
packsca
refresh
script
showconfig
spool
startup
syncalldcs
syncdc
timing
unpacksca
unsyncalldcs
unsyncdc
vars
Working with the Design Time Repository
Getting Started
Managing Design Time Repository Preferences
Concepts
Design Time Repository Architecture
Workspaces
Activity
Version Control
Distributed Development
Conflicts
Glossary
Tasks
Managing DTR Clients
Administration of the DTR Content
Creating Workspace Folders
Creating Workspaces
Synchronizing a DC in a Local File System
Turning On Advanced Design Time Repository Features
Managing Resources
Managing Resource Versions
Managing Activities
Activating Activities in the CBS
Releasing Activities
Resolving Conflicts
Reference
Glossary
Tutorials
How to Perform Non-NWDI Development of Web Dynpro Application
How to Perform Team-Oriented Development
Preparing the System
Granting Initial Privileges
Creating Users and Assigning Groups Using UME
Creating New Projects
Enhancing the Projects
Starting the Application
Composition Environment Command Line Tool
Archive Packaging Attributes
Batch Processing
Commands of the CECLT
buildalldcs
builddc
buildlist
buildusingdcs
createsda
dcwrap
displaysca
exec
exit
exportproductversiondescription
exportscversiondescription
exportforassembly
help
importconfig
importsca
listavailabledcs
listbuildorder
listbuildresults
listuseddcs
listusingdcs
loadconfig
packdcs
packsca
refresh
script
showconfig
spool
startup
syncalldcs
syncdc
timing
unpacksca
unsyncalldcs
unsyncdc
vars