public boolean[] getCurrentEnharmonics(int index) {
Polylist tones = new Polylist();
Chord currentChord = chordProg.getCurrentChord(index);
if (currentChord != null && !currentChord.getName().equals(NOCHORD)) {
try {
tones = chordProg.getCurrentChord(index).getPriority();
} catch (NullPointerException e) {
tones = new Polylist();
Trace.log(2, "Null pointer exception should be fixed in Score.getCurrentEnharmonics.");
Trace.log(2, e.getStackTrace().toString());
}
}
return getCurrentEnharmonics(index, tones);
}
/** Empties the destination and copies the section of the source into the destination. */
public void execute() {
Trace.log(2, "executing CopyCommand");
Part newPart = source.extract(startSlot, endSlot);
Part.PartIterator i = newPart.iterator();
dest.empty();
while (i.hasNext()) dest.addUnit(i.next());
}
/**
* Returns an exact copy of this Part
*
* @return Part copy
*/
public Part copy() {
Trace.log(3, "copying part of size " + size);
Part newPart = new Part(size);
/*
* PartIterator i = iterator(); while(i.hasNext())
* newPart.slots.set(i.nextIndex(), i.next().copy());
*/
for (int i = 0; i < size; i++) {
Unit unit = slots.get(i);
if (unit != null) {
unit = unit.copy();
}
newPart.slots.set(i, unit);
}
newPart.unitCount = unitCount;
newPart.title = title;
newPart.volume = volume;
newPart.instrument = instrument;
newPart.swing = swing;
newPart.setMetre(metre[0], metre[1]);
newPart.keySig = keySig;
return newPart;
}
/**
* Overwrites a section of the Part (starting at the specified index) with the slots contained in
* the given Part.
*
* @param part the Part to paste into this
* @param index the slot at which to start pasting over
*/
public void pasteSlots(Part part, int index) {
if (part == null) return;
Trace.log(2, "pasting part of length " + part.size() + " at index " + index);
for (int i = 0; i < part.size(); i++) {
if (slots.get(index + i) != null) unitCount--;
if (part.slots.get(i) != null) unitCount++;
slots.set(index + i, part.slots.get(i));
}
int prevIndex = this.getPrevIndex(index);
if (prevIndex == -1) prevIndex = 0;
int rv = getUnitRhythmValue(prevIndex);
Trace.log(3, "in pasteSlots, setting rhythmValue");
getUnit(prevIndex).setRhythmValue(rv);
}
/**
* Adds the specified Part to the Score.
*
* @param part Part to add
*/
public void addPart(MelodyPart part) {
Trace.log(2, "adding existing melody part to score");
if (length < part.size()) {
setLength(part.size());
}
partList.add(part);
}
/**
* Sets the key signature of the Score
*
* @param keySig the key signature to set the Score to
*/
public void setKeySignature(int keySig) {
Trace.log(2, "setting key signature of score to " + keySig);
this.keySig = keySig;
chordProg.setKeySignature(keySig);
ListIterator<MelodyPart> i = partList.listIterator();
while (i.hasNext()) {
i.next().setKeySignature(keySig);
}
}
/**
* Creates a new Command that can paste a source Part over a section of a destination Part.
*
* @param source the Part to paste
* @param dest the Part to paste over
* @param startSlot the slot to start pasting over in the dest
* @param undoable the boolean to see if the action is undoable
*/
public SideSlipCommand(
MelodyPart source,
boolean undoable,
String direction,
int distance,
int keySig,
CommandManager cm) {
this(source, direction, distance, keySig, cm);
this.undoable = undoable;
Trace.log(2, "creating SideSlipCommand");
}
/**
* Returns a Part that contains the slots with in the range specified.
*
* @param first the first slot in the range
* @param last the last slot in the range
* @return Part the Part that contains the extracted chunk
*/
public Part extractSlots(int first, int last) {
Trace.log(3, "extractSlots from " + first + " to " + last);
if (last > size - 1) last = size - 1;
Part newPart = new Part(last - first + 1);
for (int i = first; i < last; i++) // was <=, changed May 13 2012
newPart.slots.set(i - first, slots.get(i));
// I'm getting an ArrayIndexOutOfBoundsException -1 here, 21 June 2012
return newPart;
}
public void setLength(int newLength) {
if (newLength == length) {
return; // avoid unnecessary setting
}
Trace.log(3, "setting score length to " + newLength);
length = newLength;
if (chordProg != null) {
chordProg.setSize(length);
}
Iterator<MelodyPart> i = partList.listIterator();
while (i.hasNext()) {
i.next().setSize(length);
}
}
/** applies the transformation to the source MelodyPart */
public void execute() {
Trace.log(2, "executing SideSlipCommand");
int start = original.getSize();
if (direction.equals("up")) { // slide up
cm.execute(new ShiftPitchesCommand(distance, dest, 0, start, 0, 128, keySig));
} else if (direction.equals("down")) { // slide down
cm.execute(new ShiftPitchesCommand(-1 * distance, dest, 0, start, 0, 128, keySig));
}
// add two of the same melodies with one transposed
source.setSize(dest.getSize() * 2);
source.pasteOver(dest, start);
}
public void saveLeadsheet(BufferedWriter out, int[] metre, boolean lineBreaks)
throws IOException {
String outString = toLeadsheet();
Trace.log(3, "saving note to leadsheet: " + outString);
// Format for a maximum rhythm value per line.
if (lineBreaks && accumulatedRhythmValue >= maxRhythmValuePerLine) {
out.newLine();
out.newLine();
accumulatedRhythmValue -= maxRhythmValuePerLine;
}
out.write(" ");
out.write(outString);
accumulatedRhythmValue += rhythmValue;
}
public Part fitPart(int freeSlots) {
if (freeSlots == 0) return null;
Part fitPart = this.copy();
while (fitPart.size() > freeSlots) {
Part scaledPart = new Part();
Part.PartIterator i = fitPart.iterator();
while (i.hasNext()) {
Unit unit = i.next();
if (unit.getRhythmValue() != 1) {
Trace.log(3, "in fitPart, setting rhythmValue");
unit.setRhythmValue(unit.getRhythmValue() / 2);
if (unit.getRhythmValue() <= MIN_RHYTHM_VALUE) return null;
}
scaledPart.addUnit(unit);
}
fitPart = scaledPart;
}
return fitPart;
}
/**
* A rewritten version of pastOver
*
* @param part the Part to paste into this
* @param index the slot at which to start pasting over
*/
public void newPasteOver(Part part, int index) {
Trace.log(3, "pasteOver " + part + " onto " + index + " " + this.hashCode());
int limit = size();
int incoming = part.size();
// if( index + incoming < limit )
// {
// limit = index + incoming;
// }
int i = 0;
int j = index;
for (; i < incoming && j < limit; i++, j++) {
Unit unit = part.getUnit(i);
if (unit == null) {
newSetUnit(j, null);
} else {
newSetUnit(j, unit.copy());
}
}
}