Short BOOPSI Overview

Grzegorz Kraszewski

Object Oriented Programming

The object oriented programming is a technique developed as a response for two trends in the computer market. The first one was increasing complexity of software. Management of a traditionally written code becomes harder when the code size increases. The second trend was increasing popularity of graphical user interfaces, which meant the end of the sequential execution of programs. Instead modern programs are event driven, it means the flow of code is determined by external events (like an user input) and is not known at a time of writing the program. Object oriented programming divides a program into a set of objects interacting with each other using well defined interfaces. Such a modularization simplifies the management of project and also fits naturally the concept of modern graphical user interfaces. User controls (called "gadgets" in MUI) are just objects in the code and interact with objects representing user data.

This short introduction is not intended to be a complete lecture on object oriented programming. On the other hand no knowledge of any particular object oriented programming language is required to get familiar with BOOPSI. Usually the support for OOP techniques comes with a programming language, which is either designed for OOP (like C++, C# or Java) or has OOP support added in more or less logical way (Objective C, PHP). This is not the case for BOOPSI and MUI however. In this case object oriented programming support comes from the operating system. BOOPSI and MUI can be used with any programming language, including traditional ones, for example C and even assembler.

The BOOPSI module is located in the intuition.library, with some important functions being added from a statically linked libabox. It's primary design goal was to build a framework for wrapping Intuition GUI elements in an object oriented interface. This approach was unfortunately not flexible enough, so MUI uses only basic BOOPSI framework. This framework provides the four basic concepts of the object oriented programming: classes, objects, methods and attributes. It also supports class inheritance. Because of it's simplicity, BOOPSI is easy to understand and use, especially when compared to sophisticated frameworks, like the one in the C++ programming language.

Methods and Attributes

Methods are just actions, which can be performed on an object. A set of available methods is defined by the object's class. Technically speaking, a method is a function called with an object as its parameter and changing the object's state. In BOOPSI, methods are called using DoMethod() call from libabox:

result = DoMethod(object, method_id, ... /* method parameters */);
result = DoMethodA(object, method_struct);

The first, more popular form of the call just builds the method structure on the fly, from arguments passed. Any method structure has always the method identifier as the first field. DoMethodA() call gets a pointer to the method structure, the structure is built by the application. This second form is rarely used. The number and meaning of parameters, as well as the meaning of the result are method specific. Comparision of executing a method with both forms of the call is given below:

struct MUIP_SomeMethod
{
  ULONG MethodID;
  LONG ParameterA;
  LONG ParameterB;
};

DoMethod(object, MUIM_SomeMethod, 3, 7);

struct MUIP_SomeMethod mparams = { MUIM_SomeMethod, 3, 7 };
DoMethodA(object, &mparams);

The DoMethod() form is more convenient, so it is commonly used. MUI uses specific prefixes for all its structures and constants:

• MUIM_ for method identifiers.
• MUIP_ for method parameter structures.
• MUIA_ for attribute identifiers.
• MUIV_ for special, predefined attribute values.

The C types used in the method structure above may need some explanation. LONG is a 32-bit signed integer, ULONG is an unsigned one. Because the structure is usually built on the processor stack, all parameters are extended and aligned to 32 bits. Then every parameter in the structure must be defined either as 32-bit integer or a pointer. Any parameter larger than 32 bits must be passed via pointer (for example double precision floats or strings).

Object's attributes represent it's properties. They are set and get using special methods, OM_SET() and OM_GET() respectively. It differs from the most of object oriented programming languages, where attributes (being implemented as object's fields) are accessed directly. Manipulating attributes in BOOPSI is slower then, as it implies performing a method.

Setting an attribute

The OM_SET() method does not take a single attribute and its value, but a list of them, so one can set multiple attributes at once.