BC ABAP Workbench Tools
   New Features in Release 4.6C
   Object Navigator
      Working With Development Objects
         Selecting Objects
         Creating New Objects
            Creating a Program
         Copying Objects
         Deleting Objects
         Assigning an Object to a Different Development Class
         Activating Objects
         Using Set Mode
         Navigation Areas
            Hiding the Navigation Area
         Navigating in the Tool Area
         Object List Functions
         Navigation Stack
         Navigation Context
            Setting Markers
      User-Specific Settings
   Integrating Internet Services
      Web Application Builder
         Creating an Internet Service
            Using Mixed Mode
         Creating HTML Templates
         Extending HTML Templates
         Adding MIME Objects
         Creating Language Resources
         Publishing a Service
         Executing a Service
      User Settings for Internet Services
      Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
         Documentation Not Available in Release 4.6C
   ABAP Workbench: Tools
      Overview of the Workbench
         Tool Integration and Working Methods
         Development Objects and Development Classes
            Development in a Team Environment
         Further Reading
      ABAP Editor
         Introduction to the ABAP Editor
            The Frontend Editor
            Table Control Mode
            Changing the Editor Mode
            Local Editing
         Creating a Program
         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: 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 a Message Long Text
         Assigning IMG Activities to a Message
      The Splitscreen Editor
         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 New Classes
            Creating New Interfaces
         Defining Components
            Class Editor
            Creating Attributes
            Creating Methods
            Creating Parameters and Exceptions
            Implementing Methods
            Creating Events
            Creating Internal Types in Classes
         Defining Relationships Between Object Types
            Implementing Interfaces in Classes
            Creating Subclasses
               Extending Subclasses
            Nesting Interfaces
         Activating Classes and Interfaces
            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
            Element List in Graphical Mode
         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
            Display Attributes
            Tabstrip Control Attributes
            Table Control Attributes
            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
            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
      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
                  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
   Other Concepts
      Inactive Sources
         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