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; }