public InsertCopyableUndoEntry(ISelectParent parent, Copyable copyable, int right, string action)
: base($"{parent.ChildString} {action}", parent)
{
this.right = right;
init = copyable.Contents;
}
void Copyable_Insert(Copyable paste, int right, bool imported)
{
List <Track> pasted;
try {
pasted = paste.Contents.Cast <Track>().ToList();
} catch (InvalidCastException) {
return;
}
Program.Project.Undo.Add($"Track {(imported? "Imported" : "Pasted")}", () => {
for (int i = paste.Contents.Count - 1; i >= 0; i--)
{
Program.Project.Remove(right + i + 1);
}
}, () => {
for (int i = 0; i < paste.Contents.Count; i++)
{
Program.Project.Insert(right + i + 1, pasted[i].Clone());
}
}, () => {
foreach (Track track in pasted)
{
track.Dispose();
}
pasted = null;
});
for (int i = 0; i < paste.Contents.Count; i++)
{
Program.Project.Insert(right + i + 1, pasted[i].Clone());
}
}
private void Copyable_Insert(Copyable paste, int right, bool imported)
{
List <Device> pasted;
try {
pasted = paste.Contents.Cast <Device>().ToList();
} catch (InvalidCastException) {
return;
}
List <int> path = Track.GetPath(_chain);
Program.Project.Undo.Add($"Device {(imported? "Imported" : "Pasted")}", () => {
Chain chain = ((Chain)Track.TraversePath(path));
for (int i = paste.Contents.Count - 1; i >= 0; i--)
{
chain.Remove(right + i + 1);
}
}, () => {
Chain chain = ((Chain)Track.TraversePath(path));
for (int i = 0; i < paste.Contents.Count; i++)
{
chain.Insert(right + i + 1, pasted[i].Clone());
}
});
for (int i = 0; i < paste.Contents.Count; i++)
{
_chain.Insert(right + i + 1, pasted[i].Clone());
}
}
/// <summary>
/// Saves a shifted copy of an externally constructed cell.
/// </summary>
/// <param name="cell"></param>
/// <param name="newX"></param>
/// <param name="newY"></param>
public void SaveExternalCell(MapCellType cell, int newX, int newY)
{
Point sp = new Point(newX, newY);
Copyable <MapCellType> cc = (Copyable <MapCellType>)cell;
savedCells[sp] = cc.Copy();
}
public async void Paste(int right)
{
Copyable paste = await Copyable.DecodeClipboard();
if (paste != null && Copyable_Insert(paste, right, out Action undo, out Action redo, out Action dispose))
{
Program.Project.Undo.Add("Track Pasted", undo, redo, dispose);
}
}
public static async void Paste(ISelectParent parent, int right)
{
Copyable paste = await Copyable.DecodeClipboard();
if (paste != null && InsertCopyable(parent, paste, right, "Pasted", out InsertCopyableUndoEntry entry))
{
Program.Project.Undo.AddAndExecute(entry);
}
}
public object TryGetCopy(object obj)
{
Copyable copyable = obj as Copyable;
if (copyable == null)
{
return(obj);
}
return(this.GetCopy(copyable));
}
private static void Encode(BinaryWriter writer, Copyable o)
{
EncodeID(writer, typeof(Copyable));
writer.Write(o.Contents.Count);
for (int i = 0; i < o.Contents.Count; i++)
{
Encode(writer, (dynamic)o.Contents[i]);
}
}
static Copyable CreateCopyable(ISelectParent parent, int left, int right)
{
Copyable copy = new Copyable();
for (int i = left; i <= right; i++)
{
copy.Contents.Add(parent.IChildren[i]);
}
return(copy);
}
public bool TryCache(object obj)
{
Copyable copyable = obj as Copyable;
if (copyable == null)
{
return(false);
}
this.Cache(copyable);
return(true);
}
async void ReadFile(string path, bool recovery)
{
Project loaded = null;
Copyable imported = null;
try {
try {
using (FileStream file = File.Open(path, FileMode.Open, FileAccess.Read))
loaded = await Decoder.Decode(file, typeof(Project));
if (!recovery)
{
loaded.FilePath = path;
loaded.Undo.SavePosition();
Preferences.RecentsAdd(path);
}
Program.Project?.Dispose();
Program.Project = loaded;
} catch (InvalidDataException) {
using (FileStream file = File.Open(path, FileMode.Open, FileAccess.Read))
imported = await Decoder.Decode(file, typeof(Copyable));
Program.Project?.Dispose();
Program.Project = new Project(
tracks: (imported.Type == typeof(Track))
? imported.Contents.Cast <Track>().ToList()
: new List <Track>()
{
new Track(new Chain((imported.Type == typeof(Chain))
? new List <Device>()
{
new Group(imported.Contents.Cast <Chain>().ToList())
}
: imported.Contents.Cast <Device>().ToList()
))
}
);
}
} catch {
await MessageWindow.Create(
$"An error occurred while reading the file.\n\n" +
"You may not have sufficient privileges to read from the destination folder, or\n" +
"the file you're attempting to read is invalid.",
null, this
);
return;
}
ProjectWindow.Create(this);
Close();
}
public Copyable GetCopy(Copyable obj)
{
for (int i = objectPool.Count - 1; i >= 0; --i)
{
Copyable o = objectPool[i];
if (o.CopyFrom(obj))
{
objectPool.RemoveAt(i);
return(o);
}
}
return(obj.Copy());
}
static bool InsertCopyable(ISelectParent parent, Copyable copyable, int right, string action, out InsertCopyableUndoEntry entry)
{
entry = null;
if (!parent.ChildType.IsAssignableFrom(copyable.Type))
{
return(false);
}
entry = new InsertCopyableUndoEntry(parent, copyable, right, action);
return(true);
}
public static async void Replace(ISelectParent parent, int left, int right)
{
Copyable paste = await Copyable.DecodeClipboard();
if (paste != null && InsertCopyable(parent, paste, right, "", out InsertCopyableUndoEntry insert))
{
Program.Project.Undo.AddAndExecute(new ReplaceUndoEntry(
parent,
new DeleteUndoEntry(parent, left, right),
insert
));
}
}
bool Copyable_Insert(Copyable paste, int right, out Action undo, out Action redo, out Action dispose)
{
undo = redo = dispose = null;
List <Device> pasted;
try {
pasted = paste.Contents.Cast <Device>().ToList();
} catch (InvalidCastException) {
return(false);
}
List <int> path = Track.GetPath(_chain);
undo = () => {
Chain chain = Track.TraversePath <Chain>(path);
for (int i = paste.Contents.Count - 1; i >= 0; i--)
{
chain.Remove(right + i + 1);
}
};
redo = () => {
Chain chain = Track.TraversePath <Chain>(path);
for (int i = 0; i < paste.Contents.Count; i++)
{
chain.Insert(right + i + 1, pasted[i].Clone());
}
Track.Get(chain).Window?.Selection.Select(chain[right + 1], true);
};
dispose = () => {
foreach (Device device in pasted)
{
device.Dispose();
}
pasted = null;
};
for (int i = 0; i < paste.Contents.Count; i++)
{
_chain.Insert(right + i + 1, pasted[i].Clone());
}
Track.Get(_chain).Window?.Selection.Select(_chain[right + 1], true);
return(true);
}
async void ReadFile(string path, bool recovery)
{
Project loaded = null;
Copyable imported = null;
try {
try {
using (FileStream file = File.Open(path, FileMode.Open, FileAccess.Read))
loaded = await Decoder.Decode <Project>(file);
if (!recovery)
{
loaded.FilePath = path;
loaded.Undo.SavePosition();
Preferences.RecentsAdd(path);
}
Program.Project?.Dispose();
Program.Project = loaded;
} catch (InvalidDataException) {
using (FileStream file = File.Open(path, FileMode.Open, FileAccess.Read))
imported = await Decoder.Decode <Copyable>(file);
Program.Project?.Dispose();
Program.Project = new Project(
tracks: (imported.Type == typeof(Track))
? imported.Contents.Cast <Track>().ToList()
: new List <Track>()
{
new Track(new Chain((imported.Type == typeof(Chain))
? new List <Device>()
{
new Group(imported.Contents.Cast <Chain>().ToList())
}
: imported.Contents.Cast <Device>().ToList()
))
}
);
}
} catch {
await MessageWindow.CreateReadError(this);
Program.Project = null;
return;
}
ProjectWindow.Create(this);
Close();
}
public async void Export(int left, int right)
{
Window sender = Track.Get(_chain).Window;
SaveFileDialog sfd = new SaveFileDialog()
{
Filters = new List <FileDialogFilter>()
{
new FileDialogFilter()
{
Extensions = new List <string>()
{
"apdev"
},
Name = "Apollo Device Preset"
}
},
Title = "Export Device Preset"
};
string result = await sfd.ShowAsync(sender);
if (result != null)
{
string[] file = result.Split(Path.DirectorySeparatorChar);
if (Directory.Exists(string.Join("/", file.Take(file.Count() - 1))))
{
Copyable copy = new Copyable();
for (int i = left; i <= right; i++)
{
copy.Contents.Add(_chain[i]);
}
try {
File.WriteAllBytes(result, Encoder.Encode(copy).ToArray());
} catch (UnauthorizedAccessException) {
await MessageWindow.Create(
$"An error occurred while writing the file.\n\n" +
"You may not have sufficient privileges to write to the destination folder, or\n" +
"the current file already exists but cannot be overwritten.",
null, sender
);
}
}
}
}
public void Copy(int left, int right, bool cut = false)
{
Copyable copy = new Copyable();
for (int i = left; i <= right; i++)
{
copy.Contents.Add(Program.Project[i]);
}
copy.StoreToClipboard();
if (cut)
{
Delete(left, right);
}
}
public async void Replace(int left, int right)
{
Copyable paste = await Copyable.DecodeClipboard();
if (paste != null && Copyable_Insert(paste, right, out Action undo, out Action redo, out Action dispose))
{
Region_Delete(left, right, out Action undo2, out Action redo2, out Action dispose2);
Program.Project.Undo.Add("Track Replaced",
undo2 + undo,
redo + redo2 + (() => Program.Project.Window?.Selection.Select(Program.Project[left + paste.Contents.Count - 1], true)),
dispose2 + dispose
);
Selection.Select(Program.Project[left + paste.Contents.Count - 1], true);
}
}
static void Encode(BinaryWriter writer, Copyable o)
{
EncodeID(writer, typeof(Copyable));
writer.Write(o.Contents.Count);
for (int i = 0; i < o.Contents.Count; i++)
{
if (o.Contents[i] is Device d)
{
Encode(writer, d);
}
else
{
Encode(writer, (dynamic)o.Contents[i]);
}
}
}
bool Copyable_Insert(Copyable paste, int right, out Action undo, out Action redo, out Action dispose)
{
undo = redo = dispose = null;
List <Track> pasted;
try {
pasted = paste.Contents.Cast <Track>().ToList();
} catch (InvalidCastException) {
return(false);
}
undo = () => {
for (int i = paste.Contents.Count - 1; i >= 0; i--)
{
Program.Project.Remove(right + i + 1);
}
};
redo = () => {
for (int i = 0; i < paste.Contents.Count; i++)
{
Program.Project.Insert(right + i + 1, pasted[i].Clone());
}
Program.Project.Window?.Selection.Select(Program.Project[right + 1], true);
};
dispose = () => {
foreach (Track track in pasted)
{
track.Dispose();
}
pasted = null;
};
for (int i = 0; i < paste.Contents.Count; i++)
{
Program.Project.Insert(right + i + 1, pasted[i].Clone());
}
Selection.Select(Program.Project[right + 1], true);
return(true);
}
/// <summary>Creates a deep copy of the object, reusing the given object.</summary>
/// <param name="into">The object to copy into.</param>
/// <returns>The copy.</returns>
public void CopyInto(SpatialHashedQuadTree <T> into)
{
Copyable.CopyInto(this, into);
into._cells.Clear();
foreach (var entry in _cells)
{
var treeCopy = entry.Value.NewInstance();
entry.Value.CopyInto(treeCopy);
into._cells.Add(entry.Key, treeCopy);
}
into._entryBounds.Clear();
foreach (var bound in _entryBounds)
{
into._entryBounds.Add(bound.Key, bound.Value);
}
}
public async void Copy(int left, int right, bool cut = false)
{
Copyable copy = new Copyable();
for (int i = left; i <= right; i++)
{
copy.Contents.Add(_chain[i]);
}
string b64 = Convert.ToBase64String(Encoder.Encode(copy).ToArray());
if (cut)
{
Delete(left, right);
}
await Application.Current.Clipboard.SetTextAsync(b64);
}
/// <summary>
/// Constructs a shifted copy of the specified block, located
/// at the specified (upper left) corner, and saves the result.
/// </summary>
/// <param name="block"></param>
/// <param name="xmin"></param>
/// <param name="ymin"></param>
public void SaveExternalBlock(MapCellType[,] block, int xmin, int ymin)
{
int width = block.GetLength(0);
int height = block.GetLength(1);
MapCellType cell;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Copyable <MapCellType> copyable = block[x, y];
cell = copyable.Copy();
Point sp = new Point(x + xmin, y + ymin);
savedCells[sp] = cell;
}
}
}
public async void Import(int right, string path = null)
{
Window sender = Track.Get(_chain).Window;
if (path == null)
{
OpenFileDialog ofd = new OpenFileDialog()
{
AllowMultiple = false,
Filters = new List <FileDialogFilter>()
{
new FileDialogFilter()
{
Extensions = new List <string>()
{
"apdev"
},
Name = "Apollo Device Preset"
}
},
Title = "Import Device Preset"
};
string[] result = await ofd.ShowAsync(sender);
if (result.Length > 0)
{
path = result[0];
}
else
{
return;
}
}
Copyable loaded = await Copyable.DecodeFile(path, sender);
if (loaded != null && Copyable_Insert(loaded, right, out Action undo, out Action redo, out Action dispose))
{
Program.Project.Undo.Add("Device Imported", undo, redo, dispose);
}
}
public static async void Import(ISelectParent parent, int right, string[] paths = null)
{
if (parent.ChildFileExtension == null)
{
return;
}
Window sender = parent.IWindow;
paths = paths ?? await CreateOFD(parent).ShowAsync(sender);
if (!paths.Any())
{
return;
}
Copyable loaded = await Copyable.DecodeFile(paths, sender, parent.ChildType);
if (loaded != null && InsertCopyable(parent, loaded, right, "Imported", out InsertCopyableUndoEntry entry))
{
Program.Project.Undo.AddAndExecute(entry);
}
}
public async void Replace(int left, int right)
{
Copyable paste = await Copyable.DecodeClipboard();
if (paste != null && Copyable_Insert(paste, right, out Action undo, out Action redo, out Action dispose))
{
Region_Delete(left, right, out Action undo2, out Action redo2, out Action dispose2);
List <int> path = Track.GetPath(_chain);
Program.Project.Undo.Add("Device Replaced",
undo2 + undo,
redo + redo2 + (() => {
Chain chain = Track.TraversePath <Chain>(path);
Track.Get(chain).Window?.Selection.Select(chain[left + paste.Contents.Count - 1], true);
}),
dispose2 + dispose
);
Track.Get(_chain).Window?.Selection.Select(_chain[left + paste.Contents.Count - 1], true);
}
}
/// <summary>
/// Creates a deep copy of the system. The passed system must be of the same type.
/// <para>
/// This clones any contained data types to return an instance that represents a complete copy of the one passed
/// in.
/// </para>
/// </summary>
/// <param name="into">The instance to copy into.</param>
/// <remarks>The manager for the system to copy into must be set to the manager into which the system is being copied.</remarks>
public virtual void CopyInto(AbstractSystem into)
{
// Don't allow identity copying.
Debug.Assert(into != this, "Cannot copy into self, is this intentional?");
if (into == this)
{
return;
}
// Manager must be re-set to new owner before copying.
if (into.Manager == null)
{
throw new ArgumentException("Target must have a Manager.", "into");
}
// Systems should never have to be copied inside the same context.
if (into.Manager == Manager)
{
throw new ArgumentException("Target must have a different Manager.", "into");
}
// Use dynamic function to do basic copying.
Copyable.CopyInto(this, into);
}
/// <summary>Creates a deep copy of the object, reusing the given object.</summary>
/// <param name="into">The object to copy into.</param>
/// <returns>The copy.</returns>
public void CopyInto(JointEdge into)
{
Copyable.CopyInto(this, into);
}
/// <summary>Creates a deep copy of the object, reusing the given object.</summary>
/// <param name="into">The object to copy into.</param>
/// <returns>The copy.</returns>
public virtual void CopyInto(Behavior into)
{
Copyable.CopyInto(this, into);
}
