620 lines
23 KiB
Objective-C
620 lines
23 KiB
Objective-C
//
|
|
// MPExpressionView.m
|
|
// MathPad
|
|
//
|
|
// Created by Kim Wittenburg on 17.04.14.
|
|
// Copyright (c) 2014 Kim Wittenburg. All rights reserved.
|
|
//
|
|
|
|
#import "MPExpressionView.h"
|
|
#import "MPExpressionStorage.h"
|
|
#import "MPExpressionLayout.h"
|
|
#import "MPFunctionLayout.h"
|
|
|
|
#import "MPRangePath.h"
|
|
|
|
#import "NSIndexPath+MPAdditions.h"
|
|
|
|
#import "MPSumFunction.h"
|
|
|
|
|
|
|
|
@interface MPExpressionView ()
|
|
|
|
@property (nonatomic, weak) NSButton *functionsButton;
|
|
|
|
@property (nonatomic, strong) NSTimer *caretTimer;
|
|
@property (nonatomic) NSTimeInterval caretBlinkRate;
|
|
@property (nonatomic) BOOL caretVisible;
|
|
|
|
@property (nonatomic, getter = isSelectionModifyingStart) BOOL selectionModifyingStart;
|
|
|
|
@property (nonatomic, strong) NSIndexPath *mouseAnchor;
|
|
|
|
@end
|
|
|
|
|
|
|
|
@interface MPExpressionView (MPDrawing)
|
|
|
|
- (NSPoint)expressionOrigin;
|
|
|
|
@end
|
|
|
|
|
|
|
|
@interface MPExpressionView (MPSelection)
|
|
- (void)restartCaretTimer;
|
|
- (void)updateCaret:(NSTimer *)timer;
|
|
|
|
- (NSRect)selectionRect;
|
|
|
|
- (NSIndexPath *)selectionToTheRightOf:(NSIndexPath *)selectionPath
|
|
byExtendingSelection:(BOOL)extendingSelection
|
|
selectWords:(BOOL)selectWords;
|
|
- (NSIndexPath *)selectionToTheLeftOf:(NSIndexPath *)selectionPath
|
|
byExtendingSelection:(BOOL)extendingSelection
|
|
selectWords:(BOOL)selectWords;
|
|
|
|
- (MPRangePath *)rangePathEnclosingAnchorPath:(NSIndexPath *)anchor
|
|
newSelectionPath:(NSIndexPath *)newSelection;
|
|
@end
|
|
|
|
|
|
|
|
@implementation MPExpressionView (MPDrawing)
|
|
|
|
- (NSPoint)expressionOrigin
|
|
{
|
|
NSRect expressionBounds = [self.expressionStorage.rootLayout bounds];
|
|
CGFloat y = (self.bounds.size.height - expressionBounds.size.height) / 2 + fabs(expressionBounds.origin.y);
|
|
return NSMakePoint(0, y);
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
|
|
@implementation MPExpressionView (MPSelection)
|
|
|
|
- (void)restartCaretTimer
|
|
{
|
|
if (self.caretTimer) {
|
|
if ([self.caretTimer isValid]) {
|
|
[self.caretTimer invalidate];
|
|
}
|
|
}
|
|
self.caretTimer = [NSTimer scheduledTimerWithTimeInterval:self.caretBlinkRate/2 target:self selector:@selector(updateCaret:) userInfo:nil repeats:YES];
|
|
self.caretVisible = NO;
|
|
[self updateCaret:self.caretTimer];
|
|
}
|
|
|
|
- (void)updateCaret:(NSTimer *)timer
|
|
{
|
|
self.caretVisible = !self.caretVisible;
|
|
self.needsDisplay = YES;
|
|
}
|
|
|
|
- (NSRect)selectionRect
|
|
{
|
|
NSRect selectionRect = [self.expressionStorage.rootLayout boundingRectForRangePath:self.selection];
|
|
if (self.selection.length == 0) {
|
|
selectionRect.size.width = 1;
|
|
}
|
|
return selectionRect;
|
|
}
|
|
|
|
- (NSIndexPath *)selectionToTheRightOf:(NSIndexPath *)selectionPath
|
|
byExtendingSelection:(BOOL)extendingSelection
|
|
selectWords:(BOOL)selectWords
|
|
{
|
|
NSIndexPath *targetExpressionPath = [selectionPath indexPathByRemovingLastIndex];
|
|
MPExpression *targetExpression = [self.expressionStorage elementAtIndexPath:targetExpressionPath];
|
|
NSUInteger locationInTarget = selectionPath.lastIndex;
|
|
NSUInteger locationInElement;
|
|
NSUInteger targetElementIndex = [targetExpression indexOfElementAtSymbolLocation:locationInTarget
|
|
offset:&locationInElement];
|
|
|
|
id<MPExpressionElement> targetElement;
|
|
// There is only a target element if the selection is not the last location in an expression
|
|
if (targetElementIndex < targetExpression.numberOfElements) {
|
|
targetElement = [targetExpression elementAtIndex:targetElementIndex];
|
|
}
|
|
|
|
if (!selectWords && !extendingSelection && (locationInElement == 0 || locationInTarget == targetExpression.length)) {
|
|
// First or last index in an element or expression
|
|
|
|
// Last element in the expression
|
|
if (locationInTarget == targetExpression.length) {
|
|
// The selection is inside a function and should proceed
|
|
if (selectionPath.length > 1) {
|
|
NSIndexPath *functionPath = [[selectionPath indexPathByRemovingLastIndex] indexPathByRemovingLastIndex];
|
|
MPFunctionLayout *functionLayout = (MPFunctionLayout *)[self.expressionStorage.rootLayout childLayoutAtIndexPath:functionPath];
|
|
NSUInteger currentChildIndex = [selectionPath indexPathByRemovingLastIndex].lastIndex;
|
|
NSUInteger newChildIndex = [functionLayout indexOfChildAfterChildAtIndex:currentChildIndex];
|
|
|
|
// The function is to be exited
|
|
if (newChildIndex == NSNotFound) {
|
|
targetExpression = [self.expressionStorage elementAtIndexPath:[functionPath indexPathByRemovingLastIndex]];
|
|
NSUInteger functionLocationInExpression = [targetExpression locationOfElementAtIndex:functionPath.lastIndex];
|
|
return [functionPath indexPathByReplacingLastIndexWithIndex:functionLocationInExpression+1];
|
|
} else {
|
|
return [[targetExpressionPath indexPathByReplacingLastIndexWithIndex:newChildIndex] indexPathByAddingIndex:0];
|
|
}
|
|
} // else the selection does not change
|
|
|
|
// First Element
|
|
} else {
|
|
if ([targetElement isString]) {
|
|
locationInTarget++;
|
|
} else {
|
|
NSIndexPath *targetFunctionPath = [selectionPath indexPathByReplacingLastIndexWithIndex:targetElementIndex];
|
|
MPFunctionLayout *functionLayout = (MPFunctionLayout *)[self.expressionStorage.rootLayout childLayoutAtIndexPath:targetFunctionPath];
|
|
NSUInteger leadingChildIndex = [functionLayout indexOfLeadingChild];
|
|
return [[targetFunctionPath indexPathByAddingIndex:leadingChildIndex] indexPathByAddingIndex:0];
|
|
}
|
|
}
|
|
} else if (locationInTarget < targetExpression.length) {
|
|
if (selectWords) {
|
|
locationInTarget = [targetExpression locationOfElementAtIndex:targetElementIndex+1];
|
|
} else {
|
|
locationInTarget++;
|
|
}
|
|
}
|
|
return [selectionPath indexPathByReplacingLastIndexWithIndex:locationInTarget];
|
|
}
|
|
|
|
- (NSIndexPath *)selectionToTheLeftOf:(NSIndexPath *)selectionPath
|
|
byExtendingSelection:(BOOL)extendingSelection
|
|
selectWords:(BOOL)selectWords
|
|
{
|
|
NSIndexPath *targetExpressionPath = [selectionPath indexPathByRemovingLastIndex];
|
|
MPExpression *targetExpression = [self.expressionStorage elementAtIndexPath:targetExpressionPath];
|
|
NSUInteger locationInTarget = selectionPath.lastIndex;
|
|
NSUInteger locationInElement;
|
|
NSUInteger targetElementIndex = [targetExpression indexOfElementAtSymbolLocation:locationInTarget
|
|
offset:&locationInElement];
|
|
|
|
NSUInteger previousElementIndex = targetElementIndex - (locationInElement == 0 ? 1 : 0);
|
|
id<MPExpressionElement> previousElement;
|
|
if (locationInTarget > 0) {
|
|
previousElement = [targetExpression elementAtIndex:previousElementIndex];
|
|
}
|
|
|
|
if (!selectWords && !extendingSelection && locationInElement == 0) {
|
|
// First element in expression
|
|
if (locationInTarget == 0) {
|
|
if (selectionPath.length > 1) {
|
|
NSIndexPath *functionPath = [[selectionPath indexPathByRemovingLastIndex] indexPathByRemovingLastIndex];
|
|
MPFunctionLayout *functionLayout = (MPFunctionLayout *)[self.expressionStorage.rootLayout childLayoutAtIndexPath:functionPath];
|
|
NSUInteger currentChildIndex = [selectionPath indexPathByRemovingLastIndex].lastIndex;
|
|
NSUInteger newChildIndex = [functionLayout indexOfChildBeforeChildAtIndex:currentChildIndex];
|
|
|
|
// The function is to be exited
|
|
if (newChildIndex == NSNotFound) {
|
|
targetExpression = [self.expressionStorage elementAtIndexPath:[functionPath indexPathByRemovingLastIndex]];
|
|
NSUInteger functionLocationInExpression = [targetExpression locationOfElementAtIndex:functionPath.lastIndex];
|
|
return [functionPath indexPathByReplacingLastIndexWithIndex:functionLocationInExpression];
|
|
} else {
|
|
targetExpressionPath = [targetExpressionPath indexPathByReplacingLastIndexWithIndex:newChildIndex];
|
|
targetExpression = [self.expressionStorage elementAtIndexPath:targetExpressionPath];
|
|
return [targetExpressionPath indexPathByAddingIndex:targetExpression.length];
|
|
}
|
|
} // else the selection does not change
|
|
|
|
// Just
|
|
} else {
|
|
if ([previousElement isString]) {
|
|
locationInTarget--;
|
|
} else {
|
|
NSIndexPath *targetFunctionPath = [selectionPath indexPathByReplacingLastIndexWithIndex:previousElementIndex];
|
|
MPFunctionLayout *functionLayout = (MPFunctionLayout *)[self.expressionStorage.rootLayout childLayoutAtIndexPath:targetFunctionPath];
|
|
NSUInteger trailingChildIndex = [functionLayout indexOfTrailingChild];
|
|
|
|
targetExpressionPath = [targetFunctionPath indexPathByAddingIndex:trailingChildIndex];
|
|
targetExpression = [self.expressionStorage elementAtIndexPath:targetExpressionPath];
|
|
return [targetExpressionPath indexPathByAddingIndex:targetExpression.length];
|
|
}
|
|
}
|
|
} else if (locationInTarget > 0) {
|
|
if (selectWords) {
|
|
if (locationInElement == 0) {
|
|
targetElementIndex--;
|
|
}
|
|
locationInTarget = [targetExpression locationOfElementAtIndex:targetElementIndex];
|
|
} else {
|
|
locationInTarget--;
|
|
}
|
|
}
|
|
return [selectionPath indexPathByReplacingLastIndexWithIndex:locationInTarget];
|
|
}
|
|
|
|
- (MPRangePath *)rangePathEnclosingAnchorPath:(NSIndexPath *)anchorPath
|
|
newSelectionPath:(NSIndexPath *)newSelectionPath
|
|
{
|
|
if ([anchorPath isEqual:newSelectionPath]) {
|
|
return MPMakeRangePath(anchorPath, 0);
|
|
}
|
|
|
|
NSIndexPath *commonPath = [anchorPath commonIndexPathWith:newSelectionPath];
|
|
if (commonPath.length == anchorPath.length-1 && commonPath.length == newSelectionPath.length-1) {
|
|
// The two paths point to different locations in the same expression
|
|
NSUInteger anchorIndex = [anchorPath indexAtPosition:commonPath.length];
|
|
NSUInteger newIndex = [newSelectionPath indexAtPosition:commonPath.length];
|
|
NSUInteger minIndex = MIN(anchorIndex, newIndex);
|
|
NSUInteger length = MAX(anchorIndex, newIndex) - minIndex;
|
|
return MPMakeRangePath([commonPath indexPathByAddingIndex:minIndex], length);
|
|
} else {
|
|
if ((commonPath.length & 1) == 1) {
|
|
commonPath = [commonPath indexPathByRemovingLastIndex];
|
|
}
|
|
MPExpression *closestCommonAncestor = [self.expressionStorage elementAtIndexPath:commonPath];
|
|
NSUInteger anchorIndex = [anchorPath indexAtPosition:commonPath.length];
|
|
NSUInteger newIndex = [newSelectionPath indexAtPosition:commonPath.length];
|
|
|
|
if (commonPath.length < anchorPath.length-1) {
|
|
anchorIndex = [closestCommonAncestor locationOfElementAtIndex:anchorIndex];
|
|
}
|
|
if (commonPath.length < newSelectionPath.length-1) {
|
|
newIndex = [closestCommonAncestor locationOfElementAtIndex:newIndex];
|
|
}
|
|
|
|
NSUInteger minIndex = MIN(anchorIndex, newIndex);
|
|
if (commonPath.length < anchorPath.length-1 && anchorIndex != minIndex) {
|
|
anchorIndex++;
|
|
} else if (commonPath.length < newSelectionPath.length-1 && newIndex != minIndex) {
|
|
newIndex++;
|
|
}
|
|
|
|
NSUInteger length = MAX(anchorIndex, newIndex) - minIndex;
|
|
if (anchorIndex == newIndex) {
|
|
length++;
|
|
}
|
|
MPRangePath *newSelection = MPMakeRangePath([commonPath indexPathByAddingIndex:minIndex], length);
|
|
return newSelection;
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
|
|
@implementation MPExpressionView
|
|
|
|
#pragma mark Creation Methods
|
|
- (id)initWithFrame:(NSRect)frame
|
|
{
|
|
self = [super initWithFrame:frame];
|
|
if (self) {
|
|
[self initializeExpressionView];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (id)initWithCoder:(NSCoder *)aDecoder
|
|
{
|
|
self = [super initWithCoder:aDecoder];
|
|
if (self) {
|
|
[self initializeExpressionView];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)initializeExpressionView
|
|
{
|
|
// Setup the Expression Storage
|
|
MPExpressionStorage *expressionStorage = [[MPExpressionStorage alloc] initWithElements:@[@"12345", [[MPSumFunction alloc] init]]];
|
|
expressionStorage.expressionView = self;
|
|
_expressionStorage = expressionStorage;
|
|
|
|
// Setup the Functions Button
|
|
NSButton *button = [[NSButton alloc] initWithFrame:NSZeroRect];
|
|
button.buttonType = NSSwitchButton;
|
|
[button setTitle:@"Functions"];
|
|
self.functionsButton = button;
|
|
[self addSubview:self.functionsButton];
|
|
|
|
// Setup Selection
|
|
self.selection = [[MPRangePath alloc] initWithRange:NSMakeRange(0, 0)];
|
|
self.caretBlinkRate = 1.0;
|
|
[self restartCaretTimer];
|
|
}
|
|
|
|
#pragma mark Properties
|
|
- (void)setExpressionStorage:(MPExpressionStorage *)expressionStorage
|
|
{
|
|
_expressionStorage.expressionView = nil;
|
|
_expressionStorage = expressionStorage;;
|
|
_expressionStorage.expressionView = self;
|
|
[self invalidateIntrinsicContentSize];
|
|
}
|
|
|
|
- (void)setSelection:(MPRangePath *)selection
|
|
{
|
|
_selection = selection;
|
|
[self restartCaretTimer];
|
|
self.needsDisplay = YES;
|
|
}
|
|
|
|
#pragma mark NSView Stuff
|
|
- (BOOL)acceptsFirstResponder
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)canBecomeKeyView
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)isFlipped
|
|
{
|
|
return NO;
|
|
}
|
|
|
|
- (BOOL)isOpaque
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (void)layout
|
|
{
|
|
NSSize buttonSize = [self.functionsButton fittingSize];
|
|
self.functionsButton.frame = NSMakeRect(self.bounds.size.width - buttonSize.width,
|
|
(self.bounds.size.height - buttonSize.height) / 2,
|
|
buttonSize.width,
|
|
buttonSize.height);
|
|
[super layout];
|
|
}
|
|
|
|
- (NSSize)intrinsicContentSize
|
|
{
|
|
// return NSMakeSize(500, 500);
|
|
// return self.bounds.size;
|
|
return self.expressionStorage.rootLayout.bounds.size;
|
|
}
|
|
|
|
- (void)resetCursorRects
|
|
{
|
|
[self addCursorRect:self.bounds
|
|
cursor:[NSCursor IBeamCursor]];
|
|
}
|
|
|
|
#pragma mark Key Event Handling
|
|
- (void)keyDown:(NSEvent *)theEvent
|
|
{
|
|
NSString *characters = theEvent.characters;
|
|
NSMutableCharacterSet *allowedCharacters = [NSMutableCharacterSet alphanumericCharacterSet];
|
|
[allowedCharacters addCharactersInString:@"+-*= "];
|
|
if (characters.length == 1 && [characters stringByTrimmingCharactersInSet:allowedCharacters].length == 0) {
|
|
MPExpression *targetExpression = [self.expressionStorage elementAtIndexPath:[self.selection.location indexPathByRemovingLastIndex]];
|
|
[targetExpression replaceSymbolsInRange:self.selection.rangeAtLastIndex withElements:@[characters]];
|
|
self.selection = MPMakeRangePath([self.selection.location indexPathByIncrementingLastIndex], 0);
|
|
} else {
|
|
[self interpretKeyEvents:@[theEvent]];
|
|
}
|
|
}
|
|
|
|
- (void)insertNewline:(id)sender
|
|
{
|
|
if (self.target && self.action) {
|
|
[self.target performSelector:self.action
|
|
withObject:self
|
|
afterDelay:0.0];
|
|
}
|
|
}
|
|
|
|
- (void)moveRight:(id)sender
|
|
{
|
|
if (self.selection.length > 0) {
|
|
self.selection = MPMakeRangePath(self.selection.maxRangePath, 0);
|
|
} else {
|
|
NSIndexPath *newSelectionLocation = [self selectionToTheRightOf:self.selection.location
|
|
byExtendingSelection:NO
|
|
selectWords:NO];
|
|
self.selection = MPMakeRangePath(newSelectionLocation, 0);
|
|
}
|
|
}
|
|
|
|
- (void)moveLeft:(id)sender
|
|
{
|
|
if (self.selection.length > 0) {
|
|
self.selection = MPMakeRangePath(self.selection.location, 0);
|
|
} else {
|
|
NSIndexPath *newSelectionLocation = [self selectionToTheLeftOf:self.selection.location
|
|
byExtendingSelection:NO
|
|
selectWords:NO];
|
|
self.selection = MPMakeRangePath(newSelectionLocation, 0);
|
|
}
|
|
}
|
|
|
|
- (void)moveWordRight:(id)sender
|
|
{
|
|
NSIndexPath *location = self.selection.maxRangePath;
|
|
NSIndexPath *newSelectionLocation = [self selectionToTheRightOf:location
|
|
byExtendingSelection:NO
|
|
selectWords:YES];
|
|
self.selection = MPMakeRangePath(newSelectionLocation, 0);
|
|
}
|
|
|
|
- (void)moveWordLeft:(id)sender
|
|
{
|
|
NSIndexPath *location = self.selection.location;
|
|
NSIndexPath *newSelectionLocation = [self selectionToTheLeftOf:location
|
|
byExtendingSelection:NO
|
|
selectWords:YES];
|
|
self.selection = MPMakeRangePath(newSelectionLocation, 0);
|
|
}
|
|
|
|
- (void)moveToBeginningOfLine:(id)sender
|
|
{
|
|
self.selection = MPMakeRangePath([self.selection.location indexPathByReplacingLastIndexWithIndex:0], 0);
|
|
}
|
|
|
|
- (void)moveToEndOfLine:(id)sender
|
|
{
|
|
MPExpression *targetExpression = [self.expressionStorage elementAtIndexPath:[self.selection.location indexPathByRemovingLastIndex]];
|
|
self.selection = MPMakeRangePath([self.selection.location indexPathByReplacingLastIndexWithIndex:targetExpression.length], 0);
|
|
}
|
|
|
|
- (void)moveLeftAndModifySelection:(id)sender
|
|
{
|
|
if (self.selection.length == 0) {
|
|
self.selectionModifyingStart = YES;
|
|
}
|
|
NSIndexPath *location = self.selection.location;
|
|
NSIndexPath *maxLocation = self.selection.maxRangePath;
|
|
if (self.selectionModifyingStart) {
|
|
location = [self selectionToTheLeftOf:location
|
|
byExtendingSelection:YES
|
|
selectWords:NO];
|
|
} else {
|
|
maxLocation = [self selectionToTheLeftOf:maxLocation
|
|
byExtendingSelection:YES
|
|
selectWords:NO];
|
|
}
|
|
self.selection = [self rangePathEnclosingAnchorPath:maxLocation newSelectionPath:location];
|
|
}
|
|
|
|
- (void)moveRightAndModifySelection:(id)sender
|
|
{
|
|
if (self.selection.length == 0) {
|
|
self.selectionModifyingStart = NO;
|
|
}
|
|
NSIndexPath *location = self.selection.location;
|
|
NSIndexPath *maxLocation = self.selection.maxRangePath;
|
|
|
|
if (self.selectionModifyingStart) {
|
|
location = [self selectionToTheRightOf:location
|
|
byExtendingSelection:YES
|
|
selectWords:NO];
|
|
} else {
|
|
maxLocation = [self selectionToTheRightOf:maxLocation
|
|
byExtendingSelection:YES
|
|
selectWords:NO];
|
|
}
|
|
self.selection = MPMakeRangePath(location, maxLocation.lastIndex-location.lastIndex);
|
|
}
|
|
|
|
- (void)moveWordRightAndModifySelection:(id)sender
|
|
{
|
|
if (self.selection.length == 0) {
|
|
self.selectionModifyingStart = NO;
|
|
}
|
|
NSIndexPath *location = self.selection.location;
|
|
NSIndexPath *maxLocation = self.selection.maxRangePath;
|
|
if (self.selectionModifyingStart) {
|
|
location = [self selectionToTheRightOf:location
|
|
byExtendingSelection:YES
|
|
selectWords:YES];
|
|
if (location.lastIndex > maxLocation.lastIndex) {
|
|
location = [location indexPathByReplacingLastIndexWithIndex:maxLocation.lastIndex];
|
|
}
|
|
} else {
|
|
maxLocation = [self selectionToTheRightOf:maxLocation
|
|
byExtendingSelection:YES
|
|
selectWords:YES];
|
|
}
|
|
self.selection = MPMakeRangePath(location, maxLocation.lastIndex-location.lastIndex);
|
|
}
|
|
|
|
- (void)moveWordLeftAndModifySelection:(id)sender
|
|
{
|
|
if (self.selection.length == 0) {
|
|
self.selectionModifyingStart = YES;
|
|
}
|
|
NSIndexPath *location = self.selection.location;
|
|
NSIndexPath *maxLocation = self.selection.maxRangePath;
|
|
if (self.selectionModifyingStart) {
|
|
location = [self selectionToTheLeftOf:location
|
|
byExtendingSelection:YES
|
|
selectWords:YES];
|
|
} else {
|
|
maxLocation = [self selectionToTheLeftOf:maxLocation
|
|
byExtendingSelection:YES
|
|
selectWords:YES];
|
|
if (maxLocation.lastIndex < location.lastIndex) {
|
|
maxLocation = [maxLocation indexPathByReplacingLastIndexWithIndex:location.lastIndex];
|
|
}
|
|
}
|
|
self.selection = MPMakeRangePath(location, maxLocation.lastIndex-location.lastIndex);
|
|
}
|
|
|
|
- (void)selectAll:(id)sender
|
|
{
|
|
NSIndexPath *location = [NSIndexPath indexPathWithIndex:0];
|
|
self.selection = MPMakeRangePath(location, self.expressionStorage.length);
|
|
}
|
|
|
|
- (void)deleteBackward:(id)sender
|
|
{
|
|
MPExpression *targetExpression = [self.expressionStorage elementAtIndexPath:[self.selection.location indexPathByRemovingLastIndex]];
|
|
if (self.selection.length > 0) {
|
|
[targetExpression replaceSymbolsInRange:self.selection.rangeAtLastIndex withElements:@[]];
|
|
self.selection = MPMakeRangePath(self.selection.location, 0);
|
|
} else if (self.selection.location.lastIndex > 0) {
|
|
[targetExpression replaceSymbolsInRange:NSMakeRange(self.selection.location.lastIndex-1, 1) withElements:@[]];
|
|
self.selection = MPMakeRangePath([self.selection.location indexPathByDecrementingLastIndex], 0);
|
|
}
|
|
}
|
|
|
|
#pragma mark Mouse Event Handling
|
|
- (void)mouseDown:(NSEvent *)theEvent
|
|
{
|
|
NSPoint pointInView = [self convertPoint:theEvent.locationInWindow
|
|
fromView:nil];
|
|
NSPoint expressionOrigin = self.expressionOrigin;
|
|
pointInView.x -= expressionOrigin.x;
|
|
pointInView.y -= expressionOrigin.y;
|
|
NSIndexPath *selectionPath = [self.expressionStorage.rootLayout indexPathForMousePoint:pointInView];
|
|
self.mouseAnchor = selectionPath;
|
|
self.selection = MPMakeRangePath(selectionPath, 0);
|
|
}
|
|
|
|
- (void)mouseDragged:(NSEvent *)theEvent
|
|
{
|
|
NSPoint pointInView = [self convertPoint:theEvent.locationInWindow
|
|
fromView:nil];
|
|
NSPoint expressionOrigin = self.expressionOrigin;
|
|
pointInView.x -= expressionOrigin.x;
|
|
pointInView.y -= expressionOrigin.y;
|
|
NSIndexPath *mouseSelectionPath = [self.expressionStorage.rootLayout indexPathForMousePoint:pointInView];
|
|
|
|
self.selection = [self rangePathEnclosingAnchorPath:self.mouseAnchor
|
|
newSelectionPath:mouseSelectionPath];
|
|
}
|
|
|
|
#pragma mark Drawing Methods
|
|
- (void)drawRect:(NSRect)dirtyRect
|
|
{
|
|
// Draw the background
|
|
[super drawRect:dirtyRect];
|
|
[[NSColor whiteColor] set];
|
|
NSRectFill(dirtyRect);
|
|
|
|
// Calculate the position of the expression (probably also forces layout of the expression the first time)
|
|
NSPoint expressionOrigin = self.expressionOrigin;
|
|
|
|
// Draw the selection
|
|
if (self.caretVisible || self.selection.length > 0) {
|
|
if (self.selection.length == 0) {
|
|
[[NSColor blackColor] set];
|
|
} else {
|
|
[[NSColor selectedTextBackgroundColor] set];
|
|
}
|
|
NSAffineTransform *transform = [NSAffineTransform transform];
|
|
[transform translateXBy:expressionOrigin.x
|
|
yBy:expressionOrigin.y];
|
|
[transform concat];
|
|
NSRectFill([self selectionRect]);
|
|
[transform invert];
|
|
[transform concat];
|
|
}
|
|
|
|
// Draw the expression
|
|
[[NSColor textColor] set];
|
|
[self.expressionStorage.rootLayout drawAtPoint:expressionOrigin];
|
|
}
|
|
|
|
@end
|