1

/* $Id$ */

     2

     3

/** @file toolbar_gui.cpp Code related to the (main) toolbar. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "window_func.h"

    10

#include "viewport_func.h"

    11

#include "command_func.h"

    12

#include "variables.h"

    13

#include "train.h"

    14

#include "roadveh.h"

    15

#include "vehicle_gui.h"

    16

#include "rail_gui.h"

    17

#include "road_gui.h"

    18

#include "date_func.h"

    19

#include "vehicle_func.h"

    20

#include "sound_func.h"

    21

#include "terraform_gui.h"

    22

#include "transparency.h"

    23

#include "strings_func.h"

    24

#include "player_base.h"

    25

#include "player_func.h"

    26

#include "player_gui.h"

    27

#include "settings_type.h"

    28

#include "toolbar_gui.h"

    29

#include "vehicle_base.h"

    30

#include "gfx_func.h"

    31

#include "cheat_func.h"

    32

#include "transparency_gui.h"

    33

#include "screenshot.h"

    34

#include "newgrf_config.h"

    35

#include "signs_func.h"

    36

#include "fios.h"

    37

#include "functions.h"

    38

#include "console_gui.h"

    39

#include "news_gui.h"

    40

#include "tilehighlight_func.h"

    41

    42

#include "network/network.h"

    43

#include "network/network_gui.h"

    44

    45

#include "table/strings.h"

    46

#include "table/sprites.h"

    47

    48

static void PopupMainToolbMenu(Window *parent, uint16 parent_button, StringID base_string, byte item_count, byte disabled_mask = 0, int sel_index = 0, int checked_items = 0);

    49

static void PopupMainPlayerToolbMenu(Window *parent, int main_button, int gray = 0);

    50

static void SplitToolbar(Window *w);

    51

    52

RailType _last_built_railtype;

    53

RoadType _last_built_roadtype;

    54

    55

/** This enum gathers properties of both toolbars */

    56

enum ToolBarProperties {

    57

	TBP_BUTTONWIDTH        =  22,  ///< width of a button

    58

	TBP_BUTTONHEIGHT       =  22,  ///< height of a button as well as the toolbars

    59

	TBP_DATEPANELWIDTH     = 130,  ///< used in scenario editor to calculate width of the toolbar.

    60

    61

	TBP_TOOLBAR_MINBUTTON  =  14,  ///< references both toolbars

    62

	TBP_NORMAL_MAXBUTTON   =  19,  ///< normal toolbar has this many buttons

    63

	TBP_SCENARIO_MAXBUTTON =  16,  ///< while the scenario has these

    64

};

    65

    66

enum ToolbarMode {

    67

	TB_NORMAL,

    68

	TB_UPPER,

    69

	TB_LOWER

    70

};

    71

    72

enum ToolbarNormalWidgets {

    73

	TBN_PAUSE         = 0,

    74

	TBN_FASTFORWARD,

    75

	TBN_SETTINGS,

    76

	TBN_SAVEGAME,

    77

	TBN_SMALLMAP,

    78

	TBN_TOWNDIRECTORY,

    79

	TBN_SUBSIDIES,

    80

	TBN_STATIONS,

    81

	TBN_FINANCES,

    82

	TBN_PLAYERS,

    83

	TBN_GRAPHICS,

    84

	TBN_LEAGUE,

    85

	TBN_INDUSTRIES,

    86

	TBN_VEHICLESTART,      ///< trains, actually.  So following are trucks, boats and planes

    87

	TBN_TRAINS        = TBN_VEHICLESTART,

    88

	TBN_ROADVEHS,

    89

	TBN_SHIPS,

    90

	TBN_AIRCRAFTS,

    91

	TBN_ZOOMIN,

    92

	TBN_ZOOMOUT,

    93

	TBN_RAILS,

    94

	TBN_ROADS,

    95

	TBN_WATER,

    96

	TBN_AIR,

    97

	TBN_LANDSCAPE,

    98

	TBN_MUSICSOUND,

    99

	TBN_NEWSREPORT,

   100

	TBN_HELP,

   101

	TBN_SWITCHBAR,         ///< only available when toolbar has been split

   102

};

   103

   104

enum ToolbarScenEditorWidgets {

   105

	TBSE_PAUSE        = 0,

   106

	TBSE_FASTFORWARD,

   107

	TBSE_SAVESCENARIO = 3,

   108

	TBSE_SPACERPANEL,

   109

	TBSE_DATEPANEL,

