public void Load()
{
lineMaterial = new Material(Shader.Find("Sprites/Default"));
var stream = CharStreams.fromPath(filePath);
var lexer = new GravisLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new GravisParser(tokens)
{
BuildParseTree = true
};
var loader = new LoadListener();
var tree = parser.file_input();
ParseTreeWalker.Default.Walk(loader, tree);
RelinkSubspaces(loader.subspaces, loader.nodes);
var volume = new Volume();
var parts = Node.FindIsolatedGraphs(loader.nodes);
for (var i = 0; i < parts.Count; i++)
{
var nodes = parts[i];
Node.AlignNodesByForceDirected(nodes);
DrawNodes(nodes, i, volume);
}
var orbit = Camera.main.GetComponent <DragMouseOrbit>();
orbit.target = volume.GetCenter();
orbit.distance = volume.GetRadius() * 2;
}
public async Task Load(List <string> files, LoadListener listener, CancellationToken cancelToken)
{
this.listener = listener;
this.cancelToken = cancelToken;
lock (songs)
{
songs.Clear();
}
try
{
await Task.Run(() =>
{
splits = 0;
listener.NotifyLoadInitiated(files.Count);
SplitAndLoad(files);
}, cancelToken);
}
catch (Exception e)
{
Messenger.Log("Canceled!");
}
lock (songs)
{
Messenger.Log("Collected songs: " + songs.Count);
listener.NotifyCompleted(songs);
}
}
public List <string> Load(string path, LoadListener listener)
{
Path = path;
this.listener = listener;
Initiate();
return(new List <string>());
}
public Task Load(List <string> files, LoadListener listener1, CancellationToken cancelToken)
{
return(Task.Run(() =>
{
listener1.NotifyProgress(1);
listener1.NotifyCompleted(Songs);
}, cancelToken));
}
public List <string> Load(string path, LoadListener listener)
{
listener.NotifyNewLoad();
Messenger.PostMessage("Counting files, please be patient", Messenger.TargetType.Frontend);
var list = fileCollector.CollectFileNamesSync(path);
Messenger.PostMessage("Now adding " + list.Count + " files to library. Please be patient.",
Messenger.TargetType.Frontend);
return(list);
}
public Task <List <string> > LoadAsync(string path, LoadListener listener)
{
var task = Task.Run(() =>
{
Path = path;
this.listener = listener;
Initiate();
listener.NotifyProgress(1);
var list1 = list.Select((e) => e.Name).ToList();
return(list1);
});
task.Wait();
return(task);
}
public void DeleteSongs(IList <Song> songs, LoadListener progressTracker)
{
progressTracker.NotifyNewLoad();
progressTracker.NotifyLoadInitiated(songs.Count);
foreach (var s in songs)
{
library.RemoveById(s.ID);
Messenger.Post("Deleted song: " + s.Name);
progressTracker.NotifyProgress(1);
}
progressTracker.NotifyCompleted(songs);
library.InitialiseParts();
NotifyUpdated();
}
public void DeleteAlbum(string album, LoadListener listener)
{
var songsToDelete = library.GetSongsByAlbum(album);
listener.NotifyNewLoad();
listener.NotifyLoadInitiated(songsToDelete.Count);
foreach (var song in songsToDelete)
{
library.RemoveById(song.ID);
listener.NotifyProgress(1);
}
library.InitialiseParts();
listener.NotifyCompleted(new List <Song>());
NotifyUpdated();
}
public void DeleteArtist(string artist, LoadListener progressTracker)
{
var songs = library.GetSongsByArtist(artist);
progressTracker.NotifyNewLoad();
progressTracker.NotifyLoadInitiated(songs.Count + 1);
foreach (var song in songs)
{
library.RemoveById(song.ID);
progressTracker.NotifyProgress(1);
}
library.InitialiseParts();
progressTracker.NotifyProgress(1);
progressTracker.NotifyCompleted(new List <Song>());
NotifyUpdated();
}
public Task StartNewLoad(LoadListener listener, CancellationToken cancelToken)
{
Messenger.Log("Starting new Async load");
if (engine != null)
{
if (songCollector == null)
{
songCollector = new SongCollector(listener, tagReaderFactory);
}
return(Task.Run(async() =>
{
var list = await engine.LoadAsync(Path, listener);
await songCollector.Load(list, listener, cancelToken);
Messenger.Log("Done loading, " + list.Count);
}));
}
Messenger.Log("No engine?");
return(null);
}
private IList <Song> LoadFromXml(LoadListener listener)
{
if (!File.Exists(filename))
{
throw new Exception(filename + " not found!");
}
listener.NotifyNewLoad();
List <PersistedSong> songs = null;
using (var reader = XmlReader.Create(filename))
{
songs = new List <PersistedSong>((PersistedSong[])serializerInstance.Deserialize(reader));
}
Messenger.Post("Library reloaded from " + filename);
var convertedSongs = new SongConverter().ConvertPersistedSongs(songs);
Messenger.Log("Persisted songs converted");
listener.NotifyLoadInitiated(convertedSongs.Count);
listener.NotifyCompleted(convertedSongs);
return(convertedSongs);
}
public async Task <List <string> > LoadAsync(string path, LoadListener listener)
{
return(await Task.Run <List <string> >(() => Load(path, listener)));
}
public Task StartNewLoad(LoadListener listener, CancellationToken cancelToken)
{
return(Task.Run(() => LoadFromXml(listener)));
}
public Task LoadSongs(IAsyncSongLoader loader, LoadListener listener, CancellationToken cancelToken)
{
attachedListener = listener != this ? listener : null;
return(loader.StartNewLoad(this, cancelToken));
}
public Task LoadSongs(IAsyncSongLoader loader, LoadListener listener)
{
listener.Completed += Listener_Completed;
return(LoadSongs(loader, listener, CancellationToken.None));
}
public SongCollector(LoadListener listener, TagReaderFactory tagReaderFactory)
{
this.listener = listener;
this.tagReaderFactory = tagReaderFactory;
songs = new List <Song>();
}
