[Mac] Star as a rhs-decoration in AutocompleteTextFieldCell.

chrome/browser/cocoa/location_bar/autocomplete_text_field_cell.mm

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "chrome/browser/cocoa/location_bar/autocomplete_text_field_cell.h"
 
 #include "base/logging.h"
 #import "chrome/browser/cocoa/image_utils.h"
 #import "chrome/browser/cocoa/location_bar/location_bar_decoration.h"
 
@@ skipping 10 matching lines @@
 
 @end
 
 namespace {
 
 const CGFloat kBaselineAdjust = 2.0;
 
 // Matches the clipping radius of |GradientButtonCell|.
 const CGFloat kCornerRadius = 4.0;
 
-// Gap to leave between hint and right-hand-side of cell.
-const NSInteger kHintXOffset = 4;
-
 // How far to shift bounding box of hint down from top of field.
 // Assumes -setFlipped:YES.
 const NSInteger kHintYOffset = 4;
 
 // TODO(shess): The keyword hint image wants to sit on the baseline.
 // This moves it down so that there is approximately as much image
 // above the lowercase ascender as below the baseline.  A better
 // technique would be nice to have, though.
 const NSInteger kKeywordHintImageBaseline = -6;
 
 // How far to shift bounding box of hint icon label down from top of field.
 const NSInteger kIconLabelYOffset = 7;
 
 // How far the editor insets itself, for purposes of determining if
 // decorations need to be trimmed.
 const CGFloat kEditorHorizontalInset = 3.0;
 
 // How far to inset the left-hand decorations from the field's bounds.
 const CGFloat kLeftDecorationXOffset = 3.0;
 
+// How far to inset the right-hand decorations from the field's bounds.
+// TODO(shess): Why is this different from |kLeftDecorationXOffset|?
+const CGFloat kRightDecorationXOffset = 4.0;
+
 // The amount of padding on either side reserved for drawing decorations.
-const NSInteger kDecorationHorizontalPad = 3;
+const CGFloat kDecorationHorizontalPad = 3;
 
 // How long to wait for mouse-up on the location icon before assuming
 // that the user wants to drag.
 const NSTimeInterval kLocationIconDragTimeout = 0.25;
 
 // Conveniences to centralize width+offset calculations.
 CGFloat WidthForHint(NSAttributedString* hintString) {
-  return kHintXOffset + ceil([hintString size].width);
+  return kRightDecorationXOffset + ceil([hintString size].width);
 }
 
 // Convenience to draw |image| in the |rect| portion of |view|.
 void DrawImageInRect(NSImage* image, NSView* view, const NSRect& rect) {
   // If there is an image, make sure we calculated the target size
   // correctly.
   DCHECK(!image || NSEqualSizes([image size], rect.size));
   [image drawInRect:rect
            fromRect:NSZeroRect  // Entire image
           operation:NSCompositeSourceOver
@@ skipping 16 matching lines @@
   scoped_nsobject<NSMutableAttributedString> as(
       [[NSAttributedString attributedStringWithAttachment:attachment]
         mutableCopy]);
   [as addAttribute:NSBaselineOffsetAttributeName
       value:[NSNumber numberWithFloat:baselineAdjustment]
       range:NSMakeRange(0, [as length])];
 
   return [[as copy] autorelease];
 }
 
-// Helper function for calculating placement of decorations w/in the
-// cell.  |frame| is the cell's boundary rectangle.
-// |left_decorations| is a set of decorations for the left-hand side
-// of the cell, before the text.  |decorations| will contain the
-// resulting visible decorations, and |decoration_frames| will contain
-// their frames in the same coordinates as |frame|.  |remaining_frame|
-// will contain the frame left over for the field editor.
-void CalculatePositionsInFrame(
-    const NSRect cell_frame,
-    const std::vector<LocationBarDecoration*>& left_decorations,
+// Calculate the positions for a set of decorations.  |frame| is the
+// overall frame to do layout in, |remaining_frame| will get the
+// left-over space.  |all_decorations| is the set of decorations to
+// lay out, |decorations| will be set to the decorations which are
+// visible and which fit, in the same order as |all_decorations|,
+// while |decoration_frames| will be the corresponding frames.
+// |x_edge| describes the edge to layout the decorations against
+// (|NSMinXEdge| or |NSMaxXEdge|).  |initial_padding| is the padding
+// from the edge of |cell_frame| (|kDecorationHorizontalPad| is used
+// between decorations).
+void CalculatePositionsHelper(
+    NSRect frame,
+    const std::vector<LocationBarDecoration*>& all_decorations,
+    NSRectEdge x_edge,
+    CGFloat initial_padding,
     std::vector<LocationBarDecoration*>* decorations,
     std::vector<NSRect>* decoration_frames,
     NSRect* remaining_frame) {
-  NSRect frame = cell_frame;
+  DCHECK(x_edge == NSMinXEdge || x_edge == NSMaxXEdge);
+  DCHECK_EQ(decorations->size(), decoration_frames->size());
 
-  // The left-most decoration will be inset a bit further from the edge.
-  CGFloat left_padding = kLeftDecorationXOffset;
+  // The outer-most decoration will be inset a bit further from the
+  // edge.
+  CGFloat padding = initial_padding;
 
-  decorations->clear();
-  decoration_frames->clear();
+  for (size_t i = 0; i < all_decorations.size(); ++i) {
+    if (all_decorations[i]->IsVisible()) {
+      NSRect padding_rect, available;
 
-  for (size_t i = 0; i < left_decorations.size(); ++i) {
-    if (left_decorations[i]->IsVisible()) {
-      NSRect padding, available;
-
-      // Peel off the left-side padding.
-      NSDivideRect(frame, &padding, &available, left_padding, NSMinXEdge);
+      // Peel off the outside padding.
+      NSDivideRect(frame, &padding_rect, &available, padding, x_edge);
 
       // Find out how large the decoration will be in the remaining
       // space.
       const CGFloat used_width =
-          left_decorations[i]->GetWidthForSpace(NSWidth(available));
+          all_decorations[i]->GetWidthForSpace(NSWidth(available));
 
       if (used_width != LocationBarDecoration::kOmittedWidth) {
         DCHECK_GT(used_width, 0.0);
         NSRect decoration_frame;
 
         // Peel off the desired width, leaving the remainder in
         // |frame|.
         NSDivideRect(available, &decoration_frame, &frame,
-                     used_width, NSMinXEdge);
+                     used_width, x_edge);
 
-        decorations->push_back(left_decorations[i]);
+        decorations->push_back(all_decorations[i]);
         decoration_frames->push_back(decoration_frame);
         DCHECK_EQ(decorations->size(), decoration_frames->size());
 
         // Adjust padding for between decorations.
-        left_padding = kDecorationHorizontalPad;
+        padding = kDecorationHorizontalPad;
       }
     }
   }
 
+  DCHECK_EQ(decorations->size(), decoration_frames->size());
   *remaining_frame = frame;
+}
+
+// Helper function for calculating placement of decorations w/in the
+// cell.  |frame| is the cell's boundary rectangle, |remaining_frame|
+// will get any space left after decorations are laid out (for text).
+// |left_decorations| is a set of decorations for the left-hand side
+// of the cell, |right_decorations| for the right-hand side.
+// |decorations| will contain the resulting visible decorations, and
+// |decoration_frames| will contain their frames in the same
+// coordinates as |frame|.  Decorations will be ordered left to right.
+void CalculatePositionsInFrame(
+    NSRect frame,
+    const std::vector<LocationBarDecoration*>& left_decorations,
+    const std::vector<LocationBarDecoration*>& right_decorations,
+    std::vector<LocationBarDecoration*>* decorations,
+    std::vector<NSRect>* decoration_frames,
+    NSRect* remaining_frame) {
+  decorations->clear();
+  decoration_frames->clear();
+
+  // Layout |left_decorations| against the LHS.
+  CalculatePositionsHelper(frame, left_decorations,
+                           NSMinXEdge, kLeftDecorationXOffset,
+                           decorations, decoration_frames, &frame);
   DCHECK_EQ(decorations->size(), decoration_frames->size());
+
+  // Capture the number of visible left-hand decorations.
+  const size_t left_count = decorations->size();
+
+  // Layout |right_decorations| against the RHS.
+  CalculatePositionsHelper(frame, right_decorations,
+                           NSMaxXEdge, kRightDecorationXOffset,
+                           decorations, decoration_frames, &frame);
+  DCHECK_EQ(decorations->size(), decoration_frames->size());
+
+  // Reverse the right-hand decorations so that overall everything is
+  // sorted left to right.
+  std::reverse(decorations->begin() + left_count, decorations->end());
+  std::reverse(decoration_frames->begin() + left_count,
+               decoration_frames->end());
+
+  *remaining_frame = frame;
 }
 
 }  // namespace
 
 @implementation AutocompleteTextAttachmentCell
 
 - (void)drawWithFrame:(NSRect)cellFrame inView:(NSView *)aView {
   // Draw image with |DrawImageInRect()| to get consistent
   // flipped treatment.
   DrawImageInRect([self image], aView, cellFrame);
@@ skipping 149 matching lines @@
 }
 
 - (void)clearHint {
   hintString_.reset();
 }
 
 - (void)setPageActionViewList:(LocationBarViewMac::PageActionViewList*)list {
   page_action_views_ = list;
 }
 
-- (void)setStarIconView:(LocationBarViewMac::LocationBarImageView*)view {
-  starIconView_ = view;
-}
-
 - (void)setContentSettingViewsList:
     (LocationBarViewMac::ContentSettingViews*)views {
   content_setting_views_ = views;
 }
 
 - (void)clearDecorations {
   leftDecorations_.clear();
+  rightDecorations_.clear();
 }
 
 - (void)addLeftDecoration:(LocationBarDecoration*)decoration {
   leftDecorations_.push_back(decoration);
 }
 
+- (void)addRightDecoration:(LocationBarDecoration*)decoration {
+  rightDecorations_.push_back(decoration);
+}
+
 - (CGFloat)availableWidthInFrame:(const NSRect)frame {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(frame, leftDecorations_,
+  CalculatePositionsInFrame(frame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &textFrame);
 
   return NSWidth(textFrame);
 }
 
 - (NSRect)frameForDecoration:(const LocationBarDecoration*)aDecoration
                      inFrame:(NSRect)cellFrame {
   // Short-circuit if the decoration is known to be not visible.
   if (aDecoration && !aDecoration->IsVisible())
     return NSZeroRect;
 
   // Layout the decorations.
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_,
+  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &textFrame);
 
   // Find our decoration and return the corresponding frame.
   std::vector<LocationBarDecoration*>::const_iterator iter =
       std::find(decorations.begin(), decorations.end(), aDecoration);
   if (iter != decorations.end()) {
     const size_t index = iter - decorations.begin();
     return decorationFrames[index];
   }
 
   // Decorations which are not visible should have been filtered out
   // at the top, but return |NSZeroRect| rather than a 0-width rect
   // for consistency.
   NOTREACHED();
   return NSZeroRect;
 }
 
 // Overriden to account for the hint strings and hint icons.
 - (NSRect)textFrameForFrame:(NSRect)cellFrame {
   // Get the frame adjusted for decorations.
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame = [super textFrameForFrame:cellFrame];
-  CalculatePositionsInFrame(textFrame, leftDecorations_,
+  CalculatePositionsInFrame(textFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &textFrame);
 
   // NOTE: This function must closely match the logic in
   // |-drawInteriorWithFrame:inView:|.
 
   // Leave room for items on the right (SSL label, page actions, etc).
   // Icons are laid out in |cellFrame| rather than |textFrame| for
   // consistency with drawing code.
   NSArray* icons = [self layedOutIcons:cellFrame];
   if ([icons count]) {
     // Max x for resulting text frame.
     const CGFloat maxX = NSMinX([[icons objectAtIndex:0] rect]);
     textFrame.size.width = maxX - NSMinX(textFrame);
   }
 
   // Keyword string or hint string if they fit.
   if (hintString_) {
     const CGFloat hintWidth(WidthForHint(hintString_));
 
     // TODO(shess): This could be better.  Show the hint until the
     // non-hint text bumps against it?
     if (hintWidth < NSWidth(textFrame)) {
       textFrame.size.width -= hintWidth;
     }
   }
 
   return textFrame;
 }
 
-- (NSRect)starIconFrameForFrame:(NSRect)cellFrame {
-  if (!starIconView_ || !starIconView_->IsVisible())
-    return NSZeroRect;
-
-  // The star icon is always at the RHS.
-  scoped_nsobject<AutocompleteTextFieldIcon> icon(
-        [[AutocompleteTextFieldIcon alloc] initImageWithView:starIconView_]);
-  cellFrame.size.width -= kHintXOffset;
-  [icon positionInFrame:cellFrame];
-  return [icon rect];
-}
-
 - (size_t)pageActionCount {
   // page_action_views_ may be NULL during testing, or if the
   // containing LocationViewMac object has already been destructed
   // (happens sometimes during window shutdown).
   if (!page_action_views_)
     return 0;
   return page_action_views_->Count();
 }
 
 - (NSRect)pageActionFrameForIndex:(size_t)index inFrame:(NSRect)cellFrame {
@@ skipping 33 matching lines @@
                               cellFrame.origin.y + kHintYOffset,
                               ceil([hintString_ size].width),
                               cellFrame.size.height - kHintYOffset));
   [hintString_.get() drawInRect:infoFrame];
 }
 
 - (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect workingFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_,
+  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &workingFrame);
 
   // Draw the decorations first.
   for (size_t i = 0; i < decorations.size(); ++i) {
     if (decorations[i])
       decorations[i]->DrawInFrame(decorationFrames[i], controlView);
   }
 
   // NOTE: This function must closely match the logic in
   // |-textFrameForFrame:|.
@@ skipping 18 matching lines @@
       [self drawHintWithFrame:cellFrame inView:controlView];
       workingFrame.size.width -= hintWidth;
     }
   }
 
   // Superclass draws text portion WRT original |cellFrame|.
   [super drawInteriorWithFrame:cellFrame inView:controlView];
 }
 
 - (NSArray*)layedOutIcons:(NSRect)cellFrame {
+  // Trim the decoration area from |cellFrame|.  This is duplicate
+  // work WRT the caller in some cases, but locating this here is
+  // simpler, and this code will go away soon.
+  std::vector<LocationBarDecoration*> decorations;
+  std::vector<NSRect> decorationFrames;
+  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
+                            &decorations, &decorationFrames, &cellFrame);
+
   // The set of views to display right-justified in the cell, from
   // left to right.
   NSMutableArray* result = [NSMutableArray array];
 
   // Collect the image views for bulk processing.
   // TODO(shess): Refactor with LocationBarViewMac to make the
   // different types of items more consistent.
   std::vector<LocationBarViewMac::LocationBarImageView*> views;
 
   if (content_setting_views_) {
     views.insert(views.end(),
                  content_setting_views_->begin(),
                  content_setting_views_->end());
   }
 
   // TODO(shess): Previous implementation of this method made a
   // right-to-left array, so add the page-action items in that order.
   // As part of the refactor mentioned above, lay everything out
   // nicely left-to-right.
   for (size_t i = [self pageActionCount]; i-- > 0;) {
     views.push_back(page_action_views_->ViewAt(i));
   }
 
