Approach to OOP

The fundamental idea behind the Object

Oriented approach is to combine both the
data and functions that operate on the
data into a single unit.

Features of OOPs
Emphasis is on Data rather than procedure
Programs are divided into Classes and Objects
Functions that operate on data are tied together
with data
Data is hidden and cant be accessed by
external functions
Objects can communicate through functions

Benefits of OOPs
Better Security to the data
Code Reusability
Reduction of Implementation costs and
time
Software complexity can be easily
managed
Improves the quality and productivity

Concepts of OOP

Object and class

Data Abstraction and Encapsulation
Inheritance
Polymorphism
Interfaces
Exception handling

Class and Objects

Class is a Collection of Data and Methods
(Functions) to manipulate the data
Objects are like variables of type Class
Class contains..
Attributes (Variables)/data
Methods (Services)
Events

Classes: 2 types
Local Classes SE38
Global Classes SE24

Class Syntax
Class c1 definition.
Public section
Methods

Protected section
Private section

Endclass
Class C1 implementation.
Methods
Endmethod
Endclass
Data: object obj1 type ref to C1
Create object obj1
Call method obj1-Method

Syntax of the Class

Class class-name
{
Private :
variable declaration.
function declaration.
Public :
variable declaration.
function declaration.
Protected :
variable declaration.
function declaration.
}

Access Specifies
Private : The private members can be
accessed only with in the class.
Public : The public members can be
accessed outside the class.
Protected : The main purpose of the
protected visibility label inherit derived
from it.

Encapsulation
Combining of Data and functions into a
single unit (Class) is called as
Encapsulation (Data Binding)
The data is not accessible to the outside
functions. Only those functions, which are
combined in the class can access it.
The hiding of data from direct access by
the program is called Data Hiding

Inheritance
The mechanism of deriving a new class from an old class
is called inheritance.
The concept of inheritance is based on the reusability of
the properties of the existing classes by the newly created
class.
The old class is called base class, and the new class is
called as derived class.
The derived class inherits some (or) all of the traits from
the base class.
It is a mechanism by which objects of one class can
acquire the properties of another class.
Inheritance leads to the idea of reusability

Polymorphism
Polymorphism means one name ,multiple forms.
Polymorphism is a feature that allows a single
name/operator to be associated with different operations
depending on the type of the data passed.
Polymorphism is implemented using the function
overloading, operator overloading and dynamic binding
(virtual functions).
Polymorphism are two types :
1.Compiletime polymorphism.
2.Runtime polymorphism.

Overloading
Function overloading :

The concept of function-overloading allows

multiple functions to share the same name with different
argument types.

using the concept of function overloading, we

can design a family of function with one function name but
with different argument lists.
Operator overloading :

The mechanism of providing the operators with

a special meaning for a data type is called operator
loading.

Interfaces
Interfaces are used to define a group of constants,
variables and Methods. Interfaces are just like classes,
methods are declared with out any implementation.
The implementation part of the methods are declared in
subclasses. Any number of classes can implement the
same interface.
Some rules to be remembered:
All methods in an interface are by default public.
An interface can extend any number of interfaces, but
dont implement any interface.
A class can implement any number of interfaces but no
interfaces can be extended to a class.

Exception Handling
Exceptions refers to unusual conditions in
a program that causes the programs to fail
(or) certain conditions that lead errors.
The error handling mechanism is called
exception handling.
Exceptions are classified into two groups:

Synchronous exceptions

Asynchronous exceptions

Example-1

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: M1.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
WRITE: / 'hello'.
ENDMETHOD.
"M1
ENDCLASS.
"c1 IMPLEMENTATION
DATA: O1 TYPE REF TO C1.
START-OF-SELECTION.
CREATE OBJECT O1.
CALL METHOD O1->M1.

Example-2

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: M1 IMPORTING A TYPE I.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
WRITE: / A.
ENDMETHOD.
"M1
ENDCLASS.
"c1 IMPLEMENTATION
DATA: O1 TYPE REF TO C1.
START-OF-SELECTION.
CREATE OBJECT O1.
CALL METHOD O1->M1 EXPORTING a = 4.

