topic Re: diff b/w oops alv and alv using function module in Application Development and Automation Discussions

diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 09:52:53 GMT

Hi,

can anybody tell me what is the difference between alv using oops concept and function module

and

is there is mandatory events in the report

pls help

Re: diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 09:55:45 GMT

OOPs ALV is an advanced approach of ALV

It handles mutple events effectively.

For each object, one set of class variables will be assigned

In FM approach all will sahre the same

Narendra

Re: diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 09:56:36 GMT

In Normal ALV we use Function mnodule and in OOPs we use classes and methods.

In Normal ALV we cannot place grids on screens but in OOALV we can place grids on screens.

we can insert logos in OOPS ALV.

see the code below

for displaying LOGO in ALV GRID CONTROL, we work with

Predefined global class. CL_GUI_ALV_TREE_SIMPLE. FOR

displaying LOGO. AND we use CL_GUI_CUSTOM_CONTAINTER for

identifies the location where we r goinh to display.

DECLARATIONS;

TYPE-POOLS: SDYDO, SLIS.

DATA: L_LOGO TYPE SDYDO_VALUE,” FOR DISPLAYING LOGO

L_LIST TYPE SLIS_T_LISTHEADER. ” FOR LIST HEADING

DATA: LOGO TYPE SCRFNAME VALUE ‘SLOGO’,

CONTAINER TYPE REF TO CL_GUI_CUSTOM_CONTAINER,

LOGO1 TYPE REF TO CL_GUI_ALV_TREE_SIMPLE.

CREATE INSTANCE FOR ABOVE DEFINED CLASSES IN PBO EVENT

OF SCREEN FLOW LOGIC.

IF CONTAINER IS INITIAL.

CREATE OBJECT CONTAINER EXPORTING CONTAINER_NAME =

LOGO.

CREATE OBJECT LOGO1 EXPORTING I_PARENT = CONTAINER.

NOW CALL THE METHOD FOR DISPLAYING LOGO IN GRID CONTROL

CALL METHOD LOGO->‘CREATE_REPORT_HEADER’

EXPORTING

I_LIST_COMMENTARY = L_LIST

I_LOGO = ’ ’ ” HERE PASS WHERE LOGO EXISTING.

THE ABOVE METHOD EXISTING

ALV is Application List viewer. Sap provides a set of ALV (ABAP LIST VIEWER) function modules which can be put into use to embellish the output of a report. This set of ALV functions is used to enhance the readability and functionality of any report output. Cases arise in sap when the output of a report contains columns extending more than 255 characters in length. In such cases, this set of ALV functions can help choose selected columns and arrange the different columns from a report output and also save different variants for report display. This is a very efficient tool for dynamically sorting and arranging the columns from a report output. The report output can contain up to 90 columns in the display with the wide array of display options.

We can implement OOPS concepts in SAP using ABAP objets concept.

ABAP Objects is a new concept in R/3 Release 4.0. The term has two meanings. On the one hand, it stands for the entire ABAP runtime environment. On the other hand, it represents the object-oriented extension of the ABAP language.

The Object-Oriented Language Extension

ABAP Objects is a complete set of object-oriented statements that has been introduced into the ABAP language. This object-oriented extension of ABAP builds on the existing language, and is fully compatible with it. You can use ABAP Objects in existing programs, and can also use "conventional" ABAP in new ABAP Objects programs.

ABAP Objects supports object-oriented programming. Object orientation (OO), also know as the object-oriented paradigm, is a programming model that unites data and functions in objects. The rest of the ABAP language is primarily intended for structured programming, where data is stored in a structured form in database tables and function-oriented programs access and work with it.

The object-oriented enhancement of ABAP is based on the models of Java and C++. It is compatible with external object interfaces such as DCOM and CORBA. The implementation of object-oriented elements in the kernel of the ABAP language has considerably increased response times when you work with ABAP Objects. SAP Business Objects and GUI objects - already object-oriented themselves - will also profit from being incorporated in ABAP Objects.

Introduction

