electron/atom/browser/ui/cocoa/atom_touch_bar.mm

// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.

#import "atom/browser/ui/cocoa/atom_touch_bar.h"

#include "atom/common/color_util.h"
#include "atom/common/native_mate_converters/image_converter.h"
#include "base/strings/sys_string_conversions.h"
#include "skia/ext/skia_utils_mac.h"
#include "ui/gfx/image/image.h"

@implementation AtomTouchBar

static NSTouchBarItemIdentifier ButtonIdentifier =
    @"com.electron.touchbar.button.";
static NSTouchBarItemIdentifier ColorPickerIdentifier =
    @"com.electron.touchbar.colorpicker.";
static NSTouchBarItemIdentifier GroupIdentifier =
    @"com.electron.touchbar.group.";
static NSTouchBarItemIdentifier LabelIdentifier =
    @"com.electron.touchbar.label.";
static NSTouchBarItemIdentifier PopoverIdentifier =
    @"com.electron.touchbar.popover.";
static NSTouchBarItemIdentifier SliderIdentifier =
    @"com.electron.touchbar.slider.";
static NSTouchBarItemIdentifier SegmentedControlIdentifier =
    @"com.electron.touchbar.segmentedcontrol.";
static NSTouchBarItemIdentifier ScrubberIdentifier =
    @"com.electron.touchbar.scrubber.";

static NSString* const TextScrubberItemIdentifier = @"scrubber.text.item";
static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";

- (id)initWithDelegate:(id<NSTouchBarDelegate>)delegate
                window:(atom::NativeWindow*)window
              settings:
                  (const std::vector<mate::PersistentDictionary>&)settings {
  if ((self = [super init])) {
    delegate_ = delegate;
    window_ = window;
    ordered_settings_ = settings;
  }
  return self;
}

- (NSTouchBar*)makeTouchBar {
  NSMutableArray* identifiers =
      [self identifiersFromSettings:ordered_settings_];
  return [self touchBarFromItemIdentifiers:identifiers];
}

- (NSTouchBar*)touchBarFromItemIdentifiers:(NSMutableArray*)items {
  base::scoped_nsobject<NSTouchBar> bar(
      [[NSClassFromString(@"NSTouchBar") alloc] init]);
  [bar setDelegate:delegate_];
  [bar setDefaultItemIdentifiers:items];
  return bar.autorelease();
}

- (NSMutableArray*)identifiersFromSettings:
    (const std::vector<mate::PersistentDictionary>&)dicts {
  NSMutableArray* identifiers = [NSMutableArray array];

  if (@available(macOS 10.12.2, *)) {
    for (const auto& item : dicts) {
      std::string type;
      std::string item_id;
      if (item.Get("type", &type) && item.Get("id", &item_id)) {
        NSTouchBarItemIdentifier identifier = nil;
        if (type == "spacer") {
          std::string size;
          item.Get("size", &size);
          if (size == "large") {
            identifier = NSTouchBarItemIdentifierFixedSpaceLarge;
          } else if (size == "flexible") {
            identifier = NSTouchBarItemIdentifierFlexibleSpace;
          } else {
            identifier = NSTouchBarItemIdentifierFixedSpaceSmall;
          }
        } else {
          identifier = [self identifierFromID:item_id type:type];
        }

        if (identifier) {
          settings_[item_id] = item;
          [identifiers addObject:identifier];
        }
      }
    }
    [identifiers addObject:NSTouchBarItemIdentifierOtherItemsProxy];
  }

  return identifiers;
}

- (NSTouchBarItem*)makeItemForIdentifier:(NSTouchBarItemIdentifier)identifier {
  NSString* item_id = nil;

  if ([identifier hasPrefix:ButtonIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:ButtonIdentifier];
    return [self makeButtonForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:LabelIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:LabelIdentifier];
    return [self makeLabelForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:ColorPickerIdentifier]) {
    item_id =
        [self idFromIdentifier:identifier withPrefix:ColorPickerIdentifier];
    return [self makeColorPickerForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:SliderIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:SliderIdentifier];
    return [self makeSliderForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:PopoverIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:PopoverIdentifier];
    return [self makePopoverForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:GroupIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:GroupIdentifier];
    return [self makeGroupForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:SegmentedControlIdentifier]) {
    item_id = [self idFromIdentifier:identifier
                          withPrefix:SegmentedControlIdentifier];
    return [self makeSegmentedControlForID:item_id withIdentifier:identifier];
  } else if ([identifier hasPrefix:ScrubberIdentifier]) {
    item_id = [self idFromIdentifier:identifier withPrefix:ScrubberIdentifier];
    return [self makeScrubberForID:item_id withIdentifier:identifier];
  }

  return nil;
}

