multi_slider.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPLv3-or-later
// SPDX-FileCopyrightText: Louis Moureaux <m_louis30@yahoo.com>
 
#include "widgets/multi_slider.h"
 
#include "log.h"
 
#include <QFocusEvent>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QPainter>
 
#include <algorithm>
#include <cmath>
 
namespace {
namespace colors {
const QColor focus_indicator = Qt::gray;
const QColor handle_background = Qt::lightGray;
const QColor handle_indicator = Qt::gray;
const QColor handle_hover = Qt::darkGray;
const QColor handle_dragged = handle_hover;
} // namespace colors
namespace metrics {
const double focus_bar_gap = 3;
const double focus_bar_height = 1;
const double handle_bar_gap = 2;
const double handle_bar_width = 4;
const double handle_gap = 1;
const double handle_radius = 8;
const double handle_indicator_radius = 4;
const double handle_active_indicator_radius = handle_indicator_radius + 1;
const double extra_height = std::max(focus_bar_gap + focus_bar_height,
                                     handle_gap + handle_radius * 2);
} // namespace metrics
} // anonymous namespace
 
namespace freeciv {
 
multi_slider::multi_slider(QWidget *parent) : QWidget(parent)
{
  setFocusPolicy(Qt::StrongFocus);
  setMouseTracking(true);
  setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed,
                            QSizePolicy::Slider));
}
 
std::size_t multi_slider::add_category(const QPixmap &icon)
{
  m_categories.push_back({icon});
  m_values.push_back(0);
 
  if (icon.size() != m_categories.front().icon.size()) {
    qWarning() << "Inconsistent icon sizes:" << icon.size() << "and"
               << m_categories.front().icon.size();
  }
 
  return m_categories.size() - 1;
}
 
void multi_slider::set_range(std::size_t category, int min, int max)
{
  fc_assert_ret(category < m_categories.size());
  fc_assert_ret(min >= 0);
  fc_assert_ret(min <= max);
 
  m_categories[category].minimum = min;
  m_categories[category].maximum = max;
 
  update_cached_geometry();
  updateGeometry();
}
 
void multi_slider::set_values(const std::vector<int> &values)
{
  fc_assert_ret(values.size() == m_categories.size());
 
  m_values = values;
  update_cached_geometry();
  updateGeometry();
 
  emit values_changed(values);
}
 
std::size_t multi_slider::total() const
{
  return std::accumulate(m_values.begin(), m_values.end(), 0);
}
 
QSize multi_slider::sizeHint() const
{
  if (m_categories.empty()) {
    return QSize();
  }
 
  auto icon_size = m_categories.front().icon.size();
  return QSize(total() * icon_size.width() + 2 * metrics::handle_radius,
               icon_size.height() + metrics::extra_height);
}
 
QSize multi_slider::minimumSizeHint() const
{
  if (m_categories.empty()) {
    return QSize();
  }
 
  auto icon_size = m_categories.front().icon.size();
  return QSize(total() * 5 + 2 * metrics::handle_radius,
               icon_size.height() + metrics::extra_height);
}
 
bool multi_slider::event(QEvent *event)
{
  // Allow using Tab and Backtab to move between visible categories
  // We need to trap those early to override the default behaviour
  if (event->type() == QEvent::KeyPress) {
    auto kevt = dynamic_cast<QKeyEvent *>(event);
    // Check if focus can be moved to the next visible category
    if (kevt->key() == Qt::Key_Tab && move_focus(true)) {
      event->accept();
      return true;
    } else if (kevt->key() == Qt::Key_Backtab && move_focus(false)) {
      event->accept();
      return true;
    }
  }
  return QWidget::event(event);
}
 
void multi_slider::focusInEvent(QFocusEvent *event)
{
  if (!m_categories.empty()) {
    if (event->reason() == Qt::BacktabFocusReason) {
      m_focused_category = m_categories.size() - 1;
    } else if (event->reason() == Qt::TabFocusReason) {
      m_focused_category = 0;
    } else {
      // Keep old category alive if still present, making sure it's >= 0
      m_focused_category = std::max(m_focused_category, 0);
    }
  }
  QWidget::focusInEvent(event);
}
 