The object orientation can be defined as a problem-solving method in which the software solution reflects objects in the real world. Therefore, a comprehensive introduction to object orientation would go far beyond the limits of this introduction to ABAP Objects as a whole.

Object

An object can be defined as a section of source code that contains data and provides services. The attributes of the object are formed by the data. The services are known as methods (also known as operations or functions). Typically, it is seen that the methods operate on private data (the attributes, or state of the object), which is only visible to the methods of the object. Thus, the attributes of an object cannot be changed directly by the user, but by the methods of the object only. This guarantees the internal consistency of the object.

Classes

The classes are very important, as they describe the objects. From a technical point of view, the objects are runtime instances of a class. One can create any number of objects based on a single class in theory. Each instance (object) of a class has a unique identity and its own set of values for its attributes.

Features of Object Orientation

Encapsulation

According to this property, objects restrict the visibility of their resources (attributes and methods) to other users. Every object has an interface which plays a very important role. It determines how other objects can interact with it. It is found that the implementation of the object is encapsulated, which means that it is invisible outside the object itself.

Polymorphism

According to this property, identical (identically-named) methods behave differently in different classes. Object-oriented programming contains constructions, which are called interfaces. They enable you to address methods with the same name in different objects. The implementation of the method is specific to a particular class, though the form of address is always the same.

Inheritance

According to this property, one can use an existing class to derive a new class. The data and methods of the super class are inherited by the derived classes. However, they can overwrite existing methods and add new ones.

Uses of Object Orientation

The object-oriented programming is quite useful in many ways. It has various advantages, some of which are mentioned below.

Since object-oriented structuring provides a closer representation of reality than other programming techniques, complex software systems become easier to understand.

In object-oriented system, it should be possible to implement changes at class level, without having to make alterations at other points in the system. This reduces the overall amount of maintenance required.

The object-oriented programming allows reusing individual components through polymorphism and inheritance.

In this system, the amount of work involved in revising and maintaining the system is reduced as many problems can be detected and corrected in the design phase.

To achieve these goals, the followings are required:

Object-oriented programming languages: The efficiency of object-oriented programming depends directly on how object-oriented language techniques are implemented in the system kernel.

Object-oriented tools: Object-oriented tools allow you to create object-oriented programs in object Oriented languages. They also allow you to model and store development objects and the Relationships between them.

Object-oriented modeling: The object-orientation modeling of a software system is the most important, most time-consuming, and most difficult requirement for attaining the above goals. These designs involve more than just object-oriented programming and logical advantages that are independent of the actual implementation are provided by it.

ABAP Objects

ABAP Objects is a new concept in R/3 System and you can find its two distinct meanings --- one is for the entire ABAP runtime environment and the other represents the new object-oriented generation of this language.

The Runtime Environment

ABAP Objects, for the entire ABAP runtime environment, are an indication of how SAP has, for sometime, been moving towards object orientation. Object-oriented techniques have been used exclusively in system design. The ABAP language did not support these techniques earlier.

The ABAP Workbench will allow creating R/3 Repository objects in this regard. These objects are programs, authorization objects, lock objects, customizing objects, and so on and so forth. By using function modules, one can also encapsulate functions in separate programs with a defined lnterface. The Business Object Repository (BOR) allows you to create SAP Business Objects for internal and external use.

The Object-Oriented Language Extension

ABAP Objects support object-oriented programming. The ABAP Objects is a complete set of object-oriented statements, which has been introduced into the ABAP language. This object-oriented extension of ABAP builds on the existing language and is fully compatible with it.

The Object Orientation (OO), also known as the object-oriented paradigm, is a programming model that unites data and functions in objects. You can not only use ABAP Objects in existing programs, but also work with and use a conventional ABAP in new ABAP Objects programs. The rest of the ABAP language is primarily intended for structured programming, where data is stored in a structured form in database tables and function-oriented programs access and work with it.

