ISO/IEC

11XXX

Contents

**1 Scope**

1.1 Definition of Scope

1.2 Field Of Application

2 Normative References

3 Definitions

4 Relationship Between SGML, HyTime and SMSL

4.1 HyBrid Parameter Entity

4.2 HyTime Hyperlink Module

4.3 HyTime Measurement Module

5 SMSL Application Model

5.1 Object-Oriented Model

5.1.1 Encapsulation

5.1.2 Inheritance

5.1.3 Composition

5.1.4 Polymorphism

5.2 Message Passing Model

5.3 Multimedia Authoring Paradigms

5.4 User Interface Paradigm

5.5 Authoring-time Environment

5.6 Run-time Environment

7 Classes

7.1 The Class Architectural Form

7.2 Memfunc Architectural Form

7.3 Memdata Architectural Form

7.4 Virtual Functions

8 Aggregates

8.1 The Aggregate Architectural Form

8.2 Expressing Aggregates Using ASN.1

8.3 Expressing Aggregates Using SMSL Architectural Forms

8.3.1 asn1bool

8.3.2 asn1int

8.3.3 asn1bits

8.3.4 asn1ostr

8.3.5 asn1null

8.3.6 asn1oid

8.3.7 asn1desc

8.3.8 asn1ext

8.3.9 asn1real

8.3.10 asn1enum

8.3.11 asn1seq

8.3.12 asn1set

8.3.13 asn1nums

8.3.14 asn1pstr

8.3.15 asn1ttex

8.3.16 asn1vtex

8.3.17 asn1ia5

8.3.18 asn1utct

8.3.19 asn1gent

8.3.20 asn18824

8.3.21 asn1646

8.3.22 asn1gstr

8.4 Expressing Aggregates Using Other Notations

9 Object Identifiers

9.1 The smsl.oid Architectural Form

10 Messages

10.1 The smsl.msg Architectural Form

10.2 The Message Routing Service

12 SMSL Predefined Classes

12.1 User Interface Classes

12.1.x SMSL.Archive

12.1.x SMSL.Exception

12.1.x SMSL.Bitmap

12.1.x SMSL.BitmapButton

12.1.x SMSL.Brush

12.1.x SMSL.Button

12.1.x SMSL.ByteArray

12.1.x SMSL.CmdTarget

12.1.x SMSL.CmdUI

12.1.x SMSL.ColorDialog

12.1.x SMSL.ComboBox

12.1.x SMSL.CreateContext

12.1.x SMSL.DataExchange

12.1.CDC

12.1.x SMSL.Dialog

12.1.x SMSL.DialogBar

12.1.x SMSL.DocItem

12.1.x SMSL.DocTemplate

12.1.x SMSL.Document

12.1.1 Window

12.1.2 Menu bar

12.1.3 Popdown Menu

12.1.4 Button

12.1.5 Radio Button

12.1.6 Control Slider

12.1.7 Text Edit Box

12.1.8 List Box

12.1.9 Hot Spot

12.2 Multimedia Classes

12.2.1 Audio Player

12.2.2 Audio Recorder

12.2.3 Video Player

12.2.4 Video Recorder

12.2.5 Graphic Viewer

12.2.6 Graphic Editor

12.2.7 Video Clip

12.2.8 Audio Clip

12.2.9 Graphic

13 SMSL Services

13.1 ObjectConstruct

Purpose

Use

Input

Output

13.2 ObjectDestroy

Purpose

Use

Input

Output

13.3 SendMessage

Purpose

Use

Input

Output

Annex A: Using C++ as a Scripting Language

Annex B: The SMSL Meta-DTD

Foreward

(The standard ISO forward text goes here. Is the forward part of the
document, or is it automatically inserted by ISO?)

0 Introduction

The traditional view of computer processing is that the program which
acts upon data and the data that is acted upon are separate. This, at
first, may seem like a natural division. Clearly, one should not have to
change a program to process new data. The problem with this theory is
that most applications require the data (information) to be structured
in a particular way before the program may process it. One program\'s
view of the data structures is often entirely different than another.
Data must be converted from one format to another, often with some
associated loss of information. If the structure of data changes,
programs must be modified.

What is needed is a mechanism that makes data self-describing. A
requisite step in this process is separating the data (content) from the
structure of the data. ISO/IEC 10744: Standard Generalized Markup
Language (SGML) and ISO/IEC 10744: Hypermedia/Time-based Structuring
Language (HyTime) provide a mechanism for describing structure without
affecting content. This description is known as a Document Type
Definition (DTD). To apply object-oriented terminology to SGML, the DTD
defines a class of documents and each document is an instance of a
class.

While structure may be defined in a standardized manner, the semantics
are application defined. This has led to much misunderstanding; how can
a standard be useful if there are no semantics attached to it? The
answer becomes clear when one realizes the benefits of self-describing
information. In this scenario, the structure of the information drives
the application; not the other way around. The imposition of semantics
would subvert this model.

\*\*\*\* The following paragraph needs to be rewritten per the editing
instructions from the Estes Park meeting \*\*\*\*

The emphasis of the Standard Multimedia/Hypermedia Scripting Language
(SMSL) is on information, not programming. SMSL is not a language for
imposing the will of programmers on the art and science of information
processing. The assumption of SMSL is that people have information and
they want to do something with it; not that they have applications that
they need to feed information to. The SMSL model considers applications
to be transitory things which serve a limited purpose, and information
to be perpetual. The transitory nature of applications is an immutable
law of nature; none the less, a majority of the work done to date in
information science has been focused on breaking this law, with the
results being roughly equivalent to the Alchemists\' search for the
Philosopher\'s Stone. If applications are transitory, then the language
they are written in should be simple and efficient. Such is the design
goal of SMSL.

# 1 Scope

## 1.1 Definition of Scope

This International Standard defines an environment for authoring and
running hypermedia applications. An application is comprised of a
program (an executable entity), data, and structure.

In SMSL, the program is represented as a series of scripts, which are
written in a special language known as a Scripting Language.

A Scripting Language is a Programming Language, however, not all
Programming Languages are Scripting Languages. More precisely, the set
of Scripting Languages is a subset of the set of Programming Languages.
The attributes which differentiate the Scripting Language subset are
subtle, and often have more to do with perception than with any clear
technical distinctions.