void multi_slider::keyPressEvent(QKeyEvent *event)
{
  if (m_categories.empty()) {
    return;
  }
 
  if (event->modifiers() == Qt::NoModifier) {
    switch (event->key()) {
    case Qt::Key_Up:
      if (grab_item(m_focused_category, 1)) {
        emit values_changed(values());
        event->accept();
        return;
      }
      break;
    case Qt::Key_Down:
      if (grab_item(m_focused_category, -1)) {
        emit values_changed(values());
        event->accept();
        return;
      }
      break;
    case Qt::Key_Left:
      if (move_focus(false)) {
        event->accept();
        return;
      }
      break;
    case Qt::Key_Right:
      if (move_focus(true)) {
        event->accept();
        return;
      }
      break;
    default:
      break;
    }
  }
  QWidget::keyPressEvent(event);
}
 
void multi_slider::leaveEvent(QEvent *event)
{
  m_closest_handle = -1;
  update();
  QWidget::leaveEvent(event);
}
 
void multi_slider::mouseDoubleClickEvent(QMouseEvent *event)
{
  if (event->buttons() == Qt::LeftButton
      && event->modifiers() == Qt::NoModifier) {
    // Double click
    move_handle(handle_near(event->pos()), event->pos());
  }
  QWidget::mouseMoveEvent(event);
}
 
void multi_slider::mouseMoveEvent(QMouseEvent *event)
{
  if (m_dragged_handle >= 0 && event->buttons() == Qt::LeftButton
      && event->modifiers() == Qt::NoModifier) {
    // Drag
    move_handle(m_dragged_handle, event->pos());
  }
 
  // Update the closest handle
  auto new_handle = handle_near(event->pos());
  if (new_handle != m_closest_handle) {
    m_closest_handle = new_handle;
    update();
  }
 
  QWidget::mouseMoveEvent(event);
}
 
void multi_slider::mousePressEvent(QMouseEvent *event)
{
  if (event->buttons() == Qt::LeftButton
      && event->modifiers() == Qt::NoModifier) {
    m_dragged_handle = handle_near(event->pos());
    update();
  }
  QWidget::mousePressEvent(event);
}
 
void multi_slider::mouseReleaseEvent(QMouseEvent *event)
{
  m_dragged_handle = -1;
  update();
  QWidget::mouseReleaseEvent(event);
}
 
void multi_slider::paintEvent(QPaintEvent *event)
{
  if (m_categories.empty() || total() <= 0) {
    return;
  }
 
  // Assume all icons have the same width
  const auto iheight = m_categories.front().icon.height();
 
  // Center everything
  QPainter p(this);
  p.translate(m_geom.left_margin, 0);
 
  // Draw icons
  p.setPen(Qt::NoPen);
  p.setRenderHint(QPainter::Antialiasing);
  double xmin = 0, xmax = 0;
  for (std::size_t i = 0; i < m_values.size(); ++i) {
    xmax += m_values[i] * m_geom.item_width;
    p.drawTiledPixmap(QRectF(xmin, 0, xmax - xmin, iheight),
                      m_categories[i].icon, QPointF(xmin, 0));
 
    // Focus indicator
    if (hasFocus() && i == m_focused_category) {
      p.setBrush(colors::focus_indicator);
      p.drawRect(QRectF(xmin, iheight + metrics::focus_bar_gap, xmax - xmin,
                        metrics::focus_bar_height));
    }
    xmin = xmax;
  }
 
  // Draw handles (skipping the dummy last one)
  auto handles = visible_handles();
  for (auto h : handles) {
    auto x = m_geom.item_width * h.location;
 
    // Background
    p.setBrush(colors::handle_background);
    p.drawRect(QRectF(x - metrics::handle_bar_width / 2,
                      metrics::handle_bar_gap, metrics::handle_bar_width,
                      iheight + metrics::handle_gap));
    p.drawEllipse(QPointF(x, iheight + metrics::handle_gap
                                 + metrics::handle_radius - 1),
                  metrics::handle_radius, metrics::handle_radius);
 
    // Active handle indicator
    bool is_closest = h.index == m_closest_handle;
    bool is_dragged = h.index == m_dragged_handle;
    double inner_radius = is_dragged
                              ? metrics::handle_active_indicator_radius
                              : metrics::handle_indicator_radius;
    p.setBrush(is_dragged   ? colors::handle_dragged
               : is_closest ? colors::handle_hover
                            : colors::handle_indicator);
    p.drawEllipse(QPointF(x, iheight + metrics::handle_gap
                                 + metrics::handle_radius - 1),
                  inner_radius, inner_radius);
  }
}
 
