private IEventBindingService GetEventPropertyService(object obj, ITypeDescriptorContext context) { IEventBindingService iEventBindingService = null; if (!sunkEvent) { sunkEvent = true; IDesignerEventService iDesignerEventService = sp.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (iDesignerEventService != null) { iDesignerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(OnActiveDesignerChanged); } } if (iEventBindingService == null && host != null) { iEventBindingService = host.GetService(typeof(IEventBindingService)) as IEventBindingService; } if (iEventBindingService == null && obj is IComponent) { if (obj != null) { iEventBindingService = (obj as IComponent).Site.GetService(typeof(IEventBindingService)) as IEventBindingService; } } if (iEventBindingService == null && context != null) { iEventBindingService = context.GetService(typeof(IEventBindingService)) as IEventBindingService; } return(iEventBindingService); }
void IDisposable.Dispose() { WorkflowView view = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; if (view != null) { if (this.refreshTypesHandler != null) { view.Idle -= this.refreshTypesHandler; } if (this.refreshDesignerActionsHandler != null) { view.Idle -= this.refreshDesignerActionsHandler; } if (this.refreshTasksHandler != null) { view.Idle -= this.refreshTasksHandler; } } this.refreshTypesHandler = null; this.refreshDesignerActionsHandler = null; this.refreshTasksHandler = null; IExtendedUIService service = this.serviceProvider.GetService(typeof(IExtendedUIService)) as IExtendedUIService; if (service != null) { service.RemoveDesignerActions(); } IPropertyValueUIService service2 = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService; if (service2 != null) { service2.RemovePropertyValueUIHandler(new PropertyValueUIHandler(this.OnPropertyGridAdornments)); } IComponentChangeService service3 = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (service3 != null) { service3.ComponentChanged -= new ComponentChangedEventHandler(this.OnComponentChanged); } ISelectionService service4 = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; if (service4 != null) { service4.SelectionChanged -= new EventHandler(this.OnSelectionChanged); } ITypeProvider provider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (provider != null) { provider.TypesChanged -= new EventHandler(this.OnTypeSystemTypesChanged); } IDesignerEventService service5 = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (service5 != null) { service5.ActiveDesignerChanged -= new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } this.serviceProvider.LoadComplete -= new EventHandler(this.OnDesignerReloaded); }
public override void Initialize(IComponent component) { base.Initialize(component); IComponentChangeService changeService = GetService(typeof(IComponentChangeService)) as IComponentChangeService; IDesignerEventService desigerEvt = GetService(typeof(IDesignerEventService)) as IDesignerEventService; changeService.ComponentRemoved += new ComponentEventHandler(changeService_ComponentRemoved); orbAdorner = new Adorner(); tabAdorner = new Adorner(); BehaviorService.Adorners.AddRange(new Adorner[] { orbAdorner, tabAdorner }); if (Ribbon.QuickAcessToolbar.Visible) { quickAccessAdorner = new Adorner(); BehaviorService.Adorners.Add(quickAccessAdorner); quickAccessAdorner.Glyphs.Add(new RibbonQuickAccessToolbarGlyph(BehaviorService, this, Ribbon)); } else { quickAccessAdorner = null; } //orbAdorner.Glyphs.Add(new RibbonOrbAdornerGlyph(BehaviorService, this, Ribbon)); tabAdorner.Glyphs.Add(new RibbonTabGlyph(BehaviorService, this, Ribbon)); }
public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider) { this.serviceProvider = serviceProvider; this.serviceProvider.LoadComplete += new EventHandler(this.OnDesignerReloaded); IDesignerEventService service = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (service != null) { service.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } ITypeProvider provider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (provider != null) { provider.TypesChanged += new EventHandler(this.OnTypeSystemTypesChanged); } ISelectionService service2 = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; if (service2 != null) { service2.SelectionChanged += new EventHandler(this.OnSelectionChanged); } IComponentChangeService service3 = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (service3 != null) { service3.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged); } IPropertyValueUIService service4 = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService; if (service4 != null) { service4.AddPropertyValueUIHandler(new PropertyValueUIHandler(this.OnPropertyGridAdornments)); } }
private IEventBindingService GetEventPropertyService(object obj, ITypeDescriptorContext context) { IEventBindingService service = null; if (!this.sunkEvent) { IDesignerEventService service2 = (IDesignerEventService)this.sp.GetService(typeof(IDesignerEventService)); if (service2 != null) { service2.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } this.sunkEvent = true; } if ((service == null) && (this.currentHost != null)) { service = (IEventBindingService)this.currentHost.GetService(typeof(IEventBindingService)); } if ((service == null) && (obj is IComponent)) { ISite site = ((IComponent)obj).Site; if (site != null) { service = (IEventBindingService)site.GetService(typeof(IEventBindingService)); } } if ((service == null) && (context != null)) { service = (IEventBindingService)context.GetService(typeof(IEventBindingService)); } return(service); }
//- realy on SurfaceManager.ActiveDesignSurface //- which effectively points to ACTIVE DesignSurface public void ReloadComboBox() { _bSuppressEvents = true; try { //- IDesignerEventService provides a global eventing mechanism for designer events. With this mechanism, //- an application is informed when a designer becomes active. The service provides a collection of //- designers and a single place where global objects, such as the Properties window, can monitor selection //- change events. IDesignerEventService des = (IDesignerEventService) SurfaceManager.GetService( typeof( IDesignerEventService ) ); if( null == des ) return; IDesignerHost host = des.ActiveDesigner; object selectedObj = pgrdPropertyGrid.SelectedObject; if( null == selectedObj ) return; //- don't reload at all //- get the name of the control selected from the comboBox //- and if we are not able to get it then it's better to exit string sName = string.Empty; if( selectedObj is Form ) { sName = ((Form) selectedObj).Name; } else if( selectedObj is Control ) { sName = ((Control) selectedObj).Site.Name; } if( string.IsNullOrEmpty( sName ) ) return; //- prepare the data for reloading the combobox (begin) List<object> ctrlsToAdd = new List<object>(); string pgrdComboBox_Text = string.Empty; try { ComponentCollection ctrlsExisting = host.Container.Components; Debug.Assert( 0 != ctrlsExisting.Count ); foreach( Component comp in ctrlsExisting ) { string sItemText = TranslateComponentToName( comp ); ctrlsToAdd.Add( sItemText ); if( sName == comp.Site.Name ) pgrdComboBox_Text = sItemText; }//end_foreach } catch( Exception ) { return; //- (rollback) } //- update the combobox (commit) pgrdComboBox.Items.Clear(); pgrdComboBox.Items.AddRange( ctrlsToAdd.ToArray() ); pgrdComboBox.Text = pgrdComboBox_Text; } finally { _bSuppressEvents = false; } }
public override void Initialize(IComponent component) { base.Initialize(component); IComponentChangeService changeService = GetService(typeof(IComponentChangeService)) as IComponentChangeService; IDesignerEventService desigerEvt = GetService(typeof(IDesignerEventService)) as IDesignerEventService; changeService.ComponentRemoved += new ComponentEventHandler(changeService_ComponentRemoved); }
private void OnTypeSystemTypesChanged(object sender, EventArgs e) { this.typeSystemTypesChanged = true; IDesignerEventService service = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if ((service != null) && (service.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost)))) { this.RefreshTypes(); } }
//- rely on SurfaceManager.ActiveDesignSurface //- which effectively points to ACTIVE DesignSurface private void OrientPropertyGridTowardsObject() { //- IDesignerEventService provides a global eventing mechanism for designer events. With this mechanism, //- an application is informed when a designer becomes active. The service provides a collection of //- designers and a single place where global objects, such as the Properties window, can monitor selection //- change events. IDesignerEventService des = (IDesignerEventService)SurfaceManager.GetService(typeof(IDesignerEventService)); if (null == des) { return; } IDesignerHost host = des.ActiveDesigner; //- get the ISelectionService from the active Designsurface //- and if we are not able to get it then it'sType better to exit ISelectionService iSel = host.GetService(typeof(ISelectionService)) as ISelectionService; if (iSel == null) { return; } //- get the name of the control selected from the comboBox //- and if we are not able to get it then it's better to exit string sName = pgrdComboBox.SelectedItem.ToString(); if (string.IsNullOrEmpty(sName)) { return; } //- save the collection of objects currently selected //- loop through the controls inside the current Designsurface //- if we find the one selected into the comboBox then //- use the ISelectionService to select it //- (and this will select it into the PropertyGridHost) ComponentCollection ctrlsExisting = host.Container.Components; Debug.Assert(0 != ctrlsExisting.Count); foreach (Component comp in ctrlsExisting) { string sItemText = TranslateComponentToName(comp); if (sName == sItemText) { Component[] arr = { comp }; //- ISelectionService in action... iSel.SetSelectedComponents(arr); //this.SelectedObject = arr[0]; break; } } }
internal void OnDesignerInfoChanged(DesignerToolboxInfo state) { if (this._designerEventService == null) { this._designerEventService = state.DesignerHost.GetService(typeof(IDesignerEventService)) as IDesignerEventService; } if ((this._designerEventService != null) && (this._designerEventService.ActiveDesigner == state.DesignerHost)) { this.FilterChanged(); } }
private void OnTypeSystemTypesChanged(object sender, EventArgs e) { this.typeSystemTypesChanged = true; //If the current designer is not active designer then we need to wait for it to be active before we update the types IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (designerEventService != null && designerEventService.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost))) { RefreshTypes(); } }
private void OnRefreshTasks(object sender, EventArgs e) { WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; if (this.refreshTasksHandler != null) { if (workflowView != null) { workflowView.Idle -= this.refreshTasksHandler; } this.refreshTasksHandler = null; } ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; IExtendedUIService extendedUIService = this.serviceProvider.GetService(typeof(IExtendedUIService)) as IExtendedUIService; if (selectionService != null && extendedUIService != null) { extendedUIService.RemoveDesignerActions(); //Only if the current designer is active designer we add the designer actions to the task list IDesignerEventService designerEventService = (IDesignerEventService)this.serviceProvider.GetService(typeof(IDesignerEventService)); if (designerEventService != null && designerEventService.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost))) { foreach (object obj in selectionService.GetSelectedComponents()) { ActivityDesigner activityDesigner = null; if (obj is HitTestInfo) { activityDesigner = ((HitTestInfo)obj).AssociatedDesigner; } else if (obj is Activity) { activityDesigner = ActivityDesigner.GetDesigner(obj as Activity); } if (activityDesigner != null) { extendedUIService.AddDesignerActions(new List <DesignerAction>(activityDesigner.DesignerActions).ToArray()); } } } } if (workflowView != null) { workflowView.Invalidate(); } }
/// <devdoc> /// Visual Studio tells us that a project is going to be closed before it /// begins closing document windows. We must release type loaders at /// project close, but this means that any unflushed designers won't /// be able to get to their type loaders. So flush all of them here. /// </devdoc> private void FlushAllOpenDesigners() { IDesignerEventService ds = (IDesignerEventService)GetService(typeof(IDesignerEventService)); if (ds != null) { foreach (IDesignerHost host in ds.Designers) { IVSMDDesigner designer = host as IVSMDDesigner; if (designer != null) { designer.Flush(); } } } }
private void OnRefreshTasks(object sender, EventArgs e) { WorkflowView view = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; if (this.refreshTasksHandler != null) { if (view != null) { view.Idle -= this.refreshTasksHandler; } this.refreshTasksHandler = null; } ISelectionService service = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; IExtendedUIService service2 = this.serviceProvider.GetService(typeof(IExtendedUIService)) as IExtendedUIService; if ((service != null) && (service2 != null)) { service2.RemoveDesignerActions(); IDesignerEventService service3 = (IDesignerEventService)this.serviceProvider.GetService(typeof(IDesignerEventService)); if ((service3 != null) && (service3.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost)))) { foreach (object obj2 in service.GetSelectedComponents()) { ActivityDesigner associatedDesigner = null; if (obj2 is HitTestInfo) { associatedDesigner = ((HitTestInfo)obj2).AssociatedDesigner; } else if (obj2 is Activity) { associatedDesigner = ActivityDesigner.GetDesigner(obj2 as Activity); } if (associatedDesigner != null) { service2.AddDesignerActions(new List <DesignerAction>(associatedDesigner.DesignerActions).ToArray()); } } } } if (view != null) { view.Invalidate(); } }
public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider) { this.serviceProvider = serviceProvider; this.serviceProvider.LoadComplete += new EventHandler(OnDesignerReloaded); //Listen to the events so that we are sure that we appropriately refresh the designer actions and tasks when the types //change IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (designerEventService != null) { designerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(OnActiveDesignerChanged); } ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (typeProvider != null) { typeProvider.TypesChanged += new EventHandler(OnTypeSystemTypesChanged); } ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; if (selectionService != null) { selectionService.SelectionChanged += new EventHandler(OnSelectionChanged); } IComponentChangeService componentChangedService = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (componentChangedService != null) { componentChangedService.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged); } IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService; if (propertyValueService != null) { propertyValueService.AddPropertyValueUIHandler(new PropertyValueUIHandler(OnPropertyGridAdornments)); } }
/// <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 initilaization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { base.Initialize(); // Remove SolutionListenerForProjectUpdates from collection of SolutionListeners as we do not support references SolutionListenerForProjectReferenceUpdate referenceUpdateListener = SolutionListeners.OfType <SolutionListenerForProjectReferenceUpdate>().SingleOrDefault(); if (referenceUpdateListener != null) { referenceUpdateListener.Dispose(); SolutionListeners.Remove(referenceUpdateListener); } // Find SolutionListenerForProjectEvents and subscribe to OnBeforeProjectClosed SolutionListenerForProjectEvents projectEventListener = SolutionListeners.OfType <SolutionListenerForProjectEvents>().SingleOrDefault(); if (projectEventListener != null) { projectEventListener.BeforeProjectFileClosed += new EventHandler <BeforeProjectFileClosedEventArgs>(OnBeforeProjectFileClosed); } // Hook designer event services IDesignerEventService eventService = (IDesignerEventService)GetService(typeof(IDesignerEventService)); eventService.DesignerCreated += new DesignerEventHandler(OnDesignerCreated); // Hook ToolboxInitialized event this.ToolboxInitialized += new EventHandler(OnToolboxInitialized); this.ToolboxUpgraded += new EventHandler(OnToolboxUpgraded); // Add menu handlers this.AddMenuHandlers(); // Create settings service AddonStudioSettings settings = new AddonStudioSettings(this); // Add service this.AddService(typeof(IInterfaceStudioSettings), settings); // Register the WoW project factory base.RegisterProjectFactory(new MultiverseInterfaceProjectFactory(this)); }
private void StopMonitoring(object sender, EventArgs e) { IDesignerEventService des = (IDesignerEventService)this.Control.Site.GetService(typeof(IDesignerEventService)); if (des == null) { return; } // Remove event handlers for event notification methods. des.DesignerCreated -= new DesignerEventHandler(this.DesignerCreated); des.DesignerDisposed -= new DesignerEventHandler(this.DesignerDisposed); des.ActiveDesignerChanged -= new ActiveDesignerEventHandler(this.DesignerChanged); des.SelectionChanged -= new EventHandler(this.SelectionChanged); dm.monitoring_events = false; // Rebuild menu with "Start monitoring" command. dvc = new DesignerVerbCollection(new DesignerVerb[] { new DesignerVerb("Start monitoring", new EventHandler(this.StartMonitoring)) }); dm.Refresh(); }
private IEventBindingService GetEventPropertyService(object obj, ITypeDescriptorContext context) { IEventBindingService eventPropertySvc = null; if (!sunkEvent) { IDesignerEventService des = (IDesignerEventService)sp.GetService(typeof(IDesignerEventService)); Debug.Assert(des != null, "Unable to get DesignerEventService for EventsTab"); if (des != null) { des.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } sunkEvent = true; } if (eventPropertySvc == null && currentHost != null) { eventPropertySvc = (IEventBindingService)currentHost.GetService(typeof(IEventBindingService)); } if (eventPropertySvc == null && obj is IComponent) { ISite site = ((IComponent)obj).Site; if (site != null) { eventPropertySvc = (IEventBindingService)site.GetService(typeof(IEventBindingService)); } } if (eventPropertySvc == null && context != null) { eventPropertySvc = (IEventBindingService)context.GetService(typeof(IEventBindingService)); } return(eventPropertySvc); }
//<Snippet1> public void LinkDesignerEvent(IDesignerEventService eventService) { // Registers an event handler for the DesignerCreated and DesignerDisposed events. eventService.DesignerCreated += new DesignerEventHandler(this.OnDesignerEvent); eventService.DesignerDisposed += new DesignerEventHandler(this.OnDesignerEvent); }
private void EnsureDesignerEventService() { if (GetFlag(GotDesignerEventService)) { return; } designerEventService = (IDesignerEventService)GetService(typeof(IDesignerEventService)); if (designerEventService != null) { SetFlag(GotDesignerEventService, true); designerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); OnActiveDesignerChanged(null, new ActiveDesignerEventArgs(null, designerEventService.ActiveDesigner)); } }
/// <include file='doc\PropertyGrid.uex' path='docs/doc[@for="PropertyGrid.Dispose"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> protected override void Dispose(bool disposing) { if (disposing) { // Unhook IDesignerEventService.ActiveDesignerChanged event // if (GetFlag(GotDesignerEventService)) { Debug.Assert(designerEventService != null, "GetFlag(GotDesignerEventService) inconsistent with designerEventService == null"); if (designerEventService != null) { designerEventService.ActiveDesignerChanged -= new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } designerEventService = null; SetFlag(GotDesignerEventService, false); } this.ActiveDesigner = null; if (viewTabs != null) { for (int i = 0; i < viewTabs.Length; i++) { viewTabs[i].Dispose(); } viewTabs = null; } if (imageList != null) { for (int i = 0; i < imageList.Length; i++) { if(imageList[i] != null) { imageList[i].Dispose(); } } imageList = null; } if (bmpAlpha != null) { bmpAlpha.Dispose(); bmpAlpha = null; } if (bmpCategory != null) { bmpCategory.Dispose(); bmpCategory = null; } if (bmpPropPage != null) { bmpPropPage.Dispose(); bmpPropPage = null; } if (lineBrush != null) { lineBrush.Dispose(); lineBrush = null; } if (peMain != null) { peMain.Dispose(); peMain = null; } if (currentObjects != null) { currentObjects = null; SinkPropertyNotifyEvents(); } ClearCachedProps(); currentPropEntries = null; } base.Dispose(disposing); }
internal void BeginLoad(DesignerLoader loader) { if ((this._loader != null) && (this._loader != loader)) { Exception exception = new InvalidOperationException(System.Design.SR.GetString("DesignerHostLoaderSpecified")) { HelpLink = "DesignerHostLoaderSpecified" }; throw exception; } IDesignerEventService service = null; bool flag = this._loader != null; this._loader = loader; if (!flag) { if (loader is IExtenderProvider) { IExtenderProviderService service2 = this.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService; if (service2 != null) { service2.AddExtenderProvider((IExtenderProvider) loader); } } service = this.GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (service != null) { service.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); this._designerEventService = service; } } this._state[StateLoading] = true; this._surface.OnLoading(); try { this._loader.BeginLoad(this); } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } string message = innerException.Message; if ((message == null) || (message.Length == 0)) { innerException = new Exception(System.Design.SR.GetString("DesignSurfaceFatalError", new object[] { innerException.ToString() }), innerException); } ((IDesignerLoaderHost) this).EndLoad(null, false, new object[] { innerException }); } if (this._designerEventService == null) { this.OnActiveDesignerChanged(null, new ActiveDesignerEventArgs(null, this)); } }
private void EnsureDesignerEventService() { if (!this.GetFlag(2)) { this.designerEventService = (IDesignerEventService) this.GetService(typeof(IDesignerEventService)); if (this.designerEventService != null) { this.SetFlag(2, true); this.designerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); this.OnActiveDesignerChanged(null, new ActiveDesignerEventArgs(null, this.designerEventService.ActiveDesigner)); } } }
internal DesignerCreationListener(IDesignerEventService designerEvents, Options options) { designerEvents.DesignerCreated += (s, e) => e.Designer.LoadComplete += OnDesignerLoaded; _options = options; }
// </snippet6> // <snippet7> // This utility method connects the designer to various // services it will use. private void InitializeServices() { // Acquire a reference to DesignerActionService. this.actionService = GetService(typeof(DesignerActionService)) as DesignerActionService; // Acquire a reference to DesignerActionUIService. this.actionUiService = GetService(typeof(DesignerActionUIService)) as DesignerActionUIService; // Acquire a reference to IComponentChangeService. this.changeService = GetService(typeof(IComponentChangeService)) as IComponentChangeService; // <snippet14> // Hook the IComponentChangeService events. if (this.changeService != null) { this.changeService.ComponentChanged += new ComponentChangedEventHandler( ChangeService_ComponentChanged); this.changeService.ComponentAdded += new ComponentEventHandler( ChangeService_ComponentAdded); this.changeService.ComponentRemoved += new ComponentEventHandler( changeService_ComponentRemoved); } // </snippet14> // Acquire a reference to ISelectionService. this.selectionService = GetService(typeof(ISelectionService)) as ISelectionService; // Hook the SelectionChanged event. if (this.selectionService != null) { this.selectionService.SelectionChanged += new EventHandler(selectionService_SelectionChanged); } // Acquire a reference to IDesignerEventService. this.eventService = GetService(typeof(IDesignerEventService)) as IDesignerEventService; if (this.eventService != null) { this.eventService.ActiveDesignerChanged += new ActiveDesignerEventHandler( eventService_ActiveDesignerChanged); } // Acquire a reference to IDesignerHost. this.host = GetService(typeof(IDesignerHost)) as IDesignerHost; // Acquire a reference to IDesignerOptionService. this.optionService = GetService(typeof(IDesignerOptionService)) as IDesignerOptionService; // Acquire a reference to IEventBindingService. this.eventBindingService = GetService(typeof(IEventBindingService)) as IEventBindingService; // Acquire a reference to IExtenderListService. this.listService = GetService(typeof(IExtenderListService)) as IExtenderListService; // Acquire a reference to IReferenceService. this.referenceService = GetService(typeof(IReferenceService)) as IReferenceService; // Acquire a reference to ITypeResolutionService. this.typeResService = GetService(typeof(ITypeResolutionService)) as ITypeResolutionService; // Acquire a reference to IComponentDiscoveryService. this.componentDiscoveryService = GetService(typeof(IComponentDiscoveryService)) as IComponentDiscoveryService; // Acquire a reference to IToolboxService. this.toolboxService = GetService(typeof(IToolboxService)) as IToolboxService; // Acquire a reference to UndoEngine. this.undoEng = GetService(typeof(UndoEngine)) as UndoEngine; if (this.undoEng != null) { MessageBox.Show("UndoEngine"); } }
//<Snippet1> public void LinkActiveDesignerEvent(IDesignerEventService eventService) { // Registers an event handler for the ActiveDesignerChanged event. eventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerEvent); }
protected override void Dispose(bool disposing) { if (disposing) { if (this.GetFlag(2)) { if (this.designerEventService != null) { this.designerEventService.ActiveDesignerChanged -= new ActiveDesignerEventHandler(this.OnActiveDesignerChanged); } this.designerEventService = null; this.SetFlag(2, false); } this.ActiveDesigner = null; if (this.viewTabs != null) { for (int i = 0; i < this.viewTabs.Length; i++) { this.viewTabs[i].Dispose(); } this.viewTabs = null; } if (this.imageList != null) { for (int j = 0; j < this.imageList.Length; j++) { if (this.imageList[j] != null) { this.imageList[j].Dispose(); } } this.imageList = null; } if (this.bmpAlpha != null) { this.bmpAlpha.Dispose(); this.bmpAlpha = null; } if (this.bmpCategory != null) { this.bmpCategory.Dispose(); this.bmpCategory = null; } if (this.bmpPropPage != null) { this.bmpPropPage.Dispose(); this.bmpPropPage = null; } if (this.lineBrush != null) { this.lineBrush.Dispose(); this.lineBrush = null; } if (this.peMain != null) { this.peMain.Dispose(); this.peMain = null; } if (this.currentObjects != null) { this.currentObjects = null; this.SinkPropertyNotifyEvents(); } this.ClearCachedProps(); this.currentPropEntries = null; } base.Dispose(disposing); }