Class Survey
Because ATF is a very large framework, this survey concentrates on some of the more representative and useful classes. Some classes are variations of each other, and this survey may only show a few of the variants. Listed classes are only a fraction of the ones available.
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 a 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.
For detailed information about these classes, download the ATF API Reference. The class descriptions here mention a lot of interfaces, and you can get information on them in the API Reference. Many of the interfaces are also described in the ATF Programmer's Guide. For an overview of ATF namespaces, see ATF Namespaces.
This namespace provides a variety of general purpose utilities and MEF components. For example, it contains general purpose file dialogs, loggers, file utilities, GDI utilities, Windows® interoperability functions, LINQ (Language Integrated Query) classes, and mathematics utilities.
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 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 on another type. The type Parameters are T, the underlying list type, and U, the adapted list type.
ColorUtil: Static class with useful Color struct utilities.
*CrashLogger: A service to log unhandled exceptions (crashes) to a remote server.
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).
DependencySystem<T>: Contains a dependency relation between objects, where T is the type of object with dependencies. Dependencies can be invalidated, and a list of invalidated dependents can be retrieved to be updated by the client.
DirectoryUtil: Directory utilities to enumerate files.
DragDataHelper: Provide extended functionality for the IDataObject interface during drag and drop actions.
DragDropExtender: Extend drag and drop functionality, allowing the attachment of an image and description.
EnumDisplayUtil: Static utility methods for working with enums.
EnumUtil: Utilities for working with enum types.
FileMoveService: Class that provides atomic file copy, move, and delete operations: 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.
ItemInsertedEventArgss<T>: Arguments for "item inserted" event. T is the item type.
ItemRemovedEventArgsItemRemovedEventArgs<T>: Arguments for "item removed" event. T is the item type.
ItemsChangedEventArgs<T>: Class for notifying event subscribers when items are added, removed, or changed in some context or collection. T is the item type.
ItemSelectedEventArgs<T>: Event arguments for "Item selected" events. T is the item type.
KeysUtil: Utility methods for WfKeys (Windows key codes and modifiers).
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.
MathUtil: Mathematics utilities to perform atypical operations, such as testing approximate equality, clamping and snapping.
Multimap<Key,Value>: A class to map a key to one or more values.
NumericUtil: Numeric utility methods used by controls.
*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.
Pair<T1,T2>: Standard Pair struct.
Path<T>: Class to represent a path in a tree or graph. Supports a limited form of IList, not allowing add, remove, insert, or clear. T is a node item.
PathUtil: File path utilities.
Resources: Standard embedded resources, such as images.
*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 type of selected items.
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 Sony's World Wide Studios.
Shell32: Supports interoperability for structures and functions in Shell32.dll.
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 ATF uses English literal strings in its source code).
StringUtil: String utilities.
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. It contains the interfaces IAdaptable and the key extension methods As<T>() and Cast<T>(). For more information on adaptation, see Adaptation in ATF.
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.
AdaptablePath<T>: Class to represent a path in a tree or graph with the capability of adapting the last element of the path (the Last property) to a requested type. T is the type of items in the path.
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. T is the type of items in the selection.
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.
BindingAdapterObject: Generates PropertyDescriptors based on adapting the adaptee to all possible types and returning descriptors for each adapter.
These classes offer a variety of services needed for applications, including many MEF components you can easily incorporate into applications. For more on ATF application basics, see ATF Application Basics and Services.
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. For more information, see AtfScriptVariables Component.
*AutoDocumentService: Service that auto-loads a document at application start up. For more information, see AutoDocumentService Component.
*AutomationService: Service that provides facilities to run an automated script using the .NET remoting service. To learn more, see AutomationService Component.
*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. For more information, see BasicPythonService Component.
Command: Abstract base class for Commands, which encapsulate some undoable/redoable action.
CommandHistory: A Command history for undo/redo.
CommandInfo: Menu/Toolbar command information. Is used either directly or indirectly with ICommandService to provide configuration information about how a command is presented to the user. Includes menu text, toolbar icons, shortcut keys, and visibility flags. For additional information, see CommandInfo Class.
*CommandService: Service to handle commands in menus and toolbars, adding a status bar at the bottom of the main form. To learn more, see Registering Commands.
*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. For more information, see Context Registry. To learn about more, see ATF Contexts.
*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. For a discussion, see ControlHostService Component.
ControlInfo: Class that holds information about controls hosted by IControlHostService implementations. For more details, see ControlInfo Class.
*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. For more information on this and other components that provide commands, see Using Standard Command Components.
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.
DirectoryWatcherService: Service to watch for changes to directories.
DocumentClientInfo: Class to hold document editor information.
*DocumentRegistry: Component that tracks documents. For a further discussion, see Document Registry and Services.
*DomNodePropertySearchService: Allow the search/replace UI for the currently active context to be displayed in a control host client. For a discussion of how this class is used in the ATF Simple DOM Editor Sample, see DomNodePropertySearchService Component.
*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.
FilteredTreeControlEditor: Add filtering support for tree editors.
FilteredTreeView: Helper class to adapt a data context that implements ITreeView to support filtering items in a tree view.
FormNcRenderer: Renders non-client area of the form.
FunctionalTestBase: Base testing facilities. For a further discussion, see FunctionalTestBase Class.
*GridPropertyEditor: Component to edit DOM object values and attributes using the GridControl. To learn more, see GridPropertyEditor Component.
*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.
*HistoryLister: Provides visual representation of undo commands. For more information, see HistoryLister Component.
*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. This component is used in several samples, including ATF Circuit Editor Sample.
*LemurOscService: Provides Open Sound Control support that is compatible with the Lemur iPad app, made by the Liine company. For details, see LemurOscService Component.
ListViewAdapter: Adapter that adapts a System.Windows.Forms.ListView control to an IListView.
ListViewEditor: Base class for list editors. It is not abstract, so it can be used as a generic list editor. For more details, see ListViewEditor Component.
MainForm: Application main form, with optional ToolStrip container. Persists form size, state, and ToolStrip state. For a discussion of using MainForm, see WinForms Application.
*MainWindowTitleService: Service that updates the main Form's title to reflect the current document and its state.
MenuInfo: Container for menu information. For details, see WinForms Menus.
*OutputService: Service that displays text output to the user in a RichTextBox. If this type is added to a MEF catalog, then the Outputs component should probably be added as well. This component is used in several samples, including ATF Circuit Editor Sample, ATF Code Editor Sample, and ATF Timeline Editor Sample.
*PaletteService: Class to manage the global palette of objects that can be dragged onto other controls. For a discussion of using a palette, see Using a Palette.
*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. For more details, see PropertyEditingCommands Component.
*PropertyEditor: Component to edit DOM object values and attributes using the PropertyGrid. To learn more, see PropertyEditor Component.
*PrototypeLister: Editor that presents an IPrototypingContext using a TreeControl. This component is used in several samples, including ATF Circuit Editor Sample, ATF FSM Editor Sample, and ATF State Chart Editor Sample.
*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. For more information, see PythonService Component.
*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.
*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. For more information, see ScriptConsole Component.
ScriptingService: An abstract base class for services (e.g., MEF components) that can expose C# objects to a scripting language. For additional information, see ScriptingService Class.
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.
SelectionContexts: Useful methods for operating on an ISelectionContext.
*SettingsService: Service that manages user editable settings (preferences) and application settings persistence. For more details, see SettingsService Component.
*SingleInstanceService: Enforces the single-instance constraint on a graphical user interface application. This component is used in the ATF State Chart Editor Sample.
SkinEditor: Editor for skins. For more information on skins in ATF, see SkinService Component.
*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. For more information, see SkinService Component.
*SourceControlCommands: Component that implements source control commands.
SourceControlService: Abstract base class for source control service. For an example of its usage, see the ATF Code Editor Sample.
StandardCommand: Standard menu/toolbar commands enumeration.
StandardCommandGroup: Standard command groups in menus and toolbars enumeration.
StandardControlGroup: Standard docking groups enumeration, which determine where controls are initially docked.
StandardDockAreas: Standard docking areas enumeration, which determine where controls can be docked.
*StandardEditCommands: Implements the standard Edit menu's Cut, Copy, Paste and Delete commands. For more details, see StandardEditCommands and Instancing.
*StandardEditHistoryCommands: Implements the standard Edit/Undo and Edit/Redo commands. For more information on this and other components that provide commands, see Using Standard Command Components.
*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. For additional information, see StandardFileCommands Component.
*StandardFileExitCommand: Component that adds the File/Exit command that closes the application's main form. For more information on this and other components that provide commands, see Using Standard Command Components.
*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. For more information on this and other components that provide commands, see Using Standard Command Components.
*StandardLockCommands: Implements standard Lock and Unlock commands on contexts implementing the ILockingContext interface. For more information on this and other components that provide commands, see Using Standard Command Components.
StandardMenu: Standard application menus.
*StandardPrintCommands: Standard printing commands: File/Print, File/PageSetup, and File/PrintPreview. For more information on this and other components that provide commands, see Using Standard Command Components.
*StandardSelectionCommands: Class that implements the standard selection commands. For more information on this and other components that provide commands, see Using Standard Command Components.
*StandardShowCommands: Class that implements the standard Show menu commands: Show Selected, Hide Selected, Show Last Hidden, Show All, and Isolate. For more information on this and other components that provide commands, see Using Standard Command Components.
*StandardViewCommands: Class that implements the standard viewing commands on contexts implementing the IViewingContext interface. For more information on this and other components that provide commands, see Using Standard Command Components.
*StatusService: Service that provides a status user interface. For a discussion, see StatusService Component.
*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. The ATF DOM Tree Editor Sample uses this class.
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. For information on this and other ATF custom controls, see ATF Custom Controls.
TreeListViewAdapter: Wraps a TreeListView and allows user to supply data to the TreeListView through the ITreeListView interface and View property of the TreeListViewAdapter. For a discussion, see TreeListViewAdapter Class.
TreeListViewEditor: Combines a TreeListViewAdapter with right click context menu editing. For a discussion of using this class, see Tree List Editor Programming Discussion.
*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 the CrashLogger component for non-GUI unhandled exception logging to a remote server. Many of the ATF Code Samples use this service.
WebHelp: Simple class that launches a webpage when the user presses F1 on a particular Control (or otherwise causes the HelpRequested event to be raised).
*WebHelpCommands: Commands for offering web-based help, so that a specific web page is opened if the user presses F1. See WebHelp class for offering context-sensitive help.
*WindowLayoutService: Window layout service. Several of the samples use this, including ATF Circuit Editor Sample, ATF Code Editor Sample, and ATF Tree List Editor Sample.
*WindowLayoutServiceCommands: Window layout service commands. Provides menu options and GUIs for managing and using layouts. This component is used in several samples, including ATF Circuit Editor Sample, ATF Code Editor Sample, and ATF Tree List Editor Sample.
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, PS4 DevKits, or Vita DevKits. For an example of using some of these classes, see the ATF Target Manager Sample and Target Manager Programming Discussion.
*Deci4pTargetProvider: Provides information about development devices available for Deci4p.
*Ps3TargetProvider: Provides information about development devices (targets) available for PS3™.
*Ps4TargetProvider: Provides information about development devices (targets) available for PS4™.
Target: Represents a named network endpoint.
*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.
*TargetService: Standard component implementation of ITargetService, which provides network support.
TargetTcpSocket: High level client TCP socket.
TcpCommandClient: High level command/packet based protocol for TCP.
TcpIpTargetInfo : Class to describe TCP/IP target information.
*TcpIpTargetProvider: Provides information about development devices available via TCP/IP.
*X86TargetProvider: Provides information about development devices (targets) available for X86.
These classes provide web services that enable ATF tools to communicate with SHIP (for Sony users) 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.
Anim: ATGI Anim.
*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.
Mesh: ATGI Mesh.
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.
Scene: ATGI scene.
Schema: ATGI Schema.
Shader: ATGI Shader.
Texture: ATGI Texture.
This provides a component to resolve COLLADA resources.
Animation: COLLADA animation.
Collada: COLLADA utilities.
*ColladaResolver: This service resolves COLLADA resources.
Effect: COLLADA rendering effects.
Mesh: COLLADA mesh.
Node: COLLADA node.
Scene: COLLADA scene.
Schema: COLLADA Schema.
SubMesh: COLLADA submesh.
Tools: COLLADA static tools.
VisualScene: COLLADA visual scene.
Classes for working with various kinds of collections.
AdaptableObservableCollection<T,U>: Wraps an IObservableCollection of one type to implement IObservableCollection of another type. T: underlying list type, U: adapted list type.
AdaptingCollection<T,M>: Base class for collections that can sort or filter their contents. code>T: type of items in the collection, M: metadata about type T.
AdaptingCollection<T>: Base class for collections that can sort or filter their contents. T: type of items in the collection.
CollectionChangeListener: Class that listens for specific property changes for all items within a collection.
FilteringCollection<T,M>: Collection that filters the items by the specified filter. T: type of items in the collection, M: metadata about type T.
ObservableCollectionAdapter<T,U>: Wraps an IObservableCollection of one type to implement IObservableCollection of another type. T: underlying list type, U: adapted list type.
OrderingCollection<T,M>: Collection that orders the items by the specified order. code>T: type of objects in the collection, M: metadata about type T.
PriorityQueue<T,TPriority>: Queue of items of type T, sorted by priority of type TPriority. T: Type of the items in the queue, TPriority: Type of the priority to sort by.
ReferenceCollectionAdapter<TRefTarget,U>: Collection to adapt an observable collection of references to an observable collection of their reference targets. TRefTarget: Type of reference target, code>U: Type of reference target.
SortedObservableCollection<T>: Utility class for a sorted observable collection. T is the type of items in the collection.
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. For information about using controls, see Controls in ATF.
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.
Many of these controls are used to edit property values. For more information, see Value Editors and Value Editing Controls.
For a discussion of controls, see Controls in ATF.
AboutDialog: A "Help About..." dialog, with Sony Logo and assembly list.
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.
CustomColorTable: This class can be used to create a new ToolStripProfessionalRenderer (.NET class that handles painting functionality for ToolStrip objects, applying a custom palette and a streamlined style).
CustomizeKeyboardDialog: Dialog to edit and assign shortcuts to the registered commands.
DataBoundListView: Extends Window's ListView with data binding and cell editing capablities.
ErrorDialog: Dialog to display error messages to user; used by the ErrorDialogService component.
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.
ProgressDialog: Progress dialog.
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.
TabbedControlSelectorDialog: Dialog that enumerates all controls accessible by the specified IControlHostService.
ThumbnailControl: A thumbnail viewer control.
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: Provides a tree ListView.
WindowLayoutManageDialog: Manage layouts dialog. Used by WindowLayoutServiceCommands component.
WindowLayoutNewDialog: New window layout dialog.
This namespace contains adapters for various controls.
For a discussion of adaptation, see Adaptation in ATF. Control adapters give you an easy way to add abilities to certain controls without changing the control at all. For a discussion, see Control Adapters. Many of the classes in the namespace are control adapters and are described in Control Adapter Descriptions.
AdaptableControl: Adaptable control, a control with adapters (decorators). The adaptable control can be converted into any of its adapters using the IAdaptable.As() method. For more details, see AdaptableControl Class.
CanvasAdapter: Basic implementation of a canvas adapter, which defines the canvas bounds and visible window size.
ControlAdapter: Base class for control adapters. For additional information, see ControlAdapter Class.
D2dAdaptableControl: A control with adapters (decorators); the adaptable control can be converted into any of its adapters using the IAdaptable.As() method. Derives from AdaptableControl and is more often used. For more details, see AdaptableControl Class.
D2dAnnotationAdapter: Adapter that allows AdaptableControl to display and edit diagram annotations (comments). For a list of control adapters, see Control Adapter Descriptions.
D2dGridAdapter: Adapter to draw a grid on the diagram and to perform layout constraints using that grid. For a list of control adapters, see Control Adapter Descriptions.
*DiagramTheme: Diagram theme, which determines how elements in diagrams are rendered and picked. This component is used in several samples, including ATF Circuit Editor Sample, ATF Fsm Editor Sample, and ATF State Chart Editor Sample.
DragDropAdapter: Adapter to add drag and drop support to an adapted control. For a list of control adapters, see Control Adapter Descriptions.
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. For a list of control adapters, see Control Adapter Descriptions.
HoverAdapter: Adapter that uses an IPickingAdapter and a timer to generate events when the user hovers over diagram items. For a list of control adapters, see Control Adapter Descriptions.
MouseLayoutManipulator: Control adapter to add a layout adorner to complex states. For a list of control adapters, see Control Adapter Descriptions.
MouseTransformManipulator: Control adapter that converts mouse drags into translations and scales of the canvas using an ITransformAdapter. For a list of control adapters, see Control Adapter Descriptions.
MouseWheelManipulator: Control adapter that converts mouse wheel rotation into scales using an ITransformAdapter. For a list of control adapters, see Control Adapter Descriptions.
RectangleDragSelector: Adapter that allows user to drag-select rectangular regions on the adapted control to modify the selection. For a list of control adapters, see Control Adapter Descriptions.
ScrollbarAdapter : Adapter that adds horizontal and vertical scrollbars to the adapted control. For a list of control adapters, see Control Adapter Descriptions.
SelectionAdapter: Adapter that adds mouse click and drag selection to AdaptableControl. The context must be convertible to ISelectionContext. For a list of control adapters, see Control Adapter Descriptions.
TransformAdapter: Adapter that defines a transform for the adapted control consisting of a scale followed by a translation. Implements ITransformAdapter. This transform affects how the canvas is viewed. Other control adapters use this class. For a list of control adapters, see Control Adapter Descriptions.
ViewingAdapter: Adapter that defines a viewing context on the adapted control. Requires an ITransformAdapter. For a list of control adapters, see Control Adapter Descriptions.
This namespace’s classes adapt graph-related controls. Many adapt DomNodes.
For a discussion of graphs and circuits, see Graphs in ATF. For circuits in particular, see the ATF Circuit Editor Sample and Circuit Editor Programming Discussion.
Circuit: Adapts DomNode to a circuit and observable context with change notification events.
CircuitDocument: Adapts the circuit to IDocument and synchronizes URI and dirty bit changes to the ControlInfo instance used to register the viewing control in the UI.
CircuitEditingContext: Class that defines a circuit editing context. Each context represents a circuit, with a history, selection, and editing capabilities. There may be multiple contexts within a single circuit document, because each sub-circuit has its own editing context.
CircuitUtil: Class with static method circuit utilities.
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. The ATF Fsm Editor Sample uses this class.
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. Used in ATF Circuit Editor Sample, ATF Fsm Editor Sample, and ATF State Chart Editor Sample.
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. Used in ATF Circuit Editor Sample, ATF Fsm Editor Sample, and ATF State Chart Editor Sample.
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. Used in ATF Circuit Editor Sample, ATF Fsm Editor Sample, and ATF State Chart Editor Sample.
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. Used in ATF State Chart Editor Sample.
D2dSubCircuitRenderer<TElement, TWire, TPin>: Subgraph renderer that draws subnodes as circuit elements, and subedges as wires. Also draws virtual representations of group pins for editing. Used in ATF Circuit Editor Sample.
D2dSubgraphAdapter<TNode,TEdge,TEdgeRoute>: Control adapter to reference and render a subgraph diagram. Also provides hit testing with the Pick() method, and viewing support with the Frame() and EnsureVisible() methods. Used in ATF Circuit Editor Sample.
Element: Adapts DomNode to circuit element, which is the base circuit element with pins. Used in ATF Circuit Editor Sample.
GraphHitRecord: Hit record specifying the node, edge, and in/out edge routes from graph picking operation. Used in ATF Circuit Editor Sample.
GraphRenderer<TNode, TEdge, TEdgeRoute>: Abstract base class for graph renderers, which render and hit-test a graph.
Group: Adapts DomNode to group in a circuit. Used in ATF Circuit Editor Sample.
*GroupingCommands: Component that defines circuit-specific commands for group and ungroup. Grouping takes modules and the connections between them and turns those into a single element that is equivalent. Used in ATF Circuit Editor Sample.
GroupPin: Adapter for a pin on a group module, with extra information needed to associate the pin on the group with the internal module where it was connected before grouping. A group pin is a pin on a grouped sub-circuit; it extends the information of a pin to preserve the internal pin/module which is connected to the outside circuit. Used in ATF Circuit Editor Sample.
LayerFolder : Adapts DomNode to a layer folder. A layer folder allows a hierarchy of layers to be defined.
*LayeringCommands: Component to add "Add Layer" command to application. Used in ATF Circuit Editor Sample.
Pin: Adapts DomNode to a pin in a circuit; used in mastering and as a base class for GroupPin. Used in ATF Circuit Editor Sample.
Prototype: Adapts DomNode to a circuit prototype, which contains modules and connections that can be instanced in a circuit.
Wire: Adapts DomNode to connection in a circuit. Used in ATF Circuit Editor Sample.
These classes allow color editing.
ColorBox: Color box displaying colors for a color picker.
ColorPicker: Color picker.
This namespace provides curve editing facilities, including a component. For more information on curve editing, download the ATF Curve Editor User and Programming Guide.
Cartesian2dCanvas>: Cartesian 2D canvas class with numerous drawing methods.
CurveCanvas: Offers methods for drawing and picking curves.
CurveEditingControl: Container control for CurveControl. Used in ATF DOM Tree Editor Sample. Used by CurveEditor component.
*CurveEditor: Component to edit curves using the CurveEditorControl. Used in the ATF DOM Tree Editor Sample.
CurveRenderer: Class used by CurveControl for picking and rendering.
CurveUtils: Utility class used by CurveControl and client application.
HermiteCurveEvaluator: Evaluator for hermite curve. A curve evaluator calculates y-coordinates from x-coordinates using appropriate interpolation for a curve.
LinearCurveEvaluator: Curve evaluator methods for linear curves.
These classes provide value editors, value editing controls, value converters, and associated classes to edit data properties. Value editing controls can be embedded in property editors, such as the PropertyEditor and GridPropertyEditor components. Value editor classes names typically end in "Editor", value editing control classes in "Control", and value converter classes in "Converter".
To learn about property editing, see Property Editing in ATF. In particular, for information about value editors, see Value Editors. Value Editors and Value Editing Controls shows the UI for value editing controls, and tells which value editors and samples use them. For a discussion of how value converters convert values between value editors and value controls, see Value Converters.
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.
CollectionEditingControl: Collection editing control used by CollectionEditor.
CollectionEditor: Editor that provides collection editing controls.
ColorEditor: UITypeEditor class for editing colors.
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. Used by the GridPropertyEditor component.
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. Used by GridControl.
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.
NestedCollectionEditor: Nested collections editor.
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 ATF 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 ATF 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.
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 contains classes for a syntax editor. For an example of its usage, see the ATF Code Editor Sample.
BreakpointIndicator: Breakpoint indicator.
SyntaxEditorControl: Encapsulates the Actipro SyntaxEditor control, implementing ISyntaxEditorControl.
This namespace defines a Timeline abstraction and control that are UI-platform-agnostic, 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.
For an example of a timeline application, see ATF Timeline Editor Sample and Timeline Editor Programming Discussion.
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.
HitRecord: Holds the results of a hit testing operation.
Intervals: Useful static and extension methods for IInterval 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 D2dTimelineControl 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.
TimelinePath: Class for timeline path, which is a sequence of objects in timelines, e.g., groups, tracks, and events.
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 zero or greater length 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 classes for working with timeline elements, including a renderer, control, and manipulators, that are dependent on the Windows® Forms UI platform and use Direct2D to render timeline objects.
For an example of a timeline application, see ATF Timeline Editor Sample and Timeline Editor Programming Discussion.
D2dDefaultTimelineRenderer: Default timeline renderer. This class is designed to be instantiated once per D2dTimelineControl.
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 D2dTimelineControl. The attachment is permanent, and there must be one D2dTimelineControl 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 takes 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 D2dTimelineControl.
This namespace offers various drawing facilities using Direct2D. For an example of its use, see the ATF Using Direct2D Sample.
D2dBitmap: Represents a bitmap that has been bound to a D2dGraphics object.
D2dBrush: Defines an object that paints an area.
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.
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.
D2dReadingDirection: Specifies the direction in which reading progresses.
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: Describes the font and paragraph properties used to format text and also describes locale information.
D2dTextLayout: Represents a block of text after it has been fully analyzed and formatted.
D2dUtil: Direct2D utility static methods.
These classes work with Microsoft DirectWrite.
TextEditor: Text editing and selecting using DirectWrite.
This namespace’s classes allow you to use the ATF Document Object Model (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. For more information, see Other Metadata Classes.
AttributePropertyDescriptor: PropertyDescriptor for an attribute of a node. For more information, see AttributePropertyDescriptor Class.
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. For additional information, see ATF Rule Classes.
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.
BindingAdapter: DomNodeAdapter that adds support for data binding to adapters obtained through the IAdaptable interface.
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 DomNode. For more information, see Other Metadata Classes.
ChildPropertyDescriptor: PropertyDescriptor for a child of a DomNode. For more information, see ChildPropertyDescriptor Class.
ChildRule: Abstract base class for a rule that constrains parent-child relationships. A rule might constrain the number or type of children. For additional information, see ATF Rule Classes.
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. For more information, see DOM Adapters Validate, ATF DOM Validators, and Using Rule Classes with DataValidator.
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. Several ATF samples use DomDocument, such as ATF Simple DOM Editor Sample.
*DomExplorer: Component to implement a DOM explorer, a tree view and property grid for exploring data in a DOM. It is useful as a raw view on DOM data for diagnosing DOM problems. To learn more, see Using DomExplorer.
DomNode: Node in a DOM data tree. Fundamental class in the DOM. For additional information, see DomNode Class.
DomNodeAdapter: Base class for DomNode adapters, which allow DomNodes to be dynamically cast to more convenient forms. Very important class in the DOM. For a discussion, see DOM Adapters.
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. For an example of its use, see OnNodeSet Method.
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. For more information, see DomNodeType Class.
*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. To learn more, see Using the DomRecorder Component.
DomXmlReader: Class to read DOM data defined by an XML schema. For additional information, see Reading Application Data.
DomXmlWriter: Class to write DOM data defined by an XML schema. For more information, see Writing Application Data.
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. For more information, see EditingContext Class.
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. For additional information about extensions and DOM adapters, see DOM Adapters.
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. For additional information about extensions and DOM adapters, see DOM Adapters.
FieldMetadata: Metadata for a field (e.g., child element or attribute or extension) that is defined by a DomNodeType and owned by a possibly separate DomNodeType (if a DOM type exists that derives from the base DOM type that defines this field). For more information, see Other Metadata Classes.
HistoryContext: Adds history to a TransactionContext. If the adapter can adapt the node to an ISelectionContext, the history includes selection changes. For information on this and other context classes, see Context Classes.
IdValidator: Abstract base class for node ID validators. This class collects nodes that have been added, removed, and renamed in the DOM subtree and passes them to derived class for handling. For additional information on this and other validators, see ATF DOM Validators.
LockingValidator: Validator that tracks locked data in the DOM. Checks are made only within validations, which are signaled by IValidationContexts within the DOM data. For additional information on this and other validators, see ATF DOM Validators.
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. For information on this and other context classes, see Context Classes.
NamedMetadata: Base class for metadata. DomNodeType, AttributeInfo, ChildInfo, and ExtensionInfo all derive from this type. For more information, see DomNodeType Class.
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. For a discussion of using NodeTypePaletteItem in setting up a palette, see Using a Palette.
ObservableDomNodeAdapter: DomNodeAdapter that facilitates observing property changes in DomNode children.
Observer: Abstract base class for DOM contexts, which track DOM nodes as they enter and exit the subtree rooted at the DOM node to which this adapter is bound.
PropertyDescriptor: Abstract base class for DOM PropertyDescriptors. For additional information, see PropertyDescriptor Class.
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. For information on this and other validators, see ATF DOM Validators.
SelectionContext: Adapts a DOM node to an ISelectionContext, using an AdaptableSelection. For information on this and other context classes, see Context Classes.
Template: Represents a type of template that appears in a special editor like the TemplateLister. A template references a particular instance of data (the Target property), while adding additional information about that reference (the Name and Guid properties).
*TemplateLister: Editor that presents an ITemplatingContext using a TreeControl.
*TemplatingCommands: Component to add "Add Template Folder" command to application.
TemplatingContext: Editing Context for templates library; this is the context that is bound to the TemplateLister when a circuit document becomes the active context.
TransactionContext: Adapts a DOM node to an ITransactionContext. For information on this and other context classes, see Context Classes.
TransactionReporter: Observes and collects the DOM changes in the attached DOM tree during transactions and then raises the final "cleaned-up" events after the transaction finishes.
UniqueIdValidator: Adapter that ensures that every DOM node in the subtree has a unique ID. For additional information on this and other validators, see ATF DOM Validators.
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 the Validating property is true, because otherwise your code might end up throwing InvalidTransactionException during the transaction unrolling stage and the second InvalidTransactionException causes the application to crash. Throw InvalidOperationException in OnNodeSet() if necessary. For additional information on this and other validators, see ATF DOM Validators.
XmlSchemaTypeCollection: A collection of metadata (DomNodeType, ChildInfo, and AttributeInfo objects) that is associated with a target namespace from an XML schema file. For a discussion, see Type Loaders.
XmlSchemaTypeLoader: XML schema loader that creates DomNodeTypes, parses annotations, and creates attribute rules. To learn more, see Type Loaders.
This namespace contains classes for performance monitoring.
PerformanceTimers: A utility class that uses a single system stop watch to time any number of distinct types of events, identified by a supplied name. Can prepare a simple report.
These classes handle keyboard and mouse input.
Keys: Enum for key codes.
KeysUtil: Defines utility methods for Keys enum.
These classes handle view models for WPF.
AdapterViewModel: View model class that can adapt an adaptee and provide a bindable As property.
This offers a service for Perforce source control and related classes.
*PerforceService: Component implementing ISourceControlService using the Perforce Client API.
This namespace contains facilities for rendering 3D graphics and includes:
- A
Cameraclass to define a standard viewing geometry. - Camera controllers, including a base
Controllerclass, 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.
MayaControlScheme: Implements a camera control scheme, mapping certain mouse and keyboard events to camera commands, similar to Maya camera controls.
RenderState: 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).
TextureInfo: Holds data about a texture.
TrackBallCameraController: Maya-style camera controller.
WalkCameraController: Walk camera controller, which uses WASD keys to move, and mouse to rotate.
These classes render data that is typically stored in a DOM, such as rendering DOM data as a 3D Scene. This namespace includes:
-
SceneandSceneNodeclasses to represent theSceneGraph. - DOM object interface classes to adapt DOM data for
SceneGraphbuilding, rendering, and picking. - Utilities for building, rendering, and picking the
SceneGraph. - 3D Manipulator abstractions.
- A
DesignControlclass, derived fromCanvasControl3D, which can render and manipulate a 3D Scene. - A mechanism for generating thumbnail bitmaps from scenes.
DesignControl: Extends CanvasControl3D to provide SceneGraph rendering and picking.
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.
TraverseSortUtils: Helper functions for render state sorting.
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.
BezierPoint: A 3D Bezier Point.
BezierSpline: A 3D Bezier spline, made up of Bezier points.
Box: A simple 3D bounding box.
CircleF: A circle (sphere in 2D) represented with floats.
EulerAngles3F: Euler angles representing a 3D rotation.
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.
Plane3F: 3D Plane, of the form Normal * p = Distance, where p is a point on the plane.
Polygon3F: A set of vertices representing a closed planar polygon.
QuatF: Unit quaternion to represent rotations.
Ray2F, Ray3F: 2D and 3D rays.
Seg2F: A 2D line segment.
Sphere3F: A 3D sphere.
Triangle3F: A 3D triangle.
Vec2F, Vec3F, Vec4F: 2D, 3D, 4D vectors, represented with floats.
This namespace contains WPF utilities.
Contracts: MEF contract strings for various models.
DelegateCommand, DelegateCommand<T>, DelegateCommand<T1, T2>: These classes allow 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, T1, and T2 are types of parameters passed to delegates.
DialogUtils: Dialog utility functions.
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.
DispatcherExtensions: Provides a set of commonly used Dispatcher extension methods.
FreezableCursor: Class for a cursor that is Freezable, i.e., has a modifiable state and a read-only (frozen) state.
ImageUtil: Image utilities and UIElement extension methods.
MathUtil: Mathematics utilities.
Resources: Resource keys for styles and images.
ResourceUtil: Resource utility extension methods.
*ViewModelRepository: Singleton class to manage view models and their attachment to views.
VisualTreeExtensions: Extension methods for visual trees.
This namespace provides a variety of utilities and components. It is the WPF analog to Sce.Atf.Applications. For a sample WPF application using ATF, see ATF Simple DOM Editor WPF Sample.
AtfApp : Base ATF WPF application class. Derive WPF applications from this class to avoid rewriting boilerplate code.
*AutoDocumentService: Service that auto-loads a document at application startup. For more information, see AutoDocumentService Component.
CommandDef: Command definition information. For additional information, see CommandInfo Class.
*CommandService: Service that handles commands in menus and toolbars. This is one of the key components that other components need. To learn more, see Registering Commands.
ControlDef: Control definition class. For more details, see ControlDef Class.
*ControlHostService: Service to host content in the main dock panel. This is one of the key components that other components need. For a discussion, see ControlHostService Component.
ControlHostServices: Useful static/extension methods for IControlHostServices.
ControlInfo: Class that holds information about controls hosted by IControlHostService implementations. For more details, see ControlInfo Class.
*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, New, Open, Save, Save As, and Close.
*HelpCommands: Provides main application help command and context specific context menu help commands.
LayoutContexts: Useful static/extension methods on ILayoutContext.
MenuDef: Menu definition. For details, see WPF Menus.
*OutputService: Service that displays text output to user.
*PaletteService: Class to manage the global palette of objects that can be dragged onto other controls. For a discussion of using a palette, see Using a Palette.
*SettingsService: Service that manages user editable settings (preferences) and application settings persistence. For more details, see SettingsService Component.
*SourceControlCommands: Component that implements source control commands.
*StandardEditCommands: Component that implements the standard Edit menu's Cut, Copy, Paste, and Delete commands. For more details, see StandardEditCommands and Instancing.
*StatusService: Service that provides a status user interface. For a discussion, see StatusService Component.
*TargetService: Standard component implementation of ITargetService.
TcpIpTarget: Class representing a TCP/IP target with observable properties.
*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.
*WindowLayoutServiceCommands: Window layout service commands.
WpfItemInfo: Holds information on the appearance and behavior of an item in a list or tree control.
These classes provide web services that enable ATF tools to communicate with SHIP (for Sony users) over SOAP Web services to submit bugs and check for updated tool versions. Analagous to Sce.Atf.Applications.WebServices.
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.
These classes define WPF behaviors.
AdaptableControl: Adaptable control, which is a control with adapters (decorators). The adaptable control can be converted into any of its adapters using the ControlAs() method. For information on control adapters, see Control Adapters.
AtfTreeViewBehavior: Behavior for TreeView that works alongside the TreeViewModel class to support multi-selection and "bring into view" capabilities.
CommandBehavior: Attached command behavior to hook routed events to ICommands in the view model.
DataObjectAdapter: Adapter to convert WPF clipboard data to WinForms clipboard data.
EditableTextBlockBehavior: Editable text block behavior.
GridViewSortBehavior: GridView sort behavior.
LastHitAwareBehavior: Behavior for last item hit.
SelectionBehaviorBase: Base class for Selection Behaviors. Can be used on Selectors or TreeViews.
ThemeStyleBehavior: Attached Property which allows a style that uses BasedOn="" to be re-based when the application theme is dynamically changed.
TwoWaySelectionBehavior: Behavior to add two way selection binding support between an ISelectionContext and a selector or multi-selector.
ViewModelLocator: Locates the ViewModel used.
These classes provide collections for WPF.
PriorityQuadTree<T>: Class for a priority tree of rectangular objects, where T is the type of nodes in tree.
These classes provide various WPF controls.
AboutDialog: Interaction logic for an about dialog.
BrowseForFolderDialog: Implementation of a folder browser dialog.
CommonDialog: Base class for dialogs.
ConfirmationDialog: Code behind for a confirmation dialog.
DirectoryPicker: Implementation of a directory picker dialog.
ErrorDialog: Interaction logic for error dialogs.
FilePicker: Implementation of a FilePicker dialog.
FormattingTextBox: A TextBox with a bindable StringFormat property.
MainWindow: Interaction logic for main windows.
MessageBoxDialog: Interaction logic for message boxes.
ProgressDialog: Interaction logic to display progress to the user.
RangeSlider: A slider that provides a range.
RangeSliderBase: Represents a slider with a range of allowed values that can be turned on or off.
SliderBox: Combines a slider with a formatted textbox.
SplitButton: A button which has drop down content.
TargetDialog: Interaction logic for a target dialog.
TileView: Class representing a tiled layout view.
TreeListView: Provides a TreeView ListView.
TreeListViewItem: Selectable item in a TreeListView.
VirtualizingWrapPanel: Arranges and virtualizes content on a panel with wrapping.
WindowLayoutManageDialog: Interaction logic for ManageWindowLayoutsDialog.
Similarly to Sce.Atf.Controls.PropertyEditing, these classes provide property editors, value editors, and associated classes for various kinds of data. For details on property editing, see Property Editing in ATF.
DependencyAttribute: Dependency attribute for updating a node with dependencies on a property of other nodes.
DynamicPropertyNode: Property node that adds support for dynamic dependencies with other property descriptors.
DynamicStandardValuesConverter: A type converter that dynamically provides a set of standard values when queried.
EditorTemplateSelector: Provides a way to select a value editor.
FilePathValueEditor: Custom property editor for editing file paths.
FilePathValueEditorContext: Editing context for the FilePathValueEditor.
FolderPathValueEditor: Data bound property editor that uses a template to edit a folder path.
MultiLineTextValueEditor: Class for editing a value with a multi-line TextBox.
NumberFormatAttribute: Numeric format string attribute.
PropertyGrid: Grid of PropertyNodes.
PropertyGridToolBar: PropertyGrid ToolBar.
PropertyNode: Encapsulates an object or collection of objects and a property common to them all.
RangeSliderValueEditor: Slider property editor with a range of allowable values.
RangeSliderValueEditorContext: Editing context for RangeSliderValueEditor.
SliderValueEditor: Class for editing a value with a slider control.
StandardValuesAttribute: Standard values attribute for enumerable list of values.
StandardValuesAttributeBase: Standard values attribute base for enumerable list of values.
StandardValuesConverter: A type converter which provides a set of standard values when queried.
StandardValuesEditor: Property editor for an enumerable list of values.
TransactionPropertyNode: PropertyNode where setting the property value is done as a transaction.
ValueEditor: Base class for editing a value with a control.
ValueEditorUtil: Utilities for ValueEditor.
This namespace's classes handle a dock.
ContentSettings: Content settings collection class.
DockContent: Class representing content to be docked in the docking framework.
DockedWindow: This class represents a window while it is docked into the hierarchy. It provides the title bar, close and collapse icons, and can be resized within the hierarchy.
DockIcon: Class for icon used when user wants to dock the window, and the UI shows icon indicators, indicating where to dock the window.
DockPanel: Root class that provides docking/undocking/collapsing windows and other things.
FloatingWindow : This window holds content when it is undocked.
GridLayout: Layout that lays its children horizontally or vertically separated with separators. Each child is a DockedWindow, or another GridLayout.
ResizablePopup: Resizable popup that can be resized to one side, depending on which side it is docked to.
SidePopup: Collapsible panel on the side.
TabLayout: Layout that represents its children as tabs.
These classes provide WPF DOM support, which is minimal, because the DOM functions identically in WinForms and WPF, for the most part.
DataContextAdapter<Telement,Tdata>: Utility class used to adapt FrameworkElement DataContext using ATF's IAdaptable pattern.
DomRecorder: Component to implement a DOM recorder, which records DOM events on the active context and displays them in a list. These logged events can also be retrieved programmatically. To learn more, see Using the DomRecorder Component.
HelpAnnotations: Class for working with objects that provide context sensitive help.
This namespace offers classes for running legacy code in WPF applications.
*ContextMenuService: Creates context menus. This class adapts Sce.Atf.Wpf.Applications.IContextMenuService to Sce.Atf.Applications.CommandService. 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: Provides control host services. Class to adapt Sce.Atf.Wpf.Applications.IControlHostService to Sce.Atf.Applications.IControlHostService. This allows WinForms-based applications to be run in a WPF based application. For more information on ControlHostService, see ControlHostService Component.
*DialogService: Service to abstract display of parented WinForms dialog.
KeysInterop: Static utility methods for converting among different key types.
*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 can easily be used.
StatusServiceAdapter: Service that manages a status display. Class to adapt Sce.Atf.Wpf.Applications.IStatusService to Sce.Atf.Applications.IStatusService. This allows WinForms-based applications to be run in a WPF based application. For more information on StatusService, see StatusService Component.
These classes handle WPF markup extensions for XAML.
CommandServiceExtension: Command service markup extension.
EnumValuesExtension: Extension for working with enum values.
GenericExtension: Extension for working with generic types.
MultiConverterMarkupExtension<T>: XAML markup extension implementations that can be supported by .NET Framework XAML Services and its XAML readers and XAML writers. T is the converter type.
ResourceKeyBinding: XAML markup extension to provide data binding for a resource key.
TransactionBinding: Binding that adds validation rules to begin and end transactions.
TransactionBindingCore: Core class used in order to share functionality between TransactionMultiBinding and TransactionBinding.
TransactionMultiBinding: Multibinding that adds validation rules to begin and end transactions.
TypeConverterExtension: Converts between type names and Types for source and target types.
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 adapter client classes that you define. The adapter 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.
AdaptableViewModelCollection<T,U>: Wraps an IObservableCollection of one type to implement IObservableCollection of another type, where T is a class and U is a new class. This adapter class can be used to simulate interface covariance, where an IObservableCollection of Type1 can be made to implement an IObservableCollection of Type2, as long as Type1 implements or can be adapted to Type2. This class differs from AdaptableObservableCollection in that it always creates a complete new set of adapters for the underlying collection using the IAdapterCreator passed in to the constructor. This feature is useful for WPF MVVM situations where a collection must be adapted to a new collection of unique view models rather than shared view models.
DialogViewModelBase: Base class for dialog view models. Implements commands and logic for OK/Cancel and validation.
*MainMenuViewModel: View model for an application's menus.
MenuModel: Menu View Model. Used for sub menus and as a base class for root menus.
Node: View model for a node in TreeViewModel.
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.
NotifyPropertyChangedBase: Base class for all view models. Implements INotifyPropertyChanged for binding.
OutputItemVm: View model for items in an output window.
OutputVm: View model for an output window.
PaletteContent: Class representing global palette of objects that can be dragged onto other controls. For a discussion of setting up a palette, see Using a Palette.
PaletteItem: Item on a palette. For a discussion of using a palette, see Using a Palette.
StandardViewModels: Obtains a TypeCatalog of all the Sce.Atf.Wpf.Models namespace's extensions (plus Sce.Atf.Wpf.ViewModelRepository) for ready inclusion in an AggregateCatalog so that these extensions can be used easily.
*StatusBarViewModel: View model for a status bar.
TargetDialogViewModel: View model for a target dialog.
TargetViewModel: View model for a Target.
*ToolBarViewModel: View model for an application's tool bars.
TreeViewModel: View model for a TreeView.
These classes handle application skinning. For more information on skins in ATF, see SkinService Component.
Skin: Abstract base class to assist with loading skin resources.
This namespace provides classes that perform various type conversions, typically for converting bound values.
AdaptingCollectionValueConverter<T,U>: Value converter to convert an IObservableCollection of one type to an IObservableCollection of another type using the IAdaptable interface, where T is a collection class and U is another collection class.
AdaptingValueConverter<T,U>: Value converter to convert backwards and forwards between two types using the IAdaptable interface, where T is the original type and U is the adapted type.
BoolVisibilityConverter: Value converter that sets an item's visibility based on its Boolean value.
BrushToColorConverter: Converts a Brush to a Color.
ColorToBrushConverter: Converts a Color to a SolidColorBrush.
DisplayStringConverter: Converter used on any type, overriding the standard behavior of ToString() for enumeration values.
EnumDescriptionConverter: Converter for an enumeration to a description.
EnumToBoolConverter: Converter for enum to Boolean.
EnumValuesConverter: Converter for enumeration value to array of values of constants.
InputGestureTextConverter: Converts InputGestureCollection to a single KeyGesture string by taking first available KeyGesture.
InterfaceTemplateSelector: WPF does not provide automatic data template selection based on interfaces (only based on concrete types). This is due to problems with multiple inheritance of interfaces. This selector ignores these problems by searching for a data template for each interface implemented on a type until one is found and then stopping.
IntToBoolConverter: Converter for int to Boolean.
IntToVisibilityConverter: Converts an int to a Visibility value.
IsAssignableFromConverter: Converter for whether type passed as parameter is assignable from type of value.
IsNullConverter: Converter for whether or not an object is null.
ItemToCollectionConverter: Converts a single value to a collection.
ListToStringConverter: Converter for list to string.
MenuItemStyleSelector: Selector for menu item styles.
ResourceLookupConverter: Converter for a UI resource using the input value as a resource key.
RoundDoubleConverter: Converter for rounding a double value.
SimpleAdaptingValueConverter: Value converter to convert one-way to an adapted type using IAdaptable.
TimeSpanFormatConverter: Converter for TimeSpan to another format.
TimeSpanToVisibilityConverter: Converter for TimeSpan to Visibility.
ToDoubleConverter: Allows conversion from int, long, byte, double, and float, to double.
TypeConverter: General converter from one type to another.
VisibilityToBoolConverter: Converts a Visibility value to a Boolean.
- 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