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 355 of file RBSplitView.m.

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

addSubview:

- (void) addSubview: (NSView*) aView

implementation

Definition at line 500 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];
}

References setMustAdjust.

Referenced by addSubview:atPosition:, and initWithFrame:andSubviews:.

Here is the call graph for this function:

Here is the caller graph for this function:

addSubview:atPosition:

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

Definition at line 527 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];
    }
}

References addSubview:, addSubview:positioned:relativeTo:, and subviewAtPosition:.

Referenced by OOJavaScriptConsoleController::awakeFromNib.

Here is the call graph for this function:

Here is the caller graph for this function:

addSubview:positioned:relativeTo:

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

implementation

Definition at line 513 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];
}

References setMustAdjust.

Referenced by addSubview:atPosition:, and RBSplitSubview::setPosition:.

Here is the call graph for this function:

Here is the caller graph for this function:

adjustSubviews

- (void) adjustSubviews

Definition at line 844 of file RBSplitView.m.

                       {
    [self RB___adjustSubviewsExcepting:nil];
}

References adjustSubviews, and RB___adjustSubviewsExcepting:.

Referenced by adjustSubviews, display, isInScrollView, needsDisplay, RBSplitView(RB___ViewAdditions)::RB___adjustOutermostIfNeeded, RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, RBSplitSubview(RB___SubviewAdditions)::RB___stepAnimation, setFrameSize:, and RBSplitSubview::setHidden:.

Here is the call graph for this function:

Here is the caller graph for this function:

adjustSubviewsExcepting:

- (void) adjustSubviewsExcepting:

(RBSplitSubview*)

excepting

Definition at line 839 of file RBSplitView.m.

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

References RBSplitSubview::isCollapsed.

Referenced by RBSplitSubview::setDimension:, RBSplitSubview::setHidden:, and OOJavaScriptConsoleController::splitView:wasResizedFrom:to:.

Here is the call graph for this function:

Here is the caller graph for this function:

arrayWithStates

- (NSArray *) arrayWithStates

Definition at line 146 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;
}

References arrayWithStates, and stringWithSavedState.

Referenced by arrayWithStates, and autosaveName.

Here is the call graph for this function:

Here is the caller graph for this function:

asSplitView

- (RBSplitView *) asSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 311 of file RBSplitView.m.

                            {
    return self;
}

References asSplitView.

Referenced by asSplitView.

Here is the call graph for this function:

Here is the caller graph for this function:

autoresizesSubviews

- (BOOL) autoresizesSubviews

implementation

Reimplemented from RBSplitSubview.

Definition at line 553 of file RBSplitView.m.

                            {
    return NO;
}

References autoresizesSubviews.

Referenced by autoresizesSubviews.

Here is the call graph for this function:

Here is the caller graph for this function:

autosaveName

- (NSString *) autosaveName

References arrayWithStates, autosaveName, and stringWithSavedState.

Here is the call graph for this function:

awakeFromNib

- (void) awakeFromNib

implementation

Definition at line 743 of file RBSplitView.m.

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

References awakeFromNib, restoreState:, and RBSplitSubview::splitView.

Referenced by awakeFromNib.

Here is the call graph for this function:

Here is the caller graph for this function:

background

- (NSColor *) background

References background, and isVertical.

Here is the call graph for this function:

coupledSplitView

- (RBSplitView *) coupledSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 316 of file RBSplitView.m.

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

References coupledSplitView, isCoupled, and nil.

Referenced by coupledSplitView, drawRect:, and mouseDown:.

Here is the call graph for this function:

Here is the caller graph for this function:

couplingSplitView

- (RBSplitView *) couplingSplitView

implementation

Reimplemented from RBSplitSubview.

Definition at line 306 of file RBSplitView.m.

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

References RBSplitSubview::couplingSplitView, couplingSplitView, isCoupled, and nil.

Referenced by couplingSplitView, isOpaque, RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, setBackground:, and setDivider:.

Here is the call graph for this function:

Here is the caller graph for this function:

cursor:

+ (NSCursor *) cursor:

(RBSVCursorType)

type

Definition at line 33 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];
}