- (void)refreshTouchBarItem:(NSTouchBar*)touchBar
                         id:(NSTouchBarItemIdentifier)identifier
                   withType:(const std::string&)item_type
               withSettings:(const mate::PersistentDictionary&)settings
    API_AVAILABLE(macosx(10.12.2)) {
  NSTouchBarItem* item = [touchBar itemForIdentifier:identifier];
  if (!item)
    return;

  if (item_type == "button") {
    [self updateButton:(NSCustomTouchBarItem*)item withSettings:settings];
  } else if (item_type == "label") {
    [self updateLabel:(NSCustomTouchBarItem*)item withSettings:settings];
  } else if (item_type == "colorpicker") {
    [self updateColorPicker:(NSColorPickerTouchBarItem*)item
               withSettings:settings];
  } else if (item_type == "slider") {
    [self updateSlider:(NSSliderTouchBarItem*)item withSettings:settings];
  } else if (item_type == "popover") {
    [self updatePopover:(NSPopoverTouchBarItem*)item withSettings:settings];
  } else if (item_type == "segmented_control") {
    [self updateSegmentedControl:(NSCustomTouchBarItem*)item
                    withSettings:settings];
  } else if (item_type == "scrubber") {
    [self updateScrubber:(NSCustomTouchBarItem*)item withSettings:settings];
  } else if (item_type == "group") {
    [self updateGroup:(NSGroupTouchBarItem*)item withSettings:settings];
  }
}

- (void)addNonDefaultTouchBarItems:
    (const std::vector<mate::PersistentDictionary>&)items {
  [self identifiersFromSettings:items];
}

- (void)setEscapeTouchBarItem:(const mate::PersistentDictionary&)item
                  forTouchBar:(NSTouchBar*)touchBar {
  if (![touchBar
          respondsToSelector:@selector(escapeKeyReplacementItemIdentifier)])
    return;
  std::string type;
  std::string item_id;
  NSTouchBarItemIdentifier identifier = nil;
  if (item.Get("type", &type) && item.Get("id", &item_id)) {
    identifier = [self identifierFromID:item_id type:type];
  }
  if (identifier) {
    [self addNonDefaultTouchBarItems:{item}];
    touchBar.escapeKeyReplacementItemIdentifier = identifier;
  } else {
    touchBar.escapeKeyReplacementItemIdentifier = nil;
  }
}

- (void)refreshTouchBarItem:(NSTouchBar*)touchBar
                         id:(const std::string&)item_id {
  if (![self hasItemWithID:item_id])
    return;

  mate::PersistentDictionary settings = settings_[item_id];
  std::string item_type;
  settings.Get("type", &item_type);

  auto identifier = [self identifierFromID:item_id type:item_type];
  if (!identifier)
    return;

  std::vector<mate::Dictionary> parents;
  settings.Get("_parents", &parents);
  for (auto& parent : parents) {
    std::string parent_type;
    std::string parent_id;
    if (!parent.Get("type", &parent_type) || !parent.Get("id", &parent_id))
      continue;
    auto parentIdentifier = [self identifierFromID:parent_id type:parent_type];
    if (!parentIdentifier)
      continue;

    if (parent_type == "popover") {
      NSPopoverTouchBarItem* popoverItem =
          [touchBar itemForIdentifier:parentIdentifier];
      [self refreshTouchBarItem:popoverItem.popoverTouchBar
                             id:identifier
                       withType:item_type
                   withSettings:settings];
    } else if (parent_type == "group") {
      NSGroupTouchBarItem* groupItem =
          [touchBar itemForIdentifier:parentIdentifier];
      [self refreshTouchBarItem:groupItem.groupTouchBar
                             id:identifier
                       withType:item_type
                   withSettings:settings];
    }
  }

  [self refreshTouchBarItem:touchBar
                         id:identifier
                   withType:item_type
               withSettings:settings];
}

