Uses of Interface
VASSAL.script.expression.Auditable

Packages that use Auditable

Package	Description
VASSAL.build	Provides classes for building Java instances automatically from XML files.
VASSAL.build.module	Contains classes that may be added to a GameModule.
VASSAL.build.module.chessclockcontrol
VASSAL.build.module.dice
VASSAL.build.module.documentation	Contains classes that may be added to a Documentation.
VASSAL.build.module.folder
VASSAL.build.module.gamepieceimage
VASSAL.build.module.map	Contains classes that may be added to a Map.
VASSAL.build.module.map.boardPicker	Contains classes that may be added to a BoardPicker.
VASSAL.build.module.map.boardPicker.board	Contains classes that may be added to a Board.
VASSAL.build.module.map.boardPicker.board.mapgrid	Contains classes that may be added to a MapGrid.
VASSAL.build.module.map.deck
VASSAL.build.module.properties
VASSAL.build.module.turn
VASSAL.build.widget	Contains classes that can be added to a Widget.
VASSAL.chat.ui
VASSAL.configure	Provides classes for building "Edit Property" dialogs, and for editing GameModule's and ModuleExtension's.
VASSAL.counters	Provides classes that define game pieces.
VASSAL.i18n
VASSAL.launch
VASSAL.preferences	Provides support for specifying and saving preferences.
VASSAL.script
VASSAL.script.expression
VASSAL.tools	Contains various utility classes.
VASSAL.tools.icon

Uses of Auditable in VASSAL.build

Classes in VASSAL.build that implement Auditable

Modifier and Type	Class	Description
class	AbstractBuildable	Abstract implementation of the Buildable interface.
class	AbstractConfigurable	An abstract implementation of the Configurable interface.
class	AbstractFolder	Abstract class for a Folder component that can contain/organize a particular type of configurable(s).
class	AbstractToolbarItem	Creates an item that is both configurable w/ an edit box AbstractConfigurable and buildable from the XML buildFile AbstractBuildable, but which also has a Toolbar launch button.
class	GameModule	The GameModule class is the base class for a VASSAL module.
class	Widget	A general-purpose configurable GUI container Widgets are Configurable objects that represent AWT components.

Constructors in VASSAL.build with parameters of type Auditable

Modifier	Constructor	Description
	BadDataReport(String message, String data, Throwable cause, Auditable owner, AuditTrail auditTrail)	BadDataReport for a general exception raised during Expression Execution with supplied audit info

Uses of Auditable in VASSAL.build.module

Classes in VASSAL.build.module that implement Auditable

Modifier and Type	Class	Description
class	ChartWindow	A top-level Widget for displaying Charts
class	ChessClockControl	CHESS CLOCK CONTROLLER for VASSAL.
class	ConnectionWindow	This is now a dummy class
class	DiceButton	This component places a button into the controls window toolbar.
class	DieManager
class	DoActionButton	This component places a button into the controls window toolbar.
class	Documentation	Represents the Help menu of the controls window
class	EventLog
class	GlobalKeyCommand	This version of MassKeyCommand is added directly to a GameModule and applies to all maps.
class	GlobalOptions	GlobalOptions is a junction point for several flavors of "preferences"-related categories.
class	InternetDiceButton	This component places a button into the controls window toolbar.
class	Inventory
class	Inventory.Counter	Holds static information of and a reference to a gamepiece.
class	Map	The Map is the main component for displaying and containing GamePieces during play.
class	ModuleExtension	An optional extension to a GameModule Like a GameModule, it is built from scratch from a 'buildFile' in a DataArchive The components described in the buildFile are appended to components in the base DataArchive
class	ModulePlugin	A ModulePlugin is basically identical to a ModuleExtension except that is loaded earlier and must throw Plugin specific error messages
class	MultiActionButton	Combines multiple buttons from the toolbar into a single button.
class	NotesWindow	This is a GameComponent that allows players to type and save text notes during a game.
class	PieceWindow	A window from which players can create new GamePieces by clicking and dragging from the PieceWindow.
class	PlayerHand
class	PlayerRoster	Maintains a list of players involved in the current game
class	Plugin	Plugin is a general purpose component for use by Module Plugins that require some sort of initialisation.
class	PredefinedSetup	Defines a saved game that is accessible from the File menu.
class	PrivateMap	A Map that may be configured to be visible only a particular side.
class	PrototypeDefinition
class	PrototypesContainer	Container for definitions of Game Piece prototypes.
class	RandomTextButton
class	SpecialDiceButton	...
class	SpecialDie
class	SpecialDieFace
class	StartupGlobalKeyCommand	A Global Key Command that is automatically invoked on game start-up, once the various Key Listeners have been started.
class	ToolbarMenu	Takes buttons from the toolbar of a Map or the main module and places them into a popup menu

