Rebase onto master
[xonotic/netradiant.git] / libs / uilib / uilib.h
1 #ifndef INCLUDED_UILIB_H
2 #define INCLUDED_UILIB_H
3
4 #include <string>
5 #include <glib-object.h>
6
7 struct _GdkEventKey;
8 struct _GtkAccelGroup;
9 struct _GtkAdjustment;
10 struct _GtkAlignment;
11 struct _GtkBin;
12 struct _GtkBox;
13 struct _GtkButton;
14 struct _GtkCellEditable;
15 struct _GtkCellRenderer;
16 struct _GtkCellRendererText;
17 struct _GtkCheckButton;
18 struct _GtkCheckMenuItem;
19 struct _GtkComboBox;
20 struct _GtkComboBoxText;
21 struct _GtkContainer;
22 struct _GtkDialog;
23 struct _GtkEditable;
24 struct _GtkEntry;
25 struct _GtkEntryCompletion;
26 struct _GtkFrame;
27 struct _GtkHBox;
28 struct _GtkHPaned;
29 struct _GtkHScale;
30 struct _GtkImage;
31 struct _GtkItem;
32 struct _GtkLabel;
33 struct _GtkListStore;
34 struct _GtkMenu;
35 struct _GtkMenuBar;
36 struct _GtkMenuItem;
37 struct _GtkMenuShell;
38 struct _GtkMisc;
39 struct _GtkObject;
40 struct _GtkPaned;
41 struct _GtkRadioButton;
42 struct _GtkRadioMenuItem;
43 struct _GtkRadioToolButton;
44 struct _GtkRange;
45 struct _GtkScale;
46 struct _GtkScrolledWindow;
47 struct _GtkSpinButton;
48 struct _GtkTable;
49 struct _GtkTearoffMenuItem;
50 struct _GtkTextView;
51 struct _GtkToggleButton;
52 struct _GtkToggleToolButton;
53 struct _GtkToolbar;
54 struct _GtkToolButton;
55 struct _GtkToolItem;
56 struct _GtkTreeModel;
57 struct _GtkTreePath;
58 struct _GtkTreeSelection;
59 struct _GtkTreeView;
60 struct _GtkTreeViewColumn;
61 struct _GtkVBox;
62 struct _GtkVPaned;
63 struct _GtkWidget;
64 struct _GtkWindow;
65 struct _GTypeInstance;
66
67 #if GTK_TARGET == 3
68 struct _GtkGLArea;
69 #endif
70
71 #if GTK_TARGET == 2
72 using _GtkGLArea = struct _GtkDrawingArea;
73 #endif
74
75 struct ModalDialog;
76
77 namespace ui {
78
79     bool init(int *argc, char **argv[], char const *parameter_string, char const **error);
80
81     void main();
82
83     void process();
84
85     extern class Widget root;
86
87     enum class alert_type {
88         OK,
89         OKCANCEL,
90         YESNO,
91         YESNOCANCEL,
92         NOYES,
93     };
94
95     enum class alert_icon {
96         Default,
97         Error,
98         Warning,
99         Question,
100         Asterisk,
101     };
102
103     enum class alert_response {
104         OK,
105         CANCEL,
106         YES,
107         NO,
108     };
109
110     enum class window_type {
111         TOP,
112         POPUP
113     };
114
115     enum class Shadow {
116         NONE,
117         IN,
118         OUT,
119         ETCHED_IN,
120         ETCHED_OUT
121     };
122
123     enum class Policy {
124         ALWAYS,
125         AUTOMATIC,
126         NEVER
127     };
128
129     namespace details {
130
131         enum class Convert {
132             Implicit, Explicit
133         };
134
135         template<class Self, class T, Convert mode>
136         struct Convertible;
137
138         template<class Self, class T>
139         struct Convertible<Self, T, Convert::Implicit> {
140             operator T() const
141             { return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
142         };
143
144         template<class Self, class T>
145         struct Convertible<Self, T, Convert::Explicit> {
146             explicit operator T() const
147             { return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
148         };
149
150         template<class Self, class... T>
151         struct All : T ... {
152             All()
153             {};
154         };
155
156         template<class Self, class Interfaces>
157         struct Mixin;
158         template<class Self>
159         struct Mixin<Self, void()> {
160             using type = All<Self>;
161         };
162         template<class Self, class... Interfaces>
163         struct Mixin<Self, void(Interfaces...)> {
164             using type = All<Self, Interfaces...>;
165         };
166     }
167
168     extern struct Null {} null;
169
170     class Object :
171             public details::Convertible<Object, _GtkObject *, details::Convert::Explicit>,
172             public details::Convertible<Object, _GTypeInstance *, details::Convert::Explicit> {
173     public:
174         using self = Object *;
175         using native = _GtkObject *;
176         native _handle;
177
178         Object(native h) : _handle(h)
179         {}
180
181         explicit operator bool() const
182         { return _handle != nullptr; }
183
184         explicit operator void *() const
185         { return _handle; }
186
187         void unref()
188         { g_object_unref(_handle); }
189
190         template<class Lambda>
191         gulong connect(char const *detailed_signal, Lambda &&c_handler, void *data);
192
193         template<class Lambda>
194         gulong connect(char const *detailed_signal, Lambda &&c_handler, Object data);
195     };
196     static_assert(sizeof(Object) == sizeof(Object::native), "object slicing");
197
198 #define WRAP(name, super, T, interfaces, ctors, methods) \
199     class name; \
200     class I##name : public details::Convertible<name, T *, details::Convert::Implicit> { \
201     public: \
202         using self = name *; \
203         methods \
204     }; \
205     class name : public super, public I##name, public details::Mixin<name, void interfaces>::type { \
206     public: \
207         using self = name *; \
208         using native = T *; \
209         explicit name(native h) : super(reinterpret_cast<super::native>(h)) {} \
210         explicit name(Null n) : name((native) nullptr) {} \
211         ctors \
212     }; \
213     inline bool operator<(name self, name other) { return self._handle < other._handle; } \
214     static_assert(sizeof(name) == sizeof(super), "object slicing")
215
216     // https://developer.gnome.org/gtk2/stable/ch01.html
217
218     // GInterface
219
220     WRAP(CellEditable, Object, _GtkCellEditable, (),
221     ,
222     );
223
224     WRAP(Editable, Object, _GtkEditable, (),
225          Editable();
226     ,
227          void editable(bool value);
228     );
229
230     WRAP(TreeModel, Object, _GtkTreeModel, (),
231     ,
232     );
233
234     // GObject
235
236     WRAP(Widget, Object, _GtkWidget, (),
237          Widget();
238     ,
239          alert_response alert(
240                  std::string text,
241                  std::string title = "NetRadiant",
242                  alert_type type = alert_type::OK,
243                  alert_icon icon = alert_icon::Default
244          );
245          const char *file_dialog(
246                  bool open,
247                  const char *title,
248                  const char *path = nullptr,
249                  const char *pattern = nullptr,
250                  bool want_load = false,
251                  bool want_import = false,
252                  bool want_save = false
253          );
254          void show();
255     );
256
257     WRAP(Container, Widget, _GtkContainer, (),
258     ,
259          void add(Widget widget);
260
261          void remove(Widget widget);
262
263          template<class Lambda>
264          void foreach(Lambda &&lambda);
265     );
266
267     WRAP(Bin, Container, _GtkBin, (),
268     ,
269     );
270
271     class AccelGroup;
272     WRAP(Window, Bin, _GtkWindow, (),
273          Window(window_type type);
274     ,
275          Window create_dialog_window(
276                  const char *title,
277                  void func(),
278                  void *data,
279                  int default_w = -1,
280                  int default_h = -1
281          );
282
283          Window create_modal_dialog_window(
284                  const char *title,
285                  ModalDialog &dialog,
286                  int default_w = -1,
287                  int default_h = -1
288          );
289
290          Window create_floating_window(const char *title);
291
292          std::uint64_t on_key_press(
293                  bool (*f)(Widget widget, _GdkEventKey *event, void *extra),
294                  void *extra = nullptr
295          );
296
297          void add_accel_group(AccelGroup group);
298     );
299
300     WRAP(Dialog, Window, _GtkDialog, (),
301     ,
302     );
303
304     WRAP(Alignment, Bin, _GtkAlignment, (),
305          Alignment(float xalign, float yalign, float xscale, float yscale);
306     ,
307     );
308
309     WRAP(Frame, Bin, _GtkFrame, (),
310          Frame(const char *label = nullptr);
311     ,
312     );
313
314     WRAP(Button, Bin, _GtkButton, (),
315          Button();
316          Button(const char *label);
317     ,
318     );
319
320     WRAP(ToggleButton, Button, _GtkToggleButton, (),
321     ,
322          bool active();
323     );
324
325     WRAP(CheckButton, ToggleButton, _GtkCheckButton, (),
326          CheckButton(const char *label);
327     ,
328     );
329
330     WRAP(RadioButton, CheckButton, _GtkRadioButton, (),
331     ,
332     );
333
334     WRAP(Item, Bin, _GtkItem, (),
335     ,
336     );
337
338     WRAP(MenuItem, Item, _GtkMenuItem, (),
339          MenuItem();
340          MenuItem(const char *label, bool mnemonic = false);
341     ,
342     );
343
344     WRAP(CheckMenuItem, MenuItem, _GtkCheckMenuItem, (),
345     ,
346     );
347
348     WRAP(RadioMenuItem, CheckMenuItem, _GtkRadioMenuItem, (),
349     ,
350     );
351
352     WRAP(TearoffMenuItem, MenuItem, _GtkTearoffMenuItem, (),
353          TearoffMenuItem();
354     ,
355     );
356
357     WRAP(ComboBox, Bin, _GtkComboBox, (),
358     ,
359     );
360
361     WRAP(ComboBoxText, ComboBox, _GtkComboBoxText, (),
362          ComboBoxText();
363     ,
364     );
365
366     WRAP(ToolItem, Bin, _GtkToolItem, (),
367     ,
368     );
369
370     WRAP(ToolButton, ToolItem, _GtkToolButton, (),
371     ,
372     );
373
374     WRAP(ToggleToolButton, ToolButton, _GtkToggleToolButton, (),
375     ,
376     );
377
378     WRAP(RadioToolButton, ToggleToolButton, _GtkRadioToolButton, (),
379     ,
380     );
381
382     WRAP(ScrolledWindow, Bin, _GtkScrolledWindow, (),
383          ScrolledWindow();
384     ,
385     );
386
387     WRAP(Box, Container, _GtkBox, (),
388     ,
389     );
390
391     WRAP(VBox, Box, _GtkVBox, (),
392          VBox(bool homogenous, int spacing);
393     ,
394     );
395
396     WRAP(HBox, Box, _GtkHBox, (),
397          HBox(bool homogenous, int spacing);
398     ,
399     );
400
401     WRAP(Paned, Container, _GtkPaned, (),
402     ,
403     );
404
405     WRAP(HPaned, Paned, _GtkHPaned, (),
406          HPaned();
407     ,
408     );
409
410     WRAP(VPaned, Paned, _GtkVPaned, (),
411          VPaned();
412     ,
413     );
414
415     WRAP(MenuShell, Container, _GtkMenuShell, (),
416     ,
417     );
418
419     WRAP(MenuBar, MenuShell, _GtkMenuBar, (),
420     ,
421     );
422
423     WRAP(Menu, MenuShell, _GtkMenu, (),
424          Menu();
425     ,
426     );
427
428     WRAP(Table, Container, _GtkTable, (),
429          Table(std::size_t rows, std::size_t columns, bool homogenous);
430     ,
431     );
432
433     WRAP(TextView, Container, _GtkTextView, (),
434          TextView();
435     ,
436     );
437
438     WRAP(Toolbar, Container, _GtkToolbar, (),
439     ,
440     );
441
442     class TreeModel;
443     WRAP(TreeView, Widget, _GtkTreeView, (),
444          TreeView();
445          TreeView(TreeModel model);
446     ,
447     );
448
449     WRAP(Misc, Widget, _GtkMisc, (),
450     ,
451     );
452
453     WRAP(Label, Widget, _GtkLabel, (),
454          Label(const char *label);
455     ,
456     );
457
458     WRAP(Image, Widget, _GtkImage, (),
459          Image();
460     ,
461     );
462
463     WRAP(Entry, Widget, _GtkEntry, (IEditable, ICellEditable),
464          Entry();
465          Entry(std::size_t max_length);
466     ,
467     );
468
469     class Adjustment;
470     WRAP(SpinButton, Entry, _GtkSpinButton, (),
471          SpinButton(Adjustment adjustment, double climb_rate, std::size_t digits);
472     ,
473     );
474
475     WRAP(Range, Widget, _GtkRange, (),
476     ,
477     );
478
479     WRAP(Scale, Range, _GtkScale, (),
480     ,
481     );
482
483     WRAP(HScale, Scale, _GtkHScale, (),
484          HScale(Adjustment adjustment);
485          HScale(double min, double max, double step);
486     ,
487     );
488
489     WRAP(Adjustment, Object, _GtkAdjustment, (),
490          Adjustment(double value,
491                     double lower, double upper,
492                     double step_increment, double page_increment,
493                     double page_size);
494     ,
495     );
496
497     WRAP(CellRenderer, Object, _GtkCellRenderer, (),
498     ,
499     );
500
501     WRAP(CellRendererText, CellRenderer, _GtkCellRendererText, (),
502          CellRendererText();
503     ,
504     );
505
506     struct TreeViewColumnAttribute {
507         const char *attribute;
508         int column;
509     };
510     WRAP(TreeViewColumn, Object, _GtkTreeViewColumn, (),
511          TreeViewColumn(const char *title, CellRenderer renderer, std::initializer_list<TreeViewColumnAttribute> attributes);
512     ,
513     );
514
515     WRAP(AccelGroup, Object, _GtkAccelGroup, (),
516          AccelGroup();
517     ,
518     );
519
520     WRAP(EntryCompletion, Object, _GtkEntryCompletion, (),
521     ,
522     );
523
524     WRAP(ListStore, Object, _GtkListStore, (ITreeModel),
525     ,
526          void clear();
527     );
528
529     WRAP(TreeSelection, Object, _GtkTreeSelection, (),
530     ,
531     );
532
533     // GBoxed
534
535     WRAP(TreePath, Object, _GtkTreePath, (),
536          TreePath();
537          TreePath(const char *path);
538     ,
539     );
540
541     // Custom
542
543     WRAP(GLArea, Widget, _GtkGLArea, (),
544     ,
545          guint on_render(GCallback pFunction, void *data);
546     );
547
548 #undef WRAP
549
550     // callbacks
551
552     namespace {
553         using GtkCallback = void (*)(_GtkWidget *, void *);
554         extern "C" {
555         void gtk_container_foreach(_GtkContainer *, GtkCallback, void *);
556         }
557     }
558
559 #define this (*static_cast<self>(this))
560
561     template<class Lambda>
562     gulong Object::connect(char const *detailed_signal, Lambda &&c_handler, void *data)
563     {
564         return g_signal_connect(G_OBJECT(this), detailed_signal, c_handler, data);
565     }
566
567     template<class Lambda>
568     gulong Object::connect(char const *detailed_signal, Lambda &&c_handler, Object data)
569     {
570         return g_signal_connect(G_OBJECT(this), detailed_signal, c_handler, (_GtkObject *) data);
571     }
572
573     template<class Lambda>
574     void IContainer::foreach(Lambda &&lambda)
575     {
576         GtkCallback cb = [](_GtkWidget *widget, void *data) -> void {
577             using Function = typename std::decay<Lambda>::type;
578             Function *f = static_cast<Function *>(data);
579             (*f)(Widget(widget));
580         };
581         gtk_container_foreach(this, cb, &lambda);
582     }
583
584 #undef this
585
586 }
587
588 #endif