AccessManager : An AccessManager creates and manages access points.
AccessPoint : An access point manages the state of a communications service.
ActionEvent : The ActionEvent class manages ActionEvents, which are sent when an action takes place on a toolkit component.
ActionListenerInterface : The ActionListenerInterface class is the abstract base class for ActionListener objects. It is the listener interface for receiving action events.
Adjustable : The Adjustable class is a base class of objects that have a minimum and maximum boundary and a value that is within these boundaries.
AdjustmentEvent : The AdjustmentEvent class manages AdjustmentEvents, which are sent when the value of an Adjustable toolkit component changes.
AdjustmentListenerInterface : The AdjustmentListenerInterface class is the abstract base class for AdjustmentListener objects. It is the listener interface for receiving...
AlarmManager : The AlarmManager class provides API that applications can use to register real time alarms. When the specified date and time arrives, the application...
Allocator : The Allocator object in GEOS-SC can stand alone (as the heap Allocator does), or it can be paired with a DataMap and used only via the DataMap.
AppAttributeData : AppAttributeData objects contain various data about attributes of built-in application objects. These are statically defined alongside...
AppBase : Every application contains an AppBase object. The AppBase object is the top object in an application's UI hierarchy ; all the FlexFrames,...
AppCachePolicy : The ApplicationCache class provides API for launching and switching between applications. The AppCachePolicy class provides hooks for OEMs to use to...
AppNameAttribute : AppNameAttribute objects define the user-visible name of a given application. Define one of these along with a ResidentApplication object.
ApplicationCache : The ApplicationCache class implements the public API for loading and unloading applications. The code that actually implements the application...
Array : The Array class is an extension of the traditional C language array.
AudioStreamDriver : This class provides API for GEOS-SC modules to access the phone hardware's audio stream.
BaseTimer : BaseTimer serves as class for all timer classes. Do not use a BaseTimer directly. Instead us one of its derived classes:Timer or RealTimer.
Bitmap : The Bitmap class provides a way to create bitmaps and get all the information about them necessary for rendering.
Block : The Block class is a subclass of Data that simply stores a single block of memory.
BroadcastListener : BroadcastListener is the base class of all listener classes that receive events from remote threads. It ties in with the Broadcaster class, to...
Broadcaster : The Broadcaster class implements a list that objects derived from the BroadcastListener class can add themselves to.
CDMAVoiceCallManager : An CDMAVoiceCallManager is the voice call manager for the IS-95 CDMA air interface.
CDMAVoiceCallOwner : A CDMAVoiceCallManager can provide special features if passed CDMAVoiceCallOwner objects.
ComponentAdapter : The ComponentAdapter class is a subclass of ComponentListenerInterface to be notified of component events.
ComponentEvent : The ComponentEvent is generated and sent to a ComponentListener when a FlexComponent is hidden, moved, resized, or shown.
ComponentListenerInterface : ComponentListenerInterface is the abstract base class for ComponentListener objects. It is the listener interface for receiving component events.
Connection : The Connection class is mostly just a wrapper for two streams so it is highly tied to the Stream class.
ContainerAdapter : The ContainerAdapter class is a subclass of ContainerListenerInterface. This subclass provides empty function definitions so that a new subclass does...
ContainerEvent : The ContainerEvent is generated and sent to a ContainerListener when a FlexComponent is added or removed from a container.
ContainerListenerInterface : ContainerListenerInterface is the abstract base class for ContainerListener objects. It is the listener interface for receiving container events.
Data : The Data class provides an opaque interface to arbitrarily complex data structures.
DataCallListener : A DataCallListener listens for events on a DataLine.
DataCallManager : A DataCallManager is an encapsulation of a phone line with a circuit data interface, such as a modem, or an air interface data call.
DataMap : The DataMap class provides movable memory allocation routines and support.
Database : The Database class allows programs to store and retrieve data in record format, where each record contains typed fields.
DatabaseListener : DatabaseListener class provides a base class for applications to derive subclasses, in order to receive database event notification.
DateTime : The DateTime class is used to manage date and time information for real-time timers.
DebugCommand : The DebugCommand class is the base class from which all new debug commands derive.
DebugMonitor : The DebugMonitor class provides a command line interface from which user defined commands can be run.
DebugMonitorLog : This subclass of Log class redirects the log output to the DebugMonitor specified in the constructor.
DeliveryEvent : This class is used by the Inbox to deliver incoming messages to applications. The Inbox sends an instance of DeliveryEvent to an app's...
DeliveryListener : The DeliveryListener class is used to receive incoming messages from the Inbox. Clients should inherit from DeliveryListener and intercept the...
DialogLayout : The DialogLayout class implements a layout manager that organizes components in a way that is useful for creating dialog boxes.
Dimension : The Dimension class is used to pass height and width information. A Dimension object contains a height and width value that can be retrieved or...
DisplayDriver : The DisplayDriver class defines the API for the display driver. The display driver provides the low level access to the device's display hardware.
EmulatedAbstractIPInterface : EmulatedAbstractIPInterface implements the AccessPoint for the Internet emulator.
EmulationVoiceCallManager : An EmulationVoiceCallManager is the voice call manager for the phone emulation environment.
EmulationVoiceCallOwner : A EmulationVoiceCallManager can use special features if passed EmulationVoiceCallOwner objects.
EventListenerInterface : EventListenerInterface is the base class for listeners of toolkit events.
FatalErrorDriver : The fatal error driver implements a fatal error function that should be called whenever the system has encountered an error so severe that the system...
FidoDriver : The FidoDriver class provides API for fetching attributes from unloaded applications and for loading and unloading applications.
File : File objects are used to manipulate data stored in FileStores.
FileBody : The FileBody class is a subclass of MessageBody used to store message bodies in the filesystem.
FileIterator : The FileIterator class is a helper class that iterates through the contents of a directory.
FileStore : FileStore is the abstract base class for file system drivers.
FileStoreIterator : FileStoreIterator is a helper class that iterates through all the FileStore objects registered with a FileStoreManager.
FileStoreManager : The FileStoreManager class manages the various FileStores and provides the public file-and directory-manipulation interface.
FilterEvent : The FilterEvent manages FilterEvents, which are sent out to the FilterListener when a user inputs text into the text object.
FilterListenerInterface : FilterListenerInterface is the abstract base class for text FilterListener objects. It is the listener interface for receiving filter events.
FlexButton : The FlexButton class creates a standard button for use in user interfaces. The button can be labeled with either a string or an image.
FlexCanvas : The FlexCanvas class is a component intended for the application writer to subclass. A FlexCanvas object allows the programmer to draw directly to...
FlexCheckbox : The FlexCheckbox class creates a standard Checkbox for use in user interfaces. The Checkbox can be labeled with either a string or an image but...
FlexCheckboxGroup : The FlexCheckboxGroup allows a maximum of 255 FlexCheckboxes to be placed together in one mutually exclusive group.
FlexComponent : This is the base class for the UI components in the toolkit library. This class should not be used by itself.
FlexContainer : FlexContainer is the base class for all Toolkit objects that can have children.
FlexDialog : The FlexDialog class consists of windows that are are displayed over other components on the screen. They are normally used to display momentary...
FlexFrame : This type of window is used mostly as a background for the contents of a main screen.
FlexHorizontalPanel : The FlexHorizontalPanel comes with a default HorizontalFlowLayout layout manager. The application does not have to worry about tracking and...
FlexImage : The FlexImage is a components that displays a bitmap. The FlexImage class will not destroy the Bitmap object in its destructor; it is up to the...
FlexInk : The FlexInk is used to accept ink data from the user and display ink data.
FlexLabel : A component that displays a single line of read-only text.
FlexList : The FlexList is a component that maintains a list of strings. A FlexScrollbar is automatically added when there are more elements in the FlexList...
FlexMenu : The FlexMenu class implements a menu component.
FlexMenuButton : The FlexMenuButton class implements a standard menu item.
FlexPanel : The FlexPanel class is used for grouping components that need to be laid out together. This object is similar to the FlexContainer, with the...
FlexScrollPane : This is a special type of FlexContainer that scrolls a single child by providing automatic scrollbars, or can be scrolled by calling...
FlexScrollbar : The FlexScrollbar class creates a scrollbar for use in user interfaces. When the FlexScrollbar's value changes, an AdjustmentEvent is sent to all...
FlexTable : The FlexTable class manages the table component, which provides a way to display data formatted into rows and columns.
FlexTextArea : The FlexTextArea is a multi-line text component that allows you to edit or view multiple lines of text.
FlexTextComponent : FlexTextComponent is the parent class of FlexTextField and FlexTextArea. This class implements the functions common to both classes.
FlexTextField : The FlexTextField class creates a single-line text object that is user-editable.
FlexVerticalPanel : The FlexVerticalPanel comes with a default VerticalFlowLayout layout manager. The application does not have to worry about tracking and destroying...
FlexWindow : This is the superclass for all window-style containers.
FlowLayout : FlowLayout is the base class for layout managers that arrange components in a straight line.
FocusAdapter : The FocusAdapter class is a subclass of FocusListenerInterface to be notified of FocusEvents. This subclass provides empty function definitions so...
FocusChangeEvent : The FocusChangeEvent class implements FocusChangeEvents, which are passed to FocusChangeListener objects that are registered with the AppBase via...
FocusChangeListenerInterface : FocusChangeListenerInterface is a listener class that is notified when the focus under an application changes.
FocusEvent : The FocusEvent is created and sent to a FocusListener when a FlexComponent has gained or received focus.
FocusListenerInterface : FocusListenerInterface is the abstract base class for FocusListener objects. It is the listener interface for receiving focus events.
FocusManagerInterface : FocusManagerInterface is the interface class from which all FocusManager objects are subclassed.
FromUnicodeConverter : This is an abstract base class for classes used to convert Unicode text into other encodings. The FromUnicodeConverter class does not allocate any...
GSMSMSSystem : The GSMSMSSystem class defines an API to the GSM SMS-TP protocol.
GSMVoiceCallManager : An GSMVoiceCallManager is the voice call manager for the GSM air interface.
GSMVoiceCallOwner : A GSMVoiceCallManager can provide special features if passed GSMVoiceCallOwner objects.
Geode : A Geode is used to intercept system notifications.
GifDecoder : This is the GIF decoder class.
HTFileCacheManager : File cache manager. There must only be one disk cache manager. All clients share the same disk cache. There is no good reason to have multiple disk...
HTFileCacheReader : File cache reader. Is a wwstream that allows reading and prevents writing.
HTFileCacheWriter : Cache writer. Is a wwstream that allows writing but prevents reading.
HTMLViewer : Viewer for displaying HTML documents. A HTMLViewer is used to display HTML data and text, i.e., MIME types "text/html"and "text/plain".
HTTP : HTTP is a www protocol that implements RFC2068. It supports HTTP/1.1 and HTTP/1.0. The HTTP methods supported are GET and POST.
HardIconListener : The HardIconListener's HardIconPressed() member function is invoked when the user presses a hard icon.
HorizontalFlowLayout : The HorizontalFlowLayout class implements a layout manager that arranges components along a horizontal line with a variety of spacing options.
InetEmulator : InetEmulator implements the Inet API with native sockets.
Ink : The Ink class is used to store and maintain ink data. The Ink class contains ink data (a collection of pen strokes made by the user).
InkAdapter : The InkAdapter class is a subclass of InkListenerInterface to be notified of ink events. This subclass provides empty function definitions so that a...
InkEvent : The InkEvent is created and sent to an InkListener when a FlexInk has started and finished drawing.
InkListenerInterface : InkListenerInterface is the abstract base class for InkListener objects. It is the listener interface for receiving ink events.
InkMonitor : The InkMonitor collects ink for every movement event after a pen down event, until it determines ink collection is done.
InlineBody : The InlineBody class is a subclass of MessageBody used to store short message bodies in the mailbox itself (in the "body-ref"field of the message...
InputEvent : The InputEvent class is a base class for input events, specifically MouseEvent and KeyEvent. Consume() an event if someone wants it to not be used...
InputManager : The InputManager class provides a mechanism by which drivers can deliver input to applications.
InputMonitor : InputMonitor objects are used to filter incoming input events.
InsetHorizontalFlowLayout : The InsetHorizontalFlowLayout class implements a horizontal flow layout that can be used as a starting point for more complicated layouts.
InsetVerticalFlowLayout : The InsetVerticalFlowLayoutclass implements a vertical flow layout that can be used as a starting point for more complicated layouts.
Insets : The Insets class implements storage for the margins of a FlexContainer. Layout managers usually operate within these margins.
InterceptShutdownListener : The InterceptShutdownListener class is used by clients to stop user-initiated shutdowns (shutdowns with PD::NORMAL_SUSPEND_PRIORITY).
IrdaClient : The IrdaClient class provides API for accessing the non-connection-oriented functions of the IrDA protocol stack.
IrdaConnection : The IrdaConnection class provides API for accessing the connection-oriented functions of the IrDA protocol stack.
IrdaDeviceList : The IrdaDeviceList is a list of IrdaDeviceInfo structures for devices found during discovery.
IrdaDriver : The IrdaDriver class facilitates communication between IrDA applications and the IrDA stack. theIrdaDriver is the single instance of this class.
IrdaIasObject : IrdaIasObject instances are created and placed in the IAS database. Remote devices search the database to determine the services offered by the...
IrdaIasQuery : The IrdaIasQuery class is used to query remote devices of the services they offer.
IrdaPacket : IrdaPacket is used for transmitting IrDA packets. This class contains a pointer to a buffer which contains the data that will be sent.
IrdaRxBuffer : IrdaRxBuffer instances contain a received packet. Applications will not actually create instances of this class but will be passed pointers to...
ItemEvent : The ItemEvent is sent when the selected state of an ItemSelectable object changes. An example of this is when the selected state of a FlexCheckbox...
ItemListenerInterface : ItemListenerInterface is the abstract base class for ItemListener objects. It is the listener interface for receiving item events.
ItemSelectable : ItemSelectable is a base class that contains a set of items for which zero or more can be selected. Examples include FlexCheckbox, FlexList,...
JisToUnicodeConverter : This class is used to convert Japanese text in the JIS national encoding into Unicode. The JIS encoding is widely used for Japanese information...
KeyAdapter : The KeyAdapter class is a subclass of KeyListenerInterface to be notified of key events. This subclass provides empty function definitions so that a...
KeyEvent : The KeyEvent is created and sent to a KeyListener when the FlexComponent receives a key press or key release.
KeyListenerInterface : KeyListenerInterface is the abstract base class for KeyListener objects. It is the listener interface for receiving key events.
LayoutManagerInterface : LayoutManagerInterface is the interface class from which all LayoutManager objects are subclassed.
List : A singly linked list of ListElement objects.
ListElement : ListElement is the base class for objects that need to be put on a List.
LoadedApps : The LoadedApps class provides API for determining the number of currently loaded applications and getting a pointer to each one.
Lock : A Lock is similar to a semaphore, but it can be acquired multiple times by a single thread.
Log : Logs provide a convenient iostream-like API for logging debugging information.
LoopbackTransport : LoopbackTransports send messages from the Outbox to the Inbox.
MailboxListener : The MailboxListener class is used to gather notifications for mailbox events. Each instance of MailboxListener may Register() to receive...
MediaAvailableListener : MediaAvailableListeners receive notification when FileStore media are inserted into or removed from the device.
MenuAdapter : The MenuAdapter class is a subclass of MenuListenerInterface to be notified of menu events. This subclass provides empty function definitions so that...
MenuEvent : The MenuEvent is created and sent to a MenuListener when a menu item is chosen.
MenuItem : The MenuItem class forms part of the inheritance hierarchy for any component that is placed inside a menu window.
MenuListenerInterface : This class is the abstract base class for MenuListener objects. It is the listener interface for receiving menu events.
Message : The Message class encapsulates a message number and seven data elements. Messages are used to pass data between threads or from an interrupt service...
MessageBody : The MessageBody class provides the common API for classes used to store message bodies.
MessagePool : The MessagePool class provides pools of Message objects for efficient allocation and deallocation.
MessagePoolManager : The MessagePoolManager class manages the initialization and destruction of MessagePool objects.
MessageQueue : The MessageQueue class is a queue of Message objects. It also provides a default Message dispatch loop implementation.
MimeDeserializer : This class is used to decode mime message bodies and convert them into our internal hierarchical representation.
MimeLayout : This class represents the structure of a MIME layout file. It maintains an array of MimePartNodes, each of which corresponds to one line in the...
MimeLibrary : This class provides some library functions for manipulating MIME data. ***************************************************************************/
MimeSerializer : This class is used to encode and serialize mime bodies that are stored using our hierarchical file format.
MouseAdapter : The MouseAdapter class is a subclass of MouseListenerInterface to be notified of mouse events. This subclass provides empty function definitions so...
MouseEvent : The MouseEvent is created and sent to a MouseListener when a FlexComponent has received a mouse press, mouse release, or mouse drag.
MouseListenerInterface : MouseListenerInterface is the abstract base class for MouseListener objects. It is the listener interface for receiving mouse events.
MouseMotionAdapter : The MouseMotionAdapter class is a subclass of MouseMotionListenerInterface to be notified of mouse motion events.
MouseMotionListenerInterface : MouseMotionListenerInterface is the abstract base class for MouseMotionListener objects. It is the listener interface for receiving mouse motion...
MovableList : The MovableList class manages a doubly linked list of nodes that are stored in movable memory. The class itself is not movable, but only takes up 8...
MovableListNode : The MovableListNode class provides an interface for interacting with the nodes in a movable list. While the class itself is not movable, it only...
NTStore : NTStore is a FileStore "driver"which uses the native NT file system to store files.
NiftySpoolListener : The spool listener for this transport.
NiftyTransport : The transport driver that implements Niftyserve transport functionality.
PD : This class allows us to put the types used by the power driver into a nonglobal scope.
PDCVoiceCallManager : An PDCVoiceCallManager is the voice call manager for the PDC air interface.
PDCVoiceCallOwner : A PDCVoiceCallManager can provide special features if passed PDCVoiceCallOwner objects.
PatternMatcher : Used to match one, or a set of, string patterns. Uses the Knuth-Morris-Pratt (KMP) pattern-matching algorithm, which is both reasonably efficient and...
PenRefUI : This class contains utility functions that pertain to the UI for a specific project.
PhoneInterfaceManager : PhoneInterfaceManager is the superclass of VoiceCallManager, DataCallManager, and FaxCallManager.
PhoneSystem : PhoneSystem manages phone numbers and arbitrates connection access.
PlatformDriver : The PlatformDriver is a driver for target hardware. This functionality is seprated in a driver to make GEOS-SC higly portable.
PointerDriver : The PointerDriver class is implemented by the pointer driver on a given platform, and provides API to the system to interact with the pointer driver.
Pop3Transport : The Pop3Transport class implements the POP3 protocol used to retrieve Internet mail from a maildrop. It uses TCP/IP sockets to connect to the server,...
PowerDriver : The PowerDriver class defines the external API for controlling the various components of a device, as well as power management behavior that is...
PowerListener : The PowerListener class has a set of member functions which are invoked when the system power status has changed.
PriorityList : The PriorityList class is an ordered, singly linked list of elements. It supports insertion, removal, and enumeration of these ordered lists.
RAMAllocator : The RAMAllocator class manages memory allocation of RAM. It is the Allocator used for both the RAMStore (otherwise known as the POS) and the heap.
RAMStore : The RAMStore is a FileStore "driver"that keeps files in nonvolatile RAM.
ROMStore : The ROMStore is a FileStore "driver"that reads files from a compressed read-only file system image.
RealTimer : RealTimers are used for timers that must go off on a specific date and time. Even if the system is suspended, the real-time clock will turn on the...
Registry : The Registry geode initializes, opens and cleans up the database file used to store registry data. This process occurs automatically because Registry...
RegistryKey : A RegistryKey object represents a key/value pair in the registry tree.
Renderer : Provides direct access to the Sprite bitmap for fast customized rendering.
ResidentApplication : The ResidentApplication object provides an interface between built-in applications and the ResidentFido driver.
RetrieveTracker : The RetrieveTracker class provides an API by which Transport users can implement per-message functionality during Transport retrieve operations.
Semaphore : A standard synchronization primitive.
Semaphore::Hold : The Semaphore::Hold helper class P's a Semaphore for the lifetime of a Hold object.
SerialDriver : There is one instance of class SerialDriver, theSerialDriver. This instance allows applications to communicate serially with remote devices using the...
Sgml : The code is ported from Geos SGML parser.
SharedExclLock : The SharedExclLock class is a synchronization object used to solve reader/writer problems.
ShellAppBase : ShellAppBase is the base class for any Environment Shell application in the system.
SjisToUnicodeConverter : This class is used to convert Japanese text in the Shift-JIS encoding into Unicode. The Shift-JIS encoding is used as an internal encoding for...
SmtpTransport : The SmtpTransport class implements the SMTP protocol used to send Internet mail. It uses TCP/IP sockets to connect to the server, with which it...
SoundDriver : The SoundDriver class defines the API for the sound driver. The sound driver is used to play tones over the speaker.
SpoolListener : This class is used to monitor the activity of the Uma message spool. Instances of SpoolListener can register to receive asynchronous notifications of...
Sprite : The Sprite class represents the bitmap used by Sprite Windows. It provides methods for maintaining the Sprite linkage, the position of the sprite on...
StandardSound : The StandardSound class provides API for playing a set of shared standard sounds on a device.
StaticMessage : StaticMessage objects are Message objects that can only be statically instantiated.
Stream : A Stream is a FIFO circular buffer with one reader and one writer.
TTimer : A TTimer is used to receive notification that a certain amount of time has elapsed. The timer is continual:it keeps notifying the program after the...
TableAdapter : The TableAdapter class is a subclass of TableListenerInterface to be notified of table events. This subclass provides empty function definitions so...
TableEvent : The TableEvent is created and sent to a TableListenerInterface when the FlexTable needs to be redrawn or the selection has changed.
TableListenerInterface : TableListenerInterface is the abstract base class for TableListener objects. It is the listener interface for receiving table events.
TagData : TagData class provides a mechanism to dynamically store and retrieve data with objects, without using the normal data member mechanism.
Target : Defines 3 methods for the streaming of tags and data.
TargetChangeEvent : The TargetChangeEvent class implements TargetChangeEvents, which are passed to TargetChangeListener objects that are registered with the AppBase via...
TargetChangeListenerInterface : TargetChangeListenerInterface is a listener class that is notified when the target under an application changes.
TenYenTransport : The TenYenTransport class implements the 10-Yen mail protocol and service jointly provided by Masternet and NTT DoCoMo in Japan.
TextAdapter : The TextAdapter class is a subclass of the TextListenerInterface class. This subclass is provided so that a user does not have to subclass all the...
TextEvent : The TextEvent is sent when a Text object is acted on. An example of this is when a character is added to the Text object or when a FlexTextArea is...
TextListenerInterface : TextListenerInterface is the abstract base class for TextListener objects. It is the listener interface for receiving text events.
TextState : The TextState class stores information about the visual appearance of text. It is passed to text drawing routines.
Thread : Threads are independent streams of execution and are used to execute multiple tasks simultaneously.
TimeDateListener : The TimeDateListener class has a member function that is invoked when the system time/date has been changed.
Timer : Timer is a timer based on the "system time", which has millisecond accuracy.
TitleEvent : The TitleEvent is sent via a TitleListenerInterface object when titled components are about to draw their title.
TitleListenerInterface : TitleListenerInterface is the base class for TitleListener objects. This class is used for receiving notification that a title is about to be drawn.
ToUnicodeConverter : This is an abstract base class for classes used to convert text in other character sets into Unicode. The ToUnicodeConverter class does not allocate...
ToolkitEvent : The ToolkitEvent class is the base class for tookit events.
Transport : The Transport class provides a uniform API for sending and retrieving Uma messages.
TreeFocusManager : The TreeFocusManager class navigates the focus between the descendants of a container.
UIFactory : The UIFactory class allows the application programmer to instantiate visible components in the toolkit.
UnicodeToJisConverter : This class is used to convert Japanese text in Unicode into the JIS national encoding. The JIS encoding is widely used for Japanese information...
UnicodeToSjisConverter : This class is used to convert Japanese text in Unicode into the Shift-JIS encoding developed by Microsoft Corporation.
UnicodeToUtf8Converter : This class is used to convert Unicode text into the UTF-8 encoding. UTF-8 is a variable-length encoding for Unicode that is used in 8-bit...
UniqueFileNameGenerator : This class generates unique filenames within a given directory, by appending a successively-iterated number to the end of a base prefix, which is...
Utf8ToUnicodeConverter : This class is used to convert UTF-8 encoded text into Unicode. UTF-8 is a variable-length encoding for Unicode that is used in 8-bit environments.
VariableArray : The VariableArray class is a subclass of Array that handles variable sized elements.
VerticalFlowLayout : The VerticalFlowLayout class implements a layout manager that arranges components along a vertical line with a variety of spacing options.
VoiceCallManager : A VoiceCallManager is a device that can make voice phone calls. Use the global object theVoiceCallManager, defined in one of the network specific...
VoiceCallOwner : A VoiceCallOwner listens for events on a VoiceCallManager.
WWFile : WWFile is a www protocol for loading local files. The size of the file stream (set using SetMimeLegth()) is defaulted to the file size.
WWList : Fixed memory list. WWList can be used as a FIFO or LIFO list. To use a FIFO list, use Append() and Get(). To use a LIFO list, use Prepend() and Get().
WWListElement : Elements of fixed memory WWList.
WWSList : Synchronize using a semaphore. Caller is response for calling lock on the list.
WWStatus : WW Status Manager
WWStream : A WWStream represents a data object with a MIME type.
WinRectangle : The rectangle groups four coordinates together, specifying a left, top, right and bottom dimension.
WinXYPoint : WinXYPoint represents an (x, y) point. The class provides several methods to simplify dealing with points.
Window : The Window class is the graphics entity that maintains location and size in a display. A window can be dull or sprite-mode.
WindowAdapter : The WindowAdapter class is a subclass of WindowListenerInterface to be notified of window events. This subclass provides empty function definitions...
WindowEvent : The WindowEvent is created and sent to a WindowListener when certain window-related events take place.
WindowListenerInterface : WindowListenerInterface is the abstract base class for WindowListener objects. It is the interface for receiving window events.
_DB_IndexDriverLinker : Class IndexDriverLinker helps to add index drivers to the system.
_DB_SearchDriverLinker : SearchDriverLinker adds a search driver to the database subsystem.