internal void AddContent(IDockContent content)
{
if (Contents.Contains(content))
{
return;
}
Contents.Add(content);
}
internal void RemoveContent(IDockContent content)
{
if (!Contents.Contains(content))
{
return;
}
Contents.Remove(content);
}
/// <summary>
/// 添加到选择集
/// </summary>
/// <param name="entity">实体</param>
public static void AddSelection(IFeature entity)
{
UnmarkSelection();
if (!Contents.Contains(entity))
{
Contents.Add(entity);
}
MarkSelection();
OnSelectionChanged();
}
internal void AddContent(IDockContent content)
{
if (content == null)
throw(new ArgumentNullException());
if (!Contents.Contains(content))
{
Contents.Add(content);
OnContentAdded(new DockContentEventArgs(content));
}
}
internal void RemoveContent(IDockContent content)
{
if (content == null)
throw(new ArgumentNullException());
if (Contents.Contains(content))
{
Contents.Remove(content);
OnContentRemoved(new DockContentEventArgs(content));
}
}
public bool Remove(TContent content)
{
if (isUpdating)
{
beRemoved.AddLast(content);
return(Contents.Contains(content) || beAdded.Contains(content));
}
else
{
return(RemoveFromContents(content));
}
}
public override bool CanFit(IInventoryItem item)
{
if (!Contents.Contains(item) && Capacity > Count)
{
return(true);
}
if (item is IInventoryStack stack)
{
return(stack.Capacity > stack.Count);
}
return(false);
}
/// <summary>
/// Adds item to the list of scanned items List. If the item is already in the List, 1 quantity is added; else the item is added with 1 qty.
/// </summary>
/// <param name="itm">Item to be added to the contents of this box.</param>
public void AddItem(Item itm)
{
if (Contents.Contains(itm)) //check if item is in the box
{
var indexItem = Contents.IndexOf(itm); //find it's index
Contents[indexItem].Quantity += 1; //add 1 quantity
}
else
{//else add the new item
Contents.Add(itm);
}
}
/// <summary>
/// Move an entity out of this' named container
/// </summary>
/// <typeparam name="T">the type of entity to remove</typeparam>
/// <param name="thing">the entity</param>
/// <param name="containerName">the name of the container</param>
/// <returns>errors</returns>
public string MoveFrom <T>(T thing, string containerName)
{
var implimentedTypes = DataUtility.GetAllImplimentingedTypes(typeof(T));
if (implimentedTypes.Contains(typeof(IInanimate)))
{
var obj = (IInanimate)thing;
if (!Contents.Contains(obj, containerName))
{
return("That is not in the container");
}
Contents.Remove(obj, containerName);
obj.CurrentLocation = null;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
if (implimentedTypes.Contains(typeof(IMobile)))
{
var obj = (IMobile)thing;
if (!MobilesInside.Contains(obj, containerName))
{
return("That is not in the container");
}
MobilesInside.Remove(obj, containerName);
obj.CurrentLocation = null;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
if (implimentedTypes.Contains(typeof(IPathway)))
{
var obj = (IPathway)thing;
if (!Pathways.Contains(obj, containerName))
{
return("That is not in the container");
}
Pathways.Remove(obj, containerName);
obj.CurrentLocation = null;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
return("Invalid type to move from container.");
}
/// <summary>
/// 添加到选择集
/// </summary>
/// <param name="entities">实体数组</param>
public static void AddSelection(IFeature[] entities)
{
UnmarkSelection();
entities.ToList().ForEach(x =>
{
if (!Contents.Contains(x))
{
Contents.Add(x);
}
});
MarkSelection();
OnSelectionChanged();
}
/// <summary>
/// 从选择集减去
/// </summary>
/// <param name="entities">实体数组</param>
public static void SubtractSelection(IFeature[] entities)
{
UnmarkSelection();
entities.ToList().ForEach(x =>
{
if (Contents.Contains(x))
{
Contents.Remove(x);
}
});
MarkSelection();
OnSelectionChanged();
}
/// <summary>
/// Move an entity into a named container in this
/// </summary>
/// <typeparam name="T">the type of the entity to add</typeparam>
/// <param name="thing">the entity to add</param>
/// <param name="containerName">the name of the container</param>
/// <returns>errors</returns>
public string MoveInto <T>(T thing, string containerName)
{
var implimentedTypes = DataUtility.GetAllImplimentingedTypes(typeof(T));
if (implimentedTypes.Contains(typeof(IInanimate)))
{
var obj = (IInanimate)thing;
if (Contents.Contains(obj, containerName))
{
return("That is already in the container");
}
Contents.Add(obj, containerName);
obj.CurrentLocation = this;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
if (implimentedTypes.Contains(typeof(IMobile)))
{
var obj = (IMobile)thing;
if (MobilesInside.Contains(obj, containerName))
{
return("That is already in the container");
}
MobilesInside.Add(obj, containerName);
obj.CurrentLocation = this;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
if (implimentedTypes.Contains(typeof(IPathway)))
{
var obj = (IPathway)thing;
if (Pathways.Contains(obj, containerName))
{
return("That is already in the container");
}
Pathways.Add(obj, containerName);
obj.CurrentLocation = this;
this.UpsertToLiveWorldCache();
return(string.Empty);
}
return("Invalid type to move to container.");
}
/// <summary>
/// Move the specified element to this cell.
/// The element will be removed from any cell it occupies.
/// TODO: Modify this for multi-cell entities?
/// </summary>
/// <param name="element"></param>
public void PlaceInCell(Element element)
{
if (!Contents.Contains(element))
{
MapData mD = element.GetData <MapData>(true);
if (mD.MapCell != null && mD.MapCell.Contents.Contains(element))
{
mD.MapCell.RemoveFromCell(element);
}
Contents.Add(element);
mD.MapCell = this;
NotifyPropertyChanged("Contents"); //TEMP
}
}
internal void AddContent(Content c)
{
if (Contents.Contains(c))
{
return;
}
Contents.Add(c);
SetDockState();
if (!c.IsHidden && CountOfVisibleContents == 1)
{
ActiveContent = c;
Refresh();
}
}
internal void RemoveContent(IDockableWindow content)
{
if (!Contents.Contains(content))
{
return;
}
Contents.Remove(content);
if (content.DockHandler.Pane == this)
{
content.DockHandler.SetPane(null);
}
if (Contents.Count == 0)
{
Dispose();
}
}
/// <summary>
/// Add the collection of hot zones.
/// </summary>
/// <param name="redock">Reference to a redocker instance.</param>
/// <param name="collection">Collection of hot zones.</param>
public void AddHotZones(Redocker redock, HotZoneCollection collection)
{
RedockerContent redocker = redock as RedockerContent;
bool itself = false;
bool nullZone = false;
// We process differently for WindowContent to redock into itself!
if ((redocker.WindowContent != null) && (redocker.WindowContent == this))
{
itself = true;
}
// We do not allow a Content to redock into its existing container
if (itself && !Contents.Contains(redocker.Content))
{
nullZone = true;
}
Rectangle newSize = this.RectangleToScreen(this.ClientRectangle);
Rectangle hotArea = _tabControl.RectangleToScreen(_tabControl.ClientRectangle);;
// Find any caption detail and use that area as the hot area
foreach (WindowDetail wd in WindowDetails)
{
WindowDetailCaption wdc = wd as WindowDetailCaption;
if (wdc != null)
{
hotArea = wdc.RectangleToScreen(wdc.ClientRectangle);
hotArea.Inflate(_hotAreaInflate, _hotAreaInflate);
break;
}
}
if (nullZone)
{
collection.Add(new HotZoneNull(hotArea));
}
else
{
collection.Add(new HotZoneTabbed(hotArea, newSize, this, itself));
}
}
private static void MarkSelection() // mod 20130226
{
foreach (var layer in MapControl.Current.Layers)
{
if (layer is DrawingMapLayer)
{
foreach (var content in (layer as DrawingMapLayer).Features)
{
var feature = content.Key;
var drawing = content.Value;
if (Contents.Contains(feature))
{
if (FindLayer(feature).GeoType != VectorLayer.GEOTYPE_LINEAR)
{
(layer as DrawingMapLayer).BringToFront(drawing);
}
drawing.Pen.Brush = MarkBrush;
//_tempDrawings.Add(drawing);
}
}
}
else
{
foreach (var content in layer.Features)
{
var feature = content.Key;
var shape = content.Value;
//System.Windows.Controls.Canvas.SetZIndex(shape, 0);
if (Contents.Contains(feature))
{
if (FindLayer(feature).GeoType != VectorLayer.GEOTYPE_LINEAR)
{
layer.BringToFront(shape);
}
shape.Stroke = MarkBrush;
//_tempShapes.Add(shape);
}
}
}
}
//UpdateSelectionMark();
}
public Bill_Identifier(string path)
{
if (File.Exists(path))
{
LobPath = path;
Contents = FileUtils.FileContents(path);
if (Contents.Contains("<")) // < isn't always done correctly
{
var re_lt = "<";
Contents = Regex.Replace(Contents, re_lt, "<").ToString();
}
ExtractID(Contents);
ExtractAuthor(Contents);
ExtractTitle(Contents);
}
else
{
throw new ArgumentException($"{path} does not exist.");
}
}
internal void AddContent(IDockContent content)
{
if (content == null)
{
throw (new ArgumentNullException());
}
if (!Contents.Contains(content))
{
Contents.Add(content);
OnContentAdded(new DockContentEventArgs(content));
}
else
{
string msg = "1) your PersistStringInstantiator returned the same instance twice"
+ "2) REMOVE SHOWING DOCKED FORMS DURING LOADFROMXML()";
throw new Exception(msg);
Contents.Add(content);
OnContentAdded(new DockContentEventArgs(content));
}
}
/// <summary>
/// Move an entity out of this' named container
/// </summary>
/// <typeparam name="T">the type of entity to remove</typeparam>
/// <param name="thing">the entity</param>
/// <param name="containerName">the name of the container</param>
/// <returns>errors</returns>
public string MoveFrom <T>(T thing, string containerName)
{
IEnumerable <Type> implimentedTypes = DataUtility.GetAllImplimentingedTypes(typeof(T));
if (implimentedTypes.Contains(typeof(IInanimate)))
{
IInanimate obj = (IInanimate)thing;
if (!Contents.Contains(obj, containerName))
{
return("That is not in the container");
}
Contents.Remove(obj, containerName);
UpsertToLiveWorldCache();
return(string.Empty);
}
if (implimentedTypes.Contains(typeof(IMobile)))
{
IMobile obj = (IMobile)thing;
if (!MobilesInside.Contains(obj, containerName))
{
return("That is not in the container");
}
MobilesInside.Remove(obj, containerName);
UpsertToLiveWorldCache();
return(string.Empty);
}
return("Invalid type to move from container.");
}
public bool HasItem(IGameObject item)
{
return(Contents.Contains(item));
}
public void ConsolidateConnections()
{
// Ensure components consuming composition inputs/outputs have a source
// Find connections that are consumed by internal components but are not provided by external components
var neglectedInternalConnections = from c in Connections
where c.Source == this
where Contents.Contains(c.Destination)
where !Connections.Any(con => con.DestinationInput == c.SourceOutput)
select c;
if (neglectedInternalConnections.Any())
{
throw new NoProvidingSourceException(Name, from c in neglectedInternalConnections select c.SourceOutput);
}
// Find connections that are consumed by external components but are not provided by internal components
var neglectedExternalConnections = from c in Connections
where c.Source == this
where c.Destination != this
where !Contents.Contains(c.Destination)
where !Connections.Any(con => con.DestinationInput == c.SourceOutput)
select c;
if (neglectedExternalConnections.Any())
{
throw new NoProvidingSourceException(Name, from c in neglectedExternalConnections select c.SourceOutput);
}
// Begin consolidating composition connections
// First, consolidate the connections leading into the composition
var incomingConnections = from c in Connections
where c.Destination == this
where c.Source != this
where !Contents.Contains(c.Source)
select c;
foreach (var connection in incomingConnections)
{
// Find all of the places this input is consumed
var destinationConnections = from c in Connections
where c.Source == this
where c.SourceOutput == connection.DestinationInput
select c;
foreach (var destinationConnection in destinationConnections)
{
var trueDestinations = Enumerable.Repeat(destinationConnection, 1);
// If the input passes through straight to an output, connect the input to the external components
if (destinationConnection.Destination == this)
{
trueDestinations = from c in Connections
where c.Source == this
where c.SourceOutput == destinationConnection.DestinationInput
select c;
}
// Connect the source to the current destination and remove the destination's connection to the composition
foreach (var trueDestination in trueDestinations)
{
connection.Source.Connect(trueDestination.Destination, connection.SourceOutput, trueDestination.DestinationInput, connection.ConnectionType);
trueDestination.Destination.Connections.Remove(trueDestination);
}
}
// Remove the source's connection to the composition
connection.Source.Connections.Remove(connection);
}
// Then, consolidate the connections leading out of the composition
var outgoingConnections = from c in Connections
where c.Destination == this
where Contents.Contains(c.Source)
select c;
foreach (var connection in outgoingConnections)
{
var destinationConnections = from c in Connections
where c.Source == this
where c.SourceOutput == connection.DestinationInput
select c;
foreach (var destinationConnection in destinationConnections)
{
connection.Source.Connect(destinationConnection.Destination, connection.SourceOutput, destinationConnection.DestinationInput, connection.ConnectionType);
destinationConnection.Destination.Connections.Remove(destinationConnection);
}
connection.Source.Connections.Remove(connection);
}
// Remove all connections and content from the composition
Connections.Clear();
Contents.Clear();
}
public bool Contains(string thing)
{
return(Contents.Contains(thing));
}
protected virtual void UpdateContents()
{
foreach (var trackedObject in TrackedObject.TrackedObjects)
{
if (trackedObject == TrackedPlayer.LocalPlayer || trackedObject.Trackers.Any(t => t != null && t.trackerContinuity && t.trackerContinuity.IsTracking))
{
if (trackedObject.Trackers.Any(t => t != null && t.trackerContinuity && Zone.Contains(t.optitrackRigidBody.transform.position)))
{
// Some of the Tracked Object's RBs are inside this zone
if (Contents.Contains(trackedObject))
{
// Object already present
//Debug.Log(trackedObject + " is in zone " + this.name);
}
else if (priorContents.Remove(trackedObject))
{
// Object was last in this zone
if (Contents.Add(trackedObject))
{
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [Returned to " + this.name + "]");
if (OnZoneEntered != null)
{
OnZoneEntered(this, trackedObject);
}
}
}
else
{
// Object has not been in this zone recently
if (m_ConnectedZones.Length == 0 ||
m_ConnectedZones.Any(z => z && (z.Contents.Contains(trackedObject) || z.priorContents.Contains(trackedObject))) ||
!Zones.Any(z => z && (z.Contents.Contains(trackedObject) || z.priorContents.Contains(trackedObject)))
)
{
if (Contents.Add(trackedObject))
{
// Object has just entered zone!
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [Entered " + this.name + "]");
if (OnZoneEntered != null)
{
OnZoneEntered(this, trackedObject);
}
}
}
else
{
// Object isn't entering via a valid edge
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [Entered " + this.name + " from an invalid edge]");
}
}
}
else if (TrackedPlayer.LocalPlayer && trackedObject == TrackedPlayer.LocalPlayer && Zone.Contains(TrackedPlayer.LocalPlayer.HmdTracker.transform.position))
{
// The current TrackedObject is the Local Player and its the Hmd is inside this zone
if (Contents.Contains(TrackedPlayer.LocalPlayer))
{
// Local Player is already in this zone
}
else if (m_ConnectedZones.Length == 0 ||
m_ConnectedZones.Any(z => z && (z.Contents.Contains(TrackedPlayer.LocalPlayer) || z.priorContents.Contains(TrackedPlayer.LocalPlayer))) ||
!Zones.Any(z => z && (z.Contents.Contains(TrackedPlayer.LocalPlayer) || z.priorContents.Contains(TrackedPlayer.LocalPlayer)))
)
{
if (Contents.Add(TrackedPlayer.LocalPlayer))
{
// LocalPlayer has just entered this zone! Zone now active.
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [Entered " + this.name + "]");
if (OnZoneEntered != null)
{
OnZoneEntered(this, trackedObject);
}
}
}
else
{
// Player isn't entering via a valid edge
Spaces.LBE.DebugLog.Log("tracker", TrackedPlayer.LocalPlayer.name + " [Entered " + this.name + " from an invalid edge]");
}
}
else
{
// None of this object's trackers are inside this zone currently
// TODO: Decide if player can leave if not entering a valid zone to do so. Do we raise an alarm?
//if (m_ConnectedZones.Any(z => z.Contents.Contains(trackedObject) || z.priorContents.Contains(trackedObject)))
if (Contents.Remove(trackedObject))
{
// Object has just left zone
priorContents.Add(trackedObject);
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [Exited " + this.name + "]");
if (OnZoneExited != null)
{
OnZoneExited(this, trackedObject);
}
}
else if (priorContents.Contains(trackedObject))
{
// TODO: determine better criteria for removing objects from priors
if (Zones.Any(z => z != this && z.Contents.Contains(trackedObject)))
{
// Object is still contained in some other zone, so we will go ahead and remove it from prior contents
if (priorContents.Remove(trackedObject))
{
Spaces.LBE.DebugLog.Log("tracker", trackedObject.name + " [No longer in Prior Contents of " + this.name + "]");
}
}
else
{
// Object has been out of zone for an entire update cycle and is in no other zone, therefore we will keep it in this one's priors.
// This will allow it to re-enter this zone rather than only be able to enter via a start zone.
}
}
else
{
// Object is not in any zone...
}
}
}
}
}
public bool Contains <T>(T item) where T : Thing
{
return(Contents.Contains(item));
}
/// <summary>
/// Checks if this hand contains that element.
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public virtual bool Contains(TElement element)
{
return(Contents.Contains(element));
}
public bool Contains(T item)
{
return(Contents.Contains(item));
}