SAP Library - BC - ABAP Workbench: Tools

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

Fehlerseiten anlegen

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

Calling a Controller

Calling a View

Fehlerseiten anlegen

goto Tag and call Tag

Class CL_BSP_CONTROLLER

Navigation->goto_page and goto Tag

Call Options of BSP Components

Componentization

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

Copying Page Attributes

Mass Import for MIMEs Using WebDAV

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

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

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 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 Tool

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

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