diff --git a/haiku/GNUmakeinc.mk b/haiku/GNUmakeinc.mk index fa9aa3b4..98549234 100644 --- a/haiku/GNUmakeinc.mk +++ b/haiku/GNUmakeinc.mk @@ -4,8 +4,21 @@ CXXFILES += \ haiku/alloc.cpp \ haiku/area.cpp \ haiku/box.cpp \ + haiku/button.cpp \ + haiku/checkbox.cpp \ + haiku/combobox.cpp \ haiku/control.cpp \ + haiku/datetimepicker.cpp \ + haiku/entry.cpp \ + haiku/group.cpp \ + haiku/label.cpp \ haiku/main.cpp \ + haiku/progressbar.cpp \ + haiku/radiobuttons.cpp \ + haiku/separator.cpp \ + haiku/slider.cpp \ + haiku/spinbox.cpp \ + haiku/tab.cpp \ haiku/text.cpp \ haiku/util.cpp \ haiku/window.cpp diff --git a/haiku/button.cpp b/haiku/button.cpp new file mode 100644 index 00000000..3c3b9350 --- /dev/null +++ b/haiku/button.cpp @@ -0,0 +1,43 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiButton { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiButton, // type name + uiButtonType, // type function + dummy // handle +) + +char *uiButtonText(uiButton *b) +{ + // TODO + return NULL; +} + +void uiButtonSetText(uiButton *b, const char *text) +{ + // TODO +} + +void uiButtonOnClicked(uiButton *b, void (*f)(uiButton *b, void *data), void *data) +{ + // TODO +} + +uiButton *uiNewButton(const char *text) +{ + uiButton *b; + + b = (uiButton *) uiNewControl(uiButtonType()); + + b->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiButton not implemented"); + + uiHaikuFinishNewControl(b, uiButton); + + return b; +} diff --git a/haiku/checkbox.cpp b/haiku/checkbox.cpp new file mode 100644 index 00000000..25b65d35 --- /dev/null +++ b/haiku/checkbox.cpp @@ -0,0 +1,54 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiCheckbox { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiCheckbox, // type name + uiCheckboxType, // type function + dummy // handle +) + +char *uiCheckboxText(uiCheckbox *c) +{ + // TODO + return NULL; +} + +void uiCheckboxSetText(uiCheckbox *c, const char *text) +{ + // TODO +} + +void uiCheckboxOnToggled(uiCheckbox *c, void (*f)(uiCheckbox *c, void *data), void *data) +{ + // TODO +} + +int uiCheckboxChecked(uiCheckbox *c) +{ + // TODO + return 0; +} + +void uiCheckboxSetChecked(uiCheckbox *c, int checked) +{ + // TODO +} + +uiCheckbox *uiNewCheckbox(const char *text) +{ + uiCheckbox *c; + + c = (uiCheckbox *) uiNewControl(uiCheckboxType()); + + c->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiCheckbox not implemented"); + + uiHaikuFinishNewControl(c, uiCheckbox); + + return c; +} diff --git a/haiku/combobox.cpp b/haiku/combobox.cpp new file mode 100644 index 00000000..0a413b67 --- /dev/null +++ b/haiku/combobox.cpp @@ -0,0 +1,58 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiCombobox { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiCombobox, // type name + uiComboboxType, // type function + dummy // handle +) + +void uiComboboxAppend(uiCombobox *c, const char *text) +{ + // TODO +} + +intmax_t uiComboboxSelected(uiCombobox *c) +{ + // TODO + return -1; +} + +void uiComboboxSetSelected(uiCombobox *c, intmax_t n) +{ + // TODO +} + +void uiComboboxOnSelected(uiCombobox *c, void (*f)(uiCombobox *c, void *data), void *data) +{ + // TODO +} + +static uiCombobox *finishNewCombobox(void) +{ + uiCombobox *c; + + c = (uiCombobox *) uiNewControl(uiComboboxType()); + + c->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiCombobox not implemented"); + + uiHaikuFinishNewControl(c, uiCombobox); + + return c; +} + +uiCombobox *uiNewCombobox(void) +{ + return finishNewCombobox(); +} + +uiCombobox *uiNewEditableCombobox(void) +{ + return finishNewCombobox(); +} diff --git a/haiku/datetimepicker.cpp b/haiku/datetimepicker.cpp new file mode 100644 index 00000000..66958260 --- /dev/null +++ b/haiku/datetimepicker.cpp @@ -0,0 +1,42 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiDateTimePicker { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiDateTimePicker, // type name + uiDateTimePickerType, // type function + dummy // handle +) + +static uiDateTimePicker *finishNewDateTimePicker(void) +{ + uiDateTimePicker *d; + + d = (uiDateTimePicker *) uiNewControl(uiDateTimePickerType()); + + d->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiDateTimePicker not implemented"); + + uiHaikuFinishNewControl(d, uiDateTimePicker); + + return d; +} + +uiDateTimePicker *uiNewDateTimePicker(void) +{ + return finishNewDateTimePicker(); +} + +uiDateTimePicker *uiNewDatePicker(void) +{ + return finishNewDateTimePicker(); +} + +uiDateTimePicker *uiNewTimePicker(void) +{ + return finishNewDateTimePicker(); +} diff --git a/haiku/entry.cpp b/haiku/entry.cpp new file mode 100644 index 00000000..a56609cc --- /dev/null +++ b/haiku/entry.cpp @@ -0,0 +1,54 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiEntry { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiEntry, // type name + uiEntryType, // type function + dummy // handle +) + +char *uiEntryText(uiEntry *e) +{ + // TODO + return NULL; +} + +void uiEntrySetText(uiEntry *e, const char *text) +{ + // TODO +} + +void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *e, void *data), void *data) +{ + // TODO +} + +int uiEntryReadOnly(uiEntry *e) +{ + // TODO + return 0; +} + +void uiEntrySetReadOnly(uiEntry *e, int readonly) +{ + // TODO +} + +uiEntry *uiNewEntry(void) +{ + uiEntry *e; + + e = (uiEntry *) uiNewControl(uiEntryType()); + + e->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiEntry not implemented"); + + uiHaikuFinishNewControl(e, uiEntry); + + return e; +} diff --git a/haiku/group.cpp b/haiku/group.cpp new file mode 100644 index 00000000..8cbeba87 --- /dev/null +++ b/haiku/group.cpp @@ -0,0 +1,54 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiGroup { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiGroup, // type name + uiGroupType, // type function + dummy // handle +) + +char *uiGroupTitle(uiGroup *g) +{ + // TODO + return NULL; +} + +void uiGroupSetTitle(uiGroup *g, const char *title) +{ + // TODO +} + +void uiGroupSetChild(uiGroup *g, uiControl *c) +{ + // TODO +} + +int uiGroupMargined(uiGroup *g) +{ + // TODO + return 0; +} + +void uiGroupSetMargined(uiGroup *g, int margined) +{ + // TODO +} + +uiGroup *uiNewGroup(const char *title) +{ + uiGroup *g; + + g = (uiGroup *) uiNewControl(uiGroupType()); + + g->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiGroup not implemented"); + + uiHaikuFinishNewControl(g, uiGroup); + + return g; +} diff --git a/haiku/label.cpp b/haiku/label.cpp new file mode 100644 index 00000000..e3cfc607 --- /dev/null +++ b/haiku/label.cpp @@ -0,0 +1,38 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +// TODO forcibly aligned to the bottom of the allocation + +struct uiLabel { + uiHaikuControl c; + BStringView *label; +}; + +uiHaikuDefineControl( + uiLabel, // type name + uiLabelType, // type function + label // handle +) + +char *uiLabelText(uiLabel *l) +{ + return uiHaikuStrdupText(l->label->Text()); +} + +void uiLabelSetText(uiLabel *l, const char *text) +{ + l->label->SetText(text); +} + +uiLabel *uiNewLabel(const char *text) +{ + uiLabel *l; + + l = (uiLabel *) uiNewControl(uiLabelType()); + + l->label = new BStringView(BRect(0, 0, 1, 1), NULL, text); + + uiHaikuFinishNewControl(l, uiLabel); + + return l; +} diff --git a/haiku/progressbar.cpp b/haiku/progressbar.cpp new file mode 100644 index 00000000..9ca7c5d4 --- /dev/null +++ b/haiku/progressbar.cpp @@ -0,0 +1,32 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiProgressBar { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiProgressBar, // type name + uiProgressBarType, // type function + dummy // handle +) + +void uiProgressBarSetValue(uiProgressBar *p, int n) +{ + // TODO +} + +uiProgressBar *uiNewProgressBar(void) +{ + uiProgressBar *p; + + p = (uiProgressBar *) uiNewControl(uiProgressBarType()); + + p->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiProgressBar not implemented"); + + uiHaikuFinishNewControl(p, uiProgressBar); + + return p; +} diff --git a/haiku/radiobuttons.cpp b/haiku/radiobuttons.cpp new file mode 100644 index 00000000..d590f6e0 --- /dev/null +++ b/haiku/radiobuttons.cpp @@ -0,0 +1,32 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiRadioButtons { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiRadioButtons, // type name + uiRadioButtonsType, // type function + dummy // handle +) + +void uiRadioButtonsAppend(uiRadioButtons *r, const char *text) +{ + // TODO +} + +uiRadioButtons *uiNewRadioButtons(void) +{ + uiRadioButtons *r; + + r = (uiRadioButtons *) uiNewControl(uiRadioButtonsType()); + + r->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiRadioButtons not implemented"); + + uiHaikuFinishNewControl(r, uiRadioButtons); + + return r; +} diff --git a/haiku/separator.cpp b/haiku/separator.cpp new file mode 100644 index 00000000..53c97da3 --- /dev/null +++ b/haiku/separator.cpp @@ -0,0 +1,27 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiSeparator { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiSeparator, // type name + uiSeparatorType, // type function + dummy // handle +) + +uiSeparator *uiNewHorizontalSeparator(void) +{ + uiSeparator *s; + + s = (uiSeparator *) uiNewControl(uiSeparatorType()); + + s->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiSeparator not implemented"); + + uiHaikuFinishNewControl(s, uiSeparator); + + return s; +} diff --git a/haiku/slider.cpp b/haiku/slider.cpp new file mode 100644 index 00000000..77926c95 --- /dev/null +++ b/haiku/slider.cpp @@ -0,0 +1,43 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiSlider { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiSlider, // type name + uiSliderType, // type function + dummy // handle +) + +intmax_t uiSliderValue(uiSlider *s) +{ + // TODO + return 0; +} + +void uiSliderSetValue(uiSlider *s, intmax_t value) +{ + // TODO +} + +void uiSliderOnChanged(uiSlider *s, void (*f)(uiSlider *s, void *data), void *data) +{ + // TODO +} + +uiSlider *uiNewSlider(intmax_t min, intmax_t max) +{ + uiSlider *s; + + s = (uiSlider *) uiNewControl(uiSliderType()); + + s->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiSlider not implemented"); + + uiHaikuFinishNewControl(s, uiSlider); + + return s; +} diff --git a/haiku/spinbox.cpp b/haiku/spinbox.cpp new file mode 100644 index 00000000..29b49e76 --- /dev/null +++ b/haiku/spinbox.cpp @@ -0,0 +1,43 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiSpinbox { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiSpinbox, // type name + uiSpinboxType, // type function + dummy // handle +) + +intmax_t uiSpinboxValue(uiSpinbox *s) +{ + // TODO + return 0; +} + +void uiSpinboxSetValue(uiSpinbox *s, intmax_t value) +{ + // TODO +} + +void uiSpinboxOnChanged(uiSpinbox *s, void (*f)(uiSpinbox *s, void *data), void *data) +{ + // TODO +} + +uiSpinbox *uiNewSpinbox(intmax_t min, intmax_t max) +{ + uiSpinbox *s; + + s = (uiSpinbox *) uiNewControl(uiSpinboxType()); + + s->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiSpinbox not implemented"); + + uiHaikuFinishNewControl(s, uiSpinbox); + + return s; +} diff --git a/haiku/tab.cpp b/haiku/tab.cpp new file mode 100644 index 00000000..f02ff8b9 --- /dev/null +++ b/haiku/tab.cpp @@ -0,0 +1,59 @@ +// 18 november 2015 +#include "uipriv_haiku.hpp" + +struct uiTab { + uiHaikuControl c; + BStringView *dummy; +}; + +uiHaikuDefineControl( + uiTab, // type name + uiTabType, // type function + dummy // handle +) + +void uiTabAppend(uiTab *t, const char *name, uiControl *c) +{ + // TODO +} + +void uiTabInsertAt(uiTab *t, const char *name, uintmax_t before, uiControl *c) +{ + // TODO +} + +void uiTabDelete(uiTab *t, uintmax_t index) +{ + // TODO +} + +uintmax_t uiTabNumPages(uiTab *t) +{ + // TODO + return 0; +} + +int uiTabMargined(uiTab *t, uintmax_t page) +{ + // TODO + return 0; +} + +void uiTabSetMargined(uiTab *t, uintmax_t page, int margined) +{ + // TODO +} + +uiTab *uiNewTab(void) +{ + uiTab *t; + + t = (uiTab *) uiNewControl(uiTabType()); + + t->dummy = new BStringView(BRect(0, 0, 1, 1), NULL, + "TODO uiTab not implemented"); + + uiHaikuFinishNewControl(t, uiTab); + + return t; +}