DISTRHO
/
gl-examples
mirror of https://github.com/DISTRHO/gl-examples
1
0
Fork 0
Code Releases 0 Activity
DPF OpenGL examples
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
61 Commits
1 Branch
2.1MB
Tree: 295eccbe1b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '295eccbe1b'
${ noResults }
gl-examples/examples/blendish_res/example.c

1311 lines
44KB
Raw Blame History 

  1. //

  2. // based on NanoVG's example code by Mikko Mononen

  3. 

  4. #include <stdio.h>

  5. #include <stdbool.h>

  6. #ifdef NANOVG_GLEW

  7. #	include <GL/glew.h>

  8. #endif

  9. #ifdef __APPLE__

  10. #	define GLFW_INCLUDE_GLCOREARB

  11. #endif

  12. #include <GLFW/glfw3.h>

  13. #include "nanovg.h"

  14. #define NANOVG_GL3_IMPLEMENTATION

  15. #include "nanovg_gl.h"

  16. 

  17. #define BLENDISH_IMPLEMENTATION

  18. #include "blendish.h"

  19. 

  20. #define OUI_IMPLEMENTATION

  21. #include "oui.h"

  22. 

  23. ////////////////////////////////////////////////////////////////////////////////

  24. 

  25. typedef struct exContext {

  26.     NVGcontext *vg;

  27.     UIcontext *uictx;

  28. } exContext;

  29. 

  30. typedef enum {

  31.     // label

  32.     ST_LABEL = 0,

  33.     // button

  34.     ST_BUTTON = 1,

  35.     // radio button

  36.     ST_RADIO = 2,

  37.     // progress slider

  38.     ST_SLIDER = 3,

  39.     // column

  40.     ST_COLUMN = 4,

  41.     // row

  42.     ST_ROW = 5,

  43.     // check button

  44.     ST_CHECK = 6,

  45.     // panel

  46.     ST_PANEL = 7,

  47.     // text

  48.     ST_TEXT = 8,

  49.     //

  50.     ST_IGNORE = 9,

  51. 

  52.     ST_DEMOSTUFF = 10,

  53.     // colored rectangle

  54.     ST_RECT = 11,

  55. 

  56.     ST_HBOX = 12,

  57.     ST_VBOX = 13,

  58. } SubType;

  59. 

  60. typedef struct {

  61.     int subtype;

  62.     UIhandler handler;

  63. } UIData;

  64. 

  65. typedef struct {

  66.     UIData head;

  67.     const char *label;

  68.     NVGcolor color;

  69. } UIRectData;

  70. 

  71. typedef struct {

  72.     UIData head;

  73.     int iconid;

  74.     const char *label;

  75. } UIButtonData;

  76. 

  77. typedef struct {

  78.     UIData head;

  79.     const char *label;

  80.     bool *option;

  81. } UICheckData;

  82. 

  83. typedef struct {

  84.     UIData head;

  85.     int iconid;

  86.     const char *label;

  87.     int *value;

  88. } UIRadioData;

  89. 

  90. typedef struct {

  91.     UIData head;

  92.     const char *label;

  93.     float *progress;

  94. } UISliderData;

  95. 

  96. typedef struct {

  97.     UIData head;

  98.     char *text;

  99.     int maxsize;

  100. } UITextData;

  101. 

  102. ////////////////////////////////////////////////////////////////////////////////

  103. 

  104. void draw_demostuff(NVGcontext *vg, int x, int y, float w, float h);

  105. 

  106. void ui_handler(UIcontext *uictx, int item, UIevent event) {

  107. 	UIData *data = (UIData *)uiGetHandle(uictx, item);

  108. 	if (data && data->handler) {

  109. 		data->handler(uictx, item, event);

  110. 	}

  111. }

  112. 

  113. void init(NVGcontext *vg) {

  114.     bndSetFont(nvgCreateFont(vg, "system", "../DejaVuSans.ttf"));

  115.     bndSetIconImage(nvgCreateImage(vg, "../blender_icons16.png", 0));

  116. }

  117. 

  118. void testrect(NVGcontext *vg, UIrect rect) {

  119. #if 0

  120.     nvgBeginPath(vg);

  121.     nvgRect(vg,rect.x+0.5,rect.y+0.5,rect.w-1,rect.h-1);

  122.     nvgStrokeColor(vg,nvgRGBf(1,0,0));

  123.     nvgStrokeWidth(vg,1);

  124.     nvgStroke(vg);

  125. #endif

  126. }

  127. 

  128. 

  129. void drawUI(exContext *ectx, int item, int corners);

  130. 

  131. void drawUIItems(exContext *ectx, int item, int corners) {

  132.     int kid = uiFirstChild(ectx->uictx, item);

  133.     while (kid > 0) {

  134.         drawUI(ectx, kid, corners);

  135.         kid = uiNextSibling(ectx->uictx, kid);

  136.     }

  137. }

  138. 

  139. void drawUIItemsHbox(exContext *ectx, int item) {

  140.     int kid = uiFirstChild(ectx->uictx, item);

  141.     if (kid < 0) return;

  142.     int nextkid = uiNextSibling(ectx->uictx, kid);

  143.     if (nextkid < 0) {

  144.         drawUI(ectx, kid, BND_CORNER_NONE);

  145.     } else {

  146.         drawUI(ectx, kid, BND_CORNER_RIGHT);

  147.         kid = nextkid;

  148.         while (uiNextSibling(ectx->uictx, kid) > 0) {

  149.             drawUI(ectx, kid, BND_CORNER_ALL);

  150.             kid = uiNextSibling(ectx->uictx, kid);

  151.         }

  152.         drawUI(ectx, kid, BND_CORNER_LEFT);

  153.     }

  154. }

  155. 

  156. void drawUIItemsVbox(exContext *ectx, int item) {

  157.     int kid = uiFirstChild(ectx->uictx, item);

  158.     if (kid < 0) return;

  159.     int nextkid = uiNextSibling(ectx->uictx, kid);

  160.     if (nextkid < 0) {

  161.         drawUI(ectx, kid, BND_CORNER_NONE);

  162.     } else {

  163.         drawUI(ectx, kid, BND_CORNER_DOWN);

  164.         kid = nextkid;

  165.         while (uiNextSibling(ectx->uictx, kid) > 0) {

  166.             drawUI(ectx, kid, BND_CORNER_ALL);

  167.             kid = uiNextSibling(ectx->uictx, kid);

  168.         }

  169.         drawUI(ectx, kid, BND_CORNER_TOP);

  170.     }

  171. }

  172. 

  173. void drawUI(exContext *ectx, int item, int corners) {

  174.     NVGcontext *vg = ectx->vg;

  175.     UIcontext *uictx = ectx->uictx;

  176.     const UIData *head = (const UIData *)uiGetHandle(uictx, item);

  177.     UIrect rect = uiGetRect(uictx, item);

  178.     if (uiGetState(uictx, item) == UI_FROZEN) {

  179.         nvgGlobalAlpha(vg, BND_DISABLED_ALPHA);

  180.     }

  181.     if (head) {

  182.         switch(head->subtype) {

  183.             default: {

  184.                 testrect(vg, rect);

  185.                 drawUIItems(ectx,item,corners);

  186.             } break;

  187.             case ST_HBOX: {

  188.                 drawUIItemsHbox(ectx, item);

  189.             } break;

  190.             case ST_VBOX: {

  191.                 drawUIItemsVbox(ectx, item);

  192.             } break;

  193.             case ST_PANEL: {

  194.                 bndBevel(vg,rect.x,rect.y,rect.w,rect.h);

  195.                 drawUIItems(ectx,item,corners);

  196.             } break;

  197.             case ST_LABEL: {

  198.                 assert(head);

  199.                 const UIButtonData *data = (UIButtonData*)head;

  200.                 bndLabel(vg,rect.x,rect.y,rect.w,rect.h,

  201.                     data->iconid,data->label);

  202.             } break;

  203.             case ST_BUTTON: {

  204.                 const UIButtonData *data = (UIButtonData*)head;

  205.                 bndToolButton(vg,rect.x,rect.y,rect.w,rect.h,

  206.                         corners,(BNDwidgetState)uiGetState(uictx, item),

  207.                     data->iconid,data->label);

  208.             } break;

  209.             case ST_CHECK: {

  210.                 const UICheckData *data = (UICheckData*)head;

  211.                 BNDwidgetState state = (BNDwidgetState)uiGetState(uictx, item);

  212.                 if (*data->option)

  213.                     state = BND_ACTIVE;

  214.                 bndOptionButton(vg,rect.x,rect.y,rect.w,rect.h, state,

  215.                     data->label);

  216.             } break;

  217.             case ST_RADIO:{

  218.                 const UIRadioData *data = (UIRadioData*)head;

  219.                 BNDwidgetState state = (BNDwidgetState)uiGetState(uictx, item);

  220.                 if (*data->value == item)

  221.                     state = BND_ACTIVE;

  222.                 bndRadioButton(vg,rect.x,rect.y,rect.w,rect.h,

  223.                         corners,state,

  224.                     data->iconid,data->label);

  225.             } break;

  226.             case ST_SLIDER:{

  227.                 const UISliderData *data = (UISliderData*)head;

  228.                 BNDwidgetState state = (BNDwidgetState)uiGetState(uictx, item);

  229.                 static char value[32];

  230.                 sprintf(value,"%.0f%%",(*data->progress)*100.0f);

  231.                 bndSlider(vg,rect.x,rect.y,rect.w,rect.h,

  232.                         corners,state,

  233.                     *data->progress,data->label,value);

  234.             } break;

  235.             case ST_TEXT: {

  236.                 const UITextData *data = (UITextData*)head;

  237.                 BNDwidgetState state = (BNDwidgetState)uiGetState(uictx, item);

  238.                 int idx = strlen(data->text);

  239.                 bndTextField(vg,rect.x,rect.y,rect.w,rect.h,

  240.                         corners,state, -1, data->text, idx, idx);

  241.             } break;

  242.             case ST_DEMOSTUFF: {

  243.                 draw_demostuff(vg, rect.x, rect.y, rect.w, rect.h);

  244.             } break;

  245.             case ST_RECT: {

  246.                 const UIRectData *data = (UIRectData*)head;

  247.                 if (rect.w && rect.h) {

  248.                     BNDwidgetState state = (BNDwidgetState)uiGetState(uictx, item);

  249.                     nvgSave(vg);

  250.                     nvgStrokeColor(vg, nvgRGBAf(data->color.r,data->color.g,data->color.b,0.9f));

  251.                     if (state != BND_DEFAULT) {

  252.                         nvgFillColor(vg, nvgRGBAf(data->color.r,data->color.g,data->color.b,0.5f));

  253.                     } else {

  254.                         nvgFillColor(vg, nvgRGBAf(data->color.r,data->color.g,data->color.b,0.1f));

  255.                     }

  256.                     nvgStrokeWidth(vg,2);

  257.                     nvgBeginPath(vg);

  258.                     #if 0

  259.                     nvgRect(vg,rect.x,rect.y,rect.w,rect.h);

  260.                     #else

  261.                     nvgRoundedRect(vg,rect.x,rect.y,rect.w,rect.h,3);

  262.                     #endif

  263.                     nvgFill(vg);

  264.                     nvgStroke(vg);

  265. 

  266.                     if (state != BND_DEFAULT) {

  267.                         nvgFillColor(vg, nvgRGBAf(0.0f,0.0f,0.0f,1.0f));

  268.                         nvgFontSize(vg, 15.0f);

  269.                         nvgBeginPath(vg);

  270.                         nvgTextAlign(vg, NVG_ALIGN_TOP|NVG_ALIGN_CENTER);

  271.                         nvgTextBox(vg, rect.x, rect.y+rect.h*0.3f, rect.w, data->label, NULL);

  272.                     }

  273. 

  274.                     nvgRestore(vg);

  275.                 }

  276.                 nvgSave(vg);

  277.                 nvgIntersectScissor(vg, rect.x, rect.y, rect.w, rect.h);

  278. 

  279.                 drawUIItems(ectx,item,corners);

  280. 

  281.                 nvgRestore(vg);

  282.             } break;

  283.         }

  284.     } else {

  285.         testrect(vg,rect);

  286.         drawUIItems(ectx,item,corners);

  287.     }

  288. 

  289.     if (uiGetState(uictx, item) == UI_FROZEN) {

  290.         nvgGlobalAlpha(vg, 1.0);

  291.     }

  292. }

  293. 

  294. 

  295. int colorrect(UIcontext *uictx, const char *label, NVGcolor color) {

  296.     int item = uiItem(uictx);

  297.     UIRectData *data = (UIRectData *)uiAllocHandle(uictx, item, sizeof(UIRectData));

  298.     data->head.subtype = ST_RECT;

  299.     data->head.handler = NULL;

  300.     data->label = label;

  301.     data->color = color;

  302.     uiSetEvents(uictx, item, UI_BUTTON0_DOWN);

  303.     return item;

  304. }

  305. 

  306. int label(UIcontext *uictx, int iconid, const char *label) {

  307.     int item = uiItem(uictx);

  308.     uiSetSize(uictx, item, 0, BND_WIDGET_HEIGHT);

  309.     UIButtonData *data = (UIButtonData *)uiAllocHandle(uictx, item, sizeof(UIButtonData));

  310.     data->head.subtype = ST_LABEL;

  311.     data->head.handler = NULL;

  312.     data->iconid = iconid;

  313.     data->label = label;

  314.     return item;

  315. }

  316. 

  317. void demohandler(UIcontext *uictx, int item, UIevent event) {

  318.     const UIButtonData *data = (const UIButtonData *)uiGetHandle(uictx, item);

  319.     printf("clicked: %p %s\n", uiGetHandle(uictx, item), data->label);

  320. }

  321. 

  322. int button(UIcontext *uictx, int iconid, const char *label, UIhandler handler) {

  323.     // create new ui item

  324.     int item = uiItem(uictx);

  325.     // set size of wiget; horizontal size is dynamic, vertical is fixed

  326.     uiSetSize(uictx, item, 0, BND_WIDGET_HEIGHT);

  327.     uiSetEvents(uictx, item, UI_BUTTON0_HOT_UP);

  328.     // store some custom data with the button that we use for styling

  329.     UIButtonData *data = (UIButtonData *)uiAllocHandle(uictx, item, sizeof(UIButtonData));

  330.     data->head.subtype = ST_BUTTON;

  331.     data->head.handler = handler;

  332.     data->iconid = iconid;

  333.     data->label = label;

  334.     return item;

  335. }

  336. 

  337. void checkhandler(UIcontext *uictx, int item, UIevent event) {

  338.     const UICheckData *data = (const UICheckData *)uiGetHandle(uictx, item);

  339.     *data->option = !(*data->option);

  340. }

  341. 

  342. int check(UIcontext *uictx, const char *label, bool *option) {

  343.     // create new ui item

  344.     int item = uiItem(uictx);

  345.     // set size of wiget; horizontal size is dynamic, vertical is fixed

  346.     uiSetSize(uictx, item, 0, BND_WIDGET_HEIGHT);

  347.     // attach event handler e.g. demohandler above

  348.     uiSetEvents(uictx, item, UI_BUTTON0_DOWN);

  349.     // store some custom data with the button that we use for styling

  350.     UICheckData *data = (UICheckData *)uiAllocHandle(uictx, item, sizeof(UICheckData));

  351.     data->head.subtype = ST_CHECK;

  352.     data->head.handler = checkhandler;

  353.     data->label = label;

  354.     data->option = option;

  355.     return item;

  356. }

  357. 

  358. // simple logic for a slider

  359. 

  360. // starting offset of the currently active slider

  361. static float sliderstart = 0.0;

  362. 

  363. // event handler for slider (same handler for all sliders)

  364. void sliderhandler(UIcontext *uictx, int item, UIevent event) {

  365.     // retrieve the custom data we saved with the slider

  366.     UISliderData *data = (UISliderData *)uiGetHandle(uictx, item);

  367.     switch(event) {

  368.         default: break;

  369.         case UI_BUTTON0_DOWN: {

  370.             // button was pressed for the first time; capture initial

  371.             // slider value.

  372.             sliderstart = *data->progress;

  373.         } break;

  374.         case UI_BUTTON0_CAPTURE: {

  375.             // called for every frame that the button is pressed.

  376.             // get the delta between the click point and the current

  377.             // mouse position

  378.             UIvec2 pos = uiGetCursorStartDelta(uictx);

  379.             // get the items layouted rectangle

  380.             UIrect rc = uiGetRect(uictx, item);

  381.             // calculate our new offset and clamp

  382.             float value = sliderstart + ((float)pos.x / (float)rc.w);

  383.             value = (value<0)?0:(value>1)?1:value;

  384.             // assign the new value

  385.             *data->progress = value;

  386.         } break;

  387.     }

  388. }

  389. 

  390. int slider(UIcontext *uictx, const char *label, float *progress) {

  391.     // create new ui item

  392.     int item = uiItem(uictx);

  393.     // set size of wiget; horizontal size is dynamic, vertical is fixed

  394.     uiSetSize(uictx, item, 0, BND_WIDGET_HEIGHT);

  395.     // attach our slider event handler and capture two classes of events

  396.     uiSetEvents(uictx, item, UI_BUTTON0_DOWN | UI_BUTTON0_CAPTURE);

  397.     // store some custom data with the button that we use for styling

  398.     // and logic, e.g. the pointer to the data we want to alter.

  399.     UISliderData *data = (UISliderData *)uiAllocHandle(uictx, item, sizeof(UISliderData));

  400.     data->head.subtype = ST_SLIDER;

  401.     data->head.handler = sliderhandler;

  402.     data->label = label;

  403.     data->progress = progress;

  404.     return item;

  405. }

  406. 

  407. void textboxhandler(UIcontext *uictx, int item, UIevent event) {

  408.     UITextData *data = (UITextData *)uiGetHandle(uictx, item);

  409.     switch(event) {

  410.         default: break;

  411.         case UI_BUTTON0_DOWN: {

  412.             uiFocus(uictx, item);

  413.         } break;

  414.         case UI_KEY_DOWN: {

  415.             unsigned int key = uiGetKey(uictx);

  416.             switch(key) {

  417.                 default: break;

  418.                 case GLFW_KEY_BACKSPACE: {

  419.                     int size = strlen(data->text);

  420.                     if (!size) return;

  421.                     data->text[size-1] = 0;

  422.                 } break;

  423.                 case GLFW_KEY_ENTER: {

  424.                     uiFocus(uictx, -1);

  425.                 } break;

  426.             }

  427.         } break;

  428.         case UI_CHAR: {

  429.             unsigned int key = uiGetKey(uictx);

  430.             if ((key > 255)||(key < 32)) return;

  431.             int size = strlen(data->text);

  432.             if (size >= (data->maxsize-1)) return;

  433.             data->text[size] = (char)key;

  434.         } break;

  435.     }

  436. }

  437. 

  438. int textbox(UIcontext *uictx, char *text, int maxsize) {

  439.     int item = uiItem(uictx);

  440.     uiSetSize(uictx, item, 0, BND_WIDGET_HEIGHT);

  441.     uiSetEvents(uictx, item, UI_BUTTON0_DOWN | UI_KEY_DOWN | UI_CHAR);

  442.     // store some custom data with the button that we use for styling

  443.     // and logic, e.g. the pointer to the data we want to alter.

  444.     UITextData *data = (UITextData *)uiAllocHandle(uictx, item, sizeof(UITextData));

  445.     data->head.subtype = ST_TEXT;

  446.     data->head.handler = textboxhandler;

  447.     data->text = text;

  448.     data->maxsize = maxsize;

  449.     return item;

  450. }

  451. 

  452. // simple logic for a radio button

  453. void radiohandler(UIcontext *uictx, int item, UIevent event) {

  454.     UIRadioData *data = (UIRadioData *)uiGetHandle(uictx, item);

  455.     *data->value = item;

  456. }

  457. 

  458. int radio(UIcontext *uictx, int iconid, const char *label, int *value) {

  459.     int item = uiItem(uictx);

  460.     uiSetSize(uictx, item, label?0:BND_TOOL_WIDTH, BND_WIDGET_HEIGHT);

  461.     UIRadioData *data = (UIRadioData *)uiAllocHandle(uictx, item, sizeof(UIRadioData));

  462.     data->head.subtype = ST_RADIO;

  463.     data->head.handler = radiohandler;

  464.     data->iconid = iconid;

  465.     data->label = label;

  466.     data->value = value;

  467.     uiSetEvents(uictx, item, UI_BUTTON0_DOWN);

  468.     return item;

  469. }

  470. 

  471. int panel(UIcontext *uictx) {

  472.     int item = uiItem(uictx);

  473.     UIData *data = (UIData *)uiAllocHandle(uictx, item, sizeof(UIData));

  474.     data->subtype = ST_PANEL;

  475.     data->handler = NULL;

  476.     return item;

  477. }

  478. 

  479. int hbox(UIcontext *uictx) {

  480.     int item = uiItem(uictx);

  481.     UIData *data = (UIData *)uiAllocHandle(uictx, item, sizeof(UIData));

  482.     data->subtype = ST_HBOX;

  483.     data->handler = NULL;

  484.     uiSetBox(uictx, item, UI_ROW);

  485.     return item;

  486. }

  487. 

  488. 

  489. int vbox(UIcontext *uictx) {

  490.     int item = uiItem(uictx);

  491.     UIData *data = (UIData *)uiAllocHandle(uictx, item, sizeof(UIData));

  492.     data->subtype = ST_VBOX;

  493.     data->handler = NULL;

  494.     uiSetBox(uictx, item, UI_COLUMN);

  495.     return item;

  496. }

  497. 

  498. 

  499. int column_append(UIcontext *uictx, int parent, int item) {

  500.     uiInsert(uictx, parent, item);

  501.     // fill parent horizontally, anchor to previous item vertically

  502.     uiSetLayout(uictx, item, UI_HFILL);

  503.     uiSetMargins(uictx, item, 0, 1, 0, 0);

  504.     return item;

  505. }

  506. 

  507. int column(UIcontext *uictx) {

  508.     int item = uiItem(uictx);

  509.     uiSetBox(uictx, item, UI_COLUMN);

  510.     return item;

  511. }

  512. 

  513. int vgroup_append(UIcontext *uictx, int parent, int item) {

  514.     uiInsert(uictx, parent, item);

  515.     // fill parent horizontally, anchor to previous item vertically

  516.     uiSetLayout(uictx, item, UI_HFILL);

  517.     return item;

  518. }

  519. 

  520. int vgroup(UIcontext *uictx) {

  521.     int item = uiItem(uictx);

  522.     uiSetBox(uictx, item, UI_COLUMN);

  523.     return item;

  524. }

  525. 

  526. int hgroup_append(UIcontext *uictx, int parent, int item) {

  527.     uiInsert(uictx, parent, item);

  528.     uiSetLayout(uictx, item, UI_HFILL);

  529.     return item;

  530. }

  531. 

  532. int hgroup_append_fixed(UIcontext *uictx, int parent, int item) {

  533.     uiInsert(uictx, parent, item);

  534.     return item;

  535. }

  536. 

  537. int hgroup(UIcontext *uictx) {

  538.     int item = uiItem(uictx);

  539.     uiSetBox(uictx, item, UI_ROW);

  540.     return item;

  541. }

  542. 

  543. int row_append(UIcontext *uictx, int parent, int item) {

  544.     uiInsert(uictx, parent, item);

  545.     uiSetLayout(uictx, item, UI_HFILL);

  546.     return item;

  547. }

  548. 

  549. int row(UIcontext *uictx) {

  550.     int item = uiItem(uictx);

  551.     uiSetBox(uictx, item, UI_ROW);

  552.     return item;

  553. }

  554. 

  555. void draw_noodles(NVGcontext *vg, int x, int y) {

  556.     int w = 200;

  557.     int s = 70;

  558.     int i;

  559. 

  560.     bndNodeBackground(vg, x+w, y-50, 100, 200, BND_DEFAULT, BND_ICONID(6,3),

  561.         "Default", nvgRGBf(0.392f,0.392f,0.392f));

  562.     bndNodeBackground(vg, x+w+120, y-50, 100, 200, BND_HOVER, BND_ICONID(6,3),

  563.         "Hover", nvgRGBf(0.392f,0.392f,0.392f));

  564.     bndNodeBackground(vg, x+w+240, y-50, 100, 200, BND_ACTIVE, BND_ICONID(6,3),

  565.         "Active", nvgRGBf(0.392f,0.392f,0.392f));

  566. 

  567.     for (i = 0; i < 9; ++i) {

  568.         int a = i%3;

  569.         int b = i/3;

  570.         bndNodeWire(vg, x, y+s*a, x+w, y+s*b, (BNDwidgetState)a, (BNDwidgetState)b);

  571.     }

  572. 

  573.     bndNodePort(vg, x, y, BND_DEFAULT, nvgRGBf(0.5f, 0.5f, 0.5f));

  574.     bndNodePort(vg, x+w, y, BND_DEFAULT, nvgRGBf(0.5f, 0.5f, 0.5f));

  575.     bndNodePort(vg, x, y+s, BND_HOVER, nvgRGBf(0.5f, 0.5f, 0.5f));

  576.     bndNodePort(vg, x+w, y+s, BND_HOVER, nvgRGBf(0.5f, 0.5f, 0.5f));

  577.     bndNodePort(vg, x, y+2*s, BND_ACTIVE, nvgRGBf(0.5f, 0.5f, 0.5f));

  578.     bndNodePort(vg, x+w, y+2*s, BND_ACTIVE, nvgRGBf(0.5f, 0.5f, 0.5f));

  579. }

  580. 

  581. static void roothandler(UIcontext *uictx, int parent, UIevent event) {

  582. 	switch(event) {

  583. 	default: break;

  584. 	case UI_SCROLL: {

  585. 		UIvec2 pos = uiGetScroll(uictx);

  586. 		printf("scroll! %d %d\n", pos.x, pos.y);

  587. 	} break;

  588. 	case UI_BUTTON0_DOWN: {

  589. 		printf("%d clicks\n", uiGetClicks(uictx));

  590. 	} break;

  591. 	}

  592. }

  593. 

  594. void draw_demostuff(NVGcontext *vg, int x, int y, float w, float h) {

  595.     nvgSave(vg);

  596.     nvgTranslate(vg, x, y);

  597. 

  598.     bndSplitterWidgets(vg, 0, 0, w, h);

  599. 

  600.     x = 10;

  601.     y = 10;

  602. 

  603.     bndToolButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  604.         BND_ICONID(6,3),"Default");

  605.     y += 25;

  606.     bndToolButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  607.         BND_ICONID(6,3),"Hovered");

  608.     y += 25;

  609.     bndToolButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  610.         BND_ICONID(6,3),"Active");

  611. 

  612.     y += 40;

  613.     bndRadioButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  614.         -1,"Default");

  615.     y += 25;

  616.     bndRadioButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  617.         -1,"Hovered");

  618.     y += 25;

  619.     bndRadioButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  620.         -1,"Active");

  621. 

  622.     y += 25;

  623.     bndLabel(vg,x,y,120,BND_WIDGET_HEIGHT,-1,"Label:");

  624.     y += BND_WIDGET_HEIGHT;

  625.     bndChoiceButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  626.         -1, "Default");

  627.     y += 25;

  628.     bndChoiceButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  629.         -1, "Hovered");

  630.     y += 25;

  631.     bndChoiceButton(vg,x,y,80,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  632.         -1, "Active");

  633. 

  634.     y += 25;

  635.     int ry = y;

  636.     int rx = x;

  637. 

  638.     y = 10;

  639.     x += 130;

  640.     bndOptionButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_DEFAULT,"Default");

  641.     y += 25;

  642.     bndOptionButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_HOVER,"Hovered");

  643.     y += 25;

  644.     bndOptionButton(vg,x,y,120,BND_WIDGET_HEIGHT,BND_ACTIVE,"Active");

  645. 

  646.     y += 40;

  647.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_DOWN,BND_DEFAULT,

  648.         "Top","100");

  649.     y += BND_WIDGET_HEIGHT-2;

  650.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_ALL,BND_DEFAULT,

  651.         "Center","100");

  652.     y += BND_WIDGET_HEIGHT-2;

  653.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_TOP,BND_DEFAULT,

  654.         "Bottom","100");

  655. 

  656.     int mx = x-30;

  657.     int my = y-12;

  658.     int mw = 120;

  659.     bndMenuBackground(vg,mx,my,mw,120,BND_CORNER_TOP);

  660.     bndMenuLabel(vg,mx,my,mw,BND_WIDGET_HEIGHT,-1,"Menu Title");

  661.     my += BND_WIDGET_HEIGHT-2;

  662.     bndMenuItem(vg,mx,my,mw,BND_WIDGET_HEIGHT,BND_DEFAULT,

  663.         BND_ICONID(17,3),"Default");

  664.     my += BND_WIDGET_HEIGHT-2;

  665.     bndMenuItem(vg,mx,my,mw,BND_WIDGET_HEIGHT,BND_HOVER,

  666.         BND_ICONID(18,3),"Hovered");

  667.     my += BND_WIDGET_HEIGHT-2;

  668.     bndMenuItem(vg,mx,my,mw,BND_WIDGET_HEIGHT,BND_ACTIVE,

  669.         BND_ICONID(19,3),"Active");

  670. 

  671.     y = 10;

  672.     x += 130;

  673.     int ox = x;

  674.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  675.         "Default","100");

  676.     y += 25;

  677.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  678.         "Hovered","100");

  679.     y += 25;

  680.     bndNumberField(vg,x,y,120,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  681.         "Active","100");

  682. 

  683.     y += 40;

  684.     bndRadioButton(vg,x,y,60,BND_WIDGET_HEIGHT,BND_CORNER_RIGHT,BND_DEFAULT,

  685.         -1,"One");

  686.     x += 60-1;

  687.     bndRadioButton(vg,x,y,60,BND_WIDGET_HEIGHT,BND_CORNER_ALL,BND_DEFAULT,

  688.         -1,"Two");

  689.     x += 60-1;

  690.     bndRadioButton(vg,x,y,60,BND_WIDGET_HEIGHT,BND_CORNER_ALL,BND_DEFAULT,

  691.         -1,"Three");

  692.     x += 60-1;

  693.     bndRadioButton(vg,x,y,60,BND_WIDGET_HEIGHT,BND_CORNER_LEFT,BND_ACTIVE,

  694.         -1,"Butts");

  695. 

  696.     x = ox;

  697.     y += 40;

  698.     float progress_value = fmodf(glfwGetTime()/10.0,1.0);

  699.     char progress_label[32];

  700.     sprintf(progress_label, "%d%%", (int)(progress_value*100+0.5f));

  701.     bndSlider(vg,x,y,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  702.         progress_value,"Default",progress_label);

  703.     y += 25;

  704.     bndSlider(vg,x,y,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  705.         progress_value,"Hovered",progress_label);

  706.     y += 25;

  707.     bndSlider(vg,x,y,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  708.         progress_value,"Active",progress_label);

  709. 

  710.     int rw = x+240-rx;

  711.     float s_offset = sinf(glfwGetTime()/2.0)*0.5+0.5;

  712.     float s_size = cosf(glfwGetTime()/3.11)*0.5+0.5;

  713. 

  714.     bndScrollBar(vg,rx,ry,rw,BND_SCROLLBAR_HEIGHT,BND_DEFAULT,s_offset,s_size);

  715.     ry += 20;

  716.     bndScrollBar(vg,rx,ry,rw,BND_SCROLLBAR_HEIGHT,BND_HOVER,s_offset,s_size);

  717.     ry += 20;

  718.     bndScrollBar(vg,rx,ry,rw,BND_SCROLLBAR_HEIGHT,BND_ACTIVE,s_offset,s_size);

  719. 

  720.     const char edit_text[] = "The quick brown fox";

  721.     int textlen = strlen(edit_text)+1;

  722.     int t = (int)(glfwGetTime()*2);

  723.     int idx1 = (t/textlen)%textlen;

  724.     int idx2 = idx1 + (t%(textlen-idx1));

  725. 

  726.     ry += 25;

  727.     bndTextField(vg,rx,ry,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_DEFAULT,

  728.         -1, edit_text, idx1, idx2);

  729.     ry += 25;

  730.     bndTextField(vg,rx,ry,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_HOVER,

  731.         -1, edit_text, idx1, idx2);

  732.     ry += 25;

  733.     bndTextField(vg,rx,ry,240,BND_WIDGET_HEIGHT,BND_CORNER_NONE,BND_ACTIVE,

  734.         -1, edit_text, idx1, idx2);

  735. 

  736.     draw_noodles(vg, 20, ry+50);

  737. 

  738.     rx += rw + 20;

  739.     ry = 10;

  740.     bndScrollBar(vg,rx,ry,BND_SCROLLBAR_WIDTH,240,BND_DEFAULT,s_offset,s_size);

  741.     rx += 20;

  742.     bndScrollBar(vg,rx,ry,BND_SCROLLBAR_WIDTH,240,BND_HOVER,s_offset,s_size);

  743.     rx += 20;

  744.     bndScrollBar(vg,rx,ry,BND_SCROLLBAR_WIDTH,240,BND_ACTIVE,s_offset,s_size);

  745. 

  746.     x = ox;

  747.     y += 40;

  748.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_RIGHT,

  749.         BND_DEFAULT,BND_ICONID(0,10),NULL);

  750.     x += BND_TOOL_WIDTH-1;

  751.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  752.         BND_DEFAULT,BND_ICONID(1,10),NULL);

  753.     x += BND_TOOL_WIDTH-1;

  754.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  755.         BND_DEFAULT,BND_ICONID(2,10),NULL);

  756.     x += BND_TOOL_WIDTH-1;

  757.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  758.         BND_DEFAULT,BND_ICONID(3,10),NULL);

  759.     x += BND_TOOL_WIDTH-1;

  760.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  761.         BND_DEFAULT,BND_ICONID(4,10),NULL);

  762.     x += BND_TOOL_WIDTH-1;

  763.     bndToolButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_LEFT,

  764.         BND_DEFAULT,BND_ICONID(5,10),NULL);

  765.     x += BND_TOOL_WIDTH-1;

  766.     x += 5;

  767.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_RIGHT,

  768.         BND_DEFAULT,BND_ICONID(0,11),NULL);

  769.     x += BND_TOOL_WIDTH-1;

  770.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  771.         BND_DEFAULT,BND_ICONID(1,11),NULL);

  772.     x += BND_TOOL_WIDTH-1;

  773.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  774.         BND_DEFAULT,BND_ICONID(2,11),NULL);

  775.     x += BND_TOOL_WIDTH-1;

  776.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  777.         BND_DEFAULT,BND_ICONID(3,11),NULL);

  778.     x += BND_TOOL_WIDTH-1;

  779.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_ALL,

  780.         BND_ACTIVE,BND_ICONID(4,11),NULL);

  781.     x += BND_TOOL_WIDTH-1;

  782.     bndRadioButton(vg,x,y,BND_TOOL_WIDTH,BND_WIDGET_HEIGHT,BND_CORNER_LEFT,

  783.         BND_DEFAULT,BND_ICONID(5,11),NULL);

  784. 

  785.     nvgRestore(vg);

  786. }

  787. 

  788. static int enum1 = -1;

  789. 

  790. void build_democontent(UIcontext *uictx, int parent) {

  791.     // some persistent variables for demonstration

  792.     static float progress1 = 0.25f;

  793.     static float progress2 = 0.75f;

  794.     static bool option1 = true;

  795.     static bool option2 = false;

  796.     static bool option3 = false;

  797. 

  798.     int col = column(uictx);

  799.     uiInsert(uictx, parent, col);

  800.     uiSetMargins(uictx, col, 10, 10, 10, 10);

  801.     uiSetLayout(uictx, col, UI_TOP|UI_HFILL);

  802. 

  803.     column_append(uictx, col, button(uictx, BND_ICON_GHOST, "Item 1", demohandler));

  804.     if (option3)

  805.         column_append(uictx, col, button(uictx, BND_ICON_GHOST, "Item 2", demohandler));

  806. 

  807.     {

  808.         int h = column_append(uictx, col, hbox(uictx));

  809.         hgroup_append(uictx, h, radio(uictx, BND_ICON_GHOST, "Item 3.0", &enum1));

  810.         if (option2)

  811.             uiSetMargins(uictx, hgroup_append_fixed(uictx, h, radio(uictx, BND_ICON_REC, NULL, &enum1)), -1,0,0,0);

  812.         uiSetMargins(uictx, hgroup_append_fixed(uictx, h, radio(uictx, BND_ICON_PLAY, NULL, &enum1)), -1,0,0,0);

  813.         uiSetMargins(uictx, hgroup_append(uictx, h, radio(uictx, BND_ICON_GHOST, "Item 3.3", &enum1)), -1,0,0,0);

  814.     }

  815. 

  816.     {

  817.         int rows = column_append(uictx, col, row(uictx));

  818.         int coll = row_append(uictx, rows, vgroup(uictx));

  819.         vgroup_append(uictx, coll, label(uictx, -1, "Items 4.0:"));

  820.         coll = vgroup_append(uictx, coll, vbox(uictx));

  821.         vgroup_append(uictx, coll, button(uictx, BND_ICON_GHOST, "Item 4.0.0", demohandler));

  822.         uiSetMargins(uictx, vgroup_append(uictx, coll, button(uictx, BND_ICON_GHOST, "Item 4.0.1", demohandler)),0,-2,0,0);

  823.         int colr = row_append(uictx, rows, vgroup(uictx));

  824.         uiSetMargins(uictx, colr, 8, 0, 0, 0);

  825.         uiSetFrozen(uictx, colr, option1);

  826.         vgroup_append(uictx, colr, label(uictx, -1, "Items 4.1:"));

  827.         colr = vgroup_append(uictx, colr, vbox(uictx));

  828.         vgroup_append(uictx, colr, slider(uictx, "Item 4.1.0", &progress1));

  829.         uiSetMargins(uictx, vgroup_append(uictx, colr, slider(uictx, "Item 4.1.1", &progress2)),0,-2,0,0);

  830.     }

  831. 

  832.     column_append(uictx, col, button(uictx, BND_ICON_GHOST, "Item 5", NULL));

  833. 

  834.     static char textbuffer[1024] = "The quick brown fox.";

  835.     column_append(uictx, col, textbox(uictx, textbuffer, 1024));

  836. 

  837.     column_append(uictx, col, check(uictx, "Frozen", &option1));

  838.     column_append(uictx, col, check(uictx, "Item 7", &option2));

  839.     column_append(uictx, col, check(uictx, "Item 8", &option3));

  840. }

  841. 

  842. int demorect(UIcontext *uictx, int parent, const char *label, float hue, int box, int layout, int w, int h, int m1, int m2, int m3, int m4) {

  843.     int item = colorrect(uictx, label, nvgHSL(hue, 1.0f, 0.8f));

  844.     uiSetLayout(uictx, item, layout);

  845.     uiSetBox(uictx, item, box);

  846.     uiSetMargins(uictx, item, m1, m2, m3, m4);

  847.     uiSetSize(uictx, item, w, h);

  848.     uiInsert(uictx, parent, item);

  849.     return item;

  850. }

  851. 

  852. void build_layoutdemo(UIcontext *uictx, int parent) {

  853.     const int M = 10;

  854.     const int S = 150;

  855. 

  856.     int box = demorect(uictx, parent, "Box( UI_LAYOUT )\nLayout( UI_FILL )", 0.6f, UI_LAYOUT, UI_FILL, 0, 0, M, M, M, M);

  857.     demorect(uictx, box, "Layout( UI_HFILL | UI_TOP )", 0.7f, 0, UI_HFILL|UI_TOP, S, S+M, M, M, M, 0);

  858.     demorect(uictx, box, "Layout( UI_HFILL )", 0.7f, 0, UI_HFILL, S, S+2*M, M, 0, M, 0);

  859.     demorect(uictx, box, "Layout( UI_HFILL | UI_DOWN )", 0.7f, 0, UI_HFILL|UI_DOWN, S, S+M, M, 0, M, M);

  860. 

  861.     demorect(uictx, box, "Layout( UI_LEFT | UI_VFILL )", 0.7f, 0, UI_LEFT|UI_VFILL, S+M, S, M, M, 0, M);

  862.     demorect(uictx, box, "Layout( UI_VFILL )", 0.7f, 0, UI_VFILL, S+2*M, S, 0, M, 0, M);

  863.     demorect(uictx, box, "Layout( UI_RIGHT | UI_VFILL )", 0.7f, 0, UI_RIGHT|UI_VFILL, S+M, S, 0, M, M, M);

  864. 

  865.     demorect(uictx, box, "Layout( UI_LEFT | UI_TOP )", 0.55f, 0, UI_LEFT|UI_TOP, S, S, M, M, 0, 0);

  866.     demorect(uictx, box, "Layout( UI_TOP )", 0.57f, 0, UI_TOP, S, S, 0, M, 0, 0);

  867.     demorect(uictx, box, "Layout( UI_RIGHT | UI_TOP )", 0.55f, 0, UI_RIGHT|UI_TOP, S, S, 0, M, M, 0);

  868.     demorect(uictx, box, "Layout( UI_LEFT )", 0.57f, 0, UI_LEFT, S, S, M, 0, 0, 0);

  869.     demorect(uictx, box, "Layout( UI_CENTER )", 0.59f, 0, UI_CENTER, S, S, 0, 0, 0, 0);

  870.     demorect(uictx, box, "Layout( UI_RIGHT )", 0.57f, 0, UI_RIGHT, S, S, 0, 0, M, 0);

  871.     demorect(uictx, box, "Layout( UI_LEFT | UI_DOWN )", 0.55f, 0, UI_LEFT|UI_DOWN, S, S, M, 0, 0, M);

  872.     demorect(uictx, box, "Layout( UI_DOWN)", 0.57f, 0, UI_DOWN, S, S, 0, 0, 0, M);

  873.     demorect(uictx, box, "Layout( UI_RIGHT | UI_DOWN )", 0.55f, 0, UI_RIGHT|UI_DOWN, S, S, 0, 0, M, M);

  874. }

  875. 

  876. void build_rowdemo(UIcontext *uictx, int parent) {

  877.     uiSetBox(uictx, parent, UI_COLUMN);

  878. 

  879.     const int M = 10;

  880.     const int S = 200;

  881.     const int T = 100;

  882. 

  883.     {

  884.         int box = demorect(uictx, parent, "Box( UI_ROW )\nLayout( UI_LEFT | UI_VFILL )", 0.6f, UI_ROW, UI_LEFT|UI_VFILL, 0, S, M, M, M, M);

  885. 

  886.         demorect(uictx, box, "Layout( UI_TOP )", 0.05f, 0, UI_TOP, T, T, M, M, M, 0);

  887.         demorect(uictx, box, "Layout( UI_VCENTER )", 0.1f, 0, UI_VCENTER, T, T, 0, 0, M, 0);

  888.         demorect(uictx, box, "Layout( UI_VFILL )", 0.15f, 0, UI_VFILL, T, T, 0, M, M, M);

  889.         demorect(uictx, box, "Layout( UI_DOWN )", 0.25f, 0, UI_DOWN, T, T, 0, 0, M, M);

  890.     }

  891.     {

  892.         int box = demorect(uictx, parent, "Box( UI_ROW | UI_JUSTIFY )\nLayout( UI_FILL )", 0.6f, UI_ROW|UI_JUSTIFY, UI_FILL, 0, S, M, 0, M, M);

  893. 

  894.         demorect(uictx, box, "Layout( UI_TOP )", 0.05f, 0, UI_TOP, T, T, M, M, M, 0);

  895.         demorect(uictx, box, "Layout( UI_VCENTER )", 0.1f, 0, UI_VCENTER, T, T, 0, 0, M, 0);

  896.         demorect(uictx, box, "Layout( UI_VFILL )", 0.15f, 0, UI_VFILL, T, T, 0, M, M, M);

  897.         demorect(uictx, box, "Layout( UI_DOWN )", 0.25f, 0, UI_DOWN, T, T, 0, 0, M, M);

  898.     }

  899.     {

  900.         int box = demorect(uictx, parent, "Box( UI_ROW )\nLayout( UI_FILL )", 0.6f, UI_ROW, UI_FILL, 0, S, M, 0, M, M);

  901. 

  902.         demorect(uictx, box, "Layout( UI_TOP )", 0.05f, 0, UI_TOP, T, T, M, M, M, 0);

  903.         demorect(uictx, box, "Layout( UI_VCENTER )", 0.1f, 0, UI_VCENTER, T, T, 0, 0, M, 0);

  904.         demorect(uictx, box, "Layout( UI_VFILL )", 0.15f, 0, UI_VFILL, T, T, 0, M, M, M);

  905.         demorect(uictx, box, "Layout( UI_HFILL )", 0.2f, 0, UI_HFILL, T, T, 0, 0, M, 0);

  906.         demorect(uictx, box, "Layout( UI_HFILL )", 0.2f, 0, UI_HFILL, T, T, 0, 0, M, 0);

  907.         demorect(uictx, box, "Layout( UI_HFILL )", 0.2f, 0, UI_HFILL, T, T, 0, 0, M, 0);

  908.         demorect(uictx, box, "Layout( UI_DOWN )", 0.25f, 0, UI_DOWN, T, T, 0, 0, M, M);

  909.     }

  910. }

  911. 

  912. void build_columndemo(UIcontext *uictx, int parent) {

  913.     uiSetBox(uictx, parent, UI_ROW);

  914. 

  915.     const int M = 10;

  916.     const int S = 200;

  917.     const int T = 100;

  918. 

  919.     {

  920.         int box = demorect(uictx, parent, "Box( UI_COLUMN )\nLayout( UI_TOP | UI_HFILL )", 0.6f, UI_COLUMN, UI_TOP|UI_HFILL, S, 0, M, M, M, M);

  921. 

  922.         demorect(uictx, box, "Layout( UI_LEFT )", 0.05f, 0, UI_LEFT, T, T, M, M, 0, M);

  923.         demorect(uictx, box, "Layout( UI_HCENTER )", 0.1f, 0, UI_HCENTER, T, T, 0, 0, 0, M);

  924.         demorect(uictx, box, "Layout( UI_HFILL )", 0.15f, 0, UI_HFILL, T, T, M, 0, M, M);

  925.         demorect(uictx, box, "Layout( UI_RIGHT )", 0.25f, 0, UI_RIGHT, T, T, 0, 0, M, M);

  926.     }

  927.     {

  928.         int box = demorect(uictx, parent, "Box( UI_COLUMN )\nLayout( UI_FILL )", 0.6f, UI_COLUMN, UI_FILL, S, 0, 0, M, M, M);

  929. 

  930.         demorect(uictx, box, "Layout( UI_LEFT )", 0.05f, 0, UI_LEFT, T, T, M, M, 0, M);

  931.         demorect(uictx, box, "Layout( UI_HCENTER )", 0.1f, 0, UI_HCENTER, T, T, 0, 0, 0, M);

  932.         demorect(uictx, box, "Layout( UI_HFILL )", 0.15f, 0, UI_HFILL, T, T, M, 0, M, M);

  933.         demorect(uictx, box, "Layout( UI_RIGHT )", 0.25f, 0, UI_RIGHT, T, T, 0, 0, M, M);

  934.     }

  935.     {

  936.         int box = demorect(uictx, parent, "Box( UI_COLUMN )\nLayout( UI_FILL )", 0.6f, UI_COLUMN, UI_FILL, S, 0, 0, M, M, M);

  937. 

  938.         demorect(uictx, box, "Layout( UI_LEFT )", 0.05f, 0, UI_LEFT, T, T, M, M, 0, M);

  939.         demorect(uictx, box, "Layout( UI_HCENTER )", 0.1f, 0, UI_HCENTER, T, T, 0, 0, 0, M);

  940.         demorect(uictx, box, "Layout( UI_HFILL )", 0.15f, 0, UI_HFILL, T, T, M, 0, M, M);

  941.         demorect(uictx, box, "Layout( UI_VFILL )", 0.2f, 0, UI_VFILL, T, T, 0, 0, 0, M);

  942.         demorect(uictx, box, "Layout( UI_VFILL )", 0.2f, 0, UI_VFILL, T, T, 0, 0, 0, M);

  943.         demorect(uictx, box, "Layout( UI_VFILL )", 0.2f, 0, UI_VFILL, T, T, 0, 0, 0, M);

  944.         demorect(uictx, box, "Layout( UI_RIGHT )", 0.25f, 0, UI_RIGHT, T, T, 0, 0, M, M);

  945.     }

  946. }

  947. 

  948. void fill_wrap_row_box(UIcontext *uictx, int box) {

  949.     const int M = 5;

  950.     const int T = 50;

  951.     int i;

  952. 

  953.     srand(303);

  954.     for (i = 0; i < 20; ++i) {

  955.         float hue = (float)(rand()%360)/360.0f;

  956.         int width = 10 + (rand()%5)*10;

  957. 

  958.         int u;

  959.         switch(rand()%4) {

  960.         default: break;

  961.         case 0: {

  962.             u = demorect(uictx, box, "Layout( UI_TOP )",

  963.                     hue, 0, UI_TOP, width, T, M, M, M, M);

  964.         } break;

  965.         case 1: {

  966.             u = demorect(uictx, box, "Layout( UI_VCENTER )",

  967.                     hue, 0, UI_VCENTER, width, T/2, M, M, M, M);

  968.         } break;

  969.         case 2: {

  970.             u = demorect(uictx, box, "Layout( UI_VFILL )",

  971.                     hue, 0, UI_VFILL, width, T, M, M, M, M);

  972.         } break;

  973.         case 3: {

  974.             u = demorect(uictx, box, "Layout( UI_DOWN )",

  975.                     hue, 0, UI_DOWN, width, T/2, M, M, M, M);

  976.         } break;

  977.         }

  978. 

  979.         if (rand()%10 == 0)

  980.             uiSetLayout(uictx, u, uiGetLayout(uictx, u)|UI_BREAK);

  981. 

  982.     }

  983. 

  984. }

  985. 

  986. void fill_wrap_column_box(UIcontext *uictx, int box) {

  987.     const int M = 5;

  988.     const int T = 50;

  989.     int i;

  990.     srand(303);

  991.     for (i = 0; i < 20; ++i) {

  992.         float hue = (float)(rand()%360)/360.0f;

  993.         int height = 10 + (rand()%5)*10;

  994. 

  995.         int u;

  996.         switch(rand()%4) {

  997.         default: break;

  998.         case 0: {

  999.             u = demorect(uictx, box, "Layout( UI_LEFT )",

  1000.                     hue, 0, UI_LEFT, T, height, M, M, M, M);

  1001.         } break;

  1002.         case 1: {

  1003.             u = demorect(uictx, box, "Layout( UI_HCENTER )",

  1004.                     hue, 0, UI_HCENTER, T/2, height, M, M, M, M);

  1005.         } break;

  1006.         case 2: {

  1007.             u = demorect(uictx, box, "Layout( UI_HFILL )",

  1008.                     hue, 0, UI_HFILL, T, height, M, M, M, M);

  1009.         } break;

  1010.         case 3: {

  1011.             u = demorect(uictx, box, "Layout( UI_RIGHT )",

  1012.                     hue, 0, UI_RIGHT, T/2, height, M, M, M, M);

  1013.         } break;

  1014.         }

  1015. 

  1016.         if (rand()%10 == 0)

  1017.             uiSetLayout(uictx, u, uiGetLayout(uictx, u)|UI_BREAK);

  1018.     }

  1019. 

  1020. }

  1021. 

  1022. void build_wrapdemo(UIcontext *uictx, int parent) {

  1023.     int col = uiItem(uictx);

  1024.     uiInsert(uictx, parent, col);

  1025.     uiSetBox(uictx, col, UI_COLUMN);

  1026.     uiSetLayout(uictx, col, UI_FILL);

  1027. 

  1028.     const int M = 5;

  1029. 

  1030.     int box;

  1031.     box = demorect(uictx, col, "Box( UI_ROW | UI_WRAP | UI_START )\nLayout( UI_HFILL | UI_TOP )",

  1032.             0.6f, UI_ROW | UI_WRAP | UI_START, UI_TOP, 0, 0, M, M, M, M);

  1033.     fill_wrap_row_box(uictx, box);

  1034. 

  1035.     box = demorect(uictx, col, "Box( UI_ROW | UI_WRAP | UI_MIDDLE )\nLayout( UI_HFILL | UI_TOP )",

  1036.             0.6f, UI_ROW | UI_WRAP, UI_HFILL | UI_TOP, 0, 0, M, M, M, M);

  1037.     fill_wrap_row_box(uictx, box);

  1038. 

  1039.     box = demorect(uictx, col, "Box( UI_ROW | UI_WRAP | UI_END )\nLayout( UI_HFILL | UI_TOP )",

  1040.             0.6f, UI_ROW | UI_WRAP | UI_END, UI_HFILL | UI_TOP, 0, 0, M, M, M, M);

  1041.     fill_wrap_row_box(uictx, box);

  1042. 

  1043.     box = demorect(uictx, col, "Box( UI_ROW | UI_WRAP | UI_JUSTIFY )\nLayout( UI_HFILL | UI_TOP )",

  1044.             0.6f, UI_ROW | UI_WRAP | UI_JUSTIFY, UI_HFILL | UI_TOP, 0, 0, M, M, M, M);

  1045.     fill_wrap_row_box(uictx, box);

  1046. 

  1047.     box = demorect(uictx, col, "Box( UI_COLUMN | UI_WRAP | UI_START )\nLayout( UI_LEFT | UI_VFILL )",

  1048.             0.6f, UI_COLUMN | UI_WRAP | UI_START, UI_LEFT | UI_VFILL, 0, 0, M, M, M, M);

  1049.     fill_wrap_column_box(uictx, box);

  1050. }

  1051. 

  1052. 

  1053. int add_menu_option(UIcontext *uictx, int parent, const char *name, int *choice) {

  1054.     int opt = radio(uictx, -1, name, choice);

  1055.     uiInsert(uictx, parent, opt);

  1056.     uiSetLayout(uictx, opt, UI_HFILL|UI_TOP);

  1057.     uiSetMargins(uictx, opt, 1, 1, 1, 1);

  1058.     return opt;

  1059. }

  1060. 

  1061. void draw(exContext *ec, float w, float h) {

  1062.     UIcontext *uictx = ec->uictx;

  1063.     NVGcontext *vg = ec->vg;

  1064.     bndBackground(vg, 0, 0, w, h);

  1065. 

  1066.     // some OUI stuff

  1067. 

  1068.     uiBeginLayout(uictx);

  1069. 

  1070.     int root = panel(uictx);

  1071.     // position root element

  1072.     uiSetSize(uictx, 0,w,h);

  1073.     ((UIData*)uiGetHandle(uictx, root))->handler = roothandler;

  1074.     uiSetEvents(uictx, root, UI_SCROLL|UI_BUTTON0_DOWN);

  1075.     uiSetBox(uictx, root, UI_COLUMN);

  1076. 

  1077.     static int choice = -1;

  1078. 

  1079.     int menu = uiItem(uictx);

  1080.     uiSetLayout(uictx, menu, UI_HFILL|UI_TOP);

  1081.     uiSetBox(uictx, menu, UI_ROW);

  1082.     uiInsert(uictx, root, menu);

  1083. 

  1084.     int opt_blendish_demo = add_menu_option(uictx, menu, "Blendish Demo", &choice);

  1085.     int opt_oui_demo = add_menu_option(uictx, menu, "OUI Demo", &choice);

  1086.     int opt_layouts = add_menu_option(uictx, menu, "UI_LAYOUT", &choice);

  1087.     int opt_row = add_menu_option(uictx, menu, "UI_ROW", &choice);

  1088.     int opt_column = add_menu_option(uictx, menu, "UI_COLUMN", &choice);

  1089.     int opt_wrap = add_menu_option(uictx, menu, "UI_WRAP", &choice);

  1090.     if (choice < 0)

  1091.         choice = opt_blendish_demo;

  1092. 

  1093.     int content = uiItem(uictx);

  1094.     uiSetLayout(uictx, content, UI_FILL);

  1095.     uiInsert(uictx, root, content);

  1096. 

  1097.     if (choice == opt_blendish_demo) {

  1098.         int democontent = uiItem(uictx);

  1099.         uiSetLayout(uictx, democontent, UI_FILL);

  1100.         uiInsert(uictx, content, democontent);

  1101. 

  1102.         UIData *data = (UIData *)uiAllocHandle(uictx, democontent, sizeof(UIData));

  1103.         data->handler = 0;

  1104.         data->subtype = ST_DEMOSTUFF;

  1105.     } else if (choice == opt_oui_demo) {

  1106.         int democontent = uiItem(uictx);

  1107.         uiSetLayout(uictx, democontent, UI_TOP);

  1108.         uiSetSize(uictx, democontent, 250, 0);

  1109.         uiInsert(uictx, content, democontent);

  1110. 

  1111.         build_democontent(uictx, democontent);

  1112.     } else if (choice == opt_layouts) {

  1113.         build_layoutdemo(uictx, content);

  1114.     } else if (choice == opt_row) {

  1115.         build_rowdemo(uictx, content);

  1116.     } else if (choice == opt_column) {

  1117.         build_columndemo(uictx, content);

  1118.     } else if (choice == opt_wrap) {

  1119.         build_wrapdemo(uictx, content);

  1120.     }

  1121. 

  1122.     uiEndLayout(uictx);

  1123. 

  1124.     drawUI(ec, 0, BND_CORNER_NONE);

  1125. 

  1126. #if 0

  1127.     for (int i = 0; i < uiGetLastItemCount(); ++i) {

  1128.         if (uiRecoverItem(i) == -1) {

  1129.             UIitem *pitem = uiLastItemPtr(i);

  1130.             nvgBeginPath(vg);

  1131.             nvgRect(vg,pitem->margins[0],pitem->margins[1],pitem->size[0],pitem->size[1]);

  1132.             nvgStrokeWidth(vg, 2);

  1133.             nvgStrokeColor(vg, nvgRGBAf(1.0f,0.0f,0.0f,0.5f));

  1134.             nvgStroke(vg);

  1135.         }

  1136.     }

  1137. #endif

  1138. 

  1139.     if (choice == opt_blendish_demo) {

  1140.         UIvec2 cursor = uiGetCursor(uictx);

  1141.         cursor.x -= w/2;

  1142.         cursor.y -= h/2;

  1143.         if (abs(cursor.x) > (w/3)) {

  1144.             bndJoinAreaOverlay(vg, 0, 0, w, h, 0, (cursor.x > 0));

  1145.         } else if (abs(cursor.y) > (h/3)) {

  1146.             bndJoinAreaOverlay(vg, 0, 0, w, h, 1, (cursor.y > 0));

  1147.         }

  1148.     }

  1149. 

  1150.     uiProcess(uictx, (int)(glfwGetTime()*1000.0));

  1151. }

  1152. 

  1153. ////////////////////////////////////////////////////////////////////////////////

  1154. 

  1155. void errorcb(int error, const char* desc)

  1156. {

  1157. 	printf("GLFW error %d: %s\n", error, desc);

  1158. }

  1159. 

  1160. static void mousebutton(GLFWwindow *window, int button, int action, int mods) {

  1161. 	exContext *ec;

  1162. 	switch(button) {

  1163. 	case 1: button = 2; break;

  1164. 	case 2: button = 1; break;

  1165. 	}

  1166.     ec = (exContext*)glfwGetWindowUserPointer(window);

  1167.     uiSetButton(ec->uictx, button, mods, (action == GLFW_PRESS));

  1168. }

  1169. 

  1170. static void cursorpos(GLFWwindow *window, double x, double y) {

  1171. 	exContext *ec = (exContext*)glfwGetWindowUserPointer(window);

  1172.     uiSetCursor(ec->uictx, (int)x,(int)y);

  1173. }

  1174. 

  1175. static void scrollevent(GLFWwindow *window, double x, double y) {

  1176. 	exContext *ec = (exContext*)glfwGetWindowUserPointer(window);

  1177.     uiSetScroll(ec->uictx, (int)x, (int)y);

  1178. }

  1179. 

  1180. static void charevent(GLFWwindow *window, unsigned int value) {

  1181.     exContext *ec = (exContext*)glfwGetWindowUserPointer(window);

  1182.     uiSetChar(ec->uictx, value);

  1183. }

  1184. 

  1185. static void key(GLFWwindow* window, int key, int scancode, int action, int mods)

  1186. {

  1187.     exContext *ec;

  1188. 	NVG_NOTUSED(scancode);

  1189. 	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)

  1190. 		glfwSetWindowShouldClose(window, GL_TRUE);

  1191.     ec = (exContext*)glfwGetWindowUserPointer(window);

  1192.     uiSetKey(ec->uictx, key, mods, action ? true : false);

  1193. }

  1194. 

  1195. int main()

  1196. {

  1197. 	GLFWwindow* window;

  1198.     exContext ec;

  1199.     memset(&ec, 0, sizeof(exContext));

  1200. 

  1201.     ec.uictx = uiCreateContext(4096, 1<<20);

  1202.     uiSetHandler(ec.uictx, ui_handler);

  1203. 

  1204. 	if (!glfwInit()) {

  1205. 		printf("Failed to init GLFW.");

  1206. 		return -1;

  1207. 	}

  1208. 

  1209. 	glfwSetErrorCallback(errorcb);

  1210. #ifndef _WIN32 // don't require this on win32, and works with more cards

  1211. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

  1212. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);

  1213. 	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

  1214. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  1215. #endif

  1216. 	glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1);

  1217. 

  1218. 	window = glfwCreateWindow(650, 650, "OUI Blendish Demo", NULL, NULL);

  1219. 	if (!window) {

  1220. 		glfwTerminate();

  1221. 		return -1;

  1222. 	}

  1223. 

  1224.     glfwSetWindowUserPointer(window, &ec);

  1225. 	glfwSetKeyCallback(window, key);

  1226.     glfwSetCharCallback(window, charevent);

  1227.     glfwSetCursorPosCallback(window, cursorpos);

  1228.     glfwSetMouseButtonCallback(window, mousebutton);

  1229.     glfwSetScrollCallback(window, scrollevent);

  1230. 

  1231. 	glfwMakeContextCurrent(window);

  1232. #ifdef NANOVG_GLEW

  1233. 	glewExperimental = GL_TRUE;

  1234. 	if(glewInit() != GLEW_OK) {

  1235. 		printf("Could not init glew.\n");

  1236. 		return -1;

  1237. 	}

  1238. 	// GLEW generates GL error because it calls glGetString(GL_EXTENSIONS), we'll consume it here.

  1239. 	glGetError();

  1240. #endif

  1241. 

  1242. 	//ec.vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES);

  1243. 	ec.vg = nvgCreateGL3(NVG_ANTIALIAS);

  1244. 	if (ec.vg == NULL) {

  1245. 		printf("Could not init nanovg.\n");

  1246. 		return -1;

  1247. 	}

  1248. 

  1249. 	init(ec.vg);

  1250. 

  1251.     printf("sizeof(UIitem)=%lu\n", sizeof(UIitem));

  1252. 

  1253. 	glfwSwapInterval(0);

  1254. 

  1255. 	glfwSetTime(0);

  1256. 

  1257. 	double c = 0.0;

  1258. 	int total = 0;

  1259. 

  1260. 	int peak_items = 0;

  1261. 	unsigned int peak_alloc = 0;

  1262. 

  1263. 	while (!glfwWindowShouldClose(window))

  1264. 	{

  1265. 		double mx, my;

  1266. 		int winWidth, winHeight;

  1267. 		int fbWidth, fbHeight;

  1268. 		float pxRatio;

  1269. 

  1270. 		glfwGetCursorPos(window, &mx, &my);

  1271. 		glfwGetWindowSize(window, &winWidth, &winHeight);

  1272. 		glfwGetFramebufferSize(window, &fbWidth, &fbHeight);

  1273. 		// Calculate pixel ration for hi-dpi devices.

  1274. 		pxRatio = (float)fbWidth / (float)winWidth;

  1275. 

  1276. 		// Update and render

  1277. 		glViewport(0, 0, fbWidth, fbHeight);

  1278. 		glClearColor(0,0,0,1);

  1279. 		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);

  1280. 

  1281.         double t = glfwGetTime();

  1282. 		nvgBeginFrame(ec.vg, winWidth, winHeight, pxRatio);

  1283. 

  1284.         draw(&ec, winWidth, winHeight);

  1285.         peak_items = (peak_items > uiGetItemCount(ec.uictx))?peak_items:uiGetItemCount(ec.uictx);

  1286.         peak_alloc = (peak_alloc > uiGetAllocSize(ec.uictx))?peak_alloc:uiGetAllocSize(ec.uictx);

  1287. 

  1288. 		nvgEndFrame(ec.vg);

  1289.         double t2 = glfwGetTime();

  1290.         c += (t2 - t);

  1291.         total++;

  1292.         if (total > (1*60)) {

  1293.             printf("%fms\n", (c / (double)total)*1000.0);

  1294.             total = 0;

  1295.             c = 0.0;

  1296.         }

  1297. 

  1298. 		glfwSwapBuffers(window);

  1299. 		glfwPollEvents();

  1300. 	}

  1301. 	printf("Peak item count: %i (%lu bytes)\nPeak allocated handles: %u bytes\n",

  1302. 	        peak_items, peak_items * sizeof(UIitem), peak_alloc);

  1303. 

  1304.     uiDestroyContext(ec.uictx);

  1305. 

  1306. 	nvgDeleteGL3(ec.vg);

  1307. 

  1308. 	glfwTerminate();

  1309. 	return 0;

  1310. }