Glossary
Glossary of Terms
accessing method
A method that is either an accessor or a mutator; a way of referring to operations whose purpose is to either get or set the value of a variable.
accessor
An accessing method that gets, or returns, the value of a variable.
See also:
mutator.
action widget
A widget that enables a user to invoke an application's action. Action widgets include action buttons and menu items. Action widgets are designed to ask an application model to carry out their actions.
application
A complete program that enables users to define, process, store, and/or retrieve data in various ways. Applications help to automate various aspects of operation in some domain. Typical applications include word-processing systems, spreadsheets, calculators, and payroll systems.
VisualWorks applications are composite, in that they can be composed of other applications. Consequently, the term "application" may refer to a single application model (plus its associated user interface and domain models) or to a combination of multiple interacting application models.
application class
Canvases, menus, and graphical images are stored in VisualWorks as resources, and saved as specifications in class methods of the application model. In effect, these resource methods are a VisualWorks convention for representing user interface framework.
An application class can support multiple interfaces, each of which may involve multiple canvases for the VisualWorks main window, secondary windows and dialogs.
application framework
A set of classes that provide a core structure from which to build a complete application.
The VisualWorks application framework includes the `ApplicationModel` class and its subclasses, the `UIBuilder` class, policy classes for various platform "look-and-feels," and classes for the various widgets and value models.
application model
A model in a Smalltalk program that provides application-specific information and services. At a minimum, an application model provides the code required to support the mechanics of the graphical user interface. For example, an application model establishes the connections between widgets and domain models, and it defines the interactions between widgets.
Application models are usually created from the VisualWorks application framework. An application model refers to a subclass of the `ApplicationModel` class or to an instance of such a subclass.
argument
An object that specifies additional information for an operation. Arguments are specified as variables, literals, or expressions.
aspect adaptor
A kind of value model that accesses a value held in another object, called its subject. An aspect adaptor responds to `value` and `value:` messages by sending appropriate accessor and mutator messages to its subject. An aspect adaptor is an instance of the class `AspectAdaptor` , which is a subclass of `ValueModel` .
aspect path
A sequence of accessor method names used with an `AspectAdaptor` that together comprise the chain of messages passed to a subject to access a particular attribute. An aspect path contains multiple elements, in which the first element (the head) refers to a subject channel for the aspect adaptor, and one or more subsequent elements that specify accessor names. Aspect paths provide a way to fill in a data widget's aspect property to cause the builder to create an aspect adaptor for the widget.
assignment
An expression that makes a change to a variable's value--for example `quantity := 19` .
binary message
A message that has one argument and whose selector is made up of one or two non-alphanumeric characters (the second character may not be a minus sign.) For example, in the message expression `3+4` , the binary message is `+4` , where `+` is the selector and `4` is the argument.
binding
A binding is an association between a name and a value. Bindings are similar to variables in this regard, but are supported by special classes and provide additional operations, such as privacy and import/export provisions.
Bindings are currently used in the system in the implementation of shared variables, classes, and namespaces.
See also:
namespace
shared variable
block expression
A description of a deferred sequence of actions. A block expression consists of one or more expressions that are found within a block closure.
block closure
One or more block expressions that are enclosed in square brackets.
Boolean objects
The Smalltalk objects `true` and `false` , which serve as the answers to yes-no questions and which respond to messages that request logical operations and conditional control structures (if-then-else operations).
browser
A window that displays portions of the Smalltalk class library for viewing or editing. A browser displays its information in multiple views.
builder
An object that builds an operating window from an interface specification. A builder is created by an application model when the application needs to open a window. The builder, in turn, creates and assembles appropriate user-interface objects according to the contents of the interface specification and a specified look policy.
A builder holds onto the user-interface objects it creates. Consequently, an application can send messages to a builder to obtain programmatic access to a given widget or to the window itself.
Builders are instances of the class `UIBuilder` , which is part of the VisualWorks application framework.
bundle
A code component which may contain packages or other bundles. Bundles are used by StORE to represent higher levels of project functionality by organizing and grouping smaller components.
See also:
component
parcel
canvas
A special work area in which you paint the contents and layout of a window (or part of a window) for an application. You also affect the appearance of a canvas by setting properties. A canvas is the graphical form of an interface specification.
See also:
widget
Canvas Tool
The VisualWorks tool for fine-tuning a canvas's appearance and for invoking additional canvas-preparation tools. A Canvas Tool is automatically opened when you open a canvas.
cascaded messages
Multiple messages sent to one object in a single message expression. A cascaded message expression consists of one description of the receiver followed by several messages separated by semicolons. For example:
OrderedCollection new add: 1; add: 2; add: 3; yourself.
results in three `add:` messages being sent to the result of `OrderedCollection new` .
category
A group of classes. Every class in the system belongs to exactly one category . Classes are grouped into categories purely for organizational purposes; all classes in all categories are globally available.
See also:
protocol
Change List
The VisualWorks tool that displays the changes stored in a changes file. To open a Change List, choose Changes->Open Change List from the VisualWorks main window.
changes file
A file that lists all the changes made to the Cincom Smalltalk system in your image(1). The changes file is located in the same directory as the corresponding image file and has the file extension " .cha ." You view your changes file using the Change List.
Cincom Smalltalk language
The general-purpose, object-oriented computer programming language that is provided by VisualWorks. The applications you build with VisualWorks are implemented in the Cincom Smalltalk language , as is VisualWorks itself.
In the Cincom Smalltalk language, every entity is an object, and all processing is carried out as messages sent among the objects. Because the VisualWorks implementation of the language also provides a large set of predefined objects, the language is considered part of the Cincom Smalltalk system.
Cincom Smalltalk system
The collection of interacting objects implemented in the Cincom Smalltalk language. Some of these objects provide functions that make up the VisualWorks software development system: the compiler, debugger, browsers, and so on. Other objects in the system exist so that you can incorporate them into your own applications, as, for example, when you use classes in the VisualWorks application framework. You extend this system whenever you create new objects.
class
A description of a group of similar objects. A class serves as a "template" for defining the data and operations for these objects, which are its instances.
A class defines the instance variables in which the instances store their data, and the instance methods that describe how instances carry out their operations,
Every class is itself a kind of object and therefore has its own data (class variables) and operations (class methods). One of the primary operations of a class is to create the objects that are its instances.
class hierarchy
The structure formed by the inheritance relationships among classes. The hierarchy of classes is rooted in the class `Object` , which defines the state and behavior common to all objects in the system. `Object` does not inherit from any other class.
class instance variable
A variable whose scope is an individual class. Class instance variables are declared in the class definition, and are used to hold data about the class itself that might differ for subclasses. Class instance variables are private to the class and accessible only to its class methods.
class message
A message that is sent to a class object, which invokes a class method (e.g., `new` ).
class method
A method that defines a particular operation that is carried out by a class, such as creating an instance of itself. Class methods are invoked by sending messages to a class rather than to one of its instances.
class variable
A variable that is shared by a class and all its instances. Class variables maintain information that is the same for all instances.
component
A distinct part or module of a framework, a component is made up of single or multiple objects that provide a set of behaviors for the framework.
See also:
parcel
context
An object containing information regarding the state of a method or block of executing code.
controller
An object in a Smalltalk program that enables the user to interact with information displayed by a view. Together, view-controller pairs form user-interface objects such as widgets. A controller manages a widget's response to mouse or keyboard input.
See also:
MVC architecture
cursor
A graphic, usually in the shape of an arrow, that you move on the screen using a pointing device, such as a mouse, trackball, or joystick. You use a pointer to interact with widgets in VisualWorks windows.
data widget
A widget that displays some aspect of an application's data and/or collects it from the user. Data widgets include input fields, lists, datasets, and so on. Data widgets are designed to use value models to manage their access to the data they present.
Definer
The VisualWorks tool for generating Smalltalk code that supports widgets. The code is generated in an application model. You invoke the Definer from a Canvas Tool.
dependency mechanism
A widely used technique for coordinating the activities of different objects in an application, whereby one object, usually an instance of a subclass of `Model` , maintains a list of objects that depend on it for information and notifies these objects whenever the relevant information changes.
See also:
model
distinguished instance
The sole instance of a class in the system. Examples include: nil (`UndefinedObject` ), true (`True` ) and false (`False` ). Typically these objects have override `new` to prevent `new` instances being created.
domain
The area of endeavor that an application helps to automate--for example, employee payroll, billing, inventory control, accounting, and so on.
domain model
A model in a Smalltalk program that defines data and operations that are relevant to the application's domain. For example, an accounting application might include domain models such as `Customer` , `Account` , and so on. Domain models are generally kept free of user-interface code, so that they can be reused with other interfaces.
environment
See:
primary reference
exception
An error condition resulting in the creation of a notifier window.
expression
A sequence of characters that describes an object, which is the value of the expression. Expression types include literals, variable names, message expressions, and block expressions.
See also:
message expression
block expression
file in
To load one or more files from a disk into the current VisualWorks image(1). When Smalltalk files are filed in, any class and method definitions they contain are compiled into the image(1). Note that parcelling is now the preferred method of bringing code into the image.
File List
The VisualWorks tool for interacting with your operating system's file-management facilities. You use a File List to locate and select files in your file system and then read them into your image(1). To open a File List, choose Tools->File List in the VisualWorks main window.
file out
To store the source code for one or more classes, methods, or categories in a disk file that is separate from the VisualWorks image(1) file. Smalltalk code in file out format normally has the file extension " .st ". Filing out is a common means of backing up your work, preserving intermediate versions, or transferring code to another image (by filing in ). Note that parcelling is now the preferred method of saving code from an image.
garbage collection
A mechanism used by the object engine for reclaiming memory that was occupied by objects that are no longer valid or used in the system.
global variable
A variable whose value can be accessed by all objects within a namespace, and potentially within the entire system.
Strictly speaking, globals do not exist in VisualWorks versions 5i and later. Globals, pools, and class variables have been superseded by shared variables.
See also:
binding
namespace
graphical image
A bitmapped illustration. You create graphical images using the Image Editor, import them from other tools, or use screen capture. You can use graphical images in a variety of ways--for example, as labels for action buttons.
See also:
mask
graphical user interface
A user interface that consists of a collection of windows containing visual controls, or widgets.
In VisualWorks, a graphical user interface includes not only the windows and widgets themselves, but also various supporting objects that are supplied by the application framework. In addition, a graphical user interface includes the code that implements the widgets' application-specific behavior--the functionality that enables them to interact with domain models. A VisualWorks graphical user interface is normally implemented using one or more application models and interface specifications.
Hierarchy Browser
A kind of browser that displays the superclasses and subclasses of a particular class. To open a Hierarchy Browser, you choose Browse->Class Named... in the VisualWorks main window and then specify the class.
image(1)
A file that stores the entire state of an individual Cincom Smalltalk system, including all the current objects, all the information on the screen, and any pending instructions to the system. A VisualWorks image preserves objects between VisualWorks sessions. When you start VisualWorks, the object engine reads the image file and restores the system to its previous state. You share information between images by filing source code out of one image and filing it into another.
See also:
standard image
working image
file in
file out
parcel
image(2)
See:
graphical image
Image Editor
The VisualWorks tool for creating and modifying graphical images, with pixel-level control. You open the Image Editor from a Canvas Tool, or using the VisualWorks Launcher.
import
A namespace may express interest in other namespaces or their enclosed bindings by importing them. Namespace definitions contain an "imports list" which specify the variables or other namespaces which may be referenced within the scope of the namespace declaring the import.
Only public bindings may be imported into a namespace.
See also:
namespace
binding
inheritance
A mechanism whereby classes can make use of the methods and variables defined in all classes above them on their branch of the class hierarchy.
inheritance hierarchy
See:
class hierarchy
Inspector
The VisualWorks tool for examining the values of the variables in an object. To open an Inspector, you choose inspect from an <Operate> menu.
install
To save a resource (such as a painted canvas) in an application model. Installing a resource creates a resource method, which makes the resource available to the running application.
instance
An individual object described by a class. An instance has private memory consisting of instance variables, and it responds to messages by invoking methods defined or inherited by its class.
Every object in the Smalltalk system is an instance of a class. All instances of a given class are identical in form and behavior, although they generally hold different data in their instance variables.
instance method
A method that describes how a particular operation is carried out by every instance of a class.
See also:
class method
instance variable
A variable that stores data for an instance of a class. Collectively, an object's instance variables describe the object's data structure. Instances of the same class have the same number of instance variables with the same names; these instance variables generally store different values for different instances of the class.
See also:
class variable
interface
See:
graphical user interface
interface specification
A symbolic description of a window (or part of a window) that is created when you install a painted canvas in an application model. An interface specification contains a description of the widgets you painted in the canvas, plus the properties you set for them. When the application runs, the interface specification serves as the builder's blueprint for constructing an operational window.
interpreter
See:
object engine
keyboard focus
The state of a widget that enables it to receive input from the keyboard. You can move the keyboard focus among widgets by clicking them or by pressing the <Tab> key.
keyword
An identifier with a trailing colon, such as `ifTrue:` . Keywords are used in keyword messages.
keyword message
A message with one or more arguments whose selector is made up of one or more keywords. For example, in the following message expression:
aRunArray copyFrom: startIndex to: stopIndex
the selector is `copyFrom:to:` (consisting of keywords `copyFrom:` and `to:` ) and the arguments are `startIndex` and `stopIndex` .
Launcher
See:
VisualWorks main window
lazy initialization
A technique for initializing an instance variable. Initialization code is put in an accessor so that the variable is initialized the first time it is accessed. This technique is used in code generated by the Definer.
look policy
The platform-specific "look-and-feel" of an application's interface, which determines the appearance and behavior of buttons, scroll bars, and so on. You set the look policy by selecting it in the Settings Tool. A separate `FeelPolicy` class hierarchy introduces custom key definitions to a UI.
mask
A monochrome graphical image that is used to "mask off" certain areas of another image.
Menu Editor
VisualWorks tool for creating and editing menus. You open the Menu Editor from a Canvas Tool, or from the Tools menu of the Launcher.
message
A request for an object to carry out one of its operations. A message consists of a selector and possibly one or more arguments.
See also: binary message; keyword message; unary message.
message category
See:
protocol
message expression
A description of a message to a receiver. When a message expression is evaluated, the receiver carries out the operation requested by the message and returns an object to the sender; this object is the value of the message expression. The value is determined by the method that the message invokes. That method is found in the class of the receiver.
message protocol
The list of messages to which an object can respond. The behavior of a class may organized into several protocols, some public, some private.
message receiver
See:
receiver
message selector
See:
selector
metaclass
A class whose instances are classes. There is exactly one metaclass for each class in the image. The metaclass instance may be obtained by sending the message `class` to the class.
method
A description of how to perform one of an object's operations. This description contains a sequence of one or more expressions, which are evaluated when the method is executed. Methods are analogous to procedures or functions in other programming languages.
A method is executed when a message matching its message pattern is sent to an instance of the class in which the method is found. A method determines the value of a message expression, either by explicitly specifying the object to be returned or by allowing the receiver itself to be returned.
See also:
instance method
class method
method lookup
The mechanism used to determine which method to execute when a message is sent to an object.
The receiver object can be referenced as a variable, a pseudo variable, or the value of some expression. The class definition of the receiver's class is searched for a method matching the message selector. If none is found, the superclass is searched. If still none is found, that class's superclass is searched, and so on, until either a match is found, or there are no more superclasses to search. In the former case, that method is invoked, and in the latter case a `"Message not understood"` exception is raised. If the receiver was referenced by the special pseudo variable `super` , then the mechanism varies slightly: instead of beginning the search for a matching method in the receiver's class, the search begins in the superclass of the class of the method in which `super` was referenced.
See also:
pseudo variable
super
modal dialog box
A dialog box that must be accepted, canceled, or closed before the user can invoke any other application actions.
model
An object in a Smalltalk program that is concerned with defining and processing data. The data in a model is usually presented to users via user-interface objects . A typical VisualWorks application contains a number of different kinds of models, including domain models, application models, and value models.
Models are composite, in that they can be composed of other models. In particular, the term "model" may refer to a single piece of information presented by an individual widget or to the entire portion of the application that stores and processes information, independent of the presentation services provided by the user interface.
Models are generally created from classes in the VisualWorks application framework. Consequently, the term "model" also refers to any subclass of the Model class, or to an instance of such a subclass. As such, models inherit an implementation of the dependency mechanism.
See also:
MVC architecture
mouse pointer
See:
cursor
mutator
An accessing method that sets a new value for a variable.
See also:
accessor
MVC architecture
The classic Smalltalk programming method of decomposing an application (or a portion of an application) into models (M), views (V), and controllers (C).
namespace
A namespace is a named object which represents a name scope for a set of enclosed shared variables. All shared variables within a name space are required to have unique names, but shared variables in distinct name spaces are permitted to have the same name. A name space has a reference to its environment, which is the name space which contains the name space's primary reference -- this is used to allow the programming tools to manipulate the name space efficiently. Like a class, a name space also has a name.
Name spaces are organized hierarchically, which is to say, some of the shared variables in a name space may have other name spaces as their values. However, the shared variables in the containing name space are not automatically visible within the contained name spaces.
See also:
import
object
A software unit that contains storage for a collection of related data plus operations for manipulating that data. Fundamental kinds of objects are classes and instances of classes.
object engine
The executable program that runs the Cincom Smalltalk system on your platform; it essentially "sets in motion" the system objects in an image(1).
object memory
The zone of memory available to the object engine. The object memory is coextensive with a running image(1).
open
To start an application by sending an `open` message to create an instance of an application model. The term "open" also means causing a window to display.
package
The fundamental component used by StORE for structuring applications. Packages may be organized into larger units by grouping them inside bundles.
component
parcel
bundle
paint
To specify the layout and contents of a window (or part of a window) by selecting widgets from a Palette and positioning them appropriately on a canvas. You can also affect the appearance of a canvas by setting properties.
Palette
The VisualWorks tool that supplies the widgets you can paint on a canvas. By default, a Palette is opened automatically when you open a canvas. Should not be confused with a "color palette."
parcel
Parcels are packages of Smallatlk objects that work together as functional units and can be stored as external files. Parcels are a fast object loading mechanism especially suited for both code storage and application delivery.
See also:
component
package
bundle
pool
A group of variables that can be shared between several classes. In VisualWorks 5i, pools are superseded by namespaces.
See also:
namespace
primary reference
The primary reference of a named object (such as a class) is the shared variable whose value is the object, whose key is the same as the object's name, and which, when the class is created, renamed, or removed, is automatically created, given a new key, or removed at the same time. For example, in previous versions of VisualWorks, the primary reference of the class `Array` would be the object returned by the expression:
Smalltalk associationAt: #Array
See also:
shared variable
primitive
A method which is executed directly by the object engine.
process
A single thread of execution running within the Smalltalk system. The object engine appears as a single heavyweight process on the host platform, and it manages a multithreading scheme for running Smalltalk processes.
properties
Attributes of widgets and windows that define a variety of visual characteristics, such as font, color, borders, and so on. For widgets that display data, properties also indicate the nature of the data to be displayed and how that data is to be referenced by the application. Should not be confused with the term "property" associated with ActiveX and COM components, which refers to an attribute of the component.
Properties Tool
The VisualWorks tool for setting the various properties for individual widgets. Properties are displayed in a notebook containing pages of related properties. You open a Properties Tool from a Canvas Tool.
protocol
A group of methods in a class definition. Every method in a class belongs to exactly one protocol . Methods are grouped into protocols for organizational purposes only. Also called a message category.
pseudo variable
A pseudo variable may be distinguished from other variables in that its value cannot be reassigned. Pseudo variables include references to objects passed into a method as arguments, the special unique objects `nil` , `true` , and `false` , and special reserved words `self` , `thisContext` , and `super` . The object referenced by `self` or `super` varies depending on where they are used.
See also:
variable
Boolean objects
self
super
receiver
The object to which a message is sent in a message expression. The receiver is described by an expression. It is up to the receiver to decide how to respond to the message.
resource
An object or description needed by the builder to assemble a particular window for a running application. Resources include interface specifications (canvases), menu bars, graphical images, and database queries. An application's resources are normally stored in separate resource methods in an application model.
Resource Finder
The VisualWorks tool for locating classes that contain resources. You can use a Resource Finder to start applications or to open individual resources for editing. To open a Resource Finder, choose Browse->Resources in the VisualWorks main window.
resource method
A method (usually a class method) in an application model that returns a resource. Resource methods are normally invoked by the builder when an application opens a window.
return
To communicate information back to the sender of a message. Whenever a message expression is evaluated, the receiver of the message always responds by returning an object, which becomes the value of the message expression. Returning a value indicates that the receiver's response to the message is complete.
The object that is returned by a receiver is determined by the method that is invoked by a message. The method may specify the returned object explicitly through an expression containing the return operator (`^` ); otherwise, the default value returned is usually the receiver itself.
selector
The name of a method; the portion of a message that determines which of the receiver's methods will be invoked.
self
A pseudo variable available within the execution context of any method defined in a class. This pseudo variable always refers to the receiver of the message that invoked the method in which `self` is referenced. If `self` is referenced outside the context of a method body, like in the following workspace code:
self halt.
then `self` , like any other uninitialized variable, refers to `nil` .
See also:
pseudo variable
super
method lookup
Settings Tool
The VisualWorks tool for customizing various global parameters of an image(1), such as the default size, look, and behavior for VisualWorks tools. To open the Settings Tool, choose File->Settings in the VisualWorks main window.
shared variable
A variable whose value is logically independent of any single object. Unlike instance variables, in which each instance holds separate state for the variable, or class instance variables, in which each class holds separate state for the variable, shared variables can be shared among multiple classes.
In previous releases of VisualWorks, shared variables included class variables, pool variables, and global variables. Until version 5i.3, they were referred to as static variables.
Smalltalk
See:
Cincom Smalltalk language
snapshot
A saved image(1) file. "Taking a snapshot" of an image refers to saving that image periodically.
See also:
object memory
sources file
A file that contains the source text of the compiled Smalltalk classes and methods in an image(1). Every image consults a sources file to display class and method definitions.
specification
A description of a user interface. Specifications are usually stored as class methods in UI model classes.
standard image
The image(1) that is delivered with the VisualWorks product (also sometimes referred to as a "vanilla image.") The first time you start VisualWorks, you use the standard image; thereafter, you normally do your work in your own working image.
subclass
A class that inherits variables and methods from some other class (its superclass). A subclass is lower in the class hierarchy than its superclass. A subclass is generally a specialization of its superclass--its instances have the same kind of data and behavior as instances of the superclass, plus some of their own. A subclass may also override any of its inherited behavior by redefining inherited methods.
subject
An object that holds onto information to be accessed by an aspect adaptor. Every aspect adaptor is created either with a subject or a subject channel.
subject channel
A value model that holds onto a subject for an aspect adaptor. Subject channels provide a convenient mechanism for changing a subject that is shared by multiple aspect adaptors.
super
A pseudo variable that refers to the receiver of the message that invoked the method in which `super` is referenced. `Super` behaves exactly like `self` in regards to the object it references. However, `super` behaves differently when looking up a method to match a message.
See also:
pseudo variable
self
method lookup
superclass
The class from which variables and methods are inherited. A superclass is higher in the class hierarchy than its subclasses.
symbol
A string that is guaranteed to be unique in the system; class and method names are symbols. A symbol is expressed literally by prefixing it with the character `#` (for example, `#balance` ).
System Browser
A VisualWorks tool for creating and viewing class and method definitions. To open a System Browser, choose Browse->System in the VisualWorks main window. There are many types of browsers in VisualWorks.
system classes
The set of classes that come with the Cincom Smalltalk system. The system classes provide the standard functionality of a programming language (arithmetic, data structures, control structures, and input/output facilities) and development environment (editor, compiler, debugger, window system, and so on).
With the advent of namespaces, the system classes are found in the namespace named `Smalltalk` .
System Transcript
The display area for informational messages generated by VisualWorks or your code. By default, the System Transcript is in the area below the tool bar of the VisualWorks main window. To close or reopen a System Transcript, choose Tools->System Transcript from the VisualWorks main window.
tab chain
A sequence of widgets (in a single window) whose properties are set so that the application user can move keyboard focus among them using the <Tab> key.
temporary variable
A variable that provides temporary storage for a value referenced in one or more expressions, usually in a method definition.
A temporary variable is declared between vertical bars--for example `| aCheck |` .
text cursor
A small vertical bar or triangular graphic that indicates where typed input will be inserted. A triangular text cursor appears at the base of a line of text.
UI object
See:
user-interface object
unary message
A message without arguments. In a message expression such as `0 asValue` , the unary message is `asValue` .
user interface
The means by which a user can control the behavior of an application; the software that handles input and output.
See also:
graphical user interface
user-interface object
An object in a Smalltalk program that is concerned with presenting information and enabling users to interact with it. User-interface objects include windows and widgets. Each user-interface object is a complex object containing a view coupled with a controller and associated supporting objects.
value
The object that is described by an expression. The value of a variable name is the object that is referenced by the variable. The value of a message expression is the object returned by the invoked method.
In discussions concerning value models, "value" usually refers to the object that is returned by sending the message `value` to a value model.
value holder
A kind of value model that holds onto its value through an instance variable. A value holder is an instance of the class `ValueHolder` , which is a subclass of `ValueModel` .
See also:
aspect adaptor
value model
An object that contains or refers to some other object (its value). A value model responds to a standard protocol (the messages `value` and `value:` ) for accessing the value, and also otifies other interested objects when the value changes.
Typically, data widgets depend on value models to store or retrieve the data they collect or display.
Value models are created from the VisualWorks application framework. The term refers to a subclass of the class `ValueModel` , or to an instance of such a subclass.
See also:
aspect adaptor
data widget
value holder
variable
A storage place within an object for a reference to another object. A variable's name is a simple identifier composed of letters and digits, beginning with a letter. A variable name is used as an expression that describes the referenced object.
The methods in a class have access to different kinds of variables ( see: class variable, global variable, instance variable, and temporary variable). These kinds of variables differ in terms of how widely they are available (their scope), how long they persist, and their capitalization conventions.
view
A visual component that displays text or graphics representing information in a model. A view is tightly coupled with a controller; together, view-controller pairs form user-interface objects such as widgets.
Views are composite, in that they can be composed of other views. Consequently, the term may refer to the display of a single widget or to the portion of an entire graphical user interface that is devoted to displaying.
A view also refers to any of the display regions of a Smalltalk browser. For example, in a System Browser, the category view displays a list of categories in the system, whereas the code view displays textual lines of code.
See also:
MVC architecture
visual component
Any object that can display itself in a window.
See also:
widget
visual part
A kind of visual component that identifies two other visual components: one outside and wholly containing the visual part, the other inside as a component of the visual part. The containing visual component is known as the container and the other, the component .
visual structure
A linked container/component tree of visual parts. The visual structure of a window is a tree whose root node is the window itself and its subnodes are visual parts. Messages for control or window repair (damage) pass down the visual structure to the components that need control or updating. Similar messages as requests pass up the visual structure from a component to its container. Also known as a visual component tree .
VisualWorks main window
The window that serves as the starting point for your work. The VisualWorks main window is identified by the title " VisualWorks " and the name under which the image was last saved. It contains a menu bar and a tool bar for invoking VisualWorks' main tools. Formerly known as the Launcher.
widget
A visual part that appears in an application's graphical user interface--for example, an action button, an input field, or a scrollable list. Widgets are controls that enable the application user to view information, enter information, or invoke operations.
Each widget is a user-interface object that provides a characteristic display and visual response to keyboard and mouse input. Each widget consists of a view coupled with a controller and associated supporting objects.
Widgets have an attribute of class `WidgetState` which maintains their boolean conditions. A visual part which is not a widget may be made to respond to most of the widget protocol by placing it in a `WidgetWrapper` .
See also:
action widget
data widget
window
A display area on the screen that is part of an application's graphical user interface. A window presents the user with information and controls for invoking operations. You create a window for an application by painting a canvas and installing it in an application model.
working image
An changed copy of the standard image in which a user does his or her own work.
wrapper
A container with a single component that modifies or provides certain services to the component such as translation of coordinates, a bounding box, a border, or scroll bar facilities.
Workspace
A window in which you can enter text and/or evaluate fragments of Smalltalk code. To open a Workspace, choose Tools->Workspace in the VisualWorks main window.