1

/* $Id$ */

     2

     3

/** @file player_gui.cpp Player related GUIs. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "textbuf_gui.h"

    10

#include "viewport_func.h"

    11

#include "gfx_func.h"

    12

#include "player_func.h"

    13

#include "player_base.h"

    14

#include "command_func.h"

    15

#include "network/network.h"

    16

#include "network/network_gui.h"

    17

#include "variables.h"

    18

#include "roadveh.h"

    19

#include "train.h"

    20

#include "aircraft.h"

    21

#include "newgrf.h"

    22

#include "player_face.h"

    23

#include "strings_func.h"

    24

#include "functions.h"

    25

#include "window_func.h"

    26

#include "date_func.h"

    27

#include "string_func.h"

    28

#include "settings_type.h"

    29

#include "widgets/dropdown_func.h"

    30

#include "widgets/dropdown_type.h"

    31

#include "tilehighlight_func.h"

    32

    33

#include "table/sprites.h"

    34

#include "table/strings.h"

    35

    36

enum {

    37

	FIRST_GUI_CALL = INT_MAX,  ///< default value to specify thuis is the first call of the resizable gui

    38

};

    39

    40

static void DoShowPlayerFinances(PlayerID player, bool show_small, bool show_stickied, int top = FIRST_GUI_CALL, int left = FIRST_GUI_CALL);

    41

static void DoSelectPlayerFace(Window *parent, bool show_big, int top =  FIRST_GUI_CALL, int left = FIRST_GUI_CALL);

    42

    43

static void DrawPlayerEconomyStats(const Player *p, bool small)

    44

{

    45

	int x, y, i, j, year;

    46

	const Money (*tbl)[EXPENSES_END];

    47

	Money sum, cost;

    48

	StringID str;

    49

    50

	if (!small) { // normal sized economics window

    51

		/* draw categories */

    52

		DrawStringCenterUnderline(61, 15, STR_700F_EXPENDITURE_INCOME, TC_FROMSTRING);

    53

		for (i = 0; i != EXPENSES_END; i++)

    54

			DrawString(2, 27 + i * 10, STR_7011_CONSTRUCTION + i, TC_FROMSTRING);

    55

		DrawStringRightAligned(111, 27 + 10 * EXPENSES_END + 2, STR_7020_TOTAL, TC_FROMSTRING);

    56

    57

		/* draw the price columns */

    58

		year = _cur_year - 2;

    59

		j = 3;

    60

		x = 215;

    61

		tbl = p->yearly_expenses + 2;

    62

		do {

    63

			if (year >= p->inaugurated_year) {

    64

				SetDParam(0, year);

    65

				DrawStringRightAlignedUnderline(x, 15, STR_7010, TC_FROMSTRING);

    66

				sum = 0;

    67

				for (i = 0; i != EXPENSES_END; i++) {

    68

					/* draw one row in the price column */

    69

					cost = (*tbl)[i];

    70

					if (cost != 0) {

    71

						sum += cost;

    72

    73

						str = STR_701E;

    74

						if (cost < 0) { cost = -cost; str++; }

    75

						SetDParam(0, cost);

    76

						DrawStringRightAligned(x, 27 + i * 10, str, TC_FROMSTRING);

    77

					}

    78

				}

    79

    80

				str = STR_701E;

    81

				if (sum < 0) { sum = -sum; str++; }

    82

				SetDParam(0, sum);

    83

				DrawStringRightAligned(x, 27 + EXPENSES_END * 10 + 2, str, TC_FROMSTRING);

    84

    85

				GfxFillRect(x - 75, 27 + 10 * EXPENSES_END, x, 27 + 10 * EXPENSES_END, 215);

    86

				x += 95;

    87

			}

    88

			year++;

    89

			tbl--;

    90

		} while (--j != 0);

    91

    92

		y = 27 + 10 * EXPENSES_END + 14;

    93

    94

		/* draw max loan aligned to loan below (y += 10) */

    95

		SetDParam(0, _economy.max_loan);

    96

		DrawString(202, y + 10, STR_MAX_LOAN, TC_FROMSTRING);

    97

	} else {

    98

		y = 15;

    99

	}

   100

   101

	DrawString(2, y, STR_7026_BANK_BALANCE, TC_FROMSTRING);

   102

	SetDParam(0, p->player_money);

   103

	DrawStringRightAligned(182, y, STR_7028, TC_FROMSTRING);

   104

   105

	y += 10;

   106

   107

	DrawString(2, y, STR_7027_LOAN, TC_FROMSTRING);

   108

	SetDParam(0, p->current_loan);

   109

	DrawStringRightAligned(182, y, STR_7028, TC_FROMSTRING);

   110

   111

	y += 12;

   112

   113

	GfxFillRect(182 - 75, y - 2, 182, y - 2, 215);

   114

   115

	SetDParam(0, p->player_money - p->current_loan);

   116

	DrawStringRightAligned(182, y, STR_7028, TC_FROMSTRING);

   117

}

   118

   119

