mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
OpenRCT2/src/openrct2-ui/windows/TileInspector.cpp

2371 lines
119 KiB
C++
Raw Normal View History

Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
/*****************************************************************************
Replace 2022 with 2023 in copyright headers Replace all instances of the year 2022 with 2023 in all copyright headers
2023-01-01 11:58:01 +01:00
* Copyright (c) 2014-2023 OpenRCT2 developers
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
*
Ready copyright notice for clang-format Clang-format sees the text behind `#pragma region` as code and formats it. Instead of stating the copyright and date there, it's now in the comment block right below it. The text "Copyright" is left in the `#pragma region` line, as clang-format sees it as a single identifier. I took the opportunity to normalize the dates, and add the copyright notice to the source files where it was missing them (except for third-party and the generated resources.h file).
2018-06-15 14:07:34 +02:00
* For a complete list of all authors, please refer to contributors.md
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
*
Ready copyright notice for clang-format Clang-format sees the text behind `#pragma region` as code and formats it. Instead of stating the copyright and date there, it's now in the comment block right below it. The text "Copyright" is left in the `#pragma region` line, as clang-format sees it as a single identifier. I took the opportunity to normalize the dates, and add the copyright notice to the source files where it was missing them (except for third-party and the generated resources.h file).
2018-06-15 14:07:34 +02:00
* OpenRCT2 is licensed under the GNU General Public License version 3.
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
*****************************************************************************/
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Remove Math::Clamp in favour of std::clamp
2018-08-12 13:50:40 +02:00
#include <algorithm>
Use std::size instead of Util::CountOf
2018-11-21 23:16:04 +01:00
#include <iterator>
clang-format UI windows
2018-06-22 23:21:44 +02:00
#include <openrct2-ui/interface/Dropdown.h>
#include <openrct2-ui/interface/Widget.h>
Move tile inspector to UI module
2017-11-23 00:42:12 +01:00
#include <openrct2-ui/windows/Window.h>
clang-format UI windows
2018-06-22 23:21:44 +02:00
#include <openrct2/Game.h>
#include <openrct2/Input.h>
Split actions hpp files into separate h and cpp files (#13548) * Split up SmallSceneryPlace/Remove Added undo function for Remove Scenery * Refactor: Balloon and Banner actions hpp=>h/cpp * Refactor: rename all action *.hpp files to *.cpp This is preparation for separation in later commits. Note that without the complete set of commits in this branch, the code will not build. * Refactor Clear, Climate, Custom, and Footpath actions hpp=>h/cpp * VSCode: add src subdirectories to includePath * Refactor Guest actions hpp=>h/cpp * Refactor Land actions hpp=>h/cpp * Refactor LargeScenery actions hpp=>h/cpp * Refactor Load, Maze, Network actions hpp=>h/cpp * Refactor Park actions hpp=>h/cpp * Refactor/style: move private function declarations in actions *.h Previous action .h files included private function declarations with private member variables, before public function declarations. This commit re-orders the header files to the following order: - public member variables - private member variables - public functions - private functions * Refactor Pause action hpp=>h/cpp * Refactor Peep, Place, Player actions hpp=>h/cpp * Refactor Ride actions hpp=>h/cpp * Refactor Scenario, Set*, Sign* actions hpp=>h/cpp * Refactor SmallScenerySetColourAction hpp=>h/cpp * Refactor Staff actions hpp=>h/cpp * Refactor Surface, Tile, Track* actions hpp=>h/cpp * Refactor Wall and Water actions hpp=>h/cpp * Fix various includes and other compile errors Update includes for tests. Move static function declarations to .h files Add explicit includes to various files that were previously implicit (the required header was a nested include in an action hpp file, and the action .h file does not include that header) Move RideSetStatus string enum to the cpp file to avoid unused imports * Xcode: modify project file for actions refactor * Cleanup whitespace and end-of-file newlines Co-authored-by: duncanspumpkin <duncans_pumpkin@hotmail.co.uk>
2020-12-10 07:39:10 +01:00
#include <openrct2/actions/TileModifyAction.h>
Refactor and clean up for CI's.
2019-05-18 10:23:33 +02:00
#include <openrct2/common.h>
Move tile inspector to UI module
2017-11-23 00:42:12 +01:00
#include <openrct2/core/Guard.hpp>
Forward declare Formatter
2021-12-12 00:06:06 +01:00
#include <openrct2/localisation/Formatter.h>
Compile localisation folder as C++
2018-01-06 18:32:25 +01:00
#include <openrct2/localisation/Localisation.h>
#include <openrct2/localisation/StringIds.h>
Split off scenery entries (#19133) BannerSceneryEntry, WallSceneryEntry footpathItemEntry
2023-01-25 20:56:29 +01:00
#include <openrct2/object/FootpathItemEntry.h>
Add new .park save format Co-authored-by: Gymnasiast <Gymnasiast@users.noreply.github.com> Co-authored-by: duncanspumpkin <duncanspumpkin@users.noreply.github.com> Co-authored-by: ZehMatt <Zehmatt@users.noreply.github.com> Co-authored-by: Broxzier <Broxzier@users.noreply.github.com>
2021-10-27 14:21:14 +02:00
#include <openrct2/object/FootpathObject.h>
#include <openrct2/object/FootpathRailingsObject.h>
#include <openrct2/object/FootpathSurfaceObject.h>
Split off LargeSceneryEntry (#19277)
2023-01-26 19:44:42 +01:00
#include <openrct2/object/LargeSceneryEntry.h>
ObjectEntry Cleanup. FootpathItem, SceneryGroup, Water, LargeScenery (#19385) * Move footpathitem entry into new getter * Move scenery group entry into new getter * Move water entry into new getter * Move large scenery entry into new getter * Remove unused header includes * Fix compile issue * Include missing header from vcxproj
2023-02-15 22:35:16 +01:00
#include <openrct2/object/ObjectEntryManager.h>
Split off SmallSceneryEntry into dedicated file (#19115) * Split off small scenery entry to new file * Move flags to new file
2023-01-25 20:25:33 +01:00
#include <openrct2/object/SmallSceneryEntry.h>
Tile Inspector: remove hardcoded surface/edge style names
2020-07-28 22:37:52 +02:00
#include <openrct2/object/TerrainEdgeObject.h>
#include <openrct2/object/TerrainSurfaceObject.h>
Split off scenery entries (#19133) BannerSceneryEntry, WallSceneryEntry footpathItemEntry
2023-01-25 20:56:29 +01:00
#include <openrct2/object/WallSceneryEntry.h>
Change casing of header files
2018-01-10 00:00:09 +01:00
#include <openrct2/ride/RideData.h>
Move tile inspector to UI module
2017-11-23 00:42:12 +01:00
#include <openrct2/ride/Track.h>
#include <openrct2/sprites.h>
Remove loadsasnakes (#19192) * Rename snake_case methods in scenario folder * Rename snake_case methods in title folder * Rename snake_case methods in object folder * Rename snake_case methods in platform folder * Rename snake_case methods in windows folder * Rename tile_inspector.h to TileInspectorGlobals.h * Rename snake_case methods in ui/windows folder
2023-01-17 20:46:55 +01:00
#include <openrct2/windows/TileInspectorGlobals.h>
clang-format UI windows
2018-06-22 23:21:44 +02:00
#include <openrct2/world/Banner.h>
Compile files in world folder as C++
2018-01-11 10:59:26 +01:00
#include <openrct2/world/Footpath.h>
clang-format UI windows
2018-06-22 23:21:44 +02:00
#include <openrct2/world/Park.h>
Compile files in world folder as C++
2018-01-11 10:59:26 +01:00
#include <openrct2/world/Scenery.h>
Seperate surface tile element
2018-05-01 16:33:16 +02:00
#include <openrct2/world/Surface.h>
Feature #15164: Highlight selected Tile Inspector element
2021-08-01 22:13:12 +02:00
#include <openrct2/world/TileInspector.h>
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Rename rct_string_id to StringId
2022-07-31 14:22:58 +02:00
static constexpr const StringId EntranceTypeStringIds[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
STR_TILE_INSPECTOR_ENTRANCE_TYPE_RIDE_ENTRANCE,
STR_TILE_INSPECTOR_ENTRANCE_TYPE_RIDE_EXIT,
STR_TILE_INSPECTOR_ENTRANCE_TYPE_PARK_ENTRANC,
Clean up string and sprite ID's (#3977)
2016-07-14 14:07:49 +02:00
};
Rename rct_string_id to StringId
2022-07-31 14:22:58 +02:00
static constexpr const StringId ParkEntrancePartStringIds[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
STR_TILE_INSPECTOR_ENTRANCE_MIDDLE,
STR_TILE_INSPECTOR_ENTRANCE_LEFT,
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
STR_TILE_INSPECTOR_ENTRANCE_RIGHT,
Entrance details @todo: For park entrances, the left and right tile do not show the entrance ID. Will solve this later.
2016-09-18 23:59:23 +02:00
};
Rename rct_string_id to StringId
2022-07-31 14:22:58 +02:00
static constexpr const StringId WallSlopeStringIds[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
STR_TILE_INSPECTOR_WALL_FLAT,
STR_TILE_INSPECTOR_WALL_SLOPED_LEFT,
Fix #9029: Set animation frame on doors using the tile inspector (#11206)
2020-04-18 12:43:46 +02:00
STR_TILE_INSPECTOR_WALL_SLOPED_RIGHT,
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
STR_TILE_INSPECTOR_WALL_ANIMATION_FRAME,
Add dropdown for changing fence slopes
2016-10-01 22:57:09 +02:00
};
Clang tidy Part 3: Ui Project Enum Names (#15986) * Enum constant case * Apply enum names clang tidy * Rename scoped enum missed by clang-tidy
2021-11-26 15:25:34 +01:00
enum WindowTileInspectorWidgetIdx
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
{
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_BACKGROUND,
WIDX_TITLE,
WIDX_CLOSE,
WIDX_LIST,
WIDX_SPINNER_X,
WIDX_SPINNER_X_INCREASE,
WIDX_SPINNER_X_DECREASE,
WIDX_SPINNER_Y,
WIDX_SPINNER_Y_INCREASE,
WIDX_SPINNER_Y_DECREASE,
WIDX_BUTTON_REMOVE,
WIDX_BUTTON_MOVE_UP,
Tile Inspector: Use correct names for up/down buttons This little mistake has been around for years and is most likely caused by reordering the buttons. They used to be side-to-side, but their names were never changed, and since the order of tile elements is reversed I never noticed it was wrong.
2019-07-21 11:34:50 +02:00
WIDX_BUTTON_MOVE_DOWN,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_BUTTON_ROTATE,
WIDX_BUTTON_SORT,
WIDX_BUTTON_PASTE,
Switch tile inspector copy paste button placement (#11358)
2020-04-19 22:41:45 +02:00
WIDX_BUTTON_COPY,
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
WIDX_COLUMN_INVISIBLE,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_COLUMN_TYPE,
WIDX_COLUMN_BASEHEIGHT,
WIDX_COLUMN_CLEARANCEHEIGHT,
Close #12825: Show object rotation in Tile Inspector
2021-11-16 23:16:59 +01:00
WIDX_COLUMN_DIRECTION,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_COLUMN_GHOSTFLAG,
WIDX_COLUMN_LASTFLAG,
WIDX_GROUPBOX_DETAILS,
WIDX_GROUPBOX_PROPERTIES,
PAGE_WIDGETS,
// Surface
WIDX_SURFACE_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_SURFACE_SPINNER_HEIGHT_INCREASE,
WIDX_SURFACE_SPINNER_HEIGHT_DECREASE,
WIDX_SURFACE_BUTTON_REMOVE_FENCES,
WIDX_SURFACE_BUTTON_RESTORE_FENCES,
WIDX_SURFACE_CHECK_CORNER_N,
WIDX_SURFACE_CHECK_CORNER_E,
WIDX_SURFACE_CHECK_CORNER_S,
WIDX_SURFACE_CHECK_CORNER_W,
WIDX_SURFACE_CHECK_DIAGONAL,
// Path
WIDX_PATH_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_PATH_SPINNER_HEIGHT_INCREASE,
WIDX_PATH_SPINNER_HEIGHT_DECREASE,
Feature #8791: Improved tile element flag manipulation in Tile Inspector
2019-05-14 21:38:31 +02:00
WIDX_PATH_CHECK_BROKEN,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_PATH_CHECK_SLOPED,
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
WIDX_PATH_CHECK_JUNCTION_RAILINGS,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
WIDX_PATH_CHECK_EDGE_NE, // Note: This is NOT named after the world orientation, but after the way
WIDX_PATH_CHECK_EDGE_E, // it looks in the window (top corner is north). Their order is important,
WIDX_PATH_CHECK_EDGE_SE, // as this is the same order paths use for their corners / edges.
WIDX_PATH_CHECK_EDGE_S, // N
WIDX_PATH_CHECK_EDGE_SW, // NW-------NE
WIDX_PATH_CHECK_EDGE_W, // W ------------- E
WIDX_PATH_CHECK_EDGE_NW, // SW-------SE
WIDX_PATH_CHECK_EDGE_N, // S
// Track
WIDX_TRACK_CHECK_APPLY_TO_ALL = PAGE_WIDGETS,
WIDX_TRACK_SPINNER_HEIGHT,
WIDX_TRACK_SPINNER_HEIGHT_INCREASE,
WIDX_TRACK_SPINNER_HEIGHT_DECREASE,
WIDX_TRACK_CHECK_CHAIN_LIFT,
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
WIDX_TRACK_CHECK_BRAKE_CLOSED,
Feature #8791: Improved tile element flag manipulation in Tile Inspector
2019-05-14 21:38:31 +02:00
WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
// Scenery
WIDX_SCENERY_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_SCENERY_SPINNER_HEIGHT_INCREASE,
WIDX_SCENERY_SPINNER_HEIGHT_DECREASE,
WIDX_SCENERY_CHECK_QUARTER_N,
WIDX_SCENERY_CHECK_QUARTER_E,
WIDX_SCENERY_CHECK_QUARTER_S,
WIDX_SCENERY_CHECK_QUARTER_W,
WIDX_SCENERY_CHECK_COLLISION_N,
WIDX_SCENERY_CHECK_COLLISION_E,
WIDX_SCENERY_CHECK_COLLISION_S,
WIDX_SCENERY_CHECK_COLLISION_W,
// Entrance
WIDX_ENTRANCE_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_ENTRANCE_SPINNER_HEIGHT_INCREASE,
WIDX_ENTRANCE_SPINNER_HEIGHT_DECREASE,
Add button to tile inspector to make entrances usable With this, entrances and exits that have been moved away from its original XY location can be made usable. Only one entrance or exit will be usable per station.
2018-01-13 15:44:10 +01:00
WIDX_ENTRANCE_BUTTON_MAKE_USABLE,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
// Wall
WIDX_WALL_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_WALL_SPINNER_HEIGHT_INCREASE,
WIDX_WALL_SPINNER_HEIGHT_DECREASE,
WIDX_WALL_DROPDOWN_SLOPE,
WIDX_WALL_DROPDOWN_SLOPE_BUTTON,
Fix #9029: Set animation frame on doors using the tile inspector (#11206)
2020-04-18 12:43:46 +02:00
WIDX_WALL_SPINNER_ANIMATION_FRAME,
WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE,
WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE,
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
// Large
WIDX_LARGE_SCENERY_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_LARGE_SCENERY_SPINNER_HEIGHT_INCREASE,
WIDX_LARGE_SCENERY_SPINNER_HEIGHT_DECREASE,
// Banner
WIDX_BANNER_SPINNER_HEIGHT = PAGE_WIDGETS,
WIDX_BANNER_SPINNER_HEIGHT_INCREASE,
WIDX_BANNER_SPINNER_HEIGHT_DECREASE,
WIDX_BANNER_CHECK_BLOCK_NE,
WIDX_BANNER_CHECK_BLOCK_SE,
WIDX_BANNER_CHECK_BLOCK_SW,
WIDX_BANNER_CHECK_BLOCK_NW,
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
};
Add build-time verifications for shortcut keys
2021-12-03 00:28:43 +01:00
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_ROTATE == WIDX_BUTTON_ROTATE);
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_COPY == WIDX_BUTTON_COPY);
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_PASTE == WIDX_BUTTON_PASTE);
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_REMOVE == WIDX_BUTTON_REMOVE);
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_MOVE_UP == WIDX_BUTTON_MOVE_UP);
static_assert(WC_TILE_INSPECTOR__WIDX_BUTTON_MOVE_DOWN == WIDX_BUTTON_MOVE_DOWN);
static_assert(WC_TILE_INSPECTOR__WIDX_SPINNER_X_INCREASE == WIDX_SPINNER_X_INCREASE);
static_assert(WC_TILE_INSPECTOR__WIDX_SPINNER_X_DECREASE == WIDX_SPINNER_X_DECREASE);
static_assert(WC_TILE_INSPECTOR__WIDX_SPINNER_Y_INCREASE == WIDX_SPINNER_Y_INCREASE);
static_assert(WC_TILE_INSPECTOR__WIDX_SPINNER_Y_DECREASE == WIDX_SPINNER_Y_DECREASE);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
#pragma region MEASUREMENTS
Add compile option to move close box to the left
2019-10-19 04:02:31 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
static constexpr const StringId WINDOW_TITLE = STR_TILE_INSPECTOR_TITLE;
Reordered widget defines These defines are used to calculate the edges of the widgets. They are now ordered in the same way the widgets are listed for the pages. This commit also adds some extra defines, to make it more easy to tweak the sizes and padding of widgets.
2016-10-01 23:23:47 +02:00
// Window sizes
Make WW and WH static
2020-05-09 17:05:01 +02:00
static constexpr const int32_t WW = 400;
static constexpr const int32_t WH = 170;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Use constexpr on openrct2-ui/*
2019-10-24 05:38:13 +02:00
constexpr int32_t MIN_WW = WW;
constexpr int32_t MAX_WW = WW;
constexpr int32_t MIN_WH = 130;
constexpr int32_t MAX_WH = 800;
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Reordered widget defines These defines are used to calculate the edges of the widgets. They are now ordered in the same way the widgets are listed for the pages. This commit also adds some extra defines, to make it more easy to tweak the sizes and padding of widgets.
2016-10-01 23:23:47 +02:00
// Button space for top buttons
Use ScreenCoordsXY and ScreenSize structs for main toolbar
2021-10-22 20:49:34 +02:00
constexpr auto ToolbarButtonAnchor = ScreenCoordsXY{ WW - 27, 17 };
constexpr auto ToolbarButtonSize = ScreenSize{ 24, 24 };
constexpr auto ToolbarButtonHalfSize = ScreenSize{ 24, 12 };
constexpr auto ToolbarButtonOffsetX = ScreenSize{ -24, 0 };
Recreated UI for tile inspector. Added swap functionality.
2015-12-28 23:11:36 +01:00
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
// List's column offsets
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
constexpr auto InvisibleFlagColumnXY = ScreenCoordsXY{ 3, 42 };
Use eye glyph instead of checkbox for visibility
2022-04-16 17:01:43 +02:00
constexpr auto InvisibleFlagColumnSize = ScreenSize{ 20, 14 };
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
constexpr auto TypeColumnXY = InvisibleFlagColumnXY + ScreenSize{ InvisibleFlagColumnSize.width, 0 };
Use eye glyph instead of checkbox for visibility
2022-04-16 17:01:43 +02:00
constexpr auto TypeColumnSize = ScreenSize{ 252, 14 };
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
constexpr auto BaseHeightColumnXY = TypeColumnXY + ScreenSize{ TypeColumnSize.width, 0 };
Tweak column headers and scrollbar
2021-11-01 21:56:12 +01:00
constexpr auto BaseHeightColumnSize = ScreenSize{ 30, 14 };
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
constexpr auto ClearanceHeightColumnXY = BaseHeightColumnXY + ScreenCoordsXY{ BaseHeightColumnSize.width, 0 };
Tweak column headers and scrollbar
2021-11-01 21:56:12 +01:00
constexpr auto ClearanceHeightColumnSize = ScreenSize{ 30, 14 };
Close #12825: Show object rotation in Tile Inspector
2021-11-16 23:16:59 +01:00
constexpr auto DirectionColumnXY = ClearanceHeightColumnXY + ScreenCoordsXY{ ClearanceHeightColumnSize.width, 0 };
constexpr auto DirectionColumnSize = ScreenSize{ 15, 14 };
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
constexpr auto GhostFlagColumnXY = DirectionColumnXY + ScreenCoordsXY{ DirectionColumnSize.width, 0 };
Tweak column headers and scrollbar
2021-11-01 21:56:12 +01:00
constexpr auto GhostFlagColumnSize = ScreenSize{ 15, 14 };
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
constexpr auto LastFlagColumnXY = GhostFlagColumnXY + ScreenCoordsXY{ GhostFlagColumnSize.width, 0 };
Tweak column headers and scrollbar
2021-11-01 21:56:12 +01:00
constexpr auto LastFlagColumnSize = ScreenSize{ 32, 14 };
Use constexpr on openrct2-ui/*
2019-10-24 05:38:13 +02:00
constexpr int32_t PADDING_BOTTOM = 15;
constexpr int32_t GROUPBOX_PADDING = 6;
constexpr int32_t HORIZONTAL_GROUPBOX_PADDING = 5;
constexpr int32_t VERTICAL_GROUPBOX_PADDING = 4;
Update and remove obsolete tile inspector macros
2021-11-01 21:34:52 +01:00
constexpr auto PropertyButtonSize = ScreenSize{ 130, 18 };
constexpr auto PropertyFullWidth = ScreenSize{ 370, 18 };
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
#pragma endregion
Start use of constexpr functions for widget placement
2021-10-31 22:44:42 +01:00
constexpr ScreenCoordsXY PropertyRowCol(ScreenCoordsXY anchor, int32_t row, int32_t column)
{
return anchor
+ ScreenCoordsXY{ column * (PropertyButtonSize.width + HORIZONTAL_GROUPBOX_PADDING),
row * (PropertyButtonSize.height + VERTICAL_GROUPBOX_PADDING) };
}
Reordered widget defines These defines are used to calculate the edges of the widgets. They are now ordered in the same way the widgets are listed for the pages. This commit also adds some extra defines, to make it more easy to tweak the sizes and padding of widgets.
2016-10-01 23:23:47 +02:00
Introduce helper function for checkbox groups
2021-11-01 22:24:56 +01:00
constexpr ScreenCoordsXY CheckboxGroupOffset(
ScreenCoordsXY anchorPoint, int16_t horizontalMultiplier, int16_t verticalMultiplier)
{
return anchorPoint + ScreenCoordsXY{ 14 * horizontalMultiplier, 7 * verticalMultiplier };
}
Reordered widget defines These defines are used to calculate the edges of the widgets. They are now ordered in the same way the widgets are listed for the pages. This commit also adds some extra defines, to make it more easy to tweak the sizes and padding of widgets.
2016-10-01 23:23:47 +02:00
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
// clang-format off
Update and remove obsolete tile inspector macros
2021-11-01 21:34:52 +01:00
// Macros for easily obtaining the top and bottom of a widget inside a properties group box
#define GBBT(GROUPTOP, row) ((GROUPTOP) + 14 + row * (PropertyButtonSize.height + VERTICAL_GROUPBOX_PADDING))
#define GBBB(GROUPTOP, row) (GBBT((GROUPTOP), row) + PropertyButtonSize.height)
Reordered widget defines These defines are used to calculate the edges of the widgets. They are now ordered in the same way the widgets are listed for the pages. This commit also adds some extra defines, to make it more easy to tweak the sizes and padding of widgets.
2016-10-01 23:23:47 +02:00
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
#define MAIN_TILE_INSPECTOR_WIDGETS \
Apply review requests
2020-05-09 16:44:21 +02:00
WINDOW_SHIM(WINDOW_TITLE, WW, WH), \
Tweak column headers and scrollbar
2021-11-01 21:56:12 +01:00
MakeWidget({3, 57}, {WW - 6, WH - PADDING_BOTTOM - 58}, WindowWidgetType::Scroll, WindowColour::Secondary, SCROLL_VERTICAL), /* Element list */ \
Move table header text to widget definitions
2020-09-02 20:39:22 +02:00
/* X and Y spinners */ \
Update scroll and spinners
2021-10-22 19:52:17 +02:00
MakeSpinnerWidgets({20, 23}, {51, 12}, WindowWidgetType::Spinner, WindowColour::Secondary), /* Spinner X (3 widgets) */ \
MakeSpinnerWidgets({90, 23}, {51, 12}, WindowWidgetType::Spinner, WindowColour::Secondary), /* Spinner Y (3 widgets) */ \
Move table header text to widget definitions
2020-09-02 20:39:22 +02:00
/* Top buttons */ \
Allow using ImageId in widgets directly
2022-12-24 17:47:22 +01:00
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 0, ToolbarButtonSize, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_DEMOLISH), STR_REMOVE_SELECTED_ELEMENT_TIP ), /* Remove button */ \
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 1, ToolbarButtonHalfSize, WindowWidgetType::Button, WindowColour::Secondary, STR_UP, STR_MOVE_SELECTED_ELEMENT_UP_TIP), /* Move up */ \
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 1 + ScreenSize{0, 12}, ToolbarButtonHalfSize, WindowWidgetType::Button, WindowColour::Secondary, STR_DOWN, STR_MOVE_SELECTED_ELEMENT_DOWN_TIP), /* Move down */ \
Allow using ImageId in widgets directly
2022-12-24 17:47:22 +01:00
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 2, ToolbarButtonSize, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_ROTATE_ARROW), STR_ROTATE_SELECTED_ELEMENT_TIP), /* Rotate button */ \
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 3, ToolbarButtonSize, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_G2_SORT), STR_TILE_INSPECTOR_SORT_TIP), /* Sort button */ \
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 4, ToolbarButtonSize, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_G2_PASTE), STR_TILE_INSPECTOR_PASTE_TIP), /* Paste button */ \
MakeWidget(ToolbarButtonAnchor + ToolbarButtonOffsetX * 5, ToolbarButtonSize, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_G2_COPY), STR_TILE_INSPECTOR_COPY_TIP), /* Copy button */ \
Move table header text to widget definitions
2020-09-02 20:39:22 +02:00
/* Column headers */ \
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
MakeWidget(InvisibleFlagColumnXY, InvisibleFlagColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_INVISIBLE_SHORT, STR_TILE_INSPECTOR_FLAG_INVISIBLE), /* Invisible flag */ \
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
MakeWidget(TypeColumnXY, TypeColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_ELEMENT_TYPE), /* Type */ \
MakeWidget(BaseHeightColumnXY, BaseHeightColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_BASE_HEIGHT_SHORT, STR_TILE_INSPECTOR_BASE_HEIGHT), /* Base height */ \
MakeWidget(ClearanceHeightColumnXY, ClearanceHeightColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_CLEARANGE_HEIGHT_SHORT, STR_TILE_INSPECTOR_CLEARANCE_HEIGHT), /* Clearance height */ \
Close #12825: Show object rotation in Tile Inspector
2021-11-16 23:16:59 +01:00
MakeWidget(DirectionColumnXY, DirectionColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_DIRECTION_SHORT, STR_TILE_INSPECTOR_DIRECTION), /* Direction */ \
Use ScreenCoordsXY/ScreenSize for columns
2021-10-22 22:16:04 +02:00
MakeWidget(GhostFlagColumnXY, GhostFlagColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_FLAG_GHOST_SHORT, STR_TILE_INSPECTOR_FLAG_GHOST), /* Ghost flag */ \
MakeWidget(LastFlagColumnXY, LastFlagColumnSize, WindowWidgetType::TableHeader, WindowColour::Secondary, STR_TILE_INSPECTOR_FLAG_LAST_SHORT, STR_TILE_INSPECTOR_FLAG_LAST), /* Last of tile flag */ \
Move table header text to widget definitions
2020-09-02 20:39:22 +02:00
/* Group boxes */ \
MakeWidget({6, 0}, {WW - 12, 0}, WindowWidgetType::Groupbox, WindowColour::Secondary, STR_NONE, STR_NONE ), /* Details group box */ \
MakeWidget({6, 0}, {WW - 12, 0}, WindowWidgetType::Groupbox, WindowColour::Secondary, STR_TILE_INSPECTOR_GROUPBOX_PROPERTIES, STR_NONE ) /* Properties group box */
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget DefaultWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update surface page to use new widget system
2021-11-01 21:26:35 +01:00
constexpr int32_t NumSurfaceProperties = 4;
constexpr int32_t NumSurfaceDetails = 4;
constexpr int32_t SurfacePropertiesHeight = 16 + NumSurfaceProperties * 21;
constexpr int32_t SurfaceDetailsHeight = 20 + NumSurfaceDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget SurfaceWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update surface page to use new widget system
2021-11-01 21:26:35 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_SURFACE_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
MakeWidget(PropertyRowCol({ 12, 0 }, 1, 0), PropertyButtonSize, WindowWidgetType::Button, WindowColour::Secondary, STR_TILE_INSPECTOR_SURFACE_REMOVE_FENCES), // WIDX_SURFACE_BUTTON_REMOVE_FENCES
MakeWidget(PropertyRowCol({ 12, 0 }, 1, 1), PropertyButtonSize, WindowWidgetType::Button, WindowColour::Secondary, STR_TILE_INSPECTOR_SURFACE_RESTORE_FENCES), // WIDX_SURFACE_BUTTON_RESTORE_FENCES
Introduce helper function for checkbox groups
2021-11-01 22:24:56 +01:00
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 3, 1), 1, 0), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SURFACE_CHECK_CORNER_N
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 3, 1), 2, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SURFACE_CHECK_CORNER_E
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 3, 1), 1, 2), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SURFACE_CHECK_CORNER_S
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 3, 1), 0, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SURFACE_CHECK_CORNER_W
Update surface page to use new widget system
2021-11-01 21:26:35 +01:00
MakeWidget(PropertyRowCol({ 12, 0 }, 4, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_SURFACE_DIAGONAL), // WIDX_SURFACE_CHECK_DIAGONAL
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
constexpr int32_t NumPathProperties = 6;
Add new .park save format Co-authored-by: Gymnasiast <Gymnasiast@users.noreply.github.com> Co-authored-by: duncanspumpkin <duncanspumpkin@users.noreply.github.com> Co-authored-by: ZehMatt <Zehmatt@users.noreply.github.com> Co-authored-by: Broxzier <Broxzier@users.noreply.github.com>
2021-10-27 14:21:14 +02:00
constexpr int32_t NumPathDetails = 3;
Update path page to use new widget system
2021-11-01 21:19:32 +01:00
constexpr int32_t PathPropertiesHeight = 16 + NumPathProperties * 21;
constexpr int32_t PathDetailsHeight = 20 + NumPathDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget PathWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update path page to use new widget system
2021-11-01 21:19:32 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_PATH_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
MakeWidget(PropertyRowCol({ 12, 0 }, 1, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_PATH_BROKEN), // WIDX_PATH_CHECK_BROKEN
MakeWidget(PropertyRowCol({ 12, 0 }, 2, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_PATH_SLOPED), // WIDX_PATH_CHECK_SLOPED
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
MakeWidget(PropertyRowCol({ 12, 0 }, 3, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_PATH_JUNCTION_RAILINGS), // WIDX_PATH_CHECK_JUNCTION_RAILINGS
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 3, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_NE
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 4, 2), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_E
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 3, 3), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_SE
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 2, 4), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_S
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 1, 3), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_SW
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 0, 2), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_W
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 1, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_NW
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 4, 1), 2, 0), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_PATH_CHECK_EDGE_N
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update track page to use new widget system
2021-11-01 21:14:07 +01:00
constexpr int32_t NumTrackProperties = 5;
constexpr int32_t NumTrackDetails = 7;
constexpr int32_t TrackPropertiesHeight = 16 + NumTrackProperties * 21;
constexpr int32_t TrackDetailsHeight = 20 + NumTrackDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget TrackWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update track page to use new widget system
2021-11-01 21:14:07 +01:00
MakeWidget(PropertyRowCol({ 12, 0}, 0, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_TRACK_ENTIRE_TRACK_PIECE), // WIDX_TRACK_CHECK_APPLY_TO_ALL
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 1, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_TRACK_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
MakeWidget(PropertyRowCol({ 12, 0}, 2, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_TRACK_CHAIN_LIFT), // WIDX_TRACK_CHECK_CHAIN_LIFT
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
MakeWidget(PropertyRowCol({ 12, 0}, 3, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_TRACK_BRAKE_CLOSED), // WIDX_TRACK_CHECK_BRAKE_CLOSED
Update track page to use new widget system
2021-11-01 21:14:07 +01:00
MakeWidget(PropertyRowCol({ 12, 0}, 4, 0), PropertyFullWidth, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_TILE_INSPECTOR_TRACK_IS_INDESTRUCTIBLE), // WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update scenery page to use new widget system
2021-11-01 21:05:55 +01:00
constexpr int32_t NumSceneryProperties = 4; // The checkbox groups both count for 2 rows
constexpr int32_t NumSceneryDetails = 4;
constexpr int32_t SceneryPropertiesHeight = 16 + NumSceneryProperties * 21;
constexpr int32_t SceneryDetailsHeight = 20 + NumSceneryDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget SceneryWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update scenery page to use new widget system
2021-11-01 21:05:55 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_SCENERY_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
Introduce helper function for checkbox groups
2021-11-01 22:24:56 +01:00
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 1, 0), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_QUARTER_N
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 2, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_QUARTER_E
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 1, 2), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_QUARTER_S
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 0, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_QUARTER_W
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 2, 1), 1, 0), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_COLLISION_N
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 2, 1), 2, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_COLLISION_E
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 2, 1), 1, 2), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_COLLISION_S
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 2, 1), 0, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_SCENERY_CHECK_COLLISION_W
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update entrance page to use new widget system
2021-11-01 20:31:10 +01:00
constexpr int32_t NumEntranceProperties = 2;
constexpr int32_t NumEntranceDetails = 4;
constexpr int32_t EntrancePropertiesHeight = 16 + NumEntranceProperties * 21;
constexpr int32_t EntranceDetailsHeight = 20 + NumEntranceDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget EntranceWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update entrance page to use new widget system
2021-11-01 20:31:10 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_ENTRANCE_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
MakeWidget(PropertyRowCol({ 12, 0 }, 1, 0), PropertyButtonSize, WindowWidgetType::Button, WindowColour::Secondary, STR_TILE_INSPECTOR_ENTRANCE_MAKE_USABLE, STR_TILE_INSPECTOR_ENTRANCE_MAKE_USABLE_TIP), // WIDX_ENTRANCE_BUTTON_MAKE_USABLE
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
};
Update wall page to use new widget system Also fixes setting of groupbox title properly and make the list static
2021-11-01 20:02:56 +01:00
constexpr int32_t NumWallProperties = 3;
constexpr int32_t NumWallDetails = 2;
constexpr int32_t WallPropertiesHeight = 16 + NumWallProperties * 21;
constexpr int32_t WallDetailsHeight = 20 + NumWallDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget WallWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update wall page to use new widget system Also fixes setting of groupbox title properly and make the list static
2021-11-01 20:02:56 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_WALL_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
MakeWidget(PropertyRowCol({ 12, 0 }, 1, 1), PropertyButtonSize, WindowWidgetType::DropdownMenu, WindowColour::Secondary), // WIDX_WALL_DROPDOWN_SLOPE
MakeWidget(PropertyRowCol({ 12 + PropertyButtonSize.width - 12, 0 }, 1, 1), { 11, 12}, WindowWidgetType::Button, WindowColour::Secondary, STR_DROPDOWN_GLYPH), // WIDX_WALL_DROPDOWN_SLOPE_BUTTON
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 2, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_WALL_SPINNER_ANIMATION_FRAME{,_INCREASE,_DECREASE}
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update large scenery page to use new widget system
2021-10-31 22:59:26 +01:00
constexpr int32_t NumLargeSceneryProperties = 1;
constexpr int32_t NumLargeSceneryDetails = 3;
constexpr int32_t LargeSceneryPropertiesHeight = 16 + NumLargeSceneryProperties * 21;
constexpr int32_t LargeSceneryDetailsHeight = 20 + NumLargeSceneryDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget LargeSceneryWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Fix incorrect WIDX ID comments
2021-11-01 19:45:43 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_LARGE_SCENERY_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Update banner page to use new widget system
2021-10-31 22:57:01 +01:00
constexpr int32_t NumBannerProperties = 3;
constexpr int32_t NumBannerDetails = 1;
constexpr int32_t BannerPropertiesHeight = 16 + NumBannerProperties * 21;
constexpr int32_t BannerDetailsHeight = 20 + NumBannerDetails * 11;
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget BannerWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
MAIN_TILE_INSPECTOR_WIDGETS,
Update banner page to use new widget system
2021-10-31 22:57:01 +01:00
MakeSpinnerWidgets(PropertyRowCol({ 12, 0 }, 0, 1), PropertyButtonSize, WindowWidgetType::Spinner, WindowColour::Secondary), // WIDX_BANNER_SPINNER_HEIGHT{,_INCREASE,_DECREASE}
Introduce helper function for checkbox groups
2021-11-01 22:24:56 +01:00
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 3, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_BANNER_CHECK_BLOCK_NE
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 3, 3), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_BANNER_CHECK_BLOCK_SE
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 1, 3), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_BANNER_CHECK_BLOCK_SW
MakeWidget(CheckboxGroupOffset(PropertyRowCol({ 12, 0 }, 1, 1), 1, 1), { 12, 12 }, WindowWidgetType::Checkbox, WindowColour::Secondary), // WIDX_BANNER_CHECK_BLOCK_NW
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Make WIDGETS_END constexpr
2021-09-26 11:11:42 +02:00
WIDGETS_END,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
static Widget *PageWidgets[] = {
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
DefaultWidgets,
SurfaceWidgets,
PathWidgets,
TrackWidgets,
SceneryWidgets,
EntranceWidgets,
WallWidgets,
LargeSceneryWidgets,
BannerWidgets,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
// clang-format on
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
Start use of constexpr functions for widget placement
2021-10-31 22:44:42 +01:00
struct TileInspectorGroupboxSettings
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
{
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
// Offsets from the bottom of the window
Replace our own integer types with standard ones
2018-06-20 17:28:51 +02:00
int16_t details_top_offset, details_bottom_offset;
int16_t properties_top_offset, properties_bottom_offset;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
// String to be displayed in the details groupbox
Rename rct_string_id to StringId
2022-07-31 14:22:58 +02:00
StringId string_id;
Start use of constexpr functions for widget placement
2021-10-31 22:44:42 +01:00
};
Update wall page to use new widget system Also fixes setting of groupbox title properly and make the list static
2021-11-01 20:02:56 +01:00
static constexpr TileInspectorGroupboxSettings MakeGroupboxSettings(
Rename rct_string_id to StringId
2022-07-31 14:22:58 +02:00
int16_t detailsHeight, int16_t propertiesHeight, StringId stringId)
Start use of constexpr functions for widget placement
2021-10-31 22:44:42 +01:00
{
TileInspectorGroupboxSettings settings{};
decltype(settings.properties_bottom_offset) offsetSum = 0;
settings.properties_bottom_offset = (offsetSum += PADDING_BOTTOM);
settings.properties_top_offset = (offsetSum += propertiesHeight);
settings.details_bottom_offset = (offsetSum += GROUPBOX_PADDING);
settings.details_top_offset = (offsetSum += detailsHeight);
Update wall page to use new widget system Also fixes setting of groupbox title properly and make the list static
2021-11-01 20:02:56 +01:00
settings.string_id = stringId;
Start use of constexpr functions for widget placement
2021-10-31 22:44:42 +01:00
return settings;
}
Make groupbox settings array static
2021-11-01 21:28:40 +01:00
static constexpr TileInspectorGroupboxSettings PageGroupBoxSettings[] = {
Update surface page to use new widget system
2021-11-01 21:26:35 +01:00
MakeGroupboxSettings(SurfaceDetailsHeight, SurfacePropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_SURFACE_INFO),
Update path page to use new widget system
2021-11-01 21:19:32 +01:00
MakeGroupboxSettings(PathDetailsHeight, PathPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_PATH_INFO),
Update track page to use new widget system
2021-11-01 21:14:07 +01:00
MakeGroupboxSettings(TrackDetailsHeight, TrackPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_TRACK_INFO),
Update scenery page to use new widget system
2021-11-01 21:05:55 +01:00
MakeGroupboxSettings(SceneryDetailsHeight, SceneryPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_SCENERY_INFO),
Update entrance page to use new widget system
2021-11-01 20:31:10 +01:00
MakeGroupboxSettings(EntranceDetailsHeight, EntrancePropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_ENTRANCE_INFO),
Update wall page to use new widget system Also fixes setting of groupbox title properly and make the list static
2021-11-01 20:02:56 +01:00
MakeGroupboxSettings(WallDetailsHeight, WallPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_WALL_INFO),
Update large scenery page to use new widget system
2021-10-31 22:59:26 +01:00
MakeGroupboxSettings(LargeSceneryDetailsHeight, LargeSceneryPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_BANNER_INFO),
Update banner page to use new widget system
2021-10-31 22:57:01 +01:00
MakeGroupboxSettings(BannerDetailsHeight, BannerPropertiesHeight, STR_TILE_INSPECTOR_GROUPBOX_BANNER_INFO),
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Refactor viewport interaction flags and add plugin API
2021-02-10 02:06:18 +01:00
static constexpr int32_t ViewportInteractionFlags = EnumsToFlags(
ViewportInteractionItem::Terrain, ViewportInteractionItem::Entity, ViewportInteractionItem::Ride,
ViewportInteractionItem::Scenery, ViewportInteractionItem::Footpath, ViewportInteractionItem::FootpathItem,
ViewportInteractionItem::ParkEntrance, ViewportInteractionItem::Wall, ViewportInteractionItem::LargeScenery,
ViewportInteractionItem::Banner);
Improve array formatting For most of these cases, adding a trailing comma to the array block makes clang-format put each item on a new line, and clang-format exception blocks could be reduced where clang-format does not handle them properly.
2021-10-17 15:31:56 +02:00
// clang-format off
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Replace our own integer types with standard ones
2018-06-20 17:28:51 +02:00
static uint64_t PageHoldDownWidgets[] = {
Use lower-case u integral suffix
2022-10-17 19:21:18 +02:00
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_SURFACE_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_SURFACE_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_PATH_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_PATH_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_TRACK_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_TRACK_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_SCENERY_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_SCENERY_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_ENTRANCE_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_ENTRANCE_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_WALL_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_WALL_SPINNER_HEIGHT_DECREASE) | (1uLL << WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE) | (1uLL << WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_LARGE_SCENERY_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_LARGE_SCENERY_SPINNER_HEIGHT_DECREASE),
(1uLL << WIDX_SPINNER_X_INCREASE) | (1uLL << WIDX_SPINNER_X_DECREASE) | (1uLL << WIDX_SPINNER_Y_INCREASE) | (1uLL << WIDX_SPINNER_Y_DECREASE) | (1uLL << WIDX_BANNER_SPINNER_HEIGHT_INCREASE) | (1uLL << WIDX_BANNER_SPINNER_HEIGHT_DECREASE),
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Replace our own integer types with standard ones
2018-06-20 17:28:51 +02:00
static uint64_t PageDisabledWidgets[] = {
Use lower-case u integral suffix
2022-10-17 19:21:18 +02:00
(1uLL << WIDX_BUTTON_MOVE_UP) | (1uLL << WIDX_BUTTON_MOVE_DOWN) | (1uLL << WIDX_BUTTON_REMOVE) | (1uLL << WIDX_BUTTON_ROTATE) | (1uLL << WIDX_BUTTON_COPY),
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
0,
0,
0,
0,
0,
0,
Use lower-case u integral suffix
2022-10-17 19:21:18 +02:00
(1uLL << WIDX_BUTTON_ROTATE),
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
0,
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
};
Exclude pre-formatted blocks from clang-format (#7520) [ci skip]
2018-05-16 20:41:29 +02:00
// clang-format on
[WIP] Prepared group boxes for details and properties
2016-05-29 16:12:53 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
class TileInspector final : public Window
Select previous element after removing in tile inspector
2017-06-05 13:23:09 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
private:
int16_t _highlightedIndex = -1;
bool _tileSelected = false;
int32_t _toolMouseX = 0;
int32_t _toolMouseY = 0;
bool _toolCtrlDown = false;
CoordsXY _toolMap = {};
bool _applyToAll = false;
bool _elementCopied = false;
TileElement _copiedElement;
public:
void OnOpen() override
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
min_width = MIN_WW;
min_height = MIN_WH;
max_width = MAX_WW;
max_height = MAX_WH;
Remove window internals from TileInspector logic
2018-06-11 01:09:00 +02:00
windowTileInspectorSelectedIndex = -1;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetPage(TileInspectorPage::Default);
WindowInitScrollWidgets(*this);
_tileSelected = false;
Feature #15164: Highlight selected Tile Inspector element
2021-08-01 22:13:12 +02:00
Rename global window functions to TitleCase (#19167)
2023-01-16 21:13:42 +01:00
ToolSet(*this, WIDX_BACKGROUND, Tool::Crosshair);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnUpdate() override
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Check if the mouse is hovering over the list
if (!WidgetIsHighlighted(*this, WIDX_LIST))
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
_highlightedIndex = -1;
InvalidateWidget(WIDX_LIST);
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (gCurrentToolWidget.window_classification != WindowClass::TileInspector)
Close();
}
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnMouseUp(WidgetIndex widgetIndex) override
{
switch (widgetIndex)
{
case WIDX_CLOSE:
Rename global window functions to TitleCase (#19167)
2023-01-16 21:13:42 +01:00
ToolCancel();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Close();
return;
Minor improvements - Paths are now properly rotated, including flat ones - Banners can not be rotated - The X and Y coordinates can be changed with spinners - Highligint selected tile while now hovering over viewport - Added helper function for enabling and disabling widgets more easily
2016-06-05 00:45:13 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_REMOVE:
{
int32_t nextItemToSelect = windowTileInspectorSelectedIndex - 1;
RemoveElement(windowTileInspectorSelectedIndex);
SelectElementFromList(nextItemToSelect);
break;
}
Minor improvements - Paths are now properly rotated, including flat ones - Banners can not be rotated - The X and Y coordinates can be changed with spinners - Highligint selected tile while now hovering over viewport - Added helper function for enabling and disabling widgets more easily
2016-06-05 00:45:13 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_ROTATE:
RotateElement(windowTileInspectorSelectedIndex);
break;
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_SORT:
SortElements();
break;
Function to remove elements using the tile inspector.
2015-12-29 15:43:49 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_COPY:
CopyElement();
break;
Added button to reotate map elements in tile inspector - closes #3106
2016-04-17 00:35:11 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_PASTE:
PasteElement();
break;
Added empty button that swaps the top two map elements
2015-12-21 00:52:42 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_MOVE_UP:
SwapElements(windowTileInspectorSelectedIndex, windowTileInspectorSelectedIndex + 1);
break;
Added sort button, cleaned up page switching.
2016-06-11 19:39:51 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BUTTON_MOVE_DOWN:
SwapElements(windowTileInspectorSelectedIndex - 1, windowTileInspectorSelectedIndex);
break;
}
Add copy/paste functionality to tile inspector
2016-10-23 20:40:23 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Only element-specific widgets from now on
if (tileInspectorPage == TileInspectorPage::Default || windowTileInspectorSelectedIndex == -1)
return;
Add copy/paste functionality to tile inspector
2016-10-23 20:40:23 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
TileElement* const tileElement = GetSelectedElement();
Change base height
2017-01-25 14:22:33 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Update selection, can be nullptr.
OpenRCT2::TileInspector::SetSelectedElement(tileElement);
Add show/restore park fences to MP
2017-01-27 13:30:09 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (tileElement == nullptr)
return;
Tile inspector raises surface when all corners are raised. Removes printf.
2016-10-09 00:00:36 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Page widgets
switch (tileElement->GetType())
{
case TileElementType::Surface:
switch (widgetIndex)
{
case WIDX_SURFACE_BUTTON_REMOVE_FENCES:
SurfaceShowParkFences(false);
break;
case WIDX_SURFACE_BUTTON_RESTORE_FENCES:
SurfaceShowParkFences(true);
break;
case WIDX_SURFACE_CHECK_CORNER_N:
case WIDX_SURFACE_CHECK_CORNER_E:
case WIDX_SURFACE_CHECK_CORNER_S:
case WIDX_SURFACE_CHECK_CORNER_W:
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
SurfaceToggleCorner(((widgetIndex - WIDX_SURFACE_CHECK_CORNER_N) + 2 - GetCurrentRotation()) & 3);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break;
case WIDX_SURFACE_CHECK_DIAGONAL:
SurfaceToggleDiagonal();
break;
} // switch widgetindex
break;
case TileElementType::Path:
switch (widgetIndex)
{
case WIDX_PATH_CHECK_SLOPED:
PathSetSloped(windowTileInspectorSelectedIndex, !tileElement->AsPath()->IsSloped());
break;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
case WIDX_PATH_CHECK_JUNCTION_RAILINGS:
PathSetJunctionRailings(
windowTileInspectorSelectedIndex, !tileElement->AsPath()->HasJunctionRailings());
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_PATH_CHECK_BROKEN:
PathSetBroken(windowTileInspectorSelectedIndex, !tileElement->AsPath()->IsBroken());
break;
case WIDX_PATH_CHECK_EDGE_E:
case WIDX_PATH_CHECK_EDGE_S:
case WIDX_PATH_CHECK_EDGE_W:
case WIDX_PATH_CHECK_EDGE_N:
{
// 0 = east/right, 1 = south/bottom, 2 = west/left, 3 = north/top
const int32_t eswn = (widgetIndex - WIDX_PATH_CHECK_EDGE_E) / 2;
// Transform to world orientation
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
const int32_t index = (eswn - GetCurrentRotation()) & 3;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
PathToggleEdge(
windowTileInspectorSelectedIndex,
index + 4); // The corners are stored in the 4 most significant bits, hence the + 4
break;
}
Add diagonal toggle to MP
2017-01-27 14:19:23 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_PATH_CHECK_EDGE_NE:
case WIDX_PATH_CHECK_EDGE_SE:
case WIDX_PATH_CHECK_EDGE_SW:
case WIDX_PATH_CHECK_EDGE_NW:
{
// 0 = NE, 1 = SE, 2 = SW, 3 = NW
const int32_t neseswnw = (widgetIndex - WIDX_PATH_CHECK_EDGE_NE) / 2;
// Transform to world orientation
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
const int32_t index = (neseswnw - GetCurrentRotation()) & 3;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
PathToggleEdge(windowTileInspectorSelectedIndex, index);
break;
}
} // switch widget index
break;
Add toggling footpath slope to MP
2017-02-06 14:51:45 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Track:
switch (widgetIndex)
{
case WIDX_TRACK_CHECK_APPLY_TO_ALL:
_applyToAll ^= 1;
InvalidateWidget(widgetIndex);
break;
Feature #8791: Improved tile element flag manipulation in Tile Inspector
2019-05-14 21:38:31 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_TRACK_CHECK_CHAIN_LIFT:
{
bool entireTrackBlock = IsWidgetPressed(WIDX_TRACK_CHECK_APPLY_TO_ALL);
bool newLift = !tileElement->AsTrack()->HasChain();
TrackBlockSetLift(windowTileInspectorSelectedIndex, entireTrackBlock, newLift);
break;
}
Add path edges and corner toggle to MP
2017-01-27 19:12:25 +01:00
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
case WIDX_TRACK_CHECK_BRAKE_CLOSED:
TrackSetBrakeClosed(windowTileInspectorSelectedIndex, !tileElement->AsTrack()->IsBrakeClosed());
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break;
Add button to tile inspector to make entrances usable With this, entrances and exits that have been moved away from its original XY location can be made usable. Only one entrance or exit will be usable per station.
2018-01-13 15:44:10 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE:
TrackSetIndestructible(windowTileInspectorSelectedIndex, !tileElement->AsTrack()->IsIndestructible());
break;
} // switch widget index
break;
Add setting slope for fences to MP
2017-02-02 20:06:27 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::SmallScenery:
switch (widgetIndex)
{
case WIDX_SCENERY_CHECK_QUARTER_N:
case WIDX_SCENERY_CHECK_QUARTER_E:
case WIDX_SCENERY_CHECK_QUARTER_S:
case WIDX_SCENERY_CHECK_QUARTER_W:
QuarterTileSet(windowTileInspectorSelectedIndex, widgetIndex - WIDX_SCENERY_CHECK_QUARTER_N);
break;
case WIDX_SCENERY_CHECK_COLLISION_N:
case WIDX_SCENERY_CHECK_COLLISION_E:
case WIDX_SCENERY_CHECK_COLLISION_S:
case WIDX_SCENERY_CHECK_COLLISION_W:
ToggleQuadrantCollosion(windowTileInspectorSelectedIndex, widgetIndex - WIDX_SCENERY_CHECK_COLLISION_N);
break;
} // switch widget index
break;
Fix #9029: Set animation frame on doors using the tile inspector (#11206)
2020-04-18 12:43:46 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Entrance:
switch (widgetIndex)
{
case WIDX_ENTRANCE_BUTTON_MAKE_USABLE:
EntranceMakeUsable(windowTileInspectorSelectedIndex);
break;
} // switch widget index
break;
Add toggle to raise/lower entire track block, and to raise fances On top of that, added the definition of one of the map flags, and an assert that I placed while debugging, which wouldn't hurt leaving there.
2016-09-10 22:37:47 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Banner:
switch (widgetIndex)
{
case WIDX_BANNER_CHECK_BLOCK_NE:
case WIDX_BANNER_CHECK_BLOCK_SE:
case WIDX_BANNER_CHECK_BLOCK_SW:
case WIDX_BANNER_CHECK_BLOCK_NW:
BannerToggleBlock(windowTileInspectorSelectedIndex, widgetIndex - WIDX_BANNER_CHECK_BLOCK_NE);
break;
} // switch widget index
break;
pinner for fence height, apply-all works for lift hill & cleanups - Removes old (now unused) string - Cleans up includes in tile_inspector.c - Properly invalidating widgets upon changes made - Invalidates tile when lift hill is changed - Makes 'apply to all' works for lift hills
2016-09-11 23:02:34 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::LargeScenery:
case TileElementType::Wall:
default:
break;
}
}
Feature #8791: Improved tile element flag manipulation in Tile Inspector
2019-05-14 21:38:31 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnClose() override
{
OpenRCT2::TileInspector::SetSelectedElement(nullptr);
}
Feature #8791: Improved tile element flag manipulation in Tile Inspector
2019-05-14 21:38:31 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnResize() override
{
if (width < min_width)
{
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
width = min_width;
}
if (height < min_height)
{
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
height = min_height;
}
}
scenery page and some changes to the other pages
2016-09-18 10:29:48 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnMouseDown(WidgetIndex widgetIndex) override
{
switch (widgetIndex)
{
case WIDX_SPINNER_X_INCREASE:
windowTileInspectorTile.x = std::min<int32_t>(windowTileInspectorTile.x + 1, MAXIMUM_MAP_SIZE_TECHNICAL - 1);
_toolMap.x = std::min<int32_t>(_toolMap.x + 32, MAXIMUM_TILE_START_XY);
LoadTile(nullptr);
break;
Add setting quadrant collision for small scenery to MP
2017-02-07 15:25:42 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_SPINNER_X_DECREASE:
windowTileInspectorTile.x = std::max<int32_t>(windowTileInspectorTile.x - 1, 0);
_toolMap.x = std::max<int32_t>(_toolMap.x - 32, 0);
LoadTile(nullptr);
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_SPINNER_Y_INCREASE:
windowTileInspectorTile.y = std::min<int32_t>(windowTileInspectorTile.y + 1, MAXIMUM_MAP_SIZE_TECHNICAL - 1);
_toolMap.y = std::min<int32_t>(_toolMap.y + 32, MAXIMUM_TILE_START_XY);
LoadTile(nullptr);
break;
Add banner toggle for blocking paths to MP
2017-02-07 21:42:39 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_SPINNER_Y_DECREASE:
windowTileInspectorTile.y = std::max<int32_t>(windowTileInspectorTile.y - 1, 0);
_toolMap.y = std::max<int32_t>(_toolMap.y - 32, 0);
LoadTile(nullptr);
break;
} // switch widget index
Add clamp corrupt element to MP
2017-02-07 15:39:07 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Only element-specific widgets from now on
if (tileInspectorPage == TileInspectorPage::Default || windowTileInspectorSelectedIndex == -1)
return;
Feature #15164: Highlight selected Tile Inspector element
2021-08-01 22:13:12 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const TileElement* tileElement = GetSelectedElement();
if (tileElement == nullptr)
Prevent recently closed window from having actions performed on it (#8143) Fixes #8121
2018-10-24 20:57:39 +02:00
return;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
switch (tileElement->GetType())
{
case TileElementType::Surface:
switch (widgetIndex)
{
case WIDX_SURFACE_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_SURFACE_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Path:
switch (widgetIndex)
{
case WIDX_PATH_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_PATH_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
Fix #15221: Update tile inspector highlighted element when order changes (#15223)
2021-08-16 11:36:02 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Track:
switch (widgetIndex)
{
case WIDX_TRACK_SPINNER_HEIGHT_INCREASE:
if (IsWidgetPressed(WIDX_TRACK_CHECK_APPLY_TO_ALL))
TrackBlockHeightOffset(windowTileInspectorSelectedIndex, 1);
else
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_TRACK_SPINNER_HEIGHT_DECREASE:
if (IsWidgetPressed(WIDX_TRACK_CHECK_APPLY_TO_ALL))
TrackBlockHeightOffset(windowTileInspectorSelectedIndex, -1);
else
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
Fix #15221: Update tile inspector highlighted element when order changes (#15223)
2021-08-16 11:36:02 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::SmallScenery:
switch (widgetIndex)
{
case WIDX_SCENERY_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_SCENERY_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Entrance:
switch (widgetIndex)
{
case WIDX_ENTRANCE_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_ENTRANCE_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
case WIDX_ENTRANCE_BUTTON_MAKE_USABLE:
EntranceMakeUsable(windowTileInspectorSelectedIndex);
break;
} // switch widget index
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Wall:
switch (widgetIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_WALL_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_WALL_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
case WIDX_WALL_DROPDOWN_SLOPE_BUTTON:
{
Rename rct_widget to Widget
2022-12-24 16:50:29 +01:00
Widget* widget = &widgets[widgetIndex];
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Use dropdown instead of dropdown button
widget--;
// Fill dropdown list
gDropdownItems[0].Format = STR_DROPDOWN_MENU_LABEL;
gDropdownItems[1].Format = STR_DROPDOWN_MENU_LABEL;
gDropdownItems[2].Format = STR_DROPDOWN_MENU_LABEL;
gDropdownItems[0].Args = STR_TILE_INSPECTOR_WALL_FLAT;
gDropdownItems[1].Args = STR_TILE_INSPECTOR_WALL_SLOPED_LEFT;
gDropdownItems[2].Args = STR_TILE_INSPECTOR_WALL_SLOPED_RIGHT;
WindowDropdownShowTextCustomWidth(
{ windowPos.x + widget->left, windowPos.y + widget->top }, widget->height() + 1, colours[1], 0,
Dropdown::Flag::StayOpen, 3, widget->width() - 3);
// Set current value as checked
Dropdown::SetChecked(tileElement->AsWall()->GetSlope(), true);
break;
}
case WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE:
WallAnimationFrameOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE:
WallAnimationFrameOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
case TileElementType::LargeScenery:
switch (widgetIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_LARGE_SCENERY_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_LARGE_SCENERY_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
clang-format UI windows
2018-06-22 23:21:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Banner:
switch (widgetIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case WIDX_BANNER_SPINNER_HEIGHT_INCREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, 1);
break;
case WIDX_BANNER_SPINNER_HEIGHT_DECREASE:
BaseHeightOffset(windowTileInspectorSelectedIndex, -1);
break;
} // switch widget index
break;
clang-format UI windows
2018-06-22 23:21:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
default:
break;
}
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnDropdown(WidgetIndex widgetIndex, int32_t dropdownIndex) override
{
if (dropdownIndex == -1)
return;
// Get selected element
TileElement* const tileElement = GetSelectedElement();
if (tileInspectorPage == TileInspectorPage::Wall)
{
openrct2_assert(tileElement->GetType() == TileElementType::Wall, "Element is not a wall");
if (widgetIndex == WIDX_WALL_DROPDOWN_SLOPE_BUTTON)
WallSetSlope(windowTileInspectorSelectedIndex, dropdownIndex);
}
}
clang-format UI windows
2018-06-22 23:21:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnToolUpdate(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
{
Next chunk of World/Map.h snakes (#18296) * Next chunk of World/Map.h snakes * Apply clang-format
2022-10-12 07:35:20 +02:00
MapInvalidateSelectionRect();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
CoordsXY mapCoords;
TileElement* clickedElement = nullptr;
bool mouseOnViewport = false;
if (InputTestPlaceObjectModifier(PLACE_OBJECT_MODIFIER_COPY_Z))
{
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
auto info = GetMapCoordinatesFromPos(screenCoords, ViewportInteractionFlags);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
clickedElement = info.Element;
mapCoords = info.Loc;
}
// Even if Ctrl was pressed, fall back to normal selection when there was nothing under the cursor
if (clickedElement == nullptr)
{
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
auto mouseCoords = ScreenPosToMapPos(screenCoords, nullptr);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (mouseCoords.has_value())
{
mouseOnViewport = true;
mapCoords = mouseCoords.value();
}
}
if (mouseOnViewport)
gMapSelectPositionA = gMapSelectPositionB = mapCoords;
else if (_tileSelected)
gMapSelectPositionA = gMapSelectPositionB = _toolMap;
else
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
gMapSelectType = MAP_SELECT_TYPE_FULL;
Next chunk of World/Map.h snakes (#18296) * Next chunk of World/Map.h snakes * Apply clang-format
2022-10-12 07:35:20 +02:00
MapInvalidateSelectionRect();
Avoid referencing null tile elements or derivations
2021-03-03 22:06:07 +01:00
}
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnToolDown(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
UpdateSelectedTile(screenCoords);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnToolDrag(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
UpdateSelectedTile(screenCoords);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
ScreenSize OnScrollGetSize(int32_t scrollIndex) override
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
return ScreenSize(WW - 30, windowTileInspectorElementCount * SCROLLABLE_ROW_HEIGHT);
}
void OnScrollMouseDown(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// There is nothing to interact with when no tile is selected
if (!_tileSelected)
return;
// Because the list items are displayed in reverse order, subtract the calculated index from the amount of elements
const int16_t index = windowTileInspectorElementCount - (screenCoords.y - 1) / SCROLLABLE_ROW_HEIGHT - 1;
const ScreenRect checkboxColumnRect{ { 2, 0 }, { 15, screenCoords.y } };
if (index >= 0 && checkboxColumnRect.Contains(screenCoords))
{ // Checkbox was clicked
ToggleInvisibility(index);
}
else
{
SelectElementFromList(index);
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void OnScrollMouseOver(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
{
int16_t index = windowTileInspectorElementCount - (screenCoords.y - 1) / SCROLLABLE_ROW_HEIGHT - 1;
if (index < 0 || index >= windowTileInspectorElementCount)
_highlightedIndex = -1;
else
_highlightedIndex = index;
InvalidateWidget(WIDX_LIST);
}
Avoid referencing null tile elements or derivations
2021-03-03 22:06:07 +01:00
Rename classes with snakes OpenRCT2/A*-F* (#19215) * Rename classes with snakes OpenRCT2/A*-F* * Clang format files
2023-01-19 09:16:44 +01:00
void OnDraw(DrawPixelInfo& dpi) override
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
DrawWidgets(dpi);
ScreenCoordsXY screenCoords(windowPos.x, windowPos.y);
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Draw coordinates
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
GfxDrawString(dpi, screenCoords + ScreenCoordsXY(5, 24), "X:", { colours[1] });
GfxDrawString(dpi, screenCoords + ScreenCoordsXY(74, 24), "Y:", { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (_tileSelected)
{
auto tileCoords = TileCoordsXY{ _toolMap };
auto ft = Formatter();
ft.Add<int32_t>(tileCoords.x);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 43, 24 }, STR_FORMAT_INTEGER, ft, { colours[1], TextAlignment::RIGHT });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
ft = Formatter();
ft.Add<int32_t>(tileCoords.y);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 113, 24 }, STR_FORMAT_INTEGER, ft, { colours[1], TextAlignment::RIGHT });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
else
{
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
GfxDrawString(dpi, screenCoords + ScreenCoordsXY(43 - 7, 24), "-", { colours[1] });
GfxDrawString(dpi, screenCoords + ScreenCoordsXY(113 - 7, 24), "-", { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
if (windowTileInspectorSelectedIndex != -1)
{
// X and Y of first element in detail box
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_GROUPBOX_DETAILS].top + 14 };
// Get map element
TileElement* const tileElement = GetSelectedElement();
if (tileElement == nullptr)
return;
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
switch (tileElement->GetType())
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Surface:
{
// Details
// Terrain texture name
StringId terrainNameId = STR_EMPTY;
auto surfaceStyle = tileElement->AsSurface()->GetSurfaceStyleObject();
if (surfaceStyle != nullptr)
terrainNameId = surfaceStyle->NameStringId;
auto ft = Formatter();
ft.Add<StringId>(terrainNameId);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SURFACE_TERAIN, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Edge texture name
StringId terrainEdgeNameId = STR_EMPTY;
auto edgeStyle = tileElement->AsSurface()->GetEdgeStyleObject();
if (edgeStyle != nullptr)
terrainEdgeNameId = edgeStyle->NameStringId;
ft = Formatter();
ft.Add<StringId>(terrainEdgeNameId);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_SURFACE_EDGE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Land ownership
StringId landOwnership;
if (tileElement->AsSurface()->GetOwnership() & OWNERSHIP_OWNED)
landOwnership = STR_LAND_OWNED;
else if (tileElement->AsSurface()->GetOwnership() & OWNERSHIP_AVAILABLE)
landOwnership = STR_LAND_SALE;
else if (tileElement->AsSurface()->GetOwnership() & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED)
landOwnership = STR_CONSTRUCTION_RIGHTS_OWNED;
else if (tileElement->AsSurface()->GetOwnership() & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE)
landOwnership = STR_CONSTRUCTION_RIGHTS_SALE;
else
landOwnership = STR_TILE_INSPECTOR_LAND_NOT_OWNED_AND_NOT_AVAILABLE;
ft = Formatter();
ft.Add<StringId>(landOwnership);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_SURFACE_OWNERSHIP, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Water level
ft = Formatter();
ft.Add<uint32_t>(tileElement->AsSurface()->GetWaterHeight());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_SURFACE_WATER_LEVEL, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
// Properties
// Raise / lower label
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_SURFACE_SPINNER_HEIGHT].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_SURFACE_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Raised corners
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_SURFACE_CHECK_CORNER_E].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SURFACE_CORNERS, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break;
}
case TileElementType::Path:
{
// Details
auto pathEl = tileElement->AsPath();
auto footpathObj = pathEl->GetLegacyPathEntry();
if (footpathObj == nullptr)
{
// Surface name
auto surfaceObj = pathEl->GetSurfaceEntry();
if (surfaceObj != nullptr)
{
auto ft = Formatter();
ft.Add<StringId>(surfaceObj->NameStringId);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_FOOTPATH_SURFACE_NAME, ft, { COLOUR_WHITE });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
// Railings name
auto railingsObj = pathEl->GetRailingsEntry();
if (railingsObj != nullptr)
{
auto ft = Formatter();
ft.Add<StringId>(railingsObj->NameStringId);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_FOOTPATH_RAILINGS_NAME, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ COLOUR_WHITE });
}
}
else
{
// Legacy path name
Rename classes with snakes OpenRCT2/A*-F* (#19215) * Rename classes with snakes OpenRCT2/A*-F* * Clang format files
2023-01-19 09:16:44 +01:00
auto footpathEntry = reinterpret_cast<const FootpathEntry*>(footpathObj->GetLegacyData());
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto ft = Formatter();
ft.Add<StringId>(footpathEntry->string_idx);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_PATH_NAME, ft, { COLOUR_WHITE });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
// Path addition
if (tileElement->AsPath()->HasAddition())
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
ObjectEntry Cleanup. FootpathItem, SceneryGroup, Water, LargeScenery (#19385) * Move footpathitem entry into new getter * Move scenery group entry into new getter * Move water entry into new getter * Move large scenery entry into new getter * Remove unused header includes * Fix compile issue * Include missing header from vcxproj
2023-02-15 22:35:16 +01:00
const auto pathBitEntry = tileElement->AsPath()->GetAdditionEntry();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
StringId additionNameId = pathBitEntry != nullptr ? pathBitEntry->name
: static_cast<StringId>(STR_UNKNOWN_OBJECT_TYPE);
auto ft = Formatter();
ft.Add<StringId>(additionNameId);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 2 * 11 }, STR_TILE_INSPECTOR_PATH_ADDITIONS, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ COLOUR_WHITE });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
}
else
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 2 * 11 }, STR_TILE_INSPECTOR_PATH_ADDITIONS_NONE, {},
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ COLOUR_WHITE });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Properties
// Raise / lower label
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_PATH_SPINNER_HEIGHT].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_PATH_SPINNER_HEIGHT].left + 3;
auto ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Path connections
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_PATH_CHECK_EDGE_W].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_PATH_CONNECTED_EDGES, {}, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
case TileElementType::Track:
{
auto trackElement = tileElement->AsTrack();
RideId id = trackElement->GetRideIndex();
Change openrct2/ride methods to UpperCamelCase, part 1
2023-01-17 01:32:54 +01:00
auto rideTile = GetRide(id);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Ride ID
auto ft = Formatter();
ft.Add<int16_t>(id);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_TRACK_RIDE_ID, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Ride name
if (rideTile != nullptr)
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
ft = Formatter();
rideTile->FormatNameTo(ft);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_TRACK_RIDE_NAME, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
// Ride type. Individual pieces may be of a different ride type from the ride it belongs to.
const auto& rtd = GetRideTypeDescriptor(trackElement->GetRideType());
ft = Formatter();
ft.Add<StringId>(rtd.Naming.Name);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_TRACK_RIDE_TYPE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Track
ft = Formatter();
ft.Add<track_type_t>(trackElement->GetTrackType());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_TRACK_PIECE_ID, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
ft = Formatter();
ft.Add<track_type_t>(trackElement->GetSequenceIndex());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 44 }, STR_TILE_INSPECTOR_TRACK_SEQUENCE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (trackElement->IsStation())
{
auto stationIndex = trackElement->GetStationIndex();
ft = Formatter();
ft.Add<StringId>(STR_COMMA16);
ft.Add<int16_t>(stationIndex.ToUnderlying());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 55 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
}
else
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const char* stationNone = "-";
ft = Formatter();
ft.Add<StringId>(STR_STRING);
ft.Add<char*>(stationNone);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 55 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
ft = Formatter();
ft.Add<StringId>(ColourSchemeNames[trackElement->GetColourScheme()]);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 66 }, STR_TILE_INSPECTOR_COLOUR_SCHEME, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Properties
// Raise / lower label
screenCoords.y = windowPos.y + widgets[WIDX_TRACK_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_TRACK_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::SmallScenery:
{
// Details
// Age
auto ft = Formatter();
ft.Add<int16_t>(tileElement->AsSmallScenery()->GetAge());
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SCENERY_AGE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Quadrant value
const auto* sceneryEntry = tileElement->AsSmallScenery()->GetEntry();
if (sceneryEntry != nullptr && !(sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_FULL_TILE)))
{
int16_t quadrant = tileElement->AsSmallScenery()->GetSceneryQuadrant();
static constexpr StringId _quadrantStringIdx[] = {
STR_TILE_INSPECTOR_SCENERY_QUADRANT_SW,
STR_TILE_INSPECTOR_SCENERY_QUADRANT_NW,
STR_TILE_INSPECTOR_SCENERY_QUADRANT_NE,
STR_TILE_INSPECTOR_SCENERY_QUADRANT_SE,
};
ft = Formatter();
ft.Add<StringId>(_quadrantStringIdx[quadrant]);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_SCENERY_QUADRANT, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
// Scenery ID
ft = Formatter();
ft.Add<ObjectEntryIndex>(tileElement->AsSmallScenery()->GetEntryIndex());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_SCENERY_ENTRY_IDX, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Properties
// Raise / Lower
screenCoords.y = windowPos.y + widgets[WIDX_SCENERY_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_SCENERY_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Quarter tile
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_SCENERY_CHECK_QUARTER_E].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SCENERY_QUADRANT_LABEL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Collision
screenCoords.y = windowPos.y + widgets[WIDX_SCENERY_CHECK_COLLISION_E].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_COLLISSION, {}, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
case TileElementType::Entrance:
{
// Details
// Entrance type
auto ft = Formatter();
ft.Add<StringId>(EntranceTypeStringIds[tileElement->AsEntrance()->GetEntranceType()]);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_ENTRANCE_TYPE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_PARK_ENTRANCE)
{
// TODO: Make this work with Left/Right park entrance parts
ft = Formatter();
Remove snakes from entrance
2022-10-04 08:38:00 +02:00
ft.Add<StringId>(ParkEntranceGetIndex({ _toolMap, tileElement->GetBaseZ() }));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
else
{
ft = Formatter();
ft.Add<int16_t>(tileElement->AsEntrance()->GetStationIndex().ToUnderlying());
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_RIDE_ENTRANCE)
{
// Ride entrance ID
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
else
{
// Ride exit ID
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_EXIT_ID, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
}
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_PARK_ENTRANCE)
{
// Entrance part
ft = Formatter();
ft.Add<StringId>(ParkEntrancePartStringIds[tileElement->AsEntrance()->GetSequenceIndex()]);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRANCE_PART, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
else
{
// Ride ID
ft = Formatter();
ft.Add<RideId>(tileElement->AsEntrance()->GetRideIndex());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRANCE_RIDE_ID, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
// Station index
auto stationIndex = tileElement->AsEntrance()->GetStationIndex();
ft = Formatter();
ft.Add<StringId>(STR_COMMA16);
ft.Add<int16_t>(stationIndex.ToUnderlying());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
// Properties
// Raise / Lower
screenCoords.y = windowPos.y + widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Wall:
{
// Details
// Type
auto ft = Formatter();
ft.Add<ObjectEntryIndex>(tileElement->AsWall()->GetEntryIndex());
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_TYPE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Banner info
auto banner = tileElement->AsWall()->GetBanner();
if (banner != nullptr)
{
ft = Formatter();
banner->FormatTextTo(ft);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
else
{
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, {},
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
// Properties
// Raise / lower label
screenCoords.y = windowPos.y + widgets[WIDX_WALL_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_WALL_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Slope label
screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_GROUPBOX_DETAILS].left + 7, widgets[WIDX_WALL_DROPDOWN_SLOPE].top };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_SLOPE, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Animation frame label
screenCoords.y = windowPos.y + widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_ANIMATION_FRAME, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current animation frame
colour_t colour = colours[1];
if (IsWidgetDisabled(WIDX_WALL_SPINNER_ANIMATION_FRAME))
{
colour = colours[0] | COLOUR_FLAG_INSET;
}
screenCoords.x = windowPos.x + widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].left + 3;
ft = Formatter();
ft.Add<int32_t>(tileElement->AsWall()->GetAnimationFrame());
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colour });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
case TileElementType::LargeScenery:
{
// Details
// Type
auto sceneryElement = tileElement->AsLargeScenery();
ObjectEntryIndex largeSceneryType = sceneryElement->GetEntryIndex();
auto ft = Formatter();
ft.Add<ObjectEntryIndex>(largeSceneryType);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_LARGE_SCENERY_TYPE, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Part ID
ft = Formatter();
ft.Add<int16_t>(sceneryElement->GetSequenceIndex());
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_LARGE_SCENERY_PIECE_ID, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
// Banner info
ObjectEntry Cleanup. FootpathItem, SceneryGroup, Water, LargeScenery (#19385) * Move footpathitem entry into new getter * Move scenery group entry into new getter * Move water entry into new getter * Move large scenery entry into new getter * Remove unused header includes * Fix compile issue * Include missing header from vcxproj
2023-02-15 22:35:16 +01:00
auto* largeSceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<LargeSceneryEntry>(largeSceneryType);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (largeSceneryEntry != nullptr && largeSceneryEntry->scrolling_mode != SCROLLING_MODE_NONE)
{
auto banner = sceneryElement->GetBanner();
if (banner != nullptr)
{
ft = Formatter();
banner->FormatTextTo(ft);
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft,
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
}
else
{
DrawTextBasic(
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, {},
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{ colours[1] });
}
// Properties
// Raise / lower label
screenCoords.y = windowPos.y + widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].left + 3;
ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
case TileElementType::Banner:
{
// Details
// Banner info
auto banner = tileElement->AsBanner()->GetBanner();
if (banner != nullptr)
{
Formatter ft;
banner->FormatTextTo(ft);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
// Properties
// Raise / lower label
screenCoords.y = windowPos.y + widgets[WIDX_BANNER_SPINNER_HEIGHT].top;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Current base height
screenCoords.x = windowPos.x + widgets[WIDX_BANNER_SPINNER_HEIGHT].left + 3;
auto ft = Formatter();
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Blocked paths
screenCoords.y += 28;
screenCoords.x = windowPos.x + widgets[WIDX_GROUPBOX_DETAILS].left + 7;
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BANNER_BLOCKED_PATHS, {}, { colours[1] });
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break;
}
default:
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
}
}
Rename classes with snakes OpenRCT2/A*-F* (#19215) * Rename classes with snakes OpenRCT2/A*-F* * Clang format files
2023-01-19 09:16:44 +01:00
void OnScrollDraw(int32_t scrollIndex, DrawPixelInfo& dpi) override
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{
const int32_t listWidth = widgets[WIDX_LIST].width();
Remove snake_case from first chunk of Drawing (#19164) * Remove snake_case from first chunk of Drawing * Address formatting
2023-01-16 14:50:43 +01:00
GfxFillRect(
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
&dpi, { { dpi.x, dpi.y }, { dpi.x + dpi.width - 1, dpi.y + dpi.height - 1 } }, ColourMapA[colours[1]].mid_light);
// Show usage hint when nothing is selected
if (!_tileSelected)
{
auto& listWidget = widgets[WIDX_LIST];
auto centrePos = ScreenCoordsXY{ listWidget.width() / 2,
Finish Removing snake_case from Drawing Methods
2023-01-16 23:31:34 +01:00
(listWidget.height() - FontGetLineHeight(FontStyle::Medium)) / 2 };
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto ft = Formatter{};
auto textPaint = TextPaint{ colours[1], TextAlignment::CENTRE };
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextWrapped(dpi, centrePos, listWidth, STR_TILE_INSPECTOR_SELECT_TILE_HINT, ft, textPaint);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
return;
}
ScreenCoordsXY screenCoords{};
screenCoords.y = SCROLLABLE_ROW_HEIGHT * (windowTileInspectorElementCount - 1);
int32_t i = 0;
char buffer[256];
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Code style: Remove snakes from everything world apart from Map.h (#18273) * Remove remaining snakes from world (outside of map) * Initial few desnaking of Map.h
2022-10-11 20:39:24 +02:00
const TileElement* tileElement = MapGetFirstElementAt(_toolMap);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
do
{
if (tileElement == nullptr)
break;
const bool selectedRow = i == windowTileInspectorSelectedIndex;
const bool hoveredRow = i == _highlightedIndex;
const char* typeName = "";
// Draw row background colour
auto fillRectangle = ScreenRect{ { 0, screenCoords.y }, { listWidth, screenCoords.y + SCROLLABLE_ROW_HEIGHT - 1 } };
if (selectedRow)
Remove snake_case from first chunk of Drawing (#19164) * Remove snake_case from first chunk of Drawing * Address formatting
2023-01-16 14:50:43 +01:00
GfxFillRect(&dpi, fillRectangle, ColourMapA[colours[1]].mid_dark);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
else if (hoveredRow)
Remove snake_case from first chunk of Drawing (#19164) * Remove snake_case from first chunk of Drawing * Address formatting
2023-01-16 14:50:43 +01:00
GfxFillRect(&dpi, fillRectangle, ColourMapA[colours[1]].mid_dark | 0x1000000);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Zebra stripes
else if (((windowTileInspectorElementCount - i) & 1) == 0)
Remove snake_case from first chunk of Drawing (#19164) * Remove snake_case from first chunk of Drawing * Address formatting
2023-01-16 14:50:43 +01:00
GfxFillRect(&dpi, fillRectangle, ColourMapA[colours[1]].light | 0x1000000);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const StringId stringFormat = (selectedRow || hoveredRow) ? STR_WHITE_STRING : STR_WINDOW_COLOUR_2_STRINGID;
auto checkboxFormatter = Formatter();
checkboxFormatter.Add<StringId>(STR_STRING);
checkboxFormatter.Add<char*>(CheckBoxMarkString);
// Draw checkbox and check if visible
Remove snake_case from first chunk of Drawing (#19164) * Remove snake_case from first chunk of Drawing * Address formatting
2023-01-16 14:50:43 +01:00
GfxFillRectInset(&dpi, { { 2, screenCoords.y }, { 15, screenCoords.y + 11 } }, colours[1], INSET_RECT_F_E0);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (!tileElement->IsInvisible())
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto eyeFormatter = Formatter();
eyeFormatter.Add<StringId>(STR_STRING);
eyeFormatter.Add<char*>(EyeString);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 2, 1 }, stringFormat, eyeFormatter);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
const auto type = tileElement->GetType();
switch (type)
{
case TileElementType::Surface:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
typeName = LanguageGetString(STR_TILE_INSPECTOR_SURFACE);
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Path:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
typeName = tileElement->AsPath()->IsQueue() ? LanguageGetString(STR_QUEUE_LINE_MAP_TIP)
: LanguageGetString(STR_FOOTPATH_MAP_TIP);
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Track:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
typeName = LanguageGetString(STR_RIDE_COMPONENT_TRACK_CAPITALISED);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break;
case TileElementType::SmallScenery:
Fix #9029: Set animation frame on doors using the tile inspector (#11206)
2020-04-18 12:43:46 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const auto* sceneryEntry = tileElement->AsSmallScenery()->GetEntry();
snprintf(
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
buffer, sizeof(buffer), "%s (%s)", LanguageGetString(STR_OBJECT_SELECTION_SMALL_SCENERY),
sceneryEntry != nullptr ? LanguageGetString(sceneryEntry->name) : "");
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
typeName = buffer;
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Fix #9029: Set animation frame on doors using the tile inspector (#11206)
2020-04-18 12:43:46 +02:00
}
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Entrance:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
typeName = LanguageGetString(STR_RIDE_CONSTRUCTION_ENTRANCE);
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Wall:
{
const auto* entry = tileElement->AsWall()->GetEntry();
snprintf(
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
buffer, sizeof(buffer), "%s (%s)", LanguageGetString(STR_TILE_INSPECTOR_WALL),
entry != nullptr ? LanguageGetString(entry->name) : "");
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
typeName = buffer;
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::LargeScenery:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
typeName = LanguageGetString(STR_OBJECT_SELECTION_LARGE_SCENERY);
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Banner:
snprintf(
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
buffer, sizeof(buffer), "%s (%u)", LanguageGetString(STR_BANNER_WINDOW_TITLE),
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
tileElement->AsBanner()->GetIndex().ToUnderlying());
typeName = buffer;
Allow holding down spinners in tile inspector (#7647) This basically moves much of the event handling from mouseup to mousedown, and adds a new array with widget indices for the spinners. This automatically enables scrolling for them as well.
2018-06-10 18:55:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
default:
Rename snake_case functions from localisation folder
2023-01-17 00:12:35 +01:00
snprintf(buffer, sizeof(buffer), "%s (%d)", LanguageGetString(STR_UNKNOWN_OBJECT_TYPE), EnumValue(type));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
typeName = buffer;
}
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
const int32_t clearanceHeight = tileElement->ClearanceHeight;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const bool ghost = tileElement->IsGhost();
const bool last = tileElement->IsLastForTile();
// Element name
auto ft = Formatter();
ft.Add<StringId>(STR_STRING);
ft.Add<char*>(typeName);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextEllipsised(dpi, screenCoords + ScreenCoordsXY{ TypeColumnXY.x, 0 }, TypeColumnSize.width, stringFormat, ft);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Base height
ft = Formatter();
ft.Add<StringId>(STR_FORMAT_INTEGER);
Rename base_height, clearance_height and owner
2023-01-19 20:36:30 +01:00
ft.Add<int32_t>(tileElement->BaseHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ BaseHeightColumnXY.x, 0 }, stringFormat, ft);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Clearance height
ft = Formatter();
ft.Add<StringId>(STR_FORMAT_INTEGER);
ft.Add<int32_t>(clearanceHeight);
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ ClearanceHeightColumnXY.x, 0 }, stringFormat, ft);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Direction
ft = Formatter();
ft.Add<StringId>(STR_FORMAT_INTEGER);
ft.Add<int32_t>(tileElement->GetDirection());
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ DirectionColumnXY.x, 0 }, stringFormat, ft);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Checkmarks for ghost and last for tile
if (ghost)
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ GhostFlagColumnXY.x, 0 }, stringFormat, checkboxFormatter);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (last)
Pass DPI by ref to string drawing
2023-02-24 22:05:07 +01:00
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ LastFlagColumnXY.x, 0 }, stringFormat, checkboxFormatter);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
screenCoords.y -= SCROLLABLE_ROW_HEIGHT;
i++;
} while (!(tileElement++)->IsLastForTile());
Avoid referencing null tile elements or derivations
2021-03-03 22:06:07 +01:00
}
Add dropdown for changing fence slopes
2016-10-01 22:57:09 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void ClearClipboard()
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
_elementCopied = false;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
private:
void SetPage(const TileInspectorPage p)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Invalidate();
// subtract current page height, then add new page height
if (tileInspectorPage != TileInspectorPage::Default)
{
auto index = EnumValue(tileInspectorPage) - 1;
height -= PageGroupBoxSettings[index].details_top_offset - GROUPBOX_PADDING - 3;
min_height -= PageGroupBoxSettings[index].details_top_offset - GROUPBOX_PADDING - 3;
}
if (p != TileInspectorPage::Default)
{
auto index = EnumValue(p) - 1;
height += PageGroupBoxSettings[index].details_top_offset - GROUPBOX_PADDING - 3;
min_height += PageGroupBoxSettings[index].details_top_offset - GROUPBOX_PADDING - 3;
}
tileInspectorPage = p;
auto pageIndex = EnumValue(p);
widgets = PageWidgets[pageIndex];
hold_down_widgets = PageHoldDownWidgets[pageIndex];
disabled_widgets = PageDisabledWidgets[pageIndex];
pressed_widgets = 0;
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void UpdateSelectedTile(const ScreenCoordsXY& screenCoords)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const bool ctrlIsHeldDown = InputTestPlaceObjectModifier(PLACE_OBJECT_MODIFIER_COPY_Z);
// Mouse hasn't moved
if (screenCoords.x == _toolMouseX && screenCoords.y == _toolMouseY && _toolCtrlDown == ctrlIsHeldDown)
return;
_toolMouseX = screenCoords.x;
_toolMouseY = screenCoords.y;
_toolCtrlDown = ctrlIsHeldDown;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
CoordsXY mapCoords{};
TileElement* clickedElement = nullptr;
if (ctrlIsHeldDown)
Close #12444: Refactor TILE_INSPECTOR_PAGE to use strong enum (#13134)
2021-01-03 14:30:59 +01:00
{
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
auto info = GetMapCoordinatesFromPos(screenCoords, ViewportInteractionFlags);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
clickedElement = info.Element;
mapCoords = info.Loc;
Close #12444: Refactor TILE_INSPECTOR_PAGE to use strong enum (#13134)
2021-01-03 14:30:59 +01:00
}
Add dropdown for changing fence slopes
2016-10-01 22:57:09 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Even if Ctrl was pressed, fall back to normal selection when there was nothing under the cursor
if (clickedElement == nullptr)
{
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
auto mouseCoords = ScreenPosToMapPos(screenCoords, nullptr);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (!mouseCoords.has_value())
return;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
mapCoords = mouseCoords.value();
// Tile is already selected
if (_tileSelected && mapCoords.x == _toolMap.x && mapCoords.y == _toolMap.y)
return;
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
_tileSelected = true;
_toolMap = mapCoords;
windowTileInspectorTile = TileCoordsXY(mapCoords);
OpenRCT2::TileInspector::SetSelectedElement(clickedElement);
LoadTile(clickedElement);
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void SelectElementFromList(int32_t index)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (index < 0 || index >= windowTileInspectorElementCount)
Fix #10410: Tile Inspector does not hightlight tile correctly Mistake made when refactoring not passing the error up through the chain and silently working.
2019-12-22 13:59:24 +01:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
windowTileInspectorSelectedIndex = -1;
OpenRCT2::TileInspector::SetSelectedElement(nullptr);
}
else
{
windowTileInspectorSelectedIndex = index;
const TileElement* const tileElement = GetSelectedElement();
OpenRCT2::TileInspector::SetSelectedElement(tileElement);
Fix #10410: Tile Inspector does not hightlight tile correctly Mistake made when refactoring not passing the error up through the chain and silently working.
2019-12-22 13:59:24 +01:00
}
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void LoadTile(TileElement* elementToSelect)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
windowTileInspectorSelectedIndex = -1;
scrolls[0].v_top = 0;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Code style: Remove snakes from everything world apart from Map.h (#18273) * Remove remaining snakes from world (outside of map) * Initial few desnaking of Map.h
2022-10-11 20:39:24 +02:00
TileElement* element = MapGetFirstElementAt(_toolMap);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
int16_t numItems = 0;
do
{
if (element == nullptr)
break;
if (element == elementToSelect)
windowTileInspectorSelectedIndex = numItems;
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
numItems++;
} while (!(element++)->IsLastForTile());
windowTileInspectorElementCount = numItems;
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void RemoveElement(int32_t elementIndex)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
openrct2_assert(elementIndex >= 0 && elementIndex < windowTileInspectorElementCount, "elementIndex out of range");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnyRemove, elementIndex);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void RotateElement(int32_t elementIndex)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
openrct2_assert(elementIndex >= 0 && elementIndex < windowTileInspectorElementCount, "elementIndex out of range");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnyRotate, elementIndex);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Swap element with its parent
void SwapElements(int16_t first, int16_t second)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
bool firstInRange = first >= 0 && first < windowTileInspectorElementCount;
bool secondInRange = second >= 0 && second < windowTileInspectorElementCount;
// This might happen if two people are modifying the same tile.
if (!firstInRange || !secondInRange)
Add Ctrl + Click to select tile elements Co-authored-by: wolfreak99 <jbminor1991@gmail.com>
2018-05-21 22:34:42 +02:00
return;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnySwap, first, second);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void SortElements()
{
openrct2_assert(_tileSelected, "No tile selected");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnySort);
GameActions::Execute(&modifyTile);
}
Recreated UI for tile inspector. Added swap functionality.
2015-12-28 23:11:36 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void CopyElement()
{
// Copy value, in case the element gets moved
_copiedElement = *GetSelectedElement();
_elementCopied = true;
Fix invalidation issues
2022-07-02 23:02:55 +02:00
Invalidate();
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void PasteElement()
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnyPaste, 0, 0, _copiedElement);
GameActions::Execute(&modifyTile);
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void BaseHeightOffset(int16_t elementIndex, int8_t heightOffset)
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnyBaseHeightOffset, elementIndex, heightOffset);
GameActions::Execute(&modifyTile);
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
}
Added sort button, cleaned up page switching.
2016-06-11 19:39:51 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void SurfaceShowParkFences(bool showFences)
{
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::SurfaceShowParkFences, showFences);
GameActions::Execute(&modifyTile);
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void SurfaceToggleCorner(int32_t cornerIndex)
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::SurfaceToggleCorner, cornerIndex);
GameActions::Execute(&modifyTile);
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
}
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void SurfaceToggleDiagonal()
{
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::SurfaceToggleDiagonal);
GameActions::Execute(&modifyTile);
}
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void PathSetSloped(int32_t elementIndex, bool sloped)
{
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::PathSetSlope, elementIndex, sloped);
GameActions::Execute(&modifyTile);
}
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
void PathSetJunctionRailings(int32_t elementIndex, bool hasJunctionRailings)
{
auto modifyTile = TileModifyAction(
_toolMap, TileModifyType::PathSetJunctionRailings, elementIndex, hasJunctionRailings);
GameActions::Execute(&modifyTile);
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void PathSetBroken(int32_t elementIndex, bool broken)
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::PathSetBroken, elementIndex, broken);
GameActions::Execute(&modifyTile);
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void PathToggleEdge(int32_t elementIndex, int32_t cornerIndex)
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
openrct2_assert(elementIndex >= 0 && elementIndex < windowTileInspectorElementCount, "elementIndex out of range");
openrct2_assert(cornerIndex >= 0 && cornerIndex < 8, "cornerIndex out of range");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::PathToggleEdge, elementIndex, cornerIndex);
GameActions::Execute(&modifyTile);
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void EntranceMakeUsable(int32_t elementIndex)
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Guard::ArgumentInRange(elementIndex, 0, windowTileInspectorElementCount - 1);
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::EntranceMakeUsable, elementIndex);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void WallSetSlope(int32_t elementIndex, int32_t slopeValue)
#5832 Resize tile inspector automatically when selecting a tile element
2018-05-21 14:09:18 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Make sure only the correct bits are set
openrct2_assert((slopeValue & 3) == slopeValue, "slopeValue doesn't match its mask");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::WallSetSlope, elementIndex, slopeValue);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void WallAnimationFrameOffset(int16_t elementIndex, int8_t animationFrameOffset)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::WallSetAnimationFrame, elementIndex, animationFrameOffset);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void TrackBlockHeightOffset(int32_t elementIndex, int8_t heightOffset)
{
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::TrackBaseHeightOffset, elementIndex, heightOffset);
GameActions::Execute(&modifyTile);
}
clang-format UI windows
2018-06-22 23:21:44 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void TrackBlockSetLift(int32_t elementIndex, bool entireTrackBlock, bool chain)
Automatically set the correct page Instead of having to set the page and setup the widgets correctly when a new elements gets selected, it now switches automatically on invalidation to the correct tab. This fixes the issue where pasted elements were selected but the page for them not shown, and removes two of the intents that were made for the tile inspector.
2018-05-21 19:11:14 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(
_toolMap, entireTrackBlock ? TileModifyType::TrackSetChainBlock : TileModifyType::TrackSetChain, elementIndex,
chain);
GameActions::Execute(&modifyTile);
}
Fix #14102: NPE in window_tile_inspector_invalidate()
2021-03-03 10:21:49 +01:00
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
void TrackSetBrakeClosed(int32_t elementIndex, bool isClosed)
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::TrackSetBrake, elementIndex, isClosed);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void TrackSetIndestructible(int32_t elementIndex, bool isIndestructible)
{
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::TrackSetIndestructible, elementIndex, isIndestructible);
GameActions::Execute(&modifyTile);
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void QuarterTileSet(int32_t elementIndex, const int32_t quarterIndex)
{
// quarterIndex is widget index relative to WIDX_SCENERY_CHECK_QUARTER_N, so a value from 0-3
openrct2_assert(quarterIndex >= 0 && quarterIndex < 4, "quarterIndex out of range");
auto modifyTile = TileModifyAction(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
_toolMap, TileModifyType::ScenerySetQuarterLocation, elementIndex, (quarterIndex - GetCurrentRotation()) & 3);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
GameActions::Execute(&modifyTile);
}
Close #11561: Use ScreenCoordsXY in gfx_draw_string() * Fix #11572 create gfx_draw_string() overload created the overload and changed all calls of the old function to the new (using const ScreenCoordsXY&) ...
2020-05-10 14:49:15 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// ToggleQuadrantCollision?
void ToggleQuadrantCollosion(int32_t elementIndex, const int32_t quadrantIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
_toolMap, TileModifyType::ScenerySetQuarterCollision, elementIndex, (quadrantIndex + 2 - GetCurrentRotation()) & 3);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void BannerToggleBlock(int32_t elementIndex, int32_t edgeIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
openrct2_assert(edgeIndex >= 0 && edgeIndex < 4, "edgeIndex out of range");
// Make edgeIndex abstract
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
edgeIndex = (edgeIndex - GetCurrentRotation()) & 3;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::BannerToggleBlockingEdge, elementIndex, edgeIndex);
GameActions::Execute(&modifyTile);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void ToggleInvisibility(int32_t elementIndex)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
openrct2_assert(elementIndex >= 0 && elementIndex < windowTileInspectorElementCount, "elementIndex out of range");
auto modifyTile = TileModifyAction(_toolMap, TileModifyType::AnyToggleInvisilibity, elementIndex);
GameActions::Execute(&modifyTile);
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
TileElement* GetSelectedElement()
{
openrct2_assert(
windowTileInspectorSelectedIndex >= 0 && windowTileInspectorSelectedIndex < windowTileInspectorElementCount,
"Selected list item out of range");
Code style: Remove snakes from everything world apart from Map.h (#18273) * Remove remaining snakes from world (outside of map) * Initial few desnaking of Map.h
2022-10-11 20:39:24 +02:00
return MapGetFirstElementAt(_toolMap) + windowTileInspectorSelectedIndex;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Fix invalidation issues
2022-07-02 23:02:55 +02:00
void OnPrepareDraw() override
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{
// Set the correct page automatically
TileInspectorPage p = TileInspectorPage::Default;
if (windowTileInspectorSelectedIndex != -1)
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
const auto element = GetSelectedElement();
switch (element->GetType())
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
default:
case TileElementType::Surface:
p = TileInspectorPage::Surface;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Path:
p = TileInspectorPage::Path;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Track:
p = TileInspectorPage::Track;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::SmallScenery:
p = TileInspectorPage::Scenery;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Entrance:
p = TileInspectorPage::Entrance;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Wall:
p = TileInspectorPage::Wall;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::LargeScenery:
p = TileInspectorPage::LargeScenery;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
case TileElementType::Banner:
p = TileInspectorPage::Banner;
break;
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (tileInspectorPage != p)
{
SetPage(p);
Invalidate();
Avoid referencing null tile elements or derivations
2021-03-03 22:06:07 +01:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// X and Y spinners
SetWidgetDisabled(WIDX_SPINNER_X_INCREASE, !(_tileSelected && ((_toolMap.x / 32) < MAXIMUM_MAP_SIZE_TECHNICAL - 1)));
SetWidgetDisabled(WIDX_SPINNER_X_DECREASE, !(_tileSelected && ((_toolMap.x / 32) > 0)));
SetWidgetDisabled(WIDX_SPINNER_Y_INCREASE, !(_tileSelected && ((_toolMap.y / 32) < MAXIMUM_MAP_SIZE_TECHNICAL - 1)));
SetWidgetDisabled(WIDX_SPINNER_Y_DECREASE, !(_tileSelected && ((_toolMap.y / 32) > 0)));
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Sort buttons
SetWidgetDisabled(WIDX_BUTTON_SORT, !(_tileSelected && windowTileInspectorElementCount > 1));
Adjust list style to match other lists - No odd/even checked colours - Black text (white on hover) - Darker background - Solid fill background for hovered and selected element
2018-05-21 13:46:55 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Move Up button
SetWidgetDisabled(
WIDX_BUTTON_MOVE_UP,
!(windowTileInspectorSelectedIndex != -1
&& windowTileInspectorSelectedIndex < windowTileInspectorElementCount - 1));
InvalidateWidget(WIDX_BUTTON_MOVE_UP);
Show Tile Inspector hint when nothing is selected
2022-05-07 15:42:24 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Move Down button
SetWidgetDisabled(WIDX_BUTTON_MOVE_DOWN, !(windowTileInspectorSelectedIndex > 0));
InvalidateWidget(WIDX_BUTTON_MOVE_DOWN);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Copy button
SetWidgetDisabled(WIDX_BUTTON_COPY, !(windowTileInspectorSelectedIndex >= 0));
InvalidateWidget(WIDX_BUTTON_COPY);
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Paste button
SetWidgetDisabled(WIDX_BUTTON_PASTE, !(_tileSelected && _elementCopied));
InvalidateWidget(WIDX_BUTTON_PASTE);
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_BACKGROUND].bottom = height - 1;
Adjust list style to match other lists - No odd/even checked colours - Black text (white on hover) - Darker background - Solid fill background for hovered and selected element
2018-05-21 13:46:55 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (tileInspectorPage == TileInspectorPage::Default)
Adjust list style to match other lists - No odd/even checked colours - Black text (white on hover) - Darker background - Solid fill background for hovered and selected element
2018-05-21 13:46:55 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_GROUPBOX_DETAILS].type = WindowWidgetType::Empty;
widgets[WIDX_GROUPBOX_PROPERTIES].type = WindowWidgetType::Empty;
widgets[WIDX_LIST].bottom = height - PADDING_BOTTOM;
Adjust list style to match other lists - No odd/even checked colours - Black text (white on hover) - Darker background - Solid fill background for hovered and selected element
2018-05-21 13:46:55 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
else
Re-add zebra stripes and light text
2018-05-22 21:54:09 +02:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_GROUPBOX_DETAILS].type = WindowWidgetType::Groupbox;
widgets[WIDX_GROUPBOX_PROPERTIES].type = WindowWidgetType::Groupbox;
auto pageIndex = EnumValue(tileInspectorPage) - 1;
widgets[WIDX_GROUPBOX_DETAILS].text = PageGroupBoxSettings[pageIndex].string_id;
widgets[WIDX_GROUPBOX_DETAILS].top = height - PageGroupBoxSettings[pageIndex].details_top_offset;
widgets[WIDX_GROUPBOX_DETAILS].bottom = height - PageGroupBoxSettings[pageIndex].details_bottom_offset;
widgets[WIDX_GROUPBOX_PROPERTIES].top = height - PageGroupBoxSettings[pageIndex].properties_top_offset;
widgets[WIDX_GROUPBOX_PROPERTIES].bottom = height - PageGroupBoxSettings[pageIndex].properties_bottom_offset;
widgets[WIDX_LIST].bottom = widgets[WIDX_GROUPBOX_DETAILS].top - GROUPBOX_PADDING;
Re-add zebra stripes and light text
2018-05-22 21:54:09 +02:00
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// The default page doesn't need further invalidation
if (tileInspectorPage == TileInspectorPage::Default)
return;
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Using a switch, because I don't think giving each page their own callbacks is
// needed here, as only the mouseup and invalidate functions are different.
const int32_t propertiesAnchor = widgets[WIDX_GROUPBOX_PROPERTIES].top;
const TileElement* const tileElement = GetSelectedElement();
if (tileElement == nullptr)
return;
Replace visibility button with checkboxes per element
2021-11-25 23:52:24 +01:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
switch (tileElement->GetType())
clang-format UI windows
2018-06-22 23:21:44 +02:00
{
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Surface:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_SURFACE_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_SURFACE_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_SURFACE_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_SURFACE_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_SURFACE_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_SURFACE_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_SURFACE_BUTTON_REMOVE_FENCES].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_SURFACE_BUTTON_REMOVE_FENCES].bottom = GBBB(propertiesAnchor, 1);
widgets[WIDX_SURFACE_BUTTON_RESTORE_FENCES].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_SURFACE_BUTTON_RESTORE_FENCES].bottom = GBBB(propertiesAnchor, 1);
widgets[WIDX_SURFACE_CHECK_CORNER_N].top = GBBT(propertiesAnchor, 2) + 7 * 0;
widgets[WIDX_SURFACE_CHECK_CORNER_N].bottom = widgets[WIDX_SURFACE_CHECK_CORNER_N].top + 13;
widgets[WIDX_SURFACE_CHECK_CORNER_E].top = GBBT(propertiesAnchor, 2) + 7 * 1;
widgets[WIDX_SURFACE_CHECK_CORNER_E].bottom = widgets[WIDX_SURFACE_CHECK_CORNER_E].top + 13;
widgets[WIDX_SURFACE_CHECK_CORNER_S].top = GBBT(propertiesAnchor, 2) + 7 * 2;
widgets[WIDX_SURFACE_CHECK_CORNER_S].bottom = widgets[WIDX_SURFACE_CHECK_CORNER_S].top + 13;
widgets[WIDX_SURFACE_CHECK_CORNER_W].top = GBBT(propertiesAnchor, 2) + 7 * 1;
widgets[WIDX_SURFACE_CHECK_CORNER_W].bottom = widgets[WIDX_SURFACE_CHECK_CORNER_W].top + 13;
widgets[WIDX_SURFACE_CHECK_DIAGONAL].top = GBBT(propertiesAnchor, 3) + 7 * 1;
widgets[WIDX_SURFACE_CHECK_DIAGONAL].bottom = widgets[WIDX_SURFACE_CHECK_DIAGONAL].top + 13;
SetCheckboxValue(
WIDX_SURFACE_CHECK_CORNER_N,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
tileElement->AsSurface()->GetSlope() & (1 << ((2 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_SURFACE_CHECK_CORNER_E,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
tileElement->AsSurface()->GetSlope() & (1 << ((3 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_SURFACE_CHECK_CORNER_S,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
tileElement->AsSurface()->GetSlope() & (1 << ((0 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_SURFACE_CHECK_CORNER_W,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
tileElement->AsSurface()->GetSlope() & (1 << ((1 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_SURFACE_CHECK_DIAGONAL, tileElement->AsSurface()->GetSlope() & TILE_ELEMENT_SLOPE_DOUBLE_HEIGHT);
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Path:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_PATH_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_PATH_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_PATH_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_PATH_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_PATH_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_PATH_CHECK_BROKEN].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_PATH_CHECK_BROKEN].bottom = GBBB(propertiesAnchor, 1);
widgets[WIDX_PATH_CHECK_SLOPED].top = GBBT(propertiesAnchor, 2);
widgets[WIDX_PATH_CHECK_SLOPED].bottom = GBBB(propertiesAnchor, 2);
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_JUNCTION_RAILINGS].top = GBBT(propertiesAnchor, 3);
widgets[WIDX_PATH_CHECK_JUNCTION_RAILINGS].bottom = GBBB(propertiesAnchor, 3);
widgets[WIDX_PATH_CHECK_EDGE_N].top = GBBT(propertiesAnchor, 4) + 7 * 0;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_N].bottom = widgets[WIDX_PATH_CHECK_EDGE_N].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_NE].top = GBBT(propertiesAnchor, 4) + 7 * 1;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_NE].bottom = widgets[WIDX_PATH_CHECK_EDGE_NE].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_E].top = GBBT(propertiesAnchor, 4) + 7 * 2;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_E].bottom = widgets[WIDX_PATH_CHECK_EDGE_E].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_SE].top = GBBT(propertiesAnchor, 4) + 7 * 3;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_SE].bottom = widgets[WIDX_PATH_CHECK_EDGE_SE].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_S].top = GBBT(propertiesAnchor, 4) + 7 * 4;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_S].bottom = widgets[WIDX_PATH_CHECK_EDGE_S].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_SW].top = GBBT(propertiesAnchor, 4) + 7 * 3;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_SW].bottom = widgets[WIDX_PATH_CHECK_EDGE_SW].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_W].top = GBBT(propertiesAnchor, 4) + 7 * 2;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_W].bottom = widgets[WIDX_PATH_CHECK_EDGE_W].top + 13;
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
widgets[WIDX_PATH_CHECK_EDGE_NW].top = GBBT(propertiesAnchor, 4) + 7 * 1;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_PATH_CHECK_EDGE_NW].bottom = widgets[WIDX_PATH_CHECK_EDGE_NW].top + 13;
SetCheckboxValue(WIDX_PATH_CHECK_SLOPED, tileElement->AsPath()->IsSloped());
Fix #19503. Hide 3+ queue junction railings behind a flag (#19644) * Fix #19503. Hide 3+ queue junction railings behind a flag This is to prevent existing parks from changing their behaviour * Clang format * Bump version numbers. Update changelog * Update text
2023-03-23 09:16:32 +01:00
SetCheckboxValue(WIDX_PATH_CHECK_JUNCTION_RAILINGS, tileElement->AsPath()->HasJunctionRailings());
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(WIDX_PATH_CHECK_BROKEN, tileElement->AsPath()->IsBroken());
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_NE, tileElement->AsPath()->GetEdges() & (1 << ((0 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_SE, tileElement->AsPath()->GetEdges() & (1 << ((1 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_SW, tileElement->AsPath()->GetEdges() & (1 << ((2 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_NW, tileElement->AsPath()->GetEdges() & (1 << ((3 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_E, tileElement->AsPath()->GetCorners() & (1 << ((0 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_S, tileElement->AsPath()->GetCorners() & (1 << ((1 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_W, tileElement->AsPath()->GetCorners() & (1 << ((2 - GetCurrentRotation()) & 3)));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
WIDX_PATH_CHECK_EDGE_N, tileElement->AsPath()->GetCorners() & (1 << ((3 - GetCurrentRotation()) & 3)));
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Track:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_TRACK_CHECK_APPLY_TO_ALL].top = GBBT(propertiesAnchor, 0);
widgets[WIDX_TRACK_CHECK_APPLY_TO_ALL].bottom = GBBB(propertiesAnchor, 0);
widgets[WIDX_TRACK_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 1) + 3;
widgets[WIDX_TRACK_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 1) - 3;
widgets[WIDX_TRACK_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 1) + 4;
widgets[WIDX_TRACK_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 1) - 4;
widgets[WIDX_TRACK_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 1) + 4;
widgets[WIDX_TRACK_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 1) - 4;
widgets[WIDX_TRACK_CHECK_CHAIN_LIFT].top = GBBT(propertiesAnchor, 2);
widgets[WIDX_TRACK_CHECK_CHAIN_LIFT].bottom = GBBB(propertiesAnchor, 2);
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
widgets[WIDX_TRACK_CHECK_BRAKE_CLOSED].top = GBBT(propertiesAnchor, 3);
widgets[WIDX_TRACK_CHECK_BRAKE_CLOSED].bottom = GBBB(propertiesAnchor, 3);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE].top = GBBT(propertiesAnchor, 4);
widgets[WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE].bottom = GBBB(propertiesAnchor, 4);
SetCheckboxValue(WIDX_TRACK_CHECK_APPLY_TO_ALL, _applyToAll);
SetCheckboxValue(WIDX_TRACK_CHECK_CHAIN_LIFT, tileElement->AsTrack()->HasChain());
Rename GetBrakeClosed() to IsBrakeClosed()
2022-12-31 14:06:22 +01:00
SetCheckboxValue(WIDX_TRACK_CHECK_BRAKE_CLOSED, tileElement->AsTrack()->IsBrakeClosed());
widgets[WIDX_TRACK_CHECK_BRAKE_CLOSED].content = tileElement->AsTrack()->IsBlockStart()
? STR_TILE_INSPECTOR_TRACK_BLOCK_BRAKE
: STR_TILE_INSPECTOR_TRACK_BRAKE_CLOSED;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(WIDX_TRACK_CHECK_IS_INDESTRUCTIBLE, tileElement->AsTrack()->IsIndestructible());
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::SmallScenery:
Fix #14032: NPE in window_tile_inspector_scrollpaint()
2021-02-09 23:02:31 +01:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
// Raise / Lower
widgets[WIDX_SCENERY_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_SCENERY_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_SCENERY_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_SCENERY_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_SCENERY_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_SCENERY_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
// Quadrant checkboxes
widgets[WIDX_SCENERY_CHECK_QUARTER_N].top = GBBT(propertiesAnchor, 1) - 5 + 7 * 0;
widgets[WIDX_SCENERY_CHECK_QUARTER_N].bottom = widgets[WIDX_SCENERY_CHECK_QUARTER_N].top + 13;
widgets[WIDX_SCENERY_CHECK_QUARTER_E].top = GBBT(propertiesAnchor, 1) - 5 + 7 * 1;
widgets[WIDX_SCENERY_CHECK_QUARTER_E].bottom = widgets[WIDX_SCENERY_CHECK_QUARTER_E].top + 13;
widgets[WIDX_SCENERY_CHECK_QUARTER_S].top = GBBT(propertiesAnchor, 1) - 5 + 7 * 2;
widgets[WIDX_SCENERY_CHECK_QUARTER_S].bottom = widgets[WIDX_SCENERY_CHECK_QUARTER_S].top + 13;
widgets[WIDX_SCENERY_CHECK_QUARTER_W].top = GBBT(propertiesAnchor, 1) - 5 + 7 * 1;
widgets[WIDX_SCENERY_CHECK_QUARTER_W].bottom = widgets[WIDX_SCENERY_CHECK_QUARTER_W].top + 13;
// This gets the relative rotation, by subtracting the camera's rotation, and wrapping it between 0-3 inclusive
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
bool N = tileElement->AsSmallScenery()->GetSceneryQuadrant() == ((0 - GetCurrentRotation()) & 3);
bool E = tileElement->AsSmallScenery()->GetSceneryQuadrant() == ((1 - GetCurrentRotation()) & 3);
bool S = tileElement->AsSmallScenery()->GetSceneryQuadrant() == ((2 - GetCurrentRotation()) & 3);
bool W = tileElement->AsSmallScenery()->GetSceneryQuadrant() == ((3 - GetCurrentRotation()) & 3);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(WIDX_SCENERY_CHECK_QUARTER_N, N);
SetCheckboxValue(WIDX_SCENERY_CHECK_QUARTER_E, E);
SetCheckboxValue(WIDX_SCENERY_CHECK_QUARTER_S, S);
SetCheckboxValue(WIDX_SCENERY_CHECK_QUARTER_W, W);
// Collision checkboxes
widgets[WIDX_SCENERY_CHECK_COLLISION_N].top = GBBT(propertiesAnchor, 2) + 5 + 7 * 0;
widgets[WIDX_SCENERY_CHECK_COLLISION_N].bottom = widgets[WIDX_SCENERY_CHECK_COLLISION_N].top + 13;
widgets[WIDX_SCENERY_CHECK_COLLISION_E].top = GBBT(propertiesAnchor, 2) + 5 + 7 * 1;
widgets[WIDX_SCENERY_CHECK_COLLISION_E].bottom = widgets[WIDX_SCENERY_CHECK_COLLISION_E].top + 13;
widgets[WIDX_SCENERY_CHECK_COLLISION_S].top = GBBT(propertiesAnchor, 2) + 5 + 7 * 2;
widgets[WIDX_SCENERY_CHECK_COLLISION_S].bottom = widgets[WIDX_SCENERY_CHECK_COLLISION_S].top + 13;
widgets[WIDX_SCENERY_CHECK_COLLISION_W].top = GBBT(propertiesAnchor, 2) + 5 + 7 * 1;
widgets[WIDX_SCENERY_CHECK_COLLISION_W].bottom = widgets[WIDX_SCENERY_CHECK_COLLISION_W].top + 13;
auto occupiedQuadrants = tileElement->GetOccupiedQuadrants();
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
N = (occupiedQuadrants & (1 << ((2 - GetCurrentRotation()) & 3))) != 0;
E = (occupiedQuadrants & (1 << ((3 - GetCurrentRotation()) & 3))) != 0;
S = (occupiedQuadrants & (1 << ((0 - GetCurrentRotation()) & 3))) != 0;
W = (occupiedQuadrants & (1 << ((1 - GetCurrentRotation()) & 3))) != 0;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(WIDX_SCENERY_CHECK_COLLISION_N, N);
SetCheckboxValue(WIDX_SCENERY_CHECK_COLLISION_E, E);
SetCheckboxValue(WIDX_SCENERY_CHECK_COLLISION_S, S);
SetCheckboxValue(WIDX_SCENERY_CHECK_COLLISION_W, W);
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Fix #14032: NPE in window_tile_inspector_scrollpaint()
2021-02-09 23:02:31 +01:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Entrance:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_ENTRANCE_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_ENTRANCE_BUTTON_MAKE_USABLE].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_ENTRANCE_BUTTON_MAKE_USABLE].bottom = GBBB(propertiesAnchor, 1);
SetWidgetDisabled(
WIDX_ENTRANCE_BUTTON_MAKE_USABLE,
!(tileElement->AsEntrance()->GetEntranceType() != ENTRANCE_TYPE_PARK_ENTRANCE));
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Wall:
Fix #14032: NPE in window_tile_inspector_scrollpaint()
2021-02-09 23:02:31 +01:00
{
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
bool canBeSloped = false;
bool hasAnimation = false;
const auto wallEntry = tileElement->AsWall()->GetEntry();
if (wallEntry != nullptr)
{
canBeSloped = !(wallEntry->flags & WALL_SCENERY_CANT_BUILD_ON_SLOPE);
hasAnimation = wallEntry->flags & WALL_SCENERY_IS_DOOR;
}
widgets[WIDX_WALL_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_WALL_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_WALL_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_WALL_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_WALL_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_WALL_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_WALL_DROPDOWN_SLOPE].top = GBBT(propertiesAnchor, 1) + 3;
widgets[WIDX_WALL_DROPDOWN_SLOPE].bottom = GBBB(propertiesAnchor, 1) - 3;
widgets[WIDX_WALL_DROPDOWN_SLOPE].text = WallSlopeStringIds[tileElement->AsWall()->GetSlope()];
widgets[WIDX_WALL_DROPDOWN_SLOPE_BUTTON].top = GBBT(propertiesAnchor, 1) + 4;
widgets[WIDX_WALL_DROPDOWN_SLOPE_BUTTON].bottom = GBBB(propertiesAnchor, 1) - 4;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].top = GBBT(propertiesAnchor, 2) + 3;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].bottom = GBBB(propertiesAnchor, 2) - 3;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE].top = GBBT(propertiesAnchor, 2) + 4;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE].bottom = GBBB(propertiesAnchor, 2) - 4;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE].top = GBBT(propertiesAnchor, 2) + 4;
widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE].bottom = GBBB(propertiesAnchor, 2) - 4;
// Wall slope dropdown
SetWidgetDisabled(WIDX_WALL_DROPDOWN_SLOPE, !canBeSloped);
InvalidateWidget(WIDX_WALL_DROPDOWN_SLOPE);
SetWidgetDisabled(WIDX_WALL_DROPDOWN_SLOPE_BUTTON, !canBeSloped);
InvalidateWidget(WIDX_WALL_DROPDOWN_SLOPE_BUTTON);
// Wall animation frame spinner
SetWidgetDisabled(WIDX_WALL_SPINNER_ANIMATION_FRAME, !hasAnimation);
SetWidgetDisabled(WIDX_WALL_SPINNER_ANIMATION_FRAME_INCREASE, !hasAnimation);
SetWidgetDisabled(WIDX_WALL_SPINNER_ANIMATION_FRAME_DECREASE, !hasAnimation);
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Fix #14032: NPE in window_tile_inspector_scrollpaint()
2021-02-09 23:02:31 +01:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::LargeScenery:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
Drop the N postfix
2021-12-11 00:39:39 +01:00
case TileElementType::Banner:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
widgets[WIDX_BANNER_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
widgets[WIDX_BANNER_SPINNER_HEIGHT].bottom = GBBB(propertiesAnchor, 0) - 3;
widgets[WIDX_BANNER_SPINNER_HEIGHT_INCREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_BANNER_SPINNER_HEIGHT_INCREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_BANNER_SPINNER_HEIGHT_DECREASE].top = GBBT(propertiesAnchor, 0) + 4;
widgets[WIDX_BANNER_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
widgets[WIDX_BANNER_CHECK_BLOCK_NE].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_BANNER_CHECK_BLOCK_NE].bottom = GBBB(propertiesAnchor, 1);
widgets[WIDX_BANNER_CHECK_BLOCK_SE].top = GBBT(propertiesAnchor, 2);
widgets[WIDX_BANNER_CHECK_BLOCK_SE].bottom = GBBB(propertiesAnchor, 2);
widgets[WIDX_BANNER_CHECK_BLOCK_SW].top = GBBT(propertiesAnchor, 2);
widgets[WIDX_BANNER_CHECK_BLOCK_SW].bottom = GBBB(propertiesAnchor, 2);
widgets[WIDX_BANNER_CHECK_BLOCK_NW].top = GBBT(propertiesAnchor, 1);
widgets[WIDX_BANNER_CHECK_BLOCK_NW].bottom = GBBB(propertiesAnchor, 1);
SetCheckboxValue(
WIDX_BANNER_CHECK_BLOCK_NE,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
(tileElement->AsBanner()->GetAllowedEdges() & (1 << ((0 - GetCurrentRotation()) & 3))));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_BANNER_CHECK_BLOCK_SE,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
(tileElement->AsBanner()->GetAllowedEdges() & (1 << ((1 - GetCurrentRotation()) & 3))));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_BANNER_CHECK_BLOCK_SW,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
(tileElement->AsBanner()->GetAllowedEdges() & (1 << ((2 - GetCurrentRotation()) & 3))));
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
SetCheckboxValue(
WIDX_BANNER_CHECK_BLOCK_NW,
Remove snake_case in interface folder
2023-01-16 21:14:50 +01:00
(tileElement->AsBanner()->GetAllowedEdges() & (1 << ((3 - GetCurrentRotation()) & 3))));
clang-format UI windows
2018-06-22 23:21:44 +02:00
break;
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
clang-format UI windows
2018-06-22 23:21:44 +02:00
default:
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
break; // Nothing.
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
}
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
}
};
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Rename snake_case Class names (Remaining Bits) (#19237) * Rename snake_case Class names * Clang format * Fix build issues
2023-01-21 20:57:17 +01:00
WindowBase* WindowTileInspectorOpen()
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
{
Rename snake_case Class names (Remaining Bits) (#19237) * Rename snake_case Class names * Clang format * Fix build issues
2023-01-21 20:57:17 +01:00
WindowBase* window = WindowBringToFrontByClass(WindowClass::TileInspector);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (window == nullptr)
window = WindowCreate<TileInspector>(WindowClass::TileInspector, ScreenCoordsXY(0, 29), WW, WH, WF_RESIZABLE);
return window;
}
Expand tabs to spaces This commit expands tabs to spaces (ts=4) in all the files under src/ and test/. Until now we had two wildly different code styles with C using tabs and new C++ using spaces. It is painful to maintain as none of the commonly used tools support this kind of setup and in reality is needless, as we can simply convert all the sources to spaces and have opened PRs do the same, where needed. Additionally, trailing whitespace has been removed.
2017-06-06 23:24:18 +02:00
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
void WindowTileInspectorClearClipboard()
{
Rename global window functions to TitleCase (#19167)
2023-01-16 21:13:42 +01:00
auto* window = WindowFindByClass(WindowClass::TileInspector);
Refactor of TileInspector to Window class
2022-03-24 03:01:23 +01:00
if (window != nullptr)
static_cast<TileInspector*>(window)->ClearClipboard();
Add debug toolbar menu, start tile inspector
2015-06-01 03:33:56 +02:00
}