|
//------------------------------------------------------------------------------
// <copyright file="NestedContainer.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.ComponentModel {
using System;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Security.Permissions;
/// <devdoc>
/// A nested container is a container that is owned by another component. Nested
/// containers can be found by querying a component site's services for NestedConainter.
/// Nested containers are a useful tool to establish owner relationships among components.
/// All components within a nested container are named with the owning component's name
/// as a prefix.
/// </devdoc>
[HostProtection(SharedState = true)]
public class NestedContainer : Container, INestedContainer {
private IComponent _owner;
/// <devdoc>
/// Creates a new NestedContainer.
/// </devdoc>
public NestedContainer(IComponent owner) {
if (owner == null) {
throw new ArgumentNullException("owner");
}
_owner = owner;
_owner.Disposed += new EventHandler(OnOwnerDisposed);
}
/// <devdoc>
/// The component that owns this nested container.
/// </devdoc>
public IComponent Owner {
get {
return _owner;
}
}
/// <devdoc>
/// Retrieves the name of the owning component. This may be overridden to
/// provide a custom owner name. The default searches the owner's site for
/// INestedSite and calls FullName, or ISite.Name if there is no nested site.
/// If neither is available, this returns null.
/// </devdoc>
protected virtual string OwnerName {
get {
string ownerName = null;
if (_owner != null && _owner.Site != null) {
INestedSite nestedOwnerSite = _owner.Site as INestedSite;
if (nestedOwnerSite != null) {
ownerName = nestedOwnerSite.FullName;
}
else {
ownerName = _owner.Site.Name;
}
}
return ownerName;
}
}
/// <devdoc>
/// Creates a site for the component within the container.
/// </devdoc>
protected override ISite CreateSite(IComponent component, string name) {
if (component == null) {
throw new ArgumentNullException("component");
}
return new Site(component, this, name);
}
/// <devdoc>
/// Override of Container's dispose.
/// </devdoc>
protected override void Dispose(bool disposing) {
if (disposing) {
_owner.Disposed -= new EventHandler(OnOwnerDisposed);
}
base.Dispose(disposing);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected override object GetService(Type service) {
if (service == typeof(INestedContainer)) {
return this;
}
else {
return base.GetService(service);
}
}
/// <devdoc>
/// Called when our owning component is destroyed.
/// </devdoc>
private void OnOwnerDisposed(object sender, EventArgs e) {
Dispose();
}
/// <devdoc>
/// Simple site implementation. We do some special processing to name the site, but
/// that's about it.
/// </devdoc>
private class Site : INestedSite
{
private IComponent component;
private NestedContainer container;
private string name;
internal Site(IComponent component, NestedContainer container, string name) {
this.component = component;
this.container = container;
this.name = name;
}
// The component sited by this component site.
public IComponent Component {
get {
return component;
}
}
// The container in which the component is sited.
public IContainer Container {
get {
return container;
}
}
public Object GetService(Type service) {
return((service == typeof(ISite)) ? this : container.GetService(service));
}
// Indicates whether the component is in design mode.
public bool DesignMode {
get {
IComponent owner = container.Owner;
if (owner != null && owner.Site != null) {
return owner.Site.DesignMode;
}
return false;
}
}
public string FullName {
get {
if (name != null) {
string ownerName = container.OwnerName;
string childName = name;
if (ownerName != null) {
childName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", ownerName, childName);
}
return childName;
}
return name;
}
}
// The name of the component.
//
public String Name
{
get {
return name;
}
set {
if (value == null || name == null || !value.Equals(name)) {
container.ValidateName(component, value);
name = value;
}
}
}
}
}
}
|