1

/* $Id$ */

     2

     3

/** @file window.h regroups declarations for all windowing system, as well as a few helper functions */

     4

     5

#ifndef WINDOW_H

     6

#define WINDOW_H

     7

     8

#include "widget/widget.h"

     9

#include <map>

    10

    11

struct WindowEvent;

    12

    13

typedef void WindowProc(BaseWindow *w, WindowEvent *e);

    14

    15

/* How the resize system works:

    16

    First, you need to add a WWT_RESIZEBOX to the widgets, and you need

    17

     to add the flag WDF_RESIZABLE to the window. Now the window is ready

    18

     to resize itself.

    19

    As you may have noticed, all widgets have a RESIZE_XXX in their line.

    20

     This lines controls how the widgets behave on resize. RESIZE_NONE means

    21

     it doesn't do anything. Any other option let's one of the borders

    22

     move with the changed width/height. So if a widget has

    23

     RESIZE_RIGHT, and the window is made 5 pixels wider by the user,

    24

     the right of the window will also be made 5 pixels wider.

    25

    Now, what if you want to clamp a widget to the bottom? Give it the flag

    26

     RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets

    27

     5 pixels bigger, both the top and bottom gets 5 bigger, so the whole

    28

     widgets moves downwards without resizing, and appears to be clamped

    29

     to the bottom. Nice aint it?

    30

   You should know one more thing about this system. Most windows can't

    31

    handle an increase of 1 pixel. So there is a step function, which

    32

    let the windowsize only be changed by X pixels. You configure this

    33

    after making the window, like this:

    34

      w->resize.step_height = 10;

    35

    Now the window will only change in height in steps of 10.

    36

   You can also give a minimum width and height. The default value is

    37

    the default height/width of the window itself. You can change this

    38

    AFTER window-creation, with:

    39

     w->resize.width or w->resize.height.

    40

   That was all.. good luck, and enjoy :) -- TrueLight */

    41

    42

enum ResizeFlag {

    43

	RESIZE_NONE   = 0,  ///< no resize required

    44

    45

	RESIZE_LEFT   = 1,  ///< left resize flag

    46

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    47

	RESIZE_TOP    = 4,  ///< top resize flag

    48

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    49

    50

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,   ///<  combination of left and right resize flags

    51

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,  ///<  combination of right and bottom resize flags

    52

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,  ///<  combination of top and bottom resize flags

    53

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM, ///< combination of left, right and bottom resize flags

    54

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,  ///<  combination of all resize flags

    55

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM, ///<  combination of right, top and bottom resize flag

    56

    57

	/* The following flags are used by the system to specify what is disabled, hidden, or clicked

    58

	 * They are used in the same place as the above RESIZE_x flags, Widget visual_flags.

    59

	 * These states are used in exceptions. If nothing is specified, they will indicate

    60

	 * Enabled, visible or unclicked widgets*/

    61

	WIDG_DISABLED = 4,  ///< widget is greyed out, not available

    62

	WIDG_HIDDEN   = 5,  ///< widget is made invisible

    63

	WIDG_LOWERED  = 6,  ///< widget is paint lowered, a pressed button in fact

    64

};

    65

    66

DECLARE_ENUM_AS_BIT_SET(ResizeFlag);

    67

    68

enum WindowFlags {

    69

	//WF_TIMEOUT_SHL       = 0,

    70

	//WF_TIMEOUT_MASK      = 7,

    71

	WF_DRAGGING          = 1 <<  3,

    72

	WF_SCROLL_UP         = 1 <<  4,

    73

	WF_SCROLL_DOWN       = 1 <<  5,

    74

	WF_SCROLL_MIDDLE     = 1 <<  6,

    75

	WF_HSCROLL           = 1 <<  7,

    76

	WF_SIZING            = 1 <<  8,

    77

	WF_STICKY            = 1 <<  9,

    78

    79

	WF_DISABLE_VP_SCROLL = 1 << 10,

    80

    81

	//WF_WHITE_BORDER_ONE  = 1 << 11,

    82

