window_type.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 WINDOW_TYPE_H
#define WINDOW_TYPE_H
 
#include "core/convertible_through_base.hpp"
#include "core/enum_type.hpp"

using WidgetID = int;

static constexpr WidgetID INVALID_WIDGET = -1;

enum class GameOptionsWindowNumber : uint8_t {
  AI, 
  GS, 
  About, 
  NewGRFState, 
  GameOptions, 
};

enum class QueryStringWindowNumber : uint8_t {
  Default, 
  Sign, 
};

enum class ConfirmPopupQueryWindowNumber : uint8_t {
  Default, 
  Bootstrap, 
};

enum class NetworkWindowNumber : uint8_t {
  Game, 
  ContentList, 
  StartServer, 
};

enum class NetworkStatusWindowNumber : uint8_t {
  Join, 
  ContentDownload, 
};

enum class WindowClass : uint16_t {
  None, 

  MainWindow = WindowClass::None,

  MainToolbar,

  Statusbar,

  BuildToolbar,

  ScenarioBuildToolbar,

  BuildTrees,

  TransparencyToolbar,

  BuildSignal,

  SmallMap,

  ErrorMessage,

  ToolTips,

  QueryString,

  ConfirmPopupQuery,

  GoalQuestion,
 

  SaveLoad,

  LandInfo,

  DropdownMenu,

  OnScreenKeyboard,

  SetDate,
 

  ScriptSettings,

  NewGRFParameters,

  Textfile,
 

  TownAuthority,

  VehicleDetails,

  VehicleRefit,

  VehicleOrders,

  ReplaceVehicle,

  VehicleTimetable,

  CompanyLivery,

  CompanyManagerFace,

  JoinStation,

  News,

  TownDirectory,

  SubsidyList,

  IndustryDirectory,

  MessageHistory,

  SignList,

  ScriptList,

  GoalList,

  StoryBook,

  StationList,

  TrainList,

  RoadVehicleList,

  ShipList,

  AircraftList,
 

  TownView,

  VehicleView,

  StationView,

  VehicleDepot,

  WaypointView,

  IndustryView,

  Company,
 

  BuildObject,

  BuildHouse,

  BuildVehicle,

  BuildBridge,

  BuildStation,

  BuildBusStation,

  BuildTruckStation,

  BuildDepot,

  BuildWaypoint,

  FoundTown,

  BuildIndustry,
 

  SelectGame,

  ScenarioGenerateLandscape,

  GenerateLandscape,

  ModalProgress,
 

  Network,

  NetworkClientList,

  NetworkStatus,

  NetworkAskRelay,

  NetworkAskSurvey,

  NetworkChat,

  IndustryCargoes,

  GraphLegend,

  Finances,

  IncomeGraph,

  OperatingProfitGraph,

  DeliveredCargoGraph,

  PerformanceGraph,

  CompanyValueGraph,

  CompanyLeague,

  CargoPaymentRatesGraph,

  PerformanceDetail,

  IndustryProductionGraph,

  TownCargoGraph,

  CompanyInfrastructure,
 

  BuyCompany,

  EnginePreview,
 

  Music,

  MusicTrackSelection,

  GameOptions,

  CustomCurrenty,

  Cheat,

  ExtraViewport,
 

  Console,

  Bootstrap,

  Highscore,

  Endscreen,
 

  ScriptDebug,

  NewGRFInspect,

  SpriteAligner,

  LinkGraphLegend,

  SavePreset,

  FramerateDisplay,

  FrametimeGraph,

  Screenshot,

  Help,
 
  Invalid = 0xFFFF, 
};

enum GameOptionsInvalidationData : uint8_t {
  GOID_DEFAULT = 0,
  GOID_NEWGRF_RESCANNED,       
  GOID_NEWGRF_CURRENT_LOADED,  
  GOID_NEWGRF_LIST_EDITED,     
  GOID_NEWGRF_CHANGES_MADE,    
};
 
struct Window;

struct WindowNumber {
private:
  int32_t value = 0; 
public:
  WindowNumber() = default;

  WindowNumber(int32_t value) : value(value) {}
  WindowNumber(ConvertibleThroughBase auto value) : value(value.base()) {}
  template <typename T> requires is_scoped_enum_v<T>
  WindowNumber(T value) : value(to_underlying(value)) {}

  operator int32_t() const { return value; }

  template <typename T> requires (std::is_enum_v<T> || std::is_class_v<T>)
  operator T() const { return static_cast<T>(value); };

  constexpr bool operator==(const std::integral auto &rhs) const { return this->value == static_cast<int32_t>(rhs); }
  constexpr bool operator==(const ConvertibleThroughBase auto &rhs) const { return this->value == static_cast<int32_t>(rhs.base()); }
  template <typename T> requires is_scoped_enum_v<T>
  constexpr bool operator==(const T &rhs) const { return this->value == static_cast<int32_t>(to_underlying(rhs)); }
};

enum EventState : uint8_t {
  ES_HANDLED,     
  ES_NOT_HANDLED, 
};
 
#endif /* WINDOW_TYPE_H */