You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
831 lines
30 KiB
831 lines
30 KiB
//
|
|
// PXSourceList.m
|
|
// PXSourceList
|
|
//
|
|
// Created by Alex Rozanski on 05/09/2009.
|
|
// Copyright 2009-10 Alex Rozanski http://perspx.com
|
|
//
|
|
// GC-enabled code revised by Stefan Vogt http://byteproject.net
|
|
//
|
|
|
|
#import "CompatibilityFixes.h"
|
|
#import "PXSourceList.h"
|
|
#import "SideBarItem.h"
|
|
|
|
//Layout constants
|
|
#define MIN_BADGE_WIDTH 22.0 //The minimum badge width for each item (default 22.0)
|
|
#define BADGE_HEIGHT 14.0 //The badge height for each item (default 14.0)
|
|
#define BADGE_MARGIN 5.0 //The spacing between the badge and the cell for that row
|
|
#define ROW_RIGHT_MARGIN 5.0 //The spacing between the right edge of the badge and the edge of the table column
|
|
#define ICON_SPACING 2.0 //The spacing between the icon and it's adjacent cell
|
|
#define DISCLOSURE_TRIANGLE_SPACE 18.0 //The indentation reserved for disclosure triangles for non-group items
|
|
|
|
//Drawing constants
|
|
#define BADGE_BACKGROUND_COLOR [NSColor colorWithCalibratedRed:(152/255.0) green:(168/255.0) blue:(202/255.0) alpha:1]
|
|
#define BADGE_HIDDEN_BACKGROUND_COLOR [NSColor colorWithDeviceWhite:(180/255.0) alpha:1]
|
|
#define BADGE_SELECTED_TEXT_COLOR [NSColor keyboardFocusIndicatorColor]
|
|
#define BADGE_SELECTED_UNFOCUSED_TEXT_COLOR [NSColor colorWithCalibratedRed:(153/255.0) green:(169/255.0) blue:(203/255.0) alpha:1]
|
|
#define BADGE_SELECTED_HIDDEN_TEXT_COLOR [NSColor colorWithCalibratedWhite:(170/255.0) alpha:1]
|
|
#define BADGE_FONT [NSFont boldSystemFontOfSize:11]
|
|
|
|
//Delegate notification constants
|
|
NSString * const PXSLSelectionIsChangingNotification = @"PXSourceListSelectionIsChanging";
|
|
NSString * const PXSLSelectionDidChangeNotification = @"PXSourceListSelectionDidChange";
|
|
NSString * const PXSLItemWillExpandNotification = @"PXSourceListItemWillExpand";
|
|
NSString * const PXSLItemDidExpandNotification = @"PXSourceListItemDidExpand";
|
|
NSString * const PXSLItemWillCollapseNotification = @"PXSourceListItemWillCollapse";
|
|
NSString * const PXSLItemDidCollapseNotification = @"PXSourceListItemDidCollapse";
|
|
NSString * const PXSLDeleteKeyPressedOnRowsNotification = @"PXSourceListDeleteKeyPressedOnRows";
|
|
|
|
#pragma mark -
|
|
@interface PXSourceList ()
|
|
|
|
- (NSSize)sizeOfBadgeAtRow:(NSInteger)rowIndex;
|
|
- (void)drawBadgeForRow:(NSInteger)rowIndex inRect:(NSRect)badgeFrame;
|
|
- (void)registerDelegateToReceiveNotification:(NSString*)notification withSelector:(SEL)selector;
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
@implementation PXSourceList
|
|
|
|
@dynamic dataSource;
|
|
@dynamic delegate;
|
|
|
|
#pragma mark Init/Dealloc/Finalize
|
|
|
|
- (id)initWithCoder:(NSCoder*)decoder
|
|
{
|
|
if(self=[super initWithCoder:decoder])
|
|
{
|
|
[self setDelegate:(id<PXSourceListDelegate, NSOutlineViewDelegate>)[super delegate]];
|
|
[super setDelegate:self];
|
|
[self setDataSource:(id<PXSourceListDataSource, NSOutlineViewDataSource>)[super dataSource]];
|
|
[super setDataSource:self];
|
|
|
|
_iconSize = NSMakeSize(16,16);
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
//Unregister the delegate from receiving notifications
|
|
[[NSNotificationCenter defaultCenter] removeObserver:_secondaryDelegate];
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Custom Accessors
|
|
|
|
- (void)setDelegate:(id<PXSourceListDelegate>)aDelegate
|
|
{
|
|
//Unregister the old delegate from receiving notifications
|
|
[[NSNotificationCenter defaultCenter] removeObserver:_secondaryDelegate name:nil object:self];
|
|
|
|
_secondaryDelegate = aDelegate;
|
|
//Register the new delegate to receive notifications
|
|
[self registerDelegateToReceiveNotification:PXSLSelectionIsChangingNotification withSelector:@selector(sourceListSelectionIsChanging:)];
|
|
[self registerDelegateToReceiveNotification:PXSLSelectionDidChangeNotification withSelector:@selector(sourceListSelectionDidChange:)];
|
|
[self registerDelegateToReceiveNotification:PXSLItemWillExpandNotification withSelector:@selector(sourceListItemWillExpand:)];
|
|
[self registerDelegateToReceiveNotification:PXSLItemDidExpandNotification withSelector:@selector(sourceListItemDidExpand:)];
|
|
[self registerDelegateToReceiveNotification:PXSLItemWillCollapseNotification withSelector:@selector(sourceListItemWillCollapse:)];
|
|
[self registerDelegateToReceiveNotification:PXSLItemDidCollapseNotification withSelector:@selector(sourceListItemDidCollapse:)];
|
|
[self registerDelegateToReceiveNotification:PXSLDeleteKeyPressedOnRowsNotification withSelector:@selector(sourceListDeleteKeyPressedOnRows:)];
|
|
}
|
|
|
|
|
|
- (void)setDataSource:(id<PXSourceListDataSource>)aDataSource
|
|
{
|
|
_secondaryDataSource = aDataSource;
|
|
|
|
if ([self respondsToSelector:@selector(reloadData)])
|
|
[self reloadData];
|
|
}
|
|
|
|
- (void)setIconSize:(NSSize)newIconSize
|
|
{
|
|
_iconSize = newIconSize;
|
|
CGFloat rowHeight = [self rowHeight];
|
|
|
|
//Make sure icon height does not exceed row height; if so constrain, keeping width and height in proportion
|
|
if(_iconSize.height>rowHeight)
|
|
{
|
|
_iconSize.width = _iconSize.width * (rowHeight/_iconSize.height);
|
|
_iconSize.height = rowHeight;
|
|
}
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Data Management
|
|
|
|
- (void)reloadData
|
|
{
|
|
if ([super respondsToSelector:@selector(reloadData)])
|
|
[super reloadData];
|
|
|
|
//Expand items that are displayed as always expanded
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)] &&
|
|
[_secondaryDelegate respondsToSelector:@selector(sourceList:isGroupAlwaysExpanded:)])
|
|
{
|
|
for(NSUInteger i=0;i<[self numberOfGroups];i++)
|
|
{
|
|
id item = [_secondaryDataSource sourceList:self child:i ofItem:nil];
|
|
|
|
if([self isGroupAlwaysExpanded:item]) {
|
|
[self expandItem:item expandChildren:NO];
|
|
}
|
|
}
|
|
}
|
|
|
|
//If there are selected rows and the item hierarchy has changed, make sure a Group row isn't
|
|
//selected
|
|
if([self numberOfSelectedRows]>0) {
|
|
NSIndexSet *selectedIndexes = [self selectedRowIndexes];
|
|
NSUInteger firstSelectedRow = [selectedIndexes firstIndex];
|
|
|
|
//Is a group item selected?
|
|
if([self isGroupItem:[self itemAtRow:firstSelectedRow]]) {
|
|
//Work backwards to find the first non-group row
|
|
BOOL foundRow = NO;
|
|
for(NSUInteger i=firstSelectedRow;i>0;i--)
|
|
{
|
|
if(![self isGroupItem:[self itemAtRow:i]]) {
|
|
[self selectRowIndexes:[NSIndexSet indexSetWithIndex:i] byExtendingSelection:NO];
|
|
foundRow = YES;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//If there is no non-group row preceding the currently selected group item, remove the selection
|
|
//from the Source List
|
|
if(!foundRow) {
|
|
[self deselectAll:self];
|
|
}
|
|
}
|
|
}
|
|
else if(![self allowsEmptySelection]&&[self numberOfSelectedRows]==0)
|
|
{
|
|
//Select the first non-group row if no rows are selected, and empty selection is disallowed
|
|
for(NSUInteger i=0;i<[self numberOfRows];i++)
|
|
{
|
|
if(![self isGroupItem:[self itemAtRow:i]]) {
|
|
[self selectRowIndexes:[NSIndexSet indexSetWithIndex:i] byExtendingSelection:NO];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (NSUInteger)numberOfGroups
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:numberOfChildrenOfItem:)]) {
|
|
return [_secondaryDataSource sourceList:self numberOfChildrenOfItem:nil];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
- (BOOL)isGroupItem:(id)item
|
|
{
|
|
//Groups are defined as root items (at level 0)
|
|
return 0==[self levelForItem:item];
|
|
}
|
|
|
|
|
|
- (BOOL)isGroupAlwaysExpanded:(id)group
|
|
{
|
|
//Make sure that the item IS a group to prevent unwanted queries sent to the data source
|
|
if([self isGroupItem:group]) {
|
|
//Query the data source
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:isGroupAlwaysExpanded:)]) {
|
|
return [_secondaryDelegate sourceList:self isGroupAlwaysExpanded:group];
|
|
}
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
|
|
- (BOOL)itemHasBadge:(id)item
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:itemHasBadge:)]) {
|
|
return [_secondaryDataSource sourceList:self itemHasBadge:item];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
- (NSInteger)badgeValueForItem:(id)item
|
|
{
|
|
//Make sure that the item has a badge
|
|
if(![self itemHasBadge:item]) {
|
|
return NSNotFound;
|
|
}
|
|
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:badgeValueForItem:)]) {
|
|
return [_secondaryDataSource sourceList:self badgeValueForItem:item];
|
|
}
|
|
|
|
return NSNotFound;
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Selection Handling
|
|
|
|
- (void)selectRowIndexes:(NSIndexSet*)indexes byExtendingSelection:(BOOL)extend
|
|
{
|
|
NSUInteger numberOfIndexes = [indexes count];
|
|
|
|
//Prevent empty selection if we don't want it
|
|
if(![self allowsEmptySelection]&&0==numberOfIndexes) {
|
|
return;
|
|
}
|
|
|
|
//Would use blocks but we're also targeting 10.5...
|
|
//Get the selected indexes
|
|
NSUInteger *selectedIndexes = malloc(sizeof(NSUInteger)*numberOfIndexes);
|
|
[indexes getIndexes:selectedIndexes maxCount:numberOfIndexes inIndexRange:nil];
|
|
|
|
//Loop through the indexes and only add non-group row indexes
|
|
//Allows selection across groups without selecting the group rows
|
|
NSMutableIndexSet *newSelectionIndexes = [NSMutableIndexSet indexSet];
|
|
for(NSInteger i=0;i<numberOfIndexes;i++)
|
|
{
|
|
if(![self isGroupItem:[self itemAtRow:selectedIndexes[i]]]) {
|
|
[newSelectionIndexes addIndex:selectedIndexes[i]];
|
|
}
|
|
}
|
|
|
|
//If there are any non-group rows selected
|
|
if([newSelectionIndexes count]>0) {
|
|
[super selectRowIndexes:newSelectionIndexes byExtendingSelection:extend];
|
|
}
|
|
|
|
//C memory management... *sigh*
|
|
free(selectedIndexes);
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Layout
|
|
|
|
- (NSRect)frameOfOutlineCellAtRow:(NSInteger)row
|
|
{
|
|
//Return a zero-rect if the item is always expanded (a disclosure triangle will not be drawn)
|
|
if([self isGroupAlwaysExpanded:[self itemAtRow:row]]) {
|
|
return NSZeroRect;
|
|
}
|
|
|
|
return [super frameOfOutlineCellAtRow:row];
|
|
}
|
|
|
|
|
|
- (NSRect)frameOfCellAtColumn:(NSInteger)column row:(NSInteger)row
|
|
{
|
|
id item = [self itemAtRow:row];
|
|
|
|
NSCell *cell = [self preparedCellAtColumn:column row:row];
|
|
NSSize cellSize = [cell cellSize];
|
|
if (!([cell type] == NSImageCellType) && !([cell type] == NSTextCellType))
|
|
cellSize = [cell cellSizeForBounds:[super frameOfCellAtColumn:column row:row]];
|
|
|
|
NSRect cellFrame = [super frameOfCellAtColumn:column row:row];
|
|
NSRect rowRect = [self rectOfRow:row];
|
|
|
|
if([self isGroupItem:item])
|
|
{
|
|
CGFloat minX = NSMinX(cellFrame);
|
|
|
|
//Set the origin x-coord; if there are no children of the group at current, there will still be a
|
|
//margin to the left of the cell (in cellFrame), which we don't want
|
|
if([self isGroupAlwaysExpanded:[self itemAtRow:row]]) {
|
|
minX = 7;
|
|
}
|
|
|
|
return NSMakeRect(minX, NSMidY(cellFrame)-(cellSize.height/2.0), NSWidth(rowRect)-minX, cellSize.height);
|
|
}
|
|
else
|
|
{
|
|
CGFloat leftIndent = ([self levelForRow:row] -1)*[self indentationPerLevel]+DISCLOSURE_TRIANGLE_SPACE;
|
|
|
|
//Calculate space left for a badge if need be
|
|
CGFloat rightIndent = [self sizeOfBadgeAtRow:row].width+ROW_RIGHT_MARGIN;
|
|
|
|
//Allow space for an icon if need be
|
|
if(![self isGroupItem:item]&&[_secondaryDataSource respondsToSelector:@selector(sourceList:itemHasIcon:)])
|
|
{
|
|
if([_secondaryDataSource sourceList:self itemHasIcon:item]) {
|
|
leftIndent += [self iconSize].width+(ICON_SPACING*2);
|
|
}
|
|
}
|
|
return NSMakeRect(leftIndent, NSMidY(rowRect)-(cellSize.height/2.0), NSWidth(rowRect)-rightIndent-leftIndent, cellSize.height);
|
|
}
|
|
}
|
|
|
|
|
|
//This method calculates and returns the size of the badge for the row index passed to the method. If the
|
|
//row for the row index passed to the method does not have a badge, then NSZeroSize is returned.
|
|
- (NSSize)sizeOfBadgeAtRow:(NSInteger)rowIndex
|
|
{
|
|
id rowItem = [self itemAtRow:rowIndex];
|
|
|
|
//Make sure that the item has a badge
|
|
if(![self itemHasBadge:rowItem]) {
|
|
return NSZeroSize;
|
|
}
|
|
|
|
NSAttributedString *badgeAttrString = [[NSAttributedString alloc] initWithString:[NSString stringWithFormat:@"%ld", [self badgeValueForItem:rowItem]] attributes:[NSDictionary dictionaryWithObjectsAndKeys:BADGE_FONT, NSFontAttributeName, nil]];
|
|
NSSize stringSize = [badgeAttrString size];
|
|
|
|
//Calculate the width needed to display the text or the minimum width if it's smaller
|
|
CGFloat width = stringSize.width+(2*BADGE_MARGIN);
|
|
|
|
if(width<MIN_BADGE_WIDTH) {
|
|
width = MIN_BADGE_WIDTH;
|
|
}
|
|
|
|
return NSMakeSize(width, BADGE_HEIGHT);
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
#pragma mark Drawing
|
|
|
|
- (void)drawRow:(NSInteger)rowIndex clipRect:(NSRect)clipRect
|
|
{
|
|
[super drawRow:rowIndex clipRect:clipRect];
|
|
id item = [self itemAtRow:rowIndex];
|
|
|
|
//Draw an icon if the item has one
|
|
if(![self isGroupItem:item]&&[_secondaryDataSource respondsToSelector:@selector(sourceList:itemHasIcon:)])
|
|
{
|
|
if([_secondaryDataSource sourceList:self itemHasIcon:item])
|
|
{
|
|
NSRect cellFrame = [self frameOfCellAtColumn:0 row:rowIndex];
|
|
NSSize iconSize = [self iconSize];
|
|
NSRect iconRect = NSMakeRect(NSMinX(cellFrame)-iconSize.width-ICON_SPACING, NSMidY(cellFrame)-(iconSize.width/2.0f), iconSize.width, iconSize.height);
|
|
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:iconForItem:)])
|
|
{
|
|
NSImage *icon = [_secondaryDataSource sourceList:self iconForItem:item];
|
|
if(icon!=nil)
|
|
{
|
|
NSSize actualIconSize = [icon size];
|
|
//If the icon is *smaller* than the size retrieved from the -iconSize property, make sure we
|
|
//reduce the size of the rectangle to draw the icon in, so that it is not stretched.
|
|
if((actualIconSize.width<iconSize.width)||(actualIconSize.height<iconSize.height))
|
|
{
|
|
iconRect = NSMakeRect(NSMidX(iconRect)-(actualIconSize.width/2.0f), NSMidY(iconRect)-(actualIconSize.height/2.0f), actualIconSize.width, actualIconSize.height);
|
|
}
|
|
|
|
[icon drawInRect:iconRect
|
|
fromRect:NSZeroRect
|
|
operation:NSCompositeSourceOver
|
|
fraction:1
|
|
respectFlipped:YES hints:nil];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Draw the badge if the item has one
|
|
if([self itemHasBadge:item])
|
|
{
|
|
NSRect rowRect = [self rectOfRow:rowIndex];
|
|
NSSize badgeSize = [self sizeOfBadgeAtRow:rowIndex];
|
|
|
|
NSRect badgeFrame = NSMakeRect(NSMaxX(rowRect)-badgeSize.width-ROW_RIGHT_MARGIN,
|
|
NSMidY(rowRect)-(badgeSize.height/2.0),
|
|
badgeSize.width,
|
|
badgeSize.height);
|
|
[self drawBadgeForRow:rowIndex inRect:badgeFrame];
|
|
}
|
|
}
|
|
|
|
- (void)drawBadgeForRow:(NSInteger)rowIndex inRect:(NSRect)badgeFrame
|
|
{
|
|
id rowItem = [self itemAtRow:rowIndex];
|
|
NSBezierPath *badgePath = [NSBezierPath bezierPathWithRoundedRect:badgeFrame
|
|
xRadius:(BADGE_HEIGHT/2.0)
|
|
yRadius:(BADGE_HEIGHT/2.0)];
|
|
|
|
//Get window and control state to determine colours used
|
|
BOOL isVisible = [[NSApp mainWindow] isVisible];
|
|
BOOL isFocused = [[[self window] firstResponder] isEqual:self];
|
|
NSInteger rowBeingEdited = [self editedRow];
|
|
|
|
//Set the attributes based on the row state
|
|
NSDictionary *attributes;
|
|
NSColor *backgroundColor;
|
|
|
|
if([[self selectedRowIndexes] containsIndex:rowIndex])
|
|
{
|
|
backgroundColor = [NSColor whiteColor];
|
|
//Set the text color based on window and control state
|
|
NSColor *textColor;
|
|
if(isVisible && (isFocused || rowBeingEdited==rowIndex)) {
|
|
textColor = BADGE_SELECTED_TEXT_COLOR;
|
|
}
|
|
else if(isVisible && !isFocused) {
|
|
textColor = BADGE_SELECTED_UNFOCUSED_TEXT_COLOR;
|
|
}
|
|
else {
|
|
textColor = BADGE_SELECTED_HIDDEN_TEXT_COLOR;
|
|
}
|
|
|
|
attributes = [[NSDictionary alloc] initWithObjectsAndKeys:BADGE_FONT, NSFontAttributeName, textColor, NSForegroundColorAttributeName, nil];
|
|
}
|
|
else
|
|
{
|
|
//Set the text colour based on window and control state
|
|
NSColor *badgeColor = [NSColor whiteColor];
|
|
|
|
if(isVisible) {
|
|
//If the data source returns a custom colour..
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:badgeBackgroundColorForItem:)]) {
|
|
backgroundColor = [_secondaryDataSource sourceList:self badgeBackgroundColorForItem:rowItem];
|
|
|
|
if(backgroundColor==nil)
|
|
backgroundColor = BADGE_BACKGROUND_COLOR;
|
|
}
|
|
else { //Otherwise use the default (purple-blue colour)
|
|
backgroundColor = BADGE_BACKGROUND_COLOR;
|
|
}
|
|
|
|
//If the delegate wants a custom badge text colour..
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:badgeTextColorForItem:)]) {
|
|
badgeColor = [_secondaryDataSource sourceList:self badgeTextColorForItem:rowItem];
|
|
|
|
if(badgeColor==nil)
|
|
badgeColor = [NSColor whiteColor];
|
|
}
|
|
}
|
|
else { //Gray colour
|
|
backgroundColor = BADGE_HIDDEN_BACKGROUND_COLOR;
|
|
}
|
|
attributes = [[NSDictionary alloc] initWithObjectsAndKeys:BADGE_FONT, NSFontAttributeName, badgeColor, NSForegroundColorAttributeName, nil];
|
|
}
|
|
|
|
[backgroundColor set];
|
|
[badgePath fill];
|
|
|
|
//Draw the badge text
|
|
NSAttributedString *badgeAttrString = [[NSAttributedString alloc] initWithString:[NSString stringWithFormat:@"%ld", [self badgeValueForItem:rowItem]] attributes:attributes];
|
|
|
|
NSSize stringSize = [badgeAttrString size];
|
|
NSPoint badgeTextPoint = NSMakePoint(NSMidX(badgeFrame)-(stringSize.width/2.0), //Center in the badge frame
|
|
NSMidY(badgeFrame)-(stringSize.height/2.0)); //Center in the badge frame
|
|
[badgeAttrString drawAtPoint:badgeTextPoint];
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Keyboard Handling
|
|
|
|
- (void)keyDown:(NSEvent *)theEvent
|
|
{
|
|
NSIndexSet *selectedIndexes = [self selectedRowIndexes];
|
|
NSString *keyCharacters = [theEvent characters];
|
|
|
|
//Make sure we have a selection
|
|
if([selectedIndexes count]>0)
|
|
{
|
|
if([keyCharacters length]>0)
|
|
{
|
|
unichar firstKey = [keyCharacters characterAtIndex:0];
|
|
if(firstKey==NSUpArrowFunctionKey||firstKey==NSDownArrowFunctionKey)
|
|
{
|
|
//Handle keyboard navigation across groups
|
|
if([selectedIndexes count]==1&&!([theEvent modifierFlags] & NSShiftKeyMask))
|
|
{
|
|
int delta = firstKey==NSDownArrowFunctionKey?1:-1;
|
|
//Search "backwards" if up arrow, "forwards" if down
|
|
|
|
NSInteger newRow = [selectedIndexes firstIndex];
|
|
//Keep incrementing/decrementing the row until a non-header row is reached
|
|
do {
|
|
newRow+=delta;
|
|
|
|
//If out of bounds of the number of rows..
|
|
if(newRow<0||newRow==[self numberOfRows])
|
|
break;
|
|
} while([self isGroupItem:[self itemAtRow:newRow]]);
|
|
|
|
[self selectRowIndexes:[NSIndexSet indexSetWithIndex:newRow] byExtendingSelection:NO];
|
|
|
|
return;
|
|
}
|
|
}
|
|
else if(firstKey==NSDeleteCharacter||firstKey==NSBackspaceCharacter)
|
|
{
|
|
//Post the notification
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLDeleteKeyPressedOnRowsNotification object:self userInfo:[NSDictionary dictionaryWithObject:selectedIndexes forKey:@"rows"]];
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//We don't care about it
|
|
[super keyDown:theEvent];
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Menu Handling
|
|
|
|
|
|
- (NSMenu *)menuForEvent:(NSEvent *)theEvent
|
|
{
|
|
NSMenu * m = nil;
|
|
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:menuForEvent:item:)]) {
|
|
NSPoint clickPoint = [self convertPoint:[theEvent locationInWindow] fromView:nil];
|
|
NSInteger row = [self rowAtPoint:clickPoint];
|
|
id clickedItem = [self itemAtRow:row];
|
|
|
|
if ([clickedItem sdtype] > 0)
|
|
m = [_secondaryDelegate sourceList:self menuForEvent:theEvent item:clickedItem];
|
|
else
|
|
m = [super menuForEvent:theEvent];
|
|
}
|
|
|
|
if (m == nil) {
|
|
m = [super menuForEvent:theEvent];
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark NSOutlineView Data Source methods
|
|
|
|
- (NSInteger)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item
|
|
{
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)]) {
|
|
return [_secondaryDataSource sourceList:self numberOfChildrenOfItem:item];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
- (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item
|
|
{
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)]) {
|
|
return [_secondaryDataSource sourceList:self child:index ofItem:item];
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
|
|
{
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)]) {
|
|
return [_secondaryDataSource sourceList:self isItemExpandable:item];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
|
|
- (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)tableColumn byItem:(id)item
|
|
{
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)]) {
|
|
return [_secondaryDataSource sourceList:self objectValueForItem:item];
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
|
|
- (void)outlineView:(NSOutlineView *)outlineView setObjectValue:(id)object forTableColumn:(NSTableColumn *)tableColumn byItem:(id)item
|
|
{
|
|
if([_secondaryDataSource conformsToProtocol:@protocol(PXSourceListDataSource)]) {
|
|
[_secondaryDataSource sourceList:self setObjectValue:object forItem:item];
|
|
}
|
|
}
|
|
|
|
|
|
- (id)outlineView:(NSOutlineView *)outlineView itemForPersistentObject:(id)object
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:itemForPersistentObject:)]) {
|
|
return [_secondaryDataSource sourceList:self itemForPersistentObject:object];
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (id)outlineView:(NSOutlineView *)outlineView persistentObjectForItem:(id)item
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:persistentObjectForItem:)]) {
|
|
return [_secondaryDataSource sourceList:self persistentObjectForItem:item];
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pasteboard
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:writeItems:toPasteboard:)]) {
|
|
return [_secondaryDataSource sourceList:self writeItems:items toPasteboard:pasteboard];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
- (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(NSInteger)index
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:validateDrop:proposedItem:proposedChildIndex:)]) {
|
|
return [_secondaryDataSource sourceList:self validateDrop:info proposedItem:item proposedChildIndex:index];
|
|
}
|
|
|
|
return NSDragOperationNone;
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView acceptDrop:(id <NSDraggingInfo>)info item:(id)item childIndex:(NSInteger)index
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:acceptDrop:item:childIndex:)]) {
|
|
return [_secondaryDataSource sourceList:self acceptDrop:info item:item childIndex:index];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
- (NSArray *)outlineView:(NSOutlineView *)outlineView namesOfPromisedFilesDroppedAtDestination:(NSURL *)dropDestination forDraggedItems:(NSArray *)items
|
|
{
|
|
if([_secondaryDataSource respondsToSelector:@selector(sourceList:namesOfPromisedFilesDroppedAtDestination:forDraggedItems:)]) {
|
|
return [_secondaryDataSource sourceList:self namesOfPromisedFilesDroppedAtDestination:dropDestination forDraggedItems:items];
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
#pragma mark NSOutlineView Delegate methods
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView shouldExpandItem:(id)item
|
|
{
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:shouldExpandItem:)]) {
|
|
return [_secondaryDelegate sourceList:self shouldExpandItem:item];
|
|
}
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView shouldCollapseItem:(id)item
|
|
{
|
|
//Make sure the item isn't displayed as always expanded
|
|
if([self isGroupItem:item])
|
|
{
|
|
if([self isGroupAlwaysExpanded:item]) {
|
|
return NO;
|
|
}
|
|
}
|
|
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:shouldCollapseItem:)]) {
|
|
return [_secondaryDelegate sourceList:self shouldCollapseItem:item];
|
|
}
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (NSCell *)outlineView:(NSOutlineView *)outlineView dataCellForTableColumn:(NSTableColumn *)tableColumn item:(id)item
|
|
{
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:dataCellForItem:)]) {
|
|
return [_secondaryDelegate sourceList:self dataCellForItem:item];
|
|
}
|
|
|
|
NSInteger row = [self rowForItem:item];
|
|
|
|
//Return the default table column
|
|
return [[[self tableColumns] firstObject] dataCellForRow:row];
|
|
}
|
|
|
|
- (void)outlineView:(NSOutlineView *)outlineView willDisplayCell:(id)cell forTableColumn:(NSTableColumn *)tableColumn item:(id)item
|
|
{
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:willDisplayCell:forItem:)]) {
|
|
[_secondaryDelegate sourceList:self willDisplayCell:cell forItem:item];
|
|
}
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView shouldSelectItem:(id)item
|
|
{
|
|
//Make sure that the item isn't a group as they can't be selected
|
|
if(![self isGroupItem:item]) {
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:shouldSelectItem:)]) {
|
|
return [_secondaryDelegate sourceList:self shouldSelectItem:item];
|
|
}
|
|
}
|
|
else {
|
|
return NO;
|
|
}
|
|
|
|
return YES;
|
|
}
|
|
|
|
|
|
- (NSIndexSet *)outlineView:(NSOutlineView *)outlineView selectionIndexesForProposedSelection:(NSIndexSet *)proposedSelectionIndexes
|
|
{
|
|
//The outline view will try to select the first row if -[allowsEmptySelection:] is set to NO – if this is a group row
|
|
//stop it from doing so and leave it to our implementation of-[reloadData] which will select the first non-group row
|
|
//for us.
|
|
if([self numberOfSelectedRows]==0) {
|
|
if([self isGroupItem:[self itemAtRow:[proposedSelectionIndexes firstIndex]]]) {
|
|
return [NSIndexSet indexSet];
|
|
}
|
|
}
|
|
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:selectionIndexesForProposedSelection:)]) {
|
|
return [_secondaryDelegate sourceList:self selectionIndexesForProposedSelection:proposedSelectionIndexes];
|
|
}
|
|
|
|
//Since we implement this method, something must be returned to the outline view
|
|
return proposedSelectionIndexes;
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView shouldEditTableColumn:(NSTableColumn *)tableColumn item:(id)item
|
|
{
|
|
//Group titles can't be edited
|
|
if([self isGroupItem:item])
|
|
return NO;
|
|
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:shouldEditItem:)]) {
|
|
return [_secondaryDelegate sourceList:self shouldEditItem:item];
|
|
}
|
|
|
|
return YES;
|
|
}
|
|
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView shouldTrackCell:(NSCell *)cell forTableColumn:(NSTableColumn *)tableColumn item:(id)item
|
|
{
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:shouldTrackCell:forItem:)]) {
|
|
return [_secondaryDelegate sourceList:self shouldTrackCell:cell forItem:item];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
- (CGFloat)outlineView:(NSOutlineView *)outlineView heightOfRowByItem:(id)item
|
|
{
|
|
if([_secondaryDelegate respondsToSelector:@selector(sourceList:heightOfRowByItem:)]) {
|
|
return [_secondaryDelegate sourceList:self heightOfRowByItem:item];
|
|
}
|
|
|
|
return [self rowHeight];
|
|
}
|
|
|
|
- (BOOL)outlineView:(NSOutlineView *)outlineView isGroupItem:(id)item
|
|
{
|
|
return [self isGroupItem:item];
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Notification handling
|
|
|
|
/* Notification wrappers */
|
|
- (void)outlineViewSelectionIsChanging:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLSelectionIsChangingNotification object:self];
|
|
}
|
|
|
|
|
|
- (void)outlineViewSelectionDidChange:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLSelectionDidChangeNotification object:self];
|
|
}
|
|
|
|
- (void)outlineViewItemWillExpand:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLItemWillExpandNotification object:self userInfo:[notification userInfo]];
|
|
}
|
|
|
|
- (void)outlineViewItemDidExpand:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLItemDidExpandNotification object:self userInfo:[notification userInfo]];
|
|
}
|
|
|
|
- (void)outlineViewItemWillCollapse:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLItemWillCollapseNotification object:self userInfo:[notification userInfo]];
|
|
}
|
|
|
|
- (void)outlineViewItemDidCollapse:(NSNotification *)notification
|
|
{
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:PXSLItemDidCollapseNotification object:self userInfo:[notification userInfo]];
|
|
}
|
|
|
|
- (void)registerDelegateToReceiveNotification:(NSString*)notification withSelector:(SEL)selector
|
|
{
|
|
NSNotificationCenter *defaultCenter = [NSNotificationCenter defaultCenter];
|
|
|
|
//Set the delegate as a receiver of the notification if it implements the notification method
|
|
if([_secondaryDelegate respondsToSelector:selector]) {
|
|
[defaultCenter addObserver:_secondaryDelegate selector:selector name:notification object:self];
|
|
}
|
|
}
|
|
|
|
@end
|
|
|