Example-3

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: M1 IMPORTING A TYPE I
EXPORTING B TYPE I.
ENDCLASS.
"c1 DEFINITION
.
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
B = A * A.
ENDMETHOD.
"M1
ENDCLASS.
"c1 IMPLEMENTATION
DATA: O1 TYPE REF TO C1.
DATA: RESULT TYPE I.
START-OF-SELECTION.
CREATE OBJECT O1.
CALL METHOD O1->M1
EXPORTING
A=4
IMPORTING
B = RESULT.
WRITE: RESULT.

Example-4

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
data: x type i,
Y TYPE I.
METHODS: M1 IMPORTING A TYPE I EXPORTING B TYPE I.
METHODS: M2.
ENDCLASS.
"c1 DEFINITION
.
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
B = A * A.
ENDMETHOD.
"M1
METHOD: M2.
WRITE:/ X, Y.
ENDMETHOD.
"M2
ENDCLASS.
"c1 IMPLEMENTATION
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
DATA: O2 TYPE REF TO C1.
CREATE OBJECT O2.
DATA: RESULT TYPE I.
CREATE OBJECT O1.
CALL METHOD O1->M1
EXPORTING
A=4
IMPORTING
B = RESULT.
WRITE: RESULT.
O2->X = 2.
O2->Y = 4.
CALL METHOD O2->M2

Example-5

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
DATA: X TYPE I,
Y TYPE I.
METHODS: M1 IMPORTING A TYPE I EXPORTING B TYPE I.
METHODS: M2.
METHODS: M3 IMPORTING X TYPE I Y TYPE I.
PRIVATE SECTION.
DATA: P TYPE I,
Q TYPE I.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
B = A * A.
ENDMETHOD.
"M1
METHOD: M2.
WRITE: / X, Y.
WRITE: / P, Q.
ULINE.
ENDMETHOD.
"M2
METHOD: M3.
P = X.
Q = Y.
ENDMETHOD.
"M2
ENDCLASS.
"c1 IMPLEMENTATION
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
DATA: O2 TYPE REF TO C1.
CREATE OBJECT O2.
DATA: O3 TYPE REF TO C1.
CREATE OBJECT O3.
DATA: RESULT TYPE I.
CREATE OBJECT O1.
CALL METHOD O1->M1
EXPORTING

Interfaces
Interfaces extend the scope of a class by
adding their own components to its public
section
Interface I1
Methods
End interface
Interfaces do not have implementation
part
Interfaces are implemented by classes

INTEFACES

*----------------------------------------------------------------------*
*
INTERFACE i_data
*----------------------------------------------------------------------*
INTERFACE I_DATA.
METHODS: CREATE,CHANGE,DISPLAY.
ENDINTERFACE.
"i_data
PARAMETERS: PO RADIOBUTTON GROUP R1 USER-COMMAND ABCD.
PARAMETERS: SO RADIOBUTTON GROUP R1.
SELECTION-SCREEN: ULINE.
PARAMETERS: CR RADIOBUTTON GROUP R2 USER-COMMAND ABCDE.
PARAMETERS: CH RADIOBUTTON GROUP R2.
PARAMETERS: DI RADIOBUTTON GROUP R2.
*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
INTERFACES: I_DATA.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: I_DATA~CREATE.
CALL TRANSACTION 'ME21N'.
ENDMETHOD.
"i_data~create
METHOD: I_DATA~CHANGE.
CALL TRANSACTION 'ME22N'.
ENDMETHOD.
"i_data~cHANGE
METHOD: I_DATA~DISPLAY.
CALL TRANSACTION 'ME23N'.
ENDMETHOD.
"i_data~DISPLAY
ENDCLASS.
"c1 IMPLEMENTATION

INTERFACES Cont

