コード例 #1
0
        private void AddPageToPackage(IOptionsPage page, dynamic package, Type packageType)
        {
            try
            {
                var container = default(Container);
                // If we have access to the container field, we can add any kind of page.
                container = (Container)package._pagesAndProfiles;

                if (container == null)
                {
                    // Calling GetDialogPage with a dummy page type will cause the
                    // container to be initialized and the given page to be cached. This
                    // is harmless since there is no accompanying registry information
                    // for a page with this dummy guid, and hence it never shows up
                    // on the UI.
                    package.GetDialogPage(GetDummyPage(packageType));
                    // Get the value again. It would be non-null this time.
                    container = (Container)package._pagesAndProfiles;

                    Debug.Assert(container != null, "Failed to initialize internal container for dialog pages in the package.");
                }

                if (container != null)
                {
                    container.Add(page);
                }
            }
            catch (RuntimeBinderException)
            {
                throw new NotSupportedException(Strings.OptionsManager.Unsupported);
            }
        }
コード例 #2
0
 private void NotifyRemove(IOptionsPage value)
 {
     if (this.activePage != value)
     {
         return;
     }
     this.activePage = (IOptionsPage)null;
 }
コード例 #3
0
            public void Insert(int index, IOptionsPage value)
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                IConfigurationObject configurationObject = this.configurationService["Options." + value.Name];

                value.Load(configurationObject);
                this.pages.Insert(index, value);
            }
コード例 #4
0
        public void Setup()
        {
            var pagePlatform = Environment.GetPagePlatformFromEnvironment(executingPlatform, localPreference);

            app       = Configure(pagePlatform);
            container = ContainerConfig.Configure(app, pagePlatform);

            mainPage     = container.Resolve <IMainPage> ();
            optionsPage  = container.Resolve <IOptionsPage> ();
            shippingPage = container.Resolve <IShippingPage> ();
        }
      public void SetUp ()
      {
        _extensionMock = MockRepository.GenerateMock<ILicenseHeaderExtension> ();
        _optionsPage = MockRepository.GenerateMock<IOptionsPage>();
        _replacer = new LicenseHeaderReplacer (_extensionMock);
        _projectItem = MockRepository.GenerateMock<ProjectItem> ();
        _languagesPage = MockRepository.GenerateMock<ILanguagesPage>();
        _extensionMock.Expect (x => x.LanguagesPage).Return (_languagesPage);
        _extensionMock.Expect (x => x.OptionsPage).Return (_optionsPage);
        _optionsPage.Expect (x => x.UseRequiredKeywords).Return (true);
        _optionsPage.Expect (x => x.RequiredKeywords).Return ("");

        _projectItem.Stub(x => x.Open(Constants.vsViewKindTextView)).Return(MockRepository.GenerateMock<Window>());
      }
コード例 #6
0
            public void SetUp()
            {
                _extensionMock = MockRepository.GenerateMock <ILicenseHeaderExtension>();
                _optionsPage   = MockRepository.GenerateMock <IOptionsPage>();
                _replacer      = new LicenseHeaderReplacer(_extensionMock);
                _projectItem   = MockRepository.GenerateMock <ProjectItem>();
                _languagesPage = MockRepository.GenerateMock <ILanguagesPage>();
                _extensionMock.Expect(x => x.LanguagesPage).Return(_languagesPage);
                _extensionMock.Expect(x => x.OptionsPage).Return(_optionsPage);
                _optionsPage.Expect(x => x.UseRequiredKeywords).Return(true);
                _optionsPage.Expect(x => x.RequiredKeywords).Return("");

                _projectItem.Stub(x => x.Open(Constants.vsViewKindTextView)).Return(MockRepository.GenerateMock <Window>());
            }
コード例 #7
0
        /// <summary>
        /// Adds the page to the manager using the given owning package identifier.
        /// </summary>
        public void AddPage(IOptionsPage page)
        {
            var pageType = page.GetType();
            var categoryName = pageType.ComponentModel().Category ?? "";
            var displayName = pageType.ComponentModel().DisplayName ?? "";

            if (string.IsNullOrEmpty(categoryName))
                throw new ArgumentException(Strings.OptionsManager.PageCategoryRequired(page.GetType()));

            if (string.IsNullOrEmpty(categoryName))
                throw new ArgumentException(Strings.OptionsManager.PageDisplayNameRequired(page.GetType()));

            //TODO: validate attributes on the type, write to registry, etc.
            RegisterOptionsPage(registryRoot, serviceProvider.GetPackageGuidOrThrow(), categoryName, displayName, pageType);

            // Need to load the page into the collection for the owning package.
            AddPageToPackage(page, serviceProvider.AsDynamicReflection(), serviceProvider.GetType());
        }
