643 lines
14 KiB
C++
643 lines
14 KiB
C++
#ifndef INCLUDED_UILIB_H
|
|
#define INCLUDED_UILIB_H
|
|
|
|
#include <string>
|
|
#include <glib-object.h>
|
|
|
|
struct _GdkEventKey;
|
|
struct _GtkAccelGroup;
|
|
struct _GtkAdjustment;
|
|
struct _GtkAlignment;
|
|
struct _GtkBin;
|
|
struct _GtkBox;
|
|
struct _GtkButton;
|
|
struct _GtkCellEditable;
|
|
struct _GtkCellRenderer;
|
|
struct _GtkCellRendererText;
|
|
struct _GtkCheckButton;
|
|
struct _GtkCheckMenuItem;
|
|
struct _GtkComboBox;
|
|
struct _GtkComboBoxText;
|
|
struct _GtkContainer;
|
|
struct _GtkDialog;
|
|
struct _GtkEditable;
|
|
struct _GtkEntry;
|
|
struct _GtkEntryCompletion;
|
|
struct _GtkFrame;
|
|
struct _GtkHBox;
|
|
struct _GtkHPaned;
|
|
struct _GtkHScale;
|
|
struct _GtkImage;
|
|
struct _GtkItem;
|
|
struct _GtkLabel;
|
|
struct _GtkListStore;
|
|
struct _GtkTreeIter;
|
|
struct _GtkMenu;
|
|
struct _GtkMenuBar;
|
|
struct _GtkMenuItem;
|
|
struct _GtkMenuShell;
|
|
struct _GtkMisc;
|
|
struct _GtkObject;
|
|
struct _GtkPaned;
|
|
struct _GtkRadioButton;
|
|
struct _GtkRadioMenuItem;
|
|
struct _GtkRadioToolButton;
|
|
struct _GtkRange;
|
|
struct _GtkScale;
|
|
struct _GtkScrolledWindow;
|
|
struct _GtkSpinButton;
|
|
struct _GtkTable;
|
|
struct _GtkTearoffMenuItem;
|
|
struct _GtkTextView;
|
|
struct _GtkToggleButton;
|
|
struct _GtkToggleToolButton;
|
|
struct _GtkToolbar;
|
|
struct _GtkToolButton;
|
|
struct _GtkToolItem;
|
|
struct _GtkTreeModel;
|
|
struct _GtkTreePath;
|
|
struct _GtkTreeSelection;
|
|
struct _GtkTreeStore;
|
|
struct _GtkTreeView;
|
|
struct _GtkTreeViewColumn;
|
|
struct _GtkVBox;
|
|
struct _GtkVPaned;
|
|
struct _GtkWidget;
|
|
struct _GtkWindow;
|
|
struct _GTypeInstance;
|
|
|
|
#if GTK_TARGET == 3
|
|
struct _GtkGLArea;
|
|
#endif
|
|
|
|
#if GTK_TARGET == 2
|
|
using _GtkGLArea = struct _GtkDrawingArea;
|
|
#endif
|
|
|
|
struct ModalDialog;
|
|
|
|
namespace ui {
|
|
|
|
bool init(int *argc, char **argv[], char const *parameter_string, char const **error);
|
|
|
|
void main();
|
|
|
|
void process();
|
|
|
|
enum class window_type {
|
|
TOP,
|
|
POPUP
|
|
};
|
|
|
|
enum class Shadow {
|
|
NONE,
|
|
IN,
|
|
OUT,
|
|
ETCHED_IN,
|
|
ETCHED_OUT
|
|
};
|
|
|
|
enum class Policy {
|
|
ALWAYS,
|
|
AUTOMATIC,
|
|
NEVER
|
|
};
|
|
|
|
namespace details {
|
|
|
|
enum class Convert {
|
|
Implicit, Explicit
|
|
};
|
|
|
|
template<class Self, class T, Convert mode>
|
|
struct Convertible;
|
|
|
|
template<class Self, class T>
|
|
struct Convertible<Self, T, Convert::Implicit> {
|
|
operator T() const
|
|
{ return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
|
|
};
|
|
|
|
template<class Self, class T>
|
|
struct Convertible<Self, T, Convert::Explicit> {
|
|
explicit operator T() const
|
|
{ return reinterpret_cast<T>(static_cast<Self const *>(this)->_handle); }
|
|
};
|
|
|
|
template<class Self, class... T>
|
|
struct All : T ... {
|
|
All()
|
|
{};
|
|
};
|
|
|
|
template<class Self, class Interfaces>
|
|
struct Mixin;
|
|
template<class Self>
|
|
struct Mixin<Self, void()> {
|
|
using type = All<Self>;
|
|
};
|
|
template<class Self, class... Interfaces>
|
|
struct Mixin<Self, void(Interfaces...)> {
|
|
using type = All<Self, Interfaces...>;
|
|
};
|
|
}
|
|
|
|
const struct Null {} null = {};
|
|
const struct New_t {} New = {};
|
|
|
|
class Object :
|
|
public details::Convertible<Object, _GtkObject *, details::Convert::Explicit>,
|
|
public details::Convertible<Object, _GTypeInstance *, details::Convert::Explicit> {
|
|
public:
|
|
using self = Object *;
|
|
using native = _GtkObject *;
|
|
native _handle;
|
|
|
|
explicit Object(native h) : _handle(h)
|
|
{}
|
|
|
|
explicit operator bool() const
|
|
{ return _handle != nullptr; }
|
|
|
|
explicit operator void *() const
|
|
{ return _handle; }
|
|
|
|
void unref()
|
|
{ g_object_unref(_handle); }
|
|
|
|
void ref()
|
|
{ g_object_ref(_handle); }
|
|
|
|
template<class Lambda>
|
|
gulong connect(char const *detailed_signal, Lambda &&c_handler, void *data);
|
|
|
|
template<class Lambda>
|
|
gulong connect(char const *detailed_signal, Lambda &&c_handler, Object data);
|
|
};
|
|
static_assert(sizeof(Object) == sizeof(Object::native), "object slicing");
|
|
|
|
#define WRAP(name, super, T, interfaces, ctors, methods) \
|
|
class name; \
|
|
class I##name : public details::Convertible<name, T *, details::Convert::Implicit> { \
|
|
public: \
|
|
using self = name *; \
|
|
methods \
|
|
}; \
|
|
class name : public super, public I##name, public details::Mixin<name, void interfaces>::type { \
|
|
public: \
|
|
using self = name *; \
|
|
using native = T *; \
|
|
protected: \
|
|
explicit name(native h) noexcept : super(reinterpret_cast<super::native>(h)) {} \
|
|
public: \
|
|
explicit name(Null n) noexcept : name((native) nullptr) {} \
|
|
explicit name(New_t); \
|
|
static name from(native h) { return name(h); } \
|
|
static name from(void *ptr) { return name((native) ptr); } \
|
|
ctors \
|
|
}; \
|
|
inline bool operator<(name self, name other) { return self._handle < other._handle; } \
|
|
static_assert(sizeof(name) == sizeof(super), "object slicing")
|
|
|
|
// https://developer.gnome.org/gtk2/stable/ch01.html
|
|
|
|
// GInterface
|
|
|
|
WRAP(CellEditable, Object, _GtkCellEditable, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Editable, Object, _GtkEditable, (),
|
|
,
|
|
void editable(bool value);
|
|
);
|
|
|
|
WRAP(TreeModel, Object, _GtkTreeModel, (),
|
|
,
|
|
);
|
|
|
|
// GObject
|
|
|
|
struct Dimensions {
|
|
int width;
|
|
int height;
|
|
};
|
|
|
|
class Window;
|
|
WRAP(Widget, Object, _GtkWidget, (),
|
|
,
|
|
Window window();
|
|
const char *file_dialog(
|
|
bool open,
|
|
const char *title,
|
|
const char *path = nullptr,
|
|
const char *pattern = nullptr,
|
|
bool want_load = false,
|
|
bool want_import = false,
|
|
bool want_save = false
|
|
);
|
|
bool visible();
|
|
void visible(bool shown);
|
|
void show();
|
|
void hide();
|
|
Dimensions dimensions();
|
|
void dimensions(int width, int height);
|
|
void destroy();
|
|
);
|
|
|
|
WRAP(Container, Widget, _GtkContainer, (),
|
|
,
|
|
void add(Widget widget);
|
|
|
|
void remove(Widget widget);
|
|
|
|
template<class Lambda>
|
|
void foreach(Lambda &&lambda);
|
|
);
|
|
|
|
WRAP(Bin, Container, _GtkBin, (),
|
|
,
|
|
);
|
|
|
|
class AccelGroup;
|
|
WRAP(Window, Bin, _GtkWindow, (),
|
|
explicit Window(window_type type);
|
|
,
|
|
Window create_dialog_window(
|
|
const char *title,
|
|
void func(),
|
|
void *data,
|
|
int default_w = -1,
|
|
int default_h = -1
|
|
);
|
|
|
|
Window create_modal_dialog_window(
|
|
const char *title,
|
|
ModalDialog &dialog,
|
|
int default_w = -1,
|
|
int default_h = -1
|
|
);
|
|
|
|
Window create_floating_window(const char *title);
|
|
|
|
std::uint64_t on_key_press(
|
|
bool (*f)(Widget widget, _GdkEventKey *event, void *extra),
|
|
void *extra = nullptr
|
|
);
|
|
|
|
void add_accel_group(AccelGroup group);
|
|
);
|
|
|
|
WRAP(Dialog, Window, _GtkDialog, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Alignment, Bin, _GtkAlignment, (),
|
|
Alignment(float xalign, float yalign, float xscale, float yscale);
|
|
,
|
|
);
|
|
|
|
WRAP(Frame, Bin, _GtkFrame, (),
|
|
explicit Frame(const char *label = nullptr);
|
|
,
|
|
);
|
|
|
|
WRAP(Button, Bin, _GtkButton, (),
|
|
explicit Button(const char *label);
|
|
,
|
|
);
|
|
|
|
WRAP(ToggleButton, Button, _GtkToggleButton, (),
|
|
,
|
|
bool active() const;
|
|
void active(bool value);
|
|
);
|
|
|
|
WRAP(CheckButton, ToggleButton, _GtkCheckButton, (),
|
|
explicit CheckButton(const char *label);
|
|
,
|
|
);
|
|
|
|
WRAP(RadioButton, CheckButton, _GtkRadioButton, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Item, Bin, _GtkItem, (),
|
|
,
|
|
);
|
|
|
|
WRAP(MenuItem, Item, _GtkMenuItem, (),
|
|
explicit MenuItem(const char *label, bool mnemonic = false);
|
|
,
|
|
);
|
|
|
|
WRAP(CheckMenuItem, MenuItem, _GtkCheckMenuItem, (),
|
|
,
|
|
);
|
|
|
|
WRAP(RadioMenuItem, CheckMenuItem, _GtkRadioMenuItem, (),
|
|
,
|
|
);
|
|
|
|
WRAP(TearoffMenuItem, MenuItem, _GtkTearoffMenuItem, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ComboBox, Bin, _GtkComboBox, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ComboBoxText, ComboBox, _GtkComboBoxText, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ToolItem, Bin, _GtkToolItem, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ToolButton, ToolItem, _GtkToolButton, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ToggleToolButton, ToolButton, _GtkToggleToolButton, (),
|
|
,
|
|
);
|
|
|
|
WRAP(RadioToolButton, ToggleToolButton, _GtkRadioToolButton, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ScrolledWindow, Bin, _GtkScrolledWindow, (),
|
|
,
|
|
void overflow(Policy x, Policy y);
|
|
);
|
|
|
|
WRAP(Box, Container, _GtkBox, (),
|
|
,
|
|
void pack_start(ui::Widget child, bool expand, bool fill, unsigned int padding);
|
|
void pack_end(ui::Widget child, bool expand, bool fill, unsigned int padding);
|
|
);
|
|
|
|
WRAP(VBox, Box, _GtkVBox, (),
|
|
VBox(bool homogenous, int spacing);
|
|
,
|
|
);
|
|
|
|
WRAP(HBox, Box, _GtkHBox, (),
|
|
HBox(bool homogenous, int spacing);
|
|
,
|
|
);
|
|
|
|
WRAP(Paned, Container, _GtkPaned, (),
|
|
,
|
|
);
|
|
|
|
WRAP(HPaned, Paned, _GtkHPaned, (),
|
|
,
|
|
);
|
|
|
|
WRAP(VPaned, Paned, _GtkVPaned, (),
|
|
,
|
|
);
|
|
|
|
WRAP(MenuShell, Container, _GtkMenuShell, (),
|
|
,
|
|
);
|
|
|
|
WRAP(MenuBar, MenuShell, _GtkMenuBar, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Menu, MenuShell, _GtkMenu, (),
|
|
,
|
|
);
|
|
|
|
struct TableAttach {
|
|
unsigned int left, right, top, bottom;
|
|
};
|
|
|
|
struct TableAttachOptions {
|
|
// todo: type safety
|
|
unsigned int x, y;
|
|
};
|
|
|
|
struct TablePadding {
|
|
unsigned int x, y;
|
|
};
|
|
|
|
WRAP(Table, Container, _GtkTable, (),
|
|
Table(std::size_t rows, std::size_t columns, bool homogenous);
|
|
,
|
|
// 5 = expand | fill
|
|
void attach(Widget child, TableAttach attach, TableAttachOptions options = {5, 5}, TablePadding padding = {0, 0});
|
|
);
|
|
|
|
WRAP(TextView, Container, _GtkTextView, (),
|
|
,
|
|
void text(char const *str);
|
|
);
|
|
|
|
WRAP(Toolbar, Container, _GtkToolbar, (),
|
|
,
|
|
);
|
|
|
|
class TreeModel;
|
|
WRAP(TreeView, Widget, _GtkTreeView, (),
|
|
TreeView(TreeModel model);
|
|
,
|
|
);
|
|
|
|
WRAP(Misc, Widget, _GtkMisc, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Label, Widget, _GtkLabel, (),
|
|
explicit Label(const char *label);
|
|
,
|
|
void text(char const *str);
|
|
);
|
|
|
|
WRAP(Image, Widget, _GtkImage, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Entry, Widget, _GtkEntry, (IEditable, ICellEditable),
|
|
explicit Entry(std::size_t max_length);
|
|
,
|
|
char const *text();
|
|
void text(char const *str);
|
|
);
|
|
|
|
class Adjustment;
|
|
WRAP(SpinButton, Entry, _GtkSpinButton, (),
|
|
SpinButton(Adjustment adjustment, double climb_rate, std::size_t digits);
|
|
,
|
|
);
|
|
|
|
WRAP(Range, Widget, _GtkRange, (),
|
|
,
|
|
);
|
|
|
|
WRAP(Scale, Range, _GtkScale, (),
|
|
,
|
|
);
|
|
|
|
WRAP(HScale, Scale, _GtkHScale, (),
|
|
explicit HScale(Adjustment adjustment);
|
|
HScale(double min, double max, double step);
|
|
,
|
|
);
|
|
|
|
WRAP(Adjustment, Object, _GtkAdjustment, (),
|
|
Adjustment(double value,
|
|
double lower, double upper,
|
|
double step_increment, double page_increment,
|
|
double page_size);
|
|
,
|
|
);
|
|
|
|
WRAP(CellRenderer, Object, _GtkCellRenderer, (),
|
|
,
|
|
);
|
|
|
|
WRAP(CellRendererText, CellRenderer, _GtkCellRendererText, (),
|
|
,
|
|
);
|
|
|
|
struct TreeViewColumnAttribute {
|
|
const char *attribute;
|
|
int column;
|
|
};
|
|
WRAP(TreeViewColumn, Object, _GtkTreeViewColumn, (),
|
|
TreeViewColumn(const char *title, CellRenderer renderer, std::initializer_list<TreeViewColumnAttribute> attributes);
|
|
,
|
|
);
|
|
|
|
WRAP(AccelGroup, Object, _GtkAccelGroup, (),
|
|
,
|
|
);
|
|
|
|
WRAP(EntryCompletion, Object, _GtkEntryCompletion, (),
|
|
,
|
|
);
|
|
|
|
WRAP(ListStore, Object, _GtkListStore, (ITreeModel),
|
|
,
|
|
void clear();
|
|
|
|
template<class... T>
|
|
void append(T... args);
|
|
|
|
void append();
|
|
);
|
|
|
|
WRAP(TreeStore, Object, _GtkTreeStore, (ITreeModel),
|
|
,
|
|
);
|
|
|
|
WRAP(TreeSelection, Object, _GtkTreeSelection, (),
|
|
,
|
|
);
|
|
|
|
// GBoxed
|
|
|
|
WRAP(TreePath, Object, _GtkTreePath, (),
|
|
explicit TreePath(const char *path);
|
|
,
|
|
);
|
|
|
|
// Custom
|
|
|
|
WRAP(GLArea, Widget, _GtkGLArea, (),
|
|
,
|
|
guint on_render(GCallback pFunction, void *data);
|
|
);
|
|
|
|
#undef WRAP
|
|
|
|
// global
|
|
|
|
enum class alert_response {
|
|
OK,
|
|
CANCEL,
|
|
YES,
|
|
NO,
|
|
};
|
|
|
|
enum class alert_type {
|
|
OK,
|
|
OKCANCEL,
|
|
YESNO,
|
|
YESNOCANCEL,
|
|
NOYES,
|
|
};
|
|
|
|
enum class alert_icon {
|
|
Default,
|
|
Error,
|
|
Warning,
|
|
Question,
|
|
Asterisk,
|
|
};
|
|
|
|
extern class Window root;
|
|
|
|
alert_response alert(
|
|
Window parent,
|
|
std::string text,
|
|
std::string title = "WorldSpawn",
|
|
alert_type type = alert_type::OK,
|
|
alert_icon icon = alert_icon::Default
|
|
);
|
|
|
|
// callbacks
|
|
|
|
namespace {
|
|
using GtkCallback = void (*)(_GtkWidget *, void *);
|
|
extern "C" {
|
|
void gtk_container_foreach(_GtkContainer *, GtkCallback, void *);
|
|
}
|
|
}
|
|
|
|
#define this (*static_cast<self>(this))
|
|
|
|
template<class Lambda>
|
|
gulong Object::connect(char const *detailed_signal, Lambda &&c_handler, void *data)
|
|
{
|
|
return g_signal_connect(G_OBJECT(this), detailed_signal, c_handler, data);
|
|
}
|
|
|
|
template<class Lambda>
|
|
gulong Object::connect(char const *detailed_signal, Lambda &&c_handler, Object data)
|
|
{
|
|
return g_signal_connect(G_OBJECT(this), detailed_signal, c_handler, (_GtkObject *) data);
|
|
}
|
|
|
|
template<class Lambda>
|
|
void IContainer::foreach(Lambda &&lambda)
|
|
{
|
|
GtkCallback cb = [](_GtkWidget *widget, void *data) -> void {
|
|
using Function = typename std::decay<Lambda>::type;
|
|
Function *f = static_cast<Function *>(data);
|
|
(*f)(Widget::from(widget));
|
|
};
|
|
gtk_container_foreach(this, cb, &lambda);
|
|
}
|
|
|
|
namespace {
|
|
extern "C" {
|
|
void gtk_list_store_insert_with_values(_GtkListStore *, _GtkTreeIter *, gint position, ...);
|
|
}
|
|
}
|
|
|
|
template<class... T>
|
|
void IListStore::append(T... args) {
|
|
static_assert(sizeof...(args) % 2 == 0, "received an odd number of arguments");
|
|
gtk_list_store_insert_with_values(this, NULL, -1, args..., -1);
|
|
}
|
|
|
|
#undef this
|
|
|
|
}
|
|
|
|
#endif
|