1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include <list>

     8

#include "macros.h"

     9

#include "string.h"

    10

#include "order.h"

    11

#include "rail.h"

    12

#include "airport.h"

    14

#include "misc/countedptr.hpp"

    15

    16

typedef struct WindowEvent WindowEvent;

    17

    19

    20

/* How the resize system works:

    21

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

    22

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

    23

     to resize itself.

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

     widgets moves downwards without resizing, and appears to be clamped

    34

     to the bottom. Nice aint it?

    35

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

    36

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

    37

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

    38

    after making the window, like this:

    39

      w->resize.step_height = 10;

    40

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

    41

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

    42

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

    43

    AFTER window-creation, with:

    44

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

    45

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

    46

    48

	RESIZE_NONE   = 0,

    49

    50

	RESIZE_LEFT   = 1,

    51

	RESIZE_RIGHT  = 2,

    52

	RESIZE_TOP    = 4,

    53

	RESIZE_BOTTOM = 8,

    54

    55

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    56

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    57

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    58

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    59

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    60

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    61

    62

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

    63

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

    64

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

    65

	 * Enabled, visible or unclicked widgets*/

    66

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

    67

	WIDG_HIDDEN   = 5,  // widget is made invisible

    68

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

    72

    73

enum WindowFlags {

    74

	//WF_TIMEOUT_SHL       = 0,

    75

	//WF_TIMEOUT_MASK      = 7,

    76

	WF_DRAGGING          = 1 <<  3,

    77

	WF_SCROLL_UP         = 1 <<  4,

    78

	WF_SCROLL_DOWN       = 1 <<  5,

    79

	WF_SCROLL_MIDDLE     = 1 <<  6,

    80

	WF_HSCROLL           = 1 <<  7,

    81

	WF_SIZING            = 1 <<  8,

    82

	WF_STICKY            = 1 <<  9,

    83

    84

	WF_DISABLE_VP_SCROLL = 1 << 10,

    85

    86

	//WF_WHITE_BORDER_ONE  = 1 << 11,

    87

	//WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

    88

	WF_SCROLL2           = 1 << 13,

    89

};

    90

    91

DECLARE_ENUM_AS_BIT_SET(WindowFlags);

    92

    93

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

    94

enum {

    95

	WIDGET_LIST_END = -1,

    96

};

    97

   148

   149

typedef enum FrameFlags {

   150

	FR_NONE         = 0x00,

   151

	FR_TRANSPARENT  = 0x01,  ///< Makes the background transparent if set

   152

	FR_BORDERONLY   = 0x10,  ///< Draw border only, no background

   153

	FR_LOWERED      = 0x20,  ///< If set the frame is lowered and the background color brighter (ie. buttons when pressed)

   154

	FR_DARKENED     = 0x40,  ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes)

   155

} FrameFlags;

   156

   157

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   158

   159

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

   160

   161

enum WindowEventCodes {

   162

	WE_CREATE,

   163

	WE_DESTROY,

   164

	WE_PAINT,

   165

	WE_KEYPRESS,

   166

	WE_CLICK,

   167

	WE_RCLICK,

   168

	WE_MOUSEOVER,

   169

	WE_MOUSELOOP,

   170

	WE_MOUSEWHEEL,

   171

	WE_TICK,

   172

	WE_4,

   173

	WE_TIMEOUT,

   174

	WE_PLACE_OBJ,

   175

	WE_ABORT_PLACE_OBJ,

   176

	WE_ON_EDIT_TEXT,

   177

	WE_ON_EDIT_TEXT_CANCEL,

   178

	WE_POPUPMENU_SELECT,

   179

	WE_POPUPMENU_OVER,

   180

	WE_DRAGDROP,

   181

	WE_PLACE_DRAG,

   182

	WE_PLACE_MOUSEUP,

   183

	WE_PLACE_PRESIZE,

   184

	WE_DROPDOWN_SELECT,

   185

	WE_RESIZE,

   186

	WE_MESSAGE,

   187

	WE_SCROLL,

   188

