picker_gui.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef PICKER_GUI_H
#define PICKER_GUI_H
 
#include "newgrf_badge.h"
#include "newgrf_badge_gui.h"
#include "querystring_gui.h"
#include "sortlist_type.h"
#include "stringfilter_type.h"
#include "strings_type.h"
#include "timer/timer.h"
#include "timer/timer_game_calendar.h"
#include "timer/timer_window.h"
#include "window_gui.h"
#include "window_type.h"

enum class PickerFilterMode : uint8_t {
  All, 
  Used, 
  Saved, 
};

using PickerFilterModes = EnumBitSet<PickerFilterMode, uint8_t>;
 
struct PickerItem {
  uint32_t grfid;
  uint16_t local_id;
  int class_index;
  int index;
 
  inline auto operator<=>(const PickerItem &other) const
  {
    if (auto cmp = this->grfid <=> other.grfid; cmp != 0) return cmp;
    return this->local_id <=> other.local_id;
  }
};

class PickerCallbacks {
public:
  explicit PickerCallbacks(const std::string &ini_group);
  virtual ~PickerCallbacks();

  virtual void Close([[maybe_unused]] int data) { }

  virtual GrfSpecFeature GetFeature() const = 0;
  virtual bool IsActive() const = 0;
  virtual bool HasClassChoice() const = 0;
 
  /* Class callbacks */
  virtual StringID GetClassTooltip() const = 0;
  virtual int GetClassCount() const = 0;
  virtual int GetSelectedClass() const = 0;
  virtual void SetSelectedClass(int id) const = 0;
  virtual StringID GetClassName(int id) const = 0;
 
  /* Type callbacks */
  virtual StringID GetTypeTooltip() const = 0;
  virtual int GetTypeCount(int cls_id) const = 0;
  virtual int GetSelectedType() const = 0;
  virtual void SetSelectedType(int id) const = 0;
  virtual PickerItem GetPickerItem(int cls_id, int id) const = 0;
  virtual StringID GetTypeName(int cls_id, int id) const = 0;
  virtual std::span<const BadgeID> GetTypeBadges(int cls_id, int id) const = 0;
  virtual bool IsTypeAvailable(int cls_id, int id) const = 0;
  virtual void DrawType(int x, int y, int cls_id, int id) const = 0;
 
  /* Collection Callbacks */
  virtual StringID GetCollectionTooltip() const = 0;

  virtual void FillUsedItems(std::set<PickerItem> &items) = 0;
  virtual std::map<std::string, std::set<PickerItem>> UpdateSavedItems(const std::map<std::string, std::set<PickerItem>> &src) = 0;
  inline std::set<std::string> InitializeInactiveCollections(const std::map<std::string, std::set<PickerItem>> collections)
  {
    std::set<std::string> inactive;
 
    for (const auto &collection : collections) {
      if ((collection.second.size() == 1 && collection.second.contains({})) || collection.first == "") continue;
      for (const PickerItem &item : collection.second) {
        if (item.class_index == -1 || item.index == -1) {
          inactive.emplace(collection.first);
          break;
        }
        if (GetTypeName(item.class_index, item.index) == INVALID_STRING_ID) {
          inactive.emplace(collection.first);
          break;
        }
      }
    }
    return inactive;
  }
 
  Listing class_last_sorting = { false, 0 }; 
  Filtering class_last_filtering = { false, 0 }; 
 
  Listing type_last_sorting = { false, 0 }; 
  Filtering type_last_filtering = { false, 0 }; 
 
  Listing collection_last_sorting = { false, 0 }; 
 
  const std::string ini_group; 
  PickerFilterModes mode{}; 
  bool rename_collection = false;      
  std::string sel_collection;          
  std::string edit_collection;         
  std::set<std::string> rm_collections; 
 
  int preview_height = 0; 
 
  std::set<PickerItem> used; 
  std::map<std::string, std::set<PickerItem>> saved; 
};

template <typename T>
class PickerCallbacksNewGRFClass : public PickerCallbacks {
public:
  explicit PickerCallbacksNewGRFClass(const std::string &ini_group) : PickerCallbacks(ini_group) {}

  inline typename T::index_type GetClassIndex(int cls_id) const { return static_cast<typename T::index_type>(cls_id); }

  inline const T *GetClass(int cls_id) const { return T::Get(this->GetClassIndex(cls_id)); }

  inline const typename T::spec_type *GetSpec(int cls_id, int id) const { return this->GetClass(cls_id)->GetSpec(id); }
 
  bool HasClassChoice() const override { return T::GetUIClassCount() > 1; }
 
  int GetClassCount() const override { return T::GetClassCount(); }
  int GetTypeCount(int cls_id) const override { return this->GetClass(cls_id)->GetSpecCount(); }

  PickerItem GetPickerItem(const typename T::spec_type *spec, int cls_id = -1, int id = -1) const
  {
    if (spec == nullptr) return {0, 0, cls_id, id};
    return {spec->grf_prop.grfid, spec->grf_prop.local_id, spec->class_index.base(), spec->index};
  }

  PickerItem GetPickerItem(int cls_id, int id) const override
  {
    return GetPickerItem(GetClass(cls_id)->GetSpec(id), cls_id, id);
  }
 