enum PlayerFinancesWindowWidgets {

   120

	PFW_WIDGET_TOGGLE_SIZE   = 2,

   121

	PFW_WIDGET_INCREASE_LOAN = 6,

   122

	PFW_WIDGET_REPAY_LOAN    = 7,

   123

};

   124

   125

static const Widget _player_finances_widgets[] = {

   126

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,               STR_018B_CLOSE_WINDOW},

   127

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   379,     0,    13, STR_700E_FINANCES,      STR_018C_WINDOW_TITLE_DRAG_THIS},

   128

{     WWT_IMGBTN,   RESIZE_NONE,    14,   380,   394,     0,    13, SPR_LARGE_SMALL_WINDOW, STR_7075_TOGGLE_LARGE_SMALL_WINDOW},

   129

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   395,   406,     0,    13, 0x0,                    STR_STICKY_BUTTON},

   130

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   406,    14, 39 + 10 * EXPENSES_END, 0x0,    STR_NULL},

   131

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   406, 40 + 10 * EXPENSES_END, 73 + 10 * EXPENSES_END, 0x0, STR_NULL},

   132

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,   202, 74 + 10 * EXPENSES_END, 85 + 10 * EXPENSES_END, STR_7029_BORROW,        STR_7035_INCREASE_SIZE_OF_LOAN},

   133

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   203,   406, 74 + 10 * EXPENSES_END, 85 + 10 * EXPENSES_END, STR_702A_REPAY,         STR_7036_REPAY_PART_OF_LOAN},

   134

{   WIDGETS_END},

   135

};

   136

   137

static const Widget _player_finances_small_widgets[] = {

   138

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,               STR_018B_CLOSE_WINDOW},

   139

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   253,     0,    13, STR_700E_FINANCES,      STR_018C_WINDOW_TITLE_DRAG_THIS},

   140

{     WWT_IMGBTN,   RESIZE_NONE,    14,   254,   267,     0,    13, SPR_LARGE_SMALL_WINDOW, STR_7075_TOGGLE_LARGE_SMALL_WINDOW},

   141

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   268,   279,     0,    13, 0x0,                    STR_STICKY_BUTTON},

   142

{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                    STR_NULL},

   143

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   279,    14,    47, STR_NULL,               STR_NULL},

   144

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,   139,    48,    59, STR_7029_BORROW,        STR_7035_INCREASE_SIZE_OF_LOAN},

   145

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   140,   279,    48,    59, STR_702A_REPAY,         STR_7036_REPAY_PART_OF_LOAN},

   146

{   WIDGETS_END},

   147

};

   148

   149

struct PlayerFinancesWindow : Window {

   150

	bool small;

   151

   152

	PlayerFinancesWindow(const WindowDesc *desc, PlayerID player, bool show_small,

   153

					bool show_stickied, int top, int left) :

   154

			Window(desc, player),

   155

			small(show_small)

   156

