Пример #1
0
        public override void Initialize(IComponent component)
        {
            base.Initialize(component);
            this.inheritanceService = new InheritanceService();
            ISite                    provider  = component.Site;
            IContainer               container = null;
            IDesignerHost            host      = (IDesignerHost)this.GetService(typeof(IDesignerHost));
            IExtenderProviderService ex        = (IExtenderProviderService)this.GetService(typeof(IExtenderProviderService));

            if (ex != null)
            {
                this.designerExtenders = new DesignerExtenders(ex);
            }
            if (host != null)
            {
                this.eventHandlerService = new EventHandlerService(null);
                this.selectionUIService  = new SelectionUIService(host);
                host.AddService(typeof(IInheritanceService), this.inheritanceService);
                host.AddService(typeof(IEventHandlerService), this.eventHandlerService);
                host.AddService(typeof(ISelectionUIService), this.selectionUIService);
                this.compositionUI = new CompositionUI(this, provider);
                host.AddService(typeof(ComponentTray), this.compositionUI);
                IComponentChangeService service2 = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
                if (service2 != null)
                {
                    service2.ComponentAdded   += new ComponentEventHandler(this.OnComponentAdded);
                    service2.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
                }
                ISelectionService service3 = (ISelectionService)this.GetService(typeof(ISelectionService));
                if (service3 != null)
                {
                    service3.SetSelectedComponents(new object[] { component }, SelectionTypes.Auto);
                }
            }
            if (provider != null)
            {
                this.commandSet = new CompositionCommandSet(this.compositionUI, provider);
                container       = provider.Container;
            }
            this.pbrsFwd = new PbrsForward(this.compositionUI, provider);
            this.inheritanceService.AddInheritedComponents(component, container);
            IServiceContainer service = (IServiceContainer)this.GetService(typeof(IServiceContainer));

            if (service != null)
            {
                this.delegateFilterService = (ITypeDescriptorFilterService)this.GetService(typeof(ITypeDescriptorFilterService));
                if (this.delegateFilterService != null)
                {
                    service.RemoveService(typeof(ITypeDescriptorFilterService));
                }
                service.AddService(typeof(ITypeDescriptorFilterService), this);
            }
        }
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         IDesignerHost host = (IDesignerHost) this.GetService(typeof(IDesignerHost));
         if (host != null)
         {
             host.RemoveService(typeof(IInheritanceService));
             host.RemoveService(typeof(IEventHandlerService));
             host.RemoveService(typeof(ISelectionUIService));
             host.RemoveService(typeof(ComponentTray));
             IComponentChangeService service = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
             if (service != null)
             {
                 service.ComponentAdded -= new ComponentEventHandler(this.OnComponentAdded);
                 service.ComponentRemoved -= new ComponentEventHandler(this.OnComponentRemoved);
             }
         }
         if (this.selectionUIService != null)
         {
             this.selectionUIService.Dispose();
             this.selectionUIService = null;
         }
         if (this.commandSet != null)
         {
             this.commandSet.Dispose();
             this.commandSet = null;
         }
         if (this.pbrsFwd != null)
         {
             this.pbrsFwd.Dispose();
             this.pbrsFwd = null;
         }
         if (this.compositionUI != null)
         {
             this.compositionUI.Dispose();
             this.compositionUI = null;
         }
         if (this.designerExtenders != null)
         {
             this.designerExtenders.Dispose();
             this.designerExtenders = null;
         }
         if (this.inheritanceService != null)
         {
             this.inheritanceService.Dispose();
             this.inheritanceService = null;
         }
     }
     base.Dispose(disposing);
 }
