private static void Reorder(ITrack track)
{
for (var i = 0; i < track.MediaItems.Count; i++)
{
track.MediaItems[i].Order = i;
}
}
private static void WaitForIsLoaded(ITrack track, CancellationToken cancellationToken)
{
while (!track.IsLoaded() || cancellationToken.IsCancellationRequested)
{
Task.Delay(250, cancellationToken);
}
}
/// <summary>
/// Sets the interval's track</summary>
/// <param name="interval">Interval to move to a new track</param>
/// <param name="newTrack">New track that becomes the owner of this interval,
/// or null if there is no new owning track</param>
/// <remarks>
/// SetTrack DOES NOT by itself set the interval's Track property!
/// This happens indirectly and only if ITrack is implemented correctly.
///
/// If the interval and new track are DomNodes AND Intervals are DOM-children of their track,
/// you can implement the Track property like this:
/// public ITrack Track { get { return GetParentAs<ITrack>(); } }
///
/// Otherwise, use an ObservableCollection for your Intervals list,
/// monitor changes and update the interval's Track property when
/// intervals are being added to or removed from a Track.
/// </remarks>
public static void SetTrack(this IInterval interval, ITrack newTrack)
{
ITrack currentTrack = interval.Track;
if (currentTrack != null)
currentTrack.Intervals.Remove(interval);
if (newTrack != null)
newTrack.Intervals.Add(interval);
}
public void Update(TimeSpan dt, ITrack track)
{
_position += _velocity * dt.TotalSeconds;
while (_position > track.Length) _position -= track.Length;
var tmp = PositionUpdated;
if (tmp != null) tmp(this);
}
public Track(ITrack track, Dispatcher dispatcher)
{
InternalTrack = track;
_album = new Lazy<Album>(() => new Album(InternalTrack.Album, dispatcher));
_artists = new Lazy<IEnumerable<Artist>>(() => InternalTrack.Artists.Select(artist => new Artist(artist, dispatcher)));
_duration = new Lazy<TimeSpan>(() => InternalTrack.Duration);
}
private static object GetIcon(ITrack track)
{
//if (track.TargetType == MediaType.AudioMpeg)
//{
// return "pack://application:,,,/Images/File Audio MP3-01.png";
//}
return "pack://application:,,,/Images/File Audio-01.png";
}
public void StopAllPlayback()
{
currentTrack = null;
SpotifySession.PlayerUnload();
isPaused = false;
currentTrackPositionOffset = new TimeSpan(0);
player.Stop();
PlaybackMonitor.Stop();
}
public Track(ITrack track, Dispatcher dispatcher)
{
_dispatcher = dispatcher;
InternalTrack = track;
_album = new Lazy<Album>(() => new Album(InternalTrack.Album, _dispatcher));
_artists = new Lazy<IEnumerable<Artist>>(GetArtists);
_duration = new Lazy<TimeSpan>(() => InternalTrack.Duration);
}
public override void SongPlay(ITrack track)
{
if (_client != null)
{
var foundChannel = CurrentServer?.TextChannels.First(d => d.Name == "bot_tests");
foundChannel.SendMessage("Now Playing: " + track.Name + " by " + track.Artists[0].Name);
_providerConverted = null;
}
}
public void PlayOrQueue(ITrack track)
{
Append(track);
if (Index < 0)
{
Index = 0;
Play();
}
}
public Track(ITrack track)
{
Name = track.Name;
Artists = track.Artists.Select(a => new Artist(a)).ToArray();
Album = track.Album.Name;
Length = track.Duration;
IsAvailable = track.IsAvailable;
Popularity = track.Popularity;
IsStarred = track.IsStarred;
}
public TrackStarted(IRoom room, ITrack track)
{
if (room == null)
throw new ArgumentNullException(nameof(room));
if (track == null)
throw new ArgumentNullException(nameof(track));
TrackId = track.Id;
RoomId = room.Id;
}
public void AddTrack(ITrack nuTrack)
{
// do some checking
// perhaps the movie needs to get longer!
if (GetTrackByTrackId(nuTrack.TrackMetaData.TrackId) != null)
{
// We already have a track with that trackId. Create a new one
nuTrack.TrackMetaData.TrackId = GetNextTrackId();
}
Tracks.Add(nuTrack);
}
public bool Equals(ITrack track)
{
iTunesTrack typeTrack = track as iTunesTrack;
if (typeTrack != null &&
typeTrack.m_track.TrackDatabaseID == m_track.TrackDatabaseID)
{
return true;
}
else
{
return false;
}
}
private TrackViewModel BuildMediaItemsTimelineTrackViewModel(ITrack track, MediaItemsTimelineViewModel mediaItemsTimelineViewModel)
{
var trackViewModel = new TrackViewModel {
MediaItems = new ObservableCollection<MediaItemViewModel>(),
Track = track
};
trackViewModel.DropHandler = new TrackViewModelDropHandler(trackViewModel);
CollectionObserver.BindCollection(trackViewModel.MediaItems,
track.MediaItems,
mediaItem => BuildMediaItemsTimelineMediaItemViewModel(mediaItem, mediaItemsTimelineViewModel, trackViewModel));
return trackViewModel;
}
public ITrack TrackSimplifier(ITrack track)
{
List<ITrackSegment> simplifiedSegmnet = new List<ITrackSegment>();
foreach (ITrackSegment segment in track.TrackSegments)
{
simplifiedSegmnet.Add(SimplifySegment(segment));
}
track.TrackSegments.Clear();
foreach (ITrackSegment segmnet in simplifiedSegmnet)
{
track.TrackSegments.Add(segmnet);
}
return track;
}
protected String GenerateArguments(String tmpFilePath, ITrack track)
{
if (tmpFilePath == null)
{
throw new ArgumentNullException("tmpFilePath");
}
if (track == null)
{
throw new ArgumentNullException("track");
}
StringBuilder builder = new StringBuilder();
PropertyMetaData prop;
if (track.Args.HasArgument("inputpath"))
{
builder.AppendFormat("-i \"{0}\" ", track.Args.ArgumentValue("inputpath"));
}
else
{
prop = track["INPUTPATH"];
if (prop != null)
{
builder.AppendFormat("-i \"{0}\" ", prop);
}
}
prop = track["TitleChapter"];
if (prop != null)
{
builder.AppendFormat("{0} ", prop);
}
builder.AppendFormat("-o \"{0}\" ", tmpFilePath);
prop = track["HANDBRAKEOPTIONS"];
if (prop != null)
{
builder.Append(prop);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("HandBrake Options {0}", builder);
}
return builder.ToString();
}
/// <summary>
/// Ensures some music is playing for the current track.
/// Will resume playback from a manual user pause if the track has changed.
/// </summary>
private void ensurePlayingSelected()
{
ITrack track = music.CurrentTrack;
bool isNewTrack = !lastTrack.TryGetTarget(out var last) || last != track;
track.RestartPoint = Beatmap.Value.Metadata.PreviewTime;
if (!track.IsRunning && (music.UserPauseRequested != true || isNewTrack))
{
music.Play(true);
}
lastTrack.SetTarget(track);
}
public void AddClipIgnoresUnrequiredAssistant()
{
using (ITimeline timeline = new DefaultTimeline())
{
MockMediaFileAssistant assistant = new MockMediaFileAssistant(false);
timeline.InstallAssistant(assistant);
Assert.AreEqual(0, assistant.ExecutionCount);
ITrack track = timeline.AddAudioGroup().AddTrack();
track.AddAudio("1sec.wav");
Assert.AreEqual(0, assistant.ExecutionCount);
}
}
protected virtual void CrossFade(ITrack from, ITrack to)
{
var steps = TrackInterchangeCrossFadeSteps.Value;
var interval = TimeSpan.FromMilliseconds(TrackInterchangeCrossfadeTime.Value / steps);
var fromStepSize = from.Volume / steps;
var toStepSize = (1f - to.Volume) / steps;
for (var i = 0; i < steps; ++i)
{
from.Volume -= fromStepSize;
to.Volume += toStepSize;
Thread.CurrentThread.Join(interval);
}
from.Stop();
}
public static ILink <ITrack> CreateLink(this ITrack track)
{
IntPtr linkPtr, trackPtr;
trackPtr = Track.GetPointer(track);
lock (libspotify.Mutex)
linkPtr = libspotify.sp_link_create_from_track(trackPtr);
ILink <ITrack> link = (ILink <ITrack>)Link.Get((Session)track.Session, linkPtr);
lock (libspotify.Mutex)
libspotify.sp_link_release(linkPtr);
return(link);
}
/// <summary>
/// Creates a target track if it doesn't already exist as a value in the 'newTrackMap' dictionary. New
/// tracks are added to 'newTrackMap', with 'original' as the key.</summary>
/// <param name="original">The key in the 'newTrackMap' dictionary</param>
/// <param name="newTrackMap">Dictionary that maps original tracks to new tracks</param>
/// <returns>The new track, equal to newTrackMap[original]</returns>
private ITrack CreateTargetTrack(ITrack original, Dictionary <ITrack, ITrack> newTrackMap)
{
ITrack target;
if (!newTrackMap.TryGetValue(original, out target))
{
ITimeline timeline = m_owner.TimelineDocument.Timeline;
IGroup newGroup = m_owner.Create(original.Group);
timeline.Groups.Add(newGroup);
target = m_owner.Create(original);
newGroup.Tracks.Add(target);
newTrackMap.Add(original, target);
}
return(target);
}
private void OnTrackSeenChangedCallback(IntPtr playlistPtr, int position, bool seen, IntPtr userdataptr)
{
if (playlistPtr != _playlist.Handle)
{
return;
}
ITrack track = PlaylistTrackManager.Get(
_playlist.Session,
_playlist,
Spotify.sp_playlist_track(playlistPtr, position),
position);
_playlist.QueueThis(() => _playlist.OnTrackSeenChanged(new TrackSeenEventArgs(track, seen)));
}
public void AddClipUsesAssistant()
{
using (ITimeline timeline = new DefaultTimeline())
{
var assistant = new MockMediaFileAssistant(true);
timeline.InstallAssistant(assistant);
Assert.AreEqual(0, assistant.ExecutionCount);
ITrack track = timeline.AddAudioGroup().AddTrack();
track.AddAudio("..\\..\\1sec.wav");
Assert.AreEqual(1, assistant.ExecutionCount);
}
}
public void RemoveEvents()
{
int count = 0;
EventHandler increment = delegate { count++; };
EventHandler <AddedEffectEventArgs> incrementForAfterEffectAdded =
delegate { count++; };
EventHandler <AddedTransitionEventArgs> incrementForAfterTransitionAdded =
delegate { count++; };
EventHandler <AddedClipEventArgs> incrementForAfterClipAdded =
delegate { count++; };
using (ITimeline timeline = new DefaultTimeline())
{
ITrack track = timeline.AddAudioGroup().AddTrack();
track.AddedEffect += incrementForAfterEffectAdded;
track.AddedTransition += incrementForAfterTransitionAdded;
track.AddedClip += incrementForAfterClipAdded;
track.AddingEffect += increment;
track.AddingTransition += increment;
track.AddingClip += increment;
track.AddEffect(0, 2, StandardEffects.CreateDefaultBlur());
track.AddClip("..\\..\\testinput.mp3", GroupMediaType.Audio, InsertPosition.Absolute, 0, 0, 1);
track.AddTransition(0, 2, StandardTransitions.CreateFade());
Assert.AreEqual(6, count);
count = 0;
track.AddedEffect -= incrementForAfterEffectAdded;
track.AddedTransition -= incrementForAfterTransitionAdded;
track.AddedClip -= incrementForAfterClipAdded;
track.AddingEffect -= increment;
track.AddingTransition -= increment;
track.AddingClip -= increment;
track.AddEffect(0, 2, StandardEffects.CreateDefaultBlur());
track.AddClip("..\\..\\testinput.mp3", GroupMediaType.Audio, InsertPosition.Relative, 0, 0, 1);
track.AddTransition(2, 2, StandardTransitions.CreateFade());
Assert.AreEqual(0, count);
}
}
public void GetTrackById()
{
handler.Content = base.GetServerResponse("track");
ITrack track = session.Tracks.GetById(DUMMY_ID, CancellationToken.None)
.Result;
Assert.IsNotNull(track, nameof(track));
Assert.AreEqual(3135556, track.Id, nameof(track.Id));
Assert.AreEqual("Harder, Better, Faster, Stronger", track.Title, nameof(track.Title));
Assert.AreEqual("Harder, Better, Faster, Stronger", track.ShortTitle, nameof(track.ShortTitle));
Assert.AreEqual("GBDUW0000059", track.ISRC, nameof(track.ISRC));
Assert.AreEqual("https://www.deezer.com/track/3135556", track.Link, nameof(track.Link));
Assert.AreEqual("https://www.deezer.com/track/3135556?utm_source=deezer&utm_content=track-3135556&utm_term=0_1562079211&utm_medium=web", track.ShareLink, nameof(track.ShareLink));
Assert.AreEqual(224, track.Duration, nameof(track.Duration));
Assert.AreEqual(4, track.TrackNumber, nameof(track.TrackNumber));
Assert.AreEqual(1, track.DiscNumber, nameof(track.DiscNumber));
Assert.AreEqual(759175, track.Rank, nameof(track.Rank));
Assert.AreEqual(new DateTime(2001, 03, 07), track.ReleaseDate, nameof(track.ReleaseDate));
Assert.IsFalse(track.IsExplicit, nameof(track.IsExplicit));
Assert.AreEqual("https://cdns-preview-d.dzcdn.net/stream/c-deda7fa9316d9e9e880d2c6207e92260-5.mp3", track.PreviewLink, nameof(track.PreviewLink));
Assert.AreEqual(123.4f, track.BPM, nameof(track.BPM));
Assert.AreEqual(-12.4f, track.Gain, nameof(track.Gain));
Assert.IsNotNull(track.AvailableIn, nameof(track.AvailableIn));
var countries = track.AvailableIn.ToList();
Assert.AreEqual(209, countries.Count, "AvailableIn.Count");
Assert.IsNotNull(track.Contributors, nameof(track.Contributors));
var contributors = track.Contributors.ToList();
Assert.AreEqual(1, contributors.Count, "contributors.Count");
Assert.AreEqual(27, contributors[0].Id, "contributors[0].Id");
Assert.AreEqual("Daft Punk", contributors[0].Name, "contributors[0].Name");
Assert.IsNotNull(track.Artist, nameof(track.Artist));
Assert.AreEqual(27, track.Artist.Id, "Artist.Id");
Assert.AreEqual("Daft Punk", track.Artist.Name, "Artist.Name");
Assert.IsNotNull(track.Album, nameof(track.Album));
Assert.AreEqual(302127, track.Album.Id, "Album.Id");
Assert.AreEqual("Discovery", track.Album.Title, "Album.Title");
Assert.AreEqual("Discovery", track.AlbumName, nameof(track.AlbumName));
}
public void WatermarkVideoClip()
{
// this demonstrates one way of watermarking a video clip...
string outputFile = "WatermarkVideoClip.wmv";
using (ITimeline timeline = new DefaultTimeline(15))
{
// greate our default audio track
timeline.AddAudioGroup().AddTrack();
// add a video group, 32bpp, 320x240 (32bpp required to allow for an alpha channel)
IGroup videoGroup = timeline.AddVideoGroup(32, 320, 240);
// add our default video track
ITrack videoTrack = videoGroup.AddTrack();
// add another video track, this will be used to contain our watermark image
ITrack watermarkTrack = videoGroup.AddTrack();
// add the video in "transitions.wmv" to the first video track, and the audio in "transitions.wmv"
// to the first audio track.
timeline.AddVideoWithAudio("transitions.wmv");
// add the watermark image in, and apply it for the duration of the videoContent
// this image will be stretched to fit the video clip, and in this case is a transparent gif.
IClip watermarkClip = watermarkTrack.AddImage("testlogo.gif", 0, videoTrack.Duration);
// add a alpha setter effect to the image, this will adjust the alpha of the image to be 0.5
// of it's previous value - so the watermark is 50% transparent.
watermarkClip.AddEffect(0, watermarkClip.Duration, StandardEffects.CreateAlphaSetterRamp(0.8));
// add a transition to the watermark track, this allows the video clip to "shine through" the watermark,
// base on the values present in the alpha channel of the watermark track.
watermarkTrack.AddTransition(0, videoTrack.Duration,
StandardTransitions.CreateKey(KeyTransitionType.Alpha, null, null, null,
null,
null),
false);
using (
// render it to windows media
var renderer =
new WindowsMediaRenderer(timeline, outputFile, WindowsMediaProfiles.HighQualityVideo))
{
renderer.Render();
}
}
}
protected virtual void FadeIn(ITrack track)
{
if (null == track)
{
return;
}
var steps = TrackInterchangeCrossFadeSteps.Value;
var interval = TimeSpan.FromMilliseconds(TrackInterchangeCrossfadeTime.Value / steps);
var toStepSize = (1f - track.Volume) / steps;
for (var i = 0; i < steps; ++i)
{
track.Volume += toStepSize;
Thread.CurrentThread.Join(interval);
}
}
private void AddNewTrack(ITrack track, int index)
{
IntPtr[] ptrArray = new[] { track.GetHandle() };
IntPtr trackArrayPtr = Marshal.AllocHGlobal(Marshal.SizeOf(ptrArray[0]));
Marshal.Copy(ptrArray, 0, trackArrayPtr, 1);
AssertHandle();
lock (Spotify.Mutex)
{
Spotify.sp_playlist_add_tracks(Handle, trackArrayPtr, 1, index, Session.GetHandle());
}
Marshal.FreeHGlobal(trackArrayPtr);
}
public Error PlayerPrefetch(ITrack track)
{
AssertHandle();
INativeObject nativeObject = track as INativeObject;
if (nativeObject == null)
{
throw new ArgumentException("Invalid argument");
}
lock (Spotify.Mutex)
{
return(Spotify.sp_session_player_prefetch(Handle, nativeObject.GetHandle()));
}
}
private void PlayTrack(ITrack track)
{
if (currentTrack != null)
{
SpotifySession.PlayerUnload();
player.Stop();
PlaybackMonitor.Stop();
}
currentTrackPositionOffset = new TimeSpan(0);
var result = SpotifySession.PlayerLoad(track);
Play();
currentTrack = track;
SyncMainTableWithView();
PlaybackMonitor.Start();
}
public bool IsInValidAirSpace(ITrack track)
{
if (track.Altitude < _LowerBound ||
track.Altitude > _UpperBound ||
track.PositionX < _WestBound ||
track.PositionX > _EastBound ||
track.PositionY > _NorthBound ||
track.PositionY < _SouthBound)
{
return(false);
}
else
{
return(true);
}
}
public static void StoreResult(ITrack track, IVehicleModel vehicle, ISummary summary, string imageFilePath, string fileName)
{
var serializableSummary = new SerialzableSimulationResult
{
SimulationTime = summary.SimulationTime.TotalSeconds,
Result = summary.Result,
Log = summary.Log.Select(SerializableEventFactory.From),
Track = SerializableTrack.From(track.TileSize, track.Circuit, track.OccupancyGrid),
VehicleModel = vehicle,
TrackImageFilePath = imageFilePath
};
var json = JsonConvert.SerializeObject(serializableSummary, CustomJsonSerializationSettings.Default);
File.WriteAllText(fileName, json);
}
private void SetTrackText(ITrack track)
{
if (track == null)
{
throw new ArgumentNullException("track");
}
var displayText =
string.Format("{0} {1} {2}", track.ParentChannel.ChannelName, P.Resources.ColonSeparator,
track.TrackTitle);
MainNotifyIcon.Text = (displayText.Length > 63) ? displayText.Remove(63) : displayText;
if (ParentForm != null)
{
ParentForm.Text = displayText;
}
}
private void Tracks_ItemRemoved(ITrack track)
{
var musictrack =
track as MusicTrack;
NoteSelections.Remove(musictrack);
if (ActiveTrackIndex >= Tracks.Count)
{
ActiveTrackIndex = Tracks.Count - 1;
}
InvalidateTime(new Duration {
End = Tracks.MaxOrDefault(_ => _.Length.Value)
});
}
private static void PopulateTimeline(ApplicationOptions options, ITimeline timeline)
{
IGroup group = timeline.AddVideoGroup(32, options.Width, options.Height);
ITrack audioTrack = timeline.AddAudioGroup().AddTrack();
IClip audioClip = audioTrack.AddAudio(options.SoundtrackFile);
ITrack videoTrack = group.AddTrack();
double step = audioClip.Duration / options.SourceImage.Length;
for (int i = 0; i < options.SourceImage.Length; i++)
{
videoTrack.AddImage(options.SourceImage[i], 0, step);
}
}
public AudioPlaylistTests()
{
_musicLibrary = A.Fake <IMusicLibrary>();
_mediaPlayer = A.Fake <IMediaPlayer>();
A.CallTo(() => _mediaPlayer.LoadFile(A <string> .Ignored, A <MediaPlayerMetadata> .Ignored)).Invokes((o) => _mediaPlayer.Playing = true);
_audioPlaylist = new AudioPlaylist(_musicLibrary, _mediaPlayer);
_track = A.Fake <ITrack>();
A.CallTo(() => _track.Song).Returns(new Song {
FileName = TrackFileName
});
_audioPlaylist.Tracks.Add(_track);
}
public double GetAcceleration(Car car, Car next, ITrack track)
{
var distance = track.Distance(car, next);
if (distance < ComfortDistance)
{
_targetVelocity = next.Velocity / 2;
}
if (distance > ComfortDistance * 5)
{
_targetVelocity = _comfortVelocity;
}
var a = (_targetVelocity - car.Velocity);
if (a > MaxAceleration) a = MaxAceleration;
if (a < -MaxAceleration) a = -MaxAceleration;
return a;
}
/// <summary>
/// IComputerDriver
/// </summary>
public void GetNextGridPoint(ITrack track, ICar car, IList <Point> routeGridPoints, Point middleGridPoint,
out uint nrBacktracks, out Point gridPoint)
{
if (routeGridPoints.Count == 0)
{
GetNextGridPoint_Count0(track, out nrBacktracks, out gridPoint);
}
else if (routeGridPoints.Count == 1)
{
GetNextGridPoint_Count1(track, car, routeGridPoints, out nrBacktracks, out gridPoint);
}
else
{
GetNextGridPoint_CountGreater1(track, car, routeGridPoints, middleGridPoint, out nrBacktracks, out gridPoint);
}
}
public void Visit(ITrack track)
{
if (AlreadyVisited(track))
{
return;
}
MarkVisited(track);
ApplyRules(track, m_ConfigurationMapper.GetConfiguration(m_MetadataMapper.GetFile(track)));
track?.Disk.Accept(this);
track?.Album.Accept(this);
track?.AlbumArtist.Accept(this);
track?.Artist.Accept(this);
}
public static string QueryFormat(this ITrack track, bool shouldUseAuthor, bool shouldUseLyrics)
{
if (shouldUseAuthor && !shouldUseLyrics)
{
return($"{track.Authors.First()} - {track.Title}");
}
if (shouldUseLyrics && !shouldUseAuthor)
{
return($"{track.Title} lyrics");
}
if (shouldUseAuthor && shouldUseLyrics)
{
return($"{track.Authors.First()} - {track.Title} lyrics");
}
return(track.Title);
}
public void SetUp()
{
_uut = new Track
{
Tag = "AAA111",
Altitude = 1900,
Course = 180,
PositionX = 28756,
PositionY = 78562,
Timestamp = DateTime.Now,
Velocity = 218
};
_newDataTrack = Substitute.For <ITrack>();
_newDataTrack.Tag = _uut.Tag;
_trackCalculator = Substitute.For <TrackCalculator>();
}
private bool IsTrackVisible(ITrack track)
{
TimelineLayout layout = TimelineControl.GetLayout();
RectangleF trackBounds;
if (layout.TryGetBounds(new TimelinePath(track), out trackBounds))
{
RectangleF clientRectF = m_timelineControl.VisibleClientRectangle;
if (clientRectF.Top <= trackBounds.Bottom &&
clientRectF.Bottom >= trackBounds.Top)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Draws a track</summary>
/// <param name="track">Track</param>
/// <param name="bounds">Bounding rectangle, in screen space</param>
/// <param name="drawMode">Drawing mode</param>
/// <param name="c">Drawing context</param>
protected override void Draw(ITrack track, RectangleF bounds, DrawMode drawMode, Context c)
{
switch (drawMode & DrawMode.States)
{
case DrawMode.Normal:
c.Graphics.DrawRectangle(bounds, TrackBrush);
break;
case DrawMode.Collapsed:
break;
case DrawMode.Ghost:
c.Graphics.FillRectangle(bounds, GhostTrackBrush);
break;
}
}
protected void ToplistsMenu()
{
ConsoleEx.WriteLine("=== Toplist ===", ConsoleColor.Cyan);
IToplistBrowse toplistBrowse = Session
.Browse(ToplistType.Tracks)
.WaitForCompletion();
for (int i = 0; i < toplistBrowse.Tracks.Count; i++)
{
ITrack track = toplistBrowse.Tracks[i];
ConsoleEx.Write("{0:00} : {1,-20}", ConsoleColor.White, (i + 1), ConsoleEx.Truncate(track.Name, 20));
ConsoleEx.Write(" {0,-16}", ConsoleColor.Gray, ConsoleEx.Truncate(track.Album.Artist.Name, 15));
ConsoleEx.WriteLine(" {0,-16}", ConsoleColor.DarkGray, ConsoleEx.Truncate(track.Album.Name, 15));
}
}
protected void VerifyTracksMatch(ITrack expected, ITrack got)
{
Assert.Equal(expected.AlbumArtistNames, got.AlbumArtistNames);
Assert.Equal(expected.AlbumTitle, got.AlbumTitle);
Assert.Equal(expected.ArtistNames, got.ArtistNames);
Assert.Equal(expected.BeatsPerMinute, got.BeatsPerMinute);
Assert.Equal(expected.Comments, got.Comments);
Assert.Equal(expected.Genres, got.Genres);
Assert.Equal(expected.Grouping, got.Grouping);
//Assert.True(expected.MediaMonkey.Equals(got.MediaMonkey));
Assert.Equal(expected.MediaMonkey, got.MediaMonkey);
Assert.Equal(expected.Rating, got.Rating);
Assert.Equal(expected.Ratings, got.Ratings);
Assert.Equal(expected.Title, got.Title);
Assert.Equal(expected.TrackNumber, got.TrackNumber);
}
static void Main(string[] args)
{
List <IDriver> drivers = new List <IDriver>();
List <ITrack> tracks = new List <ITrack>();
try
{
for (int i = 15; i < 75; i += 7)
{
IDriver driver = new Driver("Ivan", i);
ITrack track = new RaceTrack(i * 1.23, i - 4, "tarmac", i % 2 == 0 ? true : false);
drivers.Add(driver);
tracks.Add(track);
}
IDriver bmwDriver = drivers.FirstOrDefault(d => d.Age > 25 && d.Age < 45);
IEnumerable <ITrack> openTracks = tracks.Where(t => t.IsOpenAllYear == true);
ITrack currentTrack = openTracks.FirstOrDefault(t => t.CornersCount > 25);
ICar bmw = new BMW(2005, "M5", 507, bmwDriver, currentTrack);
string resultReport = GetInfo(currentTrack, bmw);
string path = @"D:\RacetrackReport.txt";
if (!File.Exists(path))
{
using (StreamWriter sw = File.CreateText(path))
{
sw.WriteLine(resultReport);
}
}
else
{
using (StreamWriter sw = File.AppendText(path))
{
sw.WriteLine(resultReport);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void SetValues()
{
ITrack track = CurrentTrack;
// track title
toolTipLinks.SetToolTip(lnkTrackTitle, track.TrackTitle);
lnkTrackTitle.Text = track.TrackTitle;
// comment count
lnkPostComments.Text = string.Format("Read and Post Comments {0}{1} {2}{3}", "(", track.CommentCount,
"comments", ")");
// forum url
if (track.ForumUrl != null)
{
lnkPostComments.Links[0].LinkData = track.ForumUrl.AbsoluteUri;
toolTipLinks.SetToolTip(lnkPostComments, track.ForumUrl.AbsoluteUri);
}
// artist homepage link
if (track.ArtistUri != null)
{
lnkTrackTitle.Links[0].LinkData = track.ArtistUri.AbsoluteUri;
lnkTrackTitle.LinkBehavior = LinkBehavior.AlwaysUnderline;
lnkTrackTitle.LinkColor = Color.RoyalBlue;
toolTipLinks.SetToolTip(lnkTrackTitle, track.ArtistUri.AbsoluteUri);
}
// record label
if (track.RecordLabel != null)
{
lblRecordLabel.Text = track.RecordLabel;
}
// the url to the track (what is this?)
Uri trackUrl;
if (track.TrackUrl != null)
{
trackUrl = track.TrackUrl;
}
// time the track started
DateTime startTime = track.StartTime.AddMinutes(Settings.Default.TrackStartTimeOffset);
StartTimeLabel.Text = string.Format("{0} {1}", "Started at", startTime.ToShortTimeString());
}
public int IndexOf(ITrack track)
{
iTunesTrack typeTrack = track as iTunesTrack;
if (typeTrack == null)
{
return -1;
}
for (int i = 0; i < m_playlist.Tracks.Count; ++i)
{
if (m_playlist.Tracks[i + 1].TrackDatabaseID == typeTrack.InternalTrack.TrackDatabaseID)
{
return i;
}
}
return -1;
}
public String GetFileExt(ITrack track)
{
if (track == null)
{
throw new ArgumentNullException("track");
}
var value = track["hbfileext"];
if (value != null)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("HandBrake File Extension {0}", value);
}
return value;
}
value = track["fileext"];
if (value != null)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("HandBrake File Extension {0}", value);
}
return value;
}
value = track["filename"];
if (value != null)
{
FileInfo fi = new FileInfo(value);
if (log.IsDebugEnabled)
{
log.DebugFormat("HandBrake File Extension {0}", fi.Extension);
}
return fi.Extension;
}
if (log.IsDebugEnabled)
{
log.Debug("HandBrake File Extension .mp4");
}
return ".mp4";
}
public long[] SampleNumbers(ITrack track)
{
var segmentStartSamples =new List<long>() {1};
var sampleDurations = track.SampleDurations;
var syncSamples = track.SyncSamples;
long timescale = track.TrackMetaData.Timescale;
double time = 0;
for (uint i = 0; i < sampleDurations.Length; i++)
{
time += (double)sampleDurations[i] / timescale;
if (time >= _fragmentLength &&
(syncSamples == null || syncSamples.Contains(i+1)))
{
if (i > 0)
{
segmentStartSamples.Add(i+1);
}
time = 0;
}
}
return segmentStartSamples.ToArray();
}
/// <summary>
/// Gets an image for the album of the given track
/// </summary>
/// <param name="track">A track of the requested album</param>
/// <param name="artwork">The reference object to store the resulting artwork in</param>
/// <returns>The result status code for this service call</returns>
public ServiceResultStatus GetAlbumArtwork(ITrack track, out Image artwork)
{
artwork = null;
// We only do files
if (!(track is ITrack)) return ServiceResultStatus.NoResult;
// Get uri of file
var uri = track.Uri;
// We only process local files
if (!uri.IsFile) return ServiceResultStatus.NoResult;
// Get the tags
TagLib.File file = null;
try {
file = TagLib.File.Create(
uri.LocalPath.Replace("\\\\localhost\\", "")
);
}
catch (Exception) { }
// If we have no pictures, bail out
if (file == null || file.Tag.Pictures.Length == 0) return ServiceResultStatus.NoResult;
// Find the frontcover
var picture = file.Tag.Pictures.FirstOrDefault(p => p.Type == PictureType.FrontCover);
if (picture == null) picture = file.Tag.Pictures.First();
var bytes = picture.Data.ToArray();
try {
var stream = new MemoryStream(bytes);
artwork = new Bitmap(stream);
}
catch (Exception) { }
return artwork == null ? ServiceResultStatus.NoResult : ServiceResultStatus.Success;
}
protected override void Given()
{
mockInternalSession = MockRepository.GenerateMock<IInternalSession>();
var mockRegistry = MockRepository.GenerateStub<IRegistry>();
var mockBackingStore = MockRepository.GenerateStub<IBackingStore>();
var mockQueryFactory = MockRepository.GenerateStub<IQueryFactory>();
subject = new StashedSet<DummyPersistentObject>(
mockInternalSession,
mockRegistry,
mockBackingStore,
mockQueryFactory,
new[] {new StashedSet<DummyPersistentObject>(mockInternalSession, mockRegistry, mockBackingStore, mockQueryFactory)});
mockRegisteredGraph = MockRepository.GenerateStub<IRegisteredGraph<DummyPersistentObject>>();
mockRegistry.Stub(_ => _.GetRegistrationFor(Arg<Type>.Is.Anything)).Return(mockRegisteredGraph);
mockStoredGraph = MockRepository.GenerateStub<IStoredGraph>();
mockBackingStore.Stub(_ => _.Get((IQuery)null)).IgnoreArguments().Return(new[] {mockStoredGraph});
mockTrack = MockRepository.GenerateStub<ITrack>();
mockTrack.Stub(_ => _.UntypedGraph).Return(new DummyPersistentObject());
}
public void OnTrackChanged(ITrack previous, ITrack current)
{
if (previous != null)
{
_backdropDelayDownloadTimer.Stop();
// Only get a new backdrop if the current artist is different than the previous
ITrack previousTrack = previous;
if (previousTrack.Album != null && current.Album != null)
{
if (previousTrack.Album.Artist.Name != current.Album.Artist.Name)
{
// Start the timer. This is done to limit the amount of times we need to get a backdrop, if the user presses Next/Previous a alot
_backdropDelayDownloadTimer.Tag = current;
_backdropDelayDownloadTimer.Start();
}
}
}
else
{
GetBackdropForTrack(current);
}
}
//TODO: Implement user private User who
public TrackCreatedChangedEventArgs(ITrack track, DateTime when/*, User who*/)
: base(track)
{
this.when = when;
//this.who = who;
}
public bool Transition()
{
if (_ReadOnlyTracks.Count == 0)
return false;
if (_Index == _ReadOnlyTracks.Count - 1)
{
if (this.AutoReplay)
Init();
else
PrivateCurrentTrack = null;
return AutoReplay;
}
_Index++;
CurrentTrack = _ReadOnlyTracks[_Index];
return true;
}
public void Init()
{
if (_ReadOnlyTracks.Count == 0)
{
_Index = -1;
CurrentTrack = null;
return;
}
_Index = 0;
CurrentTrack = _ReadOnlyTracks[0];
}
public TrackCreatedChangedEventArgs(ITrack track, DateTime when)
{
Track = track;
When = when;
}
public PlayerQueueItem(bool isQueued, ITrack track)
{
IsQueued = isQueued;
Track = track;
}
public async Task<bool> RunAsync(ITrack track, string tmpFilePath)
{
if (track == null)
{
throw new ArgumentNullException("track");
}
if (tmpFilePath == null)
{
throw new ArgumentNullException("tmpFilePath");
}
String handbrakeclr = "HandBrakeCLI";
String value = track["HandBrakeCLI"];
if(!String.IsNullOrWhiteSpace(value))
{
handbrakeclr = value;
}
String args = GenerateArguments(tmpFilePath, track);
int rvalue = await Methods.ExecuteProgramAsync(handbrakeclr, args, false);
return rvalue == 0;
}
