public GuitarMessage(GuitarMessageList owner, TickPair pair, GuitarMessageType type)
{
this.messageType = type;
this.props = new MidiEventProps(owner, pair);
this.SetTicks(pair);
}
public static GuitarChordName CreateEvent(GuitarMessageList owner, TickPair ticks, ChordNameMeta meta, bool chordNameHidden)
{
var ret = new GuitarChordName(owner, ticks, meta, chordNameHidden);
ret.IsNew = true;
ret.CreateEvents();
return ret;
}
public GuitarModifier(GuitarMessageList owner, TickPair ticks, GuitarModifierType type, GuitarMessageType mt)
: base(owner, ticks, mt)
{
Data2 = 100;
Channel = 0;
this.ModifierType = type;
}
public static GuitarHandPosition CreateEvent(GuitarMessageList owner, TickPair ticks, int noteFret)
{
var ret = new GuitarHandPosition(owner, ticks, noteFret);
ret.IsNew = true;
ret.CreateEvents();
return ret;
}
public GuitarNote(GuitarMessageList owner, TickPair ticks)
: base(owner, ticks, GuitarMessageType.GuitarNote)
{
Data2 = Utility.Data2Default;
Channel = Utility.ChannelDefault;
SetTicks(ticks);
}
public GuitarBigRockEnding(GuitarMessageList owner, TickPair ticks, IEnumerable<MidiEventPair> events)
: this(owner, ticks)
{
Channel = 0;
events.ToList().ForEach(ev => AddSubMessage(new GuitarBigRockEndingSubMessage(this, ev)));
SetTicks(ticks);
}
public GuitarPowerup(GuitarMessageList owner, TickPair pair)
: base(owner, pair, GuitarModifierType.Powerup, GuitarMessageType.GuitarPowerup)
{
this.Data1 = Utility.PowerupData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(pair);
}
public GuitarMultiStringTremelo(GuitarMessageList owner, TickPair pair)
: base(owner, pair, GuitarModifierType.MultiStringTremelo, GuitarMessageType.GuitarMultiStringTremelo)
{
this.Data1 = Utility.MultiStringTremeloData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(pair);
}
public GuitarChordName(GuitarMessageList owner, TickPair pair, ChordNameMeta meta, bool hidden)
: base(owner, pair, GuitarMessageType.GuitarChordName)
{
this.Data1 = meta.ToneName.ToToneNameData1().ToInt();
this.Meta = meta;
this.ChordNameHidden = hidden;
Channel = 0;
}
public static GuitarSolo CreateSolo(GuitarMessageList owner, TickPair ticks)
{
var ret = new GuitarSolo(owner, ticks);
ret.IsNew = true;
ret.CreateEvents();
return ret;
}
public GuitarHandPosition(GuitarMessageList owner, TickPair pair, int noteFret)
: base(owner, pair, GuitarMessageType.GuitarHandPosition)
{
this.Data1 = Utility.HandPositionData1;
NoteFretDown = noteFret;
Channel = 0;
this.SetTicks(pair);
}
public GuitarSolo(GuitarMessageList owner, TickPair ticks)
: base(owner, ticks, GuitarModifierType.Solo, GuitarMessageType.GuitarSolo)
{
this.Data1 = Utility.SoloData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(ticks);
}
public static GuitarBigRockEnding CreateBigRockEnding(GuitarMessageList owner, TickPair ticks)
{
var ret = new GuitarBigRockEnding(owner, ticks);
ret.IsNew = true;
ret.CreateEvents();
return ret;
}
public GuitarBigRockEndingSubMessage(GuitarBigRockEnding owner, TickPair ticks, int data1)
: base(owner.Owner, ticks, GuitarMessageType.GuitarBigRockEndingSubMessage)
{
Channel = 0;
this.Data1 = data1;
this.Data2 = 100;
this.owner = owner;
this.SetTicks(ticks);
}
public GuitarBigRockEnding(GuitarMessageList owner, TickPair ticks)
: base(owner,ticks,GuitarModifierType.BigRockEnding, GuitarMessageType.GuitarBigRockEnding)
{
Channel = 0;
foreach (var data1 in Utility.GetBigRockEndingData1(IsPro))
{
childEvents.Add(new GuitarBigRockEndingSubMessage(this, ticks, data1));
}
SetTicks(ticks);
}
public static GuitarArpeggio CreateArpeggio(GuitarMessageList owner, TickPair ticks, GuitarDifficulty difficulty)
{
GuitarArpeggio ret = null;
if (Utility.GetArpeggioData1(difficulty).IsNotNull())
{
ret = new GuitarArpeggio(owner, ticks, difficulty);
if (ret != null)
{
ret.IsNew = true;
ret.CreateEvents();
}
}
return ret;
}
public GuitarTrainer(GuitarMessageList owner, TickPair ticks, GuitarTrainerType type, GuitarTextEvent start, GuitarTextEvent end, GuitarTextEvent norm)
: base(owner, ticks, GuitarMessageType.GuitarTrainer)
{
this.TrainerType = type;
Start = start;
End = end;
Norm = norm;
this.TrainerIndex = ParseTrainerIndex();
this.Loopable = norm != null;
SetTicks(ticks);
}
public GuitarTrainer(GuitarMessageList owner, TickPair ticks, GuitarTrainerType type, bool loopable, int index = Int32.MinValue)
: base(owner, ticks, GuitarMessageType.GuitarTrainer)
{
this.TrainerType = type;
this.TrainerIndex = index.IsNull() ? (owner.Trainers.Where(x => x.TrainerType == type).Count() + 1) : index;
this.Loopable = loopable;
Start = new GuitarTextEvent(owner, ticks.Down, GetStartText(TrainerType, TrainerIndex));
End = new GuitarTextEvent(owner, ticks.Up, GetEndText(TrainerType, TrainerIndex));
if (Loopable)
{
Norm = new GuitarTextEvent(owner, GetNormTick(ticks), GetNormText(TrainerType, TrainerIndex, Loopable));
}
SetTicks(ticks);
}
public GuitarChord Deserialize(GuitarMessageList owner, GuitarDifficulty diff, TickPair ticks)
{
int[] frets;
int[] channels;
ChordStrum chordStrum;
bool isSlide;
bool isSlideReverse;
bool isHammeron;
GuitarChordRootNoteConfig rootConfig;
GetProperties(out frets, out channels, out chordStrum, out isSlide, out isSlideReverse, out isHammeron, out rootConfig);
var ret = GuitarChord.CreateChord(owner, diff, ticks,
new GuitarChordConfig(frets, channels,
isSlide,
isSlideReverse,
isHammeron,
chordStrum,
rootConfig));
return ret;
}
public TickPair GetClientPointFromScreenPoint(TickPair pair)
{
return new TickPair(GetClientPointFromScreenPoint(pair.Down),
GetClientPointFromScreenPoint(pair.Up));
}
public override void SetTicks(TickPair ticks)
{
base.SetTicks(ticks);
childEvents.ToList().ForEach(x => x.SetTicks(ticks));
}
public TimePair TickToTime(TickPair ticks)
{
return new TimePair(TickToTime(ticks.Down), TickToTime(ticks.Up));
}
public MidiEventPair Insert(int data1, int data2, int channel, TickPair ticks)
{
if (!ticks.IsValid)
return default(MidiEventPair);
var down = Insert(ticks.Down, new ChannelMessage(ChannelCommand.NoteOn, data1, data2, channel));
var up = Insert(ticks.Up, new ChannelMessage(ChannelCommand.NoteOff, data1, 0, channel));
return new MidiEventPair(Messages, down, up);
}
void DrawRect(Graphics g, Brush b, TickPair ticks, int minString, int maxString)
{
var maxScreen = TopLineOffset + LineSpacing * (5 - minString) + NoteHeight - 2;
var minScreen = TopLineOffset + LineSpacing * (5 - maxString) - NoteHeight + 2;
g.FillRectangle(b,
ticks.Down,
minScreen, ticks.TickLength,
maxScreen - minScreen);
if (maxScreen - minScreen >= 4)
{
g.DrawRectangle(Utility.noteBoundPen,
ticks.Down,
minScreen, ticks.TickLength,
maxScreen - minScreen);
}
}
private TickPair snapRightTick(TickPair tickPair, GridPoint gridPoint,
IEnumerable<TickPair> closeToRight,
IEnumerable<TickPair> closeToRight5, SnapConfig config)
{
var gridTick = Int32.MinValue;
var tickPair5 = Int32.MinValue;
var tickPair6 = Int32.MinValue;
if (gridPoint != null && config.SnapGrid)
{
if (tickPair.Up.IsCloseTick(gridPoint.Tick))
gridTick = gridPoint.Tick;
}
if (config.SnapG5 && closeToRight5 != null && closeToRight5.Any())
{
var closeDown = closeToRight5.Where(x => x.Down.IsCloseTick(tickPair.Up)).ToList();
var closeUp = closeToRight5.Where(x => x.Up.IsCloseTick(tickPair.Up)).ToList();
if (closeDown.Any())
{
var minDown = closeDown.Select(x => new { Dist = (tickPair.Up - x.Down).Abs(), Val = x.Down }).OrderBy(x => x.Dist).FirstOrDefault().Val;
if (tickPair.Up.IsCloseTick(minDown))
{
tickPair5 = minDown;
}
else if (gridPoint != null && config.SnapGrid && gridTick.IsNotNull())
{
var gd = gridTick.DistSq(tickPair.Up);
if (gd < minDown.DistSq(tickPair.Up))
{
if (tickPair.Up.IsCloseTick(gridTick))
tickPair5 = gridTick;
}
else
{
if (tickPair.Up.IsCloseTick(minDown))
tickPair5 = minDown;
}
}
}
if (closeUp.Any())
{
var maxUp = closeUp.Select(x => new { Dist = (tickPair.Up - x.Up).Abs(), Val = x.Up }).OrderBy(x => x.Dist).FirstOrDefault().Val;
if (tickPair.Up.IsCloseTick(maxUp))
{
tickPair5 = maxUp;
}
else if (gridPoint != null && config.SnapGrid && gridTick.IsNotNull())
{
var gd = gridTick.DistSq(tickPair.Up);
if (gd < maxUp.DistSq(tickPair.Up))
{
if (tickPair.Up.IsCloseTick(gridTick))
tickPair5 = gridTick;
}
else
{
if (tickPair.Up.IsCloseTick(maxUp))
tickPair5 = maxUp;
}
}
}
}
if (config.SnapG6 && closeToRight != null && closeToRight.Any())
{
var closeDown = closeToRight.Where(x => x.Down.IsCloseTick(tickPair.Up)).ToList();
var closeUp = closeToRight.Where(x => x.Up.IsCloseTick(tickPair.Up)).ToList();
if (closeDown.Any())
{
var minDown = closeDown.Select(x => new { Dist = (tickPair.Up - x.Down).Abs(), Val = x.Down }).OrderBy(x => x.Dist).FirstOrDefault().Val;
if (tickPair.Up.IsCloseTick(minDown))
{
tickPair6 = minDown;
}
else if (gridPoint != null && config.SnapGrid && gridTick.IsNotNull())
{
var gd = gridTick.DistSq(tickPair.Up);
if (gd < minDown.DistSq(tickPair.Up))
{
if (tickPair.Up.IsCloseTick(gridTick))
tickPair6 = gridTick;
}
else
{
if (tickPair.Up.IsCloseTick(minDown))
tickPair6 = minDown;
}
}
}
if (closeUp.Any())
{
var maxUp = closeUp.Select(x => new { Dist = (tickPair.Up - x.Up).Abs(), Val = x.Up }).OrderBy(x => x.Dist).FirstOrDefault().Val;
if (tickPair.Up.IsCloseTick(maxUp))
{
tickPair6 = maxUp;
}
else if (gridPoint != null && config.SnapGrid && gridTick.IsNotNull())
{
var gd = gridTick.DistSq(tickPair.Up);
if (gd < maxUp.DistSq(tickPair.Up))
{
if (tickPair.Up.IsCloseTick(gridTick))
tickPair6 = gridTick;
}
else
{
if (tickPair.Up.IsCloseTick(maxUp))
tickPair6 = maxUp;
}
}
}
}
else if (gridPoint != null && config.SnapGrid && gridTick.IsNotNull())
{
if (tickPair.Up.IsCloseTick(gridTick))
tickPair.Up = gridTick;
}
var ret = new[] { tickPair6, tickPair5, gridTick }.Where(x => x.IsNotNull());
if (ret.Any())
{
tickPair.Up = ret.Select(x => new { Dist = (x - tickPair.Up).Abs(), Val = x }).OrderBy(x => x.Dist).FirstOrDefault().Val;
}
if (tickPair.Up.IsNull() == false &&
tickPair.Up < tickPair.Down)
{
tickPair.Up = tickPair.Down;
}
return tickPair;
}
private TickPair snapRightScreenPoint(TickPair screenPair, GridPoint gridPoint, List<GuitarChord> closeToRight, List<GuitarChord> closeToRight5)
{
var gridScreenPoint = Int32.MinValue;
if (gridPoint != null)
{
if (screenPair.Up.IsCloseScreenPoint(gridPoint.ScreenPoint))
gridScreenPoint = gridPoint.ScreenPoint;
}
if (closeToRight.Any())
{
var minDown = closeToRight.Min(x => x.ScreenPointPair.Down);
if (minDown < screenPair.Up)
{
if (screenPair.Up.IsCloseScreenPoint(minDown))
screenPair.Up = minDown;
}
else if (gridPoint != null)
{
var gd = gridScreenPoint.DistSq(screenPair.Up);
if (gd < minDown.DistSq(screenPair.Up))
{
if (screenPair.Up.IsCloseScreenPoint(gridScreenPoint))
screenPair.Up = gridScreenPoint;
}
else
{
if (screenPair.Up.IsCloseScreenPoint(minDown))
screenPair.Up = minDown;
}
}
else
{
if (screenPair.Up.IsCloseScreenPoint(minDown))
screenPair.Up = minDown;
}
}
else if (gridPoint != null)
{
if (screenPair.Up.IsCloseScreenPoint(gridScreenPoint))
screenPair.Up = gridScreenPoint;
}
return screenPair;
}
private TickPair snapLeftScreenPoint(TickPair screenPair, GridPoint gridPoint, List<GuitarChord> closeToLeft, List<GuitarChord> closeToLeft5)
{
var gridScreenPoint = Int32.MinValue;
if (gridPoint != null)
{
if (screenPair.Down.IsCloseScreenPoint(gridPoint.ScreenPoint))
gridScreenPoint = gridPoint.ScreenPoint;
}
if (closeToLeft5.Any())
{
var maxLeft = closeToLeft5.Max(x => x.ScreenPointPair.Up);
if (maxLeft > screenPair.Down)
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
else if (gridPoint != null)
{
var gd = gridScreenPoint.DistSq(screenPair.Down);
if (gd < maxLeft.DistSq(screenPair.Down))
{
if (screenPair.Down.IsCloseScreenPoint(gridScreenPoint))
screenPair.Down = gridScreenPoint;
}
else
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
}
else
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
}
if (closeToLeft.Any())
{
var maxLeft = closeToLeft.Max(x => x.ScreenPointPair.Up);
if (maxLeft > screenPair.Down)
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
else if (gridPoint != null)
{
var gd = gridScreenPoint.DistSq(screenPair.Down);
if (gd < maxLeft.DistSq(screenPair.Down))
{
if (screenPair.Down.IsCloseScreenPoint(gridScreenPoint))
screenPair.Down = gridScreenPoint;
}
else
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
}
else
{
if (screenPair.Down.IsCloseScreenPoint(maxLeft))
screenPair.Down = maxLeft;
}
}
else if (gridPoint != null)
{
if (screenPair.Down.IsCloseScreenPoint(gridScreenPoint))
screenPair.Down = gridScreenPoint;
}
return screenPair;
}
private void DrawTextAtTime(Graphics g, int alpha80, int alpha180,
bool tabActive, bool drawSelected, TickPair ticks, string text, SolidBrush tb, bool fullHeight)
{
var screenTicks = GetClientPointFromTick(ticks);
if (screenTicks.TickLength <= 0)
screenTicks.Up = screenTicks.Down + 1;
if (screenTicks.Up > 0 && screenTicks.Down < Width)
{
var size = g.MeasureString(text, Utility.fretFont);
var textRect = new RectangleF((float)screenTicks.Down, (size.Height * (0)) + (0 * size.Height * 0.1f),
size.Width, size.Height);
for (int idx = 0; idx < 8; idx++)
{
var ntr = new RectangleF((float)screenTicks.Down, (size.Height * (idx)) + (idx * size.Height * 0.1f),
size.Width, size.Height);
if (VisibleTextEvents.CountOverlapping(ntr) == 0)
{
textRect = ntr;
VisibleTextEvents.Add(new GuitarTextEvent(Messages, screenTicks.Down, text),
ntr);
break;
}
}
if (fullHeight)
{
using (var br = new SolidBrush(Color.FromArgb(alpha80, tb.Color)))
{
g.FillRectangle(br,
screenTicks.Down,
0, screenTicks.TickLength,
fullHeight ? (InnerHeight - 1) : size.Height + 1);
}
using (var p = new Pen(tb))
{
g.DrawRectangle(p,
screenTicks.Down, 0,
screenTicks.TickLength,
fullHeight ? (InnerHeight) : size.Height + 2);
}
}
using (var tbg = new SolidBrush(Color.FromArgb(tabActive ? (drawSelected ? 255 : 200) : alpha80, Utility.BackgroundBrush.Color)))
{
g.FillRectangle(tbg,
textRect.X, textRect.Y, textRect.Width, textRect.Height + 1);
}
using (var tbg = new Pen(Color.FromArgb(alpha180, Utility.noteBoundPen.Color)))
{
g.DrawRectangle(tbg,
textRect.X, textRect.Y, textRect.Width, textRect.Height + 1);
}
using (var fb = new SolidBrush(Color.FromArgb(alpha180, Utility.fretBrush.Color)))
{
var tl = textRect.Location;
tl.X -= 1;
textRect.Location = tl;
textRect.Width += 3;
g.DrawString(text, Utility.fretFont, fb, textRect, StringFormat.GenericDefault);
}
}
}
void FillRect(Graphics g, Brush b, TickPair ticks)
{
var rectTicks = GetClientPointFromTick(ticks);
g.FillRectangle(b,
rectTicks.Down,
0, rectTicks.Up - rectTicks.Down,
Height - HScroll.Height - 1);
if (rectTicks.TickLength >= 4)
{
using (var pen = new Pen(Color.FromArgb(30, Utility.noteBoundPen.Color)))
{
g.DrawRectangle(pen,
rectTicks.Down,
0, rectTicks.Up - rectTicks.Down,
Height - HScroll.Height - 1);
}
}
}
public TickPair GetClientPointFromTick(TickPair p)
{
return new TickPair(GetClientPointFromTick(p.Down),
GetClientPointFromTick(p.Up));
}
