RBSplitView(RB___ViewAdditions) Category Reference

#include <RBSplitViewPrivateDefines.h>

Instance Methods
(void)	- RB___adjustOutermostIfNeeded
(void)	- RB___setDragging:
(CGFloat)	- RB___dividerOrigin:
(NSArray *)	- RB___subviews
(NSUInteger)	- RB___numberOfSubviews
(void)	- RB___adjustSubviewsExcepting:
(CGFloat)	- RB___dimensionWithoutDividers
(CGFloat)	- RB___dividerThickness
(NSRect)	- RB___dividerRect:relativeToView:
(void)	- RB___setMustClearFractions
(BOOL)	- RB___shouldResizeWindowForDivider:betweenView:andView:willGrow:
(void)	- RB___tryToExpandLeading:divider:trailing:delta:
(void)	- RB___tryToShortenLeading:divider:trailing:delta:always:
(void)	- RB___tryToExpandTrailing:leading:delta:
(void)	- RB___tryToShortenTrailing:divider:leading:delta:always:
(void)	- RB___trackMouseEvent:from:withBase:inDivider:
(void)	- RB___addCursorRectsTo:forDividerRect:thickness:
(NSUInteger)	- RB___dividerHitBy:relativeToView:thickness:
(void)	- RB___drawDividersIn:forDividerRect:thickness:

Detailed Description

Definition at line 960 of file RBSplitView.m.

Method Documentation

RB___addCursorRectsTo:forDividerRect:thickness:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___adjustOutermostIfNeeded

- (void) RB___adjustOutermostIfNeeded

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___adjustSubviewsExcepting:

- (void) RB___adjustSubviewsExcepting:

(RBSplitSubview*)

excepting

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___dimensionWithoutDividers

- (CGFloat) RB___dimensionWithoutDividers

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___dividerHitBy:relativeToView:thickness:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___dividerOrigin:

- (CGFloat) RB___dividerOrigin:

(NSUInteger)

indx

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___dividerRect:relativeToView:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___dividerThickness

- (CGFloat) RB___dividerThickness

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

                                 {
    return dividerThickness;
}

RB___drawDividersIn:forDividerRect:thickness:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___numberOfSubviews

- (NSUInteger) RB___numberOfSubviews

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___setDragging:

- (void) RB___setDragging:

(BOOL)

flag

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___setMustClearFractions

- (void) RB___setMustClearFractions

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

                                   {
    mustClearFractions = YES;
}

RB___shouldResizeWindowForDivider:betweenView:andView:willGrow:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___subviews

- (NSArray *) RB___subviews

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___trackMouseEvent:from:withBase:inDivider:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___tryToExpandLeading:divider:trailing:delta:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___tryToExpandTrailing:leading:delta:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___tryToShortenLeading:divider:trailing:delta:always:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

RB___tryToShortenTrailing:divider:leading:delta:always:

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

Extends class RBSplitView.

Definition at line 25 of file RBSplitView.m.

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

---

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

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