- (void)buttonAction:(id)sender {
  NSString* item_id =
      [NSString stringWithFormat:@"%ld", ((NSButton*)sender).tag];
  window_->NotifyTouchBarItemInteraction([item_id UTF8String],
                                         base::DictionaryValue());
}

- (void)colorPickerAction:(id)sender {
  NSString* identifier = ((NSColorPickerTouchBarItem*)sender).identifier;
  NSString* item_id =
      [self idFromIdentifier:identifier withPrefix:ColorPickerIdentifier];
  NSColor* color = ((NSColorPickerTouchBarItem*)sender).color;
  std::string hex_color = atom::ToRGBHex(skia::NSDeviceColorToSkColor(color));
  base::DictionaryValue details;
  details.SetString("color", hex_color);
  window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
}

- (void)sliderAction:(id)sender {
  NSString* identifier = ((NSSliderTouchBarItem*)sender).identifier;
  NSString* item_id =
      [self idFromIdentifier:identifier withPrefix:SliderIdentifier];
  base::DictionaryValue details;
  details.SetInteger("value",
                     [((NSSliderTouchBarItem*)sender).slider intValue]);
  window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
}

- (NSString*)idFromIdentifier:(NSString*)identifier
                   withPrefix:(NSString*)prefix {
  return [identifier substringFromIndex:[prefix length]];
}

- (void)segmentedControlAction:(id)sender {
  NSString* item_id =
      [NSString stringWithFormat:@"%ld", ((NSSegmentedControl*)sender).tag];
  base::DictionaryValue details;
  details.SetInteger("selectedIndex",
                     ((NSSegmentedControl*)sender).selectedSegment);
  details.SetBoolean(
      "isSelected",
      [((NSSegmentedControl*)sender)
          isSelectedForSegment:((NSSegmentedControl*)sender).selectedSegment]);
  window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
}

- (void)scrubber:(NSScrubber*)scrubber
    didSelectItemAtIndex:(NSInteger)selectedIndex
    API_AVAILABLE(macosx(10.12.2)) {
  base::DictionaryValue details;
  details.SetInteger("selectedIndex", selectedIndex);
  details.SetString("type", "select");
  window_->NotifyTouchBarItemInteraction([scrubber.identifier UTF8String],
                                         details);
}

- (void)scrubber:(NSScrubber*)scrubber
    didHighlightItemAtIndex:(NSInteger)highlightedIndex
    API_AVAILABLE(macosx(10.12.2)) {
  base::DictionaryValue details;
  details.SetInteger("highlightedIndex", highlightedIndex);
  details.SetString("type", "highlight");
  window_->NotifyTouchBarItemInteraction([scrubber.identifier UTF8String],
                                         details);
}

- (NSTouchBarItemIdentifier)identifierFromID:(const std::string&)item_id
                                        type:(const std::string&)type {
  NSTouchBarItemIdentifier base_identifier = nil;
  if (type == "button")
    base_identifier = ButtonIdentifier;
  else if (type == "label")
    base_identifier = LabelIdentifier;
  else if (type == "colorpicker")
    base_identifier = ColorPickerIdentifier;
  else if (type == "slider")
    base_identifier = SliderIdentifier;
  else if (type == "popover")
    base_identifier = PopoverIdentifier;
  else if (type == "group")
    base_identifier = GroupIdentifier;
  else if (type == "segmented_control")
    base_identifier = SegmentedControlIdentifier;
  else if (type == "scrubber")
    base_identifier = ScrubberIdentifier;

  if (base_identifier)
    return [NSString stringWithFormat:@"%@%s", base_identifier, item_id.data()];
  else
    return nil;
}

- (bool)hasItemWithID:(const std::string&)item_id {
  return settings_.find(item_id) != settings_.end();
}

- (NSColor*)colorFromHexColorString:(const std::string&)colorString {
  SkColor color = atom::ParseHexColor(colorString);
  return skia::SkColorToDeviceNSColor(color);
}

