Wrap GtkListStore
[xonotic/netradiant.git] / libs / uilib / uilib.h
1 #ifndef INCLUDED_UILIB_H
2 #define INCLUDED_UILIB_H
3
4 #include <string>
5
6 struct _GdkEventKey;
7 struct _GtkAccelGroup;
8 struct _GtkAdjustment;
9 struct _GtkAlignment;
10 struct _GtkBin;
11 struct _GtkBox;
12 struct _GtkButton;
13 struct _GtkCellEditable;
14 struct _GtkCellRenderer;
15 struct _GtkCellRendererText;
16 struct _GtkCheckButton;
17 struct _GtkComboBox;
18 struct _GtkComboBoxText;
19 struct _GtkContainer;
20 struct _GtkDialog;
21 struct _GtkEditable;
22 struct _GtkEntry;
23 struct _GtkFrame;
24 struct _GtkHBox;
25 struct _GtkHPaned;
26 struct _GtkHScale;
27 struct _GtkImage;
28 struct _GtkItem;
29 struct _GtkLabel;
30 struct _GtkListStore;
31 struct _GtkMenu;
32 struct _GtkMenuShell;
33 struct _GtkMenuItem;
34 struct _GtkMisc;
35 struct _GtkObject;
36 struct _GtkPaned;
37 struct _GtkRange;
38 struct _GtkScale;
39 struct _GtkScrolledWindow;
40 struct _GtkSpinButton;
41 struct _GtkTable;
42 struct _GtkTearoffMenuItem;
43 struct _GtkTextView;
44 struct _GtkToggleButton;
45 struct _GtkTreeModel;
46 struct _GtkTreePath;
47 struct _GtkTreeView;
48 struct _GtkTreeViewColumn;
49 struct _GtkVBox;
50 struct _GtkVPaned;
51 struct _GtkWidget;
52 struct _GtkWindow;
53 struct _GTypeInstance;
54
55 struct ModalDialog;
56
57 namespace ui {
58
59     void init(int argc, char *argv[]);
60
61     void main();
62
63     extern class Widget root;
64
65     enum class alert_type {
66         OK,
67         OKCANCEL,
68         YESNO,
69         YESNOCANCEL,
70         NOYES,
71     };
72
73     enum class alert_icon {
74         Default,
75         Error,
76         Warning,
77         Question,
78         Asterisk,
79     };
80
81     enum class alert_response {
82         OK,
83         CANCEL,
84         YES,
85         NO,
86     };
87
88     enum class window_type {
89         TOP,
90         POPUP
91     };
92
93     namespace details {
94
95         enum class Convert {
96             Implicit, Explicit
97         };
98
99         template<class Self, class T, Convert mode>
100         struct Convertible;
101
102         template<class Self, class T>
103         struct Convertible<Self, T, Convert::Implicit> {
104             operator T() const
105             { return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
106         };
107
108         template<class Self, class T>
109         struct Convertible<Self, T, Convert::Explicit> {
110             explicit operator T() const
111             { return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
112         };
113
114         template<class Self, class... T>
115         struct All : T ... {
116             All()
117             {};
118         };
119
120         template<class Self, class Interfaces>
121         struct Mixin;
122         template<class Self>
123         struct Mixin<Self, void()> {
124             using type = All<Self>;
125         };
126         template<class Self, class... Interfaces>
127         struct Mixin<Self, void(Interfaces...)> {
128             using type = All<Self, Interfaces...>;
129         };
130     }
131
132     class Object :
133             public details::Convertible<Object, _GtkObject *, details::Convert::Explicit>,
134             public details::Convertible<Object, _GTypeInstance *, details::Convert::Explicit> {
135     public:
136         using native = _GtkObject *;
137         native _handle;
138
139         Object(native h) : _handle(h)
140         {}
141
142         explicit operator bool() const
143         { return _handle != nullptr; }
144
145         explicit operator void *() const
146         { return _handle; }
147     };
148     static_assert(sizeof(Object) == sizeof(Object::native), "object slicing");
149
150 #define WRAP(name, super, T, interfaces, ctors, methods) \
151     class name; \
152     class I##name { \
153     public: \
154         using self = name *; \
155         methods \
156     }; \
157     class name : public super, public details::Convertible<name, T *, details::Convert::Implicit>, public I##name, public details::Mixin<name, void interfaces>::type { \
158     public: \
159         using self = name *; \
160         using native = T *; \
161         explicit name(native h) : super(reinterpret_cast<super::native>(h)) {} \
162         ctors \
163     }; \
164     inline bool operator<(name self, name other) { return self._handle < other._handle; } \
165     static_assert(sizeof(name) == sizeof(super), "object slicing")
166
167     // https://developer.gnome.org/gtk2/stable/ch01.html
168
169     WRAP(CellEditable, Object, _GtkCellEditable, (),
170     ,
171     );
172
173     WRAP(Editable, Object, _GtkEditable, (),
174          Editable();
175     ,
176          void editable(bool value);
177     );
178
179     WRAP(Widget, Object, _GtkWidget, (),
180          Widget();
181     ,
182          alert_response alert(
183                  std::string text,
184                  std::string title = "NetRadiant",
185                  alert_type type = alert_type::OK,
186                  alert_icon icon = alert_icon::Default
187          );
188          const char *file_dialog(
189                  bool open,
190                  const char *title,
191                  const char *path = nullptr,
192                  const char *pattern = nullptr,
193                  bool want_load = false,
194                  bool want_import = false,
195                  bool want_save = false
196          );
197     );
198
199     WRAP(Container, Widget, _GtkContainer, (),
200     ,
201     );
202
203     WRAP(Bin, Container, _GtkBin, (),
204     ,
205     );
206
207     class AccelGroup;
208     WRAP(Window, Bin, _GtkWindow, (),
209          Window();
210          Window(window_type type);
211     ,
212          Window create_dialog_window(
213                  const char *title,
214                  void func(),
215                  void *data,
216                  int default_w = -1,
217                  int default_h = -1
218          );
219
220          Window create_modal_dialog_window(
221                  const char *title,
222                  ModalDialog &dialog,
223                  int default_w = -1,
224                  int default_h = -1
225          );
226
227          Window create_floating_window(const char *title);
228
229          std::uint64_t on_key_press(
230                  bool (*f)(Widget widget, _GdkEventKey *event, void *extra),
231                  void *extra = nullptr
232          );
233
234          void add_accel_group(AccelGroup group);
235     );
236
237     WRAP(Dialog, Window, _GtkDialog, (),
238     ,
239     );
240
241     WRAP(Alignment, Bin, _GtkAlignment, (),
242          Alignment(float xalign, float yalign, float xscale, float yscale);
243     ,
244     );
245
246     WRAP(Frame, Bin, _GtkFrame, (),
247          Frame(const char *label = nullptr);
248     ,
249     );
250
251     WRAP(Button, Bin, _GtkButton, (),
252          Button();
253          Button(const char *label);
254     ,
255     );
256
257     WRAP(ToggleButton, Button, _GtkToggleButton, (),
258     ,
259          bool active();
260     );
261
262     WRAP(CheckButton, ToggleButton, _GtkCheckButton, (),
263          CheckButton(const char *label);
264     ,
265     );
266
267     WRAP(Item, Bin, _GtkItem, (),
268     ,
269     );
270
271     WRAP(MenuItem, Item, _GtkMenuItem, (),
272          MenuItem();
273          MenuItem(const char *label, bool mnemonic = false);
274     ,
275     );
276     WRAP(TearoffMenuItem, MenuItem, _GtkTearoffMenuItem, (),
277          TearoffMenuItem();
278     ,
279     );
280
281     WRAP(ComboBox, Bin, _GtkComboBox, (),
282     ,
283     );
284
285     WRAP(ComboBoxText, ComboBox, _GtkComboBoxText, (),
286          ComboBoxText();
287     ,
288     );
289
290     WRAP(ScrolledWindow, Bin, _GtkScrolledWindow, (),
291          ScrolledWindow();
292     ,
293     );
294
295     WRAP(Box, Container, _GtkBox, (),
296     ,
297     );
298
299     WRAP(VBox, Box, _GtkVBox, (),
300          VBox(bool homogenous, int spacing);
301     ,
302     );
303
304     WRAP(HBox, Box, _GtkHBox, (),
305          HBox(bool homogenous, int spacing);
306     ,
307     );
308
309     WRAP(Paned, Container, _GtkPaned, (),
310     ,
311     );
312
313     WRAP(HPaned, Paned, _GtkHPaned, (),
314          HPaned();
315     ,
316     );
317
318     WRAP(VPaned, Paned, _GtkVPaned, (),
319          VPaned();
320     ,
321     );
322
323     WRAP(MenuShell, Container, _GtkMenuShell, (),
324     ,
325     );
326
327     WRAP(Menu, Widget, _GtkMenu, (),
328          Menu();
329     ,
330     );
331
332     WRAP(Table, Widget, _GtkTable, (),
333          Table(std::size_t rows, std::size_t columns, bool homogenous);
334     ,
335     );
336
337     WRAP(TextView, Widget, _GtkTextView, (),
338          TextView();
339     ,
340     );
341
342     class TreeModel;
343     WRAP(TreeView, Widget, _GtkTreeView, (),
344          TreeView();
345          TreeView(TreeModel model);
346     ,
347     );
348
349     WRAP(Misc, Widget, _GtkMisc, (),
350     ,
351     );
352
353     WRAP(Label, Widget, _GtkLabel, (),
354          Label(const char *label);
355     ,
356     );
357
358     WRAP(Image, Widget, _GtkImage, (),
359          Image();
360     ,
361     );
362
363     WRAP(Entry, Widget, _GtkEntry, (IEditable, ICellEditable),
364          Entry();
365          Entry(std::size_t max_length);
366     ,
367     );
368
369     class Adjustment;
370     WRAP(SpinButton, Entry, _GtkSpinButton, (),
371          SpinButton(Adjustment adjustment, double climb_rate, std::size_t digits);
372     ,
373     );
374
375     WRAP(Range, Widget, _GtkRange, (),
376     ,
377     );
378
379     WRAP(Scale, Range, _GtkScale, (),
380     ,
381     );
382
383     WRAP(HScale, Scale, _GtkHScale, (),
384          HScale(Adjustment adjustment);
385          HScale(double min, double max, double step);
386     ,
387     );
388
389     WRAP(Adjustment, Object, _GtkAdjustment, (),
390          Adjustment(double value,
391                     double lower, double upper,
392                     double step_increment, double page_increment,
393                     double page_size);
394     ,
395     );
396
397     WRAP(CellRenderer, Object, _GtkCellRenderer, (),
398     ,
399     );
400
401     WRAP(CellRendererText, CellRenderer, _GtkCellRendererText, (),
402          CellRendererText();
403     ,
404     );
405
406     struct TreeViewColumnAttribute {
407         const char *attribute;
408         int column;
409     };
410     WRAP(TreeViewColumn, Object, _GtkTreeViewColumn, (),
411          TreeViewColumn(const char *title, CellRenderer renderer, std::initializer_list<TreeViewColumnAttribute> attributes);
412     ,
413     );
414
415     WRAP(AccelGroup, Object, _GtkAccelGroup, (),
416          AccelGroup();
417     ,
418     );
419
420     WRAP(ListStore, Object, _GtkListStore, (),
421     ,
422          void clear();
423     );
424
425     WRAP(TreeModel, Widget, _GtkTreeModel, (),
426     ,
427     );
428
429     WRAP(TreePath, Object, _GtkTreePath, (),
430          TreePath();
431          TreePath(const char *path);
432     ,
433     );
434
435 #undef WRAP
436
437 }
438
439 #endif