[AiS] changing mac omnibox suggestions form NSMatrix to NSTableView

chrome/browser/ui/cocoa/omnibox/omnibox_popup_matrix.mm

 // Copyright 2013 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/ui/cocoa/omnibox/omnibox_popup_matrix.h"
 
 #include "base/logging.h"
+#include "base/mac/foundation_util.h"
 #import "chrome/browser/ui/cocoa/omnibox/omnibox_popup_cell.h"
+#include "chrome/browser/ui/cocoa/omnibox/omnibox_popup_view_mac.h"
+#include "components/omnibox/autocomplete_result.h"
 
 namespace {
 
 // NSEvent -buttonNumber for middle mouse button.
 const NSInteger kMiddleButtonNumber = 2;
 
 }  // namespace
 
-@interface OmniboxPopupMatrix()
+@interface OmniboxPopupTableController ()
+- (instancetype)initWithArray:(NSArray*)array;
+@end
+
+@implementation OmniboxPopupTableController
+
+- (instancetype)initWithMatchResults:(const AutocompleteResult&)result
+                           tableView:(OmniboxPopupMatrix*)tableView
+                           popupView:(const OmniboxPopupViewMac&)popupView
+                         answerImage:(NSImage*)answerImage {
+  base::scoped_nsobject<NSMutableArray> array([[NSMutableArray alloc] init]);
+  CGFloat max_match_contents_width = 0.0f;
+  CGFloat contentsOffset = -1.0f;
+  for (const AutocompleteMatch& match : result) {
+    if (match.type == AutocompleteMatchType::SEARCH_SUGGEST_TAIL &&
+        contentsOffset < 0.0f)
+      contentsOffset = [OmniboxPopupCell computeContentsOffset:match];
+    base::scoped_nsobject<OmniboxPopupCellData> cellData(
+        [[OmniboxPopupCellData alloc]
+             initWithMatch:match
+            contentsOffset:contentsOffset
+                     image:popupView.ImageForMatch(match)
+               answerImage:(match.answer ? answerImage : nil)]);
+    [array addObject:cellData];
+    if (match.type == AutocompleteMatchType::SEARCH_SUGGEST_TAIL) {
+      max_match_contents_width =
+          std::max(max_match_contents_width, [cellData getMatchContentsWidth]);
+    }
+  }
+
+  [tableView setMaxMatchContentsWidth:max_match_contents_width];
+  return [self initWithArray:array];
+}
+
+- (instancetype)initWithArray:(NSArray*)array {
+  if ((self = [super init])) {
+    hoveredIndex_ = -1;
+    array_.reset([array copy]);
+  }
+  return self;
+}
+
+- (NSInteger)numberOfRowsInTableView:(NSTableView*)tableView {
+  return [array_ count];
+}
+
+- (id)tableView:(NSTableView*)tableView
+    objectValueForTableColumn:(NSTableColumn*)tableColumn
+                          row:(NSInteger)rowIndex {
+  return [array_ objectAtIndex:rowIndex];
+}
+
+- (void)tableView:(NSTableView*)aTableView
+    setObjectValue:(id)anObject
+    forTableColumn:(NSTableColumn*)aTableColumn
+               row:(NSInteger)rowIndex {
+  NOTREACHED();
+}
+
+- (void)tableView:(NSTableView*)tableView
+    willDisplayCell:(id)cell
+     forTableColumn:(NSTableColumn*)tableColumn
+                row:(NSInteger)rowIndex {
+  OmniboxPopupCell* popupCell =
+      base::mac::ObjCCastStrict<OmniboxPopupCell>(cell);
+  [popupCell
+      setState:([tableView selectedRow] == rowIndex) ? NSOnState : NSOffState];
+  [popupCell highlight:(hoveredIndex_ == rowIndex)
+             withFrame:[tableView bounds]
+                inView:tableView];
+}
+
+- (NSInteger)highlightedRow {
+  return hoveredIndex_;
+}
+
+- (void)setHighlightedRow:(NSInteger)rowIndex {
+  hoveredIndex_ = rowIndex;
+}
+
+- (CGFloat)tableView:(NSTableView*)tableView heightOfRow:(NSInteger)row {
+  return [[array_ objectAtIndex:row] rowHeight];
+}
+
+@end
+
+@interface OmniboxPopupMatrix ()
+- (OmniboxPopupTableController*)controller;
 - (void)resetTrackingArea;
