settingentry_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 SETTINGENTRY_GUI_H
#define SETTINGENTRY_GUI_H
 
#include "core/enum_type.hpp"
#include "settings_internal.h"
#include "stringfilter_type.h"

enum class SettingEntryFlag : uint8_t {
  LeftDepressed, 
  RightDepressed, 
  LastField, 
  Filtered, 
};
using SettingEntryFlags = EnumBitSet<SettingEntryFlag, uint8_t>;
 
static constexpr SettingEntryFlags SEF_BUTTONS_MASK = {SettingEntryFlag::LeftDepressed, SettingEntryFlag::RightDepressed}; 

enum RestrictionMode : uint8_t {
  RM_BASIC,                            
  RM_ADVANCED,                         
  RM_ALL,                              
  RM_CHANGED_AGAINST_DEFAULT,          
  RM_CHANGED_AGAINST_NEW,              
  RM_END,                              
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(RestrictionMode)
 

struct SettingFilter {
  StringFilter string;     
  RestrictionMode min_cat; 
  bool type_hides;         
  RestrictionMode mode;    
  SettingType type;        
};

struct BaseSettingEntry {
  SettingEntryFlags flags; 
  uint8_t level; 
 
  BaseSettingEntry() : flags(), level(0) {}
  virtual ~BaseSettingEntry() = default;
 
  virtual void Init(uint8_t level = 0);
  virtual void FoldAll() {}
  virtual void UnFoldAll() {}
  virtual void ResetAll() = 0;

  void SetLastField(bool last_field) { this->flags.Set(SettingEntryFlag::LastField, last_field); }
 
  virtual uint Length() const = 0;
  virtual void GetFoldingState([[maybe_unused]] bool &all_folded, [[maybe_unused]] bool &all_unfolded) const {}
  virtual bool IsVisible(const BaseSettingEntry *item) const;
  virtual BaseSettingEntry *FindEntry(uint row, uint *cur_row);
  virtual uint GetMaxHelpHeight([[maybe_unused]] int maxw) { return 0; }

  bool IsFiltered() const { return this->flags.Test(SettingEntryFlag::Filtered); }
 
  virtual bool UpdateFilterState(SettingFilter &filter, bool force_visible) = 0;
 
  virtual uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const;
 
  static inline Dimension circle_size; 
  static inline int line_height; 
 
protected:
  virtual void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const = 0;
};

struct SettingEntry : BaseSettingEntry {
  const std::string_view name; 
  const IntSettingDesc *setting = nullptr; 
 
  SettingEntry(std::string_view name) : name(name) {}
 
  void Init(uint8_t level = 0) override;
  void ResetAll() override;
  uint Length() const override;
  uint GetMaxHelpHeight(int maxw) override;
  bool UpdateFilterState(SettingFilter &filter, bool force_visible) override;
 
  void SetButtons(SettingEntryFlags new_val);
 
protected:
  void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const override;
 
private:
  bool IsVisibleByRestrictionMode(RestrictionMode mode) const;
};

struct SettingsContainer {
  typedef std::vector<BaseSettingEntry*> EntryVector;
  EntryVector entries; 
 
  template <typename T>
  T *Add(T *item)
  {
    this->entries.push_back(item);
    return item;
  }
 
  void Init(uint8_t level = 0);
  void ResetAll();
  void FoldAll();
  void UnFoldAll();
 
  uint Length() const;
  void GetFoldingState(bool &all_folded, bool &all_unfolded) const;
  bool IsVisible(const BaseSettingEntry *item) const;
  BaseSettingEntry *FindEntry(uint row, uint *cur_row);
  uint GetMaxHelpHeight(int maxw);
 
  bool UpdateFilterState(SettingFilter &filter, bool force_visible);
 
  uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const;
};

struct SettingsPage : BaseSettingEntry, SettingsContainer {
  StringID title;     
  bool folded;        
 
  SettingsPage(StringID title);
 
  void Init(uint8_t level = 0) override;
  void ResetAll() override;
  void FoldAll() override;
  void UnFoldAll() override;
 
  uint Length() const override;
  void GetFoldingState(bool &all_folded, bool &all_unfolded) const override;
  bool IsVisible(const BaseSettingEntry *item) const override;
  BaseSettingEntry *FindEntry(uint row, uint *cur_row) override;
  uint GetMaxHelpHeight(int maxw) override { return SettingsContainer::GetMaxHelpHeight(maxw); }
 
  bool UpdateFilterState(SettingFilter &filter, bool force_visible) override;
 
  uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const override;
 
protected:
  void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const override;
};
 
SettingsContainer &GetSettingsTree();
const void *ResolveObject(const GameSettings *settings_ptr, const IntSettingDesc *sd);
 
#endif /* SETTINGENTRY_GUI_H */