Moreover, we should know that the object-oriented enhancement of ABAP is based on the models of Java and C++. It is compatible with external object interfaces such as DCOM and CORBA. The implementation of object-oriented elements in the kernel of the ABAP language has considerably increased response times when you work with ABAP Objects. Some other objects, such as SAP Business Objects and GUI objects, which are already object-oriented by themselves, are also benefiting from being incorporated into ABAP Objects.

About Classes

The classes are templates for objects. An abstract description of an object is the class. You could say it is a set of instructions for building an object. The attributes of objects are defined by the components of the class, which describe the state and behavior of objects.

Local and Global Classes

In ABAP Objects, classes can be declared either globally or locally. You define global classes and interfaces in the Class Builder (Transaction SE24.} in the ABAP Workbench. In the R/3 Repository, they are stored centrally in class pools in the class library. In an R/3 System, all of the ABAP programs can access the global classes. The local classes are defined within an ABAP program. Local classes and interfaces can only be used in the program in which they are defined. When you use a class in an ABAP program, the system first searches for a local class with the specified name. If it does not find one, then it looks for a global class. Apart from the visibility question, there is no difference between using a global class and using a local class.

However, there is a significant difference in the way that local and global classes are designed. If you are defining a local class that is only used in a single program, then to define the outwardly visible components so that it fits into that program is usually sufficient. On the other hand, global classes must be able to be used anywhere. Since the system must be able to guarantee any program using an object of a global class, it can recognize the data type of each interface parameter and then certain restrictions are applied at the time of defining the interface of a global class.

Defining Local Classes

Local classes consist of ABAP source code, where the ABAP statements CLASS...ENDCLASS are enclosed. A complete class definition consists of the following parts, a declaration part and, if required, an implementation part. It is found that the declaration part of a class . The new class is called the subclass of the class from which it is derived. The original class is called the superclass of the new class. It contains the same components as the superclass if you do not add any new declarations to the subclass. However, in the subclass only the public and protected components of the superclass are visible. The private components of the superclass are not visible though they exist in the subclass. You can declare private components in a subclass that have the same names as private components of the superclass. It is seen that each class works with its own private components. The another point that we note is that methods which a subclass inherits from a superclass use the private attributes of the superclass and not any private components of the subclass with the same names.

The subclass is an exact replica of the superclass if the superclass does not have any private visibility section. However, you can add a new component to the subclass because it allows you to turn the subclass into a specialized version of the superclass. If a subclass is itself the superclass of further classes, then you can introduce a new level of specialization.

Polymorphism

Reference variables are defined with reference to a superclass or an interface defined with reference to it can also contain references to any of its subclasses. A reference variable defined with reference to a superclass or an interface implemented by a superclass can contain references to instances of any of its subclasses, since subclasses contain all of the components of all of their superclasses and also convey that the interfaces of methods cannot be changed. In particular, you can define the target variable with reference to the generic class OBJECT.

Using the CREATE OBJECT statement, when you create an object and a reference variable typed with reference to a subclass then you can use the TY PE addition to which the reference in the reference variable will point.

A reference variable can be used by a static user to address the components visible to it in the superclass to which the reference variable refers. However, any specialization implemented in the subclass cannot be addressed by it.

Depending on the position in the inheritance tree at which the referenced object occurs, you can use a single reference variable to call different implementations of the method. This is possible only if you redefine an instance method in one or more subclasses. This concept is called polymorphism, in which different classes can have the same interface and, therefore, be addressed using reference variables with a single type.

Here is the simple code as explained previously.

Then coming to steps for creation of ALV in OOABAP.

1. Create a program in se38 and just activate it without any code for now.

2. Go to module pool and create a screen, put a custom container control on to the screen. (You will find this control on right side tool box).

3. Give a name to the control created in step 2.

4. Activate the screen.

5. Come to the program declare two variables to hold instances of 2 classes CL_GUI_CUSTOM_CONTAINER, CL_GUI_ALV_GRID.

6. create an instance of the class CL_GUI_CUSTOM_CONTAINER passing container name created in step 3.

7. create an instance of the class CL_GUI_ALV_GRID passing INSTANCE VARIBALE name created in step 6.

