[Author: thomasvl]

Move the nib finding code in GTMUILocalizer to a class methods so it can
  be called without an instance.
Add GTMUILocalizerAndLayoutTweaker getting UI localized and then running
  through it to auto size UI items that have been marked and also support
  limited tweaks on other objects based on a group of tweaks.
Provide a class method for this sizeToFit fixup of individual objects.
Unittests for the new class.

R=dmaclach,stuartmorgan
DELTA=3161  (3157 added, 0 deleted, 4 changed)

1 files changed, 300 insertions, 0 deletions

diff --git a/AppKit/GTMUILocalizerAndLayoutTweaker.m b/AppKit/GTMUILocalizerAndLayoutTweaker.m
new file mode 100644
index 0000000..5ee8298
--- /dev/null
+++ b/AppKit/GTMUILocalizerAndLayoutTweaker.m
@@ -0,0 +1,300 @@
+//
+//  GTMUILocalizerAndLayoutTweaker.m
+//
+//  Copyright 2009 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import "GTMDefines.h"
+#import "GTMUILocalizerAndLayoutTweaker.h"
+#import "GTMUILocalizer.h"
+
+// Helper that will try to do a SizeToFit on any UI items and do the special
+// case handling we also need to end up with a usable UI item.  It also takes
+// an offset so we can slide the item if we need to.
+// Returns the change in the view's size.
+static NSSize SizeToFit(NSView *view, NSPoint offset);
+// Compare function for -[NSArray sortedArrayUsingFunction:context:]
+static NSInteger CompareFrameX(id view1, id view2, void *context);
+// Check if the view is anchored on the right (fixed right, flexable left).
+static BOOL IsRightAnchored(NSView *view);
+
+@interface GTMUILocalizerAndLayoutTweaker (PrivateMethods)
+// Recursively walk the UI triggering Tweakers.
+- (void)tweakView:(NSView *)view;
+@end
+
+@interface GTMWidthBasedTweaker (InternalMethods)
+// Does the actual work to size and adjust the views within this Tweaker.  The
+// offset is the amount this view should shift as part of it's resize.
+// Returns change in this view's width.
+- (CGFloat)tweakLayoutWithOffset:(NSPoint)offset;
+@end
+
+@implementation GTMUILocalizerAndLayoutTweaker
+
+- (void)awakeFromNib {
+  if (uiObject_) {
+    GTMUILocalizer *localizer = localizer_;
+    if (!localizer) {
+      NSBundle *bundle = [GTMUILocalizer bundleForOwner:localizerOwner_];
+      localizer = [[[GTMUILocalizer alloc] initWithBundle:bundle] autorelease];
+    }
+    [self applyLocalizer:localizer tweakingUI:uiObject_];
+  }
+}
+
+- (void)applyLocalizer:(GTMUILocalizer *)localizer
+            tweakingUI:(id)uiObject {
+  // Localize first
+  [localizer localizeObject:uiObject recursively:YES];
+
+  // Figure out where we start
+  NSView *startView;
+  if ([uiObject isKindOfClass:[NSWindow class]]) {
+    startView = [(NSWindow *)uiObject contentView];
+  } else {
+    _GTMDevAssert([uiObject isKindOfClass:[NSView class]],
+                  @"should have been a subclass of NSView");
+    startView = (NSView *)uiObject;
+  }
+
+  // And Tweak!
+  [self tweakView:startView];
+}
+
+- (void)tweakView:(NSView *)view {
+  // If its a alignment box, let it do its thing, otherwise, go find boxes
+  if ([view isKindOfClass:[GTMWidthBasedTweaker class]]) {
+    [(GTMWidthBasedTweaker *)view tweakLayoutWithOffset:NSZeroPoint];
+  } else {
+    NSArray *subviews = [view subviews];
+    NSView *subview = nil;
+    GTM_FOREACH_OBJECT(subview, subviews) {
+      [self tweakView:subview];
+    }
+  }
+}
+
++ (NSSize)sizeToFitView:(NSView *)view {
+  return SizeToFit(view, NSZeroPoint);
+}
+
+@end
+
+@implementation GTMWidthBasedTweaker
+
+- (CGFloat)changedWidth {
+  return widthChange_;
+}
+
+- (CGFloat)tweakLayoutWithOffset:(NSPoint)offset {
+  NSArray *subviews = [self subviews];
+  if (![subviews count]) {
+    widthChange_ = 0.0;
+    return widthChange_;
+  }
+
+  BOOL sumMode = NO;
+  NSMutableArray *rightAlignedSubViews = nil;
+  NSMutableArray *rightAlignedSubViewDeltas = nil;
+  if ([subviews count] > 1) {
+    // Do they share left edges (within a pixel)
+    if (fabs(NSMinX([[subviews objectAtIndex:0] frame]) -
+             NSMinX([[subviews objectAtIndex:1] frame])) > 1.0) {
+      // No, so walk them x order moving them along so they don't overlap.
+      sumMode = YES;
+      subviews = [subviews sortedArrayUsingFunction:CompareFrameX context:NULL];
+    } else {
+      // Since they are vertical, any views pinned to the right will have to be
+      // shifted after we finish figuring out the final size.
+      rightAlignedSubViews = [NSMutableArray array];
+      rightAlignedSubViewDeltas = [NSMutableArray array];
+    }
+  }
+
+  // Size our subviews
+  NSView *subView;
+  CGFloat finalDelta = sumMode ? 0 : -CGFLOAT_MAX;
+  NSPoint subViewOffset = NSZeroPoint;
+  GTM_FOREACH_OBJECT(subView, subviews) {
+    if (sumMode) {
+      subViewOffset.x = finalDelta;
+    }
+    CGFloat delta = SizeToFit(subView, subViewOffset).width;
+    if (sumMode) {
+      finalDelta += delta;
+    } else {
+      if (delta > finalDelta) {
+        finalDelta = delta;
+      }
+    }
+    // Track the right anchored subviews size changes so we can update them
+    // once we know this view's size.
+    if (IsRightAnchored(subView)) {
+      [rightAlignedSubViews addObject:subView];
+      [rightAlignedSubViewDeltas addObject:[NSNumber numberWithDouble:delta]];
+    }
+  }
+
+  // Are we pinned to the right of our parent?
+  BOOL rightAnchored = IsRightAnchored(self);
+
+  // Adjust our size (turn off auto resize, because we just fixed up all the
+  // objects within us).
+  BOOL autoresizesSubviews = [self autoresizesSubviews];
+  if (autoresizesSubviews) {
+    [self setAutoresizesSubviews:NO];
+  }
+  NSRect selfFrame = [self frame];
+  selfFrame.size.width += finalDelta;
+  if (rightAnchored) {
+    // Right side is anchored, so we need to slide back to the left.
+    selfFrame.origin.x -= finalDelta;
+  }
+  selfFrame.origin.x += offset.x;
+  selfFrame.origin.y += offset.y;
+  [self setFrame:selfFrame];
+  if (autoresizesSubviews) {
+    [self setAutoresizesSubviews:autoresizesSubviews];
+  }
+
+  // Now spin over the list of right aligned view and their size changes
+  // fixing up their positions so they are still right aligned in our final
+  // view.
+  for (NSUInteger lp = 0; lp < [rightAlignedSubViews count]; ++lp) {
+    subView = [rightAlignedSubViews objectAtIndex:lp];
+    CGFloat delta = [[rightAlignedSubViewDeltas objectAtIndex:lp] doubleValue];
+    NSRect viewFrame = [subView frame];
+    viewFrame.origin.x += -delta + finalDelta;
+    [subView setFrame:viewFrame];
+  }
+
+  if (viewToSlideAndResize_) {
+    NSRect viewFrame = [viewToSlideAndResize_ frame];
+    if (!rightAnchored) {
+      // If our right wasn't anchored, this view slides (we push it right).
+      // (If our right was anchored, the assumption is the view is in front of
+      // us so its x shouldn't move.)
+      viewFrame.origin.x += finalDelta;
+    }
+    viewFrame.size.width -= finalDelta;
+    [viewToSlideAndResize_ setFrame:viewFrame];
+  }
+  if (viewToSlide_) {
+    NSRect viewFrame = [viewToSlide_ frame];
+    // Move the view the same direction we moved.
+    if (rightAnchored) {
+      viewFrame.origin.x -= finalDelta;
+    } else {
+      viewFrame.origin.x += finalDelta;
+    }
+    [viewToSlide_ setFrame:viewFrame];
+  }
+  if (viewToResize_) {
+    if ([viewToResize_ isKindOfClass:[NSWindow class]]) {
+      NSWindow *window = (NSWindow *)viewToResize_;
+      NSRect windowFrame = [window frame];
+      windowFrame.size.width += finalDelta;
+      [window setFrame:windowFrame display:YES];
+      // For some reason the content view is resizing, but not adjusting its
+      // origin, so correct it manually.
+      [[window contentView] setFrameOrigin:NSMakePoint(0, 0)];
+      // TODO: should we update min size?
+    } else {
+      NSRect viewFrame = [viewToResize_ frame];
+      viewFrame.size.width += finalDelta;
+      [viewToResize_ setFrame:viewFrame];
+      // TODO: should we check if this view is right anchored, and adjust its
+      // x position also?
+    }
+  }
+
+  widthChange_ = finalDelta;
+  return widthChange_;
+}
+
+@end
+
+#pragma mark -
+
+static NSSize SizeToFit(NSView *view, NSPoint offset) {
+
+  // If we've got one of us within us, recurse (for grids)
+  if ([view isKindOfClass:[GTMWidthBasedTweaker class]]) {
+    GTMWidthBasedTweaker *widthAlignmentBox = (GTMWidthBasedTweaker *)view;
+    return NSMakeSize([widthAlignmentBox tweakLayoutWithOffset:offset], 0);
+  }
+
+  NSRect oldFrame = [view frame];
+  NSRect fitFrame = oldFrame;
+  NSRect newFrame = oldFrame;
+
+  if ([view isKindOfClass:[NSTextField class]] &&
+      [(NSTextField *)view isEditable]) {
+    // Don't try to sizeToFit because edit fields really don't want to be sized
+    // to what is in them as they are for users to enter things so honor their
+    // current size.
+  } else {
+
+    // Genericaly fire a sizeToFit if it has one.
+    if ([view respondsToSelector:@selector(sizeToFit)]) {
+      [view performSelector:@selector(sizeToFit)];
+      fitFrame = [view frame];
+      newFrame = fitFrame;
+    }
+
+    // -[NSButton sizeToFit] gives much worse results than IB's Size to Fit
+    // option. This is the amount of padding IB adds over a sizeToFit,
+    // empirically determined.
+    // TODO: We need to check the type of button before doing this.
+    if ([view isKindOfClass:[NSButton class]]) {
+      const float kExtraPaddingAmount = 12;
+      const float kMinButtonWidth = 70; // The default button size in IB.
+      newFrame.size.width = NSWidth(newFrame) + kExtraPaddingAmount;
+      if (NSWidth(newFrame) < kMinButtonWidth) {
+        newFrame.size.width = kMinButtonWidth;
+      }
+    }
+  }
+
+  // Apply the offset, and see if we need to change the frame (again).
+  newFrame.origin.x += offset.x;
+  newFrame.origin.y += offset.y;
+  if (!NSEqualRects(fitFrame, newFrame)) {
+    [view setFrame:newFrame];
+  }
+
+  // Return how much we changed size.
+  return NSMakeSize(NSWidth(newFrame) - NSWidth(oldFrame),
+                    NSHeight(newFrame) - NSHeight(oldFrame));
+}
+
+static NSInteger CompareFrameX(id view1, id view2, void *context) {
+  CGFloat x1 = [view1 frame].origin.x;
+  CGFloat x2 = [view2 frame].origin.x;
+  if (x1 < x2)
+    return NSOrderedAscending;
+  else if (x1 > x2)
+    return NSOrderedDescending;
+  else
+    return NSOrderedSame;
+}
+
+static BOOL IsRightAnchored(NSView *view) {
+  NSUInteger autoresizing = [view autoresizingMask];
+  BOOL viewRightAnchored =
+   ((autoresizing & (NSViewMinXMargin | NSViewMaxXMargin)) == NSViewMinXMargin);
+  return viewRightAnchored;
+}