- (NSTouchBarItem*)makeButtonForID:(NSString*)id
                    withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSCustomTouchBarItem> item([[NSClassFromString(
      @"NSCustomTouchBarItem") alloc] initWithIdentifier:identifier]);
  NSButton* button = [NSButton buttonWithTitle:@""
                                        target:self
                                        action:@selector(buttonAction:)];
  button.tag = [id floatValue];
  [item setView:button];
  [self updateButton:item withSettings:settings];
  return item.autorelease();
}

- (void)updateButton:(NSCustomTouchBarItem*)item
        withSettings:(const mate::PersistentDictionary&)settings {
  NSButton* button = (NSButton*)item.view;

  std::string backgroundColor;
  if (settings.Get("backgroundColor", &backgroundColor)) {
    button.bezelColor = [self colorFromHexColorString:backgroundColor];
  }

  std::string label;
  settings.Get("label", &label);
  button.title = base::SysUTF8ToNSString(label);

  gfx::Image image;
  if (settings.Get("icon", &image)) {
    button.image = image.AsNSImage();

    std::string iconPosition;
    settings.Get("iconPosition", &iconPosition);
    if (iconPosition == "left") {
      button.imagePosition = NSImageLeft;
    } else if (iconPosition == "right") {
      button.imagePosition = NSImageRight;
    } else {
      button.imagePosition = NSImageOverlaps;
    }
  }
}

- (NSTouchBarItem*)makeLabelForID:(NSString*)id
                   withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSCustomTouchBarItem> item([[NSClassFromString(
      @"NSCustomTouchBarItem") alloc] initWithIdentifier:identifier]);
  [item setView:[NSTextField labelWithString:@""]];
  [self updateLabel:item withSettings:settings];
  return item.autorelease();
}

- (void)updateLabel:(NSCustomTouchBarItem*)item
       withSettings:(const mate::PersistentDictionary&)settings {
  NSTextField* text_field = (NSTextField*)item.view;

  std::string label;
  settings.Get("label", &label);
  text_field.stringValue = base::SysUTF8ToNSString(label);

  std::string textColor;
  if (settings.Get("textColor", &textColor) && !textColor.empty()) {
    text_field.textColor = [self colorFromHexColorString:textColor];
  } else {
    text_field.textColor = nil;
  }
}

- (NSTouchBarItem*)makeColorPickerForID:(NSString*)id
                         withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSColorPickerTouchBarItem> item([[NSClassFromString(
      @"NSColorPickerTouchBarItem") alloc] initWithIdentifier:identifier]);
  [item setTarget:self];
  [item setAction:@selector(colorPickerAction:)];
  [self updateColorPicker:item withSettings:settings];
  return item.autorelease();
}

- (void)updateColorPicker:(NSColorPickerTouchBarItem*)item
             withSettings:(const mate::PersistentDictionary&)settings {
  std::vector<std::string> colors;
  if (settings.Get("availableColors", &colors) && !colors.empty()) {
    NSColorList* color_list =
        [[[NSColorList alloc] initWithName:@""] autorelease];
    for (size_t i = 0; i < colors.size(); ++i) {
      [color_list insertColor:[self colorFromHexColorString:colors[i]]
                          key:base::SysUTF8ToNSString(colors[i])
                      atIndex:i];
    }
    item.colorList = color_list;
  }

  std::string selectedColor;
  if (settings.Get("selectedColor", &selectedColor)) {
    item.color = [self colorFromHexColorString:selectedColor];
  }
}

- (NSTouchBarItem*)makeSliderForID:(NSString*)id
                    withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSSliderTouchBarItem> item([[NSClassFromString(
      @"NSSliderTouchBarItem") alloc] initWithIdentifier:identifier]);
  [item setTarget:self];
  [item setAction:@selector(sliderAction:)];
  [self updateSlider:item withSettings:settings];
  return item.autorelease();
}

