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(); }
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(PropertyEditor), // property grid for editing selected objects typeof(GridPropertyEditor), // grid control for editing selected objects typeof(PropertyEditingCommands), // commands for PropertyEditor and GridPropertyEditor 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() { // 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(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(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); // 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 }
public static void Main(string[] args) { // 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(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(SkinService), // skin service. 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(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(PrototypeLister), // editable palette of instantiable item groups typeof(Outputs), // passes messages to all log writers typeof(ErrorDialogService), // displays errors to the user in a message box typeof(Editor), // editor which manages FSM documents and controls typeof(PaletteClient), // component which adds items to palette typeof(DefaultTabCommands), // provides the default commands related to document tab Controls 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 ); // 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 to the container batch.AddPart(mainForm); batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-FSM-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); // 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(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() { // 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 /* 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(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() { // 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(); Application.Run(mainForm); container.Dispose(); mainForm.Dispose(); logRedirect.Dispose(); engineDevice.PrepareForShutdown(); XLEBridgeUtils.Utils.DetachLibrary(); attach0.Dispose(); engineDevice.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(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(PropertyEditor), // property grid for editing selected objects typeof(GridPropertyEditor), // grid control 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(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(); }