	//WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

    83

	WF_SCROLL2           = 1 << 13,

    84

};

    85

    86

DECLARE_ENUM_AS_BIT_SET(WindowFlags);

    87

    88

/* used to indicate the end of widgets' list for vararg functions */

    89

enum {

    90

	WIDGET_LIST_END = -1, ///< indicate the end of widgets' list for vararg functions

    91

};

    92

    93

/****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/

    94

enum WindowWidgetBehaviours {

    95

	WWB_PUSHBUTTON  = 1 << 5,

    96

	WWB_MASK        = 0xE0,

    97

};

    98

    99

enum WindowWidgetTypes {

   100

	WWT_EMPTY,

   101

   102

	WWT_PANEL,      /* simple depressed panel */

   103

	WWT_INSET,      /* pressed (inset) panel, most commonly used as combo box _text_ area */

   104

	WWT_IMGBTN,     /* button with image */

   105

	WWT_IMGBTN_2,   /* button with diff image when clicked */

   106

   107

	WWT_TEXTBTN,    /* button with text */

   108

	WWT_TEXTBTN_2,  /* button with diff text when clicked */

   109

	WWT_LABEL,      /* centered label */

   110

	WWT_TEXT,       /* pure simple text */

   111

	WWT_MATRIX,

   112

	WWT_SCROLLBAR,

   113

	WWT_FRAME,      /* frame */

   114

	WWT_CAPTION,

   115

   116

	WWT_HSCROLLBAR,

   117

	WWT_STICKYBOX,

   118

	WWT_SCROLL2BAR, /* 2nd vertical scrollbar*/

   119

	WWT_RESIZEBOX,

   120

	WWT_CLOSEBOX,

   121

	WWT_LAST,       /* Last Item. use WIDGETS_END to fill up padding!! */

   122

   123

	WWT_MASK = 0x1F,

   124

   125

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   126

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   127

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   128

};

   129

   130

#define WIDGETS_END WWT_LAST,   RESIZE_NONE,     0,     0,     0,     0,     0, 0, STR_NULL

   131

   132

   133

   134

   135

void DrawFrameRect(int left, int top, int right, int bottom, int color, FrameFlags flags);

   136

   137

enum WindowEventCodes {

   138

	WE_CREATE,

   139

	WE_DESTROY,

   140

	WE_PAINT,

   141

	WE_KEYPRESS,

   142

	WE_CLICK,

   143

	WE_RCLICK,

   144

	WE_MOUSEOVER,

   145

	WE_MOUSELOOP,

   146

	WE_MOUSEWHEEL,

   147

	WE_TICK,

   148

	WE_4,

   149

	WE_TIMEOUT,

   150

	WE_PLACE_OBJ,

   151

	WE_ABORT_PLACE_OBJ,

   152

	WE_ON_EDIT_TEXT,

   153

	WE_ON_EDIT_TEXT_CANCEL,

   154

	WE_POPUPMENU_SELECT,

   155

	WE_POPUPMENU_OVER,

   156

	WE_DRAGDROP,

   157

	WE_PLACE_DRAG,

   158

	WE_PLACE_MOUSEUP,

   159

	WE_PLACE_PRESIZE,

   160

	WE_DROPDOWN_SELECT,

   161

	WE_RESIZE,

   162

	WE_MESSAGE,

   163

	WE_SCROLL,

   164

	WE_INVALIDATE_DATA,

   165

};

   166

   167

struct WindowEvent {

   168

	byte event;

   169

	union {

   170

		struct{

   171

			PointRaw pt;

   172

			int widget;

   173

		} click;

   174

   175

		struct {

   176

			PointRaw pt;

   177

			TileIndex tile;

   178

			TileIndex starttile;

   179

			int userdata;

   180

		} place;

   181

   182

		struct {

   183

			PointRaw pt;

   184

			int widget;

   185

		} dragdrop;

   186

   187

		struct {

   188

			PointRaw size;

   189

			PointRaw diff;

   190

		} sizing;

   191

   192

		struct {

   193

			char *str;