References cursors, RBSV2WayCursor, RBSVCursorTypeCount, RBSVDragCursor, RBSVHorizontalCursor, and RBSVVerticalCursor.

Referenced by RBSplitSubview::mouseDown:, mouseDown:, and RBSplitView(RB___ViewAdditions)::RB___addCursorRectsTo:forDividerRect:thickness:.

Here is the caller graph for this function:

dealloc

- (void) dealloc

implementation

Reimplemented from RBSplitSubview.

Definition at line 277 of file RBSplitView.m.

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

References RBSplitSubview::dealloc, dealloc, and dividers.

Referenced by dealloc.

Here is the call graph for this function:

Here is the caller graph for this function:

defaultsKeyForName:isHorizontal:

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

Definition at line 72 of file RBSplitView.m.

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

delegate

- (id) delegate

References delegate.

description

- (NSString *) description

implementation

Reimplemented from RBSplitSubview.

Definition at line 389 of file RBSplitView.m.

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

References RBSplitSubview::description, description, and stringWithSavedState.

Referenced by description.

Here is the call graph for this function:

Here is the caller graph for this function:

display

- (void) display

implementation

Reimplemented from RBSplitSubview.

Definition at line 753 of file RBSplitView.m.

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

References adjustSubviews, RBSplitSubview::display, display, isAdjusting, and mustAdjust.

Referenced by RBSplitSubview::display, display, and RBSplitSubview::mouseDown:.

Here is the call graph for this function:

Here is the caller graph for this function:

divider

- (NSImage *) divider

References divider.

dividerThickness

- (CGFloat) dividerThickness

References dividerThickness.

drawDivider:inRect:betweenView:andView:

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

Definition at line 809 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];
    }
}

References background, delegate, and RBSplitSubview::splitView.

Referenced by RBSplitView(RB___ViewAdditions)::RB___drawDividersIn:forDividerRect:thickness:.

Here is the call graph for this function:

Here is the caller graph for this function:

drawRect:

- (void) drawRect: (NSRect) rect

implementation

Reimplemented from RBSplitSubview.

Definition at line 761 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];
                }
            }
        }
    }
}

References coupledSplitView, divider, dividers, dividerThickness, RBSplitSubview::drawRect:, RBSplitSubview::isCollapsed, RB___drawDividersIn:forDividerRect:thickness:, and RB___subviews.

Here is the call graph for this function:

encodeWithCoder:

- (void) encodeWithCoder: (NSCoder *) coder

implementation

Reimplemented from RBSplitSubview.

Definition at line 890 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];
    }
}

References RBSplitSubview::encodeWithCoder:.

Here is the call graph for this function:

initWithCoder:

- (id) initWithCoder: (NSCoder *) coder

implementation

Reimplemented from RBSplitSubview.

Definition at line 911 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;
}

References canSaveState, dividers, isCoupled, isDragging, isHorizontal, isInScrollView, nil, setAutosaveName:recursively:, setBackground:, setDelegate:, setDivider:, setDividerThickness:, and setMustAdjust.

Here is the call graph for this function:

initWithFrame:

- (id) initWithFrame:

(NSRect)

frame

Reimplemented from RBSplitSubview.

Definition at line 248 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;
}

References canSaveState, dividers, RBSplitSubview::initWithFrame:, isCoupled, isDragging, isInScrollView, setAutosaveName:recursively:, setBackground:, setDivider:, and setVertical:.

Referenced by initWithFrame:andSubviews:.

Here is the call graph for this function:

Here is the caller graph for this function:

initWithFrame:andSubviews:

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

Definition at line 265 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;
}

References addSubview:, count, initWithFrame:, and setMustAdjust.

Here is the call graph for this function:

isAdjusting

- (BOOL) isAdjusting

References isAdjusting.

isDragging

- (BOOL) isDragging

References isDragging.

isFlipped

- (BOOL) isFlipped

implementation

Reimplemented from RBSplitSubview.

Definition at line 327 of file RBSplitView.m.

                  {
    return YES;
}

References isFlipped.

Referenced by isFlipped, and setDivider:.

Here is the call graph for this function:

Here is the caller graph for this function:

isHorizontal

