ash / hud_display / hud_settings_view.cc [blame]

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/hud_display/hud_settings_view.h"

#include <set>
#include <string>

#include "ash/hud_display/ash_tracing_handler.h"
#include "ash/hud_display/hud_display.h"
#include "ash/hud_display/hud_properties.h"
#include "ash/shell.h"
#include "ash/shell_delegate.h"
#include "base/compiler_specific.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/strcat.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "cc/debug/layer_tree_debug_state.h"
#include "components/viz/common/display/renderer_settings.h"
#include "components/viz/host/host_frame_sink_manager.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkPath.h"
#include "ui/aura/env.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/events/event.h"
#include "ui/events/types/event_type.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/paint_throbber.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/controls/button/checkbox.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/slider.h"
#include "ui/views/layout/box_layout.h"

namespace ash {
namespace hud_display {
namespace {

constexpr SkColor kHUDDisabledButtonColor =
    SkColorSetA(kHUDDefaultColor, 0xFF * 0.5);

// Thickness of border around settings.
constexpr int kHUDSettingsBorderWidth = 1;

ui::ScopedAnimationDurationScaleMode* scoped_animation_duration_scale_mode =
    nullptr;

}  // anonymous namespace

class HUDCheckboxHandler {
 public:
  HUDCheckboxHandler(
      views::Checkbox* checkbox,
      base::RepeatingCallback<void(views::Checkbox*)> update_state)
      : checkbox_(checkbox), update_state_(update_state) {}

  HUDCheckboxHandler(const HUDCheckboxHandler&) = delete;
  HUDCheckboxHandler& operator=(const HUDCheckboxHandler&) = delete;

  void UpdateState() const { update_state_.Run(checkbox_.get()); }

 private:
  const raw_ptr<views::Checkbox> checkbox_;  // not owned.
  base::RepeatingCallback<void(views::Checkbox*)> update_state_;
};

namespace {

base::RepeatingCallback<void(views::Checkbox*)> GetVisDebugUpdateStateCallback(
    const bool viz::DebugRendererSettings::*field) {
  return base::BindRepeating(
      [](const bool viz::DebugRendererSettings::*field,
         views::Checkbox* checkbox) {
        checkbox->SetChecked(aura::Env::GetInstance()
                                 ->context_factory()
                                 ->GetHostFrameSinkManager()
                                 ->debug_renderer_settings().*
                             field);
      },
      field);
}

base::RepeatingCallback<void(views::Checkbox*)> GetVisDebugHandleClickCallback(
    bool viz::DebugRendererSettings::*field) {
  return base::BindRepeating(
      [](bool viz::DebugRendererSettings::*field, views::Checkbox* checkbox) {
        viz::HostFrameSinkManager* manager = aura::Env::GetInstance()
                                                 ->context_factory()
                                                 ->GetHostFrameSinkManager();
        viz::DebugRendererSettings debug_settings =
            manager->debug_renderer_settings();
        debug_settings.*field = checkbox->GetChecked();
        manager->UpdateDebugRendererSettings(debug_settings);
      },
      field);
}

base::RepeatingCallback<void(views::Checkbox*)> GetCCDebugUpdateStateCallback(
    const bool cc::LayerTreeDebugState::*field) {
  return base::BindRepeating(
      [](const bool cc::LayerTreeDebugState::*field,
         views::Checkbox* checkbox) {
        bool is_enabled = false;
        aura::Window::Windows root_windows = Shell::Get()->GetAllRootWindows();
        for (aura::Window* window : root_windows) {
          ui::Compositor* compositor = window->GetHost()->compositor();
          is_enabled |= compositor->GetLayerTreeDebugState().*field;
        }
        checkbox->SetChecked(is_enabled);
      },
      field);
}

base::RepeatingCallback<void(views::Checkbox*)> GetCCDebugHandleClickCallback(
    bool cc::LayerTreeDebugState::*field) {
  return base::BindRepeating(
      [](bool cc::LayerTreeDebugState::*field, views::Checkbox* checkbox) {
        aura::Window::Windows root_windows = Shell::Get()->GetAllRootWindows();
        for (aura::Window* window : root_windows) {
          ui::Compositor* compositor = window->GetHost()->compositor();
          cc::LayerTreeDebugState state = compositor->GetLayerTreeDebugState();
          state.*field = checkbox->GetChecked();
          compositor->SetLayerTreeDebugState(state);
        }
      },
      field);
}

// views::Checkbox that ignores theme colors.
class SettingsCheckbox : public views::Checkbox {
  METADATA_HEADER(SettingsCheckbox, views::Checkbox)