   110

	TBSE_DATEBACKWARD,

   111

	TBSE_DATEFORWARD,

   112

	TBSE_SMALLMAP,

   113

	TBSE_ZOOMIN,

   114

	TBSE_ZOOMOUT,

   115

	TBSE_LANDGENERATE,

   116

	TBSE_TOWNGENERATE,

   117

	TBSE_INDUSTRYGENERATE,

   118

	TBSE_BUILDROAD,

   119

	TBSE_BUILDDOCKS,

   120

	TBSE_PLANTTREES,

   121

	TBSE_PLACESIGNS,

   122

};

   123

   124

/** The idea of this enum is to allow a separation between widget position

   125

 * and _menu_clicked_procs's entry.  By shifting, the "action" id is extracted and

   126

 * kept safe for usage when required.

   127

 * @see ToolbarMenuWindow::OnMouseLoop */

   128

enum ScenarioEditorMenuActions {

   129

	SEMA_MAP_CLICK = 17 << 8,

   130

};

   131

   132

static ToolbarMode _toolbar_mode;

   133

   134

static void SelectSignTool()

   135

{

   136

	if (_cursor.sprite == SPR_CURSOR_SIGN) {

   137

		ResetObjectToPlace();

   138

	} else {

   139

		SetObjectToPlace(SPR_CURSOR_SIGN, PAL_NONE, VHM_RECT, WC_MAIN_TOOLBAR, 0);

   140

		_place_proc = PlaceProc_Sign;

   141

	}

   142

}

   143

   144

/** Returns the position where the toolbar wants the menu to appear.

   145

 * Make sure the dropdown is fully visible within the window.

   146

 * x + w->left because x is supposed to be the offset of the toolbar-button

   147

 * we clicked on and w->left the toolbar window itself. So meaning that

   148

 * the default position is aligned with the left side of the clicked button */

   149

static Point GetToolbarDropdownPos(uint16 parent_button, int width, int height)

   150

{

   151

	const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);

   152

	Point pos;

   153

	pos.x = w->widget[GB(parent_button, 0, 8)].left;

   154

	pos.x = w->left + Clamp(pos.x, 0, w->width - width);

   155

	pos.y = w->height;

   156

   157

	return pos;

   158

}

   159

   160

/**

   161

 * Retrieve the menu item number from a position

   162

 * @param w Window holding the menu items

   163

 * @param x X coordinate of the position

   164

 * @param y Y coordinate of the position

   165

 * @return Index number of the menu item, or \c -1 if no valid selection under position

   166

 */

   167

static int GetMenuItemIndex(const Window *w, int item_count, int disabled_items)

   168

{

   169

	int x = _cursor.pos.x;

   170

	int y = _cursor.pos.y;

   171

   172

	if ((x -= w->left) >= 0 && x < w->width && (y -= w->top + 1) >= 0) {

   173

		y /= 10;

   174

   175

		if (y < item_count &&

   176

				!HasBit(disabled_items, y)) {

   177

			return y;

   178

		}

   179

	}

   180

	return -1;

   181

}

   182

   183

/* --- Pausing --- */

   184

   185

static void ToolbarPauseClick(Window *w)

   186

{

   187

	if (_networking && !_network_server) return; // only server can pause the game

   188

   189

	if (DoCommandP(0, _pause_game ? 0 : 1, 0, NULL, CMD_PAUSE)) SndPlayFx(SND_15_BEEP);

   190

}

   191

   192

/* --- Fast forwarding --- */

   193

   194

static void ToolbarFastForwardClick(Window *w)

   195

{

   196

	_fast_forward ^= true;

   197

	SndPlayFx(SND_15_BEEP);

   198

}

   199

   200

/* --- Options button menu --- */

   201

   202

enum OptionMenuEntries {

   203

	OME_GAMEOPTIONS    = 0,

   204

	OME_DIFFICULTIES,

   205

	OME_PATCHES,

   206

	OME_NEWGRFSETTINGS,

   207

	OME_TRANSPARENCIES,

   208

	OME_SHOW_TOWNNAMES = 6,

   209

	OME_SHOW_STATIONNAMES,

   210

	OME_SHOW_SIGNS,

   211

	OME_SHOW_WAYPOINTNAMES,

   212

	OME_FULL_ANIMATION,

   213

	OME_FULL_DETAILS,

   214

	OME_TRANSPARENTBUILDINGS,

   215

	OME_SHOW_STATIONSIGNS,

   216