- (void)updateSlider:(NSSliderTouchBarItem*)item
        withSettings:(const mate::PersistentDictionary&)settings {
  std::string label;
  settings.Get("label", &label);
  item.label = base::SysUTF8ToNSString(label);

  int maxValue = 100;
  int minValue = 0;
  int value = 50;
  settings.Get("minValue", &minValue);
  settings.Get("maxValue", &maxValue);
  settings.Get("value", &value);

  item.slider.minValue = minValue;
  item.slider.maxValue = maxValue;
  item.slider.doubleValue = value;
}

- (NSTouchBarItem*)makePopoverForID:(NSString*)id
                     withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSPopoverTouchBarItem> item([[NSClassFromString(
      @"NSPopoverTouchBarItem") alloc] initWithIdentifier:identifier]);
  [self updatePopover:item withSettings:settings];
  return item.autorelease();
}

- (void)updatePopover:(NSPopoverTouchBarItem*)item
         withSettings:(const mate::PersistentDictionary&)settings {
  std::string label;
  settings.Get("label", &label);
  item.collapsedRepresentationLabel = base::SysUTF8ToNSString(label);

  gfx::Image image;
  if (settings.Get("icon", &image)) {
    item.collapsedRepresentationImage = image.AsNSImage();
  }

  bool showCloseButton = true;
  settings.Get("showCloseButton", &showCloseButton);
  item.showsCloseButton = showCloseButton;

  mate::PersistentDictionary child;
  std::vector<mate::PersistentDictionary> items;
  if (settings.Get("child", &child) && child.Get("ordereredItems", &items)) {
    item.popoverTouchBar =
        [self touchBarFromItemIdentifiers:[self identifiersFromSettings:items]];
  }
}

- (NSTouchBarItem*)makeGroupForID:(NSString*)id
                   withIdentifier:(NSString*)identifier {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;
  mate::PersistentDictionary settings = settings_[s_id];

  mate::PersistentDictionary child;
  if (!settings.Get("child", &child))
    return nil;
  std::vector<mate::PersistentDictionary> items;
  if (!child.Get("ordereredItems", &items))
    return nil;

  NSMutableArray* generatedItems = [NSMutableArray array];
  NSMutableArray* identifiers = [self identifiersFromSettings:items];
  for (NSUInteger i = 0; i < [identifiers count]; ++i) {
    if ([identifiers objectAtIndex:i] !=
        NSTouchBarItemIdentifierOtherItemsProxy) {
      NSTouchBarItem* generatedItem =
          [self makeItemForIdentifier:[identifiers objectAtIndex:i]];
      if (generatedItem) {
        [generatedItems addObject:generatedItem];
      }
    }
  }
  return [NSClassFromString(@"NSGroupTouchBarItem")
      groupItemWithIdentifier:identifier
                        items:generatedItems];
}

- (void)updateGroup:(NSGroupTouchBarItem*)item
       withSettings:(const mate::PersistentDictionary&)settings
    API_AVAILABLE(macosx(10.12.2)) {
  mate::PersistentDictionary child;
  if (!settings.Get("child", &child))
    return;
  std::vector<mate::PersistentDictionary> items;
  if (!child.Get("ordereredItems", &items))
    return;

  item.groupTouchBar =
      [self touchBarFromItemIdentifiers:[self identifiersFromSettings:items]];
}

- (NSTouchBarItem*)makeSegmentedControlForID:(NSString*)id
                              withIdentifier:(NSString*)identifier
    API_AVAILABLE(macosx(10.12.2)) {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSCustomTouchBarItem> item([[NSClassFromString(
      @"NSCustomTouchBarItem") alloc] initWithIdentifier:identifier]);

  NSSegmentedControl* control = [NSSegmentedControl
      segmentedControlWithLabels:[NSMutableArray array]
                    trackingMode:NSSegmentSwitchTrackingSelectOne
                          target:self
                          action:@selector(segmentedControlAction:)];
  control.tag = [id floatValue];
  [item setView:control];

  [self updateSegmentedControl:item withSettings:settings];
  return item.autorelease();
}