 public:
  SettingsCheckbox(const std::u16string& label, const std::u16string& tooltip)
      : views::Checkbox(label, views::Button::PressedCallback()) {
    SetTooltipText(tooltip);
  }
  SettingsCheckbox(const SettingsCheckbox& other) = delete;
  SettingsCheckbox operator=(const SettingsCheckbox& other) = delete;

  ~SettingsCheckbox() override = default;

  // views::Checkbox:
  SkColor GetIconImageColor(int icon_state) const override {
    return kHUDDefaultColor;
  }
};

BEGIN_METADATA(SettingsCheckbox)
END_METADATA

class AnimationSpeedSlider : public views::Slider {
  METADATA_HEADER(AnimationSpeedSlider, views::Slider)

 public:
  AnimationSpeedSlider(const base::flat_set<float>& values,
                       views::SliderListener* listener = nullptr)
      : views::Slider(listener) {
    SetAllowedValues(&values);
  }

  AnimationSpeedSlider(const AnimationSpeedSlider&) = delete;
  AnimationSpeedSlider operator=(const AnimationSpeedSlider&) = delete;

  ~AnimationSpeedSlider() override = default;

  // views::Slider:
  SkColor GetThumbColor() const override { return kHUDDefaultColor; }

  SkColor GetTroughColor() const override { return kHUDDefaultColor; }
  void OnPaint(gfx::Canvas* canvas) override;
};

BEGIN_METADATA(AnimationSpeedSlider)
END_METADATA

void AnimationSpeedSlider::OnPaint(gfx::Canvas* canvas) {
  views::Slider::OnPaint(canvas);

  // Paint ticks.
  const int kTickHeight = 8;
  const gfx::Rect content = GetContentsBounds();
  const gfx::Insets insets = GetInsets();
  const int y = insets.top() + content.height() / 2 - kTickHeight / 2;

  SkPath path;
  for (const float v : allowed_values()) {
    const float x = insets.left() + content.width() * v;
    path.moveTo(x, y);
    path.lineTo(x, y + kTickHeight);
  }

  cc::PaintFlags flags;
  flags.setAntiAlias(true);
  flags.setBlendMode(SkBlendMode::kSrc);
  flags.setColor(GetThumbColor());
  flags.setStrokeWidth(1);
  flags.setStyle(cc::PaintFlags::kStroke_Style);
  canvas->DrawPath(path, flags);
}

// Checkbox group for setting UI animation speed.
class AnimationSpeedControl : public views::SliderListener, public views::View {
  METADATA_HEADER(AnimationSpeedControl, views::View)

 public:
  AnimationSpeedControl();
  AnimationSpeedControl(const AnimationSpeedControl&) = delete;
  AnimationSpeedControl& operator=(const AnimationSpeedControl&) = delete;

  ~AnimationSpeedControl() override;

  // views::SliderListener:
  void SliderValueChanged(views::Slider* sender,
                          float value,
                          float old_value,
                          views::SliderChangeReason reason) override;

  // views::View:
  void Layout(PassKey) override;

 private:
  // Map slider values to animation scale.
  using SliderValuesMap = base::flat_map<float, float>;

  raw_ptr<views::View> hints_container_ = nullptr;  // not owned.
  raw_ptr<AnimationSpeedSlider> slider_ = nullptr;  // not owned.