- (BOOL) isHorizontal

References isHorizontal, and setMustAdjust.

Here is the call graph for this function:

isInScrollView

- (BOOL) isInScrollView

References adjustSubviews, and isInScrollView.

Here is the call graph for this function:

isOpaque

- (BOOL) isOpaque

implementation

Reimplemented from RBSplitSubview.

Definition at line 382 of file RBSplitView.m.

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

References background, couplingSplitView, and isOpaque.

Referenced by RBSplitSubview::isOpaque, and isOpaque.

Here is the call graph for this function:

Here is the caller graph for this function:

isVertical

- (BOOL) isVertical

Definition at line 412 of file RBSplitView.m.

                   {
    return ![self isHorizontal];
}

References isHorizontal, and isVertical.

Referenced by background, isVertical, and resetCursorRects.

Here is the call graph for this function:

Here is the caller graph for this function:

mouseDown:

- (void) mouseDown: (NSEvent*) theEvent

implementation

Reimplemented from RBSplitSubview.

Definition at line 582 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];
            }
        }
    }
}

References RBSplitSubview::actDivider, RBSplitSubview::canCollapse, coupledSplitView, cursor:, delegate, DIM, RBSplitSubview::dimension, RBSplitSubview::display, divider, dividers, dividerThickness, RBSplitSubview::isCollapsed, isHorizontal, RBSplitSubview::mouseDown:, mustAdjust, OTHER, RB___dividerHitBy:relativeToView:thickness:, RB___dividerRect:relativeToView:, RB___setDragging:, RB___setMustClearFractions, RB___subviews, RB___trackMouseEvent:from:withBase:inDivider:, RB___tryToExpandLeading:divider:trailing:delta:, RB___tryToExpandTrailing:leading:delta:, RB___tryToShortenLeading:divider:trailing:delta:always:, RB___tryToShortenTrailing:divider:leading:delta:always:, and RBSplitSubview::splitView.

Here is the call graph for this function:

mouseDownCanMoveWindow

- (BOOL) mouseDownCanMoveWindow

implementation

Definition at line 321 of file RBSplitView.m.

                               {
    return NO;
}

References mouseDownCanMoveWindow.

Referenced by mouseDownCanMoveWindow.

Here is the call graph for this function:

Here is the caller graph for this function:

mustAdjust

- (BOOL) mustAdjust

References mustAdjust.

needsDisplay

- (BOOL) needsDisplay

implementation

Definition at line 734 of file RBSplitView.m.

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

References adjustSubviews, isAdjusting, mustAdjust, and needsDisplay.

Referenced by needsDisplay.

Here is the call graph for this function:

Here is the caller graph for this function:

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 1370 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];
            }
        }
    }
}

Referenced by resetCursorRects.

Here is the caller graph for this function:

RB___adjustOutermostIfNeeded

- (void) RB___adjustOutermostIfNeeded

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1424 of file RBSplitView.m.

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

Referenced by RBSplitView(RB___ViewAdditions)::RB___adjustOutermostIfNeeded.

Here is the caller graph for this function:

RB___adjustSubviewsExcepting:

- (void) RB___adjustSubviewsExcepting: (RBSplitSubview*) excepting

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1440 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];
    }
}

Referenced by adjustSubviews.

Here is the caller graph for this function:

RB___dimensionWithoutDividers

- (CGFloat) RB___dimensionWithoutDividers

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1011 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));
}

Referenced by RBSplitSubview::dimension, RBSplitSubview(RB___SubviewAdditions)::RB___collapse, RBSplitSubview(RB___SubviewAdditions)::RB___expandAndSetToMinimum:, RBSplitSubview(RB___SubviewAdditions)::RB___stepAnimation, and RBSplitSubview::setDimension:.

Here is the caller graph for this function:

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 1034 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;
}

Referenced by mouseDown:.

Here is the caller graph for this function:

RB___dividerOrigin:

- (CGFloat) RB___dividerOrigin: (NSUInteger) indx

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 983 of file RBSplitView.m.

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

Referenced by RBSplitSubview::mouseDown:.

Here is the caller graph for this function:

RB___dividerRect:relativeToView:

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

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1020 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;
}