	OME_MENUCOUNT,

   217

};

   218

   219

static void ToolbarOptionsClick(Window *w)

   220

{

   221

	uint16 x = 0;

   222

	if (HasBit(_display_opt, DO_SHOW_TOWN_NAMES))    SetBit(x, OME_SHOW_TOWNNAMES);

   223

	if (HasBit(_display_opt, DO_SHOW_STATION_NAMES)) SetBit(x, OME_SHOW_STATIONNAMES);

   224

	if (HasBit(_display_opt, DO_SHOW_SIGNS))         SetBit(x, OME_SHOW_SIGNS);

   225

	if (HasBit(_display_opt, DO_WAYPOINTS))          SetBit(x, OME_SHOW_WAYPOINTNAMES);

   226

	if (HasBit(_display_opt, DO_FULL_ANIMATION))     SetBit(x, OME_FULL_ANIMATION);

   227

	if (HasBit(_display_opt, DO_FULL_DETAIL))        SetBit(x, OME_FULL_DETAILS);

   228

	if (IsTransparencySet(TO_HOUSES))                SetBit(x, OME_TRANSPARENTBUILDINGS);

   229

	if (IsTransparencySet(TO_SIGNS))                 SetBit(x, OME_SHOW_STATIONSIGNS);

   230

   231

	PopupMainToolbMenu(w, TBN_SETTINGS, STR_02C4_GAME_OPTIONS, OME_MENUCOUNT, 0, 0, x);

   232

}

   233

   234

static void MenuClickSettings(int index)

   235

{

   236

	switch (index) {

   237

		case OME_GAMEOPTIONS:          ShowGameOptions();                              return;

   238

		case OME_DIFFICULTIES:         ShowGameDifficulty();                           return;

   239

		case OME_PATCHES:              ShowPatchesSelection();                         return;

   240

		case OME_NEWGRFSETTINGS:       ShowNewGRFSettings(!_networking, true, true, &_grfconfig);   return;

   241

		case OME_TRANSPARENCIES:       ShowTransparencyToolbar();                      break;

   242

   243

		case OME_SHOW_TOWNNAMES:       ToggleBit(_display_opt, DO_SHOW_TOWN_NAMES);    break;

   244

		case OME_SHOW_STATIONNAMES:    ToggleBit(_display_opt, DO_SHOW_STATION_NAMES); break;

   245

		case OME_SHOW_SIGNS:           ToggleBit(_display_opt, DO_SHOW_SIGNS);         break;

   246

		case OME_SHOW_WAYPOINTNAMES:   ToggleBit(_display_opt, DO_WAYPOINTS);          break;

   247

		case OME_FULL_ANIMATION:       ToggleBit(_display_opt, DO_FULL_ANIMATION);     break;

   248

		case OME_FULL_DETAILS:         ToggleBit(_display_opt, DO_FULL_DETAIL);        break;

   249

		case OME_TRANSPARENTBUILDINGS: ToggleTransparency(TO_HOUSES);                  break;

   250

		case OME_SHOW_STATIONSIGNS:    ToggleTransparency(TO_SIGNS);                   break;

   251

	}

   252

	MarkWholeScreenDirty();

   253

}

   254

   255

/* --- Saving/loading button menu --- */

   256

   257

enum SaveLoadEditorMenuEntries {

   258

	SLEME_SAVE_SCENARIO   = 0,

   259

	SLEME_LOAD_SCENARIO,

   260

	SLEME_LOAD_HEIGHTMAP,

   261

	SLEME_EXIT_TOINTRO,

   262

	SLEME_EXIT_GAME       = 5,

   263

	SLEME_MENUCOUNT,

   264

};

   265

   266

enum SaveLoadNormalMenuEntries {

   267

	SLNME_SAVE_GAME   = 0,

   268

	SLNME_LOAD_GAME,

   269

	SLNME_EXIT_TOINTRO,

   270

	SLNME_EXIT_GAME,

   271

	SLNME_MENUCOUNT,

   272

};

   273

   274

static void ToolbarSaveClick(Window *w)

   275

{

   276

	PopupMainToolbMenu(w, TBN_SAVEGAME, STR_015C_SAVE_GAME, SLNME_MENUCOUNT);

   277

}

   278

   279

static void ToolbarScenSaveOrLoad(Window *w)

   280

{

   281

	PopupMainToolbMenu(w, TBSE_SAVESCENARIO, STR_0292_SAVE_SCENARIO, SLEME_MENUCOUNT);

   282

}

   283

   284