  SliderValuesMap slider_values_;
};

BEGIN_METADATA(AnimationSpeedControl)
END_METADATA

AnimationSpeedControl::AnimationSpeedControl() {
  // This view consists of the title, slider values hints and a slider.
  // Values hints live in a separate container.
  // Slider is under that container and is resized to match the hints.
  SetLayoutManager(std::make_unique<views::BoxLayout>(
                       views::BoxLayout::Orientation::kVertical))
      ->set_cross_axis_alignment(views::BoxLayout::CrossAxisAlignment::kCenter);

  views::Label* title = AddChildView(std::make_unique<views::Label>(
      u"Animation speed:", views::style::CONTEXT_LABEL));
  title->SetAutoColorReadabilityEnabled(false);
  title->SetEnabledColor(kHUDDefaultColor);

  hints_container_ = AddChildView(std::make_unique<views::View>());
  hints_container_->SetLayoutManager(std::make_unique<views::BoxLayout>(
      views::BoxLayout::Orientation::kHorizontal));

  std::vector<float> multipliers;

  auto add_speed_point = [](AnimationSpeedControl* self, views::View* container,
                            std::vector<float>& multipliers, float multiplier,
                            const std::u16string& text) {
    constexpr int kLabelBorderWidth = 3;
    views::Label* label = container->AddChildView(
        std::make_unique<views::Label>(text, views::style::CONTEXT_LABEL));
    label->SetAutoColorReadabilityEnabled(false);
    label->SetEnabledColor(kHUDDefaultColor);
    label->SetBorder(
        views::CreateEmptyBorder(gfx::Insets::VH(0, kLabelBorderWidth)));
    label->SetHorizontalAlignment(gfx::ALIGN_CENTER);
    multipliers.push_back(multiplier);
  };

  add_speed_point(this, hints_container_, multipliers, 0, u"0");
  add_speed_point(this, hints_container_, multipliers, 0.5, u"0.5");
  add_speed_point(this, hints_container_, multipliers, 1, u"1");
  add_speed_point(this, hints_container_, multipliers, 2, u"2");
  add_speed_point(this, hints_container_, multipliers, 4, u"4");
  add_speed_point(this, hints_container_, multipliers, 10, u"10");

  // Now we need to calculate discrete values for the slider and active slider
  // value.
  std::vector<float> slider_values_list;
  const float steps = multipliers.size() - 1;
  const float active_multiplier =
      ui::ScopedAnimationDurationScaleMode::duration_multiplier();
  float slider_value = -1;
  for (size_t i = 0; i < multipliers.size(); ++i) {
    const float slider_step = i / steps;
    slider_values_list.push_back(slider_step);
    slider_values_[slider_step] = multipliers[i];
    if (multipliers[i] == active_multiplier)
      slider_value = slider_step;

    // If we did not find exact value for the slider, set it to upper bound
    // or to the maximum.
    if (slider_value == -1 &&
        (i == multipliers.size() - 1 || multipliers[i] > active_multiplier))
      slider_value = slider_step;
  }

  slider_ = AddChildView(std::make_unique<AnimationSpeedSlider>(
      base::flat_set<float>(slider_values_list), this));
  slider_->SetProperty(kHUDClickHandler, HTCLIENT);
  if (slider_value != -1)
    slider_->SetValue(slider_value);

  // Because the slider is focusable, it needs to have an accessible name so
  // that the screen reader knows what to announce. Indicating the slider is
  // labelled by the title will cause ViewAccessibility to set the name.
  slider_->GetViewAccessibility().SetName(*title);
}

AnimationSpeedControl::~AnimationSpeedControl() = default;

void AnimationSpeedControl::SliderValueChanged(
    views::Slider* sender,
    float value,
    float old_value,
    views::SliderChangeReason reason) {
  SliderValuesMap::const_iterator it = slider_values_.find(value);
  DCHECK(it != slider_values_.end());
  float multiplier = it->second;
  // There could be only one instance of the scoped modifier at a time.
  // So we need to destroy the existing one before we can create a
  // new one.
  delete scoped_animation_duration_scale_mode;
  scoped_animation_duration_scale_mode = nullptr;
  if (multiplier != 1) {
    scoped_animation_duration_scale_mode =
        new ui::ScopedAnimationDurationScaleMode(multiplier);
  }
}

void AnimationSpeedControl::Layout(PassKey) {
  gfx::Size max_size;
  // Make all labels equal size.
  for (const views::View* label : hints_container_->children()) {
    max_size.SetToMax(
        label->GetPreferredSize(views::SizeBounds(label->width(), {})));
  }

  for (views::View* label : hints_container_->children()) {
    label->SetPreferredSize(max_size);
  }

  gfx::Size hints_total_size = hints_container_->GetPreferredSize();
  // Slider should begin in the middle of the first label, and end in the
  // middle of the last label. But ripple overlays border, so we set total
  // width to match the total hints width and adjust border to make slider
  // correct size.
  gfx::Size slider_size(hints_total_size.width(), 30);
  slider_->SetPreferredSize(slider_size);
  slider_->SetBorder(
      views::CreateEmptyBorder(gfx::Insets::VH(0, max_size.width() / 2)));
  LayoutSuperclass<views::View>(this);
}

class HUDActionButton : public views::LabelButton {
  METADATA_HEADER(HUDActionButton, views::LabelButton)

