public void AddToLayer(Layer layer)
{
mLayer = layer;
if (layer != null)
{
if (layer.CameraBelongingTo == null)
{
mText.CameraToAdjustPixelPerfectTo = SpriteManager.Camera;
}
else
{
mText.CameraToAdjustPixelPerfectTo = layer.CameraBelongingTo;
}
}
if (mCircleVisibleRepresentation != null)
{
ShapeManager.AddToLayer(mCircleVisibleRepresentation, layer);
}
else
{
SpriteManager.AddToLayer(mSpriteVisibleRepresentation, layer);
}
ShapeManager.AddToLayer(mParentLine, layer);
ShapeManager.AddToLayer(mParentAttachmentPoint, layer);
TextManager.AddToLayer(mText, layer);
mText.SetPixelPerfectScale(mLayer);
}
public virtual void MoveToLayer(Layer layerToMoveTo)
{
if (LayerProvidedByContainer != null)
{
LayerProvidedByContainer.Remove(LabelText);
}
TextManager.AddToLayer(LabelText, layerToMoveTo);
LayerProvidedByContainer = layerToMoveTo;
}
// Generated AddToManagers
public virtual void ReAddToManagers(Layer layerToAddTo)
{
LayerProvidedByContainer = layerToAddTo;
SpriteManager.AddPositionedObject(this);
GuiManager.AddWindow(this);
TextManager.AddToLayer(LabelText, LayerProvidedByContainer);
if (LabelText.Font != null)
{
LabelText.SetPixelPerfectScale(LayerProvidedByContainer);
}
}
public void AddToManagers(Layer layer)
{
CurrentSelectableState = SelectableState.NotSelected;
SpriteManager.AddSpriteFrame(_backgroundSprite);
GuiManager.AddWindow(this);
TextManager.AddText(_label);
TextManager.AddToLayer(_label, layer);
Layer = layer;
}
// Generated AddToManagers
public virtual void ReAddToManagers(Layer layerToAddTo)
{
LayerProvidedByContainer = layerToAddTo;
SpriteManager.AddPositionedObject(this);
TextManager.AddToLayer(TextInstance, LayerProvidedByContainer);
if (TextInstance.Font != null)
{
TextInstance.SetPixelPerfectScale(LayerProvidedByContainer);
}
SpriteManager.AddToLayer(SpriteInstance, LayerProvidedByContainer);
ShapeManager.AddToLayer(mCollision, LayerProvidedByContainer);
}
static void CreateTextIfNecessary()
{
if (mText == null)
{
mText = TextManager.AddText("");
mLayer = SpriteManager.TopLayer;
TextManager.AddToLayer(mText, mLayer);
mText.AttachTo(SpriteManager.Camera, false);
mText.VerticalAlignment = VerticalAlignment.Top;
mText.AdjustPositionForPixelPerfectDrawing = true;
}
}
public virtual void MoveToLayer(Layer layerToMoveTo)
{
if (LayerProvidedByContainer != null)
{
LayerProvidedByContainer.Remove(TextInstance);
}
TextManager.AddToLayer(TextInstance, layerToMoveTo);
if (LayerProvidedByContainer != null)
{
LayerProvidedByContainer.Remove(SpriteInstance);
}
SpriteManager.AddToLayer(SpriteInstance, layerToMoveTo);
LayerProvidedByContainer = layerToMoveTo;
}
protected bool Collect; //used to signal running events that this window has been destroyed
public Window(Window owner = null, bool modal = false, string sprite = "")
{
if (owner != null && modal)
{
throw new ArgumentException("Child cannot be modal");
}
Collect = false;
Immovable = false;
zEventEscape = null;
zModal = modal;
Name = string.Empty;
zOrigin = new Vector2(0, 0);
if (sprite == "")
{
zSprite = SpriteManager.AddSprite(Path.Make(Path.Misc, "pixel.bmp"));
}
else
{
zSprite = SpriteManager.AddSprite(sprite);
}
zSprite.ColorOperation = ColorOperation.ColorTextureAlpha;
Color = Color.White;
zVisible = true;
OnClick = delegate() { };
Hover = delegate() { };
HoverMousedown = delegate() { };
MouseLeave = delegate() { };
MouseEnter = delegate() { };
zParent = owner;
zChildren = new List <Window>();
zText = TextManager.AddText(string.Empty, Globals.Font);
zText.ColorOperation = ColorOperation.ColorTextureAlpha;
zText.AttachTo(zSprite, false);
Size = new Vector2(1, 1);
if (owner == null)
{
InitializeAsTopLevel();
}
else
{
InitializeAsChild();
}
SpriteManager.AddToLayer(zSprite, zLayer);
TextManager.AddToLayer(zText, zLayer);
zSprite.AttachTo(Camera.Main, true);
}
private object CreateFlatRedBallTypeNos(NamedObjectSave namedObjectSave,
PositionedObjectList <ElementRuntime> listToPopulate, Layer layerToPutOn)
{
object returnObject = null;
ElementRuntime newElementRuntime = null;
switch (namedObjectSave.SourceClassType)
{
case "Layer":
case "FlatRedBall.Graphics.Layer":
returnObject = CreateLayerObject(namedObjectSave, returnObject);
break;
case "AxisAlignedRectangle":
case "FlatRedBall.Math.Geometry.AxisAlignedRectangle":
AxisAlignedRectangle aaRectangle = ShapeManager.AddAxisAlignedRectangle();
if (layerToPutOn != null)
{
ShapeManager.AddToLayer(aaRectangle, layerToPutOn);
}
aaRectangle.Name = namedObjectSave.InstanceName;
returnObject = aaRectangle;
break;
case "Camera":
case "FlatRedBall.Camera":
if (namedObjectSave.IsNewCamera)
{
returnObject = null;
}
else
{
returnObject = SpriteManager.Camera;
}
break;
case "Circle":
case "FlatRedBall.Math.Geometry.Circle":
Circle circle = ShapeManager.AddCircle();
circle.Name = namedObjectSave.InstanceName;
if (layerToPutOn != null)
{
ShapeManager.AddToLayer(circle, layerToPutOn);
}
returnObject = circle;
break;
case "Polygon":
case "FlatRedBall.Math.Geometry.Polygon":
Polygon polygon = ShapeManager.AddPolygon();
polygon.Name = namedObjectSave.InstanceName;
if (layerToPutOn != null)
{
ShapeManager.AddToLayer(polygon, layerToPutOn);
}
returnObject = polygon;
break;
case "Sprite":
case "FlatRedBall.Sprite":
Sprite sprite = SpriteManager.AddSprite((Texture2D)null);
if (layerToPutOn != null)
{
SpriteManager.AddToLayer(sprite, layerToPutOn);
}
sprite.Name = namedObjectSave.InstanceName;
returnObject = sprite;
break;
case "SpriteFrame":
case "FlatRedBall.ManagedSpriteGroups.SpriteFrame":
SpriteFrame spriteFrame = SpriteManager.AddSpriteFrame(null, SpriteFrame.BorderSides.All);
if (layerToPutOn != null)
{
SpriteManager.AddToLayer(spriteFrame, layerToPutOn);
}
spriteFrame.Name = namedObjectSave.InstanceName;
returnObject = spriteFrame;
break;
case "Text":
case "FlatRedBall.Graphics.Text":
Text text = TextManager.AddText("");
if (layerToPutOn != null)
{
TextManager.AddToLayer(text, layerToPutOn);
text.SetPixelPerfectScale(layerToPutOn);
}
text.Name = namedObjectSave.InstanceName;
returnObject = text;
break;
case "Scene":
case "FlatRedBall.Scene":
Scene scene = new Scene();
scene.Name = namedObjectSave.InstanceName;
returnObject = scene;
break;
default:
// do nothing - need to add more types?
break;
}
if (returnObject != null)
{
if (returnObject is IScalable)
{
newElementRuntime = new ScalableElementRuntime(null, layerToPutOn, namedObjectSave, CreationOptions.OnBeforeVariableSet, CreationOptions.OnAfterVariableSet);
}
else
{
newElementRuntime = new ElementRuntime(null, layerToPutOn, namedObjectSave, CreationOptions.OnBeforeVariableSet, CreationOptions.OnAfterVariableSet);
}
newElementRuntime.mDirectObjectReference = returnObject;
if (returnObject is Camera && !namedObjectSave.IsNewCamera)
{
SpriteManager.Camera.AttachTo(newElementRuntime, false);
SpriteManager.Camera.RelativePosition = Vector3.Zero;
newElementRuntime.Z = 40;
newElementRuntime.Name = namedObjectSave.InstanceName;
}
else if (returnObject is FlatRedBall.Utilities.INameable)
{
newElementRuntime.Name = ((FlatRedBall.Utilities.INameable)returnObject).Name;
}
else
{
object nameValueAsObject;
if (LateBinder.TryGetValueStatic(returnObject, "Name", out nameValueAsObject))
{
newElementRuntime.Name = (string)nameValueAsObject;
}
}
listToPopulate.Add(newElementRuntime);
}
return(returnObject);
}
/// <summary>
/// Creates a runtime object and adds the LoadedFile to the element.
/// </summary>
/// <param name="objectToLoad"></param>
/// <param name="container"></param>
/// <param name="elementRuntime"></param>
/// <param name="objectType"></param>
/// <param name="objectJustLoaded"></param>
/// <param name="newElementRuntime"></param>
/// <param name="toAddTo"></param>
/// <param name="layerToAddTo"></param>
/// <param name="rfs"></param>
/// <param name="pullsFromEntireNamedObject"></param>
/// <returns></returns>
private static LoadedFile CreateRuntimeObjectForNamedObject(NamedObjectSave objectToLoad,
IElement container, ElementRuntime elementRuntime, string objectType,
LoadedFile objectJustLoaded,
ElementRuntime newElementRuntime,
object toAddTo,
Layer layerToAddTo, ReferencedFileSave rfs, bool pullsFromEntireNamedObject)
{
var fileName = ElementRuntime.ContentDirectory + objectToLoad.SourceFile;
bool shouldClone = rfs != null && (rfs.IsSharedStatic && !(container is ScreenSave)) && !pullsFromEntireNamedObject;
LoadedFile toReturn = null;
// This could have a ( in the name in a file like .scnx, so use the last (
//int indexOfType = objectToLoad.SourceName.IndexOf("(");
int indexOfType = objectToLoad.SourceName.LastIndexOf("(");
string objectName = objectToLoad.SourceName.Substring(0, indexOfType - 1);
switch (objectType)
{
case "Scene":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
foreach (Text text in scene.Texts)
{
text.AdjustPositionForPixelPerfectDrawing = true;
if (ObjectFinder.Self.GlueProject.UsesTranslation)
{
text.DisplayText = LocalizationManager.Translate(text.DisplayText);
}
}
if (shouldClone)
{
scene = scene.Clone();
elementRuntime.EntireScenes.Add(objectToLoad.SourceFile, scene);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = scene;
loadedFile.FilePath = objectToLoad.SourceFile;
loadedFile.ReferencedFileSave = rfs;
toReturn = loadedFile;
newElementRuntime.ReferencedFileRuntimeList.Add(loadedFile);
scene.AddToManagers(layerToAddTo);
}
}
break;
case "Sprite":
{
Sprite loadedSprite = null;
Scene scene = objectJustLoaded.RuntimeObject as Scene;
if (scene != null)
{
loadedSprite = scene.Sprites.FindByName(objectName);
}
if (loadedSprite == null)
{
System.Windows.Forms.MessageBox.Show("There is a missing Sprite called\n\n" + objectName + "\n\n" +
"in the object\n\n" + elementRuntime.Name + "\n\n" +
"This probably happened if someone changed the name of a Sprite in a .scnx file but didn't update " +
"the associated object in Glue", "Missing Sprite");
}
else
{
if (shouldClone)
{
loadedSprite = loadedSprite.Clone();
(toAddTo as Scene).Sprites.Add(loadedSprite);
SpriteManager.AddToLayer(loadedSprite, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSprite;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteFrame":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteFrame loadedSpriteFrame = scene.SpriteFrames.FindByName(objectName);
if (loadedSpriteFrame != null)
{
if (shouldClone)
{
loadedSpriteFrame = loadedSpriteFrame.Clone();
(toAddTo as Scene).SpriteFrames.Add(loadedSpriteFrame);
SpriteManager.AddToLayer(loadedSpriteFrame, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSpriteFrame;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteGrid":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteGrid spriteGrid = null;
for (int i = 0; i < scene.SpriteGrids.Count; i++)
{
if (scene.SpriteGrids[i].Name == objectName)
{
spriteGrid = scene.SpriteGrids[i];
break;
}
}
if (spriteGrid != null)
{
if (shouldClone)
{
spriteGrid = spriteGrid.Clone();
(toAddTo as Scene).SpriteGrids.Add(spriteGrid);
spriteGrid.Layer = layerToAddTo;
spriteGrid.PopulateGrid();
spriteGrid.RefreshPaint();
spriteGrid.Manage();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spriteGrid;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "Text":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
Text loadedText = scene.Texts.FindByName(objectName);
if (loadedText != null)
{
if (shouldClone)
{
loadedText = loadedText.Clone();
(toAddTo as Scene).Texts.Add(loadedText);
TextManager.AddToLayer(loadedText, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedText;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
loadedText.AdjustPositionForPixelPerfectDrawing = true;
if (LocalizationManager.HasDatabase)
{
loadedText.DisplayText = LocalizationManager.Translate(loadedText.DisplayText);
}
}
}
break;
case "ShapeCollection":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
if (shouldClone)
{
shapeCollection = shapeCollection.Clone();
elementRuntime.EntireShapeCollections.Add(objectToLoad.SourceFile, shapeCollection);
newElementRuntime.ReferencedFileRuntimeList.LoadedShapeCollections.Add(shapeCollection);
shapeCollection.AddToManagers(layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = shapeCollection;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
// Most cases are handled below in an AttachTo method, but
// ShapeCollection isn't a PositionedObject so we have to do it manually here
if (objectToLoad.AttachToContainer)
{
shapeCollection.AttachTo(elementRuntime, true);
}
}
break;
case "AxisAlignedCube":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedCube loadedAxisAlignedCube = shapeCollection.AxisAlignedCubes.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedCube = loadedAxisAlignedCube.Clone();
(toAddTo as ShapeCollection).AxisAlignedCubes.Add(loadedAxisAlignedCube);
ShapeManager.AddToLayer(loadedAxisAlignedCube, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedCube;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "AxisAlignedRectangle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedRectangle loadedAxisAlignedRectangle = shapeCollection.AxisAlignedRectangles.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedRectangle = loadedAxisAlignedRectangle.Clone();
(toAddTo as ShapeCollection).AxisAlignedRectangles.Add(loadedAxisAlignedRectangle);
ShapeManager.AddToLayer(loadedAxisAlignedRectangle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedRectangle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Circle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Circle loadedCircle = shapeCollection.Circles.FindByName(objectName);
if (shouldClone)
{
loadedCircle = loadedCircle.Clone();
(toAddTo as ShapeCollection).Circles.Add(loadedCircle);
ShapeManager.AddToLayer(loadedCircle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCircle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Polygon":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Polygon loadedPolygon = shapeCollection.Polygons.FindByName(objectName);
if (shouldClone)
{
loadedPolygon = loadedPolygon.Clone();
(toAddTo as ShapeCollection).Polygons.Add(loadedPolygon);
ShapeManager.AddToLayer(loadedPolygon, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedPolygon;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Sphere":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Sphere loadedSphere = shapeCollection.Spheres.FindByName(objectName);
if (shouldClone)
{
loadedSphere = loadedSphere.Clone();
(toAddTo as ShapeCollection).Spheres.Add(loadedSphere);
ShapeManager.AddToLayer(loadedSphere, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSphere;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Capsule2D":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Capsule2D loadedCapsule2D = shapeCollection.Capsule2Ds.FindByName(objectName);
if (shouldClone)
{
loadedCapsule2D = loadedCapsule2D.Clone();
(toAddTo as ShapeCollection).Capsule2Ds.Add(loadedCapsule2D);
ShapeManager.AddToLayer(loadedCapsule2D, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCapsule2D;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Emitter":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
Emitter loadedEmitter = emitterList.FindByName(objectName);
if (shouldClone && loadedEmitter != null)
{
loadedEmitter = loadedEmitter.Clone();
(toAddTo as EmitterList).Add(loadedEmitter);
SpriteManager.AddEmitter(loadedEmitter, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedEmitter;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "EmitterList":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
if (shouldClone && emitterList != null)
{
emitterList = emitterList.Clone();
foreach (var item in emitterList)
{
SpriteManager.AddEmitter(item);
}
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = emitterList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "NodeNetwork":
{
NodeNetwork nodeNetwork = objectJustLoaded.RuntimeObject as NodeNetwork;
if (shouldClone)
{
nodeNetwork = nodeNetwork.Clone();
elementRuntime.EntireNodeNetworks.Add(objectToLoad.SourceFile, nodeNetwork);
newElementRuntime.ReferencedFileRuntimeList.LoadedNodeNetworks.Add(nodeNetwork);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = nodeNetwork;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "SplineList":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
if (shouldClone)
{
splineList = splineList.Clone();
elementRuntime.EntireSplineLists.Add(splineList.Name, splineList);
foreach (var spline in splineList)
{
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
splineList.AddToManagers();
splineList[0].UpdateShapes();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = splineList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Spline":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
Spline spline = splineList.FirstOrDefault(item => item.Name == objectName);
if (shouldClone && spline != null)
{
spline = spline.Clone();
(toAddTo as SplineList).Add(spline);
// Eventually support layers?
//ShapeManager.AddToLayer(spline, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spline;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
break;
}
if (toReturn == null)
{
foreach (var manager in ReferencedFileRuntimeList.FileManagers)
{
var objectFromFile = manager.TryGetObjectFromFile(elementRuntime.ReferencedFileRuntimeList.LoadedRfses, rfs, objectType, objectName);
if (objectFromFile != null)
{
var runtimeObject = objectFromFile;
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = runtimeObject;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
break;
}
}
}
if (toReturn != null && objectToLoad.AttachToContainer)
{
if (toReturn.RuntimeObject is PositionedObject)
{
// If the object is already attached to something, that means it
// came from a file, so we don't want to re-attach it.
PositionedObject asPositionedObject = toReturn.RuntimeObject as PositionedObject;
if (asPositionedObject.Parent == null)
{
asPositionedObject.AttachTo(elementRuntime, true);
}
}
else if (toReturn.RuntimeObject is Scene)
{
((Scene)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
else if (toReturn.RuntimeObject is ShapeCollection)
{
((ShapeCollection)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
}
return(toReturn);
}
public void AddToManagers(Layer layer)
{
TextManager.AddToLayer(_text, layer);
_text.SetPixelPerfectScale(layer);
Layer = layer;
}