/// <summary>
/// Initializes a new instance of the <see cref="AddSatelliteProviderCommand"/> class.
/// </summary>
/// <remarks>
/// This class is intended to be initialized by the <see cref="SectionViewModel.CreateElementCollectionAddCommands"/>.
/// </remarks>
/// <param name="commandAttribute">The <see cref="AddSateliteProviderCommandAttribute"/> that specifes metadata for this <see cref="AddSatelliteProviderCommand"/> to be initialized with.</param>
/// <param name="collection"></param>
/// <param name="commandService"></param>
/// <param name="configurationElementType"></param>
/// <param name="lookup"></param>
/// <param name="uiService"></param>
public AddSatelliteProviderCommand(AddSateliteProviderCommandAttribute commandAttribute, MenuCommandService commandService, ConfigurationElementType configurationElementType, ElementCollectionViewModel collection, ElementLookup lookup, IUIServiceWpf uiService)
: base(commandAttribute, configurationElementType, collection, uiService)
{
this.commandService = commandService;
this.commandAttribute = commandAttribute;
this.lookup = lookup;
}
public static void Register(MenuCommandService mcs)
{
CommandID nestId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdNest);
OleMenuCommand menuNest = new OleMenuCommand(Nest, nestId);
mcs.AddCommand(menuNest);
menuNest.BeforeQueryStatus += BeforeNest;
}
public static void Register(MenuCommandService mcs)
{
var cmdId = new CommandID(VSCommandTable.PackageGuids.VSPackageCmdSetGuid, VSCommandTable.CommandIds.SolutionExplorerItemContextMenuItem);
var menu = new OleMenuCommand((s, e) => { }, cmdId);
menu.BeforeQueryStatus += BeforeQueryStatus;
mcs.AddCommand(menu);
}
public static void Register(DTE2 dte, MenuCommandService mcs)
{
_dte = dte;
CommandID nestAllId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdRunNesting);
OleMenuCommand menuNestAll = new OleMenuCommand(NestAll, nestAllId);
mcs.AddCommand(menuNestAll);
}
public static void Register(MenuCommandService mcs)
{
var cmdId = new CommandID(VSCommandTable.PackageGuids.VSPackageCmdSetGuid, VSCommandTable.CommandIds.CreateServiceCode);
var menu = new OleMenuCommand(MenuItemCallbackHandler, cmdId);
menu.BeforeQueryStatus += BeforeQueryStatus;
mcs.AddCommand(menu);
}
public static void Register(DTE2 dte, MenuCommandService mcs)
{
_dte = dte;
CommandID nestAllId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdRunNesting);
OleMenuCommand menuNestAll = new OleMenuCommand(NestAll, nestAllId);
mcs.AddCommand(menuNestAll);
}
public static void Register(DTE2 dte, MenuCommandService mcs)
{
_dte = dte;
CommandID autoId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdAutoNesting);
OleMenuCommand menuAuto = new OleMenuCommand(AutoNest, autoId);
mcs.AddCommand(menuAuto);
menuAuto.BeforeQueryStatus += BeforeAutoNest;
}
public static void Register(MenuCommandService mcs)
{
var cmdId = new CommandID(VSCommandTable.PackageGuids.VSPackageCmdSetGuid, VSCommandTable.CommandIds.SolutionExplorerItemContextMenuItem);
var menu = new OleMenuCommand((s, e) => { }, cmdId);
menu.BeforeQueryStatus += BeforeQueryStatus;
mcs.AddCommand(menu);
}
public static void Register(MenuCommandService mcs)
{
var cmdId = new CommandID(VSCommandTable.PackageGuids.VSPackageCmdSetGuid, VSCommandTable.CommandIds.CreateContractCode);
var menu = new OleMenuCommand(MenuItemCallbackHandler, cmdId);
menu.BeforeQueryStatus += BeforeQueryStatus;
mcs.AddCommand(menu);
}
public static void Register(DTE2 dte, MenuCommandService mcs)
{
_dte = dte;
CommandID nestAllId = new CommandID(PackageGuids.guidFileNestingCmdSet, PackageIds.cmdRunNesting);
OleMenuCommand menuNestAll = new OleMenuCommand(NestAll, nestAllId);
mcs.AddCommand(menuNestAll);
}
public static void Register(MenuCommandService mcs)
{
CommandID unNestId = new CommandID(PackageGuids.guidFileNestingCmdSet, PackageIds.cmdUnNest);
OleMenuCommand menuUnNest = new OleMenuCommand(UnNest, unNestId);
mcs.AddCommand(menuUnNest);
menuUnNest.BeforeQueryStatus += BeforeUnNest;
}
public static void Register(MenuCommandService mcs)
{
CommandID nestId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdNest);
OleMenuCommand menuNest = new OleMenuCommand(Nest, nestId);
mcs.AddCommand(menuNest);
menuNest.BeforeQueryStatus += BeforeNest;
}
public void ShowVSExtensionManager(object parameter)
{
MenuCommandService menuCommandService = serviceProvider.Get <MenuCommandService>();
CommandID commandId = new CommandID(VSConstants.VsStd2010, 3000);
menuCommandService.GlobalInvoke(commandId, parameter);
serviceProvider.Get <ITeamExplorer>().HideNotification(GuidList.UpdateNotificationId);
}
public static void Register(DTE2 dte, MenuCommandService mcs)
{
_dte = dte;
CommandID autoId = new CommandID(GuidList.guidFileNestingCmdSet, (int)PkgCmdIDList.cmdAutoNesting);
OleMenuCommand menuAuto = new OleMenuCommand(AutoNest, autoId);
mcs.AddCommand(menuAuto);
menuAuto.BeforeQueryStatus += BeforeAutoNest;
}
public SelectionMenu(MenuCommandService menuCommandService)
: base("SelectionMenu")
{
_getEnabled = delegate(IToolStripItemCodon codon)
{
DesignerContextMenuStripItemCodon contextMenuCodon = codon as DesignerContextMenuStripItemCodon;
return(contextMenuCodon.ContextMenuCommand.Enabled);
};
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandShowEvents(menuCommandService), IconsLibrary.Event)
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandBringToFront(menuCommandService), IconsLibrary.BringToFrontHS)
{
IsEnabled = _getEnabled
});
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandSendToBack(menuCommandService), IconsLibrary.SendToBackHS)
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandLockControls(menuCommandService))
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
foreach (DesignerVerb verb in menuCommandService.Verbs)
{
this.Items.Add(new DesignerContextMenuStripItemCodon(verb));
}
if (menuCommandService.Verbs.Count > 0)
{
this.Items.Add(new ToolStripSeparatorCodon());
}
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandCut(menuCommandService), IconsLibrary.Cut)
{
IsEnabled = _getEnabled
});
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandCopy(menuCommandService), IconsLibrary.Copy)
{
IsEnabled = _getEnabled
});
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandPaste(menuCommandService), IconsLibrary.Paste)
{
IsEnabled = _getEnabled
});
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandDelete(menuCommandService), IconsLibrary.Delete)
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandProperties(menuCommandService), IconsLibrary.Property)
{
IsEnabled = _getEnabled
});
}
private void ChangeCommand(int commandId, bool enabled)
{
var command = new CommandID(GuidList.guidthreadfix_pluginCmdSet, commandId);
var menuItem = MenuCommandService.FindCommand(command);
if (menuItem != null)
{
menuItem.Enabled = enabled;
}
}
public override CommandResult Invoke(Guid group, int id, object inputArg, ref object outputArg)
{
if (MenuCommandService != null)
{
POINTS[] position = (POINTS[])inputArg;
CommandID menuCommand = new CommandID(_cmdSetGuid, (int)_menuId);
MenuCommandService.ShowContextMenu(menuCommand, position[0].x, position[0].y);
return(CommandResult.Executed);
}
return(CommandResult.NotSupported);
}
public Control GetControl()
{
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(System.ComponentModel.Design.IDesignerEventService), new DesignerEventService());
serviceContainer.AddService(typeof(System.ComponentModel.Design.Serialization.INameCreationService), new NameCreationService());
_toolboxService = new CustomToolboxService();
serviceContainer.AddService(typeof(IToolboxService), _toolboxService);
DesignSurface surface = new DesignSurface(serviceContainer);
_host = (IDesignerHost)surface.GetService(typeof(IDesignerHost));
serviceContainer.AddService(typeof(System.ComponentModel.Design.IEventBindingService), new Services.EventBindingService(surface));
_menuCommandService = new MenuCommandService(surface);
serviceContainer.AddService(typeof(IMenuCommandService), _menuCommandService);
//surface.BeginLoad(typeof(Form));
_CodeDomHostLoader = new Loader.CodeDomHostLoader();
surface.BeginLoad(_CodeDomHostLoader);
Control designerContorl = (Control)surface.View;
designerContorl.BackColor = Color.Aqua;
designerContorl.Dock = DockStyle.Fill;
//获取root组件
var designerHost = (IDesignerHost)this._host;
if (designerHost != null)
{
rootComponent = (Form)designerHost.RootComponent;
}
rootComponent.FormBorderStyle = FormBorderStyle.None;
#region 初始化窗体大小
//- set the Size
PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(designerContorl);
//- Sets a PropertyDescriptor to the specific property.
PropertyDescriptor pdS = pdc.Find("Size", false);
if (null != pdS)
{
pdS.SetValue(_host.RootComponent, new Size(800, 480));
}
#endregion
return(designerContorl);
}
private void UpdateUndoRedoMenuCommandsStatus()
{
MenuCommandService menuCommandService = GetService(typeof(MenuCommandService)) as MenuCommandService;
var undoMenuCommand = menuCommandService.FindCommand(StandardCommands.Undo);
var redoMenuCommand = menuCommandService.FindCommand(StandardCommands.Redo);
if (undoMenuCommand is object)
{
undoMenuCommand.Enabled = currentPos > 0;
}
if (redoMenuCommand is object)
{
redoMenuCommand.Enabled = currentPos < undoUnitList.Count;
}
}
public StationMapForm()
{
InitializeComponent();
persistState = new PersistWindowState(registryPath, this);
DesignSurface surface = new DesignSurface();
IServiceContainer container = surface.GetService(typeof(IServiceContainer)) as IServiceContainer;
_menuCommandService = new MenuCommandService(surface);
if (container != null)
{
container.AddService(typeof(IMenuCommandService), _menuCommandService);
}
DrawForm();
//InitStationDeviceType();
}
private void UpdateUndoRedoMenuCommandsStatus()
{
// this components maybe cached.
MenuCommandService menuCommandService = GetService(typeof(MenuCommandService)) as MenuCommandService;
MenuCommand undoMenuCommand = menuCommandService.FindCommand(StandardCommands.Undo);
MenuCommand redoMenuCommand = menuCommandService.FindCommand(StandardCommands.Redo);
if (undoMenuCommand != null)
{
undoMenuCommand.Enabled = currentPos > 0;
}
if (redoMenuCommand != null)
{
redoMenuCommand.Enabled = currentPos < this.undoUnitList.Count;
}
}
private void OnShowContextMenu(object sender, ShowContextMenuEventArgs e)
{
if (MenuCommandService != null)
{
OnBeforeShowContextMenu();
var explorerContextMenu = GetContextMenuCommandID();
var p = _elementHost.PointToScreen(new Point((int)e.Point.X, (int)e.Point.Y));
try
{
MenuCommandService.ShowContextMenu(explorerContextMenu, p.X, p.Y);
}
catch (COMException ex)
{
// do not rethrow exception as this causes VS crash
Debug.Fail("Caught exception of type " + ex.GetType().FullName +
" with message " + ex.Message + ". Stack Trace: " + ex.StackTrace);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="ApplicationViewModel"/>.
/// </summary>
/// <param name="uiService">The <see cref="IUIServiceWpf"/> that should be used to interact with the user.</param>
/// <param name="sourceModel">The <see cref="ConfigurationSourceModel"/> that should be used to interact with the configuration schema.</param>
/// <param name="lookup">The <see cref="ElementLookup"/> that should be used to look up <see cref="ElementViewModel"/> instances.</param>
/// <param name="builder">The <see cref="IUnityContainer"/> instance that should be used to create view model instances with.</param>
/// <param name="menuCommandService">The <see cref="MenuCommandService"/> that should be used to look up top-level <see cref="CommandModel"/> instances.</param>
/// <param name="validationModel">The <see cref="ValidationModel"/> that should be used to add validation errors and warnings to.</param>
public ApplicationViewModel(IUIServiceWpf uiService, ConfigurationSourceModel sourceModel, ElementLookup lookup,
IUnityContainer builder, MenuCommandService menuCommandService,
ValidationModel validationModel)
{
ValidationModel = validationModel;
this.uiService = uiService;
this.sourceModel = sourceModel;
this.lookup = lookup;
this.builder = builder;
this.menuCommandService = menuCommandService;
NewConfigurationCommand = new DelegateCommand(x => New());
SaveConfigurationCommand = new DelegateCommand(x => Save());
SaveAsConfigurationCommand = new DelegateCommand(x => SaveAs());
OpenConfigurationCommand = new DelegateCommand(x => OpenConfigurationSource());
ExitCommand = new DelegateCommand(x => Close());
OpenEnvironmentCommand = new OpenEnvironmentConfigurationDeltaCommand(uiService, this);
NewEnvironmentCommand = new DelegateCommand(x => NewEnvironment());
}
private void UpdateUndoRedoMenuCommandsStatus()
{
// this components maybe cached.
try
{
MenuCommandService menuCommandService = GetService(typeof(MenuCommandService)) as MenuCommandService;
menuCommandService = new Host.MenuCommandServiceImpl(IUGConceptor._hostSurfaceManager);
MenuCommand undoMenuCommand = menuCommandService.FindCommand(StandardCommands.Undo);
MenuCommand redoMenuCommand = menuCommandService.FindCommand(StandardCommands.Redo);
if (undoMenuCommand != null)
{
undoMenuCommand.Enabled = currentPos > 0;
}
if (redoMenuCommand != null)
{
redoMenuCommand.Enabled = currentPos < this.undoUnitList.Count;
}
}
catch
{
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
/// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
/// <param name="progress">A provider for progress updates.</param>
/// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
var commandService = await GetServiceAsync(typeof(System.ComponentModel.Design.IMenuCommandService)) as OleMenuCommandService;
if (commandService is MenuCommandService)
{
_menuCommandService = commandService;
}
await cmdCommandWindow.InitializeAsync(this);
await cmdCloudDeploy.InitializeAsync(this);
await cmdCloudCompress.InitializeAsync(this);
await cmdConfigureSSH.InitializeAsync(this);
// await cmdDeployWindow.InitializeAsync(this);
}
public ContainerMenu(MenuCommandService menuCommandService)
: base("ContainerMenu")
{
_getEnabled = delegate(IToolStripItemCodon codon)
{
DesignerContextMenuStripItemCodon contextMenuCodon = codon as DesignerContextMenuStripItemCodon;
return(contextMenuCodon.ContextMenuCommand.Enabled);
};
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandShowEvents(menuCommandService), IconsLibrary.Event)
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandTabOrder(menuCommandService), IconsLibrary.TabOrder)
{
IsEnabled = _getEnabled
});
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandLockControls(menuCommandService))
{
IsEnabled = _getEnabled
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandPaste(menuCommandService), IconsLibrary.Paste)
{
IsEnabled = delegate(IToolStripItemCodon codon)
{
DesignerContextMenuStripItemCodon contextMenuCodon = codon as DesignerContextMenuStripItemCodon;
return(contextMenuCodon.ContextMenuCommand.Enabled);
}
});
this.Items.Add(new ToolStripSeparatorCodon());
this.Items.Add(new DesignerContextMenuStripItemCodon(new ContextMenuCommandProperties(menuCommandService), IconsLibrary.Property)
{
IsEnabled = _getEnabled
});
}
/// <summary>
/// Initializes a new instance of <see cref="ApplicationViewModel"/>.
/// </summary>
/// <param name="uiService">The <see cref="IUIServiceWpf"/> that should be used to interact with the user.</param>
/// <param name="sourceModel">The <see cref="ConfigurationSourceModel"/> that should be used to interact with the configuration schema.</param>
/// <param name="lookup">The <see cref="ElementLookup"/> that should be used to look up <see cref="ElementViewModel"/> instances.</param>
/// <param name="builder">The <see cref="IUnityContainer"/> instance that should be used to create view model instances with.</param>
/// <param name="menuCommandService">The <see cref="MenuCommandService"/> that should be used to look up top-level <see cref="CommandModel"/> instances.</param>
/// <param name="validationModel">The <see cref="ValidationModel"/> that should be used to add validation errors and warnings to.</param>
/// <param name="profile">The <see cref="Profile"/> that should be used to filter UI elements based on the platform.</param>
public ApplicationViewModel(IUIServiceWpf uiService, ConfigurationSourceModel sourceModel, ElementLookup lookup,
IUnityContainer builder, MenuCommandService menuCommandService,
ValidationModel validationModel, Profile profile)
{
ValidationModel = validationModel;
this.uiService = uiService;
this.sourceModel = sourceModel;
this.lookup = lookup;
this.builder = builder;
this.menuCommandService = menuCommandService;
this.profile = profile;
NewConfigurationCommand = new DelegateCommand(x => New());
SaveConfigurationCommand = new DelegateCommand(x => Save());
SaveAsConfigurationCommand = new DelegateCommand(x => SaveAs());
OpenConfigurationCommand = new DelegateCommand(x => OpenConfigurationSource());
ExitCommand = new DelegateCommand(x => Close());
var environmentCommandsEnabled = this.profile == null ? true : profile.EnvironmentCommandsEnabled;
OpenEnvironmentCommand = new OpenEnvironmentConfigurationDeltaCommand(uiService, this, environmentCommandsEnabled);
NewEnvironmentCommand = new DelegateCommand(x => NewEnvironment(), _ => environmentCommandsEnabled);
}
public override void Initialize(IComponent component)
{
base.Initialize(component);
sections = new List<BaseSection>();
// We need to listen to change events. If a shape changes,
// we need to invalidate our view.
//
this.componentChangeService = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (this.componentChangeService != null)
{
this.componentChangeService.ComponentAdded += new ComponentEventHandler(OnComponentAdded);
// this.componentChangeService.ComponentRemoving += new ComponentEventHandler(OnComponentRemoving);
// this.componentChangeService.ComponentRemoved += new ComponentEventHandler(OnComponentRemoved);
this.componentChangeService.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
// this.componentChangeService.ComponentChanging += new ComponentChangingEventHandler(OnComponentChanging);
}
// Add the menu commands we support. We must be a member of the VSIP program to
// define new menu items, but we can handle any item located within the StandardCommands
// class because Visual Studio already defines them.
//
menuCommandService = (MenuCommandService)GetService(typeof(MenuCommandService));
/*
if (menuCommandService != null)
{
/*
m_menuCommands = new MenuCommand[]
{
new MenuCommand(new EventHandler(OnMenuCut), StandardCommands.Cut),
new MenuCommand(new EventHandler(OnMenuCopy), StandardCommands.Copy),
// new ImmediateMenuCommand(new EventHandler(OnMenuPasteStatus), new EventHandler(OnMenuPaste), StandardCommands.Paste),
new MenuCommand(new EventHandler(OnMenuDelete), StandardCommands.Delete)
};
foreach(MenuCommand mc in m_menuCommands)
{
m_menuCommandService.AddCommand(mc);
}
System.Console.WriteLine("RootDesigner menuService set");
}
*/
// Select our base shape. By default there is nothing selected but that looks
// strange (the property grid is empty).
//
this.selectionService = (ISelectionService)GetService(typeof(ISelectionService));
if (this.selectionService != null)
{
this.selectionService.SetSelectedComponents(new object[] {component}, SelectionTypes.Replace);
this.selectionService.SelectionChanged += new EventHandler(OnSelectionChanged);
}
this.host = (IDesignerHost)GetService(typeof(IDesignerHost));
this.menuCommandService = (MenuCommandService)host.GetService(typeof(MenuCommandService));
if (host != null)
{
host.LoadComplete += new EventHandler(OnLoadComplete);
}
//Dragdropp only allowed in Section
this.Control.AllowDrop = false;
}
public MenuCommandServiceExt(IServiceProvider serviceProvider)
{
this._serviceProvider = serviceProvider;
_menuCommandService = new MenuCommandService(serviceProvider);
}
public AbstractContextMenuCommand(MenuCommandService menuCommandService)
{
_menuCommandService = menuCommandService;
}
protected SingleCommand(int commandId, VisualStudioPackage package) : base(commandId, package)
{
_command = new OleMenuCommand(InvokeHandler, new CommandID(CommandSet.Guid, commandId));
_command.BeforeQueryStatus += CommandOnBeforeQueryStatus;
MenuCommandService.AddCommand(_command);
}
private void Initialize()
{
IDesignerHost host;
Form form;
IRootDesigner rootDesigner;
Control view;
// Initialise service container and designer host
serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(INameCreationService), new NameCreationService());
serviceContainer.AddService(typeof(IUIService), new UIService(this));
host = new DesignerHost(serviceContainer);
// Add toolbox service
serviceContainer.AddService(typeof(IToolboxService), lstToolbox);
lstToolbox.designPanel = pnlViewHost;
PopulateToolbox(lstToolbox);
// Add menu command service
menuService = new MenuCommandService();
serviceContainer.AddService(typeof(IMenuCommandService), menuService);
// Start the designer host off with a Form to design
form = (Form)host.CreateComponent(typeof(Form));
form.TopLevel = false;
form.Text = "Form1";
// Get the root designer for the form and add its design view to this form
rootDesigner = (IRootDesigner)host.GetDesigner(form);
view = (Control)rootDesigner.GetView(ViewTechnology.WindowsForms);
view.Dock = DockStyle.Fill;
pnlViewHost.Controls.Add(view);
// Subscribe to the selectionchanged event and activate the designer
ISelectionService s = (ISelectionService)serviceContainer.GetService(typeof(ISelectionService));
s.SelectionChanged += new EventHandler(OnSelectionChanged);
host.Activate();
}
internal Guid pageGuid;//与model的编号对应
public DesignWorkbench(string pageName)
{
InitializeComponent();
AutoScaleMode = AutoScaleMode.Dpi;
PageMoel pm = new PageMoel();
_propertyGrid = new PropertyGrid {
Dock = DockStyle.Fill
};
pm.propertyGrid = _propertyGrid;
pm.PageName = pageName;
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(System.ComponentModel.Design.IDesignerEventService), new DesignerEventService());
serviceContainer.AddService(typeof(System.ComponentModel.Design.Serialization.INameCreationService), new NameCreationService());
_toolboxService = new CustomToolboxService();
serviceContainer.AddService(typeof(IToolboxService), _toolboxService);
surface = new DesignSurface(serviceContainer);
_host = (IDesignerHost)surface.GetService(typeof(IDesignerHost));
serviceContainer.AddService(typeof(System.ComponentModel.Design.IEventBindingService), new Services.EventBindingService(surface));
_menuCommandService = new MenuCommandService(surface);
serviceContainer.AddService(typeof(IMenuCommandService), _menuCommandService);
//surface.BeginLoad(typeof(Form));
_CodeDomHostLoader = new Loader.CodeDomHostLoader();
surface.BeginLoad(_CodeDomHostLoader);
Control designerContorl = (Control)surface.View;
designerContorl.BackColor = Color.Aqua;
designerContorl.Dock = DockStyle.Fill;
//获取root组件
var designerHost = (IDesignerHost)this._host;
if (designerHost != null)
{
rootComponent = (Form)designerHost.RootComponent;
}
rootComponent.FormBorderStyle = FormBorderStyle.None;
#region 初始化窗体大小
//- set the Size
PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(designerContorl);
//- Sets a PropertyDescriptor to the specific property.
PropertyDescriptor pdS = pdc.Find("Size", false);
if (null != pdS)
{
pdS.SetValue(_host.RootComponent, new Size(800, 480));
}
#endregion
tpDesign.Controls.Add(designerContorl);//窗体
_textEditor = new TextEditorControl
{
IsReadOnly = true,
Dock = DockStyle.Fill,
Document = { HighlightingStrategy = HighlightingStrategyFactory.CreateHighlightingStrategy("C#") }
}; //代码编辑器
tpCode.Controls.Add(_textEditor);
_propertyGrid.SelectedObject = surface.ComponentContainer.Components[0];
_propertyGrid.Site = (new IDEContainer(_host)).CreateSite(_propertyGrid);
_propertyGrid.PropertyTabs.AddTabType(typeof(System.Windows.Forms.Design.EventsTab), PropertyTabScope.Document);
pm.serviceContainer = serviceContainer;
pm.surFace = surface;
pageGuid = Guid.NewGuid();
pm.PageGuid = pageGuid;
List <PageMoel> pages = GolableInstance.PageList();
pages.Add(pm);
//if (ChangeSur != null) ChangeSur();
}
protected override void OnBeforeShowContextMenu()
{
// Creating commands for adding scalar and complex properties to complex types (one for each complex type from the model).
// Since the scalar types can change dependent on the schemaVersion and since complex types can be added or deleted
// we need to compute these commands each time a context menu is requested
// only need to do this if selected is ExplorerComplexType
var selectedElement = CurrentExplorerInfo._explorerFrame.GetSelectedExplorerEFElement();
if (selectedElement is ExplorerComplexType)
{
var service = EditingContext.GetEFArtifactService();
Debug.Assert(service != null && service.Artifact != null, "service and service.Artifact must both be non-null");
if (service != null &&
service.Artifact != null)
{
// Creating commands for adding scalar properties to complex types (one for each primitive type)
var i = 0;
foreach (var type in ModelHelper.AllPrimitiveTypesSorted(service.Artifact.SchemaVersion))
{
var cmdId = new CommandID(
PackageConstants.guidEscherCmdSet, PackageConstants.cmdIdExplorerAddScalarPropertyBase + i);
var cmd = MenuCommandService.FindCommand(cmdId);
if (cmd == null)
{
cmd = new DynamicStatusMenuCommand(OnStatusAddComplexTypeProperty, OnMenuAddComplexTypeProperty, cmdId);
cmd.Properties[PackageConstants.guidEscherCmdSet] = type;
MenuCommandService.AddCommand(cmd);
}
else
{
cmd.Properties[PackageConstants.guidEscherCmdSet] = type;
}
i++;
}
// set up commands for complex types
var conceptualModel = service.Artifact.ConceptualModel();
Debug.Assert(conceptualModel != null, "service.Artifact.ConceptualModel() should not be null");
if (conceptualModel != null)
{
var complexTypes = new List <ComplexType>(conceptualModel.ComplexTypes());
complexTypes.Sort(EFElement.EFElementDisplayNameComparison);
i = 0;
foreach (var complexType in complexTypes)
{
// don't add an item for a ComplexType that is same as currently selected one
if (selectedElement.ModelItem == complexType)
{
continue;
}
// if we find an old command with the same cmdId remove it and replace
// with the new one to force VS to refresh the text
var cmdId = new CommandID(
PackageConstants.guidEscherCmdSet, PackageConstants.cmdIdExplorerAddComplexPropertyBase + i);
var cmd = MenuCommandService.FindCommand(cmdId);
if (cmd != null)
{
MenuCommandService.RemoveCommand(cmd);
}
cmd = new DynamicStatusMenuCommand(OnStatusAddComplexTypeProperty, OnMenuAddComplexTypeProperty, cmdId);
cmd.Properties[PackageConstants.guidEscherCmdSet] = complexType;
MenuCommandService.AddCommand(cmd);
i++;
if (i >= AddComplexPropertyCommandMaxCount)
{
// break after adding 10 ComplexTypes
break;
}
}
// if some of the complex types were removed, we need to remove unnecessary commands
var cmd2 =
MenuCommandService.FindCommand(
new CommandID(PackageConstants.guidEscherCmdSet, PackageConstants.cmdIdExplorerAddComplexPropertyBase + i));
while (i < AddComplexPropertyCommandMaxCount &&
cmd2 != null)
{
MenuCommandService.RemoveCommand(cmd2);
i++;
cmd2 =
MenuCommandService.FindCommand(
new CommandID(
PackageConstants.guidEscherCmdSet, PackageConstants.cmdIdExplorerAddComplexPropertyBase + i));
}
}
}
}
}
public override void Initialize(IComponent component)
{
base.Initialize(component);
sections = new List <BaseSection>();
// We need to listen to change events. If a shape changes,
// we need to invalidate our view.
//
this.componentChangeService = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (this.componentChangeService != null)
{
this.componentChangeService.ComponentAdded += new ComponentEventHandler(OnComponentAdded);
// this.componentChangeService.ComponentRemoving += new ComponentEventHandler(OnComponentRemoving);
// this.componentChangeService.ComponentRemoved += new ComponentEventHandler(OnComponentRemoved);
this.componentChangeService.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
this.componentChangeService.ComponentChanging += new ComponentChangingEventHandler(OnComponentChanging);
}
// Add the menu commands we support. We must be a member of the VSIP program to
// define new menu items, but we can handle any item located within the StandardCommands
// class because Visual Studio already defines them.
//
menuCommandService = (MenuCommandService)GetService(typeof(MenuCommandService));
/*
* if (menuCommandService != null)
* {
* /*
* m_menuCommands = new MenuCommand[]
* {
* new MenuCommand(new EventHandler(OnMenuCut), StandardCommands.Cut),
* new MenuCommand(new EventHandler(OnMenuCopy), StandardCommands.Copy),
* // new ImmediateMenuCommand(new EventHandler(OnMenuPasteStatus), new EventHandler(OnMenuPaste), StandardCommands.Paste),
* new MenuCommand(new EventHandler(OnMenuDelete), StandardCommands.Delete)
* };
*
* foreach(MenuCommand mc in m_menuCommands)
* {
* m_menuCommandService.AddCommand(mc);
* }
*
* System.Console.WriteLine("RootDesigner menuService set");
* }
*/
// Select our base shape. By default there is nothing selected but that looks
// strange (the property grid is empty).
//
selectionService = (ISelectionService)GetService(typeof(ISelectionService));
if (this.selectionService != null)
{
this.selectionService.SetSelectedComponents(new object[] { component }, SelectionTypes.Replace);
this.selectionService.SelectionChanged += new EventHandler(OnSelectionChanged);
}
host = (IDesignerHost)GetService(typeof(IDesignerHost));
menuCommandService = (MenuCommandService)host.GetService(typeof(MenuCommandService));
if (host != null)
{
host.LoadComplete += OnLoadComplete;
}
//Dragdropp only allowed in Section
this.Control.AllowDrop = false;
}
/// <summary>
/// Called to do control-specific processing for this window.
/// </summary>
void IWindowTarget.OnMessage(ref Message m)
{
// Get the Designer for the currently selected item on the Designer...
// SET STATE ..
ignoreMessages = false;
// Here lets query for the ISupportInSituService.
// If we find the service then ask if it has a designer which is interested
// in getting the keychars by querying the IgnoreMessages.
if ((m.Msg >= (int)User32.WM.KEYFIRST && m.Msg <= (int)User32.WM.KEYLAST) ||
(m.Msg >= (int)User32.WM.IME_STARTCOMPOSITION && m.Msg <= (int)User32.WM.IME_COMPOSITION))
{
if (InSituSupportService != null)
{
ignoreMessages = InSituSupportService.IgnoreMessages;
}
}
switch (m.Msg)
{
case WM_PRIVATE_POSTCHAR:
if (bufferedChars == null)
{
return;
}
// recreate the keystroke to the newly activated window
IntPtr hWnd;
if (!ignoreMessages)
{
hWnd = User32.GetFocus();
}
else
{
if (InSituSupportService != null)
{
hWnd = InSituSupportService.GetEditWindow();
}
else
{
hWnd = User32.GetFocus();
}
}
if (hWnd != m.HWnd)
{
foreach (BufferedKey bk in bufferedChars)
{
if (bk.KeyChar.MsgInternal == User32.WM.CHAR)
{
if (bk.KeyDown.MsgInternal != 0)
{
User32.SendMessageW(hWnd, User32.WM.KEYDOWN, bk.KeyDown.WParamInternal, bk.KeyDown.LParamInternal);
}
User32.SendMessageW(hWnd, User32.WM.CHAR, bk.KeyChar.WParamInternal, bk.KeyChar.LParamInternal);
if (bk.KeyUp.MsgInternal != 0)
{
User32.SendMessageW(hWnd, User32.WM.KEYUP, bk.KeyUp.WParamInternal, bk.KeyUp.LParamInternal);
}
}
else
{
User32.SendMessageW(hWnd, bk.KeyChar.MsgInternal, bk.KeyChar.WParamInternal, bk.KeyChar.LParamInternal);
}
}
}
bufferedChars.Clear();
return;
case (int)User32.WM.KEYDOWN:
lastKeyDown = m;
break;
case (int)User32.WM.IME_ENDCOMPOSITION:
case (int)User32.WM.KEYUP:
lastKeyDown.Msg = 0;
break;
case (int)User32.WM.CHAR:
case (int)User32.WM.IME_STARTCOMPOSITION:
case (int)User32.WM.IME_COMPOSITION:
if ((Control.ModifierKeys & (Keys.Control | Keys.Alt)) != 0)
{
break;
}
if (bufferedChars == null)
{
bufferedChars = new ArrayList();
}
bufferedChars.Add(new BufferedKey(lastKeyDown, m, lastKeyDown));
if (!ignoreMessages && MenuCommandService != null)
{
// throw the properties window command, we will redo the keystroke when we actually
// lose focus
postCharMessage = true;
MenuCommandService.GlobalInvoke(StandardCommands.PropertiesWindow);
}
else if (ignoreMessages && m.Msg != (int)User32.WM.IME_COMPOSITION)
{
if (InSituSupportService != null)
{
postCharMessage = true;
InSituSupportService.HandleKeyChar();
}
}
if (postCharMessage)
{
// If copy of message has been buffered for forwarding, eat the original now
return;
}
break;
case (int)User32.WM.KILLFOCUS:
if (postCharMessage)
{
// see ASURT 45313
// now that we've actually lost focus, post this message to the queue. This allows
// any activity that's in the queue to settle down before our characters are posted.
// to the queue.
//
// we post because we need to allow the focus to actually happen before we send
// our strokes so we know where to send them
//
// we can't use the wParam here because it may not be the actual window that needs
// to pick up the strokes.
//
User32.PostMessageW(target.Handle, (User32.WM)WM_PRIVATE_POSTCHAR, IntPtr.Zero, IntPtr.Zero);
postCharMessage = false;
}
break;
}
if (oldTarget != null)
{
oldTarget.OnMessage(ref m);
}
}
public SEUndoUnitZOrder(EnumSendTo sendTo, MenuCommandService menuCommandService, CommandID commandID)
{
_sendTo = sendTo;
_menuCommandService = menuCommandService;
_commandId = commandID;
}