Uses of Auditable in VASSAL.build.module.chessclockcontrol

Classes in VASSAL.build.module.chessclockcontrol that implement Auditable

Modifier and Type	Class	Description
class	ChessClock	CHESS CLOCK class for VASSAL.

Uses of Auditable in VASSAL.build.module.dice

Classes in VASSAL.build.module.dice that implement Auditable

Modifier and Type	Class	Description
class	BonesDiceServer
class	DieServer	Base DieServer Class Does most of the work.
class	ShadowDiceDieServer	ShadowDice Dice Server

Uses of Auditable in VASSAL.build.module.documentation

Classes in VASSAL.build.module.documentation that implement Auditable

Modifier and Type	Class	Description
class	AboutScreen	Places an entry in the Help menu.
class	BrowserHelpFile	Unpacks a zipped directory stored in the module and displays it in an external browser window.
class	BrowserPDFFile	Easier-to-use support for opening a single PDF file in the browser (it can be done with BrowserHelpFile, but requires a substantial workaround and weird confusing procedures)
class	HelpFile	Places an entry in the Help menu.
class	Tutorial	Provides tutorial functionality by reading in a logfile

Uses of Auditable in VASSAL.build.module.folder

Classes in VASSAL.build.module.folder that implement Auditable

Modifier and Type	Class	Description
class	DeckSubFolder
class	GlobalPropertyFolder
class	MapSubFolder
class	ModuleSubFolder
class	PrototypeFolder

Uses of Auditable in VASSAL.build.module.gamepieceimage

Classes in VASSAL.build.module.gamepieceimage that implement Auditable

Modifier and Type	Class	Description
class	ColorManager	Container for definitions of Generic Color Definitions
class	ColorSwatch	Class that implements a named Color Swatch
class	FontManager	Container for definitions of Generic Color Definitions
class	FontStyle	Class that implements a names Font Swatch
class	GamePieceImage
class	GamePieceImageDefinitions	Container for definitions of Generic Counter Definitions.
class	GamePieceLayout
class	GamePieceLayoutsContainer	Container for definitions of Generic Counter Definitions.
class	ImageItem
class	ImageItemInstance
class	Item	The base portion of a Counter Layout component.
class	ItemInstance	Individual override parameters for an instance of an Item.
class	ShapeItem
class	ShapeItemInstance
class	SymbolItem
class	SymbolItemInstance
class	TextBoxItem
class	TextBoxItemInstance
class	TextItem
class	TextItemInstance

Uses of Auditable in VASSAL.build.module.map

Classes in VASSAL.build.module.map that implement Auditable

