RBSplitView Class Reference

#include <RBSplitView.h>

Inheritance diagram for RBSplitView:

Collaboration diagram for RBSplitView:

Instance Methods
(void)	- setAutosaveName:recursively:
(NSString *)	- autosaveName
(BOOL)	- saveState:
(BOOL)	- restoreState:
(NSString *)	- stringWithSavedState
(BOOL)	- setStateFromString:
(NSArray *)	- arrayWithStates
(BOOL)	- setStatesFromArray:
(id)	- initWithFrame:
(id)	- initWithFrame:andSubviews:
(void)	- setDelegate:
(id)	- delegate
(RBSplitSubview *)	- subviewWithIdentifier:
(RBSplitSubview *)	- subviewAtPosition:
(void)	- addSubview:atPosition:
(void)	- setDividerThickness:
(CGFloat)	- dividerThickness
(void)	- setDivider:
(NSImage *)	- divider
(void)	- setBackground:
(NSColor *)	- background
(void)	- setVertical:
(BOOL)	- isVertical
(void)	- setHorizontal:
(BOOL)	- isHorizontal
(void)	- setMustAdjust
(BOOL)	- mustAdjust
(BOOL)	- isAdjusting
(BOOL)	- isDragging
(BOOL)	- isInScrollView
(void)	- adjustSubviews
(void)	- adjustSubviewsExcepting:
(void)	- drawDivider:inRect:betweenView:andView:
(void)	- dealloc [implementation]
(void)	- setCoupled: [implementation]
(RBSplitView *)	- couplingSplitView [implementation]
(RBSplitView *)	- asSplitView [implementation]
(RBSplitView *)	- coupledSplitView [implementation]
(BOOL)	- mouseDownCanMoveWindow [implementation]
(BOOL)	- isFlipped [implementation]
(BOOL)	- acceptsFirstMouse: [implementation]
(BOOL)	- shouldDelayWindowOrderingForEvent: [implementation]
(BOOL)	- isOpaque [implementation]
(NSString *)	- description [implementation]
(void)	- addSubview: [implementation]
(void)	- addSubview:positioned:relativeTo: [implementation]
(void)	- viewDidMoveToSuperview [implementation]
(void)	- willRemoveSubview: [implementation]
(BOOL)	- autoresizesSubviews [implementation]
(void)	- setFrameSize: [implementation]
(void)	- mouseDown: [implementation]
(BOOL)	- needsDisplay [implementation]
(void)	- awakeFromNib [implementation]
(void)	- display [implementation]
(void)	- drawRect: [implementation]
(void)	- resetCursorRects [implementation]
(void)	- encodeWithCoder: [implementation]
(id)	- initWithCoder: [implementation]
(void)	- RB___adjustOutermostIfNeeded [implementation]
(void)	- RB___setDragging: [implementation]
(CGFloat)	- RB___dividerOrigin: [implementation]
(NSArray *)	- RB___subviews [implementation]
(NSUInteger)	- RB___numberOfSubviews [implementation]
(void)	- RB___adjustSubviewsExcepting: [implementation]
(CGFloat)	- RB___dimensionWithoutDividers [implementation]
(CGFloat)	- RB___dividerThickness [implementation]
(NSRect)	- RB___dividerRect:relativeToView: [implementation]
(void)	- RB___setMustClearFractions [implementation]
(BOOL)	- RB___shouldResizeWindowForDivider:betweenView:andView:willGrow: [implementation]
(void)	- RB___tryToExpandLeading:divider:trailing:delta: [implementation]
(void)	- RB___tryToShortenLeading:divider:trailing:delta:always: [implementation]
(void)	- RB___tryToExpandTrailing:leading:delta: [implementation]
(void)	- RB___tryToShortenTrailing:divider:leading:delta:always: [implementation]
(void)	- RB___trackMouseEvent:from:withBase:inDivider: [implementation]
(void)	- RB___addCursorRectsTo:forDividerRect:thickness: [implementation]
(NSUInteger)	- RB___dividerHitBy:relativeToView:thickness: [implementation]
(void)	- RB___drawDividersIn:forDividerRect:thickness: [implementation]
Instance Methods inherited from RBSplitSubview
(RBSplitView *)	- splitView
(RBSplitView *)	- outermostSplitView
(BOOL)	- isCoupled
(BOOL)	- splitViewIsHorizontal
(NSUInteger)	- numberOfSubviews
(void)	- setTag:
(NSInteger)	- tag
(void)	- setIdentifier:
(NSString *)	- identifier
(NSUInteger)	- position
(void)	- setPosition:
(BOOL)	- isCollapsed
(RBSSubviewStatus)	- status
(BOOL)	- canCollapse
(void)	- setCanCollapse:
(BOOL)	- canShrink
(BOOL)	- canExpand
(CGFloat)	- minDimension
(CGFloat)	- maxDimension
(void)	- setMinDimension:andMaxDimension:
(CGFloat)	- expand
(CGFloat)	- collapse
(BOOL)	- collapseWithAnimation
(BOOL)	- expandWithAnimation
(BOOL)	- collapseWithAnimation:withResize:
(BOOL)	- expandWithAnimation:withResize:
(CGFloat)	- dimension
(void)	- setDimension:
(CGFloat)	- changeDimensionBy:mayCollapse:move:
(void)	- setHidden: [implementation]
(BOOL)	- acceptsFirstResponder [implementation]
(void)	- setAutoresizesSubviews: [implementation]
(void)	- resizeSubviewsWithOldSize: [implementation]
(NSView *)	- hitTest: [implementation]
(void)	- RB___setHidden: [implementation]
(animationData *)	- RB___animationData:resize: [implementation]
(void)	- RB___stepAnimation [implementation]
(BOOL)	- RB___stopAnimation [implementation]
(CGFloat)	- RB___visibleDimension [implementation]
(CGFloat)	- RB___setMinAndMaxTo:savingMin:andMax: [implementation]
(CGFloat)	- RB___collapse [implementation]
(CGFloat)	- RB___expandAndSetToMinimum: [implementation]
(void)	- RB___finishCollapse:withFraction: [implementation]
(void)	- RB___finishExpand:withFraction: [implementation]
(void)	- RB___setFrameSize:withFraction: [implementation]
(void)	- RB___setFrame:withFraction:notify: [implementation]
(double)	- RB___fraction [implementation]
(void)	- RB___copyIntoCache: [implementation]
(void)	- RB___updateFromCache:withTotalDimension: [implementation]
(BOOL)	- RB___clearResponder [implementation]

Class Methods
(NSCursor *)	+ cursor:
(void)	+ setCursor:toCursor:
(void)	+ removeStateUsingName:
(NSString *)	+ defaultsKeyForName:isHorizontal:
Class Methods inherited from RBSplitSubview
(BOOL)	+ animating

Protected Attributes
IBOutlet id	delegate
NSString *	autosaveName
NSColor *	background
NSImage *	divider
NSRect *	dividers
CGFloat	dividerThickness
BOOL	mustAdjust
BOOL	mustClearFractions
BOOL	isHorizontal
BOOL	canSaveState
BOOL	isCoupled
BOOL	isAdjusting
BOOL	isDragging
BOOL	isInScrollView
Protected Attributes inherited from RBSplitSubview
NSString *	identifier
NSInteger	tag
CGFloat	minDimension
CGFloat	maxDimension
double	fraction
NSRect	previous
NSSize	savedSize
NSUInteger	actDivider
BOOL	canDragWindow
BOOL	canCollapse
BOOL	notInLimits

Detailed Description

Definition at line 21 of file RBSplitView.h.

Method Documentation

acceptsFirstMouse:

- (BOOL) acceptsFirstMouse: (NSEvent*) theEvent

implementation

Definition at line 25 of file RBSplitView.m.

                         :(NSEvent*)theEvent {
    return ([theEvent modifierFlags]&NSCommandKeyMask)==0;
}

addSubview:

- (void) addSubview: (NSView*) aView

implementation