*----------------------------------------------------------------------*
*
CLASS C2 DEFINITION
*----------------------------------------------------------------------*
CLASS C2 DEFINITION.
PUBLIC SECTION.
INTERFACES: I_DATA.
ENDCLASS.
"C2 DEFINITION
*----------------------------------------------------------------------*
*
CLASS C2 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C2 IMPLEMENTATION.
METHOD: I_DATA~CREATE.
CALL TRANSACTION 'VA01'.
ENDMETHOD.
"i_data~create
METHOD: I_DATA~CHANGE.
CALL TRANSACTION 'VA02'.
ENDMETHOD.
"i_data~cHANGE
METHOD: I_DATA~DISPLAY.
CALL TRANSACTION 'VA03'.
ENDMETHOD.
"i_data~DISPLAY
ENDCLASS.
"C2 IMPLEMENTATION
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
DATA: O2 TYPE REF TO C2.
CREATE OBJECT O2.
DATA: IREF TYPE REF TO I_DATA.
IF PO = 'X'.
IREF = O1.
ELSE.
IREF = O2.
ENDIF.
IF CR = 'X'.
CALL METHOD IREF->CREATE.
ELSEIF CH = 'X'.
CALL METHOD IREF->CHANGE.
ELSE.
CALL METHOD IREF->DISPLAY.
ENDIF.

Events
Event is a mechanism by which method of one
class can raise the method of another class
without instantiating that class
Steps
Create an event in a class
Create a triggering method for that event in
same class which will raise the event
Create an event handler method for the event in
same / other class
Register the event_handler method in the
program

Events
Some methods acts as triggeers(trigger
event) other menthods(handlers)
i.e Handler methods are executed when
event occurs in trigger methods

TRIGGERING AND HANDLING

EVENTS

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: GET_DATA, APPEND_DATA, DISPLAY_DATA, REFRESH_DATA.
EVENTS: IS_INITIAL.
PRIVATE SECTION.
DATA: IT_EKPO TYPE STANDARD TABLE OF EKPO.
DATA: WA_EKPO TYPE EKPO.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: GET_DATA.
SELECT * FROM EKPO INTO TABLE IT_EKPO UP TO 10 ROWS.
ENDMETHOD.
METHOD: APPEND_DATA.
WA_EKPO-EBELN = '12345'.
APPEND WA_EKPO TO IT_EKPO.
ENDMETHOD.
METHOD: DISPLAY_DATA.
IF IT_EKPO IS NOT INITIAL.
LOOP AT IT_EKPO INTO WA_EKPO.
WRITE: / WA_EKPO-EBELN.
ENDLOOP.
ELSE.
RAISE EVENT IS_INITIAL.
ENDIF.
ENDMETHOD.
METHOD: REFRESH_DATA.
REFRESH IT_EKPO.
ENDMETHOD.
ENDCLASS.
"c1 IMPLEMENTATION

Cont

CLASS C1_HANDLER DEFINITION.

PUBLIC SECTION.
METHODS: HANDLE_INITIAL FOR EVENT IS_INITIAL OF C1.
ENDCLASS.
CLASS C1_HANDLER IMPLEMENTATION.
METHOD: HANDLE_INITIAL.
WRITE: / 'EVENT ''IS_INITIAL'' IS TRIGGERED'.
ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
DATA: O2 TYPE REF TO C1_HANDLER.
CREATE OBJECT O2.
* REGISTERING EVENTS WITH CLASS
SET HANDLER O2->HANDLE_INITIAL FOR O1.
CALL METHOD O1->DISPLAY_DATA.
CALL METHOD O1->GET_DATA.
CALL METHOD O1->DISPLAY_DATA.
CALL METHOD O1->APPEND_DATA.
CALL METHOD O1->DISPLAY_DATA.
CALL METHOD O1->REFRESH_DATA.
CALL METHOD O1->DISPLAY_DATA.

Calling Methods in different

ways

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: m1 importing a type i.
ENDCLASS.
"c1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: m1.
write: / a.
ENDMETHOD.
endclass.
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
CALL METHOD O1->m1 exporting a = 4.
CALL METHOD O1->m1( a = 5 ).
CALL METHOD O1->m1( 6 ).