void multi_slider::resizeEvent(QResizeEvent *event)
{
  update_cached_geometry();
}
 
void multi_slider::exchange(std::size_t giver, std::size_t taker, int amount)
{
  m_values[giver] -= amount;
  m_values[taker] += amount;
  focus_some_category();
  update();
}
 
bool multi_slider::grab_item(std::size_t taker, int amount, bool from_left,
                             bool from_right)
{
  fc_assert_ret_val(taker < m_categories.size(), false);
 
  const auto &category = m_categories[taker];
  if (!category.allowed(m_values[taker] + amount)) {
    return false;
  }
 
  // Find category to exchange with. First look to the right...
  if (from_right) {
    for (int i = taker + 1; i < m_categories.size(); ++i) {
      if (m_categories[i].allowed(m_values[i] - amount)) {
        exchange(i, taker, amount);
        return true;
      }
    }
  }
 
  // No luck to the right. Try on the other side
  if (from_left) {
    for (int i = taker - 1; i >= 0; --i) {
      if (m_categories[i].allowed(m_values[i] - amount)) {
        exchange(i, taker, amount);
        return true;
      }
    }
  }
 
  // No luck
  return false;
}
 
void multi_slider::focus_some_category()
{
  if (m_categories.empty() || m_values[m_focused_category] > 0) {
    // Already good
    return;
  }
 
  // One of them will always succeed
  if (!move_focus(true)) {
    move_focus(false);
  }
}
 
bool multi_slider::move_focus(bool forward)
{
  int step = forward ? 1 : -1;
  // Check if focus can be moved to the next visible category
  for (int i = m_focused_category + step; i >= 0 && i < m_categories.size();
       i += step) {
    if (m_values[i] > 0) {
      m_focused_category = i;
      update();
      return true;
    }
  }
  return false;
}
 
int multi_slider::handle_near(const QPoint &where)
{
  const auto handles = visible_handles();
  const auto handle_x = [this](const handle &h) {
    return m_geom.left_margin + h.location * m_geom.item_width;
  };
  const auto best_handle =
      std::min_element(handles.begin(), handles.end(),
                       [where, handle_x](const handle &a, const handle &b) {
                         return std::abs(where.x() - handle_x(a))
                                < std::abs(where.x() - handle_x(b));
                       });
  return best_handle->index;
}
 
bool multi_slider::move_handle(int handle, const QPoint &where)
{
  // Target location of the handle
  int target =
      std::round((where.x() - m_geom.left_margin) / m_geom.item_width);
 
  // Current location of the handle
  int current =
      std::accumulate(m_values.begin(), m_values.begin() + handle + 1, 0);
 
  // Direction in which we move the handle
  bool moving_left = current > target;
 
  // Category gaining items
  int taker = moving_left ? handle + 1 : handle;
 
  // Try to transfer items to the taker
  for (int i = 0; i < std::abs(current - target); ++i) {
    // grab_item works in units of 1 item
    if (!grab_item(taker, 1, moving_left, !moving_left)) {
      // Nothing more we can do to move the handle in this direction
      return false;
    }
  }
  emit values_changed(values());
  return true;
}
 
void multi_slider::update_cached_geometry()
{
  const auto icon_size = m_categories.front().icon.size();
  const auto items = total();
 
  // Safety - we shouldn't be used this way...
  if (items <= 0) {
    m_geom = {1, 0, 1};
    return;
  }
 
  m_geom.icons_width = items * icon_size.width();
  int total_width = m_geom.icons_width + 2 * metrics::handle_radius;
 
  // Adjust if we don't have enough space
  if (total_width > width()) {
    int available_width = width() - 2 * metrics::handle_radius;
    int icon_count =
        available_width / icon_size.width(); // Note we round down
    m_geom.icons_width = icon_count * icon_size.width();
  }
 
  m_geom.left_margin = (width() - m_geom.icons_width) / 2;
 
  // If we have enough space, this is equal to the width of one icon
  m_geom.item_width = static_cast<double>(m_geom.icons_width) / items;
}
 
std::vector<multi_slider::handle> multi_slider::visible_handles() const
{
  std::vector<handle> handles;
  bool first = true;
  int location = 0;
  for (int i = 0; i < m_values.size() - 1; ++i) {
    location += m_values[i];
    if (first || m_values[i] > 0) {
      handles.push_back({i, location});
    }
    first = false;
  }
  return handles;
}
 
} // namespace freeciv