Пример #3
0
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         IDesignerHost host = (IDesignerHost)this.GetService(typeof(IDesignerHost));
         if (host != null)
         {
             host.RemoveService(typeof(IInheritanceService));
             host.RemoveService(typeof(IEventHandlerService));
             host.RemoveService(typeof(ISelectionUIService));
             host.RemoveService(typeof(ComponentTray));
             IComponentChangeService service = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
             if (service != null)
             {
                 service.ComponentAdded   -= new ComponentEventHandler(this.OnComponentAdded);
                 service.ComponentRemoved -= new ComponentEventHandler(this.OnComponentRemoved);
             }
         }
         if (this.selectionUIService != null)
         {
             this.selectionUIService.Dispose();
             this.selectionUIService = null;
         }
         if (this.commandSet != null)
         {
             this.commandSet.Dispose();
             this.commandSet = null;
         }
         if (this.pbrsFwd != null)
         {
             this.pbrsFwd.Dispose();
             this.pbrsFwd = null;
         }
         if (this.compositionUI != null)
         {
             this.compositionUI.Dispose();
             this.compositionUI = null;
         }
         if (this.designerExtenders != null)
         {
             this.designerExtenders.Dispose();
             this.designerExtenders = null;
         }
         if (this.inheritanceService != null)
         {
             this.inheritanceService.Dispose();
             this.inheritanceService = null;
         }
     }
     base.Dispose(disposing);
 }
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         IDesignerHost host = (IDesignerHost) this.GetService(typeof(IDesignerHost));
         if (host != null)
         {
             ToolStripAdornerWindowService service = (ToolStripAdornerWindowService) this.GetService(typeof(ToolStripAdornerWindowService));
             if (service != null)
             {
                 service.Dispose();
                 host.RemoveService(typeof(ToolStripAdornerWindowService));
             }
             host.Activated -= new EventHandler(this.OnDesignerActivate);
             host.Deactivated -= new EventHandler(this.OnDesignerDeactivate);
             if (this.componentTray != null)
             {
                 ISplitWindowService service2 = (ISplitWindowService) this.GetService(typeof(ISplitWindowService));
                 if (service2 != null)
                 {
                     service2.RemoveSplitWindow(this.componentTray);
                     this.componentTray.Dispose();
                     this.componentTray = null;
                 }
                 host.RemoveService(typeof(ComponentTray));
             }
             IComponentChangeService service3 = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
             if (service3 != null)
             {
                 service3.ComponentAdded -= new ComponentEventHandler(this.OnComponentAdded);
                 service3.ComponentChanged -= new ComponentChangedEventHandler(this.OnComponentChanged);
                 service3.ComponentRemoved -= new ComponentEventHandler(this.OnComponentRemoved);
             }
             if (this.undoEngine != null)
             {
                 this.undoEngine.Undoing -= new EventHandler(this.OnUndoing);
                 this.undoEngine.Undone -= new EventHandler(this.OnUndone);
             }
             if (this.toolboxCreator != null)
             {
                 IToolboxService service4 = (IToolboxService) this.GetService(typeof(IToolboxService));
                 if (service4 != null)
                 {
                     service4.RemoveCreator(axClipFormat, host);
                     service4.RemoveCreator(OleDragDropHandler.DataFormat, host);
                     service4.RemoveCreator(OleDragDropHandler.NestedToolboxItemFormat, host);
                 }
                 this.toolboxCreator = null;
             }
         }
         if (this.menuEditorService != null)
         {
             host.RemoveService(typeof(IMenuEditorService));
             this.menuEditorService = null;
         }
         ISelectionService service5 = (ISelectionService) this.GetService(typeof(ISelectionService));
         if (service5 != null)
         {
             service5.SelectionChanged -= new EventHandler(this.OnSelectionChanged);
         }
         if (this.behaviorService != null)
         {
             this.behaviorService.Dispose();
             this.behaviorService = null;
         }
         if (this.selectionManager != null)
         {
             this.selectionManager.Dispose();
             this.selectionManager = null;
         }
         if (this.componentTray != null)
         {
             if (host != null)
             {
                 ISplitWindowService service6 = (ISplitWindowService) this.GetService(typeof(ISplitWindowService));
                 if (service6 != null)
                 {
                     service6.RemoveSplitWindow(this.componentTray);
                 }
             }
             this.componentTray.Dispose();
             this.componentTray = null;
         }
         if (this.pbrsFwd != null)
         {
             this.pbrsFwd.Dispose();
             this.pbrsFwd = null;
         }
         if (this.frame != null)
         {
             this.frame.Dispose();
             this.frame = null;
         }
         if (this.commandSet != null)
         {
             this.commandSet.Dispose();
             this.commandSet = null;
         }
         if (this.inheritanceService != null)
         {
             this.inheritanceService.Dispose();
             this.inheritanceService = null;
         }
         if (this.inheritanceUI != null)
         {
             this.inheritanceUI.Dispose();
             this.inheritanceUI = null;
         }
         if (this.designBindingValueUIHandler != null)
         {
             IPropertyValueUIService service7 = (IPropertyValueUIService) this.GetService(typeof(IPropertyValueUIService));
             if (service7 != null)
             {
                 service7.RemovePropertyValueUIHandler(new PropertyValueUIHandler(this.designBindingValueUIHandler.OnGetUIValueItem));
                 service7 = null;
             }
             this.designBindingValueUIHandler.Dispose();
             this.designBindingValueUIHandler = null;
         }
         if (this.designerExtenders != null)
         {
             this.designerExtenders.Dispose();
             this.designerExtenders = null;
         }
         if (this.axTools != null)
         {
             this.axTools.Clear();
         }
         if (host != null)
         {
             host.RemoveService(typeof(BehaviorService));
             host.RemoveService(typeof(ToolStripAdornerWindowService));
             host.RemoveService(typeof(SelectionManager));
             host.RemoveService(typeof(IInheritanceService));
             host.RemoveService(typeof(IEventHandlerService));
             host.RemoveService(typeof(IOverlayService));
             host.RemoveService(typeof(ISplitWindowService));
             host.RemoveService(typeof(InheritanceUI));
         }
     }
     base.Dispose(disposing);
 }
 public override void Initialize(IComponent component)
 {
     this.initializing = true;
     base.Initialize(component);
     this.initializing = false;
     PropertyDescriptor descriptor = TypeDescriptor.GetProperties(base.Component.GetType())["BackColor"];
     if (((descriptor != null) && (descriptor.PropertyType == typeof(System.Drawing.Color))) && !descriptor.ShouldSerializeValue(base.Component))
     {
         this.Control.BackColor = SystemColors.Control;
     }
     IDesignerHost serviceProvider = (IDesignerHost) this.GetService(typeof(IDesignerHost));
     IExtenderProviderService ex = (IExtenderProviderService) this.GetService(typeof(IExtenderProviderService));
     if (ex != null)
     {
         this.designerExtenders = new DesignerExtenders(ex);
     }
     if (serviceProvider != null)
     {
         serviceProvider.Activated += new EventHandler(this.OnDesignerActivate);
         serviceProvider.Deactivated += new EventHandler(this.OnDesignerDeactivate);
         ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
         serviceProvider.AddService(typeof(IEventHandlerService), callback);
         this.frame = new DesignerFrame(component.Site);
         IOverlayService frame = this.frame;
         serviceProvider.AddService(typeof(IOverlayService), frame);
         serviceProvider.AddService(typeof(ISplitWindowService), this.frame);
         this.behaviorService = new BehaviorService(base.Component.Site, this.frame);
         serviceProvider.AddService(typeof(BehaviorService), this.behaviorService);
         this.selectionManager = new SelectionManager(serviceProvider, this.behaviorService);
         serviceProvider.AddService(typeof(SelectionManager), this.selectionManager);
         serviceProvider.AddService(typeof(ToolStripAdornerWindowService), callback);
         IComponentChangeService service = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
         if (service != null)
         {
             service.ComponentAdded += new ComponentEventHandler(this.OnComponentAdded);
             service.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged);
             service.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
         }
         this.inheritanceUI = new InheritanceUI();
         serviceProvider.AddService(typeof(InheritanceUI), this.inheritanceUI);
         InheritanceService serviceInstance = new DocumentInheritanceService(this);
         serviceProvider.AddService(typeof(IInheritanceService), serviceInstance);
         manager = serviceProvider.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager;
         serviceInstance.AddInheritedComponents(component, component.Site.Container);
         manager = null;
         this.inheritanceService = serviceInstance;
         if (this.Control.IsHandleCreated)
         {
             this.OnCreateHandle();
         }
         IPropertyValueUIService service5 = (IPropertyValueUIService) component.Site.GetService(typeof(IPropertyValueUIService));
         if (service5 != null)
         {
             this.designBindingValueUIHandler = new DesignBindingValueUIHandler();
             service5.AddPropertyValueUIHandler(new PropertyValueUIHandler(this.designBindingValueUIHandler.OnGetUIValueItem));
         }
         IToolboxService service6 = (IToolboxService) serviceProvider.GetService(typeof(IToolboxService));
         if (service6 != null)
         {
             this.toolboxCreator = new ToolboxItemCreatorCallback(this.OnCreateToolboxItem);
             service6.AddCreator(this.toolboxCreator, axClipFormat, serviceProvider);
             service6.AddCreator(this.toolboxCreator, OleDragDropHandler.DataFormat, serviceProvider);
             service6.AddCreator(this.toolboxCreator, OleDragDropHandler.NestedToolboxItemFormat, serviceProvider);
         }
         serviceProvider.LoadComplete += new EventHandler(this.OnLoadComplete);
     }
     this.commandSet = new ControlCommandSet(component.Site);
     this.frame.Initialize(this.Control);
     this.pbrsFwd = new PbrsForward(this.frame, component.Site);
     this.Location = new Point(0, 0);
 }
 public override void Initialize(IComponent component)
 {
     base.Initialize(component);
     this.inheritanceService = new InheritanceService();
     ISite provider = component.Site;
     IContainer container = null;
     IDesignerHost host = (IDesignerHost) this.GetService(typeof(IDesignerHost));
     IExtenderProviderService ex = (IExtenderProviderService) this.GetService(typeof(IExtenderProviderService));
     if (ex != null)
     {
         this.designerExtenders = new DesignerExtenders(ex);
     }
     if (host != null)
     {
         this.eventHandlerService = new EventHandlerService(null);
         this.selectionUIService = new SelectionUIService(host);
         host.AddService(typeof(IInheritanceService), this.inheritanceService);
         host.AddService(typeof(IEventHandlerService), this.eventHandlerService);
         host.AddService(typeof(ISelectionUIService), this.selectionUIService);
         this.compositionUI = new CompositionUI(this, provider);
         host.AddService(typeof(ComponentTray), this.compositionUI);
         IComponentChangeService service2 = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
         if (service2 != null)
         {
             service2.ComponentAdded += new ComponentEventHandler(this.OnComponentAdded);
             service2.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
         }
         ISelectionService service3 = (ISelectionService) this.GetService(typeof(ISelectionService));
         if (service3 != null)
         {
             service3.SetSelectedComponents(new object[] { component }, SelectionTypes.Auto);
         }
     }
     if (provider != null)
     {
         this.commandSet = new CompositionCommandSet(this.compositionUI, provider);
         container = provider.Container;
     }
     this.pbrsFwd = new PbrsForward(this.compositionUI, provider);
     this.inheritanceService.AddInheritedComponents(component, container);
     IServiceContainer service = (IServiceContainer) this.GetService(typeof(IServiceContainer));
     if (service != null)
     {
         this.delegateFilterService = (ITypeDescriptorFilterService) this.GetService(typeof(ITypeDescriptorFilterService));
         if (this.delegateFilterService != null)
         {
             service.RemoveService(typeof(ITypeDescriptorFilterService));
         }
         service.AddService(typeof(ITypeDescriptorFilterService), this);
     }
 }