Modifier and Type	Class	Description
class	BoardPicker	This class is responsible for maintaining the Boards on a Map.
class	CounterDetailViewer	This is a Drawable class that draws the counters horizontally when the mouse is held over a stack with the control key down.
class	DeckGlobalKeyCommand	This version of MassKeyCommand is added to a DrawPile (which holds a Deck) and applies to pieces/cards currently in the deck.
static class	DeckGlobalKeyCommand.DeckGlobalCommand
static class	DeckGlobalKeyCommand.DeckPolicyConfig2
class	DrawPile
class	Flare	Allows a player to ping a location ("send up a flare") by clicking on a map with the correct modifier key combination held down (default: Alt+LeftClick).
protected class	GlobalMap.CounterViewer
class	HandMetrics	Handles the drawing of cards in a PlayerHand.
class	HighlightLastMoved
class	ImageSaver	This allows the user to capture a snapshot of the entire map into a PNG file.
class	LayerControl	Adds a button to the toolbar to manipulate Game Piece Layers
class	LayeredPieceCollection	The optional "Game Piece Layers" component of a Map which allows pieces on the map to be assigned to an arbitrary number of visual layers according to a property setting.
class	LOS_Thread	A class that allows the user to draw a straight line on a Map (LOS = Line Of Sight).
class	MapCenterer	Centers the map when user right-clicks on an empty hex
class	MapShader	Draw shaded regions on a map.
class	MassKeyCommand	Adds a button to a map window toolbar.
static class	MassKeyCommand.DeckPolicyConfig
class	MoveCameraButton	Adds a button to a Maps toolbar that moves the view/camera to a specific point
class	PieceMover	PieceMover handles the "Drag and Drop" of pieces and stacks, onto or within a Map window.
class	PieceRecenterer	Adds a button to a Maps toolbar that adjusts the positions of all pieces so that their centroid is at the center of the map
class	Scroller	This component listens to key events on a Map window and scrolls the map.
class	SelectionHighlighter
class	SelectionHighlighters
class	SetupStack	This is the "At-Start Stack" component, which initializes a Map or Board with a specified stack.
class	StackMetrics	StackMetrics provides the [Stacking options] component of a Map.
class	TextSaver
class	Zoomer	Controls the zooming in/out of a Map window.

Uses of Auditable in VASSAL.build.module.map.boardPicker

Classes in VASSAL.build.module.map.boardPicker that implement Auditable

Modifier and Type	Class	Description
class	Board

Uses of Auditable in VASSAL.build.module.map.boardPicker.board

Classes in VASSAL.build.module.map.boardPicker.board that implement Auditable

Modifier and Type	Class	Description
class	HexGrid	A Hexgrid is a map grid composed of hexes.
class	Region
class	RegionGrid
class	SquareGrid
class	ZonedGrid	Map Grid that contains any number of Zones against a background MapGrid

Uses of Auditable in VASSAL.build.module.map.boardPicker.board.mapgrid

Classes in VASSAL.build.module.map.boardPicker.board.mapgrid that implement Auditable

Modifier and Type	Class	Description
class	HexGridNumbering
class	RegularGridNumbering	Abstract base class for grid numbering classes for hexagonal and rectangular grids
class	SquareGridNumbering
class	Zone
class	ZonedGridHighlighter
class	ZoneHighlight	A Class that defines a method of highlighting the a zone in a multi-zoned grid.

Uses of Auditable in VASSAL.build.module.map.deck

Classes in VASSAL.build.module.map.deck that implement Auditable

Modifier and Type	Class	Description
class	AbstractDeckKeyCommand	Base class for additional Menu items (with Hotkeys) that can be added to a DrawPile/Deck
class	DeckSendKeyCommand
class	DeckSortKeyCommand

Uses of Auditable in VASSAL.build.module.properties

Subinterfaces of Auditable in VASSAL.build.module.properties

Modifier and Type	Interface	Description
static interface	IncrementProperty.Constraints
static interface	PropertyChangerConfigurer.Constraints
interface	PropertySource	A PropertySource provides an interface to read properties (values), usually game- or UI-related, from various game objects.

Classes in VASSAL.build.module.properties that implement Auditable

Modifier and Type	Class	Description
class	AbstractScenarioProperty
class	BooleanScenarioProperty
class	ChangePropertyButton	Adds a toolbar button that changes the value of a global property
class	GlobalProperties	Dummy component that acts as a simple container for GlobalProperty components
class	GlobalProperty	Adds a global property to a Map or Module
class	GlobalTranslatableMessage	Adds a global property to a Map or Module
class	GlobalTranslatableMessages	Dummy component that acts as a simple container for GlobalProperty components
class	ListScenarioProperty
class	NumberScenarioProperty
class	ScenarioPropertiesOptionTab
class	StringScenarioProperty
class	SumProperties	For property names of the form sum(name), returns the value of the named property summed over a list of pieces.
class	ZoneProperty