 public:
  HUDActionButton(views::Button::PressedCallback::Callback callback,
                  const std::u16string& text)
      : LabelButton(callback, text) {
    SetHorizontalAlignment(gfx::ALIGN_CENTER);
    SetEnabledTextColors(kHUDBackground);
    SetProperty(kHUDClickHandler, HTCLIENT);
    constexpr float kActionButtonCournerRadius = 2;
    SetBackground(views::CreateRoundedRectBackground(
        kHUDDefaultColor, kActionButtonCournerRadius));
    SetFocusBehavior(views::View::FocusBehavior::ACCESSIBLE_ONLY);
    on_enabled_changed_subscription_ =
        AddEnabledChangedCallback(base::BindRepeating(
            &HUDActionButton::OnEnabedChanged, base::Unretained(this)));
  }

  HUDActionButton(const HUDActionButton&) = delete;
  HUDActionButton& operator=(const HUDActionButton&) = delete;

  ~HUDActionButton() override = default;

  void PaintButtonContents(gfx::Canvas* canvas) override {
    views::LabelButton::PaintButtonContents(canvas);
    if (spinner_refresh_timer_.IsRunning()) {
      base::Time now = base::Time::Now();
      gfx::Rect spinner = GetContentsBounds();
      int spinner_width = std::min(spinner.width(), spinner.height());
      spinner.ClampToCenteredSize(gfx::Size(spinner_width, spinner_width));
      gfx::PaintThrobberSpinning(canvas, spinner,
                                 SkColorSetA(SK_ColorWHITE, 0xFF * (.5)),
                                 (now - spinner_created_) / 8);
    }
  }

  void DisableWithSpinner() {
    DCHECK(!spinner_refresh_timer_.IsRunning());
    SetEnabled(false);
    constexpr base::TimeDelta interval = base::Seconds(0.5);
    spinner_created_ = base::Time::Now();
    spinner_refresh_timer_.Start(
        FROM_HERE, interval,
        base::BindRepeating(
            [](views::View* button) { button->SchedulePaint(); },
            base::Unretained(this)));
    SchedulePaint();
  }

  void UpdateBackgroundColor() override {
    if (GetVisualState() == STATE_DISABLED) {
      GetBackground()->SetNativeControlColor(kHUDDisabledButtonColor);
    } else {
      GetBackground()->SetNativeControlColor(kHUDDefaultColor);
    }
  }