Referenced by mouseDown:.

Here is the caller graph for this function:

RB___dividerThickness

- (CGFloat) RB___dividerThickness

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1006 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 1396 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];
        }
    }
}

Referenced by drawRect:.

Here is the caller graph for this function:

RB___numberOfSubviews

- (NSUInteger) RB___numberOfSubviews

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 972 of file RBSplitView.m.

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

Referenced by RBSplitView(RB___ViewAdditions)::RB___dividerHitBy:relativeToView:thickness:.

Here is the caller graph for this function:

RB___setDragging:

- (void) RB___setDragging: (BOOL) flag

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 963 of file RBSplitView.m.

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

Referenced by RBSplitSubview::mouseDown:, mouseDown:, RBSplitSubview(RB___SubviewAdditions)::RB___animationData:resize:, and RBSplitSubview(RB___SubviewAdditions)::RB___stopAnimation.

Here is the caller graph for this function:

RB___setMustClearFractions

- (void) RB___setMustClearFractions

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 1057 of file RBSplitView.m.

                                   {
    mustClearFractions = YES;
}

Referenced by RBSplitSubview::changeDimensionBy:mayCollapse:move:, RBSplitSubview::mouseDown:, mouseDown:, RBSplitSubview(RB___SubviewAdditions)::RB___finishCollapse:withFraction:, and RBSplitSubview(RB___SubviewAdditions)::RB___finishExpand:withFraction:.

Here is the caller graph for this function:

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 1063 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;
}

Referenced by RBSplitView(RB___ViewAdditions)::RB___tryToExpandLeading:divider:trailing:delta:, RBSplitView(RB___ViewAdditions)::RB___tryToShortenLeading:divider:trailing:delta:always:, and RBSplitView(RB___ViewAdditions)::RB___tryToShortenTrailing:divider:leading:delta:always:.

Here is the caller graph for this function:

RB___subviews

- (NSArray *) RB___subviews

implementation

Provided by category RBSplitView(RB___ViewAdditions).

Definition at line 993 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;
}

Referenced by drawRect:, mouseDown:, RBSplitView(RB___ViewAdditions)::RB___addCursorRectsTo:forDividerRect:thickness:, RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, RBSplitView(RB___ViewAdditions)::RB___drawDividersIn:forDividerRect:thickness:, RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:, and resetCursorRects.

Here is the caller graph for this function:

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 1300 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];
        }
    }
}

Referenced by RBSplitSubview::mouseDown:, and mouseDown:.

Here is the caller graph for this function:

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 1071 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];
    }
}

Referenced by mouseDown:, and RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:.

Here is the caller graph for this function:

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 1267 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];
}

Referenced by mouseDown:, and RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:.

Here is the caller graph for this function:

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 1142 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];
        }
    }
}

Referenced by mouseDown:, and RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:.

Here is the caller graph for this function:

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 1203 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];
        }
    }
}

Referenced by mouseDown:, and RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:.

Here is the caller graph for this function:

removeStateUsingName:

+ (void) removeStateUsingName:

(NSString*)

name

Definition at line 63 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]];
    }
}

Referenced by setAutosaveName:recursively:.

Here is the caller graph for this function:

resetCursorRects

- (void) resetCursorRects

implementation

Definition at line 850 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];
        }
    }
}

References delegate, divider, dividers, dividerThickness, isVertical, nil, RB___addCursorRectsTo:forDividerRect:thickness:, RB___subviews, and resetCursorRects.

Referenced by resetCursorRects.

Here is the call graph for this function:

Here is the caller graph for this function:

restoreState:

- (BOOL) restoreState:

(BOOL)

recurse

Definition at line 129 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;
}

References autosaveName, canSaveState, isHorizontal, and setStateFromString:.

Referenced by awakeFromNib.

Here is the call graph for this function:

Here is the caller graph for this function:

saveState:

- (BOOL) saveState:

(BOOL)

recurse

Definition at line 112 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;
}

References autosaveName, canSaveState, isDragging, isHorizontal, and stringWithSavedState.

Referenced by RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, and RBSplitView(RB___ViewAdditions)::RB___setDragging:.

