commit f9975f3c0e1867bdca7a30882d5d112833c8622b Author: camh Date: Fri Sep 10 23:12:19 2021 -0700 first commit diff --git a/.codelite/.tern-project b/.codelite/.tern-project new file mode 100644 index 0000000..09b6465 --- /dev/null +++ b/.codelite/.tern-project @@ -0,0 +1,13 @@ +{ + "libs": ["browser", "ecma5", "ecma6"], + "plugins": { + "commonjs": { + }, + "modules": { + }, + "node_resolve": { + }, + "node": { + } + } +} \ No newline at end of file diff --git a/.codelite/Dialog-macdev.tags b/.codelite/Dialog-macdev.tags new file mode 100644 index 0000000..96a971f Binary files /dev/null and b/.codelite/Dialog-macdev.tags differ diff --git a/.codelite/Dialog.session b/.codelite/Dialog.session new file mode 100644 index 0000000..0e31174 --- /dev/null +++ b/.codelite/Dialog.session @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/.codelite/Dialog.tags b/.codelite/Dialog.tags new file mode 100644 index 0000000..6f2794a Binary files /dev/null and b/.codelite/Dialog.tags differ diff --git a/.codelite/Dialog.workspace.minh_danh b/.codelite/Dialog.workspace.minh_danh new file mode 100644 index 0000000..34d4191 --- /dev/null +++ b/.codelite/Dialog.workspace.minh_danh @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/.codelite/DialogSampleApp.session b/.codelite/DialogSampleApp.session new file mode 100644 index 0000000..14ee549 --- /dev/null +++ b/.codelite/DialogSampleApp.session @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/.codelite/DialogSampleApp.tags b/.codelite/DialogSampleApp.tags new file mode 100644 index 0000000..e1f80cd Binary files /dev/null and b/.codelite/DialogSampleApp.tags differ diff --git a/.codelite/HelloWorld-cameron_henlin.tags b/.codelite/HelloWorld-cameron_henlin.tags new file mode 100644 index 0000000..7970a43 Binary files /dev/null and b/.codelite/HelloWorld-cameron_henlin.tags differ diff --git a/.codelite/HelloWorld-macdev.tags b/.codelite/HelloWorld-macdev.tags new file mode 100644 index 0000000..ce25e85 Binary files /dev/null and b/.codelite/HelloWorld-macdev.tags differ diff --git a/.codelite/HelloWorld-macdev.tags-shm b/.codelite/HelloWorld-macdev.tags-shm new file mode 100644 index 0000000..dbfc882 Binary files /dev/null and b/.codelite/HelloWorld-macdev.tags-shm differ diff --git a/.codelite/HelloWorld-macdev.tags-wal b/.codelite/HelloWorld-macdev.tags-wal new file mode 100644 index 0000000..f4e291f Binary files /dev/null and b/.codelite/HelloWorld-macdev.tags-wal differ diff --git a/.codelite/HelloWorld.session b/.codelite/HelloWorld.session new file mode 100644 index 0000000..9451c88 --- /dev/null +++ b/.codelite/HelloWorld.session @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.codelite/HelloWorld.workspace.cameron_henlin b/.codelite/HelloWorld.workspace.cameron_henlin new file mode 100644 index 0000000..e4cab5a --- /dev/null +++ b/.codelite/HelloWorld.workspace.cameron_henlin @@ -0,0 +1,4 @@ + + + + diff --git a/.codelite/NuklearQuickDraw-cameron_henlin.tags b/.codelite/NuklearQuickDraw-cameron_henlin.tags new file mode 100644 index 0000000..e69de29 diff --git a/.codelite/NuklearQuickDraw-cameron_henlin.tags-shm b/.codelite/NuklearQuickDraw-cameron_henlin.tags-shm new file mode 100644 index 0000000..6bb49fb Binary files /dev/null and b/.codelite/NuklearQuickDraw-cameron_henlin.tags-shm differ diff --git a/.codelite/NuklearQuickDraw.session b/.codelite/NuklearQuickDraw.session new file mode 100644 index 0000000..4418fb5 --- /dev/null +++ b/.codelite/NuklearQuickDraw.session @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/.codelite/QuickDrawTest-cameron_henlin.tags b/.codelite/QuickDrawTest-cameron_henlin.tags new file mode 100644 index 0000000..0a069e9 Binary files /dev/null and b/.codelite/QuickDrawTest-cameron_henlin.tags differ diff --git a/.codelite/QuickDrawTest.session b/.codelite/QuickDrawTest.session new file mode 100644 index 0000000..f8ee52b --- /dev/null +++ b/.codelite/QuickDrawTest.session @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.codelite/Sys6DialogTestApp.session b/.codelite/Sys6DialogTestApp.session new file mode 100644 index 0000000..1dc12b7 --- /dev/null +++ b/.codelite/Sys6DialogTestApp.session @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/.codelite/Sys6DialogTestApp.tags b/.codelite/Sys6DialogTestApp.tags new file mode 100644 index 0000000..6c18cba Binary files /dev/null and b/.codelite/Sys6DialogTestApp.tags differ diff --git a/.codelite/Sys6Dialogapp.session b/.codelite/Sys6Dialogapp.session new file mode 100644 index 0000000..cbf9aa6 --- /dev/null +++ b/.codelite/Sys6Dialogapp.session @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/.codelite/Sys6Dialogapp.tags b/.codelite/Sys6Dialogapp.tags new file mode 100644 index 0000000..d789fd9 Binary files /dev/null and b/.codelite/Sys6Dialogapp.tags differ diff --git a/.codelite/compilation.db b/.codelite/compilation.db new file mode 100644 index 0000000..d4960d2 Binary files /dev/null and b/.codelite/compilation.db differ diff --git a/.codelite/compile_commands.json b/.codelite/compile_commands.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/.codelite/compile_commands.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/.codelite/cppcheck.list b/.codelite/cppcheck.list new file mode 100644 index 0000000..abd95a6 --- /dev/null +++ b/.codelite/cppcheck.list @@ -0,0 +1 @@ +/home/minhdanh/Documents/LinuxApps/Dialog/dialog.c diff --git a/.codelite/refactoring.db b/.codelite/refactoring.db new file mode 100644 index 0000000..2bc195c Binary files /dev/null and b/.codelite/refactoring.db differ diff --git a/.codelite/subversion.conf b/.codelite/subversion.conf new file mode 100644 index 0000000..5fdccfe --- /dev/null +++ b/.codelite/subversion.conf @@ -0,0 +1,5 @@ +{ + "svn-settings": { + "m_repoPath": "" + } +} \ No newline at end of file diff --git a/.codelite/valgrind.memcheck.supp b/.codelite/valgrind.memcheck.supp new file mode 100644 index 0000000..e69de29 diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..977110b --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,14 @@ +# HOW TO BUILD USING CMAKE as a standalone project: +# mkdir build +# cd build +# cmake .. -DCMAKE_TOOLCHAIN_FILE=path/to/Retro68-build/toolchain/cmake/retro68.toolchain.cmake +# make + +cmake_minimum_required(VERSION 2.8) + +add_application(NuklearQuickDraw + SerialHelper.c + coprocessorjs.c + Sample.c + Sample.r + ) diff --git a/JS/index.js b/JS/index.js new file mode 100644 index 0000000..1095009 --- /dev/null +++ b/JS/index.js @@ -0,0 +1,19 @@ + + +class PuppeteerTest { + + async getBodyAtURL (url) { + + let response + + try { + + } catch (error) { + + console.error(error) + } + + return response + } +} +module.exports = PuppeteerTest \ No newline at end of file diff --git a/JS/package.json b/JS/package.json new file mode 100644 index 0000000..287dc03 --- /dev/null +++ b/JS/package.json @@ -0,0 +1,13 @@ +{ + "name": "test", + "version": "1.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "" + }, + "author": "", + "license": "ISC", + "dependencies": { + } +} diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b41daa6 --- /dev/null +++ b/Makefile @@ -0,0 +1,54 @@ +# path to RETRO68 +RETRO68=../../../Retro68-build/toolchain + +PREFIX=$(RETRO68)/m68k-unknown-elf +CC=$(RETRO68)/bin/m68k-unknown-elf-gcc +CXX=$(RETRO68)/bin/m68k-unknown-elf-g++ +REZ=$(RETRO68)/bin/Rez + +LDFLAGS=-lRetroConsole +RINCLUDES=$(PREFIX)/RIncludes +REZFLAGS=-I$(RINCLUDES) + +# all resource file help is from https://github.com/clehner/Browsy/blob/master/Makefile +RSRC_HEX=$(wildcard rsrc/*/*.hex) +RSRC_TXT=$(wildcard rsrc/*/*.txt) +RSRC_JS=$(wildcard rsrc/*/*.js) +RSRC_JSON=$(wildcard rsrc/*/*.json) +RSRC_DAT=$(RSRC_HEX:.hex=.dat) $(RSRC_TXT:.txt=.dat) $(RSRC_JS:.js=.dat) $(RSRC_JSON:.json=.dat) + +NuklearQuickDraw.bin NuklearQuickDraw.APPL NuklearQuickDraw.dsk: NuklearQuickDraw.flt rsrc-args compile_js + $(REZ) $(REZFLAGS) \ + -DFLT_FILE_NAME="\"NuklearQuickDraw.flt\"" "$(RINCLUDES)/Retro68APPL.r" \ + -t "APPL" \ + -Ofast -o NuklearQuickDraw.bin --cc NuklearQuickDraw.APPL --cc NuklearQuickDraw.dsk -C WWW6 $(shell cat rsrc-args) + +NuklearQuickDraw.flt: hello.o + $(CXX) $< -o $@ $(LDFLAGS) # C++ used for linking because RetroConsole needs it + +.PHONY: clean +clean: + rm -f NuklearQuickDraw.bin NuklearQuickDraw.APPL NuklearQuickDraw.dsk NuklearQuickDraw.flt NuklearQuickDraw.flt.gdb hello.o rsrc/*/*.dat rsrc-args + +compile_js: + ./compile_js.sh + +rsrc: $(RSRC_DAT) rsrc-args + +rsrc/%.dat: rsrc/%.hex + $(QUIET_RSRC)$(FROM_HEX) $< > $@ + +rsrc/TEXT/%.dat: rsrc/TEXT/%.txt + $(QUIET_RSRC)tr '\n' '\r' < $< > $@ + +rsrc/JS/%.dat: rsrc/TEXT/%.txt + $(QUIET_RSRC)tr '\n' '\r' < $< > $@ + +rsrc-args: $(RSRC_DAT) + @cd rsrc && for code in $$(ls); do \ + echo -n "-t $$code "; \ + cd "$$code" && for file in *.dat; do \ + echo -n "-r $${file%.dat} rsrc/$$code/$$file "; \ + done; \ + cd ..; \ + done > ../$@ diff --git a/NuklearQuickDraw.project b/NuklearQuickDraw.project new file mode 100644 index 0000000..6aa4fe9 --- /dev/null +++ b/NuklearQuickDraw.project @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps/ + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + + + + + + + + + + + + + + + + + + + + + + + ./clean.sh + ./build.sh NuklearQuickDraw + + + + + /home/camh/Documents/Retro68kApps + + + + + + + + + + /home/camh/Documents/Retro68/Retro68/CIncludes/ +/home/camh/Documents/Retro68/Retro68/RIncludes/ + + + + diff --git a/NuklearQuickDraw.workspace b/NuklearQuickDraw.workspace new file mode 100644 index 0000000..5300396 --- /dev/null +++ b/NuklearQuickDraw.workspace @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..df56041 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# nuklear-quickdraw +very messy, not quite working yet: QuickDraw (Classic Macintosh) back end implementation for nuklear, along with a very hacked up sample C app made from previous example apps + +still wip diff --git a/Sample.c b/Sample.c new file mode 100644 index 0000000..a8093a6 --- /dev/null +++ b/Sample.c @@ -0,0 +1,939 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "Sample.h" +#include "SerialHelper.h" +#include "Quickdraw.h" +#include "output_js.h" +#include "coprocessorjs.h" + + +// needed by overview.c: +#include +#include +#include + +#define WINDOW_WIDTH 510 +#define WINDOW_HEIGHT 302 + +#define NK_ZERO_COMMAND_MEMORY +#define NK_INCLUDE_FIXED_TYPES +#define NK_INCLUDE_STANDARD_IO +#define NK_INCLUDE_STANDARD_VARARGS +#define NK_INCLUDE_DEFAULT_ALLOCATOR +#define NK_IMPLEMENTATION +#define NK_QUICKDRAW_IMPLEMENTATION +#define NK_MEMSET memset +#define NK_MEMCPY memcpy + +void aFailed(char *file, int line) { + + MoveTo(10, 10); + char *textoutput; + sprintf(textoutput, "%s:%d", file, line); + writeSerialPortDebug(boutRefNum, "assertion failure"); + writeSerialPortDebug(boutRefNum, textoutput); + // hold the program - we want to be able to read the text! assuming anything after the assert would be a crash + while (true) {} +} + +#define NK_ASSERT(e) \ + if (!(e)) \ + aFailed(__FILE__, __LINE__) +#include "nuklear.h" +#include "nuklear_quickdraw.h" +#include "overview.c" +/* GMac is used to hold the result of a SysEnvirons call. This makes + it convenient for any routine to check the environment. */ +SysEnvRec gMac; /* set up by Initialize */ + +/* GHasWaitNextEvent is set at startup, and tells whether the WaitNextEvent + trap is available. If it is false, we know that we must call GetNextEvent. */ +Boolean gHasWaitNextEvent; /* set up by Initialize */ + +/* GInBackground is maintained by our osEvent handling routines. Any part of + the program can check it to find out if it is currently in the background. */ +Boolean gInBackground; /* maintained by Initialize and DoEvent */ + +// #define MAC_APP_DEBUGGING +/* The following globals are the state of the window. If we supported more than + one window, they would be attatched to each document, rather than globals. */ + +/* Here are declarations for all of the C routines. In MPW 3.0 we can use + actual prototypes for parameter type checking. */ +void EventLoop( struct nk_context *ctx ); +void DoEvent( EventRecord *event, struct nk_context *ctx ); +void GetGlobalMouse( Point *mouse ); +void DoUpdate( WindowPtr window ); +void DoActivate( WindowPtr window, Boolean becomingActive ); +void DoContentClick( WindowPtr window ); +void AdjustMenus( void ); +void DoMenuCommand( long menuResult ); +Boolean DoCloseWindow( WindowPtr window ); +void Terminate( void ); +void Initialize( void ); +Boolean GoGetRect( short rectID, Rect *theRect ); +void ForceEnvirons( void ); +Boolean IsAppWindow( WindowPtr window ); +Boolean IsDAWindow( WindowPtr window ); +Boolean TrapAvailable( short tNumber, TrapType tType ); +void AlertUser( void ); + + +/* Define HiWrd and LoWrd macros for efficiency. */ +#define HiWrd(aLong) (((aLong) >> 16) & 0xFFFF) +#define LoWrd(aLong) ((aLong) & 0xFFFF) + +/* Define TopLeft and BotRight macros for convenience. Notice the implicit + dependency on the ordering of fields within a Rect */ +#define TopLeft(aRect) (* (Point *) &(aRect).top) +#define BotRight(aRect) (* (Point *) &(aRect).bottom) + +// TODO: +// set up coprocessor +// set up imessage service +// new typescript one that responds via graphql endpoints????? +// finish setting up UI (maybe mock data from coprocessor?) +// need UI to start new chat threads +// need function to create new chat + send message in it +// QUESTION should the chat UI be a scrollable panel with labels inside of it so both sides of the conversation can be shown? +// further improve ui performance -- it's close! eliminate more on keyboard events and we'll be fine + +char jsFunctionResponse[102400]; // Matches MAX_RECEIVE_SIZE + +// function to send messages in chat +void sendMessage(message) { + + char output[128]; + // sprintf(output, "D%d,%d", x, y); + + callFunctionOnCoprocessor("runEvent", output, jsFunctionResponse); +} + +// set up function to get messages in current chat +// limit to recent messages +// figure out pagination?? button on the top that says "get previous chats"? +void getMessages(thread, page) { + + char output[128]; + // sprintf(output, "D%d,%d", x, y); + + callFunctionOnCoprocessor("runEvent", output, jsFunctionResponse); +} + +// set up function to get available chat (fill buttons on right hand side) +// run it on some interval? make sure user is not typing!!! +void getChats(thread) { + + char output[128]; + // sprintf(output, "D%d,%d", x, y); + + callFunctionOnCoprocessor("runEvent", output, jsFunctionResponse); +} + +static void boxTest(struct nk_context *ctx) { + + if (nk_begin(ctx, "Chats", nk_rect(410, 0, 100, WINDOW_HEIGHT), NK_WINDOW_BORDER)) { + + nk_layout_row_dynamic(ctx, 25, 1); + if (nk_button_label(ctx, "chat 1")) { + + writeSerialPortDebug(boutRefNum, "CLICK!"); + } + nk_button_label(ctx, "chat 2"); + nk_button_label(ctx, "chat 3"); + nk_button_label(ctx, "chat 4"); + nk_button_label(ctx, "chat 5"); + nk_button_label(ctx, "chat 6"); + nk_button_label(ctx, "chat 7"); + nk_button_label(ctx, "chat 8"); + nk_button_label(ctx, "chat 9"); + nk_button_label(ctx, "chat 10"); + nk_button_label(ctx, "chat 11"); + nk_button_label(ctx, "chat 12"); + nk_button_label(ctx, "chat 13"); + nk_button_label(ctx, "chat 14"); + nk_button_label(ctx, "chat 15"); + nk_button_label(ctx, "chat 16"); + nk_button_label(ctx, "chat 17"); + nk_button_label(ctx, "chat 18"); + nk_button_label(ctx, "chat 19"); + nk_button_label(ctx, "chat 20"); + + nk_end(ctx); + } + + if (nk_begin(ctx, "Message", nk_rect(0, 0, 410, WINDOW_HEIGHT), NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR)) { + + static char box_buffer[512]; + static char box_input_buffer[512]; + static int box_len; + static int box_input_len; + int options = NK_WINDOW_BORDER | NK_WINDOW_NO_SCROLLBAR; + + // top part of the window + nk_layout_row_dynamic(ctx, 20, 1); + { + // chat label + nk_label(ctx, "chat name", NK_TEXT_ALIGN_CENTERED); + } + nk_layout_row_end(ctx); + + nk_layout_row_dynamic(ctx, 208, 1); + { + // chat contents + nk_edit_string(ctx, NK_EDIT_BOX, box_buffer, &box_len, 512, nk_filter_default); + } + nk_layout_row_end(ctx); + + // bottom text input + nk_layout_row_begin(ctx, NK_STATIC, 50, 2); + { + nk_layout_row_push(ctx, 300); // 40% wide + + nk_edit_string(ctx, NK_EDIT_BOX, box_input_buffer, &box_input_len, 512, nk_filter_default); + + nk_layout_row_push(ctx, 96); // 40% wide + if (nk_button_label(ctx, "send")) { + //fprintf(stdout, "pushed!\n"); + } + + nk_layout_row_end(ctx); + } + nk_layout_row_end(ctx); + + nk_end(ctx); + } + + +} + +#pragma segment Main +void main() +{ + Initialize(); /* initialize the program */ + + UnloadSeg((Ptr) Initialize); /* note that Initialize must not be in Main! */ + + setupCoprocessor("nuklear", "modem"); // could also be "printer", modem is 0 in PCE settings - printer would be 1 + + char programResult[MAX_RECEIVE_SIZE]; + sendProgramToCoprocessor(OUTPUT_JS, programResult); + + nk_quickdraw_init(WINDOW_WIDTH, WINDOW_HEIGHT); + + struct nk_context *ctx; + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "call nk_init"); + #endif + + ctx = nk_quickdraw_init(WINDOW_WIDTH, WINDOW_HEIGHT); + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "call into event loop"); + #endif + + EventLoop(ctx); /* call the main event loop */ +} + + +#pragma segment Main +void EventLoop(struct nk_context *ctx) +{ + RgnHandle cursorRgn; + Boolean gotEvent; + EventRecord event; + Point mouse; + cursorRgn = NewRgn(); + + Boolean firstOrMouseMove = true; + int lastMouseHPos = 0; + int lastMouseVPos = 0; + + do { + + Boolean beganInput = false; + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_begin"); + #endif + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_begin complete"); + #endif + + + GetGlobalMouse(&mouse); + + + // as far as i can tell, there is no way to event on mouse movement with mac libraries, + // so we are just going to track on our own, and create our own events. + // this seems kind of a bummer to not pass this to event handling code, but to make + // it work we would need to create a dummy event, etc, so we will just directly + // call the nk_input_motion command + if (lastMouseHPos != mouse.h || lastMouseVPos != mouse.v) { + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_motion!"); + #endif + + firstOrMouseMove = true; + + Point tempPoint; + SetPt(&tempPoint, mouse.h, mouse.v); + GlobalToLocal(&tempPoint); + + beganInput = true; + nk_input_begin(ctx); + nk_input_motion(ctx, tempPoint.h, tempPoint.v); + } + + lastMouseHPos = mouse.h; + lastMouseVPos = mouse.v; + + if (gHasWaitNextEvent) { + + gotEvent = WaitNextEvent(everyEvent, &event, MAXLONG, cursorRgn); + } else { + + SystemTask(); + gotEvent = GetNextEvent(everyEvent, &event); + } + + long start; + long end; + long total; + long eventTime0; + long eventTime1; + long eventTime2; + long eventTime3; + + start = TickCount(); + if (gotEvent) { + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "calling to DoEvent"); + #endif + + if (!beganInput) { + + nk_input_begin(ctx); + } + + beganInput = true; + + DoEvent(&event, ctx); + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "done with DoEvent"); + #endif + } + + end = TickCount(); + + total = end - start; + eventTime0 = total;// / 60.0; + start = TickCount(); + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_end"); + #endif + + if (beganInput) { + + nk_input_end(ctx); + } + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_end complete"); + #endif + + // only re-render if there is an event, prevents screen flickering + if (gotEvent || firstOrMouseMove) { + + firstOrMouseMove = false; + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_quickdraw_render"); + #endif + + + + start = TickCount(); + + //calculator(ctx); + //overview(ctx); + boxTest(ctx); + + + end = TickCount(); + + total = end - start; + eventTime1 = total;// / 60.0; + start = TickCount(); + nk_quickdraw_render(FrontWindow(), ctx); + end = TickCount(); + + total = end - start; + eventTime2 = total;// / 60.0; + start = TickCount(); + nk_clear(ctx); + end = TickCount(); + + total = end - start; + eventTime3 = total;// / 60.0; + start = TickCount(); + + // char logx[255]; + // sprintf(logx, "EventLoop() eventTime0 (handle event) %ld, eventTime1 (nuklear UI) %ld, eventTime2 (render function) %ld, eventTime3 (clear) %ld ticks to execute\n", eventTime0, eventTime1, eventTime2, eventTime3); + // writeSerialPortDebug(boutRefNum, logx); + } + + + #ifdef MAC_APP_DEBUGGING + + writeSerialPortDebug(boutRefNum, "nk_input_render complete"); + #endif + } while ( true ); /* loop forever; we quit via ExitToShell */ +} /*EventLoop*/ + + +/* Do the right thing for an event. Determine what kind of event it is, and call + the appropriate routines. */ + +#pragma segment Main +void DoEvent(EventRecord *event, struct nk_context *ctx) { + + short part; + short err; + WindowPtr window; + Boolean hit; + char key; + Point aPoint; + + switch ( event->what ) { + + case mouseUp: + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "mouseup"); + #endif + + part = FindWindow(event->where, &window); + switch (part) + { + case inContent: + nk_quickdraw_handle_event(event, ctx); + break; + default: + break; + } + break; + case mouseDown: + + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "mousedown"); + #endif + + part = FindWindow(event->where, &window); + switch ( part ) { + case inMenuBar: /* process a mouse menu command (if any) */ + AdjustMenus(); + DoMenuCommand(MenuSelect(event->where)); + break; + case inSysWindow: /* let the system handle the mouseDown */ + SystemClick(event, window); + break; + case inContent: + if ( window != FrontWindow() ) { + SelectWindow(window); + + } + nk_quickdraw_handle_event(event, ctx); + break; + case inDrag: /* pass screenBits.bounds to get all gDevices */ + DragWindow(window, event->where, &qd.screenBits.bounds); + break; + case inGrow: + break; + case inZoomIn: + case inZoomOut: + hit = TrackBox(window, event->where, part); + if ( hit ) { + SetPort(window); /* the window must be the current port... */ + EraseRect(&window->portRect); /* because of a bug in ZoomWindow */ + ZoomWindow(window, part, true); /* note that we invalidate and erase... */ + InvalRect(&window->portRect); /* to make things look better on-screen */ + } + break; + } + break; + case keyDown: + case autoKey: /* check for menukey equivalents */ + + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "key"); + #endif + + key = event->message & charCodeMask; + if ( event->modifiers & cmdKey ) { /* Command key down */ + if ( event->what == keyDown ) { + AdjustMenus(); /* enable/disable/check menu items properly */ + DoMenuCommand(MenuKey(key)); + } + } + + nk_quickdraw_handle_event(event, ctx); + break; + case activateEvt: + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "activate"); + #endif + DoActivate((WindowPtr) event->message, (event->modifiers & activeFlag) != 0); + break; + case updateEvt: + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "update"); + #endif + DoUpdate((WindowPtr) event->message); + break; + /* 1.01 - It is not a bad idea to at least call DIBadMount in response + to a diskEvt, so that the user can format a floppy. */ + case diskEvt: + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "disk"); + #endif + if ( HiWord(event->message) != noErr ) { + SetPt(&aPoint, kDILeft, kDITop); + err = DIBadMount(aPoint, event->message); + } + break; + + case osEvt: + + #ifdef MAC_APP_DEBUGGING + writeSerialPortDebug(boutRefNum, "os"); + #endif + + // this should be trigger on mousemove but does not -- if we can figure that out, we should call through to + // nk_quickdraw_handle_event, and allow it to handle the mousemove events + /* 1.02 - must BitAND with 0x0FF to get only low byte */ + switch ((event->message >> 24) & 0x0FF) { /* high byte of message */ + case kSuspendResumeMessage: /* suspend/resume is also an activate/deactivate */ + gInBackground = (event->message & kResumeMask) == 0; + DoActivate(FrontWindow(), !gInBackground); + break; + } + break; + } +} /*DoEvent*/ + +/* Get the global coordinates of the mouse. When you call OSEventAvail + + it will return either a pending event or a null event. In either case, + the where field of the event record will contain the current position + of the mouse in global coordinates and the modifiers field will reflect + the current state of the modifiers. Another way to get the global + coordinates is to call GetMouse and LocalToGlobal, but that requires + being sure that thePort is set to a valid port. */ + +#pragma segment Main +void GetGlobalMouse(mouse) + Point *mouse; +{ + EventRecord event; + + OSEventAvail(kNoEvents, &event); /* we aren't interested in any events */ + *mouse = event.where; /* just the mouse position */ +} /*GetGlobalMouse*/ + + +/* This is called when an update event is received for a window. + It calls DrawWindow to draw the contents of an application window. + As an effeciency measure that does not have to be followed, it + calls the drawing routine only if the visRgn is non-empty. This + will handle situations where calculations for drawing or drawing + itself is very time-consuming. */ + +#pragma segment Main +void DoUpdate(window) + WindowPtr window; +{ + if ( IsAppWindow(window) ) { + BeginUpdate(window); + EndUpdate(window); + } +} /*DoUpdate*/ + + +/* This is called when a window is activated or deactivated. + In Sample, the Window Manager's handling of activate and + deactivate events is sufficient. Other applications may have + TextEdit records, controls, lists, etc., to activate/deactivate. */ + +#pragma segment Main +void DoActivate(window, becomingActive) + WindowPtr window; + Boolean becomingActive; +{ + if ( IsAppWindow(window) ) { + if ( becomingActive ) + /* do whatever you need to at activation */ ; + else + /* do whatever you need to at deactivation */ ; + } +} /*DoActivate*/ + + + +/* Draw the contents of the application window. We do some drawing in color, using + Classic QuickDraw's color capabilities. This will be black and white on old + machines, but color on color machines. At this point, the windowÕs visRgn + is set to allow drawing only where it needs to be done. */ + +static Rect okayButtonBounds; + + +/* Enable and disable menus based on the current state. + The user can only select enabled menu items. We set up all the menu items + before calling MenuSelect or MenuKey, since these are the only times that + a menu item can be selected. Note that MenuSelect is also the only time + the user will see menu items. This approach to deciding what enable/ + disable state a menu item has the advantage of concentrating all + the decision-making in one routine, as opposed to being spread throughout + the application. Other application designs may take a different approach + that is just as valid. */ + +#pragma segment Main +void AdjustMenus() +{ + WindowPtr window; + MenuHandle menu; + + window = FrontWindow(); + + menu = GetMenuHandle(mFile); + if ( IsDAWindow(window) ) /* we can allow desk accessories to be closed from the menu */ + EnableItem(menu, iClose); + else + DisableItem(menu, iClose); /* but not our traffic light window */ + + menu = GetMenuHandle(mEdit); + if ( IsDAWindow(window) ) { /* a desk accessory might need the edit menuÉ */ + EnableItem(menu, iUndo); + EnableItem(menu, iCut); + EnableItem(menu, iCopy); + EnableItem(menu, iClear); + EnableItem(menu, iPaste); + } else { /* Ébut we donÕt use it */ + DisableItem(menu, iUndo); + DisableItem(menu, iCut); + DisableItem(menu, iCopy); + DisableItem(menu, iClear); + DisableItem(menu, iPaste); + } + + menu = GetMenuHandle(mLight); + if ( IsAppWindow(window) ) { /* we know that it must be the traffic light */ + EnableItem(menu, iStop); + EnableItem(menu, iGo); + } else { + DisableItem(menu, iStop); + DisableItem(menu, iGo); + } +} /*AdjustMenus*/ + + +/* This is called when an item is chosen from the menu bar (after calling + MenuSelect or MenuKey). It performs the right operation for each command. + It is good to have both the result of MenuSelect and MenuKey go to + one routine like this to keep everything organized. */ + +#pragma segment Main +void DoMenuCommand(menuResult) + long menuResult; +{ + short menuID; /* the resource ID of the selected menu */ + short menuItem; /* the item number of the selected menu */ + short itemHit; + Str255 daName; + short daRefNum; + Boolean handledByDA; + + menuID = HiWord(menuResult); /* use macros for efficiency to... */ + menuItem = LoWord(menuResult); /* get menu item number and menu number */ + switch ( menuID ) { + case mApple: + switch ( menuItem ) { + // case iAbout: /* bring up alert for About */ + default: + itemHit = Alert(rAboutAlert, nil); + break; + + /* + default: // all non-About items in this menu are DAs + // type Str255 is an array in MPW 3 + GetItem(GetMHandle(mApple), menuItem, daName); + daRefNum = OpenDeskAcc(daName); + break; + */ + } + break; + case mFile: + switch ( menuItem ) { + case iClose: + DoCloseWindow(FrontWindow()); + break; + case iQuit: + Terminate(); + break; + } + break; + case mEdit: /* call SystemEdit for DA editing & MultiFinder */ + handledByDA = SystemEdit(menuItem-1); /* since we donÕt do any Editing */ + break; + case mLight: + switch ( menuItem ) { + case iStop: + break; + case iGo: + break; + } + break; + + case mHelp: + switch ( menuItem ) { + case iQuickHelp: + itemHit = Alert(rAboutAlert, nil); + break; + case iUserGuide: + { + // AlertUser(); + + // write data to serial port + // Configure PCE/macplus to map serial port to ser_b.out. This port can then be used for debug output + // by using: tail -f ser_b.out + // OSErr res = writeSerialPortDebug(boutRefNum, "Hello World"); + // if (res < 0) + // AlertUser(); + + // http://www.mac.linux-m68k.org/devel/macalmanac.php + short* ROM85 = (short*) 0x028E; + short* SysVersion = (short*) 0x015A; + short* ScrVRes = (short*) 0x0102; + short* ScrHRes = (short*) 0x0104; + unsigned long* Time = (unsigned long*) 0x020C; + + char str2[255]; + sprintf(str2, "ROM85: %d - SysVersion: %d - VRes: %d - HRes: %d - Time: %lu", *ROM85, *SysVersion, *ScrVRes, *ScrHRes, *Time); + // writeSerialPortDebug(boutRefNum, str2); + + Boolean is128KROM = ((*ROM85) > 0); + Boolean hasSysEnvirons = false; + Boolean hasStripAddr = false; + Boolean hasSetDefaultStartup = false; + if (is128KROM) + { + UniversalProcPtr trapSysEnv = GetOSTrapAddress(_SysEnvirons); + UniversalProcPtr trapStripAddr = GetOSTrapAddress(_StripAddress); + UniversalProcPtr trapSetDefaultStartup = GetOSTrapAddress(_SetDefaultStartup); + UniversalProcPtr trapUnimpl = GetOSTrapAddress(_Unimplemented); + + hasSysEnvirons = (trapSysEnv != trapUnimpl); + hasStripAddr = (trapStripAddr != trapUnimpl); + hasSetDefaultStartup = (trapSetDefaultStartup != trapUnimpl); + } + + sprintf(str2, "is128KROM: %d - hasSysEnvirons: %d - hasStripAddr: %d - hasSetDefaultStartup - %d", + is128KROM, hasSysEnvirons, hasStripAddr, hasSetDefaultStartup); + // writeSerialPortDebug(boutRefNum, str2); + + break; + } + } + break; + } + HiliteMenu(0); /* unhighlight what MenuSelect (or MenuKey) hilited */ +} /*DoMenuCommand*/ + +/* Close a window. This handles desk accessory and application windows. */ + +/* 1.01 - At this point, if there was a document associated with a + window, you could do any document saving processing if it is 'dirty'. + DoCloseWindow would return true if the window actually closed, i.e., + the user didnÕt cancel from a save dialog. This result is handy when + the user quits an application, but then cancels the save of a document + associated with a window. */ + +#pragma segment Main +Boolean DoCloseWindow(window) + WindowPtr window; +{ + /* if ( IsDAWindow(window) ) + CloseDeskAcc(((WindowPeek) window)->windowKind); + else */ if ( IsAppWindow(window) ) + CloseWindow(window); + return true; +} /*DoCloseWindow*/ + + +/* Clean up the application and exit. We close all of the windows so that + they can update their documents, if any. */ + +/* 1.01 - If we find out that a cancel has occurred, we won't exit to the + shell, but will return instead. */ + +#pragma segment Main +void Terminate() +{ + WindowPtr aWindow; + Boolean closed; + + closed = true; + do { + aWindow = FrontWindow(); /* get the current front window */ + if (aWindow != nil) + closed = DoCloseWindow(aWindow); /* close this window */ + } + while (closed && (aWindow != nil)); + if (closed) + ExitToShell(); /* exit if no cancellation */ +} /*Terminate*/ + + +#pragma segment Initialize +void Initialize() +{ + Handle menuBar; + WindowPtr window; + long total, contig; + EventRecord event; + short count; + + gInBackground = false; + + InitGraf((Ptr) &qd.thePort); + InitFonts(); + InitWindows(); + InitMenus(); + TEInit(); + InitDialogs(nil); + InitCursor(); + + for (count = 1; count <= 3; count++) { + EventAvail(everyEvent, &event); + } + + window = (WindowPtr) NewPtr(sizeof(WindowRecord)); + + if ( window == nil ) { + AlertUser(); + } + + window = GetNewWindow(rWindow, (Ptr) window, (WindowPtr) -1); + SetPort(window); + + menuBar = GetNewMBar(rMenuBar); /* read menus into menu bar */ + + if ( menuBar == nil ) { + + AlertUser(); + } + + SetMenuBar(menuBar); /* install menus */ + DisposeHandle(menuBar); + AppendResMenu(GetMenuHandle(mApple), 'DRVR'); /* add DA names to Apple menu */ + DrawMenuBar(); + +} /*Initialize*/ + + +#pragma segment Main +Boolean IsAppWindow(window) + WindowPtr window; +{ + short windowKind; + + if ( window == nil ) { + return false; + } /* application windows have windowKinds = userKind (8) */ + + windowKind = ((WindowPeek) window)->windowKind; + + return (windowKind = userKind); +} /*IsAppWindow*/ + + +/* Check to see if a window belongs to a desk accessory. */ + +#pragma segment Main +Boolean IsDAWindow(window) + WindowPtr window; +{ + if ( window == nil ) { + return false; + } + /* DA windows have negative windowKinds */ + return ((WindowPeek) window)->windowKind < 0; +} /*IsDAWindow*/ + + +#pragma segment Initialize +Boolean TrapAvailable(tNumber,tType) + short tNumber; + TrapType tType; +{ + if ( ( tType == ToolTrap ) && + ( gMac.machineType > envMachUnknown ) && + ( gMac.machineType < envMacII ) ) { /* it's a 512KE, Plus, or SE */ + tNumber = tNumber & 0x03FF; + if ( tNumber > 0x01FF ) { /* which means the tool traps */ + tNumber = _Unimplemented; /* only go to 0x01FF */ + } + } + + return NGetTrapAddress(tNumber, tType) != GetTrapAddress(_Unimplemented); +} /*TrapAvailable*/ + + +#pragma segment Main +void AlertUser() { + short itemHit; + + SetCursor(&qd.arrow); + itemHit = Alert(rUserAlert, nil); + ExitToShell(); +} /* AlertUser */ \ No newline at end of file diff --git a/Sample.h b/Sample.h new file mode 100644 index 0000000..df9137a --- /dev/null +++ b/Sample.h @@ -0,0 +1 @@ +/*------------------------------------------------------------------------------ # # Apple Macintosh Developer Technical Support # # MultiFinder-Aware Simple Sample Application # # Sample # # Sample.h - Rez and C Include Source # # Copyright © 1989 Apple Computer, Inc. # All rights reserved. # # Versions: # 1.00 08/88 # 1.01 11/88 # 1.02 04/89 MPW 3.1 # # Components: # Sample.p April 1, 1989 # Sample.c April 1, 1989 # Sample.a April 1, 1989 # Sample.inc1.a April 1, 1989 # SampleMisc.a April 1, 1989 # Sample.r April 1, 1989 # Sample.h April 1, 1989 # [P]Sample.make April 1, 1989 # [C]Sample.make April 1, 1989 # [A]Sample.make April 1, 1989 # # Sample is an example application that demonstrates how to # initialize the commonly used toolbox managers, operate # successfully under MultiFinder, handle desk accessories, # and create, grow, and zoom windows. # # It does not by any means demonstrate all the techniques # you need for a large application. In particular, Sample # does not cover exception handling, multiple windows/documents, # sophisticated memory management, printing, or undo. All of # these are vital parts of a normal full-sized application. # # This application is an example of the form of a Macintosh # application; it is NOT a template. It is NOT intended to be # used as a foundation for the next world-class, best-selling, # 600K application. A stick figure drawing of the human body may # be a good example of the form for a painting, but that does not # mean it should be used as the basis for the next Mona Lisa. # # We recommend that you review this program or TESample before # beginning a new application. ------------------------------------------------------------------------------*/ /* These #defines correspond to values defined in the Pascal source code. Sample.c and Sample.r include this file. */ /* Determining an application's minimum size to request from MultiFinder depends on many things, each of which can be unique to an application's function, the anticipated environment, the developer's attitude of what constitutes reasonable functionality and performance, etc. Here is a list of some things to consider when determining the minimum size (and preferred size) for your application. The list is pretty much in order of importance, but by no means complete. 1. What is the minimum size needed to give almost 100 percent assurance that the application won't crash because it ran out of memory? This includes not only things that you do have direct control over such as checking for NIL handles and pointers, but also things that some feel are not so much under their control such as QuickDraw and the Segment Loader. 2. What kind of performance can a user expect from the application when it is running in the minimum memory configuration? Performance includes not only speed in handling data, but also things like how many documents can be opened, etc. 3. What are the typical sizes of scraps [is a boy dog] that a user might wish to work with when lauching or switching to your application? If the amount of memory is too small, the scrap may get lost [will have to be shot]. This can be quite frustrating to the user. 4. The previous items have concentrated on topics that tend to cause an increase in the minimum size to request from MultiFinder. On the flip side, however, should be the consideration of what environments the application may be running in. There may be a high probability that many users with relatively small memory configurations will want to avail themselves of your application. Or, many users might want to use it while several other, possibly related/complementary applications are running. If that is the case, it would be helpful to have a fairly small minimum size. So, what did we decide on Sample? First, Sample has little risk of running out of memory once it starts. Second, performance isn't much of an issue since it doesn't do much and multiple windows are not allowed. Third, there are no edit operations in Sample itself, so we just want to provide enough space for a reasonable scrap to survive between desk accessory launches. Lastly, Sample should intrude as little as possible, so the effort should be towards making it as small as possible. We looked at some heap dumps while the application was running under various partition sizes. With a size of 23K, there was approximately 8-9K free, which is a good 'slop' factor in an application like this which doesn't do much, but where we'd still like the scrap to survive most of the time. */ #define MAXLONG 2147483648 #define kMinSize 88 /* application's minimum size (in K) */ /* We made the preferred size bigger than the minimum size by 12K, so that there would be even more room for the scrap, FKEYs, etc. */ #define kPrefSize 100 /* application's preferred size (in K) */ #define rMenuBar 128 /* application's menu bar */ #define rAboutAlert 128 /* about alert */ #define rUserAlert 129 /* error user alert */ #define rWindow 128 /* application's window */ #define rStopRect 128 /* rectangle for Stop light */ #define rGoRect 130 /* rectangle for Go light */ #define rXRect 129 /* rectangle for X light */ /* kSysEnvironsVersion is passed to SysEnvirons to tell it which version of the SysEnvRec we understand. */ #define kSysEnvironsVersion 1 /* kOSEvent is the event number of the suspend/resume and mouse-moved events sent by MultiFinder. Once we determine that an event is an osEvent, we look at the high byte of the message sent to determine which kind it is. To differentiate suspend and resume events we check the resumeMask bit. */ #define kOSEvent app4Evt /* event used by MultiFinder */ #define kSuspendResumeMessage 1 /* high byte of suspend/resume event message */ #define kResumeMask 1 /* bit of message field for resume vs. suspend */ #define kMouseMovedMessage 0xFA /* high byte of mouse-moved event message */ #define kNoEvents 0 /* no events mask */ /* The following constants are used to identify menus and their items. The menu IDs have an "m" prefix and the item numbers within each menu have an "i" prefix. */ #define mApple 128 /* Apple menu */ #define iAbout 1 #define mFile 129 /* File menu */ #define iNew 1 #define iClose 4 #define iQuit 12 #define mEdit 130 /* Edit menu */ #define iUndo 1 #define iCut 3 #define iCopy 4 #define iPaste 5 #define iClear 6 #define mLight 131 /* Light menu */ #define mHelp 132 /* Light menu */ #define iQuickHelp 1 #define iUserGuide 2 #define iStop 1 #define iGo 2 /* 1.01 - kTopLeft - This is for positioning the Disk Initialization dialogs. */ #define kDITop 0x0050 #define kDILeft 0x0070 /* 1.01 - kMinHeap - This is the minimum result from the following equation: ORD(GetApplLimit) - ORD(ApplicZone) for the application to run. It will insure that enough memory will be around for reasonable-sized scraps, FKEYs, etc. to exist with the application, and still give the application some 'breathing room'. To derive this number, we ran under a MultiFinder partition that was our requested minimum size, as given in the 'SIZE' resource. */ #define kMinHeap 21 * 1024 /* 1.01 - kMinSpace - This is the minimum result from PurgeSpace, when called at initialization time, for the application to run. This number acts as a double-check to insure that there really is enough memory for the application to run, including what has been taken up already by pre-loaded resources, the scrap, code, and other sundry memory blocks. */ #define kMinSpace 8 * 1024 /* kExtremeNeg and kExtremePos are used to set up wide open rectangles and regions. */ #define kExtremeNeg -32768 #define kExtremePos 32767 - 1 /* required to address an old region bug */ /* these #defines are used to set enable/disable flags of a menu */ #define AllItems 0b1111111111111111111111111111111 /* 31 flags */ #define NoItems 0b0000000000000000000000000000000 #define MenuItem1 0b0000000000000000000000000000001 #define MenuItem2 0b0000000000000000000000000000010 #define MenuItem3 0b0000000000000000000000000000100 #define MenuItem4 0b0000000000000000000000000001000 #define MenuItem5 0b0000000000000000000000000010000 #define MenuItem6 0b0000000000000000000000000100000 #define MenuItem7 0b0000000000000000000000001000000 #define MenuItem8 0b0000000000000000000000010000000 #define MenuItem9 0b0000000000000000000000100000000 #define MenuItem10 0b0000000000000000000001000000000 #define MenuItem11 0b0000000000000000000010000000000 #define MenuItem12 0b0000000000000000000100000000000 \ No newline at end of file diff --git a/Sample.r b/Sample.r new file mode 100644 index 0000000..a3232b7 --- /dev/null +++ b/Sample.r @@ -0,0 +1 @@ +/* # # Apple Macintosh Developer Technical Support # # MultiFinder-Aware Simple Sample Application # # Sample # # Sample.r - Rez Source # # Copyright © 1989 Apple Computer, Inc. # All rights reserved. # # Versions: # 1.00 08/88 # 1.01 11/88 # 1.02 04/89 MPW 3.1 # # Components: # Sample.p April 1, 1989 # Sample.c April 1, 1989 # Sample.a April 1, 1989 # Sample.inc1.a April 1, 1989 # SampleMisc.a April 1, 1989 # Sample.r April 1, 1989 # Sample.h April 1, 1989 # [P]Sample.make April 1, 1989 # [C]Sample.make April 1, 1989 # [A]Sample.make April 1, 1989 # # Sample is an example application that demonstrates how to # initialize the commonly used toolbox managers, operate # successfully under MultiFinder, handle desk accessories, # and create, grow, and zoom windows. # # It does not by any means demonstrate all the techniques # you need for a large application. In particular, Sample # does not cover exception handling, multiple windows/documents, # sophisticated memory management, printing, or undo. All of # these are vital parts of a normal full-sized application. # # This application is an example of the form of a Macintosh # application; it is NOT a template. It is NOT intended to be # used as a foundation for the next world-class, best-selling, # 600K application. A stick figure drawing of the human body may # be a good example of the form for a painting, but that does not # mean it should be used as the basis for the next Mona Lisa. # # We recommend that you review this program or TESample before # beginning a new application. */ #include "Types.r" #include "Sample.h" /* this is a definition for a resource which contains only a rectangle */ type 'RECT' { rect; }; /* we use an MBAR resource to conveniently load all the menus */ resource 'MBAR' (rMenuBar, preload) { { mApple, mFile, mEdit, mLight, mHelp }; /* five menus */ }; resource 'MENU' (mApple, preload) { mApple, textMenuProc, AllItems & ~MenuItem2, /* Disable dashed line, enable About and DAs */ enabled, apple, { "About Sample", noicon, nokey, nomark, plain; "-", noicon, nokey, nomark, plain } }; resource 'MENU' (mFile, preload) { mFile, textMenuProc, MenuItem12, /* enable Quit only, program enables others */ enabled, "File", { "New", noicon, "N", nomark, plain; "Open", noicon, "O", nomark, plain; "-", noicon, nokey, nomark, plain; "Close", noicon, "W", nomark, plain; "Save", noicon, "S", nomark, plain; "Save As", noicon, nokey, nomark, plain; "Revert", noicon, nokey, nomark, plain; "-", noicon, nokey, nomark, plain; "Page Setup", noicon, nokey, nomark, plain; "Print", noicon, nokey, nomark, plain; "-", noicon, nokey, nomark, plain; "Quit", noicon, "Q", nomark, plain } }; resource 'MENU' (mEdit, preload) { mEdit, textMenuProc, NoItems, /* disable everything, program does the enabling */ enabled, "Edit", { "Undo", noicon, "Z", nomark, plain; "-", noicon, nokey, nomark, plain; "Cut", noicon, "X", nomark, plain; "Copy", noicon, "C", nomark, plain; "Paste", noicon, "V", nomark, plain; "Clear", noicon, nokey, nomark, plain } }; resource 'MENU' (mLight, preload) { mLight, textMenuProc, NoItems, /* disable everything, program does the enabling */ enabled, "Traffic", { "Red Light", noicon, nokey, nomark, plain; "Green Light", noicon, nokey, nomark, plain } }; resource 'MENU' (mHelp, preload) { mHelp, textMenuProc, AllItems, /* disable everything, program does the enabling */ enabled, "Help", { "Quick Help", noicon, nokey, nomark, plain; "User Guide", noicon, nokey, nomark, plain; "Test Entry", noicon, nokey, nomark, plain; "Test Entry 2", noicon, nokey, nomark, plain; "Test Entry 3", noicon, nokey, nomark, plain; } }; /* this ALRT and DITL are used as an About screen */ resource 'ALRT' (rAboutAlert, purgeable) { {40, 20, 160, 290}, rAboutAlert, { /* array: 4 elements */ /* [1] */ OK, visible, silent, /* [2] */ OK, visible, silent, /* [3] */ OK, visible, silent, /* [4] */ OK, visible, silent }, centerMainScreen // Where to show the alert }; resource 'DITL' (rAboutAlert, purgeable) { { /* array DITLarray: 5 elements */ /* [1] */ {88, 180, 108, 260}, Button { enabled, "OK" }, /* [2] */ {8, 8, 24, 214}, StaticText { disabled, "Messages for Macintosh" }, /* [3] */ {32, 8, 48, 237}, StaticText { disabled, "Copyright © 2021 Cameron Henlin" }, /* [4] */ {56, 8, 72, 136}, StaticText { disabled, "cam.henlin@gmail.com" }, /* [5] */ {80, 24, 112, 167}, StaticText { disabled, "https://github.com/CamHenlin/MessagesForMacintosh" } } }; /* this ALRT and DITL are used as an error screen */ resource 'ALRT' (rUserAlert, purgeable) { {40, 20, 120, 260}, rUserAlert, { /* array: 4 elements */ /* [1] */ OK, visible, silent, /* [2] */ OK, visible, silent, /* [3] */ OK, visible, silent, /* [4] */ OK, visible, silent }, centerMainScreen // Where to show the alert }; resource 'DITL' (rUserAlert, purgeable) { { /* array DITLarray: 3 elements */ /* [1] */ {50, 150, 70, 230}, Button { enabled, "OK" }, /* [2] */ {10, 60, 30, 230}, StaticText { disabled, "Sample - Error occurred!" }, /* [3] */ {8, 8, 40, 40}, Icon { disabled, 2 } } }; resource 'WIND' (rWindow, preload, purgeable) { {39, 1, 341, 511}, zoomDocProc, visible, noGoAway, 0x0, "Messages", centerMainScreen // Where to show the alert }; resource 'RECT' (rStopRect, preload, purgeable) { {69, 69, 110, 110} }; resource 'RECT' (rXRect, preload, purgeable) { {32, 32, 69, 69} }; resource 'RECT' (rGoRect, preload, purgeable) { {120, 10, 220, 110} }; /* here is the quintessential MultiFinder friendliness device, the SIZE resource */ resource 'SIZE' (-1) { dontSaveScreen, acceptSuspendResumeEvents, enableOptionSwitch, canBackground, /* we can background; we don't currently, but our sleep value */ /* guarantees we don't hog the Mac while we are in the background */ multiFinderAware, /* this says we do our own activate/deactivate; don't fake us out */ backgroundAndForeground, /* this is definitely not a background-only application! */ dontGetFrontClicks, /* change this is if you want "do first click" behavior like the Finder */ ignoreChildDiedEvents, /* essentially, I'm not a debugger (sub-launching) */ not32BitCompatible, /* this app should not be run in 32-bit address space */ reserved, reserved, reserved, reserved, reserved, reserved, reserved, kPrefSize * 1024, kMinSize * 1024 }; data 'PICT' (150) { $"0278 0000 0000 003F 003F 1101 0100 0A00" /* .x.....?.?....�. */ $"0000 0000 3F00 3FA0 0082 A000 8E98 0008" /* ....?.?�.��.��.. */ $"0000 0000 003F 003F 0000 0000 003F 003F" /* .....?.?.....?.? */ $"0000 0000 003F 003F 0000 06FC 0002 3F00" /* .....?.?...�..?. */ $"0006 FC00 02FF C000 07FD 0003 01FF E000" /* ..�..��..�...��. */ $"07FD 0003 03E1 F000 07FD 0003 079E 7800" /* .�...��..�...�x. */ $"07FD 0003 0F61 BC00 07FD 0003 1E80 5E00" /* .�...a�..�...�^. */ $"07FD 0003 3D00 2F00 07FD 0003 7A00 1780" /* .�..=./..�..z..� */ $"07FD 0003 F400 0BC0 08FE 0004 01E8 0005" /* .�..�..�.�...�.. */ $"E008 FE00 0403 D000 02F0 08FE 0004 07A0" /* �.�...�..�.�...� */ $"0001 7808 FE00 040F 4000 00BC 08FE 0004" /* ..x.�...@..�.�.. */ $"1E80 0000 5C08 FE00 003D FE00 005E 08FE" /* .�..\.�..=�..^.� */ $"0000 7AFE 0000 2E08 FE00 00F4 FE00 002E" /* ..z�....�..��... */ $"0903 0000 01E8 FE00 002E 0903 0000 03D0" /* �....��...�....� */ $"FE00 002E 0907 0000 07A0 0100 005E 0907" /* �...�....�...^�. */ $"0000 0F40 0380 005C 0907 0000 1E80 01C0" /* ...@.�.\�....�.� */ $"00BC 0907 0000 3D00 08E0 0178 0907 0000" /* .��...=..�.x�... */ $"7A00 1C70 02F0 0907 0000 F400 0E38 05E0" /* z..p.��...�..8.� */ $"0907 0001 E800 E758 0BC0 0907 0003 D001" /* �...�.�X.��...�. */ $"F388 1780 0907 0007 A003 3810 2F00 0907" /* �.��...�.8./.�. */ $"000F 4002 5C60 5E00 0907 001E 8002 8C00" /* ..@.\`^.�...�.�. */ $"BC00 0907 003D 0010 C801 7800 0907 007A" /* �.�..=..�.x.�..z */ $"0110 F002 F000 0907 00F4 0390 6005 E000" /* ..�.�.�..�.�`.�. */ $"0907 01E8 01D0 000B C000 0907 03D0 00FF" /* �..�.�..�.�..�.� */ $"8017 8000 0905 07A0 1E70 002F FF00 0905" /* �.�.�..�.p./�.�. */ $"0F40 3738 005E FF00 0905 1E80 239C 00BC" /* .@78.^�.�..�#�.� */ $"FF00 0905 3D00 31C8 0178 FF00 0905 7A00" /* �.�.=.1�.x�.�.z. */ $"38C0 02F0 FF00 0905 7400 1C40 05E0 FF00" /* 8�.��.�.t..@.��. */ $"0905 F400 0EC0 0BC0 FF00 0905 E800 0780" /* �.�..�.��.�.�..� */ $"1780 FF00 0800 E8FE 0000 2FFE 0008 00E8" /* .��...��../�...� */ $"FE00 005E FE00 0800 E8FE 0000 BCFE 0008" /* �..^�...��..��.. */ $"04F4 0000 0178 FE00 0804 7400 0002 F0FE" /* .�...x�...t...�� */ $"0008 047A 0000 05E0 FE00 0804 3D00 000B" /* ...z...��...=... */ $"C0FE 0008 041E 8000 1780 FE00 0703 0F40" /* ��....�..��....@ */ $"002F FD00 0703 07A0 005E FD00 0703 03D0" /* ./�....�.^�....� */ $"00BC FD00 0703 01E8 0178 FD00 0703 00F4" /* .��....�.x�....� */ $"02F0 FD00 0703 007B 0DE0 FD00 0703 003C" /* .��....{.��....< */ $"F3C0 FD00 0703 001F 0F80 FD00 0602 000F" /* ���......��..... */ $"FFFC 0006 0200 07FE FC00 0602 0001 F8FC" /* ��.....��.....�� */ $"00A0 008F A000 83FF" /* .�.��.�� */ }; data 'PICT' (153) { $"3B5A 0000 0000 0064 0174 0011 02FF 0C00" /* ;Z.....d.t...�.. */ $"FFFF FFFF 0000 0000 0000 0000 0174 0000" /* ����.........t.. */ $"0064 0000 0000 0000 00A0 0082 001E 0001" /* .d.......�.�.... */ $"000A 0000 0000 0064 0174 0098 8174 0000" /* .�.....d.t.��t.. */ $"0000 0064 0174 0000 0000 0000 0000 0048" /* ...d.t.........H */ $"0000 0048 0000 0000 0008 0001 0008 0000" /* ...H............ */ $"0000 0000 3438 0000 0000 0000 4E0D 8000" /* ....48......N.�. */ $"00FF 0000 FFFF FFFF FFFF 0000 FFFF FFFF" /* .�..������..���� */ $"CCCC 0000 FFFF FFFF 9999 0000 FFFF FFFF" /* ��..������..���� */ $"6666 0000 FFFF FFFF 3333 0000 FFFF FFFF" /* ff..����33..���� */ $"0000 0000 FFFF CCCC FFFF 0000 FFFF CCCC" /* ....������..���� */ $"CCCC 0000 FFFF CCCC 9999 0000 FFFF CCCC" /* ��..���̙�..���� */ $"6666 0000 FFFF CCCC 3333 0000 FFFF CCCC" /* ff..����33..���� */ $"0000 0000 FFFF 9999 FFFF 0000 FFFF 9999" /* ....������..���� */ $"CCCC 0000 FFFF 9999 9999 0000 FFFF 9999" /* ��..������..���� */ $"6666 0000 FFFF 9999 3333 0000 FFFF 9999" /* ff..����33..���� */ $"0000 0000 FFFF 6666 FFFF 0000 FFFF 6666" /* ....��ff��..��ff */ $"CCCC 0000 FFFF 6666 9999 0000 FFFF 6666" /* ��..��ff��..��ff */ $"6666 0000 FFFF 6666 3333 0000 FFFF 6666" /* ff..��ff33..��ff */ $"0000 0000 FFFF 3333 FFFF 0000 FFFF 3333" /* ....��33��..��33 */ $"CCCC 0000 FFFF 3333 9999 0000 FFFF 3333" /* ��..��33��..��33 */ $"6666 0000 FFFF 3333 3333 0000 FFFF 3333" /* ff..��3333..��33 */ $"0000 0000 FFFF 0000 FFFF 0000 FFFF 0000" /* ....��..��..��.. */ $"CCCC 0000 FFFF 0000 9999 0000 FFFF 0000" /* ��..��..��..��.. */ $"6666 0000 FFFF 0000 3333 0000 FFFF 0000" /* ff..��..33..��.. */ $"0000 0000 CCCC FFFF FFFF 0000 CCCC FFFF" /* ....������..���� */ $"CCCC 0000 CCCC FFFF 9999 0000 CCCC FFFF" /* ��..������..���� */ $"6666 0000 CCCC FFFF 3333 0000 CCCC FFFF" /* ff..����33..���� */ $"0000 0000 CCCC CCCC FFFF 0000 CCCC CCCC" /* ....������..���� */ $"CCCC 0000 CCCC CCCC 9999 0000 CCCC CCCC" /* ��..���̙�..���� */ $"6666 0000 CCCC CCCC 3333 0000 CCCC CCCC" /* ff..����33..���� */ $"0000 0000 CCCC 9999 FFFF 0000 CCCC 9999" /* ....�̙���..�̙� */ $"CCCC 0000 CCCC 9999 9999 0000 CCCC 9999" /* ��..�̙���..�̙� */ $"6666 0000 CCCC 9999 3333 0000 CCCC 9999" /* ff..�̙�33..�̙� */ $"0000 0000 CCCC 6666 FFFF 0000 CCCC 6666" /* ....��ff��..��ff */ $"CCCC 0000 CCCC 6666 9999 0000 CCCC 6666" /* ��..��ff��..��ff */ $"6666 0000 CCCC 6666 3333 0000 CCCC 6666" /* ff..��ff33..��ff */ $"0000 0000 CCCC 3333 FFFF 0000 CCCC 3333" /* ....��33��..��33 */ $"CCCC 0000 CCCC 3333 9999 0000 CCCC 3333" /* ��..��33��..��33 */ $"6666 0000 CCCC 3333 3333 0000 CCCC 3333" /* ff..��3333..��33 */ $"0000 0000 CCCC 0000 FFFF 0000 CCCC 0000" /* ....��..��..��.. */ $"CCCC 0000 CCCC 0000 9999 0000 CCCC 0000" /* ��..��..��..��.. */ $"6666 0000 CCCC 0000 3333 0000 CCCC 0000" /* ff..��..33..��.. */ $"0000 0000 9999 FFFF FFFF 0000 9999 FFFF" /* ....������..���� */ $"CCCC 0000 9999 FFFF 9999 0000 9999 FFFF" /* ��..������..���� */ $"6666 0000 9999 FFFF 3333 0000 9999 FFFF" /* ff..����33..���� */ $"0000 0000 9999 CCCC FFFF 0000 9999 CCCC" /* ....������..���� */ $"CCCC 0000 9999 CCCC 9999 0000 9999 CCCC" /* ��..���̙�..���� */ $"6666 0000 9999 CCCC 3333 0000 9999 CCCC" /* ff..����33..���� */ $"0000 0000 9999 9999 FFFF 0000 9999 9999" /* ....������..���� */ $"CCCC 0000 9999 9999 9999 0000 9999 9999" /* ��..������..���� */ $"6666 0000 9999 9999 3333 0000 9999 9999" /* ff..����33..���� */ $"0000 0000 9999 6666 FFFF 0000 9999 6666" /* ....��ff��..��ff */ $"CCCC 0000 9999 6666 9999 0000 9999 6666" /* ��..��ff��..��ff */ $"6666 0000 9999 6666 3333 0000 9999 6666" /* ff..��ff33..��ff */ $"0000 0000 9999 3333 FFFF 0000 9999 3333" /* ....��33��..��33 */ $"CCCC 0000 9999 3333 9999 0000 9999 3333" /* ��..��33��..��33 */ $"6666 0000 9999 3333 3333 0000 9999 3333" /* ff..��3333..��33 */ $"0000 0000 9999 0000 FFFF 0000 9999 0000" /* ....��..��..��.. */ $"CCCC 0000 9999 0000 9999 0000 9999 0000" /* ��..��..��..��.. */ $"6666 0000 9999 0000 3333 0000 9999 0000" /* ff..��..33..��.. */ $"0000 0000 6666 FFFF FFFF 0000 6666 FFFF" /* ....ff����..ff�� */ $"CCCC 0000 6666 FFFF 9999 0000 6666 FFFF" /* ��..ff����..ff�� */ $"6666 0000 6666 FFFF 3333 0000 6666 FFFF" /* ff..ff��33..ff�� */ $"0000 0000 6666 CCCC FFFF 0000 6666 CCCC" /* ....ff����..ff�� */ $"CCCC 0000 6666 CCCC 9999 0000 6666 CCCC" /* ��..ff�̙�..ff�� */ $"6666 0000 6666 CCCC 3333 0000 6666 CCCC" /* ff..ff��33..ff�� */ $"0000 0000 6666 9999 FFFF 0000 6666 9999" /* ....ff����..ff�� */ $"CCCC 0000 6666 9999 9999 0000 6666 9999" /* ��..ff����..ff�� */ $"6666 0000 6666 9999 3333 0000 6666 9999" /* ff..ff��33..ff�� */ $"0000 0000 6666 6666 FFFF 0000 6666 6666" /* ....ffff��..ffff */ $"CCCC 0000 6666 6666 9999 0000 6666 6666" /* ��..ffff��..ffff */ $"6666 0000 6666 6666 3333 0000 6666 6666" /* ff..ffff33..ffff */ $"0000 0000 6666 3333 FFFF 0000 6666 3333" /* ....ff33��..ff33 */ $"CCCC 0000 6666 3333 9999 0000 6666 3333" /* ��..ff33��..ff33 */ $"6666 0000 6666 3333 3333 0000 6666 3333" /* ff..ff3333..ff33 */ $"0000 0000 6666 0000 FFFF 0000 6666 0000" /* ....ff..��..ff.. */ $"CCCC 0000 6666 0000 9999 0000 6666 0000" /* ��..ff..��..ff.. */ $"6666 0000 6666 0000 3333 0000 6666 0000" /* ff..ff..33..ff.. */ $"0000 0000 3333 FFFF FFFF 0000 3333 FFFF" /* ....33����..33�� */ $"CCCC 0000 3333 FFFF 9999 0000 3333 FFFF" /* ��..33����..33�� */ $"6666 0000 3333 FFFF 3333 0000 3333 FFFF" /* ff..33��33..33�� */ $"0000 0000 3333 CCCC FFFF 0000 3333 CCCC" /* ....33����..33�� */ $"CCCC 0000 3333 CCCC 9999 0000 3333 CCCC" /* ��..33�̙�..33�� */ $"6666 0000 3333 CCCC 3333 0000 3333 CCCC" /* ff..33��33..33�� */ $"0000 0000 3333 9999 FFFF 0000 3333 9999" /* ....33����..33�� */ $"CCCC 0000 3333 9999 9999 0000 3333 9999" /* ��..33����..33�� */ $"6666 0000 3333 9999 3333 0000 3333 9999" /* ff..33��33..33�� */ $"0000 0000 3333 6666 FFFF 0000 3333 6666" /* ....33ff��..33ff */ $"CCCC 0000 3333 6666 9999 0000 3333 6666" /* ��..33ff��..33ff */ $"6666 0000 3333 6666 3333 0000 3333 6666" /* ff..33ff33..33ff */ $"0000 0000 3333 3333 FFFF 0000 3333 3333" /* ....3333��..3333 */ $"CCCC 0000 3333 3333 9999 0000 3333 3333" /* ��..3333��..3333 */ $"6666 0000 3333 3333 3333 0000 3333 3333" /* ff..333333..3333 */ $"0000 0000 3333 0000 FFFF 0000 3333 0000" /* ....33..��..33.. */ $"CCCC 0000 3333 0000 9999 0000 3333 0000" /* ��..33..��..33.. */ $"6666 0000 3333 0000 3333 0000 3333 0000" /* ff..33..33..33.. */ $"0000 0000 0000 FFFF FFFF 0000 0000 FFFF" /* ......����....�� */ $"CCCC 0000 0000 FFFF 9999 0000 0000 FFFF" /* ��....����....�� */ $"6666 0000 0000 FFFF 3333 0000 0000 FFFF" /* ff....��33....�� */ $"0000 0000 0000 CCCC FFFF 0000 0000 CCCC" /* ......����....�� */ $"CCCC 0000 0000 CCCC 9999 0000 0000 CCCC" /* ��....�̙�....�� */ $"6666 0000 0000 CCCC 3333 0000 0000 CCCC" /* ff....��33....�� */ $"0000 0000 0000 9999 FFFF 0000 0000 9999" /* ......����....�� */ $"CCCC 0000 0000 9999 9999 0000 0000 9999" /* ��....����....�� */ $"6666 0000 0000 9999 3333 0000 0000 9999" /* ff....��33....�� */ $"0000 0000 0000 6666 FFFF 0000 0000 6666" /* ......ff��....ff */ $"CCCC 0000 0000 6666 9999 0000 0000 6666" /* ��....ff��....ff */ $"6666 0000 0000 6666 3333 0000 0000 6666" /* ff....ff33....ff */ $"0000 0000 0000 3333 FFFF 0000 0000 3333" /* ......33��....33 */ $"CCCC 0000 0000 3333 9999 0000 0000 3333" /* ��....33��....33 */ $"6666 0000 0000 3333 3333 0000 0000 3333" /* ff....3333....33 */ $"0000 0000 0000 0000 FFFF 0000 0000 0000" /* ........��...... */ $"CCCC 0000 0000 0000 9999 0000 0000 0000" /* ��......��...... */ $"6666 0000 0000 0000 3333 0000 EEEE 0000" /* ff......33..��.. */ $"0000 0000 DDDD 0000 0000 0000 BBBB 0000" /* ....��......��.. */ $"0000 0000 AAAA 0000 0000 0000 8888 0000" /* ....��......��.. */ $"0000 0000 7777 0000 0000 0000 5555 0000" /* ....ww......UU.. */ $"0000 0000 4444 0000 0000 0000 2222 0000" /* ....DD......"".. */ $"0000 0000 1111 0000 0000 0000 0000 EEEE" /* ..............�� */ $"0000 0000 0000 DDDD 0000 0000 0000 BBBB" /* ......��......�� */ $"0000 0000 0000 AAAA 0000 0000 0000 8888" /* ......��......�� */ $"0000 0000 0000 7777 0000 0000 0000 5555" /* ......ww......UU */ $"0000 0000 0000 4444 0000 0000 0000 2222" /* ......DD......"" */ $"0000 0000 0000 1111 0000 0000 0000 0000" /* ................ */ $"EEEE 0000 0000 0000 DDDD 0000 0000 0000" /* ��......��...... */ $"BBBB 0000 0000 0000 AAAA 0000 0000 0000" /* ��......��...... */ $"8888 0000 0000 0000 7777 0000 0000 0000" /* ��......ww...... */ $"5555 0000 0000 0000 4444 0000 0000 0000" /* UU......DD...... */ $"2222 0000 0000 0000 1111 0000 EEEE EEEE" /* ""..........���� */ $"EEEE 0000 DDDD DDDD DDDD 0000 BBBB BBBB" /* ��..������..���� */ $"BBBB 0000 AAAA AAAA AAAA 0000 8888 8888" /* ��..������..���� */ $"8888 0000 7777 7777 7777 0000 5555 5555" /* ��..wwwwww..UUUU */ $"5555 0000 4444 4444 4444 0000 2222 2222" /* UU..DDDDDD.."""" */ $"2222 0000 1111 1111 1111 0000 0000 0000" /* "".............. */ $"0000 0000 0000 0064 0174 0000 0000 0064" /* .......d.t.....d */ $"0174 0000 0006 810A 810A 8D0A 0026 E10A" /* .t....��.&�� */ $"02FF ACFF D90A FC22 F80A 0122 22DF 0A05" /* .������"��.""��. */ $"2222 0A0A 2222 F10A 0122 22F2 0A01 2222" /* ""��""��.""��."" */ $"810A B30A 0029 E20A 0481 ACFE FFFF DA0A" /* �³�.)��.������� */ $"0122 22F5 0A01 2222 DF0A 0522 220A 0A22" /* .""��.""��.""��" */ $"22F1 0A01 2222 F20A 0122 2281 0AB3 0A00" /* "��.""��.""�³�. */ $"5EE5 0A08 F9F9 ACAC FDFF ACFF 2BDB 0A01" /* ^��.��������+��. */ $"2222 FD0A 0622 220A 0A22 220A FD22 000A" /* ""��.""��""��".� */ $"FC22 010A 0AFE 2201 0A0A FA22 FE0A FE22" /* �".���".���"���" */ $"FB0A FD22 000A FD22 FE0A FE22 010A 0AFD" /* ���".��"���".��� */ $"2208 0A0A 2222 0A22 220A 0AFD 22FC 0AFD" /* ".��""�""���"��� */ $"2201 0A0A FE22 FD0A 0122 2281 0ABF 0A00" /* ".���"��.""�¿�. */ $"64E5 0A09 FFFE FDFF FAFF FBFF F8FF DC0A" /* d��������������� */ $"FD22 FE0A FD22 FE0A 0322 220A 0AFE 22FE" /* �"���"��.""���"� */ $"0A13 2222 0A22 220A 2222 0A22 220A 2222" /* �.""�""�""�""�"" */ $"0A22 220A 2222 FB0A 0822 220A 0A22 220A" /* �""�""��.""��""� */ $"2222 FD0A 0822 220A 2222 0A22 220A FD22" /* ""��.""�""�""��" */ $"030A 0A22 22F8 0A08 2222 0A0A 2222 0A22" /* .��""��.""��""�" */ $"2281 0ABA 0A00 64E6 0A0E FDFD FFFE 56FE" /* "�º�.d��.����V� */ $"F9F9 FA56 F8F7 FFFF 81E0 0A01 2222 FB0A" /* ���V�������.""�� */ $"0122 22FD 0A05 2222 0A0A 2222 FD0A FC22" /* .""��.""��""���" */ $"090A 2222 0A22 220A 2222 0AFC 22FB 0A0A" /* ��""�""�""��"��� */ $"2222 0A0A 2222 0A22 220A 0AFD 2206 0A22" /* ""��""�""���".�" */ $"220A 2222 0AFE 22FD 0AFE 22FA 0A08 2222" /* "�""��"���"��."" */ $"0A0A 2222 0A22 2281 0ABA 0A00 67E7 0A08" /* ��""�""�º�.g��. */ $"FFFF FEFB FBFF ACF9 F8FE F902 56F9 F8DF" /* �����������.V��� */ $"0A01 2222 FC0A FD22 FE0A 0522 220A 0A22" /* �.""���"��.""��" */ $"22FD 0A01 2222 FD0A 0A22 220A 2222 0A22" /* "��.""���""�""�" */ $"220A 2222 F80A 1522 220A 0A22 220A 2222" /* "�""��.""��""�"" */ $"0A22 220A 2222 0A22 220A 2222 0AFD 22FC" /* �""�""�""�""��"� */ $"0A01 2222 FB0A 0822 220A 0A22 220A 2222" /* �.""��.""��""�"" */ $"810A BA0A 006C E80A 10FD FFFF ACFC FFFD" /* �º�.l��.������� */ $"F956 F9F7 FAF9 F9FF 56FF E00A FC22 060A" /* �V������V����".� */ $"2222 0A0A 2222 FE0A 0422 220A 2222 FC0A" /* ""��""��.""�""�� */ $"FE22 0B0A 0A22 220A 2222 0A22 220A 0AFE" /* �".��""�""�""��� */ $"22F9 0A09 2222 0A22 220A 2222 0A0A FD22" /* "���""�""�""���" */ $"0C0A 2222 0A22 220A 2222 0A22 220A FD22" /* .�""�""�""�""��" */ $"F90A 0322 220A 0AFE 22FD 0A01 2222 810A" /* ��.""���"��.""�� */ $"BF0A 001B E90A 00FE FEFF 02FC FFFF FEF9" /* ��..��.���.����� */ $"0756 F956 56F8 ACFF FF81 0A81 0AB7 0A00" /* .V�VV�����·�. */ $"1EEA 0A12 FDFE FFFF FDFE FFFE F9F9 81F9" /* .��.������������ */ $"F8FA FAF7 F8FF FF81 0AB7 0AFE 2284 0A00" /* ��������·��"��. */ $"73EA 0A00 FEFE FF0F FCFF FFFE F9FA F9F9" /* s��.���.�������� */ $"FAFB FFFC F9FC FFFF C70A FC22 F30A FE22" /* �����������"���" */ $"FC0A FC22 030A 0A22 22EA 0AFD 22FE 0A01" /* ���".��""���"��. */ $"2222 E70A FD22 F90A FE22 000A FE22 030A" /* ""���"���".��".� */ $"0A22 22E8 0A04 2222 0A22 22FA 0A01 2222" /* �""��.""�""��."" */ $"FD0A 0122 22F1 0A01 2222 FC0A 0522 220A" /* ��.""��.""��.""� */ $"0A22 22F3 0A01 2222 EC0A 0122 22F8 0A01" /* �""��.""��.""��. */ $"2222 E30A 0076 EA0A FDFF 0FFC FEFF ACF9" /* ""��.v����.����� */ $"FAF9 FAFB FBFF FFFA FFFE FFC7 0A05 2222" /* �������������."" */ $"0A0A 2222 F30A 0122 22FC 0A01 2222 E40A" /* ��""��.""��.""�� */ $"0922 220A 0A22 220A 0A22 22E8 0A05 2222" /* �""��""��""��."" */ $"0A0A 2222 F90A 0522 220A 0A22 22E4 0AFD" /* ��""��.""��""��� */ $"220F 0A0A 040A 040A 040A 2222 040A 040A" /* ".��.�.�.�"".�.� */ $"2222 F10A 0122 22FC 0A05 2222 0A0A 2222" /* ""��.""��.""��"" */ $"F30A 0122 22EC 0A01 2222 D80A 00E0 EB0A" /* ��.""��.""��.��� */ $"14FD FEFF FFAC FBAC FFFC AC56 F9FA FAFB" /* .����������V���� */ $"FFFF ACFB FFFF C70A 0722 220A 0A22 220A" /* ��������.""��""� */ $"0AFE 220A 0A0A 2222 0A22 220A 0A22 22FC" /* ��"���""�""��""� */ $"0A01 2222 FD0A FE22 000A FD22 010A 0AFD" /* �.""���".��".��� */ $"22F6 0A01 2222 FC0A FD22 010A 0AFE 2209" /* "��.""���".���"� */ $"0A0A 2222 0A0A 2222 0A0A FE22 FB0A 0122" /* ��""��""���"��." */ $"22FC 0A0D 2222 0A22 220A 0A22 220A 0A22" /* "��.""�""��""��" */ $"220A FE22 080A 2222 0A0A 2222 0A0A FE22" /* "��".�""��""���" */ $"010A 0AFD 22F9 0A0B 2222 040A 040A 040A" /* .���"��."".�.�.� */ $"040A 040A FB22 0204 0A0A FE22 010A 0AFC" /* .�.��"..���".��� */ $"2201 0A0A FD22 FC0A 0722 220A 0A22 220A" /* ".���"��.""��""� */ $"0AFE 2201 0A0A FC22 000A FD22 010A 0AFE" /* ��".���".��".��� */ $"2201 0A0A FD22 FE0A FD22 000A FD22 010A" /* ".���"���".��".� */ $"0AFE 2201 0A0A FE22 000A FD22 E80A 00E0" /* ��".���".��"��.� */ $"EB0A 14AC FBFF FFFA FFFD FC56 ACFF FDF9" /* ��.��������V���� */ $"FBAC FFFF FEF9 FFFF C70A FC22 FC0A 0B22" /* �����������"��." */ $"220A 2222 0A22 220A 0A22 22FC 0AFD 22FE" /* "�""�""��""���"� */ $"0A0D 2222 0A22 220A 2222 0A22 220A 2222" /* �.""�""�""�""�"" */ $"F60A FD22 FE0A 0A22 220A 0A22 220A 2222" /* ���"���""��""�"" */ $"0A0A FD22 060A 0A22 220A 2222 FB0A FD22" /* ���".��""�""���" */ $"140A 0A22 220A 2222 0A0A 2222 0A0A 2222" /* .��""�""��""��"" */ $"0A0A 2222 0A0A FD22 FC0A 0722 220A 2222" /* ��""���"��.""�"" */ $"0A22 22FD 0A01 040A FB22 0604 0A04 0A04" /* �""��..��"..�.�. */ $"0A04 FB22 070A 040A 040A 2222 0AFE 22FE" /* �.�".�.�.�""��"� */ $"0A04 2222 0A22 22FC 0AFB 22FD 0A02 2222" /* �.""�""���"��."" */ $"0AFE 22FD 0A11 2222 0A0A 2222 0A22 220A" /* ��"��.""��""�""� */ $"2222 0A22 220A 2222 FC0A 1222 220A 0A22" /* ""�""�""��.""��" */ $"220A 2222 0A0A 2222 0A22 220A 2222 E90A" /* "�""��""�""�""�� */ $"00E3 EC0A 14FF AC0A ACFA F8FE FEFF F981" /* .���.��¬������� */ $"FFFE 56FC FEFF FDFD FFFF C60A 0122 22FB" /* ��V���������.""� */ $"0AFD 2209 0A22 220A 2222 0A0A 2222 FC0A" /* ��"��""�""��""�� */ $"0122 22FC 0A0D 2222 0A22 220A 2222 0A22" /* .""��.""�""�""�" */ $"220A 2222 F30A 0722 220A 0A22 220A 0AFC" /* "�""��.""��""��� */ $"2201 0A0A FD22 010A 0AFC 22F8 0A15 2222" /* ".���".���"��."" */ $"0A22 220A 2222 0A0A 2222 0A0A 2222 0A0A" /* �""�""��""��""�� */ $"2222 0A0A FD22 FE0A FD22 050A 2222 0A22" /* ""���"���".�""�" */ $"22FE 0A10 040A 2222 040A 2222 040A 040A" /* "��..�"".�"".�.� */ $"040A 040A 04FD 2203 0A04 0A04 FD22 020A" /* .�.�.�".�.�.�".� */ $"2222 FD0A 0422 220A 2222 FC0A 0722 220A" /* ""��.""�""��.""� */ $"0A22 220A 0AFD 2202 0A22 22FC 0A03 2222" /* �""���".�""��."" */ $"0A0A FC22 070A 2222 0A22 220A 0AFE 22FE" /* ���".�""�""���"� */ $"0A03 2222 0A0A FC22 090A 0A22 220A 2222" /* �.""���"���""�"" */ $"0A22 22E9 0A00 F5ED 0A15 FFFC 0AFA FFFA" /* �""��.���.������ */ $"FDFE FFAC F9FF FFFE FEFF FAFB FCFD FDFF" /* ���������������� */ $"C60A 0122 22FC 0A0E 2222 0A22 220A 2222" /* ��.""��.""�""�"" */ $"0A22 220A 0A22 22FC 0A01 2222 FC0A 0D22" /* �""��""��.""��." */ $"220A 2222 0A22 220A 2222 0A22 22F7 0A0D" /* "�""�""�""�""��. */ $"2222 0A0A 2222 0A0A 2222 0A0A 2222 FB0A" /* ""��""��""��""�� */ $"0122 22FE 0A01 2222 F90A 1722 220A 0A22" /* .""��.""��.""��" */ $"220A 2222 0A22 220A 0A22 220A 0A22 220A" /* "�""�""��""��""� */ $"0A22 22FE 0A01 2222 FE0A 1222 220A 2222" /* �""��.""��.""�"" */ $"0A22 220A 2222 040A 040A 0422 220A FD22" /* �""�"".�.�.""��" */ $"0704 0A04 0A04 0A04 0AFD 220A 040A 0422" /* ..�.�.�.��"�.�." */ $"220A 2222 0422 22FD 0A04 2222 0A22 22FC" /* "�"".""��.""�""� */ $"0A0E 2222 0A0A 2222 0A22 220A 2222 0A22" /* �.""��""�""�""�" */ $"22FC 0A05 2222 0A0A 2222 FD0A 0422 220A" /* "��.""��""��.""� */ $"2222 FD0A 0922 220A 0A22 220A 0A22 22FC" /* ""���""��""��""� */ $"0A07 2222 0A22 220A 2222 E90A 00E1 EB0A" /* �.""�""�""��.��� */ $"13FB FFFE F72B 81F7 F8FA FDFC F8FF FDFA" /* .����+���������� */ $"FFFF FDFF FFC6 0A01 2222 FB0A FD22 010A" /* �������.""���".� */ $"0AFD 2203 0A0A 2222 FC0A 0122 22FC 0A0D" /* ��".��""��.""��. */ $"2222 0A22 220A 2222 0A22 220A 2222 FE0A" /* ""�""�""�""�""�� */ $"0122 22FB 0AFD 22FD 0A03 2222 0A0A FE22" /* .""���"��.""���" */ $"FD0A 0122 22FD 0AFE 22FA 0AFD 22FE 0AFD" /* ��.""���"���"��� */ $"220B 0A0A 2222 0A0A 2222 0A0A 2222 FE0A" /* ".��""��""��""�� */ $"0122 22FD 0AFD 220B 0A22 220A 2222 0A04" /* .""���".�""�""�. */ $"0A04 0A04 FE22 0A04 0A22 2204 0A04 0A04" /* �.�.�"�.�"".�.�. */ $"0A04 FD22 030A 040A 04FD 2203 0A22 2204" /* �.�".�.�.�".�"". */ $"FD0A FD22 FC0A 0722 220A 0A22 220A 0AFD" /* ���"��.""��""��� */ $"2202 0A22 22FB 0A03 2222 0A0A FE22 070A" /* ".�""��.""���".� */ $"0A22 220A 2222 0AFD 22FD 0A03 2222 0A0A" /* �""�""��"��.""�� */ $"FE22 FE0A 0722 220A 2222 0A22 22E9 0A00" /* �"��.""�""�""��. */ $"48EB 0A0D FF0A FDF7 FE56 F7F7 5656 ACF8" /* H��.�����V��VV�� */ $"F8F9 FDFF 02F9 00FF 940A 0122 22B0 0A26" /* ����.�.���.""��& */ $"040A 040A 040A 040A 040A 040A 040A 040A" /* .�.�.�.�.�.�.�.� */ $"040A 040A 040A 040A 040A 040A 040A 040A" /* .�.�.�.�.�.�.�.� */ $"040A 040A 040A 049F 0A00 2CFB 5FFD 0A04" /* .�.�.�.��.,�_��. */ $"ACFF FEFE FFF8 0A13 FD56 FCF9 5656 FAF9" /* �������.�V��VV�� */ $"F7F8 F7F7 FE81 81AC FAF5 00FF FE0A 995F" /* ����������.��™_ */ $"0122 2281 5FA6 5F00 31FC 5FFD 0A06 FFFA" /* .""�_�_.1�_��.�� */ $"FA81 F8F9 FFFE FD19 FFFF FE0A 0AFF 56FB" /* �������.������V� */ $"F9F9 F8F9 FBF9 F7F7 F8F8 F7F8 FDF7 F5FC" /* ���������������� */ $"FFFF FE0A 815F 815F BD5F 0034 FD5F FE0A" /* ���_�_�_.4�_�� */ $"11FE 56FF F9F8 81FD F7FE FFAC FC81 56F7" /* .�V�����������V� */ $"FAFB 81FE 5611 F756 FDAC 56F8 F8F7 F981" /* ����V.�V��V����� */ $"FCF9 F6F9 FCF6 2BFF FE0A 815F 815F BE5F" /* ������+��_�_�_ */ $"005A FA0A 27FC FFF9 F9F8 F756 81FF FCFA" /* .Z��'������V���� */ $"FBFA F8F7 ACF8 FDFF F956 56F8 F856 56F8" /* ���������VV��VV� */ $"F82B ACFD 56F5 F5FD F7F5 F52B F5FC 0AC0" /* �+��V������+���� */ $"10E0 0AEE 10B0 0A0D 040A 040A 040A 040A" /* .���.��..�.�.�.� */ $"040A 040A 040A EB02 0C04 0A04 0A04 0A04" /* .�.�.��...�.�.�. */ $"0A04 0A04 0A04 D70A F710 EC0A 0056 FA0A" /* �.�.�.���.��.V�� */ $"29FC FFF9 56F8 F8FD FA81 FAFF F9FC F9F8" /* )���V����������� */ $"F7F7 81F8 FDF8 FAF9 F856 56F8 F7F9 FD2B" /* ���������VV����+ */ $"F600 FCFB F5F9 F9F6 56F5 FFBC 10E1 0AE2" /* �.������V���.��� */ $"10BB 0A0A 040A 040A 040A 040A 040A 04E7" /* .���.�.�.�.�.�.� */ $"020B 0A04 0A04 0A04 0A04 0A04 0A04 DA0A" /* ..�.�.�.�.�.�.�� */ $"F410 ED0A 0058 F90A 25FE FBF8 5656 81F9" /* �.��.X��%���VV�� */ $"F9FD AC81 FE81 F9F8 F7F7 F8FA FEAC FEFC" /* ���������������� */ $"FAF9 F7FA FEF7 F62B 81FE F8FB FBF7 2BFE" /* �������+������+� */ $"F6BA 10E4 0ADF 10BE 0A09 040A 040A 040A" /* ��.���.���.�.�.� */ $"040A 040A F702 F701 F702 0A04 0A04 0A04" /* .�.��.�.�.�.�.�. */ $"0A04 0A04 0A04 DB0A F310 EF0A 0010 005E" /* �.�.�.���.��...^ */ $"0010 FA0A 0EFB FD56 F8F9 FCAC FB81 81AC" /* ..��.��V�������� */ $"FCFB AC81 FDF8 FEF7 0CF9 FFFC FEFF FEFC" /* ��������.������� */ $"F8AC FDFC FCF8 FEF6 03FA ACF7 FFB8 10E9" /* ��������.�����.� */ $"0ADC 10D8 0AF5 10F5 0A09 040A 040A 040A" /* ��.���.���.�.�.� */ $"040A 040A F902 F101 F902 0A04 0A04 0A04" /* .�.��.�.�.�.�.�. */ $"0A04 0A04 0A04 DD0A F010 F30A FE10 0059" /* �.�.�.���.���..Y */ $"F810 0DFF FFFE FCFB F9FB FDFF F9FA F9F8" /* �..������������� */ $"FCFC 5615 F8F7 F8FF F9F7 5656 FCFB FDFC" /* ��V.������VV���� */ $"2BF9 FEAC FFAC F6F7 F62B 8110 F910 DC0A" /* +��������+�.�.�� */ $"F210 F70A 0904 0A04 0A04 0A04 0A04 0AFA" /* �.���.�.�.�.�.�� */ $"02ED 01FA 020A 040A 040A 040A 040A 040A" /* .�.�.�.�.�.�.�.� */ $"04E0 0AEC 10F7 0AFC 1000 61F9 102A FCFD" /* .���.���..a�.*�� */ $"F981 FD81 FBFC 81FD F9FC FFF7 FDF9 F9FA" /* ���������������� */ $"F9F8 F8F9 FCF9 F7F8 F7F7 F8F9 81FB F900" /* ���������������. */ $"F8FA F52B F72B 2BFF 5681 10C5 10F9 0A09" /* ���+�++�V�.�.��� */ $"040A 040A 040A 040A 040A FB02 E901 FB02" /* .�.�.�.�.��.�.�. */ $"0A04 0A04 0A04 0A04 0A04 0A04 F60A 0234" /* �.�.�.�.�.�.��.4 */ $"5F5F FE89 0265 5F34 F60A DC10 005C F910" /* __��.e_4���..\�. */ $"00FF FEF8 0AFB AC56 56FA FBF9 81F9 56FE" /* .������VV�����V� */ $"FEF9 FE56 15FC FE56 F7F8 F8F7 F856 F7FB" /* ���V.��V�����V�� */ $"FBF7 0081 81F5 F62B F6F9 FF81 10C3 10FC" /* ��.����+����.�.� */ $"0A09 040A 040A 040A 040A 040A FB02 E701" /* ��.�.�.�.�.��.�. */ $"FB02 0804 0A04 0A04 0A04 0A04 FA0A FE10" /* �...�.�.�.�.���. */ $"003A F789 005F F80A DB10 0052 FA10 0CAC" /* .:��._���..R�..� */ $"FAF8 F8F9 F8FA F9F8 F9FC FEF9 FEAC 1BFA" /* ��������������.� */ $"FAFB FCFB F881 FDF9 F956 F8F7 F8F7 F7F6" /* ���������V������ */ $"FDFC F600 2BF6 F62B F600 FD81 10C2 10FE" /* ���.+��+�.��.�.� */ $"0A09 040A 040A 040A 040A 040A FC02 E301" /* ��.�.�.�.�.��.�. */ $"FC02 F70A FA10 005F F489 FB0A D910 0057" /* �.���.._����..W */ $"FA10 1BAC AC56 F9F9 AC81 F9F8 F9AC FCFB" /* �..��V���������� */ $"81FD FDFA FBAC AC81 81FB FFFF 8156 F8FE" /* �������������V�� */ $"F70C 2BF7 F7FF F7F5 F5F6 F6F5 F52B FF81" /* �.+����������+�� */ $"10C0 1009 0A0A 040A 040A 040A 040A FC02" /* .�.���.�.�.�.��. */ $"E101 FC02 F80A FB10 005F FE89 003A FD10" /* �.�.���.._��.:�. */ $"013A 5FFC 89D4 1000 49FA 1001 FEFF FEF9" /* .:_���..I�..���� */ $"12AC FEAC F9FC FA56 F9F9 FCFC 81FD ACFC" /* .������V�������� */ $"F8FF F7F9 FCFF 0EFE FDFD FCFA FFFC 2BF5" /* ������.�������+� */ $"F5F6 F6F5 56FF 8110 C010 F80A FC02 DF01" /* ����V��.�.���.�. */ $"FC02 F80A FC10 FD89 0065 FA10 FD89 003A" /* �.���.��.e�.��.: */ $"D510 0052 F910 19FF FCFA 81AC ACFA FDFB" /* �..R�..��������� */ $"FA56 FBFA F9FC 81FC FB56 FAFF F8FB ACFC" /* �V�������V������ */ $"81FE F90D FAFA FDAC ACFF FB2B F5F5 F6F7" /* ���.�������+���� */ $"81FF CF10 0016 8110 F310 F80A FC02 DF01" /* ���...�.�.���.�. */ $"FC02 F80A FD10 063A 893A 103A 8989 FA10" /* �.���..:�:.:���. */ $"FE89 003A D510 005F F910 05FE FFFB 81FB" /* ��.:�.._�..����� */ $"FBFE AC0B 56FA FA56 FAFA ACFA FCFB FEF9" /* ���.V��V�������� */ $"FE56 11F9 F956 F7F8 56F8 FCFD FCFC FE81" /* �V.��V��V������� */ $"F7F6 F656 FFD5 1000 16FD 10FC 16C8 1001" /* ���V��...�.�.�.. */ $"3A3A FC5F 013A 3AB8 10F8 0AFC 02DD 01FC" /* ::�_.::�.���.�.� */ $"02F8 0AFE 1001 5F89 FE10 023A 895F FB10" /* .���.._��..:�_�. */ $"035F 8989 3AD5 1000 6BF8 1007 FEFF ACAC" /* ._��:�..k�..���� */ $"FFFE FCF9 FEFA 0AF9 FCFA FCFC 56F9 F9F8" /* ������������V��� */ $"F7F8 FD56 0EF7 F856 FBFB FDFB F9FB FFFB" /* ���V.��V�������� */ $"FAFA FFAC D610 F616 CB10 005F F489 015F" /* �����.�.�.._�._ */ $"3AF9 1000 3AFE 5FFD 8900 5FDE 1001 8989" /* :�..:�_��._�..�� */ $"FE5F 0289 895F F810 F80A FD02 DB01 FD02" /* �_.��_�.���.�.�. */ $"F80A FE10 015F 5FFD 1001 5F89 FA10 0289" /* ���..__�.._��..� */ $"893A D510 005B F710 1481 ACFC FFF9 FAFA" /* �:�..[�..������� */ $"8181 FAFB FDFB FBFC FEF9 2BF8 F8F7 FEF8" /* ����������+����� */ $"0EF7 F7F8 F9FE F9AC FA81 FAFA FBFF FFFD" /* .��������������� */ $"D510 F516 CE10 005F EF89 FA10 F889 DE10" /* �.�.�.._��.���. */ $"F989 003A F910 F90A FC02 DB01 FC02 F90A" /* ��.:�.���.�.�.�� */ $"FE10 015F 65FC 1001 8989 FB10 0189 89D4" /* �.._e�..���..��� */ $"1000 72F4 1011 FEFB FAF9 FBFD ACAC FAAC" /* ..r�..���������� */ $"81FB FDFF F9F8 F856 FDF8 0DF7 2BAC FBFE" /* �������V��.�+��� */ $"F956 FAF9 F9FA F9FD FEDF 1000 16F9 10F2" /* �V��������...�.� */ $"16D2 1000 3AFD 8901 653A FB10 013A 5FFA" /* .�..:��.e:�..:_� */ $"89FB 1600 5FF9 89F7 1000 3AFE 5FEB 1000" /* ��.._���..:�_�.. */ $"65FB 8900 3AFA 10F8 0AFD 02D9 01FD 02F8" /* e��.:�.���.�.�.� */ $"0A03 1010 3A89 FC10 023A 895F FD10 035F" /* �...:��..:�_�.._ */ $"8989 3AD5 1000 78F4 100E FBFE 81FA FCFC" /* ��:�..x�..������ */ $"FBAC FEAC 81FE FAFB FAFE 5600 F8FE F70E" /* ����������V.���. */ $"2BFB FF56 AC56 56F9 56F9 FAFA F9FF FDEC" /* +��V�VV�V������� */ $"1001 1616 F910 FC16 FD10 EC16 D710 005F" /* ....�.�.�.�.�.._ */ $"FE89 005F F710 0116 5FFB 89FA 1600 3AFA" /* ��._�..._���..:� */ $"89FE 16FB 10FB 8900 3AEC 10FB 8900 3AFA" /* ��.�.��.:�.��.:� */ $"10F9 0AFC 02D9 01FC 02F9 0AFE 1001 8965" /* .���.�.�.���..�e */ $"FC10 0565 8989 5F3A 5FFE 8900 3AD5 1000" /* �..e��_:_��.:�.. */ $"6FF3 100C FBFF FBFB FEFF FFFB 562B F9F9" /* o�..��������V+�� */ $"FFFE F913 56F8 F8F7 F7AC FFFB FA81 5681" /* ���.V���������V� */ $"F9F9 FBF9 F9FB FCFF F210 D316 D810 0065" /* ���������.�.�..e */ $"FE89 003A FB10 FB16 003A FC89 005F F916" /* ��.:�.�..:��._�. */ $"003A FB89 FD16 FD10 005F FA89 EC10 005F" /* .:���.�.._���.._ */ $"FC89 003A FA10 F90A FD02 D701 FD02 F90A" /* ��.:�.���.�.�.�� */ $"FE10 025F 8989 FC10 003A FA89 003A D510" /* �.._���..:��.:�. */ $"0066 F110 17FE FFAC FEFF F8F8 FAF9 FFAC" /* .f�..����������� */ $"ACF9 FAF9 F8F7 56FB FA81 FFF9 F8FD 5605" /* ������V�������V. */ $"F856 F9F9 FBFF F410 D016 DA10 005F FE89" /* �V�����.�.�.._�� */ $"003A F416 FC89 0065 F716 FB89 FC16 FE10" /* .:�.��.e�.���.�. */ $"005F FA89 EC10 005F FC89 003A FA10 F90A" /* ._���.._��.:�.�� */ $"FD02 D701 FD02 F90A FD10 0465 8989 655F" /* �.�.�.���..e��e_ */ $"FE3A 005F FB89 D410 0070 F010 0A16 FDFC" /* �:._���..p�.�.�� */ $"ACFD F7F8 FA81 FAFF FDF9 11FC FAAC FD81" /* ����������.����� */ $"FBF8 F781 F7F8 56F9 F9FA F9FE FFFA 10FD" /* ������V�������.� */ $"1602 F9FD FFD1 16E6 10F6 1600 3AFE 8900" /* ..����.�.�..:��. */ $"3AF4 16FC 8900 5FF6 16FB 89FA 1601 1010" /* :�.��._�.���.... */ $"FB89 003A EC10 005F FC89 003A FB10 F80A" /* ��.:�.._��.:�.�� */ $"FD02 D701 FD02 F80A FD10 005F F589 003A" /* �.�.�.���.._��.: */ $"FA10 0016 F910 0016 E510 006F F210 FD16" /* �...�...�..o�.�. */ $"1D81 81F9 FBF8 2BF7 FDFB FD81 FFFA FCFA" /* .�����+��������� */ $"ACF9 FBF9 56F7 FFF9 56F9 81F9 F9FD FEF5" /* ����V���V������� */ $"1603 ACFE F9FF D116 E910 F416 FE89 0065" /* ..�����.�.�.��.e */ $"F516 003A FD89 0065 F416 FB89 F716 033A" /* �..:��.e�.���..: */ $"6565 5FEA 1000 5FFC 8900 3AFB 10F9 0AFD" /* ee_�.._��.:�.��� */ $"02D5 01FD 02F9 0AFB 1000 65F8 8902 3A16" /* .�.�.���..e��.:. */ $"16FD 10FC 16FD 10FC 16E7 1000 64F7 10F8" /* .�.�.�.�.�..d�.� */ $"161C FBFB F681 FF81 F756 FEF8 FAFA FCF9" /* ..�������V������ */ $"81F9 F9FA F9F9 56F9 F8F9 56FA F9FB FFF6" /* ������V���V����� */ $"1606 F9AC FDF8 F7FA FFD0 16F0 10F0 1600" /* ..��������.�.�.. */ $"65FE 89F6 1600 3AFD 8900 65F2 16FB 89DC" /* e���..:��.e�.��� */ $"1600 65FC 8900 3AFB 16F9 10FD 02D5 01FD" /* ..e��.:�.�.�.�.� */ $"02F9 0AFA 1001 163A FD65 015F 3AE0 16F2" /* .���...:�e._:�.� */ $"1000 51EE 160D ACF9 F556 F6FD FF81 FB81" /* ..Q�..���V������ */ $"ACF9 56FB FBF9 0256 F856 FEF9 01AC FFF5" /* ��V���.V�V��.��� */ $"1607 FDFD 56F7 F8F8 81FC AF16 FE89 0065" /* ..��V������.��.e */ $"F716 0065 FE89 0065 F016 FB89 DC16 0065" /* �..e��.e�.���..e */ $"FC89 003A FB16 F910 FD02 D501 FD02 F90A" /* ��.:�.�.�.�.�.�� */ $"FE10 C516 0060 EE16 1AAC F9F6 F5F6 FEAC" /* �.�..`�..������� */ $"ACFE FDFB ACFC FFF9 FAFA 5656 F856 F8F9" /* ����������VV�V�� */ $"FAAC FFFF F416 07FF FB2B F8F8 56F8 FDB0" /* �����..��+��V��� */ $"1600 65FE 8900 3AF9 1600 3AFE 8900 65EE" /* ..e��.:�..:��.e� */ $"16FB 89DC 1600 65FC 8900 3AFB 16F9 10FD" /* .���..e��.:�.�.� */ $"02F4 0100 08FA 0100 08EB 01FD 02F9 10F0" /* .�...�...�.�.�.� */ $"1601 653A D516 008C EE16 12FC 56F6 F5F5" /* ..e:�..��..�V��� */ $"FCFB FEFB FAFA F9FC FCF8 F856 F8F8 FE56" /* �����������V���V */ $"FDFF FE16 0456 16F9 FDFE FDFF 05FE FFFF" /* ���..V.�����.��� */ $"FEFA 2BFE F801 81FF B116 FD89 F916 0365" /* ��+��.���.���..e */ $"8989 5FEC 16FB 89FB 1600 3AFE 8907 653A" /* ��_�.���..:��.e: */ $"3A5F 6589 8965 F716 0065 FE89 0165 3AFE" /* :_e��e�..e��.e:� */ $"1600 65FC 8900 3AFB 16FC 1001 3A5F F789" /* ..e��.:�.�..:_�� */ $"015E 33FD 0100 2CFD 89FE 5EFD 8907 0101" /* .^3�..,���^��... */ $"5782 8989 5E33 F401 FD02 F910 F116 0265" /* W���^3�.�.�.�..e */ $"893A D516 0082 EE16 1CFE 56F5 00F6 FAFF" /* �:�..��..�V�.��� */ $"FBFA 81FC ACFF FDF9 FBFF FEF9 56FA FDAC" /* ������������V��� */ $"FDFE 1616 81FA FEFF 11AC FCFC FBFA F9FB" /* ��..����.������� */ $"FEFD FEFE 56F8 F8F7 F7FB FEB3 1600 3AFD" /* ����V�������..:� */ $"89FB 1603 3A89 8965 EA16 FB89 FB16 0065" /* ��..:��e�.���..e */ $"F689 F916 0065 F989 0265 1665 FC89 003A" /* ���..e��.e.e��.: */ $"FB16 FD10 005F F389 0033 FD01 012C 5EFA" /* �.�.._�.3�..,^� */ $"8902 5E01 08FA 8900 82F5 01FD 02F9 10F5" /* �.^..��.��.�.�.� */ $"1601 3A65 FD89 D416 008E EE16 08FD F8F7" /* ..:e���..��..��� */ $"F7F6 F9FF FBAC FEFE 05F9 FAFD FB56 FEFE" /* ��������.����V�� */ $"FF1C FB81 ACFE 16FE FCFB F956 FAF9 FAAC" /* �.����.����V���� */ $"FBFC 8181 56FF 16FD FEF9 F8F7 F7FA FDB3" /* ����V�.��������� */ $"1600 3AFD 89FC 1603 6589 893A E916 FB89" /* ..:���..e��:�.�� */ $"FA16 0065 F889 003A FA16 FC89 033A 163A" /* �..e��.:�.��.:.: */ $"5FF8 8900 3AFB 16FE 10FB 8903 5E33 3357" /* _��.:�.�.��.^33W */ $"FB89 005E FB01 005E FC89 0282 012C F889" /* ��.^�..^��.�.,�� */ $"0082 F601 FD02 F910 0216 1665 FE89 003A" /* .��.�.�....e��.: */ $"FE16 0065 FA89 D416 0091 EE16 0AFF F8F8" /* �..e���..��.���� */ $"F9F5 F5FC ACFD F8F5 FDF6 13F5 F62B F8FC" /* ����������.��+�� */ $"F856 F9FC FFFD AC56 F9FA FDFE FFFD ACFE" /* �V�����V�������� */ $"F90C FA56 ACFD 16FF FEFA F781 F9FD ACB4" /* �.�V��.��������� */ $"1600 65FD 89FD 1603 3A89 893A E816 FB89" /* ..e���..:��:�.�� */ $"F916 005F FB89 0065 F916 FD89 0065 FB16" /* �.._��.e�.��.e�. */ $"0065 FA89 003A FB16 0110 10FC 8900 5FFD" /* .e��.:�....��._� */ $"0202 0101 82FD 8900 5EFB 0100 33FC 8901" /* ....���.^�..3��. */ $"5E2C F689 002C F701 FD02 F910 0116 3AFC" /* ^,��.,�.�.�...:� */ $"8902 3A16 65F9 8900 3AD5 1600 A3EE 160A" /* �.:.e��.:�..��.� */ $"FFF7 F6F9 F5F5 00F5 F7F7 F8FD F909 2BF6" /* ������.�������+� */ $"F6F7 F8FB FEFF FD81 FEFC 17FB FCFA 5656" /* ����������.���VV */ $"F9F9 56F8 F9F9 FAFA FF16 16FF FEF8 81FC" /* ��V������..����� */ $"2BFD ACB5 16FC 89FD 1603 3A89 8965 FD16" /* +���.���..:��e�. */ $"0065 FE89 0565 3A3A 163A 65FD 89FA 16FB" /* .e��.e::.:e���.� */ $"89F8 16FB 8900 3AFA 1600 65FD 89F9 1601" /* ��.��.:�..e���.. */ $"3A65 FC89 003A FB16 0110 5FFD 8901 5F10" /* :e��.:�..._��._. */ $"FD02 0201 0133 FD89 0033 FB01 0033 F989" /* �....3��.3�..3�� */ $"045E 2C08 2C5E FC89 0033 F701 FD02 F910" /* .^,.,^��.3�.�.�. */ $"0816 3A89 895F 5F89 893A FD89 FC65 D416" /* ..:��__��:���e�. */ $"0096 EE16 17FF F7F5 FBF5 F6F5 F52B F9FC" /* .��..��������+�� */ $"FFFE FEAC F62B F6F8 FDFE FDFB 81FD F902" /* �����+���������. */ $"FEF9 F8FD 5602 F8F7 F8FE F900 FDFE 1607" /* ����V.�����.��.. */ $"FEFD 81F8 F856 FCFF B616 FC89 FD16 003A" /* �����V���.���..: */ $"FE89 0065 FE16 003A F589 0065 FA16 FB89" /* ��.e�..:��.e�.�� */ $"F816 FB89 FA16 003A FD89 0065 F816 0065" /* �.���..:��.e�..e */ $"FC89 003A FB16 0010 FC89 0110 10FD 0202" /* ��.:�...��...�.. */ $"0101 5EFE 8900 82FA 0100 33FB 8900 5EFB" /* ..^��.��..3��.^� */ $"01FC 8900 33F7 01FD 02F9 1002 163A 89FD" /* .��.3�.�.�...:�� */ $"1603 6589 8965 CD16 0090 EE16 04FF 2BF5" /* ..e��e�..��..�+� */ $"8100 FEF5 11FA FFFF ACFC FCFF 2BF6 F7FB" /* �.��.�������+��� */ $"81FD F9FA FA56 56FE F90D FAF9 F8F8 F7F8" /* �����VV��.������ */ $"56F7 F756 FBFA F9FF FE16 07FE ACF8 56F9" /* V��V�����..���V� */ $"F881 FFB7 16FC 89FC 1603 6589 8965 FD16" /* ����.���..e��e�. */ $"003A F789 0065 F916 FB89 F816 FB89 FA16" /* .:��.e�.���.���. */ $"0065 FD89 F716 0065 FC89 003A FB16 005F" /* .e���..e��.:�.._ */ $"FD89 003A FE10 FE02 0109 82FD 89F9 0100" /* ��.:�.�..Ƃ���.. */ $"33FC 8900 5EFA 01FC 89F7 01FD 02F8 1002" /* 3��.^�.���.�.�.. */ $"163A 65FC 1601 8965 CC16 0091 EE16 15FF" /* .:e�..�e�..��..� */ $"2BF5 F9F5 00F6 56FF FBFC FB56 2BFF 2BF6" /* +���.�V����V+�+� */ $"81AC F9FD FAFC F910 FAFA 81FA F9F7 F7F8" /* �������.�������� */ $"56F8 F7F8 FCFA F9AC 81FE 1607 FEFD F9F9" /* V���������..���� */ $"F8F7 ACFC B816 FC89 003A FC16 0165 65FA" /* �����.��.:�..ee� */ $"16F9 8900 65F8 16FB 89F8 16FB 89FA 16FC" /* .��.e�.���.���.� */ $"89F7 1600 65FC 8900 3AFB 16FC 89FD 1002" /* ��..e��.:�.���.. */ $"0202 58FD 8900 5EF8 0100 33FC 8900 5EFB" /* ..X��.^�..3��.^� */ $"0100 33FD 8900 57F7 01FD 02F9 1003 1616" /* ..3��.W�.�.�.... */ $"3A65 FD16 013A 89F9 1600 3AD4 1600 92EE" /* :e�..:��..:�..�� */ $"1616 ACF8 F6F7 56F5 F6F5 FE2B F8F7 F72B" /* ..����V����+���+ */ $"FD56 00FF 81AC FAFE 56FD F900 FAFE 8102" /* �V.�����V��.���. */ $"FAF8 F7FD 5605 F7F9 FAF9 81FE FD16 06FF" /* ����V.�������..� */ $"F9F9 FCF9 F7FF B816 FC89 0065 F316 003A" /* �������.��.e�..: */ $"FA89 F716 FB89 F816 FB89 FB16 003A FD89" /* ���.���.���..:�� */ $"0065 F716 0065 FC89 003A FC16 003A FC89" /* .e�..e��.:�..:�� */ $"FD10 0102 58FE 8900 5EF6 0100 33FC 8900" /* �...X��.^�..3��. */ $"5EFC 0100 08FD 8900 33F6 01FD 02F9 1003" /* ^�...��.3�.�.�.. */ $"1616 3A89 FD16 0189 5FFA 1602 3A89 3AD5" /* ..:��..�_�..:�:� */ $"1600 92EE 161A ACFA 0000 FD00 F500 FDFA" /* ..��..��..�.�.�� */ $"F8F7 F8F7 81FA F6FF 56FF 2BFF FAF8 FFFC" /* ��������V�+����� */ $"F9FE 8103 ACFD FAF8 FC56 05F9 FBF9 56FF" /* ���.�����V.���V� */ $"FCFE 1607 FF56 F9F9 FCFC FAFF B916 0065" /* ��..�V�������..e */ $"FC89 F216 FB89 0065 F716 FB89 F816 FB89" /* ���.��.e�.���.�� */ $"FB16 005F FD89 003A F716 0065 FC89 003A" /* �.._��.:�..e��.: */ $"FC16 0065 FD89 005F FD10 0058 FE89 002D" /* �..e��._�..X��.- */ $"F501 0033 FC89 005E FC01 035E 8957 08F5" /* �..3��.^�..^�W.� */ $"01FC 02F9 1002 1616 3AFD 8902 5F89 65F8" /* .�.�....:��._�e� */ $"8900 3AD5 1600 90EE 1609 FAFE F500 ACF5" /* �.:�..��.����.�� */ $"F500 FBFD FDF8 0BF9 FCFB FCF9 FFF9 81FD" /* �.����.��������� */ $"F8FC FBFC FA0D FFFB 56F9 FCFA 81FA F8AC" /* �����.��V������� */ $"F9F8 81FE FE16 07FE FAF8 F82B FEFE FFF7" /* �����..����+���� */ $"16FC 1CC8 1600 65FC 8900 65F3 16FB 8900" /* .�.�..e��.e�.��. */ $"65F7 16FB 89F8 16FB 89FB 1600 65FD 8900" /* e�.���.���..e��. */ $"3AF7 1600 65FC 8900 3AFC 16FC 8900 5FFE" /* :�..e��.:�.��._� */ $"1000 5FFE 8901 0202 F501 0033 FC89 005E" /* .._��...�..3��.^ */ $"FC01 0157 57F3 01FD 02F8 1002 1616 3AFE" /* �..WW�.�.�....:� */ $"89FE 65F7 89D4 1600 90ED 161B FF2B F5F8" /* ��e���..��..�+�� */ $"F72B 2BF8 FEF7 F8F8 F756 FFFE FB56 FFFB" /* �++������V���V�� */ $"2BFF F956 F9F9 FAF9 FEFA 0CF9 F9F8 ACF9" /* +��V������.����� */ $"81F9 F981 F956 F7FF FE16 05FC FDF9 2B2B" /* �����V���..���++ */ $"ACF9 16E2 1CDE 1600 3AFB 8900 3AF4 16FB" /* ��.�.�..:��.:�.� */ $"8900 65F7 16FB 89F8 16FB 89FB 1600 65FD" /* �.e�.���.���..e� */ $"8900 3AF7 1600 65FC 8900 3AFC 16FC 8900" /* �.:�..e��.:�.��. */ $"5FFE 10FE 89FD 02F6 0100 33FC 8900 5EFB" /* _�.���.�..3��.^� */ $"0100 08F4 01FC 02F9 10FE 1600 3AFE 8902" /* ...�.�.�.�..:��. */ $"5F65 65F7 8900 3AD5 1600 87ED 1616 FFF7" /* _ee��.:�..��..�� */ $"F52B FAF6 8100 FFF5 F856 F956 FEAC FC56" /* �+���.���V�V���V */ $"81FF F8FC FDFE 5600 F9FC 560C F956 ACFA" /* ������V.��V.�V�� */ $"FAF9 F9F8 FDF8 F9FA FDFE 1604 FEFF F9F8" /* ����������..���� */ $"FEFB 16DF 1CDE 16FA 89F4 16FB 8900 65F7" /* ��.�.�.���.��.e� */ $"16FB 89F8 16FB 89FB 1600 65FD 8900 65F7" /* .���.���..e��.e� */ $"1600 65FC 8900 3AFC 16FC 8902 6510 10FE" /* ..e��.:�.��.e..� */ $"8900 10FD 02F6 0100 33FC 8900 5EED 01FD" /* �..�.�..3��.^�.� */ $"02F8 10FE 1604 3A89 1616 89F6 1601 893A" /* .�.�..:�..��..�: */ $"D516 0080 EE16 18FA FFF5 F52B F9F5 FB00" /* �..��..����+���. */ $"FDF9 2B56 F856 81FF ACF9 FAFF FDFA FAAC" /* ��+V�V���������� */ $"FC56 FEF8 0C56 F9F9 FCFA FAF9 56FA 81F9" /* �V��.V������V��� */ $"56FE FD16 03FE FEFF ACFC 16DE 1CDE 16F9" /* V��..�����.�.�.� */ $"89F5 16FB 8900 65F7 16FB 89F8 16FB 89FB" /* ��.��.e�.���.��� */ $"1600 65FD 8900 65F7 1600 65FC 8900 3AFC" /* ..e��.e�..e��.:� */ $"16FB 8905 103A 8989 1010 FC02 F701 0033" /* .��..:��..�.�..3 */ $"FC89 005E EE01 FC02 F810 FE16 003A FE89" /* ��.^�.�.�.�..:�� */ $"005F C816 007F EE16 1D81 FEF5 F6F5 FBF6" /* ._�...�..������� */ $"8100 81FB 2BF8 56F9 56FB FF56 F9FF FFF9" /* �.��+�V�V��V���� */ $"FDFA 8156 56F9 F9FD AC0C FDFA FEF9 81FC" /* ���VV����.������ */ $"5656 ACF9 F981 FFFB 1CFD 16DB 1CDF 1600" /* VV������.�.�.�.. */ $"3AF9 8900 3AF7 16FB 8900 65F7 16FB 89F8" /* :��.:�.��.e�.��� */ $"16FB 89FB 1600 3AFC 89F7 1600 65FC 8900" /* .���..:���..e��. */ $"3AFC 16F8 8900 5FFE 10FC 0202 0101 08FB" /* :�.��._�.�.....� */ $"0100 33FC 8900 5EEF 01FC 02F8 10FC 1602" /* ..3��.^�.�.�.�.. */ $"6589 5FC7 1600 7EEE 1619 FB56 F5F6 F5FA" /* e�_�..~�..�V���� */ $"F7F8 F62B FFF6 56F8 FA56 F7AC ACF8 FDFF" /* ���+��V��V������ */ $"FCFE FAFB FE56 00F8 FEFA 0EF9 FBFD FF56" /* �����V.���.����V */ $"FAFF FAF8 FBF9 FAFA FBFF D11C DF16 F789" /* �����������.�.�� */ $"015F 3AFC 1601 3A65 FB89 0065 F716 FB89" /* ._:�..:e��.e�.�� */ $"F816 FB89 FB16 003A FC89 003A F816 0065" /* �.���..:��.:�..e */ $"FC89 003A FC16 0065 F989 FD10 FC02 0301" /* ��.:�..e���.�... */ $"5E89 08FC 0100 33FC 8900 5EEF 01FC 02F8" /* ^�.�..3��.^�.�.� */ $"16D3 1CED 1600 74EE 1601 AC2B FEF5 2B00" /* .�.�..t�..�+��+. */ $"FCF7 2BF5 F9FF F9F7 F9F8 F8F7 ACFB FCFA" /* ��+������������� */ $"FFF9 FDFB FBF8 FE56 F8F8 56F9 F956 FCFA" /* �������V��V��V�� */ $"F7FC 81F7 FBFC F9F9 FAAC FFD0 1CE1 1600" /* ������������.�.. */ $"3AE9 8900 65F7 16FB 89F8 16FB 89FA 16FB" /* :�.e�.���.���.� */ $"89F8 16FB 8900 3AFC 1600 3AFA 8900 65FC" /* ��.��.:�..:��.e� */ $"10FE 0204 3383 8989 5EFC 0100 33FC 8900" /* .�..3���^�..3��. */ $"5EF0 01FC 02F8 16CD 1CF2 1600 8500 1CEF" /* ^�.�.�.�.�..�..� */ $"1631 FEF6 F6F5 F500 F956 F7F5 F5F7 FFFA" /* .1�����.�V������ */ $"F8F7 56F7 F7FD 81FF FBFD FF81 FCFA FEFC" /* ��V������������� */ $"F8F8 F9FA 5656 FA81 F7F8 56F7 F9FE F9FD" /* ����VV����V����� */ $"FCF9 FFFD CB1C E616 0065 EA89 0065 F71C" /* �����.�..e�.e�. */ $"FB89 FC1C FD16 FB89 FA16 0065 FB89 025F" /* ���.�.���..e��._ */ $"1616 FE3A 0116 65FB 8900 3AFB 16F8 8900" /* ..�:..e��.:�.��. */ $"5FFE 3A01 5F83 FB89 FC01 0033 FC89 005E" /* _�:._����..3��.^ */ $"F101 FC02 F716 F91C 0065 FD89 0065 DB1C" /* �.�.�.�..e��.e�. */ $"F216 0074 FE1C F116 26FE F6F5 00F5 F6F5" /* �..t�.�.&���.��� */ $"ACF7 F5F5 F6FF FE56 F8F7 56F7 F8FD FFF9" /* �������V��V����� */ $"FEFF FCF9 81FB 81F9 F9FA F9FA F9F9 FBF7" /* ���������������� */ $"FEF8 082B FBFD FCFD 56F7 FFFD CA1C E716" /* ��.+����V����.�. */ $"0065 EA89 0040 F91C 0040 FB89 F91C 0016" /* .e�.@�..@���... */ $"FB89 003A FA16 EC89 003A FC16 0065 ED89" /* ��.:�.�.:�..e� */ $"FC01 005E FB89 F301 FB02 F716 F91C 0065" /* �..^���.�.�.�..e */ $"FB89 0065 DB1C F316 007B FC1C F316 02FD" /* ��.e�.�..{�.�..� */ $"F5F6 FE00 05F5 8156 00F6 F6FE FE23 F8F7" /* ���..��V.����#�� */ $"56F8 2BFB FFAC F9FF FFF9 81F9 56F8 F9F9" /* V�+���������V��� */ $"FBFC F9F9 FCF7 F8F8 562B 8181 FA81 5656" /* ��������V+����VV */ $"FAFF C81C EE16 FB1C 0065 EA89 0065 FA1C" /* ���.�.�..e�.e�. */ $"F989 FA1C 0065 FA89 0065 FB16 005F EC89" /* ���..e��.e�.._� */ $"0065 FC16 EE89 015E 02FE 0100 33FA 8900" /* .e�.�.^.�..3��. */ $"5EF5 01FB 02F6 16FA 1C04 4089 8965 65FD" /* ^�.�.�.�..@��ee� */ $"89D9 1CF5 1600 76EF 1C28 FCAC F6F6 F500" /* ��.�..v�.(�����. */ $"F500 F8FD 00F5 81FC F8FF FCF7 F8F9 F7FA" /* �.��.����������� */ $"FFFC F8F9 56FE F7FD F856 56FC FFFD F956" /* ����V����VV����V */ $"FCF8 F8FE F907 56AC 81F7 F7F8 F7FE AE1C" /* �����.V��������. */ $"0065 EA89 FC1C 0040 F789 0040 FE1C 0040" /* .e��..@��.@�..@ */ $"F789 0065 FB1C 0065 EC89 FB1C EF89 002D" /* ��.e�..e��.�.- */ $"FE02 005E F789 F801 FA02 F616 F91C 0289" /* �..^���.�.�.�..� */ $"8940 FE1C FE89 0040 D01C 0116 1600 76EF" /* �@�.��.@�.....v� */ $"1C34 FEFB 0000 F5F5 00F6 00FE 2B56 FEFB" /* .4��..��.�.�+V�� */ $"F9F9 FFFC 56F7 F9FC FBAC F9F8 2BF7 FA56" /* ����V�������+��V */ $"F9F9 F881 FDAC F9F9 ACF8 F9FA F9F9 F7FB" /* ���������������� */ $"ACF7 F7F8 F7F8 FFAD 1C00 65ED 8900 40FC" /* ��������..e�.@� */ $"1CF5 89FE 1C00 65F6 89FA 1C00 40EE 8900" /* .���..e���..@�. */ $"65FA 1C00 65F2 8900 33FE 0200 33F6 8900" /* e�..e�.3�..3��. */ $"5EFB 01F9 02F6 16F8 1C01 8940 FD1C 0340" /* ^�.�.�.�..�@�..@ */ $"8989 40CE 1C00 86EF 1C05 FFFA 00F5 F5F6" /* ��@�..��..��.��� */ $"FEF5 2C81 56F9 FFFA FAF9 FFFF ACF9 ACFC" /* ��,�V����������� */ $"FBF8 FEFE AC2B 2BF8 56FC F7F9 81FA 56FC" /* �����++�V�����V� */ $"FE56 81F9 56F9 F8FA F9AC 2BF7 F72B ACAC" /* �V��V�����+��+�� */ $"AB1C FC40 F91C FD40 F91C 0140 40FB 1C01" /* �.�@�.�@�..@@�.. */ $"4040 FC1C FE40 FD1C FD40 F81C FD40 F81C" /* @@�.�@�.�@�.�@�. */ $"FD40 F61C FE40 FB16 FD3A 0016 FC02 0A33" /* �@�.�@�.�:..�.�3 */ $"332D 0902 0101 082C 3333 FD01 F702 F616" /* 3-�....,33�.�.�. */ $"F81C 0140 89FB 1C02 8989 40CE 1C00 52EF" /* �..@��..��@�..R� */ $"1C05 AC81 F6F5 F5F6 FEF5 03F6 81FA FDFE" /* ..��������.����� */ $"F905 FF56 FDFF FEFD FE56 1CF7 FBFE F856" /* �.�V�����V.����V */ $"F8F9 81F7 56F9 56FF FEF9 F9FA FCFC FAF9" /* ����V�V��������� */ $"FAFC 56F8 FA81 56FF 811C CF1C F516 E702" /* ��V���V��.�.�.�. */ $"F516 F71C 0140 89FD 1C00 40FE 8900 40CE" /* �.�..@��..@��.@� */ $"1C00 54EE 1C06 FDF6 F5F5 F6F5 00FE F52A" /* ..T�..������.��* */ $"81FC F956 81FE F9F9 FEFF ACF8 F956 F7F8" /* ���V���������V�� */ $"FCFC FF56 F7AC F9F7 5656 FAFE ACFA FAAC" /* ���V����VV������ */ $"FCF9 F9FD F8FC F8FE FFF8 AC81 1CCF 1CF3" /* ������������.�.� */ $"16EB 02F3 16F7 1C01 4089 FD1C 0065 FE89" /* .�.�.�..@��..e�� */ $"FB1C 0189 40D5 1C00 53EF 1C04 FFFD F700" /* �..�@�..S�..���. */ $"00FE F5FE 002B FBFA 56F8 FCFE 56F9 F9FB" /* .���.+��V���V��� */ $"FEFC 56F8 F8FE ACFF FAF8 5656 FCF7 F7F8" /* ��V�������VV���� */ $"5656 81FF FBFA FAF9 2BFC ACAC F8FC FAF9" /* VV������+������� */ $"F9FF 811C CF1C F216 EF02 F216 F61C 0040" /* ���.�.�.�.�.�..@ */ $"FC89 FE65 0040 FA89 0040 D51C 004D EF1C" /* ���e.@��.@�..M�. */ $"0681 FF56 F500 F5F5 FE00 19F6 FEF9 F82B" /* .��V�.���..����+ */ $"FEAC F8F9 FBF9 81FF FAF9 F7FD F9F8 56F9" /* ��������������V� */ $"FAF8 81F8 2BFE F810 F9F9 FDAC F9F9 F8FC" /* ����+��.�������� */ $"56FC ACF8 F9F9 F8FE 8181 1CCE 1CF0 16F7" /* V���������.�.�.� */ $"02F0 16F4 1C00 40F1 89D4 1C00 46EE 1C03" /* .�.�..@��..F�.. */ $"FFF7 F500 FCF5 1A2B FFF8 F8F6 FFFD 56F9" /* ���.��.+������V� */ $"FEF9 F9FE FEFA FC81 FF56 F9F9 FCFB F9FB" /* ���������V������ */ $"F7F7 FEF8 0FF9 56F9 F956 F756 FCFA FFFA" /* ����.�V��V�V���� */ $"F9FA F900 FE81 1CCD 1CD7 16F3 1C00 40F1" /* ���.��.�.�.�..@� */ $"89D4 1C00 4EEE 1C36 FFF7 00F6 F5F6 F5F5" /* ��..N�.6��.����� */ $"F6F7 FEF8 F72B FEAC FBF7 ACF9 5656 FFFE" /* �����+������VV�� */ $"FCF9 FFAC FAFA 81FA F8FD F7F7 F956 56FA" /* �������������VV� */ $"56F8 F856 562B FEF8 FDAC 5656 AC81 FF81" /* V��VV+����VV���� */ $"1CCC 1CD9 16F2 1C02 4089 65F5 1C02 6589" /* .�.�.�..@�e�..e� */ $"40D5 1C00 4AEE 1C36 FF2B 002B F6F6 2B00" /* @�..J�.6�+.+��+. */ $"F681 FCF8 56F7 ACFE AC56 F856 56F8 F8AC" /* ����V����V�VV��� */ $"FFFD FBFF 81FB FA56 FAF9 FCF8 F956 FBAC" /* �������V�����V�� */ $"FD2B F7F7 F8F7 FAFB 56FF FAF8 81FF FE81" /* �+������V������� */ $"1CCB 1CDB 16F0 1C00 89F3 1C00 40D4 1C00" /* .�.�.�..��..@�.. */ $"44EE 1C14 FEFC 00F5 F62B 002B 00FD FBF8" /* D�..��.��+.+.��� */ $"F756 FCFE FDF8 F9F8 F7FE F806 ACAC FCFF" /* �V���������.���� */ $"81F9 F9FE 5606 ACF9 FAFB 81FF 81FC F708" /* ����V.���������. */ $"2BAC F9AC FCF9 ACFF FF81 1CC9 1CDF 16EE" /* +���������.�.�.� */ $"1C00 40C5 1C00 41EE 1C03 FBFA 00F5 FEF6" /* ..@�..A�..��.��� */ $"0E00 00FF FAF9 F881 FCFD FDF9 F9F7 F8F6" /* ...������������� */ $"FEF8 0AFC FCAC F956 56F8 F8FA 81FC FEF9" /* �������VV������� */ $"0C56 F8F7 F8F7 F956 56AC AC56 FBFB FEFF" /* .V�����VV��V���� */ $"811C C71C E316 AF1C 003E EE1C 0381 2BF5" /* �.�.�.�..>�..�+� */ $"F5FE F615 F500 FFF9 F956 FBFB FDAC FA56" /* ���.�.���V�����V */ $"56F8 2BF7 F7F8 F7F7 56F7 FDF8 0456 FAFD" /* V�+�����V���.V�� */ $"FAFA FEF9 0856 F7F8 56F8 F8AC FF56 FCFF" /* ����.V��V����V�� */ $"811C C51C E716 AD1C 0041 EE1C 04FA F6F5" /* �.�.�.�..A�..��� */ $"00F6 FDF5 0FFF 56F8 F8FC FBFD FBFC FCF8" /* .���.�V��������� */ $"F8F7 F8F8 56FE F80B F7F8 F8F7 F856 56FD" /* ����V��.�����VV� */ $"FFFD FD81 FEF8 04F9 F956 F9AC FEFF 03FB" /* ������.��V����.� */ $"FCFB FF81 1CC2 1CED 16AA 1C00 41F0 5F03" /* ����.�.�.�..A�_. */ $"1C1C FCF6 FDF5 1400 F5F6 FF56 F856 81FF" /* ..����..���V�V�� */ $"FFFC FBAC 81F8 F881 F8F8 56F8 FCF7 16F8" /* ����������V���.� */ $"F856 ACFC F9F9 FDF9 F7F9 ACAC F9FB ACFB" /* �V�������������� */ $"FFAC FBFB 81FF FD1C 815F 815F DB5F 0046" /* �������.�_�_�_.F */ $"F15F 1D1C 1C81 FCF6 00F5 F6F5 F500 F8FF" /* �_...���.����.�� */ $"FA56 F9FC FFFF FC81 FDF9 56FD ACF9 F856" /* �V��������V����V */ $"F8FE F717 F856 F8F8 F9FE F9F8 56FD F7F7" /* ���.�V������V��� */ $"FBFE FBF9 FBFF 81FE FDFB FBF8 FEFF FE1C" /* ���������������. */ $"815F 815F DC5F 0047 F15F 031C 1CFF FBFD" /* �_�_�_.G�_...��� */ $"F636 0000 F500 FEFE FFFF FAFE FCFC 81F8" /* �6..�.���������� */ $"56F9 56FE F956 56F8 F7F8 F8FB FE56 F8AC" /* V�V��VV������V�� */ $"FDF8 F881 F92B F8F8 81F9 FAAC FDFD FCFD" /* �����+���������� */ $"FFFE FFAC FEFB FE1C 1C81 5F81 5FDC 5F00" /* �������..�_�_�_. */ $"43EE 1C00 FDFE F50F F600 F5F6 F5F7 FFFE" /* C�..���.�.������ */ $"FAFF FEF8 FC81 5656 FEF9 22F8 56F8 F781" /* ������VV��"�V��� */ $"F956 FC81 F981 FFFF 56F8 FEF7 F7F8 F8F7" /* �V������V������� */ $"56AC FEFE F9FC FCFD ACFE FC81 ACFE 811C" /* V��������������. */ $"811C DA1C 0043 EE1C 1D81 FF2B 00F6 00F5" /* �.�..C�..��+.�.� */ $"00F5 2BFF FCF8 FBFE F7FC F956 F856 F956" /* .�+��������V�V�V */ $"F8F8 2BF9 FD56 56FE F918 81FD FEF8 FCF9" /* ��+��VV��.������ */ $"F7F7 56F7 F8FB FAF8 FDFC FFF9 81AC FB81" /* ��V������������� */ $"FAF8 AC81 1C81 1CDA 1C00 42ED 1C02 FEAC" /* ����.�.�..B�..�� */ $"FAFE 002A F500 2BFF F9F9 F8FA F8FE 5656" /* ��.*�.+�������VV */ $"F9F9 56F8 F7F7 FAFE F956 56F9 FAFA F9FD" /* ��V������VV����� */ $"FCF8 FE56 F856 56F8 FAFC 2BF8 81AC FDFE" /* ���V�VV���+����� */ $"F904 FAF9 F9F8 FC81 1C81 1CDA 1C00 44EE" /* �.������.�.�..D� */ $"1C0A FCFF F82B F6F5 F500 F6FC ACFE F90F" /* .����+���.�����. */ $"F8F7 FEFA F9FA F9F8 F8F7 56FF FBF7 5656" /* ����������V���VV */ $"FEF9 1956 FF56 FE56 F8F9 56F8 56FD F8F7" /* ��.V�V�V��V�V��� */ $"F82B FEFD FA56 F9F9 5656 F7FC F981 1C81" /* �+���V��VV����.� */ $"1CDB 1C00 44EE 1C10 FE2B F5F5 F6F5 2BF5" /* .�..D�..�+����+� */ $"00FF F9F8 81FC F756 ACFE FA26 81F7 56F7" /* .������V���&��V� */ $"FCFD F7F8 AC56 F9F9 56FD FEFD F9F8 F9F9" /* �����V��V������� */ $"5656 FC81 F92B F82B F7FA F9F8 F9F9 56F8" /* VV���+�+������V� */ $"5681 FE81 1C81 1CDB 1C00 44EE 1C04 FFFE" /* V���.�.�..D�..�� */ $"F9F6 00FE F532 2BFF FDAC FAFF FC56 F9FD" /* ��.��2+������V�� */ $"ACFB FF56 F8FC FE56 F8F8 F9F8 F956 F8FF" /* ���V���V�����V�� */ $"FEF9 F8F9 F9FA F8AC 81FE FCF7 F8F8 F7F8" /* ���������������� */ $"5656 F9F8 F8F9 F8F9 FF81 1C81 1CDB 1C00" /* VV��������.�.�.. */ $"3FED 1C17 FBFF F7F5 F5F6 F5F8 FDF9 F6F7" /* ?�..������������ */ $"FEFE 56FE FD81 FAFB F981 FFFA FE56 00F9" /* ��V����������V.� */ $"FE56 0EF7 FDF8 F7FA FFFA F7FB FCFA ACF9" /* �V.������������� */ $"5656 FAF9 04FA FFF9 F8FF 811C 811C DB1C" /* VV��.������.�.�. */ $"0042 ED1C 07FE F9F5 F500 002B 2BFE 000C" /* .B�..����..++�.. */ $"FEAC F981 FFFA FAF9 56FB FF81 FAFD F91D" /* ��������V������. */ $"56F8 F8F7 F8F7 F7FB FFF8 F9FD 5656 F8F8" /* V�����������VV�� */ $"5656 FAFA F956 FAF9 F8FD FFFC F8FF 811C" /* VV���V���������. */ $"811C DB1C 0045 EEFF 11AC FD81 F800 00F6" /* �.�..E��.����..� */ $"FAFD F500 FEFC F656 ACFE 56FE F926 FFAC" /* ���.���V��V��&�� */ $"F8F9 F9FA FAF9 56F7 2BF7 56F8 F8F9 F9F7" /* ������V�+�V����� */ $"FCF9 F8F8 56F8 F856 F9F9 FA56 5681 56F8" /* ����V��V���VV�V� */ $"FC56 F8FE 8181 FF81 FFDC FF01 6E28 E0FE" /* �V���������.n(�� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"F9AC F8F8 81FA FCFF FDFF 00F5 F6FD 81FD" /* ����������.����� */ $"FBFB F7F8 FAAC FCFE F907 FA81 FAFA F9F9" /* ���������.������ */ $"F8F8 FD56 03F7 FCF9 F8FD F731 F8AC 8156" /* ���V.������1���V */ $"F9F9 F8FA FCF9 F9FA F9AC FCFE E0FE E0FE" /* ���������������� */ $"E0FE 1616 E0FE E0FE E0FE E0FE E0FE E0FE" /* ��..������������ */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE FE16" /* ���������������. */ $"7FFE E016 16FE E0FE E0FE E0FE E0FE E0FE" /* .��..����������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E016 16FE E0FE E0FE E016" /* �������..������. */ $"16FE E0FE E0FE E0FE E0FE E0FE E016 16FE" /* .������������..� */ $"E016 16FE E0FE E0FE E0FE E0FE E0FE E0FE" /* �..������������� */ $"E0FE E0FE E0FE E016 16FE E0FE E0FE E0FE" /* �������..������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE 1616 E0FE" /* ������������..�� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E00E FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* �.�������������� */ $"FEFE 1637 FEE0 FEE0 FE16 16E0 FE16 16E0" /* ��.7�����..��..� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FB16 05FE" /* �������������..� */ $"E0FE E0FE E0FD 1609 FEE0 FEE0 FEE0 FEE0" /* ������.��������� */ $"FEE0 FC16 00E0 FE16 11E0 FE16 16E0 FEE0" /* ���..��..��..��� */ $"FEE0 FEE0 FE16 16E0 FEE0 FE01 7630 FEE0" /* �����..����.v0�� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 56FF" /* ��������������V� */ $"FFAC FBF7 F9FF AC56 FAFF 00F5 00F6 ACF8" /* �������V��.�.��� */ $"FC56 F756 FDF9 FEF8 FAF9 FA81 FEAC F9FE" /* �V�V������������ */ $"5603 F956 56F9 FDF7 0EF6 2BF7 F82B FFFC" /* V.�VV���.�+��+�� */ $"56F9 F9F8 F7FF FBF9 FEFA 7FFF E0FE E0FE" /* V���������.����� */ $"E0FE E016 16FE E0FE E0FE E0FE E0FE E0FE" /* ���..����������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"1616 E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ..�������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE 1616 E0FE E0FE E0FE" /* ��������..������ */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE 1616" /* ��������������.. */ $"E0FE 1616 E0FE E0FE E0FE E0FE E0FE E0FE" /* ��..������������ */ $"E0FE E0FE E0FE E0FE 1616 E07F FEE0 FEE0" /* ��������..�.���� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 1616" /* ��������������.. */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FE16 16E0 FEE0 FEE0 FEE0 1616 FEE0 1616" /* �..�������..��.. */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FE16" /* ���������������. */ $"16E0 FEE0 FEE0 FEE0 1616 FEE0 2516 16FE" /* .�������..��%..� */ $"E0FE E0FE E0FE E0FE 1616 E0FE E0FE E016" /* ��������..�����. */ $"16FE E0FE E0FE E0FE E0FE E0FE E016 16FE" /* .������������..� */ $"E0FE E001 5B29 E0FE E0FE E0FE E0FE E0FE" /* ���.[)���������� */ $"E0FE E0FE E0FA FFF9 FCFD F956 F8AC FDFC" /* �����������V���� */ $"FAFF 56FF 56F9 56F9 FEF8 F8F7 FC56 FCFA" /* ��V�V�V������V�� */ $"FEF9 07FB FCFC F956 F856 FAFD F904 56F8" /* ��.����V�V���.V� */ $"F72B 2BFC F80B 56F8 1616 F7FB FC81 1616" /* �++��.V�..����.. */ $"F9FF FE16 03E0 FEE0 FEFD 1602 E0FE E0FE" /* ���..�����..���� */ $"1609 E0FE 1616 E0FE 1616 E0FE FE16 08FE" /* .���..��..���..� */ $"E0FE E0FE E016 16FE FE16 00FE FD16 02E0" /* �����..��..��..� */ $"FEE0 FD16 01FE E0FE 1601 E0FE FC16 01FE" /* ���..���..���..� */ $"E0FE 1602 E0FE E0FD 1604 FEE0 FEE0 FEFE" /* ��..����..������ */ $"1600 FEFD 1605 E0FE E0FE E0FE FD16 00E0" /* ..��..�������..� */ $"FD16 02FE E0FE FE16 06FE E0FE E0FE E0FE" /* �..����..������� */ $"FE16 01FE E0FD 1602 FEE0 FEFE 1601 FEE0" /* �..���..����..�� */ $"FA16 01E0 FEFD 1602 E0FE E0FE 1601 E0FE" /* �..���..����..�� */ $"FC16 01FE E0FD 1605 FEE0 FEE0 FEE0 FE16" /* �..���..�������. */ $"01E0 FEFD 1604 E0FE E0FE E0FD 1600 FEFD" /* .���..������..�� */ $"1602 E0FE E0FE 1606 E0FE E0FE E0FE E0FD" /* ..����..�������� */ $"1601 FEE0 FE16 02E0 FEE0 FE16 32E0 FEE0" /* ..���..����.2��� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 1616" /* ��������������.. */ $"FEE0 FEE0 FEE0 FE16 16E0 FEE0 FEE0 FEE0" /* �������..������� */ $"FEE0 FEE0 FEE0 1616 FEE0 FEE0 FE16 16E0" /* ������..�����..� */ $"FE16 01E0 FEFE 1601 FEE0 FD16 02FE E0FE" /* �..���..���..��� */ $"016B 2AFE E0FE E0FE E0FE E0FE E0FE E0FE" /* .k*������������� */ $"E0FC FFF7 2B2B ACF7 56F9 FFFC FDAC FF56" /* ����++��V������V */ $"81FF FFFD FC81 F856 F8F9 8181 5656 FDF9" /* �������V����VV�� */ $"FD56 07F9 F9FA F9FA F956 F8FD F706 F856" /* �V.������V���.�V */ $"F7F8 56F7 F8FB 1616 FAFA 1616 FE16 16E0" /* ��V���..��..�..� */ $"FEE0 1616 FE16 16E0 FEE0 FE16 16E0 FEFD" /* ��..�..����..��� */ $"1624 E0FE 1616 E016 16FE E0FE E0FE 1616" /* .$��..�..�����.. */ $"E0FE 1616 E016 16FE 1616 E016 16FE 1616" /* ��..�..�..�..�.. */ $"E016 16FE 1616 E0FE 165C E0FE E016 16FE" /* �..�..��.\���..� */ $"1616 E016 16FE 1616 E0FE E0FE E0FE 1616" /* ..�..�..������.. */ $"E016 16FE 1616 E0FE E0FE E0FE 1616 E0FE" /* �..�..������..�� */ $"1616 E016 16FE 1616 E016 16FE E0FE E0FE" /* ..�..�..�..����� */ $"1616 E016 16FE 1616 E016 16FE E0FE E016" /* ..�..�..�..����. */ $"16FE 1616 E016 16FE 1616 E016 16FE 1616" /* .�..�..�..�..�.. */ $"E016 16FE 1616 E0FE 165B E0FE E016 16FE" /* �..�..��.[���..� */ $"E0FE E0FE E0FE E016 16FE 1616 E0FE 1616" /* �������..�..��.. */ $"E0FE E0FE E0FE E016 16FE E016 16FE 1616" /* �������..��..�.. */ $"E016 16FE 1616 E0FE E0FE E016 16FE E0FE" /* �..�..�����..��� */ $"E016 16FE 1616 E0FE E0FE 1616 E0FE E0FE" /* �..�..����..���� */ $"E0FE E0FE E0FE E0FE E0FE E0FE 1616 E0FE" /* ������������..�� */ $"E0FE E0FE E0FE FD16 09E0 FEE0 FEE0 FEE0" /* �������.�������� */ $"FEE0 FEFD 1616 E0FE E016 16FE E016 16FE" /* ����..���..��..� */ $"1616 E016 16FE E016 16FE E0FE E001 5A32" /* ..�..��..����.Z2 */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FC FFFA" /* ���������������� */ $"F7F7 F8FB F7F8 F7FF FDFA ACFF FEFE ACFD" /* ���������������� */ $"FBFA F9F8 F956 F856 F9F9 56F9 F956 56F7" /* �����V�V��V��VV� */ $"F7F8 56FC F904 56F8 56F8 F8FC 5603 F8F8" /* ��V��.V�V���V.�� */ $"F7F8 FB16 01F7 F9FC 1609 FEE0 FE16 16E0" /* ���..���.����..� */ $"1616 FEE0 FD16 01FE E0FD 1601 FEE0 FC16" /* ..���..���..���. */ $"17E0 FEE0 FEE0 1616 FEE0 1616 FE16 16E0" /* .�����..��..�..� */ $"1616 FE16 16E0 1616 FEFC 1606 FE16 16E0" /* ..�..�..��..�..� */ $"FEE0 FEFC 1623 FE16 16E0 1616 FEE0 FEE0" /* ����.#�..�..���� */ $"FEE0 1616 FE16 16E0 1616 FEE0 FEE0 FEE0" /* ��..�..�..������ */ $"1616 FEE0 1616 FE16 16E0 FC16 11E0 FEE0" /* ..��..�..��..��� */ $"FEE0 1616 FEE0 FEE0 1616 FE16 16E0 FEFD" /* ��..����..�..��� */ $"160F E016 16FE 1616 E016 16FE 1616 E016" /* ..�..�..�..�..�. */ $"16FE FC16 07FE 1616 E0FE E0FE E0FE 161F" /* .��..�..������.. */ $"E0FE E0FE E0FE 1616 E016 16FE E016 16FE" /* ������..�..��..� */ $"E0FE E0FE E0FE 1616 E0FE 1616 E016 16FE" /* ������..��..�..� */ $"FC16 05FE E0FE E0FE E0FE 1601 E0FE FC16" /* �..�������..���. */ $"01FE E0FD 1642 FEE0 FEE0 FEE0 FEE0 FEE0" /* .���.B���������� */ $"FEE0 FEE0 FEE0 1616 FEE0 FEE0 FEE0 FEE0" /* ������..�������� */ $"FEE0 FE16 16E0 FEE0 FEE0 FEE0 FEE0 1616" /* ���..���������.. */ $"FEE0 FEE0 FE16 16E0 FE16 16E0 1616 FE16" /* �����..��..�..�. */ $"16E0 FE16 16E0 FEE0 FE01 6F0E FEE0 FEE0" /* .��..����.o.���� */ $"FEE0 FEE0 FEE0 FE81 FCFF FCFD F810 F981" /* �������������.�� */ $"F7F8 ACFC FDFC F9F9 F8FA FD81 FAF9 F9FD" /* ���������������� */ $"56FC F903 56F8 F7F7 FDF8 FEF9 0856 56F8" /* V��.V�������.VV� */ $"F856 56F9 FB56 FEF8 02F7 F7F8 FD16 7FFC" /* �VV��V��.����..� */ $"81AC 1616 FCFF F9E0 FEE0 1616 FE16 16E0" /* ��..������..�..� */ $"1616 FE16 16E0 FEE0 1616 FEE0 FE16 16E0" /* ..�..���..���..� */ $"FEE0 FEE0 FEE0 FE16 16E0 FE16 16E0 1616" /* �������..��..�.. */ $"FE16 16E0 1616 FE16 16E0 1616 FEE0 FEE0" /* �..�..�..�..���� */ $"1616 FEE0 FEE0 1616 FEE0 FEE0 1616 FE16" /* ..����..����..�. */ $"16E0 FEE0 FEE0 FE16 16E0 1616 FE16 16E0" /* .������..�..�..� */ $"FEE0 FEE0 FE16 16E0 FE16 16E0 1616 FE16" /* �����..��..�..�. */ $"16E0 FEE0 FEE0 FEE0 FE16 16E0 1616 FE7F" /* .��������..�..�. */ $"1616 E016 16FE 1616 E016 16FE 1616 E016" /* ..�..�..�..�..�. */ $"16FE 1616 E016 16FE 1616 E016 16FE E0FE" /* .�..�..�..�..��� */ $"E016 16FE E0FE E0FE E0FE 1616 E0FE E0FE" /* �..�������..���� */ $"E016 16FE 1616 E0FE 1616 E0FE E0FE E0FE" /* �..�..��..������ */ $"E016 16FE E016 16FE 1616 E016 16FE E0FE" /* �..��..�..�..��� */ $"E0FE E0FE E0FE E0FE 1616 E016 16FE E0FE" /* ��������..�..��� */ $"E016 16FE 1616 E0FE E0FE E0FE E0FE E0FE" /* �..�..���������� */ $"E0FE E0FE E0FE 1616 E0FE E0FE E0FE E016" /* ������..�������. */ $"2816 FEE0 1616 FEE0 FEE0 FEE0 FEE0 FE16" /* (.��..���������. */ $"16E0 FEE0 FEE0 1616 FEE0 1616 FE16 16E0" /* .�����..��..�..� */ $"1616 FEE0 1616 FEE0 FEE0 0163 09E0 FEE0" /* ..��..����.c���� */ $"FEE0 FEE0 FEE0 F9FD FF10 F956 F856 F956" /* ���������.�V�V�V */ $"ACFA 56F8 56FA FCFC 81FA 56FA F902 FAF9" /* ��V�V�����V��.�� */ $"F9FE FA01 F956 FDF8 1456 F8FA F9FC 5656" /* ���.�V��.V����VV */ $"F7F8 F816 16FA 1616 F816 16F7 F7FC FD16" /* ���..�..�..����. */ $"0356 FB81 81FE 160A FFFE E0FE 1616 E016" /* .V����.�����..�. */ $"16FE E0FD 1608 FEE0 FE16 16E0 FEE0 FEFE" /* .���..���..����� */ $"1613 FEE0 FEE0 FEE0 1616 FEE0 1616 FE16" /* ..������..��..�. */ $"16E0 1616 FEE0 FD16 01FE E0FE 1608 E0FE" /* .�..���..���..�� */ $"1616 E0FE E0FE E0FE 1602 E0FE E0FD 161E" /* ..������..����.. */ $"FEE0 FEE0 FEE0 1616 FE16 16E0 1616 FEE0" /* ������..�..�..�� */ $"FEE0 FEE0 FE16 16E0 1616 FE16 16E0 FEFE" /* �����..�..�..��� */ $"1606 FEE0 FEE0 FEE0 FEFE 1608 FEE0 1616" /* ..��������..��.. */ $"FE16 16E0 FEFD 1609 E016 16FE 1616 E016" /* �..���.��..�..�. */ $"16FE FD16 02E0 FEE0 FE16 07E0 FE16 16E0" /* .��..����..��..� */ $"FEE0 FEFD 1606 E0FE E0FE E0FE E0FE 1616" /* ����..��������.. */ $"E0FE E016 16FE E0FE E0FE E0FE E016 16FE" /* ���..��������..� */ $"1616 E016 16FE E0FE 1605 E0FE E0FE E0FE" /* ..�..���..������ */ $"FD16 02E0 FEE0 FE16 02E0 FEE0 FD16 19FE" /* �..����..����..� */ $"1616 E016 16FE 1616 E0FE E0FE E0FE E016" /* ..�..�..�������. */ $"16FE E0FE E016 16FE E0FD 1609 FEE0 FE16" /* .����..���.����. */ $"16E0 FEE0 FEE0 FC16 09E0 FE16 16E0 FE16" /* .������.���..��. */ $"16E0 FEFE 1608 FEE0 FEE0 1616 FEE0 FE01" /* .���..����..���. */ $"773F FEE0 FEE0 FEE0 FEE0 F9FD FFAC 8156" /* w?�������������V */ $"56F9 FBFD FAF9 56FD 56F8 F82B F9FA F9FB" /* V�����V�V��+���� */ $"ACFA 56F9 56F9 56F9 F9FA F9FA FEAC F9F9" /* ��V�V�V��������� */ $"F82B 56F8 F8FC ACFC 56F8 2BF7 F7F8 F856" /* �+V�����V�+����V */ $"FBFC FE56 7FF8 F856 81FD FAF9 F956 F8F7" /* ���V.��V�����V�� */ $"F7F8 00FC FFFA F9E0 FEE0 FEE0 FEE0 FEE0" /* ��.������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FE16 16E0 FEE0 FEE0 FEE0 FEE0" /* �����..��������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FE7F E0FE E0FE E0FE E0FE E0FE" /* �����.���������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE 30E0 FEE0 FEE0 FEE0 FEE0" /* ������0��������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 0172 16E0 FEE0 FEE0" /* ��������.r.����� */ $"FEE0 F9FE FFFB FAF9 5656 F8FC FBF9 FAF9" /* ��������VV������ */ $"F9AC FDF7 1CAC FBFC ACFD ACF8 56F8 56F9" /* ����.�������V�V� */ $"F9FA F9F9 ACF9 56F9 56F8 F9F9 F8FA F9F7" /* ������V�V������� */ $"F8F9 FEF7 00F8 FC56 FEF8 0A56 56FB FCFA" /* ����.��V���VV��� */ $"FAF9 56F8 2BF7 FEF8 2EFC FF81 FEE0 FEE0" /* ��V�+���.������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FE16 7FE0 FEE0 FEE0" /* ���������..����� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FE6F E0FE E0FE" /* �����������o���� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE 0176 11FE" /* ������������.v.� */ $"E0FE E0FE E0FB FFFE FCF8 F9F7 F8F7 F7F8" /* ���������������� */ $"56FD F920 F8F7 F9F9 56F8 5656 F9F8 8156" /* V�� ����V�VV���V */ $"F8F9 81FC FEF8 56F9 56F9 F8F8 56FA 56F9" /* ������V�V���V�V� */ $"56F9 5656 F7FE 567F F8F8 5656 F856 56F8" /* V�VV��V.��VV�VV� */ $"F756 56F9 FBFC ACFD FEFF FDFD FCFA F9AC" /* �VV������������� */ $"FBF9 FEFD FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 7FFE E0FE E0FE E0FE" /* ��������.������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E0FE E0FE E0FE E0FE" /* ���������������� */ $"E0FE E0FE E0FE E0FE E039 FEE0 FEE0 FEE0" /* ���������9������ */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0 FEE0" /* ���������������� */ $"FEE0 FEE0 00A0 0083 00FF" /* ����.�.�.� */ }; \ No newline at end of file diff --git a/SerialHelper.c b/SerialHelper.c new file mode 100644 index 0000000..f21a06d --- /dev/null +++ b/SerialHelper.c @@ -0,0 +1,60 @@ +#include "SerialHelper.h" +#include "stdio.h" + +/* +Read more: http://stason.org/TULARC/os-macintosh/programming/7-1-How-do-I-get-at-the-serial-ports-Communications-and-N.html#ixzz4cIxU3Tob + +Serial implementation: + +https://opensource.apple.com/source/gdb/gdb-186.1/src/gdb/ser-mac.c?txt +http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/Devices/Devices-320.html +*/ +OSErr writeSerialPortDebug(short refNum, const char* str) +{ +#define MODEM_PORT_OUT "\p.AOut" +#define PRINTER_PORT_OUT "\p.BOut" + // OSErr err; + // return err; + + const char* nameStr = ""; + switch (refNum) + { + case aoutRefNum: + nameStr = MODEM_PORT_OUT; + break; + case boutRefNum: + nameStr = PRINTER_PORT_OUT; + break; + + default: + return -1; + } + + OSErr err; + short serialPort = 0; + err = OpenDriver(nameStr, &serialPort); + if (err < 0) return err; + + CntrlParam cb2; + cb2.ioCRefNum = serialPort; + cb2.csCode = 8; + cb2.csParam[0] = stop10 | noParity | data8 | baud9600; + err = PBControl ((ParmBlkPtr) & cb2, 0); + if (err < 0) return err; + + IOParam pb2; + pb2.ioRefNum = serialPort; + + char str2[255]; + sprintf(str2, "%s\n", str); + pb2.ioBuffer = (Ptr) str2; + pb2.ioReqCount = strlen(str2); + + err = PBWrite((ParmBlkPtr)& pb2, 0); + if (err < 0) return err; + + // hangs on Mac512K (write hasn't finished due to slow Speed when we wants to close driver + // err = CloseDriver(serialPort); + + return err; +} \ No newline at end of file diff --git a/SerialHelper.h b/SerialHelper.h new file mode 100644 index 0000000..a9a85eb --- /dev/null +++ b/SerialHelper.h @@ -0,0 +1,6 @@ +#include +#include +#include +#include + +OSErr writeSerialPortDebug(short refNum, const char* str); \ No newline at end of file diff --git a/build/%NuklearQuickDraw.ad b/build/%NuklearQuickDraw.ad new file mode 100644 index 0000000..0eda112 Binary files /dev/null and b/build/%NuklearQuickDraw.ad differ diff --git a/build/.finf/NuklearQuickDraw.APPL b/build/.finf/NuklearQuickDraw.APPL new file mode 100644 index 0000000..6d687eb Binary files /dev/null and b/build/.finf/NuklearQuickDraw.APPL differ diff --git a/build/.rsrc/NuklearQuickDraw.APPL b/build/.rsrc/NuklearQuickDraw.APPL new file mode 100644 index 0000000..05a8fad Binary files /dev/null and b/build/.rsrc/NuklearQuickDraw.APPL differ diff --git a/build/CMakeCache.txt b/build/CMakeCache.txt new file mode 100644 index 0000000..1501b82 --- /dev/null +++ b/build/CMakeCache.txt @@ -0,0 +1,360 @@ +# This is the CMakeCache file. +# For build in directory: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ar + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ranlib + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_C_COMPILER_AR:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ar + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_C_COMPILER_RANLIB:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ranlib + +//Flags used by the C compiler during all build types. +CMAKE_C_FLAGS:STRING= + +//Flags used by the C compiler during DEBUG builds. +CMAKE_C_FLAGS_DEBUG:STRING=-g + +//Flags used by the C compiler during MINSIZEREL builds. +CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the C compiler during RELEASE builds. +CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the C compiler during RELWITHDEBINFO builds. +CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF + +//installation prefix +CMAKE_INSTALL_PREFIX:PATH=/home/camh/Retro68-build/toolchain/m68k-apple-macos + +//Path to a program. +CMAKE_LINKER:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-objdump + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=Project + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-strip + +//The CMake toolchain file +CMAKE_TOOLCHAIN_FILE:FILEPATH=/home/camh/Retro68-build/toolchain/m68k-apple-macos/cmake/retro68.toolchain.cmake + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Value Computed by CMake +Project_BINARY_DIR:STATIC=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build + +//Value Computed by CMake +Project_SOURCE_DIR:STATIC=/home/camh/Documents/Retro68kApps/NuklearQuickDraw + +//path to root of Retro68 Toolchain +RETRO68_ROOT:PATH=/home/camh/Retro68-build/toolchain + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=16 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER_AR +CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB +CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS +CMAKE_C_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG +CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL +CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE +CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO +CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/camh/Documents/Retro68kApps/NuklearQuickDraw +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.16 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 + diff --git a/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake b/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake new file mode 100644 index 0000000..70fedf4 --- /dev/null +++ b/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake @@ -0,0 +1,76 @@ +set(CMAKE_C_COMPILER "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc") +set(CMAKE_C_COMPILER_ARG1 "") +set(CMAKE_C_COMPILER_ID "GNU") +set(CMAKE_C_COMPILER_VERSION "9.1.0") +set(CMAKE_C_COMPILER_VERSION_INTERNAL "") +set(CMAKE_C_COMPILER_WRAPPER "") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11") +set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert") +set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes") +set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros") +set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert") + +set(CMAKE_C_PLATFORM_ID "") +set(CMAKE_C_SIMULATE_ID "") +set(CMAKE_C_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_C_SIMULATE_VERSION "") + + + +set(CMAKE_AR "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ar") +set(CMAKE_C_COMPILER_AR "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ar") +set(CMAKE_RANLIB "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ranlib") +set(CMAKE_C_COMPILER_RANLIB "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ranlib") +set(CMAKE_LINKER "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ld") +set(CMAKE_MT "") +set(CMAKE_COMPILER_IS_GNUCC 1) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS TRUE) +set(CMAKE_C_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "") +set(CMAKE_C_COMPILER_ABI "") +set(CMAKE_C_LIBRARY_ARCHITECTURE "") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include") +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;c;retrocrt;Interface") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake b/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..9018db8 --- /dev/null +++ b/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake @@ -0,0 +1,88 @@ +set(CMAKE_CXX_COMPILER "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "9.1.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") + +set(CMAKE_CXX_PLATFORM_ID "") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + +set(CMAKE_AR "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ar") +set(CMAKE_CXX_COMPILER_AR "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ar") +set(CMAKE_RANLIB "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc-ranlib") +set(CMAKE_LINKER "/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-ld") +set(CMAKE_MT "") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "") +set(CMAKE_CXX_COMPILER_ABI "") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/backward;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc;c;retrocrt;Interface") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin b/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin new file mode 100644 index 0000000..e69de29 diff --git a/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin b/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin new file mode 100644 index 0000000..e69de29 diff --git a/build/CMakeFiles/3.16.3/CMakeSystem.cmake b/build/CMakeFiles/3.16.3/CMakeSystem.cmake new file mode 100644 index 0000000..6968466 --- /dev/null +++ b/build/CMakeFiles/3.16.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-5.11.0-27-generic") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "5.11.0-27-generic") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + +include("/home/camh/Retro68-build/toolchain/m68k-apple-macos/cmake/retro68.toolchain.cmake") + +set(CMAKE_SYSTEM "Retro68-1") +set(CMAKE_SYSTEM_NAME "Retro68") +set(CMAKE_SYSTEM_VERSION "1") +set(CMAKE_SYSTEM_PROCESSOR "") + +set(CMAKE_CROSSCOMPILING "TRUE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/build/CMakeFiles/3.16.3/CompilerIdC/.finf/a.out b/build/CMakeFiles/3.16.3/CompilerIdC/.finf/a.out new file mode 100644 index 0000000..6d687eb Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdC/.finf/a.out differ diff --git a/build/CMakeFiles/3.16.3/CompilerIdC/.rsrc/a.out b/build/CMakeFiles/3.16.3/CompilerIdC/.rsrc/a.out new file mode 100644 index 0000000..ba2a2f3 Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdC/.rsrc/a.out differ diff --git a/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c b/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c new file mode 100644 index 0000000..d884b50 --- /dev/null +++ b/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c @@ -0,0 +1,671 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#if defined(__18CXX) +# define ID_VOID_MAIN +#endif +#if defined(__CLASSIC_C__) +/* cv-qualifiers did not exist in K&R C */ +# define const +# define volatile +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_C) +# define COMPILER_ID "SunPro" +# if __SUNPRO_C >= 0x5100 + /* __SUNPRO_C = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# endif + +#elif defined(__HP_cc) +# define COMPILER_ID "HP" + /* __HP_cc = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100) + +#elif defined(__DECC) +# define COMPILER_ID "Compaq" + /* __DECC_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000) + +#elif defined(__IBMC__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800 +# define COMPILER_ID "XL" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TINYC__) +# define COMPILER_ID "TinyCC" + +#elif defined(__BCC__) +# define COMPILER_ID "Bruce" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + +#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC) +# define COMPILER_ID "SDCC" +# if defined(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR) +# define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH) +# else + /* SDCC = VRP */ +# define COMPILER_VERSION_MAJOR DEC(SDCC/100) +# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10) +# define COMPILER_VERSION_PATCH DEC(SDCC % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +#if !defined(__STDC__) +# if (defined(_MSC_VER) && !defined(__clang__)) \ + || (defined(__ibmxl__) || defined(__IBMC__)) +# define C_DIALECT "90" +# else +# define C_DIALECT +# endif +#elif __STDC_VERSION__ >= 201000L +# define C_DIALECT "11" +#elif __STDC_VERSION__ >= 199901L +# define C_DIALECT "99" +#else +# define C_DIALECT "90" +#endif +const char* info_language_dialect_default = + "INFO" ":" "dialect_default[" C_DIALECT "]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +# if defined(__CLASSIC_C__) +int main(argc, argv) int argc; char *argv[]; +# else +int main(int argc, char* argv[]) +# endif +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/build/CMakeFiles/3.16.3/CompilerIdC/a.out b/build/CMakeFiles/3.16.3/CompilerIdC/a.out new file mode 100644 index 0000000..e69de29 diff --git a/build/CMakeFiles/3.16.3/CompilerIdC/a.out.gdb b/build/CMakeFiles/3.16.3/CompilerIdC/a.out.gdb new file mode 100755 index 0000000..28a13e7 Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdC/a.out.gdb differ diff --git a/build/CMakeFiles/3.16.3/CompilerIdCXX/.finf/a.out b/build/CMakeFiles/3.16.3/CompilerIdCXX/.finf/a.out new file mode 100644 index 0000000..6d687eb Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdCXX/.finf/a.out differ diff --git a/build/CMakeFiles/3.16.3/CompilerIdCXX/.rsrc/a.out b/build/CMakeFiles/3.16.3/CompilerIdCXX/.rsrc/a.out new file mode 100644 index 0000000..b1abdf8 Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdCXX/.rsrc/a.out differ diff --git a/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..69cfdba --- /dev/null +++ b/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,660 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__COMO__) +# define COMPILER_ID "Comeau" + /* __COMO_VERSION__ = VRR */ +# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100) +# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100) + +#elif defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L +# if defined(__INTEL_CXX11_MODE__) +# if defined(__cpp_aggregate_nsdmi) +# define CXX_STD 201402L +# else +# define CXX_STD 201103L +# endif +# else +# define CXX_STD 199711L +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# define CXX_STD _MSVC_LANG +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if CXX_STD > 201703L + "20" +#elif CXX_STD >= 201703L + "17" +#elif CXX_STD >= 201402L + "14" +#elif CXX_STD >= 201103L + "11" +#else + "98" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out b/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out new file mode 100644 index 0000000..e69de29 diff --git a/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out.gdb b/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out.gdb new file mode 100755 index 0000000..4f1f132 Binary files /dev/null and b/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out.gdb differ diff --git a/build/CMakeFiles/CMakeDirectoryInformation.cmake b/build/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000..cb19425 --- /dev/null +++ b/build/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/camh/Documents/Retro68kApps/NuklearQuickDraw") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/build/CMakeFiles/CMakeError.log b/build/CMakeFiles/CMakeError.log new file mode 100644 index 0000000..6c0b15a --- /dev/null +++ b/build/CMakeFiles/CMakeError.log @@ -0,0 +1,4 @@ +The C compiler identification could not be found in "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/3.16.3/CompilerIdC/a.out" + +The CXX compiler identification could not be found in "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out" + diff --git a/build/CMakeFiles/CMakeOutput.log b/build/CMakeFiles/CMakeOutput.log new file mode 100644 index 0000000..91bb6eb --- /dev/null +++ b/build/CMakeFiles/CMakeOutput.log @@ -0,0 +1,364 @@ +The target system is: Retro68 - 1 - +The host system is: Linux - 5.11.0-27-generic - x86_64 +Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded. +Compiler: /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc +Build flags: +Id flags: + +The output was: +0 + + +Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out" + +Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out.gdb" + +The C compiler identification is GNU, found in "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/3.16.3/CompilerIdC/a.out.gdb" + +Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. +Compiler: /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ +Build flags: +Id flags: + +The output was: +0 + + +Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + +Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out.gdb" + +The CXX compiler identification is GNU, found in "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out.gdb" + +Determining if the C compiler works passed with the following output: +Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_d1773/fast && /usr/bin/make -f CMakeFiles/cmTC_d1773.dir/build.make CMakeFiles/cmTC_d1773.dir/build +make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_d1773.dir/testCCompiler.c.obj +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc -o CMakeFiles/cmTC_d1773.dir/testCCompiler.c.obj -c /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp/testCCompiler.c +Linking C executable cmTC_d1773 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_d1773.dir/link.txt --verbose=1 +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc CMakeFiles/cmTC_d1773.dir/testCCompiler.c.obj -o cmTC_d1773 +make[1]: Leaving directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' + + + +Detecting C compiler ABI info compiled with the following output: +Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_11e88/fast && /usr/bin/make -f CMakeFiles/cmTC_11e88.dir/build.make CMakeFiles/cmTC_11e88.dir/build +make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc -v -o CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c +Using built-in specs. +COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc +Target: m68k-apple-macos +Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c,c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing +Thread model: single +gcc version 9.1.0 (GCC) +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/cc1 -quiet -v -Wno-trigraphs /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mcpu=68000 -auxbase-strip CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -version -o /tmp/cccxFRbw.s +GNU C17 (GCC) version 9.1.0 (m68k-apple-macos) + compiled by GNU C version 9.3.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version none +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +ignoring nonexistent directory "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/sys-include" +#include "..." search starts here: +#include <...> search starts here: + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include +End of search list. +GNU C17 (GCC) version 9.1.0 (m68k-apple-macos) + compiled by GNU C version 9.3.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version none +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +Compiler executable checksum: 68baab70957df643ffb4605a09112146 +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/as -mcpu=68000 -o CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj /tmp/cccxFRbw.s +COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/ +LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000' +Linking C executable cmTC_11e88 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_11e88.dir/link.txt --verbose=1 +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc -v CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -o cmTC_11e88 +Using built-in specs. +COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc +COLLECT_LTO_WRAPPER=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper +Target: m68k-apple-macos +Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c,c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing +Thread model: single +gcc version 9.1.0 (GCC) +COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/ +LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_11e88' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2 -plugin /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so -plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper -plugin-opt=-fresolution=/tmp/ccZtAb32.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lretrocrt -plugin-opt=-pass-through=-lInterface -elf2mac -q -undefined=_consolewrite -o cmTC_11e88 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj --start-group -lgcc -lc -lretrocrt -lInterface --end-group +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_11e88' '-mcpu=68000' +make[1]: Leaving directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' + + + +Parsed C implicit include dir info from above output: rv=done + found start of include info + found start of implicit include info + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] + end of search list found + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include] + implicit include dirs: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include] + + +Parsed C implicit link information from above output: + link line regex: [^( *|.*[/\])(m68k-apple-macos-ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command(s):/usr/bin/make cmTC_11e88/fast && /usr/bin/make -f CMakeFiles/cmTC_11e88.dir/build.make CMakeFiles/cmTC_11e88.dir/build] + ignore line: [make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp'] + ignore line: [Building C object CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj] + ignore line: [/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc -v -o CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc] + ignore line: [Target: m68k-apple-macos] + ignore line: [Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing] + ignore line: [Thread model: single] + ignore line: [gcc version 9.1.0 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000'] + ignore line: [ /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/cc1 -quiet -v -Wno-trigraphs /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mcpu=68000 -auxbase-strip CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -version -o /tmp/cccxFRbw.s] + ignore line: [GNU C17 (GCC) version 9.1.0 (m68k-apple-macos)] + ignore line: [ compiled by GNU C version 9.3.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version none] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/sys-include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] + ignore line: [End of search list.] + ignore line: [GNU C17 (GCC) version 9.1.0 (m68k-apple-macos)] + ignore line: [ compiled by GNU C version 9.3.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version none] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 68baab70957df643ffb4605a09112146] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000'] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/as -mcpu=68000 -o CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj /tmp/cccxFRbw.s] + ignore line: [COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/] + ignore line: [LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj' '-c' '-mcpu=68000'] + ignore line: [Linking C executable cmTC_11e88] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_11e88.dir/link.txt --verbose=1] + ignore line: [/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc -v CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj -o cmTC_11e88 ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc] + ignore line: [COLLECT_LTO_WRAPPER=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper] + ignore line: [Target: m68k-apple-macos] + ignore line: [Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing] + ignore line: [Thread model: single] + ignore line: [gcc version 9.1.0 (GCC) ] + ignore line: [COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/] + ignore line: [LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_11e88' '-mcpu=68000'] + link line: [ /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2 -plugin /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so -plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper -plugin-opt=-fresolution=/tmp/ccZtAb32.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lretrocrt -plugin-opt=-pass-through=-lInterface -elf2mac -q -undefined=_consolewrite -o cmTC_11e88 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj --start-group -lgcc -lc -lretrocrt -lInterface --end-group] + arg [/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccZtAb32.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lretrocrt] ==> ignore + arg [-plugin-opt=-pass-through=-lInterface] ==> ignore + arg [-elf2mac] ==> ignore + arg [-q] ==> ignore + arg [-undefined=_consolewrite] ==> ignore + arg [-o] ==> ignore + arg [cmTC_11e88] ==> ignore + arg [-L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] ==> dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] + arg [-L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] ==> dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] + arg [CMakeFiles/cmTC_11e88.dir/CMakeCCompilerABI.c.obj] ==> ignore + arg [--start-group] ==> ignore + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lretrocrt] ==> lib [retrocrt] + arg [-lInterface] ==> lib [Interface] + arg [--end-group] ==> ignore + collapse library dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] + collapse library dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib] + implicit libs: [gcc;c;retrocrt;Interface] + implicit dirs: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib] + implicit fwks: [] + + +Determining if the CXX compiler works passed with the following output: +Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_171bc/fast && /usr/bin/make -f CMakeFiles/cmTC_171bc.dir/build.make CMakeFiles/cmTC_171bc.dir/build +make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_171bc.dir/testCXXCompiler.cxx.obj +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ -o CMakeFiles/cmTC_171bc.dir/testCXXCompiler.cxx.obj -c /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp/testCXXCompiler.cxx +Linking CXX executable cmTC_171bc +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_171bc.dir/link.txt --verbose=1 +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ CMakeFiles/cmTC_171bc.dir/testCXXCompiler.cxx.obj -o cmTC_171bc +make[1]: Leaving directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' + + + +Detecting CXX compiler ABI info compiled with the following output: +Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_7a831/fast && /usr/bin/make -f CMakeFiles/cmTC_7a831.dir/build.make CMakeFiles/cmTC_7a831.dir/build +make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ -v -o CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp +Using built-in specs. +COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ +Target: m68k-apple-macos +Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c,c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing +Thread model: single +gcc version 9.1.0 (GCC) +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/cc1plus -quiet -v -Wno-trigraphs /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mcpu=68000 -auxbase-strip CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -version -o /tmp/ccCyFETM.s +GNU C++14 (GCC) version 9.1.0 (m68k-apple-macos) + compiled by GNU C version 9.3.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version none +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +ignoring nonexistent directory "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/sys-include" +#include "..." search starts here: +#include <...> search starts here: + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0 + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/backward + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include +End of search list. +GNU C++14 (GCC) version 9.1.0 (m68k-apple-macos) + compiled by GNU C version 9.3.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version none +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +Compiler executable checksum: 5b31867a30cfa7e65d4bce12c39f8a21 +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/as -mcpu=68000 -o CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj /tmp/ccCyFETM.s +COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/ +LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000' +Linking CXX executable cmTC_7a831 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_7a831.dir/link.txt --verbose=1 +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ -v CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -o cmTC_7a831 +Using built-in specs. +COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ +COLLECT_LTO_WRAPPER=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper +Target: m68k-apple-macos +Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c,c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing +Thread model: single +gcc version 9.1.0 (GCC) +COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/ +LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7a831' '-mcpu=68000' + /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2 -plugin /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so -plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper -plugin-opt=-fresolution=/tmp/ccCvfKei.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lretrocrt -plugin-opt=-pass-through=-lInterface -elf2mac -q -undefined=_consolewrite -o cmTC_7a831 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -lstdc++ -lm --start-group -lgcc -lc -lretrocrt -lInterface --end-group +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7a831' '-mcpu=68000' +make[1]: Leaving directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp' + + + +Parsed CXX implicit include dir info from above output: rv=done + found start of include info + found start of implicit include info + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/backward] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + add: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] + end of search list found + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/backward] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/backward] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + collapse include dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include] + implicit include dirs: [/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include/c++/9.1.0/backward;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include;/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed;/home/camh/Retro68-build/toolchain/m68k-apple-macos/include] + + +Parsed CXX implicit link information from above output: + link line regex: [^( *|.*[/\])(m68k-apple-macos-ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command(s):/usr/bin/make cmTC_7a831/fast && /usr/bin/make -f CMakeFiles/cmTC_7a831.dir/build.make CMakeFiles/cmTC_7a831.dir/build] + ignore line: [make[1]: Entering directory '/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/CMakeTmp'] + ignore line: [Building CXX object CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj] + ignore line: [/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ -v -o CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++] + ignore line: [Target: m68k-apple-macos] + ignore line: [Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing] + ignore line: [Thread model: single] + ignore line: [gcc version 9.1.0 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000'] + ignore line: [ /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/cc1plus -quiet -v -Wno-trigraphs /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mcpu=68000 -auxbase-strip CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -version -o /tmp/ccCyFETM.s] + ignore line: [GNU C++14 (GCC) version 9.1.0 (m68k-apple-macos)] + ignore line: [ compiled by GNU C version 9.3.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version none] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/sys-include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/m68k-apple-macos] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include/c++/9.1.0/backward] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/include-fixed] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/include] + ignore line: [End of search list.] + ignore line: [GNU C++14 (GCC) version 9.1.0 (m68k-apple-macos)] + ignore line: [ compiled by GNU C version 9.3.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version none] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 5b31867a30cfa7e65d4bce12c39f8a21] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000'] + ignore line: [ /home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/as -mcpu=68000 -o CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj /tmp/ccCyFETM.s] + ignore line: [COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/] + ignore line: [LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj' '-c' '-mcpu=68000'] + ignore line: [Linking CXX executable cmTC_7a831] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_7a831.dir/link.txt --verbose=1] + ignore line: [/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++ -v CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -o cmTC_7a831 ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-g++] + ignore line: [COLLECT_LTO_WRAPPER=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper] + ignore line: [Target: m68k-apple-macos] + ignore line: [Configured with: /home/camh/Retro68/gcc/configure --target=m68k-apple-macos --prefix=/home/camh/Retro68-build/toolchain/ --enable-languages=c c++ --with-arch=m68k --with-cpu=m68000 --disable-libssp MAKEINFO=missing] + ignore line: [Thread model: single] + ignore line: [gcc version 9.1.0 (GCC) ] + ignore line: [COMPILER_PATH=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/bin/] + ignore line: [LIBRARY_PATH=/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/:/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7a831' '-mcpu=68000'] + link line: [ /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2 -plugin /home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so -plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper -plugin-opt=-fresolution=/tmp/ccCvfKei.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lretrocrt -plugin-opt=-pass-through=-lInterface -elf2mac -q -undefined=_consolewrite -o cmTC_7a831 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0 -L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj -lstdc++ -lm --start-group -lgcc -lc -lretrocrt -lInterface --end-group] + arg [/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/home/camh/Retro68-build/toolchain/libexec/gcc/m68k-apple-macos/9.1.0/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccCvfKei.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lretrocrt] ==> ignore + arg [-plugin-opt=-pass-through=-lInterface] ==> ignore + arg [-elf2mac] ==> ignore + arg [-q] ==> ignore + arg [-undefined=_consolewrite] ==> ignore + arg [-o] ==> ignore + arg [cmTC_7a831] ==> ignore + arg [-L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] ==> dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] + arg [-L/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] ==> dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] + arg [CMakeFiles/cmTC_7a831.dir/CMakeCXXCompilerABI.cpp.obj] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [--start-group] ==> ignore + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lretrocrt] ==> lib [retrocrt] + arg [-lInterface] ==> lib [Interface] + arg [--end-group] ==> ignore + collapse library dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] ==> [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0] + collapse library dir [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0/../../../../m68k-apple-macos/lib] ==> [/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib] + implicit libs: [stdc++;m;gcc;c;retrocrt;Interface] + implicit dirs: [/home/camh/Retro68-build/toolchain/lib/gcc/m68k-apple-macos/9.1.0;/home/camh/Retro68-build/toolchain/m68k-apple-macos/lib] + implicit fwks: [] + + diff --git a/build/CMakeFiles/CMakeRuleHashes.txt b/build/CMakeFiles/CMakeRuleHashes.txt new file mode 100644 index 0000000..cdaa29a --- /dev/null +++ b/build/CMakeFiles/CMakeRuleHashes.txt @@ -0,0 +1,4 @@ +# Hashes of file build rules. +8ffde4ac1cdc1218469a04ac02fc18d8 CMakeFiles/NuklearQuickDraw_APPL +329185643b4f6900eadfaea9a548f63a NuklearQuickDraw.bin +91b2346eaa6612a55994cce77404dcb4 Sample.r.rsrc.bin diff --git a/build/CMakeFiles/Makefile.cmake b/build/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000..1a7279e --- /dev/null +++ b/build/CMakeFiles/Makefile.cmake @@ -0,0 +1,119 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "../CMakeLists.txt" + "CMakeFiles/3.16.3/CMakeCCompiler.cmake" + "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake" + "CMakeFiles/3.16.3/CMakeSystem.cmake" + "/home/camh/Retro68-build/toolchain/m68k-apple-macos/cmake/Platform/Retro68.cmake" + "/home/camh/Retro68-build/toolchain/m68k-apple-macos/cmake/add_application.cmake" + "/home/camh/Retro68-build/toolchain/m68k-apple-macos/cmake/retro68.toolchain.cmake" + "/usr/share/cmake-3.16/Modules/CMakeCCompiler.cmake.in" + "/usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c" + "/usr/share/cmake-3.16/Modules/CMakeCInformation.cmake" + "/usr/share/cmake-3.16/Modules/CMakeCXXCompiler.cmake.in" + "/usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp" + "/usr/share/cmake-3.16/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake-3.16/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake" + "/usr/share/cmake-3.16/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake-3.16/Modules/CMakeCompilerIdDetection.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCCompiler.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCXXCompiler.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCompileFeatures.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerABI.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerId.cmake" + "/usr/share/cmake-3.16/Modules/CMakeDetermineSystem.cmake" + "/usr/share/cmake-3.16/Modules/CMakeFindBinUtils.cmake" + "/usr/share/cmake-3.16/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake-3.16/Modules/CMakeInitializeConfigs.cmake" + "/usr/share/cmake-3.16/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake-3.16/Modules/CMakeParseArguments.cmake" + "/usr/share/cmake-3.16/Modules/CMakeParseImplicitIncludeInfo.cmake" + "/usr/share/cmake-3.16/Modules/CMakeParseImplicitLinkInfo.cmake" + "/usr/share/cmake-3.16/Modules/CMakeSystem.cmake.in" + "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake-3.16/Modules/CMakeTestCCompiler.cmake" + "/usr/share/cmake-3.16/Modules/CMakeTestCXXCompiler.cmake" + "/usr/share/cmake-3.16/Modules/CMakeTestCompilerCommon.cmake" + "/usr/share/cmake-3.16/Modules/CMakeUnixFindMake.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/ADSP-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/ARMClang-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Borland-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Bruce-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Compaq-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Cray-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GHS-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU-C.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU-FindBinUtils.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/GNU.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/HP-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/IAR-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Intel-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/MSVC-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/NVIDIA-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/PGI-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/PathScale-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/SCO-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/SDCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/SunPro-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/TI-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/Watcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/XL-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/XLClang-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/zOS-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.16/Modules/Internal/CMakeCheckCompilerFlag.cmake" + "/usr/share/cmake-3.16/Modules/Internal/FeatureTesting.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/3.16.3/CMakeSystem.cmake" + "CMakeFiles/3.16.3/CMakeCCompiler.cmake" + "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake" + "CMakeFiles/3.16.3/CMakeCCompiler.cmake" + "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake" + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/NuklearQuickDraw_APPL.dir/DependInfo.cmake" + "CMakeFiles/NuklearQuickDraw.dir/DependInfo.cmake" + ) diff --git a/build/CMakeFiles/Makefile2 b/build/CMakeFiles/Makefile2 new file mode 100644 index 0000000..9ea45ed --- /dev/null +++ b/build/CMakeFiles/Makefile2 @@ -0,0 +1,135 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/NuklearQuickDraw_APPL.dir/all +all: CMakeFiles/NuklearQuickDraw.dir/all + +.PHONY : all + +# The main recursive "preinstall" target. +preinstall: + +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/NuklearQuickDraw_APPL.dir/clean +clean: CMakeFiles/NuklearQuickDraw.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target CMakeFiles/NuklearQuickDraw_APPL.dir + +# All Build rule for target. +CMakeFiles/NuklearQuickDraw_APPL.dir/all: CMakeFiles/NuklearQuickDraw.dir/all + $(MAKE) -f CMakeFiles/NuklearQuickDraw_APPL.dir/build.make CMakeFiles/NuklearQuickDraw_APPL.dir/depend + $(MAKE) -f CMakeFiles/NuklearQuickDraw_APPL.dir/build.make CMakeFiles/NuklearQuickDraw_APPL.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=5,6 "Built target NuklearQuickDraw_APPL" +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/NuklearQuickDraw_APPL.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles 6 + $(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/NuklearQuickDraw_APPL.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles 0 +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/rule + +# Convenience name for target. +NuklearQuickDraw_APPL: CMakeFiles/NuklearQuickDraw_APPL.dir/rule + +.PHONY : NuklearQuickDraw_APPL + +# clean rule for target. +CMakeFiles/NuklearQuickDraw_APPL.dir/clean: + $(MAKE) -f CMakeFiles/NuklearQuickDraw_APPL.dir/build.make CMakeFiles/NuklearQuickDraw_APPL.dir/clean +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/NuklearQuickDraw.dir + +# All Build rule for target. +CMakeFiles/NuklearQuickDraw.dir/all: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/depend + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=1,2,3,4 "Built target NuklearQuickDraw" +.PHONY : CMakeFiles/NuklearQuickDraw.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/NuklearQuickDraw.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles 4 + $(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/NuklearQuickDraw.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles 0 +.PHONY : CMakeFiles/NuklearQuickDraw.dir/rule + +# Convenience name for target. +NuklearQuickDraw: CMakeFiles/NuklearQuickDraw.dir/rule + +.PHONY : NuklearQuickDraw + +# clean rule for target. +CMakeFiles/NuklearQuickDraw.dir/clean: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/clean +.PHONY : CMakeFiles/NuklearQuickDraw.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/C.includecache b/build/CMakeFiles/NuklearQuickDraw.dir/C.includecache new file mode 100644 index 0000000..d53fe8a --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/C.includecache @@ -0,0 +1,178 @@ +#IncludeRegexLine: ^[ ]*[#%][ ]*(include|import)[ ]*[<"]([^">]+)([">]) + +#IncludeRegexScan: ^.*$ + +#IncludeRegexComplain: ^$ + +#IncludeRegexTransform: + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c +Types.h +- +Resources.h +- +Quickdraw.h +- +Fonts.h +- +Events.h +- +Windows.h +- +Menus.h +- +TextEdit.h +- +Dialogs.h +- +ToolUtils.h +- +Memory.h +- +SegLoad.h +- +Files.h +- +OSUtils.h +- +DiskInit.h +- +Packages.h +- +Traps.h +- +Serial.h +- +Devices.h +- +stdio.h +- +string.h +- +Sample.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.h +SerialHelper.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h +Quickdraw.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/Quickdraw.h +output_js.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/output_js.h +coprocessorjs.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.h +limits.h +- +time.h +- +math.h +- +nuklear.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear.h +nuklear_quickdraw.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear_quickdraw.h +overview.c +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/overview.c + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c +SerialHelper.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h +stdio.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/stdio.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h +Serial.h +- +Devices.h +- +stdio.h +- +string.h +- + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c +stdio.h +- +Serial.h +- +math.h +- +Devices.h +- +string.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/string.h +stdbool.h +- +time.h +- +SerialHelper.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h +coprocessorjs.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear.h +stdarg.h +- +sal.h +- +stdint.h +- +stdbool.h +- +stdlib.h +- +stdio.h +- +stdarg.h +- +assert.h +- +stdlib.h +- +assert.h +- +stb_truetype.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/stb_truetype.h +stdio.h +- +stb_truetype.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/stb_truetype.h +math.h +- +math.h +- +math.h +- +math.h +- +math.h +- +stdlib.h +- +assert.h +- +string.h +- +string.h +- + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear_quickdraw.h +MacTypes.h +- +Types.h +- +Quickdraw.h +- +Scrap.h +- +Serial.h +- +SerialHelper.h +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/output_js.h + +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/overview.c + diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/DependInfo.cmake b/build/CMakeFiles/NuklearQuickDraw.dir/DependInfo.cmake new file mode 100644 index 0000000..d5c9ed1 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj" + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj" + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj b/build/CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj new file mode 100644 index 0000000..13728b0 Binary files /dev/null and b/build/CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj differ diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj b/build/CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj new file mode 100644 index 0000000..180f856 Binary files /dev/null and b/build/CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj differ diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/build.make b/build/CMakeFiles/NuklearQuickDraw.dir/build.make new file mode 100644 index 0000000..e16b342 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/build.make @@ -0,0 +1,128 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build + +# Include any dependencies generated for this target. +include CMakeFiles/NuklearQuickDraw.dir/depend.make + +# Include the progress variables for this target. +include CMakeFiles/NuklearQuickDraw.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/NuklearQuickDraw.dir/flags.make + +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj: CMakeFiles/NuklearQuickDraw.dir/flags.make +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj: ../SerialHelper.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj -c /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c + +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.i" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c > CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.i + +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.s" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c -o CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.s + +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj: CMakeFiles/NuklearQuickDraw.dir/flags.make +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj: ../coprocessorjs.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building C object CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj -c /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c + +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.i" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c > CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.i + +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.s" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c -o CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.s + +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: CMakeFiles/NuklearQuickDraw.dir/flags.make +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../Sample.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building C object CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj -c /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c + +CMakeFiles/NuklearQuickDraw.dir/Sample.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/NuklearQuickDraw.dir/Sample.c.i" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c > CMakeFiles/NuklearQuickDraw.dir/Sample.c.i + +CMakeFiles/NuklearQuickDraw.dir/Sample.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/NuklearQuickDraw.dir/Sample.c.s" + /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c -o CMakeFiles/NuklearQuickDraw.dir/Sample.c.s + +# Object files for target NuklearQuickDraw +NuklearQuickDraw_OBJECTS = \ +"CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj" \ +"CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj" \ +"CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj" + +# External object files for target NuklearQuickDraw +NuklearQuickDraw_EXTERNAL_OBJECTS = + +NuklearQuickDraw.code.bin: CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj +NuklearQuickDraw.code.bin: CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj +NuklearQuickDraw.code.bin: CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj +NuklearQuickDraw.code.bin: CMakeFiles/NuklearQuickDraw.dir/build.make +NuklearQuickDraw.code.bin: CMakeFiles/NuklearQuickDraw.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking C executable NuklearQuickDraw.code.bin" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/NuklearQuickDraw.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/NuklearQuickDraw.dir/build: NuklearQuickDraw.code.bin + +.PHONY : CMakeFiles/NuklearQuickDraw.dir/build + +CMakeFiles/NuklearQuickDraw.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/NuklearQuickDraw.dir/cmake_clean.cmake +.PHONY : CMakeFiles/NuklearQuickDraw.dir/clean + +CMakeFiles/NuklearQuickDraw.dir/depend: + cd /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/camh/Documents/Retro68kApps/NuklearQuickDraw /home/camh/Documents/Retro68kApps/NuklearQuickDraw /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : CMakeFiles/NuklearQuickDraw.dir/depend + diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/cmake_clean.cmake b/build/CMakeFiles/NuklearQuickDraw.dir/cmake_clean.cmake new file mode 100644 index 0000000..3e269c8 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/cmake_clean.cmake @@ -0,0 +1,12 @@ +file(REMOVE_RECURSE + "CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj" + "CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj" + "CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj" + "NuklearQuickDraw.code.bin" + "NuklearQuickDraw.code.bin.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/NuklearQuickDraw.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj b/build/CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj new file mode 100644 index 0000000..8d234fc Binary files /dev/null and b/build/CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj differ diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/depend.internal b/build/CMakeFiles/NuklearQuickDraw.dir/depend.internal new file mode 100644 index 0000000..37a8128 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/depend.internal @@ -0,0 +1,19 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.c + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/nuklear_quickdraw.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/output_js.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/overview.c +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.c + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/SerialHelper.h + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.c + /home/camh/Documents/Retro68kApps/NuklearQuickDraw/coprocessorjs.h diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/depend.make b/build/CMakeFiles/NuklearQuickDraw.dir/depend.make new file mode 100644 index 0000000..3c7b42a --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/depend.make @@ -0,0 +1,19 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../Sample.c +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../Sample.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../SerialHelper.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../coprocessorjs.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../nuklear.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../nuklear_quickdraw.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../output_js.h +CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj: ../overview.c + +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj: ../SerialHelper.c +CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj: ../SerialHelper.h + +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj: ../SerialHelper.h +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj: ../coprocessorjs.c +CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj: ../coprocessorjs.h + diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/flags.make b/build/CMakeFiles/NuklearQuickDraw.dir/flags.make new file mode 100644 index 0000000..cf8207c --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# compile C with /home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc +C_FLAGS = + +C_DEFINES = + +C_INCLUDES = + diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/link.txt b/build/CMakeFiles/NuklearQuickDraw.dir/link.txt new file mode 100644 index 0000000..f1afeca --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/link.txt @@ -0,0 +1 @@ +/home/camh/Retro68-build/toolchain/bin/m68k-apple-macos-gcc CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj -o NuklearQuickDraw.code.bin diff --git a/build/CMakeFiles/NuklearQuickDraw.dir/progress.make b/build/CMakeFiles/NuklearQuickDraw.dir/progress.make new file mode 100644 index 0000000..a69a57e --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw.dir/progress.make @@ -0,0 +1,5 @@ +CMAKE_PROGRESS_1 = 1 +CMAKE_PROGRESS_2 = 2 +CMAKE_PROGRESS_3 = 3 +CMAKE_PROGRESS_4 = 4 + diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/DependInfo.cmake b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/DependInfo.cmake new file mode 100644 index 0000000..d413eb4 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/DependInfo.cmake @@ -0,0 +1,20 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) +# The set of files for implicit dependencies of each language: + +# Pairs of files generated by the same build rule. +set(CMAKE_MULTIPLE_OUTPUT_PAIRS + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/%NuklearQuickDraw.ad" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.bin" + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.APPL" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.bin" + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.ad" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.bin" + "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.dsk" "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/NuklearQuickDraw.bin" + ) + + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/build.make b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/build.make new file mode 100644 index 0000000..d77f086 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/build.make @@ -0,0 +1,103 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build + +# Utility rule file for NuklearQuickDraw_APPL. + +# Include the progress variables for this target. +include CMakeFiles/NuklearQuickDraw_APPL.dir/progress.make + +CMakeFiles/NuklearQuickDraw_APPL: NuklearQuickDraw.bin + + +NuklearQuickDraw.bin: NuklearQuickDraw.code.bin +NuklearQuickDraw.bin: Sample.r.rsrc.bin + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --blue --bold --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Generating NuklearQuickDraw.bin, NuklearQuickDraw.APPL, NuklearQuickDraw.dsk, NuklearQuickDraw.ad, %NuklearQuickDraw.ad" + /home/camh/Retro68-build/toolchain/bin/Rez /home/camh/Retro68-build/toolchain/m68k-apple-macos/RIncludes/Retro68APPL.r -I/home/camh/Retro68-build/toolchain/m68k-apple-macos/RIncludes --copy NuklearQuickDraw.code.bin -o NuklearQuickDraw.bin -t APPL -c ???? --cc NuklearQuickDraw.dsk --cc NuklearQuickDraw.APPL --cc %NuklearQuickDraw.ad /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/Sample.r.rsrc.bin + +NuklearQuickDraw.APPL: NuklearQuickDraw.bin + @$(CMAKE_COMMAND) -E touch_nocreate NuklearQuickDraw.APPL + +NuklearQuickDraw.dsk: NuklearQuickDraw.bin + @$(CMAKE_COMMAND) -E touch_nocreate NuklearQuickDraw.dsk + +NuklearQuickDraw.ad: NuklearQuickDraw.bin + @$(CMAKE_COMMAND) -E touch_nocreate NuklearQuickDraw.ad + +%NuklearQuickDraw.ad: NuklearQuickDraw.bin + @$(CMAKE_COMMAND) -E touch_nocreate %NuklearQuickDraw.ad + +Sample.r.rsrc.bin: ../Sample.r + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --blue --bold --progress-dir=/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Generating Sample.r.rsrc.bin" + /home/camh/Retro68-build/toolchain/bin/Rez /home/camh/Documents/Retro68kApps/NuklearQuickDraw/Sample.r -I /home/camh/Retro68-build/toolchain/m68k-apple-macos/RIncludes -o Sample.r.rsrc.bin + +NuklearQuickDraw_APPL: CMakeFiles/NuklearQuickDraw_APPL +NuklearQuickDraw_APPL: NuklearQuickDraw.bin +NuklearQuickDraw_APPL: NuklearQuickDraw.APPL +NuklearQuickDraw_APPL: NuklearQuickDraw.dsk +NuklearQuickDraw_APPL: NuklearQuickDraw.ad +NuklearQuickDraw_APPL: %NuklearQuickDraw.ad +NuklearQuickDraw_APPL: Sample.r.rsrc.bin +NuklearQuickDraw_APPL: CMakeFiles/NuklearQuickDraw_APPL.dir/build.make + +.PHONY : NuklearQuickDraw_APPL + +# Rule to build all files generated by this target. +CMakeFiles/NuklearQuickDraw_APPL.dir/build: NuklearQuickDraw_APPL + +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/build + +CMakeFiles/NuklearQuickDraw_APPL.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/NuklearQuickDraw_APPL.dir/cmake_clean.cmake +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/clean + +CMakeFiles/NuklearQuickDraw_APPL.dir/depend: + cd /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/camh/Documents/Retro68kApps/NuklearQuickDraw /home/camh/Documents/Retro68kApps/NuklearQuickDraw /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw_APPL.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : CMakeFiles/NuklearQuickDraw_APPL.dir/depend + diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/cmake_clean.cmake b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/cmake_clean.cmake new file mode 100644 index 0000000..5bd5f9d --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/cmake_clean.cmake @@ -0,0 +1,14 @@ +file(REMOVE_RECURSE + "%NuklearQuickDraw.ad" + "CMakeFiles/NuklearQuickDraw_APPL" + "NuklearQuickDraw.APPL" + "NuklearQuickDraw.ad" + "NuklearQuickDraw.bin" + "NuklearQuickDraw.dsk" + "Sample.r.rsrc.bin" +) + +# Per-language clean rules from dependency scanning. +foreach(lang ) + include(CMakeFiles/NuklearQuickDraw_APPL.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.internal b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.internal new file mode 100644 index 0000000..f647855 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.internal @@ -0,0 +1,3 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.make b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.make new file mode 100644 index 0000000..f647855 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/depend.make @@ -0,0 +1,3 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + diff --git a/build/CMakeFiles/NuklearQuickDraw_APPL.dir/progress.make b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/progress.make new file mode 100644 index 0000000..3a86673 --- /dev/null +++ b/build/CMakeFiles/NuklearQuickDraw_APPL.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 5 +CMAKE_PROGRESS_2 = 6 + diff --git a/build/CMakeFiles/TargetDirectories.txt b/build/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..b4bcd82 --- /dev/null +++ b/build/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,4 @@ +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/rebuild_cache.dir +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/edit_cache.dir +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw_APPL.dir +/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/NuklearQuickDraw.dir diff --git a/build/CMakeFiles/cmake.check_cache b/build/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/build/CMakeFiles/progress.marks b/build/CMakeFiles/progress.marks new file mode 100644 index 0000000..1e8b314 --- /dev/null +++ b/build/CMakeFiles/progress.marks @@ -0,0 +1 @@ +6 diff --git a/build/Makefile b/build/Makefile new file mode 100644 index 0000000..367597f --- /dev/null +++ b/build/Makefile @@ -0,0 +1,252 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.16 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +# Allow only one "make -f Makefile2" at a time, but pass parallelism. +.NOTPARALLEL: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build + +#============================================================================= +# Targets provided globally by CMake. + +# Special rule for the target rebuild_cache +rebuild_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..." + /usr/bin/cmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : rebuild_cache + +# Special rule for the target rebuild_cache +rebuild_cache/fast: rebuild_cache + +.PHONY : rebuild_cache/fast + +# Special rule for the target edit_cache +edit_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "No interactive CMake dialog available..." + /usr/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available. +.PHONY : edit_cache + +# Special rule for the target edit_cache +edit_cache/fast: edit_cache + +.PHONY : edit_cache/fast + +# The main all target +all: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles/progress.marks + $(MAKE) -f CMakeFiles/Makefile2 all + $(CMAKE_COMMAND) -E cmake_progress_start /home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/CMakeFiles 0 +.PHONY : all + +# The main clean target +clean: + $(MAKE) -f CMakeFiles/Makefile2 clean +.PHONY : clean + +# The main clean target +clean/fast: clean + +.PHONY : clean/fast + +# Prepare targets for installation. +preinstall: all + $(MAKE) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall + +# Prepare targets for installation. +preinstall/fast: + $(MAKE) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall/fast + +# clear depends +depend: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 +.PHONY : depend + +#============================================================================= +# Target rules for targets named NuklearQuickDraw_APPL + +# Build rule for target. +NuklearQuickDraw_APPL: cmake_check_build_system + $(MAKE) -f CMakeFiles/Makefile2 NuklearQuickDraw_APPL +.PHONY : NuklearQuickDraw_APPL + +# fast build rule for target. +NuklearQuickDraw_APPL/fast: + $(MAKE) -f CMakeFiles/NuklearQuickDraw_APPL.dir/build.make CMakeFiles/NuklearQuickDraw_APPL.dir/build +.PHONY : NuklearQuickDraw_APPL/fast + +#============================================================================= +# Target rules for targets named NuklearQuickDraw + +# Build rule for target. +NuklearQuickDraw: cmake_check_build_system + $(MAKE) -f CMakeFiles/Makefile2 NuklearQuickDraw +.PHONY : NuklearQuickDraw + +# fast build rule for target. +NuklearQuickDraw/fast: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/build +.PHONY : NuklearQuickDraw/fast + +Sample.obj: Sample.c.obj + +.PHONY : Sample.obj + +# target to build an object file +Sample.c.obj: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/Sample.c.obj +.PHONY : Sample.c.obj + +Sample.i: Sample.c.i + +.PHONY : Sample.i + +# target to preprocess a source file +Sample.c.i: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/Sample.c.i +.PHONY : Sample.c.i + +Sample.s: Sample.c.s + +.PHONY : Sample.s + +# target to generate assembly for a file +Sample.c.s: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/Sample.c.s +.PHONY : Sample.c.s + +SerialHelper.obj: SerialHelper.c.obj + +.PHONY : SerialHelper.obj + +# target to build an object file +SerialHelper.c.obj: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.obj +.PHONY : SerialHelper.c.obj + +SerialHelper.i: SerialHelper.c.i + +.PHONY : SerialHelper.i + +# target to preprocess a source file +SerialHelper.c.i: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.i +.PHONY : SerialHelper.c.i + +SerialHelper.s: SerialHelper.c.s + +.PHONY : SerialHelper.s + +# target to generate assembly for a file +SerialHelper.c.s: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/SerialHelper.c.s +.PHONY : SerialHelper.c.s + +coprocessorjs.obj: coprocessorjs.c.obj + +.PHONY : coprocessorjs.obj + +# target to build an object file +coprocessorjs.c.obj: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.obj +.PHONY : coprocessorjs.c.obj + +coprocessorjs.i: coprocessorjs.c.i + +.PHONY : coprocessorjs.i + +# target to preprocess a source file +coprocessorjs.c.i: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.i +.PHONY : coprocessorjs.c.i + +coprocessorjs.s: coprocessorjs.c.s + +.PHONY : coprocessorjs.s + +# target to generate assembly for a file +coprocessorjs.c.s: + $(MAKE) -f CMakeFiles/NuklearQuickDraw.dir/build.make CMakeFiles/NuklearQuickDraw.dir/coprocessorjs.c.s +.PHONY : coprocessorjs.c.s + +# Help Target +help: + @echo "The following are some of the valid targets for this Makefile:" + @echo "... all (the default if no target is provided)" + @echo "... clean" + @echo "... depend" + @echo "... rebuild_cache" + @echo "... edit_cache" + @echo "... NuklearQuickDraw_APPL" + @echo "... NuklearQuickDraw" + @echo "... Sample.obj" + @echo "... Sample.i" + @echo "... Sample.s" + @echo "... SerialHelper.obj" + @echo "... SerialHelper.i" + @echo "... SerialHelper.s" + @echo "... coprocessorjs.obj" + @echo "... coprocessorjs.i" + @echo "... coprocessorjs.s" +.PHONY : help + + + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/build/NuklearQuickDraw.APPL b/build/NuklearQuickDraw.APPL new file mode 100644 index 0000000..e69de29 diff --git a/build/NuklearQuickDraw.ad b/build/NuklearQuickDraw.ad new file mode 100644 index 0000000..e69de29 diff --git a/build/NuklearQuickDraw.bin b/build/NuklearQuickDraw.bin new file mode 100644 index 0000000..a2f0e2c Binary files /dev/null and b/build/NuklearQuickDraw.bin differ diff --git a/build/NuklearQuickDraw.code.bin b/build/NuklearQuickDraw.code.bin new file mode 100644 index 0000000..eb8ec0f Binary files /dev/null and b/build/NuklearQuickDraw.code.bin differ diff --git a/build/NuklearQuickDraw.code.bin.gdb b/build/NuklearQuickDraw.code.bin.gdb new file mode 100755 index 0000000..332252b Binary files /dev/null and b/build/NuklearQuickDraw.code.bin.gdb differ diff --git a/build/NuklearQuickDraw.dsk b/build/NuklearQuickDraw.dsk new file mode 100644 index 0000000..4e66537 Binary files /dev/null and b/build/NuklearQuickDraw.dsk differ diff --git a/build/Sample.r.rsrc.bin b/build/Sample.r.rsrc.bin new file mode 100644 index 0000000..73b6a46 Binary files /dev/null and b/build/Sample.r.rsrc.bin differ diff --git a/build/cmake_install.cmake b/build/cmake_install.cmake new file mode 100644 index 0000000..0230a18 --- /dev/null +++ b/build/cmake_install.cmake @@ -0,0 +1,44 @@ +# Install script for directory: /home/camh/Documents/Retro68kApps/NuklearQuickDraw + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/home/camh/Retro68-build/toolchain/m68k-apple-macos") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "TRUE") +endif() + +if(CMAKE_INSTALL_COMPONENT) + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +file(WRITE "/home/camh/Documents/Retro68kApps/NuklearQuickDraw/build/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") diff --git a/compile_commands.json b/compile_commands.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/compile_commands.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/compile_js.sh b/compile_js.sh new file mode 100755 index 0000000..0bf0057 --- /dev/null +++ b/compile_js.sh @@ -0,0 +1,21 @@ +#!/bin/bash +# wraps up all JS files (including json) in "JS" directory within the current directory +# into a single file following the format outlined for programs in https://github.com/CamHenlin/coprocessor.js +# requires truncate +# requires xxd + +truncate --size=0 output_js +truncate --size=0 output_js.h + +cd JS + +for filename in *.js*; do + echo "$filename@@@" >> ../output_js + cat $filename >> ../output_js + echo "&&&" >> ../output_js +done + +cd .. +truncate -s-4 output_js # remove trailing &&& +xxd -C -i output_js >> output_js.h +#rm output_js diff --git a/coprocessorjs.c b/coprocessorjs.c new file mode 100644 index 0000000..a8827df --- /dev/null +++ b/coprocessorjs.c @@ -0,0 +1,579 @@ +#include +#include +#include +#include +#include "string.h" +#include +#include +#include "SerialHelper.h" +#include "coprocessorjs.h" + +IOParam outgoingSerialPortReference; +IOParam incomingSerialPortReference; +const bool PRINT_ERRORS = false; +const bool DEBUGGING = false; +const int RECEIVE_WINDOW_SIZE = 102400; // receive in up to 100kb chunks? +const int MAX_RECEIVE_SIZE = RECEIVE_WINDOW_SIZE; // not sure if these ever need to be different +char GlobalSerialInputBuffer[102400]; // make this match MAX_RECEIVE_SIZE + +char application_id[255]; +int call_counter = 0; + +// from: https://stackoverflow.com/questions/29847915/implementing-strtok-whose-delimiter-has-more-than-one-character +// basically multichar delimter strtok +char *strtokm(char *str, const char *delim) +{ + static char *tok; + static char *next; + char *m; + + if (delim == NULL) return NULL; + + tok = (str) ? str : next; + if (tok == NULL) return NULL; + + m = strstr(tok, delim); + + if (m) { + next = m + strlen(delim); + *m = '\0'; + } else { + next = NULL; + } + + return tok; +} + +/* +// http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/Devices/Devices-320.html +Read more: http://stason.org/TULARC/os-macintosh/programming/7-1-How-do-I-get-at-the-serial-ports-Communications-and-N.html#ixzz4cIxU3Tob this one is only useful for enumerating ports +// https://developer.apple.com/library/archive/documentation/mac/pdf/Devices/Serial_Driver.pdf +Serial implementation: + +https://opensource.apple.com/source/gdb/gdb-186.1/src/gdb/ser-mac.c?txt another example of a serial library +http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/Devices/Devices-320.html +*/ + +// notes from above article: +// You can use OpenDriver, SetReset, SetHShake, SetSetBuf, SerGetBuf and +// the other Serial Manager functions on these drivers. + +// To write to the +// serial port, use FSWrite for synchronous writes that wait until all is +// written, or PBWrite asynchronously for queuing up data that is supposed +// to go out but you don't want to wait for it. + +// At least once each time +// through your event loop, you should call SerGetBuf on the in driver +// reference number you got from OpenDriver, and call FSRead for that many +// bytes - neither more nor less. + +// TODO: handle all OSErr - they are all unhandled at the moment +void setupPBControlForSerialPort(short serialPortShort) { + + CntrlParam cb; + cb.ioCRefNum = serialPortShort; // TODO: this is always 0 - does it matter? should we hard code 0 here? research + cb.csCode = 8; // TODO: need to look up and document what csCode = 8 means + cb.csParam[0] = stop10 | noParity | data8 | baud28800; // TODO: can we achieve higher than 9600 baud? - should be able to achieve at least 19.2k on a 68k machine + OSErr err = PBControl ((ParmBlkPtr) & cb, 0); // PBControl definition: http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/Networking/Networking-296.html + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + if (err < 0) { + + return; + } +} + + + +void setupSerialPort(const char *name) { +#define MODEM_PORT_OUT "\p.AOut" +#define MODEM_PORT_IN "\p.AIn" +#define PRINTER_PORT_OUT "\p.BOut" +#define PRINTER_PORT_IN "\p.BIn" + + const char* serialPortOutputName = ""; + const char* serialPortInputName = ""; + + if (strcmp (name, "modem") == 0) { + + serialPortOutputName = MODEM_PORT_OUT; + serialPortInputName = MODEM_PORT_IN; + } else if (strcmp (name, "printer") == 0) { + + serialPortOutputName = PRINTER_PORT_OUT; + serialPortInputName = MODEM_PORT_IN; + } else { + + return; + } + + short serialPortOutput = 0; // TODO: why is this always 0? is this right? + short serialPortInput = 0; // TODO: not realy sure what this should be - just incrementing from the last item here + + OSErr err = MacOpenDriver(serialPortOutputName, &serialPortOutput); + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + if (err < 0) { + + return; + } + + err = MacOpenDriver(serialPortInputName, &serialPortInput); // result in 0 but still doesn't work + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + if (err < 0) { + + return; + } + + // From https://developer.apple.com/library/archive/documentation/mac/pdf/Devices/Serial_Driver.pdf + // Set baud rate and data format. Note that you only need to set the + // output driver; the settings are reflected on the input side + setupPBControlForSerialPort(serialPortOutput); + + outgoingSerialPortReference.ioRefNum = serialPortOutput; + incomingSerialPortReference.ioRefNum = serialPortInput; + + // the next 2 commands set up the receive window size to whatever we want, in bytes. + // as far as i can tell, this needs to be set before any data begins flowing, so it seemed + // like a good call to make the buffer a global that gets instantiated at serial port setup + incomingSerialPortReference.ioBuffer = (Ptr)GlobalSerialInputBuffer; + SerSetBuf(incomingSerialPortReference.ioRefNum, incomingSerialPortReference.ioBuffer, RECEIVE_WINDOW_SIZE); +} + +void wait(float timeInSeconds) { + + // from "Inside Macintosh: Macintosh Toolbox Essentials" pg 2-112 + // You can use the TickCount function to get the current number of ticks (a tick is + // approximately 1/60 of a second) since the system last started up. + // FUNCTION TickCount: LongInt; + + // previous implementation, which might work on more modern platforms (which is why this is left as a comment), was: + // note that this appeared to sometimes be off by as much as 1s on a Macintosh classic (using other normal C time functions to measure...) + // time_t start; + // time_t end; + + // time(&start); + + // do { + + // time(&end); + // } while (difftime(end, start) <= timeInSeconds); + + long start; + long end; + long waitTicks = (long)timeInSeconds * 60; + + start = TickCount(); + + do { + + end = TickCount(); + } while (end - start <= waitTicks); + + // char log[255]; + // sprintf(log, "start time was %ld end time was %ld split was %ld and wait ticks were %ld, input was %f\n ", start, end, end - start, waitTicks, timeInSeconds); + // printf(log); +} + +// void because this function re-assigns respo +void readSerialPort(char* output) { + + if (DEBUGGING) { + + printf("readSerialPort\n"); + } + + // make sure output variable is clear + memset(&output[0], 0, MAX_RECEIVE_SIZE); + + bool done = false; + char tempOutput[MAX_RECEIVE_SIZE]; + long int totalByteCount = 0; + incomingSerialPortReference.ioReqCount = 0; + + while (!done) { + + long int byteCount = 0; + long int lastByteCount = 0; + bool doByteCountsMatch = false; + short serGetBufStatus; + + // the byteCount != lastByteCount portion of the loop means that we want to wait + // for the byteCounts to match between SerGetBuf calls - this means that the buffer + // is full and ready to be read + while (!doByteCountsMatch || byteCount == 0) { + + if (DEBUGGING) { + + char debugMessage[100]; + sprintf(debugMessage, "receive loop: byteCount: %d, lastByteCount: %d\n", byteCount, lastByteCount); + printf(debugMessage); + } + + lastByteCount = (long int)byteCount; + + wait(0.01); // give the buffer a moment to fill + + serGetBufStatus = SerGetBuf(incomingSerialPortReference.ioRefNum, &byteCount); + + if (serGetBufStatus != 0 && PRINT_ERRORS) { + + printf("potential problem with serGetBufStatus:\n"); + char debugMessage[100]; + sprintf(debugMessage, "serGetBufStatus: %d\n", serGetBufStatus); + printf(debugMessage); + } + + if (byteCount == lastByteCount && byteCount != 0 && lastByteCount != 0) { + + if (DEBUGGING) { + + char debugMessage[100]; + sprintf(debugMessage, "receive loop setting last doByteCountsMatch to true: byteCount: %d, lastByteCount: %d\n", byteCount, lastByteCount); + printf(debugMessage); + } + + doByteCountsMatch = true; + } + } + + if (DEBUGGING) { + + char debugMessage[100]; + sprintf(debugMessage, "receive loop complete: byteCount: %d, lastByteCount: %d\n", byteCount, lastByteCount); + printf(debugMessage); + } + + incomingSerialPortReference.ioReqCount = byteCount; + + OSErr err = PBRead((ParmBlkPtr)&incomingSerialPortReference, 0); + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + memcpy(tempOutput, GlobalSerialInputBuffer, byteCount); + + totalByteCount += byteCount; + + if (strstr(tempOutput, ";;@@&&") != NULL) { + + if (DEBUGGING) { + + printf("done building temp output\n"); + printf(tempOutput); + + char *debugOutput; + char tempString[MAX_RECEIVE_SIZE]; + strncat(tempString, tempOutput, totalByteCount); + sprintf(debugOutput, "\n'%d'\n", strlen(tempString)); + printf(debugOutput); + printf("\ndone with output\n"); + printf("\n"); + } + + done = true; + } + } + + // attach the gathered up output from the buffer to the output variable + strncat(output, tempOutput, totalByteCount); + + // once we are done reading the buffer entirely, we need to clear it. i'm not sure if this is the best way or not but seems to work + memset(&GlobalSerialInputBuffer[0], 0, MAX_RECEIVE_SIZE); + + return; +} + + +OSErr writeSerialPort(const char* stringToWrite) { + + if (DEBUGGING) { + + printf("writeSerialPort\n"); + } + + outgoingSerialPortReference.ioBuffer = (Ptr) stringToWrite; + outgoingSerialPortReference.ioReqCount = strlen(stringToWrite); + + if (DEBUGGING) { + + printf("attempting to write string to serial port\n"); + printf(stringToWrite); + printf("\n"); + } + + // PBWrite Definition From Inside Macintosh Volume II-185: + // PBWrite takes ioReqCount bytes from the buffer pointed to by ioBuffer and attempts to write them to the device driver having the reference number ioRefNum. + // The drive number, if any, of the device to be written to is specified by ioVRefNum. After the write is completed, the position is returned in ioPosOffset and the number of bytes actually written is returned in ioActCount. + OSErr err = PBWrite((ParmBlkPtr)& outgoingSerialPortReference, 0); + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + return err; +} + +void setupCoprocessor(char *applicationId, const char *serialDeviceName) { + + strcpy(application_id, applicationId); + + setupSerialPort(serialDeviceName); + + return; +} + +OSErr closeSerialPort() { + + OSErr err = MacCloseDriver(outgoingSerialPortReference.ioRefNum); + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "err:%d\n", err); + printf(errMessage); + } + + return err; +} + +// return time is char but this is only for error messages - final param is output variable that will be re-assigned within this function +char* _getReturnValueFromResponse(char* response, char* application_id, char* call_counter, char* operation, char* output) { + + if (DEBUGGING) { + + printf("_getReturnValueFromResponse\n"); + printf(response); + printf("\n"); + } + + // get the first token in to memory + char *token = strtokm(response, ";;;"); + + // we need to track the token that we are on because the coprocessor.js responses are standardized + // so the tokens at specific positions will map to specific items in the response + int tokenCounter = 0; + const int MAX_ATTEMPTS = 10; + + // loop through the string to extract all other tokens + while (token != NULL) { + + if (tokenCounter > MAX_ATTEMPTS) { + + return "max attempts exceeded"; + } + + if (DEBUGGING) { + + char *debugOutput; + sprintf(debugOutput, "inspect token %d: %s\n", tokenCounter, token); + printf(debugOutput); + } + + switch (tokenCounter) { + + case 0: // APPLICATION ID + + if (strcmp(token, application_id) != 0) { + + return "application id mismatch"; // TODO figure out better error handling + } + + break; + case 1: // CALL COUNTER + + if (strcmp(token, call_counter) != 0) { + + return "call counter mismatch"; // TODO figure out better error handling + } + + break; + case 2: // OPERATION + + if (strcmp(token, operation) != 0) { + + return "operation mismatch"; // TODO figure out better error handling + } + + break; + case 3: // STATUS + + if (strcmp(token, "SUCCESS") != 0) { + + return "operation failed"; // TODO figure out better error handling + } + + break; + case 4: + + if (DEBUGGING) { + + printf("setting output to token:\n"); + printf(token); + char *debugOutput; + sprintf(debugOutput, "\n'%d'\n", strlen(token)); + printf(debugOutput); + printf("\ndone with output\n"); + } + + strncat(output, token, strlen(token) - 6); // the -6 here is to drop the ;;@@&& off the end of the response + + return NULL; + + default: + + break; + } + + // get the next token. strtokm has some weird syntax + token = strtokm(NULL, ";;;"); + tokenCounter++; + } + + return NULL; +} + +void writeToCoprocessor(char* operation, char* operand) { + + if (DEBUGGING) { + + printf("writeToCoprocessor\n"); + } + + const char* messageTemplate = "%s;;;%s;;;%s;;;%s;;@@&&"; // see: https://github.com/CamHenlin/coprocessor.js/blob/main/index.js#L25 + char call_id[32]; + + // over-allocate by 1kb for the operand (which could be an entire nodejs app) + message template wrapper + // and other associated info. wasting a tiny bit of memory here, could get more precise if memory becomes a problem. + char messageToSend[strlen(operand) + 1024]; + + sprintf(call_id, "%d", call_counter++); + + // application_id is globally defined for now, how will that work in a library? + sprintf(messageToSend, messageTemplate, application_id, call_id, operation, operand); + + OSErr err = writeSerialPort(messageToSend); + + if (PRINT_ERRORS) { + + char errMessage[100]; + sprintf(errMessage, "writeToCoprocessor err:%d\n", err); + printf(errMessage); + } + + return; +} + +// must be called after writeToCoprocessor and before other writeToCoprocessor +// operations because we depend on the location of call_counter +char* getReturnValueFromResponse(char *response, char *operation, char *output) { + + if (DEBUGGING) { + + printf("getReturnValueFromResponse\n"); + } + + char call_id[32]; + sprintf(call_id, "%d", call_counter - 1); + + char *err = _getReturnValueFromResponse(response, application_id, call_id, operation, output); + + if (err != NULL && PRINT_ERRORS) { + + printf("error getting return value from response:\n"); + printf(err); + printf("\n"); + } +} + +// TODO: this is a function we would want to expose in a library +// TODO: these should all bubble up and return legible errors +void sendProgramToCoprocessor(char* program, char *output) { + + if (DEBUGGING) { + + printf("sendProgramToCoprocessor\n"); + } + + writeToCoprocessor("PROGRAM", program); + + char serialPortResponse[MAX_RECEIVE_SIZE]; + readSerialPort(serialPortResponse); + + getReturnValueFromResponse(serialPortResponse, "PROGRAM", output); + + return; +} + +// TODO: this is a function we would want to expose in a library +void callFunctionOnCoprocessor(char* functionName, char* parameters, char* output) { + + if (DEBUGGING) { + + printf("callFunctionOnCoprocessor\n"); + } + + const char* functionTemplate = "%s&&&%s"; + + // over-allocate by 1kb for the operand (which could be whatever a programmer sends to this function) + message template wrapper + // and other associated info. wasting a tiny bit of memory here, could get more precise if memory becomes a problem. + char functionCallMessage[strlen(parameters) + 1024]; + + // delimeter for function paramters is &&& - user must do this on their own via sprintf call or other construct - this is easiest for us to deal with + sprintf(functionCallMessage, functionTemplate, functionName, parameters); + + // writeSerialPortDebug(boutRefNum, functionCallMessage); + writeToCoprocessor("FUNCTION", functionCallMessage); + + char serialPortResponse[MAX_RECEIVE_SIZE]; + readSerialPort(serialPortResponse); + // writeSerialPortDebug(boutRefNum, "========================Got response from serial port"); + // writeSerialPortDebug(boutRefNum, serialPortResponse); + getReturnValueFromResponse(serialPortResponse, "FUNCTION", output); + + return; +} + +// TODO: this is a function we would want to expose in a library +void callEvalOnCoprocessor(char* toEval, char* output) { + + if (DEBUGGING) { + + printf("callEvalOnCoprocessor\n"); + } + + writeToCoprocessor("EVAL", toEval); + + char serialPortResponse[MAX_RECEIVE_SIZE]; + readSerialPort(serialPortResponse); + getReturnValueFromResponse(serialPortResponse, "EVAL", output); + + return; +} \ No newline at end of file diff --git a/coprocessorjs.h b/coprocessorjs.h new file mode 100644 index 0000000..9370e02 --- /dev/null +++ b/coprocessorjs.h @@ -0,0 +1,15 @@ + + +const int MAX_RECEIVE_SIZE; + +void setupCoprocessor(char *applicationId, const char *serialDeviceName); + +void sendProgramToCoprocessor(char* program, char *output); + +void callFunctionOnCoprocessor(char* functionName, char* parameters, char* output); + +void callEvalOnCoprocessor(char* toEval, char* output); + +void wait(float whatever); + +OSErr closeSerialPort(); \ No newline at end of file diff --git a/nuklear.h b/nuklear.h new file mode 100644 index 0000000..5361911 --- /dev/null +++ b/nuklear.h @@ -0,0 +1,30401 @@ +/* +/// # Nuklear +/// ![](https://cloud.githubusercontent.com/assets/8057201/11761525/ae06f0ca-a0c6-11e5-819d-5610b25f6ef4.gif) +/// +/// ## Contents +/// 1. About section +/// 2. Highlights section +/// 3. Features section +/// 4. Usage section +/// 1. Flags section +/// 2. Constants section +/// 3. Dependencies section +/// 5. Example section +/// 6. API section +/// 1. Context section +/// 2. Input section +/// 3. Drawing section +/// 4. Window section +/// 5. Layouting section +/// 6. Groups section +/// 7. Tree section +/// 8. Properties section +/// 7. License section +/// 8. Changelog section +/// 9. Gallery section +/// 10. Credits section +/// +/// ## About +/// This is a minimal state immediate mode graphical user interface toolkit +/// written in ANSI C and licensed under public domain. It was designed as a simple +/// embeddable user interface for application and does not have any dependencies, +/// a default renderbackend or OS window and input handling but instead provides a very modular +/// library approach by using simple input state for input and draw +/// commands describing primitive shapes as output. So instead of providing a +/// layered library that tries to abstract over a number of platform and +/// render backends it only focuses on the actual UI. +/// +/// ## Highlights +/// - Graphical user interface toolkit +/// - Single header library +/// - Written in C89 (a.k.a. ANSI C or ISO C90) +/// - Small codebase (~18kLOC) +/// - Focus on portability, efficiency and simplicity +/// - No dependencies (not even the standard library if not wanted) +/// - Fully skinnable and customizable +/// - Low memory footprint with total memory control if needed or wanted +/// - UTF-8 support +/// - No global or hidden state +/// - Customizable library modules (you can compile and use only what you need) +/// - Optional font baker and vertex buffer output +/// +/// ## Features +/// - Absolutely no platform dependent code +/// - Memory management control ranging from/to +/// - Ease of use by allocating everything from standard library +/// - Control every byte of memory inside the library +/// - Font handling control ranging from/to +/// - Use your own font implementation for everything +/// - Use this libraries internal font baking and handling API +/// - Drawing output control ranging from/to +/// - Simple shapes for more high level APIs which already have drawing capabilities +/// - Hardware accessible anti-aliased vertex buffer output +/// - Customizable colors and properties ranging from/to +/// - Simple changes to color by filling a simple color table +/// - Complete control with ability to use skinning to decorate widgets +/// - Bendable UI library with widget ranging from/to +/// - Basic widgets like buttons, checkboxes, slider, ... +/// - Advanced widget like abstract comboboxes, contextual menus,... +/// - Compile time configuration to only compile what you need +/// - Subset which can be used if you do not want to link or use the standard library +/// - Can be easily modified to only update on user input instead of frame updates +/// +/// ## Usage +/// This library is self contained in one single header file and can be used either +/// in header only mode or in implementation mode. The header only mode is used +/// by default when included and allows including this header in other headers +/// and does not contain the actual implementation.

+/// +/// The implementation mode requires to define the preprocessor macro +/// NK_IMPLEMENTATION in *one* .c/.cpp file before #includeing this file, e.g.: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~C +/// #define NK_IMPLEMENTATION +/// #include "nuklear.h" +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Also optionally define the symbols listed in the section "OPTIONAL DEFINES" +/// below in header and implementation mode if you want to use additional functionality +/// or need more control over the library. +/// +/// !!! WARNING +/// Every time nuklear is included define the same compiler flags. This very important not doing so could lead to compiler errors or even worse stack corruptions. +/// +/// ### Flags +/// Flag | Description +/// --------------------------------|------------------------------------------ +/// NK_PRIVATE | If defined declares all functions as static, so they can only be accessed inside the file that contains the implementation +/// NK_INCLUDE_FIXED_TYPES | If defined it will include header `` for fixed sized types otherwise nuklear tries to select the correct type. If that fails it will throw a compiler error and you have to select the correct types yourself. +/// NK_INCLUDE_DEFAULT_ALLOCATOR | If defined it will include header `` and provide additional functions to use this library without caring for memory allocation control and therefore ease memory management. +/// NK_INCLUDE_STANDARD_IO | If defined it will include header `` and provide additional functions depending on file loading. +/// NK_INCLUDE_STANDARD_VARARGS | If defined it will include header and provide additional functions depending on file loading. +/// NK_INCLUDE_STANDARD_BOOL | If defined it will include header `` for nk_bool otherwise nuklear defines nk_bool as int. +/// NK_INCLUDE_VERTEX_BUFFER_OUTPUT | Defining this adds a vertex draw command list backend to this library, which allows you to convert queue commands into vertex draw commands. This is mainly if you need a hardware accessible format for OpenGL, DirectX, Vulkan, Metal,... +/// NK_INCLUDE_FONT_BAKING | Defining this adds `stb_truetype` and `stb_rect_pack` implementation to this library and provides font baking and rendering. If you already have font handling or do not want to use this font handler you don't have to define it. +/// NK_INCLUDE_DEFAULT_FONT | Defining this adds the default font: ProggyClean.ttf into this library which can be loaded into a font atlas and allows using this library without having a truetype font +/// NK_INCLUDE_COMMAND_USERDATA | Defining this adds a userdata pointer into each command. Can be useful for example if you want to provide custom shaders depending on the used widget. Can be combined with the style structures. +/// NK_BUTTON_TRIGGER_ON_RELEASE | Different platforms require button clicks occurring either on buttons being pressed (up to down) or released (down to up). By default this library will react on buttons being pressed, but if you define this it will only trigger if a button is released. +/// NK_ZERO_COMMAND_MEMORY | Defining this will zero out memory for each drawing command added to a drawing queue (inside nk_command_buffer_push). Zeroing command memory is very useful for fast checking (using memcmp) if command buffers are equal and avoid drawing frames when nothing on screen has changed since previous frame. +/// NK_UINT_DRAW_INDEX | Defining this will set the size of vertex index elements when using NK_VERTEX_BUFFER_OUTPUT to 32bit instead of the default of 16bit +/// NK_KEYSTATE_BASED_INPUT | Define this if your backend uses key state for each frame rather than key press/release events +/// +/// !!! WARNING +/// The following flags will pull in the standard C library: +/// - NK_INCLUDE_DEFAULT_ALLOCATOR +/// - NK_INCLUDE_STANDARD_IO +/// - NK_INCLUDE_STANDARD_VARARGS +/// +/// !!! WARNING +/// The following flags if defined need to be defined for both header and implementation: +/// - NK_INCLUDE_FIXED_TYPES +/// - NK_INCLUDE_DEFAULT_ALLOCATOR +/// - NK_INCLUDE_STANDARD_VARARGS +/// - NK_INCLUDE_STANDARD_BOOL +/// - NK_INCLUDE_VERTEX_BUFFER_OUTPUT +/// - NK_INCLUDE_FONT_BAKING +/// - NK_INCLUDE_DEFAULT_FONT +/// - NK_INCLUDE_STANDARD_VARARGS +/// - NK_INCLUDE_COMMAND_USERDATA +/// - NK_UINT_DRAW_INDEX +/// +/// ### Constants +/// Define | Description +/// --------------------------------|--------------------------------------- +/// NK_BUFFER_DEFAULT_INITIAL_SIZE | Initial buffer size allocated by all buffers while using the default allocator functions included by defining NK_INCLUDE_DEFAULT_ALLOCATOR. If you don't want to allocate the default 4k memory then redefine it. +/// NK_MAX_NUMBER_BUFFER | Maximum buffer size for the conversion buffer between int and string Under normal circumstances this should be more than sufficient. +/// NK_INPUT_MAX | Defines the max number of bytes which can be added as text input in one frame. Under normal circumstances this should be more than sufficient. +/// +/// !!! WARNING +/// The following constants if defined need to be defined for both header and implementation: +/// - NK_MAX_NUMBER_BUFFER +/// - NK_BUFFER_DEFAULT_INITIAL_SIZE +/// - NK_INPUT_MAX +/// +/// ### Dependencies +/// Function | Description +/// ------------|--------------------------------------------------------------- +/// // NK_ASSERT | If you don't define this, nuklear will use with assert(). +/// NK_MEMSET | You can define this to 'memset' or your own memset implementation replacement. If not nuklear will use its own version. +/// NK_MEMCPY | You can define this to 'memcpy' or your own memcpy implementation replacement. If not nuklear will use its own version. +/// NK_SQRT | You can define this to 'sqrt' or your own sqrt implementation replacement. If not nuklear will use its own slow and not highly accurate version. +/// NK_SIN | You can define this to 'sinf' or your own sine implementation replacement. If not nuklear will use its own approximation implementation. +/// NK_COS | You can define this to 'cosf' or your own cosine implementation replacement. If not nuklear will use its own approximation implementation. +/// NK_STRTOD | You can define this to `strtod` or your own string to double conversion implementation replacement. If not defined nuklear will use its own imprecise and possibly unsafe version (does not handle nan or infinity!). +/// NK_DTOA | You can define this to `dtoa` or your own double to string conversion implementation replacement. If not defined nuklear will use its own imprecise and possibly unsafe version (does not handle nan or infinity!). +/// NK_VSNPRINTF| If you define `NK_INCLUDE_STANDARD_VARARGS` as well as `NK_INCLUDE_STANDARD_IO` and want to be safe define this to `vsnprintf` on compilers supporting later versions of C or C++. By default nuklear will check for your stdlib version in C as well as compiler version in C++. if `vsnprintf` is available it will define it to `vsnprintf` directly. If not defined and if you have older versions of C or C++ it will be defined to `vsprintf` which is unsafe. +/// +/// !!! WARNING +/// The following dependencies will pull in the standard C library if not redefined: +/// - // NK_ASSERT +/// +/// !!! WARNING +/// The following dependencies if defined need to be defined for both header and implementation: +/// - // NK_ASSERT +/// +/// !!! WARNING +/// The following dependencies if defined need to be defined only for the implementation part: +/// - NK_MEMSET +/// - NK_MEMCPY +/// - NK_SQRT +/// - NK_SIN +/// - NK_COS +/// - NK_STRTOD +/// - NK_DTOA +/// - NK_VSNPRINTF +/// +/// ## Example +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// // init gui state +/// enum {EASY, HARD}; +/// static int op = EASY; +/// static int value = 0.6f; +/// static int i = 20; +/// struct nk_context ctx; +/// +/// nk_init_fixed(&ctx, calloc(1, MAX_MEMORY), MAX_MEMORY, &font); +/// if (nk_begin(&ctx, "Show", nk_rect(50, 50, 220, 220), +/// NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_CLOSABLE)) { +/// // fixed widget pixel width +/// nk_layout_row_static(&ctx, 30, 80, 1); +/// if (nk_button_label(&ctx, "button")) { +/// // event handling +/// } +/// +/// // fixed widget window ratio width +/// nk_layout_row_dynamic(&ctx, 30, 2); +/// if (nk_option_label(&ctx, "easy", op == EASY)) op = EASY; +/// if (nk_option_label(&ctx, "hard", op == HARD)) op = HARD; +/// +/// // custom widget pixel width +/// nk_layout_row_begin(&ctx, NK_STATIC, 30, 2); +/// { +/// nk_layout_row_push(&ctx, 50); +/// nk_label(&ctx, "Volume:", NK_TEXT_LEFT); +/// nk_layout_row_push(&ctx, 110); +/// nk_slider_int(&ctx, 0, &value, 1.0f, 0.1f); +/// } +/// nk_layout_row_end(&ctx); +/// } +/// nk_end(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// ![](https://cloud.githubusercontent.com/assets/8057201/10187981/584ecd68-675c-11e5-897c-822ef534a876.png) +/// +/// ## API +/// +*/ +#ifndef NK_SINGLE_FILE + #define NK_SINGLE_FILE +#endif + +#ifndef NK_NUKLEAR_H_ +#define NK_NUKLEAR_H_ + +#ifdef __cplusplus +extern "C" { +#endif +/* + * ============================================================== + * + * CONSTANTS + * + * =============================================================== + */ +#define NK_UNDEFINED (-1.0f) +#define NK_UTF_INVALID 0xFFFD /* internal invalid utf8 rune */ +#define NK_UTF_SIZE 4 /* describes the number of bytes a glyph consists of*/ +#ifndef NK_INPUT_MAX + #define NK_INPUT_MAX 16 +#endif +#ifndef NK_MAX_NUMBER_BUFFER + #define NK_MAX_NUMBER_BUFFER 64 +#endif +#ifndef NK_SCROLLBAR_HIDING_TIMEOUT + #define NK_SCROLLBAR_HIDING_TIMEOUT 4.0f +#endif +/* + * ============================================================== + * + * HELPER + * + * =============================================================== + */ +#ifndef NK_API + #ifdef NK_PRIVATE + #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199409L)) + #define NK_API static inline + #elif defined(__cplusplus) + #define NK_API static inline + #else + #define NK_API static + #endif + #else + #define NK_API extern + #endif +#endif +#ifndef NK_LIB + #ifdef NK_SINGLE_FILE + #define NK_LIB static + #else + #define NK_LIB extern + #endif +#endif + +#define NK_INTERN static +#define NK_STORAGE static +#define NK_GLOBAL static + +#define NK_FLAG(x) (1 << (x)) +#define NK_STRINGIFY(x) #x +#define NK_MACRO_STRINGIFY(x) NK_STRINGIFY(x) +#define NK_STRING_JOIN_IMMEDIATE(arg1, arg2) arg1 ## arg2 +#define NK_STRING_JOIN_DELAY(arg1, arg2) NK_STRING_JOIN_IMMEDIATE(arg1, arg2) +#define NK_STRING_JOIN(arg1, arg2) NK_STRING_JOIN_DELAY(arg1, arg2) + +#ifdef _MSC_VER + #define NK_UNIQUE_NAME(name) NK_STRING_JOIN(name,__COUNTER__) +#else + #define NK_UNIQUE_NAME(name) NK_STRING_JOIN(name,__LINE__) +#endif + +#ifndef NK_STATIC_ASSERT + #define NK_STATIC_ASSERT(exp) typedef char NK_UNIQUE_NAME(_dummy_array)[(exp)?1:-1] +#endif + +#ifndef NK_FILE_LINE +#ifdef _MSC_VER + #define NK_FILE_LINE __FILE__ ":" NK_MACRO_STRINGIFY(__COUNTER__) +#else + #define NK_FILE_LINE __FILE__ ":" NK_MACRO_STRINGIFY(__LINE__) +#endif +#endif + +#define NK_MIN(a,b) ((a) < (b) ? (a) : (b)) +#define NK_MAX(a,b) ((a) < (b) ? (b) : (a)) +#define NK_CLAMP(i,v,x) (NK_MAX(NK_MIN(v,x), i)) + +#ifdef NK_INCLUDE_STANDARD_VARARGS + #include + #if defined(_MSC_VER) && (_MSC_VER >= 1600) /* VS 2010 and above */ + #include + #define NK_PRINTF_FORMAT_STRING _Printf_format_string_ + #else + #define NK_PRINTF_FORMAT_STRING + #endif + #if defined(__GNUC__) + #define NK_PRINTF_VARARG_FUNC(fmtargnumber) __attribute__((format(__printf__, fmtargnumber, fmtargnumber+1))) + #define NK_PRINTF_VALIST_FUNC(fmtargnumber) __attribute__((format(__printf__, fmtargnumber, 0))) + #else + #define NK_PRINTF_VARARG_FUNC(fmtargnumber) + #define NK_PRINTF_VALIST_FUNC(fmtargnumber) + #endif +#endif + +/* + * =============================================================== + * + * BASIC + * + * =============================================================== + */ +#ifdef NK_INCLUDE_FIXED_TYPES + #include + #define NK_INT8 int8_t + #define NK_UINT8 uint8_t + #define NK_INT16 int16_t + #define NK_UINT16 uint16_t + #define NK_INT32 int32_t + #define NK_UINT32 uint32_t + #define NK_SIZE_TYPE uintptr_t + #define NK_POINTER_TYPE uintptr_t +#else + #ifndef NK_INT8 + #define NK_INT8 signed char + #endif + #ifndef NK_UINT8 + #define NK_UINT8 unsigned char + #endif + #ifndef NK_INT16 + #define NK_INT16 signed short + #endif + #ifndef NK_UINT16 + #define NK_UINT16 unsigned short + #endif + #ifndef NK_INT32 + #if defined(_MSC_VER) + #define NK_INT32 __int32 + #else + #define NK_INT32 signed int + #endif + #endif + #ifndef NK_UINT32 + #if defined(_MSC_VER) + #define NK_UINT32 unsigned __int32 + #else + #define NK_UINT32 unsigned int + #endif + #endif + #ifndef NK_SIZE_TYPE + #if defined(_WIN64) && defined(_MSC_VER) + #define NK_SIZE_TYPE unsigned __int64 + #elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER) + #define NK_SIZE_TYPE unsigned __int32 + #elif defined(__GNUC__) || defined(__clang__) + #if defined(__x86_64__) || defined(__ppc64__) + #define NK_SIZE_TYPE unsigned long + #else + #define NK_SIZE_TYPE unsigned int + #endif + #else + #define NK_SIZE_TYPE unsigned long + #endif + #endif + #ifndef NK_POINTER_TYPE + #if defined(_WIN64) && defined(_MSC_VER) + #define NK_POINTER_TYPE unsigned __int64 + #elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER) + #define NK_POINTER_TYPE unsigned __int32 + #elif defined(__GNUC__) || defined(__clang__) + #if defined(__x86_64__) || defined(__ppc64__) + #define NK_POINTER_TYPE unsigned long + #else + #define NK_POINTER_TYPE unsigned int + #endif + #else + #define NK_POINTER_TYPE unsigned long + #endif + #endif +#endif + +#ifndef NK_BOOL + #ifdef NK_INCLUDE_STANDARD_BOOL + #include + #define NK_BOOL bool + #else + #define NK_BOOL int /* could be char, use int for drop-in replacement backwards compatibility */ + #endif +#endif + +typedef NK_INT8 nk_char; +typedef NK_UINT8 nk_uchar; +typedef NK_UINT8 nk_byte; +typedef NK_INT16 nk_short; +typedef NK_UINT16 nk_ushort; +typedef NK_INT32 nk_int; +typedef NK_UINT32 nk_uint; +typedef NK_SIZE_TYPE nk_size; +typedef NK_POINTER_TYPE nk_ptr; +typedef NK_BOOL nk_bool; + +typedef nk_uint nk_hash; +typedef nk_uint nk_flags; +typedef nk_uint nk_rune; + +/* Make sure correct type size: + * This will fire with a negative subscript error if the type sizes + * are set incorrectly by the compiler, and compile out if not */ +NK_STATIC_ASSERT(sizeof(nk_short) == 2); +NK_STATIC_ASSERT(sizeof(nk_ushort) == 2); +NK_STATIC_ASSERT(sizeof(nk_uint) == 4); +NK_STATIC_ASSERT(sizeof(nk_int) == 4); +NK_STATIC_ASSERT(sizeof(nk_byte) == 1); +NK_STATIC_ASSERT(sizeof(nk_flags) >= 4); +NK_STATIC_ASSERT(sizeof(nk_rune) >= 4); +NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*)); +NK_STATIC_ASSERT(sizeof(nk_ptr) >= sizeof(void*)); +#ifdef NK_INCLUDE_STANDARD_BOOL +NK_STATIC_ASSERT(sizeof(nk_bool) == sizeof(bool)); +#else +NK_STATIC_ASSERT(sizeof(nk_bool) >= 2); +#endif + +/* ============================================================================ + * + * API + * + * =========================================================================== */ +struct nk_buffer; +struct nk_allocator; +struct nk_command_buffer; +struct nk_draw_command; +struct nk_convert_config; +struct nk_style_item; +struct nk_text_edit; +struct nk_draw_list; +struct nk_user_font; +struct nk_panel; +struct nk_context; +struct nk_draw_vertex_layout_element; +struct nk_style_button; +struct nk_style_toggle; +struct nk_style_selectable; +struct nk_style_slide; +struct nk_style_progress; +struct nk_style_scrollbar; +struct nk_style_edit; +struct nk_style_property; +struct nk_style_chart; +struct nk_style_combo; +struct nk_style_tab; +struct nk_style_window_header; +struct nk_style_window; + +enum {nk_false, nk_true}; +struct nk_color {nk_byte r,g,b,a;}; +struct nk_colorf {int r,g,b,a;}; +struct nk_vec2 {int x,y;}; +struct nk_vec2i {short x, y;}; +struct nk_rect {int x,y,w,h;}; +struct nk_recti {short x,y,w,h;}; +typedef char nk_glyph[NK_UTF_SIZE]; +typedef union {void *ptr; int id;} nk_handle; +struct nk_image {nk_handle handle;unsigned short w,h;unsigned short region[4];}; +struct nk_cursor {struct nk_image img; struct nk_vec2 size, offset;}; +struct nk_scroll {nk_uint x, y;}; + +enum nk_heading {NK_UP, NK_RIGHT, NK_DOWN, NK_LEFT}; +enum nk_button_behavior {NK_BUTTON_DEFAULT, NK_BUTTON_REPEATER}; +enum nk_modify {NK_FIXED = nk_false, NK_MODIFIABLE = nk_true}; +enum nk_orientation {NK_VERTICAL, NK_HORIZONTAL}; +enum nk_collapse_states {NK_MINIMIZED = nk_false, NK_MAXIMIZED = nk_true}; +enum nk_show_states {NK_HIDDEN = nk_false, NK_SHOWN = nk_true}; +enum nk_chart_type {NK_CHART_LINES, NK_CHART_COLUMN, NK_CHART_MAX}; +enum nk_chart_event {NK_CHART_HOVERING = 0x01, NK_CHART_CLICKED = 0x02}; +enum nk_color_format {NK_RGB, NK_RGBA}; +enum nk_popup_type {NK_POPUP_STATIC, NK_POPUP_DYNAMIC}; +enum nk_layout_format {NK_DYNAMIC, NK_STATIC}; +enum nk_tree_type {NK_TREE_NODE, NK_TREE_TAB}; + +typedef void*(*nk_plugin_alloc)(nk_handle, void *old, nk_size); +typedef void (*nk_plugin_free)(nk_handle, void *old); +typedef nk_bool(*nk_plugin_filter)(const struct nk_text_edit*, nk_rune unicode); +typedef void(*nk_plugin_paste)(nk_handle, struct nk_text_edit*); +typedef void(*nk_plugin_copy)(nk_handle, const char*, int len); + +struct nk_allocator { + nk_handle userdata; + nk_plugin_alloc alloc; + nk_plugin_free free; +}; +enum nk_symbol_type { + NK_SYMBOL_NONE, + NK_SYMBOL_X, + NK_SYMBOL_UNDERSCORE, + NK_SYMBOL_CIRCLE_SOLID, + NK_SYMBOL_CIRCLE_OUTLINE, + NK_SYMBOL_RECT_SOLID, + NK_SYMBOL_RECT_OUTLINE, + NK_SYMBOL_TRIANGLE_UP, + NK_SYMBOL_TRIANGLE_DOWN, + NK_SYMBOL_TRIANGLE_LEFT, + NK_SYMBOL_TRIANGLE_RIGHT, + NK_SYMBOL_PLUS, + NK_SYMBOL_MINUS, + NK_SYMBOL_MAX +}; +/* ============================================================================= + * + * CONTEXT + * + * =============================================================================*/ +/*/// ### Context +/// Contexts are the main entry point and the majestro of nuklear and contain all required state. +/// They are used for window, memory, input, style, stack, commands and time management and need +/// to be passed into all nuklear GUI specific functions. +/// +/// #### Usage +/// To use a context it first has to be initialized which can be achieved by calling +/// one of either `nk_init_default`, `nk_init_fixed`, `nk_init`, `nk_init_custom`. +/// Each takes in a font handle and a specific way of handling memory. Memory control +/// hereby ranges from standard library to just specifying a fixed sized block of memory +/// which nuklear has to manage itself from. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// // [...] +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// --------------------|------------------------------------------------------- +/// __nk_init_default__ | Initializes context with standard library memory allocation (malloc,free) +/// __nk_init_fixed__ | Initializes context from single fixed size memory block +/// __nk_init__ | Initializes context with memory allocator callbacks for alloc and free +/// __nk_init_custom__ | Initializes context from two buffers. One for draw commands the other for window/panel/table allocations +/// __nk_clear__ | Called at the end of the frame to reset and prepare the context for the next frame +/// __nk_free__ | Shutdown and free all memory allocated inside the context +/// __nk_set_user_data__| Utility function to pass user data to draw command + */ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +/*/// #### nk_init_default +/// Initializes a `nk_context` struct with a default standard library allocator. +/// Should be used if you don't want to be bothered with memory management in nuklear. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_init_default(struct nk_context *ctx, const struct nk_user_font *font); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|--------------------------------------------------------------- +/// __ctx__ | Must point to an either stack or heap allocated `nk_context` struct +/// __font__ | Must point to a previously initialized font handle for more info look at font documentation +/// +/// Returns either `false(0)` on failure or `true(1)` on success. +/// +*/ +NK_API nk_bool nk_init_default(struct nk_context*, const struct nk_user_font*); +#endif +/*/// #### nk_init_fixed +/// Initializes a `nk_context` struct from single fixed size memory block +/// Should be used if you want complete control over nuklear's memory management. +/// Especially recommended for system with little memory or systems with virtual memory. +/// For the later case you can just allocate for example 16MB of virtual memory +/// and only the required amount of memory will actually be committed. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size, const struct nk_user_font *font); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// !!! Warning +/// make sure the passed memory block is aligned correctly for `nk_draw_commands`. +/// +/// Parameter | Description +/// ------------|-------------------------------------------------------------- +/// __ctx__ | Must point to an either stack or heap allocated `nk_context` struct +/// __memory__ | Must point to a previously allocated memory block +/// __size__ | Must contain the total size of __memory__ +/// __font__ | Must point to a previously initialized font handle for more info look at font documentation +/// +/// Returns either `false(0)` on failure or `true(1)` on success. +*/ +NK_API nk_bool nk_init_fixed(struct nk_context*, void *memory, nk_size size, const struct nk_user_font*); +/*/// #### nk_init +/// Initializes a `nk_context` struct with memory allocation callbacks for nuklear to allocate +/// memory from. Used internally for `nk_init_default` and provides a kitchen sink allocation +/// interface to nuklear. Can be useful for cases like monitoring memory consumption. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_init(struct nk_context *ctx, struct nk_allocator *alloc, const struct nk_user_font *font); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|--------------------------------------------------------------- +/// __ctx__ | Must point to an either stack or heap allocated `nk_context` struct +/// __alloc__ | Must point to a previously allocated memory allocator +/// __font__ | Must point to a previously initialized font handle for more info look at font documentation +/// +/// Returns either `false(0)` on failure or `true(1)` on success. +*/ +NK_API nk_bool nk_init(struct nk_context*, struct nk_allocator*, const struct nk_user_font*); +/*/// #### nk_init_custom +/// Initializes a `nk_context` struct from two different either fixed or growing +/// buffers. The first buffer is for allocating draw commands while the second buffer is +/// used for allocating windows, panels and state tables. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_init_custom(struct nk_context *ctx, struct nk_buffer *cmds, struct nk_buffer *pool, const struct nk_user_font *font); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|--------------------------------------------------------------- +/// __ctx__ | Must point to an either stack or heap allocated `nk_context` struct +/// __cmds__ | Must point to a previously initialized memory buffer either fixed or dynamic to store draw commands into +/// __pool__ | Must point to a previously initialized memory buffer either fixed or dynamic to store windows, panels and tables +/// __font__ | Must point to a previously initialized font handle for more info look at font documentation +/// +/// Returns either `false(0)` on failure or `true(1)` on success. +*/ +NK_API nk_bool nk_init_custom(struct nk_context*, struct nk_buffer *cmds, struct nk_buffer *pool, const struct nk_user_font*); +/*/// #### nk_clear +/// Resets the context state at the end of the frame. This includes mostly +/// garbage collector tasks like removing windows or table not called and therefore +/// used anymore. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_clear(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +*/ +NK_API void nk_clear(struct nk_context*); +/*/// #### nk_free +/// Frees all memory allocated by nuklear. Not needed if context was +/// initialized with `nk_init_fixed`. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_free(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +*/ +NK_API void nk_free(struct nk_context*); +#ifdef NK_INCLUDE_COMMAND_USERDATA +/*/// #### nk_set_user_data +/// Sets the currently passed userdata passed down into each draw command. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_set_user_data(struct nk_context *ctx, nk_handle data); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|-------------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __data__ | Handle with either pointer or index to be passed into every draw commands +*/ +NK_API void nk_set_user_data(struct nk_context*, nk_handle handle); +#endif +/* ============================================================================= + * + * INPUT + * + * =============================================================================*/ +/*/// ### Input +/// The input API is responsible for holding the current input state composed of +/// mouse, key and text input states. +/// It is worth noting that no direct OS or window handling is done in nuklear. +/// Instead all input state has to be provided by platform specific code. This on one hand +/// expects more work from the user and complicates usage but on the other hand +/// provides simple abstraction over a big number of platforms, libraries and other +/// already provided functionality. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// // [...] +/// } +/// } nk_input_end(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Usage +/// Input state needs to be provided to nuklear by first calling `nk_input_begin` +/// which resets internal state like delta mouse position and button transistions. +/// After `nk_input_begin` all current input state needs to be provided. This includes +/// mouse motion, button and key pressed and released, text input and scrolling. +/// Both event- or state-based input handling are supported by this API +/// and should work without problems. Finally after all input state has been +/// mirrored `nk_input_end` needs to be called to finish input process. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// Event evt; +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// // [...] +/// } +/// } +/// nk_input_end(&ctx); +/// // [...] +/// nk_clear(&ctx); +/// } nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// --------------------|------------------------------------------------------- +/// __nk_input_begin__ | Begins the input mirroring process. Needs to be called before all other `nk_input_xxx` calls +/// __nk_input_motion__ | Mirrors mouse cursor position +/// __nk_input_key__ | Mirrors key state with either pressed or released +/// __nk_input_button__ | Mirrors mouse button state with either pressed or released +/// __nk_input_scroll__ | Mirrors mouse scroll values +/// __nk_input_char__ | Adds a single ASCII text character into an internal text buffer +/// __nk_input_glyph__ | Adds a single multi-byte UTF-8 character into an internal text buffer +/// __nk_input_unicode__| Adds a single unicode rune into an internal text buffer +/// __nk_input_end__ | Ends the input mirroring process by calculating state changes. Don't call any `nk_input_xxx` function referenced above after this call +*/ +enum nk_keys { + NK_KEY_NONE, + NK_KEY_SHIFT, + NK_KEY_CTRL, + NK_KEY_DEL, + NK_KEY_ENTER, + NK_KEY_TAB, + NK_KEY_BACKSPACE, + NK_KEY_COPY, + NK_KEY_CUT, + NK_KEY_PASTE, + NK_KEY_UP, + NK_KEY_DOWN, + NK_KEY_LEFT, + NK_KEY_RIGHT, + /* Shortcuts: text field */ + NK_KEY_TEXT_INSERT_MODE, + NK_KEY_TEXT_REPLACE_MODE, + NK_KEY_TEXT_RESET_MODE, + NK_KEY_TEXT_LINE_START, + NK_KEY_TEXT_LINE_END, + NK_KEY_TEXT_START, + NK_KEY_TEXT_END, + NK_KEY_TEXT_UNDO, + NK_KEY_TEXT_REDO, + NK_KEY_TEXT_SELECT_ALL, + NK_KEY_TEXT_WORD_LEFT, + NK_KEY_TEXT_WORD_RIGHT, + /* Shortcuts: scrollbar */ + NK_KEY_SCROLL_START, + NK_KEY_SCROLL_END, + NK_KEY_SCROLL_DOWN, + NK_KEY_SCROLL_UP, + NK_KEY_MAX +}; +enum nk_buttons { + NK_BUTTON_LEFT, + NK_BUTTON_MIDDLE, + NK_BUTTON_RIGHT, + NK_BUTTON_DOUBLE, + NK_BUTTON_MAX +}; +/*/// #### nk_input_begin +/// Begins the input mirroring process by resetting text, scroll +/// mouse, previous mouse position and movement as well as key state transitions, +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_begin(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +*/ +NK_API void nk_input_begin(struct nk_context*); +/*/// #### nk_input_motion +/// Mirrors current mouse position to nuklear +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_motion(struct nk_context *ctx, int x, int y); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __x__ | Must hold an integer describing the current mouse cursor x-position +/// __y__ | Must hold an integer describing the current mouse cursor y-position +*/ +NK_API void nk_input_motion(struct nk_context*, int x, int y); +/*/// #### nk_input_key +/// Mirrors the state of a specific key to nuklear +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_key(struct nk_context*, enum nk_keys key, nk_bool down); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __key__ | Must be any value specified in enum `nk_keys` that needs to be mirrored +/// __down__ | Must be 0 for key is up and 1 for key is down +*/ +NK_API void nk_input_key(struct nk_context*, enum nk_keys, nk_bool down); +/*/// #### nk_input_button +/// Mirrors the state of a specific mouse button to nuklear +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_button(struct nk_context *ctx, enum nk_buttons btn, int x, int y, nk_bool down); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __btn__ | Must be any value specified in enum `nk_buttons` that needs to be mirrored +/// __x__ | Must contain an integer describing mouse cursor x-position on click up/down +/// __y__ | Must contain an integer describing mouse cursor y-position on click up/down +/// __down__ | Must be 0 for key is up and 1 for key is down +*/ +NK_API void nk_input_button(struct nk_context*, enum nk_buttons, int x, int y, nk_bool down); +/*/// #### nk_input_scroll +/// Copies the last mouse scroll value to nuklear. Is generally +/// a scroll value. So does not have to come from mouse and could also originate +/// TODO finish this sentence +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_scroll(struct nk_context *ctx, struct nk_vec2 val); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __val__ | vector with both X- as well as Y-scroll value +*/ +NK_API void nk_input_scroll(struct nk_context*, struct nk_vec2 val); +/*/// #### nk_input_char +/// Copies a single ASCII character into an internal text buffer +/// This is basically a helper function to quickly push ASCII characters into +/// nuklear. +/// +/// !!! Note +/// Stores up to NK_INPUT_MAX bytes between `nk_input_begin` and `nk_input_end`. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_char(struct nk_context *ctx, char c); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __c__ | Must be a single ASCII character preferable one that can be printed +*/ +NK_API void nk_input_char(struct nk_context*, char); +/*/// #### nk_input_glyph +/// Converts an encoded unicode rune into UTF-8 and copies the result into an +/// internal text buffer. +/// +/// !!! Note +/// Stores up to NK_INPUT_MAX bytes between `nk_input_begin` and `nk_input_end`. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_glyph(struct nk_context *ctx, const nk_glyph g); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __g__ | UTF-32 unicode codepoint +*/ +NK_API void nk_input_glyph(struct nk_context*, const nk_glyph); +/*/// #### nk_input_unicode +/// Converts a unicode rune into UTF-8 and copies the result +/// into an internal text buffer. +/// !!! Note +/// Stores up to NK_INPUT_MAX bytes between `nk_input_begin` and `nk_input_end`. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_unicode(struct nk_context*, nk_rune rune); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +/// __rune__ | UTF-32 unicode codepoint +*/ +NK_API void nk_input_unicode(struct nk_context*, nk_rune); +/*/// #### nk_input_end +/// End the input mirroring process by resetting mouse grabbing +/// state to ensure the mouse cursor is not grabbed indefinitely. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_input_end(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to a previously initialized `nk_context` struct +*/ +NK_API void nk_input_end(struct nk_context*); +/* ============================================================================= + * + * DRAWING + * + * =============================================================================*/ +/*/// ### Drawing +/// This library was designed to be render backend agnostic so it does +/// not draw anything to screen directly. Instead all drawn shapes, widgets +/// are made of, are buffered into memory and make up a command queue. +/// Each frame therefore fills the command buffer with draw commands +/// that then need to be executed by the user and his own render backend. +/// After that the command buffer needs to be cleared and a new frame can be +/// started. It is probably important to note that the command buffer is the main +/// drawing API and the optional vertex buffer API only takes this format and +/// converts it into a hardware accessible format. +/// +/// #### Usage +/// To draw all draw commands accumulated over a frame you need your own render +/// backend able to draw a number of 2D primitives. This includes at least +/// filled and stroked rectangles, circles, text, lines, triangles and scissors. +/// As soon as this criterion is met you can iterate over each draw command +/// and execute each draw command in a interpreter like fashion: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case //...: +/// //[...] +/// } +/// } +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// In program flow context draw commands need to be executed after input has been +/// gathered and the complete UI with windows and their contained widgets have +/// been executed and before calling `nk_clear` which frees all previously +/// allocated draw commands. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// Event evt; +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// [...] +/// } +/// } +/// nk_input_end(&ctx); +/// // +/// // [...] +/// // +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case ...: +/// // [...] +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// You probably noticed that you have to draw all of the UI each frame which is +/// quite wasteful. While the actual UI updating loop is quite fast rendering +/// without actually needing it is not. So there are multiple things you could do. +/// +/// First is only update on input. This of course is only an option if your +/// application only depends on the UI and does not require any outside calculations. +/// If you actually only update on input make sure to update the UI two times each +/// frame and call `nk_clear` directly after the first pass and only draw in +/// the second pass. In addition it is recommended to also add additional timers +/// to make sure the UI is not drawn more than a fixed number of frames per second. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// // [...wait for input ] +/// // [...do two UI passes ...] +/// do_ui(...) +/// nk_clear(&ctx); +/// do_ui(...) +/// // +/// // draw +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case ...: +/// //[...] +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// The second probably more applicable trick is to only draw if anything changed. +/// It is not really useful for applications with continuous draw loop but +/// quite useful for desktop applications. To actually get nuklear to only +/// draw on changes you first have to define `NK_ZERO_COMMAND_MEMORY` and +/// allocate a memory buffer that will store each unique drawing output. +/// After each frame you compare the draw command memory inside the library +/// with your allocated buffer by memcmp. If memcmp detects differences +/// you have to copy the command buffer into the allocated buffer +/// and then draw like usual (this example uses fixed memory but you could +/// use dynamically allocated memory). +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// //[... other defines ...] +/// #define NK_ZERO_COMMAND_MEMORY +/// #include "nuklear.h" +/// // +/// // setup context +/// struct nk_context ctx; +/// void *last = calloc(1,64*1024); +/// void *buf = calloc(1,64*1024); +/// nk_init_fixed(&ctx, buf, 64*1024); +/// // +/// // loop +/// while (1) { +/// // [...input...] +/// // [...ui...] +/// void *cmds = nk_buffer_memory(&ctx.memory); +/// if (memcmp(cmds, last, ctx.memory.allocated)) { +/// memcpy(last,cmds,ctx.memory.allocated); +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case ...: +/// // [...] +/// } +/// } +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Finally while using draw commands makes sense for higher abstracted platforms like +/// X11 and Win32 or drawing libraries it is often desirable to use graphics +/// hardware directly. Therefore it is possible to just define +/// `NK_INCLUDE_VERTEX_BUFFER_OUTPUT` which includes optional vertex output. +/// To access the vertex output you first have to convert all draw commands into +/// vertexes by calling `nk_convert` which takes in your preferred vertex format. +/// After successfully converting all draw commands just iterate over and execute all +/// vertex draw commands: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// // fill configuration +/// struct your_vertex +/// { +/// int pos[2]; // important to keep it to 2 ints +/// int uv[2]; +/// unsigned char col[4]; +/// }; +/// struct nk_convert_config cfg = {}; +/// static const struct nk_draw_vertex_layout_element vertex_layout[] = { +/// {NK_VERTEX_POSITION, NK_FORMAT_int, NK_OFFSETOF(struct your_vertex, pos)}, +/// {NK_VERTEX_TEXCOORD, NK_FORMAT_int, NK_OFFSETOF(struct your_vertex, uv)}, +/// {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct your_vertex, col)}, +/// {NK_VERTEX_LAYOUT_END} +/// }; +/// cfg.shape_AA = NK_ANTI_ALIASING_ON; +/// cfg.line_AA = NK_ANTI_ALIASING_ON; +/// cfg.vertex_layout = vertex_layout; +/// cfg.vertex_size = sizeof(struct your_vertex); +/// cfg.vertex_alignment = NK_ALIGNOF(struct your_vertex); +/// cfg.circle_segment_count = 22; +/// cfg.curve_segment_count = 22; +/// cfg.arc_segment_count = 22; +/// cfg.global_alpha = 1.0f; +/// cfg.null = dev->null; +/// // +/// // setup buffers and convert +/// struct nk_buffer cmds, verts, idx; +/// nk_buffer_init_default(&cmds); +/// nk_buffer_init_default(&verts); +/// nk_buffer_init_default(&idx); +/// nk_convert(&ctx, &cmds, &verts, &idx, &cfg); +/// // +/// // draw +/// nk_draw_foreach(cmd, &ctx, &cmds) { +/// if (!cmd->elem_count) continue; +/// //[...] +/// } +/// nk_buffer_free(&cms); +/// nk_buffer_free(&verts); +/// nk_buffer_free(&idx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// --------------------|------------------------------------------------------- +/// __nk__begin__ | Returns the first draw command in the context draw command list to be drawn +/// __nk__next__ | Increments the draw command iterator to the next command inside the context draw command list +/// __nk_foreach__ | Iterates over each draw command inside the context draw command list +/// __nk_convert__ | Converts from the abstract draw commands list into a hardware accessible vertex format +/// __nk_draw_begin__ | Returns the first vertex command in the context vertex draw list to be executed +/// __nk__draw_next__ | Increments the vertex command iterator to the next command inside the context vertex command list +/// __nk__draw_end__ | Returns the end of the vertex draw list +/// __nk_draw_foreach__ | Iterates over each vertex draw command inside the vertex draw list +*/ +enum nk_anti_aliasing {NK_ANTI_ALIASING_OFF, NK_ANTI_ALIASING_ON}; +enum nk_convert_result { + NK_CONVERT_SUCCESS = 0, + NK_CONVERT_INVALID_PARAM = 1, + NK_CONVERT_COMMAND_BUFFER_FULL = NK_FLAG(1), + NK_CONVERT_VERTEX_BUFFER_FULL = NK_FLAG(2), + NK_CONVERT_ELEMENT_BUFFER_FULL = NK_FLAG(3) +}; +struct nk_draw_null_texture { + nk_handle texture; /* texture handle to a texture with a white pixel */ + struct nk_vec2 uv; /* coordinates to a white pixel in the texture */ +}; +struct nk_convert_config { + int global_alpha; /* global alpha value */ + enum nk_anti_aliasing line_AA; /* line anti-aliasing flag can be turned off if you are tight on memory */ + enum nk_anti_aliasing shape_AA; /* shape anti-aliasing flag can be turned off if you are tight on memory */ + unsigned circle_segment_count; /* number of segments used for circles: default to 22 */ + unsigned arc_segment_count; /* number of segments used for arcs: default to 22 */ + unsigned curve_segment_count; /* number of segments used for curves: default to 22 */ + struct nk_draw_null_texture null; /* handle to texture with a white pixel for shape drawing */ + const struct nk_draw_vertex_layout_element *vertex_layout; /* describes the vertex output format and packing */ + nk_size vertex_size; /* sizeof one vertex for vertex packing */ + nk_size vertex_alignment; /* vertex alignment: Can be obtained by NK_ALIGNOF */ +}; +/*/// #### nk__begin +/// Returns a draw command list iterator to iterate all draw +/// commands accumulated over one frame. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_command* nk__begin(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | must point to an previously initialized `nk_context` struct at the end of a frame +/// +/// Returns draw command pointer pointing to the first command inside the draw command list +*/ +NK_API const struct nk_command* nk__begin(struct nk_context*); +/*/// #### nk__next +/// Returns draw command pointer pointing to the next command inside the draw command list +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_command* nk__next(struct nk_context*, const struct nk_command*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// __cmd__ | Must point to an previously a draw command either returned by `nk__begin` or `nk__next` +/// +/// Returns draw command pointer pointing to the next command inside the draw command list +*/ +NK_API const struct nk_command* nk__next(struct nk_context*, const struct nk_command*); +/*/// #### nk_foreach +/// Iterates over each draw command inside the context draw command list +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_foreach(c, ctx) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// __cmd__ | Command pointer initialized to NULL +/// +/// Iterates over each draw command inside the context draw command list +*/ +#define nk_foreach(c, ctx) for((c) = nk__begin(ctx); (c) != 0; (c) = nk__next(ctx,c)) +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT +/*/// #### nk_convert +/// Converts all internal draw commands into vertex draw commands and fills +/// three buffers with vertexes, vertex draw commands and vertex indices. The vertex format +/// as well as some other configuration values have to be configured by filling out a +/// `nk_convert_config` struct. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_flags nk_convert(struct nk_context *ctx, struct nk_buffer *cmds, +/// struct nk_buffer *vertices, struct nk_buffer *elements, const struct nk_convert_config*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// __cmds__ | Must point to a previously initialized buffer to hold converted vertex draw commands +/// __vertices__| Must point to a previously initialized buffer to hold all produced vertices +/// __elements__| Must point to a previously initialized buffer to hold all produced vertex indices +/// __config__ | Must point to a filled out `nk_config` struct to configure the conversion process +/// +/// Returns one of enum nk_convert_result error codes +/// +/// Parameter | Description +/// --------------------------------|----------------------------------------------------------- +/// NK_CONVERT_SUCCESS | Signals a successful draw command to vertex buffer conversion +/// NK_CONVERT_INVALID_PARAM | An invalid argument was passed in the function c / ---------------------all +/// NK_CONVERT_COMMAND_BUFFER_FULL | The provided buffer for storing draw commands is full or failed to allocate more memory +/// NK_CONVERT_VERTEX_BUFFER_FULL | The provided buffer for storing vertices is full or failed to allocate more memory +/// NK_CONVERT_ELEMENT_BUFFER_FULL | The provided buffer for storing indicies is full or failed to allocate more memory +*/ +NK_API nk_flags nk_convert(struct nk_context*, struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements, const struct nk_convert_config*); +/*/// #### nk__draw_begin +/// Returns a draw vertex command buffer iterator to iterate over the vertex draw command buffer +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_draw_command* nk__draw_begin(const struct nk_context*, const struct nk_buffer*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer +/// +/// Returns vertex draw command pointer pointing to the first command inside the vertex draw command buffer +*/ +NK_API const struct nk_draw_command* nk__draw_begin(const struct nk_context*, const struct nk_buffer*); +/*/// #### nk__draw_end +/// Returns the vertex draw command at the end of the vertex draw command buffer +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_draw_command* nk__draw_end(const struct nk_context *ctx, const struct nk_buffer *buf); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer +/// +/// Returns vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer +*/ +NK_API const struct nk_draw_command* nk__draw_end(const struct nk_context*, const struct nk_buffer*); +/*/// #### nk__draw_next +/// Increments the vertex draw command buffer iterator +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// const struct nk_draw_command* nk__draw_next(const struct nk_draw_command*, const struct nk_buffer*, const struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __cmd__ | Must point to an previously either by `nk__draw_begin` or `nk__draw_next` returned vertex draw command +/// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +/// +/// Returns vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer +*/ +NK_API const struct nk_draw_command* nk__draw_next(const struct nk_draw_command*, const struct nk_buffer*, const struct nk_context*); +/*/// #### nk_draw_foreach +/// Iterates over each vertex draw command inside a vertex draw command buffer +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_draw_foreach(cmd,ctx, b) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __cmd__ | `nk_draw_command`iterator set to NULL +/// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer +/// __ctx__ | Must point to an previously initialized `nk_context` struct at the end of a frame +*/ +#define nk_draw_foreach(cmd,ctx, b) for((cmd)=nk__draw_begin(ctx, b); (cmd)!=0; (cmd)=nk__draw_next(cmd, b, ctx)) +#endif +/* ============================================================================= + * + * WINDOW + * + * ============================================================================= +/// ### Window +/// Windows are the main persistent state used inside nuklear and are life time +/// controlled by simply "retouching" (i.e. calling) each window each frame. +/// All widgets inside nuklear can only be added inside the function pair `nk_begin_xxx` +/// and `nk_end`. Calling any widgets outside these two functions will result in an +/// assert in debug or no state change in release mode.

+/// +/// Each window holds frame persistent state like position, size, flags, state tables, +/// and some garbage collected internal persistent widget state. Each window +/// is linked into a window stack list which determines the drawing and overlapping +/// order. The topmost window thereby is the currently active window.

+/// +/// To change window position inside the stack occurs either automatically by +/// user input by being clicked on or programmatically by calling `nk_window_focus`. +/// Windows by default are visible unless explicitly being defined with flag +/// `NK_WINDOW_HIDDEN`, the user clicked the close button on windows with flag +/// `NK_WINDOW_CLOSABLE` or if a window was explicitly hidden by calling +/// `nk_window_show`. To explicitly close and destroy a window call `nk_window_close`.

+/// +/// #### Usage +/// To create and keep a window you have to call one of the two `nk_begin_xxx` +/// functions to start window declarations and `nk_end` at the end. Furthermore it +/// is recommended to check the return value of `nk_begin_xxx` and only process +/// widgets inside the window if the value is not 0. Either way you have to call +/// `nk_end` at the end of window declarations. Furthermore, do not attempt to +/// nest `nk_begin_xxx` calls which will hopefully result in an assert or if not +/// in a segmentation fault. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // [... widgets ...] +/// } +/// nk_end(ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// In the grand concept window and widget declarations need to occur after input +/// handling and before drawing to screen. Not doing so can result in higher +/// latency or at worst invalid behavior. Furthermore make sure that `nk_clear` +/// is called at the end of the frame. While nuklear's default platform backends +/// already call `nk_clear` for you if you write your own backend not calling +/// `nk_clear` can cause asserts or even worse undefined behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// Event evt; +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// nk_input_xxx(...); +/// } +/// } +/// nk_input_end(&ctx); +/// +/// if (nk_begin_xxx(...) { +/// //[...] +/// } +/// nk_end(ctx); +/// +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case //...: +/// //[...] +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// ------------------------------------|---------------------------------------- +/// nk_begin | Starts a new window; needs to be called every frame for every window (unless hidden) or otherwise the window gets removed +/// nk_begin_titled | Extended window start with separated title and identifier to allow multiple windows with same name but not title +/// nk_end | Needs to be called at the end of the window building process to process scaling, scrollbars and general cleanup +// +/// nk_window_find | Finds and returns the window with give name +/// nk_window_get_bounds | Returns a rectangle with screen position and size of the currently processed window. +/// nk_window_get_position | Returns the position of the currently processed window +/// nk_window_get_size | Returns the size with width and height of the currently processed window +/// nk_window_get_width | Returns the width of the currently processed window +/// nk_window_get_height | Returns the height of the currently processed window +/// nk_window_get_panel | Returns the underlying panel which contains all processing state of the current window +/// nk_window_get_content_region | Returns the position and size of the currently visible and non-clipped space inside the currently processed window +/// nk_window_get_content_region_min | Returns the upper rectangle position of the currently visible and non-clipped space inside the currently processed window +/// nk_window_get_content_region_max | Returns the upper rectangle position of the currently visible and non-clipped space inside the currently processed window +/// nk_window_get_content_region_size | Returns the size of the currently visible and non-clipped space inside the currently processed window +/// nk_window_get_canvas | Returns the draw command buffer. Can be used to draw custom widgets +/// nk_window_get_scroll | Gets the scroll offset of the current window +/// nk_window_has_focus | Returns if the currently processed window is currently active +/// nk_window_is_collapsed | Returns if the window with given name is currently minimized/collapsed +/// nk_window_is_closed | Returns if the currently processed window was closed +/// nk_window_is_hidden | Returns if the currently processed window was hidden +/// nk_window_is_active | Same as nk_window_has_focus for some reason +/// nk_window_is_hovered | Returns if the currently processed window is currently being hovered by mouse +/// nk_window_is_any_hovered | Return if any window currently hovered +/// nk_item_is_any_active | Returns if any window or widgets is currently hovered or active +// +/// nk_window_set_bounds | Updates position and size of the currently processed window +/// nk_window_set_position | Updates position of the currently process window +/// nk_window_set_size | Updates the size of the currently processed window +/// nk_window_set_focus | Set the currently processed window as active window +/// nk_window_set_scroll | Sets the scroll offset of the current window +// +/// nk_window_close | Closes the window with given window name which deletes the window at the end of the frame +/// nk_window_collapse | Collapses the window with given window name +/// nk_window_collapse_if | Collapses the window with given window name if the given condition was met +/// nk_window_show | Hides a visible or reshows a hidden window +/// nk_window_show_if | Hides/shows a window depending on condition +*/ +/* +/// #### nk_panel_flags +/// Flag | Description +/// ----------------------------|---------------------------------------- +/// NK_WINDOW_BORDER | Draws a border around the window to visually separate window from the background +/// NK_WINDOW_MOVABLE | The movable flag indicates that a window can be moved by user input or by dragging the window header +/// NK_WINDOW_SCALABLE | The scalable flag indicates that a window can be scaled by user input by dragging a scaler icon at the button of the window +/// NK_WINDOW_CLOSABLE | Adds a closable icon into the header +/// NK_WINDOW_MINIMIZABLE | Adds a minimize icon into the header +/// NK_WINDOW_NO_SCROLLBAR | Removes the scrollbar from the window +/// NK_WINDOW_TITLE | Forces a header at the top at the window showing the title +/// NK_WINDOW_SCROLL_AUTO_HIDE | Automatically hides the window scrollbar if no user interaction: also requires delta time in `nk_context` to be set each frame +/// NK_WINDOW_BACKGROUND | Always keep window in the background +/// NK_WINDOW_SCALE_LEFT | Puts window scaler in the left-bottom corner instead right-bottom +/// NK_WINDOW_NO_INPUT | Prevents window of scaling, moving or getting focus +/// +/// #### nk_collapse_states +/// State | Description +/// ----------------|----------------------------------------------------------- +/// __NK_MINIMIZED__| UI section is collased and not visibile until maximized +/// __NK_MAXIMIZED__| UI section is extended and visibile until minimized +///

+*/ +enum nk_panel_flags { + NK_WINDOW_BORDER = NK_FLAG(0), + NK_WINDOW_MOVABLE = NK_FLAG(1), + NK_WINDOW_SCALABLE = NK_FLAG(2), + NK_WINDOW_CLOSABLE = NK_FLAG(3), + NK_WINDOW_MINIMIZABLE = NK_FLAG(4), + NK_WINDOW_NO_SCROLLBAR = NK_FLAG(5), + NK_WINDOW_TITLE = NK_FLAG(6), + NK_WINDOW_SCROLL_AUTO_HIDE = NK_FLAG(7), + NK_WINDOW_BACKGROUND = NK_FLAG(8), + NK_WINDOW_SCALE_LEFT = NK_FLAG(9), + NK_WINDOW_NO_INPUT = NK_FLAG(10) +}; +/*/// #### nk_begin +/// Starts a new window; needs to be called every frame for every +/// window (unless hidden) or otherwise the window gets removed +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __title__ | Window title and identifier. Needs to be persistent over frames to identify the window +/// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors +/// +/// Returns `true(1)` if the window can be filled up with widgets from this point +/// until `nk_end` or `false(0)` otherwise for example if minimized +*/ +NK_API nk_bool nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_begin_titled +/// Extended window start with separated title and identifier to allow multiple +/// windows with same title but not name +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Window identifier. Needs to be persistent over frames to identify the window +/// __title__ | Window title displayed inside header if flag `NK_WINDOW_TITLE` or either `NK_WINDOW_CLOSABLE` or `NK_WINDOW_MINIMIZED` was set +/// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors +/// +/// Returns `true(1)` if the window can be filled up with widgets from this point +/// until `nk_end` or `false(0)` otherwise for example if minimized +*/ +NK_API nk_bool nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_end +/// Needs to be called at the end of the window building process to process scaling, scrollbars and general cleanup. +/// All widget calls after this functions will result in asserts or no state changes +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_end(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +*/ +NK_API void nk_end(struct nk_context *ctx); +/*/// #### nk_window_find +/// Finds and returns a window from passed name +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_window *nk_window_find(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Window identifier +/// +/// Returns a `nk_window` struct pointing to the identified window or NULL if +/// no window with the given name was found +*/ +NK_API struct nk_window *nk_window_find(struct nk_context *ctx, const char *name); +/*/// #### nk_window_get_bounds +/// Returns a rectangle with screen position and size of the currently processed window +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_window_get_bounds(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns a `nk_rect` struct with window upper left window position and size +*/ +NK_API struct nk_rect nk_window_get_bounds(const struct nk_context *ctx); +/*/// #### nk_window_get_position +/// Returns the position of the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_window_get_position(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns a `nk_vec2` struct with window upper left position +*/ +NK_API struct nk_vec2 nk_window_get_position(const struct nk_context *ctx); +/*/// #### nk_window_get_size +/// Returns the size with width and height of the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_window_get_size(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns a `nk_vec2` struct with window width and height +*/ +NK_API struct nk_vec2 nk_window_get_size(const struct nk_context*); +/*/// #### nk_window_get_width +/// Returns the width of the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_window_get_width(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns the current window width +*/ +NK_API int nk_window_get_width(const struct nk_context*); +/*/// #### nk_window_get_height +/// Returns the height of the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_window_get_height(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns the current window height +*/ +NK_API int nk_window_get_height(const struct nk_context*); +/*/// #### nk_window_get_panel +/// Returns the underlying panel which contains all processing state of the current window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// !!! WARNING +/// Do not keep the returned panel pointer around, it is only valid until `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_panel* nk_window_get_panel(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns a pointer to window internal `nk_panel` state. +*/ +NK_API struct nk_panel* nk_window_get_panel(struct nk_context*); +/*/// #### nk_window_get_content_region +/// Returns the position and size of the currently visible and non-clipped space +/// inside the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_window_get_content_region(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `nk_rect` struct with screen position and size (no scrollbar offset) +/// of the visible space inside the current window +*/ +NK_API struct nk_rect nk_window_get_content_region(struct nk_context*); +/*/// #### nk_window_get_content_region_min +/// Returns the upper left position of the currently visible and non-clipped +/// space inside the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_window_get_content_region_min(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// returns `nk_vec2` struct with upper left screen position (no scrollbar offset) +/// of the visible space inside the current window +*/ +NK_API struct nk_vec2 nk_window_get_content_region_min(struct nk_context*); +/*/// #### nk_window_get_content_region_max +/// Returns the lower right screen position of the currently visible and +/// non-clipped space inside the currently processed window. +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_window_get_content_region_max(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `nk_vec2` struct with lower right screen position (no scrollbar offset) +/// of the visible space inside the current window +*/ +NK_API struct nk_vec2 nk_window_get_content_region_max(struct nk_context*); +/*/// #### nk_window_get_content_region_size +/// Returns the size of the currently visible and non-clipped space inside the +/// currently processed window +/// +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_window_get_content_region_size(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `nk_vec2` struct with size the visible space inside the current window +*/ +NK_API struct nk_vec2 nk_window_get_content_region_size(struct nk_context*); +/*/// #### nk_window_get_canvas +/// Returns the draw command buffer. Can be used to draw custom widgets +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// !!! WARNING +/// Do not keep the returned command buffer pointer around it is only valid until `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_command_buffer* nk_window_get_canvas(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns a pointer to window internal `nk_command_buffer` struct used as +/// drawing canvas. Can be used to do custom drawing. +*/ +NK_API struct nk_command_buffer* nk_window_get_canvas(struct nk_context*); +/*/// #### nk_window_get_scroll +/// Gets the scroll offset for the current window +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_get_scroll(struct nk_context *ctx, nk_uint *offset_x, nk_uint *offset_y); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// -------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __offset_x__ | A pointer to the x offset output (or NULL to ignore) +/// __offset_y__ | A pointer to the y offset output (or NULL to ignore) +*/ +NK_API void nk_window_get_scroll(struct nk_context*, nk_uint *offset_x, nk_uint *offset_y); +/*/// #### nk_window_has_focus +/// Returns if the currently processed window is currently active +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_has_focus(const struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `false(0)` if current window is not active or `true(1)` if it is +*/ +NK_API nk_bool nk_window_has_focus(const struct nk_context*); +/*/// #### nk_window_is_hovered +/// Return if the current window is being hovered +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_hovered(struct nk_context *ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `true(1)` if current window is hovered or `false(0)` otherwise +*/ +NK_API nk_bool nk_window_is_hovered(struct nk_context*); +/*/// #### nk_window_is_collapsed +/// Returns if the window with given name is currently minimized/collapsed +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_collapsed(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of window you want to check if it is collapsed +/// +/// Returns `true(1)` if current window is minimized and `false(0)` if window not +/// found or is not minimized +*/ +NK_API nk_bool nk_window_is_collapsed(struct nk_context *ctx, const char *name); +/*/// #### nk_window_is_closed +/// Returns if the window with given name was closed by calling `nk_close` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_closed(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of window you want to check if it is closed +/// +/// Returns `true(1)` if current window was closed or `false(0)` window not found or not closed +*/ +NK_API nk_bool nk_window_is_closed(struct nk_context*, const char*); +/*/// #### nk_window_is_hidden +/// Returns if the window with given name is hidden +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_hidden(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of window you want to check if it is hidden +/// +/// Returns `true(1)` if current window is hidden or `false(0)` window not found or visible +*/ +NK_API nk_bool nk_window_is_hidden(struct nk_context*, const char*); +/*/// #### nk_window_is_active +/// Same as nk_window_has_focus for some reason +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_active(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of window you want to check if it is active +/// +/// Returns `true(1)` if current window is active or `false(0)` window not found or not active +*/ +NK_API nk_bool nk_window_is_active(struct nk_context*, const char*); +/*/// #### nk_window_is_any_hovered +/// Returns if the any window is being hovered +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_window_is_any_hovered(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `true(1)` if any window is hovered or `false(0)` otherwise +*/ +NK_API nk_bool nk_window_is_any_hovered(struct nk_context*); +/*/// #### nk_item_is_any_active +/// Returns if the any window is being hovered or any widget is currently active. +/// Can be used to decide if input should be processed by UI or your specific input handling. +/// Example could be UI and 3D camera to move inside a 3D space. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_item_is_any_active(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// +/// Returns `true(1)` if any window is hovered or any item is active or `false(0)` otherwise +*/ +NK_API nk_bool nk_item_is_any_active(struct nk_context*); +/*/// #### nk_window_set_bounds +/// Updates position and size of window with passed in name +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_set_bounds(struct nk_context*, const char *name, struct nk_rect bounds); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to modify both position and size +/// __bounds__ | Must point to a `nk_rect` struct with the new position and size +*/ +NK_API void nk_window_set_bounds(struct nk_context*, const char *name, struct nk_rect bounds); +/*/// #### nk_window_set_position +/// Updates position of window with passed name +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_set_position(struct nk_context*, const char *name, struct nk_vec2 pos); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to modify both position +/// __pos__ | Must point to a `nk_vec2` struct with the new position +*/ +NK_API void nk_window_set_position(struct nk_context*, const char *name, struct nk_vec2 pos); +/*/// #### nk_window_set_size +/// Updates size of window with passed in name +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_set_size(struct nk_context*, const char *name, struct nk_vec2); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to modify both window size +/// __size__ | Must point to a `nk_vec2` struct with new window size +*/ +NK_API void nk_window_set_size(struct nk_context*, const char *name, struct nk_vec2); +/*/// #### nk_window_set_focus +/// Sets the window with given name as active +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_set_focus(struct nk_context*, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to set focus on +*/ +NK_API void nk_window_set_focus(struct nk_context*, const char *name); +/*/// #### nk_window_set_scroll +/// Sets the scroll offset for the current window +/// !!! WARNING +/// Only call this function between calls `nk_begin_xxx` and `nk_end` +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_set_scroll(struct nk_context *ctx, nk_uint offset_x, nk_uint offset_y); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// -------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __offset_x__ | The x offset to scroll to +/// __offset_y__ | The y offset to scroll to +*/ +NK_API void nk_window_set_scroll(struct nk_context*, nk_uint offset_x, nk_uint offset_y); +/*/// #### nk_window_close +/// Closes a window and marks it for being freed at the end of the frame +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_close(struct nk_context *ctx, const char *name); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to close +*/ +NK_API void nk_window_close(struct nk_context *ctx, const char *name); +/*/// #### nk_window_collapse +/// Updates collapse state of a window with given name +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_collapse(struct nk_context*, const char *name, enum nk_collapse_states state); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to close +/// __state__ | value out of nk_collapse_states section +*/ +NK_API void nk_window_collapse(struct nk_context*, const char *name, enum nk_collapse_states state); +/*/// #### nk_window_collapse_if +/// Updates collapse state of a window with given name if given condition is met +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_collapse_if(struct nk_context*, const char *name, enum nk_collapse_states, int cond); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to either collapse or maximize +/// __state__ | value out of nk_collapse_states section the window should be put into +/// __cond__ | condition that has to be met to actually commit the collapse state change +*/ +NK_API void nk_window_collapse_if(struct nk_context*, const char *name, enum nk_collapse_states, int cond); +/*/// #### nk_window_show +/// updates visibility state of a window with given name +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_show(struct nk_context*, const char *name, enum nk_show_states); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to either collapse or maximize +/// __state__ | state with either visible or hidden to modify the window with +*/ +NK_API void nk_window_show(struct nk_context*, const char *name, enum nk_show_states); +/*/// #### nk_window_show_if +/// Updates visibility state of a window with given name if a given condition is met +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_window_show_if(struct nk_context*, const char *name, enum nk_show_states, int cond); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __name__ | Identifier of the window to either hide or show +/// __state__ | state with either visible or hidden to modify the window with +/// __cond__ | condition that has to be met to actually commit the visbility state change +*/ +NK_API void nk_window_show_if(struct nk_context*, const char *name, enum nk_show_states, int cond); +/* ============================================================================= + * + * LAYOUT + * + * ============================================================================= +/// ### Layouting +/// Layouting in general describes placing widget inside a window with position and size. +/// While in this particular implementation there are five different APIs for layouting +/// each with different trade offs between control and ease of use.

+/// +/// All layouting methods in this library are based around the concept of a row. +/// A row has a height the window content grows by and a number of columns and each +/// layouting method specifies how each widget is placed inside the row. +/// After a row has been allocated by calling a layouting functions and then +/// filled with widgets will advance an internal pointer over the allocated row.

+/// +/// To actually define a layout you just call the appropriate layouting function +/// and each subsequent widget call will place the widget as specified. Important +/// here is that if you define more widgets then columns defined inside the layout +/// functions it will allocate the next row without you having to make another layouting

+/// call. +/// +/// Biggest limitation with using all these APIs outside the `nk_layout_space_xxx` API +/// is that you have to define the row height for each. However the row height +/// often depends on the height of the font.

+/// +/// To fix that internally nuklear uses a minimum row height that is set to the +/// height plus padding of currently active font and overwrites the row height +/// value if zero.

+/// +/// If you manually want to change the minimum row height then +/// use nk_layout_set_min_row_height, and use nk_layout_reset_min_row_height to +/// reset it back to be derived from font height.

+/// +/// Also if you change the font in nuklear it will automatically change the minimum +/// row height for you and. This means if you change the font but still want +/// a minimum row height smaller than the font you have to repush your value.

+/// +/// For actually more advanced UI I would even recommend using the `nk_layout_space_xxx` +/// layouting method in combination with a cassowary constraint solver (there are +/// some versions on github with permissive license model) to take over all control over widget +/// layouting yourself. However for quick and dirty layouting using all the other layouting +/// functions should be fine. +/// +/// #### Usage +/// 1. __nk_layout_row_dynamic__

+/// The easiest layouting function is `nk_layout_row_dynamic`. It provides each +/// widgets with same horizontal space inside the row and dynamically grows +/// if the owning window grows in width. So the number of columns dictates +/// the size of each widget dynamically by formula: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// widget_width = (window_width - padding - spacing) * (1/colum_count) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Just like all other layouting APIs if you define more widget than columns this +/// library will allocate a new row and keep all layouting parameters previously +/// defined. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // first row with height: 30 composed of two widgets +/// nk_layout_row_dynamic(&ctx, 30, 2); +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // second row with same parameter as defined above +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // third row uses 0 for height which will use auto layouting +/// nk_layout_row_dynamic(&ctx, 0, 2); +/// nk_widget(...); +/// nk_widget(...); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// 2. __nk_layout_row_static__

+/// Another easy layouting function is `nk_layout_row_static`. It provides each +/// widget with same horizontal pixel width inside the row and does not grow +/// if the owning window scales smaller or bigger. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // first row with height: 30 composed of two widgets with width: 80 +/// nk_layout_row_static(&ctx, 30, 80, 2); +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // second row with same parameter as defined above +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // third row uses 0 for height which will use auto layouting +/// nk_layout_row_static(&ctx, 0, 80, 2); +/// nk_widget(...); +/// nk_widget(...); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// 3. __nk_layout_row_xxx__

+/// A little bit more advanced layouting API are functions `nk_layout_row_begin`, +/// `nk_layout_row_push` and `nk_layout_row_end`. They allow to directly +/// specify each column pixel or window ratio in a row. It supports either +/// directly setting per column pixel width or widget window ratio but not +/// both. Furthermore it is a immediate mode API so each value is directly +/// pushed before calling a widget. Therefore the layout is not automatically +/// repeating like the last two layouting functions. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // first row with height: 25 composed of two widgets with width 60 and 40 +/// nk_layout_row_begin(ctx, NK_STATIC, 25, 2); +/// nk_layout_row_push(ctx, 60); +/// nk_widget(...); +/// nk_layout_row_push(ctx, 40); +/// nk_widget(...); +/// nk_layout_row_end(ctx); +/// // +/// // second row with height: 25 composed of two widgets with window ratio 0.25 and 0.75 +/// nk_layout_row_begin(ctx, NK_DYNAMIC, 25, 2); +/// nk_layout_row_push(ctx, 0.25f); +/// nk_widget(...); +/// nk_layout_row_push(ctx, 0.75f); +/// nk_widget(...); +/// nk_layout_row_end(ctx); +/// // +/// // third row with auto generated height: composed of two widgets with window ratio 0.25 and 0.75 +/// nk_layout_row_begin(ctx, NK_DYNAMIC, 0, 2); +/// nk_layout_row_push(ctx, 0.25f); +/// nk_widget(...); +/// nk_layout_row_push(ctx, 0.75f); +/// nk_widget(...); +/// nk_layout_row_end(ctx); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// 4. __nk_layout_row__

+/// The array counterpart to API nk_layout_row_xxx is the single nk_layout_row +/// functions. Instead of pushing either pixel or window ratio for every widget +/// it allows to define it by array. The trade of for less control is that +/// `nk_layout_row` is automatically repeating. Otherwise the behavior is the +/// same. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // two rows with height: 30 composed of two widgets with width 60 and 40 +/// const int size[] = {60,40}; +/// nk_layout_row(ctx, NK_STATIC, 30, 2, ratio); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // two rows with height: 30 composed of two widgets with window ratio 0.25 and 0.75 +/// const int ratio[] = {0.25, 0.75}; +/// nk_layout_row(ctx, NK_DYNAMIC, 30, 2, ratio); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// // +/// // two rows with auto generated height composed of two widgets with window ratio 0.25 and 0.75 +/// const int ratio[] = {0.25, 0.75}; +/// nk_layout_row(ctx, NK_DYNAMIC, 30, 2, ratio); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// 5. __nk_layout_row_template_xxx__

+/// The most complex and second most flexible API is a simplified flexbox version without +/// line wrapping and weights for dynamic widgets. It is an immediate mode API but +/// unlike `nk_layout_row_xxx` it has auto repeat behavior and needs to be called +/// before calling the templated widgets. +/// The row template layout has three different per widget size specifier. The first +/// one is the `nk_layout_row_template_push_static` with fixed widget pixel width. +/// They do not grow if the row grows and will always stay the same. +/// The second size specifier is `nk_layout_row_template_push_variable` +/// which defines a minimum widget size but it also can grow if more space is available +/// not taken by other widgets. +/// Finally there are dynamic widgets with `nk_layout_row_template_push_dynamic` +/// which are completely flexible and unlike variable widgets can even shrink +/// to zero if not enough space is provided. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // two rows with height: 30 composed of three widgets +/// nk_layout_row_template_begin(ctx, 30); +/// nk_layout_row_template_push_dynamic(ctx); +/// nk_layout_row_template_push_variable(ctx, 80); +/// nk_layout_row_template_push_static(ctx, 80); +/// nk_layout_row_template_end(ctx); +/// // +/// // first row +/// nk_widget(...); // dynamic widget can go to zero if not enough space +/// nk_widget(...); // variable widget with min 80 pixel but can grow bigger if enough space +/// nk_widget(...); // static widget with fixed 80 pixel width +/// // +/// // second row same layout +/// nk_widget(...); +/// nk_widget(...); +/// nk_widget(...); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// 6. __nk_layout_space_xxx__

+/// Finally the most flexible API directly allows you to place widgets inside the +/// window. The space layout API is an immediate mode API which does not support +/// row auto repeat and directly sets position and size of a widget. Position +/// and size hereby can be either specified as ratio of allocated space or +/// allocated space local position and pixel size. Since this API is quite +/// powerful there are a number of utility functions to get the available space +/// and convert between local allocated space and screen space. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_begin_xxx(...) { +/// // static row with height: 500 (you can set column count to INT_MAX if you don't want to be bothered) +/// nk_layout_space_begin(ctx, NK_STATIC, 500, INT_MAX); +/// nk_layout_space_push(ctx, nk_rect(0,0,150,200)); +/// nk_widget(...); +/// nk_layout_space_push(ctx, nk_rect(200,200,100,200)); +/// nk_widget(...); +/// nk_layout_space_end(ctx); +/// // +/// // dynamic row with height: 500 (you can set column count to INT_MAX if you don't want to be bothered) +/// nk_layout_space_begin(ctx, NK_DYNAMIC, 500, INT_MAX); +/// nk_layout_space_push(ctx, nk_rect(0.5,0.5,0.1,0.1)); +/// nk_widget(...); +/// nk_layout_space_push(ctx, nk_rect(0.7,0.6,0.1,0.1)); +/// nk_widget(...); +/// } +/// nk_end(...); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// ----------------------------------------|------------------------------------ +/// nk_layout_set_min_row_height | Set the currently used minimum row height to a specified value +/// nk_layout_reset_min_row_height | Resets the currently used minimum row height to font height +/// nk_layout_widget_bounds | Calculates current width a static layout row can fit inside a window +/// nk_layout_ratio_from_pixel | Utility functions to calculate window ratio from pixel size +// +/// nk_layout_row_dynamic | Current layout is divided into n same sized growing columns +/// nk_layout_row_static | Current layout is divided into n same fixed sized columns +/// nk_layout_row_begin | Starts a new row with given height and number of columns +/// nk_layout_row_push | Pushes another column with given size or window ratio +/// nk_layout_row_end | Finished previously started row +/// nk_layout_row | Specifies row columns in array as either window ratio or size +// +/// nk_layout_row_template_begin | Begins the row template declaration +/// nk_layout_row_template_push_dynamic | Adds a dynamic column that dynamically grows and can go to zero if not enough space +/// nk_layout_row_template_push_variable | Adds a variable column that dynamically grows but does not shrink below specified pixel width +/// nk_layout_row_template_push_static | Adds a static column that does not grow and will always have the same size +/// nk_layout_row_template_end | Marks the end of the row template +// +/// nk_layout_space_begin | Begins a new layouting space that allows to specify each widgets position and size +/// nk_layout_space_push | Pushes position and size of the next widget in own coordinate space either as pixel or ratio +/// nk_layout_space_end | Marks the end of the layouting space +// +/// nk_layout_space_bounds | Callable after nk_layout_space_begin and returns total space allocated +/// nk_layout_space_to_screen | Converts vector from nk_layout_space coordinate space into screen space +/// nk_layout_space_to_local | Converts vector from screen space into nk_layout_space coordinates +/// nk_layout_space_rect_to_screen | Converts rectangle from nk_layout_space coordinate space into screen space +/// nk_layout_space_rect_to_local | Converts rectangle from screen space into nk_layout_space coordinates +*/ +/*/// #### nk_layout_set_min_row_height +/// Sets the currently used minimum row height. +/// !!! WARNING +/// The passed height needs to include both your preferred row height +/// as well as padding. No internal padding is added. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_set_min_row_height(struct nk_context*, int height); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __height__ | New minimum row height to be used for auto generating the row height +*/ +NK_API void nk_layout_set_min_row_height(struct nk_context*, int height); +/*/// #### nk_layout_reset_min_row_height +/// Reset the currently used minimum row height back to `font_height + text_padding + padding` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_reset_min_row_height(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +*/ +NK_API void nk_layout_reset_min_row_height(struct nk_context*); +/*/// #### nk_layout_widget_bounds +/// Returns the width of the next row allocate by one of the layouting functions +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_layout_widget_bounds(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// +/// Return `nk_rect` with both position and size of the next row +*/ +NK_API struct nk_rect nk_layout_widget_bounds(struct nk_context*); +/*/// #### nk_layout_ratio_from_pixel +/// Utility functions to calculate window ratio from pixel size +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_layout_ratio_from_pixel(struct nk_context*, int pixel_width); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __pixel__ | Pixel_width to convert to window ratio +/// +/// Returns `nk_rect` with both position and size of the next row +*/ +NK_API int nk_layout_ratio_from_pixel(struct nk_context*, int pixel_width); +/*/// #### nk_layout_row_dynamic +/// Sets current row layout to share horizontal space +/// between @cols number of widgets evenly. Once called all subsequent widget +/// calls greater than @cols will allocate a new row with same layout. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_dynamic(struct nk_context *ctx, int height, int cols); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __height__ | Holds height of each widget in row or zero for auto layouting +/// __columns__ | Number of widget inside row +*/ +NK_API void nk_layout_row_dynamic(struct nk_context *ctx, int height, int cols); +/*/// #### nk_layout_row_static +/// Sets current row layout to fill @cols number of widgets +/// in row with same @item_width horizontal size. Once called all subsequent widget +/// calls greater than @cols will allocate a new row with same layout. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_static(struct nk_context *ctx, int height, int item_width, int cols); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __height__ | Holds height of each widget in row or zero for auto layouting +/// __width__ | Holds pixel width of each widget in the row +/// __columns__ | Number of widget inside row +*/ +NK_API void nk_layout_row_static(struct nk_context *ctx, int height, int item_width, int cols); +/*/// #### nk_layout_row_begin +/// Starts a new dynamic or fixed row with given height and columns. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt, int row_height, int cols); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __fmt__ | either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns +/// __height__ | holds height of each widget in row or zero for auto layouting +/// __columns__ | Number of widget inside row +*/ +NK_API void nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt, int row_height, int cols); +/*/// #### nk_layout_row_push +/// Specifies either window ratio or width of a single column +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_push(struct nk_context*, int value); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __value__ | either a window ratio or fixed width depending on @fmt in previous `nk_layout_row_begin` call +*/ +NK_API void nk_layout_row_push(struct nk_context*, int value); +/*/// #### nk_layout_row_end +/// Finished previously started row +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_end(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +*/ +NK_API void nk_layout_row_end(struct nk_context*); +/*/// #### nk_layout_row +/// Specifies row columns in array as either window ratio or size +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row(struct nk_context*, enum nk_layout_format, int height, int cols, const int *ratio); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __fmt__ | Either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns +/// __height__ | Holds height of each widget in row or zero for auto layouting +/// __columns__ | Number of widget inside row +*/ +NK_API void nk_layout_row(struct nk_context*, enum nk_layout_format, int height, int cols, const int *ratio); +/*/// #### nk_layout_row_template_begin +/// Begins the row template declaration +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_begin(struct nk_context*, int row_height); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __height__ | Holds height of each widget in row or zero for auto layouting +*/ +NK_API void nk_layout_row_template_begin(struct nk_context*, int row_height); +/*/// #### nk_layout_row_template_push_dynamic +/// Adds a dynamic column that dynamically grows and can go to zero if not enough space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_push_dynamic(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __height__ | Holds height of each widget in row or zero for auto layouting +*/ +NK_API void nk_layout_row_template_push_dynamic(struct nk_context*); +/*/// #### nk_layout_row_template_push_variable +/// Adds a variable column that dynamically grows but does not shrink below specified pixel width +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_push_variable(struct nk_context*, int min_width); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __width__ | Holds the minimum pixel width the next column must always be +*/ +NK_API void nk_layout_row_template_push_variable(struct nk_context*, int min_width); +/*/// #### nk_layout_row_template_push_static +/// Adds a static column that does not grow and will always have the same size +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_push_static(struct nk_context*, int width); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __width__ | Holds the absolute pixel width value the next column must be +*/ +NK_API void nk_layout_row_template_push_static(struct nk_context*, int width); +/*/// #### nk_layout_row_template_end +/// Marks the end of the row template +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_end(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +*/ +NK_API void nk_layout_row_template_end(struct nk_context*); +/*/// #### nk_layout_space_begin +/// Begins a new layouting space that allows to specify each widgets position and size. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_space_begin(struct nk_context*, enum nk_layout_format, int height, int widget_count); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` +/// __fmt__ | Either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns +/// __height__ | Holds height of each widget in row or zero for auto layouting +/// __columns__ | Number of widgets inside row +*/ +NK_API void nk_layout_space_begin(struct nk_context*, enum nk_layout_format, int height, int widget_count); +/*/// #### nk_layout_space_push +/// Pushes position and size of the next widget in own coordinate space either as pixel or ratio +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_space_push(struct nk_context *ctx, struct nk_rect bounds); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// __bounds__ | Position and size in laoyut space local coordinates +*/ +NK_API void nk_layout_space_push(struct nk_context*, struct nk_rect bounds); +/*/// #### nk_layout_space_end +/// Marks the end of the layout space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_space_end(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +*/ +NK_API void nk_layout_space_end(struct nk_context*); +/*/// #### nk_layout_space_bounds +/// Utility function to calculate total space allocated for `nk_layout_space` +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_layout_space_bounds(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// +/// Returns `nk_rect` holding the total space allocated +*/ +NK_API struct nk_rect nk_layout_space_bounds(struct nk_context*); +/*/// #### nk_layout_space_to_screen +/// Converts vector from nk_layout_space coordinate space into screen space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_layout_space_to_screen(struct nk_context*, struct nk_vec2); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// __vec__ | Position to convert from layout space into screen coordinate space +/// +/// Returns transformed `nk_vec2` in screen space coordinates +*/ +NK_API struct nk_vec2 nk_layout_space_to_screen(struct nk_context*, struct nk_vec2); +/*/// #### nk_layout_space_to_local +/// Converts vector from layout space into screen space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_vec2 nk_layout_space_to_local(struct nk_context*, struct nk_vec2); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// __vec__ | Position to convert from screen space into layout coordinate space +/// +/// Returns transformed `nk_vec2` in layout space coordinates +*/ +NK_API struct nk_vec2 nk_layout_space_to_local(struct nk_context*, struct nk_vec2); +/*/// #### nk_layout_space_rect_to_screen +/// Converts rectangle from screen space into layout space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_layout_space_rect_to_screen(struct nk_context*, struct nk_rect); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// __bounds__ | Rectangle to convert from layout space into screen space +/// +/// Returns transformed `nk_rect` in screen space coordinates +*/ +NK_API struct nk_rect nk_layout_space_rect_to_screen(struct nk_context*, struct nk_rect); +/*/// #### nk_layout_space_rect_to_local +/// Converts rectangle from layout space into screen space +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_rect nk_layout_space_rect_to_local(struct nk_context*, struct nk_rect); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` +/// __bounds__ | Rectangle to convert from layout space into screen space +/// +/// Returns transformed `nk_rect` in layout space coordinates +*/ +NK_API struct nk_rect nk_layout_space_rect_to_local(struct nk_context*, struct nk_rect); +/* ============================================================================= + * + * GROUP + * + * ============================================================================= +/// ### Groups +/// Groups are basically windows inside windows. They allow to subdivide space +/// in a window to layout widgets as a group. Almost all more complex widget +/// layouting requirements can be solved using groups and basic layouting +/// fuctionality. Groups just like windows are identified by an unique name and +/// internally keep track of scrollbar offsets by default. However additional +/// versions are provided to directly manage the scrollbar. +/// +/// #### Usage +/// To create a group you have to call one of the three `nk_group_begin_xxx` +/// functions to start group declarations and `nk_group_end` at the end. Furthermore it +/// is required to check the return value of `nk_group_begin_xxx` and only process +/// widgets inside the window if the value is not 0. +/// Nesting groups is possible and even encouraged since many layouting schemes +/// can only be achieved by nesting. Groups, unlike windows, need `nk_group_end` +/// to be only called if the corosponding `nk_group_begin_xxx` call does not return 0: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_group_begin_xxx(ctx, ...) { +/// // [... widgets ...] +/// nk_group_end(ctx); +/// } +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// In the grand concept groups can be called after starting a window +/// with `nk_begin_xxx` and before calling `nk_end`: +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// // Input +/// Event evt; +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// nk_input_xxx(...); +/// } +/// } +/// nk_input_end(&ctx); +/// // +/// // Window +/// if (nk_begin_xxx(...) { +/// // [...widgets...] +/// nk_layout_row_dynamic(...); +/// if (nk_group_begin_xxx(ctx, ...) { +/// //[... widgets ...] +/// nk_group_end(ctx); +/// } +/// } +/// nk_end(ctx); +/// // +/// // Draw +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case ...: +/// // [...] +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// #### Reference +/// Function | Description +/// --------------------------------|------------------------------------------- +/// nk_group_begin | Start a new group with internal scrollbar handling +/// nk_group_begin_titled | Start a new group with separeted name and title and internal scrollbar handling +/// nk_group_end | Ends a group. Should only be called if nk_group_begin returned non-zero +/// nk_group_scrolled_offset_begin | Start a new group with manual separated handling of scrollbar x- and y-offset +/// nk_group_scrolled_begin | Start a new group with manual scrollbar handling +/// nk_group_scrolled_end | Ends a group with manual scrollbar handling. Should only be called if nk_group_begin returned non-zero +/// nk_group_get_scroll | Gets the scroll offset for the given group +/// nk_group_set_scroll | Sets the scroll offset for the given group +*/ +/*/// #### nk_group_begin +/// Starts a new widget group. Requires a previous layouting function to specify a pos/size. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_group_begin(struct nk_context*, const char *title, nk_flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __title__ | Must be an unique identifier for this group that is also used for the group header +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different group behaviors +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_group_begin(struct nk_context*, const char *title, nk_flags); +/*/// #### nk_group_begin_titled +/// Starts a new widget group. Requires a previous layouting function to specify a pos/size. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_group_begin_titled(struct nk_context*, const char *name, const char *title, nk_flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __id__ | Must be an unique identifier for this group +/// __title__ | Group header title +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different group behaviors +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_group_begin_titled(struct nk_context*, const char *name, const char *title, nk_flags); +/*/// #### nk_group_end +/// Ends a widget group +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_group_end(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +*/ +NK_API void nk_group_end(struct nk_context*); +/*/// #### nk_group_scrolled_offset_begin +/// starts a new widget group. requires a previous layouting function to specify +/// a size. Does not keep track of scrollbar. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_group_scrolled_offset_begin(struct nk_context*, nk_uint *x_offset, nk_uint *y_offset, const char *title, nk_flags flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __x_offset__| Scrollbar x-offset to offset all widgets inside the group horizontally. +/// __y_offset__| Scrollbar y-offset to offset all widgets inside the group vertically +/// __title__ | Window unique group title used to both identify and display in the group header +/// __flags__ | Window flags from the nk_panel_flags section +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_group_scrolled_offset_begin(struct nk_context*, nk_uint *x_offset, nk_uint *y_offset, const char *title, nk_flags flags); +/*/// #### nk_group_scrolled_begin +/// Starts a new widget group. requires a previous +/// layouting function to specify a size. Does not keep track of scrollbar. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_group_scrolled_begin(struct nk_context*, struct nk_scroll *off, const char *title, nk_flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __off__ | Both x- and y- scroll offset. Allows for manual scrollbar control +/// __title__ | Window unique group title used to both identify and display in the group header +/// __flags__ | Window flags from nk_panel_flags section +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_group_scrolled_begin(struct nk_context*, struct nk_scroll *off, const char *title, nk_flags); +/*/// #### nk_group_scrolled_end +/// Ends a widget group after calling nk_group_scrolled_offset_begin or nk_group_scrolled_begin. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_group_scrolled_end(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +*/ +NK_API void nk_group_scrolled_end(struct nk_context*); +/*/// #### nk_group_get_scroll +/// Gets the scroll position of the given group. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_group_get_scroll(struct nk_context*, const char *id, nk_uint *x_offset, nk_uint *y_offset); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// -------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __id__ | The id of the group to get the scroll position of +/// __x_offset__ | A pointer to the x offset output (or NULL to ignore) +/// __y_offset__ | A pointer to the y offset output (or NULL to ignore) +*/ +NK_API void nk_group_get_scroll(struct nk_context*, const char *id, nk_uint *x_offset, nk_uint *y_offset); +/*/// #### nk_group_set_scroll +/// Sets the scroll position of the given group. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_group_set_scroll(struct nk_context*, const char *id, nk_uint x_offset, nk_uint y_offset); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// -------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __id__ | The id of the group to scroll +/// __x_offset__ | The x offset to scroll to +/// __y_offset__ | The y offset to scroll to +*/ +NK_API void nk_group_set_scroll(struct nk_context*, const char *id, nk_uint x_offset, nk_uint y_offset); +/* ============================================================================= + * + * TREE + * + * ============================================================================= +/// ### Tree +/// Trees represent two different concept. First the concept of a collapsable +/// UI section that can be either in a hidden or visibile state. They allow the UI +/// user to selectively minimize the current set of visible UI to comprehend. +/// The second concept are tree widgets for visual UI representation of trees.

+/// +/// Trees thereby can be nested for tree representations and multiple nested +/// collapsable UI sections. All trees are started by calling of the +/// `nk_tree_xxx_push_tree` functions and ended by calling one of the +/// `nk_tree_xxx_pop_xxx()` functions. Each starting functions takes a title label +/// and optionally an image to be displayed and the initial collapse state from +/// the nk_collapse_states section.

+/// +/// The runtime state of the tree is either stored outside the library by the caller +/// or inside which requires a unique ID. The unique ID can either be generated +/// automatically from `__FILE__` and `__LINE__` with function `nk_tree_push`, +/// by `__FILE__` and a user provided ID generated for example by loop index with +/// function `nk_tree_push_id` or completely provided from outside by user with +/// function `nk_tree_push_hashed`. +/// +/// #### Usage +/// To create a tree you have to call one of the seven `nk_tree_xxx_push_xxx` +/// functions to start a collapsable UI section and `nk_tree_xxx_pop` to mark the +/// end. +/// Each starting function will either return `false(0)` if the tree is collapsed +/// or hidden and therefore does not need to be filled with content or `true(1)` +/// if visible and required to be filled. +/// +/// !!! Note +/// The tree header does not require and layouting function and instead +/// calculates a auto height based on the currently used font size +/// +/// The tree ending functions only need to be called if the tree content is +/// actually visible. So make sure the tree push function is guarded by `if` +/// and the pop call is only taken if the tree is visible. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// if (nk_tree_push(ctx, NK_TREE_TAB, "Tree", NK_MINIMIZED)) { +/// nk_layout_row_dynamic(...); +/// nk_widget(...); +/// nk_tree_pop(ctx); +/// } +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// ----------------------------|------------------------------------------- +/// nk_tree_push | Start a collapsable UI section with internal state management +/// nk_tree_push_id | Start a collapsable UI section with internal state management callable in a look +/// nk_tree_push_hashed | Start a collapsable UI section with internal state management with full control over internal unique ID use to store state +/// nk_tree_image_push | Start a collapsable UI section with image and label header +/// nk_tree_image_push_id | Start a collapsable UI section with image and label header and internal state management callable in a look +/// nk_tree_image_push_hashed | Start a collapsable UI section with image and label header and internal state management with full control over internal unique ID use to store state +/// nk_tree_pop | Ends a collapsable UI section +// +/// nk_tree_state_push | Start a collapsable UI section with external state management +/// nk_tree_state_image_push | Start a collapsable UI section with image and label header and external state management +/// nk_tree_state_pop | Ends a collapsabale UI section +/// +/// #### nk_tree_type +/// Flag | Description +/// ----------------|---------------------------------------- +/// NK_TREE_NODE | Highlighted tree header to mark a collapsable UI section +/// NK_TREE_TAB | Non-highighted tree header closer to tree representations +*/ +/*/// #### nk_tree_push +/// Starts a collapsable UI section with internal state management +/// !!! WARNING +/// To keep track of the runtime tree collapsable state this function uses +/// defines `__FILE__` and `__LINE__` to generate a unique ID. If you want +/// to call this function in a loop please use `nk_tree_push_id` or +/// `nk_tree_push_hashed` instead. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_tree_push(ctx, type, title, state) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +#define nk_tree_push(ctx, type, title, state) nk_tree_push_hashed(ctx, type, title, state, NK_FILE_LINE,strlen(NK_FILE_LINE),__LINE__) +/*/// #### nk_tree_push_id +/// Starts a collapsable UI section with internal state management callable in a look +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_tree_push_id(ctx, type, title, state, id) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// __id__ | Loop counter index if this function is called in a loop +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +#define nk_tree_push_id(ctx, type, title, state, id) nk_tree_push_hashed(ctx, type, title, state, NK_FILE_LINE,strlen(NK_FILE_LINE),id) +/*/// #### nk_tree_push_hashed +/// Start a collapsable UI section with internal state management with full +/// control over internal unique ID used to store state +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_tree_push_hashed(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// __hash__ | Memory block or string to generate the ID from +/// __len__ | Size of passed memory block or string in __hash__ +/// __seed__ | Seeding value if this function is called in a loop or default to `0` +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_tree_push_hashed(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed); +/*/// #### nk_tree_image_push +/// Start a collapsable UI section with image and label header +/// !!! WARNING +/// To keep track of the runtime tree collapsable state this function uses +/// defines `__FILE__` and `__LINE__` to generate a unique ID. If you want +/// to call this function in a loop please use `nk_tree_image_push_id` or +/// `nk_tree_image_push_hashed` instead. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_tree_image_push(ctx, type, img, title, state) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __img__ | Image to display inside the header on the left of the label +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +#define nk_tree_image_push(ctx, type, img, title, state) nk_tree_image_push_hashed(ctx, type, img, title, state, NK_FILE_LINE,strlen(NK_FILE_LINE),__LINE__) +/*/// #### nk_tree_image_push_id +/// Start a collapsable UI section with image and label header and internal state +/// management callable in a look +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// #define nk_tree_image_push_id(ctx, type, img, title, state, id) +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __img__ | Image to display inside the header on the left of the label +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// __id__ | Loop counter index if this function is called in a loop +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +#define nk_tree_image_push_id(ctx, type, img, title, state, id) nk_tree_image_push_hashed(ctx, type, img, title, state, NK_FILE_LINE,strlen(NK_FILE_LINE),id) +/*/// #### nk_tree_image_push_hashed +/// Start a collapsable UI section with internal state management with full +/// control over internal unique ID used to store state +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_tree_image_push_hashed(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __img__ | Image to display inside the header on the left of the label +/// __title__ | Label printed in the tree header +/// __state__ | Initial tree state value out of nk_collapse_states +/// __hash__ | Memory block or string to generate the ID from +/// __len__ | Size of passed memory block or string in __hash__ +/// __seed__ | Seeding value if this function is called in a loop or default to `0` +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_tree_image_push_hashed(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed); +/*/// #### nk_tree_pop +/// Ends a collapsabale UI section +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_tree_pop(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling `nk_tree_xxx_push_xxx` +*/ +NK_API void nk_tree_pop(struct nk_context*); +/*/// #### nk_tree_state_push +/// Start a collapsable UI section with external state management +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_tree_state_push(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states *state); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling `nk_tree_xxx_push_xxx` +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __title__ | Label printed in the tree header +/// __state__ | Persistent state to update +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_tree_state_push(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states *state); +/*/// #### nk_tree_state_image_push +/// Start a collapsable UI section with image and label header and external state management +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// nk_bool nk_tree_state_image_push(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states *state); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling `nk_tree_xxx_push_xxx` +/// __img__ | Image to display inside the header on the left of the label +/// __type__ | Value from the nk_tree_type section to visually mark a tree node header as either a collapseable UI section or tree node +/// __title__ | Label printed in the tree header +/// __state__ | Persistent state to update +/// +/// Returns `true(1)` if visible and fillable with widgets or `false(0)` otherwise +*/ +NK_API nk_bool nk_tree_state_image_push(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states *state); +/*/// #### nk_tree_state_pop +/// Ends a collapsabale UI section +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_tree_state_pop(struct nk_context*); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling `nk_tree_xxx_push_xxx` +*/ +NK_API void nk_tree_state_pop(struct nk_context*); + +#define nk_tree_element_push(ctx, type, title, state, sel) nk_tree_element_push_hashed(ctx, type, title, state, sel, NK_FILE_LINE,strlen(NK_FILE_LINE),__LINE__) +#define nk_tree_element_push_id(ctx, type, title, state, sel, id) nk_tree_element_push_hashed(ctx, type, title, state, sel, NK_FILE_LINE,strlen(NK_FILE_LINE),id) +NK_API nk_bool nk_tree_element_push_hashed(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states initial_state, nk_bool *selected, const char *hash, int len, int seed); +NK_API nk_bool nk_tree_element_image_push_hashed(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states initial_state, nk_bool *selected, const char *hash, int len,int seed); +NK_API void nk_tree_element_pop(struct nk_context*); + +/* ============================================================================= + * + * LIST VIEW + * + * ============================================================================= */ +struct nk_list_view { +/* public: */ + int begin, end, count; +/* private: */ + int total_height; + struct nk_context *ctx; + nk_uint *scroll_pointer; + nk_uint scroll_value; +}; +NK_API nk_bool nk_list_view_begin(struct nk_context*, struct nk_list_view *out, const char *id, nk_flags, int row_height, int row_count); +NK_API void nk_list_view_end(struct nk_list_view*); +/* ============================================================================= + * + * WIDGET + * + * ============================================================================= */ +enum nk_widget_layout_states { + NK_WIDGET_INVALID, /* The widget cannot be seen and is completely out of view */ + NK_WIDGET_VALID, /* The widget is completely inside the window and can be updated and drawn */ + NK_WIDGET_ROM /* The widget is partially visible and cannot be updated */ +}; +enum nk_widget_states { + NK_WIDGET_STATE_MODIFIED = NK_FLAG(1), + NK_WIDGET_STATE_INACTIVE = NK_FLAG(2), /* widget is neither active nor hovered */ + NK_WIDGET_STATE_ENTERED = NK_FLAG(3), /* widget has been hovered on the current frame */ + NK_WIDGET_STATE_HOVER = NK_FLAG(4), /* widget is being hovered */ + NK_WIDGET_STATE_ACTIVED = NK_FLAG(5),/* widget is currently activated */ + NK_WIDGET_STATE_LEFT = NK_FLAG(6), /* widget is from this frame on not hovered anymore */ + NK_WIDGET_STATE_HOVERED = NK_WIDGET_STATE_HOVER|NK_WIDGET_STATE_MODIFIED, /* widget is being hovered */ + NK_WIDGET_STATE_ACTIVE = NK_WIDGET_STATE_ACTIVED|NK_WIDGET_STATE_MODIFIED /* widget is currently activated */ +}; +NK_API enum nk_widget_layout_states nk_widget(struct nk_rect*, const struct nk_context*); +NK_API enum nk_widget_layout_states nk_widget_fitting(struct nk_rect*, struct nk_context*, struct nk_vec2); +NK_API struct nk_rect nk_widget_bounds(struct nk_context*); +NK_API struct nk_vec2 nk_widget_position(struct nk_context*); +NK_API struct nk_vec2 nk_widget_size(struct nk_context*); +NK_API int nk_widget_width(struct nk_context*); +NK_API int nk_widget_height(struct nk_context*); +NK_API nk_bool nk_widget_is_hovered(struct nk_context*); +NK_API nk_bool nk_widget_is_mouse_clicked(struct nk_context*, enum nk_buttons); +NK_API nk_bool nk_widget_has_mouse_click_down(struct nk_context*, enum nk_buttons, nk_bool down); +NK_API void nk_spacing(struct nk_context*, int cols); +/* ============================================================================= + * + * TEXT + * + * ============================================================================= */ +enum nk_text_align { + NK_TEXT_ALIGN_LEFT = 0x01, + NK_TEXT_ALIGN_CENTERED = 0x02, + NK_TEXT_ALIGN_RIGHT = 0x04, + NK_TEXT_ALIGN_TOP = 0x08, + NK_TEXT_ALIGN_MIDDLE = 0x10, + NK_TEXT_ALIGN_BOTTOM = 0x20 +}; +enum nk_text_alignment { + NK_TEXT_LEFT = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_LEFT, + NK_TEXT_CENTERED = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_CENTERED, + NK_TEXT_RIGHT = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_RIGHT +}; +NK_API void nk_text(struct nk_context*, const char*, int, nk_flags); +NK_API void nk_text_colored(struct nk_context*, const char*, int, nk_flags, struct nk_color); +NK_API void nk_text_wrap(struct nk_context*, const char*, int); +NK_API void nk_text_wrap_colored(struct nk_context*, const char*, int, struct nk_color); +NK_API void nk_label(struct nk_context*, const char*, nk_flags align); +NK_API void nk_label_colored(struct nk_context*, const char*, nk_flags align, struct nk_color); +NK_API void nk_label_wrap(struct nk_context*, const char*); +NK_API void nk_label_colored_wrap(struct nk_context*, const char*, struct nk_color); +NK_API void nk_image(struct nk_context*, struct nk_image); +NK_API void nk_image_color(struct nk_context*, struct nk_image, struct nk_color); +#ifdef NK_INCLUDE_STANDARD_VARARGS +NK_API void nk_labelf(struct nk_context*, nk_flags, NK_PRINTF_FORMAT_STRING const char*, ...) NK_PRINTF_VARARG_FUNC(3); +NK_API void nk_labelf_colored(struct nk_context*, nk_flags, struct nk_color, NK_PRINTF_FORMAT_STRING const char*,...) NK_PRINTF_VARARG_FUNC(4); +NK_API void nk_labelf_wrap(struct nk_context*, NK_PRINTF_FORMAT_STRING const char*,...) NK_PRINTF_VARARG_FUNC(2); +NK_API void nk_labelf_colored_wrap(struct nk_context*, struct nk_color, NK_PRINTF_FORMAT_STRING const char*,...) NK_PRINTF_VARARG_FUNC(3); +NK_API void nk_labelfv(struct nk_context*, nk_flags, NK_PRINTF_FORMAT_STRING const char*, va_list) NK_PRINTF_VALIST_FUNC(3); +NK_API void nk_labelfv_colored(struct nk_context*, nk_flags, struct nk_color, NK_PRINTF_FORMAT_STRING const char*, va_list) NK_PRINTF_VALIST_FUNC(4); +NK_API void nk_labelfv_wrap(struct nk_context*, NK_PRINTF_FORMAT_STRING const char*, va_list) NK_PRINTF_VALIST_FUNC(2); +NK_API void nk_labelfv_colored_wrap(struct nk_context*, struct nk_color, NK_PRINTF_FORMAT_STRING const char*, va_list) NK_PRINTF_VALIST_FUNC(3); +NK_API void nk_value_bool(struct nk_context*, const char *prefix, int); +NK_API void nk_value_int(struct nk_context*, const char *prefix, int); +NK_API void nk_value_uint(struct nk_context*, const char *prefix, unsigned int); +// NK_API void nk_value_int(struct nk_context*, const char *prefix, int); +NK_API void nk_value_color_byte(struct nk_context*, const char *prefix, struct nk_color); +NK_API void nk_value_color_int(struct nk_context*, const char *prefix, struct nk_color); +NK_API void nk_value_color_hex(struct nk_context*, const char *prefix, struct nk_color); +#endif +/* ============================================================================= + * + * BUTTON + * + * ============================================================================= */ +NK_API nk_bool nk_button_text(struct nk_context*, const char *title, int len); +NK_API nk_bool nk_button_label(struct nk_context*, const char *title); +NK_API nk_bool nk_button_color(struct nk_context*, struct nk_color); +NK_API nk_bool nk_button_symbol(struct nk_context*, enum nk_symbol_type); +NK_API nk_bool nk_button_image(struct nk_context*, struct nk_image img); +NK_API nk_bool nk_button_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags text_alignment); +NK_API nk_bool nk_button_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment); +NK_API nk_bool nk_button_image_label(struct nk_context*, struct nk_image img, const char*, nk_flags text_alignment); +NK_API nk_bool nk_button_image_text(struct nk_context*, struct nk_image img, const char*, int, nk_flags alignment); +NK_API nk_bool nk_button_text_styled(struct nk_context*, const struct nk_style_button*, const char *title, int len); +NK_API nk_bool nk_button_label_styled(struct nk_context*, const struct nk_style_button*, const char *title); +NK_API nk_bool nk_button_symbol_styled(struct nk_context*, const struct nk_style_button*, enum nk_symbol_type); +NK_API nk_bool nk_button_image_styled(struct nk_context*, const struct nk_style_button*, struct nk_image img); +NK_API nk_bool nk_button_symbol_text_styled(struct nk_context*,const struct nk_style_button*, enum nk_symbol_type, const char*, int, nk_flags alignment); +NK_API nk_bool nk_button_symbol_label_styled(struct nk_context *ctx, const struct nk_style_button *style, enum nk_symbol_type symbol, const char *title, nk_flags align); +NK_API nk_bool nk_button_image_label_styled(struct nk_context*,const struct nk_style_button*, struct nk_image img, const char*, nk_flags text_alignment); +NK_API nk_bool nk_button_image_text_styled(struct nk_context*,const struct nk_style_button*, struct nk_image img, const char*, int, nk_flags alignment); +NK_API void nk_button_set_behavior(struct nk_context*, enum nk_button_behavior); +NK_API nk_bool nk_button_push_behavior(struct nk_context*, enum nk_button_behavior); +NK_API nk_bool nk_button_pop_behavior(struct nk_context*); +/* ============================================================================= + * + * CHECKBOX + * + * ============================================================================= */ +NK_API nk_bool nk_check_label(struct nk_context*, const char*, nk_bool active); +NK_API nk_bool nk_check_text(struct nk_context*, const char*, int, nk_bool active); +NK_API unsigned nk_check_flags_label(struct nk_context*, const char*, unsigned int flags, unsigned int value); +NK_API unsigned nk_check_flags_text(struct nk_context*, const char*, int, unsigned int flags, unsigned int value); +NK_API nk_bool nk_checkbox_label(struct nk_context*, const char*, nk_bool *active); +NK_API nk_bool nk_checkbox_text(struct nk_context*, const char*, int, nk_bool *active); +NK_API nk_bool nk_checkbox_flags_label(struct nk_context*, const char*, unsigned int *flags, unsigned int value); +NK_API nk_bool nk_checkbox_flags_text(struct nk_context*, const char*, int, unsigned int *flags, unsigned int value); +/* ============================================================================= + * + * RADIO BUTTON + * + * ============================================================================= */ +NK_API nk_bool nk_radio_label(struct nk_context*, const char*, nk_bool *active); +NK_API nk_bool nk_radio_text(struct nk_context*, const char*, int, nk_bool *active); +NK_API nk_bool nk_option_label(struct nk_context*, const char*, nk_bool active); +NK_API nk_bool nk_option_text(struct nk_context*, const char*, int, nk_bool active); +/* ============================================================================= + * + * SELECTABLE + * + * ============================================================================= */ +NK_API nk_bool nk_selectable_label(struct nk_context*, const char*, nk_flags align, nk_bool *value); +NK_API nk_bool nk_selectable_text(struct nk_context*, const char*, int, nk_flags align, nk_bool *value); +NK_API nk_bool nk_selectable_image_label(struct nk_context*,struct nk_image, const char*, nk_flags align, nk_bool *value); +NK_API nk_bool nk_selectable_image_text(struct nk_context*,struct nk_image, const char*, int, nk_flags align, nk_bool *value); +NK_API nk_bool nk_selectable_symbol_label(struct nk_context*,enum nk_symbol_type, const char*, nk_flags align, nk_bool *value); +NK_API nk_bool nk_selectable_symbol_text(struct nk_context*,enum nk_symbol_type, const char*, int, nk_flags align, nk_bool *value); + +NK_API nk_bool nk_select_label(struct nk_context*, const char*, nk_flags align, nk_bool value); +NK_API nk_bool nk_select_text(struct nk_context*, const char*, int, nk_flags align, nk_bool value); +NK_API nk_bool nk_select_image_label(struct nk_context*, struct nk_image,const char*, nk_flags align, nk_bool value); +NK_API nk_bool nk_select_image_text(struct nk_context*, struct nk_image,const char*, int, nk_flags align, nk_bool value); +NK_API nk_bool nk_select_symbol_label(struct nk_context*,enum nk_symbol_type, const char*, nk_flags align, nk_bool value); +NK_API nk_bool nk_select_symbol_text(struct nk_context*,enum nk_symbol_type, const char*, int, nk_flags align, nk_bool value); + +/* ============================================================================= + * + * SLIDER + * + * ============================================================================= */ +NK_API int nk_slide_int(struct nk_context*, int min, int val, int max, int step); +// NK_API int nk_slide_int(struct nk_context*, int min, int val, int max, int step); +NK_API nk_bool nk_slider_int(struct nk_context*, int min, int *val, int max, int step); +// NK_API nk_bool nk_slider_int(struct nk_context*, int min, int *val, int max, int step); +/* ============================================================================= + * + * PROGRESSBAR + * + * ============================================================================= */ +NK_API nk_bool nk_progress(struct nk_context*, nk_size *cur, nk_size max, nk_bool modifyable); +NK_API nk_size nk_prog(struct nk_context*, nk_size cur, nk_size max, nk_bool modifyable); + +/* ============================================================================= + * + * COLOR PICKER + * + * ============================================================================= */ +NK_API struct nk_colorf nk_color_picker(struct nk_context*, struct nk_colorf, enum nk_color_format); +NK_API nk_bool nk_color_pick(struct nk_context*, struct nk_colorf*, enum nk_color_format); +/* ============================================================================= + * + * PROPERTIES + * + * ============================================================================= +/// ### Properties +/// Properties are the main value modification widgets in Nuklear. Changing a value +/// can be achieved by dragging, adding/removing incremental steps on button click +/// or by directly typing a number. +/// +/// #### Usage +/// Each property requires a unique name for identifaction that is also used for +/// displaying a label. If you want to use the same name multiple times make sure +/// add a '#' before your name. The '#' will not be shown but will generate a +/// unique ID. Each propery also takes in a minimum and maximum value. If you want +/// to make use of the complete number range of a type just use the provided +/// type limits from `limits.h`. For example `INT_MIN` and `INT_MAX` for +/// `nk_property_int` and `nk_propertyi`. In additional each property takes in +/// a increment value that will be added or subtracted if either the increment +/// decrement button is clicked. Finally there is a value for increment per pixel +/// dragged that is added or subtracted from the value. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int value = 0; +/// struct nk_context ctx; +/// nk_init_xxx(&ctx, ...); +/// while (1) { +/// // Input +/// Event evt; +/// nk_input_begin(&ctx); +/// while (GetEvent(&evt)) { +/// if (evt.type == MOUSE_MOVE) +/// nk_input_motion(&ctx, evt.motion.x, evt.motion.y); +/// else if (evt.type == [...]) { +/// nk_input_xxx(...); +/// } +/// } +/// nk_input_end(&ctx); +/// // +/// // Window +/// if (nk_begin_xxx(...) { +/// // Property +/// nk_layout_row_dynamic(...); +/// nk_property_int(ctx, "ID", INT_MIN, &value, INT_MAX, 1, 1); +/// } +/// nk_end(ctx); +/// // +/// // Draw +/// const struct nk_command *cmd = 0; +/// nk_foreach(cmd, &ctx) { +/// switch (cmd->type) { +/// case NK_COMMAND_LINE: +/// your_draw_line_function(...) +/// break; +/// case NK_COMMAND_RECT +/// your_draw_rect_function(...) +/// break; +/// case ...: +/// // [...] +/// } +/// nk_clear(&ctx); +/// } +/// nk_free(&ctx); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// #### Reference +/// Function | Description +/// --------------------|------------------------------------------- +/// nk_property_int | Integer property directly modifing a passed in value +/// nk_property_int | int property directly modifing a passed in value +/// nk_property_double | Double property directly modifing a passed in value +/// nk_propertyi | Integer property returning the modified int value +/// nk_propertyf | int property returning the modified int value +/// nk_propertyd | Double property returning the modified double value +/// +*/ +/*/// #### nk_property_int +/// Integer property directly modifing a passed in value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_property_int(struct nk_context *ctx, const char *name, int min, int *val, int max, int step, int inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | Integer pointer to be modified +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +*/ +NK_API void nk_property_int(struct nk_context*, const char *name, int min, int *val, int max, int step, int inc_per_pixel); +/*/// #### nk_property_int +/// int property directly modifing a passed in value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_property_int(struct nk_context *ctx, const char *name, int min, int *val, int max, int step, int inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | int pointer to be modified +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +*/ +NK_API void nk_property_int(struct nk_context*, const char *name, int min, int *val, int max, int step, int inc_per_pixel); +/*/// #### nk_property_double +/// Double property directly modifing a passed in value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_property_double(struct nk_context *ctx, const char *name, double min, double *val, double max, double step, double inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | Double pointer to be modified +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +*/ +NK_API void nk_property_double(struct nk_context*, const char *name, double min, double *val, double max, double step, int inc_per_pixel); +/*/// #### nk_propertyi +/// Integer property modifing a passed in value and returning the new value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_propertyi(struct nk_context *ctx, const char *name, int min, int val, int max, int step, int inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | Current integer value to be modified and returned +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +/// +/// Returns the new modified integer value +*/ +NK_API int nk_propertyi(struct nk_context*, const char *name, int min, int val, int max, int step, int inc_per_pixel); +/*/// #### nk_propertyf +/// int property modifing a passed in value and returning the new value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_propertyf(struct nk_context *ctx, const char *name, int min, int val, int max, int step, int inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | Current int value to be modified and returned +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +/// +/// Returns the new modified int value +*/ +NK_API int nk_propertyf(struct nk_context*, const char *name, int min, int val, int max, int step, int inc_per_pixel); +/*/// #### nk_propertyd +/// int property modifing a passed in value and returning the new value +/// !!! WARNING +/// To generate a unique property ID using the same label make sure to insert +/// a `#` at the beginning. It will not be shown but guarantees correct behavior. +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_propertyd(struct nk_context *ctx, const char *name, double min, double val, double max, double step, double inc_per_pixel); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// --------------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct after calling a layouting function +/// __name__ | String used both as a label as well as a unique identifier +/// __min__ | Minimum value not allowed to be underflown +/// __val__ | Current double value to be modified and returned +/// __max__ | Maximum value not allowed to be overflown +/// __step__ | Increment added and subtracted on increment and decrement button +/// __inc_per_pixel__ | Value per pixel added or subtracted on dragging +/// +/// Returns the new modified double value +*/ +NK_API double nk_propertyd(struct nk_context*, const char *name, double min, double val, double max, double step, int inc_per_pixel); +/* ============================================================================= + * + * TEXT EDIT + * + * ============================================================================= */ +enum nk_edit_flags { + NK_EDIT_DEFAULT = 0, + NK_EDIT_READ_ONLY = NK_FLAG(0), + NK_EDIT_AUTO_SELECT = NK_FLAG(1), + NK_EDIT_SIG_ENTER = NK_FLAG(2), + NK_EDIT_ALLOW_TAB = NK_FLAG(3), + NK_EDIT_NO_CURSOR = NK_FLAG(4), + NK_EDIT_SELECTABLE = NK_FLAG(5), + NK_EDIT_CLIPBOARD = NK_FLAG(6), + NK_EDIT_CTRL_ENTER_NEWLINE = NK_FLAG(7), + NK_EDIT_NO_HORIZONTAL_SCROLL = NK_FLAG(8), + NK_EDIT_ALWAYS_INSERT_MODE = NK_FLAG(9), + NK_EDIT_MULTILINE = NK_FLAG(10), + NK_EDIT_GOTO_END_ON_ACTIVATE = NK_FLAG(11) +}; +enum nk_edit_types { + NK_EDIT_SIMPLE = NK_EDIT_ALWAYS_INSERT_MODE, + NK_EDIT_FIELD = NK_EDIT_SIMPLE|NK_EDIT_SELECTABLE|NK_EDIT_CLIPBOARD, + NK_EDIT_BOX = NK_EDIT_ALWAYS_INSERT_MODE| NK_EDIT_SELECTABLE| NK_EDIT_MULTILINE|NK_EDIT_ALLOW_TAB|NK_EDIT_CLIPBOARD, + NK_EDIT_EDITOR = NK_EDIT_SELECTABLE|NK_EDIT_MULTILINE|NK_EDIT_ALLOW_TAB| NK_EDIT_CLIPBOARD +}; +enum nk_edit_events { + NK_EDIT_ACTIVE = NK_FLAG(0), /* edit widget is currently being modified */ + NK_EDIT_INACTIVE = NK_FLAG(1), /* edit widget is not active and is not being modified */ + NK_EDIT_ACTIVATED = NK_FLAG(2), /* edit widget went from state inactive to state active */ + NK_EDIT_DEACTIVATED = NK_FLAG(3), /* edit widget went from state active to state inactive */ + NK_EDIT_COMMITED = NK_FLAG(4) /* edit widget has received an enter and lost focus */ +}; +NK_API nk_flags nk_edit_string(struct nk_context*, nk_flags, char *buffer, int *len, int max, nk_plugin_filter); +NK_API nk_flags nk_edit_string_zero_terminated(struct nk_context*, nk_flags, char *buffer, int max, nk_plugin_filter); +NK_API nk_flags nk_edit_buffer(struct nk_context*, nk_flags, struct nk_text_edit*, nk_plugin_filter); +NK_API void nk_edit_focus(struct nk_context*, nk_flags flags); +NK_API void nk_edit_unfocus(struct nk_context*); +/* ============================================================================= + * + * CHART + * + * ============================================================================= */ +NK_API nk_bool nk_chart_begin(struct nk_context*, enum nk_chart_type, int num, int min, int max); +NK_API nk_bool nk_chart_begin_colored(struct nk_context*, enum nk_chart_type, struct nk_color, struct nk_color active, int num, int min, int max); +NK_API void nk_chart_add_slot(struct nk_context *ctx, const enum nk_chart_type, int count, int min_value, int max_value); +NK_API void nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type, struct nk_color, struct nk_color active, int count, int min_value, int max_value); +NK_API nk_flags nk_chart_push(struct nk_context*, int); +NK_API nk_flags nk_chart_push_slot(struct nk_context*, int, int); +NK_API void nk_chart_end(struct nk_context*); +NK_API void nk_plot(struct nk_context*, enum nk_chart_type, const int *values, int count, int offset); +NK_API void nk_plot_function(struct nk_context*, enum nk_chart_type, void *userdata, int(*value_getter)(void* user, int index), int count, int offset); +/* ============================================================================= + * + * POPUP + * + * ============================================================================= */ +NK_API nk_bool nk_popup_begin(struct nk_context*, enum nk_popup_type, const char*, nk_flags, struct nk_rect bounds); +NK_API void nk_popup_close(struct nk_context*); +NK_API void nk_popup_end(struct nk_context*); +NK_API void nk_popup_get_scroll(struct nk_context*, nk_uint *offset_x, nk_uint *offset_y); +NK_API void nk_popup_set_scroll(struct nk_context*, nk_uint offset_x, nk_uint offset_y); +/* ============================================================================= + * + * COMBOBOX + * + * ============================================================================= */ +NK_API int nk_combo(struct nk_context*, const char **items, int count, int selected, int item_height, struct nk_vec2 size); +NK_API int nk_combo_separator(struct nk_context*, const char *items_separated_by_separator, int separator, int selected, int count, int item_height, struct nk_vec2 size); +NK_API int nk_combo_string(struct nk_context*, const char *items_separated_by_zeros, int selected, int count, int item_height, struct nk_vec2 size); +NK_API int nk_combo_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void *userdata, int selected, int count, int item_height, struct nk_vec2 size); +NK_API void nk_combobox(struct nk_context*, const char **items, int count, int *selected, int item_height, struct nk_vec2 size); +NK_API void nk_combobox_string(struct nk_context*, const char *items_separated_by_zeros, int *selected, int count, int item_height, struct nk_vec2 size); +NK_API void nk_combobox_separator(struct nk_context*, const char *items_separated_by_separator, int separator, int *selected, int count, int item_height, struct nk_vec2 size); +NK_API void nk_combobox_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void*, int *selected, int count, int item_height, struct nk_vec2 size); +/* ============================================================================= + * + * ABSTRACT COMBOBOX + * + * ============================================================================= */ +NK_API nk_bool nk_combo_begin_text(struct nk_context*, const char *selected, int, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_label(struct nk_context*, const char *selected, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_color(struct nk_context*, struct nk_color color, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_symbol(struct nk_context*, enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_symbol_label(struct nk_context*, const char *selected, enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_symbol_text(struct nk_context*, const char *selected, int, enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_image(struct nk_context*, struct nk_image img, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_image_label(struct nk_context*, const char *selected, struct nk_image, struct nk_vec2 size); +NK_API nk_bool nk_combo_begin_image_text(struct nk_context*, const char *selected, int, struct nk_image, struct nk_vec2 size); +NK_API nk_bool nk_combo_item_label(struct nk_context*, const char*, nk_flags alignment); +NK_API nk_bool nk_combo_item_text(struct nk_context*, const char*,int, nk_flags alignment); +NK_API nk_bool nk_combo_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment); +NK_API nk_bool nk_combo_item_image_text(struct nk_context*, struct nk_image, const char*, int,nk_flags alignment); +NK_API nk_bool nk_combo_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment); +NK_API nk_bool nk_combo_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment); +NK_API void nk_combo_close(struct nk_context*); +NK_API void nk_combo_end(struct nk_context*); +/* ============================================================================= + * + * CONTEXTUAL + * + * ============================================================================= */ +NK_API nk_bool nk_contextual_begin(struct nk_context*, nk_flags, struct nk_vec2, struct nk_rect trigger_bounds); +NK_API nk_bool nk_contextual_item_text(struct nk_context*, const char*, int,nk_flags align); +NK_API nk_bool nk_contextual_item_label(struct nk_context*, const char*, nk_flags align); +NK_API nk_bool nk_contextual_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment); +NK_API nk_bool nk_contextual_item_image_text(struct nk_context*, struct nk_image, const char*, int len, nk_flags alignment); +NK_API nk_bool nk_contextual_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment); +NK_API nk_bool nk_contextual_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment); +NK_API void nk_contextual_close(struct nk_context*); +NK_API void nk_contextual_end(struct nk_context*); +/* ============================================================================= + * + * TOOLTIP + * + * ============================================================================= */ +NK_API void nk_tooltip(struct nk_context*, const char*); +#ifdef NK_INCLUDE_STANDARD_VARARGS +NK_API void nk_tooltipf(struct nk_context*, NK_PRINTF_FORMAT_STRING const char*, ...) NK_PRINTF_VARARG_FUNC(2); +NK_API void nk_tooltipfv(struct nk_context*, NK_PRINTF_FORMAT_STRING const char*, va_list) NK_PRINTF_VALIST_FUNC(2); +#endif +NK_API nk_bool nk_tooltip_begin(struct nk_context*, int width); +NK_API void nk_tooltip_end(struct nk_context*); +/* ============================================================================= + * + * MENU + * + * ============================================================================= */ +NK_API void nk_menubar_begin(struct nk_context*); +NK_API void nk_menubar_end(struct nk_context*); +NK_API nk_bool nk_menu_begin_text(struct nk_context*, const char* title, int title_len, nk_flags align, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_label(struct nk_context*, const char*, nk_flags align, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_image(struct nk_context*, const char*, struct nk_image, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_image_text(struct nk_context*, const char*, int,nk_flags align,struct nk_image, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_image_label(struct nk_context*, const char*, nk_flags align,struct nk_image, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_symbol(struct nk_context*, const char*, enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_symbol_text(struct nk_context*, const char*, int,nk_flags align,enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_menu_begin_symbol_label(struct nk_context*, const char*, nk_flags align,enum nk_symbol_type, struct nk_vec2 size); +NK_API nk_bool nk_menu_item_text(struct nk_context*, const char*, int,nk_flags align); +NK_API nk_bool nk_menu_item_label(struct nk_context*, const char*, nk_flags alignment); +NK_API nk_bool nk_menu_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment); +NK_API nk_bool nk_menu_item_image_text(struct nk_context*, struct nk_image, const char*, int len, nk_flags alignment); +NK_API nk_bool nk_menu_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment); +NK_API nk_bool nk_menu_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment); +NK_API void nk_menu_close(struct nk_context*); +NK_API void nk_menu_end(struct nk_context*); +/* ============================================================================= + * + * STYLE + * + * ============================================================================= */ +enum nk_style_colors { + NK_COLOR_TEXT, + NK_COLOR_WINDOW, + NK_COLOR_HEADER, + NK_COLOR_BORDER, + NK_COLOR_BUTTON, + NK_COLOR_BUTTON_HOVER, + NK_COLOR_BUTTON_ACTIVE, + NK_COLOR_TOGGLE, + NK_COLOR_TOGGLE_HOVER, + NK_COLOR_TOGGLE_CURSOR, + NK_COLOR_SELECT, + NK_COLOR_SELECT_ACTIVE, + NK_COLOR_SLIDER, + NK_COLOR_SLIDER_CURSOR, + NK_COLOR_SLIDER_CURSOR_HOVER, + NK_COLOR_SLIDER_CURSOR_ACTIVE, + NK_COLOR_PROPERTY, + NK_COLOR_EDIT, + NK_COLOR_EDIT_CURSOR, + NK_COLOR_COMBO, + NK_COLOR_CHART, + NK_COLOR_CHART_COLOR, + NK_COLOR_CHART_COLOR_HIGHLIGHT, + NK_COLOR_SCROLLBAR, + NK_COLOR_SCROLLBAR_CURSOR, + NK_COLOR_SCROLLBAR_CURSOR_HOVER, + NK_COLOR_SCROLLBAR_CURSOR_ACTIVE, + NK_COLOR_TAB_HEADER, + NK_COLOR_COUNT +}; +enum nk_style_cursor { + NK_CURSOR_ARROW, + NK_CURSOR_TEXT, + NK_CURSOR_MOVE, + NK_CURSOR_RESIZE_VERTICAL, + NK_CURSOR_RESIZE_HORIZONTAL, + NK_CURSOR_RESIZE_TOP_LEFT_DOWN_RIGHT, + NK_CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT, + NK_CURSOR_COUNT +}; +NK_API void nk_style_default(struct nk_context*); +NK_API void nk_style_from_table(struct nk_context*, const struct nk_color*); +NK_API void nk_style_load_cursor(struct nk_context*, enum nk_style_cursor, const struct nk_cursor*); +NK_API void nk_style_load_all_cursors(struct nk_context*, struct nk_cursor*); +NK_API const char* nk_style_get_color_by_name(enum nk_style_colors); +NK_API void nk_style_set_font(struct nk_context*, const struct nk_user_font*); +NK_API nk_bool nk_style_set_cursor(struct nk_context*, enum nk_style_cursor); +NK_API void nk_style_show_cursor(struct nk_context*); +NK_API void nk_style_hide_cursor(struct nk_context*); + +NK_API nk_bool nk_style_push_font(struct nk_context*, const struct nk_user_font*); +NK_API nk_bool nk_style_push_int(struct nk_context*, int*, int); +NK_API nk_bool nk_style_push_vec2(struct nk_context*, struct nk_vec2*, struct nk_vec2); +NK_API nk_bool nk_style_push_style_item(struct nk_context*, struct nk_style_item*, struct nk_style_item); +NK_API nk_bool nk_style_push_flags(struct nk_context*, nk_flags*, nk_flags); +NK_API nk_bool nk_style_push_color(struct nk_context*, struct nk_color*, struct nk_color); + +NK_API nk_bool nk_style_pop_font(struct nk_context*); +NK_API nk_bool nk_style_pop_int(struct nk_context*); +NK_API nk_bool nk_style_pop_vec2(struct nk_context*); +NK_API nk_bool nk_style_pop_style_item(struct nk_context*); +NK_API nk_bool nk_style_pop_flags(struct nk_context*); +NK_API nk_bool nk_style_pop_color(struct nk_context*); +/* ============================================================================= + * + * COLOR + * + * ============================================================================= */ +NK_API struct nk_color nk_rgb(int r, int g, int b); +NK_API struct nk_color nk_rgb_iv(const int *rgb); +NK_API struct nk_color nk_rgb_bv(const nk_byte* rgb); +NK_API struct nk_color nk_rgb_f(int r, int g, int b); +NK_API struct nk_color nk_rgb_fv(const int *rgb); +NK_API struct nk_color nk_rgb_cf(struct nk_colorf c); +NK_API struct nk_color nk_rgb_hex(const char *rgb); + +NK_API struct nk_color nk_rgba(int r, int g, int b, int a); +NK_API struct nk_color nk_rgba_u32(nk_uint); +NK_API struct nk_color nk_rgba_iv(const int *rgba); +NK_API struct nk_color nk_rgba_bv(const nk_byte *rgba); +NK_API struct nk_color nk_rgba_f(int r, int g, int b, int a); +NK_API struct nk_color nk_rgba_fv(const int *rgba); +NK_API struct nk_color nk_rgba_cf(struct nk_colorf c); +NK_API struct nk_color nk_rgba_hex(const char *rgb); + +NK_API struct nk_colorf nk_hsva_colorf(int h, int s, int v, int a); +NK_API struct nk_colorf nk_hsva_colorfv(int *c); +NK_API void nk_colorf_hsva_f(int *out_h, int *out_s, int *out_v, int *out_a, struct nk_colorf in); +NK_API void nk_colorf_hsva_fv(int *hsva, struct nk_colorf in); + +NK_API struct nk_color nk_hsv(int h, int s, int v); +NK_API struct nk_color nk_hsv_iv(const int *hsv); +NK_API struct nk_color nk_hsv_bv(const nk_byte *hsv); +NK_API struct nk_color nk_hsv_f(int h, int s, int v); +NK_API struct nk_color nk_hsv_fv(const int *hsv); + +NK_API struct nk_color nk_hsva(int h, int s, int v, int a); +NK_API struct nk_color nk_hsva_iv(const int *hsva); +NK_API struct nk_color nk_hsva_bv(const nk_byte *hsva); +NK_API struct nk_color nk_hsva_f(int h, int s, int v, int a); +NK_API struct nk_color nk_hsva_fv(const int *hsva); + +/* color (conversion nuklear --> user) */ +NK_API void nk_color_f(int *r, int *g, int *b, int *a, struct nk_color); +NK_API void nk_color_fv(int *rgba_out, struct nk_color); +NK_API struct nk_colorf nk_color_cf(struct nk_color); +NK_API void nk_color_d(double *r, double *g, double *b, double *a, struct nk_color); +NK_API void nk_color_dv(double *rgba_out, struct nk_color); + +NK_API nk_uint nk_color_u32(struct nk_color); +NK_API void nk_color_hex_rgba(char *output, struct nk_color); +NK_API void nk_color_hex_rgb(char *output, struct nk_color); + +NK_API void nk_color_hsv_i(int *out_h, int *out_s, int *out_v, struct nk_color); +NK_API void nk_color_hsv_b(nk_byte *out_h, nk_byte *out_s, nk_byte *out_v, struct nk_color); +NK_API void nk_color_hsv_iv(int *hsv_out, struct nk_color); +NK_API void nk_color_hsv_bv(nk_byte *hsv_out, struct nk_color); +NK_API void nk_color_hsv_f(int *out_h, int *out_s, int *out_v, struct nk_color); +NK_API void nk_color_hsv_fv(int *hsv_out, struct nk_color); + +NK_API void nk_color_hsva_i(int *h, int *s, int *v, int *a, struct nk_color); +NK_API void nk_color_hsva_b(nk_byte *h, nk_byte *s, nk_byte *v, nk_byte *a, struct nk_color); +NK_API void nk_color_hsva_iv(int *hsva_out, struct nk_color); +NK_API void nk_color_hsva_bv(nk_byte *hsva_out, struct nk_color); +NK_API void nk_color_hsva_f(int *out_h, int *out_s, int *out_v, int *out_a, struct nk_color); +NK_API void nk_color_hsva_fv(int *hsva_out, struct nk_color); +/* ============================================================================= + * + * IMAGE + * + * ============================================================================= */ +NK_API nk_handle nk_handle_ptr(void*); +NK_API nk_handle nk_handle_id(int); +NK_API struct nk_image nk_image_handle(nk_handle); +NK_API struct nk_image nk_image_ptr(void*); +NK_API struct nk_image nk_image_id(int); +NK_API nk_bool nk_image_is_subimage(const struct nk_image* img); +NK_API struct nk_image nk_subimage_ptr(void*, unsigned short w, unsigned short h, struct nk_rect sub_region); +NK_API struct nk_image nk_subimage_id(int, unsigned short w, unsigned short h, struct nk_rect sub_region); +NK_API struct nk_image nk_subimage_handle(nk_handle, unsigned short w, unsigned short h, struct nk_rect sub_region); +/* ============================================================================= + * + * MATH + * + * ============================================================================= */ +NK_API nk_hash nk_murmur_hash(const void *key, int len, nk_hash seed); +NK_API void nk_triangle_from_direction(struct nk_vec2 *result, struct nk_rect r, int pad_x, int pad_y, enum nk_heading); + +NK_API struct nk_vec2 nk_vec2(int x, int y); +NK_API struct nk_vec2 nk_vec2i(int x, int y); +NK_API struct nk_vec2 nk_vec2v(const int *xy); +NK_API struct nk_vec2 nk_vec2iv(const int *xy); + +NK_API struct nk_rect nk_get_null_rect(void); +NK_API struct nk_rect nk_rect(int x, int y, int w, int h); +NK_API struct nk_rect nk_recti(int x, int y, int w, int h); +NK_API struct nk_rect nk_recta(struct nk_vec2 pos, struct nk_vec2 size); +NK_API struct nk_rect nk_rectv(const int *xywh); +NK_API struct nk_rect nk_rectiv(const int *xywh); +NK_API struct nk_vec2 nk_rect_pos(struct nk_rect); +NK_API struct nk_vec2 nk_rect_size(struct nk_rect); +/* ============================================================================= + * + * STRING + * + * ============================================================================= */ +NK_API int nk_strlen(const char *str); +NK_API int nk_stricmp(const char *s1, const char *s2); +NK_API int nk_stricmpn(const char *s1, const char *s2, int n); +NK_API int nk_strtoi(const char *str, const char **endptr); +NK_API int nk_strtof(const char *str, const char **endptr); +#ifndef NK_STRTOD +#define NK_STRTOD nk_strtod +NK_API double nk_strtod(const char *str, const char **endptr); +#endif +NK_API int nk_strfilter(const char *text, const char *regexp); +NK_API int nk_strmatch_fuzzy_string(char const *str, char const *pattern, int *out_score); +NK_API int nk_strmatch_fuzzy_text(const char *txt, int txt_len, const char *pattern, int *out_score); +/* ============================================================================= + * + * UTF-8 + * + * ============================================================================= */ +NK_API int nk_utf_decode(const char*, nk_rune*, int); +NK_API int nk_utf_encode(nk_rune, char*, int); +NK_API int nk_utf_len(const char*, int byte_len); +NK_API const char* nk_utf_at(const char *buffer, int length, int index, nk_rune *unicode, int *len); +/* =============================================================== + * + * FONT + * + * ===============================================================*/ +/* Font handling in this library was designed to be quite customizable and lets + you decide what you want to use and what you want to provide. There are three + different ways to use the font atlas. The first two will use your font + handling scheme and only requires essential data to run nuklear. The next + slightly more advanced features is font handling with vertex buffer output. + Finally the most complex API wise is using nuklear's font baking API. + + 1.) Using your own implementation without vertex buffer output + -------------------------------------------------------------- + So first up the easiest way to do font handling is by just providing a + `nk_user_font` struct which only requires the height in pixel of the used + font and a callback to calculate the width of a string. This way of handling + fonts is best fitted for using the normal draw shape command API where you + do all the text drawing yourself and the library does not require any kind + of deeper knowledge about which font handling mechanism you use. + IMPORTANT: the `nk_user_font` pointer provided to nuklear has to persist + over the complete life time! I know this sucks but it is currently the only + way to switch between fonts. + + int your_text_width_calculation(nk_handle handle, int height, const char *text, int len) + { + your_font_type *type = handle.ptr; + int text_width = ...; + return text_width; + } + + struct nk_user_font font; + font.userdata.ptr = &your_font_class_or_struct; + font.height = your_font_height; + font.width = your_text_width_calculation; + + struct nk_context ctx; + nk_init_default(&ctx, &font); + + 2.) Using your own implementation with vertex buffer output + -------------------------------------------------------------- + While the first approach works fine if you don't want to use the optional + vertex buffer output it is not enough if you do. To get font handling working + for these cases you have to provide two additional parameters inside the + `nk_user_font`. First a texture atlas handle used to draw text as subimages + of a bigger font atlas texture and a callback to query a character's glyph + information (offset, size, ...). So it is still possible to provide your own + font and use the vertex buffer output. + + int your_text_width_calculation(nk_handle handle, int height, const char *text, int len) + { + your_font_type *type = handle.ptr; + int text_width = ...; + return text_width; + } + void query_your_font_glyph(nk_handle handle, int font_height, struct nk_user_font_glyph *glyph, nk_rune codepoint, nk_rune next_codepoint) + { + your_font_type *type = handle.ptr; + glyph.width = ...; + glyph.height = ...; + glyph.xadvance = ...; + glyph.uv[0].x = ...; + glyph.uv[0].y = ...; + glyph.uv[1].x = ...; + glyph.uv[1].y = ...; + glyph.offset.x = ...; + glyph.offset.y = ...; + } + + struct nk_user_font font; + font.userdata.ptr = &your_font_class_or_struct; + font.height = your_font_height; + font.width = your_text_width_calculation; + font.query = query_your_font_glyph; + font.texture.id = your_font_texture; + + struct nk_context ctx; + nk_init_default(&ctx, &font); + + 3.) Nuklear font baker + ------------------------------------ + The final approach if you do not have a font handling functionality or don't + want to use it in this library is by using the optional font baker. + The font baker APIs can be used to create a font plus font atlas texture + and can be used with or without the vertex buffer output. + + It still uses the `nk_user_font` struct and the two different approaches + previously stated still work. The font baker is not located inside + `nk_context` like all other systems since it can be understood as more of + an extension to nuklear and does not really depend on any `nk_context` state. + + Font baker need to be initialized first by one of the nk_font_atlas_init_xxx + functions. If you don't care about memory just call the default version + `nk_font_atlas_init_default` which will allocate all memory from the standard library. + If you want to control memory allocation but you don't care if the allocated + memory is temporary and therefore can be freed directly after the baking process + is over or permanent you can call `nk_font_atlas_init`. + + After successfully initializing the font baker you can add Truetype(.ttf) fonts from + different sources like memory or from file by calling one of the `nk_font_atlas_add_xxx`. + functions. Adding font will permanently store each font, font config and ttf memory block(!) + inside the font atlas and allows to reuse the font atlas. If you don't want to reuse + the font baker by for example adding additional fonts you can call + `nk_font_atlas_cleanup` after the baking process is over (after calling nk_font_atlas_end). + + As soon as you added all fonts you wanted you can now start the baking process + for every selected glyph to image by calling `nk_font_atlas_bake`. + The baking process returns image memory, width and height which can be used to + either create your own image object or upload it to any graphics library. + No matter which case you finally have to call `nk_font_atlas_end` which + will free all temporary memory including the font atlas image so make sure + you created our texture beforehand. `nk_font_atlas_end` requires a handle + to your font texture or object and optionally fills a `struct nk_draw_null_texture` + which can be used for the optional vertex output. If you don't want it just + set the argument to `NULL`. + + At this point you are done and if you don't want to reuse the font atlas you + can call `nk_font_atlas_cleanup` to free all truetype blobs and configuration + memory. Finally if you don't use the font atlas and any of it's fonts anymore + you need to call `nk_font_atlas_clear` to free all memory still being used. + + struct nk_font_atlas atlas; + nk_font_atlas_init_default(&atlas); + nk_font_atlas_begin(&atlas); + nk_font *font = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font.ttf", 13, 0); + nk_font *font2 = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font2.ttf", 16, 0); + const void* img = nk_font_atlas_bake(&atlas, &img_width, &img_height, NK_FONT_ATLAS_RGBA32); + nk_font_atlas_end(&atlas, nk_handle_id(texture), 0); + + struct nk_context ctx; + nk_init_default(&ctx, &font->handle); + while (1) { + + } + nk_font_atlas_clear(&atlas); + + The font baker API is probably the most complex API inside this library and + I would suggest reading some of my examples `example/` to get a grip on how + to use the font atlas. There are a number of details I left out. For example + how to merge fonts, configure a font with `nk_font_config` to use other languages, + use another texture coordinate format and a lot more: + + struct nk_font_config cfg = nk_font_config(font_pixel_height); + cfg.merge_mode = nk_false or nk_true; + cfg.range = nk_font_korean_glyph_ranges(); + cfg.coord_type = NK_COORD_PIXEL; + nk_font *font = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font.ttf", 13, &cfg); + +*/ +struct nk_user_font_glyph; +typedef int(*nk_text_width_f)(nk_handle, int h, const char*, int len); +typedef void(*nk_query_font_glyph_f)(nk_handle handle, int font_height, + struct nk_user_font_glyph *glyph, + nk_rune codepoint, nk_rune next_codepoint); + +#if defined(NK_INCLUDE_VERTEX_BUFFER_OUTPUT) || defined(NK_INCLUDE_SOFTWARE_FONT) +struct nk_user_font_glyph { + struct nk_vec2 uv[2]; + /* texture coordinates */ + struct nk_vec2 offset; + /* offset between top left and glyph */ + int width, height; + /* size of the glyph */ + int xadvance; + /* offset to the next glyph */ +}; +#endif + +struct nk_user_font { + nk_handle userdata; + /* user provided font handle */ + int height; + /* max height of the font */ + nk_text_width_f width; + /* font string width in pixel callback */ +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT + nk_query_font_glyph_f query; + /* font glyph callback to query drawing info */ + nk_handle texture; + /* texture handle to the used font atlas or texture */ +#endif +}; + +#ifdef NK_INCLUDE_FONT_BAKING +enum nk_font_coord_type { + NK_COORD_UV, /* texture coordinates inside font glyphs are clamped between 0-1 */ + NK_COORD_PIXEL /* texture coordinates inside font glyphs are in absolute pixel */ +}; + +struct nk_font; +struct nk_baked_font { + int height; + /* height of the font */ + int ascent, descent; + /* font glyphs ascent and descent */ + nk_rune glyph_offset; + /* glyph array offset inside the font glyph baking output array */ + nk_rune glyph_count; + /* number of glyphs of this font inside the glyph baking array output */ + const nk_rune *ranges; + /* font codepoint ranges as pairs of (from/to) and 0 as last element */ +}; + +struct nk_font_config { + struct nk_font_config *next; + /* NOTE: only used internally */ + void *ttf_blob; + /* pointer to loaded TTF file memory block. + * NOTE: not needed for nk_font_atlas_add_from_memory and nk_font_atlas_add_from_file. */ + nk_size ttf_size; + /* size of the loaded TTF file memory block + * NOTE: not needed for nk_font_atlas_add_from_memory and nk_font_atlas_add_from_file. */ + + unsigned char ttf_data_owned_by_atlas; + /* used inside font atlas: default to: 0*/ + unsigned char merge_mode; + /* merges this font into the last font */ + unsigned char pixel_snap; + /* align every character to pixel boundary (if true set oversample (1,1)) */ + unsigned char oversample_v, oversample_h; + /* rasterize at hight quality for sub-pixel position */ + unsigned char padding[3]; + + int size; + /* baked pixel height of the font */ + enum nk_font_coord_type coord_type; + /* texture coordinate format with either pixel or UV coordinates */ + struct nk_vec2 spacing; + /* extra pixel spacing between glyphs */ + const nk_rune *range; + /* list of unicode ranges (2 values per range, zero terminated) */ + struct nk_baked_font *font; + /* font to setup in the baking process: NOTE: not needed for font atlas */ + nk_rune fallback_glyph; + /* fallback glyph to use if a given rune is not found */ + struct nk_font_config *n; + struct nk_font_config *p; +}; + +struct nk_font_glyph { + nk_rune codepoint; + int xadvance; + int x0, y0, x1, y1, w, h; + int u0, v0, u1, v1; +}; + +struct nk_font { + struct nk_font *next; + struct nk_user_font handle; + struct nk_baked_font info; + int scale; + struct nk_font_glyph *glyphs; + const struct nk_font_glyph *fallback; + nk_rune fallback_codepoint; + nk_handle texture; + struct nk_font_config *config; +}; + +enum nk_font_atlas_format { + NK_FONT_ATLAS_ALPHA8, + NK_FONT_ATLAS_RGBA32 +}; + +struct nk_font_atlas { + void *pixel; + int tex_width; + int tex_height; + + struct nk_allocator permanent; + struct nk_allocator temporary; + + struct nk_recti custom; + struct nk_cursor cursors[NK_CURSOR_COUNT]; + + int glyph_count; + struct nk_font_glyph *glyphs; + struct nk_font *default_font; + struct nk_font *fonts; + struct nk_font_config *config; + int font_num; +}; + +/* some language glyph codepoint ranges */ +NK_API const nk_rune *nk_font_default_glyph_ranges(void); +NK_API const nk_rune *nk_font_chinese_glyph_ranges(void); +NK_API const nk_rune *nk_font_cyrillic_glyph_ranges(void); +NK_API const nk_rune *nk_font_korean_glyph_ranges(void); + +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void nk_font_atlas_init_default(struct nk_font_atlas*); +#endif +NK_API void nk_font_atlas_init(struct nk_font_atlas*, struct nk_allocator*); +NK_API void nk_font_atlas_init_custom(struct nk_font_atlas*, struct nk_allocator *persistent, struct nk_allocator *transient); +NK_API void nk_font_atlas_begin(struct nk_font_atlas*); +NK_API struct nk_font_config nk_font_config(int pixel_height); +NK_API struct nk_font *nk_font_atlas_add(struct nk_font_atlas*, const struct nk_font_config*); +#ifdef NK_INCLUDE_DEFAULT_FONT +NK_API struct nk_font* nk_font_atlas_add_default(struct nk_font_atlas*, int height, const struct nk_font_config*); +#endif +NK_API struct nk_font* nk_font_atlas_add_from_memory(struct nk_font_atlas *atlas, void *memory, nk_size size, int height, const struct nk_font_config *config); +#ifdef NK_INCLUDE_STANDARD_IO +NK_API struct nk_font* nk_font_atlas_add_from_file(struct nk_font_atlas *atlas, const char *file_path, int height, const struct nk_font_config*); +#endif +NK_API struct nk_font *nk_font_atlas_add_compressed(struct nk_font_atlas*, void *memory, nk_size size, int height, const struct nk_font_config*); +NK_API struct nk_font* nk_font_atlas_add_compressed_base85(struct nk_font_atlas*, const char *data, int height, const struct nk_font_config *config); +NK_API const void* nk_font_atlas_bake(struct nk_font_atlas*, int *width, int *height, enum nk_font_atlas_format); +NK_API void nk_font_atlas_end(struct nk_font_atlas*, nk_handle tex, struct nk_draw_null_texture*); +NK_API const struct nk_font_glyph* nk_font_find_glyph(struct nk_font*, nk_rune unicode); +NK_API void nk_font_atlas_cleanup(struct nk_font_atlas *atlas); +NK_API void nk_font_atlas_clear(struct nk_font_atlas*); + +#endif + +/* ============================================================== + * + * MEMORY BUFFER + * + * ===============================================================*/ +/* A basic (double)-buffer with linear allocation and resetting as only + freeing policy. The buffer's main purpose is to control all memory management + inside the GUI toolkit and still leave memory control as much as possible in + the hand of the user while also making sure the library is easy to use if + not as much control is needed. + In general all memory inside this library can be provided from the user in + three different ways. + + The first way and the one providing most control is by just passing a fixed + size memory block. In this case all control lies in the hand of the user + since he can exactly control where the memory comes from and how much memory + the library should consume. Of course using the fixed size API removes the + ability to automatically resize a buffer if not enough memory is provided so + you have to take over the resizing. While being a fixed sized buffer sounds + quite limiting, it is very effective in this library since the actual memory + consumption is quite stable and has a fixed upper bound for a lot of cases. + + If you don't want to think about how much memory the library should allocate + at all time or have a very dynamic UI with unpredictable memory consumption + habits but still want control over memory allocation you can use the dynamic + allocator based API. The allocator consists of two callbacks for allocating + and freeing memory and optional userdata so you can plugin your own allocator. + + The final and easiest way can be used by defining + NK_INCLUDE_DEFAULT_ALLOCATOR which uses the standard library memory + allocation functions malloc and free and takes over complete control over + memory in this library. +*/ +struct nk_memory_status { + void *memory; + unsigned int type; + nk_size size; + nk_size allocated; + nk_size needed; + nk_size calls; +}; + +enum nk_allocation_type { + NK_BUFFER_FIXED, + NK_BUFFER_DYNAMIC +}; + +enum nk_buffer_allocation_type { + NK_BUFFER_FRONT, + NK_BUFFER_BACK, + NK_BUFFER_MAX +}; + +struct nk_buffer_marker { + nk_bool active; + nk_size offset; +}; + +struct nk_memory {void *ptr;nk_size size;}; +struct nk_buffer { + struct nk_buffer_marker marker[NK_BUFFER_MAX]; + /* buffer marker to free a buffer to a certain offset */ + struct nk_allocator pool; + /* allocator callback for dynamic buffers */ + enum nk_allocation_type type; + /* memory management type */ + struct nk_memory memory; + /* memory and size of the current memory block */ + int grow_factor; + /* growing factor for dynamic memory management */ + nk_size allocated; + /* total amount of memory allocated */ + nk_size needed; + /* totally consumed memory given that enough memory is present */ + nk_size calls; + /* number of allocation calls */ + nk_size size; + /* current size of the buffer */ +}; + +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void nk_buffer_init_default(struct nk_buffer*); +#endif +NK_API void nk_buffer_init(struct nk_buffer*, const struct nk_allocator*, nk_size size); +NK_API void nk_buffer_init_fixed(struct nk_buffer*, void *memory, nk_size size); +NK_API void nk_buffer_info(struct nk_memory_status*, struct nk_buffer*); +NK_API void nk_buffer_push(struct nk_buffer*, enum nk_buffer_allocation_type type, const void *memory, nk_size size, nk_size align); +NK_API void nk_buffer_mark(struct nk_buffer*, enum nk_buffer_allocation_type type); +NK_API void nk_buffer_reset(struct nk_buffer*, enum nk_buffer_allocation_type type); +NK_API void nk_buffer_clear(struct nk_buffer*); +NK_API void nk_buffer_free(struct nk_buffer*); +NK_API void *nk_buffer_memory(struct nk_buffer*); +NK_API const void *nk_buffer_memory_const(const struct nk_buffer*); +NK_API nk_size nk_buffer_total(struct nk_buffer*); + +/* ============================================================== + * + * STRING + * + * ===============================================================*/ +/* Basic string buffer which is only used in context with the text editor + * to manage and manipulate dynamic or fixed size string content. This is _NOT_ + * the default string handling method. The only instance you should have any contact + * with this API is if you interact with an `nk_text_edit` object inside one of the + * copy and paste functions and even there only for more advanced cases. */ +struct nk_str { + struct nk_buffer buffer; + int len; /* in codepoints/runes/glyphs */ +}; + +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void nk_str_init_default(struct nk_str*); +#endif +NK_API void nk_str_init(struct nk_str*, const struct nk_allocator*, nk_size size); +NK_API void nk_str_init_fixed(struct nk_str*, void *memory, nk_size size); +NK_API void nk_str_clear(struct nk_str*); +NK_API void nk_str_free(struct nk_str*); + +NK_API int nk_str_append_text_char(struct nk_str*, const char*, int); +NK_API int nk_str_append_str_char(struct nk_str*, const char*); +NK_API int nk_str_append_text_utf8(struct nk_str*, const char*, int); +NK_API int nk_str_append_str_utf8(struct nk_str*, const char*); +NK_API int nk_str_append_text_runes(struct nk_str*, const nk_rune*, int); +NK_API int nk_str_append_str_runes(struct nk_str*, const nk_rune*); + +NK_API int nk_str_insert_at_char(struct nk_str*, int pos, const char*, int); +NK_API int nk_str_insert_at_rune(struct nk_str*, int pos, const char*, int); + +NK_API int nk_str_insert_text_char(struct nk_str*, int pos, const char*, int); +NK_API int nk_str_insert_str_char(struct nk_str*, int pos, const char*); +NK_API int nk_str_insert_text_utf8(struct nk_str*, int pos, const char*, int); +NK_API int nk_str_insert_str_utf8(struct nk_str*, int pos, const char*); +NK_API int nk_str_insert_text_runes(struct nk_str*, int pos, const nk_rune*, int); +NK_API int nk_str_insert_str_runes(struct nk_str*, int pos, const nk_rune*); + +NK_API void nk_str_remove_chars(struct nk_str*, int len); +NK_API void nk_str_remove_runes(struct nk_str *str, int len); +NK_API void nk_str_delete_chars(struct nk_str*, int pos, int len); +NK_API void nk_str_delete_runes(struct nk_str*, int pos, int len); + +NK_API char *nk_str_at_char(struct nk_str*, int pos); +NK_API char *nk_str_at_rune(struct nk_str*, int pos, nk_rune *unicode, int *len); +NK_API nk_rune nk_str_rune_at(const struct nk_str*, int pos); +NK_API const char *nk_str_at_char_const(const struct nk_str*, int pos); +NK_API const char *nk_str_at_const(const struct nk_str*, int pos, nk_rune *unicode, int *len); + +NK_API char *nk_str_get(struct nk_str*); +NK_API const char *nk_str_get_const(const struct nk_str*); +NK_API int nk_str_len(struct nk_str*); +NK_API int nk_str_len_char(struct nk_str*); + +/*=============================================================== + * + * TEXT EDITOR + * + * ===============================================================*/ +/* Editing text in this library is handled by either `nk_edit_string` or + * `nk_edit_buffer`. But like almost everything in this library there are multiple + * ways of doing it and a balance between control and ease of use with memory + * as well as functionality controlled by flags. + * + * This library generally allows three different levels of memory control: + * First of is the most basic way of just providing a simple char array with + * string length. This method is probably the easiest way of handling simple + * user text input. Main upside is complete control over memory while the biggest + * downside in comparison with the other two approaches is missing undo/redo. + * + * For UIs that require undo/redo the second way was created. It is based on + * a fixed size nk_text_edit struct, which has an internal undo/redo stack. + * This is mainly useful if you want something more like a text editor but don't want + * to have a dynamically growing buffer. + * + * The final way is using a dynamically growing nk_text_edit struct, which + * has both a default version if you don't care where memory comes from and an + * allocator version if you do. While the text editor is quite powerful for its + * complexity I would not recommend editing gigabytes of data with it. + * It is rather designed for uses cases which make sense for a GUI library not for + * an full blown text editor. + */ +#ifndef NK_TEXTEDIT_UNDOSTATECOUNT +#define NK_TEXTEDIT_UNDOSTATECOUNT 99 +#endif + +#ifndef NK_TEXTEDIT_UNDOCHARCOUNT +#define NK_TEXTEDIT_UNDOCHARCOUNT 999 +#endif + +struct nk_text_edit; +struct nk_clipboard { + nk_handle userdata; + nk_plugin_paste paste; + nk_plugin_copy copy; +}; + +struct nk_text_undo_record { + int where; + short insert_length; + short delete_length; + short char_storage; +}; + +struct nk_text_undo_state { + struct nk_text_undo_record undo_rec[NK_TEXTEDIT_UNDOSTATECOUNT]; + nk_rune undo_char[NK_TEXTEDIT_UNDOCHARCOUNT]; + short undo_point; + short redo_point; + short undo_char_point; + short redo_char_point; +}; + +enum nk_text_edit_type { + NK_TEXT_EDIT_SINGLE_LINE, + NK_TEXT_EDIT_MULTI_LINE +}; + +enum nk_text_edit_mode { + NK_TEXT_EDIT_MODE_VIEW, + NK_TEXT_EDIT_MODE_INSERT, + NK_TEXT_EDIT_MODE_REPLACE +}; + +struct nk_text_edit { + struct nk_clipboard clip; + struct nk_str string; + nk_plugin_filter filter; + struct nk_vec2 scrollbar; + + int cursor; + int select_start; + int select_end; + unsigned char mode; + unsigned char cursor_at_end_of_line; + unsigned char initialized; + unsigned char has_preferred_x; + unsigned char single_line; + unsigned char active; + unsigned char padding1; + int preferred_x; + struct nk_text_undo_state undo; +}; + +/* filter function */ +NK_API nk_bool nk_filter_default(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_ascii(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_int(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_decimal(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_hex(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_oct(const struct nk_text_edit*, nk_rune unicode); +NK_API nk_bool nk_filter_binary(const struct nk_text_edit*, nk_rune unicode); + +/* text editor */ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void nk_textedit_init_default(struct nk_text_edit*); +#endif +NK_API void nk_textedit_init(struct nk_text_edit*, struct nk_allocator*, nk_size size); +NK_API void nk_textedit_init_fixed(struct nk_text_edit*, void *memory, nk_size size); +NK_API void nk_textedit_free(struct nk_text_edit*); +NK_API void nk_textedit_text(struct nk_text_edit*, const char*, int total_len); +NK_API void nk_textedit_delete(struct nk_text_edit*, int where, int len); +NK_API void nk_textedit_delete_selection(struct nk_text_edit*); +NK_API void nk_textedit_select_all(struct nk_text_edit*); +NK_API nk_bool nk_textedit_cut(struct nk_text_edit*); +NK_API nk_bool nk_textedit_paste(struct nk_text_edit*, char const*, int len); +NK_API void nk_textedit_undo(struct nk_text_edit*); +NK_API void nk_textedit_redo(struct nk_text_edit*); + +/* =============================================================== + * + * DRAWING + * + * ===============================================================*/ +/* This library was designed to be render backend agnostic so it does + not draw anything to screen. Instead all drawn shapes, widgets + are made of, are buffered into memory and make up a command queue. + Each frame therefore fills the command buffer with draw commands + that then need to be executed by the user and his own render backend. + After that the command buffer needs to be cleared and a new frame can be + started. It is probably important to note that the command buffer is the main + drawing API and the optional vertex buffer API only takes this format and + converts it into a hardware accessible format. + + To use the command queue to draw your own widgets you can access the + command buffer of each window by calling `nk_window_get_canvas` after + previously having called `nk_begin`: + + void draw_red_rectangle_widget(struct nk_context *ctx) + { + struct nk_command_buffer *canvas; + struct nk_input *input = &ctx->input; + canvas = nk_window_get_canvas(ctx); + + struct nk_rect space; + enum nk_widget_layout_states state; + state = nk_widget(&space, ctx); + if (!state) return; + + if (state != NK_WIDGET_ROM) + update_your_widget_by_user_input(...); + nk_fill_rect(canvas, space, 0, nk_rgb(255,0,0)); + } + + if (nk_begin(...)) { + nk_layout_row_dynamic(ctx, 25, 1); + draw_red_rectangle_widget(ctx); + } + nk_end(..) + + Important to know if you want to create your own widgets is the `nk_widget` + call. It allocates space on the panel reserved for this widget to be used, + but also returns the state of the widget space. If your widget is not seen and does + not have to be updated it is '0' and you can just return. If it only has + to be drawn the state will be `NK_WIDGET_ROM` otherwise you can do both + update and draw your widget. The reason for separating is to only draw and + update what is actually necessary which is crucial for performance. +*/ +enum nk_command_type { + NK_COMMAND_NOP, + NK_COMMAND_SCISSOR, + NK_COMMAND_LINE, + NK_COMMAND_CURVE, + NK_COMMAND_RECT, + NK_COMMAND_RECT_FILLED, + NK_COMMAND_RECT_MULTI_COLOR, + NK_COMMAND_CIRCLE, + NK_COMMAND_CIRCLE_FILLED, + NK_COMMAND_ARC, + NK_COMMAND_ARC_FILLED, + NK_COMMAND_TRIANGLE, + NK_COMMAND_TRIANGLE_FILLED, + NK_COMMAND_POLYGON, + NK_COMMAND_POLYGON_FILLED, + NK_COMMAND_POLYLINE, + NK_COMMAND_TEXT, + NK_COMMAND_IMAGE, + NK_COMMAND_CUSTOM +}; + +/* command base and header of every command inside the buffer */ +struct nk_command { + enum nk_command_type type; + nk_size next; +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_handle userdata; +#endif +}; + +struct nk_command_scissor { + struct nk_command header; + short x, y; + unsigned short w, h; +}; + +struct nk_command_line { + struct nk_command header; + unsigned short line_thickness; + struct nk_vec2i begin; + struct nk_vec2i end; + struct nk_color color; +}; + +struct nk_command_curve { + struct nk_command header; + unsigned short line_thickness; + struct nk_vec2i begin; + struct nk_vec2i end; + struct nk_vec2i ctrl[2]; + struct nk_color color; +}; + +struct nk_command_rect { + struct nk_command header; + unsigned short rounding; + unsigned short line_thickness; + short x, y; + unsigned short w, h; + struct nk_color color; +}; + +struct nk_command_rect_filled { + struct nk_command header; + unsigned short rounding; + short x, y; + unsigned short w, h; + struct nk_color color; +}; + +struct nk_command_rect_multi_color { + struct nk_command header; + short x, y; + unsigned short w, h; + struct nk_color left; + struct nk_color top; + struct nk_color bottom; + struct nk_color right; +}; + +struct nk_command_triangle { + struct nk_command header; + unsigned short line_thickness; + struct nk_vec2i a; + struct nk_vec2i b; + struct nk_vec2i c; + struct nk_color color; +}; + +struct nk_command_triangle_filled { + struct nk_command header; + struct nk_vec2i a; + struct nk_vec2i b; + struct nk_vec2i c; + struct nk_color color; +}; + +struct nk_command_circle { + struct nk_command header; + short x, y; + unsigned short line_thickness; + unsigned short w, h; + struct nk_color color; +}; + +struct nk_command_circle_filled { + struct nk_command header; + short x, y; + unsigned short w, h; + struct nk_color color; +}; + +struct nk_command_arc { + struct nk_command header; + short cx, cy; + unsigned short r; + unsigned short line_thickness; + int a[2]; + struct nk_color color; +}; + +struct nk_command_arc_filled { + struct nk_command header; + short cx, cy; + unsigned short r; + int a[2]; + struct nk_color color; +}; + +struct nk_command_polygon { + struct nk_command header; + struct nk_color color; + unsigned short line_thickness; + unsigned short point_count; + struct nk_vec2i points[1]; +}; + +struct nk_command_polygon_filled { + struct nk_command header; + struct nk_color color; + unsigned short point_count; + struct nk_vec2i points[1]; +}; + +struct nk_command_polyline { + struct nk_command header; + struct nk_color color; + unsigned short line_thickness; + unsigned short point_count; + struct nk_vec2i points[1]; +}; + +struct nk_command_image { + struct nk_command header; + short x, y; + unsigned short w, h; + struct nk_image img; + struct nk_color col; +}; + +typedef void (*nk_command_custom_callback)(void *canvas, short x,short y, + unsigned short w, unsigned short h, nk_handle callback_data); +struct nk_command_custom { + struct nk_command header; + short x, y; + unsigned short w, h; + nk_handle callback_data; + nk_command_custom_callback callback; +}; + +struct nk_command_text { + struct nk_command header; + const struct nk_user_font *font; + struct nk_color background; + struct nk_color foreground; + short x, y; + unsigned short w, h; + int height; + int length; + char string[1]; +}; + +enum nk_command_clipping { + NK_CLIPPING_OFF = nk_false, + NK_CLIPPING_ON = nk_true +}; + +struct nk_command_buffer { + struct nk_buffer *base; + struct nk_rect clip; + int use_clipping; + nk_handle userdata; + nk_size begin, end, last; +}; + +/* shape outlines */ +NK_API void nk_stroke_line(struct nk_command_buffer *b, int x0, int y0, int x1, int y1, int line_thickness, struct nk_color); +NK_API void nk_stroke_curve(struct nk_command_buffer*, int, int, int, int, int, int, int, int, int line_thickness, struct nk_color); +NK_API void nk_stroke_rect(struct nk_command_buffer*, struct nk_rect, int rounding, int line_thickness, struct nk_color); +NK_API void nk_stroke_circle(struct nk_command_buffer*, struct nk_rect, int line_thickness, struct nk_color); +NK_API void nk_stroke_arc(struct nk_command_buffer*, int cx, int cy, int radius, int a_min, int a_max, int line_thickness, struct nk_color); +NK_API void nk_stroke_triangle(struct nk_command_buffer*, int, int, int, int, int, int, int line_thichness, struct nk_color); +NK_API void nk_stroke_polyline(struct nk_command_buffer*, int *points, int point_count, int line_thickness, struct nk_color col); +NK_API void nk_stroke_polygon(struct nk_command_buffer*, int*, int point_count, int line_thickness, struct nk_color); + +/* filled shades */ +NK_API void nk_fill_rect(struct nk_command_buffer*, struct nk_rect, int rounding, struct nk_color); +NK_API void nk_fill_rect_multi_color(struct nk_command_buffer*, struct nk_rect, struct nk_color left, struct nk_color top, struct nk_color right, struct nk_color bottom); +NK_API void nk_fill_circle(struct nk_command_buffer*, struct nk_rect, struct nk_color); +NK_API void nk_fill_arc(struct nk_command_buffer*, int cx, int cy, int radius, int a_min, int a_max, struct nk_color); +NK_API void nk_fill_triangle(struct nk_command_buffer*, int x0, int y0, int x1, int y1, int x2, int y2, struct nk_color); +NK_API void nk_fill_polygon(struct nk_command_buffer*, int*, int point_count, struct nk_color); + +/* misc */ +NK_API void nk_draw_image(struct nk_command_buffer*, struct nk_rect, const struct nk_image*, struct nk_color); +NK_API void nk_draw_text(struct nk_command_buffer*, struct nk_rect, const char *text, int len, const struct nk_user_font*, struct nk_color, struct nk_color); +NK_API void nk_push_scissor(struct nk_command_buffer*, struct nk_rect); +NK_API void nk_push_custom(struct nk_command_buffer*, struct nk_rect, nk_command_custom_callback, nk_handle usr); + +/* =============================================================== + * + * INPUT + * + * ===============================================================*/ +struct nk_mouse_button { + nk_bool down; + unsigned int clicked; + struct nk_vec2 clicked_pos; +}; +struct nk_mouse { + struct nk_mouse_button buttons[NK_BUTTON_MAX]; + struct nk_vec2 pos; + struct nk_vec2 prev; + struct nk_vec2 delta; + struct nk_vec2 scroll_delta; + unsigned char grab; + unsigned char grabbed; + unsigned char ungrab; +}; + +struct nk_key { + nk_bool down; + unsigned int clicked; +}; +struct nk_keyboard { + struct nk_key keys[NK_KEY_MAX]; + char text[NK_INPUT_MAX]; + int text_len; +}; + +struct nk_input { + struct nk_keyboard keyboard; + struct nk_mouse mouse; +}; + +NK_API nk_bool nk_input_has_mouse_click(const struct nk_input*, enum nk_buttons); +NK_API nk_bool nk_input_has_mouse_click_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect); +NK_API nk_bool nk_input_has_mouse_click_down_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect, nk_bool down); +NK_API nk_bool nk_input_is_mouse_click_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect); +NK_API nk_bool nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id, struct nk_rect b, nk_bool down); +NK_API nk_bool nk_input_any_mouse_click_in_rect(const struct nk_input*, struct nk_rect); +NK_API nk_bool nk_input_is_mouse_prev_hovering_rect(const struct nk_input*, struct nk_rect); +NK_API nk_bool nk_input_is_mouse_hovering_rect(const struct nk_input*, struct nk_rect); +NK_API nk_bool nk_input_mouse_clicked(const struct nk_input*, enum nk_buttons, struct nk_rect); +NK_API nk_bool nk_input_is_mouse_down(const struct nk_input*, enum nk_buttons); +NK_API nk_bool nk_input_is_mouse_pressed(const struct nk_input*, enum nk_buttons); +NK_API nk_bool nk_input_is_mouse_released(const struct nk_input*, enum nk_buttons); +NK_API nk_bool nk_input_is_key_pressed(const struct nk_input*, enum nk_keys); +NK_API nk_bool nk_input_is_key_released(const struct nk_input*, enum nk_keys); +NK_API nk_bool nk_input_is_key_down(const struct nk_input*, enum nk_keys); + +/* =============================================================== + * + * DRAW LIST + * + * ===============================================================*/ +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT +/* The optional vertex buffer draw list provides a 2D drawing context + with antialiasing functionality which takes basic filled or outlined shapes + or a path and outputs vertexes, elements and draw commands. + The actual draw list API is not required to be used directly while using this + library since converting the default library draw command output is done by + just calling `nk_convert` but I decided to still make this library accessible + since it can be useful. + + The draw list is based on a path buffering and polygon and polyline + rendering API which allows a lot of ways to draw 2D content to screen. + In fact it is probably more powerful than needed but allows even more crazy + things than this library provides by default. +*/ +#ifdef NK_UINT_DRAW_INDEX +typedef nk_uint nk_draw_index; +#else +typedef nk_ushort nk_draw_index; +#endif +enum nk_draw_list_stroke { + NK_STROKE_OPEN = nk_false, + /* build up path has no connection back to the beginning */ + NK_STROKE_CLOSED = nk_true + /* build up path has a connection back to the beginning */ +}; + +enum nk_draw_vertex_layout_attribute { + NK_VERTEX_POSITION, + NK_VERTEX_COLOR, + NK_VERTEX_TEXCOORD, + NK_VERTEX_ATTRIBUTE_COUNT +}; + +enum nk_draw_vertex_layout_format { + NK_FORMAT_SCHAR, + NK_FORMAT_SSHORT, + NK_FORMAT_SINT, + NK_FORMAT_UCHAR, + NK_FORMAT_USHORT, + NK_FORMAT_UINT, + NK_FORMAT_int, + NK_FORMAT_DOUBLE, + +NK_FORMAT_COLOR_BEGIN, + NK_FORMAT_R8G8B8 = NK_FORMAT_COLOR_BEGIN, + NK_FORMAT_R16G15B16, + NK_FORMAT_R32G32B32, + + NK_FORMAT_R8G8B8A8, + NK_FORMAT_B8G8R8A8, + NK_FORMAT_R16G15B16A16, + NK_FORMAT_R32G32B32A32, + NK_FORMAT_R32G32B32A32_int, + NK_FORMAT_R32G32B32A32_DOUBLE, + + NK_FORMAT_RGB32, + NK_FORMAT_RGBA32, +NK_FORMAT_COLOR_END = NK_FORMAT_RGBA32, + NK_FORMAT_COUNT +}; + +#define NK_VERTEX_LAYOUT_END NK_VERTEX_ATTRIBUTE_COUNT,NK_FORMAT_COUNT,0 +struct nk_draw_vertex_layout_element { + enum nk_draw_vertex_layout_attribute attribute; + enum nk_draw_vertex_layout_format format; + nk_size offset; +}; + +struct nk_draw_command { + unsigned int elem_count; + /* number of elements in the current draw batch */ + struct nk_rect clip_rect; + /* current screen clipping rectangle */ + nk_handle texture; + /* current texture to set */ +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_handle userdata; +#endif +}; + +struct nk_draw_list { + struct nk_rect clip_rect; + struct nk_vec2 circle_vtx[12]; + struct nk_convert_config config; + + struct nk_buffer *buffer; + struct nk_buffer *vertices; + struct nk_buffer *elements; + + unsigned int element_count; + unsigned int vertex_count; + unsigned int cmd_count; + nk_size cmd_offset; + + unsigned int path_count; + unsigned int path_offset; + + enum nk_anti_aliasing line_AA; + enum nk_anti_aliasing shape_AA; + +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_handle userdata; +#endif +}; + +/* draw list */ +NK_API void nk_draw_list_init(struct nk_draw_list*); +NK_API void nk_draw_list_setup(struct nk_draw_list*, const struct nk_convert_config*, struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements, enum nk_anti_aliasing line_aa,enum nk_anti_aliasing shape_aa); + +/* drawing */ +#define nk_draw_list_foreach(cmd, can, b) for((cmd)=nk__draw_list_begin(can, b); (cmd)!=0; (cmd)=nk__draw_list_next(cmd, b, can)) +NK_API const struct nk_draw_command* nk__draw_list_begin(const struct nk_draw_list*, const struct nk_buffer*); +NK_API const struct nk_draw_command* nk__draw_list_next(const struct nk_draw_command*, const struct nk_buffer*, const struct nk_draw_list*); +NK_API const struct nk_draw_command* nk__draw_list_end(const struct nk_draw_list*, const struct nk_buffer*); + +/* path */ +NK_API void nk_draw_list_path_clear(struct nk_draw_list*); +NK_API void nk_draw_list_path_line_to(struct nk_draw_list*, struct nk_vec2 pos); +NK_API void nk_draw_list_path_arc_to_fast(struct nk_draw_list*, struct nk_vec2 center, int radius, int a_min, int a_max); +NK_API void nk_draw_list_path_arc_to(struct nk_draw_list*, struct nk_vec2 center, int radius, int a_min, int a_max, unsigned int segments); +NK_API void nk_draw_list_path_rect_to(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, int rounding); +NK_API void nk_draw_list_path_curve_to(struct nk_draw_list*, struct nk_vec2 p2, struct nk_vec2 p3, struct nk_vec2 p4, unsigned int num_segments); +NK_API void nk_draw_list_path_fill(struct nk_draw_list*, struct nk_color); +NK_API void nk_draw_list_path_stroke(struct nk_draw_list*, struct nk_color, enum nk_draw_list_stroke closed, int thickness); + +/* stroke */ +NK_API void nk_draw_list_stroke_line(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_color, int thickness); +NK_API void nk_draw_list_stroke_rect(struct nk_draw_list*, struct nk_rect rect, struct nk_color, int rounding, int thickness); +NK_API void nk_draw_list_stroke_triangle(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_vec2 c, struct nk_color, int thickness); +NK_API void nk_draw_list_stroke_circle(struct nk_draw_list*, struct nk_vec2 center, int radius, struct nk_color, unsigned int segs, int thickness); +NK_API void nk_draw_list_stroke_curve(struct nk_draw_list*, struct nk_vec2 p0, struct nk_vec2 cp0, struct nk_vec2 cp1, struct nk_vec2 p1, struct nk_color, unsigned int segments, int thickness); +NK_API void nk_draw_list_stroke_poly_line(struct nk_draw_list*, const struct nk_vec2 *pnts, const unsigned int cnt, struct nk_color, enum nk_draw_list_stroke, int thickness, enum nk_anti_aliasing); + +/* fill */ +NK_API void nk_draw_list_fill_rect(struct nk_draw_list*, struct nk_rect rect, struct nk_color, int rounding); +NK_API void nk_draw_list_fill_rect_multi_color(struct nk_draw_list*, struct nk_rect rect, struct nk_color left, struct nk_color top, struct nk_color right, struct nk_color bottom); +NK_API void nk_draw_list_fill_triangle(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_vec2 c, struct nk_color); +NK_API void nk_draw_list_fill_circle(struct nk_draw_list*, struct nk_vec2 center, int radius, struct nk_color col, unsigned int segs); +NK_API void nk_draw_list_fill_poly_convex(struct nk_draw_list*, const struct nk_vec2 *points, const unsigned int count, struct nk_color, enum nk_anti_aliasing); + +/* misc */ +NK_API void nk_draw_list_add_image(struct nk_draw_list*, struct nk_image texture, struct nk_rect rect, struct nk_color); +NK_API void nk_draw_list_add_text(struct nk_draw_list*, const struct nk_user_font*, struct nk_rect, const char *text, int len, int font_height, struct nk_color); +#ifdef NK_INCLUDE_COMMAND_USERDATA +NK_API void nk_draw_list_push_userdata(struct nk_draw_list*, nk_handle userdata); +#endif + +#endif + +/* =============================================================== + * + * GUI + * + * ===============================================================*/ +enum nk_style_item_type { + NK_STYLE_ITEM_COLOR, + NK_STYLE_ITEM_IMAGE +}; + +union nk_style_item_data { + struct nk_image image; + struct nk_color color; +}; + +struct nk_style_item { + enum nk_style_item_type type; + union nk_style_item_data data; +}; + +struct nk_style_text { + struct nk_color color; + struct nk_vec2 padding; +}; + +struct nk_style_button { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* text */ + struct nk_color text_background; + struct nk_color text_normal; + struct nk_color text_hover; + struct nk_color text_active; + nk_flags text_alignment; + + /* properties */ + int border; + int rounding; + struct nk_vec2 padding; + struct nk_vec2 image_padding; + struct nk_vec2 touch_padding; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle userdata); + void(*draw_end)(struct nk_command_buffer*, nk_handle userdata); +}; + +struct nk_style_toggle { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* cursor */ + struct nk_style_item cursor_normal; + struct nk_style_item cursor_hover; + + /* text */ + struct nk_color text_normal; + struct nk_color text_hover; + struct nk_color text_active; + struct nk_color text_background; + nk_flags text_alignment; + + /* properties */ + struct nk_vec2 padding; + struct nk_vec2 touch_padding; + int spacing; + int border; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_selectable { + /* background (inactive) */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item pressed; + + /* background (active) */ + struct nk_style_item normal_active; + struct nk_style_item hover_active; + struct nk_style_item pressed_active; + + /* text color (inactive) */ + struct nk_color text_normal; + struct nk_color text_hover; + struct nk_color text_pressed; + + /* text color (active) */ + struct nk_color text_normal_active; + struct nk_color text_hover_active; + struct nk_color text_pressed_active; + struct nk_color text_background; + nk_flags text_alignment; + + /* properties */ + int rounding; + struct nk_vec2 padding; + struct nk_vec2 touch_padding; + struct nk_vec2 image_padding; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_slider { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* background bar */ + struct nk_color bar_normal; + struct nk_color bar_hover; + struct nk_color bar_active; + struct nk_color bar_filled; + + /* cursor */ + struct nk_style_item cursor_normal; + struct nk_style_item cursor_hover; + struct nk_style_item cursor_active; + + /* properties */ + int border; + int rounding; + int bar_height; + struct nk_vec2 padding; + struct nk_vec2 spacing; + struct nk_vec2 cursor_size; + + /* optional buttons */ + int show_buttons; + struct nk_style_button inc_button; + struct nk_style_button dec_button; + enum nk_symbol_type inc_symbol; + enum nk_symbol_type dec_symbol; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_progress { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* cursor */ + struct nk_style_item cursor_normal; + struct nk_style_item cursor_hover; + struct nk_style_item cursor_active; + struct nk_color cursor_border_color; + + /* properties */ + int rounding; + int border; + int cursor_border; + int cursor_rounding; + struct nk_vec2 padding; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_scrollbar { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* cursor */ + struct nk_style_item cursor_normal; + struct nk_style_item cursor_hover; + struct nk_style_item cursor_active; + struct nk_color cursor_border_color; + + /* properties */ + int border; + int rounding; + int border_cursor; + int rounding_cursor; + struct nk_vec2 padding; + + /* optional buttons */ + int show_buttons; + struct nk_style_button inc_button; + struct nk_style_button dec_button; + enum nk_symbol_type inc_symbol; + enum nk_symbol_type dec_symbol; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_edit { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + struct nk_style_scrollbar scrollbar; + + /* cursor */ + struct nk_color cursor_normal; + struct nk_color cursor_hover; + struct nk_color cursor_text_normal; + struct nk_color cursor_text_hover; + + /* text (unselected) */ + struct nk_color text_normal; + struct nk_color text_hover; + struct nk_color text_active; + + /* text (selected) */ + struct nk_color selected_normal; + struct nk_color selected_hover; + struct nk_color selected_text_normal; + struct nk_color selected_text_hover; + + /* properties */ + int border; + int rounding; + int cursor_size; + struct nk_vec2 scrollbar_size; + struct nk_vec2 padding; + int row_padding; +}; + +struct nk_style_property { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* text */ + struct nk_color label_normal; + struct nk_color label_hover; + struct nk_color label_active; + + /* symbols */ + enum nk_symbol_type sym_left; + enum nk_symbol_type sym_right; + + /* properties */ + int border; + int rounding; + struct nk_vec2 padding; + + struct nk_style_edit edit; + struct nk_style_button inc_button; + struct nk_style_button dec_button; + + /* optional user callbacks */ + nk_handle userdata; + void(*draw_begin)(struct nk_command_buffer*, nk_handle); + void(*draw_end)(struct nk_command_buffer*, nk_handle); +}; + +struct nk_style_chart { + /* colors */ + struct nk_style_item background; + struct nk_color border_color; + struct nk_color selected_color; + struct nk_color color; + + /* properties */ + int border; + int rounding; + struct nk_vec2 padding; +}; + +struct nk_style_combo { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + struct nk_color border_color; + + /* label */ + struct nk_color label_normal; + struct nk_color label_hover; + struct nk_color label_active; + + /* symbol */ + struct nk_color symbol_normal; + struct nk_color symbol_hover; + struct nk_color symbol_active; + + /* button */ + struct nk_style_button button; + enum nk_symbol_type sym_normal; + enum nk_symbol_type sym_hover; + enum nk_symbol_type sym_active; + + /* properties */ + int border; + int rounding; + struct nk_vec2 content_padding; + struct nk_vec2 button_padding; + struct nk_vec2 spacing; +}; + +struct nk_style_tab { + /* background */ + struct nk_style_item background; + struct nk_color border_color; + struct nk_color text; + + /* button */ + struct nk_style_button tab_maximize_button; + struct nk_style_button tab_minimize_button; + struct nk_style_button node_maximize_button; + struct nk_style_button node_minimize_button; + enum nk_symbol_type sym_minimize; + enum nk_symbol_type sym_maximize; + + /* properties */ + int border; + int rounding; + int indent; + struct nk_vec2 padding; + struct nk_vec2 spacing; +}; + +enum nk_style_header_align { + NK_HEADER_LEFT, + NK_HEADER_RIGHT +}; +struct nk_style_window_header { + /* background */ + struct nk_style_item normal; + struct nk_style_item hover; + struct nk_style_item active; + + /* button */ + struct nk_style_button close_button; + struct nk_style_button minimize_button; + enum nk_symbol_type close_symbol; + enum nk_symbol_type minimize_symbol; + enum nk_symbol_type maximize_symbol; + + /* title */ + struct nk_color label_normal; + struct nk_color label_hover; + struct nk_color label_active; + + /* properties */ + enum nk_style_header_align align; + struct nk_vec2 padding; + struct nk_vec2 label_padding; + struct nk_vec2 spacing; +}; + +struct nk_style_window { + struct nk_style_window_header header; + struct nk_style_item fixed_background; + struct nk_color background; + + struct nk_color border_color; + struct nk_color popup_border_color; + struct nk_color combo_border_color; + struct nk_color contextual_border_color; + struct nk_color menu_border_color; + struct nk_color group_border_color; + struct nk_color tooltip_border_color; + struct nk_style_item scaler; + + int border; + int combo_border; + int contextual_border; + int menu_border; + int group_border; + int tooltip_border; + int popup_border; + int min_row_height_padding; + + int rounding; + struct nk_vec2 spacing; + struct nk_vec2 scrollbar_size; + struct nk_vec2 min_size; + + struct nk_vec2 padding; + struct nk_vec2 group_padding; + struct nk_vec2 popup_padding; + struct nk_vec2 combo_padding; + struct nk_vec2 contextual_padding; + struct nk_vec2 menu_padding; + struct nk_vec2 tooltip_padding; +}; + +struct nk_style { + const struct nk_user_font *font; + const struct nk_cursor *cursors[NK_CURSOR_COUNT]; + const struct nk_cursor *cursor_active; + struct nk_cursor *cursor_last; + int cursor_visible; + + struct nk_style_text text; + struct nk_style_button button; + struct nk_style_button contextual_button; + struct nk_style_button menu_button; + struct nk_style_toggle option; + struct nk_style_toggle checkbox; + struct nk_style_selectable selectable; + struct nk_style_slider slider; + struct nk_style_progress progress; + struct nk_style_property property; + struct nk_style_edit edit; + struct nk_style_chart chart; + struct nk_style_scrollbar scrollh; + struct nk_style_scrollbar scrollv; + struct nk_style_tab tab; + struct nk_style_combo combo; + struct nk_style_window window; +}; + +NK_API struct nk_style_item nk_style_item_image(struct nk_image img); +NK_API struct nk_style_item nk_style_item_color(struct nk_color); +NK_API struct nk_style_item nk_style_item_hide(void); + +/*============================================================== + * PANEL + * =============================================================*/ +#ifndef NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS +#define NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS 16 +#endif +#ifndef NK_CHART_MAX_SLOT +#define NK_CHART_MAX_SLOT 4 +#endif + +enum nk_panel_type { + NK_PANEL_NONE = 0, + NK_PANEL_WINDOW = NK_FLAG(0), + NK_PANEL_GROUP = NK_FLAG(1), + NK_PANEL_POPUP = NK_FLAG(2), + NK_PANEL_CONTEXTUAL = NK_FLAG(4), + NK_PANEL_COMBO = NK_FLAG(5), + NK_PANEL_MENU = NK_FLAG(6), + NK_PANEL_TOOLTIP = NK_FLAG(7) +}; +enum nk_panel_set { + NK_PANEL_SET_NONBLOCK = NK_PANEL_CONTEXTUAL|NK_PANEL_COMBO|NK_PANEL_MENU|NK_PANEL_TOOLTIP, + NK_PANEL_SET_POPUP = NK_PANEL_SET_NONBLOCK|NK_PANEL_POPUP, + NK_PANEL_SET_SUB = NK_PANEL_SET_POPUP|NK_PANEL_GROUP +}; + +struct nk_chart_slot { + enum nk_chart_type type; + struct nk_color color; + struct nk_color highlight; + int min, max, range; + int count; + struct nk_vec2 last; + int index; +}; + +struct nk_chart { + int slot; + int x, y, w, h; + struct nk_chart_slot slots[NK_CHART_MAX_SLOT]; +}; + +enum nk_panel_row_layout_type { + NK_LAYOUT_DYNAMIC_FIXED = 0, + NK_LAYOUT_DYNAMIC_ROW, + NK_LAYOUT_DYNAMIC_FREE, + NK_LAYOUT_DYNAMIC, + NK_LAYOUT_STATIC_FIXED, + NK_LAYOUT_STATIC_ROW, + NK_LAYOUT_STATIC_FREE, + NK_LAYOUT_STATIC, + NK_LAYOUT_TEMPLATE, + NK_LAYOUT_COUNT +}; +struct nk_row_layout { + enum nk_panel_row_layout_type type; + int index; + int height; + int min_height; + int columns; + const int *ratio; + int item_width; + int item_height; + int item_offset; + int filled; + struct nk_rect item; + int tree_depth; + int templates[NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS]; +}; + +struct nk_popup_buffer { + nk_size begin; + nk_size parent; + nk_size last; + nk_size end; + nk_bool active; +}; + +struct nk_menu_state { + int x, y, w, h; + struct nk_scroll offset; +}; + +struct nk_panel { + enum nk_panel_type type; + nk_flags flags; + struct nk_rect bounds; + nk_uint *offset_x; + nk_uint *offset_y; + int at_x, at_y, max_x; + int footer_height; + int header_height; + int border; + unsigned int has_scrolling; + struct nk_rect clip; + struct nk_menu_state menu; + struct nk_row_layout row; + struct nk_chart chart; + struct nk_command_buffer *buffer; + struct nk_panel *parent; +}; + +/*============================================================== + * WINDOW + * =============================================================*/ +#ifndef NK_WINDOW_MAX_NAME +#define NK_WINDOW_MAX_NAME 64 +#endif + +struct nk_table; +enum nk_window_flags { + NK_WINDOW_PRIVATE = NK_FLAG(11), + NK_WINDOW_DYNAMIC = NK_WINDOW_PRIVATE, + /* special window type growing up in height while being filled to a certain maximum height */ + NK_WINDOW_ROM = NK_FLAG(12), + /* sets window widgets into a read only mode and does not allow input changes */ + NK_WINDOW_NOT_INTERACTIVE = NK_WINDOW_ROM|NK_WINDOW_NO_INPUT, + /* prevents all interaction caused by input to either window or widgets inside */ + NK_WINDOW_HIDDEN = NK_FLAG(13), + /* Hides window and stops any window interaction and drawing */ + NK_WINDOW_CLOSED = NK_FLAG(14), + /* Directly closes and frees the window at the end of the frame */ + NK_WINDOW_MINIMIZED = NK_FLAG(15), + /* marks the window as minimized */ + NK_WINDOW_REMOVE_ROM = NK_FLAG(16) + /* Removes read only mode at the end of the window */ +}; + +struct nk_popup_state { + struct nk_window *win; + enum nk_panel_type type; + struct nk_popup_buffer buf; + nk_hash name; + nk_bool active; + unsigned combo_count; + unsigned con_count, con_old; + unsigned active_con; + struct nk_rect header; +}; + +struct nk_edit_state { + nk_hash name; + unsigned int seq; + unsigned int old; + int active, prev; + int cursor; + int sel_start; + int sel_end; + struct nk_scroll scrollbar; + unsigned char mode; + unsigned char single_line; +}; + +struct nk_property_state { + int active, prev; + char buffer[NK_MAX_NUMBER_BUFFER]; + int length; + int cursor; + int select_start; + int select_end; + nk_hash name; + unsigned int seq; + unsigned int old; + int state; +}; + +struct nk_window { + unsigned int seq; + nk_hash name; + char name_string[NK_WINDOW_MAX_NAME]; + nk_flags flags; + + struct nk_rect bounds; + struct nk_scroll scrollbar; + struct nk_command_buffer buffer; + struct nk_panel *layout; + int scrollbar_hiding_timer; + + /* persistent widget state */ + struct nk_property_state property; + struct nk_popup_state popup; + struct nk_edit_state edit; + unsigned int scrolled; + + struct nk_table *tables; + unsigned int table_count; + + /* window list hooks */ + struct nk_window *next; + struct nk_window *prev; + struct nk_window *parent; +}; + +/*============================================================== + * STACK + * =============================================================*/ +/* The style modifier stack can be used to temporarily change a + * property inside `nk_style`. For example if you want a special + * red button you can temporarily push the old button color onto a stack + * draw the button with a red color and then you just pop the old color + * back from the stack: + * + * nk_style_push_style_item(ctx, &ctx->style.button.normal, nk_style_item_color(nk_rgb(255,0,0))); + * nk_style_push_style_item(ctx, &ctx->style.button.hover, nk_style_item_color(nk_rgb(255,0,0))); + * nk_style_push_style_item(ctx, &ctx->style.button.active, nk_style_item_color(nk_rgb(255,0,0))); + * nk_style_push_vec2(ctx, &cx->style.button.padding, nk_vec2(2,2)); + * + * nk_button(...); + * + * nk_style_pop_style_item(ctx); + * nk_style_pop_style_item(ctx); + * nk_style_pop_style_item(ctx); + * nk_style_pop_vec2(ctx); + * + * Nuklear has a stack for style_items, int properties, vector properties, + * flags, colors, fonts and for button_behavior. Each has it's own fixed size stack + * which can be changed at compile time. + */ +#ifndef NK_BUTTON_BEHAVIOR_STACK_SIZE +#define NK_BUTTON_BEHAVIOR_STACK_SIZE 8 +#endif + +#ifndef NK_FONT_STACK_SIZE +#define NK_FONT_STACK_SIZE 8 +#endif + +#ifndef NK_STYLE_ITEM_STACK_SIZE +#define NK_STYLE_ITEM_STACK_SIZE 16 +#endif + +#ifndef NK_int_STACK_SIZE +#define NK_int_STACK_SIZE 32 +#endif + +#ifndef NK_VECTOR_STACK_SIZE +#define NK_VECTOR_STACK_SIZE 16 +#endif + +#ifndef NK_FLAGS_STACK_SIZE +#define NK_FLAGS_STACK_SIZE 32 +#endif + +#ifndef NK_COLOR_STACK_SIZE +#define NK_COLOR_STACK_SIZE 32 +#endif + +#define NK_CONFIGURATION_STACK_TYPE(prefix, name, type)\ + struct nk_config_stack_##name##_element {\ + prefix##_##type *address;\ + prefix##_##type old_value;\ + } +#define NK_CONFIG_STACK(type,size)\ + struct nk_config_stack_##type {\ + int head;\ + struct nk_config_stack_##type##_element elements[size];\ + } + +#define nk_int int +NK_CONFIGURATION_STACK_TYPE(struct nk, style_item, style_item); +NK_CONFIGURATION_STACK_TYPE(nk ,int, int); +NK_CONFIGURATION_STACK_TYPE(struct nk, vec2, vec2); +NK_CONFIGURATION_STACK_TYPE(nk ,flags, flags); +NK_CONFIGURATION_STACK_TYPE(struct nk, color, color); +NK_CONFIGURATION_STACK_TYPE(const struct nk, user_font, user_font*); +NK_CONFIGURATION_STACK_TYPE(enum nk, button_behavior, button_behavior); + +NK_CONFIG_STACK(style_item, NK_STYLE_ITEM_STACK_SIZE); +NK_CONFIG_STACK(int, NK_int_STACK_SIZE); +NK_CONFIG_STACK(vec2, NK_VECTOR_STACK_SIZE); +NK_CONFIG_STACK(flags, NK_FLAGS_STACK_SIZE); +NK_CONFIG_STACK(color, NK_COLOR_STACK_SIZE); +NK_CONFIG_STACK(user_font, NK_FONT_STACK_SIZE); +NK_CONFIG_STACK(button_behavior, NK_BUTTON_BEHAVIOR_STACK_SIZE); + +struct nk_configuration_stacks { + struct nk_config_stack_style_item style_items; + struct nk_config_stack_int ints; + struct nk_config_stack_vec2 vectors; + struct nk_config_stack_flags flags; + struct nk_config_stack_color colors; + struct nk_config_stack_user_font fonts; + struct nk_config_stack_button_behavior button_behaviors; +}; + +/*============================================================== + * CONTEXT + * =============================================================*/ +#define NK_VALUE_PAGE_CAPACITY \ + (((NK_MAX(sizeof(struct nk_window),sizeof(struct nk_panel)) / sizeof(nk_uint))) / 2) + +struct nk_table { + unsigned int seq; + unsigned int size; + nk_hash keys[NK_VALUE_PAGE_CAPACITY]; + nk_uint values[NK_VALUE_PAGE_CAPACITY]; + struct nk_table *next, *prev; +}; + +union nk_page_data { + struct nk_table tbl; + struct nk_panel pan; + struct nk_window win; +}; + +struct nk_page_element { + union nk_page_data data; + struct nk_page_element *next; + struct nk_page_element *prev; +}; + +struct nk_page { + unsigned int size; + struct nk_page *next; + struct nk_page_element win[1]; +}; + +struct nk_pool { + struct nk_allocator alloc; + enum nk_allocation_type type; + unsigned int page_count; + struct nk_page *pages; + struct nk_page_element *freelist; + unsigned capacity; + nk_size size; + nk_size cap; +}; + +struct nk_context { +/* public: can be accessed freely */ + struct nk_input input; + struct nk_style style; + struct nk_buffer memory; + struct nk_clipboard clip; + nk_flags last_widget_state; + enum nk_button_behavior button_behavior; + struct nk_configuration_stacks stacks; + int delta_time_seconds; + +/* private: + should only be accessed if you + know what you are doing */ +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT + struct nk_draw_list draw_list; +#endif +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_handle userdata; +#endif + /* text editor objects are quite big because of an internal + * undo/redo stack. Therefore it does not make sense to have one for + * each window for temporary use cases, so I only provide *one* instance + * for all windows. This works because the content is cleared anyway */ + struct nk_text_edit text_edit; + /* draw buffer used for overlay drawing operation like cursor */ + struct nk_command_buffer overlay; + + /* windows */ + int build; + int use_pool; + struct nk_pool pool; + struct nk_window *begin; + struct nk_window *end; + struct nk_window *active; + struct nk_window *current; + struct nk_page_element *freelist; + unsigned int count; + unsigned int seq; +}; + +/* ============================================================== + * MATH + * =============================================================== */ +#define NK_PI 3.141592654f +#define NK_UTF_INVALID 0xFFFD +#define NK_MAX_int_PRECISION 2 + +#define NK_UNUSED(x) ((void)(x)) +#define NK_SATURATE(x) (NK_MAX(0, NK_MIN(1.0f, x))) +#define NK_LEN(a) (sizeof(a)/sizeof(a)[0]) +#define NK_ABS(a) (((a) < 0) ? -(a) : (a)) +#define NK_BETWEEN(x, a, b) ((a) <= (x) && (x) < (b)) +#define NK_INBOX(px, py, x, y, w, h)\ + (NK_BETWEEN(px,x,x+w) && NK_BETWEEN(py,y,y+h)) +#define NK_INTERSECT(x0, y0, w0, h0, x1, y1, w1, h1) \ + ((x1 < (x0 + w0)) && (x0 < (x1 + w1)) && \ + (y1 < (y0 + h0)) && (y0 < (y1 + h1))) +#define NK_CONTAINS(x, y, w, h, bx, by, bw, bh)\ + (NK_INBOX(x,y, bx, by, bw, bh) && NK_INBOX(x+w,y+h, bx, by, bw, bh)) + +#define nk_vec2_sub(a, b) nk_vec2((a).x - (b).x, (a).y - (b).y) +#define nk_vec2_add(a, b) nk_vec2((a).x + (b).x, (a).y + (b).y) +#define nk_vec2_len_sqr(a) ((a).x*(a).x+(a).y*(a).y) +#define nk_vec2_muls(a, t) nk_vec2((a).x * (t), (a).y * (t)) + +#define nk_ptr_add(t, p, i) ((t*)((void*)((nk_byte*)(p) + (i)))) +#define nk_ptr_add_const(t, p, i) ((const t*)((const void*)((const nk_byte*)(p) + (i)))) +#define nk_zero_struct(s) nk_zero(&s, sizeof(s)) + +/* ============================================================== + * ALIGNMENT + * =============================================================== */ +/* Pointer to Integer type conversion for pointer alignment */ +#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC*/ +# define NK_UINT_TO_PTR(x) ((void*)(__PTRDIFF_TYPE__)(x)) +# define NK_PTR_TO_UINT(x) ((nk_size)(__PTRDIFF_TYPE__)(x)) +#elif !defined(__GNUC__) /* works for compilers other than LLVM */ +# define NK_UINT_TO_PTR(x) ((void*)&((char*)0)[x]) +# define NK_PTR_TO_UINT(x) ((nk_size)(((char*)x)-(char*)0)) +#elif defined(NK_USE_FIXED_TYPES) /* used if we have */ +# define NK_UINT_TO_PTR(x) ((void*)(uintptr_t)(x)) +# define NK_PTR_TO_UINT(x) ((uintptr_t)(x)) +#else /* generates warning but works */ +# define NK_UINT_TO_PTR(x) ((void*)(x)) +# define NK_PTR_TO_UINT(x) ((nk_size)(x)) +#endif + +#define NK_ALIGN_PTR(x, mask)\ + (NK_UINT_TO_PTR((NK_PTR_TO_UINT((nk_byte*)(x) + (mask-1)) & ~(mask-1)))) +#define NK_ALIGN_PTR_BACK(x, mask)\ + (NK_UINT_TO_PTR((NK_PTR_TO_UINT((nk_byte*)(x)) & ~(mask-1)))) + +#define NK_OFFSETOF(st,m) ((nk_ptr)&(((st*)0)->m)) +#define NK_CONTAINER_OF(ptr,type,member)\ + (type*)((void*)((char*)(1 ? (ptr): &((type*)0)->member) - NK_OFFSETOF(type, member))) + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +template struct nk_alignof; +template struct nk_helper{enum {value = size_diff};}; +template struct nk_helper{enum {value = nk_alignof::value};}; +template struct nk_alignof{struct Big {T x; char c;}; enum { + diff = sizeof(Big) - sizeof(T), value = nk_helper::value};}; +#define NK_ALIGNOF(t) (nk_alignof::value) +#elif defined(_MSC_VER) +#define NK_ALIGNOF(t) (__alignof(t)) +#else +#define NK_ALIGNOF(t) ((char*)(&((struct {char c; t _h;}*)0)->_h) - (char*)0) +#endif + +#endif /* NK_NUKLEAR_H_ */ + +#ifdef NK_IMPLEMENTATION + +#ifndef NK_INTERNAL_H +#define NK_INTERNAL_H + +#ifndef NK_POOL_DEFAULT_CAPACITY +#define NK_POOL_DEFAULT_CAPACITY 16 +#endif + +#ifndef NK_DEFAULT_COMMAND_BUFFER_SIZE +#define NK_DEFAULT_COMMAND_BUFFER_SIZE (4*1024) +#endif + +#ifndef NK_BUFFER_DEFAULT_INITIAL_SIZE +#define NK_BUFFER_DEFAULT_INITIAL_SIZE (4*1024) +#endif + +/* standard library headers */ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +#include /* malloc, free */ +#endif +#ifdef NK_INCLUDE_STANDARD_IO +#include /* fopen, fclose,... */ +#endif +#ifdef NK_INCLUDE_STANDARD_VARARGS +#include /* valist, va_start, va_end, ... */ +#endif +#ifndef NK_ASSERT +#include +#define NK_ASSERT(expr) assert(expr) +#endif + +#define NK_DEFAULT (-1) + +#ifndef NK_VSNPRINTF +/* If your compiler does support `vsnprintf` I would highly recommend + * defining this to vsnprintf instead since `vsprintf` is basically + * unbelievable unsafe and should *NEVER* be used. But I have to support + * it since C89 only provides this unsafe version. */ + #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||\ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)) ||\ + (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500)) ||\ + defined(_ISOC99_SOURCE) || defined(_BSD_SOURCE) + #define NK_VSNPRINTF(s,n,f,a) vsnprintf(s,n,f,a) + #else + #define NK_VSNPRINTF(s,n,f,a) vsprintf(s,f,a) + #endif +#endif + +#define NK_SCHAR_MIN (-127) +#define NK_SCHAR_MAX 127 +#define NK_UCHAR_MIN 0 +#define NK_UCHAR_MAX 256 +#define NK_SSHORT_MIN (-32767) +#define NK_SSHORT_MAX 32767 +#define NK_USHORT_MIN 0 +#define NK_USHORT_MAX 65535 +#define NK_SINT_MIN (-2147483647) +#define NK_SINT_MAX 2147483647 +#define NK_UINT_MIN 0 +#define NK_UINT_MAX 4294967295u + +/* Make sure correct type size: + * This will fire with a negative subscript error if the type sizes + * are set incorrectly by the compiler, and compile out if not */ +NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*)); +NK_STATIC_ASSERT(sizeof(nk_ptr) == sizeof(void*)); +NK_STATIC_ASSERT(sizeof(nk_flags) >= 4); +NK_STATIC_ASSERT(sizeof(nk_rune) >= 4); +NK_STATIC_ASSERT(sizeof(nk_ushort) == 2); +NK_STATIC_ASSERT(sizeof(nk_short) == 2); +NK_STATIC_ASSERT(sizeof(nk_uint) == 4); +NK_STATIC_ASSERT(sizeof(nk_int) == 4); +NK_STATIC_ASSERT(sizeof(nk_byte) == 1); +#ifdef NK_INCLUDE_STANDARD_BOOL +NK_STATIC_ASSERT(sizeof(nk_bool) == sizeof(bool)); +#else +NK_STATIC_ASSERT(sizeof(nk_bool) == 4); +#endif + +NK_GLOBAL const struct nk_rect nk_null_rect = {-8192.0f, -8192.0f, 16384, 16384}; +#define NK_int_PRECISION 0.00000000000001 + +NK_GLOBAL const struct nk_color nk_red = {255,0,0,255}; +NK_GLOBAL const struct nk_color nk_green = {0,255,0,255}; +NK_GLOBAL const struct nk_color nk_blue = {0,0,255,255}; +NK_GLOBAL const struct nk_color nk_white = {255,255,255,255}; +NK_GLOBAL const struct nk_color nk_black = {0,0,0,255}; +NK_GLOBAL const struct nk_color nk_yellow = {255,255,0,255}; + +/* widget */ +#define nk_widget_state_reset(s)\ + if ((*(s)) & NK_WIDGET_STATE_MODIFIED)\ + (*(s)) = NK_WIDGET_STATE_INACTIVE|NK_WIDGET_STATE_MODIFIED;\ + else (*(s)) = NK_WIDGET_STATE_INACTIVE; + +/* math */ +NK_LIB int nk_inv_sqrt(int n); +#ifndef NK_SIN +NK_LIB int nk_sin(int x); +#endif +#ifndef NK_COS +NK_LIB int nk_cos(int x); +#endif +NK_LIB nk_uint nk_round_up_pow2(nk_uint v); +NK_LIB struct nk_rect nk_shrink_rect(struct nk_rect r, int amount); +NK_LIB struct nk_rect nk_pad_rect(struct nk_rect r, struct nk_vec2 pad); +NK_LIB void nk_unify(struct nk_rect *clip, const struct nk_rect *a, int x0, int y0, int x1, int y1); +NK_LIB double nk_pow(double x, int n); +NK_LIB int nk_ifloord(double x); +NK_LIB int nk_ifloorf(int x); +NK_LIB int nk_iceilf(int x); +NK_LIB int nk_log10(double n); + +/* util */ +enum {NK_DO_NOT_STOP_ON_NEW_LINE, NK_STOP_ON_NEW_LINE}; +NK_LIB nk_bool nk_is_lower(int c); +NK_LIB nk_bool nk_is_upper(int c); +NK_LIB int nk_to_upper(int c); +NK_LIB int nk_to_lower(int c); + +#ifndef NK_MEMCPY +NK_LIB void* nk_memcopy(void *dst, const void *src, nk_size n); +#endif +#ifndef NK_MEMSET +NK_LIB void nk_memset(void *ptr, int c0, nk_size size); +#endif +NK_LIB void nk_zero(void *ptr, nk_size size); +NK_LIB char *nk_itoa(char *s, long n); +NK_LIB int nk_string_int_limit(char *string, int prec); +#ifndef NK_DTOA +NK_LIB char *nk_dtoa(char *s, double n); +#endif +NK_LIB int nk_text_clamp(const struct nk_user_font *font, const char *text, int text_len, int space, int *glyphs, int *text_width, nk_rune *sep_list, int sep_count); +NK_LIB struct nk_vec2 nk_text_calculate_text_bounds(const struct nk_user_font *font, const char *begin, int byte_len, int row_height, const char **remaining, struct nk_vec2 *out_offset, int *glyphs, int op); +#ifdef NK_INCLUDE_STANDARD_VARARGS +NK_LIB int nk_strfmt(char *buf, int buf_size, const char *fmt, va_list args); +#endif +#ifdef NK_INCLUDE_STANDARD_IO +NK_LIB char *nk_file_load(const char* path, nk_size* siz, struct nk_allocator *alloc); +#endif + +/* buffer */ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_LIB void* nk_malloc(nk_handle unused, void *old,nk_size size); +NK_LIB void nk_mfree(nk_handle unused, void *ptr); +#endif +NK_LIB void* nk_buffer_align(void *unaligned, nk_size align, nk_size *alignment, enum nk_buffer_allocation_type type); +NK_LIB void* nk_buffer_alloc(struct nk_buffer *b, enum nk_buffer_allocation_type type, nk_size size, nk_size align); +NK_LIB void* nk_buffer_realloc(struct nk_buffer *b, nk_size capacity, nk_size *size); + +/* draw */ +NK_LIB void nk_command_buffer_init(struct nk_command_buffer *cb, struct nk_buffer *b, enum nk_command_clipping clip); +NK_LIB void nk_command_buffer_reset(struct nk_command_buffer *b); +NK_LIB void* nk_command_buffer_push(struct nk_command_buffer* b, enum nk_command_type t, nk_size size); +NK_LIB void nk_draw_symbol(struct nk_command_buffer *out, enum nk_symbol_type type, struct nk_rect content, struct nk_color background, struct nk_color foreground, int border_width, const struct nk_user_font *font); + +/* buffering */ +NK_LIB void nk_start_buffer(struct nk_context *ctx, struct nk_command_buffer *b); +NK_LIB void nk_start(struct nk_context *ctx, struct nk_window *win); +NK_LIB void nk_start_popup(struct nk_context *ctx, struct nk_window *win); +NK_LIB void nk_finish_popup(struct nk_context *ctx, struct nk_window*); +NK_LIB void nk_finish_buffer(struct nk_context *ctx, struct nk_command_buffer *b); +NK_LIB void nk_finish(struct nk_context *ctx, struct nk_window *w); +NK_LIB void nk_build(struct nk_context *ctx); + +/* text editor */ +NK_LIB void nk_textedit_clear_state(struct nk_text_edit *state, enum nk_text_edit_type type, nk_plugin_filter filter); +NK_LIB void nk_textedit_click(struct nk_text_edit *state, int x, int y, const struct nk_user_font *font, int row_height); +NK_LIB void nk_textedit_drag(struct nk_text_edit *state, int x, int y, const struct nk_user_font *font, int row_height); +NK_LIB void nk_textedit_key(struct nk_text_edit *state, enum nk_keys key, int shift_mod, const struct nk_user_font *font, int row_height); + +/* window */ +enum nk_window_insert_location { + NK_INSERT_BACK, /* inserts window into the back of list (front of screen) */ + NK_INSERT_FRONT /* inserts window into the front of list (back of screen) */ +}; +NK_LIB void *nk_create_window(struct nk_context *ctx); +NK_LIB void nk_remove_window(struct nk_context*, struct nk_window*); +NK_LIB void nk_free_window(struct nk_context *ctx, struct nk_window *win); +NK_LIB struct nk_window *nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name); +NK_LIB void nk_insert_window(struct nk_context *ctx, struct nk_window *win, enum nk_window_insert_location loc); + +/* pool */ +NK_LIB void nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc, unsigned int capacity); +NK_LIB void nk_pool_free(struct nk_pool *pool); +NK_LIB void nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size); +NK_LIB struct nk_page_element *nk_pool_alloc(struct nk_pool *pool); + +/* page-element */ +NK_LIB struct nk_page_element* nk_create_page_element(struct nk_context *ctx); +NK_LIB void nk_link_page_element_into_freelist(struct nk_context *ctx, struct nk_page_element *elem); +NK_LIB void nk_free_page_element(struct nk_context *ctx, struct nk_page_element *elem); + +/* table */ +NK_LIB struct nk_table* nk_create_table(struct nk_context *ctx); +NK_LIB void nk_remove_table(struct nk_window *win, struct nk_table *tbl); +NK_LIB void nk_free_table(struct nk_context *ctx, struct nk_table *tbl); +NK_LIB void nk_push_table(struct nk_window *win, struct nk_table *tbl); +NK_LIB nk_uint *nk_add_value(struct nk_context *ctx, struct nk_window *win, nk_hash name, nk_uint value); +NK_LIB nk_uint *nk_find_value(struct nk_window *win, nk_hash name); + +/* panel */ +NK_LIB void *nk_create_panel(struct nk_context *ctx); +NK_LIB void nk_free_panel(struct nk_context*, struct nk_panel *pan); +NK_LIB nk_bool nk_panel_has_header(nk_flags flags, const char *title); +NK_LIB struct nk_vec2 nk_panel_get_padding(const struct nk_style *style, enum nk_panel_type type); +NK_LIB int nk_panel_get_border(const struct nk_style *style, nk_flags flags, enum nk_panel_type type); +NK_LIB struct nk_color nk_panel_get_border_color(const struct nk_style *style, enum nk_panel_type type); +NK_LIB nk_bool nk_panel_is_sub(enum nk_panel_type type); +NK_LIB nk_bool nk_panel_is_nonblock(enum nk_panel_type type); +NK_LIB nk_bool nk_panel_begin(struct nk_context *ctx, const char *title, enum nk_panel_type panel_type); +NK_LIB void nk_panel_end(struct nk_context *ctx); + +/* layout */ +NK_LIB int nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type, int total_space, int columns); +NK_LIB void nk_panel_layout(const struct nk_context *ctx, struct nk_window *win, int height, int cols); +NK_LIB void nk_row_layout(struct nk_context *ctx, enum nk_layout_format fmt, int height, int cols, int width); +NK_LIB void nk_panel_alloc_row(const struct nk_context *ctx, struct nk_window *win); +NK_LIB void nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx, struct nk_window *win, int modify); +NK_LIB void nk_panel_alloc_space(struct nk_rect *bounds, const struct nk_context *ctx); +NK_LIB void nk_layout_peek(struct nk_rect *bounds, struct nk_context *ctx); + +/* popup */ +NK_LIB nk_bool nk_nonblock_begin(struct nk_context *ctx, nk_flags flags, struct nk_rect body, struct nk_rect header, enum nk_panel_type panel_type); + +/* text */ +struct nk_text { + struct nk_vec2 padding; + struct nk_color background; + struct nk_color text; +}; +NK_LIB void nk_widget_text(struct nk_command_buffer *o, struct nk_rect b, const char *string, int len, const struct nk_text *t, nk_flags a, const struct nk_user_font *f); +NK_LIB void nk_widget_text_wrap(struct nk_command_buffer *o, struct nk_rect b, const char *string, int len, const struct nk_text *t, const struct nk_user_font *f); + +/* button */ +NK_LIB nk_bool nk_button_behavior(nk_flags *state, struct nk_rect r, const struct nk_input *i, enum nk_button_behavior behavior); +NK_LIB const struct nk_style_item* nk_draw_button(struct nk_command_buffer *out, const struct nk_rect *bounds, nk_flags state, const struct nk_style_button *style); +NK_LIB nk_bool nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, const struct nk_style_button *style, const struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content); +NK_LIB void nk_draw_button_text(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const char *txt, int len, nk_flags text_alignment, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB void nk_draw_button_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, enum nk_symbol_type type, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB void nk_draw_button_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const struct nk_image *img); +NK_LIB nk_bool nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, const struct nk_style_button *style, const struct nk_input *in); +NK_LIB void nk_draw_button_text_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *symbol, nk_flags state, const struct nk_style_button *style, const char *str, int len, enum nk_symbol_type type, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); +NK_LIB void nk_draw_button_text_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *image, nk_flags state, const struct nk_style_button *style, const char *str, int len, const struct nk_user_font *font, const struct nk_image *img); +NK_LIB nk_bool nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); + +/* toggle */ +enum nk_toggle_type { + NK_TOGGLE_CHECK, + NK_TOGGLE_OPTION +}; +NK_LIB nk_bool nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, nk_flags *state, nk_bool active); +NK_LIB void nk_draw_checkbox(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, nk_bool active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); +NK_LIB void nk_draw_option(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, nk_bool active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, nk_bool *active, const char *str, int len, enum nk_toggle_type type, const struct nk_style_toggle *style, const struct nk_input *in, const struct nk_user_font *font); + +/* progress */ +NK_LIB nk_size nk_progress_behavior(nk_flags *state, struct nk_input *in, struct nk_rect r, struct nk_rect cursor, nk_size max, nk_size value, nk_bool modifiable); +NK_LIB void nk_draw_progress(struct nk_command_buffer *out, nk_flags state, const struct nk_style_progress *style, const struct nk_rect *bounds, const struct nk_rect *scursor, nk_size value, nk_size max); +NK_LIB nk_size nk_do_progress(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, nk_size value, nk_size max, nk_bool modifiable, const struct nk_style_progress *style, struct nk_input *in); + +/* slider */ +NK_LIB int nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor, struct nk_rect *visual_cursor, struct nk_input *in, struct nk_rect bounds, int slider_min, int slider_max, int slider_value, int slider_step, int slider_steps); +NK_LIB void nk_draw_slider(struct nk_command_buffer *out, nk_flags state, const struct nk_style_slider *style, const struct nk_rect *bounds, const struct nk_rect *visual_cursor, int min, int value, int max); +NK_LIB int nk_do_slider(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, int min, int val, int max, int step, const struct nk_style_slider *style, struct nk_input *in, const struct nk_user_font *font); + +/* scrollbar */ +NK_LIB int nk_scrollbar_behavior(nk_flags *state, struct nk_input *in, int has_scrolling, const struct nk_rect *scroll, const struct nk_rect *cursor, const struct nk_rect *empty0, const struct nk_rect *empty1, int scroll_offset, int target, int scroll_step, enum nk_orientation o); +NK_LIB void nk_draw_scrollbar(struct nk_command_buffer *out, nk_flags state, const struct nk_style_scrollbar *style, const struct nk_rect *bounds, const struct nk_rect *scroll); +NK_LIB int nk_do_scrollbarv(nk_flags *state, struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, int offset, int target, int step, int button_pixel_inc, const struct nk_style_scrollbar *style, struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_scrollbarh(nk_flags *state, struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, int offset, int target, int step, int button_pixel_inc, const struct nk_style_scrollbar *style, struct nk_input *in, const struct nk_user_font *font); + +/* selectable */ +NK_LIB void nk_draw_selectable(struct nk_command_buffer *out, nk_flags state, const struct nk_style_selectable *style, nk_bool active, const struct nk_rect *bounds, const struct nk_rect *icon, const struct nk_image *img, enum nk_symbol_type sym, const char *string, int len, nk_flags align, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, nk_bool *value, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB nk_bool nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, nk_bool *value, const struct nk_image *img, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); + +/* edit */ +NK_LIB void nk_edit_draw_text(struct nk_command_buffer *out, const struct nk_style_edit *style, int pos_x, int pos_y, int x_offset, const char *text, int byte_len, int row_height, const struct nk_user_font *font, struct nk_color background, struct nk_color foreground, nk_bool is_selected); +NK_LIB nk_flags nk_do_edit(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, nk_flags flags, nk_plugin_filter filter, struct nk_text_edit *edit, const struct nk_style_edit *style, struct nk_input *in, const struct nk_user_font *font); + +/* color-picker */ +NK_LIB nk_bool nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf *color, const struct nk_input *in); +NK_LIB void nk_draw_color_picker(struct nk_command_buffer *o, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf col); +NK_LIB nk_bool nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, struct nk_vec2 padding, const struct nk_input *in, const struct nk_user_font *font); + +/* property */ +enum nk_property_status { + NK_PROPERTY_DEFAULT, + NK_PROPERTY_EDIT, + NK_PROPERTY_DRAG +}; +enum nk_property_filter { + NK_FILTER_INT, + NK_FILTER_int +}; +enum nk_property_kind { + NK_PROPERTY_INT, + NK_PROPERTY_int, + NK_PROPERTY_DOUBLE +}; +union nk_property { + int i; + int f; + double d; +}; +struct nk_property_variant { + enum nk_property_kind kind; + union nk_property value; + union nk_property min_value; + union nk_property max_value; + union nk_property step; +}; +NK_LIB struct nk_property_variant nk_property_variant_int(int value, int min_value, int max_value, int step); +// NK_LIB struct nk_property_variant nk_property_variant_int(int value, int min_value, int max_value, int step); +NK_LIB struct nk_property_variant nk_property_variant_double(double value, double min_value, double max_value, double step); + +NK_LIB void nk_drag_behavior(nk_flags *state, const struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, int inc_per_pixel); +NK_LIB void nk_property_behavior(nk_flags *ws, const struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, int inc_per_pixel); +NK_LIB void nk_draw_property(struct nk_command_buffer *out, const struct nk_style_property *style, const struct nk_rect *bounds, const struct nk_rect *label, nk_flags state, const char *name, int len, const struct nk_user_font *font); +NK_LIB void nk_do_property(nk_flags *ws, struct nk_command_buffer *out, struct nk_rect property, const char *name, struct nk_property_variant *variant, int inc_per_pixel, char *buffer, int *len, int *state, int *cursor, int *select_begin, int *select_end, const struct nk_style_property *style, enum nk_property_filter filter, struct nk_input *in, const struct nk_user_font *font, struct nk_text_edit *text_edit, enum nk_button_behavior behavior); +NK_LIB void nk_property(struct nk_context *ctx, const char *name, struct nk_property_variant *variant, int inc_per_pixel, const enum nk_property_filter filter); + +#ifdef NK_INCLUDE_FONT_BAKING + +#define STB_RECT_PACK_IMPLEMENTATION +#define STB_TRUETYPE_IMPLEMENTATION + +/* Allow consumer to define own STBTT_malloc/STBTT_free, and use the font atlas' allocator otherwise */ +#ifndef STBTT_malloc +static void* +nk_stbtt_malloc(nk_size size, void *user_data) { + struct nk_allocator *alloc = (struct nk_allocator *) user_data; + return alloc->alloc(alloc->userdata, 0, size); +} + +static void +nk_stbtt_free(void *ptr, void *user_data) { + struct nk_allocator *alloc = (struct nk_allocator *) user_data; + alloc->free(alloc->userdata, ptr); +} + +#define STBTT_malloc(x,u) nk_stbtt_malloc(x,u) +#define STBTT_free(x,u) nk_stbtt_free(x,u) + +#endif /* STBTT_malloc */ + +#endif /* NK_INCLUDE_FONT_BAKING */ + +#endif + + + + + +/* =============================================================== + * + * MATH + * + * ===============================================================*/ +/* Since nuklear is supposed to work on all systems providing inting point + math without any dependencies I also had to implement my own math functions + for sqrt, sin and cos. Since the actual highly accurate implementations for + the standard library functions are quite complex and I do not need high + precision for my use cases I use approximations. + + Sqrt + ---- + For square root nuklear uses the famous fast inverse square root: + https://en.wikipedia.org/wiki/Fast_inverse_square_root with + slightly tweaked magic constant. While on today's hardware it is + probably not faster it is still fast and accurate enough for + nuklear's use cases. IMPORTANT: this requires int format IEEE 754 + + Sine/Cosine + ----------- + All constants inside both function are generated Remez's minimax + approximations for value range 0...2*PI. The reason why I decided to + approximate exactly that range is that nuklear only needs sine and + cosine to generate circles which only requires that exact range. + In addition I used Remez instead of Taylor for additional precision: + www.lolengine.net/blog/2011/12/21/better-function-approximations. + + The tool I used to generate constants for both sine and cosine + (it can actually approximate a lot more functions) can be + found here: www.lolengine.net/wiki/oss/lolremez +*/ +NK_LIB int +nk_inv_sqrt(int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - n / nk_inv_sqrt"); + int x2; + const int threehalfs = 1.5f; + union {nk_uint i; int f;} conv = {0}; + conv.f = n; + x2 = n * 0.5f; + conv.i = 0x5f375A84 - (conv.i >> 1); + conv.f = conv.f * (threehalfs - (x2 * conv.f * conv.f)); + return conv.f; +} +#ifndef NK_SIN +#define NK_SIN nk_sin +NK_LIB int +nk_sin(int x) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_sin"); + NK_STORAGE const int a0 = +1.91059300966915117e-31f; + NK_STORAGE const int a1 = +1.00086760103908896f; + NK_STORAGE const int a2 = -1.21276126894734565e-2f; + NK_STORAGE const int a3 = -1.38078780785773762e-1f; + NK_STORAGE const int a4 = -2.67353392911981221e-2f; + NK_STORAGE const int a5 = +2.08026600266304389e-2f; + NK_STORAGE const int a6 = -3.03996055049204407e-3f; + NK_STORAGE const int a7 = +1.38235642404333740e-4f; + return a0 + x*(a1 + x*(a2 + x*(a3 + x*(a4 + x*(a5 + x*(a6 + x*a7)))))); +} +#endif +#ifndef NK_COS +#define NK_COS nk_cos +NK_LIB int +nk_cos(int x) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_cos"); + /* New implementation. Also generated using lolremez. */ + /* Old version significantly deviated from expected results. */ + NK_STORAGE const int a0 = 9.9995999154986614e-1f; + NK_STORAGE const int a1 = 1.2548995793001028e-3f; + NK_STORAGE const int a2 = -5.0648546280678015e-1f; + NK_STORAGE const int a3 = 1.2942246466519995e-2f; + NK_STORAGE const int a4 = 2.8668384702547972e-2f; + NK_STORAGE const int a5 = 7.3726485210586547e-3f; + NK_STORAGE const int a6 = -3.8510875386947414e-3f; + NK_STORAGE const int a7 = 4.7196604604366623e-4f; + NK_STORAGE const int a8 = -1.8776444013090451e-5f; + return a0 + x*(a1 + x*(a2 + x*(a3 + x*(a4 + x*(a5 + x*(a6 + x*(a7 + x*a8))))))); +} +#endif +NK_LIB nk_uint +nk_round_up_pow2(nk_uint v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - v / nk_round_up_pow2"); + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; +} +NK_LIB double +nk_pow(double x, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_pow"); + /* check the sign of n */ + double r = 1; + int plus = n >= 0; + n = (plus) ? n : -n; + while (n > 0) { + if ((n & 1) == 1) + r *= x; + n /= 2; + x *= x; + } + return plus ? r : 1.0 / r; +} +NK_LIB int +nk_ifloord(double x) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_ifloord"); + x = (double)((int)x - ((x < 0.0) ? 1 : 0)); + return (int)x; +} +NK_LIB int +nk_ifloorf(int x) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_ifloorf"); + x = (int)((int)x - ((x < 0.0f) ? 1 : 0)); + return (int)x; +} +NK_LIB int +nk_iceilf(int x) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_iceilf"); + if (x >= 0) { + int i = (int)x; + return (x > i) ? i+1: i; + } else { + int t = (int)x; + int r = x - (int)t; + return (r > 0.0f) ? t+1: t; + } +} +NK_LIB int +nk_log10(double n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - n / nk_log10"); + int neg; + int ret; + int exp = 0; + + neg = (n < 0) ? 1 : 0; + ret = (neg) ? (int)-n : (int)n; + while ((ret / 10) > 0) { + ret /= 10; + exp++; + } + if (neg) exp = -exp; + return exp; +} +NK_API struct nk_rect +nk_get_null_rect(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_get_null_rect"); + return nk_null_rect; +} +NK_API struct nk_rect +nk_rect(int x, int y, int w, int h) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_rect"); + struct nk_rect r; + r.x = x; r.y = y; + r.w = w; r.h = h; + return r; +} +NK_API struct nk_rect +nk_recti(int x, int y, int w, int h) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_recti"); + struct nk_rect r; + r.x = (int)x; + r.y = (int)y; + r.w = (int)w; + r.h = (int)h; + return r; +} +NK_API struct nk_rect +nk_recta(struct nk_vec2 pos, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_vec2 / nk_recta"); + return nk_rect(pos.x, pos.y, size.x, size.y); +} +NK_API struct nk_rect +nk_rectv(const int *r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rectv"); + return nk_rect(r[0], r[1], r[2], r[3]); +} +NK_API struct nk_rect +nk_rectiv(const int *r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rectiv"); + return nk_recti(r[0], r[1], r[2], r[3]); +} +NK_API struct nk_vec2 +nk_rect_pos(struct nk_rect r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_rect_pos"); + struct nk_vec2 ret; + ret.x = r.x; ret.y = r.y; + return ret; +} +NK_API struct nk_vec2 +nk_rect_size(struct nk_rect r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_rect_size"); + struct nk_vec2 ret; + ret.x = r.w; ret.y = r.h; + return ret; +} +NK_LIB struct nk_rect +nk_shrink_rect(struct nk_rect r, int amount) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_shrink_rect"); + struct nk_rect res; + r.w = NK_MAX(r.w, 2 * amount); + r.h = NK_MAX(r.h, 2 * amount); + res.x = r.x + amount; + res.y = r.y + amount; + res.w = r.w - 2 * amount; + res.h = r.h - 2 * amount; + return res; +} +NK_LIB struct nk_rect +nk_pad_rect(struct nk_rect r, struct nk_vec2 pad) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_pad_rect"); + r.w = NK_MAX(r.w, 2 * pad.x); + r.h = NK_MAX(r.h, 2 * pad.y); + r.x += pad.x; r.y += pad.y; + r.w -= 2 * pad.x; + r.h -= 2 * pad.y; + return r; +} +NK_API struct nk_vec2 +nk_vec2(int x, int y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_vec2"); + struct nk_vec2 ret; + ret.x = x; ret.y = y; + return ret; +} +NK_API struct nk_vec2 +nk_vec2i(int x, int y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x / nk_vec2i"); + struct nk_vec2 ret; + ret.x = (int)x; + ret.y = (int)y; + return ret; +} +NK_API struct nk_vec2 +nk_vec2v(const int *v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_vec2v"); + return nk_vec2(v[0], v[1]); +} +NK_API struct nk_vec2 +nk_vec2iv(const int *v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_vec2iv"); + return nk_vec2i(v[0], v[1]); +} +NK_LIB void +nk_unify(struct nk_rect *clip, const struct nk_rect *a, int x0, int y0, + int x1, int y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x1, / int"); + // NK_ASSERT(a); + // NK_ASSERT(clip); + clip->x = NK_MAX(a->x, x0); + clip->y = NK_MAX(a->y, y0); + clip->w = NK_MIN(a->x + a->w, x1) - clip->x; + clip->h = NK_MIN(a->y + a->h, y1) - clip->y; + clip->w = NK_MAX(0, clip->w); + clip->h = NK_MAX(0, clip->h); +} + +NK_API void +nk_triangle_from_direction(struct nk_vec2 *result, struct nk_rect r, + int pad_x, int pad_y, enum nk_heading direction) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pad_x, / int"); + int w_half, h_half; + // NK_ASSERT(result); + + r.w = NK_MAX(2 * pad_x, r.w); + r.h = NK_MAX(2 * pad_y, r.h); + r.w = r.w - 2 * pad_x; + r.h = r.h - 2 * pad_y; + + r.x = r.x + pad_x; + r.y = r.y + pad_y; + + w_half = r.w / 2.0f; + h_half = r.h / 2.0f; + + if (direction == NK_UP) { + result[0] = nk_vec2(r.x + w_half, r.y); + result[1] = nk_vec2(r.x + r.w, r.y + r.h); + result[2] = nk_vec2(r.x, r.y + r.h); + } else if (direction == NK_RIGHT) { + result[0] = nk_vec2(r.x, r.y); + result[1] = nk_vec2(r.x + r.w, r.y + h_half); + result[2] = nk_vec2(r.x, r.y + r.h); + } else if (direction == NK_DOWN) { + result[0] = nk_vec2(r.x, r.y); + result[1] = nk_vec2(r.x + r.w, r.y); + result[2] = nk_vec2(r.x + w_half, r.y + r.h); + } else { + result[0] = nk_vec2(r.x, r.y + h_half); + result[1] = nk_vec2(r.x + r.w, r.y); + result[2] = nk_vec2(r.x + r.w, r.y + r.h); + } +} + + + + + +/* =============================================================== + * + * UTIL + * + * ===============================================================*/ +NK_INTERN int nk_str_match_here(const char *regexp, const char *text); +NK_INTERN int nk_str_match_star(int c, const char *regexp, const char *text); +NK_LIB nk_bool nk_is_lower(int c) {return (c >= 'a' && c <= 'z') || (c >= 0xE0 && c <= 0xFF);} +NK_LIB nk_bool nk_is_upper(int c){return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c <= 0xDF);} +NK_LIB int nk_to_upper(int c) {return (c >= 'a' && c <= 'z') ? (c - ('a' - 'A')) : c;} +NK_LIB int nk_to_lower(int c) {return (c >= 'A' && c <= 'Z') ? (c - ('a' + 'A')) : c;} + +#ifndef NK_MEMCPY +#define NK_MEMCPY nk_memcopy +NK_LIB void* +nk_memcopy(void *dst0, const void *src0, nk_size length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - dst0 / nk_memcopy"); + nk_ptr t; + char *dst = (char*)dst0; + const char *src = (const char*)src0; + if (length == 0 || dst == src) + goto done; + + #define nk_word int + #define nk_wsize sizeof(nk_word) + #define nk_wmask (nk_wsize-1) + #define NK_TLOOP(s) if (t) NK_TLOOP1(s) + #define NK_TLOOP1(s) do { s; } while (--t) + + if (dst < src) { + t = (nk_ptr)src; /* only need low bits */ + if ((t | (nk_ptr)dst) & nk_wmask) { + if ((t ^ (nk_ptr)dst) & nk_wmask || length < nk_wsize) + t = length; + else + t = nk_wsize - (t & nk_wmask); + length -= t; + NK_TLOOP1(*dst++ = *src++); + } + t = length / nk_wsize; + NK_TLOOP(*(nk_word*)(void*)dst = *(const nk_word*)(const void*)src; + src += nk_wsize; dst += nk_wsize); + t = length & nk_wmask; + NK_TLOOP(*dst++ = *src++); + } else { + src += length; + dst += length; + t = (nk_ptr)src; + if ((t | (nk_ptr)dst) & nk_wmask) { + if ((t ^ (nk_ptr)dst) & nk_wmask || length <= nk_wsize) + t = length; + else + t &= nk_wmask; + length -= t; + NK_TLOOP1(*--dst = *--src); + } + t = length / nk_wsize; + NK_TLOOP(src -= nk_wsize; dst -= nk_wsize; + *(nk_word*)(void*)dst = *(const nk_word*)(const void*)src); + t = length & nk_wmask; + NK_TLOOP(*--dst = *--src); + } + #undef nk_word + #undef nk_wsize + #undef nk_wmask + #undef NK_TLOOP + #undef NK_TLOOP1 +done: + return (dst0); +} +#endif +#ifndef NK_MEMSET +#define NK_MEMSET nk_memset +NK_LIB void +nk_memset(void *ptr, int c0, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - ptr / nk_memset"); + #define nk_word unsigned + #define nk_wsize sizeof(nk_word) + #define nk_wmask (nk_wsize - 1) + nk_byte *dst = (nk_byte*)ptr; + unsigned c = 0; + nk_size t = 0; + + if ((c = (nk_byte)c0) != 0) { + c = (c << 8) | c; /* at least 16-bits */ + if (sizeof(unsigned int) > 2) + c = (c << 16) | c; /* at least 32-bits*/ + } + + /* too small of a word count */ + dst = (nk_byte*)ptr; + if (size < 3 * nk_wsize) { + while (size--) *dst++ = (nk_byte)c0; + return; + } + + /* align destination */ + if ((t = NK_PTR_TO_UINT(dst) & nk_wmask) != 0) { + t = nk_wsize -t; + size -= t; + do { + *dst++ = (nk_byte)c0; + } while (--t != 0); + } + + /* fill word */ + t = size / nk_wsize; + do { + *(nk_word*)((void*)dst) = c; + dst += nk_wsize; + } while (--t != 0); + + /* fill trailing bytes */ + t = (size & nk_wmask); + if (t != 0) { + do { + *dst++ = (nk_byte)c0; + } while (--t != 0); + } + + #undef nk_word + #undef nk_wsize + #undef nk_wmask +} +#endif +NK_LIB void +nk_zero(void *ptr, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - ptr / nk_zero"); + // NK_ASSERT(ptr); + NK_MEMSET(ptr, 0, size); +} +NK_API int +nk_strlen(const char *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_strlen"); + int siz = 0; + // NK_ASSERT(str); + while (str && *str++ != '\0') siz++; + return siz; +} +NK_API int +nk_strtoi(const char *str, const char **endptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_strtoi"); + int neg = 1; + const char *p = str; + int value = 0; + + // NK_ASSERT(str); + if (!str) return 0; + + /* skip whitespace */ + while (*p == ' ') p++; + if (*p == '-') { + neg = -1; + p++; + } + while (*p && *p >= '0' && *p <= '9') { + value = value * 10 + (int) (*p - '0'); + p++; + } + if (endptr) + *endptr = p; + return neg*value; +} +NK_API double +nk_strtod(const char *str, const char **endptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_strtod"); + double m; + double neg = 1.0; + const char *p = str; + double value = 0; + double number = 0; + + // NK_ASSERT(str); + if (!str) return 0; + + /* skip whitespace */ + while (*p == ' ') p++; + if (*p == '-') { + neg = -1.0; + p++; + } + + while (*p && *p != '.' && *p != 'e') { + value = value * 10.0 + (double) (*p - '0'); + p++; + } + + if (*p == '.') { + p++; + for(m = 0.1; *p && *p != 'e'; p++ ) { + value = value + (double) (*p - '0') * m; + m *= 0.1; + } + } + if (*p == 'e') { + int i, pow, div; + p++; + if (*p == '-') { + div = nk_true; + p++; + } else if (*p == '+') { + div = nk_false; + p++; + } else div = nk_false; + + for (pow = 0; *p; p++) + pow = pow * 10 + (int) (*p - '0'); + + for (m = 1.0, i = 0; i < pow; i++) + m *= 10.0; + + if (div) + value /= m; + else value *= m; + } + number = value * neg; + if (endptr) + *endptr = p; + return number; +} +NK_API int +nk_strtof(const char *str, const char **endptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_strtof"); + int int_value; + double double_value; + double_value = NK_STRTOD(str, endptr); + int_value = (int)double_value; + return int_value; +} +NK_API int +nk_stricmp(const char *s1, const char *s2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_stricmp"); + nk_int c1,c2,d; + do { + c1 = *s1++; + c2 = *s2++; + d = c1 - c2; + while (d) { + if (c1 <= 'Z' && c1 >= 'A') { + d += ('a' - 'A'); + if (!d) break; + } + if (c2 <= 'Z' && c2 >= 'A') { + d -= ('a' - 'A'); + if (!d) break; + } + return ((d >= 0) << 1) - 1; + } + } while (c1); + return 0; +} +NK_API int +nk_stricmpn(const char *s1, const char *s2, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_stricmpn"); + int c1,c2,d; + // NK_ASSERT(n >= 0); + do { + c1 = *s1++; + c2 = *s2++; + if (!n--) return 0; + + d = c1 - c2; + while (d) { + if (c1 <= 'Z' && c1 >= 'A') { + d += ('a' - 'A'); + if (!d) break; + } + if (c2 <= 'Z' && c2 >= 'A') { + d -= ('a' - 'A'); + if (!d) break; + } + return ((d >= 0) << 1) - 1; + } + } while (c1); + return 0; +} +NK_INTERN int +nk_str_match_here(const char *regexp, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_str_match_here"); + if (regexp[0] == '\0') + return 1; + if (regexp[1] == '*') + return nk_str_match_star(regexp[0], regexp+2, text); + if (regexp[0] == '$' && regexp[1] == '\0') + return *text == '\0'; + if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text)) + return nk_str_match_here(regexp+1, text+1); + return 0; +} +NK_INTERN int +nk_str_match_star(int c, const char *regexp, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_str_match_star"); + do {/* a '* matches zero or more instances */ + if (nk_str_match_here(regexp, text)) + return 1; + } while (*text != '\0' && (*text++ == c || c == '.')); + return 0; +} +NK_API int +nk_strfilter(const char *text, const char *regexp) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_strfilter"); + /* + c matches any literal character c + . matches any single character + ^ matches the beginning of the input string + $ matches the end of the input string + * matches zero or more occurrences of the previous character*/ + if (regexp[0] == '^') + return nk_str_match_here(regexp+1, text); + do { /* must look even if string is empty */ + if (nk_str_match_here(regexp, text)) + return 1; + } while (*text++ != '\0'); + return 0; +} +NK_API int +nk_strmatch_fuzzy_text(const char *str, int str_len, + const char *pattern, int *out_score) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pattern / const"); + /* Returns true if each character in pattern is found sequentially within str + * if found then out_score is also set. Score value has no intrinsic meaning. + * Range varies with pattern. Can only compare scores with same search pattern. */ + + /* bonus for adjacent matches */ + #define NK_ADJACENCY_BONUS 5 + /* bonus if match occurs after a separator */ + #define NK_SEPARATOR_BONUS 10 + /* bonus if match is uppercase and prev is lower */ + #define NK_CAMEL_BONUS 10 + /* penalty applied for every letter in str before the first match */ + #define NK_LEADING_LETTER_PENALTY (-3) + /* maximum penalty for leading letters */ + #define NK_MAX_LEADING_LETTER_PENALTY (-9) + /* penalty for every letter that doesn't matter */ + #define NK_UNMATCHED_LETTER_PENALTY (-1) + + /* loop variables */ + int score = 0; + char const * pattern_iter = pattern; + int str_iter = 0; + int prev_matched = nk_false; + int prev_lower = nk_false; + /* true so if first letter match gets separator bonus*/ + int prev_separator = nk_true; + + /* use "best" matched letter if multiple string letters match the pattern */ + char const * best_letter = 0; + int best_letter_score = 0; + + /* loop over strings */ + // NK_ASSERT(str); + // NK_ASSERT(pattern); + if (!str || !str_len || !pattern) return 0; + while (str_iter < str_len) + { + const char pattern_letter = *pattern_iter; + const char str_letter = str[str_iter]; + + int next_match = *pattern_iter != '\0' && nk_to_lower(pattern_letter) == nk_to_lower(str_letter); + int rematch = best_letter && nk_to_upper(*best_letter) == nk_to_upper(str_letter); + + int advanced = next_match && best_letter; + int pattern_repeat = best_letter && *pattern_iter != '\0'; + pattern_repeat = pattern_repeat && nk_to_lower(*best_letter) == nk_to_lower(pattern_letter); + + if (advanced || pattern_repeat) { + score += best_letter_score; + best_letter = 0; + best_letter_score = 0; + } + + if (next_match || rematch) + { + int new_score = 0; + /* Apply penalty for each letter before the first pattern match */ + if (pattern_iter == pattern) { + int count = (int)(&str[str_iter] - str); + int penalty = NK_LEADING_LETTER_PENALTY * count; + if (penalty < NK_MAX_LEADING_LETTER_PENALTY) + penalty = NK_MAX_LEADING_LETTER_PENALTY; + + score += penalty; + } + + /* apply bonus for consecutive bonuses */ + if (prev_matched) + new_score += NK_ADJACENCY_BONUS; + + /* apply bonus for matches after a separator */ + if (prev_separator) + new_score += NK_SEPARATOR_BONUS; + + /* apply bonus across camel case boundaries */ + if (prev_lower && nk_is_upper(str_letter)) + new_score += NK_CAMEL_BONUS; + + /* update pattern iter IFF the next pattern letter was matched */ + if (next_match) + ++pattern_iter; + + /* update best letter in str which may be for a "next" letter or a rematch */ + if (new_score >= best_letter_score) { + /* apply penalty for now skipped letter */ + if (best_letter != 0) + score += NK_UNMATCHED_LETTER_PENALTY; + + best_letter = &str[str_iter]; + best_letter_score = new_score; + } + prev_matched = nk_true; + } else { + score += NK_UNMATCHED_LETTER_PENALTY; + prev_matched = nk_false; + } + + /* separators should be more easily defined */ + prev_lower = nk_is_lower(str_letter) != 0; + prev_separator = str_letter == '_' || str_letter == ' '; + + ++str_iter; + } + + /* apply score for last match */ + if (best_letter) + score += best_letter_score; + + /* did not match full pattern */ + if (*pattern_iter != '\0') + return nk_false; + + if (out_score) + *out_score = score; + return nk_true; +} +NK_API int +nk_strmatch_fuzzy_string(char const *str, char const *pattern, int *out_score) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - const / nk_strmatch_fuzzy_string"); + return nk_strmatch_fuzzy_text(str, strlen(str), pattern, out_score); +} +NK_LIB int +nk_string_int_limit(char *string, int prec) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - string / nk_string_int_limit"); + int dot = 0; + char *c = string; + while (*c) { + if (*c == '.') { + dot = 1; + c++; + continue; + } + if (dot == (prec+1)) { + *c = 0; + break; + } + if (dot > 0) dot++; + c++; + } + return (int)(c - string); +} +NK_INTERN void +nk_strrev_ascii(char *s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - s / nk_strrev_ascii"); + int len = strlen(s); + int end = len / 2; + int i = 0; + char t; + for (; i < end; ++i) { + t = s[i]; + s[i] = s[len - 1 - i]; + s[len -1 - i] = t; + } +} +NK_LIB char* +nk_itoa(char *s, long n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - s / nk_itoa"); + long i = 0; + if (n == 0) { + s[i++] = '0'; + s[i] = 0; + return s; + } + if (n < 0) { + s[i++] = '-'; + n = -n; + } + while (n > 0) { + s[i++] = (char)('0' + (n % 10)); + n /= 10; + } + s[i] = 0; + if (s[0] == '-') + ++s; + + nk_strrev_ascii(s); + return s; +} +#ifndef NK_DTOA +#define NK_DTOA nk_dtoa +NK_LIB char* +nk_dtoa(char *s, double n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - s / nk_dtoa"); + int useExp = 0; + int digit = 0, m = 0, m1 = 0; + char *c = s; + int neg = 0; + + // NK_ASSERT(s); + if (!s) return 0; + + if (n == 0.0) { + s[0] = '0'; s[1] = '\0'; + return s; + } + + neg = (n < 0); + if (neg) n = -n; + + /* calculate magnitude */ + m = nk_log10(n); + useExp = (m >= 14 || (neg && m >= 9) || m <= -9); + if (neg) *(c++) = '-'; + + /* set up for scientific notation */ + if (useExp) { + if (m < 0) + m -= 1; + n = n / (double)nk_pow(10.0, m); + m1 = m; + m = 0; + } + if (m < 1.0) { + m = 0; + } + + /* convert the number */ + while (n > NK_int_PRECISION || m >= 0) { + double weight = nk_pow(10.0, m); + if (weight > 0) { + double t = (double)n / weight; + digit = nk_ifloord(t); + n -= ((double)digit * weight); + *(c++) = (char)('0' + (char)digit); + } + if (m == 0 && n > 0) + *(c++) = '.'; + m--; + } + + if (useExp) { + /* convert the exponent */ + int i, j; + *(c++) = 'e'; + if (m1 > 0) { + *(c++) = '+'; + } else { + *(c++) = '-'; + m1 = -m1; + } + m = 0; + while (m1 > 0) { + *(c++) = (char)('0' + (char)(m1 % 10)); + m1 /= 10; + m++; + } + c -= m; + for (i = 0, j = m-1; i= buf_size) break; + iter++; + + /* flag arguments */ + while (*iter) { + if (*iter == '-') flag |= NK_ARG_FLAG_LEFT; + else if (*iter == '+') flag |= NK_ARG_FLAG_PLUS; + else if (*iter == ' ') flag |= NK_ARG_FLAG_SPACE; + else if (*iter == '#') flag |= NK_ARG_FLAG_NUM; + else if (*iter == '0') flag |= NK_ARG_FLAG_ZERO; + else break; + iter++; + } + + /* width argument */ + width = NK_DEFAULT; + if (*iter >= '1' && *iter <= '9') { + const char *end; + width = nk_strtoi(iter, &end); + if (end == iter) + width = -1; + else iter = end; + } else if (*iter == '*') { + width = va_arg(args, int); + iter++; + } + + /* precision argument */ + precision = NK_DEFAULT; + if (*iter == '.') { + iter++; + if (*iter == '*') { + precision = va_arg(args, int); + iter++; + } else { + const char *end; + precision = nk_strtoi(iter, &end); + if (end == iter) + precision = -1; + else iter = end; + } + } + + /* length modifier */ + if (*iter == 'h') { + if (*(iter+1) == 'h') { + arg_type = NK_ARG_TYPE_CHAR; + iter++; + } else arg_type = NK_ARG_TYPE_SHORT; + iter++; + } else if (*iter == 'l') { + arg_type = NK_ARG_TYPE_LONG; + iter++; + } else arg_type = NK_ARG_TYPE_DEFAULT; + + /* specifier */ + if (*iter == '%') { + // NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT); + // NK_ASSERT(precision == NK_DEFAULT); + // NK_ASSERT(width == NK_DEFAULT); + if (len < buf_size) + buf[len++] = '%'; + } else if (*iter == 's') { + /* string */ + const char *str = va_arg(args, const char*); + // NK_ASSERT(str != buf && "buffer and argument are not allowed to overlap!"); + // NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT); + // NK_ASSERT(precision == NK_DEFAULT); + // NK_ASSERT(width == NK_DEFAULT); + if (str == buf) return -1; + while (str && *str && len < buf_size) + buf[len++] = *str++; + } else if (*iter == 'n') { + /* current length callback */ + signed int *n = va_arg(args, int*); + // NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT); + // NK_ASSERT(precision == NK_DEFAULT); + // NK_ASSERT(width == NK_DEFAULT); + if (n) *n = len; + } else if (*iter == 'c' || *iter == 'i' || *iter == 'd') { + /* signed integer */ + long value = 0; + const char *num_iter; + int num_len, num_print, padding; + int cur_precision = NK_MAX(precision, 1); + int cur_width = NK_MAX(width, 0); + + /* retrieve correct value type */ + if (arg_type == NK_ARG_TYPE_CHAR) + value = (signed char)va_arg(args, int); + else if (arg_type == NK_ARG_TYPE_SHORT) + value = (signed short)va_arg(args, int); + else if (arg_type == NK_ARG_TYPE_LONG) + value = va_arg(args, signed long); + else if (*iter == 'c') + value = (unsigned char)va_arg(args, int); + else value = va_arg(args, signed int); + + /* convert number to string */ + nk_itoa(number_buffer, value); + num_len = strlen(number_buffer); + padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0); + if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE)) + padding = NK_MAX(padding-1, 0); + + /* fill left padding up to a total of `width` characters */ + if (!(flag & NK_ARG_FLAG_LEFT)) { + while (padding-- > 0 && (len < buf_size)) { + if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT)) + buf[len++] = '0'; + else buf[len++] = ' '; + } + } + + /* copy string value representation into buffer */ + if ((flag & NK_ARG_FLAG_PLUS) && value >= 0 && len < buf_size) + buf[len++] = '+'; + else if ((flag & NK_ARG_FLAG_SPACE) && value >= 0 && len < buf_size) + buf[len++] = ' '; + + /* fill up to precision number of digits with '0' */ + num_print = NK_MAX(cur_precision, num_len); + while (precision && (num_print > num_len) && (len < buf_size)) { + buf[len++] = '0'; + num_print--; + } + + /* copy string value representation into buffer */ + num_iter = number_buffer; + while (precision && *num_iter && len < buf_size) + buf[len++] = *num_iter++; + + /* fill right padding up to width characters */ + if (flag & NK_ARG_FLAG_LEFT) { + while ((padding-- > 0) && (len < buf_size)) + buf[len++] = ' '; + } + } else if (*iter == 'o' || *iter == 'x' || *iter == 'X' || *iter == 'u') { + /* unsigned integer */ + unsigned long value = 0; + int num_len = 0, num_print, padding = 0; + int cur_precision = NK_MAX(precision, 1); + int cur_width = NK_MAX(width, 0); + unsigned int base = (*iter == 'o') ? 8: (*iter == 'u')? 10: 16; + + /* print oct/hex/dec value */ + const char *upper_output_format = "0123456789ABCDEF"; + const char *lower_output_format = "0123456789abcdef"; + const char *output_format = (*iter == 'x') ? + lower_output_format: upper_output_format; + + /* retrieve correct value type */ + if (arg_type == NK_ARG_TYPE_CHAR) + value = (unsigned char)va_arg(args, int); + else if (arg_type == NK_ARG_TYPE_SHORT) + value = (unsigned short)va_arg(args, int); + else if (arg_type == NK_ARG_TYPE_LONG) + value = va_arg(args, unsigned long); + else value = va_arg(args, unsigned int); + + do { + /* convert decimal number into hex/oct number */ + int digit = output_format[value % base]; + if (num_len < NK_MAX_NUMBER_BUFFER) + number_buffer[num_len++] = (char)digit; + value /= base; + } while (value > 0); + + num_print = NK_MAX(cur_precision, num_len); + padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0); + if (flag & NK_ARG_FLAG_NUM) + padding = NK_MAX(padding-1, 0); + + /* fill left padding up to a total of `width` characters */ + if (!(flag & NK_ARG_FLAG_LEFT)) { + while ((padding-- > 0) && (len < buf_size)) { + if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT)) + buf[len++] = '0'; + else buf[len++] = ' '; + } + } + + /* fill up to precision number of digits */ + if (num_print && (flag & NK_ARG_FLAG_NUM)) { + if ((*iter == 'o') && (len < buf_size)) { + buf[len++] = '0'; + } else if ((*iter == 'x') && ((len+1) < buf_size)) { + buf[len++] = '0'; + buf[len++] = 'x'; + } else if ((*iter == 'X') && ((len+1) < buf_size)) { + buf[len++] = '0'; + buf[len++] = 'X'; + } + } + while (precision && (num_print > num_len) && (len < buf_size)) { + buf[len++] = '0'; + num_print--; + } + + /* reverse number direction */ + while (num_len > 0) { + if (precision && (len < buf_size)) + buf[len++] = number_buffer[num_len-1]; + num_len--; + } + + /* fill right padding up to width characters */ + if (flag & NK_ARG_FLAG_LEFT) { + while ((padding-- > 0) && (len < buf_size)) + buf[len++] = ' '; + } + } else if (*iter == 'f') { + /* inting point */ + const char *num_iter; + int cur_precision = (precision < 0) ? 6: precision; + int prefix, cur_width = NK_MAX(width, 0); + double value = va_arg(args, double); + int num_len = 0, frac_len = 0, dot = 0; + int padding = 0; + + // NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT); + NK_DTOA(number_buffer, value); + num_len = strlen(number_buffer); + + /* calculate padding */ + num_iter = number_buffer; + while (*num_iter && *num_iter != '.') + num_iter++; + + prefix = (*num_iter == '.')?(int)(num_iter - number_buffer)+1:0; + padding = NK_MAX(cur_width - (prefix + NK_MIN(cur_precision, num_len - prefix)) , 0); + if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE)) + padding = NK_MAX(padding-1, 0); + + /* fill left padding up to a total of `width` characters */ + if (!(flag & NK_ARG_FLAG_LEFT)) { + while (padding-- > 0 && (len < buf_size)) { + if (flag & NK_ARG_FLAG_ZERO) + buf[len++] = '0'; + else buf[len++] = ' '; + } + } + + /* copy string value representation into buffer */ + num_iter = number_buffer; + if ((flag & NK_ARG_FLAG_PLUS) && (value >= 0) && (len < buf_size)) + buf[len++] = '+'; + else if ((flag & NK_ARG_FLAG_SPACE) && (value >= 0) && (len < buf_size)) + buf[len++] = ' '; + while (*num_iter) { + if (dot) frac_len++; + if (len < buf_size) + buf[len++] = *num_iter; + if (*num_iter == '.') dot = 1; + if (frac_len >= cur_precision) break; + num_iter++; + } + + /* fill number up to precision */ + while (frac_len < cur_precision) { + if (!dot && len < buf_size) { + buf[len++] = '.'; + dot = 1; + } + if (len < buf_size) + buf[len++] = '0'; + frac_len++; + } + + /* fill right padding up to width characters */ + if (flag & NK_ARG_FLAG_LEFT) { + while ((padding-- > 0) && (len < buf_size)) + buf[len++] = ' '; + } + } else { + /* Specifier not supported: g,G,e,E,p,z */ + // NK_ASSERT(0 && "specifier is not supported!"); + return result; + } + } + buf[(len >= buf_size)?(buf_size-1):len] = 0; + result = (len >= buf_size)?-1:len; + return result; +} +#endif +NK_LIB int +nk_strfmt(char *buf, int buf_size, const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - buf / nk_strfmt"); + int result = -1; + // NK_ASSERT(buf); + // NK_ASSERT(buf_size); + if (!buf || !buf_size || !fmt) return 0; +#ifdef NK_INCLUDE_STANDARD_IO + result = NK_VSNPRINTF(buf, (nk_size)buf_size, fmt, args); + result = (result >= buf_size) ? -1: result; + buf[buf_size-1] = 0; +#else + result = nk_vsnprintf(buf, buf_size, fmt, args); +#endif + return result; +} +#endif + +#define get16bits(d) (*((const uint16_t *) (d))) +NK_API nk_hash +nk_murmur_hash(const void * key, int len, nk_hash seed) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void / nk_murmur_hash"); + const nk_byte *s = key; + nk_hash hash = 0; + + for(; *s; ++s) + { + hash += *s; + hash += (hash << 10); + hash ^= (hash >> 6); + } + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash; + /* 32-Bit MurmurHash3: https://code.google.com/p/smhasher/wiki/MurmurHash3*/ + // #define NK_ROTL(x,r) ((x) << (r) | ((x) >> (32 - r))) + + // nk_uint h1 = seed; + // nk_uint k1; + // const nk_byte *data = (const nk_byte*)key; + // const nk_byte *keyptr = data; + // nk_byte *k1ptr; + // const int bsize = sizeof(k1); + // const int nblocks = len/4; + + // const nk_uint c1 = 0xcc9e2d51; + // const nk_uint c2 = 0x1b873593; + // const nk_byte *tail; + // int i; + + // /* body */ + // if (!key) return 0; + // for (i = 0; i < nblocks; ++i, keyptr += bsize) { + // k1ptr = (nk_byte*)&k1; + // k1ptr[0] = keyptr[0]; + // k1ptr[1] = keyptr[1]; + // k1ptr[2] = keyptr[2]; + // k1ptr[3] = keyptr[3]; + + // k1 *= c1; + // k1 = NK_ROTL(k1,15); + // k1 *= c2; + + // h1 ^= k1; + // h1 = NK_ROTL(h1,13); + // h1 = h1*5+0xe6546b64; + // } + + // /* tail */ + // tail = (const nk_byte*)(data + nblocks*4); + // k1 = 0; + // switch (len & 3) { + // case 3: k1 ^= (nk_uint)(tail[2] << 16); /* fallthrough */ + // case 2: k1 ^= (nk_uint)(tail[1] << 8u); /* fallthrough */ + // case 1: k1 ^= tail[0]; + // k1 *= c1; + // k1 = NK_ROTL(k1,15); + // k1 *= c2; + // h1 ^= k1; + // break; + // default: break; + // } + + // /* finalization */ + // h1 ^= (nk_uint)len; + // /* fmix32 */ + // h1 ^= h1 >> 16; + // h1 *= 0x85ebca6b; + // h1 ^= h1 >> 13; + // h1 *= 0xc2b2ae35; + // h1 ^= h1 >> 16; + + // #undef NK_ROTL + // return h1; +} + + +#ifdef NK_INCLUDE_STANDARD_IO +NK_LIB char* +nk_file_load(const char* path, nk_size* siz, struct nk_allocator *alloc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_file_load"); + char *buf; + FILE *fd; + long ret; + + // NK_ASSERT(path); + // NK_ASSERT(siz); + // NK_ASSERT(alloc); + if (!path || !siz || !alloc) + return 0; + + fd = fopen(path, "rb"); + if (!fd) return 0; + fseek(fd, 0, SEEK_END); + ret = ftell(fd); + if (ret < 0) { + fclose(fd); + return 0; + } + *siz = (nk_size)ret; + fseek(fd, 0, SEEK_SET); + buf = (char*)alloc->alloc(alloc->userdata,0, *siz); + // NK_ASSERT(buf); + if (!buf) { + fclose(fd); + return 0; + } + *siz = (nk_size)fread(buf, 1,*siz, fd); + fclose(fd); + return buf; +} +#endif +NK_LIB int +nk_text_clamp(const struct nk_user_font *font, const char *text, + int text_len, int space, int *glyphs, int *text_width, + nk_rune *sep_list, int sep_count) +{ + + + long start; + long end; + long total; + long eventTime0; + + start = TickCount(); + + //writeSerialPort(boutRefNum, "FUNCTION CALL - sep_list, / nk_rune"); + //writeSerialPort(boutRefNum, "nk_text_clamp"); + // TODO:: pretty sure this function is slow, figure out what is up + // we at least need to figure out how to cache the return value + int i = 0; + int last_width = 0; + nk_rune unicode = 0; + int width = 0; + int len = 0; + int g = 0; + int s; + + int sep_len = 0; + int sep_g = 0; + int sep_width = 0; + sep_count = NK_MAX(sep_count,0); + + unicode = text[0]; + + while ((width < space) && (len < text_len)) { + len += 1; + s = font->width(font->userdata, font->height, text, len); // has to get cached quickdraw width values + for (i = 0; i < sep_count; ++i) { + if (unicode != sep_list[i]) continue; + sep_width = last_width = width; + sep_g = g+1; + sep_len = len; + break; + } + if (i == sep_count){ + last_width = sep_width = width; + sep_g = g+1; + } + width = s; + unicode = text[len]; + g++; + } + if (len >= text_len) { + *glyphs = g; + *text_width = last_width; + return len; + } else { + *glyphs = sep_g; + *text_width = sep_width; + return (!sep_len) ? len: sep_len; + } + end = TickCount(); + + total = end - start; + eventTime0 = total;// / 60.0; + + //char logx[255]; + //sprintf(logx, "text clamp time() eventTime0 (clamp text) %ld\n", eventTime0); + //writeSerialPort(boutRefNum, logx); +} +NK_LIB struct nk_vec2 +nk_text_calculate_text_bounds(const struct nk_user_font *font, + const char *begin, int byte_len, int row_height, const char **remaining, + struct nk_vec2 *out_offset, int *glyphs, int op) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_offset / struct"); + //writeSerialPort(boutRefNum, "nk_text_calculate_text_bounds"); + int line_height = row_height; + struct nk_vec2 text_size = nk_vec2(0,0); + int line_width = 0.0f; + + int glyph_width; + int glyph_len = 0; + nk_rune unicode = 0; + int text_len = 0; + if (!begin || byte_len <= 0 || !font) + return nk_vec2(0,row_height); + + glyph_len = nk_utf_decode(begin, &unicode, byte_len); + if (!glyph_len) return text_size; + glyph_width = font->width(font->userdata, font->height, begin, glyph_len); + + *glyphs = 0; + while ((text_len < byte_len) && glyph_len) { + if (unicode == '\n') { + text_size.x = NK_MAX(text_size.x, line_width); + text_size.y += line_height; + line_width = 0; + *glyphs+=1; + if (op == NK_STOP_ON_NEW_LINE) + break; + + text_len++; + glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len); + continue; + } + + if (unicode == '\r') { + text_len++; + *glyphs+=1; + glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len); + continue; + } + + *glyphs = *glyphs + 1; + text_len += glyph_len; + line_width += (int)glyph_width; + glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len); + glyph_width = font->width(font->userdata, font->height, begin+text_len, glyph_len); + continue; + } + + if (text_size.x < line_width) + text_size.x = line_width; + if (out_offset) + *out_offset = nk_vec2(line_width, text_size.y + line_height); + if (line_width > 0 || text_size.y == 0.0f) + text_size.y += line_height; + if (remaining) + *remaining = begin+text_len; + return text_size; +} + + + + + +/* ============================================================== + * + * COLOR + * + * ===============================================================*/ +NK_INTERN int +nk_parse_hex(const char *p, int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_parse_hex"); + //writeSerialPort(boutRefNum, "nk_parse_hex"); + int i = 0; + int len = 0; + while (len < length) { + i <<= 4; + if (p[len] >= 'a' && p[len] <= 'f') + i += ((p[len] - 'a') + 10); + else if (p[len] >= 'A' && p[len] <= 'F') + i += ((p[len] - 'A') + 10); + else i += (p[len] - '0'); + len++; + } + return i; +} +NK_API struct nk_color +nk_rgba(int r, int g, int b, int a) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_rgba"); + struct nk_color ret; + ret.r = (nk_byte)NK_CLAMP(0, r, 255); + ret.g = (nk_byte)NK_CLAMP(0, g, 255); + ret.b = (nk_byte)NK_CLAMP(0, b, 255); + ret.a = (nk_byte)NK_CLAMP(0, a, 255); + return ret; +} +NK_API struct nk_color +nk_rgb_hex(const char *rgb) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_rgb_hex"); + struct nk_color col; + const char *c = rgb; + if (*c == '#') c++; + col.r = (nk_byte)nk_parse_hex(c, 2); + col.g = (nk_byte)nk_parse_hex(c+2, 2); + col.b = (nk_byte)nk_parse_hex(c+4, 2); + col.a = 255; + return col; +} +NK_API struct nk_color +nk_rgba_hex(const char *rgb) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_rgba_hex"); + struct nk_color col; + const char *c = rgb; + if (*c == '#') c++; + col.r = (nk_byte)nk_parse_hex(c, 2); + col.g = (nk_byte)nk_parse_hex(c+2, 2); + col.b = (nk_byte)nk_parse_hex(c+4, 2); + col.a = (nk_byte)nk_parse_hex(c+6, 2); + return col; +} +NK_API void +nk_color_hex_rgba(char *output, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - output / nk_color_hex_rgba"); + #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i)) + output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4); + output[1] = (char)NK_TO_HEX((col.r & 0x0F)); + output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4); + output[3] = (char)NK_TO_HEX((col.g & 0x0F)); + output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4); + output[5] = (char)NK_TO_HEX((col.b & 0x0F)); + output[6] = (char)NK_TO_HEX((col.a & 0xF0) >> 4); + output[7] = (char)NK_TO_HEX((col.a & 0x0F)); + output[8] = '\0'; + #undef NK_TO_HEX +} +NK_API void +nk_color_hex_rgb(char *output, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - output / nk_color_hex_rgb"); + #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i)) + output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4); + output[1] = (char)NK_TO_HEX((col.r & 0x0F)); + output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4); + output[3] = (char)NK_TO_HEX((col.g & 0x0F)); + output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4); + output[5] = (char)NK_TO_HEX((col.b & 0x0F)); + output[6] = '\0'; + #undef NK_TO_HEX +} +NK_API struct nk_color +nk_rgba_iv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rgba_iv"); + return nk_rgba(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgba_bv(const nk_byte *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_byte / nk_rgba_bv"); + return nk_rgba(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgb(int r, int g, int b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_rgb"); + struct nk_color ret; + ret.r = (nk_byte)NK_CLAMP(0, r, 255); + ret.g = (nk_byte)NK_CLAMP(0, g, 255); + ret.b = (nk_byte)NK_CLAMP(0, b, 255); + ret.a = (nk_byte)255; + return ret; +} +NK_API struct nk_color +nk_rgb_iv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rgb_iv"); + return nk_rgb(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgb_bv(const nk_byte* c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_byte / nk_rgb_bv"); + return nk_rgb(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgba_u32(nk_uint in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - in / nk_rgba_u32"); + struct nk_color ret; + ret.r = (in & 0xFF); + ret.g = ((in >> 8) & 0xFF); + ret.b = ((in >> 16) & 0xFF); + ret.a = (nk_byte)((in >> 24) & 0xFF); + return ret; +} +NK_API struct nk_color +nk_rgba_f(int r, int g, int b, int a) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_rgba_f"); + struct nk_color ret; + ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f); + ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f); + ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f); + ret.a = (nk_byte)(NK_SATURATE(a) * 255.0f); + return ret; +} +NK_API struct nk_color +nk_rgba_fv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rgba_fv"); + return nk_rgba_f(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgba_cf(struct nk_colorf c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_colorf / nk_rgba_cf"); + return nk_rgba_f(c.r, c.g, c.b, c.a); +} +NK_API struct nk_color +nk_rgb_f(int r, int g, int b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_rgb_f"); + struct nk_color ret; + ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f); + ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f); + ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f); + ret.a = 255; + return ret; +} +NK_API struct nk_color +nk_rgb_fv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_rgb_fv"); + return nk_rgb_f(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgb_cf(struct nk_colorf c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_colorf / nk_rgb_cf"); + return nk_rgb_f(c.r, c.g, c.b); +} +NK_API struct nk_color +nk_hsv(int h, int s, int v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_hsv"); + return nk_hsva(h, s, v, 255); +} +NK_API struct nk_color +nk_hsv_iv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_hsv_iv"); + return nk_hsv(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_hsv_bv(const nk_byte *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_byte / nk_hsv_bv"); + return nk_hsv(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_hsv_f(int h, int s, int v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_hsv_f"); + return nk_hsva_f(h, s, v, 1.0f); +} +NK_API struct nk_color +nk_hsv_fv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_hsv_fv"); + return nk_hsv_f(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_hsva(int h, int s, int v, int a) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_hsva"); + int hf = ((int)NK_CLAMP(0, h, 255)) / 255.0f; + int sf = ((int)NK_CLAMP(0, s, 255)) / 255.0f; + int vf = ((int)NK_CLAMP(0, v, 255)) / 255.0f; + int af = ((int)NK_CLAMP(0, a, 255)) / 255.0f; + return nk_hsva_f(hf, sf, vf, af); +} +NK_API struct nk_color +nk_hsva_iv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_hsva_iv"); + return nk_hsva(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_hsva_bv(const nk_byte *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_byte / nk_hsva_bv"); + return nk_hsva(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_colorf +nk_hsva_colorf(int h, int s, int v, int a) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_hsva_colorf"); + int i; + int p, q, t, f; + struct nk_colorf out = {0,0,0,0}; + if (s <= 0.0f) { + out.r = v; out.g = v; out.b = v; out.a = a; + return out; + } + h = h / (60.0f/360.0f); + i = (int)h; + f = h - (int)i; + p = v * (1.0f - s); + q = v * (1.0f - (s * f)); + t = v * (1.0f - s * (1.0f - f)); + + switch (i) { + case 0: default: out.r = v; out.g = t; out.b = p; break; + case 1: out.r = q; out.g = v; out.b = p; break; + case 2: out.r = p; out.g = v; out.b = t; break; + case 3: out.r = p; out.g = q; out.b = v; break; + case 4: out.r = t; out.g = p; out.b = v; break; + case 5: out.r = v; out.g = p; out.b = q; break;} + out.a = a; + return out; +} +NK_API struct nk_colorf +nk_hsva_colorfv(int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_hsva_colorfv"); + return nk_hsva_colorf(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_hsva_f(int h, int s, int v, int a) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_hsva_f"); + struct nk_colorf c = nk_hsva_colorf(h, s, v, a); + return nk_rgba_f(c.r, c.g, c.b, c.a); +} +NK_API struct nk_color +nk_hsva_fv(const int *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_hsva_fv"); + return nk_hsva_f(c[0], c[1], c[2], c[3]); +} +NK_API nk_uint +nk_color_u32(struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_color / nk_color_u32"); + nk_uint out = (nk_uint)in.r; + out |= ((nk_uint)in.g << 8); + out |= ((nk_uint)in.b << 16); + out |= ((nk_uint)in.a << 24); + return out; +} +NK_API void +nk_color_f(int *r, int *g, int *b, int *a, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_color_f"); + NK_STORAGE const int s = 1.0f/255.0f; + *r = (int)in.r * s; + *g = (int)in.g * s; + *b = (int)in.b * s; + *a = (int)in.a * s; +} +NK_API void +nk_color_fv(int *c, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_color_fv"); + nk_color_f(&c[0], &c[1], &c[2], &c[3], in); +} +NK_API struct nk_colorf +nk_color_cf(struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_color / nk_color_cf"); + struct nk_colorf o; + nk_color_f(&o.r, &o.g, &o.b, &o.a, in); + return o; +} +NK_API void +nk_color_d(double *r, double *g, double *b, double *a, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / nk_color_d"); + NK_STORAGE const double s = 1.0/255.0; + *r = (double)in.r * s; + *g = (double)in.g * s; + *b = (double)in.b * s; + *a = (double)in.a * s; +} +NK_API void +nk_color_dv(double *c, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_color_dv"); + nk_color_d(&c[0], &c[1], &c[2], &c[3], in); +} +NK_API void +nk_color_hsv_f(int *out_h, int *out_s, int *out_v, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_h / nk_color_hsv_f"); + int a; + nk_color_hsva_f(out_h, out_s, out_v, &a, in); +} +NK_API void +nk_color_hsv_fv(int *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsv_fv"); + int a; + nk_color_hsva_f(&out[0], &out[1], &out[2], &a, in); +} +NK_API void +nk_colorf_hsva_f(int *out_h, int *out_s, + int *out_v, int *out_a, struct nk_colorf in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_v, / int"); + int chroma; + int K = 0.0f; + if (in.g < in.b) { + const int t = in.g; in.g = in.b; in.b = t; + K = -1.f; + } + if (in.r < in.g) { + const int t = in.r; in.r = in.g; in.g = t; + K = -2.f/6.0f - K; + } + chroma = in.r - ((in.g < in.b) ? in.g: in.b); + *out_h = NK_ABS(K + (in.g - in.b)/(6.0f * chroma + 1e-20f)); + *out_s = chroma / (in.r + 1e-20f); + *out_v = in.r; + *out_a = in.a; + +} +NK_API void +nk_colorf_hsva_fv(int *hsva, struct nk_colorf in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - hsva / nk_colorf_hsva_fv"); + nk_colorf_hsva_f(&hsva[0], &hsva[1], &hsva[2], &hsva[3], in); +} +NK_API void +nk_color_hsva_f(int *out_h, int *out_s, + int *out_v, int *out_a, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_v, / int"); + struct nk_colorf col; + nk_color_f(&col.r,&col.g,&col.b,&col.a, in); + nk_colorf_hsva_f(out_h, out_s, out_v, out_a, col); +} +NK_API void +nk_color_hsva_fv(int *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsva_fv"); + nk_color_hsva_f(&out[0], &out[1], &out[2], &out[3], in); +} +NK_API void +nk_color_hsva_i(int *out_h, int *out_s, int *out_v, + int *out_a, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_a, / int"); + int h,s,v,a; + nk_color_hsva_f(&h, &s, &v, &a, in); + *out_h = (nk_byte)(h * 255.0f); + *out_s = (nk_byte)(s * 255.0f); + *out_v = (nk_byte)(v * 255.0f); + *out_a = (nk_byte)(a * 255.0f); +} +NK_API void +nk_color_hsva_iv(int *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsva_iv"); + nk_color_hsva_i(&out[0], &out[1], &out[2], &out[3], in); +} +NK_API void +nk_color_hsva_bv(nk_byte *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsva_bv"); + int tmp[4]; + nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in); + out[0] = (nk_byte)tmp[0]; + out[1] = (nk_byte)tmp[1]; + out[2] = (nk_byte)tmp[2]; + out[3] = (nk_byte)tmp[3]; +} +NK_API void +nk_color_hsva_b(nk_byte *h, nk_byte *s, nk_byte *v, nk_byte *a, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - h / nk_color_hsva_b"); + int tmp[4]; + nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in); + *h = (nk_byte)tmp[0]; + *s = (nk_byte)tmp[1]; + *v = (nk_byte)tmp[2]; + *a = (nk_byte)tmp[3]; +} +NK_API void +nk_color_hsv_i(int *out_h, int *out_s, int *out_v, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_h / nk_color_hsv_i"); + int a; + nk_color_hsva_i(out_h, out_s, out_v, &a, in); +} +NK_API void +nk_color_hsv_b(nk_byte *out_h, nk_byte *out_s, nk_byte *out_v, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out_h / nk_color_hsv_b"); + int tmp[4]; + nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in); + *out_h = (nk_byte)tmp[0]; + *out_s = (nk_byte)tmp[1]; + *out_v = (nk_byte)tmp[2]; +} +NK_API void +nk_color_hsv_iv(int *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsv_iv"); + nk_color_hsv_i(&out[0], &out[1], &out[2], in); +} +NK_API void +nk_color_hsv_bv(nk_byte *out, struct nk_color in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - out / nk_color_hsv_bv"); + int tmp[4]; + nk_color_hsv_i(&tmp[0], &tmp[1], &tmp[2], in); + out[0] = (nk_byte)tmp[0]; + out[1] = (nk_byte)tmp[1]; + out[2] = (nk_byte)tmp[2]; +} + + + + + +/* =============================================================== + * + * UTF-8 + * + * ===============================================================*/ +NK_GLOBAL const nk_byte nk_utfbyte[NK_UTF_SIZE+1] = {0x80, 0, 0xC0, 0xE0, 0xF0}; +NK_GLOBAL const nk_byte nk_utfmask[NK_UTF_SIZE+1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8}; +NK_GLOBAL const nk_uint nk_utfmin[NK_UTF_SIZE+1] = {0, 0, 0x80, 0x800, 0x10000}; +NK_GLOBAL const nk_uint nk_utfmax[NK_UTF_SIZE+1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF}; + +NK_INTERN int +nk_utf_validate(nk_rune *u, int i) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - u / nk_utf_validate"); + // NK_ASSERT(u); + if (!u) return 0; + if (!NK_BETWEEN(*u, nk_utfmin[i], nk_utfmax[i]) || + NK_BETWEEN(*u, 0xD800, 0xDFFF)) + *u = NK_UTF_INVALID; + for (i = 1; *u > nk_utfmax[i]; ++i); + return i; +} +NK_INTERN nk_rune +nk_utf_decode_byte(char c, int *i) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_utf_decode_byte"); + // NK_ASSERT(i); + if (!i) return 0; + for(*i = 0; *i < (int)NK_LEN(nk_utfmask); ++(*i)) { + if (((nk_byte)c & nk_utfmask[*i]) == nk_utfbyte[*i]) + return (nk_byte)(c & ~nk_utfmask[*i]); + } + return 0; +} +NK_API int +nk_utf_decode(const char *c, nk_rune *u, int clen) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_utf_decode"); + + if (!c || !u) { + + return 0; + } + if (!clen) { + + return 0; + } + + *u = c[0]; + + return 1; +} +NK_INTERN char +nk_utf_encode_byte(nk_rune u, int i) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - u / nk_utf_encode_byte"); + return (char)((nk_utfbyte[i]) | ((nk_byte)u & ~nk_utfmask[i])); +} +NK_API int +nk_utf_encode(nk_rune u, char *c, int clen) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - u / nk_utf_encode"); + c[0] = u; + return 1; +} +NK_API int +nk_utf_len(const char *str, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_utf_len"); + return len; +} +NK_API const char* +nk_utf_at(const char *buffer, int length, int index, + nk_rune *unicode, int *len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - unicode, / nk_rune"); + + //writeSerialPort(boutRefNum, "nk_utf_at"); + int i = 0; + int src_len = 0; + int glyph_len = 0; + const char *text; + int text_len; + + // NK_ASSERT(buffer); + // NK_ASSERT(unicode); + // NK_ASSERT(len); + + if (!buffer || !unicode || !len) return 0; + if (index < 0) { + *unicode = NK_UTF_INVALID; + *len = 0; + return 0; + } + + text = buffer; + text_len = length; + glyph_len = nk_utf_decode(text, unicode, text_len); + while (glyph_len) { + if (i == index) { + *len = glyph_len; + break; + } + + i++; + src_len = src_len + glyph_len; + glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len); + } + if (i != index) return 0; + return buffer + src_len; +} + + + + + +/* ============================================================== + * + * BUFFER + * + * ===============================================================*/ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_LIB void* +nk_malloc(nk_handle unused, void *old,nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - unused / nk_malloc"); + NK_UNUSED(unused); + NK_UNUSED(old); + return malloc(size); +} +NK_LIB void +nk_mfree(nk_handle unused, void *ptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - unused / nk_mfree"); + NK_UNUSED(unused); + free(ptr); +} +NK_API void +nk_buffer_init_default(struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_init_default"); + struct nk_allocator alloc; + alloc.userdata.ptr = 0; + alloc.alloc = nk_malloc; + alloc.free = nk_mfree; + nk_buffer_init(buffer, &alloc, NK_BUFFER_DEFAULT_INITIAL_SIZE); +} +#endif + +NK_API void +nk_buffer_init(struct nk_buffer *b, const struct nk_allocator *a, + nk_size initial_size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - initial_size) / nk_size"); + // NK_ASSERT(b); + // NK_ASSERT(a); + // NK_ASSERT(initial_size); + if (!b || !a || !initial_size) return; + + nk_zero(b, sizeof(*b)); + b->type = NK_BUFFER_DYNAMIC; + b->memory.ptr = a->alloc(a->userdata,0, initial_size); + b->memory.size = initial_size; + b->size = initial_size; + b->grow_factor = 2.0f; + b->pool = *a; +} +NK_API void +nk_buffer_init_fixed(struct nk_buffer *b, void *m, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_init_fixed"); + // NK_ASSERT(b); + // NK_ASSERT(m); + // NK_ASSERT(size); + if (!b || !m || !size) return; + + nk_zero(b, sizeof(*b)); + b->type = NK_BUFFER_FIXED; + b->memory.ptr = m; + b->memory.size = size; + b->size = size; +} +NK_LIB void* +nk_buffer_align(void *unaligned, + nk_size align, nk_size *alignment, + enum nk_buffer_allocation_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer_align"); + void *memory = 0; + switch (type) { + default: + case NK_BUFFER_MAX: + case NK_BUFFER_FRONT: + if (align) { + memory = NK_ALIGN_PTR(unaligned, align); + *alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned); + } else { + memory = unaligned; + *alignment = 0; + } + break; + case NK_BUFFER_BACK: + if (align) { + memory = NK_ALIGN_PTR_BACK(unaligned, align); + *alignment = (nk_size)((nk_byte*)unaligned - (nk_byte*)memory); + } else { + memory = unaligned; + *alignment = 0; + } + break; + } + return memory; +} +NK_LIB void* +nk_buffer_realloc(struct nk_buffer *b, nk_size capacity, nk_size *size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_realloc"); + void *temp; + nk_size buffer_size; + + // NK_ASSERT(b); + // NK_ASSERT(size); + if (!b || !size || !b->pool.alloc || !b->pool.free) + return 0; + + buffer_size = b->memory.size; + temp = b->pool.alloc(b->pool.userdata, b->memory.ptr, capacity); + // NK_ASSERT(temp); + if (!temp) return 0; + + *size = capacity; + if (temp != b->memory.ptr) { + NK_MEMCPY(temp, b->memory.ptr, buffer_size); + b->pool.free(b->pool.userdata, b->memory.ptr); + } + + if (b->size == buffer_size) { + /* no back buffer so just set correct size */ + b->size = capacity; + return temp; + } else { + /* copy back buffer to the end of the new buffer */ + void *dst, *src; + nk_size back_size; + back_size = buffer_size - b->size; + dst = nk_ptr_add(void, temp, capacity - back_size); + src = nk_ptr_add(void, temp, b->size); + NK_MEMCPY(dst, src, back_size); + b->size = capacity - back_size; + } + return temp; +} +NK_LIB void* +nk_buffer_alloc(struct nk_buffer *b, enum nk_buffer_allocation_type type, + nk_size size, nk_size align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer_alloc"); + int full; + nk_size alignment; + void *unaligned; + void *memory; + + // NK_ASSERT(b); + // NK_ASSERT(size); + if (!b || !size) return 0; + b->needed += size; + + /* calculate total size with needed alignment + size */ + if (type == NK_BUFFER_FRONT) + unaligned = nk_ptr_add(void, b->memory.ptr, b->allocated); + else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size); + memory = nk_buffer_align(unaligned, align, &alignment, type); + + /* check if buffer has enough memory*/ + if (type == NK_BUFFER_FRONT) + full = ((b->allocated + size + alignment) > b->size); + else full = ((b->size - NK_MIN(b->size,(size + alignment))) <= b->allocated); + + if (full) { + nk_size capacity; + if (b->type != NK_BUFFER_DYNAMIC) + return 0; + // NK_ASSERT(b->pool.alloc && b->pool.free); + if (b->type != NK_BUFFER_DYNAMIC || !b->pool.alloc || !b->pool.free) + return 0; + + /* buffer is full so allocate bigger buffer if dynamic */ + capacity = (nk_size)((int)b->memory.size * b->grow_factor); + capacity = NK_MAX(capacity, nk_round_up_pow2((nk_uint)(b->allocated + size))); + b->memory.ptr = nk_buffer_realloc(b, capacity, &b->memory.size); + if (!b->memory.ptr) return 0; + + /* align newly allocated pointer */ + if (type == NK_BUFFER_FRONT) + unaligned = nk_ptr_add(void, b->memory.ptr, b->allocated); + else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size); + memory = nk_buffer_align(unaligned, align, &alignment, type); + } + if (type == NK_BUFFER_FRONT) + b->allocated += size + alignment; + else b->size -= (size + alignment); + b->needed += alignment; + b->calls++; + return memory; +} +NK_API void +nk_buffer_push(struct nk_buffer *b, enum nk_buffer_allocation_type type, + const void *memory, nk_size size, nk_size align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer_push"); + void *mem = nk_buffer_alloc(b, type, size, align); + if (!mem) return; + NK_MEMCPY(mem, memory, size); +} +NK_API void +nk_buffer_mark(struct nk_buffer *buffer, enum nk_buffer_allocation_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_mark"); + // NK_ASSERT(buffer); + if (!buffer) return; + buffer->marker[type].active = nk_true; + if (type == NK_BUFFER_BACK) + buffer->marker[type].offset = buffer->size; + else buffer->marker[type].offset = buffer->allocated; +} +NK_API void +nk_buffer_reset(struct nk_buffer *buffer, enum nk_buffer_allocation_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_reset"); + // NK_ASSERT(buffer); + if (!buffer) return; + if (type == NK_BUFFER_BACK) { + /* reset back buffer either back to marker or empty */ + buffer->needed -= (buffer->memory.size - buffer->marker[type].offset); + if (buffer->marker[type].active) + buffer->size = buffer->marker[type].offset; + else buffer->size = buffer->memory.size; + buffer->marker[type].active = nk_false; + } else { + /* reset front buffer either back to back marker or empty */ + buffer->needed -= (buffer->allocated - buffer->marker[type].offset); + if (buffer->marker[type].active) + buffer->allocated = buffer->marker[type].offset; + else buffer->allocated = 0; + buffer->marker[type].active = nk_false; + } +} +NK_API void +nk_buffer_clear(struct nk_buffer *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_clear"); + // NK_ASSERT(b); + if (!b) return; + b->allocated = 0; + b->size = b->memory.size; + b->calls = 0; + b->needed = 0; +} +NK_API void +nk_buffer_free(struct nk_buffer *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_free"); + // NK_ASSERT(b); + if (!b || !b->memory.ptr) return; + if (b->type == NK_BUFFER_FIXED) return; + if (!b->pool.free) return; + // NK_ASSERT(b->pool.free); + b->pool.free(b->pool.userdata, b->memory.ptr); +} +NK_API void +nk_buffer_info(struct nk_memory_status *s, struct nk_buffer *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_memory_status / nk_buffer_info"); + // NK_ASSERT(b); + // NK_ASSERT(s); + if (!s || !b) return; + s->allocated = b->allocated; + s->size = b->memory.size; + s->needed = b->needed; + s->memory = b->memory.ptr; + s->calls = b->calls; +} +NK_API void* +nk_buffer_memory(struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_memory"); + // NK_ASSERT(buffer); + if (!buffer) return 0; + return buffer->memory.ptr; +} +NK_API const void* +nk_buffer_memory_const(const struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_buffer_memory_const"); + // NK_ASSERT(buffer); + if (!buffer) return 0; + return buffer->memory.ptr; +} +NK_API nk_size +nk_buffer_total(struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / nk_buffer_total"); + // NK_ASSERT(buffer); + if (!buffer) return 0; + return buffer->memory.size; +} + + + + + +/* =============================================================== + * + * STRING + * + * ===============================================================*/ +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void +nk_str_init_default(struct nk_str *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_init_default"); + struct nk_allocator alloc; + alloc.userdata.ptr = 0; + alloc.alloc = nk_malloc; + alloc.free = nk_mfree; + nk_buffer_init(&str->buffer, &alloc, 32); + str->len = 0; +} +#endif + +NK_API void +nk_str_init(struct nk_str *str, const struct nk_allocator *alloc, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_init"); + nk_buffer_init(&str->buffer, alloc, size); + str->len = 0; +} +NK_API void +nk_str_init_fixed(struct nk_str *str, void *memory, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_init_fixed"); + nk_buffer_init_fixed(&str->buffer, memory, size); + str->len = 0; +} +NK_API int +nk_str_append_text_char(struct nk_str *s, const char *str, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_text_char"); + char *mem; + // NK_ASSERT(s); + // NK_ASSERT(str); + if (!s || !str || !len) return 0; + mem = (char*)nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0); + if (!mem) return 0; + NK_MEMCPY(mem, str, (nk_size)len * sizeof(char)); + s->len += nk_utf_len(str, len); + return len; +} +NK_API int +nk_str_append_str_char(struct nk_str *s, const char *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_str_char"); + return nk_str_append_text_char(s, str, strlen(str)); +} +NK_API int +nk_str_append_text_utf8(struct nk_str *str, const char *text, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_text_utf8"); + int i = 0; + int byte_len = 0; + nk_rune unicode; + if (!str || !text || !len) return 0; + for (i = 0; i < len; ++i) + byte_len += nk_utf_decode(text+byte_len, &unicode, 4); + nk_str_append_text_char(str, text, byte_len); + return len; +} +NK_API int +nk_str_append_str_utf8(struct nk_str *str, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_str_utf8"); + //writeSerialPort(boutRefNum, "nk_str_append_str_utf8"); + int runes = 0; + int byte_len = 0; + int num_runes = 0; + int glyph_len = 0; + nk_rune unicode; + if (!str || !text) return 0; + + glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4); + while (unicode != '\0' && glyph_len) { + glyph_len = nk_utf_decode(text+byte_len, &unicode, 4); + byte_len += glyph_len; + num_runes++; + } + nk_str_append_text_char(str, text, byte_len); + return runes; +} +NK_API int +nk_str_append_text_runes(struct nk_str *str, const nk_rune *text, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_text_runes"); + int i = 0; + int byte_len = 0; + nk_glyph glyph; + + // NK_ASSERT(str); + if (!str || !text || !len) return 0; + for (i = 0; i < len; ++i) { + byte_len = nk_utf_encode(text[i], glyph, NK_UTF_SIZE); + if (!byte_len) break; + nk_str_append_text_char(str, glyph, byte_len); + } + return len; +} +NK_API int +nk_str_append_str_runes(struct nk_str *str, const nk_rune *runes) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_append_str_runes"); + //writeSerialPort(boutRefNum, "nk_str_append_str_runes"); + int i = 0; + nk_glyph glyph; + int byte_len; + // NK_ASSERT(str); + if (!str || !runes) return 0; + while (runes[i] != '\0') { + byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE); + nk_str_append_text_char(str, glyph, byte_len); + i++; + } + return i; +} +NK_API int +nk_str_insert_at_char(struct nk_str *s, int pos, const char *str, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_at_char"); + int i; + void *mem; + char *src; + char *dst; + + int copylen; + // NK_ASSERT(s); + // NK_ASSERT(str); + // NK_ASSERT(len >= 0); + if (!s || !str || !len || (nk_size)pos > s->buffer.allocated) return 0; + if ((s->buffer.allocated + (nk_size)len >= s->buffer.memory.size) && (s->buffer.type == NK_BUFFER_FIXED)) return 0; + + copylen = (int)s->buffer.allocated - pos; + if (!copylen) { + nk_str_append_text_char(s, str, len); + return 1; + } + mem = nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0); + if (!mem) return 0; + + /* memmove */ + // NK_ASSERT(((int)pos + (int)len + ((int)copylen - 1)) >= 0); + // NK_ASSERT(((int)pos + ((int)copylen - 1)) >= 0); + dst = nk_ptr_add(char, s->buffer.memory.ptr, pos + len + (copylen - 1)); + src = nk_ptr_add(char, s->buffer.memory.ptr, pos + (copylen-1)); + for (i = 0; i < copylen; ++i) *dst-- = *src--; + mem = nk_ptr_add(void, s->buffer.memory.ptr, pos); + NK_MEMCPY(mem, str, (nk_size)len * sizeof(char)); + s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated); + return 1; +} +NK_API int +nk_str_insert_at_rune(struct nk_str *str, int pos, const char *cstr, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_at_rune"); + int glyph_len; + nk_rune unicode; + const char *begin; + const char *buffer; + + // NK_ASSERT(str); + // NK_ASSERT(cstr); + // NK_ASSERT(len); + if (!str || !cstr || !len) return 0; + begin = nk_str_at_rune(str, pos, &unicode, &glyph_len); + if (!str->len) + return nk_str_append_text_char(str, cstr, len); + buffer = nk_str_get_const(str); + if (!begin) return 0; + return nk_str_insert_at_char(str, (int)(begin - buffer), cstr, len); +} +NK_API int +nk_str_insert_text_char(struct nk_str *str, int pos, const char *text, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_text_char"); + return nk_str_insert_text_utf8(str, pos, text, len); +} +NK_API int +nk_str_insert_str_char(struct nk_str *str, int pos, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_str_char"); + return nk_str_insert_text_utf8(str, pos, text, strlen(text)); +} +NK_API int +nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_text_utf8"); + int i = 0; + int byte_len = 0; + nk_rune unicode; + + // NK_ASSERT(str); + // NK_ASSERT(text); + if (!str || !text || !len) return 0; + for (i = 0; i < len; ++i) + byte_len += nk_utf_decode(text+byte_len, &unicode, 4); + nk_str_insert_at_rune(str, pos, text, byte_len); + return len; +} +NK_API int +nk_str_insert_str_utf8(struct nk_str *str, int pos, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_str_utf8"); + int runes = 0; + int byte_len = 0; + int num_runes = 0; + int glyph_len = 0; + nk_rune unicode; + if (!str || !text) return 0; + + glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4); + //writeSerialPort(boutRefNum, "nk_str_insert_str_utf8"); + while (unicode != '\0' && glyph_len) { + glyph_len = nk_utf_decode(text+byte_len, &unicode, 4); + byte_len += glyph_len; + num_runes++; + } + nk_str_insert_at_rune(str, pos, text, byte_len); + return runes; +} +NK_API int +nk_str_insert_text_runes(struct nk_str *str, int pos, const nk_rune *runes, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_text_runes"); + int i = 0; + int byte_len = 0; + nk_glyph glyph; + + // NK_ASSERT(str); + if (!str || !runes || !len) return 0; + for (i = 0; i < len; ++i) { + byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE); + if (!byte_len) break; + nk_str_insert_at_rune(str, pos+i, glyph, byte_len); + } + return len; +} +NK_API int +nk_str_insert_str_runes(struct nk_str *str, int pos, const nk_rune *runes) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_insert_str_runes"); + int i = 0; + nk_glyph glyph; + int byte_len; + // NK_ASSERT(str); + if (!str || !runes) return 0; + //writeSerialPort(boutRefNum, "nk_str_insert_str_runes"); + while (runes[i] != '\0') { + byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE); + nk_str_insert_at_rune(str, pos+i, glyph, byte_len); + i++; + } + return i; +} +NK_API void +nk_str_remove_chars(struct nk_str *s, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_remove_chars"); + // NK_ASSERT(s); + // NK_ASSERT(len >= 0); + if (!s || len < 0 || (nk_size)len > s->buffer.allocated) return; + // NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0); + s->buffer.allocated -= (nk_size)len; + s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated); +} +NK_API void +nk_str_remove_runes(struct nk_str *str, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_remove_runes"); + int index; + const char *begin; + const char *end; + nk_rune unicode; + + // NK_ASSERT(str); + // NK_ASSERT(len >= 0); + if (!str || len < 0) return; + if (len >= str->len) { + str->len = 0; + return; + } + + index = str->len - len; + begin = nk_str_at_rune(str, index, &unicode, &len); + end = (const char*)str->buffer.memory.ptr + str->buffer.allocated; + nk_str_remove_chars(str, (int)(end-begin)+1); +} +NK_API void +nk_str_delete_chars(struct nk_str *s, int pos, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_delete_chars"); + // NK_ASSERT(s); + if (!s || !len || (nk_size)pos > s->buffer.allocated || + (nk_size)(pos + len) > s->buffer.allocated) return; + + if ((nk_size)(pos + len) < s->buffer.allocated) { + /* memmove */ + char *dst = nk_ptr_add(char, s->buffer.memory.ptr, pos); + char *src = nk_ptr_add(char, s->buffer.memory.ptr, pos + len); + NK_MEMCPY(dst, src, s->buffer.allocated - (nk_size)(pos + len)); + // NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0); + s->buffer.allocated -= (nk_size)len; + } else nk_str_remove_chars(s, len); + s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated); +} +NK_API void +nk_str_delete_runes(struct nk_str *s, int pos, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_delete_runes"); + char *temp; + nk_rune unicode; + char *begin; + char *end; + int unused; + + // NK_ASSERT(s); + // NK_ASSERT(s->len >= pos + len); + if (s->len < pos + len) + len = NK_CLAMP(0, (s->len - pos), s->len); + if (!len) return; + + temp = (char *)s->buffer.memory.ptr; + begin = nk_str_at_rune(s, pos, &unicode, &unused); + if (!begin) return; + s->buffer.memory.ptr = begin; + end = nk_str_at_rune(s, len, &unicode, &unused); + s->buffer.memory.ptr = temp; + if (!end) return; + nk_str_delete_chars(s, (int)(begin - temp), (int)(end - begin)); +} +NK_API char* +nk_str_at_char(struct nk_str *s, int pos) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_at_char"); + // NK_ASSERT(s); + if (!s || pos > (int)s->buffer.allocated) return 0; + return nk_ptr_add(char, s->buffer.memory.ptr, pos); +} +NK_API char* +nk_str_at_rune(struct nk_str *str, int pos, nk_rune *unicode, int *len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_at_rune"); + return (char*)str->buffer.memory.ptr + strlen((char*)str->buffer.memory.ptr); +} +NK_API const char* +nk_str_at_char_const(const struct nk_str *s, int pos) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_str_at_char_const"); + // NK_ASSERT(s); + if (!s || pos > (int)s->buffer.allocated) return 0; + return nk_ptr_add(char, s->buffer.memory.ptr, pos); +} +NK_API const char* +nk_str_at_const(const struct nk_str *str, int pos, nk_rune *unicode, int *len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_str_at_const"); + int i = 0; + int src_len = 0; + int glyph_len = 0; + char *text; + int text_len; + + // NK_ASSERT(str); + // NK_ASSERT(unicode); + // NK_ASSERT(len); + + if (!str || !unicode || !len) return 0; + if (pos < 0) { + *unicode = 0; + *len = 0; + return 0; + } + + text = (char*)str->buffer.memory.ptr; + text_len = (int)str->buffer.allocated; + glyph_len = nk_utf_decode(text, unicode, text_len); + //writeSerialPort(boutRefNum, "nk_str_at_const"); + while (glyph_len) { + if (i == pos) { + *len = glyph_len; + break; + } + + i++; + src_len = src_len + glyph_len; + glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len); + } + if (i != pos) return 0; + return text + src_len; +} +NK_API nk_rune +nk_str_rune_at(const struct nk_str *str, int pos) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_str_rune_at"); + int len; + nk_rune unicode = 0; + nk_str_at_const(str, pos, &unicode, &len); + return unicode; +} +NK_API char* +nk_str_get(struct nk_str *s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_get"); + // NK_ASSERT(s); + if (!s || !s->len || !s->buffer.allocated) return 0; + return (char*)s->buffer.memory.ptr; +} +NK_API const char* +nk_str_get_const(const struct nk_str *s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_str_get_const"); + // NK_ASSERT(s); + if (!s || !s->len || !s->buffer.allocated) return 0; + return (const char*)s->buffer.memory.ptr; +} +NK_API int +nk_str_len(struct nk_str *s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_len"); + // NK_ASSERT(s); + if (!s || !s->len || !s->buffer.allocated) return 0; + return s->len; +} +NK_API int +nk_str_len_char(struct nk_str *s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_len_char"); + // NK_ASSERT(s); + if (!s || !s->len || !s->buffer.allocated) return 0; + return (int)s->buffer.allocated; +} +NK_API void +nk_str_clear(struct nk_str *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_clear"); + // NK_ASSERT(str); + nk_buffer_clear(&str->buffer); + str->len = 0; +} +NK_API void +nk_str_free(struct nk_str *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_str / nk_str_free"); + // NK_ASSERT(str); + nk_buffer_free(&str->buffer); + str->len = 0; +} + + + + + +/* ============================================================== + * + * DRAW + * + * ===============================================================*/ +NK_LIB void +nk_command_buffer_init(struct nk_command_buffer *cb, + struct nk_buffer *b, enum nk_command_clipping clip) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_command_buffer_init"); + // NK_ASSERT(cb); + // NK_ASSERT(b); + if (!cb || !b) return; + cb->base = b; + cb->use_clipping = (int)clip; + cb->begin = b->allocated; + cb->end = b->allocated; + cb->last = b->allocated; +} +NK_LIB void +nk_command_buffer_reset(struct nk_command_buffer *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_command_buffer / nk_command_buffer_reset"); + // NK_ASSERT(b); + if (!b) return; + b->begin = 0; + b->end = 0; + b->last = 0; + b->clip = nk_null_rect; +#ifdef NK_INCLUDE_COMMAND_USERDATA + b->userdata.ptr = 0; +#endif +} +NK_LIB void* +nk_command_buffer_push(struct nk_command_buffer* b, + enum nk_command_type t, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_command_buffer_push"); + NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_command); + struct nk_command *cmd; + nk_size alignment; + void *unaligned; + void *memory; + + if (!b) return 0; + cmd = (struct nk_command*)nk_buffer_alloc(b->base,NK_BUFFER_FRONT,size,align); + if (!cmd) return 0; + + /* make sure the offset to the next command is aligned */ + b->last = (nk_size)((nk_byte*)cmd - (nk_byte*)b->base->memory.ptr); + unaligned = (nk_byte*)cmd + size; + memory = NK_ALIGN_PTR(unaligned, align); + alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned); +#ifdef NK_ZERO_COMMAND_MEMORY + NK_MEMSET(cmd, 0, size + alignment); +#endif + + cmd->type = t; + cmd->next = b->base->allocated + alignment; +#ifdef NK_INCLUDE_COMMAND_USERDATA + cmd->userdata = b->userdata; +#endif + b->end = cmd->next; + return cmd; +} +NK_API void +nk_push_scissor(struct nk_command_buffer *b, struct nk_rect r) +{ + // //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_command_buffer / nk_push_scissor"); + struct nk_command_scissor *cmd; + // NK_ASSERT(b); + if (!b) return; + + b->clip.x = r.x; + b->clip.y = r.y; + b->clip.w = r.w; + b->clip.h = r.h; + cmd = (struct nk_command_scissor*) + nk_command_buffer_push(b, NK_COMMAND_SCISSOR, sizeof(*cmd)); + + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(0, r.w); + cmd->h = (unsigned short)NK_MAX(0, r.h); +} +NK_API void +nk_stroke_line(struct nk_command_buffer *b, int x0, int y0, + int x1, int y1, int line_thickness, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_line"); + struct nk_command_line *cmd; + + if (!b || line_thickness <= 0) return; + cmd = (struct nk_command_line*) + nk_command_buffer_push(b, NK_COMMAND_LINE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->begin.x = (short)x0; + cmd->begin.y = (short)y0; + cmd->end.x = (short)x1; + cmd->end.y = (short)y1; + cmd->color = c; +} +NK_API void +nk_stroke_curve(struct nk_command_buffer *b, int ax, int ay, + int ctrl0x, int ctrl0y, int ctrl1x, int ctrl1y, + int bx, int by, int line_thickness, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - bx, / int"); + struct nk_command_curve *cmd; + // NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + + cmd = (struct nk_command_curve*) + nk_command_buffer_push(b, NK_COMMAND_CURVE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->begin.x = (short)ax; + cmd->begin.y = (short)ay; + cmd->ctrl[0].x = (short)ctrl0x; + cmd->ctrl[0].y = (short)ctrl0y; + cmd->ctrl[1].x = (short)ctrl1x; + cmd->ctrl[1].y = (short)ctrl1y; + cmd->end.x = (short)bx; + cmd->end.y = (short)by; + cmd->color = col; +} +NK_API void +nk_stroke_rect(struct nk_command_buffer *b, struct nk_rect rect, + int rounding, int line_thickness, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_rect"); + struct nk_command_rect *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + cmd = (struct nk_command_rect*) + nk_command_buffer_push(b, NK_COMMAND_RECT, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->x = (short)rect.x; + cmd->y = (short)rect.y; + cmd->w = (unsigned short)NK_MAX(0, rect.w); + cmd->h = (unsigned short)NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect(struct nk_command_buffer *b, struct nk_rect rect, + int rounding, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_fill_rect"); + struct nk_command_rect_filled *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_filled*) + nk_command_buffer_push(b, NK_COMMAND_RECT_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)rect.x; + cmd->y = (short)rect.y; + cmd->w = (unsigned short)NK_MAX(0, rect.w); + cmd->h = (unsigned short)NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect_multi_color(struct nk_command_buffer *b, struct nk_rect rect, + struct nk_color left, struct nk_color top, struct nk_color right, + struct nk_color bottom) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_fill_rect_multi_color"); + struct nk_command_rect_multi_color *cmd; + // NK_ASSERT(b); + if (!b || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_multi_color*) + nk_command_buffer_push(b, NK_COMMAND_RECT_MULTI_COLOR, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)rect.x; + cmd->y = (short)rect.y; + cmd->w = (unsigned short)NK_MAX(0, rect.w); + cmd->h = (unsigned short)NK_MAX(0, rect.h); + cmd->left = left; + cmd->top = top; + cmd->right = right; + cmd->bottom = bottom; +} +NK_API void +nk_stroke_circle(struct nk_command_buffer *b, struct nk_rect r, + int line_thickness, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_circle"); + struct nk_command_circle *cmd; + if (!b || r.w == 0 || r.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(r.w, 0); + cmd->h = (unsigned short)NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_fill_circle(struct nk_command_buffer *b, struct nk_rect r, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL -nk_fill_circlee"); + struct nk_command_circle_filled *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0 || r.w == 0 || r.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle_filled*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(r.w, 0); + cmd->h = (unsigned short)NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_stroke_arc(struct nk_command_buffer *b, int cx, int cy, int radius, + int a_min, int a_max, int line_thickness, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_arc"); + struct nk_command_arc *cmd; + if (!b || c.a == 0 || line_thickness <= 0) return; + cmd = (struct nk_command_arc*) + nk_command_buffer_push(b, NK_COMMAND_ARC, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->cx = (short)cx; + cmd->cy = (short)cy; + cmd->r = (unsigned short)radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_fill_arc(struct nk_command_buffer *b, int cx, int cy, int radius, + int a_min, int a_max, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_fill_arc"); + struct nk_command_arc_filled *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0) return; + cmd = (struct nk_command_arc_filled*) + nk_command_buffer_push(b, NK_COMMAND_ARC_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->cx = (short)cx; + cmd->cy = (short)cy; + cmd->r = (unsigned short)radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_stroke_triangle(struct nk_command_buffer *b, int x0, int y0, int x1, + int y1, int x2, int y2, int line_thickness, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_triangle"); + struct nk_command_triangle *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->a.x = (short)x0; + cmd->a.y = (short)y0; + cmd->b.x = (short)x1; + cmd->b.y = (short)y1; + cmd->c.x = (short)x2; + cmd->c.y = (short)y2; + cmd->color = c; +} +NK_API void +nk_fill_triangle(struct nk_command_buffer *b, int x0, int y0, int x1, + int y1, int x2, int y2, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_fill_triangle"); + struct nk_command_triangle_filled *cmd; + // NK_ASSERT(b); + if (!b || c.a == 0) return; + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle_filled*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->a.x = (short)x0; + cmd->a.y = (short)y0; + cmd->b.x = (short)x1; + cmd->b.y = (short)y1; + cmd->c.x = (short)x2; + cmd->c.y = (short)y2; + cmd->color = c; +} +NK_API void +nk_stroke_polygon(struct nk_command_buffer *b, int *points, int point_count, + int line_thickness, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - line_thickness, / int"); + int i; + nk_size size = 0; + struct nk_command_polygon *cmd; + + // NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size); + if (!cmd) return; + cmd->color = col; + cmd->line_thickness = (unsigned short)line_thickness; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = (short)points[i*2]; + cmd->points[i].y = (short)points[i*2+1]; + } +} +NK_API void +nk_fill_polygon(struct nk_command_buffer *b, int *points, int point_count, + struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_fill_polygon"); + int i; + nk_size size = 0; + struct nk_command_polygon_filled *cmd; + + // NK_ASSERT(b); + if (!b || col.a == 0) return; + size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon_filled*) + nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = (short)points[i*2+0]; + cmd->points[i].y = (short)points[i*2+1]; + } +} +NK_API void +nk_stroke_polyline(struct nk_command_buffer *b, int *points, int point_count, + int line_thickness, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_stroke_polyline"); + int i; + nk_size size = 0; + struct nk_command_polyline *cmd; + + // NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + cmd->line_thickness = (unsigned short)line_thickness; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = (short)points[i*2]; + cmd->points[i].y = (short)points[i*2+1]; + } +} +NK_API void +nk_draw_image(struct nk_command_buffer *b, struct nk_rect r, + const struct nk_image *img, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_image"); + struct nk_command_image *cmd; + // NK_ASSERT(b); + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + cmd = (struct nk_command_image*) + nk_command_buffer_push(b, NK_COMMAND_IMAGE, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(0, r.w); + cmd->h = (unsigned short)NK_MAX(0, r.h); + cmd->img = *img; + cmd->col = col; +} +NK_API void +nk_push_custom(struct nk_command_buffer *b, struct nk_rect r, + nk_command_custom_callback cb, nk_handle usr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_push_custom"); + struct nk_command_custom *cmd; + // NK_ASSERT(b); + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + cmd = (struct nk_command_custom*) + nk_command_buffer_push(b, NK_COMMAND_CUSTOM, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(0, r.w); + cmd->h = (unsigned short)NK_MAX(0, r.h); + cmd->callback_data = usr; + cmd->callback = cb; +} +NK_API void +nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, + const char *string, int length, const struct nk_user_font *font, + struct nk_color bg, struct nk_color fg) +{ + + + // long start; + // long end; + // long total; + // long eventTime0; + + // start = TickCount(); + + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_text"); + int text_width = 0; + struct nk_command_text *cmd; + + // NK_ASSERT(b); + // NK_ASSERT(font); + if (!b || !string || !length || (bg.a == 0 && fg.a == 0)) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + /* make sure text fits inside bounds */ + text_width = font->width(font->userdata, font->height, string, length); + if (text_width > r.w){ + int glyphs = 0; + int txt_width = (int)text_width; + length = nk_text_clamp(font, string, length, r.w, &glyphs, &txt_width, 0,0); + } + + if (!length) return; + cmd = (struct nk_command_text*) + nk_command_buffer_push(b, NK_COMMAND_TEXT, sizeof(*cmd) + (nk_size)(length + 1)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)r.w; + cmd->h = (unsigned short)r.h; + cmd->background = bg; + cmd->foreground = fg; + cmd->font = font; + cmd->length = length; + cmd->height = font->height; + NK_MEMCPY(cmd->string, string, (nk_size)length); + cmd->string[length] = '\0'; + // end = TickCount(); + + // total = end - start; + // eventTime0 = total;// / 60.0; + + //// char logx[255]; + //// sprintf(logx, "text draw time() eventTime0 (draw text) %ld\n", eventTime0); + // // writeSerialPort(boutRefNum, logx); +} + + + + + +/* =============================================================== + * + * VERTEX + * + * ===============================================================*/ +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT +NK_API void +nk_draw_list_init(struct nk_draw_list *list) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_init"); + nk_size i = 0; + // NK_ASSERT(list); + if (!list) return; + nk_zero(list, sizeof(*list)); + for (i = 0; i < NK_LEN(list->circle_vtx); ++i) { + const int a = ((int)i / (int)NK_LEN(list->circle_vtx)) * 2 * NK_PI; + list->circle_vtx[i].x = (int)NK_COS(a); + list->circle_vtx[i].y = (int)NK_SIN(a); + } +} +NK_API void +nk_draw_list_setup(struct nk_draw_list *canvas, const struct nk_convert_config *config, + struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements, + enum nk_anti_aliasing line_aa, enum nk_anti_aliasing shape_aa) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list_setup"); + // NK_ASSERT(canvas); + // NK_ASSERT(config); + // NK_ASSERT(cmds); + // NK_ASSERT(vertices); + // NK_ASSERT(elements); + if (!canvas || !config || !cmds || !vertices || !elements) + return; + + canvas->buffer = cmds; + canvas->config = *config; + canvas->elements = elements; + canvas->vertices = vertices; + canvas->line_AA = line_aa; + canvas->shape_AA = shape_aa; + canvas->clip_rect = nk_null_rect; + + canvas->cmd_offset = 0; + canvas->element_count = 0; + canvas->vertex_count = 0; + canvas->cmd_offset = 0; + canvas->cmd_count = 0; + canvas->path_count = 0; +} +NK_API const struct nk_draw_command* +nk__draw_list_begin(const struct nk_draw_list *canvas, const struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk__draw_list_begin"); + nk_byte *memory; + nk_size offset; + const struct nk_draw_command *cmd; + + // NK_ASSERT(buffer); + if (!buffer || !buffer->size || !canvas->cmd_count) + return 0; + + memory = (nk_byte*)buffer->memory.ptr; + offset = buffer->memory.size - canvas->cmd_offset; + cmd = nk_ptr_add(const struct nk_draw_command, memory, offset); + return cmd; +} +NK_API const struct nk_draw_command* +nk__draw_list_end(const struct nk_draw_list *canvas, const struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk__draw_list_end"); + nk_size size; + nk_size offset; + nk_byte *memory; + const struct nk_draw_command *end; + + // NK_ASSERT(buffer); + // NK_ASSERT(canvas); + if (!buffer || !canvas) + return 0; + + memory = (nk_byte*)buffer->memory.ptr; + size = buffer->memory.size; + offset = size - canvas->cmd_offset; + end = nk_ptr_add(const struct nk_draw_command, memory, offset); + end -= (canvas->cmd_count-1); + return end; +} +NK_API const struct nk_draw_command* +nk__draw_list_next(const struct nk_draw_command *cmd, + const struct nk_buffer *buffer, const struct nk_draw_list *canvas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / const"); + const struct nk_draw_command *end; + // NK_ASSERT(buffer); + // NK_ASSERT(canvas); + if (!cmd || !buffer || !canvas) + return 0; + + end = nk__draw_list_end(canvas, buffer); + if (cmd <= end) return 0; + return (cmd-1); +} +NK_INTERN struct nk_vec2* +nk_draw_list_alloc_path(struct nk_draw_list *list, int count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_alloc_path"); + struct nk_vec2 *points; + NK_STORAGE const nk_size point_align = NK_ALIGNOF(struct nk_vec2); + NK_STORAGE const nk_size point_size = sizeof(struct nk_vec2); + points = (struct nk_vec2*) + nk_buffer_alloc(list->buffer, NK_BUFFER_FRONT, + point_size * (nk_size)count, point_align); + + if (!points) return 0; + if (!list->path_offset) { + void *memory = nk_buffer_memory(list->buffer); + list->path_offset = (unsigned int)((nk_byte*)points - (nk_byte*)memory); + } + list->path_count += (unsigned int)count; + return points; +} +NK_INTERN struct nk_vec2 +nk_draw_list_path_last(struct nk_draw_list *list) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_path_last"); + void *memory; + struct nk_vec2 *point; + // NK_ASSERT(list->path_count); + memory = nk_buffer_memory(list->buffer); + point = nk_ptr_add(struct nk_vec2, memory, list->path_offset); + point += (list->path_count-1); + return *point; +} +NK_INTERN struct nk_draw_command* +nk_draw_list_push_command(struct nk_draw_list *list, struct nk_rect clip, + nk_handle texture) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - texture) / nk_handle"); + NK_STORAGE const nk_size cmd_align = NK_ALIGNOF(struct nk_draw_command); + NK_STORAGE const nk_size cmd_size = sizeof(struct nk_draw_command); + struct nk_draw_command *cmd; + + // NK_ASSERT(list); + cmd = (struct nk_draw_command*) + nk_buffer_alloc(list->buffer, NK_BUFFER_BACK, cmd_size, cmd_align); + + if (!cmd) return 0; + if (!list->cmd_count) { + nk_byte *memory = (nk_byte*)nk_buffer_memory(list->buffer); + nk_size total = nk_buffer_total(list->buffer); + memory = nk_ptr_add(nk_byte, memory, total); + list->cmd_offset = (nk_size)(memory - (nk_byte*)cmd); + } + + cmd->elem_count = 0; + cmd->clip_rect = clip; + cmd->texture = texture; +#ifdef NK_INCLUDE_COMMAND_USERDATA + cmd->userdata = list->userdata; +#endif + + list->cmd_count++; + list->clip_rect = clip; + return cmd; +} +NK_INTERN struct nk_draw_command* +nk_draw_list_command_last(struct nk_draw_list *list) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_command_last"); + void *memory; + nk_size size; + struct nk_draw_command *cmd; + // NK_ASSERT(list->cmd_count); + + memory = nk_buffer_memory(list->buffer); + size = nk_buffer_total(list->buffer); + cmd = nk_ptr_add(struct nk_draw_command, memory, size - list->cmd_offset); + return (cmd - (list->cmd_count-1)); +} +NK_INTERN void +nk_draw_list_add_clip(struct nk_draw_list *list, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_add_clip"); + // NK_ASSERT(list); + if (!list) return; + if (!list->cmd_count) { + nk_draw_list_push_command(list, rect, list->config.null.texture); + } else { + struct nk_draw_command *prev = nk_draw_list_command_last(list); + if (prev->elem_count == 0) + prev->clip_rect = rect; + nk_draw_list_push_command(list, rect, prev->texture); + } +} +NK_INTERN void +nk_draw_list_push_image(struct nk_draw_list *list, nk_handle texture) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_push_image"); + // NK_ASSERT(list); + if (!list) return; + if (!list->cmd_count) { + nk_draw_list_push_command(list, nk_null_rect, texture); + } else { + struct nk_draw_command *prev = nk_draw_list_command_last(list); + if (prev->elem_count == 0) { + prev->texture = texture; + #ifdef NK_INCLUDE_COMMAND_USERDATA + prev->userdata = list->userdata; + #endif + } else if (prev->texture.id != texture.id + #ifdef NK_INCLUDE_COMMAND_USERDATA + || prev->userdata.id != list->userdata.id + #endif + ) nk_draw_list_push_command(list, prev->clip_rect, texture); + } +} +#ifdef NK_INCLUDE_COMMAND_USERDATA +NK_API void +nk_draw_list_push_userdata(struct nk_draw_list *list, nk_handle userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_push_userdata"); + list->userdata = userdata; +} +#endif +NK_INTERN void* +nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_alloc_vertices"); + void *vtx; + // NK_ASSERT(list); + if (!list) return 0; + vtx = nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, + list->config.vertex_size*count, list->config.vertex_alignment); + if (!vtx) return 0; + list->vertex_count += (unsigned int)count; + + /* This assert triggers because your are drawing a lot of stuff and nuklear + * defined `nk_draw_index` as `nk_ushort` to safe space be default. + * + * So you reached the maximum number of indicies or rather vertexes. + * To solve this issue please change typdef `nk_draw_index` to `nk_uint` + * and don't forget to specify the new element size in your drawing + * backend (OpenGL, DirectX, ...). For example in OpenGL for `glDrawElements` + * instead of specifing `GL_UNSIGNED_SHORT` you have to define `GL_UNSIGNED_INT`. + * Sorry for the inconvenience. */ + if(sizeof(nk_draw_index)==2) // NK_ASSERT((list->vertex_count < NK_USHORT_MAX && "To many verticies for 16-bit vertex indicies. Please read comment above on how to solve this problem")); + return vtx; +} +NK_INTERN nk_draw_index* +nk_draw_list_alloc_elements(struct nk_draw_list *list, nk_size count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_alloc_elements"); + nk_draw_index *ids; + struct nk_draw_command *cmd; + NK_STORAGE const nk_size elem_align = NK_ALIGNOF(nk_draw_index); + NK_STORAGE const nk_size elem_size = sizeof(nk_draw_index); + // NK_ASSERT(list); + if (!list) return 0; + + ids = (nk_draw_index*) + nk_buffer_alloc(list->elements, NK_BUFFER_FRONT, elem_size*count, elem_align); + if (!ids) return 0; + cmd = nk_draw_list_command_last(list); + list->element_count += (unsigned int)count; + cmd->elem_count += (unsigned int)count; + return ids; +} +NK_INTERN int +nk_draw_vertex_layout_element_is_end_of_layout( + const struct nk_draw_vertex_layout_element *element) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_vertex_layout_element / const"); + return (element->attribute == NK_VERTEX_ATTRIBUTE_COUNT || + element->format == NK_FORMAT_COUNT); +} +NK_INTERN void +nk_draw_vertex_color(void *attr, const int *vals, + enum nk_draw_vertex_layout_format format) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - format / enum"); + /* if this triggers you tried to provide a value format for a color */ + int val[4]; + // NK_ASSERT(format >= NK_FORMAT_COLOR_BEGIN); + // NK_ASSERT(format <= NK_FORMAT_COLOR_END); + if (format < NK_FORMAT_COLOR_BEGIN || format > NK_FORMAT_COLOR_END) return; + + val[0] = NK_SATURATE(vals[0]); + val[1] = NK_SATURATE(vals[1]); + val[2] = NK_SATURATE(vals[2]); + val[3] = NK_SATURATE(vals[3]); + + switch (format) { + default: break;// NK_ASSERT(0 && "Invalid vertex layout color format"); break; + case NK_FORMAT_R8G8B8A8: + case NK_FORMAT_R8G8B8: { + struct nk_color col = nk_rgba_fv(val); + NK_MEMCPY(attr, &col.r, sizeof(col)); + } break; + case NK_FORMAT_B8G8R8A8: { + struct nk_color col = nk_rgba_fv(val); + struct nk_color bgra = nk_rgba(col.b, col.g, col.r, col.a); + NK_MEMCPY(attr, &bgra, sizeof(bgra)); + } break; + case NK_FORMAT_R16G15B16: { + nk_ushort col[3]; + col[0] = (nk_ushort)(val[0]*(int)NK_USHORT_MAX); + col[1] = (nk_ushort)(val[1]*(int)NK_USHORT_MAX); + col[2] = (nk_ushort)(val[2]*(int)NK_USHORT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R16G15B16A16: { + nk_ushort col[4]; + col[0] = (nk_ushort)(val[0]*(int)NK_USHORT_MAX); + col[1] = (nk_ushort)(val[1]*(int)NK_USHORT_MAX); + col[2] = (nk_ushort)(val[2]*(int)NK_USHORT_MAX); + col[3] = (nk_ushort)(val[3]*(int)NK_USHORT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32: { + nk_uint col[3]; + col[0] = (nk_uint)(val[0]*(int)NK_UINT_MAX); + col[1] = (nk_uint)(val[1]*(int)NK_UINT_MAX); + col[2] = (nk_uint)(val[2]*(int)NK_UINT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32A32: { + nk_uint col[4]; + col[0] = (nk_uint)(val[0]*(int)NK_UINT_MAX); + col[1] = (nk_uint)(val[1]*(int)NK_UINT_MAX); + col[2] = (nk_uint)(val[2]*(int)NK_UINT_MAX); + col[3] = (nk_uint)(val[3]*(int)NK_UINT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32A32_int: + NK_MEMCPY(attr, val, sizeof(int)*4); + break; + case NK_FORMAT_R32G32B32A32_DOUBLE: { + double col[4]; + col[0] = (double)val[0]; + col[1] = (double)val[1]; + col[2] = (double)val[2]; + col[3] = (double)val[3]; + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_RGB32: + case NK_FORMAT_RGBA32: { + struct nk_color col = nk_rgba_fv(val); + nk_uint color = nk_color_u32(col); + NK_MEMCPY(attr, &color, sizeof(color)); + } break; } +} +NK_INTERN void +nk_draw_vertex_element(void *dst, const int *values, int value_count, + enum nk_draw_vertex_layout_format format) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - format / enum"); + int value_index; + void *attribute = dst; + /* if this triggers you tried to provide a color format for a value */ + // NK_ASSERT(format < NK_FORMAT_COLOR_BEGIN); + if (format >= NK_FORMAT_COLOR_BEGIN && format <= NK_FORMAT_COLOR_END) return; + for (value_index = 0; value_index < value_count; ++value_index) { + switch (format) { + default: // NK_ASSERT(0 && "invalid vertex layout format"); break; + case NK_FORMAT_SCHAR: { + char value = (char)NK_CLAMP((int)NK_SCHAR_MIN, values[value_index], (int)NK_SCHAR_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(char)); + } break; + case NK_FORMAT_SSHORT: { + nk_short value = (nk_short)NK_CLAMP((int)NK_SSHORT_MIN, values[value_index], (int)NK_SSHORT_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(value)); + } break; + case NK_FORMAT_SINT: { + nk_int value = (nk_int)NK_CLAMP((int)NK_SINT_MIN, values[value_index], (int)NK_SINT_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(nk_int)); + } break; + case NK_FORMAT_UCHAR: { + unsigned char value = (unsigned char)NK_CLAMP((int)NK_UCHAR_MIN, values[value_index], (int)NK_UCHAR_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(unsigned char)); + } break; + case NK_FORMAT_USHORT: { + nk_ushort value = (nk_ushort)NK_CLAMP((int)NK_USHORT_MIN, values[value_index], (int)NK_USHORT_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(value)); + } break; + case NK_FORMAT_UINT: { + nk_uint value = (nk_uint)NK_CLAMP((int)NK_UINT_MIN, values[value_index], (int)NK_UINT_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(nk_uint)); + } break; + case NK_FORMAT_int: + NK_MEMCPY(attribute, &values[value_index], sizeof(values[value_index])); + attribute = (void*)((char*)attribute + sizeof(int)); + break; + case NK_FORMAT_DOUBLE: { + double value = (double)values[value_index]; + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(double)); + } break; + } + } +} +NK_INTERN void* +nk_draw_vertex(void *dst, const struct nk_convert_config *config, + struct nk_vec2 pos, struct nk_vec2 uv, struct nk_colorf color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pos / struct"); + void *result = (void*)((char*)dst + config->vertex_size); + const struct nk_draw_vertex_layout_element *elem_iter = config->vertex_layout; + //writeSerialPort(boutRefNum, "nk_draw_vertex"); + while (!nk_draw_vertex_layout_element_is_end_of_layout(elem_iter)) { + void *address = (void*)((char*)dst + elem_iter->offset); + switch (elem_iter->attribute) { + case NK_VERTEX_ATTRIBUTE_COUNT: + default: // NK_ASSERT(0 && "wrong element attribute"); break; + case NK_VERTEX_POSITION: nk_draw_vertex_element(address, &pos.x, 2, elem_iter->format); break; + case NK_VERTEX_TEXCOORD: nk_draw_vertex_element(address, &uv.x, 2, elem_iter->format); break; + case NK_VERTEX_COLOR: nk_draw_vertex_color(address, &color.r, elem_iter->format); break; + } + elem_iter++; + } + return result; +} +NK_API void +nk_draw_list_stroke_poly_line(struct nk_draw_list *list, const struct nk_vec2 *points, + const unsigned int points_count, struct nk_color color, enum nk_draw_list_stroke closed, + int thickness, enum nk_anti_aliasing aliasing) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - thickness, / int"); + nk_size count; + int thick_line; + struct nk_colorf col; + struct nk_colorf col_trans; + // NK_ASSERT(list); + if (!list || points_count < 2) return; + + color.a = (nk_byte)((int)color.a * list->config.global_alpha); + count = points_count; + if (!closed) count = points_count-1; + thick_line = thickness > 1.0f; + +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_draw_list_push_userdata(list, list->userdata); +#endif + + color.a = (nk_byte)((int)color.a * list->config.global_alpha); + nk_color_fv(&col.r, color); + col_trans = col; + col_trans.a = 0; + + if (aliasing == NK_ANTI_ALIASING_ON) { + /* ANTI-ALIASED STROKE */ + const int AA_SIZE = 1.0f; + NK_STORAGE const nk_size pnt_align = NK_ALIGNOF(struct nk_vec2); + NK_STORAGE const nk_size pnt_size = sizeof(struct nk_vec2); + + /* allocate vertices and elements */ + nk_size i1 = 0; + nk_size vertex_offset; + nk_size index = list->vertex_count; + + const nk_size idx_count = (thick_line) ? (count * 18) : (count * 12); + const nk_size vtx_count = (thick_line) ? (points_count * 4): (points_count *3); + + void *vtx = nk_draw_list_alloc_vertices(list, vtx_count); + nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count); + + nk_size size; + struct nk_vec2 *normals, *temp; + if (!vtx || !ids) return; + + /* temporary allocate normals + points */ + vertex_offset = (nk_size)((nk_byte*)vtx - (nk_byte*)list->vertices->memory.ptr); + nk_buffer_mark(list->vertices, NK_BUFFER_FRONT); + size = pnt_size * ((thick_line) ? 5 : 3) * points_count; + normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align); + if (!normals) return; + temp = normals + points_count; + + /* make sure vertex pointer is still correct */ + vtx = (void*)((nk_byte*)list->vertices->memory.ptr + vertex_offset); + + /* calculate normals */ + for (i1 = 0; i1 < count; ++i1) { + const nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1); + struct nk_vec2 diff = nk_vec2_sub(points[i2], points[i1]); + int len; + + /* vec2 inverted length */ + len = nk_vec2_len_sqr(diff); + if (len != 0.0f) + len = nk_inv_sqrt(len); + else len = 1.0f; + + diff = nk_vec2_muls(diff, len); + normals[i1].x = diff.y; + normals[i1].y = -diff.x; + } + + if (!closed) + normals[points_count-1] = normals[points_count-2]; + + if (!thick_line) { + nk_size idx1, i; + if (!closed) { + struct nk_vec2 d; + temp[0] = nk_vec2_add(points[0], nk_vec2_muls(normals[0], AA_SIZE)); + temp[1] = nk_vec2_sub(points[0], nk_vec2_muls(normals[0], AA_SIZE)); + d = nk_vec2_muls(normals[points_count-1], AA_SIZE); + temp[(points_count-1) * 2 + 0] = nk_vec2_add(points[points_count-1], d); + temp[(points_count-1) * 2 + 1] = nk_vec2_sub(points[points_count-1], d); + } + + /* fill elements */ + idx1 = index; + for (i1 = 0; i1 < count; i1++) { + struct nk_vec2 dm; + int dmr2; + nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1); + nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 3); + + /* average normals */ + dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f); + dmr2 = dm.x * dm.x + dm.y* dm.y; + if (dmr2 > 0.000001f) { + int scale = 1.0f/dmr2; + scale = NK_MIN(100.0f, scale); + dm = nk_vec2_muls(dm, scale); + } + + dm = nk_vec2_muls(dm, AA_SIZE); + temp[i2*2+0] = nk_vec2_add(points[i2], dm); + temp[i2*2+1] = nk_vec2_sub(points[i2], dm); + + ids[0] = (nk_draw_index)(idx2 + 0); ids[1] = (nk_draw_index)(idx1+0); + ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2); + ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+0); + ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1); + ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0); + ids[10]= (nk_draw_index)(idx2 + 0); ids[11]= (nk_draw_index)(idx2+1); + ids += 12; + idx1 = idx2; + } + + /* fill vertices */ + for (i = 0; i < points_count; ++i) { + const struct nk_vec2 uv = list->config.null.uv; + vtx = nk_draw_vertex(vtx, &list->config, points[i], uv, col); + vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+0], uv, col_trans); + vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+1], uv, col_trans); + } + } else { + nk_size idx1, i; + const int half_inner_thickness = (thickness - AA_SIZE) * 0.5f; + if (!closed) { + struct nk_vec2 d1 = nk_vec2_muls(normals[0], half_inner_thickness + AA_SIZE); + struct nk_vec2 d2 = nk_vec2_muls(normals[0], half_inner_thickness); + + temp[0] = nk_vec2_add(points[0], d1); + temp[1] = nk_vec2_add(points[0], d2); + temp[2] = nk_vec2_sub(points[0], d2); + temp[3] = nk_vec2_sub(points[0], d1); + + d1 = nk_vec2_muls(normals[points_count-1], half_inner_thickness + AA_SIZE); + d2 = nk_vec2_muls(normals[points_count-1], half_inner_thickness); + + temp[(points_count-1)*4+0] = nk_vec2_add(points[points_count-1], d1); + temp[(points_count-1)*4+1] = nk_vec2_add(points[points_count-1], d2); + temp[(points_count-1)*4+2] = nk_vec2_sub(points[points_count-1], d2); + temp[(points_count-1)*4+3] = nk_vec2_sub(points[points_count-1], d1); + } + + /* add all elements */ + idx1 = index; + for (i1 = 0; i1 < count; ++i1) { + struct nk_vec2 dm_out, dm_in; + const nk_size i2 = ((i1+1) == points_count) ? 0: (i1 + 1); + nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 4); + + /* average normals */ + struct nk_vec2 dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f); + int dmr2 = dm.x * dm.x + dm.y* dm.y; + if (dmr2 > 0.000001f) { + int scale = 1.0f/dmr2; + scale = NK_MIN(100.0f, scale); + dm = nk_vec2_muls(dm, scale); + } + + dm_out = nk_vec2_muls(dm, ((half_inner_thickness) + AA_SIZE)); + dm_in = nk_vec2_muls(dm, half_inner_thickness); + temp[i2*4+0] = nk_vec2_add(points[i2], dm_out); + temp[i2*4+1] = nk_vec2_add(points[i2], dm_in); + temp[i2*4+2] = nk_vec2_sub(points[i2], dm_in); + temp[i2*4+3] = nk_vec2_sub(points[i2], dm_out); + + /* add indexes */ + ids[0] = (nk_draw_index)(idx2 + 1); ids[1] = (nk_draw_index)(idx1+1); + ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2); + ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+1); + ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1); + ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0); + ids[10]= (nk_draw_index)(idx2 + 0); ids[11] = (nk_draw_index)(idx2+1); + ids[12]= (nk_draw_index)(idx2 + 2); ids[13] = (nk_draw_index)(idx1+2); + ids[14]= (nk_draw_index)(idx1 + 3); ids[15] = (nk_draw_index)(idx1+3); + ids[16]= (nk_draw_index)(idx2 + 3); ids[17] = (nk_draw_index)(idx2+2); + ids += 18; + idx1 = idx2; + } + + /* add vertices */ + for (i = 0; i < points_count; ++i) { + const struct nk_vec2 uv = list->config.null.uv; + vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+0], uv, col_trans); + vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+1], uv, col); + vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+2], uv, col); + vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+3], uv, col_trans); + } + } + /* free temporary normals + points */ + nk_buffer_reset(list->vertices, NK_BUFFER_FRONT); + } else { + /* NON ANTI-ALIASED STROKE */ + nk_size i1 = 0; + nk_size idx = list->vertex_count; + const nk_size idx_count = count * 6; + const nk_size vtx_count = count * 4; + void *vtx = nk_draw_list_alloc_vertices(list, vtx_count); + nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count); + if (!vtx || !ids) return; + + for (i1 = 0; i1 < count; ++i1) { + int dx, dy; + const struct nk_vec2 uv = list->config.null.uv; + const nk_size i2 = ((i1+1) == points_count) ? 0 : i1 + 1; + const struct nk_vec2 p1 = points[i1]; + const struct nk_vec2 p2 = points[i2]; + struct nk_vec2 diff = nk_vec2_sub(p2, p1); + int len; + + /* vec2 inverted length */ + len = nk_vec2_len_sqr(diff); + if (len != 0.0f) + len = nk_inv_sqrt(len); + else len = 1.0f; + diff = nk_vec2_muls(diff, len); + + /* add vertices */ + dx = diff.x * (thickness * 0.5f); + dy = diff.y * (thickness * 0.5f); + + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x + dy, p1.y - dx), uv, col); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x + dy, p2.y - dx), uv, col); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x - dy, p2.y + dx), uv, col); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x - dy, p1.y + dx), uv, col); + + ids[0] = (nk_draw_index)(idx+0); ids[1] = (nk_draw_index)(idx+1); + ids[2] = (nk_draw_index)(idx+2); ids[3] = (nk_draw_index)(idx+0); + ids[4] = (nk_draw_index)(idx+2); ids[5] = (nk_draw_index)(idx+3); + + ids += 6; + idx += 4; + } + } +} +NK_API void +nk_draw_list_fill_poly_convex(struct nk_draw_list *list, + const struct nk_vec2 *points, const unsigned int points_count, + struct nk_color color, enum nk_anti_aliasing aliasing) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + struct nk_colorf col; + struct nk_colorf col_trans; + + NK_STORAGE const nk_size pnt_align = NK_ALIGNOF(struct nk_vec2); + NK_STORAGE const nk_size pnt_size = sizeof(struct nk_vec2); + // NK_ASSERT(list); + if (!list || points_count < 3) return; + +#ifdef NK_INCLUDE_COMMAND_USERDATA + nk_draw_list_push_userdata(list, list->userdata); +#endif + + color.a = (nk_byte)((int)color.a * list->config.global_alpha); + nk_color_fv(&col.r, color); + col_trans = col; + col_trans.a = 0; + + if (aliasing == NK_ANTI_ALIASING_ON) { + nk_size i = 0; + nk_size i0 = 0; + nk_size i1 = 0; + + const int AA_SIZE = 1.0f; + nk_size vertex_offset = 0; + nk_size index = list->vertex_count; + + const nk_size idx_count = (points_count-2)*3 + points_count*6; + const nk_size vtx_count = (points_count*2); + + void *vtx = nk_draw_list_alloc_vertices(list, vtx_count); + nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count); + + nk_size size = 0; + struct nk_vec2 *normals = 0; + unsigned int vtx_inner_idx = (unsigned int)(index + 0); + unsigned int vtx_outer_idx = (unsigned int)(index + 1); + if (!vtx || !ids) return; + + /* temporary allocate normals */ + vertex_offset = (nk_size)((nk_byte*)vtx - (nk_byte*)list->vertices->memory.ptr); + nk_buffer_mark(list->vertices, NK_BUFFER_FRONT); + size = pnt_size * points_count; + normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align); + if (!normals) return; + vtx = (void*)((nk_byte*)list->vertices->memory.ptr + vertex_offset); + + /* add elements */ + for (i = 2; i < points_count; i++) { + ids[0] = (nk_draw_index)(vtx_inner_idx); + ids[1] = (nk_draw_index)(vtx_inner_idx + ((i-1) << 1)); + ids[2] = (nk_draw_index)(vtx_inner_idx + (i << 1)); + ids += 3; + } + + /* compute normals */ + for (i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) { + struct nk_vec2 p0 = points[i0]; + struct nk_vec2 p1 = points[i1]; + struct nk_vec2 diff = nk_vec2_sub(p1, p0); + + /* vec2 inverted length */ + int len = nk_vec2_len_sqr(diff); + if (len != 0.0f) + len = nk_inv_sqrt(len); + else len = 1.0f; + diff = nk_vec2_muls(diff, len); + + normals[i0].x = diff.y; + normals[i0].y = -diff.x; + } + + /* add vertices + indexes */ + for (i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) { + const struct nk_vec2 uv = list->config.null.uv; + struct nk_vec2 n0 = normals[i0]; + struct nk_vec2 n1 = normals[i1]; + struct nk_vec2 dm = nk_vec2_muls(nk_vec2_add(n0, n1), 0.5f); + int dmr2 = dm.x*dm.x + dm.y*dm.y; + if (dmr2 > 0.000001f) { + int scale = 1.0f / dmr2; + scale = NK_MIN(scale, 100.0f); + dm = nk_vec2_muls(dm, scale); + } + dm = nk_vec2_muls(dm, AA_SIZE * 0.5f); + + /* add vertices */ + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2_sub(points[i1], dm), uv, col); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2_add(points[i1], dm), uv, col_trans); + + /* add indexes */ + ids[0] = (nk_draw_index)(vtx_inner_idx+(i1<<1)); + ids[1] = (nk_draw_index)(vtx_inner_idx+(i0<<1)); + ids[2] = (nk_draw_index)(vtx_outer_idx+(i0<<1)); + ids[3] = (nk_draw_index)(vtx_outer_idx+(i0<<1)); + ids[4] = (nk_draw_index)(vtx_outer_idx+(i1<<1)); + ids[5] = (nk_draw_index)(vtx_inner_idx+(i1<<1)); + ids += 6; + } + /* free temporary normals + points */ + nk_buffer_reset(list->vertices, NK_BUFFER_FRONT); + } else { + nk_size i = 0; + nk_size index = list->vertex_count; + const nk_size idx_count = (points_count-2)*3; + const nk_size vtx_count = points_count; + void *vtx = nk_draw_list_alloc_vertices(list, vtx_count); + nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count); + + if (!vtx || !ids) return; + for (i = 0; i < vtx_count; ++i) + vtx = nk_draw_vertex(vtx, &list->config, points[i], list->config.null.uv, col); + for (i = 2; i < points_count; ++i) { + ids[0] = (nk_draw_index)index; + ids[1] = (nk_draw_index)(index+ i - 1); + ids[2] = (nk_draw_index)(index+i); + ids += 3; + } + } +} +NK_API void +nk_draw_list_path_clear(struct nk_draw_list *list) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_path_clear"); + // NK_ASSERT(list); + if (!list) return; + nk_buffer_reset(list->buffer, NK_BUFFER_FRONT); + list->path_count = 0; + list->path_offset = 0; +} +NK_API void +nk_draw_list_path_line_to(struct nk_draw_list *list, struct nk_vec2 pos) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_path_line_to"); + struct nk_vec2 *points = 0; + struct nk_draw_command *cmd = 0; + // NK_ASSERT(list); + if (!list) return; + if (!list->cmd_count) + nk_draw_list_add_clip(list, nk_null_rect); + + cmd = nk_draw_list_command_last(list); + if (cmd && cmd->texture.ptr != list->config.null.texture.ptr) + nk_draw_list_push_image(list, list->config.null.texture); + + points = nk_draw_list_alloc_path(list, 1); + if (!points) return; + points[0] = pos; +} +NK_API void +nk_draw_list_path_arc_to_fast(struct nk_draw_list *list, struct nk_vec2 center, + int radius, int a_min, int a_max) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - radius, / int"); + int a = 0; + // NK_ASSERT(list); + if (!list) return; + if (a_min <= a_max) { + for (a = a_min; a <= a_max; a++) { + const struct nk_vec2 c = list->circle_vtx[(nk_size)a % NK_LEN(list->circle_vtx)]; + const int x = center.x + c.x * radius; + const int y = center.y + c.y * radius; + nk_draw_list_path_line_to(list, nk_vec2(x, y)); + } + } +} +NK_API void +nk_draw_list_path_arc_to(struct nk_draw_list *list, struct nk_vec2 center, + int radius, int a_min, int a_max, unsigned int segments) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - radius, / int"); + unsigned int i = 0; + // NK_ASSERT(list); + if (!list) return; + if (radius == 0.0f) return; + + /* This algorithm for arc drawing relies on these two trigonometric identities[1]: + sin(a + b) = sin(a) * cos(b) + cos(a) * sin(b) + cos(a + b) = cos(a) * cos(b) - sin(a) * sin(b) + + Two coordinates (x, y) of a point on a circle centered on + the origin can be written in polar form as: + x = r * cos(a) + y = r * sin(a) + where r is the radius of the circle, + a is the angle between (x, y) and the origin. + + This allows us to rotate the coordinates around the + origin by an angle b using the following transformation: + x' = r * cos(a + b) = x * cos(b) - y * sin(b) + y' = r * sin(a + b) = y * cos(b) + x * sin(b) + + [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Angle_sum_and_difference_identities + */ + {const int d_angle = (a_max - a_min) / (int)segments; + const int sin_d = (int)NK_SIN(d_angle); + const int cos_d = (int)NK_COS(d_angle); + + int cx = (int)NK_COS(a_min) * radius; + int cy = (int)NK_SIN(a_min) * radius; + for(i = 0; i <= segments; ++i) { + int new_cx, new_cy; + const int x = center.x + cx; + const int y = center.y + cy; + nk_draw_list_path_line_to(list, nk_vec2(x, y)); + + new_cx = cx * cos_d - cy * sin_d; + new_cy = cy * cos_d + cx * sin_d; + cx = new_cx; + cy = new_cy; + }} +} +NK_API void +nk_draw_list_path_rect_to(struct nk_draw_list *list, struct nk_vec2 a, + struct nk_vec2 b, int rounding) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list_path_rect_to"); + int r; + // NK_ASSERT(list); + if (!list) return; + r = rounding; + r = NK_MIN(r, ((b.x-a.x) < 0) ? -(b.x-a.x): (b.x-a.x)); + r = NK_MIN(r, ((b.y-a.y) < 0) ? -(b.y-a.y): (b.y-a.y)); + + if (r == 0.0f) { + nk_draw_list_path_line_to(list, a); + nk_draw_list_path_line_to(list, nk_vec2(b.x,a.y)); + nk_draw_list_path_line_to(list, b); + nk_draw_list_path_line_to(list, nk_vec2(a.x,b.y)); + } else { + nk_draw_list_path_arc_to_fast(list, nk_vec2(a.x + r, a.y + r), r, 6, 9); + nk_draw_list_path_arc_to_fast(list, nk_vec2(b.x - r, a.y + r), r, 9, 12); + nk_draw_list_path_arc_to_fast(list, nk_vec2(b.x - r, b.y - r), r, 0, 3); + nk_draw_list_path_arc_to_fast(list, nk_vec2(a.x + r, b.y - r), r, 3, 6); + } +} +NK_API void +nk_draw_list_path_curve_to(struct nk_draw_list *list, struct nk_vec2 p2, + struct nk_vec2 p3, struct nk_vec2 p4, unsigned int num_segments) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - p3 / struct"); + int t_step; + unsigned int i_step; + struct nk_vec2 p1; + + // NK_ASSERT(list); + // NK_ASSERT(list->path_count); + if (!list || !list->path_count) return; + num_segments = NK_MAX(num_segments, 1); + + p1 = nk_draw_list_path_last(list); + t_step = 1.0f/(int)num_segments; + for (i_step = 1; i_step <= num_segments; ++i_step) { + int t = t_step * (int)i_step; + int u = 1.0f - t; + int w1 = u*u*u; + int w2 = 3*u*u*t; + int w3 = 3*u*t*t; + int w4 = t * t *t; + int x = w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x; + int y = w1 * p1.y + w2 * p2.y + w3 * p3.y + w4 * p4.y; + nk_draw_list_path_line_to(list, nk_vec2(x,y)); + } +} +NK_API void +nk_draw_list_path_fill(struct nk_draw_list *list, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list / nk_draw_list_path_fill"); + struct nk_vec2 *points; + // NK_ASSERT(list); + if (!list) return; + points = (struct nk_vec2*)nk_buffer_memory(list->buffer); + nk_draw_list_fill_poly_convex(list, points, list->path_count, color, list->config.shape_AA); + nk_draw_list_path_clear(list); +} +NK_API void +nk_draw_list_path_stroke(struct nk_draw_list *list, struct nk_color color, + enum nk_draw_list_stroke closed, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - closed / enum"); + struct nk_vec2 *points; + // NK_ASSERT(list); + if (!list) return; + points = (struct nk_vec2*)nk_buffer_memory(list->buffer); + nk_draw_list_stroke_poly_line(list, points, list->path_count, color, + closed, thickness, list->config.line_AA); + nk_draw_list_path_clear(list); +} +NK_API void +nk_draw_list_stroke_line(struct nk_draw_list *list, struct nk_vec2 a, + struct nk_vec2 b, struct nk_color col, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list_stroke_line"); + // NK_ASSERT(list); + if (!list || !col.a) return; + if (list->line_AA == NK_ANTI_ALIASING_ON) { + nk_draw_list_path_line_to(list, a); + nk_draw_list_path_line_to(list, b); + } else { + nk_draw_list_path_line_to(list, nk_vec2_sub(a,nk_vec2(0.5f,0.5f))); + nk_draw_list_path_line_to(list, nk_vec2_sub(b,nk_vec2(0.5f,0.5f))); + } + nk_draw_list_path_stroke(list, col, NK_STROKE_OPEN, thickness); +} +NK_API void +nk_draw_list_fill_rect(struct nk_draw_list *list, struct nk_rect rect, + struct nk_color col, int rounding) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - col / struct"); + // NK_ASSERT(list); + if (!list || !col.a) return; + + if (list->line_AA == NK_ANTI_ALIASING_ON) { + nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y), + nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding); + } else { + nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f), + nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding); + } nk_draw_list_path_fill(list, col); +} +NK_API void +nk_draw_list_stroke_rect(struct nk_draw_list *list, struct nk_rect rect, + struct nk_color col, int rounding, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - col / struct"); + // NK_ASSERT(list); + if (!list || !col.a) return; + if (list->line_AA == NK_ANTI_ALIASING_ON) { + nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y), + nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding); + } else { + nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f), + nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding); + } nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness); +} +NK_API void +nk_draw_list_fill_rect_multi_color(struct nk_draw_list *list, struct nk_rect rect, + struct nk_color left, struct nk_color top, struct nk_color right, + struct nk_color bottom) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - bottom / struct"); + void *vtx; + struct nk_colorf col_left, col_top; + struct nk_colorf col_right, col_bottom; + nk_draw_index *idx; + nk_draw_index index; + + nk_color_fv(&col_left.r, left); + nk_color_fv(&col_right.r, right); + nk_color_fv(&col_top.r, top); + nk_color_fv(&col_bottom.r, bottom); + + // NK_ASSERT(list); + if (!list) return; + + nk_draw_list_push_image(list, list->config.null.texture); + index = (nk_draw_index)list->vertex_count; + vtx = nk_draw_list_alloc_vertices(list, 4); + idx = nk_draw_list_alloc_elements(list, 6); + if (!vtx || !idx) return; + + idx[0] = (nk_draw_index)(index+0); idx[1] = (nk_draw_index)(index+1); + idx[2] = (nk_draw_index)(index+2); idx[3] = (nk_draw_index)(index+0); + idx[4] = (nk_draw_index)(index+2); idx[5] = (nk_draw_index)(index+3); + + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x, rect.y), list->config.null.uv, col_left); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y), list->config.null.uv, col_top); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y + rect.h), list->config.null.uv, col_right); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x, rect.y + rect.h), list->config.null.uv, col_bottom); +} +NK_API void +nk_draw_list_fill_triangle(struct nk_draw_list *list, struct nk_vec2 a, + struct nk_vec2 b, struct nk_vec2 c, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list_fill_triangle"); + // NK_ASSERT(list); + if (!list || !col.a) return; + nk_draw_list_path_line_to(list, a); + nk_draw_list_path_line_to(list, b); + nk_draw_list_path_line_to(list, c); + nk_draw_list_path_fill(list, col); +} +NK_API void +nk_draw_list_stroke_triangle(struct nk_draw_list *list, struct nk_vec2 a, + struct nk_vec2 b, struct nk_vec2 c, struct nk_color col, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_list_stroke_triangle"); + // NK_ASSERT(list); + if (!list || !col.a) return; + nk_draw_list_path_line_to(list, a); + nk_draw_list_path_line_to(list, b); + nk_draw_list_path_line_to(list, c); + nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness); +} +NK_API void +nk_draw_list_fill_circle(struct nk_draw_list *list, struct nk_vec2 center, + int radius, struct nk_color col, unsigned int segs) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - radius, / int"); + int a_max; + // NK_ASSERT(list); + if (!list || !col.a) return; + a_max = NK_PI * 2.0f * ((int)segs - 1.0f) / (int)segs; + nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs); + nk_draw_list_path_fill(list, col); +} +NK_API void +nk_draw_list_stroke_circle(struct nk_draw_list *list, struct nk_vec2 center, + int radius, struct nk_color col, unsigned int segs, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - radius, / int"); + int a_max; + // NK_ASSERT(list); + if (!list || !col.a) return; + a_max = NK_PI * 2.0f * ((int)segs - 1.0f) / (int)segs; + nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs); + nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness); +} +NK_API void +nk_draw_list_stroke_curve(struct nk_draw_list *list, struct nk_vec2 p0, + struct nk_vec2 cp0, struct nk_vec2 cp1, struct nk_vec2 p1, + struct nk_color col, unsigned int segments, int thickness) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - col / struct"); + // NK_ASSERT(list); + if (!list || !col.a) return; + nk_draw_list_path_line_to(list, p0); + nk_draw_list_path_curve_to(list, cp0, cp1, p1, segments); + nk_draw_list_path_stroke(list, col, NK_STROKE_OPEN, thickness); +} +NK_INTERN void +nk_draw_list_push_rect_uv(struct nk_draw_list *list, struct nk_vec2 a, + struct nk_vec2 c, struct nk_vec2 uva, struct nk_vec2 uvc, + struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + void *vtx; + struct nk_vec2 uvb; + struct nk_vec2 uvd; + struct nk_vec2 b; + struct nk_vec2 d; + + struct nk_colorf col; + nk_draw_index *idx; + nk_draw_index index; + // NK_ASSERT(list); + if (!list) return; + + nk_color_fv(&col.r, color); + uvb = nk_vec2(uvc.x, uva.y); + uvd = nk_vec2(uva.x, uvc.y); + b = nk_vec2(c.x, a.y); + d = nk_vec2(a.x, c.y); + + index = (nk_draw_index)list->vertex_count; + vtx = nk_draw_list_alloc_vertices(list, 4); + idx = nk_draw_list_alloc_elements(list, 6); + if (!vtx || !idx) return; + + idx[0] = (nk_draw_index)(index+0); idx[1] = (nk_draw_index)(index+1); + idx[2] = (nk_draw_index)(index+2); idx[3] = (nk_draw_index)(index+0); + idx[4] = (nk_draw_index)(index+2); idx[5] = (nk_draw_index)(index+3); + + vtx = nk_draw_vertex(vtx, &list->config, a, uva, col); + vtx = nk_draw_vertex(vtx, &list->config, b, uvb, col); + vtx = nk_draw_vertex(vtx, &list->config, c, uvc, col); + vtx = nk_draw_vertex(vtx, &list->config, d, uvd, col); +} +NK_API void +nk_draw_list_add_image(struct nk_draw_list *list, struct nk_image texture, + struct nk_rect rect, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - rect / struct"); + // NK_ASSERT(list); + if (!list) return; + /* push new command with given texture */ + nk_draw_list_push_image(list, texture.handle); + if (nk_image_is_subimage(&texture)) { + /* add region inside of the texture */ + struct nk_vec2 uv[2]; + uv[0].x = (int)texture.region[0]/(int)texture.w; + uv[0].y = (int)texture.region[1]/(int)texture.h; + uv[1].x = (int)(texture.region[0] + texture.region[2])/(int)texture.w; + uv[1].y = (int)(texture.region[1] + texture.region[3])/(int)texture.h; + nk_draw_list_push_rect_uv(list, nk_vec2(rect.x, rect.y), + nk_vec2(rect.x + rect.w, rect.y + rect.h), uv[0], uv[1], color); + } else nk_draw_list_push_rect_uv(list, nk_vec2(rect.x, rect.y), + nk_vec2(rect.x + rect.w, rect.y + rect.h), + nk_vec2(0.0f, 0.0f), nk_vec2(1.0f, 1.0f),color); +} +NK_API void +nk_draw_list_add_text(struct nk_draw_list *list, const struct nk_user_font *font, + struct nk_rect rect, const char *text, int len, int font_height, + struct nk_color fg) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fg / struct"); + int x = 0; + int text_len = 0; + nk_rune unicode = 0; + nk_rune next = 0; + int glyph_len = 0; + int next_glyph_len = 0; + struct nk_user_font_glyph g; + + // NK_ASSERT(list); + if (!list || !len || !text) return; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + list->clip_rect.x, list->clip_rect.y, list->clip_rect.w, list->clip_rect.h)) return; + + nk_draw_list_push_image(list, font->texture); + x = rect.x; + glyph_len = nk_utf_decode(text, &unicode, len); + if (!glyph_len) return; + + /* draw every glyph image */ + fg.a = (nk_byte)((int)fg.a * list->config.global_alpha); + //writeSerialPort(boutRefNum, "nk_draw_list_add_text"); + while (text_len < len && glyph_len) { + int gx, gy, gh, gw; + int char_width = 0; + if (unicode == NK_UTF_INVALID) break; + + /* query currently drawn glyph information */ + next_glyph_len = nk_utf_decode(text + text_len + glyph_len, &next, (int)len - text_len); + font->query(font->userdata, font_height, &g, unicode, + (next == NK_UTF_INVALID) ? '\0' : next); + + /* calculate and draw glyph drawing rectangle and image */ + gx = x + g.offset.x; + gy = rect.y + g.offset.y; + gw = g.width; gh = g.height; + char_width = g.xadvance; + nk_draw_list_push_rect_uv(list, nk_vec2(gx,gy), nk_vec2(gx + gw, gy+ gh), + g.uv[0], g.uv[1], fg); + + /* offset next glyph */ + text_len += glyph_len; + x += char_width; + glyph_len = next_glyph_len; + unicode = next; + } +} +NK_API nk_flags +nk_convert(struct nk_context *ctx, struct nk_buffer *cmds, + struct nk_buffer *vertices, struct nk_buffer *elements, + const struct nk_convert_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_convert_config / const"); + nk_flags res = NK_CONVERT_SUCCESS; + const struct nk_command *cmd; + // NK_ASSERT(ctx); + // NK_ASSERT(cmds); + // NK_ASSERT(vertices); + // NK_ASSERT(elements); + // NK_ASSERT(config); + // NK_ASSERT(config->vertex_layout); + // NK_ASSERT(config->vertex_size); + if (!ctx || !cmds || !vertices || !elements || !config || !config->vertex_layout) + return NK_CONVERT_INVALID_PARAM; + + nk_draw_list_setup(&ctx->draw_list, config, cmds, vertices, elements, + config->line_AA, config->shape_AA); + nk_foreach(cmd, ctx) + { +#ifdef NK_INCLUDE_COMMAND_USERDATA + ctx->draw_list.userdata = cmd->userdata; +#endif + switch (cmd->type) { + case NK_COMMAND_NOP: break; + case NK_COMMAND_SCISSOR: { + const struct nk_command_scissor *s = (const struct nk_command_scissor*)cmd; + nk_draw_list_add_clip(&ctx->draw_list, nk_rect(s->x, s->y, s->w, s->h)); + } break; + case NK_COMMAND_LINE: { + const struct nk_command_line *l = (const struct nk_command_line*)cmd; + nk_draw_list_stroke_line(&ctx->draw_list, nk_vec2(l->begin.x, l->begin.y), + nk_vec2(l->end.x, l->end.y), l->color, l->line_thickness); + } break; + case NK_COMMAND_CURVE: { + const struct nk_command_curve *q = (const struct nk_command_curve*)cmd; + nk_draw_list_stroke_curve(&ctx->draw_list, nk_vec2(q->begin.x, q->begin.y), + nk_vec2(q->ctrl[0].x, q->ctrl[0].y), nk_vec2(q->ctrl[1].x, + q->ctrl[1].y), nk_vec2(q->end.x, q->end.y), q->color, + config->curve_segment_count, q->line_thickness); + } break; + case NK_COMMAND_RECT: { + const struct nk_command_rect *r = (const struct nk_command_rect*)cmd; + nk_draw_list_stroke_rect(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h), + r->color, (int)r->rounding, r->line_thickness); + } break; + case NK_COMMAND_RECT_FILLED: { + const struct nk_command_rect_filled *r = (const struct nk_command_rect_filled*)cmd; + nk_draw_list_fill_rect(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h), + r->color, (int)r->rounding); + } break; + case NK_COMMAND_RECT_MULTI_COLOR: { + const struct nk_command_rect_multi_color *r = (const struct nk_command_rect_multi_color*)cmd; + nk_draw_list_fill_rect_multi_color(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h), + r->left, r->top, r->right, r->bottom); + } break; + case NK_COMMAND_CIRCLE: { + const struct nk_command_circle *c = (const struct nk_command_circle*)cmd; + nk_draw_list_stroke_circle(&ctx->draw_list, nk_vec2((int)c->x + (int)c->w/2, + (int)c->y + (int)c->h/2), (int)c->w/2, c->color, + config->circle_segment_count, c->line_thickness); + } break; + case NK_COMMAND_CIRCLE_FILLED: { + const struct nk_command_circle_filled *c = (const struct nk_command_circle_filled *)cmd; + nk_draw_list_fill_circle(&ctx->draw_list, nk_vec2((int)c->x + (int)c->w/2, + (int)c->y + (int)c->h/2), (int)c->w/2, c->color, + config->circle_segment_count); + } break; + case NK_COMMAND_ARC: { + const struct nk_command_arc *c = (const struct nk_command_arc*)cmd; + nk_draw_list_path_line_to(&ctx->draw_list, nk_vec2(c->cx, c->cy)); + nk_draw_list_path_arc_to(&ctx->draw_list, nk_vec2(c->cx, c->cy), c->r, + c->a[0], c->a[1], config->arc_segment_count); + nk_draw_list_path_stroke(&ctx->draw_list, c->color, NK_STROKE_CLOSED, c->line_thickness); + } break; + case NK_COMMAND_ARC_FILLED: { + const struct nk_command_arc_filled *c = (const struct nk_command_arc_filled*)cmd; + nk_draw_list_path_line_to(&ctx->draw_list, nk_vec2(c->cx, c->cy)); + nk_draw_list_path_arc_to(&ctx->draw_list, nk_vec2(c->cx, c->cy), c->r, + c->a[0], c->a[1], config->arc_segment_count); + nk_draw_list_path_fill(&ctx->draw_list, c->color); + } break; + case NK_COMMAND_TRIANGLE: { + const struct nk_command_triangle *t = (const struct nk_command_triangle*)cmd; + nk_draw_list_stroke_triangle(&ctx->draw_list, nk_vec2(t->a.x, t->a.y), + nk_vec2(t->b.x, t->b.y), nk_vec2(t->c.x, t->c.y), t->color, + t->line_thickness); + } break; + case NK_COMMAND_TRIANGLE_FILLED: { + const struct nk_command_triangle_filled *t = (const struct nk_command_triangle_filled*)cmd; + nk_draw_list_fill_triangle(&ctx->draw_list, nk_vec2(t->a.x, t->a.y), + nk_vec2(t->b.x, t->b.y), nk_vec2(t->c.x, t->c.y), t->color); + } break; + case NK_COMMAND_POLYGON: { + int i; + const struct nk_command_polygon*p = (const struct nk_command_polygon*)cmd; + for (i = 0; i < p->point_count; ++i) { + struct nk_vec2 pnt = nk_vec2((int)p->points[i].x, (int)p->points[i].y); + nk_draw_list_path_line_to(&ctx->draw_list, pnt); + } + nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_CLOSED, p->line_thickness); + } break; + case NK_COMMAND_POLYGON_FILLED: { + int i; + const struct nk_command_polygon_filled *p = (const struct nk_command_polygon_filled*)cmd; + for (i = 0; i < p->point_count; ++i) { + struct nk_vec2 pnt = nk_vec2((int)p->points[i].x, (int)p->points[i].y); + nk_draw_list_path_line_to(&ctx->draw_list, pnt); + } + nk_draw_list_path_fill(&ctx->draw_list, p->color); + } break; + case NK_COMMAND_POLYLINE: { + int i; + const struct nk_command_polyline *p = (const struct nk_command_polyline*)cmd; + for (i = 0; i < p->point_count; ++i) { + struct nk_vec2 pnt = nk_vec2((int)p->points[i].x, (int)p->points[i].y); + nk_draw_list_path_line_to(&ctx->draw_list, pnt); + } + nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_OPEN, p->line_thickness); + } break; + case NK_COMMAND_TEXT: { + const struct nk_command_text *t = (const struct nk_command_text*)cmd; + nk_draw_list_add_text(&ctx->draw_list, t->font, nk_rect(t->x, t->y, t->w, t->h), + t->string, t->length, t->height, t->foreground); + } break; + case NK_COMMAND_IMAGE: { + const struct nk_command_image *i = (const struct nk_command_image*)cmd; + nk_draw_list_add_image(&ctx->draw_list, i->img, nk_rect(i->x, i->y, i->w, i->h), i->col); + } break; + case NK_COMMAND_CUSTOM: { + const struct nk_command_custom *c = (const struct nk_command_custom*)cmd; + c->callback(&ctx->draw_list, c->x, c->y, c->w, c->h, c->callback_data); + } break; + default: break; + } + } + res |= (cmds->needed > cmds->allocated + (cmds->memory.size - cmds->size)) ? NK_CONVERT_COMMAND_BUFFER_FULL: 0; + res |= (vertices->needed > vertices->allocated) ? NK_CONVERT_VERTEX_BUFFER_FULL: 0; + res |= (elements->needed > elements->allocated) ? NK_CONVERT_ELEMENT_BUFFER_FULL: 0; + return res; +} +NK_API const struct nk_draw_command* +nk__draw_begin(const struct nk_context *ctx, + const struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / const"); + return nk__draw_list_begin(&ctx->draw_list, buffer); +} +NK_API const struct nk_draw_command* +nk__draw_end(const struct nk_context *ctx, const struct nk_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk__draw_end"); + return nk__draw_list_end(&ctx->draw_list, buffer); +} +NK_API const struct nk_draw_command* +nk__draw_next(const struct nk_draw_command *cmd, + const struct nk_buffer *buffer, const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_buffer / const"); + return nk__draw_list_next(cmd, buffer, &ctx->draw_list); +} +#endif + + +/* stb_rect_pack.h - v1.00 - public domain - rectangle packing */ +/* Sean Barrett 2014 */ +/* */ +/* Useful for e.g. packing rectangular textures into an atlas. */ +/* Does not do rotation. */ +/* */ +/* Not necessarily the awesomest packing method, but better than */ +/* the totally naive one in stb_truetype (which is primarily what */ +/* this is meant to replace). */ +/* */ +/* Has only had a few tests run, may have issues. */ +/* */ +/* More docs to come. */ +/* */ +/* No memory allocations; uses qsort() and assert() from stdlib. */ +/* Can override those by defining STBRP_SORT and STBRP_ASSERT. */ +/* */ +/* This library currently uses the Skyline Bottom-Left algorithm. */ +/* */ +/* Please note: better rectangle packers are welcome! Please */ +/* implement them to the same API, but with a different init */ +/* function. */ +/* */ +/* Credits */ +/* */ +/* Library */ +/* Sean Barrett */ +/* Minor features */ +/* Martins Mozeiko */ +/* github:IntellectualKitty */ +/* */ +/* Bugfixes / warning fixes */ +/* Jeremy Jaussaud */ +/* Fabian Giesen */ +/* */ +/* Version history: */ +/* */ +/* 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles */ +/* 0.99 (2019-02-07) warning fixes */ +/* 0.11 (2017-03-03) return packing success/fail result */ +/* 0.10 (2016-10-25) remove cast-away-const to avoid warnings */ +/* 0.09 (2016-08-27) fix compiler warnings */ +/* 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) */ +/* 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) */ +/* 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort */ +/* 0.05: added STBRP_ASSERT to allow replacing assert */ +/* 0.04: fixed minor bug in STBRP_LARGE_RECTS support */ +/* 0.01: initial release */ +/* */ +/* LICENSE */ +/* */ +/* See end of file for license information. */ + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* INCLUDE SECTION */ +/* */ + +#ifndef STB_INCLUDE_STB_RECT_PACK_H +#define STB_INCLUDE_STB_RECT_PACK_H + +#define STB_RECT_PACK_VERSION 1 + +#ifdef STBRP_STATIC +#define STBRP_DEF static +#else +#define STBRP_DEF extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct stbrp_context stbrp_context; +typedef struct stbrp_node stbrp_node; +typedef struct stbrp_rect stbrp_rect; + +#ifdef STBRP_LARGE_RECTS +typedef int stbrp_coord; +#else +typedef unsigned short stbrp_coord; +#endif + +STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects); +/* Assign packed locations to rectangles. The rectangles are of type */ +/* 'stbrp_rect' defined below, stored in the array 'rects', and there */ +/* are 'num_rects' many of them. */ +/* */ +/* Rectangles which are successfully packed have the 'was_packed' flag */ +/* set to a non-zero value and 'x' and 'y' store the minimum location */ +/* on each axis (i.e. bottom-left in cartesian coordinates, top-left */ +/* if you imagine y increasing downwards). Rectangles which do not fit */ +/* have the 'was_packed' flag set to 0. */ +/* */ +/* You should not try to access the 'rects' array from another thread */ +/* while this function is running, as the function temporarily reorders */ +/* the array while it executes. */ +/* */ +/* To pack into another rectangle, you need to call stbrp_init_target */ +/* again. To continue packing into the same rectangle, you can call */ +/* this function again. Calling this multiple times with multiple rect */ +/* arrays will probably produce worse packing results than calling it */ +/* a single time with the full rectangle array, but the option is */ +/* available. */ +/* */ +/* The function returns 1 if all of the rectangles were successfully */ +/* packed and 0 otherwise. */ + +struct stbrp_rect +{ + /* reserved for your use: */ + int id; + + /* input: */ + stbrp_coord w, h; + + /* output: */ + stbrp_coord x, y; + int was_packed; /* non-zero if valid packing */ + +}; /* 16 bytes, nominally */ + + +STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes); +/* Initialize a rectangle packer to: */ +/* pack a rectangle that is 'width' by 'height' in dimensions */ +/* using temporary storage provided by the array 'nodes', which is 'num_nodes' long */ +/* */ +/* You must call this function every time you start packing into a new target. */ +/* */ +/* There is no "shutdown" function. The 'nodes' memory must stay valid for */ +/* the following stbrp_pack_rects() call (or calls), but can be freed after */ +/* the call (or calls) finish. */ +/* */ +/* Note: to guarantee best results, either: */ +/* 1. make sure 'num_nodes' >= 'width' */ +/* or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' */ +/* */ +/* If you don't do either of the above things, widths will be quantized to multiples */ +/* of small integers to guarantee the algorithm doesn't run out of temporary storage. */ +/* */ +/* If you do #2, then the non-quantized algorithm will be used, but the algorithm */ +/* may run out of temporary storage and be unable to pack some rectangles. */ + +STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem); +/* Optionally call this function after init but before doing any packing to */ +/* change the handling of the out-of-temp-memory scenario, described above. */ +/* If you call init again, this will be reset to the default (false). */ + + +STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic); +/* Optionally select which packing heuristic the library should use. Different */ +/* heuristics will produce better/worse results for different data sets. */ +/* If you call init again, this will be reset to the default. */ + +enum +{ + STBRP_HEURISTIC_Skyline_default=0, + STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default, + STBRP_HEURISTIC_Skyline_BF_sortHeight +}; + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* the details of the following structures don't matter to you, but they must */ +/* be visible so you can handle the memory allocations for them */ + +struct stbrp_node +{ + stbrp_coord x,y; + stbrp_node *next; +}; + +struct stbrp_context +{ + int width; + int height; + int align; + int init_mode; + int heuristic; + int num_nodes; + stbrp_node *active_head; + stbrp_node *free_head; + stbrp_node extra[2]; /* we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' */ +}; + +#ifdef __cplusplus +} +#endif + +#endif + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* IMPLEMENTATION SECTION */ +/* */ + +#ifdef STB_RECT_PACK_IMPLEMENTATION +#ifndef STBRP_SORT +#include +#define STBRP_SORT qsort +#endif + +#ifndef STBRP_ASSERT +#include +#define STBRP_ASSERT assert +#endif + +#ifdef _MSC_VER +#define STBRP__NOTUSED(v) (void)(v) +#else +#define STBRP__NOTUSED(v) (void)sizeof(v) +#endif + +enum +{ + STBRP__INIT_skyline = 1 +}; + +STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_setup_heuristic / STBRP_DEF"); + switch (context->init_mode) { + case STBRP__INIT_skyline: + STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight); + context->heuristic = heuristic; + break; + default: + STBRP_ASSERT(0); + } +} + +STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_setup_allow_out_of_mem / STBRP_DEF"); + if (allow_out_of_mem) + /* if it's ok to run out of memory, then don't bother aligning them; */ + /* this gives better packing, but may fail due to OOM (even though */ + /* the rectangles easily fit). @TODO a smarter approach would be to only */ + /* quantize once we've hit OOM, then we could get rid of this parameter. */ + context->align = 1; + else { + /* if it's not ok to run out of memory, then quantize the widths */ + /* so that num_nodes is always enough nodes. */ + /* */ + /* I.e. num_nodes * align >= width */ + /* align >= width / num_nodes */ + /* align = ceil(width/num_nodes) */ + + context->align = (context->width + context->num_nodes-1) / context->num_nodes; + } +} + +STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_init_target / STBRP_DEF"); + int i; +#ifndef STBRP_LARGE_RECTS + STBRP_ASSERT(width <= 0xffff && height <= 0xffff); +#endif + + for (i=0; i < num_nodes-1; ++i) + nodes[i].next = &nodes[i+1]; + nodes[i].next = NULL; + context->init_mode = STBRP__INIT_skyline; + context->heuristic = STBRP_HEURISTIC_Skyline_default; + context->free_head = &nodes[0]; + context->active_head = &context->extra[0]; + context->width = width; + context->height = height; + context->num_nodes = num_nodes; + stbrp_setup_allow_out_of_mem(context, 0); + + /* node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) */ + context->extra[0].x = 0; + context->extra[0].y = 0; + context->extra[0].next = &context->extra[1]; + context->extra[1].x = (stbrp_coord) width; +#ifdef STBRP_LARGE_RECTS + context->extra[1].y = (1<<30); +#else + context->extra[1].y = 65535; +#endif + context->extra[1].next = NULL; +} + +/* find minimum y position if it starts at x1 */ +static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp__skyline_find_min_y / static"); + stbrp_node *node = first; + int x1 = x0 + width; + int min_y, visited_width, waste_area; + + STBRP__NOTUSED(c); + + STBRP_ASSERT(first->x <= x0); + + #if 0 + /* skip in case we're past the node */ + while (node->next->x <= x0) + ++node; + #else + STBRP_ASSERT(node->next->x > x0); /* we ended up handling this in the caller for efficiency */ + #endif + + STBRP_ASSERT(node->x <= x0); + + min_y = 0; + waste_area = 0; + visited_width = 0; + //writeSerialPort(boutRefNum, "stbrp__skyline_find_min_y"); + while (node->x < x1) { + if (node->y > min_y) { + /* raise min_y higher. */ + /* we've accounted for all waste up to min_y, */ + /* but we'll now add more waste for everything we've visted */ + waste_area += visited_width * (node->y - min_y); + min_y = node->y; + /* the first time through, visited_width might be reduced */ + if (node->x < x0) + visited_width += node->next->x - x0; + else + visited_width += node->next->x - node->x; + } else { + /* add waste area */ + int under_width = node->next->x - node->x; + if (under_width + visited_width > width) + under_width = width - visited_width; + waste_area += under_width * (min_y - node->y); + visited_width += under_width; + } + node = node->next; + } + + *pwaste = waste_area; + return min_y; +} + +typedef struct +{ + int x,y; + stbrp_node **prev_link; +} stbrp__findresult; + +static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp__skyline_find_best_pos / static"); + //writeSerialPort(boutRefNum, "stbrp__skyline_find_best_pos"); + int best_waste = (1<<30), best_x, best_y = (1 << 30); + stbrp__findresult fr; + stbrp_node **prev, *node, *tail, **best = NULL; + + /* align to multiple of c->align */ + width = (width + c->align - 1); + width -= width % c->align; + STBRP_ASSERT(width % c->align == 0); + + /* if it can't possibly fit, bail immediately */ + if (width > c->width || height > c->height) { + fr.prev_link = NULL; + fr.x = fr.y = 0; + return fr; + } + + node = c->active_head; + prev = &c->active_head; + + //writeSerialPort(boutRefNum, "stbrp__skyline_find_best_pos"); + while (node->x + width <= c->width) { + int y,waste; + y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste); + if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { /* actually just want to test BL */ + /* bottom left */ + if (y < best_y) { + best_y = y; + best = prev; + } + } else { + /* best-fit */ + if (y + height <= c->height) { + /* can only use it if it first vertically */ + if (y < best_y || (y == best_y && waste < best_waste)) { + best_y = y; + best_waste = waste; + best = prev; + } + } + } + prev = &node->next; + node = node->next; + } + + best_x = (best == NULL) ? 0 : (*best)->x; + + /* if doing best-fit (BF), we also have to try aligning right edge to each node position */ + /* */ + /* e.g, if fitting */ + /* */ + /* ____________________ */ + /* |____________________| */ + /* */ + /* into */ + /* */ + /* | | */ + /* | ____________| */ + /* |____________| */ + /* */ + /* then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned */ + /* */ + /* This makes BF take about 2x the time */ + + if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) { + tail = c->active_head; + node = c->active_head; + prev = &c->active_head; + /* find first node that's admissible */ + while (tail->x < width) + tail = tail->next; + while (tail) { + int xpos = tail->x - width; + int y,waste; + STBRP_ASSERT(xpos >= 0); + /* find the left position that matches this */ + while (node->next->x <= xpos) { + prev = &node->next; + node = node->next; + } + STBRP_ASSERT(node->next->x > xpos && node->x <= xpos); + y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste); + if (y + height <= c->height) { + if (y <= best_y) { + if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) { + best_x = xpos; + STBRP_ASSERT(y <= best_y); + best_y = y; + best_waste = waste; + best = prev; + } + } + } + tail = tail->next; + } + } + + fr.prev_link = best; + fr.x = best_x; + fr.y = best_y; + return fr; +} + +static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp__skyline_pack_rectangle / static"); + /* find best position according to heuristic */ + stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height); + stbrp_node *node, *cur; + + /* bail if: */ + /* 1. it failed */ + /* 2. the best node doesn't fit (we don't always check this) */ + /* 3. we're out of memory */ + if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) { + res.prev_link = NULL; + return res; + } + + /* on success, create new node */ + node = context->free_head; + node->x = (stbrp_coord) res.x; + node->y = (stbrp_coord) (res.y + height); + + context->free_head = node->next; + + /* insert the new node into the right starting point, and */ + /* let 'cur' point to the remaining nodes needing to be */ + /* stiched back in */ + + cur = *res.prev_link; + if (cur->x < res.x) { + /* preserve the existing one, so start testing with the next one */ + stbrp_node *next = cur->next; + cur->next = node; + cur = next; + } else { + *res.prev_link = node; + } + + //writeSerialPort(boutRefNum, "stbrp__skyline_pack_rectangle"); + /* from here, traverse cur and free the nodes, until we get to one */ + /* that shouldn't be freed */ + while (cur->next && cur->next->x <= res.x + width) { + stbrp_node *next = cur->next; + /* move the current node to the free list */ + cur->next = context->free_head; + context->free_head = cur; + cur = next; + } + + /* stitch the list back in */ + node->next = cur; + + if (cur->x < res.x + width) + cur->x = (stbrp_coord) (res.x + width); + +#ifdef _DEBUG + cur = context->active_head; + while (cur->x < context->width) { + STBRP_ASSERT(cur->x < cur->next->x); + cur = cur->next; + } + STBRP_ASSERT(cur->next == NULL); + + { + int count=0; + cur = context->active_head; + while (cur) { + cur = cur->next; + ++count; + } + cur = context->free_head; + while (cur) { + cur = cur->next; + ++count; + } + STBRP_ASSERT(count == context->num_nodes+2); + } +#endif + + return res; +} + +static int rect_height_compare(const void *a, const void *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - rect_height_compare / static"); + const stbrp_rect *p = (const stbrp_rect *) a; + const stbrp_rect *q = (const stbrp_rect *) b; + if (p->h > q->h) + return -1; + if (p->h < q->h) + return 1; + return (p->w > q->w) ? -1 : (p->w < q->w); +} + +static int rect_original_order(const void *a, const void *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - rect_original_order / static"); + const stbrp_rect *p = (const stbrp_rect *) a; + const stbrp_rect *q = (const stbrp_rect *) b; + return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed); +} + +#ifdef STBRP_LARGE_RECTS +#define STBRP__MAXVAL 0xffffffff +#else +#define STBRP__MAXVAL 0xffff +#endif + +STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_pack_rects / STBRP_DEF"); + int i, all_rects_packed = 1; + + /* we use the 'was_packed' field internally to allow sorting/unsorting */ + for (i=0; i < num_rects; ++i) { + rects[i].was_packed = i; + } + + /* sort according to heuristic */ + STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare); + + for (i=0; i < num_rects; ++i) { + if (rects[i].w == 0 || rects[i].h == 0) { + rects[i].x = rects[i].y = 0; /* empty rect needs no space */ + } else { + stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h); + if (fr.prev_link) { + rects[i].x = (stbrp_coord) fr.x; + rects[i].y = (stbrp_coord) fr.y; + } else { + rects[i].x = rects[i].y = STBRP__MAXVAL; + } + } + } + + /* unsort */ + STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order); + + /* set was_packed flags and all_rects_packed status */ + for (i=0; i < num_rects; ++i) { + rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL); + if (!rects[i].was_packed) + all_rects_packed = 0; + } + + /* return the all_rects_packed status */ + return all_rects_packed; +} +#endif + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ + +/* stb_truetype.h - v1.24 - public domain */ +/* authored from 2009-2020 by Sean Barrett / RAD Game Tools */ +/* */ +/* ======================================================================= */ +/* */ +/* NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES */ +/* */ +/* This library does no range checking of the offsets found in the file, */ +/* meaning an attacker can use it to read arbitrary memory. */ +/* */ +/* ======================================================================= */ +/* */ +/* This library processes TrueType files: */ +/* parse files */ +/* extract glyph metrics */ +/* extract glyph shapes */ +/* render glyphs to one-channel bitmaps with antialiasing (box filter) */ +/* render glyphs to one-channel SDF bitmaps (signed-distance field/function) */ +/* */ +/* Todo: */ +/* non-MS cmaps */ +/* crashproof on bad data */ +/* hinting? (no longer patented) */ +/* cleartype-style AA? */ +/* optimize: use simple memory allocator for intermediates */ +/* optimize: build edge-list directly from curves */ +/* optimize: rasterize directly from curves? */ +/* */ +/* ADDITIONAL CONTRIBUTORS */ +/* */ +/* Mikko Mononen: compound shape support, more cmap formats */ +/* Tor Andersson: kerning, subpixel rendering */ +/* Dougall Johnson: OpenType / Type 2 font handling */ +/* Daniel Ribeiro Maciel: basic GPOS-based kerning */ +/* */ +/* Misc other: */ +/* Ryan Gordon */ +/* Simon Glass */ +/* github:IntellectualKitty */ +/* Imanol Celaya */ +/* Daniel Ribeiro Maciel */ +/* */ +/* Bug/warning reports/fixes: */ +/* "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe */ +/* Cass Everitt Martins Mozeiko github:aloucks */ +/* stoiko (Haemimont Games) Cap Petschulat github:oyvindjam */ +/* Brian Hook Omar Cornut github:vassvik */ +/* Walter van Niftrik Ryan Griege */ +/* David Gow Peter LaValle */ +/* David Given Sergey Popov */ +/* Ivan-Assen Ivanov Giumo X. Clanjor */ +/* Anthony Pesch Higor Euripedes */ +/* Johan Duparc Thomas Fields */ +/* Hou Qiming Derek Vinyard */ +/* Rob Loach Cort Stratton */ +/* Kenney Phillis Jr. Brian Costabile */ +/* Ken Voskuil (kaesve) */ +/* */ +/* VERSION HISTORY */ +/* */ +/* 1.24 (2020-02-05) fix warning */ +/* 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) */ +/* 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined */ +/* 1.21 (2019-02-25) fix warning */ +/* 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() */ +/* 1.19 (2018-02-11) GPOS kerning, STBTT_fmod */ +/* 1.18 (2018-01-29) add missing function */ +/* 1.17 (2017-07-23) make more arguments const; doc fix */ +/* 1.16 (2017-07-12) SDF support */ +/* 1.15 (2017-03-03) make more arguments const */ +/* 1.14 (2017-01-16) num-fonts-in-TTC function */ +/* 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts */ +/* 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual */ +/* 1.11 (2016-04-02) fix unused-variable warning */ +/* 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef */ +/* 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly */ +/* 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges */ +/* 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; */ +/* variant PackFontRanges to pack and render in separate phases; */ +/* fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); */ +/* fixed an assert() bug in the new rasterizer */ +/* replace assert() with STBTT_assert() in new rasterizer */ +/* */ +/* Full history can be found at the end of this file. */ +/* */ +/* LICENSE */ +/* */ +/* See end of file for license information. */ +/* */ +/* USAGE */ +/* */ +/* Include this file in whatever places need to refer to it. In ONE C/C++ */ +/* file, write: */ +/* #define STB_TRUETYPE_IMPLEMENTATION */ +/* before the #include of this file. This expands out the actual */ +/* implementation into that C/C++ file. */ +/* */ +/* To make the implementation private to the file that generates the implementation, */ +/* #define STBTT_STATIC */ +/* */ +/* Simple 3D API (don't ship this, but it's fine for tools and quick start) */ +/* stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture */ +/* stbtt_GetBakedQuad() -- compute quad to draw for a given char */ +/* */ +/* Improved 3D API (more shippable): */ +/* #include "stb_rect_pack.h" -- optional, but you really want it */ +/* stbtt_PackBegin() */ +/* stbtt_PackSetOversampling() -- for improved quality on small fonts */ +/* stbtt_PackFontRanges() -- pack and renders */ +/* stbtt_PackEnd() */ +/* stbtt_GetPackedQuad() */ +/* */ +/* "Load" a font file from a memory buffer (you have to keep the buffer loaded) */ +/* stbtt_InitFont() */ +/* stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections */ +/* stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections */ +/* */ +/* Render a unicode codepoint to a bitmap */ +/* stbtt_GetCodepointBitmap() -- allocates and returns a bitmap */ +/* stbtt_MakeCodepointBitmap() -- renders into bitmap you provide */ +/* stbtt_GetCodepointBitmapBox() -- how big the bitmap must be */ +/* */ +/* Character advance/positioning */ +/* stbtt_GetCodepointHMetrics() */ +/* stbtt_GetFontVMetrics() */ +/* stbtt_GetFontVMetricsOS2() */ +/* stbtt_GetCodepointKernAdvance() */ +/* */ +/* Starting with version 1.06, the rasterizer was replaced with a new, */ +/* faster and generally-more-precise rasterizer. The new rasterizer more */ +/* accurately measures pixel coverage for anti-aliasing, except in the case */ +/* where multiple shapes overlap, in which case it overestimates the AA pixel */ +/* coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If */ +/* this turns out to be a problem, you can re-enable the old rasterizer with */ +/* #define STBTT_RASTERIZER_VERSION 1 */ +/* which will incur about a 15% speed hit. */ +/* */ +/* ADDITIONAL DOCUMENTATION */ +/* */ +/* Immediately after this block comment are a series of sample programs. */ +/* */ +/* After the sample programs is the "header file" section. This section */ +/* includes documentation for each API function. */ +/* */ +/* Some important concepts to understand to use this library: */ +/* */ +/* Codepoint */ +/* Characters are defined by unicode codepoints, e.g. 65 is */ +/* uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is */ +/* the hiragana for "ma". */ +/* */ +/* Glyph */ +/* A visual character shape (every codepoint is rendered as */ +/* some glyph) */ +/* */ +/* Glyph index */ +/* A font-specific integer ID representing a glyph */ +/* */ +/* Baseline */ +/* Glyph shapes are defined relative to a baseline, which is the */ +/* bottom of uppercase characters. Characters extend both above */ +/* and below the baseline. */ +/* */ +/* Current Point */ +/* As you draw text to the screen, you keep track of a "current point" */ +/* which is the origin of each character. The current point's vertical */ +/* position is the baseline. Even "baked fonts" use this model. */ +/* */ +/* Vertical Font Metrics */ +/* The vertical qualities of the font, used to vertically position */ +/* and space the characters. See docs for stbtt_GetFontVMetrics. */ +/* */ +/* Font Size in Pixels or Points */ +/* The preferred interface for specifying font sizes in stb_truetype */ +/* is to specify how tall the font's vertical extent should be in pixels. */ +/* If that sounds good enough, skip the next paragraph. */ +/* */ +/* Most font APIs instead use "points", which are a common typographic */ +/* measurement for describing font size, defined as 72 points per inch. */ +/* stb_truetype provides a point API for compatibility. However, true */ +/* "per inch" conventions don't make much sense on computer displays */ +/* since different monitors have different number of pixels per */ +/* inch. For example, Windows traditionally uses a convention that */ +/* there are 96 pixels per inch, thus making 'inch' measurements have */ +/* nothing to do with inches, and thus effectively defining a point to */ +/* be 1.333 pixels. Additionally, the TrueType font data provides */ +/* an explicit scale factor to scale a given font's glyphs to points, */ +/* but the author has observed that this scale factor is often wrong */ +/* for non-commercial fonts, thus making fonts scaled in points */ +/* according to the TrueType spec incoherently sized in practice. */ +/* */ +/* DETAILED USAGE: */ +/* */ +/* Scale: */ +/* Select how high you want the font to be, in points or pixels. */ +/* Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute */ +/* a scale factor SF that will be used by all other functions. */ +/* */ +/* Baseline: */ +/* You need to select a y-coordinate that is the baseline of where */ +/* your text will appear. Call GetFontBoundingBox to get the baseline-relative */ +/* bounding box for all characters. SF*-y0 will be the distance in pixels */ +/* that the worst-case character could extend above the baseline, so if */ +/* you want the top edge of characters to appear at the top of the */ +/* screen where y=0, then you would set the baseline to SF*-y0. */ +/* */ +/* Current point: */ +/* Set the current point where the first character will appear. The */ +/* first character could extend left of the current point; this is font */ +/* dependent. You can either choose a current point that is the leftmost */ +/* point and hope, or add some padding, or check the bounding box or */ +/* left-side-bearing of the first character to be displayed and set */ +/* the current point based on that. */ +/* */ +/* Displaying a character: */ +/* Compute the bounding box of the character. It will contain signed values */ +/* relative to . I.e. if it returns x0,y0,x1,y1, */ +/* then the character should be displayed in the rectangle from */ +/* to = 32 && *text < 128) { + stbtt_aligned_quad q; + stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);/* 1=opengl & d3d10+,0=d3d9 */ + glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1); + } + ++text; + } + glEnd(); +} +#endif +/* */ +/* */ +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* Complete program (this compiles): get a single bitmap, print as ASCII art */ +/* */ +#if 0 +#include +#define STB_TRUETYPE_IMPLEMENTATION /* force following include to generate implementation */ +#include "stb_truetype.h" + +char ttf_buffer[1<<25]; + +int main(int argc, char **argv) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / int"); + stbtt_fontinfo font; + unsigned char *bitmap; + int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); + + fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); + + stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); + bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); + + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) + putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); + putchar('\n'); + } + return 0; +} +#endif +/* */ +/* Output: */ +/* */ +/* .ii. */ +/* @@@@@@. */ +/* V@Mio@@o */ +/* :i. V@V */ +/* :oM@@M */ +/* :@@@MM@M */ +/* @@o o@M */ +/* :@@. M@M */ +/* @@@o@@@@ */ +/* :M@@V:@@. */ +/* */ +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* Complete program: print "Hello World!" banner, with bugs */ +/* */ +#if 0 +char buffer[24<<20]; +unsigned char screen[20][79]; + +int main(int arg, char **argv) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / int"); + stbtt_fontinfo font; + int i,j,ascent,baseline,ch=0; + int scale, xpos=2; /* leave a little padding in case the character extends left */ + char *text = "Heljo World!"; /* intentionally misspelled to show 'lj' brokenness */ + + fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); + stbtt_InitFont(&font, buffer, 0); + + scale = stbtt_ScaleForPixelHeight(&font, 15); + stbtt_GetFontVMetrics(&font, &ascent,0,0); + baseline = (int) (ascent*scale); + + while (text[ch]) { + int advance,lsb,x0,y0,x1,y1; + int x_shift = xpos - (int) floor(xpos); + stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); + stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); + stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); + /* note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong */ + /* because this API is really for baking character bitmaps into textures. if you want to render */ + /* a sequence of characters, you really need to render each bitmap to a temp buffer, then */ + /* "alpha blend" that into the working buffer */ + xpos += (advance * scale); + if (text[ch+1]) + xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); + ++ch; + } + + for (j=0; j < 20; ++j) { + for (i=0; i < 78; ++i) + putchar(" .:ioVM@"[screen[j][i]>>5]); + putchar('\n'); + } + + return 0; +} +#endif + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* //////////////////////////////////////////////////////////////////////////// */ +/* // */ +/* // INTEGRATION WITH YOUR CODEBASE */ +/* // */ +/* // The following sections allow you to supply alternate definitions */ +/* // of C library functions used by stb_truetype, e.g. if you don't */ +/* // link with the C runtime library. */ + +#ifdef STB_TRUETYPE_IMPLEMENTATION + /* #define your own (u)stbtt_int8/16/32 before including to override this */ + #ifndef stbtt_uint8 + typedef unsigned char stbtt_uint8; + typedef signed char stbtt_int8; + typedef unsigned short stbtt_uint16; + typedef signed short stbtt_int16; + typedef unsigned int stbtt_uint32; + typedef signed int stbtt_int32; + #endif + + typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; + typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; + + /* e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h */ + #ifndef STBTT_ifloor + #include + #define STBTT_ifloor(x) ((int) floor(x)) + #define STBTT_iceil(x) ((int) ceil(x)) + #endif + + #ifndef STBTT_sqrt + #include + #define STBTT_sqrt(x) sqrt(x) + #define STBTT_pow(x,y) pow(x,y) + #endif + + #ifndef STBTT_fmod + #include + #define STBTT_fmod(x,y) fmod(x,y) + #endif + + #ifndef STBTT_cos + #include + #define STBTT_cos(x) cos(x) + #define STBTT_acos(x) acos(x) + #endif + + #ifndef STBTT_fabs + #include + #define STBTT_fabs(x) fabs(x) + #endif + + /* #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h */ + #ifndef STBTT_malloc + #include + #define STBTT_malloc(x,u) ((void)(u),malloc(x)) + #define STBTT_free(x,u) ((void)(u),free(x)) + #endif + + #ifndef STBTT_assert + #include + #define STBTT_assert(x) assert(x) + #endif + + #ifndef STBTT_strlen + #include + #define STBTT_strlen(x) strlen(x) + #endif + + #ifndef STBTT_memcpy + #include + #define STBTT_memcpy memcpy + #define STBTT_memset memset + #endif +#endif + +/* ///////////////////////////////////////////////////////////////////////////// */ +/* ///////////////////////////////////////////////////////////////////////////// */ +/* // */ +/* // INTERFACE */ +/* // */ +/* // */ + +#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ +#define __STB_INCLUDE_STB_TRUETYPE_H__ + +#ifdef STBTT_STATIC +#define STBTT_DEF static +#else +#define STBTT_DEF extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* private structure */ +typedef struct +{ + unsigned char *data; + int cursor; + int size; +} stbtt__buf; + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* TEXTURE BAKING API */ +/* */ +/* If you use this API, you only have to call two functions ever. */ +/* */ + +typedef struct +{ + unsigned short x0,y0,x1,y1; /* coordinates of bbox in bitmap */ + int xoff,yoff,xadvance; +} stbtt_bakedchar; + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, /* font location (use offset=0 for plain .ttf) */ + int pixel_height, /* height of font in pixels */ + unsigned char *pixels, int pw, int ph, /* bitmap to be filled in */ + int first_char, int num_chars, /* characters to bake */ + stbtt_bakedchar *chardata); /* you allocate this, it's num_chars long */ +/* if return is positive, the first unused row of the bitmap */ +/* if return is negative, returns the negative of the number of characters that fit */ +/* if return is 0, no characters fit and no rows were used */ +/* This uses a very crappy packing. */ + +typedef struct +{ + int x0,y0,s0,t0; /* top-left */ + int x1,y1,s1,t1; /* bottom-right */ +} stbtt_aligned_quad; + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, /* same data as above */ + int char_index, /* character to display */ + int *xpos, int *ypos, /* pointers to current position in screen pixel space */ + stbtt_aligned_quad *q, /* output: quad to draw */ + int opengl_fillrule); /* true if opengl fill rule; false if DX9 or earlier */ +/* Call GetBakedQuad with char_index = 'character - first_char', and it */ +/* creates the quad you need to draw and advances the current position. */ +/* */ +/* The coordinate system used assumes y increases downwards. */ +/* */ +/* Characters will extend both above and below the current position; */ +/* see discussion of "BASELINE" above. */ +/* */ +/* It's inefficient; you might want to c&p it and optimize it. */ + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, int size, int *ascent, int *descent, int *lineGap); +/* Query the font vertical metrics without having to create a font first. */ + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* NEW TEXTURE BAKING API */ +/* */ +/* This provides options for packing multiple fonts into one atlas, not */ +/* perfectly but better than nothing. */ + +typedef struct +{ + unsigned short x0,y0,x1,y1; /* coordinates of bbox in bitmap */ + int xoff,yoff,xadvance; + int xoff2,yoff2; +} stbtt_packedchar; + +typedef struct stbtt_pack_context stbtt_pack_context; +typedef struct stbtt_fontinfo stbtt_fontinfo; +#ifndef STB_RECT_PACK_VERSION +typedef struct stbrp_rect stbrp_rect; +#endif + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); +/* Initializes a packing context stored in the passed-in stbtt_pack_context. */ +/* Future calls using this context will pack characters into the bitmap passed */ +/* in here: a 1-channel bitmap that is width * height. stride_in_bytes is */ +/* the distance from one row to the next (or 0 to mean they are packed tightly */ +/* together). "padding" is the amount of padding to leave between each */ +/* character (normally you want '1' for bitmaps you'll use as textures with */ +/* bilinear filtering). */ +/* */ +/* Returns 0 on failure, 1 on success. */ + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); +/* Cleans up the packing context and frees all memory. */ + +#define STBTT_POINT_SIZE(x) (-(x)) + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, int font_size, + int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); +/* Creates character bitmaps from the font_index'th font found in fontdata (use */ +/* font_index=0 if you don't know what that is). It creates num_chars_in_range */ +/* bitmaps for characters with unicode values starting at first_unicode_char_in_range */ +/* and increasing. Data for how to render them is stored in chardata_for_range; */ +/* pass these to stbtt_GetPackedQuad to get back renderable quads. */ +/* */ +/* font_size is the full height of the character from ascender to descender, */ +/* as computed by stbtt_ScaleForPixelHeight. To use a point size as computed */ +/* by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() */ +/* and pass that result as 'font_size': */ +/* ..., 20 , ... // font max minus min y is 20 pixels tall */ +/* ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall */ + +typedef struct +{ + int font_size; + int first_unicode_codepoint_in_range; /* if non-zero, then the chars are continuous, and this is the first codepoint */ + int *array_of_unicode_codepoints; /* if non-zero, then this is an array of unicode codepoints */ + int num_chars; + stbtt_packedchar *chardata_for_range; /* output */ + unsigned char h_oversample, v_oversample; /* don't set these, they're used internally */ +} stbtt_pack_range; + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); +/* Creates character bitmaps from multiple ranges of characters stored in */ +/* ranges. This will usually create a better-packed bitmap than multiple */ +/* calls to stbtt_PackFontRange. Note that you can call this multiple */ +/* times within a single PackBegin/PackEnd. */ + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); +/* Oversampling a font increases the quality by allowing higher-quality subpixel */ +/* positioning, and is especially valuable at smaller text sizes. */ +/* */ +/* This function sets the amount of oversampling for all following calls to */ +/* stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given */ +/* pack context. The default (no oversampling) is achieved by h_oversample=1 */ +/* and v_oversample=1. The total number of pixels required is */ +/* h_oversample*v_oversample larger than the default; for example, 2x2 */ +/* oversampling requires 4x the storage of 1x1. For best results, render */ +/* oversampled textures with bilinear filtering. Look at the readme in */ +/* stb/tests/oversample for information about oversampled fonts */ +/* */ +/* To use with PackFontRangesGather etc., you must set it before calls */ +/* call to PackFontRangesGatherRects. */ + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); +/* If skip != 0, this tells stb_truetype to skip any codepoints for which */ +/* there is no corresponding glyph. If skip=0, which is the default, then */ +/* codepoints without a glyph recived the font's "missing character" glyph, */ +/* typically an empty box by convention. */ + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, /* same data as above */ + int char_index, /* character to display */ + int *xpos, int *ypos, /* pointers to current position in screen pixel space */ + stbtt_aligned_quad *q, /* output: quad to draw */ + int align_to_integer); + +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +/* Calling these functions in sequence is roughly equivalent to calling */ +/* stbtt_PackFontRanges(). If you more control over the packing of multiple */ +/* fonts, or if you want to pack custom data into a font texture, take a look */ +/* at the source to of stbtt_PackFontRanges() and create a custom version */ +/* using these functions, e.g. call GatherRects multiple times, */ +/* building up a single array of rects, then call PackRects once, */ +/* then call RenderIntoRects repeatedly. This may result in a */ +/* better packing than calling PackFontRanges multiple times */ +/* (or it may not). */ + +/* this is an opaque structure that you shouldn't mess with which holds */ +/* all the context needed from PackBegin to PackEnd. */ +struct stbtt_pack_context { + void *user_allocator_context; + void *pack_info; + int width; + int height; + int stride_in_bytes; + int padding; + int skip_missing; + unsigned int h_oversample, v_oversample; + unsigned char *pixels; + void *nodes; +}; + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* FONT LOADING */ +/* */ +/* */ + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); +/* This function will determine the number of fonts in a font file. TrueType */ +/* collection (.ttc) files may contain multiple fonts, while TrueType font */ +/* (.ttf) files only contain one font. The number of fonts can be used for */ +/* indexing with the previous function where the index is between zero and one */ +/* less than the total fonts. If an error occurs, -1 is returned. */ + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); +/* Each .ttf/.ttc file may have more than one font. Each font has a sequential */ +/* index number starting from 0. Call this function to get the font offset for */ +/* a given index; it returns -1 if the index is out of range. A regular .ttf */ +/* file will only define one font and it always be at offset 0, so it will */ +/* return '0' for index 0, and -1 for all other indices. */ + +/* The following structure is defined publicly so you can declare one on */ +/* the stack or as a global or etc, but you should treat it as opaque. */ +struct stbtt_fontinfo +{ + void * userdata; + unsigned char * data; /* pointer to .ttf file */ + int fontstart; /* offset of start of font */ + + int numGlyphs; /* number of glyphs, needed for range checking */ + + int loca,head,glyf,hhea,hmtx,kern,gpos,svg; /* table locations as offset from start of .ttf */ + int index_map; /* a cmap mapping for our chosen character encoding */ + int indexToLocFormat; /* format needed to map from glyph index to glyph */ + + stbtt__buf cff; /* cff font data */ + stbtt__buf charstrings; /* the charstring index */ + stbtt__buf gsubrs; /* global charstring subroutines index */ + stbtt__buf subrs; /* private charstring subroutines index */ + stbtt__buf fontdicts; /* array of font dicts */ + stbtt__buf fdselect; /* map from glyph to fontdict */ +}; + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); +/* Given an offset into the file that defines a font, this function builds */ +/* the necessary cached info for the rest of the system. You must allocate */ +/* the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't */ +/* need to do anything special to free it, because the contents are pure */ +/* value data with no additional data structures. Returns 0 on failure. */ + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* CHARACTER TO GLYPH-INDEX CONVERSIOn */ + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); +/* If you're going to perform multiple operations on the same character */ +/* and you want a speed-up, call this function with the character you're */ +/* going to process, then use glyph-based functions instead of the */ +/* codepoint-based functions. */ +/* Returns 0 if the character codepoint is not defined in the font. */ + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* CHARACTER PROPERTIES */ +/* */ + +STBTT_DEF int stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, int pixels); +/* computes a scale factor to produce a font whose "height" is 'pixels' tall. */ +/* Height is measured as the distance from the highest ascender to the lowest */ +/* descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics */ +/* and computing: */ +/* scale = pixels / (ascent - descent) */ +/* so if you prefer to measure height by the ascent only, use a similar calculation. */ + +STBTT_DEF int stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, int pixels); +/* computes a scale factor to produce a font whose EM size is mapped to */ +/* 'pixels' tall. This is probably what traditional APIs compute, but */ +/* I'm not positive. */ + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); +/* ascent is the coordinate above the baseline the font extends; descent */ +/* is the coordinate below the baseline the font extends (i.e. it is typically negative) */ +/* lineGap is the spacing between one row's descent and the next row's ascent... */ +/* so you should advance the vertical position by "*ascent - *descent + *lineGap" */ +/* these are expressed in unscaled coordinates, so you must multiply by */ +/* the scale factor for a given size */ + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); +/* analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 */ +/* table (specific to MS/Windows TTF files). */ +/* */ +/* Returns 1 on success (table present), 0 on failure. */ + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); +/* the bounding box around all possible characters */ + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); +/* leftSideBearing is the offset from the current horizontal position to the left edge of the character */ +/* advanceWidth is the offset from the current horizontal position to the next horizontal position */ +/* these are expressed in unscaled coordinates */ + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); +/* an additional amount to add to the 'advance' value between ch1 and ch2 */ + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); +/* Gets the bounding box of the visible part of the glyph, in unscaled coordinates */ + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); +/* as above, but takes one or more glyph indices for greater efficiency */ + +typedef struct stbtt_kerningentry +{ + int glyph1; /* use stbtt_FindGlyphIndex */ + int glyph2; + int advance; +} stbtt_kerningentry; + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); +/* Retrieves a complete list of all of the kerning pairs provided by the font */ +/* stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. */ +/* The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) */ + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* GLYPH SHAPES (you probably don't need these, but they have to go before */ +/* the bitmaps for C declaration-order reasons) */ +/* */ + +#ifndef STBTT_vmove /* you can predefine these to use different values (but why?) */ + enum { + STBTT_vmove=1, + STBTT_vline, + STBTT_vcurve, + STBTT_vcubic + }; +#endif + +#ifndef stbtt_vertex /* you can predefine this to use different values */ + /* (we share this with other code at RAD) */ + #define stbtt_vertex_type short /* can't use stbtt_int16 because that's not visible in the header file */ + typedef struct + { + stbtt_vertex_type x,y,cx,cy,cx1,cy1; + unsigned char type,padding; + } stbtt_vertex; +#endif + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); +/* returns non-zero if nothing is drawn for this glyph */ + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); +/* returns # of vertices and fills *vertices with the pointer to them */ +/* these are expressed in "unscaled" coordinates */ +/* */ +/* The shape is a series of contours. Each one starts with */ +/* a STBTT_moveto, then consists of a series of mixed */ +/* STBTT_lineto and STBTT_curveto segments. A lineto */ +/* draws a line from previous endpoint to its x,y; a curveto */ +/* draws a quadratic bezier from previous endpoint to */ +/* its x,y, using cx,cy as the bezier control point. */ + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); +/* frees the data allocated above */ + +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); +/* fills svg with the character's SVG data. */ +/* returns data size or 0 if SVG not found. */ + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* BITMAP RENDERING */ +/* */ + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); +/* frees the bitmap allocated below */ + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, int scale_x, int scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +/* allocates a large-enough single-channel 8bpp bitmap and renders the */ +/* specified character/glyph at the specified scale into it, with */ +/* antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). */ +/* *width & *height are filled out with the width & height of the bitmap, */ +/* which is stored left-to-right, top-to-bottom. */ +/* */ +/* xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap */ + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, int scale_x, int scale_y, int shift_x, int shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +/* the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel */ +/* shift for the character */ + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int codepoint); +/* the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap */ +/* in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap */ +/* is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the */ +/* width and height and positioning info for it first. */ + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int codepoint); +/* same as stbtt_MakeCodepointBitmap, but you can specify a subpixel */ +/* shift for the character */ + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int oversample_x, int oversample_y, int *sub_x, int *sub_y, int codepoint); +/* same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering */ +/* is performed (see stbtt_PackSetOversampling) */ + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, int scale_x, int scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +/* get the bbox of the bitmap centered around the glyph origin; so the */ +/* bitmap width is ix1-ix0, height is iy1-iy0, and location to place */ +/* the bitmap top left is (leftSideBearing*scale,iy0). */ +/* (Note that the bitmap uses y-increases-down, but the shape uses */ +/* y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) */ + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, int scale_x, int scale_y, int shift_x, int shift_y, int *ix0, int *iy0, int *ix1, int *iy1); +/* same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel */ +/* shift for the character */ + +/* the following functions are equivalent to the above functions, but operate */ +/* on glyph indices instead of Unicode codepoints (for efficiency) */ +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, int scale_x, int scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, int scale_x, int scale_y, int shift_x, int shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int oversample_x, int oversample_y, int *sub_x, int *sub_y, int glyph); +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, int scale_x, int scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, int scale_x, int scale_y,int shift_x, int shift_y, int *ix0, int *iy0, int *ix1, int *iy1); + + +/* @TODO: don't expose this structure */ +typedef struct +{ + int w,h,stride; + unsigned char *pixels; +} stbtt__bitmap; + +/* rasterize a shape with quadratic beziers into a bitmap */ +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, /* 1-channel bitmap to draw into */ + int flatness_in_pixels, /* allowable error of curve in pixels */ + stbtt_vertex *vertices, /* array of vertices defining shape */ + int num_verts, /* number of vertices in above array */ + int scale_x, int scale_y, /* scale applied to input vertices */ + int shift_x, int shift_y, /* translation applied to input vertices */ + int x_off, int y_off, /* another translation applied to input */ + int invert, /* if non-zero, vertically flip shape */ + void *userdata); /* context for to STBTT_MALLOC */ + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* Signed Distance Function (or Field) rendering */ + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); +/* frees the SDF bitmap allocated below */ + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, int scale, int glyph, int padding, unsigned char onedge_value, int pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, int scale, int codepoint, int padding, unsigned char onedge_value, int pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +/* These functions compute a discretized SDF field for a single character, suitable for storing */ +/* in a single-channel texture, sampling with bilinear filtering, and testing against */ +/* larger than some threshold to produce scalable fonts. */ +/* info -- the font */ +/* scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap */ +/* glyph/codepoint -- the character to generate the SDF for */ +/* padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), */ +/* which allows effects like bit outlines */ +/* onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) */ +/* pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) */ +/* if positive, > onedge_value is inside; if negative, < onedge_value is inside */ +/* width,height -- output height & width of the SDF bitmap (including padding) */ +/* xoff,yoff -- output origin of the character */ +/* return value -- a 2D array of bytes 0..255, width*height in size */ +/* */ +/* pixel_dist_scale & onedge_value are a scale & bias that allows you to make */ +/* optimal use of the limited 0..255 for your application, trading off precision */ +/* and special effects. SDF values outside the range 0..255 are clamped to 0..255. */ +/* */ +/* Example: */ +/* scale = stbtt_ScaleForPixelHeight(22) */ +/* padding = 5 */ +/* onedge_value = 180 */ +/* pixel_dist_scale = 180/5.0 = 36.0 */ +/* */ +/* This will create an SDF bitmap in which the character is about 22 pixels */ +/* high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled */ +/* shape, sample the SDF at each pixel and fill the pixel if the SDF value */ +/* is greater than or equal to 180/255. (You'll actually want to antialias, */ +/* which is beyond the scope of this example.) Additionally, you can compute */ +/* offset outlines (e.g. to stroke the character border inside & outside, */ +/* or only outside). For example, to fill outside the character up to 3 SDF */ +/* pixels, you would compare against (180-36.0*3)/255 = 72/255. The above */ +/* choice of variables maps a range from 5 pixels outside the shape to */ +/* 2 pixels inside the shape to 0..255; this is intended primarily for apply */ +/* outside effects only (the interior range is needed to allow proper */ +/* antialiasing of the font at *smaller* sizes) */ +/* */ +/* The function computes the SDF analytically at each SDF pixel, not by e.g. */ +/* building a higher-res bitmap and approximating it. In theory the quality */ +/* should be as high as possible for an SDF of this size & representation, but */ +/* unclear if this is true in practice (perhaps building a higher-res bitmap */ +/* and computing from that can allow drop-out prevention). */ +/* */ +/* The algorithm has not been optimized at all, so expect it to be slow */ +/* if computing lots of characters or very large sizes. */ + + + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* Finding the right font... */ +/* */ +/* You should really just solve this offline, keep your own tables */ +/* of what font is what, and don't try to get it out of the .ttf file. */ +/* That's because getting it out of the .ttf file is really hard, because */ +/* the names in the file can appear in many possible encodings, in many */ +/* possible languages, and e.g. if you need a case-insensitive comparison, */ +/* the details of that depend on the encoding & language in a complex way */ +/* (actually underspecified in truetype, but also gigantic). */ +/* */ +/* But you can use the provided functions in two possible ways: */ +/* stbtt_FindMatchingFont() will use *case-sensitive* comparisons on */ +/* unicode-encoded names to try to find the font you want; */ +/* you can run this before calling stbtt_InitFont() */ +/* */ +/* stbtt_GetFontNameString() lets you get any of the various strings */ +/* from the file yourself and do your own comparisons on them. */ +/* You have to have called stbtt_InitFont() first. */ + + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); +/* returns the offset (not index) of the font that matches, or -1 if none */ +/* if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". */ +/* if you use any other flag, use a font name like "Arial"; this checks */ +/* the 'macStyle' header field; i don't know if fonts set this consistently */ +#define STBTT_MACSTYLE_DONTCARE 0 +#define STBTT_MACSTYLE_BOLD 1 +#define STBTT_MACSTYLE_ITALIC 2 +#define STBTT_MACSTYLE_UNDERSCORE 4 +#define STBTT_MACSTYLE_NONE 8 /* <= not same as 0, this makes us check the bitfield is 0 */ + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); +/* returns 1/0 whether the first string interpreted as utf8 is identical to */ +/* the second string interpreted as big-endian utf16... useful for strings from next func */ + +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); +/* returns the string (which may be big-endian double byte, e.g. for unicode) */ +/* and puts the length in bytes in *length. */ +/* */ +/* some of the values for the IDs are below; for more see the truetype spec: */ +/* http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html */ +/* http://www.microsoft.com/typography/otspec/name.htm */ + +enum { /* platformID */ + STBTT_PLATFORM_ID_UNICODE =0, + STBTT_PLATFORM_ID_MAC =1, + STBTT_PLATFORM_ID_ISO =2, + STBTT_PLATFORM_ID_MICROSOFT =3 +}; + +enum { /* encodingID for STBTT_PLATFORM_ID_UNICODE */ + STBTT_UNICODE_EID_UNICODE_1_0 =0, + STBTT_UNICODE_EID_UNICODE_1_1 =1, + STBTT_UNICODE_EID_ISO_10646 =2, + STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, + STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 +}; + +enum { /* encodingID for STBTT_PLATFORM_ID_MICROSOFT */ + STBTT_MS_EID_SYMBOL =0, + STBTT_MS_EID_UNICODE_BMP =1, + STBTT_MS_EID_SHIFTJIS =2, + STBTT_MS_EID_UNICODE_FULL =10 +}; + +enum { /* encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes */ + STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, + STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, + STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, + STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 +}; + +enum { /* languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... */ + /* problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs */ + STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, + STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, + STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, + STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, + STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, + STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D +}; + +enum { /* languageID for STBTT_PLATFORM_ID_MAC */ + STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, + STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, + STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, + STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , + STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , + STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, + STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 +}; + +#ifdef __cplusplus +} +#endif + +#endif /* __STB_INCLUDE_STB_TRUETYPE_H__ */ + +/* ///////////////////////////////////////////////////////////////////////////// */ +/* ///////////////////////////////////////////////////////////////////////////// */ +/* // */ +/* // IMPLEMENTATION */ +/* // */ +/* // */ + +#ifdef STB_TRUETYPE_IMPLEMENTATION + +#ifndef STBTT_MAX_OVERSAMPLE +#define STBTT_MAX_OVERSAMPLE 8 +#endif + +#if STBTT_MAX_OVERSAMPLE > 255 +#error "STBTT_MAX_OVERSAMPLE cannot be > 255" +#endif + +typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]; + +#ifndef STBTT_RASTERIZER_VERSION +#define STBTT_RASTERIZER_VERSION 2 +#endif + +#ifdef _MSC_VER +#define STBTT__NOTUSED(v) (void)(v) +#else +#define STBTT__NOTUSED(v) (void)sizeof(v) +#endif + +/* //////////////////////////////////////////////////////////////////////// */ +/* */ +/* stbtt__buf helpers to parse data from file */ +/* */ + +static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_get8 / static"); + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor++]; +} + +static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_peek8 / static"); + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor]; +} + +static void stbtt__buf_seek(stbtt__buf *b, int o) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_seek / static"); + STBTT_assert(!(o > b->size || o < 0)); + b->cursor = (o > b->size || o < 0) ? b->size : o; +} + +static void stbtt__buf_skip(stbtt__buf *b, int o) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_skip / static"); + stbtt__buf_seek(b, b->cursor + o); +} + +static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_get / static"); + stbtt_uint32 v = 0; + int i; + STBTT_assert(n >= 1 && n <= 4); + for (i = 0; i < n; i++) + v = (v << 8) | stbtt__buf_get8(b); + return v; +} + +static stbtt__buf stbtt__new_buf(const void *p, size_t size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__new_buf / static"); + stbtt__buf r; + STBTT_assert(size < 0x40000000); + r.data = (stbtt_uint8*) p; + r.size = (int) size; + r.cursor = 0; + return r; +} + +#define stbtt__buf_get16(b) stbtt__buf_get((b), 2) +#define stbtt__buf_get32(b) stbtt__buf_get((b), 4) + +static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__buf_range / static"); + stbtt__buf r = stbtt__new_buf(NULL, 0); + if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r; + r.data = b->data + o; + r.size = s; + return r; +} + +static stbtt__buf stbtt__cff_get_index(stbtt__buf *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cff_get_index / static"); + int count, start, offsize; + start = b->cursor; + count = stbtt__buf_get16(b); + if (count) { + offsize = stbtt__buf_get8(b); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(b, offsize * count); + stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1); + } + return stbtt__buf_range(b, start, b->cursor - start); +} + +static stbtt_uint32 stbtt__cff_int(stbtt__buf *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cff_int / static"); + int b0 = stbtt__buf_get8(b); + if (b0 >= 32 && b0 <= 246) return b0 - 139; + else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108; + else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108; + else if (b0 == 28) return stbtt__buf_get16(b); + else if (b0 == 29) return stbtt__buf_get32(b); + STBTT_assert(0); + return 0; +} + +static void stbtt__cff_skip_operand(stbtt__buf *b) { + //writeSerialPort(boutRefNum, "stbtt__cff_skip_operand"); + int v, b0 = stbtt__buf_peek8(b); + STBTT_assert(b0 >= 28); + if (b0 == 30) { + stbtt__buf_skip(b, 1); + while (b->cursor < b->size) { + v = stbtt__buf_get8(b); + if ((v & 0xF) == 0xF || (v >> 4) == 0xF) + break; + } + } else { + stbtt__cff_int(b); + } +} + +static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__dict_get / static"); + //writeSerialPort(boutRefNum, "stbtt__dict_get"); + stbtt__buf_seek(b, 0); + while (b->cursor < b->size) { + int start = b->cursor, end, op; + while (stbtt__buf_peek8(b) >= 28) + stbtt__cff_skip_operand(b); + end = b->cursor; + op = stbtt__buf_get8(b); + if (op == 12) op = stbtt__buf_get8(b) | 0x100; + if (op == key) return stbtt__buf_range(b, start, end-start); + } + return stbtt__buf_range(b, 0, 0); +} + +static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__dict_get_ints / static"); + int i; + stbtt__buf operands = stbtt__dict_get(b, key); + for (i = 0; i < outcount && operands.cursor < operands.size; i++) + out[i] = stbtt__cff_int(&operands); +} + +static int stbtt__cff_index_count(stbtt__buf *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cff_index_count / static"); + stbtt__buf_seek(b, 0); + return stbtt__buf_get16(b); +} + +static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cff_index_get / static"); + int count, offsize, start, end; + stbtt__buf_seek(&b, 0); + count = stbtt__buf_get16(&b); + offsize = stbtt__buf_get8(&b); + STBTT_assert(i >= 0 && i < count); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(&b, i*offsize); + start = stbtt__buf_get(&b, offsize); + end = stbtt__buf_get(&b, offsize); + return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); +} + +/* //////////////////////////////////////////////////////////////////////// */ +/* */ +/* accessors to parse data from file */ +/* */ + +/* on platforms that don't allow misaligned reads, if we want to allow */ +/* truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE */ + +#define ttBYTE(p) (* (stbtt_uint8 *) (p)) +#define ttCHAR(p) (* (stbtt_int8 *) (p)) +#define ttFixed(p) ttLONG(p) + +static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } +static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + +#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) +#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) + +static int stbtt__isfont(stbtt_uint8 *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__isfont / static"); + /* check the version number */ + if (stbtt_tag4(font, '1',0,0,0)) return 1; /* TrueType 1 */ + if (stbtt_tag(font, "typ1")) return 1; /* TrueType with type 1 font -- we don't support this! */ + if (stbtt_tag(font, "OTTO")) return 1; /* OpenType with CFF */ + if (stbtt_tag4(font, 0,1,0,0)) return 1; /* OpenType 1.0 */ + if (stbtt_tag(font, "true")) return 1; /* Apple specification for TrueType fonts */ + return 0; +} + +/* @OPTIMIZE: binary search */ +static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__find_table / static"); + stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); + stbtt_uint32 tabledir = fontstart + 12; + stbtt_int32 i; + for (i=0; i < num_tables; ++i) { + stbtt_uint32 loc = tabledir + 16*i; + if (stbtt_tag(data+loc+0, tag)) + return ttULONG(data+loc+8); + } + return 0; +} + +static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetFontOffsetForIndex_internal / static"); + /* if it's just a font, there's only one valid index */ + if (stbtt__isfont(font_collection)) + return index == 0 ? 0 : -1; + + /* check if it's a TTC */ + if (stbtt_tag(font_collection, "ttcf")) { + /* version 1? */ + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + stbtt_int32 n = ttLONG(font_collection+8); + if (index >= n) + return -1; + return ttULONG(font_collection+12+index*4); + } + } + return -1; +} + +static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetNumberOfFonts_internal / static"); + /* if it's just a font, there's only one valid font */ + if (stbtt__isfont(font_collection)) + return 1; + + /* check if it's a TTC */ + if (stbtt_tag(font_collection, "ttcf")) { + /* version 1? */ + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + return ttLONG(font_collection+8); + } + } + return 0; +} + +static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__get_subrs / static"); + stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 }; + stbtt__buf pdict; + stbtt__dict_get_ints(&fontdict, 18, 2, private_loc); + if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0); + pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]); + stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff); + if (!subrsoff) return stbtt__new_buf(NULL, 0); + stbtt__buf_seek(&cff, private_loc[1]+subrsoff); + return stbtt__cff_get_index(&cff); +} + +/* since most people won't use this, find this table the first time it's needed */ +static int stbtt__get_svg(stbtt_fontinfo *info) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__get_svg / static"); + stbtt_uint32 t; + if (info->svg < 0) { + t = stbtt__find_table(info->data, info->fontstart, "SVG "); + if (t) { + stbtt_uint32 offset = ttULONG(info->data + t + 2); + info->svg = t + offset; + } else { + info->svg = 0; + } + } + return info->svg; +} + +static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_InitFont_internal / static"); + stbtt_uint32 cmap, t; + stbtt_int32 i,numTables; + + info->data = data; + info->fontstart = fontstart; + info->cff = stbtt__new_buf(NULL, 0); + + cmap = stbtt__find_table(data, fontstart, "cmap"); /* required */ + info->loca = stbtt__find_table(data, fontstart, "loca"); /* required */ + info->head = stbtt__find_table(data, fontstart, "head"); /* required */ + info->glyf = stbtt__find_table(data, fontstart, "glyf"); /* required */ + info->hhea = stbtt__find_table(data, fontstart, "hhea"); /* required */ + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); /* required */ + info->kern = stbtt__find_table(data, fontstart, "kern"); /* not required */ + info->gpos = stbtt__find_table(data, fontstart, "GPOS"); /* not required */ + + if (!cmap || !info->head || !info->hhea || !info->hmtx) + return 0; + if (info->glyf) { + /* required for truetype */ + if (!info->loca) return 0; + } else { + /* initialization for CFF / Type2 fonts (OTF) */ + stbtt__buf b, topdict, topdictidx; + stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; + stbtt_uint32 cff; + + cff = stbtt__find_table(data, fontstart, "CFF "); + if (!cff) return 0; + + info->fontdicts = stbtt__new_buf(NULL, 0); + info->fdselect = stbtt__new_buf(NULL, 0); + + /* @TODO this should use size from table (not 512MB) */ + info->cff = stbtt__new_buf(data+cff, 512*1024*1024); + b = info->cff; + + /* read the header */ + stbtt__buf_skip(&b, 2); + stbtt__buf_seek(&b, stbtt__buf_get8(&b)); /* hdrsize */ + + /* @TODO the name INDEX could list multiple fonts, */ + /* but we just use the first one. */ + stbtt__cff_get_index(&b); /* name INDEX */ + topdictidx = stbtt__cff_get_index(&b); + topdict = stbtt__cff_index_get(topdictidx, 0); + stbtt__cff_get_index(&b); /* string INDEX */ + info->gsubrs = stbtt__cff_get_index(&b); + + stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); + stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype); + stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff); + stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); + info->subrs = stbtt__get_subrs(b, topdict); + + /* we only support Type 2 charstrings */ + if (cstype != 2) return 0; + if (charstrings == 0) return 0; + + if (fdarrayoff) { + /* looks like a CID font */ + if (!fdselectoff) return 0; + stbtt__buf_seek(&b, fdarrayoff); + info->fontdicts = stbtt__cff_get_index(&b); + info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff); + } + + stbtt__buf_seek(&b, charstrings); + info->charstrings = stbtt__cff_get_index(&b); + } + + t = stbtt__find_table(data, fontstart, "maxp"); + if (t) + info->numGlyphs = ttUSHORT(data+t+4); + else + info->numGlyphs = 0xffff; + + info->svg = -1; + + /* find a cmap encoding table we understand *now* to avoid searching */ + /* later. (todo: could make this installable) */ + /* the same regardless of glyph. */ + numTables = ttUSHORT(data + cmap + 2); + info->index_map = 0; + for (i=0; i < numTables; ++i) { + stbtt_uint32 encoding_record = cmap + 4 + 8 * i; + /* find an encoding we understand: */ + switch(ttUSHORT(data+encoding_record)) { + case STBTT_PLATFORM_ID_MICROSOFT: + switch (ttUSHORT(data+encoding_record+2)) { + case STBTT_MS_EID_UNICODE_BMP: + case STBTT_MS_EID_UNICODE_FULL: + /* MS/Unicode */ + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + break; + case STBTT_PLATFORM_ID_UNICODE: + /* Mac/iOS has these */ + /* all the encodingIDs are unicode, so we don't bother to check it */ + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + } + if (info->index_map == 0) + return 0; + + info->indexToLocFormat = ttUSHORT(data+info->head + 50); + return 1; +} + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FindGlyphIndex / STBTT_DEF"); + + //writeSerialPort(boutRefNum, "stbtt_FindGlyphIndex"); + stbtt_uint8 *data = info->data; + stbtt_uint32 index_map = info->index_map; + + stbtt_uint16 format = ttUSHORT(data + index_map + 0); + if (format == 0) { /* apple byte encoding */ + stbtt_int32 bytes = ttUSHORT(data + index_map + 2); + if (unicode_codepoint < bytes-6) + return ttBYTE(data + index_map + 6 + unicode_codepoint); + return 0; + } else if (format == 6) { + stbtt_uint32 first = ttUSHORT(data + index_map + 6); + stbtt_uint32 count = ttUSHORT(data + index_map + 8); + if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) + return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); + return 0; + } else if (format == 2) { + STBTT_assert(0); /* @TODO: high-byte mapping for japanese/chinese/korean */ + return 0; + } else if (format == 4) { /* standard mapping for windows fonts: binary search collection of ranges */ + stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; + stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; + stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); + stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; + + /* do a binary search of the segments */ + stbtt_uint32 endCount = index_map + 14; + stbtt_uint32 search = endCount; + + if (unicode_codepoint > 0xffff) + return 0; + + /* they lie from endCount .. endCount + segCount */ + /* but searchRange is the nearest power of two, so... */ + if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) + search += rangeShift*2; + + /* now decrement to bias correctly to find smallest */ + search -= 2; + while (entrySelector) { + stbtt_uint16 end; + searchRange >>= 1; + end = ttUSHORT(data + search + searchRange*2); + if (unicode_codepoint > end) + search += searchRange*2; + --entrySelector; + } + search += 2; + + { + stbtt_uint16 offset, start; + stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); + + STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item)); + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + if (unicode_codepoint < start) + return 0; + + offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); + if (offset == 0) + return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); + + return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); + } + } else if (format == 12 || format == 13) { + stbtt_uint32 ngroups = ttULONG(data+index_map+12); + stbtt_int32 low,high; + low = 0; high = (stbtt_int32)ngroups; + /* Binary search the right group. */ + while (low < high) { + stbtt_int32 mid = low + ((high-low) >> 1); /* rounds down, so low <= mid < high */ + stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); + stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); + if ((stbtt_uint32) unicode_codepoint < start_char) + high = mid; + else if ((stbtt_uint32) unicode_codepoint > end_char) + low = mid+1; + else { + stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); + if (format == 12) + return start_glyph + unicode_codepoint-start_char; + else /* format == 13 */ + return start_glyph; + } + } + return 0; /* not found */ + } + /* @TODO */ + STBTT_assert(0); + return 0; +} + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointShape / STBTT_DEF"); + return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); +} + +static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_setvertex / static"); + v->type = type; + v->x = (stbtt_int16) x; + v->y = (stbtt_int16) y; + v->cx = (stbtt_int16) cx; + v->cy = (stbtt_int16) cy; +} + +static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyfOffset / static"); + int g1,g2; + + STBTT_assert(!info->cff.size); + + if (glyph_index >= info->numGlyphs) return -1; /* glyph index out of range */ + if (info->indexToLocFormat >= 2) return -1; /* unknown index->glyph map format */ + + if (info->indexToLocFormat == 0) { + g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; + g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; + } else { + g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); + g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); + } + + return g1==g2 ? -1 : g1; /* if length is 0, return -1 */ +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); + +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphBox / STBTT_DEF"); + if (info->cff.size) { + stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1); + } else { + int g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 0; + + if (x0) *x0 = ttSHORT(info->data + g + 2); + if (y0) *y0 = ttSHORT(info->data + g + 4); + if (x1) *x1 = ttSHORT(info->data + g + 6); + if (y1) *y1 = ttSHORT(info->data + g + 8); + } + return 1; +} + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointBox / STBTT_DEF"); + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_IsGlyphEmpty / STBTT_DEF"); + stbtt_int16 numberOfContours; + int g; + if (info->cff.size) + return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0; + g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 1; + numberOfContours = ttSHORT(info->data + g); + return numberOfContours == 0; +} + +static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, + stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - sx, / stbtt_int32"); + if (start_off) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + return num_vertices; +} + +static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphShapeTT / static"); + stbtt_int16 numberOfContours; + stbtt_uint8 *endPtsOfContours; + stbtt_uint8 *data = info->data; + stbtt_vertex *vertices=0; + int num_vertices=0; + int g = stbtt__GetGlyfOffset(info, glyph_index); + + *pvertices = NULL; + + if (g < 0) return 0; + + numberOfContours = ttSHORT(data + g); + + if (numberOfContours > 0) { + stbtt_uint8 flags=0,flagcount; + stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; + stbtt_int32 x,y,cx,cy,sx,sy, scx,scy; + stbtt_uint8 *points; + endPtsOfContours = (data + g + 10); + ins = ttUSHORT(data + g + 10 + numberOfContours * 2); + points = data + g + 10 + numberOfContours * 2 + 2 + ins; + + n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); + + m = n + 2*numberOfContours; /* a loose bound on how many vertices we might need */ + vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); + if (vertices == 0) + return 0; + + next_move = 0; + flagcount=0; + + /* in first pass, we load uninterpreted data into the allocated array */ + /* above, shifted to the end of the array so we won't overwrite it when */ + /* we create our final data starting from the front */ + + off = m - n; /* starting offset for uninterpreted data, regardless of how m ends up being calculated */ + + /* first load flags */ + + for (i=0; i < n; ++i) { + if (flagcount == 0) { + flags = *points++; + if (flags & 8) + flagcount = *points++; + } else + --flagcount; + vertices[off+i].type = flags; + } + + /* now load x coordinates */ + x=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 2) { + stbtt_int16 dx = *points++; + x += (flags & 16) ? dx : -dx; /* ??? */ + } else { + if (!(flags & 16)) { + x = x + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].x = (stbtt_int16) x; + } + + /* now load y coordinates */ + y=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 4) { + stbtt_int16 dy = *points++; + y += (flags & 32) ? dy : -dy; /* ??? */ + } else { + if (!(flags & 32)) { + y = y + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].y = (stbtt_int16) y; + } + + /* now convert them to our format */ + num_vertices=0; + sx = sy = cx = cy = scx = scy = 0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + x = (stbtt_int16) vertices[off+i].x; + y = (stbtt_int16) vertices[off+i].y; + + if (next_move == i) { + if (i != 0) + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + + /* now start the new one */ + start_off = !(flags & 1); + if (start_off) { + /* if we start off with an off-curve point, then when we need to find a point on the curve */ + /* where we can start, and we need to save some state for when we wraparound. */ + scx = x; + scy = y; + if (!(vertices[off+i+1].type & 1)) { + /* next point is also a curve point, so interpolate an on-point curve */ + sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; + sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; + } else { + /* otherwise just use the next point as our start point */ + sx = (stbtt_int32) vertices[off+i+1].x; + sy = (stbtt_int32) vertices[off+i+1].y; + ++i; /* we're using point i+1 as the starting point, so skip it */ + } + } else { + sx = x; + sy = y; + } + stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); + was_off = 0; + next_move = 1 + ttUSHORT(endPtsOfContours+j*2); + ++j; + } else { + if (!(flags & 1)) { /* if it's a curve */ + if (was_off) /* two off-curve control points in a row means interpolate an on-curve midpoint */ + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); + cx = x; + cy = y; + was_off = 1; + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); + was_off = 0; + } + } + } + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + } else if (numberOfContours < 0) { + /* Compound shapes. */ + int more = 1; + stbtt_uint8 *comp = data + g + 10; + num_vertices = 0; + vertices = 0; + while (more) { + stbtt_uint16 flags, gidx; + int comp_num_verts = 0, i; + stbtt_vertex *comp_verts = 0, *tmp = 0; + int mtx[6] = {1,0,0,1,0,0}, m, n; + + flags = ttSHORT(comp); comp+=2; + gidx = ttSHORT(comp); comp+=2; + + if (flags & 2) { /* XY values */ + if (flags & 1) { /* shorts */ + mtx[4] = ttSHORT(comp); comp+=2; + mtx[5] = ttSHORT(comp); comp+=2; + } else { + mtx[4] = ttCHAR(comp); comp+=1; + mtx[5] = ttCHAR(comp); comp+=1; + } + } + else { + /* @TODO handle matching point */ + STBTT_assert(0); + } + if (flags & (1<<3)) { /* WE_HAVE_A_SCALE */ + mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + } else if (flags & (1<<6)) { /* WE_HAVE_AN_X_AND_YSCALE */ + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } else if (flags & (1<<7)) { /* WE_HAVE_A_TWO_BY_TWO */ + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } + + /* Find transformation scales. */ + m = (int) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (int) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); + + /* Get indexed glyph. */ + comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); + if (comp_num_verts > 0) { + /* Transform vertices. */ + for (i = 0; i < comp_num_verts; ++i) { + stbtt_vertex* v = &comp_verts[i]; + stbtt_vertex_type x,y; + x=v->x; y=v->y; + v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + x=v->cx; y=v->cy; + v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + } + /* Append vertices. */ + tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); + if (!tmp) { + if (vertices) STBTT_free(vertices, info->userdata); + if (comp_verts) STBTT_free(comp_verts, info->userdata); + return 0; + } + if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); + STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); + if (vertices) STBTT_free(vertices, info->userdata); + vertices = tmp; + STBTT_free(comp_verts, info->userdata); + num_vertices += comp_num_verts; + } + /* More components ? */ + more = flags & (1<<5); + } + } else { + /* numberOfCounters == 0, do nothing */ + } + + *pvertices = vertices; + return num_vertices; +} + +typedef struct +{ + int bounds; + int started; + int first_x, first_y; + int x, y; + stbtt_int32 min_x, max_x, min_y, max_y; + + stbtt_vertex *pvertices; + int num_vertices; +} stbtt__csctx; + +#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0} + +static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__track_vertex / static"); + if (x > c->max_x || !c->started) c->max_x = x; + if (y > c->max_y || !c->started) c->max_y = y; + if (x < c->min_x || !c->started) c->min_x = x; + if (y < c->min_y || !c->started) c->min_y = y; + c->started = 1; +} + +static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__csctx_v / static"); + if (c->bounds) { + stbtt__track_vertex(c, x, y); + if (type == STBTT_vcubic) { + stbtt__track_vertex(c, cx, cy); + stbtt__track_vertex(c, cx1, cy1); + } + } else { + stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy); + c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1; + c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1; + } + c->num_vertices++; +} + +static void stbtt__csctx_close_shape(stbtt__csctx *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__csctx_close_shape / static"); + if (ctx->first_x != ctx->x || ctx->first_y != ctx->y) + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, int dx, int dy) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__csctx_rmove_to / static"); + stbtt__csctx_close_shape(ctx); + ctx->first_x = ctx->x = ctx->x + dx; + ctx->first_y = ctx->y = ctx->y + dy; + stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rline_to(stbtt__csctx *ctx, int dx, int dy) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__csctx_rline_to / static"); + ctx->x += dx; + ctx->y += dy; + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__csctx_rccurve_to / static"); + int cx1 = ctx->x + dx1; + int cy1 = ctx->y + dy1; + int cx2 = cx1 + dx2; + int cy2 = cy1 + dy2; + ctx->x = cx2 + dx3; + ctx->y = cy2 + dy3; + stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2); +} + +static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__get_subr / static"); + int count = stbtt__cff_index_count(&idx); + int bias = 107; + if (count >= 33900) + bias = 32768; + else if (count >= 1240) + bias = 1131; + n += bias; + if (n < 0 || n >= count) + return stbtt__new_buf(NULL, 0); + return stbtt__cff_index_get(idx, n); +} + +static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cid_get_glyph_subrs / static"); + stbtt__buf fdselect = info->fdselect; + int nranges, start, end, v, fmt, fdselector = -1, i; + + stbtt__buf_seek(&fdselect, 0); + fmt = stbtt__buf_get8(&fdselect); + if (fmt == 0) { + /* untested */ + stbtt__buf_skip(&fdselect, glyph_index); + fdselector = stbtt__buf_get8(&fdselect); + } else if (fmt == 3) { + nranges = stbtt__buf_get16(&fdselect); + start = stbtt__buf_get16(&fdselect); + for (i = 0; i < nranges; i++) { + v = stbtt__buf_get8(&fdselect); + end = stbtt__buf_get16(&fdselect); + if (glyph_index >= start && glyph_index < end) { + fdselector = v; + break; + } + start = end; + } + } + if (fdselector == -1) stbtt__new_buf(NULL, 0); + return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector)); +} + +static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__run_charstring / static"); + int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; + int has_subrs = 0, clear_stack; + int s[48]; + stbtt__buf subr_stack[10], subrs = info->subrs, b; + int f; + + //writeSerialPort(boutRefNum, "stbtt__run_charstring"); +#define STBTT__CSERR(s) (0) + + /* this currently ignores the initial width value, which isn't needed if we have hmtx */ + b = stbtt__cff_index_get(info->charstrings, glyph_index); + while (b.cursor < b.size) { + i = 0; + clear_stack = 1; + b0 = stbtt__buf_get8(&b); + switch (b0) { + /* @TODO implement hinting */ + case 0x13: /* hintmask */ + case 0x14: /* cntrmask */ + if (in_header) + maskbits += (sp / 2); /* implicit "vstem" */ + in_header = 0; + stbtt__buf_skip(&b, (maskbits + 7) / 8); + break; + + case 0x01: /* hstem */ + case 0x03: /* vstem */ + case 0x12: /* hstemhm */ + case 0x17: /* vstemhm */ + maskbits += (sp / 2); + break; + + case 0x15: /* rmoveto */ + in_header = 0; + if (sp < 2) return STBTT__CSERR("rmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); + break; + case 0x04: /* vmoveto */ + in_header = 0; + if (sp < 1) return STBTT__CSERR("vmoveto stack"); + stbtt__csctx_rmove_to(c, 0, s[sp-1]); + break; + case 0x16: /* hmoveto */ + in_header = 0; + if (sp < 1) return STBTT__CSERR("hmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-1], 0); + break; + + case 0x05: /* rlineto */ + if (sp < 2) return STBTT__CSERR("rlineto stack"); + for (; i + 1 < sp; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + /* hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical */ + /* starting from a different place. */ + + case 0x07: /* vlineto */ + if (sp < 1) return STBTT__CSERR("vlineto stack"); + goto vlineto; + case 0x06: /* hlineto */ + if (sp < 1) return STBTT__CSERR("hlineto stack"); + for (;;) { + if (i >= sp) break; + stbtt__csctx_rline_to(c, s[i], 0); + i++; + vlineto: + if (i >= sp) break; + stbtt__csctx_rline_to(c, 0, s[i]); + i++; + } + break; + + case 0x1F: /* hvcurveto */ + if (sp < 4) return STBTT__CSERR("hvcurveto stack"); + goto hvcurveto; + case 0x1E: /* vhcurveto */ + if (sp < 4) return STBTT__CSERR("vhcurveto stack"); + for (;;) { + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f); + i += 4; + hvcurveto: + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]); + i += 4; + } + break; + + case 0x08: /* rrcurveto */ + if (sp < 6) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x18: /* rcurveline */ + if (sp < 8) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp - 2; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack"); + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + case 0x19: /* rlinecurve */ + if (sp < 8) return STBTT__CSERR("rlinecurve stack"); + for (; i + 1 < sp - 6; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack"); + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x1A: /* vvcurveto */ + case 0x1B: /* hhcurveto */ + if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); + f = 0.0; + if (sp & 1) { f = s[i]; i++; } + for (; i + 3 < sp; i += 4) { + if (b0 == 0x1B) + stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0); + else + stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]); + f = 0.0; + } + break; + + case 0x0A: /* callsubr */ + if (!has_subrs) { + if (info->fdselect.size) + subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); + has_subrs = 1; + } + /* fallthrough */ + case 0x1D: /* callgsubr */ + if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); + v = (int) s[--sp]; + if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); + subr_stack[subr_stack_height++] = b; + b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v); + if (b.size == 0) return STBTT__CSERR("subr not found"); + b.cursor = 0; + clear_stack = 0; + break; + + case 0x0B: /* return */ + if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); + b = subr_stack[--subr_stack_height]; + clear_stack = 0; + break; + + case 0x0E: /* endchar */ + stbtt__csctx_close_shape(c); + return 1; + + case 0x0C: { /* two-byte escape */ + int dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; + int dx, dy; + int b1 = stbtt__buf_get8(&b); + switch (b1) { + /* @TODO These "flex" implementations ignore the flex-depth and resolution, */ + /* and always draw beziers. */ + case 0x22: /* hflex */ + if (sp < 7) return STBTT__CSERR("hflex stack"); + dx1 = s[0]; + dx2 = s[1]; + dy2 = s[2]; + dx3 = s[3]; + dx4 = s[4]; + dx5 = s[5]; + dx6 = s[6]; + stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); + break; + + case 0x23: /* flex */ + if (sp < 13) return STBTT__CSERR("flex stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = s[10]; + dy6 = s[11]; + /* fd is s[12] */ + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + case 0x24: /* hflex1 */ + if (sp < 9) return STBTT__CSERR("hflex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dx4 = s[5]; + dx5 = s[6]; + dy5 = s[7]; + dx6 = s[8]; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); + break; + + case 0x25: /* flex1 */ + if (sp < 11) return STBTT__CSERR("flex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = dy6 = s[10]; + dx = dx1+dx2+dx3+dx4+dx5; + dy = dy1+dy2+dy3+dy4+dy5; + if (STBTT_fabs(dx) > STBTT_fabs(dy)) + dy6 = -dy; + else + dx6 = -dx; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + default: + return STBTT__CSERR("unimplemented"); + } + } break; + + default: + if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254)) + return STBTT__CSERR("reserved operator"); + + /* push immediate */ + if (b0 == 255) { + f = (int)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; + } else { + stbtt__buf_skip(&b, -1); + f = (int)(stbtt_int16)stbtt__cff_int(&b); + } + if (sp >= 48) return STBTT__CSERR("push stack overflow"); + s[sp++] = f; + clear_stack = 0; + break; + } + if (clear_stack) sp = 0; + } + return STBTT__CSERR("no endchar"); + +#undef STBTT__CSERR +} + +static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphShapeT2 / static"); + /* runs the charstring twice, once to count and once to output (to avoid realloc) */ + stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); + stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); + if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { + *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata); + output_ctx.pvertices = *pvertices; + if (stbtt__run_charstring(info, glyph_index, &output_ctx)) { + STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices); + return output_ctx.num_vertices; + } + } + *pvertices = NULL; + return 0; +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphInfoT2 / static"); + stbtt__csctx c = STBTT__CSCTX_INIT(1); + int r = stbtt__run_charstring(info, glyph_index, &c); + if (x0) *x0 = r ? c.min_x : 0; + if (y0) *y0 = r ? c.min_y : 0; + if (x1) *x1 = r ? c.max_x : 0; + if (y1) *y1 = r ? c.max_y : 0; + return r ? c.num_vertices : 0; +} + +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphShape / STBTT_DEF"); + if (!info->cff.size) + return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices); + else + return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices); +} + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphHMetrics / STBTT_DEF"); + stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); + if (glyph_index < numOfLongHorMetrics) { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); + } else { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); + } +} + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetKerningTableLength / STBTT_DEF"); + stbtt_uint8 *data = info->data + info->kern; + + /* we only look at the first table. it must be 'horizontal' and format 0. */ + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + return 0; + if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + return 0; + + return ttUSHORT(data+10); +} + +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetKerningTable / STBTT_DEF"); + stbtt_uint8 *data = info->data + info->kern; + int k, length; + + /* we only look at the first table. it must be 'horizontal' and format 0. */ + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + return 0; + if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + return 0; + + length = ttUSHORT(data+10); + if (table_length < length) + length = table_length; + + for (k = 0; k < length; k++) + { + table[k].glyph1 = ttUSHORT(data+18+(k*6)); + table[k].glyph2 = ttUSHORT(data+20+(k*6)); + table[k].advance = ttSHORT(data+22+(k*6)); + } + + return length; +} + +static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphKernInfoAdvance / static"); + stbtt_uint8 *data = info->data + info->kern; + stbtt_uint32 needle, straw; + int l, r, m; + + /* we only look at the first table. it must be 'horizontal' and format 0. */ + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + return 0; + if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + return 0; + + l = 0; + r = ttUSHORT(data+10) - 1; + needle = glyph1 << 16 | glyph2; + while (l <= r) { + m = (l + r) >> 1; + straw = ttULONG(data+18+(m*6)); /* note: unaligned read */ + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else + return ttSHORT(data+22+(m*6)); + } + return 0; +} + +static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetCoverageIndex / static"); + stbtt_uint16 coverageFormat = ttUSHORT(coverageTable); + switch(coverageFormat) { + case 1: { + stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); + + /* Binary search. */ + stbtt_int32 l=0, r=glyphCount-1, m; + int straw, needle=glyph; + while (l <= r) { + stbtt_uint8 *glyphArray = coverageTable + 4; + stbtt_uint16 glyphID; + m = (l + r) >> 1; + glyphID = ttUSHORT(glyphArray + 2 * m); + straw = glyphID; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + return m; + } + } + } break; + + case 2: { + stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); + stbtt_uint8 *rangeArray = coverageTable + 4; + + /* Binary search. */ + stbtt_int32 l=0, r=rangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *rangeRecord; + m = (l + r) >> 1; + rangeRecord = rangeArray + 6 * m; + strawStart = ttUSHORT(rangeRecord); + strawEnd = ttUSHORT(rangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else { + stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4); + return startCoverageIndex + glyph - strawStart; + } + } + } break; + + default: { + /* There are no other cases. */ + STBTT_assert(0); + } break; + } + + return -1; +} + +static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphClass / static"); + stbtt_uint16 classDefFormat = ttUSHORT(classDefTable); + switch(classDefFormat) + { + case 1: { + stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2); + stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4); + stbtt_uint8 *classDef1ValueArray = classDefTable + 6; + + if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount) + return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID)); + + classDefTable = classDef1ValueArray + 2 * glyphCount; + } break; + + case 2: { + stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); + stbtt_uint8 *classRangeRecords = classDefTable + 4; + + /* Binary search. */ + stbtt_int32 l=0, r=classRangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *classRangeRecord; + m = (l + r) >> 1; + classRangeRecord = classRangeRecords + 6 * m; + strawStart = ttUSHORT(classRangeRecord); + strawEnd = ttUSHORT(classRangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else + return (stbtt_int32)ttUSHORT(classRangeRecord + 4); + } + + classDefTable = classRangeRecords + 6 * classRangeCount; + } break; + + default: { + /* There are no other cases. */ + STBTT_assert(0); + } break; + } + + return -1; +} + +/* Define to STBTT_assert(x) if you want to break on unimplemented formats. */ +#define STBTT_GPOS_TODO_assert(x) + +static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__GetGlyphGPOSInfoAdvance / static"); + stbtt_uint16 lookupListOffset; + stbtt_uint8 *lookupList; + stbtt_uint16 lookupCount; + stbtt_uint8 *data; + stbtt_int32 i; + + if (!info->gpos) return 0; + + data = info->data + info->gpos; + + if (ttUSHORT(data+0) != 1) return 0; /* Major version 1 */ + if (ttUSHORT(data+2) != 0) return 0; /* Minor version 0 */ + + lookupListOffset = ttUSHORT(data+8); + lookupList = data + lookupListOffset; + lookupCount = ttUSHORT(lookupList); + + for (i=0; i> 1; + pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m; + secondGlyph = ttUSHORT(pairValue); + straw = secondGlyph; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + stbtt_int16 xAdvance = ttSHORT(pairValue + 2); + return xAdvance; + } + } + } break; + + case 2: { + stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); + stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); + + stbtt_uint16 classDef1Offset = ttUSHORT(table + 8); + stbtt_uint16 classDef2Offset = ttUSHORT(table + 10); + int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1); + int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2); + + stbtt_uint16 class1Count = ttUSHORT(table + 12); + stbtt_uint16 class2Count = ttUSHORT(table + 14); + STBTT_assert(glyph1class < class1Count); + STBTT_assert(glyph2class < class2Count); + + /* TODO: Support more formats. */ + STBTT_GPOS_TODO_assert(valueFormat1 == 4); + if (valueFormat1 != 4) return 0; + STBTT_GPOS_TODO_assert(valueFormat2 == 0); + if (valueFormat2 != 0) return 0; + + if (glyph1class >= 0 && glyph1class < class1Count && glyph2class >= 0 && glyph2class < class2Count) { + stbtt_uint8 *class1Records = table + 16; + stbtt_uint8 *class2Records = class1Records + 2 * (glyph1class * class2Count); + stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class); + return xAdvance; + } + } break; + + default: { + /* There are no other cases. */ + STBTT_assert(0); + break; + }; + } + } + break; + }; + + default: + /* TODO: Implement other stuff. */ + break; + } + } + + return 0; +} + +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphKernAdvance / STBTT_DEF"); + int xAdvance = 0; + + if (info->gpos) + xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2); + else if (info->kern) + xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2); + + return xAdvance; +} + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointKernAdvance / STBTT_DEF"); + if (!info->kern && !info->gpos) /* if no kerning table, don't waste time looking up both codepoint->glyphs */ + return 0; + return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); +} + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointHMetrics / STBTT_DEF"); + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetFontVMetrics / STBTT_DEF"); + if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); + if (descent) *descent = ttSHORT(info->data+info->hhea + 6); + if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); +} + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetFontVMetricsOS2 / STBTT_DEF"); + int tab = stbtt__find_table(info->data, info->fontstart, "OS/2"); + if (!tab) + return 0; + if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68); + if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70); + if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72); + return 1; +} + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetFontBoundingBox / STBTT_DEF"); + *x0 = ttSHORT(info->data + info->head + 36); + *y0 = ttSHORT(info->data + info->head + 38); + *x1 = ttSHORT(info->data + info->head + 40); + *y1 = ttSHORT(info->data + info->head + 42); +} + +STBTT_DEF int stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, int height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_ScaleForPixelHeight / STBTT_DEF"); + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (int) height / fheight; +} + +STBTT_DEF int stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, int pixels) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_ScaleForMappingEmToPixels / STBTT_DEF"); + int unitsPerEm = ttUSHORT(info->data + info->head + 18); + return pixels / unitsPerEm; +} + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FreeShape / STBTT_DEF"); + STBTT_free(v, info->userdata); +} + +STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FindSVGDoc / STBTT_DEF"); + int i; + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info); + + int numEntries = ttUSHORT(svg_doc_list); + stbtt_uint8 *svg_docs = svg_doc_list + 2; + + for(i=0; i= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2))) + return svg_doc; + } + return 0; +} + +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphSVG / STBTT_DEF"); + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc; + + if (info->svg == 0) + return 0; + + svg_doc = stbtt_FindSVGDoc(info, gl); + if (svg_doc != NULL) { + *svg = (char *) data + info->svg + ttULONG(svg_doc + 4); + return ttULONG(svg_doc + 8); + } else { + return 0; + } +} + +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointSVG / STBTT_DEF"); + return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* antialiasing software rasterizer */ +/* */ + +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, int scale_x, int scale_y,int shift_x, int shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphBitmapBoxSubpixel / STBTT_DEF"); + int x0=0,y0=0,x1,y1; /* =0 suppresses compiler warning */ + if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { + /* e.g. space character */ + if (ix0) *ix0 = 0; + if (iy0) *iy0 = 0; + if (ix1) *ix1 = 0; + if (iy1) *iy1 = 0; + } else { + /* move to integral bboxes (treating pixels as little squares, what pixels get touched)? */ + if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); + if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); + if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); + if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y); + } +} + +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, int scale_x, int scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetGlyphBitmapBox / STBTT_DEF"); + stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, int scale_x, int scale_y, int shift_x, int shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointBitmapBoxSubpixel / STBTT_DEF"); + stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, int scale_x, int scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetCodepointBitmapBox / STBTT_DEF"); + stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* Rasterizer */ + +typedef struct stbtt__hheap_chunk +{ + struct stbtt__hheap_chunk *next; +} stbtt__hheap_chunk; + +typedef struct stbtt__hheap +{ + struct stbtt__hheap_chunk *head; + void *first_free; + int num_remaining_in_head_chunk; +} stbtt__hheap; + +static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__hheap_alloc / static"); + if (hh->first_free) { + void *p = hh->first_free; + hh->first_free = * (void **) p; + return p; + } else { + if (hh->num_remaining_in_head_chunk == 0) { + int count = (size < 32 ? 2000 : size < 128 ? 800 : 100); + stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata); + if (c == NULL) + return NULL; + c->next = hh->head; + hh->head = c; + hh->num_remaining_in_head_chunk = count; + } + --hh->num_remaining_in_head_chunk; + return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk; + } +} + +static void stbtt__hheap_free(stbtt__hheap *hh, void *p) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__hheap_free / static"); + *(void **) p = hh->first_free; + hh->first_free = p; +} + +static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__hheap_cleanup / static"); + stbtt__hheap_chunk *c = hh->head; + while (c) { + stbtt__hheap_chunk *n = c->next; + STBTT_free(c, userdata); + c = n; + } +} + +typedef struct stbtt__edge { + int x0,y0, x1,y1; + int invert; +} stbtt__edge; + + +typedef struct stbtt__active_edge +{ + struct stbtt__active_edge *next; + #if STBTT_RASTERIZER_VERSION==1 + int x,dx; + int ey; + int direction; + #elif STBTT_RASTERIZER_VERSION==2 + int fx,fdx,fdy; + int direction; + int sy; + int ey; + #else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" + #endif +} stbtt__active_edge; + +#if STBTT_RASTERIZER_VERSION == 1 +#define STBTT_FIXSHIFT 10 +#define STBTT_FIX (1 << STBTT_FIXSHIFT) +#define STBTT_FIXMASK (STBTT_FIX-1) + +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, int start_point, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__new_active / static"); + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + int dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + if (!z) return z; + + /* round dx down to avoid overshooting */ + if (dxdy < 0) + z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); + else + z->dx = STBTT_ifloor(STBTT_FIX * dxdy); + + z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); /* use z->dx so when we offset later it's by the same amount */ + z->x -= off_x * STBTT_FIX; + + z->ey = e->y1; + z->next = 0; + z->direction = e->invert ? 1 : -1; + return z; +} +#elif STBTT_RASTERIZER_VERSION == 2 +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, int start_point, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__new_active / static"); + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + int dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + /* STBTT_assert(e->y0 <= start_point); */ + if (!z) return z; + z->fdx = dxdy; + z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; + z->fx = e->x0 + dxdy * (start_point - e->y0); + z->fx -= off_x; + z->direction = e->invert ? 1.0f : -1.0f; + z->sy = e->y0; + z->ey = e->y1; + z->next = 0; + return z; +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#if STBTT_RASTERIZER_VERSION == 1 +/* note: this routine clips fills that extend off the edges... ideally this */ +/* wouldn't happen, but it could happen if the truetype glyph bounding boxes */ +/* are wrong, or if the user supplies a too-small bitmap */ +static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__fill_active_edges / static"); + /* non-zero winding fill */ + int x0=0, w=0; + + while (e) { + if (w == 0) { + /* if we're currently at zero, we need to record the edge start point */ + x0 = e->x; w += e->direction; + } else { + int x1 = e->x; w += e->direction; + /* if we went to zero, we need to draw */ + if (w == 0) { + int i = x0 >> STBTT_FIXSHIFT; + int j = x1 >> STBTT_FIXSHIFT; + + if (i < len && j >= 0) { + if (i == j) { + /* x0,x1 are the same pixel, so compute combined coverage */ + scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); + } else { + if (i >= 0) /* add antialiasing for x0 */ + scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); + else + i = -1; /* clip */ + + if (j < len) /* add antialiasing for x1 */ + scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); + else + j = len; /* clip */ + + for (++i; i < j; ++i) /* fill pixels between x0 and x1 */ + scanline[i] = scanline[i] + (stbtt_uint8) max_weight; + } + } + } + } + + e = e->next; + } +} + +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__rasterize_sorted_edges / static"); + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0; + int max_weight = (255 / vsubsample); /* weight per vertical scanline */ + int s; /* vertical subsample index */ + unsigned char scanline_data[512], *scanline; + + if (result->w > 512) + scanline = (unsigned char *) STBTT_malloc(result->w, userdata); + else + scanline = scanline_data; + + y = off_y * vsubsample; + e[n].y0 = (off_y + result->h) * (int) vsubsample + 1; + + while (j < result->h) { + STBTT_memset(scanline, 0, result->w); + for (s=0; s < vsubsample; ++s) { + /* find center of pixel for this scanline */ + int scan_y = y + 0.5f; + stbtt__active_edge **step = &active; + + /* update all active edges; */ + /* remove all active edges that terminate before the center of this scanline */ + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y) { + *step = z->next; /* delete from list */ + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + z->x += z->dx; /* advance to position for current scanline */ + step = &((*step)->next); /* advance through list */ + } + } + + /* resort the list if needed */ + for(;;) { + int changed=0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + stbtt__active_edge *t = *step; + stbtt__active_edge *q = t->next; + + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + /* insert all edges that start before the center of this scanline -- omit ones that also end on this scanline */ + while (e->y0 <= scan_y) { + if (e->y1 > scan_y) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); + if (z != NULL) { + /* find insertion point */ + if (active == NULL) + active = z; + else if (z->x < active->x) { + /* insert at front */ + z->next = active; + active = z; + } else { + /* find thing to insert AFTER */ + stbtt__active_edge *p = active; + while (p->next && p->next->x < z->x) + p = p->next; + /* at this point, p->next->x is NOT < z->x */ + z->next = p->next; + p->next = z; + } + } + } + ++e; + } + + /* now process all active edges in XOR fashion */ + if (active) + stbtt__fill_active_edges(scanline, result->w, active, max_weight); + + ++y; + } + STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} + +#elif STBTT_RASTERIZER_VERSION == 2 + +/* the edge passed in here does not cross the vertical line at x or the vertical line at x+1 */ +/* (i.e. it has already been clipped to those) */ +static void stbtt__handle_clipped_edge(int *scanline, int x, stbtt__active_edge *e, int x0, int y0, int x1, int y1) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__handle_clipped_edge / static"); + if (y0 == y1) return; + STBTT_assert(y0 < y1); + STBTT_assert(e->sy <= e->ey); + if (y0 > e->ey) return; + if (y1 < e->sy) return; + if (y0 < e->sy) { + x0 += (x1-x0) * (e->sy - y0) / (y1-y0); + y0 = e->sy; + } + if (y1 > e->ey) { + x1 += (x1-x0) * (e->ey - y1) / (y1-y0); + y1 = e->ey; + } + + if (x0 == x) + STBTT_assert(x1 <= x+1); + else if (x0 == x+1) + STBTT_assert(x1 >= x); + else if (x0 <= x) + STBTT_assert(x1 <= x); + else if (x0 >= x+1) + STBTT_assert(x1 >= x+1); + else + STBTT_assert(x1 >= x && x1 <= x+1); + + if (x0 <= x && x1 <= x) + scanline[x] += e->direction * (y1-y0); + else if (x0 >= x+1 && x1 >= x+1) + ; + else { + STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); + scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); /* coverage = 1 - average x position */ + } +} + +static void stbtt__fill_active_edges_new(int *scanline, int *scanline_fill, int len, stbtt__active_edge *e, int y_top) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__fill_active_edges_new / static"); + int y_bottom = y_top+1; + + while (e) { + /* brute force every pixel */ + + /* compute intersection points with top & bottom */ + STBTT_assert(e->ey >= y_top); + + if (e->fdx == 0) { + int x0 = e->fx; + if (x0 < len) { + if (x0 >= 0) { + stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom); + stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom); + } else { + stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom); + } + } + } else { + int x0 = e->fx; + int dx = e->fdx; + int xb = x0 + dx; + int x_top, x_bottom; + int sy0,sy1; + int dy = e->fdy; + STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); + + /* compute endpoints of line segment clipped to this scanline (if the */ + /* line segment starts on this scanline. x0 is the intersection of the */ + /* line with y_top, but that may be off the line segment. */ + if (e->sy > y_top) { + x_top = x0 + dx * (e->sy - y_top); + sy0 = e->sy; + } else { + x_top = x0; + sy0 = y_top; + } + if (e->ey < y_bottom) { + x_bottom = x0 + dx * (e->ey - y_top); + sy1 = e->ey; + } else { + x_bottom = xb; + sy1 = y_bottom; + } + + if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { + /* from here on, we don't have to range check x values */ + + if ((int) x_top == (int) x_bottom) { + int height; + /* simple case, only spans one pixel */ + int x = (int) x_top; + height = sy1 - sy0; + STBTT_assert(x >= 0 && x < len); + scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2) * height; + scanline_fill[x] += e->direction * height; /* everything right of this pixel is filled */ + } else { + int x,x1,x2; + int y_crossing, step, sign, area; + /* covers 2+ pixels */ + if (x_top > x_bottom) { + /* flip scanline vertically; signed area is the same */ + int t; + sy0 = y_bottom - (sy0 - y_top); + sy1 = y_bottom - (sy1 - y_top); + t = sy0, sy0 = sy1, sy1 = t; + t = x_bottom, x_bottom = x_top, x_top = t; + dx = -dx; + dy = -dy; + t = x0, x0 = xb, xb = t; + } + + x1 = (int) x_top; + x2 = (int) x_bottom; + /* compute intersection with y axis at x1+1 */ + y_crossing = (x1+1 - x0) * dy + y_top; + + sign = e->direction; + /* area of the rectangle covered from y0..y_crossing */ + area = sign * (y_crossing-sy0); + /* area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing) */ + scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2); + + step = sign * dy; + for (x = x1+1; x < x2; ++x) { + scanline[x] += area + step/2; + area += step; + } + y_crossing += dy * (x2 - (x1+1)); + + STBTT_assert(STBTT_fabs(area) <= 1.01f); + + scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing); + + scanline_fill[x2] += sign * (sy1-sy0); + } + } else { + /* if edge goes outside of box we're drawing, we require */ + /* clipping logic. since this does not match the intended use */ + /* of this library, we use a different, very slow brute */ + /* force implementation */ + int x; + for (x=0; x < len; ++x) { + /* cases: */ + /* */ + /* there can be up to two intersections with the pixel. any intersection */ + /* with left or right edges can be handled by splitting into two (or three) */ + /* regions. intersections with top & bottom do not necessitate case-wise logic. */ + /* */ + /* the old way of doing this found the intersections with the left & right edges, */ + /* then used some simple logic to produce up to three segments in sorted order */ + /* from top-to-bottom. however, this had a problem: if an x edge was epsilon */ + /* across the x border, then the corresponding y position might not be distinct */ + /* from the other y segment, and it might ignored as an empty segment. to avoid */ + /* that, we need to explicitly produce segments based on x positions. */ + + /* rename variables to clearly-defined pairs */ + int y0 = y_top; + int x1 = (int) (x); + int x2 = (int) (x+1); + int x3 = xb; + int y3 = y_bottom; + + /* x = e->x + e->dx * (y-y_top) */ + /* (y-y_top) = (x - e->x) / e->dx */ + /* y = (x - e->x) / e->dx + y_top */ + int y1 = (x - x0) / dx + y_top; + int y2 = (x+1 - x0) / dx + y_top; + + if (x0 < x1 && x3 > x2) { /* three segments descending down-right */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x1 && x0 > x2) { /* three segments descending down-left */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x1 && x3 > x1) { /* two segments across x, down-right */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x3 < x1 && x0 > x1) { /* two segments across x, down-left */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x2 && x3 > x2) { /* two segments across x+1, down-right */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x2 && x0 > x2) { /* two segments across x+1, down-left */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else { /* one segment */ + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); + } + } + } + } + e = e->next; + } +} + +/* directly AA rasterize edges w/o supersampling */ +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__rasterize_sorted_edges / static"); + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0, i; + int scanline_data[129], *scanline, *scanline2; + + STBTT__NOTUSED(vsubsample); + + if (result->w > 64) + scanline = (int *) STBTT_malloc((result->w*2+1) * sizeof(int), userdata); + else + scanline = scanline_data; + + scanline2 = scanline + result->w; + + y = off_y; + e[n].y0 = (int) (off_y + result->h) + 1; + + while (j < result->h) { + /* find center of pixel for this scanline */ + int scan_y_top = y + 0.0f; + int scan_y_bottom = y + 1.0f; + stbtt__active_edge **step = &active; + + STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); + STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); + + /* update all active edges; */ + /* remove all active edges that terminate before the top of this scanline */ + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y_top) { + *step = z->next; /* delete from list */ + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + step = &((*step)->next); /* advance through list */ + } + } + + /* insert all edges that start before the bottom of this scanline */ + while (e->y0 <= scan_y_bottom) { + if (e->y0 != e->y1) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); + if (z != NULL) { + if (j == 0 && off_y != 0) { + if (z->ey < scan_y_top) { + /* this can happen due to subpixel positioning and some kind of fp rounding error i think */ + z->ey = scan_y_top; + } + } + STBTT_assert(z->ey >= scan_y_top); /* if we get really unlucky a tiny bit of an edge can be out of bounds */ + /* insert at front */ + z->next = active; + active = z; + } + } + ++e; + } + + /* now process all active edges */ + if (active) + stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); + + { + int sum = 0; + for (i=0; i < result->w; ++i) { + int k; + int m; + sum += scanline2[i]; + k = scanline[i] + sum; + k = (int) STBTT_fabs(k)*255 + 0.5f; + m = (int) k; + if (m > 255) m = 255; + result->pixels[j*result->stride + i] = (unsigned char) m; + } + } + /* advance all the edges */ + step = &active; + while (*step) { + stbtt__active_edge *z = *step; + z->fx += z->fdx; /* advance to position for current scanline */ + step = &((*step)->next); /* advance through list */ + } + + ++y; + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0) + +static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__sort_edges_ins_sort / static"); + int i,j; + for (i=1; i < n; ++i) { + stbtt__edge t = p[i], *a = &t; + j = i; + while (j > 0) { + stbtt__edge *b = &p[j-1]; + int c = STBTT__COMPARE(a,b); + if (!c) break; + p[j] = p[j-1]; + --j; + } + if (i != j) + p[j] = t; + } +} + +static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__sort_edges_quicksort / static"); + /* threshold for transitioning to insertion sort */ + while (n > 12) { + stbtt__edge t; + int c01,c12,c,m,i,j; + + /* compute median of three */ + m = n >> 1; + c01 = STBTT__COMPARE(&p[0],&p[m]); + c12 = STBTT__COMPARE(&p[m],&p[n-1]); + /* if 0 >= mid >= end, or 0 < mid < end, then use mid */ + if (c01 != c12) { + /* otherwise, we'll need to swap something else to middle */ + int z; + c = STBTT__COMPARE(&p[0],&p[n-1]); + /* 0>mid && midn => n; 0 0 */ + /* 0n: 0>n => 0; 0 n */ + z = (c == c12) ? 0 : n-1; + t = p[z]; + p[z] = p[m]; + p[m] = t; + } + /* now p[m] is the median-of-three */ + /* swap it to the beginning so it won't move around */ + t = p[0]; + p[0] = p[m]; + p[m] = t; + + /* partition loop */ + i=1; + j=n-1; + for(;;) { + /* handling of equality is crucial here */ + /* for sentinels & efficiency with duplicates */ + for (;;++i) { + if (!STBTT__COMPARE(&p[i], &p[0])) break; + } + for (;;--j) { + if (!STBTT__COMPARE(&p[0], &p[j])) break; + } + /* make sure we haven't crossed */ + if (i >= j) break; + t = p[i]; + p[i] = p[j]; + p[j] = t; + + ++i; + --j; + } + /* recurse on smaller side, iterate on larger */ + if (j < (n-i)) { + stbtt__sort_edges_quicksort(p,j); + p = p+i; + n = n-i; + } else { + stbtt__sort_edges_quicksort(p+i, n-i); + n = j; + } + } +} + +static void stbtt__sort_edges(stbtt__edge *p, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__sort_edges / static"); + stbtt__sort_edges_quicksort(p, n); + stbtt__sort_edges_ins_sort(p, n); +} + +typedef struct +{ + int x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, int scale_x, int scale_y, int shift_x, int shift_y, int off_x, int off_y, int invert, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__rasterize / static"); + int y_scale_inv = invert ? -scale_y : scale_y; + stbtt__edge *e; + int n,i,j,k,m; +#if STBTT_RASTERIZER_VERSION == 1 + int vsubsample = result->h < 8 ? 15 : 5; +#elif STBTT_RASTERIZER_VERSION == 2 + int vsubsample = 1; +#else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + /* vsubsample should divide 255 evenly; otherwise we won't reach full opacity */ + + /* now we have to blow out the windings into explicit edge lists */ + n = 0; + for (i=0; i < windings; ++i) + n += wcount[i]; + + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); /* add an extra one as a sentinel */ + if (e == 0) return; + n = 0; + + m=0; + for (i=0; i < windings; ++i) { + stbtt__point *p = pts + m; + m += wcount[i]; + j = wcount[i]-1; + for (k=0; k < wcount[i]; j=k++) { + int a=k,b=j; + /* skip the edge if horizontal */ + if (p[j].y == p[k].y) + continue; + /* add edge from j to k to the list */ + e[n].invert = 0; + if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { + e[n].invert = 1; + a=j,b=k; + } + e[n].x0 = p[a].x * scale_x + shift_x; + e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample; + e[n].x1 = p[b].x * scale_x + shift_x; + e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; + ++n; + } + } + + /* now sort the edges by their highest point (should snap to integer, and then by x) */ + /* STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); */ + stbtt__sort_edges(e, n); + + /* now, traverse the scanlines and find the intersections on each scanline, use xor winding rule */ + stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); + + STBTT_free(e, userdata); +} + +static void stbtt__add_point(stbtt__point *points, int n, int x, int y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__add_point / static"); + if (!points) return; /* during first pass, it's unallocated */ + points[n].x = x; + points[n].y = y; +} + +/* tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching */ +static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, int x0, int y0, int x1, int y1, int x2, int y2, int objspace_flatness_squared, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__tesselate_curve / static"); + /* midpoint */ + int mx = (x0 + 2*x1 + x2)/4; + int my = (y0 + 2*y1 + y2)/4; + /* versus directly drawn line */ + int dx = (x0+x2)/2 - mx; + int dy = (y0+y2)/2 - my; + if (n > 16) /* 65536 segments on one curve better be enough! */ + return 1; + if (dx*dx+dy*dy > objspace_flatness_squared) { /* half-pixel error allowed... need to be smaller if AA */ + stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x2,y2); + *num_points = *num_points+1; + } + return 1; +} + +static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int objspace_flatness_squared, int n) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__tesselate_cubic / static"); + /* @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough */ + int dx0 = x1-x0; + int dy0 = y1-y0; + int dx1 = x2-x1; + int dy1 = y2-y1; + int dx2 = x3-x2; + int dy2 = y3-y2; + int dx = x3-x0; + int dy = y3-y0; + int longlen = (int) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); + int shortlen = (int) STBTT_sqrt(dx*dx+dy*dy); + int flatness_squared = longlen*longlen-shortlen*shortlen; + + if (n > 16) /* 65536 segments on one curve better be enough! */ + return; + + if (flatness_squared > objspace_flatness_squared) { + int x01 = (x0+x1)/2; + int y01 = (y0+y1)/2; + int x12 = (x1+x2)/2; + int y12 = (y1+y2)/2; + int x23 = (x2+x3)/2; + int y23 = (y2+y3)/2; + + int xa = (x01+x12)/2; + int ya = (y01+y12)/2; + int xb = (x12+x23)/2; + int yb = (y12+y23)/2; + + int mx = (xa+xb)/2; + int my = (ya+yb)/2; + + stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x3,y3); + *num_points = *num_points+1; + } +} + +/* returns number of contours */ +static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, int objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FlattenCurves / static"); + stbtt__point *points=0; + int num_points=0; + + int objspace_flatness_squared = objspace_flatness * objspace_flatness; + int i,n=0,start=0, pass; + + /* count how many "moves" there are to get the contour count */ + for (i=0; i < num_verts; ++i) + if (vertices[i].type == STBTT_vmove) + ++n; + + *num_contours = n; + if (n == 0) return 0; + + *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); + + if (*contour_lengths == 0) { + *num_contours = 0; + return 0; + } + + /* make two passes through the points so we don't need to realloc */ + for (pass=0; pass < 2; ++pass) { + int x=0,y=0; + if (pass == 1) { + points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); + if (points == NULL) goto error; + } + num_points = 0; + n= -1; + for (i=0; i < num_verts; ++i) { + switch (vertices[i].type) { + case STBTT_vmove: + /* start the next contour */ + if (n >= 0) + (*contour_lengths)[n] = num_points - start; + ++n; + start = num_points; + + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x,y); + break; + case STBTT_vline: + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x, y); + break; + case STBTT_vcurve: + stbtt__tesselate_curve(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + case STBTT_vcubic: + stbtt__tesselate_cubic(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].cx1, vertices[i].cy1, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + } + } + (*contour_lengths)[n] = num_points - start; + } + + return points; +error: + STBTT_free(points, userdata); + STBTT_free(*contour_lengths, userdata); + *contour_lengths = 0; + *num_contours = 0; + return NULL; +} + +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, int flatness_in_pixels, stbtt_vertex *vertices, int num_verts, int scale_x, int scale_y, int shift_x, int shift_y, int x_off, int y_off, int invert, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_Rasterize / STBTT_DEF"); + int scale = scale_x > scale_y ? scale_y : scale_x; + int winding_count = 0; + int *winding_lengths = NULL; + stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); + if (windings) { + stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); + STBTT_free(winding_lengths, userdata); + STBTT_free(windings, userdata); + } +} + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FreeBitmap / STBTT_DEF"); + STBTT_free(bitmap, userdata); +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, int scale_x, int scale_y, int shift_x, int shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + int ix0,iy0,ix1,iy1; + stbtt__bitmap gbm; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + + if (scale_x == 0) scale_x = scale_y; + if (scale_y == 0) { + if (scale_x == 0) { + STBTT_free(vertices, info->userdata); + return NULL; + } + scale_y = scale_x; + } + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); + + /* now we get the size */ + gbm.w = (ix1 - ix0); + gbm.h = (iy1 - iy0); + gbm.pixels = NULL; /* in case we error */ + + if (width ) *width = gbm.w; + if (height) *height = gbm.h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + if (gbm.w && gbm.h) { + gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); + if (gbm.pixels) { + gbm.stride = gbm.w; + + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); + } + } + STBTT_free(vertices, info->userdata); + return gbm.pixels; +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, int scale_x, int scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeGlyphBitmapSubpixel / STBTT_DEF"); + int ix0,iy0; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + stbtt__bitmap gbm; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); + gbm.pixels = output; + gbm.w = out_w; + gbm.h = out_h; + gbm.stride = out_stride; + + if (gbm.w && gbm.h) + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); + + STBTT_free(vertices, info->userdata); +} + +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeGlyphBitmap / STBTT_DEF"); + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, int scale_x, int scale_y, int shift_x, int shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int oversample_x, int oversample_y, int *sub_x, int *sub_y, int codepoint) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeCodepointBitmapSubpixelPrefilter / STBTT_DEF"); + stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int codepoint) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeCodepointBitmapSubpixel / STBTT_DEF"); + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, int scale_x, int scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int codepoint) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeCodepointBitmap / STBTT_DEF"); + stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* bitmap baking */ +/* */ +/* This is SUPER-CRAPPY packing to keep source code small */ + +static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, /* font location (use offset=0 for plain .ttf) */ + int pixel_height, /* height of font in pixels */ + unsigned char *pixels, int pw, int ph, /* bitmap to be filled in */ + int first_char, int num_chars, /* characters to bake */ + stbtt_bakedchar *chardata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - chardata) / stbtt_bakedchar"); + int scale; + int x,y,bottom_y, i; + stbtt_fontinfo f; + f.userdata = NULL; + if (!stbtt_InitFont(&f, data, offset)) + return -1; + STBTT_memset(pixels, 0, pw*ph); /* background of 0 around pixels */ + x=y=1; + bottom_y = 1; + + scale = stbtt_ScaleForPixelHeight(&f, pixel_height); + + for (i=0; i < num_chars; ++i) { + int advance, lsb, x0,y0,x1,y1,gw,gh; + int g = stbtt_FindGlyphIndex(&f, first_char + i); + stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); + stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); + gw = x1-x0; + gh = y1-y0; + if (x + gw + 1 >= pw) + y = bottom_y, x = 1; /* advance to next row */ + if (y + gh + 1 >= ph) /* check if it fits vertically AFTER potentially moving to next row */ + return -i; + STBTT_assert(x+gw < pw); + STBTT_assert(y+gh < ph); + stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); + chardata[i].x0 = (stbtt_int16) x; + chardata[i].y0 = (stbtt_int16) y; + chardata[i].x1 = (stbtt_int16) (x + gw); + chardata[i].y1 = (stbtt_int16) (y + gh); + chardata[i].xadvance = scale * advance; + chardata[i].xoff = (int) x0; + chardata[i].yoff = (int) y0; + x = x + gw + 1; + if (y+gh+1 > bottom_y) + bottom_y = y+gh+1; + } + return bottom_y; +} + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, int *xpos, int *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetBakedQuad / STBTT_DEF"); + int d3d_bias = opengl_fillrule ? 0 : -0.5f; + int ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_bakedchar *b = chardata + char_index; + int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f); + int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f); + + q->x0 = round_x + d3d_bias; + q->y0 = round_y + d3d_bias; + q->x1 = round_x + b->x1 - b->x0 + d3d_bias; + q->y1 = round_y + b->y1 - b->y0 + d3d_bias; + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* rectangle packing replacement routines if you don't have stb_rect_pack.h */ +/* */ + +#ifndef STB_RECT_PACK_VERSION + +typedef int stbrp_coord; + +/* ////////////////////////////////////////////////////////////////////////////////// */ +/* // */ +/* // */ +/* COMPILER WARNING ?!?!? // */ +/* // */ +/* // */ +/* if you get a compile warning due to these symbols being defined more than // */ +/* once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // */ +/* // */ +/* ////////////////////////////////////////////////////////////////////////////////// */ + +typedef struct +{ + int width,height; + int x,y,bottom_y; +} stbrp_context; + +typedef struct +{ + unsigned char x; +} stbrp_node; + +struct stbrp_rect +{ + stbrp_coord x,y; + int id,w,h,was_packed; +}; + +static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_init_target / static"); + con->width = pw; + con->height = ph; + con->x = 0; + con->y = 0; + con->bottom_y = 0; + STBTT__NOTUSED(nodes); + STBTT__NOTUSED(num_nodes); +} + +static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbrp_pack_rects / static"); + int i; + for (i=0; i < num_rects; ++i) { + if (con->x + rects[i].w > con->width) { + con->x = 0; + con->y = con->bottom_y; + } + if (con->y + rects[i].h > con->height) + break; + rects[i].x = con->x; + rects[i].y = con->y; + rects[i].was_packed = 1; + con->x += rects[i].w; + if (con->y + rects[i].h > con->bottom_y) + con->bottom_y = con->y + rects[i].h; + } + for ( ; i < num_rects; ++i) + rects[i].was_packed = 0; +} +#endif + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* bitmap baking */ +/* */ +/* This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If */ +/* stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. */ + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackBegin / STBTT_DEF"); + stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context); + int num_nodes = pw - padding; + stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context); + + if (context == NULL || nodes == NULL) { + if (context != NULL) STBTT_free(context, alloc_context); + if (nodes != NULL) STBTT_free(nodes , alloc_context); + return 0; + } + + spc->user_allocator_context = alloc_context; + spc->width = pw; + spc->height = ph; + spc->pixels = pixels; + spc->pack_info = context; + spc->nodes = nodes; + spc->padding = padding; + spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw; + spc->h_oversample = 1; + spc->v_oversample = 1; + spc->skip_missing = 0; + + stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); + + if (pixels) + STBTT_memset(pixels, 0, pw*ph); /* background of 0 around pixels */ + + return 1; +} + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackEnd / STBTT_DEF"); + STBTT_free(spc->nodes , spc->user_allocator_context); + STBTT_free(spc->pack_info, spc->user_allocator_context); +} + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackSetOversampling / STBTT_DEF"); + STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE); + STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE); + if (h_oversample <= STBTT_MAX_OVERSAMPLE) + spc->h_oversample = h_oversample; + if (v_oversample <= STBTT_MAX_OVERSAMPLE) + spc->v_oversample = v_oversample; +} + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackSetSkipMissingCodepoints / STBTT_DEF"); + spc->skip_missing = skip; +} + +#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1) + +static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__h_prefilter / static"); + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_w = w - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); /* suppress bogus warning from VS2013 -analyze */ + for (j=0; j < h; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + /* make kernel_width a constant in common cases so compiler can optimize out the divide */ + switch (kernel_width) { + case 2: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < w; ++i) { + STBTT_assert(pixels[i] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i] = (unsigned char) (total / kernel_width); + } + + pixels += stride_in_bytes; + } +} + +static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__v_prefilter / static"); + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_h = h - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); /* suppress bogus warning from VS2013 -analyze */ + for (j=0; j < w; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + /* make kernel_width a constant in common cases so compiler can optimize out the divide */ + switch (kernel_width) { + case 2: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < h; ++i) { + STBTT_assert(pixels[i*stride_in_bytes] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + + pixels += 1; + } +} + +static int stbtt__oversample_shift(int oversample) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__oversample_shift / static"); + if (!oversample) + return 0.0f; + + /* The prefilter is a box filter of width "oversample", */ + /* which shifts phase by (oversample - 1)/2 pixels in */ + /* oversampled space. We want to shift in the opposite */ + /* direction to counter this. */ + return (int)-(oversample - 1) / (2.0f * (int)oversample); +} + +/* rects array must be big enough to accommodate all characters in the given ranges */ +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackFontRangesGatherRects / STBTT_DEF"); + int i,j,k; + int missing_glyph_added = 0; + + k=0; + for (i=0; i < num_ranges; ++i) { + int fh = ranges[i].font_size; + int scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + ranges[i].h_oversample = (unsigned char) spc->h_oversample; + ranges[i].v_oversample = (unsigned char) spc->v_oversample; + for (j=0; j < ranges[i].num_chars; ++j) { + int x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) { + rects[k].w = rects[k].h = 0; + } else { + stbtt_GetGlyphBitmapBoxSubpixel(info,glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + &x0,&y0,&x1,&y1); + rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1); + rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1); + if (glyph == 0) + missing_glyph_added = 1; + } + ++k; + } + } + + return k; +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, int scale_x, int scale_y, int shift_x, int shift_y, int prefilter_x, int prefilter_y, int *sub_x, int *sub_y, int glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_MakeGlyphBitmapSubpixelPrefilter / STBTT_DEF"); + stbtt_MakeGlyphBitmapSubpixel(info, + output, + out_w - (prefilter_x - 1), + out_h - (prefilter_y - 1), + out_stride, + scale_x, + scale_y, + shift_x, + shift_y, + glyph); + + if (prefilter_x > 1) + stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x); + + if (prefilter_y > 1) + stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y); + + *sub_x = stbtt__oversample_shift(prefilter_x); + *sub_y = stbtt__oversample_shift(prefilter_y); +} + +/* rects array must be big enough to accommodate all characters in the given ranges */ +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackFontRangesRenderIntoRects / STBTT_DEF"); + int i,j,k, missing_glyph = -1, return_value = 1; + + /* save current values */ + int old_h_over = spc->h_oversample; + int old_v_over = spc->v_oversample; + + k = 0; + for (i=0; i < num_ranges; ++i) { + int fh = ranges[i].font_size; + int scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + int recip_h,recip_v,sub_x,sub_y; + spc->h_oversample = ranges[i].h_oversample; + spc->v_oversample = ranges[i].v_oversample; + recip_h = 1.0f / spc->h_oversample; + recip_v = 1.0f / spc->v_oversample; + sub_x = stbtt__oversample_shift(spc->h_oversample); + sub_y = stbtt__oversample_shift(spc->v_oversample); + for (j=0; j < ranges[i].num_chars; ++j) { + stbrp_rect *r = &rects[k]; + if (r->was_packed && r->w != 0 && r->h != 0) { + stbtt_packedchar *bc = &ranges[i].chardata_for_range[j]; + int advance, lsb, x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + stbrp_coord pad = (stbrp_coord) spc->padding; + + /* pad on left and top */ + r->x += pad; + r->y += pad; + r->w -= pad; + r->h -= pad; + stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb); + stbtt_GetGlyphBitmapBox(info, glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + &x0,&y0,&x1,&y1); + stbtt_MakeGlyphBitmapSubpixel(info, + spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w - spc->h_oversample+1, + r->h - spc->v_oversample+1, + spc->stride_in_bytes, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + glyph); + + if (spc->h_oversample > 1) + stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->h_oversample); + + if (spc->v_oversample > 1) + stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->v_oversample); + + bc->x0 = (stbtt_int16) r->x; + bc->y0 = (stbtt_int16) r->y; + bc->x1 = (stbtt_int16) (r->x + r->w); + bc->y1 = (stbtt_int16) (r->y + r->h); + bc->xadvance = scale * advance; + bc->xoff = (int) x0 * recip_h + sub_x; + bc->yoff = (int) y0 * recip_v + sub_y; + bc->xoff2 = (x0 + r->w) * recip_h + sub_x; + bc->yoff2 = (y0 + r->h) * recip_v + sub_y; + + if (glyph == 0) + missing_glyph = j; + } else if (spc->skip_missing) { + return_value = 0; + } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { + ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; + } else { + return_value = 0; /* if any fail, report failure */ + } + + ++k; + } + } + + /* restore original values */ + spc->h_oversample = old_h_over; + spc->v_oversample = old_v_over; + + return return_value; +} + +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackFontRangesPackRects / STBTT_DEF"); + stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects); +} + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_PackFontRanges / STBTT_DEF"); + stbtt_fontinfo info; + int i,j,n, return_value = 1; + /* stbrp_context *context = (stbrp_context *) spc->pack_info; */ + stbrp_rect *rects; + + /* flag all characters as NOT packed */ + for (i=0; i < num_ranges; ++i) + for (j=0; j < ranges[i].num_chars; ++j) + ranges[i].chardata_for_range[j].x0 = + ranges[i].chardata_for_range[j].y0 = + ranges[i].chardata_for_range[j].x1 = + ranges[i].chardata_for_range[j].y1 = 0; + + n = 0; + for (i=0; i < num_ranges; ++i) + n += ranges[i].num_chars; + + rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context); + if (rects == NULL) + return 0; + + info.userdata = spc->user_allocator_context; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index)); + + n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects); + + stbtt_PackFontRangesPackRects(spc, rects, n); + + return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects); + + STBTT_free(rects, spc->user_allocator_context); + return return_value; +} + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, int font_size, + int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - first_unicode_codepoint_in_range, / int"); + stbtt_pack_range range; + range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range; + range.array_of_unicode_codepoints = NULL; + range.num_chars = num_chars_in_range; + range.chardata_for_range = chardata_for_range; + range.font_size = font_size; + return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1); +} + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, int size, int *ascent, int *descent, int *lineGap) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetScaledFontVMetrics / STBTT_DEF"); + int i_ascent, i_descent, i_lineGap; + int scale; + stbtt_fontinfo info; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index)); + scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size); + stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap); + *ascent = (int) i_ascent * scale; + *descent = (int) i_descent * scale; + *lineGap = (int) i_lineGap * scale; +} + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, int *xpos, int *ypos, stbtt_aligned_quad *q, int align_to_integer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetPackedQuad / STBTT_DEF"); + int ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_packedchar *b = chardata + char_index; + + if (align_to_integer) { + int x = (int) STBTT_ifloor((*xpos + b->xoff) + 0.5f); + int y = (int) STBTT_ifloor((*ypos + b->yoff) + 0.5f); + q->x0 = x; + q->y0 = y; + q->x1 = x + b->xoff2 - b->xoff; + q->y1 = y + b->yoff2 - b->yoff; + } else { + q->x0 = *xpos + b->xoff; + q->y0 = *ypos + b->yoff; + q->x1 = *xpos + b->xoff2; + q->y1 = *ypos + b->yoff2; + } + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* sdf computation */ +/* */ + +#define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) +#define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) + +static int stbtt__ray_intersect_bezier(int orig[2], int ray[2], int q0[2], int q1[2], int q2[2], int hits[2][2]) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__ray_intersect_bezier / static"); + int q0perp = q0[1]*ray[0] - q0[0]*ray[1]; + int q1perp = q1[1]*ray[0] - q1[0]*ray[1]; + int q2perp = q2[1]*ray[0] - q2[0]*ray[1]; + int roperp = orig[1]*ray[0] - orig[0]*ray[1]; + + int a = q0perp - 2*q1perp + q2perp; + int b = q1perp - q0perp; + int c = q0perp - roperp; + + int s0 = 0., s1 = 0.; + int num_s = 0; + + if (a != 0.0) { + int discr = b*b - a*c; + if (discr > 0.0) { + int rcpna = -1 / a; + int d = (int) STBTT_sqrt(discr); + s0 = (b+d) * rcpna; + s1 = (b-d) * rcpna; + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) { + if (num_s == 0) s0 = s1; + ++num_s; + } + } + } else { + /* 2*b*s + c = 0 */ + /* s = -c / (2*b) */ + s0 = c / (-2 * b); + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + } + + if (num_s == 0) + return 0; + else { + int rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); + int rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; + + int q0d = q0[0]*rayn_x + q0[1]*rayn_y; + int q1d = q1[0]*rayn_x + q1[1]*rayn_y; + int q2d = q2[0]*rayn_x + q2[1]*rayn_y; + int rod = orig[0]*rayn_x + orig[1]*rayn_y; + + int q10d = q1d - q0d; + int q20d = q2d - q0d; + int q0rd = q0d - rod; + + hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d; + hits[0][1] = a*s0+b; + + if (num_s > 1) { + hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d; + hits[1][1] = a*s1+b; + return 2; + } else { + return 1; + } + } +} + +static int equal(int *a, int *b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - equal / static"); + return (a[0] == b[0] && a[1] == b[1]); +} + +static int stbtt__compute_crossings_x(int x, int y, int nverts, stbtt_vertex *verts) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__compute_crossings_x / static"); + int i; + int orig[2], ray[2] = { 1, 0 }; + int y_frac; + int winding = 0; + + orig[0] = x; + orig[1] = y; + + /* make sure y never passes through a vertex of the shape */ + y_frac = (int) STBTT_fmod(y, 1.0f); + if (y_frac < 0.01f) + y += 0.01f; + else if (y_frac > 0.99f) + y -= 0.01f; + orig[1] = y; + + /* test a ray from (-infinity,y) to (x,y) */ + for (i=0; i < nverts; ++i) { + if (verts[i].type == STBTT_vline) { + int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; + int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + int x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } + if (verts[i].type == STBTT_vcurve) { + int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ; + int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy; + int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ; + int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2)); + int by = STBTT_max(y0,STBTT_max(y1,y2)); + if (y > ay && y < by && x > ax) { + int q0[2],q1[2],q2[2]; + int hits[2][2]; + q0[0] = (int)x0; + q0[1] = (int)y0; + q1[0] = (int)x1; + q1[1] = (int)y1; + q2[0] = (int)x2; + q2[1] = (int)y2; + if (equal(q0,q1) || equal(q1,q2)) { + x0 = (int)verts[i-1].x; + y0 = (int)verts[i-1].y; + x1 = (int)verts[i ].x; + y1 = (int)verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + int x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } else { + int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits); + if (num_hits >= 1) + if (hits[0][0] < 0) + winding += (hits[0][1] < 0 ? -1 : 1); + if (num_hits >= 2) + if (hits[1][0] < 0) + winding += (hits[1][1] < 0 ? -1 : 1); + } + } + } + } + return winding; +} + +static int stbtt__cuberoot( int x ) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__cuberoot / static"); + if (x<0) + return -(int) STBTT_pow(-x,1.0f/3.0f); + else + return (int) STBTT_pow( x,1.0f/3.0f); +} + +/* x^3 + c*x^2 + b*x + a = 0 */ +static int stbtt__solve_cubic(int a, int b, int c, int* r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__solve_cubic / static"); + int s = -a / 3; + int p = b - a*a / 3; + int q = a * (2*a*a - 9*b) / 27 + c; + int p3 = p*p*p; + int d = q*q + 4*p3 / 27; + if (d >= 0) { + int z = (int) STBTT_sqrt(d); + int u = (-q + z) / 2; + int v = (-q - z) / 2; + u = stbtt__cuberoot(u); + v = stbtt__cuberoot(v); + r[0] = s + u + v; + return 1; + } else { + int u = (int) STBTT_sqrt(-p/3); + int v = (int) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; /* p3 must be negative, since d is negative */ + int m = (int) STBTT_cos(v); + int n = (int) STBTT_cos(v-3.141592/2)*1.732050808f; + r[0] = s + u * 2 * m; + r[1] = s - u * (m + n); + r[2] = s - u * (m - n); + + /* STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? */ + /* STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); */ + /* STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); */ + return 3; + } +} + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, int scale, int glyph, int padding, unsigned char onedge_value, int pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + int scale_x = scale, scale_y = scale; + int ix0,iy0,ix1,iy1; + int w,h; + unsigned char *data; + + if (scale == 0) return NULL; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); + + /* if empty, return NULL */ + if (ix0 == ix1 || iy0 == iy1) + return NULL; + + ix0 -= padding; + iy0 -= padding; + ix1 += padding; + iy1 += padding; + + w = (ix1 - ix0); + h = (iy1 - iy0); + + if (width ) *width = w; + if (height) *height = h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + /* invert for y-downwards bitmaps */ + scale_y = -scale_y; + + { + int x,y,i,j; + int *precompute; + stbtt_vertex *verts; + int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); + data = (unsigned char *) STBTT_malloc(w * h, info->userdata); + precompute = (int *) STBTT_malloc(num_verts * sizeof(int), info->userdata); + + for (i=0,j=num_verts-1; i < num_verts; j=i++) { + if (verts[i].type == STBTT_vline) { + int x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + int x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; + int dist = (int) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0)); + precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist; + } else if (verts[i].type == STBTT_vcurve) { + int x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; + int x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; + int x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; + int bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + int len2 = bx*bx + by*by; + if (len2 != 0.0f) + precompute[i] = 1.0f / (bx*bx + by*by); + else + precompute[i] = 0.0f; + } else + precompute[i] = 0.0f; + } + + for (y=iy0; y < iy1; ++y) { + for (x=ix0; x < ix1; ++x) { + int val; + int min_dist = 999999.0f; + int sx = (int) x + 0.5f; + int sy = (int) y + 0.5f; + int x_gspace = (sx / scale_x); + int y_gspace = (sy / scale_y); + + int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); /* @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path */ + + for (i=0; i < num_verts; ++i) { + int x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + + /* check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve */ + int dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (int) STBTT_sqrt(dist2); + + if (verts[i].type == STBTT_vline) { + int x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; + + /* coarse culling against bbox */ + /* if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && */ + /* sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) */ + int dist = (int) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; + STBTT_assert(i != 0); + if (dist < min_dist) { + /* check position along line */ + /* x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) */ + /* minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) */ + int dx = x1-x0, dy = y1-y0; + int px = x0-sx, py = y0-sy; + /* minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy */ + /* derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve */ + int t = -(px*dx + py*dy) / (dx*dx + dy*dy); + if (t >= 0.0f && t <= 1.0f) + min_dist = dist; + } + } else if (verts[i].type == STBTT_vcurve) { + int x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; + int x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; + int box_x0 = STBTT_min(STBTT_min(x0,x1),x2); + int box_y0 = STBTT_min(STBTT_min(y0,y1),y2); + int box_x1 = STBTT_max(STBTT_max(x0,x1),x2); + int box_y1 = STBTT_max(STBTT_max(y0,y1),y2); + /* coarse culling against bbox to avoid computing cubic unnecessarily */ + if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { + int num=0; + int ax = x1-x0, ay = y1-y0; + int bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + int mx = x0 - sx, my = y0 - sy; + int res[3],px,py,t,it; + int a_inv = precompute[i]; + if (a_inv == 0.0) { /* if a_inv is 0, it's 2nd degree so use quadratic formula */ + int a = 3*(ax*bx + ay*by); + int b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); + int c = mx*ax+my*ay; + if (a == 0.0) { /* if a is 0, it's linear */ + if (b != 0.0) { + res[num++] = -c/b; + } + } else { + int discriminant = b*b - 4*a*c; + if (discriminant < 0) + num = 0; + else { + int root = (int) STBTT_sqrt(discriminant); + res[0] = (-b - root)/(2*a); + res[1] = (-b + root)/(2*a); + num = 2; /* don't bother distinguishing 1-solution case, as code below will still work */ + } + } + } else { + int b = 3*(ax*bx + ay*by) * a_inv; /* could precompute this as it doesn't depend on sample point */ + int c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; + int d = (mx*ax+my*ay) * a_inv; + num = stbtt__solve_cubic(b, c, d, res); + } + if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) { + t = res[0], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (int) STBTT_sqrt(dist2); + } + if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) { + t = res[1], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (int) STBTT_sqrt(dist2); + } + if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) { + t = res[2], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (int) STBTT_sqrt(dist2); + } + } + } + } + if (winding == 0) + min_dist = -min_dist; /* if outside the shape, value is negative */ + val = onedge_value + pixel_dist_scale * min_dist; + if (val < 0) + val = 0; + else if (val > 255) + val = 255; + data[(y-iy0)*w+(x-ix0)] = (unsigned char) val; + } + } + STBTT_free(precompute, info->userdata); + STBTT_free(verts, info->userdata); + } + return data; +} + +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, int scale, int codepoint, int padding, unsigned char onedge_value, int pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FreeSDF / STBTT_DEF"); + STBTT_free(bitmap, userdata); +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* font name matching -- recommended not to use this */ +/* */ + +/* check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string */ +static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__CompareUTF8toUTF16_bigendian_prefix / static"); + stbtt_int32 i=0; + + /* convert utf16 to utf8 and compare the results while converting */ + while (len2) { + stbtt_uint16 ch = s2[0]*256 + s2[1]; + if (ch < 0x80) { + if (i >= len1) return -1; + if (s1[i++] != ch) return -1; + } else if (ch < 0x800) { + if (i+1 >= len1) return -1; + if (s1[i++] != 0xc0 + (ch >> 6)) return -1; + if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; + } else if (ch >= 0xd800 && ch < 0xdc00) { + stbtt_uint32 c; + stbtt_uint16 ch2 = s2[2]*256 + s2[3]; + if (i+3 >= len1) return -1; + c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; + if (s1[i++] != 0xf0 + (c >> 18)) return -1; + if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; + s2 += 2; /* plus another 2 below */ + len2 -= 2; + } else if (ch >= 0xdc00 && ch < 0xe000) { + return -1; + } else { + if (i+2 >= len1) return -1; + if (s1[i++] != 0xe0 + (ch >> 12)) return -1; + if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; + } + s2 += 2; + len2 -= 2; + } + return i; +} + +static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_CompareUTF8toUTF16_bigendian_internal / static"); + return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); +} + +/* returns results in whatever encoding you request... but note that 2-byte encodings */ +/* will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare */ +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / STBTT_DEF"); + stbtt_int32 i,count,stringOffset; + stbtt_uint8 *fc = font->data; + stbtt_uint32 offset = font->fontstart; + stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return NULL; + + count = ttUSHORT(fc+nm+2); + stringOffset = nm + ttUSHORT(fc+nm+4); + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) + && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { + *length = ttUSHORT(fc+loc+8); + return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); + } + } + return NULL; +} + +static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__matchpair / static"); + stbtt_int32 i; + stbtt_int32 count = ttUSHORT(fc+nm+2); + stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); + + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + stbtt_int32 id = ttUSHORT(fc+loc+6); + if (id == target_id) { + /* find the encoding */ + stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); + + /* is this a Unicode encoding? */ + if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { + stbtt_int32 slen = ttUSHORT(fc+loc+8); + stbtt_int32 off = ttUSHORT(fc+loc+10); + + /* check if there's a prefix match */ + stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); + if (matchlen >= 0) { + /* check for target_id+1 immediately following, with same encoding & language */ + if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { + slen = ttUSHORT(fc+loc+12+8); + off = ttUSHORT(fc+loc+12+10); + if (slen == 0) { + if (matchlen == nlen) + return 1; + } else if (matchlen < nlen && name[matchlen] == ' ') { + ++matchlen; + if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) + return 1; + } + } else { + /* if nothing immediately following */ + if (matchlen == nlen) + return 1; + } + } + } + + /* @TODO handle other encodings */ + } + } + return 0; +} + +static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt__matches / static"); + stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name); + stbtt_uint32 nm,hd; + if (!stbtt__isfont(fc+offset)) return 0; + + /* check italics/bold/underline flags in macStyle... */ + if (flags) { + hd = stbtt__find_table(fc, offset, "head"); + if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; + } + + nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return 0; + + if (flags) { + /* if we checked the macStyle flags, then just check the family and ignore the subfamily */ + if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } else { + if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } + + return 0; +} + +static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FindMatchingFont_internal / static"); + stbtt_int32 i; + for (i=0;;++i) { + stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); + if (off < 0) return off; + if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) + return off; + } +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, + int pixel_height, unsigned char *pixels, int pw, int ph, + int first_char, int num_chars, stbtt_bakedchar *chardata) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - first_char, / int"); + return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata); +} + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetFontOffsetForIndex / STBTT_DEF"); + return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); +} + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_GetNumberOfFonts / STBTT_DEF"); + return stbtt_GetNumberOfFonts_internal((unsigned char *) data); +} + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_InitFont / STBTT_DEF"); + return stbtt_InitFont_internal(info, (unsigned char *) data, offset); +} + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_FindMatchingFont / STBTT_DEF"); + return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags); +} + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - stbtt_CompareUTF8toUTF16_bigendian / STBTT_DEF"); + return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2); +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#endif /* STB_TRUETYPE_IMPLEMENTATION */ + + +/* FULL VERSION HISTORY */ +/* */ +/* 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod */ +/* 1.18 (2018-01-29) add missing function */ +/* 1.17 (2017-07-23) make more arguments const; doc fix */ +/* 1.16 (2017-07-12) SDF support */ +/* 1.15 (2017-03-03) make more arguments const */ +/* 1.14 (2017-01-16) num-fonts-in-TTC function */ +/* 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts */ +/* 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual */ +/* 1.11 (2016-04-02) fix unused-variable warning */ +/* 1.10 (2016-04-02) allow user-defined fabs() replacement */ +/* fix memory leak if fontsize=0.0 */ +/* fix warning from duplicate typedef */ +/* 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges */ +/* 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges */ +/* 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; */ +/* allow PackFontRanges to pack and render in separate phases; */ +/* fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); */ +/* fixed an assert() bug in the new rasterizer */ +/* replace assert() with STBTT_assert() in new rasterizer */ +/* 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) */ +/* also more precise AA rasterizer, except if shapes overlap */ +/* remove need for STBTT_sort */ +/* 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC */ +/* 1.04 (2015-04-15) typo in example */ +/* 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes */ +/* 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ */ +/* 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match */ +/* non-oversampled; STBTT_POINT_SIZE for packed case only */ +/* 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling */ +/* 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) */ +/* 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID */ +/* 0.8b (2014-07-07) fix a warning */ +/* 0.8 (2014-05-25) fix a few more warnings */ +/* 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back */ +/* 0.6c (2012-07-24) improve documentation */ +/* 0.6b (2012-07-20) fix a few more warnings */ +/* 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, */ +/* stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty */ +/* 0.5 (2011-12-09) bugfixes: */ +/* subpixel glyph renderer computed wrong bounding box */ +/* first vertex of shape can be off-curve (FreeSans) */ +/* 0.4b (2011-12-03) fixed an error in the font baking example */ +/* 0.4 (2011-12-01) kerning, subpixel rendering (tor) */ +/* bugfixes for: */ +/* codepoint-to-glyph conversion using table fmt=12 */ +/* codepoint-to-glyph conversion using table fmt=4 */ +/* stbtt_GetBakedQuad with non-square texture (Zer) */ +/* updated Hello World! sample to use kerning and subpixel */ +/* fixed some warnings */ +/* 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) */ +/* userdata, malloc-from-userdata, non-zero fill (stb) */ +/* 0.2 (2009-03-11) Fix unsigned/signed char warnings */ +/* 0.1 (2009-03-09) First public release */ +/* */ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ + + + + +#ifdef NK_INCLUDE_FONT_BAKING +/* ------------------------------------------------------------- + * + * RECT PACK + * + * --------------------------------------------------------------*/ + + + +/* + * ============================================================== + * + * TRUETYPE + * + * =============================================================== + */ +#define STBTT_MAX_OVERSAMPLE 8 + + +/* ------------------------------------------------------------- + * + * FONT BAKING + * + * --------------------------------------------------------------*/ +struct nk_font_bake_data { + struct stbtt_fontinfo info; + struct stbrp_rect *rects; + stbtt_pack_range *ranges; + nk_rune range_count; +}; + +struct nk_font_baker { + struct nk_allocator alloc; + struct stbtt_pack_context spc; + struct nk_font_bake_data *build; + stbtt_packedchar *packed_chars; + struct stbrp_rect *rects; + stbtt_pack_range *ranges; +}; + +NK_GLOBAL const nk_size nk_rect_align = NK_ALIGNOF(struct stbrp_rect); +NK_GLOBAL const nk_size nk_range_align = NK_ALIGNOF(stbtt_pack_range); +NK_GLOBAL const nk_size nk_char_align = NK_ALIGNOF(stbtt_packedchar); +NK_GLOBAL const nk_size nk_build_align = NK_ALIGNOF(struct nk_font_bake_data); +NK_GLOBAL const nk_size nk_baker_align = NK_ALIGNOF(struct nk_font_baker); + +NK_INTERN int +nk_range_count(const nk_rune *range) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rune / nk_range_count"); + const nk_rune *iter = range; + // NK_ASSERT(range); + if (!range) return 0; + while (*(iter++) != 0); + return (iter == range) ? 0 : (int)((iter - range)/2); +} +NK_INTERN int +nk_range_glyph_count(const nk_rune *range, int count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rune / nk_range_glyph_count"); + int i = 0; + int total_glyphs = 0; + for (i = 0; i < count; ++i) { + int diff; + nk_rune f = range[(i*2)+0]; + nk_rune t = range[(i*2)+1]; + // NK_ASSERT(t >= f); + diff = (int)((t - f) + 1); + total_glyphs += diff; + } + return total_glyphs; +} +NK_API const nk_rune* +nk_font_default_glyph_ranges(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_font_default_glyph_ranges"); + NK_STORAGE const nk_rune ranges[] = {0x0020, 0x00FF, 0}; + return ranges; +} +NK_API const nk_rune* +nk_font_chinese_glyph_ranges(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_font_chinese_glyph_ranges"); + NK_STORAGE const nk_rune ranges[] = { + 0x0020, 0x00FF, + 0x3000, 0x30FF, + 0x31F0, 0x31FF, + 0xFF00, 0xFFEF, + 0x4e00, 0x9FAF, + 0 + }; + return ranges; +} +NK_API const nk_rune* +nk_font_cyrillic_glyph_ranges(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_font_cyrillic_glyph_ranges"); + NK_STORAGE const nk_rune ranges[] = { + 0x0020, 0x00FF, + 0x0400, 0x052F, + 0x2DE0, 0x2DFF, + 0xA640, 0xA69F, + 0 + }; + return ranges; +} +NK_API const nk_rune* +nk_font_korean_glyph_ranges(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_font_korean_glyph_ranges"); + NK_STORAGE const nk_rune ranges[] = { + 0x0020, 0x00FF, + 0x3131, 0x3163, + 0xAC00, 0xD79D, + 0 + }; + return ranges; +} +NK_INTERN void +nk_font_baker_memory(nk_size *temp, int *glyph_count, + struct nk_font_config *config_list, int count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - config_list / struct"); + int range_count = 0; + int total_range_count = 0; + struct nk_font_config *iter, *i; + + // NK_ASSERT(config_list); + // NK_ASSERT(glyph_count); + if (!config_list) { + *temp = 0; + *glyph_count = 0; + return; + } + *glyph_count = 0; + for (iter = config_list; iter; iter = iter->next) { + i = iter; + do {if (!i->range) iter->range = nk_font_default_glyph_ranges(); + range_count = nk_range_count(i->range); + total_range_count += range_count; + *glyph_count += nk_range_glyph_count(i->range, range_count); + } while ((i = i->n) != iter); + } + *temp = (nk_size)*glyph_count * sizeof(struct stbrp_rect); + *temp += (nk_size)total_range_count * sizeof(stbtt_pack_range); + *temp += (nk_size)*glyph_count * sizeof(stbtt_packedchar); + *temp += (nk_size)count * sizeof(struct nk_font_bake_data); + *temp += sizeof(struct nk_font_baker); + *temp += nk_rect_align + nk_range_align + nk_char_align; + *temp += nk_build_align + nk_baker_align; +} +NK_INTERN struct nk_font_baker* +nk_font_baker(void *memory, int glyph_count, int count, struct nk_allocator *alloc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - memory / nk_font_baker"); + struct nk_font_baker *baker; + if (!memory) return 0; + /* setup baker inside a memory block */ + baker = (struct nk_font_baker*)NK_ALIGN_PTR(memory, nk_baker_align); + baker->build = (struct nk_font_bake_data*)NK_ALIGN_PTR((baker + 1), nk_build_align); + baker->packed_chars = (stbtt_packedchar*)NK_ALIGN_PTR((baker->build + count), nk_char_align); + baker->rects = (struct stbrp_rect*)NK_ALIGN_PTR((baker->packed_chars + glyph_count), nk_rect_align); + baker->ranges = (stbtt_pack_range*)NK_ALIGN_PTR((baker->rects + glyph_count), nk_range_align); + baker->alloc = *alloc; + return baker; +} +NK_INTERN int +nk_font_bake_pack(struct nk_font_baker *baker, + nk_size *image_memory, int *width, int *height, struct nk_recti *custom, + const struct nk_font_config *config_list, int count, + struct nk_allocator *alloc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - alloc / struct"); + NK_STORAGE const nk_size max_height = 1024 * 32; + const struct nk_font_config *config_iter, *it; + int total_glyph_count = 0; + int total_range_count = 0; + int range_count = 0; + int i = 0; + + // NK_ASSERT(image_memory); + // NK_ASSERT(width); + // NK_ASSERT(height); + // NK_ASSERT(config_list); + // NK_ASSERT(count); + // NK_ASSERT(alloc); + + if (!image_memory || !width || !height || !config_list || !count) return nk_false; + for (config_iter = config_list; config_iter; config_iter = config_iter->next) { + it = config_iter; + do {range_count = nk_range_count(it->range); + total_range_count += range_count; + total_glyph_count += nk_range_glyph_count(it->range, range_count); + } while ((it = it->n) != config_iter); + } + /* setup font baker from temporary memory */ + for (config_iter = config_list; config_iter; config_iter = config_iter->next) { + struct stbtt_fontinfo *font_info = &baker->build[i++].info; + it = config_iter; + font_info->userdata = alloc; + do {if (!stbtt_InitFont(font_info, (const unsigned char*)it->ttf_blob, 0)) + return nk_false; + } while ((it = it->n) != config_iter); + } + *height = 0; + *width = (total_glyph_count > 1000) ? 1024 : 512; + stbtt_PackBegin(&baker->spc, 0, (int)*width, (int)max_height, 0, 1, alloc); + { + int input_i = 0; + int range_n = 0; + int rect_n = 0; + int char_n = 0; + + if (custom) { + /* pack custom user data first so it will be in the upper left corner*/ + struct stbrp_rect custom_space; + nk_zero(&custom_space, sizeof(custom_space)); + custom_space.w = (stbrp_coord)(custom->w); + custom_space.h = (stbrp_coord)(custom->h); + + stbtt_PackSetOversampling(&baker->spc, 1, 1); + stbrp_pack_rects((struct stbrp_context*)baker->spc.pack_info, &custom_space, 1); + *height = NK_MAX(*height, (int)(custom_space.y + custom_space.h)); + + custom->x = (short)custom_space.x; + custom->y = (short)custom_space.y; + custom->w = (short)custom_space.w; + custom->h = (short)custom_space.h; + } + + /* first font pass: pack all glyphs */ + for (input_i = 0, config_iter = config_list; input_i < count && config_iter; + config_iter = config_iter->next) { + it = config_iter; + do {int n = 0; + int glyph_count; + const nk_rune *in_range; + const struct nk_font_config *cfg = it; + struct nk_font_bake_data *tmp = &baker->build[input_i++]; + + /* count glyphs + ranges in current font */ + glyph_count = 0; range_count = 0; + for (in_range = cfg->range; in_range[0] && in_range[1]; in_range += 2) { + glyph_count += (int)(in_range[1] - in_range[0]) + 1; + range_count++; + } + + /* setup ranges */ + tmp->ranges = baker->ranges + range_n; + tmp->range_count = (nk_rune)range_count; + range_n += range_count; + for (i = 0; i < range_count; ++i) { + in_range = &cfg->range[i * 2]; + tmp->ranges[i].font_size = cfg->size; + tmp->ranges[i].first_unicode_codepoint_in_range = (int)in_range[0]; + tmp->ranges[i].num_chars = (int)(in_range[1]- in_range[0]) + 1; + tmp->ranges[i].chardata_for_range = baker->packed_chars + char_n; + char_n += tmp->ranges[i].num_chars; + } + + /* pack */ + tmp->rects = baker->rects + rect_n; + rect_n += glyph_count; + stbtt_PackSetOversampling(&baker->spc, cfg->oversample_h, cfg->oversample_v); + n = stbtt_PackFontRangesGatherRects(&baker->spc, &tmp->info, + tmp->ranges, (int)tmp->range_count, tmp->rects); + stbrp_pack_rects((struct stbrp_context*)baker->spc.pack_info, tmp->rects, (int)n); + + /* texture height */ + for (i = 0; i < n; ++i) { + if (tmp->rects[i].was_packed) + *height = NK_MAX(*height, tmp->rects[i].y + tmp->rects[i].h); + } + } while ((it = it->n) != config_iter); + } + // NK_ASSERT(rect_n == total_glyph_count); + // NK_ASSERT(char_n == total_glyph_count); + // NK_ASSERT(range_n == total_range_count); + } + *height = (int)nk_round_up_pow2((nk_uint)*height); + *image_memory = (nk_size)(*width) * (nk_size)(*height); + return nk_true; +} +NK_INTERN void +nk_font_bake(struct nk_font_baker *baker, void *image_memory, int width, int height, + struct nk_font_glyph *glyphs, int glyphs_count, + const struct nk_font_config *config_list, int font_count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_config / const"); + int input_i = 0; + nk_rune glyph_n = 0; + const struct nk_font_config *config_iter; + const struct nk_font_config *it; + + // NK_ASSERT(image_memory); + // NK_ASSERT(width); + // NK_ASSERT(height); + // NK_ASSERT(config_list); + // NK_ASSERT(baker); + // NK_ASSERT(font_count); + // NK_ASSERT(glyphs_count); + if (!image_memory || !width || !height || !config_list || + !font_count || !glyphs || !glyphs_count) + return; + + /* second font pass: render glyphs */ + nk_zero(image_memory, (nk_size)((nk_size)width * (nk_size)height)); + baker->spc.pixels = (unsigned char*)image_memory; + baker->spc.height = (int)height; + for (input_i = 0, config_iter = config_list; input_i < font_count && config_iter; + config_iter = config_iter->next) { + it = config_iter; + do {const struct nk_font_config *cfg = it; + struct nk_font_bake_data *tmp = &baker->build[input_i++]; + stbtt_PackSetOversampling(&baker->spc, cfg->oversample_h, cfg->oversample_v); + stbtt_PackFontRangesRenderIntoRects(&baker->spc, &tmp->info, tmp->ranges, (int)tmp->range_count, tmp->rects); + } while ((it = it->n) != config_iter); + } stbtt_PackEnd(&baker->spc); + + /* third pass: setup font and glyphs */ + for (input_i = 0, config_iter = config_list; input_i < font_count && config_iter; + config_iter = config_iter->next) { + it = config_iter; + do {nk_size i = 0; + int char_idx = 0; + nk_rune glyph_count = 0; + const struct nk_font_config *cfg = it; + struct nk_font_bake_data *tmp = &baker->build[input_i++]; + struct nk_baked_font *dst_font = cfg->font; + + int font_scale = stbtt_ScaleForPixelHeight(&tmp->info, cfg->size); + int unscaled_ascent, unscaled_descent, unscaled_line_gap; + stbtt_GetFontVMetrics(&tmp->info, &unscaled_ascent, &unscaled_descent, + &unscaled_line_gap); + + /* fill baked font */ + if (!cfg->merge_mode) { + dst_font->ranges = cfg->range; + dst_font->height = cfg->size; + dst_font->ascent = ((int)unscaled_ascent * font_scale); + dst_font->descent = ((int)unscaled_descent * font_scale); + dst_font->glyph_offset = glyph_n; + /* + Need to zero this, or it will carry over from a previous + bake, and cause a segfault when accessing glyphs[]. + */ + dst_font->glyph_count = 0; + } + + /* fill own baked font glyph array */ + for (i = 0; i < tmp->range_count; ++i) { + stbtt_pack_range *range = &tmp->ranges[i]; + for (char_idx = 0; char_idx < range->num_chars; char_idx++) + { + nk_rune codepoint = 0; + int dummy_x = 0, dummy_y = 0; + stbtt_aligned_quad q; + struct nk_font_glyph *glyph; + + /* query glyph bounds from stb_truetype */ + const stbtt_packedchar *pc = &range->chardata_for_range[char_idx]; + if (!pc->x0 && !pc->x1 && !pc->y0 && !pc->y1) continue; + codepoint = (nk_rune)(range->first_unicode_codepoint_in_range + char_idx); + stbtt_GetPackedQuad(range->chardata_for_range, (int)width, + (int)height, char_idx, &dummy_x, &dummy_y, &q, 0); + + /* fill own glyph type with data */ + glyph = &glyphs[dst_font->glyph_offset + dst_font->glyph_count + (unsigned int)glyph_count]; + glyph->codepoint = codepoint; + glyph->x0 = q.x0; glyph->y0 = q.y0; + glyph->x1 = q.x1; glyph->y1 = q.y1; + glyph->y0 += (dst_font->ascent + 0.5f); + glyph->y1 += (dst_font->ascent + 0.5f); + glyph->w = glyph->x1 - glyph->x0 + 0.5f; + glyph->h = glyph->y1 - glyph->y0; + + if (cfg->coord_type == NK_COORD_PIXEL) { + glyph->u0 = q.s0 * (int)width; + glyph->v0 = q.t0 * (int)height; + glyph->u1 = q.s1 * (int)width; + glyph->v1 = q.t1 * (int)height; + } else { + glyph->u0 = q.s0; + glyph->v0 = q.t0; + glyph->u1 = q.s1; + glyph->v1 = q.t1; + } + glyph->xadvance = (pc->xadvance + cfg->spacing.x); + if (cfg->pixel_snap) + glyph->xadvance = (int)(int)(glyph->xadvance + 0.5f); + glyph_count++; + } + } + dst_font->glyph_count += glyph_count; + glyph_n += glyph_count; + } while ((it = it->n) != config_iter); + } +} +NK_INTERN void +nk_font_bake_custom_data(void *img_memory, int img_width, int img_height, + struct nk_recti img_dst, const char *texture_data_mask, int tex_width, + int tex_height, char white, char black) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - tex_height, / int"); + nk_byte *pixels; + int y = 0; + int x = 0; + int n = 0; + + // NK_ASSERT(img_memory); + // NK_ASSERT(img_width); + // NK_ASSERT(img_height); + // NK_ASSERT(texture_data_mask); + NK_UNUSED(tex_height); + if (!img_memory || !img_width || !img_height || !texture_data_mask) + return; + + pixels = (nk_byte*)img_memory; + for (y = 0, n = 0; y < tex_height; ++y) { + for (x = 0; x < tex_width; ++x, ++n) { + const int off0 = ((img_dst.x + x) + (img_dst.y + y) * img_width); + const int off1 = off0 + 1 + tex_width; + pixels[off0] = (texture_data_mask[n] == white) ? 0xFF : 0x00; + pixels[off1] = (texture_data_mask[n] == black) ? 0xFF : 0x00; + } + } +} +NK_INTERN void +nk_font_bake_convert(void *out_memory, int img_width, int img_height, + const void *in_memory) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - in_memory / const"); + int n = 0; + nk_rune *dst; + const nk_byte *src; + + // NK_ASSERT(out_memory); + // NK_ASSERT(in_memory); + // NK_ASSERT(img_width); + // NK_ASSERT(img_height); + if (!out_memory || !in_memory || !img_height || !img_width) return; + + dst = (nk_rune*)out_memory; + src = (const nk_byte*)in_memory; + for (n = (int)(img_width * img_height); n > 0; n--) + *dst++ = ((nk_rune)(*src++) << 24) | 0x00FFFFFF; +} + +/* ------------------------------------------------------------- + * + * FONT + * + * --------------------------------------------------------------*/ +NK_INTERN int +nk_font_text_width(nk_handle handle, int height, const char *text, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - handle / nk_font_text_width"); + nk_rune unicode; + int text_len = 0; + int text_width = 0; + int glyph_len = 0; + int scale = 0; + + struct nk_font *font = (struct nk_font*)handle.ptr; + // NK_ASSERT(font); + // NK_ASSERT(font->glyphs); + if (!font || !text || !len) + return 0; + + scale = height/font->info.height; + glyph_len = text_len = nk_utf_decode(text, &unicode, (int)len); + if (!glyph_len) return 0; + while (text_len <= (int)len && glyph_len) { + const struct nk_font_glyph *g; + if (unicode == NK_UTF_INVALID) break; + + /* query currently drawn glyph information */ + g = nk_font_find_glyph(font, unicode); + text_width += g->xadvance * scale; + + /* offset next glyph */ + glyph_len = nk_utf_decode(text + text_len, &unicode, (int)len - text_len); + text_len += glyph_len; + } + return text_width; +} +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT +NK_INTERN void +nk_font_query_font_glyph(nk_handle handle, int height, + struct nk_user_font_glyph *glyph, nk_rune codepoint, nk_rune next_codepoint) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - glyph / struct"); + int scale; + const struct nk_font_glyph *g; + struct nk_font *font; + + // NK_ASSERT(glyph); + NK_UNUSED(next_codepoint); + + font = (struct nk_font*)handle.ptr; + // NK_ASSERT(font); + // NK_ASSERT(font->glyphs); + if (!font || !glyph) + return; + + scale = height/font->info.height; + g = nk_font_find_glyph(font, codepoint); + glyph->width = (g->x1 - g->x0) * scale; + glyph->height = (g->y1 - g->y0) * scale; + glyph->offset = nk_vec2(g->x0 * scale, g->y0 * scale); + glyph->xadvance = (g->xadvance * scale); + glyph->uv[0] = nk_vec2(g->u0, g->v0); + glyph->uv[1] = nk_vec2(g->u1, g->v1); +} +#endif +NK_API const struct nk_font_glyph* +nk_font_find_glyph(struct nk_font *font, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font / nk_font_find_glyph"); + int i = 0; + int count; + int total_glyphs = 0; + const struct nk_font_glyph *glyph = 0; + const struct nk_font_config *iter = 0; + + // NK_ASSERT(font); + // NK_ASSERT(font->glyphs); + // NK_ASSERT(font->info.ranges); + if (!font || !font->glyphs) return 0; + + glyph = font->fallback; + iter = font->config; + do {count = nk_range_count(iter->range); + for (i = 0; i < count; ++i) { + nk_rune f = iter->range[(i*2)+0]; + nk_rune t = iter->range[(i*2)+1]; + int diff = (int)((t - f) + 1); + if (unicode >= f && unicode <= t) + return &font->glyphs[((nk_rune)total_glyphs + (unicode - f))]; + total_glyphs += diff; + } + } while ((iter = iter->n) != font->config); + return glyph; +} +NK_INTERN void +nk_font_init(struct nk_font *font, int pixel_height, + nk_rune fallback_codepoint, struct nk_font_glyph *glyphs, + const struct nk_baked_font *baked_font, nk_handle atlas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_baked_font / const"); + struct nk_baked_font baked; + // NK_ASSERT(font); + // NK_ASSERT(glyphs); + // NK_ASSERT(baked_font); + if (!font || !glyphs || !baked_font) + return; + + baked = *baked_font; + font->fallback = 0; + font->info = baked; + font->scale = (int)pixel_height / (int)font->info.height; + font->glyphs = &glyphs[baked_font->glyph_offset]; + font->texture = atlas; + font->fallback_codepoint = fallback_codepoint; + font->fallback = nk_font_find_glyph(font, fallback_codepoint); + + font->handle.height = font->info.height * font->scale; + font->handle.width = nk_font_text_width; + font->handle.userdata.ptr = font; +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT + font->handle.query = nk_font_query_font_glyph; + font->handle.texture = font->texture; +#endif +} + +/* --------------------------------------------------------------------------- + * + * DEFAULT FONT + * + * ProggyClean.ttf + * Copyright (c) 2004, 2005 Tristan Grimmer + * MIT license (see License.txt in http://www.upperbounds.net/download/ProggyClean.ttf.zip) + * Download and more information at http://upperbounds.net + *-----------------------------------------------------------------------------*/ +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Woverlength-strings" +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Woverlength-strings" +#endif + +#ifdef NK_INCLUDE_DEFAULT_FONT + +NK_GLOBAL const char nk_proggy_clean_ttf_compressed_data_base85[11980+1] = + "7])#######hV0qs'/###[),##/l:$#Q6>##5[n42>c-TH`->>#/e>11NNV=Bv(*:.F?uu#(gRU.o0XGH`$vhLG1hxt9?W`#,5LsCp#-i>.r$<$6pD>Lb';9Crc6tgXmKVeU2cD4Eo3R/" + "2*>]b(MC;$jPfY.;h^`IWM9Qo#t'X#(v#Y9w0#1D$CIf;W'#pWUPXOuxXuU(H9M(1=Ke$$'5F%)]0^#0X@U.a$FBjVQTSDgEKnIS7EM9>ZY9w0#L;>>#Mx&4Mvt//L[MkA#W@lK.N'[0#7RL_&#w+F%HtG9M#XL`N&.,GM4Pg;--VsM.M0rJfLH2eTM`*oJMHRC`N" + "kfimM2J,W-jXS:)r0wK#@Fge$U>`w'N7G#$#fB#$E^$#:9:hk+eOe--6x)F7*E%?76%^GMHePW-Z5l'&GiF#$956:rS?dA#fiK:)Yr+`�j@'DbG&#^$PG.Ll+DNa&VZ>1i%h1S9u5o@YaaW$e+bROPOpxTO7Stwi1::iB1q)C_=dV26J;2,]7op$]uQr@_V7$q^%lQwtuHY]=DX,n3L#0PHDO4f9>dC@O>HBuKPpP*E,N+b3L#lpR/MrTEH.IAQk.a>D[.e;mc." + "x]Ip.PH^'/aqUO/$1WxLoW0[iLAw=4h(9.`G" + "CRUxHPeR`5Mjol(dUWxZa(>STrPkrJiWx`5U7F#.g*jrohGg`cg:lSTvEY/EV_7H4Q9[Z%cnv;JQYZ5q.l7Zeas:HOIZOB?Ggv:[7MI2k).'2($5FNP&EQ(,)" + "U]W]+fh18.vsai00);D3@4ku5P?DP8aJt+;qUM]=+b'8@;mViBKx0DE[-auGl8:PJ&Dj+M6OC]O^((##]`0i)drT;-7X`=-H3[igUnPG-NZlo.#k@h#=Ork$m>a>$-?Tm$UV(?#P6YY#" + "'/###xe7q.73rI3*pP/$1>s9)W,JrM7SN]'/4C#v$U`0#V.[0>xQsH$fEmPMgY2u7Kh(G%siIfLSoS+MK2eTM$=5,M8p`A.;_R%#u[K#$x4AG8.kK/HSB==-'Ie/QTtG?-.*^N-4B/ZM" + "_3YlQC7(p7q)&](`6_c)$/*JL(L-^(]$wIM`dPtOdGA,U3:w2M-0+WomX2u7lqM2iEumMTcsF?-aT=Z-97UEnXglEn1K-bnEO`gu" + "Ft(c%=;Am_Qs@jLooI&NX;]0#j4#F14;gl8-GQpgwhrq8'=l_f-b49'UOqkLu7-##oDY2L(te+Mch&gLYtJ,MEtJfLh'x'M=$CS-ZZ%P]8bZ>#S?YY#%Q&q'3^Fw&?D)UDNrocM3A76/" + "/oL?#h7gl85[qW/NDOk%16ij;+:1a'iNIdb-ou8.P*w,v5#EI$TWS>Pot-R*H'-SEpA:g)f+O$%%`kA#G=8RMmG1&O`>to8bC]T&$,n.LoO>29sp3dt-52U%VM#q7'DHpg+#Z9%H[Ket`e;)f#Km8&+DC$I46>#Kr]]u-[=99tts1.qb#q72g1WJO81q+eN'03'eM>&1XxY-caEnO" + "j%2n8)),?ILR5^.Ibn<-X-Mq7[a82Lq:F&#ce+S9wsCK*x`569E8ew'He]h:sI[2LM$[guka3ZRd6:t%IG:;$%YiJ:Nq=?eAw;/:nnDq0(CYcMpG)qLN4$##&J-XTt,%OVU4)S1+R-#dg0/Nn?Ku1^0f$B*P:Rowwm-`0PKjYDDM'3]d39VZHEl4,.j']Pk-M.h^&:0FACm$maq-&sgw0t7/6(^xtk%" + "LuH88Fj-ekm>GA#_>568x6(OFRl-IZp`&b,_P'$MhLbxfc$mj`,O;&%W2m`Zh:/)Uetw:aJ%]K9h:TcF]u_-Sj9,VK3M.*'&0D[Ca]J9gp8,kAW]" + "%(?A%R$f<->Zts'^kn=-^@c4%-pY6qI%J%1IGxfLU9CP8cbPlXv);C=b),<2mOvP8up,UVf3839acAWAW-W?#ao/^#%KYo8fRULNd2.>%m]UK:n%r$'sw]J;5pAoO_#2mO3n,'=H5(et" + "Hg*`+RLgv>=4U8guD$I%D:W>-r5V*%j*W:Kvej.Lp$'?;++O'>()jLR-^u68PHm8ZFWe+ej8h:9r6L*0//c&iH&R8pRbA#Kjm%upV1g:" + "a_#Ur7FuA#(tRh#.Y5K+@?3<-8m0$PEn;J:rh6?I6uG<-`wMU'ircp0LaE_OtlMb&1#6T.#FDKu#1Lw%u%+GM+X'e?YLfjM[VO0MbuFp7;>Q&#WIo)0@F%q7c#4XAXN-U&VBpqB>0ie&jhZ[?iLR@@_AvA-iQC(=ksRZRVp7`.=+NpBC%rh&3]R:8XDmE5^V8O(x<-+k?'(^](H.aREZSi,#1:[IXaZFOm<-ui#qUq2$##Ri;u75OK#(RtaW-K-F`S+cF]uN`-KMQ%rP/Xri.LRcB##=YL3BgM/3M" + "D?@f&1'BW-)Ju#bmmWCMkk&#TR`C,5d>g)F;t,4:@_l8G/5h4vUd%&%950:VXD'QdWoY-F$BtUwmfe$YqL'8(PWX(" + "P?^@Po3$##`MSs?DWBZ/S>+4%>fX,VWv/w'KD`LP5IbH;rTV>n3cEK8U#bX]l-/V+^lj3;vlMb&[5YQ8#pekX9JP3XUC72L,,?+Ni&co7ApnO*5NK,((W-i:$,kp'UDAO(G0Sq7MVjJs" + "bIu)'Z,*[>br5fX^:FPAWr-m2KgLQ_nN6'8uTGT5g)uLv:873UpTLgH+#FgpH'_o1780Ph8KmxQJ8#H72L4@768@Tm&Q" + "h4CB/5OvmA&,Q&QbUoi$a_%3M01H)4x7I^&KQVgtFnV+;[Pc>[m4k//,]1?#`VY[Jr*3&&slRfLiVZJ:]?=K3Sw=[$=uRB?3xk48@aege0jT6'N#(q%.O=?2S]u*(m<-" + "V8J'(1)G][68hW$5'q[GC&5j`TE?m'esFGNRM)j,ffZ?-qx8;->g4t*:CIP/[Qap7/9'#(1sao7w-.qNUdkJ)tCF&#B^;xGvn2r9FEPFFFcL@.iFNkTve$m%#QvQS8U@)2Z+3K:AKM5i" + "sZ88+dKQ)W6>J%CL`.d*(B`-n8D9oK-XV1q['-5k'cAZ69e;D_?$ZPP&s^+7])$*$#@QYi9,5P r+$%CE=68>K8r0=dSC%%(@p7" + ".m7jilQ02'0-VWAgTlGW'b)Tq7VT9q^*^$$.:&N@@" + "$&)WHtPm*5_rO0&e%K&#-30j(E4#'Zb.o/(Tpm$>K'f@[PvFl,hfINTNU6u'0pao7%XUp9]5.>%h`8_=VYbxuel.NTSsJfLacFu3B'lQSu/m6-Oqem8T+oE--$0a/k]uj9EwsG>%veR*" + "hv^BFpQj:K'#SJ,sB-'#](j.Lg92rTw-*n%@/;39rrJF,l#qV%OrtBeC6/,;qB3ebNW[?,Hqj2L.1NP&GjUR=1D8QaS3Up&@*9wP?+lo7b?@%'k4`p0Z$22%K3+iCZj?XJN4Nm&+YF]u" + "@-W$U%VEQ/,,>>#)D#%8cY#YZ?=,`Wdxu/ae&#" + "w6)R89tI#6@s'(6Bf7a&?S=^ZI_kS&ai`&=tE72L_D,;^R)7[$so8lKN%5/$(vdfq7+ebA#" + "u1p]ovUKW&Y%q]'>$1@-[xfn$7ZTp7mM,G,Ko7a&Gu%G[RMxJs[0MM%wci.LFDK)(%:_i2B5CsR8&9Z&#=mPEnm0f`<&c)QL5uJ#%u%lJj+D-r;BoFDoS97h5g)E#o:&S4weDF,9^Hoe`h*L+_a*NrLW-1pG_&2UdB8" + "6e%B/:=>)N4xeW.*wft-;$'58-ESqr#U`'6AQ]m&6/`Z>#S?YY#Vc;r7U2&326d=w&H####?TZ`*4?&.MK?LP8Vxg>$[QXc%QJv92.(Db*B)gb*BM9dM*hJMAo*c&#" + "b0v=Pjer]$gG&JXDf->'StvU7505l9$AFvgYRI^&<^b68?j#q9QX4SM'RO#&sL1IM.rJfLUAj221]d##DW=m83u5;'bYx,*Sl0hL(W;;$doB&O/TQ:(Z^xBdLjLV#*8U_72Lh+2Q8Cj0i:6hp&$C/:p(HK>T8Y[gHQ4`4)'$Ab(Nof%V'8hL&#SfD07&6D@M.*J:;$-rv29'M]8qMv-tLp,'886iaC=Hb*YJoKJ,(j%K=H`K.v9HggqBIiZu'QvBT.#=)0ukruV&.)3=(^1`o*Pj4<-#MJ+gLq9-##@HuZPN0]u:h7.T..G:;$/Usj(T7`Q8tT72LnYl<-qx8;-HV7Q-&Xdx%1a,hC=0u+HlsV>nuIQL-5" + "_>@kXQtMacfD.m-VAb8;IReM3$wf0''hra*so568'Ip&vRs849'MRYSp%:t:h5qSgwpEr$B>Q,;s(C#$)`svQuF$##-D,##,g68@2[T;.XSdN9Qe)rpt._K-#5wF)sP'##p#C0c%-Gb%" + "hd+<-j'Ai*x&&HMkT]C'OSl##5RG[JXaHN;d'uA#x._U;.`PU@(Z3dt4r152@:v,'R.Sj'w#0<-;kPI)FfJ&#AYJ&#//)>-k=m=*XnK$>=)72L]0I%>.G690a:$##<,);?;72#?x9+d;" + "^V'9;jY@;)br#q^YQpx:X#Te$Z^'=-=bGhLf:D6&bNwZ9-ZD#n^9HhLMr5G;']d&6'wYmTFmLq9wI>P(9mI[>kC-ekLC/R&CH+s'B;K-M6$EB%is00:" + "+A4[7xks.LrNk0&E)wILYF@2L'0Nb$+pv<(2.768/FrY&h$^3i&@+G%JT'<-,v`3;_)I9M^AE]CN?Cl2AZg+%4iTpT3$U4O]GKx'm9)b@p7YsvK3w^YR-" + "CdQ*:Ir<($u&)#(&?L9Rg3H)4fiEp^iI9O8KnTj,]H?D*r7'M;PwZ9K0E^k&-cpI;.p/6_vwoFMV<->#%Xi.LxVnrU(4&8/P+:hLSKj$#U%]49t'I:rgMi'FL@a:0Y-uA[39',(vbma*" + "hU%<-SRF`Tt:542R_VV$p@[p8DV[A,?1839FWdFTi1O*H&#(AL8[_P%.M>v^-))qOT*F5Cq0`Ye%+$B6i:7@0IXSsDiWP,##P`%/L-" + "S(qw%sf/@%#B6;/U7K]uZbi^Oc^2n%t<)'mEVE''n`WnJra$^TKvX5B>;_aSEK',(hwa0:i4G?.Bci.(X[?b*($,=-n<.Q%`(X=?+@Am*Js0&=3bh8K]mL69=Lb,OcZV/);TTm8VI;?%OtJ<(b4mq7M6:u?KRdFl*:xP?Yb.5)%w_I?7uk5JC+FS(m#i'k.'a0i)9<7b'fs'59hq$*5Uhv##pi^8+hIEBF`nvo`;'l0.^S1<-wUK2/Coh58KKhLj" + "M=SO*rfO`+qC`W-On.=AJ56>>i2@2LH6A:&5q`?9I3@@'04&p2/LVa*T-4<-i3;M9UvZd+N7>b*eIwg:CC)c<>nO&#$(>.Z-I&J(Q0Hd5Q%7Co-b`-cP)hI;*_F]u`Rb[.j8_Q/<&>uu+VsH$sM9TA%?)(vmJ80),P7E>)tjD%2L=-t#fK[%`v=Q8WlA2);Sa" + ">gXm8YB`1d@K#n]76-a$U,mF%Ul:#/'xoFM9QX-$.QN'>" + "[%$Z$uF6pA6Ki2O5:8w*vP1<-1`[G,)-m#>0`P&#eb#.3i)rtB61(o'$?X3B2Qft^ae_5tKL9MUe9b*sLEQ95C&`=G?@Mj=wh*'3E>=-<)Gt*Iw)'QG:`@I" + "wOf7&]1i'S01B+Ev/Nac#9S;=;YQpg_6U`*kVY39xK,[/6Aj7:'1Bm-_1EYfa1+o&o4hp7KN_Q(OlIo@S%;jVdn0'1h19w,WQhLI)3S#f$2(eb,jr*b;3Vw]*7NH%$c4Vs,eD9>XW8?N]o+(*pgC%/72LV-uW%iewS8W6m2rtCpo'RS1R84=@paTKt)>=%&1[)*vp'u+x,VrwN;&]kuO9JDbg=pO$J*.jVe;u'm0dr9l,<*wMK*Oe=g8lV_KEBFkO'oU]^=[-792#ok,)" + "i]lR8qQ2oA8wcRCZ^7w/Njh;?.stX?Q1>S1q4Bn$)K1<-rGdO'$Wr.Lc.CG)$/*JL4tNR/,SVO3,aUw'DJN:)Ss;wGn9A32ijw%FL+Z0Fn.U9;reSq)bmI32U==5ALuG&#Vf1398/pVo" + "1*c-(aY168o<`JsSbk-,1N;$>0:OUas(3:8Z972LSfF8eb=c-;>SPw7.6hn3m`9^Xkn(r.qS[0;T%&Qc=+STRxX'q1BNk3&*eu2;&8q$&x>Q#Q7^Tf+6<(d%ZVmj2bDi%.3L2n+4W'$P" + "iDDG)g,r%+?,$@?uou5tSe2aN_AQU*'IAO" + "URQ##V^Fv-XFbGM7Fl(N<3DhLGF%q.1rC$#:T__&Pi68%0xi_&[qFJ(77j_&JWoF.V735&T,[R*:xFR*K5>>#`bW-?4Ne_&6Ne_&6Ne_&n`kr-#GJcM6X;uM6X;uM(.a..^2TkL%oR(#" + ";u.T%fAr%4tJ8&><1=GHZ_+m9/#H1F^R#SC#*N=BA9(D?v[UiFY>>^8p,KKF.W]L29uLkLlu/+4T" + "w$)F./^n3+rlo+DB;5sIYGNk+i1t-69Jg--0pao7Sm#K)pdHW&;LuDNH@H>#/X-TI(;P>#,Gc>#0Su>#4`1?#8lC?#xL$#B.`$#F:r$#JF.%#NR@%#R_R%#Vke%#Zww%#_-4^Rh%Sflr-k'MS.o?.5/sWel/wpEM0%3'/1)K^f1-d>G21&v(35>V`39V7A4=onx4" + "A1OY5EI0;6Ibgr6M$HS7Q<)58C5w,;WoA*#[%T*#`1g*#d=#+#hI5+#lUG+#pbY+#tnl+#x$),#&1;,#*=M,#.I`,#2Ur,#6b.-#;w[H#iQtA#m^0B#qjBB#uvTB##-hB#'9$C#+E6C#" + "/QHC#3^ZC#7jmC#;v)D#?,)4kMYD4lVu`4m`:&5niUA5@(A5BA1]PBB:xlBCC=2CDLXMCEUtiCf&0g2'tN?PGT4CPGT4CPGT4CPGT4CPGT4CPGT4CPGT4CP" + "GT4CPGT4CPGT4CPGT4CPGT4CPGT4CP-qekC`.9kEg^+F$kwViFJTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5o,^<-28ZI'O?;xp" + "O?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xp;7q-#lLYI:xvD=#"; + +#endif /* NK_INCLUDE_DEFAULT_FONT */ + +#define NK_CURSOR_DATA_W 90 +#define NK_CURSOR_DATA_H 27 +NK_GLOBAL const char nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] = +{ + "..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX" + "..- -X.....X- X.X - X.X -X.....X - X.....X" + "--- -XXX.XXX- X...X - X...X -X....X - X....X" + "X - X.X - X.....X - X.....X -X...X - X...X" + "XX - X.X -X.......X- X.......X -X..X.X - X.X..X" + "X.X - X.X -XXXX.XXXX- XXXX.XXXX -X.X X.X - X.X X.X" + "X..X - X.X - X.X - X.X -XX X.X - X.X XX" + "X...X - X.X - X.X - XX X.X XX - X.X - X.X " + "X....X - X.X - X.X - X.X X.X X.X - X.X - X.X " + "X.....X - X.X - X.X - X..X X.X X..X - X.X - X.X " + "X......X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X XX-XX X.X " + "X.......X - X.X - X.X -X.....................X- X.X X.X-X.X X.X " + "X........X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X..X-X..X.X " + "X.........X -XXX.XXX- X.X - X..X X.X X..X - X...X-X...X " + "X..........X-X.....X- X.X - X.X X.X X.X - X....X-X....X " + "X......XXXXX-XXXXXXX- X.X - XX X.X XX - X.....X-X.....X " + "X...X..X --------- X.X - X.X - XXXXXXX-XXXXXXX " + "X..X X..X - -XXXX.XXXX- XXXX.XXXX ------------------------------------" + "X.X X..X - -X.......X- X.......X - XX XX - " + "XX X..X - - X.....X - X.....X - X.X X.X - " + " X..X - X...X - X...X - X..X X..X - " + " XX - X.X - X.X - X...XXXXXXXXXXXXX...X - " + "------------ - X - X -X.....................X- " + " ----------------------------------- X...XXXXXXXXXXXXX...X - " + " - X..X X..X - " + " - X.X X.X - " + " - XX XX - " +}; + +#ifdef __clang__ +#pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic pop +#endif + +NK_GLOBAL unsigned char *nk__barrier; +NK_GLOBAL unsigned char *nk__barrier2; +NK_GLOBAL unsigned char *nk__barrier3; +NK_GLOBAL unsigned char *nk__barrier4; +NK_GLOBAL unsigned char *nk__dout; + +NK_INTERN unsigned int +nk_decompress_length(unsigned char *input) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_decompress_length"); + return (unsigned int)((input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11]); +} +NK_INTERN void +nk__match(unsigned char *data, unsigned int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk__match"); + /* INVERSE of memmove... write each byte before copying the next...*/ + // NK_ASSERT (nk__dout + length <= nk__barrier); + if (nk__dout + length > nk__barrier) { nk__dout += length; return; } + if (data < nk__barrier4) { nk__dout = nk__barrier+1; return; } + while (length--) *nk__dout++ = *data++; +} +NK_INTERN void +nk__lit(unsigned char *data, unsigned int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk__lit"); + // NK_ASSERT (nk__dout + length <= nk__barrier); + if (nk__dout + length > nk__barrier) { nk__dout += length; return; } + if (data < nk__barrier2) { nk__dout = nk__barrier+1; return; } + NK_MEMCPY(nk__dout, data, length); + nk__dout += length; +} +NK_INTERN unsigned char* +nk_decompress_token(unsigned char *i) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_decompress_token"); + #define nk__in2(x) ((i[x] << 8) + i[(x)+1]) + #define nk__in3(x) ((i[x] << 16) + nk__in2((x)+1)) + #define nk__in4(x) ((i[x] << 24) + nk__in3((x)+1)) + + if (*i >= 0x20) { /* use fewer if's for cases that expand small */ + if (*i >= 0x80) nk__match(nk__dout-i[1]-1, (unsigned int)i[0] - 0x80 + 1), i += 2; + else if (*i >= 0x40) nk__match(nk__dout-(nk__in2(0) - 0x4000 + 1), (unsigned int)i[2]+1), i += 3; + else /* *i >= 0x20 */ nk__lit(i+1, (unsigned int)i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1); + } else { /* more ifs for cases that expand large, since overhead is amortized */ + if (*i >= 0x18) nk__match(nk__dout-(unsigned int)(nk__in3(0) - 0x180000 + 1), (unsigned int)i[3]+1), i += 4; + else if (*i >= 0x10) nk__match(nk__dout-(unsigned int)(nk__in3(0) - 0x100000 + 1), (unsigned int)nk__in2(3)+1), i += 5; + else if (*i >= 0x08) nk__lit(i+2, (unsigned int)nk__in2(0) - 0x0800 + 1), i += 2 + (nk__in2(0) - 0x0800 + 1); + else if (*i == 0x07) nk__lit(i+3, (unsigned int)nk__in2(1) + 1), i += 3 + (nk__in2(1) + 1); + else if (*i == 0x06) nk__match(nk__dout-(unsigned int)(nk__in3(1)+1), i[4]+1u), i += 5; + else if (*i == 0x04) nk__match(nk__dout-(unsigned int)(nk__in3(1)+1), (unsigned int)nk__in2(4)+1u), i += 6; + } + return i; +} +NK_INTERN unsigned int +nk_adler32(unsigned int adler32, unsigned char *buffer, unsigned int buflen) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - int / nk_adler32"); + const unsigned long ADLER_MOD = 65521; + unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16; + unsigned long blocklen, i; + + blocklen = buflen % 5552; + while (buflen) { + for (i=0; i + 7 < blocklen; i += 8) { + s1 += buffer[0]; s2 += s1; + s1 += buffer[1]; s2 += s1; + s1 += buffer[2]; s2 += s1; + s1 += buffer[3]; s2 += s1; + s1 += buffer[4]; s2 += s1; + s1 += buffer[5]; s2 += s1; + s1 += buffer[6]; s2 += s1; + s1 += buffer[7]; s2 += s1; + buffer += 8; + } + for (; i < blocklen; ++i) { + s1 += *buffer++; s2 += s1; + } + + s1 %= ADLER_MOD; s2 %= ADLER_MOD; + buflen -= (unsigned int)blocklen; + blocklen = 5552; + } + return (unsigned int)(s2 << 16) + (unsigned int)s1; +} +NK_INTERN unsigned int +nk_decompress(unsigned char *output, unsigned char *i, unsigned int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_decompress"); + unsigned int olen; + if (nk__in4(0) != 0x57bC0000) return 0; + if (nk__in4(4) != 0) return 0; /* error! stream is > 4GB */ + olen = nk_decompress_length(i); + nk__barrier2 = i; + nk__barrier3 = i+length; + nk__barrier = output + olen; + nk__barrier4 = output; + i += 16; + + nk__dout = output; + for (;;) { + unsigned char *old_i = i; + i = nk_decompress_token(i); + if (i == old_i) { + if (*i == 0x05 && i[1] == 0xfa) { + // NK_ASSERT(nk__dout == output + olen); + if (nk__dout != output + olen) return 0; + if (nk_adler32(1, output, olen) != (unsigned int) nk__in4(2)) + return 0; + return olen; + } else { + // NK_ASSERT(0); /* NOTREACHED */ + return 0; + } + } + // NK_ASSERT(nk__dout <= output + olen); + if (nk__dout > output + olen) + return 0; + } +} +NK_INTERN unsigned int +nk_decode_85_byte(char c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / nk_decode_85_byte"); + return (unsigned int)((c >= '\\') ? c-36 : c-35); +} +NK_INTERN void +nk_decode_85(unsigned char* dst, const unsigned char* src) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char / nk_decode_85"); + while (*src) + { + unsigned int tmp = + nk_decode_85_byte((char)src[0]) + + 85 * (nk_decode_85_byte((char)src[1]) + + 85 * (nk_decode_85_byte((char)src[2]) + + 85 * (nk_decode_85_byte((char)src[3]) + + 85 * nk_decode_85_byte((char)src[4])))); + + /* we can't assume little-endianess. */ + dst[0] = (unsigned char)((tmp >> 0) & 0xFF); + dst[1] = (unsigned char)((tmp >> 8) & 0xFF); + dst[2] = (unsigned char)((tmp >> 16) & 0xFF); + dst[3] = (unsigned char)((tmp >> 24) & 0xFF); + + src += 5; + dst += 4; + } +} + +/* ------------------------------------------------------------- + * + * FONT ATLAS + * + * --------------------------------------------------------------*/ +NK_API struct nk_font_config +nk_font_config(int pixel_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pixel_height / nk_font_config"); + struct nk_font_config cfg; + nk_zero_struct(cfg); + cfg.ttf_blob = 0; + cfg.ttf_size = 0; + cfg.ttf_data_owned_by_atlas = 0; + cfg.size = pixel_height; + cfg.oversample_h = 3; + cfg.oversample_v = 1; + cfg.pixel_snap = 0; + cfg.coord_type = NK_COORD_UV; + cfg.spacing = nk_vec2(0,0); + cfg.range = nk_font_default_glyph_ranges(); + cfg.merge_mode = 0; + cfg.fallback_glyph = '?'; + cfg.font = 0; + cfg.n = 0; + return cfg; +} +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void +nk_font_atlas_init_default(struct nk_font_atlas *atlas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_init_default"); + // NK_ASSERT(atlas); + if (!atlas) return; + nk_zero_struct(*atlas); + atlas->temporary.userdata.ptr = 0; + atlas->temporary.alloc = nk_malloc; + atlas->temporary.free = nk_mfree; + atlas->permanent.userdata.ptr = 0; + atlas->permanent.alloc = nk_malloc; + atlas->permanent.free = nk_mfree; +} +#endif +NK_API void +nk_font_atlas_init(struct nk_font_atlas *atlas, struct nk_allocator *alloc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_init"); + // NK_ASSERT(atlas); + // NK_ASSERT(alloc); + if (!atlas || !alloc) return; + nk_zero_struct(*atlas); + atlas->permanent = *alloc; + atlas->temporary = *alloc; +} +NK_API void +nk_font_atlas_init_custom(struct nk_font_atlas *atlas, + struct nk_allocator *permanent, struct nk_allocator *temporary) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - permanent / struct"); + // NK_ASSERT(atlas); + // NK_ASSERT(permanent); + // NK_ASSERT(temporary); + if (!atlas || !permanent || !temporary) return; + nk_zero_struct(*atlas); + atlas->permanent = *permanent; + atlas->temporary = *temporary; +} +NK_API void +nk_font_atlas_begin(struct nk_font_atlas *atlas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_begin"); + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc && atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc && atlas->permanent.free); + if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free || + !atlas->temporary.alloc || !atlas->temporary.free) return; + if (atlas->glyphs) { + atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs); + atlas->glyphs = 0; + } + if (atlas->pixel) { + atlas->permanent.free(atlas->permanent.userdata, atlas->pixel); + atlas->pixel = 0; + } +} +NK_API struct nk_font* +nk_font_atlas_add(struct nk_font_atlas *atlas, const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_add"); + struct nk_font *font = 0; + struct nk_font_config *cfg; + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + + // NK_ASSERT(config); + // NK_ASSERT(config->ttf_blob); + // NK_ASSERT(config->ttf_size); + // NK_ASSERT(config->size > 0.0f); + + if (!atlas || !config || !config->ttf_blob || !config->ttf_size || config->size <= 0.0f|| + !atlas->permanent.alloc || !atlas->permanent.free || + !atlas->temporary.alloc || !atlas->temporary.free) + return 0; + + /* allocate font config */ + cfg = (struct nk_font_config*) + atlas->permanent.alloc(atlas->permanent.userdata,0, sizeof(struct nk_font_config)); + NK_MEMCPY(cfg, config, sizeof(*config)); + cfg->n = cfg; + cfg->p = cfg; + + if (!config->merge_mode) { + /* insert font config into list */ + if (!atlas->config) { + atlas->config = cfg; + cfg->next = 0; + } else { + struct nk_font_config *i = atlas->config; + while (i->next) i = i->next; + i->next = cfg; + cfg->next = 0; + } + /* allocate new font */ + font = (struct nk_font*) + atlas->permanent.alloc(atlas->permanent.userdata,0, sizeof(struct nk_font)); + // NK_ASSERT(font); + nk_zero(font, sizeof(*font)); + if (!font) return 0; + font->config = cfg; + + /* insert font into list */ + if (!atlas->fonts) { + atlas->fonts = font; + font->next = 0; + } else { + struct nk_font *i = atlas->fonts; + while (i->next) i = i->next; + i->next = font; + font->next = 0; + } + cfg->font = &font->info; + } else { + /* extend previously added font */ + struct nk_font *f = 0; + struct nk_font_config *c = 0; + // NK_ASSERT(atlas->font_num); + f = atlas->fonts; + c = f->config; + cfg->font = &f->info; + + cfg->n = c; + cfg->p = c->p; + c->p->n = cfg; + c->p = cfg; + } + /* create own copy of .TTF font blob */ + if (!config->ttf_data_owned_by_atlas) { + cfg->ttf_blob = atlas->permanent.alloc(atlas->permanent.userdata,0, cfg->ttf_size); + // NK_ASSERT(cfg->ttf_blob); + if (!cfg->ttf_blob) { + atlas->font_num++; + return 0; + } + NK_MEMCPY(cfg->ttf_blob, config->ttf_blob, cfg->ttf_size); + cfg->ttf_data_owned_by_atlas = 1; + } + atlas->font_num++; + return font; +} +NK_API struct nk_font* +nk_font_atlas_add_from_memory(struct nk_font_atlas *atlas, void *memory, + nk_size size, int height, const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - size, / nk_size"); + struct nk_font_config cfg; + // NK_ASSERT(memory); + // NK_ASSERT(size); + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + if (!atlas || !atlas->temporary.alloc || !atlas->temporary.free || !memory || !size || + !atlas->permanent.alloc || !atlas->permanent.free) + return 0; + + cfg = (config) ? *config: nk_font_config(height); + cfg.ttf_blob = memory; + cfg.ttf_size = size; + cfg.size = height; + cfg.ttf_data_owned_by_atlas = 0; + return nk_font_atlas_add(atlas, &cfg); +} +#ifdef NK_INCLUDE_STANDARD_IO +NK_API struct nk_font* +nk_font_atlas_add_from_file(struct nk_font_atlas *atlas, const char *file_path, + int height, const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - height, / int"); + nk_size size; + char *memory; + struct nk_font_config cfg; + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + + if (!atlas || !file_path) return 0; + memory = nk_file_load(file_path, &size, &atlas->permanent); + if (!memory) return 0; + + cfg = (config) ? *config: nk_font_config(height); + cfg.ttf_blob = memory; + cfg.ttf_size = size; + cfg.size = height; + cfg.ttf_data_owned_by_atlas = 1; + return nk_font_atlas_add(atlas, &cfg); +} +#endif +NK_API struct nk_font* +nk_font_atlas_add_compressed(struct nk_font_atlas *atlas, + void *compressed_data, nk_size compressed_size, int height, + const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_config / const"); + unsigned int decompressed_size; + void *decompressed_data; + struct nk_font_config cfg; + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + + // NK_ASSERT(compressed_data); + // NK_ASSERT(compressed_size); + if (!atlas || !compressed_data || !atlas->temporary.alloc || !atlas->temporary.free || + !atlas->permanent.alloc || !atlas->permanent.free) + return 0; + + decompressed_size = nk_decompress_length((unsigned char*)compressed_data); + decompressed_data = atlas->permanent.alloc(atlas->permanent.userdata,0,decompressed_size); + // NK_ASSERT(decompressed_data); + if (!decompressed_data) return 0; + nk_decompress((unsigned char*)decompressed_data, (unsigned char*)compressed_data, + (unsigned int)compressed_size); + + cfg = (config) ? *config: nk_font_config(height); + cfg.ttf_blob = decompressed_data; + cfg.ttf_size = decompressed_size; + cfg.size = height; + cfg.ttf_data_owned_by_atlas = 1; + return nk_font_atlas_add(atlas, &cfg); +} +NK_API struct nk_font* +nk_font_atlas_add_compressed_base85(struct nk_font_atlas *atlas, + const char *data_base85, int height, const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - data_base85 / const"); + int compressed_size; + void *compressed_data; + struct nk_font *font; + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + + // NK_ASSERT(data_base85); + if (!atlas || !data_base85 || !atlas->temporary.alloc || !atlas->temporary.free || + !atlas->permanent.alloc || !atlas->permanent.free) + return 0; + + compressed_size = (((int)strlen(data_base85) + 4) / 5) * 4; + compressed_data = atlas->temporary.alloc(atlas->temporary.userdata,0, (nk_size)compressed_size); + // NK_ASSERT(compressed_data); + if (!compressed_data) return 0; + nk_decode_85((unsigned char*)compressed_data, (const unsigned char*)data_base85); + font = nk_font_atlas_add_compressed(atlas, compressed_data, + (nk_size)compressed_size, height, config); + atlas->temporary.free(atlas->temporary.userdata, compressed_data); + return font; +} + +#ifdef NK_INCLUDE_DEFAULT_FONT +NK_API struct nk_font* +nk_font_atlas_add_default(struct nk_font_atlas *atlas, + int pixel_height, const struct nk_font_config *config) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pixel_height, / int"); + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + return nk_font_atlas_add_compressed_base85(atlas, + nk_proggy_clean_ttf_compressed_data_base85, pixel_height, config); +} +#endif +NK_API const void* +nk_font_atlas_bake(struct nk_font_atlas *atlas, int *width, int *height, + enum nk_font_atlas_format fmt) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fmt / enum"); + int i = 0; + void *tmp = 0; + nk_size tmp_size, img_size; + struct nk_font *font_iter; + struct nk_font_baker *baker; + + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + + // NK_ASSERT(width); + // NK_ASSERT(height); + if (!atlas || !width || !height || + !atlas->temporary.alloc || !atlas->temporary.free || + !atlas->permanent.alloc || !atlas->permanent.free) + return 0; + +#ifdef NK_INCLUDE_DEFAULT_FONT + /* no font added so just use default font */ + if (!atlas->font_num) + atlas->default_font = nk_font_atlas_add_default(atlas, 13.0f, 0); +#endif + // NK_ASSERT(atlas->font_num); + if (!atlas->font_num) return 0; + + /* allocate temporary baker memory required for the baking process */ + nk_font_baker_memory(&tmp_size, &atlas->glyph_count, atlas->config, atlas->font_num); + tmp = atlas->temporary.alloc(atlas->temporary.userdata,0, tmp_size); + // NK_ASSERT(tmp); + if (!tmp) goto failed; + memset(tmp,0,tmp_size); + + /* allocate glyph memory for all fonts */ + baker = nk_font_baker(tmp, atlas->glyph_count, atlas->font_num, &atlas->temporary); + atlas->glyphs = (struct nk_font_glyph*)atlas->permanent.alloc( + atlas->permanent.userdata,0, sizeof(struct nk_font_glyph)*(nk_size)atlas->glyph_count); + // NK_ASSERT(atlas->glyphs); + if (!atlas->glyphs) + goto failed; + + /* pack all glyphs into a tight fit space */ + atlas->custom.w = (NK_CURSOR_DATA_W*2)+1; + atlas->custom.h = NK_CURSOR_DATA_H + 1; + if (!nk_font_bake_pack(baker, &img_size, width, height, &atlas->custom, + atlas->config, atlas->font_num, &atlas->temporary)) + goto failed; + + /* allocate memory for the baked image font atlas */ + atlas->pixel = atlas->temporary.alloc(atlas->temporary.userdata,0, img_size); + // NK_ASSERT(atlas->pixel); + if (!atlas->pixel) + goto failed; + + /* bake glyphs and custom white pixel into image */ + nk_font_bake(baker, atlas->pixel, *width, *height, + atlas->glyphs, atlas->glyph_count, atlas->config, atlas->font_num); + nk_font_bake_custom_data(atlas->pixel, *width, *height, atlas->custom, + nk_custom_cursor_data, NK_CURSOR_DATA_W, NK_CURSOR_DATA_H, '.', 'X'); + + if (fmt == NK_FONT_ATLAS_RGBA32) { + /* convert alpha8 image into rgba32 image */ + void *img_rgba = atlas->temporary.alloc(atlas->temporary.userdata,0, + (nk_size)(*width * *height * 4)); + // NK_ASSERT(img_rgba); + if (!img_rgba) goto failed; + nk_font_bake_convert(img_rgba, *width, *height, atlas->pixel); + atlas->temporary.free(atlas->temporary.userdata, atlas->pixel); + atlas->pixel = img_rgba; + } + atlas->tex_width = *width; + atlas->tex_height = *height; + + /* initialize each font */ + for (font_iter = atlas->fonts; font_iter; font_iter = font_iter->next) { + struct nk_font *font = font_iter; + struct nk_font_config *config = font->config; + nk_font_init(font, config->size, config->fallback_glyph, atlas->glyphs, + config->font, nk_handle_ptr(0)); + } + + /* initialize each cursor */ + {NK_STORAGE const struct nk_vec2 nk_cursor_data[NK_CURSOR_COUNT][3] = { + /* Pos Size Offset */ + {{ 0, 3}, {12,19}, { 0, 0}}, + {{13, 0}, { 7,16}, { 4, 8}}, + {{31, 0}, {23,23}, {11,11}}, + {{21, 0}, { 9, 23}, { 5,11}}, + {{55,18}, {23, 9}, {11, 5}}, + {{73, 0}, {17,17}, { 9, 9}}, + {{55, 0}, {17,17}, { 9, 9}} + }; + for (i = 0; i < NK_CURSOR_COUNT; ++i) { + struct nk_cursor *cursor = &atlas->cursors[i]; + cursor->img.w = (unsigned short)*width; + cursor->img.h = (unsigned short)*height; + cursor->img.region[0] = (unsigned short)(atlas->custom.x + nk_cursor_data[i][0].x); + cursor->img.region[1] = (unsigned short)(atlas->custom.y + nk_cursor_data[i][0].y); + cursor->img.region[2] = (unsigned short)nk_cursor_data[i][1].x; + cursor->img.region[3] = (unsigned short)nk_cursor_data[i][1].y; + cursor->size = nk_cursor_data[i][1]; + cursor->offset = nk_cursor_data[i][2]; + }} + /* free temporary memory */ + atlas->temporary.free(atlas->temporary.userdata, tmp); + return atlas->pixel; + +failed: + /* error so cleanup all memory */ + if (tmp) atlas->temporary.free(atlas->temporary.userdata, tmp); + if (atlas->glyphs) { + atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs); + atlas->glyphs = 0; + } + if (atlas->pixel) { + atlas->temporary.free(atlas->temporary.userdata, atlas->pixel); + atlas->pixel = 0; + } + return 0; +} +NK_API void +nk_font_atlas_end(struct nk_font_atlas *atlas, nk_handle texture, + struct nk_draw_null_texture *null) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - null / struct"); + int i = 0; + struct nk_font *font_iter; + // NK_ASSERT(atlas); + if (!atlas) { + if (!null) return; + null->texture = texture; + null->uv = nk_vec2(0.5f,0.5f); + } + if (null) { + null->texture = texture; + null->uv.x = (atlas->custom.x + 0.5f)/(int)atlas->tex_width; + null->uv.y = (atlas->custom.y + 0.5f)/(int)atlas->tex_height; + } + for (font_iter = atlas->fonts; font_iter; font_iter = font_iter->next) { + font_iter->texture = texture; +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT + font_iter->handle.texture = texture; +#endif + } + for (i = 0; i < NK_CURSOR_COUNT; ++i) + atlas->cursors[i].img.handle = texture; + + atlas->temporary.free(atlas->temporary.userdata, atlas->pixel); + atlas->pixel = 0; + atlas->tex_width = 0; + atlas->tex_height = 0; + atlas->custom.x = 0; + atlas->custom.y = 0; + atlas->custom.w = 0; + atlas->custom.h = 0; +} +NK_API void +nk_font_atlas_cleanup(struct nk_font_atlas *atlas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_cleanup"); + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free) return; + if (atlas->config) { + struct nk_font_config *iter; + for (iter = atlas->config; iter; iter = iter->next) { + struct nk_font_config *i; + for (i = iter->n; i != iter; i = i->n) { + atlas->permanent.free(atlas->permanent.userdata, i->ttf_blob); + i->ttf_blob = 0; + } + atlas->permanent.free(atlas->permanent.userdata, iter->ttf_blob); + iter->ttf_blob = 0; + } + } +} +NK_API void +nk_font_atlas_clear(struct nk_font_atlas *atlas) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_font_atlas / nk_font_atlas_clear"); + // NK_ASSERT(atlas); + // NK_ASSERT(atlas->temporary.alloc); + // NK_ASSERT(atlas->temporary.free); + // NK_ASSERT(atlas->permanent.alloc); + // NK_ASSERT(atlas->permanent.free); + if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free) return; + + if (atlas->config) { + struct nk_font_config *iter, *next; + for (iter = atlas->config; iter; iter = next) { + struct nk_font_config *i, *n; + for (i = iter->n; i != iter; i = n) { + n = i->n; + if (i->ttf_blob) + atlas->permanent.free(atlas->permanent.userdata, i->ttf_blob); + atlas->permanent.free(atlas->permanent.userdata, i); + } + next = iter->next; + if (i->ttf_blob) + atlas->permanent.free(atlas->permanent.userdata, iter->ttf_blob); + atlas->permanent.free(atlas->permanent.userdata, iter); + } + atlas->config = 0; + } + if (atlas->fonts) { + struct nk_font *iter, *next; + for (iter = atlas->fonts; iter; iter = next) { + next = iter->next; + atlas->permanent.free(atlas->permanent.userdata, iter); + } + atlas->fonts = 0; + } + if (atlas->glyphs) + atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs); + nk_zero_struct(*atlas); +} +#endif + + + + + +/* =============================================================== + * + * INPUT + * + * ===============================================================*/ +NK_API void +nk_input_begin(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_begin"); + int i; + struct nk_input *in; + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + for (i = 0; i < NK_BUTTON_MAX; ++i) + in->mouse.buttons[i].clicked = 0; + + in->keyboard.text_len = 0; + in->mouse.scroll_delta = nk_vec2(0,0); + in->mouse.prev.x = in->mouse.pos.x; + in->mouse.prev.y = in->mouse.pos.y; + in->mouse.delta.x = 0; + in->mouse.delta.y = 0; + for (i = 0; i < NK_KEY_MAX; i++) + in->keyboard.keys[i].clicked = 0; +} +NK_API void +nk_input_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_end"); + struct nk_input *in; + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + if (in->mouse.grab) + in->mouse.grab = 0; + if (in->mouse.ungrab) { + in->mouse.grabbed = 0; + in->mouse.ungrab = 0; + in->mouse.grab = 0; + } +} +NK_API void +nk_input_motion(struct nk_context *ctx, int x, int y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_motion"); + struct nk_input *in; + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + in->mouse.pos.x = (int)x; + in->mouse.pos.y = (int)y; + in->mouse.delta.x = in->mouse.pos.x - in->mouse.prev.x; + in->mouse.delta.y = in->mouse.pos.y - in->mouse.prev.y; +} +NK_API void +nk_input_key(struct nk_context *ctx, enum nk_keys key, nk_bool down) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_key"); + struct nk_input *in; + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; +#ifdef NK_KEYSTATE_BASED_INPUT + if (in->keyboard.keys[key].down != down) + in->keyboard.keys[key].clicked++; +#else + in->keyboard.keys[key].clicked++; +#endif + in->keyboard.keys[key].down = down; +} +NK_API void +nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, nk_bool down) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_button"); + struct nk_mouse_button *btn; + struct nk_input *in; + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + if (in->mouse.buttons[id].down == down) return; + + btn = &in->mouse.buttons[id]; + btn->clicked_pos.x = (int)x; + btn->clicked_pos.y = (int)y; + btn->down = down; + btn->clicked++; +} +NK_API void +nk_input_scroll(struct nk_context *ctx, struct nk_vec2 val) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_scroll"); + // NK_ASSERT(ctx); + if (!ctx) return; + ctx->input.mouse.scroll_delta.x += val.x; + ctx->input.mouse.scroll_delta.y += val.y; +} +NK_API void +nk_input_glyph(struct nk_context *ctx, const nk_glyph glyph) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_glyph"); + int len = 0; + nk_rune unicode; + struct nk_input *in; + + // NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + + len = nk_utf_decode(glyph, &unicode, NK_UTF_SIZE); + if (len && ((in->keyboard.text_len + len) < NK_INPUT_MAX)) { + nk_utf_encode(unicode, &in->keyboard.text[in->keyboard.text_len], + NK_INPUT_MAX - in->keyboard.text_len); + in->keyboard.text_len += len; + } +} +NK_API void +nk_input_char(struct nk_context *ctx, char c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_char"); + nk_glyph glyph; + // NK_ASSERT(ctx); + if (!ctx) return; + glyph[0] = c; + nk_input_glyph(ctx, glyph); +} +NK_API void +nk_input_unicode(struct nk_context *ctx, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_input_unicode"); + nk_glyph rune; + // NK_ASSERT(ctx); + if (!ctx) return; + nk_utf_encode(unicode, rune, NK_UTF_SIZE); + nk_input_glyph(ctx, rune); +} +NK_API nk_bool +nk_input_has_mouse_click(const struct nk_input *i, enum nk_buttons id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_has_mouse_click"); + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; + return (btn->clicked && btn->down == nk_false) ? nk_true : nk_false; +} +NK_API nk_bool +nk_input_has_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id, + struct nk_rect b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input_has_mouse_click_in_rect"); + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; + if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h)) + return nk_false; + return nk_true; +} +NK_API nk_bool +nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id, + struct nk_rect b, nk_bool down) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input_has_mouse_click_down_in_rect"); + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; + return nk_input_has_mouse_click_in_rect(i, id, b) && (btn->down == down); +} +NK_API nk_bool +nk_input_is_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id, + struct nk_rect b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input_is_mouse_click_in_rect"); + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; + return (nk_input_has_mouse_click_down_in_rect(i, id, b, nk_false) && btn->clicked) ? nk_true : nk_false; +} +NK_API nk_bool +nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id, + struct nk_rect b, nk_bool down) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input_is_mouse_click_down_in_rect"); + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; + return (nk_input_has_mouse_click_down_in_rect(i, id, b, down) && btn->clicked) ? nk_true : nk_false; +} +NK_API nk_bool +nk_input_any_mouse_click_in_rect(const struct nk_input *in, struct nk_rect b) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_any_mouse_click_in_rect"); + int i, down = 0; + for (i = 0; i < NK_BUTTON_MAX; ++i) + down = down || nk_input_is_mouse_click_in_rect(in, (enum nk_buttons)i, b); + return down; +} +NK_API nk_bool +nk_input_is_mouse_hovering_rect(const struct nk_input *i, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_mouse_hovering_rect"); + if (!i) return nk_false; + return NK_INBOX(i->mouse.pos.x, i->mouse.pos.y, rect.x, rect.y, rect.w, rect.h); +} +NK_API nk_bool +nk_input_is_mouse_prev_hovering_rect(const struct nk_input *i, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_mouse_prev_hovering_rect"); + if (!i) return nk_false; + return NK_INBOX(i->mouse.prev.x, i->mouse.prev.y, rect.x, rect.y, rect.w, rect.h); +} +NK_API nk_bool +nk_input_mouse_clicked(const struct nk_input *i, enum nk_buttons id, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_mouse_clicked"); + if (!i) return nk_false; + if (!nk_input_is_mouse_hovering_rect(i, rect)) return nk_false; + return nk_input_is_mouse_click_in_rect(i, id, rect); +} +NK_API nk_bool +nk_input_is_mouse_down(const struct nk_input *i, enum nk_buttons id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_mouse_down"); + if (!i) return nk_false; + return i->mouse.buttons[id].down; +} +NK_API nk_bool +nk_input_is_mouse_pressed(const struct nk_input *i, enum nk_buttons id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_mouse_pressed"); + const struct nk_mouse_button *b; + if (!i) return nk_false; + b = &i->mouse.buttons[id]; + if (b->down && b->clicked) + return nk_true; + return nk_false; +} +NK_API nk_bool +nk_input_is_mouse_released(const struct nk_input *i, enum nk_buttons id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_mouse_released"); + if (!i) return nk_false; + return (!i->mouse.buttons[id].down && i->mouse.buttons[id].clicked); +} +NK_API nk_bool +nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_key_pressed"); + const struct nk_key *k; + if (!i) return nk_false; + k = &i->keyboard.keys[key]; + + if ((k->down && k->clicked) || (!k->down && k->clicked >= 2)) + return nk_true; + return nk_false; +} +NK_API nk_bool +nk_input_is_key_released(const struct nk_input *i, enum nk_keys key) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_key_released"); + const struct nk_key *k; + if (!i) return nk_false; + k = &i->keyboard.keys[key]; + if ((!k->down && k->clicked) || (k->down && k->clicked >= 2)) + return nk_true; + return nk_false; +} +NK_API nk_bool +nk_input_is_key_down(const struct nk_input *i, enum nk_keys key) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_input_is_key_down"); + const struct nk_key *k; + if (!i) return nk_false; + k = &i->keyboard.keys[key]; + if (k->down) return nk_true; + return nk_false; +} + + + + + +/* =============================================================== + * + * STYLE + * + * ===============================================================*/ +NK_API void nk_style_default(struct nk_context *ctx){nk_style_from_table(ctx, 0);} +#define NK_COLOR_MAP(NK_COLOR)\ + NK_COLOR(NK_COLOR_TEXT, 175,175,175,255) \ + NK_COLOR(NK_COLOR_WINDOW, 45, 45, 45, 255) \ + NK_COLOR(NK_COLOR_HEADER, 40, 40, 40, 255) \ + NK_COLOR(NK_COLOR_BORDER, 65, 65, 65, 255) \ + NK_COLOR(NK_COLOR_BUTTON, 50, 50, 50, 255) \ + NK_COLOR(NK_COLOR_BUTTON_HOVER, 40, 40, 40, 255) \ + NK_COLOR(NK_COLOR_BUTTON_ACTIVE, 35, 35, 35, 255) \ + NK_COLOR(NK_COLOR_TOGGLE, 100,100,100,255) \ + NK_COLOR(NK_COLOR_TOGGLE_HOVER, 120,120,120,255) \ + NK_COLOR(NK_COLOR_TOGGLE_CURSOR, 45, 45, 45, 255) \ + NK_COLOR(NK_COLOR_SELECT, 45, 45, 45, 255) \ + NK_COLOR(NK_COLOR_SELECT_ACTIVE, 35, 35, 35,255) \ + NK_COLOR(NK_COLOR_SLIDER, 38, 38, 38, 255) \ + NK_COLOR(NK_COLOR_SLIDER_CURSOR, 100,100,100,255) \ + NK_COLOR(NK_COLOR_SLIDER_CURSOR_HOVER, 120,120,120,255) \ + NK_COLOR(NK_COLOR_SLIDER_CURSOR_ACTIVE, 150,150,150,255) \ + NK_COLOR(NK_COLOR_PROPERTY, 38, 38, 38, 255) \ + NK_COLOR(NK_COLOR_EDIT, 38, 38, 38, 255) \ + NK_COLOR(NK_COLOR_EDIT_CURSOR, 175,175,175,255) \ + NK_COLOR(NK_COLOR_COMBO, 45, 45, 45, 255) \ + NK_COLOR(NK_COLOR_CHART, 120,120,120,255) \ + NK_COLOR(NK_COLOR_CHART_COLOR, 45, 45, 45, 255) \ + NK_COLOR(NK_COLOR_CHART_COLOR_HIGHLIGHT, 255, 0, 0, 255) \ + NK_COLOR(NK_COLOR_SCROLLBAR, 40, 40, 40, 255) \ + NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR, 100,100,100,255) \ + NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR_HOVER, 120,120,120,255) \ + NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR_ACTIVE, 150,150,150,255) \ + NK_COLOR(NK_COLOR_TAB_HEADER, 40, 40, 40,255) + +NK_GLOBAL const struct nk_color +nk_default_color_style[NK_COLOR_COUNT] = { +#define NK_COLOR(a,b,c,d,e) {b,c,d,e}, + NK_COLOR_MAP(NK_COLOR) +#undef NK_COLOR +}; +NK_GLOBAL const char *nk_color_names[NK_COLOR_COUNT] = { +#define NK_COLOR(a,b,c,d,e) #a, + NK_COLOR_MAP(NK_COLOR) +#undef NK_COLOR +}; + +NK_API const char* +nk_style_get_color_by_name(enum nk_style_colors c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_colors / nk_style_get_color_by_name"); + return nk_color_names[c]; +} +NK_API struct nk_style_item +nk_style_item_image(struct nk_image img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_image / nk_style_item_image"); + struct nk_style_item i; + i.type = NK_STYLE_ITEM_IMAGE; + i.data.image = img; + return i; +} +NK_API struct nk_style_item +nk_style_item_color(struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_color / nk_style_item_color"); + struct nk_style_item i; + i.type = NK_STYLE_ITEM_COLOR; + i.data.color = col; + return i; +} +NK_API struct nk_style_item +nk_style_item_hide(void) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - void) / nk_style_item_hide"); + struct nk_style_item i; + i.type = NK_STYLE_ITEM_COLOR; + i.data.color = nk_rgba(0,0,0,0); + return i; +} +NK_API void +nk_style_from_table(struct nk_context *ctx, const struct nk_color *table) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_from_table"); + struct nk_style *style; + struct nk_style_text *text; + struct nk_style_button *button; + struct nk_style_toggle *toggle; + struct nk_style_selectable *select; + struct nk_style_slider *slider; + struct nk_style_progress *prog; + struct nk_style_scrollbar *scroll; + struct nk_style_edit *edit; + struct nk_style_property *property; + struct nk_style_combo *combo; + struct nk_style_chart *chart; + struct nk_style_tab *tab; + struct nk_style_window *win; + + // NK_ASSERT(ctx); + if (!ctx) return; + style = &ctx->style; + table = (!table) ? nk_default_color_style: table; + + /* default text */ + text = &style->text; + text->color = table[NK_COLOR_TEXT]; + text->padding = nk_vec2(0,0); + + /* default button */ + button = &style->button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_BUTTON]); + button->hover = nk_style_item_color(table[NK_COLOR_BUTTON_HOVER]); + button->active = nk_style_item_color(table[NK_COLOR_BUTTON_ACTIVE]); + button->border_color = table[NK_COLOR_BORDER]; + button->text_background = table[NK_COLOR_BUTTON]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->image_padding = nk_vec2(0.0f,0.0f); + button->touch_padding = nk_vec2(0.0f, 0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 1.0f; + button->rounding = 4.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* contextual button */ + button = &style->contextual_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->hover = nk_style_item_color(table[NK_COLOR_BUTTON_HOVER]); + button->active = nk_style_item_color(table[NK_COLOR_BUTTON_ACTIVE]); + button->border_color = table[NK_COLOR_WINDOW]; + button->text_background = table[NK_COLOR_WINDOW]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* menu button */ + button = &style->menu_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->hover = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->active = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->border_color = table[NK_COLOR_WINDOW]; + button->text_background = table[NK_COLOR_WINDOW]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 1.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* checkbox toggle */ + toggle = &style->checkbox; + nk_zero_struct(*toggle); + toggle->normal = nk_style_item_color(table[NK_COLOR_TOGGLE]); + toggle->hover = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]); + toggle->active = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]); + toggle->cursor_normal = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]); + toggle->cursor_hover = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]); + toggle->userdata = nk_handle_ptr(0); + toggle->text_background = table[NK_COLOR_WINDOW]; + toggle->text_normal = table[NK_COLOR_TEXT]; + toggle->text_hover = table[NK_COLOR_TEXT]; + toggle->text_active = table[NK_COLOR_TEXT]; + toggle->padding = nk_vec2(2.0f, 2.0f); + toggle->touch_padding = nk_vec2(0,0); + toggle->border_color = nk_rgba(0,0,0,0); + toggle->border = 0.0f; + toggle->spacing = 4; + + /* option toggle */ + toggle = &style->option; + nk_zero_struct(*toggle); + toggle->normal = nk_style_item_color(table[NK_COLOR_TOGGLE]); + toggle->hover = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]); + toggle->active = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]); + toggle->cursor_normal = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]); + toggle->cursor_hover = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]); + toggle->userdata = nk_handle_ptr(0); + toggle->text_background = table[NK_COLOR_WINDOW]; + toggle->text_normal = table[NK_COLOR_TEXT]; + toggle->text_hover = table[NK_COLOR_TEXT]; + toggle->text_active = table[NK_COLOR_TEXT]; + toggle->padding = nk_vec2(3.0f, 3.0f); + toggle->touch_padding = nk_vec2(0,0); + toggle->border_color = nk_rgba(0,0,0,0); + toggle->border = 0.0f; + toggle->spacing = 4; + + /* selectable */ + select = &style->selectable; + nk_zero_struct(*select); + select->normal = nk_style_item_color(table[NK_COLOR_SELECT]); + select->hover = nk_style_item_color(table[NK_COLOR_SELECT]); + select->pressed = nk_style_item_color(table[NK_COLOR_SELECT]); + select->normal_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]); + select->hover_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]); + select->pressed_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]); + select->text_normal = table[NK_COLOR_TEXT]; + select->text_hover = table[NK_COLOR_TEXT]; + select->text_pressed = table[NK_COLOR_TEXT]; + select->text_normal_active = table[NK_COLOR_TEXT]; + select->text_hover_active = table[NK_COLOR_TEXT]; + select->text_pressed_active = table[NK_COLOR_TEXT]; + select->padding = nk_vec2(2.0f,2.0f); + select->image_padding = nk_vec2(2.0f,2.0f); + select->touch_padding = nk_vec2(0,0); + select->userdata = nk_handle_ptr(0); + select->rounding = 0.0f; + select->draw_begin = 0; + select->draw_end = 0; + + /* slider */ + slider = &style->slider; + nk_zero_struct(*slider); + slider->normal = nk_style_item_hide(); + slider->hover = nk_style_item_hide(); + slider->active = nk_style_item_hide(); + slider->bar_normal = table[NK_COLOR_SLIDER]; + slider->bar_hover = table[NK_COLOR_SLIDER]; + slider->bar_active = table[NK_COLOR_SLIDER]; + slider->bar_filled = table[NK_COLOR_SLIDER_CURSOR]; + slider->cursor_normal = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR]); + slider->cursor_hover = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_HOVER]); + slider->cursor_active = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_ACTIVE]); + slider->inc_symbol = NK_SYMBOL_TRIANGLE_RIGHT; + slider->dec_symbol = NK_SYMBOL_TRIANGLE_LEFT; + slider->cursor_size = nk_vec2(16,16); + slider->padding = nk_vec2(2,2); + slider->spacing = nk_vec2(2,2); + slider->userdata = nk_handle_ptr(0); + slider->show_buttons = nk_false; + slider->bar_height = 8; + slider->rounding = 0; + slider->draw_begin = 0; + slider->draw_end = 0; + + /* slider buttons */ + button = &style->slider.inc_button; + button->normal = nk_style_item_color(nk_rgb(40,40,40)); + button->hover = nk_style_item_color(nk_rgb(42,42,42)); + button->active = nk_style_item_color(nk_rgb(44,44,44)); + button->border_color = nk_rgb(65,65,65); + button->text_background = nk_rgb(40,40,40); + button->text_normal = nk_rgb(175,175,175); + button->text_hover = nk_rgb(175,175,175); + button->text_active = nk_rgb(175,175,175); + button->padding = nk_vec2(8.0f,8.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 1.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + style->slider.dec_button = style->slider.inc_button; + + /* progressbar */ + prog = &style->progress; + nk_zero_struct(*prog); + prog->normal = nk_style_item_color(table[NK_COLOR_SLIDER]); + prog->hover = nk_style_item_color(table[NK_COLOR_SLIDER]); + prog->active = nk_style_item_color(table[NK_COLOR_SLIDER]); + prog->cursor_normal = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR]); + prog->cursor_hover = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_HOVER]); + prog->cursor_active = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_ACTIVE]); + prog->border_color = nk_rgba(0,0,0,0); + prog->cursor_border_color = nk_rgba(0,0,0,0); + prog->userdata = nk_handle_ptr(0); + prog->padding = nk_vec2(4,4); + prog->rounding = 0; + prog->border = 0; + prog->cursor_rounding = 0; + prog->cursor_border = 0; + prog->draw_begin = 0; + prog->draw_end = 0; + + /* scrollbars */ + scroll = &style->scrollh; + nk_zero_struct(*scroll); + scroll->normal = nk_style_item_color(table[NK_COLOR_SCROLLBAR]); + scroll->hover = nk_style_item_color(table[NK_COLOR_SCROLLBAR]); + scroll->active = nk_style_item_color(table[NK_COLOR_SCROLLBAR]); + scroll->cursor_normal = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR]); + scroll->cursor_hover = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR_HOVER]); + scroll->cursor_active = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR_ACTIVE]); + scroll->dec_symbol = NK_SYMBOL_CIRCLE_SOLID; + scroll->inc_symbol = NK_SYMBOL_CIRCLE_SOLID; + scroll->userdata = nk_handle_ptr(0); + scroll->border_color = table[NK_COLOR_SCROLLBAR]; + scroll->cursor_border_color = table[NK_COLOR_SCROLLBAR]; + scroll->padding = nk_vec2(0,0); + scroll->show_buttons = nk_false; + scroll->border = 0; + scroll->rounding = 0; + scroll->border_cursor = 0; + scroll->rounding_cursor = 0; + scroll->draw_begin = 0; + scroll->draw_end = 0; + style->scrollv = style->scrollh; + + /* scrollbars buttons */ + button = &style->scrollh.inc_button; + button->normal = nk_style_item_color(nk_rgb(40,40,40)); + button->hover = nk_style_item_color(nk_rgb(42,42,42)); + button->active = nk_style_item_color(nk_rgb(44,44,44)); + button->border_color = nk_rgb(65,65,65); + button->text_background = nk_rgb(40,40,40); + button->text_normal = nk_rgb(175,175,175); + button->text_hover = nk_rgb(175,175,175); + button->text_active = nk_rgb(175,175,175); + button->padding = nk_vec2(4.0f,4.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 1.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + style->scrollh.dec_button = style->scrollh.inc_button; + style->scrollv.inc_button = style->scrollh.inc_button; + style->scrollv.dec_button = style->scrollh.inc_button; + + /* edit */ + edit = &style->edit; + nk_zero_struct(*edit); + edit->normal = nk_style_item_color(table[NK_COLOR_EDIT]); + edit->hover = nk_style_item_color(table[NK_COLOR_EDIT]); + edit->active = nk_style_item_color(table[NK_COLOR_EDIT]); + edit->cursor_normal = table[NK_COLOR_TEXT]; + edit->cursor_hover = table[NK_COLOR_TEXT]; + edit->cursor_text_normal= table[NK_COLOR_EDIT]; + edit->cursor_text_hover = table[NK_COLOR_EDIT]; + edit->border_color = table[NK_COLOR_BORDER]; + edit->text_normal = table[NK_COLOR_TEXT]; + edit->text_hover = table[NK_COLOR_TEXT]; + edit->text_active = table[NK_COLOR_TEXT]; + edit->selected_normal = table[NK_COLOR_TEXT]; + edit->selected_hover = table[NK_COLOR_TEXT]; + edit->selected_text_normal = table[NK_COLOR_EDIT]; + edit->selected_text_hover = table[NK_COLOR_EDIT]; + edit->scrollbar_size = nk_vec2(10,10); + edit->scrollbar = style->scrollv; + edit->padding = nk_vec2(4,4); + edit->row_padding = 2; + edit->cursor_size = 4; + edit->border = 1; + edit->rounding = 0; + + /* property */ + property = &style->property; + nk_zero_struct(*property); + property->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]); + property->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]); + property->active = nk_style_item_color(table[NK_COLOR_PROPERTY]); + property->border_color = table[NK_COLOR_BORDER]; + property->label_normal = table[NK_COLOR_TEXT]; + property->label_hover = table[NK_COLOR_TEXT]; + property->label_active = table[NK_COLOR_TEXT]; + property->sym_left = NK_SYMBOL_TRIANGLE_LEFT; + property->sym_right = NK_SYMBOL_TRIANGLE_RIGHT; + property->userdata = nk_handle_ptr(0); + property->padding = nk_vec2(4,4); + property->border = 1; + property->rounding = 10; + property->draw_begin = 0; + property->draw_end = 0; + + /* property buttons */ + button = &style->property.dec_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]); + button->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]); + button->active = nk_style_item_color(table[NK_COLOR_PROPERTY]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_PROPERTY]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(0.0f,0.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + style->property.inc_button = style->property.dec_button; + + /* property edit */ + edit = &style->property.edit; + nk_zero_struct(*edit); + edit->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]); + edit->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]); + edit->active = nk_style_item_color(table[NK_COLOR_PROPERTY]); + edit->border_color = nk_rgba(0,0,0,0); + edit->cursor_normal = table[NK_COLOR_TEXT]; + edit->cursor_hover = table[NK_COLOR_TEXT]; + edit->cursor_text_normal= table[NK_COLOR_EDIT]; + edit->cursor_text_hover = table[NK_COLOR_EDIT]; + edit->text_normal = table[NK_COLOR_TEXT]; + edit->text_hover = table[NK_COLOR_TEXT]; + edit->text_active = table[NK_COLOR_TEXT]; + edit->selected_normal = table[NK_COLOR_TEXT]; + edit->selected_hover = table[NK_COLOR_TEXT]; + edit->selected_text_normal = table[NK_COLOR_EDIT]; + edit->selected_text_hover = table[NK_COLOR_EDIT]; + edit->padding = nk_vec2(0,0); + edit->cursor_size = 8; + edit->border = 0; + edit->rounding = 0; + + /* chart */ + chart = &style->chart; + nk_zero_struct(*chart); + chart->background = nk_style_item_color(table[NK_COLOR_CHART]); + chart->border_color = table[NK_COLOR_BORDER]; + chart->selected_color = table[NK_COLOR_CHART_COLOR_HIGHLIGHT]; + chart->color = table[NK_COLOR_CHART_COLOR]; + chart->padding = nk_vec2(4,4); + chart->border = 0; + chart->rounding = 0; + + /* combo */ + combo = &style->combo; + combo->normal = nk_style_item_color(table[NK_COLOR_COMBO]); + combo->hover = nk_style_item_color(table[NK_COLOR_COMBO]); + combo->active = nk_style_item_color(table[NK_COLOR_COMBO]); + combo->border_color = table[NK_COLOR_BORDER]; + combo->label_normal = table[NK_COLOR_TEXT]; + combo->label_hover = table[NK_COLOR_TEXT]; + combo->label_active = table[NK_COLOR_TEXT]; + combo->sym_normal = NK_SYMBOL_TRIANGLE_DOWN; + combo->sym_hover = NK_SYMBOL_TRIANGLE_DOWN; + combo->sym_active = NK_SYMBOL_TRIANGLE_DOWN; + combo->content_padding = nk_vec2(4,4); + combo->button_padding = nk_vec2(0,4); + combo->spacing = nk_vec2(4,0); + combo->border = 1; + combo->rounding = 0; + + /* combo button */ + button = &style->combo.button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_COMBO]); + button->hover = nk_style_item_color(table[NK_COLOR_COMBO]); + button->active = nk_style_item_color(table[NK_COLOR_COMBO]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_COMBO]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* tab */ + tab = &style->tab; + tab->background = nk_style_item_color(table[NK_COLOR_TAB_HEADER]); + tab->border_color = table[NK_COLOR_BORDER]; + tab->text = table[NK_COLOR_TEXT]; + tab->sym_minimize = NK_SYMBOL_TRIANGLE_RIGHT; + tab->sym_maximize = NK_SYMBOL_TRIANGLE_DOWN; + tab->padding = nk_vec2(4,4); + tab->spacing = nk_vec2(4,4); + tab->indent = 10.0f; + tab->border = 1; + tab->rounding = 0; + + /* tab button */ + button = &style->tab.tab_minimize_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_TAB_HEADER]); + button->hover = nk_style_item_color(table[NK_COLOR_TAB_HEADER]); + button->active = nk_style_item_color(table[NK_COLOR_TAB_HEADER]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_TAB_HEADER]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + style->tab.tab_maximize_button =*button; + + /* node button */ + button = &style->tab.node_minimize_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->hover = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->active = nk_style_item_color(table[NK_COLOR_WINDOW]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_TAB_HEADER]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(2.0f,2.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + style->tab.node_maximize_button =*button; + + /* window header */ + win = &style->window; + win->header.align = NK_HEADER_RIGHT; + win->header.close_symbol = NK_SYMBOL_X; + win->header.minimize_symbol = NK_SYMBOL_MINUS; + win->header.maximize_symbol = NK_SYMBOL_PLUS; + win->header.normal = nk_style_item_color(table[NK_COLOR_HEADER]); + win->header.hover = nk_style_item_color(table[NK_COLOR_HEADER]); + win->header.active = nk_style_item_color(table[NK_COLOR_HEADER]); + win->header.label_normal = table[NK_COLOR_TEXT]; + win->header.label_hover = table[NK_COLOR_TEXT]; + win->header.label_active = table[NK_COLOR_TEXT]; + win->header.label_padding = nk_vec2(4,4); + win->header.padding = nk_vec2(4,4); + win->header.spacing = nk_vec2(0,0); + + /* window header close button */ + button = &style->window.header.close_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_HEADER]); + button->hover = nk_style_item_color(table[NK_COLOR_HEADER]); + button->active = nk_style_item_color(table[NK_COLOR_HEADER]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_HEADER]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(0.0f,0.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* window header minimize button */ + button = &style->window.header.minimize_button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(table[NK_COLOR_HEADER]); + button->hover = nk_style_item_color(table[NK_COLOR_HEADER]); + button->active = nk_style_item_color(table[NK_COLOR_HEADER]); + button->border_color = nk_rgba(0,0,0,0); + button->text_background = table[NK_COLOR_HEADER]; + button->text_normal = table[NK_COLOR_TEXT]; + button->text_hover = table[NK_COLOR_TEXT]; + button->text_active = table[NK_COLOR_TEXT]; + button->padding = nk_vec2(0.0f,0.0f); + button->touch_padding = nk_vec2(0.0f,0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 0.0f; + button->rounding = 0.0f; + button->draw_begin = 0; + button->draw_end = 0; + + /* window */ + win->background = table[NK_COLOR_WINDOW]; + win->fixed_background = nk_style_item_color(table[NK_COLOR_WINDOW]); + win->border_color = table[NK_COLOR_BORDER]; + win->popup_border_color = table[NK_COLOR_BORDER]; + win->combo_border_color = table[NK_COLOR_BORDER]; + win->contextual_border_color = table[NK_COLOR_BORDER]; + win->menu_border_color = table[NK_COLOR_BORDER]; + win->group_border_color = table[NK_COLOR_BORDER]; + win->tooltip_border_color = table[NK_COLOR_BORDER]; + win->scaler = nk_style_item_color(table[NK_COLOR_TEXT]); + + win->rounding = 0.0f; + win->spacing = nk_vec2(4,4); + win->scrollbar_size = nk_vec2(10,10); + win->min_size = nk_vec2(64,64); + + win->combo_border = 1; + win->contextual_border = 1; + win->menu_border = 1; + win->group_border = 1; + win->tooltip_border = 1; + win->popup_border = 1; + win->border = 2; + win->min_row_height_padding = 8; + + win->padding = nk_vec2(4,4); + win->group_padding = nk_vec2(4,4); + win->popup_padding = nk_vec2(4,4); + win->combo_padding = nk_vec2(4,4); + win->contextual_padding = nk_vec2(4,4); + win->menu_padding = nk_vec2(4,4); + win->tooltip_padding = nk_vec2(4,4); +} +NK_API void +nk_style_set_font(struct nk_context *ctx, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_set_font"); + struct nk_style *style; + // NK_ASSERT(ctx); + + if (!ctx) return; + style = &ctx->style; + style->font = font; + ctx->stacks.fonts.head = 0; + if (ctx->current) + nk_layout_reset_min_row_height(ctx); +} +NK_API nk_bool +nk_style_push_font(struct nk_context *ctx, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_push_font"); + struct nk_config_stack_user_font *font_stack; + struct nk_config_stack_user_font_element *element; + + // NK_ASSERT(ctx); + if (!ctx) return 0; + + font_stack = &ctx->stacks.fonts; + // NK_ASSERT(font_stack->head < (int)NK_LEN(font_stack->elements)); + if (font_stack->head >= (int)NK_LEN(font_stack->elements)) + return 0; + + element = &font_stack->elements[font_stack->head++]; + element->address = &ctx->style.font; + element->old_value = ctx->style.font; + ctx->style.font = font; + return 1; +} +NK_API nk_bool +nk_style_pop_font(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_pop_font"); + struct nk_config_stack_user_font *font_stack; + struct nk_config_stack_user_font_element *element; + + // NK_ASSERT(ctx); + if (!ctx) return 0; + + font_stack = &ctx->stacks.fonts; + // NK_ASSERT(font_stack->head > 0); + if (font_stack->head < 1) + return 0; + + element = &font_stack->elements[--font_stack->head]; + *element->address = element->old_value; + return 1; +} +// #define NK_STYLE_PUSH_IMPLEMENATION(prefix, type, stack) \ +// nk_style_push_##type(struct nk_context *ctx, prefix##_##type *address, prefix##_##type value)\ +// {\ +// struct nk_config_stack_##type * type_stack;\ +// struct nk_config_stack_##type##_element *element;\ +// NK_ASSERT(ctx);\ +// if (!ctx) return 0;\ +// type_stack = &ctx->stacks.stack;\ +// NK_ASSERT(type_stack->head < (int)NK_LEN(type_stack->elements));\ +// if (type_stack->head >= (int)NK_LEN(type_stack->elements))\ +// return 0;\ +// element = &type_stack->elements[type_stack->head++];\ +// element->address = address;\ +// element->old_value = *address;\ +// *address = value;\ +// return 1;\ +// } +// #define NK_STYLE_POP_IMPLEMENATION(type, stack) \ +// nk_style_pop_##type(struct nk_context *ctx)\ +// {\ +// struct nk_config_stack_##type *type_stack;\ +// struct nk_config_stack_##type##_element *element;\ +// NK_ASSERT(ctx);\ +// if (!ctx) return 0;\ +// type_stack = &ctx->stacks.stack;\ +// NK_ASSERT(type_stack->head > 0);\ +// if (type_stack->head < 1)\ +// return 0;\ +// element = &type_stack->elements[--type_stack->head];\ +// *element->address = element->old_value;\ +// return 1;\ +// } +// NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, style_item, style_items) +// NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,int, ints) +// NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, vec2, vectors) +// NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,flags, flags) +// NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk,color, colors) + +// NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(style_item, style_items) +// NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(int,ints) +// NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(vec2, vectors) +// NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(flags,flags) +// NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(color,colors) + +NK_API nk_bool +nk_style_set_cursor(struct nk_context *ctx, enum nk_style_cursor c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_set_cursor"); + struct nk_style *style; + // NK_ASSERT(ctx); + if (!ctx) return 0; + style = &ctx->style; + if (style->cursors[c]) { + style->cursor_active = style->cursors[c]; + return 1; + } + return 0; +} +NK_API void +nk_style_show_cursor(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_show_cursor"); + ctx->style.cursor_visible = nk_true; +} +NK_API void +nk_style_hide_cursor(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_hide_cursor"); + ctx->style.cursor_visible = nk_false; +} +NK_API void +nk_style_load_cursor(struct nk_context *ctx, enum nk_style_cursor cursor, + const struct nk_cursor *c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_cursor / const"); + struct nk_style *style; + // NK_ASSERT(ctx); + if (!ctx) return; + style = &ctx->style; + style->cursors[cursor] = c; +} +NK_API void +nk_style_load_all_cursors(struct nk_context *ctx, struct nk_cursor *cursors) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_style_load_all_cursors"); + int i = 0; + struct nk_style *style; + // NK_ASSERT(ctx); + if (!ctx) return; + style = &ctx->style; + for (i = 0; i < NK_CURSOR_COUNT; ++i) + style->cursors[i] = &cursors[i]; + style->cursor_visible = nk_true; +} + + + + + +/* ============================================================== + * + * CONTEXT + * + * ===============================================================*/ +NK_INTERN void +nk_setup(struct nk_context *ctx, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_setup"); + // NK_ASSERT(ctx); + if (!ctx) return; + nk_zero_struct(*ctx); + nk_style_default(ctx); + ctx->seq = 1; + if (font) ctx->style.font = font; +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT + nk_draw_list_init(&ctx->draw_list); +#endif +} +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API nk_bool +nk_init_default(struct nk_context *ctx, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_init_default"); + struct nk_allocator alloc; + alloc.userdata.ptr = 0; + alloc.alloc = nk_malloc; + alloc.free = nk_mfree; + return nk_init(ctx, &alloc, font); +} +#endif +NK_API nk_bool +nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + // NK_ASSERT(memory); + if (!memory) return 0; + nk_setup(ctx, font); + nk_buffer_init_fixed(&ctx->memory, memory, size); + ctx->use_pool = nk_false; + return 1; +} +NK_API nk_bool +nk_init_custom(struct nk_context *ctx, struct nk_buffer *cmds, + struct nk_buffer *pool, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - pool / struct"); + // NK_ASSERT(cmds); + // NK_ASSERT(pool); + if (!cmds || !pool) return 0; + + nk_setup(ctx, font); + ctx->memory = *cmds; + if (pool->type == NK_BUFFER_FIXED) { + /* take memory from buffer and alloc fixed pool */ + nk_pool_init_fixed(&ctx->pool, pool->memory.ptr, pool->memory.size); + } else { + /* create dynamic pool from buffer allocator */ + struct nk_allocator *alloc = &pool->pool; + nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY); + } + ctx->use_pool = nk_true; + return 1; +} +NK_API nk_bool +nk_init(struct nk_context *ctx, struct nk_allocator *alloc, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + // NK_ASSERT(alloc); + if (!alloc) return 0; + nk_setup(ctx, font); + nk_buffer_init(&ctx->memory, alloc, NK_DEFAULT_COMMAND_BUFFER_SIZE); + nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY); + ctx->use_pool = nk_true; + return 1; +} +#ifdef NK_INCLUDE_COMMAND_USERDATA +NK_API void +nk_set_user_data(struct nk_context *ctx, nk_handle handle) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_set_user_data"); + if (!ctx) return; + ctx->userdata = handle; + if (ctx->current) + ctx->current->buffer.userdata = handle; +} +#endif +NK_API void +nk_free(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_free"); + // NK_ASSERT(ctx); + if (!ctx) return; + nk_buffer_free(&ctx->memory); + if (ctx->use_pool) + nk_pool_free(&ctx->pool); + + nk_zero(&ctx->input, sizeof(ctx->input)); + nk_zero(&ctx->style, sizeof(ctx->style)); + nk_zero(&ctx->memory, sizeof(ctx->memory)); + + ctx->seq = 0; + ctx->build = 0; + ctx->begin = 0; + ctx->end = 0; + ctx->active = 0; + ctx->current = 0; + ctx->freelist = 0; + ctx->count = 0; +} +NK_API void +nk_clear(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_clear"); + struct nk_window *iter; + struct nk_window *next; + // NK_ASSERT(ctx); + + if (!ctx) return; + if (ctx->use_pool) + nk_buffer_clear(&ctx->memory); + else nk_buffer_reset(&ctx->memory, NK_BUFFER_FRONT); + + ctx->build = 0; + ctx->memory.calls = 0; + ctx->last_widget_state = 0; + ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_ARROW]; + NK_MEMSET(&ctx->overlay, 0, sizeof(ctx->overlay)); + + /* garbage collector */ + iter = ctx->begin; + while (iter) { + /* make sure valid minimized windows do not get removed */ + if ((iter->flags & NK_WINDOW_MINIMIZED) && !(iter->flags & NK_WINDOW_CLOSED) && iter->seq == ctx->seq) { + iter = iter->next; + continue; + } + /* remove hotness from hidden or closed windows*/ + if (((iter->flags & NK_WINDOW_HIDDEN) || + (iter->flags & NK_WINDOW_CLOSED)) && iter == ctx->active) { + ctx->active = iter->prev; + ctx->end = iter->prev; + if (!ctx->end) + ctx->begin = 0; + if (ctx->active) + ctx->active->flags &= ~(unsigned)NK_WINDOW_ROM; + } + /* free unused popup windows */ + if (iter->popup.win && iter->popup.win->seq != ctx->seq) { + nk_free_window(ctx, iter->popup.win); + iter->popup.win = 0; + } + /* remove unused window state tables */ + {struct nk_table *n, *it = iter->tables; + while (it) { + n = it->next; + if (it->seq != ctx->seq) { + nk_remove_table(iter, it); + nk_zero(it, sizeof(union nk_page_data)); + nk_free_table(ctx, it); + if (it == iter->tables) + iter->tables = n; + } it = n; + }} + /* window itself is not used anymore so free */ + if (iter->seq != ctx->seq || iter->flags & NK_WINDOW_CLOSED) { + next = iter->next; + nk_remove_window(ctx, iter); + nk_free_window(ctx, iter); + iter = next; + } else iter = iter->next; + } + ctx->seq++; +} +NK_LIB void +nk_start_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_start_buffer"); + // NK_ASSERT(ctx); + // NK_ASSERT(buffer); + if (!ctx || !buffer) return; + buffer->begin = ctx->memory.allocated; + buffer->end = buffer->begin; + buffer->last = buffer->begin; + buffer->clip = nk_null_rect; +} +NK_LIB void +nk_start(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_start"); + // NK_ASSERT(ctx); + // NK_ASSERT(win); + nk_start_buffer(ctx, &win->buffer); +} +NK_LIB void +nk_start_popup(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_start_popup"); + struct nk_popup_buffer *buf; + // NK_ASSERT(ctx); + // NK_ASSERT(win); + if (!ctx || !win) return; + + /* save buffer fill state for popup */ + buf = &win->popup.buf; + buf->begin = win->buffer.end; + buf->end = win->buffer.end; + buf->parent = win->buffer.last; + buf->last = buf->begin; + buf->active = nk_true; +} +NK_LIB void +nk_finish_popup(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_finish_popup"); + struct nk_popup_buffer *buf; + // NK_ASSERT(ctx); + // NK_ASSERT(win); + if (!ctx || !win) return; + + buf = &win->popup.buf; + buf->last = win->buffer.last; + buf->end = win->buffer.end; +} +NK_LIB void +nk_finish_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_finish_buffer"); + // NK_ASSERT(ctx); + // NK_ASSERT(buffer); + if (!ctx || !buffer) return; + buffer->end = ctx->memory.allocated; +} +NK_LIB void +nk_finish(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_finish"); + struct nk_popup_buffer *buf; + struct nk_command *parent_last; + void *memory; + + // NK_ASSERT(ctx); + // NK_ASSERT(win); + if (!ctx || !win) return; + nk_finish_buffer(ctx, &win->buffer); + if (!win->popup.buf.active) return; + + buf = &win->popup.buf; + memory = ctx->memory.memory.ptr; + parent_last = nk_ptr_add(struct nk_command, memory, buf->parent); + parent_last->next = buf->end; +} +NK_LIB void +nk_build(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_build"); + struct nk_window *it = 0; + struct nk_command *cmd = 0; + nk_byte *buffer = 0; + + /* draw cursor overlay */ + if (!ctx->style.cursor_active) + ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_ARROW]; + if (ctx->style.cursor_active && !ctx->input.mouse.grabbed && ctx->style.cursor_visible) { + struct nk_rect mouse_bounds; + const struct nk_cursor *cursor = ctx->style.cursor_active; + nk_command_buffer_init(&ctx->overlay, &ctx->memory, NK_CLIPPING_OFF); + nk_start_buffer(ctx, &ctx->overlay); + + mouse_bounds.x = ctx->input.mouse.pos.x - cursor->offset.x; + mouse_bounds.y = ctx->input.mouse.pos.y - cursor->offset.y; + mouse_bounds.w = cursor->size.x; + mouse_bounds.h = cursor->size.y; + + nk_draw_image(&ctx->overlay, mouse_bounds, &cursor->img, nk_white); + nk_finish_buffer(ctx, &ctx->overlay); + } + /* build one big draw command list out of all window buffers */ + it = ctx->begin; + buffer = (nk_byte*)ctx->memory.memory.ptr; + while (it != 0) { + struct nk_window *next = it->next; + if (it->buffer.last == it->buffer.begin || (it->flags & NK_WINDOW_HIDDEN)|| + it->seq != ctx->seq) + goto cont; + + cmd = nk_ptr_add(struct nk_command, buffer, it->buffer.last); + while (next && ((next->buffer.last == next->buffer.begin) || + (next->flags & NK_WINDOW_HIDDEN) || next->seq != ctx->seq)) + next = next->next; /* skip empty command buffers */ + + if (next) cmd->next = next->buffer.begin; + cont: it = next; + } + /* append all popup draw commands into lists */ + it = ctx->begin; + while (it != 0) { + struct nk_window *next = it->next; + struct nk_popup_buffer *buf; + if (!it->popup.buf.active) + goto skip; + + buf = &it->popup.buf; + cmd->next = buf->begin; + cmd = nk_ptr_add(struct nk_command, buffer, buf->last); + buf->active = nk_false; + skip: it = next; + } + if (cmd) { + /* append overlay commands */ + if (ctx->overlay.end != ctx->overlay.begin) + cmd->next = ctx->overlay.begin; + else cmd->next = ctx->memory.allocated; + } +} +NK_API const struct nk_command* +nk__begin(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk__begin"); + struct nk_window *iter; + nk_byte *buffer; + // NK_ASSERT(ctx); + if (!ctx) return 0; + if (!ctx->count) return 0; + + buffer = (nk_byte*)ctx->memory.memory.ptr; + if (!ctx->build) { + nk_build(ctx); + ctx->build = nk_true; + } + iter = ctx->begin; + while (iter && ((iter->buffer.begin == iter->buffer.end) || + (iter->flags & NK_WINDOW_HIDDEN) || iter->seq != ctx->seq)) + iter = iter->next; + if (!iter) return 0; + return nk_ptr_add_const(struct nk_command, buffer, iter->buffer.begin); +} + +NK_API const struct nk_command* +nk__next(struct nk_context *ctx, const struct nk_command *cmd) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk__next"); + nk_byte *buffer; + const struct nk_command *next; + // NK_ASSERT(ctx); + if (!ctx || !cmd || !ctx->count) return 0; + if (cmd->next >= ctx->memory.allocated) return 0; + buffer = (nk_byte*)ctx->memory.memory.ptr; + next = nk_ptr_add_const(struct nk_command, buffer, cmd->next); + return next; +} + + + + + + +/* =============================================================== + * + * POOL + * + * ===============================================================*/ +NK_LIB void +nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc, + unsigned int capacity) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - capacity / unsigned"); + // NK_ASSERT(capacity >= 1); + nk_zero(pool, sizeof(*pool)); + pool->alloc = *alloc; + pool->capacity = capacity; + pool->type = NK_BUFFER_DYNAMIC; + pool->pages = 0; +} +NK_LIB void +nk_pool_free(struct nk_pool *pool) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_pool / nk_pool_free"); + struct nk_page *iter; + if (!pool) return; + iter = pool->pages; + if (pool->type == NK_BUFFER_FIXED) return; + while (iter) { + struct nk_page *next = iter->next; + pool->alloc.free(pool->alloc.userdata, iter); + iter = next; + } +} +NK_LIB void +nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_pool / nk_pool_init_fixed"); + nk_zero(pool, sizeof(*pool)); + // NK_ASSERT(size >= sizeof(struct nk_page)); + if (size < sizeof(struct nk_page)) return; + /* first nk_page_element is embedded in nk_page, additional elements follow in adjacent space */ + pool->capacity = 1 + (unsigned)(size - sizeof(struct nk_page)) / sizeof(struct nk_page_element); + pool->pages = (struct nk_page*)memory; + pool->type = NK_BUFFER_FIXED; + pool->size = size; +} +NK_LIB struct nk_page_element* +nk_pool_alloc(struct nk_pool *pool) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_pool / nk_pool_alloc"); + if (!pool->pages || pool->pages->size >= pool->capacity) { + /* allocate new page */ + struct nk_page *page; + if (pool->type == NK_BUFFER_FIXED) { + // NK_ASSERT(pool->pages); + if (!pool->pages) return 0; + // NK_ASSERT(pool->pages->size < pool->capacity); + return 0; + } else { + nk_size size = sizeof(struct nk_page); + size += (pool->capacity - 1) * sizeof(struct nk_page_element); + page = (struct nk_page*)pool->alloc.alloc(pool->alloc.userdata,0, size); + page->next = pool->pages; + pool->pages = page; + page->size = 0; + } + } return &pool->pages->win[pool->pages->size++]; +} + + + + + +/* =============================================================== + * + * PAGE ELEMENT + * + * ===============================================================*/ +NK_LIB struct nk_page_element* +nk_create_page_element(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_create_page_element"); + struct nk_page_element *elem; + if (ctx->freelist) { + /* unlink page element from free list */ + elem = ctx->freelist; + ctx->freelist = elem->next; + } else if (ctx->use_pool) { + /* allocate page element from memory pool */ + elem = nk_pool_alloc(&ctx->pool); + // NK_ASSERT(elem); + if (!elem) return 0; + } else { + /* allocate new page element from back of fixed size memory buffer */ + NK_STORAGE const nk_size size = sizeof(struct nk_page_element); + NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_page_element); + elem = (struct nk_page_element*)nk_buffer_alloc(&ctx->memory, NK_BUFFER_BACK, size, align); + // NK_ASSERT(elem); + if (!elem) return 0; + } + nk_zero_struct(*elem); + elem->next = 0; + elem->prev = 0; + return elem; +} +NK_LIB void +nk_link_page_element_into_freelist(struct nk_context *ctx, + struct nk_page_element *elem) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - elem / struct"); + /* link table into freelist */ + if (!ctx->freelist) { + ctx->freelist = elem; + } else { + elem->next = ctx->freelist; + ctx->freelist = elem; + } +} +NK_LIB void +nk_free_page_element(struct nk_context *ctx, struct nk_page_element *elem) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_free_page_element"); + /* we have a pool so just add to free list */ + if (ctx->use_pool) { + nk_link_page_element_into_freelist(ctx, elem); + return; + } + /* if possible remove last element from back of fixed memory buffer */ + {void *elem_end = (void*)(elem + 1); + void *buffer_end = (nk_byte*)ctx->memory.memory.ptr + ctx->memory.size; + if (elem_end == buffer_end) + ctx->memory.size -= sizeof(struct nk_page_element); + else nk_link_page_element_into_freelist(ctx, elem);} +} + + + + + +/* =============================================================== + * + * TABLE + * + * ===============================================================*/ +NK_LIB struct nk_table* +nk_create_table(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_create_table"); + struct nk_page_element *elem; + elem = nk_create_page_element(ctx); + if (!elem) return 0; + nk_zero_struct(*elem); + return &elem->data.tbl; +} +NK_LIB void +nk_free_table(struct nk_context *ctx, struct nk_table *tbl) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_free_table"); + union nk_page_data *pd = NK_CONTAINER_OF(tbl, union nk_page_data, tbl); + struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data); + nk_free_page_element(ctx, pe); +} +NK_LIB void +nk_push_table(struct nk_window *win, struct nk_table *tbl) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_window / nk_push_table"); + if (!win->tables) { + win->tables = tbl; + tbl->next = 0; + tbl->prev = 0; + tbl->size = 0; + win->table_count = 1; + return; + } + win->tables->prev = tbl; + tbl->next = win->tables; + tbl->prev = 0; + tbl->size = 0; + win->tables = tbl; + win->table_count++; +} +NK_LIB void +nk_remove_table(struct nk_window *win, struct nk_table *tbl) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_window / nk_remove_table"); + if (win->tables == tbl) + win->tables = tbl->next; + if (tbl->next) + tbl->next->prev = tbl->prev; + if (tbl->prev) + tbl->prev->next = tbl->next; + tbl->next = 0; + tbl->prev = 0; +} +NK_LIB nk_uint* +nk_add_value(struct nk_context *ctx, struct nk_window *win, + nk_hash name, nk_uint value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - name, / nk_hash"); + // NK_ASSERT(ctx); + // NK_ASSERT(win); + if (!win || !ctx) return 0; + if (!win->tables || win->tables->size >= NK_VALUE_PAGE_CAPACITY) { + struct nk_table *tbl = nk_create_table(ctx); + // NK_ASSERT(tbl); + if (!tbl) return 0; + nk_push_table(win, tbl); + } + win->tables->seq = win->seq; + win->tables->keys[win->tables->size] = name; + win->tables->values[win->tables->size] = value; + return &win->tables->values[win->tables->size++]; +} +NK_LIB nk_uint* +nk_find_value(struct nk_window *win, nk_hash name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_window / nk_find_value"); + struct nk_table *iter = win->tables; + while (iter) { + unsigned int i = 0; + unsigned int size = iter->size; + for (i = 0; i < size; ++i) { + if (iter->keys[i] == name) { + iter->seq = win->seq; + return &iter->values[i]; + } + } size = NK_VALUE_PAGE_CAPACITY; + iter = iter->next; + } + return 0; +} + + + + + +/* =============================================================== + * + * PANEL + * + * ===============================================================*/ +NK_LIB void* +nk_create_panel(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_create_panel"); + struct nk_page_element *elem; + elem = nk_create_page_element(ctx); + if (!elem) return 0; + nk_zero_struct(*elem); + return &elem->data.pan; +} +NK_LIB void +nk_free_panel(struct nk_context *ctx, struct nk_panel *pan) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_free_panel"); + union nk_page_data *pd = NK_CONTAINER_OF(pan, union nk_page_data, pan); + struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data); + nk_free_page_element(ctx, pe); +} +NK_LIB nk_bool +nk_panel_has_header(nk_flags flags, const char *title) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - flags / nk_panel_has_header"); + nk_bool active = 0; + active = (flags & (NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE)); + active = active || (flags & NK_WINDOW_TITLE); + active = active && !(flags & NK_WINDOW_HIDDEN) && title; + return active; +} +NK_LIB struct nk_vec2 +nk_panel_get_padding(const struct nk_style *style, enum nk_panel_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_panel_get_padding"); + switch (type) { + default: + case NK_PANEL_WINDOW: return style->window.padding; + case NK_PANEL_GROUP: return style->window.group_padding; + case NK_PANEL_POPUP: return style->window.popup_padding; + case NK_PANEL_CONTEXTUAL: return style->window.contextual_padding; + case NK_PANEL_COMBO: return style->window.combo_padding; + case NK_PANEL_MENU: return style->window.menu_padding; + case NK_PANEL_TOOLTIP: return style->window.menu_padding;} +} +NK_LIB int +nk_panel_get_border(const struct nk_style *style, nk_flags flags, + enum nk_panel_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_panel_get_border"); + if (flags & NK_WINDOW_BORDER) { + switch (type) { + default: + case NK_PANEL_WINDOW: return style->window.border; + case NK_PANEL_GROUP: return style->window.group_border; + case NK_PANEL_POPUP: return style->window.popup_border; + case NK_PANEL_CONTEXTUAL: return style->window.contextual_border; + case NK_PANEL_COMBO: return style->window.combo_border; + case NK_PANEL_MENU: return style->window.menu_border; + case NK_PANEL_TOOLTIP: return style->window.menu_border; + }} else return 0; +} +NK_LIB struct nk_color +nk_panel_get_border_color(const struct nk_style *style, enum nk_panel_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_panel_get_border_color"); + switch (type) { + default: + case NK_PANEL_WINDOW: return style->window.border_color; + case NK_PANEL_GROUP: return style->window.group_border_color; + case NK_PANEL_POPUP: return style->window.popup_border_color; + case NK_PANEL_CONTEXTUAL: return style->window.contextual_border_color; + case NK_PANEL_COMBO: return style->window.combo_border_color; + case NK_PANEL_MENU: return style->window.menu_border_color; + case NK_PANEL_TOOLTIP: return style->window.menu_border_color;} +} +NK_LIB nk_bool +nk_panel_is_sub(enum nk_panel_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_panel_type / nk_panel_is_sub"); + return (type & NK_PANEL_SET_SUB)?1:0; +} +NK_LIB nk_bool +nk_panel_is_nonblock(enum nk_panel_type type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_panel_type / nk_panel_is_nonblock"); + return (type & NK_PANEL_SET_NONBLOCK)?1:0; +} +NK_LIB nk_bool +nk_panel_begin(struct nk_context *ctx, const char *title, enum nk_panel_type panel_type) +{ + + + long start; + long end; + long total; + long eventTime0; + + start = TickCount(); + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_panel_begin"); + struct nk_input *in; + struct nk_window *win; + struct nk_panel *layout; + struct nk_command_buffer *out; + const struct nk_style *style; + const struct nk_user_font *font; + + struct nk_vec2 scrollbar_size; + struct nk_vec2 panel_padding; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return 0; + nk_zero(ctx->current->layout, sizeof(*ctx->current->layout)); + if ((ctx->current->flags & NK_WINDOW_HIDDEN) || (ctx->current->flags & NK_WINDOW_CLOSED)) { + nk_zero(ctx->current->layout, sizeof(struct nk_panel)); + ctx->current->layout->type = panel_type; + return 0; + } + /* pull state into local stack */ + style = &ctx->style; + font = style->font; + win = ctx->current; + layout = win->layout; + out = &win->buffer; + in = (win->flags & NK_WINDOW_NO_INPUT) ? 0: &ctx->input; +#ifdef NK_INCLUDE_COMMAND_USERDATA + win->buffer.userdata = ctx->userdata; +#endif + /* pull style configuration into local stack */ + scrollbar_size = style->window.scrollbar_size; + panel_padding = nk_panel_get_padding(style, panel_type); + + /* window movement */ + if ((win->flags & NK_WINDOW_MOVABLE) && !(win->flags & NK_WINDOW_ROM)) { + int left_mouse_down; + int left_mouse_clicked; + int left_mouse_click_in_cursor; + + /* calculate draggable window space */ + struct nk_rect header; + header.x = win->bounds.x; + header.y = win->bounds.y; + header.w = win->bounds.w; + if (nk_panel_has_header(win->flags, title)) { + header.h = font->height + 2.0f * style->window.header.padding.y; + header.h += 2.0f * style->window.header.label_padding.y; + } else header.h = panel_padding.y; + + /* window movement by dragging */ + left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down; + left_mouse_clicked = (int)in->mouse.buttons[NK_BUTTON_LEFT].clicked; + left_mouse_click_in_cursor = nk_input_has_mouse_click_down_in_rect(in, + NK_BUTTON_LEFT, header, nk_true); + if (left_mouse_down && left_mouse_click_in_cursor && !left_mouse_clicked) { + win->bounds.x = win->bounds.x + in->mouse.delta.x; + win->bounds.y = win->bounds.y + in->mouse.delta.y; + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x += in->mouse.delta.x; + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y += in->mouse.delta.y; + ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_MOVE]; + } + } + + /* setup panel */ + layout->type = panel_type; + layout->flags = win->flags; + layout->bounds = win->bounds; + layout->bounds.x += panel_padding.x; + layout->bounds.w -= 2*panel_padding.x; + if (win->flags & NK_WINDOW_BORDER) { + layout->border = 1;//= nk_panel_get_border(style, win->flags, panel_type); + layout->bounds = nk_shrink_rect(layout->bounds, layout->border); + } else layout->border = 0; + layout->at_y = layout->bounds.y; + layout->at_x = layout->bounds.x; + layout->max_x = 0; + layout->header_height = 0; + layout->footer_height = 0; + nk_layout_reset_min_row_height(ctx); + layout->row.index = 0; + layout->row.columns = 0; + layout->row.ratio = 0; + layout->row.item_width = 0; + layout->row.tree_depth = 0; + layout->row.height = panel_padding.y; + layout->has_scrolling = nk_true; + if (!(win->flags & NK_WINDOW_NO_SCROLLBAR)) + layout->bounds.w -= scrollbar_size.x; + if (!nk_panel_is_nonblock(panel_type)) { + layout->footer_height = 0; + if (!(win->flags & NK_WINDOW_NO_SCROLLBAR) || win->flags & NK_WINDOW_SCALABLE) + layout->footer_height = scrollbar_size.y; + layout->bounds.h -= layout->footer_height; + } + + /* panel header */ + if (nk_panel_has_header(win->flags, title)) + { + struct nk_text text; + struct nk_rect header; + const struct nk_style_item *background = 0; + + /* calculate header bounds */ + header.x = win->bounds.x; + header.y = win->bounds.y; + header.w = win->bounds.w; + header.h = font->height + 2.0f * style->window.header.padding.y; + header.h += (2.0f * style->window.header.label_padding.y); + + /* shrink panel by header */ + layout->header_height = header.h; + layout->bounds.y += header.h; + layout->bounds.h -= header.h; + layout->at_y += header.h; + + /* select correct header background and text color */ + if (ctx->active == win) { + background = &style->window.header.active; + text.text = style->window.header.label_active; + } else if (nk_input_is_mouse_hovering_rect(&ctx->input, header)) { + background = &style->window.header.hover; + text.text = style->window.header.label_hover; + } else { + background = &style->window.header.normal; + text.text = style->window.header.label_normal; + } + + /* draw header background */ + header.h += 1.0f; + if (background->type == NK_STYLE_ITEM_IMAGE) { + text.background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + text.background = background->data.color; + nk_fill_rect(out, header, 0, background->data.color); + } + + /* window close button */ + {struct nk_rect button; + button.y = header.y + style->window.header.padding.y; + button.h = header.h - 2 * style->window.header.padding.y; + button.w = button.h; + if (win->flags & NK_WINDOW_CLOSABLE) { + nk_flags ws = 0; + if (style->window.header.align == NK_HEADER_RIGHT) { + button.x = (header.w + header.x) - (button.w + style->window.header.padding.x); + header.w -= button.w + style->window.header.spacing.x + style->window.header.padding.x; + } else { + button.x = header.x + style->window.header.padding.x; + header.x += button.w + style->window.header.spacing.x + style->window.header.padding.x; + } + + if (nk_do_button_symbol(&ws, &win->buffer, button, + style->window.header.close_symbol, NK_BUTTON_DEFAULT, + &style->window.header.close_button, in, style->font) && !(win->flags & NK_WINDOW_ROM)) + { + layout->flags |= NK_WINDOW_HIDDEN; + layout->flags &= (nk_flags)~NK_WINDOW_MINIMIZED; + } + } + + /* window minimize button */ + if (win->flags & NK_WINDOW_MINIMIZABLE) { + nk_flags ws = 0; + if (style->window.header.align == NK_HEADER_RIGHT) { + button.x = (header.w + header.x) - button.w; + if (!(win->flags & NK_WINDOW_CLOSABLE)) { + button.x -= style->window.header.padding.x; + header.w -= style->window.header.padding.x; + } + header.w -= button.w + style->window.header.spacing.x; + } else { + button.x = header.x; + header.x += button.w + style->window.header.spacing.x + style->window.header.padding.x; + } + if (nk_do_button_symbol(&ws, &win->buffer, button, (layout->flags & NK_WINDOW_MINIMIZED)? + style->window.header.maximize_symbol: style->window.header.minimize_symbol, + NK_BUTTON_DEFAULT, &style->window.header.minimize_button, in, style->font) && !(win->flags & NK_WINDOW_ROM)) + layout->flags = (layout->flags & NK_WINDOW_MINIMIZED) ? + layout->flags & (nk_flags)~NK_WINDOW_MINIMIZED: + layout->flags | NK_WINDOW_MINIMIZED; + }} + + {/* window header title */ + int text_len = strlen(title); + struct nk_rect label = {0,0,0,0}; + int t = font->width(font->userdata, font->height, title, text_len); + text.padding = nk_vec2(0,0); + + label.x = header.x + style->window.header.padding.x; + label.x += style->window.header.label_padding.x; + label.y = header.y + style->window.header.label_padding.y; + label.h = font->height + 2 * style->window.header.label_padding.y; + label.w = t + 2 * style->window.header.spacing.x; + label.w = NK_CLAMP(0, label.w, header.x + header.w - label.x); + nk_widget_text(out, label,(const char*)title, text_len, &text, NK_TEXT_LEFT, font);} + } + + /* draw window background */ + if (!(layout->flags & NK_WINDOW_MINIMIZED) && !(layout->flags & NK_WINDOW_DYNAMIC)) { + struct nk_rect body; + body.x = win->bounds.x; + body.w = win->bounds.w; + body.y = (win->bounds.y + layout->header_height); + body.h = (win->bounds.h - layout->header_height); + if (style->window.fixed_background.type == NK_STYLE_ITEM_IMAGE) + nk_draw_image(out, body, &style->window.fixed_background.data.image, nk_white); + else nk_fill_rect(out, body, 0, style->window.fixed_background.data.color); + } + + /* set clipping rectangle */ + {struct nk_rect clip; + layout->clip = layout->bounds; + nk_unify(&clip, &win->buffer.clip, layout->clip.x, layout->clip.y, + layout->clip.x + layout->clip.w, layout->clip.y + layout->clip.h); + // nk_push_scissor(out, clip); + layout->clip = clip;} + + + + + end = TickCount(); + + total = end - start; + eventTime0 = total;// / 60.0; + + //char logx[255]; + //sprintf(logx, "nk_panel_begin() eventTime0 (run UI) %ld\n", eventTime0); + //writeSerialPort(boutRefNum, logx); + return !(layout->flags & NK_WINDOW_HIDDEN) && !(layout->flags & NK_WINDOW_MINIMIZED); +} +NK_LIB void +nk_panel_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_panel_end"); + struct nk_input *in; + struct nk_window *window; + struct nk_panel *layout; + const struct nk_style *style; + struct nk_command_buffer *out; + + struct nk_vec2 scrollbar_size; + struct nk_vec2 panel_padding; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + window = ctx->current; + layout = window->layout; + style = &ctx->style; + out = &window->buffer; + in = (layout->flags & NK_WINDOW_ROM || layout->flags & NK_WINDOW_NO_INPUT) ? 0 :&ctx->input; + // if (!nk_panel_is_sub(layout->type)) + // nk_push_scissor(out, nk_null_rect); + + /* cache configuration data */ + scrollbar_size = style->window.scrollbar_size; + panel_padding = nk_panel_get_padding(style, layout->type); + + /* update the current cursor Y-position to point over the last added widget */ + layout->at_y += layout->row.height; + + /* dynamic panels */ + if (layout->flags & NK_WINDOW_DYNAMIC && !(layout->flags & NK_WINDOW_MINIMIZED)) + { + /* update panel height to fit dynamic growth */ + struct nk_rect empty_space; + if (layout->at_y < (layout->bounds.y + layout->bounds.h)) + layout->bounds.h = layout->at_y - layout->bounds.y; + + /* fill top empty space */ + empty_space.x = window->bounds.x; + empty_space.y = layout->bounds.y; + empty_space.h = panel_padding.y; + empty_space.w = window->bounds.w; + nk_fill_rect(out, empty_space, 0, style->window.background); + + /* fill left empty space */ + empty_space.x = window->bounds.x; + empty_space.y = layout->bounds.y; + empty_space.w = panel_padding.x + layout->border; + empty_space.h = layout->bounds.h; + nk_fill_rect(out, empty_space, 0, style->window.background); + + /* fill right empty space */ + empty_space.x = layout->bounds.x + layout->bounds.w; + empty_space.y = layout->bounds.y; + empty_space.w = panel_padding.x + layout->border; + empty_space.h = layout->bounds.h; + if (*layout->offset_y == 0 && !(layout->flags & NK_WINDOW_NO_SCROLLBAR)) + empty_space.w += scrollbar_size.x; + nk_fill_rect(out, empty_space, 0, style->window.background); + + /* fill bottom empty space */ + if (layout->footer_height > 0) { + empty_space.x = window->bounds.x; + empty_space.y = layout->bounds.y + layout->bounds.h; + empty_space.w = window->bounds.w; + empty_space.h = layout->footer_height; + nk_fill_rect(out, empty_space, 0, style->window.background); + } + } + + /* scrollbars */ + if (!(layout->flags & NK_WINDOW_NO_SCROLLBAR) && !(layout->flags & NK_WINDOW_MINIMIZED) && window->scrollbar_hiding_timer < NK_SCROLLBAR_HIDING_TIMEOUT) + { + struct nk_rect scroll; + int scroll_has_scrolling; + int scroll_target; + int scroll_offset; + int scroll_step; + int scroll_inc; + + /* mouse wheel scrolling */ + if (nk_panel_is_sub(layout->type)) + { + /* sub-window mouse wheel scrolling */ + struct nk_window *root_window = window; + struct nk_panel *root_panel = window->layout; + while (root_panel->parent) + root_panel = root_panel->parent; + while (root_window->parent) + root_window = root_window->parent; + + /* only allow scrolling if parent window is active */ + scroll_has_scrolling = 0; + if ((root_window == ctx->active) && layout->has_scrolling) { + /* and panel is being hovered and inside clip rect*/ + if (nk_input_is_mouse_hovering_rect(in, layout->bounds) && NK_INTERSECT(layout->bounds.x, layout->bounds.y, layout->bounds.w, layout->bounds.h, + root_panel->clip.x, root_panel->clip.y, root_panel->clip.w, root_panel->clip.h)) + { + /* deactivate all parent scrolling */ + root_panel = window->layout; + while (root_panel->parent) { + root_panel->has_scrolling = nk_false; + root_panel = root_panel->parent; + } + root_panel->has_scrolling = nk_false; + scroll_has_scrolling = nk_true; + } + } + } else if (!nk_panel_is_sub(layout->type)) { + /* window mouse wheel scrolling */ + scroll_has_scrolling = (window == ctx->active) && layout->has_scrolling; + if (in && (in->mouse.scroll_delta.y > 0 || in->mouse.scroll_delta.x > 0) && scroll_has_scrolling) + window->scrolled = nk_true; + else window->scrolled = nk_false; + } else scroll_has_scrolling = nk_false; + + { + /* vertical scrollbar */ + nk_flags state = 0; + scroll.x = layout->bounds.x + layout->bounds.w + panel_padding.x; + scroll.y = layout->bounds.y; + scroll.w = scrollbar_size.x; + scroll.h = layout->bounds.h; + + scroll_offset = (int)*layout->offset_y; + scroll_step = scroll.h * 0.10f; + scroll_inc = scroll.h * 0.01f; + scroll_target = (int)(int)(layout->at_y - scroll.y); + scroll_offset = nk_do_scrollbarv(&state, out, scroll, scroll_has_scrolling, + scroll_offset, scroll_target, scroll_step, scroll_inc, + &ctx->style.scrollv, in, style->font); + *layout->offset_y = (nk_uint)scroll_offset; + if (in && scroll_has_scrolling) + in->mouse.scroll_delta.y = 0; + } + { + /* horizontal scrollbar */ + nk_flags state = 0; + scroll.x = layout->bounds.x; + scroll.y = layout->bounds.y + layout->bounds.h; + scroll.w = layout->bounds.w; + scroll.h = scrollbar_size.y; + + scroll_offset = (int)*layout->offset_x; + scroll_target = (int)(int)(layout->max_x - scroll.x); + scroll_step = layout->max_x * 0.05f; + scroll_inc = layout->max_x * 0.005f; + scroll_offset = nk_do_scrollbarh(&state, out, scroll, scroll_has_scrolling, + scroll_offset, scroll_target, scroll_step, scroll_inc, + &ctx->style.scrollh, in, style->font); + *layout->offset_x = (nk_uint)scroll_offset; + } + } + + /* hide scroll if no user input */ + if (window->flags & NK_WINDOW_SCROLL_AUTO_HIDE) { + int has_input = ctx->input.mouse.delta.x != 0 || ctx->input.mouse.delta.y != 0 || ctx->input.mouse.scroll_delta.y != 0; + int is_window_hovered = nk_window_is_hovered(ctx); + int any_item_active = (ctx->last_widget_state & NK_WIDGET_STATE_MODIFIED); + if ((!has_input && is_window_hovered) || (!is_window_hovered && !any_item_active)) + window->scrollbar_hiding_timer += ctx->delta_time_seconds; + else window->scrollbar_hiding_timer = 0; + } else window->scrollbar_hiding_timer = 0; + + /* window border */ + if (layout->flags & NK_WINDOW_BORDER) + { + struct nk_color border_color = nk_panel_get_border_color(style, layout->type); + const int padding_y = (layout->flags & NK_WINDOW_MINIMIZED) + ? (style->window.border + window->bounds.y + layout->header_height) + : ((layout->flags & NK_WINDOW_DYNAMIC) + ? (layout->bounds.y + layout->bounds.h + layout->footer_height) + : (window->bounds.y + window->bounds.h)); + struct nk_rect b = window->bounds; + b.h = padding_y - window->bounds.y; + nk_stroke_rect(out, b, 0, layout->border, border_color); + } + + /* scaler */ + if ((layout->flags & NK_WINDOW_SCALABLE) && in && !(layout->flags & NK_WINDOW_MINIMIZED)) + { + /* calculate scaler bounds */ + struct nk_rect scaler; + scaler.w = scrollbar_size.x; + scaler.h = scrollbar_size.y; + scaler.y = layout->bounds.y + layout->bounds.h; + if (layout->flags & NK_WINDOW_SCALE_LEFT) + scaler.x = layout->bounds.x - panel_padding.x * 0.5f; + else scaler.x = layout->bounds.x + layout->bounds.w + panel_padding.x; + if (layout->flags & NK_WINDOW_NO_SCROLLBAR) + scaler.x -= scaler.w; + + /* draw scaler */ + {const struct nk_style_item *item = &style->window.scaler; + if (item->type == NK_STYLE_ITEM_IMAGE) + nk_draw_image(out, scaler, &item->data.image, nk_white); + else { + if (layout->flags & NK_WINDOW_SCALE_LEFT) { + nk_fill_triangle(out, scaler.x, scaler.y, scaler.x, + scaler.y + scaler.h, scaler.x + scaler.w, + scaler.y + scaler.h, item->data.color); + } else { + nk_fill_triangle(out, scaler.x + scaler.w, scaler.y, scaler.x + scaler.w, + scaler.y + scaler.h, scaler.x, scaler.y + scaler.h, item->data.color); + } + }} + + /* do window scaling */ + if (!(window->flags & NK_WINDOW_ROM)) { + struct nk_vec2 window_size = style->window.min_size; + int left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down; + int left_mouse_click_in_scaler = nk_input_has_mouse_click_down_in_rect(in, + NK_BUTTON_LEFT, scaler, nk_true); + + if (left_mouse_down && left_mouse_click_in_scaler) { + int delta_x = in->mouse.delta.x; + if (layout->flags & NK_WINDOW_SCALE_LEFT) { + delta_x = -delta_x; + window->bounds.x += in->mouse.delta.x; + } + /* dragging in x-direction */ + if (window->bounds.w + delta_x >= window_size.x) { + if ((delta_x < 0) || (delta_x > 0 && in->mouse.pos.x >= scaler.x)) { + window->bounds.w = window->bounds.w + delta_x; + scaler.x += in->mouse.delta.x; + } + } + /* dragging in y-direction (only possible if static window) */ + if (!(layout->flags & NK_WINDOW_DYNAMIC)) { + if (window_size.y < window->bounds.h + in->mouse.delta.y) { + if ((in->mouse.delta.y < 0) || (in->mouse.delta.y > 0 && in->mouse.pos.y >= scaler.y)) { + window->bounds.h = window->bounds.h + in->mouse.delta.y; + scaler.y += in->mouse.delta.y; + } + } + } + ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT]; + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = scaler.x + scaler.w/2.0f; + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y = scaler.y + scaler.h/2.0f; + } + } + } + if (!nk_panel_is_sub(layout->type)) { + /* window is hidden so clear command buffer */ + if (layout->flags & NK_WINDOW_HIDDEN) + nk_command_buffer_reset(&window->buffer); + /* window is visible and not tab */ + else nk_finish(ctx, window); + } + + /* NK_WINDOW_REMOVE_ROM flag was set so remove NK_WINDOW_ROM */ + if (layout->flags & NK_WINDOW_REMOVE_ROM) { + layout->flags &= ~(nk_flags)NK_WINDOW_ROM; + layout->flags &= ~(nk_flags)NK_WINDOW_REMOVE_ROM; + } + window->flags = layout->flags; + + /* property garbage collector */ + if (window->property.active && window->property.old != window->property.seq && window->property.active == window->property.prev) { + nk_zero(&window->property, sizeof(window->property)); + } else { + window->property.old = window->property.seq; + window->property.prev = window->property.active; + window->property.seq = 0; + } + /* edit garbage collector */ + if (window->edit.active && window->edit.old != window->edit.seq && window->edit.active == window->edit.prev) { + nk_zero(&window->edit, sizeof(window->edit)); + } else { + window->edit.old = window->edit.seq; + window->edit.prev = window->edit.active; + window->edit.seq = 0; + } + /* contextual garbage collector */ + if (window->popup.active_con && window->popup.con_old != window->popup.con_count) { + window->popup.con_count = 0; + window->popup.con_old = 0; + window->popup.active_con = 0; + } else { + window->popup.con_old = window->popup.con_count; + window->popup.con_count = 0; + } + window->popup.combo_count = 0; + /* helper to make sure you have a 'nk_tree_push' for every 'nk_tree_pop' */ + // NK_ASSERT(!layout->row.tree_depth); +} + + + + + +/* =============================================================== + * + * WINDOW + * + * ===============================================================*/ +NK_LIB void* +nk_create_window(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_create_window"); + struct nk_page_element *elem; + elem = nk_create_page_element(ctx); + if (!elem) return 0; + elem->data.win.seq = ctx->seq; + return &elem->data.win; +} +NK_LIB void +nk_free_window(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_free_window"); + /* unlink windows from list */ + struct nk_table *it = win->tables; + if (win->popup.win) { + nk_free_window(ctx, win->popup.win); + win->popup.win = 0; + } + win->next = 0; + win->prev = 0; + + while (it) { + /*free window state tables */ + struct nk_table *n = it->next; + nk_remove_table(win, it); + nk_free_table(ctx, it); + if (it == win->tables) + win->tables = n; + it = n; + } + + /* link windows into freelist */ + {union nk_page_data *pd = NK_CONTAINER_OF(win, union nk_page_data, win); + struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data); + nk_free_page_element(ctx, pe);} +} +NK_LIB struct nk_window* +nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_find_window"); + struct nk_window *iter; + iter = ctx->begin; + while (iter) { + // NK_ASSERT(iter != iter->next); + if (iter->name == hash) { + int max_len = strlen(iter->name_string); + if (!nk_stricmpn(iter->name_string, name, max_len)) + return iter; + } + iter = iter->next; + } + return 0; +} +NK_LIB void +nk_insert_window(struct nk_context *ctx, struct nk_window *win, + enum nk_window_insert_location loc) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - loc / enum"); + const struct nk_window *iter; + // NK_ASSERT(ctx); + // NK_ASSERT(win); + if (!win || !ctx) return; + + iter = ctx->begin; + while (iter) { + // NK_ASSERT(iter != iter->next); + // NK_ASSERT(iter != win); + if (iter == win) return; + iter = iter->next; + } + + if (!ctx->begin) { + win->next = 0; + win->prev = 0; + ctx->begin = win; + ctx->end = win; + ctx->count = 1; + return; + } + if (loc == NK_INSERT_BACK) { + struct nk_window *end; + end = ctx->end; + end->flags |= NK_WINDOW_ROM; + end->next = win; + win->prev = ctx->end; + win->next = 0; + ctx->end = win; + ctx->active = ctx->end; + ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM; + } else { + /*ctx->end->flags |= NK_WINDOW_ROM;*/ + ctx->begin->prev = win; + win->next = ctx->begin; + win->prev = 0; + ctx->begin = win; + ctx->begin->flags &= ~(nk_flags)NK_WINDOW_ROM; + } + ctx->count++; +} +NK_LIB void +nk_remove_window(struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_remove_window"); + if (win == ctx->begin || win == ctx->end) { + if (win == ctx->begin) { + ctx->begin = win->next; + if (win->next) + win->next->prev = 0; + } + if (win == ctx->end) { + ctx->end = win->prev; + if (win->prev) + win->prev->next = 0; + } + } else { + if (win->next) + win->next->prev = win->prev; + if (win->prev) + win->prev->next = win->next; + } + if (win == ctx->active || !ctx->active) { + ctx->active = ctx->end; + if (ctx->end) + ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM; + } + win->next = 0; + win->prev = 0; + ctx->count--; +} +NK_API nk_bool +nk_begin(struct nk_context *ctx, const char *title, + struct nk_rect bounds, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - bounds / struct"); + return nk_begin_titled(ctx, title, title, bounds, flags); +} +NK_API nk_bool +nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, + struct nk_rect bounds, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - bounds / struct"); + struct nk_window *win; + struct nk_style *style; + nk_hash name_hash; + int name_len; + int ret = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(name); + // NK_ASSERT(title); + // NK_ASSERT(ctx->style.font && ctx->style.font->width && "if this triggers you forgot to add a font"); + // NK_ASSERT(!ctx->current && "if this triggers you missed a `nk_end` call"); + if (!ctx || ctx->current || !title || !name) + return 0; + + /* find or create window */ + style = &ctx->style; + name_len = (int)strlen(name); + name_hash = nk_murmur_hash(name, (int)name_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, name_hash, name); + if (!win) { + /* create new window */ + nk_size name_length = (nk_size)name_len; + win = (struct nk_window*)nk_create_window(ctx); + // NK_ASSERT(win); + if (!win) return 0; + + if (flags & NK_WINDOW_BACKGROUND) + nk_insert_window(ctx, win, NK_INSERT_FRONT); + else nk_insert_window(ctx, win, NK_INSERT_BACK); + nk_command_buffer_init(&win->buffer, &ctx->memory, NK_CLIPPING_ON); + + win->flags = flags; + win->bounds = bounds; + win->name = name_hash; + name_length = NK_MIN(name_length, NK_WINDOW_MAX_NAME-1); + NK_MEMCPY(win->name_string, name, name_length); + win->name_string[name_length] = 0; + win->popup.win = 0; + if (!ctx->active) + ctx->active = win; + } else { + /* update window */ + win->flags &= ~(nk_flags)(NK_WINDOW_PRIVATE-1); + win->flags |= flags; + if (!(win->flags & (NK_WINDOW_MOVABLE | NK_WINDOW_SCALABLE))) + win->bounds = bounds; + /* If this assert triggers you either: + * + * I.) Have more than one window with the same name or + * II.) You forgot to actually draw the window. + * More specific you did not call `nk_clear` (nk_clear will be + * automatically called for you if you are using one of the + * provided demo backends). */ + // NK_ASSERT(win->seq != ctx->seq); + win->seq = ctx->seq; + if (!ctx->active && !(win->flags & NK_WINDOW_HIDDEN)) { + ctx->active = win; + ctx->end = win; + } + } + if (win->flags & NK_WINDOW_HIDDEN) { + ctx->current = win; + win->layout = 0; + return 0; + } else nk_start(ctx, win); + + /* window overlapping */ + if (!(win->flags & NK_WINDOW_HIDDEN) && !(win->flags & NK_WINDOW_NO_INPUT)) + { + int inpanel, ishovered; + struct nk_window *iter = win; + int h = ctx->style.font->height + 2.0f * style->window.header.padding.y + + (2.0f * style->window.header.label_padding.y); + struct nk_rect win_bounds = (!(win->flags & NK_WINDOW_MINIMIZED))? + win->bounds: nk_rect(win->bounds.x, win->bounds.y, win->bounds.w, h); + + /* activate window if hovered and no other window is overlapping this window */ + inpanel = nk_input_has_mouse_click_down_in_rect(&ctx->input, NK_BUTTON_LEFT, win_bounds, nk_true); + inpanel = inpanel && ctx->input.mouse.buttons[NK_BUTTON_LEFT].clicked; + ishovered = nk_input_is_mouse_hovering_rect(&ctx->input, win_bounds); + if ((win != ctx->active) && ishovered && !ctx->input.mouse.buttons[NK_BUTTON_LEFT].down) { + iter = win->next; + while (iter) { + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && (!(iter->flags & NK_WINDOW_HIDDEN))) + break; + + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && NK_INTERSECT(win->bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + + /* activate window if clicked */ + if (iter && inpanel && (win != ctx->end)) { + iter = win->next; + while (iter) { + /* try to find a panel with higher priority in the same position */ + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INBOX(ctx->input.mouse.pos.x, ctx->input.mouse.pos.y, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && !(iter->flags & NK_WINDOW_HIDDEN)) + break; + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + if (iter && !(win->flags & NK_WINDOW_ROM) && (win->flags & NK_WINDOW_BACKGROUND)) { + win->flags |= (nk_flags)NK_WINDOW_ROM; + iter->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = iter; + if (!(iter->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, iter); + nk_insert_window(ctx, iter, NK_INSERT_BACK); + } + } else { + if (!iter && ctx->end != win) { + if (!(win->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, win); + nk_insert_window(ctx, win, NK_INSERT_BACK); + } + win->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = win; + } + if (ctx->end != win && !(win->flags & NK_WINDOW_BACKGROUND)) + win->flags |= NK_WINDOW_ROM; + } + } + win->layout = (struct nk_panel*)nk_create_panel(ctx); + ctx->current = win; + ret = nk_panel_begin(ctx, title, NK_PANEL_WINDOW); + win->layout->offset_x = &win->scrollbar.x; + win->layout->offset_y = &win->scrollbar.y; + return ret; +} +NK_API void +nk_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_end"); + struct nk_panel *layout; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current && "if this triggers you forgot to call `nk_begin`"); + if (!ctx || !ctx->current) + return; + + layout = ctx->current->layout; + if (!layout || (layout->type == NK_PANEL_WINDOW && (ctx->current->flags & NK_WINDOW_HIDDEN))) { + ctx->current = 0; + return; + } + nk_panel_end(ctx); + nk_free_panel(ctx, ctx->current->layout); + ctx->current = 0; +} +NK_API struct nk_rect +nk_window_get_bounds(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_get_bounds"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return nk_rect(0,0,0,0); + return ctx->current->bounds; +} +NK_API struct nk_vec2 +nk_window_get_position(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_get_position"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return nk_vec2(0,0); + return nk_vec2(ctx->current->bounds.x, ctx->current->bounds.y); +} +NK_API struct nk_vec2 +nk_window_get_size(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_get_size"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return nk_vec2(0,0); + return nk_vec2(ctx->current->bounds.w, ctx->current->bounds.h); +} +NK_API int +nk_window_get_width(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_get_width"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return 0; + return ctx->current->bounds.w; +} +NK_API int +nk_window_get_height(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_get_height"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return 0; + return ctx->current->bounds.h; +} +NK_API struct nk_rect +nk_window_get_content_region(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_content_region"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return nk_rect(0,0,0,0); + return ctx->current->layout->clip; +} +NK_API struct nk_vec2 +nk_window_get_content_region_min(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_content_region_min"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current) return nk_vec2(0,0); + return nk_vec2(ctx->current->layout->clip.x, ctx->current->layout->clip.y); +} +NK_API struct nk_vec2 +nk_window_get_content_region_max(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_content_region_max"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current) return nk_vec2(0,0); + return nk_vec2(ctx->current->layout->clip.x + ctx->current->layout->clip.w, + ctx->current->layout->clip.y + ctx->current->layout->clip.h); +} +NK_API struct nk_vec2 +nk_window_get_content_region_size(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_content_region_size"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current) return nk_vec2(0,0); + return nk_vec2(ctx->current->layout->clip.w, ctx->current->layout->clip.h); +} +NK_API struct nk_command_buffer* +nk_window_get_canvas(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_canvas"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current) return 0; + return &ctx->current->buffer; +} +NK_API struct nk_panel* +nk_window_get_panel(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_panel"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return 0; + return ctx->current->layout; +} +NK_API void +nk_window_get_scroll(struct nk_context *ctx, nk_uint *offset_x, nk_uint *offset_y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_get_scroll"); + struct nk_window *win; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return ; + win = ctx->current; + if (offset_x) + *offset_x = win->scrollbar.x; + if (offset_y) + *offset_y = win->scrollbar.y; +} +NK_API nk_bool +nk_window_has_focus(const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_window_has_focus"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current) return 0; + return ctx->current == ctx->active; +} +NK_API nk_bool +nk_window_is_hovered(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_hovered"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return 0; + if(ctx->current->flags & NK_WINDOW_HIDDEN) + return 0; + return nk_input_is_mouse_hovering_rect(&ctx->input, ctx->current->bounds); +} +NK_API nk_bool +nk_window_is_any_hovered(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_any_hovered"); + struct nk_window *iter; + // NK_ASSERT(ctx); + if (!ctx) return 0; + iter = ctx->begin; + while (iter) { + /* check if window is being hovered */ + if(!(iter->flags & NK_WINDOW_HIDDEN)) { + /* check if window popup is being hovered */ + if (iter->popup.active && iter->popup.win && nk_input_is_mouse_hovering_rect(&ctx->input, iter->popup.win->bounds)) + return 1; + + if (iter->flags & NK_WINDOW_MINIMIZED) { + struct nk_rect header = iter->bounds; + header.h = ctx->style.font->height + 2 * ctx->style.window.header.padding.y; + if (nk_input_is_mouse_hovering_rect(&ctx->input, header)) + return 1; + } else if (nk_input_is_mouse_hovering_rect(&ctx->input, iter->bounds)) { + return 1; + } + } + iter = iter->next; + } + return 0; +} +NK_API nk_bool +nk_item_is_any_active(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_item_is_any_active"); + int any_hovered = nk_window_is_any_hovered(ctx); + int any_active = (ctx->last_widget_state & NK_WIDGET_STATE_MODIFIED); + return any_hovered || any_active; +} +NK_API nk_bool +nk_window_is_collapsed(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_collapsed"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return 0; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return 0; + return win->flags & NK_WINDOW_MINIMIZED; +} +NK_API nk_bool +nk_window_is_closed(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_closed"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return 1; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return 1; + return (win->flags & NK_WINDOW_CLOSED); +} +NK_API nk_bool +nk_window_is_hidden(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_hidden"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return 1; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return 1; + return (win->flags & NK_WINDOW_HIDDEN); +} +NK_API nk_bool +nk_window_is_active(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_is_active"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return 0; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return 0; + return win == ctx->active; +} +NK_API struct nk_window* +nk_window_find(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_find"); + int title_len; + nk_hash title_hash; + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + return nk_find_window(ctx, title_hash, name); +} +NK_API void +nk_window_close(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_close"); + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return; + win = nk_window_find(ctx, name); + if (!win) return; + // NK_ASSERT(ctx->current != win && "You cannot close a currently active window"); + if (ctx->current == win) return; + win->flags |= NK_WINDOW_HIDDEN; + win->flags |= NK_WINDOW_CLOSED; +} +NK_API void +nk_window_set_bounds(struct nk_context *ctx, + const char *name, struct nk_rect bounds) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - name / const"); + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return; + win = nk_window_find(ctx, name); + if (!win) return; + // NK_ASSERT(ctx->current != win && "You cannot update a currently in procecss window"); + win->bounds = bounds; +} +NK_API void +nk_window_set_position(struct nk_context *ctx, + const char *name, struct nk_vec2 pos) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - name / const"); + struct nk_window *win = nk_window_find(ctx, name); + if (!win) return; + win->bounds.x = pos.x; + win->bounds.y = pos.y; +} +NK_API void +nk_window_set_size(struct nk_context *ctx, + const char *name, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - name / const"); + struct nk_window *win = nk_window_find(ctx, name); + if (!win) return; + win->bounds.w = size.x; + win->bounds.h = size.y; +} +NK_API void +nk_window_set_scroll(struct nk_context *ctx, nk_uint offset_x, nk_uint offset_y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_set_scroll"); + struct nk_window *win; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return; + win = ctx->current; + win->scrollbar.x = offset_x; + win->scrollbar.y = offset_y; +} +NK_API void +nk_window_collapse(struct nk_context *ctx, const char *name, + enum nk_collapse_states c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / enum"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return; + if (c == NK_MINIMIZED) + win->flags |= NK_WINDOW_MINIMIZED; + else win->flags &= ~(nk_flags)NK_WINDOW_MINIMIZED; +} +NK_API void +nk_window_collapse_if(struct nk_context *ctx, const char *name, + enum nk_collapse_states c, int cond) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - c / enum"); + // NK_ASSERT(ctx); + if (!ctx || !cond) return; + nk_window_collapse(ctx, name, c); +} +NK_API void +nk_window_show(struct nk_context *ctx, const char *name, enum nk_show_states s) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_show"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (!win) return; + if (s == NK_HIDDEN) { + win->flags |= NK_WINDOW_HIDDEN; + } else win->flags &= ~(nk_flags)NK_WINDOW_HIDDEN; +} +NK_API void +nk_window_show_if(struct nk_context *ctx, const char *name, + enum nk_show_states s, int cond) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - s / enum"); + // NK_ASSERT(ctx); + if (!ctx || !cond) return; + nk_window_show(ctx, name, s); +} + +NK_API void +nk_window_set_focus(struct nk_context *ctx, const char *name) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_window_set_focus"); + int title_len; + nk_hash title_hash; + struct nk_window *win; + // NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)strlen(name); + title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE); + win = nk_find_window(ctx, title_hash, name); + if (win && ctx->end != win) { + nk_remove_window(ctx, win); + nk_insert_window(ctx, win, NK_INSERT_BACK); + } + ctx->active = win; +} + + + + +/* =============================================================== + * + * POPUP + * + * ===============================================================*/ +NK_API nk_bool +nk_popup_begin(struct nk_context *ctx, enum nk_popup_type type, + const char *title, nk_flags flags, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + struct nk_window *popup; + struct nk_window *win; + struct nk_panel *panel; + + int title_len; + nk_hash title_hash; + nk_size allocated; + + // NK_ASSERT(ctx); + // NK_ASSERT(title); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + panel = win->layout; + // NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP) && "popups are not allowed to have popups"); + (void)panel; + title_len = (int)strlen(title); + title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_POPUP); + + popup = win->popup.win; + if (!popup) { + popup = (struct nk_window*)nk_create_window(ctx); + popup->parent = win; + win->popup.win = popup; + win->popup.active = 0; + win->popup.type = NK_PANEL_POPUP; + } + + /* make sure we have correct popup */ + if (win->popup.name != title_hash) { + if (!win->popup.active) { + nk_zero(popup, sizeof(*popup)); + win->popup.name = title_hash; + win->popup.active = 1; + win->popup.type = NK_PANEL_POPUP; + } else return 0; + } + + /* popup position is local to window */ + ctx->current = popup; + rect.x += win->layout->clip.x; + rect.y += win->layout->clip.y; + + /* setup popup data */ + popup->parent = win; + popup->bounds = rect; + popup->seq = ctx->seq; + popup->layout = (struct nk_panel*)nk_create_panel(ctx); + popup->flags = flags; + popup->flags |= NK_WINDOW_BORDER; + if (type == NK_POPUP_DYNAMIC) + popup->flags |= NK_WINDOW_DYNAMIC; + + popup->buffer = win->buffer; + nk_start_popup(ctx, win); + allocated = ctx->memory.allocated; + // nk_push_scissor(&popup->buffer, nk_null_rect); + + if (nk_panel_begin(ctx, title, NK_PANEL_POPUP)) { + /* popup is running therefore invalidate parent panels */ + struct nk_panel *root; + root = win->layout; + while (root) { + root->flags |= NK_WINDOW_ROM; + root->flags &= ~(nk_flags)NK_WINDOW_REMOVE_ROM; + root = root->parent; + } + win->popup.active = 1; + popup->layout->offset_x = &popup->scrollbar.x; + popup->layout->offset_y = &popup->scrollbar.y; + popup->layout->parent = win->layout; + return 1; + } else { + /* popup was closed/is invalid so cleanup */ + struct nk_panel *root; + root = win->layout; + while (root) { + root->flags |= NK_WINDOW_REMOVE_ROM; + root = root->parent; + } + win->popup.buf.active = 0; + win->popup.active = 0; + ctx->memory.allocated = allocated; + ctx->current = win; + nk_free_panel(ctx, popup->layout); + popup->layout = 0; + return 0; + } +} +NK_LIB nk_bool +nk_nonblock_begin(struct nk_context *ctx, + nk_flags flags, struct nk_rect body, struct nk_rect header, + enum nk_panel_type panel_type) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - panel_type / enum"); + struct nk_window *popup; + struct nk_window *win; + struct nk_panel *panel; + int is_active = nk_true; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + /* popups cannot have popups */ + win = ctx->current; + panel = win->layout; + // NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP)); + (void)panel; + popup = win->popup.win; + if (!popup) { + /* create window for nonblocking popup */ + popup = (struct nk_window*)nk_create_window(ctx); + popup->parent = win; + win->popup.win = popup; + win->popup.type = panel_type; + nk_command_buffer_init(&popup->buffer, &ctx->memory, NK_CLIPPING_ON); + } else { + /* close the popup if user pressed outside or in the header */ + int pressed, in_body, in_header; +#ifdef NK_BUTTON_TRIGGER_ON_RELEASE + pressed = nk_input_is_mouse_released(&ctx->input, NK_BUTTON_LEFT); +#else + pressed = nk_input_is_mouse_pressed(&ctx->input, NK_BUTTON_LEFT); +#endif + in_body = nk_input_is_mouse_hovering_rect(&ctx->input, body); + in_header = nk_input_is_mouse_hovering_rect(&ctx->input, header); + if (pressed && (!in_body || in_header)) + is_active = nk_false; + } + win->popup.header = header; + + if (!is_active) { + /* remove read only mode from all parent panels */ + struct nk_panel *root = win->layout; + while (root) { + root->flags |= NK_WINDOW_REMOVE_ROM; + root = root->parent; + } + return is_active; + } + popup->bounds = body; + popup->parent = win; + popup->layout = (struct nk_panel*)nk_create_panel(ctx); + popup->flags = flags; + popup->flags |= NK_WINDOW_BORDER; + popup->flags |= NK_WINDOW_DYNAMIC; + popup->seq = ctx->seq; + win->popup.active = 1; + // NK_ASSERT(popup->layout); + + nk_start_popup(ctx, win); + popup->buffer = win->buffer; + // nk_push_scissor(&popup->buffer, nk_null_rect); + ctx->current = popup; + + nk_panel_begin(ctx, 0, panel_type); + win->buffer = popup->buffer; + popup->layout->parent = win->layout; + popup->layout->offset_x = &popup->scrollbar.x; + popup->layout->offset_y = &popup->scrollbar.y; + + /* set read only mode to all parent panels */ + {struct nk_panel *root; + root = win->layout; + while (root) { + root->flags |= NK_WINDOW_ROM; + root = root->parent; + }} + return is_active; +} +NK_API void +nk_popup_close(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_popup_close"); + struct nk_window *popup; + // NK_ASSERT(ctx); + if (!ctx || !ctx->current) return; + + popup = ctx->current; + // NK_ASSERT(popup->parent); + // NK_ASSERT(popup->layout->type & NK_PANEL_SET_POPUP); + popup->flags |= NK_WINDOW_HIDDEN; +} +NK_API void +nk_popup_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_popup_end"); + struct nk_window *win; + struct nk_window *popup; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + popup = ctx->current; + if (!popup->parent) return; + win = popup->parent; + if (popup->flags & NK_WINDOW_HIDDEN) { + struct nk_panel *root; + root = win->layout; + while (root) { + root->flags |= NK_WINDOW_REMOVE_ROM; + root = root->parent; + } + win->popup.active = 0; + } + // nk_push_scissor(&popup->buffer, nk_null_rect); + nk_end(ctx); + + win->buffer = popup->buffer; + nk_finish_popup(ctx, win); + ctx->current = win; + // nk_push_scissor(&win->buffer, win->layout->clip); +} +NK_API void +nk_popup_get_scroll(struct nk_context *ctx, nk_uint *offset_x, nk_uint *offset_y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_popup_get_scroll"); + struct nk_window *popup; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + popup = ctx->current; + if (offset_x) + *offset_x = popup->scrollbar.x; + if (offset_y) + *offset_y = popup->scrollbar.y; +} +NK_API void +nk_popup_set_scroll(struct nk_context *ctx, nk_uint offset_x, nk_uint offset_y) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_popup_set_scroll"); + struct nk_window *popup; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + popup = ctx->current; + popup->scrollbar.x = offset_x; + popup->scrollbar.y = offset_y; +} + + + + +/* ============================================================== + * + * CONTEXTUAL + * + * ===============================================================*/ +NK_API nk_bool +nk_contextual_begin(struct nk_context *ctx, nk_flags flags, struct nk_vec2 size, + struct nk_rect trigger_bounds) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - trigger_bounds / struct"); + struct nk_window *win; + struct nk_window *popup; + struct nk_rect body; + + NK_STORAGE const struct nk_rect null_rect = {-1,-1,0,0}; + int is_clicked = 0; + int is_open = 0; + int ret = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + ++win->popup.con_count; + if (ctx->current != ctx->active) + return 0; + + /* check if currently active contextual is active */ + popup = win->popup.win; + is_open = (popup && win->popup.type == NK_PANEL_CONTEXTUAL); + is_clicked = nk_input_mouse_clicked(&ctx->input, NK_BUTTON_RIGHT, trigger_bounds); + if (win->popup.active_con && win->popup.con_count != win->popup.active_con) + return 0; + if (!is_open && win->popup.active_con) + win->popup.active_con = 0; + if ((!is_open && !is_clicked)) + return 0; + + /* calculate contextual position on click */ + win->popup.active_con = win->popup.con_count; + if (is_clicked) { + body.x = ctx->input.mouse.pos.x; + body.y = ctx->input.mouse.pos.y; + } else { + body.x = popup->bounds.x; + body.y = popup->bounds.y; + } + body.w = size.x; + body.h = size.y; + + /* start nonblocking contextual popup */ + ret = nk_nonblock_begin(ctx, flags|NK_WINDOW_NO_SCROLLBAR, body, + null_rect, NK_PANEL_CONTEXTUAL); + if (ret) win->popup.type = NK_PANEL_CONTEXTUAL; + else { + win->popup.active_con = 0; + win->popup.type = NK_PANEL_NONE; + if (win->popup.win) + win->popup.win->flags = 0; + } + return ret; +} +NK_API nk_bool +nk_contextual_item_text(struct nk_context *ctx, const char *text, int len, + nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - alignment) / nk_flags"); + struct nk_window *win; + const struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding); + if (!state) return nk_false; + + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds, + text, len, alignment, NK_BUTTON_DEFAULT, &style->contextual_button, in, style->font)) { + nk_contextual_close(ctx); + return nk_true; + } + return nk_false; +} +NK_API nk_bool +nk_contextual_item_label(struct nk_context *ctx, const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_contextual_item_label"); + return nk_contextual_item_text(ctx, label, strlen(label), align); +} +NK_API nk_bool +nk_contextual_item_image_text(struct nk_context *ctx, struct nk_image img, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + struct nk_window *win; + const struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding); + if (!state) return nk_false; + + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer, bounds, + img, text, len, align, NK_BUTTON_DEFAULT, &style->contextual_button, style->font, in)){ + nk_contextual_close(ctx); + return nk_true; + } + return nk_false; +} +NK_API nk_bool +nk_contextual_item_image_label(struct nk_context *ctx, struct nk_image img, + const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_contextual_item_image_text(ctx, img, label, strlen(label), align); +} +NK_API nk_bool +nk_contextual_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbol, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + struct nk_window *win; + const struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding); + if (!state) return nk_false; + + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds, + symbol, text, len, align, NK_BUTTON_DEFAULT, &style->contextual_button, style->font, in)) { + nk_contextual_close(ctx); + return nk_true; + } + return nk_false; +} +NK_API nk_bool +nk_contextual_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type symbol, + const char *text, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_contextual_item_symbol_text(ctx, symbol, text, strlen(text), align); +} +NK_API void +nk_contextual_close(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_contextual_close"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return; + nk_popup_close(ctx); +} +NK_API void +nk_contextual_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_contextual_end"); + struct nk_window *popup; + struct nk_panel *panel; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return; + + popup = ctx->current; + panel = popup->layout; + // NK_ASSERT(popup->parent); + // NK_ASSERT(panel->type & NK_PANEL_SET_POPUP); + if (panel->flags & NK_WINDOW_DYNAMIC) { + /* Close behavior + This is a bit of a hack solution since we do not know before we end our popup + how big it will be. We therefore do not directly know when a + click outside the non-blocking popup must close it at that direct frame. + Instead it will be closed in the next frame.*/ + struct nk_rect body = {0,0,0,0}; + if (panel->at_y < (panel->bounds.y + panel->bounds.h)) { + struct nk_vec2 padding = nk_panel_get_padding(&ctx->style, panel->type); + body = panel->bounds; + body.y = (panel->at_y + panel->footer_height + panel->border + padding.y + panel->row.height); + body.h = (panel->bounds.y + panel->bounds.h) - body.y; + } + {int pressed = nk_input_is_mouse_pressed(&ctx->input, NK_BUTTON_LEFT); + int in_body = nk_input_is_mouse_hovering_rect(&ctx->input, body); + if (pressed && in_body) + popup->flags |= NK_WINDOW_HIDDEN; + } + } + if (popup->flags & NK_WINDOW_HIDDEN) + popup->seq = 0; + nk_popup_end(ctx); + return; +} + + + + + +/* =============================================================== + * + * MENU + * + * ===============================================================*/ +NK_API void +nk_menubar_begin(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_menubar_begin"); + struct nk_panel *layout; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + layout = ctx->current->layout; + // NK_ASSERT(layout->at_y == layout->bounds.y); + /* if this assert triggers you allocated space between nk_begin and nk_menubar_begin. + If you want a menubar the first nuklear function after `nk_begin` has to be a + `nk_menubar_begin` call. Inside the menubar you then have to allocate space for + widgets (also supports multiple rows). + Example: + if (nk_begin(...)) { + nk_menubar_begin(...); + nk_layout_xxxx(...); + nk_button(...); + nk_layout_xxxx(...); + nk_button(...); + nk_menubar_end(...); + } + nk_end(...); + */ + if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED) + return; + + layout->menu.x = layout->at_x; + layout->menu.y = layout->at_y + layout->row.height; + layout->menu.w = layout->bounds.w; + layout->menu.offset.x = *layout->offset_x; + layout->menu.offset.y = *layout->offset_y; + *layout->offset_y = 0; +} +NK_API void +nk_menubar_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_menubar_end"); + struct nk_window *win; + struct nk_panel *layout; + struct nk_command_buffer *out; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + out = &win->buffer; + layout = win->layout; + if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED) + return; + + layout->menu.h = layout->at_y - layout->menu.y; + layout->menu.h += layout->row.height + ctx->style.window.spacing.y; + + layout->bounds.y += layout->menu.h; + layout->bounds.h -= layout->menu.h; + + *layout->offset_x = layout->menu.offset.x; + *layout->offset_y = layout->menu.offset.y; + layout->at_y = layout->bounds.y - layout->row.height; + + layout->clip.y = layout->bounds.y; + layout->clip.h = layout->bounds.h; + // nk_push_scissor(out, layout->clip); +} +NK_INTERN int +nk_menu_begin(struct nk_context *ctx, struct nk_window *win, + const char *id, int is_clicked, struct nk_rect header, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - id / const"); + int is_open = 0; + int is_active = 0; + struct nk_rect body; + struct nk_window *popup; + nk_hash hash = nk_murmur_hash(id, (int)strlen(id), NK_PANEL_MENU); + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + body.x = header.x; + body.w = size.x; + body.y = header.y + header.h; + body.h = size.y; + + popup = win->popup.win; + is_open = popup ? nk_true : nk_false; + is_active = (popup && (win->popup.name == hash) && win->popup.type == NK_PANEL_MENU); + if ((is_clicked && is_open && !is_active) || (is_open && !is_active) || + (!is_open && !is_active && !is_clicked)) return 0; + if (!nk_nonblock_begin(ctx, NK_WINDOW_NO_SCROLLBAR, body, header, NK_PANEL_MENU)) + return 0; + + win->popup.type = NK_PANEL_MENU; + win->popup.name = hash; + return 1; +} +NK_API nk_bool +nk_menu_begin_text(struct nk_context *ctx, const char *title, int len, + nk_flags align, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - align, / nk_flags"); + struct nk_window *win; + const struct nk_input *in; + struct nk_rect header; + int is_clicked = nk_false; + nk_flags state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + state = nk_widget(&header, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || win->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, header, + title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font)) + is_clicked = nk_true; + return nk_menu_begin(ctx, win, title, is_clicked, header, size); +} +NK_API nk_bool nk_menu_begin_label(struct nk_context *ctx, + const char *text, nk_flags align, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_menu_begin_text(ctx, text, strlen(text), align, size); +} +NK_API nk_bool +nk_menu_begin_image(struct nk_context *ctx, const char *id, struct nk_image img, + struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - size / struct"); + struct nk_window *win; + struct nk_rect header; + const struct nk_input *in; + int is_clicked = nk_false; + nk_flags state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + state = nk_widget(&header, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_image(&ctx->last_widget_state, &win->buffer, header, + img, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in)) + is_clicked = nk_true; + return nk_menu_begin(ctx, win, id, is_clicked, header, size); +} +NK_API nk_bool +nk_menu_begin_symbol(struct nk_context *ctx, const char *id, + enum nk_symbol_type sym, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - sym / enum"); + struct nk_window *win; + const struct nk_input *in; + struct nk_rect header; + int is_clicked = nk_false; + nk_flags state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + state = nk_widget(&header, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, header, + sym, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font)) + is_clicked = nk_true; + return nk_menu_begin(ctx, win, id, is_clicked, header, size); +} +NK_API nk_bool +nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len, + nk_flags align, struct nk_image img, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - align, / nk_flags"); + struct nk_window *win; + struct nk_rect header; + const struct nk_input *in; + int is_clicked = nk_false; + nk_flags state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + state = nk_widget(&header, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer, + header, img, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button, + ctx->style.font, in)) + is_clicked = nk_true; + return nk_menu_begin(ctx, win, title, is_clicked, header, size); +} +NK_API nk_bool +nk_menu_begin_image_label(struct nk_context *ctx, + const char *title, nk_flags align, struct nk_image img, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_menu_begin_image_text(ctx, title, strlen(title), align, img, size); +} +NK_API nk_bool +nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len, + nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - align, / nk_flags"); + struct nk_window *win; + struct nk_rect header; + const struct nk_input *in; + int is_clicked = nk_false; + nk_flags state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + state = nk_widget(&header, ctx); + if (!state) return 0; + + in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, + header, sym, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button, + ctx->style.font, in)) is_clicked = nk_true; + return nk_menu_begin(ctx, win, title, is_clicked, header, size); +} +NK_API nk_bool +nk_menu_begin_symbol_label(struct nk_context *ctx, + const char *title, nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size ) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_menu_begin_symbol_text(ctx, title, strlen(title), align,sym,size); +} +NK_API nk_bool +nk_menu_item_text(struct nk_context *ctx, const char *title, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_menu_item_text"); + return nk_contextual_item_text(ctx, title, len, align); +} +NK_API nk_bool +nk_menu_item_label(struct nk_context *ctx, const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_menu_item_label"); + return nk_contextual_item_label(ctx, label, align); +} +NK_API nk_bool +nk_menu_item_image_label(struct nk_context *ctx, struct nk_image img, + const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_contextual_item_image_label(ctx, img, label, align); +} +NK_API nk_bool +nk_menu_item_image_text(struct nk_context *ctx, struct nk_image img, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_contextual_item_image_text(ctx, img, text, len, align); +} +NK_API nk_bool nk_menu_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_contextual_item_symbol_text(ctx, sym, text, len, align); +} +NK_API nk_bool nk_menu_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym, + const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_contextual_item_symbol_label(ctx, sym, label, align); +} +NK_API void nk_menu_close(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_menu_close / NK_API"); + nk_contextual_close(ctx); +} +NK_API void +nk_menu_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_menu_end"); + nk_contextual_end(ctx); +} + + + + + +/* =============================================================== + * + * LAYOUT + * + * ===============================================================*/ +NK_API void +nk_layout_set_min_row_height(struct nk_context *ctx, int height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_set_min_row_height"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + layout->row.min_height = height; +} +NK_API void +nk_layout_reset_min_row_height(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_reset_min_row_height"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + layout->row.min_height = ctx->style.font->height; + layout->row.min_height += ctx->style.text.padding.y*2; + layout->row.min_height += ctx->style.window.min_row_height_padding*2; +} +NK_LIB int +nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type, + int total_space, int columns) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - total_space, / int"); + int panel_spacing; + int panel_space; + + struct nk_vec2 spacing; + + spacing = style->window.spacing; + + /* calculate the usable panel space */ + panel_spacing = (int)NK_MAX(columns - 1, 0) * spacing.x; + panel_space = total_space - panel_spacing; + return panel_space; +} +NK_LIB void +nk_panel_layout(const struct nk_context *ctx, struct nk_window *win, + int height, int cols) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - height, / int"); + struct nk_panel *layout; + const struct nk_style *style; + struct nk_command_buffer *out; + + struct nk_vec2 item_spacing; + struct nk_color color; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + /* prefetch some configuration data */ + layout = win->layout; + style = &ctx->style; + out = &win->buffer; + color = style->window.background; + item_spacing = style->window.spacing; + + /* if one of these triggers you forgot to add an `if` condition around either + a window, group, popup, combobox or contextual menu `begin` and `end` block. + Example: + if (nk_begin(...) {...} nk_end(...); or + if (nk_group_begin(...) { nk_group_end(...);} */ + // NK_ASSERT(!(layout->flags & NK_WINDOW_MINIMIZED)); + // NK_ASSERT(!(layout->flags & NK_WINDOW_HIDDEN)); + // NK_ASSERT(!(layout->flags & NK_WINDOW_CLOSED)); + + /* update the current row and set the current row layout */ + layout->row.index = 0; + layout->at_y += layout->row.height; + layout->row.columns = cols; + if (height == 0.0f) + layout->row.height = NK_MAX(height, layout->row.min_height) + item_spacing.y; + else layout->row.height = height + item_spacing.y; + + layout->row.item_offset = 0; + if (layout->flags & NK_WINDOW_DYNAMIC) { + /* draw background for dynamic panels */ + struct nk_rect background; + background.x = win->bounds.x; + background.w = win->bounds.w; + background.y = layout->at_y - 1.0f; + background.h = layout->row.height + 1.0f; + nk_fill_rect(out, background, 0, color); + } +} +NK_LIB void +nk_row_layout(struct nk_context *ctx, enum nk_layout_format fmt, + int height, int cols, int width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - height, / int"); + /* update the current row and set the current row layout */ + struct nk_window *win; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + nk_panel_layout(ctx, win, height, cols); + if (fmt == NK_DYNAMIC) + win->layout->row.type = NK_LAYOUT_DYNAMIC_FIXED; + else win->layout->row.type = NK_LAYOUT_STATIC_FIXED; + + win->layout->row.ratio = 0; + win->layout->row.filled = 0; + win->layout->row.item_offset = 0; + win->layout->row.item_width = (int)width; +} +NK_API int +nk_layout_ratio_from_pixel(struct nk_context *ctx, int pixel_width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_ratio_from_pixel"); + struct nk_window *win; + // NK_ASSERT(ctx); + // NK_ASSERT(pixel_width); + if (!ctx || !ctx->current || !ctx->current->layout) return 0; + win = ctx->current; + return NK_CLAMP(0.0f, pixel_width/win->bounds.x, 1.0f); +} +NK_API void +nk_layout_row_dynamic(struct nk_context *ctx, int height, int cols) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_dynamic"); + nk_row_layout(ctx, NK_DYNAMIC, height, cols, 0); +} +NK_API void +nk_layout_row_static(struct nk_context *ctx, int height, int item_width, int cols) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_static"); + nk_row_layout(ctx, NK_STATIC, height, cols, item_width); +} +NK_API void +nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt, + int row_height, int cols) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - row_height, / int"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + nk_panel_layout(ctx, win, row_height, cols); + if (fmt == NK_DYNAMIC) + layout->row.type = NK_LAYOUT_DYNAMIC_ROW; + else layout->row.type = NK_LAYOUT_STATIC_ROW; + + layout->row.ratio = 0; + layout->row.filled = 0; + layout->row.item_width = 0; + layout->row.item_offset = 0; + layout->row.columns = cols; +} +NK_API void +nk_layout_row_push(struct nk_context *ctx, int ratio_or_width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_push"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW); + if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW) + return; + + if (layout->row.type == NK_LAYOUT_DYNAMIC_ROW) { + int ratio = ratio_or_width; + if ((ratio + layout->row.filled) > 1.0f) return; + if (ratio > 0.0f) + layout->row.item_width = NK_SATURATE(ratio); + else layout->row.item_width = 1.0f - layout->row.filled; + } else layout->row.item_width = ratio_or_width; +} +NK_API void +nk_layout_row_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_end"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW); + if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW) + return; + layout->row.item_width = 0; + layout->row.item_offset = 0; +} +NK_API void +nk_layout_row(struct nk_context *ctx, enum nk_layout_format fmt, + int height, int cols, const int *ratio) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - height, / int"); + int i; + int n_undef = 0; + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + nk_panel_layout(ctx, win, height, cols); + if (fmt == NK_DYNAMIC) { + /* calculate width of undefined widget ratios */ + int r = 0; + layout->row.ratio = ratio; + for (i = 0; i < cols; ++i) { + if (ratio[i] < 0.0f) + n_undef++; + else r += ratio[i]; + } + r = NK_SATURATE(1.0f - r); + layout->row.type = NK_LAYOUT_DYNAMIC; + layout->row.item_width = (r > 0 && n_undef > 0) ? (r / (int)n_undef):0; + } else { + layout->row.ratio = ratio; + layout->row.type = NK_LAYOUT_STATIC; + layout->row.item_width = 0; + layout->row.item_offset = 0; + } + layout->row.item_offset = 0; + layout->row.filled = 0; +} +NK_API void +nk_layout_row_template_begin(struct nk_context *ctx, int height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_template_begin"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + nk_panel_layout(ctx, win, height, 1); + layout->row.type = NK_LAYOUT_TEMPLATE; + layout->row.columns = 0; + layout->row.ratio = 0; + layout->row.item_width = 0; + layout->row.item_height = 0; + layout->row.item_offset = 0; + layout->row.filled = 0; + layout->row.item.x = 0; + layout->row.item.y = 0; + layout->row.item.w = 0; + layout->row.item.h = 0; +} +NK_API void +nk_layout_row_template_push_dynamic(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_template_push_dynamic"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE); + // NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS); + if (layout->row.type != NK_LAYOUT_TEMPLATE) return; + if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return; + layout->row.templates[layout->row.columns++] = -1.0f; +} +NK_API void +nk_layout_row_template_push_variable(struct nk_context *ctx, int min_width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_template_push_variable"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE); + // NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS); + if (layout->row.type != NK_LAYOUT_TEMPLATE) return; + if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return; + layout->row.templates[layout->row.columns++] = -min_width; +} +NK_API void +nk_layout_row_template_push_static(struct nk_context *ctx, int width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_template_push_static"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE); + // NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS); + if (layout->row.type != NK_LAYOUT_TEMPLATE) return; + if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return; + layout->row.templates[layout->row.columns++] = width; +} +NK_API void +nk_layout_row_template_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_row_template_end"); + struct nk_window *win; + struct nk_panel *layout; + + int i = 0; + int variable_count = 0; + int min_variable_count = 0; + int min_fixed_width = 0.0f; + int total_fixed_width = 0.0f; + int max_variable_width = 0.0f; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + // NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE); + if (layout->row.type != NK_LAYOUT_TEMPLATE) return; + for (i = 0; i < layout->row.columns; ++i) { + int width = layout->row.templates[i]; + if (width >= 0.0f) { + total_fixed_width += width; + min_fixed_width += width; + } else if (width < -1.0f) { + width = -width; + total_fixed_width += width; + max_variable_width = NK_MAX(max_variable_width, width); + variable_count++; + } else { + min_variable_count++; + variable_count++; + } + } + if (variable_count) { + int space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type, + layout->bounds.w, layout->row.columns); + int var_width = (NK_MAX(space-min_fixed_width,0.0f)) / (int)variable_count; + int enough_space = var_width >= max_variable_width; + if (!enough_space) + var_width = (NK_MAX(space-total_fixed_width,0)) / (int)min_variable_count; + for (i = 0; i < layout->row.columns; ++i) { + int *width = &layout->row.templates[i]; + *width = (*width >= 0.0f)? *width: (*width < -1.0f && !enough_space)? -(*width): var_width; + } + } +} +NK_API void +nk_layout_space_begin(struct nk_context *ctx, enum nk_layout_format fmt, + int height, int widget_count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - height, / int"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + nk_panel_layout(ctx, win, height, widget_count); + if (fmt == NK_STATIC) + layout->row.type = NK_LAYOUT_STATIC_FREE; + else layout->row.type = NK_LAYOUT_DYNAMIC_FREE; + + layout->row.ratio = 0; + layout->row.filled = 0; + layout->row.item_width = 0; + layout->row.item_offset = 0; +} +NK_API void +nk_layout_space_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_end"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + layout->row.item_width = 0; + layout->row.item_height = 0; + layout->row.item_offset = 0; + nk_zero(&layout->row.item, sizeof(layout->row.item)); +} +NK_API void +nk_layout_space_push(struct nk_context *ctx, struct nk_rect rect) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_push"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + layout->row.item = rect; +} +NK_API struct nk_rect +nk_layout_space_bounds(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_bounds"); + struct nk_rect ret; + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x = layout->clip.x; + ret.y = layout->clip.y; + ret.w = layout->clip.w; + ret.h = layout->row.height; + return ret; +} +NK_API struct nk_rect +nk_layout_widget_bounds(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_widget_bounds"); + struct nk_rect ret; + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x = layout->at_x; + ret.y = layout->at_y; + ret.w = layout->bounds.w - NK_MAX(layout->at_x - layout->bounds.x,0); + ret.h = layout->row.height; + return ret; +} +NK_API struct nk_vec2 +nk_layout_space_to_screen(struct nk_context *ctx, struct nk_vec2 ret) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_to_screen"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x += layout->at_x - (int)*layout->offset_x; + ret.y += layout->at_y - (int)*layout->offset_y; + return ret; +} +NK_API struct nk_vec2 +nk_layout_space_to_local(struct nk_context *ctx, struct nk_vec2 ret) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_to_local"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x += -layout->at_x + (int)*layout->offset_x; + ret.y += -layout->at_y + (int)*layout->offset_y; + return ret; +} +NK_API struct nk_rect +nk_layout_space_rect_to_screen(struct nk_context *ctx, struct nk_rect ret) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_rect_to_screen"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x += layout->at_x - (int)*layout->offset_x; + ret.y += layout->at_y - (int)*layout->offset_y; + return ret; +} +NK_API struct nk_rect +nk_layout_space_rect_to_local(struct nk_context *ctx, struct nk_rect ret) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_layout_space_rect_to_local"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + win = ctx->current; + layout = win->layout; + + ret.x += -layout->at_x + (int)*layout->offset_x; + ret.y += -layout->at_y + (int)*layout->offset_y; + return ret; +} +NK_LIB void +nk_panel_alloc_row(const struct nk_context *ctx, struct nk_window *win) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_panel_alloc_row"); + struct nk_panel *layout = win->layout; + struct nk_vec2 spacing = ctx->style.window.spacing; + const int row_height = layout->row.height - spacing.y; + nk_panel_layout(ctx, win, row_height, layout->row.columns); +} +NK_LIB void +nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx, + struct nk_window *win, int modify) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_layout_widget_space"); + struct nk_panel *layout; + const struct nk_style *style; + + struct nk_vec2 spacing; + + int item_offset = 0; + int item_width = 0; + int item_spacing = 0; + int panel_space = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + style = &ctx->style; + // NK_ASSERT(bounds); + + spacing = style->window.spacing; + panel_space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type, + layout->bounds.w, layout->row.columns); + + #define NK_FRAC(x) (x - (int)x) /* will be used to remove fookin gaps */ + /* calculate the width of one item inside the current layout space */ + switch (layout->row.type) { + case NK_LAYOUT_DYNAMIC_FIXED: { + /* scaling fixed size widgets item width */ + int w = NK_MAX(1.0f,panel_space) / (int)layout->row.columns; + item_offset = (int)layout->row.index * w; + item_width = w + NK_FRAC(item_offset); + item_spacing = (int)layout->row.index * spacing.x; + } break; + case NK_LAYOUT_DYNAMIC_ROW: { + /* scaling single ratio widget width */ + int w = layout->row.item_width * panel_space; + item_offset = layout->row.item_offset; + item_width = w + NK_FRAC(item_offset); + item_spacing = 0; + + if (modify) { + layout->row.item_offset += w + spacing.x; + layout->row.filled += layout->row.item_width; + layout->row.index = 0; + } + } break; + case NK_LAYOUT_DYNAMIC_FREE: { + /* panel width depended free widget placing */ + bounds->x = layout->at_x + (layout->bounds.w * layout->row.item.x); + bounds->x -= (int)*layout->offset_x; + bounds->y = layout->at_y + (layout->row.height * layout->row.item.y); + bounds->y -= (int)*layout->offset_y; + bounds->w = layout->bounds.w * layout->row.item.w + NK_FRAC(bounds->x); + bounds->h = layout->row.height * layout->row.item.h + NK_FRAC(bounds->y); + return; + } + case NK_LAYOUT_DYNAMIC: { + /* scaling arrays of panel width ratios for every widget */ + int ratio, w; + // NK_ASSERT(layout->row.ratio); + ratio = (layout->row.ratio[layout->row.index] < 0) ? + layout->row.item_width : layout->row.ratio[layout->row.index]; + + w = (ratio * panel_space); + item_spacing = (int)layout->row.index * spacing.x; + item_offset = layout->row.item_offset; + item_width = w + NK_FRAC(item_offset); + + if (modify) { + layout->row.item_offset += w; + layout->row.filled += ratio; + } + } break; + case NK_LAYOUT_STATIC_FIXED: { + /* non-scaling fixed widgets item width */ + item_width = layout->row.item_width; + item_offset = (int)layout->row.index * item_width; + item_spacing = (int)layout->row.index * spacing.x; + } break; + case NK_LAYOUT_STATIC_ROW: { + /* scaling single ratio widget width */ + item_width = layout->row.item_width; + item_offset = layout->row.item_offset; + item_spacing = (int)layout->row.index * spacing.x; + if (modify) layout->row.item_offset += item_width; + } break; + case NK_LAYOUT_STATIC_FREE: { + /* free widget placing */ + bounds->x = layout->at_x + layout->row.item.x; + bounds->w = layout->row.item.w; + if (((bounds->x + bounds->w) > layout->max_x) && modify) + layout->max_x = (bounds->x + bounds->w); + bounds->x -= (int)*layout->offset_x; + bounds->y = layout->at_y + layout->row.item.y; + bounds->y -= (int)*layout->offset_y; + bounds->h = layout->row.item.h; + return; + } + case NK_LAYOUT_STATIC: { + /* non-scaling array of panel pixel width for every widget */ + item_spacing = (int)layout->row.index * spacing.x; + item_width = layout->row.ratio[layout->row.index]; + item_offset = layout->row.item_offset; + if (modify) layout->row.item_offset += item_width; + } break; + case NK_LAYOUT_TEMPLATE: { + /* stretchy row layout with combined dynamic/static widget width*/ + int w; + // NK_ASSERT(layout->row.index < layout->row.columns); + // NK_ASSERT(layout->row.index < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS); + w = layout->row.templates[layout->row.index]; + item_offset = layout->row.item_offset; + item_width = w + NK_FRAC(item_offset); + item_spacing = (int)layout->row.index * spacing.x; + if (modify) layout->row.item_offset += w; + } break; + #undef NK_FRAC + default: break; // NK_ASSERT(0); break; + }; + + /* set the bounds of the newly allocated widget */ + bounds->w = item_width; + bounds->h = layout->row.height - spacing.y; + bounds->y = layout->at_y - (int)*layout->offset_y; + bounds->x = layout->at_x + item_offset + item_spacing; + if (((bounds->x + bounds->w) > layout->max_x) && modify) + layout->max_x = bounds->x + bounds->w; + bounds->x -= (int)*layout->offset_x; +} +NK_LIB void +nk_panel_alloc_space(struct nk_rect *bounds, const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_panel_alloc_space"); + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + /* check if the end of the row has been hit and begin new row if so */ + win = ctx->current; + layout = win->layout; + if (layout->row.index >= layout->row.columns) + nk_panel_alloc_row(ctx, win); + + /* calculate widget position and size */ + nk_layout_widget_space(bounds, ctx, win, nk_true); + layout->row.index++; +} +NK_LIB void +nk_layout_peek(struct nk_rect *bounds, struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_layout_peek"); + int y; + int index; + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + y = layout->at_y; + index = layout->row.index; + if (layout->row.index >= layout->row.columns) { + layout->at_y += layout->row.height; + layout->row.index = 0; + } + nk_layout_widget_space(bounds, ctx, win, nk_false); + if (!layout->row.index) { + bounds->x -= layout->row.item_offset; + } + layout->at_y = y; + layout->row.index = index; +} + + + + + +/* =============================================================== + * + * TREE + * + * ===============================================================*/ +NK_INTERN int +nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image *img, const char *title, enum nk_collapse_states *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - img / struct"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_style *style; + struct nk_command_buffer *out; + const struct nk_input *in; + const struct nk_style_button *button; + enum nk_symbol_type symbol; + int row_height; + + struct nk_vec2 item_spacing; + struct nk_rect header = {0,0,0,0}; + struct nk_rect sym = {0,0,0,0}; + struct nk_text text; + + nk_flags ws = 0; + enum nk_widget_layout_states widget_state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + /* cache some data */ + win = ctx->current; + layout = win->layout; + out = &win->buffer; + style = &ctx->style; + item_spacing = style->window.spacing; + + /* calculate header bounds and draw background */ + row_height = style->font->height + 2 * style->tab.padding.y; + nk_layout_set_min_row_height(ctx, row_height); + nk_layout_row_dynamic(ctx, row_height, 1); + nk_layout_reset_min_row_height(ctx); + + widget_state = nk_widget(&header, ctx); + if (type == NK_TREE_TAB) { + const struct nk_style_item *background = &style->tab.background; + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, header, &background->data.image, nk_white); + text.background = nk_rgba(0,0,0,0); + } else { + text.background = background->data.color; + nk_fill_rect(out, header, 0, style->tab.border_color); + nk_fill_rect(out, nk_shrink_rect(header, style->tab.border), + style->tab.rounding, background->data.color); + } + } else text.background = style->window.background; + + /* update node state */ + in = (!(layout->flags & NK_WINDOW_ROM)) ? &ctx->input: 0; + in = (in && widget_state == NK_WIDGET_VALID) ? &ctx->input : 0; + if (nk_button_behavior(&ws, header, in, NK_BUTTON_DEFAULT)) + *state = (*state == NK_MAXIMIZED) ? NK_MINIMIZED : NK_MAXIMIZED; + + /* select correct button style */ + if (*state == NK_MAXIMIZED) { + symbol = style->tab.sym_maximize; + if (type == NK_TREE_TAB) + button = &style->tab.tab_maximize_button; + else button = &style->tab.node_maximize_button; + } else { + symbol = style->tab.sym_minimize; + if (type == NK_TREE_TAB) + button = &style->tab.tab_minimize_button; + else button = &style->tab.node_minimize_button; + } + + {/* draw triangle button */ + sym.w = sym.h = style->font->height; + sym.y = header.y + style->tab.padding.y; + sym.x = header.x + style->tab.padding.x; + nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT, + button, 0, style->font); + + if (img) { + /* draw optional image icon */ + sym.x = sym.x + sym.w + 4 * item_spacing.x; + nk_draw_image(&win->buffer, sym, img, nk_white); + sym.w = style->font->height + style->tab.spacing.x;} + } + + {/* draw label */ + struct nk_rect label; + header.w = NK_MAX(header.w, sym.w + item_spacing.x); + label.x = sym.x + sym.w + item_spacing.x; + label.y = sym.y; + label.w = header.w - (sym.w + item_spacing.y + style->tab.indent); + label.h = style->font->height; + text.text = style->tab.text; + text.padding = nk_vec2(0,0); + nk_widget_text(out, label, title, strlen(title), &text, + NK_TEXT_LEFT, style->font);} + + /* increase x-axis cursor widget position pointer */ + if (*state == NK_MAXIMIZED) { + layout->at_x = header.x + (int)*layout->offset_x + style->tab.indent; + layout->bounds.w = NK_MAX(layout->bounds.w, style->tab.indent); + layout->bounds.w -= (style->tab.indent + style->window.padding.x); + layout->row.tree_depth++; + return nk_true; + } else return nk_false; +} +NK_INTERN int +nk_tree_base(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image *img, const char *title, enum nk_collapse_states initial_state, + const char *hash, int len, int line) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - hash / const"); + struct nk_window *win = ctx->current; + int title_len = 0; + nk_hash tree_hash = 0; + nk_uint *state = 0; + + /* retrieve tree state from internal widget state tables */ + if (!hash) { + title_len = (int)strlen(title); + tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line); + } else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line); + state = nk_find_value(win, tree_hash); + if (!state) { + state = nk_add_value(ctx, win, tree_hash, 0); + *state = initial_state; + } + return nk_tree_state_base(ctx, type, img, title, (enum nk_collapse_states*)state); +} +NK_API nk_bool +nk_tree_state_push(struct nk_context *ctx, enum nk_tree_type type, + const char *title, enum nk_collapse_states *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_tree_state_base(ctx, type, 0, title, state); +} +NK_API nk_bool +nk_tree_state_image_push(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image img, const char *title, enum nk_collapse_states *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - img / struct"); + return nk_tree_state_base(ctx, type, &img, title, state); +} +NK_API void +nk_tree_state_pop(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tree_state_pop"); + struct nk_window *win = 0; + struct nk_panel *layout = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + layout->at_x -= ctx->style.tab.indent + (int)*layout->offset_x; + layout->bounds.w += ctx->style.tab.indent + ctx->style.window.padding.x; + // NK_ASSERT(layout->row.tree_depth); + layout->row.tree_depth--; +} +NK_API nk_bool +nk_tree_push_hashed(struct nk_context *ctx, enum nk_tree_type type, + const char *title, enum nk_collapse_states initial_state, + const char *hash, int len, int line) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - hash / const"); + return nk_tree_base(ctx, type, 0, title, initial_state, hash, len, line); +} +NK_API nk_bool +nk_tree_image_push_hashed(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image img, const char *title, enum nk_collapse_states initial_state, + const char *hash, int len,int seed) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - hash / const"); + return nk_tree_base(ctx, type, &img, title, initial_state, hash, len, seed); +} +NK_API void +nk_tree_pop(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tree_pop"); + nk_tree_state_pop(ctx); +} +NK_INTERN int +nk_tree_element_image_push_hashed_base(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image *img, const char *title, int title_len, + enum nk_collapse_states *state, nk_bool *selected) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - state / enum"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_style *style; + struct nk_command_buffer *out; + const struct nk_input *in; + const struct nk_style_button *button; + enum nk_symbol_type symbol; + int row_height; + struct nk_vec2 padding; + + int text_len; + int text_width; + + struct nk_vec2 item_spacing; + struct nk_rect header = {0,0,0,0}; + struct nk_rect sym = {0,0,0,0}; + + nk_flags ws = 0; + enum nk_widget_layout_states widget_state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + /* cache some data */ + win = ctx->current; + layout = win->layout; + out = &win->buffer; + style = &ctx->style; + item_spacing = style->window.spacing; + padding = style->selectable.padding; + + /* calculate header bounds and draw background */ + row_height = style->font->height + 2 * style->tab.padding.y; + nk_layout_set_min_row_height(ctx, row_height); + nk_layout_row_dynamic(ctx, row_height, 1); + nk_layout_reset_min_row_height(ctx); + + widget_state = nk_widget(&header, ctx); + if (type == NK_TREE_TAB) { + const struct nk_style_item *background = &style->tab.background; + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, header, &background->data.image, nk_white); + } else { + nk_fill_rect(out, header, 0, style->tab.border_color); + nk_fill_rect(out, nk_shrink_rect(header, style->tab.border), + style->tab.rounding, background->data.color); + } + } + + in = (!(layout->flags & NK_WINDOW_ROM)) ? &ctx->input: 0; + in = (in && widget_state == NK_WIDGET_VALID) ? &ctx->input : 0; + + /* select correct button style */ + if (*state == NK_MAXIMIZED) { + symbol = style->tab.sym_maximize; + if (type == NK_TREE_TAB) + button = &style->tab.tab_maximize_button; + else button = &style->tab.node_maximize_button; + } else { + symbol = style->tab.sym_minimize; + if (type == NK_TREE_TAB) + button = &style->tab.tab_minimize_button; + else button = &style->tab.node_minimize_button; + } + {/* draw triangle button */ + sym.w = sym.h = style->font->height; + sym.y = header.y + style->tab.padding.y; + sym.x = header.x + style->tab.padding.x; + if (nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT, button, in, style->font)) + *state = (*state == NK_MAXIMIZED) ? NK_MINIMIZED : NK_MAXIMIZED;} + + /* draw label */ + {nk_flags dummy = 0; + struct nk_rect label; + /* calculate size of the text and tooltip */ + text_len = strlen(title); + text_width = style->font->width(style->font->userdata, style->font->height, title, text_len); + text_width += (4 * padding.x); + + header.w = NK_MAX(header.w, sym.w + item_spacing.x); + label.x = sym.x + sym.w + item_spacing.x; + label.y = sym.y; + label.w = NK_MIN(header.w - (sym.w + item_spacing.y + style->tab.indent), text_width); + label.h = style->font->height; + + if (img) { + nk_do_selectable_image(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT, + selected, img, &style->selectable, in, style->font); + } else nk_do_selectable(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT, + selected, &style->selectable, in, style->font); + } + /* increase x-axis cursor widget position pointer */ + if (*state == NK_MAXIMIZED) { + layout->at_x = header.x + (int)*layout->offset_x + style->tab.indent; + layout->bounds.w = NK_MAX(layout->bounds.w, style->tab.indent); + layout->bounds.w -= (style->tab.indent + style->window.padding.x); + layout->row.tree_depth++; + return nk_true; + } else return nk_false; +} +NK_INTERN int +nk_tree_element_base(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image *img, const char *title, enum nk_collapse_states initial_state, + nk_bool *selected, const char *hash, int len, int line) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / nk_bool"); + struct nk_window *win = ctx->current; + int title_len = 0; + nk_hash tree_hash = 0; + nk_uint *state = 0; + + /* retrieve tree state from internal widget state tables */ + if (!hash) { + title_len = (int)strlen(title); + tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line); + } else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line); + state = nk_find_value(win, tree_hash); + if (!state) { + state = nk_add_value(ctx, win, tree_hash, 0); + *state = initial_state; + } return nk_tree_element_image_push_hashed_base(ctx, type, img, title, + strlen(title), (enum nk_collapse_states*)state, selected); +} +NK_API nk_bool +nk_tree_element_push_hashed(struct nk_context *ctx, enum nk_tree_type type, + const char *title, enum nk_collapse_states initial_state, + nk_bool *selected, const char *hash, int len, int seed) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / nk_bool"); + return nk_tree_element_base(ctx, type, 0, title, initial_state, selected, hash, len, seed); +} +NK_API nk_bool +nk_tree_element_image_push_hashed(struct nk_context *ctx, enum nk_tree_type type, + struct nk_image img, const char *title, enum nk_collapse_states initial_state, + nk_bool *selected, const char *hash, int len,int seed) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / nk_bool"); + return nk_tree_element_base(ctx, type, &img, title, initial_state, selected, hash, len, seed); +} +NK_API void +nk_tree_element_pop(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tree_element_pop"); + nk_tree_state_pop(ctx); +} + + + + + +/* =============================================================== + * + * GROUP + * + * ===============================================================*/ +NK_API nk_bool +nk_group_scrolled_offset_begin(struct nk_context *ctx, + nk_uint *x_offset, nk_uint *y_offset, const char *title, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - x_offset, / nk_uint"); + struct nk_rect bounds; + struct nk_window panel; + struct nk_window *win; + + win = ctx->current; + nk_panel_alloc_space(&bounds, ctx); + {const struct nk_rect *c = &win->layout->clip; + if (!NK_INTERSECT(c->x, c->y, c->w, c->h, bounds.x, bounds.y, bounds.w, bounds.h) && !(flags & NK_WINDOW_MOVABLE)) { + return 0; + }} + if (win->flags & NK_WINDOW_ROM) + flags |= NK_WINDOW_ROM; + + /* initialize a fake window to create the panel from */ + nk_zero(&panel, sizeof(panel)); + panel.bounds = bounds; + panel.flags = flags; + panel.scrollbar.x = *x_offset; + panel.scrollbar.y = *y_offset; + panel.buffer = win->buffer; + panel.layout = (struct nk_panel*)nk_create_panel(ctx); + ctx->current = &panel; + nk_panel_begin(ctx, (flags & NK_WINDOW_TITLE) ? title: 0, NK_PANEL_GROUP); + + win->buffer = panel.buffer; + win->buffer.clip = panel.layout->clip; + panel.layout->offset_x = x_offset; + panel.layout->offset_y = y_offset; + panel.layout->parent = win->layout; + win->layout = panel.layout; + + ctx->current = win; + if ((panel.layout->flags & NK_WINDOW_CLOSED) || + (panel.layout->flags & NK_WINDOW_MINIMIZED)) + { + nk_flags f = panel.layout->flags; + nk_group_scrolled_end(ctx); + if (f & NK_WINDOW_CLOSED) + return NK_WINDOW_CLOSED; + if (f & NK_WINDOW_MINIMIZED) + return NK_WINDOW_MINIMIZED; + } + return 1; +} +NK_API void +nk_group_scrolled_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_group_scrolled_end"); + struct nk_window *win; + struct nk_panel *parent; + struct nk_panel *g; + + struct nk_rect clip; + struct nk_window pan; + struct nk_vec2 panel_padding; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return; + + /* make sure nk_group_begin was called correctly */ + // NK_ASSERT(ctx->current); + win = ctx->current; + // NK_ASSERT(win->layout); + g = win->layout; + // NK_ASSERT(g->parent); + parent = g->parent; + + /* dummy window */ + nk_zero_struct(pan); + panel_padding = nk_panel_get_padding(&ctx->style, NK_PANEL_GROUP); + pan.bounds.y = g->bounds.y - (g->header_height + g->menu.h); + pan.bounds.x = g->bounds.x - panel_padding.x; + pan.bounds.w = g->bounds.w + 2 * panel_padding.x; + pan.bounds.h = g->bounds.h + g->header_height + g->menu.h; + if (g->flags & NK_WINDOW_BORDER) { + pan.bounds.x -= g->border; + pan.bounds.y -= g->border; + pan.bounds.w += 2*g->border; + pan.bounds.h += 2*g->border; + } + if (!(g->flags & NK_WINDOW_NO_SCROLLBAR)) { + pan.bounds.w += ctx->style.window.scrollbar_size.x; + pan.bounds.h += ctx->style.window.scrollbar_size.y; + } + pan.scrollbar.x = *g->offset_x; + pan.scrollbar.y = *g->offset_y; + pan.flags = g->flags; + pan.buffer = win->buffer; + pan.layout = g; + pan.parent = win; + ctx->current = &pan; + + /* make sure group has correct clipping rectangle */ + nk_unify(&clip, &parent->clip, pan.bounds.x, pan.bounds.y, + pan.bounds.x + pan.bounds.w, pan.bounds.y + pan.bounds.h + panel_padding.x); + // nk_push_scissor(&pan.buffer, clip); + nk_end(ctx); + + win->buffer = pan.buffer; + // nk_push_scissor(&win->buffer, parent->clip); + ctx->current = win; + win->layout = parent; + g->bounds = pan.bounds; + return; +} +NK_API nk_bool +nk_group_scrolled_begin(struct nk_context *ctx, + struct nk_scroll *scroll, const char *title, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - scroll / struct"); + return nk_group_scrolled_offset_begin(ctx, &scroll->x, &scroll->y, title, flags); +} +NK_API nk_bool +nk_group_begin_titled(struct nk_context *ctx, const char *id, + const char *title, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + int id_len; + nk_hash id_hash; + struct nk_window *win; + nk_uint *x_offset; + nk_uint *y_offset; + + // NK_ASSERT(ctx); + // NK_ASSERT(id); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !id) + return 0; + + /* find persistent group scrollbar value */ + win = ctx->current; + id_len = (int)strlen(id); + id_hash = nk_murmur_hash(id, (int)id_len, NK_PANEL_GROUP); + x_offset = nk_find_value(win, id_hash); + if (!x_offset) { + x_offset = nk_add_value(ctx, win, id_hash, 0); + y_offset = nk_add_value(ctx, win, id_hash+1, 0); + + // NK_ASSERT(x_offset); + // NK_ASSERT(y_offset); + if (!x_offset || !y_offset) return 0; + *x_offset = *y_offset = 0; + } else y_offset = nk_find_value(win, id_hash+1); + return nk_group_scrolled_offset_begin(ctx, x_offset, y_offset, title, flags); +} +NK_API nk_bool +nk_group_begin(struct nk_context *ctx, const char *title, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_group_begin"); + return nk_group_begin_titled(ctx, title, title, flags); +} +NK_API void +nk_group_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_group_end"); + nk_group_scrolled_end(ctx); +} +NK_API void +nk_group_get_scroll(struct nk_context *ctx, const char *id, nk_uint *x_offset, nk_uint *y_offset) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_group_get_scroll"); + int id_len; + nk_hash id_hash; + struct nk_window *win; + nk_uint *x_offset_ptr; + nk_uint *y_offset_ptr; + + // NK_ASSERT(ctx); + // NK_ASSERT(id); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !id) + return; + + /* find persistent group scrollbar value */ + win = ctx->current; + id_len = (int)strlen(id); + id_hash = nk_murmur_hash(id, (int)id_len, NK_PANEL_GROUP); + x_offset_ptr = nk_find_value(win, id_hash); + if (!x_offset_ptr) { + x_offset_ptr = nk_add_value(ctx, win, id_hash, 0); + y_offset_ptr = nk_add_value(ctx, win, id_hash+1, 0); + + // NK_ASSERT(x_offset_ptr); + // NK_ASSERT(y_offset_ptr); + if (!x_offset_ptr || !y_offset_ptr) return; + *x_offset_ptr = *y_offset_ptr = 0; + } else y_offset_ptr = nk_find_value(win, id_hash+1); + if (x_offset) + *x_offset = *x_offset_ptr; + if (y_offset) + *y_offset = *y_offset_ptr; +} +NK_API void +nk_group_set_scroll(struct nk_context *ctx, const char *id, nk_uint x_offset, nk_uint y_offset) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_group_set_scroll"); + int id_len; + nk_hash id_hash; + struct nk_window *win; + nk_uint *x_offset_ptr; + nk_uint *y_offset_ptr; + + // NK_ASSERT(ctx); + // NK_ASSERT(id); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !id) + return; + + /* find persistent group scrollbar value */ + win = ctx->current; + id_len = (int)strlen(id); + id_hash = nk_murmur_hash(id, (int)id_len, NK_PANEL_GROUP); + x_offset_ptr = nk_find_value(win, id_hash); + if (!x_offset_ptr) { + x_offset_ptr = nk_add_value(ctx, win, id_hash, 0); + y_offset_ptr = nk_add_value(ctx, win, id_hash+1, 0); + + // NK_ASSERT(x_offset_ptr); + // NK_ASSERT(y_offset_ptr); + if (!x_offset_ptr || !y_offset_ptr) return; + *x_offset_ptr = *y_offset_ptr = 0; + } else y_offset_ptr = nk_find_value(win, id_hash+1); + *x_offset_ptr = x_offset; + *y_offset_ptr = y_offset; +} + + + + +/* =============================================================== + * + * LIST VIEW + * + * ===============================================================*/ +NK_API nk_bool +nk_list_view_begin(struct nk_context *ctx, struct nk_list_view *view, + const char *title, nk_flags flags, int row_height, int row_count) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + int title_len; + nk_hash title_hash; + nk_uint *x_offset; + nk_uint *y_offset; + + int result; + struct nk_window *win; + struct nk_panel *layout; + const struct nk_style *style; + struct nk_vec2 item_spacing; + + // NK_ASSERT(ctx); + // NK_ASSERT(view); + // NK_ASSERT(title); + if (!ctx || !view || !title) return 0; + + win = ctx->current; + style = &ctx->style; + item_spacing = style->window.spacing; + row_height += NK_MAX(0, (int)item_spacing.y); + + /* find persistent list view scrollbar offset */ + title_len = (int)strlen(title); + title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_GROUP); + x_offset = nk_find_value(win, title_hash); + if (!x_offset) { + x_offset = nk_add_value(ctx, win, title_hash, 0); + y_offset = nk_add_value(ctx, win, title_hash+1, 0); + + // NK_ASSERT(x_offset); + // NK_ASSERT(y_offset); + if (!x_offset || !y_offset) return 0; + *x_offset = *y_offset = 0; + } else y_offset = nk_find_value(win, title_hash+1); + view->scroll_value = *y_offset; + view->scroll_pointer = y_offset; + + *y_offset = 0; + result = nk_group_scrolled_offset_begin(ctx, x_offset, y_offset, title, flags); + win = ctx->current; + layout = win->layout; + + view->total_height = row_height * NK_MAX(row_count,1); + view->begin = (int)NK_MAX(((int)view->scroll_value / (int)row_height), 0.0f); + view->count = (int)NK_MAX(nk_iceilf((layout->clip.h)/(int)row_height),0); + view->count = NK_MIN(view->count, row_count - view->begin); + view->end = view->begin + view->count; + view->ctx = ctx; + return result; +} +NK_API void +nk_list_view_end(struct nk_list_view *view) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_list_view / nk_list_view_end"); + struct nk_context *ctx; + struct nk_window *win; + struct nk_panel *layout; + + // NK_ASSERT(view); + // NK_ASSERT(view->ctx); + // NK_ASSERT(view->scroll_pointer); + if (!view || !view->ctx) return; + + ctx = view->ctx; + win = ctx->current; + layout = win->layout; + layout->at_y = layout->bounds.y + (int)view->total_height; + *view->scroll_pointer = *view->scroll_pointer + view->scroll_value; + nk_group_end(view->ctx); +} + + + + + +/* =============================================================== + * + * WIDGET + * + * ===============================================================*/ +NK_API struct nk_rect +nk_widget_bounds(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_bounds"); + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return nk_rect(0,0,0,0); + nk_layout_peek(&bounds, ctx); + return bounds; +} +NK_API struct nk_vec2 +nk_widget_position(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_position"); + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return nk_vec2(0,0); + + nk_layout_peek(&bounds, ctx); + return nk_vec2(bounds.x, bounds.y); +} +NK_API struct nk_vec2 +nk_widget_size(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_size"); + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return nk_vec2(0,0); + + nk_layout_peek(&bounds, ctx); + return nk_vec2(bounds.w, bounds.h); +} +NK_API int +nk_widget_width(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_width"); + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return 0; + + nk_layout_peek(&bounds, ctx); + return bounds.w; +} +NK_API int +nk_widget_height(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_height"); + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return 0; + + nk_layout_peek(&bounds, ctx); + return bounds.h; +} +NK_API nk_bool +nk_widget_is_hovered(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_is_hovered"); + struct nk_rect c, v; + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current || ctx->active != ctx->current) + return 0; + + c = ctx->current->layout->clip; + c.x = (int)((int)c.x); + c.y = (int)((int)c.y); + c.w = (int)((int)c.w); + c.h = (int)((int)c.h); + + nk_layout_peek(&bounds, ctx); + nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h); + if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h)) + return 0; + return nk_input_is_mouse_hovering_rect(&ctx->input, bounds); +} +NK_API nk_bool +nk_widget_is_mouse_clicked(struct nk_context *ctx, enum nk_buttons btn) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_is_mouse_clicked"); + struct nk_rect c, v; + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current || ctx->active != ctx->current) + return 0; + + c = ctx->current->layout->clip; + c.x = (int)((int)c.x); + c.y = (int)((int)c.y); + c.w = (int)((int)c.w); + c.h = (int)((int)c.h); + + nk_layout_peek(&bounds, ctx); + nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h); + if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h)) + return 0; + return nk_input_mouse_clicked(&ctx->input, btn, bounds); +} +NK_API nk_bool +nk_widget_has_mouse_click_down(struct nk_context *ctx, enum nk_buttons btn, nk_bool down) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_widget_has_mouse_click_down"); + struct nk_rect c, v; + struct nk_rect bounds; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current || ctx->active != ctx->current) + return 0; + + c = ctx->current->layout->clip; + c.x = (int)((int)c.x); + c.y = (int)((int)c.y); + c.w = (int)((int)c.w); + c.h = (int)((int)c.h); + + nk_layout_peek(&bounds, ctx); + nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h); + if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h)) + return 0; + return nk_input_has_mouse_click_down_in_rect(&ctx->input, btn, bounds, down); +} +NK_API enum nk_widget_layout_states +nk_widget(struct nk_rect *bounds, const struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / nk_widget"); + struct nk_rect c, v; + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return NK_WIDGET_INVALID; + + /* allocate space and check if the widget needs to be updated and drawn */ + nk_panel_alloc_space(bounds, ctx); + win = ctx->current; + layout = win->layout; + in = &ctx->input; + c = layout->clip; + + /* if one of these triggers you forgot to add an `if` condition around either + a window, group, popup, combobox or contextual menu `begin` and `end` block. + Example: + if (nk_begin(...) {...} nk_end(...); or + if (nk_group_begin(...) { nk_group_end(...);} */ + // NK_ASSERT(!(layout->flags & NK_WINDOW_MINIMIZED)); + // NK_ASSERT(!(layout->flags & NK_WINDOW_HIDDEN)); + // NK_ASSERT(!(layout->flags & NK_WINDOW_CLOSED)); + + /* need to convert to int here to remove inting point errors */ + bounds->x = (int)((int)bounds->x); + bounds->y = (int)((int)bounds->y); + bounds->w = (int)((int)bounds->w); + bounds->h = (int)((int)bounds->h); + + c.x = (int)((int)c.x); + c.y = (int)((int)c.y); + c.w = (int)((int)c.w); + c.h = (int)((int)c.h); + + nk_unify(&v, &c, bounds->x, bounds->y, bounds->x + bounds->w, bounds->y + bounds->h); + if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds->x, bounds->y, bounds->w, bounds->h)) + return NK_WIDGET_INVALID; + if (!NK_INBOX(in->mouse.pos.x, in->mouse.pos.y, v.x, v.y, v.w, v.h)) + return NK_WIDGET_ROM; + return NK_WIDGET_VALID; +} +NK_API enum nk_widget_layout_states +nk_widget_fitting(struct nk_rect *bounds, struct nk_context *ctx, + struct nk_vec2 item_padding) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - item_padding / struct"); + /* update the bounds to stand without padding */ + enum nk_widget_layout_states state; + NK_UNUSED(item_padding); + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return NK_WIDGET_INVALID; + + state = nk_widget(bounds, ctx); + return state; +} +NK_API void +nk_spacing(struct nk_context *ctx, int cols) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_spacing"); + struct nk_window *win; + struct nk_panel *layout; + struct nk_rect none; + int i, index, rows; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + /* spacing over row boundaries */ + win = ctx->current; + layout = win->layout; + index = (layout->row.index + cols) % layout->row.columns; + rows = (layout->row.index + cols) / layout->row.columns; + if (rows) { + for (i = 0; i < rows; ++i) + nk_panel_alloc_row(ctx, win); + cols = index; + } + /* non table layout need to allocate space */ + if (layout->row.type != NK_LAYOUT_DYNAMIC_FIXED && layout->row.type != NK_LAYOUT_STATIC_FIXED) { + for (i = 0; i < cols; ++i) + nk_panel_alloc_space(&none, ctx); + } layout->row.index = index; +} + + + + + +/* =============================================================== + * + * TEXT + * + * ===============================================================*/ +NK_LIB void +nk_widget_text(struct nk_command_buffer *o, struct nk_rect b, + const char *string, int len, const struct nk_text *t, + nk_flags a, const struct nk_user_font *f) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_widget_text"); + struct nk_rect label; + int text_width; + + if (!o || !t) return; + + b.h = NK_MAX(b.h, 2 * t->padding.y); + label.x = 0; label.w = 0; + label.y = b.y + t->padding.y; + label.h = NK_MIN(f->height, b.h - 2 * t->padding.y); + + text_width = f->width(f->userdata, f->height, (const char*)string, len); + text_width += (2.0f * t->padding.x); + + /* align in x-axis */ + if (a & NK_TEXT_ALIGN_LEFT) { + label.x = b.x + t->padding.x; + label.w = NK_MAX(0, b.w - 2 * t->padding.x); + } else if (a & NK_TEXT_ALIGN_CENTERED) { + label.w = NK_MAX(1, 2 * t->padding.x + (int)text_width); + label.x = (b.x + t->padding.x + ((b.w - 2 * t->padding.x) - label.w) / 2); + label.x = NK_MAX(b.x + t->padding.x, label.x); + label.w = NK_MIN(b.x + b.w, label.x + label.w); + if (label.w >= label.x) label.w -= label.x; + } else if (a & NK_TEXT_ALIGN_RIGHT) { + label.x = NK_MAX(b.x + t->padding.x, (b.x + b.w) - (2 * t->padding.x + (int)text_width)); + label.w = (int)text_width + 2 * t->padding.x; + } else return; + + /* align in y-axis */ + if (a & NK_TEXT_ALIGN_MIDDLE) { + label.y = b.y + b.h/2.0f - (int)f->height/2.0f; + label.h = NK_MAX(b.h/2.0f, b.h - (b.h/2.0f + f->height/2.0f)); + } else if (a & NK_TEXT_ALIGN_BOTTOM) { + label.y = b.y + b.h - f->height; + label.h = f->height; + } + nk_draw_text(o, label, (const char*)string, len, f, t->background, t->text); +} +NK_LIB void +nk_widget_text_wrap(struct nk_command_buffer *o, struct nk_rect b, + const char *string, int len, const struct nk_text *t, + const struct nk_user_font *f) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int width; + int glyphs = 0; + int fitting = 0; + int done = 0; + struct nk_rect line; + struct nk_text text; + NK_INTERN nk_rune seperator[] = {' '}; + + // NK_ASSERT(o); + // NK_ASSERT(t); + if (!o || !t) return; + + text.padding = nk_vec2(0,0); + text.background = t->background; + text.text = t->text; + + b.w = NK_MAX(b.w, 2 * t->padding.x); + b.h = NK_MAX(b.h, 2 * t->padding.y); + b.h = b.h - 2 * t->padding.y; + + line.x = b.x + t->padding.x; + line.y = b.y + t->padding.y; + line.w = b.w - 2 * t->padding.x; + line.h = 2 * t->padding.y + f->height; + + fitting = nk_text_clamp(f, string, len, line.w, &glyphs, &width, seperator,NK_LEN(seperator)); + while (done < len) { + if (!fitting || line.y + line.h >= (b.y + b.h)) break; + nk_widget_text(o, line, &string[done], fitting, &text, NK_TEXT_LEFT, f); + done += fitting; + line.y += f->height + 2 * t->padding.y; + fitting = nk_text_clamp(f, &string[done], len - done, line.w, &glyphs, &width, seperator,NK_LEN(seperator)); + } +} +NK_API void +nk_text_colored(struct nk_context *ctx, const char *str, int len, + nk_flags alignment, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - alignment, / nk_flags"); + struct nk_window *win; + const struct nk_style *style; + + struct nk_vec2 item_padding; + struct nk_rect bounds; + struct nk_text text; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return; + + win = ctx->current; + style = &ctx->style; + nk_panel_alloc_space(&bounds, ctx); + item_padding = style->text.padding; + + text.padding.x = item_padding.x; + text.padding.y = item_padding.y; + text.background = style->window.background; + text.text = color; + nk_widget_text(&win->buffer, bounds, str, len, &text, alignment, style->font); +} +NK_API void +nk_text_wrap_colored(struct nk_context *ctx, const char *str, + int len, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - len, / int"); + struct nk_window *win; + const struct nk_style *style; + + struct nk_vec2 item_padding; + struct nk_rect bounds; + struct nk_text text; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return; + + win = ctx->current; + style = &ctx->style; + nk_panel_alloc_space(&bounds, ctx); + item_padding = style->text.padding; + + text.padding.x = item_padding.x; + text.padding.y = item_padding.y; + text.background = style->window.background; + text.text = color; + nk_widget_text_wrap(&win->buffer, bounds, str, len, &text, style->font); +} +#ifdef NK_INCLUDE_STANDARD_VARARGS +NK_API void +nk_labelf_colored(struct nk_context *ctx, nk_flags flags, + struct nk_color color, const char *fmt, ...) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + va_list args; + va_start(args, fmt); + nk_labelfv_colored(ctx, flags, color, fmt, args); + va_end(args); +} +NK_API void +nk_labelf_colored_wrap(struct nk_context *ctx, struct nk_color color, + const char *fmt, ...) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fmt / const"); + va_list args; + va_start(args, fmt); + nk_labelfv_colored_wrap(ctx, color, fmt, args); + va_end(args); +} +NK_API void +nk_labelf(struct nk_context *ctx, nk_flags flags, const char *fmt, ...) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_labelf"); + va_list args; + va_start(args, fmt); + nk_labelfv(ctx, flags, fmt, args); + va_end(args); +} +NK_API void +nk_labelf_wrap(struct nk_context *ctx, const char *fmt,...) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_labelf_wrap"); + va_list args; + va_start(args, fmt); + nk_labelfv_wrap(ctx, fmt, args); + va_end(args); +} +NK_API void +nk_labelfv_colored(struct nk_context *ctx, nk_flags flags, + struct nk_color color, const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + char buf[256]; + nk_strfmt(buf, NK_LEN(buf), fmt, args); + nk_label_colored(ctx, buf, flags, color); +} + +NK_API void +nk_labelfv_colored_wrap(struct nk_context *ctx, struct nk_color color, + const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fmt / const"); + char buf[256]; + nk_strfmt(buf, NK_LEN(buf), fmt, args); + nk_label_colored_wrap(ctx, buf, color); +} + +NK_API void +nk_labelfv(struct nk_context *ctx, nk_flags flags, const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_labelfv"); + char buf[256]; + nk_strfmt(buf, NK_LEN(buf), fmt, args); + nk_label(ctx, buf, flags); +} + +NK_API void +nk_labelfv_wrap(struct nk_context *ctx, const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_labelfv_wrap"); + char buf[256]; + nk_strfmt(buf, NK_LEN(buf), fmt, args); + nk_label_wrap(ctx, buf); +} + +NK_API void +nk_value_bool(struct nk_context *ctx, const char *prefix, int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_bool"); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: %s", prefix, ((value) ? "true": "false")); +} +NK_API void +nk_value_int(struct nk_context *ctx, const char *prefix, int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_int"); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: %d", prefix, value); +} +NK_API void +nk_value_uint(struct nk_context *ctx, const char *prefix, unsigned int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_uint"); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: %u", prefix, value); +} +// NK_API void +// nk_value_int(struct nk_context *ctx, const char *prefix, int value) +// { +// double double_value = (double)value; +// nk_labelf(ctx, NK_TEXT_LEFT, "%s: %.3f", prefix, double_value); +// } +NK_API void +nk_value_color_byte(struct nk_context *ctx, const char *p, struct nk_color c) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_color_byte"); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: (%d, %d, %d, %d)", p, c.r, c.g, c.b, c.a); +} +NK_API void +nk_value_color_int(struct nk_context *ctx, const char *p, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_color_int"); + double c[4]; nk_color_dv(c, color); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: (%.2f, %.2f, %.2f, %.2f)", + p, c[0], c[1], c[2], c[3]); +} +NK_API void +nk_value_color_hex(struct nk_context *ctx, const char *prefix, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_value_color_hex"); + char hex[16]; + nk_color_hex_rgba(hex, color); + nk_labelf(ctx, NK_TEXT_LEFT, "%s: %s", prefix, hex); +} +#endif +NK_API void +nk_text(struct nk_context *ctx, const char *str, int len, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_text"); + // NK_ASSERT(ctx); + if (!ctx) return; + nk_text_colored(ctx, str, len, alignment, ctx->style.text.color); +} +NK_API void +nk_text_wrap(struct nk_context *ctx, const char *str, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_text_wrap"); + // NK_ASSERT(ctx); + if (!ctx) return; + nk_text_wrap_colored(ctx, str, len, ctx->style.text.color); +} +NK_API void +nk_label(struct nk_context *ctx, const char *str, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_label"); + nk_text(ctx, str, strlen(str), alignment); +} +NK_API void +nk_label_colored(struct nk_context *ctx, const char *str, nk_flags align, + struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + nk_text_colored(ctx, str, strlen(str), align, color); +} +NK_API void +nk_label_wrap(struct nk_context *ctx, const char *str) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_label_wrap"); + nk_text_wrap(ctx, str, strlen(str)); +} +NK_API void +nk_label_colored_wrap(struct nk_context *ctx, const char *str, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_label_colored_wrap"); + nk_text_wrap_colored(ctx, str, strlen(str), color); +} + + + + + +/* =============================================================== + * + * IMAGE + * + * ===============================================================*/ +NK_API nk_handle +nk_handle_ptr(void *ptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - ptr / nk_handle_ptr"); + nk_handle handle = {0}; + handle.ptr = ptr; + return handle; +} +NK_API nk_handle +nk_handle_id(int id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - id / nk_handle_id"); + nk_handle handle; + nk_zero_struct(handle); + handle.id = id; + return handle; +} +NK_API struct nk_image +nk_subimage_ptr(void *ptr, unsigned short w, unsigned short h, struct nk_rect r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - ptr / nk_subimage_ptr"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle.ptr = ptr; + s.w = w; s.h = h; + s.region[0] = (unsigned short)r.x; + s.region[1] = (unsigned short)r.y; + s.region[2] = (unsigned short)r.w; + s.region[3] = (unsigned short)r.h; + return s; +} +NK_API struct nk_image +nk_subimage_id(int id, unsigned short w, unsigned short h, struct nk_rect r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - id / nk_subimage_id"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle.id = id; + s.w = w; s.h = h; + s.region[0] = (unsigned short)r.x; + s.region[1] = (unsigned short)r.y; + s.region[2] = (unsigned short)r.w; + s.region[3] = (unsigned short)r.h; + return s; +} +NK_API struct nk_image +nk_subimage_handle(nk_handle handle, unsigned short w, unsigned short h, + struct nk_rect r) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / struct"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle = handle; + s.w = w; s.h = h; + s.region[0] = (unsigned short)r.x; + s.region[1] = (unsigned short)r.y; + s.region[2] = (unsigned short)r.w; + s.region[3] = (unsigned short)r.h; + return s; +} +NK_API struct nk_image +nk_image_handle(nk_handle handle) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - handle / nk_image_handle"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle = handle; + s.w = 0; s.h = 0; + s.region[0] = 0; + s.region[1] = 0; + s.region[2] = 0; + s.region[3] = 0; + return s; +} +NK_API struct nk_image +nk_image_ptr(void *ptr) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - ptr / nk_image_ptr"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + // NK_ASSERT(ptr); + s.handle.ptr = ptr; + s.w = 0; s.h = 0; + s.region[0] = 0; + s.region[1] = 0; + s.region[2] = 0; + s.region[3] = 0; + return s; +} +NK_API struct nk_image +nk_image_id(int id) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - id / nk_image_id"); + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle.id = id; + s.w = 0; s.h = 0; + s.region[0] = 0; + s.region[1] = 0; + s.region[2] = 0; + s.region[3] = 0; + return s; +} +NK_API nk_bool +nk_image_is_subimage(const struct nk_image* img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_image_is_subimage"); + // NK_ASSERT(img); + return !(img->w == 0 && img->h == 0); +} +NK_API void +nk_image(struct nk_context *ctx, struct nk_image img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_image"); + struct nk_window *win; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return; + + win = ctx->current; + if (!nk_widget(&bounds, ctx)) return; + nk_draw_image(&win->buffer, bounds, &img, nk_white); +} +NK_API void +nk_image_color(struct nk_context *ctx, struct nk_image img, struct nk_color col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_image_color"); + struct nk_window *win; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) return; + + win = ctx->current; + if (!nk_widget(&bounds, ctx)) return; + nk_draw_image(&win->buffer, bounds, &img, col); +} + + + + + +/* ============================================================== + * + * BUTTON + * + * ===============================================================*/ +NK_LIB void +nk_draw_symbol(struct nk_command_buffer *out, enum nk_symbol_type type, + struct nk_rect content, struct nk_color background, struct nk_color foreground, + int border_width, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - border_width, / int"); + switch (type) { + case NK_SYMBOL_X: + case NK_SYMBOL_UNDERSCORE: + case NK_SYMBOL_PLUS: + case NK_SYMBOL_MINUS: { + /* single character text symbol */ + const char *X = (type == NK_SYMBOL_X) ? "x": + (type == NK_SYMBOL_UNDERSCORE) ? "_": + (type == NK_SYMBOL_PLUS) ? "+": "-"; + struct nk_text text; + text.padding = nk_vec2(0,0); + text.background = background; + text.text = foreground; + nk_widget_text(out, content, X, 1, &text, NK_TEXT_CENTERED, font); + } break; + case NK_SYMBOL_CIRCLE_SOLID: + case NK_SYMBOL_CIRCLE_OUTLINE: + case NK_SYMBOL_RECT_SOLID: + case NK_SYMBOL_RECT_OUTLINE: { + /* simple empty/filled shapes */ + if (type == NK_SYMBOL_RECT_SOLID || type == NK_SYMBOL_RECT_OUTLINE) { + nk_fill_rect(out, content, 0, foreground); + if (type == NK_SYMBOL_RECT_OUTLINE) + nk_fill_rect(out, nk_shrink_rect(content, border_width), 0, background); + } else { + nk_fill_circle(out, content, foreground); + if (type == NK_SYMBOL_CIRCLE_OUTLINE) + nk_fill_circle(out, nk_shrink_rect(content, 1), background); + } + } break; + case NK_SYMBOL_TRIANGLE_UP: + case NK_SYMBOL_TRIANGLE_DOWN: + case NK_SYMBOL_TRIANGLE_LEFT: + case NK_SYMBOL_TRIANGLE_RIGHT: { + enum nk_heading heading; + struct nk_vec2 points[3]; + heading = (type == NK_SYMBOL_TRIANGLE_RIGHT) ? NK_RIGHT : + (type == NK_SYMBOL_TRIANGLE_LEFT) ? NK_LEFT: + (type == NK_SYMBOL_TRIANGLE_UP) ? NK_UP: NK_DOWN; + nk_triangle_from_direction(points, content, 0, 0, heading); + nk_fill_triangle(out, points[0].x, points[0].y, points[1].x, points[1].y, + points[2].x, points[2].y, foreground); + } break; + default: + case NK_SYMBOL_NONE: + case NK_SYMBOL_MAX: break; + } +} +NK_LIB nk_bool +nk_button_behavior(nk_flags *state, struct nk_rect r, + const struct nk_input *i, enum nk_button_behavior behavior) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input / const"); + int ret = 0; + nk_widget_state_reset(state); + if (!i) return 0; + if (nk_input_is_mouse_hovering_rect(i, r)) { + *state = NK_WIDGET_STATE_HOVERED; + if (nk_input_is_mouse_down(i, NK_BUTTON_LEFT)) + *state = NK_WIDGET_STATE_ACTIVE; + if (nk_input_has_mouse_click_in_rect(i, NK_BUTTON_LEFT, r)) { + ret = (behavior != NK_BUTTON_DEFAULT) ? + nk_input_is_mouse_down(i, NK_BUTTON_LEFT): +#ifdef NK_BUTTON_TRIGGER_ON_RELEASE + nk_input_is_mouse_released(i, NK_BUTTON_LEFT); +#else + nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT); +#endif + } + } + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(i, r)) + *state |= NK_WIDGET_STATE_LEFT; + return ret; +} +NK_LIB const struct nk_style_item* +nk_draw_button(struct nk_command_buffer *out, + const struct nk_rect *bounds, nk_flags state, + const struct nk_style_button *style) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_button / const"); + const struct nk_style_item *background; + if (state & NK_WIDGET_STATE_HOVER) + background = &style->hover; + else if (state & NK_WIDGET_STATE_ACTIVED) + background = &style->active; + else background = &style->normal; + + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, *bounds, &background->data.image, nk_white); + } else { + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color); + } + return background; +} +NK_LIB nk_bool +nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, + const struct nk_style_button *style, const struct nk_input *in, + enum nk_button_behavior behavior, struct nk_rect *content) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - behavior / enum"); + struct nk_rect bounds; + + if (!out || !style) + return nk_false; + + /* calculate button content space */ + content->x = r.x + style->padding.x + style->border + style->rounding; + content->y = r.y + style->padding.y + style->border + style->rounding; + content->w = r.w - (2 * style->padding.x + style->border + style->rounding*2); + content->h = r.h - (2 * style->padding.y + style->border + style->rounding*2); + + /* execute button behavior */ + bounds.x = r.x - style->touch_padding.x; + bounds.y = r.y - style->touch_padding.y; + bounds.w = r.w + 2 * style->touch_padding.x; + bounds.h = r.h + 2 * style->touch_padding.y; + return nk_button_behavior(state, bounds, in, behavior); +} +NK_LIB void +nk_draw_button_text(struct nk_command_buffer *out, + const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, + const struct nk_style_button *style, const char *txt, int len, + nk_flags text_alignment, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_button_text"); + struct nk_text text; + nk_draw_button(out, bounds, state, style); + + text.padding = nk_vec2(0,0); + nk_widget_text(out, *content, txt, len, &text, text_alignment, font); +} +NK_LIB nk_bool +nk_do_button_text(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + const char *string, int len, nk_flags align, enum nk_button_behavior behavior, + const struct nk_style_button *style, const struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_do_button_text"); + struct nk_rect content; + int ret = nk_false; + + // NK_ASSERT(state); + // NK_ASSERT(style); + // NK_ASSERT(out); + // NK_ASSERT(string); + // NK_ASSERT(font); + if (!out || !style || !font || !string) + return nk_false; + + ret = nk_do_button(state, out, bounds, style, in, behavior, &content); + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_button_text(out, &bounds, &content, *state, style, string, len, align, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return ret; +} +NK_LIB void +nk_draw_button_symbol(struct nk_command_buffer *out, + const struct nk_rect *bounds, const struct nk_rect *content, + nk_flags state, const struct nk_style_button *style, + enum nk_symbol_type type, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_draw_button_symbol"); + struct nk_color sym, bg; + const struct nk_style_item *background; + + /* select correct colors/images */ + background = nk_draw_button(out, bounds, state, style); + if (background->type == NK_STYLE_ITEM_COLOR) + bg = background->data.color; + else bg = style->text_background; + + if (state & NK_WIDGET_STATE_HOVER) + sym = style->text_hover; + else if (state & NK_WIDGET_STATE_ACTIVED) + sym = style->text_active; + else sym = style->text_normal; + nk_draw_symbol(out, type, *content, bg, sym, 1, font); +} +NK_LIB nk_bool +nk_do_button_symbol(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + enum nk_symbol_type symbol, enum nk_button_behavior behavior, + const struct nk_style_button *style, const struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int ret; + struct nk_rect content; + + // NK_ASSERT(state); + // NK_ASSERT(style); + // NK_ASSERT(font); + // NK_ASSERT(out); + if (!out || !style || !font || !state) + return nk_false; + + ret = nk_do_button(state, out, bounds, style, in, behavior, &content); + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_button_symbol(out, &bounds, &content, *state, style, symbol, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return ret; +} +NK_LIB void +nk_draw_button_image(struct nk_command_buffer *out, + const struct nk_rect *bounds, const struct nk_rect *content, + nk_flags state, const struct nk_style_button *style, const struct nk_image *img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - state, / nk_flags"); + nk_draw_button(out, bounds, state, style); + nk_draw_image(out, *content, img, nk_white); +} +NK_LIB nk_bool +nk_do_button_image(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + struct nk_image img, enum nk_button_behavior b, + const struct nk_style_button *style, const struct nk_input *in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_button / const"); + int ret; + struct nk_rect content; + + // NK_ASSERT(state); + // NK_ASSERT(style); + // NK_ASSERT(out); + if (!out || !style || !state) + return nk_false; + + ret = nk_do_button(state, out, bounds, style, in, b, &content); + content.x += style->image_padding.x; + content.y += style->image_padding.y; + content.w -= 2 * style->image_padding.x; + content.h -= 2 * style->image_padding.y; + + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_button_image(out, &bounds, &content, *state, style, &img); + if (style->draw_end) style->draw_end(out, style->userdata); + return ret; +} +NK_LIB void +nk_draw_button_text_symbol(struct nk_command_buffer *out, + const struct nk_rect *bounds, const struct nk_rect *label, + const struct nk_rect *symbol, nk_flags state, const struct nk_style_button *style, + const char *str, int len, enum nk_symbol_type type, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + struct nk_color sym; + struct nk_text text; + const struct nk_style_item *background; + + /* select correct background colors/images */ + background = nk_draw_button(out, bounds, state, style); + if (background->type == NK_STYLE_ITEM_COLOR) + text.background = background->data.color; + else text.background = style->text_background; + + /* select correct text colors */ + if (state & NK_WIDGET_STATE_HOVER) { + sym = style->text_hover; + text.text = style->text_hover; + } else if (state & NK_WIDGET_STATE_ACTIVED) { + sym = style->text_active; + text.text = style->text_active; + } else { + sym = style->text_normal; + text.text = style->text_normal; + } + + text.padding = nk_vec2(0,0); + nk_draw_symbol(out, type, *symbol, style->text_background, sym, 0, font); + nk_widget_text(out, *label, str, len, &text, NK_TEXT_CENTERED, font); +} +NK_LIB nk_bool +nk_do_button_text_symbol(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + enum nk_symbol_type symbol, const char *str, int len, nk_flags align, + enum nk_button_behavior behavior, const struct nk_style_button *style, + const struct nk_user_font *font, const struct nk_input *in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int ret; + struct nk_rect tri = {0,0,0,0}; + struct nk_rect content; + + // NK_ASSERT(style); + // NK_ASSERT(out); + // NK_ASSERT(font); + if (!out || !style || !font) + return nk_false; + + ret = nk_do_button(state, out, bounds, style, in, behavior, &content); + tri.y = content.y + (content.h/2) - font->height/2; + tri.w = font->height; tri.h = font->height; + if (align & NK_TEXT_ALIGN_LEFT) { + tri.x = (content.x + content.w) - (2 * style->padding.x + tri.w); + tri.x = NK_MAX(tri.x, 0); + } else tri.x = content.x + 2 * style->padding.x; + + /* draw button */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_button_text_symbol(out, &bounds, &content, &tri, + *state, style, str, len, symbol, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return ret; +} +NK_LIB void +nk_draw_button_text_image(struct nk_command_buffer *out, + const struct nk_rect *bounds, const struct nk_rect *label, + const struct nk_rect *image, nk_flags state, const struct nk_style_button *style, + const char *str, int len, const struct nk_user_font *font, + const struct nk_image *img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_image / const"); + struct nk_text text; + const struct nk_style_item *background; + background = nk_draw_button(out, bounds, state, style); + + /* select correct colors */ + if (background->type == NK_STYLE_ITEM_COLOR) + text.background = background->data.color; + else text.background = style->text_background; + if (state & NK_WIDGET_STATE_HOVER) + text.text = style->text_hover; + else if (state & NK_WIDGET_STATE_ACTIVED) + text.text = style->text_active; + else text.text = style->text_normal; + + text.padding = nk_vec2(0,0); + nk_widget_text(out, *label, str, len, &text, NK_TEXT_CENTERED, font); + nk_draw_image(out, *image, img, nk_white); +} +NK_LIB nk_bool +nk_do_button_text_image(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + struct nk_image img, const char* str, int len, nk_flags align, + enum nk_button_behavior behavior, const struct nk_style_button *style, + const struct nk_user_font *font, const struct nk_input *in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int ret; + struct nk_rect icon; + struct nk_rect content; + + // NK_ASSERT(style); + // NK_ASSERT(state); + // NK_ASSERT(font); + // NK_ASSERT(out); + if (!out || !font || !style || !str) + return nk_false; + + ret = nk_do_button(state, out, bounds, style, in, behavior, &content); + icon.y = bounds.y + style->padding.y; + icon.w = icon.h = bounds.h - 2 * style->padding.y; + if (align & NK_TEXT_ALIGN_LEFT) { + icon.x = (bounds.x + bounds.w) - (2 * style->padding.x + icon.w); + icon.x = NK_MAX(icon.x, 0); + } else icon.x = bounds.x + 2 * style->padding.x; + + icon.x += style->image_padding.x; + icon.y += style->image_padding.y; + icon.w -= 2 * style->image_padding.x; + icon.h -= 2 * style->image_padding.y; + + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_button_text_image(out, &bounds, &content, &icon, *state, style, str, len, font, &img); + if (style->draw_end) style->draw_end(out, style->userdata); + return ret; +} +NK_API void +nk_button_set_behavior(struct nk_context *ctx, enum nk_button_behavior behavior) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_set_behavior"); + // NK_ASSERT(ctx); + if (!ctx) return; + ctx->button_behavior = behavior; +} +NK_API nk_bool +nk_button_push_behavior(struct nk_context *ctx, enum nk_button_behavior behavior) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_push_behavior"); + struct nk_config_stack_button_behavior *button_stack; + struct nk_config_stack_button_behavior_element *element; + + // NK_ASSERT(ctx); + if (!ctx) return 0; + + button_stack = &ctx->stacks.button_behaviors; + // NK_ASSERT(button_stack->head < (int)NK_LEN(button_stack->elements)); + if (button_stack->head >= (int)NK_LEN(button_stack->elements)) + return 0; + + element = &button_stack->elements[button_stack->head++]; + element->address = &ctx->button_behavior; + element->old_value = ctx->button_behavior; + ctx->button_behavior = behavior; + return 1; +} +NK_API nk_bool +nk_button_pop_behavior(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_pop_behavior"); + struct nk_config_stack_button_behavior *button_stack; + struct nk_config_stack_button_behavior_element *element; + + // NK_ASSERT(ctx); + if (!ctx) return 0; + + button_stack = &ctx->stacks.button_behaviors; + // NK_ASSERT(button_stack->head > 0); + if (button_stack->head < 1) + return 0; + + element = &button_stack->elements[--button_stack->head]; + *element->address = element->old_value; + return 1; +} +NK_API nk_bool +nk_button_text_styled(struct nk_context *ctx, + const struct nk_style_button *style, const char *title, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_button / const"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(style); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!style || !ctx || !ctx->current || !ctx->current->layout) return 0; + + win = ctx->current; + layout = win->layout; + state = nk_widget(&bounds, ctx); + + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds, + title, len, style->text_alignment, ctx->button_behavior, + style, in, ctx->style.font); +} +NK_API nk_bool +nk_button_text(struct nk_context *ctx, const char *title, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_text"); + // NK_ASSERT(ctx); + if (!ctx) return 0; + return nk_button_text_styled(ctx, &ctx->style.button, title, len); +} +NK_API nk_bool nk_button_label_styled(struct nk_context *ctx, + const struct nk_style_button *style, const char *title) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_button / const"); + return nk_button_text_styled(ctx, style, title, strlen(title)); +} +NK_API nk_bool nk_button_label(struct nk_context *ctx, const char *title) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_button_label / NK_API"); + return nk_button_text(ctx, title, strlen(title)); +} +NK_API nk_bool +nk_button_color(struct nk_context *ctx, struct nk_color color) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_color"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + struct nk_style_button button; + + int ret = 0; + struct nk_rect bounds; + struct nk_rect content; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + + button = ctx->style.button; + button.normal = nk_style_item_color(color); + button.hover = nk_style_item_color(color); + button.active = nk_style_item_color(color); + ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds, + &button, in, ctx->button_behavior, &content); + nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button); + return ret; +} +NK_API nk_bool +nk_button_symbol_styled(struct nk_context *ctx, + const struct nk_style_button *style, enum nk_symbol_type symbol) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_button / const"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + layout = win->layout; + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, bounds, + symbol, ctx->button_behavior, style, in, ctx->style.font); +} +NK_API nk_bool +nk_button_symbol(struct nk_context *ctx, enum nk_symbol_type symbol) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_symbol"); + // NK_ASSERT(ctx); + if (!ctx) return 0; + return nk_button_symbol_styled(ctx, &ctx->style.button, symbol); +} +NK_API nk_bool +nk_button_image_styled(struct nk_context *ctx, const struct nk_style_button *style, + struct nk_image img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - img / struct"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_button_image(&ctx->last_widget_state, &win->buffer, bounds, + img, ctx->button_behavior, style, in); +} +NK_API nk_bool +nk_button_image(struct nk_context *ctx, struct nk_image img) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_button_image"); + // NK_ASSERT(ctx); + if (!ctx) return 0; + return nk_button_image_styled(ctx, &ctx->style.button, img); +} +NK_API nk_bool +nk_button_symbol_text_styled(struct nk_context *ctx, + const struct nk_style_button *style, enum nk_symbol_type symbol, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds, + symbol, text, len, align, ctx->button_behavior, + style, ctx->style.font, in); +} +NK_API nk_bool +nk_button_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbol, + const char* text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - char* / const"); + // NK_ASSERT(ctx); + if (!ctx) return 0; + return nk_button_symbol_text_styled(ctx, &ctx->style.button, symbol, text, len, align); +} +NK_API nk_bool nk_button_symbol_label(struct nk_context *ctx, enum nk_symbol_type symbol, + const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_button_symbol_text(ctx, symbol, label, strlen(label), align); +} +NK_API nk_bool nk_button_symbol_label_styled(struct nk_context *ctx, + const struct nk_style_button *style, enum nk_symbol_type symbol, + const char *title, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_button_symbol_text_styled(ctx, style, symbol, title, strlen(title), align); +} +NK_API nk_bool +nk_button_image_text_styled(struct nk_context *ctx, + const struct nk_style_button *style, struct nk_image img, const char *text, + int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - len, / int"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_button_text_image(&ctx->last_widget_state, &win->buffer, + bounds, img, text, len, align, ctx->button_behavior, + style, ctx->style.font, in); +} +NK_API nk_bool +nk_button_image_text(struct nk_context *ctx, struct nk_image img, + const char *text, int len, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_button_image_text_styled(ctx, &ctx->style.button,img, text, len, align); +} +NK_API nk_bool nk_button_image_label(struct nk_context *ctx, struct nk_image img, + const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_button_image_text(ctx, img, label, strlen(label), align); +} +NK_API nk_bool nk_button_image_label_styled(struct nk_context *ctx, + const struct nk_style_button *style, struct nk_image img, + const char *label, nk_flags text_alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_button_image_text_styled(ctx, style, img, label, strlen(label), text_alignment); +} + + + + + +/* =============================================================== + * + * TOGGLE + * + * ===============================================================*/ +NK_LIB nk_bool +nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, + nk_flags *state, nk_bool active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - state, / nk_flags"); + nk_widget_state_reset(state); + if (nk_button_behavior(state, select, in, NK_BUTTON_DEFAULT)) { + *state = NK_WIDGET_STATE_ACTIVE; + active = !active; + } + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, select)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, select)) + *state |= NK_WIDGET_STATE_LEFT; + return active; +} +NK_LIB void +nk_draw_checkbox(struct nk_command_buffer *out, + nk_flags state, const struct nk_style_toggle *style, nk_bool active, + const struct nk_rect *label, const struct nk_rect *selector, + const struct nk_rect *cursors, const char *string, int len, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + const struct nk_style_item *background; + const struct nk_style_item *cursor; + struct nk_text text; + + /* select correct colors/images */ + if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + cursor = &style->cursor_hover; + text.text = style->text_hover; + } else if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->hover; + cursor = &style->cursor_hover; + text.text = style->text_active; + } else { + background = &style->normal; + cursor = &style->cursor_normal; + text.text = style->text_normal; + } + + /* draw background and cursor */ + if (background->type == NK_STYLE_ITEM_COLOR) { + nk_fill_rect(out, *selector, 0, style->border_color); + nk_fill_rect(out, nk_shrink_rect(*selector, style->border), 0, background->data.color); + } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { + if (cursor->type == NK_STYLE_ITEM_IMAGE) + nk_draw_image(out, *cursors, &cursor->data.image, nk_white); + else nk_fill_rect(out, *cursors, 0, cursor->data.color); + } + + text.padding.x = 0; + text.padding.y = 0; + text.background = style->text_background; + nk_widget_text(out, *label, string, len, &text, NK_TEXT_LEFT, font); +} +NK_LIB void +nk_draw_option(struct nk_command_buffer *out, + nk_flags state, const struct nk_style_toggle *style, nk_bool active, + const struct nk_rect *label, const struct nk_rect *selector, + const struct nk_rect *cursors, const char *string, int len, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + const struct nk_style_item *background; + const struct nk_style_item *cursor; + struct nk_text text; + + /* select correct colors/images */ + if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + cursor = &style->cursor_hover; + text.text = style->text_hover; + } else if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->hover; + cursor = &style->cursor_hover; + text.text = style->text_active; + } else { + background = &style->normal; + cursor = &style->cursor_normal; + text.text = style->text_normal; + } + + /* draw background and cursor */ + if (background->type == NK_STYLE_ITEM_COLOR) { + nk_fill_circle(out, *selector, style->border_color); + nk_fill_circle(out, nk_shrink_rect(*selector, style->border), background->data.color); + } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { + if (cursor->type == NK_STYLE_ITEM_IMAGE) + nk_draw_image(out, *cursors, &cursor->data.image, nk_white); + else nk_fill_circle(out, *cursors, cursor->data.color); + } + + text.padding.x = 0; + text.padding.y = 0; + text.background = style->text_background; + nk_widget_text(out, *label, string, len, &text, NK_TEXT_LEFT, font); +} +NK_LIB nk_bool +nk_do_toggle(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect r, + nk_bool *active, const char *str, int len, enum nk_toggle_type type, + const struct nk_style_toggle *style, const struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int was_active; + struct nk_rect bounds; + struct nk_rect select; + struct nk_rect cursor; + struct nk_rect label; + + // NK_ASSERT(style); + // NK_ASSERT(out); + // NK_ASSERT(font); + if (!out || !style || !font || !active) + return 0; + + r.w = NK_MAX(r.w, font->height + 2 * style->padding.x); + r.h = NK_MAX(r.h, font->height + 2 * style->padding.y); + + /* add additional touch padding for touch screen devices */ + bounds.x = r.x - style->touch_padding.x; + bounds.y = r.y - style->touch_padding.y; + bounds.w = r.w + 2 * style->touch_padding.x; + bounds.h = r.h + 2 * style->touch_padding.y; + + /* calculate the selector space */ + select.w = font->height; + select.h = select.w; + select.y = r.y + r.h/2.0f - select.h/2.0f; + select.x = r.x; + + /* calculate the bounds of the cursor inside the selector */ + cursor.x = select.x + style->padding.x + style->border; + cursor.y = select.y + style->padding.y + style->border; + cursor.w = select.w - (2 * style->padding.x + 2 * style->border); + cursor.h = select.h - (2 * style->padding.y + 2 * style->border); + + /* label behind the selector */ + label.x = select.x + select.w + style->spacing; + label.y = select.y; + label.w = NK_MAX(r.x + r.w, label.x) - label.x; + label.h = select.w; + + /* update selector */ + was_active = *active; + *active = nk_toggle_behavior(in, bounds, state, *active); + + /* draw selector */ + if (style->draw_begin) + style->draw_begin(out, style->userdata); + if (type == NK_TOGGLE_CHECK) { + nk_draw_checkbox(out, *state, style, *active, &label, &select, &cursor, str, len, font); + } else { + nk_draw_option(out, *state, style, *active, &label, &select, &cursor, str, len, font); + } + if (style->draw_end) + style->draw_end(out, style->userdata); + return (was_active != *active); +} +/*---------------------------------------------------------------- + * + * CHECKBOX + * + * --------------------------------------------------------------*/ +NK_API nk_bool +nk_check_text(struct nk_context *ctx, const char *text, int len, nk_bool active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_check_text"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return active; + + win = ctx->current; + style = &ctx->style; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return active; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &active, + text, len, NK_TOGGLE_CHECK, &style->checkbox, in, style->font); + return active; +} +NK_API unsigned int +nk_check_flags_text(struct nk_context *ctx, const char *text, int len, + unsigned int flags, unsigned int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - flags / unsigned"); + int old_active; + // NK_ASSERT(ctx); + // NK_ASSERT(text); + if (!ctx || !text) return flags; + old_active = (int)((flags & value) & value); + if (nk_check_text(ctx, text, len, old_active)) + flags |= value; + else flags &= ~value; + return flags; +} +NK_API nk_bool +nk_checkbox_text(struct nk_context *ctx, const char *text, int len, nk_bool *active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_checkbox_text"); + int old_val; + // NK_ASSERT(ctx); + // NK_ASSERT(text); + // NK_ASSERT(active); + if (!ctx || !text || !active) return 0; + old_val = *active; + *active = nk_check_text(ctx, text, len, *active); + return old_val != *active; +} +NK_API nk_bool +nk_checkbox_flags_text(struct nk_context *ctx, const char *text, int len, + unsigned int *flags, unsigned int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - flags / unsigned"); + nk_bool active; + // NK_ASSERT(ctx); + // NK_ASSERT(text); + // NK_ASSERT(flags); + if (!ctx || !text || !flags) return 0; + + active = (int)((*flags & value) & value); + if (nk_checkbox_text(ctx, text, len, &active)) { + if (active) *flags |= value; + else *flags &= ~value; + return 1; + } + return 0; +} +NK_API nk_bool nk_check_label(struct nk_context *ctx, const char *label, nk_bool active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_check_label / NK_API"); + return nk_check_text(ctx, label, strlen(label), active); +} +NK_API unsigned int nk_check_flags_label(struct nk_context *ctx, const char *label, + unsigned int flags, unsigned int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - flags / unsigned"); + return nk_check_flags_text(ctx, label, strlen(label), flags, value); +} +NK_API nk_bool nk_checkbox_label(struct nk_context *ctx, const char *label, nk_bool *active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_checkbox_label / NK_API"); + return nk_checkbox_text(ctx, label, strlen(label), active); +} +NK_API nk_bool nk_checkbox_flags_label(struct nk_context *ctx, const char *label, + unsigned int *flags, unsigned int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - flags / unsigned"); + return nk_checkbox_flags_text(ctx, label, strlen(label), flags, value); +} +/*---------------------------------------------------------------- + * + * OPTION + * + * --------------------------------------------------------------*/ +NK_API nk_bool +nk_option_text(struct nk_context *ctx, const char *text, int len, nk_bool is_active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_option_text"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return is_active; + + win = ctx->current; + style = &ctx->style; + layout = win->layout; + + state = nk_widget(&bounds, ctx); + if (!state) return (int)state; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active, + text, len, NK_TOGGLE_OPTION, &style->option, in, style->font); + return is_active; +} +NK_API nk_bool +nk_radio_text(struct nk_context *ctx, const char *text, int len, nk_bool *active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_radio_text"); + int old_value; + // NK_ASSERT(ctx); + // NK_ASSERT(text); + // NK_ASSERT(active); + if (!ctx || !text || !active) return 0; + old_value = *active; + *active = nk_option_text(ctx, text, len, old_value); + return old_value != *active; +} +NK_API nk_bool +nk_option_label(struct nk_context *ctx, const char *label, nk_bool active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_option_label"); + return nk_option_text(ctx, label, strlen(label), active); +} +NK_API nk_bool +nk_radio_label(struct nk_context *ctx, const char *label, nk_bool *active) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_radio_label"); + return nk_radio_text(ctx, label, strlen(label), active); +} + + + + + +/* =============================================================== + * + * SELECTABLE + * + * ===============================================================*/ +NK_LIB void +nk_draw_selectable(struct nk_command_buffer *out, + nk_flags state, const struct nk_style_selectable *style, nk_bool active, + const struct nk_rect *bounds, + const struct nk_rect *icon, const struct nk_image *img, enum nk_symbol_type sym, + const char *string, int len, nk_flags align, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - string / const"); + const struct nk_style_item *background; + struct nk_text text; + text.padding = style->padding; + + /* select correct colors/images */ + if (!active) { + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->pressed; + text.text = style->text_pressed; + } else if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + text.text = style->text_hover; + } else { + background = &style->normal; + text.text = style->text_normal; + } + } else { + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->pressed_active; + text.text = style->text_pressed_active; + } else if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover_active; + text.text = style->text_hover_active; + } else { + background = &style->normal_active; + text.text = style->text_normal_active; + } + } + /* draw selectable background and text */ + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, *bounds, &background->data.image, nk_white); + text.background = nk_rgba(0,0,0,0); + } else { + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + text.background = background->data.color; + } + if (icon) { + if (img) nk_draw_image(out, *icon, img, nk_white); + else nk_draw_symbol(out, sym, *icon, text.background, text.text, 1, font); + } + nk_widget_text(out, *bounds, string, len, &text, align, font); +} +NK_LIB nk_bool +nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, + struct nk_rect bounds, const char *str, int len, nk_flags align, nk_bool *value, + const struct nk_style_selectable *style, const struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int old_value; + struct nk_rect touch; + + // NK_ASSERT(state); + // NK_ASSERT(out); + // NK_ASSERT(str); + // NK_ASSERT(len); + // NK_ASSERT(value); + // NK_ASSERT(style); + // NK_ASSERT(font); + + if (!state || !out || !str || !len || !value || !style || !font) return 0; + old_value = *value; + + /* remove padding */ + touch.x = bounds.x - style->touch_padding.x; + touch.y = bounds.y - style->touch_padding.y; + touch.w = bounds.w + style->touch_padding.x * 2; + touch.h = bounds.h + style->touch_padding.y * 2; + + /* update button */ + if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT)) + *value = !(*value); + + /* draw selectable */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_selectable(out, *state, style, *value, &bounds, 0,0,NK_SYMBOL_NONE, str, len, align, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return old_value != *value; +} +NK_LIB nk_bool +nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, + struct nk_rect bounds, const char *str, int len, nk_flags align, nk_bool *value, + const struct nk_image *img, const struct nk_style_selectable *style, + const struct nk_input *in, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input / const"); + nk_bool old_value; + struct nk_rect touch; + struct nk_rect icon; + + // NK_ASSERT(state); + // NK_ASSERT(out); + // NK_ASSERT(str); + // NK_ASSERT(len); + // NK_ASSERT(value); + // NK_ASSERT(style); + // NK_ASSERT(font); + + if (!state || !out || !str || !len || !value || !style || !font) return 0; + old_value = *value; + + /* toggle behavior */ + touch.x = bounds.x - style->touch_padding.x; + touch.y = bounds.y - style->touch_padding.y; + touch.w = bounds.w + style->touch_padding.x * 2; + touch.h = bounds.h + style->touch_padding.y * 2; + if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT)) + *value = !(*value); + + icon.y = bounds.y + style->padding.y; + icon.w = icon.h = bounds.h - 2 * style->padding.y; + if (align & NK_TEXT_ALIGN_LEFT) { + icon.x = (bounds.x + bounds.w) - (2 * style->padding.x + icon.w); + icon.x = NK_MAX(icon.x, 0); + } else icon.x = bounds.x + 2 * style->padding.x; + + icon.x += style->image_padding.x; + icon.y += style->image_padding.y; + icon.w -= 2 * style->image_padding.x; + icon.h -= 2 * style->image_padding.y; + + /* draw selectable */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_selectable(out, *state, style, *value, &bounds, &icon, img, NK_SYMBOL_NONE, str, len, align, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return old_value != *value; +} +NK_LIB nk_bool +nk_do_selectable_symbol(nk_flags *state, struct nk_command_buffer *out, + struct nk_rect bounds, const char *str, int len, nk_flags align, nk_bool *value, + enum nk_symbol_type sym, const struct nk_style_selectable *style, + const struct nk_input *in, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_input / const"); + int old_value; + struct nk_rect touch; + struct nk_rect icon; + + // NK_ASSERT(state); + // NK_ASSERT(out); + // NK_ASSERT(str); + // NK_ASSERT(len); + // NK_ASSERT(value); + // NK_ASSERT(style); + // NK_ASSERT(font); + + if (!state || !out || !str || !len || !value || !style || !font) return 0; + old_value = *value; + + /* toggle behavior */ + touch.x = bounds.x - style->touch_padding.x; + touch.y = bounds.y - style->touch_padding.y; + touch.w = bounds.w + style->touch_padding.x * 2; + touch.h = bounds.h + style->touch_padding.y * 2; + if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT)) + *value = !(*value); + + icon.y = bounds.y + style->padding.y; + icon.w = icon.h = bounds.h - 2 * style->padding.y; + if (align & NK_TEXT_ALIGN_LEFT) { + icon.x = (bounds.x + bounds.w) - (2 * style->padding.x + icon.w); + icon.x = NK_MAX(icon.x, 0); + } else icon.x = bounds.x + 2 * style->padding.x; + + icon.x += style->image_padding.x; + icon.y += style->image_padding.y; + icon.w -= 2 * style->image_padding.x; + icon.h -= 2 * style->image_padding.y; + + /* draw selectable */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_selectable(out, *state, style, *value, &bounds, &icon, 0, sym, str, len, align, font); + if (style->draw_end) style->draw_end(out, style->userdata); + return old_value != *value; +} + +NK_API nk_bool +nk_selectable_text(struct nk_context *ctx, const char *str, int len, + nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - align, / nk_flags"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + const struct nk_style *style; + + enum nk_widget_layout_states state; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(value); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !value) + return 0; + + win = ctx->current; + layout = win->layout; + style = &ctx->style; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds, + str, len, align, value, &style->selectable, in, style->font); +} +NK_API nk_bool +nk_selectable_image_text(struct nk_context *ctx, struct nk_image img, + const char *str, int len, nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - str / const"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + const struct nk_style *style; + + enum nk_widget_layout_states state; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(value); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !value) + return 0; + + win = ctx->current; + layout = win->layout; + style = &ctx->style; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_selectable_image(&ctx->last_widget_state, &win->buffer, bounds, + str, len, align, value, &img, &style->selectable, in, style->font); +} +NK_API nk_bool +nk_selectable_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, + const char *str, int len, nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - str / const"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_input *in; + const struct nk_style *style; + + enum nk_widget_layout_states state; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(value); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !value) + return 0; + + win = ctx->current; + layout = win->layout; + style = &ctx->style; + + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_selectable_symbol(&ctx->last_widget_state, &win->buffer, bounds, + str, len, align, value, sym, &style->selectable, in, style->font); +} +NK_API nk_bool +nk_selectable_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym, + const char *title, nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_selectable_symbol_text(ctx, sym, title, strlen(title), align, value); +} +NK_API nk_bool nk_select_text(struct nk_context *ctx, const char *str, int len, + nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - align, / nk_flags"); + nk_selectable_text(ctx, str, len, align, &value);return value; +} +NK_API nk_bool nk_selectable_label(struct nk_context *ctx, const char *str, nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_selectable_label / NK_API"); + return nk_selectable_text(ctx, str, strlen(str), align, value); +} +NK_API nk_bool nk_selectable_image_label(struct nk_context *ctx,struct nk_image img, + const char *str, nk_flags align, nk_bool *value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - str / const"); + return nk_selectable_image_text(ctx, img, str, strlen(str), align, value); +} +NK_API nk_bool nk_select_label(struct nk_context *ctx, const char *str, nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_select_label / NK_API"); + nk_selectable_text(ctx, str, strlen(str), align, &value);return value; +} +NK_API nk_bool nk_select_image_label(struct nk_context *ctx, struct nk_image img, + const char *str, nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - str / const"); + nk_selectable_image_text(ctx, img, str, strlen(str), align, &value);return value; +} +NK_API nk_bool nk_select_image_text(struct nk_context *ctx, struct nk_image img, + const char *str, int len, nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - str / const"); + nk_selectable_image_text(ctx, img, str, len, align, &value);return value; +} +NK_API nk_bool +nk_select_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, + const char *title, int title_len, nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + nk_selectable_symbol_text(ctx, sym, title, title_len, align, &value);return value; +} +NK_API nk_bool +nk_select_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym, + const char *title, nk_flags align, nk_bool value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - title / const"); + return nk_select_symbol_text(ctx, sym, title, strlen(title), align, value); +} + + + + + +/* =============================================================== + * + * SLIDER + * + * ===============================================================*/ +NK_LIB int +nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor, + struct nk_rect *visual_cursor, struct nk_input *in, + struct nk_rect bounds, int slider_min, int slider_max, int slider_value, + int slider_step, int slider_steps) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - slider_step, / int"); + int left_mouse_down; + int left_mouse_click_in_cursor; + + /* check if visual cursor is being dragged */ + nk_widget_state_reset(state); + left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down; + left_mouse_click_in_cursor = in && nk_input_has_mouse_click_down_in_rect(in, + NK_BUTTON_LEFT, *visual_cursor, nk_true); + + if (left_mouse_down && left_mouse_click_in_cursor) { + int ratio = 0; + const int d = in->mouse.pos.x - (visual_cursor->x+visual_cursor->w*0.5f); + const int pxstep = bounds.w / slider_steps; + + /* only update value if the next slider step is reached */ + *state = NK_WIDGET_STATE_ACTIVE; + if (NK_ABS(d) >= pxstep) { + const int steps = (int)((int)(NK_ABS(d) / pxstep)); + slider_value += (d > 0) ? (slider_step*steps) : -(slider_step*steps); + slider_value = NK_CLAMP(slider_min, slider_value, slider_max); + ratio = (slider_value - slider_min)/slider_step; + logical_cursor->x = bounds.x + (logical_cursor->w * ratio); + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = logical_cursor->x; + } + } + + /* slider widget state */ + if (nk_input_is_mouse_hovering_rect(in, bounds)) + *state = NK_WIDGET_STATE_HOVERED; + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, bounds)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, bounds)) + *state |= NK_WIDGET_STATE_LEFT; + return slider_value; +} +NK_LIB void +nk_draw_slider(struct nk_command_buffer *out, nk_flags state, + const struct nk_style_slider *style, const struct nk_rect *bounds, + const struct nk_rect *visual_cursor, int min, int value, int max) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / const"); + struct nk_rect fill; + struct nk_rect bar; + const struct nk_style_item *background; + + /* select correct slider images/colors */ + struct nk_color bar_color; + const struct nk_style_item *cursor; + + NK_UNUSED(min); + NK_UNUSED(max); + NK_UNUSED(value); + + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + bar_color = style->bar_active; + cursor = &style->cursor_active; + } else if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + bar_color = style->bar_hover; + cursor = &style->cursor_hover; + } else { + background = &style->normal; + bar_color = style->bar_normal; + cursor = &style->cursor_normal; + } + /* calculate slider background bar */ + bar.x = bounds->x; + bar.y = (visual_cursor->y + visual_cursor->h/2) - bounds->h/12; + bar.w = bounds->w; + bar.h = bounds->h/6; + + /* filled background bar style */ + fill.w = (visual_cursor->x + (visual_cursor->w/2.0f)) - bar.x; + fill.x = bar.x; + fill.y = bar.y; + fill.h = bar.h; + + /* draw background */ + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, *bounds, &background->data.image, nk_white); + } else { + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color); + } + + /* draw slider bar */ + nk_fill_rect(out, bar, style->rounding, bar_color); + nk_fill_rect(out, fill, style->rounding, style->bar_filled); + + /* draw cursor */ + if (cursor->type == NK_STYLE_ITEM_IMAGE) + nk_draw_image(out, *visual_cursor, &cursor->data.image, nk_white); + else nk_fill_circle(out, *visual_cursor, cursor->data.color); +} +NK_LIB int +nk_do_slider(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + int min, int val, int max, int step, + const struct nk_style_slider *style, struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int slider_range; + int slider_min; + int slider_max; + int slider_value; + int slider_steps; + int cursor_offset; + + struct nk_rect visual_cursor; + struct nk_rect logical_cursor; + + // NK_ASSERT(style); + // NK_ASSERT(out); + if (!out || !style) + return 0; + + /* remove padding from slider bounds */ + bounds.x = bounds.x + style->padding.x; + bounds.y = bounds.y + style->padding.y; + bounds.h = NK_MAX(bounds.h, 2*style->padding.y); + bounds.w = NK_MAX(bounds.w, 2*style->padding.x + style->cursor_size.x); + bounds.w -= 2 * style->padding.x; + bounds.h -= 2 * style->padding.y; + + /* optional buttons */ + if (style->show_buttons) { + nk_flags ws; + struct nk_rect button; + button.y = bounds.y; + button.w = bounds.h; + button.h = bounds.h; + + /* decrement button */ + button.x = bounds.x; + if (nk_do_button_symbol(&ws, out, button, style->dec_symbol, NK_BUTTON_DEFAULT, + &style->dec_button, in, font)) + val -= step; + + /* increment button */ + button.x = (bounds.x + bounds.w) - button.w; + if (nk_do_button_symbol(&ws, out, button, style->inc_symbol, NK_BUTTON_DEFAULT, + &style->inc_button, in, font)) + val += step; + + bounds.x = bounds.x + button.w + style->spacing.x; + bounds.w = bounds.w - (2*button.w + 2*style->spacing.x); + } + + /* remove one cursor size to support visual cursor */ + bounds.x += style->cursor_size.x*0.5f; + bounds.w -= style->cursor_size.x; + + /* make sure the provided values are correct */ + slider_max = NK_MAX(min, max); + slider_min = NK_MIN(min, max); + slider_value = NK_CLAMP(slider_min, val, slider_max); + slider_range = slider_max - slider_min; + slider_steps = slider_range / step; + cursor_offset = (slider_value - slider_min) / step; + + /* calculate cursor + Basically you have two cursors. One for visual representation and interaction + and one for updating the actual cursor value. */ + logical_cursor.h = bounds.h; + logical_cursor.w = bounds.w / slider_steps; + logical_cursor.x = bounds.x + (logical_cursor.w * cursor_offset); + logical_cursor.y = bounds.y; + + visual_cursor.h = style->cursor_size.y; + visual_cursor.w = style->cursor_size.x; + visual_cursor.y = (bounds.y + bounds.h*0.5f) - visual_cursor.h*0.5f; + visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f; + + slider_value = nk_slider_behavior(state, &logical_cursor, &visual_cursor, + in, bounds, slider_min, slider_max, slider_value, step, slider_steps); + visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f; + + /* draw slider */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_slider(out, *state, style, &bounds, &visual_cursor, slider_min, slider_value, slider_max); + if (style->draw_end) style->draw_end(out, style->userdata); + return slider_value; +} +// NK_API nk_bool +// nk_slider_int(struct nk_context *ctx, int min_value, int *value, int max_value, +// int value_step) +// { +// struct nk_window *win; +// struct nk_panel *layout; +// struct nk_input *in; +// const struct nk_style *style; + +// int ret = 0; +// int old_value; +// struct nk_rect bounds; +// enum nk_widget_layout_states state; + +// // NK_ASSERT(ctx); +// // NK_ASSERT(ctx->current); +// // NK_ASSERT(ctx->current->layout); +// // NK_ASSERT(value); +// if (!ctx || !ctx->current || !ctx->current->layout || !value) +// return ret; + +// win = ctx->current; +// style = &ctx->style; +// layout = win->layout; + +// state = nk_widget(&bounds, ctx); +// if (!state) return ret; +// in = (/*state == NK_WIDGET_ROM || */ layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + +// old_value = *value; +// *value = nk_do_slider(&ctx->last_widget_state, &win->buffer, bounds, min_value, +// old_value, max_value, value_step, &style->slider, in, style->font); +// return (old_value > *value || old_value < *value); +// } +NK_API int +nk_slide_int(struct nk_context *ctx, int min, int val, int max, int step) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_slide_int"); + nk_slider_int(ctx, min, &val, max, step); return val; +} +// NK_API int +// nk_slide_int(struct nk_context *ctx, int min, int val, int max, int step) +// { +// int value = (int)val; +// nk_slider_int(ctx, (int)min, &value, (int)max, (int)step); +// return (int)value; +// } +NK_API nk_bool +nk_slider_int(struct nk_context *ctx, int min, int *val, int max, int step) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_slider_int"); + int ret; + int value = (int)*val; + ret = nk_slider_int(ctx, (int)min, &value, (int)max, (int)step); + *val = (int)value; + return ret; +} + + + + + +/* =============================================================== + * + * PROGRESS + * + * ===============================================================*/ +NK_LIB nk_size +nk_progress_behavior(nk_flags *state, struct nk_input *in, + struct nk_rect r, struct nk_rect cursor, nk_size max, nk_size value, nk_bool modifiable) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - r / struct"); + int left_mouse_down = 0; + int left_mouse_click_in_cursor = 0; + + nk_widget_state_reset(state); + if (!in || !modifiable) return value; + left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down; + left_mouse_click_in_cursor = in && nk_input_has_mouse_click_down_in_rect(in, + NK_BUTTON_LEFT, cursor, nk_true); + if (nk_input_is_mouse_hovering_rect(in, r)) + *state = NK_WIDGET_STATE_HOVERED; + + if (in && left_mouse_down && left_mouse_click_in_cursor) { + if (left_mouse_down && left_mouse_click_in_cursor) { + int ratio = NK_MAX(0, (int)(in->mouse.pos.x - cursor.x)) / (int)cursor.w; + value = (nk_size)NK_CLAMP(0, (int)max * ratio, (int)max); + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = cursor.x + cursor.w/2.0f; + *state |= NK_WIDGET_STATE_ACTIVE; + } + } + /* set progressbar widget state */ + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, r)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, r)) + *state |= NK_WIDGET_STATE_LEFT; + return value; +} +NK_LIB void +nk_draw_progress(struct nk_command_buffer *out, nk_flags state, + const struct nk_style_progress *style, const struct nk_rect *bounds, + const struct nk_rect *scursor, nk_size value, nk_size max) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / const"); + const struct nk_style_item *background; + const struct nk_style_item *cursor; + + NK_UNUSED(max); + NK_UNUSED(value); + + /* select correct colors/images to draw */ + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + cursor = &style->cursor_active; + } else if (state & NK_WIDGET_STATE_HOVER){ + background = &style->hover; + cursor = &style->cursor_hover; + } else { + background = &style->normal; + cursor = &style->cursor_normal; + } + + /* draw background */ + if (background->type == NK_STYLE_ITEM_COLOR) { + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color); + } else nk_draw_image(out, *bounds, &background->data.image, nk_white); + + /* draw cursor */ + if (cursor->type == NK_STYLE_ITEM_COLOR) { + nk_fill_rect(out, *scursor, style->rounding, cursor->data.color); + nk_stroke_rect(out, *scursor, style->rounding, style->border, style->border_color); + } else nk_draw_image(out, *scursor, &cursor->data.image, nk_white); +} +NK_LIB nk_size +nk_do_progress(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + nk_size value, nk_size max, nk_bool modifiable, + const struct nk_style_progress *style, struct nk_input *in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_style_progress / const"); + int prog_scale; + nk_size prog_value; + struct nk_rect cursor; + + // NK_ASSERT(style); + // NK_ASSERT(out); + if (!out || !style) return 0; + + /* calculate progressbar cursor */ + cursor.w = NK_MAX(bounds.w, 2 * style->padding.x + 2 * style->border); + cursor.h = NK_MAX(bounds.h, 2 * style->padding.y + 2 * style->border); + cursor = nk_pad_rect(bounds, nk_vec2(style->padding.x + style->border, style->padding.y + style->border)); + prog_scale = (int)value / (int)max; + + /* update progressbar */ + prog_value = NK_MIN(value, max); + prog_value = nk_progress_behavior(state, in, bounds, cursor,max, prog_value, modifiable); + cursor.w = cursor.w * prog_scale; + + /* draw progressbar */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_progress(out, *state, style, &bounds, &cursor, value, max); + if (style->draw_end) style->draw_end(out, style->userdata); + return prog_value; +} +NK_API nk_bool +nk_progress(struct nk_context *ctx, nk_size *cur, nk_size max, nk_bool is_modifyable) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_progress"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_style *style; + struct nk_input *in; + + struct nk_rect bounds; + enum nk_widget_layout_states state; + nk_size old_value; + + // NK_ASSERT(ctx); + // NK_ASSERT(cur); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !cur) + return 0; + + win = ctx->current; + style = &ctx->style; + layout = win->layout; + state = nk_widget(&bounds, ctx); + if (!state) return 0; + + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + old_value = *cur; + *cur = nk_do_progress(&ctx->last_widget_state, &win->buffer, bounds, + *cur, max, is_modifyable, &style->progress, in); + return (*cur != old_value); +} +NK_API nk_size +nk_prog(struct nk_context *ctx, nk_size cur, nk_size max, nk_bool modifyable) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_prog"); + nk_progress(ctx, &cur, max, modifyable); + return cur; +} + + + + + +/* =============================================================== + * + * SCROLLBAR + * + * ===============================================================*/ +NK_LIB int +nk_scrollbar_behavior(nk_flags *state, struct nk_input *in, + int has_scrolling, const struct nk_rect *scroll, + const struct nk_rect *cursor, const struct nk_rect *empty0, + const struct nk_rect *empty1, int scroll_offset, + int target, int scroll_step, enum nk_orientation o) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - target, / int"); + nk_flags ws = 0; + int left_mouse_down; + int left_mouse_clicked; + int left_mouse_click_in_cursor; + int scroll_delta; + + nk_widget_state_reset(state); + if (!in) return scroll_offset; + + left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down; + left_mouse_clicked = in->mouse.buttons[NK_BUTTON_LEFT].clicked; + left_mouse_click_in_cursor = nk_input_has_mouse_click_down_in_rect(in, + NK_BUTTON_LEFT, *cursor, nk_true); + if (nk_input_is_mouse_hovering_rect(in, *scroll)) + *state = NK_WIDGET_STATE_HOVERED; + + scroll_delta = (o == NK_VERTICAL) ? in->mouse.scroll_delta.y: in->mouse.scroll_delta.x; + if (left_mouse_down && left_mouse_click_in_cursor && !left_mouse_clicked) { + /* update cursor by mouse dragging */ + int pixel, delta; + *state = NK_WIDGET_STATE_ACTIVE; + if (o == NK_VERTICAL) { + int cursor_y; + pixel = in->mouse.delta.y; + delta = (pixel / scroll->h) * target; + scroll_offset = NK_CLAMP(0, scroll_offset + delta, target - scroll->h); + cursor_y = scroll->y + ((scroll_offset/target) * scroll->h); + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y = cursor_y + cursor->h/2.0f; + } else { + int cursor_x; + pixel = in->mouse.delta.x; + delta = (pixel / scroll->w) * target; + scroll_offset = NK_CLAMP(0, scroll_offset + delta, target - scroll->w); + cursor_x = scroll->x + ((scroll_offset/target) * scroll->w); + in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = cursor_x + cursor->w/2.0f; + } + } else if ((nk_input_is_key_pressed(in, NK_KEY_SCROLL_UP) && o == NK_VERTICAL && has_scrolling)|| + nk_button_behavior(&ws, *empty0, in, NK_BUTTON_DEFAULT)) { + /* scroll page up by click on empty space or shortcut */ + if (o == NK_VERTICAL) + scroll_offset = NK_MAX(0, scroll_offset - scroll->h); + else scroll_offset = NK_MAX(0, scroll_offset - scroll->w); + } else if ((nk_input_is_key_pressed(in, NK_KEY_SCROLL_DOWN) && o == NK_VERTICAL && has_scrolling) || + nk_button_behavior(&ws, *empty1, in, NK_BUTTON_DEFAULT)) { + /* scroll page down by click on empty space or shortcut */ + if (o == NK_VERTICAL) + scroll_offset = NK_MIN(scroll_offset + scroll->h, target - scroll->h); + else scroll_offset = NK_MIN(scroll_offset + scroll->w, target - scroll->w); + } else if (has_scrolling) { + if ((scroll_delta < 0 || (scroll_delta > 0))) { + /* update cursor by mouse scrolling */ + scroll_offset = scroll_offset + scroll_step * (-scroll_delta); + if (o == NK_VERTICAL) + scroll_offset = NK_CLAMP(0, scroll_offset, target - scroll->h); + else scroll_offset = NK_CLAMP(0, scroll_offset, target - scroll->w); + } else if (nk_input_is_key_pressed(in, NK_KEY_SCROLL_START)) { + /* update cursor to the beginning */ + if (o == NK_VERTICAL) scroll_offset = 0; + } else if (nk_input_is_key_pressed(in, NK_KEY_SCROLL_END)) { + /* update cursor to the end */ + if (o == NK_VERTICAL) scroll_offset = target - scroll->h; + } + } + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, *scroll)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, *scroll)) + *state |= NK_WIDGET_STATE_LEFT; + return scroll_offset; +} +NK_LIB void +nk_draw_scrollbar(struct nk_command_buffer *out, nk_flags state, + const struct nk_style_scrollbar *style, const struct nk_rect *bounds, + const struct nk_rect *scroll) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_rect / const"); + const struct nk_style_item *background; + const struct nk_style_item *cursor; + + /* select correct colors/images to draw */ + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + cursor = &style->cursor_active; + } else if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + cursor = &style->cursor_hover; + } else { + background = &style->normal; + cursor = &style->cursor_normal; + } + + /* draw background */ + if (background->type == NK_STYLE_ITEM_COLOR) { + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color); + } else { + nk_draw_image(out, *bounds, &background->data.image, nk_white); + } + + /* draw cursor */ + if (cursor->type == NK_STYLE_ITEM_COLOR) { + nk_fill_rect(out, *scroll, style->rounding_cursor, cursor->data.color); + nk_stroke_rect(out, *scroll, style->rounding_cursor, style->border_cursor, style->cursor_border_color); + } else nk_draw_image(out, *scroll, &cursor->data.image, nk_white); +} +NK_LIB int +nk_do_scrollbarv(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, + int offset, int target, int step, int button_pixel_inc, + const struct nk_style_scrollbar *style, struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + struct nk_rect empty_north; + struct nk_rect empty_south; + struct nk_rect cursor; + + int scroll_step; + int scroll_offset; + int scroll_off; + int scroll_ratio; + + // NK_ASSERT(out); + // NK_ASSERT(style); + // NK_ASSERT(state); + if (!out || !style) return 0; + + scroll.w = NK_MAX(scroll.w, 1); + scroll.h = NK_MAX(scroll.h, 0); + if (target <= scroll.h) return 0; + + /* optional scrollbar buttons */ + if (style->show_buttons) { + nk_flags ws; + int scroll_h; + struct nk_rect button; + + button.x = scroll.x; + button.w = scroll.w; + button.h = scroll.w; + + scroll_h = NK_MAX(scroll.h - 2 * button.h,0); + scroll_step = NK_MIN(step, button_pixel_inc); + + /* decrement button */ + button.y = scroll.y; + if (nk_do_button_symbol(&ws, out, button, style->dec_symbol, + NK_BUTTON_REPEATER, &style->dec_button, in, font)) + offset = offset - scroll_step; + + /* increment button */ + button.y = scroll.y + scroll.h - button.h; + if (nk_do_button_symbol(&ws, out, button, style->inc_symbol, + NK_BUTTON_REPEATER, &style->inc_button, in, font)) + offset = offset + scroll_step; + + scroll.y = scroll.y + button.h; + scroll.h = scroll_h; + } + + /* calculate scrollbar constants */ + scroll_step = NK_MIN(step, scroll.h); + scroll_offset = NK_CLAMP(0, offset, target - scroll.h); + scroll_ratio = scroll.h / target; + scroll_off = scroll_offset / target; + + /* calculate scrollbar cursor bounds */ + cursor.h = NK_MAX((scroll_ratio * scroll.h) - (2*style->border + 2*style->padding.y), 0); + cursor.y = scroll.y + (scroll_off * scroll.h) + style->border + style->padding.y; + cursor.w = scroll.w - (2 * style->border + 2 * style->padding.x); + cursor.x = scroll.x + style->border + style->padding.x; + + /* calculate empty space around cursor */ + empty_north.x = scroll.x; + empty_north.y = scroll.y; + empty_north.w = scroll.w; + empty_north.h = NK_MAX(cursor.y - scroll.y, 0); + + empty_south.x = scroll.x; + empty_south.y = cursor.y + cursor.h; + empty_south.w = scroll.w; + empty_south.h = NK_MAX((scroll.y + scroll.h) - (cursor.y + cursor.h), 0); + + /* update scrollbar */ + scroll_offset = nk_scrollbar_behavior(state, in, has_scrolling, &scroll, &cursor, + &empty_north, &empty_south, scroll_offset, target, scroll_step, NK_VERTICAL); + scroll_off = scroll_offset / target; + cursor.y = scroll.y + (scroll_off * scroll.h) + style->border_cursor + style->padding.y; + + /* draw scrollbar */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_scrollbar(out, *state, style, &scroll, &cursor); + if (style->draw_end) style->draw_end(out, style->userdata); + return scroll_offset; +} +NK_LIB int +nk_do_scrollbarh(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, + int offset, int target, int step, int button_pixel_inc, + const struct nk_style_scrollbar *style, struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + struct nk_rect cursor; + struct nk_rect empty_west; + struct nk_rect empty_east; + + int scroll_step; + int scroll_offset; + int scroll_off; + int scroll_ratio; + + // NK_ASSERT(out); + // NK_ASSERT(style); + if (!out || !style) return 0; + + /* scrollbar background */ + scroll.h = NK_MAX(scroll.h, 1); + scroll.w = NK_MAX(scroll.w, 2 * scroll.h); + if (target <= scroll.w) return 0; + + /* optional scrollbar buttons */ + if (style->show_buttons) { + nk_flags ws; + int scroll_w; + struct nk_rect button; + button.y = scroll.y; + button.w = scroll.h; + button.h = scroll.h; + + scroll_w = scroll.w - 2 * button.w; + scroll_step = NK_MIN(step, button_pixel_inc); + + /* decrement button */ + button.x = scroll.x; + if (nk_do_button_symbol(&ws, out, button, style->dec_symbol, + NK_BUTTON_REPEATER, &style->dec_button, in, font)) + offset = offset - scroll_step; + + /* increment button */ + button.x = scroll.x + scroll.w - button.w; + if (nk_do_button_symbol(&ws, out, button, style->inc_symbol, + NK_BUTTON_REPEATER, &style->inc_button, in, font)) + offset = offset + scroll_step; + + scroll.x = scroll.x + button.w; + scroll.w = scroll_w; + } + + /* calculate scrollbar constants */ + scroll_step = NK_MIN(step, scroll.w); + scroll_offset = NK_CLAMP(0, offset, target - scroll.w); + scroll_ratio = scroll.w / target; + scroll_off = scroll_offset / target; + + /* calculate cursor bounds */ + cursor.w = (scroll_ratio * scroll.w) - (2*style->border + 2*style->padding.x); + cursor.x = scroll.x + (scroll_off * scroll.w) + style->border + style->padding.x; + cursor.h = scroll.h - (2 * style->border + 2 * style->padding.y); + cursor.y = scroll.y + style->border + style->padding.y; + + /* calculate empty space around cursor */ + empty_west.x = scroll.x; + empty_west.y = scroll.y; + empty_west.w = cursor.x - scroll.x; + empty_west.h = scroll.h; + + empty_east.x = cursor.x + cursor.w; + empty_east.y = scroll.y; + empty_east.w = (scroll.x + scroll.w) - (cursor.x + cursor.w); + empty_east.h = scroll.h; + + /* update scrollbar */ + scroll_offset = nk_scrollbar_behavior(state, in, has_scrolling, &scroll, &cursor, + &empty_west, &empty_east, scroll_offset, target, scroll_step, NK_HORIZONTAL); + scroll_off = scroll_offset / target; + cursor.x = scroll.x + (scroll_off * scroll.w); + + /* draw scrollbar */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_scrollbar(out, *state, style, &scroll, &cursor); + if (style->draw_end) style->draw_end(out, style->userdata); + return scroll_offset; +} + + + + + +/* =============================================================== + * + * TEXT EDITOR + * + * ===============================================================*/ +/* stb_textedit.h - v1.8 - public domain - Sean Barrett */ +struct nk_text_find { + int x,y; /* position of n'th character */ + int height; /* height of line */ + int first_char, length; /* first char of row, and length */ + int prev_first; /*_ first char of previous row */ +}; + +struct nk_text_edit_row { + int x0,x1; + /* starting x location, end x location (allows for align=right, etc) */ + int baseline_y_delta; + /* position of baseline relative to previous row's baseline*/ + int ymin,ymax; + /* height of row above and below baseline */ + int num_chars; +}; + +/* forward declarations */ +NK_INTERN void nk_textedit_makeundo_delete(struct nk_text_edit*, int, int); +NK_INTERN void nk_textedit_makeundo_insert(struct nk_text_edit*, int, int); +NK_INTERN void nk_textedit_makeundo_replace(struct nk_text_edit*, int, int, int); +#define NK_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end) + +NK_INTERN int +nk_textedit_get_width(const struct nk_text_edit *edit, int line_start, int char_id, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int len = 0; + nk_rune unicode = 0; + const char *str = nk_str_at_const(&edit->string, line_start + char_id, &unicode, &len); + return font->width(font->userdata, font->height, str, len); +} +NK_INTERN void +nk_textedit_layout_row(struct nk_text_edit_row *r, struct nk_text_edit *edit, + int line_start_id, int row_height, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - line_start_id, / int"); + int l; + int glyphs = 0; + nk_rune unicode; + const char *remaining; + int len = nk_str_len_char(&edit->string); + const char *end = nk_str_get_const(&edit->string) + len; + const char *text = nk_str_at_const(&edit->string, line_start_id, &unicode, &l); + const struct nk_vec2 size = nk_text_calculate_text_bounds(font, + text, (int)(end - text), row_height, &remaining, 0, &glyphs, NK_STOP_ON_NEW_LINE); + + r->x0 = 0.0f; + r->x1 = size.x; + r->baseline_y_delta = size.y; + r->ymin = 0.0f; + r->ymax = size.y; + r->num_chars = glyphs; +} +NK_INTERN int +nk_textedit_locate_coord(struct nk_text_edit *edit, int x, int y, + const struct nk_user_font *font, int row_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + struct nk_text_edit_row r; + int n = edit->string.len; + int base_y = 0, prev_x; + int i=0, k; + + r.x0 = r.x1 = 0; + r.ymin = r.ymax = 0; + r.num_chars = 0; + + /* search rows to find one that straddles 'y' */ + while (i < n) { + nk_textedit_layout_row(&r, edit, i, row_height, font); + if (r.num_chars <= 0) + return n; + + if (i==0 && y < base_y + r.ymin) + return 0; + + if (y < base_y + r.ymax) + break; + + i += r.num_chars; + base_y += r.baseline_y_delta; + } + + /* below all text, return 'after' last character */ + if (i >= n) + return n; + + /* check if it's before the beginning of the line */ + if (x < r.x0) + return i; + + /* check if it's before the end of the line */ + if (x < r.x1) { + /* search characters in row for one that straddles 'x' */ + k = i; + prev_x = r.x0; + for (i=0; i < r.num_chars; ++i) { + int w = nk_textedit_get_width(edit, k, i, font); + if (x < prev_x+w) { + if (x < prev_x+w/2) + return k+i; + else return k+i+1; + } + prev_x += w; + } + /* shouldn't happen, but if it does, fall through to end-of-line case */ + } + + /* if the last character is a newline, return that. + * otherwise return 'after' the last character */ + if (nk_str_rune_at(&edit->string, i+r.num_chars-1) == '\n') + return i+r.num_chars-1; + else return i+r.num_chars; +} +NK_LIB void +nk_textedit_click(struct nk_text_edit *state, int x, int y, + const struct nk_user_font *font, int row_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + /* API click: on mouse down, move the cursor to the clicked location, + * and reset the selection */ + state->cursor = nk_textedit_locate_coord(state, x, y, font, row_height); + state->select_start = state->cursor; + state->select_end = state->cursor; + state->has_preferred_x = 0; +} +NK_LIB void +nk_textedit_drag(struct nk_text_edit *state, int x, int y, + const struct nk_user_font *font, int row_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + /* API drag: on mouse drag, move the cursor and selection endpoint + * to the clicked location */ + int p = nk_textedit_locate_coord(state, x, y, font, row_height); + if (state->select_start == state->select_end) + state->select_start = state->cursor; + state->cursor = state->select_end = p; +} +NK_INTERN void +nk_textedit_find_charpos(struct nk_text_find *find, struct nk_text_edit *state, + int n, int single_line, const struct nk_user_font *font, int row_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - n, / int"); + /* find the x/y location of a character, and remember info about the previous + * row in case we get a move-up event (for page up, we'll have to rescan) */ + struct nk_text_edit_row r; + int prev_start = 0; + int z = state->string.len; + int i=0, first; + + nk_zero_struct(r); + if (n == z) { + /* if it's at the end, then find the last line -- simpler than trying to + explicitly handle this case in the regular code */ + nk_textedit_layout_row(&r, state, 0, row_height, font); + if (single_line) { + find->first_char = 0; + find->length = z; + } else { + while (i < z) { + prev_start = i; + i += r.num_chars; + nk_textedit_layout_row(&r, state, i, row_height, font); + } + + find->first_char = i; + find->length = r.num_chars; + } + find->x = r.x1; + find->y = r.ymin; + find->height = r.ymax - r.ymin; + find->prev_first = prev_start; + return; + } + + /* search rows to find the one that straddles character n */ + find->y = 0; + + for(;;) { + nk_textedit_layout_row(&r, state, i, row_height, font); + if (n < i + r.num_chars) break; + prev_start = i; + i += r.num_chars; + find->y += r.baseline_y_delta; + } + + find->first_char = first = i; + find->length = r.num_chars; + find->height = r.ymax - r.ymin; + find->prev_first = prev_start; + + /* now scan to find xpos */ + find->x = r.x0; + for (i=0; first+i < n; ++i) + find->x += nk_textedit_get_width(state, first, i, font); +} +NK_INTERN void +nk_textedit_clamp(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_clamp"); + /* make the selection/cursor state valid if client altered the string */ + int n = state->string.len; + if (NK_TEXT_HAS_SELECTION(state)) { + if (state->select_start > n) state->select_start = n; + if (state->select_end > n) state->select_end = n; + /* if clamping forced them to be equal, move the cursor to match */ + if (state->select_start == state->select_end) + state->cursor = state->select_start; + } + if (state->cursor > n) state->cursor = n; +} +NK_API void +nk_textedit_delete(struct nk_text_edit *state, int where, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_delete"); + /* delete characters while updating undo */ + nk_textedit_makeundo_delete(state, where, len); + nk_str_delete_runes(&state->string, where, len); + state->has_preferred_x = 0; +} +NK_API void +nk_textedit_delete_selection(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_delete_selection"); + /* delete the section */ + nk_textedit_clamp(state); + if (NK_TEXT_HAS_SELECTION(state)) { + if (state->select_start < state->select_end) { + nk_textedit_delete(state, state->select_start, + state->select_end - state->select_start); + state->select_end = state->cursor = state->select_start; + } else { + nk_textedit_delete(state, state->select_end, + state->select_start - state->select_end); + state->select_start = state->cursor = state->select_end; + } + state->has_preferred_x = 0; + } +} +NK_INTERN void +nk_textedit_sortselection(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_sortselection"); + /* canonicalize the selection so start <= end */ + if (state->select_end < state->select_start) { + int temp = state->select_end; + state->select_end = state->select_start; + state->select_start = temp; + } +} +NK_INTERN void +nk_textedit_move_to_first(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_move_to_first"); + /* move cursor to first character of selection */ + if (NK_TEXT_HAS_SELECTION(state)) { + nk_textedit_sortselection(state); + state->cursor = state->select_start; + state->select_end = state->select_start; + state->has_preferred_x = 0; + } +} +NK_INTERN void +nk_textedit_move_to_last(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_move_to_last"); + /* move cursor to last character of selection */ + if (NK_TEXT_HAS_SELECTION(state)) { + nk_textedit_sortselection(state); + nk_textedit_clamp(state); + state->cursor = state->select_end; + state->select_start = state->select_end; + state->has_preferred_x = 0; + } +} +NK_INTERN int +nk_is_word_boundary( struct nk_text_edit *state, int idx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_is_word_boundary"); + int len; + nk_rune c; + if (idx <= 0) return 1; + if (!nk_str_at_rune(&state->string, idx, &c, &len)) return 1; + return (c == ' ' || c == '\t' ||c == 0x3000 || c == ',' || c == ';' || + c == '(' || c == ')' || c == '{' || c == '}' || c == '[' || c == ']' || + c == '|'); +} +NK_INTERN int +nk_textedit_move_to_word_previous(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_move_to_word_previous"); + int c = state->cursor - 1; + while( c >= 0 && !nk_is_word_boundary(state, c)) + --c; + + if( c < 0 ) + c = 0; + + return c; +} +NK_INTERN int +nk_textedit_move_to_word_next(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_move_to_word_next"); + const int len = state->string.len; + int c = state->cursor+1; + while( c < len && !nk_is_word_boundary(state, c)) + ++c; + + if( c > len ) + c = len; + + return c; +} +NK_INTERN void +nk_textedit_prep_selection_at_cursor(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_prep_selection_at_cursor"); + /* update selection and cursor to match each other */ + if (!NK_TEXT_HAS_SELECTION(state)) + state->select_start = state->select_end = state->cursor; + else state->cursor = state->select_end; +} +NK_API nk_bool +nk_textedit_cut(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_cut"); + /* API cut: delete selection */ + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) + return 0; + if (NK_TEXT_HAS_SELECTION(state)) { + nk_textedit_delete_selection(state); /* implicitly clamps */ + state->has_preferred_x = 0; + return 1; + } + return 0; +} +NK_API nk_bool +nk_textedit_paste(struct nk_text_edit *state, char const *ctext, int len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_paste"); + /* API paste: replace existing selection with passed-in text */ + int glyphs; + const char *text = (const char *) ctext; + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) return 0; + + /* if there's a selection, the paste should delete it */ + nk_textedit_clamp(state); + nk_textedit_delete_selection(state); + + /* try to insert the characters */ + glyphs = nk_utf_len(ctext, len); + if (nk_str_insert_text_char(&state->string, state->cursor, text, len)) { + nk_textedit_makeundo_insert(state, state->cursor, glyphs); + state->cursor += len; + state->has_preferred_x = 0; + return 1; + } + /* remove the undo since we didn't actually insert the characters */ + if (state->undo.undo_point) + --state->undo.undo_point; + return 0; +} +NK_API void +nk_textedit_text(struct nk_text_edit *state, const char *text, int total_len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_text"); + nk_rune unicode; + int glyph_len; + int text_len = 0; + + // NK_ASSERT(state); + // NK_ASSERT(text); + if (!text || !total_len || state->mode == NK_TEXT_EDIT_MODE_VIEW) return; + + glyph_len = nk_utf_decode(text, &unicode, total_len); + while ((text_len < total_len) && glyph_len) + { + /* don't insert a backward delete, just process the event */ + if (unicode == 127) goto next; + /* can't add newline in single-line mode */ + if (unicode == '\n' && state->single_line) goto next; + /* filter incoming text */ + if (state->filter && !state->filter(state, unicode)) goto next; + + if (!NK_TEXT_HAS_SELECTION(state) && state->cursor < state->string.len) + { + if (state->mode == NK_TEXT_EDIT_MODE_REPLACE) { + nk_textedit_makeundo_replace(state, state->cursor, 1, 1); + nk_str_delete_runes(&state->string, state->cursor, 1); + } + if (nk_str_insert_text_utf8(&state->string, state->cursor, + text+text_len, 1)) + { + ++state->cursor; + state->has_preferred_x = 0; + } + } else { + nk_textedit_delete_selection(state); /* implicitly clamps */ + if (nk_str_insert_text_utf8(&state->string, state->cursor, + text+text_len, 1)) + { + nk_textedit_makeundo_insert(state, state->cursor, 1); + ++state->cursor; + state->has_preferred_x = 0; + } + } + next: + text_len += glyph_len; + glyph_len = nk_utf_decode(text + text_len, &unicode, total_len-text_len); + } +} +NK_LIB void +nk_textedit_key(struct nk_text_edit *state, enum nk_keys key, int shift_mod, + const struct nk_user_font *font, int row_height) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); +retry: + switch (key) + { + case NK_KEY_NONE: + case NK_KEY_CTRL: + case NK_KEY_ENTER: + case NK_KEY_SHIFT: + case NK_KEY_TAB: + case NK_KEY_COPY: + case NK_KEY_CUT: + case NK_KEY_PASTE: + case NK_KEY_MAX: + default: break; + case NK_KEY_TEXT_UNDO: + nk_textedit_undo(state); + state->has_preferred_x = 0; + break; + + case NK_KEY_TEXT_REDO: + nk_textedit_redo(state); + state->has_preferred_x = 0; + break; + + case NK_KEY_TEXT_SELECT_ALL: + nk_textedit_select_all(state); + state->has_preferred_x = 0; + break; + + case NK_KEY_TEXT_INSERT_MODE: + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) + state->mode = NK_TEXT_EDIT_MODE_INSERT; + break; + case NK_KEY_TEXT_REPLACE_MODE: + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) + state->mode = NK_TEXT_EDIT_MODE_REPLACE; + break; + case NK_KEY_TEXT_RESET_MODE: + if (state->mode == NK_TEXT_EDIT_MODE_INSERT || + state->mode == NK_TEXT_EDIT_MODE_REPLACE) + state->mode = NK_TEXT_EDIT_MODE_VIEW; + break; + + case NK_KEY_LEFT: + if (shift_mod) { + nk_textedit_clamp(state); + nk_textedit_prep_selection_at_cursor(state); + /* move selection left */ + if (state->select_end > 0) + --state->select_end; + state->cursor = state->select_end; + state->has_preferred_x = 0; + } else { + /* if currently there's a selection, + * move cursor to start of selection */ + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_first(state); + else if (state->cursor > 0) + --state->cursor; + state->has_preferred_x = 0; + } break; + + case NK_KEY_RIGHT: + if (shift_mod) { + nk_textedit_prep_selection_at_cursor(state); + /* move selection right */ + ++state->select_end; + nk_textedit_clamp(state); + state->cursor = state->select_end; + state->has_preferred_x = 0; + } else { + /* if currently there's a selection, + * move cursor to end of selection */ + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_last(state); + else ++state->cursor; + nk_textedit_clamp(state); + state->has_preferred_x = 0; + } break; + + case NK_KEY_TEXT_WORD_LEFT: + if (shift_mod) { + if( !NK_TEXT_HAS_SELECTION( state ) ) + nk_textedit_prep_selection_at_cursor(state); + state->cursor = nk_textedit_move_to_word_previous(state); + state->select_end = state->cursor; + nk_textedit_clamp(state ); + } else { + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_first(state); + else { + state->cursor = nk_textedit_move_to_word_previous(state); + nk_textedit_clamp(state ); + } + } break; + + case NK_KEY_TEXT_WORD_RIGHT: + if (shift_mod) { + if( !NK_TEXT_HAS_SELECTION( state ) ) + nk_textedit_prep_selection_at_cursor(state); + state->cursor = nk_textedit_move_to_word_next(state); + state->select_end = state->cursor; + nk_textedit_clamp(state); + } else { + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_last(state); + else { + state->cursor = nk_textedit_move_to_word_next(state); + nk_textedit_clamp(state ); + } + } break; + + case NK_KEY_DOWN: { + struct nk_text_find find; + struct nk_text_edit_row row; + int i, sel = shift_mod; + + if (state->single_line) { + /* on windows, up&down in single-line behave like left&right */ + key = NK_KEY_RIGHT; + goto retry; + } + + if (sel) + nk_textedit_prep_selection_at_cursor(state); + else if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_last(state); + + /* compute current position of cursor point */ + nk_textedit_clamp(state); + nk_textedit_find_charpos(&find, state, state->cursor, state->single_line, + font, row_height); + + /* now find character position down a row */ + if (find.length) + { + int x; + int goal_x = state->has_preferred_x ? state->preferred_x : find.x; + int start = find.first_char + find.length; + + state->cursor = start; + nk_textedit_layout_row(&row, state, state->cursor, row_height, font); + x = row.x0; + + for (i=0; i < row.num_chars && x < row.x1; ++i) { + int dx = nk_textedit_get_width(state, start, i, font); + x += dx; + if (x > goal_x) + break; + ++state->cursor; + } + nk_textedit_clamp(state); + + state->has_preferred_x = 1; + state->preferred_x = goal_x; + if (sel) + state->select_end = state->cursor; + } + } break; + + case NK_KEY_UP: { + struct nk_text_find find; + struct nk_text_edit_row row; + int i, sel = shift_mod; + + if (state->single_line) { + /* on windows, up&down become left&right */ + key = NK_KEY_LEFT; + goto retry; + } + + if (sel) + nk_textedit_prep_selection_at_cursor(state); + else if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_move_to_first(state); + + /* compute current position of cursor point */ + nk_textedit_clamp(state); + nk_textedit_find_charpos(&find, state, state->cursor, state->single_line, + font, row_height); + + /* can only go up if there's a previous row */ + if (find.prev_first != find.first_char) { + /* now find character position up a row */ + int x; + int goal_x = state->has_preferred_x ? state->preferred_x : find.x; + + state->cursor = find.prev_first; + nk_textedit_layout_row(&row, state, state->cursor, row_height, font); + x = row.x0; + + for (i=0; i < row.num_chars && x < row.x1; ++i) { + int dx = nk_textedit_get_width(state, find.prev_first, i, font); + x += dx; + if (x > goal_x) + break; + ++state->cursor; + } + nk_textedit_clamp(state); + + state->has_preferred_x = 1; + state->preferred_x = goal_x; + if (sel) state->select_end = state->cursor; + } + } break; + + case NK_KEY_DEL: + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) + break; + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_delete_selection(state); + else { + int n = state->string.len; + if (state->cursor < n) + nk_textedit_delete(state, state->cursor, 1); + } + state->has_preferred_x = 0; + break; + + case NK_KEY_BACKSPACE: + if (state->mode == NK_TEXT_EDIT_MODE_VIEW) + break; + if (NK_TEXT_HAS_SELECTION(state)) + nk_textedit_delete_selection(state); + else { + nk_textedit_clamp(state); + if (state->cursor > 0) { + nk_textedit_delete(state, state->cursor-1, 1); + --state->cursor; + } + } + state->has_preferred_x = 0; + break; + + case NK_KEY_TEXT_START: + if (shift_mod) { + nk_textedit_prep_selection_at_cursor(state); + state->cursor = state->select_end = 0; + state->has_preferred_x = 0; + } else { + state->cursor = state->select_start = state->select_end = 0; + state->has_preferred_x = 0; + } + break; + + case NK_KEY_TEXT_END: + if (shift_mod) { + nk_textedit_prep_selection_at_cursor(state); + state->cursor = state->select_end = state->string.len; + state->has_preferred_x = 0; + } else { + state->cursor = state->string.len; + state->select_start = state->select_end = 0; + state->has_preferred_x = 0; + } + break; + + case NK_KEY_TEXT_LINE_START: { + if (shift_mod) { + struct nk_text_find find; + nk_textedit_clamp(state); + nk_textedit_prep_selection_at_cursor(state); + if (state->string.len && state->cursor == state->string.len) + --state->cursor; + nk_textedit_find_charpos(&find, state,state->cursor, state->single_line, + font, row_height); + state->cursor = state->select_end = find.first_char; + state->has_preferred_x = 0; + } else { + struct nk_text_find find; + if (state->string.len && state->cursor == state->string.len) + --state->cursor; + nk_textedit_clamp(state); + nk_textedit_move_to_first(state); + nk_textedit_find_charpos(&find, state, state->cursor, state->single_line, + font, row_height); + state->cursor = find.first_char; + state->has_preferred_x = 0; + } + } break; + + case NK_KEY_TEXT_LINE_END: { + if (shift_mod) { + struct nk_text_find find; + nk_textedit_clamp(state); + nk_textedit_prep_selection_at_cursor(state); + nk_textedit_find_charpos(&find, state, state->cursor, state->single_line, + font, row_height); + state->has_preferred_x = 0; + state->cursor = find.first_char + find.length; + if (find.length > 0 && nk_str_rune_at(&state->string, state->cursor-1) == '\n') + --state->cursor; + state->select_end = state->cursor; + } else { + struct nk_text_find find; + nk_textedit_clamp(state); + nk_textedit_move_to_first(state); + nk_textedit_find_charpos(&find, state, state->cursor, state->single_line, + font, row_height); + + state->has_preferred_x = 0; + state->cursor = find.first_char + find.length; + if (find.length > 0 && nk_str_rune_at(&state->string, state->cursor-1) == '\n') + --state->cursor; + }} break; + } +} +NK_INTERN void +nk_textedit_flush_redo(struct nk_text_undo_state *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_undo_state / nk_textedit_flush_redo"); + state->redo_point = NK_TEXTEDIT_UNDOSTATECOUNT; + state->redo_char_point = NK_TEXTEDIT_UNDOCHARCOUNT; +} +NK_INTERN void +nk_textedit_discard_undo(struct nk_text_undo_state *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_undo_state / nk_textedit_discard_undo"); + /* discard the oldest entry in the undo list */ + if (state->undo_point > 0) { + /* if the 0th undo state has characters, clean those up */ + if (state->undo_rec[0].char_storage >= 0) { + int n = state->undo_rec[0].insert_length, i; + /* delete n characters from all other records */ + state->undo_char_point = (short)(state->undo_char_point - n); + NK_MEMCPY(state->undo_char, state->undo_char + n, + (nk_size)state->undo_char_point*sizeof(nk_rune)); + for (i=0; i < state->undo_point; ++i) { + if (state->undo_rec[i].char_storage >= 0) + state->undo_rec[i].char_storage = (short) + (state->undo_rec[i].char_storage - n); + } + } + --state->undo_point; + NK_MEMCPY(state->undo_rec, state->undo_rec+1, + (nk_size)((nk_size)state->undo_point * sizeof(state->undo_rec[0]))); + } +} +NK_INTERN void +nk_textedit_discard_redo(struct nk_text_undo_state *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_undo_state / nk_textedit_discard_redo"); +/* discard the oldest entry in the redo list--it's bad if this + ever happens, but because undo & redo have to store the actual + characters in different cases, the redo character buffer can + fill up even though the undo buffer didn't */ + nk_size num; + int k = NK_TEXTEDIT_UNDOSTATECOUNT-1; + if (state->redo_point <= k) { + /* if the k'th undo state has characters, clean those up */ + if (state->undo_rec[k].char_storage >= 0) { + int n = state->undo_rec[k].insert_length, i; + /* delete n characters from all other records */ + state->redo_char_point = (short)(state->redo_char_point + n); + num = (nk_size)(NK_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point); + NK_MEMCPY(state->undo_char + state->redo_char_point, + state->undo_char + state->redo_char_point-n, num * sizeof(char)); + for (i = state->redo_point; i < k; ++i) { + if (state->undo_rec[i].char_storage >= 0) { + state->undo_rec[i].char_storage = (short) + (state->undo_rec[i].char_storage + n); + } + } + } + ++state->redo_point; + num = (nk_size)(NK_TEXTEDIT_UNDOSTATECOUNT - state->redo_point); + if (num) NK_MEMCPY(state->undo_rec + state->redo_point-1, + state->undo_rec + state->redo_point, num * sizeof(state->undo_rec[0])); + } +} +NK_INTERN struct nk_text_undo_record* +nk_textedit_create_undo_record(struct nk_text_undo_state *state, int numchars) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_undo_state / nk_textedit_create_undo_record"); + /* any time we create a new undo record, we discard redo*/ + nk_textedit_flush_redo(state); + + /* if we have no free records, we have to make room, + * by sliding the existing records down */ + if (state->undo_point == NK_TEXTEDIT_UNDOSTATECOUNT) + nk_textedit_discard_undo(state); + + /* if the characters to store won't possibly fit in the buffer, + * we can't undo */ + if (numchars > NK_TEXTEDIT_UNDOCHARCOUNT) { + state->undo_point = 0; + state->undo_char_point = 0; + return 0; + } + + /* if we don't have enough free characters in the buffer, + * we have to make room */ + while (state->undo_char_point + numchars > NK_TEXTEDIT_UNDOCHARCOUNT) + nk_textedit_discard_undo(state); + return &state->undo_rec[state->undo_point++]; +} +NK_INTERN nk_rune* +nk_textedit_createundo(struct nk_text_undo_state *state, int pos, + int insert_len, int delete_len) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - insert_len, / int"); + struct nk_text_undo_record *r = nk_textedit_create_undo_record(state, insert_len); + if (r == 0) + return 0; + + r->where = pos; + r->insert_length = (short) insert_len; + r->delete_length = (short) delete_len; + + if (insert_len == 0) { + r->char_storage = -1; + return 0; + } else { + r->char_storage = state->undo_char_point; + state->undo_char_point = (short)(state->undo_char_point + insert_len); + return &state->undo_char[r->char_storage]; + } +} +NK_API void +nk_textedit_undo(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_undo"); + struct nk_text_undo_state *s = &state->undo; + struct nk_text_undo_record u, *r; + if (s->undo_point == 0) + return; + + /* we need to do two things: apply the undo record, and create a redo record */ + u = s->undo_rec[s->undo_point-1]; + r = &s->undo_rec[s->redo_point-1]; + r->char_storage = -1; + + r->insert_length = u.delete_length; + r->delete_length = u.insert_length; + r->where = u.where; + + if (u.delete_length) + { + /* if the undo record says to delete characters, then the redo record will + need to re-insert the characters that get deleted, so we need to store + them. + there are three cases: + - there's enough room to store the characters + - characters stored for *redoing* don't leave room for redo + - characters stored for *undoing* don't leave room for redo + if the last is true, we have to bail */ + if (s->undo_char_point + u.delete_length >= NK_TEXTEDIT_UNDOCHARCOUNT) { + /* the undo records take up too much character space; there's no space + * to store the redo characters */ + r->insert_length = 0; + } else { + int i; + /* there's definitely room to store the characters eventually */ + while (s->undo_char_point + u.delete_length > s->redo_char_point) { + /* there's currently not enough room, so discard a redo record */ + nk_textedit_discard_redo(s); + /* should never happen: */ + if (s->redo_point == NK_TEXTEDIT_UNDOSTATECOUNT) + return; + } + + r = &s->undo_rec[s->redo_point-1]; + r->char_storage = (short)(s->redo_char_point - u.delete_length); + s->redo_char_point = (short)(s->redo_char_point - u.delete_length); + + /* now save the characters */ + for (i=0; i < u.delete_length; ++i) + s->undo_char[r->char_storage + i] = + nk_str_rune_at(&state->string, u.where + i); + } + /* now we can carry out the deletion */ + nk_str_delete_runes(&state->string, u.where, u.delete_length); + } + + /* check type of recorded action: */ + if (u.insert_length) { + /* easy case: was a deletion, so we need to insert n characters */ + nk_str_insert_text_runes(&state->string, u.where, + &s->undo_char[u.char_storage], u.insert_length); + s->undo_char_point = (short)(s->undo_char_point - u.insert_length); + } + state->cursor = (short)(u.where + u.insert_length); + + s->undo_point--; + s->redo_point--; +} +NK_API void +nk_textedit_redo(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_redo"); + struct nk_text_undo_state *s = &state->undo; + struct nk_text_undo_record *u, r; + if (s->redo_point == NK_TEXTEDIT_UNDOSTATECOUNT) + return; + + /* we need to do two things: apply the redo record, and create an undo record */ + u = &s->undo_rec[s->undo_point]; + r = s->undo_rec[s->redo_point]; + + /* we KNOW there must be room for the undo record, because the redo record + was derived from an undo record */ + u->delete_length = r.insert_length; + u->insert_length = r.delete_length; + u->where = r.where; + u->char_storage = -1; + + if (r.delete_length) { + /* the redo record requires us to delete characters, so the undo record + needs to store the characters */ + if (s->undo_char_point + u->insert_length > s->redo_char_point) { + u->insert_length = 0; + u->delete_length = 0; + } else { + int i; + u->char_storage = s->undo_char_point; + s->undo_char_point = (short)(s->undo_char_point + u->insert_length); + + /* now save the characters */ + for (i=0; i < u->insert_length; ++i) { + s->undo_char[u->char_storage + i] = + nk_str_rune_at(&state->string, u->where + i); + } + } + nk_str_delete_runes(&state->string, r.where, r.delete_length); + } + + if (r.insert_length) { + /* easy case: need to insert n characters */ + nk_str_insert_text_runes(&state->string, r.where, + &s->undo_char[r.char_storage], r.insert_length); + } + state->cursor = r.where + r.insert_length; + + s->undo_point++; + s->redo_point++; +} +NK_INTERN void +nk_textedit_makeundo_insert(struct nk_text_edit *state, int where, int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_makeundo_insert"); + nk_textedit_createundo(&state->undo, where, 0, length); +} +NK_INTERN void +nk_textedit_makeundo_delete(struct nk_text_edit *state, int where, int length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_makeundo_delete"); + int i; + nk_rune *p = nk_textedit_createundo(&state->undo, where, length, 0); + if (p) { + for (i=0; i < length; ++i) + p[i] = nk_str_rune_at(&state->string, where+i); + } +} +NK_INTERN void +nk_textedit_makeundo_replace(struct nk_text_edit *state, int where, + int old_length, int new_length) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - old_length, / int"); + int i; + nk_rune *p = nk_textedit_createundo(&state->undo, where, old_length, new_length); + if (p) { + for (i=0; i < old_length; ++i) + p[i] = nk_str_rune_at(&state->string, where+i); + } +} +NK_LIB void +nk_textedit_clear_state(struct nk_text_edit *state, enum nk_text_edit_type type, + nk_plugin_filter filter) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - filter) / nk_plugin_filter"); + /* reset the state to default */ + state->undo.undo_point = 0; + state->undo.undo_char_point = 0; + state->undo.redo_point = NK_TEXTEDIT_UNDOSTATECOUNT; + state->undo.redo_char_point = NK_TEXTEDIT_UNDOCHARCOUNT; + state->select_end = state->select_start = 0; + state->cursor = 0; + state->has_preferred_x = 0; + state->preferred_x = 0; + state->cursor_at_end_of_line = 0; + state->initialized = 1; + state->single_line = (unsigned char)(type == NK_TEXT_EDIT_SINGLE_LINE); + state->mode = NK_TEXT_EDIT_MODE_VIEW; + state->filter = filter; + state->scrollbar = nk_vec2(0,0); +} +NK_API void +nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_init_fixed"); + // NK_ASSERT(state); + // NK_ASSERT(memory); + if (!state || !memory || !size) return; + NK_MEMSET(state, 0, sizeof(struct nk_text_edit)); + nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0); + nk_str_init_fixed(&state->string, memory, size); +} +NK_API void +nk_textedit_init(struct nk_text_edit *state, struct nk_allocator *alloc, nk_size size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_init"); + // NK_ASSERT(state); + // NK_ASSERT(alloc); + if (!state || !alloc) return; + NK_MEMSET(state, 0, sizeof(struct nk_text_edit)); + nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0); + nk_str_init(&state->string, alloc, size); +} +#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR +NK_API void +nk_textedit_init_default(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_init_default"); + // NK_ASSERT(state); + if (!state) return; + NK_MEMSET(state, 0, sizeof(struct nk_text_edit)); + nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0); + nk_str_init_default(&state->string); +} +#endif +NK_API void +nk_textedit_select_all(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_select_all"); + // NK_ASSERT(state); + state->select_start = 0; + state->select_end = state->string.len; +} +NK_API void +nk_textedit_free(struct nk_text_edit *state) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_text_edit / nk_textedit_free"); + // NK_ASSERT(state); + if (!state) return; + nk_str_free(&state->string); +} + + + + + +/* =============================================================== + * + * FILTER + * + * ===============================================================*/ +NK_API nk_bool +nk_filter_default(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_default"); + NK_UNUSED(unicode); + NK_UNUSED(box); + return nk_true; +} +NK_API nk_bool +nk_filter_ascii(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_ascii"); + NK_UNUSED(box); + if (unicode > 128) return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_int(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_int"); + NK_UNUSED(box); + if ((unicode < '0' || unicode > '9') && unicode != '.' && unicode != '-') + return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_decimal(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_decimal"); + NK_UNUSED(box); + if ((unicode < '0' || unicode > '9') && unicode != '-') + return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_hex(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_hex"); + NK_UNUSED(box); + if ((unicode < '0' || unicode > '9') && (unicode < 'a' || unicode > 'f') && (unicode < 'A' || unicode > 'F')) + return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_oct(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_oct"); + NK_UNUSED(box); + if (unicode < '0' || unicode > '7') + return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_binary(const struct nk_text_edit *box, nk_rune unicode) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - struct / nk_filter_binary"); + NK_UNUSED(box); + if (unicode != '0' && unicode != '1') + return nk_false; + else return nk_true; +} + +/* =============================================================== + * + * EDIT + * + * ===============================================================*/ +NK_LIB void +nk_edit_draw_text(struct nk_command_buffer *out, + const struct nk_style_edit *style, int pos_x, int pos_y, + int x_offset, const char *text, int byte_len, int row_height, + const struct nk_user_font *font, struct nk_color background, + struct nk_color foreground, nk_bool is_selected) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - foreground / struct"); + // NK_ASSERT(out); + // NK_ASSERT(font); + // NK_ASSERT(style); + if (!text || !byte_len || !out || !style) return; + + {int glyph_len = 0; + nk_rune unicode = 0; + int text_len = 0; + int line_width = 0; + int glyph_width; + const char *line = text; + int line_offset = 0; + int line_count = 0; + + struct nk_text txt; + txt.padding = nk_vec2(0,0); + txt.background = background; + txt.text = foreground; + + glyph_len = nk_utf_decode(text+text_len, &unicode, byte_len-text_len); + if (!glyph_len) return; + while ((text_len < byte_len) && glyph_len) + { + if (unicode == '\n') { + /* new line separator so draw previous line */ + struct nk_rect label; + label.y = pos_y + line_offset; + label.h = row_height; + label.w = line_width; + label.x = pos_x; + if (!line_count) + label.x += x_offset; + + if (is_selected) /* selection needs to draw different background color */ + nk_fill_rect(out, label, 0, background); + nk_widget_text(out, label, line, (int)((text + text_len) - line), + &txt, NK_TEXT_CENTERED, font); + + text_len++; + line_count++; + line_width = 0; + line = text + text_len; + line_offset += row_height; + glyph_len = nk_utf_decode(text + text_len, &unicode, (int)(byte_len-text_len)); + continue; + } + if (unicode == '\r') { + text_len++; + glyph_len = nk_utf_decode(text + text_len, &unicode, byte_len-text_len); + continue; + } + glyph_width = font->width(font->userdata, font->height, text+text_len, glyph_len); + line_width += (int)glyph_width; + text_len += glyph_len; + glyph_len = nk_utf_decode(text + text_len, &unicode, byte_len-text_len); + continue; + } + if (line_width > 0) { + /* draw last line */ + struct nk_rect label; + label.y = pos_y + line_offset; + label.h = row_height; + label.w = line_width; + label.x = pos_x; + if (!line_count) + label.x += x_offset; + + if (is_selected) + nk_fill_rect(out, label, 0, background); + nk_widget_text(out, label, line, (int)((text + text_len) - line), + &txt, NK_TEXT_LEFT, font); + }} +} +NK_LIB nk_flags +nk_do_edit(nk_flags *state, struct nk_command_buffer *out, + struct nk_rect bounds, nk_flags flags, nk_plugin_filter filter, + struct nk_text_edit *edit, const struct nk_style_edit *style, + struct nk_input *in, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - in / struct"); + struct nk_rect area; + nk_flags ret = 0; + int row_height; + char prev_state = 0; + char is_hovered = 0; + char select_all = 0; + char cursor_follow = 0; + struct nk_rect old_clip; + struct nk_rect clip; + + // NK_ASSERT(state); + // NK_ASSERT(out); + // NK_ASSERT(style); + if (!state || !out || !style) + return ret; + + /* visible text area calculation */ + area.x = bounds.x + style->padding.x + style->border; + area.y = bounds.y + style->padding.y + style->border; + area.w = bounds.w - (2.0f * style->padding.x + 2 * style->border); + area.h = bounds.h - (2.0f * style->padding.y + 2 * style->border); + if (flags & NK_EDIT_MULTILINE) + area.w = NK_MAX(0, area.w - style->scrollbar_size.x); + row_height = (flags & NK_EDIT_MULTILINE)? font->height + style->row_padding: area.h; + + /* calculate clipping rectangle */ + old_clip = out->clip; + nk_unify(&clip, &old_clip, area.x, area.y, area.x + area.w, area.y + area.h); + + /* update edit state */ + prev_state = (char)edit->active; + is_hovered = (char)nk_input_is_mouse_hovering_rect(in, bounds); + if (in && in->mouse.buttons[NK_BUTTON_LEFT].clicked && in->mouse.buttons[NK_BUTTON_LEFT].down) { + edit->active = NK_INBOX(in->mouse.pos.x, in->mouse.pos.y, + bounds.x, bounds.y, bounds.w, bounds.h); + } + + /* (de)activate text editor */ + if (!prev_state && edit->active) { + const enum nk_text_edit_type type = (flags & NK_EDIT_MULTILINE) ? + NK_TEXT_EDIT_MULTI_LINE: NK_TEXT_EDIT_SINGLE_LINE; + /* keep scroll position when re-activating edit widget */ + struct nk_vec2 oldscrollbar = edit->scrollbar; + nk_textedit_clear_state(edit, type, filter); + edit->scrollbar = oldscrollbar; + if (flags & NK_EDIT_AUTO_SELECT) + select_all = nk_true; + if (flags & NK_EDIT_GOTO_END_ON_ACTIVATE) { + edit->cursor = edit->string.len; + in = 0; + } + } else if (!edit->active) edit->mode = NK_TEXT_EDIT_MODE_VIEW; + if (flags & NK_EDIT_READ_ONLY) + edit->mode = NK_TEXT_EDIT_MODE_VIEW; + else if (flags & NK_EDIT_ALWAYS_INSERT_MODE) + edit->mode = NK_TEXT_EDIT_MODE_INSERT; + + ret = (edit->active) ? NK_EDIT_ACTIVE: NK_EDIT_INACTIVE; + if (prev_state != edit->active) + ret |= (edit->active) ? NK_EDIT_ACTIVATED: NK_EDIT_DEACTIVATED; + + /* handle user input */ + if (edit->active && in) + { + int shift_mod = in->keyboard.keys[NK_KEY_SHIFT].down; + const int mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x; + const int mouse_y = (in->mouse.pos.y - area.y) + edit->scrollbar.y; + + /* mouse click handler */ + is_hovered = (char)nk_input_is_mouse_hovering_rect(in, area); + if (select_all) { + nk_textedit_select_all(edit); + } else if (is_hovered && in->mouse.buttons[NK_BUTTON_LEFT].down && in->mouse.buttons[NK_BUTTON_LEFT].clicked) { + nk_textedit_click(edit, mouse_x, mouse_y, font, row_height); + } else if (is_hovered && in->mouse.buttons[NK_BUTTON_LEFT].down && (in->mouse.delta.x != 0.0f || in->mouse.delta.y != 0.0f)) { + nk_textedit_drag(edit, mouse_x, mouse_y, font, row_height); + cursor_follow = nk_true; + } else if (is_hovered && in->mouse.buttons[NK_BUTTON_RIGHT].clicked && in->mouse.buttons[NK_BUTTON_RIGHT].down) { + nk_textedit_key(edit, NK_KEY_TEXT_WORD_LEFT, nk_false, font, row_height); + nk_textedit_key(edit, NK_KEY_TEXT_WORD_RIGHT, nk_true, font, row_height); + cursor_follow = nk_true; + } + + // {int i; /* keyboard input */ + // int old_mode = edit->mode; + // for (i = 0; i < NK_KEY_MAX; ++i) { + // if (i == NK_KEY_ENTER || i == NK_KEY_TAB) continue; /* special case */ + // if (nk_input_is_key_pressed(in, (enum nk_keys)i)) { + // nk_textedit_key(edit, (enum nk_keys)i, shift_mod, font, row_height); + // cursor_follow = nk_true; + // } + // } + // if (old_mode != edit->mode) { + // in->keyboard.text_len = 0; + // }} + + // /* text input */ + // edit->filter = filter; + if (in->keyboard.text_len) { + nk_textedit_text(edit, in->keyboard.text, in->keyboard.text_len); + cursor_follow = nk_true; + in->keyboard.text_len = 0; + } + // cursor_follow = nk_true; + + /* enter key handler */ + if (nk_input_is_key_pressed(in, NK_KEY_ENTER)) { + cursor_follow = nk_true; + if (flags & NK_EDIT_CTRL_ENTER_NEWLINE && shift_mod) + nk_textedit_text(edit, "\n", 1); + else if (flags & NK_EDIT_SIG_ENTER) + ret |= NK_EDIT_COMMITED; + else nk_textedit_text(edit, "\n", 1); + } + + /* cut & copy handler */ + // {int copy= nk_input_is_key_pressed(in, NK_KEY_COPY); + // int cut = nk_input_is_key_pressed(in, NK_KEY_CUT); + // if ((copy || cut) && (flags & NK_EDIT_CLIPBOARD)) + // { + // int glyph_len; + // nk_rune unicode; + // const char *text; + // int b = edit->select_start; + // int e = edit->select_end; + + // int begin = NK_MIN(b, e); + // int end = NK_MAX(b, e); + // text = nk_str_at_const(&edit->string, begin, &unicode, &glyph_len); + // if (edit->clip.copy) + // edit->clip.copy(edit->clip.userdata, text, end - begin); + // if (cut && !(flags & NK_EDIT_READ_ONLY)){ + // nk_textedit_cut(edit); + // cursor_follow = nk_true; + // } + // }} + + // /* paste handler */ + // {int paste = nk_input_is_key_pressed(in, NK_KEY_PASTE); + // if (paste && (flags & NK_EDIT_CLIPBOARD) && edit->clip.paste) { + // edit->clip.paste(edit->clip.userdata, edit); + // cursor_follow = nk_true; + // }} + + // /* tab handler */ + // {int tab = nk_input_is_key_pressed(in, NK_KEY_TAB); + // if (tab && (flags & NK_EDIT_ALLOW_TAB)) { + // nk_textedit_text(edit, " ", 4); + // cursor_follow = nk_true; + // }} + } + + /* set widget state */ + if (edit->active) + *state = NK_WIDGET_STATE_ACTIVE; + else nk_widget_state_reset(state); + + if (is_hovered) + *state |= NK_WIDGET_STATE_HOVERED; + + /* DRAW EDIT */ + {const char *text = nk_str_get_const(&edit->string); + int len = nk_str_len_char(&edit->string); + + // {/* select background colors/images */ + // const struct nk_style_item *background; + // if (*state & NK_WIDGET_STATE_ACTIVED) + // background = &style->active; + // else if (*state & NK_WIDGET_STATE_HOVER) + // background = &style->hover; + // else background = &style->normal; + + // draw background frame + // if (background->type == NK_STYLE_ITEM_COLOR) { + // nk_fill_rect(out, bounds, style->rounding, background->data.color); + nk_stroke_rect(out, bounds, style->rounding, style->border, style->border_color); + // } else nk_draw_image(out, bounds, &background->data.image, nk_white);} + + area.w = NK_MAX(0, area.w - style->cursor_size); + if (edit->active ) // TODO + { + int total_lines = 1; + struct nk_vec2 text_size = nk_vec2(0,0); + + /* text pointer positions */ + const char *cursor_ptr = 0; + const char *select_begin_ptr = 0; + const char *select_end_ptr = 0; + + /* 2D pixel positions */ + struct nk_vec2 cursor_pos = nk_vec2(0,0); + struct nk_vec2 selection_offset_start = nk_vec2(0,0); + struct nk_vec2 selection_offset_end = nk_vec2(0,0); + + int selection_begin = NK_MIN(edit->select_start, edit->select_end); + int selection_end = NK_MAX(edit->select_start, edit->select_end); + + /* calculate total line count + total space + cursor/selection position */ + int line_width = 0.0f; + if (text && len) + { + /* utf8 encoding */ + int glyph_width; + int glyph_len = 0; + nk_rune unicode = 0; + int text_len = 0; + int glyphs = 0; + int row_begin = 0; + + glyph_len = nk_utf_decode(text, &unicode, len); + glyph_width = font->width(font->userdata, font->height, text, glyph_len); + line_width = 0; + + /* iterate all lines */ + while ((text_len < len) && glyph_len) + { + /* set cursor 2D position and line */ + if (!cursor_ptr && glyphs == edit->cursor) + { + int glyph_offset; + struct nk_vec2 out_offset; + struct nk_vec2 row_size; + const char *remaining; + + /* calculate 2d position */ + cursor_pos.y = (int)(total_lines-1) * row_height; + row_size = nk_text_calculate_text_bounds(font, text+row_begin, + text_len-row_begin, row_height, &remaining, + &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE); + cursor_pos.x = row_size.x; + cursor_ptr = text + text_len; + } + + /* set start selection 2D position and line */ + if (!select_begin_ptr && edit->select_start != edit->select_end && glyphs == selection_begin) + { + int glyph_offset; + struct nk_vec2 out_offset; + struct nk_vec2 row_size; + const char *remaining; + + /* calculate 2d position */ + selection_offset_start.y = (int)(NK_MAX(total_lines-1,0)) * row_height; + row_size = nk_text_calculate_text_bounds(font, text+row_begin, + text_len-row_begin, row_height, &remaining, + &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE); + selection_offset_start.x = row_size.x; + select_begin_ptr = text + text_len; + } + + /* set end selection 2D position and line */ + if (!select_end_ptr && edit->select_start != edit->select_end && glyphs == selection_end) + { + int glyph_offset; + struct nk_vec2 out_offset; + struct nk_vec2 row_size; + const char *remaining; + + /* calculate 2d position */ + selection_offset_end.y = (int)(total_lines-1) * row_height; + row_size = nk_text_calculate_text_bounds(font, text+row_begin, + text_len-row_begin, row_height, &remaining, + &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE); + selection_offset_end.x = row_size.x; + select_end_ptr = text + text_len; + } + if (unicode == '\n') { + text_size.x = NK_MAX(text_size.x, line_width); + total_lines++; + line_width = 0; + text_len++; + glyphs++; + row_begin = text_len; + glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len); + glyph_width = font->width(font->userdata, font->height, text+text_len, glyph_len); + continue; + } + + glyphs++; + text_len += glyph_len; + line_width += (int)glyph_width; + + glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len); + glyph_width = font->width(font->userdata, font->height, + text+text_len, glyph_len); + continue; + } + text_size.y = (int)total_lines * row_height; + + /* handle case when cursor is at end of text buffer */ + if (!cursor_ptr && edit->cursor == edit->string.len) { + cursor_pos.x = line_width; + cursor_pos.y = text_size.y - row_height; + } + } + { + /* scrollbar */ + if (cursor_follow) + { + /* update scrollbar to follow cursor */ + if (!(flags & NK_EDIT_NO_HORIZONTAL_SCROLL)) { + /* horizontal scroll */ + const int scroll_increment = area.w * 0.25f; + if (cursor_pos.x < edit->scrollbar.x) + edit->scrollbar.x = (int)(int)NK_MAX(0.0f, cursor_pos.x - scroll_increment); + if (cursor_pos.x >= edit->scrollbar.x + area.w) + edit->scrollbar.x = (int)(int)NK_MAX(0.0f, cursor_pos.x - area.w + scroll_increment); + } else edit->scrollbar.x = 0; + + if (flags & NK_EDIT_MULTILINE) { + /* vertical scroll */ + if (cursor_pos.y < edit->scrollbar.y) + edit->scrollbar.y = NK_MAX(0.0f, cursor_pos.y - row_height); + if (cursor_pos.y >= edit->scrollbar.y + area.h) + edit->scrollbar.y = edit->scrollbar.y + row_height; + } else edit->scrollbar.y = 0; + } + + /* scrollbar widget */ + if (flags & NK_EDIT_MULTILINE) + { + nk_flags ws; + struct nk_rect scroll; + int scroll_target; + int scroll_offset; + int scroll_step; + int scroll_inc; + + scroll = area; + scroll.x = (bounds.x + bounds.w - style->border) - style->scrollbar_size.x; + scroll.w = style->scrollbar_size.x; + + scroll_offset = edit->scrollbar.y; + scroll_step = scroll.h * 0.10f; + scroll_inc = scroll.h * 0.01f; + scroll_target = text_size.y; + edit->scrollbar.y = nk_do_scrollbarv(&ws, out, scroll, 0, + scroll_offset, scroll_target, scroll_step, scroll_inc, + &style->scrollbar, in, font); + } + } + + /* draw text */ + {struct nk_color background_color; + struct nk_color text_color; + struct nk_color sel_background_color; + struct nk_color sel_text_color; + struct nk_color cursor_color; + struct nk_color cursor_text_color; + const struct nk_style_item *background; + // nk_push_scissor(out, clip); + + /* select correct colors to draw */ + if (*state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + text_color = style->text_active; + sel_text_color = style->selected_text_hover; + sel_background_color = style->selected_hover; + cursor_color = style->cursor_hover; + cursor_text_color = style->cursor_text_hover; + } else if (*state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + text_color = style->text_hover; + sel_text_color = style->selected_text_hover; + sel_background_color = style->selected_hover; + cursor_text_color = style->cursor_text_hover; + cursor_color = style->cursor_hover; + } else { + background = &style->normal; + text_color = style->text_normal; + sel_text_color = style->selected_text_normal; + sel_background_color = style->selected_normal; + cursor_color = style->cursor_normal; + cursor_text_color = style->cursor_text_normal; + } + if (background->type == NK_STYLE_ITEM_IMAGE) + background_color = nk_rgba(0,0,0,0); + else background_color = background->data.color; + + + if (edit->select_start == edit->select_end) { + /* no selection so just draw the complete text */ + const char *begin = nk_str_get_const(&edit->string); + int l = nk_str_len_char(&edit->string); + nk_edit_draw_text(out, style, area.x - edit->scrollbar.x, + area.y - edit->scrollbar.y, 0, begin, l, row_height, font, + background_color, text_color, nk_false); + } else { + /* edit has selection so draw 1-3 text chunks */ + if (edit->select_start != edit->select_end && selection_begin > 0){ + /* draw unselected text before selection */ + const char *begin = nk_str_get_const(&edit->string); + // NK_ASSERT(select_begin_ptr); + nk_edit_draw_text(out, style, area.x - edit->scrollbar.x, + area.y - edit->scrollbar.y, 0, begin, (int)(select_begin_ptr - begin), + row_height, font, background_color, text_color, nk_false); + } + if (edit->select_start != edit->select_end) { + /* draw selected text */ + // NK_ASSERT(select_begin_ptr); + if (!select_end_ptr) { + const char *begin = nk_str_get_const(&edit->string); + select_end_ptr = begin + nk_str_len_char(&edit->string); + } + nk_edit_draw_text(out, style, + area.x - edit->scrollbar.x, + area.y + selection_offset_start.y - edit->scrollbar.y, + selection_offset_start.x, + select_begin_ptr, (int)(select_end_ptr - select_begin_ptr), + row_height, font, sel_background_color, sel_text_color, nk_true); + } + if ((edit->select_start != edit->select_end && selection_end < edit->string.len)) + { + /* draw unselected text after selected text */ + const char *begin = select_end_ptr; + const char *end = nk_str_get_const(&edit->string) + + nk_str_len_char(&edit->string); + // NK_ASSERT(select_end_ptr); + nk_edit_draw_text(out, style, + area.x - edit->scrollbar.x, + area.y + selection_offset_end.y - edit->scrollbar.y, + selection_offset_end.x, + begin, (int)(end - begin), row_height, font, + background_color, text_color, nk_true); + } + } + + /* cursor */ + if (edit->select_start == edit->select_end) + { + if (edit->cursor >= nk_str_len(&edit->string) || + (cursor_ptr && *cursor_ptr == '\n')) { + /* draw cursor at end of line */ + struct nk_rect cursor; + cursor.w = style->cursor_size; + cursor.h = font->height; + cursor.x = area.x + cursor_pos.x - edit->scrollbar.x; + cursor.y = area.y + cursor_pos.y + row_height/2.0f - cursor.h/2.0f; + cursor.y -= edit->scrollbar.y; + nk_fill_rect(out, cursor, 0, cursor_color); + } else { + /* draw cursor inside text */ + int glyph_len; + struct nk_rect label; + struct nk_text txt; + + nk_rune unicode; + // NK_ASSERT(cursor_ptr); + glyph_len = nk_utf_decode(cursor_ptr, &unicode, 4); + + label.x = area.x + cursor_pos.x - edit->scrollbar.x; + label.y = area.y + cursor_pos.y - edit->scrollbar.y; + label.w = font->width(font->userdata, font->height, cursor_ptr, glyph_len); + label.h = row_height; + + txt.padding = nk_vec2(0,0); + txt.background = cursor_color;; + txt.text = cursor_text_color; + nk_fill_rect(out, label, 0, cursor_color); + nk_widget_text(out, label, cursor_ptr, glyph_len, &txt, NK_TEXT_LEFT, font); + } + }} + } else { + /* not active so just draw text */ + int l = nk_str_len_char(&edit->string); + const char *begin = nk_str_get_const(&edit->string); + + const struct nk_style_item *background; + struct nk_color background_color; + struct nk_color text_color; + // nk_push_scissor(out, clip); + background = &style->normal; + text_color = style->text_normal; + background_color = background->data.color; + nk_edit_draw_text(out, style, area.x - edit->scrollbar.x, + area.y - edit->scrollbar.y, 0, begin, l, row_height, font, + background_color, text_color, nk_false); + } + // nk_push_scissor(out, old_clip);} + } + return ret; +} +NK_API void +nk_edit_focus(struct nk_context *ctx, nk_flags flags) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_edit_focus"); + nk_hash hash; + struct nk_window *win; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return; + + win = ctx->current; + hash = win->edit.seq; + win->edit.active = nk_true; + win->edit.name = hash; + if (flags & NK_EDIT_ALWAYS_INSERT_MODE) + win->edit.mode = NK_TEXT_EDIT_MODE_INSERT; +} +NK_API void +nk_edit_unfocus(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_edit_unfocus"); + struct nk_window *win; + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return; + + win = ctx->current; + win->edit.active = nk_false; + win->edit.name = 0; +} +NK_API nk_flags +nk_edit_string(struct nk_context *ctx, nk_flags flags, + char *memory, int *len, int max, nk_plugin_filter filter) +{ + + long start; + long end; + long total; + long eventTime0; + long eventTime1; + long eventTime2; + long eventTime3; + long eventTime4; + + start = TickCount(); + + //writeSerialPort(boutRefNum, "FUNCTION CALL - memory, / char"); + nk_hash hash; + nk_flags state; + struct nk_text_edit *edit; + struct nk_window *win; + + // NK_ASSERT(ctx); + // NK_ASSERT(memory); + // NK_ASSERT(len); + if (!ctx || !memory || !len) + return 0; + + filter = (!filter) ? nk_filter_default: filter; + win = ctx->current; + hash = win->edit.seq; + edit = &ctx->text_edit; + nk_textedit_clear_state(&ctx->text_edit, (flags & NK_EDIT_MULTILINE)? + NK_TEXT_EDIT_MULTI_LINE: NK_TEXT_EDIT_SINGLE_LINE, filter); + + + + total = end - start; + + + end = TickCount(); + eventTime1 = total;// / 60.0; + + start = TickCount(); + + if (win->edit.active && hash == win->edit.name) { + if (flags & NK_EDIT_NO_CURSOR) + edit->cursor = nk_utf_len(memory, *len); + else edit->cursor = win->edit.cursor; + if (!(flags & NK_EDIT_SELECTABLE)) { + edit->select_start = win->edit.cursor; + edit->select_end = win->edit.cursor; + } else { + edit->select_start = win->edit.sel_start; + edit->select_end = win->edit.sel_end; + } + edit->mode = win->edit.mode; + edit->scrollbar.x = (int)win->edit.scrollbar.x; + edit->scrollbar.y = (int)win->edit.scrollbar.y; + edit->active = nk_true; + } else edit->active = nk_false; + + + end = TickCount(); + + total = end - start; + eventTime2 = total;// / 60.0; + + max = NK_MAX(1, max); + *len = NK_MIN(*len, max-1); + + start = TickCount(); + + nk_str_init_fixed(&edit->string, memory, (nk_size)max); + + edit->string.buffer.allocated = (nk_size)*len; + edit->string.len = nk_utf_len(memory, *len); + + + + end = TickCount(); + + total = end - start; + eventTime3 = total;// / 60.0; + start = TickCount(); + + + state = nk_edit_buffer(ctx, flags, edit, filter); + *len = (int)edit->string.buffer.allocated; + + if (edit->active) { + win->edit.cursor = edit->cursor; + win->edit.sel_start = edit->select_start; + win->edit.sel_end = edit->select_end; + win->edit.mode = edit->mode; + win->edit.scrollbar.x = (nk_uint)edit->scrollbar.x; + win->edit.scrollbar.y = (nk_uint)edit->scrollbar.y; + } + + + + end = TickCount(); + + total = end - start; + eventTime0 = total;// / 60.0; + + + //char logx[255]; + //sprintf(logx, "nk_edit_string() eventTime0 (edit string) %ld, eventTime1 (edit string) %ld, eventTime2 (edit string) %ld, eventTime3 (edit string) %ld ticks to execute\n", eventTime0, eventTime1, eventTime2, eventTime3); + //writeSerialPort(boutRefNum, logx); + return state; +} +NK_API nk_flags +nk_edit_buffer(struct nk_context *ctx, nk_flags flags, + struct nk_text_edit *edit, nk_plugin_filter filter) +{ + + + + long start; + long end; + long total; + long eventTime0 = 0; + long eventTime1 = 0; + long eventTime2 = 0; + long eventTime3 = 0; + long eventTime4 = 0; + + + start = TickCount(); + //writeSerialPort(boutRefNum, "FUNCTION CALL - edit / struct"); + struct nk_window *win; + struct nk_style *style; + struct nk_input *in; + + enum nk_widget_layout_states state; + struct nk_rect bounds; + + nk_flags ret_flags = 0; + unsigned char prev_state; + nk_hash hash; + + /* make sure correct values */ + // NK_ASSERT(ctx); + // NK_ASSERT(edit); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + state = nk_widget(&bounds, ctx); + if (!state) return state; + in = (win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + + /* check if edit is currently hot item */ + hash = win->edit.seq++; + if (win->edit.active && hash == win->edit.name) { + if (flags & NK_EDIT_NO_CURSOR) + edit->cursor = edit->string.len; + if (!(flags & NK_EDIT_SELECTABLE)) { + edit->select_start = edit->cursor; + edit->select_end = edit->cursor; + } + if (flags & NK_EDIT_CLIPBOARD) + edit->clip = ctx->clip; + edit->active = (unsigned char)win->edit.active; + } else edit->active = nk_false; + edit->mode = win->edit.mode; + + filter = (!filter) ? nk_filter_default: filter; + prev_state = (unsigned char)edit->active; + in = (flags & NK_EDIT_READ_ONLY) ? 0: in; + + + + end = TickCount(); + + total = end - start; + eventTime1 = total;// / 60.0; + start = TickCount(); + ret_flags = nk_do_edit(&ctx->last_widget_state, &win->buffer, bounds, flags, + filter, edit, &style->edit, in, style->font); + + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_TEXT]; + if (edit->active && prev_state != edit->active) { + /* current edit is now hot */ + win->edit.active = nk_true; + win->edit.name = hash; + } else if (prev_state && !edit->active) { + /* current edit is now cold */ + win->edit.active = nk_false; + } + + + + + end = TickCount(); + + total = end - start; + eventTime2 = total;// / 60.0; + + + // char logx[255]; + // sprintf(logx, "nk_edit_buffer() eventTime0 (edit string) %ld, eventTime1 (edit string) %ld, eventTime2 (edit string) %ld, eventTime3 (edit string) %ld ticks to execute\n", eventTime0, eventTime1, eventTime2, eventTime3); + // writeSerialPort(boutRefNum, logx); + + return ret_flags; +} +NK_API nk_flags +nk_edit_string_zero_terminated(struct nk_context *ctx, nk_flags flags, + char *buffer, int max, nk_plugin_filter filter) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - buffer, / char"); + nk_flags result; + int len = strlen(buffer); + result = nk_edit_string(ctx, flags, buffer, &len, max, filter); + buffer[NK_MIN(NK_MAX(max-1,0), len)] = '\0'; + return result; +} + + + + + +/* =============================================================== + * + * PROPERTY + * + * ===============================================================*/ +NK_LIB void +nk_drag_behavior(nk_flags *state, const struct nk_input *in, + struct nk_rect drag, struct nk_property_variant *variant, + int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - inc_per_pixel) / int"); + int left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down; + int left_mouse_click_in_cursor = in && nk_input_has_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, drag, nk_true); + + nk_widget_state_reset(state); + if (nk_input_is_mouse_hovering_rect(in, drag)) + *state = NK_WIDGET_STATE_HOVERED; + + if (left_mouse_down && left_mouse_click_in_cursor) { + int delta, pixels; + pixels = in->mouse.delta.x; + delta = pixels * inc_per_pixel; + switch (variant->kind) { + default: break; + case NK_PROPERTY_INT: + variant->value.i = variant->value.i + (int)delta; + variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i, variant->max_value.i); + break; + // case NK_PROPERTY_int: + // variant->value.f = variant->value.f + (int)delta; + // variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f, variant->max_value.f); + // break; + case NK_PROPERTY_DOUBLE: + variant->value.d = variant->value.d + (double)delta; + variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d, variant->max_value.d); + break; + } + *state = NK_WIDGET_STATE_ACTIVE; + } + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, drag)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, drag)) + *state |= NK_WIDGET_STATE_LEFT; +} +NK_LIB void +nk_property_behavior(nk_flags *ws, const struct nk_input *in, + struct nk_rect property, struct nk_rect label, struct nk_rect edit, + struct nk_rect empty, int *state, struct nk_property_variant *variant, + int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - inc_per_pixel) / int"); + nk_widget_state_reset(ws); + if (in && *state == NK_PROPERTY_DEFAULT) { + if (nk_button_behavior(ws, edit, in, NK_BUTTON_DEFAULT)) + *state = NK_PROPERTY_EDIT; + else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, label, nk_true)) + *state = NK_PROPERTY_DRAG; + else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, empty, nk_true)) + *state = NK_PROPERTY_DRAG; + } + if (*state == NK_PROPERTY_DRAG) { + nk_drag_behavior(ws, in, property, variant, inc_per_pixel); + if (!(*ws & NK_WIDGET_STATE_ACTIVED)) *state = NK_PROPERTY_DEFAULT; + } +} +NK_LIB void +nk_draw_property(struct nk_command_buffer *out, const struct nk_style_property *style, + const struct nk_rect *bounds, const struct nk_rect *label, nk_flags state, + const char *name, int len, const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - name / const"); + struct nk_text text; + const struct nk_style_item *background; + + /* select correct background and text color */ + if (state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + text.text = style->label_active; + } else if (state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + text.text = style->label_hover; + } else { + background = &style->normal; + text.text = style->label_normal; + } + + /* draw background */ + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(out, *bounds, &background->data.image, nk_white); + text.background = nk_rgba(0,0,0,0); + } else { + text.background = background->data.color; + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + nk_stroke_rect(out, *bounds, style->rounding, style->border, background->data.color); + } + + /* draw label */ + text.padding = nk_vec2(0,0); + nk_widget_text(out, *label, name, len, &text, NK_TEXT_CENTERED, font); +} +NK_LIB void +nk_do_property(nk_flags *ws, + struct nk_command_buffer *out, struct nk_rect property, + const char *name, struct nk_property_variant *variant, + int inc_per_pixel, char *buffer, int *len, + int *state, int *cursor, int *select_begin, int *select_end, + const struct nk_style_property *style, + enum nk_property_filter filter, struct nk_input *in, + const struct nk_user_font *font, struct nk_text_edit *text_edit, + enum nk_button_behavior behavior) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - behavior / enum"); + const nk_plugin_filter filters[] = { + nk_filter_decimal, + nk_filter_int + }; + nk_bool active, old; + int num_len, name_len; + char string[NK_MAX_NUMBER_BUFFER]; + int size; + + char *dst = 0; + int *length; + + struct nk_rect left; + struct nk_rect right; + struct nk_rect label; + struct nk_rect edit; + struct nk_rect empty; + + /* left decrement button */ + left.h = font->height/2; + left.w = left.h; + left.x = property.x + style->border + style->padding.x; + left.y = property.y + style->border + property.h/2.0f - left.h/2; + + /* text label */ + name_len = strlen(name); + size = font->width(font->userdata, font->height, name, name_len); + label.x = left.x + left.w + style->padding.x; + label.w = (int)size + 2 * style->padding.x; + label.y = property.y + style->border + style->padding.y; + label.h = property.h - (2 * style->border + 2 * style->padding.y); + + /* right increment button */ + right.y = left.y; + right.w = left.w; + right.h = left.h; + right.x = property.x + property.w - (right.w + style->padding.x); + + /* edit */ + if (*state == NK_PROPERTY_EDIT) { + size = font->width(font->userdata, font->height, buffer, *len); + size += style->edit.cursor_size; + length = len; + dst = buffer; + } else { + switch (variant->kind) { + default: break; + case NK_PROPERTY_INT: + nk_itoa(string, variant->value.i); + num_len = strlen(string); + break; + case NK_PROPERTY_int: + NK_DTOA(string, (double)variant->value.f); + num_len = nk_string_int_limit(string, NK_MAX_int_PRECISION); + break; + case NK_PROPERTY_DOUBLE: + NK_DTOA(string, variant->value.d); + num_len = nk_string_int_limit(string, NK_MAX_int_PRECISION); + break; + } + size = font->width(font->userdata, font->height, string, num_len); + dst = string; + length = &num_len; + } + + edit.w = (int)size + 2 * style->padding.x; + edit.w = NK_MIN(edit.w, right.x - (label.x + label.w)); + edit.x = right.x - (edit.w + style->padding.x); + edit.y = property.y + style->border; + edit.h = property.h - (2 * style->border); + + /* empty left space activator */ + empty.w = edit.x - (label.x + label.w); + empty.x = label.x + label.w; + empty.y = property.y; + empty.h = property.h; + + /* update property */ + old = (*state == NK_PROPERTY_EDIT); + nk_property_behavior(ws, in, property, label, edit, empty, state, variant, inc_per_pixel); + + /* draw property */ + if (style->draw_begin) style->draw_begin(out, style->userdata); + nk_draw_property(out, style, &property, &label, *ws, name, name_len, font); + if (style->draw_end) style->draw_end(out, style->userdata); + + /* execute right button */ + if (nk_do_button_symbol(ws, out, left, style->sym_left, behavior, &style->dec_button, in, font)) { + switch (variant->kind) { + default: break; + case NK_PROPERTY_INT: + variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i - variant->step.i, variant->max_value.i); break; + case NK_PROPERTY_int: + variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f - variant->step.f, variant->max_value.f); break; + case NK_PROPERTY_DOUBLE: + variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d - variant->step.d, variant->max_value.d); break; + } + } + /* execute left button */ + if (nk_do_button_symbol(ws, out, right, style->sym_right, behavior, &style->inc_button, in, font)) { + switch (variant->kind) { + default: break; + case NK_PROPERTY_INT: + variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i + variant->step.i, variant->max_value.i); break; + case NK_PROPERTY_int: + variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f + variant->step.f, variant->max_value.f); break; + case NK_PROPERTY_DOUBLE: + variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d + variant->step.d, variant->max_value.d); break; + } + } + if (old != NK_PROPERTY_EDIT && (*state == NK_PROPERTY_EDIT)) { + /* property has been activated so setup buffer */ + NK_MEMCPY(buffer, dst, (nk_size)*length); + *cursor = nk_utf_len(buffer, *length); + *len = *length; + length = len; + dst = buffer; + active = 0; + } else active = (*state == NK_PROPERTY_EDIT); + + /* execute and run text edit field */ + nk_textedit_clear_state(text_edit, NK_TEXT_EDIT_SINGLE_LINE, filters[filter]); + text_edit->active = (unsigned char)active; + text_edit->string.len = *length; + text_edit->cursor = NK_CLAMP(0, *cursor, *length); + text_edit->select_start = NK_CLAMP(0,*select_begin, *length); + text_edit->select_end = NK_CLAMP(0,*select_end, *length); + text_edit->string.buffer.allocated = (nk_size)*length; + text_edit->string.buffer.memory.size = NK_MAX_NUMBER_BUFFER; + text_edit->string.buffer.memory.ptr = dst; + text_edit->string.buffer.size = NK_MAX_NUMBER_BUFFER; + text_edit->mode = NK_TEXT_EDIT_MODE_INSERT; + nk_do_edit(ws, out, edit, NK_EDIT_FIELD|NK_EDIT_AUTO_SELECT, + filters[filter], text_edit, &style->edit, (*state == NK_PROPERTY_EDIT) ? in: 0, font); + + *length = text_edit->string.len; + *cursor = text_edit->cursor; + *select_begin = text_edit->select_start; + *select_end = text_edit->select_end; + if (text_edit->active && nk_input_is_key_pressed(in, NK_KEY_ENTER)) + text_edit->active = nk_false; + + if (active && !text_edit->active) { + /* property is now not active so convert edit text to value*/ + *state = NK_PROPERTY_DEFAULT; + buffer[*len] = '\0'; + switch (variant->kind) { + default: break; + case NK_PROPERTY_INT: + variant->value.i = nk_strtoi(buffer, 0); + variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i, variant->max_value.i); + break; + case NK_PROPERTY_int: + nk_string_int_limit(buffer, NK_MAX_int_PRECISION); + variant->value.f = nk_strtof(buffer, 0); + variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f, variant->max_value.f); + break; + case NK_PROPERTY_DOUBLE: + nk_string_int_limit(buffer, NK_MAX_int_PRECISION); + variant->value.d = nk_strtod(buffer, 0); + variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d, variant->max_value.d); + break; + } + } +} +NK_LIB struct nk_property_variant +nk_property_variant_int(int value, int min_value, int max_value, int step) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - value / nk_property_variant_int"); + struct nk_property_variant result; + result.kind = NK_PROPERTY_INT; + result.value.i = value; + result.min_value.i = min_value; + result.max_value.i = max_value; + result.step.i = step; + return result; +} +// NK_LIB struct nk_property_variant +// nk_property_variant_int(int value, int min_value, int max_value, int step) +// { +// struct nk_property_variant result; +// result.kind = NK_PROPERTY_int; +// result.value.f = value; +// result.min_value.f = min_value; +// result.max_value.f = max_value; +// result.step.f = step; +// return result; +// } +NK_LIB struct nk_property_variant +nk_property_variant_double(double value, double min_value, double max_value, + double step) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - step) / double"); + struct nk_property_variant result; + result.kind = NK_PROPERTY_DOUBLE; + result.value.d = value; + result.min_value.d = min_value; + result.max_value.d = max_value; + result.step.d = step; + return result; +} +NK_LIB void +nk_property(struct nk_context *ctx, const char *name, struct nk_property_variant *variant, + int inc_per_pixel, const enum nk_property_filter filter) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - inc_per_pixel, / int"); + struct nk_window *win; + struct nk_panel *layout; + struct nk_input *in; + const struct nk_style *style; + + struct nk_rect bounds; + enum nk_widget_layout_states s; + + int *state = 0; + nk_hash hash = 0; + char *buffer = 0; + int *len = 0; + int *cursor = 0; + int *select_begin = 0; + int *select_end = 0; + int old_state; + + char dummy_buffer[NK_MAX_NUMBER_BUFFER]; + int dummy_state = NK_PROPERTY_DEFAULT; + int dummy_length = 0; + int dummy_cursor = 0; + int dummy_select_begin = 0; + int dummy_select_end = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return; + + win = ctx->current; + layout = win->layout; + style = &ctx->style; + s = nk_widget(&bounds, ctx); + if (!s) return; + + /* calculate hash from name */ + if (name[0] == '#') { + hash = nk_murmur_hash(name, (int)strlen(name), win->property.seq++); + name++; /* special number hash */ + } else hash = nk_murmur_hash(name, (int)strlen(name), 42); + + /* check if property is currently hot item */ + if (win->property.active && hash == win->property.name) { + buffer = win->property.buffer; + len = &win->property.length; + cursor = &win->property.cursor; + state = &win->property.state; + select_begin = &win->property.select_start; + select_end = &win->property.select_end; + } else { + buffer = dummy_buffer; + len = &dummy_length; + cursor = &dummy_cursor; + state = &dummy_state; + select_begin = &dummy_select_begin; + select_end = &dummy_select_end; + } + + /* execute property widget */ + old_state = *state; + ctx->text_edit.clip = ctx->clip; + in = ((s == NK_WIDGET_ROM && !win->property.active) || + layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + nk_do_property(&ctx->last_widget_state, &win->buffer, bounds, name, + variant, inc_per_pixel, buffer, len, state, cursor, select_begin, + select_end, &style->property, filter, in, style->font, &ctx->text_edit, + ctx->button_behavior); + + if (in && *state != NK_PROPERTY_DEFAULT && !win->property.active) { + /* current property is now hot */ + win->property.active = 1; + NK_MEMCPY(win->property.buffer, buffer, (nk_size)*len); + win->property.length = *len; + win->property.cursor = *cursor; + win->property.state = *state; + win->property.name = hash; + win->property.select_start = *select_begin; + win->property.select_end = *select_end; + if (*state == NK_PROPERTY_DRAG) { + ctx->input.mouse.grab = nk_true; + ctx->input.mouse.grabbed = nk_true; + } + } + /* check if previously active property is now inactive */ + if (*state == NK_PROPERTY_DEFAULT && old_state != NK_PROPERTY_DEFAULT) { + if (old_state == NK_PROPERTY_DRAG) { + ctx->input.mouse.grab = nk_false; + ctx->input.mouse.grabbed = nk_false; + ctx->input.mouse.ungrab = nk_true; + } + win->property.select_start = 0; + win->property.select_end = 0; + win->property.active = 0; + } +} +NK_API void +nk_property_int(struct nk_context *ctx, const char *name, + int min, int *val, int max, int step, int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - min, / int"); + struct nk_property_variant variant; + // NK_ASSERT(ctx); + // NK_ASSERT(name); + // NK_ASSERT(val); + + if (!ctx || !ctx->current || !name || !val) return; + variant = nk_property_variant_int(*val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT); + *val = variant.value.i; +} +// NK_API void +// nk_property_int(struct nk_context *ctx, const char *name, +// int min, int *val, int max, int step, int inc_per_pixel) +// { +// struct nk_property_variant variant; +// // NK_ASSERT(ctx); +// // NK_ASSERT(name); +// // NK_ASSERT(val); + +// if (!ctx || !ctx->current || !name || !val) return; +// variant = nk_property_variant_int(*val, min, max, step); +// nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_int); +// *val = variant.value.f; +// } +NK_API void +nk_property_double(struct nk_context *ctx, const char *name, + double min, double *val, double max, double step, int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - min, / double"); + struct nk_property_variant variant; + // NK_ASSERT(ctx); + // NK_ASSERT(name); + // NK_ASSERT(val); + + if (!ctx || !ctx->current || !name || !val) return; + variant = nk_property_variant_double(*val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_int); + *val = variant.value.d; +} +NK_API int +nk_propertyi(struct nk_context *ctx, const char *name, int min, int val, + int max, int step, int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - max, / int"); + struct nk_property_variant variant; + // NK_ASSERT(ctx); + // NK_ASSERT(name); + + if (!ctx || !ctx->current || !name) return val; + variant = nk_property_variant_int(val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT); + val = variant.value.i; + return val; +} +NK_API int +nk_propertyf(struct nk_context *ctx, const char *name, int min, + int val, int max, int step, int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - val, / int"); + struct nk_property_variant variant; + // NK_ASSERT(ctx); + // NK_ASSERT(name); + + if (!ctx || !ctx->current || !name) return val; + variant = nk_property_variant_int(val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_int); + val = variant.value.f; + return val; +} +NK_API double +nk_propertyd(struct nk_context *ctx, const char *name, double min, + double val, double max, double step, int inc_per_pixel) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - val, / double"); + struct nk_property_variant variant; + // NK_ASSERT(ctx); + // NK_ASSERT(name); + + if (!ctx || !ctx->current || !name) return val; + variant = nk_property_variant_double(val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_int); + val = variant.value.d; + return val; +} + + + + + +/* ============================================================== + * + * CHART + * + * ===============================================================*/ +NK_API nk_bool +nk_chart_begin_colored(struct nk_context *ctx, enum nk_chart_type type, + struct nk_color color, struct nk_color highlight, + int count, int min_value, int max_value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - count, / int"); + struct nk_window *win; + struct nk_chart *chart; + const struct nk_style *config; + const struct nk_style_chart *style; + + const struct nk_style_item *background; + struct nk_rect bounds = {0, 0, 0, 0}; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + + if (!ctx || !ctx->current || !ctx->current->layout) return 0; + if (!nk_widget(&bounds, ctx)) { + chart = &ctx->current->layout->chart; + nk_zero(chart, sizeof(*chart)); + return 0; + } + + win = ctx->current; + config = &ctx->style; + chart = &win->layout->chart; + style = &config->chart; + + /* setup basic generic chart */ + nk_zero(chart, sizeof(*chart)); + chart->x = bounds.x + style->padding.x; + chart->y = bounds.y + style->padding.y; + chart->w = bounds.w - 2 * style->padding.x; + chart->h = bounds.h - 2 * style->padding.y; + chart->w = NK_MAX(chart->w, 2 * style->padding.x); + chart->h = NK_MAX(chart->h, 2 * style->padding.y); + + /* add first slot into chart */ + {struct nk_chart_slot *slot = &chart->slots[chart->slot++]; + slot->type = type; + slot->count = count; + slot->color = color; + slot->highlight = highlight; + slot->min = NK_MIN(min_value, max_value); + slot->max = NK_MAX(min_value, max_value); + slot->range = slot->max - slot->min;} + + /* draw chart background */ + background = &style->background; + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(&win->buffer, bounds, &background->data.image, nk_white); + } else { + nk_fill_rect(&win->buffer, bounds, style->rounding, style->border_color); + nk_fill_rect(&win->buffer, nk_shrink_rect(bounds, style->border), + style->rounding, style->background.data.color); + } + return 1; +} +NK_API nk_bool +nk_chart_begin(struct nk_context *ctx, const enum nk_chart_type type, + int count, int min_value, int max_value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - count, / int"); + return nk_chart_begin_colored(ctx, type, ctx->style.chart.color, + ctx->style.chart.selected_color, count, min_value, max_value); +} +NK_API void +nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type type, + struct nk_color color, struct nk_color highlight, + int count, int min_value, int max_value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - count, / int"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + // NK_ASSERT(ctx->current->layout->chart.slot < NK_CHART_MAX_SLOT); + if (!ctx || !ctx->current || !ctx->current->layout) return; + if (ctx->current->layout->chart.slot >= NK_CHART_MAX_SLOT) return; + + /* add another slot into the graph */ + {struct nk_chart *chart = &ctx->current->layout->chart; + struct nk_chart_slot *slot = &chart->slots[chart->slot++]; + slot->type = type; + slot->count = count; + slot->color = color; + slot->highlight = highlight; + slot->min = NK_MIN(min_value, max_value); + slot->max = NK_MAX(min_value, max_value); + slot->range = slot->max - slot->min;} +} +NK_API void +nk_chart_add_slot(struct nk_context *ctx, const enum nk_chart_type type, + int count, int min_value, int max_value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - count, / int"); + nk_chart_add_slot_colored(ctx, type, ctx->style.chart.color, + ctx->style.chart.selected_color, count, min_value, max_value); +} +NK_INTERN nk_flags +nk_chart_push_line(struct nk_context *ctx, struct nk_window *win, + struct nk_chart *g, int value, int slot) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - g / struct"); + struct nk_panel *layout = win->layout; + const struct nk_input *i = &ctx->input; + struct nk_command_buffer *out = &win->buffer; + + nk_flags ret = 0; + struct nk_vec2 cur; + struct nk_rect bounds; + struct nk_color color; + int step; + int range; + int ratio; + + // NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT); + step = g->w / (int)g->slots[slot].count; + range = g->slots[slot].max - g->slots[slot].min; + ratio = (value - g->slots[slot].min) / range; + + if (g->slots[slot].index == 0) { + /* first data point does not have a connection */ + g->slots[slot].last.x = g->x; + g->slots[slot].last.y = (g->y + g->h) - ratio * (int)g->h; + + bounds.x = g->slots[slot].last.x - 2; + bounds.y = g->slots[slot].last.y - 2; + bounds.w = bounds.h = 4; + + color = g->slots[slot].color; + if (!(layout->flags & NK_WINDOW_ROM) && NK_INBOX(i->mouse.pos.x,i->mouse.pos.y, g->slots[slot].last.x-3, g->slots[slot].last.y-3, 6, 6)){ + ret = nk_input_is_mouse_hovering_rect(i, bounds) ? NK_CHART_HOVERING : 0; + ret |= (i->mouse.buttons[NK_BUTTON_LEFT].down && i->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0; + color = g->slots[slot].highlight; + } + nk_fill_rect(out, bounds, 0, color); + g->slots[slot].index += 1; + return ret; + } + + /* draw a line between the last data point and the new one */ + color = g->slots[slot].color; + cur.x = g->x + (int)(step * (int)g->slots[slot].index); + cur.y = (g->y + g->h) - (ratio * (int)g->h); + nk_stroke_line(out, g->slots[slot].last.x, g->slots[slot].last.y, cur.x, cur.y, 1.0f, color); + + bounds.x = cur.x - 3; + bounds.y = cur.y - 3; + bounds.w = bounds.h = 6; + + /* user selection of current data point */ + if (!(layout->flags & NK_WINDOW_ROM)) { + if (nk_input_is_mouse_hovering_rect(i, bounds)) { + ret = NK_CHART_HOVERING; + ret |= (!i->mouse.buttons[NK_BUTTON_LEFT].down && i->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0; + color = g->slots[slot].highlight; + } + } + nk_fill_rect(out, nk_rect(cur.x - 2, cur.y - 2, 4, 4), 0, color); + + /* save current data point position */ + g->slots[slot].last.x = cur.x; + g->slots[slot].last.y = cur.y; + g->slots[slot].index += 1; + return ret; +} +NK_INTERN nk_flags +nk_chart_push_column(const struct nk_context *ctx, struct nk_window *win, + struct nk_chart *chart, int value, int slot) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - chart / struct"); + struct nk_command_buffer *out = &win->buffer; + const struct nk_input *in = &ctx->input; + struct nk_panel *layout = win->layout; + + int ratio; + nk_flags ret = 0; + struct nk_color color; + struct nk_rect item = {0,0,0,0}; + + // NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT); + if (chart->slots[slot].index >= chart->slots[slot].count) + return nk_false; + if (chart->slots[slot].count) { + int padding = (int)(chart->slots[slot].count-1); + item.w = (chart->w - padding) / (int)(chart->slots[slot].count); + } + + /* calculate bounds of current bar chart entry */ + color = chart->slots[slot].color;; + item.h = chart->h * NK_ABS((value/chart->slots[slot].range)); + if (value >= 0) { + ratio = (value + NK_ABS(chart->slots[slot].min)) / NK_ABS(chart->slots[slot].range); + item.y = (chart->y + chart->h) - chart->h * ratio; + } else { + ratio = (value - chart->slots[slot].max) / chart->slots[slot].range; + item.y = chart->y + (chart->h * NK_ABS(ratio)) - item.h; + } + item.x = chart->x + ((int)chart->slots[slot].index * item.w); + item.x = item.x + ((int)chart->slots[slot].index); + + /* user chart bar selection */ + if (!(layout->flags & NK_WINDOW_ROM) && NK_INBOX(in->mouse.pos.x,in->mouse.pos.y,item.x,item.y,item.w,item.h)) { + ret = NK_CHART_HOVERING; + ret |= (!in->mouse.buttons[NK_BUTTON_LEFT].down && in->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0; + color = chart->slots[slot].highlight; + } + nk_fill_rect(out, item, 0, color); + chart->slots[slot].index += 1; + return ret; +} +NK_API nk_flags +nk_chart_push_slot(struct nk_context *ctx, int value, int slot) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_chart_push_slot"); + nk_flags flags; + struct nk_window *win; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT); + // NK_ASSERT(slot < ctx->current->layout->chart.slot); + if (!ctx || !ctx->current || slot >= NK_CHART_MAX_SLOT) return nk_false; + if (slot >= ctx->current->layout->chart.slot) return nk_false; + + win = ctx->current; + if (win->layout->chart.slot < slot) return nk_false; + switch (win->layout->chart.slots[slot].type) { + case NK_CHART_LINES: + flags = nk_chart_push_line(ctx, win, &win->layout->chart, value, slot); break; + case NK_CHART_COLUMN: + flags = nk_chart_push_column(ctx, win, &win->layout->chart, value, slot); break; + default: + case NK_CHART_MAX: + flags = 0; + } + return flags; +} +NK_API nk_flags +nk_chart_push(struct nk_context *ctx, int value) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_chart_push"); + return nk_chart_push_slot(ctx, value, 0); +} +NK_API void +nk_chart_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_chart_end"); + struct nk_window *win; + struct nk_chart *chart; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) + return; + + win = ctx->current; + chart = &win->layout->chart; + NK_MEMSET(chart, 0, sizeof(*chart)); + return; +} +NK_API void +nk_plot(struct nk_context *ctx, enum nk_chart_type type, const int *values, + int count, int offset) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - count, / int"); + int i = 0; + int min_value; + int max_value; + + // NK_ASSERT(ctx); + // NK_ASSERT(values); + if (!ctx || !values || !count) return; + + min_value = values[offset]; + max_value = values[offset]; + for (i = 0; i < count; ++i) { + min_value = NK_MIN(values[i + offset], min_value); + max_value = NK_MAX(values[i + offset], max_value); + } + + if (nk_chart_begin(ctx, type, count, min_value, max_value)) { + for (i = 0; i < count; ++i) + nk_chart_push(ctx, values[i + offset]); + nk_chart_end(ctx); + } +} +NK_API void +nk_plot_function(struct nk_context *ctx, enum nk_chart_type type, void *userdata, + int(*value_getter)(void* user, int index), int count, int offset) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - value_getter) / int"); + int i = 0; + int min_value; + int max_value; + + // NK_ASSERT(ctx); + // NK_ASSERT(value_getter); + if (!ctx || !value_getter || !count) return; + + max_value = min_value = value_getter(userdata, offset); + for (i = 0; i < count; ++i) { + int value = value_getter(userdata, i + offset); + min_value = NK_MIN(value, min_value); + max_value = NK_MAX(value, max_value); + } + + if (nk_chart_begin(ctx, type, count, min_value, max_value)) { + for (i = 0; i < count; ++i) + nk_chart_push(ctx, value_getter(userdata, i + offset)); + nk_chart_end(ctx); + } +} + + + + + +/* ============================================================== + * + * COLOR PICKER + * + * ===============================================================*/ +NK_LIB nk_bool +nk_color_picker_behavior(nk_flags *state, + const struct nk_rect *bounds, const struct nk_rect *matrix, + const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, + struct nk_colorf *color, const struct nk_input *in) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - color / struct"); + int hsva[4]; + nk_bool value_changed = 0; + nk_bool hsv_changed = 0; + + // NK_ASSERT(state); + // NK_ASSERT(matrix); + // NK_ASSERT(hue_bar); + // NK_ASSERT(color); + + /* color matrix */ + nk_colorf_hsva_fv(hsva, *color); + if (nk_button_behavior(state, *matrix, in, NK_BUTTON_REPEATER)) { + hsva[1] = NK_SATURATE((in->mouse.pos.x - matrix->x) / (matrix->w-1)); + hsva[2] = 1.0f - NK_SATURATE((in->mouse.pos.y - matrix->y) / (matrix->h-1)); + value_changed = hsv_changed = 1; + } + /* hue bar */ + if (nk_button_behavior(state, *hue_bar, in, NK_BUTTON_REPEATER)) { + hsva[0] = NK_SATURATE((in->mouse.pos.y - hue_bar->y) / (hue_bar->h-1)); + value_changed = hsv_changed = 1; + } + /* alpha bar */ + if (alpha_bar) { + if (nk_button_behavior(state, *alpha_bar, in, NK_BUTTON_REPEATER)) { + hsva[3] = 1.0f - NK_SATURATE((in->mouse.pos.y - alpha_bar->y) / (alpha_bar->h-1)); + value_changed = 1; + } + } + nk_widget_state_reset(state); + if (hsv_changed) { + *color = nk_hsva_colorfv(hsva); + *state = NK_WIDGET_STATE_ACTIVE; + } + if (value_changed) { + color->a = hsva[3]; + *state = NK_WIDGET_STATE_ACTIVE; + } + /* set color picker widget state */ + if (nk_input_is_mouse_hovering_rect(in, *bounds)) + *state = NK_WIDGET_STATE_HOVERED; + if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, *bounds)) + *state |= NK_WIDGET_STATE_ENTERED; + else if (nk_input_is_mouse_prev_hovering_rect(in, *bounds)) + *state |= NK_WIDGET_STATE_LEFT; + return value_changed; +} +NK_LIB void +nk_draw_color_picker(struct nk_command_buffer *o, const struct nk_rect *matrix, + const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, + struct nk_colorf col) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - col / struct"); + NK_STORAGE const struct nk_color black = {0,0,0,255}; + NK_STORAGE const struct nk_color white = {255, 255, 255, 255}; + NK_STORAGE const struct nk_color black_trans = {0,0,0,0}; + + const int crosshair_size = 7.0f; + struct nk_color temp; + int hsva[4]; + int line_y; + int i; + + // NK_ASSERT(o); + // NK_ASSERT(matrix); + // NK_ASSERT(hue_bar); + + /* draw hue bar */ + nk_colorf_hsva_fv(hsva, col); + for (i = 0; i < 6; ++i) { + NK_GLOBAL const struct nk_color hue_colors[] = { + {255, 0, 0, 255}, {255,255,0,255}, {0,255,0,255}, {0, 255,255,255}, + {0,0,255,255}, {255, 0, 255, 255}, {255, 0, 0, 255} + }; + nk_fill_rect_multi_color(o, + nk_rect(hue_bar->x, hue_bar->y + (int)i * (hue_bar->h/6.0f) + 0.5f, + hue_bar->w, (hue_bar->h/6.0f) + 0.5f), hue_colors[i], hue_colors[i], + hue_colors[i+1], hue_colors[i+1]); + } + line_y = (int)(int)(hue_bar->y + hsva[0] * matrix->h + 0.5f); + nk_stroke_line(o, hue_bar->x-1, line_y, hue_bar->x + hue_bar->w + 2, + line_y, 1, nk_rgb(255,255,255)); + + /* draw alpha bar */ + if (alpha_bar) { + int alpha = NK_SATURATE(col.a); + line_y = (int)(int)(alpha_bar->y + (1.0f - alpha) * matrix->h + 0.5f); + + nk_fill_rect_multi_color(o, *alpha_bar, white, white, black, black); + nk_stroke_line(o, alpha_bar->x-1, line_y, alpha_bar->x + alpha_bar->w + 2, + line_y, 1, nk_rgb(255,255,255)); + } + + /* draw color matrix */ + temp = nk_hsv_f(hsva[0], 1.0f, 1.0f); + nk_fill_rect_multi_color(o, *matrix, white, temp, temp, white); + nk_fill_rect_multi_color(o, *matrix, black_trans, black_trans, black, black); + + /* draw cross-hair */ + {struct nk_vec2 p; int S = hsva[1]; int V = hsva[2]; + p.x = (int)(int)(matrix->x + S * matrix->w); + p.y = (int)(int)(matrix->y + (1.0f - V) * matrix->h); + nk_stroke_line(o, p.x - crosshair_size, p.y, p.x-2, p.y, 1.0f, white); + nk_stroke_line(o, p.x + crosshair_size + 1, p.y, p.x+3, p.y, 1.0f, white); + nk_stroke_line(o, p.x, p.y + crosshair_size + 1, p.x, p.y+3, 1.0f, white); + nk_stroke_line(o, p.x, p.y - crosshair_size, p.x, p.y-2, 1.0f, white);} +} +NK_LIB nk_bool +nk_do_color_picker(nk_flags *state, + struct nk_command_buffer *out, struct nk_colorf *col, + enum nk_color_format fmt, struct nk_rect bounds, + struct nk_vec2 padding, const struct nk_input *in, + const struct nk_user_font *font) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_user_font / const"); + int ret = 0; + struct nk_rect matrix; + struct nk_rect hue_bar; + struct nk_rect alpha_bar; + int bar_w; + + // NK_ASSERT(out); + // NK_ASSERT(col); + // NK_ASSERT(state); + // NK_ASSERT(font); + if (!out || !col || !state || !font) + return ret; + + bar_w = font->height; + bounds.x += padding.x; + bounds.y += padding.x; + bounds.w -= 2 * padding.x; + bounds.h -= 2 * padding.y; + + matrix.x = bounds.x; + matrix.y = bounds.y; + matrix.h = bounds.h; + matrix.w = bounds.w - (3 * padding.x + 2 * bar_w); + + hue_bar.w = bar_w; + hue_bar.y = bounds.y; + hue_bar.h = matrix.h; + hue_bar.x = matrix.x + matrix.w + padding.x; + + alpha_bar.x = hue_bar.x + hue_bar.w + padding.x; + alpha_bar.y = bounds.y; + alpha_bar.w = bar_w; + alpha_bar.h = matrix.h; + + ret = nk_color_picker_behavior(state, &bounds, &matrix, &hue_bar, + (fmt == NK_RGBA) ? &alpha_bar:0, col, in); + nk_draw_color_picker(out, &matrix, &hue_bar, (fmt == NK_RGBA) ? &alpha_bar:0, *col); + return ret; +} +NK_API nk_bool +nk_color_pick(struct nk_context * ctx, struct nk_colorf *color, + enum nk_color_format fmt) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fmt / enum"); + struct nk_window *win; + struct nk_panel *layout; + const struct nk_style *config; + const struct nk_input *in; + + enum nk_widget_layout_states state; + struct nk_rect bounds; + + // NK_ASSERT(ctx); + // NK_ASSERT(color); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !color) + return 0; + + win = ctx->current; + config = &ctx->style; + layout = win->layout; + state = nk_widget(&bounds, ctx); + if (!state) return 0; + in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; + return nk_do_color_picker(&ctx->last_widget_state, &win->buffer, color, fmt, bounds, + nk_vec2(0,0), in, config->font); +} +NK_API struct nk_colorf +nk_color_picker(struct nk_context *ctx, struct nk_colorf color, + enum nk_color_format fmt) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - fmt / enum"); + nk_color_pick(ctx, &color, fmt); + return color; +} + + + + + +/* ============================================================== + * + * COMBO + * + * ===============================================================*/ +NK_INTERN nk_bool +nk_combo_begin(struct nk_context *ctx, struct nk_window *win, + struct nk_vec2 size, nk_bool is_clicked, struct nk_rect header) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - size / struct"); + struct nk_window *popup; + int is_open = 0; + int is_active = 0; + struct nk_rect body; + nk_hash hash; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + popup = win->popup.win; + body.x = header.x; + body.w = size.x; + body.y = header.y + header.h-ctx->style.window.combo_border; + body.h = size.y; + + hash = win->popup.combo_count++; + is_open = (popup) ? nk_true:nk_false; + is_active = (popup && (win->popup.name == hash) && win->popup.type == NK_PANEL_COMBO); + if ((is_clicked && is_open && !is_active) || (is_open && !is_active) || + (!is_open && !is_active && !is_clicked)) return 0; + if (!nk_nonblock_begin(ctx, 0, body, + (is_clicked && is_open)?nk_rect(0,0,0,0):header, NK_PANEL_COMBO)) return 0; + + win->popup.type = NK_PANEL_COMBO; + win->popup.name = hash; + return 1; +} +NK_API nk_bool +nk_combo_begin_text(struct nk_context *ctx, const char *selected, int len, + struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - size / struct"); + const struct nk_input *in; + struct nk_window *win; + struct nk_style *style; + + enum nk_widget_layout_states s; + int is_clicked = nk_false; + struct nk_rect header; + const struct nk_style_item *background; + struct nk_text text; + + // NK_ASSERT(ctx); + // NK_ASSERT(selected); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout || !selected) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (s == NK_WIDGET_INVALID) + return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) { + background = &style->combo.active; + text.text = style->combo.label_active; + } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) { + background = &style->combo.hover; + text.text = style->combo.label_hover; + } else { + background = &style->combo.normal; + text.text = style->combo.label_normal; + } + if (background->type == NK_STYLE_ITEM_IMAGE) { + text.background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + text.background = background->data.color; + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + /* print currently selected text item */ + struct nk_rect label; + struct nk_rect button; + struct nk_rect content; + int draw_button_symbol; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else + sym = style->combo.sym_normal; + + /* represents whether or not the combo's button symbol should be drawn */ + draw_button_symbol = sym != NK_SYMBOL_NONE; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.x; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + + /* draw selected label */ + text.padding = nk_vec2(0,0); + label.x = header.x + style->combo.content_padding.x; + label.y = header.y + style->combo.content_padding.y; + label.h = header.h - 2 * style->combo.content_padding.y; + if (draw_button_symbol) + label.w = button.x - (style->combo.content_padding.x + style->combo.spacing.x) - label.x; + else + label.w = header.w - 2 * style->combo.content_padding.x; + nk_widget_text(&win->buffer, label, selected, len, &text, + NK_TEXT_LEFT, ctx->style.font); + + /* draw open/close button */ + if (draw_button_symbol) + nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_label(struct nk_context *ctx, const char *selected, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_begin_label"); + return nk_combo_begin_text(ctx, selected, strlen(selected), size); +} +NK_API nk_bool +nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_begin_color"); + struct nk_window *win; + struct nk_style *style; + const struct nk_input *in; + + struct nk_rect header; + int is_clicked = nk_false; + enum nk_widget_layout_states s; + const struct nk_style_item *background; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (s == NK_WIDGET_INVALID) + return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) + background = &style->combo.active; + else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + background = &style->combo.hover; + else background = &style->combo.normal; + + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(&win->buffer, header, &background->data.image,nk_white); + } else { + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + struct nk_rect content; + struct nk_rect button; + struct nk_rect bounds; + int draw_button_symbol; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else sym = style->combo.sym_normal; + + /* represents whether or not the combo's button symbol should be drawn */ + draw_button_symbol = sym != NK_SYMBOL_NONE; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.x; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + + /* draw color */ + bounds.h = header.h - 4 * style->combo.content_padding.y; + bounds.y = header.y + 2 * style->combo.content_padding.y; + bounds.x = header.x + 2 * style->combo.content_padding.x; + if (draw_button_symbol) + bounds.w = (button.x - (style->combo.content_padding.x + style->combo.spacing.x)) - bounds.x; + else + bounds.w = header.w - 4 * style->combo.content_padding.x; + nk_fill_rect(&win->buffer, bounds, 0, color); + + /* draw open/close button */ + if (draw_button_symbol) + nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_symbol(struct nk_context *ctx, enum nk_symbol_type symbol, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_begin_symbol"); + struct nk_window *win; + struct nk_style *style; + const struct nk_input *in; + + struct nk_rect header; + int is_clicked = nk_false; + enum nk_widget_layout_states s; + const struct nk_style_item *background; + struct nk_color sym_background; + struct nk_color symbol_color; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (s == NK_WIDGET_INVALID) + return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) { + background = &style->combo.active; + symbol_color = style->combo.symbol_active; + } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) { + background = &style->combo.hover; + symbol_color = style->combo.symbol_hover; + } else { + background = &style->combo.normal; + symbol_color = style->combo.symbol_hover; + } + + if (background->type == NK_STYLE_ITEM_IMAGE) { + sym_background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + sym_background = background->data.color; + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + struct nk_rect bounds = {0,0,0,0}; + struct nk_rect content; + struct nk_rect button; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else sym = style->combo.sym_normal; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.y; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + + /* draw symbol */ + bounds.h = header.h - 2 * style->combo.content_padding.y; + bounds.y = header.y + style->combo.content_padding.y; + bounds.x = header.x + style->combo.content_padding.x; + bounds.w = (button.x - style->combo.content_padding.y) - bounds.x; + nk_draw_symbol(&win->buffer, symbol, bounds, sym_background, symbol_color, + 1.0f, style->font); + + /* draw open/close button */ + nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_symbol_text(struct nk_context *ctx, const char *selected, int len, + enum nk_symbol_type symbol, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - symbol / enum"); + struct nk_window *win; + struct nk_style *style; + struct nk_input *in; + + struct nk_rect header; + int is_clicked = nk_false; + enum nk_widget_layout_states s; + const struct nk_style_item *background; + struct nk_color symbol_color; + struct nk_text text; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (!s) return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) { + background = &style->combo.active; + symbol_color = style->combo.symbol_active; + text.text = style->combo.label_active; + } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) { + background = &style->combo.hover; + symbol_color = style->combo.symbol_hover; + text.text = style->combo.label_hover; + } else { + background = &style->combo.normal; + symbol_color = style->combo.symbol_normal; + text.text = style->combo.label_normal; + } + if (background->type == NK_STYLE_ITEM_IMAGE) { + text.background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + text.background = background->data.color; + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + struct nk_rect content; + struct nk_rect button; + struct nk_rect label; + struct nk_rect image; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else sym = style->combo.sym_normal; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.x; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + + /* draw symbol */ + image.x = header.x + style->combo.content_padding.x; + image.y = header.y + style->combo.content_padding.y; + image.h = header.h - 2 * style->combo.content_padding.y; + image.w = image.h; + nk_draw_symbol(&win->buffer, symbol, image, text.background, symbol_color, + 1.0f, style->font); + + /* draw label */ + text.padding = nk_vec2(0,0); + label.x = image.x + image.w + style->combo.spacing.x + style->combo.content_padding.x; + label.y = header.y + style->combo.content_padding.y; + label.w = (button.x - style->combo.content_padding.x) - label.x; + label.h = header.h - 2 * style->combo.content_padding.y; + nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_begin_image"); + struct nk_window *win; + struct nk_style *style; + const struct nk_input *in; + + struct nk_rect header; + int is_clicked = nk_false; + enum nk_widget_layout_states s; + const struct nk_style_item *background; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (s == NK_WIDGET_INVALID) + return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) + background = &style->combo.active; + else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + background = &style->combo.hover; + else background = &style->combo.normal; + + if (background->type == NK_STYLE_ITEM_IMAGE) { + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + struct nk_rect bounds = {0,0,0,0}; + struct nk_rect content; + struct nk_rect button; + int draw_button_symbol; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else sym = style->combo.sym_normal; + + /* represents whether or not the combo's button symbol should be drawn */ + draw_button_symbol = sym != NK_SYMBOL_NONE; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.y; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + + /* draw image */ + bounds.h = header.h - 2 * style->combo.content_padding.y; + bounds.y = header.y + style->combo.content_padding.y; + bounds.x = header.x + style->combo.content_padding.x; + if (draw_button_symbol) + bounds.w = (button.x - style->combo.content_padding.y) - bounds.x; + else + bounds.w = header.w - 2 * style->combo.content_padding.x; + nk_draw_image(&win->buffer, bounds, &img, nk_white); + + /* draw open/close button */ + if (draw_button_symbol) + nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_image_text(struct nk_context *ctx, const char *selected, int len, + struct nk_image img, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - img / struct"); + struct nk_window *win; + struct nk_style *style; + struct nk_input *in; + + struct nk_rect header; + int is_clicked = nk_false; + enum nk_widget_layout_states s; + const struct nk_style_item *background; + struct nk_text text; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + win = ctx->current; + style = &ctx->style; + s = nk_widget(&header, ctx); + if (!s) return 0; + + in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input; + if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT)) + is_clicked = nk_true; + + /* draw combo box header background and border */ + if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) { + background = &style->combo.active; + text.text = style->combo.label_active; + } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) { + background = &style->combo.hover; + text.text = style->combo.label_hover; + } else { + background = &style->combo.normal; + text.text = style->combo.label_normal; + } + if (background->type == NK_STYLE_ITEM_IMAGE) { + text.background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + } else { + text.background = background->data.color; + nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color); + nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color); + } + { + struct nk_rect content; + struct nk_rect button; + struct nk_rect label; + struct nk_rect image; + int draw_button_symbol; + + enum nk_symbol_type sym; + if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) + sym = style->combo.sym_hover; + else if (is_clicked) + sym = style->combo.sym_active; + else sym = style->combo.sym_normal; + + /* represents whether or not the combo's button symbol should be drawn */ + draw_button_symbol = sym != NK_SYMBOL_NONE; + + /* calculate button */ + button.w = header.h - 2 * style->combo.button_padding.y; + button.x = (header.x + header.w - header.h) - style->combo.button_padding.x; + button.y = header.y + style->combo.button_padding.y; + button.h = button.w; + + content.x = button.x + style->combo.button.padding.x; + content.y = button.y + style->combo.button.padding.y; + content.w = button.w - 2 * style->combo.button.padding.x; + content.h = button.h - 2 * style->combo.button.padding.y; + if (draw_button_symbol) + nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state, + &ctx->style.combo.button, sym, style->font); + + /* draw image */ + image.x = header.x + style->combo.content_padding.x; + image.y = header.y + style->combo.content_padding.y; + image.h = header.h - 2 * style->combo.content_padding.y; + image.w = image.h; + nk_draw_image(&win->buffer, image, &img, nk_white); + + /* draw label */ + text.padding = nk_vec2(0,0); + label.x = image.x + image.w + style->combo.spacing.x + style->combo.content_padding.x; + label.y = header.y + style->combo.content_padding.y; + label.h = header.h - 2 * style->combo.content_padding.y; + if (draw_button_symbol) + label.w = (button.x - style->combo.content_padding.x) - label.x; + else + label.w = (header.x + header.w - style->combo.content_padding.x) - label.x; + nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font); + } + return nk_combo_begin(ctx, win, size, is_clicked, header); +} +NK_API nk_bool +nk_combo_begin_symbol_label(struct nk_context *ctx, + const char *selected, enum nk_symbol_type type, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected / const"); + return nk_combo_begin_symbol_text(ctx, selected, strlen(selected), type, size); +} +NK_API nk_bool +nk_combo_begin_image_label(struct nk_context *ctx, + const char *selected, struct nk_image img, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected / const"); + return nk_combo_begin_image_text(ctx, selected, strlen(selected), img, size); +} +NK_API nk_bool +nk_combo_item_text(struct nk_context *ctx, const char *text, int len,nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_item_text"); + return nk_contextual_item_text(ctx, text, len, align); +} +NK_API nk_bool +nk_combo_item_label(struct nk_context *ctx, const char *label, nk_flags align) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_combo_item_label"); + return nk_contextual_item_label(ctx, label, align); +} +NK_API nk_bool +nk_combo_item_image_text(struct nk_context *ctx, struct nk_image img, const char *text, + int len, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - len, / int"); + return nk_contextual_item_image_text(ctx, img, text, len, alignment); +} +NK_API nk_bool +nk_combo_item_image_label(struct nk_context *ctx, struct nk_image img, + const char *text, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_contextual_item_image_label(ctx, img, text, alignment); +} +NK_API nk_bool +nk_combo_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, + const char *text, int len, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - text / const"); + return nk_contextual_item_symbol_text(ctx, sym, text, len, alignment); +} +NK_API nk_bool +nk_combo_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym, + const char *label, nk_flags alignment) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - label / const"); + return nk_contextual_item_symbol_label(ctx, sym, label, alignment); +} +NK_API void nk_combo_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_combo_end / NK_API"); + nk_contextual_end(ctx); +} +NK_API void nk_combo_close(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_combo_close / NK_API"); + nk_contextual_close(ctx); +} +NK_API int +nk_combo(struct nk_context *ctx, const char **items, int count, + int selected, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / int"); + int i = 0; + int max_height; + struct nk_vec2 item_spacing; + struct nk_vec2 window_padding; + + // NK_ASSERT(ctx); + // NK_ASSERT(items); + // NK_ASSERT(ctx->current); + if (!ctx || !items ||!count) + return selected; + + item_spacing = ctx->style.window.spacing; + window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type); + max_height = count * item_height + count * (int)item_spacing.y; + max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2; + size.y = NK_MIN(size.y, (int)max_height); + if (nk_combo_begin_label(ctx, items[selected], size)) { + nk_layout_row_dynamic(ctx, (int)item_height, 1); + for (i = 0; i < count; ++i) { + if (nk_combo_item_label(ctx, items[i], NK_TEXT_LEFT)) + selected = i; + } + nk_combo_end(ctx); + } + return selected; +} +NK_API int +nk_combo_separator(struct nk_context *ctx, const char *items_separated_by_separator, + int separator, int selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - separator, / int"); + int i; + int max_height; + struct nk_vec2 item_spacing; + struct nk_vec2 window_padding; + const char *current_item; + const char *iter; + int length = 0; + + // NK_ASSERT(ctx); + // NK_ASSERT(items_separated_by_separator); + if (!ctx || !items_separated_by_separator) + return selected; + + /* calculate popup window */ + item_spacing = ctx->style.window.spacing; + window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type); + max_height = count * item_height + count * (int)item_spacing.y; + max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2; + size.y = NK_MIN(size.y, (int)max_height); + + /* find selected item */ + current_item = items_separated_by_separator; + for (i = 0; i < count; ++i) { + iter = current_item; + while (*iter && *iter != separator) iter++; + length = (int)(iter - current_item); + if (i == selected) break; + current_item = iter + 1; + } + + if (nk_combo_begin_text(ctx, current_item, length, size)) { + current_item = items_separated_by_separator; + nk_layout_row_dynamic(ctx, (int)item_height, 1); + for (i = 0; i < count; ++i) { + iter = current_item; + while (*iter && *iter != separator) iter++; + length = (int)(iter - current_item); + if (nk_combo_item_text(ctx, current_item, length, NK_TEXT_LEFT)) + selected = i; + current_item = current_item + length + 1; + } + nk_combo_end(ctx); + } + return selected; +} +NK_API int +nk_combo_string(struct nk_context *ctx, const char *items_separated_by_zeros, + int selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / int"); + return nk_combo_separator(ctx, items_separated_by_zeros, '\0', selected, count, item_height, size); +} +NK_API int +nk_combo_callback(struct nk_context *ctx, void(*item_getter)(void*, int, const char**), + void *userdata, int selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - userdata, / void"); + int i; + int max_height; + struct nk_vec2 item_spacing; + struct nk_vec2 window_padding; + const char *item; + + // NK_ASSERT(ctx); + // NK_ASSERT(item_getter); + if (!ctx || !item_getter) + return selected; + + /* calculate popup window */ + item_spacing = ctx->style.window.spacing; + window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type); + max_height = count * item_height + count * (int)item_spacing.y; + max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2; + size.y = NK_MIN(size.y, (int)max_height); + + item_getter(userdata, selected, &item); + if (nk_combo_begin_label(ctx, item, size)) { + nk_layout_row_dynamic(ctx, (int)item_height, 1); + for (i = 0; i < count; ++i) { + item_getter(userdata, i, &item); + if (nk_combo_item_label(ctx, item, NK_TEXT_LEFT)) + selected = i; + } + nk_combo_end(ctx); + } return selected; +} +NK_API void +nk_combobox(struct nk_context *ctx, const char **items, int count, + int *selected, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / int"); + *selected = nk_combo(ctx, items, count, *selected, item_height, size); +} +NK_API void +nk_combobox_string(struct nk_context *ctx, const char *items_separated_by_zeros, + int *selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - selected, / int"); + *selected = nk_combo_string(ctx, items_separated_by_zeros, *selected, count, item_height, size); +} +NK_API void +nk_combobox_separator(struct nk_context *ctx, const char *items_separated_by_separator, + int separator, int *selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - separator, / int"); + *selected = nk_combo_separator(ctx, items_separated_by_separator, separator, + *selected, count, item_height, size); +} +NK_API void +nk_combobox_callback(struct nk_context *ctx, + void(*item_getter)(void* data, int id, const char **out_text), + void *userdata, int *selected, int count, int item_height, struct nk_vec2 size) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - userdata, / void"); + *selected = nk_combo_callback(ctx, item_getter, userdata, *selected, count, item_height, size); +} + + + + + +/* =============================================================== + * + * TOOLTIP + * + * ===============================================================*/ +NK_API nk_bool +nk_tooltip_begin(struct nk_context *ctx, int width) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tooltip_begin"); + int x,y,w,h; + struct nk_window *win; + const struct nk_input *in; + struct nk_rect bounds; + int ret; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + if (!ctx || !ctx->current || !ctx->current->layout) + return 0; + + /* make sure that no nonblocking popup is currently active */ + win = ctx->current; + in = &ctx->input; + if (win->popup.win && (win->popup.type & NK_PANEL_SET_NONBLOCK)) + return 0; + + w = nk_iceilf(width); + h = nk_iceilf(nk_null_rect.h); + x = nk_ifloorf(in->mouse.pos.x + 1) - (int)win->layout->clip.x; + y = nk_ifloorf(in->mouse.pos.y + 1) - (int)win->layout->clip.y; + + bounds.x = (int)x; + bounds.y = (int)y; + bounds.w = (int)w; + bounds.h = (int)h; + + ret = nk_popup_begin(ctx, NK_POPUP_DYNAMIC, + "__##Tooltip##__", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER, bounds); + if (ret) win->layout->flags &= ~(nk_flags)NK_WINDOW_ROM; + win->popup.type = NK_PANEL_TOOLTIP; + ctx->current->layout->type = NK_PANEL_TOOLTIP; + return ret; +} + +NK_API void +nk_tooltip_end(struct nk_context *ctx) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tooltip_end"); + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return; + ctx->current->seq--; + nk_popup_close(ctx); + nk_popup_end(ctx); +} +NK_API void +nk_tooltip(struct nk_context *ctx, const char *text) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tooltip"); + const struct nk_style *style; + struct nk_vec2 padding; + + int text_len; + int text_width; + int text_height; + + // NK_ASSERT(ctx); + // NK_ASSERT(ctx->current); + // NK_ASSERT(ctx->current->layout); + // NK_ASSERT(text); + if (!ctx || !ctx->current || !ctx->current->layout || !text) + return; + + /* fetch configuration data */ + style = &ctx->style; + padding = style->window.padding; + + /* calculate size of the text and tooltip */ + text_len = strlen(text); + text_width = style->font->width(style->font->userdata, + style->font->height, text, text_len); + text_width += (4 * padding.x); + text_height = (style->font->height + 2 * padding.y); + + /* execute tooltip and fill with text */ + if (nk_tooltip_begin(ctx, (int)text_width)) { + nk_layout_row_dynamic(ctx, (int)text_height, 1); + nk_text(ctx, text, text_len, NK_TEXT_LEFT); + nk_tooltip_end(ctx); + } +} +#ifdef NK_INCLUDE_STANDARD_VARARGS +NK_API void +nk_tooltipf(struct nk_context *ctx, const char *fmt, ...) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tooltipf"); + va_list args; + va_start(args, fmt); + nk_tooltipfv(ctx, fmt, args); + va_end(args); +} +NK_API void +nk_tooltipfv(struct nk_context *ctx, const char *fmt, va_list args) +{ + //writeSerialPort(boutRefNum, "FUNCTION CALL - nk_context / nk_tooltipfv"); + char buf[256]; + nk_strfmt(buf, NK_LEN(buf), fmt, args); + nk_tooltip(ctx, buf); +} +#endif + + + +#endif /* NK_IMPLEMENTATION */ + +/* +/// ## License +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~none +/// ------------------------------------------------------------------------------ +/// This software is available under 2 licenses -- choose whichever you prefer. +/// ------------------------------------------------------------------------------ +/// ALTERNATIVE A - MIT License +/// Copyright (c) 2016-2018 Micha Mettke +/// Permission is hereby granted, free of charge, to any person obtaining a copy of +/// this software and associated documentation files (the "Software"), to deal in +/// the Software without restriction, including without limitation the rights to +/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +/// of the Software, and to permit persons to whom the Software is furnished to do +/// so, subject to the following conditions: +/// The above copyright notice and this permission notice shall be included in all +/// copies or substantial portions of the Software. +/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +/// SOFTWARE. +/// ------------------------------------------------------------------------------ +/// ALTERNATIVE B - Public Domain (www.unlicense.org) +/// This is free and unencumbered software released into the public domain. +/// Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +/// software, either in source code form or as a compiled binary, for any purpose, +/// commercial or non-commercial, and by any means. +/// In jurisdictions that recognize copyright laws, the author or authors of this +/// software dedicate any and all copyright interest in the software to the public +/// domain. We make this dedication for the benefit of the public at large and to +/// the detriment of our heirs and successors. We intend this dedication to be an +/// overt act of relinquishment in perpetuity of all present and future rights to +/// this software under copyright law. +/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +/// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +/// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +/// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/// ------------------------------------------------------------------------------ +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +/// ## Changelog +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~none +/// [date][x.yy.zz]-[description] +/// -[date]: date on which the change has been pushed +/// -[x.yy.zz]: Numerical version string representation. Each version number on the right +/// resets back to zero if version on the left is incremented. +/// - [x]: Major version with API and library breaking changes +/// - [yy]: Minor version with non-breaking API and library changes +/// - [zz]: Bug fix version with no direct changes to API +/// +/// - 2021/03/17 (4.07.0) - Fix nk_property hover bug +/// - 2021/03/15 (4.06.4) - Change nk_propertyi back to int +/// - 2021/03/15 (4.06.3) - Update documentation for functions that now return nk_bool +/// - 2020/12/19 (4.06.2) - Fix additional C++ style comments which are not allowed in ISO C90. +/// - 2020/10/11 (4.06.1) - Fix C++ style comments which are not allowed in ISO C90. +/// - 2020/10/07 (4.06.0) - Fix nk_combo return type wrongly changed to nk_bool +/// - 2020/09/05 (4.05.0) - Use the nk_font_atlas allocator for stb_truetype memory management. +/// - 2020/09/04 (4.04.1) - Replace every boolean int by nk_bool +/// - 2020/09/04 (4.04.0) - Add nk_bool with NK_INCLUDE_STANDARD_BOOL +/// - 2020/06/13 (4.03.1) - Fix nk_pool allocation sizes. +/// - 2020/06/04 (4.03.0) - Made nk_combo header symbols optional. +/// - 2020/05/27 (4.02.5) - Fix nk_do_edit: Keep scroll position when re-activating edit widget. +/// - 2020/05/09 (4.02.4) - Fix nk_menubar height calculation bug +/// - 2020/05/08 (4.02.3) - Fix missing stdarg.h with NK_INCLUDE_STANDARD_VARARGS +/// - 2020/04/30 (4.02.2) - Fix nk_edit border drawing bug +/// - 2020/04/09 (4.02.1) - Removed unused nk_sqrt function to fix compiler warnings +/// - Fixed compiler warnings if you bring your own methods for +/// nk_cos/nk_sin/nk_strtod/nk_memset/nk_memcopy/nk_dtoa +/// - 2020/04/06 (4.01.10) - Fix bug: Do not use pool before checking for NULL +/// - 2020/03/22 (4.01.9) - Fix bug where layout state wasn't restored correctly after +/// popping a tree. +/// - 2020/03/11 (4.01.8) - Fix bug where padding is subtracted from widget +/// - 2020/03/06 (4.01.7) - Fix bug where width padding was applied twice +/// - 2020/02/06 (4.01.6) - Update stb_truetype.h and stb_rect_pack.h and separate them +/// - 2019/12/10 (4.01.5) - Fix off-by-one error in NK_INTERSECT +/// - 2019/10/09 (4.01.4) - Fix bug for autoscrolling in nk_do_edit +/// - 2019/09/20 (4.01.3) - Fixed a bug wherein combobox cannot be closed by clicking the header +/// when NK_BUTTON_TRIGGER_ON_RELEASE is defined. +/// - 2019/09/10 (4.01.2) - Fixed the nk_cos function, which deviated significantly. +/// - 2019/09/08 (4.01.1) - Fixed a bug wherein re-baking of fonts caused a segmentation +/// fault due to dst_font->glyph_count not being zeroed on subsequent +/// bakes of the same set of fonts. +/// - 2019/06/23 (4.01.0) - Added nk_***_get_scroll and nk_***_set_scroll for groups, windows, and popups. +/// - 2019/06/12 (4.00.3) - Fix panel background drawing bug. +/// - 2018/10/31 (4.00.2) - Added NK_KEYSTATE_BASED_INPUT to "fix" state based backends +/// like GLFW without breaking key repeat behavior on event based. +/// - 2018/04/01 (4.00.1) - Fixed calling `nk_convert` multiple time per single frame. +/// - 2018/04/01 (4.00.0) - BREAKING CHANGE: nk_draw_list_clear no longer tries to +/// clear provided buffers. So make sure to either free +/// or clear each passed buffer after calling nk_convert. +/// - 2018/02/23 (3.00.6) - Fixed slider dragging behavior. +/// - 2018/01/31 (3.00.5) - Fixed overcalculation of cursor data in font baking process. +/// - 2018/01/31 (3.00.4) - Removed name collision with stb_truetype. +/// - 2018/01/28 (3.00.3) - Fixed panel window border drawing bug. +/// - 2018/01/12 (3.00.2) - Added `nk_group_begin_titled` for separed group identifier and title. +/// - 2018/01/07 (3.00.1) - Started to change documentation style. +/// - 2018/01/05 (3.00.0) - BREAKING CHANGE: The previous color picker API was broken +/// because of conversions between int and byte color representation. +/// Color pickers now use inting point values to represent +/// HSV values. To get back the old behavior I added some additional +/// color conversion functions to cast between nk_color and +/// nk_colorf. +/// - 2017/12/23 (2.00.7) - Fixed small warning. +/// - 2017/12/23 (2.00.7) - Fixed `nk_edit_buffer` behavior if activated to allow input. +/// - 2017/12/23 (2.00.7) - Fixed modifyable progressbar dragging visuals and input behavior. +/// - 2017/12/04 (2.00.6) - Added formated string tooltip widget. +/// - 2017/11/18 (2.00.5) - Fixed window becoming hidden with flag `NK_WINDOW_NO_INPUT`. +/// - 2017/11/15 (2.00.4) - Fixed font merging. +/// - 2017/11/07 (2.00.3) - Fixed window size and position modifier functions. +/// - 2017/09/14 (2.00.2) - Fixed `nk_edit_buffer` and `nk_edit_focus` behavior. +/// - 2017/09/14 (2.00.1) - Fixed window closing behavior. +/// - 2017/09/14 (2.00.0) - BREAKING CHANGE: Modifing window position and size funtions now +/// require the name of the window and must happen outside the window +/// building process (between function call nk_begin and nk_en / gd). +/// - 2017/09/11 (1.40.9) - Fixed window background flag if background window is declared last. +/// - 2017/08/27 (1.40.8) - Fixed `nk_item_is_any_active` for hidden windows. +/// - 2017/08/27 (1.40.7) - Fixed window background flag. +/// - 2017/07/07 (1.40.6) - Fixed missing clipping rect check for hovering/clicked +/// query for widgets. +/// - 2017/07/07 (1.40.5) - Fixed drawing bug for vertex output for lines and stroked +/// and filled rectangles. +/// - 2017/07/07 (1.40.4) - Fixed bug in nk_convert trying to add windows that are in +/// process of being destroyed. +/// - 2017/07/07 (1.40.3) - Fixed table internal bug caused by storing table size in +/// window instead of directly in table. +/// - 2017/06/30 (1.40.2) - Removed unneeded semicolon in C++ NK_ALIGNOF macro. +/// - 2017/06/30 (1.40.1) - Fixed drawing lines smaller or equal zero. +/// - 2017/06/08 (1.40.0) - Removed the breaking part of last commit. Auto layout now only +/// comes in effect if you pass in zero was row height argument. +/// - 2017/06/08 (1.40.0) - BREAKING CHANGE: while not directly API breaking it will change +/// how layouting works. From now there will be an internal minimum +/// row height derived from font height. If you need a row smaller than +/// that you can directly set it by `nk_layout_set_min_row_height` and +/// reset the value back by calling `nk_layout_reset_min_row_height. +/// - 2017/06/08 (1.39.1) - Fixed property text edit handling bug caused by past `nk_widget` fix. +/// - 2017/06/08 (1.39.0) - Added function to retrieve window space without calling a `nk_layout_xxx` function. +/// - 2017/06/06 (1.38.5) - Fixed `nk_convert` return flag for command buffer. +/// - 2017/05/23 (1.38.4) - Fixed activation behavior for widgets partially clipped. +/// - 2017/05/10 (1.38.3) - Fixed wrong min window size mouse scaling over boundries. +/// - 2017/05/09 (1.38.2) - Fixed vertical scrollbar drawing with not enough space. +/// - 2017/05/09 (1.38.1) - Fixed scaler dragging behavior if window size hits minimum size. +/// - 2017/05/06 (1.38.0) - Added platform double-click support. +/// - 2017/04/20 (1.37.1) - Fixed key repeat found inside glfw demo backends. +/// - 2017/04/20 (1.37.0) - Extended properties with selection and clipboard support. +/// - 2017/04/20 (1.36.2) - Fixed #405 overlapping rows with zero padding and spacing. +/// - 2017/04/09 (1.36.1) - Fixed #403 with another widget int error. +/// - 2017/04/09 (1.36.0) - Added window `NK_WINDOW_NO_INPUT` and `NK_WINDOW_NOT_INTERACTIVE` flags. +/// - 2017/04/09 (1.35.3) - Fixed buffer heap corruption. +/// - 2017/03/25 (1.35.2) - Fixed popup overlapping for `NK_WINDOW_BACKGROUND` windows. +/// - 2017/03/25 (1.35.1) - Fixed windows closing behavior. +/// - 2017/03/18 (1.35.0) - Added horizontal scroll requested in #377. +/// - 2017/03/18 (1.34.3) - Fixed long window header titles. +/// - 2017/03/04 (1.34.2) - Fixed text edit filtering. +/// - 2017/03/04 (1.34.1) - Fixed group closable flag. +/// - 2017/02/25 (1.34.0) - Added custom draw command for better language binding support. +/// - 2017/01/24 (1.33.0) - Added programatic way of remove edit focus. +/// - 2017/01/24 (1.32.3) - Fixed wrong define for basic type definitions for windows. +/// - 2017/01/21 (1.32.2) - Fixed input capture from hidden or closed windows. +/// - 2017/01/21 (1.32.1) - Fixed slider behavior and drawing. +/// - 2017/01/13 (1.32.0) - Added flag to put scaler into the bottom left corner. +/// - 2017/01/13 (1.31.0) - Added additional row layouting method to combine both +/// dynamic and static widgets. +/// - 2016/12/31 (1.30.0) - Extended scrollbar offset from 16-bit to 32-bit. +/// - 2016/12/31 (1.29.2) - Fixed closing window bug of minimized windows. +/// - 2016/12/03 (1.29.1) - Fixed wrapped text with no seperator and C89 error. +/// - 2016/12/03 (1.29.0) - Changed text wrapping to process words not characters. +/// - 2016/11/22 (1.28.6) - Fixed window minimized closing bug. +/// - 2016/11/19 (1.28.5) - Fixed abstract combo box closing behavior. +/// - 2016/11/19 (1.28.4) - Fixed tooltip flickering. +/// - 2016/11/19 (1.28.3) - Fixed memory leak caused by popup repeated closing. +/// - 2016/11/18 (1.28.2) - Fixed memory leak caused by popup panel allocation. +/// - 2016/11/10 (1.28.1) - Fixed some warnings and C++ error. +/// - 2016/11/10 (1.28.0) - Added additional `nk_button` versions which allows to directly +/// pass in a style struct to change buttons visual. +/// - 2016/11/10 (1.27.0) - Added additional `nk_tree` versions to support external state +/// storage. Just like last the `nk_group` commit the main +/// advantage is that you optionally can minimize nuklears runtime +/// memory consumption or handle hash collisions. +/// - 2016/11/09 (1.26.0) - Added additional `nk_group` version to support external scrollbar +/// offset storage. Main advantage is that you can externalize +/// the memory management for the offset. It could also be helpful +/// if you have a hash collision in `nk_group_begin` but really +/// want the name. In addition I added `nk_list_view` which allows +/// to draw big lists inside a group without actually having to +/// commit the whole list to nuklear (issue #269). +/// - 2016/10/30 (1.25.1) - Fixed clipping rectangle bug inside `nk_draw_list`. +/// - 2016/10/29 (1.25.0) - Pulled `nk_panel` memory management into nuklear and out of +/// the hands of the user. From now on users don't have to care +/// about panels unless they care about some information. If you +/// still need the panel just call `nk_window_get_panel`. +/// - 2016/10/21 (1.24.0) - Changed widget border drawing to stroked rectangle from filled +/// rectangle for less overdraw and widget background transparency. +/// - 2016/10/18 (1.23.0) - Added `nk_edit_focus` for manually edit widget focus control. +/// - 2016/09/29 (1.22.7) - Fixed deduction of basic type in non `` compilation. +/// - 2016/09/29 (1.22.6) - Fixed edit widget UTF-8 text cursor drawing bug. +/// - 2016/09/28 (1.22.5) - Fixed edit widget UTF-8 text appending/inserting/removing. +/// - 2016/09/28 (1.22.4) - Fixed drawing bug inside edit widgets which offset all text +/// text in every edit widget if one of them is scrolled. +/// - 2016/09/28 (1.22.3) - Fixed small bug in edit widgets if not active. The wrong +/// text length is passed. It should have been in bytes but +/// was passed as glyphes. +/// - 2016/09/20 (1.22.2) - Fixed color button size calculation. +/// - 2016/09/20 (1.22.1) - Fixed some `nk_vsnprintf` behavior bugs and removed `` +/// again from `NK_INCLUDE_STANDARD_VARARGS`. +/// - 2016/09/18 (1.22.0) - C89 does not support vsnprintf only C99 and newer as well +/// as C++11 and newer. In addition to use vsnprintf you have +/// to include . So just defining `NK_INCLUDE_STD_VAR_ARGS` +/// is not enough. That behavior is now fixed. By default if +/// both varargs as well as stdio is selected I try to use +/// vsnprintf if not possible I will revert to vsprintf. If +/// varargs but not stdio was defined I will use my own function. +/// - 2016/09/15 (1.21.2) - Fixed panel `close` behavior for deeper panel levels. +/// - 2016/09/15 (1.21.1) - Fixed C++ errors and wrong argument to `nk_panel_get_xxxx`. +/// - 2016/09/13 (1.21.0) - !BREAKING! Fixed nonblocking popup behavior in menu, combo, +/// and contextual which prevented closing in y-direction if +/// popup did not reach max height. +/// In addition the height parameter was changed into vec2 +/// for width and height to have more control over the popup size. +/// - 2016/09/13 (1.20.3) - Cleaned up and extended type selection. +/// - 2016/09/13 (1.20.2) - Fixed slider behavior hopefully for the last time. This time +/// all calculation are correct so no more hackery. +/// - 2016/09/13 (1.20.1) - Internal change to divide window/panel flags into panel flags and types. +/// Suprisinly spend years in C and still happened to confuse types +/// with flags. Probably something to take note. +/// - 2016/09/08 (1.20.0) - Added additional helper function to make it easier to just +/// take the produced buffers from `nk_convert` and unplug the +/// iteration process from `nk_context`. So now you can +/// just use the vertex,element and command buffer + two pointer +/// inside the command buffer retrieved by calls `nk__draw_begin` +/// and `nk__draw_end` and macro `nk_draw_foreach_bounded`. +/// - 2016/09/08 (1.19.0) - Added additional asserts to make sure every `nk_xxx_begin` call +/// for windows, popups, combobox, menu and contextual is guarded by +/// `if` condition and does not produce false drawing output. +/// - 2016/09/08 (1.18.0) - Changed confusing name for `NK_SYMBOL_RECT_FILLED`, `NK_SYMBOL_RECT` +/// to hopefully easier to understand `NK_SYMBOL_RECT_FILLED` and +/// `NK_SYMBOL_RECT_OUTLINE`. +/// - 2016/09/08 (1.17.0) - Changed confusing name for `NK_SYMBOL_CIRLCE_FILLED`, `NK_SYMBOL_CIRCLE` +/// to hopefully easier to understand `NK_SYMBOL_CIRCLE_FILLED` and +/// `NK_SYMBOL_CIRCLE_OUTLINE`. +/// - 2016/09/08 (1.16.0) - Added additional checks to select correct types if `NK_INCLUDE_FIXED_TYPES` +/// is not defined by supporting the biggest compiler GCC, clang and MSVC. +/// - 2016/09/07 (1.15.3) - Fixed `NK_INCLUDE_COMMAND_USERDATA` define to not cause an error. +/// - 2016/09/04 (1.15.2) - Fixed wrong combobox height calculation. +/// - 2016/09/03 (1.15.1) - Fixed gaps inside combo boxes in OpenGL. +/// - 2016/09/02 (1.15.0) - Changed nuklear to not have any default vertex layout and +/// instead made it user provided. The range of types to convert +/// to is quite limited at the moment, but I would be more than +/// happy to accept PRs to add additional. +/// - 2016/08/30 (1.14.2) - Removed unused variables. +/// - 2016/08/30 (1.14.1) - Fixed C++ build errors. +/// - 2016/08/30 (1.14.0) - Removed mouse dragging from SDL demo since it does not work correctly. +/// - 2016/08/30 (1.13.4) - Tweaked some default styling variables. +/// - 2016/08/30 (1.13.3) - Hopefully fixed drawing bug in slider, in general I would +/// refrain from using slider with a big number of steps. +/// - 2016/08/30 (1.13.2) - Fixed close and minimize button which would fire even if the +/// window was in Read Only Mode. +/// - 2016/08/30 (1.13.1) - Fixed popup panel padding handling which was previously just +/// a hack for combo box and menu. +/// - 2016/08/30 (1.13.0) - Removed `NK_WINDOW_DYNAMIC` flag from public API since +/// it is bugged and causes issues in window selection. +/// - 2016/08/30 (1.12.0) - Removed scaler size. The size of the scaler is now +/// determined by the scrollbar size. +/// - 2016/08/30 (1.11.2) - Fixed some drawing bugs caused by changes from 1.11.0. +/// - 2016/08/30 (1.11.1) - Fixed overlapping minimized window selection. +/// - 2016/08/30 (1.11.0) - Removed some internal complexity and overly complex code +/// handling panel padding and panel border. +/// - 2016/08/29 (1.10.0) - Added additional height parameter to `nk_combobox_xxx`. +/// - 2016/08/29 (1.10.0) - Fixed drawing bug in dynamic popups. +/// - 2016/08/29 (1.10.0) - Added experimental mouse scrolling to popups, menus and comboboxes. +/// - 2016/08/26 (1.10.0) - Added window name string prepresentation to account for +/// hash collisions. Currently limited to `NK_WINDOW_MAX_NAME` +/// which in term can be redefined if not big enough. +/// - 2016/08/26 (1.10.0) - Added stacks for temporary style/UI changes in code. +/// - 2016/08/25 (1.10.0) - Changed `nk_input_is_key_pressed` and 'nk_input_is_key_released' +/// to account for key press and release happening in one frame. +/// - 2016/08/25 (1.10.0) - Added additional nk_edit flag to directly jump to the end on activate. +/// - 2016/08/17 (1.09.6) - Removed invalid check for value zero in `nk_propertyx`. +/// - 2016/08/16 (1.09.5) - Fixed ROM mode for deeper levels of popup windows parents. +/// - 2016/08/15 (1.09.4) - Editbox are now still active if enter was pressed with flag +/// `NK_EDIT_SIG_ENTER`. Main reasoning is to be able to keep +/// typing after commiting. +/// - 2016/08/15 (1.09.4) - Removed redundant code. +/// - 2016/08/15 (1.09.4) - Fixed negative numbers in `nk_strtoi` and remove unused variable. +/// - 2016/08/15 (1.09.3) - Fixed `NK_WINDOW_BACKGROUND` flag behavior to select a background +/// window only as selected by hovering and not by clicking. +/// - 2016/08/14 (1.09.2) - Fixed a bug in font atlas which caused wrong loading +/// of glyphes for font with multiple ranges. +/// - 2016/08/12 (1.09.1) - Added additional function to check if window is currently +/// hidden and therefore not visible. +/// - 2016/08/12 (1.09.1) - nk_window_is_closed now queries the correct flag `NK_WINDOW_CLOSED` +/// instead of the old flag `NK_WINDOW_HIDDEN`. +/// - 2016/08/09 (1.09.0) - Added additional double version to nk_property and changed +/// the underlying implementation to not cast to int and instead +/// work directly on the given values. +/// - 2016/08/09 (1.08.0) - Added additional define to overwrite library internal +/// inting pointer number to string conversion for additional +/// precision. +/// - 2016/08/09 (1.08.0) - Added additional define to overwrite library internal +/// string to inting point number conversion for additional +/// precision. +/// - 2016/08/08 (1.07.2) - Fixed compiling error without define `NK_INCLUDE_FIXED_TYPE`. +/// - 2016/08/08 (1.07.1) - Fixed possible inting point error inside `nk_widget` leading +/// to wrong wiget width calculation which results in widgets falsly +/// becomming tagged as not inside window and cannot be accessed. +/// - 2016/08/08 (1.07.0) - Nuklear now differentiates between hiding a window (NK_WINDOW_HIDDEN) and +/// closing a window (NK_WINDOW_CLOSED). A window can be hidden/shown +/// by using `nk_window_show` and closed by either clicking the close +/// icon in a window or by calling `nk_window_close`. Only closed +/// windows get removed at the end of the frame while hidden windows +/// remain. +/// - 2016/08/08 (1.06.0) - Added `nk_edit_string_zero_terminated` as a second option to +/// `nk_edit_string` which takes, edits and outputs a '\0' terminated string. +/// - 2016/08/08 (1.05.4) - Fixed scrollbar auto hiding behavior. +/// - 2016/08/08 (1.05.3) - Fixed wrong panel padding selection in `nk_layout_widget_space`. +/// - 2016/08/07 (1.05.2) - Fixed old bug in dynamic immediate mode layout API, calculating +/// wrong item spacing and panel width. +/// - 2016/08/07 (1.05.1) - Hopefully finally fixed combobox popup drawing bug. +/// - 2016/08/07 (1.05.0) - Split varargs away from `NK_INCLUDE_STANDARD_IO` into own +/// define `NK_INCLUDE_STANDARD_VARARGS` to allow more fine +/// grained controlled over library includes. +/// - 2016/08/06 (1.04.5) - Changed memset calls to `NK_MEMSET`. +/// - 2016/08/04 (1.04.4) - Fixed fast window scaling behavior. +/// - 2016/08/04 (1.04.3) - Fixed window scaling, movement bug which appears if you +/// move/scale a window and another window is behind it. +/// If you are fast enough then the window behind gets activated +/// and the operation is blocked. I now require activating +/// by hovering only if mouse is not pressed. +/// - 2016/08/04 (1.04.2) - Fixed changing fonts. +/// - 2016/08/03 (1.04.1) - Fixed `NK_WINDOW_BACKGROUND` behavior. +/// - 2016/08/03 (1.04.0) - Added color parameter to `nk_draw_image`. +/// - 2016/08/03 (1.04.0) - Added additional window padding style attributes for +/// sub windows (combo, menu, ...). +/// - 2016/08/03 (1.04.0) - Added functions to show/hide software cursor. +/// - 2016/08/03 (1.04.0) - Added `NK_WINDOW_BACKGROUND` flag to force a window +/// to be always in the background of the screen. +/// - 2016/08/03 (1.03.2) - Removed invalid assert macro for NK_RGB color picker. +/// - 2016/08/01 (1.03.1) - Added helper macros into header include guard. +/// - 2016/07/29 (1.03.0) - Moved the window/table pool into the header part to +/// simplify memory management by removing the need to +/// allocate the pool. +/// - 2016/07/29 (1.02.0) - Added auto scrollbar hiding window flag which if enabled +/// will hide the window scrollbar after NK_SCROLLBAR_HIDING_TIMEOUT +/// seconds without window interaction. To make it work +/// you have to also set a delta time inside the `nk_context`. +/// - 2016/07/25 (1.01.1) - Fixed small panel and panel border drawing bugs. +/// - 2016/07/15 (1.01.0) - Added software cursor to `nk_style` and `nk_context`. +/// - 2016/07/15 (1.01.0) - Added const correctness to `nk_buffer_push' data argument. +/// - 2016/07/15 (1.01.0) - Removed internal font baking API and simplified +/// font atlas memory management by converting pointer +/// arrays for fonts and font configurations to lists. +/// - 2016/07/15 (1.00.0) - Changed button API to use context dependend button +/// behavior instead of passing it for every function ca / toll. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// ## Gallery +/// ![Figure [blue]: Feature overview with blue color styling](https://cloud.githubusercontent.com/assets/8057201/13538240/acd96876-e249-11e5-9547-5ac0b19667a0.png) +/// ![Figure [red]: Feature overview with red color styling](https://cloud.githubusercontent.com/assets/8057201/13538243/b04acd4c-e249-11e5-8fd2-ad7744a5b446.png) +/// ![Figure [widgets]: Widget overview](https://cloud.githubusercontent.com/assets/8057201/11282359/3325e3c6-8eff-11e5-86cb-cf02b0596087.png) +/// ![Figure [blackwhite]: Black and white](https://cloud.githubusercontent.com/assets/8057201/11033668/59ab5d04-86e5-11e5-8091-c56f16411565.png) +/// ![Figure [filexp]: File explorer](https://cloud.githubusercontent.com/assets/8057201/10718115/02a9ba08-7b6b-11e5-950f-adacdd637739.png) +/// ![Figure [opengl]: OpenGL Editor](https://cloud.githubusercontent.com/assets/8057201/12779619/2a20d72c-ca69-11e5-95fe-4edecf820d5c.png) +/// ![Figure [nodedit]: Node Editor](https://cloud.githubusercontent.com/assets/8057201/9976995/e81ac04a-5ef7-11e5-872b-acd54fbeee03.gif) +/// ![Figure [skinning]: Using skinning in Nuklear](https://cloud.githubusercontent.com/assets/8057201/15991632/76494854-30b8-11e6-9555-a69840d0d50b.png) +/// ![Figure [bf]: Heavy modified version](https://cloud.githubusercontent.com/assets/8057201/14902576/339926a8-0d9c-11e6-9fee-a8b73af04473.png) +/// +/// ## Credits +/// Developed by Micha Mettke and every direct or indirect github contributor.

+/// +/// Embeds [stb_texedit](https://github.com/nothings/stb/blob/master/stb_textedit.h), [stb_truetype](https://github.com/nothings/stb/blob/master/stb_truetype.h) and [stb_rectpack](https://github.com/nothings/stb/blob/master/stb_rect_pack.h) by Sean Barret (public domain)
+/// Uses [stddoc.c](https://github.com/r-lyeh/stddoc.c) from r-lyeh@github.com for documentation generation

+/// Embeds ProggyClean.ttf font by Tristan Grimmer (MIT license).
+/// +/// Big thank you to Omar Cornut (ocornut@github) for his [imgui library](https://github.com/ocornut/imgui) and +/// giving me the inspiration for this library, Casey Muratori for handmade hero +/// and his original immediate mode graphical user interface idea and Sean +/// Barret for his amazing single header libraries which restored my faith +/// in libraries and brought me to create some of my own. Finally Apoorva Joshi +/// for his single header file packer. +*/ + diff --git a/nuklear_quickdraw.h b/nuklear_quickdraw.h new file mode 100644 index 0000000..8c7d514 --- /dev/null +++ b/nuklear_quickdraw.h @@ -0,0 +1,1383 @@ +/* + * Nuklear - 1.32.0 - public domain + * no warranty implied; use at your own risk. + * based on allegro5 version authored from 2015-2016 by Micha Mettke + * quickdraw version camhenlin 2021 + * + * v1 intent: + * - only default system font support + * - no graphics/images support - quickdraw has very limited support for this + */ +/* + * ============================================================== + * + * API + * + * =============================================================== + */ +#ifndef NK_QUICKDRAW_H_ +#define NK_QUICKDRAW_H_ +#include +#include +#include +#include +#include +#include "SerialHelper.h" + +typedef struct NkQuickDrawFont NkQuickDrawFont; +NK_API struct nk_context* nk_quickdraw_init(unsigned int width, unsigned int height); +NK_API int nk_quickdraw_handle_event(EventRecord *event, struct nk_context *nuklear_context); +NK_API void nk_quickdraw_shutdown(void); +NK_API void nk_quickdraw_render(WindowPtr window, struct nk_context *ctx); + +NK_API struct nk_image* nk_quickdraw_create_image(const char* file_name); +NK_API void nk_quickdraw_del_image(struct nk_image* image); +NK_API NkQuickDrawFont* nk_quickdraw_font_create_from_file(); + +#endif + +/* + * ============================================================== + * + * IMPLEMENTATION + * + * =============================================================== + */ + +#ifdef NK_QUICKDRAW_IMPLEMENTATION +#ifndef NK_QUICKDRAW_TEXT_MAX +#define NK_QUICKDRAW_TEXT_MAX 256 +#endif +#endif +struct NkQuickDrawFont { + struct nk_user_font nk; + char *font; +}; + +int lastEventWasKey = 0; +void *last; +void *buf; + +// constant keyboard mappings for convenenience +// See Inside Macintosh: Text pg A-7, A-8 +int homeKey = (int)0x01; +int enterKey = (int)0x03; +int endKey = (int)0x04; +int helpKey = (int)0x05; +int backspaceKey = (int)0x08; +int deleteKey = (int)0x7F; +int tabKey = (int)0x09; +int pageUpKey = (int)0x0B; +int pageDownKey = (int)0x0C; +int returnKey = (int)0x0D; +int rightArrowKey = (int)0x1D; +int leftArrowKey = (int)0x1C; +int downArrowKey = (int)0x1F; +int upArrowKey = (int)0x1E; +int eitherShiftKey = (int)0x0F; +int escapeKey = (int)0x1B; + +// #define NK_QUICKDRAW_GRAPHICS_DEBUGGING +// #def#ifdef NK_QUICKDRAW_EVENTS_DEBUGG + +typedef struct { + Ptr Address; + long RowBytes; + GrafPtr bits; + Rect bounds; + + BitMap BWBits; + GrafPort BWPort; + + Handle OrigBits; + +} ShockBitmap; + +void NewShockBitmap(ShockBitmap *theMap, short width, short height) { + + theMap->bits = 0L; + SetRect(&theMap->bounds, 0, 0, width, height); + + theMap->BWBits.bounds = theMap->bounds; + theMap->BWBits.rowBytes = ((width+15) >> 4)<<1; // round to even + theMap->BWBits.baseAddr = NewPtr(((long) height * (long) theMap->BWBits.rowBytes)); + + theMap->BWBits.baseAddr = StripAddress(theMap->BWBits.baseAddr); + + OpenPort(&theMap->BWPort); + SetPort(&theMap->BWPort); + SetPortBits(&theMap->BWBits); + + SetRectRgn(theMap->BWPort.visRgn, theMap->bounds.left, theMap->bounds.top, theMap->bounds.right, theMap->bounds.bottom); + SetRectRgn(theMap->BWPort.clipRgn, theMap->bounds.left, theMap->bounds.top, theMap->bounds.right, theMap->bounds.bottom); + EraseRect(&theMap->bounds); + + theMap->Address = theMap->BWBits.baseAddr; + theMap->RowBytes = (long) theMap->BWBits.rowBytes; + theMap->bits = (GrafPtr) &theMap->BWPort; +} + +ShockBitmap gMainOffScreen; + +// bezier code is from http://preserve.mactech.com/articles/mactech/Vol.05/05.01/BezierCurve/index.html +// as it is not built in to quickdraw like other "modern" graphics environments +/* + The greater the number of curve segments, the smoother the curve, +and the longer it takes to generate and draw. The number below was pulled +out of a hat, and seems to work o.k. + */ +#define SEGMENTS 16 + +static Fixed weight1[SEGMENTS + 1]; +static Fixed weight2[SEGMENTS + 1]; + +#define w1(s) weight1[s] +#define w2(s) weight2[s] +#define w3(s) weight2[SEGMENTS - s] +#define w4(s) weight1[SEGMENTS - s] + +/* + * SetupBezier -- one-time setup code. + * Compute the weights for the Bezier function. + * For the those concerned with space, the tables can be precomputed. +Setup is done here for purposes of illustration. + */ +void setupBezier() { + + Fixed t, zero, one; + int s; + + zero = FixRatio(0, 1); + one = FixRatio(1, 1); + weight1[0] = one; + weight2[0] = zero; + + for (s = 1; s < SEGMENTS; ++s) { + + t = FixRatio(s, SEGMENTS); + weight1[s] = FixMul(one - t, FixMul(one - t, one - t)); + weight2[s] = 3 * FixMul(t, FixMul(t - one, t - one)); + } + + weight1[SEGMENTS] = zero; + weight2[SEGMENTS] = zero; +} + +/* + * computeSegments -- compute segments for the Bezier curve + * Compute the segments along the curve. + * The curve touches the endpoints, so don’t bother to compute them. + */ +static void computeSegments(p1, p2, p3, p4, segment) Point p1, p2, p3, p4; Point segment[]; { + + int s; + + segment[0] = p1; + + for (s = 1; s < SEGMENTS; ++s) { + + segment[s].v = FixRound(w1(s) * p1.v + w2(s) * p2.v + w3(s) * p3.v + w4(s) * p4.v); + segment[s].h = FixRound(w1(s) * p1.h + w2(s) * p2.h + w3(s) * p3.h + w4(s) * p4.h); + } + + segment[SEGMENTS] = p4; +} + +/* + * BezierCurve -- Draw a Bezier Curve + * Draw a curve with the given endpoints (p1, p4), and the given + * control points (p2, p3). + * Note that we make no assumptions about pen or pen mode. + */ +void BezierCurve(p1, p2, p3, p4) Point p1, p2, p3, p4; { + + int s; + Point segment[SEGMENTS + 1]; + + computeSegments(p1, p2, p3, p4, segment); + MoveTo(segment[0].h, segment[0].v); + + for (s = 1 ; s <= SEGMENTS ; ++s) { + + if (segment[s].h != segment[s - 1].h || segment[s].v != segment[s - 1].v) { + + LineTo(segment[s].h, segment[s].v); + } + } +} + +// ex usage: +// Point control[4] = {{144,72}, {72,144}, {216,144}, {144,216}}; +// BezierCurve(c[0], c[1], c[2], c[3]); + +static struct nk_quickdraw { + unsigned int width; + unsigned int height; + struct nk_context nuklear_context; + struct nk_buffer cmds; +} quickdraw; + +// TODO: maybe V2 - skipping images for first pass +NK_API struct nk_image* nk_quickdraw_create_image(const char* file_name) { + + // TODO: just read the file to a char, we can draw it using quickdraw + // b&w bitmaps are pretty easy to draw... + // for us to do this, we need to figure out the format, then figure out if we can make it in to a quickdraw rect + // and set the buffer to the image handle pointer in the image struct + // i assume this gets consumed elsewhere in the code, thinking NK_COMMAND_IMAGE + char* bitmap = ""; //al_load_bitmap(file_name); // TODO: https://www.allegro.cc/manual/5/al_load_bitmap, loads file to in-memory buffer understood by allegro + + if (bitmap == NULL) { + + fprintf(stdout, "Unable to load image file: %s\n", file_name); + return NULL; + } + + struct nk_image *image = (struct nk_image*)calloc(1, sizeof(struct nk_image)); + image->handle.ptr = bitmap; + image->w = 0; // al_get_bitmap_width(bitmap); // TODO: this can be retrieved from a bmp file + image->h = 0; // al_get_bitmap_height(bitmap); // TODO: this can be retrieved from a bmp file + + return image; +} + +// TODO: maybe V2 - skipping images for first pass +NK_API void nk_quickdraw_del_image(struct nk_image* image) { + + if (!image) { + + return; + } + + // al_destroy_bitmap(image->handle.ptr); // TODO: https://www.allegro.cc/manual/5/al_destroy_bitmap + //this is just de-allocating the memory from a loaded bitmap + + free(image); +} + +int widthFor12ptFont[128] = { + 0, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 8, + 10, + 10, + 10, + 0, + 10, + 10, + 10, + 11, + 11, + 9, + 11, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 4, + 6, + 7, + 10, + 7, + 11, + 10, + 3, + 5, + 5, + 7, + 7, + 4, + 7, + 4, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 4, + 4, + 6, + 8, + 6, + 8, + 11, + 8, + 8, + 8, + 8, + 7, + 7, + 8, + 8, + 6, + 7, + 9, + 7, + 12, + 9, + 8, + 8, + 8, + 8, + 7, + 6, + 8, + 8, + 12, + 8, + 8, + 8, + 5, + 7, + 5, + 8, + 8, + 6, + 8, + 8, + 7, + 8, + 8, + 6, + 8, + 8, + 4, + 6, + 8, + 4, + 12, + 8, + 8, + 8, + 8, + 6, + 7, + 6, + 8, + 8, + 12, + 8, + 8, + 8, + 5, + 5, + 5, + 8, + 8 +}; + +// note: if this produces a greater value than the actual length of the text, +// the cursor will walk off to the right +// too small, it will precede the end of the text +// TODO: fully convert +// TODO: assuming system font for v1, support other fonts in v2 +// doing this in a "fast" way by using a precomputed table for a 12pt font +static int nk_quickdraw_font_get_text_width(nk_handle handle, int height, const char *text, int len) { + + // writeSerialPortDebug(boutRefNum, "nk_quickdraw_font_get_text_width"); + + if (!text || len == 0) { + + return 0; + } + + int width = 0; + + for (int i = 0; i < len; i++) { + + width += widthFor12ptFont[(int)text[i]]; + } + + return width; +} + +static int _get_text_width(const char *text, int len) { + + // writeSerialPortDebug(boutRefNum, "nk_quickdraw_font_get_text_width"); + + if (!text || len == 0) { + + return 0; + } + + int width = 0; + + for (int i = 0; i < len; i++) { + + width += widthFor12ptFont[(int)text[i]]; + } + + return width; +} + + + +static int nk_color_to_quickdraw_bw_color(struct nk_color color) { + + // TODO: since we are operating under a b&w display - we need to convert these colors to black and white + // look up a simple algorithm for taking RGBA values and making the call on black or white and try it out here + // as a future upgrade, we could support color quickdraw + // using an algorithm from https://stackoverflow.com/questions/3942878/how-to-decide-font-color-in-white-or-black-depending-on-background-color + // if (red*0.299 + green*0.587 + blue*0.114) > 186 use #000000 else use #ffffff + // return al_map_rgba((unsigned char)color.r, (unsigned char)color.g, (unsigned char)color.b, (unsigned char)color.a); + + float magicColorNumber = color.r * 0.299 + color.g * 0.587 + color.b * 0.114; + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + char stringMagicColorNumber[255]; + sprintf(stringMagicColorNumber, "stringMagicColorNumber: %f", magicColorNumber); + writeSerialPortDebug(boutRefNum, stringMagicColorNumber); + #endif + + if (magicColorNumber > 37) { + + return blackColor; + } + + return whiteColor; +} + +// i split this in to a 2nd routine because we can use the various shades of gray when filling rectangles and whatnot +static Pattern nk_color_to_quickdraw_color(struct nk_color color) { + + // as a future upgrade, we could support color quickdraw + // using an algorithm from https://stackoverflow.com/questions/3942878/how-to-decide-font-color-in-white-or-black-depending-on-background-color + // if (red*0.299 + green*0.587 + blue*0.114) > 186 use #000000 else use #ffffff + uint8_t red; + uint8_t blue; + uint8_t green; + + + float magicColorNumber = color.r * 0.299 + color.g * 0.587 + color.b * 0.114; + + if (magicColorNumber > 150) { + + return qd.black; + } else if (magicColorNumber > 100) { + + return qd.dkGray; + } else if (magicColorNumber > 75) { + + return qd.gray; + } else if (magicColorNumber > 49) { + + return qd.ltGray; + } + + return qd.white; +} + +/* Flags are identical to al_load_font() flags argument */ +NK_API NkQuickDrawFont* nk_quickdraw_font_create_from_file() { + + NkQuickDrawFont *font = (NkQuickDrawFont*)calloc(1, sizeof(NkQuickDrawFont)); + + font->font = calloc(1, 1024); + if (font->font == NULL) { + fprintf(stdout, "Unable to load font file\n"); + return NULL; + } + font->nk.userdata = nk_handle_ptr(font); + font->nk.height = (int)12; + font->nk.width = nk_quickdraw_font_get_text_width; + return font; +} + +NK_API void nk_quickdraw_render(WindowPtr window, struct nk_context *ctx) { + + long start; + long end; + long total; + start = TickCount(); + + long renderTime1; + long renderTime2; + long renderTime3; + + + void *cmds = nk_buffer_memory(&ctx->memory); + + // do not render if the buffer did not change from the previous rendering run + if (!memcmp(cmds, last, ctx->memory.allocated)) { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_NOP"); + #endif + + return; + } + + memcpy(last, cmds, ctx->memory.allocated); + + const struct nk_command *cmd = 0; + + if (!lastEventWasKey) { + OpenPort(&gMainOffScreen.BWPort); + SetPort(&gMainOffScreen.BWPort); + SetPortBits(&gMainOffScreen.BWBits); + // EraseRect(&gMainOffScreen.bounds); + } else { + + SetPort(window); + } + + end = TickCount(); + total = end - start; + renderTime1 = total;// / 60.0; + start = TickCount(); + + nk_foreach(cmd, ctx) { + + int color; + + if (lastEventWasKey && cmd->type == NK_COMMAND_TEXT) { + + + //writeSerialPortDebug(boutRefNum, "FAST INPUT"); + + + const struct nk_command_text *t = (const struct nk_command_text*)cmd; + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_TEXT"); + char log[255]; + sprintf(log, "%f: %c, %d", (int)t->height, &t->string, (int)t->length); + writeSerialPortDebug(boutRefNum, log); + #endif + + MoveTo((int)t->x + _get_text_width(&t->string, (int)t->length - 1), (int)t->y + (int)t->height); + + // DrawText((const char*)t->string, 0, (int)t->length); + + DrawChar(t->string[t->length - 1]); + + } else if (!lastEventWasKey) { + + + // writeSerialPortDebug(boutRefNum, "SLOW INPUT"); + switch (cmd->type) { + + case NK_COMMAND_NOP: + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_NOP"); + #endif + + + break; + case NK_COMMAND_SCISSOR: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_SCISSOR"); + #endif + + const struct nk_command_scissor *s =(const struct nk_command_scissor*)cmd; + // // al_set_clipping_rectangle((int)s->x, (int)s->y, (int)s->w, (int)s->h); // TODO: https://www.allegro.cc/manual/5/al_set_clipping_rectangle + // // this essentially just sets the region of the screen that we are going to write to + // // initially, i thought that this would be SetClip, but now believe this should be ClipRect, see: + // // Inside Macintosh: Imaging with Quickdraw pages 2-48 and 2-49 for more info + // // additionally, see page 2-61 for a data structure example for the rectangle OR + // // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-60.html + // // for usage example + // Rect quickDrawRectangle; + // quickDrawRectangle.top = (int)s->y; + // quickDrawRectangle.left = (int)s->x; + // quickDrawRectangle.bottom = (int)s->y + (int)s->h; + // quickDrawRectangle.right = (int)s->x + (int)s->w; + + // ClipRect(&quickDrawRectangle); + } + + break; + case NK_COMMAND_LINE: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_LINE"); + #endif + + const struct nk_command_line *l = (const struct nk_command_line *)cmd; + + color = nk_color_to_quickdraw_bw_color(l->color); + // great reference: http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-60.html + // al_draw_line((float)l->begin.x, (float)l->begin.y, (float)l->end.x, (float)l->end.y, color, (float)l->line_thickness); // TODO: look up and convert al_draw_line + ForeColor(color); + PenSize((int)l->line_thickness, (int)l->line_thickness); + MoveTo((int)l->begin.x, (int)l->begin.y); + LineTo((int)l->end.x, (int)l->end.y); + } + + break; + case NK_COMMAND_RECT: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_RECT"); + #endif + + // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-102.html#MARKER-9-372 + // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-103.html#HEADING103-0 + const struct nk_command_rect *r = (const struct nk_command_rect *)cmd; + + color = nk_color_to_quickdraw_bw_color(r->color); + + ForeColor(color); + PenSize((int)r->line_thickness, (int)r->line_thickness); + + Rect quickDrawRectangle; + quickDrawRectangle.top = (int)r->y; + quickDrawRectangle.left = (int)r->x; + quickDrawRectangle.bottom = (int)r->y + (int)r->h; + quickDrawRectangle.right = (int)r->x + (int)r->w; + + FrameRoundRect(&quickDrawRectangle, (float)r->rounding, (float)r->rounding); + } + + break; + case NK_COMMAND_RECT_FILLED: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_RECT_FILLED"); + #endif + + const struct nk_command_rect_filled *r = (const struct nk_command_rect_filled *)cmd; + + color = nk_color_to_quickdraw_bw_color(r->color); + + ForeColor(color); + Pattern colorPattern = nk_color_to_quickdraw_color(r->color); + + // BackPat(&colorPattern); // inside macintosh: imaging with quickdraw 3-48 + PenSize(1.0, 1.0); // no member line thickness on this struct so assume we want a thin line + // might actually need to build this with SetRect, search inside macintosh: imaging with quickdraw + Rect quickDrawRectangle; + quickDrawRectangle.top = (int)r->y; + quickDrawRectangle.left = (int)r->x; + quickDrawRectangle.bottom = (int)r->y + (int)r->h; + quickDrawRectangle.right = (int)r->x + (int)r->w; + + FillRoundRect(&quickDrawRectangle, (float)r->rounding, (float)r->rounding, &colorPattern); + FrameRoundRect(&quickDrawRectangle, (float)r->rounding, (float)r->rounding); // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-105.html#HEADING105-0 + } + + break; + case NK_COMMAND_CIRCLE: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_CIRCLE"); + #endif + + const struct nk_command_circle *c = (const struct nk_command_circle *)cmd; + + color = nk_color_to_quickdraw_bw_color(c->color); + + ForeColor(color); + Rect quickDrawRectangle; + quickDrawRectangle.top = (int)c->y; + quickDrawRectangle.left = (int)c->x; + quickDrawRectangle.bottom = (int)c->y + (int)c->h; + quickDrawRectangle.right = (int)c->x + (int)c->w; + + FrameOval(&quickDrawRectangle); // An oval is a circular or elliptical shape defined by the bounding rectangle that encloses it. inside macintosh: imaging with quickdraw 3-25 + } + + break; + case NK_COMMAND_CIRCLE_FILLED: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_CIRCLE_FILLED"); + #endif + + const struct nk_command_circle_filled *c = (const struct nk_command_circle_filled *)cmd; + + color = nk_color_to_quickdraw_bw_color(c->color); + + ForeColor(color); + Pattern colorPattern = nk_color_to_quickdraw_color(c->color); + // BackPat(&colorPattern); // inside macintosh: imaging with quickdraw 3-48 + PenSize(1.0, 1.0); + Rect quickDrawRectangle; + quickDrawRectangle.top = (int)c->y; + quickDrawRectangle.left = (int)c->x; + quickDrawRectangle.bottom = (int)c->y + (int)c->h; + quickDrawRectangle.right = (int)c->x + (int)c->w; + + FillOval(&quickDrawRectangle, &colorPattern); + FrameOval(&quickDrawRectangle);// An oval is a circular or elliptical shape defined by the bounding rectangle that encloses it. inside macintosh: imaging with quickdraw 3-25 + // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-111.html#HEADING111-0 + } + + break; + case NK_COMMAND_TRIANGLE: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_TRIANGLE"); + #endif + + const struct nk_command_triangle *t = (const struct nk_command_triangle*)cmd; + color = nk_color_to_quickdraw_bw_color(t->color); + + ForeColor(color); + PenSize((int)t->line_thickness, (int)t->line_thickness); + + MoveTo((int)t->a.x, (int)t->a.y); + LineTo((int)t->b.x, (int)t->b.y); + LineTo((int)t->c.x, (int)t->c.y); + LineTo((int)t->a.x, (int)t->a.y); + } + + break; + case NK_COMMAND_TRIANGLE_FILLED: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_TRIANGLE_FILLED"); + #endif + + const struct nk_command_triangle_filled *t = (const struct nk_command_triangle_filled *)cmd; + Pattern colorPattern = nk_color_to_quickdraw_color(t->color); + color = nk_color_to_quickdraw_bw_color(t->color); + PenSize(1.0, 1.0); + // BackPat(&colorPattern); // inside macintosh: imaging with quickdraw 3-48 + ForeColor(color); + + PolyHandle trianglePolygon = OpenPoly(); + MoveTo((int)t->a.x, (int)t->a.y); + LineTo((int)t->b.x, (int)t->b.y); + LineTo((int)t->c.x, (int)t->c.y); + LineTo((int)t->a.x, (int)t->a.y); + ClosePoly(); + + FillPoly(trianglePolygon, &colorPattern); + KillPoly(trianglePolygon); + } + + break; + case NK_COMMAND_POLYGON: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_POLYGON"); + #endif + + const struct nk_command_polygon *p = (const struct nk_command_polygon*)cmd; + + color = nk_color_to_quickdraw_bw_color(p->color); + ForeColor(color); + int i; + + for (i = 0; i < p->point_count; i++) { + + if (i == 0) { + + MoveTo(p->points[i].x, p->points[i].y); + } + + LineTo(p->points[i].x, p->points[i].y); + + if (i == p->point_count - 1) { + + + LineTo(p->points[0].x, p->points[0].y); + } + } + } + + break; + case NK_COMMAND_POLYGON_FILLED: { + + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_POLYGON_FILLED"); + #endif + + const struct nk_command_polygon *p = (const struct nk_command_polygon*)cmd; + + Pattern colorPattern = nk_color_to_quickdraw_color(p->color); + color = nk_color_to_quickdraw_bw_color(p->color); + // BackPat(&colorPattern); // inside macintosh: imaging with quickdraw 3-48 -- but might actually need PenPat -- look into this + ForeColor(color); + int i; + + PolyHandle trianglePolygon = OpenPoly(); + for (i = 0; i < p->point_count; i++) { + + if (i == 0) { + + MoveTo(p->points[i].x, p->points[i].y); + } + + LineTo(p->points[i].x, p->points[i].y); + + if (i == p->point_count - 1) { + + + LineTo(p->points[0].x, p->points[0].y); + } + } + + ClosePoly(); + + FillPoly(trianglePolygon, &colorPattern); + KillPoly(trianglePolygon); + } + + break; + case NK_COMMAND_POLYLINE: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_POLYLINE"); + #endif + + // this is similar to polygons except the polygon does not get closed to the 0th point + // check out the slight difference in the for loop + const struct nk_command_polygon *p = (const struct nk_command_polygon*)cmd; + + color = nk_color_to_quickdraw_bw_color(p->color); + ForeColor(color); + int i; + + for (i = 0; i < p->point_count; i++) { + + if (i == 0) { + + MoveTo(p->points[i].x, p->points[i].y); + } + + LineTo(p->points[i].x, p->points[i].y); + } + } + + break; + case NK_COMMAND_TEXT: { + + const struct nk_command_text *t = (const struct nk_command_text*)cmd; + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_TEXT"); + char log[255]; + sprintf(log, "%f: %c, %d", (int)t->height, &t->string, (int)t->length); + writeSerialPortDebug(boutRefNum, log); + #endif + + color = nk_color_to_quickdraw_bw_color(t->foreground); + ForeColor(color); + MoveTo((int)t->x, (int)t->y + (int)t->height); + + DrawText((const char*)t->string, 0, (int)t->length); + + // DrawChar(t->string[t->length - 1]); + } + + break; + case NK_COMMAND_CURVE: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_CURVE"); + #endif + + const struct nk_command_curve *q = (const struct nk_command_curve *)cmd; + color = nk_color_to_quickdraw_bw_color(q->color); + ForeColor(color); + Point p1 = { (int)q->begin.x, (int)q->begin.y}; + Point p2 = { (int)q->ctrl[0].x, (int)q->ctrl[0].y}; + Point p3 = { (int)q->ctrl[1].x, (int)q->ctrl[1].y}; + Point p4 = { (int)q->end.x, (int)q->end.y}; + + BezierCurve(p1, p2, p3, p4); + } + + break; + case NK_COMMAND_ARC: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_ARC"); + #endif + + const struct nk_command_arc *a = (const struct nk_command_arc *)cmd; + + color = nk_color_to_quickdraw_bw_color(a->color); + ForeColor(color); + Rect arcBoundingBoxRectangle; + // this is kind of silly because the cx is at the center of the arc and we need to create a rectangle around it + // http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/QuickDraw/QuickDraw-60.html#MARKER-2-116 + int x1 = (int)a->cx - (int)a->r; + int y1 = (int)a->cy - (int)a->r; + int x2 = (int)a->cx + (int)a->r; + int y2 = (int)a->cy + (int)a->r; + SetRect(&arcBoundingBoxRectangle, x1, y1, x2, y2); + // SetRect(secondRect,90,20,140,70); + + FrameArc(&arcBoundingBoxRectangle, a->a[0], a->a[1]); + } + + break; + case NK_COMMAND_IMAGE: { + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_IMAGE"); + #endif + + const struct nk_command_image *i = (const struct nk_command_image *)cmd; + // al_draw_bitmap_region(i->img.handle.ptr, 0, 0, i->w, i->h, i->x, i->y, 0); // TODO: look up and convert al_draw_bitmap_region + // TODO: consider implementing a bitmap drawing routine. we could iterate pixel by pixel and draw + // here is some super naive code that could work, used for another project that i was working on with a custom format but would be + // easy to modify for standard bitmap files (just need to know how many bytes represent each pixel and iterate from there): + // + // for (int i = 0; i < strlen(string); i++) { + // printf("\nchar: %c", string[i]); + // char pixel[1]; + // memcpy(pixel, &string[i], 1); + // if (strcmp(pixel, "0") == 0) { // white pixel + // MoveTo(++x, y); + // } else if (strcmp(pixel, "1") == 0) { // black pixel + // // advance the pen and draw a 1px x 1px "line" + // MoveTo(++x, y); + // LineTo(x, y); + // } else if (strcmp(pixel, "|") == 0) { // next line + // x = 1; + // MoveTo(x, ++y); + // } else if (strcmp(pixel, "/") == 0) { // end + // } + // } + } + + break; + + // why are these cases not implemented? + case NK_COMMAND_RECT_MULTI_COLOR: + case NK_COMMAND_ARC_FILLED: + default: + + #ifdef NK_QUICKDRAW_GRAPHICS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "NK_COMMAND_RECT_MULTI_COLOR/NK_COMMAND_ARC_FILLED/default"); + #endif + break; + } + } + } + + + end = TickCount(); + total = end - start; + renderTime2 = total;// / 60.0; + start = TickCount(); + + + + if (!lastEventWasKey) { + SetPort(window); + + + // our offscreen bitmap is the same size as our port rectangle, so we + // get away with using the portRect sizing for source and destination + CopyBits(&gMainOffScreen.bits->portBits, &window->portBits, &window->portRect, &window->portRect, srcCopy, 0L); + } + + end = TickCount(); + total = end - start; + renderTime3 = total;// / 60.0; + start = TickCount(); + + + // char logx[255]; + // sprintf(logx, "nk_quickdraw_render() renderTime1 (pre-render) %ld, renderTime2 (render loop) %ld, renderTime3 (post-render) %ld ticks to execute\n", renderTime1, renderTime2, renderTime3); + // writeSerialPortDebug(boutRefNum, logx); + + lastEventWasKey = 0; +} + +NK_API int nk_quickdraw_handle_event(EventRecord *event, struct nk_context *nuklear_context) { + // see: inside macintosh: toolbox essentials 2-4 + // and inside macintosh toolbox essentials 2-79 + + WindowPtr window; + FindWindow(event->where, &window); + // char logb[255]; + // sprintf(logb, "nk_quickdraw_handle_event event %d", event->what); + // writeSerialPortDebug(boutRefNum, logb); + + switch (event->what) { + case updateEvt: { + return 1; + } + break; + case osEvt: { + // the quicktime osEvts are supposed to cover mouse movement events + // notice that we are actually calling nk_input_motion in the EventLoop for the program + // instead, as handling this event directly does not appear to work for whatever reason + // TODO: research this + writeSerialPortDebug(boutRefNum, "osEvt"); + + switch (event->message) { + + case mouseMovedMessage: { + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "mouseMovedMessage"); + #endif + + + // event->where should have coordinates??? or is it just a pointer to what the mouse is over? + // TODO need to figure this out + nk_input_motion(nuklear_context, event->where.h, event->where.v); // TODO figure out mouse coordinates - not sure if this is right + + break; + } + + return 1; + } + } + break; + + case mouseUp: + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "mouseUp!!!"); + #endif + case mouseDown: { + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "mouseUp/Down"); + #endif + + short part = FindWindow(event->where, &window); + + switch (part) { + case inContent: { + // event->where should have coordinates??? or is it just a pointer to what the mouse is over? + // TODO need to figure this out + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "mouseUp/Down IN DEFAULT ZONE!!!!"); + #endif + + // this converts the offset of the window to the actual location of the mouse within the window + Point tempPoint; + SetPt(&tempPoint, event->where.h, event->where.v); + GlobalToLocal(&tempPoint); + + if (!event->where.h) { + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "no event location for mouse!!!!"); + #endif + return 1; + } + int x = tempPoint.h; + int y = tempPoint.v; + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + char logx[255]; + sprintf(logx, "mouse location at time of click h: %d, v: %d", x, y); + writeSerialPortDebug(boutRefNum, logx); + #endif + + // nk_input_motion(nuklear_context, x, y); // you can enable this if you don't want to use motion tracking + // in the Mac event loop handler as in the nuklear quickdraw sample, and this will allow mouse clicks to + // work properly, but will not allow hover states to work + nk_input_button(nuklear_context, NK_BUTTON_LEFT, x, y, event->what == mouseDown); + } + break; + return 1; + } + + break; + case keyDown: + case autoKey: {/* check for menukey equivalents */ + + char charKey = event->message & charCodeMask; + int key = (int)charKey; + + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "keyDown/autoKey"); + + char logy[255]; + sprintf(logy, "key pressed: key: '%c', 02x: '%02X', return: '%02X', %d == %d ??", key, key, returnKey, (int)(key), (int)(returnKey)); + writeSerialPortDebug(boutRefNum, logy); + #endif + + const Boolean isKeyDown = event->what == keyDown; + + if (event->modifiers & cmdKey) {/* Command key down */ + + if (isKeyDown) { + + // AdjustMenus(); /* enable/disable/check menu items properly */ + // DoMenuCommand(MenuKey(key)); + } + + if (key == 'c') { + + nk_input_key(nuklear_context, NK_KEY_COPY, 1); + } else if (key == 'v') { + + nk_input_key(nuklear_context, NK_KEY_PASTE, 1); + } else if (key == 'x') { + + nk_input_key(nuklear_context, NK_KEY_CUT, 1); + } else if (key == 'z') { + + nk_input_key(nuklear_context, NK_KEY_TEXT_UNDO, 1); + } else if (key == 'r') { + + nk_input_key(nuklear_context, NK_KEY_TEXT_REDO, 1); + } + } else if (key == eitherShiftKey) { + + nk_input_key(nuklear_context, NK_KEY_SHIFT, isKeyDown); + } else if (key == deleteKey) { + + nk_input_key(nuklear_context, NK_KEY_DEL, isKeyDown); + } else if (key == enterKey) { + + nk_input_key(nuklear_context, NK_KEY_ENTER, isKeyDown); + } else if (key == returnKey) { + + nk_input_key(nuklear_context, NK_KEY_ENTER, isKeyDown); + } else if (key == tabKey) { + + nk_input_key(nuklear_context, NK_KEY_TAB, isKeyDown); + } else if (key == leftArrowKey) { + + nk_input_key(nuklear_context, NK_KEY_LEFT, isKeyDown); + } else if (key == rightArrowKey) { + + nk_input_key(nuklear_context, NK_KEY_RIGHT, isKeyDown); + } else if (key == upArrowKey) { + + nk_input_key(nuklear_context, NK_KEY_UP, isKeyDown); + } else if (key == downArrowKey) { + + nk_input_key(nuklear_context, NK_KEY_DOWN, isKeyDown); + } else if (key == backspaceKey) { + + nk_input_key(nuklear_context, NK_KEY_BACKSPACE, isKeyDown); + } else if (key == escapeKey) { + + // nk_input_key(nuklear_context, NK_KEY_TEXT_RESET_MODE, isKeyDown); + } else if (key == pageUpKey) { + + nk_input_key(nuklear_context, NK_KEY_SCROLL_UP, isKeyDown); + } else if (key == pageDownKey) { + + nk_input_key(nuklear_context, NK_KEY_SCROLL_DOWN, isKeyDown); + } else if (key == homeKey) { + + // nk_input_key(nuklear_context, NK_KEY_TEXT_START, isKeyDown); + nk_input_key(nuklear_context, NK_KEY_SCROLL_START, isKeyDown); + } else if (key == endKey) { + + // nk_input_key(nuklear_context, NK_KEY_TEXT_END, isKeyDown); + nk_input_key(nuklear_context, NK_KEY_SCROLL_END, isKeyDown); + } else { + + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "default keydown/autokey event"); + #endif + + nk_input_unicode(nuklear_context, charKey); + } + + lastEventWasKey = 1; + + return 1; + } + break; + default: { + #ifdef NK_QUICKDRAW_EVENTS_DEBUGGING + + writeSerialPortDebug(boutRefNum, "default unhandled event"); + #endif + + return 1; + } + break; + } + } +} + +// i think these functions are close to correct, but throw an error around invalid storage class +NK_INTERN void nk_quickdraw_clipboard_paste(nk_handle usr, struct nk_text_edit *edit) { + + Handle hDest = NewHandle(0); // { automatically resizes it} + HLock(hDest); + // {put data into memory referenced thru hDest handle} + int sizeOfSurfData = GetScrap(hDest, 'TEXT', 0); + HUnlock(hDest); + nk_textedit_paste(edit, (char *)hDest, sizeOfSurfData); + DisposeHandle(hDest); +} + +NK_INTERN void nk_quickdraw_clipboard_copy(nk_handle usr, const char *text, int len) { + + // in Macintosh Toolbox the clipboard is referred to as "scrap manager" + PutScrap(len, 'TEXT', text); +} + +// it us up to our "main" function to call this code +NK_API struct nk_context* nk_quickdraw_init(unsigned int width, unsigned int height) { + + // needed to calculate bezier info, see mactech article. + setupBezier(); + + NewShockBitmap(&gMainOffScreen, width, height); + NkQuickDrawFont *quickdrawfont = nk_quickdraw_font_create_from_file(); + struct nk_user_font *font = &quickdrawfont->nk; + + last = calloc(1, 64 * 1024); + buf = calloc(1, 64 * 1024); + nk_init_fixed(&quickdraw.nuklear_context, buf, 64 * 1024, font); + + // nk_init_default(&quickdraw.nuklear_context, font); + nk_style_push_font(&quickdraw.nuklear_context, font); + + // this is pascal code but i think we would need to do something like this if we want this function + // to be responsible for setting the window size + // Region locUpdateRgn = NewRgn(); + // SetRect(limitRect, kMinDocSize, kMinDocSize, kMaxDocSize, kMaxDocSize); + // // {call Window Manager to let user drag size box} + // growSize = GrowWindow(thisWindow, event.where, limitRect); + // SizeWindow(thisWindow, LoWord(growSize), HiWord(growSize), TRUE); + // SectRect(oldViewRect, myData^^.editRec^^.viewRect, oldViewRect); + // // {validate the intersection (don't update)} + // ValidRect(oldViewRect); + // // {invalidate any prior update region} + // InvalRgn(locUpdateRgn); + // DisposeRgn(locUpdateRgn); + + quickdraw.nuklear_context.clip.copy = nk_quickdraw_clipboard_copy; + quickdraw.nuklear_context.clip.paste = nk_quickdraw_clipboard_paste; + quickdraw.nuklear_context.clip.userdata = nk_handle_ptr(0); + + // fix styles to be more "mac-like" + struct nk_style *style; + struct nk_style_toggle *toggle; + struct nk_style_button *button; + style = &quickdraw.nuklear_context.style; + + /* checkbox toggle */ + toggle = &style->checkbox; + nk_zero_struct(*toggle); + toggle->normal = nk_style_item_color(nk_rgba(45, 45, 45, 255)); + toggle->hover = nk_style_item_color(nk_rgba(80, 80, 80, 255)); // this is the "background" hover state regardless of checked status - we want light gray + toggle->active = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // i can't tell what this does yet + toggle->cursor_normal = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // this is the "checked" box itself - we want "black" + toggle->cursor_hover = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // this is the hover state of a "checked" box - anything lighter than black is ok + toggle->userdata = nk_handle_ptr(0); + toggle->text_background = nk_rgba(255, 255, 255, 255); + toggle->text_normal = nk_rgba(70, 70, 70, 255); + toggle->text_hover = nk_rgba(70, 70, 70, 255); + toggle->text_active = nk_rgba(70, 70, 70, 255); + toggle->padding = nk_vec2(3.0f, 3.0f); + toggle->touch_padding = nk_vec2(0,0); + toggle->border_color = nk_rgba(0,0,0,0); + toggle->border = 0.0f; + toggle->spacing = 5; + + /* option toggle */ + toggle = &style->option; + nk_zero_struct(*toggle); + toggle->normal = nk_style_item_color(nk_rgba(45, 45, 45, 255)); + toggle->hover = nk_style_item_color(nk_rgba(80, 80, 80, 255)); // this is the "background" hover state regardless of checked status - we want light gray + toggle->active = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // i can't tell what this does yet + toggle->cursor_normal = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // this is the "checked" box itself - we want "black" + toggle->cursor_hover = nk_style_item_color(nk_rgba(255, 255, 255, 255)); // this is the hover state of a "checked" box - anything lighter than black is ok + toggle->userdata = nk_handle_ptr(0); + toggle->text_background = nk_rgba(255, 255, 255, 255); + toggle->text_normal = nk_rgba(70, 70, 70, 255); + toggle->text_hover = nk_rgba(70, 70, 70, 255); + toggle->text_active = nk_rgba(70, 70, 70, 255); + toggle->padding = nk_vec2(3.0f, 3.0f); + toggle->touch_padding = nk_vec2(0,0); + toggle->border_color = nk_rgba(0,0,0,0); + toggle->border = 0.0f; + toggle->spacing = 5; + + // button + button = &style->button; + nk_zero_struct(*button); + button->normal = nk_style_item_color(nk_rgba(0, 0, 0, 255)); + button->hover = nk_style_item_color(nk_rgba(80, 80, 80, 255)); + button->active = nk_style_item_color(nk_rgba(150, 150, 150, 255)); + button->border_color = nk_rgba(255, 255, 255, 255); + button->text_background = nk_rgba(255, 255, 255, 255); + button->text_normal = nk_rgba(70, 70, 70, 255); + button->text_hover = nk_rgba(70, 70, 70, 255); + button->text_active = nk_rgba(0, 0, 0, 255); + button->padding = nk_vec2(2.0f,2.0f); + button->image_padding = nk_vec2(0.0f,0.0f); + button->touch_padding = nk_vec2(0.0f, 0.0f); + button->userdata = nk_handle_ptr(0); + button->text_alignment = NK_TEXT_CENTERED; + button->border = 1.0f; + button->rounding = 4.0f; + button->draw_begin = 0; + button->draw_end = 0; + + ForeColor(blackColor); + + TextSize(13); + + + return &quickdraw.nuklear_context; +} + +NK_API void nk_quickdraw_shutdown(void) { + + nk_free(&quickdraw.nuklear_context); + memset(&quickdraw, 0, sizeof(quickdraw)); +} + + + diff --git a/output_js b/output_js new file mode 100644 index 0000000..1694f1e --- /dev/null +++ b/output_js @@ -0,0 +1,34 @@ +index.js@@@ + + +class PuppeteerTest { + + async getBodyAtURL (url) { + + let response + + try { + + } catch (error) { + + console.error(error) + } + + return response + } +} +module.exports = PuppeteerTest&&& +package.json@@@ +{ + "name": "test", + "version": "1.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "" + }, + "author": "", + "license": "ISC", + "dependencies": { + } +} diff --git a/output_js.h b/output_js.h new file mode 100644 index 0000000..71c3a49 --- /dev/null +++ b/output_js.h @@ -0,0 +1,38 @@ +unsigned char OUTPUT_JS[] = { + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x6a, 0x73, 0x40, 0x40, 0x40, 0x0a, + 0x0a, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x75, 0x70, 0x70, + 0x65, 0x74, 0x65, 0x65, 0x72, 0x54, 0x65, 0x73, 0x74, 0x20, 0x7b, 0x0a, + 0x0a, 0x20, 0x20, 0x61, 0x73, 0x79, 0x6e, 0x63, 0x20, 0x67, 0x65, 0x74, + 0x42, 0x6f, 0x64, 0x79, 0x41, 0x74, 0x55, 0x52, 0x4c, 0x20, 0x28, 0x75, + 0x72, 0x6c, 0x29, 0x20, 0x7b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, + 0x65, 0x74, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x0a, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x74, 0x72, 0x79, 0x20, 0x7b, 0x0a, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x20, + 0x28, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x29, 0x20, 0x7b, 0x0a, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, + 0x2e, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x7d, 0x0a, 0x7d, 0x0a, 0x6d, + 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x73, 0x20, 0x3d, 0x20, 0x50, 0x75, 0x70, 0x70, 0x65, 0x74, 0x65, 0x65, + 0x72, 0x54, 0x65, 0x73, 0x74, 0x26, 0x26, 0x26, 0x0a, 0x70, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6a, 0x73, 0x6f, 0x6e, 0x40, 0x40, 0x40, + 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, + 0x20, 0x22, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x22, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x20, 0x22, 0x31, + 0x2e, 0x30, 0x2e, 0x30, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x22, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x20, + 0x22, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x22, 0x6d, 0x61, 0x69, 0x6e, 0x22, + 0x3a, 0x20, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x6a, 0x73, 0x22, + 0x2c, 0x0a, 0x20, 0x20, 0x22, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x73, + 0x22, 0x3a, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x22, 0x74, 0x65, + 0x73, 0x74, 0x22, 0x3a, 0x20, 0x22, 0x22, 0x0a, 0x20, 0x20, 0x7d, 0x2c, + 0x0a, 0x20, 0x20, 0x22, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x22, 0x3a, + 0x20, 0x22, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x22, 0x6c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x22, 0x3a, 0x20, 0x22, 0x49, 0x53, 0x43, 0x22, 0x2c, + 0x0a, 0x20, 0x20, 0x22, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, + 0x63, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x7d, + 0x0a, 0x7d, 0x0a +}; +unsigned int OUTPUT_JS_LEN = 411; diff --git a/overview.c b/overview.c new file mode 100644 index 0000000..ae1a0d8 --- /dev/null +++ b/overview.c @@ -0,0 +1,1299 @@ +// static int +// overview(struct nk_context *ctx) +// { + + + + +// /* window flags */ +// static int show_menu = nk_true; +// static int titlebar = nk_true; +// static int border = nk_true; +// static int resize = nk_true; +// static int movable = nk_true; +// static int no_scrollbar = nk_false; +// static int scale_left = nk_false; +// static nk_flags window_flags = 0; +// static int minimizable = nk_true; + +// /* popups */ +// static enum nk_style_header_align header_align = NK_HEADER_RIGHT; +// static int show_app_about = nk_false; + +// /* window flags */ +// window_flags = 0; +// ctx->style.window.header.align = header_align; +// if (border) window_flags |= NK_WINDOW_BORDER; +// if (resize) window_flags |= NK_WINDOW_SCALABLE; +// if (movable) window_flags |= NK_WINDOW_MOVABLE; +// if (no_scrollbar) window_flags |= NK_WINDOW_NO_SCROLLBAR; +// if (scale_left) window_flags |= NK_WINDOW_SCALE_LEFT; +// if (minimizable) window_flags |= NK_WINDOW_MINIMIZABLE; + +// if (nk_begin(ctx, "Overview", nk_rect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT), window_flags)) +// { +// if (show_menu) +// { +// /* menubar */ +// enum menu_states {MENU_DEFAULT, MENU_WINDOWS}; +// static nk_size mprog = 60; +// static int mslider = 10; +// static int mcheck = nk_true; +// nk_menubar_begin(ctx); + +// /* menu #1 */ +// nk_layout_row_begin(ctx, NK_STATIC, 25, 5); +// nk_layout_row_push(ctx, 45); +// if (nk_menu_begin_label(ctx, "MENU", NK_TEXT_LEFT, nk_vec2(120, 200))) +// { +// static size_t prog = 40; +// static int slider = 10; +// static int check = nk_true; +// nk_layout_row_dynamic(ctx, 25, 1); +// if (nk_menu_item_label(ctx, "Hide", NK_TEXT_LEFT)) +// show_menu = nk_false; +// if (nk_menu_item_label(ctx, "About", NK_TEXT_LEFT)) +// show_app_about = nk_true; +// nk_progress(ctx, &prog, 100, NK_MODIFIABLE); +// nk_slider_int(ctx, 0, &slider, 16, 1); +// nk_checkbox_label(ctx, "check", &check); +// nk_menu_end(ctx); +// } +// /* menu #2 */ +// nk_layout_row_push(ctx, 60); +// if (nk_menu_begin_label(ctx, "ADVANCED", NK_TEXT_LEFT, nk_vec2(200, 600))) +// { +// enum menu_state {MENU_NONE,MENU_FILE, MENU_EDIT,MENU_VIEW,MENU_CHART}; +// static enum menu_state menu_state = MENU_NONE; +// enum nk_collapse_states state; + +// state = (menu_state == MENU_FILE) ? NK_MAXIMIZED: NK_MINIMIZED; +// if (nk_tree_state_push(ctx, NK_TREE_TAB, "FILE", &state)) { +// menu_state = MENU_FILE; +// nk_menu_item_label(ctx, "New", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Open", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Save", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Close", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Exit", NK_TEXT_LEFT); +// nk_tree_pop(ctx); +// } else menu_state = (menu_state == MENU_FILE) ? MENU_NONE: menu_state; + +// state = (menu_state == MENU_EDIT) ? NK_MAXIMIZED: NK_MINIMIZED; +// if (nk_tree_state_push(ctx, NK_TREE_TAB, "EDIT", &state)) { +// menu_state = MENU_EDIT; +// nk_menu_item_label(ctx, "Copy", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Delete", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Cut", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Paste", NK_TEXT_LEFT); +// nk_tree_pop(ctx); +// } else menu_state = (menu_state == MENU_EDIT) ? MENU_NONE: menu_state; + +// state = (menu_state == MENU_VIEW) ? NK_MAXIMIZED: NK_MINIMIZED; +// if (nk_tree_state_push(ctx, NK_TREE_TAB, "VIEW", &state)) { +// menu_state = MENU_VIEW; +// nk_menu_item_label(ctx, "About", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Options", NK_TEXT_LEFT); +// nk_menu_item_label(ctx, "Customize", NK_TEXT_LEFT); +// nk_tree_pop(ctx); +// } else menu_state = (menu_state == MENU_VIEW) ? MENU_NONE: menu_state; + +// state = (menu_state == MENU_CHART) ? NK_MAXIMIZED: NK_MINIMIZED; +// if (nk_tree_state_push(ctx, NK_TREE_TAB, "CHART", &state)) { +// size_t i = 0; +// const int values[]={26,13,30,15,25,10,20,40,12,8,22,28}; +// menu_state = MENU_CHART; +// nk_layout_row_dynamic(ctx, 150, 1); +// nk_chart_begin(ctx, NK_CHART_COLUMN, NK_LEN(values), 0, 50); +// for (i = 0; i < NK_LEN(values); ++i) +// nk_chart_push(ctx, values[i]); +// nk_chart_end(ctx); +// nk_tree_pop(ctx); +// } else menu_state = (menu_state == MENU_CHART) ? MENU_NONE: menu_state; +// nk_menu_end(ctx); +// } +// /* menu widgets */ +// nk_layout_row_push(ctx, 70); +// nk_progress(ctx, &mprog, 100, NK_MODIFIABLE); +// nk_slider_int(ctx, 0, &mslider, 16, 1); +// nk_checkbox_label(ctx, "check", &mcheck); +// nk_menubar_end(ctx); +// } + +// if (show_app_about) +// { +// /* about popup */ +// static struct nk_rect s = {20, 100, 300, 190}; +// if (nk_popup_begin(ctx, NK_POPUP_STATIC, "About", NK_WINDOW_CLOSABLE, s)) +// { +// nk_layout_row_dynamic(ctx, 20, 1); +// nk_label(ctx, "Nuklear", NK_TEXT_LEFT); +// nk_label(ctx, "By Micha Mettke", NK_TEXT_LEFT); +// nk_label(ctx, "nuklear is licensed under the public domain License.", NK_TEXT_LEFT); +// nk_popup_end(ctx); +// } else show_app_about = nk_false; +// } + +// /* window flags */ +// if (nk_tree_push(ctx, NK_TREE_TAB, "Window", NK_MINIMIZED)) { +// nk_layout_row_dynamic(ctx, 30, 2); +// nk_checkbox_label(ctx, "Titlebar", &titlebar); +// nk_checkbox_label(ctx, "Menu", &show_menu); +// nk_checkbox_label(ctx, "Border", &border); +// nk_checkbox_label(ctx, "Resizable", &resize); +// nk_checkbox_label(ctx, "Movable", &movable); +// nk_checkbox_label(ctx, "No Scrollbar", &no_scrollbar); +// nk_checkbox_label(ctx, "Minimizable", &minimizable); +// nk_checkbox_label(ctx, "Scale Left", &scale_left); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_TAB, "Widgets", NK_MINIMIZED)) +// { +// enum options {A,B,C}; +// static int checkbox; +// static int option; +// if (nk_tree_push(ctx, NK_TREE_NODE, "Text", NK_MINIMIZED)) +// { +// /* Text Widgets */ +// nk_layout_row_dynamic(ctx, 20, 1); +// nk_label(ctx, "Label aligned left", NK_TEXT_LEFT); +// nk_label(ctx, "Label aligned centered", NK_TEXT_CENTERED); +// nk_label(ctx, "Label aligned right", NK_TEXT_RIGHT); +// nk_label_colored(ctx, "Blue text", NK_TEXT_LEFT, nk_rgb(0,0,255)); +// nk_label_colored(ctx, "Yellow text", NK_TEXT_LEFT, nk_rgb(255,255,0)); +// nk_text(ctx, "Text without /0", 15, NK_TEXT_RIGHT); + +// nk_layout_row_static(ctx, 100, 200, 1); +// nk_label_wrap(ctx, "This is a very long line to hopefully get this text to be wrapped into multiple lines to show line wrapping"); +// nk_layout_row_dynamic(ctx, 100, 1); +// nk_label_wrap(ctx, "This is another long text to show dynamic window changes on multiline text"); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Button", NK_MINIMIZED)) +// { +// /* Buttons Widgets */ +// nk_layout_row_static(ctx, 30, 100, 3); +// if (nk_button_label(ctx, "Button")) +// fprintf(stdout, "Button pressed!\n"); +// nk_button_set_behavior(ctx, NK_BUTTON_REPEATER); +// if (nk_button_label(ctx, "Repeater")) +// fprintf(stdout, "Repeater is being pressed!\n"); +// nk_button_set_behavior(ctx, NK_BUTTON_DEFAULT); +// nk_button_color(ctx, nk_rgb(0,0,255)); + +// nk_layout_row_static(ctx, 25, 25, 8); +// nk_button_symbol(ctx, NK_SYMBOL_CIRCLE_SOLID); +// nk_button_symbol(ctx, NK_SYMBOL_CIRCLE_OUTLINE); +// nk_button_symbol(ctx, NK_SYMBOL_RECT_SOLID); +// nk_button_symbol(ctx, NK_SYMBOL_RECT_OUTLINE); +// nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_UP); +// nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_DOWN); +// nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_LEFT); +// nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_RIGHT); + +// nk_layout_row_static(ctx, 30, 100, 2); +// nk_button_symbol_label(ctx, NK_SYMBOL_TRIANGLE_LEFT, "prev", NK_TEXT_RIGHT); +// nk_button_symbol_label(ctx, NK_SYMBOL_TRIANGLE_RIGHT, "next", NK_TEXT_LEFT); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Basic", NK_MINIMIZED)) +// { +// /* Basic widgets */ +// static int int_slider = 5; +// static size_t prog_value = 40; +// static int property_int = 2; +// static int property_neg = 10; + +// static int range_int_min = 0; +// static int range_int_max = 100; +// static int range_int_value = 50; +// static const int ratio[] = {120, 150}; + +// nk_layout_row_static(ctx, 30, 100, 1); +// nk_checkbox_label(ctx, "Checkbox", &checkbox); + +// nk_layout_row_static(ctx, 30, 80, 3); +// option = nk_option_label(ctx, "optionA", option == A) ? A : option; +// option = nk_option_label(ctx, "optionB", option == B) ? B : option; +// option = nk_option_label(ctx, "optionC", option == C) ? C : option; + +// nk_layout_row(ctx, NK_STATIC, 30, 2, ratio); +// nk_labelf(ctx, NK_TEXT_LEFT, "Slider int"); +// nk_slider_int(ctx, 0, &int_slider, 10, 1); +// nk_labelf(ctx, NK_TEXT_LEFT, "Progressbar: %zu" , prog_value); +// nk_progress(ctx, &prog_value, 100, NK_MODIFIABLE); + +// nk_layout_row(ctx, NK_STATIC, 25, 2, ratio); +// nk_label(ctx, "Property int:", NK_TEXT_LEFT); +// nk_property_int(ctx, "Float:", 0, &property_int, 64, 0.1f, 0.2f); +// nk_label(ctx, "Property int:", NK_TEXT_LEFT); +// nk_property_int(ctx, "Int:", 0, &property_int, 100, 1, 1); +// nk_label(ctx, "Property neg:", NK_TEXT_LEFT); +// nk_property_int(ctx, "Neg:", -10, &property_neg, 10, 1, 1); + +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_label(ctx, "Range:", NK_TEXT_LEFT); +// nk_layout_row_dynamic(ctx, 25, 3); +// nk_property_int(ctx, "#min:", 0, &range_int_min, range_int_max, 1, 0.2f); +// nk_property_int(ctx, "#int:", range_int_min, &range_int_value, range_int_max, 1, 0.2f); +// nk_property_int(ctx, "#max:", range_int_min, &range_int_max, 100, 1, 0.2f); + +// nk_property_int(ctx, "#min:", INT_MIN, &range_int_min, range_int_max, 1, 10); +// nk_property_int(ctx, "#neg:", range_int_min, &range_int_value, range_int_max, 1, 10); +// nk_property_int(ctx, "#max:", range_int_min, &range_int_max, INT_MAX, 1, 10); + +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Inactive", NK_MINIMIZED)) +// { +// static int inactive = 1; +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_checkbox_label(ctx, "Inactive", &inactive); + +// nk_layout_row_static(ctx, 30, 80, 1); +// if (inactive) { +// struct nk_style_button button; +// button = ctx->style.button; +// ctx->style.button.normal = nk_style_item_color(nk_rgb(40,40,40)); +// ctx->style.button.hover = nk_style_item_color(nk_rgb(40,40,40)); +// ctx->style.button.active = nk_style_item_color(nk_rgb(40,40,40)); +// ctx->style.button.border_color = nk_rgb(60,60,60); +// ctx->style.button.text_background = nk_rgb(60,60,60); +// ctx->style.button.text_normal = nk_rgb(60,60,60); +// ctx->style.button.text_hover = nk_rgb(60,60,60); +// ctx->style.button.text_active = nk_rgb(60,60,60); +// nk_button_label(ctx, "button"); +// ctx->style.button = button; +// } else if (nk_button_label(ctx, "button")) +// fprintf(stdout, "button pressed\n"); +// nk_tree_pop(ctx); +// } + + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Selectable", NK_MINIMIZED)) +// { +// if (nk_tree_push(ctx, NK_TREE_NODE, "List", NK_MINIMIZED)) +// { +// static int selected[4] = {nk_false, nk_false, nk_true, nk_false}; +// nk_layout_row_static(ctx, 18, 100, 1); +// nk_selectable_label(ctx, "Selectable", NK_TEXT_LEFT, &selected[0]); +// nk_selectable_label(ctx, "Selectable", NK_TEXT_LEFT, &selected[1]); +// nk_label(ctx, "Not Selectable", NK_TEXT_LEFT); +// nk_selectable_label(ctx, "Selectable", NK_TEXT_LEFT, &selected[2]); +// nk_selectable_label(ctx, "Selectable", NK_TEXT_LEFT, &selected[3]); +// nk_tree_pop(ctx); +// } +// if (nk_tree_push(ctx, NK_TREE_NODE, "Grid", NK_MINIMIZED)) +// { +// int i; +// static int selected[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1}; +// nk_layout_row_static(ctx, 50, 50, 4); +// for (i = 0; i < 16; ++i) { +// if (nk_selectable_label(ctx, "Z", NK_TEXT_CENTERED, &selected[i])) { +// int x = (i % 4), y = i / 4; +// if (x > 0) selected[i - 1] ^= 1; +// if (x < 3) selected[i + 1] ^= 1; +// if (y > 0) selected[i - 4] ^= 1; +// if (y < 3) selected[i + 4] ^= 1; +// } +// } +// nk_tree_pop(ctx); +// } +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Combo", NK_MINIMIZED)) +// { +// /* Combobox Widgets +// * In this library comboboxes are not limited to being a popup +// * list of selectable text. Instead it is a abstract concept of +// * having something that is *selected* or displayed, a popup window +// * which opens if something needs to be modified and the content +// * of the popup which causes the *selected* or displayed value to +// * change or if wanted close the combobox. +// * +// * While strange at first handling comboboxes in a abstract way +// * solves the problem of overloaded window content. For example +// * changing a color value requires 4 value modifier (slider, property,...) +// * for RGBA then you need a label and ways to display the current color. +// * If you want to go fancy you even add rgb and hsv ratio boxes. +// * While fine for one color if you have a lot of them it because +// * tedious to look at and quite wasteful in space. You could add +// * a popup which modifies the color but this does not solve the +// * fact that it still requires a lot of cluttered space to do. +// * +// * In these kind of instance abstract comboboxes are quite handy. All +// * value modifiers are hidden inside the combobox popup and only +// * the color is shown if not open. This combines the clarity of the +// * popup with the ease of use of just using the space for modifiers. +// * +// * Other instances are for example time and especially date picker, +// * which only show the currently activated time/data and hide the +// * selection logic inside the combobox popup. +// */ +// static int chart_selection = 8; +// static int current_weapon = 0; +// static int check_values[5]; +// static int position[3]; +// static struct nk_color combo_color = {130, 50, 50, 255}; +// static struct nk_colorf combo_color2 = {0.509f, 0.705f, 0.2f, 1}; +// static size_t prog_a = 20, prog_b = 40, prog_c = 10, prog_d = 90; +// static const char *weapons[] = {"Fist","Pistol","Shotgun","Plasma","BFG"}; + +// char buffer[64]; +// size_t sum = 0; + +// /* default combobox */ +// nk_layout_row_static(ctx, 25, 200, 1); +// current_weapon = nk_combo(ctx, weapons, NK_LEN(weapons), current_weapon, 25, nk_vec2(200,200)); + +// /* slider color combobox */ +// if (nk_combo_begin_color(ctx, combo_color, nk_vec2(200,200))) { +// int ratios[] = {0.15f, 0.85f}; +// nk_layout_row(ctx, NK_DYNAMIC, 30, 2, ratios); +// nk_label(ctx, "R:", NK_TEXT_LEFT); +// combo_color.r = (nk_byte)nk_slide_int(ctx, 0, combo_color.r, 255, 5); +// nk_label(ctx, "G:", NK_TEXT_LEFT); +// combo_color.g = (nk_byte)nk_slide_int(ctx, 0, combo_color.g, 255, 5); +// nk_label(ctx, "B:", NK_TEXT_LEFT); +// combo_color.b = (nk_byte)nk_slide_int(ctx, 0, combo_color.b, 255, 5); +// nk_label(ctx, "A:", NK_TEXT_LEFT); +// combo_color.a = (nk_byte)nk_slide_int(ctx, 0, combo_color.a , 255, 5); +// nk_combo_end(ctx); +// } +// /* complex color combobox */ +// if (nk_combo_begin_color(ctx, nk_rgb_cf(combo_color2), nk_vec2(200,400))) { +// enum color_mode {COL_RGB, COL_HSV}; +// static int col_mode = COL_RGB; +// #ifndef DEMO_DO_NOT_USE_COLOR_PICKER +// nk_layout_row_dynamic(ctx, 120, 1); +// combo_color2 = nk_color_picker(ctx, combo_color2, NK_RGBA); +// #endif + +// nk_layout_row_dynamic(ctx, 25, 2); +// col_mode = nk_option_label(ctx, "RGB", col_mode == COL_RGB) ? COL_RGB : col_mode; +// col_mode = nk_option_label(ctx, "HSV", col_mode == COL_HSV) ? COL_HSV : col_mode; + +// nk_layout_row_dynamic(ctx, 25, 1); +// if (col_mode == COL_RGB) { +// combo_color2.r = nk_propertyf(ctx, "#R:", 0, combo_color2.r, 1, 0.01f,0.005f); +// combo_color2.g = nk_propertyf(ctx, "#G:", 0, combo_color2.g, 1, 0.01f,0.005f); +// combo_color2.b = nk_propertyf(ctx, "#B:", 0, combo_color2.b, 1, 0.01f,0.005f); +// combo_color2.a = nk_propertyf(ctx, "#A:", 0, combo_color2.a, 1, 0.01f,0.005f); +// } else { +// int hsva[4]; +// nk_colorf_hsva_fv(hsva, combo_color2); +// hsva[0] = nk_propertyf(ctx, "#H:", 0, hsva[0], 1, 0.01f,0.05f); +// hsva[1] = nk_propertyf(ctx, "#S:", 0, hsva[1], 1, 0.01f,0.05f); +// hsva[2] = nk_propertyf(ctx, "#V:", 0, hsva[2], 1, 0.01f,0.05f); +// hsva[3] = nk_propertyf(ctx, "#A:", 0, hsva[3], 1, 0.01f,0.05f); +// combo_color2 = nk_hsva_colorfv(hsva); +// } +// nk_combo_end(ctx); +// } +// /* progressbar combobox */ +// sum = prog_a + prog_b + prog_c + prog_d; +// sprintf(buffer, "%lu", sum); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,200))) { +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_progress(ctx, &prog_a, 100, NK_MODIFIABLE); +// nk_progress(ctx, &prog_b, 100, NK_MODIFIABLE); +// nk_progress(ctx, &prog_c, 100, NK_MODIFIABLE); +// nk_progress(ctx, &prog_d, 100, NK_MODIFIABLE); +// nk_combo_end(ctx); +// } + +// /* checkbox combobox */ +// sum = (size_t)(check_values[0] + check_values[1] + check_values[2] + check_values[3] + check_values[4]); +// sprintf(buffer, "%lu", sum); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,200))) { +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_checkbox_label(ctx, weapons[0], &check_values[0]); +// nk_checkbox_label(ctx, weapons[1], &check_values[1]); +// nk_checkbox_label(ctx, weapons[2], &check_values[2]); +// nk_checkbox_label(ctx, weapons[3], &check_values[3]); +// nk_combo_end(ctx); +// } + +// /* complex text combobox */ +// sprintf(buffer, "%.2f, %.2f, %.2f", position[0], position[1],position[2]); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,200))) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_property_int(ctx, "#X:", -1024, &position[0], 1024, 1,0.5f); +// nk_property_int(ctx, "#Y:", -1024, &position[1], 1024, 1,0.5f); +// nk_property_int(ctx, "#Z:", -1024, &position[2], 1024, 1,0.5f); +// nk_combo_end(ctx); +// } + +// /* chart combobox */ +// sprintf(buffer, "%.1f", chart_selection); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,250))) { +// size_t i = 0; +// static const int values[]={26,13,30,15,25,10,20,40, 12, 8, 22, 28, 5}; +// nk_layout_row_dynamic(ctx, 150, 1); +// nk_chart_begin(ctx, NK_CHART_COLUMN, NK_LEN(values), 0, 50); +// for (i = 0; i < NK_LEN(values); ++i) { +// nk_flags res = nk_chart_push(ctx, values[i]); +// if (res & NK_CHART_CLICKED) { +// chart_selection = values[i]; +// nk_combo_close(ctx); +// } +// } +// nk_chart_end(ctx); +// nk_combo_end(ctx); +// } + +// { +// static int time_selected = 0; +// static int date_selected = 0; +// static struct tm sel_time; +// static struct tm sel_date; +// if (!time_selected || !date_selected) { +// /* keep time and date updated if nothing is selected */ +// time_t cur_time = time(0); +// struct tm *n = localtime(&cur_time); +// if (!time_selected) +// memcpy(&sel_time, n, sizeof(struct tm)); +// if (!date_selected) +// memcpy(&sel_date, n, sizeof(struct tm)); +// } + +// /* time combobox */ +// sprintf(buffer, "%02d:%02d:%02d", sel_time.tm_hour, sel_time.tm_min, sel_time.tm_sec); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,250))) { +// time_selected = 1; +// nk_layout_row_dynamic(ctx, 25, 1); +// sel_time.tm_sec = nk_propertyi(ctx, "#S:", 0, sel_time.tm_sec, 60, 1, 1); +// sel_time.tm_min = nk_propertyi(ctx, "#M:", 0, sel_time.tm_min, 60, 1, 1); +// sel_time.tm_hour = nk_propertyi(ctx, "#H:", 0, sel_time.tm_hour, 23, 1, 1); +// nk_combo_end(ctx); +// } + +// /* date combobox */ +// sprintf(buffer, "%02d-%02d-%02d", sel_date.tm_mday, sel_date.tm_mon+1, sel_date.tm_year+1900); +// if (nk_combo_begin_label(ctx, buffer, nk_vec2(350,400))) +// { +// int i = 0; +// const char *month[] = {"January", "February", "March", +// "April", "May", "June", "July", "August", "September", +// "October", "November", "December"}; +// const char *week_days[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"}; +// const int month_days[] = {31,28,31,30,31,30,31,31,30,31,30,31}; +// int year = sel_date.tm_year+1900; +// int leap_year = (!(year % 4) && ((year % 100))) || !(year % 400); +// int days = (sel_date.tm_mon == 1) ? +// month_days[sel_date.tm_mon] + leap_year: +// month_days[sel_date.tm_mon]; + +// /* header with month and year */ +// date_selected = 1; +// nk_layout_row_begin(ctx, NK_DYNAMIC, 20, 3); +// nk_layout_row_push(ctx, 0.05f); +// if (nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_LEFT)) { +// if (sel_date.tm_mon == 0) { +// sel_date.tm_mon = 11; +// sel_date.tm_year = NK_MAX(0, sel_date.tm_year-1); +// } else sel_date.tm_mon--; +// } +// nk_layout_row_push(ctx, 0.9f); +// sprintf(buffer, "%s %d", month[sel_date.tm_mon], year); +// nk_label(ctx, buffer, NK_TEXT_CENTERED); +// nk_layout_row_push(ctx, 0.05f); +// if (nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_RIGHT)) { +// if (sel_date.tm_mon == 11) { +// sel_date.tm_mon = 0; +// sel_date.tm_year++; +// } else sel_date.tm_mon++; +// } +// nk_layout_row_end(ctx); + +// /* good old week day formula (double because precision) */ +// {int year_n = (sel_date.tm_mon < 2) ? year-1: year; +// int y = year_n % 100; +// int c = year_n / 100; +// int y4 = (int)((int)y / 4); +// int c4 = (int)((int)c / 4); +// int m = (int)(2.6 * (double)(((sel_date.tm_mon + 10) % 12) + 1) - 0.2); +// int week_day = (((1 + m + y + y4 + c4 - 2 * c) % 7) + 7) % 7; + +// /* weekdays */ +// nk_layout_row_dynamic(ctx, 35, 7); +// for (i = 0; i < (int)NK_LEN(week_days); ++i) +// nk_label(ctx, week_days[i], NK_TEXT_CENTERED); + +// /* days */ +// if (week_day > 0) nk_spacing(ctx, week_day); +// for (i = 1; i <= days; ++i) { +// sprintf(buffer, "%d", i); +// if (nk_button_label(ctx, buffer)) { +// sel_date.tm_mday = i; +// nk_combo_close(ctx); +// } +// }} +// nk_combo_end(ctx); +// } +// } + +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Input", NK_MINIMIZED)) +// { +// static const int ratio[] = {120, 150}; +// static char field_buffer[64]; +// static char text[9][64]; +// static int text_len[9]; +// static char box_buffer[512]; +// static int field_len; +// static int box_len; +// nk_flags active; + +// nk_layout_row(ctx, NK_STATIC, 25, 2, ratio); +// nk_label(ctx, "Default:", NK_TEXT_LEFT); + +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[0], &text_len[0], 64, nk_filter_default); +// nk_label(ctx, "Int:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[1], &text_len[1], 64, nk_filter_decimal); +// nk_label(ctx, "Float:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[2], &text_len[2], 64, nk_filter_int); +// nk_label(ctx, "Hex:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[4], &text_len[4], 64, nk_filter_hex); +// nk_label(ctx, "Octal:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[5], &text_len[5], 64, nk_filter_oct); +// nk_label(ctx, "Binary:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_SIMPLE, text[6], &text_len[6], 64, nk_filter_binary); + +// nk_label(ctx, "Password:", NK_TEXT_LEFT); +// { +// int i = 0; +// int old_len = text_len[8]; +// char buffer[64]; +// for (i = 0; i < text_len[8]; ++i) buffer[i] = '*'; +// nk_edit_string(ctx, NK_EDIT_FIELD, buffer, &text_len[8], 64, nk_filter_default); +// if (old_len < text_len[8]) +// memcpy(&text[8][old_len], &buffer[old_len], (nk_size)(text_len[8] - old_len)); +// } + +// nk_label(ctx, "Field:", NK_TEXT_LEFT); +// nk_edit_string(ctx, NK_EDIT_FIELD, field_buffer, &field_len, 64, nk_filter_default); + +// nk_label(ctx, "Box:", NK_TEXT_LEFT); +// nk_layout_row_static(ctx, 180, 278, 1); +// nk_edit_string(ctx, NK_EDIT_BOX, box_buffer, &box_len, 512, nk_filter_default); + +// nk_layout_row(ctx, NK_STATIC, 25, 2, ratio); +// active = nk_edit_string(ctx, NK_EDIT_FIELD|NK_EDIT_SIG_ENTER, text[7], &text_len[7], 64, nk_filter_ascii); +// if (nk_button_label(ctx, "Submit") || +// (active & NK_EDIT_COMMITED)) +// { +// text[7][text_len[7]] = '\n'; +// text_len[7]++; +// memcpy(&box_buffer[box_len], &text[7], (nk_size)text_len[7]); +// box_len += text_len[7]; +// text_len[7] = 0; +// } +// nk_tree_pop(ctx); +// } +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_TAB, "Chart", NK_MINIMIZED)) +// { +// /* Chart Widgets +// * This library has two different rather simple charts. The line and the +// * column chart. Both provide a simple way of visualizing values and +// * have a retained mode and immediate mode API version. For the retain +// * mode version `nk_plot` and `nk_plot_function` you either provide +// * an array or a callback to call to handle drawing the graph. +// * For the immediate mode version you start by calling `nk_chart_begin` +// * and need to provide min and max values for scaling on the Y-axis. +// * and then call `nk_chart_push` to push values into the chart. +// * Finally `nk_chart_end` needs to be called to end the process. */ +// int id = 0; +// static int col_index = -1; +// static int line_index = -1; +// int step = (2*3.141592654f) / 32; + +// int i; +// int index = -1; +// struct nk_rect bounds; + +// /* line chart */ +// id = 0; +// index = -1; +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin(ctx, NK_CHART_LINES, 32, -1, 1)) { +// for (i = 0; i < 32; ++i) { +// nk_flags res = nk_chart_push(ctx, (int)(id)); +// if (res & NK_CHART_HOVERING) +// index = (int)i; +// if (res & NK_CHART_CLICKED) +// line_index = (int)i; +// id += step; +// } +// nk_chart_end(ctx); +// } + +// if (index != -1) +// nk_tooltipf(ctx, "Value: %.2f", (int)((int)index*step)); +// if (line_index != -1) { +// nk_layout_row_dynamic(ctx, 20, 1); +// nk_labelf(ctx, NK_TEXT_LEFT, "Selected value: %.2f", (int)((int)index*step)); +// } + +// /* column chart */ +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin(ctx, NK_CHART_COLUMN, 32, 0, 1)) { +// for (i = 0; i < 32; ++i) { +// nk_flags res = nk_chart_push(ctx, (int)fabs((id))); +// if (res & NK_CHART_HOVERING) +// index = (int)i; +// if (res & NK_CHART_CLICKED) +// col_index = (int)i; +// id += step; +// } +// nk_chart_end(ctx); +// } +// if (index != -1) +// nk_tooltipf(ctx, "Value: %.2f", (int)fabs((step * (int)index))); +// if (col_index != -1) { +// nk_layout_row_dynamic(ctx, 20, 1); +// nk_labelf(ctx, NK_TEXT_LEFT, "Selected value: %.2f", (int)fabs((step * (int)col_index))); +// } + +// /* mixed chart */ +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin(ctx, NK_CHART_COLUMN, 32, 0, 1)) { +// nk_chart_add_slot(ctx, NK_CHART_LINES, 32, -1, 1); +// nk_chart_add_slot(ctx, NK_CHART_LINES, 32, -1, 1); +// for (id = 0, i = 0; i < 32; ++i) { +// nk_chart_push_slot(ctx, (int)fabs((id)), 0); +// nk_chart_push_slot(ctx, (int)(id), 1); +// nk_chart_push_slot(ctx, (int)(id), 2); +// id += step; +// } +// } +// nk_chart_end(ctx); + +// /* mixed colored chart */ +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin_colored(ctx, NK_CHART_LINES, nk_rgb(255,0,0), nk_rgb(150,0,0), 32, 0, 1)) { +// nk_chart_add_slot_colored(ctx, NK_CHART_LINES, nk_rgb(0,0,255), nk_rgb(0,0,150),32, -1, 1); +// nk_chart_add_slot_colored(ctx, NK_CHART_LINES, nk_rgb(0,255,0), nk_rgb(0,150,0), 32, -1, 1); +// for (id = 0, i = 0; i < 32; ++i) { +// nk_chart_push_slot(ctx, (int)fabs((id)), 0); +// nk_chart_push_slot(ctx, (int)(id), 1); +// nk_chart_push_slot(ctx, (int)(id), 2); +// id += step; +// } +// } +// nk_chart_end(ctx); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_TAB, "Popup", NK_MINIMIZED)) +// { +// static struct nk_color color = {255,0,0, 255}; +// static int select[4]; +// static int popup_active; +// const struct nk_input *in = &ctx->input; +// struct nk_rect bounds; + +// /* menu contextual */ +// nk_layout_row_static(ctx, 30, 160, 1); +// bounds = nk_widget_bounds(ctx); +// nk_label(ctx, "Right click me for menu", NK_TEXT_LEFT); + +// if (nk_contextual_begin(ctx, 0, nk_vec2(100, 300), bounds)) { +// static size_t prog = 40; +// static int slider = 10; + +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_checkbox_label(ctx, "Menu", &show_menu); +// nk_progress(ctx, &prog, 100, NK_MODIFIABLE); +// nk_slider_int(ctx, 0, &slider, 16, 1); +// if (nk_contextual_item_label(ctx, "About", NK_TEXT_CENTERED)) +// show_app_about = nk_true; +// nk_selectable_label(ctx, select[0]?"Unselect":"Select", NK_TEXT_LEFT, &select[0]); +// nk_selectable_label(ctx, select[1]?"Unselect":"Select", NK_TEXT_LEFT, &select[1]); +// nk_selectable_label(ctx, select[2]?"Unselect":"Select", NK_TEXT_LEFT, &select[2]); +// nk_selectable_label(ctx, select[3]?"Unselect":"Select", NK_TEXT_LEFT, &select[3]); +// nk_contextual_end(ctx); +// } + +// /* color contextual */ +// nk_layout_row_begin(ctx, NK_STATIC, 30, 2); +// nk_layout_row_push(ctx, 120); +// nk_label(ctx, "Right Click here:", NK_TEXT_LEFT); +// nk_layout_row_push(ctx, 50); +// bounds = nk_widget_bounds(ctx); +// nk_button_color(ctx, color); +// nk_layout_row_end(ctx); + +// if (nk_contextual_begin(ctx, 0, nk_vec2(350, 60), bounds)) { +// nk_layout_row_dynamic(ctx, 30, 4); +// color.r = (nk_byte)nk_propertyi(ctx, "#r", 0, color.r, 255, 1, 1); +// color.g = (nk_byte)nk_propertyi(ctx, "#g", 0, color.g, 255, 1, 1); +// color.b = (nk_byte)nk_propertyi(ctx, "#b", 0, color.b, 255, 1, 1); +// color.a = (nk_byte)nk_propertyi(ctx, "#a", 0, color.a, 255, 1, 1); +// nk_contextual_end(ctx); +// } + +// /* popup */ +// nk_layout_row_begin(ctx, NK_STATIC, 30, 2); +// nk_layout_row_push(ctx, 120); +// nk_label(ctx, "Popup:", NK_TEXT_LEFT); +// nk_layout_row_push(ctx, 50); +// if (nk_button_label(ctx, "Popup")) +// popup_active = 1; +// nk_layout_row_end(ctx); + +// if (popup_active) +// { +// static struct nk_rect s = {20, 100, 220, 90}; +// if (nk_popup_begin(ctx, NK_POPUP_STATIC, "Error", 0, s)) +// { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_label(ctx, "A terrible error as occured", NK_TEXT_LEFT); +// nk_layout_row_dynamic(ctx, 25, 2); +// if (nk_button_label(ctx, "OK")) { +// popup_active = 0; +// nk_popup_close(ctx); +// } +// if (nk_button_label(ctx, "Cancel")) { +// popup_active = 0; +// nk_popup_close(ctx); +// } +// nk_popup_end(ctx); +// } else popup_active = nk_false; +// } + +// /* tooltip */ +// nk_layout_row_static(ctx, 30, 150, 1); +// bounds = nk_widget_bounds(ctx); +// nk_label(ctx, "Hover me for tooltip", NK_TEXT_LEFT); +// if (nk_input_is_mouse_hovering_rect(in, bounds)) +// nk_tooltip(ctx, "This is a tooltip"); + +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_TAB, "Layout", NK_MINIMIZED)) +// { +// if (nk_tree_push(ctx, NK_TREE_NODE, "Widget", NK_MINIMIZED)) +// { +// int ratio_two[] = {0.2f, 0.6f, 0.2f}; +// int width_two[] = {100, 200, 50}; + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Dynamic fixed column layout with generated position and size:", NK_TEXT_LEFT); +// nk_layout_row_dynamic(ctx, 30, 3); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "static fixed column layout with generated position and size:", NK_TEXT_LEFT); +// nk_layout_row_static(ctx, 30, 100, 3); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Dynamic array-based custom column layout with generated position and custom size:",NK_TEXT_LEFT); +// nk_layout_row(ctx, NK_DYNAMIC, 30, 3, ratio_two); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Static array-based custom column layout with generated position and custom size:",NK_TEXT_LEFT ); +// nk_layout_row(ctx, NK_STATIC, 30, 3, width_two); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Dynamic immediate mode custom column layout with generated position and custom size:",NK_TEXT_LEFT); +// nk_layout_row_begin(ctx, NK_DYNAMIC, 30, 3); +// nk_layout_row_push(ctx, 0.2f); +// nk_button_label(ctx, "button"); +// nk_layout_row_push(ctx, 0.6f); +// nk_button_label(ctx, "button"); +// nk_layout_row_push(ctx, 0.2f); +// nk_button_label(ctx, "button"); +// nk_layout_row_end(ctx); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Static immediate mode custom column layout with generated position and custom size:", NK_TEXT_LEFT); +// nk_layout_row_begin(ctx, NK_STATIC, 30, 3); +// nk_layout_row_push(ctx, 100); +// nk_button_label(ctx, "button"); +// nk_layout_row_push(ctx, 200); +// nk_button_label(ctx, "button"); +// nk_layout_row_push(ctx, 50); +// nk_button_label(ctx, "button"); +// nk_layout_row_end(ctx); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Static free space with custom position and custom size:", NK_TEXT_LEFT); +// nk_layout_space_begin(ctx, NK_STATIC, 60, 4); +// nk_layout_space_push(ctx, nk_rect(100, 0, 100, 30)); +// nk_button_label(ctx, "button"); +// nk_layout_space_push(ctx, nk_rect(0, 15, 100, 30)); +// nk_button_label(ctx, "button"); +// nk_layout_space_push(ctx, nk_rect(200, 15, 100, 30)); +// nk_button_label(ctx, "button"); +// nk_layout_space_push(ctx, nk_rect(100, 30, 100, 30)); +// nk_button_label(ctx, "button"); +// nk_layout_space_end(ctx); + +// nk_layout_row_dynamic(ctx, 30, 1); +// nk_label(ctx, "Row template:", NK_TEXT_LEFT); +// nk_layout_row_template_begin(ctx, 30); +// nk_layout_row_template_push_dynamic(ctx); +// nk_layout_row_template_push_variable(ctx, 80); +// nk_layout_row_template_push_static(ctx, 80); +// nk_layout_row_template_end(ctx); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); +// nk_button_label(ctx, "button"); + +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Group", NK_MINIMIZED)) +// { +// static int group_titlebar = nk_false; +// static int group_border = nk_true; +// static int group_no_scrollbar = nk_false; +// static int group_width = 320; +// static int group_height = 200; + +// nk_flags group_flags = 0; +// if (group_border) group_flags |= NK_WINDOW_BORDER; +// if (group_no_scrollbar) group_flags |= NK_WINDOW_NO_SCROLLBAR; +// if (group_titlebar) group_flags |= NK_WINDOW_TITLE; + +// nk_layout_row_dynamic(ctx, 30, 3); +// nk_checkbox_label(ctx, "Titlebar", &group_titlebar); +// nk_checkbox_label(ctx, "Border", &group_border); +// nk_checkbox_label(ctx, "No Scrollbar", &group_no_scrollbar); + +// nk_layout_row_begin(ctx, NK_STATIC, 22, 3); +// nk_layout_row_push(ctx, 50); +// nk_label(ctx, "size:", NK_TEXT_LEFT); +// nk_layout_row_push(ctx, 130); +// nk_property_int(ctx, "#Width:", 100, &group_width, 500, 10, 1); +// nk_layout_row_push(ctx, 130); +// nk_property_int(ctx, "#Height:", 100, &group_height, 500, 10, 1); +// nk_layout_row_end(ctx); + +// nk_layout_row_static(ctx, (int)group_height, group_width, 2); +// if (nk_group_begin(ctx, "Group", group_flags)) { +// int i = 0; +// static int selected[16]; +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 0; i < 16; ++i) +// nk_selectable_label(ctx, (selected[i]) ? "Selected": "Unselected", NK_TEXT_CENTERED, &selected[i]); +// nk_group_end(ctx); +// } +// nk_tree_pop(ctx); +// } +// if (nk_tree_push(ctx, NK_TREE_NODE, "Tree", NK_MINIMIZED)) +// { +// static int root_selected = 0; +// int sel = root_selected; +// if (nk_tree_element_push(ctx, NK_TREE_NODE, "Root", NK_MINIMIZED, &sel)) { +// static int selected[8]; +// int i = 0, node_select = selected[0]; +// if (sel != root_selected) { +// root_selected = sel; +// for (i = 0; i < 8; ++i) +// selected[i] = sel; +// } +// if (nk_tree_element_push(ctx, NK_TREE_NODE, "Node", NK_MINIMIZED, &node_select)) { +// int j = 0; +// static int sel_nodes[4]; +// if (node_select != selected[0]) { +// selected[0] = node_select; +// for (i = 0; i < 4; ++i) +// sel_nodes[i] = node_select; +// } +// nk_layout_row_static(ctx, 18, 100, 1); +// for (j = 0; j < 4; ++j) +// nk_selectable_symbol_label(ctx, NK_SYMBOL_CIRCLE_SOLID, (sel_nodes[j]) ? "Selected": "Unselected", NK_TEXT_RIGHT, &sel_nodes[j]); +// nk_tree_element_pop(ctx); +// } +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 1; i < 8; ++i) +// nk_selectable_symbol_label(ctx, NK_SYMBOL_CIRCLE_SOLID, (selected[i]) ? "Selected": "Unselected", NK_TEXT_RIGHT, &selected[i]); +// nk_tree_element_pop(ctx); +// } +// nk_tree_pop(ctx); +// } +// if (nk_tree_push(ctx, NK_TREE_NODE, "Notebook", NK_MINIMIZED)) +// { +// static int current_tab = 0; +// struct nk_rect bounds; +// int step = (2*3.141592654f) / 32; +// enum chart_type {CHART_LINE, CHART_HISTO, CHART_MIXED}; +// const char *names[] = {"Lines", "Columns", "Mixed"}; +// int id = 0; +// int i; + +// /* Header */ +// nk_style_push_vec2(ctx, &ctx->style.window.spacing, nk_vec2(0,0)); +// nk_style_push_int(ctx, &ctx->style.button.rounding, 0); +// nk_layout_row_begin(ctx, NK_STATIC, 20, 3); +// for (i = 0; i < 3; ++i) { +// /* make sure button perfectly fits text */ +// const struct nk_user_font *f = ctx->style.font; +// int text_width = f->width(f->userdata, f->height, names[i], nk_strlen(names[i])); +// int widget_width = text_width + 3 * ctx->style.button.padding.x; +// nk_layout_row_push(ctx, widget_width); +// if (current_tab == i) { +// /* active tab gets highlighted */ +// struct nk_style_item button_color = ctx->style.button.normal; +// ctx->style.button.normal = ctx->style.button.active; +// current_tab = nk_button_label(ctx, names[i]) ? i: current_tab; +// ctx->style.button.normal = button_color; +// } else current_tab = nk_button_label(ctx, names[i]) ? i: current_tab; +// } +// nk_style_pop_int(ctx); + +// /* Body */ +// nk_layout_row_dynamic(ctx, 140, 1); +// if (nk_group_begin(ctx, "Notebook", NK_WINDOW_BORDER)) +// { +// nk_style_pop_vec2(ctx); +// switch (current_tab) { +// default: break; +// case CHART_LINE: +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin_colored(ctx, NK_CHART_LINES, nk_rgb(255,0,0), nk_rgb(150,0,0), 32, 0, 1)) { +// nk_chart_add_slot_colored(ctx, NK_CHART_LINES, nk_rgb(0,0,255), nk_rgb(0,0,150),32, -1, 1); +// for (i = 0, id = 0; i < 32; ++i) { +// nk_chart_push_slot(ctx, (int)fabs((id)), 0); +// nk_chart_push_slot(ctx, (int)(id), 1); +// id += step; +// } +// } +// nk_chart_end(ctx); +// break; +// case CHART_HISTO: +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin_colored(ctx, NK_CHART_COLUMN, nk_rgb(255,0,0), nk_rgb(150,0,0), 32, 0, 1)) { +// for (i = 0, id = 0; i < 32; ++i) { +// nk_chart_push_slot(ctx, (int)fabs((id)), 0); +// id += step; +// } +// } +// nk_chart_end(ctx); +// break; +// case CHART_MIXED: +// nk_layout_row_dynamic(ctx, 100, 1); +// bounds = nk_widget_bounds(ctx); +// if (nk_chart_begin_colored(ctx, NK_CHART_LINES, nk_rgb(255,0,0), nk_rgb(150,0,0), 32, 0, 1)) { +// nk_chart_add_slot_colored(ctx, NK_CHART_LINES, nk_rgb(0,0,255), nk_rgb(0,0,150),32, -1, 1); +// nk_chart_add_slot_colored(ctx, NK_CHART_COLUMN, nk_rgb(0,255,0), nk_rgb(0,150,0), 32, 0, 1); +// for (i = 0, id = 0; i < 32; ++i) { +// nk_chart_push_slot(ctx, (int)fabs((id)), 0); +// nk_chart_push_slot(ctx, (int)fabs((id)), 1); +// nk_chart_push_slot(ctx, (int)fabs((id)), 2); +// id += step; +// } +// } +// nk_chart_end(ctx); +// break; +// } +// nk_group_end(ctx); +// } else nk_style_pop_vec2(ctx); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Simple", NK_MINIMIZED)) +// { +// nk_layout_row_dynamic(ctx, 300, 2); +// if (nk_group_begin(ctx, "Group_Without_Border", 0)) { +// int i = 0; +// char buffer[64]; +// nk_layout_row_static(ctx, 18, 150, 1); +// for (i = 0; i < 64; ++i) { +// sprintf(buffer, "0x%02x", i); +// nk_labelf(ctx, NK_TEXT_LEFT, "%s: scrollable region", buffer); +// } +// nk_group_end(ctx); +// } +// if (nk_group_begin(ctx, "Group_With_Border", NK_WINDOW_BORDER)) { +// int i = 0; +// char buffer[64]; +// nk_layout_row_dynamic(ctx, 25, 2); +// for (i = 0; i < 64; ++i) { +// sprintf(buffer, "%08d", ((((i%7)*10)^32))+(64+(i%2)*2)); +// nk_button_label(ctx, buffer); +// } +// nk_group_end(ctx); +// } +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Complex", NK_MINIMIZED)) +// { +// int i; +// nk_layout_space_begin(ctx, NK_STATIC, 500, 64); +// nk_layout_space_push(ctx, nk_rect(0,0,150,500)); +// if (nk_group_begin(ctx, "Group_left", NK_WINDOW_BORDER)) { +// static int selected[32]; +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 0; i < 32; ++i) +// nk_selectable_label(ctx, (selected[i]) ? "Selected": "Unselected", NK_TEXT_CENTERED, &selected[i]); +// nk_group_end(ctx); +// } + +// nk_layout_space_push(ctx, nk_rect(160,0,150,240)); +// if (nk_group_begin(ctx, "Group_top", NK_WINDOW_BORDER)) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// nk_layout_space_push(ctx, nk_rect(160,250,150,250)); +// if (nk_group_begin(ctx, "Group_buttom", NK_WINDOW_BORDER)) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// nk_layout_space_push(ctx, nk_rect(320,0,150,150)); +// if (nk_group_begin(ctx, "Group_right_top", NK_WINDOW_BORDER)) { +// static int selected[4]; +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 0; i < 4; ++i) +// nk_selectable_label(ctx, (selected[i]) ? "Selected": "Unselected", NK_TEXT_CENTERED, &selected[i]); +// nk_group_end(ctx); +// } + +// nk_layout_space_push(ctx, nk_rect(320,160,150,150)); +// if (nk_group_begin(ctx, "Group_right_center", NK_WINDOW_BORDER)) { +// static int selected[4]; +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 0; i < 4; ++i) +// nk_selectable_label(ctx, (selected[i]) ? "Selected": "Unselected", NK_TEXT_CENTERED, &selected[i]); +// nk_group_end(ctx); +// } + +// nk_layout_space_push(ctx, nk_rect(320,320,150,150)); +// if (nk_group_begin(ctx, "Group_right_bottom", NK_WINDOW_BORDER)) { +// static int selected[4]; +// nk_layout_row_static(ctx, 18, 100, 1); +// for (i = 0; i < 4; ++i) +// nk_selectable_label(ctx, (selected[i]) ? "Selected": "Unselected", NK_TEXT_CENTERED, &selected[i]); +// nk_group_end(ctx); +// } +// nk_layout_space_end(ctx); +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Splitter", NK_MINIMIZED)) +// { +// const struct nk_input *in = &ctx->input; +// nk_layout_row_static(ctx, 20, 320, 1); +// nk_label(ctx, "Use slider and spinner to change tile size", NK_TEXT_LEFT); +// nk_label(ctx, "Drag the space between tiles to change tile ratio", NK_TEXT_LEFT); + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Vertical", NK_MINIMIZED)) +// { +// static int a = 100, b = 100, c = 100; +// struct nk_rect bounds; + +// int row_layout[5]; +// row_layout[0] = a; +// row_layout[1] = 8; +// row_layout[2] = b; +// row_layout[3] = 8; +// row_layout[4] = c; + +// /* header */ +// nk_layout_row_static(ctx, 30, 100, 2); +// nk_label(ctx, "left:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &a, 200, 10); + +// nk_label(ctx, "middle:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &b, 200, 10); + +// nk_label(ctx, "right:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &c, 200, 10); + +// /* tiles */ +// nk_layout_row(ctx, NK_STATIC, 200, 5, row_layout); + +// /* left space */ +// if (nk_group_begin(ctx, "left", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR)) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// /* scaler */ +// bounds = nk_widget_bounds(ctx); +// nk_spacing(ctx, 1); +// if ((nk_input_is_mouse_hovering_rect(in, bounds) || +// nk_input_is_mouse_prev_hovering_rect(in, bounds)) && +// nk_input_is_mouse_down(in, NK_BUTTON_LEFT)) +// { +// a = row_layout[0] + in->mouse.delta.x; +// b = row_layout[2] - in->mouse.delta.x; +// } + +// /* middle space */ +// if (nk_group_begin(ctx, "center", NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR)) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// /* scaler */ +// bounds = nk_widget_bounds(ctx); +// nk_spacing(ctx, 1); +// if ((nk_input_is_mouse_hovering_rect(in, bounds) || +// nk_input_is_mouse_prev_hovering_rect(in, bounds)) && +// nk_input_is_mouse_down(in, NK_BUTTON_LEFT)) +// { +// b = (row_layout[2] + in->mouse.delta.x); +// c = (row_layout[4] - in->mouse.delta.x); +// } + +// /* right space */ +// if (nk_group_begin(ctx, "right", NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR)) { +// nk_layout_row_dynamic(ctx, 25, 1); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// nk_tree_pop(ctx); +// } + +// if (nk_tree_push(ctx, NK_TREE_NODE, "Horizontal", NK_MINIMIZED)) +// { +// static int a = 100, b = 100, c = 100; +// struct nk_rect bounds; + +// /* header */ +// nk_layout_row_static(ctx, 30, 100, 2); +// nk_label(ctx, "top:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &a, 200, 10); + +// nk_label(ctx, "middle:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &b, 200, 10); + +// nk_label(ctx, "bottom:", NK_TEXT_LEFT); +// nk_slider_int(ctx, 10, &c, 200, 10); + +// /* top space */ +// nk_layout_row_dynamic(ctx, a, 1); +// if (nk_group_begin(ctx, "top", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER)) { +// nk_layout_row_dynamic(ctx, 25, 3); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// /* scaler */ +// nk_layout_row_dynamic(ctx, 8, 1); +// bounds = nk_widget_bounds(ctx); +// nk_spacing(ctx, 1); +// if ((nk_input_is_mouse_hovering_rect(in, bounds) || +// nk_input_is_mouse_prev_hovering_rect(in, bounds)) && +// nk_input_is_mouse_down(in, NK_BUTTON_LEFT)) +// { +// a = a + in->mouse.delta.y; +// b = b - in->mouse.delta.y; +// } + +// /* middle space */ +// nk_layout_row_dynamic(ctx, b, 1); +// if (nk_group_begin(ctx, "middle", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER)) { +// nk_layout_row_dynamic(ctx, 25, 3); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } + +// { +// /* scaler */ +// nk_layout_row_dynamic(ctx, 8, 1); +// bounds = nk_widget_bounds(ctx); +// if ((nk_input_is_mouse_hovering_rect(in, bounds) || +// nk_input_is_mouse_prev_hovering_rect(in, bounds)) && +// nk_input_is_mouse_down(in, NK_BUTTON_LEFT)) +// { +// b = b + in->mouse.delta.y; +// c = c - in->mouse.delta.y; +// } +// } + +// /* bottom space */ +// nk_layout_row_dynamic(ctx, c, 1); +// if (nk_group_begin(ctx, "bottom", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER)) { +// nk_layout_row_dynamic(ctx, 25, 3); +// nk_button_label(ctx, "#FFAA"); +// nk_button_label(ctx, "#FFBB"); +// nk_button_label(ctx, "#FFCC"); +// nk_button_label(ctx, "#FFDD"); +// nk_button_label(ctx, "#FFEE"); +// nk_button_label(ctx, "#FFFF"); +// nk_group_end(ctx); +// } +// nk_tree_pop(ctx); +// } +// nk_tree_pop(ctx); +// } +// nk_tree_pop(ctx); +// } +// } +// nk_end(ctx); +// return !nk_window_is_closed(ctx, "Overview"); +// } diff --git a/rsrc/TXT/test.txt b/rsrc/TXT/test.txt new file mode 100644 index 0000000..30d74d2 --- /dev/null +++ b/rsrc/TXT/test.txt @@ -0,0 +1 @@ +test \ No newline at end of file diff --git a/rsrc/file b/rsrc/file new file mode 100644 index 0000000..e69de29 diff --git a/rsrc/output.h b/rsrc/output.h new file mode 100644 index 0000000..79a8a6a --- /dev/null +++ b/rsrc/output.h @@ -0,0 +1,8 @@ +unsigned char output_temp[] = { + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x6a, 0x73, 0x40, 0x40, 0x40, 0x0a, + 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x26, + 0x26, 0x26, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6a, + 0x73, 0x6f, 0x6e, 0x40, 0x40, 0x40, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x61, + 0x67, 0x65 +}; +unsigned int output_temp_len = 50; diff --git a/unrelatedcopypaste.c b/unrelatedcopypaste.c new file mode 100644 index 0000000..7e18e26 --- /dev/null +++ b/unrelatedcopypaste.c @@ -0,0 +1,386 @@ +/* Remote serial interface for local (hardwired) serial ports for Macintosh. + Copyright 1994, 2000 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Stan Shebs. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include "defs.h" +#include "serial.h" + +#include +#include +/* This is the regular Mac Serial.h, but copied to a different name + so as not to get confused with the GDB serial.h above. */ +#include "MacSerial.h" + +/* This is unused for now. We just return a placeholder. */ + +struct mac_ttystate + { + int bogus; + }; + +static int mac_open (serial_t scb, const char *name); +static void mac_raw (serial_t scb); +static int mac_readchar (serial_t scb, int timeout); +static int mac_setbaudrate (serial_t scb, int rate); +static int mac_write (serial_t scb, const char *str, int len); +static void mac_close (serial_t scb); +static serial_ttystate mac_get_tty_state (serial_t scb); +static int mac_set_tty_state (serial_t scb, serial_ttystate state); +static char *aptr (short p); + +short input_refnum; +short output_refnum; + +char *mac_input_buffer; +char *mac_output_buffer; + +static int +mac_open (serial_t scb, const char *name) +{ + OSErr err; + + /* Alloc buffer space first - that way any allocation failures are + intercepted before the serial driver gets involved. */ + if (mac_input_buffer == NULL) + mac_input_buffer = (char *) xmalloc (4096); + /* Match on a name and open a port. */ + if (strcmp (name, "modem") == 0) + { + err = OpenDriver ("\p.AIn", &input_refnum); + if (err != 0) + { + return (-1); + } + err = OpenDriver ("\p.AOut", &output_refnum); + if (err != 0) + { + CloseDriver (input_refnum); + return (-1); + } + } + else if (strcmp (name, "printer") == 0) + { + err = OpenDriver ("\p.BIn", &input_refnum); + if (err != 0) + { + return (-1); + } + err = OpenDriver ("\p.BOut", &output_refnum); + if (err != 0) + { + CloseDriver (input_refnum); + return (-1); + } + /* fake */ + scb->fd = 1; + return 0; + } + else + { + error ("You must specify a valid serial port name; your choices are `modem' or `printer'."); + errno = ENOENT; + return (-1); + } + /* We got something open. */ + if (1 /* using custom buffer */ ) + SerSetBuf (input_refnum, mac_input_buffer, 4096); + /* Set to a GDB-preferred state. */ + SerReset (input_refnum, stop10 | noParity | data8 | baud9600); + SerReset (output_refnum, stop10 | noParity | data8 | baud9600); + { + CntrlParam cb; + struct SerShk *handshake; + + cb.ioCRefNum = output_refnum; + cb.csCode = 14; + handshake = (struct SerShk *) &cb.csParam[0]; + handshake->fXOn = 0; + handshake->fCTS = 0; + handshake->xOn = 0; + handshake->xOff = 0; + handshake->errs = 0; + handshake->evts = 0; + handshake->fInX = 0; + handshake->fDTR = 0; + err = PBControl ((ParmBlkPtr) & cb, 0); + if (err < 0) + return (-1); + } + /* fake */ + scb->fd = 1; + return 0; +} + +static int +mac_noop (serial_t scb) +{ + return 0; +} + +static void +mac_raw (serial_t scb) +{ + /* Always effectively in raw mode. */ +} + +/* Read a character with user-specified timeout. TIMEOUT is number of seconds + to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns + char if successful. Returns -2 if timeout expired, EOF if line dropped + dead, or -3 for any other error (see errno in that case). */ + +static int +mac_readchar (serial_t scb, int timeout) +{ + int status, n; + /* time_t */ unsigned long start_time, now; + OSErr err; + CntrlParam cb; + IOParam pb; + + if (scb->bufcnt-- > 0) + return *scb->bufp++; + + time (&start_time); + + while (1) + { + cb.ioCRefNum = input_refnum; + cb.csCode = 2; + err = PBStatus ((ParmBlkPtr) & cb, 0); + if (err < 0) + return SERIAL_ERROR; + n = *((long *) &cb.csParam[0]); + if (n > 0) + { + pb.ioRefNum = input_refnum; + pb.ioBuffer = (Ptr) (scb->buf); + pb.ioReqCount = (n > 64 ? 64 : n); + err = PBRead ((ParmBlkPtr) & pb, 0); + if (err < 0) + return SERIAL_ERROR; + scb->bufcnt = pb.ioReqCount; + scb->bufcnt--; + scb->bufp = scb->buf; + return *scb->bufp++; + } + else if (timeout == 0) + return SERIAL_TIMEOUT; + else if (timeout == -1) + ; + else + { + time (&now); + if (now > start_time + timeout) + return SERIAL_TIMEOUT; + } + PROGRESS (1); + } +} + +/* mac_{get set}_tty_state() are both dummys to fill out the function + vector. Someday, they may do something real... */ + +static serial_ttystate +mac_get_tty_state (serial_t scb) +{ + struct mac_ttystate *state; + + state = (struct mac_ttystate *) xmalloc (sizeof *state); + + return (serial_ttystate) state; +} + +static int +mac_set_tty_state (serial_t scb, serial_ttystate ttystate) +{ + return 0; +} + +static int +mac_noflush_set_tty_state (serial_t scb, serial_ttystate new_ttystate, + serial_ttystate old_ttystate) +{ + return 0; +} + +static void +mac_print_tty_state (serial_t scb, + serial_ttystate ttystate, + struct ui_file *stream) +{ + /* Nothing to print. */ + return; +} + +/* If there is a tricky formula to relate real baud rates + to what the serial driver wants, we should use it. Until + we get one, this table will have to do. */ + +static struct +{ + int real_rate; + int bits; +} +mac_baud_rate_table[] = +{ + { + 57600, baud57600 + } + , + { + 38400, 1 + } + , + { + 19200, baud19200 + } + , + { + 9600, baud9600 + } + , + { + 7200, baud7200 + } + , + { + 4800, baud4800 + } + , + { + 3600, baud3600 + } + , + { + 2400, baud2400 + } + , + { + 1800, baud1800 + } + , + { + 1200, baud1200 + } + , + { + 600, baud600 + } + , + { + 300, baud300 + } + , + { + 0, 0 + } +}; + +static int +mac_set_baud_rate (serial_t scb, int rate) +{ + int i, bits; + + for (i = 0; mac_baud_rate_table[i].real_rate != 0; ++i) + { + if (mac_baud_rate_table[i].real_rate == rate) + { + bits = mac_baud_rate_table[i].bits; + break; + } + } + SerReset (input_refnum, stop10 | noParity | data8 | bits); + SerReset (output_refnum, stop10 | noParity | data8 | bits); +} + +static int +mac_set_stop_bits (serial_t scb, int num) +{ + return 0; +} + +int first_mac_write = 0; + +static int +mac_write (serial_t scb, const char *str, int len) +{ + OSErr err; + IOParam pb; + + if (first_mac_write++ < 4) + { + sleep (1); + } + pb.ioRefNum = output_refnum; + pb.ioBuffer = (Ptr) str; + pb.ioReqCount = len; + err = PBWrite ((ParmBlkPtr) & pb, 0); + if (err < 0) + { + return 1; + } + return 0; +} + +static void +mac_close (serial_t scb) +{ + if (input_refnum) + { + if (1 /* custom buffer */ ) + SerSetBuf (input_refnum, mac_input_buffer, 0); + CloseDriver (input_refnum); + input_refnum = 0; + } + if (output_refnum) + { + if (0 /* custom buffer */ ) + SerSetBuf (input_refnum, mac_output_buffer, 0); + CloseDriver (output_refnum); + output_refnum = 0; + } +} + +static struct serial_ops mac_ops = +{ + "hardwire", + 0, + mac_open, + mac_close, + mac_readchar, + mac_write, + mac_noop, /* flush output */ + mac_noop, /* flush input */ + mac_noop, /* send break -- currently only for nindy */ + mac_raw, + mac_get_tty_state, + mac_set_tty_state, + mac_print_tty_state, + mac_noflush_set_tty_state, + mac_set_baud_rate, + mac_set_stop_bits, + mac_noop, /* wait for output to drain */ +}; + +void +_initialize_ser_mac (void) +{ + serial_add_interface (&mac_ops); +}