 private:
  void OnEnabedChanged() {
    if (GetEnabled())
      spinner_refresh_timer_.Stop();
  }

  base::CallbackListSubscription on_enabled_changed_subscription_;
  base::Time spinner_created_;
  base::RepeatingTimer spinner_refresh_timer_;
};

BEGIN_METADATA(HUDActionButton)
END_METADATA

}  // anonymous namespace

BEGIN_METADATA(HUDSettingsView)
END_METADATA

HUDSettingsView::HUDSettingsView(HUDDisplayView* hud_display) {
  SetVisible(false);

  // We want AnimationSpeedControl to be stretched horizontally so we turn
  // stretch on by default.
  views::BoxLayout* layout_manager =
      SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kVertical));
  layout_manager->set_cross_axis_alignment(
      views::BoxLayout::CrossAxisAlignment::kStretch);
  SetBorder(
      views::CreateSolidBorder(kHUDSettingsBorderWidth, kHUDDefaultColor));

  // We want the HUD to be draggable when clicked on the whitespace, so we do
  // not want the buttons to extend past the minimum size. To overcome the
  // default horizontal stretch we put them into a separate container with
  // default left alignment.
  views::View* checkbox_container =
      AddChildView(std::make_unique<views::View>());
  checkbox_container
      ->SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kVertical))
      ->set_cross_axis_alignment(views::BoxLayout::CrossAxisAlignment::kStart);

  auto add_checkbox =
      [](HUDSettingsView* self, views::View* container,
         const std::u16string& text, const std::u16string& tooltip,
         base::RepeatingCallback<void(views::Checkbox*)> callback) {
        views::Checkbox* checkbox = container->AddChildView(
            std::make_unique<SettingsCheckbox>(text, tooltip));
        checkbox->SetCallback(
            base::BindRepeating(std::move(callback), checkbox));
        checkbox->SetEnabledTextColors(kHUDDefaultColor);
        checkbox->SetProperty(kHUDClickHandler, HTCLIENT);
        return checkbox;
      };

  checkbox_handlers_.push_back(std::make_unique<HUDCheckboxHandler>(
      add_checkbox(
          this, checkbox_container, u"Tint composited content",
          u"Equivalent to --tint-composited-content command-line option.",
          GetVisDebugHandleClickCallback(
              &viz::DebugRendererSettings::tint_composited_content)),
      GetVisDebugUpdateStateCallback(
          &viz::DebugRendererSettings::tint_composited_content)));
  checkbox_handlers_.push_back(std::make_unique<HUDCheckboxHandler>(
      add_checkbox(
          this, checkbox_container, u"Show overdraw feedback",
          u"Equivalent to --show-overdraw-feedback command-line option.",
          GetVisDebugHandleClickCallback(
              &viz::DebugRendererSettings::show_overdraw_feedback)),
      GetVisDebugUpdateStateCallback(
          &viz::DebugRendererSettings::show_overdraw_feedback)));
  checkbox_handlers_.push_back(std::make_unique<HUDCheckboxHandler>(
      add_checkbox(
          this, checkbox_container, u"Show aggregated damage",
          u"Equivalent to --show-aggregated-damage command-line option.",
          GetVisDebugHandleClickCallback(
              &viz::DebugRendererSettings::show_aggregated_damage)),
      GetVisDebugUpdateStateCallback(
          &viz::DebugRendererSettings::show_aggregated_damage)));
  checkbox_handlers_.push_back(std::make_unique<HUDCheckboxHandler>(
      add_checkbox(this, checkbox_container, u"Show paint rect.",
                   u"Equivalent to --ui-show-paint-rects command-line option.",
                   GetCCDebugHandleClickCallback(
                       &cc::LayerTreeDebugState::show_paint_rects)),
      GetCCDebugUpdateStateCallback(
          &cc::LayerTreeDebugState::show_paint_rects)));
  checkbox_handlers_.push_back(std::make_unique<HUDCheckboxHandler>(
      add_checkbox(this, checkbox_container, u"HUD is overlay.",
                   u"Flips HUD overlay mode flag.",
                   base::BindRepeating(
                       [](HUDDisplayView* hud_display, views::Checkbox*) {
                         hud_display->ToggleOverlay();
                       },
                       base::Unretained(hud_display))),
      base::BindRepeating(
          [](HUDDisplayView* hud_display, views::Checkbox* checkbox) {
            checkbox->SetChecked(hud_display->IsOverlay());
          },
          base::Unretained(hud_display))));
  AddChildView(std::make_unique<AnimationSpeedControl>());

  // Ui Dev Tools controls.
  constexpr int kUiDevToolsControlButtonMargin = 6;
  views::View* ui_devtools_controls =
      AddChildView(std::make_unique<views::View>());
  ui_devtools_controls
      ->SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kVertical))
      ->set_cross_axis_alignment(
          views::BoxLayout::CrossAxisAlignment::kStretch);

  // Show cursor position.
  constexpr int kCursorPositionDisplayButtonMargin = 6;
  views::View* cursor_position_display =
      AddChildView(std::make_unique<views::View>());
  cursor_position_display
      ->SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kVertical))
      ->set_cross_axis_alignment(
          views::BoxLayout::CrossAxisAlignment::kStretch);

  // Tracing controls.
  constexpr int kTracingControlButtonMargin = 6;
  views::View* tracing_controls = AddChildView(std::make_unique<views::View>());
  tracing_controls
      ->SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kVertical))
      ->set_cross_axis_alignment(
          views::BoxLayout::CrossAxisAlignment::kStretch);

  ui_devtools_controls->SetBorder(
      views::CreateEmptyBorder(kUiDevToolsControlButtonMargin));
  ui_dev_tools_control_button_ =
      ui_devtools_controls->AddChildView(std::make_unique<HUDActionButton>(
          base::BindRepeating(&HUDSettingsView::OnEnableUiDevToolsButtonPressed,
                              base::Unretained(this)),
          std::u16string()));
  UpdateDevToolsControlButtonLabel();

  cursor_position_display->SetBorder(
      views::CreateEmptyBorder(kCursorPositionDisplayButtonMargin));
  cursor_position_display_button_ =
      cursor_position_display->AddChildView(std::make_unique<HUDActionButton>(
          base::BindRepeating(
              &HUDSettingsView::OnEnableCursorPositionDisplayButtonPressed,
              base::Unretained(this)),
          u"Show cursor position"));

  tracing_controls->SetBorder(
      views::CreateEmptyBorder(kTracingControlButtonMargin));
  tracing_control_button_ =
      tracing_controls->AddChildView(std::make_unique<HUDActionButton>(
          base::BindRepeating(&HUDSettingsView::OnEnableTracingButtonPressed,
                              base::Unretained(this)),
          std::u16string()));

  const int kLabelBorderWidth = 3;
  tracing_status_message_ =
      tracing_controls->AddChildView(std::make_unique<views::Label>(
          std::u16string(), views::style::CONTEXT_LABEL));
  tracing_status_message_->SetAutoColorReadabilityEnabled(false);
  tracing_status_message_->SetEnabledColor(kHUDDefaultColor);
  tracing_status_message_->SetBorder(
      views::CreateEmptyBorder(gfx::Insets::VH(0, kLabelBorderWidth)));
  tracing_status_message_->SetHorizontalAlignment(gfx::ALIGN_LEFT);

  views::Label* pii_label = tracing_controls->AddChildView(std::make_unique<
                                                           views::Label>(
      u"WARNING: Trace files may contain Personally Identifiable Information. "
      u"You should use discretion when sharing your trace files.",
      views::style::CONTEXT_LABEL));
  pii_label->SetMultiLine(true);
  pii_label->SetAutoColorReadabilityEnabled(false);
  pii_label->SetEnabledColor(kHUDDefaultColor);
  pii_label->SetBorder(
      views::CreateEmptyBorder(gfx::Insets::VH(0, kLabelBorderWidth)));
  pii_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);

  UpdateTracingControlButton();

  AshTracingManager::Get().AddObserver(this);
  aura::Env* env = aura::Env::GetInstance();
  env->AddEventObserver(this, env,
                        std::set<ui::EventType>({ui::EventType::kMouseDragged,
                                                 ui::EventType::kMouseMoved}));
}