static void MenuClickSaveLoad(int index = 0)

   285

{

   286

	if (_game_mode == GM_EDITOR) {

   287

		switch (index) {

   288

			case SLEME_SAVE_SCENARIO:  ShowSaveLoadDialog(SLD_SAVE_SCENARIO);  break;

   289

			case SLEME_LOAD_SCENARIO:  ShowSaveLoadDialog(SLD_LOAD_SCENARIO);  break;

   290

			case SLEME_LOAD_HEIGHTMAP: ShowSaveLoadDialog(SLD_LOAD_HEIGHTMAP); break;

   291

			case SLEME_EXIT_TOINTRO:   AskExitToGameMenu();                    break;

   292

			case SLEME_EXIT_GAME:      HandleExitGameRequest();                break;

   293

		}

   294

	} else {

   295

		switch (index) {

   296

			case SLNME_SAVE_GAME:      ShowSaveLoadDialog(SLD_SAVE_GAME); break;

   297

			case SLNME_LOAD_GAME:      ShowSaveLoadDialog(SLD_LOAD_GAME); break;

   298

			case SLNME_EXIT_TOINTRO:   AskExitToGameMenu();               break;

   299

			case SLNME_EXIT_GAME:      HandleExitGameRequest();           break;

   300

		}

   301

	}

   302

}

   303

   304

/* --- Map button menu --- */

   305

   306

enum MapMenuEntries {

   307

	MME_SHOW_SMALLMAP        = 0,

   308

	MME_SHOW_EXTRAVIEWPORTS,

   309

	MME_SHOW_SIGNLISTS,

   310

	MME_SHOW_TOWNDIRECTORY,    ///< This entry is only used in Editor mode

   311

	MME_MENUCOUNT_NORMAL     = 3,

   312

	MME_MENUCOUNT_EDITOR     = 4,

   313

};

   314

   315

static void ToolbarMapClick(Window *w)

   316

{

   317

	PopupMainToolbMenu(w, TBN_SMALLMAP, STR_02DE_MAP_OF_WORLD, MME_MENUCOUNT_NORMAL);

   318

}

   319

   320

static void ToolbarScenMapTownDir(Window *w)

   321

{

   322

	/* Scenario editor button, Use different button to activate.

   323

	 * This scheme will allow to have an action (SEMA_MAP_CLICK, which is in fact

   324

	 * an entry in _menu_clicked_procs) while at the same time having a start button

   325

	 * who is not at the same index as its action

   326

	 * @see ToolbarMenuWindow::OnMouseLoop */

   327

	PopupMainToolbMenu(w, TBSE_SMALLMAP | SEMA_MAP_CLICK, STR_02DE_MAP_OF_WORLD, MME_MENUCOUNT_EDITOR);

   328

}

   329

   330

static void MenuClickMap(int index)

   331

{

   332

	switch (index) {

   333

		case MME_SHOW_SMALLMAP:       ShowSmallMap();            break;

   334

		case MME_SHOW_EXTRAVIEWPORTS: ShowExtraViewPortWindow(); break;

   335

		case MME_SHOW_SIGNLISTS:      ShowSignList();            break;

   336

		case MME_SHOW_TOWNDIRECTORY:  if (_game_mode == GM_EDITOR) ShowTownDirectory(); break;

   337

	}

   338

}

   339

   340

/* --- Town button menu --- */

   341

   342

static void ToolbarTownClick(Window *w)

   343

{

   344

	PopupMainToolbMenu(w, TBN_TOWNDIRECTORY, STR_02BB_TOWN_DIRECTORY, 1);

   345

}

   346

   347

static void MenuClickTown(int index)

   348

{

   349

	ShowTownDirectory();

   350

}

   351

   352

/* --- Subidies button menu --- */

   353

   354

static void ToolbarSubsidiesClick(Window *w)

   355

{

   356

	PopupMainToolbMenu(w, TBN_SUBSIDIES, STR_02DD_SUBSIDIES, 1);

   357

}

   358

   359

static void MenuClickSubsidies(int index)

   360

{

   361

	ShowSubsidiesList();

   362

}

   363

   364

/* --- Stations button menu --- */

   365

   366

static void ToolbarStationsClick(Window *w)

   367

{

   368

	PopupMainPlayerToolbMenu(w, TBN_STATIONS);

   369

}

   370

   371

static void MenuClickStations(int index)

   372

{

   373

	ShowPlayerStations((PlayerID)index);

   374

}

   375

   376