-- (void)highlightRowAt:(NSInteger)rowIndex;
 - (void)highlightRowUnder:(NSEvent*)theEvent;
 - (BOOL)selectCellForEvent:(NSEvent*)theEvent;
 @end
 
 @implementation OmniboxPopupMatrix
 
+@synthesize separator = separator_;
+@synthesize maxMatchContentsWidth = maxMatchContentsWidth_;
+
 - (instancetype)initWithObserver:(OmniboxPopupMatrixObserver*)observer {
   if ((self = [super initWithFrame:NSZeroRect])) {
     observer_ = observer;
-    [self setCellClass:[OmniboxPopupCell class]];
+
+    base::scoped_nsobject<NSTableColumn> column(
+        [[NSTableColumn alloc] initWithIdentifier:@"MainColumn"]);
+    [column setDataCell:[[[OmniboxPopupCell alloc] init] autorelease]];
+    [self addTableColumn:column];
 
     // Cells pack with no spacing.
     [self setIntercellSpacing:NSMakeSize(0.0, 0.0)];
 
-    [self setDrawsBackground:YES];
+    [self setSelectionHighlightStyle:NSTableViewSelectionHighlightStyleNone];
     [self setBackgroundColor:[NSColor controlBackgroundColor]];
-    [self renewRows:0 columns:1];
     [self setAllowsEmptySelection:YES];
-    [self setMode:NSRadioModeMatrix];
-    [self deselectAllCells];
+    [self deselectAll:self];
 
     [self resetTrackingArea];
   }
   return self;
 }
 
+- (OmniboxPopupTableController*)controller {
+  return base::mac::ObjCCastStrict<OmniboxPopupTableController>(
+      [self delegate]);
+}
+
 - (void)setObserver:(OmniboxPopupMatrixObserver*)observer {
   observer_ = observer;
 }
 
-- (NSInteger)highlightedRow {
-  NSArray* cells = [self cells];
-  const NSUInteger count = [cells count];
-  for(NSUInteger i = 0; i < count; ++i) {
-    if ([[cells objectAtIndex:i] isHighlighted]) {
-      return i;
-    }
-  }
-  return -1;
-}
-
 - (void)updateTrackingAreas {
   [self resetTrackingArea];
   [super updateTrackingAreas];
 }
 
 // Callbacks from tracking area.
 - (void)mouseEntered:(NSEvent*)theEvent {
   [self highlightRowUnder:theEvent];
 }
 
 - (void)mouseMoved:(NSEvent*)theEvent {
   [self highlightRowUnder:theEvent];
 }
 
 - (void)mouseExited:(NSEvent*)theEvent {
-  [self highlightRowAt:-1];
+  [[self controller] setHighlightedRow:-1];
 }
 
 // The tracking area events aren't forwarded during a drag, so handle
 // highlighting manually for middle-click and middle-drag.
 - (void)otherMouseDown:(NSEvent*)theEvent {
   if ([theEvent buttonNumber] == kMiddleButtonNumber) {
     [self highlightRowUnder:theEvent];
   }
   [super otherMouseDown:theEvent];
 }
 
 - (void)otherMouseDragged:(NSEvent*)theEvent {
   if ([theEvent buttonNumber] == kMiddleButtonNumber) {
     [self highlightRowUnder:theEvent];
   }
   [super otherMouseDragged:theEvent];
 }
 
 - (void)otherMouseUp:(NSEvent*)theEvent {
   // Only intercept middle button.
   if ([theEvent buttonNumber] != kMiddleButtonNumber) {
     [super otherMouseUp:theEvent];
     return;
   }
 
   // -otherMouseDragged: should always have been called at this location, but
   // make sure the user is getting the right feedback.
   [self highlightRowUnder:theEvent];
 
-  const NSInteger highlightedRow = [self highlightedRow];
+  const NSInteger highlightedRow = [[self controller] highlightedRow];
   if (highlightedRow != -1) {
     DCHECK(observer_);
     observer_->OnMatrixRowMiddleClicked(self, highlightedRow);
   }
 }
 
 // Track the mouse until released, keeping the cell under the mouse selected.
 // If the mouse wanders off-view, revert to the originally-selected cell. If
 // the mouse is released over a cell, call the delegate to open the row's URL.
 - (void)mouseDown:(NSEvent*)theEvent {
   NSCell* selectedCell = [self selectedCell];
 
   // Clear any existing highlight.
-  [self highlightRowAt:-1];
+  [[self controller] setHighlightedRow:-1];
 
   do {
     if (![self selectCellForEvent:theEvent]) {
       [self selectCell:selectedCell];
     }
 
     const NSUInteger mask = NSLeftMouseUpMask | NSLeftMouseDraggedMask;
     theEvent = [[self window] nextEventMatchingMask:mask];
   } while ([theEvent type] == NSLeftMouseDragged);
 
   // Do not message the delegate if released outside view.
   if (![self selectCellForEvent:theEvent]) {
     [self selectCell:selectedCell];
   } else {
     const NSInteger selectedRow = [self selectedRow];
 
     // No row could be selected if the model failed to update.
     if (selectedRow == -1) {
       NOTREACHED();
       return;
     }
 
     DCHECK(observer_);
     observer_->OnMatrixRowClicked(self, selectedRow);
   }
 }
 
