 |
The glossary from the book “The Power of PenPoint,”
pp. 323-334.
This Glossary defines terms that are used in this book or that are important
to an understanding of PenPoint.
abstract class
A class that defines messages or provides useful functionality, but is not
useful as is; you wouldn’t create instances of it.
accessory
An accessory document floats on the desktop when active, appearing over
pages in the Notebook. Most accessories appear in the Tools auxiliary notebook.
acetate plane, acetate layer
The window system maintains a global, screen-wide display plane; called the
acetate plane, which is where ink from the pen is normally dribbled by the
pen-tracking software as the user writes on the screen.
activation
The transition of a document to an active state, with a running process, an
application instance, and so forth.
activation
What happens when the user actually operates a control, often by lifting the pen
up. The user can preview a control without activating it.
ancestor
Every class has one immediate ancestor. When a class receives a message,
the class can elect to pass the message on to its immediate ancestor, and
in turn the ancestor may pass on the message to its own ancestor. Hence a
class can pick up, or inherit the behavior of its ancestors.
API
Application Programmer’s Interface – The programmatic interface to a
software system. The PenPoint API is covered in depth in the Architecture
Reference; the functions and messages comprising the PenPoint API are listed in
the API Reference and in the header files in \penpoint\sdk\inc from which the API
Reference was derived.
application class
A PenPoint class that contains the code and initialization data used to
create running applications.
Bezier curve
A curved line formed from two end points and two control points, supported by SysDC.
bind
You must bind a DC to a window (and hence a pixel device) before you can draw using it.
binding
The process that joins a device driver to a port or another device driver;
for example, a client binding to a service makes the client known to that service.
bitmap
An array of pixels, with an optional mask and hot spot.
Browser
A component that displays file system contents to the user; used in disk
viewers, installers, and TOCs.
button
Buttons are labels that the user can activate.
child window
A window that is a child, or grandchild, of another in the window tree.
choice
A table that displays several alternatives and allows the user to pick only one.
class
A special kind of object that implements a particular style of behavior
in response to messages. Most classes act as factories for objects: you can create
instances of a class by sending that class the message msgNew. In the PenPoint
Class Manager, a class has a method table. The method table tells the class
which messages sent to objects of that class to respond to. A class’s
processing of a message often involves passing the message to the class’s
ancestor in order to inherit appropriate behavior.
Class Manager
The code that supports the object-oriented, message-passing, class-based
programming style used throughout the PenPoint operating system and in
all PenPoint applications. The Class Manager itself implements two classes,
clsObject and clsClass.
client
(1) The general term for any software using some feature of PenPoint (2)
The object that receives messages from Toolkit components notifying it of important
user actions and events.
client window
Frames and scrollwins manage a window that is supplied by, or of interest to,
the client of the frame or scrollwin.
clipping
The process by which drawing operations in a window are prevented from
affecting certain pixels on the windowing device, for example because those pixels
are part of another window.
clsApp
Class for all applications; provides a head start framework by responding
to the PenPoint Framework’s protocol of messages.
component
A piece of system or application software functionality with a well-defined
external interface, packaged as a DLL, which can be used or dynamically
replaced by a third-party developer. Some components are unbundled and must
be licensed separately from PenPoint.
component layer
The component layer of PenPoint consists of general-purpose subsystems
offering significant functionality that can be shared among applications.
connected
A file system volume that is accessible from a PenPoint computer is
connected: a volume may be known yet disconnected.
constraints
Specifications for the sizing and positioning of child windows during
layout. The UI Toolkit includes clsTableLayout and clsCustomLayout, which implement
tabular layout and relative positioning respectively.
context
(1) Information maintained by the driver and slave in a traversal engine
episode. (2) Information maintained by the Class Manager to keep track
of messages passed up and down the class hierarchy during message processing.
(3) The PenPoint Source Debugger maintains a context indicating the current
procedure body, which controls the lexical scope of variables.
cork margin
An optional thin strip in the default application frame which knows how
to embed applications.
current directory entry
Each directory handle maintains a reference to the next directory entry it
will use when the directory is read one entry at a time.
current grafic
A picture segment maintains an index in its set of grafics which is the
grafic relative to which the next operation will take place.
data object
An object that maintains, manipulates and can recursively file data. Any
descendant of clsObject can do this. Often used in Applications together with a
view that observes the data object.
data resource
Contains information saved as a stream of bytes; see also object resource. ..||:|
DC
Drawing Context – An object that implements, an imaging model; it
draws on the device of the window to which it is bound. GO’s SysDC is the
imaging model used by all PenPoint’s visual components.
deactivate
Deactivating an application removes its code from the user’s PenPoint
computer, but the Installer still keeps track of the application’s UID
and its home.
descendant class
A class that inherits from another, either directly or through a chain of subclasses.
directory handle
An object that references either a new or existing directory node in the file system.
dirty layout
A client can mark a window’s layout dirty to indicate that it needs to be laid out.
dirty window
The window system marks regions of a window dirty when they need to be
repainted. Dirty windows later receive msgWinRepaint telling them to repaint
their contents. You can mark windows as dirty yourself to make them repaint.
document
A filed instance of some application. A document has a directory in
the application hierarchy, but at any given time it may not actually have
a running process and a live application instance. These usually are destroyed when
the user turns the page. Most documents live in the Notebook, but running
copies of floating applications such as the Calculator and Installer are also documents.
dribble
The ink from the pen when the user writes over windows that support
gestures and/or handwriting.
driver
The object requesting the traversal (such as the traversal engine or the search
and replace application); see also slave.
DU4
Device Units 4th quadrant – The coordinate system of pixels on the
PenPoint-based screen. Usually you perform window operations in LWC and
specify drawing coordinates in LUC.
embed
The PenPoint Framework provides facilities for applications and components to
display and operate inside other applications and components without detailed
knowledge of each other. For example, every page in the Notebook is
actually a document embedded in the Notebook’s window. As another
example, a business graphic document or component can be embedded within a
text document.
embedded document
An embedded document is a document contained within another document.
embedded window mark
clsEmbeddedWin provides an embedded window mark that indicates the location of
an embedded window.
entries
The items in a list box. List boxes are scrolling windows that support
very large numbers of items, not all of which need to exist as windows at all times.
event
The occurrence of some an activity, such as the user moving the pen or pressing a key.
extract
The removal of a window and its children from the tree of windows on some
device. It makes the window invisible but does not destroy it.
fields
Labels in which you can handwrite.
file export
A mechanism of the browser that presents the user with a choice of file
format translators to export the selection.
file handle
The object with which you access a file node and its data (the handle is not a file itself).
file import
A mechanism of the browser that presents the user with a list of available
applications that can accept the imported file.
filing
Objects must ordinarily file their state in the file system so that the user
is not aware of documents activating and terminating on page turns.
filter
A means of restricting the kinds of messages an object or process receives.
fixed-point numbers
A 32-bit number composed of an integer and fractional component.
floating
A floating window appears above the main Notebook; unlike documents on pages
in the Notebook, the user can move and resize a floating window.
font cache
After ImagePoint renders a font glyph into a bitmap, it keeps the bitmap
in a font cache to speed future drawing of the character at that size.
frame
The border surrounding documents and Option Sheets, which often includes
a title bar, resize corner, move box, and so forth.
gesture
A simple shape or figure that the user draws on the screen with the
pen to invoke an action or command. (See also scribble.)
global memory
Memory accessible from all tasks – you can pass pointers to objects
in global memory between tasks.
glyph
A symbol or character in a font.
grab
Getting exclusive notification of events in the system, for example when
tracking the pen.
grafic
The individual figure drawing operations stored in a picture segment.
graphics state
The current scale, rotation, units, foreground and background colors,
line thickness, and so on, maintained by a SysDC object.
heap
A pool of memory; individual chunks of memory in it aren’t protected,
but it’s cheaper than allocating a segment.
hot mode
A state in which the PenPoint Framework will not terminate (shut down) an application.
image device
A windowing device the image memory of which is under the control
of the client (instead of on a screen or printer).
in-line
In-line fields provide full handwriting and gesture recognition, allowing the
user to write with the pen directly into the field itself.
In Box
PenPoint’s In Box and Out Box services allow the user to defer and
batch data transfer operations for later execution; they appear as iconic notebooks.
inheritance
A class inherits the behavior of its immediate ancestor class. Through
inheritance, all classes form a tree with clsObject at the top.
insertion pad
A window that supports character entry. It may contain windows supporting
different kinds of character entry such as character boxes, ruled paper,
and a virtual keyboard.
installation
Usually refers to the process of installing some item onto a PenPoint
computer, especially an application, but also fonts, handwriting prototypes,
and services.
instance
Every object is an immediate instance of the class that created it. It
is also an instance of that class’s ancestors. For example, a button
is an instance of clsButton, but it is also an instance of clsLabel, of
clsWin, and of clsObject.
instance data
Data stored in an object; it is normally only accessable by the object’s
class, which uses instance data in responding to messages sent to that
object. The class defines the format of the instance data. Classes often
choose to have instance data include pointers to instance information stored
outside the object.
kernel
The portion of the PenPoint operating system that interacts directly with the
hardware; the core memory and task management code that is the first code
loaded when PenPoint boots. Most system services are implemented in the kernel.
label
A window that displays a string or another window.
layout
The process of sizing and positioning a tree of windows. Windows and
Graphics implement a protocol through which a client can tell windows to
lay out, and windows can ask each other for their desired sizes. Instead
of specifying the exact position and size of all windows, you need only
supply a set of constraints on their relative positions.
list
An object that holds an ordered collection of items.
list box
A scrolling window that displays a subset of entries from a potentially very large set.
local memory
Per-process memory; pointers to objects in local memory can only be passed
between tasks in the same task family.
local volume
Volumes on hard or floppy disk drives attached to the PenPoint Computer through
its built-in SCSI port.
locator
Specifies a node in the file system; it is a directory handle:path pair, in which
the path is the path from that directory handle to the node.
LUC
Local Unit Coordinates – Arbitrary coordinates associated with a DC. You
can specify different units, scaling, rotation, and transformation for LUC.
LWC
Local Window Coordinates – The coordinates of a window in pixels,
with the origin at the lower-left corner of the window.
main window
The window of an application that the PenPoint Framework inserts on-screen in
the page location or as a floating window. An application’s main window
is usually a frame.
installation manager
An installation manager is an instance of clslnstallMgr that manages the
installation, activation, deactivation, and Update from Home of a set of similar items.
memory-mapped file
You can map a file into memory so that you read and write to it simply
by accessing memory.
menu bar
A frame has an optional menu bar below its title bar. The PenPoint
Framework defines standard application menu items (SAMS) for an application’s
main window frame.
menu button
A button that displays a pop-up menu when the user taps on it.
message
A 32-bit value you send to an object requesting it to perform some action.
Messages are constants representing some action that an object can perform. The
type message is a tag that identifies the class defining the message and
guarantees uniqueness. When you send a message to an object, if that
message is mentioned in the class’s method table, then the Class Manager
calls a message handler routine in the class’s code which responds to the message.
message argument(s)
The information needed by a class to respond to a message. Often the message
argument parameter is a pointer to a separate message arguments structure: this
is the only way a class can pass back information to the sender.
message handler
A function in a class’s code that implements appropriate behavior for some message
or messages; called by the Class Manager in response to message associated with
it in the class’s method table.
method
Synonym for message handler.
method table
An array of message-function name pairs (plus some flags) that determines
which message handler function (if any) will handle messages sent to
objects of that class.
Method Table Compiler
DOS program that compiles a file of method tables into an object file
that you link with your class’s code.
metrics
Information made public about instances of a class is often called metrics,
and many classes provide a pair of messages to set and get metrics.
node
A location in the File System; can be a directory or file. The PenPoint file
system is organized as a tree of nodes.
note
A window that presents transient information to the user.
Notebook
The main notebook on-screen, usually the user’s personal notebook.
notebook metaphor
The visual paradigm in PenPoint of a physical notebook containing pages, documents
and sections, with tabs, a page turn-effect, and so on.
object
An entity that maintains private data and can receive messages. Each object is
an instance of some class, created by sending msgNew to the class.
object resource
Contains information required for creating or restoring a PenPoint object;
see also data resource.
observer
An object that has asked the Class Manager to notify it when changes occur
to another object. Objects maintain a list of their observers.
open
A document currently displayed on-screen.
Option Sheet
A floating frame displays attributes of the selection in one or more card windows.
owner
The process that creates a subtask owns that subtask and any sibling
subtasks created by it.
parent window
Every window in the window tree but the root window has a parent window.
Conversely, when you extract a window from the window tree, it no longer
has a parent and so it and all its child windows are no longer visible on-screen.
PenPoint Framework
Both the protocol supporting multiple, embeddable, concurrent applications in the
Notebook, and the support code that implements most of your application’s
default response to the protocol for you. The protocol and code provide
a head start for building applications in the pen-based, document-oriented
Notebook environment.
picture segment
An object in which you can store and replay sequences of drawing operations.
pixel
A picture element with a value.
pixelmap
A rectangular array of pixels.
point
1/72 of an inch.
pop-up
A window (usually a menu or field) that temporarily appears on top of all other windows.
previewing
The feedback provided by a control while the user is manipulating the control,
before the user chooses whether to activate the control.
process
An operating system context with its own local memory.
prototype
A shape template with which sets of strokes are compared in handwriting
recognition.
proximity
A state reported by the pen hardware on some PenPoint computers when
the user has the pen near the screen. It’s independent of the
pen tip being down. Using a mouse, you simulate this by pressing
the middle mouse button to go out of proximity.
PWC
Parent Window Coordinates – The Local Window Coordinates of a window’s parent.
recognition
Matching a set of user strokes with the most likely prototype(s) during
handwriting translation.
remote volume
Volumes available over a network or other communication channel.
repaint
The pixels of a window need to be repainted in various circumstances: when
the window first appears on screen, when the window is covered by another
window and then exposed, when the window changes size, and so on. When
a window needs repainting, the window system marks it dirty. When you repaint a
window, the pixels affected are the visible portions of the dirty region.
resource
A uniquely identified collection of data. Resources allow applications to separate data
from code in a clean, structured way.
RGB
Red, Green, Blue – A means of specifying colors by the amount of these primary colors.
root directory
Top-most node of the file system hierarchy on a volume.
root window
Top of the window tree on a windowing device.
row
A Table Server table has a fixed number of columns and a variable number of rows.
sampled image
An image made up of pixels.
SAMS
Standard Application Menus – The PenPoint Framework supplies a set of
SAMS (the Document and Edit menus), to which applications can add their own menu items.
scribble
A collection of strokes that translators can translate into either text characters or
command gestures.
SDK
Software Developer’s Kit – A development package to assist developers in
writing applications for a system. The PenPoint SDK provides the code required
to develop applications, and documentation and tools to assist development.
selection
PenPoint maintains a system-wide selection, which is the target for all editing
operations. The Notebook Ul lets users select applications and icons; applications
and components may allow users to select words, shapes, and other entities
within their windows.
self
The object that originally receives a message. Code that processes a message
is passed the UID of self.
service
A general, non-application DLL that enables PenPoint clients to communicate with
a device or to access a function, such as a database engine.
service section
A section in the In Box or Out Box; each is associated with a specific service
and represents a queue to or from that service.
shut down
The PenPoint Framework shuts down a document to conserve memory by destroying
its application object and terminating its process. Thereafter the document only exists
as a directory and files in the application hierarchy.
standard message
A procedural interface to put up standardized notifications, warnings, and requests
to the user in the form of notes. The text of standard messages is stored in resources.
stationery
Application-specific template documents.
status value
Most functions and messages in PenPoint return a value of type status, indicating
success, an error of some sort, or some other status. Status values are constant
tags in order to indicate the class (or pseudo-class) returning the status, and
to guarantee uniqueness.
stroke
Data structure that stores the path traced by the pen when the user holds it
against the screen and writes with it. Note that the pen hardware supplies stroke
coordinates at much higher resolution than that of the ink dribbled by the pen on-screen.
subclass
To create a new class that inherits from an existing class. You subclass a class
in order to pick up its behavior, while modifying or extending its behavior
to do what you want.
subtask
A task that shares the address space (local memory as well as global memory) of
its parent process.
SysDC
System Drawing Context – PenPoint’s standard DC, which implements the
imaging model used by all of PenPoint’s visual components. It supports
polylines, splines, arcs, outline fonts, arbitrary units, scaling, transformation,
and many other features. It unifies text with other graphics primitives in a single,
PostScript-like imaging model.
system layer
The system layer of PenPoint provides windowing, graphics, and user interface
support in addition to common operating system services such as filing and networking.
system privilege
A high level privilege associated with executing code; particular segments may only
be accessible by tasks running at this level. Only PenPoint code executes at this
level.
tag
(1) A unique 32-bit number that uses the administered value of a well-known
UID to ensure uniqueness. (2) An arbitrary 32-bit number that you can associate
with any window. You can check a window’s tag and search for a particular
tag in the window tree; this makes tags useful for identifying components in
shared option sheets and menus.
tap
A pen down event followed by a pen up, with no significant motion in between.
task
Generic term for a thread of control executing code in PenPoint; includes
software tasks and hardware tasks.
task family
A process and all its subtasks.
task ID
Hexadecimal identifier of a task in DB.
TOC
Table of Contents – The browser page at the beginning of a notebook or
section that shows its contents.
toolkit table
Workhorse class in the UI Toolkit for a tabular collection of other components;
its descendants include choices, option tables, menus, tab bars, and command
bars. You can define toolkit tables statically, so they form a simple user
interface specification language.
translator
An object that when hooked up to a handwriting window receives captured scribbles
and translates them into ASCII characters or gestures.
UI component
Any window implemented by one of the UI Toolkit’s many classes.
UI Toolkit
PenPoint’s User Interface Toolkit provides many different kinds of window
subclasses to support a wide variety of on-screen controls, such as labels,
buttons, menus, frames, option sheets, and so forth.
UID
Unique Identifier – A 32-bit number that is the handle on an object.
When you send a message to an object, you send it to the object’s UID.
UUID
Universal Unique Identifier – A 64-bit number that is guaranteed to be
unique across all PenPoint computers, usually used to identify resources
in resource files.
view
A window that presents a user interface and observes a data object; when
the data change, the data object notifies its observers and the view updates
its display of the object.
view-data model
An approach to designing applications and components that divides the presentation
and storage of state into separate view and data objects.
volume
A physical medium or a network entity that supports a file system.
well-known
(1) An object is well known when its UID is statically defined for all
PenPoint computers. Access may still not be possible if the object is not
correctly installed on a particular PenPoint computer. Most PenPoint classes and
globally accessible objects (such as theScreen or theWorkingDir) have well-known
UID’s. (2) Well-known resource IDs identify data and object resources that can
be used by any client.
window tree
The hierarchy of windows formed by a window, its child windows, their child
windows, and so on. The on-screen window tree starts with a root window on a
windowing device.
windowing device
A pixel device that supports multiple overlapping windows. All windows are
associated with some windowing device, even if the window is not currently inserted
in the window tree on that device.
|  |
Home 