	{

   157

		this->caption_color = this->window_number;

   158

   159

		if (show_stickied) this->flags4 |= WF_STICKY;

   160

   161

		/* Check if repositioning from default is required */

   162

		if (top != FIRST_GUI_CALL && left != FIRST_GUI_CALL) {

   163

			this->top = top;

   164

			this->left = left;

   165

		}

   166

   167

		this->FindWindowPlacementAndResize(desc);

   168

	}

   169

   170

	virtual void OnPaint()

   171

	{

   172

		PlayerID player = (PlayerID)this->window_number;

   173

		const Player *p = GetPlayer(player);

   174

   175

		/* Recheck the size of the window as it might need to be resized due to the local player changing */

   176

		int new_height = ((player != _local_player) ? 0 : 12) + ((this->small != 0) ? 48 : 74 + 10 * EXPENSES_END);

   177

		if (this->height != new_height) {

   178

			/* Make window dirty before and after resizing */

   179

			this->SetDirty();

   180

			this->height = new_height;

   181

			this->SetDirty();

   182

   183

			this->SetWidgetHiddenState(PFW_WIDGET_INCREASE_LOAN, player != _local_player);

   184

			this->SetWidgetHiddenState(PFW_WIDGET_REPAY_LOAN,    player != _local_player);

   185

		}

   186

   187

		/* Borrow button only shows when there is any more money to loan */

   188

		this->SetWidgetDisabledState(PFW_WIDGET_INCREASE_LOAN, p->current_loan == _economy.max_loan);

   189

   190

		/* Repay button only shows when there is any more money to repay */

   191

		this->SetWidgetDisabledState(PFW_WIDGET_REPAY_LOAN, player != _local_player || p->current_loan == 0);

   192

   193

		SetDParam(0, p->index);

   194

		SetDParam(1, p->index);

   195

		SetDParam(2, LOAN_INTERVAL);

   196

		this->DrawWidgets();

   197

   198

		DrawPlayerEconomyStats(p, this->small);

   199

	}

   200

   201

	virtual void OnClick(Point pt, int widget)

   202

	{

   203

		switch (widget) {

   204

			case PFW_WIDGET_TOGGLE_SIZE: {/* toggle size */

   205

				bool new_mode = !this->small;

   206

				bool stickied = !!(this->flags4 & WF_STICKY);

   207

				int oldtop = this->top;   ///< current top position of the window before closing it

   208

				int oldleft = this->left; ///< current left position of the window before closing it

   209

				PlayerID player = (PlayerID)this->window_number;

   210

   211

				delete this;

   212

				/* Open up the (toggled size) Finance window at the same position as the previous */

   213

				DoShowPlayerFinances(player, new_mode, stickied, oldtop, oldleft);

   214

			}

   215

			break;

   216

   217

			case PFW_WIDGET_INCREASE_LOAN: /* increase loan */

   218

				DoCommandP(0, 0, _ctrl_pressed, NULL, CMD_INCREASE_LOAN | CMD_MSG(STR_702C_CAN_T_BORROW_ANY_MORE_MONEY));

   219

				break;

   220

   221

			case PFW_WIDGET_REPAY_LOAN: /* repay loan */

   222

				DoCommandP(0, 0, _ctrl_pressed, NULL, CMD_DECREASE_LOAN | CMD_MSG(STR_702F_CAN_T_REPAY_LOAN));

   223

				break;

   224

		}

   225

	}

   226

};

   227

   228

static const WindowDesc _player_finances_desc = {

   229

	WDP_AUTO, WDP_AUTO, 407, 86 + 10 * EXPENSES_END, 407, 86 + 10 * EXPENSES_END,

   230

	WC_FINANCES, WC_NONE,

   231

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   232

	_player_finances_widgets,

   233

};

   234

   235

static const WindowDesc _player_finances_small_desc = {

   236

	WDP_AUTO, WDP_AUTO, 280, 60, 280, 60,

   237

	WC_FINANCES, WC_NONE,

   238

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   239

	_player_finances_small_widgets,

   240

};

   241

   242

