private void AddCaseTrack(
int caseId,
string title,
string stepTitle,
CaseStates state,
int flowStep,
Guid currentUserId,
DateTime dueDate,
int priority,
bool isLatestTrack,
string url,
DateTime creationDate)
{
var caseTrack = new CaseTracker(
caseId,
title,
stepTitle,
state,
flowStep,
currentUserId,
dueDate,
priority,
isLatestTrack,
url,
creationDate);
Tracks.Add(caseTrack);
}
public void AddTrack(string trackName, double lapDistance)
{
if (Tracks.FirstOrDefault(x => x.Name == trackName) == null)
{
Tracks.Add(new Track(trackName, lapDistance));
}
}
public override void ParseTracks(List <int> tracksOffsets)
{
foreach (var track in tracksOffsets)
{
var trackBytes = arr.Skip(track).ToArray();
var header = trackBytes.Take(4).ToArray().getInt(0);
if (Track.IsMusicTrack(header))
{
var t = new Track(trackBytes);
if (t.Channel > 15)
{
t.Channel -= 15;
}
if (t.Channel > 0 && t.Channel <= 0x10)
{
t.InitialInstrument = ChannelsInstruments[t.Channel];
Tracks.Add(t);
}
}
}
HandleNegativeTracks();
}
/// <summary>
/// Добавление трека
/// </summary>
public string Add(RocksmithTrack track)
{
// Если список треков от пользователя достиг лимита, то добавляем в отложенную очередь
int count = Tracks.Count(t => t.User == track.User);
if (count >= userLimit)
{
DeferredTracks.Add(track);
int deferredTracksCount = DeferredTracks.Count(t => t.User == track.User);
// Сохранение очередей в файл
Save();
return($"{track.User}, трек добавлен в отложенную очередь, {count + deferredTracksCount} треков всего");
}
TrackAddEvent?.Invoke(new TrackEventArgs {
Track = track
});
Tracks.Add(track);
// Сохранение очередей в файл
Save();
return($"{track.User}, трек добавлен.");
}
/// <summary>
/// Удаление трека
/// </summary>
public void RemoveTrack(RocksmithTrack track)
{
if (!Tracks.Contains(track))
{
return;
}
Tracks.Remove(track);
TrackRemoveEvent?.Invoke(new TrackEventArgs {
Track = track
});
// После удаления из очереди проверяем треки, которые можно добавить из отложенных
RocksmithTrack addTrack = DeferredTracks.FirstOrDefault(t => Tracks.Count(tt => tt.User == t.User) < userLimit);
if (addTrack != null)
{
DeferredTracks.Remove(addTrack);
Tracks.Add(addTrack);
TrackAddEvent?.Invoke(new TrackEventArgs {
Track = addTrack
});
}
// Сохранение очередей в файл
Save();
}
public SessionsViewModel()
{
Title = "Sessions";
_logger = AppSettings.Log.CreateLogger(Title);
_dataStore = App.DataStore;
_tracks = new List <TrackState>();
_selectedTrack = null;
_sessions = new ObservableCollection <SessionState>();
_sessionsGroupedByDate = new ObservableCollection <Grouping <SessionDateInfo, SessionState> >();
DependencyService.Get <IMessageBus>().OnEventRefreshed(this, state =>
{
Sessions.Clear();
foreach (SessionState session in state.Sessions)
{
Sessions.Add(session);
}
Tracks.Clear();
foreach (var track in state.Tracks)
{
Tracks.Add(track);
}
FilterSessions(_selectedTrack);
});
}
private async Task LoadArtistRelatedTracks()
{
var returned = await _albumService.Get <List <Album> >(new AlbumSearchRequest()
{
ArtistId = ThisArtistId
});
var thisArtist = await _artistService.GetById <Artist>(ThisArtistId);
foreach (var item in returned)
{
var tracksInAlbum = await _trackService.Get <List <Track> >(new TrackSearchRequest()
{
AlbumId = item.AlbumId
});
foreach (var x in tracksInAlbum)
{
TrackHelperVM local = new TrackHelperVM()
{
AlbumId = item.AlbumId,
AlbumName = item.AlbumName,
ArtistId = (int)ThisArtistId,
ArtistName = thisArtist.ArtistName,
TrackId = x.TrackId,
TrackName = x.TrackName
};
Tracks.Add(local);
AllTracks.Add(local);
}
}
}
private void ViewModelAddData(Search result)
{
result.Albums.Items.ForEach(a => Albums.Add(a));
result.Artists.Items.ForEach(a => Artists.Add(a));
result.Playlists.Items.ForEach(p => Playlists.Add(p));
result.Tracks.Items.ForEach(t => Tracks.Add(t));
}
private void AddFilesWizard_Load(object sender, EventArgs e)
{
foreach (string pfd in FilesDirs.ToArray <string>())
{
if (Directory.Exists(pfd))
{
AddDirToNode(pfd, tvBands.Nodes);
}
else if (File.Exists(pfd))
{
XmlTrack track = new XmlTrack(pfd);
Tracks.Add(track);
TracksOrphaned.Add(track);
}
}
XmlDisc discOrphaned = new XmlDisc(TracksOrphaned);
foreach (XmlTrack track in TracksOrphaned)
{
TreeNode tnOrphaned = new TreeNode("Orphaned Tracks");
tnOrphaned.Tag = discOrphaned;
tvBands.Nodes.Add(tnOrphaned);
}
if (tvBands.Nodes.Count > 0 && tvBands.Nodes[0].Nodes.Count > 0)
{
tvBands.SelectedNode = tvBands.Nodes[0].Nodes[0];
}
else if (tvBands.Nodes.Count > 0)
{
tvBands.SelectedNode = tvBands.Nodes[0];
}
}
public void Drop(IDropInfo dropInfo)
{
if (dropInfo.Data is Audio && Tracks.Count < 15 && Tracks.All(t => t.Id != ((Audio)dropInfo.Data).Id))
{
Tracks.Add((VkAudio)dropInfo.Data);
}
}
public async Task LoadTracks(IReadOnlyList <StorageFile> tracks)
{
if (tracks == null)
{
return;
}
int i = 0;
foreach (var track in tracks)
{
i++;
var trackItem = await GetInformationsFromMusicFile.GetTrackItemFromFile(track, Artist, Name, i, ArtistId, Id);
var databaseTrack = await _trackDataRepository.LoadTrack(ArtistId, Id, trackItem.Name);
if (databaseTrack == null)
{
await _trackDataRepository.Add(trackItem);
Tracks.Add(trackItem);
}
await DispatchHelper.InvokeAsync(() =>
{
Locator.MusicLibraryVM.Track.Add(trackItem);
OnPropertyChanged("Track");
});
}
}
public static void LoadInput()
{
int x = 0;
int y = 0;
foreach (char c in Input)
{
if (c == '\n')
{
y++; x = 0; continue;
}
else if (c == '>' || c == '<')
{
Tracks.Add(new Point(x, y), '-');
Minecarts.Add(MineCart.GetMineCart(c, new Point(x, y)));
}
else if (c == '^' || c == 'v')
{
Tracks.Add(new Point(x, y), '|');
Minecarts.Add(MineCart.GetMineCart(c, new Point(x, y)));
}
else if (c == ' ')
{
}
else
{
Tracks.Add(new Point(x, y), c);
}
x++;
}
}
public TrackStepViewModel AddTrack(SamplePlayer samplePlayer)
{
var track = new Track(samplePlayer);
Tracks.Add(track);
var trackVm = new TrackStepViewModel(track);
try
{
if (CurrentTrackViewModel != null)
{
var index = TrackViewModels.IndexOf(CurrentTrackViewModel);
if (index != -1)
{
TrackViewModels.Insert(index + 1, trackVm);
return(trackVm);
}
}
}
catch (ArgumentOutOfRangeException)
{
}
TrackViewModels.Add(trackVm);
return(trackVm);
}
private void LoadList()
{
Guid?selectedTrackId = SelectedTrack?.Track.Id;
var tracks = tracksProvider.Tracks.Select(t => new TrackListItemVM()
{
Track = t,
Body = t.Body.Names.First(),
StartDate = JulianDayToString(t.From),
EndDate = JulianDayToString(t.To),
Color = t.Color
});
Tracks.Clear();
foreach (var track in tracks)
{
Tracks.Add(track);
}
if (selectedTrackId != null)
{
SelectedTrack = tracks.FirstOrDefault(t => t.Track.Id == selectedTrackId.Value);
}
NotifyPropertyChanged(nameof(NoTracks));
}
public World(int trains = 1)
{
for (var i = 0; i < trains; i++)
{
Tracks.Add(new Track());
}
}
public override int Build()
{
Tracks.Clear();
Track track = new Track(++trackId, Tracktype.Airline);
Node node;
Osm.Segment segment = new Osm.Segment();
segment.Tags.Add("ref", "North/South connection");
Osm.Node osmNode;
segment.Id = 1;
// make a track with segment size of 96 meter. (180 segments North/South)
for (int y = -MapSize / 2; y <= MapSize / 2; y += 96)
{
osmNode = new Osm.Node();
osmNode.Lat = GeoTools.DistanceToLat(lat, y);
osmNode.Lon = lon;
node = CreateNode(track, segment, osmNode, 0, y);
track.Nodes.Add(node);
}
Tracks.Add(track);
return(0);
}
public void AddTrack(TrackObject trackObject)
{
if (!Tracks.Contains(trackObject))
{
Tracks.Add(trackObject);
}
}
void Load_files()
{
var dialog = new FolderBrowserDialog();
if (dialog.ShowDialog() == DialogResult.OK)
{
Tracks.Clear();
foreach (string file in Directory.GetFiles(dialog.SelectedPath))
{
if (filter.Exists(n => n == file.Split(new char[] { '.' }).Last().ToLower()))
{
try
{
var fileinfo = new FileInfo(file);
Tracks.Add(new Track {
Name = fileinfo.Name, Path_to_Track = fileinfo.FullName, Size = fileinfo.Length / 1000
});
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(ex.Message);
}
}
}
}
}
private void OnVisualizeTrack(VisualizeTrackEvent obj)
{
Tracks.Clear();
if (obj.Track != null && obj.Track.Any())
{
if (obj.Track.Count == 2)
{
Tracks.Add(obj.Track.First().CalculateGreatCircleLocations(obj.Track.Last()));
}
else if (obj.Track.Count > 2)
{
IList <LogbookLocation> filteredTrack = GetFilteredTrack(obj.Track, Length.FromMeters(10));
int pageSize = 2000;
int pages = (int)Math.Ceiling(filteredTrack.Count / (double)pageSize);
for (int i = 0; i < pages * pageSize; i += pageSize)
{
LocationCollection locations = new LocationCollection();
foreach (LogbookLocation location in filteredTrack.Skip(i).Take(pageSize))
{
locations.Add(location);
}
Tracks.Add(locations);
}
}
ZoomToTracksBounds();
}
}
private async Task Init()
{
var tracksintracklist = await _tracklistTrackService.Get <List <TracklistTrack> >(new TracklistTrackSearchRequest()
{
TracklistId = TracklistId
});
if (AddTracks == false)
{
foreach (var item in tracksintracklist)
{
var thisTrack = await _trackService.GetById <Track>(item.TrackId);
var thisAlbum = await _albumService.GetById <Album>(thisTrack.AlbumId);
var thisArtist = await _artistService.GetById <Artist>(thisAlbum.ArtistId);
TrackHelperVM local = new TrackHelperVM()
{
TrackId = thisTrack.TrackId,
TrackName = thisTrack.TrackName,
AlbumId = thisAlbum.AlbumId,
AlbumName = thisAlbum.AlbumName,
ArtistId = thisArtist.ArtistId,
ArtistName = thisArtist.ArtistName
};
Tracks.Add(local);
AllTracks.Add(local);
}
}
}
/// <summary>Schedules the talks.</summary>
/// <exception cref="TrackManagementException">Unable to find matching subset.</exception>
public void ScheduleTalks()
{
try
{
if (null == UnscheduledTalks || null == Tracks)
{
return;
}
while (AreTalksRemaining)
{
if (TrySchedulingUsingBufferTrackTime())
{
break;
}
ITrack newTrack = Factory.Instance.GetNewTrack(Date);
bool scheduleResult = newTrack.ScheduleTrack(UnscheduledTalks);
if (!scheduleResult)
{
var trackContent = newTrack.ToString();
if (!string.IsNullOrWhiteSpace(trackContent))
{
Console.WriteLine(Resource.TrackSchedulingError);
Console.WriteLine(trackContent);
}
throw new TrackManagementException(Resource.UnableToFindSubsetMessage);
}
Tracks.Add(newTrack);
Date = Date.AddDays(1); //Next track will begin on next day.
}
}
catch (TrackManagementException trackManagementException)
{
PrintException(trackManagementException);
}
}
public async Task SetupView(Playlist newPlaylist)
{
// Check if the models saved playlist is null
if (newPlaylist != null && (Playlist == null || Playlist.Id != newPlaylist.Id))
{
// Show the loading ring
(App.CurrentFrame?.FindName("PlaylistInfoPane") as InfoPane)?.ShowLoading();
// Set the playlist
Playlist = newPlaylist;
// Clear any existing tracks
Tracks.Clear();
// Get the resource loader
var resources = ResourceLoader.GetForCurrentView();
// Check if the tile is pinned
if (TileService.Instance.DoesTileExist("Playlist_" + Playlist.Id))
{
PinButtonIcon = "\uE77A";
PinButtonText = resources.GetString("AppBarUI_Unpin_Raw");
}
else
{
PinButtonIcon = "\uE718";
PinButtonText = resources.GetString("AppBarUI_Pin_Raw");
}
if (await SoundByteService.Instance.ExistsAsync($"/e1/me/playlist_likes/{Playlist.Id}"))
{
LikeButtonText = "Unlike Playlist";
}
else
{
LikeButtonText = "Like Playlist";
}
try
{
// Show the loading ring
(App.CurrentFrame?.FindName("PlaylistInfoPane") as InfoPane)?.ShowLoading();
// Get the playlist tracks
var playlistTracks =
(await SoundByteService.Instance.GetAsync <Playlist>("/playlists/" + Playlist.Id)).Tracks;
playlistTracks.ForEach(x => Tracks.Add(x));
// Hide the loading ring
(App.CurrentFrame?.FindName("PlaylistInfoPane") as InfoPane)?.ClosePane();
}
catch (Exception)
{
(App.CurrentFrame?.FindName("PlaylistInfoPane") as InfoPane)?.ShowMessage("Could not load tracks",
"Something went wrong when trying to load the tracks for this playlist, please make sure you are connected to the internet and then go back, and click on this playlist again.",
"", false);
}
// Hide the loading ring
(App.CurrentFrame?.FindName("PlaylistInfoPane") as InfoPane)?.ClosePane();
}
}
private void AddTrack(String name, TrackType trackType)
{
Track track = new Track(name, trackType);
trackType.Tracks.Add(track);
Tracks.Add(track);
TrackList.Add(track);
}
public MidiTrack CreateTrack()
{
var track = new MidiTrack();
track.Index = Tracks.Count;
track.File = this;
Tracks.Add(track);
return(track);
}
/// <summary>
/// Removes all paths that don't exist and fills the list of tracks according to paths remainig
/// </summary>
public void Recover()
{
Paths.RemoveAll(path => !File.Exists(path));
foreach (string path in Paths)
{
Tracks.Add(AudioDictionary.GetAudio(path));
}
}
public CUEMetadata(string id, int AudioTracks)
: this()
{
Id = id;
for (int i = 0; i < AudioTracks; i++)
{
Tracks.Add(new CUETrackMetadata());
}
}
private void InitSynth()
{
foreach (var trackIndex in WrapperRoot.AcbFile.GetSynth(CueRef.ReferenceIndex.TableGuid).ActionTracks)
{
ACB_Track track = WrapperRoot.AcbFile.GetActionTrack(trackIndex.TableGuid);
Tracks.Add(new Track_Wrapper(track, WrapperRoot, this, ActionTrackType.Synth));
}
}
public void Add(StationTrack track)
{
if (track == null)
{
throw new ArgumentNullException(nameof(track));
}
track.Station = this;
Tracks.Add(track);
}
public override void CreateEmptyMedia()
{
_LastError = "";
Tracks.Clear();
for (int i = 0; i < 80; ++i)
{
Tracks.Add(new Track(i + 1, 40));
}
CreateBAM();
}
public void Initalize(IEnumerable <NormalPlaylist> playlists)
{
foreach (var playlist in playlists)
{
foreach (var track in playlist.Tracks.Where(track => track.IsFavorite))
{
Tracks.Add(track);
}
}
}