8. using the ref. variable of previous step call method SET_TABLE FORFIRST_DISPLAY method and pass structure name and internal table containing data.

9. then call screen created in step 2.

REPORT zgs_simple_alv.

DATA : it_mara TYPE TABLE OF mara.

DATA : container TYPE REF TO cl_gui_custom_container,

grid TYPE REF TO cl_gui_alv_grid.

SELECT * FROM mara INTO TABLE it_mara UP TO 10 ROWS.

CREATE OBJECT container

EXPORTING

PARENT =

container_name = 'CONTAINER'

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.

CREATE OBJECT grid

EXPORTING

I_SHELLSTYLE = 0

I_LIFETIME =

i_parent = container

I_APPL_EVENTS = space

I_PARENTDBG =

I_APPLOGPARENT =

I_GRAPHICSPARENT =

I_NAME =

I_FCAT_COMPLETE = SPACE

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.

CALL METHOD grid->set_table_for_first_display

EXPORTING

I_BUFFER_ACTIVE =

I_BYPASSING_BUFFER =

I_CONSISTENCY_CHECK =

i_structure_name = 'MARA'

IS_VARIANT =

I_SAVE =

I_DEFAULT = 'X'

IS_LAYOUT =

IS_PRINT =

IT_SPECIAL_GROUPS =

IT_TOOLBAR_EXCLUDING =

IT_HYPERLINK =

IT_ALV_GRAPHICS =

IT_EXCEPT_QINFO =

IR_SALV_ADAPTER =

CHANGING

it_outtab = it_mara

IT_FIELDCATALOG =

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.

CALL SCREEN 100.

Please check these links ...

http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCABA/BCABA.pdf -- Page no: 1291

http://esnips.com/doc/5c65b0dd-eddf-4512-8e32-ecd26735f0f2/prefinalppt.ppt

http://esnips.com/doc/2c76dc57-e74a-4539-a20e-29383317e804/OO-abap.pdf

http://esnips.com/doc/0ef39d4b-586a-4637-abbb-e4f69d2d9307/SAP-CONTROLS-WORKSHOP.pdf

http://esnips.com/doc/92be4457-1b6e-4061-92e5-8e4b3a6e3239/Object-Oriented-ABAP.ppt

http://esnips.com/doc/448e8302-68b1-4046-9fef-8fa8808caee0/abap-objects-by-helen.pdf

http://esnips.com/doc/39fdc647-1aed-4b40-a476-4d3042b6ec28/class_builder.ppt

<REMOVED BY MODERATOR>

Cheers,

Chandra Sekhar.

Edited by: Alvaro Tejada Galindo on May 23, 2008 6:40 PM

Re: diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 09:57:00 GMT

The main difference is OOPS ALV had built in classes and methods which can be triggered to print top header and perform user interaction.

In ALV using function module, all the user action has to be handled via coding.

Thanks

Vasudha

Re: diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 09:58:20 GMT

For OOPS, follow these links :-

Check this for basic concepts of OOPS

https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/webas/abap/abap%20code%20samples/abap%20objects/abap%20code%20sample%20to%20learn%20basic%20concept%20of%20object-oriented%20programming.doc

https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/webas/abap/abap%20code%20samples/alv%20grid/abap%20code%20sample%20to%20display%20data%20in%20alv%20grid%20using%20object%20oriented%20programming.doc

Tabstrip

https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/webas/abap/abap%20code%20samples/alv%20grid/abap%20code%20sample%20for%20tab%20strip%20in%20alv.pdf

Editable ALV

https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/webas/abap/abap%20code%20samples/alv%20grid/abap%20code%20sample%20to%20edit%20alv%20grid.doc

Tree

http://www.sapdevelopment.co.uk/reporting/alv/alvtree/alvtree_usrint.htm

General Tutorial for OOPS

https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/webas/abap/an%20easy%20reference%20for%20alv%20grid%20control.pdf

http://www.sapdevelopment.co.uk/reporting/alvhome.htm