/**

   243

 * Open the small/large finance window of the player

   244

 *

   245

 * @param player         the player who's finances are requested to be seen

   246

 * @param show_small     show large or small version opf the window

   247

 * @param show_stickied  previous "stickyness" of the window

   248

 * @param top            previous top position of the window

   249

 * @param left           previous left position of the window

   250

 *

   251

 * @pre is player a valid player

   252

 */

   253

static void DoShowPlayerFinances(PlayerID player, bool show_small, bool show_stickied, int top, int left)

   254

{

   255

	if (!IsValidPlayer(player)) return;

   256

   257

	if (BringWindowToFrontById(WC_FINANCES, player)) return;

   258

	new PlayerFinancesWindow(show_small ? &_player_finances_small_desc : &_player_finances_desc, player, show_small, show_stickied, top, left);

   259

}

   260

   261

void ShowPlayerFinances(PlayerID player)

   262

{

   263

	DoShowPlayerFinances(player, false, false);

   264

}

   265

   266

/* List of colours for the livery window */

   267

static const StringID _colour_dropdown[] = {

   268

	STR_00D1_DARK_BLUE,

   269

	STR_00D2_PALE_GREEN,

   270

	STR_00D3_PINK,

   271

	STR_00D4_YELLOW,

   272

	STR_00D5_RED,

   273

	STR_00D6_LIGHT_BLUE,

   274

	STR_00D7_GREEN,

   275

	STR_00D8_DARK_GREEN,

   276

	STR_00D9_BLUE,

   277

	STR_00DA_CREAM,

   278

	STR_00DB_MAUVE,

   279

	STR_00DC_PURPLE,

   280

	STR_00DD_ORANGE,

   281

	STR_00DE_BROWN,

   282

	STR_00DF_GREY,

   283

	STR_00E0_WHITE,

   284

};

   285

   286

/* Association of liveries to livery classes */

   287

static const LiveryClass _livery_class[LS_END] = {

   288

	LC_OTHER,

   289

	LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL, LC_RAIL,

   290

	LC_ROAD, LC_ROAD,

   291

	LC_SHIP, LC_SHIP,

   292

	LC_AIRCRAFT, LC_AIRCRAFT, LC_AIRCRAFT,

   293

	LC_ROAD, LC_ROAD,

   294

};

   295

   296

class DropDownListColourItem : public DropDownListItem {

   297

public:

   298

	DropDownListColourItem(int result, bool masked) : DropDownListItem(result, masked) {}

   299

   300

	virtual ~DropDownListColourItem() {}

   301

   302

	virtual StringID String() const

   303

	{

   304

		return _colour_dropdown[this->result];

   305

	}

   306

   307

	virtual uint Height(uint width) const

   308

	{

   309

		return 14;

   310

	}

   311

   312

	virtual void Draw(int x, int y, uint width, uint height, bool sel) const

   313

	{

   314

		DrawSprite(SPR_VEH_BUS_SIDE_VIEW, PALETTE_RECOLOR_START + this->result, x + 16, y + 7);

   315

		DrawStringTruncated(x + 32, y + 3, this->String(), sel ? TC_WHITE : TC_BLACK, x + width - 30);

   316

	}

   317

};

   318

   319

struct SelectPlayerLiveryWindow : public Window {

   320

private:

   321

	uint32 sel;

   322

	LiveryClass livery_class;

   323

   324

	enum PlayerLiveryWindowWidgets {

   325

		PLW_WIDGET_CLOSE,

   326

		PLW_WIDGET_CAPTION,

   327

		PLW_WIDGET_CLASS_GENERAL,

   328

		PLW_WIDGET_CLASS_RAIL,

   329

		PLW_WIDGET_CLASS_ROAD,

   330

		PLW_WIDGET_CLASS_SHIP,

   331

		PLW_WIDGET_CLASS_AIRCRAFT,

   332

		PLW_WIDGET_SPACER_CLASS,

   333

		PLW_WIDGET_SPACER_DROPDOWN,

   334

		PLW_WIDGET_PRI_COL_DROPDOWN,