- (void)updateSegmentedControl:(NSCustomTouchBarItem*)item
                  withSettings:(const mate::PersistentDictionary&)settings
    API_AVAILABLE(macosx(10.12.2)) {
  NSSegmentedControl* control = item.view;

  std::string segmentStyle;
  settings.Get("segmentStyle", &segmentStyle);
  if (segmentStyle == "rounded")
    control.segmentStyle = NSSegmentStyleRounded;
  else if (segmentStyle == "textured-rounded")
    control.segmentStyle = NSSegmentStyleTexturedRounded;
  else if (segmentStyle == "round-rect")
    control.segmentStyle = NSSegmentStyleRoundRect;
  else if (segmentStyle == "textured-square")
    control.segmentStyle = NSSegmentStyleTexturedSquare;
  else if (segmentStyle == "capsule")
    control.segmentStyle = NSSegmentStyleCapsule;
  else if (segmentStyle == "small-square")
    control.segmentStyle = NSSegmentStyleSmallSquare;
  else if (segmentStyle == "separated")
    control.segmentStyle = NSSegmentStyleSeparated;
  else
    control.segmentStyle = NSSegmentStyleAutomatic;

  std::string segmentMode;
  settings.Get("mode", &segmentMode);
  if (segmentMode == "multiple")
    control.trackingMode = NSSegmentSwitchTrackingSelectAny;
  else if (segmentMode == "buttons")
    control.trackingMode = NSSegmentSwitchTrackingMomentary;
  else
    control.trackingMode = NSSegmentSwitchTrackingSelectOne;

  std::vector<mate::Dictionary> segments;
  settings.Get("segments", &segments);

  control.segmentCount = segments.size();
  for (size_t i = 0; i < segments.size(); ++i) {
    std::string label;
    gfx::Image image;
    bool enabled = true;
    segments[i].Get("enabled", &enabled);
    if (segments[i].Get("label", &label)) {
      [control setLabel:base::SysUTF8ToNSString(label) forSegment:i];
    } else {
      [control setLabel:@"" forSegment:i];
    }
    if (segments[i].Get("icon", &image)) {
      [control setImage:image.AsNSImage() forSegment:i];
      [control setImageScaling:NSImageScaleProportionallyUpOrDown forSegment:i];
    } else {
      [control setImage:nil forSegment:i];
    }
    [control setEnabled:enabled forSegment:i];
  }

  int selectedIndex = 0;
  settings.Get("selectedIndex", &selectedIndex);
  if (selectedIndex >= 0 && selectedIndex < control.segmentCount)
    control.selectedSegment = selectedIndex;
}