   194

		} edittext;

   195

   196

		struct {

   197

			PointRaw pt;

   198

		} popupmenu;

   199

   200

		struct {

   201

			int button;

   202

			int index;

   203

		} dropdown;

   204

   205

		struct {

   206

			PointRaw pt;

   207

			int widget;

   208

		} mouseover;

   209

   210

		struct {

   211

			bool cont;      ///< continue the search? (default true)

   212

			uint16 key;     ///< 16-bit Unicode value of the key

   213

			uint16 keycode; ///< untranslated key (including shift-state)

   214

		} keypress;

   215

   216

		struct {

   217

			int msg;      ///< message to be sent

   218

			int wparam;   ///< additional message-specific information

   219

			int lparam;   ///< additional message-specific information

   220

		} message;

   221

   222

		struct {

   223

			PointRaw delta;   ///< delta position against position of last call

   224

		} scroll;

   225

   226

		struct {

   227

			int wheel;     ///< how much was 'wheel'd'

   228

		} wheel;

   229

	} we;

   230

};

   231

   232

struct OldWidget;

   233

   234

struct WindowDesc {

   235

	int16 left, top, width, height;

   236

	WindowClass cls;

   237

	WindowClass parent_cls;

   238

	uint32 flags;

   239

	const OldWidget *widgets;

   240

	WindowProc *proc;

   241

};

   242

   243

enum WindowDefaultFlag {

   244

	WDF_STD_TOOLTIPS    =   1, ///< use standard routine when displaying tooltips

   245

	WDF_DEF_WIDGET      =   2, ///< default widget control for some widgets in the on click event

   246

	WDF_STD_BTN         =   4, ///< default handling for close and drag widgets (widget no 0 and 1)

   247

   248

	WDF_UNCLICK_BUTTONS =  16, ///< Unclick buttons when the window event times out */

   249

	WDF_STICKY_BUTTON   =  32, ///< Set window to sticky mode; they are not closed unless closed with 'X' (widget 2)

   250

	WDF_RESIZABLE       =  64, ///< A window can be resized

   251

	WDF_MODAL           = 128, ///< The window is a modal child of some other window, meaning the parent is 'inactive'

   252

};

   253

   254

/* can be used as x or y coordinates to cause a specific placement */

   255

enum WindowDefaultPosition {

   256

	WDP_AUTO      = -1, ///< Find a place automatically

   257

	WDP_CENTER    = -2, ///< Center the window (left/right or top/bottom)

   258

	WDP_ALIGN_TBR = -3, ///< Align the right side of the window with the right side of the main toolbar

   259

	WDP_ALIGN_TBL = -4, ///< Align the left side of the window with the left side of the main toolbar

   260

};

   261

   262

struct Textbuf {

   263

	char *buf;                  ///< buffer in which text is saved

   264

	uint16 maxlength, maxwidth; ///< the maximum size of the buffer. Maxwidth specifies screensize in pixels, maxlength is in bytes

   265

	uint16 length, width;       ///< the current size of the string. Width specifies screensize in pixels, length is in bytes

   266

	bool caret;                 ///< is the caret ("_") visible or not

   267

	uint16 caretpos;            ///< the current position of the caret in the buffer, in bytes

   268

	uint16 caretxoffs;          ///< the current position of the caret in pixels

   269

};

   270

   271

#define WP(ptr,str) (*(str*)(ptr)->custom)

   272

/* You cannot 100% reliably calculate the biggest custom struct as

   273

 * the number of pointers in it and alignment will have a huge impact.

   274

 * 96 is the largest window-size for 64-bit machines currently */

   275

#define WINDOW_CUSTOM_SIZE 96

   276

   277

struct Scrollbar {

   278

	uint16 count, cap, pos;

   279

};

   280

   281

struct ResizeInfo {

   282

	uint width; ///< Minimum width and height

   283

	uint height;

   284

	uint step_width; ///< In how big steps the width and height go

   285

	uint step_height;

   286

};

   287

   288

struct WindowMessage {

   289

	int msg;

   290