   335

		PLW_WIDGET_SEC_COL_DROPDOWN,

   336

		PLW_WIDGET_MATRIX,

   337

	};

   338

   339

	void ShowColourDropDownMenu(uint32 widget)

   340

	{

   341

		uint32 used_colours = 0;

   342

		const Livery *livery;

   343

		LiveryScheme scheme;

   344

   345

		/* Disallow other player colours for the primary colour */

   346

		if (HasBit(this->sel, LS_DEFAULT) && widget == PLW_WIDGET_PRI_COL_DROPDOWN) {

   347

			const Player *p;

   348

			FOR_ALL_PLAYERS(p) {

   349

				if (p->is_active && p->index != _local_player) SetBit(used_colours, p->player_color);

   350

			}

   351

		}

   352

   353

		/* Get the first selected livery to use as the default dropdown item */

   354

		for (scheme = LS_BEGIN; scheme < LS_END; scheme++) {

   355

			if (HasBit(this->sel, scheme)) break;

   356

		}

   357

		if (scheme == LS_END) scheme = LS_DEFAULT;

   358

		livery = &GetPlayer((PlayerID)this->window_number)->livery[scheme];

   359

   360

		DropDownList *list = new DropDownList();

   361

		for (uint i = 0; i < lengthof(_colour_dropdown); i++) {

   362

			list->push_back(new DropDownListColourItem(i, HasBit(used_colours, i)));

   363

		}

   364

   365

		ShowDropDownList(this, list, widget == PLW_WIDGET_PRI_COL_DROPDOWN ? livery->colour1 : livery->colour2, widget);

   366

	}

   367

   368

public:

   369

	SelectPlayerLiveryWindow(const WindowDesc *desc, PlayerID player) : Window(desc, player)

   370

	{

   371

		this->caption_color = player;

   372

		this->livery_class = LC_OTHER;

   373

		this->sel = 1;

   374

		this->LowerWidget(PLW_WIDGET_CLASS_GENERAL);

   375

		this->OnInvalidateData(_loaded_newgrf_features.has_2CC);

   376

		this->FindWindowPlacementAndResize(desc);

   377

	}

   378

   379

	virtual void OnPaint()

   380

	{

   381

		const Player *p = GetPlayer((PlayerID)this->window_number);

   382

		LiveryScheme scheme = LS_DEFAULT;

   383

		int y = 51;

   384

   385

		/* Disable dropdown controls if no scheme is selected */

   386

		this->SetWidgetDisabledState(PLW_WIDGET_PRI_COL_DROPDOWN, this->sel == 0);

   387

		this->SetWidgetDisabledState(PLW_WIDGET_SEC_COL_DROPDOWN, this->sel == 0);

   388

   389

		if (this->sel != 0) {

   390

			for (scheme = LS_BEGIN; scheme < LS_END; scheme++) {

   391

				if (HasBit(this->sel, scheme)) break;

   392

			}

   393

			if (scheme == LS_END) scheme = LS_DEFAULT;

   394

		}

   395

   396

		SetDParam(0, STR_00D1_DARK_BLUE + p->livery[scheme].colour1);

   397

		SetDParam(1, STR_00D1_DARK_BLUE + p->livery[scheme].colour2);

   398

   399

		this->DrawWidgets();

   400

   401

		for (scheme = LS_DEFAULT; scheme < LS_END; scheme++) {

   402

			if (_livery_class[scheme] == this->livery_class) {

   403

				bool sel = HasBit(this->sel, scheme) != 0;

   404

   405

				if (scheme != LS_DEFAULT) {

   406

					DrawSprite(p->livery[scheme].in_use ? SPR_BOX_CHECKED : SPR_BOX_EMPTY, PAL_NONE, 2, y);

   407

				}

   408

   409

				DrawString(15, y, STR_LIVERY_DEFAULT + scheme, sel ? TC_WHITE : TC_BLACK);

   410

   411

				DrawSprite(SPR_SQUARE, GENERAL_SPRITE_COLOR(p->livery[scheme].colour1), 152, y);

   412

				DrawString(165, y, STR_00D1_DARK_BLUE + p->livery[scheme].colour1, sel ? TC_WHITE : TC_GOLD);

   413

   414

				if (!this->IsWidgetHidden(PLW_WIDGET_SEC_COL_DROPDOWN)) {

   415

					DrawSprite(SPR_SQUARE, GENERAL_SPRITE_COLOR(p->livery[scheme].colour2), 277, y);

   416

					DrawString(290, y, STR_00D1_DARK_BLUE + p->livery[scheme].colour2, sel ? TC_WHITE : TC_GOLD);

   417

				}

   418

   419

				y += 14;

   420

			}

   421

		}

   422

	}

