Create the external constraint function: A + B + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Construct a cartoon line between two points.
You should make sure that if you use a pacing function which is
a slow_in_slow_out that the result of the slow part is 0.2
(== cutoff_point).
Create the external constraint function: (A + B)/2 + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
An interface_pred predicate class to serve as a "continue predicate" (see
base_interactor.traverse_and_collect()) for a semantic redraw traversal
(done by a semantic lens object).
Constructor based on a loaded_image for use as an icon within a button
and assuming a default position (presumably this object will be positioned
with constraints).
This callback method collects callbacks from multllist_lists that don't have
a "private" callback object set on them and forwards to our callback
object.
Create the external constraint function: clip(A, B+K, C-K) which means:
result = A;
if (A < B+K) result = B+K;
if (A < C-K) result = C-K;
return result
For the external case, K can be any integer.
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the constraint function: clip(A, B+K, C-K) which means:
result = A;
if (A < B+K) result = B+K;
if (A < C-K) result = C-K;
return result
In this case K is treated as an unsigned 8 bit quantity.
Constant for return from char_filter to signify that character is to
be considered a closure point which ends input and should be acted upon
(usually this would be done for end of line characters).
This interface provides constants for refering to parts of objects in
composition placement rules and for declaring expected types to composer
objects.
Do the constraint evaluation necessary to make sure all visible objects
in the subtree rooted at this object have up-to-date bounds (and other
information) prior to drawing.
Do the constraint evaluation necessary to make sure all visible objects
in the subtree rooted at this object have up-to-date bounds (and other
information) prior to drawing.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
Indicate that the object has been modified in such as way that its
appearance within the given area of the screen (expressed in local
coordinates) might change and needs to be redrawn.
This is subclass of interactor applet that inserts a debugging lens
above its normal subtree (using a debug_lens_top_level object with
a fake_top_level child).
This class is a special subclass of top_level that provides support for
a semantic_lens object providing debugging information about the
interactors installed under it.
This class has been provided an extensibility hook for the particular
purpose of allowing code that monitors the effects of input dispatches
of other people's code.
This method is called by some policies (most notably the
positional policy) to dispatch events which did not meet the
selection criteria of the policy itself.
We override dispatch_unused_event so we can tell the object
that the mouse left the area even if the mouse is now not
over any of our sub_arctic interactors.
Create the external constraint function: (A / B) + K (returns K on div
by zero)
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Attempt to perform event dispatch(es) to the given object, resetting
the state to the start state when appropriate (see comments for
make_transition).do_init() -
Method in class sub_arctic.lib.interactor_applet
Initialize by registering the component with the manager then calling
user routines.
Draw the object on the given drawing surface at the given location.
Note: this will produce useful results only if compose() has already been
called to establish a layout.
Specialization of, and wrapper for, Graphics class.
This class provides a specialization of the AWT Graphics class that
modifies drawing operations slightly to work better with subArctic
(e.g., in the area of image drawing), and add some operations for
convenience purposes.
Establish an associative link between the given part of a value_consumer
(usually an interactor) and part of a value_provider (usually an
external_constraint) that gives it a value.
Option flag to handle an unexpected exception by sending the
"handle_exception()" message to the object previously registered
via "handle_exceptions_with()".
This is a small class that just provides one static method: OBJ() which
returns an ext_objpart_encoding initialized to refer to a given interactor
object.
Create the external constraint function for fill: B - A - K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Collect the set of snap target objects whose bounds are within snapping
distance of the bounding box of the feature points of the object being
dragged.
This function gets called to inform you that you have been put into
the focus set (in this case the menu_focus_agent is the agent
whose set you are in).
Transform a point in global coordinate space (that is the coordinate
system of the top_level object which roots the interactor tree this
object is in) into the local space of the object.
Transform a point in global coordinate space (that is the coordinate
system of the top_level object which roots the interactor tree this
object is in) into the local space of the object.
Transform a point in global coordinate space (that is the coordinate
system of the top_level object which roots the interactor tree this
object is in) into the local space of the object.
Transform a point in global coordinate space (that is the coordinate
system of the top_level object which roots the interactor tree this
object is in) into the local space of the object.
Construct a blank based on 3 images, a set of border sizes, and either
an exterior or an interior size request for both the height (as
indicated by w_kind being either EXTERIOR_SIZED, or INTERIOR_SIZED
respectively).
This abstract class represents an based interactor blank which is capable of
being expanded both horizontally and vertically to meet a given size
request.
Construct a blank based on 9 images, a set of border sizes, and either
an exterior or an interior size request for both the width and height
(as indicated by w/h_kind being either EXTERIOR_SIZED, or INTERIOR_SIZED
respectively).
Construct a blank based on 9 images, a set of border sizes, and either
an exterior or an interior size request (as indicated by size_kind being
either EXTERIOR_SIZED, or INTERIOR_SIZED respectively).
Create the external constraint function:
(if self.enabled then A else B) + K.
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the external constraint function:
(if self.visible then A else B) + K.
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
This is a small demo program that allows rectangular sections to be
cut out of images (loaded from a URL) and then written out as subArctic
code for statically initializing a loaded_image object.
interactor_dragout_applet is a subclass of interactor_applet that lets
you pick up your applets and drag them outside of the browser! To put
them back, just close the window containing the applet and it'll pop back
into the browser window.
This is a version of a toggle which implements the look of a label_toggle
via the style system (which can have the look of either a radio button or
a checkbox).
A container class that normally draws its first child, but will alternately
draw a different child when given a properly constructed lens_info_drawable
(i.e., one from a switch_lens) to draw on.
Construct a blank in memory image of the given size and force it
to be "loaded" (not clear what that means for in-memory images, but
it seems to be required).
Transform a point in the local coordinate space into the global space
(that is the coordinate system of the top_level object which roots the
interactor tree this object is in).
Transform a point in the local coordinate space into the global space
(that is the coordinate system of the top_level object which roots the
interactor tree this object is in).
Transform a point in the local coordinate space into the global space
(that is the coordinate system of the top_level object which roots the
interactor tree this object is in).
Transform a point in the local coordinate space into the global space
(that is the coordinate system of the top_level object which roots the
interactor tree this object is in).
This class provides overall coordination and management functions for the
toolkit as well as providing a series of utility functions, and functions
that isolate the interface to AWT.
Mark all our geometric parts out-of-date and tell all potentially
dependent objects that all our parts are out-of-date (this gets done
when we move around in the hierarchy).
Mark all our geometric parts out-of-date and tell all potentially
dependent objects that all our parts are out-of-date (this gets done
when we move around in the hierarchy).
Create the external constraint function: max(A,B) + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
This parameter controls how far down the images resulting from
a menubar should be shifted down (in their hotspot) to compensate
for potential style system beveling.
This parameter controls how far down the images resulting from
a menubar should be shifted down (in their hotspot) to compensate
for potential style system beveling.
Create the external constraint function: min(A,B) + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the external constraint function: (A % B) + K (returns K on mod
by zero)
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the external constraint function: A * B + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
This class provides a simple base class for objects which represents a
current position within an interactor tree and provide an API for moving
that position around in the tree (i.e., implement navigable).
Determine if a given platform specific workaround (identified by a
platform id and workaround id pair) is needed on the platform we are
currently running on.
Create the external constraint function: A + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Reset after each call to nextOption(), optarg() returns the argument to
the option, if one was provided, and if Getopt is "expecting" an argument
as specified by the optstring (using the colon notation).
This is an interface for implementing pacing functions.
Your function should map a point in a time interval (0.0 to 1.0)
to another point in that interval.
Create the external constraint function: parent.fun1(A,K) which is a
special function in all interactors that can be overridden to to subclass
specific things.
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the external constraint function: parent.fun2(A,B,K) which is a
special function in all interactors that can be overridden to to subclass
specific things.
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the constraint function: parent.fun2(A,B,K) which is a special
function in all interactors that can be overridden to to subclass specific
things.
You can call this method from another thread and it will perform
the work represented by the work_proc with the system in a safe
synchronization state.
Determine if the given point (in local coordinates) is close enough
to snap to this object (and return the square of its distance, and
the point snapped to).
Determine if the given point (in local coordinates) is close enough
to snap to the point (and return the square of its distance, and
the point snapped to).
Produce an in-memory loaded_image containing the drawing of a gradient
with the same color sequence, but using a different center line and/or
angular offset.
Produce an in-memory loaded_image containing the drawing of a masked
gradient with the same color sequence, but using a different center line
and/or angular offset.
Produce an in-memory loaded_image containing the drawing of a gradient
with the same color sequence, but using a different center point and/or
angular offset.
Produce an in-memory loaded_image containing the drawing of a masked
gradient with the same color sequence, but using a different center point
and/or angular offset.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a gradient with the same color sequence, but
using a different center point and/or angular offset.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a masked gradient with the same color sequence,
but using a different center point and/or angular offset.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a gradient with the same color sequence, but
using a different orientation line.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a masked gradient with the same color sequence,
but using a different orientation line.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a gradient with the same color sequence, but
using a different center point and/or angular offset.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a masked gradient with the same color sequence,
but using a different center point and/or angular offset.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a gradient with the same color sequence, but
using a different orientation line.
Produce an in-memory data array (suitable for constructing an image)
containing the drawing of a masked gradient with the same color sequence,
but using a different orientation line.
Create the external constraint function: rotate_x(theta, D) + K where
rotate_x computes the x position found by rotating the point dist,0 by
theta/1000 degrees counter-clockwise (i.e.
Create the constraint function: rotate_x(theta, D) + K where rotate_x
computes the x position found by rotating the point dist,0 by theta/1000
degrees counter-clockwise (i.e.
Create the external constraint function: rotate_y(theta, D) + K where
rotate_y computes the y position found by rotating the point dist,0 by
theta/1000 degrees counter-clockwise (i.e., a scaled cosine function).
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Create the constraint function: rotate_y(theta, D) + K where rotate_y
computes the y position found by rotating the point dist,0 by theta/1000
degrees counter-clockwise (i.e., a scaled cosine function).
Create the external constraint function: self.fun1(A,K) which is a
special function in all interactors that can be overridden to to subclass
specific things.
Create the external constraint function: self.fun2(A,B,K) which is a
special function in all interactors that can be overridden to to subclass
specific things.
An interface_pred predicate class to serve as a "continue predicate" (see
base_interactor.traverse_and_collect()) for a semantic redraw traversal
(done by a semantic lens object).
This is a special version of set_focus_to for the menu agent since
frequently menus are popped up from some object which needs to
be aware that the interaction has now ended.
This function will move the scrolled object in such a way that
the parameter given will be at the top of the displayed area.
It takes into account margins and bevelling.
Sets the interactors we are focussed on- not sure what the application
for this is, yet, but there may be something interesting, such as
an agent that sets the targets to every instance of some class
Sets the interactors we are focussed on- not sure what the application
for this is, yet, but there may be something interesting, such as
an agent that sets the targets to every instance of some class
This class implements a simple blank base on a rectangle with a
highlight color one pixel above and left, and a shadow color one pixel
below and right.
This class implements a simple blank base on a rounded rectangle with a
highlight color one pixel above and left, and a shadow color one pixel
below and right.
This function is called when the listbox is sure that no further
click is forthcoming and that the callback code for the
SINGLE_CLICK_FINAL can be safely called.
Most users shouldn't need to override this method, as they can
put their code to handle the single click in the callback object.
The object passed as the parameter to the callback function
when this callback is run is the currently focused on
object.
Interface to define user accessible constraint encoding constants.
This interface defines a series of "constant factories" used to designate
parts of objects in a standard constraint.
This class provides an external constraint that executes one of the
standard constraint functions based on a (partial) standard constraint
encoding along with an explicit set of operands (which involve explicitly
provided objects and standard or non-standard parts).
Construct a 2 operand external constraint that executes the constraint
function encoded in standard from, but with potentially arbitrary
operand values.
Construct a 1 operand external constraint that executes the constraint
function encoded in standard from, but with a potentially arbitrary
operand value.
This class holds onto information that the toolkit will need about
the current way to display the interface and other properties of
the interface w.r.t.
Construct a blank in memory image of the given size and force it
to be "loaded" (not clear what that means for in-memory images, but
it seems to be required).
Construct a blank in memory image of the given size and force it
to be "loaded" (not clear what that means for in-memory images, but
it seems to be required).
Construct a blank in memory image of the given size and force it
to be "loaded" (not clear what that means for in-memory images, but
it seems to be required).
Create the external constraint function: A - B + K
Note: the "self" object and orientation for this constraint need to
be filled in before the constraint is used.
Convert to a small tag string which indicates the type of interactor
along with a (hopefully unique) integer (its hashCode) that can
be used to identify it during debugging.
Convert to a small tag string which indicates the type of interactor
along with a (hopefully unique) integer (its hashCode) that can
be used to identify it during debugging.
This class creates a drawable_wrapper object which does a debugging
trace print of its operations as it draws (then forwards the actual
drawing operation to its wrapped drawable).
Construct a blank based on either an exterior or an interior size
request (as indicated by size_kind being either EXTERIOR_SIZED, or
INTERIOR_SIZED respectively, which we promptly ignore since they are
the same for us).
Construct a blank based on either an exterior or an interior size
requests (as indicated by size_kind being either EXTERIOR_SIZED, or
INTERIOR_SIZED respectively, which we promptly ignore since they are
the same for us).
Interface representing an object that transforms a set of "parameter"
values from those suitable for use by a parent object into a set suitable
for use by a child object (for example, during a traversal using
traverse_and_collect()).
Return a positive integer value that is unique among results from this
routine (we ignore the fact that this will eventually wrap-around, so
if you need one every micro-second, do it yourself with a long).
Construct a blank based on 3 images, a set of border sizes, and either
an exterior or an interior size request for both the height (as
indicated by h_kind being either EXTERIOR_SIZED, or INTERIOR_SIZED
respectively).
Indicate that a part value (X, Y, W, H, VISIBLE, ENABLED, PART_A, or
PART_B) with an external constraint attached should be marked out-of-date
because something it depends on (externally) is out-of-date.
Indicate that a part value (X, Y, W, H, VISIBLE, ENABLED, PART_A, or
PART_B) with an external constraint attached should be marked out-of-date
because something it depends on (externally) is out-of-date.
This is the class that handles dispatching the work_procs on
the "synchronized side of the world."
User's should never use this class directly but should use
the API in the manager instead.
This interface provides you with the basic infrastructure necessary
to execute multi-threaded code safely in the sub_arctic framework.
This interface defines a function which you can arrange to be called
with the sub_arctic system in a "safe state." In this state, you
can call any methods on any sub_arctic objects in your interface; if
you are not in this state, you should not be modifying
the interactor tree or any of the sub_arctic infrastructure.