Use of Export and Changing

parameters

data w_tAx type p decimals 2.

data w_sal type p decimals 2.
*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS tax DEFINITION.
PUBLIC SECTION.
METHODS: tax_calc importing grade type c
exporting itax type p
changing sal type p.
ENDCLASS.
"c1 DEFINITION
.
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS tax IMPLEMENTATION.
METHOD: tax_calc.
case grade.
when 'A'.
ITAX = SAL * '0.3'.
when 'B'.
ITAX = SAL * '0.2'.
when 'C'.
ITAX = SAL * '0.1'.
endcase.
SAL = SAL - ITAX.
ENDMETHOD.
endclass.
START-OF-SELECTION.
DATA: O1 TYPE REF TO TAX.
CREATE OBJECT O1.
W_SAL = 30000.
WRITE: / W_SAL, W_TAX.
CALL METHOD O1->TAX_CALC exporting GRADE = 'A'
IMPORTING ITAX = W_TAX
CHANGING SAL = W_SAL.
WRITE: / W_SAL, W_TAX.

Method using ITAB as parameter

TYPES:BEGIN OF TY_EKPO,
EBELN TYPE EBELN,EBELP TYPE EBELP,MENGE TYPE EKPO-MENGE,NETPR TYPE EKPO-NETPR,
END OF TY_EKPO.
DATA: IT_EKPO TYPE STANDARD TABLE OF TY_EKPO.
DATA: WA_EKPO TYPE TY_EKPO.
*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: GET_EKPO IMPORTING EBELN TYPE EBELN
EXPORTING ITAB_EKPO TYPE ANY TABLE.
ENDCLASS.
"c1 DEFINITION
.
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: GET_EKPO.
SELECT EBELN EBELP MENGE NETPR FROM EKPO INTO TABLE ITAB_EKPO
WHERE EBELN = EBELN.
ENDMETHOD.
"get_ekpo
ENDCLASS.
"c1 IMPLEMENTATION
START-OF-SELECTION.
PARAMETERS: P_EBELN TYPE EBELN.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
CALL METHOD O1->GET_EKPO
EXPORTING
EBELN = P_EBELN
IMPORTING
ITAB_EKPO = IT_EKPO.
LOOP AT IT_EKPO INTO WA_EKPO.
WRITE: / WA_EKPO-EBELN,WA_EKPO-EBELP.
ENDLOOP.

Using RETURN Parameter

When we use RETURN , EXPORT AND
CHANGING should not be there and only
one RETURN parameter is allowed
RETURN parameter is always passed by
VALUE

DATA: W_NUM TYPE I.

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: M1 IMPORTING A TYPE I
B TYPE I
RETURNING VALUE(RESULT) TYPE I.
ENDCLASS.
"C1 DEFINITION
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
RESULT = A + B.
ENDMETHOD.
"M1
ENDCLASS.
"C1 IMPLEMENTATION
START-OF-SELECTION.
DATA: O1 TYPE REF TO C1.
CREATE OBJECT O1.
CALL METHOD O1->M1
EXPORTING
A
=2
B
=4
RECEIVING
RESULT = W_NUM.
*or w_num = o1->m1( a = 2 b = 4 ).
WRITE: / W_NUM.

Inheritance

*----------------------------------------------------------------------*
*
CLASS c1 DEFINITION
*----------------------------------------------------------------------*
CLASS C1 DEFINITION.
PUBLIC SECTION.
METHODS: M1.
DATA: NUM1 TYPE I VALUE 4.
PROTECTED SECTION.
METHODS: M2.
DATA: NUM2 TYPE I VALUE 6.
ENDCLASS.
"C1 DEFINITION
.
*----------------------------------------------------------------------*
*
CLASS c1 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C1 IMPLEMENTATION.
METHOD: M1.
WRITE: / 'Iam in M1'.
WRITE: / NUM1.
ENDMETHOD.
"M1
METHOD: M2.
WRITE: / 'Iam in M2'.
WRITE: / NUM2.
ENDMETHOD.
"M1
ENDCLASS.
"C1 IMPLEMENTATION
*----------------------------------------------------------------------*
*
CLASS C2 DEFINITION
*----------------------------------------------------------------------*
CLASS C2 DEFINITION INHERITING FROM C1.
PUBLIC SECTION.
METHODS: M3.
ENDCLASS.
"C2 DEFINITION

