Home | History | Annotate | Download | only in location_bar 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #import "chrome/browser/ui/cocoa/location_bar/autocomplete_text_field_cell.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/mac/foundation_util.h"
      9 #include "base/mac/mac_logging.h"
     10 #include "chrome/browser/search/search.h"
     11 #import "chrome/browser/ui/cocoa/location_bar/autocomplete_text_field.h"
     12 #import "chrome/browser/ui/cocoa/location_bar/button_decoration.h"
     13 #import "chrome/browser/ui/cocoa/location_bar/location_bar_decoration.h"
     14 #import "extensions/common/feature_switch.h"
     15 #include "grit/theme_resources.h"
     16 #import "third_party/mozilla/NSPasteboard+Utils.h"
     17 #import "ui/base/cocoa/appkit_utils.h"
     18 #import "ui/base/cocoa/nsview_additions.h"
     19 #import "ui/base/cocoa/tracking_area.h"
     20 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
     21 
     22 using extensions::FeatureSwitch;
     23 
     24 namespace {
     25 
     26 // Matches the clipping radius of |GradientButtonCell|.
     27 const CGFloat kCornerRadius = 3.0;
     28 
     29 // How far to inset the left- and right-hand decorations from the field's
     30 // bounds.
     31 const CGFloat kLeftDecorationXOffset = 5.0;
     32 const CGFloat kRightDecorationXOffset = 5.0;
     33 
     34 // The amount of padding on either side reserved for drawing
     35 // decorations.  [Views has |kItemPadding| == 3.]
     36 const CGFloat kDecorationHorizontalPad = 3.0;
     37 
     38 NSString* const kButtonDecorationKey = @"ButtonDecoration";
     39 
     40 const ui::NinePartImageIds kPopupBorderImageIds =
     41     IMAGE_GRID(IDR_OMNIBOX_POPUP_BORDER_AND_SHADOW);
     42 
     43 const ui::NinePartImageIds kNormalBorderImageIds = IMAGE_GRID(IDR_TEXTFIELD);
     44 
     45 // How long to wait for mouse-up on the location icon before assuming
     46 // that the user wants to drag.
     47 const NSTimeInterval kLocationIconDragTimeout = 0.25;
     48 
     49 // Calculate the positions for a set of decorations.  |frame| is the
     50 // overall frame to do layout in, |remaining_frame| will get the
     51 // left-over space.  |all_decorations| is the set of decorations to
     52 // lay out, |decorations| will be set to the decorations which are
     53 // visible and which fit, in the same order as |all_decorations|,
     54 // while |decoration_frames| will be the corresponding frames.
     55 // |x_edge| describes the edge to layout the decorations against
     56 // (|NSMinXEdge| or |NSMaxXEdge|).  |regular_padding| is the padding
     57 // from the edge of |cell_frame| to use when the first visible decoration
     58 // is a regular decoration. |action_padding| is the padding to use when the
     59 // first decoration is a button decoration, ie. the action box button.
     60 // (|kDecorationHorizontalPad| is used between decorations).
     61 void CalculatePositionsHelper(
     62     NSRect frame,
     63     const std::vector<LocationBarDecoration*>& all_decorations,
     64     NSRectEdge x_edge,
     65     CGFloat regular_padding,
     66     CGFloat action_padding,
     67     std::vector<LocationBarDecoration*>* decorations,
     68     std::vector<NSRect>* decoration_frames,
     69     NSRect* remaining_frame) {
     70   DCHECK(x_edge == NSMinXEdge || x_edge == NSMaxXEdge);
     71   DCHECK_EQ(decorations->size(), decoration_frames->size());
     72 
     73   // The initial padding depends on whether the first visible decoration is
     74   // a button or not.
     75   bool is_first_visible_decoration = true;
     76 
     77   for (size_t i = 0; i < all_decorations.size(); ++i) {
     78     if (all_decorations[i]->IsVisible()) {
     79       CGFloat padding = kDecorationHorizontalPad;
     80       if (is_first_visible_decoration) {
     81         padding = all_decorations[i]->AsButtonDecoration() ?
     82             action_padding : regular_padding;
     83         is_first_visible_decoration = false;
     84       }
     85 
     86       NSRect padding_rect, available;
     87 
     88       // Peel off the outside padding.
     89       NSDivideRect(frame, &padding_rect, &available, padding, x_edge);
     90 
     91       // Find out how large the decoration will be in the remaining
     92       // space.
     93       const CGFloat used_width =
     94           all_decorations[i]->GetWidthForSpace(NSWidth(available));
     95 
     96       if (used_width != LocationBarDecoration::kOmittedWidth) {
     97         DCHECK_GT(used_width, 0.0);
     98         NSRect decoration_frame;
     99 
    100         // Peel off the desired width, leaving the remainder in
    101         // |frame|.
    102         NSDivideRect(available, &decoration_frame, &frame,
    103                      used_width, x_edge);
    104 
    105         decorations->push_back(all_decorations[i]);
    106         decoration_frames->push_back(decoration_frame);
    107         DCHECK_EQ(decorations->size(), decoration_frames->size());
    108 
    109         // Adjust padding for between decorations.
    110         padding = kDecorationHorizontalPad;
    111       }
    112     }
    113   }
    114 
    115   DCHECK_EQ(decorations->size(), decoration_frames->size());
    116   *remaining_frame = frame;
    117 }
    118 
    119 // Helper function for calculating placement of decorations w/in the cell.
    120 // |frame| is the cell's boundary rectangle, |remaining_frame| will get any
    121 // space left after decorations are laid out (for text).  |left_decorations| is
    122 // a set of decorations for the left-hand side of the cell, |right_decorations|
    123 // for the right-hand side.  |edge_width| is the width of one vertical edge of
    124 // the omnibox, this depends on whether the display is low DPI or high DPI.
    125 // |decorations| will contain the resulting visible decorations, and
    126 // |decoration_frames| will contain their frames in the same coordinates as
    127 // |frame|.  Decorations will be ordered left to right. As a convenience returns
    128 // the index of the first right-hand decoration.
    129 size_t CalculatePositionsInFrame(
    130     NSRect frame,
    131     const std::vector<LocationBarDecoration*>& left_decorations,
    132     const std::vector<LocationBarDecoration*>& right_decorations,
    133     CGFloat edge_width,
    134     std::vector<LocationBarDecoration*>* decorations,
    135     std::vector<NSRect>* decoration_frames,
    136     NSRect* remaining_frame) {
    137   decorations->clear();
    138   decoration_frames->clear();
    139 
    140   // Layout |left_decorations| against the LHS.
    141   CalculatePositionsHelper(frame, left_decorations, NSMinXEdge,
    142                            kLeftDecorationXOffset, edge_width,
    143                            decorations, decoration_frames, &frame);
    144   DCHECK_EQ(decorations->size(), decoration_frames->size());
    145 
    146   // Capture the number of visible left-hand decorations.
    147   const size_t left_count = decorations->size();
    148 
    149   // Layout |right_decorations| against the RHS.
    150   CalculatePositionsHelper(frame, right_decorations, NSMaxXEdge,
    151                            kRightDecorationXOffset, edge_width, decorations,
    152                            decoration_frames, &frame);
    153   DCHECK_EQ(decorations->size(), decoration_frames->size());
    154 
    155   // Reverse the right-hand decorations so that overall everything is
    156   // sorted left to right.
    157   std::reverse(decorations->begin() + left_count, decorations->end());
    158   std::reverse(decoration_frames->begin() + left_count,
    159                decoration_frames->end());
    160 
    161   *remaining_frame = frame;
    162   return left_count;
    163 }
    164 
    165 }  // namespace
    166 
    167 @interface AutocompleteTextFieldCell ()
    168 // Post an OnSetFocus notification to the observer of |controlView|.
    169 - (void)focusNotificationFor:(NSEvent*)event
    170                       ofView:(AutocompleteTextField*)controlView;
    171 @end
    172 
    173 @implementation AutocompleteTextFieldCell
    174 
    175 @synthesize isPopupMode = isPopupMode_;
    176 
    177 - (CGFloat)topTextFrameOffset {
    178   return 3.0;
    179 }
    180 
    181 - (CGFloat)bottomTextFrameOffset {
    182   return 3.0;
    183 }
    184 
    185 - (CGFloat)cornerRadius {
    186   return kCornerRadius;
    187 }
    188 
    189 - (CGFloat)edgeWidth {
    190   // The omnibox vertical edge width is 1 pixel both in low DPI and high DPI.
    191   return [[self controlView] cr_lineWidth];
    192 }
    193 
    194 - (BOOL)shouldDrawBezel {
    195   return YES;
    196 }
    197 
    198 - (CGFloat)lineHeight {
    199   return 17;
    200 }
    201 
    202 - (void)clearDecorations {
    203   leftDecorations_.clear();
    204   rightDecorations_.clear();
    205 }
    206 
    207 - (void)addLeftDecoration:(LocationBarDecoration*)decoration {
    208   leftDecorations_.push_back(decoration);
    209 }
    210 
    211 - (void)addRightDecoration:(LocationBarDecoration*)decoration {
    212   rightDecorations_.push_back(decoration);
    213 }
    214 
    215 - (CGFloat)availableWidthInFrame:(const NSRect)frame {
    216   std::vector<LocationBarDecoration*> decorations;
    217   std::vector<NSRect> decorationFrames;
    218   NSRect textFrame;
    219   CalculatePositionsInFrame(frame, leftDecorations_, rightDecorations_,
    220                             [self edgeWidth], &decorations, &decorationFrames,
    221                             &textFrame);
    222 
    223   return NSWidth(textFrame);
    224 }
    225 
    226 - (NSRect)frameForDecoration:(const LocationBarDecoration*)aDecoration
    227                      inFrame:(NSRect)cellFrame {
    228   // Short-circuit if the decoration is known to be not visible.
    229   if (aDecoration && !aDecoration->IsVisible())
    230     return NSZeroRect;
    231 
    232   // Layout the decorations.
    233   std::vector<LocationBarDecoration*> decorations;
    234   std::vector<NSRect> decorationFrames;
    235   NSRect textFrame;
    236   CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
    237                             [self edgeWidth], &decorations, &decorationFrames,
    238                             &textFrame);
    239 
    240   // Find our decoration and return the corresponding frame.
    241   std::vector<LocationBarDecoration*>::const_iterator iter =
    242       std::find(decorations.begin(), decorations.end(), aDecoration);
    243   if (iter != decorations.end()) {
    244     const size_t index = iter - decorations.begin();
    245     return decorationFrames[index];
    246   }
    247 
    248   // Decorations which are not visible should have been filtered out
    249   // at the top, but return |NSZeroRect| rather than a 0-width rect
    250   // for consistency.
    251   NOTREACHED();
    252   return NSZeroRect;
    253 }
    254 
    255 // Overriden to account for the decorations.
    256 - (NSRect)textFrameForFrame:(NSRect)cellFrame {
    257   // Get the frame adjusted for decorations.
    258   std::vector<LocationBarDecoration*> decorations;
    259   std::vector<NSRect> decorationFrames;
    260   NSRect textFrame = [super textFrameForFrame:cellFrame];
    261   CalculatePositionsInFrame(textFrame, leftDecorations_, rightDecorations_,
    262                             [self edgeWidth], &decorations, &decorationFrames,
    263                             &textFrame);
    264 
    265   // NOTE: This function must closely match the logic in
    266   // |-drawInteriorWithFrame:inView:|.
    267 
    268   return textFrame;
    269 }
    270 
    271 // Returns the sub-frame where clicks can happen within the cell.
    272 - (NSRect)clickableFrameForFrame:(NSRect)cellFrame {
    273   return [super textFrameForFrame:cellFrame];
    274 }
    275 
    276 - (NSRect)textCursorFrameForFrame:(NSRect)cellFrame {
    277   std::vector<LocationBarDecoration*> decorations;
    278   std::vector<NSRect> decorationFrames;
    279   NSRect textFrame;
    280   size_t left_count =
    281       CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
    282                                 [self edgeWidth], &decorations,
    283                                 &decorationFrames, &textFrame);
    284 
    285   // Determine the left-most extent for the i-beam cursor.
    286   CGFloat minX = NSMinX(textFrame);
    287   for (size_t index = left_count; index--; ) {
    288     if (decorations[index]->AcceptsMousePress())
    289       break;
    290 
    291     // If at leftmost decoration, expand to edge of cell.
    292     if (!index) {
    293       minX = NSMinX(cellFrame);
    294     } else {
    295       minX = NSMinX(decorationFrames[index]) - kDecorationHorizontalPad;
    296     }
    297   }
    298 
    299   // Determine the right-most extent for the i-beam cursor.
    300   CGFloat maxX = NSMaxX(textFrame);
    301   for (size_t index = left_count; index < decorations.size(); ++index) {
    302     if (decorations[index]->AcceptsMousePress())
    303       break;
    304 
    305     // If at rightmost decoration, expand to edge of cell.
    306     if (index == decorations.size() - 1) {
    307       maxX = NSMaxX(cellFrame);
    308     } else {
    309       maxX = NSMaxX(decorationFrames[index]) + kDecorationHorizontalPad;
    310     }
    311   }
    312 
    313   // I-beam cursor covers left-most to right-most.
    314   return NSMakeRect(minX, NSMinY(textFrame), maxX - minX, NSHeight(textFrame));
    315 }
    316 
    317 - (void)drawWithFrame:(NSRect)frame inView:(NSView*)controlView {
    318   // Background color.
    319   const CGFloat lineWidth = [controlView cr_lineWidth];
    320   if (isPopupMode_) {
    321     [[self backgroundColor] set];
    322     NSRectFillUsingOperation(NSInsetRect(frame, 1, 1), NSCompositeSourceOver);
    323   } else {
    324     CGFloat insetSize = lineWidth == 0.5 ? 1.5 : 2.0;
    325     NSRect fillRect = NSInsetRect(frame, insetSize, insetSize);
    326     [[self backgroundColor] set];
    327     [[NSBezierPath bezierPathWithRoundedRect:fillRect
    328                                      xRadius:kCornerRadius
    329                                      yRadius:kCornerRadius] fill];
    330   }
    331 
    332   // Border.
    333   ui::DrawNinePartImage(frame,
    334                         isPopupMode_ ? kPopupBorderImageIds
    335                                      : kNormalBorderImageIds,
    336                         NSCompositeSourceOver,
    337                         1.0,
    338                         true);
    339 
    340   // Interior contents. Drawn after the border as some of the interior controls
    341   // draw over the border.
    342   [self drawInteriorWithFrame:frame inView:controlView];
    343 
    344   // Focus ring.
    345   if ([self showsFirstResponder]) {
    346     NSRect focusRingRect = NSInsetRect(frame, lineWidth, lineWidth);
    347     [[[NSColor keyboardFocusIndicatorColor]
    348         colorWithAlphaComponent:0.5 / lineWidth] set];
    349     NSBezierPath* path = [NSBezierPath bezierPathWithRoundedRect:focusRingRect
    350                                                          xRadius:kCornerRadius
    351                                                          yRadius:kCornerRadius];
    352     [path setLineWidth:lineWidth * 2.0];
    353     [path stroke];
    354   }
    355 }
    356 
    357 - (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
    358   std::vector<LocationBarDecoration*> decorations;
    359   std::vector<NSRect> decorationFrames;
    360   NSRect workingFrame;
    361 
    362   CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
    363                             [self edgeWidth], &decorations, &decorationFrames,
    364                             &workingFrame);
    365 
    366   // Draw the decorations.
    367   for (size_t i = 0; i < decorations.size(); ++i) {
    368     if (decorations[i]) {
    369       NSRect background_frame = NSInsetRect(
    370           decorationFrames[i], -(kDecorationHorizontalPad + 1) / 2, 2);
    371       decorations[i]->DrawWithBackgroundInFrame(
    372           background_frame, decorationFrames[i], controlView);
    373     }
    374   }
    375 
    376   // NOTE: This function must closely match the logic in
    377   // |-textFrameForFrame:|.
    378 
    379   // Superclass draws text portion WRT original |cellFrame|.
    380   // Even though -isOpaque is NO due to rounded corners, we know that the text
    381   // will be drawn on top of an opaque area, therefore it is safe to enable
    382   // font smoothing.
    383   {
    384     gfx::ScopedNSGraphicsContextSaveGState scopedGState;
    385     NSGraphicsContext* context = [NSGraphicsContext currentContext];
    386     CGContextRef cgContext = static_cast<CGContextRef>([context graphicsPort]);
    387     CGContextSetShouldSmoothFonts(cgContext, true);
    388     [super drawInteriorWithFrame:cellFrame inView:controlView];
    389   }
    390 }
    391 
    392 - (LocationBarDecoration*)decorationForEvent:(NSEvent*)theEvent
    393                                       inRect:(NSRect)cellFrame
    394                                       ofView:(AutocompleteTextField*)controlView
    395 {
    396   const BOOL flipped = [controlView isFlipped];
    397   const NSPoint location =
    398       [controlView convertPoint:[theEvent locationInWindow] fromView:nil];
    399 
    400   std::vector<LocationBarDecoration*> decorations;
    401   std::vector<NSRect> decorationFrames;
    402   NSRect textFrame;
    403   CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
    404                             [self edgeWidth], &decorations, &decorationFrames,
    405                             &textFrame);
    406 
    407   for (size_t i = 0; i < decorations.size(); ++i) {
    408     if (NSMouseInRect(location, decorationFrames[i], flipped))
    409       return decorations[i];
    410   }
    411 
    412   return NULL;
    413 }
    414 
    415 - (NSMenu*)decorationMenuForEvent:(NSEvent*)theEvent
    416                            inRect:(NSRect)cellFrame
    417                            ofView:(AutocompleteTextField*)controlView {
    418   LocationBarDecoration* decoration =
    419       [self decorationForEvent:theEvent inRect:cellFrame ofView:controlView];
    420   if (decoration)
    421     return decoration->GetMenu();
    422   return nil;
    423 }
    424 
    425 - (BOOL)mouseDown:(NSEvent*)theEvent
    426            inRect:(NSRect)cellFrame
    427            ofView:(AutocompleteTextField*)controlView {
    428   // TODO(groby): Factor this into three pieces - find target for event, handle
    429   // delayed focus (for any and all events), execute mouseDown for target.
    430 
    431   // Check if this mouseDown was the reason the control became firstResponder.
    432   // If not, discard focus event.
    433   base::scoped_nsobject<NSEvent> focusEvent(focusEvent_.release());
    434   if (![theEvent isEqual:focusEvent])
    435     focusEvent.reset();
    436 
    437   LocationBarDecoration* decoration =
    438       [self decorationForEvent:theEvent inRect:cellFrame ofView:controlView];
    439   if (!decoration || !decoration->AcceptsMousePress())
    440     return NO;
    441 
    442   NSRect decorationRect =
    443       [self frameForDecoration:decoration inFrame:cellFrame];
    444 
    445   // If the decoration is draggable, then initiate a drag if the user
    446   // drags or holds the mouse down for awhile.
    447   if (decoration->IsDraggable()) {
    448     NSDate* timeout =
    449         [NSDate dateWithTimeIntervalSinceNow:kLocationIconDragTimeout];
    450     NSEvent* event = [NSApp nextEventMatchingMask:(NSLeftMouseDraggedMask |
    451                                                    NSLeftMouseUpMask)
    452                                         untilDate:timeout
    453                                            inMode:NSEventTrackingRunLoopMode
    454                                           dequeue:YES];
    455     if (!event || [event type] == NSLeftMouseDragged) {
    456       NSPasteboard* pboard = decoration->GetDragPasteboard();
    457       DCHECK(pboard);
    458 
    459       NSImage* image = decoration->GetDragImage();
    460       DCHECK(image);
    461 
    462       NSRect dragImageRect = decoration->GetDragImageFrame(decorationRect);
    463 
    464       // Center under mouse horizontally, with cursor below so the image
    465       // can be seen.
    466       const NSPoint mousePoint =
    467           [controlView convertPoint:[theEvent locationInWindow] fromView:nil];
    468       dragImageRect.origin =
    469           NSMakePoint(mousePoint.x - NSWidth(dragImageRect) / 2.0,
    470                       mousePoint.y - NSHeight(dragImageRect));
    471 
    472       // -[NSView dragImage:at:*] wants the images lower-left point,
    473       // regardless of -isFlipped.  Converting the rect to window base
    474       // coordinates doesn't require any special-casing.  Note that
    475       // -[NSView dragFile:fromRect:*] takes a rect rather than a
    476       // point, likely for this exact reason.
    477       const NSPoint dragPoint =
    478           [controlView convertRect:dragImageRect toView:nil].origin;
    479       [[controlView window] dragImage:image
    480                                    at:dragPoint
    481                                offset:NSZeroSize
    482                                 event:theEvent
    483                            pasteboard:pboard
    484                                source:self
    485                             slideBack:YES];
    486 
    487       return YES;
    488     }
    489 
    490     // On mouse-up fall through to mouse-pressed case.
    491     DCHECK_EQ([event type], NSLeftMouseUp);
    492   }
    493 
    494   bool handled;
    495   if (decoration->AsButtonDecoration()) {
    496     ButtonDecoration* button = decoration->AsButtonDecoration();
    497 
    498     button->SetButtonState(ButtonDecoration::kButtonStatePressed);
    499     [controlView setNeedsDisplay:YES];
    500 
    501     // Track the mouse until the user releases the button.
    502     [self trackMouse:theEvent
    503               inRect:decorationRect
    504               ofView:controlView
    505         untilMouseUp:YES];
    506 
    507     const NSPoint mouseLocation = [[NSApp currentEvent] locationInWindow];
    508     const NSPoint point = [controlView convertPoint:mouseLocation fromView:nil];
    509 
    510     // Post delayed focus notification, if necessary.
    511     if (focusEvent.get() && !button->PreventFocus(point))
    512       [self focusNotificationFor:focusEvent ofView:controlView];
    513     focusEvent.reset();
    514 
    515     // Set the proper state (hover or normal) once the mouse has been released,
    516     // and call |OnMousePressed| if the button was released while the mouse was
    517     // within the bounds of the button.
    518     if (NSMouseInRect(point, decorationRect, [controlView isFlipped])) {
    519       button->SetButtonState(ButtonDecoration::kButtonStateHover);
    520       [controlView setNeedsDisplay:YES];
    521       handled = decoration->OnMousePressed(
    522           [self frameForDecoration:decoration inFrame:cellFrame],
    523           NSMakePoint(point.x - decorationRect.origin.x,
    524                       point.y - decorationRect.origin.y));
    525     } else {
    526       button->SetButtonState(ButtonDecoration::kButtonStateNormal);
    527       [controlView setNeedsDisplay:YES];
    528       handled = true;
    529     }
    530   } else {
    531     const NSPoint mouseLocation = [theEvent locationInWindow];
    532     const NSPoint point = [controlView convertPoint:mouseLocation fromView:nil];
    533     handled = decoration->OnMousePressed(
    534         decorationRect,
    535         NSMakePoint(point.x - decorationRect.origin.x,
    536                     point.y - decorationRect.origin.y));
    537   }
    538 
    539   return handled ? YES : NO;
    540 }
    541 
    542 // Helper method for the |mouseEntered:inView:| and |mouseExited:inView:|
    543 // messages. Retrieves the |ButtonDecoration| for the specified event (received
    544 // from a tracking area), and returns |NULL| if no decoration matches.
    545 - (ButtonDecoration*)getButtonDecorationForEvent:(NSEvent*)theEvent {
    546   ButtonDecoration* bd = static_cast<ButtonDecoration*>(
    547       [[[[theEvent trackingArea] userInfo] valueForKey:kButtonDecorationKey]
    548           pointerValue]);
    549 
    550   CHECK(!bd ||
    551       std::count(leftDecorations_.begin(), leftDecorations_.end(), bd) ||
    552       std::count(rightDecorations_.begin(), rightDecorations_.end(), bd));
    553 
    554   return bd;
    555 }
    556 
    557 // Helper method for |setUpTrackingAreasInView|. Creates an |NSDictionary| to
    558 // be used as user information to identify which decoration is the source of an
    559 // event (from a tracking area).
    560 - (NSDictionary*)getDictionaryForButtonDecoration:
    561     (ButtonDecoration*)decoration {
    562   if (!decoration)
    563     return nil;
    564 
    565   DCHECK(
    566     std::count(leftDecorations_.begin(), leftDecorations_.end(), decoration) ||
    567     std::count(rightDecorations_.begin(), rightDecorations_.end(), decoration));
    568 
    569   return [NSDictionary
    570       dictionaryWithObject:[NSValue valueWithPointer:decoration]
    571                     forKey:kButtonDecorationKey];
    572 }
    573 
    574 - (void)mouseEntered:(NSEvent*)theEvent
    575               inView:(AutocompleteTextField*)controlView {
    576   ButtonDecoration* decoration = [self getButtonDecorationForEvent:theEvent];
    577   if (decoration) {
    578     decoration->SetButtonState(ButtonDecoration::kButtonStateHover);
    579     [controlView setNeedsDisplay:YES];
    580   }
    581 }
    582 
    583 - (void)mouseExited:(NSEvent*)theEvent
    584              inView:(AutocompleteTextField*)controlView {
    585   ButtonDecoration* decoration = [self getButtonDecorationForEvent:theEvent];
    586   if (decoration) {
    587     decoration->SetButtonState(ButtonDecoration::kButtonStateNormal);
    588     [controlView setNeedsDisplay:YES];
    589   }
    590 }
    591 
    592 - (void)setUpTrackingAreasInRect:(NSRect)frame
    593                           ofView:(AutocompleteTextField*)view {
    594   std::vector<LocationBarDecoration*> decorations;
    595   std::vector<NSRect> decorationFrames;
    596   NSRect textFrame;
    597   NSRect cellRect = [self clickableFrameForFrame:[view bounds]];
    598   CalculatePositionsInFrame(cellRect, leftDecorations_, rightDecorations_,
    599                             [self edgeWidth], &decorations, &decorationFrames,
    600                             &textFrame);
    601 
    602   // Remove previously-registered tracking areas, since we'll update them below.
    603   for (CrTrackingArea* area in [view trackingAreas]) {
    604     if ([[area userInfo] objectForKey:kButtonDecorationKey])
    605       [view removeTrackingArea:area];
    606   }
    607 
    608   // Setup new tracking areas for the buttons.
    609   for (size_t i = 0; i < decorations.size(); ++i) {
    610     ButtonDecoration* button = decorations[i]->AsButtonDecoration();
    611     if (button) {
    612       // If the button isn't pressed (in which case we want to leave it as-is),
    613       // update it's state since we might have missed some entered/exited events
    614       // because of the removing/adding of the tracking areas.
    615       if (button->GetButtonState() !=
    616           ButtonDecoration::kButtonStatePressed) {
    617         const NSPoint mouseLocationWindow =
    618             [[view window] mouseLocationOutsideOfEventStream];
    619         const NSPoint mouseLocation =
    620             [view convertPoint:mouseLocationWindow fromView:nil];
    621         const BOOL mouseInRect = NSMouseInRect(
    622             mouseLocation, decorationFrames[i], [view isFlipped]);
    623         button->SetButtonState(mouseInRect ?
    624                                    ButtonDecoration::kButtonStateHover :
    625                                    ButtonDecoration::kButtonStateNormal);
    626         [view setNeedsDisplay:YES];
    627       }
    628 
    629       NSDictionary* info = [self getDictionaryForButtonDecoration:button];
    630       base::scoped_nsobject<CrTrackingArea> area(
    631           [[CrTrackingArea alloc] initWithRect:decorationFrames[i]
    632                                        options:NSTrackingMouseEnteredAndExited |
    633                                                NSTrackingActiveAlways
    634                                          owner:view
    635                                       userInfo:info]);
    636       [view addTrackingArea:area];
    637     }
    638   }
    639 }
    640 
    641 // Given a newly created .webloc plist url file, also give it a resource
    642 // fork and insert 'TEXT and 'url ' resources holding further copies of the
    643 // url data. This is required for apps such as Terminal and Safari to accept it
    644 // as a real webloc file when dragged in.
    645 // It's expected that the resource fork requirement will go away at some
    646 // point and this code can then be deleted.
    647 OSErr WriteURLToNewWebLocFileResourceFork(NSURL* file, NSString* urlStr) {
    648   ResFileRefNum refNum = kResFileNotOpened;
    649   ResFileRefNum prevResRef = CurResFile();
    650   FSRef fsRef;
    651   OSErr err = noErr;
    652   HFSUniStr255 resourceForkName;
    653   FSGetResourceForkName(&resourceForkName);
    654 
    655   if (![[NSFileManager defaultManager] fileExistsAtPath:[file path]])
    656     return fnfErr;
    657 
    658   if (!CFURLGetFSRef((CFURLRef)file, &fsRef))
    659     return fnfErr;
    660 
    661   err = FSCreateResourceFork(&fsRef,
    662                              resourceForkName.length,
    663                              resourceForkName.unicode,
    664                              0);
    665   if (err)
    666     return err;
    667   err = FSOpenResourceFile(&fsRef,
    668                            resourceForkName.length,
    669                            resourceForkName.unicode,
    670                            fsRdWrPerm, &refNum);
    671   if (err)
    672     return err;
    673 
    674   const char* utf8URL = [urlStr UTF8String];
    675   int urlChars = strlen(utf8URL);
    676 
    677   Handle urlHandle = NewHandle(urlChars);
    678   memcpy(*urlHandle, utf8URL, urlChars);
    679 
    680   Handle textHandle = NewHandle(urlChars);
    681   memcpy(*textHandle, utf8URL, urlChars);
    682 
    683   // Data for the 'drag' resource.
    684   // This comes from derezzing webloc files made by the Finder.
    685   // It's bigendian data, so it's represented here as chars to preserve
    686   // byte order.
    687   char dragData[] = {
    688     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // Header.
    689     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
    690     0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x01, 0x00, // 'TEXT', 0, 256
    691     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    692     0x75, 0x72, 0x6C, 0x20, 0x00, 0x00, 0x01, 0x00, // 'url ', 0, 256
    693     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    694   };
    695   Handle dragHandle = NewHandleClear(sizeof(dragData));
    696   memcpy(*dragHandle, &dragData[0], sizeof(dragData));
    697 
    698   // Save the resources to the file.
    699   ConstStr255Param noName = {0};
    700   AddResource(dragHandle, 'drag', 128, noName);
    701   AddResource(textHandle, 'TEXT', 256, noName);
    702   AddResource(urlHandle, 'url ', 256, noName);
    703 
    704   CloseResFile(refNum);
    705   UseResFile(prevResRef);
    706   return noErr;
    707 }
    708 
    709 // Returns the file path for file |name| if saved at NSURL |base|.
    710 static NSString* PathWithBaseURLAndName(NSURL* base, NSString* name) {
    711   NSString* filteredName =
    712       [name stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
    713   return [[NSURL URLWithString:filteredName relativeToURL:base] path];
    714 }
    715 
    716 // Returns if there is already a file |name| at dir NSURL |base|.
    717 static BOOL FileAlreadyExists(NSURL* base, NSString* name) {
    718   NSString* path = PathWithBaseURLAndName(base, name);
    719   DCHECK([path hasSuffix:name]);
    720   return [[NSFileManager defaultManager] fileExistsAtPath:path];
    721 }
    722 
    723 // Takes a destination URL, a suggested file name, & an extension (eg .webloc).
    724 // Returns the complete file name with extension you should use.
    725 // The name returned will not contain /, : or ?, will not be longer than
    726 // kMaxNameLength + length of extension, and will not be a file name that
    727 // already exists in that directory. If necessary it will try appending a space
    728 // and a number to the name (but before the extension) trying numbers up to and
    729 // including kMaxIndex.
    730 // If the function gives up it returns nil.
    731 static NSString* UnusedLegalNameForNewDropFile(NSURL* saveLocation,
    732                                                NSString *fileName,
    733                                                NSString *extension) {
    734   int number = 1;
    735   const int kMaxIndex = 20;
    736   const unsigned kMaxNameLength = 64; // Arbitrary.
    737 
    738   NSString* filteredName = [fileName stringByReplacingOccurrencesOfString:@"/"
    739                                                                withString:@"-"];
    740   filteredName = [filteredName stringByReplacingOccurrencesOfString:@":"
    741                                                          withString:@"-"];
    742   filteredName = [filteredName stringByReplacingOccurrencesOfString:@"?"
    743                                                          withString:@"-"];
    744 
    745   if ([filteredName length] > kMaxNameLength)
    746     filteredName = [filteredName substringToIndex:kMaxNameLength];
    747 
    748   NSString* candidateName = [filteredName stringByAppendingString:extension];
    749 
    750   while (FileAlreadyExists(saveLocation, candidateName)) {
    751     if (number > kMaxIndex)
    752       return nil;
    753     else
    754       candidateName = [filteredName stringByAppendingFormat:@" %d%@",
    755                        number++, extension];
    756   }
    757 
    758   return candidateName;
    759 }
    760 
    761 - (NSArray*)namesOfPromisedFilesDroppedAtDestination:(NSURL*)dropDestination {
    762   NSPasteboard* pboard = [NSPasteboard pasteboardWithName:NSDragPboard];
    763   NSFileManager* fileManager = [NSFileManager defaultManager];
    764 
    765   if (![pboard containsURLData])
    766     return NULL;
    767 
    768   NSArray *urls = NULL;
    769   NSArray* titles = NULL;
    770   [pboard getURLs:&urls andTitles:&titles convertingFilenames:YES];
    771 
    772   NSString* urlStr = [urls objectAtIndex:0];
    773   NSString* nameStr = [titles objectAtIndex:0];
    774 
    775   NSString* nameWithExtensionStr =
    776       UnusedLegalNameForNewDropFile(dropDestination, nameStr, @".webloc");
    777   if (!nameWithExtensionStr)
    778     return NULL;
    779 
    780   NSDictionary* urlDict = [NSDictionary dictionaryWithObject:urlStr
    781                                                       forKey:@"URL"];
    782   NSURL* outputURL =
    783       [NSURL fileURLWithPath:PathWithBaseURLAndName(dropDestination,
    784                                                     nameWithExtensionStr)];
    785   [urlDict writeToURL:outputURL
    786            atomically:NO];
    787 
    788   if (![fileManager fileExistsAtPath:[outputURL path]])
    789     return NULL;
    790 
    791   NSDictionary* attr = [NSDictionary dictionaryWithObjectsAndKeys:
    792       [NSNumber numberWithBool:YES], NSFileExtensionHidden,
    793       [NSNumber numberWithUnsignedLong:'ilht'], NSFileHFSTypeCode,
    794       [NSNumber numberWithUnsignedLong:'MACS'], NSFileHFSCreatorCode,
    795       nil];
    796   [fileManager setAttributes:attr
    797                 ofItemAtPath:[outputURL path]
    798                        error:nil];
    799   // Add resource data.
    800   OSErr resStatus = WriteURLToNewWebLocFileResourceFork(outputURL, urlStr);
    801   OSSTATUS_DCHECK(resStatus == noErr, resStatus);
    802 
    803   return [NSArray arrayWithObject:nameWithExtensionStr];
    804 }
    805 
    806 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal {
    807   return NSDragOperationCopy;
    808 }
    809 
    810 - (void)updateToolTipsInRect:(NSRect)cellFrame
    811                       ofView:(AutocompleteTextField*)controlView {
    812   std::vector<LocationBarDecoration*> decorations;
    813   std::vector<NSRect> decorationFrames;
    814   NSRect textFrame;
    815   CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
    816                             [self edgeWidth], &decorations, &decorationFrames,
    817                             &textFrame);
    818 
    819   for (size_t i = 0; i < decorations.size(); ++i) {
    820     NSString* tooltip = decorations[i]->GetToolTip();
    821     if ([tooltip length] > 0)
    822       [controlView addToolTip:tooltip forRect:decorationFrames[i]];
    823   }
    824 }
    825 
    826 - (BOOL)hideFocusState {
    827   return hideFocusState_;
    828 }
    829 
    830 - (void)setHideFocusState:(BOOL)hideFocusState
    831                    ofView:(AutocompleteTextField*)controlView {
    832   if (hideFocusState_ == hideFocusState)
    833     return;
    834   hideFocusState_ = hideFocusState;
    835   [controlView setNeedsDisplay:YES];
    836   NSTextView* fieldEditor =
    837       base::mac::ObjCCastStrict<NSTextView>([controlView currentEditor]);
    838   [fieldEditor updateInsertionPointStateAndRestartTimer:YES];
    839 }
    840 
    841 - (BOOL)showsFirstResponder {
    842   return [super showsFirstResponder] && !hideFocusState_;
    843 }
    844 
    845 - (void)focusNotificationFor:(NSEvent*)event
    846                       ofView:(AutocompleteTextField*)controlView {
    847   if ([controlView observer]) {
    848     const bool controlDown = ([event modifierFlags] & NSControlKeyMask) != 0;
    849     [controlView observer]->OnSetFocus(controlDown);
    850   }
    851 }
    852 
    853 - (void)handleFocusEvent:(NSEvent*)event
    854                   ofView:(AutocompleteTextField*)controlView {
    855   // Only intercept left button click. All other events cause immediate focus.
    856   if ([event type] == NSLeftMouseDown) {
    857     LocationBarDecoration* decoration =
    858         [self decorationForEvent:event
    859                           inRect:[controlView bounds]
    860                           ofView:controlView];
    861     // Only ButtonDecorations need a delayed focus handling.
    862     if (decoration && decoration->AsButtonDecoration()) {
    863       focusEvent_.reset([event retain]);
    864       return;
    865     }
    866   }
    867 
    868   // Handle event immediately.
    869   [self focusNotificationFor:event ofView:controlView];
    870 }
    871 
    872 @end
    873