/* --- Finances button menu --- */

   377

   378

static void ToolbarFinancesClick(Window *w)

   379

{

   380

	PopupMainPlayerToolbMenu(w, TBN_FINANCES);

   381

}

   382

   383

static void MenuClickFinances(int index)

   384

{

   385

	ShowPlayerFinances((PlayerID)index);

   386

}

   387

   388

/* --- Company's button menu --- */

   389

   390

static void ToolbarPlayersClick(Window *w)

   391

{

   392

	PopupMainPlayerToolbMenu(w, TBN_PLAYERS);

   393

}

   394

   395

static void MenuClickCompany(int index)

   396

{

   397

	if (_networking && index == 0) {

   398

		ShowClientList();

   399

	} else {

   400

		if (_networking) index--;

   401

		ShowPlayerCompany((PlayerID)index);

   402

	}

   403

}

   404

   405

/* --- Graphs button menu --- */

   406

   407

static void ToolbarGraphsClick(Window *w)

   408

{

   409

	PopupMainToolbMenu(w, TBN_GRAPHICS, STR_0154_OPERATING_PROFIT_GRAPH, (_toolbar_mode == TB_NORMAL) ? 6 : 8);

   410

}

   411

   412

static void MenuClickGraphs(int index)

   413

{

   414

	switch (index) {

   415

		case 0: ShowOperatingProfitGraph();    break;

   416

		case 1: ShowIncomeGraph();             break;

   417

		case 2: ShowDeliveredCargoGraph();     break;

   418

		case 3: ShowPerformanceHistoryGraph(); break;

   419

		case 4: ShowCompanyValueGraph();       break;

   420

		case 5: ShowCargoPaymentRates();       break;

   421

		/* functions for combined graphs/league button */

   422

		case 6: ShowCompanyLeagueTable();      break;

   423

		case 7: ShowPerformanceRatingDetail(); break;

   424

	}

   425

}

   426

   427

/* --- League button menu --- */

   428

   429

static void ToolbarLeagueClick(Window *w)

   430

{

   431

	PopupMainToolbMenu(w, TBN_LEAGUE, STR_015A_COMPANY_LEAGUE_TABLE, 2);

   432

}

   433

   434

static void MenuClickLeague(int index)

   435

{

   436

	switch (index) {

   437

		case 0: ShowCompanyLeagueTable();      break;

   438

		case 1: ShowPerformanceRatingDetail(); break;

   439

	}

   440

}

   441

   442

/* --- Industries button menu --- */

   443

   444

static void ToolbarIndustryClick(Window *w)

   445

{

   446

	/* Disable build-industry menu if we are a spectator */

   447

	PopupMainToolbMenu(w, TBN_INDUSTRIES, STR_INDUSTRY_DIR, 2, (_current_player == PLAYER_SPECTATOR) ? 2 : 0);

   448

}

   449

   450

static void MenuClickIndustry(int index)

   451

{

   452

	switch (index) {

   453

		case 0: ShowIndustryDirectory();   break;

   454

		case 1: ShowBuildIndustryWindow(); break;

   455

	}

   456

}

   457

   458

/* --- Trains button menu + 1 helper function for all vehicles. --- */

   459

   460

static void ToolbarVehicleClick(Window *w, VehicleType veh)

   461

{

   462

	const Vehicle *v;

   463

	int dis = ~0;

   464

   465

	FOR_ALL_VEHICLES(v) {

   466

		if (v->type == veh && v->IsPrimaryVehicle()) ClrBit(dis, v->owner);

   467

	}

   468

	PopupMainPlayerToolbMenu(w, TBN_VEHICLESTART + veh, dis);

   469

}

   470

   471

   472

static void ToolbarTrainClick(Window *w)

   473

{

   474

	ToolbarVehicleClick(w, VEH_TRAIN);

   475

}

   476

   477

static void MenuClickShowTrains(int index)

   478

{

   479

	ShowVehicleListWindow((PlayerID)index, VEH_TRAIN);

   480

}

   481

   482

/* --- Road vehicle button menu --- */

   483

   484

static void ToolbarRoadClick(Window *w)

   485

{

   486

	ToolbarVehicleClick(w, VEH_ROAD);

   487

}

   488

   489

static void MenuClickShowRoad(int index)

   490

{

   491

	ShowVehicleListWindow((PlayerID)index, VEH_ROAD);

   492

}

   493

   494

/* --- Ship button menu --- */