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);
}
