ABAP Workbench: Tools
Overview of the Workbench
Tool Integration and Working Methods
Development Objects and Packages
Development in a Team Environment
Learning More
Object Navigator
Object Lists in the Object Navigator
Selecting Objects
Creating New Objects
Creating a Program
Copying Objects
Deleting Objects
Assigning an Object to a Different Package
Creating a Transport Entry
Activating Objects
Using Set Mode
Navigation
Areas of Navigation in SE80
Hiding the Navigation Area
Navigating in the Tool Area
Object List Functions
Navigation Stack
Navigation Context
Worklist
Setting Markers
User-Specific Settings
ABAP Editor
Overview of the ABAP Editor
Frontend Editor (Plain Text Mode)
Backend Editor
Changing the Editor Mode
Creating a Program
Editing a Program
Navigating in the Source Code
Navigating by Double-Click
Using Compression Logic
Editing Source Code (Frontend Editor)
Editing Source Code (Backend Editor)
Using Buffers
Find and Replace (Frontend Editor)
Find and Replace (Backend Editor)
Inserting Statement Patterns
Inserting Statement Patterns by Drag and Drop
Expanding Includes
Using ABAP Help
Improving the Layout
Features of the Pretty Printer
Saving and Activating a Program
Checking a Program
Extended Program Check
Errors and Warnings
Local Editing
Function Builder
Overview of Function Modules
Initial Screen of the Function Builder
Looking Up Function Modules
Getting Information about Interface Parameters
Calling Function Modules From Your Programs
Creating new Function Modules
Creating a Function Group
Creating a Function Module
Specifying Parameters and Exceptions
Understanding Function Module Code
Checking and Activating Modules
Testing Function Modules
Saving Tests and Test Sequences
Documenting and Releasing a Function Module
Class Builder
Introduction to the Class Builder
Naming Conventions in ABAP Objects
Overview of Existing Object Types
Class Browser
Creating Object Types
Initial screen
Creating Classes
Creating Standard Classes
Creating Exception Classes
Creating Persistent Classes
Creating Interfaces
Defining Components
Class Editor
Creating Attributes
Creating and Defining Methods
Creating Parameters for Methods
Creating Exceptions for Methods
Implementing Methods
Creating Event Handler Methods
Creating Events
Creating Types
Implementing Local Auxiliary Classes
Defining Macros that are Local to the Class
Defining Relationships Between Object Types
Enhancing Classes with Interfaces
Creating Subclasses
Extending Subclasses
Nesting Interfaces
Defining Friends Relationships
Activating Classes and Interfaces
Defining Persistent Classes
The Mapping Assistant
Creating Persistent Classes
Generated Classes
Class Diagram: Created Classes
Defining Persistence Representation
Defining Value Attributes, Key Attributes, and GUIDs
Defining Reference Attributes
Class Diagram: Persistence Representation
Activating Persistent Classes
Class diagram: After activation
Editing Persistent Attributes
Defining Global Exception Classes
Creating Exception Classes
Creating Attributes for Exception Classes
Inserting Exception Texts
Settings in the Class Builder
Utilities of the Class Builder
Moving Components to the Superclass
Moving Components to Subclass(es)
Moving Components to the Interface
Moving Components to Associated Classes
Moving Interfaces to the Superclass
Moving Interfaces to Subclass(es)
Moving Interface Components in Class(es)
Moving Interface Components to the Component Interface
Splitting Classes
Splitting Interfaces
Testing
Testing a Class
Creating Instances
Testing Attributes
Testing Methods
Testing Event Handling
Testing an Interface View of an Object
Screen Painter
Screen Painter Concepts
Screen Painter: Initial Screen
Creating Screens
The Flow Logic Editor
Flow Logic Keywords
Graphical Layout Editor
Overview of Screen Layout
Screen Elements
Selecting Fields
Creating Screen Elements without Fields
Modifying Screen Elements
Using Icons
Using Radio Buttons
Tabstrip Controls
Defining a Tabstrip Control
Using the Tabstrip Control Wizard
Table Controls
Defining a Table Control
Using the Table Control Wizard
Editing Table Controls
Creating a Custom Container
Working with Step Loops
Converting a Step Loop
The Alphanumeric Fullscreen Editor
Creating Screen Elements
Using Dictionary and Program Fields on a Screen
Creating and Modifying Table Controls
Creating a Tabstrip Control
Creating an SAP Custom Container
Creating and Modifying Step Loops
Modifying Screen Elements
Converting Elements
Using the Field List View
Defining the Element Attributes
General Attributes
Dictionary Attributes
Program Attributes for Screen Elements
Display Attributes
Tabstrip Control Attributes
Table Control Attributes
Attributes of the Subscreen Area
Custom Container Attributes
Choosing Field Formats
Testing Screens
Checking Screens
Saving, Activating, and Deleting Screens
Menu Painter
The Menu Painter: Introduction
The Menu Painter Interface
Menu Painter: Initial Screen
Creating a GUI Title
Defining a Status
Creating a GUI Status
Creating a Context Menu
Working with Menu Bars
Creating a Menu Bar
Observing Standards
Adding Functions to a Menu
Defining Function Key Settings
Defining an Application Toolbar
Defining Icons in the Application Toolbar
Fixed Positions
Inserting Separators
Creating the Standard Toolbar
Testing and Activating a Status
Using the Extended Check
Copying a Status
Linking Objects in a GUI Status
Working with Overview Lists
Functions
Using Function Types
Defining a Fastpath
Activating and Deactivating Function Codes
Deactivating Functions at Runtime
Defining Dynamic Function Texts
Defining Dynamic Menu Texts
Setting a GUI Status and GUI Title
Evaluating Function Codes in the Program
The Splitscreen Editor
Overview
Starting the Splitscreen Editor
Initial Screen
Special Splitscreen Editor Functions
Editor Functions
Transformation Editor
Creating the Transformation Program
Activating the Transformation Program
Testing Transformation
Creating Breakpoints in XSLT Programs
XSLT Debugger
Starting and Exiting a Debugging Session
The Debugger User Interface
Result View
Breakpoint View
Call View
Variable View
Breakpoints
Creating Breakpoints in XSLT Programs
Saving Breakpoints
Deleting Breakpoints
Debugger Execution Types
XSLT Debugger and ABAP Debugger
Web Dynpro in the ABAP Workbench
Go and Create: The First Application with Web Dynpro ABAP
Step 1: Creating and Editing a Component
Step 2: Designing the First View
Step 3: Context Mapping of the First View
Step 4: Binding the Attribute
Step 5: Structuring the Second View
Step 6: Maintaining the Context of the Second View
Step 7: Embedding the Views in a Window
Step 8: Defining the Navigation
Step 9: Creating and Testing a Web Dynpro Application
Creating a Simple Flight Info Application
Part 1: Creating and Editing the "Search” View
Step 2: Testing the First View
Part 3: Creating and Editing the “Display” View
Part 4: Implementing the Data Transport
Part 5: Setting Up Navigation
Web Dynpro Tools in the ABAP Workbench
Component Editor
Controller Editor
Controller: Properties
Controller: Context
Creating and Maintaining Context Nodes
Create and Maintain Context Attributes
Defining Mapping
Controller: Attribute
Controller: Events
Controller: Methods
View Editor
View: Layout
View: Inbound and Outbound Plugs
View: Components of a View Controller
Window Editor
Window: The View Hierarchy
Window: Inbound and Outbound Plugs
Navigation Links of a Window’s Outbound Plugs
Window: Components of a Window Controller
Display an Interface View
Displaying and Defining the Interface Controller
Web Dynpro Application
The Web Dynpro Code Wizard
Web Application Builder for BSPs
Introduction
Structure of a BSP Application
Event Handler
Page Attributes
Global Objects
Basic Functions
Creating BSP Applications
Creating Pages
Creating a Controller
Creating Error Pages
Determining the Page Flow
Creating References to MIMEs
Activating BSP Applications
Executing BSP Applications
Model View Controller (MVC)
MVC Design Pattern
Using MVC for BSP
Creating a Controller
Creating a View
Testing Controllers
Calling (Sub) Controllers
Calling a View
Creating Error Pages
From Pages to Controllers
Call Options of BSP Components
Navigation
Lifetime
Data Binding
Calling the Model Class by the Controller
Components
Process Flow
Creating Your Own Components
Creating the Top-Level Controller
Creating Components
Calling Components
Determining Input Processing
Class CL_BSP_CONTROLLER2
Examples of Architecture
BSP Application with Controllers and Views
BSP Application with Several Views per Controller
Combination of the Previous Examples
Calling Controllers of Other Applications
Calling Several Controllers from a View
Model View Controller Tutorial
Creating a Controller
Creating a View
Calling a Controller
Defining Your Own BSP Extension
BSP Extension Framework
Creating BSP Extensions
Defining BSP Elements
Defining the Element Content
User-Defined Validation
Iteration Through Element Content
Manipulation of the Element Content
Pass by Reference for Attributes
Activating the BSP Extension
Implementing Element Handler Classes
Generated Classes and Class Hierarchy
Basis Class CL_BSP_ELEMENT
Entering Documentation
Using BSP Elements
Example: Using Extensions in BSP Pages
Implementing External Tools with WebDAV
Implementing the Page Layout Using External Tools
Mass Import for MIMEs Using WebDAV
Tips & Tricks
Copying Page Attributes
Mass Import for MIMEs Using WebDAV
MIME Repository
Supported MIME Categories
Importing MIMEs
Uploading and Downloading MIMEs
Creating Folders
Converting MIMEs into BSPs
Deleting MIMEs or Directories
Creating Namespace Folders
Marking MIMEs as Relevant for Translation
Additional Functions
Web Services
Web Services Toolset
Creating a Web Service
Service Definition Wizard
Creating a Service Definition for a Function Group or BAPI
Editing a Service Definition
Releasing a Service Definition for the SOAP Runtime
Administration for SOAP Runtime
Maintaining UDDI Registries
Web Services and Security
Secure Data Transfer
WS Security
Authentication
Authorization
Configuring Security
Configuration of Signature Processing
Consuming a Web Service
ABAP Proxy Runtime
ABAP Proxy Generation
UDDI as a Source for a WSDL Documents
Tips for Generating ABAP Proxies
Converting WSDL to the Target Language
Naming Proxy Objects
Regenerating Proxy Objects
Appendix: Mapping XSD to ABAP
Programming with Client and Server Proxies
Sending a Message
Implementing a Server Proxy
Error Handling
Fault Messages
Reporting and Handling Errors
Protocols
Querying the Payload
Activating Extended XML Handling
Accessing the Message ID
Runtime Configuration
Creating a Logical Port
Example
Creating a Web Service
Testing the Web Service
Creating a Web Service Client Application
Web Application Builder for ITS Services
Introduction
User Settings for Internet Services
Basic Functions
Creating an Internet Service
Components of Internet Services
Using Mixed Mode
Creating HTML Templates
Generation Style: Classic
Generation Style: HTML Business
Generation Style: WebGUI
Extending HTML Templates
Creating MIME Objects
Creating Non-Language-Specific MIME Objects
Creating Language-Specific MIME Objects
Editing MIME Objects
Creating Language Resources
Publishing a Service
Statuses of Web Development Objects
Executing a Service
Tools Used for Implementation Support
Navigating Using Double-Click
Using Patterns and Wizards
Flow Builder
MiniApp Maintenance
Creating MiniApp Objects
Maintaining Entries for MiniApps
Tutorial: Implementing Web Applications
ITS Architecture Components
Step 1: Defining Page Layouts
Step 2: Creating a Service
Step 3: Creating HTML Templates
Step 4: Defining a Layout
Step 5: Implementing the Flow Logic
Step 6: Publishing a Service
Step 7: Executing a Web Application
Maintaining Text Elements
Maintaining Text Elements: Overview
Initial Screen
Creating and Maintaining Text Elements
Creating List and Column Headings
Maintaining Selection Texts
Maintaining Text Symbols
Analyzing Text Elements
Analyzing Selection Texts
Analyzing Text Symbols
Copying Text Elements
Translating Text Elements
Maintaining Messages
Creating Message Classes
Adding Messages
Creating Message Long Texts
Assigning IMG Activities to a Message
Variant Maintenance
Variants: Overview
Initial Screen
Displaying a List of all Variants
Creating and Maintaining Variants
Creating Variants
Variant Attributes
Changing Variants
Deleting Variants
Printing Variants
Variable Values in Variants
Using Variables for Date Calculations
User-specific Selection Variables
Creating User-Specific Variables
Changing Values Interactively
Changing Values from a Program
Fixed Values from Table TVARVC
Creating Table Variables from TVARVC
Maintaining Entries in Table TVARVC
Executing Programs with Variants
Debugger
Runtime Analysis
Information on Development Objects
Navigation and Information System: Overview
The Repository Information System
Environment Analysis
Determining the Environment
Where-used Lists
The Application Hierarchy
The Data Browser
Customizing the Data Browser Display
Other Data Browser Functions
Additional Concepts
Inactive Sources
Concept
Support in the ABAP Workbench Tools
Activating Objects
Overview of Inactive Objects
Status Display
Activating Classes and Interfaces
Effect of Inactive Sources on Operations
Further Effects
Inactive Sources and Modifications
Classic BAdIs
Package Builder
Scenario 1: Defining the Package Hierarchy
Creating a Structure Package
Creating the Main Package
Adding Sub-Packages to the Main Package
Creating Package Interfaces
Scenario 2: Making Services Available
Creating Package Interfaces
Adding Elements to an Interface
Restricting the Use of the Interface
Extending Visibility over Several Levels
Graphic: Extending Visibility
Scenario 3: Using Services from Other Packages
Creating Use Accesses
Graphic: Permissible Use Accesses
Package Architecture in R/3 Enterprise
Creating Packages in the Enterprise Core
Software Components
Structure Packages
Creating Packages in Enterprise Extensions
Activating Enterprise Extensions
Creating Packages in Customer Scenarios
Solution: Scenario 1
Solution: Scenario 2
Solution: Scenario 3
Package Checks and System Settings
Checks and When They Are Performed
System Settings
Package Check Scenario
How the Package Check Works
Troubleshooting
Appendix
The Package Concept
Naming Conventions for Packages
Questions and Answers