Cont

*----------------------------------------------------------------------*
*
CLASS C2 IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS C2 IMPLEMENTATION.
METHOD: M3.
WRITE: / 'Iam in M3'.
CALL METHOD M2.
ENDMETHOD.
"M3
ENDCLASS.
"C2 IMPLEMENTATION
START-OF-SELECTION.
DATA: O1 TYPE REF TO C2.
CREATE OBJECT O1.
CALL METHOD O1->M1.
* call method O1->m2.
CALL METHOD O1->M3.

Polymorphism

interface itf.
methods interface_display.
endinterface.

class vehicle definition.

public section.
interfaces itf.
methods class_display.
endclass.

class vehicle implementation.

method itf~interface_display.
write: / 'This is from Interface display'.
endmethod.
method class_display.
write: / 'This is from Class display'.
endmethod.
endclass.

Cont
data: int_ref type ref to itf,

obj_ref type ref to vehicle.

start-of-selection.
create object obj_ref.
int_ref = obj_ref. "narrow cast or upcast
call method int_ref->interface_display.
obj_ref ?= int_ref.
call method obj_ref->itf~interface_display.
call method obj_ref->class_display.

ALV Using OOPs

Create a screen 1111 and place a Custom
Control C1 on the layout

Steps

Prepare ITAB
Prepare FieldCat:LVC_T_FCAT
Prepare Layout:LVC_S_LAYO
Event Handler: Register

ALV Grid require a container to be linked to the

screen. We use instance of clgui_custom_container
Add a custom control on the screenwhich will be
related to the custom container

 Prepare ITAB
Data control1 type scrfname value C1.
Here C1 is the control on the screen

Flow Logic of 1111

Program

REPORT YMATDAT
.
TYPES: BEGIN OF TY_EKPO,
EBELN TYPE EBELN,
EBELP TYPE EBELP,
MENGE TYPE EKPO-MENGE,
NETPR TYPE EKPO-NETPR,
END OF TY_EKPO.
DATA: IT_EKPO TYPE STANDARD TABLE OF TY_EKPO.
DATA: WA_EKPO TYPE TY_EKPO.
DATA:CONTROL TYPE SCRFNAME VALUE 'C1',
GRID
TYPE REF TO CL_GUI_ALV_GRID,
CONTAINER TYPE REF TO CL_GUI_CUSTOM_CONTAINER.
DATA: IT_FCAT TYPE LVC_T_FCAT,
WA_FCAT TYPE LVC_S_FCAT,
WA_LAYOUT TYPE LVC_S_LAYO.

Cont

*---------------------------------------------------------------------*
*
CLASS cl_event_receiver DEFINITION
*---------------------------------------------------------------------*
CLASS CL_EVENT_HANDLER DEFINITION.
PUBLIC SECTION.
METHODS:
D_CLICK FOR EVENT DOUBLE_CLICK OF CL_GUI_ALV_GRID
IMPORTING E_ROW E_COLUMN ES_ROW_NO.
ENDCLASS.
"event_handler DEFINITION
DATA: OBJ_EVENT_HANDLER TYPE REF TO CL_EVENT_HANDLER.
START-OF-SELECTION.
SELECT EBELN EBELP MENGE NETPR
FROM EKPO INTO TABLE IT_EKPO UP TO 10 ROWS.
IF SY-SUBRC = 0.
CALL SCREEN 1111.
ENDIF.

Cont