Methods in VASSAL.build.module.properties with parameters of type Auditable

Modifier and Type	Method	Description
String	RemoteEnumeratedPropertyPrompt.getNewValue(DynamicProperty target, Auditable owner, PropertySource ps)
String	RemoteIncrementProperty.getNewValue(DynamicProperty target, Auditable owner, PropertySource ps)
String	RemotePropertyChanger.getNewValue(DynamicProperty target, Auditable owner, PropertySource ps)
String	RemotePropertyPrompt.getNewValue(DynamicProperty target, Auditable owner, PropertySource ps)
String	RemotePropertySetter.getNewValue(DynamicProperty remoteDP, Auditable owner, PropertySource ps)	Evaluate any expression using the remote piece as the source of properties Pre-evaluate any $$ variables in the local piece.

Uses of Auditable in VASSAL.build.module.turn

Classes in VASSAL.build.module.turn that implement Auditable

Modifier and Type	Class	Description
class	CounterTurnLevel
class	ListTurnLevel
class	TurnComponent	Generic Turn Component
class	TurnGlobalHotkey
class	TurnLevel
class	TurnTracker	Generic Turn Counter

Uses of Auditable in VASSAL.build.widget

Classes in VASSAL.build.widget that implement Auditable

Modifier and Type	Class	Description
class	BoxWidget	A Widget that corresponds to a panel with a JComboBox above a JPanel with a CardLayout layout.
class	CardSlot	A CardSlot is identical to a PieceSlot except that it is initialized with a card-like GamePiece.
class	Chart	A Chart is used for displaying charts and tables for the module.
class	HtmlChart	An HtmlChart is used for displaying html information for the module.
class	ListWidget	A Widget that corresponds to a panel with a JList sitting to the right of a JPanel with a CardLayout layout.
class	MapWidget
class	PanelWidget	A Widget that corresponds to a JPanel with a GridLayout or BoxLayout layout.
class	PieceSlot	A Component that displays a GamePiece.
class	TabWidget	A Widget that corresponds to a JTabbedPane.
class	WidgetMap

Uses of Auditable in VASSAL.chat.ui

Classes in VASSAL.chat.ui that implement Auditable

Modifier and Type	Class	Description
class	ChatServerControls

Uses of Auditable in VASSAL.configure

Methods in VASSAL.configure with parameters of type Auditable

Modifier and Type	Method	Description
boolean	PropertyExpression.accept(PropertySource source, GamePiece piece, Auditable owner, AuditTrail trail)
boolean	PropertyExpression.accept(GamePiece source, GamePiece piece, Auditable owner, AuditTrail trail)
boolean	PropertyExpression.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	PropertyExpression.accept(GamePiece piece, Auditable owner, AuditTrail audit)
PieceFilter	PropertyExpression.getFilter(PropertySource source, Auditable owner, String fieldKey)
PieceFilter	PropertyExpression.getFilter(PropertySource source, Auditable owner, AuditTrail audit)
boolean	PropertyExpression.isTrue(PropertySource ps, Auditable owner, AuditTrail audit)

Uses of Auditable in VASSAL.counters

Subinterfaces of Auditable in VASSAL.counters

Modifier and Type	Interface	Description
interface	EditablePiece	If class implementing GamePiece also implements the EditablePiece interface, then it can be manipulated from the Editor's Configuration Tree via the PieceDefiner dialog.
interface	GamePiece	Interface to deal with the behaviors of a physical component of the game, or a Trait of one.
interface	PropertyExporter	Interface for classes that can export the names and values of the properties they maintain

Classes in VASSAL.counters that implement Auditable

