bsnes/HexFiend/HFRepresenterTextViewCallout.m

478 lines
19 KiB
Mathematica
Raw Normal View History

//
// HFRepresenterTextViewCallout.m
// HexFiend_2
//
// Copyright 2011 ridiculous_fish. All rights reserved.
//
#import "HFRepresenterTextViewCallout.h"
#import "HFRepresenterTextView.h"
static const CGFloat HFTeardropRadius = 12;
static const CGFloat HFTeadropTipScale = 2.5;
static const CGFloat HFShadowXOffset = -6;
static const CGFloat HFShadowYOffset = 0;
static const CGFloat HFShadowOffscreenHack = 3100;
static NSPoint rotatePoint(NSPoint center, NSPoint point, CGFloat percent) {
CGFloat radians = percent * M_PI * 2;
CGFloat x = point.x - center.x;
CGFloat y = point.y - center.y;
CGFloat newX = x * cos(radians) + y * sin(radians);
CGFloat newY = x * -sin(radians) + y * cos(radians);
return NSMakePoint(center.x + newX, center.y + newY);
}
static NSPoint scalePoint(NSPoint center, NSPoint point, CGFloat percent) {
CGFloat x = point.x - center.x;
CGFloat y = point.y - center.y;
CGFloat newX = x * percent;
CGFloat newY = y * percent;
return NSMakePoint(center.x + newX, center.y + newY);
}
static NSBezierPath *copyTeardropPath(void) {
static NSBezierPath *sPath = nil;
if (! sPath) {
CGFloat radius = HFTeardropRadius;
CGFloat rotation = 0;
CGFloat droppiness = .15;
CGFloat tipScale = HFTeadropTipScale;
CGFloat tipLengthFromCenter = radius * tipScale;
NSPoint bulbCenter = NSMakePoint(-tipLengthFromCenter, 0);
NSPoint triangleCenter = rotatePoint(bulbCenter, NSMakePoint(bulbCenter.x + radius, bulbCenter.y), rotation);
NSPoint dropCorner1 = rotatePoint(bulbCenter, triangleCenter, droppiness / 2);
NSPoint dropCorner2 = rotatePoint(bulbCenter, triangleCenter, -droppiness / 2);
NSPoint dropTip = scalePoint(bulbCenter, triangleCenter, tipScale);
NSBezierPath *path = [[NSBezierPath alloc] init];
[path appendBezierPathWithArcWithCenter:bulbCenter radius:radius startAngle:-rotation * 360 + droppiness * 180. endAngle:-rotation * 360 - droppiness * 180. clockwise:NO];
[path moveToPoint:dropCorner1];
[path lineToPoint:dropTip];
[path lineToPoint:dropCorner2];
[path closePath];
sPath = path;
}
return [sPath retain];
}
@implementation HFRepresenterTextViewCallout
/* A helpful struct for representing a wedge (portion of a circle). Wedges are counterclockwise. */
typedef struct {
double offset; // 0 <= offset < 1
double length; // 0 <= length <= 1
} Wedge_t;
static inline double normalizeAngle(double x) {
/* Convert an angle to the range [0, 1). We typically only generate angles that are off by a full rotation, so a loop isn't too bad. */
while (x >= 1.) x -= 1.;
while (x < 0.) x += 1.;
return x;
}
static inline double distanceCCW(double a, double b) { return normalizeAngle(b-a); }
static inline double wedgeMax(Wedge_t wedge) {
return normalizeAngle(wedge.offset + wedge.length);
}
/* Computes the smallest wedge containing the two given wedges. Compute the wedge from the min of one to the furthest part of the other, and pick the smaller. */
static Wedge_t wedgeUnion(Wedge_t wedge1, Wedge_t wedge2) {
// empty wedges don't participate
if (wedge1.length <= 0) return wedge2;
if (wedge2.length <= 0) return wedge1;
Wedge_t union1 = wedge1;
union1.length = fmin(1., fmax(union1.length, distanceCCW(union1.offset, wedge2.offset) + wedge2.length));
Wedge_t union2 = wedge2;
union2.length = fmin(1., fmax(union2.length, distanceCCW(union2.offset, wedge1.offset) + wedge1.length));
Wedge_t result = (union1.length <= union2.length ? union1 : union2);
HFASSERT(result.length <= 1);
return result;
}
- (instancetype)init {
self = [super init];
if (self) {
// Initialization code here.
}
return self;
}
- (void)dealloc {
[_representedObject release];
[_color release];
[_label release];
[super dealloc];
}
- (NSComparisonResult)compare:(HFRepresenterTextViewCallout *)callout {
return [_representedObject compare:callout.representedObject];
}
static Wedge_t computeForbiddenAngle(double distanceFromEdge, double angleToEdge) {
Wedge_t newForbiddenAngle;
/* This is how far it is to the center of our teardrop */
const double teardropLength = HFTeardropRadius * HFTeadropTipScale;
if (distanceFromEdge <= 0) {
/* We're above or below. */
if (-distanceFromEdge >= (teardropLength + HFTeardropRadius)) {
/* We're so far above or below we won't be visible at all. No hope. */
newForbiddenAngle = (Wedge_t){.offset = 0, .length = 1};
} else {
/* We're either above or below the bounds, but there's a hope we can be visible */
double invertedAngleToEdge = normalizeAngle(angleToEdge + .5);
double requiredAngle;
if (-distanceFromEdge >= teardropLength) {
// We're too far north or south that all we can do is point in the right direction
requiredAngle = 0;
} else {
// By confining ourselves to required angles, we can make ourselves visible
requiredAngle = acos(-distanceFromEdge / teardropLength) / (2 * M_PI);
}
// Require at least a small spread
requiredAngle = fmax(requiredAngle, .04);
double requiredMin = invertedAngleToEdge - requiredAngle;
double requiredMax = invertedAngleToEdge + requiredAngle;
newForbiddenAngle = (Wedge_t){.offset = requiredMax, .length = distanceCCW(requiredMax, requiredMin) };
}
} else if (distanceFromEdge < teardropLength) {
// We're onscreen, but some angle will be forbidden
double forbiddenAngle = acos(distanceFromEdge / teardropLength) / (2 * M_PI);
// This is a wedge out of the top (or bottom)
newForbiddenAngle = (Wedge_t){.offset = angleToEdge - forbiddenAngle, .length = 2 * forbiddenAngle};
} else {
/* Nothing prohibited at all */
newForbiddenAngle = (Wedge_t){0, 0};
}
return newForbiddenAngle;
}
static double distanceMod1(double a, double b) {
/* Assuming 0 <= a, b < 1, returns the distance between a and b, mod 1 */
if (a > b) {
return fmin(a-b, b-a+1);
} else {
return fmin(b-a, a-b+1);
}
}
+ (void)layoutCallouts:(NSArray *)callouts inView:(HFRepresenterTextView *)textView {
// Keep track of how many drops are at a given location
NSCountedSet *dropsPerByteLoc = [[NSCountedSet alloc] init];
const CGFloat lineHeight = [textView lineHeight];
const NSRect bounds = [textView bounds];
NSMutableArray *remainingCallouts = [[callouts mutableCopy] autorelease];
[remainingCallouts sortUsingSelector:@selector(compare:)];
while ([remainingCallouts count] > 0) {
/* Get the next callout to lay out */
const NSInteger byteLoc = [remainingCallouts[0] byteOffset];
/* Get all the callouts that share that byteLoc */
NSMutableArray *sharedCallouts = [NSMutableArray array];
FOREACH(HFRepresenterTextViewCallout *, testCallout, remainingCallouts) {
if ([testCallout byteOffset] == byteLoc) {
[sharedCallouts addObject:testCallout];
}
}
/* We expect to get at least one */
const NSUInteger calloutCount = [sharedCallouts count];
HFASSERT(calloutCount > 0);
/* Get the character origin */
const NSPoint characterOrigin = [textView originForCharacterAtByteIndex:byteLoc];
Wedge_t forbiddenAngle = {0, 0};
// Compute how far we are from the top (or bottom)
BOOL isNearerTop = (characterOrigin.y < NSMidY(bounds));
double verticalDistance = (isNearerTop ? characterOrigin.y - NSMinY(bounds) : NSMaxY(bounds) - characterOrigin.y);
forbiddenAngle = wedgeUnion(forbiddenAngle, computeForbiddenAngle(verticalDistance, (isNearerTop ? .25 : .75)));
// Compute how far we are from the left (or right)
BOOL isNearerLeft = (characterOrigin.x < NSMidX(bounds));
double horizontalDistance = (isNearerLeft ? characterOrigin.x - NSMinX(bounds) : NSMaxX(bounds) - characterOrigin.x);
forbiddenAngle = wedgeUnion(forbiddenAngle, computeForbiddenAngle(horizontalDistance, (isNearerLeft ? .5 : 0.)));
/* How much will each callout rotate? No more than 1/8th. */
HFASSERT(forbiddenAngle.length <= 1);
double changeInRotationPerCallout = fmin(.125, (1. - forbiddenAngle.length) / calloutCount);
double totalConsumedAmount = changeInRotationPerCallout * calloutCount;
/* We would like to center around .375. */
const double goalCenter = .375;
/* We're going to pretend to work on a line segment that extends from the max prohibited angle all the way back to min */
double segmentLength = 1. - forbiddenAngle.length;
double goalSegmentCenter = normalizeAngle(goalCenter - wedgeMax(forbiddenAngle)); //may exceed segmentLength!
/* Now center us on the goal, or as close as we can get. */
double consumedSegmentCenter;
/* We only need to worry about wrapping around if we have some prohibited angle */
if (forbiddenAngle.length <= 0) { //never expect < 0, but be paranoid
consumedSegmentCenter = goalSegmentCenter;
} else {
/* The consumed segment center is confined to the segment range [amount/2, length - amount/2] */
double consumedSegmentCenterMin = totalConsumedAmount/2;
double consumedSegmentCenterMax = segmentLength - totalConsumedAmount/2;
if (goalSegmentCenter >= consumedSegmentCenterMin && goalSegmentCenter < consumedSegmentCenterMax) {
/* We can hit our goal */
consumedSegmentCenter = goalSegmentCenter;
} else {
/* Pick either the min or max location, depending on which one gets us closer to the goal segment center mod 1. */
if (distanceMod1(goalSegmentCenter, consumedSegmentCenterMin) <= distanceMod1(goalSegmentCenter, consumedSegmentCenterMax)) {
consumedSegmentCenter = consumedSegmentCenterMin;
} else {
consumedSegmentCenter = consumedSegmentCenterMax;
}
}
}
/* Now convert this back to an angle */
double consumedAngleCenter = normalizeAngle(wedgeMax(forbiddenAngle) + consumedSegmentCenter);
// move us slightly towards the character
NSPoint teardropTipOrigin = NSMakePoint(characterOrigin.x + 1, characterOrigin.y + floor(lineHeight / 8.));
// make the pin
NSPoint pinStart, pinEnd;
pinStart = NSMakePoint(characterOrigin.x + .25, characterOrigin.y);
pinEnd = NSMakePoint(pinStart.x, pinStart.y + lineHeight);
// store it all, invalidating as necessary
NSInteger i = 0;
FOREACH(HFRepresenterTextViewCallout *, callout, sharedCallouts) {
/* Compute the rotation */
double seq = (i+1)/2; //0, 1, -1, 2, -2...
if ((i & 1) == 0) seq = -seq;
//if we've got an even number of callouts, we want -.5, .5, -1.5, 1.5...
if (! (calloutCount & 1)) seq -= .5;
// compute the angle of rotation
double angle = consumedAngleCenter + seq * changeInRotationPerCallout;
// our notion of rotation has 0 meaning pointing right and going counterclockwise, but callouts with 0 pointing left and going clockwise, so convert
angle = normalizeAngle(.5 - angle);
NSRect beforeRect = [callout rect];
callout->rotation = angle;
callout->tipOrigin = teardropTipOrigin;
callout->pinStart = pinStart;
callout->pinEnd = pinEnd;
// Only the first gets a pin
pinStart = pinEnd = NSZeroPoint;
NSRect afterRect = [callout rect];
if (! NSEqualRects(beforeRect, afterRect)) {
[textView setNeedsDisplayInRect:beforeRect];
[textView setNeedsDisplayInRect:afterRect];
}
i++;
}
/* We're done laying out these callouts */
[remainingCallouts removeObjectsInArray:sharedCallouts];
}
[dropsPerByteLoc release];
}
- (CGAffineTransform)teardropTransform {
CGAffineTransform trans = CGAffineTransformMakeTranslation(tipOrigin.x, tipOrigin.y);
trans = CGAffineTransformRotate(trans, rotation * M_PI * 2);
return trans;
}
- (NSRect)teardropBaseRect {
NSSize teardropSize = NSMakeSize(HFTeardropRadius * (1 + HFTeadropTipScale), HFTeardropRadius*2);
NSRect result = NSMakeRect(-teardropSize.width, -teardropSize.height/2, teardropSize.width, teardropSize.height);
return result;
}
- (CGAffineTransform)shadowTransform {
CGFloat shadowXOffset = HFShadowXOffset;
CGFloat shadowYOffset = HFShadowYOffset;
CGFloat offscreenOffset = HFShadowOffscreenHack;
// Figure out how much movement the shadow offset produces
CGFloat shadowTranslationDistance = hypot(shadowXOffset, shadowYOffset);
CGAffineTransform transform = CGAffineTransformIdentity;
transform = CGAffineTransformTranslate(transform, tipOrigin.x + offscreenOffset - shadowXOffset, tipOrigin.y - shadowYOffset);
transform = CGAffineTransformRotate(transform, rotation * M_PI * 2 - atan2(shadowTranslationDistance, 2*HFTeardropRadius /* bulbHeight */));
return transform;
}
- (void)drawShadowWithClip:(NSRect)clip {
USE(clip);
CGContextRef ctx = [[NSGraphicsContext currentContext] graphicsPort];
// Set the shadow. Note that these shadows are pretty unphysical for high rotations.
NSShadow *shadow = [[NSShadow alloc] init];
[shadow setShadowBlurRadius:5.];
[shadow setShadowOffset:NSMakeSize(HFShadowXOffset - HFShadowOffscreenHack, HFShadowYOffset)];
[shadow setShadowColor:[NSColor colorWithDeviceWhite:0. alpha:.5]];
[shadow set];
[shadow release];
// Draw the shadow first and separately
CGAffineTransform transform = [self shadowTransform];
CGContextConcatCTM(ctx, transform);
NSBezierPath *teardrop = copyTeardropPath();
[teardrop fill];
[teardrop release];
// Clear the shadow
CGContextSetShadowWithColor(ctx, CGSizeZero, 0, NULL);
// Undo the transform
CGContextConcatCTM(ctx, CGAffineTransformInvert(transform));
}
- (void)drawWithClip:(NSRect)clip {
USE(clip);
CGContextRef ctx = [[NSGraphicsContext currentContext] graphicsPort];
// Here's the font we'll use
CTFontRef ctfont = CTFontCreateWithName(CFSTR("Helvetica-Bold"), 1., NULL);
if (ctfont) {
// Set the font
[(NSFont *)ctfont set];
// Get characters
NSUInteger labelLength = MIN([_label length], kHFRepresenterTextViewCalloutMaxGlyphCount);
UniChar calloutUniLabel[kHFRepresenterTextViewCalloutMaxGlyphCount];
[_label getCharacters:calloutUniLabel range:NSMakeRange(0, labelLength)];
// Get our glyphs and advances
CGGlyph glyphs[kHFRepresenterTextViewCalloutMaxGlyphCount];
CGSize advances[kHFRepresenterTextViewCalloutMaxGlyphCount];
CTFontGetGlyphsForCharacters(ctfont, calloutUniLabel, glyphs, labelLength);
CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, glyphs, advances, labelLength);
// Count our glyphs. Note: this won't work with any label containing spaces, etc.
NSUInteger glyphCount;
for (glyphCount = 0; glyphCount < labelLength; glyphCount++) {
if (glyphs[glyphCount] == 0) break;
}
// Set our color.
[_color set];
// Draw the pin first
if (! NSEqualPoints(pinStart, pinEnd)) {
[NSBezierPath setDefaultLineWidth:1.25];
[NSBezierPath strokeLineFromPoint:pinStart toPoint:pinEnd];
}
CGContextSaveGState(ctx);
CGContextBeginTransparencyLayerWithRect(ctx, NSRectToCGRect([self rect]), NULL);
// Rotate and translate in preparation for drawing the teardrop
CGContextConcatCTM(ctx, [self teardropTransform]);
// Draw the teardrop
NSBezierPath *teardrop = copyTeardropPath();
[teardrop fill];
[teardrop release];
// Draw the text with white and alpha. Use blend mode copy so that we clip out the shadow, and when the transparency layer is ended we'll composite over the text.
CGFloat textScale = (glyphCount == 1 ? 24 : 20);
// we are flipped by default, so invert the rotation's sign to get the text direction. Use a little slop so we don't get jitter.
const CGFloat textDirection = (rotation <= .27 || rotation >= .73) ? -1 : 1;
CGPoint positions[kHFRepresenterTextViewCalloutMaxGlyphCount];
CGFloat totalAdvance = 0;
for (NSUInteger i=0; i < glyphCount; i++) {
// make sure to provide negative advances if necessary
positions[i].x = copysign(totalAdvance, -textDirection);
positions[i].y = 0;
CGFloat advance = advances[i].width;
// Workaround 5834794
advance *= textScale;
// Tighten up the advances a little
advance *= .85;
totalAdvance += advance;
}
// Compute the vertical offset
CGFloat textYOffset = (glyphCount == 1 ? 4 : 5);
// LOL
if ([_label isEqualToString:@"6"] || [_label isEqualToString:@"7"] == 7) textYOffset -= 1;
// Apply this text matrix
NSRect bulbRect = [self teardropBaseRect];
CGAffineTransform textMatrix = CGAffineTransformMakeScale(-copysign(textScale, textDirection), copysign(textScale, textDirection)); //roughly the font size we want
textMatrix.tx = NSMinX(bulbRect) + HFTeardropRadius + copysign(totalAdvance/2, textDirection);
if (textDirection < 0) {
textMatrix.ty = NSMaxY(bulbRect) - textYOffset;
} else {
textMatrix.ty = NSMinY(bulbRect) + textYOffset;
}
// Draw
CGContextSetTextMatrix(ctx, textMatrix);
CGContextSetTextDrawingMode(ctx, kCGTextClip);
CGContextShowGlyphsAtPositions(ctx, glyphs, positions, glyphCount);
CGContextSetBlendMode(ctx, kCGBlendModeCopy);
CGContextSetGrayFillColor(ctx, 1., .66); //faint white fill
CGContextFillRect(ctx, NSRectToCGRect(NSInsetRect(bulbRect, -20, -20)));
// Done drawing, so composite
CGContextEndTransparencyLayer(ctx);
CGContextRestoreGState(ctx); // this also restores the clip, which is important
// Done with the font
CFRelease(ctfont);
}
}
- (NSRect)rect {
// get the transformed teardrop rect
NSRect result = NSRectFromCGRect(CGRectApplyAffineTransform(NSRectToCGRect([self teardropBaseRect]), [self teardropTransform]));
// outset a bit for the shadow
result = NSInsetRect(result, -8, -8);
return result;
}
@end