1

/* $Id$ */

     2

     3

/** @file newgrf_download.cpp GUI to download NewGRFs. */

     4

#include "../stdafx.h"

     5

#include "../openttd.h"

     6

#include "../strings_func.h"

     7

#include "../date_func.h"

     8

#include "../gui.h"

     9

#include "../window_gui.h"

    10

#include "../textbuf_gui.h"

    11

#include "../variables.h"

    12

#include "../newgrf.h"

    13

#include "newgrf_download.h"

    14

#include "../functions.h"

    15

#include "../window_func.h"

    16

#include "../core/alloc_func.hpp"

    17

#include "../string_func.h"

    18

#include "../gfx_func.h"

    19

#include "../querystring_gui.h"

    20

#include "../sortlist_type.h"

    21

    22

#include "table/strings.h"

    23

#include "../table/sprites.h"

    24

    25

// XXX: copy-pasted from newgrf_gui.cpp

    26

static void ShowDownloadNewGRFInfo(const GRFConfig *c, uint x, uint y, uint w, uint bottom, bool show_params)

    27

{

    28

	char buff[256];

    29

    30

	if (c->error != NULL) {

    31

		char message[512];

    32

		if (c->error->custom_message == NULL) {

    33

			SetDParamStr(0, c->filename);

    34

			SetDParamStr(1, c->error->data);

    35

			for (uint i = 0; i < c->error->num_params; i++) {

    36

				uint32 param = 0;

    37

				byte param_number = c->error->param_number[i];

    38

    39

				if (param_number < c->num_params) param = c->param[param_number];

    40

    41

				SetDParam(2 + i, param);

    42

			}

    43

    44

			GetString(message, c->error->message, lastof(message));

    45

		} else {

    46

			SetDParamStr(0, c->error->custom_message);

    47

			GetString(message, STR_JUST_RAW_STRING, lastof(message));

    48

		}

    49

    50

		SetDParamStr(0, message);

    51

		y += DrawStringMultiLine(x, y, c->error->severity, w, bottom - y);

    52

	}

    53

    54

	/* Draw filename or not if it is not known (GRF sent over internet) */

    55

	if (c->filename != NULL) {

    56

		SetDParamStr(0, c->filename);

    57

		y += DrawStringMultiLine(x, y, STR_NEWGRF_FILENAME, w, bottom - y);

    58

	}

    59

    60

	/* Prepare and draw GRF ID */

    61

	snprintf(buff, lengthof(buff), "%08X", BSWAP32(c->grfid));

    62

	SetDParamStr(0, buff);

    63

	y += DrawStringMultiLine(x, y, STR_NEWGRF_GRF_ID, w, bottom - y);

    64

    65

	/* Prepare and draw MD5 sum */

    66

	md5sumToString(buff, lastof(buff), c->md5sum);

    67

	SetDParamStr(0, buff);

    68

	y += DrawStringMultiLine(x, y, STR_NEWGRF_MD5SUM, w, bottom - y);

    69

    70

	/* Show GRF parameter list */

    71

	if (show_params) {

    72

		if (c->num_params > 0) {

    73

			GRFBuildParamList(buff, c, lastof(buff));

    74

			SetDParam(0, STR_JUST_RAW_STRING);

    75

			SetDParamStr(1, buff);

    76

		} else {

    77

			SetDParam(0, STR_01A9_NONE);

    78

		}

    79

		y += DrawStringMultiLine(x, y, STR_NEWGRF_PARAMETER, w, bottom - y);

    80

	}

    81

    82

	/* Show flags */

    83

	if (c->status == GCS_NOT_FOUND)        y += DrawStringMultiLine(x, y, STR_NEWGRF_NOT_FOUND, w, bottom - y);

    84

	if (c->status == GCS_DISABLED)         y += DrawStringMultiLine(x, y, STR_NEWGRF_DISABLED, w, bottom - y);

    85

	if (HasBit(c->flags, GCF_COMPATIBLE)) y += DrawStringMultiLine(x, y, STR_NEWGRF_COMPATIBLE_LOADED, w, bottom - y);

    86

    87

	/* Draw GRF info if it exists */

    88

	if (c->info != NULL && !StrEmpty(c->info)) {

    89

		SetDParam(0, STR_JUST_RAW_STRING);

    90

		SetDParamStr(1, c->info);

    91

		y += DrawStringMultiLine(x, y, STR_02BD, w, bottom - y);

    92

	} else {

    93

		y += DrawStringMultiLine(x, y, STR_NEWGRF_NO_INFO, w, bottom - y);

    94

	}

    95

}

    96

    97