HUDSettingsView::~HUDSettingsView() {
  AshTracingManager::Get().RemoveObserver(this);
  aura::Env::GetInstance()->RemoveEventObserver(this);
}

void HUDSettingsView::OnTracingStatusChange() {
  UpdateTracingControlButton();
}

void HUDSettingsView::OnEnableUiDevToolsButtonPressed(const ui::Event& event) {
  if (Shell::Get()->shell_delegate()->IsUiDevToolsStarted()) {
    Shell::Get()->shell_delegate()->StopUiDevTools();
  } else {
    Shell::Get()->shell_delegate()->StartUiDevTools();
  }
  UpdateDevToolsControlButtonLabel();
}

void HUDSettingsView::UpdateDevToolsControlButtonLabel() {
  if (!Shell::Get()->shell_delegate()->IsUiDevToolsStarted()) {
    ui_dev_tools_control_button_->SetText(u"Create Ui Dev Tools");
  } else {
    const int port = Shell::Get()->shell_delegate()->GetUiDevToolsPort();
    ui_dev_tools_control_button_->SetText(base::ASCIIToUTF16(
        base::StringPrintf("Ui Dev Tools: ON, port %d", port).c_str()));
  }
}

void HUDSettingsView::OnEnableCursorPositionDisplayButtonPressed(
    const ui::Event& event) {
  showing_cursor_position_ = !showing_cursor_position_;
  if (showing_cursor_position_) {
    cursor_position_display_button_->SetText(base::ASCIIToUTF16(base::StrCat(
        {"Cursor: ",
         aura::Env::GetInstance()->last_mouse_location().ToString()})));
  } else {
    cursor_position_display_button_->SetText(u"Show cursor position");
  }
}