Пример #7
0
        /// <include file='doc\CompositionDesigner.uex' path='docs/doc[@for="ComponentDocumentDesigner.Dispose"]/*' />
        /// <devdoc>
        ///    <para>Disposes of the resources (other than memory) used by
        ///       the <see cref='System.Windows.Forms.Design.ComponentDocumentDesigner'/>.</para>
        /// </devdoc>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
                Debug.Assert(!CompModSwitches.CommonDesignerServices.Enabled || host != null, "IDesignerHost not found");

                if (host != null)
                {
                    host.RemoveService(typeof(IInheritanceService));
                    host.RemoveService(typeof(IEventHandlerService));
                    host.RemoveService(typeof(ISelectionUIService));
                    host.RemoveService(typeof(ComponentTray));

                    IComponentChangeService cs = (IComponentChangeService)GetService(typeof(IComponentChangeService));
                    Debug.Assert(!CompModSwitches.CommonDesignerServices.Enabled || cs != null, "IComponentChangeService not found");
                    if (cs != null)
                    {
                        cs.ComponentAdded   -= new ComponentEventHandler(OnComponentAdded);
                        cs.ComponentRemoved -= new ComponentEventHandler(OnComponentRemoved);
                    }
                }

                if (selectionUIService != null)
                {
                    selectionUIService.Dispose();
                    selectionUIService = null;
                }

                if (commandSet != null)
                {
                    commandSet.Dispose();
                    commandSet = null;
                }

                if (this.pbrsFwd != null)
                {
                    pbrsFwd.Dispose();
                    pbrsFwd = null;
                }

                if (compositionUI != null)
                {
                    compositionUI.Dispose();
                    compositionUI = null;
                }

                if (designerExtenders != null)
                {
                    designerExtenders.Dispose();
                    designerExtenders = null;
                }

                if (inheritanceService != null)
                {
                    inheritanceService.Dispose();
                    inheritanceService = null;
                }
            }
            base.Dispose(disposing);
        }