コード例 #8
0
        /// <summary>
        /// Adds the page to the manager using the given owning package identifier.
        /// </summary>
        public void AddPage(IOptionsPage page)
        {
            var pageType     = page.GetType();
            var categoryName = pageType.ComponentModel().Category ?? "";
            var displayName  = pageType.ComponentModel().DisplayName ?? "";

            if (string.IsNullOrEmpty(categoryName))
            {
                throw new ArgumentException(Strings.OptionsManager.PageCategoryRequired(page.GetType()));
            }

            if (string.IsNullOrEmpty(categoryName))
            {
                throw new ArgumentException(Strings.OptionsManager.PageDisplayNameRequired(page.GetType()));
            }

            //TODO: validate attributes on the type, write to registry, etc.
            RegisterOptionsPage(registryRoot, serviceProvider.GetPackageGuidOrThrow(), categoryName, displayName, pageType);

            // Need to load the page into the collection for the owning package.
            AddPageToPackage(page, serviceProvider.AsDynamicReflection(), serviceProvider.GetType());
        }
コード例 #9
0
        public void Load(IServices services)
        {
            this.services = services;
            ICommandService service1 = this.services.GetService <ICommandService>();

            this.services.GetService <IDocumentService>();
            IDocumentTypeManager   service2         = this.services.GetService <IDocumentTypeManager>();
            IViewService           service3         = this.services.GetService <IViewService>();
            IProjectManager        service4         = this.services.GetService <IProjectManager>();
            IAssemblyService       service5         = this.services.GetService <IAssemblyService>();
            IMessageDisplayService service6         = this.services.GetService <IMessageDisplayService>();
            IWindowService         service7         = this.services.GetService <IWindowService>();
            CodeOptionsModel       codeOptionsModel = new CodeOptionsModel();

            this.editingService = new EditingService((IServiceProvider)this.services, codeOptionsModel);
            this.services.AddService(typeof(ITextEditorService), (object)this.editingService);
            this.services.AddService(typeof(ITextBufferService), (object)this.editingService);
            ICodeProjectService codeProjectService = (ICodeProjectService) new CodeProjectService(service4, service5, service6, service3, service2);

            this.services.AddService(typeof(ICodeModelService), (object)new CodeModelService(this.services, codeProjectService));
            if (service2 != null)
            {
                this.csharpDocumentType = (IDocumentType) new CSharpDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.csharpDocumentType);
                this.visualBasicDocumentType = (IDocumentType) new VisualBasicDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.visualBasicDocumentType);
                this.javascriptDocumentType = (IDocumentType) new JavascriptDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.javascriptDocumentType);
                this.fSharpDocumentType = (IDocumentType) new FSharpDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.fSharpDocumentType);
                this.fSharpScriptDocumentType = (IDocumentType) new FSharpScriptDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.fSharpScriptDocumentType);
                this.fSharpTemplateDocumentType = (IDocumentType) new FSharpTemplateDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.fSharpTemplateDocumentType);
                this.cPlusPlusDocumentType = (IDocumentType) new CPlusPlusDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.cPlusPlusDocumentType);
                this.headerDocumentType = (IDocumentType) new HeaderDocumentType(codeProjectService, service3, codeOptionsModel, service7);
                service2.Register(this.headerDocumentType);
                this.htmlDocumentType = (IDocumentType) new HTMLDocumentType(this.editingService);
                service2.Register(this.htmlDocumentType);
                this.xmlDocumentType = (IDocumentType) new XmlDocumentType(this.editingService);
                service2.Register(this.xmlDocumentType);
                this.limitedXamlDocumentType = (IDocumentType) new LimitedXamlDocumentType(this.editingService);
                service2.Register(this.limitedXamlDocumentType);
                this.fxgDocumentType = (IDocumentType) new FxgDocumentType(this.editingService);
                service2.Register(this.fxgDocumentType);
            }
            IOptionsDialogService service8 = this.services.GetService <IOptionsDialogService>();

            if (service8 != null)
            {
                this.codeOptionsPage = (IOptionsPage) new CodeOptionsPage(this.editingService);
                service8.OptionsPages.Add(this.codeOptionsPage);
            }
            if (service1 == null)
            {
                return;
            }
            this.commandTarget = new CommandTarget();
            this.commandTarget.AddCommand("Project_EditVisualStudio", (ICommand) new EditVisualStudioCommand(service4, service1, service6));
            service1.AddTarget((ICommandTarget)this.commandTarget);
        }
