Breakpoint KVO fixes.

Author: stefanceriu

SCXcodeMinimap/IDEBreakpointManager+SCXcodeMinimap.h

@@ -8,11 +8,23 @@
 
 #import "IDEBreakpointManager.h"
 
+typedef void (^SCKVONotificationBlock)(id object, NSDictionary *change);
+
+@interface SCKVOController : NSObject
+
+- (void)observeObject:(id)object forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(SCKVONotificationBlock)block;
+- (void)unobserveObject:(id)object forKeyPath:(NSString *)keyPath;
+- (void)unobserveObject:(id)object;
+- (void)unobserveAll;
+
+@end
+
 @protocol IDEBreakpointManagerDelegate;
 
 @interface IDEBreakpointManager (SCXcodeMinimap)
 
 @property (nonatomic, weak) id<IDEBreakpointManagerDelegate> delegate;
+@property (nonatomic, strong) SCKVOController *kvoController;
 
 @end
 

SCXcodeMinimap/IDEBreakpointManager+SCXcodeMinimap.m

@@ -10,8 +10,6 @@
 #import "IDEFileBreakpoint.h"
 #import <objc/runtime.h>
 
-static void *SCXcodeMinimapBreakpointObserverContext = &SCXcodeMinimapBreakpointObserverContext;
-
 @implementation IDEBreakpointManager (SCXcodeMinimap)
 
 static void sc_swizzleInstanceMethod(Class class, SEL originalSelector, SEL swizzledSelector) {
@@ -26,6 +24,7 @@ static void sc_swizzleInstanceMethod(Class class, SEL originalSelector, SEL swiz
 
 + (void)load
 {
+	sc_swizzleInstanceMethod(self, @selector(_handleWorkspaceContainerRemoved:), @selector(sc_handleWorkspaceContainerRemoved:));
 	sc_swizzleInstanceMethod(self, @selector(addBreakpoint:), @selector(sc_addBreakpoint:));
 	sc_swizzleInstanceMethod(self, @selector(removeBreakpoint:), @selector(sc_removeBreakpoint:));
 }
@@ -40,14 +39,39 @@ - (void)setDelegate:(id<IDEBreakpointManagerDelegate>)delegate
 	return objc_getAssociatedObject(self, @selector(delegate));
 }
 
+- (void)setKvoController:(SCKVOController *)kvoController
+{
+	objc_setAssociatedObject(self, @selector(kvoController), kvoController, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (SCKVOController *)kvoController
+{
+	SCKVOController *kvoController = objc_getAssociatedObject(self, @selector(kvoController));
+	
+	if(kvoController == nil) {
+		kvoController = [[SCKVOController alloc] init];
+		[self setKvoController:kvoController];
+		
+		for(IDEBreakpoint *breakpoint in self.breakpoints) {
+			if([breakpoint isKindOfClass:[IDEFileBreakpoint class]]) {
+				[self _observeBreakpoint:breakpoint];
+			}
+		}
+	}
+	
+	return kvoController;
+}
+
+- (void)sc_handleWorkspaceContainerRemoved:(id)arg1
+{
+	[self.kvoController unobserveAll];
+}
+
 - (void)sc_addBreakpoint:(IDEBreakpoint *)breakpoint
 {
 	[self sc_addBreakpoint:breakpoint];
 
-	if([breakpoint isKindOfClass:[IDEFileBreakpoint class]]) {
-		[breakpoint addObserver:self forKeyPath:@"location" options:NSKeyValueObservingOptionNew context:SCXcodeMinimapBreakpointObserverContext];
-		[breakpoint addObserver:self forKeyPath:@"shouldBeEnabled" options:NSKeyValueObservingOptionNew context:SCXcodeMinimapBreakpointObserverContext];
-	}
+	[self _observeBreakpoint:breakpoint];
 
 	if([self.delegate respondsToSelector:@selector(breakpointManagerDidAddBreakpoint:)]) {
 		[self.delegate breakpointManagerDidAddBreakpoint:self];
@@ -56,10 +80,7 @@ - (void)sc_addBreakpoint:(IDEBreakpoint *)breakpoint
 
 - (void)sc_removeBreakpoint:(IDEBreakpoint *)breakpoint
 {
-	if([breakpoint isKindOfClass:[IDEFileBreakpoint class]]) {
-		[breakpoint removeObserver:self forKeyPath:@"location" context:SCXcodeMinimapBreakpointObserverContext];
-		[breakpoint removeObserver:self forKeyPath:@"shouldBeEnabled" context:SCXcodeMinimapBreakpointObserverContext];
-	}
+	[self.kvoController unobserveObject:breakpoint];
 
 	[self sc_removeBreakpoint:breakpoint];
 
@@ -68,13 +89,178 @@ - (void)sc_removeBreakpoint:(IDEBreakpoint *)breakpoint
 	}
 }
 
-- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+- (void)_observeBreakpoint:(IDEBreakpoint *)breakpoint
 {
-	if(context == SCXcodeMinimapBreakpointObserverContext) {
+	[self.kvoController observeObject:breakpoint forKeyPath:@"location" options:NSKeyValueObservingOptionNew block:^(id object, NSDictionary *change) {
+		if([self.delegate respondsToSelector:@selector(breakpointManagerDidChangeBreakpoint:)]) {
+			[self.delegate breakpointManagerDidChangeBreakpoint:self];
+		}
+	}];
+	
+	[self.kvoController observeObject:breakpoint forKeyPath:@"shouldBeEnabled" options:NSKeyValueObservingOptionNew block:^(id object, NSDictionary *change) {
 		if([self.delegate respondsToSelector:@selector(breakpointManagerDidChangeBreakpoint:)]) {
 			[self.delegate breakpointManagerDidChangeBreakpoint:self];
 		}
+	}];
+}
+
+@end
+
+
+@interface SCKVOKeyPathInfo : NSObject
+
+@property (nonatomic, strong) NSMutableSet *blocks;
+
+@end
+
+
+@interface SCKVOInfo : NSObject
+
+@property (nonatomic, weak) id observer;
+@property (nonatomic, strong) NSMutableDictionary *keyPathInfos;
+
+- (instancetype)initWithObserver:(id)observer;
+
+@end
+
+
+@interface SCKVOController()
+
+@property (nonatomic, strong) NSMapTable *mapTable;
+
+@end
+
+
+@implementation SCKVOController
+
+- (void)dealloc
+{
+	[self unobserveAll];
+}
+
+- (void)observeObject:(id)object forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(SCKVONotificationBlock)block
+{
+	NSParameterAssert(object);
+	NSParameterAssert(keyPath);
+	NSParameterAssert(block);
+	
+	SCKVOInfo *info = [self.mapTable objectForKey:object];
+	
+	if (!info) {
+		info = [[SCKVOInfo alloc] initWithObserver:object];
+		[self.mapTable setObject:info forKey:object];
+	}
+	
+	SCKVOKeyPathInfo *kvoKeyPathInfo = [info.keyPathInfos objectForKey:keyPath];
+	
+	BOOL registerObserver = NO;
+	
+	if (!kvoKeyPathInfo) {
+		kvoKeyPathInfo = [[SCKVOKeyPathInfo alloc] init];
+		[info.keyPathInfos setValue:kvoKeyPathInfo forKey:keyPath];
+		registerObserver = YES;
+	}
+	
+	[kvoKeyPathInfo.blocks addObject:[block copy]];
+	
+	if (registerObserver) {
+		[object addObserver:self forKeyPath:keyPath options:options context:NULL];
+	}
+}
+
+- (void)unobserveObject:(id)object forKeyPath:(NSString *)keyPath
+{
+	NSParameterAssert(object);
+	NSParameterAssert(keyPath);
+	
+	SCKVOInfo *info = [self.mapTable objectForKey:object];
+	
+	if (info) {
+		if (info.keyPathInfos[keyPath]) {
+			[info.keyPathInfos removeObjectForKey:keyPath];
+			[object removeObserver:self forKeyPath:keyPath context:NULL];
+			
+			if (info.keyPathInfos.count == 0) {
+				[self.mapTable removeObjectForKey:object];
+			}
+		}
+	}
+}
+
+- (void)unobserveObject:(id)object
+{
+	NSParameterAssert(object);
+	
+	SCKVOInfo *info = [self.mapTable objectForKey:object];
+	if (info) {
+		for (NSString *keyPath in [info.keyPathInfos allKeys]) {
+			[self unobserveObject:object forKeyPath:keyPath];
+		}
+	}
+}
+
+- (void)unobserveAll
+{
+	NSMapTable *mapTable = [self.mapTable copy];
+	
+	for (id object in mapTable) {
+		[self unobserveObject:object];
+	}
+}
+
+- (NSMapTable *)mapTable
+{
+	if (!_mapTable) {
+		_mapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory|NSPointerFunctionsObjectPointerPersonality valueOptions:NSPointerFunctionsStrongMemory|NSPointerFunctionsObjectPersonality];
+	}
+	
+	return _mapTable;
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+					  ofObject:(id)object
+						change:(NSDictionary *)change
+					   context:(void *)context
+{
+	SCKVOInfo *info = [self.mapTable objectForKey:object];
+	
+	if (info) {
+		SCKVOKeyPathInfo *kvoKeyPathInfo = [info.keyPathInfos objectForKey:keyPath];
+		
+		if (kvoKeyPathInfo) {
+			for (SCKVONotificationBlock block in  kvoKeyPathInfo.blocks) {
+				block(object, change);
+			}
+		}
+	}
+}
+
+@end
+
+
+@implementation SCKVOKeyPathInfo
+
+- (instancetype)init
+{
+	if (self = [super init]) {
+		self.blocks = [NSMutableSet set];
+	}
+	
+	return self;
+}
+
+@end
+
+
+@implementation SCKVOInfo
+
+- (instancetype)initWithObserver:(id)observer
+{
+	if (self = [super init]) {
+		self.observer = observer;
+		self.keyPathInfos = [NSMutableDictionary dictionary];
 	}
+	return self;
 }
 
 @end

SCXcodeMinimap/SCXcodeMinimapView.m

@@ -228,6 +228,7 @@ - (NSDictionary *)layoutManager:(NSLayoutManager *)layoutManager
 
 	// Delay invalidation for performance reasons and attempt a full range invalidation later
 	if(!self.shouldAllowFullSyntaxHighlight && ![layoutManager isEqual:self.editorTextView.layoutManager]) {
+		
 		[NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(invalidateDisplayForVisibleMinimapRange) object:nil];
 		[self performSelector:@selector(invalidateDisplayForVisibleMinimapRange) withObject:nil afterDelay:kDurationBetweenInvalidations];
 
@@ -303,7 +304,7 @@ - (void)foldingManager:(DVTFoldingManager *)foldingManager didUnfoldRange:(NSRan
 	[self invalidateLayoutForVisibleMinimapRange];
 }
 
-#pragma makr - IDEBreakpointManagerDelegate
+#pragma mark - IDEBreakpointManagerDelegate
 
 - (void)breakpointManagerDidAddBreakpoint:(IDEBreakpointManager *)breakpointManager
 {
@@ -342,7 +343,7 @@ - (void)updateBreakpoints
 
 				if([fileBreakpoint.documentURL isEqualTo:self.editor.document.fileURL] && fileBreakpoint.location.startingLineNumber == lineNumber) {
 					[self.breakpointDictionaries addObject:@{kBreakpointRangeKey : [NSValue valueWithRange:lineRange],
-															 kBreakpointEnabledKey : @(fileBreakpoint.shouldBeEnabled)}];
+															 kBreakpointEnabledKey : @(fileBreakpoint.shouldBeEnabled && breakpointManager.breakpointsActivated)}];
 				}
 			}
 		}
@@ -351,6 +352,11 @@ - (void)updateBreakpoints
 	}
 
 	[self invalidateDisplayForVisibleMinimapRange];
+	
+	BOOL editorHighlightingEnabled = [[[NSUserDefaults standardUserDefaults] objectForKey:SCXcodeMinimapShouldHighlightEditorKey] boolValue];
+	if(editorHighlightingEnabled) {
+		[self invalidateDisplayForVisibleEditorRange];
+	}
 }
 
 #pragma mark - Navigation
@@ -417,7 +423,6 @@ - (void)updateTheme
 {
 	self.editorTheme = [self minimapThemeWithTheme:[DVTFontAndColorTheme currentTheme]];
 
-	
 	DVTPreferenceSetManager *preferenceSetManager = [DVTFontAndColorTheme preferenceSetsManager];
 	NSArray *preferenceSet = [preferenceSetManager availablePreferenceSets];
 
@@ -487,6 +492,7 @@ - (void)resizeWithOldSuperviewSize:(NSSize)oldSize
 - (void)invalidateDisplayForVisibleMinimapRange
 {
 	self.shouldAllowFullSyntaxHighlight = YES;
+	
 	NSRange visibleMinimapRange = [self.textView visibleCharacterRange];
 	[self.textView.layoutManager invalidateDisplayForCharacterRange:visibleMinimapRange];
 }