+- (void)selectRowIndex:(NSInteger)rowIndex {
+  NSIndexSet* indexSet = [NSIndexSet indexSetWithIndex:rowIndex];
+  [self selectRowIndexes:indexSet byExtendingSelection:NO];
+}
+
+- (NSInteger)highlightedRow {
+  return [[self controller] highlightedRow];
+}
+
+- (void)setController:(OmniboxPopupTableController*)controller {
+  matrixController_.reset([controller retain]);
+  [self setDelegate:controller];
+  [self setDataSource:controller];
+  [self reloadData];
+}
+
 - (void)resetTrackingArea {
   if (trackingArea_.get())
     [self removeTrackingArea:trackingArea_.get()];
 
   trackingArea_.reset([[CrTrackingArea alloc]
       initWithRect:[self frame]
            options:NSTrackingMouseEnteredAndExited |
                    NSTrackingMouseMoved |
                    NSTrackingActiveInActiveApp |
                    NSTrackingInVisibleRect
              owner:self
           userInfo:nil]);
   [self addTrackingArea:trackingArea_.get()];
 }
 
-- (void)highlightRowAt:(NSInteger)rowIndex {
-  // highlightCell will be nil if rowIndex is out of range, so no cell will be
-  // highlighted.
-  NSCell* highlightCell = [self cellAtRow:rowIndex column:0];
-
-  for (NSCell* cell in [self cells]) {
-    [cell setHighlighted:(cell == highlightCell)];
-  }
-}
-
 - (void)highlightRowUnder:(NSEvent*)theEvent {
   NSPoint point = [self convertPoint:[theEvent locationInWindow] fromView:nil];
-  NSInteger row, column;
-  if ([self getRow:&row column:&column forPoint:point]) {
-    [self highlightRowAt:row];
-  } else {
-    [self highlightRowAt:-1];
+  NSInteger oldRow = [[self controller] highlightedRow];
+  NSInteger newRow = [self rowAtPoint:point];
+  if (oldRow != newRow) {
+    [[self controller] setHighlightedRow:newRow];
+    [self setNeedsDisplayInRect:[self rectOfRow:oldRow]];
+    [self setNeedsDisplayInRect:[self rectOfRow:newRow]];
   }
 }
 
-// Select cell under |theEvent|, returning YES if a selection is made.
 - (BOOL)selectCellForEvent:(NSEvent*)theEvent {
   NSPoint point = [self convertPoint:[theEvent locationInWindow] fromView:nil];
 
-  NSInteger row, column;
-  if ([self getRow:&row column:&column forPoint:point]) {
-    DCHECK_EQ(column, 0);
+  NSInteger row = [self rowAtPoint:point];
+  [self selectRowIndex:row];
+  if (row != -1) {
     DCHECK(observer_);
     observer_->OnMatrixRowSelected(self, row);
     return YES;
   }
   return NO;
 }
 
 @end