	int wparam;

   291

	int lparam;

   292

};

   293

   294

struct OldWidget {

   295

	WindowWidgetTypes type;           ///< OldWidget type, see @WindowWidgetTypes

   296

	byte m_display_flags;             ///< Resize direction, alignment, etc. during resizing, see @ResizeFlags

   297

	byte color;                       ///< OldWidget colour, see docs/ottd-colourtext-palette.png

   298

	int16 left, right, top, bottom;   ///< The position offsets inside the window

   299

	uint16 data;                      ///< The String/Image or special code (list-matrixes) of a widget

   300

	StringID tooltips;                ///< Tooltips that are shown when rightclicking on a widget

   301

};

   302

   303

   304

   305

struct BaseWindow;

   306

typedef CCountedPtr<BaseWindow> WindowPtr;

   307

   308

struct WindowList {

   309

	struct Item {

   310

		WindowPtr w;

   311

		Item(BaseWindow *v = NULL) : w(v) {}

   312

		Item(const Item &src) : w(src.w) {}

   313

		~Item()

   314

		{}

   315

	};

   316

	typedef std::list<Item> List;

   317

	typedef List::iterator Iterator;

   318

	typedef List::reverse_iterator ReverseIterator;

   319

   320

	List m_list;

   321

   322

	void Add(BaseWindow *w);

   323

	void Remove(BaseWindow *w);

   324

	void CloseAll();

   325

	Iterator Find(BaseWindow *w);

   326

	Iterator FindFirstVitalWindow();

   327

	Iterator FindByClass(WindowClass cls);

   328

	Iterator FindById(WindowClass cls, WindowNumber num);

   329

	Iterator FindFromPt(int x, int y);

   330

   331

	Iterator EnumT(bool (*enum_proc)(Iterator))

   332

	{

   333

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   334

			if (enum_proc(it)) return it;

   335

		}

   336

		return m_list.end();

   337

	}

   338

   339

	template <class Tmatch_1> Iterator EnumT(bool (*enum_proc)(Iterator, Tmatch_1), Tmatch_1 match)

   340

	{

   341

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   342

			if (enum_proc(it, match)) return it;

   343

		}

   344

		return m_list.end();

   345

	}

   346

   347

	template <class Tmatch_1, class Tmatch_2> Iterator EnumT(bool (*enum_proc)(Iterator, Tmatch_1, Tmatch_2), Tmatch_1 match_1, Tmatch_2 match_2)

   348

	{

   349

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   350

			if (enum_proc(it, match_1, match_2)) return it;

   351

		}

   352

		return m_list.end();

   353

	}

   354

   355

	Iterator ReverseEnumT(bool (*enum_proc)(Iterator))

   356

	{

   357

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   358

			--it;

   359

			if (enum_proc(it)) return it;

   360

		}

   361

		return m_list.end();

   362

	}

   363

   364

	template <class Tmatch_1> Iterator ReverseEnumT(bool (*enum_proc)(Iterator, Tmatch_1), Tmatch_1 match)

   365

	{

   366

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   367

			--it;

   368

			if (enum_proc(it, match)) return it;

   369

		}

   370

		return m_list.end();

   371

	}

   372

   373

	template <class Tmatch_1, class Tmatch_2> Iterator ReverseEnumT(bool (*enum_proc)(Iterator, Tmatch_1, Tmatch_2), Tmatch_1 match_1, Tmatch_2 match_2)

   374

	{

   375

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   376

			--it;

   377

			if (enum_proc(it, match_1, match_2)) return it;

   378

		}

   379

		return m_list.end();

   380

	}

   381

   382

};

   383

   384

struct BaseWindow : public gui::Panel {

   385

public:

   386

	typedef gui::Panel super;

   387

   388

	static WindowList s_list;

   389

   390

	ZeroInitBegin m_zero_init_area; ///< following members get cleared by constructor

   391

   392

	WindowFlags flags4;

   393

	WindowClass window_class;

   394

	WindowNumber window_number;

   395

   396

protected:

   397

	Point16    m_wnd_pos;

