public override void Add(IComponent component, string name)
{
IDesigner designer;
base.Add(component, name);
if (_rootComponent == null)
{
_rootComponent = component;
designer = this.CreateDesigner(component, true);
}
else
{
designer = this.CreateDesigner(component, false);
}
if (designer != null)
{
_designers[component] = designer;
designer.Initialize(component);
}
if (component is IExtenderProvider)
{
IExtenderProviderService service = this.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
service.AddExtenderProvider((IExtenderProvider)component);
}
}
}
internal void RemoveCore(IComponent component)
{
IDesigner designer = _designers[component] as IDesigner;
if (designer != null)
{
designer.Dispose();
}
_designers.Remove(component);
if (component == _rootComponent)
{
_rootComponent = null;
}
if (component is IExtenderProvider)
{
IExtenderProviderService service = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
service.RemoveExtenderProvider((IExtenderProvider)component);
}
}
base.Remove(component);
}
protected override void Initialize(Activity activity)
{
base.Initialize(activity);
IExtenderListService service = (IExtenderListService)base.GetService(typeof(IExtenderListService));
if (service != null)
{
bool flag = false;
foreach (IExtenderProvider provider in service.GetExtenderProviders())
{
if (provider.GetType() == typeof(ConditionPropertyProviderExtender))
{
flag = true;
}
}
if (!flag)
{
IExtenderProviderService service2 = (IExtenderProviderService)base.GetService(typeof(IExtenderProviderService));
if (service2 != null)
{
service2.AddExtenderProvider(new ConditionPropertyProviderExtender());
}
}
}
}
internal void RemovePreProcess(IComponent component)
{
if (ComponentRemoving != null)
{
ComponentRemoving(this, new ComponentEventArgs(component));
}
IDesigner designer = _designers[component] as IDesigner;
if (designer != null)
{
designer.Dispose();
}
_designers.Remove(component);
if (component == _rootComponent)
{
_rootComponent = null;
}
if (component is IExtenderProvider)
{
IExtenderProviderService service = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
service.RemoveExtenderProvider((IExtenderProvider)component);
}
}
}
protected override void Initialize(Activity activity)
{
base.Initialize(activity);
IExtenderListService extenderListService = (IExtenderListService)GetService(typeof(IExtenderListService));
if (extenderListService != null)
{
bool foundExtender = false;
foreach (IExtenderProvider extenderProvider in extenderListService.GetExtenderProviders())
{
if (extenderProvider.GetType() == typeof(WorkflowServiceAttributesPropertyProviderExtender))
{
foundExtender = true;
}
}
if (!foundExtender)
{
IExtenderProviderService extenderProviderService = (IExtenderProviderService)GetService(typeof(IExtenderProviderService));
if (extenderProviderService != null)
{
extenderProviderService.AddExtenderProvider(new WorkflowServiceAttributesPropertyProviderExtender());
}
}
}
}
public LocalizationExtenderProvider(ISite serviceProvider, IComponent baseComponent)
{
this.serviceProvider = serviceProvider;
this.baseComponent = baseComponent;
if (serviceProvider != null)
{
IExtenderProviderService service = (IExtenderProviderService)serviceProvider.GetService(typeof(IExtenderProviderService));
if (service != null)
{
service.AddExtenderProvider(this);
}
}
this.language = CultureInfo.InvariantCulture;
ResourceManager manager = new ResourceManager(baseComponent.GetType());
if (manager != null)
{
ResourceSet set = manager.GetResourceSet(this.language, true, false);
if (set != null)
{
object obj2 = set.GetObject("$this.Localizable");
if (obj2 is bool)
{
this.defaultLocalizable = (bool)obj2;
this.localizable = this.defaultLocalizable;
}
}
}
}
public void ExtenderProviderService_AddExtenderProvider_NullProvider_ThrowsArgumentNullException()
{
var surface = new DesignSurface();
object service = surface.GetService(typeof(IExtenderListService));
IExtenderProviderService providerService = Assert.IsAssignableFrom <IExtenderProviderService>(service);
Assert.Throws <ArgumentNullException>("provider", () => providerService.AddExtenderProvider(null));
}
private void RemoveAsExtenderProvider(IComponent component)
{
if (component is IExtenderProvider)
{
IExtenderProviderService e = (IExtenderProviderService)GetService(typeof(IExtenderProviderService));
e.RemoveExtenderProvider((IExtenderProvider)component);
}
}
public void Dispose()
{
if ((this._providerService != null) && (this._extender != null))
{
this._providerService.RemoveExtenderProvider(this._extender);
this._providerService = null;
this._extender = null;
}
}
/// <summary>
/// Disposes this object.
/// </summary>
public void Dispose()
{
if (_providerService is not null && _extender is not null)
{
_providerService.RemoveExtenderProvider(_extender);
_providerService = null;
_extender = null;
}
}
public void Dispose()
{
if ((this._providerService != null) && (this._extender != null))
{
this._providerService.RemoveExtenderProvider(this._extender);
this._providerService = null;
this._extender = null;
}
}
protected override void Dispose(bool disposing)
{
// Removes any previously added extender provider.
if (localExtenderServiceReference != null)
{
localExtenderServiceReference.RemoveExtenderProvider(extender);
localExtenderServiceReference = null;
}
}
private void Initialize(IServiceProvider provider)
{
this._providerService = provider.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (this._providerService == null)
{
throw new NotSupportedException(System.Design.SR.GetString("LocalizationProviderMissingService", new object[] { typeof(IExtenderProviderService).Name }));
}
this._extender = new LanguageExtenders(provider, this._supportedCultures);
this._providerService.AddExtenderProvider(this._extender);
}
public void ExtenderProviderService_RemoveExtenderProvider_InvokeWithoutProviders_Nop()
{
var surface = new DesignSurface();
object service = surface.GetService(typeof(IExtenderListService));
IExtenderListService listService = Assert.IsAssignableFrom <IExtenderListService>(service);
IExtenderProviderService providerService = Assert.IsAssignableFrom <IExtenderProviderService>(service);
var mockExtenderProvider = new Mock <IExtenderProvider>(MockBehavior.Strict);
providerService.RemoveExtenderProvider(mockExtenderProvider.Object);
Assert.Empty(listService.GetExtenderProviders());
}
protected virtual void Dispose(bool disposing)
{
if (disposing && (this.serviceProvider != null))
{
IExtenderProviderService service = (IExtenderProviderService)this.serviceProvider.GetService(typeof(IExtenderProviderService));
if (service != null)
{
service.RemoveExtenderProvider(this);
}
}
}
public void ExtenderProviderService_AddExtenderProvider_DuplicateProvider_ThrowsArgumentException()
{
var surface = new DesignSurface();
object service = surface.GetService(typeof(IExtenderListService));
IExtenderListService listService = Assert.IsAssignableFrom <IExtenderListService>(service);
IExtenderProviderService providerService = Assert.IsAssignableFrom <IExtenderProviderService>(service);
var mockExtenderProvider = new Mock <IExtenderProvider>(MockBehavior.Strict);
providerService.AddExtenderProvider(mockExtenderProvider.Object);
Assert.Throws <ArgumentException>("provider", () => providerService.AddExtenderProvider(mockExtenderProvider.Object));
}
/// <include file='doc\Localizer.uex' path='docs/doc[@for="LocalizationExtenderProvider.Dispose"]/*' />
/// <devdoc>
/// <para>Disposes of the resources (other than memory) used by the <see cref='System.ComponentModel.Design.LocalizationExtenderProvider'/>.</para>
/// </devdoc>
public void Dispose()
{
if (serviceProvider != null)
{
IExtenderProviderService es = (IExtenderProviderService)serviceProvider.GetService(typeof(IExtenderProviderService));
if (es != null)
{
es.RemoveExtenderProvider(this);
}
}
}
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);
}
}
public void Dispose()
{
if ((this.extenderService != null) && (this.providers != null))
{
for (int i = 0; i < this.providers.Length; i++)
{
this.extenderService.RemoveExtenderProvider(this.providers[i]);
}
this.providers = null;
this.extenderService = null;
}
}
public DesignerExtenders(IExtenderProviderService ex)
{
this.extenderService = ex;
if (this.providers == null)
{
this.providers = new IExtenderProvider[] { new NameExtenderProvider(), new NameInheritedExtenderProvider() };
}
for (int i = 0; i < this.providers.Length; i++)
{
ex.AddExtenderProvider(this.providers[i]);
}
}
public void Dispose()
{
if ((this.extenderService != null) && (this.providers != null))
{
for (int i = 0; i < this.providers.Length; i++)
{
this.extenderService.RemoveExtenderProvider(this.providers[i]);
}
this.providers = null;
this.extenderService = null;
}
}
public DesignerExtenders(IExtenderProviderService ex)
{
this.extenderService = ex;
if (this.providers == null)
{
this.providers = new IExtenderProvider[] { new NameExtenderProvider(), new NameInheritedExtenderProvider() };
}
for (int i = 0; i < this.providers.Length; i++)
{
ex.AddExtenderProvider(this.providers[i]);
}
}
/// <summary>
/// Adds our extended properties.
/// </summary>
private void Initialize(IServiceProvider provider)
{
_providerService = provider.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (_providerService is null)
{
throw new NotSupportedException(string.Format(SR.LocalizationProviderMissingService, typeof(IExtenderProviderService).Name));
}
_extender = new LanguageExtenders(provider, _supportedCultures);
_providerService.AddExtenderProvider(_extender);
}
/// <summary>
/// This is called at the appropriate time to remove any extra extender
/// providers previously added to the designer host.
/// </summary>
public void Dispose()
{
if (extenderService != null && providers != null)
{
for (int i = 0; i < providers.Length; i++)
{
extenderService.RemoveExtenderProvider(providers[i]);
}
providers = null;
extenderService = null;
}
}
internal void AddPostProcess(IComponent component, string name)
{
IDesigner designer;
if (_rootComponent == null)
{
_rootComponent = component;
designer = this.CreateDesigner(component, true);
}
else
{
designer = this.CreateDesigner(component, false);
}
if (designer != null)
{
_designers[component] = designer;
designer.Initialize(component);
}
else
{
IUIService uiService = GetService(typeof(IUIService)) as IUIService;
if (uiService != null)
{
uiService.ShowError("Unable to load a designer for component type '" +
component.GetType().Name + "'");
}
this.DestroyComponent(component);
}
// Activate the host and design surface once the root component is added to
// the container and its designer is loaded and added to the designers collection
if (component == _rootComponent)
{
this.Activate();
}
if (component is IExtenderProvider)
{
IExtenderProviderService service = this.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
service.AddExtenderProvider((IExtenderProvider)component);
}
}
if (ComponentAdded != null)
{
ComponentAdded(this, new ComponentEventArgs(component));
}
}
public void EnsureExtender(IServiceProvider sp)
{
if (!this.addedExtender)
{
if (sp != null)
{
IExtenderProviderService es = (IExtenderProviderService)sp.GetService(typeof(IExtenderProviderService));
if (es != null)
{
es.AddExtenderProvider(new RootComponentNameProvider(sp, (this.LanguageOptions & LanguageOptions.CaseInsensitive) != LanguageOptions.None, CodeGenerator));
addedExtender = true;
}
}
}
}
public void Remove(System.ComponentModel.IComponent component)
{
ISite site = component.Site;
IDesigner designer = null;
// Make sure component isn't null
if (component == null)
{
return;
}
// Make sure component is sited here
if (component.Site == null || component.Site.Container != this)
{
return;
}
// Let the nice people know the component is being removed
if (ComponentRemoving != null)
{
ComponentRemoving(this, new ComponentEventArgs(component));
}
// Remove extender provider (if any)
if (component is IExtenderProvider)
{
IExtenderProviderService e = (IExtenderProviderService)GetService(typeof(IExtenderProviderService));
e.RemoveExtenderProvider((IExtenderProvider)component);
}
// Remove the component and dispose of its designer
components.Remove(site.Name);
designer = (IDesigner)designers[component];
if (designer != null)
{
designer.Dispose();
designers.Remove(component);
}
// Let the nice people know the component has been removed
if (ComponentRemoved != null)
{
ComponentRemoved(this, new ComponentEventArgs(component));
}
// Kill the component's site
component.Site = null;
}
/// <include file='doc\DesignerExtenders.uex' path='docs/doc[@for="DesignerExtenders.AddExtenderProviders"]/*' />
/// <devdoc>
/// This is called by a root designer to add the correct extender providers.
/// </devdoc>
public DesignerExtenders(IExtenderProviderService ex)
{
this.extenderService = ex;
if (providers == null)
{
providers = new IExtenderProvider[] {
new ModifiersExtenderProvider(),
new ModifiersInheritedExtenderProvider()
};
}
for (int i = 0; i < providers.Length; i++)
{
ex.AddExtenderProvider(providers[i]);
}
}
public void ExtenderProviderService_AddExtenderProvider_Invoke_Success()
{
var surface = new DesignSurface();
object service = surface.GetService(typeof(IExtenderListService));
IExtenderListService listService = Assert.IsAssignableFrom <IExtenderListService>(service);
IExtenderProviderService providerService = Assert.IsAssignableFrom <IExtenderProviderService>(service);
var mockExtenderProvider1 = new Mock <IExtenderProvider>(MockBehavior.Strict);
var mockExtenderProvider2 = new Mock <IExtenderProvider>(MockBehavior.Strict);
providerService.AddExtenderProvider(mockExtenderProvider1.Object);
Assert.Equal(new IExtenderProvider[] { mockExtenderProvider1.Object }, listService.GetExtenderProviders());
// Add another.
providerService.AddExtenderProvider(mockExtenderProvider2.Object);
Assert.Equal(new IExtenderProvider[] { mockExtenderProvider1.Object, mockExtenderProvider2.Object }, listService.GetExtenderProviders());
}
protected override void Initialize()
{
base.Initialize();
Type type = Type.GetType("System.Workflow.Activities.InvokeWorkflowActivity, System.Workflow.Activities, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
if (type != null)
{
TypeDescriptor.AddAttributes(type, new Attribute[] { new DesignerAttribute(typeof(InvokeWorkflowDesigner), typeof(IDesigner)) });
}
base.LoaderHost.AddService(typeof(WorkflowDesignerLoader), this);
ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
if (base.LoaderHost.GetService(typeof(IWorkflowCompilerOptionsService)) == null)
{
base.LoaderHost.AddService(typeof(IWorkflowCompilerOptionsService), callback);
}
if (base.LoaderHost.GetService(typeof(IIdentifierCreationService)) == null)
{
base.LoaderHost.AddService(typeof(IIdentifierCreationService), callback);
}
if (base.LoaderHost.GetService(typeof(ComponentSerializationService)) == null)
{
base.LoaderHost.AddService(typeof(ComponentSerializationService), callback);
}
base.LoaderHost.RemoveService(typeof(IReferenceService));
if (base.LoaderHost.GetService(typeof(IReferenceService)) == null)
{
base.LoaderHost.AddService(typeof(IReferenceService), callback);
}
if (base.LoaderHost.GetService(typeof(IDesignerVerbProviderService)) == null)
{
base.LoaderHost.AddService(typeof(IDesignerVerbProviderService), callback);
}
IExtenderProviderService service = base.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
foreach (IExtenderProvider provider in ComponentDispenser.Extenders)
{
service.AddExtenderProvider(provider);
}
}
this.customActivityDesignerAdapter = new CustomActivityDesignerAdapter(base.LoaderHost);
}
public override void Dispose()
{
if (this.eventsCoordinator != null)
{
((IDisposable)this.eventsCoordinator).Dispose();
this.eventsCoordinator = null;
}
if (this.customActivityDesignerAdapter != null)
{
((IDisposable)this.customActivityDesignerAdapter).Dispose();
this.customActivityDesignerAdapter = null;
}
IExtenderProviderService extenderProviderService = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (extenderProviderService != null)
{
foreach (IExtenderProvider extender in ComponentDispenser.Extenders)
{
extenderProviderService.RemoveExtenderProvider(extender);
}
}
if (LoaderHost != null)
{
if (this.createdServices != null)
{
foreach (Type serviceType in this.createdServices.Keys)
{
LoaderHost.RemoveService(serviceType);
OnDisposeService(serviceType, this.createdServices[serviceType]);
}
this.createdServices.Clear();
this.createdServices = null;
}
LoaderHost.RemoveService(typeof(WorkflowDesignerLoader));
}
base.Dispose();
}
public override void Initialize(System.ComponentModel.IComponent component)
{
base.Initialize(component);
// Attempts to obtain an IExtenderProviderService.
IExtenderProviderService extenderService = (IExtenderProviderService)component.Site.GetService(typeof(IExtenderProviderService));
if (extenderService != null)
{
// If the service was obtained, adds a ComponentExtender
// that adds an "ExtenderIndex" integer property to the
// designer's component.
extender = new ComponentExtender();
extenderService.AddExtenderProvider(extender);
localExtenderServiceReference = extenderService;
}
else
{
MessageBox.Show("Could not obtain an IExtenderProviderService.");
}
}
internal void AddCore(IComponent component, string name)
{
IDesigner designer;
base.Add(component, name);
if (_rootComponent == null)
{
_rootComponent = component;
designer = this.CreateDesigner(component, true);
}
else
{
designer = this.CreateDesigner(component, false);
}
if (designer != null)
{
_designers[component] = designer;
designer.Initialize(component);
}
// Activate the host and design surface once the root component is added to
// the container and its designer is loaded and added to the designers collection
if (_rootComponent == null)
{
_rootComponent = component;
this.Activate();
}
if (component is IExtenderProvider)
{
IExtenderProviderService service = this.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (service != null)
{
service.AddExtenderProvider((IExtenderProvider)component);
}
}
}
public override void Initialize(System.ComponentModel.IComponent component)
{
base.Initialize(component);
foreach(var item in Component.Site.Container.Components) {
AddProvider(item);
}
IComponentChangeService service = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
if(service != null) {
service.ComponentRemoving += OnComponentRemoving;
service.ComponentAdding += OnComponentAdding;
}
IExtenderProviderService extenderService = (IExtenderProviderService)component.Site.GetService(typeof(IExtenderProviderService));
if(extenderService != null) {
extender = new CommonPropertiesExtender(this);
extenderService.AddExtenderProvider(extender);
localExtenderServiceReference = extenderService;
}
}
private void Initialize(IServiceProvider provider)
{
this._providerService = provider.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (this._providerService == null)
{
throw new NotSupportedException(System.Design.SR.GetString("LocalizationProviderMissingService", new object[] { typeof(IExtenderProviderService).Name }));
}
this._extender = new LanguageExtenders(provider, this._supportedCultures);
this._providerService.AddExtenderProvider(this._extender);
}
protected override void Dispose(bool disposing)
{
if(disposing) {
IComponentChangeService service = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
if(service != null) {
service.ComponentRemoving -= new ComponentEventHandler(this.OnComponentRemoving);
service.ComponentAdding -= OnComponentAdding;
}
if(localExtenderServiceReference != null) {
localExtenderServiceReference.RemoveExtenderProvider(extender);
localExtenderServiceReference = null;
}
//foreach(var item in Component.Site.Container.Components) {
// RemoveProvider(item);
//}
}
base.Dispose(disposing);
}
protected override void Initialize()
{
base.Initialize();
ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
base.LoaderHost.AddService(typeof(ComponentSerializationService), callback);
base.LoaderHost.AddService(typeof(INameCreationService), this);
base.LoaderHost.AddService(typeof(IDesignerSerializationService), this);
if (base.GetService(typeof(ITypeResolutionService)) == null)
{
ITypeResolutionService typeResolutionService = this.TypeResolutionService;
if (typeResolutionService == null)
{
throw new InvalidOperationException(System.Design.SR.GetString("CodeDomDesignerLoaderNoTypeResolution"));
}
base.LoaderHost.AddService(typeof(ITypeResolutionService), typeResolutionService);
this._state[StateOwnTypeResolution] = true;
}
this._extenderProviderService = base.GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
if (this._extenderProviderService != null)
{
this._extenderProviders = new IExtenderProvider[] { new ModifiersExtenderProvider(), new ModifiersInheritedExtenderProvider() };
foreach (IExtenderProvider provider in this._extenderProviders)
{
this._extenderProviderService.AddExtenderProvider(provider);
}
}
}