Here is the call graph for this function:

Here is the caller graph for this function:

setAutosaveName:recursively:

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

Definition at line 87 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];
            }
        }
    }
}

References autosaveName, removeStateUsingName:, and setAutosaveName:recursively:.

Referenced by initWithCoder:, initWithFrame:, and setAutosaveName:recursively:.

Here is the call graph for this function:

Here is the caller graph for this function:

setBackground:

- (void) setBackground:

(NSColor*)

color

Definition at line 374 of file RBSplitView.m.

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

References background, couplingSplitView, and nil.

Referenced by initWithCoder:, and initWithFrame:.

Here is the call graph for this function:

Here is the caller graph for this function:

setCoupled:

- (void) setCoupled: (BOOL) flag

implementation

Reimplemented from RBSplitSubview.

Definition at line 290 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];
    }
}

References divider, isCoupled, setDivider:, setMustAdjust, and RBSplitSubview::splitView.

Here is the call graph for this function:

setCursor:toCursor:

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

Definition at line 55 of file RBSplitView.m.

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

References cursors, and RBSVCursorTypeCount.

setDelegate:

- (void) setDelegate:

(id)

anObject

Definition at line 445 of file RBSplitView.m.

                   :(id)anObject {
    delegate = anObject;
}

References delegate.

Referenced by OOJavaScriptConsoleController::awakeFromNib, and initWithCoder:.

Here is the caller graph for this function:

setDivider:

- (void) setDivider:

(NSImage*)

image

Definition at line 458 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];
    }
}

References couplingSplitView, divider, isFlipped, setDividerThickness:, and setMustAdjust.

Referenced by OOJavaScriptConsoleController::awakeFromNib, initWithCoder:, initWithFrame:, and setCoupled:.

Here is the call graph for this function:

Here is the caller graph for this function:

setDividerThickness:

- (void) setDividerThickness:

(CGFloat)

thickness

Definition at line 490 of file RBSplitView.m.

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

References dividerThickness, fMAX(), and setMustAdjust.

Referenced by initWithCoder:, setDivider:, and setHorizontal:.

Here is the call graph for this function:

Here is the caller graph for this function:

setFrameSize:

- (void) setFrameSize: (NSSize) size

implementation

Definition at line 559 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];
    }
}

References adjustSubviews, delegate, DIM, isAdjusting, isHorizontal, mustAdjust, setMustAdjust, and RBSplitSubview::splitView.

Here is the call graph for this function:

setHorizontal:

- (void) setHorizontal:

(BOOL)

flag

Definition at line 403 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];
    }
}

References divider, isHorizontal, setDividerThickness:, setMustAdjust, and RBSplitSubview::splitView.

Referenced by setVertical:.

Here is the call graph for this function:

Here is the caller graph for this function:

setMustAdjust

- (void) setMustAdjust

Definition at line 333 of file RBSplitView.m.

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

References mustAdjust, and setMustAdjust.

Referenced by addSubview:, addSubview:positioned:relativeTo:, RBSplitSubview::changeDimensionBy:mayCollapse:move:, initWithCoder:, initWithFrame:andSubviews:, isHorizontal, RBSplitSubview(RB___SubviewAdditions)::RB___setFrame:withFraction:notify:, RBSplitSubview(RB___SubviewAdditions)::RB___setFrameSize:withFraction:, RBSplitView(RB___ViewAdditions)::RB___tryToExpandLeading:divider:trailing:delta:, RBSplitView(RB___ViewAdditions)::RB___tryToShortenLeading:divider:trailing:delta:always:, RBSplitView(RB___ViewAdditions)::RB___tryToShortenTrailing:divider:leading:delta:always:, setCoupled:, setDivider:, setDividerThickness:, setFrameSize:, setHorizontal:, RBSplitSubview::setMinDimension:andMaxDimension:, setMustAdjust, setStateFromString:, and willRemoveSubview:.

Here is the call graph for this function:

Here is the caller graph for this function:

setStateFromString:

- (BOOL) setStateFromString:

(NSString*)

aString

Definition at line 210 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;
}