*---------------------------------------------------------------------*
*
CLASS cl_event_receiver DEFINITION
*---------------------------------------------------------------------*
CLASS CL_EVENT_HANDLER DEFINITION.
PUBLIC SECTION.
METHODS:
D_CLICK FOR EVENT DOUBLE_CLICK OF CL_GUI_ALV_GRID
IMPORTING E_ROW E_COLUMN ES_ROW_NO.
ENDCLASS.
"event_handler DEFINITION
DATA: OBJ_EVENT_HANDLER TYPE REF TO CL_EVENT_HANDLER.
START-OF-SELECTION.
SELECT EBELN EBELP MENGE NETPR
FROM EKPO INTO TABLE IT_EKPO UP TO 10 ROWS.
IF SY-SUBRC = 0.
CALL SCREEN 1111.
ENDIF.

Cont

*&---------------------------------------------------------------------*
*&
Module STATUS_1111 OUTPUT
*&---------------------------------------------------------------------*
*
text
*----------------------------------------------------------------------*
MODULE STATUS_1111 OUTPUT.
SET PF-STATUS 'ABCD'.
IF GRID IS INITIAL.
PERFORM CREATE_CONTAINER.
PERFORM CREATE_GRID.
PERFORM BUILD_LAYOUT.
PERFORM BUILD_FCAT.
PERFORM CALL_DISPLAY_METHOD.
*** Registering GRID object with E-VENT_HANDLER method
CREATE OBJECT OBJ_EVENT_HANDLER.
SET HANDLER OBJ_EVENT_HANDLER->D_CLICK FOR GRID.
ELSE.
PERFORM CALL_REFRESH_METHOD.
ENDIF.
ENDMODULE.
" STATUS_1111 OUTPUT

Cont

*&---------------------------------------------------------------------*
*&
Module USER_COMMAND_1111 INPUT
*&---------------------------------------------------------------------*
*
text
*----------------------------------------------------------------------*
MODULE USER_COMMAND_1111 INPUT.
IF SY-UCOMM = 'BACK'.
LEAVE PROGRAM.
ENDIF.
ENDMODULE.
" USER_COMMAND_1111
INPUT

Cont

*&---------------------------------------------------------------------*
*&
Form create_container
*&---------------------------------------------------------------------*
FORM CREATE_CONTAINER .
CREATE OBJECT CONTAINER
EXPORTING
*
PARENT
=
CONTAINER_NAME
= 'C1'
*
STYLE
=
*
LIFETIME
= lifetime_default
*
REPID
=
*
DYNNR
=
*
NO_AUTODEF_PROGID_DYNNR =
EXCEPTIONS
CNTL_ERROR
=1
CNTL_SYSTEM_ERROR
=2
CREATE_ERROR
=3
LIFETIME_ERROR
=4
LIFETIME_DYNPRO_DYNPRO_LINK = 5
OTHERS
=6
.
IF SY-SUBRC <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM.
" create_container

Cont

*&---------------------------------------------------------------------*
*&
Form create_grid
*&---------------------------------------------------------------------*
FORM CREATE_GRID .
CREATE OBJECT GRID
EXPORTING
*
I_SHELLSTYLE
=0
*
I_LIFETIME
=
I_PARENT
= CONTAINER
*
I_APPL_EVENTS = space
*
I_PARENTDBG
=
*
I_APPLOGPARENT =
*
I_GRAPHICSPARENT =
*
I_NAME
=
EXCEPTIONS
ERROR_CNTL_CREATE = 1
ERROR_CNTL_INIT = 2
ERROR_CNTL_LINK = 3
ERROR_DP_CREATE = 4
OTHERS
=5
.
IF SY-SUBRC <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM.
" create_grid

Cont

*&---------------------------------------------------------------------*
*&
Form BUILD_LAYOUT
*&---------------------------------------------------------------------*
FORM BUILD_LAYOUT .
* Set a titlebar for the grid control
WA_LAYOUT-GRID_TITLE = TEXT-100.
WA_LAYOUT-CWIDTH_OPT = 'X'.
WA_LAYOUT-ZEBRA
= 'X'.
ENDFORM.
" BUILD_LAYOUT

