public void ChangeBottom(object sender, SelectionChangedEventArgs args) { ListBoxItem li4 = ((sender as ListBox).SelectedItem as ListBoxItem); LengthConverter myLengthConverter = new LengthConverter(); Double db4 = (Double)myLengthConverter.ConvertFromString(li4.Content.ToString()); Canvas.SetBottom(text1, db4); String st1 = (String)myLengthConverter.ConvertToString(Canvas.GetBottom(text1)); canvasBottom.Text = "Canvas.Bottom = " + st1; }
public void ChangeRight(object sender, SelectionChangedEventArgs args) { ListBoxItem li2 = ((sender as ListBox).SelectedItem as ListBoxItem); LengthConverter myLengthConverter = new LengthConverter(); Double db2 = (Double)myLengthConverter.ConvertFromString(li2.Content.ToString()); Canvas.SetRight(text1, db2); String st1 = (String)myLengthConverter.ConvertToString(Canvas.GetRight(text1)); canvasRight.Text = "Canvas.Right = " + st1; }
public PrintLayout(string w, string h, string left, string top, string right, string bottom) { var converter = new LengthConverter(); var width = (double)converter.ConvertFromInvariantString(w); var height = (double)converter.ConvertFromInvariantString(h); var marginLeft = (double)converter.ConvertFromInvariantString(left); var marginTop = (double)converter.ConvertFromInvariantString(top); var marginRight = (double)converter.ConvertFromInvariantString(right); var marginBottom = (double)converter.ConvertFromInvariantString(bottom); this._Size = new Size(width, height); this._Margin = new Thickness(marginLeft, marginTop, marginRight, marginBottom); }
private static QuantizedTime FindNearestTime(IReadOnlyList <long> grid, long time, TimeSpanType distanceCalculationType, double quantizingLevel, TempoMap tempoMap) { var distanceToGridTime = -1L; var convertedDistanceToGridTime = TimeSpanUtilities.GetMaxTimeSpan(distanceCalculationType); var gridTime = -1L; for (int i = 0; i < grid.Count; i++) { var currentGridTime = grid[i]; var distance = Math.Abs(time - currentGridTime); var convertedDistance = LengthConverter.ConvertTo(distance, distanceCalculationType, Math.Min(time, currentGridTime), tempoMap); if (convertedDistance.CompareTo(convertedDistanceToGridTime) >= 0) { break; } distanceToGridTime = distance; convertedDistanceToGridTime = convertedDistance; gridTime = currentGridTime; } // var shift = convertedDistanceToGridTime.Multiply(quantizingLevel); var convertedTime = TimeConverter.ConvertTo(time, distanceCalculationType, tempoMap); var newTime = TimeConverter.ConvertFrom( gridTime > time ? convertedTime.Add(shift, TimeSpanMode.TimeLength) : convertedTime.Subtract(shift, TimeSpanMode.TimeLength), tempoMap); // return(new QuantizedTime(newTime, gridTime, shift, distanceToGridTime, convertedDistanceToGridTime)); }
/// <summary> /// Splits objects by the specified step so every object will be splitted at points /// equally distanced from each other starting from the object's start time. /// </summary> /// <remarks> /// Nulls, objects with zero length and objects with length smaller than <paramref name="step"/> /// will not be splitted and will be returned as clones of the input objects. /// </remarks> /// <param name="objects">Objects to split.</param> /// <param name="step">Step to split objects by.</param> /// <param name="tempoMap">Tempo map used to calculate times to split by.</param> /// <returns>Objects that are result of splitting <paramref name="objects"/> going in the same /// order as elements of <paramref name="objects"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="objects"/> is null. -or- /// <paramref name="step"/> is null. -or- <paramref name="tempoMap"/> is null.</exception> public IEnumerable <TObject> SplitByStep(IEnumerable <TObject> objects, ITimeSpan step, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(objects), objects); ThrowIfArgument.IsNull(nameof(step), step); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); foreach (var obj in objects) { if (obj == null) { yield return(default(TObject)); continue; } if (obj.Length == 0) { yield return(CloneObject(obj)); continue; } var startTime = obj.Time; var endTime = startTime + obj.Length; var time = startTime; var tail = CloneObject(obj); while (time < endTime && tail != null) { var convertedStep = LengthConverter.ConvertFrom(step, time, tempoMap); if (convertedStep == 0) { throw new InvalidOperationException("Step is too small."); } time += convertedStep; var parts = SplitObject(tail, time); yield return(parts.LeftPart); tail = parts.RightPart; } } }
public void WithExplicitUnitAndBindingNonUnitStringFormat(Type targetType, object expected) { var converter = new LengthConverter { Unit = LengthUnit.Centimetres, }; var providerMock = new ServiceProviderMock { BindingStringFormat = "{}{0:F2}" }; converter.ProvideValue(providerMock.Object); var length = Length.FromMillimetres(12); var actual = converter.Convert(length, targetType, null, null); Assert.AreEqual(expected, actual); }
public void SettingStringFormatFailsIfBadFormat(string badFormat) { var converter = new LengthConverter { Unit = LengthUnit.Centimetres }; Wpf.Is.DesignMode = true; var ex = Assert.Throws <FormatException>(() => converter.StringFormat = badFormat); var expected = $"Error parsing: '{badFormat}' for Gu.Units.LengthUnit"; Assert.AreEqual(expected, ex.Message); Wpf.Is.DesignMode = false; converter.StringFormat = badFormat; var convert = converter.Convert(Length.Zero, typeof(string), null, null); Assert.AreEqual(expected, convert); }
public static void TestConversion <TTimeSpan>(TTimeSpan timeSpan, ITimeSpan referenceTimeSpan, ITimeSpan time, TempoMap tempoMap) where TTimeSpan : ITimeSpan { time = time ?? new MidiTimeSpan(); var ticks = LengthConverter.ConvertFrom(timeSpan, time, tempoMap); AreEqual(timeSpan, LengthConverter.ConvertTo <TTimeSpan>(ticks, time, tempoMap), "Cyclic conversion failed."); AreEqual(timeSpan, LengthConverter.ConvertTo <TTimeSpan>(referenceTimeSpan, time, tempoMap), "ConvertTo failed."); Assert.AreEqual(LengthConverter.ConvertFrom(referenceTimeSpan, time, tempoMap), ticks, "ConvertFrom failed."); }
public void Convert() { double result = LengthConverter.Convert( LengthUnit.Feet, LengthUnit.Inch, 1); Assert.AreEqual(12, result); result = LengthConverter.Convert( LengthUnit.Inch, LengthUnit.Feet, 12); Assert.AreEqual(1, result); result = LengthConverter.Convert( LengthUnit.Mile, LengthUnit.Kilometer, 10); Assert.AreEqual(16.09344, result); result = LengthConverter.Convert( LengthUnit.Meter, LengthUnit.Feet, 10); Assert.AreEqual(32.808398950131235, result); }
protected override void OnModelCreating(ModelBuilder modelBuilder) { LengthConverter lengthConverter = new LengthConverter(); JsonConverter <ICollection <string> > stringArrayConverter = new JsonConverter <ICollection <string> >(); JsonConverter <ICollection <CreditRoleType> > creditRoleTypeConverter = new JsonConverter <ICollection <CreditRoleType> >(); JsonConverter <Budget> budgetConverter = new JsonConverter <Budget>(); JsonConverter <ICollection <OfficialSite> > officialSitesConverter = new JsonConverter <ICollection <OfficialSite> >(); modelBuilder.Entity <Person>().Property(e => e.Height).HasConversion(lengthConverter); modelBuilder.Entity <Movie>().Property(e => e.FilmingLocations).HasConversion(stringArrayConverter); modelBuilder.Entity <Movie>().Property(e => e.Budget).HasConversion(budgetConverter); modelBuilder.Entity <Movie>().Property(e => e.OfficialSites).HasConversion(officialSitesConverter); modelBuilder.Entity <Person>().Property(e => e.Roles).HasConversion(creditRoleTypeConverter); modelBuilder.Entity <PersisterHistory>().Property(e => e.IsSuccess).HasConversion <short>(); modelBuilder.Entity <Image>().Property(e => e.Content).HasColumnType("BYTEA"); modelBuilder.Entity <Production>() .HasDiscriminator(e => e.ProductionType) .HasValue <Production>(ProductionTypeEnum.Undefined) .HasValue <TVSeries>(ProductionTypeEnum.TVSeries) .HasValue <Movie>(ProductionTypeEnum.Movie); modelBuilder.Entity <Credit>() .HasDiscriminator(e => e.RoleType) .HasValue <Credit>(CreditRoleType.Undefined) .HasValue <ActingCredit>(CreditRoleType.Actor) .HasValue <ActingCredit>(CreditRoleType.Actress) .HasValue <Credit>(CreditRoleType.Composer) .HasValue <Credit>(CreditRoleType.Creator) .HasValue <Credit>(CreditRoleType.Director) .HasValue <Credit>(CreditRoleType.MusicDepartment) .HasValue <Credit>(CreditRoleType.Producer) .HasValue <Credit>(CreditRoleType.Writer) .HasValue <ActingCredit>(CreditRoleType.Acting); modelBuilder.Entity <Character>() .HasDiscriminator(e => e.CharacterType) .HasValue <Character>(CharacterTypeEnum.Character) .HasValue <TVCharacter>(CharacterTypeEnum.TVCharacter); base.OnModelCreating(modelBuilder); }
public static void WithSymbolSettings(string value, UnitInput unitInput, bool expectSuccess, string expected) { var converter = new LengthConverter { Unit = LengthUnit.Centimetres, UnitInput = unitInput, }; var actual = converter.ConvertBack(value, typeof(Length), null, CultureInfo.InvariantCulture); if (expectSuccess) { var expectedValue = Length.Parse(expected, CultureInfo.InvariantCulture); Assert.AreEqual(expectedValue, actual); } else { Assert.AreEqual(expected, actual); } }
private MidiFile To(MusicItem data) { var midiFile = new MidiFile(); var tempoMap = midiFile.GetTempoMap(); var trackChunk = new TrackChunk(); using (var notesManager = trackChunk.ManageNotes()) { var length = LengthConverter.ConvertFrom( 2 * MusicalTimeSpan.Eighth.Triplet(), 0, tempoMap); var note = new Melanchall.DryWetMidi.Interaction.Note(NoteName.A, 4, length); notesManager.Notes.Add(note); } midiFile.Chunks.Add(trackChunk); return(midiFile); }
/// <summary>Convert the numbers to the new unit.</summary> /// <param name="numbers">The numbers used in the conversion.</param> /// <returns>The result of the conversion execution.</returns> /// <exception cref="ArgumentNullException">When numbers is null.</exception> /// <exception cref="ArgumentException">When the length of numbers do not equal <see cref="ArgumentCount"/>.</exception> public PreciseNumber Evaluate(PreciseNumber[] operands) { ((IExpression)this).Validate(operands); PreciseNumber fromValue = operands[0]; if (!fromValue.HasValue) { return(fromValue); } return(_current.UnitType switch { UnitType.Length => new PreciseNumber(LengthConverter.Convert((LengthUnit)_current.FromUnit, (LengthUnit)_current.ToUnit, fromValue.Value)), UnitType.Mass => new PreciseNumber(MassConverter.Convert((MassUnit)_current.FromUnit, (MassUnit)_current.ToUnit, fromValue.Value)), UnitType.Speed => new PreciseNumber(SpeedConverter.Convert((SpeedUnit)_current.FromUnit, (SpeedUnit)_current.ToUnit, fromValue.Value)), UnitType.Temperature => new PreciseNumber(TemperatureConverter.Convert((TemperatureUnit)_current.FromUnit, (TemperatureUnit)_current.ToUnit, fromValue.Value)), UnitType.Time => new PreciseNumber(TimeConverter.Convert((TimeUnit)_current.FromUnit, (TimeUnit)_current.ToUnit, fromValue.Value)), UnitType.Volume => new PreciseNumber(VolumeConverter.Convert((VolumeUnit)_current.FromUnit, (VolumeUnit)_current.ToUnit, fromValue.Value)), _ => throw new ArgumentOutOfRangeException(nameof(operands)), });
private void SplitByGrid_MultipleSteps(IEnumerable <TObject> inputObjects, ITimeSpan gridStart, IEnumerable <ITimeSpan> gridSteps, Dictionary <TObject, IEnumerable <TimeAndLength> > expectedParts, TempoMap tempoMap) { var expectedObjects = expectedParts .SelectMany(p => p.Value.Select(tl => CloneAndChangeTimeAndLength( p.Key, TimeConverter.ConvertFrom(tl.Time, tempoMap), LengthConverter.ConvertFrom(tl.Length, tl.Time, tempoMap)))) .ToArray(); var actualObjects = Splitter.SplitByGrid(inputObjects, new SteppedGrid(gridStart, gridSteps), tempoMap).ToArray(); MidiAsserts.AreEqual( expectedObjects.OfType <ITimedObject>(), actualObjects.OfType <ITimedObject>(), true, 0, "Objects are invalid."); }
/// <summary> /// Gets points in time of the current grid. /// </summary> /// <param name="tempoMap">Tempo map used to get grid's times.</param> /// <returns>Collection of points in time of the current grid.</returns> /// <exception cref="ArgumentNullException"><paramref name="tempoMap"/> is null.</exception> public IEnumerable <long> GetTimes(TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); if (!Steps.Any()) { yield break; } var time = TimeConverter.ConvertFrom(Start, tempoMap); yield return(time); while (true) { foreach (var step in Steps) { time += LengthConverter.ConvertFrom(step, time, tempoMap); yield return(time); } } }
public override PatternActionResult Invoke(long time, PatternContext context) { if (State == PatternActionState.Excluded) { return(PatternActionResult.DoNothing); } context.SaveTime(time); var chordLength = LengthConverter.ConvertFrom(ChordDescriptor.Length, time, context.TempoMap); if (State == PatternActionState.Disabled) { return(new PatternActionResult(time + chordLength)); } return(new PatternActionResult(time + chordLength, ChordDescriptor.Notes.Select(d => new Note(d.NoteNumber, chordLength, time) { Channel = context.Channel, Velocity = ChordDescriptor.Velocity }))); }
public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice) { var length = LengthConverter.Convert(feature.Value); if (length != null) { var desired = length.AsPx(renderDevice, RenderMode.Vertical); var available = (Double)renderDevice.ViewPortHeight; if (feature.IsMaximum) { return(available <= desired); } else if (feature.IsMinimum) { return(available >= desired); } return(desired == available); } return(false); }
static RaceCar() { Vector2[] baseBorderPointsInMeters = new Vector2[BORDER_POINTS_BASE.Length]; for (int i = 0; i < BORDER_POINTS_BASE.Length; i++) { var point = BORDER_POINTS_BASE[i]; var pointPrime = new Vector2( LengthConverter.InchToMeter(point.X), LengthConverter.InchToMeter(point.Y)); baseBorderPointsInMeters[i] = pointPrime; } CAR_SHAPE = new ConvexPolygon(baseBorderPointsInMeters); var centerOfMassShift = CAR_SHAPE.CenterOfMassShift; CENTER_OF_MASS_SHIFT_IN_INCHES = new Vector2( LengthConverter.MeterToInch(centerOfMassShift.X), LengthConverter.MeterToInch(centerOfMassShift.Y)); }
public void SettingStringFormatWithUnitWhenUnitIsSet(bool designMode) { var converter = new LengthConverter { Unit = LengthUnit.Centimetres }; var expected = "Unit is set to 'cm' but StringFormat is 'F1 mm'"; if (designMode) { Wpf.Is.DesignMode = true; var ex = Assert.Throws <InvalidOperationException>(() => converter.StringFormat = "F1 mm"); Assert.AreEqual(expected, ex.Message); } else { Wpf.Is.DesignMode = false; converter.StringFormat = "F1 mm"; var actual = converter.Convert(Length.FromMetres(1.2), typeof(string), null, CultureInfo.InvariantCulture); Assert.AreEqual(expected, actual); } }
public Boolean Validate(IMediaFeature feature, IRenderDevice device) { var length = LengthConverter.Convert(feature.Value); if (length != null) { var desired = length.AsPixel(); var available = (Double)device.DeviceWidth; if (feature.IsMaximum) { return(available <= desired); } else if (feature.IsMinimum) { return(available >= desired); } return(desired == available); } return(false); }
public static MidiFile TestNotes(Pattern pattern, ICollection <NoteInfo> expectedNotesInfos, params Tuple <long, Tempo>[] tempoChanges) { TempoMap tempoMap; using (var tempoMapManager = new TempoMapManager()) { foreach (var tempoChange in tempoChanges) { tempoMapManager.SetTempo(tempoChange.Item1, tempoChange.Item2); } tempoMap = tempoMapManager.TempoMap; } var midiFile = pattern.ToFile(tempoMap, Channel); var expectedNotes = expectedNotesInfos.Select(i => { var expectedTime = TimeConverter.ConvertFrom(i.Time ?? new MetricTimeSpan(), tempoMap); var expectedLength = LengthConverter.ConvertFrom(i.Length, expectedTime, tempoMap); return(new DryWetMidi.Interaction.Note(i.NoteNumber, expectedLength, expectedTime) { Velocity = i.Velocity, Channel = Channel }); }) .OrderBy(n => n.Time) .ToArray(); var actualNotes = midiFile.GetNotes().ToArray(); MidiAsserts.AreEqual(expectedNotes, actualNotes, "Notes are invalid."); return(midiFile); }
public override PatternActionResult Invoke(long time, PatternContext context) { if (State == PatternActionState.Excluded) { return(PatternActionResult.DoNothing); } context.SaveTime(time); var noteLength = LengthConverter.ConvertFrom(NoteDescriptor.Length, time, context.TempoMap); if (State == PatternActionState.Disabled) { return(new PatternActionResult(time + noteLength)); } var note = new Note(NoteDescriptor.Note.NoteNumber, noteLength, time) { Channel = context.Channel, Velocity = NoteDescriptor.Velocity }; return(new PatternActionResult(time + noteLength, new[] { note })); }
public void ConvertCsvToMidiFile_NoteLength_Metric(NoteNumberFormat noteNumberFormat, string[] csvLines) { var midiFile = ConvertCsvToMidiFile(MidiFileCsvLayout.DryWetMidi, TimeSpanType.Midi, csvLines, NoteFormat.Note, noteNumberFormat, TimeSpanType.Metric); var tempoMap = TempoMap.Default; var expectedObjects = new ITimedObject[] { new Note((SevenBitNumber)50, LengthConverter.ConvertFrom(new MetricTimeSpan(0, 0, 10), 0, tempoMap), 0) { Channel = (FourBitNumber)10, Velocity = (SevenBitNumber)120, OffVelocity = (SevenBitNumber)70 }, new TimedEvent(new TextEvent("Te\"s\"\"t"), 0), new Note((SevenBitNumber)70, LengthConverter.ConvertFrom(new MetricTimeSpan(0, 0, 0, 500), 100, tempoMap), 100) { Channel = (FourBitNumber)7, Velocity = (SevenBitNumber)110, OffVelocity = (SevenBitNumber)80 } }; Assert.AreEqual(1, midiFile.GetTrackChunks().Count(), "Track chunks count is invalid."); MidiAsserts.AreEqual( expectedObjects, midiFile.GetObjects(ObjectType.TimedEvent | ObjectType.Note), false, 0, "Invalid objects."); }
static string TrackToString(List <Chord> track, TempoMap tempoMap) { string representation = "\t{.music_chords = (struct MusicChord[]) {\n"; int num_chords = track.Count; MetricTimeSpan lastChordEndTime = new MetricTimeSpan(0); foreach (Chord chord in track) { MetricTimeSpan chordStartTime = TimeConverter.ConvertTo <MetricTimeSpan>(chord.Time, tempoMap); MetricTimeSpan chordDuration = LengthConverter.ConvertTo <MetricTimeSpan>(chord.Length, chord.Time, tempoMap); MetricTimeSpan chordEndTime = chordStartTime + chordDuration; //pad the track if necessary with rests if (lastChordEndTime < chordStartTime) { representation += RestToString(chordStartTime - lastChordEndTime) + ",\n"; num_chords++; } //add the chord's string representation representation += ChordToString(chord, tempoMap); if (track[track.Count - 1] != chord) { representation += ",\n"; } //record the end time for the next chord lastChordEndTime = chordEndTime; } representation += "\n\t}, .playback_type = PLAYBACK_MONO, .length = " + num_chords + "}"; return(representation); }
/// <summary> /// Create new hotspots on the map /// </summary> /// <param name="newPoint"></param> public void CreateNewPoints(Point newPoint) { if (currLocationExists && currentMarker == "current") { canAdd = false; } else if (originExists && currentMarker == "origin") { canAdd = false; } else { canAdd = true; } if (buttonChecked != null) { if (canAdd) { if (RadioColor != 0) { //get the point clicked and calculate the longitute and latitude LengthConverter myLengthConverter = new LengthConverter(); Double db1 = newPoint.X - 27; Double db2 = newPoint.Y - 87; //These operations are used to calculate the exact longitude and latitude before saving into the xml file. this.findImageSize(); Double mapcurWidth = mapWidth * map1.GetZoomableCanvas.Scale; Double mapcurHeight = mapHeight * map1.GetZoomableCanvas.Scale; Point newP = map1.GetZoomableCanvas.Offset; Double canvasLeft = (db1 + newP.X) / mapcurWidth; Double canvasTop = (db2 + newP.Y) / mapcurHeight; String lon = canvasLeft.ToString(); String lat = canvasTop.ToString(); Ellipse newEllipse = new Ellipse(); ellipses.Add(newEllipse); SurfaceRadioButton newMarker = new SurfaceRadioButton(); SolidColorBrush mySolidColorBrush = new SolidColorBrush(); if (currentMarker == "current")//yellow { mySolidColorBrush.Color = Color.FromArgb(255, 255, 255, 0); currentX.Add(lon); dic.Add(newMarker, "yellow" + "," + lon + "," + lat); currLocationExists = true; } else if (currentMarker == "exhibit")//blue { mySolidColorBrush.Color = Color.FromArgb(255, 0, 0, 255); dic.Add(newMarker, "blue" + "," + lon + "," + lat); } else if (currentMarker == "origin")//red { mySolidColorBrush.Color = Color.FromArgb(255, 255, 0, 0); originX.Add(lon); dic.Add(newMarker, "red" + "," + lon + "," + lat); originExists = true; canAdd = true; currentMarker = null; } mapCover.Children.Add(newEllipse); mapCover.Children.Add(newMarker); newEllipse.Width = 13.5; newEllipse.Height = 13.5; newEllipse.Fill = mySolidColorBrush; foreach (SurfaceRadioButton rb in radioButtons) { rb.IsChecked = false; } newMarker.IsChecked = true; radioButtons.Add(newMarker); dicRb.Add(newMarker, newEllipse); Double screenPosX = canvasLeft - map1.GetZoomableCanvas.Offset.X; //need to reset the location thing Double screenPosY = (map1.GetZoomableCanvas.Scale / (1 / 15) * db2) - map1.GetZoomableCanvas.Offset.Y; Canvas.SetLeft(newEllipse, db1 - 20.8); Canvas.SetTop(newEllipse, db2 - 5); Canvas.SetLeft(newMarker, db1 - 22.8); Canvas.SetTop(newMarker, db2 - 13); buttonChecked.IsChecked = false; //only enable to create one circle at a time RadioColor = 0; currentMarker = null; } } else { System.Windows.MessageBox.Show("There may only be one location of origin and one current location."); if (buttonChecked != null) { buttonChecked.IsChecked = false; buttonChecked = null; } buttonChecked = null; currentMarker = null; return; } } }
private void CheckPlayback( ICollection <EventToSend> eventsToSend, double speed, PlaybackAction beforePlaybackStarted, PlaybackAction startPlayback, PlaybackAction afterPlaybackStarted, PlaybackAction waiting, PlaybackAction finalChecks, CreateTickGeneratorCallback createTickGeneratorCallback = null) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = new List <MidiEvent>(); var expectedTimes = playbackContext.ExpectedTimes; var currentTime = TimeSpan.Zero; foreach (var eventToSend in eventsToSend.Where(e => !(e.Event is MetaEvent))) { var midiEvent = eventToSend.Event.Clone(); midiEvent.DeltaTime = LengthConverter.ConvertFrom((MetricTimeSpan)eventToSend.Delay, (MetricTimeSpan)currentTime, tempoMap); currentTime += eventToSend.Delay; eventsForPlayback.Add(midiEvent); expectedTimes.Add(TimeSpan.FromTicks(MathUtilities.RoundToLong(currentTime.Ticks / speed))); } using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); var clockSettings = createTickGeneratorCallback != null ? new MidiClockSettings { CreateTickGeneratorCallback = createTickGeneratorCallback } : null; using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice, clockSettings)) { playback.Speed = speed; beforePlaybackStarted(playbackContext, playback); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); startPlayback(playbackContext, playback); afterPlaybackStarted(playbackContext, playback); waiting(playbackContext, playback); stopwatch.Stop(); finalChecks(playbackContext, playback); } } } CompareSentReceivedEvents(sentEvents.Take(expectedTimes.Count).ToList(), receivedEvents.Take(expectedTimes.Count).ToList(), expectedTimes); }
private void PopupAdjust(object sender, EventArgs e) { //<SnippetIsOpen> myPopupIsOpen.IsOpen = true; //</SnippetIsOpen> //<SnippetPopupPosition> Popup myPopup = new Popup(); myPopup.PlacementTarget = myEllipse; myPopup.PlacementRectangle = new Rect(0, 0, 30, 50); myPopup.VerticalOffset = 20; myPopup.HorizontalOffset = 20; myPopup.Placement = PlacementMode.Bottom; myPopup.PopupAnimation = PopupAnimation.Fade; myPopup.AllowsTransparency = true; TextBlock popupText = new TextBlock(); popupText.Background = Brushes.Beige; popupText.FontSize = 12; popupText.Width = 75; popupText.TextWrapping = TextWrapping.Wrap; myPopup.Child = popupText; //</SnippetPopupPosition> //<SnippetChild> Popup myPopupWithText = new Popup(); TextBlock textBlock = new TextBlock(); textBlock.Text = "Popup Text"; textBlock.Background = Brushes.Yellow; myPopupWithText.Child = textBlock; myStackPanel.Children.Add(myPopup); //</SnippetChild> LengthConverter myPopupLengthConverter = new LengthConverter(); //<SnippetAllowsTransparency> myPopup.AllowsTransparency = true; //</SnippetAllowsTransparency> //<SnippetHorizontalVerticalOffset> myPopup.HorizontalOffset = (Double)myPopupLengthConverter.ConvertFromString(".5cm"); myPopup.VerticalOffset = (Double)myPopupLengthConverter.ConvertFromString(".1cm"); //</SnippetHorizontalVerticalOffset> //<SnippetHasDropShadow> bool hasDropShadow = myPopup.HasDropShadow; //</SnippetHasDropShadow> TextBlock myTextBlock = new TextBlock(); myTextBlock.Text = "Special TextBlock"; myTextBlock.Background = Brushes.Orange; myTextBlock.Height = 20; Popup myTextBlockPopup = new Popup(); TextBlock popupDescription = new TextBlock(); popupDescription.Background = Brushes.Coral; popupDescription.Text = "Special Popup Text"; //<SnippetPlacement> myTextBlockPopup.PlacementTarget = myTextBlock; myTextBlockPopup.PlacementRectangle = new Rect(0, 0, 30, 40); myTextBlockPopup.Placement = PlacementMode.Center; myTextBlockPopup.Child = popupDescription; myTextBlockPopup.IsOpen = true; //</SnippetPlacement> //<SnippetAnimation> myTextBlockPopup.PopupAnimation = PopupAnimation.Fade; //</SnippetAnimation> //<SnippetStaysOpen> myTextBlockPopup.StaysOpen = true; //</SnippetStaysOpen> myStackPanel.Children.Add(myTextBlock); }
public void TestKilometrov0() { LengthConverter izmerenie = new LengthConverter(); Assert.Equal(0, izmerenie.TransferKilometrov(0)); }
public TObject Create(ITimeSpan time, ITimeSpan length, TempoMap tempoMap) { var convertedTime = TimeConverter.ConvertFrom(time, tempoMap); return(Create(convertedTime, LengthConverter.ConvertFrom(length, convertedTime, tempoMap))); }
public void SetLength(TObject obj, ITimeSpan length, ITimeSpan time, TempoMap tempoMap) { var convertedTime = TimeConverter.ConvertFrom(time, tempoMap); SetLength(obj, LengthConverter.ConvertFrom(length, convertedTime, tempoMap)); }
private void createUI() { DataTemplate dt = new DataTemplate(); // FrameworkElementFactory expander = new FrameworkElementFactory(typeof(Expander)); FrameworkElementFactory stackPanel = new FrameworkElementFactory(typeof(StackPanel)); stackPanel.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal); FrameworkElementFactory label = new FrameworkElementFactory(typeof(Label)); label.SetValue(Label.ContentProperty, string.Format("{0} [{1}]", this.data.TagName, this.data.Childrens.Count)); if (this.data.Childrens.Count > 0) { FrameworkElementFactory button = new FrameworkElementFactory(typeof(Button)); button.SetValue(Button.ContentProperty, "+"); button.SetValue(Button.BackgroundProperty, Brushes.Transparent); button.SetValue(Button.BorderBrushProperty, Brushes.White); button.SetValue(Button.IsTabStopProperty, false); LengthConverter lc = new LengthConverter(); string qualifiedDouble = "24px"; var converted = lc.ConvertFrom(qualifiedDouble); button.SetValue(Button.WidthProperty, converted); button.SetValue(Button.HeightProperty, converted); button.SetValue(Button.BorderThicknessProperty, new Thickness(0)); button.AddHandler(Button.ClickEvent, new RoutedEventHandler(ExpanderClick)); button.AddHandler(Button.LoadedEvent, new RoutedEventHandler(LoaderBtn)); //Create a style Style st = new Style(); Trigger tg = new Trigger() { Property = Button.IsMouseOverProperty, Value = true // <Trigger Property="IsMouseOver" Value="true"> // <!--<Setter Property="Fill" TargetName="checkBoxFill" Value="{StaticResource OptionMark.MouseOver.Background}"/>--> // <Setter Property="Fill" TargetName="optionMark" Value="{StaticResource OptionMark.MouseOver.Glyph}"/> // <Setter Property="Fill" TargetName="indeterminateMark" Value="{StaticResource OptionMark.MouseOver.Glyph}"/> // </Trigger> //Binding = new Binding("CustomerId"), //Value = 1 }; tg.Setters.Add(new Setter() { Property = Button.BackgroundProperty, Value = Brushes.Red }); st.Triggers.Add(tg); //end style button.SetValue(Button.StyleProperty, st); // expander.SetValue(Expander.HeaderProperty, this.data.TagName); stackPanel.AppendChild(button); } stackPanel.AppendChild(label); this.HeaderTemplate = dt; dt.VisualTree = stackPanel; }
public RadialGradientConverter(Boolean repeating) : base(repeating) { var position = PointConverter.StartsWithKeyword(Keywords.At).Option(Point.Center); var circle = WithOrder(WithAny(Assign(Keywords.Circle, true).Option(true), LengthConverter.Option()), position); var ellipse = WithOrder(WithAny(Assign(Keywords.Ellipse, false).Option(false), LengthOrPercentConverter.Many(2, 2).Option()), position); var extents = WithOrder(WithAny(Toggle(Keywords.Circle, Keywords.Ellipse).Option(false), Map.RadialGradientSizeModes.ToConverter()), position); _converter = circle.Or(ellipse.Or(extents)); }
public void Setup() { _timeSpanTimes = _midiTimes.Select(time => TimeConverter.ConvertTo <TTimeSpan>(time, TempoMap)).ToList(); _timeSpanLengths = _midiTimes.Select(time => Tuple.Create(LengthConverter.ConvertTo <TTimeSpan>(Length, time, TempoMap), time)).ToList(); }
/// <summary> /// Mouse Enter event Handler that handles the visibility of the indicator /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Slider_MouseEnter(object sender, MouseEventArgs e) { Slider s = sender as Slider; Point p=e.GetPosition(s); object cItem = this.FindName("SliderCanvas"); Canvas canvas = cItem as Canvas; Point globalP = e.GetPosition(canvas); double myTime = (p.X / s.ActualWidth) * ((AudioPlayerModel)this.DataContext).Length; object item = this.FindName("position_indicator"); if ((item != null) && (item is PositionIndicator)) { PositionIndicator indicator = item as PositionIndicator; indicator.Visibility = Visibility.Visible; indicator.SetValue(Canvas.LeftProperty,p.X-16); object item_label = indicator.FindName("TimePositionLabel"); if ((item_label != null) && (item_label is TextBlock)) { TextBlock label = item_label as TextBlock; LengthConverter converter = new LengthConverter(); label.Text = (string)converter.Convert(myTime, typeof(string), null, null); //Console.WriteLine(myTime); } //indicator.Margin = new Thickness(globalP.X, 0, 0, 0); } }
private void PageInitialize() { if (printorientation == PrintingOrientation.Portrait) { FlowDocument doc = docs.Document; doc.PageHeight = PrintLayout.A4.Size.Height; doc.PageWidth = PrintLayout.A4.Size.Width; //doc.PagePadding = PrintLayout.A4.Margin; doc.ColumnGap = 0.0d; doc.ColumnWidth = PrintLayout.A4.ColumnWidth; } else { LengthConverter converter = new LengthConverter(); FlowDocument doc = docs.Document; doc.PageHeight = PrintLayout.A4Landscape.Size.Height; //doc.PageWidth = PrintLayout.A4Landscape.Size.Width; doc.PageWidth = (double)converter.ConvertFromInvariantString(docs.Width.ToString()); //doc.PagePadding = PrintLayout.A4.Margin; doc.ColumnGap = 0.0d; doc.ColumnWidth = PrintLayout.A4Landscape.ColumnWidth; } }
public void TestMil() { LengthConverter izmerenie = new LengthConverter(); Assert.Equal(1.609, izmerenie.TransferMil(1)); }