Modifier and Type	Class	Description
class	ActionButton	A Trait (aka Decorator that acts like a button on a GamePiece, such that clicking on a particular area of the piece invokes a key command
class	AreaOfEffect
class	Attachment	Trait allowing creation of an "attachment" to one or more other pieces, which can then be sent GKCs very swiftly and whose properties can be easily read (and if a Dynamic Property can also be set with a Set Global Property trait)
class	BasicName	This trait overrides the $BasicName$ property provided by the "Basic Piece", allowing a module designer decking to define pieces entirely by prototype to safely ignore and leave empty the Basic Piece.
class	BasicPiece	Basic class for representing a physical component of the game.
class	BorderOutline	Trait to draw a colored border around a piece
class	CalculatedProperty	Conditional Marker A marker with a variable value depending on conditions.
class	Clone	This trait adds a command that creates a duplicate of the selected Gamepiece
class	Comment	A trait that exists in a Piece Definition, but is not included when the piece is created in a real game.
class	CounterGlobalKeyCommand	Trait that sends a Key Command to other pieces, selected with various filters.
class	Deck	A collection of pieces that behaves like a deck, i.e.: Doesn't move.
class	Decorator	The abstract class describing a generic 'Trait' of a full GamePiece.
class	Delete	This trait adds a command that creates a duplicate of the selected Gamepiece
class	Deselect	Implements a trait to allow a piece to be deselected from the KeyBuffer in response to a Key Command.
class	DynamicProperty	Trait that contains a property accessible via getProperty() and updatable dynamically via key commands
class	Embellishment	d/b/a "Layer" The "Layer" trait.
class	Embellishment0	Embellishment has been extensively re-written for Vassal 3.2 changing both the behavior and the visual look of the configurer.
class	Footprint	Displays a movement trail indicating where a piece has been moved
class	FreeRotator	d/b/a "Can Rotate" A Decorator that rotates a GamePiece to an arbitrary angle
class	GlobalAttach	Variant on GlobalCommand for use with Attachment -- instead of sending a key, finds pieces and attaches them
class	GlobalCommand	The heart of all the different forms of Global Key Command, GlobalCommand handles sending a key command to multiple pieces, potentially on multiple maps, as long as they match its filtering condition.
class	GlobalDetach	Variant on GlobalCommand for use with Attachment -- instead of sending a key, finds pieces and *detaches* them
class	GlobalHotKey	Adds a menu entry that fires a specified key event to the module window.
class	GlobalSetter	Variant on GlobalCommand for use with SetPieceProperty -- instead of sending a key, finds pieces and sets their properties
class	Hideable
class	Immobilized	d/b/a "Does Not Stack" Decorator that filters events to prevent a GamePiece from being selected and/or moved.
class	Labeler	d/b/a "Text Label" Displays a text label, with content specified by the user at runtime.
class	Marker	A generic Decorator that retains in its state the value of a property.
class	Mat	Designates the piece as a "Mat" on which other pieces ("Cargo") can be placed.
class	MatCargo	Designates the piece as "Cargo", which can be placed on a "Mat" to move along with it
class	MenuSeparator	This trait puts a menu separator bar in the context menu for the piece
class	MovementMarkable	d/b/a "Mark When Moved" A GamePiece with this trait will automatically be marked whenever it is moved.
class	MultiLocationCommand	Allows a single trait to generate multiple context menu commands, using a set of filtered map locations.
class	NonRectangular	A trait for assigning an arbitrary shape to a GamePiece
class	Obscurable	d/b/a "Mask" Trait that lets some traits of a piece be hidden "from some players, some of the time".
class	Pivot	d/b/a "Can Pivot" Provides commands to pivot a Game Piece around a given point
class	PlaceMarker	This Decorator defines a key command to places another counter on top of this one.
class	PlaySound	A trait that plays a sound clip
class	PropertySheet	A Decorator class that endows a GamePiece with a dialog.
class	Replace	GamePiece trait that replaces a GamePiece with another one
class	ReportState	d/b/a "Report Action" A GamePiece with this trait will echo the piece's current name when any of a given key commands are pressed (and after they take effect)
static class	ReportState.OldAndNewPieceProperties	Looks in both the new and old piece for property values.
class	RestrictCommands	RestrictCommands Restrict the availability of Key Commands, depending on a Property Match String
class	Restricted	d/b/a "Restricted Access" A GamePiece with the Restricted trait can only be manipulated by the player playing a specific side
class	ReturnToDeck	GamePiece trait that returns a piece to a DrawPile
class	SendToLocation	This trait adds a command that sends a piece to another location.
class	SetGlobalProperty
class	SetPieceProperty
class	Stack	A Stack is a collection of pieces in the same location that can often be moved with a single drag-and-drop.
class	SubMenu	A trait that groups menu items of other traits into a sub-menu
class	TableInfo	d/b/a "Spreadsheet" A Decorator class that endows a GamePiece with an editable spreadsheet (i.e.
class	TranslatableMessage	A trait to expose a translated string as a readable/displayable property.
class	Translate	d/b/a "Move Fixed Distance" Give a piece a command that moves it a fixed amount in a particular direction, optionally tracking the current rotation of the piece.
class	TriggerAction	Macro Execute a series of Keystrokes against this same piece - Triggered by own KeyCommand or list of keystrokes - Match against an optional Property Filter
class	UsePrototype	d/b/a "Prototype" This trait is a placeholder for a pre-defined series of traits specified in a PrototypeDefinition object.

Methods in VASSAL.counters with parameters of type Auditable

Modifier and Type	Method	Description
boolean	BooleanAndPieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BooleanAndPieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)
boolean	BooleanOrPieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BooleanOrPieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)
default boolean	PieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)	Test if a piece matches the filter and provide Expression auditing facilities
default boolean	PieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)	Test if a piece matches the filter and provide Expression auditing facilities
static SendToLocation.Destination	SendToLocation.getSendLocation(PropertySource source, Auditable auditSource, String destination, FormattedString mapId, FormattedString boardName, FormattedString zone, FormattedString region, FormattedString gridLocation, FormattedString x, FormattedString y, PropertyExpression propertyFilter, Map sourceMap, Point startPosition)	Compute a destination from the parameters
GlobalCommandVisitor	GlobalAttach.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
protected GlobalCommandVisitor	GlobalCommand.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
GlobalCommandVisitor	GlobalDetach.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
GlobalCommandVisitor	GlobalSetter.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
static Command	Decorator.setDynamicProperties(List<Parameter> parameters, GamePiece piece, PropertySource source, Auditable owner)	Find and set a series of Dynamic Properties in the supplied GamePiece named propertyName and generate a Command to set it to the specified values in other clients
static Command	Decorator.setDynamicProperties(List<Parameter> parameters, GamePiece piece, PropertySource source, Auditable owner, AuditTrail auditSoFar)
static Command	Decorator.setDynamicProperty(String propertyName, String value, GamePiece piece, PropertySource source, Auditable owner, AuditTrail audit)	Find a Dynamic Property in the supplied GamePiece named propertyName and generate a Command to set it to the specified value
void	GlobalCommandVisitor.setOwner(Auditable val)