   398

   399

public:

   400

	StringID   m_caption_text;

   401

   402

	Scrollbar hscroll, vscroll, vscroll2;

   403

	ResizeInfo resize;

   404

   405

	byte caption_color;

   406

	byte autorepeat_timeout; ///< timer for scroll (spin) click autorepeat

   407

	byte flash_timeout;      ///< timer for flashing white border

   408

   409

	WindowProc *wndproc;

   410

	ViewPort *viewport;

   411

	const OldWidget *original_widget;

   412

	OldWidget *widget;

   413

	uint widget_count;

   414

	uint32 desc_flags;

   415

   416

	WindowMessage message;

   417

	BaseWindow *parent;

   418

	byte custom[WINDOW_CUSTOM_SIZE];

   419

   420

	ZeroInitEnd m_zero_init_end; ///< end of zero initialization area

   421

   422

protected:

   423

	BaseWindow(WindowClass cls, StringID caption_text = 0, byte color = COLOUR_GREY, gui::FeatureFlags feature_flags = gui::FF_NONE)

   424

		: super(NULL, feature_flags, 0, color)

   425

		, m_zero_init_area(m_zero_init_end)

   426

		, window_class(cls)

   427

		, m_caption_text(caption_text)

   428

	{}

   429

   430

public:

   431

	BaseWindow(const WindowDesc *desc, WindowNumber num = 0)

   432

		: m_zero_init_area(m_zero_init_end)

   433

	{

   434

		Create(desc, num);

   435

	}

   436

   437

	int16 Left() const;

   438

	int16 Top() const;

   439

	int16 Right() const;

   440

	int16 Bottom() const;

   441

	const Point16& TopLeft() const;

   442

	Point16 BottomRight() const;

   443

	Rect16 GetRect() const;

   444

   445

	void SetLeft(int16 val);

   446

	void SetTop(int16 val);

   447

	void SetRight(int16 val);

   448

	void SetBottom(int16 val);

   449

	void SetTopLeft(const Point16 &pt);

   450

	void SetBottomRight(const Point16 &pt);

   451

	void SetSize(const Point16 &pt);

   452

	void SetRect(const Rect16 &rect);

   453

   454

	virtual bool Create(WindowNumber num);

   455

	virtual bool Create(const WindowDesc *desc, WindowNumber num = 0);

   456

   457

	/*virtual*/ void CreateNcWidgets();

   458

	/*virtual*/ void CreateWidgets(); ///< @TODO remove it when old gui infrastructure will no longer be used

   459

   460

	/*virtual*/ void OnCreate(gui::EvtCreate &ev);

   461

	/*virtual*/ void OnPaint(gui::EvtPaint &ev);

   462

	/*virtual*/ void OnResize(gui::EvtResize &ev);

   463

   464

   465

	static BaseWindow* Allocate(int x, int y, int width, int height, WindowProc *proc, WindowClass cls, const OldWidget *widget);

   466

	static BaseWindow* Allocate(const WindowDesc *desc, int window_number = 0);

   467

	static BaseWindow* AllocateFront(const WindowDesc *desc, int window_number = 0);

   468

   469

	/*virtual*/ BaseWindow* GetWindow();

   470

	BaseWindow* FindChild() const;

   471

	void SetDirty() const;

   472

	void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...);

   473

	void CDECL SetWidgetsHiddenState(bool hidden_stat, int widgets, ...);

   474

	void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...);

   475

	void RaiseButtons();

   476

	void HandleButtonClick(byte widget);

   477

	void BringToFront();

   478

	static BaseWindow* BringToFrontById(WindowClass cls, WindowNumber number);

   479

	void StartDrag();

   480

	bool ContinueDrag();

   481

	void StartSizing();

   482

	bool ContinueSizing();

   483

	static bool HandleWindowDragging(void);

   484

	void DispatchLeftClickEvent(int x, int y);

   485

	void DispatchRightClickEvent(int x, int y);

   486

	void DispatchMouseWheelEvent(int widget, int wheel);

   487

   488