private DomNode CreatePrefab(IEnumerable <IGameObject> gobs) { UniqueNamer uniqueNamer = new UniqueNamer(); DomNode[] temp = new DomNode[1]; List <IGameObject> copyList = new List <IGameObject>(); AABB bound = new AABB(); foreach (IGameObject gameObject in SelectedGobs) { IBoundable boundable = gameObject.As <IBoundable>(); bound.Extend(boundable.BoundingBox); Matrix4F world = TransformUtils.ComputeWorldTransform(gameObject); temp[0] = gameObject.As <DomNode>(); DomNode[] copies = DomNode.Copy(temp); copies[0].InitializeExtensions(); IGameObject copy = copies[0].As <IGameObject>(); copy.Name = uniqueNamer.Name(copy.Name); TransformUtils.SetTransform(copy, world); copyList.Add(copy); } DomNode prefab = new DomNode(Schema.prefabType.Type, Schema.prefabRootElement); var list = prefab.GetChildList(Schema.prefabType.gameObjectChild); Vec3F center = bound.Center; foreach (IGameObject gob in copyList) { gob.Translation = gob.Translation - center; gob.UpdateTransform(); list.Add(gob.As <DomNode>()); } return(prefab); }
public void TestCopy_MultipleNodes() { DomNodeType type = new DomNodeType("type"); ChildInfo info = new ChildInfo("child", type); ChildInfo infoList = new ChildInfo("childList", type, true); type.Define(info); type.Define(infoList); ChildInfo rootInfo = new ChildInfo("root", type, true); DomNode test = new DomNode(type, rootInfo); DomNode child1 = new DomNode(type); test.SetChild(info, child1); DomNode child2 = new DomNode(type); DomNode child3 = new DomNode(type); IList <DomNode> list = test.GetChildList(infoList); list.Add(child2); list.Add(child3); DomNode[] result = DomNode.Copy(new DomNode[] { test }); Assert.AreEqual(result.Length, 1); Assert.True(Equals(result[0], test)); DomNode singleResult = DomNode.Copy(test); Assert.True(Equals(singleResult, test)); }
/// <summary> /// Copies the selection. Returns a data object representing the copied items.</summary> /// <returns>Data object representing the copied items; e.g., a /// System.Windows.Forms.IDataObject object</returns> public object Copy() { IEnumerable <DomNode> resources = Selection.AsIEnumerable <DomNode>(); List <object> copies = new List <object>(DomNode.Copy(resources)); return(new DataObject(copies.ToArray())); }
/// <summary> /// Clone the object /// </summary> /// <returns>A new cloned object</returns> public object Clone() { var copy = DomNode.Copy(new[] { DomNode }); copy[0].InitializeExtensions(); return(copy[0].As <SledFunctionBaseType>()); }
// 'center' must be in world coordinates private void Insert(object insertingObject, Point center, Statechart insertionPoint) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } object[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); foreach (Annotation annotation in Adapters.AsIEnumerable <Annotation>(itemCopies)) { this.As <Document>().Annotations.Add(annotation); } IEnumerable <StateBase> states = Adapters.AsIEnumerable <StateBase>(itemCopies); foreach (StateBase state in states) { insertionPoint.States.Add(state); } foreach (Transition transition in Adapters.AsIEnumerable <Transition>(itemCopies)) { m_transitions.Add(transition); } // centering hierarchical states requires some special code Center(itemCopies, center); Selection.SetRange(itemCopies); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } object[] itemCopies = DomNode.Copy(items.AsIEnumerable <DomNode>()); // create a new prototype DomNode node = new DomNode(Schema.prototypeType.Type); Prototype prototype = node.As <Prototype>(); prototype.Name = "Prototype".Localize("Statechart prototype"); foreach (StateBase state in itemCopies.AsIEnumerable <StateBase>()) { prototype.States.Add(state); } foreach (Transition transition in itemCopies.AsIEnumerable <Transition>()) { prototype.Transitions.Add(transition); } PrototypeFolder folder = m_activeItem.As <PrototypeFolder>(); if (folder == null) { folder = PrototypeFolder; } folder.Prototypes.Add(prototype); }
/// <summary> /// Refresh group</summary> public void Refresh() { m_inputs.Clear(); m_outputs.Clear(); if (Template == null) { return; } var targetGroup = Template.Target.As <Group>(); if (m_targetGroup != targetGroup) { if (m_targetGroup != null) { m_targetGroup.Changed -= TargetGroupChanged; } m_targetGroup = targetGroup; if (m_targetGroup != null) { m_targetGroup.Changed += TargetGroupChanged; } } if (m_targetGroup == null) { return; } var templateInputPins = m_targetGroup.InputGroupPins.ToArray(); var templateOutputPins = m_targetGroup.OutputGroupPins.ToArray(); var grpPinCopies = DomNode.Copy(templateInputPins.AsIEnumerable <DomNode>()); for (int i = 0; i < grpPinCopies.Length; ++i) { var grpPinNode = grpPinCopies[i]; var grpin = grpPinNode.Cast <GroupPin>(); grpin.SetPinTarget(true); grpin.PinTarget.InstancingNode = DomNode; // share the template group pin info grpin.Info = templateInputPins[i].Info; m_inputs.Add(grpin); } var grpPinCopies2 = DomNode.Copy(templateOutputPins.AsIEnumerable <DomNode>()); for (int i = 0; i < grpPinCopies2.Length; ++i) { var grpPinNode = grpPinCopies2[i]; var grpin = grpPinNode.Cast <GroupPin>(); grpin.SetPinTarget(false); grpin.PinTarget.InstancingNode = DomNode; // share the template group pin info grpin.Info = templateOutputPins[i].Info; m_outputs.Add(grpin); } Info.Offset = m_targetGroup.Info.Offset; }
/// <summary> /// Performs custom actions on validation Ending events. /// If resources referenced are not available in the same package, /// they are cloned and added to the package.</summary> /// <param name="sender">Validation context</param> /// <param name="e">Event args</param> protected override void OnEnding(object sender, System.EventArgs e) { foreach (ChildEventArgs refInsert in m_referenceInserts) { UIPackage dstPackage = GetPackage(refInsert.Parent); UIRef uiRef = refInsert.Child.As <UIRef>(); DomNode resource = uiRef.UIObject.DomNode; UIPackage srcPackage = GetPackage(resource); if (dstPackage != srcPackage) { DomNode[] copies = DomNode.Copy(new DomNode[] { resource }); UIObject refObject = copies[0].As <UIObject>(); uiRef.UIObject = refObject; // add the cloned ref object to the package in the first child array // of compatible type foreach (ChildInfo childInfo in dstPackage.DomNode.Type.Children) { if (childInfo.Type.IsAssignableFrom(refObject.DomNode.Type)) { dstPackage.DomNode.GetChildList(childInfo).Add(refObject.DomNode); break; } } } } }
public object Copy(Selection <object> selection) { IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>()); object[] copies = DomNode.Copy(rootDomNodes).ToArray <object>(); return(new DataObject(copies)); }
/// <summary> /// Refresh group</summary> public void Refresh() { m_inputs.Clear(); m_outputs.Clear(); var templateInputPins = m_targetGroup.InputGroupPins.ToArray(); var templateOutputPins = m_targetGroup.OutputGroupPins.ToArray(); var grpPinCopies = DomNode.Copy(templateInputPins.AsIEnumerable <DomNode>()); for (int i = 0; i < grpPinCopies.Length; ++i) { var grpPinNode = grpPinCopies[i]; var grpin = grpPinNode.Cast <Sce.Atf.Controls.Adaptable.Graphs.GroupPin>(); grpin.SetPinTarget(true); grpin.PinTarget.InstancingNode = m_owner.DomNode; // share the template group pin info grpin.Info = templateInputPins[i].Info; m_inputs.Add(grpin); } var grpPinCopies2 = DomNode.Copy(templateOutputPins.AsIEnumerable <DomNode>()); for (int i = 0; i < grpPinCopies2.Length; ++i) { var grpPinNode = grpPinCopies2[i]; var grpin = grpPinNode.Cast <Sce.Atf.Controls.Adaptable.Graphs.GroupPin>(); grpin.SetPinTarget(false); grpin.PinTarget.InstancingNode = m_owner.DomNode; // share the template group pin info grpin.Info = templateOutputPins[i].Info; m_outputs.Add(grpin); } }
/// <summary> /// Copies the selection. Returns a data object representing the copied items.</summary> /// <returns>Data object representing the copied items; e.g., a /// System.Windows.Forms.IDataObject object</returns> object IInstancingContext.Copy() { IEnumerable <DomNode> resources = Selection.AsIEnumerable <DomNode>(); List <object> copies = new List <object>(DomNode.Copy(resources)); //List<object> copies = new List<object>(); //foreach (DomNode node in resources) //{ // DomNode nodeCopy = DomNode.Copy(node); // _CheckNodeName(nodeCopy); // //if (bitBoxSchema.nodeType.Type.IsAssignableFrom(node.Type)) // //{ // // DomNode parent = node.Parent; // // parent.GetChildList(bitBoxSchema.nodeType.nodeChild).Add(nodeCopy); // //} // copies.Add(nodeCopy); //} //foreach (object cpy in copies) //{ // DomNode node = cpy as DomNode; // if( node != null ) // { // _CheckNodeName(cpy as DomNode); // } //} return(new DataObject(copies.ToArray())); }
private void Insert(object insertingObject, Point centerLocation) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } object[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); List <State> states = new List <State>(Adapters.AsIEnumerable <State>(itemCopies)); foreach (State state in states) { m_fsm.States.Add(state); } foreach (Transition transition in Adapters.AsIEnumerable <Transition>(itemCopies)) { m_fsm.Transitions.Add(transition); } foreach (Annotation annotation in Adapters.AsIEnumerable <Annotation>(itemCopies)) { m_fsm.Annotations.Add(annotation); } Center(itemCopies, centerLocation); Selection.SetRange(itemCopies); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } object[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); // create a new prototype DomNode node = new DomNode(PrototypeType); Prototype prototype = node.As <Prototype>(); prototype.Name = "Prototype".Localize("Circuit prototype"); foreach (Element module in Adapters.AsIEnumerable <Element>(itemCopies)) { prototype.Modules.Add(module); } foreach (Wire connection in Adapters.AsIEnumerable <Wire>(itemCopies)) { prototype.Connections.Add(connection); } PrototypeFolder folder = Adapters.As <PrototypeFolder>(m_activeItem); if (folder == null) { folder = PrototypeFolder; } folder.Prototypes.Add(prototype); }
/// <summary> /// Copies the selection. Returns a data object representing the copied items.</summary> /// <returns>Data object representing the copied items; e.g., a /// System.Windows.Forms.IDataObject object</returns> public object Copy() { IEnumerable <UIObject> uiObjects = Selection.AsIEnumerable <UIObject>(); IEnumerable <DomNode> rootNodes = DomNode.GetRoots(Adapters.AsIEnumerable <DomNode>(uiObjects)); List <object> copies = new List <object>(DomNode.Copy(rootNodes)); return(new DataObject(copies.ToArray())); }
public IGameObject CreateInstance() { DomNode[] org = { m_node.GetChild(Schema.prototypeType.gameObjectChild) }; DomNode copy = DomNode.Copy(org)[0]; copy.InitializeExtensions(); return(copy.As <IGameObject>()); }
/// <summary> /// Clone the item /// </summary> /// <returns>A new cloned object</returns> public object Clone() { var copy = DomNode.Copy(new[] { DomNode }); copy[0].InitializeExtensions(); return(copy[0].As <SledProfileInfoType>()); }
public object Clone() { var copy = DomNode.Copy(new[] { DomNode }); copy[0].InitializeExtensions(); return(copy[0].As <SledLuaVarNameTypePairType>()); }
private DomNode CreatePrototype(IEnumerable <IGameObject> gobs) { DomNode[] originals = new DomNode[1]; List <IGameObject> copyList = new List <IGameObject>(); AABB bound = new AABB(); foreach (IGameObject gameObject in SelectedGobs) { IBoundable boundable = gameObject.As <IBoundable>(); bound.Extend(boundable.BoundingBox); Matrix4F world = TransformUtils.ComputeWorldTransform(gameObject); originals[0] = gameObject.As <DomNode>(); DomNode[] copies = DomNode.Copy(originals); IGameObject copy = copies[0].As <IGameObject>(); TransformUtils.SetTransform(copy, world); copyList.Add(copy); } DomNode gobchild = null; if (copyList.Count > 1) {// create group IGame game = m_contextRegistry.GetActiveContext <IGame>(); IGameObjectGroup gobgroup = game.CreateGameObjectGroup(); gobgroup.Translation = bound.Center; gobgroup.UpdateTransform(); Matrix4F worldInv = new Matrix4F(); worldInv.Invert(gobgroup.Transform); foreach (IGameObject gob in copyList) { Vec3F translate = gob.Translation; worldInv.Transform(ref translate); gob.Translation = translate; gob.UpdateTransform(); gobgroup.GameObjects.Add(gob); } gobchild = gobgroup.As <DomNode>(); } else { gobchild = copyList[0].As <DomNode>(); } gobchild.InitializeExtensions(); gobchild.As <IGameObject>().Translation = new Vec3F(0, 0, 0); DomNode prototype = null; if (gobchild != null) { prototype = new DomNode(Schema.prototypeType.Type, Schema.prototypeRootElement); prototype.SetChild(Schema.prototypeType.gameObjectChild, gobchild); } return(prototype); }
/// <summary> /// Copies selected items from the statechart</summary> /// <returns>DataObject containing an enumeration of selected items</returns> public object Copy() { List <DomNode> domNodes = new List <DomNode>(); // form state "closure" for determining which transitions to copy HashSet <StateBase> allStates = new HashSet <StateBase>(); // for all selected root states and sub-states IEnumerable <DomNode> rootNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>()); IEnumerable <StateBase> rootStates = Adapters.AsIEnumerable <StateBase>(rootNodes); foreach (StateBase stateBase in rootStates) { domNodes.Add(stateBase.DomNode); allStates.Add(stateBase); State state = stateBase.As <State>(); if (state != null) { foreach (StateBase subState in state.SubStates) { allStates.Add(subState); } } } // get selected transitions between selected states bool itemsIncludeTransitions = false; foreach (Transition transition in Selection.AsIEnumerable <Transition>()) { domNodes.Add(transition.DomNode); itemsIncludeTransitions = true; } // if there were none, then try to add any transitions between selected states or sub-states if (!itemsIncludeTransitions) { foreach (Transition transition in m_transitions) { if (allStates.Contains(transition.FromState) && allStates.Contains(transition.ToState)) { domNodes.Add(transition.DomNode); } } } foreach (Annotation annotation in Selection.AsIEnumerable <Annotation>()) { domNodes.Add(annotation.DomNode); } DomNode[] copies = DomNode.Copy(domNodes); return(new DataObject(Enumerable.ToArray <object>(copies))); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> /// <remarks>ApplicationUtil calls this method in its Insert method, BUT /// if the context also implements IHierarchicalInsertionContext, /// IHierarchicalInsertionContext is preferred and the IInstancingContext /// implementation is ignored for insertion.</remarks> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } var folder = m_activeItem.As <TemplateFolder>() ?? RootFolder; var domNodes = items.AsIEnumerable <DomNode>(); IsMovingItems = domNodes.All(x => IsTemplateItem(x, x.Parent)); var itemCopies = IsMovingItems ? domNodes.ToArray() // shallow copy, for moving items around inside template lister : DomNode.Copy(domNodes); // DOM deep copy if (IsMovingItems) { // Note: since both templates and template folders are implemented as DomNodes, // inserting a DomNode to a new parent will auto-remove the node from its old parent, // so we only need to take care of the insertion part foreach (var item in itemCopies) { if (item.Is <Template>()) { folder.Templates.Add(item.Cast <Template>()); } else if (item.Is <TemplateFolder>()) { folder.Folders.Add(item.Cast <TemplateFolder>()); } } } else //insert items as templates { m_lastPromoted.Clear(); if (IsExternalTemplate(folder)) { folder = RootFolder; // perhaps shouldn't prompt items to an external folder directly, let's add to root folder } for (int index = 0; index < itemCopies.Length; ++index) { var item = itemCopies[index]; var template = new DomNode(TemplateType).Cast <Template>(); template.Target = item; template.Guid = Guid.NewGuid(); folder.Templates.Add(template); m_lastPromoted.Add(items[index], template); } } IsMovingItems = false; }
private DomNode CreatePrefab(IEnumerable <object> gobs) { UniqueNamer uniqueNamer = new UniqueNamer(); DomNode[] temp = new DomNode[1]; var copyList = new List <object>(); AABB bound = new AABB(); foreach (var gameObject in SelectedGobs) { IBoundable boundable = gameObject.As <IBoundable>(); bound.Extend(boundable.BoundingBox); var trans = gameObject.As <ITransformable>(); var world = (trans != null) ? TransformUtils.ComputeWorldTransform(trans) : Matrix4F.Identity; temp[0] = gameObject.As <DomNode>(); DomNode[] copies = DomNode.Copy(temp); copies[0].InitializeExtensions(); var nameable = copies[0].As <INameable>(); if (nameable != null) { nameable.Name = uniqueNamer.Name(nameable.Name); } var copyTrans = copies[0].As <ITransformable>(); if (copyTrans != null) { TransformUtils.SetTransform(copyTrans, world); } copyList.Add(copies[0]); } DomNode prefab = new DomNode(Schema.prefabType.Type, Schema.prefabRootElement); var list = prefab.GetChildList(Schema.prefabType.gameObjectChild); Vec3F center = bound.Center; foreach (var gob in copyList) { var trans = gob.As <ITransformable>(); if (trans != null) { trans.Translation = trans.Translation - center; trans.UpdateTransform(); } var node = gob.As <DomNode>(); if (node != null) { list.Add(node); } } return(prefab); }
/// <summary> /// Conversion function for drag-drop operations</summary> /// <param name="sourceObject">source object</param> /// <returns>IEnumerable of objects </returns> public static IEnumerable <object> ConvertData(object sourceObject, bool copydataobject) { IResourceService resourceService = Globals.ResourceService; IEnumerable <object> objectlist = sourceObject as IEnumerable <object>; IDataObject dataObject = sourceObject as IDataObject; DomNode domNode = Adapters.As <DomNode>(sourceObject); if (domNode != null) { yield return(domNode); } else if (objectlist != null) { foreach (object obj in objectlist) { yield return(obj); } } else if (dataObject != null) { DomNode[] domNodes = dataObject.GetData(typeof(DomNode[])) as DomNode[]; if (domNodes != null) { DomNode[] copies = copydataobject ? DomNode.Copy(domNodes) : domNodes; foreach (DomNode node in copies) { yield return(node); } } object[] objects = dataObject.GetData(typeof(object[])) as object[]; if (objects != null) { foreach (object node in objects) { yield return(node); } } string[] files = dataObject.GetData(DataFormats.FileDrop) as string[]; if (files != null && resourceService != null) { foreach (string file in files) { IResource resource = resourceService.Load(new Uri(file)); if (resource != null) { yield return(resource); } } } } }
public override object Clone() { var copy = DomNode.Copy(new[] { DomNode }); copy[0].InitializeExtensions(); var luaVar = copy[0].As <SledLuaVarBaseType>(); SetSortKeys(luaVar); return(luaVar); }
/// <summary> /// Copies the selection. Returns a data object representing the copied items.</summary> /// <returns>Data object representing the copied items; e.g., a /// System.Windows.Forms.IDataObject object</returns> public object Copy() { IEnumerable <UIObject> uiObjects = Selection.AsIEnumerable <UIObject>(); IEnumerable <Curve> curves = Selection.AsIEnumerable <Curve>(); IEnumerable <DomNode> rootNodes = DomNode.GetRoots(uiObjects.AsIEnumerable <DomNode>()); IEnumerable <DomNode> rootNodes2 = DomNode.GetRoots(curves.AsIEnumerable <DomNode>()); List <object> copies = new List <object>(DomNode.Copy(rootNodes)); copies.AddRange(rootNodes2); return(new DataObject(copies.ToArray())); }
public void TestCopy_SingleNode() { DomNodeType type = new DomNodeType("type"); AttributeInfo info = GetStringAttribute("string"); type.Define(info); DomNode test = new DomNode(type); test.SetAttribute(info, "foo"); DomNode[] result = DomNode.Copy(new DomNode[] { test }); Assert.True(Equals(result[0], test)); }
private DomNode[] Insert(object insertingObject, Point center) { var dataObject = (IDataObject)insertingObject; IEnumerable <object> items = GetCompatibleData(dataObject); if (items == null) { return(null); } if (items.All(x => x.Is <Template>())) { var refs = new List <object>(); foreach (var item in items.AsIEnumerable <Template>()) { refs.Add(InsertReference(item)); } Center(refs, center); Selection.SetRange(refs); return(null); } var itemCopies = DomNode.Copy(items.AsIEnumerable <DomNode>()); var modules = new List <Element>(itemCopies.AsIEnumerable <Element>()); foreach (var module in modules) { m_circuitContainer.Elements.Add(module); } foreach (var connection in itemCopies.AsIEnumerable <Wire>()) { m_circuitContainer.Wires.Add(connection); } foreach (var annotation in itemCopies.AsIEnumerable <Annotation>()) { m_circuitContainer.Annotations.Add(annotation); } Center(itemCopies, center); Selection.SetRange(itemCopies); return(itemCopies); }
/// <summary> /// Obtains dropped items from DragEventArgs data</summary> /// <param name="e">DragEventArgs containing drag and drop event data</param> /// <returns>Dropped items from drag-and-drop event</returns> protected virtual IEnumerable <ITimelineObject> ConvertDrop(DragEventArgs e) { object[] items = e.Data.GetData(typeof(object[])) as object[]; if (items == null) { return(EmptyEnumerable <ITimelineObject> .Instance); } DomNode[] nodeCopies = DomNode.Copy(items.AsIEnumerable <DomNode>()); IEnumerable <ITimelineObject> itemCopies = nodeCopies.AsIEnumerable <ITimelineObject>(); Point clientPoint = m_timelineControl.PointToClient(new Point(e.X, e.Y)); PointF mouseLocation = clientPoint; CenterEvents(itemCopies.AsIEnumerable <IEvent>(), mouseLocation, m_timelineControl.Transform); return(itemCopies); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } DomNode[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); IList <Event> events = this.Cast <WinGuiCommonData>().Events; foreach (Event _event in Adapters.AsIEnumerable <Event>(itemCopies)) { events.Add(_event); } Selection.SetRange(itemCopies); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } DomNode[] itemCopies = DomNode.Copy(items.AsIEnumerable <DomNode>()); IList <Character> characters = this.Cast <Settings>().Characters; foreach (Character character in itemCopies.AsIEnumerable <Character>()) { characters.Add(character); } Selection.SetRange(itemCopies); }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } DomNode[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); IList <Resource> resources = this.Cast <Event>().Resources; foreach (Resource resource in Adapters.AsIEnumerable <Resource>(itemCopies)) { resources.Add(resource); } Selection.SetRange(itemCopies); }