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