References DIM, isHorizontal, RBSplitSubview::RB___collapse, RBSplitSubview::RB___setFrame:withFraction:notify:, RBSplitSubview::RB___setHidden:, and setMustAdjust.

Referenced by restoreState:.

Here is the call graph for this function:

Here is the caller graph for this function:

setStatesFromArray:

- (BOOL) setStatesFromArray:

(NSArray*)

array

Definition at line 164 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;
}

References count, and nil.

setVertical:

- (void) setVertical:

(BOOL)

flag

Definition at line 416 of file RBSplitView.m.

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

References setHorizontal:.

Referenced by OOJavaScriptConsoleController::awakeFromNib, and initWithFrame:.

Here is the call graph for this function:

Here is the caller graph for this function:

shouldDelayWindowOrderingForEvent:

- (BOOL) shouldDelayWindowOrderingForEvent: (NSEvent*) theEvent

implementation

Definition at line 359 of file RBSplitView.m.

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

stringWithSavedState

- (NSString *) stringWithSavedState

Definition at line 193 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;
}

References RBSplitSubview::isCollapsed, and stringWithSavedState.

Referenced by arrayWithStates, autosaveName, description, saveState:, and stringWithSavedState.

Here is the call graph for this function:

Here is the caller graph for this function:

subviewAtPosition:

- (RBSplitSubview *) subviewAtPosition:

(NSUInteger)

position

Definition at line 431 of file RBSplitView.m.

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

References nil, and RBSplitSubview::position.

Referenced by addSubview:atPosition:, and OOJavaScriptConsoleController::awakeFromNib.

Here is the call graph for this function:

Here is the caller graph for this function:

subviewWithIdentifier:

- (RBSplitSubview *) subviewWithIdentifier:

(NSString*)

anIdentifier

Definition at line 421 of file RBSplitView.m.

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

References RBSplitSubview::identifier, and nil.

viewDidMoveToSuperview

- (void) viewDidMoveToSuperview

implementation

Definition at line 537 of file RBSplitView.m.

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

References isInScrollView, and viewDidMoveToSuperview.

Referenced by viewDidMoveToSuperview.

Here is the call graph for this function:

Here is the caller graph for this function:

willRemoveSubview:

- (void) willRemoveSubview: (NSView*) subview

implementation

Definition at line 544 of file RBSplitView.m.

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

References RBSplitSubview::RB___stopAnimation, and setMustAdjust.

Here is the call graph for this function:

Member Data Documentation

autosaveName

- (NSString *) autosaveName

protected

Definition at line 79 of file RBSplitView.m.

                          {
    return autosaveName;
}

Referenced by autosaveName, restoreState:, saveState:, and setAutosaveName:recursively:.

background

- (NSColor *) background

protected

Definition at line 369 of file RBSplitView.m.

                       {
    RBSplitView* sv = [self couplingSplitView];
    return sv?[sv background]:background;
}

Referenced by background, drawDivider:inRect:betweenView:andView:, RBSplitSubview::drawRect:, isOpaque, and setBackground:.

canSaveState

- (BOOL) canSaveState

protected

Definition at line 34 of file RBSplitView.h.

Referenced by initWithCoder:, initWithFrame:, restoreState:, and saveState:.

delegate

- (id) delegate

protected

Definition at line 441 of file RBSplitView.m.

               {
    return delegate;
}

Referenced by delegate, drawDivider:inRect:betweenView:andView:, RBSplitSubview::drawRect:, RBSplitSubview::hitTest:, mouseDown:, RBSplitSubview(RB___SubviewAdditions)::RB___animationData:resize:, RBSplitSubview(RB___SubviewAdditions)::RB___finishCollapse:withFraction:, RBSplitSubview(RB___SubviewAdditions)::RB___finishExpand:withFraction:, RBSplitSubview(RB___SubviewAdditions)::RB___setFrame:withFraction:notify:, resetCursorRects, setDelegate:, and setFrameSize:.

divider

- (NSImage *) divider

protected

Definition at line 453 of file RBSplitView.m.

                    {
    RBSplitView* sv = [self couplingSplitView];
    return sv?[sv divider]:divider;
}