http://www.sap-img.com/abap/what-is-alv-programming.htm

http://www.sap-img.com/abap-function.htm

http://www.geocities.com/mpioud/Abap_programs.html

http://www.sapdevelopment.co.uk/reporting/alv/alvtree%5Calvtree_basic.htm

http://esnips.com/doc/ad20dca9-6182-4903-8d8f-96a66dc8590c/ALV.pdf

http://www.sap-img.com/abap-function.htm

Classical ALV:

http://www.geocities.com/mpioud/Abap_programs.html

OOPS ALV:

https://www.sdn.sap.com/irj/sdn/go/portal/prtroot/docs/library/uuid/e8a1d690-0201-0010-b7ad-d9719a415907

for Fn Module -

Function Modules;

Check this matter.

Function Modules are Global ABAP programs created by SAP for reusable purpose.they have IMPORT,EXPORT and TABLE parameters, and EXCEPTIONS to through when error occurs.

You can create them from TCode SE37.

Go through the following doc:

Function modules are cross-program, reusable procedures that are organized into function groups, and whose functions are implemented between the statements FUNCTION and ENDFUNCTION. Function modules and their interfaces are created in the Function Builder.

Function Module Interfaces

The parameter interface of a function module is defined in the Function Builder. It includes the definition of interface parameters and the specification of exceptions that can be triggered by a function module. The Function Builder automatically generates comment lines below the FUNCTION statement in the source code of the function module, which represent the interface of the function module with the following syntax:

Syntax

... [IMPORTING parameters]

[EXPORTING parameters]

[CHANGING parameters]

[TABLES table_parameters]

[{RAISING|EXCEPTIONS} exc1 exc2 ...]

The syntax and semantics of IMPORTING, EXPORTING, CHANGING, RAISING, and EXCEPTIONS mainly correspond to the definition of method interfaces with [CLASS-]METHODS. The additional option of defining table parameters using TABLES is obsolete.

Interface parameters

The interface parameters are defined on the relevant tab pages in the Function Builder.

IMPORTING parameters are input parameters. When the function module is called, a suitable actual parameter must be specified for every non-optional input parameter. The content of the actual parameter is passed to the input parameter when the call is made. The content of an input parameter for which 'pass by reference' is defined cannot be changed in the function module.

EXPORTING parameters are output parameters. When the function module is called, a suitable actual parameter can be specified for every output parameter. The content of an output parameter that is defined for 'pass by value' is transferred to the actual parameter if the function module is completed without errors. An output parameter that is defined for pass by reference is not initialized when the function module is called.

CHANGING parameters are input and output parameters. When the function module is called, a suitable actual parameter must be specified for every non-optional input or output parameter. When the function module is called, the content of the actual parameter is passed to the input/output parameter, and when the function module is completed, the content of the input/output parameter is passed to the actual parameter.

TABLES parameters are table parameters. Table parameters are obsolete CHANGING parameters that are typed as standard tables with a header line. If an internal table without a header line or a table body is passed as an actual parameter to a formal parameter of this type, an empty local header line is generated in the function module. If an internal table with a header line is used as an actual parameter, both the table body and the header line are passed to the function module. Pass by value is not possible in formal parameters defined using TABLES. Formal parameters defined with TABLES can be replaced by formal parameters defined with CHANGING. A local work area can be created for the internal table in the function module by using the addition LIKE LINE OF itab of the DATA statement.

Exceptions

The exception of a function module are defined on the Exceptions tab page in the Function Builder. Here you can select exception classes to define whether class-based exceptions are declared or non-class-based exception are defined. Class-based exceptions are represented in the above syntax by RAISING, and non-class-based exceptions are represented by EXCEPTIONS.

