private static void PropagateVisible(LayerFolder layer, bool visible)
{
// Recursive call to update all sub-layers
foreach (LayerFolder subLayer in layer.Folders)
{
PropagateVisible(subLayer, visible);
}
// Set visibility for all GameObjects
foreach (Element gameObject in layer.GetElements())
{
IVisible iVisible = gameObject.As <IVisible>();
if (iVisible != null)
{
iVisible.Visible = visible;
}
}
}
/// <summary>
/// Adds the given objects to a layer using a transaction; entry point for automation. If a new layer
/// is created, returns that new layer. Otherwise returns null.</summary>
/// <param name="parent">Layer's parent</param>
/// <param name="objectToInsert">Object(s) to insert in layer</param>
/// <returns>New layer if created, null otherwise</returns>
public LayerFolder InsertAuto(object parent, object objectToInsert)
{
DataObject dataObject = null;
if (objectToInsert is IEnumerable)
{
//if the input is a native C# IEnumerable, such as passing in circuit.Connections,
//manaully convert the IEnumerable into an object array
List <object> tempArray = new List <object>();
foreach (object obj in (IEnumerable)objectToInsert)
{
tempArray.Add(obj);
}
dataObject = new DataObject(tempArray.ToArray());
}
else
{
//if the input is a single object, put the single object into an array
dataObject = new DataObject(new object[] { objectToInsert });
}
int cntBefore = Layers.Count;
ITransactionContext transactionContext = this.As <ITransactionContext>();
transactionContext.DoTransaction(
delegate
{
Insert(parent, dataObject);
}, "Scripted Insert Layer");
int cntAfter = Layers.Count;
LayerFolder newLayer = null;
if (cntAfter > cntBefore)
{
newLayer = Layers[cntAfter - 1];
}
return(newLayer);
}
/// <summary>
/// Obtains enumeration of the children of the given parent object</summary>
/// <param name="parent">Parent object</param>
/// <returns>Enumeration of children of the parent object</returns>
IEnumerable <object> ITreeView.GetChildren(object parent)
{
LayerFolder layer = parent.As <LayerFolder>();
if (layer != null)
{
foreach (LayerFolder subLayer in layer.Folders)
{
yield return(subLayer);
}
foreach (ElementRef reference in layer.ElementRefs)
{
yield return(reference);
}
}
else if (parent.Is <LayeringContext>())
{
foreach (LayerFolder childLayer in Layers)
{
yield return(childLayer);
}
}
}
/// <summary>
/// Returns whether the item is visible</summary>
/// <param name="item">Item</param>
/// <returns>True iff the item is visible</returns>
public bool IsVisible(object item)
{
LayerFolder layer = item.As <LayerFolder>();
return(layer == null || GetCheckState(layer) == CheckState.Checked);
}
/// <summary>
/// Adds the given objects to a layer</summary>
/// <param name="parent">Layer's parent</param>
/// <param name="insertingObject">Object(s) to insert in layer</param>
public void Insert(object parent, object insertingObject)
{
if (parent == null)
{
parent = m_activeItem ?? this;
}
else if (!(parent is LayeringContext) && !(parent is LayerFolder))
{
return;
}
IEnumerable <DomNode> nodes = GetCompatibleNodes((IDataObject)insertingObject);
if (nodes == null)
{
return;
}
// If the parent is the LayeringContext itself:
// create a new layer for the objects about to be inserted
LayerFolder layer = parent.As <LayerFolder>();
if (layer == null && nodes.Count() > 0)
{
DomNode node = new DomNode(LayerFolderType);
LayerFolder subLayer = node.As <LayerFolder>();
subLayer.Name = "New Layer".Localize();
Layers.Add(subLayer);
layer = subLayer;
}
if (layer == null)
{
return;
}
foreach (DomNode node in nodes)
{
// Insert GameObjects
Element gameObject = node.As <Element>();
if (gameObject != null && !layer.Contains(gameObject))
{
DomNode refNode = new DomNode(ElementRefType);
ElementRef newRef = refNode.As <ElementRef>();
newRef.Element = gameObject;
layer.ElementRefs.Add(newRef);
}
// Insert References
ElementRef reference = node.As <ElementRef>();
if (reference != null)
{
if (reference.Element != null && !layer.Contains(reference.Element))
{
layer.ElementRefs.Add(reference);
}
}
// Insert Sub-Layers
LayerFolder otherLayer = node.As <LayerFolder>();
if (otherLayer != null)
{
layer.Folders.Add(otherLayer);
}
}
}
private static void PropagateVisible(LayerFolder layer, bool visible)
{
// Recursive call to update all sub-layers
foreach (LayerFolder subLayer in layer.Folders)
PropagateVisible(subLayer, visible);
// Set visibility for all GameObjects
foreach (Element gameObject in layer.GetElements())
{
IVisible iVisible = gameObject.As<IVisible>();
if (iVisible != null)
iVisible.Visible = visible;
}
}
private static CheckState GetCheckState(LayerFolder layer)
{
bool hasUncheckedChild = false;
bool hasCheckedChild = false;
foreach (LayerFolder subLayer in layer.Folders)
{
CheckState subCheckState = GetCheckState(subLayer);
switch (subCheckState)
{
case CheckState.Checked:
hasCheckedChild = true;
break;
case CheckState.Unchecked:
hasUncheckedChild = true;
break;
case CheckState.Indeterminate:
hasCheckedChild = true;
hasUncheckedChild = true;
break;
}
}
foreach (Element gameObject in layer.GetElements())
{
IVisible iVisible = gameObject.As<IVisible>();
if (iVisible != null)
{
if (iVisible.Visible)
hasCheckedChild = true;
else
hasUncheckedChild = true;
}
}
if (hasCheckedChild && !hasUncheckedChild)
return CheckState.Checked;
if (hasUncheckedChild && !hasCheckedChild)
return CheckState.Unchecked;
return CheckState.Indeterminate;
}
