public void Unload()
{
this.services.RemoveService(typeof(ITextEditorService));
this.services.RemoveService(typeof(ITextBufferService));
this.services.RemoveService(typeof(ICodeModelService));
this.services.RemoveService(typeof(ICodeProjectService));
if (this.editingService != null)
{
this.editingService.Dispose();
this.editingService = (EditingService)null;
}
if (this.commandTarget != null)
{
this.services.GetService <ICommandService>().RemoveTarget((ICommandTarget)this.commandTarget);
this.commandTarget = (CommandTarget)null;
}
IDocumentTypeManager service = this.services.GetService <IDocumentTypeManager>();
service.Unregister(this.csharpDocumentType);
service.Unregister(this.visualBasicDocumentType);
service.Unregister(this.javascriptDocumentType);
service.Unregister(this.fSharpDocumentType);
service.Unregister(this.fSharpScriptDocumentType);
service.Unregister(this.fSharpTemplateDocumentType);
service.Unregister(this.cPlusPlusDocumentType);
service.Unregister(this.headerDocumentType);
service.Unregister(this.htmlDocumentType);
service.Unregister(this.xmlDocumentType);
service.Unregister(this.limitedXamlDocumentType);
service.Unregister(this.fxgDocumentType);
this.services.GetService <IOptionsDialogService>().OptionsPages.Remove(this.codeOptionsPage);
}
/// <summary>
/// Parameterized PUBLIC class constructor
/// </summary>
/// <param name="avLayout"></param>
/// <param name="documentTypeManager"></param>
public InstallModule(IAvalonDockLayoutViewModel avLayout,
IDocumentTypeManager documentTypeManager)
: this()
{
_avLayout = avLayout;
_documentTypeManager = documentTypeManager;
}
/// <summary>
/// Initialize this module via standard PRISM MEF procedure
/// </summary>
private void Initialize(IAvalonDockLayoutViewModel avLayout,
IToolWindowRegistry toolRegistry,
IDocumentTypeManager documentTypeManager)
{
this.RegisterDataTemplates(avLayout.ViewProperties.SelectPanesTemplate);
this.RegisterStyles(avLayout.ViewProperties.SelectPanesStyle);
toolRegistry.RegisterTool(new Log4NetToolViewModel());
toolRegistry.RegisterTool(new Log4NetMessageToolViewModel());
var docType = documentTypeManager.RegisterDocumentType
(Log4NetViewModel.DocumentKey,
Log4NetViewModel.Description,
Log4NetViewModel.FileFilterName,
Log4NetViewModel.DefaultFilter,
Log4NetViewModel.LoadFile,
null, // Log4Net Grid Viewer is a readonly viewer
typeof(Log4NetViewModel), 40);
if (docType != null)
{
var t = docType.CreateItem("log4net XML output", new List <string>()
{
"log4j", "log", "txt", "xml"
}, 35);
docType.RegisterFileTypeItem(t);
}
}
/// <summary>
/// Public parameterized class constructor
/// </summary>
public InstallModule(IAvalonDockLayoutViewModel avLayout,
IToolWindowRegistry toolRegistry,
IDocumentTypeManager documentTypeManager)
{
_avLayout = avLayout;
_toolRegistry = toolRegistry;
_documentTypeManager = documentTypeManager;
}
public MefLoadEdiDocuments(IAvalonDockLayoutViewModel avLayout,
IToolWindowRegistry toolRegistry,
ISettingsManager settingsManager,
IDocumentTypeManager documentTypeManager)
{
_mAvLayout = avLayout;
_mToolRegistry = toolRegistry;
_mDocumentTypeManager = documentTypeManager;
}
/// <summary>
/// Initialize this module via standard PRISM MEF procedure
/// </summary>
private void Initialize(IAvalonDockLayoutViewModel avLayout,
IDocumentTypeManager documentTypeManager)
{
RegisterDataTemplates(avLayout.ViewProperties.SelectPanesTemplate);
RegisterStyles(avLayout.ViewProperties.SelectPanesStyle);
RegisterEdiTextEditor(documentTypeManager);
RegisterMiniUml(documentTypeManager);
}
public MEFLoadLog4NetTools(IAvalonDockLayoutViewModel avLayout,
IToolWindowRegistry toolRegistry,
ISettingsManager settingsManager,
IDocumentTypeManager documentTypeManager)
{
this.mAvLayout = avLayout;
this.mToolRegistry = toolRegistry;
this.mSettingsManager = settingsManager;
this.mDocumentTypeManager = documentTypeManager;
}
public void Unload()
{
KnownProjectBase.MetadataStore = null;
ViewNodeManager.EnsureLayoutRequired -= new EventHandler(this.ViewNodeManager_EnsureLayoutRequired);
XamlPerformanceEvents.UnregisterEvents();
this.services.RemoveService(typeof(AnnotationService));
this.annotationService.Shutdown();
IProjectTypeManager service = this.services.GetService <IProjectTypeManager>();
IDocumentTypeManager documentTypeManager = this.services.GetService <IDocumentTypeManager>();
IWindowService windowService = this.services.GetService <IWindowService>();
IOptionsDialogService optionsDialogService = this.services.GetService <IOptionsDialogService>();
this.services.GetService <ICommandService>().RemoveTarget(this.commandTarget);
this.commandTarget = null;
foreach (Tool tool in this.tools)
{
this.designerContext.ToolManager.Remove(tool);
}
this.services.RemoveService(typeof(ToolManager));
this.services.RemoveService(typeof(SnappingEngine));
this.services.RemoveService(typeof(IAttachedPropertyMetadataFactory));
this.services.RemoveService(typeof(IOutOfBrowserDeploymentService));
this.services.GetService <IDesignerDefaultPlatformService>().Dispose();
this.services.RemoveService(typeof(IDesignerDefaultPlatformService));
this.services.RemoveService(typeof(IHelpService));
windowService.RemoveResourceDictionary(this.designSurfaceIcons);
optionsDialogService.OptionsPages.Remove(this.unitsOptionsPage);
optionsDialogService.OptionsPages.Remove(this.artboardOptionsPage);
optionsDialogService.OptionsPages.Remove(this.viewOptionsPage);
optionsDialogService.OptionsPages.Remove(this.annotationsOptionsPage);
this.sharedColorSpaceManager.Unload();
if (windowService.PaletteRegistry["Designer_ProjectPane"] != null)
{
ProjectPane content = (ProjectPane)windowService.PaletteRegistry["Designer_ProjectPane"].Content;
}
SceneViewModel.UnregisterPipelineTasks(this.services.GetService <ISchedulingService>());
foreach (IProjectType projectType in this.projectTypes)
{
service.Unregister(projectType);
}
foreach (IDocumentType documentType in this.documentTypes)
{
documentTypeManager.Unregister(documentType);
}
this.projectTypes.Clear();
this.documentTypes.Clear();
this.designerContext.Uninitialize();
this.designerContext = null;
IAssemblyService assemblyService = this.services.GetService <IAssemblyService>();
assemblyService.UnregisterPlatformResolver("Silverlight");
assemblyService.UnregisterPlatformResolver(".NETFramework");
this.silverLightAssemblyResolver.Dispose();
}
public CodeProject(IProject project, IAssemblyService assemblyService, ICodeProjectService codeProjectService, BuildManager buildManager, IViewService viewService, IDocumentTypeManager documentTypeManager)
{
this.project = project;
this.assemblyService = assemblyService;
this.codeProjectService = codeProjectService;
this.buildManager = buildManager;
this.documentTypeManager = documentTypeManager;
this.documentChangeWatcher = new CodeProject.OpenDocumentsChangeWatcher(viewService);
this.documentChangeWatcher.DocumentClosed += new EventHandler <CodeProject.DocumentChangedEventArgs>(this.DocumentChangeWatcher_DocumentClosed);
this.documentChangeWatcher.DocumentOpened += new EventHandler <CodeProject.DocumentChangedEventArgs>(this.DocumentChangeWatcher_DocumentOpened);
this.documentChangeWatcher.InitializeDocuments();
}
private void EnsureSupportedDocuments()
{
SceneNodeProperty sceneNodeProperty = this.editingProperty as SceneNodeProperty;
if (sceneNodeProperty == null)
{
return;
}
IDocumentTypeManager documentTypeManager = sceneNodeProperty.SceneNodeObjectSet.DesignerContext.DocumentTypeManager;
IDocumentType folderDocumentType = documentTypeManager.DocumentTypes[DocumentTypeNamesHelper.Folder];
if (UriEditor.mediaDocuments == null)
{
UriEditor.mediaDocuments = Enumerable.ToArray <IDocumentType>(Enumerable.Where <IDocumentType>((IEnumerable <IDocumentType>)documentTypeManager.DocumentTypes, (Func <IDocumentType, bool>)(doc => doc is MediaDocumentType)));
}
if (UriEditor.imageDocuments == null)
{
UriEditor.imageDocuments = Enumerable.ToArray <IDocumentType>(Enumerable.Where <IDocumentType>((IEnumerable <IDocumentType>)documentTypeManager.DocumentTypes, (Func <IDocumentType, bool>)(doc => doc is ImageDocumentType)));
}
if (UriEditor.fontDocuments == null)
{
UriEditor.fontDocuments = Enumerable.ToArray <IDocumentType>(Enumerable.Where <IDocumentType>((IEnumerable <IDocumentType>)documentTypeManager.DocumentTypes, (Func <IDocumentType, bool>)(doc => doc is FontDocumentType)));
}
if (UriEditor.multiScaleDocuments == null)
{
UriEditor.multiScaleDocuments = new IDocumentType[2]
{
documentTypeManager.DocumentTypes[DocumentTypeNamesHelper.Xml],
documentTypeManager.DocumentTypes[DocumentTypeNamesHelper.DeepZoom]
}
}
;
if (UriEditor.xamlDocuments == null)
{
UriEditor.xamlDocuments = new IDocumentType[1]
{
documentTypeManager.DocumentTypes[DocumentTypeNamesHelper.Xaml]
}
}
;
if (UriEditor.defaultDocuments != null)
{
return;
}
UriEditor.defaultDocuments = Enumerable.ToArray <IDocumentType>(Enumerable.Where <IDocumentType>((IEnumerable <IDocumentType>)documentTypeManager.DocumentTypes, (Func <IDocumentType, bool>)(doc =>
{
if (!(doc is AssemblyReferenceDocumentType) && !(doc is ICodeDocumentType))
{
return(doc != folderDocumentType);
}
return(false);
})));
}
internal CodeProjectService(IProjectManager projectManager, IAssemblyService assemblyService, IMessageDisplayService messageDisplayService, IViewService viewService, IDocumentTypeManager documentTypeManager)
{
this.projectManager = projectManager;
this.assemblyService = assemblyService;
this.messageDisplayService = messageDisplayService;
this.viewService = viewService;
this.documentTypeManager = documentTypeManager;
if (this.projectManager == null)
{
return;
}
this.projectManager.ProjectClosed += new EventHandler <ProjectEventArgs>(this.OnProjectClosed);
}
private void RegisterEdiTextEditor(IDocumentTypeManager documentTypeManager)
{
// Register these patterns for the build in AvalonEdit text editor
// All Files (*.*)|*.*
var docType = documentTypeManager.RegisterDocumentType(EdiViewModel.DocumentKey,
EdiViewModel.Description,
EdiViewModel.FileFilterName,
EdiViewModel.DefaultFilter,
EdiViewModel.LoadFile,
EdiViewModel.CreateNewDocument,
typeof(EdiViewModel),
10);
if (docType != null) // Lets register some sub-types for editing with Edi's text editor
{
// Text Files (*.txt)|*.txt
// C# Files (*.cs)|*.cs
// HTML Files (*.htm,*.html,*.css,*.js)|*.htm;*.html;*.css;*.js
// Structured Query Language (*.sql) |*.sql
var t = docType.CreateItem("Text Files", new List <string>()
{
"txt"
}, 12);
docType.RegisterFileTypeItem(t);
t = docType.CreateItem("C# Files", new List <string>()
{
"cs", "xaml", "config"
}, 14);
docType.RegisterFileTypeItem(t);
t = docType.CreateItem("HTML Files", new List <string>()
{
"htm", "html", "css", "js"
}, 16);
docType.RegisterFileTypeItem(t);
t = docType.CreateItem("Structured Query Language", new List <string>()
{
"sql"
}, 18);
docType.RegisterFileTypeItem(t);
}
}
public void Unload()
{
Microsoft.Expression.Framework.UserInterface.IWindowService service = this.services.GetService <Microsoft.Expression.Framework.UserInterface.IWindowService>();
service.Closing -= new CancelEventHandler(this.WindowManager_Closing);
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Send, new DispatcherOperationCallback((object o) => {
Application.Current.SessionEnding -= new SessionEndingCancelEventHandler(this.Current_SessionEnding);
return(null);
}), null);
ICommandService commandService = this.services.GetService <ICommandService>();
IProjectManager projectManager = this.services.GetService <IProjectManager>();
projectManager.CloseSolution();
ProjectManager projectManager1 = (ProjectManager)projectManager;
projectManager1.UpdateConfiguration();
commandService.RemoveTarget(projectManager1);
IDocumentTypeManager documentTypeManager = this.services.GetService <IDocumentTypeManager>();
documentTypeManager.Unregister(this.assemblyDocumentType);
documentTypeManager.Unregister(this.projectReferenceDocumentType);
documentTypeManager.Unregister(this.folderDocumentType);
documentTypeManager.Unregister(this.comReferenceDocumentType);
documentTypeManager.Unregister(this.cursorDocumentType);
documentTypeManager.Unregister(this.deepZoomDocumentType);
IProjectTypeManager projectTypeManager = this.services.GetService <IProjectTypeManager>();
projectTypeManager.Unregister(this.websiteProjectType);
projectTypeManager.Unregister(this.webApplicationProjectType);
this.services.GetService <IOptionsDialogService>().OptionsPages.Remove(this.projectSystemOptionsPage);
this.assemblyLoggingService.Unload();
this.services.RemoveService(typeof(IAssemblyLoggingService));
this.services.RemoveService(typeof(IProjectTypeManager));
this.services.RemoveService(typeof(IDocumentTypeManager));
this.services.RemoveService(typeof(IProjectManager));
this.services.RemoveService(typeof(ISolutionService));
this.services.AssemblyService().UnregisterLibraryResolver(this.blendSdkAssemblyResolver);
this.services.AssemblyService().UnregisterLibraryResolver(this.blendAssemblyResolver);
this.services.RemoveService(typeof(IAssemblyService));
this.services.RemoveService(typeof(ISatelliteAssemblyResolver));
this.assemblyService.Dispose();
}
private void RegisterMiniUml(IDocumentTypeManager documentTypeManager)
{
// Unified Modeling Language (*.uml,*.xml)|*.uml;*.xml
var docType = documentTypeManager.RegisterDocumentType(MiniUmlViewModel.DocumentKey,
MiniUmlViewModel.Description,
MiniUmlViewModel.FileFilterName,
MiniUmlViewModel.DefaultFilter,
MiniUmlViewModel.LoadFile,
null,
typeof(MiniUmlViewModel),
90);
if (docType != null) // Lets register some sub-types for editing with Edi's text editor
{
var t = docType.CreateItem("UML Files", new List <string>()
{
"uml", "xml"
}, 92);
docType.RegisterFileTypeItem(t);
}
}
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));
}
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);
}
public DocumentTypesController(IDocumentTypeManager docManager)
{
_docManager = docManager;
}
public KnownDocumentTypes(IDocumentTypeManager documentTypeManager)
{
this.documentTypeManager = documentTypeManager;
}