	WE_INVALIDATE_DATA,

   189

};

   190

   191

struct WindowEvent {

   192

	byte event;

   193

	union {

   194

		struct{

   195

			Point pt;

   196

			int widget;

   197

		} click;

   198

   199

		struct {

   200

			Point pt;

   201

			TileIndex tile;

   202

			TileIndex starttile;

   203

			int userdata;

   204

		} place;

   205

   206

		struct {

   207

			Point pt;

   208

			int widget;

   209

		} dragdrop;

   210

   211

		struct {

   212

			Point size;

   213

			Point diff;

   214

		} sizing;

   215

   216

		struct {

   217

			char *str;

   218

		} edittext;

   219

   220

		struct {

   221

			Point pt;

   222

		} popupmenu;

   223

   224

		struct {

   225

			int button;

   226

			int index;

   227

		} dropdown;

   228

   229

		struct {

   230

			Point pt;

   231

			int widget;

   232

		} mouseover;

   233

   234

		struct {

   235

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

   236

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

   237

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

   238

		} keypress;

   239

   240

		struct {

   241

			int msg;      // message to be sent

   242

			int wparam;   // additional message-specific information

   243

			int lparam;   // additional message-specific information

   244

		} message;

   245

   246

		struct {

   247

			Point delta;   // delta position against position of last call

   248

		} scroll;

   249

   250

		struct {

   251

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

   252

		} wheel;

   253

	} we;

   254

};

   255

   258

typedef struct WindowDesc {

   259

	int16 left, top, width, height;

   260

	WindowClass cls;

   261

	WindowClass parent_cls;

   262

	uint32 flags;

   264

	WindowProc *proc;

   265

} WindowDesc;

   266

   267

enum WindowDefaultFlag {

   268

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

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

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

   276

};

   277

   278

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

   279

enum WindowDefaultPosition {

   280

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

   281

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

   282

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

   283

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

   284

};

   285

   286

typedef struct Textbuf {

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

} Textbuf;

   294

   295

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

   296

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

   297

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

   298

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

   299

#define WINDOW_CUSTOM_SIZE 96

   300

   301

typedef struct Scrollbar {

   302

	uint16 count, cap, pos;

   303

} Scrollbar;

   304

   305

typedef struct ResizeInfo {

   306

	uint width; /* Minimum width and height */

   307

	uint height;

   308

   309

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

   310

	uint step_height;

   311

} ResizeInfo;

   312

   313

typedef struct WindowMessage {

   314

		int msg;

   315

		int wparam;

   316

		int lparam;

   317

} WindowMessage;

   318

   407

   408

struct WindowList {

   409

	struct Item {

   410

		WindowPtr w;

   412

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

   413

		~Item()

   414

		{}

   415

	};

   416

	typedef std::list<Item> List;

   417

	typedef List::iterator Iterator;

   418

	typedef List::reverse_iterator ReverseIterator;

   419

   420

	List m_list;

   421

   425

	Iterator FindFirstVitalWindow();

   426

	Iterator FindByClass(WindowClass cls);

   427

	Iterator FindById(WindowClass cls, WindowNumber num);

   429

   430

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

   431

	{

   432

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

   433

			if (enum_proc(it)) return it;

   434

		}

   435

		return m_list.end();

   436

	}

   437

   438

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

   439

	{

   440

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

   441

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

   442

		}

   443

		return m_list.end();

   444

	}

   445

   446

	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)

   447

	{

   448

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

   449

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

   450

		}

   451

		return m_list.end();

   452

	}

   453

   454

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

   455

	{

   456

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

   457

			--it;

   458

			if (enum_proc(it)) return it;

   459

		}

   460

		return m_list.end();

   461

	}

   462

   463

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

   464

	{

   465

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

   466

			--it;

   467

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

   468

		}

   469

		return m_list.end();

   470

	}

   481

};

   482

   484

public:

   485

	static WindowList s_list;

   486

   487

	WindowFlags flags4;

   488

	WindowClass window_class;

   489

	WindowNumber window_number;

   490

   491

	int left, top;