Пример #8
0
        /// <include file='doc\CompositionDesigner.uex' path='docs/doc[@for="ComponentDocumentDesigner.Initialize"]/*' />
        /// <devdoc>
        ///    <para>
        ///       Initializes the designer with the specified component.</para>
        /// </devdoc>
        public override void Initialize(IComponent component)
        {
            base.Initialize(component);

            inheritanceService = new InheritanceService();

            ISite      site      = component.Site;
            IContainer container = null;

            IDesignerHost            host = (IDesignerHost)GetService(typeof(IDesignerHost));
            IExtenderProviderService exps = (IExtenderProviderService)GetService(typeof(IExtenderProviderService));

            if (exps != null)
            {
                designerExtenders = new DesignerExtenders(exps);
            }

            Debug.Assert(!CompModSwitches.CommonDesignerServices.Enabled || host != null, "IDesignerHost not found");
            if (host != null)
            {
                eventHandlerService = new EventHandlerService(null);
                selectionUIService  = new SelectionUIService(host);

                host.AddService(typeof(IInheritanceService), inheritanceService);
                host.AddService(typeof(IEventHandlerService), eventHandlerService);
                host.AddService(typeof(ISelectionUIService), selectionUIService);

                compositionUI = new CompositionUI(this, site);

                host.AddService(typeof(ComponentTray), compositionUI);

                IComponentChangeService cs = (IComponentChangeService)GetService(typeof(IComponentChangeService));
                Debug.Assert(!CompModSwitches.CommonDesignerServices.Enabled || cs != null, "IComponentChangeService not found");
                if (cs != null)
                {
                    cs.ComponentAdded   += new ComponentEventHandler(OnComponentAdded);
                    cs.ComponentRemoved += new ComponentEventHandler(OnComponentRemoved);
                }

                // Select this component.
                //
                ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));
                if (ss != null)
                {
                    ss.SetSelectedComponents(new object[] { component }, SelectionTypes.Normal);
                }
            }

            // Set up our menu command set
            //
            if (site != null)
            {
                commandSet = new CompositionCommandSet(compositionUI, site);
                container  = site.Container;
            }

            this.pbrsFwd = new PbrsForward(compositionUI, site);

            // Hook up our inheritance service and do a scan for inherited components.
            //
            inheritanceService.AddInheritedComponents(component, container);

            // Hook yourself up to the ITypeDescriptorFilterService so we can hide the
            // location property on all components being added to the designer.
            //
            IServiceContainer serviceContainer = (IServiceContainer)GetService(typeof(IServiceContainer));

            if (serviceContainer != null)
            {
                delegateFilterService = (ITypeDescriptorFilterService)GetService(typeof(ITypeDescriptorFilterService));
                if (delegateFilterService != null)
                {
                    serviceContainer.RemoveService(typeof(ITypeDescriptorFilterService));
                }

                serviceContainer.AddService(typeof(ITypeDescriptorFilterService), this);
            }
        }