mirror of
https://github.com/microtherion/VocalEasel.git
synced 2024-12-22 19:23:59 +00:00
315 lines
7.3 KiB
Plaintext
315 lines
7.3 KiB
Plaintext
//
|
|
// VLSheetView.mm
|
|
// Vocalese
|
|
//
|
|
// Created by Matthias Neeracher on 12/17/05.
|
|
// Copyright 2005 __MyCompanyName__. All rights reserved.
|
|
//
|
|
|
|
#import "VLSheetView.h"
|
|
#import "VLSheetViewInternal.h"
|
|
#import "VLSheetViewChords.h"
|
|
#import "VLSheetViewNotes.h"
|
|
|
|
#import "VLDocument.h"
|
|
|
|
#include <cmath>
|
|
|
|
@implementation VLSheetView
|
|
|
|
static NSImage ** sMusic;
|
|
|
|
static NSString * sElementNames[kMusicElements] = {
|
|
@"g-clef",
|
|
@"flat",
|
|
@"sharp",
|
|
@"natural",
|
|
@"whole-notehead",
|
|
@"half-notehead",
|
|
@"notehead",
|
|
@"whole-rest",
|
|
@"half-rest",
|
|
@"quarter-rest",
|
|
@"eighth-rest",
|
|
@"sixteenth-rest",
|
|
@"thirtysecondth-rest",
|
|
@"eighth-flag",
|
|
@"sixteenth-flag",
|
|
@"thirtysecondth-flag",
|
|
@"notecursor"
|
|
};
|
|
|
|
static float sSharpPos[] = {
|
|
kLineY+4.0f*kLineH, // F#
|
|
kLineY+2.5f*kLineH, // C#
|
|
kLineY+4.5f*kLineH, // G#
|
|
kLineY+3.0f*kLineH, // D#
|
|
kLineY+1.5f*kLineH, // A#
|
|
kLineY+3.5f*kLineH, // E#
|
|
kLineY+2.0f*kLineH, // B#
|
|
};
|
|
|
|
static float sFlatPos[] = {
|
|
kLineY+2.0f*kLineH, // Bb
|
|
kLineY+3.5f*kLineH, // Eb
|
|
kLineY+1.5f*kLineH, // Ab
|
|
kLineY+3.0f*kLineH, // Db
|
|
kLineY+1.0f*kLineH, // Gb
|
|
kLineY+2.5f*kLineH, // Cb
|
|
kLineY+0.5f*kLineH, // Fb
|
|
};
|
|
|
|
- (id)initWithFrame:(NSRect)frame
|
|
{
|
|
self = [super initWithFrame:frame];
|
|
if (self) {
|
|
if (!sMusic) {
|
|
NSBundle * b = [NSBundle mainBundle];
|
|
sMusic = new NSImage * [kMusicElements];
|
|
for (int i=0; i<kMusicElements; ++i) {
|
|
NSString * name =
|
|
[b pathForResource:sElementNames[i] ofType:@"eps"
|
|
inDirectory:@"Music"];
|
|
sMusic[i] = [[NSImage alloc] initWithContentsOfFile: name];
|
|
NSSize sz = [sMusic[i] size];
|
|
sz.width *= kImgScale;
|
|
sz.height*= kImgScale;
|
|
[sMusic[i] setScalesWhenResized:YES];
|
|
[sMusic[i] setSize:sz];
|
|
}
|
|
}
|
|
needsRecalc = YES;
|
|
firstMeasure = 0;
|
|
noteRectTracker = 0;
|
|
noteCursorCache = nil;
|
|
noteCursorMeasure = -1;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (VLDocument *) document
|
|
{
|
|
return [[[self window] windowController] document];
|
|
}
|
|
|
|
- (VLSong *) song
|
|
{
|
|
return [[self document] song];
|
|
}
|
|
|
|
- (NSImage *) musicElement:(VLMusicElement)elt
|
|
{
|
|
return sMusic[elt];
|
|
}
|
|
|
|
- (float) noteYWithPitch:(int)pitch
|
|
{
|
|
int semi = pitch % 12;
|
|
int octave = (pitch / 12) - 5;
|
|
bool useSharps = [self song]->fProperties.front().fKey >= 0;
|
|
|
|
float y = kLineY+octave*3.5f*kLineH;
|
|
float sharp = useSharps ? 0.0f : 0.5f*kLineH;
|
|
|
|
switch (semi) {
|
|
case 0: // C
|
|
return y-1.0f*kLineH;
|
|
case 1: // C# / Db
|
|
return y-1.0f*kLineH+sharp;
|
|
case 2: // D
|
|
return y-0.5f*kLineH;
|
|
case 3: // D# / Eb
|
|
return y-0.5f*kLineH+sharp;
|
|
case 4: // E
|
|
return y;
|
|
case 5: // F
|
|
return y+0.5f*kLineH;
|
|
case 6: // F# / Gb
|
|
return y+0.5f*kLineH+sharp;
|
|
case 7: // G
|
|
return y+1.0f*kLineH;
|
|
case 8: // G# / Ab
|
|
return y+1.0f*kLineH+sharp;
|
|
case 9: // A
|
|
return y+1.5f*kLineH;
|
|
case 10: // A# / Bb
|
|
return y+1.5f*kLineH+sharp;
|
|
case 11: // B
|
|
default:
|
|
return y+2.0f*kLineH;
|
|
}
|
|
}
|
|
|
|
- (float) noteXInMeasure:(int)measure at:(VLFraction)at
|
|
{
|
|
const VLProperties & prop = [self song]->fProperties.front();
|
|
const float mx = clefKeyW+(measure-firstMeasure)*measureW;
|
|
|
|
at /= prop.fTime / (4 * prop.fDivisions);
|
|
int div = at.fNum / at.fDenom;
|
|
|
|
return mx + (div + (div / divPerGroup) + 1)*kNoteW;
|
|
}
|
|
|
|
- (void) recalculateDimensions
|
|
{
|
|
needsRecalc = NO;
|
|
|
|
const VLSong * song = [self song];
|
|
const VLProperties & prop = song->fProperties.front();
|
|
|
|
groups = prop.fTime.fNum / std::max(prop.fTime.fDenom / 4, 1);
|
|
quarterBeats = (prop.fTime.fNum*4) / prop.fTime.fDenom;
|
|
divPerGroup = prop.fDivisions * (quarterBeats / groups);
|
|
clefKeyW = kClefX+kClefW+(std::labs(prop.fKey)+1)*kKeyW;
|
|
measureW = groups*(divPerGroup+1)*kNoteW;
|
|
visibleMeasures = (int)std::floor(([self bounds].size.width - clefKeyW)
|
|
/ measureW);
|
|
[self setValue:
|
|
[NSNumber numberWithInt:
|
|
std::max((int)song->fMeasures.size()-visibleMeasures, 0)]
|
|
forKey: @"lastMeasure"];
|
|
if (firstMeasure > lastMeasure)
|
|
[self setValue: [NSNumber numberWithInt:lastMeasure]
|
|
forKey: @"firstMeasure"];
|
|
|
|
[self setupChords];
|
|
|
|
noteRect = NSMakeRect(clefKeyW, kLineY-kMaxLedgers*kLineH,
|
|
visibleMeasures*measureW,
|
|
(4.0f+2.0f*kMaxLedgers)*kLineH);
|
|
NSPoint mouse =
|
|
[self convertPoint:[[self window] mouseLocationOutsideOfEventStream]
|
|
fromView: nil];
|
|
BOOL inNoteRect = [self mouse:mouse inRect:noteRect];
|
|
|
|
[self removeTrackingRect:noteRectTracker];
|
|
noteRectTracker = [self addTrackingRect:noteRect owner:self
|
|
userData:nil assumeInside:inNoteRect];
|
|
[[self window] setAcceptsMouseMovedEvents:inNoteRect];
|
|
[[self window] makeFirstResponder:self];
|
|
}
|
|
|
|
- (void)drawRect:(NSRect)rect
|
|
{
|
|
const VLSong * song = [self song];
|
|
const VLProperties & prop = song->fProperties.front();
|
|
|
|
NSBezierPath * bz = [NSBezierPath bezierPath];
|
|
|
|
//
|
|
// Draw lines
|
|
//
|
|
[bz setLineWidth:0.0];
|
|
if (needsRecalc)
|
|
[self recalculateDimensions];
|
|
for (int line = 0; line<5; ++line) {
|
|
const float x0 = kLineX;
|
|
const float xx = x0 + clefKeyW + visibleMeasures*measureW;
|
|
const float y = kLineY+line*kLineH;
|
|
[bz moveToPoint: NSMakePoint(x0, y)];
|
|
[bz lineToPoint: NSMakePoint(xx, y)];
|
|
}
|
|
[bz stroke];
|
|
[bz removeAllPoints];
|
|
//
|
|
// Draw measure lines
|
|
//
|
|
[bz setLineWidth:2.0];
|
|
for (int measure = 0; measure<=visibleMeasures; ++measure) {
|
|
const float x = clefKeyW+measure*measureW;
|
|
const float yy = kLineY+4.0f*kLineH;
|
|
[bz moveToPoint: NSMakePoint(x, kLineY)];
|
|
[bz lineToPoint: NSMakePoint(x, yy)];
|
|
}
|
|
[bz stroke];
|
|
[bz removeAllPoints];
|
|
|
|
//
|
|
// Draw division lines
|
|
//
|
|
[bz setLineWidth:0.0];
|
|
[[NSColor colorWithDeviceWhite:0.8f alpha:1.0f] set];
|
|
for (int measure = 0; measure<visibleMeasures; ++measure) {
|
|
const float mx = clefKeyW+measure*measureW;
|
|
const float y0 = kLineY-2.0f*kLineH;
|
|
const float yy = kLineY+6.0f*kLineH;
|
|
for (int group = 0; group < groups; ++group) {
|
|
for (int div = 0; div < divPerGroup; ++div) {
|
|
const float x = mx+(group*(divPerGroup+1)+div+1)*kNoteW;
|
|
[bz moveToPoint: NSMakePoint(x, y0)];
|
|
[bz lineToPoint: NSMakePoint(x, yy)];
|
|
}
|
|
}
|
|
}
|
|
[bz stroke];
|
|
|
|
//
|
|
// Draw clef
|
|
//
|
|
[[self musicElement:kMusicGClef]
|
|
compositeToPoint:NSMakePoint(kClefX, kClefY)
|
|
operation: NSCompositeSourceOver];
|
|
//
|
|
// Draw key (sharps & flats)
|
|
//
|
|
if (prop.fKey > 0) {
|
|
float x = kClefX+kClefW;
|
|
for (int i=0; i<prop.fKey; ++i) {
|
|
[[self musicElement:kMusicSharp] compositeToPoint:
|
|
NSMakePoint(x, sSharpPos[i]+kSharpY)
|
|
operation: NSCompositeSourceOver];
|
|
x += kAccW;
|
|
}
|
|
} else if (prop.fKey < 0) {
|
|
float x = kClefX+kClefW;
|
|
for (int i=0; -i>prop.fKey; ++i) {
|
|
[[self musicElement: kMusicFlat] compositeToPoint:
|
|
NSMakePoint(x, sFlatPos[i]+kFlatY)
|
|
operation: NSCompositeSourceOver];
|
|
x += kAccW;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw notes
|
|
//
|
|
[self drawNotes];
|
|
}
|
|
|
|
- (IBAction) setKey:(id)sender
|
|
{
|
|
int key = [[sender selectedItem] tag];
|
|
[[self document] setKey: key transpose: YES];
|
|
needsRecalc = YES;
|
|
[self setNeedsDisplay: YES];
|
|
}
|
|
|
|
- (IBAction) setTime:(id)sender
|
|
{
|
|
int time = [[sender selectedItem] tag];
|
|
|
|
[[self document] setTimeNum: time >> 8 denom: time & 0xFF];
|
|
needsRecalc = YES;
|
|
[self setNeedsDisplay: YES];
|
|
}
|
|
|
|
- (IBAction) setDivisions:(id)sender
|
|
{
|
|
int div = [[sender selectedItem] tag];
|
|
|
|
[[self document] setDivisions: div];
|
|
needsRecalc = YES;
|
|
[self setNeedsDisplay: YES];
|
|
}
|
|
|
|
- (void) setFirstMeasure: (NSNumber *)measure
|
|
{
|
|
firstMeasure = [measure intValue];
|
|
|
|
[self setupChords];
|
|
[self setNeedsDisplay: YES];
|
|
}
|
|
|
|
@end
|