コード例 #10
0
        private void AddPageToPackage(IOptionsPage page, dynamic package, Type packageType)
        {
            try
            {
                var container = default(Container);
                // If we have access to the container field, we can add any kind of page.
                container = (Container)package._pagesAndProfiles;

                if (container == null)
                {
                    // Calling GetDialogPage with a dummy page type will cause the 
                    // container to be initialized and the given page to be cached. This 
                    // is harmless since there is no accompanying registry information 
                    // for a page with this dummy guid, and hence it never shows up
                    // on the UI.
                    package.GetDialogPage(GetDummyPage(packageType));
                    // Get the value again. It would be non-null this time.
                    container = (Container)package._pagesAndProfiles;

                    Debug.Assert(container != null, "Failed to initialize internal container for dialog pages in the package.");
                }

                if (container != null)
                    container.Add(page);
            }
            catch (RuntimeBinderException)
            {
                throw new NotSupportedException(Strings.OptionsManager.Unsupported);
            }
        }
コード例 #11
0
 public void Remove(IOptionsPage value)
 {
     this.owner.NotifyRemove(value);
     this.pages.Remove(value);
 }
コード例 #12
0
ファイル: MainForm.cs プロジェクト: stever/windar
 void InitialiseModulesPage()
 {
     PlaydarModulesPage options;
     _optionsPage = options = new PlaydarModulesPage();
     _optionsPage.Load();
 }
コード例 #13
0
ファイル: MainForm.cs プロジェクト: stever/windar
        void InitialiseLibraryPage()
        {
            LibraryOptionsPage options;
            _optionsPage = options = new LibraryOptionsPage();
            _optionsPage.Load();

            // Load scan paths list.
            libraryGrid.Rows.Clear();
            foreach (string path in options.ScanPaths) libraryGrid.Rows.Add(GetScanPathRow(path));

            UpdateLibraryControls();

            // Deselect
            libraryGrid.CurrentCell = null;
            if (libraryGrid.Rows.Count <= 0) return;
            libraryGrid.Rows[0].Selected = false;

            // Sort
            libraryGrid.Sort(libraryGrid.Columns[0], ListSortDirection.Ascending);
        }
コード例 #14
0
ファイル: MainForm.cs プロジェクト: stever/windar
        void InitialiseGeneralOptionsPage()
        {
            GeneralOptionsPage options;
            _optionsPage = options = new GeneralOptionsPage();
            _optionsPage.Load();

            nodeNameTextBox.Text = options.NodeName;
            portTextBox.Text = options.Port.ToString();
            allowIncomingCheckBox.Checked = options.AllowIncoming;
            forwardCheckBox.Checked = options.ForwardQueries;
            //TODO: Autostart option.

            // Load peers table.
            peersGrid.Rows.Clear();
            foreach (PeerInfo peer in options.Peers) peersGrid.Rows.Add(GetPeerListRow(peer));
            peersGrid.CurrentCell = null;
            if (peersGrid.Rows.Count <= 0) return;
            peersGrid.Rows[0].Selected = false;
        }
コード例 #15
0
ファイル: MainForm.cs プロジェクト: stever/windar
 /// <summary>
 /// Check if changes. Require save or cancel changes.
 /// </summary>
 /// <returns>Returns true if ok to proceed, false otherwise.</returns>
 bool ApplyOptionsOrCancel()
 {
     if (Visible && _optionsPage != null && _optionsPage.Changed)
     {
         DialogResult result = Program.ShowYesNoCancelDialog("Save changes?");
         if (result == DialogResult.Cancel) return false;
         if (result == DialogResult.No) _optionsPage = null;
         else if (_optionsPage is GeneralOptionsPage) SaveGeneralOptions();
         else if (_optionsPage is LibraryOptionsPage) BuildLibrary(false);
         ResetOptionsPagesButtons();
     }
     return true;
 }