Definition at line 25 of file RBSplitView.m.

                  :(NSView*)aView {
    if ([aView isKindOfClass:[RBSplitSubview class]]) {
        [super addSubview:aView];
    } else {
        [aView setFrameOrigin:NSZeroPoint];
        RBSplitSubview* sub = [[[RBSplitSubview alloc] initWithFrame:[aView frame]] autorelease];
        [aView setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
        [sub addSubview:aView];
        [super addSubview:sub];
    }
    [self setMustAdjust];
}

addSubview:atPosition:

- (void) addSubview:		(NSView*)	aView
atPosition:		(NSUInteger)	position

Definition at line 25 of file RBSplitView.m.

                  :(NSView*)aView atPosition:(NSUInteger)position {
    RBSplitSubview* suv = [self subviewAtPosition:position];
    if (suv) {
        [self addSubview:aView positioned:NSWindowBelow relativeTo:suv];
    } else {
        [self addSubview:aView];
    }
}

addSubview:positioned:relativeTo:

- (void) addSubview: (NSView*) aView positioned: (NSWindowOrderingMode) place relativeTo: (NSView*) otherView

implementation

Definition at line 25 of file RBSplitView.m.

                  :(NSView*)aView positioned:(NSWindowOrderingMode)place relativeTo:(NSView*)otherView {
    if ([aView isKindOfClass:[RBSplitSubview class]]) {
        [super addSubview:aView positioned:place relativeTo:otherView];
    } else {
        [aView setFrameOrigin:NSZeroPoint];
        RBSplitSubview* sub = [[[RBSplitSubview alloc] initWithFrame:[aView frame]] autorelease];
        [aView setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
        [sub addSubview:aView];
        [super addSubview:sub positioned:place relativeTo:otherView];
        [aView setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
    }
    [self setMustAdjust];
}

adjustSubviews

- (void) adjustSubviews

Definition at line 25 of file RBSplitView.m.

                       {
    [self RB___adjustSubviewsExcepting:nil];
}

adjustSubviewsExcepting:

- (void) adjustSubviewsExcepting:

(RBSplitSubview*)

excepting

Definition at line 25 of file RBSplitView.m.

                               :(RBSplitSubview*)excepting {
    [self RB___adjustSubviewsExcepting:[excepting isCollapsed]?nil:excepting];
}

arrayWithStates

- (NSArray *) arrayWithStates

Definition at line 25 of file RBSplitView.m.

                            {
    NSMutableArray* array = [NSMutableArray array];
    [array addObject:[self stringWithSavedState]];
    for (RBSplitSubview* sub in [self subviews]){
        RBSplitView* suv = [sub asSplitView];
        if (suv) {
            [array addObject:[suv arrayWithStates]];
        } else {
            [array addObject:[NSNull null]];
        }
    }
    return array;
}

asSplitView

- (RBSplitView *) asSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                            {
    return self;
}

autoresizesSubviews

- (BOOL) autoresizesSubviews

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                            {
    return NO;
}

autosaveName

- (NSString *) autosaveName

awakeFromNib

- (void) awakeFromNib

implementation

Definition at line 25 of file RBSplitView.m.

                     {
    if ([RBSplitSubview instancesRespondToSelector:@selector(awakeFromNib)]) {
        [super awakeFromNib];
    }
    if (![self splitView]) {
        [self restoreState:YES];
    }
}

background

- (NSColor *) background

coupledSplitView

- (RBSplitView *) coupledSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                                 {
    return [self isCoupled]?self:nil;
}

couplingSplitView

- (RBSplitView *) couplingSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                                  {
    return isCoupled?[super couplingSplitView]:nil;
}

cursor:

+ (NSCursor *) cursor:

(RBSVCursorType)

type

Definition at line 25 of file RBSplitView.m.

                   :(RBSVCursorType)type {
    if ((type>=0)&&(type<RBSVCursorTypeCount)) {
        NSCursor* result = cursors[type];
        if (result) {
            return result;
        }
        switch (type) {
            case RBSVHorizontalCursor:
                return [NSCursor resizeUpDownCursor];
            case RBSVVerticalCursor:
                return [NSCursor resizeLeftRightCursor];
            case RBSV2WayCursor:
                return [NSCursor openHandCursor];
            case RBSVDragCursor:
                return [NSCursor closedHandCursor];
            default:
                break;
        }
    }
    return [NSCursor currentCursor];
}

dealloc

- (void) dealloc

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                {
    if (dividers) {
        free(dividers);
    }
    [autosaveName release];
    [divider release];
    [background release];
    [super dealloc];
}

defaultsKeyForName:isHorizontal:

+ (NSString *) defaultsKeyForName:		(NSString*)	name
isHorizontal:		(BOOL)	orientation

Definition at line 25 of file RBSplitView.m.

                               :(NSString*)name isHorizontal:(BOOL)orientation {
    return [NSString stringWithFormat:@"RBSplitView %@ %@",orientation?@"H":@"V",name];
}

delegate

- (id) delegate

description

- (NSString *) description

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                         {
    return [NSString stringWithFormat:@"%@ {%@}",[super description],[self stringWithSavedState]];
}

display

- (void) display

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                {
    if (mustAdjust&&!isAdjusting) {
        [self adjustSubviews];
    }
    [super display];
}

divider

- (NSImage *) divider

dividerThickness

- (CGFloat) dividerThickness

drawDivider:inRect:betweenView:andView:

- (void) drawDivider:		(NSImage*)	anImage
inRect:		(NSRect)	rect
betweenView:		(RBSplitSubview*)	leading
andView:		(RBSplitSubview*)	trailing

Definition at line 25 of file RBSplitView.m.

                   :(NSImage*)anImage inRect:(NSRect)rect betweenView:(RBSplitSubview*)leading andView:(RBSplitSubview*)trailing {
// Fill the view with the background color (if there's any). Don't draw the background again for
// thumbs.
    if (leading||trailing) {
        NSColor* bg = [self background];
        if (bg) {
            [bg set];
            NSRectFillUsingOperation(rect,NSCompositeSourceOver);
        }
    }
// Center the image, if there is one.
    NSRect imrect = NSZeroRect;
    NSRect dorect = NSZeroRect;
    if (anImage) {
        imrect.size = dorect.size = [anImage size];
        dorect.origin = NSMakePoint(floor(rect.origin.x+(rect.size.width-dorect.size.width)/2),
                                    floor(rect.origin.y+(rect.size.height-dorect.size.height)/2));
    }
// Ask the delegate for the final rect where the image should be drawn.
    if ([delegate respondsToSelector:@selector(splitView:willDrawDividerInRect:betweenView:andView:withProposedRect:)]) {
        dorect = [delegate splitView:self willDrawDividerInRect:rect betweenView:leading andView:trailing withProposedRect:dorect];
    }
// Draw the image if the delegate returned a non-empty rect.
    if (!NSIsEmptyRect(dorect)) {
        [anImage drawInRect:dorect fromRect:imrect operation:NSCompositeSourceOver fraction:1.0];
    }
}

drawRect:

- (void) drawRect: (NSRect) rect

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                :(NSRect)rect {
    [super drawRect:rect];
    if (!dividers) {
        return;
    }
    NSArray* subviews = [self RB___subviews];
    NSUInteger subcount = [subviews count];
// Return if there are no dividers to draw.
    if (subcount<2) {
        return;
    }
    --subcount;
    NSUInteger i;
// Cache the divider image.
    NSImage* divdr = [self divider];
    CGFloat divt = [self dividerThickness];
// Loop over the divider rectangles.
    for (i=0;i<subcount;i++) {
// Check if we need to draw this particular divider.
        if ([self needsToDrawRect:dividers[i]]) {
            RBSplitView* leading = [subviews objectAtIndex:i];
            RBSplitView* trailing = [subviews objectAtIndex:i+1];
            BOOL lexp = divdr?![leading isCollapsed]:NO;
            BOOL texp = divdr?![trailing isCollapsed]:NO;
// We don't draw the divider image if either of the neighboring subviews is a non-collapsed
// nested split view.
            BOOL nodiv = (lexp&&[leading coupledSplitView])||(texp&&[trailing coupledSplitView]);
            [self drawDivider:nodiv?nil:divdr inRect:dividers[i] betweenView:leading andView:trailing];
            if (divdr) {
// Draw the corresponding two-axis thumbs if the leading view is a nested RBSplitView.
                if ((leading = [leading coupledSplitView])&&lexp) {
                    [leading RB___drawDividersIn:self forDividerRect:dividers[i] thickness:divt];
                }
// Draw the corresponding two-axis thumbs if the trailing view is a nested RBSplitView.
                if ((trailing = [trailing coupledSplitView])&&texp) {
                    [trailing RB___drawDividersIn:self forDividerRect:dividers[i] thickness:divt];
                }
            }
        }
    }
}

encodeWithCoder:

- (void) encodeWithCoder: (NSCoder *) coder

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                       :(NSCoder *)coder {
    [super encodeWithCoder:coder];
    if ([coder allowsKeyedCoding]) {
        [coder encodeConditionalObject:delegate forKey:@"delegate"];
        [coder encodeObject:autosaveName forKey:@"autosaveName"];
        [coder encodeObject:[divider TIFFRepresentation] forKey:@"divider"];
        [coder encodeObject:background forKey:@"background"];
        [coder encodeDouble:dividerThickness forKey:@"dividerThickness"];
        [coder encodeBool:isHorizontal forKey:@"isHorizontal"];
        [coder encodeBool:isCoupled forKey:@"isCoupled"];
    } else {
        [coder encodeConditionalObject:delegate];
        [coder encodeObject:autosaveName];
        [coder encodeObject:[divider TIFFRepresentation]];
        [coder encodeObject:background];
        [coder encodeValueOfObjCType:@encode(typeof(dividerThickness)) at:&dividerThickness];
        [coder encodeValueOfObjCType:@encode(typeof(isHorizontal)) at:&isHorizontal];
        [coder encodeValueOfObjCType:@encode(typeof(isCoupled)) at:&isCoupled];
    }
}

initWithCoder:

- (id) initWithCoder: (NSCoder *) coder

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                   :(NSCoder *)coder {
    if ((self = [super initWithCoder:coder])) {
        NSData* data = nil;
        CGFloat divt = 0.0;
        isCoupled = YES;
        isDragging = NO;
        isInScrollView = NO;
        canSaveState = NO;
        if ([coder allowsKeyedCoding]) {
            isCoupled = [coder decodeBoolForKey:@"isCoupled"];
            [self setDelegate:[coder decodeObjectForKey:@"delegate"]];
            [self setAutosaveName:[coder decodeObjectForKey:@"autosaveName"] recursively:NO];
            data = [coder decodeObjectForKey:@"divider"];
            [self setBackground:[coder decodeObjectForKey:@"background"]];
            divt = [coder decodeDoubleForKey:@"dividerThickness"];
            isHorizontal = [coder decodeBoolForKey:@"isHorizontal"];
        } else {
            [self setDelegate:[coder decodeObject]];
            [self setAutosaveName:[coder decodeObject] recursively:NO];
            data = [coder decodeObject];
            [self setBackground:[coder decodeObject]];
            [coder decodeValueOfObjCType:@encode(typeof(divt)) at:&divt];
            [coder decodeValueOfObjCType:@encode(typeof(isHorizontal)) at:&isHorizontal];
            [coder decodeValueOfObjCType:@encode(typeof(isCoupled)) at:&isCoupled];
        }
        dividers = NULL;
        if (data) {
            NSBitmapImageRep* rep = [NSBitmapImageRep imageRepWithData:data];
            NSImage* image = [[[NSImage alloc] initWithSize:[rep size]] autorelease];
            [image setFlipped:YES];
            [image addRepresentation:rep];
            [self setDivider:image];
        } else {
            [self setDivider:nil];
        }
        [self setDividerThickness:divt];
        [self setMustAdjust];
        [self performSelector:@selector(viewDidMoveToSuperview) withObject:nil afterDelay:0.0];
        [self performSelector:@selector(RB___adjustOutermostIfNeeded) withObject:nil afterDelay:0.0];
    }
    return self;
}

initWithFrame:

- (id) initWithFrame:

(NSRect)

frame

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                   :(NSRect)frame {
    self = [super initWithFrame:frame];
    if (self) {
        dividers = NULL;
        isCoupled = YES;
        isDragging = NO;
        isInScrollView = NO;
        canSaveState = NO;
        [self setVertical:YES];
        [self setDivider:nil];
        [self setAutosaveName:nil recursively:NO];
        [self setBackground:nil];
    }
    return self;
}

initWithFrame:andSubviews:

- (id) initWithFrame:		(NSRect)	frame
andSubviews:		(NSUInteger)	count

Definition at line 25 of file RBSplitView.m.

                   :(NSRect)frame andSubviews:(NSUInteger)count {
    self = [self initWithFrame:frame];
    if (self) {
        while (count-->0) {
            [self addSubview:[[[RBSplitSubview alloc] initWithFrame:frame] autorelease]];
        }
        [self setMustAdjust];
    }
    return self;
}

isAdjusting

- (BOOL) isAdjusting

isDragging

- (BOOL) isDragging

isFlipped

- (BOOL) isFlipped

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                  {
    return YES;
}

isHorizontal

- (BOOL) isHorizontal

isInScrollView

- (BOOL) isInScrollView

isOpaque

- (BOOL) isOpaque

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                 {
    RBSplitView* sv = [self couplingSplitView];
    return sv?[sv isOpaque]:(background&&([background alphaComponent]>=1.0));
}

isVertical

- (BOOL) isVertical

Definition at line 25 of file RBSplitView.m.

                   {
    return ![self isHorizontal];
}

mouseDown:

- (void) mouseDown: (NSEvent*) theEvent

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                 :(NSEvent*)theEvent {
    if (!dividers) {
        return;
    }
    NSArray* subviews = [self RB___subviews];
    NSUInteger subcount = [subviews count];
    if (subcount<2) {
        return;
    }
// If the mousedown was in an alternate dragview, or if there's no divider image, handle it in RBSplitSubview.
    if ((actDivider<NSNotFound)||![self divider]) {
        [super mouseDown:theEvent];
        return;
    }
    NSPoint where = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    BOOL ishor = [self isHorizontal];
    NSUInteger i;
    --subcount;
// Loop over the divider rectangles.
    for (i=0;i<subcount;i++) {
        NSRect* divdr = &dividers[i];
        if ([self mouse:where inRect:*divdr]) {
// leading points at the subview immediately leading the divider being tracked.
            RBSplitView* leading = [subviews objectAtIndex:i];
// trailing points at the subview immediately trailing the divider being tracked.
            RBSplitView* trailing = [subviews objectAtIndex:i+1];
            if ([delegate respondsToSelector:@selector(splitView:shouldHandleEvent:inDivider:betweenView:andView:)]) {
                if (![delegate splitView:self shouldHandleEvent:theEvent inDivider:i betweenView:leading andView:trailing]) {
                    return;
                }
            }
// If it's a double click, try to expand or collapse one of the neighboring subviews.
            if ([theEvent clickCount]>1) {
// If both are collapsed, we do nothing. If one of them is collapsed, we try to expand it.
                if ([trailing isCollapsed]) {
                    if (![leading isCollapsed]) {
                        [self RB___tryToExpandTrailing:trailing leading:leading delta:-[trailing dimension]];
                    }
                } else {
                    if ([leading isCollapsed]) {
                        [self RB___tryToExpandLeading:leading divider:i trailing:trailing delta:[leading dimension]];
                    } else {
// If neither are collapsed, we check if both are collapsible.
                        BOOL lcan = [leading canCollapse];
                        BOOL tcan = [trailing canCollapse];
                        CGFloat ldim = [leading dimension];
                        if (lcan&&tcan) {
// If both are collapsible, we try asking the delegate.
                            if ([delegate respondsToSelector:@selector(splitView:collapseLeading:orTrailing:)]) {
                                RBSplitSubview* sub = [delegate splitView:self collapseLeading:leading orTrailing:trailing];
// If the delegate returns nil, neither view will collapse.
                                lcan = sub==leading;
                                tcan = sub==trailing;
                            } else {
// Otherwise we try collapsing the smaller one. If they're equal, the trailing one will be collapsed.
                                lcan = ldim<[trailing dimension];
                            }
                        }
// At this point, we'll try to collapse the leading subview.
                        if (lcan) {
                            [self RB___tryToShortenLeading:leading divider:i trailing:trailing delta:-ldim always:NO];
                        }
// If the leading subview didn't collapse for some reason, we try to collapse the trailing one.
                        if (!mustAdjust&&tcan) {
                            [self RB___tryToShortenTrailing:trailing divider:i leading:leading delta:[trailing dimension] always:NO];
                        }
                    }
                }
// If the subviews have changed, clear the fractions, adjust and redisplay
                if (mustAdjust) {
                    [self RB___setMustClearFractions];
                    RBSplitView* sv = [self splitView];
                    [sv?sv:self adjustSubviews];
                    [super display];
                }
            } else {
// Single click; record the offsets within the divider rectangle and check for nesting.
                CGFloat divt = [self dividerThickness];
                CGFloat offset = DIM(where)-DIM(divdr->origin);
// Check if the leading subview is nested and if yes, if one of its two-axis thumbs was hit.
                NSInteger ldivdr = NSNotFound;
                CGFloat loffset = 0.0;
                NSPoint lwhere = where;
                NSRect lrect = NSZeroRect;
                if ((leading = [leading coupledSplitView])) {
                    ldivdr = [leading RB___dividerHitBy:lwhere relativeToView:self thickness:divt];
                    if (ldivdr!=NSNotFound) {
                        lrect = [leading RB___dividerRect:ldivdr relativeToView:self];
                        loffset = OTHER(lwhere)-OTHER(lrect.origin);
                    }
                }
// Check if the trailing subview is nested and if yes, if one of its two-axis thumbs was hit.
                NSInteger tdivdr = NSNotFound;
                CGFloat toffset = 0.0;
                NSPoint twhere = where;
                NSRect trect = NSZeroRect;
                if ((trailing = [trailing coupledSplitView])) {
                    tdivdr = [trailing RB___dividerHitBy:twhere relativeToView:self thickness:divt];
                    if (tdivdr!=NSNotFound) {
                        trect = [trailing RB___dividerRect:tdivdr relativeToView:self];
                        toffset = OTHER(twhere)-OTHER(trect.origin);
                    }
                }
// Now we loop handling mouse events until we get a mouse up event, while showing the drag cursor.
                [[RBSplitView cursor:RBSVDragCursor] push];
                [self RB___setDragging:YES];
                while ((theEvent = [NSApp nextEventMatchingMask:NSLeftMouseDownMask|NSLeftMouseDraggedMask|NSLeftMouseUpMask untilDate:[NSDate distantFuture] inMode:NSEventTrackingRunLoopMode dequeue:YES])&&([theEvent type]!=NSLeftMouseUp)) {
// Set up a local autorelease pool for the loop to prevent buildup of temporary objects.
                    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
                    NSDisableScreenUpdates();
// Track the mouse along the main coordinate. 
                    [self RB___trackMouseEvent:theEvent from:where withBase:NSZeroPoint inDivider:i];
                    if (ldivdr!=NSNotFound) {
// Track any two-axis thumbs for the leading nested RBSplitView.
                        [leading RB___trackMouseEvent:theEvent from:[self convertPoint:lwhere toView:leading] withBase:NSZeroPoint inDivider:ldivdr];
                    }
                    if (tdivdr!=NSNotFound) {
// Track any two-axis thumbs for the trailing nested RBSplitView.
                        [trailing RB___trackMouseEvent:theEvent from:[self convertPoint:twhere toView:trailing] withBase:NSZeroPoint inDivider:tdivdr];
                    }
                    if (mustAdjust||[leading mustAdjust]||[trailing mustAdjust]) {
// The mouse was dragged and the subviews changed, so we must redisplay, as
// several divider rectangles may have changed.
                        RBSplitView* sv = [self splitView];
                        [sv?sv:self adjustSubviews];
                        [super display];
                        divdr = &dividers[i];
// Adjust to the new cursor coordinates.
                        DIM(where) = DIM(divdr->origin)+offset;
                        if ((ldivdr!=NSNotFound)&&![leading isCollapsed]) {
// Adjust for the leading nested RBSplitView's thumbs while it's not collapsed.
                            lrect = [leading RB___dividerRect:ldivdr relativeToView:self];
                            OTHER(lwhere) = OTHER(lrect.origin)+loffset;
                        }
                        if ((tdivdr!=NSNotFound)&&![trailing isCollapsed]) {
// Adjust for the trailing nested RBSplitView's thumbs while it's not collapsed.
                            trect = [trailing RB___dividerRect:tdivdr relativeToView:self];
                            OTHER(twhere) = OTHER(trect.origin)+toffset;
                        }
                    }
                    NSEnableScreenUpdates();
                    [pool drain];
                }
                [self RB___setDragging:NO];
// Redisplay the previous cursor.
                [NSCursor pop];
            }
        }
    }
}

mouseDownCanMoveWindow

- (BOOL) mouseDownCanMoveWindow

implementation

Definition at line 25 of file RBSplitView.m.

                               {
    return NO;
}

mustAdjust

- (BOOL) mustAdjust

needsDisplay

- (BOOL) needsDisplay

implementation

Definition at line 25 of file RBSplitView.m.

                     {
    if (mustAdjust&&!isAdjusting) {
        [self adjustSubviews];
        return YES;
    }
    return [super needsDisplay];
}

RB___addCursorRectsTo:forDividerRect:thickness:

- (void) RB___addCursorRectsTo: (RBSplitView*) masterView forDividerRect: (NSRect) rect thickness: (CGFloat) delta

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                             :(RBSplitView*)masterView forDividerRect:(NSRect)rect thickness:(CGFloat)delta {
    if (dividers&&[self divider]) {
        NSArray* subviews = [self RB___subviews];
        NSInteger divcount = [subviews count]-1;
        if (divcount<1) {
            return;
        }
        NSInteger i;
        NSCursor* cursor = [RBSplitView cursor:RBSV2WayCursor];
        BOOL ishor = [self isHorizontal];
// Loop over the divider rectangles, intersect them with the view's own, and add the thumb rectangle
// to the containing split view.
        for (i=0;i<divcount;i++) {
            NSRect divdr = dividers[i];
            divdr.origin = [self convertPoint:divdr.origin toView:masterView];
            OTHER(divdr.origin) -= delta;
            OTHER(divdr.size) += 2*delta;
            divdr = NSIntersectionRect(divdr,rect);
            if (!NSIsEmptyRect(divdr)) {
                [masterView addCursorRect:divdr cursor:cursor];
            }
        }
    }
}

RB___adjustOutermostIfNeeded

- (void) RB___adjustOutermostIfNeeded

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                     {
    RBSplitView* sv = [self splitView];
    if (sv) {
        [sv RB___adjustOutermostIfNeeded];
        return;
    }
    if (mustAdjust&&!isAdjusting) {
        [self adjustSubviews];
    }
}

RB___adjustSubviewsExcepting:

- (void) RB___adjustSubviewsExcepting: (RBSplitSubview*) excepting

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                    :(RBSplitSubview*)excepting {
    mustAdjust = NO;
    NSArray* subviews = [self RB___subviews];
    NSUInteger subcount = [subviews count];
    if (subcount<1) {
        return;
    }
    NSRect bounds = [self bounds];
// Never adjust if the splitview itself is collapsed.
    if ((bounds.size.width<1.0)||(bounds.size.height<1.0)) {
        return;
    }
// Prevents adjustSubviews being called recursively, which unfortunately may happen otherwise.
    if (isAdjusting) {
        return;
    }
    isAdjusting = YES;
// Tell the delegate we're about to adjust subviews.
    if ([delegate respondsToSelector:@selector(willAdjustSubviews:)]) {
        [delegate willAdjustSubviews:self];
        bounds = [self bounds];
    }
    NSUInteger divcount = subcount-1;
    if (divcount<1) {
// No dividers at all.
        if (dividers) {
            free(dividers);
            dividers = NULL;
        }
    } else {
// Try to allocate or resize if we already have a dividers array.
        NSUInteger divsiz = sizeof(NSRect)*divcount;
        dividers = (NSRect*)(dividers?reallocf(dividers,divsiz):malloc(divsiz));
        if (!dividers) {
            return;
        }
    }
// This C array of subviewCaches is used to cache the subview information.
    subviewCache* caches = (subviewCache*)malloc(sizeof(subviewCache)*subcount);
    double realsize = 0.0;
    double expsize = 0.0;
    CGFloat newsize = 0.0;
    CGFloat effsize = 0.0;
    CGFloat limit;
    subviewCache* curr;
    NSUInteger i;
    BOOL ishor = [self isHorizontal];
    CGFloat divt = [self dividerThickness];
// First we loop over subviews and cache their information.
    for (i=0;i<subcount;i++) {
        curr = &caches[i];
        [[subviews objectAtIndex:i] RB___copyIntoCache:curr];
    }
// This is a counter to limit the outer loop to three iterations (six if excepting is non-nil).
    NSInteger sanity = excepting?-3:0;
    while (sanity++<3) {
// We try to accomodate the exception for the first group of loops, turn it off for the second.
        if (sanity==1) {
            excepting = nil;
        }
// newsize is the available space for actual subviews (so dividers don't count). It will be an integer.
// Same as calling [self RB___dimensionWithoutDividers].
        NSUInteger smallest = 0;
        CGFloat smalldim = -1.0;
        BOOL haveexp = NO;
// Loop over subviews and sum the expanded dimensions into expsize, including fractions.
// Also find the collapsed subview with the smallest minimum dimension.
        for (i=0;i<subcount;i++) {
            curr = &caches[i];
            curr->constrain = NO;
            if (curr->size>0.0) {
                expsize += curr->size;
                if (!isInScrollView) {
// ignore fractions if we're in a NSScrollView, however.
                    expsize += curr->fraction;
                }
                haveexp = YES;
            } else {
                limit = [curr->sub minDimension];
                if (smalldim>limit) {
                    smalldim = limit;
                    smallest = i;
                }
            }
        }
// haveexp should be YES at this point. If not, all subviews were collapsed; can't have that, so we 
// expand the smallest subview (or the first, if all have the same minimum).
        curr = &caches[smallest];
        if (!haveexp) {
            curr->size = [curr->sub minDimension];
            curr->fraction = 0.0;
            expsize += curr->size;
        }
        if (isInScrollView) {
// If we're inside an NSScrollView, we just grow the view to accommodate the subviews, instead of 
// the other way around.
            DIM(bounds.size) = expsize;
            break;
        } else {
// If the total dimension of all expanded subviews is less than 1.0 we set the dimension of the smallest
// subview (which we're sure is expanded at this point) to the available space.
            newsize = DIM(bounds.size)-divcount*divt;
            if (expsize<1.0) {
                curr->size = newsize;
                curr->fraction = 0.0;
                expsize = newsize;
            }
// Loop over the subviews and check if they're within the limits after scaling. We also recalculate the
// exposed size and repeat until no more subviews hit the constraints during that loop.
            BOOL constrained;
            effsize = newsize;// we're caching newsize here, this is an integer.
            do {
// scale is the scalefactor by which all views should be scaled - assuming none have constraints.
// It's a double to (hopefully) keep rounding errors small enough for all practical purposes.
                double scale = newsize/expsize;
                constrained = NO;
                realsize = 0.0;
                expsize = 0.0;
                for (i=0;i<subcount;i++) {
// Loop over the cached subview info.
                    curr = &caches[i];
                    if (curr->size>0.0) {
// Check non-collapsed subviews only.
                        if (!curr->constrain) {
// Check non-constrained subviews only; calculate the proposed new size.
                            CGFloat cursize = (curr->size+curr->fraction)*scale;
// Check if we hit a limit. limit will contain either the max or min dimension, whichever was hit.
                            if (([curr->sub RB___animationData:NO resize:NO]&&((limit = curr->size)>=0.0))||
                                ((curr->sub==excepting)&&((limit = [curr->sub dimension])>0.0))||
                                (cursize<(limit = [curr->sub minDimension]))||
                                (cursize>(limit = [curr->sub maxDimension]))) {
// If we hit a limit, we mark the view and set to repeat the loop; non-constrained subviews will
// have to be recalculated.
                                curr->constrain = constrained = YES;
// We set the new size to the limit we hit, and subtract it from the total size to be subdivided.
                                cursize = limit;
                                curr->fraction = 0.0;
                                newsize -= cursize;
                            } else {
// If we didn't hit a limit, we round the size to the nearest integer and recalculate the fraction. 
                                double rem = fmod(cursize,1.0);
                                cursize -= rem;
                                if (rem>0.5) {
                                    ++cursize;
                                    --rem;
                                }
                                expsize += cursize;
                                curr->fraction = rem;
                            }
// We store the new size in the cache.
                            curr->size = cursize;
                        }
// And add the full size with fraction to the actual sum of all expanded subviews.
                        realsize += curr->size+curr->fraction;
                    }
                }
// At this point, newsize will be the sum of the new dimensions of non-constrained views.
// expsize will be the sum of the recalculated dimensions of the same views, if any.
// We repeat the loop if any view has been recently constrained, and if there are any
// unconstrained views left.
            } while (constrained&&(expsize>0.0));
// At this point, the difference between realsize and effsize should be less than 1 pixel.
// realsize is the total size of expanded subviews as recalculated above, and
// effsize is the value realsize should have.
            limit = realsize-effsize;
            if (limit>=1.0) {
// If realsize is larger than effsize by 1 pixel or more, we will need to collapse subviews to make room.
// This in turn might expand previously collapsed subviews. So, we'll try collapsing constrained subviews
// until we're back into range, and then recalculate everything from the beginning.
                for (i=0;i<subcount;i++) {
                    curr = &caches[i];
                    if (curr->constrain&&(curr->sub!=excepting)&&([curr->sub RB___animationData:NO resize:NO]==nil)&&[curr->sub canCollapse]) {
                        realsize -= curr->size;
                        if (realsize<1.0) {
                            break;
                        }
                        curr->size = 0.0;
                        if ((realsize-effsize)<1.0) {
                            break;
                        }
                    }
                }
            } else if (limit<=-1.0) {
// If realsize is smaller than effsize by 1 pixel or more, we will need to expand subviews.
// This in turn might collapse previously expanded subviews. So, we'll try expanding collapsed subviews
// until we're back into range, and then recalculate everything from the beginning.
                for (i=0;i<subcount;i++) {
                    curr = &caches[i];
                    if (curr->size<=0.0) {
                        curr->size = [curr->sub minDimension];
                        curr->fraction = 0.0;
                        realsize += curr->size;
                        if ((realsize-effsize)>-1.0) {
                            break;
                        }
                    }
                }
            } else {
// The difference is less than 1 pixel, meaning that in all probability our calculations are
// exact or off by at most one pixel after rounding, so we break the loop here.
                break;
            }
        }
// After passing through the outer loop a few times, the frames may still be wrong, but there's nothing
// else we can do about it. You probably should avoid this by some other means like setting a minimum
// or maximum size for the window, for instance, or leaving at least one unlimited subview.
    }
// newframe is used to reset all subview frames. Subviews always fill the entire RBSplitView along the
// current orientation.
    NSRect newframe = NSMakeRect(0.0,0.0,bounds.size.width,bounds.size.height);
// We now loop over the subviews yet again and set the definite frames, also recalculating the
// divider rectangles as we go along, and collapsing and expanding subviews whenever requested.
    RBSplitSubview* last = nil;
// And we make a note if there's any nested RBSplitView.
    NSInteger nested = NSNotFound;
//  newsize = DIM(bounds.size)-divcount*divt;
    for (i=0;i<subcount;i++) {
        curr = &caches[i];
// If we have a nested split view store its index.
        if ((nested==NSNotFound)&&([curr->sub asSplitView]!=nil)) {
            nested = i;
        }
// Adjust the subview to the correct origin and resize it to fit into the "other" dimension.
        curr->rect.origin = newframe.origin;
        OTHER(curr->rect.size) = OTHER(newframe.size);
        DIM(curr->rect.size) = curr->size;
// Clear fractions for expanded subviews if requested.
        if ((curr->size>0.0)&&mustClearFractions) {
            curr->fraction = 0.0;
        }
// Ask the subview to do the actual moving/resizing etc. from the cache.
        [curr->sub RB___updateFromCache:curr withTotalDimension:effsize];
// Step to the next position and record the subview if it's not collapsed.
        DIM(newframe.origin) += curr->size;
        if (curr->size>0.0) {
            last = curr->sub;
        }
        if (i==divcount) {
// We're at the last subview, so we now check if the actual and calculated dimensions
// are the same.
            CGFloat remain = DIM(bounds.size)-DIM(newframe.origin);
            if (last&&(fabs(remain)>0.0)) {
// We'll resize the last expanded subview to whatever it takes to squeeze within the frame.
// Normally the change should be at most one pixel, but if too many subviews were constrained,
// this may be a large value, and the last subview may be resized beyond its constraints;
// there's nothing else to do at this point.
                newframe = [last frame];
                DIM(newframe.size) += remain;
                [last RB___setFrameSize:newframe.size withFraction:[last RB___fraction]-remain];
// And we loop back over the rightmost dividers (if any) to adjust their offsets.
                while ((i>0)&&(last!=[subviews objectAtIndex:i])) {
                    DIM(dividers[--i].origin) += remain;
                }
                break;
            }
        } else {
// For any but the last subview, we just calculate the divider frame.
            DIM(newframe.size) = divt;
            if (dividers) {     // test for NULL to satisfy the analyzer
                dividers[i] = newframe;
            }
            DIM(newframe.origin) += divt;
        }
    }
// We resize our frame at this point, if we're inside an NSScrollView.
    if (isInScrollView) {
        [super setFrameSize:bounds.size];
    }
// If there was at least one nested RBSplitView, we loop over the subviews and adjust those that need it.
    for (i=nested;i<subcount;i++) {
        curr = &caches[i];
        RBSplitView* sv = [curr->sub asSplitView];
        if ([sv mustAdjust]) {
            [sv adjustSubviews];
        }
    }
// Free the cache array.
    free(caches);
// Clear cursor rects.
    mustAdjust = NO;
    mustClearFractions = NO;
    [[self window] invalidateCursorRectsForView:self];
// Save the state for all subviews.
    if (!isDragging) {
        [self saveState:NO];
    }
// If we're a nested RBSplitView, also invalidate cursorRects for the superview.
    RBSplitView* sv = [self couplingSplitView];
    if (sv) {
        [[self window] invalidateCursorRectsForView:sv];
    }
    isAdjusting = NO;
// Tell the delegate we're finished.
    if ([delegate respondsToSelector:@selector(didAdjustSubviews:)]) {
        [delegate didAdjustSubviews:self];
    }
}

RB___dimensionWithoutDividers

- (CGFloat) RB___dimensionWithoutDividers

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                         {
    BOOL ishor = [self isHorizontal];
    NSSize size = [self frame].size;
    return fMAX(1.0,DIM(size)-[self dividerThickness]*([self RB___numberOfSubviews]-1));
}

RB___dividerHitBy:relativeToView:thickness:

- (NSUInteger) RB___dividerHitBy: (NSPoint) point relativeToView: (RBSplitView*) view thickness: (CGFloat) delta

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                               :(NSPoint)point relativeToView:(RBSplitView*)view thickness:(CGFloat)delta {
    if (!dividers) {
        return NSNotFound;
    }
    NSInteger divcount = [self RB___numberOfSubviews]-1;
    if (divcount<1) {
        return NSNotFound;
    }
    NSInteger i;
    BOOL ishor = [self isHorizontal];
    point = [self convertPoint:point fromView:view];
    for (i=0;i<divcount;i++) {
        NSRect divdr = dividers[i];
        OTHER(divdr.origin) -= delta;
        OTHER(divdr.size) += 2*delta;
        if ([self mouse:point inRect:divdr]) {
            return i;
        }
    }
    return NSNotFound;
}

RB___dividerOrigin:

- (CGFloat) RB___dividerOrigin: (NSUInteger) indx

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                             :(NSUInteger)indx {
    CGFloat result = 0.0;
    if (dividers) {
        BOOL ishor = [self isHorizontal];
        result = DIM(dividers[indx].origin);
    }
    return result;
}

RB___dividerRect:relativeToView:

- (NSRect) RB___dividerRect: (NSUInteger) indx relativeToView: (RBSplitView*) view

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                          :(NSUInteger)indx relativeToView:(RBSplitView*)view {
    if (dividers&&(indx<[self RB___numberOfSubviews]-1)) {
        NSRect result = dividers[indx];
        if (view&&(view!=self)) {
            result = [self convertRect:result toView:view];
        }
        return result;
    }
    return NSZeroRect;
}

RB___dividerThickness

- (CGFloat) RB___dividerThickness

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                 {
    return dividerThickness;
}

RB___drawDividersIn:forDividerRect:thickness:

- (void) RB___drawDividersIn: (RBSplitView*) masterView forDividerRect: (NSRect) rect thickness: (CGFloat) delta

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                           :(RBSplitView*)masterView forDividerRect:(NSRect)rect thickness:(CGFloat)delta {
    if (!dividers) {
        return;
    }
    NSArray* subviews = [self RB___subviews];
    NSInteger divcount = [subviews count]-1;
    if (divcount<1) {
        return;
    }
    NSInteger i;
    BOOL ishor = [self isHorizontal];
// Get the outer split view's divider image.
    NSImage* image = [masterView divider];
// Loop over the divider rectangles, intersect them with the view's own, and draw the thumb there.
    for (i=0;i<divcount;i++) {
        NSRect divdr = dividers[i];
        divdr.origin = [self convertPoint:divdr.origin toView:masterView];
        OTHER(divdr.origin) -= delta;
        OTHER(divdr.size) += 2*delta;
        divdr = NSIntersectionRect(divdr,rect);
        if (!NSIsEmptyRect(divdr)) {
            [masterView drawDivider:image inRect:divdr betweenView:nil andView:nil];
        }
    }
}

RB___numberOfSubviews

- (NSUInteger) RB___numberOfSubviews

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                    {
    NSUInteger result = 0;
    for (RBSplitSubview* sub in [self subviews]) {
        if (![sub isHidden]) {
            ++result;
        }
    }
    return result;
}

RB___setDragging:

- (void) RB___setDragging: (BOOL) flag

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                        :(BOOL)flag {
    BOOL save = isDragging&&!flag;
    isDragging = flag;
    if (save) {
        [self saveState:NO];
    }
}

RB___setMustClearFractions

- (void) RB___setMustClearFractions

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                   {
    mustClearFractions = YES;
}

RB___shouldResizeWindowForDivider:betweenView:andView:willGrow:

- (BOOL) RB___shouldResizeWindowForDivider: (NSUInteger) indx betweenView: (RBSplitSubview*) leading andView: (RBSplitSubview*) trailing willGrow: (BOOL) grow

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                         :(NSUInteger)indx betweenView:(RBSplitSubview*)leading andView:(RBSplitSubview*)trailing willGrow:(BOOL)grow {
    if (!isInScrollView&&[delegate respondsToSelector:@selector(splitView:shouldResizeWindowForDivider:betweenView:andView:willGrow:)]) {
        return [delegate splitView:self shouldResizeWindowForDivider:indx betweenView:leading andView:trailing willGrow:grow];
    }
    return NO;
}

RB___subviews

- (NSArray *) RB___subviews

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                          {
    NSMutableArray* result = [NSMutableArray arrayWithArray:[self subviews]];
    NSInteger i;
    for (i=[result count]-1;i>=0;i--) {
        RBSplitSubview* view = [result objectAtIndex:i];
        if ([view isHidden]) {
            [result removeObjectAtIndex:i];
        }
    }
    return result;
}

RB___trackMouseEvent:from:withBase:inDivider:

- (void) RB___trackMouseEvent: (NSEvent*) theEvent from: (NSPoint) where withBase: (NSPoint) base inDivider: (NSUInteger) indx

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                            :(NSEvent*)theEvent from:(NSPoint)where withBase:(NSPoint)base inDivider:(NSUInteger)indx {
    NSArray* subviews = [self RB___subviews];
    NSUInteger subcount = [subviews count];
// Make sure that the divider number is valid.
    if (indx>=subcount) {
        return;
    }
    NSPoint result;
    NSUInteger k;
// leading and trailing point at the subviews immediately leading and trailing the divider being tracked
    RBSplitSubview* leading = [subviews objectAtIndex:indx];
    RBSplitSubview* trailing = [subviews objectAtIndex:indx+1];
// Convert the mouse coordinates to apply to the same system the divider rects are in.
    NSPoint mouse = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    mouse.x -= base.x;
    mouse.y -= base.y;
    result.x = mouse.x-where.x;
    result.y = mouse.y-where.y;
// delta is the actual amount the mouse has moved in the relevant coordinate since the last event.
    BOOL ishor = [self isHorizontal];
    CGFloat delta = DIM(result);
    if (delta<0.0) {
// Negative delta means the mouse is being moved left or upwards.
// firstLeading will point at the first expanded subview to the left (or upwards) of the divider.
// If there's none (all subviews are collapsed) it will point at the nearest subview.
        RBSplitSubview* firstLeading = leading;
        k = indx;
        while (![firstLeading canShrink]) {
            if (k==0) {
                firstLeading = leading;
                break;
            }
            firstLeading = [subviews objectAtIndex:--k];
        }
        if (isInScrollView) {
            trailing = nil;
        }
// If the trailing subview is collapsed, it might be expanded if some conditions are met.
        if ([trailing isCollapsed]) {
            [self RB___tryToExpandTrailing:trailing leading:firstLeading delta:delta];
        } else {
            [self RB___tryToShortenLeading:firstLeading divider:indx trailing:trailing delta:delta always:YES];
        }
    } else if (delta>0.0) {
// Positive delta means the mouse is being moved right or downwards.
// firstTrailing will point at the first expanded subview to the right (or downwards) of the divider.
// If there's none (all subviews are collapsed) it will point at the nearest subview.
        RBSplitSubview* firstTrailing = nil;
        if (!isInScrollView) {
            firstTrailing = trailing;
            k = indx+1;
            while (![firstTrailing canShrink]) {
                if (++k>=subcount) {
                    firstTrailing = trailing;
                    break;
                }
                firstTrailing = [subviews objectAtIndex:k];
            }
        }
// If the leading subview is collapsed, it might be expanded if some conditions are met.
        if ([leading isCollapsed]) {
            [self RB___tryToExpandLeading:leading divider:indx trailing:firstTrailing delta:delta];
        } else {
// The leading subview is not collapsed, so we try to shorten or even collapse it
            [self RB___tryToShortenTrailing:firstTrailing divider:indx leading:leading delta:delta always:YES];
        }
    }
}

RB___tryToExpandLeading:divider:trailing:delta:

- (void) RB___tryToExpandLeading: (RBSplitSubview*) leading divider: (NSUInteger) indx trailing: (RBSplitSubview*) trailing delta: (CGFloat) delta

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                               :(RBSplitSubview*)leading divider:(NSUInteger)indx trailing:(RBSplitSubview*)trailing delta:(CGFloat)delta {
    NSWindow* window = nil;
    NSView* document = nil;
    NSSize maxsize = NSMakeSize(WAYOUT,WAYOUT);
    NSRect frame = NSZeroRect;
    NSRect screen = NSMakeRect(0,0,WAYOUT,WAYOUT);
    BOOL ishor = NO;
// First we ask the delegate, if there's any, if the window should resize.
    BOOL dowin = ([self RB___shouldResizeWindowForDivider:indx betweenView:leading andView:trailing willGrow:YES]);
    if (dowin) {
// We initialize the other local variables only if we need them for the window.
        ishor = [self isHorizontal];
        document = [[self enclosingScrollView] documentView];
        if (document) {
            frame = [document frame];
        } else {
            window = [self window];
            frame = [window frame];
            maxsize = [window maxSize];
            screen = [[NSScreen mainScreen] visibleFrame];
        }
    }
// The mouse has to move over half of the expanded size (plus hysteresis) and the expansion shouldn't
// reduce the trailing subview to less than its minimum size (or grow the window beyond its maximum).
    CGFloat limit = [leading minDimension];
    CGFloat dimension = 0.0;
    if (dowin) {
        CGFloat maxd = fMAX(0.0,(ishor?frame.origin.y-screen.origin.y:(screen.origin.x+screen.size.width)-(frame.origin.x+frame.size.width)));
        dimension = fMIN(DIM(maxsize)-DIM(frame.size),maxd);
    } else {
        dimension = trailing?[trailing dimension]:WAYOUT;
    }
    if (limit>dimension) {
        return;
    }
    if (!dowin&&trailing) {
        limit += [trailing minDimension];
        if (limit>dimension) {
// If the trailing subview is going below its minimum, we try to collapse it first.
// However, we don't collapse if that would cause the leading subview to become larger than its maximum.
            if (([trailing canCollapse])&&(delta>(0.5+HYSTERESIS)*dimension)&&([leading maxDimension]<=dimension)) {
                delta = -[trailing RB___collapse];
                [leading changeDimensionBy:delta mayCollapse:NO move:NO];
            }
            return;
        }
    }
// The leading subview may be expanded normally.
    delta = -[leading changeDimensionBy:delta mayCollapse:NO move:NO];
    if (dowin) {
// If it does expand, we widen the window.
        DIM(frame.size) -= delta;
        if (ishor) {
            DIM(frame.origin) += delta;
        }
        if (document) {
            [document setFrame:frame];
            [document setNeedsDisplay:YES];
        } else {
            [window setFrame:frame display:YES];
        }
        [self setMustAdjust];
    } else {
// If it does expand, we shorten the trailing subview.
        [trailing changeDimensionBy:delta mayCollapse:NO move:YES];
    }
}

RB___tryToExpandTrailing:leading:delta:

- (void) RB___tryToExpandTrailing: (RBSplitSubview*) trailing leading: (RBSplitSubview*) leading delta: (CGFloat) delta

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                :(RBSplitSubview*)trailing leading:(RBSplitSubview*)leading delta:(CGFloat)delta {
// The mouse has to move over half of the expanded size (plus hysteresis) and the expansion shouldn't
// reduce the leading subview to less than its minimum size. If it does, we try to collapse it first.
// However, we don't collapse if that would cause the trailing subview to become larger than its maximum.
    CGFloat limit = trailing?[trailing minDimension]:0.0;
    CGFloat dimension = [leading dimension];
    if (limit>dimension) {
        return;
    }
    limit += [leading minDimension];
    if (limit>dimension) {
        if ([leading canCollapse]&&(-delta>(0.5+HYSTERESIS)*dimension)&&((trailing?[trailing maxDimension]:0.0)<=dimension)) {
            delta = -[leading RB___collapse];
            [trailing changeDimensionBy:delta mayCollapse:NO move:YES];
        }
        return;
    }
// The trailing subview may be expanded normally. If it does expand, we shorten the leading subview.
    if (trailing) {
        delta = -[trailing changeDimensionBy:-delta mayCollapse:NO move:YES];
    }
    [leading changeDimensionBy:delta mayCollapse:NO move:NO];
}

RB___tryToShortenLeading:divider:trailing:delta:always:

- (void) RB___tryToShortenLeading: (RBSplitSubview*) leading divider: (NSUInteger) indx trailing: (RBSplitSubview*) trailing delta: (CGFloat) delta always: (BOOL) always

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                :(RBSplitSubview*)leading divider:(NSUInteger)indx trailing:(RBSplitSubview*)trailing delta:(CGFloat)delta always:(BOOL)always {
    NSWindow* window = nil;
    NSView* document = nil;
    NSSize minsize = NSZeroSize;
    NSRect frame = NSZeroRect;
    BOOL ishor = NO;
// First we ask the delegate, if there's any, if the window should resize.
    BOOL dowin = ([self RB___shouldResizeWindowForDivider:indx betweenView:leading andView:trailing willGrow:NO]);
    if (dowin) {
// We initialize the other local variables only if we need them for the window.
        ishor = [self isHorizontal];
        document = [[self enclosingScrollView] documentView];
        if (document) {
            frame = [document frame];
        } else {
            window = [self window];
            frame = [window frame];
            minsize = [window minSize];
        }
    }
// We avoid making the trailing subview larger than its maximum, or the window smaller than its minimum.
    CGFloat limit = 0.0;
    if (dowin) {
        limit = DIM(frame.size)-DIM(minsize);
    } else {
        limit = trailing?([trailing maxDimension]-[trailing dimension]):WAYOUT;
    }
    if (-delta>limit) {
        if (always) {
            delta = -limit;
        } else {
            return;
        }
    }
    BOOL okl = limit>=[leading dimension];
    if (always||okl) {
// Resize leading.
        delta = -[leading changeDimensionBy:delta mayCollapse:okl move:NO];
        if (dowin) {
// Resize the window.
            DIM(frame.size) -= delta;
            if (ishor) {
                DIM(frame.origin) += delta;
            }
            if (document) {
                [document setFrame:frame];
                [document setNeedsDisplay:YES];
            } else {
                [window setFrame:frame display:YES];
            }
            [self setMustAdjust];
        } else {
// Otherwise, resize trailing.
            [trailing changeDimensionBy:delta mayCollapse:NO move:YES];
        }
    }
}

RB___tryToShortenTrailing:divider:leading:delta:always:

- (void) RB___tryToShortenTrailing: (RBSplitSubview*) trailing divider: (NSUInteger) indx leading: (RBSplitSubview*) leading delta: (CGFloat) delta always: (BOOL) always

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 25 of file RBSplitView.m.

                                 :(RBSplitSubview*)trailing divider:(NSUInteger)indx leading:(RBSplitSubview*)leading delta:(CGFloat)delta always:(BOOL)always {
    NSWindow* window = nil;
    NSView* document = nil;
    NSSize maxsize = NSMakeSize(WAYOUT,WAYOUT);
    NSRect frame = NSZeroRect;
    NSRect screen = NSMakeRect(0,0,WAYOUT,WAYOUT);
    BOOL ishor = NO;
// First we ask the delegate, if there's any, if the window should resize.
    BOOL dowin = ([self RB___shouldResizeWindowForDivider:indx betweenView:leading andView:trailing willGrow:YES]);
    if (dowin) {
// We initialize the other local variables only if we need them for the window.
        ishor = [self isHorizontal];
        document = [[self enclosingScrollView] documentView];
        if (document) {
            frame = [document frame];
        } else {
            window = [self window];
            frame = [window frame];
            maxsize = [window maxSize];
            screen = [[NSScreen mainScreen] visibleFrame];
        }
    }
// We avoid making the leading subview larger than its maximum, or the window larger than its maximum.
    CGFloat limit = 0.0;
    if (dowin) {
        CGFloat maxd = fMAX(0.0,(ishor?frame.origin.y-screen.origin.y:(screen.origin.x+screen.size.width)-(frame.origin.x+frame.size.width)));
        limit = fMIN(DIM(maxsize)-DIM(frame.size),maxd);
    } else {
        limit = [leading maxDimension]-[leading dimension];
    }
    if (delta>limit) {
        if (always) {
            delta = limit;
        } else {
            return;
        }
    }
    BOOL okl = dowin||(limit>=(trailing?[trailing dimension]:WAYOUT));
    if (always||okl) {
        if (dowin) {
// If we should resize the window, resize leading, then the window.
            delta = [leading changeDimensionBy:delta mayCollapse:NO move:NO];
            DIM(frame.size) += delta;
            if (ishor) {
                DIM(frame.origin) -= delta;
            }
            if (document) {
                [document setFrame:frame];
                [document setNeedsDisplay:YES];
            } else {
                [window setFrame:frame display:YES];
            }
            [self setMustAdjust];
        } else {
// Otherwise, resize trailing, then leading.
            if (trailing) {
                delta = -[trailing changeDimensionBy:-delta mayCollapse:okl move:YES];
            }
            [leading changeDimensionBy:delta mayCollapse:NO move:NO];
        }
    }
}

removeStateUsingName:

+ (void) removeStateUsingName:

(NSString*)

name

Definition at line 25 of file RBSplitView.m.

                            :(NSString*)name {
    if ([name length]) {
        NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
        [defaults removeObjectForKey:[[self class] defaultsKeyForName:name isHorizontal:NO]];
        [defaults removeObjectForKey:[[self class] defaultsKeyForName:name isHorizontal:YES]];
    }
}

resetCursorRects

- (void) resetCursorRects

implementation

Definition at line 25 of file RBSplitView.m.

                         {
    if (!dividers) {
        return;
    }
    id del = [delegate respondsToSelector:@selector(splitView:cursorRect:forDivider:)]?delegate:nil;
    NSArray* subviews = [self RB___subviews];
    NSInteger divcount = [subviews count]-1;
    if ((divcount<1)||![self divider]) {
        [del splitView:self cursorRect:NSZeroRect forDivider:0];
        return;
    }
    NSInteger i;
    NSCursor* cursor = [RBSplitView cursor:[self isVertical]?RBSVVerticalCursor:RBSVHorizontalCursor];
    CGFloat divt = [self dividerThickness];
    for (i=0;i<divcount;i++) {
        RBSplitView* sub = [[subviews objectAtIndex:i] coupledSplitView];
// If the leading subview is a nested RBSplitView, add the thumb rectangles first.
        if (sub) {
            [sub  RB___addCursorRectsTo:self forDividerRect:dividers[i] thickness:divt];
        }
        sub = [[subviews objectAtIndex:i+1] coupledSplitView];
// If the trailing subview is a nested RBSplitView, add the thumb rectangles first.
        if (sub) {
            [sub  RB___addCursorRectsTo:self forDividerRect:dividers[i] thickness:divt];
        }
// Now add the divider rectangle.
        NSRect divrect = dividers[i];
        if (del) {
            divrect = [del splitView:self cursorRect:divrect forDivider:i];
        }
        if (!NSIsEmptyRect(divrect)) {
            [self addCursorRect:divrect cursor:cursor];
        }
    }
}

restoreState:

- (BOOL) restoreState:

(BOOL)

recurse

Definition at line 25 of file RBSplitView.m.

                    :(BOOL)recurse {
    BOOL result = NO;
    if ([autosaveName length]) {
        result = [self setStateFromString:[[NSUserDefaults standardUserDefaults] stringForKey:[[self class] defaultsKeyForName:autosaveName isHorizontal:[self isHorizontal]]]];
        if (result&&recurse) {
            for (RBSplitSubview* sub in [self subviews]){
                [[sub asSplitView] restoreState:YES];
            }
        }
    }
    canSaveState = YES;
    return result;
}

saveState:

- (BOOL) saveState:

(BOOL)

recurse

Definition at line 25 of file RBSplitView.m.

                 :(BOOL)recurse {
// Saving the state is also disabled while dragging.
    if (canSaveState&&![self isDragging]&&[autosaveName length]) {
        [[NSUserDefaults standardUserDefaults] setObject:[self stringWithSavedState] forKey:[[self class] defaultsKeyForName:autosaveName isHorizontal:[self isHorizontal]]];
        if (recurse) {
            for (RBSplitSubview* sub in [self subviews]){
                [[sub asSplitView] saveState:YES];
            }
        }
        return YES;
    }
    return NO;
}

setAutosaveName:recursively:

- (void) setAutosaveName:		(NSString*)	aString
recursively:		(BOOL)	flag

Definition at line 25 of file RBSplitView.m.

                       :(NSString*)aString recursively:(BOOL)flag {
    BOOL clear;
    if ((clear = ![aString length])) {
        aString = @"";
    }
    [RBSplitView removeStateUsingName:autosaveName];
    [autosaveName autorelease];
    autosaveName = [aString retain];
    if (flag) {
        NSArray* subviews = [self subviews];
        NSUInteger subcount = [subviews count];
        NSUInteger i;
        for (i=0;i<subcount;i++) {
            RBSplitView* sv = [[subviews objectAtIndex:i] asSplitView];
            if (sv) {
                NSString* subst = clear?@"":[aString stringByAppendingFormat:@"[%ld]",i];
                [sv setAutosaveName:subst recursively:YES];
            }
        }
    }
}

setBackground:

- (void) setBackground:

(NSColor*)

color

Definition at line 25 of file RBSplitView.m.

                     :(NSColor*)color {
    if (![self couplingSplitView]) {
        [background autorelease];
        background = color?([color alphaComponent]>0.0?[color retain]:nil):nil;
        [self setNeedsDisplay:YES];
    }
}

setCoupled:

- (void) setCoupled: (BOOL) flag

implementation

Reimplemented from RBSplitSubview.

Definition at line 25 of file RBSplitView.m.

                  :(BOOL)flag {
    if (flag!=isCoupled) {
        isCoupled = flag;
// If we've just been uncoupled and there's no divider image, we copy it from the containing view. 
        if (!isCoupled&&!divider) {
            [self setDivider:[[self splitView] divider]];
        }
        [self setMustAdjust];
    }
}

setCursor:toCursor:

+ (void) setCursor:		(RBSVCursorType)	type
toCursor:		(NSCursor*)	cursor

Definition at line 25 of file RBSplitView.m.

                 :(RBSVCursorType)type toCursor:(NSCursor*)cursor {
    if ((type>=0)&&(type<RBSVCursorTypeCount)) {
        [cursors[type] release];
        cursors[type] = [cursor retain];
    }
}

setDelegate:

- (void) setDelegate:

(id)

anObject

Definition at line 25 of file RBSplitView.m.

                   :(id)anObject {
    delegate = anObject;
}

setDivider:

- (void) setDivider:

(NSImage*)

image

Definition at line 25 of file RBSplitView.m.

                  :(NSImage*)image {
    if (![self couplingSplitView]) {
        [divider autorelease];
        if ([image isFlipped]) {
// If the image is flipped, we just retain it.
            divider = [image retain];
        } else {
// if the image isn't flipped, we copy the image instead of retaining it, and flip the copy.
            divider = [image copy];
            [divider setFlipped:YES];
        }
// We set the thickness to 0.0 so the image dimension will prevail.
        [self setDividerThickness:0.0];
        [self setMustAdjust];
    }
}

setDividerThickness:

- (void) setDividerThickness:

(CGFloat)

thickness

Definition at line 25 of file RBSplitView.m.

                           :(CGFloat)thickness {
    CGFloat t = fMAX(0.0,floor(thickness));
    if ((NSInteger)dividerThickness!=(NSInteger)t) {
        dividerThickness = t;
        [self setMustAdjust];
    }
}

setFrameSize:

- (void) setFrameSize: (NSSize) size

implementation

Definition at line 25 of file RBSplitView.m.

                    :(NSSize)size {
//  NSLog(@"setFrameSize of %@ to %@",self,NSStringFromSize(size));
    NSSize oldsize = [self frame].size;
    [super setFrameSize:size];
    [self setMustAdjust];
    if ([delegate respondsToSelector:@selector(splitView:wasResizedFrom:to:)]) {
        BOOL ishor = [self isHorizontal];
        CGFloat olddim = DIM(oldsize);
        CGFloat newdim = DIM(size);
// The delegate is not called if the dimension hasn't changed.
        if (((NSInteger)newdim!=(NSInteger)olddim)) {
            [delegate splitView:self wasResizedFrom:olddim to:newdim];
        }
    }
// We adjust the subviews only if the delegate didn't.
    if (mustAdjust&&!isAdjusting) {
        [self adjustSubviews];
    }
}

setHorizontal:

- (void) setHorizontal:

(BOOL)

flag

Definition at line 25 of file RBSplitView.m.

                     :(BOOL)flag {
    if (![self splitView]&&(isHorizontal!=flag)) {
        BOOL ishor = isHorizontal = flag;
        NSSize size = divider?[divider size]:NSZeroSize;
        [self setDividerThickness:DIM(size)];
        [self setMustAdjust];
    }
}

setMustAdjust

- (void) setMustAdjust

Definition at line 25 of file RBSplitView.m.

                      {
    mustAdjust = YES;
    [self setNeedsDisplay:YES];
}

setStateFromString:

- (BOOL) setStateFromString:

(NSString*)

aString

Definition at line 25 of file RBSplitView.m.

                          :(NSString*)aString {
    if ([aString length]) {
        NSArray* parts = [aString componentsSeparatedByString:@" "];
        NSArray* subviews = [self subviews];
        NSInteger subcount = [subviews count];
        NSInteger k = [parts count];
        if ((k-->1)&&([[parts objectAtIndex:0] intValue]==subcount)&&(k==subcount)) {
            NSInteger i;
            NSRect frame = [self frame];
            BOOL ishor = [self isHorizontal];
            for (i=0;i<subcount;i++) {
                NSString* part = [parts objectAtIndex:i+1];
                double size = [part doubleValue];
                BOOL hidden = [part hasSuffix:@"H"];
                BOOL negative = size<=0.0;
                if (negative) {
                    size = -size;
                }
                double fract = size;
                size = floor(size);
                fract -= size;
                DIM(frame.size) = size;
                RBSplitSubview* sub = [subviews objectAtIndex:i];
                [sub RB___setFrame:frame withFraction:fract notify:NO];
                if (negative) {
                    [sub RB___collapse];
                }
                [sub RB___setHidden:hidden];
            }
            [self setMustAdjust];
            return YES;
        }
    }
    return NO;
}

setStatesFromArray:

- (BOOL) setStatesFromArray:

(NSArray*)

array

Definition at line 25 of file RBSplitView.m.

                          :(NSArray*)array {
    NSArray* subviews = [self subviews];
    NSUInteger count = [array count];
    if (count==([subviews count]+1)) {
        NSString* me = [array objectAtIndex:0];
        if ([me isKindOfClass:[NSString class]]) {
            if ([self setStateFromString:me]) {
                NSUInteger i;
                for (i=1;i<count;i++) {
                    NSArray* item = [array objectAtIndex:i];
                    RBSplitView* suv = [[subviews objectAtIndex:i-1] asSplitView];
                    if ([item isKindOfClass:[NSArray class]]==(suv!=nil)) {
                        if (suv&&![suv setStatesFromArray:item]) {
                            return NO;
                        }
                    } else {
                        return NO;
                    }
                }
                return YES;
            }
        }
    }
    return NO;
}

setVertical:

- (void) setVertical:

(BOOL)

flag

Definition at line 25 of file RBSplitView.m.

                   :(BOOL)flag {
    [self setHorizontal:!flag];
}

shouldDelayWindowOrderingForEvent:

- (BOOL) shouldDelayWindowOrderingForEvent: (NSEvent*) theEvent

implementation

Definition at line 25 of file RBSplitView.m.

                                         :(NSEvent*)theEvent {
    return ([theEvent modifierFlags]&NSCommandKeyMask)!=0;
}

stringWithSavedState

- (NSString *) stringWithSavedState

Definition at line 25 of file RBSplitView.m.

                                  {
    NSArray* subviews = [self subviews];
    NSMutableString* result = [NSMutableString stringWithFormat:@"%ld",[subviews count]];
    for (RBSplitSubview* sub in [self subviews]){
        double size = [sub dimension];
        if ([sub isCollapsed]) {
            size = -size;
        } else {
            size += +[sub RB___fraction];
        }
        [result appendFormat:[sub isHidden]?@" %gH":@" %g",size];
    }
    return result;
}

subviewAtPosition:

- (RBSplitSubview *) subviewAtPosition:

(NSUInteger)

position

Definition at line 25 of file RBSplitView.m.

                                    :(NSUInteger)position {
    NSArray* subviews = [super subviews];
    NSUInteger subcount = [subviews count];
    if (position<subcount) {
        return [subviews objectAtIndex:position];
    }
    return nil;
}

subviewWithIdentifier:

- (RBSplitSubview *) subviewWithIdentifier:

(NSString*)

anIdentifier

Definition at line 25 of file RBSplitView.m.

                                        :(NSString*)anIdentifier {
    for (RBSplitSubview* sub in [self subviews]){
        if ([anIdentifier isEqualToString:[sub identifier]]) {
            return sub;
        }
    }
    return nil;
}

viewDidMoveToSuperview

- (void) viewDidMoveToSuperview

implementation

Definition at line 25 of file RBSplitView.m.

                               {
    [super viewDidMoveToSuperview];
    NSScrollView* scrollv = [self enclosingScrollView];
    isInScrollView = scrollv?[scrollv documentView]==self:NO;
}

willRemoveSubview:

- (void) willRemoveSubview: (NSView*) subview

implementation

Definition at line 25 of file RBSplitView.m.

                         :(NSView*)subview {
    if ([subview respondsToSelector:@selector(RB___stopAnimation)]) {
        [(RBSplitSubview*)subview RB___stopAnimation];
    }
    [super willRemoveSubview:subview];
    [self setMustAdjust];
}

Member Data Documentation

autosaveName

- (NSString *) autosaveName

protected

Definition at line 26 of file RBSplitView.h.

background

- (NSColor *) background

protected

Definition at line 27 of file RBSplitView.h.

canSaveState

- (BOOL) canSaveState

protected

Definition at line 34 of file RBSplitView.h.

delegate

- (id) delegate

protected

Definition at line 25 of file RBSplitView.h.

divider

- (NSImage *) divider

protected

Definition at line 28 of file RBSplitView.h.

dividers

- (NSRect*) dividers

protected

Definition at line 29 of file RBSplitView.h.

dividerThickness

- (CGFloat) dividerThickness

protected

Definition at line 30 of file RBSplitView.h.

isAdjusting

- (BOOL) isAdjusting

protected

Definition at line 36 of file RBSplitView.h.

isCoupled

- (BOOL) isCoupled

protected

Definition at line 35 of file RBSplitView.h.

isDragging

- (BOOL) isDragging

protected

Definition at line 37 of file RBSplitView.h.

isHorizontal

- (BOOL) isHorizontal

protected

Definition at line 33 of file RBSplitView.h.

isInScrollView

- (BOOL) isInScrollView

protected

Definition at line 38 of file RBSplitView.h.

mustAdjust

- (BOOL) mustAdjust

protected

Definition at line 31 of file RBSplitView.h.

mustClearFractions

- (BOOL) mustClearFractions

protected

Definition at line 32 of file RBSplitView.h.

---

The documentation for this class was generated from the following files:

• Mac-specific/DebugBundle/Source/RBSplitView/RBSplitView.h
• Mac-specific/DebugBundle/Source/RBSplitView/RBSplitView.m