Constructors in VASSAL.counters with parameters of type Auditable

Modifier	Constructor	Description
	AttachVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	DetachVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck, GlobalCommand globalCommand)
	SetVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)

Uses of Auditable in VASSAL.i18n

Subinterfaces of Auditable in VASSAL.i18n

Modifier and Type	Interface	Description
interface	TranslatablePiece	Decorators that contain localizable elements must implement this interface

Classes in VASSAL.i18n that implement Auditable

Modifier and Type	Class	Description
class	Language	Container for definitions of Translations.
class	Localization	Singleton class for managing the translation of a module into other languages
class	TranslatableMarker
class	Translation
class	VassalTranslation	Utility class to allow translation of VASSAL using the Component Translation mechanism.

Uses of Auditable in VASSAL.launch

Classes in VASSAL.launch that implement Auditable

Modifier and Type	Class	Description
class	BasicModule	Deprecated, for removal: This API element is subject to removal in a future version.

Uses of Auditable in VASSAL.preferences

Classes in VASSAL.preferences that implement Auditable

Modifier and Type	Class	Description
class	BasicPreference	Base class for a Module Preference.
class	BooleanPreference	A Checkbox Module Preference.
class	DoublePreference	A Decimal Number Module Preference.
class	EnumPreference	A Drop-down list preference.
class	IntegerPreference	A whole number Module Preference.
class	StringPreference	A String Module Preference.
class	TextPreference	A multi-line textbox Module Preference.