-  // The star icon should always come last.
-  if (starIconView_)
-    views.push_back(starIconView_);
-
   // Load the visible views into |result|.
   for (std::vector<LocationBarViewMac::LocationBarImageView*>::const_iterator
            iter = views.begin(); iter != views.end(); ++iter) {
     if ((*iter)->IsVisible()) {
       scoped_nsobject<AutocompleteTextFieldIcon> icon(
           [[AutocompleteTextFieldIcon alloc] initImageWithView:*iter]);
       [result addObject:icon];
     }
   }
 
-  // Leave a boundary at RHS of field.
-  cellFrame.size.width -= kHintXOffset;
+  // Padding from right-hand decoration.  There should always be at
+  // least one (the star).
+  cellFrame.size.width -= kDecorationHorizontalPad;
 
   // Position each view within the frame from right to left.
   for (AutocompleteTextFieldIcon* icon in [result reverseObjectEnumerator]) {
     [icon positionInFrame:cellFrame];
 
     // Trim the icon's space from the frame.
-    cellFrame.size.width = NSMinX([icon rect]) - kDecorationHorizontalPad;
+    cellFrame.size.width =
+        NSMinX([icon rect]) - NSMinX(cellFrame) - kDecorationHorizontalPad;
   }
   return result;
 }
 
 // Returns the decoration under |theEvent|, or NULL if none.
 // Like |-iconForEvent:inRect:ofView:|, but for decorations.
 - (LocationBarDecoration*)decorationForEvent:(NSEvent*)theEvent
                                       inRect:(NSRect)cellFrame
                                       ofView:(AutocompleteTextField*)controlView
 {
   const BOOL flipped = [controlView isFlipped];
   const NSPoint location =
       [controlView convertPoint:[theEvent locationInWindow] fromView:nil];
 
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_,
+  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &textFrame);
 
   for (size_t i = 0; i < decorations.size(); ++i) {
     if (NSMouseInRect(location, decorationFrames[i], flipped))
       return decorations[i];
   }
 
   return NULL;
 }
 
@@ skipping 96 matching lines @@
   }
 
   return YES;
 }
 
 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal {
   return NSDragOperationCopy;
 }
 
 @end