- (NSTouchBarItem*)makeScrubberForID:(NSString*)id
                      withIdentifier:(NSString*)identifier
    API_AVAILABLE(macosx(10.12.2)) {
  std::string s_id([id UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  base::scoped_nsobject<NSCustomTouchBarItem> item([[NSClassFromString(
      @"NSCustomTouchBarItem") alloc] initWithIdentifier:identifier]);

  NSScrubber* scrubber = [[[NSClassFromString(@"NSScrubber") alloc]
      initWithFrame:NSZeroRect] autorelease];

  [scrubber registerClass:NSClassFromString(@"NSScrubberTextItemView")
        forItemIdentifier:TextScrubberItemIdentifier];
  [scrubber registerClass:NSClassFromString(@"NSScrubberImageItemView")
        forItemIdentifier:ImageScrubberItemIdentifier];

  scrubber.delegate = self;
  scrubber.dataSource = self;
  scrubber.identifier = id;

  [item setView:scrubber];
  [self updateScrubber:item withSettings:settings];

  return item.autorelease();
}

- (void)updateScrubber:(NSCustomTouchBarItem*)item
          withSettings:(const mate::PersistentDictionary&)settings
    API_AVAILABLE(macosx(10.12.2)) {
  NSScrubber* scrubber = item.view;

  bool showsArrowButtons = false;
  settings.Get("showArrowButtons", &showsArrowButtons);
  scrubber.showsArrowButtons = showsArrowButtons;

  std::string selectedStyle;
  std::string overlayStyle;
  settings.Get("selectedStyle", &selectedStyle);
  settings.Get("overlayStyle", &overlayStyle);

  if (selectedStyle == "outline") {
    scrubber.selectionBackgroundStyle =
        [NSClassFromString(@"NSScrubberSelectionStyle") outlineOverlayStyle];
  } else if (selectedStyle == "background") {
    scrubber.selectionBackgroundStyle =
        [NSClassFromString(@"NSScrubberSelectionStyle") roundedBackgroundStyle];
  } else {
    scrubber.selectionBackgroundStyle = nil;
  }

  if (overlayStyle == "outline") {
    scrubber.selectionOverlayStyle =
        [NSClassFromString(@"NSScrubberSelectionStyle") outlineOverlayStyle];
  } else if (overlayStyle == "background") {
    scrubber.selectionOverlayStyle =
        [NSClassFromString(@"NSScrubberSelectionStyle") roundedBackgroundStyle];
  } else {
    scrubber.selectionOverlayStyle = nil;
  }

  std::string mode;
  settings.Get("mode", &mode);
  if (mode == "fixed") {
    scrubber.mode = NSScrubberModeFixed;
  } else {
    scrubber.mode = NSScrubberModeFree;
  }

  bool continuous = true;
  settings.Get("continuous", &continuous);
  scrubber.continuous = continuous;

  [scrubber reloadData];
}

- (NSInteger)numberOfItemsForScrubber:(NSScrubber*)scrubber
    API_AVAILABLE(macosx(10.12.2)) {
  std::string s_id([[scrubber identifier] UTF8String]);
  if (![self hasItemWithID:s_id])
    return 0;

  mate::PersistentDictionary settings = settings_[s_id];
  std::vector<mate::PersistentDictionary> items;
  settings.Get("items", &items);
  return items.size();
}

- (NSScrubberItemView*)scrubber:(NSScrubber*)scrubber
             viewForItemAtIndex:(NSInteger)index
    API_AVAILABLE(macosx(10.12.2)) {
  std::string s_id([[scrubber identifier] UTF8String]);
  if (![self hasItemWithID:s_id])
    return nil;

  mate::PersistentDictionary settings = settings_[s_id];
  std::vector<mate::PersistentDictionary> items;
  if (!settings.Get("items", &items))
    return nil;

  if (index >= static_cast<NSInteger>(items.size()))
    return nil;

  mate::PersistentDictionary item = items[index];

  NSScrubberItemView* itemView;
  std::string title;

  if (item.Get("label", &title)) {
    NSScrubberTextItemView* view =
        [scrubber makeItemWithIdentifier:TextScrubberItemIdentifier owner:self];
    view.title = base::SysUTF8ToNSString(title);
    itemView = view;
  } else {
    NSScrubberImageItemView* view =
        [scrubber makeItemWithIdentifier:ImageScrubberItemIdentifier
                                   owner:self];
    gfx::Image image;
    if (item.Get("icon", &image)) {
      view.image = image.AsNSImage();
    }
    itemView = view;
  }

  return itemView;
}

- (NSSize)scrubber:(NSScrubber*)scrubber
                layout:(NSScrubberFlowLayout*)layout
    sizeForItemAtIndex:(NSInteger)itemIndex API_AVAILABLE(macosx(10.12.2)) {
  NSInteger width = 50;
  NSInteger height = 30;
  NSInteger margin = 15;
  NSSize defaultSize = NSMakeSize(width, height);

  std::string s_id([[scrubber identifier] UTF8String]);
  if (![self hasItemWithID:s_id])
    return defaultSize;

  mate::PersistentDictionary settings = settings_[s_id];
  std::vector<mate::PersistentDictionary> items;
  if (!settings.Get("items", &items))
    return defaultSize;

  if (itemIndex >= static_cast<NSInteger>(items.size()))
    return defaultSize;

  mate::PersistentDictionary item = items[itemIndex];
  std::string title;

  if (item.Get("label", &title)) {
    NSSize size = NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX);
    NSRect textRect = [base::SysUTF8ToNSString(title)
        boundingRectWithSize:size
                     options:NSStringDrawingUsesLineFragmentOrigin |
                             NSStringDrawingUsesFontLeading
                  attributes:@{
                    NSFontAttributeName : [NSFont systemFontOfSize:0]
                  }];

    width = textRect.size.width + margin;
  } else {
    gfx::Image image;
    if (item.Get("icon", &image)) {
      width = image.AsNSImage().size.width;
    }
  }

  return NSMakeSize(width, height);
}

@end