/**

    98

 * Window for downloading NewGRF files

    99

 */

   100

struct NewGRFDownloadWindow : public Window {

   101

	/* Names of the add a newgrf window widgets */

   102

	enum DownloadNewGRFWindowWidgets {

   103

        DNGRFS_CLOSEBOX = 0,

   104

		DNGRFS_CAPTION,

   105

		DNGRFS_BACKGROUND,

   106

		DNGRFS_FILE_LIST,

   107

		DNGRFS_SCROLLBAR,

   108

		DNGRFS_NEWGRF_INFO,

   109

		DNGRFS_CHECK_AVAILABLE,

   110

		DNGRFS_DOWNLOAD_AVAILABLE,

   111

		DNGRFS_RESIZE,

   112

	};

   113

   114

    // XXX: do we need a temp. copy? I think not

   115

	GRFConfig *list;       ///< temporary grf list to which changes are made

   116

	const GRFConfig *sel;

   117

   119

	{

   120

        // resize magic

   121

		this->resize.step_height = 14;

   122

   123

        // the list of GRFs

   125

   126

        // display window?

   127

		this->FindWindowPlacementAndResize(desc);

   128

   129

        // set up our own state

   130

		this->SetupDownloadNewGRFWindow();

   131

	}

   132

   133

	~NewGRFDownloadWindow()

   134

	{

   135

		/* Remove the temporary copy of grf-list used in window */

   136

		ClearGRFConfigList(&this->list);

   137

    }

   138

   139

    void SetupDownloadNewGRFWindow()

   140

	{

   141

		const GRFConfig *c;

   142

		int i;

   143

   144

        // count how many NewGRFs in our list

   145

		for (c = this->list, i = 0; c != NULL; c = c->next, i++) {}

   146

   147

        // something to do with vertical scrolling...

   148

		this->vscroll.cap = (this->widget[DNGRFS_FILE_LIST].bottom - this->widget[DNGRFS_FILE_LIST].top) / 14 + 1;

   149

		SetVScrollCount(this, i);

   150

   151

        // disable the "Check Available" button if there are no incompatible NewGRFs

   152

		this->SetWidgetDisabledState(DNGRFS_CHECK_AVAILABLE, (i == 0));

   153

   154

        // disable the "Download Available" button until we've checked for available NewGRFs

   155

		this->SetWidgetDisabledState(DNGRFS_DOWNLOAD_AVAILABLE, 1);

   156

	}

   157

   158

    virtual void OnPaint()

   159