void HUDSettingsView::OnEvent(ui::Event* event) {
  views::View::OnEvent(event);
}

void HUDSettingsView::OnEvent(const ui::Event& event) {
  if (!showing_cursor_position_ || !event.IsMouseEvent()) {
    return;
  }

  cursor_position_display_button_->SetText(base::ASCIIToUTF16(
      base::StrCat({"Cursor: ", event.AsMouseEvent()->location().ToString()})));
}

void HUDSettingsView::ToggleVisibility() {
  const bool is_shown = !GetVisible();
  if (is_shown) {
    for (const auto& handler : checkbox_handlers_) {
      handler->UpdateState();
    }
  }
  SetVisible(is_shown);
}

void HUDSettingsView::OnEnableTracingButtonPressed(const ui::Event& event) {
  ToggleTracing();
}

void HUDSettingsView::ToggleTracingForTesting() {
  ToggleTracing();
}

void HUDSettingsView::ToggleTracing() {
  AshTracingManager& manager = AshTracingManager::Get();
  tracing_control_button_->DisableWithSpinner();
  if (manager.IsTracingStarted()) {
    manager.Stop();
  } else {
    manager.Start();
  }
}

void HUDSettingsView::UpdateTracingControlButton() {
  AshTracingManager& manager = AshTracingManager::Get();
  if (!manager.IsBusy())
    tracing_control_button_->SetEnabled(true);

  tracing_status_message_->SetText(
      base::ASCIIToUTF16(manager.GetStatusMessage()));
  if (manager.IsTracingStarted()) {
    tracing_control_button_->SetText(u"Stop tracing.");
  } else {
    tracing_control_button_->SetText(u"Start tracing.");
  }
}

}  // namespace hud_display

}  // namespace ash