Referenced by divider, drawRect:, mouseDown:, RBSplitView(RB___ViewAdditions)::RB___drawDividersIn:forDividerRect:thickness:, resetCursorRects, setCoupled:, setDivider:, and setHorizontal:.

dividers

- (NSRect*) dividers

protected

Definition at line 29 of file RBSplitView.h.

Referenced by dealloc, drawRect:, initWithCoder:, initWithFrame:, mouseDown:, and resetCursorRects.

dividerThickness

- (CGFloat) dividerThickness

protected

Definition at line 477 of file RBSplitView.m.

                            {
    if (dividerThickness>0.0) {
        return dividerThickness;
    }
    NSImage* divdr = [self divider];
    if (divdr) {
        NSSize size = [divdr size];
        BOOL ishor = [self isHorizontal];
        return DIM(size);
    }
    return 0.0;
}

Referenced by dividerThickness, drawRect:, mouseDown:, RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, resetCursorRects, and setDividerThickness:.

isAdjusting

- (BOOL) isAdjusting

protected

Definition at line 954 of file RBSplitView.m.

                    {
    return isAdjusting;
}

Referenced by display, isAdjusting, needsDisplay, and setFrameSize:.

isCoupled

- (BOOL) isCoupled

protected

Definition at line 301 of file RBSplitView.m.

                  {
    return isCoupled&&([super splitView]!=nil);
}

Referenced by coupledSplitView, couplingSplitView, initWithCoder:, initWithFrame:, and setCoupled:.

isDragging

- (BOOL) isDragging

protected

Definition at line 344 of file RBSplitView.m.

                   {
    return isDragging;
}

Referenced by initWithCoder:, initWithFrame:, isDragging, and saveState:.

isHorizontal

- (BOOL) isHorizontal

protected

Definition at line 398 of file RBSplitView.m.

                     {
    RBSplitView* sv = [self splitView];
    return sv?[sv isVertical]:isHorizontal;
}

Referenced by RBSplitSubview::changeDimensionBy:mayCollapse:move:, initWithCoder:, isHorizontal, isVertical, RBSplitSubview::mouseDown:, mouseDown:, RBSplitView(RB___ViewAdditions)::RB___addCursorRectsTo:forDividerRect:thickness:, RBSplitView(RB___ViewAdditions)::RB___adjustSubviewsExcepting:, RBSplitSubview(RB___SubviewAdditions)::RB___collapse, RBSplitView(RB___ViewAdditions)::RB___dimensionWithoutDividers, RBSplitView(RB___ViewAdditions)::RB___dividerHitBy:relativeToView:thickness:, RBSplitView(RB___ViewAdditions)::RB___dividerOrigin:, RBSplitView(RB___ViewAdditions)::RB___drawDividersIn:forDividerRect:thickness:, RBSplitSubview(RB___SubviewAdditions)::RB___expandAndSetToMinimum:, RBSplitSubview(RB___SubviewAdditions)::RB___stepAnimation, RBSplitView(RB___ViewAdditions)::RB___trackMouseEvent:from:withBase:inDivider:, RBSplitView(RB___ViewAdditions)::RB___tryToExpandLeading:divider:trailing:delta:, RBSplitView(RB___ViewAdditions)::RB___tryToShortenLeading:divider:trailing:delta:always:, RBSplitView(RB___ViewAdditions)::RB___tryToShortenTrailing:divider:leading:delta:always:, RBSplitSubview::resizeSubviewsWithOldSize:, restoreState:, saveState:, RBSplitSubview::setDimension:, setFrameSize:, setHorizontal:, setStateFromString:, and RBSplitSubview::splitViewIsHorizontal.

isInScrollView

- (BOOL) isInScrollView

protected

Definition at line 349 of file RBSplitView.m.

                       {
    return isInScrollView;
}

Referenced by initWithCoder:, initWithFrame:, isInScrollView, and viewDidMoveToSuperview.

mustAdjust

- (BOOL) mustAdjust

protected

Definition at line 339 of file RBSplitView.m.

                   {
    return mustAdjust;
}

Referenced by display, mouseDown:, mustAdjust, needsDisplay, setFrameSize:, and setMustAdjust.

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