コード例 #16
0
ファイル: MainForm.cs プロジェクト: stever/windar
        void ReloadLibrarySettings()
        {
            // Attempt to reload the configuration files.
            // Don't continue to apply changes dialog if load fails.
            if (!Program.Instance.LoadConfiguration()) return;

            // Reload options.
            LibraryOptionsPage options;
            _optionsPage = options = new LibraryOptionsPage();
            _optionsPage.Load();

            // Load scan paths list.
            libraryGrid.Rows.Clear();
            foreach (string path in options.ScanPaths) libraryGrid.Rows.Add(GetScanPathRow(path));

            // Deselect
            libraryGrid.CurrentCell = null;
            if (libraryGrid.Rows.Count <= 0) return;
            libraryGrid.Rows[0].Selected = false;

            // Sort
            libraryGrid.Sort(libraryGrid.Columns[0], ListSortDirection.Ascending);
        }
コード例 #17
0
ファイル: MainForm.cs プロジェクト: stever/windar
 void InitialisePluginsPropertiesPage()
 {
     PluginPropertiesPage options;
     _optionsPage = options = new PluginPropertiesPage();
     _optionsPage.Load();
 }
コード例 #18
0
        public void Load(IServices services)
        {
            PerformanceUtility.StartPerformanceSequence(PerformanceEvent.DesignerPackageLoad);
            this.services = services;
            PropertyReference.RegisterAssemblyNamespace(typeof(DesignerPackage).Assembly, new string[] { "Microsoft.Expression.DesignSurface", "Microsoft.Expression.DesignSurface.Properties" });
            IWindowService        service              = this.services.GetService <IWindowService>();
            IProjectTypeManager   projectTypeManager   = this.services.GetService <IProjectTypeManager>();
            IDocumentTypeManager  documentTypeManager  = this.services.GetService <IDocumentTypeManager>();
            IOptionsDialogService optionsDialogService = this.services.GetService <IOptionsDialogService>();

            this.services.GetService <IProjectManager>();
            this.designSurfaceIcons = FileTable.GetResourceDictionary("Resources/Icons/DesignSurfaceIcons.xaml");
            service.AddResourceDictionary(this.designSurfaceIcons);
            SceneViewModel.RegisterPipelineTasks(this.services.GetService <ISchedulingService>());
            this.designerContext = new DesignerContext(this.services);
            this.designerContext.Initialize();
            this.services.AddService(typeof(SelectionManager), this.designerContext.SelectionManager);
            this.services.AddService(typeof(ToolManager), this.designerContext.ToolManager);
            this.services.AddService(typeof(SnappingEngine), this.designerContext.SnappingEngine);
            this.services.AddService(typeof(ICodeAidProvider), this.designerContext.CodeAidProvider);
            this.services.AddService(typeof(IAttachedPropertyMetadataFactory), new AttachedPropertyMetadataFactory());
            IOutOfBrowserDeploymentService outOfBrowserDeploymentService = new OutOfBrowserDeploymentService(this.services);

            this.services.AddService(typeof(IOutOfBrowserDeploymentService), outOfBrowserDeploymentService);
            this.services.AddService(typeof(IPlatformContextChanger), this.designerContext.PlatformContextChanger);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.DesignerPackageLoad, "Registering Document Types");
            this.documentTypes.Add(new LicxDocumentType());
            this.documentTypes.Add(new SceneDocumentType(this.designerContext));
            this.documentTypes.Add(new ResourceDictionaryDocumentType(this.designerContext));
            this.documentTypes.Add(new ImageDocumentType(this.designerContext));
            this.documentTypes.Add(new IconImageDocumentType(this.designerContext));
            this.documentTypes.Add(new PngImageDocumentType(this.designerContext));
            this.documentTypes.Add(new JpgImageDocumentType(this.designerContext));
            this.documentTypes.Add(new GifImageDocumentType(this.designerContext));
            this.documentTypes.Add(new TifImageDocumentType(this.designerContext));
            this.documentTypes.Add(new FontDocumentType());
            this.documentTypes.Add(new WpfMediaDocumentType(this.designerContext));
            this.documentTypes.Add(new SilverlightAndWpfMediaDocumentType(this.designerContext));
            this.documentTypes.Add(new XapDocumentType());
            this.documentTypes.Add(new WavefrontObjAsset(this.designerContext));
            this.documentTypes.Add(new WavefrontMtlDocumentType(this.designerContext));
            this.documentTypes.Add(new ApplicationDefinitionDocumentType(this.designerContext));
            foreach (IDocumentType documentType in this.documentTypes)
            {
                documentTypeManager.Register(documentType);
            }
            PerformanceUtility.MarkInterimStep(PerformanceEvent.DesignerPackageLoad, "Initializing DesignTime Metadata Store");
            IDesignerDefaultPlatformService designerDefaultPlatformService = new DesignerDefaultPlatformService(this.services);

            this.services.AddService(typeof(IDesignerDefaultPlatformService), designerDefaultPlatformService);
            IHelpService helpService = new HelpService();

            this.services.AddService(typeof(IHelpService), helpService);
            CanonicalTransform3D.Initialize(this.designerContext);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.DesignerPackageLoad, "Creating Managers");
            this.unitsOptionsPage = new UnitsOptionsPage(this.designerContext);
            optionsDialogService.OptionsPages.Add(this.unitsOptionsPage);
            this.artboardOptionsPage = new ArtboardOptionsPage(this.designerContext);
            optionsDialogService.OptionsPages.Add(this.artboardOptionsPage);
            this.viewOptionsPage = new ViewOptionsPage(this.designerContext);
            optionsDialogService.OptionsPages.Add(this.viewOptionsPage);
            this.annotationsOptionsPage = new AnnotationsOptionsPage(this.designerContext);
            optionsDialogService.OptionsPages.Add(this.annotationsOptionsPage);
            this.projectTypes.Add(new ExecutableProjectType());
            this.projectTypes.Add(new WindowsExecutableProjectType());
            this.projectTypes.Add(new WpfProjectType());
            this.projectTypes.Add(new SilverlightProjectType(services));
            foreach (IProjectType projectType in this.projectTypes)
            {
                projectTypeManager.Register(projectType);
            }
            IAssemblyService assemblyService = services.GetService <IAssemblyService>();

            this.silverLightAssemblyResolver = new SilverlightAssemblyResolver(AppDomain.CurrentDomain, services);
            assemblyService.RegisterPlatformResolver(".NETFramework", new ClrAssemblyResolver());
            assemblyService.RegisterPlatformResolver("Silverlight", this.silverLightAssemblyResolver);
            service.AddResourceDictionary(FileTable.GetResourceDictionary("Resources\\DesignSurfaceStyles.xaml"));
            PerformanceUtility.MarkInterimStep(PerformanceEvent.ApplicationStartup, "Opening Panels");
            PerformanceUtility.StartPerformanceSequence(PerformanceEvent.OpeningPanels);
            ToolContext toolContext = this.designerContext.ToolContext;

            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Tools");
            service.RegisterPalette("Designer_ToolPane", new ToolPane(this.designerContext, toolContext), StringTable.ToolPaneTitle, null, new StandaloneViewProperties(false, true, false));
            ProjectPane projectPane = new ProjectPane(services);

            service.RegisterPalette("Designer_ProjectPane", projectPane, StringTable.ProjectPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Data");
            service.RegisterPalette("Designer_DataPane", new DataPane(this.designerContext), StringTable.DataPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Resources");
            service.RegisterPalette("Designer_ResourcePane", new ResourcePane(this.designerContext, this.designerContext.ProjectManager, this.designerContext.ResourceManager), StringTable.ResourcePaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "PropertyInspector");
            service.RegisterPalette("Designer_PropertyInspector", new SceneNodePropertyInspectorPane(this.designerContext.PropertyInspectorModel), StringTable.PropertyInspectorPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Timeline");
            service.RegisterPalette("Designer_TimelinePane", new TimelinePane(this.designerContext), StringTable.TimelinePaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Triggers");
            service.RegisterPalette("Designer_TriggersPane", new TriggersPane(this.designerContext), StringTable.TriggersPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "States");
            service.RegisterPalette("Interaction_Skin", new SkinView(this.designerContext), StringTable.SkinPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Asset");
            service.RegisterPalette("Designer_AssetPane", new AssetPane(this.designerContext, toolContext), StringTable.AssetPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Parts");
            service.RegisterPalette("Interaction_Parts", new PartsPane(this.designerContext), StringTable.PartsPaneTitle);
            PerformanceUtility.MarkInterimStep(PerformanceEvent.OpeningPanels, "Results");
            ResultsPane resultsPane = new ResultsPane(this.designerContext, new ProjectErrorTaskCollection(this.designerContext));
            KeyBinding  keyBinding  = new KeyBinding()
            {
                Key = Key.F12
            };

            resultsPane.Palette = service.RegisterPalette("Designer_ResultsPane", resultsPane, StringTable.ResultsPaneTitle, keyBinding);
            PerformanceUtility.EndPerformanceSequence(PerformanceEvent.OpeningPanels);
            this.services.RemoveService(typeof(IErrorService));
            this.services.RemoveService(typeof(IMessageLoggingService));
            this.services.AddService(typeof(IErrorService), resultsPane.ErrorManager);
            this.services.AddService(typeof(IMessageLoggingService), resultsPane.MessageLoggingService);
            this.designerContext.ErrorManager          = resultsPane.ErrorManager;
            this.designerContext.MessageLoggingService = resultsPane.MessageLoggingService;
            PerformanceUtility.MarkInterimStep(PerformanceEvent.DesignerPackageLoad, "Adding Tools to ToolManager");
            this.tools.Add(new SelectionTool(toolContext));
            this.tools.Add(new SubselectionTool(toolContext));
            this.tools.Add(new RectangleTool(toolContext));
            this.tools.Add(new EllipseTool(toolContext));
            this.tools.Add(new LineTool(toolContext));
            this.tools.Add(new PenTool(toolContext));
            this.tools.Add(new PencilTool(toolContext));
            this.tools.Add(new PanTool(toolContext));
            this.tools.Add(new ZoomTool(toolContext));
            this.tools.Add(new EyedropperTool(toolContext));
            this.tools.Add(new PaintBucketTool(toolContext));
            this.tools.Add(new GradientBrushTool(toolContext));
            this.tools.Add(new BrushTransformTool(toolContext));
            this.tools.Add(new CameraOrbitTool(toolContext));
            foreach (ITypeId textToolType in TextTool.TextToolTypes)
            {
                this.tools.Add(new TextTool(toolContext, textToolType));
            }
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.Grid, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.Canvas, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.StackPanel, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, ProjectNeutralTypes.WrapPanel, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, ProjectNeutralTypes.DockPanel, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.ScrollViewer, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.Border, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, PlatformTypes.UniformGrid, ToolCategory.LayoutPanels));
            this.tools.Add(new GenericControlTool(toolContext, ProjectNeutralTypes.Viewbox, ToolCategory.LayoutPanels));
            foreach (ITypeId knownGenericControlType in DesignerPackage.KnownGenericControlTypes)
            {
                this.tools.Add(new GenericControlTool(toolContext, knownGenericControlType, ToolCategory.CommonControls));
            }
            foreach (Tool tool in this.tools)
            {
                this.designerContext.ToolManager.Add(tool);
            }
            this.sharedColorSpaceManager = new SharedColorSpaceManager(this.designerContext.Configuration);
            this.annotationService       = new AnnotationService(this.designerContext);
            services.AddService(typeof(AnnotationService), this.annotationService);
            this.commandTarget = new CommandTarget();
            this.commandTarget.AddCommand("Application_AddNewItem", new AddNewItemCommand(this.designerContext, null));
            CommandTarget   commandTarget   = this.commandTarget;
            DesignerContext designerContext = this.designerContext;

            string[] strArrays = new string[] { "ResourceDictionary.xaml" };
            commandTarget.AddCommand("Application_AddNewResource", new AddNewItemCommand(designerContext, strArrays));
            this.commandTarget.AddCommand("Project_OpenView", new OpenViewCommand(this.designerContext));
            this.commandTarget.AddCommand("Project_EnablePlatformExtensions", new EnablePlatformExtensionsCommand(services));
            this.commandTarget.AddCommand("Project_EnableOutOfBrowser", new EnableApplicationOutsideBrowserCommand(services));
            this.commandTarget.AddCommand("Project_EnablePreviewOutOfBrowser", new EnablePreviewOutOfBrowserCommand(services));
            this.commandTarget.AddCommand("Project_EnableElevatedOutOfBrowser", new EnableElevatedOutOfBrowserCommand(services));
            this.commandTarget.AddCommand("Project_AddReference", new AddReferenceCommand(services));
            this.designerContext.CommandService.AddTarget(this.commandTarget);
            PerformanceUtility.EndPerformanceSequence(PerformanceEvent.DesignerPackageLoad);
            EventRouter.InitializeKeyboardHook(this.designerContext);
            XamlPerformanceEvents.RegisterEvents();
            UIThreadDispatcherHelper.Capture();
            ViewNodeManager.EnsureLayoutRequired += new EventHandler(this.ViewNodeManager_EnsureLayoutRequired);
            KnownProjectBase.MetadataStore        = new DesignerPackage.MetadataStore();
            UIThreadDispatcher.Instance.BeginInvoke(DispatcherPriority.SystemIdle, new Action(FontResolver.CleanFontCache));
        }