The addition RAISING is used to declare class-based exceptions that can be propagated from the function module to the caller. Exceptions in the categories CX_STATIC_CHECK and CX_DYNAMIC_CHECK must be explicitly declared, otherwise a propagation can lead to an interface violation. A violation of the interface leads to the treatable exception CX_SY_NO_HANDLER. Exceptions of the category CX_NO_CHECK are implicitly always declared. The declaration of exceptions of the category CX_STATIC_CHECK is statically checked in the syntax check. For exceptions of the category CX_DYNAMIC_CHECK, the check is not performed until runtime. In a function module in which class-based exceptions are declared with the RAISING addition, the statement CATCH SYSTEM-EXCEPTIONS cannot be used. Instead, the relevant treatable exceptions should be handled in a TRY control structure.

The addition EXCEPTIONS is used to define a list of non-class-based exceptions that can be triggered in the function module using the statements RAISE or MESSAGE RAISING. Exceptions defined in this way - as with formal parameters - are bound to the function module and cannot be propagated. If an exception of this type is triggered in a function module, and no return value has been assigned to it with the homonymous addition EXCEPTIONS of the CALL FUNCTION statement when the call was made, this leads to a runtime error.

Note

For new developments after release 6.10, SAP recommends that you work with class-based exceptions that are independent of the function module.

RFC is a technology which is used to access a functions (Modules) from

the remote systems.

If a function module is set as remote enabled which can be access from

the remote system via RFC.Eg: U can access the Remote enabled function modules in ur VB,Webdynpro,Java,Visual composer program.

A function module can be set as remote enabled by SE37->Go to ur FM->click the option Button "remote enabled".

But Normal function modules can not accessd from the remote system.

Good Example for RFC enabled function module is : BAPI(Business Application Programming Interface)

Note: All BAPIs are Remote enabled but not all remote enabled function modules are BAPI.

CALLING A FUNCTION MODULE:

1)In U ABAP Editor --> Click "Patter" ---> Selection Option Button "Call Function"

--> Write the Corresponding FM name --> Hit Enter

2)The appropriate import ,export Parameters will be displayed in ur editor

3)Pass the Values Here.

events in report :-

Events in Dialog Program

PBO - Process Before Output

PAI - Process After Input

POH - Process on Help Request

POV - Process on Value Request.

Events in ABAP Programming

Classical Reporting:

INITIALIZATION

AT SELECTION-SCREEN OUTPUT

AT SELECTION-SCREEN

START-OF–SELECTION.

TOP-OF-PAGE

END-OF-PAGE

END-OF-SELECTION.

Events in Interactive Report

TOP-OF-PAGE DURING LINE-SELECTION

AT USER-COMMAND.

AT LINE-SELECTION

AT PF-FUNCTION KEY

Control Break events related to Internal Tables:

AT NEW FIELD

AT END OF FIELD

AT FIRST

AT LAST

Re: diff b/w oops alv and alv using function module

Former Member — Mon, 28 Jan 2008 10:15:55 GMT

HI,

OOPS Alv is quite powerfull than Normal ALV since we can handle all the output functionalities . But which is not quite possible in normal ALV

For example if we want to bring the compnay's logo into footer or to the side of the list , we cannot do it in normal ALV but in OOPS Alv we can design a container and handle the events in such a way that the logo is displayed as per our needs.

Thanks

<REMOVED BY MODERATOR>

Edited by: Alvaro Tejada Galindo on May 23, 2008 6:41 PM

Re: diff b/w oops alv and alv using function module

Former Member — Fri, 23 May 2008 16:05:11 GMT

Hi Chandra,

It is fair to say that your reply is very useful for those willing to embrace OOP in ABAP programming. I read the whole post and tried to implement the header logo solution in one of my programs. This program is based on one screen with two OO ALV Grids on it and it works fine.

However, I cannot see how this code example can "attach" to one of my ALV Grids:

- Should I design a new container in my screen, just for the header object?

- Could you explain a little better how to "relate" the header and my ALV Grid object?

Thank You

Joao

"Any job, big or small, do it right or not at all"

Re: diff b/w oops alv and alv using function module

mangesh_sonawane — Mon, 10 Dec 2012 07:03:06 GMT

The difference between normal alv and oo alv is:

i want to add one more point

Even if you upgarde the system you will find the oo alv but the its not about the normal alv(alv using function module).