  std::map<std::string, std::set<PickerItem>> UpdateSavedItems(const std::map<std::string, std::set<PickerItem>> &src) override
  {
    if (src.empty()) return {};
 
    std::map<std::string, std::set<PickerItem>> dst;
    for (auto it = src.begin(); it != src.end(); it++) {
      if (it->second.empty() || (it->second.size() == 1 && it->second.contains({}))) {
        dst[it->first];
        continue;
      }
 
      for (const auto &item : it->second) {
        const auto *spec = T::GetByGrf(item.grfid, item.local_id);
        if (spec == nullptr) {
          dst[it->first].emplace(item.grfid, item.local_id, -1, -1);
        } else {
          dst[it->first].emplace(GetPickerItem(spec));
        }
      }
    }
    return dst;
  }
};
 
struct PickerFilterData : StringFilter {
  const PickerCallbacks *callbacks; 
  std::optional<BadgeTextFilter> btf;
  std::optional<BadgeDropdownFilter> bdf;
};
 
using PickerClassList = GUIList<int, std::nullptr_t, PickerFilterData &>; 
using PickerTypeList = GUIList<PickerItem, std::nullptr_t, PickerFilterData &>; 
using PickerCollectionList = GUIList<std::string, std::nullptr_t, PickerFilterData &>; 
 
class PickerWindow : public PickerWindowBase {
public:
  enum class PickerInvalidation : uint8_t {
    Class, 
    Type, 
    Collection, 
    Position, 
    Validate, 
    Filter, 
  };

  using PickerInvalidations = EnumBitSet<PickerInvalidation, uint8_t>;
 
  static constexpr PickerInvalidations PICKER_INVALIDATION_ALL{PickerInvalidation::Class, PickerInvalidation::Type, PickerInvalidation::Position, PickerInvalidation::Validate};
 
  static constexpr int PREVIEW_WIDTH = 64; 
  static constexpr int PREVIEW_HEIGHT = 48; 
  static constexpr int PREVIEW_LEFT = 31; 
  static constexpr int PREVIEW_BOTTOM = 31; 
 
  static constexpr int STEP_PREVIEW_HEIGHT = 16; 
  static constexpr int MAX_PREVIEW_HEIGHT = PREVIEW_HEIGHT * 3; 
 
  static constexpr uint EDITBOX_MAX_SIZE = 16; 
 
  bool has_class_picker = false; 
  bool has_type_picker = false; 
  bool has_collection_picker = false; 
  int preview_height = 0; 
  std::set<std::string> inactive; 
 
  PickerWindow(WindowDesc &desc, Window *parent, int window_number, PickerCallbacks &callbacks);
  void OnInit() override;
  void Close(int data = 0) override;
  void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override;
  std::string GetWidgetString(WidgetID widget, StringID stringid) const override;
  DropDownList BuildCollectionDropDownList();
  void DrawWidget(const Rect &r, WidgetID widget) const override;
  void OnDropdownSelect(WidgetID widget, int index, int click_result) override;
  void OnResize() override;
  void static DeletePickerCollectionCallback(Window *win, bool confirmed);
  void OnClick(Point pt, WidgetID widget, int click_count) override;
  void OnQueryTextFinished(std::optional<std::string> str) override;
  void OnInvalidateData(int data = 0, bool gui_scope = true) override;
  EventState OnHotkey(int hotkey) override;
  void OnEditboxChanged(WidgetID wid) override;

  enum PickerClassWindowHotkeys : int32_t {
    PCWHK_FOCUS_FILTER_BOX, 
  };
 
  void InvalidateData(PickerInvalidations data) { this->Window::InvalidateData(data.base()); }
 
protected:
  void ConstructWindow();
 
  PickerCallbacks &callbacks;
 
private:
  PickerClassList classes; 
  PickerFilterData class_string_filter;
  QueryString class_editbox; 
 
  void BuildPickerClassList();
  void EnsureSelectedClassIsValid();
  void EnsureSelectedClassIsVisible();
 
  PickerTypeList types; 
  PickerFilterData type_string_filter;
  QueryString type_editbox; 
 
  void RefreshUsedTypeList();
  void BuildPickerTypeList();
  void EnsureSelectedTypeIsValid();
  void EnsureSelectedTypeIsVisible();
 
  PickerCollectionList collections; 
 
  void BuildPickerCollectionList();
 
  GUIBadgeClasses badge_classes;
  std::pair<WidgetID, WidgetID> badge_filters{};
  BadgeFilterChoices badge_filter_choices{};
 
  const IntervalTimer<TimerGameCalendar> yearly_interval = {{TimerGameCalendar::Trigger::Year, TimerGameCalendar::Priority::None}, [this](auto) {
    this->SetDirty();
  }};
 
  const IntervalTimer<TimerWindow> refresh_interval = {std::chrono::seconds(3), [this](auto) {
    RefreshUsedTypeList();
  }};
};
 
class NWidgetBase;
std::unique_ptr<NWidgetBase> MakePickerClassWidgets();
std::unique_ptr<NWidgetBase> MakePickerTypeWidgets();
 
#endif /* PICKER_GUI_H */