However, Scripting Languages often display one or more of the following
characteristics:

-   language syntax and grammar resemble natural (spoken) languages

-   language is usable by people who are not professional programmers

-   language design stresses simplicity over functionality

-   language is \"application focused\", in that it is intended to
    address the needs of one class of application (language is not
    \"general purpose\")

The programs written in a Scripting Language are called \"Scripts\".

Scripting languages are most frequently applied to tasks where the
required scripts are relatively simple, as well as somewhat repetitive;
for example, application installation. The creation and modification of
the script is often hidden from the user. For instance, a terminal
emulator may support logon scripts, but the creation of the scripts
might be managed by a menu-driven front end.

The Standard Multimedia/Hypermedia Scripting Language (SMSL), as its
name implies, is designed for manipulating multimedia information. Any
information that can be stored in a computer system and manipulated
under software control qualifies as multimedia information.

In this standard, the data, scripts and structural information are
organized into a single identifiable unit known as a document. The term
document has the same meaning in this context as in SGML (ISO 8879) and
HyTime (ISO 10744).

## 1.2 Field Of Application

# 2 Normative References

ISO 10744: 1992 Information Processing --- Text and office systems ---
Hypermedia/Time-based Structuring Language (HyTime)

ISO 8879:1986 Information Processing --- Text and office systems ---
Standard Generalized Markup Lanuage (SGML)

ISO 8824:1990 Information Processing --- Open Systems Interconnection
--- Specification of Abstract Syntax Notation One (ASN.1)

ISO 8825:1990 Information Processing --- Open Systems Interconnection
--- Specification of Basic Encoding Rules for Abstract Syntax Notation
One (ASN.1)

ISO DIS 13xxx MHEG part1

# 3 Definitions

  --------------------- ------------------------------------------------------
  **aggregate**         A simple or compound data structure constructed using
                        the rules of SMSL.

  **architecural form** 

  **ASN.1**             Abstract Syntax Notation One

  **attribute**         

  **authoring**         The process of creating multimedia applications.

  **authoring system**  The software and hardware associated with the creation
                        of multimedia applications.

  **BER**               Basic Encoding Rules

  **class**             

  **construct**         To create a run-time instance of an object, including
                        the allocation of memory and other system resources
                        required by the object.

  **!destruct**         To destroy a run-time instance of an object, including
                        the deallocation of all resources used by the object.

  **document**          A collection of information that is identified as a
                        unit and that is intended for human perception; in
                        SMSL, the document encapsulates data, structure and
                        scripts.

  **element**           

  **entity**            

  **HyTime**            ISO/IEC 10744:1992 The Time-based Structuring
                        Language.

  **member data**       The data, expressed as aggregates, that is
                        encapsulated by a class.

  **member function**   The methods, or functions, encapsulated by a class.

  **message**           Information communicated between objects.

  **message handler**   A method that handles a particular message type.

  **message map**       A data structure which maps message type to message
                        handler for a class.

  **object**            An instance of a class.

  **object-oriented**   

  **run-time**          

  **scripting           A programming language used with SMSL applications.
  language**            

  **semaphore**         A shared resource used to implement mutual exclusion
                        algorithms.

  **SGML**              ISO/IEC 8879:1986 The Standard Generalized Markup
                        Language
  --------------------- ------------------------------------------------------

# 4 Relationship Between SGML, HyTime and SMSL

## 4.1 HyBrid Parameter Entity

## 4.2 HyTime Hyperlink Module

This section is about the interface between SMSL and the HyTime
hyperlink module.

1.  Creating objects which correspond to link ends so that things
    automatically occur relative to a link.

## 4.3 HyTime Measurement Module

this section is about the interface between SMSL and the FCS module.

1.  Define the sequencing of events in a "timeline-based" authoring
    paradigm

2.  Define virtual coordinate spaces for displays

# 5 SMSL Application Model

-   SMSL is a standardized scripting enviroment.

-   An application is comprised of three components: data, structure,
    and methods.

-   An SMSL application is synonymous with a document, in that the
    document "contains" (or encapsulates) the three essential
    application components.

-   SMSL is intended to support \"self-contained\" applications, in
    which case, most of the processing associated with the application
    is embedded in the scripts.

-   Any number of languages may be used as a scripting language with
    SMSL.

-   Scripts interact with documents via SMSL services.

-   There is no media requirement in SMSL, the application can reside on
    any number and combination of media including CD-ROM, local disk and
    network server disk.

-   The application is intended to be as platform-independent as
    possible and SMSL provides the mechanisms for achieving almost
    universal portability. However, the application designer and/or SMSL
    implementor may choose not to support full portability for a variety
    of reasons (security, economics, etc.) and SMSL does not discourage
    them from doing so.

## 5.1 Object-Oriented Model

-   SMSL supports all of the criteria for object-oriented languages,
    such as encapsulation, inheritance (including multiple inheritance),
    polymorphism and containment.

-   Scripting languages used with SMSL do not have to be object-oriented
    languages.

-   Using SMSL implies superimposing object-oriented design on an
    application, even if the languages(s) used are not object-oriented.

### 5.1.1 Encapsulation

### 5.1.2 Inheritance

SMSL places no limits on either the depth or breadth of the class
hierarchy.

### 5.1.3 Composition

A class may contain other classes. For example, a class corresponding to
a dialog box can be built from other more primitive classes (button,
text edit box, list box, etc.)

### 5.1.4 Polymorphism

Polymorphism is the ability to call a variety of functions using the
same interface.

**What is the correct term here? Polymorphism doesn't seem to be what I
am describing below.**

SMSL supports polymorphism by allowing multiple implementations of a
method, providing that each instance either return a different data
type, that the order and type of arguments vary, or some combination.

## 5.2 Message Passing Model

-   Many modern software systems are based on a processing model where
    objects receive messages (or commands) which control their
    processing.

-   Each message type handled by an object corresponds to one member
    function of the class from which the object was instantiated.

-   The SMSL run-time environment serves as a kernel through which all
    application messages are passed.

-   The kernel keeps an ordered message queue.

-   Using the SendMessage service, an SMSL application can request that
    a a message be sent to an object. These messages are known as
    syncrhonous events.

-   The kernel can, in some instances (such as mouse button events) send
    messages to an object that were not specifically requested to be
    sent by the application. These messages are known as asynchronous
    events.

-   The application or the kernel can request messages be sent to an
    object either at a specific time, or at a time relative to another
    event. These messages are known as isochronous events.

-   A message map establishes the relationship between a message and a
    message identifier (messageID).

## 5.3 Multimedia Authoring Paradigms

SMSL supports all popular authoring paradigms for multimedia
applications.

## 5.4 User Interface Paradigm

Due to the fact that SMSL is intended for use in multimedia
applications, SMSL assumes, but does not require, a graphical user
interface. Graphical user interfaces share a number of common
characteristics, and SMSL exploits these characteristics.

SMSL assumes the following hardware is available on the run-time
platform:

  ----------------------------------- -----------------------------------
  **Device**                          **Examples**

  Display                             bit mapped color (or gray scale)
                                      graphics display

  Cursor movement                     mouse, touch screen, track ball,
                                      joy stick

  Character input                     keyboard

  Mass storage                        hard disk, optical disk (CD-ROM)

  Semaphore                           global shared memory resource

  Sound                               sound card, MIDI synthesizer

  Timer                               system clock
  ----------------------------------- -----------------------------------

The SMSL services rely on the underlying operating system to support the
display of windows and dialog boxes, display of graphics, audio and
video playback, and other system dependent services required by the
application. The interfaces between the SMSL run-time environment and
the underlying operating system are not specified or enforced by SMSL.

## 5.5 Authoring-time Environment

## 5.6 Run-time Environment

6 Event Sequencing

SMSL provides a mechanism for producing a sequence of messages that are
sent to objects. This is a simple method of building an application from
a set of objects. It is assumed that most of the processing will be
performed by the methods associated with the objects, thus only the most
rudimentary operations are supported using event sequencing. Still, most
interactive multimedia applications could be implemented using this
mechanism. Event sequencing is based on HyTime Finite Coordinate Spaces
(FCS) and a variation of the HyLex and HyQ notations (see clause xx in
ISO/IEC 10744: for further details.)

A common application of the Event Sequencing facility would be to have
compiled scripts which implement the methods assoicated with a class of
objects, and to interpret the event sequence at run time to implement
the actual application.

# 7 Classes

A class is a set of objects that share a common structure and behavior.

Classes are declared in SMSL documents using the class architectural
form. New classes can be derived from existing classes which are either
implied by the element hierarchy of an SGML/HyTime document, or are
defined as part of this standard.

One of the useful characteristics of SMSL is that new class hierarchies
can be superimposed onto existing documents.

The content of a class is arbitrary, however two additional
architectural forms are available which correspond to the
object-oriented programming paradigm: the memfunc architectural form
which is used to declare the member functions of a class (also known as
methods), and the memdata architectural form which is used to declare
data members.

The organization and use of the class by the scripting languages is not
specified by SMSL. The class declaration may be used to derive any
combination of authoring and run-time information that the implementor
chooses. For example, if C or C++ is used as a scripting language, the
class declarations may be used to produce header files that can be
compiled along with the scripts.

## 7.1 The Class Architectural Form

The class architectural form is used when declaring a new class. The
content of a class element is member function (script) elements, and
data member elements. If additional content is required then a new
element type, with the appropriate content model, should be derived from
class.

The super atttribute is a list of superclass names from which the new
class is derived (i.e. a list of classes from which the new class will
inheret data and function members). The order the superclasses are
listed is not of significance to SMSL, although it may be significant to
the scripting language implementation. The elements referenced by the
super attribute must also specify the class architectural form.

A class is of ctype abstract if it cannot be directly instantiated; i.e.
only other classes may be derived from this class. A class is of ctype
normal (the default) if an instance of the class can be directly
constructed.

In some languages, other attributes may be appropriate. For example, in
C++, keywords such as virtual, public, private or protected are commonly
used in class declarations. If the scripting language used by an
application supports (or requires) additional keywords, it is
recommended that an element type be derived from the class architectural
form, and that the additional keywords be declared as attribute types of
the derived element type.

\<!element class - - (%HyBrid;)\* \>

\<!attlist class

SMSL NAME "class"

id ID #REQUIRED

super IDREFS #IMPLIED

ctype (normal, abstract) normal

\>

## 7.2 Memfunc Architectural Form

The memfunc architectural form declares a member function of a class.
The content of a memfunc element (or an element type derived from
script) is a script in a declared notation.

The funcname attribute names the function. In some languages, there may
be additional constraints placed upon the name. The only restrictions
SMSL places on the function name is that it be a generic identifer that
is unique to the class in which the function is declared.

The functype attribute names the notation that the script is written in.
The notation must be declared according to the rules of clause x.x.x.

The message attribute, if provided, must have as its value an IDREF to a
smsl.msg element. The message attribute indicates that the function acts
as a handler when messages of that type are sent to the object. This is
the primary mechanism for creating "virtual functions" in SMSL. Refer to
clause x.x.x for further information about virtual functions.

\<!element memfunc - O (%HyBrid;)\* \>

\<!attlist memfunc

SMSL NAME "memfunc"

funcname NAME #REQUIRED

functype NOTATION #REQUIRED

message IDREF #IMPLIED

\>

In addition to the other attributes listed above, an implementation may
add its own attribute types to a class derived from memfunc. For
example, when C++ is used as a scripting language, it may be useful to
create an access attribute that has as its possible values "protected",
"public" or "private".

## 7.3 Memdata Architectural Form

The memdata architectural form declares a data member of a class. Each
data member is an aggregate even if it is comprised of a single basic
data type.

The aggregate may be declared externally to the class, in which case the
ID of the aggregate is supplied when the data member is declared, or the
aggregate may be declared in place, in which case the content of the
memdata element declares the aggregate using the rules described in
clause x.x.x

The memname attribute specifies the name of the data member. The memname
is a generic identifier that must be unique to the class in which the
memdata element is defined.

The aggname attribute specifies the ID of an aggregate. If the aggname
attribute is used, the content of the memdata element must be empty.

\<!element memdata - O (%HyBrid;)\* \>

\<!attlist memdata

SMSL NAME membdata

memname NAME #REQUIRED \-- data member name,

must be unique to

this class \--

aggname IDREF #IMPLIED \-- aggregate name \--

\>

## 7.4 Virtual Functions

-   Overloading message handlers is the mechanism for implementing
    virtual functions in SMSL.

-   The SMSL built-in classes provide default handlers for most member
    functions.

-   Some mechanism is needed to explicitly call the message handlers in
    classes from which another class was derived.

-   Will the name of the function have any role the overloading?

-   Will multiple functions of the same name be allowed, providing they
    either return different data types or accept different arguments?

# 8 Aggregates

Aggregates are a method of constructing data structures. The purpose of
aggregates is to avoid platform and/or language-dependent data types.
Aggregates may be expressed in any number of notations, with the common
factor being that the SMSL run-time representation always uses the Basic
Encoding Rules (BER) of ISO:IEC xxxx:xxxx. Because of this requirement,
SMSL can be easily deployed in distributed computing environments. Data
can be passed between objects which may exist not only on different
systems, but systems with different operating systems and/or processors,
with little consideration of data format compatibility issues.

## 8.1 The Aggregate Architectural Form

The aggregate architectural form is used to construct aggregates
compatible with SMSL applications. The content model for the aggregate
architectural form is general. SMSL applications may derive new element
types based on the aggregate architectural form, which may further
constrain their content model.

The notation used to describe an aggregate during the authoring phase is
left to the application, although SMSL provides predefined notation
types for ASN.1 and SMSL, and architectural forms which properly
constrain the content model for the notation in use.

\<!ELEMENT aggregate - - (PCDATA)\>

\<!ATTLIST aggregate

SMSL NAME #FIXED

id ID #REQUIRED

notation NOTATION #REQUIRED

\>

## 8.2 Expressing Aggregates Using ASN.1

Aggregates may be expressed using the Abstract Syntax Notation One
(ASN.1) described in ISO/IEC xxxx.xxxx. The implementation is expected
to supply the requisite interpreter/compiler for the ASN.1 notation.

**NOTE:** Other standards (such as MHEG) provide ASN.1 notation for
various classes of objects. The use of ASN.1 notation in SMSL
applications provides for a potential bridge between the standards.
Further, the use of BER as a run-time representation facilitates even
greater compatibility.

\<!NOTATION ASN.1 PUBLIC

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

\<!ELEMENT agg.asn1 - - (PCDATA)\>

\<!ATTLIST agg.asn1

SMSL NAME #FIXED SMSL

id ID #REQUIRED

notation NOTATION #FIXED ASN.1

\>

## 8.3 Expressing Aggregates Using SMSL Architectural Forms

\<!ELEMENT agg.smsl - - (%agg.smsl)\>

\<!ATTLIST agg.smsl

SMSL NAME #FIXED

id ID #REQUIRED

notation NOTATION

\>

### 8.3.1 asn1bool

\<!NOTATION asn1bool \-- Boolean: universal tag 1 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.2 asn1int

\<!NOTATION asn1int \-- Integer: universal tag 2 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.3 asn1bits

\<!NOTATION asn1bits \-- BitString: universal tag 3 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.4 asn1ostr

\<!NOTATION asn1ostr \-- OctetString: universal tag 4 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.5 asn1null

\<!NOTATION asn1null \-- Null: universal tag 5 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.6 asn1oid

\<!NOTATION asn1oid \-- ObjectIdentifier: universal tag 6 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.7 asn1desc

\<!NOTATION asn1desc \-- ObjectDescriptor: universal tag 7 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.8 asn1ext

\<!NOTATION asn1ext \-- External: universal tag 8 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.9 asn1real

\<!NOTATION asn1real \-- Real: universal tag 9 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.10 asn1enum

\<!NOTATION asn1enum \-- Enumerated: universal tag 10 \--\>

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.11 asn1seq

\<!NOTATION asn1seq \-- Sequence/SequenceOf: universal tag 16 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.12 asn1set

\<!NOTATION asn1set \-- Set/SetOf: universal tag 17 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.13 asn1nums

\<!NOTATION asn1nums \-- NumericString: universal tag 18 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.14 asn1pstr

\<!NOTATION asn1pstr \-- PrintableString: univeral tag 19 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.15 asn1ttex

\<!NOTATION asn1ttex \-- TeletexString: universal tag 20 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.16 asn1vtex

\<!NOTATION asn1vtex \-- VideotextString: universal tag 21 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.17 asn1ia5

\<!NOTATION asn1ia5 \-- IA5String: univeral tag 22 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.18 asn1utct

\<!NOTATION asn1utct \-- UTCTime: universal tag 23 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.19 asn1gent

\<!NOTATION asn1gent \-- GeneralizedTime: universal tag 24 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.20 asn18824

\<!NOTATION asn18824 \-- ISO 8824 GraphicString: universal tag 25 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.21 asn1646

\<!NOTATION asn1646 \-- ISO 646 VisibleString: universal tag 26 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

### 8.3.22 asn1gstr

\<!NOTATION asn1gstr \-- GeneralString: universal tag 27 \--

"ISO 8824:1990 //NOTATION

Abstract Syntax Notation One (ASN.1) //EN"\>

## 8.4 Expressing Aggregates Using Other Notations

# 9 Object Identifiers

-   Object identifiers uniqely identify an object. The object identifier
    is a run-time entity, in that it's purpose is to address the object
    only during the "life" of the object.

-   The format of the object identifier is left as an implementation
    decision. In some implementations, the value of the object
    identifier might be a handle. In others, the value of the object
    identifer might be a pointer to the object's location in memory.

-   It is possible for object identifiers to be reused if the
    implementation so chooses, providing that at any point in time, an
    object identifier maps to one and only one object.

-   The SMSL run-time environment is required to maintain a database of
    object identifiers and object locations.

-   An object idenfier results from invoking the SMSL ObjectConstruct
    Service (clause x.x.x).

## 9.1 The smsl.oid Architectural Form

Used to declare an object identifier usable by the object instantiation
services.

# 10 Messages

Messages are passed between objects in SMSL applications under control
of the message routing service. There are two types of messages: SMSL
and Application. SMSL messages are defined by the standard. Application
messages are defined by the application.

## 10.1 The smsl.msg Architectural Form

The smsl.msg architectural form is used to define message types in SMSL
applications. Each message type is assigned a unique generic ID. The
content of an smsl.msg element, or an element type derived from
smsl.msg, is a string of letters and/or numbers that an SMSL
implementation uses to identify the message. It is assumed that these
values will be unique to each implementation of SMSL.

\<!ELEMENT smsl.msg - - ()\* \>

\<!ATTLIST smsl.msg

smsl NAME #FIXED smsl

id ID required

\>

The generic ID specified when a smsl.msg element is declared is used (in
an IDREF) when member functions for a class are declared (refer to
clause x.x). This provides a mapping between the message type and the
functions which handle that message for a particular class.

## 10.2 The Message Routing Service

The message routing service is used to pass messages between objects in
SMSL applications. The arguments to the message routing service are the
objectID of the object to receive the message, the messageID of the
message to be sent, an aggregateID for the arguments passed to the
message handler function, and a second aggregateID that will contain the
function results when the message handler returns.

**NOTE:** The mechanism for presenting the arguments to the message
routing service is left as an implementation detail.

11 Declaring Script Notations

SMSL is designed to work with any number of scripting languages. A
FORMAL notation declaration (refer to ISO/IEC 8879:1986) is required for
each language in use. The following example notation declaration would
allow the LISP dialect known as *scheme* to be used as a scripting
language in SMSL applications.

\<!notation scheme PUBLIC

"+//ISBN 0-xxxx-xxxx-1::Programming Language//NOTATION

IEEE Scheme Specification//EN"\>

# 12 SMSL Predefined Classes

-   The classes described in this clause are all catalogued in the SMSL
    meta-DTD.

-   The messages described in the clause are also catalogued in the SMSL
    meta-DTD.

-   The data members are all described as aggregates using the SMSL
    notation for ASN.1

-   The methods described for each class must be implemented as part of
    the SMSL services.

## 12.1 User Interface Classes

-   User interaction will take place through a variety of user interface
    objects, such as dialog boxes, movie players, sound players, text
    editors, windows, and graphics interpreters.

### 12.1.x SMSL.Archive

The archive class is for saving and loading objects to and from mass
storage or network devices. Objects are "flattened", or stored in a
single level data structure, which can include both data and methods.

Messages

Close

Flush

GetFile

IsLoading

IsStoring

Read

ReadObject

Write

WriteObject

Operator\<\<

Operator\>\>

### 12.1.x SMSL.Exception

Messages

Catch

Throw

### 12.1.x SMSL.Bitmap

Messages

LoadBitmap

LoadOEMBitmap

CreateBitmap

CreateBitmapIndirect

CreateCompatibleBitmap

CreateDiscardableBitmap

FromHandle

SetBitmapBits

GetBitmapBits

SetBitmapDimension

GetBitmapDimension

### 12.1.x SMSL.BitmapButton

Messages

LoadBitmaps

AutoLoad

SizeToContent

### 12.1.x SMSL.Brush

Messages

CreateBrushIndirect

CreateDIBPatternBrush

CreateHatchBrush

CreatePatternBrush

CreateSolidBrush

FromHandle

### 12.1.x SMSL.Button

Messages

Create

GetState

SetState

GetCheck

SetCheck

GetButtonStyle

SetButtonStyle

DrawItem

### 12.1.x SMSL.ByteArray

Messages

GetSize

GetUpperBound

SetSize

FreeExtra

RemoveAll

GetAt

SetAt

ElementAt

SetAtGrow

Add

InsertAt

RemoveAt

Operator\[\]

### 12.1.x SMSL.CmdTarget

Messages

BeginWaitCursor

EndWaitCursor

RestoreWaitCursor

OnCmdMsg

### 12.1.x SMSL.CmdUI

Messages

Enable

SetCheck

SetText

ContinueRouting

### 12.1.x SMSL.ColorDialog

Messages

DoModal

GetGolor

SetCurrentColor

OnColorOK

### 12.1.x SMSL.ComboBox

Messages

Create

GetCount

GetCurSel

SetCurSel

GetEditSel

SetEditSel

SetItemData

SetItemDataPtr

GetItemData

GetItemDataPtr

Clear

Copy

Cut

Paste

LimitText

SetItemHeight

GetItemHeight

GetLBText

GetLBTextLen

ShowDropDown

GetDroppedControlRect

GetDroppedState

SetExtendedUI

GetExtendedUI

AddString

DeleteString

InsertString

ResetContent

Dir

FindString

FIndStringExact

SelectString

DrawItem

MeasureItem

CompareItem

DeleteItem

### 12.1.x SMSL.CreateContext

Messages

### 12.1.x SMSL.DataExchange

Messages

PrepareCtrl

PrepareEditCtrl

Fail

PrepareVBCtrl

### 12.1.x SMSL.CDC

CreateDC

CreateIC

CreateCompatibleDC

DeleteDC

FromHandle

DeleteTempMap

Attach

Detach

SetAttribDC

SetOutputDC

ReleaseAttribDC

ReleaseOutputDC\
GetSafeHdc

SaveDC

RestoreDC

ResetDC

GetDeviceCaps

IsPrinting

GetBrushOrg

SetBrushOrg

EnumObjects

SelectObject

SelectStockObject

GetNearestColor

SelectPalette

RealizePallette

UpdatedColors

GetBkColor

SetBkColor

GetBkMode

SetBkMode

GetPolyFillMode

SetPolyFillMode

GetROP2

SetROP2

GetStretchBltMode

SetStretchBltMode

GetTextColor

SetTextColor

GetMapMode

SetMapMode

GetViewportOrg

SetViewportOrg

GetViewportExt

SetViewportExt

ScaleViewportExt

GetWindowOrg

SetWindowOrg

OffsetWindowOrg

GetWindowExt

SetWindowExt

ScaleWindowExt

DPtoLP

LPtoDP

FillRgn

FrameRgn

InvertRgn

PaintRgn

SetBoundsRect

GetBoundsRect

GetClipBox

SelectClipRgn

ExcludeClipRect

ExcludeUpdateRgn

IntersectClipRect

OffsetClipRgn

PtVisible

RectVisible

GetCurrentPosition

MoveTo

LineTo

Arc

Polyline

FillRect

FrameRect

InvertRect

DrawIcon

Chord

DrawFocusRect

Ellipse

Pie

Polygon

PolyPolygon

Rectangle

RoundRect

PatyBlt

BitBlt

StretchBlt

GetPixel

SetPixel

FloodFill\
ExtFloodFill

TextOut

ExtTextOut

TabbedTextOut

DrawText

GetTextExtent

GetOutputTextExtent

GetTabbedTextExtent

GetOutputTabbedTextExtent

GrayString

GetTextAlign

SetTextAlign

GetTextMetrics

GetOutputTextMetrics

SetTextJustification

GetTextCharacterExtra

SetTextCharacterExtra

GetFontData

GetKerningPairs

GetOUtlineTextMetrics

GetGlyphOutline

GetCharABCWidths

GetCharWidth

GetOutputCharWidth

SetMapperFlags

GetApectRatioFilter

QueryAbort

Escape

StartDoc

StartPage

EndPage

SetAbortProc

AbortDoc

EndDoc

ScrollDC

PlayMetaFile

### 12.1.x SMSL.Dialog

Messages

InitModalIndirect

DoModal\
MapDIalogRect

IsDialogMessage

NextDlgCtrl

PrevDlgCtrl

GotoDlgCtrl

SetDefID

GetDefID

SetHelpID

EndDialog

OnInitDialog

OnSetFOnt

OnOK\
OnCancel

### 12.1.x SMSL.DialogBar

Messages

Create

### 12.1.x SMSL.DocItem

Messages

GetDocument

### 12.1.x SMSL.DocTemplate

Messages

GetDocString

### 12.1.x SMSL.Document

Messages

AddView

GetDocTemplate

GetFirstViewPosition

GetNextView

GetPathName

GetTitle\
IsModified

RemoveView

SetModifiedFlag

SetPathName

SetTitle

UpdateAllViews

CanCloseFrame

DeleteContents

OnChangedViewList

OnCLoseDocument

OnNewDocument

OnOpenDocument

OnSaveDocument

ReportSaveLoadException

SaveModified

SetModifiedFlag

SetPathName

SetTitle

UpdateAllViews

### 12.1.x SMSL.DumpContext

Messages

Flush

operator\<\<

HexDump

GetDepth

SetDepth

### 121.x SMSL.DWordArray

Messages

GetSize

GetUpperBound

SetSize

FreeExtra

RemoveAll

GetAt

SetAt

ElementAt

SetAtGrow

Add

InsertAt

RemoveAt

operator\[\]

### 12.1.x SMSL.Edit

Messages

Create

GetLineCount

GetHandle

SetHandle

FmtLines

LineIndex

SetRect

SetRectNP

SetTabStops

CanUndo

GetModify

SetModify

SetReadOnly

GetPasswordChar

GetRect

GetSel

GetLine

GetFIrstVisibleLine

EmptyUndoBuffer

LimitText

LineFromChar

LineLength

LineScroll

ReplaceSel

SetPasswordChar

SetSel

Undo

Clear

Copy

Cut

Paste

### 12.1.x SMSL.EditView

Messages

GetEditCtrl

GetPrinterFont

GetSelectedText

SetPrinterFont

SetTabStops

FIndText

PrintInsideRect

SerializeRaw

OnFindNext

OnReplaceAll

OnReplaceSel

OnTextNotFound

### 12.1.x SMSL.Exception

SMSL.MemoryException

SMSL.NotSupportedException

SMSL.ArchiveException

SMSL.FileException

SMSL.ResourceException

Messages:

IsKindOf

Try

Catch

Throw

### 12.1.x SMSL.File

Messages

Duplicate

Open

Close

Read\
Write

Flush

Seek

SeekToBegin

SeekToEnd

GetLength

SetLength

LockRange

UnlockRange

GetPosition

GetStatus

Rename

Remove

GetStatus

SetStatus

### 12.1.x SMSL.FileDialog

Messages

DoModal

GetPathName

GetFileName

GetFileExt

GetFileTitle

GetReadOnlyPref

OnShareViolation

OnFIleNameOK

OnLBSelChangedNotify

### 12.1.x SMSL.FileException

Messages

OSErrorToException

ErrnoToException

ThrowOsError

ThrowErrno

### 12.1.x SMSL.FindReplaceDialog

Messages

Create

FindNext

GetNotifier

GetFindString

GetReplaceString

IsTerminating

MatchCase

MatchWholeWord

ReplaceAll\
RepalceCurrent

SearchDown

### 12.1.x SMSL.Font

Messages

CreateFontIndirect

CreateFont

FromHandle

### 12.1.x SMSL.FontDialog

Messages

DoModal

GetCurrentFont

GetFaceName

GetStyleName

GetSize

GetColor

GetWeight

IsStrikeOut

IsUnderline

IsBold

IsItalic

### 12.1.x SMSL.FormView

### 12.1.x SMSL.FrameWnd

Messages

Create

LoadFrame

LoadAccelTable

ActivateFrame

SetActiveView

GetActiveView

GetActiveDocument

RecalcLayout

OnSetPreviewMode

OnCreateClient

### 12.1.x SMSL.GdiObject

Messages

GetSafeHandle

FromHandle

Attach

Detach

DeleteObject

DeleteTempMap

GetObject

CreateStockObject

UnrealizeObject

### 12.1.x SMSL.ListBox

Messages

Create

GetCount

GetHorizontalExtent

SetHorizontalExtent

GetTopIndex

SetTopIndex

GetItemData

GetItemDataPtr

SetItemData

SetItemDataPtr

GetItemRect

SetItemHeight

GetItemHeight

GetSel

GetText

GetTextLen

SetColumnWidth

SetTabStops

GetCurSel

SetCurSel

SetSel

GetCaretIndex

SetCaretIndex

GetSelCount

GetSelItems

SelItemRange

AddString

DeleteString

InsertString

ResetContent

Dir

FindString

FindStringExact

SelectString

DrawItem

MeasureItem

CompareItem

DeleteItem

### 12.1.x SMSL.MDIChildWindow

Messages

Create

MDIDestroy

MDIActivate

MDIMaximize

MDIRestore

GetMDIFrame

### 12.1.x SMSL.Menu

Messages

Attach

Detach

FromHandle

GetSafeHMenu

DeleteTempMap

CreateMenu

CreatePopupMenu

LoadMenu

LoadMenuIndirect

DestroyMenu

DeleteMenu

TGrackPopupMenu

AppendMenu

CheckMenuItem

EnableMenuItem

GetMenuItemCount

GetMenuItemID

GetMenuState

GetMenuString

GetSubMenu

InsertMenu

ModifyMenu

### 12.1.x SMSL.MetaFileDC

Messages

Create

Close

### 12.1.x SMSL.PaintDC

Messages

### 12.1.x SMSL.Palette

Messages

CreatePalette

FromHandle

GetPaletteEntries

SetPaletteEntries

AnimatePalette

GetNearestPaletteIndex

ResizePalette

### 12.1.x SMSL.Rect

Messages

Width

Height

Size

TopLeft

BottomRight

IsRectEmpty

IsRectNull

PtInRect

SetRect

SetRectEmpty

CopyRect

EqualRect

InflateRect

OffsetRect

SubtractRect

IntersectRect

UnionRect

### 12.1.x SMSL.Regiion

Messages

CreateRectRgn

CreateRectRgnIndirect

CreateEllipticRgn

CreateEllipticRgnIndirect

CreatePolygonRgn

CreatePolyPolygonRgn

CreateRoundRectRgn

CombineRgn

CopyRgn

EqualRgn

FromHandle

GetRgnBox

OffsetRgn

PtInRegion

RectInRegion

SetRectRgn

### 12.1.x SMSL.ScrollBar

Messages

GetScrollPos

SetScrollPos

GetScrollRange

SetScrollRange

ShowScrollBar

EnableScrollBar

### 12.1.x SMSL.ScrollView

Messages

FillOutsideRect

GetDeviceScrollPosition

GetDeviceScrollSizes

GetScrollPosition

GetTotalSize

ResizeParentToFit

ScrollToPosition

### 12.1.x SMSL.Size

Messages

operator==

operator!=

operator+=

operator-=

operator+

operator-

### 12.1.x SMSL.SplitterWnd

Messages

Create

CreateStatic

CreateView

GetRowCount

GetColumnCount

GetRowInfo

SetRowInfo

GetColumnInfo

SetColumnInfo

GetPane

IsChildPane

IdFromRowCol

RecalcLayout

### 12.1.x SMSL.Static

Messages

Create

SetIcon

GetIcon

### 12.1.x SMSL.StatusBar

Messages

Create

SetIndicators

CommandToIndex

GetItemID

GetItemRect\
GetPaneText

SetPaneText\
GetPaneInfo

SetPaneInfo

### 12.1.x SMSL.StdioFile

Messages

ReadString

WriteString

### 12.1.x SMSL.String

Messages

GetLength

IsEmpty

Empty

GetAt

operator\[\]

SetAt

operator const char \*()

operator=

operator+

operator+=

operator==

operator!=

operator\<

operator\>

Compare

CompareNotCase

Collate

Mid

Left

Right

SpanIncluding

SpanExcluding

MakeUpper

MakeLower

MakeReverse

Find

ReverseFind

FindOneOf

operator\<\<

operator\>\>

GetBuffer

GetBufferSetLength

ReleaseBuffer

LoadString

AnsiToOem

OemToANsi

### 12.1.x SMSL.TIme

GetCurrentTime

GetTime

GetYear

GetMonth

GetDay

GetHour

GetMinute

GetSecond

GetDayOfWeek

GetGmtTm

GetLocalTm

Format

FormatGmt

operator=

operator+

opeartor-

operator+=

operator-=

operator==

operator!=

operator\<

operator\>

operator\<\<

operator\>\>

### 12.1.x. SMSL.TimeSpan

GetDays

GetHours

GetTotalHours

GetMinutes

GetTotalMinutes

GetSeconds

GetTotalSeconds

Format

operator=

operator+

operator-

operator+=

operator-=

operator==

operator!=

operator\<

operator\>

operator\<\<

operator\>\>

### 12.1.x SMSL.ToolBar

Messages

Create

SetSizes\
SetHeight

LoadBitma

SetButtons

CommandToIndex

GetItemID

GetItemRect

GetButtonInfo

SetButtonInfo

### 12.1.x SMSL.View

Messages

DoPreparePrinting

GetDocument

IsSelected

OnActivateView

OnBeginPrinting

OnDraw

OnEndPrinting

OnEndPrintPreview

OnInitialUpdate

OnPrepareDC

OnPreparePrinting

OnPrint

OnUpdate

### 12.1.x SMSL.WinApp

Messages

LoadCursor

LoadStandardCursor

LoadOEMCursor

LoadIcon

LoadStandardIcon

LoadOEMIcon

LoadVBXFile

UnloadVBXFile

GetProfileInt

WriteProfileInt

GetProfileString

WriteProfileString

AddDocTemplate

OpenDocumentFile

AddToRecentFileList\
GetPrinterDeviceDefaults

InitApplication

InitInstance

Run

OnIdle

ExitInstance\
PreTranslateMessage

SaveAllModified

DoMessageBox

ProcessMessageFilter

ProcessWndProcException

DoWaitCursor

OnDDECommand

WinHelp

LoadStdProfileSettings

SetDialogBkColor

EnableVBX

EnableShellOpen

RegisterShellFileTypes

OnFileNew\
OnFileOpen

OnFilePrintSetup

OnContextHelp

OnHelp

OnHelpIndex

OnHelpUsing

### 12.x.x SMSL.Wnd

Messages

DestroyWindow

Create

PreCreateWindow

CalcWindowRect

GetStyle

GetExStyle

Attach

Detach

SubclassWindow

FromHandle

FromHandlePermanent

DeleteTempMap

GetSafeHwnd

IsWindowEnabled

EnableWindow

GetActiveWindow

SetActiveWindow

GetCapture

SetCapture

GetFocus

SetFocus

GetDesktopWindow

GetWindowPlacement

SetWindowPlacement

IsIconic

IsZoomed

MoveWindow

SetWindowPos

ArrangeIconicWindows

BringWindowToTop

GetWindowRect

GetCLientRect

ChildWindowFromPoint

FIndWindow

GetNextWindow

GetTopWindow

GetWindow

GetLastActivePopup

IsChild

GetParent

SetParent

WindowFromPoint

GetDlgItem

GetDlgCtrlID

GetDescendantWindow

SendMessageToDescendants

GetParentFrame

UpdateDialogControls

UpdateData

BeginPaint

EndPaint

LockWindowUpdate

GetDC

GetDCEx

RedrawWindow

GetWindowDC

ReleaseDC

UpdateWIndow

SetRedraw

GetUpdateRect

GetUpdateRgn

Invalidate

InvalidateRgn

ValidateRect

ValidateRgn

ShowWindow

IsWindowVisible

ShowOwnedPopups

EnableScrollBar

MapWIndowPoints

ClientToScreen

ScreenToClient

SetWindowText

GetWindowText

GetWindowTextLength

SetFont

GetFOnt

GetScrollPos

GetScrollRange

ScrollWindow

ScrollWindowEx

SetScrollPos

SetScrollRangfe

ShowScrollBar

EnableScrollBarCtrl

GetScrollBarCtrl

RepositionBars

DragAcceptFiles

CreateCaret

CreateSolidCaret

CreateGrayCaret

GetCaretPos

SetCaretPos

HideCaret

ShowCaret

CheckDlgButton

CheckRadioButton

DlgDirList

DlgDirListComboBox

DlgDirSelect

DlgDirSelectComboBox

GetDlgItemInt

GetDlgItemText

GetNextDlgGroupItem

GetNextDlgTabItem

IsDLgButtonChecked

SendDlgItemMessage

SetDlgItemInt

SetDlgItemText

SubclassDlgItem

GetMenu

SetMenu

DrawMenuBar

GetSystemMenu

HiliteMenuItem

SetTimer

KeillTimer

FlashWindow

MessageBox

PreTranslateMessage

SendMessage

PostMessage

ChangeClipboardChain

SetClipboardViewer

OpenClipboard

GetClipboardOwner

GetOpenClipboardWindow

GetClipboardViewer

CreateEx

GetCurrentMessage

Default

GetSuperWndProcAddr

WindowProc

DefWIndowProc

PostNcDestroy

OnChildNotify

DoDataExchange

OnInitMenu

OnInitMenuPopup

OnSysChar

OnSysCommand

OnSysDeadChar

OnSysKeyDown

OnSysKeyUp

OnCompatcting

OnDevModeChange

OnQueryNewPalette

OnQueryOpen

OnSetFocus

OnShowWindow

OnSize

OnCharToItem

OnCompareItem

OnDrawItem

OnGetDlgCode

OnMeasureItem

OnVKeyToItem

OnChar

OnDeadChar

OnHScroll

OnKeyDown

OnKeyUp

OnLButtonDblClk

OnLButtonDown

OnLButtonUp

OnMButtonDblClk

OnMButtonDown

OnMButtonUp

OnMouseActivate

OnMouseMove

OnRButtonDblClk

OnRButtonDown

OnRButtonUp

OnSetCursor

OnTimer

OnVScroll

OnNcActivate

OnNcCalcSize

OnNcCreate

OnNcDestroy

OnNcHitTest

OnNcLButtonDblClk

OnNcLButtonDown

OnNcLButtonUp

OnNcMButtonDblClk

OnNcMButtonDown

OnNcMButtonUp

OnNcMouseMove

OnNcPaint

OnNcRButtonDblClk

OnNcRButtonDown

OnNcRButtonUp

OnMDIActivate

OnAskCBFormatName

OnChangeCbChain

OnDestroyClipboard

OnDrawClipboard

OnHScrollClipboard

OnPaintClipboard

OnRenderAllFormats

OnRenderFormat

OnSizeClipboard

OnVScrollClipboard

### 12.1.2 Menu bar

#### Data Members

ItemList

#### Methods

### 12.1.3 Popdown Menu

#### Data Members

ItemList

#### Methods

### 12.1.4 Button

#### Data Members

#### Methods

### 12.1.5 Radio Button

#### Data Members

ButtonTextList

ButtonActionList

Orientation: Are radio buttons positioned vertically or horizontally?

#### Methods

### 12.1.6 Control Slider

#### Data Members

MinValue: Minimum value the slider can take

MaxValue: Maximum value the slider can take

Orientation: Is slider positioned vertically or horizontally?

#### Methods

### 12.1.7 Text Edit Box

#### Data Members

InitialText

#### Methods

### 12.1.8 List Box

#### Data Members

InitialText

#### Methods

### 12.1.9 Hot Spot

#### Data Members

#### Methods

## 12.2 Multimedia Classes

### 12.2.1 Audio Player

#### Data Members

#### Methods

### 12.2.2 Audio Recorder

#### Data Members

#### Methods

### 12.2.3 Video Player

#### Data Members

#### Methods

### 12.2.4 Video Recorder

#### Data Members

#### Methods

### 12.2.5 Graphic Viewer

#### Data Members

GraphicsFormat

ViewerRectangleSize

WindowObject

#### Methods

DisplayGraphic

CropGraphic

### 12.2.6 Graphic Editor

#### Data Members

#### Methods

### 12.2.7 Video Clip

#### Data Members

#### Methods

### 12.2.8 Audio Clip

#### Data Members

#### Methods

### 12.2.9 Graphic

#### Data Members

#### Methods

# 13 SMSL Services

-   The SMSL services use an object (message passing) architecture. An
    overview of the SMSL application environment is provided in the
    following figure:

## 13.1 ObjectConstruct

### Purpose

To create an instance of an object at run time.

### Use

Runtime

### Input

Location of root of element tree signifying the class to be
instantiated.

### Output

An object ID for the created class.

## 13.2 ObjectDestroy

### Purpose

To destroy an instance of a run-time object.

### Use

Runtime

### Input

Object ID: The object to be destoyed.

Depth: The depth to which contained objects are destroyed.

### Output

## 13.3 SendMessage

### Purpose

To send a message to an object.

### Use

Runtime

### Input

### Output

# Annex A: Using C++ as a Scripting Language

**(NORMATIVE)**

# Annex B: The SMSL Meta-DTD

**(NORMATIVE)**