public void Draw(Graphics zGraphics, Deck zDeck, ProjectLayoutElement zElement, string sInput)
{
#if true
// check the cache for this item
var zDataFormattedCache = zDeck.GetCachedMarkup(zElement.name);
// cached, render and exit
if (null != zDataFormattedCache)
{
zDataFormattedCache.Render(zElement, zGraphics);
return;
}
#endif
zDataFormattedCache = new FormattedTextDataCache();
var zFormattedTextData = new FormattedTextData(FormattedTextParser.GetMarkups(sInput));
List <MarkupBase> listRenderedMarkups = null;
if (zElement.autoscalefont)
{
listRenderedMarkups = processAutoScale(zGraphics, zElement, zFormattedTextData);
}
else
{
listRenderedMarkups = processMarkupDefinition(zGraphics, zElement, zElement.GetElementFont().Size, zFormattedTextData);
}
// update the cache
listRenderedMarkups.ForEach((zMarkup) => zDataFormattedCache.AddMarkup(zMarkup));
zDeck.AddCachedMarkup(zElement.name, zDataFormattedCache);
// render!
zDataFormattedCache.Render(zElement, zGraphics);
}
public void ParseEmpty()
{
var format = "";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.AreEqual(0, segments.Count);
}
public void Parse_EmptyTextFormat_CreatesNoSegments()
{
var format = "";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Empty(segments);
}
public void get_color_from_string()
{
var color = FormattedTextParser.ParseStringAsColor("a1b2c3");
color.R.Should().Be(0xa1);
color.G.Should().Be(0xb2);
color.B.Should().Be(0xc3);
}
public void ParseStyleUnderline()
{
var format = "{_artist}";
var segments = FormattedTextParser
.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.AreEqual(1, segments.Count);
Assert.IsTrue(segments[0].Flags.HasFlag(FormattedTextFlags.Underline));
}
public void ParseOnlyClosing()
{
var format = "}";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.AreEqual(1, segments.Count);
Assert.AreEqual("}", segments[0].Text);
Assert.IsTrue(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void Parse_FormatOnlyClosingBrace_CreatesNormalSegment()
{
var format = "}";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.Equal("}", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void Parse_FormatContainsPlaceholderWithUnclosedBrace_CreatesNormalSegment()
{
var format = "{artist";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.Equal("{artist", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void Parse_StyleUnderline_SegmentContainsUnderlineFlag()
{
var format = "{_artist}";
var segments = FormattedTextParser
.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Underline));
}
public void Parse_StyleBold_SegmentContainsBoldFlag()
{
var format = "{*artist}";
var mock = new Mock <IAudioSession>();
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.Single(segments);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Bold));
}
public void Parse_NormalTextFormat()
{
var format = "hello";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.Equal("hello", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void Parse_StyleWithColor_SegmentContainsColorAndStyle()
{
var format = "{_artist:#ff00ff}";
var segments = FormattedTextParser
.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Underline));
Assert.Equal(Color.FromRgb(255, 0, 255), segments[0].Color);
}
public void set_font_command()
{
var commands = FormattedTextParser.ParseCommands("get [#font:GiantFont]huge");
commands.Should().ContainInOrder(
FormattedTextCommand.PlainText.WithArguments("get "),
FormattedTextCommand.Font.WithArguments("GiantFont"),
FormattedTextCommand.PlainText.WithArguments("huge")
);
}
public void ValidateMarkupTranslation(string input, Type[] expectedTypes)
{
var markups = FormattedTextParser.GetMarkups(input);
Assert.AreEqual(expectedTypes.Length, markups.Count);
for (var i = 0; i < expectedTypes.Length; i++)
{
Assert.AreEqual(expectedTypes[i], markups[i].GetType());
}
}
public void Parse_InvalidPlaceholder_CreatesSegmentWithInvalidValue()
{
var format = "{something}";
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, new Mock <IAudioSession>().Object).ToList();
Assert.Single(segments);
Assert.Equal("!Invalid format!", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomLabelViewModel"/> class.
/// </summary>
/// <param name="source">The custom label.</param>
/// <param name="dialogService">The dialog service.</param>
/// <param name="audioSession">The audio session.</param>
/// <param name="messageBus">The message bus.</param>
public CustomLabelViewModel(CustomLabel source, IDialogService dialogService, IAudioSession audioSession, IMessageBus messageBus)
: base(messageBus, source)
{
_audioSession = audioSession;
_audioSession.PropertyChanged += AudioSessionOnPropertyChanged;
DialogService = dialogService;
TextSegments = FormattedTextParser.ParseFormattedString(FormatString, Color, audioSession);
IsPlaying = _audioSession.IsPlaying;
}
public void Parse_SongPlaceholder_SubstitutesText()
{
var format = "{song}";
var song = "the song";
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.SongName).Returns(song);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.Single(segments);
Assert.Equal(song, segments[0].Text);
}
public void ParseLength()
{
var format = "{length}";
var time = TimeSpan.FromSeconds(80);
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.SongLength).Returns(time);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.AreEqual(1, segments.Count);
Assert.AreEqual("1:20", segments[0].Text);
}
public void Parse_SinglePlaceholder_CreatesPlaceholderSegment()
{
var format = "{artist}";
var artist = "123";
var session = new Mock <IAudioSession>();
session.SetupGet(m => m.SongArtist).Returns(artist);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, session.Object).ToList();
Assert.Single(segments);
Assert.Equal(artist, segments[0].Text);
}
public void ParseAlbum()
{
var format = "{album}";
var album = "the album";
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.AlbumName).Returns(album);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.AreEqual(1, segments.Count);
Assert.AreEqual(album, segments[0].Text);
}
public void Parse_LengthPlaceholder_SubstitutesText()
{
var format = "{length}";
var time = TimeSpan.FromSeconds(80);
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.SongLength).Returns(time);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.Single(segments);
Assert.Equal("1:20", segments[0].Text);
}
public void Parse_AlbumPlaceholder_SubstitutesText()
{
var format = "{album}";
var album = "the album";
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.AlbumName).Returns(album);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.Single(segments);
Assert.Equal(album, segments[0].Text);
}
public void ParseSong()
{
var format = "{song}";
var song = "the song";
var mock = new Mock <IAudioSession>();
mock.SetupGet(m => m.SongName).Returns(song);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.AreEqual(1, segments.Count);
Assert.AreEqual(song, segments[0].Text);
}
public void ParsePlaceholderWithNormal()
{
var format = "{artist} song";
var artist = "123";
var session = new Mock <IAudioSession>();
session.SetupGet(m => m.SongArtist).Returns(artist);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, session.Object).ToList();
Assert.AreEqual(2, segments.Count);
Assert.AreEqual(artist, segments[0].Text);
Assert.AreEqual(" song", segments[1].Text);
Assert.IsTrue(segments[1].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void Parse_ArtistPlaceholder_SubstitutesText()
{
var format = "{artist}";
var artist = "123";
var artist2 = "next";
var mock = new Mock <IAudioSession>();
mock.SetupSequence(m => m.SongArtist).Returns(artist).Returns(artist2);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, mock.Object).ToList();
Assert.Single(segments);
Assert.Equal(artist, segments[0].Text);
mock.Raise(m => m.PropertyChanged += null, null, new PropertyChangedEventArgs(nameof(IAudioSession.SongArtist)));
Assert.Equal(artist2, segments[0].Text);
}
public void Parse_NormalWithPlaceholder_CreatesNormalAndPlaceholderSegments()
{
var format = "by {artist}";
var artist = "123";
var session = new Mock <IAudioSession>();
session.SetupGet(m => m.SongArtist).Returns(artist);
var segments = FormattedTextParser.ParseFormattedString(format, Colors.Black, session.Object).ToList();
Assert.Equal(2, segments.Count);
Assert.Equal("by ", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
Assert.Equal(artist, segments[1].Text);
}
public void plain_text_is_plain_text()
{
var commands = FormattedTextParser.ParseCommands("words [#color:aeaeae]words words [#color:a3ef37]words [#color:aaaaaa]words [#color:bbbbbb]words");
commands.Should().ContainInOrder(
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("aeaeae"),
FormattedTextCommand.PlainText.WithArguments("words words "),
FormattedTextCommand.Color.WithArguments("a3ef37"),
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("aaaaaa"),
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("bbbbbb"),
FormattedTextCommand.PlainText.WithArguments("words")
);
}
public void Parse_ComplexFormat_CreatesProperSegments()
{
var format = "this is {artist} and ";
var artist = "123";
var session = new Mock <IAudioSession>();
session.SetupGet(m => m.SongArtist).Returns(artist);
var segments = FormattedTextParser
.ParseFormattedString(format, Colors.Black, session.Object).ToList();
Assert.Equal(3, segments.Count);
Assert.Equal("this is ", segments[0].Text);
Assert.True(segments[0].Flags.HasFlag(FormattedTextFlags.Normal));
Assert.Equal(artist, segments[1].Text);
Assert.Equal(" and ", segments[2].Text);
Assert.True(segments[2].Flags.HasFlag(FormattedTextFlags.Normal));
}
public void get_fragments_from_commands()
{
var commands = new FormattedTextCommand[]
{
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("aeaeae"),
FormattedTextCommand.PlainText.WithArguments("words words "),
FormattedTextCommand.Color.WithArguments("a3ef37"),
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("aaaaaa"),
FormattedTextCommand.PlainText.WithArguments("words "),
FormattedTextCommand.Color.WithArguments("bbbbbb"),
FormattedTextCommand.PlainText.WithArguments("words")
};
var font = new MonospacedFontMetrics(new Point(4, 4));
var fragments = FormattedTextParser.GetFragmentsFromCommands(commands, font, Color.White);
fragments.Should().HaveCount(5);
}
public static void DrawFormattedText(Graphics zGraphics, Deck zDeck, ProjectLayoutElement zElement, string sInput, Brush zBrush, Font zFont, Color colorFont)
{
// check the cache for this item
var zDataFormattedCache = zDeck.GetCachedMarkup(zElement.name);
if (null == zDataFormattedCache)
{
if (null == zFont) // default to something!
{
// font will show up in red if it's not yet set
zFont = s_zDefaultFont;
zBrush = Brushes.Red;
}
if (255 != zElement.opacity)
{
zBrush = new SolidBrush(Color.FromArgb(zElement.opacity, colorFont));
}
zDataFormattedCache = new FormattedTextDataCache();
var zFormattedData = new FormattedTextData(FormattedTextParser.GetMarkups(sInput));
var zProcessData = new FormattedTextProcessData {
FontBrush = zBrush
};
// set the initial font
zProcessData.SetFont(zFont, zGraphics);
var listPassMarkups = new List <MarkupBase>(); // only contains the markups that will be actively drawn (for caching)
// Pass 1:
// - Create rectangles
// - Configure per-markup settings based on state of markup stack
// - Generate list of markups to continue to process (those that are used in the next pass)
// - Specify Markup rectanlges
// - Generate markup rows
int nIdx;
MarkupBase zMarkup;
for (nIdx = 0; nIdx < zFormattedData.AllMarkups.Count; nIdx++)
{
zMarkup = zFormattedData.AllMarkups[nIdx];
if (zMarkup.ProcessMarkup(zElement, zFormattedData, zProcessData, zGraphics))
{
zMarkup.LineNumber = zProcessData.CurrentLine;
listPassMarkups.Add(zMarkup);
}
}
// Pass 2:
// - Trim spaces from line endings
if (listPassMarkups.Count > 0)
{
nIdx = listPassMarkups.Count - 1;
zMarkup = listPassMarkups[nIdx];
var currentLineNumber = zMarkup.LineNumber;
var bFindNextLine = false;
while (nIdx > -1)
{
zMarkup = listPassMarkups[nIdx];
if (zMarkup.LineNumber != currentLineNumber)
{
currentLineNumber = zMarkup.LineNumber;
bFindNextLine = false;
}
if (!bFindNextLine && zMarkup is SpaceMarkup && ((SpaceMarkup)zMarkup).Optional)
{
listPassMarkups.RemoveAt(nIdx);
}
else
{
bFindNextLine = true;
}
nIdx--;
}
}
// Pass 3:
// - Align lines (horizontal/vertical)
// Reprocess for align (before backgroundcolor is configured)
AlignmentController.UpdateAlignment(zElement, listPassMarkups);
// Pass 4: process the remaining items
nIdx = 0;
while (nIdx < listPassMarkups.Count)
{
zMarkup = listPassMarkups[nIdx];
if (!zMarkup.PostProcessMarkupRectangle(zElement, listPassMarkups, nIdx))
{
listPassMarkups.RemoveAt(nIdx);
nIdx--;
}
else
{
zDataFormattedCache.AddMarkup(zMarkup);
}
nIdx++;
}
// update the cache
zDeck.AddCachedMarkup(zElement.name, zDataFormattedCache);
}
zDataFormattedCache.Render(zElement, zGraphics);
}
