# widget_type.h

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
    00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
    00008  */
    00009
    00012 #ifndef WIDGET_TYPE_H
    00013 #define WIDGET_TYPE_H
    00014
    00015 #include "core/alloc_type.hpp"
    00016 #include "core/bitmath_func.hpp"
    00017 #include "core/math_func.hpp"
    00018 #include "strings_type.h"
    00019 #include "gfx_type.h"
    00020 #include "window_type.h"
    00021
    00022 static const int WIDGET_LIST_END = -1;
    00023
    00025 enum MatrixWidgetValues {
    00026   /* Number of column bits of the WWT_MATRIX widget data. */
    00027   MAT_COL_START = 0,
    00028   MAT_COL_BITS  = 8,
    00029
    00030   /* Number of row bits of the WWT_MATRIX widget data. */
    00031   MAT_ROW_START = 8,
    00032   MAT_ROW_BITS  = 8,
    00033 };
    00034
    00036 enum ArrowWidgetValues {
    00037   AWV_DECREASE,
    00038   AWV_INCREASE,
    00039   AWV_LEFT,
    00040   AWV_RIGHT,
    00041 };
    00042
    00046 enum WidgetType {
    00047   /* Window widget types. */
    00048   WWT_EMPTY,
    00049
    00050   WWT_PANEL,
    00051   WWT_INSET,
    00052   WWT_IMGBTN,
    00053   WWT_IMGBTN_2,
    00054   WWT_ARROWBTN,
    00055   WWT_TEXTBTN,
    00056   WWT_TEXTBTN_2,
    00057   WWT_LABEL,
    00058   WWT_TEXT,
    00059   WWT_MATRIX,
    00060   WWT_FRAME,
    00061   WWT_CAPTION,
    00062
    00063   WWT_SHADEBOX,
    00064   WWT_STICKYBOX,
    00065   WWT_DEBUGBOX,
    00066   WWT_RESIZEBOX,
    00067   WWT_CLOSEBOX,
    00068   WWT_DROPDOWN,
    00069   WWT_EDITBOX,
    00070   WWT_LAST,
    00071
    00072   /* Nested widget types. */
    00073   NWID_HORIZONTAL,
    00074   NWID_HORIZONTAL_LTR,
    00075   NWID_VERTICAL,
    00076   NWID_MATRIX,
    00077   NWID_SPACER,
    00078   NWID_SELECTION,
    00079   NWID_VIEWPORT,
    00080   NWID_BUTTON_DROPDOWN,
    00081   NWID_HSCROLLBAR,
    00082   NWID_VSCROLLBAR,
    00083
    00084   /* Nested widget part types. */
    00085   WPT_RESIZE,
    00086   WPT_MINSIZE,
    00087   WPT_MINTEXTLINES,
    00088   WPT_FILL,
    00089   WPT_DATATIP,
    00090   WPT_PADDING,
    00091   WPT_PIPSPACE,
    00092   WPT_ENDCONTAINER,
    00093   WPT_FUNCTION,
    00094   WPT_SCROLLBAR,
    00095
    00096   /* Pushable window widget types. */
    00097   WWT_MASK = 0x7F,
    00098
    00099   WWB_PUSHBUTTON    = 1 << 7,
    00100
    00101   WWT_PUSHBTN       = WWT_PANEL    | WWB_PUSHBUTTON,
    00102   WWT_PUSHTXTBTN    = WWT_TEXTBTN  | WWB_PUSHBUTTON,
    00103   WWT_PUSHIMGBTN    = WWT_IMGBTN   | WWB_PUSHBUTTON,
    00104   WWT_PUSHARROWBTN  = WWT_ARROWBTN | WWB_PUSHBUTTON,
    00105 };
    00106
    00108 enum SizingType {
    00109   ST_SMALLEST,
    00110   ST_RESIZE,
    00111 };
    00112
    00113 /* Forward declarations. */
    00114 class NWidgetCore;
    00115 class Scrollbar;
    00116
    00123 class NWidgetBase : public ZeroedMemoryAllocator {
    00124 public:
    00125   NWidgetBase(WidgetType tp);
    00126
    00127   virtual void SetupSmallestSize(Window *w, bool init_array) = 0;
    00128   virtual void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) = 0;
    00129
    00130   virtual void FillNestedArray(NWidgetBase **array, uint length) = 0;
    00131
    00132   virtual NWidgetCore *GetWidgetFromPos(int x, int y) = 0;
    00133   virtual NWidgetBase *GetWidgetOfType(WidgetType tp);
    00134
    00142   FORCEINLINE void SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
    00143   {
    00144     this->padding_top = top;
    00145     this->padding_right = right;
    00146     this->padding_bottom = bottom;
    00147     this->padding_left = left;
    00148   }
    00149
    00150   FORCEINLINE uint GetHorizontalStepSize(SizingType sizing) const;
    00151   FORCEINLINE uint GetVerticalStepSize(SizingType sizing) const;
    00152
    00153   virtual void Draw(const Window *w) = 0;
    00154   virtual void SetDirty(const Window *w) const;
    00155
    00156   WidgetType type;
    00157   uint fill_x;
    00158   uint fill_y;
    00159   uint resize_x;
    00160   uint resize_y;
    00161   /* Size of the widget in the smallest window possible.
    00162    * Computed by #SetupSmallestSize() followed by #AssignSizePosition().
    00163    */
    00164   uint smallest_x;
    00165   uint smallest_y;
    00166   /* Current widget size (that is, after resizing). */
    00167   uint current_x;
    00168   uint current_y;
    00169
    00170   uint pos_x;
    00171   uint pos_y;
    00172
    00173   NWidgetBase *next;
    00174   NWidgetBase *prev;
    00175
    00176   uint8 padding_top;
    00177   uint8 padding_right;
    00178   uint8 padding_bottom;
    00179   uint8 padding_left;
    00180
    00181 protected:
    00182   FORCEINLINE void StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height);
    00183 };
    00184
    00189 FORCEINLINE uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
    00190 {
    00191   return (sizing == ST_RESIZE) ? this->resize_x : this->fill_x;
    00192 }
    00193
    00198 FORCEINLINE uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
    00199 {
    00200   return (sizing == ST_RESIZE) ? this->resize_y : this->fill_y;
    00201 }
    00202
    00211 FORCEINLINE void NWidgetBase::StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height)
    00212 {
    00213   this->pos_x = x;
    00214   this->pos_y = y;
    00215   if (sizing == ST_SMALLEST) {
    00216     this->smallest_x = given_width;
    00217     this->smallest_y = given_height;
    00218   }
    00219   this->current_x = given_width;
    00220   this->current_y = given_height;
    00221 }
    00222
    00223
    00228 class NWidgetResizeBase : public NWidgetBase {
    00229 public:
    00230   NWidgetResizeBase(WidgetType tp, uint fill_x, uint fill_y);
    00231
    00232   void SetMinimalSize(uint min_x, uint min_y);
    00233   void SetMinimalTextLines(uint8 min_lines, uint8 spacing, FontSize size);
    00234   void SetFill(uint fill_x, uint fill_y);
    00235   void SetResize(uint resize_x, uint resize_y);
    00236
    00237   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00238
    00239   uint min_x;
    00240   uint min_y;
    00241 };
    00242
    00244 enum NWidgetDisplay {
    00245   /* Generic. */
    00246   NDB_LOWERED         = 0,
    00247   NDB_DISABLED        = 1,
    00248   /* Viewport widget. */
    00249   NDB_NO_TRANSPARENCY = 2,
    00250   NDB_SHADE_GREY      = 3,
    00251   NDB_SHADE_DIMMED    = 4,
    00252   /* Button dropdown widget. */
    00253   NDB_DROPDOWN_ACTIVE = 5,
    00254   /* Scrollbar widget. */
    00255   NDB_SCROLLBAR_UP    = 6,
    00256   NDB_SCROLLBAR_DOWN  = 7,
    00257
    00258   ND_LOWERED  = 1 << NDB_LOWERED,
    00259   ND_DISABLED = 1 << NDB_DISABLED,
    00260   ND_NO_TRANSPARENCY = 1 << NDB_NO_TRANSPARENCY,
    00261   ND_SHADE_GREY      = 1 << NDB_SHADE_GREY,
    00262   ND_SHADE_DIMMED    = 1 << NDB_SHADE_DIMMED,
    00263   ND_DROPDOWN_ACTIVE = 1 << NDB_DROPDOWN_ACTIVE,
    00264   ND_SCROLLBAR_UP    = 1 << NDB_SCROLLBAR_UP,
    00265   ND_SCROLLBAR_DOWN  = 1 << NDB_SCROLLBAR_DOWN,
    00266   ND_SCROLLBAR_BTN   = ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN,
    00267 };
    00268 DECLARE_ENUM_AS_BIT_SET(NWidgetDisplay)
    00269
    00270
    00274 class NWidgetCore : public NWidgetResizeBase {
    00275 public:
    00276   NWidgetCore(WidgetType tp, Colours colour, uint fill_x, uint fill_y, uint16 widget_data, StringID tool_tip);
    00277
    00278   void SetIndex(int index);
    00279   void SetDataTip(uint16 widget_data, StringID tool_tip);
    00280
    00281   inline void SetLowered(bool lowered);
    00282   inline bool IsLowered() const;
    00283   inline void SetDisabled(bool disabled);
    00284   inline bool IsDisabled() const;
    00285
    00286   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00287   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00288
    00289   NWidgetDisplay disp_flags;
    00290   Colours colour;
    00291   int index;
    00292   uint16 widget_data;
    00293   StringID tool_tip;
    00294   int scrollbar_index;
    00295 };
    00296
    00301 inline void NWidgetCore::SetLowered(bool lowered)
    00302 {
    00303   this->disp_flags = lowered ? SETBITS(this->disp_flags, ND_LOWERED) : CLRBITS(this->disp_flags, ND_LOWERED);
    00304 }
    00305
    00307 inline bool NWidgetCore::IsLowered() const
    00308 {
    00309   return HasBit(this->disp_flags, NDB_LOWERED);
    00310 }
    00311
    00316 inline void NWidgetCore::SetDisabled(bool disabled)
    00317 {
    00318   this->disp_flags = disabled ? SETBITS(this->disp_flags, ND_DISABLED) : CLRBITS(this->disp_flags, ND_DISABLED);
    00319 }
    00320
    00322 inline bool NWidgetCore::IsDisabled() const
    00323 {
    00324   return HasBit(this->disp_flags, NDB_DISABLED);
    00325 }
    00326
    00327
    00332 class NWidgetContainer : public NWidgetBase {
    00333 public:
    00334   NWidgetContainer(WidgetType tp);
    00335   ~NWidgetContainer();
    00336
    00337   void Add(NWidgetBase *wid);
    00338   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00339
    00341   inline bool IsEmpty() { return head == NULL; }
    00342
    00343   /* virtual */ NWidgetBase *GetWidgetOfType(WidgetType tp);
    00344
    00345 protected:
    00346   NWidgetBase *head;
    00347   NWidgetBase *tail;
    00348 };
    00349
    00351 enum StackedZeroSizePlanes {
    00352   SZSP_VERTICAL = INT_MAX / 2,
    00353   SZSP_HORIZONTAL,
    00354   SZSP_NONE,
    00355
    00356   SZSP_BEGIN = SZSP_VERTICAL,
    00357 };
    00358
    00369 class NWidgetStacked : public NWidgetContainer {
    00370 public:
    00371   NWidgetStacked();
    00372
    00373   void SetIndex(int index);
    00374
    00375   void SetupSmallestSize(Window *w, bool init_array);
    00376   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00377   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00378
    00379   /* virtual */ void Draw(const Window *w);
    00380   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00381
    00382   void SetDisplayedPlane(int plane);
    00383
    00384   int shown_plane;
    00385   int index;
    00386 };
    00387
    00389 enum NWidContainerFlags {
    00390   NCB_EQUALSIZE = 0,
    00391
    00392   NC_NONE = 0,
    00393   NC_EQUALSIZE = 1 << NCB_EQUALSIZE,
    00394 };
    00395 DECLARE_ENUM_AS_BIT_SET(NWidContainerFlags)
    00396
    00397
    00398 class NWidgetPIPContainer : public NWidgetContainer {
    00399 public:
    00400   NWidgetPIPContainer(WidgetType tp, NWidContainerFlags flags = NC_NONE);
    00401
    00402   void SetPIP(uint8 pip_pre, uint8 pip_inter, uint8 pip_post);
    00403
    00404   /* virtual */ void Draw(const Window *w);
    00405   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00406
    00407 protected:
    00408   NWidContainerFlags flags;
    00409   uint8 pip_pre;
    00410   uint8 pip_inter;
    00411   uint8 pip_post;
    00412 };
    00413
    00418 class NWidgetHorizontal : public NWidgetPIPContainer {
    00419 public:
    00420   NWidgetHorizontal(NWidContainerFlags flags = NC_NONE);
    00421
    00422   void SetupSmallestSize(Window *w, bool init_array);
    00423   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00424 };
    00425
    00430 class NWidgetHorizontalLTR : public NWidgetHorizontal {
    00431 public:
    00432   NWidgetHorizontalLTR(NWidContainerFlags flags = NC_NONE);
    00433
    00434   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00435 };
    00436
    00441 class NWidgetVertical : public NWidgetPIPContainer {
    00442 public:
    00443   NWidgetVertical(NWidContainerFlags flags = NC_NONE);
    00444
    00445   void SetupSmallestSize(Window *w, bool init_array);
    00446   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00447 };
    00448
    00457 class NWidgetMatrix : public NWidgetPIPContainer {
    00458 public:
    00459   NWidgetMatrix();
    00460
    00461   void SetIndex(int index);
    00462   void SetColour(Colours colour);
    00463   void SetClicked(int clicked);
    00464   void SetCount(int count);
    00465   void SetScrollbar(Scrollbar *sb);
    00466
    00467   void SetupSmallestSize(Window *w, bool init_array);
    00468   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00469   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00470
    00471   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00472   /* virtual */ void Draw(const Window *w);
    00473 protected:
    00474   int index;
    00475   Colours colour;
    00476   int clicked;
    00477   int count;
    00478   Scrollbar *sb;
    00479 private:
    00480   int widget_w;
    00481   int widget_h;
    00482   int widgets_x;
    00483   int widgets_y;
    00484
    00485   void GetScrollOffsets(int &start_x, int &start_y, int &base_offs_x, int &base_offs_y);
    00486 };
    00487
    00488
    00493 class NWidgetSpacer : public NWidgetResizeBase {
    00494 public:
    00495   NWidgetSpacer(int length, int height);
    00496
    00497   void SetupSmallestSize(Window *w, bool init_array);
    00498   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00499
    00500   /* virtual */ void Draw(const Window *w);
    00501   /* virtual */ void SetDirty(const Window *w) const;
    00502   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00503 };
    00504
    00509 class NWidgetBackground : public NWidgetCore {
    00510 public:
    00511   NWidgetBackground(WidgetType tp, Colours colour, int index, NWidgetPIPContainer *child = NULL);
    00512   ~NWidgetBackground();
    00513
    00514   void Add(NWidgetBase *nwid);
    00515   void SetPIP(uint8 pip_pre, uint8 pip_inter, uint8 pip_post);
    00516
    00517   void SetupSmallestSize(Window *w, bool init_array);
    00518   void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl);
    00519
    00520   /* virtual */ void FillNestedArray(NWidgetBase **array, uint length);
    00521
    00522   /* virtual */ void Draw(const Window *w);
    00523   /* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);
    00524   /* virtual */ NWidgetBase *GetWidgetOfType(WidgetType tp);
    00525
    00526 private:
    00527   NWidgetPIPContainer *child;
    00528 };
    00529
    00539 class NWidgetViewport : public NWidgetCore {
    00540 public:
    00541   NWidgetViewport(int index);
    00542
    00543   /* virtual */ void SetupSmallestSize(Window *w, bool init_array);
    00544   /* virtual */ void Draw(const Window *w);
    00545
    00546   void InitializeViewport(Window *w, uint32 follow_flags, ZoomLevel zoom);
    00547   void UpdateViewportCoordinates(Window *w);
    00548 };
    00549
    00553 class Scrollbar {
    00554 private:
    00555   const bool is_vertical;
    00556   uint16 count;
    00557   uint16 cap;
    00558   uint16 pos;
    00559   uint16 stepsize;
    00560
    00561 public:
    00563   enum ScrollbarStepping {
    00564     SS_RAW,
    00565     SS_SMALL,
    00566     SS_BIG,
    00567   };
    00568
    00569   Scrollbar(bool is_vertical) : is_vertical(is_vertical), stepsize(1)
    00570   {
    00571   }
    00572
    00577   FORCEINLINE uint16 GetCount() const
    00578   {
    00579     return this->count;
    00580   }
    00581
    00586   FORCEINLINE uint16 GetCapacity() const
    00587   {
    00588     return this->cap;
    00589   }
    00590
    00595   FORCEINLINE uint16 GetPosition() const
    00596   {
    00597     return this->pos;
    00598   }
    00599
    00605   FORCEINLINE bool IsVisible(uint16 item) const
    00606   {
    00607     return IsInsideBS(item, this->GetPosition(), this->GetCapacity());
    00608   }
    00609
    00614   FORCEINLINE bool IsVertical() const
    00615   {
    00616     return this->is_vertical;
    00617   }
    00618
    00623   void SetStepSize(uint16 stepsize)
    00624   {
    00625     assert(stepsize > 0);
    00626     this->stepsize = stepsize;
    00627   }
    00628
    00634   void SetCount(int num)
    00635   {
    00636     assert(num >= 0);
    00637     assert(num <= MAX_UVALUE(uint16));
    00638
    00639     this->count = num;
    00640     num -= this->cap;
    00641     if (num < 0) num = 0;
    00642     if (num < this->pos) this->pos = num;
    00643   }
    00644
    00650   void SetCapacity(int capacity)
    00651   {
    00652     assert(capacity > 0);
    00653     assert(capacity <= MAX_UVALUE(uint16));
    00654
    00655     this->cap = capacity;
    00656     if (this->cap + this->pos > this->count) this->pos = max(0, this->count - this->cap);
    00657   }
    00658
    00659   void SetCapacityFromWidget(Window *w, int widget, int padding = 0);
    00660
    00665   void SetPosition(int position)
    00666   {
    00667     assert(position >= 0);
    00668     assert(this->count <= this->cap ? (position == 0) : (position + this->cap <= this->count));
    00669     this->pos = position;
    00670   }
    00671
    00678   void UpdatePosition(int difference, ScrollbarStepping unit = SS_SMALL)
    00679   {
    00680     if (difference == 0) return;
    00681     switch (unit) {
    00682       case SS_SMALL: difference *= this->stepsize; break;
    00683       case SS_BIG:   difference *= this->cap; break;
    00684       default: break;
    00685     }
    00686     this->SetPosition(Clamp(this->pos + difference, 0, max(this->count - this->cap, 0)));
    00687   }
    00688
    00695   void ScrollTowards(int position)
    00696   {
    00697     if (position < this->GetPosition()) {
    00698       /* scroll up to the item */
    00699       this->SetPosition(position);
    00700     } else if (position >= this->GetPosition() + this->GetCapacity()) {
    00701       /* scroll down so that the item is at the bottom */
    00702       this->SetPosition(position - this->GetCapacity() + 1);
    00703     }
    00704   }
    00705
    00706   int GetScrolledRowFromWidget(int clickpos, const Window * const w, int widget, int padding = 0, int line_height = -1) const;
    00707 };
    00708
    00714 class NWidgetScrollbar : public NWidgetCore, public Scrollbar {
    00715 public:
    00716   NWidgetScrollbar(WidgetType tp, Colours colour, int index);
    00717
    00718   /* virtual */ void SetupSmallestSize(Window *w, bool init_array);
    00719   /* virtual */ void Draw(const Window *w);
    00720 };
    00721
    00726 class NWidgetLeaf : public NWidgetCore {
    00727 public:
    00728   NWidgetLeaf(WidgetType tp, Colours colour, int index, uint16 data, StringID tip);
    00729
    00730   /* virtual */ void SetupSmallestSize(Window *w, bool init_array);
    00731   /* virtual */ void Draw(const Window *w);
    00732
    00733   bool ButtonHit(const Point &pt);
    00734
    00735   static void InvalidateDimensionCache();
    00736 private:
    00737   static Dimension shadebox_dimension;
    00738   static Dimension debugbox_dimension;
    00739   static Dimension stickybox_dimension;
    00740   static Dimension resizebox_dimension;
    00741   static Dimension closebox_dimension;
    00742 };
    00743
    00751 static FORCEINLINE uint ComputeMaxSize(uint base, uint max_space, uint step)
    00752 {
    00753   if (base >= max_space || step == 0) return base;
    00754   if (step == 1) return max_space;
    00755   uint increment = max_space - base;
    00756   increment -= increment % step;
    00757   return base + increment;
    00758 }
    00759
    00811 struct NWidgetPartDataTip {
    00812   uint16 data;
    00813   StringID tooltip;
    00814 };
    00815
    00820 struct NWidgetPartWidget {
    00821   Colours colour;
    00822   int16 index;
    00823 };
    00824
    00829 struct NWidgetPartPaddings {
    00830   uint8 top, right, bottom, left;
    00831 };
    00832
    00837 struct NWidgetPartPIP {
    00838   uint8 pre, inter, post;
    00839 };
    00840
    00845 struct NWidgetPartTextLines {
    00846   uint8 lines;
    00847   uint8 spacing;
    00848   FontSize size;
    00849 };
    00850
    00857 typedef NWidgetBase *NWidgetFunctionType(int *biggest_index);
    00858
    00863 struct NWidgetPart {
    00864   WidgetType type;
    00865   union {
    00866     Point xy;
    00867     NWidgetPartDataTip data_tip;
    00868     NWidgetPartWidget widget;
    00869     NWidgetPartPaddings padding;
    00870     NWidgetPartPIP pip;
    00871     NWidgetPartTextLines text_lines;
    00872     NWidgetFunctionType *func_ptr;
    00873     NWidContainerFlags cont_flags;
    00874   } u;
    00875 };
    00876
    00883 static inline NWidgetPart SetResize(int16 dx, int16 dy)
    00884 {
    00885   NWidgetPart part;
    00886
    00887   part.type = WPT_RESIZE;
    00888   part.u.xy.x = dx;
    00889   part.u.xy.y = dy;
    00890
    00891   return part;
    00892 }
    00893
    00900 static inline NWidgetPart SetMinimalSize(int16 x, int16 y)
    00901 {
    00902   NWidgetPart part;
    00903
    00904   part.type = WPT_MINSIZE;
    00905   part.u.xy.x = x;
    00906   part.u.xy.y = y;
    00907
    00908   return part;
    00909 }
    00910
    00918 static inline NWidgetPart SetMinimalTextLines(uint8 lines, uint8 spacing, FontSize size = FS_NORMAL)
    00919 {
    00920   NWidgetPart part;
    00921
    00922   part.type = WPT_MINTEXTLINES;
    00923   part.u.text_lines.lines = lines;
    00924   part.u.text_lines.spacing = spacing;
    00925   part.u.text_lines.size = size;
    00926
    00927   return part;
    00928 }
    00929
    00936 static inline NWidgetPart SetFill(uint fill_x, uint fill_y)
    00937 {
    00938   NWidgetPart part;
    00939
    00940   part.type = WPT_FILL;
    00941   part.u.xy.x = fill_x;
    00942   part.u.xy.y = fill_y;
    00943
    00944   return part;
    00945 }
    00946
    00952 static inline NWidgetPart EndContainer()
    00953 {
    00954   NWidgetPart part;
    00955
    00956   part.type = WPT_ENDCONTAINER;
    00957
    00958   return part;
    00959 }
    00960
    00967 static inline NWidgetPart SetDataTip(uint16 data, StringID tip)
    00968 {
    00969   NWidgetPart part;
    00970
    00971   part.type = WPT_DATATIP;
    00972   part.u.data_tip.data = data;
    00973   part.u.data_tip.tooltip = tip;
    00974
    00975   return part;
    00976 }
    00977
    00987 static inline NWidgetPart SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
    00988 {
    00989   NWidgetPart part;
    00990
    00991   part.type = WPT_PADDING;
    00992   part.u.padding.top = top;
    00993   part.u.padding.right = right;
    00994   part.u.padding.bottom = bottom;
    00995   part.u.padding.left = left;
    00996
    00997   return part;
    00998 }
    00999
    01005 static inline NWidgetPart SetPadding(uint8 padding)
    01006 {
    01007   return SetPadding(padding, padding, padding, padding);
    01008 }
    01009
    01017 static inline NWidgetPart SetPIP(uint8 pre, uint8 inter, uint8 post)
    01018 {
    01019   NWidgetPart part;
    01020
    01021   part.type = WPT_PIPSPACE;
    01022   part.u.pip.pre = pre;
    01023   part.u.pip.inter = inter;
    01024   part.u.pip.post = post;
    01025
    01026   return part;
    01027 }
    01028
    01036 static inline NWidgetPart SetScrollbar(int index)
    01037 {
    01038   NWidgetPart part;
    01039
    01040   part.type = WPT_SCROLLBAR;
    01041   part.u.widget.index = index;
    01042
    01043   return part;
    01044 }
    01045
    01055 static inline NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx = -1)
    01056 {
    01057   NWidgetPart part;
    01058
    01059   part.type = tp;
    01060   part.u.widget.colour = col;
    01061   part.u.widget.index = idx;
    01062
    01063   return part;
    01064 }
    01065
    01072 static inline NWidgetPart NWidget(WidgetType tp, NWidContainerFlags cont_flags = NC_NONE)
    01073 {
    01074   NWidgetPart part;
    01075
    01076   part.type = tp;
    01077   part.u.cont_flags = cont_flags;
    01078
    01079   return part;
    01080 }
    01081
    01087 static inline NWidgetPart NWidgetFunction(NWidgetFunctionType *func_ptr)
    01088 {
    01089   NWidgetPart part;
    01090
    01091   part.type = WPT_FUNCTION;
    01092   part.u.func_ptr = func_ptr;
    01093
    01094   return part;
    01095 }
    01096
    01097 NWidgetContainer *MakeNWidgets(const NWidgetPart *parts, int count, int *biggest_index, NWidgetContainer *container);
    01098 NWidgetContainer *MakeWindowNWidgetTree(const NWidgetPart *parts, int count, int *biggest_index, NWidgetStacked **shade_select);
    01099
    01100 NWidgetBase *MakeCompanyButtonRows(int *biggest_index, int widget_first, int widget_last, int max_length, StringID button_tooltip);
    01101
    01102 #endif /* WIDGET_TYPE_H */