Class Survey
Since ATF is a very large framework, this survey concentrates on some of the more useful namespaces and classes.
Each section describes a namespace followed by some of its key classes. The class information given here is also available through Intellisense in Visual Studio when you hold the mouse over the class name in a source file.
Classes marked with an asterisk (*) are MEF components, as described in MEF with ATF. For more information on useful components, see Important ATF Components.
This namespace provides a variety of utilities and MEF components.
ActiveCollection<T>: Collection representing active items. Maintains an ActiveItem and enumerates items in least-recently-active order. Provides change notification and views filtered by item type. T is the Type of the item in the collection and must be a reference type.
*AtfUsageLogger: Sends usage information to an ATF logging server, including the full computer name, user name, and operating system info. The purpose of logging this information is to help the ATF team know who is using the ATF and on what kind of hardware.
ChartUtil: Chart helper class to draw grids, scales and coordinate axes.
CollectionAdapter<T, U>: This class wraps an ICollection of one type to implement ICollection of another type. The type Parameters are T the underlying list type and U the adapted list type.
*CrashLogger: A service to log unhandled exceptions (crashes) to a remote server. Note: If used with UnhandledExceptionService, put this first in the TypeCatalog because otherwise UnhandledExceptionService may prevent CrashLogger from receiving events, but CrashLogger does not prevent UnhandledExceptionService from receiving events.
CustomFileDialog: Base class for custom SaveFileDialog and OpenFileDialog.
CustomOpenFileDialog: This class behaves the same as the System.Windows.Forms.OpenFileDialog class, but allows a custom control to be added to the bottom of the dialog (via the UserControl property).
CustomSaveFileDialog: This class behaves the same as the System.Windows.Forms.SaveFileDialog class, but allows a custom control to be added to the bottom of the dialog (via the UserControl property).
DirectoryUtil: Directory utilities to enumerate files.
FileMoveService: Class that provides atomic file copy, move, and delete operations, that is, operations either complete successfully or the file system is rolled back to its initial state.
Gdi32: Gdi32 PInvoke wrappers.
GdiUtil: GDI+ utilities to perform drawing and related operations.
ItemsChangedEventArgs<T>: Class for notifying event subscribers when items are added, removed, or changed in some context or collection. T is the Item type.
LinqQueryPredicate: Base class for creating search query predicates using Linq expressions.
ListAdapter<T, U>: This class wraps an IList of one type to implement IList of another type. T is the underlying list type. U is the adapted list type.
*LiveConnectService: This service exposes WWS LiveConnect, which provides a way to communicate between applications that are on the same subnet using automated discovery and zero-configuration. Bonjour must be installed first. (Bonjour64.msi is installed for 64-bit Windows operating systems and Bonjour.msi is installed for 32-bit Windows operating systems.)
MathUtil: Math utilities to perform atypical operations, such as testing approximate equality, clamping and snapping.
*Outputs: Provides static methods for easy access to the output message facilities in the application. Automatically finds objects that implement IOutputWriter if both this class type and an implementer of IOutputWriter (such as OutputService) are added to a MEF catalog.
Path<T>: Class to represent a path in a tree or graph. Path supports a limited form of IList, not allowing add, remove, insert, or clear. T is a node item.
PathUtil: Path utilities.
*ResourceService: Default IResourceService implementation. Contains currently loaded resources and can load and unload resources. Imports all available IResourceResolver MEF components.
ResourceUtil: Utilities for working with resources, such as Images, Icons and Cursors.
Selection<T>: Collection representing a selection. Maintains a LastSelected item and enumerates items in least-recently-selected order. Provides change notification and views filtered by item type. Uses simple casting to convert to other types. T is a selection item.
ServerLogger: A service to log text messages to a remote server. By default, the application name and version number are retrieved from the entry assembly, and logged messages are sent to an ATF server available to all of World Wide Studios.
StringLocalizer: The base class for translating string literals that are embedded in the source code. Translation occurs at run-time. This default implementation does nothing and so would be appropriate for English-only applications (because the ATF uses English literal strings in its source code).
Tree<T>: A very simple n-ary tree. T is the type of value held at each tree node.
UniqueNamer: Class to assign unique names.
User32: Interop for structures and functions in user32.dll.
WinFormsUtil: Windows Forms utilities.
This namespace contains classes that specialize in adapting objects to other types.
AdaptableActiveCollection<T>: Collection representing active items. Maintains an ActiveItem and enumerates items in least-recently-active order. Provides change notification and views filtered by item type. Uses adaptation on items implementing IAdaptable to convert them to other types.
AdaptableCollection<T, U>: This class wraps an ICollection of one type to implement ICollection of another type. T is the underlying list type and U is the adapted list type.
AdaptableList<T, U>: This class wraps an IList of one type to implement IList of another type. T is the underlying list type and U is the adapted list type.
AdaptableSelection<T>: Collection representing a selection. Maintains a LastSelected item and enumerates items in least-recently-selected order. Provides change notification and views filtered by item type. Uses adaptation to convert to other types.
Adapter: Class that wraps an object to extend its adaptability.
AdapterCreator<T>: AdapterCreator that produces adapters of the given type. T is the adapter type, a class implementing IAdapter and with a default constructor.
Adapters: Extension methods for getting adapters for basic types.
These classes offer a variety of services, including many MEF components you can easily incorporate into applications.
ApplicationUtil: Application utilities to reduce duplicate client code and to implement common patterns of using the interfaces in Sce.Atf.Applications.
*AtfScriptVariables: Exposes common ATF services as script variables, so that the given ScriptingService can easily use these ATF services.
*AutoDocumentService: Service that auto-loads a document at application startup.
*AutomationService: Service that provides facilities to run an automated script using the .NET remoting service.
*BasicPythonService: Basic Python service that provides the Python scripting engine and imports many common .NET and ATF types into the Python namespace. Consider using ScriptConsole and AtfScriptVariables as additional MEF components.
Command: Abstract base class for Commands, which encapsulate some undoable/redoable action.
*CommandService: Service to handle commands in menus and toolbars, adding a status bar at the bottom of the main form.
*ContentTypeService: Service that provides a mapping from a URI extension to a content type string.
*ContextRegistry: Component that tracks application contexts; contexts correspond to user views of data.
*ControlHostService: Service to host controls and documents. It provides a docking control in which to hold controls, such as toolbars, menus, and docking. Note: This class is for internal use, and should not be instantiated or accessed directly by clients.
ControlInfo: Class that holds information about controls hosted by IControlHostService implementations.
*DefaultTabCommands: Component that provides the default commands related to document tab controls, such as those that appear in the context menu when right-clicking on a tab. To customize, there are two choices: 1. To remove or re-order the default commands, create a new class that derives from this one that overrides whatever methods it needs to. Add it to the components list. 2. To simply add new commands, you can create a new CommandPlugin that overrides the GetPopupCommandTags method. See implementation in source.
Dialogs: Provides static methods to abstract the display of parented dialogs. These methods can be used in place of calling form.ShowDialog(parentForm) by components that need to operate in both WinForms and WPF applications.
*DocumentRegistry: Component that tracks documents.
*DomNodePropertySearchService: Allow the search/replace UI for the currently active context to be displayed in a control host client.
*ErrorDialogService: Service that displays error messages to a user in an error dialog. The user can suppress error messages that aren't of interest.
*FileDialogService: Standard file dialog service, using ATF OpenFileDialog, SaveFileDialog and ConfirmationDialog classes. Use this component to provide file dialogs for an application. An implementation of IFileDialogService is required by StandardFileCommands to implement an application's standard File menu commands, File/New, File/Open, File/Save, File/Save As, and File/Close.
*FileWatcherService: Service to watch for changes to files. It requires an ISynchronizeInvoke component to ensure that notification events are raised on the UI thread.
*GridPropertyEditor: Component to edit DOM object values and attributes using the GridControl.
*HelpAboutCommand: Adds the Help/About command, which displays a dialog box to display a description of the application (specified by a derived class) plus the ATF version number.
*ImageThumbnailResolver: Thumbnail resolver for image resources.
ItemInfo: Holds information on the appearance and behavior of an item in a list or tree control.
*LayerLister: Editor that presents an ILayeringContext using a TreeControl.
ListViewEditor: Base class for list editors. It is not abstract, so it can be used as a generic list editor.
MainForm: Application main form, with optional ToolStrip container. Persists form size, state, and ToolStrip state.
MainFormTitleService: Service that updates the main Form's title to reflect the current document and its state.
*MainWindowTitleService: Service that updates the main Form's title to reflect the current document and its state.
MenuInfo: Container for menu information.
*OutputService: Service that displays text output to the user in a RichTextBox. If this type is added to a MEF catalog, then Outputs should probably be added as well.
*PaletteService: Class to manage the global palette of objects that can be dragged onto other controls.
*PerformanceMonitor: Service that displays the rendering performance of the currently active control. Clients can customize how the target control is measured or even monitor the performance of other objects entirely.
*ProjectLister: Editor providing a hierarchical tree control, listing the contents of a loaded document.
*PropertyEditingCommands: Component to provide property editing commands that can be used inside PropertyGrid-like controls. Currently, it defines context-menu only commands to reset the current property and all properties.
*PropertyEditor: Component to edit DOM object values and attributes using the PropertyGrid.
*PrototypeLister: Editor that presents an IPrototypingContext using a TreeControl.
*PythonService: Python service that provides a dockable command console for entering Python commands and imports many common .NET and ATF types into the Python namespace. If no command console is needed, then use BasicPythonService.
*RecentDocumentCommands: Service that provides menu commands to load recent documents.
*RenameCommand: Component that defines a mass rename command.
ReplaceTextBox: Graphical user interface for specifying a search on any data set wrapped within a class that implements IQueryableReplaceContext.
*ResourceLister: Graphical user interface component for browsing and organizing resource folders and resources (e.g. models, images, etc.) Similarly to Windows Explorer, this editor contains a folder tree and a contents view area. The contents view can be switched between details and thumbnails view. Replaces ATF 2's AssetLister.
*ScriptConsole: Python service that provides a dockable command console for entering Python commands and imports many common .NET and ATF types into the Python namespace.
SearchTextBox: Graphical user interface for specifying a search on any data set wrapped within a class that implements IQueryableContext.
SearchToolStrip: Graphical user interface for specifying a search on any data set wrapped within a class that implements IQueryableContext.
*SettingsService: Service that manages user editable settings (preferences) and application settings persistence.
*SingleInstanceService: Enforces the single-instance constraint on a graphical user interface application.
*SkinService: Service that allows for easy customization of an application’s appearance by using inheritable properties that can be applied at run-time and loaded from *.skn (XML format) files. Skin files can affect any public property of any control in an application.
*SourceControlCommands: Component that implements source control commands.
*StandardEditCommands: Implements the standard Edit menu's Cut, Copy, Paste and Delete commands.
*StandardEditHistoryCommands: Implements the standard Edit Undo and Redo commands.
*StandardFileCommands: Component that adds standard file commands: File/New, File/Open, File/Save, File/SaveAs, File/Save All and File/Close. This component requires an IFileDialogService for file dialogs; ATF provides a default implementation, FileDialogService. Use this, customize it or provide your own implementation.
*StandardFileExitCommand: Component that adds the File/Exit command that closes the application's main form.
*StandardLayoutCommands: Component that provides standard layout commands, like align left, or make widths equal. The component tries to work using the active context and requires both the ISelectionContext and ILayoutContext interfaces to be implemented on it. Further, it examines the selected items to see if the layout context can set their x, y, width and height. Any commands that can be done on the selection are enabled in the graphical user interface. All commands are also available programmatically through public methods.
*StandardLockCommands: Implements standard Lock and Unlock commands on contexts implementing the ILockingContext interface.
*StandardPrintCommands: Standard printing commands: File/Print, File/PageSetup, and File/PrintPreview.
*StandardSelectionCommands: Class that implements the standard selection commands.
*StandardShowCommands: Class that implements the standard Show commands: Show Selected, Hide Selected, Show Last Hidden, Show All, and Isolate.
*StandardViewCommands: Class that implements the standard viewing commands on contexts implementing the IViewingContext interface.
*StatusService: Service that provides a status user interface.
*TabbedControlSelector: Component that enables the user to switch control focus using the Ctrl+Tab keyboard command, similar to Visual Studio, Windows, or any tabbed internet browser application.
*ThumbnailService: Service that manages the transformation of resources into thumbnail images and file paths.
ToolStripAutoFitTextBox: A ToolStripTextBox that automatically changes its preferred width to display as much text as possible without going into the overflow menu. The available space is divided evenly among all ToolStripTextBox objects that are children of the owning ToolStrip.
TreeControlAdapter: Class to adapt a TreeControl to a data context that implements ITreeView. These optional interfaces may also be used: 1. IItemView is used to determine the item's label, icon, small icon, whether it's checked, and so on. 2. IObservableContext is used to keep the TreeControl nodes in sync with data. 3. IValidationContext is used to defer updates until data becomes stable. This allows more efficient updates of the TreeControl and saves IObservableContext implementations the trouble of calculating indices for ItemInserted and ItemRemoved events.
TreeControlEditor: Base class for tree editors. It is not abstract, so it can be used as a generic tree editor. Uses contexts that implement IHierarchicalInsertionContext and IInstancingContext.
TreeListViewAdapter: Wraps a TreeListView and allows user to supply data to the TreeListView through the ITreeListView interface and View property of the TreeListViewAdapter.
TreeListViewEditor: Combines a TreeListViewAdapter with right click context menu editing.
*UnhandledExceptionService: A service to catch all unhandled exceptions from the user interface thread and present the user with the option of continuing the application so that work can be saved. See also CrashLogger for non-GUI unhandled exception logging to a remote server. Note: If both are used, put CrashLogger in the MEF TypeCatalog first.
*WindowLayoutService: Window layout service.
*WindowLayoutServiceCommands: Window layout service commands. Provides menu options and GUIs for managing and using layouts.
The classes here work with performance monitors and the tool strip.
ToolStripEx: This class enables "click through" to System.Windows.Forms.ToolStrip. See How to enable "click through" for .NET 2.0 ToolStrip and MenuStrip for more information.
This namespace provides the capability to discover, add, configure and select targets, which are network endpoints, such as TCP/IP addresses, PS3 DevKits or Vita DevKits.
*Deci4pTargetProvider: Provides information about development devices available via Deci4p.
*TargetCommands: Commands to operate on currently selected targets. Command is accessible only by right click (context menu).
TargetDialog: Dialog to add/edit a target.
*TargetEnumerationService: Service that queries and enumerates target objects. It consumes target providers created by the application. Each provider is responsible for discovering and reporting targets of a specific type and their parameters. The service combines all the targets’ information into a heterogeneous list view for displaying and editing.
TargetInfo: Base class to describe target information. It contains parameters that define a target.
*TcpIpTargetProvider: Provides information about development devices available via TCP/IP.
These classes provide web services that enable ATF tools to communicate with SHIP over SOAP Web services to submit bugs and check for updated tool versions.
FeedbackForm: Form for submitting bugs to the SourceForge bug tracker.
*UserFeedbackService: User feedback service for displaying a dialog box that allows the user to submit a bug report to SHIP.
*VersionUpdateService: Component to update to latest version on SHIP.
This namespace supports ATGI asset description files. Assets are external content files created outside your application.
*AtgiResolver: Resource resolver for ATGI files. This class should be multi-thread safe after initialization has occurred.
AtgiSchemaTypeLoader: Universal ATGI component that registers a resolver and persister for ATGI files. It can read any version of an ATGI file as if its namespace matched the atgi.xsd namespace.
CustomDataAttribute: Custom data attribute interface implementation.
Joint: Interface for ATGI Joint. Represents the jointType in atgi.xsd, which extends the nodeType complex type.
Node: Implementation of INode. Corresponds to nodeType in atgi.xsd.
NodeProperties: DOM object interface to expose ATGI node properties.
PrimitiveSet: ATGI Primitive Set. This is the lowest level object that can be rendered or selected in an ATGI model. This object does not actually do the rendering, though.
This provides a component to resolve Collada resources.
*ColladaResolver: This service resolves Collada resources.
This namespace contains many basic controls not provided in standard .NET Windows Forms, including controls for editing numbers and file paths, a label control for hovering, "About" and "Confirmation" dialogs, and an Error display form.
One of the more elaborate controls in this namespace is CanvasControl, which implements a 2D panning and zooming window on a finite size canvas. CanvasControl also implements auto-scrolling, a multiselection drag rectangle, and framing objects in the view. The GraphControl class is similar to CanvasControl, but operates over a logically infinite canvas.
BalloonToolTipHelper: Helper class for displaying balloon tool tips on controls.
CanvasControl: A control for viewing and editing a 2D bounded canvas.
ColorPickerEditor: UITypeEditor for editing colors with the ColorPicker.
CustomizeKeyboardDialog: Dialog to edit and assign shortcuts to the registered commands.
DataBoundListView: Extends Window’s ListView with data binding and cell editing capablities.
FilteredFileDialogBase: Base class for custom OpenFilteredFileDialog and SaveFilteredFileDialog.
NumericTextBox: TextBox extended to edit numeric types.
NumericTupleControl: Control for editing a numeric tuple (vector) of arbitrary dimension.
OpenFilteredFileDialog: This class behaves the same as the System.Windows.Forms.OpenFileDialog class, but allows a custom file filter to be added to exclude files in the dialog's ListView. Use for importing assets, for instance.
QuadPanelControl: Control with a 2-way splitter, holding 4 panels.
SplitButton: Represents a combination of a standard button on the left and a drop-down button on the right that is not limited to the ToolStrip.
TreeControl: A tree control to display hierarchical data. Handles user input, including editing. Decides the placement of the images, check box, and label of each item. The TreeItemRenderer decides how to draw the items. The TreeControlAdaptor adapts this tree control to the ITreeAdaptor interface.
TreeItemRenderer: Renders the items of a tree control and provides derived classes an opportunity to customize the appearance of the items in the tree control. Is responsible for rendering such things as the label, check box, and expander. However, the TreeControl decides the positions.
TreeListView: Partial implementation of the TreeListView class.
WindowLayoutManageDialog: Manage layouts dialog.
This namespace adds adapters for various controls.
AdaptableControl: Adaptable control, a control with adapters (decorators). The adaptable control can be converted into any of its adapters using the IAdaptable.As method.
CanvasAdapter: Basic implementation of a canvas adapter, which defines the canvas bounds and visible window size.
ControlAdapter: Base class for control adapters.
*DiagramTheme: Diagram theme, which determines how elements in diagrams are rendered and picked.
D2dAdaptableControl: A control with adapters (decorators); the adaptable control can be converted into any of its adapters using the IAdaptable.As method.
D2dAnnotationAdapter: Adapter that allows AdaptableControl to display and edit diagram annotations (comments).
D2dGridAdapter: Adapter to draw a grid on the diagram and to perform layout constraints using that grid.
DragDropAdapter: Adapter to add drag and drop support to an adapted control.
DraggingControlAdapter: Abstract base class for control adapters that drag. It tracks the mouse and handles the logic of determining when a drag has moved enough to be considered a drag.
HoverAdapter: Adapter that uses an IPickingAdapter and a timer to generate events when the user hovers over diagram items.
MouseWheelManipulator: Control adapter that converts mouse wheel rotation into scales using an ITransformAdapter.
SelectionAdapter: Adapter that adds mouse click and drag selection to AdaptableControl. The context must be convertible to ISelectionContext.
ViewingAdapter: Adapter that defines a viewing context on the adapted control. Requires an ITransformAdapter.
This namespace’s classes work with graphs.
D2dCircuitRenderer<TElement, TWire, TPin>: Graph renderer that draws graph nodes as circuit elements and edges as wires. Elements have 0 or more output pins where wires originate, and 0 or more input pins where wires end. Output pins are on the right, and input pins are on the left side of elements.
D2dDigraphRenderer<TNode, TEdge>: Standard directed graph renderer that renders nodes as disks and edges as lines or arcs. For this graph renderer, edge routes are integer indices, indicating which line or arc to draw for the edge. This allows multiple edges between a pair of states to be distinguished.
D2dGraphAdapter<TNode, TEdge, TEdgeRoute>: Control adapter to reference and render a graph diagram. It also provides hit testing with the Pick method and viewing support with the Frame and EnsureVisible methods.
D2dGraphEdgeEditAdapter<TNode, TEdge, TEdgeRoute>: Adapter that adds graph edge dragging capabilities to an adapted control with a graph adapter. TNode is the Node type and must implement IGraphNode. TEdge is the edge type and must implement IGraphEdge TEdgeRoute is the edge route type and must implement IEdgeRoute.
D2dGraphNodeEditAdapter<TNode, TEdge, TEdgeRoute>: Adapter that adds graph node dragging capabilities to an adapted control with a graph adapter. TNode is the Node type and must implement IGraphNode. TEdge is the edge type and must implement IGraphEdge TEdgeRoute is the edge route type and must implement IEdgeRoute.
D2dGraphRenderer<TNode, TEdge, TEdgeRoute>: Abstract base class for graph renderers, which render and hit-test a graph. TNode is the Node type and must implement IGraphNode. TEdge is the edge type and must implement IGraphEdge TEdgeRoute is the edge route type and must implement IEdgeRoute.
D2dStatechartRenderer<TNode, TEdge>: Class to handle rendering and hit testing in state charts.
GraphRenderer<TNode, TEdge, TEdgeRoute>: Abstract base class for graph renderers, which render and hit-test a graph.
These classes allow color editing.
ColorPicker: Color picker.
This namespace provides curve editing facilities, including a component.
Cartesian2dCanvas>: Cartesian 2D canvas class with numerous drawing methods.
CurveCanvas: Offers methods for drawing and picking curves.
CurveEditingControl: Container control for CurveControl.
*CurveEditor: Component to edit curves using the CurveEditorControl. CurveRenderer: Class used by CurveControl for picking and rendering.
CurveUtils: Utility class used by Curve control and client application.
These classes provide property editors and associated classes for various kinds of data.
ArrayEditor: Property editor that allows editing the size, order, and values of an array whose elements are numeric.
BoolEditor: Property editor that supplies CheckBox controls for embedding in complex property editing controls.
BoundedFloatConverter: TypeConverter for use with BoundedFloatEditor; restricts parsed float values to a specified range.
BoundedFloatEditor: Property editor that supplies BoundedFloatControl instances for embedding in complex property editing controls. These display a slider and textbox in the GUI.
BoundedIntEditor: Property editor that supplies IntInputControl instances for embedding in complex property editing controls. These display a slider and textbox in the GUI.
BoundPropertyDescriptor: A specialization of System.ComponentModel.PropertyDescriptor that is bound to a specific property of an object or type. If the property's setter is private, the BoundPropertyDescriptor’s IsReadOnly property is true.
CollectionEditor: Editor that provides collection editing controls.
ColorPickerEditor: UITypeEditor class for editing colors.
DateTimeEditor: UITypeEditor class for editing date and time values. The default TypeConverter works if the date is stored in the DOM as a DateTime (if it is specified as xs:dateTime in the schema). Other representations (string, integer number of seconds since some starting date, etc.) require a custom TypeConverter specified in the schema annotation.
EmbeddedCollectionEditor: Embedded property editor for adding, removing and editing items in a collection. Supports multiple ItemInserters, allowing you to insert child items of various types (typically derived from a common base class).
EnumTypeConverter: TypeConverter for use with enum editors; converts int flags to/from strings.
FileUriEditor: UITypeEditor class for editing file paths stored as strings or URIs.
GridControl: Wrapper Control for the spreadsheet-style GridView control, combining it with a toolbar. Use this as a replacement for the .NET System.Windows.Forms.DataGridView.
GridView: Spreadsheet-like control for displaying properties of many objects simultaneously. Only the properties that are in common with all the selected objects are displayed.
IntColorConverter: TypeConverter for use with ColorEditor; converts color stored in DOM as an ARGB int to/from Color or string types.
LongEnumEditor: Property editor that supplies an autocomplete ComboBox to facilitate editing long enum-like attributes and values. The enum list can be updated programmatically. It is recommended that you use the EnumConverter as the TypeConverter for this editor's property to support display names. A LongEnumEditor is created for each PropertyDescriptor for each selection change. PropertyDescriptors are shared between property editors, like GridView and PropertyGridView.
NumericEditor: Property editor that supplies NumericTextBox controls for embedding in complex property editing controls.
NumericMatrixEditor: Property editor that can provide controls for editing numeric matrices. All numeric types except Decimal are supported. Can be used with the standard .NET PropertyGrid, DataGrid, and DataGridView, as well as the PropertyGrid control.
NumericTupleEditor: Property editor that can provide controls for editing numeric tuples (vectors) of arbitrary dimension. All numeric types except Decimal are supported. Can be used with the standard .NET PropertyGrid, DataGrid, and DataGridView, as well as the PropertyGrid control.
PropertyEditingContext: Context in which properties can be edited, holding the selected items whose properties are to be edited. It provides machinery to get the descriptors for the properties being edited and to perform property edits as logical commands for the undo/redo system.
PropertyEditingControl: Universal property editing control that can be embedded in complex property editing controls. It uses TypeConverters and UITypeEditors to provide a GUI for every kind of .NET property.
PropertyEditorControlContext: Context for embedded property editing controls that provides a safe, convenient interface for getting and setting values without worrying about the intricacies of property descriptors and transaction contexts. It is only constructed by PropertyView.
PropertyGrid: Wrapper control for the two-column PropertyGridView, combining it with a toolbar. Use this as a replacement for the .NET System.Windows.Forms.PropertyGrid.
PropertyGridView: Control for displaying properties in a two column grid, with property names on the left and property values on the right. Properties with associated IPropertyEditor instances can embed controls into the right column, while all other properties are edited in a standard .NET way with a PropertyEditingControl.
PropertyUtils: Utilities for working with PropertyDescriptors.
PropertyView: Base class for complex property editing controls, providing formats, fonts, data binding, persistent settings, and category/property information.
UniformArrayEditor<T>: Property editor that supplies NumericTextBox controls for embedding in complex property editing controls. This class couples 1. an EditingControlContext that considers the property as an array (of arbitrary length) of identical numeric values of type T and 2. the control that displays to the user a single value of type T. T is the numeric type of each array element that is to be edited as a single property. All .NET numeric types are supported, although the scaling factor in NumericEditor is not applied to integer types. See Sce.Controls.NumericTextBox for the list.
UniformFloatArrayConverter: Type converter that can convert a uniform float[] to and from a string of the form "c". This is useful for uniform scale vectors, for example.
This namespace defines a Timeline abstraction and control, with Events, Markers, Tracks, and Track Groups. Note that several of the classes in this namespace have been replaced by classes in Sce.Atf.Controls.Timelines.Direct2D.
DefaultTimelineConstraints: Default implementation of the abstract base class for timeline constraints. It ensures that intervals don't overlap by either clipping the new interval or repositioning it to the right.
GhostInfo: Information for drawing ghosted timeline objects.
TimelineConstraints: Abstract base class for timeline constraints.
TimelineLayout: A class to associate a timeline object's path with a bounding rectangle in screen space. A timeline object can appear multiple times within a TimelineControl due to referenced sub-documents, including the possibility of the same timeline sub-document being referenced multiple times. Also provides an enumeration of all pairs of paths and rectangles.
IEvent: Interface for Events, base interface for IMarker, IInterval, and IKey.
IGroup: Interface for Groups, which contain 0 or more tracks and can be expanded or collapsed in a viewing control.
IInterval: Interface for Intervals, which are events on a track.
IMarker: Interface for Markers, which are zero length events on all tracks.
ITimeline: Interface for Timelines, which contain groups and markers.
ITimelineDocument: Interface for editable timeline documents.
ITimelineObject: Marker interface for objects in Timelines, such as Groups, Tracks, and Events.
ITrack: Interface for Tracks, which contain 0 or more Intervals.
This namespace defines a Timeline abstraction and control, with events, markers, tracks, and track groups.
D2dDefaultTimelineRenderer: Default timeline renderer. This class is designed to be instantiated once per TimelineControl.
D2dMoveManipulator: A timeline manipulator for moving IEvent objects, such as markers, keys, and intervals.
D2dScaleManipulator: Scale manipulator: a horizontal bar on the top of the scale bar. Has handles at each end, bracketing the selection set. Has two distinct modes: 1. Individual interval scaling occurs when the left or right border of an interval is scaled. In this case, the entire selection of intervals is scaled "in place". That is, their starting locations do not change. Only intervals are affected. 2. If the handles on the scaling manipulator are dragged, then the portion of the timeline that is bracketed by the first selected object to the last selected object is scaled in time. Everything selected is scaled—keys, markers, and intervals.
D2dScrubberManipulator: Scrubber manipulator: a vertical bar that can slide left and right by grabbing the handle on the top.
D2dSelectionManipulator: A timeline manipulator for implementing the selection logic. This should probably be attached last to the TimelineControl.The attachment is permanent, and there must be one TimelineControl per ITimelineDocument.
D2dSnapManipulator: A timeline manipulator intended to be used by other manipulators to allow for snapping selected objects to non-selected events and give a visual indication.
D2dSplitManipulator: A timeline manipulator for splitting intervals. When hovering the mouse over an interval, the user can press a modifier key (Alt by default) and the cursor changes to indicate where a split will take place. On the MouseDown event, the interval is split.
D2dTimelineControl: Control to display a timeline. In a multiple document application, there is one of these per “tab” or document.
D2dTimelineRenderer: Abstract base class for timeline renderers. The class is designed to be instantiated once per TimelineControl.
This namespace offers various drawing facilities using Direct2D.
D2dBitmap: Represents a bitmap that has been bound to a D2dGraphics object.
D2dBrush: Defines an object that paints an area.
D2dFactory: Represents a Direct2D factory. Creates Direct2D resources. Any resource created by this factory can be shared between D2dGraphics objects.
D2dGraphics: Represents an object that can receive drawing commands. Your application should create a D2dGraphics object once per control and hold onto it for the life of the control or until the D2dGraphics EndDraw method returns the D2DERR_RECREATE_TARGET error. If you receive this error, recreate the D2dGraphics (and any resources it created).
D2dHwndGraphics: Renders drawing instructions to a control.
D2dLinearGradientBrush: Paints an area with a linear gradient.
D2dRadialGradientBrush: Paints an area with a radial gradient.
D2dResource: Base class for all Direct2d resources.
D2dSolidColorBrush: Paints an area with a solid color.
D2dStrokeStyle: Describes the caps, miter limit, line join, and dash information for a stroke.
D2dTextFormat: D2dTextFormat describes the font and paragraph properties used to format text and also describes locale information.
D2dEllipse: Contains the center point, x-radius, and y-radius of an ellipse.
D2dFontStyle: Represents the style of a font face as normal, italic, or oblique.
D2dReadingDirection: Specifies the direction in which reading progresses.
This namespace’s classes allow you to use the DOM for application data. See DOM in a Nutshell for an overview of working with the DOM.
AttributeInfo: Metadata for attributes, which are DOM fields holding a primitive type or an array-of-primitive type. The primitive type is usually a .NET value type (such as int or float), but could also be a reference type in the case of Uris or references to DomNodes.
AttributePropertyDescriptor: PropertyDescriptor for an attribute of a node.
AttributeRule: Abstract base class for a rule that constrains attribute values. A rule for a numeric value might constrain the value to a range, while a rule for a string value might constrain it to an enumeration. See the AttributeInfo.AddRule method.
AttributeType: Class that describes the type of an attribute on a DOM node. Attributes can be primitive values, like int or float, or arrays of primitive values. Attributes are not always value types; they can be reference types in the case of Uris and references to DomNodes.
ChildAttributeCollectionPropertyDescriptor: PropertyDescriptor for child or descendant collections of attributes of a DOM object.
ChildAttributePropertyDescriptor: PropertyDescriptor for an attribute of a child or descendant of a Node.
ChildInfo: Metadata for children, which are DOM fields holding a reference to another DOM node.
ChildPropertyDescriptor: PropertyDescriptor for a child of a node.
DataValidator: Validator that checks DOM changes against attribute and child rules contained in metadata. Checks are only made within validations, which are signaled by IValidationContexts within the DOM data. InvalidTransactionExceptions are thrown, if necessary, in the Ended event of the IValidationContext.
DependencyValidator: Adapter that adds a dependency system to the DomNode's subtree and maintains constraints through transactions. The dependencies are updated at the end of every transaction that occurs in the DOM sub-tree, so are not part of transactions themselves.
DomDocument: Adapts a DOM node to implement IDocument.
*DomExplorer: Component to implement a DOM explorer, a tree view and property grid for exploring a DOM. It is useful as a raw view on DOM data for diagnosing DOM problems.
DomNode: Node in a DOM data tree.
DomNodeAdapter: Base class for DomNode adapters, which allow DomNodes to be dynamically cast to more convenient forms.
DomNodeListAdapter<T>: Wrapper that adapts a node child list to a list of T items. T is an adapted list item type that adapts a DomNode or is a DomNode. Should implement IAdaptable. Examples include DomNodeAdapter, DomNode, and IAdapter.
DomNodeSerializer: A class to support passing DOM node graphs between applications. This class has methods to serialize the node graph to and from byte arrays and is Serializable itself, so can be used as the data in an IDataObject.
DomNodeType: Defines a DOM type in a type hierarchy. Each derived type has only one base type. This is similar to XML complex types. Each type can define attributes (simple .NET types or arrays of those types), children, and extensions (typically adapters that implement IAdaptable). Each DomNode is considered to be an instance of one immutable DomNodeType.
*DomRecorder: Component to implement a DOM recorder, which records DOM events on the active context and displays them in a list. These log events can also be retrieved programmatically.
DomXmlReader: Class to read DOM data defined by an XML schema.
DomXmlWriter: Class to write DOM data defined by an XML schema.
EditingContext: An editing context is a history context with a selection, providing a basic self-contained editing context. There may be multiple EditingContexts in a document.
ExtensionInfo: Metadata for extensions, which can be any type. Use extensions to extend DOM data when it is in memory. Extensions that implement IAdapter can be retrieved through the IAdaptable interface of DomNode.
ExtensionInfo<T>: Metadata for extensions, which can be any type. Use extensions to extend DOM data when it is in memory. Extensions that implement IAdapter can be retrieved through the IAdaptable interface of DomNode. T is the type of extension; type must have a default constructor.
HistoryContext: Adds history to a TransactionContext. If the adapter can adapt the node to an ISelectionContext, the history includes selection changes.
LockingValidator: Validator that tracks locked data in the DOM. Checks are made only within validations, which are signaled by IValidationContexts within the DOM data.
MultipleHistoryContext: Adapter that observes a DOM subtree and synchronizes multiple history contexts with an IDocument adapter on the root node. The root DOM node must be adaptable to IDocument.
NamedMetadata: Base class for metadata. DomNodeType, AttributeInfo, ChildInfo, and ExtensionInfo all derive from this type.
NodeTypePaletteItem: Read-only data used to describe how a particular DomNodeType should appear in a palette of items that the user can drag and drop into a document. For example, MyDomNodeType.SetTag( new NodeTypePaletteItem(...)). IPaletteClient implementors can call DomNodeType.GetTag to retrieve these NodeTypePaletteItem objects.
PropertyDescriptor: Abstract base class for DOM PropertyDescriptors.
ReferenceValidator: Validator that tracks references and reference holders to ensure integrity of references within the DOM data. Checks are only made within validations, which are signaled by IValidationContexts in the DOM data. The adapter should be an extension to the DOM's root node. The validator does the following: 1. Tracks all DOM node references in the subtree. 2. Raises notifications if external DOM node references are added or removed. 3. After validating, raises notification events if referents have been removed, leaving dangling references.
SelectionContext: Adapts a DOM node to an ISelectionContext, using an AdaptableSelection.
TransactionContext: Adapts a DOM node to an ITransactionContext.
UniqueIdValidator: Adapter that ensures that every DOM node in the subtree has a unique id.
Validator: Abstract base class for validators that need to track all validation events in their sub-tree. Derived classes should throw InvalidTransactionException if the DomNode is considered invalid in the following methods: OnBeginning, OnEnding, and OnEnded. In these DOM-change notification methods, only do your validation logic if Validating is true, because otherwise your code might end up throwing InvalidTransactionException during the transaction unrolling stage and the second InvalidTransactionException will cause the application to crash. Throw InvalidOperationException in OnNodeSet if necessary.
XmlSchemaTypeCollection: A collection of metadata (DomNodeType, ChildInfo, and AttributeInfo objects) that is associated with a target namespace from an XML schema file.
XmlSchemaTypeLoader: XML schema loader that creates DomNodeTypes, parses annotations, and creates attribute rules.
This offers a service for Perforce source control.
*PerforceService: Component implementing ISourceControlService using the Perforce Client API.
This namespace contains facilities for rendering 3D graphics. This namespace includes:
- A Camera class to define a standard viewing geometry.
- Camera controllers, including a base Controller class, as well as walk, fly, trackball (Maya-style) and arcball controller implementations.
- Texture management classes, including classes for loading and storing textures, built-in image loaders for MS Bitmap, DDS and Targa formats, as well as classes for creating DDS textures from other formats.
- RenderState, an extensible, platform-independent representation of GPU render state, and associated classes and interfaces for managing and rendering RenderState objects.
CameraController: Base class for camera controllers.
Controller: Base class for controllers.
ControlScheme: Provides a way of mapping the mouse and keyboard keys to a set of commands that are activated in a context-sensitive manner, such as controlling a camera or selecting objects in the Design View. This class is useful in cases where the use of the left mouse button, middle mouse button, shift key, CTRL key, etc., should be customizable for modifying the behavior of various logical commands.
DomNodeUtil: Utility functions for operating on the value of a DomNode.
RenderState: RenderState is an extensible platform-independent representation of a GPU render state. GPU state is represented by a combination of flags (RenderMode) and values that accompany flags (TextureName). A RenderState is committed to the graphics device driver layer by way of the RenderStateGuardian.Commit method. RenderStates can be composed from parents. This behavior is controlled via the InheritState and OverrideChildState flags.
TextureInfo: Holds data about a texture.
These classes render data that is typically stored in a DOM, such as rendering DOM data as a 3D Scene. This namespace includes:
- Scene and SceneNode classes to represent the SceneGraph.
- DOM object interface classes to adapt DOM data for SceneGraph building, rendering, and picking.
- Utilities for building, rendering, and picking the SceneGraph.
- 3D Manipulator abstractions.
- A DesignControl class, derived from CanvasControl3D, which can render and manipulate a 3D Scene.
- A mechanism for generating thumbnail bitmaps from scenes.
HitRecord: Hit Record returned by IPickAction, used to represent single-selection hits (by casting a ray) and multi-selection hits (by using a frustum). Used for geometry-based picking and by render-picking (OpenGL pick).
PickAction: Standard implementation of IPickAction. Uses OpenGl rendering if necessary, to support "render picking" of objects, unless they implement IIntersectable.
RenderAction: Standard implementation of IRenderAction.
RenderObject: Abstract base class for assets that can be rendered. For example, each node in an ATGI model has one of these interfaces attached. Multiple instances of a model in the Design View (a complex schema type derived from gameObjectType) refer to the same RenderObject. The RenderObject is asked to build TraverseNode objects (in the Traverse method) and the TraverseNode objects are used to call back into the RenderObject's Dispatch.
Scene: SceneNode that holds the root of the Scene Graph.
SceneGraphBuilder: Class that can build a Scene Graph from a root source object, typically a DomNode.
SceneNode: A node in the scene graph. SceneNodes hold all of the render objects and constraints that are associated with a source object. SceneNodes are arranged in a graph that determines which objects to render and in what traversal order.
TransformUtils: 3D Transformation utilities.
TranslatorControl: Reusable 3D Translator control.
TraverseNode: Class for encapsulating the rendering state for each IRenderObject. These objects are the nodes in the Traverse List. Each IRenderObject is responsible for creating a TraverseNode instance and adding it to the Traverse List if it wishes to be dispatched. This must be done in the IRenderObject.Traverse method.
These classes perform rendering using OpenGL.
CanvasControl3D: 3D OpenGL canvas control.
OpenGlCore: Useful OpenGl Utilities and Extension manager.
Panel3D: A control for using OpenGL to do the painting. The constructor initializes OpenGL so that other tools that use OpenGL, like the Texture Manager, work even if BeginPaint has not been called. This allows Panel3D to work in a tabbed interface like the FAST Editor.
TextureManager: Manages texture bindings in OpenGL and associates groups of textures with a user defined context.
Util3D: 3D Graphics utilities to draw various objects and get graphics information.
VboManager: Vertex buffer manager.
This namespace has facilities for handing 2D, 3D and 4D vector objects. It defines low level types such as rays, lines, segments, Bezier curves, boxes, planes, spheres and quaternions.
BezierCurve: A 3D Bezier curve segment.
BezierSpline: A 3D Bezier spline, made up of Bezier points.
Box: A simple 3D bounding box.
Frustum: A 3D viewing frustum, made from 6 planes that are in the View Coordinate System (x: right, y: up, z: out of screen). The frustum can be in one of two modes—perspective or orthographic.
Matrix3F: A 3 x 3 matrix.
Matrix4F: Represents a 4x4 matrix that is equivalent to OpenGl's 4x4 matrix and is laid out in memory the same way as in OpenGl. The translation components are M41, M42, and M43.
Polygon3F: A set of vertices representing a closed planar polygon.
Seg2F: A 2D line segment.
Triangle3F: A 3D triangle.
This namespace contains WPF utilities.
Contracts: MEF contract strings.
DelegateCommand: This class allows delegating the commanding logic to methods passed as parameters and enables a View to bind commands to objects that are not part of the element tree.
DispatcherUtil: Provides a set of commonly used Dispatcher extension methods.
DelegateCommand<T>: This class allows delegating the commanding logic to methods passed as parameters and enables a View to bind commands to objects that are not part of the element tree. T is the type of the parameter passed to the delegates.
ImageUtil: Image rendering utilities.
MathUtil: Transform utilities.
*ViewModelRepository: Singleton class to manage view models and their attachment to views.
This namespace provides a variety of utilities and components.
*CommandService: Service that handles commands in menus and toolbars. This is one of the key components that other components need.
*ControlHostService: Service to host content in the main dock panel. This is one of the key components that other components need.
ControlHostServices: Useful static/extension methods for IControlHostServices.
ControlInfo: Class that holds information about controls hosted by IControlHostService implementations.
*ErrorDialogService: Service that displays error messages to a user in an error dialog. The user can suppress error messages that aren't of interest.
LayoutContexts: Useful static/extension methods on ILayoutContext.
*OutputService: Service that displays text output to user.
*PaletteService: Class to manage the global palette of objects that can be dragged onto other controls.
*StatusService: Service that provides a status user interface.
ThumbnailService: Service that manages the transformation of Resources into thumbnail images and file paths.
*UnhandledExceptionService: A service to catch all unhandled exceptions from the UI thread and present the user with the option of continuing the application so that work can be saved. See also Sce.Atf.CrashLogger for non-GUI unhandled exception logging to a remote server. If both are used, put CrashLogger in the TypeCatalog first.
This offers a component for running legacy code in WPF applications.
*CommandServiceAdapter: Class to adapt Sce.Atf.Wpf.Applications.ICommandService and Sce.Atf.Wpf.Applications.IContextMenuService to Sce.Atf.Applications.CommandService. This allows legacy code to be run in a WPF based application.
*ContextMenuService: This class is mainly for legacy support. Expect WPF based applications to bind their context menus directly to static commands or commands on view model.
*ControlHostServiceAdapter: Class to adapt Sce.Atf.Wpf.Applications.IControlHostService to Sce.Atf.Applications.IControlHostService. This allows WinForms based code to be run in a WPF based application.
*DialogService: Service to abstract display of parented WinForms dialog.
*MainWindowAdapter: Service to manage lifetime and notifications for main window.
StandardInteropParts: Obtains a TypeCatalog of all this namespace’s components for ready inclusion in an AggregateCatalog so that these components may be used.
This namespace provides services to manage controls that use the Model-View-Controller (MVC) design pattern. With the MVC control framework, you attach data controls to an underlying data model (usually the DOM) through adaptor client classes that you define. The adaptor client exposes, filters, and presents the data model in a way that the control can understand. It includes event handlers for managing changes to the data from either direction. The MVC control framework eliminates a lot of the repetitive and tedious work of data binding, as well as reducing dependencies on specific GUI controls.
*MainMenuViewModel: Service to manage a main menu view model.
StandardViewModels: Obtains a TypeCatalog of all this namespace’s components (plus Sce.Atf.Wpf.ViewModelRepository) for ready inclusion in an AggregateCatalog so that these components may be used.
*StatusBarViewModel: Service to manage a status bar view model.
*ToolBarViewModel: Service to manage a tool bar view model.
This namespace provides classes that perform various type conversions.
DisplayStringConverter: Used on an enum and overrides the standard behavior of ToString for enum values.
InputGestureTextConverter: Converts InputGestureCollection to a single KeyGesture string by taking first available KeyGesture.
IsNullConverter: Returns whether or not an object is null.
ResourceLookupConverter: Attempts to return a UI resource using the input value as a resource key.
TimeSpanToVisibilityConverter: Value converter returns Visible if Ticks > 0, Collapsed otherwise.
ToDoubleConverter: Allows conversion to double from int, long, byte, double and float.
- Home
- Getting Started
- Features & Benefits
- Requirements & Dependencies
- Gallery
- Technology & Samples
- Adoption
- News
- Release Notes
- ATF Community
- Searching Documentation
- Using Documentation
- Videos
- Tutorials
- How To
- Programmer's Guide
- Reference
- Code Samples
- Documentation Files
© 2014-2015, Sony Computer Entertainment America LLC