133 KiB
133 KiB
Selection Screens and Classic Lists
- Selection Screens and Classic Lists
Introduction
💡 Note
The content of this cheat sheet and the executable examples are only relevant to classic ABAP.
Selection screens and classic lists are among the classic ABAP user interfaces. They are integrated into the ABAP language itself, which means that special ABAP statements are available to create and handle them.
This cheat sheet provides a high-level overview of selection screens and classic lists, focusing on a selection of related statements, supported by executable examples to explore the syntax in action. It includes an excursion into the SAP List Viewer (ALV).
For more detailed information and syntax options, see the topics Selection Screens and Classic Lists in the ABAP Keyword Documentation.
💡 Note
- Although they are considered outdated for application programs, you will still find classic ABAP UIs frequently in classic ABAP.
- Classic ABAP UIs cannot be created in ABAP Cloud.
- This cheat sheet ...
- is not intended to encourage you to start creating classic ABAP UIs for programming new applications.
- does not cover all facets, techniques, and syntax options (there's a rich variety of keywords and additions) in great detail.
- is intended to cover a selection of related syntax that you may encounter in older ABAP code. If you need more information, always consult the ABAP Keyword Documentation.
- Links to the ABAP Keyword Documentation in this cheat sheet refer to the documentation for Standard ABAP (latest version).
Selection Screens
- Are special dynpros in executable programs ("reports"; they're also possible in function groups and module pools, but the focus here is on executable programs).
- Used for data entry in an executable program, i.e. they allow users to ...
- enter parameters (for entering single values).
- provide selection criteria (complex selection options for value lists and value ranges) that can be used to supply an executable program with values to work with.
- Can be created using special ABAP statements in the global declaration part of executable programs
- Are processed by the ABAP runtime framework, which triggers selection screen events (see further down).
- When you create a selection screen and run an ABAP program, the dynpros are generated automatically. These generated dynpros cannot be edited directly.
- Further ways in which selections screens are different from regular dynpros:
- Unlike dynpros, you can create selection screens without using the screen painter tool. The ABAP Editor is the only tool you use to define a selection screen (using ABAP statements).
- They have a more limited set of features, for example, the layout of selection screens is more restricted. However, selection screens offer various types of input fields, which can also be expressed as checkboxes or radio buttons, and which can be grouped and labeled.
- Modification options are limited. For example, you can only use some predefined function codes.
- You cannot define dialog modules in the ABAP program.
- There are two types of selection screens:
- Standalone selection screens
- Defined between the statements
SELECTION-SCREEN BEGIN OF SCREENandSELECTION-SCREEN END OF SCREEN - Can be defined in all programs that can contain dynpros
- Defined between the statements
- Standard selection screens
- Each executable program (and only there) contains a standard selection screen with the dynpro number 1000. Note: If you create a standalone selection screen, you cannot use dynpro number 1000.
- The screen elements on the standard selection screen are defined by all
PARAMETERS,SELECT-OPTIONS, andSELECTION-SCREENstatements that are defined outside of the statements mentioned above for creating standalone selection screens.
- Standalone selection screens
Classic Lists
- Used to output data in a structured and formatted way.
- This output can be ...
- created in the so-called list buffer, a memory area for storing screen lists, i.e. a list that is displayed on a predefined list dynpro (list dynpro that is accessed implicitly when a program is executed; note: this dynpro is not part of the executed program).
- sent to the SAP spool system as a spool list (i.e. a list that is not stored as a screen list but is intended for printing or archiving; the focus of this cheat sheet is on screen lists).
- Typical flow of executable programs that include selection screens and content to be displayed on the list dynpro:
- Programs are executed using the Execute button (F8).
- Selection screens are displayed, users usually make entries for whatever purpose, which are further processed in the program.
- Output result is written to the list buffer and finally displayed (on a list dynpro; note: the list processing is automatically started when running executable programs).
- The list can be further implemented to respond to user interaction, such as clicking a line in the list.
- More modern alternatives for classic lists are available, such as the classes of the SAP List Viewer (ALV), for example
CL_SALV_TABLE.
💡 Note
The program is grouped into so-called event blocks, which can contain implementations for various events (e.g. a selection screen event when a user selects a radio button, or a list event when a user double-clicks a line in the list). These event blocks are introduced by special ABAP statements. When a particular event is triggered, the corresponding event block is called and the appropriate code can be implemented there to react to the user action. See more information here.
ABAP Statements for Selection Screens
Selection screens can be created by using special ABAP statements in the global declaration part of executable programs:
PARAMETERS
- Creates ...
- a program-global variable (similar to
DATAstatements) - an input field on the selection screen automatically, i.e. the content of the program-global variable can be changed via the input field.
- a program-global variable (similar to
- The parameter name can be up to eight characters long.
- Multiple additions are available to define the appearance (e.g.
AS CHECKBOX) or influence the user interface (e.g.OBLIGATORY).
The following table includes code snippets with a selection of available syntax options:
💡 Note
- Various combinations of multiple additions are possible with
PARAMETERSstatement, and some are not. See the ABAP Keyword Documentation for details.- To try out the code examples, you can create a demo executable program, copy and paste the code snippets, and run the programs using F8. They are designed to output content using classic lists.
- The code snippets anticipate topics outlined further down, for example, event blocks and
WRITEstatements.
| Subject/Additions | Notes | Code Snippet |
|
Type specification options |
|
|
|
Parameters using ABAP Dicitionary input helps |
|
|
|
Dynamically specifying the type |
|
|
|
Specifying value options |
|
|
|
Specifying screen options |
|
|
|
Assigning function codes to selection parameters |
|
|
|
Assigning a screen element of a selection screen to a modification group |
|
|
|
Replacing the technical name displayed on the screen |
|
|
SELECT-OPTIONS
- Declares selection criteria for a data object
- Unlike the
PARAMETERSstatement, which specifies a single value for a variable, theSELECT-OPTIONSstatement allows you to specify complex criteria, such as an value range or a list of single values, to include or exclude values, that can be evaluated. - The selection criteria are assigned to a selection table:
- Such a table contains four columns -
LOW,HIGH,OPTION,SIGN- for determining range conditions. Each line of such a table represents a condition. - Typically, the content of the selection table can be evaluated in
SELECTstatements using theINoperator in theWHEREclause. - If the selection table is empty, all lines are respected.
- Selection tables have the same layout as ranges table that can be created using the syntax
TYPE RANGE OF. - For historical reasons, the selection table is a table with header line. Therefore, if you want to address the table content (beyond the use in a
SELECT ... WHERE ... IN ...statement), use the syntaxa[].
- Such a table contains four columns -
- Multiple additions are available, and combinations of them are possible.
The following table includes code snippets with a selection of available syntax options:
💡 Note
- Various combinations of multiple additions are possible with
SELECT-OPTIONSstatements.- To try out the code examples, you can create a demo executable program, copy and paste the code snippets, and run the programs using F8. They are designed to output content using classic lists.
- The code snippets anticipate topics outlined further down, for example, event blocks and
WRITEstatements.
| Subject/Addition | Notes | Code Snippet |
|
Determining the |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
|
Specifying screen options |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
|
Specifying value options |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
SELECTION-SCREEN
SELECTION-SCREENstatements can be used to create and modify the layout of standalone selection screens.- Note: The standard selection screen for executable programs is created automatically. That is, each executable program contains a standard selection screen with dynpro number 1000. The screen elements there are defined by all
PARAMETERS,SELECT-OPTIONS, andSELECTION-SCREENstatements that are not specified within theSELECTION-SCREEN BEGIN OF SCREEN ... SELECTION-SCREEN END OF SCREEN ...block. - Selection screens can be created as regular dynpros or as subscreen dynpros.
- Multiple syntax variants with
SELECTION-SCREENare available. Most of them do not create selection screens, but are used to change the layout of selection screens, create additional screen elements, and so on. - Example: The
PARAMETERSandSELECT-OPTIONSstatements create input fields on an individual line. Using the variants of theSELECTION-SCREENstatement, you can arrange the layout differently. - However, the selection screen cannot be generated if there are conflicts with existing screen elements.
- See the effect with the following snippet. Run a program with the code snippet and comment in the third line. The program terminates. The text to be created (in the same line as the first text) interferes with the first text. However, the fourth line would be possible because there is no overlap.
PARAMETERS pa TYPE string. SELECTION-SCREEN COMMENT /5(10) t1. "SELECTION-SCREEN COMMENT 10(20) t2. "SELECTION-SCREEN COMMENT 20(20) t3.
Creating Selection Screens
| Subject/Statement | Notes | Code Snippet |
|
Creating a selection screen as regular dynpro |
|
|
|
Creating a selection screen as subscreen dynpro |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
Adapting the Selection Screen Layout
| Subject/Statement | Notes | Code Snippet |
|
Adding blank lines |
|
|
|
Creating horizontal lines |
|
|
|
Creating an output field/comment on the selection screen |
|
|
|
Specifying multiple elements in one line and their position in the line |
|
|
|
Creating pushbuttons |
|
|
|
Defining a block |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
|
Defining tabstrips |
|
See the example for |
|
Adding pushbuttons in the application toolbar |
|
The code snippet, copyable to a demo program and executable using F8, implements the following:
|
Using Elements from Other Selection Screens
- You can include screen elements created in other selection screens.
- Statements include the
INCLUDEaddition. These are possible:SELECTION-SCREEN INCLUDE PARAMETERSSELECTION-SCREEN INCLUDE SELECT-OPTIONSSELECTION-SCREEN INCLUDE COMMENTSELECTION-SCREEN INCLUDE PUSHBUTTONSELECTION-SCREEN INCLUDE BLOCKS
- Find more information in the subtopics here.
The following code snippet, copyable to a demo program and executable using F8, implements the following:
- Various screen elements are created. Many of them - all possible syntax options are reflected - are reused and included in another selection screen (9000).
- The selection screen with number 9000 is called if a checkbox is selected. This selection screen then opens in a modal dialog box.
PROGRAM.
TABLES sscrfields.
SELECTION-SCREEN COMMENT /1(30) txt1.
SELECTION-SCREEN SKIP.
PARAMETERS param1 TYPE c LENGTH 10.
SELECTION-SCREEN SKIP.
DATA num TYPE c LENGTH 10.
SELECT-OPTIONS sel FOR num.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN COMMENT /1(30) txt2.
SELECTION-SCREEN PUSHBUTTON /1(15) btn USER-COMMAND cmd.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN COMMENT /1(70) txt3.
PARAMETERS toincl AS CHECKBOX DEFAULT 'X'.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN: BEGIN OF BLOCK blck,
COMMENT /1(30) txt4,
ULINE.
PARAMETERS param2 TYPE c LENGTH 10.
SELECTION-SCREEN END OF BLOCK blck.
SELECTION-SCREEN: BEGIN OF SCREEN 9000 AS WINDOW,
INCLUDE PARAMETERS param1,
INCLUDE SELECT-OPTIONS sel,
INCLUDE COMMENT /1(10) txt2,
INCLUDE PUSHBUTTON /1(15) btn,
INCLUDE BLOCKS blck,
END OF SCREEN 9000.
INITIALIZATION.
txt1 = 'Standard Selection Screen'.
txt2 = 'Pushbutton:'.
txt3 = 'Select the checkbox to demonstrate SELECTION-SCREEN ... INCLUDE'.
txt4 = 'Some text'.
btn = 'Button'.
AT SELECTION-SCREEN.
CASE sscrfields-ucomm.
WHEN 'CMD'.
MESSAGE |Hello { sy-uname }. You clicked the pushbutton| TYPE 'I'.
ENDCASE.
START-OF-SELECTION.
IF toincl = 'X'.
CALL SELECTION-SCREEN 9000 STARTING AT 10 10.
WRITE / `The checkbox was selected, and the modal dialog box opened.`.
WRITE / `This modal dialog box contains multiple included elements.`.
ELSE.
WRITE / `The checkbox was not selected, so the modal dialog box was not opened.`.
WRITE / `This modal dialog box contains multiple included elements.`.
ENDIF.
SKIP.
WRITE / |param1: "{ param1 }"|.
WRITE / |param2: "{ param2 }"|.
WRITE / `Selection table content:`.
LOOP AT sel ASSIGNING FIELD-SYMBOL(<st>).
WRITE / |low: { <st>-low }, high: { <st>-high }, option: { <st>-option }, sign: { <st>-sign }|.
ENDLOOP.
Calling Selection Screens
- There are several ways of how to call selection screens (see here), among them
CALL SELECTION-SCREENstatements. - These statements call selection screens by specifying the dynpro number.
- Any selection screen of the main program (and only from there; including 1000) can be called.
CALL SELECTION-SCREEN 9876.
"STARTING AT/ENDING AT additions for creating a modal dialog box
"The numbers determine how it should be displayed.
"STARTING AT: upper left corner (column and line); ENDING AT: bottom right
"corner (if not specified, it is set automatically)
CALL SELECTION-SCREEN 9345 STARTING AT 10 10.
CALL SELECTION-SCREEN 9345 STARTING AT a b ENDING AT c d.
"You can also predefine selection criteria for a selection screen using
"the addition USING SELECTION-SET.
Excursion: SUBMIT Statements
SUBMITstatements call executable programs and, therefore, selection screens.- In general, every executable program is started implicitly with
SUBMIT. - Selection screens can be considered a parameter interface if the program containing them is executed using
SUBMIT. - Note that when using
SUBMIT, an authorization check for the authorization group is performed using theS_PROGRAMauthorization object.
The following table includes a selection of additions and code snippets (2 programs use the demo names zdemo_abap_report for the calling program and zdemo_abap_report_submit for the called program):
| Subject/Addition | Notes | Code Snippet |
|
Calling a program, ending the current program |
|
|
| Subject/Addition | Notes | Code Snippet |
|
Dynamically calling a program |
|
|
| Subject/Addition | Notes | Code Snippet |
|
Calling a program, interrupting the current program and return |
|
The following code snippets, copyable to demo programs and executable using F8 (execute program
|
| Subject/Addition | Notes | Code Snippet |
|
Specifying a particular selection screen to be called and display it or not |
|
|
| Subject/Addition | Notes | Code Snippet |
|
Passing values to a called selection screen |
|
|
ABAP Statements for Classic Lists
Creating Lists
- Lists consist of consecutive list lines that are filled one after the other using the statement
WRITE. - This way, you can output mostly flat data objects and strings/xstrings, types converted to a character-like value (i.e. no internal table content or structures directly).
- Each time a data object is output, an output length is defined, either implicitly or explicitly (see here).
- The following snippets show a selection of additions to
WRITEstatements, covering positioning, creating special list elements, and formatting options.
"WRITE using an unnamed data object
WRITE 'Hello ABAP.'.
"Named data objects
DATA some_text TYPE string VALUE `Hi, `.
"Note: The text is written right after the previous text in one line.
WRITE some_text && sy-uname.
"/: Writes to a new line
WRITE / 'new line'.
"-------------------------- Positioning output --------------------------
"Specifying the output position (and output in new line)
WRITE /5 'positioned'.
"Specifying the length, no position specified means the output is
"written from the first column on
WRITE /(3) 'not displayed completely'.
"Specifying both length and position
WRITE /5(30) 'this is displayed completely'.
"Position/length only specified as numeric literals as above, then the
"addition AT can be omitted
WRITE AT /3(12) 'lorem ipsum'.
"Length specifications with * or **. In that case, the output length
"depends on the data type of the data object. There are special rules.
"See the ABAP Keyword Documentation for the details.
DATA dc34 TYPE decfloat34 VALUE ' 1.2345 '.
WRITE /(*) dc34.
WRITE /1(**) dc34.
"--------------------- Further specification options ----------------------
"Various examples for further specification options, among them function
"calls, string expressions, method calls
DATA txt TYPE string VALUE `abap`.
"String template
WRITE / |{ txt WIDTH = 20 ALIGN = RIGHT CASE = UPPER }|.
"The following statement uses a chained statement with colon.
WRITE: / |{ 1 + 2 }|, "String template includes an arithmetic calculation
to_upper( txt ). "Function call
"Concatenation using &&
WRITE / `conc` && `atenated`.
"Method call (returns a random integer between 1 and 10)
"Note the * specification. The returned value is of type i. Specifying *
"for the length means the length required to output the current value
"is used. You may want to try the following code snippet by removing (*).
WRITE /(*) cl_abap_random_int=>create(
seed = cl_abap_random=>seed( )
min = 1
max = 10 )->get_next( ).
"UNDER: Output in the position of previous output
"Note: If the output is written in the same line in which the previous output
"is displayed, this output is overwritten.
DATA abc TYPE c LENGTH 5 VALUE 'abcde'.
WRITE /5(5) abc.
WRITE / 'fghij' UNDER abc.
"NO-GAP
WRITE / 'g'.
WRITE 'ap1'. "Output: g ap1
WRITE: / 'g' NO-GAP, 'ap2'. "Output: gap2
"QUICKINFO: Creates a tooltip for the output
WRITE / 'Place the mouse on the following output and check the tooltip:'.
WRITE: (*) sy-uname QUICKINFO 'User name',
'/',
(*) sy-datum QUICKINFO 'Current date',
'/',
(*) sy-uzeit QUICKINFO 'Current time'.
"--------------------- Special list elements ----------------------
"INPUT: Enabling fields for input
"You can overwrite the output and further evaluate the overwritten
"content in a list event.
WRITE / ' Enter your name here ' INPUT.
"AS CHECKBOX
"The value (blank, X) is stored in the list buffer and can be
"evaluated during a list event.
DATA: chck1 TYPE c LENGTH 1 VALUE 'X',
chck2 TYPE c LENGTH 1 VALUE ' '.
WRITE: / chck1 AS CHECKBOX, 'A checkbox',
/ chck2 AS CHECKBOX, 'Another checkbox'.
"AS ICON: Outputting icons
"Check the type pool ICON for names of predefined icons.
WRITE / icon_green_light AS ICON.
WRITE / icon_red_light AS ICON.
WRITE / icon_yellow_light AS ICON.
WRITE / icon_activate AS ICON.
"AS SYMBOL: Outputting symbols
"Check the type pool SYM for names of predefined icons.
WRITE / sym_left_hand AS SYMBOL.
WRITE / sym_caution AS SYMBOL.
"AS LINE: Outputting corners, crosses, lines, and T sections
"Check the type pool LINE for names of predefined icons.
WRITE: /10 line_horizontal_line AS LINE NO-GAP,
line_space AS LINE NO-GAP,
line_vertical_line AS LINE NO-GAP.
Formatting options with WRITE and FORMAT:
"The following examples show a selection. Various other additions are
"available that deal with currency, unit, date and time-related formatting,
"among others. See the ABAP Keyword Documentation.
WRITE /(10) 'X' RIGHT-JUSTIFIED. "' X'
WRITE /(10) 'X' CENTERED. "' X '
WRITE /(10) 'X' LEFT-JUSTIFIED. "'X '
DATA dc TYPE decfloat34 VALUE '1.2345'.
WRITE /(*) dc DECIMALS 2. "1,23
"COLOR addition
"The commented out value stands for the value that can also
"be directly specified in the syntax (except 0) or contained in
"a data object. There are several additions with many options.
WRITE / 'COL_BACKGROUND (0)' COLOR COL_BACKGROUND. "0 (GUI dependent)
WRITE / 'COL_HEADING (1)' COLOR COL_HEADING. "1 (gray-blue)
WRITE / 'COL_HEADING (1)' COLOR 1.
WRITE / 'COL_NORMAL (2)' COLOR COL_NORMAL. "2 (light gray)
WRITE / 'COL_TOTAL (3)' COLOR COL_TOTAL. "3 (yellow)
WRITE / 'COL_KEY (4)' COLOR COL_KEY. "4 (blue-green)
WRITE / 'COL_POSITIVE (5)' COLOR COL_POSITIVE. "5 (green)
WRITE / 'COL_NEGATIVE (6)' COLOR COL_NEGATIVE. "6 (red)
WRITE / 'COL_GROUP (7)' COLOR COL_GROUP. "7 (orange)
WRITE / 'COLOR 7 OFF' COLOR 7 OFF. "default color
"Setting the intensity of the background color.
"Note that many of the following additions can specify further
"additions such as ON and OFF. See the details in the documentation.
WRITE / 'COLOR 7 INTENSIFIED OFF' COLOR 7 INTENSIFIED OFF.
"INVERSE: When ON, the foreground, i.e. the output is displayed
"in the selected color
WRITE / 'COLOR 7 INVERSE ON' COLOR 7 INVERSE ON.
"FORMAT: You can use FORMAT statements for applying settings on the following
"output statements up to a definition with new settings or ... OFF.
"Note: Many of the additions that are also possible for WRITE (e.g. COLOR,
"INTENSIFIED, INVERSE ...) are possible. The following example uses the already
"mentioned COLOR addition.
FORMAT COLOR COL_POSITIVE.
WRITE / 'ABC'.
WRITE / 'DEF'.
WRITE / 'GHI'.
FORMAT COLOR OFF.
"HOTSPOT addition: Displays the mouse pointer when hovering over an element.
"Here, a single click has then the same effect as a double click (i.e. the
"selection of function key F2).
FORMAT HOTSPOT ON.
DO 5 TIMES.
WRITE / sy-index.
ENDDO.
FORMAT HOTSPOT OFF.
"FRAMES addition: Defines whether the - and | characters are converted to line elements,
"producing continuous lines.
FORMAT FRAMES ON.
WRITE: / '----',
/ '| |',
/ '----'.
FORMAT FRAMES OFF.
"RESET addition: Resetting the formatting settings
"This addition sets all formatting settings for which the corresponding addition is
"not specified in the same FORMAT statement to the state OFF (exception: FRAMES).
"In the following example, all settings are reset without specifying concrete
"additions (e.g. INVERSE OFF). Note the effects of such a statement (e.g. INTENSIFIED
"is ON by default at program start; now it is set to OFF). See the ABAP Keyword
"Documentation for more information.
FORMAT COLOR 7 INVERSE ON.
WRITE / 'ABC'.
FORMAT RESET.
WRITE / 'DEF'.
More list-related ABAP keywords:
"Creating a horizontal line
ULINE.
"More additions are available e.g. for position and length
ULINE AT 5(20).
"SET BLANK LINES: Specifying if blank lines created using WRITE are displayed
"In the example, the content of a string table that contains blank lines
"is output.
DATA(itab) = VALUE string_table( ( `a` ) ( `b` ) ( `` ) ( `` ) ( `c` ) ).
"... OFF is set by default. Here it is explicitly specified.
"In this case, the blank lines are not output.
SET BLANK LINES OFF.
LOOP AT itab INTO DATA(wa).
WRITE / wa.
ENDLOOP.
"... ON: The blank lines are output.
SET BLANK LINES ON.
LOOP AT itab INTO wa.
WRITE / wa.
ENDLOOP.
"Setting the list cursor explicitly (more statements are
"available such as POSITION or BACK)
"SKIP: Positions the list cursor in another line (creating blank lines)
SKIP. "Skips 1 line
SKIP 3. "Specifying the number of lines to be skipped
"SKIP TO LINE
"In the example, the list cursor is explicitly set to
"a particular number. Here, B and C are not output (i.e.
"overwritten with the output that follows).
WRITE / 'Text A'.
WRITE / 'Text B'.
DATA(line) = sy-linno. "The line number of the previous WRITE is retrieved.
WRITE / 'Text C'.
SKIP TO LINE line.
WRITE / 'Text D'.
WRITE / 'Text E'.
"NEW-LINE: Setting list cursor to the first position of the next line
"Additions are available to affect the scrolling behavior
WRITE / 'Next statement is NEW-LINE'.
NEW-LINE.
WRITE 'WRITE statement without /'. "Output is in new line
"HIDE: Storing the content of a flat variable together with the current list line.
"Example: a (3) is the result of b (1) + c (2). Suppose you click the line
"where a is output. You may e.g. output then b and c (e.g. another WRITE in the
"AT LIST-SELECTION event block), then getting the correct context of the list line.
...
a = b + c.
WRITE / a.
HIDE: b, c.
...
"RESERVE: Creating a page break if there is not enough space left on the current list
"page between the last output and the page end or page footer, as specified with the number.
RESERVE 3 LINES.
"Consider the 3 lines defined as block. When you use BACK after RESERVE, e.g. after a loop, you
"can put the suqsequent output to the first line of this block of lines. See the effect in the
"executable example.
...
BACK.
WRITE ...
Reading and Modifying in Lists
READ LINE statements:
- Assign the content of a line stored in the list buffer to the system field
sy-lisel. - Plus, it allows other target fields to be specified.
sy-subrcis set: 0 (line was read), other than 0 (line does not exist)
"More additions than those covered are available (e.g. for
"list level and list page)
"sy-lisel contains the entire line content of the specified line
READ LINE 1.
"sy-lisel contains the entire line content of the current line
READ CURRENT LINE.
"Assigning the output of individual data objects
"Here, it is the entire line content.
DATA wa TYPE c LENGTH 50.
READ CURRENT LINE LINE VALUE INTO wa.
"Here, specific field values (val1/val2) are assigned to individual data objects
DATA dobj1 TYPE c LENGTH 10.
DATA dobj2 TYPE c LENGTH 10.
READ CURRENT LINE FIELD VALUE val1 INTO dobj1 val2 INTO dobj2.
MODIFY LINE statements:
- Overwrites a line stored in the list buffer with the content of the
sy-liselsystem field - Plus, it allows additional modifications
"Overwrites line stored in sy-lisel (which is filled e.g. using a previous
"READ LINE statement)
MODIFY CURRENT LINE.
MODIFY LINE 2.
"Specifying content to overwrite an existing line; the following examples
"only use the addition CURRENT LINE
"Overwrites the entire list line with the content
MODIFY CURRENT LINE LINE VALUE FROM 'hi'.
"Overwrite a specific field with specified content
MODIFY CURRENT LINE FIELD VALUE a FROM b.
"Mutliple fields specified
MODIFY CURRENT LINE FIELD VALUE a FROM b c FROM d.
"Change the format (here using COLOR)
"... of a specific field
MODIFY CURRENT LINE FIELD FORMAT a COLOR 3.
"... of the line
MODIFY CURRENT LINE LINE FORMAT COLOR 4.
"Note: Multiple additions and combinations are possible, using COLOR here
MODIFY CURRENT LINE FIELD FORMAT a COLOR 5 b COLOR 6 LINE FORMAT COLOR 7.
💡 Note
- Relevant sy components in the context of lists
- You can interact with a list by double-clicking a line (or pressing F2; the default
PICKfunction code raises theAT LINE-SELECTIONevent). Other function codes usually trigger theAT USER-COMMANDevent. See the event blocks below. In your ABAP program, you can react to the user action by implementing the individual event blocks. Regarding the function code, you can use thesy-ucommsystem field for evaluation (unlike dynpros, there's noOK_CODEfield to be filled).
Event Blocks
- Notes
- Introduced by an event keyword.
- Ended by the next processing block (there's no closing statement).
- Should not contain separate declarations, i.e. you should put all data object declarations in the global declaration part (except for
AT SELECTION-SCREEN ...) - It is recommended that you use ABAP Objects and methods consistently for data encapsulation
- Should not be specified more than once in a program
- Called depending on the user action and the program state (even if not explicitly specified)
LOAD-OF-PROGRAM- Program constructor
- Called when a program is loaded into the internal session
- Can be used to initialize the global data of a program. However, for executable programs, it is recommended that you use the event block
INITIALIZATIONfor this task since the start values for parameters and selection criteria are set afterLOAD-OF-PROGRAM.
- Reporting events related to executable programs in particular (and occur in predefined order).
INITIALIZATION- Used to initialize executable programs and provide start values (that cannot be statically expressed using
DEFAULT) - Called directly after
LOAD-OF-PROGRAMand before selection screen processing
- Used to initialize executable programs and provide start values (that cannot be statically expressed using
START-OF-SELECTION- Called after selection screen processing (see the following event blocks)
- If an executable program does not contain selection screens, this block is called automatically and implicitly.
- All statements are implicitly assigned to this block unless they are explicitly assigned to another block.
- Although it is optional, it is recommended that you specify the statement explicitly to improve readability.
- Selection screen events
- Used to individually evaluate selection screen elements, e.g. a specific parameter.
- In many cases, the events can be used for input validation (this should not wait until
START-OF-SELECTION). If your custom input validation fails on an input, you can raise a message (e.g. a message of typeE:MESSAGE 'Error' TYPE 'E'.) and allow users to edit the input again. AT SELECTION-SCREEN OUTPUT
Called by the dynpro event PBO of a selection screen afterINITIALIZATION; can be used for modifying screen elements (e.g. usingMODIFY SCREEN)AT SELECTION-SCREEN ON par
Called when values for a parameter or selection criteria were passed to the program; note: the syntax is also available for selection criteria; an additional variant... ON END OF ...is available (this event block is called when the selection table is passed completely allowing to check the entire selection table content)AT SELECTION-SCREEN ON BLOCK bl
Called when all input for a block is passed to the programAT SELECTION-SCREEN ON RADIOBUTTON GROUP gr
Called when the values for a radio button group were passedAT SELECTION-SCREEN ON EXIT-COMMAND
Called by Back, Exit, or Cancel (e.g. used for cleanup tasks)AT SELECTION-SCREEN ON HELP-REQUEST | VALUE-REQUEST
Relates to field (F1) and input (F4) helpAT SELECTION-SCREEN.
Called as last event in the selection screen processing when all input values are passed to the program
- List events
- Are triggered during the list creation and after certain user actions on a displayed list.
- During list creation:
TOP-OF-PAGE
For definining page headers; called when a basic list is created and when a new page begins (... DURING LINE-SELECTIONis called when details lists are created)END-OF-PAGE
For definining page footers; called when the end of a page is reached, for example, when the specified number of lines in theLINE-COUNTaddition (e.g.PROGRAM LINE-COUNT 20(3).) has been reached
- After user actions:
AT LINE-SELECTION
Called when a screen list is displayed, the screen cursor is on a list line and a function is selected using the function codePICK; when specified, the function key F2 is enabled and, therefore, double click functionality; F2 and a double click are linked with the function codePICK.AT USER-COMMAND
Called when a function with a user-defined function code is selected when a screen list is displayed; the function codes can be evaluated usingsy-ucomm; you can set a list event programmatically usingSET USER-COMMAND
Excursion: SAP List Viewer (ALV)
- Provides an object-oriented API for displaying and formatting lists
- Allows you to specify layout settings and functionality
- Classes such as
CL_SALV_TABLEencapsulate the use of the ALV grid control and simplify the integration into ABAP programs. Note: The older classCL_GUI_ALV_GRIDshould no longer be used directly for new developments. - Other classes are available to handle hierarchical lists and tree structures. The focus of the code snippets is on simple, non-nested tables and the use of the
CL_SALV_TABLEclass.
Getting Started
- To get started quickly, you only need to ...
- instantiate an ALV table object using the
factorymethod. - define the display type for the ALV output. By default, full-screen display is enabled.
- display the ALV output using the
displaymethod.
- instantiate an ALV table object using the
💡 Note
- When working with ALV, make sure that you implement appropriate error handling.
- The
factorymethod also has optional exporting parameters. You can use the optionallist_displayparameter to specify whether you want to display the ALV output as classic list. It is set to false by default. There are also exporting parameters to display the ALV output in containers (e.g. see the dynpro cheat sheet example). The exporting parameters are not relevant in this example. Here, the ALV output is displayed on the entire screen (however, it is also possible to display the ALV output in a dialog box).
The following code snippet shows a simple example to get you started quickly with the necessary method calls. It includes a demo internal table with content.
TYPES: BEGIN OF demo_struct,
col1 TYPE string,
col2 TYPE i,
col3 TYPE c LENGTH 1,
END OF demo_struct.
DATA itab TYPE TABLE OF demo_struct WITH EMPTY KEY.
itab = VALUE #( ( col1 = `abc` col2 = 1 col3 = 'X' )
( col1 = `def` col2 = 2 col3 = 'Y' )
( col1 = `ghi` col2 = 3 col3 = 'Z' ) ).
TRY.
cl_salv_table=>factory( IMPORTING r_salv_table = DATA(alv)
CHANGING t_table = itab ).
alv->display( ).
CATCH cx_salv_msg INTO DATA(err).
MESSAGE err->get_text( ) TYPE 'I' DISPLAY LIKE 'E'.
ENDTRY.
Optional Layout Settings and Functionality
- The following commented code snippet covers a selection of the many setting and functionality options.
- For simplicity of the snippet, the code only uses the root exception class. Make sure that you implement appropriate error handling and exception classes.
- You can copy and paste the code into your own test program to explore the ALV output and the effect of the method calls.
💡 Note
Check the comments for the custom functions. If there are errors in your test program, replace the relevant code section and enable the generic ALV functions.
TYPES: BEGIN OF demo_struct,
col1 TYPE string,
col2 TYPE i,
col3 TYPE string,
col4 TYPE icon_d,
col5 TYPE string,
END OF demo_struct.
DATA itab TYPE TABLE OF demo_struct WITH EMPTY KEY.
DATA alv TYPE REF TO cl_salv_table.
DATA cnt4evt TYPE i VALUE 6.
"Local class to handle events
CLASS lcl_events DEFINITION.
PUBLIC SECTION.
CLASS-METHODS single_click
FOR EVENT link_click OF cl_salv_events_table
IMPORTING row column.
CLASS-METHODS double_click
FOR EVENT double_click OF cl_salv_events_table
IMPORTING row column.
CLASS-METHODS func_click
FOR EVENT added_function OF cl_salv_events
IMPORTING e_salv_function.
ENDCLASS.
CLASS lcl_events IMPLEMENTATION.
METHOD single_click.
"Both single and double click events trigger messages.
READ TABLE itab INDEX row REFERENCE INTO DATA(sc_ref).
IF sy-subrc = 0.
ASSIGN sc_ref->(column) TO FIELD-SYMBOL(<fs_sc>).
MESSAGE `Single click event. ` &&
|Row: { row } { COND #( WHEN column IS NOT INITIAL THEN `Column: ` && column ) } | &&
|{ COND #( WHEN <fs_sc> IS ASSIGNED THEN `Value: ` && <fs_sc> ) }| TYPE 'I'.
ELSE.
MESSAGE `Single click event` TYPE 'I'.
ENDIF.
ENDMETHOD.
METHOD double_click.
READ TABLE itab INDEX row REFERENCE INTO DATA(dc_ref).
IF sy-subrc = 0.
ASSIGN dc_ref->(column) TO FIELD-SYMBOL(<fs_dc>).
MESSAGE `Double click event. ` &&
|Row: { row } { COND #( WHEN column IS NOT INITIAL THEN `Column: ` && column ) } | &&
|{ COND #( WHEN <fs_dc> IS ASSIGNED THEN `Value: ` && <fs_dc> ) }| TYPE 'I'.
ELSE.
MESSAGE `Double click event` TYPE 'I'.
ENDIF.
ENDMETHOD.
METHOD func_click.
"Handling custom functions
CASE e_salv_function.
WHEN 'DATA'.
MESSAGE `Custom function DATA. Do something ...` TYPE 'I'.
WHEN 'TEST'.
IF cnt4evt = 6.
MESSAGE `A table row will be added, demonstrating the 'refresh' ` &&
`method that rebuilds the output table.` TYPE 'I'.
ENDIF.
cnt4evt += 1.
itab = VALUE #( BASE itab ( col1 = `fffff` col2 = cnt4evt
col3 = `ttttt` col4 = icon_green_light ) ).
"Rebuilding the output table
alv->refresh( ).
WHEN 'QUIT'.
MESSAGE `Custom function QUIT. Do something ...` TYPE 'I'.
WHEN OTHERS.
MESSAGE `Some other function` TYPE 'I'.
ENDCASE.
ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.
"Populating internal table that is output
itab = VALUE #( ( col1 = `aaaaa` col2 = 1 col3 = `zzzzz` col4 = icon_green_light )
( col1 = `bbbbb` col2 = 2 col3 = 'yyyyy' col4 = icon_green_light )
( col1 = `ccccc` col2 = 3 col3 = 'xxxxx' col4 = icon_green_light ) ).
TRY.
"----------- Instantiating an ALV table object -----------
cl_salv_table=>factory( IMPORTING r_salv_table = alv
CHANGING t_table = itab ).
"----------- Creating a new instance with new data -----------
"Notes on the set_data method:
"- All objects that were referred to previously are removed.
"- Not to be used in event handlers.
"In the example, new lines are added to the existing internal table.
itab = VALUE #( BASE itab ( col1 = `ddddd` col2 = 4
col3 = `wwwww` col4 = icon_green_light )
( col1 = `ddddd` col2 = 5
col3 = `vvvvv` col4 = icon_green_light )
( col1 = `eeeee` col2 = 6
col3 = `uuuuu` col4 = icon_green_light ) ).
alv->set_data( CHANGING t_table = itab ).
"----------- Layout-related settings -----------
"Changing the list header title
CAST cl_salv_display_settings(
alv->get_display_settings( ) )->set_list_header( 'Demo Title' ).
"There are several methods to retrieve column-specific information.
"The following examples show a selection. You can check the variable
"content in the debugger.
DATA(col1obj) = alv->get_columns( )->get_column( 'COL1' ).
DATA(col1alignment) = col1obj->get_alignment( ).
DATA(col1type) = col1obj->get_ddic_inttype( ).
DATA(col1colname) = col1obj->get_columnname( ).
DATA(is_col1_visible) = col1obj->is_visible( ).
"Settings for the column header
"This example uses the get method, which returns all column objects of
"the output table. The table is processed in a loop.
"Settings covered:
"- Specifying the column header titles (long, medium, and short
" column header)
"- Specifying a tooltip for the column header
LOOP AT alv->get_columns( )->get( ) REFERENCE INTO DATA(colref).
"Specifying the column header titles
"The example sets the texts based on the columname value.
"Note: The column width is optimized further down. You may want to
"manually adjust the width in the ALV output to see the column header
"name change.
colref->r_column->set_long_text( |{ colref->columnname }| ).
colref->r_column->set_medium_text( |{ colref->columnname+2(3) }| ).
colref->r_column->set_short_text( |{ colref->columnname+3(3) }| ).
"Specifying a tooltip for the column headers
colref->r_column->set_tooltip(
|Demo tooltip { colref->columnname+3(3) }| ).
ENDLOOP.
"Displaying/Hiding the column headers
"In the example, the value is set to abap_true. Set it to abap_false
"to hide the column header.
"Note: In this and the following examples, the settings are
"intentionally done using separate casts for each example. You can also
"create object reference variables, such as for 'col1obj' to avoid having
"to specify the casts explicitly each time.
CAST cl_salv_columns_list(
alv->get_columns( ) )->set_headers_visible( abap_true ).
"Setting key columns
"Note: The key columns have a default color setting. There, you can only
"change the color in individual cells.
CAST cl_salv_column_table(
alv->get_columns( )->get_column( 'COL1' ) )->set_key( abap_true ).
"Setting column color
"Note: The executable example includes examples of coloring entire rows and
"specific cells.
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL2' )
)->set_color( VALUE lvc_s_colo( col = col_positive ) ).
"Hiding columns
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL5' )
)->set_visible( abap_false ).
"Setting text alignment
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL2' )
)->set_alignment( if_salv_c_alignment=>left ).
"Optimizing column width, i.e. automatically adjusting the column width
"to display values completely (can also be done for individual columns)
alv->get_columns( )->set_optimize( abap_true ).
"Setting output width explicitly (for an individual column)
"Note: Just to demonstrate the method call. This setting has no effect in
"the example due to the column width optimization above, and the column is
"hidden anyway.
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL5' )
)->set_output_length( '100' ).
"Setting table rows to a striped pattern
alv->get_display_settings( )->set_striped_pattern( abap_true ).
"Displaying/hiding horizontal and vertical grid lines (here, they're hidden)
alv->get_display_settings( )->set_horizontal_lines( abap_false ).
alv->get_display_settings( )->set_vertical_lines( abap_false ).
"With the following method call, the ALV output is displayed in a dialog box.
"Demo coordinates are provided. You can comment it in to see the effect.
* alv->set_screen_popup( start_column = 10
* end_column = 100
* start_line = 4
* end_line = 15 ).
"------ Adding functionality/user interaction options to the ALV output ------
"Specifying the selection type
"The following specification allows you to select multiple rows/columns (a column
"is added on the left for selections). Check the other options in the
"if_salv_c_selection_mode interface.
alv->get_selections( )->set_selection_mode( if_salv_c_selection_mode=>row_column ).
"Setting the sorting
"In the example, a particular column is sorted in descending order.
alv->get_sorts( )->add_sort( 'COL1' )->set_sequence( if_salv_c_sort=>sort_down ).
"Applying a filter
"The example is implemented to exclude one entry from the demo table.
alv->get_filters( )->add_filter( 'COL2' )->add_selopt( sign = 'E'
option = 'EQ'
low = '6' ).
"Making a calculation/aggregation
"In this example, an aggregation is added for a specific column.
"In this case, the average value is calculated. It is displayed in a row added
"at the bottom of the table.
alv->get_aggregations( )->add_aggregation(
columnname = 'COL2'
aggregation = if_salv_c_aggregation=>average ).
"Generic and custom ALV functions
"Note:
"- By default, ALV functions (such as sorting or filtering) are not available
" to users. You must explicitly enable them.
"- Depending on whether the display is full-screen (as it is here) or in a
" container, restrictions apply. In the first case, you can use your own GUI status
" to integrate custom functions.
"This (self-contained, ready-to-use) code snippet is intended so that you can simply
"copy & paste the code into a test program. For this purpose, and to be able to
"demonstrate custom functions in this full-screen ALV example using a GUI status, the
"example uses a demo GUI status that is included in another sample program (in a
"subpackage of SALV). For your own GUI status, you can check the SALV_TABLE_STANDARD
"status contained in the SALV_METADATA_STATUS function group, which you can copy and
"use as a template, for example.
"*********************************** NOTE ***********************************
"- The GUI status used here is just reused to have a copyable and self-contained example.
"- The GUI status of the sample program (specified for the report parameter below)
" contains generic and additional functions. For the additional functions, a simple
" implementation is included in this snippet. The GUI status should include the
" functions TEST, DATA, QUIT.
"- The implementations in the event handler class here do not match the implementations
" there, the button texts do not make sense for the implementations here, and so on.
"- So even though it (the button names, icons, implementations, etc.) does not make much
" sense for this snippet, you should get an idea about custom functions and be able to
" explore the event handling by clicking on the buttons.
"- The TEST function demonstrates adding new rows to the table and the 'refresh' method.
"- If this particular program, the GUI status and/or the custom functions are not available
" in your system, or if you insert the code into your own test program, run it, and
" encounter problems setting the status, remove the TRY control structure that contains
" the set_screen_status method call, and comment in the code below to use the standard
" ALV functions. In this case, the custom functions cannot be checked out with this
" snippet.
"- Check out the executable example of the cheat sheet that includes a GUI status.
TRY.
alv->set_screen_status(
pfstatus = 'SALV_TABLE_STANDARD'
report = 'SALV_TEST_REFRESH'
set_functions = alv->c_functions_all ).
"In this GUI status, the custom functions TEST, DATA, and QUIT are specified. You can
"check the results of the following method calls in the debugger.
DATA(getfunc) = alv->get_functions( ).
"Checking the activation status
DATA(is_enabled) = getfunc->is_enabled( 'TEST' ).
"Checking the visibility
DATA(is_visible) = getfunc->is_visible( 'TEST' ).
"Registering an event handler for the custom functions
"The added_function event is raised. In the implementation of the event handler method,
"you can then implement your code based on the value of the e_salv_function parameter
"(which contains the specified function name), for example, using a CASE statement.
"The implementation in this code snippet is different from the original program.
SET HANDLER lcl_events=>func_click FOR alv->get_event( ).
CATCH cx_salv_object_not_found.
MESSAGE `GUI status error. Instead, use the set_default method, for example.`
TYPE 'I'.
ENDTRY.
"If you remove the TRY control structure above, you can comment in the following
"code to use the generic ALV functions. Use the set_all method for all generic
"functions. You can also enable generic ALV functions individually. Check the
"set_* methods.
"alv->get_functions( )->set_default( abap_true ).
"Hotspot/single click functionality
"You can define the content of a cell as a clickable area. You can do this by
"specifying the cell type hotspot. When a user clicks the cell content,
"the link_click event is raised.
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL1' )
)->set_cell_type( if_salv_c_cell_type=>hotspot ).
"You can set icon columns and make the icon cells clickable areas. To do this,
"use the set_icon method. As above, the cell type of the column is set to hotspot.
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL4' )
)->set_icon( if_salv_c_bool_sap=>true ).
CAST cl_salv_column_table( alv->get_columns( )->get_column( 'COL4' )
)->set_cell_type( if_salv_c_cell_type=>hotspot ).
"An event handler is registered for the clickable areas (the link_click event
"is raised). The get_event method returns the required event object. In the
"example, a message is displayed.
SET HANDLER lcl_events=>single_click FOR alv->get_event( ).
"Double click functionality
"Registering an event handler for the double click event. In the example, a message
"is displayed. Double-click cells in columns for which the cell type is not set to hotspot.
SET HANDLER lcl_events=>double_click FOR alv->get_event( ).
"Adding tooltips to the icon column cells
alv->get_functional_settings( )->get_tooltips( )->add_tooltip(
type = cl_salv_tooltip=>c_type_icon
value = CONV lvc_value( icon_green_light )
tooltip = `This is a tooltip for an icon` ).
"----------- Displaying the ALV output -----------
alv->display( ).
CATCH cx_root INTO DATA(error).
"For simplicity, this example uses the root exception class.
"Always make sure that you use appropriate exception classes. Check the F2
"information for the methods in ADT.
MESSAGE error->get_text( ) TYPE 'I' DISPLAY LIKE 'E'.
ENDTRY.
More Information
- ABAP Keyword Documentation:
- ALV:
- SAP List Viewer (ALV) on the SAP Help Portal
- Find more demonstration examples in package
SALVand its subpackages.
Executable Examples
After the import of the repository, proceed as follows:
- Find the program in ADT using the search by choosing
CTRL + SHIFT + A. - Enter
ZDEMO_ABAP_SELSCR_LISTS_INTROand open the program. This program serves as an entry point for all selection screen and list examples. Program names of the individual examples:ZDEMO_ABAP_SELSCR_PARAMETERS: DemonstratesPARAMETERSstatementsZDEMO_ABAP_SELSCR_SELECT_OPT: DemonstratesSELECT-OPTIONSstatementsZDEMO_ABAP_SELSCR_STANDALONE: Demonstrates the creation (SELECTION-SCREENstatements) and calling of standalone selection screensZDEMO_ABAP_SELSCR_STMTS_VAR: Demonstrates variants of theSELECTION-SCREENstatements that do not create selection screensZDEMO_ABAP_LISTS: Demonstrates various ABAP statements to create and handle classic listsZDEMO_ABAP_EVENT_BLOCKS: Demonstrates event blocksZDEMO_ABAP_ALV: Demonstrates the SAP List Viewer (ALV)
- Run the program by choosing
F8.
💡 Note
- The examples in the main branch of the ABAP cheat sheet repository are designed to be imported into the SAP BTP ABAP Environment. For Standard ABAP, you can find examples (such as
ZDEMO_ABAP_SELSCR_LISTS_INTRO) in the other branches of the repository.- The executable examples ...
- do not claim to include meaningful selection screens and lists.
- are not intended to be role models for proper selection screen and list design.
- are not intended to solve concrete programming tasks. You should always work out your own solution for each individual case.
- are only intended to demonstrate a selection of keywords and visualize related syntax in action on a high level.
- include comments in the program code.
- The steps to import and run the code are outlined here.
- Disclaimer