	{

   160

        // superclass widget-drawing

   161

		this->DrawWidgets();

   162

   163

		/* Draw the NewGRF file list */

   164

   165

		int y = this->widget[DNGRFS_FILE_LIST].top;

   166

		int i = 0;

   167

   168

        // for each GRF...

   169

		for (const GRFConfig *c = this->list; c != NULL; c = c->next, i++) {

   170

   171

            // is scrolled into view

   172

			if (i >= this->vscroll.pos && i < this->vscroll.pos + this->vscroll.cap) {

   173

   174

				SpriteID pal;

   175

				byte txtoffset;

   176

   177

                // the NewGRF name

   178

				const char *text = (c->name != NULL && !StrEmpty(c->name)) ? c->name : c->filename;

   179

   180

				/* 

   181

                 * Pick a colour 

   182

                 *

   183

                 *  orange  - server has it, we don't, haven't checked availablity yet

   184

                 *  red     - not available

   185

                 *  green   - available

   186

                 *  blue    - downloaded

   187

                 */

   188

				switch (c->status) {

   189

					case GCS_NOT_FOUND:

   190

                        pal = PALETTE_TO_ORANGE;

   191

                        break;

   192

   193

					case GCS_DISABLED:

   194

						pal = PALETTE_TO_RED;

   195

						break;

   196

   197

					case GCS_AVAILABLE:

   198

						pal = PALETTE_TO_GREEN;

   199

						break;

   200

   201

					default:    // GCS_INITIALIZED or GCS_ACTIVATED

   202

						pal = PALETTE_TO_BLUE;

   203

						break;

   204

				}

   205

   206

            /*

   207

                 XXX: flags?

   208

				if (pal != PALETTE_TO_RED) {

   209

					if (HasBit(c->flags, GCF_STATIC)) {

   210

						pal = PALETTE_TO_GREY;

   211

   212

					} else if (HasBit(c->flags, GCF_COMPATIBLE)) {

   213

						pal = PALETTE_TO_ORANGE;

   214

   215

					}

   216

				}

   217

            */

   218

   219

                // draw the square in the chosen colour

   220

				DrawSprite(SPR_SQUARE, pal, 5, y + 2);

   221

   222

                // XXX: hmm... use for download errors?

   223

				if (c->error != NULL) DrawSprite(SPR_WARNING_SIGN, 0, 20, y + 2);

   224

   225

                // where to draw the text

   226

				txtoffset = c->error != NULL ? 35 : 25;

   227

   228

                // draw the chosen text (GRF name/filename)

   229

				DoDrawStringTruncated(text, txtoffset, y + 3, this->sel == c ? TC_WHITE : TC_BLACK, this->width - txtoffset - 10);

   230

   231

                // advance on to the next row

   232

				y += 14;

   233

			}

   234

		}

   235

   236

		if (this->sel != NULL) {

   237

			/* Draw NewGRF file info */

   238

			const Widget *wi = &this->widget[DNGRFS_NEWGRF_INFO];

   239

   240

			ShowDownloadNewGRFInfo(this->sel, wi->left + 2, wi->top + 2, wi->right - wi->left - 2, wi->bottom, false);

   241

		}

   242

	}

   243

   244

	virtual void OnClick(Point pt, int widget)

   245

	{

   246

		switch (widget) {

   247

            case DNGRFS_CHECK_AVAILABLE:

   248

                // XXX: implement

   249

   250

                break;

   251

   252

            case DNGRFS_DOWNLOAD_AVAILABLE:

   253

                // XXX: implement

   254

   255

                break;

   256

   257

			case DNGRFS_FILE_LIST: { // Select a GRF

   258

				GRFConfig *c;

   259

				uint i = (pt.y - this->widget[DNGRFS_FILE_LIST].top) / 14 + this->vscroll.pos;

   260

   261

				for (c = this->list; c != NULL && i > 0; c = c->next, i--) {}

   262

				this->sel = c;

   263

   264

				this->SetDirty();

   265

				break;

   266

			}

   267

		}

   268

	}

   269

   270

    virtual void OnResize(Point new_size, Point delta)

   271

	{

   272

		if (delta.x != 0) {

   273

			ResizeButtons(this, DNGRFS_CHECK_AVAILABLE, DNGRFS_DOWNLOAD_AVAILABLE);

   274

		}

   275

   276

		this->vscroll.cap += delta.y / 14;

   277

		this->widget[DNGRFS_FILE_LIST].data = (this->vscroll.cap << 8) + 1;

   278

   279

		this->SetupDownloadNewGRFWindow();

   280

	}

   281

   282

