public TimingGrid GetGrid(string gridName, bool createIfNotFound = true)
{
// Gets existing track specified by Name if it already exists
// Creates it if it does not
TimingGrid ret = Sequence.FindTimingGrid(gridName, createIfNotFound);
//TimingGrid ret = Sequence.TimingGrids.Find(gridName, MemberType.TimingGrid, true);
if (ret == null)
{
if (createIfNotFound)
{
// ERROR! Should not ever get here
System.Diagnostics.Debugger.Break();
//ret = Sequence.CreateTimingGrid(gridName);
//ret.Centiseconds = centiseconds;
//Sequence.AddTimingGrid(ret);
}
}
else
{
// Clear any existing timings from a previous run
if (ret.timings.Count > 0)
{
ret.timings = new List <int>();
}
}
return(ret);
}
private void OnMouseUpAsButton()
{
if (firstPlay)
{
AudioSource audio = GetComponent <AudioSource>();
audio.clip = playOnFirstPlayPress;
audio.Play();
firstPlay = false;
}
else
{
AudioSource audio = GetComponent <AudioSource>();
audio.Stop();
//invert button every click, starting or stoping the subroutine
isPlay = !isPlay;
SpriteRenderer spriteRenderer = (SpriteRenderer)GetComponent <Renderer>();
if (isPlay)
{
//wipe the current puck list
CreateAndPlaySequence.ClearAllPitches();
//Get all of the grids
List <GameObject> GridsAsGameObj = timeline.TimingGrids;
//for each grid
CreateAndPlaySequence.stepCount = GridsAsGameObj.Count;
CreateAndPlaySequence.Awake();
for (int beat = 0; beat < GridsAsGameObj.Count; beat++)
{
//find if there are any pucks added to the beat
TimingGrid Grid = GridsAsGameObj[beat].GetComponent <TimingGrid>();
for (int PuckIndex = Grid.Sprites.Count - 1; PuckIndex >= 0; PuckIndex--)
{
//get the puck's note and add the note to the corrisponding note in the sequence.
if (Grid.Sprites[PuckIndex].GetComponents <PlayableSprite>().Length != 0)
{
PlayableSprite SugarPuck = Grid.Sprites[PuckIndex].GetComponent <PlayableSprite>();
CreateAndPlaySequence.AddPitchAtStep(SugarPuck.PitchNumber + Grid.BeatNum, beat);
}
else
{
Grid.Sprites[PuckIndex].gameObject.GetComponent <SpriteRenderer>().enabled = false;
Grid.Sprites[PuckIndex].GetComponent <Collider2D>().enabled = false;
Destroy(Grid.Sprites[PuckIndex]);
Grid.Sprites.RemoveAt(PuckIndex);
}
}
}
CreateAndPlaySequence.StartSequencer();
spriteRenderer.sprite = stop;
}
//Stop Stepp
if (!isPlay)
{
CreateAndPlaySequence.StopSequencer();
spriteRenderer.sprite = play;
}
}
}
public int ImportTimingGrid(TimingGrid beatGrid, xTimings xEffects)
{
int errs = 0;
int lastStart = -1;
// If grid already has timings (from a previous run) clear them, start over fresh
if (beatGrid.timings.Count > 0)
{
beatGrid.timings.Clear();
}
beatGrid.TimingGridType = TimingGridType.Freeform;
for (int q = 0; q < xEffects.effects.Count; q++)
{
xEffect xef = xEffects.effects[q];
int t = ms2cs(xef.starttime);
if (t > lastStart)
{
if (t < Sequence.Centiseconds)
{
beatGrid.AddTiming(t);
}
}
lastStart = t;
}
return(errs);
}
} // end Beats
public int xTimingsToLORtimings(xTimings timings, Sequence4 sequence)
{
// Ignore the timings passed in, and use the ones already cached for Bars and Beats
// (Other transforms will use the one passed in)
seqFunct.Sequence = sequence;
int errs = 0;
if (xOnsets != null)
{
if (xOnsets.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Note Onsets", true);
seqFunct.ImportTimingGrid(barGrid, xOnsets);
}
}
return(errs);
}
//allow clear to be called externally
public void Clear()
{
//for each timeline grid
List <GameObject> GridsAsGameObj = timeline.TimingGrids;
foreach (var GridGameObj in GridsAsGameObj)
{
TimingGrid Grid = GridGameObj.GetComponent <TimingGrid>();
//for each puck in an individual grid
foreach (var PlayPuck in Grid.Sprites)
{
//destroy the objects in the grid
PlayPuck.gameObject.GetComponent <SpriteRenderer>().enabled = false;
Destroy(PlayPuck);
}
//create a new list without any objects, so that new objects can be added.
Grid.Sprites = new List <Collider2D>();
}
}
//this is a long one and should be broken into helpers
//convert whats between the ///////// to helper
private void RecomendChord()
{
List <GameObject> GridsAsGameObj = timeline.TimingGrids;
//for each grid
TimingGrid CurrGrid = GridsAsGameObj[0].GetComponent <TimingGrid>();
for (int beat = 0; beat < GridsAsGameObj.Count; beat++)
{
//find if there are any pucks added to the beat
TimingGrid Grid = GridsAsGameObj[beat].GetComponent <TimingGrid>();
if (Grid.Sprites.Count > 0)
{
//get the last grid with anything in it
CurrGrid = Grid;
}
}
//if there is a grid update
if (CurrGrid.Sprites.Count > 0 && (CurrGrid != lastGrid || SpritesInLastGrid != CurrGrid.Sprites.Count))
{
CanWiggle = false;
transform.eulerAngles = new Vector3(0, 0, 0);
lastGrid = CurrGrid;
SpritesInLastGrid = CurrGrid.Sprites.Count;
//these should be moved to a helper method.
//if there's only 1 note in the last grid
if (lastGrid.Sprites.Count == 1)
{
//find the notes in the key
int pitchNum = lastGrid.Sprites[0].GetComponent <PlayableSprite>().PitchNumber;
//find the note in the key that the current sprite is.
//if the sprite is A in the key of A, the index would be 0
//B in the key of A would be 1... ect
int keyNumIndex = -1;
for (int index = 0; index < Keychanger.NumInKey.Count; index++)
{
if (Keychanger.NumInKey[index] == pitchNum)
{
keyNumIndex = index;
}
}
//if the current puck in the last gridspace is in the key AND this sugar puck is the next note in the triad, wiggle ths puck
if (keyNumIndex != -1 && Keychanger.NumInKey[(keyNumIndex + 2) % Keychanger.NumInKey.Count] ==
PlaySprite.GetComponent <PlayableSprite>().PitchNumber % 12)
{
CanWiggle = true;
////>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//for each section of code between the left and right carrots,
//The code is implemented for use in the lessons only.
//Each of these sections follow the same logic.
//and determins how far away the next note in the basic triad is,
//either 3 or 4 steps away. As the notes are arranged linearly in one octave from A to G#
//there may be wrapping, where the user goes back to the bottom of the list, requireing a longer indicator.
//IE, a step from A to B would be up two pucks, yet a step from G# to A again would require moving down 12 pucks.
//A smaller example, from A to E is as follows:
//IE D to A instead of A to C
// e
//|-d
//| c<|
//| b |
//|>a-|
//clear all chord indicators
Keychanger.ClearAllPuckChordLines();
//if the note wraps around, IE, if the next note in the chord is "below" the first note instead of
//above, use a long arrow to point to this next puck instead of a short arrow
if (Keychanger.NumInKey[(keyNumIndex) % Keychanger.NumInKey.Count] > Keychanger.NumInKey[(keyNumIndex + 2) % Keychanger.NumInKey.Count])
{
if ((keyNumIndex + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 0)
{
//use a long 3 step arrow, the arrowhead pointing at,and starting from the new puck in the list
GameObject Step = Instantiate(VisualSteps[2]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
else
{
//use a long 4 step arrow, the arrowhead pointing at,and starting from the new puck in the list
GameObject Step = Instantiate(VisualSteps[3]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
}
//this puck is 3 steps above the previous note, no wrapping indicate it with the 3 step arrow
else if ((keyNumIndex + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex + 2) % Keychanger.NumInKey.Count == 0)
{
GameObject Step = Instantiate(VisualSteps[0]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
//this puck is 4 steps above the previous note, no wrapping indicate it with the 3 step arrow
else
{
GameObject Step = Instantiate(VisualSteps[1]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
////<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
}
//if there are 2 notes in the grid
if (lastGrid.Sprites.Count == 2)
{
//find the notes in the key
int pitchNum1 = lastGrid.Sprites[0].GetComponent <PlayableSprite>().PitchNumber;
int pitchNum2 = lastGrid.Sprites[1].GetComponent <PlayableSprite>().PitchNumber;
int keyNumIndex1 = -1;
int keyNumIndex2 = -1;
//find the notes in the key from the sugar pucks in the last grid.
for (int index = 0; index < Keychanger.NumInKey.Count; index++)
{
if (Keychanger.NumInKey[index] == pitchNum1)
{
keyNumIndex1 = index;
}
if (Keychanger.NumInKey[index] == pitchNum2)
{
keyNumIndex2 = index;
}
}
//find which note is the base of the triad, after assessing if the notes can be a triad
if (keyNumIndex1 != -1 && keyNumIndex2 != -1)
{
//assess if the first index is the base of the triad
if ((keyNumIndex1 + 2) % Keychanger.NumInKey.Count == keyNumIndex2)
{
//wiggle the last note in the triad
if (Keychanger.NumInKey[(keyNumIndex2 + 2) % Keychanger.NumInKey.Count] ==
PlaySprite.GetComponent <PlayableSprite>().PitchNumber % 12)
{
CanWiggle = true;
////>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if (Keychanger.NumInKey[(keyNumIndex2) % Keychanger.NumInKey.Count] > Keychanger.NumInKey[(keyNumIndex2 + 2) % Keychanger.NumInKey.Count])
{
if ((keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 0)
{
GameObject Step = Instantiate(VisualSteps[2]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
else
{
GameObject Step = Instantiate(VisualSteps[3]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
}
else if ((keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex2 + 2) % Keychanger.NumInKey.Count == 0)
{
GameObject Step = Instantiate(VisualSteps[0]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
else
{
GameObject Step = Instantiate(VisualSteps[1]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
////<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
}
//assess if the second index is the base of the triad
if ((keyNumIndex2 + 2) % Keychanger.NumInKey.Count == keyNumIndex1)
{
//wiggle the last note in the triad
if (Keychanger.NumInKey[(keyNumIndex1 + 2) % Keychanger.NumInKey.Count] ==
PlaySprite.GetComponent <PlayableSprite>().PitchNumber % 12)
{
CanWiggle = true;
////>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if (Keychanger.NumInKey[(keyNumIndex1) % Keychanger.NumInKey.Count] > Keychanger.NumInKey[(keyNumIndex1 + 2) % Keychanger.NumInKey.Count])
{
if ((keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 0)
{
GameObject Step = Instantiate(VisualSteps[2]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
else
{
GameObject Step = Instantiate(VisualSteps[3]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y - (TopPos - transform.position.y), StepPos.z);
}
}
else if ((keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 4 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 1 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 3 || (keyNumIndex1 + 2) % Keychanger.NumInKey.Count == 0)
{
GameObject Step = Instantiate(VisualSteps[0]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
else
{
GameObject Step = Instantiate(VisualSteps[1]);
VisualSteps.Add(Step);
Step.GetComponent <SpriteRenderer>().enabled = true;
Vector3 StepPos = Step.transform.position;
Step.transform.position = new Vector3(StepPos.x + 1f,
StepPos.y + (transform.position.y -
ZeroPos), StepPos.z);
}
////<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
}
}
}
}
}
} // end Beats
public int xTimingsToLORtimings(xTimings timings, Sequence4 sequence)
{
// Ignore the timings passed in, and use the ones already cached for Bars and Beats
// (Other transforms will use the one passed in)
seqFunct.Sequence = sequence;
int errs = 0;
if (xBars != null)
{
if (xBars.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Bars", true);
seqFunct.ImportTimingGrid(barGrid, xBars);
}
}
//if (chkBeatsFull.Checked)
if (true)
{
if (xBeatsFull != null)
{
if (xBeatsFull.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Full", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsFull);
}
}
}
//if (chkBeatsHalf.Checked)
if (true)
{
if (xBeatsHalf != null)
{
if (xBeatsHalf.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Half", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsHalf);
}
}
}
//if (chkBeatsThird.Checked)
if (true)
{
if (xBeatsThird != null)
{
if (xBeatsThird.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Third", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsThird);
}
}
}
//if (chkBeatsQuarter.Checked)
if (true)
{
if (xBeatsQuarter != null)
{
if (xBeatsQuarter.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Quarter", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsQuarter);
}
}
}
if (xFrames != null)
{
if (xFrames.effects.Count > 0)
{
TimingGrid barFrame = seqFunct.GetGrid(xFrames.timingName, true);
seqFunct.ImportTimingGrid(barFrame, xFrames);
}
}
return(errs);
}
private void MergeTimingGrids(TimingGrid destGrid, TimingGrid sourceGrid)
{
int t2Idx = 0;
int exIdx = 0;
if (sourceGrid.timings.Count > 0)
{
if (destGrid.timings.Count > 0)
{
t2Idx = 0;
exIdx = 0;
int dir = 0;
List <int> t2Timings = sourceGrid.timings;
List <int> exTimings = destGrid.timings;
while ((t2Idx < t2Timings.Count) && (exIdx < exTimings.Count))
{
if (t2Idx == exIdx)
{
// Already there! Do Nothing!
// Increment BOTH indexes
exIdx++;
t2Idx++;
}
else
{
if (t2Idx > exIdx)
{
// Haven't reached same point yet
// Increment new index
exIdx++;
}
else
{
// t2Idx < exIdx
// Didn't exist in new sequence
// Add it
destGrid.CopyTimings(sourceGrid.timings, true);
// Increment BOTH indexes
exIdx++;
t2Idx++;
} // haven't reached it
} // Not already there
} // while indexes are below counts
}
else
{
// Unlikely situation here, but nonetheless plausible
// Sequence2 and New Sequence have timing grids with the same name
// but in the New Sequence the grid is empty, and in Sequence2 it is not
// Names match, but are they the same type? (might be why it's empty)
if (sourceGrid.TimingGridType == destGrid.TimingGridType)
{
// So--- Add all of them
//destGrid.itemCount = sourceGrid.itemCount;
//Array.Resize(ref seqTwo.TimingGrids[seqNewGridIdx].timings, sourceGrid.itemCount);
foreach (int tc in sourceGrid.timings)
//for (int t = 0; t < sourceGrid.itemCount; t++)
{
destGrid.timings.Add(tc);
//sourceGrid.timings[t];
}
}
else
{
//? Not sure what to do here
string sMsg = "Help! This situation was not programmed for!\r\n";
sMsg += "Both sequences contain a timing grid named '" + sourceGrid.Name;
sMsg += "' but they are not the same type!\r\n";
sMsg += "It is highly recommended that you rename one (or both) of the timing grids in one (or both) ";
sMsg += "sequences and re-perform this merge.";
MessageBox.Show(this, sMsg, "Grid Conflict", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
} // end new timing grid has timings (or not)
} // end 2nd timing grid had items
}
private void OldMergeSequences()
{
mergeTracks = Properties.Settings.Default.MergeTracks;
mergeTracksByName = Properties.Settings.Default.MergeTracksByName;
duplicateNameAction = Properties.Settings.Default.DuplicateNameAction;
numberFormat = Properties.Settings.Default.AddNumberFormat;
bool matched = false;
int t2Idx = 0;
int exIdx = 0;
List <Map> groupMap = new List <Map>();
List <Map> trackMap = new List <Map>();
List <Map> timingMap = new List <Map>();
int newGroupCount = 0;
int newTrackCount = 0;
int newTimingCount = 0;
/////////////////////
// TIMING GRIDS //
///////////////////
// Make sure existing time grids are in order (they should be, but make sure anyway)
for (int t = 0; t < seqNew.TimingGrids.Count; t++)
{
seqNew.TimingGrids[t].timings.Sort();
}
for (int timings2Idx = 0; timings2Idx < seqTwo.TimingGrids.Count; timings2Idx++)
{
seqTwo.TimingGrids[timings2Idx].timings.Sort();
matched = false;
int matchingExTimingsGridIdx = utils.UNDEFINED;
for (int exTimingGridsIdx = 0; exTimingGridsIdx < seqNew.TimingGrids.Count; exTimingGridsIdx++)
{
// Compare names
if (seqTwo.TimingGrids[timings2Idx].CompareTo(seqNew.TimingGrids[exTimingGridsIdx]) == 0)
{
// Matching names found
matched = true;
matchingExTimingsGridIdx = exTimingGridsIdx;
exTimingGridsIdx = seqNew.TimingGrids.Count; // Break out of loop
}
} // end loop thru new sequence's timing grids
if (matched)
{
//MergeTimingGrids(timings2Idx, matchingExTimingsGridIdx);
}
else
{
// No timing grid with matching name found, so add this one
// Create a new timing grid and copy the name and type
int newSaveID = seqNew.Members.HighestSaveID + 1;
TimingGrid tGrid = seqNew.CreateTimingGrid(seqTwo.TimingGrids[timings2Idx].Name);
//tGrid.type = seqTwo.TimingGrids[timings2Idx].type;
tGrid.spacing = seqTwo.TimingGrids[timings2Idx].spacing;
// Create a new array for timings, and copy them
tGrid.CopyTimings(seqTwo.TimingGrids[timings2Idx].timings, false);
} // end if matched, or not
} // end loop thru 2nd sequence's timing grids
///////////////
// TRACKS //
/////////////
foreach (Track track2 in seqTwo.Tracks)
//for (int tracks2Idx = 0; tracks2Idx < seqTwo.Tracks.Count; tracks2Idx++)
{
matched = false;
if (mergeTracks)
{
int matchedExTracksIdx = utils.UNDEFINED;
foreach (Track newTrack in seqNew.Tracks)
//for (int exTracksIdx = 0; exTracksIdx < seqNew.Tracks.Count; exTracksIdx++)
{
if (mergeTracksByName)
{
// Merge by Name
if (track2.CompareTo(newTrack) == 0)
{
matched = true;
t2Idx = track2.Index;
exIdx = newTrack.Index;
//exTracksIdx = seqNew.Tracks.Count; // Break out of loop
break;
}
}
else
{
// Merge by Number
if (track2.Index == newTrack.Index)
{
matched = true;
t2Idx = track2.Index;
exIdx = newTrack.Index;
//exTracksIdx = seqNew.trackCount; // Break out of loop
break;
}
}
} // New Sequence Track Loop
if (matched)
{
//MergeTracks(t2Idx, exIdx);
newTrackCount++;
}
}
///////////////////////
// CHANNEL GROUPS //
/////////////////////
foreach (ChannelGroup group2 in seqTwo.ChannelGroups)
//for (int groups2Idx = 0; groups2Idx < seqTwo.channelGroupCount; groups2Idx++)
{
int matchedExGroupsIdx = utils.UNDEFINED;
foreach (ChannelGroup newGroup in seqNew.ChannelGroups)
//for (int exGroupsIdx = 0; exGroupsIdx < seqNew.channelGroupCount; exGroupsIdx++)
{
matched = false;
if (group2.CompareTo(newGroup) == 0)
{
matchedExGroupsIdx = newGroup.Index;
//exGroupsIdx = seqNew.channelGroupCount;
break;
}
//Array.Resize(ref groupMap, newGroupCount + 1);
Map gm = new Map(group2, newGroup);
groupMap.Add(gm);
if (matchedExGroupsIdx == utils.UNDEFINED)
{
ChannelGroup group3 = seqNew.CreateChannelGroup(group2.Name);
gm = new Map(group3, newGroup);
groupMap.Add(gm);
}
else
{
}
newGroupCount++;
}
/////////////////////
// RGB CHANNELS //
///////////////////
///////////////////////////
// (Regular) CHANNELS //
/////////////////////////
}
}
}
private void MergeSequences()
{
mergeTracks = Properties.Settings.Default.MergeTracks;
mergeTracksByName = Properties.Settings.Default.MergeTracksByName;
duplicateNameAction = Properties.Settings.Default.DuplicateNameAction;
mergeEffects = Properties.Settings.Default.MergeEffects;
numberFormat = Properties.Settings.Default.AddNumberFormat;
bool matched = false;
int exIdx = 0;
List <Map> groupMap = new List <Map>();
List <Map> trackMap = new List <Map>();
List <Map> timingMap = new List <Map>();
int newGroupCount = 0;
int newTrackCount = 0;
int newTimingCount = 0;
bool found = false;
/////////////////////
// TIMING GRIDS //
///////////////////
if (mergeGrids)
{
for (int g2Idx = 0; g2Idx < seqTwo.TimingGrids.Count; g2Idx++)
{
TimingGrid sourceGrid = seqTwo.TimingGrids[g2Idx];
sourceGrid.timings.Sort();
TimingGrid destGrid = null;
// Grids treated like tracks. Merge or Append?
if (mergeTracks)
{
found = true; // Reset to default
// Search for it, do NOT create if not found
destGrid = (TimingGrid)seqNew.Members.Find(sourceGrid.Name, MemberType.TimingGrid, false);
if (destGrid == null) // no match found
{
found = false;
destGrid = seqNew.CreateTimingGrid(sourceGrid.Name);
}
else // match found!
{
// Check for conflicting types and warn user
if (sourceGrid.TimingGridType == TimingGridType.FixedGrid)
{
if (destGrid.TimingGridType == TimingGridType.Freeform)
{
GridMismatchError(sourceGrid.Name);
}
}
if (sourceGrid.TimingGridType == TimingGridType.Freeform)
{
if (destGrid.TimingGridType == TimingGridType.FixedGrid)
{
GridMismatchError(sourceGrid.Name);
}
}
// What to do if match is found?
if (duplicateNameAction == ACTIONkeepBoth)
{
destGrid = seqNew.CreateTimingGrid(sourceGrid.Name);
}
if (duplicateNameAction == ACTIONaddNumber)
{
destGrid = seqNew.CreateTimingGrid(sourceGrid.Name + " (2)");
}
if (duplicateNameAction == ACTIONuseSecond)
{
destGrid.timings.Clear();
}
}
}
else // Append
{
destGrid = seqNew.CreateTimingGrid(sourceGrid.Name);
destGrid.TimingGridType = sourceGrid.TimingGridType;
} // Enbd if merge or append
// if not found, or any action other than keep first
if (!found || (duplicateNameAction != ACTIONkeepFirst))
{
// Copy type, spacing and timings
destGrid.TimingGridType = sourceGrid.TimingGridType;
destGrid.spacing = sourceGrid.spacing;
if (destGrid.TimingGridType == TimingGridType.Freeform)
{
destGrid.CopyTimings(sourceGrid.timings, false);
}
}
} // end loop thru 2nd sequence's timing grids
} // if Merge Grids
///////////////
// TRACKS //
/////////////
if (mergeTracks)
{
//foreach (Track track2 in seqTwo.Tracks)
for (int t2Idx = 0; t2Idx < seqTwo.Tracks.Count; t2Idx++)
{
Track sourceTrack = seqTwo.Tracks[t2Idx];
Track destTrack = null;
if (mergeTracksByNumber)
{
// Merge by number or name?
// If by number, do we even have that many in the destination?
if (t2Idx < seqNew.Tracks.Count)
{
destTrack = seqNew.Tracks[t2Idx];
}
else
{
// Not enough, make one
destTrack = seqNew.CreateTrack(sourceTrack.Name);
}
}
if (mergeTracksByName)
{
found = true; // reset to default
destTrack = (Track)seqNew.Members.Find(sourceTrack.Name, MemberType.Track, false);
if (destTrack == null) // no matching name found
{
found = false;
destTrack = seqNew.CreateTrack(sourceTrack.Name);
}
else // matching name found!
{
}
}
if (appendTracks)
{
destTrack = seqNew.CreateTrack(sourceTrack.Name);
}
MergeMembers(destTrack.Members, sourceTrack.Members);
Console.WriteLine(destTrack.Name);
}
}
}