Uses of Auditable in VASSAL.script

Classes in VASSAL.script that implement Auditable

Modifier and Type	Class	Description
class	AbstractScript
class	ActionScript
class	BshPlugin
class	ExpressionInterpreter	A BeanShell Interpreter customised to evaluate a single Vassal expression containing Vassal property references.
class	GeneralScript
class	ScriptContainer	Container for Scripts.

Fields in VASSAL.script declared as Auditable

Modifier and Type	Field	Description
protected Auditable	ExpressionInterpreter.currentOwner

Methods in VASSAL.script with parameters of type Auditable

Modifier and Type	Method	Description
String	ExpressionInterpreter.evaluate(PropertySource ps, boolean localized, Auditable owner, AuditTrail audit)
String	ExpressionInterpreter.evaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)

Uses of Auditable in VASSAL.script.expression

Fields in VASSAL.script.expression declared as Auditable

Modifier and Type	Field	Description
protected Auditable	AuditableException.owner

Methods in VASSAL.script.expression that return Auditable

Modifier and Type	Method	Description
Auditable	AuditableException.getOwner()

Methods in VASSAL.script.expression with parameters of type Auditable

Modifier and Type	Method	Description
boolean	BeanShellExpression.BshFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BeanShellExpression.BshFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)
static AuditTrail	AuditTrail.create(Auditable source)	Factory method to create a new AuditTrail only if auditing is enabled
static AuditTrail	AuditTrail.create(Auditable source, String originalExpression)	Factory method to create a new AuditTrail only if auditing is enabled
static AuditTrail	AuditTrail.create(Auditable source, String originalExpression, String comment)	Factory method to create a new AuditTrail only if auditing is enabled
static AuditTrail	AuditTrail.create(Auditable source, Expression originalExpression)	Factory method to create a new AuditTrail only if auditing is enabled
static AuditTrail	AuditTrail.create(Auditable source, Expression originalExpression, String comment)	Factory method to create a new AuditTrail only if auditing is enabled
static AuditTrail	AuditTrail.create(Auditable source, FormattedString originalExpression)
static AuditTrail	AuditTrail.create(Auditable source, FormattedString originalExpression, String comment)
String	BeanShellExpression.evaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)	Evaluate this expression using a BeanShell Interpreter
String	Expression.evaluate(PropertySource ps, boolean localized, Auditable owner, AuditTrail audit)
String	Expression.evaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)	Each subclass must implement evaluate() to evaluate itself The default implementation just returns the expression itself, which works correctly for simple Expression types like NullExpression and IntExpression.
String	Expression.evaluate(PropertySource ps, Auditable owner, AuditTrail audit)
String	Expression.evaluate(Auditable owner, AuditTrail audit)
String	FormattedStringExpression.evaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)
String	SinglePropertyExpression.evaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)
PieceFilter	BeanShellExpression.getFilter(PropertySource ps, Auditable owner, AuditTrail audit)
PieceFilter	Expression.getFilter(PropertySource ps, Auditable owner, AuditTrail audit)	Return a PieceFilter using the expression.
PieceFilter	Expression.getFilter(Auditable owner, AuditTrail audit)
PieceFilter	PropertyMatchExpression.getFilter(PropertySource ps, Auditable owner, AuditTrail audit)
String	Expression.quietEvaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)	A version of tryEvaluate the supresses error messages.
String	Expression.quietEvaluate(PropertySource ps, Auditable owner, String fieldKey)
void	AuditTrail.setSource(Auditable source)
String	Expression.tryEvaluate(boolean localized, Auditable owner, AuditTrail audit)	Evaluate an expression with data warning support built in
String	Expression.tryEvaluate(PropertySource ps, boolean localized, Auditable owner, AuditTrail audit)	Evaluate an expression with data warning support built in
String	Expression.tryEvaluate(PropertySource ps, Map<String,String> properties, boolean localized, Auditable owner, AuditTrail audit)	Core tryEvaluate implementation.
String	Expression.tryEvaluate(PropertySource ps, Auditable owner, String fieldKey)
String	Expression.tryEvaluate(PropertySource ps, Auditable owner, AuditTrail audit)	Evaluate an expression with data warning support built in
String	Expression.tryEvaluate(Auditable owner, AuditTrail audit)	Evaluate an expression with data warning support built in