	virtual void OnInvalidateData(int data = 0)

   283

	{

   284

		this->SetupDownloadNewGRFWindow();

   285

	}

   286

};

   287

   288

/* Widget definition of the download newgrfs window */

   289

static const Widget _newgrf_download_widgets[] = {

   290

{   WWT_CLOSEBOX,  RESIZE_NONE, 10,   0,  10,   0,  13, STR_00C5,                    STR_018B_CLOSE_WINDOW },            // DNGRFS_CLOSEBOX

   291

{    WWT_CAPTION, RESIZE_RIGHT, 10,  11, 299,   0,  13, STR_NEWGRF_SETTINGS_CAPTION, STR_018C_WINDOW_TITLE_DRAG_THIS },  // DNGRFS_CAPTION

   292

{      WWT_PANEL, RESIZE_RIGHT, 10,   0, 299,  14,  29, STR_NULL,                    STR_NULL },                         // DNGRFS_BACKGROUND

   293

   294

    /*

   295

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3,  10,  79,  16,  27, STR_NEWGRF_ADD,              STR_NEWGRF_ADD_TIP },               // SNGRFS_ADD

   296

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3,  80, 149,  16,  27, STR_NEWGRF_REMOVE,           STR_NEWGRF_REMOVE_TIP },            // SNGRFS_REMOVE

   297

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3, 150, 219,  16,  27, STR_NEWGRF_MOVEUP,           STR_NEWGRF_MOVEUP_TIP },            // SNGRFS_MOVE_UP

   298

{ WWT_PUSHTXTBTN, RESIZE_RIGHT,  3, 220, 289,  16,  27, STR_NEWGRF_MOVEDOWN,         STR_NEWGRF_MOVEDOWN_TIP },          // SNGRFS_MOVE_DOWN

   299

    */

   300

   301

{     WWT_MATRIX,    RESIZE_RB, 10,   0, 287,  30,  99, 0x501,                       STR_NEWGRF_DOWNLOAD_LIST_TIP },     // DNGRFS_FILE_LIST

   302

{  WWT_SCROLLBAR,   RESIZE_LRB, 10, 288, 299,  30,  99, 0x0,                         STR_0190_SCROLL_BAR_SCROLLS_LIST }, // DNGRFS_SCROLLBAR

   303

{      WWT_PANEL,   RESIZE_RTB, 10,   0, 299, 100, 212, STR_NULL,                    STR_NULL },                         // DNGRFS_NEWGRF_INFO

   304

{ WWT_PUSHTXTBTN,    RESIZE_TB, 10,   0, 143, 213, 224, STR_NEWGRF_CHECK_AVAILABLE,  STR_NULL },                         // DNGRFS_CHECK_AVILABLE

   305

{ WWT_PUSHTXTBTN,   RESIZE_RTB, 10, 144, 287, 213, 224, STR_NEWGRF_DOWNLOAD_AVAILABLE,  STR_NULL },                      // DNGRFS_DOWNLOAD_AVAILABLE

   306

{  WWT_RESIZEBOX,  RESIZE_LRTB, 10, 288, 299, 213, 224, 0x0,                         STR_RESIZE_BUTTON },                // DNGRFS_RESIZE

   307

{ WIDGETS_END },

   308

};

   309

   310

/* Window definition of the manage newgrfs window */

   311

static const WindowDesc _newgrf_download_desc = {

   312

	WDP_CENTER, WDP_CENTER, 300, 225, 300, 225,

   313

	WC_GAME_OPTIONS, WC_NONE,

   314

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   315

	_newgrf_download_widgets,

   316

};

   317

   318

   319

/** Setup the NewGRF download gui

   320

 * @param config pointer to a linked-list of grfconfig's needed */

   321

void ShowNewGRFDownload(GRFConfig **config)

   322

{

   347

	DeleteWindowByClass(WC_GAME_OPTIONS);

   349

}

   350