BC - ABAP Workbench: Tools
New Features in Release 6,20
New Features in Release 6.10
Object Navigator
Object Lists in the Object Navigator
Selecting Objects
Creating New Objects
Creating Programs
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
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
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
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
MIME Repository
Supported MIME Categories
Creating References to MIMEs
Importing MIMEs
Creating Folders
Converting MIMEs into BSPs
Deleting MIMEs or Directories
Creating Namespace Folders
Marking MIMEs as Relevant for Translation
Additional Functions
Changing Page Layouts in BSP Applications
Creating Themes
Redefining MIME Objects
Assigning Themes to BSP Applications
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
XSLT Editor
Creating XSLT Programs
SAP XSLT Processor Reference
Statements
Creating the Result Tree
Flow Control
Defining and Calling Template Rules
Stylesheets and Structuring
Top-Level Help Statements
Output
Additional SAP Statements
sap:call-external
sap:external-function
sap:function
Functions
XPath Functions
XSLT Functions
Additional SAP Functions
Preprocessor Sequences
General Constraints
Activating XSLT Programs
Testing the XSL Transformation
Creating Breakpoints
XSLT Debugger
Starting and Exiting a Debugging Session
The Debugger User Interface
Result View
Breakpoint View
Call View
Variable View
Breakpoints
Creating Breakpoints
Saving Breakpoints
Deleting Breakpoints
Debugger Execution Types
XSLT Debugger and ABAP Debugger
ABAP Workbench: Tools
Overview of the Workbench
Tool Integration and Working Methods
Development Objects and Packages
Development in a Team Environment
Learning More
ABAP Editor
Introduction to the ABAP Editor
The Frontend Editor
Table Control Mode
Changing the Editor Mode
Local Editing
Creating Programs
Editing the Source Code
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)
Search and Replace (Backend Editor)
Inserting Statement Patterns
Inserting Patterns Using Drag and Drop
Expanding Includes
Using ABAP Help
Improving the Layout
Features of the Pretty Printer
Saving and Activating Programs
Checking Programs
Extended Program Check
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
Variants
Variants: Overview
Initial Screen
Displaying an Overview of 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 TVARV
Creating Table Variables in Table TVARV
Changing Entries in Table TVARV
Executing a Program with a Variant
Maintaining Messages
Creating Message Classes
Adding Messages
Creating Message Long Texts
Assigning IMG Activities to a Message
The Splitscreen Editor
Overview
Starting the Splitscreen Editor
Initial Screen
Special Splitscreen Editor Functions
Editor Functions
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 Internal Types in Classes
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
Creating 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
Area Menu Maintenance from Release 4.6A
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
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
Debugger
Runtime Analysis
Performance Trace
Performance Trace: Overview
Architecture and Navigation
Initial Screen
Recording Performance Data
Starting the Trace
Stopping the Trace
Analyzing Performance Data
Display Filter
Other Filters
Displaying Lists of Trace Records
Analyzing Trace Records
SQL Trace Analysis
Embedded SQL
Measured Database Operations
Logical Sequence of Database Operations
Buffering
Analyzing a Sample SQL Data File
Example Explanation of an Oracle Statement
Example Explanation of an Informix Statement
Enqueue Trace Analysis
Enqueue Trace Records
Detailed Display of Enqueue Trace Records
RFC Trace Analysis
RFC Trace Records
Detailed Display for RFC Trace Records
Other Funtions
Configuring the Trace File
Saving Lists Locally
The Explain SQL Function
Finding Dictionary Information
Information About 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
New 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
Business Add-Ins
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