All Classes and Interfaces
Class
Description
An exception that indicates that data source doesn't have permission to access data.
A Shape subclass to represent a segment of an ellipse with start and sweep angle.
A view to show an Arc.
A collection of array utility methods.
A view to show up to four arrows.
This class has utility methods to code and decode into various different formats: hex, ASCII85, base 64.
This class is a simple implementation of a Binary Space Partitioning Tree.
This class maps a UI node value to a model key value (some kind of display object like a Swing component value or
an RMShape size).
An effect that performs a simple blur.
A class to represent a painted stroke.
This class holds a selection of Border subclasses.
A subclass for bevel border.
This Border subclass strokes the rectangular border of a given shape, with option include/exclude
individual sides.
A subclass for etched border.
A subclass for line border.
A View subclass to manage subviews along edges (top, bottom, left, right) and center.
A ViewProxy subclass to layout views along edges (top, bottom, left, right) and center.
This class represents bounds for 3D shapes (XYZ min/max).
A View that holds another view.
A ViewProxy that can layout content in the manner of BoxView for any View.
A ListView subclass to act as a BrowserView column.
A browser class.
A View subclass that represents a simple Button.
A View for Buttons.
This class has methods to paint a button.
A ButtonPainter subclass to paint classic buttons.
A ButtonPainter subclass to paint classic buttons.
This class is like a StringBuffer for bytes instead of chars.
This class represent a camera focusing on a scene and manages a display list of simple paths based on
the scene shapes and the camera transform.
A View subclass to render.
This class manages a list of char lines.
This class represents a line of chars in a CharBlock.
This class adds some convenience methods for CharSequence.
This CharSequence sub interface adds some convenience methods.
A View subclass for CheckBox.
A MenuItem subclass for Menu-item with CheckBox.
A ChildView is a ParentView (and ViewHost) that allows children to be modified.
Utility methods for Class.
A class to handle system copy/paste and to initiate drag and drop.
ClipboardData represents a data entry from a copy/paste or drag/drop.
A simple view to provide a close box.
This Tokenizer subclass supports Java/C single-line and multi-line comments.
This view subclass holds a header label and content view with support to collapse.
A class that tracks multiple collapsers, making sure only one is visible at a time.
This class represents an RGBA color.
A View to show/set a simple color selection.
A View that handle a whole grid of color swatches, including drag and drop support.
This class provides UI for selecting a color.
A Slider subclass to show colors in slider groove.
An inner class to act as an image color picker.
This abstract class is used to serve as a color space tag to identify the
specific color space of a Color object or, via a ColorModel object,
of an Image, a BufferedImage, or a GraphicsDevice.
The ColorSpaceFactory.
This control view displays a color value and interacts with ColorPanel when selected.
A View subclass to layout child views vertically, from top to bottom.
A ViewProxy subclass to layout child views vertically, from top to bottom.
A View that combines a TextField, Button and List to allow selection of list items in the space of a TextField
and/or button.
This class provides an interface to users.
An interface for a helper.
This is an interface to the console class to provide static convenience methods.
This class holds utilities to convert values.
This ParentShape subclass displays an axis box.
A View subclass to render.
A Segment representing a Cubic curve.
A class to represent a cursor.
A class to describe type of content in WebFile (from WebURL).
A simple date parser.
Some helper methods for Date.
A listener to get property changes and nested property changes.
This class is a real implementation of Console.
A view to allow inspection of View hierarchy.
A DevPane to show the console.
A TextView subclass with methods to act like a terminal/console.
A DevPane to show the console.
A DevPane tab for inspecting Graphics.
A DevPane tab for inspecting Graphics.
A DevPane tab for inspecting the view tree.
A DevPane tab for inspecting the view tree.
A class to run a dialog box.
A DialogBox subclass that shows as a sheet.
A data source implementation that draws from a directory WebFile.
A View to represent a movable separation between views.
A view to represent a traditional paper document.
A View that slides in/out of another view.
A Class to work with DropBox.
This WebSitePane subclass browses DropBox files.
A class to represent a visual effect that can be applied to drawing done in a Painter (like blur, shadow, etc.).
Class describes an ellipse that is defined by a framing rectangle.
An Effect subclass that make drawing look slightly 3D with raised or lowered edges.
Utility methods for Enums.
This class manages which node events are sent to which targets.
A class to help RootView dispatch events to Views.
An interface for objects to receive Node events.
This class provides a UI panel to inform users that an exception was hit and send info back to developer.
A demo to show explosions.
This Shape3D subclass represents a surface.
A class to hold basic information for a generic file.
A class to select a file to open or save.
Utility methods for file path strings.
This class is a WebSite implementation for local file system.
Utility methods for file.
This class represents a font for use in rich text.
This class represents all the information about a font that is independent of size.
Utilities for formatting numbers and dates.
A class to build a form.
This class represents a game character in a GameView.
The controller class for a GameView.
This class is the main view for games and manages GameActors.
This class provides functionality to find the best method for given arg classes.
An adapter class for drawing in a native environment (Java2D, JavaFX).
Graphics utilities.
A Paint subclass to represent a gradient.
A Builder class for GradientPaint.
A class to describe gradient paint stops.
A ViewHost to arrange child views in a grid.
Hit detection between Ray and Shape/VertexArray/Triangle.
A class to represent a horizontal position (LEFT, CENTER, RIGHT).
A class to represent an HTTP request and generate a response.
A class to hold headers.
A class to represent an HTTP response.
A WebSite for HTTP sources.
Represents an Image, such as JPEG, PNG, GIF, TIFF, BMP.
A class to manage an image rendered in a rectangular area.
A paint implementation to fill shapes with an image pattern.
A class provides a unique reference to an image for a given source (URL, bytes).
A class to manage a set of images.
Some Image utility methods.
A class to hold Image Info.
A View subclass for images.
This class represents a margin inset.
This class provides functionality to interpolate between two numbers given a ratio between 0-1.
An archiver to read/write objects from/to JSON.
An interface so objects can provide archival class to archiver.
An interface so objects can provide archival attributes to archiver.
An interface so objects can provide archival values to archiver.
An interface so objects can set archival values from archiver.
This JSValue subclass represents an array.
This JSValue subclass represents an object.
A JSONParser subclass (with handlers).
Array Handler.
Object Handler.
Pair Handler.
Value Handler.
Represents a node in a JSON tree.
Writes a JSON to string.
This class provides an optimized convenience for getting named values from arbitrary objects.
This is interface is implemented by objects that can get key values themselves.
This is interface is implemented by objects that can get/set key value themselves.
This class evaluates a string expression on a given object: KeyChain.getValue(object, expression).
A function handler.
This is interface is implemented by objects that can get key chain values themselves.
A Parser subclass to parse strings to KeyChains.
AdditiveExpr Handler: AdditiveExpr { MultiplicativeExpr (("+" | "-") MultiplicativeExpr)* }
ArgList Handler: ArgList { Expression ("," Expression)* }
BinaryExpr Handler.
ComparativeExpr Handler: ComparativeExpr { AdditiveExpr ((">" | "<" | ">=" | "<=") AdditiveExpr)* }
EqualityExpr Handler: EqualityExpr { ComparativeExpr (("==" | "!=") ComparativeExpr)* }
Expression Handler: Expression { LogicalOrExpr (LookAhead(2) "?" Expression (LookAhead(2) ":" Expression)?)? }
KeyChain Handler: KeyChain { Object ("." Object)* }
LogicalAndExpr Handler: LogicalAndExpr { EqualityExpr ("&&" EqualityExpr)* }
LogicalOrExpr Handler: LogicalOrExpr { LogicalAndExpr ("||" LogicalAndExpr)* }
MultiplicativeExpr Handler: MultiplicativeExpr { UnaryExpr (("*" | "/" | "%") UnaryExpr)* }
Object Handler: LookAhead(3) KEY "(" ArgList? ")" | LookAhead(2) KEY "[" Expression "]" | LookAhead(3) KEY | INT |
FLOAT | STRING | "(" Expression ")"
Statement Handler: Statement { LookAhead(2) KEY ("=" | "+=") Expression | Expression }
UnaryExpr Handler: UnaryExpr { "-" KeyChain | "!" KeyChain | KeyChain }
A class to facilitate working with keyboard key codes.
A class to model specific key strokes, including the key code and modifiers (shift, alt, etc.).
A class to display simple text with associcated image(s).
This class represents a light in a scene.
A class to represent a mathematical line.
This class represents a 3D line.
A View subclass to draw a line.
A View to show a list of items and act as basis of ListView.
A label subclass used to render items in Lists, Tables, Trees, Browsers.
Represents a selection for a List.
Represents a selection for a table.
Utility methods for use with Java.util.List.
A View to manage a list of items (ListArea) in a ScrollView.
An interface to identify classes that have external resources that may not be immediately available.
A class to load a list of loadables.
A class to store a list of loadables.
Utility methods for use with Java.util.Map.
Utility methods for common math operations.
This class represents a 3D transform.
A MenuItem subclass to show child menu items.
A View to display menus in a menu bar.
Button subclass to show a menu when clicked.
A ButtonBaseNode for MenuItem.
A class to help work with MIME type strings.
A class to rotate/zoom camera for mouse events.
A class to format tick labels.
This class manages an array of object values.
A View subclass to represent a DocView page.
A class to represent a fill for a Shape or text (Color, GradientPaint, ImagePaint).
A base class for painting Shapes, Text and Images.
A class that provide extra painter properties.
This class renders 2D painting on a 3D plane.
A Painter subclass that records painting operations for later execution instead of executing them immediately.
An instruction to clip().
An instruction to drawImage(Image,Transform).
An instruction to drawImage(Image,Transform).
An instruction to draw(Shape).
An instruction to drawString(str,x,y,cs).
An instruction to fill(Shape).
A class to represent instructions.
An instruction to restore().
An instruction to save().
An instruction to setFont().
An instruction to setOpacity().
An instruction to setPaint().
An instruction to setStroke().
An instruction to setTransform().
An instruction to strokeString(str,x,y,cs).
An instruction to transform().
A basic implementation of a painter.
The graphics state.
A Painter subclass that forward on to another.
This Shape3D subclass holds child shapes.
A View subclass for views with children.
A ViewProxy that can layout content in the manner of BoxView for any View.
A class to parse a URL string and provide the parts.
A class for working with parameter strings as found in a URL query part or fragment id, typically with the format:
field1=value1&field2=value2
An exception subclass for parser.
A class called when child rules are parsed.
A parse node.
A class to parse a given input (string) using given rule(s).
A class to pass Handler by reference, allowing it to be created lazily, but used higher up in stack.
A class to represent a parse rule.
A Parser to parse simple snap grammar rule files.
AndExpr Handler: { CountExpr CountExpr* }
CountExpr Handler: { Expression ( "*" "+" "?" )? }
Expression Handler: { String | "LookAhead" "(" (Number | OrExpr) ")" | Name | "(" OrExpr ")" }
OrExpr Handler: { AndExpr ( "|" AndExpr )* }
ParseRuleFile Handler: { ParseRule* }
ParseRule Handler: { Name "{" OrExpr "}" }
Represents an individual 'word' from parsed text.
A Builder.
A basic implementation of a Token.
Reads/Writes ParseRules from/to file.
A standard path shape that can be built/modified by standard moveTo/lineTo/curveTo methods.
Utility methods for Path2D.
This extended Path2D provides extra features like ArcLength measurement.
This class represents a path in 3D space.
A Shape3D subclass that represents a path extruded to a box.
Bezier curve fitting code adapted from
"An Algorithm for Automatically Fitting Digitized Curves", by Philip J.
A class to iterate over segments in a shape, providing specific coordinate information.
A class to show a path shape.
A list implementation that includes support for a selection and a synchronized sorted list.
A class to represent a simple geometric point.
This class represents a 3D point.
This class represents an array of points assumed to form a polygon, quads or triangles.
This class represents an array of indexes into a PointArray assumed to form a polygon, quads or triangles.
A Shape subclass to represent a simple geometric polygon.
This class represents a polygon surface in 3D space.
PathIter for PointArray.
This Shape subclass represents one or more polygons.
This Shape subclass represents one or more polygons.
A ListView subclass that displays in a PopupWindow.
A WindowView subclass for popup windows.
A class to represent a position on both horizonal and vertical axis (e.g.
A platform implementation of preferences.
A class to handle printing.
An interface for an graphical object that wants to print.
A control to show progress.
This class represents a property.
This class primarily converts a PropObject (graph) to/from a PropNode (graph).
This inner class represents a named resource associated with an archiver.
This class helps PropArchiver archive some common SnapKit classes.
A PropArchiver subclass specifically to convert to/from JSON.
A PropArchiver subclass specifically to convert to/from XML.
A class to describe object property changes.
An interface for objects that can do a PropChange.
An interface to respond to PropChange objects.
A PropChangeListener that removes itself when fired.
A class to easily add propery change support to a class (and DeepChange support).
A class to represent a PropObject and its property values as both native and String values.
This utility class converts PropNode to/from JSObject.
This utility class converts PropNode to/from XMLElement.
A base class for anything that wants to work with props.
This class is meant to stand in for archival objects that aren't PropObject.
This class holds a list of props for a PropObject class.
This class holds utility methods for Props.
A Segment representing a Quadratic curve.
Utility methods to create basic 3D quickly.
This class supports convenient drawing methods for quick and convenient vector graphics drawing.
This class supports convenient drawing methods for quick and convenient vector graphics drawing.
A path subclass to hold color and width.
A ToggleButton subclass for RadioButton.
A class to represent start and end values.
A class to manage UI for recent files (can show a panel or a menu).
This WebSite manages recent files.
This WebSitePane subclass displays files for RecentFilesSite.
Represents a rectangle - a Quadrilateral with parallel sides.
A Shape subclass to form the base class for generic rectangular shapes (Rect, Oval, Arc).
A View subclass for rects.
An Effect subclass to render a reflection.
A class for building regular expressions like a string buffer.
A class for building regular expressions like a string buffer.
This is an abstract class to renders a Scene3D for a Camera.
This Renderer subclass tries to render the Scene using the standard Painter (2D).
A default implementation.
Used to create new renderers.
An exception wrapped around a failed response.
The top level View in a window.
A Shape subclass to represent a rounded rectangle.
A View subclass to layout child views horizontally, from left to right.
A ViewProxy subclass to layout child views horizontally, from left to right.
A BoxView subclass that scales the content instead of resize.
A ViewProxy that can layout content in the manner of ScaleBox for any View.
A class to display and process System IN/OUT/ERR.
An InputStream that lets you add bytes on the fly.
A ConsoleView subclass that works with scanner.
This class is the root ParentShape of all scene shapes.
A ScrollBar for ScrollView.
A class that can scroll a child view.
A view that encapsulates multiple scroll views (center, top, left) and keeps them in sync to provide scroll headers.
A View for scrolling other views.
A class to represent hit information for Segment intersections.
A Segment is a Shape subclass that represents a part of a path: line, quadratic, cubic.
A Shape containing a list of Segment shapes (Line, Quad, Cubic) to facilitate complex shape operations like
constructive area geometry (CAG) operations (add, subtract, intersect paths).
This class provides SegmentPath utility methods to do Constructive Area Geometry (CAG) operations,
like add, subtract, intersect shapes.
An interface for views that are selectable.
This class provides a RM shape/inspector for editing JSeparator.
An Effect subclass to represent a drop shadow.
A class to represent a generic geometric shape (Line, Rect, Ellipse, etc.).
This class represents a 3D shape to be rendered in a G3DView.
A Shape implementation to present another shape in a given rect.
This shape subclass provides basic methods for constructing a shape.
A View subclass to render shapes.
This class represents a user action.
An enum to represent a side of rectanglular area: Left, right, top, bottom.
An enum to represent a side of rectanglular area: Left, right, top, bottom.
This class describes the corners of a standard cube.
This class describes the edges of the standard cube.
A class to represent a simple geometric size.
A Slider control.
This class provides general utility methods.
This class provides a basic description for comparison and sorting with a simple key and order (ascending or
descending).
A class to manage the loading and playing of a sound.
This class provides generic spell check API to allow support for any spell check technology.
An inner class to represent a misspelled word.
This class uses the SpellCheck class to check spelling.
A control to show a text value with convenient up/down buttons.
This is a shape that wraps around another shape and can provide parts.
A View subclass to show children with user adjustable divider.
A View subclass that lays out children using auto sizing settings.
A class to hold info for a spring child.
A ChildView subclass to show overlapping children.
This class manages a string and a bounding rect.
A class to convert common types to/from Strings.
An interface for classes that know how to code/decode themselves.
This class is a collection of convenient static String utils.
A view subclass to display a text string in a single style.
A class to describe strokes.
This class builds strokes.
This class holds a String and TextStyle and provides painting and sizing information.
A pane to show a specific child pane from a list.
A class to represent a TabView tab.
A builder class.
This class manages and displays a list of tabs.
Represents a Table Column.
A View subclass to show a table of items.
A View subclass to show multiple children under user selectable tabs.
Interface for tracking the progress of arbitrary tasks.
A TaskMonitor implementation that shows task updates in a panel after a short delay.
A class for running operations in the background.
A view subclass for displaying and editing a TextBlock.
This class is a helper for JavaTextArea to handle key processing.
This class provides utility methods for TextArea.
This class is the basic text storage class, holding a list of TextLine.
Utility methods to support TextBlock.
A property change event for addChars/removeChars.
A property change event for TextBlock.Style change.
A property change event for TextBlock.Style change.
This TextBlock subclass adds support for text wrapping and syncs to a source TextBlock.
This class is the basic text storage class, holding a list of TextLine.
This class provides the event and drawing code necessary to edit text in a TextDoc.
An view subclass for editing a single line of text.
An interface for text formating.
Module to load and process an OpenOffice.org-style hyphenation dictionary.
This class represents a line of text in a Text.
A class to represent a line of text (for each newline) in RichText.
A class to represent a hyperlink in a RichText TextStyle.
A class to hold the font metrics for text.
A panel for editing text files.
This is class represents a range of characters in a TextLine that share the same style.
This class iterates over TextBlock TextRuns.
A class to represent a selection of text.
A class to hold style attributes for a text run.
This class represents a 'word' in a TextLine.
This class represents an image texture.
This view subclass wraps a TextArea in a ScrollView.
This class has the behavior of a slider, without boundaries (so you can set values beyond the visible min and max).
A view to attach a title to another view.
A ButtonBase subclass for ToggleButton.
A class to manage a single selection for a group of objects that can each be selected.
This class holds TokenLines.
A class to extract tokens from a char sequence.
This class represents a line
This class implements the trackball widget.
A class to represent a mathematical linear transforms.
A panel that lets you set a view and have the old one transition out.
A class to perform transitions.
A ListArea subclass that represents a column in TreeView.
An interface for providing tree item information.
An Adapter class.
A View subclass to show a list of hierarchical items.
Undoer - this object manages undo by keeping lists of property changes.
An interface for undo/redo selection.
This class represents a single undo but holds a list of PropChanges.
Utilities for URL.
This class represents a vector.
This class represents a 3D vector.
This class manages raw vertex data (points, colors, normals, texture coords).
This Shape3D subclass just wraps around a VertexArray.
Utility methods for VertexArray.
A standard view implementation to show graphics and handle events and form the basis of all views (buttons, sliders,
text fields, etc.).
A class to animate View attributes.
Utility methods for ViewAnim.
This class handles Snap View archival.
A class to facilitate building views quickly.
An interface for platform specific UI functionality.
Represents node UI events sent to a Views for input events.
Types for events.
An interface for Views primarily intended to hold other (arbitrary) views.
A class to manage a list of views.
A base controller class that manages a UI View (usually loaded from a snp UI file).
A class to represents physical attributes of a view for the purpose of physics simulation.
This class represents a view for the purpose of layout.
A class to provide view area classes to define UI look.
A Timer to fire on node event thread.
A class to update view painting, layout and animation and ViewOwner resets.
An interface to listen to ViewUpdater events.
Utility methods for nodes.
A class to represent a vertical position (TOP, CENTER, BOTTOM).
Represents a file from a WebSite.
An interface for classes that want to post modifications to files.
A class to handle loading of URL items.
A request to a server.
The response.
This is an abstract class to provide data management (create, get, put, delete) and file management.
This class is the base class for WebSite open/save browsers.
A class to select a file to open or save.
This WebSite subclass implements some conveniences.
A class to represent a URL for a WebSite and WebFile (it can be both for nested sources).
Utility methods for Web classes.
A class to manage a Window.
A class to map snap Window functionality to native platform.
A parent view to correctly layout a content view even if rotated and/or scaled.
This class manages archival and unarchival to/from XMLElements.
An interface for objects that are archivable.
This inner class represents a named resource associated with an archiver.
This class represents an XML attribute by simply having a name and value.
The class represents an XML element and simply manages a list of XML attributes and a list XML elements (recursively).
A class to load an XMLElement from aSource.
Attribute Handler: Attribute { Name "=" String }
Document Handler: Document { Prolog? DocType? Element }
Element Handler: Element { "<" Name Attribute* ("/>" | (">" Content "</" Name ">")) }
Prolog Handler: Prolog { "<?xml" Attribute* "?>" }
A Tokenizer subclass to read XML contents.
A WebSite subclass for Zip and Jar files.