static void Main()
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Create a catalog with all the components that make up the application, except for
// our MainForm.
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(CommandService), // handles commands in menus and toolbars
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(HelpAboutCommand), // Help -> About command
typeof(FolderViewer), // manages TreeControl to display folder hierarchy
typeof(FileViewer), // managed ListView to display last selected folder contents
typeof(NameDataExtension), // extension to display file name
typeof(SizeDataExtension), // extension to display file size
typeof(CreationTimeDataExtension), // extension to display file creation time
typeof(UserFeedbackService), // component to send feedback form to SHIP
typeof(VersionUpdateService), // component to update to latest version on SHIP
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
var container = new CompositionContainer(catalog);
// manually add the MainForm
var batch = new CompositionBatch();
var mainForm = new MainForm
{
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// our custom main Form with SplitContainer
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-File-Explorer-Sample".Localize()));
container.Compose(batch);
// initialize all components which require it
container.InitializeAll();
Application.Run(mainForm);
container.Dispose();
}
/// <summary>
/// Initialize composition.
/// When you need to manage your components with this mainform, you can ask MainForm to initialize your components
/// </summary>
/// <param name="catalog">Type catalog to initialize</param>
/// <param name="sharedComponent">Shared component or pre-created batch objects</param>
public void InitializeComposition(TypeCatalog catalog, List <object> sharedComponent)
{
var container = new CompositionContainer(catalog);
CompositionBatch compositionBatch = new CompositionBatch();
if (sharedComponent != null)
{
foreach (var part in sharedComponent)
{
compositionBatch.AddPart(part);
}
}
compositionBatch.AddPart(this);
container.Compose(compositionBatch);
container.InitializeAll();
m_componentContainer = container;
}
static void CreateSharedMain()
{
// Create a type catalog with the types of components we want in the application
TypeCatalog catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(ErrorDialogService) // displays errors to the user in a message box
);
StandardEditCommands.UseSystemClipboard = true;
CompositionContainer sharedContainer = new CompositionContainer(catalog);
// Configure the main Form
var batch = new CompositionBatch();
m_toolMainForm = new ToolMainForm()
{
Text = "Diagram Editor Main".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Add the main Form instance to the container
batch.AddPart(m_toolMainForm);
sharedContainer.Compose(batch);
sharedContainer.InitializeAll();
m_SharedComponents.Add(sharedContainer.GetExportedValue <SettingsService>());
m_SharedComponents.Add(sharedContainer.GetExportedValue <UnhandledExceptionService>());
m_SharedComponents.Add(sharedContainer.GetExportedValue <IFileDialogService>());
m_SharedComponents.Add(sharedContainer.GetExportedValue <ErrorDialogService>());
m_SharedContainer = sharedContainer;
}
static void Main()
{
//// important to call these before creating application host
//Application.EnableVisualStyles();
//Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
//// Set up localization support early on, so that user-readable strings will be localized
//// during the initialization phase below. Use XML files that are embedded resources.
//Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
//Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
//// Enable metadata driven property editing for the DOM
//DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator<CustomTypeDescriptorNodeAdapter>());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
using (
var catalog =
new TypeCatalog(
/* Standard ATF stuff */
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(Outputs), // passes messages to all log writers
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(DocumentRegistry), // central document registry with change notification
typeof(FileDialogService), // standard Windows file dialogs
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(PaletteService), // global palette, for drag/drop instancing
typeof(PropertyEditor), // property grid for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
typeof(SchemaLoader),
typeof(PaletteClient), // component which adds items to palette
typeof(Editor) // tree list view editor component
))
{
using (var container = new CompositionContainer(catalog))
{
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
using (var mainForm = new MainForm(toolStripContainer))
{
mainForm.Text = "SceneEditor".Localize();
mainForm.Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage));
var batch = new CompositionBatch();
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Tree-List-Editor-Sample".Localize()));
container.Compose(batch);
container.InitializeAll();
//// Set the switch level for the Atf TraceSource instance so everything is traced.
//Outputs.TraceSource.Switch.Level = SourceLevels.All;
//// a very verbose data display that includes callstacks
//Outputs.TraceSource.Listeners["Default"].TraceOutputOptions =
// TraceOptions.Callstack | TraceOptions.DateTime |
// TraceOptions.ProcessId | TraceOptions.ThreadId |
// TraceOptions.Timestamp;
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
}
}
}
static void Main()
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(SettingsServiceCommands), // Setting service commands
typeof(FileDialogService), // proivdes standard Windows file dialogs, to let the user open and close files. Used by SkinService.
typeof(SkinService), // allows for customization of an application’s appearance by using inheritable properties that can be applied at run-time
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(HelpAboutCommand), // Help -> About command
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(ContextRegistry), // component that tracks application contexts; needed for context menu
// add target info plugins and TargetEnumerationService
typeof(Deci4pTargetProvider), // provides information about development devices available via Deci4p
typeof(TcpIpTargetProvider), // provides information about development devices available via TCP/IP
typeof(TargetCommands), // commands to operate on currently selected targets.
typeof(TargetEnumerationService) // queries and enumerates target objects, consuming target providers created by the application
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form
var batch = new CompositionBatch();
var mainForm = new MainForm(new ToolStripContainer())
{
Text = "ATF TargetManager Sample".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Add the main Form instance to the container
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Target-Manager-Sample".Localize()));
container.Compose(batch);
var controlHostService = container.GetExportedValue <ControlHostService>();
controlHostService.RegisteredCommands = ControlHostService.CommandRegister.None; // turn off standard window commands for simpele & single window UI
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main(string[] args)
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(SettingsServiceCommands), // Setting service commands
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
//typeof(StandardLockCommands), // standard Edit menu lock/unlock commands
typeof(HelpAboutCommand), // Help -> About command
typeof(PaletteService), // global palette, for drag/drop instancing
typeof(HistoryLister), // visual list of undo/redo stack
typeof(PropertyEditor), // property grid for editing selected objects
typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
typeof(Outputs), // passes messages to all log writers
typeof(ErrorDialogService), // displays errors to the user in a message box
typeof(HelpAboutCommand), // custom command component to display Help/About dialog
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(Editor), // editor which manages event sequence documents
typeof(DomTypes), // defines the DOM's metadata for this sample app
typeof(PaletteClient), // component which adds items to palette
typeof(EventListEditor), // adds drag/drop and context menu to event sequence ListViews
typeof(ResourceListEditor), // adds "slave" resources ListView control, drag/drop and context menu
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form and add it to the composition container
var batch = new CompositionBatch();
var toolStripContainer = new ToolStripContainer();
var mainForm = new MainForm(toolStripContainer)
{
Text = "Simple DOM, No XML, Editor Sample".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Simple-DOM-No-XML-Editor-Sample".Localize()));
// Compose the MEF container
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main()
{
// Important to call these before starting the app. Otherwise theming and bitmaps may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Using MEF, declare the composable parts that will make up this application
TypeCatalog catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(WindowLayoutService), // service to allow multiple window layouts
typeof(WindowLayoutServiceCommands), // command layer to allow easy switching between and managing of window layouts
// Client-specific plug-ins
typeof(Editor), // editor class component that creates and saves application documents
typeof(SchemaLoader), // loads schema and extends types
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
// Create the MEF container for the composable parts
CompositionContainer container = new CompositionContainer(catalog);
// Create the main form, give it a toolstrip
ToolStripContainer toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
MainForm mainForm = new MainForm(toolStripContainer)
{
Text = "Sample Application".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Create an MEF composable part from the main form, and add into container
CompositionBatch batch = new CompositionBatch();
AttributedModelServices.AddPart(batch, mainForm);
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
// Create a type catalog with the types of components we want in the application
var catalog = new TypeCatalog(
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService),
typeof(SkinService),
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(StandardEditHistoryCommands), // tracks document changes and updates main form title
typeof(HelpAboutCommand), // Help -> About command
typeof(ContextRegistry), // central context registry with change notification
typeof(PropertyEditor), // property grid for editing selected objects
typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor
typeof(SettingsService),
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService), // provides facilities to run an automated script using the .NET remoting service
typeof(SchemaLoader), // component that loads XML schema and sets up types
typeof(Editor) // component that manages UI documents
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form
// Configure the main Form with a ToolStripContainer so the CommandService can
// generate toolbars.
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
var mainForm = new MainForm(toolStripContainer)
{
Text = "DOM Property Editor".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Add the main Form instance to the container
var batch = new CompositionBatch();
batch.AddPart(mainForm);
// batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-DOM-Tree-Editor-Sample".Localize()));
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
var propEditor = container.GetExportedValue <PropertyEditor>();
propEditor.PropertyGrid.PropertySorting = Sce.Atf.Controls.PropertyEditing.PropertySorting.Categorized;
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main()
{
// It's important to call these before starting the app; otherwise theming and bitmaps
// may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Register the embedded image resources so that they will be available for all users of ResourceUtil,
// such as the PaletteService.
ResourceUtil.Register(typeof(Resources));
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
// Create a type catalog with the types of components we want in the application
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(SkinService),
typeof(DocumentRegistry), // central document registry with change notification
typeof(FileDialogService), // standard Windows file dialogs
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(HelpAboutCommand), // Help -> About command
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(PaletteService), // global palette, for drag/drop instancing
typeof(HistoryLister), // visual list of undo/redo stack
typeof(PropertyEditor), // property grid for editing selected objects
typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
typeof(CurveEditor), // edits curves using the CurveEditingControl
typeof(SchemaLoader), // component that loads XML schema and sets up types
typeof(Editor), // component that manages UI documents
typeof(PaletteClient), // component that adds UI types to palette
typeof(TreeLister), // component that displays the UI in a tree control
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(DomExplorer), // component that gives diagnostic view of DOM
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form with a ToolStripContainer so the CommandService can
// generate toolbars.
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
var mainForm = new MainForm(toolStripContainer)
{
Text = "Dom Tree Editor".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Add the main Form instance to the container
var batch = new CompositionBatch();
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-DOM-Tree-Editor-Sample".Localize()));
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Example of programmatic layout creation:
{
var windowLayoutService = container.GetExportedValue <IWindowLayoutService>();
var dockStateProvider = container.GetExportedValue <IDockStateProvider>();
// Load custom XML and add it to the Window Layout Service
int layoutNum = 0;
Assembly assembly = Assembly.GetExecutingAssembly();
foreach (string resourceName in assembly.GetManifestResourceNames())
{
if (resourceName.Contains("Layout") && resourceName.EndsWith(".xml"))
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(assembly.GetManifestResourceStream(resourceName));
layoutNum++;
windowLayoutService.SetOrAddLayout(dockStateProvider, "Programmatic Layout " + layoutNum, xmlDoc.InnerXml);
}
}
}
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main(string[] args)
{
// This startup sequence is based on the "Circuit editor" sample in the Sony ATF repo
// We want to take advantage of the ATF implementations whereever they exist, but we'll
// remove the parts that are specific to that circuit editor sample app.
// It's important to call these before starting the app; otherwise theming and bitmaps
// may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// early engine initialization
var engineDevice = new GUILayer.EngineDevice();
GC.KeepAlive(engineDevice);
var attach0 = new ShaderPatcherLayer.LibraryAttachMarker(engineDevice);
GC.KeepAlive(attach0);
XLEBridgeUtils.Utils.AttachLibrary(engineDevice);
var logRedirect = new XLEBridgeUtils.LoggingRedirect();
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
// Create a type catalog with the types of components we want in the application
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
// typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
// typeof(AtfUsageLogger), // logs computer info to an ATF server
// typeof(CrashLogger), // logs unhandled exceptions to an ATF server
// typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(HelpAboutCommand), // Help -> About command
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardFileExitCommand), // standard File exit menu command
// typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
// typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(StandardLayoutCommands), // standard Format menu layout commands
typeof(StandardViewCommands), // standard View menu commands
// typeof(PaletteService), // global palette, for drag/drop instancing
typeof(PropertyEditor), // property grid for editing selected objects
typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
typeof(HistoryLister), // visual list of undo/redo stack
typeof(PrototypeLister), // editable palette of instantiable item groups
typeof(LayerLister), // editable tree view of layers
typeof(Outputs), // passes messages to all log writers
// typeof(ErrorDialogService), // displays errors to the user in a message box
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(DomRecorder), // records and displays changes to the DOM for diagnostic purposes
typeof(Editor), // editor which manages circuit documents and controls
// typeof(SchemaLoader), // loads circuit schema and extends types
// typeof(GroupingCommands), // circuit group/ungroup commands
typeof(DiagramControlRegistry), // circuit controls management
// typeof(LayeringCommands), // "Add Layer" command
// typeof(GraphViewCommands), // zooming with presets
typeof(PerformanceMonitor), // displays the frame rate and memory usage
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
// typeof(ModulePlugin), // component that defines circuit module types
// typeof(TemplateLister), // template library for subgraph referencing or instancing
// typeof(TemplatingCommands), // commands for promoting/demoting graph elements to/from template library
//typeof(TemplatingSupervisor), // templated instances copy-on-edit support(optionally)
typeof(AnnotatingCommands), // annotating commands
// typeof(CircuitTestCommands), // circuit tester commands
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService), // provides facilities to run an automated script using the .NET remoting service
typeof(SkinService),
typeof(ShaderPatcherLayer.Manager),
typeof(ShaderFragmentArchive.Archive),
typeof(Controls.DiagramControl),
typeof(Controls.ShaderFragmentArchiveControl),
typeof(Controls.DiagramLister),
typeof(NodeEditorCore.ShaderFragmentArchiveModel),
typeof(NodeEditorCore.ModelConversion),
typeof(NodeEditorCore.ShaderFragmentNodeCreator),
typeof(NodeEditorCore.DiagramDocument),
typeof(ControlsLibraryExt.Commands.CommonCommands),
typeof(ControlsLibraryExt.Material.MaterialInspector),
typeof(ControlsLibraryExt.Material.MaterialSchemaLoader),
typeof(ControlsLibraryExt.ModelView.ActiveModelView),
typeof(ActiveMaterialContext),
typeof(DiagramCommands)
);
// enable use of the system clipboard
StandardEditCommands.UseSystemClipboard = true;
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// This is bit wierd, but we're going to add the container to itself.
// This will create a tight circular dependency, of course
// It's also not ideal by the core DI pattern.
// But it's useful for us, because we want to use the same container to construct
// objects (and also to retrieve global instances).
container.ComposeExportedValue <ExportProvider>(container);
container.ComposeExportedValue <CompositionContainer>(container);
// Configure the main Form
var batch = new CompositionBatch();
var mainForm = new MainForm(new ToolStripContainer())
{
Text = Application.ProductName //,
// Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
// Sce.Atf.Direct2D.D2dFactory.EnableResourceSharing(mainForm.Handle);
// Add the main Form instance, etc., to the container
batch.AddPart(mainForm);
// batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Circuit-Editor-Sample".Localize()));
container.Compose(batch);
// We need to attach compilers for models, etc
engineDevice.AttachDefaultCompilers();
container.InitializeAll();
// if there is a model filename on the command line, we will load it into our viewer
if (args != null && args.Length > 0)
{
var a = args[0];
if (string.Equals(System.IO.Path.GetExtension(a), ".dae", StringComparison.OrdinalIgnoreCase))
{
// Insert a delegate to be executed after the AutoDocumentService has run. That is attached
// to the "Loaded" event in the main form, also -- so this should occur afterwards
// This way we can pop our window to the top, after the auto load documents appear
mainForm.Loaded += delegate(object o, EventArgs eventArgs)
{
var modelView = container.GetExport <ControlsLibraryExt.ModelView.ActiveModelView>().Value;
if (modelView != null)
{
modelView.LoadFromCommandLine(a);
var hostService = container.GetExport <IControlHostService>().Value;
if (hostService != null)
{
hostService.Show(modelView.Control);
}
// unfortunately we can't suppress the autoload documents stuff from here!
}
};
}
}
Application.Run(mainForm);
container.Dispose();
mainForm.Dispose();
logRedirect.Dispose();
engineDevice.PrepareForShutdown();
XLEBridgeUtils.Utils.DetachLibrary();
attach0.Dispose();
engineDevice.Dispose();
}
static void Main()
{
// It's important to call these before starting the app; otherwise theming and bitmaps
// may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
//Engine engine = new Engine();
//engine.StartEngine();
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
// Create a type catalog with the types of components we want in the application
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
//typeof(StatusService), // status bar at bottom of main Form
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(VS2CMakeContext),
typeof(DomNodeRefDictionary),
typeof(VS2CMakeImport),
typeof(VS2CMakeGenerateCMake),
typeof(Outputs), // passes messages to all log writers
typeof(ErrorDialogService), // displays errors to the user in a message box
typeof(ConsoleOutputWriter)
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form
var batch = new CompositionBatch();
var mainForm = new ConsoleMainForm()
{
Text = Application.ProductName,
};
// Add the main Form instance, etc., to the container
batch.AddPart(mainForm);
container.Compose(batch);
container.InitializeAll();
mainForm.Run();
mainForm.Close();
// Give components a chance to clean up.
container.Dispose();
//engine.StopEngine();
}
static void Main()
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
using (
var catalog =
new TypeCatalog(
/* Standard ATF stuff */
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(Outputs), // passes messages to all log writers
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(UserFeedbackService), // displaying a dialog box that allows the user to submit a bug report to SHIP
typeof(VersionUpdateService), // updates to latest version on SHIP
typeof(ContextRegistry), // central context registry with change notification
typeof(PropertyEditor), // property grid for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
/* Different styles of TreeListView */
typeof(List), // list view editor component
typeof(CheckedList), // checked list view editor component
typeof(VirtualList), // virtual list view editor component
typeof(TreeList), // tree list view editor component
typeof(CheckedTreeList), // checked tree list view editor component
/* Use the TreeListView as a normal Control */
typeof(RawTreeListView), // tree list view editor for hierarchical file system component
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
))
{
using (var container = new CompositionContainer(catalog))
{
using (var mainForm = new MainForm())
{
mainForm.Text = "TreeListView Sample".Localize();
mainForm.Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage));
var batch = new CompositionBatch();
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Tree-List-Editor-Sample".Localize()));
container.Compose(batch);
container.InitializeAll();
// Set the switch level for the Atf TraceSource instance so everything is traced.
Outputs.TraceSource.Switch.Level = SourceLevels.All;
// a very verbose data display that includes callstacks
Outputs.TraceSource.Listeners["Default"].TraceOutputOptions =
TraceOptions.Callstack | TraceOptions.DateTime |
TraceOptions.ProcessId | TraceOptions.ThreadId |
TraceOptions.Timestamp;
Application.Run(mainForm);
}
}
}
}
static void Main()
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(AtfUsageLogger), // logs computer info to an ATF server
#if !DEBUG
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
#endif
typeof(DomExplorer), //Debug view the DOM
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable Ctrl+tab selection of documents and controls within the app
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(HelpAboutCommand), // Help -> About command
typeof(PropertyEditor), // property grid for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor
typeof(Outputs), // passes messages to all log writers
typeof(ErrorDialogService), // displays errors to the user a in message box
typeof(HelpAboutCommand), // custom command component to display Help/About dialog
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService), // provides facilities to run an automated script using the .NET remoting service
//Worldsmith stuff
typeof(SchemaLoader), //Loads the schema
typeof(Project.DotaVPKService), //Handles the VPK stuff, including reading from the VPK and building the DOM node
//UI Elements
typeof(ProjectTreeLister),
typeof(UnitTreeLister),
typeof(TextEditing.TextEditor),
typeof(DotaVPKTreeLister),
typeof(KeyValueEditor),
// typeof(UnitPropertyEditor),
//Commands
typeof(ProjectCommands),
typeof(TreeListCommands),
typeof(KeyValueCommands)
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form
var batch = new CompositionBatch();
var toolStripContainer = new ToolStripContainer();
var mainForm = new MainForm(toolStripContainer)
{
Text = "Worldsmith".Localize(),
Icon = GdiUtil.CreateIcon(WorldsmithATF.Properties.Resources.WSIcon32)
};
// Add the main Form instance to the container
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("http://www.worldsmith.net".Localize()));
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main()
{
// It's important to call these before starting the app; otherwise theming and bitmaps
// may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Enable metadata driven property editing for the DOM
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
// Create a type catalog with the types of components we want in the application
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(SettingsServiceCommands), // Setting service commands
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
//typeof(AtfUsageLogger), // logs computer info to an ATF server
//typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
//typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(HelpAboutCommand), // Help -> About command
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(StandardLayoutCommands), // standard Format menu layout commands
typeof(StandardViewCommands), // standard View menu commands
//StandardPrintCommands does not currently work with Direct2D
//typeof(StandardPrintCommands), // standard File menu print commands
typeof(PaletteService), // global palette, for drag/drop instancing
typeof(MyPropertyEditor), // property grid for editing selected objects; uses tooltips to show property descriptions
//typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
typeof(DomNodeRefDictionary), // Reference dictionary
typeof(HistoryLister), // visual list of undo/redo stack
typeof(PrototypeLister), // editable palette of instantiable item groups
typeof(LayerLister), // editable tree view of layers
typeof(Outputs), // passes messages to all log writers
// typeof(ErrorDialogService), // displays errors to the user in a message box
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(DomRecorder), // records and displays changes to the DOM for diagnostic purposes
typeof(VisualScriptEditor), // editor which manages circuit documents and controls
typeof(VisualScriptTypeManager), // loads circuit schema and extends types
typeof(GroupingCommands), // circuit group/ungroup commands
typeof(CircuitControlRegistry), // circuit controls management
typeof(LayeringCommands), // "Add Layer" command
typeof(GraphViewCommands), // zooming with presets
//typeof(PerformanceMonitor), // displays the frame rate and memory usage
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(ScriptNodeDefinitionManager), // component that defines circuit module types
typeof(TemplateLister), // template library for subgraph referencing or instancing
typeof(TemplatingCommands), // commands for promoting/demoting graph elements to/from template library
//typeof(TemplatingSupervisor), // templated instances copy-on-edit support(optionally)
typeof(AnnotatingCommands), // annotating commands
typeof(DynamicPropertyCommands), // context commands for user-defined properties in the property editors
typeof(ExpressionCommands), //
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
// enable use of the system clipboard
StandardEditCommands.UseSystemClipboard = true;
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
// Configure the main Form
var batch = new CompositionBatch();
var mainForm = new MainForm(new ToolStripContainer())
{
Text = Application.ProductName,
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
Sce.Atf.Direct2D.D2dFactory.EnableResourceSharing(mainForm.Handle);
// Add the main Form instance, etc., to the container
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Circuit-Editor-Sample".Localize()));
container.Compose(batch);
// Add a customized category comparer to the object palette.
var paletteService = container.GetExportedValue <PaletteService>();
paletteService.CategoryComparer = new CategoryComparer();
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
}
static void Main()
{
// It's important to call these before starting the app; otherwise theming and bitmaps
// may not render correctly.
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
// Register the embedded image resources so that they will be available for all users of ResourceUtil,
// such as the PaletteService.
ResourceUtil.Register(typeof(Resources));
// enable metadata driven property editing
DomNodeType.BaseOfAllTypes.AddAdapterCreator(new AdapterCreator <CustomTypeDescriptorNodeAdapter>());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(LiveConnectService), // allows easy interop between apps on same router subnet
typeof(Outputs), // passes messages to all IOutputWriter components
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(FileDialogService), // standard Windows file dialogs
typeof(DocumentRegistry), // central document registry with change notification
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(ContextRegistry), // central context registry with change notification
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(RenameCommand), // allows for renaming of multiple selected objects
//StandardPrintCommands does not currently work with Direct2D
//typeof(StandardPrintCommands), // standard File menu print commands
typeof(PaletteService), // global palette, for drag/drop instancing
typeof(HistoryLister), // visual list of undo/redo stack
typeof(PropertyEditor), // property grid for editing selected objects
typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
typeof(PerformanceMonitor), // displays the frame rate and memory usage
typeof(FileWatcherService), // service to watch for changes to files
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(SkinService), // allows for customization of an application’s appearance by using inheritable properties that can be applied at run-time
// Client-specific plug-ins
typeof(TimelineEditor), // timeline editor component
typeof(TimelineCommands), // defines Timeline-specific commands
typeof(HelpAboutCommand), // Help -> About command
// Testing related
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service
);
var container = new CompositionContainer(catalog);
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
var mainForm = new MainForm(toolStripContainer)
{
Text = "Timeline Editor Sample".Localize(),
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
var batch = new CompositionBatch();
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Timeline-Editor-Sample".Localize()));
container.Compose(batch);
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
container.Dispose();
}
static void Main(string[] args)
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
typeof(FileDialogService), // standard Windows file dialogs
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(Outputs), // service that provides static methods for writing to IOutputWriter objects.
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(HelpAboutCommand), // Help -> About command
typeof(AtfUsageLogger), // logs computer info to an ATF server
typeof(CrashLogger), // logs unhandled exceptions to an ATF server
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(ContextRegistry), // central context registry with change notification
typeof(DocumentRegistry), // central document registry with change notification
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(Editor), // code editor component
typeof(PythonService), // scripting service for automated tests
typeof(ScriptConsole), // provides a dockable command console for entering Python commands
typeof(AtfScriptVariables), // exposes common ATF services as script variables
typeof(AutomationService), // provides facilities to run an automated script using the .NET remoting service
typeof(PerforceService), // Perforce plugin
typeof(SourceControlCommands), // source control commmands to interact with Perforce plugin
typeof(SourceControlContext) // source control context component
);
var container = new CompositionContainer(catalog);
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
var mainForm = new MainForm(toolStripContainer);
var image = GdiUtil.GetImage("CodeEditor.Resources.File_edit.ico");
mainForm.Icon = GdiUtil.CreateIcon(image, 32, true);
mainForm.Text = "Code Editor".Localize();
var batch = new CompositionBatch();
batch.AddPart(mainForm);
batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-Code-Editor-Sample".Localize()));
container.Compose(batch);
// To make the tab commands (e.g., "Copy Full Path", "Open Containing Folder") available, we have to change
// the default behavior to work with this sample app's unusual Editor. In most cases, an editor like this
// would implement IDocumentClient and this customization of DefaultTabCommands wouldn't be necessary.
var tabCommands = container.GetExportedValue <DefaultTabCommands>();
tabCommands.IsDocumentControl = controlInfo => controlInfo.Client is Editor;
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
container.Dispose();
}
static void Main()
{
// important to call these before creating application host
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714
#if true
// Set up localization support early on, so that user-readable strings will be localized
// during the initialization phase below. Use XML files that are embedded resources.
Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer());
var catalog = new TypeCatalog(
typeof(SettingsService), // persistent settings and user preferences dialog
typeof(StatusService), // status bar at bottom of main Form
typeof(CommandService), // handles commands in menus and toolbars
typeof(ControlHostService), // docking control host
typeof(WindowLayoutService), // multiple window layout support
typeof(WindowLayoutServiceCommands), // window layout commands
typeof(FileDialogService), // standard Windows file dialogs
typeof(AutoDocumentService), // opens documents from last session, or creates a new document, on startup
typeof(Outputs), // service that provides static methods for writing to IOutputWriter objects.
typeof(OutputService), // rich text box for displaying error and warning messages. Implements IOutputWriter.
typeof(RecentDocumentCommands), // standard recent document commands in File menu
typeof(StandardFileCommands), // standard File menu commands for New, Open, Save, SaveAs, Close
typeof(StandardFileExitCommand), // standard File exit menu command
typeof(StandardEditCommands), // standard Edit menu commands for copy/paste
typeof(StandardEditHistoryCommands), // standard Edit menu commands for undo/redo
typeof(StandardSelectionCommands), // standard Edit menu selection commands
typeof(HelpAboutCommand), // Help -> About command
typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save
typeof(ContextRegistry), // central context registry with change notification
typeof(DocumentRegistry), // central document registry with change notification
typeof(MainWindowTitleService), // tracks document changes and updates main form title
typeof(TabbedControlSelector), // enable ctrl-tab selection of documents and controls within the app
typeof(DefaultTabCommands), // provides the default commands related to document tab Controls
typeof(PropertyEditor), // property grid for editing selected objects
//typeof(GridPropertyEditor), // grid control for editing selected objects
typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor, like Reset,
// Reset All, Copy Value, Paste Value, Copy All, Paste All
typeof(Editor), // code editor component
typeof(SchemaLoader), // loads schema and extends types
typeof(CharacterEditor),
typeof(CharacterSettingsCommands)
);
// Set up the MEF container with these components
var container = new CompositionContainer(catalog);
var toolStripContainer = new ToolStripContainer();
toolStripContainer.Dock = DockStyle.Fill;
var mainForm = new MainForm(toolStripContainer);
mainForm.Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage));
mainForm.Text = "Butterfly Engine".Localize();
var batch = new CompositionBatch();
batch.AddPart(mainForm);
container.Compose(batch);
// To make the tab commands (e.g., "Copy Full Path", "Open Containing Folder") available, we have to change
// the default behavior to work with this sample app's unusual Editor. In most cases, an editor like this
// would implement IDocumentClient and this customization of DefaultTabCommands wouldn't be necessary.
var tabCommands = container.GetExportedValue <DefaultTabCommands>();
tabCommands.IsDocumentControl = controlInfo => controlInfo.Client is Editor;
// Initialize components that require it. Initialization often can't be done in the constructor,
// or even after imports have been satisfied by MEF, since we allow circular dependencies between
// components, via the System.Lazy class. IInitializable allows components to defer some operations
// until all MEF composition has been completed.
container.InitializeAll();
// Show the main form and start message handling. The main Form Load event provides a final chance
// for components to perform initialization and configuration.
Application.Run(mainForm);
// Give components a chance to clean up.
container.Dispose();
#else
var mainForm = new FormTest
{
Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage))
};
Application.Run(mainForm);
#endif
}