Cont

*&---------------------------------------------------------------------*
*&
Form build_fcat
*&---------------------------------------------------------------------*
FORM BUILD_FCAT .
PERFORM BUILD_FCAT_RECORD USING 0 'EBELN'
'PO' 10.
PERFORM BUILD_FCAT_RECORD USING 1 'EBELP'
'ITEM' 4.
PERFORM BUILD_FCAT_RECORD USING 2 'MENGE'
'QTY' 16.
PERFORM BUILD_FCAT_RECORD USING 3 'NETPR'
'PRICE' 16.
ENDFORM.
" build_fcat

Cont

*&---------------------------------------------------------------------*
*&
Form build_fcat_record
*&---------------------------------------------------------------------*
FORM BUILD_FCAT_RECORD USING COL_POS FIELDNAME
COL_TEXT LENGTH.
WA_FCAT-COL_POS = COL_POS.
WA_FCAT-FIELDNAME = FIELDNAME.
WA_FCAT-COLTEXT = COL_TEXT.
IF WA_FCAT-FIELDNAME = 'EBELN'.
WA_FCAT-KEY = 'X'.
ENDIF.
APPEND WA_FCAT TO IT_FCAT.
CLEAR WA_FCAT.
ENDFORM.
" build_fcat_record

Cont

*&---------------------------------------------------------------------*
*&
Form call_display_method
*&---------------------------------------------------------------------*
FORM CALL_DISPLAY_METHOD .
CALL METHOD GRID->SET_TABLE_FOR_FIRST_DISPLAY
EXPORTING
*
I_BUFFER_ACTIVE
=
*
I_BYPASSING_BUFFER
=
*
I_CONSISTENCY_CHECK
=
*
I_STRUCTURE_NAME
=
*
IS_VARIANT
=
*
I_SAVE
=
*
I_DEFAULT
= 'X'
IS_LAYOUT
= WA_LAYOUT
*
IS_PRINT
=
*
IT_SPECIAL_GROUPS
=
*
IT_TOOLBAR_EXCLUDING
=
*
IT_HYPERLINK
=
*
IT_ALV_GRAPHICS
=
*
IT_EXCEPT_QINFO
=
CHANGING
IT_OUTTAB
= IT_EKPO
IT_FIELDCATALOG
= IT_FCAT
*
IT_SORT
=
*
IT_FILTER
=
EXCEPTIONS
INVALID_PARAMETER_COMBINATION = 1
PROGRAM_ERROR
=2
TOO_MANY_LINES
=3
OTHERS
=4
.
IF SY-SUBRC <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM.
" call_display_method

Cont

*&---------------------------------------------------------------------*
*&
Form call_refresh_method
*&---------------------------------------------------------------------*
FORM CALL_REFRESH_METHOD .
CALL METHOD GRID->REFRESH_TABLE_DISPLAY
* EXPORTING
*
IS_STABLE
=
*
I_SOFT_REFRESH =
* EXCEPTIONS
*
FINISHED
=1
*
others
=2
.
IF SY-SUBRC <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM.
" call_refresh_method

Cont

*---------------------------------------------------------------------*
*
CLASS cl_event_receiver IMPLEMENTATION
*---------------------------------------------------------------------*
CLASS CL_EVENT_HANDLER IMPLEMENTATION.
METHOD D_CLICK.
READ TABLE IT_EKPO INTO WA_EKPO INDEX E_ROW-INDEX.
CASE E_COLUMN-FIELDNAME.
WHEN 'EBELN'.
SET PARAMETER ID 'BES' FIELD WA_EKPO-EBELN.
CALL TRANSACTION 'ME23N' AND SKIP FIRST SCREEN.
ENDCASE.
CLEAR WA_EKPO.
ENDMETHOD.
"D_CLICK
ENDCLASS.
"event_handler IMPLEMENTATION