Constructors in VASSAL.script.expression with parameters of type Auditable

Modifier	Constructor	Description
	AuditableException(Auditable owner, AuditTrail auditTrail)
	AuditTrail(Auditable source, String sourceField)
	AuditTrail(Auditable source, String originalExpression, String sourceField)	Create a new AuditTrail
	BshFilter(Auditable owner, AuditTrail auditTrail)
	ExpressionException(String s, String e, Auditable owner, AuditTrail auditTrail)

Uses of Auditable in VASSAL.tools

Subinterfaces of Auditable in VASSAL.tools

Modifier and Type	Interface	Description
static interface	RecursionLimiter.Loopable

Classes in VASSAL.tools that implement Auditable

Modifier and Type	Class	Description
class	DebugControls
class	FormattedString	FormattedString.java A String that can include options of the form $optionName$.
class	LaunchButton	A JButton for placing into a VASSAL component's toolbar.
class	PlayerIdFormattedString	Deprecated. use FormattedString constructor with defaultProperties

Methods in VASSAL.tools with parameters of type Auditable

Modifier and Type	Method	Description
String	FormattedString.getLocalizedText(PropertySource ps, Auditable owner, String fieldKey)	Evaulate a formatted String and return localized text Use the supplied property source to find property values Create an AuditTrail object if expression auditing enabled
String	FormattedString.getLocalizedText(PropertySource ps, Auditable owner, String fieldKey, boolean quietly)
String	FormattedString.getLocalizedText(PropertySource ps, Auditable owner, AuditTrail audit)	Evaulate a formatted String and return localized text Use the supplied property source to find property values
String	FormattedString.getLocalizedText(Auditable owner, String fieldKey)	Evaulate a formatted String and return localized text Use the default property source to find property values Create an AuditTrail object if expression auditing enabled
String	FormattedString.getText(PropertySource ps, boolean localized, Auditable owner, AuditTrail audit)	Evaluate the supplied Formmatted String, using the supplied property source to replace any property references.
String	FormattedString.getText(PropertySource ps, boolean localized, Auditable owner, AuditTrail audit, boolean quietly)	Core implementation of getText.
String	FormattedString.getText(PropertySource ps, String def, Auditable owner, String fieldKey)	Evaulate a formatted String and return unlocalized text Use the supplied property source to find property values If any property value is found to be null, use the supplied default value instead Create an AuditTrail object if expression auditing enabled
String	FormattedString.getText(PropertySource ps, String def, Auditable owner, AuditTrail audit)	Evaulate a formatted String and return unlocalized text Use the supplied property source to find property values If any property value is found to be null, use the supplied default value instead
String	FormattedString.getText(PropertySource ps, Auditable owner, String fieldKey)	Evaulate a formatted String and return unlocalized text Use the supplied property source to find property values Create an AuditTrail object if expression auditing enabled
String	FormattedString.getText(PropertySource ps, Auditable owner, String fieldKey, boolean quietly)	Evaluate a formatted String and return unlocalized text Use the supplied property source to find property values Create an AuditTrail object if expression auditing enabled
String	FormattedString.getText(PropertySource ps, Auditable owner, AuditTrail audit)	Evaulate a formatted String and return unlocalized text Use the supplied property source to find property values
String	FormattedString.getText(Auditable owner, String fieldKey)	Evaulate a formatted String and return unlocalized text Use the default property source to find property values Create an AuditTrail object if expression auditing enabled
int	FormattedString.getTextAsInt(PropertySource ps, String description, EditablePiece source, Auditable owner, AuditTrail audit)

Uses of Auditable in VASSAL.tools.icon

Classes in VASSAL.tools.icon that implement Auditable

Modifier and Type	Class	Description
class	IconFamily	An IconFamily is a named set of Icons in the four standard Tango sizes.