   423

   424

	virtual void OnClick(Point pt, int widget)

   425

	{

   426

		/* Number of liveries in each class, used to determine the height of the livery window */

   427

		static const byte livery_height[] = {

   428

			1,

   429

			13,

   430

			4,

   431

			2,

   432

			3,

   433

		};

   434

   435

		switch (widget) {

   436

			/* Livery Class buttons */

   437

			case PLW_WIDGET_CLASS_GENERAL:

   438

			case PLW_WIDGET_CLASS_RAIL:

   439

			case PLW_WIDGET_CLASS_ROAD:

   440

			case PLW_WIDGET_CLASS_SHIP:

   441

			case PLW_WIDGET_CLASS_AIRCRAFT: {

   442

				LiveryScheme scheme;

   443

   444

				this->RaiseWidget(this->livery_class + PLW_WIDGET_CLASS_GENERAL);

   445

				this->livery_class = (LiveryClass)(widget - PLW_WIDGET_CLASS_GENERAL);

   446

				this->sel = 0;

   447

				this->LowerWidget(this->livery_class + PLW_WIDGET_CLASS_GENERAL);

   448

   449

				/* Select the first item in the list */

   450

				for (scheme = LS_DEFAULT; scheme < LS_END; scheme++) {

   451

					if (_livery_class[scheme] == this->livery_class) {

   452

						this->sel = 1 << scheme;

   453

						break;

   454

					}

   455

				}

   456

				this->height = 49 + livery_height[this->livery_class] * 14;

   457

				this->widget[PLW_WIDGET_MATRIX].bottom = this->height - 1;

   458

				this->widget[PLW_WIDGET_MATRIX].data = livery_height[this->livery_class] << 8 | 1;

   459

				MarkWholeScreenDirty();

   460

				break;

   461

			}

   462

   463

			case PLW_WIDGET_PRI_COL_DROPDOWN: /* First colour dropdown */

   464

				ShowColourDropDownMenu(PLW_WIDGET_PRI_COL_DROPDOWN);

   465

				break;

   466

   467

			case PLW_WIDGET_SEC_COL_DROPDOWN: /* Second colour dropdown */

   468

				ShowColourDropDownMenu(PLW_WIDGET_SEC_COL_DROPDOWN);

   469

				break;

   470

   471

			case PLW_WIDGET_MATRIX: {

   472

				LiveryScheme scheme;

   473

				LiveryScheme j = (LiveryScheme)((pt.y - 48) / 14);

   474

   475

				for (scheme = LS_BEGIN; scheme <= j; scheme++) {

   476

					if (_livery_class[scheme] != this->livery_class) j++;

   477

					if (scheme >= LS_END) return;

   478

				}

   479

				if (j >= LS_END) return;

   480

   481

				/* If clicking on the left edge, toggle using the livery */

   482

				if (pt.x < 10) {

   483

					DoCommandP(0, j | (2 << 8), !GetPlayer((PlayerID)this->window_number)->livery[j].in_use, NULL, CMD_SET_PLAYER_COLOR);

   484

				}

   485

   486

				if (_ctrl_pressed) {

   487

					ToggleBit(this->sel, j);

   488

				} else {

   489

					this->sel = 1 << j;

   490

				}

   491

				this->SetDirty();