From f7a56ebc010c2ddc6b7c70923aa5b87ea95c7cd3 Mon Sep 17 00:00:00 2001 From: Michel Pollet Date: Wed, 25 Oct 2023 08:50:14 +0100 Subject: [PATCH] Initial Commit Cleaned up for release at last! Signed-off-by: Michel Pollet --- .gitignore | 4 + LICENSE | 2 +- Makefile | 105 + README.md | 152 + contrib/incbin.h | 379 + contrib/libsofd.c | 2413 ++ contrib/libsofd.h | 194 + contrib/md5.c | 289 + contrib/md5.h | 43 + contrib/stb_image_write.h | 1724 ++ disks/Games1MB.po | Bin 0 -> 1048576 bytes disks/dos33master.nib | 1 + disks/prodos242.dsk | Bin 0 -> 143360 bytes docs/Compiling.md | 33 + docs/screen_color.png | Bin 0 -> 636367 bytes docs/screen_green.png | Bin 0 -> 285944 bytes docs/screen_main.png | Bin 0 -> 521714 bytes docs/screen_mish.png | Bin 0 -> 83093 bytes docs/screen_total.png | Bin 0 -> 214691 bytes fonts/DroidSans.ttf | Bin 0 -> 190044 bytes fonts/FreeLicense.txt | 20 + fonts/PRNumber3.ttf | Bin 0 -> 501900 bytes fonts/PrintChar21.ttf | Bin 0 -> 501992 bytes fonts/ProggyClean.ttf | Bin 0 -> 41208 bytes libmish/.gitignore | 2 + libmish/LICENSE-2.0.txt | 202 + libmish/Makefile | 98 + libmish/Makefile.common | 97 + libmish/README.md | 111 + libmish/doc/Makefile | 21 + libmish/doc/demo.gif | Bin 0 -> 1432512 bytes libmish/doc/libmish_callgraph.pdf | Bin 0 -> 21786 bytes libmish/doc/tags_to_dot.rb | 99 + libmish/mish.pc | 13 + libmish/src/bsd_queue.h | 860 + libmish/src/fifo_declare.h | 211 + libmish/src/minipt.h | 138 + libmish/src/mish.h | 113 + libmish/src/mish_capture_select.c | 86 + libmish/src/mish_client.c | 384 + libmish/src/mish_client_input.c | 233 + libmish/src/mish_cmd.c | 307 + libmish/src/mish_cmd_env.c | 72 + libmish/src/mish_input.c | 139 + libmish/src/mish_line.c | 59 + libmish/src/mish_priv.h | 273 + libmish/src/mish_priv_cmd.h | 37 + libmish/src/mish_priv_line.h | 47 + libmish/src/mish_priv_vt.h | 48 + libmish/src/mish_send.c | 200 + libmish/src/mish_session.c | 282 + libmish/src/mish_telnet.c | 241 + libmish/src/mish_vt.c | 105 + libmish/tests/mish_argv_make_test.c | 95 + libmish/tests/mish_cmd_test.c | 20 + libmish/tests/mish_debug_test.c | 94 + libmish/tests/mish_input_test.c | 146 + libmish/tests/mish_test.c | 43 + libmish/tests/mish_vt_test.c | 33 + nuklear/mii_emu.c | 322 + nuklear/mii_fonts.c | 9 + nuklear/mii_mish.c | 436 + nuklear/mii_mish_dd.c | 46 + nuklear/mii_nuklear.c | 626 + nuklear/mii_stb_implement.c | 22 + nuklear/nuklear.h | 30034 +++++++++++++++++++++ nuklear/nuklear_xlib_gl3.h | 756 + src/drivers/mii_disk2.c | 379 + src/drivers/mii_disk2.h | 9 + src/drivers/mii_epromcard.c | 89 + src/drivers/mii_mouse.c | 187 + src/drivers/mii_mouse.h | 21 + src/drivers/mii_noslotclock.c | 177 + src/drivers/mii_smartport.c | 342 + src/drivers/mii_titan_iie.c | 79 + src/format/dsk.c | 472 + src/format/empty.c | 36 + src/format/mii_dd.c | 399 + src/format/mii_dd.h | 124 + src/format/mii_disk_format.c | 95 + src/format/mii_disk_format.h | 35 + src/format/nib.c | 100 + src/mii.c | 714 + src/mii.h | 274 + src/mii_65c02.c | 581 + src/mii_65c02.h | 88 + src/mii_65c02_asm.c | 503 + src/mii_65c02_asm.h | 47 + src/mii_65c02_disasm.c | 124 + src/mii_65c02_disasm.h | 24 + src/mii_65c02_ops.h | 308 + src/mii_argv.c | 199 + src/mii_bank.c | 105 + src/mii_bank.h | 81 + src/mii_slot.c | 86 + src/mii_slot.h | 74 + src/mii_speaker.c | 212 + src/mii_speaker.h | 58 + src/mii_sw.h | 59 + src/mii_video.c | 415 + src/mii_video.h | 55 + src/roms/mii_rom_disk2.h | 26 + src/roms/mii_rom_iiee.h | 1370 + src/roms/mii_rom_iiee_video.h | 346 + test/asm/001_jmp_indirect.asm | 17 + test/asm/002_jsr_rts.asm | 25 + test/asm/003_zp_addressing.asm | 49 + test/asm/004_adc_sbc.asm | 31 + test/asm/6502_functional_test.bin | Bin 0 -> 65536 bytes test/asm/65C02_extended_opcodes_test.bin | Bin 0 -> 65536 bytes test/asm/mii_smartport_driver.asm | 100 + test/asm/mii_smartport_driver.bin | Bin 0 -> 256 bytes test/mii_asm.c | 83 + test/mii_cpu_test.c | 521 + test/mii_test.c | 61 + utils/clangd_gen.sh | 57 + 116 files changed, 51755 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 contrib/incbin.h create mode 100644 contrib/libsofd.c create mode 100644 contrib/libsofd.h create mode 100644 contrib/md5.c create mode 100644 contrib/md5.h create mode 100644 contrib/stb_image_write.h create mode 100644 disks/Games1MB.po create mode 100644 disks/dos33master.nib create mode 100644 disks/prodos242.dsk create mode 100644 docs/Compiling.md create mode 100644 docs/screen_color.png create mode 100644 docs/screen_green.png create mode 100644 docs/screen_main.png create mode 100644 docs/screen_mish.png create mode 100644 docs/screen_total.png create mode 100644 fonts/DroidSans.ttf create mode 100644 fonts/FreeLicense.txt create mode 100644 fonts/PRNumber3.ttf create mode 100644 fonts/PrintChar21.ttf create mode 100644 fonts/ProggyClean.ttf create mode 100644 libmish/.gitignore create mode 100644 libmish/LICENSE-2.0.txt create mode 100644 libmish/Makefile create mode 100644 libmish/Makefile.common create mode 100644 libmish/README.md create mode 100644 libmish/doc/Makefile create mode 100644 libmish/doc/demo.gif create mode 100644 libmish/doc/libmish_callgraph.pdf create mode 100755 libmish/doc/tags_to_dot.rb create mode 100644 libmish/mish.pc create mode 100644 libmish/src/bsd_queue.h create mode 100644 libmish/src/fifo_declare.h create mode 100644 libmish/src/minipt.h create mode 100644 libmish/src/mish.h create mode 100644 libmish/src/mish_capture_select.c create mode 100644 libmish/src/mish_client.c create mode 100644 libmish/src/mish_client_input.c create mode 100644 libmish/src/mish_cmd.c create mode 100644 libmish/src/mish_cmd_env.c create mode 100644 libmish/src/mish_input.c create mode 100644 libmish/src/mish_line.c create mode 100644 libmish/src/mish_priv.h create mode 100644 libmish/src/mish_priv_cmd.h create mode 100644 libmish/src/mish_priv_line.h create mode 100644 libmish/src/mish_priv_vt.h create mode 100644 libmish/src/mish_send.c create mode 100644 libmish/src/mish_session.c create mode 100644 libmish/src/mish_telnet.c create mode 100644 libmish/src/mish_vt.c create mode 100644 libmish/tests/mish_argv_make_test.c create mode 100644 libmish/tests/mish_cmd_test.c create mode 100644 libmish/tests/mish_debug_test.c create mode 100644 libmish/tests/mish_input_test.c create mode 100644 libmish/tests/mish_test.c create mode 100644 libmish/tests/mish_vt_test.c create mode 100644 nuklear/mii_emu.c create mode 100644 nuklear/mii_fonts.c create mode 100644 nuklear/mii_mish.c create mode 100644 nuklear/mii_mish_dd.c create mode 100644 nuklear/mii_nuklear.c create mode 100644 nuklear/mii_stb_implement.c create mode 100644 nuklear/nuklear.h create mode 100644 nuklear/nuklear_xlib_gl3.h create mode 100644 src/drivers/mii_disk2.c create mode 100644 src/drivers/mii_disk2.h create mode 100644 src/drivers/mii_epromcard.c create mode 100644 src/drivers/mii_mouse.c create mode 100644 src/drivers/mii_mouse.h create mode 100644 src/drivers/mii_noslotclock.c create mode 100644 src/drivers/mii_smartport.c create mode 100644 src/drivers/mii_titan_iie.c create mode 100644 src/format/dsk.c create mode 100644 src/format/empty.c create mode 100644 src/format/mii_dd.c create mode 100644 src/format/mii_dd.h create mode 100644 src/format/mii_disk_format.c create mode 100644 src/format/mii_disk_format.h create mode 100644 src/format/nib.c create mode 100644 src/mii.c create mode 100644 src/mii.h create mode 100644 src/mii_65c02.c create mode 100644 src/mii_65c02.h create mode 100644 src/mii_65c02_asm.c create mode 100644 src/mii_65c02_asm.h create mode 100644 src/mii_65c02_disasm.c create mode 100644 src/mii_65c02_disasm.h create mode 100644 src/mii_65c02_ops.h create mode 100644 src/mii_argv.c create mode 100644 src/mii_bank.c create mode 100644 src/mii_bank.h create mode 100644 src/mii_slot.c create mode 100644 src/mii_slot.h create mode 100644 src/mii_speaker.c create mode 100644 src/mii_speaker.h create mode 100644 src/mii_sw.h create mode 100644 src/mii_video.c create mode 100644 src/mii_video.h create mode 100644 src/roms/mii_rom_disk2.h create mode 100644 src/roms/mii_rom_iiee.h create mode 100644 src/roms/mii_rom_iiee_video.h create mode 100644 test/asm/001_jmp_indirect.asm create mode 100644 test/asm/002_jsr_rts.asm create mode 100644 test/asm/003_zp_addressing.asm create mode 100644 test/asm/004_adc_sbc.asm create mode 100644 test/asm/6502_functional_test.bin create mode 100644 test/asm/65C02_extended_opcodes_test.bin create mode 100644 test/asm/mii_smartport_driver.asm create mode 100644 test/asm/mii_smartport_driver.bin create mode 100644 test/mii_asm.c create mode 100644 test/mii_cpu_test.c create mode 100644 test/mii_test.c create mode 100644 utils/clangd_gen.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..89c2e1e --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.bash_history +build-* +.vscode +compile_commands.json diff --git a/LICENSE b/LICENSE index 5758acc..92a8418 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2023 Michel Pollet +Copyright (c) 2023 Michel Pollet Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..fe9befb --- /dev/null +++ b/Makefile @@ -0,0 +1,105 @@ + +# GCC is default -- simply because it's faster! +CC = gcc +SHELL = /bin/bash +# This is where (g)make looks for the source files for implicit rules +VPATH := src src/format src/drivers nuklear contrib + +CPPFLAGS += -Isrc -Isrc/format -Isrc/roms -Isrc/drivers +CPPFLAGS += -Icontrib -Inuklear +CPPFLAGS += -Ilibmish/src +CFLAGS += --std=gnu99 -Wall -Wextra -O2 -g +CFLAGS += -Wno-unused-parameter -Wno-unused-function +LDLIBS += -lX11 -lm -lGL -lGLU + +HAS_ALSA := $(shell pkg-config --exists alsa && echo 1) +ifeq ($(HAS_ALSA),1) +LDLIBS += $(shell pkg-config --libs alsa) +CPPFLAGS += $(shell pkg-config --cflags alsa) -DHAS_ALSA +else +${warning ALSA not found, no sound support} +endif + +O := build-$(shell $(CC) -dumpmachine) +BIN := $(O)/bin +LIB := $(O)/lib +OBJ := $(O)/obj + +all : $(BIN)/mii_emu + +MII_SRC := $(wildcard src/*.c src/format/*.c \ + src/drivers/*.c contrib/*.c) +UI_SRC := $(wildcard nuklear/*.c) +SRC := $(MII_SRC) $(UI_SRC) +ALL_OBJ := ${patsubst %, ${OBJ}/%, ${notdir ${SRC:.c=.o}}} + +$(BIN)/mii_emu : $(ALL_OBJ) +$(BIN)/mii_emu : $(LIB)/libmish.a + +libmish : $(LIB)/libmish.a +LDLIBS += $(LIB)/libmish.a +$(LIB)/libmish.a : | $(LIB) $(OBJ) $(BIN) + make -j -C libmish O=$(PWD) + +# Smartport firmware needs the assembler first +test/asm/%.bin : test/asm/%.asm | $(BIN)/mii_asm + $(BIN)/mii_asm -v -o $@ $< +# And it also INCBIN the firmware driver +$(OBJ)/mii_smarport.o : test/asm/mii_smartport_driver.bin + +$(OBJ)/libsofd.o : CPPFLAGS += -DHAVE_X11 + +clean : + rm -rf $(O) + +# This is for development purpose. This will recompile the project +# everytime a file is modified. +watch : + while true; do \ + clear; $(MAKE) -j all tests; \ + inotifywait -qre close_write src src/format nuklear test; \ + done + +tests : $(BIN)/mii_test $(BIN)/mii_cpu_test $(BIN)/mii_asm + +# Just the library for mii, not any of the UI stuff +TEST_OBJ := ${patsubst %, ${OBJ}/%, ${notdir ${MII_SRC:.c=.o}}} +VPATH += test +# Base test without the UI, for performance testing +$(BIN)/mii_test : $(TEST_OBJ) +$(BIN)/mii_test : $(OBJ)/mii_test.o $(OBJ)/mii_mish.o +$(OBJ)/mii_test.o : CFLAGS += -O0 -Og + +$(OBJ)/mii_cpu_test.o : CFLAGS += -O0 -Og +$(BIN)/mii_cpu_test : $(OBJ)/mii_cpu_test.o $(TEST_OBJ) + +$(BIN)/mii_asm : $(OBJ)/mii_asm.o $(TEST_OBJ) + +ifeq ($(V),1) +Q := +else +Q := @ +endif + +$(OBJ)/%.o : %.c | $(OBJ) + @echo " CC $<" + $(Q)$(CC) -MMD $(CPPFLAGS) $(CFLAGS) -c -o $@ $< + +$(BIN)/% : | $(BIN) + @echo " LD $@" + $(Q)$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) + +$(OBJ) $(BIN) $(LIB) : + @mkdir -p $@ + +# Generates the necessary file to help clangd index the files properly. +# This currently has to be done manually, but helps a lot if you use 'kate' +# editor or anthing else that is compatible with the LSP protocol +compile_commands.json: lsp +lsp: + { $$(which gmake) CC=gcc V=1 --always-make --dry-run all tests; \ + $$(which gmake) CC=gcc V=1 --always-make --dry-run -C libmish ; } | \ + sh utils/clangd_gen.sh >compile_commands.json + +-include $(O)/*.d +-include $(O)/obj/*.d diff --git a/README.md b/README.md new file mode 100644 index 0000000..7fc16b7 --- /dev/null +++ b/README.md @@ -0,0 +1,152 @@ +# MII Apple //e Emulator + +I know there are many out there, but none of them were ticking my fancy, so I decide to write my own. To start with it was "How hard can it be really?" then it snowballed as more and more things were fixed & added. It's been shelved for a while because well, it lacked documentation, headers, licence and stuff, so I spent some time cleaning it up for release. + +One primary reason for this project was that linapple (or -pie) codebase is really horrible. It dates back from 2000's or before, with loads of Windows crud leftover, some SDL crud added, the audio just doesn't really work, and overall if you want to hack around the codebase, it's pretty dreadful. + + +![Monochrome Double-Hi res](docs/screen_main.png) +*Double hires in monochrome* + +I wanted something: + +* Modern, Clean code, modular -- in the spirit of simavr, usable as a library. +* Made for linux. In C. With a Makefile. None of the trendy bloatware. +* Small, Fast. +* Minimal dependencies. +* No gigantic config file. +* I didn't need II+ or unenhanced IIe, just 65c02 //e. + + +![Glorious NTSC colors](docs/screen_color.png) +*Double hires in color* + +## What can it do? + * 65c02 //e with 128K of ram. + * Support all known graphic modes: + * Double-hires in mono and color, with automatic switch + * All the other modes in color/mono + * Color, Green, Amber rendering + * Simulated 'scanlines' to make it look vintage + * Speaker audio. ALSA For playback. + * Adds a small 'attack' filter when playing back to soften the often annoying 'click' of typical audio effects from the apple II. + * Mouse Card -- mouse isn't captured like in some other emulators. + * No Slot Clock + * Smartport DMA 'hard drive' card + * "Titan Accelerator //e" simulation, to turn on/off fast mode. + * Terence's J Boldt [1MB ROM card](https://github.com/tjboldt/ProDOS-ROM-Drive), also because I own a couple! + * Floppy Drive [more on that later] + * No dependencies (X11) OpenGL rendering, using Nuklear backend for UI + +![Phosphorescent Green](docs/screen_green.png) +*Good old green monitor style. Theres Amber too.* + +## How to I compile it and run it? + * You need a C compiler, make, and a few libraries: + * libasound2-dev [ optional, for audio ] + * libgl-dev + * libglu-dev + * libx11-dev + * Many of them will probably be installed already. + * For more details on development, see [Compiling](docs/Compiling.md) + * Then just type `make` and it should compile. + * To run it, just type `build-x86_64-linux-gnu/bin/bin/mii_emu` and it should start. + * `mii_emu --help` will display: + + Usage: ./build-x86_64-linux-gnu/bin/mii_emu [options] + Options: + -h, --help This help + -v, --verbose Verbose output + -m, --mute Mute the speaker + -vol, --volume Set speaker volume (0.0 to 10.0) + -speed, --speed Set the CPU speed in MHz + -s, --slot : Specify a slot and driver + Slot id is 1..7 + -d, --drive :: Specify a drive + Slot id is 1..7, drive is 1..2 + Alternate syntax: : + -L, --list-drivers List available drivers + -def, --default Set default drives: + Slot 4: mouse + Slot 6: disk2 + Slot 7: smartport + -nsc[=0|1] Enable/Disable No Slot Clock: + 0: disable + 1: enable [Enabled by default] + -titan[=0|1] Enable/Disable Titan Accelerator IIe: + 0: disable [default] + 1: enable [Start at 3.58MHz] + And the available drivers: + + $ ./build-x86_64-linux-gnu/bin/mii_emu -L + mii: available drivers: + titan - Titan Accelerator IIe + smartport - SmartPort card + nsc - No Slot Clock + mouse - Mouse card + eecard - EEPROM 1MB card + disk2 - Apple Disk ][ + +## Key Bindings +There are just a few keys that are mapped for anything useful. + * **Control-F12** is Control-Reset on the IIe. (**Shift-Control-F12** is **Open Apple-Reset**) + * **'Super'** left and **'Super'** right are **Open** and **Close Apple** keys. + These keys are mapped to the left and right 'Windows' keys on a PC keyboard, and they might want to open the start menu (I know it's the case with Cinnamon), so you might want to disable that. + * **F5** sets the CPU speed to 1MHz + * **F6** to 4MHz. + * These keys control the built-in debugger: + * **Control-F11** Stops the emulator; see the command prompt/telnet for how to proceed, dump state, disassembly etc. + * **Control-F10** 'steps' the emulator, ie one instruction at a time. + * **Control-F9** is 'continue' -- resumes the emulator. + + +![Telnet into mii_emu](docs/screen_mish.png) +*The built-in shell, telnet into the emulator!* + +## Anything else? + * Well it has it's own command line shell, using my own [libmish](https://github.com/buserror/libmish) so there's loads you can do by... *telnet into* the emulator! + * Yes, you can telnet into the running emulator! + + The telnet port is displayed in the window title bar. + + The port is 'semi random' -- it tries to find one that is derivative of the program name, but it will try several until it finds one that is free. + * It has it's own debugger shell. You can: + + Add break/watch points. + + Step, Next (jump over JSR's), Continue, Halt + + Has a 16 instruction trace history when hitting a breakpoint. + + Dump memory map + + Trigger soft switches + + Disassemble + * Also MII comes with it's own mini-assembler, used to compile some driver and the CPU unit tests (inspired by apple2ts, see bellow) + * It embeds all the files it needs, ROMs, fonts etc so you don't need to install it, just run it, it'll work. + * MII "Hard Disk" uses 'overlay' files: + + This writes blocks on a /separate/ (sparse) file from the main file. + + This "Overlay" is created automatically and allows you to keep your image files clean, unless you want to 'commit' your overlay back in. + + This allows you to make sure your disk images aren't corrupted when 'hard rebooting' the emulator, if you are in the process of testing/developing a program for example. + +## What it cannot do + * MouseCalc crashes (VBL IRQ, or a mouse mode I don't support yet) + * A2Desktop PT3 player doesn't see keypresses. + * Sometimes the emulator goes in 'slow mode', ie 0.2MHz. Likely the frame scheduler playing up. + * Thats' about it really, all the other things I tried work + +## What it could do with + * Not sure about keeping Nuklear, it does a lot bit it's hard work customizing anything + * Add a memory extension 'card' -- not sure why, but hey, why not. + * Joystick support. As soon as I find a USB joystick that vaguely looks retro, I'll get one. + * The main window is 1280x720 on purpose, so it could do Full Screen. + * Port it to Raspbery Pi. I don't expect compiling issues, just video issues with GLes + * Make a tool to 'flatten' overlay files back into the primary image. + * Some sort of UI to select/eject disks. + + +![Total Replay](docs/screen_total.png) +*Obligatory View of [Total Replay](https://github.com/a2-4am/4cade), from legend [4am](https://github.com/a2-4am)* +## Inspiration, Licence etc + * MIT Licence, I think this is the most permissive, and this work is a derivative and has a lot of inpsiration from too many projects to claim anything more restrictive. + * The CPU Emulation was inspired by a few other implementations: + * [Chips](https://github.com/floooh/chips) -- which I used for a little while, but it was a pain to add the 65c02 instructions, and it had stuff I didn't want/need like 6510 emulation. + * [Apple2ts](https://github.com/ct6502/apple2ts/) -- In fact I converted a few bits from there; and I got the idea for the built-in assember from there, and some of the unit tests, AND the Smartport driver emulation idea! + * Other bits were inspired by: + * [bobbin](https://github.com/micahcowan/bobbin) which is newish as well, and is great for text mode, but I didn't like the fact its' all globals etc. I still borrowed the Floppy emulation from there, until I get around to do one. + * [isapple2](https://github.com/ivanizag/izapple2/) for other bits and pieces. + * And of course, countless books, articles and posts read over the last 40 years! + diff --git a/contrib/incbin.h b/contrib/incbin.h new file mode 100644 index 0000000..1fb4add --- /dev/null +++ b/contrib/incbin.h @@ -0,0 +1,379 @@ +/** + * @file incbin.h + * @author Dale Weiler + * @brief Utility for including binary files + * + * Facilities for including binary files into the current translation unit and + * making use from them externally in other translation units. + */ +#ifndef INCBIN_HDR +#define INCBIN_HDR +#include + +// Michel addition: +// Allow the included file to have an extra zero, to include text files +// as plain zero terminated strings +#ifdef INCBIN_TRAILING_ZERO +#define INCBIN_TRAIL INCBIN_BYTE "0\n" +#else +#define INCBIN_TRAIL +#endif + +#if defined(__AVX512BW__) || \ + defined(__AVX512CD__) || \ + defined(__AVX512DQ__) || \ + defined(__AVX512ER__) || \ + defined(__AVX512PF__) || \ + defined(__AVX512VL__) || \ + defined(__AVX512F__) +# define INCBIN_ALIGNMENT_INDEX 6 +#elif defined(__AVX__) || \ + defined(__AVX2__) +# define INCBIN_ALIGNMENT_INDEX 5 +#elif defined(__SSE__) || \ + defined(__SSE2__) || \ + defined(__SSE3__) || \ + defined(__SSSE3__) || \ + defined(__SSE4_1__) || \ + defined(__SSE4_2__) || \ + defined(__neon__) +# define INCBIN_ALIGNMENT_INDEX 4 +#elif ULONG_MAX != 0xffffffffu +# define INCBIN_ALIGNMENT_INDEX 3 +# else +# define INCBIN_ALIGNMENT_INDEX 2 +#endif + +/* Lookup table of (1 << n) where `n' is `INCBIN_ALIGNMENT_INDEX' */ +#define INCBIN_ALIGN_SHIFT_0 1 +#define INCBIN_ALIGN_SHIFT_1 2 +#define INCBIN_ALIGN_SHIFT_2 4 +#define INCBIN_ALIGN_SHIFT_3 8 +#define INCBIN_ALIGN_SHIFT_4 16 +#define INCBIN_ALIGN_SHIFT_5 32 +#define INCBIN_ALIGN_SHIFT_6 64 + +/* Actual alignment value */ +#define INCBIN_ALIGNMENT \ + INCBIN_CONCATENATE( \ + INCBIN_CONCATENATE(INCBIN_ALIGN_SHIFT, _), \ + INCBIN_ALIGNMENT_INDEX) + +/* Stringize */ +#define INCBIN_STR(X) \ + #X +#define INCBIN_STRINGIZE(X) \ + INCBIN_STR(X) +/* Concatenate */ +#define INCBIN_CAT(X, Y) \ + X ## Y +#define INCBIN_CONCATENATE(X, Y) \ + INCBIN_CAT(X, Y) +/* Deferred macro expansion */ +#define INCBIN_EVAL(X) \ + X +#define INCBIN_INVOKE(N, ...) \ + INCBIN_EVAL(N(__VA_ARGS__)) + +/* Green Hills uses a different directive for including binary data */ +#if defined(__ghs__) +# if (__ghs_asm == 2) +# define INCBIN_MACRO ".file" +/* Or consider the ".myrawdata" entry in the ld file */ +# else +# define INCBIN_MACRO "\tINCBIN" +# endif +#else +# define INCBIN_MACRO ".incbin" +#endif + +#ifndef _MSC_VER +# define INCBIN_ALIGN \ + __attribute__((aligned(INCBIN_ALIGNMENT))) +#else +# define INCBIN_ALIGN __declspec(align(INCBIN_ALIGNMENT)) +#endif + +#if defined(__arm__) || /* GNU C and RealView */ \ + defined(__arm) || /* Diab */ \ + defined(_ARM) /* ImageCraft */ +# define INCBIN_ARM +#endif + +#ifdef __GNUC__ +/* Utilize .balign where supported */ +# define INCBIN_ALIGN_HOST ".balign " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n" +# define INCBIN_ALIGN_BYTE ".balign 1\n" +#elif defined(INCBIN_ARM) +/* + * On arm assemblers, the alignment value is calculated as (1 << n) where `n' is + * the shift count. This is the value passed to `.align' + */ +# define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT_INDEX) "\n" +# define INCBIN_ALIGN_BYTE ".align 0\n" +#else +/* We assume other inline assembler's treat `.align' as `.balign' */ +# define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n" +# define INCBIN_ALIGN_BYTE ".align 1\n" +#endif + +/* INCBIN_CONST is used by incbin.c generated files */ +#if defined(__cplusplus) +# define INCBIN_EXTERNAL extern "C" +# define INCBIN_CONST extern const +#else +# define INCBIN_EXTERNAL extern +# define INCBIN_CONST const +#endif + +/** + * @brief Optionally override the linker section into which data is emitted. + * + * @warning If you use this facility, you'll have to deal with platform-specific linker output + * section naming on your own + * + * Overriding the default linker output section, e.g for esp8266/Arduino: + * @code + * #define INCBIN_OUTPUT_SECTION ".irom.text" + * #include "incbin.h" + * INCBIN(Foo, "foo.txt"); + * // Data is emitted into program memory that never gets copied to RAM + * @endcode + */ +#if !defined(INCBIN_OUTPUT_SECTION) +# if defined(__APPLE__) +# define INCBIN_OUTPUT_SECTION ".const_data" +# else +# define INCBIN_OUTPUT_SECTION ".rodata" +# endif +#endif + +#if defined(__APPLE__) +/* The directives are different for Apple branded compilers */ +# define INCBIN_SECTION INCBIN_OUTPUT_SECTION "\n" +# define INCBIN_GLOBAL(NAME) ".globl " INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n" +# define INCBIN_INT ".long " +# define INCBIN_MANGLE "_" +# define INCBIN_BYTE ".byte " +# define INCBIN_TYPE(...) +#else +# define INCBIN_SECTION ".section " INCBIN_OUTPUT_SECTION "\n" +# define INCBIN_GLOBAL(NAME) ".global " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n" +# if defined(__ghs__) +# define INCBIN_INT ".word " +# else +# define INCBIN_INT ".int " +# endif +# if defined(__USER_LABEL_PREFIX__) +# define INCBIN_MANGLE INCBIN_STRINGIZE(__USER_LABEL_PREFIX__) +# else +# define INCBIN_MANGLE "" +# endif +# if defined(INCBIN_ARM) +/* On arm assemblers, `@' is used as a line comment token */ +# define INCBIN_TYPE(NAME) ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", %object\n" +# elif defined(__MINGW32__) || defined(__MINGW64__) +/* Mingw doesn't support this directive either */ +# define INCBIN_TYPE(NAME) +# else +/* It's safe to use `@' on other architectures */ +# define INCBIN_TYPE(NAME) ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", @object\n" +# endif +# define INCBIN_BYTE ".byte " +#endif + +/* List of style types used for symbol names */ +#define INCBIN_STYLE_CAMEL 0 +#define INCBIN_STYLE_SNAKE 1 + +/** + * @brief Specify the prefix to use for symbol names. + * + * By default this is `g', producing symbols of the form: + * @code + * #include "incbin.h" + * INCBIN(Foo, "foo.txt"); + * + * // Now you have the following symbols: + * // const unsigned char gFooData[]; + * // const unsigned char *const gFooEnd; + * // const unsigned int gFooSize; + * @endcode + * + * If however you specify a prefix before including: e.g: + * @code + * #define INCBIN_PREFIX incbin + * #include "incbin.h" + * INCBIN(Foo, "foo.txt"); + * + * // Now you have the following symbols instead: + * // const unsigned char incbinFooData[]; + * // const unsigned char *const incbinFooEnd; + * // const unsigned int incbinFooSize; + * @endcode + */ +#if !defined(INCBIN_PREFIX) +# define INCBIN_PREFIX g +#endif + +/** + * @brief Specify the style used for symbol names. + * + * Possible options are + * - INCBIN_STYLE_CAMEL "CamelCase" + * - INCBIN_STYLE_SNAKE "snake_case" + * + * Default option is *INCBIN_STYLE_CAMEL* producing symbols of the form: + * @code + * #include "incbin.h" + * INCBIN(Foo, "foo.txt"); + * + * // Now you have the following symbols: + * // const unsigned char FooData[]; + * // const unsigned char *const FooEnd; + * // const unsigned int FooSize; + * @endcode + * + * If however you specify a style before including: e.g: + * @code + * #define INCBIN_STYLE INCBIN_STYLE_SNAKE + * #include "incbin.h" + * INCBIN(foo, "foo.txt"); + * + * // Now you have the following symbols: + * // const unsigned char foo_data[]; + * // const unsigned char *const foo_end; + * // const unsigned int foo_size; + * @endcode + */ +#if !defined(INCBIN_STYLE) +# define INCBIN_STYLE INCBIN_STYLE_CAMEL +#endif + +/* Style lookup tables */ +#define INCBIN_STYLE_0_DATA Data +#define INCBIN_STYLE_0_END End +#define INCBIN_STYLE_0_SIZE Size +#define INCBIN_STYLE_1_DATA _data +#define INCBIN_STYLE_1_END _end +#define INCBIN_STYLE_1_SIZE _size + +/* Style lookup: returning identifier */ +#define INCBIN_STYLE_IDENT(TYPE) \ + INCBIN_CONCATENATE( \ + INCBIN_STYLE_, \ + INCBIN_CONCATENATE( \ + INCBIN_EVAL(INCBIN_STYLE), \ + INCBIN_CONCATENATE(_, TYPE))) + +/* Style lookup: returning string literal */ +#define INCBIN_STYLE_STRING(TYPE) \ + INCBIN_STRINGIZE( \ + INCBIN_STYLE_IDENT(TYPE)) \ + +/* Generate the global labels by indirectly invoking the macro with our style + * type and concatenating the name against them. */ +#define INCBIN_GLOBAL_LABELS(NAME, TYPE) \ + INCBIN_INVOKE( \ + INCBIN_GLOBAL, \ + INCBIN_CONCATENATE( \ + NAME, \ + INCBIN_INVOKE( \ + INCBIN_STYLE_IDENT, \ + TYPE))) \ + INCBIN_INVOKE( \ + INCBIN_TYPE, \ + INCBIN_CONCATENATE( \ + NAME, \ + INCBIN_INVOKE( \ + INCBIN_STYLE_IDENT, \ + TYPE))) + +/** + * @brief Externally reference binary data included in another translation unit. + * + * Produces three external symbols that reference the binary data included in + * another translation unit. + * + * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with + * "Data", as well as "End" and "Size" after. An example is provided below. + * + * @param NAME The name given for the binary data + * + * @code + * INCBIN_EXTERN(Foo); + * + * // Now you have the following symbols: + * // extern const unsigned char FooData[]; + * // extern const unsigned char *const FooEnd; + * // extern const unsigned int FooSize; + * @endcode + */ +#define INCBIN_EXTERN(NAME) \ + INCBIN_EXTERNAL const INCBIN_ALIGN unsigned char \ + INCBIN_CONCATENATE( \ + INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \ + INCBIN_STYLE_IDENT(DATA))[]; \ + INCBIN_EXTERNAL const INCBIN_ALIGN unsigned char *const \ + INCBIN_CONCATENATE( \ + INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \ + INCBIN_STYLE_IDENT(END)); \ + INCBIN_EXTERNAL const unsigned int \ + INCBIN_CONCATENATE( \ + INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \ + INCBIN_STYLE_IDENT(SIZE)) + +/** + * @brief Include a binary file into the current translation unit. + * + * Includes a binary file into the current translation unit, producing three symbols + * for objects that encode the data and size respectively. + * + * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with + * "Data", as well as "End" and "Size" after. An example is provided below. + * + * @param NAME The name to associate with this binary data (as an identifier.) + * @param FILENAME The file to include (as a string literal.) + * + * @code + * INCBIN(Icon, "icon.png"); + * + * // Now you have the following symbols: + * // const unsigned char IconData[]; + * // const unsigned char *const IconEnd; + * // const unsigned int IconSize; + * @endcode + * + * @warning This must be used in global scope + * @warning The identifiers may be different if INCBIN_STYLE is not default + * + * To externally reference the data included by this in another translation unit + * please @see INCBIN_EXTERN. + */ +#ifdef _MSC_VER +#define INCBIN(NAME, FILENAME) \ + INCBIN_EXTERN(NAME) +#else +#define INCBIN(NAME, FILENAME) \ + __asm__(INCBIN_SECTION \ + INCBIN_GLOBAL_LABELS(NAME, DATA) \ + INCBIN_ALIGN_HOST \ + INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) ":\n" \ + INCBIN_MACRO " \"" FILENAME "\"\n" \ + INCBIN_TRAIL \ + INCBIN_GLOBAL_LABELS(NAME, END) \ + INCBIN_ALIGN_BYTE \ + INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) ":\n" \ + INCBIN_BYTE "1\n" \ + INCBIN_GLOBAL_LABELS(NAME, SIZE) \ + INCBIN_ALIGN_HOST \ + INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(SIZE) ":\n" \ + INCBIN_INT INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) " - " \ + INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) "\n" \ + INCBIN_ALIGN_HOST \ + ".text\n" \ + ); \ + INCBIN_EXTERN(NAME) + +#endif +#endif diff --git a/contrib/libsofd.c b/contrib/libsofd.c new file mode 100644 index 0000000..f475b67 --- /dev/null +++ b/contrib/libsofd.c @@ -0,0 +1,2413 @@ +/* libSOFD - Simple Open File Dialog [for X11 without toolkit] + * + * Copyright (C) 2014 Robin Gareus + * + * 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. + */ + +/* Test and example: + * gcc -Wall -D SOFD_TEST -g -o sofd libsofd.c -lX11 + * + * public API documentation and example code at the bottom of this file + * + * This small lib may one day include openGL rendering and + * wayland window support, but not today. Today we celebrate + * 30 years of X11. + */ + +#ifdef SOFD_TEST +#define HAVE_X11 +#include "libsofd.h" +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// shared 'recently used' implementation +// sadly, xbel does not qualify as simple. +// hence we use a simple format alike the +// gtk-bookmark list (one file per line) + +#define MAX_RECENT_ENTRIES 24 +#define MAX_RECENT_AGE (15552000) // 180 days (in sec) + +typedef struct { + char path[1024]; + time_t atime; +} FibRecentFile; + +static FibRecentFile *_recentlist = NULL; +static unsigned int _recentcnt = 0; +static uint8_t _recentlock = 0; + +static int fib_isxdigit (const char x) { + if ( + (x >= '0' && x <= '9') + || + (x >= 'a' && x <= 'f') + || + (x >= 'A' && x <= 'F') + ) return 1; + return 0; +} + +static void decode_3986 (char *str) { + int len = strlen (str); + int idx = 0; + while (idx + 2 < len) { + char *in = &str[idx]; + if (('%' == *in) && fib_isxdigit (in[1]) && fib_isxdigit (in[2])) { + char hexstr[3]; + hexstr[0] = in[1]; + hexstr[1] = in[2]; + hexstr[2] = 0; + long hex = strtol (hexstr, NULL, 16); + *in = hex; + memmove (&str[idx+1], &str[idx + 3], len - idx - 2); + len -= 2; + } + ++idx; + } +} + +static char *encode_3986 (const char *str) { + size_t alloc, newlen; + char *ns = NULL; + unsigned char in; + size_t i = 0; + size_t length; + + if (!str) return strdup (""); + + alloc = strlen (str) + 1; + newlen = alloc; + + ns = (char*) malloc (alloc); + + length = alloc; + while (--length) { + in = *str; + + switch (in) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + case 'a': case 'b': case 'c': case 'd': case 'e': + case 'f': case 'g': case 'h': case 'i': case 'j': + case 'k': case 'l': case 'm': case 'n': case 'o': + case 'p': case 'q': case 'r': case 's': case 't': + case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': + case 'A': case 'B': case 'C': case 'D': case 'E': + case 'F': case 'G': case 'H': case 'I': case 'J': + case 'K': case 'L': case 'M': case 'N': case 'O': + case 'P': case 'Q': case 'R': case 'S': case 'T': + case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': + case '_': case '~': case '.': case '-': + case '/': case ',': // XXX not in RFC3986 + ns[i++] = in; + break; + default: + newlen += 2; /* this'll become a %XX */ + if (newlen > alloc) { + alloc *= 2; + ns = (char*) realloc (ns, alloc); + } + snprintf (&ns[i], 4, "%%%02X", in); + i += 3; + break; + } + ++str; + } + ns[i] = 0; + return ns; +} + +void x_fib_free_recent () { + free (_recentlist); + _recentlist = NULL; + _recentcnt = 0; +} + +static int cmp_recent (const void *p1, const void *p2) { + FibRecentFile *a = (FibRecentFile*) p1; + FibRecentFile *b = (FibRecentFile*) p2; + if (a->atime == b->atime) return 0; + return a->atime < b->atime; +} + +int x_fib_add_recent (const char *path, time_t atime) { + unsigned int i; + struct stat fs; + if (_recentlock) { return -1; } + if (access (path, R_OK)) { + return -1; + } + if (stat (path, &fs)) { + return -1; + } + if (!S_ISREG (fs.st_mode)) { + return -1; + } + if (atime == 0) atime = time (NULL); + if (MAX_RECENT_AGE > 0 && atime + MAX_RECENT_AGE < time (NULL)) { + return -1; + } + + for (i = 0; i < _recentcnt; ++i) { + if (!strcmp (_recentlist[i].path, path)) { + if (_recentlist[i].atime < atime) { + _recentlist[i].atime = atime; + } + qsort (_recentlist, _recentcnt, sizeof(FibRecentFile), cmp_recent); + return _recentcnt; + } + } + _recentlist = (FibRecentFile*)realloc (_recentlist, (_recentcnt + 1) * sizeof(FibRecentFile)); + _recentlist[_recentcnt].atime = atime; + strcpy (_recentlist[_recentcnt].path, path); + qsort (_recentlist, _recentcnt + 1, sizeof(FibRecentFile), cmp_recent); + + if (_recentcnt >= MAX_RECENT_ENTRIES) { + return (_recentcnt); + } + return (++_recentcnt); +} + +#ifdef PATHSEP +#undef PATHSEP +#endif + +#ifdef PLATFORM_WINDOWS +#define DIRSEP '\\' +#else +#define DIRSEP '/' +#endif + +static void mkpath(const char *dir) { + char tmp[1024]; + char *p; + size_t len; + + snprintf (tmp, sizeof(tmp), "%s", dir); + len = strlen(tmp); + if (tmp[len - 1] == '/') + tmp[len - 1] = 0; + for (p = tmp + 1; *p; ++p) + if(*p == DIRSEP) { + *p = 0; +#ifdef PLATFORM_WINDOWS + mkdir(tmp); +#else + mkdir(tmp, 0755); +#endif + *p = DIRSEP; + } +#ifdef PLATFORM_WINDOWS + mkdir(tmp); +#else + mkdir(tmp, 0755); +#endif +} + +int x_fib_save_recent (const char *fn) { + if (_recentlock) { return -1; } + if (!fn) { return -1; } + if (_recentcnt < 1 || !_recentlist) { return -1; } + unsigned int i; + char *dn = strdup (fn); + mkpath (dirname (dn)); + free (dn); + + FILE *rf = fopen (fn, "w"); + if (!rf) return -1; + + qsort (_recentlist, _recentcnt, sizeof(FibRecentFile), cmp_recent); + for (i = 0; i < _recentcnt; ++i) { + char *n = encode_3986 (_recentlist[i].path); + fprintf (rf, "%s %lu\n", n, _recentlist[i].atime); + free (n); + } + fclose (rf); + return 0; +} + +int x_fib_load_recent (const char *fn) { + char tmp[1024]; + if (_recentlock) { return -1; } + if (!fn) { return -1; } + x_fib_free_recent (); + if (access (fn, R_OK)) { + return -1; + } + FILE *rf = fopen (fn, "r"); + if (!rf) return -1; + while (fgets (tmp, sizeof(tmp), rf) + && strlen (tmp) > 1 + && strlen (tmp) < sizeof(tmp)) + { + char *s; + tmp[strlen (tmp) - 1] = '\0'; // strip newline + if (!(s = strchr (tmp, ' '))) { // find name <> atime sep + continue; + } + *s = '\0'; + time_t t = atol (++s); + decode_3986 (tmp); + x_fib_add_recent (tmp, t); + } + fclose (rf); + return 0; +} + +unsigned int x_fib_recent_count () { + return _recentcnt; +} + +const char *x_fib_recent_at (unsigned int i) { + if (i >= _recentcnt) + return NULL; + return _recentlist[i].path; +} + +#ifdef PLATFORM_WINDOWS +#define PATHSEP "\\" +#else +#define PATHSEP "/" +#endif + +const char *x_fib_recent_file(const char *appname) { + static char recent_file[1024]; + assert(!strchr(appname, '/')); + const char *xdg = getenv("XDG_DATA_HOME"); + if (xdg && (strlen(xdg) + strlen(appname) + 10) < sizeof(recent_file)) { + sprintf(recent_file, "%s" PATHSEP "%s" PATHSEP "recent", xdg, appname); + return recent_file; + } +#ifdef PLATFORM_WINDOWS + const char * homedrive = getenv("HOMEDRIVE"); + const char * homepath = getenv("HOMEPATH"); + if (homedrive && homepath && (strlen(homedrive) + strlen(homepath) + strlen(appname) + 29) < PATH_MAX) { + sprintf(recent_file, "%s%s" PATHSEP "Application Data" PATHSEP "%s" PATHSEP "recent.txt", homedrive, homepath, appname); + return recent_file; + } +#elif defined PLATFORM_OSX + const char *home = getenv("HOME"); + if (home && (strlen(home) + strlen(appname) + 29) < sizeof(recent_file)) { + sprintf(recent_file, "%s/Library/Preferences/%s/recent", home, appname); + return recent_file; + } +#else + const char *home = getenv("HOME"); + if (home && (strlen(home) + strlen(appname) + 22) < sizeof(recent_file)) { + sprintf(recent_file, "%s/.local/share/%s/recent", home, appname); + return recent_file; + } +#endif + return NULL; +} + +#ifdef HAVE_X11 +#include +#include + +#include +#include +#include +#include +#include + +#ifndef MIN +#define MIN(A,B) ( (A) < (B) ? (A) : (B) ) +#endif + +#ifndef MAX +#define MAX(A,B) ( (A) < (B) ? (B) : (A) ) +#endif + +static Window _fib_win = 0; +static GC _fib_gc = 0; +static XColor _c_gray0, _c_gray1, _c_gray2, _c_gray3, _c_gray4, _c_gray5, _c_gray6; +static Font _fibfont = 0; +static Pixmap _pixbuffer = None; + +static int _fib_width = 100; +static int _fib_height = 100; +static int _btn_w = 0; +static int _btn_span = 0; + +static int _fib_font_height = 0; +static int _fib_dir_indent = 0; +static int _fib_spc_norm = 0; +static int _fib_font_ascent = 0; +static int _fib_font_vsep = 0; +static int _fib_font_size_width = 0; +static int _fib_font_time_width = 0; +static int _fib_place_width = 0; + +static int _scrl_f = 0; +static int _scrl_y0 = -1; +static int _scrl_y1 = -1; +static int _scrl_my = -1; +static int _scrl_mf = -1; +static int _view_p = -1; + +static int _fsel = -1; +static int _hov_b = -1; +static int _hov_f = -1; +static int _hov_p = -1; +static int _hov_h = -1; +static int _hov_l = -1; +static int _hov_s = -1; +static int _sort = 0; +static int _columns = 0; +static int _fib_filter_fn = 1; +static int _fib_hidden_fn = 0; +static int _fib_show_places = 0; + +static uint8_t _fib_mapped = 0; +static uint8_t _fib_resized = 0; +static unsigned long _dblclk = 0; + +static int _status = -2; +static char _rv_open[1024] = ""; + +static char _fib_cfg_custom_places[1024] = ""; +static char _fib_cfg_custom_font[256] = ""; +static char _fib_cfg_title[128] = "xjadeo - Open Video File"; + +typedef struct { + char name[256]; + int x0; + int xw; +} FibPathButton; + +typedef struct { + char name[256]; + char strtime[32]; + char strsize[32]; + int ssizew; + off_t size; + time_t mtime; + uint8_t flags; // 2: selected, 4: isdir 8: recent-entry + FibRecentFile *rfp; +} FibFileEntry; + +typedef struct { + char text[24]; + uint8_t flags; // 2: selected, 4: toggle, 8 disable + int x0; + int tw; + int xw; + void (*callback)(Display*); +} FibButton; + +typedef struct { + char name[256]; + char path[1024]; + uint8_t flags; // 1: hover, 2: selected, 4:add sep +} FibPlace; + +static char _cur_path[1024] = ""; +static FibFileEntry *_dirlist = NULL; +static FibPathButton *_pathbtn = NULL; +static FibPlace *_placelist = NULL; +static int _dircount = 0; +static int _pathparts = 0; +static int _placecnt = 0; + +static FibButton _btn_ok; +static FibButton _btn_cancel; +static FibButton _btn_filter; +static FibButton _btn_places; +static FibButton _btn_hidden; +static FibButton *_btns[] = {&_btn_places, &_btn_filter, &_btn_hidden, &_btn_cancel, &_btn_ok}; + +static int (*_fib_filter_function)(const char *filename); + +/* hardcoded layout */ +#define DSEP 6 // px; horiz space beween elements, also l+r margin for file-list +#define PSEP 4 // px; horiz space beween paths +#define FILECOLUMN (17 * _fib_dir_indent) //px; min width of file-column +#define LISTTOP 2.7 //em; top of the file-browser list +#define LISTBOT 4.75 //em; bottom of the file-browers list +#define BTNBTMMARGIN 0.75 //em; height/margin of the button row +#define BTNPADDING 2 // px - only used for open/cancel buttons +#define SCROLLBARW (3 + (_fib_spc_norm&~1)) //px; - should be SCROLLBARW = (N * 2 + 3) +#define SCROLLBOXH 10 //px; arrow box top+bottom +#define PLACESW _fib_place_width //px; +#define PLACESWMAX (15 *_fib_spc_norm) //px; +#define PATHBTNTOP _fib_font_vsep //px; offset by (_fib_font_ascent); +#define FAREAMRGB 3 //px; base L+R margin +#define FAREAMRGR (FAREAMRGB + 1) //px; right margin of file-area + 1 (line width) +#define FAREAMRGL (_fib_show_places ? PLACESW + FAREAMRGB : FAREAMRGB) //px; left margin of file-area +#define TEXTSEP 4 //px; +#define FAREATEXTL (FAREAMRGL + TEXTSEP) //px; filename text-left FAREAMRGL + TEXTSEP +#define SORTBTNOFF -10 //px; + +#ifndef DBLCLKTME +#define DBLCLKTME 200 //msec; double click time +#endif + +#define DRAW_OUTLINE +#define DOUBLE_BUFFER + +static int query_font_geometry (Display *dpy, GC gc, const char *txt, int *w, int *h, int *a, int *d) { + XCharStruct text_structure; + int font_direction, font_ascent, font_descent; + XFontStruct *fontinfo = XQueryFont (dpy, XGContextFromGC (gc)); + + if (!fontinfo) { return -1; } + XTextExtents (fontinfo, txt, strlen (txt), &font_direction, &font_ascent, &font_descent, &text_structure); + if (w) *w = XTextWidth (fontinfo, txt, strlen (txt)); + if (h) *h = text_structure.ascent + text_structure.descent; + if (a) *a = text_structure.ascent; + if (d) *d = text_structure.descent; + XFreeFontInfo (NULL, fontinfo, 1); + return 0; +} + +static void VDrawRectangle (Display *dpy, Drawable d, GC gc, int x, int y, unsigned int w, unsigned int h) { + const unsigned long blackColor = BlackPixel (dpy, DefaultScreen (dpy)); +#ifdef DRAW_OUTLINE + XSetForeground (dpy, gc, _c_gray5.pixel); + XDrawLine (dpy, d, gc, x + 1, y + h, x + w, y + h); + XDrawLine (dpy, d, gc, x + w, y + 1, x + w, y + h); + + XSetForeground (dpy, gc, blackColor); + XDrawLine (dpy, d, gc, x + 1, y, x + w, y); + XDrawLine (dpy, d, gc, x, y + 1, x, y + h); +#else + XSetForeground (dpy, _fib_gc, blackColor); + XDrawRectangle (dpy, d, gc, x, y, w, h); +#endif +} + +static void fib_expose (Display *dpy, Window realwin) { + int i; + XID win; + const unsigned long whiteColor = WhitePixel (dpy, DefaultScreen (dpy)); + const unsigned long blackColor = BlackPixel (dpy, DefaultScreen (dpy)); + if (!_fib_mapped) return; + + if (_fib_resized +#ifdef DOUBLE_BUFFER + || !_pixbuffer +#endif + ) + { +#ifdef DOUBLE_BUFFER + unsigned int w = 0, h = 0; + if (_pixbuffer != None) { + Window ignored_w; + int ignored_i; + unsigned int ignored_u; + XGetGeometry(dpy, _pixbuffer, &ignored_w, &ignored_i, &ignored_i, &w, &h, &ignored_u, &ignored_u); + if (_fib_width != (int)w || _fib_height != (int)h) { + XFreePixmap (dpy, _pixbuffer); + _pixbuffer = None; + } + } + if (_pixbuffer == None) { + XWindowAttributes wa; + XGetWindowAttributes (dpy, realwin, &wa); + _pixbuffer = XCreatePixmap (dpy, realwin, _fib_width, _fib_height, wa.depth); + } +#endif + if (_pixbuffer != None) { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + XFillRectangle (dpy, _pixbuffer, _fib_gc, 0, 0, _fib_width, _fib_height); + } else { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + XFillRectangle (dpy, realwin, _fib_gc, 0, 0, _fib_width, _fib_height); + } + _fib_resized = 0; + } + + if (_pixbuffer == None) { + win = realwin; + } else { + win = _pixbuffer; + } + + // Top Row: dirs and up navigation + + int ppw = 0; + int ppx = FAREAMRGB; + + for (i = _pathparts - 1; i >= 0; --i) { + ppw += _pathbtn[i].xw + PSEP; + if (ppw >= _fib_width - PSEP - _pathbtn[0].xw - FAREAMRGB) break; // XXX, first change is from "/" to "<", NOOP + } + ++i; + // border-less "<" parent/up, IFF space is limited + if (i > 0) { + if (0 == _hov_p || (_hov_p > 0 && _hov_p < _pathparts - 1)) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + } else { + XSetForeground (dpy, _fib_gc, blackColor); + } + XDrawString (dpy, win, _fib_gc, ppx, PATHBTNTOP, "<", 1); + ppx += _pathbtn[0].xw + PSEP; + if (i == _pathparts) --i; + } + + _view_p = i; + + while (i < _pathparts) { + if (i == _hov_p) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray2.pixel); + } + XFillRectangle (dpy, win, _fib_gc, + ppx + 1, PATHBTNTOP - _fib_font_ascent, + _pathbtn[i].xw - 1, _fib_font_height); + VDrawRectangle (dpy, win, _fib_gc, + ppx, PATHBTNTOP - _fib_font_ascent, + _pathbtn[i].xw, _fib_font_height); + XDrawString (dpy, win, _fib_gc, ppx + 1 + BTNPADDING, PATHBTNTOP, + _pathbtn[i].name, strlen (_pathbtn[i].name)); + _pathbtn[i].x0 = ppx; // current position + ppx += _pathbtn[i].xw + PSEP; + ++i; + } + + // middle, scroll list of file names + const int ltop = LISTTOP * _fib_font_vsep; + const int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + const int fsel_height = 4 + llen * _fib_font_vsep; + const int fsel_width = _fib_width - FAREAMRGL - FAREAMRGR - (llen < _dircount ? SCROLLBARW : 0); + const int t_x = FAREATEXTL; + int t_s = FAREATEXTL + fsel_width; + int t_t = FAREATEXTL + fsel_width; + + // check which colums can be visible + // depending on available width of window. + _columns = 0; + if (fsel_width > FILECOLUMN + _fib_font_size_width + _fib_font_time_width) { + _columns |= 2; + t_s = FAREAMRGL + fsel_width - _fib_font_time_width - TEXTSEP; + } + if (fsel_width > FILECOLUMN + _fib_font_size_width) { + _columns |= 1; + t_t = t_s - _fib_font_size_width - TEXTSEP; + } + + int fstop = _scrl_f; // first entry in scroll position + const int ttop = ltop - _fib_font_height + _fib_font_ascent; + + if (fstop > 0 && fstop + llen > _dircount) { + fstop = MAX (0, _dircount - llen); + _scrl_f = fstop; + } + + // list header + XSetForeground (dpy, _fib_gc, _c_gray3.pixel); + XFillRectangle (dpy, win, _fib_gc, FAREAMRGL, ltop - _fib_font_vsep, fsel_width, _fib_font_vsep); + + // draw background of file list + XSetForeground (dpy, _fib_gc, _c_gray2.pixel); + XFillRectangle (dpy, win, _fib_gc, FAREAMRGL, ltop, fsel_width, fsel_height); + +#ifdef DRAW_OUTLINE + VDrawRectangle (dpy, win, _fib_gc, FAREAMRGL, ltop - _fib_font_vsep -1, _fib_width - FAREAMRGL - FAREAMRGR, fsel_height + _fib_font_vsep + 1); +#endif + + switch (_hov_h) { + case 1: + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + XFillRectangle (dpy, win, _fib_gc, t_x + _fib_dir_indent - TEXTSEP + 1, ltop - _fib_font_vsep, t_t - t_x - _fib_dir_indent - 1, _fib_font_vsep); + break; + case 2: + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + XFillRectangle (dpy, win, _fib_gc, t_t - TEXTSEP + 1, ltop - _fib_font_vsep, _fib_font_size_width + TEXTSEP - 1, _fib_font_vsep); + break; + case 3: + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + XFillRectangle (dpy, win, _fib_gc, t_s - TEXTSEP + 1, ltop - _fib_font_vsep, TEXTSEP + TEXTSEP + _fib_font_time_width - 1, _fib_font_vsep); + break; + default: + break; + } + + // column headings and sort order + int arp = MAX (2, _fib_font_height / 5); // arrow scale + const int trioff = _fib_font_height - _fib_font_ascent - arp + 1; + XPoint ptri[4] = { {0, ttop - trioff }, {arp, -arp - arp - 1}, {-arp - arp, 0}, {arp, arp + arp + 1}}; + if (_sort & 1) { + ptri[0].y = ttop -arp - arp - 1; + ptri[1].y *= -1; + ptri[3].y *= -1; + } + switch (_sort) { + case 0: + case 1: + ptri[0].x = t_t + SORTBTNOFF + 2 - arp; + XSetForeground (dpy, _fib_gc, _c_gray6.pixel); + XFillPolygon (dpy, win, _fib_gc, ptri, 3, Convex, CoordModePrevious); + XDrawLines (dpy, win, _fib_gc, ptri, 4, CoordModePrevious); + break; + case 2: + case 3: + if (_columns & 1) { + ptri[0].x = t_s + SORTBTNOFF + 2 - arp; + XSetForeground (dpy, _fib_gc, _c_gray6.pixel); + XFillPolygon (dpy, win, _fib_gc, ptri, 3, Convex, CoordModePrevious); + XDrawLines (dpy, win, _fib_gc, ptri, 4, CoordModePrevious); + } + break; + case 4: + case 5: + if (_columns & 2) { + ptri[0].x = FAREATEXTL + fsel_width + SORTBTNOFF + 2 - arp; + XSetForeground (dpy, _fib_gc, _c_gray6.pixel); + XFillPolygon (dpy, win, _fib_gc, ptri, 3, Convex, CoordModePrevious); + XDrawLines (dpy, win, _fib_gc, ptri, 4, CoordModePrevious); + } + break; + } + +#if 0 // bottom header bottom border + XSetForeground (dpy, _fib_gc, _c_gray5.pixel); + XSetLineAttributes (dpy, _fib_gc, 1, LineOnOffDash, CapButt, JoinMiter); + XDrawLine (dpy, win, _fib_gc, + FAREAMRGL + 1, ltop, + FAREAMRGL + fsel_width, ltop); + XSetLineAttributes (dpy, _fib_gc, 1, LineSolid, CapButt, JoinMiter); +#endif + + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + XDrawLine (dpy, win, _fib_gc, + t_x + _fib_dir_indent - TEXTSEP, ltop - _fib_font_vsep + 3, + t_x + _fib_dir_indent - TEXTSEP, ltop - 3); + + XSetForeground (dpy, _fib_gc, blackColor); + XDrawString (dpy, win, _fib_gc, t_x + _fib_dir_indent, ttop, "Name", 4); + + if (_columns & 1) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + XDrawLine (dpy, win, _fib_gc, + t_t - TEXTSEP, ltop - _fib_font_vsep + 3, + t_t - TEXTSEP, ltop - 3); + XSetForeground (dpy, _fib_gc, blackColor); + XDrawString (dpy, win, _fib_gc, t_t, ttop, "Size", 4); + } + + if (_columns & 2) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + XDrawLine (dpy, win, _fib_gc, + t_s - TEXTSEP, ltop - _fib_font_vsep + 3, + t_s - TEXTSEP, ltop - 3); + XSetForeground (dpy, _fib_gc, blackColor); + if (_pathparts > 0) + XDrawString (dpy, win, _fib_gc, t_s, ttop, "Last Modified", 13); + else + XDrawString (dpy, win, _fib_gc, t_s, ttop, "Last Used", 9); + } + + // scrollbar sep + if (llen < _dircount) { + const int sx0 = _fib_width - SCROLLBARW - FAREAMRGR; + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + XDrawLine (dpy, win, _fib_gc, + sx0 - 1, ltop - _fib_font_vsep, +#ifdef DRAW_OUTLINE + sx0 - 1, ltop + fsel_height +#else + sx0 - 1, ltop - 1 +#endif + ); + } + + // clip area for file-name + XRectangle clp = {FAREAMRGL + 1, ltop, t_t - FAREAMRGL - TEXTSEP - TEXTSEP - 1, fsel_height}; + + // list files in view + for (i = 0; i < llen; ++i) { + const int j = i + fstop; + if (j >= _dircount) break; + + const int t_y = ltop + (i+1) * _fib_font_vsep - 4; + + XSetForeground (dpy, _fib_gc, blackColor); + if (_dirlist[j].flags & 2) { + XSetForeground (dpy, _fib_gc, blackColor); + XFillRectangle (dpy, win, _fib_gc, + FAREAMRGL, t_y - _fib_font_ascent, fsel_width, _fib_font_height); + XSetForeground (dpy, _fib_gc, whiteColor); + } + if (_hov_f == j && !(_dirlist[j].flags & 2)) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + } + if (_dirlist[j].flags & 4) { + XDrawString (dpy, win, _fib_gc, t_x, t_y, "D", 1); + } + XSetClipRectangles (dpy, _fib_gc, 0, 0, &clp, 1, Unsorted); + XDrawString (dpy, win, _fib_gc, + t_x + _fib_dir_indent, t_y, + _dirlist[j].name, strlen (_dirlist[j].name)); + XSetClipMask (dpy, _fib_gc, None); + + if (_columns & 1) // right-aligned 'size' + XDrawString (dpy, win, _fib_gc, + t_s - TEXTSEP - 2 - _dirlist[j].ssizew, t_y, + _dirlist[j].strsize, strlen (_dirlist[j].strsize)); + if (_columns & 2) + XDrawString (dpy, win, _fib_gc, + t_s, t_y, + _dirlist[j].strtime, strlen (_dirlist[j].strtime)); + } + + // scrollbar + if (llen < _dircount) { + float sl = (fsel_height + _fib_font_vsep - (SCROLLBOXH + SCROLLBOXH)) / (float) _dircount; + sl = MAX ((8. / llen), sl); // 8px min height of scroller + const int sy1 = llen * sl; + const float mx = (fsel_height + _fib_font_vsep - (SCROLLBOXH + SCROLLBOXH) - sy1) / (float)(_dircount - llen); + const int sy0 = fstop * mx; + const int sx0 = _fib_width - SCROLLBARW - FAREAMRGR; + const int stop = ltop - _fib_font_vsep; + + _scrl_y0 = stop + SCROLLBOXH + sy0; + _scrl_y1 = _scrl_y0 + sy1; + + assert (fstop + llen <= _dircount); + // scroll-bar background + XSetForeground (dpy, _fib_gc, _c_gray3.pixel); + XFillRectangle (dpy, win, _fib_gc, sx0, stop, SCROLLBARW, fsel_height + _fib_font_vsep); + + // scroller + if (_hov_s == 0) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + } + XFillRectangle (dpy, win, _fib_gc, sx0 + 1, stop + SCROLLBOXH + sy0, SCROLLBARW - 2, sy1); + + int scrw = (SCROLLBARW -3) / 2; + // arrows top and bottom + if (_hov_s == 1) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + } + XPoint ptst[4] = { {sx0 + 1, stop + 8}, {scrw, -7}, {scrw, 7}, {-2 * scrw, 0}}; + XFillPolygon (dpy, win, _fib_gc, ptst, 3, Convex, CoordModePrevious); + XDrawLines (dpy, win, _fib_gc, ptst, 4, CoordModePrevious); + + if (_hov_s == 2) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + } + XPoint ptsb[4] = { {sx0 + 1, ltop + fsel_height - 9}, {2*scrw, 0}, {-scrw, 7}, {-scrw, -7}}; + XFillPolygon (dpy, win, _fib_gc, ptsb, 3, Convex, CoordModePrevious); + XDrawLines (dpy, win, _fib_gc, ptsb, 4, CoordModePrevious); + } else { + _scrl_y0 = _scrl_y1 = -1; + } + + if (_fib_show_places) { + assert (_placecnt > 0); + + // heading + XSetForeground (dpy, _fib_gc, _c_gray3.pixel); + XFillRectangle (dpy, win, _fib_gc, FAREAMRGB, ltop - _fib_font_vsep, PLACESW - TEXTSEP, _fib_font_vsep); + + // body + XSetForeground (dpy, _fib_gc, _c_gray2.pixel); + XFillRectangle (dpy, win, _fib_gc, FAREAMRGB, ltop, PLACESW - TEXTSEP, fsel_height); + +#ifdef DRAW_OUTLINE + VDrawRectangle (dpy, win, _fib_gc, FAREAMRGB, ltop - _fib_font_vsep -1, PLACESW - TEXTSEP, fsel_height + _fib_font_vsep + 1); +#endif + + XSetForeground (dpy, _fib_gc, blackColor); + XDrawString (dpy, win, _fib_gc, FAREAMRGB + TEXTSEP, ttop, "Places", 6); + + XRectangle pclip = {FAREAMRGB + 1, ltop, PLACESW - TEXTSEP -1, fsel_height}; + XSetClipRectangles (dpy, _fib_gc, 0, 0, &pclip, 1, Unsorted); + const int plx = FAREAMRGB + TEXTSEP; + for (i = 0; i < llen && i < _placecnt; ++i) { + const int ply = ltop + (i+1) * _fib_font_vsep - 4; + if (i == _hov_l) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + } else { + XSetForeground (dpy, _fib_gc, blackColor); + } + XDrawString (dpy, win, _fib_gc, + plx, ply, + _placelist[i].name, strlen (_placelist[i].name)); + if (_placelist[i].flags & 4) { + XSetForeground (dpy, _fib_gc, _c_gray3.pixel); + const int plly = ply - _fib_font_ascent + _fib_font_height; + const int pllx0 = FAREAMRGB; + const int pllx1 = FAREAMRGB + (PLACESW - TEXTSEP); + XDrawLine (dpy, win, _fib_gc, pllx0, plly, pllx1, plly); + } + } + XSetClipMask (dpy, _fib_gc, None); + + if (_placecnt > llen) { + const int plly = ltop + fsel_height - _fib_font_height + _fib_font_ascent; + const int pllx0 = FAREAMRGB + (PLACESW - TEXTSEP) * .75; + const int pllx1 = FAREAMRGB + (PLACESW - TEXTSEP - TEXTSEP); + + XSetForeground (dpy, _fib_gc, blackColor); + XSetLineAttributes (dpy, _fib_gc, 1, LineOnOffDash, CapButt, JoinMiter); + XDrawLine (dpy, win, _fib_gc, pllx0, plly, pllx1, plly); + XSetLineAttributes (dpy, _fib_gc, 1, LineSolid, CapButt, JoinMiter); + } + } + + // Bottom Buttons + const int numb = sizeof(_btns) / sizeof(FibButton*); + int xtra = _fib_width - _btn_span; + const int cbox = _fib_font_ascent - 2; + const int bbase = _fib_height - BTNBTMMARGIN * _fib_font_vsep - BTNPADDING; + const int cblw = cbox > 20 ? 5 : ( cbox > 9 ? 3 : 1); + + int bx = FAREAMRGB; + for (i = 0; i < numb; ++i) { + if (_btns[i]->flags & 8) { continue; } + if (_btns[i]->flags & 4) { + // checkbutton + const int cby0 = bbase - cbox + 1 + BTNPADDING; + if (i == _hov_b) { + XSetForeground (dpy, _fib_gc, _c_gray4.pixel); + } else { + XSetForeground (dpy, _fib_gc, blackColor); + } + XDrawRectangle (dpy, win, _fib_gc, + bx, cby0 - 1, cbox + 1, cbox + 1); + + if (i == _hov_b) { + XSetForeground (dpy, _fib_gc, _c_gray5.pixel); + } else { + XSetForeground (dpy, _fib_gc, blackColor); + } + XDrawString (dpy, win, _fib_gc, BTNPADDING + bx + _fib_font_ascent, 1 + bbase + BTNPADDING, + _btns[i]->text, strlen (_btns[i]->text)); + + if (i == _hov_b) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + if (_btns[i]->flags & 2) { + XSetForeground (dpy, _fib_gc, _c_gray1.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray2.pixel); + } + } + XFillRectangle (dpy, win, _fib_gc, + bx+1, cby0, cbox, cbox); + + if (_btns[i]->flags & 2) { + XSetLineAttributes (dpy, _fib_gc, cblw, LineSolid, CapRound, JoinMiter); + XSetForeground (dpy, _fib_gc, _c_gray6.pixel); + XDrawLine (dpy, win, _fib_gc, + bx + 2, cby0 + 1, + bx + cbox - 1, cby0 + cbox - 2); + XDrawLine (dpy, win, _fib_gc, + bx + cbox - 1, cby0 + 1, + bx + 2, cby0 + cbox - 2); + XSetLineAttributes (dpy, _fib_gc, 1, LineSolid, CapButt, JoinMiter); + } + } else { + if (xtra > 0) { + bx += xtra; + xtra = 0; + } + // pushbutton + + uint8_t can_hover = 1; // special case + if (_btns[i] == &_btn_ok) { + if (_fsel < 0 || _fsel >= _dircount) { + can_hover = 0; + } + } + + if (can_hover && i == _hov_b) { + XSetForeground (dpy, _fib_gc, _c_gray0.pixel); + } else { + XSetForeground (dpy, _fib_gc, _c_gray2.pixel); + } + XFillRectangle (dpy, win, _fib_gc, + bx + 1, bbase - _fib_font_ascent, + _btn_w - 1, _fib_font_height + BTNPADDING + BTNPADDING); + VDrawRectangle (dpy, win, _fib_gc, + bx, bbase - _fib_font_ascent, + _btn_w, _fib_font_height + BTNPADDING + BTNPADDING); + XDrawString (dpy, win, _fib_gc, bx + (_btn_w - _btns[i]->tw) * .5, 1 + bbase + BTNPADDING, + _btns[i]->text, strlen (_btns[i]->text)); + } + _btns[i]->x0 = bx; + bx += _btns[i]->xw + DSEP; + } + + if (_pixbuffer != None) { + XCopyArea(dpy, _pixbuffer, realwin, _fib_gc, 0, 0, _fib_width, _fib_height, 0, 0); + } + XFlush (dpy); +} + +static void fib_reset () { + _hov_p = _hov_f = _hov_h = _hov_l = -1; + _scrl_f = 0; + _fib_resized = 1; +} + +static int cmp_n_up (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + return strcmp (a->name, b->name); +} + +static int cmp_n_down (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + return strcmp (b->name, a->name); +} + +static int cmp_t_up (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + if (a->mtime == b->mtime) return 0; + return a->mtime > b->mtime ? -1 : 1; +} + +static int cmp_t_down (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + if (a->mtime == b->mtime) return 0; + return a->mtime > b->mtime ? 1 : -1; +} + +static int cmp_s_up (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && (b->flags & 4)) return 0; // dir, no size, retain order + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + if (a->size == b->size) return 0; + return a->size > b->size ? -1 : 1; +} + +static int cmp_s_down (const void *p1, const void *p2) { + FibFileEntry *a = (FibFileEntry*) p1; + FibFileEntry *b = (FibFileEntry*) p2; + if ((a->flags & 4) && (b->flags & 4)) return 0; // dir, no size, retain order + if ((a->flags & 4) && !(b->flags & 4)) return -1; + if (!(a->flags & 4) && (b->flags & 4)) return 1; + if (a->size == b->size) return 0; + return a->size > b->size ? 1 : -1; +} + +static void fmt_size (Display *dpy, FibFileEntry *f) { + if (f->size > 10995116277760) { + sprintf (f->strsize, "%.0f TB", f->size / 1099511627776.f); + } + if (f->size > 1099511627776) { + sprintf (f->strsize, "%.1f TB", f->size / 1099511627776.f); + } + else if (f->size > 10737418240) { + sprintf (f->strsize, "%.0f GB", f->size / 1073741824.f); + } + else if (f->size > 1073741824) { + sprintf (f->strsize, "%.1f GB", f->size / 1073741824.f); + } + else if (f->size > 10485760) { + sprintf (f->strsize, "%.0f MB", f->size / 1048576.f); + } + else if (f->size > 1048576) { + sprintf (f->strsize, "%.1f MB", f->size / 1048576.f); + } + else if (f->size > 10240) { + sprintf (f->strsize, "%.0f KB", f->size / 1024.f); + } + else if (f->size >= 1000) { + sprintf (f->strsize, "%.1f KB", f->size / 1024.f); + } + else { + sprintf (f->strsize, "%.0f B", f->size / 1.f); + } + int sw = 0; + query_font_geometry (dpy, _fib_gc, f->strsize, &sw, NULL, NULL, NULL); + if (sw > _fib_font_size_width) { + _fib_font_size_width = sw; + } + f->ssizew = sw; +} + +static void fmt_time (Display *dpy, FibFileEntry *f) { + struct tm *tmp; + tmp = localtime (&f->mtime); + if (!tmp) { + return; + } + strftime (f->strtime, sizeof(f->strtime), "%F %H:%M", tmp); + + int tw = 0; + query_font_geometry (dpy, _fib_gc, f->strtime, &tw, NULL, NULL, NULL); + if (tw > _fib_font_time_width) { + _fib_font_time_width = tw; + } +} + +static void fib_resort (const char * sel) { + if (_dircount < 1) { return; } + int (*sortfn)(const void *p1, const void *p2); + switch (_sort) { + case 1: sortfn = &cmp_n_down; break; + case 2: sortfn = &cmp_s_down; break; + case 3: sortfn = &cmp_s_up; break; + case 4: sortfn = &cmp_t_down; break; + case 5: sortfn = &cmp_t_up; break; + default: + sortfn = &cmp_n_up; + break; + } + qsort (_dirlist, _dircount, sizeof(_dirlist[0]), sortfn); + int i; + for (i = 0; i < _dircount && sel; ++i) { + if (!strcmp (_dirlist[i].name, sel)) { + _fsel = i; + break; + } + } +} + +static void fib_select (Display *dpy, int item) { + if (_fsel >= 0) { + _dirlist[_fsel].flags &= ~2; + } + _fsel = item; + if (_fsel >= 0 && _fsel < _dircount) { + _dirlist[_fsel].flags |= 2; + const int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + if (_fsel < _scrl_f) { + _scrl_f = _fsel; + } + else if (_fsel >= _scrl_f + llen) { + _scrl_f = 1 + _fsel - llen; + } + } else { + _fsel = -1; + } + + fib_expose (dpy, _fib_win); +} + +static inline int fib_filter (const char *name) { + if (_fib_filter_function) { + return _fib_filter_function (name); + } else { + return 1; + } +} + +static void fib_pre_opendir (Display *dpy) { + if (_dirlist) free (_dirlist); + if (_pathbtn) free (_pathbtn); + _dirlist = NULL; + _pathbtn = NULL; + _dircount = 0; + _pathparts = 0; + query_font_geometry (dpy, _fib_gc, "Size ", &_fib_font_size_width, NULL, NULL, NULL); + fib_reset (); + _fsel = -1; +} + +static void fib_post_opendir (Display *dpy, const char *sel) { + if (_dircount > 0) + _fsel = 0; // select first + else + _fsel = -1; + fib_resort (sel); + + if (_dircount > 0 && _fsel >= 0) { + fib_select (dpy, _fsel); + } else { + fib_expose (dpy, _fib_win); + } +} + +static int fib_dirlistadd (Display *dpy, const int i, const char* path, const char *name, time_t mtime) { + char tp[1024]; + struct stat fs; + if (!_fib_hidden_fn && name[0] == '.') return -1; + if (!strcmp (name, ".")) return -1; + if (!strcmp (name, "..")) return -1; + strcpy (tp, path); + strcat (tp, name); + if (access (tp, R_OK)) { + return -1; + } + if (stat (tp, &fs)) { + return -1; + } + assert (i < _dircount); // could happen if dir changes while we're reading. + if (i >= _dircount) return -1; + if (S_ISDIR (fs.st_mode)) { + _dirlist[i].flags |= 4; + } + else if (S_ISREG (fs.st_mode)) { + if (!fib_filter (name)) return -1; + } +#if 0 // only needed with lstat() + else if (S_ISLNK (fs.st_mode)) { + if (!fib_filter (name)) return -1; + } +#endif + else { + return -1; + } + strcpy (_dirlist[i].name, name); + _dirlist[i].mtime = mtime > 0 ? mtime : fs.st_mtime; + _dirlist[i].size = fs.st_size; + if (!(_dirlist[i].flags & 4)) + fmt_size (dpy, &_dirlist[i]); + fmt_time (dpy, &_dirlist[i]); + return 0; +} + +static int fib_openrecent (Display *dpy, const char *sel) { + int i; + unsigned int j; + assert (_recentcnt > 0); + fib_pre_opendir (dpy); + query_font_geometry (dpy, _fib_gc, "Last Used", &_fib_font_time_width, NULL, NULL, NULL); + _dirlist = (FibFileEntry*) calloc (_recentcnt, sizeof(FibFileEntry)); + _dircount = _recentcnt; + for (j = 0, i = 0; j < _recentcnt; ++j) { + char base[1024]; + char *s = strrchr (_recentlist[j].path, '/'); + if (!s || !*++s) continue; + size_t len = (s - _recentlist[j].path); + strncpy (base, _recentlist[j].path, len); + base[len] = '\0'; + if (!fib_dirlistadd (dpy, i, base, s, _recentlist[j].atime)) { + _dirlist[i].rfp = &_recentlist[j]; + _dirlist[i].flags |= 8; + ++i; + } + } + _dircount = i; + fib_post_opendir (dpy, sel); + return _dircount; +} + +static int fib_opendir (Display *dpy, const char* path, const char *sel) { + char *t0, *t1; + int i; + + assert (path); + + if (strlen (path) == 0 && _recentcnt > 0) { // XXX we should use a better indication for this + strcpy (_cur_path, ""); + return fib_openrecent (dpy, sel); + } + + assert (strlen (path) < sizeof(_cur_path) -1); + assert (strlen (path) > 0); + assert (strstr (path, "//") == NULL); + assert (path[0] == '/'); + + fib_pre_opendir (dpy); + + query_font_geometry (dpy, _fib_gc, "Last Modified", &_fib_font_time_width, NULL, NULL, NULL); + DIR *dir = opendir (path); + if (!dir) { + strcpy (_cur_path, "/"); + } else { + int i; + struct dirent *de; + if (path != _cur_path) + strcpy (_cur_path, path); + + if (_cur_path[strlen (_cur_path) -1] != '/') + strcat (_cur_path, "/"); + + while ((de = readdir (dir))) { + if (!_fib_hidden_fn && de->d_name[0] == '.') continue; + ++_dircount; + } + + if (_dircount > 0) + _dirlist = (FibFileEntry*) calloc (_dircount, sizeof(FibFileEntry)); + + rewinddir (dir); + + i = 0; + while ((de = readdir (dir))) { + if (!fib_dirlistadd (dpy, i, _cur_path, de->d_name, 0)) + ++i; + } + _dircount = i; + closedir (dir); + } + + t0 = _cur_path; + while (*t0 && (t0 = strchr (t0, '/'))) { + ++_pathparts; + ++t0; + } + assert (_pathparts > 0); + _pathbtn = (FibPathButton*) calloc (_pathparts + 1, sizeof(FibPathButton)); + + t1 = _cur_path; + i = 0; + while (*t1 && (t0 = strchr (t1, '/'))) { + if (i == 0) { + strcpy (_pathbtn[i].name, "/"); + } else { + *t0 = 0; + strcpy (_pathbtn[i].name, t1); + } + query_font_geometry (dpy, _fib_gc, _pathbtn[i].name, &_pathbtn[i].xw, NULL, NULL, NULL); + _pathbtn[i].xw += BTNPADDING + BTNPADDING; + *t0 = '/'; + t1 = t0 + 1; + ++i; + } + fib_post_opendir (dpy, sel); + return _dircount; +} + +static int fib_open (Display *dpy, int item) { + char tp[1024]; + if (_dirlist[item].flags & 8) { + assert (_dirlist[item].rfp); + strcpy (_rv_open, _dirlist[item].rfp->path); + _status = 1; + return 0; + } + strcpy (tp, _cur_path); + strcat (tp, _dirlist[item].name); + if (_dirlist[item].flags & 4) { + fib_opendir (dpy, tp, NULL); + return 0; + } else { + _status = 1; + strcpy (_rv_open, tp); + } + return 0; +} + +static void cb_cancel (Display *dpy) { + _status = -1; +} + +static void cb_open (Display *dpy) { + if (_fsel >= 0 && _fsel < _dircount) { + fib_open (dpy, _fsel); + } +} + +static void sync_button_states () { + if (_fib_show_places) + _btn_places.flags |= 2; + else + _btn_places.flags &= ~2; + if (_fib_filter_fn) // inverse -> show all + _btn_filter.flags &= ~2; + else + _btn_filter.flags |= 2; + if (_fib_hidden_fn) + _btn_hidden.flags |= 2; + else + _btn_hidden.flags &= ~2; +} + +static void cb_places (Display *dpy) { + _fib_show_places = ! _fib_show_places; + if (_placecnt < 1) + _fib_show_places = 0; + sync_button_states (); + _fib_resized = 1; + fib_expose (dpy, _fib_win); +} + +static void cb_filter (Display *dpy) { + _fib_filter_fn = ! _fib_filter_fn; + sync_button_states (); + char *sel = _fsel >= 0 ? strdup (_dirlist[_fsel].name) : NULL; + fib_opendir (dpy, _cur_path, sel); + free (sel); +} + +static void cb_hidden (Display *dpy) { + _fib_hidden_fn = ! _fib_hidden_fn; + sync_button_states (); + char *sel = _fsel >= 0 ? strdup (_dirlist[_fsel].name) : NULL; + fib_opendir (dpy, _cur_path, sel); + free (sel); +} + +static int fib_widget_at_pos (Display *dpy, int x, int y, int *it) { + const int btop = _fib_height - BTNBTMMARGIN * _fib_font_vsep - _fib_font_ascent - BTNPADDING; + const int bbot = btop + _fib_font_height + BTNPADDING + BTNPADDING; + const int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + const int ltop = LISTTOP * _fib_font_vsep; + const int fbot = ltop + 4 + llen * _fib_font_vsep; + const int ptop = PATHBTNTOP - _fib_font_ascent; + assert (it); + + // paths at top + if (y > ptop && y < ptop + _fib_font_height && _view_p >= 0 && _pathparts > 0) { + int i = _view_p; + *it = -1; + if (i > 0) { // special case '<' + if (x > FAREAMRGB && x <= FAREAMRGB + _pathbtn[0].xw) { + *it = _view_p - 1; + i = _pathparts; + } + } + while (i < _pathparts) { + if (x >= _pathbtn[i].x0 && x <= _pathbtn[i].x0 + _pathbtn[i].xw) { + *it = i; + break; + } + ++i; + } + assert (*it < _pathparts); + if (*it >= 0) return 1; + else return 0; + } + + // buttons at bottom + if (y > btop && y < bbot) { + size_t i; + *it = -1; + for (i = 0; i < sizeof(_btns) / sizeof(FibButton*); ++i) { + const int bx = _btns[i]->x0; + if (_btns[i]->flags & 8) { continue; } + if (x > bx && x < bx + _btns[i]->xw) { + *it = i; + } + } + if (*it >= 0) return 3; + else return 0; + } + + // main file area + if (y >= ltop - _fib_font_vsep && y < fbot && x > FAREAMRGL && x < _fib_width - FAREAMRGR) { + // scrollbar + if (_scrl_y0 > 0 && x >= _fib_width - (FAREAMRGR + SCROLLBARW) && x <= _fib_width - FAREAMRGR) { + if (y >= _scrl_y0 && y < _scrl_y1) { + *it = 0; + } else if (y >= _scrl_y1) { + *it = 2; + } else { + *it = 1; + } + return 4; + } + // file-list + else if (y >= ltop) { + const int item = (y - ltop) / _fib_font_vsep + _scrl_f; + *it = -1; + if (item >= 0 && item < _dircount) { + *it = item; + } + if (*it >= 0) return 2; + else return 0; + } + else { + *it = -1; + const int fsel_width = _fib_width - FAREAMRGL - FAREAMRGR - (llen < _dircount ? SCROLLBARW : 0); + const int t_s = FAREAMRGL + fsel_width - _fib_font_time_width - TEXTSEP - TEXTSEP; + const int t_t = FAREAMRGL + fsel_width - TEXTSEP - _fib_font_size_width - ((_columns & 2) ? ( _fib_font_time_width + TEXTSEP + TEXTSEP) : 0); + if (x >= fsel_width + FAREAMRGL) ; + else if ((_columns & 2) && x >= t_s) *it = 3; + else if ((_columns & 1) && x >= t_t) *it = 2; + else if (x >= FAREATEXTL + _fib_dir_indent - TEXTSEP) *it = 1; + if (*it >= 0) return 5; + else return 0; + } + } + + // places list + if (_fib_show_places && y >= ltop && y < fbot && x > FAREAMRGB && x < FAREAMRGL - FAREAMRGB) { + const int item = (y - ltop) / _fib_font_vsep; + *it = -1; + if (item >= 0 && item < _placecnt) { + *it = item; + } + if (*it >= 0) return 6; + else return 0; + } + + return 0; +} + +static void fib_update_hover (Display *dpy, int need_expose, const int type, const int item) { + int hov_p = -1; + int hov_b = -1; + int hov_h = -1; + int hov_s = -1; +#ifdef LIST_ENTRY_HOVER + int hov_f = -1; + int hov_l = -1; +#endif + + switch (type) { + case 1: hov_p = item; break; + case 3: hov_b = item; break; + case 4: hov_s = item; break; + case 5: hov_h = item; break; +#ifdef LIST_ENTRY_HOVER + case 6: hov_l = item; break; + case 2: hov_f = item; break; +#endif + default: break; + } +#ifdef LIST_ENTRY_HOVER + if (hov_f != _hov_f) { _hov_f = hov_f; need_expose = 1; } + if (hov_l != _hov_l) { _hov_l = hov_l; need_expose = 1; } +#endif + if (hov_b != _hov_b) { _hov_b = hov_b; need_expose = 1; } + if (hov_p != _hov_p) { _hov_p = hov_p; need_expose = 1; } + if (hov_h != _hov_h) { _hov_h = hov_h; need_expose = 1; } + if (hov_s != _hov_s) { _hov_s = hov_s; need_expose = 1; } + + if (need_expose) { + fib_expose (dpy, _fib_win); + } +} + +static void fib_motion (Display *dpy, int x, int y) { + int it = -1; + + if (_scrl_my >= 0) { + const int sdiff = y - _scrl_my; + const int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + const int fsel_height = 4 + llen * _fib_font_vsep; + const float sl = (fsel_height + _fib_font_vsep - (SCROLLBOXH + SCROLLBOXH)) / (float) _dircount; + + int news = _scrl_mf + sdiff / sl; + if (news < 0) news = 0; + if (news >= (_dircount - llen)) news = _dircount - llen; + if (news != _scrl_f) { + _scrl_f = news; + fib_expose (dpy, _fib_win); + } + return; + } + + const int type = fib_widget_at_pos (dpy, x, y, &it); + fib_update_hover (dpy, 0, type, it); +} + +static void fib_mousedown (Display *dpy, int x, int y, int btn, unsigned long time) { + int it; + switch (fib_widget_at_pos (dpy, x, y, &it)) { + case 4: // scrollbar + if (btn == 1) { + _dblclk = 0; + if (it == 0) { + _scrl_my = y; + _scrl_mf = _scrl_f; + } else { + int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + if (llen < 2) llen = 2; + int news = _scrl_f; + if (it == 1) { + news -= llen - 1; + } else { + news += llen - 1; + } + if (news < 0) news = 0; + if (news >= (_dircount - llen)) news = _dircount - llen; + if (news != _scrl_f && _scrl_y0 >= 0) { + assert (news >=0); + _scrl_f = news; + fib_update_hover (dpy, 1, 4, it); + } + } + } + break; + case 2: // file-list + if (btn == 4 || btn == 5) { + const int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + int news = _scrl_f + ((btn == 4) ? - 1 : 1); + if (news < 0) news = 0; + if (news >= (_dircount - llen)) news = _dircount - llen; + if (news != _scrl_f && _scrl_y0 >= 0) { + assert (news >=0); + _scrl_f = news; + fib_update_hover (dpy, 1, 0, 0); + } + _dblclk = 0; + } + else if (btn == 1 && it >= 0 && it < _dircount) { + if (_fsel == it) { + if (time - _dblclk < DBLCLKTME) { + fib_open (dpy, it); + _dblclk = 0; + } + _dblclk = time; + } else { + fib_select (dpy, it); + _dblclk = time; + } + if (_fsel >= 0) { + if (!(_dirlist[_fsel].flags & 4)) { + } + } + } + break; + case 1: // paths + assert (_fsel < _dircount); + assert (it >= 0 && it < _pathparts); + { + int i = 0; + char path[1024] = "/"; + while (++i <= it) { + strcat (path, _pathbtn[i].name); + strcat (path, "/"); + } + char *sel = NULL; + if (i < _pathparts) + sel = strdup (_pathbtn[i].name); + else if (i == _pathparts && _fsel >= 0) + sel = strdup (_dirlist[_fsel].name); + fib_opendir (dpy, path, sel); + free (sel); + } + break; + case 3: // btn + if (btn == 1 && _btns[it]->callback) { + _btns[it]->callback (dpy); + } + break; + case 5: // sort + if (btn == 1) { + switch (it) { + case 1: if (_sort == 0) _sort = 1; else _sort = 0; break; + case 2: if (_sort == 2) _sort = 3; else _sort = 2; break; + case 3: if (_sort == 4) _sort = 5; else _sort = 4; break; + } + if (_fsel >= 0) { + assert (_dirlist && _dircount >= _fsel); + _dirlist[_fsel].flags &= ~2; + char *sel = strdup (_dirlist[_fsel].name); + fib_resort (sel); + free (sel); + } else { + fib_resort (NULL); + _fsel = -1; + } + fib_reset (); + _hov_h = it; + fib_select (dpy, _fsel); + } + break; + case 6: + if (btn == 1 && it >= 0 && it < _placecnt) { + fib_opendir (dpy, _placelist[it].path, NULL); + } + break; + default: + break; + } +} + +static void fib_mouseup (Display *dpy, int x, int y, int btn, unsigned long time) { + _scrl_my = -1; +} + +static void add_place_raw (Display *dpy, const char *name, const char *path) { + _placelist = (FibPlace*) realloc (_placelist, (_placecnt + 1) * sizeof(FibPlace)); + strcpy (_placelist[_placecnt].path, path); + strcpy (_placelist[_placecnt].name, name); + _placelist[_placecnt].flags = 0; + + int sw; + query_font_geometry (dpy, _fib_gc, name, &sw, NULL, NULL, NULL); + if (sw > _fib_place_width) { + _fib_place_width = sw; + } + ++_placecnt; +} + +static int add_place_places (Display *dpy, const char *name, const char *url) { + char const * path; + struct stat fs; + int i; + if (!url || strlen (url) < 1) return -1; + if (!name || strlen (name) < 1) return -1; + if (url[0] == '/') { + path = url; + } + else if (!strncmp (url, "file:///", 8)) { + path = &url[7]; + } + else { + return -1; + } + + if (access (path, R_OK)) { + return -1; + } + if (stat (path, &fs)) { + return -1; + } + if (!S_ISDIR (fs.st_mode)) { + return -1; + } + + for (i = 0; i < _placecnt; ++i) { + if (!strcmp (path, _placelist[i].path)) { + return -1; + } + } + add_place_raw (dpy, name, path); + return 0; +} + +static int parse_gtk_bookmarks (Display *dpy, const char *fn) { + char tmp[1024]; + if (access (fn, R_OK)) { + return -1; + } + FILE *bm = fopen (fn, "r"); + if (!bm) return -1; + int found = 0; + while (fgets (tmp, sizeof(tmp), bm) + && strlen (tmp) > 1 + && strlen (tmp) < sizeof(tmp)) + { + char *s, *n; + tmp[strlen (tmp) - 1] = '\0'; // strip newline + if ((s = strchr (tmp, ' '))) { + *s = '\0'; + n = strdup (++s); + decode_3986 (tmp); + if (!add_place_places (dpy, n, tmp)) { + ++found; + } + free (n); + } else if ((s = strrchr (tmp, '/'))) { + n = strdup (++s); + decode_3986 (tmp); + if (!add_place_places (dpy, n, tmp)) { + ++found; + } + free (n); + } + } + fclose (bm); + return found; +} + +static const char *ignore_mountpoints[] = { + "/bin", "/boot", "/dev", "/etc", + "/lib", "/live", "/mnt", "/opt", + "/root", "/sbin", "/srv", "/tmp", + "/usr", "/var", "/proc", "/sbin", + "/net", "/sys" +}; + +static const char *ignore_fs[] = { + "auto", "autofs", + "debugfs", "devfs", + "devpts", "ecryptfs", + "fusectl", "kernfs", + "linprocfs", "proc", + "ptyfs", "rootfs", + "selinuxfs", "sysfs", + "tmpfs", "usbfs", + "nfsd", "rpc_pipefs", +}; + +static const char *ignore_devices[] = { + "binfmt_", "devpts", + "gvfs", "none", + "nfsd", "sunrpc", + "/dev/loop", "/dev/vn" +}; + +static int check_mount (const char *mountpoint, const char *fs, const char *device) { + size_t i; + if (!mountpoint || !fs || !device) return -1; + //printf("%s %s %s\n", mountpoint, fs, device); + for (i = 0 ; i < sizeof(ignore_mountpoints) / sizeof(char*); ++i) { + if (!strncmp (mountpoint, ignore_mountpoints[i], strlen (ignore_mountpoints[i]))) { + return 1; + } + } + if (!strncmp (mountpoint, "/home", 5)) { + return 1; + } + for (i = 0 ; i < sizeof(ignore_fs) / sizeof(char*); ++i) { + if (!strncmp (fs, ignore_fs[i], strlen (ignore_fs[i]))) { + return 1; + } + } + for (i = 0 ; i < sizeof(ignore_devices) / sizeof(char*); ++i) { + if (!strncmp (device, ignore_devices[i], strlen (ignore_devices[i]))) { + return 1; + } + } + return 0; +} + +static int read_mtab (Display *dpy, const char *mtab) { + FILE *mt = fopen (mtab, "r"); + if (!mt) return -1; + int found = 0; + struct mntent *mntent; + while ((mntent = getmntent (mt)) != NULL) { + char *s; + if (check_mount (mntent->mnt_dir, mntent->mnt_type, mntent->mnt_fsname)) + continue; + + if ((s = strrchr (mntent->mnt_dir, '/'))) { + ++s; + } else { + s = mntent->mnt_dir; + } + if (!add_place_places (dpy, s, mntent->mnt_dir)) { + ++found; + } + } + fclose (mt); + return found; +} + +static void populate_places (Display *dpy) { + char tmp[1024]; + int spacer = -1; + if (_placecnt > 0) return; + _fib_place_width = 0; + + if (_recentcnt > 0) { + add_place_raw (dpy, "Recently Used", ""); + _placelist[0].flags |= 4; + } + + add_place_places (dpy, "Home", getenv ("HOME")); + + if (getenv ("HOME")) { + strcpy (tmp, getenv ("HOME")); + strcat (tmp, "/Desktop"); + add_place_places (dpy, "Desktop", tmp); + } + + add_place_places (dpy, "Filesystem", "/"); + + if (_placecnt > 0) spacer = _placecnt -1; + + if (strlen (_fib_cfg_custom_places) > 0) { + parse_gtk_bookmarks (dpy, _fib_cfg_custom_places); + } + + if (read_mtab (dpy, "/proc/mounts") < 1) { + read_mtab (dpy, "/etc/mtab"); + } + + int parsed_bookmarks = 0; + if (!parsed_bookmarks && getenv ("HOME")) { + strcpy (tmp, getenv ("HOME")); + strcat (tmp, "/.gtk-bookmarks"); + if (parse_gtk_bookmarks (dpy, tmp) > 0) { + parsed_bookmarks = 1; + } + } + if (!parsed_bookmarks && getenv ("XDG_CONFIG_HOME")) { + strcpy (tmp, getenv ("XDG_CONFIG_HOME")); + strcat (tmp, "/gtk-3.0/bookmarks"); + if (parse_gtk_bookmarks (dpy, tmp) > 0) { + parsed_bookmarks = 1; + } + } + if (!parsed_bookmarks && getenv ("HOME")) { + strcpy (tmp, getenv ("HOME")); + strcat (tmp, "/.config/gtk-3.0/bookmarks"); + if (parse_gtk_bookmarks (dpy, tmp) > 0) { + parsed_bookmarks = 1; + } + } + if (_fib_place_width > 0) { + _fib_place_width = MIN (_fib_place_width + TEXTSEP + _fib_dir_indent /*extra*/ , PLACESWMAX); + } + if (spacer > 0 && spacer < _placecnt -1) { + _placelist[ spacer ].flags |= 4; + } +} + +static uint8_t font_err = 0; +static int x_error_handler (Display *d, XErrorEvent *e) { + font_err = 1; + return 0; +} + +int x_fib_show (Display *dpy, Window parent, int x, int y) { + if (_fib_win) { + XSetInputFocus (dpy, _fib_win, RevertToParent, CurrentTime); + return -1; + } + + _status = 0; + _rv_open[0] = '\0'; + + Colormap colormap = DefaultColormap (dpy, DefaultScreen (dpy)); + _c_gray1.flags= DoRed | DoGreen | DoBlue; + _c_gray0.red = _c_gray0.green = _c_gray0.blue = 61710; // 95% hover prelight + _c_gray1.red = _c_gray1.green = _c_gray1.blue = 60416; // 93% window bg, scrollbar-fg + _c_gray2.red = _c_gray2.green = _c_gray2.blue = 54016; // 83% button & list bg + _c_gray3.red = _c_gray3.green = _c_gray3.blue = 48640; // 75% heading + scrollbar-bg + _c_gray4.red = _c_gray4.green = _c_gray4.blue = 26112; // 40% prelight text, sep lines + _c_gray5.red = _c_gray5.green = _c_gray5.blue = 12800; // 20% 3D border + _c_gray6.red = _c_gray6.green = _c_gray6.blue = 6400; // 10% checkbox cross, sort triangles + + if (!XAllocColor (dpy, colormap, &_c_gray0)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray1)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray2)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray3)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray4)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray5)) return -1; + if (!XAllocColor (dpy, colormap, &_c_gray6)) return -1; + + XSetWindowAttributes attr; + memset (&attr, 0, sizeof(XSetWindowAttributes)); + attr.border_pixel = _c_gray2.pixel; + + attr.event_mask = ExposureMask | KeyPressMask + | ButtonPressMask | ButtonReleaseMask + | ConfigureNotify | StructureNotifyMask + | PointerMotionMask | LeaveWindowMask; + + _fib_win = XCreateWindow ( + dpy, DefaultRootWindow (dpy), + x, y, _fib_width, _fib_height, + 1, CopyFromParent, InputOutput, CopyFromParent, + CWEventMask | CWBorderPixel, &attr); + + if (!_fib_win) { return 1; } + + if (parent) + XSetTransientForHint (dpy, _fib_win, parent); + + XStoreName (dpy, _fib_win, "Select File"); + + Atom wmDelete = XInternAtom (dpy, "WM_DELETE_WINDOW", True); + XSetWMProtocols (dpy, _fib_win, &wmDelete, 1); + + _fib_gc = XCreateGC (dpy, _fib_win, 0, NULL); + XSetLineAttributes (dpy, _fib_gc, 1, LineSolid, CapButt, JoinMiter); + const char dl[1] = {1}; + XSetDashes (dpy, _fib_gc, 0, dl, 1); + + int (*handler)(Display *, XErrorEvent *) = XSetErrorHandler (&x_error_handler); + +#define _XTESTFONT(FN) \ + { \ + font_err = 0; \ + _fibfont = XLoadFont (dpy, FN); \ + XSetFont (dpy, _fib_gc, _fibfont); \ + XSync (dpy, False); \ + } + + font_err = 1; + if (getenv ("XJFONT")) _XTESTFONT (getenv ("XJFONT")); + if (font_err && strlen (_fib_cfg_custom_font) > 0) _XTESTFONT (_fib_cfg_custom_font); + if (font_err) _XTESTFONT ("-*-helvetica-medium-r-normal-*-24-*-*-*-*-*-*-*"); + if (font_err) _XTESTFONT ("-*-verdana-medium-r-normal-*-24-*-*-*-*-*-*-*"); + if (font_err) _XTESTFONT ("-misc-fixed-medium-r-normal-*-24-*-*-*-*-*-*-*"); + if (font_err) _XTESTFONT ("-misc-fixed-medium-r-normal-*-20-*-*-*-*-*-*-*"); + if (font_err) _fibfont = None; + XSync (dpy, False); + XSetErrorHandler (handler); + + if (_fib_font_height == 0) { // 1st time only + query_font_geometry (dpy, _fib_gc, "D ", &_fib_dir_indent, NULL, NULL, NULL); + query_font_geometry (dpy, _fib_gc, "_", &_fib_spc_norm, NULL, NULL, NULL); + if (query_font_geometry (dpy, _fib_gc, "|0Yy", NULL, &_fib_font_height, &_fib_font_ascent, NULL)) { + XFreeGC (dpy, _fib_gc); + XDestroyWindow (dpy, _fib_win); + _fib_win = 0; + return -1; + } + _fib_font_height += 3; + _fib_font_ascent += 2; + _fib_font_vsep = _fib_font_height + 2; + } + + populate_places (dpy); + + strcpy (_btn_ok.text, "Open"); + strcpy (_btn_cancel.text, "Cancel"); + strcpy (_btn_filter.text, "List All Files"); + strcpy (_btn_places.text, "Show Places"); + strcpy (_btn_hidden.text, "Show Hidden"); + + _btn_ok.callback = &cb_open; + _btn_cancel.callback = &cb_cancel; + _btn_filter.callback = &cb_filter; + _btn_places.callback = &cb_places; + _btn_hidden.callback = &cb_hidden; + _btn_filter.flags |= 4; + _btn_places.flags |= 4; + _btn_hidden.flags |= 4; + + if (!_fib_filter_function) { + _btn_filter.flags |= 8; + } + + size_t i; + int btncnt = 0; + _btn_w = 0; + _btn_span = 0; + for (i = 0; i < sizeof(_btns) / sizeof(FibButton*); ++i) { + if (_btns[i]->flags & 8) { continue; } + query_font_geometry (dpy, _fib_gc, _btns[i]->text, &_btns[i]->tw, NULL, NULL, NULL); + if (_btns[i]->flags & 4) { + _btn_span += _btns[i]->tw + _fib_font_ascent + TEXTSEP; + } else { + ++btncnt; + if (_btns[i]->tw > _btn_w) + _btn_w = _btns[i]->tw; + } + } + + _btn_w += BTNPADDING + BTNPADDING + TEXTSEP + TEXTSEP + TEXTSEP; + _btn_span += _btn_w * btncnt + DSEP * (i - 1) + FAREAMRGR + FAREAMRGB; + + for (i = 0; i < sizeof(_btns) / sizeof(FibButton*); ++i) { + if (_btns[i]->flags & 8) { continue; } + if (_btns[i]->flags & 4) { + _btns[i]->xw = _btns[i]->tw + _fib_font_ascent + TEXTSEP; + } else { + _btns[i]->xw = _btn_w; + } + } + + sync_button_states () ; + + _fib_height = _fib_font_vsep * (15.8); + _fib_width = MAX (_btn_span, 440); + + XResizeWindow (dpy, _fib_win, _fib_width, _fib_height); + + XTextProperty x_wname, x_iname; + XSizeHints hints; + XWMHints wmhints; + + hints.flags = PSize | PMinSize; + hints.min_width = _btn_span; + hints.min_height = 8 * _fib_font_vsep; + + char *w_name = & _fib_cfg_title[0]; + + wmhints.input = True; + wmhints.flags = InputHint; + if (XStringListToTextProperty (&w_name, 1, &x_wname) && + XStringListToTextProperty (&w_name, 1, &x_iname)) + { + XSetWMProperties (dpy, _fib_win, &x_wname, &x_iname, NULL, 0, &hints, &wmhints, NULL); + XFree (x_wname.value); + XFree (x_iname.value); + } + + XSetWindowBackground (dpy, _fib_win, _c_gray1.pixel); + + _fib_mapped = 0; + XMapRaised (dpy, _fib_win); + + if (!strlen (_cur_path) || !fib_opendir (dpy, _cur_path, NULL)) { + fib_opendir (dpy, getenv ("HOME") ? getenv ("HOME") : "/", NULL); + } + +#if 0 + XGrabPointer (dpy, _fib_win, True, + ButtonReleaseMask | ButtonPressMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | StructureNotifyMask, + GrabModeAsync, GrabModeAsync, None, None, CurrentTime); + XGrabKeyboard (dpy, _fib_win, True, GrabModeAsync, GrabModeAsync, CurrentTime); + //XSetInputFocus (dpy, parent, RevertToNone, CurrentTime); +#endif + _recentlock = 1; + return 0; +} + +void x_fib_close (Display *dpy) { + if (!_fib_win) return; + XFreeGC (dpy, _fib_gc); + XDestroyWindow (dpy, _fib_win); + _fib_win = 0; + free (_dirlist); + _dirlist = NULL; + free (_pathbtn); + _pathbtn = NULL; + if (_fibfont != None) XUnloadFont (dpy, _fibfont); + _fibfont = None; + free (_placelist); + _placelist = NULL; + _dircount = 0; + _pathparts = 0; + _placecnt = 0; + if (_pixbuffer != None) XFreePixmap (dpy, _pixbuffer); + _pixbuffer = None; + Colormap colormap = DefaultColormap (dpy, DefaultScreen (dpy)); + XFreeColors (dpy, colormap, &_c_gray0.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray1.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray2.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray3.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray4.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray5.pixel, 1, 0); + XFreeColors (dpy, colormap, &_c_gray6.pixel, 1, 0); + _recentlock = 0; +} + +int x_fib_handle_events (Display *dpy, XEvent *event) { + if (!_fib_win) return 0; + if (_status) return 0; + if (event->xany.window != _fib_win) { + return 0; + } + + switch (event->type) { + case MapNotify: + _fib_mapped = 1; + break; + case UnmapNotify: + _fib_mapped = 0; + break; + case LeaveNotify: + fib_update_hover (dpy, 1, 0, 0); + break; + case ClientMessage: + if (!strcmp (XGetAtomName (dpy, event->xclient.message_type), "WM_PROTOCOLS")) { + _status = -1; + } + break; + case ConfigureNotify: + if ( + (event->xconfigure.width > 1 && event->xconfigure.height > 1) + && + (event->xconfigure.width != _fib_width || event->xconfigure.height != _fib_height) + ) + { + _fib_width = event->xconfigure.width; + _fib_height = event->xconfigure.height; + _fib_resized = 1; + } + break; + case Expose: + if (event->xexpose.count == 0) { + fib_expose (dpy, event->xany.window); + } + break; + case MotionNotify: + fib_motion (dpy, event->xmotion.x, event->xmotion.y); + if (event->xmotion.is_hint == NotifyHint) { + XGetMotionEvents (dpy, event->xany.window, CurrentTime, CurrentTime, NULL); + } + break; + case ButtonPress: + fib_mousedown (dpy, event->xbutton.x, event->xbutton.y, event->xbutton.button, event->xbutton.time); + break; + case ButtonRelease: + fib_mouseup (dpy, event->xbutton.x, event->xbutton.y, event->xbutton.button, event->xbutton.time); + break; + case KeyRelease: + break; + case KeyPress: + { + KeySym key; + char buf[100]; + static XComposeStatus stat; + XLookupString (&event->xkey, buf, sizeof(buf), &key, &stat); + switch (key) { + case XK_Escape: + _status = -1; + break; + case XK_Up: + if (_fsel > 0) { + fib_select (dpy, _fsel - 1); + } + break; + case XK_Down: + if (_fsel < _dircount -1) { + fib_select ( dpy, _fsel + 1); + } + break; + case XK_Page_Up: + if (_fsel > 0) { + int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + if (llen < 1) llen = 1; else --llen; + int fs = MAX (0, _fsel - llen); + fib_select ( dpy, fs); + } + break; + case XK_Page_Down: + if (_fsel < _dircount) { + int llen = (_fib_height - LISTBOT * _fib_font_vsep) / _fib_font_vsep; + if (llen < 1) llen = 1; else --llen; + int fs = MIN (_dircount - 1, _fsel + llen); + fib_select ( dpy, fs); + } + break; + case XK_Left: + if (_pathparts > 1) { + int i = 0; + char path[1024] = "/"; + while (++i < _pathparts - 1) { + strcat (path, _pathbtn[i].name); + strcat (path, "/"); + } + char *sel = strdup (_pathbtn[_pathparts-1].name); + fib_opendir (dpy, path, sel); + free (sel); + } + break; + case XK_Right: + if (_fsel >= 0 && _fsel < _dircount) { + if (_dirlist[_fsel].flags & 4) { + cb_open (dpy); + } + } + break; + case XK_Return: + cb_open (dpy); + break; + default: + if ((key >= XK_a && key <= XK_z) || (key >= XK_0 && key <= XK_9)) { + int i; + for (i = 0; i < _dircount; ++i) { + int j = (_fsel + i + 1) % _dircount; + char kcmp = _dirlist[j].name[0]; + if (kcmp > 0x40 && kcmp <= 0x5A) kcmp |= 0x20; + if (kcmp == (char)key) { + fib_select ( dpy, j); + break; + } + } + } + break; + } + } + break; + } + + if (_status) { + x_fib_close (dpy); + } + return _status; +} + +int x_fib_status () { + return _status; +} + +int x_fib_configure (int k, const char *v) { + if (_fib_win) { return -1; } + switch (k) { + case 0: + if (strlen (v) >= sizeof(_cur_path) -1) return -2; + if (strlen (v) < 1) return -2; + if (v[0] != '/') return -2; + if (strstr (v, "//")) return -2; + strncpy (_cur_path, v, sizeof(_cur_path)); + break; + case 1: + if (strlen (v) >= sizeof(_fib_cfg_title) -1) return -2; + strncpy (_fib_cfg_title, v, sizeof(_fib_cfg_title)); + break; + case 2: + if (strlen (v) >= sizeof(_fib_cfg_custom_font) -1) return -2; + strncpy (_fib_cfg_custom_font, v, sizeof(_fib_cfg_custom_font)); + break; + case 3: + if (strlen (v) >= sizeof(_fib_cfg_custom_places) -1) return -2; + strncpy (_fib_cfg_custom_places, v, sizeof(_fib_cfg_custom_places)); + break; + default: + return -2; + } + return 0; +} + +int x_fib_cfg_buttons (int k, int v) { + if (_fib_win) { return -1; } + switch (k) { + case 1: + if (v < 0) { + _btn_hidden.flags |= 8; + } else { + _btn_hidden.flags &= ~8; + } + if (v == 1) { + _btn_hidden.flags |= 2; + _fib_hidden_fn = 1; + } else if (v == 0) { + _btn_hidden.flags &= 2; + _fib_hidden_fn = 0; + } + break; + case 2: + if (v < 0) { + _btn_places.flags |= 8; + } else { + _btn_places.flags &= ~8; + } + if (v == 1) { + _btn_places.flags |= 2; + _fib_show_places = 1; + } else if (v == 0) { + _btn_places.flags &= ~2; + _fib_show_places = 0; + } + break; + case 3: + // NB. filter button is automatically hidden + // IFF the filter-function is NULL. + if (v < 0) { + _btn_filter.flags |= 8; + } else { + _btn_filter.flags &= ~8; + } + if (v == 1) { + _btn_filter.flags &= ~2; // inverse - 'show all' = !filter + _fib_filter_fn = 1; + } else if (v == 0) { + _btn_filter.flags |= 2; + _fib_filter_fn = 0; + } + break; + default: + return -2; + } + return 0; +} + +int x_fib_cfg_filter_callback (int (*cb)(const char*)) { + if (_fib_win) { return -1; } + _fib_filter_function = cb; + return 0; +} + +char *x_fib_filename () { + if (_status > 0 && !_fib_win) + return strdup (_rv_open); + else + return NULL; +} +#endif // HAVE_X11 + + +/* example usage */ +#ifdef SOFD_TEST + +static int fib_filter_movie_filename (const char *name) { + if (!_fib_filter_fn) return 1; + const int l3 = strlen (name) - 3; + const int l4 = l3 - 1; + const int l5 = l4 - 1; + const int l6 = l5 - 1; + const int l9 = l6 - 3; + if ( + (l4 > 0 && ( + !strcasecmp (&name[l4], ".avi") + || !strcasecmp (&name[l4], ".mov") + || !strcasecmp (&name[l4], ".ogg") + || !strcasecmp (&name[l4], ".ogv") + || !strcasecmp (&name[l4], ".mpg") + || !strcasecmp (&name[l4], ".mov") + || !strcasecmp (&name[l4], ".mp4") + || !strcasecmp (&name[l4], ".mkv") + || !strcasecmp (&name[l4], ".vob") + || !strcasecmp (&name[l4], ".asf") + || !strcasecmp (&name[l4], ".avs") + || !strcasecmp (&name[l4], ".dts") + || !strcasecmp (&name[l4], ".flv") + || !strcasecmp (&name[l4], ".m4v") + )) || + (l5 > 0 && ( + !strcasecmp (&name[l5], ".h264") + || !strcasecmp (&name[l5], ".webm") + )) || + (l6 > 0 && ( + !strcasecmp (&name[l6], ".dirac") + )) || + (l9 > 0 && ( + !strcasecmp (&name[l9], ".matroska") + )) || + (l3 > 0 && ( + !strcasecmp (&name[l3], ".dv") + || !strcasecmp (&name[l3], ".ts") + )) + ) + { + return 1; + } + return 0; +} + +int main (int argc, char **argv) { + Display* dpy = XOpenDisplay (0); + if (!dpy) return -1; + + x_fib_cfg_filter_callback (fib_filter_movie_filename); + x_fib_configure (1, "Open Movie File"); + x_fib_load_recent ("/tmp/sofd.recent"); + x_fib_show (dpy, 0, 300, 300); + + while (1) { + XEvent event; + while (XPending (dpy) > 0) { + XNextEvent (dpy, &event); + if (x_fib_handle_events (dpy, &event)) { + if (x_fib_status () > 0) { + char *fn = x_fib_filename (); + printf ("OPEN '%s'\n", fn); + x_fib_add_recent (fn, time (NULL)); + free (fn); + } + } + } + if (x_fib_status ()) { + break; + } + usleep (80000); + } + x_fib_close (dpy); + + x_fib_save_recent ("/tmp/sofd.recent"); + + x_fib_free_recent (); + XCloseDisplay (dpy); + return 0; +} +#endif diff --git a/contrib/libsofd.h b/contrib/libsofd.h new file mode 100644 index 0000000..2abf788 --- /dev/null +++ b/contrib/libsofd.h @@ -0,0 +1,194 @@ +/* libSOFD - Simple Open File Dialog [for X11 without toolkit] + * + * Copyright (C) 2014 Robin Gareus + * + * 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. + */ + +#ifndef LIBSOFD_H +#define LIBSOFD_H 1 + +#ifdef HAVE_X11 +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////// +/* public API */ + +/** open a file select dialog + * @param dpy X Display connection + * @param parent (optional) if not NULL, become transient for given window + * @param x if >0 set explict initial width of the window + * @param y if >0 set explict initial height of the window + * @return 0 on success + */ +int x_fib_show (Display *dpy, Window parent, int x, int y); + +/** force close the dialog. + * This is normally not needed, the dialog closes itself + * when a file is selected or the user cancels selection. + * @param dpy X Display connection + */ +void x_fib_close (Display *dpy); + +/** non-blocking X11 event handler. + * It is safe to run this function even if the dialog is + * closed or was not initialized. + * + * @param dpy X Display connection + * @param event the XEvent to process + * @return status + * 0: the event was not for this window, or file-dialog still + * active, or the dialog window is not displayed. + * >0: file was selected, dialog closed + * <0: file selection was cancelled. + */ +int x_fib_handle_events (Display *dpy, XEvent *event); + +/** last status of the dialog + * @return >0: file was selected, <0: canceled or inactive. 0: active + */ +int x_fib_status (); + +/** query the selected filename + * @return NULL if none set, or allocated string to be free()ed by the called + */ +char *x_fib_filename (); + +/** customize/configure the dialog before calling \ref x_fib_show + * changes only have any effect if the dialog is not visible. + * @param k key to change + * 0: set current dir to display (must end with slash) + * 1: set title of dialog window + * 2: specify a custom X11 font to use + * 3: specify a custom 'places' file to include + * (following gtk-bookmark convention) + * @param v value + * @return 0 on success. + */ +int x_fib_configure (int k, const char *v); + +/** customize/configure the dialog before calling \ref x_fib_show + * changes only have any effect if the dialog is not visible. + * + * @param k button to change: + * 1: show hidden files + * 2: show places + * 3: show filter/list all (automatically hidden if there is no + * filter function) + * @param v <0 to hide the button >=0 show button, + * 0: set button-state to not-checked + * 1: set button-state to checked + * >1: retain current state + * @return 0 on success. + */ +int x_fib_cfg_buttons (int k, int v); + +/** set custom callback to filter file-names. + * NULL will disable the filter and hide the 'show all' button. + * changes only have any effect if the dialog is not visible. + * + * @param cb callback function to check file + * the callback function is called with the file name (basename only) + * and is expected to return 1 if the file passes the filter + * and 0 if the file should not be listed by default. + * @return 0 on success. + */ +int x_fib_cfg_filter_callback (int (*cb)(const char*)); + +#ifdef __cplusplus +} +#endif + +#endif /* END X11 specific functions */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* 'recently used' API. x-platform + * NOTE: all functions use a static cache and are not reentrant. + * It is expected that none of these functions are called in + * parallel from different threads. + */ + +/** release static resources of 'recently used files' + */ +void x_fib_free_recent (); + +/** add an entry to the recently used list + * + * The dialog does not add files automatically on open, + * if the application succeeds to open a selected file, + * this function should be called. + * + * @param path complete path to file + * @param atime time of last use, 0: NOW + * @return -1 on error, number of current entries otherwise + */ +int x_fib_add_recent (const char *path, time_t atime); + +/** get a platform specific path to a good location for + * saving the recently used file list. + * (follows XDG_DATA_HOME on Unix, and CSIDL_LOCAL_APPDATA spec) + * + * @param application-name to use to include in file + * @return pointer to static path or NULL + */ +const char *x_fib_recent_file(const char *appname); + +/** save the current list of recently used files to the given filename + * (the format is one file per line, filename URL encoded and space separated + * with last-used timestamp) + * + * This function tries to creates the containing directory if it does + * not exist. + * + * @param fn file to save the list to + * @return 0: on success + */ +int x_fib_save_recent (const char *fn); + +/** load a recently used file list. + * + * @param fn file to load the list from + * @return 0: on success + */ +int x_fib_load_recent (const char *fn); + +/** get number of entries in the current list + * @return number of entries in the recently used list + */ +unsigned int x_fib_recent_count (); + +/** get recently used entry at given position + * + * @param i entry to query + * @return pointer to static string + */ +const char *x_fib_recent_at (unsigned int i); + +#ifdef __cplusplus +} +#endif + +#endif // header guard diff --git a/contrib/md5.c b/contrib/md5.c new file mode 100644 index 0000000..81e6469 --- /dev/null +++ b/contrib/md5.c @@ -0,0 +1,289 @@ +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * (This is a heavily cut-down "BSD license".) + * + * This differs from Colin Plumb's older public domain implementation in that + * no exactly 32-bit integer data type is required (any 32-bit or wider + * unsigned integer data type will do), there's no compile-time endianness + * configuration, and the function prototypes match OpenSSL's. No code from + * Colin Plumb's implementation has been reused; this comment merely compares + * the properties of the two independent implementations. + * + * The primary goals of this implementation are portability and ease of use. + * It is meant to be fast, but not as fast as possible. Some known + * optimizations are not included to reduce source code size and avoid + * compile-time configuration. + */ + +#ifndef HAVE_OPENSSL +#include +#include "md5.h" + +/* + * The basic MD5 functions. + * + * F and G are optimized compared to their RFC 1321 definitions for + * architectures that lack an AND-NOT instruction, just like in Colin Plumb's + * implementation. + */ +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) +#define H(x, y, z) (((x) ^ (y)) ^ (z)) +#define H2(x, y, z) ((x) ^ ((y) ^ (z))) +#define I(x, y, z) ((y) ^ ((x) | ~(z))) + +/* + * The MD5 transformation for all four rounds. + */ +#define STEP(f, a, b, c, d, x, t, s) \ + (a) += f((b), (c), (d)) + (x) + (t); \ + (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ + (a) += (b); + +/* + * SET reads 4 input bytes in little-endian byte order and stores them in a + * properly aligned word in host byte order. + * + * The check for little-endian architectures that tolerate unaligned memory + * accesses is just an optimization. Nothing will break if it fails to detect + * a suitable architecture. + * + * Unfortunately, this optimization may be a C strict aliasing rules violation + * if the caller's data buffer has effective type that cannot be aliased by + * MD5_u32plus. In practice, this problem may occur if these MD5 routines are + * inlined into a calling function, or with future and dangerously advanced + * link-time optimizations. For the time being, keeping these MD5 routines in + * their own translation unit avoids the problem. + */ +#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) +#define SET(n) \ + (*(MD5_u32plus *)&ptr[(n) * 4]) +#define GET(n) \ + SET(n) +#else +#define SET(n) \ + (ctx->block[(n)] = \ + (MD5_u32plus)ptr[(n) * 4] | \ + ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ + ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ + ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (ctx->block[(n)]) +#endif + +/* + * This processes one or more 64-byte data blocks, but does NOT update the bit + * counters. There are no alignment requirements. + */ +static const void *body(MD5_CTX *ctx, const void *data, unsigned long size) +{ + const unsigned char *ptr; + MD5_u32plus a, b, c, d; + MD5_u32plus saved_a, saved_b, saved_c, saved_d; + + ptr = (const unsigned char *)data; + + a = ctx->a; + b = ctx->b; + c = ctx->c; + d = ctx->d; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; + +/* Round 1 */ + STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) + STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) + STEP(F, c, d, a, b, SET(2), 0x242070db, 17) + STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) + STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) + STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) + STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) + STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) + STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) + STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) + STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) + STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) + STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) + STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) + STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) + STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) + +/* Round 2 */ + STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) + STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) + STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) + STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) + STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) + STEP(G, d, a, b, c, GET(10), 0x02441453, 9) + STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) + STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) + STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) + STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) + STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) + STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) + STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) + STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) + STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) + STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) + +/* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) + +/* Round 4 */ + STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) + STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) + STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) + STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) + STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) + STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) + STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) + STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) + STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) + STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) + STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) + STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) + STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) + STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) + STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) + STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } while (size -= 64); + + ctx->a = a; + ctx->b = b; + ctx->c = c; + ctx->d = d; + + return ptr; +} + +void MD5_Init(MD5_CTX *ctx) +{ + ctx->a = 0x67452301; + ctx->b = 0xefcdab89; + ctx->c = 0x98badcfe; + ctx->d = 0x10325476; + + ctx->lo = 0; + ctx->hi = 0; +} + +void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size) +{ + MD5_u32plus saved_lo; + unsigned long used, available; + + saved_lo = ctx->lo; + if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) + ctx->hi++; + ctx->hi += size >> 29; + + used = saved_lo & 0x3f; + + if (used) { + available = 64 - used; + + if (size < available) { + memcpy(&ctx->buffer[used], data, size); + return; + } + + memcpy(&ctx->buffer[used], data, available); + data = (const unsigned char *)data + available; + size -= available; + body(ctx, ctx->buffer, 64); + } + + if (size >= 64) { + data = body(ctx, data, size & ~(unsigned long)0x3f); + size &= 0x3f; + } + + memcpy(ctx->buffer, data, size); +} + +#define OUT(dst, src) \ + (dst)[0] = (unsigned char)(src); \ + (dst)[1] = (unsigned char)((src) >> 8); \ + (dst)[2] = (unsigned char)((src) >> 16); \ + (dst)[3] = (unsigned char)((src) >> 24); + +void MD5_Final(unsigned char *result, MD5_CTX *ctx) +{ + unsigned long used, available; + + used = ctx->lo & 0x3f; + + ctx->buffer[used++] = 0x80; + + available = 64 - used; + + if (available < 8) { + memset(&ctx->buffer[used], 0, available); + body(ctx, ctx->buffer, 64); + used = 0; + available = 64; + } + + memset(&ctx->buffer[used], 0, available - 8); + + ctx->lo <<= 3; + OUT(&ctx->buffer[56], ctx->lo) + OUT(&ctx->buffer[60], ctx->hi) + + body(ctx, ctx->buffer, 64); + + OUT(&result[0], ctx->a) + OUT(&result[4], ctx->b) + OUT(&result[8], ctx->c) + OUT(&result[12], ctx->d) + + memset(ctx, 0, sizeof(*ctx)); +} + +#endif diff --git a/contrib/md5.h b/contrib/md5.h new file mode 100644 index 0000000..2497255 --- /dev/null +++ b/contrib/md5.h @@ -0,0 +1,43 @@ +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * See md5.c for more information. + */ + +#ifndef _MD5_H +#define _MD5_H + +/* Any 32-bit or wider unsigned integer data type will do */ +typedef unsigned int MD5_u32plus; + +typedef struct { + MD5_u32plus lo, hi; + MD5_u32plus a, b, c, d; + unsigned char buffer[64]; + MD5_u32plus block[16]; +} MD5_CTX; + +void MD5_Init(MD5_CTX *ctx); +void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size); +void MD5_Final(unsigned char *result, MD5_CTX *ctx); + +#endif /* _MD5_H */ diff --git a/contrib/stb_image_write.h b/contrib/stb_image_write.h new file mode 100644 index 0000000..e4b32ed --- /dev/null +++ b/contrib/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal 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. +------------------------------------------------------------------------------ +*/ diff --git a/disks/Games1MB.po b/disks/Games1MB.po new file mode 100644 index 0000000000000000000000000000000000000000..108ce683b4fbbf95803526f0e8ac9830d7e27dd2 GIT binary patch literal 1048576 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
  • |Xck@Ys@2H+yk2((s2H=^ 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

    gl9*_m>CxmSD}kQBjw{Z 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

    2UcntQ#l=B%}#QWNJ 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

    Abi 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

    Ev zT5+$AZ(;)){9ntc6)1S$|Fx7_hdAf|TA8}Rug(Vl*D~r=lK;>9zrF|meD5H5FaC30 zEa3f*%r+r}fOA0&iby@c_r!8Qazp-x^)I91e3W0ZUt9mbxaIg?wuU!7ApgtXW-6I~ zbm+JH-?#2LNib^W#6K7mGF0$d(y&iRImGYLzf=pZ6##)v3Jv)DDoE7!W+f^maaSI=~p7p-?!@86Iqoxu)W zTe;qSK9BjqS>blOu5D%_c~oQ)@Y$27fylq`7JxK-#DlnA0D7PQ;%eMB2IxN~k8h0N z>cw|J0fvSI&`(Vb1ph<7NdLKxp=;cdAYDX9$qs;%GHxe8C6-({#RuQ|N1Vg|WZ?hD z_;i07QSk?Dhb>MzSd%~rxFa0!-IgK?{m`#)mJna?`Nws?r3bxDJ#hW%BDepz|H-~4 z^NR~Xe@Wm6V9s$%=G;48x2KF|*nM^kYGbPmHG!GHA}KUYc(Mx6Nj zR!c5_>sOOEn8S~JDIkpgY#{TGDTPHyt|nrEo2&y!c*&O_WYLo)KzhYpeG#$_eChzm z#}PnS|1lixOVG5Y1Xz3|n$tdhh6?;o;?LcTxC^xa-?PD-q(6OZ3m12K%kKr=W+JMY z5A{U;|6u=fbIQ#t>1D%T!?};GfWhE)0gO`-s88fzfR4U>fRRIfk^}i8sph0v9sSz& zAh$NS(esCA9DPd;Q6ldEeapy&l$-{Cq!;2^@c*0t1OC&3lb88k1^w}+1~SRy{Fg$` z0XPQvFIf&C0ST1DFZY~40MdB^0mut}bN(S8cV0ws8-U<|O$kf{;ctU~LO>VM|MKa3 zOL;_)MD)Ge(69K{XKOE=W%o<)HlBTcX%BB7d;~c2hcF`1Xk^m~Q!UPtni701|Anih zuEa(CCQ?(gliI$0JGEoS4yuIMSlL`XqP#;^+zLi!Z*QjvvDp3_gfY4qx13bv67^>)RJqo7Zmsme;?>4=RODG@Y8Vhopa!W`51jT5ea;}hX>p{|2z3$e>=anJ;*I% zqbXYlK)-p&P4s<}gxNj)3Nm^TrEZSK>_;NO2Vz9Ceslg2WmKl20M5^*2C)0dA&*J- zadbGwHY#bja?D;t?_V46UxFo)MZ&Eb4*n-noCi4n znGl)^3dQ+HmKUcFEE`YcY>mMiD5jzsyA67|so_5ULymFGKe|Om!x!Umd|%GLJ1PbO z$j$q`#Q~lO84jR8{CYg^06vxwHxK&lGs(xqL%x@Y{u1&L@=lwb4i5F}1pG0Qp`iI# zUz8Q{fPk;R{@U-k7vD?8MK>fsKd7kz{TG7kQ74t_}~UbB@&dSsV!hS@Tp`8P;SECwPLE>;Vu8k`p3-s zRy>(y(n+$S$)}uTBakU4h#=7e=QL#-;e>B6xc+ks0{B0bKwuwXTQwyxM8ClV`ga{l zLBD~~aQZGn>NCWNytgaA{bauivn&pW!!Pdj-z6FCtLOgo4eMQCTQdGYcvx^Q(;k9-#JJm`aeRN5)k@u9O8r@A{UPJUk~0Ste=R6 z3NU_64TP%08t{jIq+@=69Q@<K$6I1wy)*o4ra&&sF1 zLm}*6Tbg)Gsb6`<*Z?0kArVxXEk!cZUmude@$LWps9(_sy8VaqpPN(^BrqTMoLrn- z8|R#yv;^jJ=mGWx2Q9e%L;OM580460N@(DJQxsupf&Xo5FFE_YUj+^FVIl7mBtjmN zm9%;DX20h||6AS22CNANv1*{TH+p$Pf30GA@4@i2axU(Sen-GFHmctb`S_B38%> zSU$^RsW3&DJWLiQ4Wq*(Vd5}Rm@rHb#t-9#QC5XjZk1W3R@y4Dimf86&?>OpJAkw%j@4-jz8F}ve18GQjAP?=oJhcDv(EiIq`!5gezcld- zduaa!Crtw6Uqo>9(EiIq`!8nbKZ-z4G{brz--ASO--A4~|FRC_@zDMYcWCj`(vI;WA|X}A(Sck=9^{g;RKUkC$GMr3~^ z#P}``{QJ=U%R~DwQ7p8b9@>B5@V$rjUmn_j;q+l2+JAvm<)QtThxT6{+JEu?s^Ovi z7n;)QARm5c|K)*k?0=OpIwrPxT#J@eD_iR}ZQDIUweJw$F#$@viJg;@Q&Q6?dzbW# zu9@Aa?mZkmd-cwu`egU*m(za$HE_`2M<09q32KOQ=&<3rBdC$1@cO@+;J<%U7&? zZPjXO&DxUJOW#;Wm92ksgS-4KYGXy^+f|$1q27g`cjDq59~o9}`>2N6zGLUE-FxTdL7n{S>rpzrR3Ty!6B6AH7$o ztJkjobmQln)U98By?y6yJwE8*3xpyuCH94XxI!TMyXk+F|Np&oi7!wRS}Kz(lrS~V zXtV)3Do}4Q2Eq5ve@nPG4vpi{aQ$!Te<=Ik($nAXr^Nqo{rxQet5Yj%AGwBvxe~); zCT5oM=H#58)1Re2+WTl&CB@%2C(D+P*o-H_+>aJ!xWfy(mQb5AGGo-`wVN^y<#V6zFG0fib3I(gTt$0_j!)jZpx`^X5a7Ub;lI zU~$g8#W^K{O*tOEo3}q^t1D)!hd(mCM721ll(+BXXVsoxN`#wo;3zz@5B}F`a@O_P zXOkI6+lqO$wY8pW<;%OH?;943p(D~6VGZR~F3jIr?v-R>nAFvI_>0CorI$!I-J9@VCd#a(JWx7<8Wknvo4wWNA+m-7o^B;|NX z)#ZIf`CDt<#=@L}{$=SHr*t>Juuow&YpLFoj(<6xANTZUE*dkJXO`;TOWFE)_3F>7 zm!<4uuGs_*YHQwxJZIn3UTn8s_LiyqjIdto|8tIPR~XkMHf-tK(q3o_l?3eyX^lu(zmtG7|W54Od4=gn zA5*=+8!{(t8?|i<^-*RJwQWP*yjt3;VfR%>pG!ZNzNgQgKAwfe8Yk)MujkUa%bs-4 zH+h8_d4*l`3j2`mtjqR(wW-VE42*`egu)BA6{MH&3ex6e6n1qVDzrNe9U@%te+q}U zA1J9iu(R@?9{f*C_|cx)t5@${X{ioJ%QQ#7!Ou1{^5y1jH6rRvl#)-C31m^N{vn&# zDha2C+o@@L^?HgrW3x=#8>9)7nBn-SOL}(8zJvPqOYe#ABGV;23fG2gbdE}tD{ zaer7Sz@=h9O+|K1MOKa5QYdiS3dth}Rgx>t6|r%lC46?irT7N2%8w%-K)zL zMheSwB{Ljiu}6X=S#Y7)35Y4Ibu*dBmls=nGgs9! zfD|Zq*CM%QYL%=;RHay8Q!n=@&IvvIb0Xhw39n32C|yuUm+>;osLV3HaRglm_%uRV z$V0PGpGf4nkyl9N74l}R!ucXZbLU$kg^}b^b=_Hp%Jzs73WZL*4doFN?BVAv;XBJH z-1GLpw6K$M2w0^?IQ&du z^V%BPbAmUebLhdaz06*AZ^XH-6ZY;7FBXdTPhYjoZtev-@mVdm(<%FG)Mf2bu*A;l2@fpAe3%FIc7HTT_Ep zD6+J|R?^!8rd^t;xofsPdh$DdA4z_<*rYRwk58WHEZR~v^6w_yE4LNuDY4PQo9+4g z=%Qje2 z@m%Y&jgHOXKi_70(rby|U$-P{UB-kLU*9`@qxju#X;ad~0zr=uO}pqJ?}?^`yds;d zi_c0N%Fl>2Y7#&KQNXKkA7i63440&hRwZSJrmzgE#8!#!zczwr)3O0^kHmD z@JRl$n`Oplblax%qc{Zd^r@`%iMAR0$L+irXY7B`Hj&THF+Da)D@)K@YmB_t8Dq;VLBGf( z?T?!EA5W>tXRd#(?)u%#Cx2BXWbj=V!=~^PQ^Yg>p7cVdEr?D^GrnXFi%dAvZya4> zoD^|kKvCMT$5Ilz2oAHx?bBv|DHgX7#;Z>7=w;%Qwr?0!O|-6c0q>1^^;*Y3|vTQFn^_wRmiGKr6%D`QoR-X(B1E)EOYiOXUBDISIB&L zwS_WO*-Kfm!_b1Klsvs(9~Kf4KO($uLdbEG^l#tAPP$gFm$bJCS1H4k;i@QATv6XR zckQhWx1Bo|jaEskTuVN`y5xGUV&8GySN$Fd8Fa?-p}T-@64IM~Ieb3#QTec^&WUBF z=QcQVrz~|$d1dJ4_H<(N6>U1aTXrSpuGjV)Z^`L`Ov|}R+Z?iW6OMjq5V{_>HtXM~ z^^44+`Fo~K-fNoYdUV;?`9*<~9aS5jAC#b~YVDNQ3x2W*Cu&{}%Sv1LUXGVvbTyBE zj2bB7b_TFz)y(|l&k&dH{^S#R5&z3m^cvl$cpv~bca!A{;`Ec~^qMZMD6G{R!nDk~ zZLg(XY*W!CY50^Z=`VxnK^x@bONH$>JsUw^8&Wy<<%&paUH7WfY^gvR)WtmJWOVEy zcK)oM-4!#oh7pMqWrff z?y0MK(iVPYxc#T)^MBZ|JKrn21{)r4~zLh{78a__u=dt z-_^69cPzenNpZo&tl3f3LtY{KzF>K43!9vJ)S>xYeQ|rIH)ASHAV}XRep7eQJ3iap zyI+STkrh4I7_VSY_x(DLXt%M~*fUaB^w^QFR7`Zv+*Cedv*PNgI{W+^&Ht9vI!+qq zyliwm|K3@9kC3u1eY^n)yy>a~$%>;l1ZH;Rxl7s?f>$ou7`02ctFlM?irXvqWW94L zyGvj9FNHZ0cHBf~beqJCEM9U@T%9K`?#Wf(^o+^TO%?7M7iL&AVVg8(*wez?31yRe zWR&wY69SJfb#ClF_SFe*Pi~#joZdCz_29t4Lr;n|6JEbLCT>Igg_+gC(e#Mc!UcOZ zhNL%ChWQH*-3)erIahaO(d@Hx%jT-*RE+pm`DzK>vDRr&&Wq7~@%)AowP~i{7OyDd z?#y5Bl&EL7)IK))ksij8Mn|#r2rK{WHZz6)*347WUZ&%ZSUoceX6IVhf}Xf3U0VBb~bsnLp6u z`Q`fj`HPj3tf{6JZyicfgl##oxbx>Ri`Sk0wVt{DRiRT~rWiIiB5PPi#0I%`^U&Q} zk1w0j()r{tui*U|OTFQX#=m&B?zV})QTpbi-!9)5+X2K`@5QbTd2tYLlEK?TUN-HD)1xg- zD_W#8yQMns5=WS}u8l`iNquv@+M6Q1AUe};+q6MtQ}&Ok`Z@O9Z`EyAX(jpE`BTn$ zO!TJ#*S5~S`Uy3yqUe%0MJyPl9knj$tvGS`?6!j4`VGf+uFYJ%ZTOC@)6_$6I6r;A z$Lmqk-(NU4QMIV(fGl)f_|FjnRrD>HRkC%&%?Z<^Ttx?3EpA@vdsx2L^B@1SHm1A@1|zqg!9X_wKjW@hTM{4RwH z&nwf?E!)2Fq^70jZ7!XL7x-Pr{tx=)LBBI6C0N_%yid3?ga#bufK^Ro`6&0o6tI>UeTEw*e! zPFjknHtTHc6ee{2-2+}m8=3gA1xg+=StBFr` z4p+L>AMJkO-QJ^^zd4TSDxQ{j#)d;=nNR@b;U=Gj-xn&y@<}SVi8mqL$w}a@PJhv?gYT(?o%B<{_!Zu^j?Km2MXGaERi{GuOYFlR@4V#Jx_rq|aXVL4V8D=d zKdf=is=7Fzzkq&yZq2-fLthpb@6KMNQ?~o8#|D~xb*9#6?z-$5I!>-TlA4ltx?O3# zz~a9AbKu@zy^;bo`@+~o>&{mke{c4zkUGX-9AXZrc|EjB{i<=rEKfnIQz|xr6&P$O zp5Zct8^g7&x{JkyJM@ZKs(m4sHEBQTE56)rQ^fzE3OaM+DUoDVOzepXlbGv{{(4Ft z(Q&UaKW~^kGo|Oxsy?P{)*KYTW@s~ewn?j19E>WCt=F|nsL7k{eeZRf^|2)zcE=Wn z^q<+SW?=0Ln$RPQY6AP!*u6!9;2|9in}hoNnEd*{klVpCEAz&z`fRN{v}D#?)BKPikfD^x(-!O zyC*X@$K33bJMNti-jI36YT4)HkEBd8IJDu;*Ewjlk>AXYfZH}T{MrS8pbaA`7PNJ%-hUiYVzA^noFVq%% z(>3}F$5!JO(Vq2B6-Ul4sIsaCP%PMycY0`6{)S&2(_0#6oVqsmg~4q~UVG)K@uR7X)aYXObdUMM%cpBLzbtuC}wQ-^jAX1Z5iIikr7l%?-QI7cstD*zd%NbhVM)1 zwq?oYkQJV4U7xyf?^kJ8tebJ+@0s1#kIx=9AbYOkrJ!8~a~*9k+DA`*vpBJ!`P+3u zPgI4XhF83*s`zTz@D1H~<<;}4x@j${G;>M{-dtNboIO5jyiHJ`>|4g1(B@xQ5zUrY(Qd*%~SFv-(hdZ{M zligckT{M01(yA7vC9mn)gr_CWc(Vij>j`UC zM!|Qs=$sME-|Ar; zJ^vMxV`_|i5HD+ltW2@O6rQ7L6V_?7>!*3@>j?wgEzE`E&VL-TMfuv{AA_CSTPQ8`Ec$tdk{~%AR$Hcwd>F+;e*W%GKx2k3QIO*;=(YS+#O!j~Al& z&mL3+UwuRLWDRb49XaLsYc%)YW%5L+tSXA_H8 zUzq9$wvHG_)K6&xN&?C8XLZzqs zjvwWiK5xY{!@8|(8#pcEMSXJEot|@F%Jmvot#z#~$X+^Q-o)%1WA2o#xb?!@`1!0cKWu0-?c>A4LnrF{W_Tv&i%)HSK5=TymrrGMeExK6UF7(( zBhK6J4g03`#c#Wtm#R&BH>Dgnaqd~hIj1(wp_3+eEEpR0_UZt~q=AzIZd_Ju9HqOP z891SK@Q$~KUhcrG9r|4IkJB~h=k?bV2A-CFtd01o<+V%C?iQ?x+OAl1e%R{Ii#xj5 zv6qLgK9(4nl$@3{CA9OK>bH}hF8s+3wp7&JzN4;O%DyT)cL z_r|^?K0mW$_U5=D3CniZuKw5)boA#lvx?0Qx_RzCPw<@mon$xk3AyeUf4%fW@y|~M zx;jmhmkd}pEN2_bU+(y9XqjY6i>C%!D{LykoDPEz$ZTyCkDn|`Sup*o9k=dSUqGaPuMx^iMH1)=|kf)=^>M*%6P%+TWKHrZpg5jlGt9) zT-(t6MQ4C;;zHi_MBSa{4(G}rV$|M}ua904E_{9Q)$dxjKePAqZJl(RM%h}p7H>|Q zCc9HR!K#y9-Lzr%%WVVBzA|^7`eMbmfzw~NUO9H6_qV1YgP;Fg`px+$rzX^4ozp#i zPaT~(`uVEi!zz2_ckkBydUlsq>r%339=A#ppOk0aP|B^9C*t1SaONYKZQvY5_m<0c z7n^RT)OcIz-Nx9X)6LJGn-U^AAl@>fnO!qadf`g5`0u|_D)J&WKE7=5r@3Db-B9J~ zKJaSx&B}q*6Wio|o+YriTNb2J$Y{PqeXZ)%rLXpwy=mUnCuTY-+mE@_?_`E3ee`^O z+0&NlF;i}O=tNi6FrM^@?qfIqt>El?i)OVbq(+Q!N7u!-S>0nWdRiL(_kJ_ObDy zb;4dNzRcZN)$DZH$We<&spq~B*W;Qws6zj){rcV+`jW9pb0-yzbi6Db!M=a<(K`zY z< z&s7(*vhdv2_0H;yktu>*_pb(bt5Grd-|o9Rm-=8ty3@kyyv-Ltvt51Da)GI z-46Cf^{FXurV1LQP<9{x&h^foSsvc1^kcn7tch3TzI}P!tVO*#Seb;`38{h2h9t&3 zH8ZpH>0)X}Z;yQo8~8=Gs`TPCo>%hCR7o%QYkNd}+x1ydzWl5%dPytSYjeNunz#2G zUE!5=KpNeoU?3sK5N!pi-*+d(XchKIx*yjoEm9=FgR0 z3!Rvf`q&%&UkOMYbVU)F@x$cX!*6eXV&oTx6T40Pe&8*KXw-_YEOMr0O2^>*tTs25 z>@iV(Gt=KBw^~m=rYfowX7M{1KX-^ zs+};S_(3wyceZ|^+tyJcmWA7m)SlcLQhpB9_Ov}L~^T~;%ur{>UeZGJK>y|q4L z&xY?_J0>eOZwXpH_LDD<*3J25V#VCNWqJ9|hz~aE&YO?K&6u$?qIdLDqXb<~RdpGW z;#!eU^-E){-fjhN9r6a()rVbnj&U3)=_X#*`=sO0SQFc+wtwBezz?fZ&n@j^oVqQ2 z^RnU*irX))_{^B*cFvj<`;{fV<6G*_OGJa&vzNZ<<_R<>-C@$_uPT<-EZ-8>(NVgK zDvgo2^p*vC4s1J;?Q(lB?BF%KK5i0U{q(4xw*{E4_Q-ck8lS??DUSF*?7eqX6JOi! zz0(VUgx(<#N+?1=l-`kMq)Anj2q<7diXtjy=tWA9A}B~eK#EASfgmVFK#_n5ii#*j zz!ocrlsEqFd!6Up&sppJ_g&{bXI9osCi7j_F4>vcxvsrGn{Tc3C}~61*u*Nu1hTTQ zxGQUM?2bRbwEw$}y(^7n-N%fe{Yd53FX^d#=_6~YkO4iTKK8z=w2%xffICT zH6|bXmSM`mTE9Pvgqop~Wz@^8aK(+z{U_heOl{BmETN6hl|1?T90D(m?h7(pJhJ_U z{N-Q#+C3aYN>K>opmoUV5hN~T%Z}1Cq;=(+S{3#78^$+DGJ*Z1;epXv&K}a&@$r8K$^1}S6~;5Ji4+sJ zO|eOrZ@s;Ca%3p;Huf#t<`@z$MnP^(_tDX)tsU&prL~*A-$JZh{=KoBR))M%SRxiu zBY}{1s`j1yp1jq1tFTJhXZMGw$(pGF#ft-0?YyTRZ1OuYZ{g6Vo8+NIB)`~*fv%Z7Mi@pgXE7cfna<~GH< zU?HJGn6!sK1vWp;WMD33DX4Bo#$NFi>qerDE_y)hHI~$X)@;ru_adywSW5LwO0l zOJC+w>AymW67#>m*M8%rr-v%ithOl*jmcPNTZ-Cf-8$QFWQX<>5sxp7qbTNL4Iag7 zlZc(BkI$xzYVxf)N1RJNYe7ppX`wZShly{NpLEKPlzMZxQBQ7CY#>dR0dxUW8qV#0fA#N z&)b^g)GzmhkK|s6%S3C*$SoJkX{vDOxDv7yeQ|eX%+UF84A-;vj^&%evF}(>OpNNE zjHx6J)pPsL;bf*&|KMWM$EdLR*~;jl>&Zwky*HS{_go-|E_z}J(U44H{0yw8;+7>o zqpu&->WG~TQ$e1FHu)9l+fVdZIvmjw>6)28UwPJu#5}%MDV;{ggoy-w7JD_^ur|OTj+O84! zMhQ{Ps1cZ}_kF@JoU#j2%T_zgqrGL6T%s46(zhcu#8DR8gYl$TXeYyT>{hk32GKs~ zMN`LJ7Ac;x2=x+P90yZIH@8yf^TJAFavnv^l~A4FCm9baT5i@ve!7Y5V_q1D5^d=4 zL>GA<;`vr16S#w*NT;BC5C5{IPk!l?I6C{%fT^Y^HlQiZCoOJmvCL9FiRD8K>?v>U zlUg}{-XF%$P=%219me*ICp?S6cEx6BV6({SmQ*;kc1!P%U*&sIYZy``_ND^zn~G%x zxsi$JC+>{9QfFpW4lhQF2p62!HRqoZuPvdQ9g`?mdVDI~m0YDzPZ-{tSvEhwVtyhr zsMdZ^30PggwRJ`4V(w)rP)#Z?6s#y#{yuJEl)h(XRk`eq=ADx)iPR=!#0dkXpsrhG z-xp?&vxh+d=fI=%ef{Qx7EjBQo%^FQ1r+eJ{j(KjLu0x2mx?a$G{~cSUcFOrqXx-x zdXkyF6nCnIIB3W*$449 zHsGS7#Q9&i_?E|m*$B@ zF%HJO8x#%Bd>Au_2zh0D@-1B1Z$-H0P;Pr*sj;TlRR?$9+H;X-ysb4e^Rn*LZ?n)T zGBEY~N2IPP!&1tUIaOPST?51NDytf(2d9=fJLy}*C1H2r5YhE#`bj@MOe%ahpg+U1V8vPhGa zd28y54YpygVLvm7K$&4b=1)xSQQjXl`W$Ef=LX|^(36&U)uFfNecCUbne2_?hL5&Y z*dE=u9BthFN=Y(EjXyUnS|T|CwYt}|zLxOfqd@-$rlOGPRNv;6BT;QsB32UVAGO-N z+UmgRqj?fuc2^{1!Ca*Fc-3sk@z+2km;BAfoUIS@ZKOq|<7+YZ8e!22$(wx#&V?>xo_~t!i2p1^5*BAq zQNv5ZRiY#BoEW$buO8BuPmi*+!)I0xgF3?so7)B z3d}s$)pxBpBP$?5AZVj(d`-O^U*V?!^VH3y$?ekGQp8!KSBWC&jqf_1hv-W_Ex{@< zHkPiiw{%Ps$&p0G@pjMg=+VNX4tDzlmYy(?SV`jgPTM_-E-#)ui{`+G7WPd9-n9Sz zBYN#^1S-OWa{8o0xbJ5pP>1AA+;a4NGnRY~pcEw!;P1n2%J3s9uj*h&Ol0*A-m5&X zV#MaDpZ7%wJ-_aUdrNuEyy-r$W)LU3=U}m3h0vND*Y&Mc4og^$&o+#a{lhWEB#x1} zu5X`uSdX`X*Z?V2XvF_(dnh-2bRZ)O+a`gF|Lgch;}wcTuTdyv0-9)7^hyksU_`z5 zS&pBQSN~F$MljU-BtG-pJ+{=y^xuB(3o&5rmz)7#P_XA%fm7AdbC-&W?Y|#V45a_$ zlOgHO5&||Uvh}28kLu&9p-izAKK@@S3Ol%sf$QoPFI$n&FBcWhT>Y}wd~!{~_S3_| zzn}f)sXSngLoG3D`z-Uh&TcrndS~LX(}5P{nuI}`@pR>TOv+EnO>E;A(T*lD(xl}T zDW;f2N9>EV01SKhV}eNX(R%T1r3~cqVi?00B@{WPgYSAL{wwh;PDhu|RVWmm6>u%o zfJNw&ba*em!NMl+ACkA@Dfd?+ccrHDBCI^$H`vKm*snM!#=aEt>rBWh{)KJjj=+|lxI zkA2gUNMm{)E3eAqV~-{Kjcm5wVz^N4P#@HYa2=yh&C}gjPwDjv`81WLJc~wNmFksy z2W&S~6OqMfzqJ45>_v!(9nx~9aUAx5yOi+uX3%rEj-ushcxc}?) zi)N1@k4SkhsD~hW?P2|eH%cA(Y*#CfDkU8FbxYZ>l>FkoH7kz8wAEE%mL-;1tGVVx z-jQ`^gkjlo9E8DF_;TY$+#0l!fLK71Q@XQTN?g11e^$?}JVe0NUbC|}me)I(%JPY+ zjS|ycHJU7_B8T)dPI_x$%_$bX*~OryumoTIJJ2|-^7!d{I+(q8Yq0>JCaD6Sjc}3cSr?rY0u<*;4HL z_jio8Pqm%*sT?TfY#})4gz+)@1x!rdB^jl}YbWAakE{Fyd<-J;bf}6aV zr1G^sqqo%y4D8#=Myco)21!f%@X~K3NRlJ6nQXm8MxyA|Sd^S%{*1B=9W9ah8MR|v z+&NQ7QK@B9Uc z=JE6r!h?ni!Z*P6iI`B2kxRO3Xr8@iQC~ft@^Ihw?LCga?{WHgkbQFEgf8!wQ?InQ z%zoh6*Z<^xXX1l0VV_VD;a*9UJbcS~rXEZxj)K-WnxUV}S5f2c@1C+xBx!HVYMAI+ zWAa{aU#+bltgXKu-90pQWC0#45PN(>VWa*>bL90}+)P8Vve?C(g__vM;X|1>eD}vm ziNSCt7HRC27wGe6Dvt-}7Vb6D>q@;@vaR0f&$WH}DSE|cCoG)cygb;cvG}Vo$%sLk z3(Du-O5yKa_+byK72(}Y3SlJCCEIMOuuf*6(rLmq<=XCU``Qk7MEjmnqw!l;zuifx z!qJxvk{LT)c9>h~0nx1eQ5O;2DKdHl9c%T#iw0kM;0e@UPxHoU)JZZ{sn!jSiZ@T? zXQ5CKERXh(`i)ZW%ud1EK1XV1?76OC+Oe6!AtIcNah5CJ*3wGFVhy_o_AueNx$oHe zjTH3B5Jt1QWp_JDE?9Pl#un7xPr`;i1RGH_pLiwSP$-yBSwZH(ctkzd*YR1Lv;pJG zLCo-K)*luiA$j7Cjz+N&X>&wVMoh)CHtwRoRY~HQEy30qAyRu>GWd9`L|moyw5gAjZvgp|ay=cAm`lvc&Tw90

    BqP{5n-eXJRknMGJKd%`t2Kj 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

    Mc#O8Np4UV-00nQJN1q}IN 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 literal 0 HcmV?d00001 diff --git a/docs/Compiling.md b/docs/Compiling.md new file mode 100644 index 0000000..652f20a --- /dev/null +++ b/docs/Compiling.md @@ -0,0 +1,33 @@ +## How to I compile it and run it? + * You need a C compiler, make, and a few libraries: + * libasound2-dev [ optional, for audio ] + * libgl-dev + * libglu-dev + * libx11-dev + * Many of them will probably be installed already if you regulargly compile stuff. + * Then just type `make` and it should compile. + * To run it, just type `build-x86_64-linux-gnu/bin/bin/mii_emu` and it should start. + +## Development +* This is the first project I made using vscode as my main IDE; I used Eclipse for many years as the indexer was pretty much unbeatable (still is). +* To support vscode I needed some tooling to create the '*compile_commands.json*' file, which is used by the C/C++ extension to provide intellisense. So to create that file, you use `make lsp` and it will create the file in the project directory. +* Another thing vscode sucks at is Makefiles (despite the extension, building is painful and next to useless). So there is a target called `make watch` that you can run in a separate terminal to auto-build as soon as you same any files in vscode. That is when you realize for example that vscode re-save the file anytime you press control-S, regardless of wether the file has changed or not. So you end up with a lot of unnecessary builds. I'm sure there is a way to fix that, but I haven't found it yet. + +## Code Style +I have pretty consistent code style across my projects. +* tabs=4. Just because. +* 80 columns lines or so. I don't like to scroll horizontally and I like splitting my screen vertically. (also see, tabs=4!). +* K&R style exclusively. None of that Allman/GNU horribleness. +* No Yoda, we are no longer in 1975. `if (0 == foo)` is just stupid. +* I use !! to convert to 1 or zero from an expression. I call it the 'normalisation operator'. it is not commonly seen, apart from places like the Linux kernel. +* I use *minipt.h* for protothreads. I like protothreads, and when you are aware of their limitations, they are a great tool. They are used for the video rendering, the no-slot-clock etc. + +## What needs doing? +* I'm sure there are bugs. I haven't tested it on a lot of hardware, and apart from quite a few games and a few known productivity app, it had had very little extensive testing. So testing! +* In the code there are a few bits which needs fixing + * The mouse card is not working properly. It works for some (most importantly A2 Desktop), but it's not working properly. I suspect the VBL Interrupt handling. + * In mii.c, the *mii_page_table_update()* does work, but it sub-optimal, it was handy to debug the countless combination of soft-switches, but it is not the ideal way to handle that problem; it needs a proper switch-case statement. + * The floppy drive emulation was borrowed from bobbin, and it works, and it + got it all working, but it's definitely not matching the style of the rest of the codebase. It needs to be replaced. + * Plenty of the most complicated piece of code (video, memory mapping) load a dozen of soft-switches, it probably should use a separately maintained bit field that is maintained by the on/off switches, and would make it a lot easier to test for bit combinations. + * The static array of memory 'banks' works, but it prevents me easily making a memory extension card. It should be refactored at some point. \ No newline at end of file diff --git a/docs/screen_color.png b/docs/screen_color.png new file mode 100644 index 0000000000000000000000000000000000000000..a0cd62090c38b13babe28e2e92bc3b1b4912cd13 GIT binary patch literal 636367 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

    K@V>rLrG$ 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

  • RT0;Y|iWgZ-3XST*f`q6g;iUNNHSKD7mOIW|%@r$wF4nn4yTymbxl7Ou_!n z6ecF$6;;j*Q}D86D^{)zxlX7;&Dn-2m}V(pcn5G>@h0cZ($E3sSyjf8;_CS9Q+1ZpqV!BKW zuL6~=s#YbMr5T536^kUrZ9%0ct4_sz!xXv-Svh42GqF|8N;VkaRRKbXh?O&D;rA<9 z#TzBZGI3Q^vUOF?O=bwDs;W_PEI`HcvRqYVfF73AVubNpDR4V@nUv8yHy92o$IG3P z`-KsER52^(j2QmWuPVPZ);v`z4~lS>8cb}mSq^H#!A)V65-g2aI2QPG8FhK)>H;lU z#>!+>1RI$AnyOe`DlGBHa>-WQI0+@SD$01RG!)T`q>L81!lrN?yJPdVZ>}MhXDpgA zhJsH!kl8v*uJN#ZlZr&O%0W#yIN}mQmZ4xXu5em}@v3Sv?&I@{u{@N?%^Z5-6=5)0 zcTnrN78XyoMQ#D^IABqpO(KHRBBbrxSK8h)CAh_eh$+(%UP85^?+N2h$Ss){X_n3l z8)b;RkQEc=T;gTikohV~5|eSY5*;FlrA&BN70uG@1$tqyLVABiEtjBo4z)_;%(yk_ zMDZ+n+XDS|{5v0S1K?l7pqX|s{)&Q%Ai08-A%o-wd6T)6qw+j#)LecGt{H z8ze=^>`J*w5)pz^&XVV8#nY~FSrHa5U8eB4&pEJVOwY|+CJhv2buH2PMH%y#nai>M zyVN|?fwT?UmAHg#kroETjoZ$`Z3M&!fb}8{u6TyK!K(_ight1N-w3AH6I0tWO`+Q0 zP#^?s7hG?ns;6`~(&-ej2X6XYD?oGR?7q#!(0^($r&5XmT6 z@iiwnSkg(97kO|apF{|?XoFHSWg}HCRe6(d_<4g;*P;!A`z9*xr%7yEXw54n*J-}Y zJc0Z0Q$lDIH*goVEo2#2tF%tE(W@*R!6|M|P(ZllNJD^#kTT}AU~N0-b3ZR3b_Cv} z+H&%QMU9yu(G(`(DkUkV`{u5z;=JMF?GGTMB1k<4V-8DcLzFh~J%uV&#cY+<45pd1 zl9pdJI+%dhfl@ik)G^_guJVEaJXCS=3YJaF<;?8xEHkJzz`=k5%O^2+6>cGsmd)d` z?ynT?WpJZhB@Izx9Z1J=qO#$brVvrFPF;tiZzz;S!lYpk(MttEmIvAZqL-Y&$fo#U z0gGe~U1sKf%sl0V0l_WMF00Z+FH6%OH}xqx$Q#Kbt<0HCPJC|NiT@||hES|w^_n8LEEnAK}5!xUbWs<*|KYVF_EpfNG$9h z1r=hs_G<;jR|v8Y38MnrO-Rae%MHQE!Z2V9of-*=6=Wr2#zlw#R8%ZaUs#fPW3+OaJpf+x<`9`{E}`t5D^UG_%O}7sWSElMZ(9 zu}A*uR_oJkETE_1&Xe-dk17ve9V8T$o=B5;kh;)!$rj+7@vIwsd~_Do(NRu?Yy|6i zX5Mwy!|lo85y$HG9pSte40j6zP*I@9*43qTDRB^0XlJ2XC9bnNLLOZOJJZCtW+vyw z`X`ZyaiHQtf19+rM#C*cOC8L$QHtOkqR8ZMwrn`OL-tJYHDs|~O*IbWK}tvx$W0PQ z==?YD5B`VWu`veNA+&GR>Nx5nQaaBk?(-$Vny8R0Vf++wlmix?HG9-w-D(@vx1;6O zI~T`whQ2xX%a0GwE(c~>q!vfbXl>l&D%Vf?L*b*a*wXf)JlvDJ6t9Z3F4o;j;A{fT ziuw;e^`DsvG}jK#84cTCu6qV?r3lj}LHaYLZ&b~`cC_mEhpi863wO~2V|pS1b9e&0 zqU5>dR0f-uE(S8FX@(!BYuZVyjzJ$aD3-^;xsMx4neDyl9xt%q4S;T`xGzH+m%f|O zzD4eLppPGxOfNXBjXL?1kWVZt!r{FIq9@m#jn4RpHUg_JaR$xN)j+NrSeZrv328gB zx`yI~pTvWUGe1Qg8Pc)Wdq>Ikj$w+1N(M4;F#9!6dUjs~M3gx+eIRlgWB_hqh?ir?VHS5cDL*v4r()BE@ zXQ@%@Uv=v*P6koa*u2z@8g5!M{AN=n{Y_JVy|nr{MK4UWYR{&=axi3p#BO{@1or+pi31Pu_;R%mr^VhRha131|uCl)4x{e_&u z?1%dNPc<{|;nxgm!Tt$3I3WfJR-Wng#3b;iKJC5N?mTE3$o!IJVyg_O@8;G@syKe+oE32DQw2T4Z|K0w$S_sa{?iB>D z3Q!#xc2#WQHQ#~$Epoq!<>fh4Z}h7Pm>t(6*f}BhjE2$@iZlIu33L4K$Q~RXk~_B1 zZl-ev6NS5P1d+4mblI4i^hl)-aT_p<+y(yx?rxDiLjrJr_;~N|!)A$GU|NjNrcc5Y$=_MjKNx*$Z}?@4qBME6 zds)7hFFLC)e(0xs`~OZ4KQnVBR#OH?rEa0~tDW>71a}^;5spY$lHdFE$-^{vuuodm z#it_(&GOuAi|r1EzhPef*5TON$6tx;nnt|3WIWY(#7y{Y=Cl^?L|A=ldU5Ie(46( zQBxn2YD(8lcSl$K<1cm^Kiav|ZQjGCC@&X(zFdB!6q>$OXMeW) z{9PXA>*3v3yL$!_wO_`!$J6}~JuInJZ1rb52ORVL?j`e~I~(9W z!_szw-Tu|+NMlpnUccELpEWA9jI%_~mih_@q?AHu3-*t}pp;uRYU6{QNfRXwTv2V! z(xchTfM538yT?24);#oZ#Uq%F{lGNE%i+D3dwaQqOfe{;JLBnYY(5MC&;a97>z&xn zx0?124x*TyJRh*ruJQ1l)%ot#X#=D3Qm;KdIJxQ~7$H@%+o%p|S1#_jUN-BO2RjBR z*A>>69b663 z_6LCb%h!8XuWK9wE^58W_U$XI@?tA7m=%Y!xxrx9ZT641A2w?ki7HYupSi24QAHee zkB@iW_Z$>vl+{{KPa6^Xb%a=ZgLeGb0`duIHQdJIPZ8^sa^V3L4) z&ggjOV5|F8!~;npAS z4ZdnL95tek)bwX%g^ZlJ&Bgwa;S_*q?^alQuq2pXu{X(&|8+EYwdqV#0JG(+*V;PX zey8puipQjuKO6pd(fpzDaHso^Yxn+1jUW#q=NHB7r{WyhjS^?i`~5@bL(4)Nwlp$lr6K4 zzv6%RExYrjFMh}%jr_$q`Rf}Zzuu0wv=VPjjqL9=PSKP^|`{yvs}7` z$V$wrSCS%6=9zW&#Se)l$*dm-p~NN5G)sah4|PGJC~A$%Q6^CdBdr? zZn#z1bz=|Tp^GvJW^BF2)Rz`C1%v;YA%WcbxD{u>4a*^hpa)fOz+e(>;O2!pY&YrpCxXmp4uhSnvka&joL|gG>Fa#rjS`1TqEZb-b*j ziEfI#q})v*z+h(D6tikG*Ns;2N;ok%xPVg?`IMeFMX5?1ja$)VYeMU}HRF+NR7+p~19&oR{+|nh33D!Ki5LX4J=wxHOFx z&1P}V6rz^rO;P6Av~iq0U$9x`$%Hj{MOQwjP7Xqw6|$Ze z(L~s|`!wxP=B7|%T073lc@<5hfdk-T4g6f2vH1B;IM)AO$XYrv*jU=P$g(MQ;`2_S z`X!x0u>pC>Gpd3rQ_)mnSt7_bz#9E6q<|uZXe@O_sLMMALP}XnTQ>#E(`?#U*gtYp zRHOhi0$uwjOD2q$xO3RyjhzEICxf&o;t8)PUeN)gP6ix{`AJbN%4jSt+=;EatnX%m zqP>E#B3?AnOll3Gc0*$~^<0dAsMBcPY}UACmk?jpZ9BDbBYv9a(TpYO=iiN8S9Gny zC0bvAN>*hw;S}$LS;(l90mH=3LR9lIo(L100(vxYGajHjQ|jgw#C~<6_|;E&kD)9h^DN%j8h|)` zAeVEdq|XvBV?KJ|tj_cKw6Kr0iz9M>N=g^wY}K+Br(EKnGYlC(-L?}8V}Mh0Q%uH1 zfyn$g^jF3vAeE*ru~2a;Cj}r9L;`$iB&K!{5<Y&7@X*lL~BZdnNbGR}W_H;8?qC1-np~PJs=q+B2LEC3>fX^8YH`d1Dcz|MB z4q_?uYH3hRa%-o2E8aL6ruY()OEPyg4I8Msb^lu0!EVMNP~~c-i{k)mV6;m#hA&1T ziS({!B_WGpex?;!Ax$p;3>zl2yAZVWOs&!B800#U$d{YY&-jL^7wAgPh7Q{q9UAyK za>8a-UJwifiYUL#cd~`RQJ-Bki5XNL2A3KJFus${ zwWx1c)3$ktuLawJLCr;qA_M?M7+X0*P20CJ-Ci??9Aob#Ux{kwZVO!YtclYtqmZKo zVsOzYbLL@H34mHzgM2NqqNzz)PF#U6R)h$lwzH+e=X<-ZV>2v0OwVQ-gt6Uorsxzg zP_7x70JM8#Psf}A83aqeWnfiRYT7}S?Ey;ISyF9rr)A&Af=6INP*h_o(D}9I^%D4b zQ&44`H-*)(oOoQjn1JCkBjA8LJhQf0r8d>D)68gXvM|-dGpniAcHhKh7H*k#Q|#ec zL8OFbx;&ExPOddub=cWBxO8d=$%UGGJ6bBR>eT&fSqJC84A-c-?U|=z4yh!=d?j&P zW2@#}7`7Z#a5fA>2$2*owex*#jQx}4z`vAJ$OR2r#1rLn^zB0j1E7cj!>Te3eSt_W7S6Ud=j+fl`*DCJ%tT!#^Ww4zmr?}N zY=F0JLz#88JnhXLjlj}OCQCnKXjV9e9r7$FUT8{sHBDS|*L2V<{4}TF2Fwe31{ORc z39Z}C>Hsf)Wps*Gw`>uOwgAGsoKT!Xt!Wdi*d22l{~Q<|Uj`?JfwoPDt$RkOeP}|6 z5;851wKHKwX5PtS5TfO87^3csr|lOShOQ!M*BG_|1?L8|3!Y5yL5L{nc{1F8WZ-rx zHX6kwW;ME4G-bx4D+ut__`=5(2KY-Dzx}`bcX$4C)B>$QG_Yo%XOX?B~ucU=rSS%mAqIQ;(0u6A}Hp3`=nj;3wm&Q`tmpV%=H8{n=r zzq=D1p3@yYi+4Vm*%+0iDr*O|iN?f!#xLc!yXx9iDE~9=GAiOt@spb2vktL3-u%w ze5azQkJd8VyS;C1wcpe}Q{KFc$`6IaXGF=Hdc!z21pss1#?keqQ>Sy>KFY9mr6u`6 zakf{^H4?0mbLU3z4bMbNtdaR~`GZA+`sDz~G}t+9U1vDyGi3D}*?b3!bu(f-3Hy)3 zp{7#WZ{i!-s{p?UHJy{z!Q9u+Iy=?kFh6xLk3eMw$L+(7ix#h;)U{%Ay&P+Nzp2xC z*}jq6=zMQWevqH;m2<7-(q_zUDow*#N@yC;WRew->GqA&y;~gD-rFp{k-h3rH0Lei z9{6ux^WM+|;YvE*l<#wa_KM21K4=YJ`1&N=Dd&g9nP!U83XVHRk%OUVrg9E4_aN6$ zd3EVU>n?531G|jfo17gk=bG-;!XKTq4jWuJ^+j`(9S>^E>?&dMv-<2O6~`RTojvQu z*Ms&pW|}dqvv7YB?&(1EcyZ(GiPxaT+c^HK{d>zT)LTmccFNgder8LQS!-L{H-c~U z?0xj@6icedY5j@9Fr3P+Qg=g5O)~9br;z_q6#q|Cae{xY2d}+ljP@~5MX1TK8b4Q> zhaExOG%oD3o_3Jt~KZfZ+SLC z88jAu@7D959=s4ZkvBL_kN#%n#b}8U!}Q#~V{1~|q~+b}`>&griLnryN6pH-x$D@yDE!1P>aO>^k zJ8!iH+&QxDdj#FNR^>5&vKH9;139V=ZdG?2g%(I+ zMNh&{HWrH5Wy;cj@lpEEKT`FT64KT9!p0Q__{$kWsB=ARh6N)FG#(vb*teDP*c3Vc(+%l@2~wTAj~RKx}W*MZR2Gm*B{claHHA@)nArVangNdEX2|L7^p z4Ik~9Hv`NtxwZ@zyo~TE(=EjIhcbAn^N#@JDO|utZJe7G$|UPunGP5YaQ_hF_F9I= z+I`~`0{||7Ca}=-6nl8Vtl*^^EVf$>a)EgT)v|~(G>uKeZEfEVgB{bvlE^X# z{dhzeS^PL&6BnLIs4_qs;efTxPLK7MB}4MGTzGv|~Sr0$;-%hCKJOD#VyW(+Nb2 zXb%hkgUaxe+`}0n82o-bo!OE!?XaHuUv8FL5z;9tx2 zQOQLe<&Wd&L`c2$#Rgpv?$ewC?Fx17Oko<}x+=u6hY$b?k`%B)6L=vww!X(w0#ZPd z=)jil5Ih$G|8hqJk*VGDKM~EC*hUE5HFWjWrK9`1b&e z(IEHy5<`wjC9RT$3A$JqCb&DPA28gU;)^oMR~kstwz@s%mIAGRsV*AHp@>y9*8fgUnDMfPHu|Oo%Xlm`?Vq$qnV$k)BZ|>-UPTi{KCcX;B=8?hp`owy zG@DT~#um0@+o(c2(G{UKMKs~1CW-uWpxp(g$dievaGP<_qRh*HW6Yr`SUBVE8JK9> zR8e0oEl4pv0i(sd+DxR@H&w7kdNE)*Vo_Jctcg~7g}h4Cc`zHVRklzsLc|r z2ym!F*LgCf6q}-UIdyUX%@nF$8Bh#F7yReTU(@Z& zDk}U0d<;~fO);yZnf{A~tc4o`=J?`ekoS_~`j^-VMTc$qxx#p>+OG4(yl`J>9YEO`kH);doX)K;>yDQ?_+)aSQ{bkoj8a*; zDFno2=agVQTVAO2j77hM7n7Ds#!+#WGu#)TlCD~s5M$EmU)m`EfUoMVdk%dqH^p>P z)W_(Rg_q6ulQ_0<031g}G-U;L3a-PucIjDq7A6gs#rUjn(cg=r&ep3qMvx6Dd9`Djt zYJB12ss;K>7+?SI|Hq~H;d)vrH{<4qxzJS;E*wVfSXtY^B*2PD)+%JEQz~~)Vel9%{Ab#N)kDZNP@W-hDfSNHa`R@LysW&e*~S}XlAltsYQrm<2C40%DpN?C+x z5_3{*7HYGE%TO#>7K}#F?dpFwfA5>tKmJ|lYlyf)na6~n&tysU_LRLn1y`WQScUb| z?JW0j8H$PJ%P1YE8u}$%*WI(+!lXOgHRFR;xusQVf%~Os7fP!aQOio(2FDte!ra>o zc9JcEPxx^wI~^`-2Y2FGwl^GkJ>3?Ag|&Yc*bFDs8LNwu;RhxLxPk2kp;pvoO;Z<@ zz%3Gn32xxJL7@Fynw&0IA94QKeBTNn^0#8YFEH>`SpWe649c>laaaV`s!)@la6Hp% z1%`G`Wz}l=QJS4%l;1T?br2p@@#k1L*8(0{| zW-y5ReQhUfW!Y%Cv>E!Q%(B*_QHr@92*6(HAC@i66sAr5mT%$MOiI4lJljN1HTk%z z>m&zl8sKT{y6V9Zxq&*a0U-J}$J2lQ0Xs%TB*%g6ZD{F}0;B=NB0Bh_xH#Y1aCNeR750w=)K1U1z6Cb+ZYHRZkaKfh)zUb(sVEyD)IYQ< zj2lI`UFmHIbH8{M77gwk2Ckq~VTyf#U>$)&fndsxBHS zv}74O8!R?$Gzp1>*1YUa3j^0qJ%6x0dgS}4lF3au-7l6q9IMVllVyN$i0*>WN}QDs%WbGo_5RbG0^1AegOT#lElACrCrf*bacTq{-*Ur1 zgW1Pk{PF0cRe-waO=6GiuWUPyOdKK_%iMdiGEy{$43l`F>-aha!1#`O{uQeUu$DnX zMsu%|;Z%^6_HpDsk3r)q3(C{sqVUjSP(<>u5G{R$7+de!*M6V48Zx3*<}o39aIWNt z$OFJtc|}q%jtRk?{25*TuTPf$^Ama10(~{UxN+42{pF0_(B3^jd#kEh{o<$1lYa|X z2;t`b;WvK$>uoHRxiRW#_~boLrvzCWaBRNP$_3#vzy7`Q_Q|C(9nqox^0#-2E%ad8-aG0ClM^6+gk*wJeXpZpZ!wGx*IfQ5kN5;o_0gx&hg zAO3q|8`-Tx2Cvz_J~D2iOIc%_{n3X{|24r6H@bH4``3Q0-$6a_DWU&n_t_tt$65(^ z_v855cN#CjXwRNK`Sx&eA0Ix1y7sfx!H;SidyZ_!d-2WfbPpZcJnB4n`tZ^7dlt@9 zJlz{VdHwxWh)z+RI(+;28xLnUG*d*$d&}y3IYX&>&)L0x_#15>nLVjh2Yo&9_Li&#xKY%Y_?6U0~ywogX)C@we;tIfmJ<9>xcs%3-+ z+uy#{{+gzE5f@LU(O*!Cft^a4?W!B<&(JoqJyrrP>m_dQqg$^n0@NgCNq%?p{C508 zYq^|yC zdAnS{wtC#F(CVe8`^nDT7yUy`6ZI%LJDlYK{?MiEC%ZRJx(HlKK;DjC-Q7IZK)I2( z_3`ZoOMKvVC2MV7b)&!3w0{=i@bvIbvJiR@O=Wh?rV zsM0Q0&!Qr^x&IpTiP2#+oMF zenjp(A~p^_*X_>7`*+tNIzzj>xwrSpjYX;z-zHmIAMd}GJ18&;Y5Cgr&-ORSn39lJ z+uKie?>88duvI4yS04{b6c;hWem1)Oynj;zvM0>V=OE zum6T)p`$_)7L!NsFRme+EfLCnZ`Jzi+QvL;ge0YUudZ;oW%@UhUwPMlmtdxb=cDm= z-+g}_AX9X!@a>P^cyw|@GsQZ4Zx(-#)6aGa0Ea+$ze3Wj^sl$l?`eJbb9=i;9yAoa zop40@R>XHxZSC%!+`9kq>+K37QR(J%MWbAYeYGj``ynlay+Kd&bb^7CZ@|Rqoz*sc=Ft7IUfk!xM^3M9lZ$B3}Wpit~{p;SZ zZY5}+XCj|P-`(Ut(B3X^f9tJl{{^(sYAWRF>9s%qh(ASdCyaLnH{T4u=HfQJli~9D zqxTnm+=pNBgCEVW{j4VV)Ukf*;L(+XcIV>t!xh~ zv)M#&S*3J+nct!*8_tU04RTV!;MiNgSGq2%|5C*~YT2zRVCaI00KASRGFf-Oc)od-2c}5vJ_O*h}z*hk# z;u69vGZxKb9dp>NhXFXaT)>%8By6)hpIN!=kVI9Uth=1y0uHMfTT_+DQ&X`OQRW#(U`G?o{-`~iqO#5 z&IB`fBv_2Qa}9%;vl>&CI=4qP1YG4Hb7RO?iq?9){ z_K%#iTJTcu!)Ly18m`R>i*i;=hIc$gfL5}hyuncotr=TWmg1ezq zhE?cd!)b&A!q;~~UIJfIhSAq7a9O~#w=<<+Ddme=OMmkY7onlGkZ^7kDT@|5DXul3 zyk(epzv2QaUT8-JB2`}IMJ#Pyv5W)g*%sTR9fKQ|sgcr2UsO$!TG%Nt)^H|-Zi=c9 z@$#}xfoGD#bpsH>~56_uGRfUKb8RZFl))1~JZfur07dS&SstM(H^|xcBNSe(`U(wb=*~@@5 zXq^@+i$t`PDF0^*Bkc6{aZhK}doq zWSxoUjY6id4ON=NBj{q95>~ic`Q&O`jbDCT1;Agz$Rf6y;*(Lu%#C5@0pKD@ov3V+ zYdy(1m~4 zK}=zodZLvmVkxbEiA%`FN!3fVo+~m_wvq(*_*fQ{v0CHyMWvw5z_!o-8f0q)7!D@{ z&=MR^r&o~zID<=~PDD~vFDmVWn8e%IOE7TZgHxC@DBGI+X`b6@RQi|&I)_Twv1e|y z09dSfl0%8VNMp--wicmw)`4;XQ4UsxF3uC)Ocom0M{vJfUQg0JO$WGeX6$S#eAJ-D zXunv^lN41l0aTWhRpc;+=9|$NSvxf_If@W8i}Gxxi{DzjPFfMiPL#4DjUiZfRR91W z07*naRLX3nE|aTJK!jmw)IriPYOitpjn=?yWI2nBI>W+UmY4Ze;w`naPL!nU7^)g~ zyMZ#LFq9rIT{!0p2C|j9IH)m&Xrg)(*#x?&{<$e^Z=*FO8d=UFv(C|-nQcMXxXxM&fJIb9kx^ov?pbmpflF00s~SgejUw$UzJEDc~t*+lgwvP_JN zQBw5Vk-$I|#;ZJLRTOHUsW5rcUb_xDKV&Rpv$cuE!-#}t$)cQSPQg%y%`Hs>kC|Q` z)QPv$F!`mkRMW`xFWc8$sk)pth59Hh!_$M znZk6Q6pDy65_58}oR+z`QbD>JU--DnseB3JTmQp9J^Dv~{}=ya(R%OMU+owm>2p;f$MNao9>5y_I5_VGgGWbS+390q zMgo@S*+B>J(W*_8{rpuRaHY}A&s?D#jq`lR==!f0au?UEB#;99Qia-wcA)8y z+`^?u7wjW(eMjm-+0w|RnQMDR2I6OmP4OQID4!H9s5DdbRQrZFYAe(^%m_O*&L+k} zJ0n)$W~wD|Y0(7HBAI`#cv2{@fR@B%Pa9Z^WG=378cMd(w4G(T_^t0Jy`Cndzs8CN=)o*fDB0hUK3fOCBHg@ZsVyw>R+m{^Pllxc{Lp-{gG zH^s~C*^6^d!D5wLZ%iztB;8JP`&;bbP2Fz)`oqOP`woApwkv9799F6wpner3)h1-P^&=8-|TJ zoC~${k?i7NSsLKhvc6;O4LX-lO09$9@;Z z;k8$e4^NUFW~kAZ-KJ-rnE&{YTxmFY{ZVfNTQ{(ch@eruTogzRM|Y z#bnD+JRU)ee7ST*dT&J!^`;&7eQ=Z1OFlc_FAS4zZ%uY?Q4_N+4XWVb%Isr)g-BFC zY1F?;af|@%J8HpIK;;n+jqb9UwYsA18{MG_wpw%|DX57+55lv z$H4EryY=ly-n#^QiSP7IfA&Bv4HWB!G2Q#Ka_0$F!7<6n*Sr_s>{HyK*B_Thf13AB zv_M4|>Q$^x^{iN_uCJwbI3qxbdKRhY+O<3VzjuA~j;$e4o9W5okK+78^lSiNNWY`b zRqCUhCWLAbN2P2PbT5^#lb)Ae+dJzaB&s3hgVnPe^OqVDwHw^Ox%Ya@Km5f%a#@a7 ze>U6vK;eYcs&_cudp&W{fwD!*-ANu`Xt*MT4SUnwo3)LO4#P6OHT_^aLkBTt+E2D$ zn~ZL0GD!RB{MuyFsZs9Su?9z@gPqscy0Og z=HjI$gVYOOyK(J}mWS|HTolea3pVd*kxbusD{4}R9dY;|- zv#d2o5dv-3&yOBY`g%5@3769RY(_c&Pzur%vU4x7OPagsVhfkO8_WB6=i%A#w#El` zBR)Hro&^oc1(a_4gWc9EO8KQ=@?jT9nZ077>A-@ZQlnuRg>v#s@qZ;<6S zl9#X=dGq`1==+(8S*g}{i>F^d$%a^TZ9z*bY0jDF=Da>!M;+XhL3>`y`+7D+A+%x* zv;S3E{|R7-dxt!DBl>!)MysiG>+jtE>62Srt6JZ%9^Q8TATSWELm@XG@PD@yNCwFO z^Pcth?pVL$60ML!2pE7lX_Fbq3i&;?M)C1O&Tu&yBo5qfQj6Sn?RFM}R}DF*nB&ur|FM3qI!R3~SJbtXgrA z3Y{m}EGm0e;4%WlBA?_wZh}%K$*-ryTu>kLK+ahm&+zzV#^a!LL2GQ*9QqxX9-W3S0qpcy2Ws6Iag@sLFbXo3J1nWRjR%T0@&V?2Lm#pDle$EtCxoFZA zmJ}kgQnhe1iR-s4&&zp}CZC_z#B*70)uDBvDHx@fpKtoeYsUOSQVa%Rv|85bOlSdc z#T)Kr(!ul%byY5Dy8iq#*|tR2plzqrx=*vXNfx52KmVOsNc(PODrC3Dq{Zd}rx47W zY|_Z7Ru^LVWLfO$#WxXEid`18tkeY<6IQEYA#n^2%w~;QN-Na@V7e}|Ddm{quku*q zl#<{%uM}NZ*_1U5i}AE6b90H?K84`*vQDSM6zJlzrrgUVmL2A_$rtrzu1_|XH+`?v zcEX}8vn5L-bX#FUO)6ohnt!Bek((VZQeb<8@n3$14IPlxd$jM=9zH4v zB8ttrSd0tY7+=P!NYVnAJsGc(bra2)!~w8TH-%S9T`BYW~=9w!7d3>`dP{hs+o=2NvF)lT@L`3p5 zEehPe{wYr3(}%u72_e2{x^C%USZ{7-#cEzC6u(-H%BMv(76t}wrD2{;#~FqQsg>YG zF3)WVw4p_sYApnnr0dBb!gCv#5NCpq8Q?y1*`-@fWnhZ0!YRx3Di6;T4uE5FducKc zA0aBBiC7d0Wrzrvk@0Y8F#8hc4VE=|!mm`2uErNWt^(jMVKkK}GVB5+kBVej&9w?} z8WpPUSy;xCFt0507|X5z0P{^2S{irMg@YNi$d=y8+`>>2UUH>6631r5q;9lv_*}b* zh|Jiv?T#ifN@QheAP_~2!XU)SO^m;?c;d}gW`qN|9H0Rh5zT#&wiS^u!yrix(rA@i zI~w&1h`?DxVB&u1+7NcP*uopGL4eh2Io9*YNdoMbYqwFBBU*dBhkMmbljTCacm=pH z2#d90_MrC&eJ0mRD!H7`wE#GWxe1E^Pz#frg4_Vb9njKLc4Q2vp2Tfw?wqKUXcq$^ zw$-)Fj#e*fY?}GG#6qctG{QRc8xP+CSgq1xYT>_^<*Ljpdbxgb!*m^MORE4VC76i# z`37&xZmd9q`!epBdA@}gf}vDcDx2?X;7oZVr8Eu466Z|O_<6As_?0QI*G;pKeWja%w9<|1;GPc33Tm7;1+7Il zS!;AYt)h@Q)nw_Qa*b~Q5$yzlyvKEezZocI&wE&nDMa08Q zVySIz8+oy1p^Pn2N|eo7bhM&w&0IUrws1|)5Q5cwC3*yh6a_VdEVd|y95YteN}uxp z4rSeZ;@YT1qNx+nxRyA=&jvw7wvshBF-9OS6Xw?V&W`X}Rpw`>n&GM{C#-J?-1yD> zs!U=VeP}@hTTDG`rZpwY##yO_f#rMzr-eyOaiC%HWn*Xgyup-`87<0HR2y1j5sC9` z>Z}3-CtO5IA=FG^D6^?ql25dxPf8SL<<%wSR;mU>y&9 zt79RDMC? zlQ1P4xoLr>R+UR`O*R4UO;ah02ZfQgrUSsaLy94*uTSgn@r%hJ2j(^yiex%uA3CRg8&N1RbumneIDKw1m;H#}0Uo~vxTxl{- zpZzt9PVlwfsPnb0_M6&q`EECYhpJ=mU+P?N;aI3+}My{lL)uhYNyfTS-&ANZxd1zt0 z9}`i=K4AhGjuP_N3qNsNn$PXB&14nBKVv!F!ygbUkMB(Z6#Hc(Wf=nJBK}Mx9!|92>Q@br~2OO<4<;xDQrRB zeYXAXC%X>Q=)N~Od#ahDA>?B(e0I(hJsMxDXErtkHJpjRm)N>G^srg&)(cZ1Q`nsQ zWufWW3fG)I8q6MSDGPT!Y&`m^BTMwaffSGG^aj;4RldE~vhNrK?G+8%%;UexD^!RO zhI!IEI_Vu~f;S=0_p7Oosh_xE&D@=}s}a9lYzkA#pv;{H{ZX1^@nCE6`arno=XR3b zJ1_2z5;TRRVg-9q@-wYY>RQ9LbI&BmDKL>Q;_oNLN9f52*=oHt?0(HMFe*=`8U2I` zltGh@U3}xM@@sD^9LcBI$z=Z5b&WWFc*f&DTc$rc2dJI{yac#J>d-LZ#$9rFm*7nr ziUcMvRGFh!Ha%nKtzh&Z(4?eeyEpOoG&L_QNWS-OL{x1)V%UsTtsNec&2 zl9+RMwDd+=Uu&DC`}NGlObyJir`~Sl=mGF8T0E?CAE(wVBWO8yT@&@zO5kJm_>6tb z@wS;;t%<)^ndsYjO1@TSw;LUw>{;6_=dOuaB84im=95NX@mr!|Z?g$j0xOJ*-mt#^ zP;Q|Yu^74iN$2LXu7Pt;jaX##sgRgl%{6{-z4h@xS8LztS^ERmws3YYu^)WcAI)*Q z8SsK0m;6*~Gj_~g+qrLHCgD$W3QY&95op{|j&O$MP7CuPgF%eZfw^;&U~pCv)US4< zB0!7RrpE0jotw`)1Si&CjTS$?^)&Ud_I1IozqcH`z!@S!Jh$%$Lj!{vNYFB`-POE5 zBm7zG)r;0E?K1^YF*u#u6>cmtt?^)c(bG5HujjA*cJ{TlK<;MKslWGV`V2b-Q^2DS zt=HdoYz#iS&?(5k%YN;v)!T1s2>wW{Cw$8AGyc& z>lH8hTAA4c)V_zo~7TTi#PoA9#(V2jGzkE3fZm5DbyVzOB~CnFqL<-A?c z(K9_)Lc2zK)2!N99ieb))@9gH5koq|jk_Ha3wyPy>@7w2LXBemkO}pcn-BXbhR(K| z(rv~gTuzaM#6v$G4m9}XsIbD?9$|DDV`?#m^+pRwzkor4mT~aFeDHPjS5}+z=f_M0k}AOg+D$a#un`##J6o6aixX(QoNty zNoZMC*d7gscMN=>TwQa@yJzbVS9U7TrF$cB4?VC_v-N7WIi>6ZigLreRJzUcTK)b} z%SYs4lw~=8W|aCJSl~rl{Q@IVdv)$-C!-j15gXQU7!3QjYztkS6fYN(A7llh4{0oC z-F~c#AEm3N)O!}+DV;bfVnqjcSg3q>KyR+3+vaxXf zYpZj8I64SDbQ+*6NoOBx%O3!C27_Mz$kl?+cI1wxWQ6%nq!lK&2GMPgVW3_9Y&rRU zRw4*rZM&QHqvdd*uqj%by1ULoT&gSF_DSDeZlSj`lpHSN{wj7a?5V)BLfBC67}0%G z-~gD<{i^QE9Ifb(R-5rzH`d{o?qJmKA2~Lv02kFXu0JU8jwemhw1U-O$Z_|novL%Ki7j-yjbKWA&$cXQn8YaKDX|<}Ok%NfM7%z*(^Ei2; zwOkH+?{r5OIE9RUoYfkf9{iv`*t+G|XhY7+@oM_FafYXm7rOLY1LGaQs(Yf-s)CO; z5(BE2s!j;#vfO`%K>+*^1_N*${LDgCwJsX$`f@)i21%v0H`QBV-s@iA6vn68@|T3f z+gowJf6ggHVbY9JbTPB+MYy{j3^Yu>7xT`h=u~JmRZcMO9xR7C-BE9uN2}u+mx}}c zaJ%=7tq$5Yg`~}LT(4t+Lu=KstL^p@OCo!$-knaP{~@-+8?~+`FVx@C)!SSc{ConJ$xUSo_w&b^E5~ z6kZv#pR`}T*g}c*7WHmyzB)+mXhhkIeXG28whqt(hlymz#(9@VSws`vIkxDno58R4 zIP(6rMQ3|ud}mCtPq&^Kogb6d40pG6$mXFz-qz24#w(Nj%rI)LBd;mUr)%^07yoDz z%Lw1v8s5K*Qy^mG^1mONU)KWQiu|yE?_?5n3wDfM-+FUsAf^TdA|`*4!UwfN&eSmO zO7nG7lSDR&afJZB8ejDIZ~n?$4U^cYxrH!ZQ&ZW_u zZWdaLFeGP5aaPmtvv&%ULOO0XV`1WEr8q3|({b5gU}oE*O{&mNwET4Htjh6O8K5(%SNGHPjX2f`c;j`snQ%&f2@r3|`d-Ex zbjqYGj~Df3rU^np!E5Oz;9?ois>)~eW`&-?Fl4Bzwv$>Gn)GR!$1|Fw=wfDz+AP6{ zv{qHR%99CgD%=m|G3w+1xEiKZy(r@ecd#k4He+rE3?sNWujXYm5vIViqN062V^|%U zvOM~^De!Pb-E&h1u zGEXMF!PB_*8Fh0|m=8>;YEi^vZnMvx72KEUcwL<3_`D5rxusSn6gW0(nsQce=K5_t zS$DnEu`y`5%;Fi{U>PJ~l8RJdMPO>^>ol8Eg-t;nURwnik(PRD7DYVa^(8>L(t`9X zD#j(lTwHmq()BuyG1V%s;$;&}q?DiADG*=QT{pFD6hh}k9?#fDqi=AfaYBt3wZ>4r zR!IueQXQjjx=}K}q@wc0Ln)|J6;Hv!9oJa|tkJh)C7_H|G?v;i_&=3XutY^lFeAV{ z$#jz?Q^pH)apUsFE`aF8@OoLq6INm1YZLOmQy3E0-X)8dRWuQrf>c&e=A}?0Ye-6q zd9|5HEdaI|O}wne>D{_XqdC=f!cQBiRpn=s5?9E92kCM@j;~u-96s3;(Tta+W(wBW z`FT@te^G{~1WPm(8BN#gI7XeyLeh9yMPniGPWX3n3YQJ-SPn2yU5bx08wrpxPb za^1u@tkhi<8B9urF)2hYAt3}OcYv?dCRb+^`^}WJ z=a4k`VxHG&e1!qN8ej0(-`~FqfWL%cS;WSU$^@&sx6^*`7Qux`VuTfcS(hl!TB~}q zUoWp~MN;DSJC8Pfl50BVMbVs5ff@ECA(p>+qpf?6Zg4vv7z(pMQ!WP4@~gV)2Jbf8 zXQjlaOs-_=SM?EA1X8jk%l2_bFtJsz1doB%0w)Y3@p`%2(SDBk=5D=G9Qhu?W##*m z?HlOV0JvjaFBb~uUyZoVCRK&SHl+f?fWy1zn2&SVEEHB60@H%65ozgtMv%o2t&~$oIL5XylGQi)!j8tbKMB;1Mr4; z;sIT0{s_b~;tGU7pg~-Qfh#mf_hHc7VVIeo_SM~0T_#OsR^~B#pY8YZE>;*Gx<}L( z`xKScU8sbV@wT^?mWdTBzWBcQ8KRh+2iZLn3-DG|-mGuC7D6QvN{GS3?4CwB=BrWn z$SoV)Cl$L9naaOc*$iuPR7nE><`I#QOTvbHeEGk zb}5@yIG-ey%xaDEP3&PqsBM>x;=YC1WlUtv#*SwrhEhdkMJt+)G1v{Ltmd69qlukV zT(jJ>oE^>OLs?a2P8D9>gGbdU}%Usmd)V!xl6_UjUIozO_lHjm~`6z%>c#3A((Ay+6 z%*g}=l&Hx_*R0?IdK;vJ3u^>G2z7p{QGlTm*>-oTuv6|A3JT4V?9?uG%p?5Bl2ZoR zMEm^vg6uSJ)bQ?oNoA>+nVf4+Z2+5hcPWNIH%+gt&S{2|0V$~=2i=#naO~Pu!IEx* zK3-eEp4HjzZ)!>nj$2F0PjZ17ycMf?Ep1dNC37~*%X5X%r!Es4qpXfm8n!5n`AL{M znkjB2<8JG)g+-N1Ll%lzYh3{|A0Px={;sQF)|gaHTnenJtcd7bY3@jQGe6#&nH~IZ zS;?xiUFl=KV2i9AN~xQ%tv5ntDdu5**T5v25*DqK`F;)cya_yk`NPX2jeQ-P#i75q zA7NN~QHf1|{wg{HQQ)nL#w;^1tyhsOEgwUM=BA2rb28lHA;;`uGqR$?R=SIkcZPJT zZ2yrisxH;?$@bX6bcx80k|v`Tw*FGavX?xRV=XACW#(oFT2PRdm4$xs@cV$fVxxXC z=yd=uHUw$L)_hDqz_+FpsV>nMfuPsq!d@L(mL{pq2sNJ3HJ`OFx&86K_)nfCz+XY@ zZrOWB*rbjdH`~u&z3pmJ6T{K*dmsEPNzkG;ZyK|2G^aPNppzxY~a6_=VmAEsQd|_{ppHKHSl9h8qu;SKmFiQ&e2c zy70+2)%*}|zHxc^19kabV&c7JT7g*yiZelG+T)GOk9$`%*U-IWa@&9C6$nw5o8E)N z>yH|UiAq5ogr~QH$2QJi!&uxuFBf>tX4!D{4mrF<@eUA7&eVrF1WU}mbK&p?Iate< zk3UvvqH?^p=G5`+?cBw$i4^eqA-s7A*u)4-1H7Msf%>8&jO*?G@4oPlwPOE|-O2s> z!zs2K@j}-7`%(9S4zHr-NmMNeE*yCF_R+O(*Bq2N2wBeKpRSU>*Z5avRo;qH4Gc_G z=~N&2LLU{v&RW|{DcuTky-{j!cc0(xe2Zd}(xf<Qb#e{RMHMdo#00{Cgs+g-K*E%s@Z4=ahY#KKip2=(Yj*N+b)K zSIq8258isrnrH|)ezx=D^vW^SE@$)On9m7LYU|GawHt4F8W2}zgXjl4$vYZM!mzlx zDYY9`ME1;?z+StA(B1CW_7C2)FcWps^@n#pnD)_&HkjD^V7l`WqgbE|LR(jSm(Q=ies26==7|GMc-W-sseBYxlNFemReS!Yedaxc27Z(VGnyS${E0{OsoW{mXw_ znP~RjF!o+D|D7hbHp%P$yRHBADHGsYlU#d_>|DaIMghkU0IyusG>Pf0Gob(qYlY z<(;>78n0>q<}kZI4S!T&c7|=X_bLM-9%--dSQR9fAzV+ceJZ5<6n*zv1SPOS&f>Yh|Nf%&A2W$!^xg3&^b6e|Nm~5sDN5u)H0;|Fy>zcJUQNq*kp?uV@EPcV)z%XfJwy z)_tS(t<4p-9hUhx|M~Rp4>Wa>!z(*4?R~9YN0fx6!T!8H{i%aN)Ibl++gHv1$i|`- z1S}Jp6r)gBD5hPDeEyo^S$o#LSbLTLe+4a1W$fePs}fXN4Y#SOK$~DDe(d`wC>50% zG9F@o9ReV#%84AW#4;F}Lq`-MTyb<{d00d=6nKhfvSTHd7veLxN>nVQI=ZHrXYyP? zfX|#)JoXu0)EHa|KUQZFa=iNruwJAsEtR(*m!MVOSt-;qhXUn|${|%v|=oGwd% zbf%rbQXYj@8eW6qM8&e_xtW9n6*V}ivVs-yI!-8qHODO8Xl~REf=w&{ph&qtpJ|ql z7d8nZgD8XObC3M2Mh)O~6NpDN$;Zlw{3Ok$Pj?y)px>?Z3|1F8mSQoKinGFB%xp}v z7tPK_-6W2NSx}Gy%u~ShOVO{2w#xBPp;Fj9lnj*~h*D)96^W3E_D0mYPOiG}F#zH; zotMK1Z+p6>Xl7As?M25~G-IbZLsNP)ulmyzPLy`J64DZMo}6rU2Mv>89UY=1q@d;* z;HgPm?3bkgN?inrP}l_0bhI-|8s#+CCKd}Miwbq7KsO;10J_1fvORDpX{-%n$rjZx zz%`~;$+}7EUhsib0J?{bXgAB2%<-nK5=tbMnx$F+?82_d9g&DM#EUi)49U0?IUYkx z(ke01MH(e&%$sJTX)0(snh$WrNVtlN0-M9zvg-n=Yh9sOp@KzFRj892wc5Zlh=*S^ zFjj_fe6Q4Okf_a!8p9&4RY>HT0{mw-serG|^#VA9ECUT?!%C%?ez0UvG01bB3&J9y z7P&SqzEDtrIwv)2Z6+j;{p$0_1EV8gZ5R_(K`ddRe@y~d-c~st04Wz?7<)LNQ)<;I zho(a)?ow`n&mqNUwoI@oG(9a*VI>KdVaZSsaUI%o$=aw8qOyuaalZB~tVuU0Pz59f z==z1Uvn!jn-W8ImSi7Z^ zKdax|DwT0W(J*$EsDe_P=K-MDh~~vg zQfqZnuVo;`0YMW`)38LfatcOHFEO(X(A2J2{<=f{pH@XxnTux-=x6OqZ_g6oub_ns zHa*jPfVt1}M5I~*oUF=ZLE;r!h?NzT=MnFrm_!sQ=6i7zNrnydk~CVdz(QZlFkYEhRU+kSI-fF%YncG)SOp7dN9f?3^6Y%ZJd8c&kW7@nP-cmjj!F@s zwC&Bx5|y1A)=HB-;L9YKs~m59m5!=viAk2)Y0FvWkA#KS&`GQ~0}Vz?DHO3L@6*7rE5FA zQVDI>^jD83Dbe_}28D*5H{F$iHMhbb3g;|I)_8yhS-1EiQW3Eh^}R}Zv5ArVR7$=m zl9^#?cgLjPN-Er$yvhT=2qsb!2hUU~+abZ6L&Zuy8B5J4OhGo1;Y3(ZXa1xpQEQ4R z(Jar0=S&lPO(CAj)!K`Wrx_bnyrCJT%4EW}$ixP-MpdzS70)fL>m`wbNbL(NfM@4(R!4g> zLYe7wI}8@ALa9!i#L+^=G4_-)jnFIHdO$JJE{KwFR^_;u=sG;~630OAPJxR2ES{69 zLT8o@<+oF5qJCorOP15ZIjyjbO-y&EMi>)B{9vmzjW4iSrW6R(!HP;kvQ*lBoRq4F zz@VV;v?(fx=1OYH36&~SFbtg|z$*xrB*y{kGlRk+_h(>XEKHU2Zao5t4(5VI%QBvu zTE1;@9@WDN<4{VL_)E5&>oZ|S8S#A6#(bhIPv(5-V>At=bt`YWzKMajQ544unIu@_ z+M$!{|06%MAetU+i{|ef-{^fsq`H%kK)Bl)NzJL7p zJ7+(pc*iLYVKKHUra^HaID!;O!vX=a6YU%Zhc@zH(t#wlQUAu3`sde}@#mf_Zwymy zP2%^&e2;Lfo|>1{le78KM_aN)k^R-i!EDPCn77t7R<~=chocW;@WDsqqmKv{AW1g7 z<<)kDO%a{SKAP@q2fF!3lAngz11V7-l}&4LwVij-a>-EiFzg;geFMv@6MK~uOFrj^dJ^52f=YO(>L&&L+CsKPA9E3hq1fnZ;bgd?BoH>+BKllYJ5$;z3k+LPBp_OcE%Y5)js6hu+qoH1T z8LlA$CjdmrqbPh&3eA`VIuD_S(;`BQrgybfJJNPp10#9jOcT7#Vk_e^8|+lNLj9!U zKiL`=miDGOg^*ITJ4qDTj}8ukLkn{?l>}Ls3V#T~CgC+FIjrebrqeU>&M!!Wx6Vwr z+r8ds;HUr~E0D|v3?V7o)W2OT2RJvART$k%;tw@ysO;U6SAGvLp`cnO^Z)v9SO4lK z+U5G2uziVGcxn<{6|s_Q`LgK|cg+WwGgZWEH8cXYN9?+`Fb3A|u*=)Z!EDA0g91Rw zO~xH<&C?~u9jn>LJe+?R^OklnF*tREcEg3@_jz(E^r&DO%rPs9=Wd}$QP~m~o(&*Z z4fmSWFmZHK0%WO=3LuKwjIQMkl7lSu7Y#&Gr=n}y92bs?u$FzYeIC|OWtMW;J&ikO zF~Nygt-jUkUbC>vu~HyQs!_55VANYa*_>3SHUcUN0mYvf5zsz`)(K$VE98CfuYs1x z*}^{bukJ?sdO?bVEG>;L!9^CN_wrJAbA0+HEC>%FzNGiDTf5ThylP^f1EC`=O(WwS}+uGi_cJ-R;Vl=pCymzg0x`oy@3KWwb6K%lZ*rV-jdc983x}u7b z`~Ur)-T!a@r)M@u&)S#R{^U>o%(g3x_a50o&x~8^pRMc&B%?c-Swr#!KzVc$@8x|Hq_@%k{v)adxDdrKS)xi&< zTle)^$@qoZ<8KX$CW?0TReA02%fUm8JvPbNYmJkyZ&cX*vVWHDh`c`3u%D_)1DWYy zoKgGohX;o-HoR%F{JH5z`yryDDFu&xd3PvFjBFZglfye?fa}E-Qy+gwo;*~Vo5G%E8l4}5G`lc%>H!mqq`Q`o;D=C`pNC951y}K@Ys2O z^}&npp9~QF(kl2t;_pv^;LW$}h8z5DKk1=0VmEK}?!I*EM9)2@{*PgP#yA?rYTHh~ z-JKsHu#?GT-NdDJH*3I1W5!Rz5_!%Z5jsLcoDAM0Zk8bF@X<%28#(6U-01e%jD{9 zJzE}i+aK;-i=C$k3WPlFUAwz+wZ!ZDJP$V~_h^cV=+xWpeP_G#EzJ-vNIpJW{M({H zB2Ss+O*U_ybah7Mk$-YDyXRIY2*qyqgS|WFO+>RdrD!al^cL?}0;L(P+Kv6oe^_@> zIjQ35`RZ?H!4I{WrQdvYZ|_ab1+A=tv-w~8iAFg#HalrFH(Z>(v&RXD%7a6w$CwaJ*87o*x}r7DuYRxSJ<$t@R~M!J3a7ia{UF-UzQ02a5B2VXzV z+h_uDBX;F`@xjvtg{IfLy!l$Yeigktvs&D^yS#pv8EAp@g@VHFhpVF>q|QZP4gKLP z%ies+9sK*mMRSGBKd9vY;AbCx`cDN)*}T!yD)W%b*}W&eZdug3+`joAzO?;qbXp}I zi=W)*e^)BB8$O^{YUXa=KpzP6Y_DNFGeUaSzV!Ai0sabFl@sh_OUQalZ2Vlh1zzc3=lvy$MDK@-`MLLeNGkqbSZDeUM z%eDG+z_UrF9V{)CU5=ALRW7=m?U%{2B=hwY;R1GHQI)KgbBwuSWnL^faNL=K!fcSu@nghtjnl4seGko zjAU51iEM{dDh)fD8hj-AP^Z3awmAujCd)~QVr7_^D8L(%=IKt6Gg{%xrCA(|eTtT_ zRxUfsq&1hAT@J}co`mxRYr{HuD^Js+(0X2Fv4|IvY2b6KOoCMsqEKfr6)h5fk{RXa z=ZLHni610kr6s_LpT!H#g3lj9ltK<-u zfyX=zMLtf~Kai(y!j*|1C7~3Sw(VJ_=M~^&pltJO5hS6$rpd#NDlB<{g`IPrE@g}v z5C)a0DT*35aaW`X3+H8o6{>B^Y#FTOR$B6rB_dhM9DB5ISLHQPV042ZB8`J!b(Yv@ z1+3;Q9cLEqH|~jS9>;-{xGU;@5iJ?Vb46KI(Q@vubd-5xmS!W)qtAaMhM`hZ!Md7vr{dl6qSbyEgqsxsY*3ku3vJ71gUFA55T zl&Y+}jN`5-l02H{W{AeTX{rXTa)%oj)RQJGoE0gSktiIM+c~#&9w`foe8MzFQeH1B zx8M|i2ts75%%5Z?eiGF#dtPN|e8{SbedbSd4Si}=Wv^B#?6q4IRkSKsORPChjhbS) zS6NuNJkN?OT51u*%4O^)(OOWrkooS~WyfL-Ticved77lrEWw`PhF@iq-2E-4&0qD$ zI)UHjWnQbK(7J*rzKB;}K8`kN$Khg_VvJQS6v;TQKjqUkWM1bEPIODN%F-waCt3ph zg@Qu1NV5?a;Zxj(rOFY>M+RVjHFZv^aV5w3=br)K!cjr8${G>c#is>`RFa6}67!B7 zVy$Sb2%15vxXj{bHb~Ffm*1Wxz+XWt=PWxxA&`{05l~C^0K?A&gE(1~47(;!!d*ky zI_bzLrCA8gGN;H_s-l)cr9mpKn8So6CMIC5s(_a>Qy`cS$svu6m7(LB(xfEA3>(M; zL=a~t#Rp3Qd63c51Q*{yPDxlAm3C%D6r-v#)-I>q(5E?C?Ak?{jq?Te#8Uu83iXCA zY-E}$S}KW`>_S3SK%-4Gx)%Wz%v6peN5w&MXm<2cq~vNfQ5JT*$#W>z#5ITlqa#oo$ z5=mCUXlmlSpfRwyT7xWrL0!{m5X=$a1}~hP<28){DE!nojdc&sDG4j1#2-i{pj^b} zv3|WG*qq5lO3_?VC_l=|3=d;URZ@$?`b6uBBnen*%M5{Cxn*Zb9(ZFd>x-jR8nQw& zDJ@ylT3IIQOi5%h8&i8^nrIaz7bGeSiJwjY6nf4Oy1rLFn)mODJ7vd03du0LlW7S>=Fbdr4!8`X&Q-Ajh0ja~HEG?zX8-~*hZ*rrJSrA!!KPEqx#!p4 zBhkOdAmZtxd7+gl1I_ID*R4okb*?ls>XHFb`m{+YFw={;0uF-$0{Q>wPCCX7%?;hpPA_K%q))*BC%waY1s87tJlT`9u-L(RhcJqd}dDV zsBBug0I!VlRqk306E46aQPRX^JVQz|5;E;eJn1phjN_$NnXRfk36m^TI{nhhqV}x7 zA*U?kB+RtWpHLaQaoCucCMqXqurQ}dJI4aWrD8EzQJWe#-{zKEdK!DB;X9!0(HIYgiaL~e6D>UA|kN~1PJyp14w~WT=d}y zFEjZp0e;rL^!5x@@D;Rw{>OiO=Ud^&pJ;3iKMco{d0C>u9;;cC=ez!8 zoGgLre-dro3rxHz=XuWF&StZL*fZQvkN5fMzQV?wkWZ({2Oo+Mt>lDZMEybD(T#b% zFlsKBTG6_)?WjK}o0yBDRDBgR{gr0&RC-=G*x(-KUvbLL>(#WTQEeI`9`L1&eJQF` z%-@ZY$9j3PJs|xZqB(QsiJFg~NVQ}DI$NZ-N%X8QP>Ye$6hjRY`n#kv(7&2su9jon z2bgn+A}F;p)U2a_@%GVw{HBR{q^ZgmJT7th!xH4uvauaBwd*zglm7HW6NBrDM*ZaF z7gm=LiV~!3z4vkFrw@!AA?PyubNhxOvm#9-a9XHQ&OX~_F>h-c-Tbm)>IB6{wW`zbJWl*2Mni3P~ zG@k1>UpBC^tKUf8KX^QC<77$7#?o&DzE-`;YxQ_@z_E@F<-ECA)gwK%5?e>);5OK( z>SG3RmqX$MPON*&+21=cQTpdg&X~Y^*Noih3j37zkY7p`178%X+MDMW(HGJm^cD z>U6TkizipM{T@D66mr7kTpJZ7OOklRIr_vz%}u_3Cx7mW9ye#F2%k>$Lu7X|7gxu_Cy z=ldq!P@Q)D_YWTXm}OuVV*Bp0|4FFDN7w5&8atY{;)Puy4Klypo!#mPEQV5F7Q62+ z>I>BK+%~3ndh@GoP0jJbpukNt8f+9TO|*jS7`HDOFIm|8r=;o98|EfPvWNtAF*31N^LgiR~E&_^WBXB-vl#dEZjI2i>jxhF0Nz^vT`h;V=9cp^|dL zdeYq;UO{sNC^%d!jeO!HDEF|vgM*_NFJD3nqnuRty$65i-OF)taZ|)Mhh=ku6;qlt zx#=uk)AbcDy~nmcpe~L+>4xFI>@IGigDF>?A7?x7Q48-Et*)4}H(Y-Yv&)!SeB3Xc zu9g5_@z1tKPwH43DNWR5p~hI)f>7ve!Ok8ySd4l#hv5_bV9SQh%dmTyXd2Gv1dcz3 z72fx#H{sF^vVWi_z-6vh0c5%h{RNE>vuj_y)c9Q+*9fNK<01d^r9_$;E@|)e{#niV zuD1DBy!U@T`sH7#)f05)!8PxNfA^sI-B16i1ZOme)4x!uP8sj5poiD-l}GbKXZ3nr zV*2IweX)6$))v}RbAS^cbZu||FkR3x1RJ0>0l@StZqws^`|P#4hGn3iC^|CiQtxDU z1+cd1Gqk~WXDHT6og!B1*E_B3ff2rRvtC8%;S-xJ^l$m$# z@~w}kx4fuss6iosw7Xlon=e=K}0S(M=n$uggXag-i zyqItOO}zh5zlUKfdboR>V@`f^QQqvPt*L%+rKVw`8%?$AclI~m)R?FhPtRr}fB8#T zQ&KSPduv^B_BCttQmts<%qr}6tXunIlov_KMvK*a{*jP6S(n;iV={#Al^U7xDl~4bvh&sP~ z|Iw9SL=MWhI+Nn&yJ`QC#=a&`-m+J(*EJ$~RS0q4fOnqiLGm2(HLzrNK(2Jj9-cM@ zq3Kp@zP-yZ3}Gjk_vpBvqRF&0jnz(fy0NdhkzW`T9D93jdvBwSyFy80m8#j#D~@Us ztNLKL)fqR@rmiKb{^Wiyyl>*%qt|+QW8<3Vpo3WziRr23>t9njXs&j*G7F`My&^gq zp6|w(lTYlujaT+JUetl(vtaOYE4i;)2V%jqRG{udp z-Wx53$jpUZ2DiY!9%wlHo%8KY@_a8wW%05KPNt82|2^%@JJ#EmojaC^QtN4Fb$lmX zY@w9K;gc*P1ry;f(JWJ>RXm)fT^;xr4a;Cu+1NkE zl_FbJIWE8Dgyr!vHBNI}4o`+WI4}4Z@6$G`XgE(d^=+1T$bwO&=?`VBjEB>-hQbf! z5Dg1|#I*!Cw6kP5PBDy1RhFD`Sb~-Svqch~GghF>XEeAp3kB$jVdEaGCCDF9hOY<&Vm8@tYe+ zT-byyqoJRk29LQt|Y_CAF*QjH1|e4QMB#I!nR8hER*w5S{#4+PqTz*nENB4CBR`LO@_m?z#!^G zMZ?S=>Gu$Bg~?e}V7LHX%5aofqo?Xj)nb7g3+&8URar1E{E5_**nayK(L5QBQ;e50 zOBD?ZeY~mLwDAukdN9s6*bgA_H&h2T|frswDZ6zq`+BqRB!hQMf=* zSYHF%kO!k&;WK}spipEi9?sH^wn(EZIvF zo?6($2DkxJ8`cDD?5bEeJ;T6RjVbJ{aL-uVy`gG$u6xQ<9BNInr?ccha5Wif)&@{A z==MnqBYY`=GE?VkyPn|+#99JuTF~wh7xR#bqf~u0<&OzA0%fpl(O!+*L6-xE$$Tsx z>DC=~w70co*U%Zb*Ya1B?BjRQ^`vxHQO!Q2fTToot6DaL0;}>Wle(mJZQ8&vL-1Cy zSuyQJf1yU4hOu!#>ge4OL-ozlnwJvOz}!`8m6bLKr9twZQ?xZGCor3}M_~gC0yRot z%ab6*%y235axMhd$ljG}SRuyy0vkzz}FogmRV#ZO!nasPo1+aU=YZmV{aE{77eCGn=)CVbj5#8G;$Z8o!-5 z*1)j`8U)%l8(A?GfOg0^FAL_Y-_C`x=-7GJm3Zf*+Nd?$ZI_@Al2D;~i`A7S;Ec4~ zYwDT}h_neYoSgc4nlDOe+&DN%-3xh(<^jdsr;jU0h zEk!i(dZmpazP4E_J8J z%?hb6J5#0$VN%#pVQD^e1G^o4Q6@-ErXD4ejVc-s@8<=lpC@U}L$NjO1 zMc3x$%o(pX40JGMq%xiLnb3(@ZCPjx-iw<6*Dv}{3V{QQ6&gv$)9B(~C@7eM9E*d`)NN8NgalttE1sHNMv@Eu2ooN%;8qgCIl-1k^M)Z(iNLe#5|1{OsiH?hk$# z%`uv*J%B&>=k)7uYfqtm{(beAe+~gUSej6_fa9!BQ8GW;m|fq{z^?U0x_ft0^RZNv z0$>i5da5&b2T$5p3hY+mvf^;`U~@In&M-QbryncKT7_nZT)C|?ctxd7AF0t3g%d95 zZIPopq^6ni6za)+HC>Z-EK4X$jSd6t9=ZJr+1SCGx3)2V`_}C3o6mXF=={;7*~27^Y?NZ_bLPjtEhP3XCG?VT4u1w@tLVHoayx1=HhB!nwSnfiFfZ# z+!${nx#sxh_Uce)U-wS@?fVl8O90RcoCr)@AR@%vY`?MD`8p-&YbvVgGW|u#(b`%m zS(af{Jq5o1Gn%9@eqk_tb+hu&h;7>YN4>Y(F0%gOvN#KVI*Q(rSlqSm-MrHKZp}g~ zypqSq{`aTpFSRS)TpYeMyWw&4bi4?X^PjU=vmI8fj98_Qir`Y?_>G-pfRaqJ;9C!7 zgJV7S@b|joJ6lx^ebHXX4u3r9e}eYYBqie)2WPKta9nVyEwkN^CUqYrnM8segO!3l z2(Q24e)~V5?G5xGX#hX_OL(ZEPl?yRUf+I^V!5N08~uFe-gy&!(FU>i+uyv@{u;%y zG~>Vd;JyFsUoU_9@Y8>~HMsc_xqMaMy%|1{_uo@klnN*X*98l2EK`H*y=Y&0$ulv| zJe=^yKh5F^`o=7eTzZaSA;J|(zdVu&tJD zw>7GZXKnTCuh}LV^Fm~k;D?Loou@HaE86z)H@6p8QHn@}+Wm03|MQtvdZvc$I$g~V zOcI$mVQRfC50zY!ozxL7;_hy&w+%&(_!+wxu7{C8t{^@)F@_!WhGY;^x z_NBFF9N@2}&8=DJp!v&^!i;=%yrQ@$JLn8LyKUFe=e2qXYlcU#RpVRz%CfNJBdE|% zPfk!0W!ui)=Cvz)!@_xy!IO`f#WD1kl$Kp?TBRP}*yCZR z(3X8PuFSdgF0cwH0M<5jd+lss$5`1}P(>ZX!%$}_0VKo;lo$|XyUH}c!+_fgKuL%~ z-3F=I1=|4a%)mi#2%k>ahEipl`sIWr1&pJr_RtWbT)0zjBQz*SUGK-ivaq$wRgOwM9`yA=Uq7qtbLr|fNW6fVK7c-> zl^~N=8Q|?ZI};m)a8E${9sxkEabXQGO`}z-VQpAYLHa24CmQDv01UvZ2>|XWc~FI2 zrr99b%gUNcZ;Ek-EmhsDw08#pjT3I4EB7MD3k{t>DNtJT+zkW!09Q$zCSjaj!0Y~P znxv$#MA$7^4e#|4gQy)FPb@@bm2)rbF@f0`b!wa9vMmt~MJS)uejYe$Q(w+ep@6>mbWorl2ip1+Ax*|yWkP1ZV~J%s5{bXHc1FSVy5ETX`2)o2Os8eh0jGIxKgpg=2gv+7*s+n@eZDH#VRaQd-kAx8PjPSiK>OjxO$ z+xNq6CGb-3!k_?90i1ErmDtRUt5&v8Oavj6rB#-7f%`{D5R8km)QUb5$_n%s=R!Mo zZ?f7ESqCt408BD+1>LOLT2}}n@3IFuy&GV}fl1OryvnfcMO7*x)KiT2XYE=0V(nQ1 z{1r5|oL6UP(zS9Gjf8)$yX_ez>(!FdeX7?~Z>TI#7G9KOeihAxMq9NVmCSh_lpND? z(iID*(#K&2VnI$A8R*eYoiH_$5Pbf$BrFw={PZm5m}%n-WpG}}(Nj%q2`hycfQy2G zD2jAa_%po9RFDNqt*soZ65_cs*R-1Ri~K@auEHsBRKAC@gfe~FX_zyJ7fRd67M6%d zesUHIjcEg$6B4Hcbuv@w3g($Q(G)my)y!puz0G!XhKyDik1^v7OEmguu9L* z)9m=ue=1%}X8U0nXbEtzO#BJYv)>~AC_#=3VxXrpgrwud4gv$$9>O3ACRKu|?5tVE z!+E-;N8)(MgAsQE_>Eg=Wyx@y;w=D{t7ydik$f8ZrR(z0NgV^-giI|i_PKu@-ns_5R2orzINnXh=gv zqaYb36&9tlNoxvGiN`!w=?a#KI+eHt7Lvow#S}>5|h}-ykl%|SCetH(`T``ows8UZi z6Ot|`PYMX}gd7&~jKkU)JjL2hWZRgCuKaX-o|dTJ45%;2vId!flkVlX)JV1fAUULg z@<-a=kgSyW{EfF?w>(z<7_fpn#DNZ$hF_)7q4Li){oVhUpipW-K@rGQuABgH!d=Bt zGGQi;V%(Iuk%1X#de&?ihvyZ?Goj;%j-7d?J_r3uae)06bwkyux?U_QbY{k~U{?5J z1y6wrElQRQXK52*7Kl{QQ1~NmWuJS3FV-A~ckI+P*1BT(v|Yh%5e--AStKwnz#EF- zob&Vl-vkAfiDb#L5VH)FN)}ZxmRfWJBFJ$;^qDYU!XiO%k!l3Y3jht2FNdZm# zrWb`A3T>_smWoDxI*c_A@P(}+{RONXl4*WUzq+ROJ6A<0iyZI&3s5;(WptPVT4Vh~ zP{8`zNgn&pe1M;|FTXv5Kz{}8@IQaE`%e!){f}A5-JhnLKhHH}a3Rp9ti23|sl`YX}4WbUM;<6_&6AkjL41-)#396_yZS5^uXu|;j z;Os6u_yH6cmE;-z2@rC5x%R8?}_n_AqHqGp*n^JKT8m%3)f^ zpv0i){2#~lcXb6$Fo4=bv-43xsY=1Rl!8g94cfP$xKhaMdHtVw1H7vPoX~Sh^#b+vMfr`>s)3h@yb^(*78n7m z2w4rO+eVP0L`IP|Yj9Qc!Tx>($0EP>y+wRYh4w_yW$2~sJ$ zE5EyDjn8dm4M#xJ40&ck0n@U4t15lgV17 zY+M(Sgk}w+sA&+dUfjC8*mAIB4mH58Sr&GW0034LEEAe^2N!XaeNuAtPNfOKRS1qi zlOH3cZDcJfu&pAM!n?35JTq$$g}Wl>-P6ePF;U+zj5{wFcU~Yk88BCwch5Hibg)uY zoFAv9zPI4n+fDCC)2%J->U1z&HPQZt0uXL0YY9+Xov9zuOaI7dV$=f&LdTTqu1iWa zq}(G)gS9haj408Q{@sVg(YxHntG<%Oi^aV(MRSFs5be~X-G-*@D$G*WV`XWhg3`2M zmb$XDuyaw5!O-5cVWdq1Q~ebv;by9qDBKmE5BewGmsmaD zG@;*z4mKhHfGC3b9I!PW*e-1Ckw#0KHkD)m>qJcg#39-vgJp=lKH2VS3l?Q5!vkHj zKpKZ>b5LRj8luK-eCovv_k4?6SF(1Cq1Pm+9D32nO*HxKdYTRva|;(%Ow%3oZ?#(3 ze-5B3N|tktS(7{E>Bcmun)}*GF6;^} zlPLQ{BQs0mA7(;LMugc$+N4;Y?X!YHYY4pufCC7aMy=&tb1bwMs;HWDSEKGiV5i(K z6coHw(LIUH5}m>Bwzhx&weIsr=nP89$1CIB3h=?XRXgt-#2(f+F=VnEBs;kl6x3`f z?>;6m8bYozZ&tknu2DHW(menGAOJ~3K~#=mRqKyC2bGEH@I){x4=7%*2tyuUK6`k0 zTA81(=V?H#58vp(OIlYn$;QAqurOkv2GuQC?BYaMfczz#yaP{iOm%T#s}JAu0BQAC zaq{3#{_Nxb?oXfDAU$heVtWRG{%YD$|97tK|L&*%F&N+Qr~PuFB?E+*rfF-r8L!*v zb2|kl0V;qK6+Dt>B_Qrob8Gkd)!*Avh+d+qJbLHfy#KR*0~IRE?QS2w`pvgGZG^ba zitOhfy~FPPwf-1Y2Ax#XYR>!i@a_KW8X_H8!uZpN( z=r+L_B1}hc@8=NU{i0d}ZoNz{U(*xd;|CC|^aPkOm`v6Hfds@5>O zE69L3q;}4DWk>&~>ZFbT%ZGda3t$@0M!j?W+ACWdXcUcs{7Jq0R{bE-(96|_(bg~0 zMh`ufNN(~czUZo;(}Y$!h4b4a%d`m${|=@Ywns`Kn9rH=+}Uzv^4h$=h_<(tvYq!~ z^>ekad3>S%^!qD0MtP}w#ljoB`2YuUItgBEOkP@6@UGf}g@gv)#M8 zpnw%E^tR64z1~VtR-nnK;(;&_A#Wz^<5&HVVfZjQ;`{EOBBT;Nk7QScQ zTyc>fMp@dQ{cPy>mDJHfV`Fpi2eyfB4ysA_@~6Xf)P1T6xqfH5`C+ciCr4}E({mq8 zR?u*%1N^VNkFL@zG^ zqVuc%bDJeb93Ufo>*tN-r`W8N?D6LxJ^bt*!zWS{1&`DTaL!>i1Mdj!ju7fB2>?`T zWalhd-NGpbPM&@tAKZ~8_Gy>a$fZjvQbTE&4_4P7FP@S(r@0vp&Q0%Ca~up93p;DK z7VB4#D5RJVKWO?tr+6s0VQuej-Dp*IkSIja@qgI~A1LFOgb1Uv#o^OtxPSSR;W8?n>r~V}m^6Ns>lg)1BVNouN-^HAq19FvUt4J2R0f9c zZtUN^blb&Dxz(`TeTOf6fg@cB8U4i=mAvG{fq^BR;Irn*n69?bOD6HJ~*Wbt;3<6)a>Bq}McSXSyB|oUG{rT3b z4IIf&z3F?OzT4eH2A$Z>($b%q>;D{Z_&Q#`fA`e?72xFcqHxY6=YNo^S(y7z@3GH* z9A~)qYJQ{gy?<$*LOfv{s7HQT)!r!K2#?t@OUs~Jz*M(}Rutty_OAYe_w39$K) z00hol1+^=HfUZMDQT|0pdrjjR4brpqJ73QN;BR3SfgMlqOlHZNk;Nz>LOJEUELD9} z0(V0`!yP^n+Od8k*3^_U9~!iqOBYpp%8tX&5>vH3oYBlr4qe<(%KUO^kU0lx`K3H= z`ucaV7{Ez8()>mdrV!;w6i&wTSxS$*a5kSM=`6*FDKevRm{)P~f*Uf9(kP!%Tre`@ zA|IBDC}>q=r=zF1PTfqQ^U7!(78O+#A`HA)#A%5{(N1_#o>6`sWsoN%@zj>fi~wyB zO`(!zGAp78N1jB;jvtpj4hm_COp?h#R6!+Ki_{YBN~AeD27HbMk9jwe2VcG@$YQMD ziZ!()%f=cVr4W97J29k;`)8j{7r=oem_WHC^h8nbxRQP7>9{vKz*(Fh*5kp_^l& z#XO26+Cp_%lY%La1pt|ftnZ}}hQ=&9g|F)=Qkz_svEaFwQF)@y_+v}4fwtu7X--bY zeh$W01Rz2=XJuGs$#2I)@N7L>$E{}p@VBsBKQRVKC7G0(?$ip$8V;m{PPnBj1&5N_ zL$5K$>=6LMhk!$>DWQ&tgK`EOL-^9%92G`V1&kzIL|Wv=3Nlujrg5hT z2uU3p)TgG2e4r$rMQ$Diirfe{HDPJWNe=@`dn3TX5>FuZ$Z?{`csB*Sy_rX%fM~~y zA_j~XP{fv(%}m^J%~&3$yzm>!Nsn!qvcST9zfloplMyh~FD(UR6XK=Bz^{>}gnFe` z!>!Js1rQ9tBUlRs5YQvajYH~zuN}c?v8K6`SOgysPDDm1!)irvNT-oJ2=RY|VnD)} zQ2fG7gKQkgeP220v?r6Pq}Y|ufo4;`m?2F_7-Ul(&$xlVsix_cX=^yU$Ay#nWiShr z3b5~|ZYGrtU<1@?LO8Cc5i;?N$y1AB1{yJ%vBO++F%c+-G&}}bNz=hJK~wrL1yFhn z_nWSRVX18|x~av5F%2-OjF1KAc7+*=Iu#I3B*$~M%;eOHZEL1Xwdj6E{YtKEZ`+C+ zv1K5WC#8&oEDtIahqMOMqh<=Nw2ZTX3 zBW|WCjITP^EM_V59o($MwJdPPiYSulkazoFqYc1968WHiR09 zpi!ZhLSg7(l`?GlhK@coBRrc7h22#eroWL()x~0!VwBS-6EKi&iu9>zcnu91dJ|Xz(ey~VB+MAg9OcO()`MxvunQ`o3?Tr> zj_6oMA(L<-KPH6f06ZI`lMo;VSh@<0Dj86IqynsgW`LzsfLTJbm_Gx-dbWP&>seR9 zx3E_K>%VCI8EVBb3%2`dck51HnF0z|E8`2DvWgueT@PCAw4$cjs=93Ix{kl87G#yr zU1N;LmOyUlbkmSZ0f&p6u~=aIC<4ULtA?Qlz{AnO)4jVnp5RRv&4)jl8=b@TZDD-( z$&K$myx~w3d^~j~Kkj_`NT~o9?Bcz_smDXbfb}=#KfAIS*N`!=qjLM5?%V_1iX$QN zWb8`CdogWjEfBkg8~iv#u1tKDXfDej2te_cbRAkPb*vWvs!h_ICm8%6vQ!>ClHLSP zvgUvP%;|sg{l+B>atku#Jmu;kJwFV-^VqH9`70?HZ*(kG0;_6Hp zX4A83hgQ@XCo_*LiL0rk!A4q}XEr_{QrcPQq&~qpCT2KUeNGVt2=1hTlLv~?oy!(B zgDsn>6s)>v>r#0)$w|PqQ0W||H1UJ|qCoD8Ftq8J)@-+>Orq*VR!wF)h86lsQDjji z^%PNX-OOrp$A}^golF&lR$sAKujy4pyJD1b`2ksaswtvyH^kr~l=zd1GARbPxvwHE z=T0lHwUj8zY%H{Pp0k@6p%i4qc`QJgt*|xG(hU41a>`%;7;P(x!S)`okF7vI`+=9dE?=a=7$%Mi5L0Ke3t~h@CR`y{%3h>mTuG_8VMzykl?*(%zoe>Zm zsitH9@Xb%dC#Z{32#8|{RYEA}EWp+oQo(AIme74FM_tt?U0NrbyF@umtWxneH;WFQ z7#5;795?$t4d)1pR0b1Cu`r3PHLkWA=Nd}Xwi!N)1m;>yc zOOi9<3WBwbWKq;l;=Yi-MF3n~ZZwc&8pLGYrnv|P-sS4n_~`sf{^q3(ZWMdFTeiRNgbkfNS0NiAZk^!`nTX59?^qp){+t4p7%tjLANIV|!drT^5|8txAl?Fk2tPJD3 z|NURy{cr#6vl-xL>vy=G%>aKpE3AHAv~lBK##?0ANJa{K`^cKRe|jzMsQ5ZS$dTCz za!&vLY4Z;p43x@?NBQW#V-Mc`@4+YwhXJ)Fxx1tYYM}z*PTkm!QOzSwe(~YGCU?n3yWlx=13Wy zwTz|~ZvjR2(kjyBgRkF0EdU9WUD*J=oEN1&WUtc;Jq}o17?bSvOa9T0dNzKlkN}xs319zuo6=Dz3wIXY2aH50v?z5xHYd;C=BkT({^+&JQdN)*2 zY#rg2yirtE;JICLUc-ft zbo0sMiyu#`XgahOlxH8uEBA5tsZI`VIiv4(3e5epsPC+qKU~xi`9~?U`|PLt{HGj` zUvBExcg%m%Ajr4QWN?T6c+B5XMDenH>iMNB9f6|reLeV~u8mDJXs1(g>OH!1H#Bgx zJUeYYc(v(cc4#|cXWz;!#tQ&fwN++*Xakka)_V0gV7y)GPGN0nZ! zK{j_u3o}Axsf>IW9eF~t4O?fRiZx;6IFt3&ZhH+$Uhs=ezTF&J97%pMfc}As)L>V{ z@_MivMM`aXv9-3de8aI&RFjw9{`kk9|1123w6(b(Y%D&nFhWJy;r{TigZK+o4w`hD z@Y_@fB#gsMO@B%P^S+!{^3JBV|4OC*N{3^I5(9*_G4#2!}#S zIr82;ocyY!NU_u^yQ|CB+x7EE6r$)&ayom!aU!n*&{kpizS1aIx50J;NA0r7Gxi`q zlCZU7xjh8cK7JFUFuH8tztu|cd8~$X^{46Tebqh^7(RfJva6PtcV2z@4>r~jP)k`B z#wTyPpZpEOLjv17m%h9Eqd5m@LQl*7vUc~!&LidD{jszAqs41;SQB>j=)?MFV;kka z3}P+mzjxO7J(D0sHWrTp8W!S26<`jD3-2ozn`CL*Tx;p**9qVwHgws$xkMIZQ9Es$ zr&=0H5EO>#RP<*vz|Yq2d_4<*zlBx06V^k=p5`*>rCyIKx;5y8abLul_O;I>Ks<73 zs1-KWUvj`$m&qP-p)89go2&?_Lc5ZBEEqC(gp^%bXUU9~p*jtfx-1xqFvPJ3E0X>= z#ley(jCisX20@7{zzGQ$@qr*w2wJA&+#d)H`(jC1a3=x>{Sc97>9`0c7+*m`7650e zGskk7%pkztE2U6GQi_w1O8n!)kFFw-(HKex{Vj@s<|pmiDN-@(GuA{xE@keCX(FF0 z0dUTplAbOxSZf~8aLnA^$y$~4EFKIK+!!foC7!K^VWb4Wam7tW{UpMWLZJu;Nv(gP z3P}ukJQybx?<6-@2Q=*E0zbKIuy`;_2C6?14~n423MBw8i+C_enrIwOV-WSTpvRN| zI54xgKTL4 z{n@eWC4+8^zp3;^*o!MY+-9snxDmtyR$}fSn=~d`!U)>)3<_7w60xtaUj}4#tYtC2 zIhVOFCW%z>hcezM=x!-7l8TmP$vDx`6!HHf3fyuZR?>JdNTkw6LN@qnLl7Ajy)Q>$O2Z@@UP2hG+}O!afK(W9VLC4oWv+dhnKV6G4+EJPOAJzS=^Li-%t9b!a$SE z^vDmw5E)HM6Ms^8Lv|7#;4ClW!6a#8)>#hGFbn$JOn>wGcG!xOem}|aDjFwv3P z)WP<&*-$GC+#=!1Bod<(gD-reMSxB<-@tso68KEGu{bDj&dw&)u@+L?zCoir^69e~ z;AiW1zMciZ-@@wnPP30|G6l5amVG4QT+3j23>^$AAv8j(7PFN}8^R?YLtmH3+UccR zt<9N>&wcqKH?)xHqw&zheLHTH6ty+6h)|%JZ3HW3r$Wxl^V!Be$BP7d9wMsXo$h*-d+?G7d znom{NO8SOhvklxiOe=!S;^tG_$uEE}fn#O!*tM$aby2+- zs(2?>%tfYt5gu`?7c>=45e_Uh-Bv}zmAcZjT3(}p+w&}DNY@XdJ%XDcbL-GP7&k5S zO^uYK(wffWmP?ILtJN$!0=Gb0V7qdbNjwh;nIWQc!Uk0qg{uvG+{-IuP!s7zp$>yM zMdqd>D$r^2%~)$#a}KIQ5+=FnyB$r#8z9xWISiV(QCTlYPR-eT?IhD^w0g`Y)C9Dm zMyIlF8tB(m%=scQF;orYl=#G&&D9hFnY3E3vIVQab1@|ihy6UjkB|`Fg~>h`SP`Wu z6eodt1pt5|gV{i)`0V~eNWQqL7G;PgXG3WyfP!^u)cr*jL_ms3JneD~Yw0Y9N|h{P z(mhQBn#*xl>3{~p;!eBkI4HEHG?mn{0Cg4+0GdE$zW_!_nDlhr#{bR-R#R@4L`0P| zaT0~`*~pm_lo~scCvNHu%a|h=z)Z@bpfe^g#~YLSByH@ccz71{u#$L(eu8f1yx=9V z$tg9x%cGLbl<_4VbE_XVj}RvE*mPTtjuTRPDV(5C`l6)AYHjw`S0KOaMC1+||dpWlK7^_XmS&_(AybgHJ7iAX59#ffnpfdJ-k&?k{!{61V~dj^P-|- zU20U@Lp`S$%YYI#tyI{;6@fEExz(7u9>>#JfnM+i%vF(c1At5#`w)57QMQ*HrX~2_N=ZpJHCMW?4NOZq1db35u|?y7xi#;A4U#ymEd!KKnh^K=Gtj zB(=xyRC=E&zoOG#T3tS6;yIa|YX^npF%<=&mA6`XOUF*_EI+vG|HLa$a*+|EUs;(r ziwe|gr}Q?`zAcayEi|iFU2|~@909pF?ye4=nAk`pk?cN_5e9434OreJD_cavT6;Pa z4?dI8$)JmE8>&?m`h{~yl4GWbcQ26bv&6uNP|1b0>0i8%Z=!B46U`VVTbA%5J;0^yP~}h{sRv-hcS(5(h@ihHM@f9^llZ*3RZyc}D@APR!V? zPL!0h#=x0@eWatzy!^U-^G`?>rA5l9??3#je0KXJ!c5xr$*HBHjtQR&I=??{k37Zs z2$ov2oh6D{UaYiScsgp#aA$!={M9*kYk_0*xJr;NJ{eUaWJC!E#{)YArPkN1o?q#F z*D}zrORMbek?}3q`9h)pT2QMrKtH?3Z7@s?wb$T;RV4$f^eR^uS zsG%d)B-U&8)^j%I%mEnOefZ>^4~rPnEt-(cD{})NG~%t#dmHnLD3-FhEB?7ofq6$+ zNk)O^f#^R~nT?!|zVTwcy@`561&7h+>F{>Sac#NLCL5 zUs$SP7BpR}H0^U$6H$puDU@03ZNKL_t(Px72#cG?0Ivm+sJiJI)@XcO#IuAn&Mz#ty5@CrdWR zh{42aSf^|DuCfLFs4o+i|ZhbIrj8L+KSz7BUd*;pE3YZYEx-C= zpa$IIasSTU_k#enlxtSKx$~XcI^w$mfP>oLZs%cQpu<}U%dHPboqcQ+bTYg&*T1^J z?5{Tp+|Xy63;z0?5-m3-;o{Sg5)D$@nCvV^%Xk7p!Yjq^E<(XYleO1c5%l2J?k*I+z=}W8nrhzj= z#~KBoR`%#Z{^SC1Bno=x{rs>0N3s6^o~>u=o3Cdxz~9bVN|sJ}r_`$&z_HYPM`Db! zv~0R*5(V!>y5!A>+|491ftquQ)m{P}VQ$GHb@%TM_n#_-0Nq@5md|P{$VcRnJGu8O z`dHO6S1-5M*VgNG?1yET(gw~C5NJf88RGTTClnUtu`oCi#!J7#D}9Opg18q0|Cc@b{mv( zv8)G~@tKd4uMTN#!s#}-L9l1U68G?6D&4&=U+lD(&z-q;Y8UM*A$SmuA3afVGK~Tn zYDFIagoLRN$G~0G;be;dG?!reDl{;V(x6rU=*`OG6Fq~Ug=`4|9N*aqS$+(i$7aFIcW20ZERpX%3eW?6D zDR-(~TT_D!?m)Z--j4D)$U>L2_d&<5H9HUKGK3gY#+Jrfy7+vdDv-~>?-B*>1au1Z zBm8CDgkT-~ZD6>HyfCe|xFChl_V z<%RmqP6zD@DMdc*hv6Y*C~w%Po?dCswd&~R+$do!@OKX=4uCC2gxYxVmCLpp?e>;s zBHfhcH8-s(JV8W4#fQo<$<{1|eWi=YG+OQDOP%%(!S<0tpof-X@pKCH5dgv)0ii>< zLc%SgAlQLLn40AVsY5!&HMC1;j7SyFIOlCTI6v-oR9m=R^V%9y%xP&9gJyry zL7$@v#&>F$x97GhI7HNS@$j*u(3%<2Tu2vIyyCyJ&4?+b!IjA`G`z?Y<8Pp1{;A7v`=t z7M}x52$#~*n}lM3{4vs6v(GOm$_)VaNcI`|MT+Uu&yw~J$;R`5GDIb?CvY!@&m&we zw&8M>yw)K*Nb*3Jv;KlNR1(BqYhIU|1!iMPVaCWE4?e)6&==tkTIAA6i~<-9Si1_% z=RjiMgUp5M5lGT!>)AT-dKLhG3oA|2AozNY%CA~QVUN1$1h-L1kW=YKQe`JMp)w*N zBlzYb69=X23cxKTq|UUxoTT{XC>IA*9+~zG7g_3;I!D$nOCbu%AUKha7=*DuqG5!m zJq?x{iPSy72ELfa!GM-IZU?eyX~iIw#y^>l62HeR+&dHo#|-640a+mZKIpi(6wQF0 zDAE57mxL^m{s5E;m+z!;x0m1qCxiJ3@f?yV0kGIFM2~}qzg^Db8O;_k3Ml9Cl=^+1 zX21DB)Hhn>kZDhIQpa0pRPaLvCmR?Js!81KClts0u?)IJ{m4jFuoNcUBE$6}a7EB7 ztiHl124UAv4pWL7|Expq_X>HkcQcAIsDy=sK2uPH@o12cJtPMSVYl>p%)+CR5y|83 zAi>EMqmV(j^m<(3K?&+f-0dX=MxT<+Ol)UD^)llr^#|%q{;`W25O%%fFku*rEAdF^ z&gubjGD@0w*k?Ey)u*m2Cpc@q7n z8)Ow65?^{pPEF#8P$`bPEn461K1|ujjtF~ja zwwYL%5m!p#PgAeYC^ibLPCHHv9NnB7MLZrQ&c4$25*;$HSCr!uwLm+(Xgi^W(aw@I z@`k17{pQ-(G+EQgs%D@Bz`-o>1}rbW{>egvuhrsL#l(Pf{II5Q)7~bUBO^mPn!Pm)gAA3_OuuBzrlaBxoj=GJYnL z7-<=3rn#wpkl>7&5A#D3W!Ql?#7XUeb0 zYvf?`)S2M{MPVDx>Jo0x7DOKEao3C(uHVI8(4+0d$EkXan7TNf435BDv&sCbf}}i8)!w+(HMsd*NUx%s z4VbXZ+(S8hA*F8_*3BO(!Al`yPaNg~W#0{{E%}{=u&wkp7SxOL1I}@?fM(a6O~+E& z5C~{XFi9c8)d@FBI4yDZR_Y{Pti(%IrJZaSj&&=50Tj>oajz<_IwKjhKF74taY|z4ehr&g=A1ZcGY4{$&%Bj&oZXW&K2WH zSE+^SraoWUHEO4XgY^G=3}xB(63mIpO9~UyKEe~$v7^;G!?4w|?zC1nn>DnJ0f;85 zQ*jS41+yUDg0?+RP?w-7$xPPY6Jv$W?SROpcJ&-Vzphb2GR%(=1y4_(J;#;VIj1r9 z9wqnDXVNv^Sw;qQu+T*zP_0*i11tQW(Yu$24{P_N!Wl`DJ3^ z!$c%dD!Y5C+GGMYc8D@BN+cw)ERJ9fO9IBs{S{)!4 zg(lk%@xPN`a>u(mM;O+GHfu(44QoORj1szgP_eLU8b$H?=K8|o5`M5oNb0BRWDViP zM&-E$1sOmV?83pgjtQuA&DdSpZLWcZhqe~u?D9dejByQhX==&V<5=0=jUm{eT9CSB zUDMaEOWd0VWFdmC`(TQ>)<+fISld2VL--v4h9<~Je6D!u)djC}{i+$^win&t+~@b- zP(;z3o9wP$;U*fmYf9sZ5L6-ul7aBF=BD-vRoJRzI}*J_qDBN;gT{*9be5FUOEhQB zOSq4|X<-y}Zl_UyUA_0jMnOo!m!&U0l(;QORPPD>L`00w*0Xi&dKLhG3+v&9!SFS7 z#mL$A`;+y-ObPJJ&dbirKh)c(A2fr|lW&dS^Dkc{09(eTv&Mg65fm+p(ILD2AH);X zFk>3VwbSP=zx)Fe`(fR2_k+7Xbwd;vky^8I>yORL|C#bD_!qzU>{tIgiIGKVHs`Nj zeQkXmGdF(iShzdXKk*eGMz(etqr!_Jzbmzph5J^X~n% z7~|*&*mLQleO}=1vCbm7aGlI!rA;Y3`9eIoD>2e4EN_sDH%J|q7K?`Y9R@Xd(eQnt2y-hltI=3M&n#fl;37qZn(p^hA` zUxpjoYCB*!>A&;u26x{@7d2g8`~8JK`Ezhky~q>YF8#ZyKsb;NHP1b|_}t?&3J8`L zf6<-Bd5P?$Wj5F6UtDNjS406;1)>!2xL2A6-3ATt#2~k{;8tgHb4i&*ZTG^nAM|Ta z(8nt)#^H^H;YBs}SbF51{*c-Ua!Iq6z4zkMXd9D%aIyONg{V!ym3F^U3vTy7NK5br&5mW@^1_o&Fy$DT8)P z_JvE0AJq+%vmvpcKl%?J-F;Jex9zR7-}}+470mhR2eS`8e)He})0mj%($+0w_n(2I z;Goe_l#!P{{NIj>VrTpO>wox~(q`<1-urhy z?%u`ypr*Oh`Ju7(ufW1hiTpNQk0j0zRcf`X^H?v1#qf`aIG;eb>UdIe)c!|CJSYS>Z&jrSYFsk{^1ROuKo8T)ajcTu)0P`Ngl{07uK34yP`X)0Z@57-ZIH-(SDr z*3gHxSb28i{`MqRr~ww*+dIoYax8SxOBN1;x4iTt^f`dcb)MVZ`2#~kyCN-zL;o$W z!1-uuo(f;QY5hRMV17^M25;ZEGp(YS)=A3N+r!RnwO?p_F}(lE)3S~Z$U<0qx$)f2 z08bg{{KL}^?wz?`7-+l99Y)J<@didYCWLb1ftMdDfMD(V`K|TWO#_A2K`j|wx-(iu z_K^trkD9PRnlM_b?0tV_wu~%=!^{^CE?)1QQSdt+&-dTHdE2d^5YbM`tq%uFcU4gg zFSHJSuu@jgm#(?l&ilPK)`SFvfG4+Ms5Ct-Ev~)z>UUZ#WO=hZz4Q5p4t9R_oU$ov+S;kt{mnl{FZ@l60+q!>_VGjhh9Zh` zVI-_?6~O)3`v3TP765+>%cqm1KpN1@c`fv-<4{4E)R!_VCIqJ^Gbuej48`a8sU+1m za;+}0CYDpT>?M33g*x1_$?9&^teThy*y1`Jx!D-o%hoE3bc3t&UM#j~Kan1)7nKVJ zJzMAs7A0W?^Crc9NRVmdWxeF99HS8mCTK*(I92c!_ISD~9z%w^$At~NX-Ijba$0aGRMtq5g+*9qxKokaA}z8|`W*W@R*|tG6_^N= zH$;9e2|*oZZX_}9Gl7B4_#(@)B*evHP0G0_<6WU)8YBU5GB6+jfGCb8`C)86H3py^9n}scloh*_*$Nof(mPJrE2|9W*l5`-M@}U71T06F0 zsoE%r%8iWYx*~Zn!SpJI+a@?#=CdlD6k?=4`Ph|YMI?h1TM!|fJhqAyzcBEO(?~oj zFhIRYSf-m*9MdvLU0yul`y7v=t!aykdR0?I5pp^ZM@6yRIc4jPB8rs6Vismt6M|ha zccn3F5gaXZw?P9#V7X}=?9`geYD(-;Wt!koNmPjPqp$#)l+!3|bUlTE#s_B*m0laS zmdF;A2`~dxHYQ$>$SrE1? zxXAET!3AYf6jCt?l4?>~iWU;wNP@z1(XJpwt4J#9roKYD8wL|OgbWGW?&h3JV&d@T*S(gE1Z>X zp(r;1C|C06h$bYoq!W7d<_OXVRQd!*n>UE1oM_1;&A4|&U+Gg}&6_BBYYqolHq-iG2?yhhBoG3YH|2J%fOLwtn;V zECBu%77rpA;ovNTcv`w1XdDMSQ>OJ|1yrPfFanPP2A}{f1aAnTsWi-u5^YK#KuXQF z>>!juoS7z`E{kXs7$LqHxG9IFJXGB~ZBQ69jReR=NOdg?%OJ+(J79_MO4%*(zy=9B z#;j`M8DNvL!e#DMSGvIy5Jn?)9NfT`<>|1T;dvM-Aq_y+0Y~>BI7CxPFzW{AP$XcO zfGJvlQyGk*j4)|%EYt3^JTl`Hj~Cs*D@x=#_>eN`nSjbNk_wTf;>ZvgXGtFI6CZoJ zgm{@&^))2`7E%b{Djt-d7-Oz`xSpaJVnD^y5U|{0;+EPJ2pSENtdjaOH}ecU@8!i& zFl9M**=?HzPGlQu(Mf7V7;3dJNkcDWu8({6EJ!CY3=2>|&IddmQ8~urmzgYw0U4-m zl*O3&p0w~RQm*lAFe&kbo5p1_l%6Mz9AB427n;KH10bbjQmV=2bd-s~1Tx&H9Ljh` zm0u?bB-2z3OTe$ehawpl2L5%-mc=lHK?axyxRBF{@DhpZv`HXGLOIa@5QQX&bB?{t zATFX%Q%|&E%L$X+7;GGT^b#^+1izaEkh&&xH3<{Xaxt7hird%0bdNB5OW?kAg`5C( zC`(wFYJLF`enR4dSHe`__%Q}|2w?^LsSw4+Sg3m*AaOgXd5$)CgWjgAC@`> z)ac7#CfSiEYfNZIOo&Aax8vLRdH_K-9F`REED#~%f6#yJvTx(!x|+^wTV zA@HYpuU|SS_|zhq40(7&fn>u(4k=(!@R3Nyr8z#)ICNO2v71(O41t-Zsmrq?$6pMX zcp5?jvqKXvKVtF#tcbV+5*oPOEQBBdS9P&cnU0HaER{ArLNr}B6rErRJ$8%O#hOsc z#HFcgWGQ+#=}57kNDN=fNfwhSXk!J&E+?}Q2|@*eFpkMYk|Ra|Mx5-0P{S1z;wSoy zYUtMqutV;SglAyA8E9UnxysE1mcG1Sd2K!e^2`D*!)RzxjGbgY+$|bN|gBF8=wsFJFIj%yHG2Zm3~6j>ptim+*Ziz9I@3YUbX}p>|ufqqr+L;SH`_s)y4JZ zj%A=Hmr>Mz_g(+K3h!uDNu@~?ULsb?G?W}Wx`cpTBThpl<}EXsMN(iHYb~%}BhD4| z)EN9)mEF=YqaCAh8r|guYPl3tj6VuS@AzCnE7{zH7hZsQ)Z*pTDp$XI{qzf$l$Y~G zf50D<*e*8H{N}xb?IAKJ5@4WJdRCj_U18O;_GVx=(9h$7xLGC6tAK}`$U#^8@Ye)G z!5W6sZlA8#RWhDnqvq~3IPO^}Y3zDW(i{(>YueV*!uIlNFPSoBV`j- zF08h{f6i#(9C=9}^~NI)$%g=}FV5|*ELtY!gcybXn-7XTgjA>5di~a^#tS37=+0UY;@|(wK1A*^ zw={RR-5@k1+$T7#Cl|Jj1A1A26DX|?9hRQ6AGbTeQ0g^I_hO0AZ$IU zXlfT_DfC>_Ij)7)^Wyr0!!uo1xmnYxVW?b1LP$n+iJu?<`g*lzwv@zyt_jmL2@cLQ zLsT}h%Cb_YhpDCyG)GaUG7ag2_xK3+8G_c)ug{w|G~9AI^M;>3eRmY0MqB_J;0C}Y z6#`&?A3ppLJT(pXTP{t9l?}4ArmD>{mszN4LZX4wAWluygheXzNaCm;G#x5UV&T4M zDIt$!k*Krf`f{c6+?{2*N(r-gEE*Z57mONv*=RHXh6zUKHjmBoXwWHyw z9}q;AHV7q%l3?b-8T5(RHQ$e$>A{NvZ$ z-2Ca&XX-VjpbCrdnXYR*Y{pOTKa#&rOby4$y)!DY5S6bs3-2%0;xV2$z-pqPhnJH=NOV8J{&+OQExd zOgN>eDQTF^tZ^}1s&MpVT4v+P!!W`hT9er(q^B%l;SgGC8Lu*lP2N`+1@Gs3d;itD z>78SEE1s=q>uc9D8l-P$ZM9xGv;6yCzEXdK#v z<^5IA=gPMrrEgWP&Exbp!FG2WGF!NnWo>}Ak# zjca%acY5Gql*?KZF0YcEBUWvHuJ~lxPca8gCkroo!{r1ywTwwwiizqX0`z(?9xH5{ z+S+36d}nU)IfCCU;ch^G6=80JN~?ONcJAd2ks@-z?|kub{OSLZ<)|jVy1M!D#_KCp zgz=S-@~@U2zvDbDG3?}0#XoacR&X7fkfMP5G0)lCpf1`KfY`Jcn^M|1i&T0M*v6IvpI+IcaKo7>#(>&&Rzz^ zYajLCP7mA(hK{Sl%?=4;I&hIMRc)H(T9)4CUQ9rN*NgQ6Y)pwIx-_J)1$$8D$-CF;nMr8-Rn%kd^TH>OHr0Q(b#U(G`_C!B5P31_Mt|ca2)0cUsHXhP zP$}4%HlOL3)eje@I!>uE5h8eR-k8 zny}MPx86+K2k0l$ia2~_`skXW^nffr^iO|YR;EWV%s3DXfky~jX|2Cdd#O@I)5Wve z=)LxAf9^!l3)Q?w2OlfI*VStC=8e}bp1+~U?f&D>;*Wmvf3x>yPnKloeb{$Sp3J=a zy|u4h)%)}^-8~Ct0R|WV0}uoulA`2AAw@W3Ne+j@4-Wak|AZs_WfPAProb zvkfEv-K%fjzKfXH2q70Qy!_IYS2U)E(PWTceUo<(`GRHHFH~Q>eEbz{Q+VGRZC7s( z8Jc4iXs)e&eU^Mq>$m*?@Dn+x2oqloc zxqm^IFu9tF?-f7jh&Lr3g;n}OXk3!GJX^X0*8Yp?-M>X$VX&FmKeA^3Gg3t>p(ENi z`S*qrcg06+3XfYq9a;}!IC6lG>|@%I1N;;$n2<1dTKYn5#-5lN?{nqm*Y{gYOaoS*#)l zxK@ehsv_0Nt|*5rRMAB9Jt6j0k*WQ_;B=xQ?U)LX6lrF;xrIxW;xHbjk%P0WLghZ} z*Yf}=_e%-OC<(^dsFMNy))VOlaxYSd^fgg4yjauXCrU!@@}L_hF=A3_LMB~FaXl#^ zDoDBdVqf z7pPu_4}v9WJd6ltQgKAoiz{u6vt=qe=0{UmXxcxn5r=V-;A0=pLznv_rEp1MItSo` zR+3JL$Wu2m(C45)az0NA4Gsy?gJhz=oo%ap3M5cCT?E1raW4&q=-WXvjRw*f>ODM` z@kDkLg^CgjLdHg_9ULVPM|h#yDHJ;E*n`|3Mu49!ukmo=Mbkpd0Oz6(xzOH@P@X5l z$Utj_0W{||Qfz9C!N{_>7g02wa#C~Y^HT~Gr>7j52C@^WohL6Qs!$8TM_$XKQpPlF zp~wO!clxOmsPk!>&Dj|(qsCd5CXN$TbqempozJ~APjPumlKI2TaSrvsv7JVfQG`oK zidY7t&>t$IaUc!@Z@ib}I6Li%up8(rp`oI6Kboi<=j6>v5p`1&H!jM;?@zr^rfL6_ z25H#IcSBe z^H&n0c;dyuwx<14CS}LS6&`F5Q{DqHRDd1ecn)NuE7Xcu1rt7Q<8(SD;S!gLR$>J_ zlJPJN+US98o9F9%|E3^~IE&j6K?zks7N#_;>Sscb15vb7z+FLj#@dQjapQuBw&0x@ z64aQMa@JNFL?{R8iAks)X(%C=t_^5b!d$1y<-C(g{B~d%M!R4gfC^UgQbiyJkwQDj zM{NrJm=vFdR^^fXy|E()_$inZ`fQBOsZvFG;kUTbmPWyh!ZsB?aWf#E@<3_a4=Nym zNeluy{r^Nc8Ez~|8bMSdmc*e`0mVp7e4Ml5#Lplt6TJjFRidwg6dx&u5axv}<7c2; z<++@)!mu#((Ueuwi*QwQs<_PKl|lzO87v)J(-fC@2Bt4-S#wtNNI>Lj+EWb6Jj4kY z255~bgN#|@+@`pbeN&3#+`xcgLRGvJO$mV~iPugEmVA^FA`jHzWFV!0 zBo_X(&>Y|lqzO##WI?0YpXPX9lqv~xQ?+zwx3B{zoSLX{1X)UkCiL`UVh1t@05e-D z3Ppv9lFmw%B}TnZs`zL{s4|%}@P=yvSDEkR;{<1bLpLJ4WK&ca&y=0`*<`3^9AZ15 z6{C#n!HkfHGN)L9QyCyLy5vZOQ$sa3O8kL~F#}L-8nIHi z#;|$>0L=q8p9qO&lQ;3Rprq0j^r58@d15-8nhYa&y)+@SnT;i3j7Apae5_Ny_{3*~ zYNLVxOqE;U>8~IU(t(ln2zG#J8}cc{_(KZ;C0DFYgy#2~JoM8ElUOv;h()C+TljMT zNmS8OVSs(PQ4#YTvBJ; zzDLfDc~?m+{Y8D12{zGILIQD+8GEs1<6DfVUl_u|U16x)iOgLe6C(m2Qcto3LtPA@ zHECC+j?O4z;!K<@LS5myK_qLLjYSYa6%gbq(59HBSVNXA{16|xDR?QBH5;>fP*Dlp zSfBnxO3PcYiW&|l7$kP+B*sjWB#o?`n$`&o*dG;TXX*2W`Y3Q3ui6T<;KQvHUuMmn7YLL8pK^2m;CpB-UYbY7 zSU;dp#ZXLqq2~))Ms2~EWw=Ttk?BZGB23~*37It-b99E{7-uNMA$KyIg*FJCH(Iks zOZzzx118#3q0@jQCC)Yg2U?}%)6t#D@B=Auogu5%t4pSdPr!w-(4JrH&1xI`bl&f8 z4vP}bhq$rvAMO}8Q1z)&Fde9ISFba+E3kBoRI##=FxYry!&zEW*gxZyw3rJdhJlqc zar)7Ct&61{0d~fvTfJ&h;O&|7S{P`A5K=-MLlhm91m0)mwZ-TE^}js(U;QJZJHUeo zb~Hi=D-4cZdvA6Zr>6<2RcBg_WsS`x%Ol6_=DC)87rQWQ!$@g|43iSvY1;eDmC;yl#tm@U+hdZNR@3@XIiTk*1Hm-aQ%K1>A1(y zspH)%&*vB$mZ$!p_fF_(ESL0Bb@_$*s*S;H$tav&>t!Qc3c-w(rTL}BMeV>H$ByIm z1HpCdn3Pl6EGV>?z+Lfd&Q>>>;09C*hb|`o7K;+Q|#4L z-04z#rxasanjD55<&E`KtT9Ix*NMh=m8CFvtRhdN4uY8_GQXnXtRbq;433@1YG`4R zrYg=TzNw*BVfEqo?Atpf@8ib~OtVs}u9_BFKnNHmW4Uas0Y-)wauSQj0#iAHY0A}g zGP|tZdEAT#a}j5_=xG`>-o9PhM(JY3=-`=|!TA}9RkiIPX$?k}CYi$wZ(%N)YiVb< zGo|@g8prCG1=<(c&%C`y8P3#8s7>6)Xky^xdsZ&H%L{o84P(M(eKc)M9F2Y~uGih= zd4VubrzqBzv1 zP^mOq%~ghHG%vEL*GX}GFHmA^&RQpyDULk$82MSr?lTMwmULs{d{Fk8)~YDH5-haebv!BFC(iD{N*S}P?Rk9jG4e-K0yZ6zcNRr}1UQA1r3QSxqy zeYlSpV%e{5PG>EFnM%!Udww#lU`A2}>u&v+JFAHxdZlQ4ei|IK63!Sc4N%}of5e>v zr-e)0I5D1`kI>sGP~E1pH{%yr*P}$uMPsf?wJ@$xfn#OR=VSYCfAZe{{J&2>&?#V! z?8pvdM;PFzV}W@;E1^haHMi&T=bv>h8UojN)MtC>P%gUR<{Ke5S#j$|fwe;F*cUZ;H z(0XxpJy@AwjFW=MQ`0G=m?3{*g*0Z!;xdLfGU_ZhhKtJr2aL_-uzW!pb>tx!LBS+5 zCwkb(2orKI#>|DlL8FEJm5mU>ELtj4Edy-BN&{B3#xm(Uqj!f75Mq!T#tYAV@tJdH zOIY!>KiGS;d$Zksxc^6&0S=Cf;k{MVXmZLNUqRb2QE+y9`P`lJ)db5m*X6N=yvfkM zSg7o(H-2~P!vdoKPaHr0+;gwY&!Gcl90x!B`QF`!H?-WF**ZCIzD&vpT^!oOZnZO( z2>4_vV<}yEEjeGq&UpuR-->TI9s(Ve%hlQW^=B_#pm5jWB@(-=sDR3rkSO%;$lx+FN>K!+^O}SX=?iLXAgtduMfiSVf)#v3O~H zVsAKr!=i?tu&OfCPZGyZ!sL-IN@r9WiyKSx7bp%VIl+hH-aB!M;;oiBw^_ch1kY;s zz1F(-&hkUIi~=r=Qu<6Is^cOQVL^V(bgq;N8?81A+hXQJ+GyjzQ;h_tt;zEx4U_-5 zY~j`TnFWEy+rSQQ%_n0U#k8nUjd#qYYsAE8e|OUuykbo@(9&%sV*bbG@)prJHwPDu z?lYxe7OkbWtS&{HmokK$2T(U|UA=MVXHkR#RdoGQ`PH-b8H7aTD&r!X@`nWu@1Du$ zPR3_WaJ0C6)TZ$4g_lmBIa#lv$eQa-_kMiu!9%oG7>vEx_|nTK&)N*V^&N9`we-Q5 zp+lMt_0`5du-TUhcEi$}Z*E`v8#zLoX|uU-{KVOFXZLLiH{ZE_N8c2dmye%6|J<>4 zlq1da^y;);~Ut?d^VgXXTyUl+V;DVzDSyD6q*fw57T>(Py zHy!@g{!L-ld{x^NKFUmsP{5{ZY&|6sA(woIP3#)?lW3c!_k`Ots1!A$)Aj)PA4v7RUuD$out&! zWso9wKg|^IOa&t_aT19$k&qY+N7F&#)Jd9cQbk7x5lFwCIvu@&IdVXL21q?oD0f_R zwi2Mf98wEzD%xD(XQKuQ)_CmZ3Nx2R)57nI{V#HOOQSq!kK$Q9`4$XjJ?DhLw9G=P z*p(J8C(iRc9C5cJax8f=TNcqYuQGH1ilaOjai=4-vkqA zA_5(NI8WVC;&g??$#Bx(#!d>jbTEg=k)wUnAExAdm&P{sUtsW z1rD(^6A>jCX%`1sFg#!w`^!9Wa$4X!IJr02*VvNuaY45ez;4(SJYV#*l~BOkm`+P1 zIgA6G$jr_17%O|LqL6&5)Nf?no>CAe;5eZ1mb-!9%OxJhSq^D*z~IRu<@O=PwY5iW@&Ws_$|~|+kF!3(4sg)U-ACTfEiGZM;IvsA}FX*v2Z1-YZL6)cL7i)#)0DG-4Y`5bG ztqF;0CSo(uG^0U<Zoy^<-v%%9a$7uqN&PbC$DIVStLncnz${fjUignC6nbhcP2{)!-H(;LXY(78$2qij20}vp( zIOG#oH6hS+s@h!P%2?o%@KyGV!dab6#jfh*3dP73rCF;S$)?s7S+gRUp*;tu%qh=_ zmOhMwQehk~EL}8GP!a>tc(#>M&&{R8z$MVO5!JdLqnJG+gk(o`A8Wq`?o_98`818_ z5>1KneL2=rWXuTaD+^`uW%P0cqEe;P-?cSxsUNnQv-AW8dxPp3;ebWjfucm34YI

    gwVN3`A$l5WLvyJfgVkr&+2t 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

    KNzDOa67bd}C3liIbfn3JSi}rGqYX-f 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

    =KE02Q*KlA?ayVCgWYJ3ua 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 literal 0 HcmV?d00001 diff --git a/docs/screen_green.png b/docs/screen_green.png new file mode 100644 index 0000000000000000000000000000000000000000..5b10a12bc94cc5775ee4e82f5c4209adf68e3481 GIT binary patch literal 285944 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

    E`~ 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%0DXQi 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

    sK;U$RU;f6 zJND1Rw>>;Oc#eqm|b9Z07)d``@8LUt| z_@s-WWewPAcKo6X6kQ2C5 z%m}qKzJT#7n?09-|0<~L#*aS(uu5h%>-yt2D`EIS*~3@>^1P3a1vR0SRT;xytc__s zF&^AD8GR8=6Jmx*lhRP^>*xsKX49rM0b;^z&y9MX1FXkHTB`0nuFB>)*0#1RZ5TOI z*qB>e`?D7K`>zF3pl9oPPmU3G#ARiXxWb}!W5~^O$7FZc?%h-~7yM1_qCOa;R1Y&T zL3F}|hD*aQ@c2+Ofx*E=5h%O6R;hKbsnC__oxs|Ai1bC@?4SX#1@hY%^>Q9;W~a5{ zn2$FF$4G>K+(XU>vv2Fr!^5WgZ37m1k=AtnB|wx}sZekAF0Adi|`2 zOCGoxuP7-9yiS*y{@ibirnJnYC=B!*V@c%W9tWX;*9=98?|0PFG*cHj7`!5Y*5mh7 zJnsfufHQX)-tLTGOp`jQCdfJR+?+igJIWM2TEgP$A4tcvSY<*hic=e4>)xa?TTw$X z>|C+5rL?a|{R2D|s$M<~^me#!5c%fokGMXQp1zLD9X)x|naHIg1w%H7O9V5$s}bDy zgmYo{B>$padnp;a?tcqF(qS52`mT=|kTZ5vlWV07;ddpU8@rS6r z?yqP&gT}qb9L%K2c51hBuS+l1)X5nubJF6Fg60-d>c$R4JoBx8eVYCERI3xrS@bjQ zMa`xnYO@OZ2x&9!?T_M8iD^sI6@UM{$pU8{kor%WKycL z*1ZU{Q!xoZ%x4y^C?y`c%0`F0!-=LFfoo|FSN18z&% zsqF8WxCPq^lVw2J;w&<#PUzAmj2nr~} zJHmHeWzYj~%lyVypR?x4?)}5S`j*rk9hnNqijzclCYY>NStzYI5tRHt3$5W68hX}c z9o2z~T5`ckxBDJENo}i=?xN_jqF19rHieHdv9-1H&Ci}WgBFKcpru96cYWR2hPbkt zuAM?YH@6oWMC1GXE6>m1=myo_5nY3W6=_{ohqKYQ~lqPO_o%YO)zN z^!zz_G7RzTo}*MbbVXH_QAGFZi?apceb;wfBSBP@A^@~E`ao+?YO^3G*umE$C=fL_ zJK(oC(-}v62dSk|RSGnd05c3hc+o)WnI}{%U+->+JA}>f;Zuw>`u6Gb<`L3UZ;7@U zK|^;}w1YDGmWK2(J4Q!BeCflROdQ!h^~Mf1P=KF7;6Z!=@M6FqOoXQudSd~N9s7%q zt;6#&0pd4(m(h~Q*g=`h5U1epZsfqr}IR(!1Nut69)lz!FLdzgLG)9`OU zV@mG5hDe|9RfcB1OA_;75lL*8);#Rr|C8#@=|&o%V;!->8#&ihLyn*bA4s^;?9S;q zf^jU>DrzjbByT^z$w!vjQq}M`eP@;eH@X{X6lg_S&*9(ix^}(3UT?c>h8KeqCe^SFViVo=9idj^_>{^36JINM_20X<==4E>xNX~*3yxiT z;;zgIJ(cX%&64k9Tv}Y5g)#cye~;U99SR=x0XboYTTXM<;JhEdahpT62?b$gWDRG` zhz|g>ah}N3DCu|dnhC4KrNjeAOH>8v zsi@shS(0Lqc-=8~+>5a*7I-v7!{A}KMSq4ty%tP>$4X{FCPC;ln^7)l3JJzs(5tD@n;~v zR91xijNgN62z?t&BHT-n^0&9OEx5k>8#A^Zr%cgGJLk+3Cxx>p%rF zt&JD(F>@*%ud1qw2j@RWj;uvtAk2xi3r6#4J$;(YIZ+cm4W=n z#Ov{m-w74{%8M)EAlT3$>!EIK#R2U{?T*H-8*lrixW`JpQ;(4X*aBf)wLEWB*Wxp4 z>*pSfvTOg_+V~O5*W#S_YB?e zrKSs0rt9tRT_$I%sr-Cm_F?9)+Jo}X4N}fD{oXs*B65H05GCA);!X@TCGo4F@v(M) zngIS-8KAP@YHXKmdM$(!tfK3}XnoI^H=LiYQ0+L)MpR}y&JG$ATQy|7MK5G}u6?oL zr+M6^v0hEp=**W`x*z+s=Iy4~mU|WR%Npa1t-lRw)qc7|2a}G0Hv|`7ot91Q*Lt46 z8@wR{=MB%ZYqYYBe>zXPzF{ArjkjZh!&CyfW zJl86$jeuey?1-*O7!3n?34VB_%GySBU^!$wawMZkVLG#Q*mRiXp-g$X@fca2fu4Yq z0pd9!Br2hjv|=}BXNgbOur(S%dK2&mPvN>x9ZiB1Ejv51qj8Xg1B0MHjBhvXbEQaZ zJ~DGU)}N%r&?`{`GRaX;R^G8=$2`q1)Rfp-_dLfF5biNV%zH-xxcbao6%ndGFU zrdqA-HcPMNfqmWC`HlGvPx|Sg+VvctuRDK6T`ruKpvtmT%cni ztIKA!#e@lK_&CN>uwlV{1kZWF^c}?vRVzba5@n4oEmtz92M)Dc@!TE9!gxt}rdYH5 z{74hT)?rO|S0LJH0&bg|F-dwtwU2w{OPUng`nf3Cu-3;^5PJvq?cE+PsJQoR-YmR) zEN6lsjavu1K=5rKydD{&N#83-*?N?1q$GM&R`fe>vfV9pbZeNnv09N&2qAV3JxstI z^D9JJ8z0tAt6X*}<@Z*{b?}Mf?!Ru7Xm4$8eX;t2UV+F?#X(~3zoZ@o`u^?8!DA}U;<#-&`%zFpWho9kuUb5GdDyC{Pe4WDwg_QaQ-Z{Z=qb*A1p}D3418jFg^i7euY6?=2 z!yddL{?AMH_17Q7Y;J8EEJHN{7fRvYMKguO4tnqosa7iwJYaP;IOb#F2RrtCWW~T+ zeX17|VNXBrBBgw%#V+x>Rp>&#>Tku$lp_vZS)|SrE$=Et1Q3b#gZkvRs7la%V&nGE z!B`KDl1x#t-%*0qz27@`Wkt!@&R3Lrm>92{BiB~Z9;I&Ba%|@54R>WT2hiKKzpsB5 zPX7A^3}D5yH1h@qX{_7$dJJH;)<&r_8eSUfF81&25ZfHl_?o@i@zH8TYAA$1P07y} zJE0!)e)cfY|NT_t=~R)W%9N%p72qZn?DIOYm*aai^!Gy+%w{ZKmlec3Tw7 zyPy)mqC7=x!b&VPklaaV-Z@NrA5vgN>w=otI*3M0&~pgFA;qO zd4!a**u_rZ&s)x+`1d!Je&c?3Egs>YS0f*xAt1Nn!JEMecM)!g6!u2rnQ~M*aY;LplnU{0Nb(ky z_oKJg-vp!8r^3#$i!7XYjNtNHDvw-w#^#eH*ZoAINW`J&eRROw(CsFBb^G+0=~b=S5H=+?e~ts**CF(SqJ6_2WA;dn@X#J zUhhw2ASQia1dw1hq@^*b&`NN!!}F+a`M^&Y$@`FDx_THsZ+X*?FIgRt9la~Ds#r+ z;2pMr=jU@8?k2sI9ih^|GA(gka6ujCyb3JK+u!!q%SNlB+4Ei*cd?lf<-^0`m> zE%|wSCKtvF8IXY`zWFV%Y&!fh6>PW4$=Kei;$ucB$QOz|+{oXoUns3SD-4kTJaSZS1L~dSgvC(NgVxWOK7F*cwZi(d zKqLD)t^`{ouf9!?t+PI`Mttj7%5u*W`L;vd3~*<_AjYdv?d1aSCf3Q&3tlU#+TRC^ zzpm*#(f)rwW>T?-%+s7h=;U6$)G9jIy*u_mChj?S595bx;&-Bh$a6qe_~)vbb$G*N z`kEyF+sx46JUn=?_@SPA%NctBvr?<~d^%_sb?z}xC}Kz<5d?6bN!!_oPH#Mf*tkL2 zs8DTB`~QZ9zR7JrC6s}I!4d*qpw!^zJCh9-t+AjM2lnVmP_|7)yo6Kqw#hj4&cld_ zr-$f~xd@_R>a%Y|kiy**`t}F*+g`Bp|BPd z1v)zC*(CAVrk@y#oC10Roca&!VmJ-c<&|(sY*}v}pBpf-iPK@kMpN2XLxZRI7k+)5 z^+S%6WJN)iQsna;F$0lPoKDTfi_{38xgIG>0|8)X@s>cwKxKAL$a{f}0*$0HY%Ny; z)m(1$_fB4e8OP?VYpqHGdqzHY6~{Y%8(9KTC|_3dy>CIVh0B7=ldxUWnwXINa`@Q! zkR?lmkq{UVc5ReyW0&3sy8exF;PiLodb8jA@BxwR-Xnb}mtB z_q-+k@25vubcOfN=$K&R%DdQ62q7EdGj?IH`*Qs>4Vre?v#p^O#?0-jq{}ojV)(L0 z%XClAk;E8geL(<5n>HnR>)OP+-3z^)?l3zlbD5@LDzlEkVQA&C(+M66vex!YT-7L} z_!}2PFO43 z^ou_@h!ahA%$JduSC^59v(GzrtYO)y1QoHX{t(P~e>x+Qlai)po00XFbL}~@#&dJ* zGQMJL15;p+M<$47nzNaXh=WS@4w-#QsmDabdVk{kNf~{YY&`{YWud||oe_-In}YF5 z95rebwhqSI9KXQ`PW}Lg0}>WU>0o_*a>M4%&Bg95y%uGt%RUxV?YjJftis>dLf|2c zSG7+c1R)I7Gup|=D)a^rZPZ1}vf%hQvNKylNfM7sCe?wOn?BIp@axyFuVB`?J^j48 z(7Whn=Z4f&qCC8dU|3Ma2hU4ZeZrQo;P^yWS2p(|A1xUP2{BP4N0<0ypSc_(W&t#CU9N?u3-K|GIjb?a=?KQY1XmRl2f4pT`q41%~)Kq$6q z97?kN`{gZWS;C~m*f`ZT@c(XYGVNJgO&S1kL-weByh#c*7vC|^;}xa&hYieyC(;KZ zacXMn#fvT%o*-?0)$5kXeP-!_B3Myj4}b+Ji^}=+$~BOMwoP8TY#HqpM-STpBtTYH z7V-nlx!=*1FK-nE1_tt;%fw>{Nv;e(hYlTL5Q1y6ml69X8oOq)Vk5>gUQ4J9;Q!-a zv~uN1ZujIuh@||mPIJ{KOyG6KRh4WGfah~_o-{S7_UpG})25~e4;V#pc-%u0RoB_h z#qNRRfJKXVBq5lhpf}tC4qsbWN3Indc<>Nn0lm7kHXb;9c(|>t?T{gW7$EfSIp#yG zt;<|1T~qJ?Z-k&*|R11(u zyoB=w$6TVb!P;+uKk6D*K$UaWyk#@hQr9t?!w8Fg6liNGH4$(Slm`J%FT1! zY10Jv7%cQy(kVum+~9W!&_HnIEJ!7dy*BUvQ#@ihiwLZ_GHDBMH%?$>$b&!2z1gmw?}4@)BHNL8A7d;xk$ zW;YxLf3{iM?Pa*-943MIl(L`l8f3Hg(L{P+iMW0H41a%_BuWn66V=n33S}!af+E|O7*nq)7cjnUfT&Q z$TQDd!=G>8x`i<=7ihr1fi{noU)xF6ctlz|Ow)LN(rI}yPQmNOB~+U6^YZNpzc){O zZVsGcAF%Z49)@ym&}m}L2mEiP5R30e+934%UNRZ-_57y%24$L|kKY`JyDL<)NONDX z5IBWW3_4tH!@^S!pjF63K?m=R=f-Ve#$k3zAeuXe@pJFHi0-X7ESBWKXW{5WGTK=z z0D)e7#BdxQiRG@!fxhCa@(N#vT9Gl{6s*vh?6_vctwGhA1Hph7J089bUx_8U4C1-b zdcwwdLrVQBwInhFvkBWW-iH2ZMz+!V%_W^ zc)FDMY8$s!gq346Ln26Bn06hUE~D>`(;@-_@=8k?auBNdd-^a}Duj%fcJ1D*J3SGYZ zSY3OL#UiyWmzFGDifsfdtkHU2$Pba_P)-WHC*^yosjCw-xnjlf+8|;EF*l=)@iE44 zZ_2@&)bUw89j{+USZPl`;GW+U%zyJ*M>IHV4$phG`vFWqB*a*&wUzK04Uz;S;#fxDA@+M;R%BNUmu!Isb#!14wqu|eh=!7JZ|D=;S z6ms19bC96%a`7(O-xQ2S3Qaa&5KqJlSqntG;Q0wM{pvGmSa`KkolvFZXi2hC~mMI|M_< z+h{8UivY9iUAq>;`PSZfcRKn0?9~y4C-q>P+BjOyB=cDo2teNurQS$UzdCRFovCgod=J zNfN3dA*5B=T2-3%Ol2(zSxb{-OK6lxiLpzAtkwVhG&8^7@9*_}&3A^JbDrni&wXFl z=lU$>7XNi9QH0=4O76Cbx3scS4SD4mIop&ejM^DAIg1W2CSWlWz4ehJyKy<1_G@_c zbAUNCE6dNW&*uo`#Af5XcySv8curjUN#$@hDx?;_{j|lOU=0v_I3T>jGUCC^LBT4M;!wpqGiw2c*|$(<})cO zpoxKY!M7lzQ4g94#{eTzpf~CpghA96z-AowOm3;jnf_O>DbqHPV5KQ9qHKW|gF1M0 zg5?CvpKNSwY;6V63g9-x4(w#`UKAMWnCd_?3*@f+~uup^}TX8{FdX%BzLobFy zPAL1b@)jS4P79AnJfBG?4K|@2V&wosJbA#-XkGT|!J_o_1=4B{FeKKaVg*5mMfE83 zTvR?l^Th-Y2MD+@WLDL9GQ`l1;vm4dDbr>>fes^gJS)TpX~srf$(e?R2w%%DUxq@b zE)Oe%+AQDxucuFq-$QM&&K3C5qZxIEJopQpK}Vss`-0CZAQl6 zEm-16^ouw5!?mFPO+f)LHkwhE6HSg?{*7zbAlkqx3r@7qzyynTIm=wj$-XtPnSRtygp+ppq5dln3ESn{DB@=_YROB<>OQ7stKJ0g4^VGvn%kEdhMKIp zP*PG)fDV4jY=LTK_n~nJKmhIi0Ld{trNkH8+bf=&3PX?;3%kg{!QkxZ`f3cmwqg#z zvnmp(n1S!hdUG0xf^l(GH4G3#_0-aeu+H5#U;N+USv^#>68}hS-=LB~d(_`kX8i@- z2@FbFtl4n6b{|E<`*BHzZL)bblxGn^377lh`9W*93#xVJ64Sw>L<%RQFJFbkb21}r zIlTYAB^+-q$$;_+F3p3Fc4W-}gWcb(@?{#F-&Hi@!D^ezibA$eAGAQS|FKzRGuQOn z`#7^`LVT3X*e_S>($08k`!bhCBy)zJ_3QB8ex*$w8ijNB2 zm`#7dl>(;fwht+f?{QS#yC+y82-6FYBxmQxfILHFuh2o#P@x*zMzaC^P%v|VBWkqu z+ei4^LLw9Xq@07z1{YC~hM6L=+d;K@kphUb1wjAX_8-4tt0kJQ^K#GPNmNuvaW=zx(p!(xU`dz5bM?E%U_K<_@9HYz^0+ z5q9%_h?%W+`W0VNY;aZPM*5YwT!0xr>(5dN!5e~iqdvPW1(fybH(Nzq8F-=A&mcH2 z`blm?@!=Jj>CG#n4@advm;~mSKbs`ZDF0baW&h`$5vw!%V#L5~!ZyCj9aW5jcexZC zbktxg`E;Ld@M;Xv>;S1vOC(lPF+RQZ)_|;Fa({ZW( ze?pdcQJUOTVoG`654D|0l5^O#u18cBdhY2m0C}RsJxUASgfhKYzrM*}_@F^J26Cv9 zcEjy+d8*cfn>Q)BwD_h6&=v6*=gw`BJrw@mA$GUQ>)n^8mTJtvbMF%Hd%9tKTovau3YTOno_80DIA}sJ$I`1Y0|dh}R%iGMc!kKJ z%AG0M@%tnlhLkm7*1VgjL`VKeI|?2fX%CNuz-cPgrY2_n9JM%7!N~9`mXVYYHG=jl z%O>4JwTOfi)Q>hzs@1Oq8ne@JP&ZMqu?|XxT@}0(FUdt!KTomJWY~>eN&sWV(RZU| zjM5PsQ`?~Y?@qFhULe9ZvyxSV_hK*;QBMn9!HD-@T_|F_pMvj>D5A_n?H46_KUOU&V6Uh zz7S)>V0CoH-@&@wR;*~+((mHJI`8(Jxp7y#GfrCPHh{NNc*sj8)2y{_`+SbaZ=}eN zDr08X*J@sW)F`5s_x%3{5q+*{ruKvh32rHR-MTCc6E-%Lzlz+M5@c~GUrNzKUI)n|9#@XEn`vl}FEEFrN-Ha!; zs#_%wQC4=Dl*|u+v*LZA5esoAX+=VGG^x{gI3|<5VjW&{6dCa4&^|CAUBrJ>RD?xD zFeOT_M)myk^Y>?d)9_iew1h=OxdV>LFUEg(wrgtMdHIo>jaDW$7JfZ_IB(lDU-K>> zj-rj?QeED{+L|hm^vmk!S{fSA1%PVh*X(ElzCZ-af(j|)M=)%mt5%5QHKl_gIgG?R zu_+~Lsef^1Qm-4Os0~dt%xo#pYGlByUsT$9bqegN3AdGmlc7c@@ z3y}q-C^LH6v>_g|xhs_w75TMZ*);~Pmn9(<$5lbNLyR=FvHHy}*%~dwTND!S1I`mz z^w;y}iTn3Eon8MDvcwc+SvpC+NJGOw#jUV+!lZ2g%+b!ak5;InpJ{&XK55epO?~WB z;3KBLT))}DLHQ5jmN9JyGupUu>O`XhLEXQa%t(J`c6i9t?Y0(WEu44M3iaN)sM1fk zS79miptiQys}}d_?H%7XFaU+i!vbRt0$5uNBDwwRb!X5U0p0;kLR(ABpEm?>#UPkv zmhVFA?4dO9#$xqLt<{82yp6&k_hlGm7o->({U0`RlKF010d}vK7vA=zd_1 zoMw=%P2e(+6<(pymm|E9O<4xEvUPn+2r z_-UamT(+!%=aU)kx`$`Vp7{y&3%3faaEa3$3u*CiZCZ9htldf8l5-VFU;<#Btj3r=cww(O&9t+>uutM~b% zDd0cUeIHO-p#$)4Ws?G+c+aO#L!lphK80W0>LDR7+cza~nPQ`10|=i6IYsJ9=5?O&2zb9F@_a28Zr zuVNR{1$Rt&5sST zoR_Dk?zPU12!?YsVk3Eu#1Q^G<;8HO^FE)~Lv^_A5Zpx4fn@)8rezdV4sjtE19oB%D=Q5p`0h(pGtz&x^r{}Yh(Ys_ zY66@9?%jRa^sBnO=+Okd$$;%6DEjYhGW{1Tc`re*GEH;1YeCWG#&_qPCZLe_^~FX; zI|^bs`zrokSlzo%8m#~~?A4n$ddXH0S78Sh6=BI`I)75IdY};v^XE^Wu*CWDB|y>y z-$G<8L@#i%ym$fHY4aJ860izsf*3jShV$kzK4Kihu{Iy_0`)fv@YAPptH6CwDx{1< z=J@@T{rf%iQ$Xy09=Dk34$_6MflSMwcNP`hZT88@&7F~o!p2%AOkwcg-k%^XCt2ri z+_-V*o+}J%WXn04GF2bAh~a_acr6`*XP%8B)|L^mkT5WQrmUgUVFYzgc$`rcD(ynO zLzTl*e%@)_%9UDsTjbAIKPPCT+}Dw<`{rMvp_1}{a0F-CGd9b6-2S}-V1YE~>})V& zCLNdnV2d#+SyfG~|FS0t5^#Ea^aukTBr)g&+2g`p*(I586&1ymH!};Ed+?4xpa|S) z)LhsSY1GU{0-qVj@e)S@&E5)B#b?h*N^YaF=Hzr_G603*)hpEa-;QG-Fj9oGpn`&e zi$!SwpdJr{>tw;ZO>oHrgi#4r2TJUEQ&jCyokj|{zVxD5|FwEE7+z z8TVh4osItxG+{}JGWridYZ9pRfVdDhun(6odLt?~YWME*xSmALUW!F`nF|62c*fAZ>XgJ=@jnjmN&0=R6?~jk?xD*1apZSe(2;DBYlBcgVxxwePwdF7}^mEi+|)=N)w#mfnZAum?UiL9F%wN2v`{- z84Mrds^~~ZN}6yl7(~HC6jU~}AW%_gtub9$g4Qv8CdkbXXar!lFl6z+;X^QBV}tkP z7OYzbTIcWQ_c!EUB0#vIBz{5?w6eNE@5Y0sW)zr|o}QkNz%|cLuq-BAFxC2V#LOSA z=hN#4C(nG>nDSe^>2CnAcKPeC#gE}D)r^~~lYmSMfeU8rrrY0qcpW=zUUAN)^xMnh zEOMaXfR>vsNc#6I4kPLiT%p|9#^L?$9Sa>6m&p_zKfVrdl$8uC$l4N$PE(T$q1Jq0 zon`H~15Ke`ymk7oq9g~J!DoqxxUqpZv%Y2hzoWoCz{0?M1& zCu#J!jXWmrF=heZ13JREW0=tP_O}Sva3_v;IJYrnRw~1bglaO=7 zJey_9-L^bJ-mHpB1}90ob*)qhQpBltHQZVN^aL z$LYA5va+(-9R9wW`m)b6%isDF;sHxZ-9md1MdtNqdpCOiw-scw6-X9Z71fVRyk6;Y z*iEdQ@p{nWB;{~4p#r${C=@&Rs-M$yC2x!(JV7}q(31<_ORx%&yveg*S#Mn=q`hLwQB zR{EZ9*rUFak=E-^^5?NX;3fR#;pJN z{RpK7`9SSK%HdS6B4Sg5i*pwacojzKPG;A>XcXDOOTjhZzwCa9F23e7lTNInm!1~lDz z?X&wW4+`QDNI?T6iJZ7qRW;=C12^Jp*bDC8k5Io#S}Ib{nB?S0^{dQ2gaQmC9gS~f zU7vyS-M`L@(WbMPLTDBkIDjkP@U_7;#fPF3p(ZMd+`AC-Pg?F37LoBKVb* zs@ymuksu#eH9Nb8%#1U=R*Q3GLap()h@1^Z3vRH#5`E5!LgV+?(z%FXf`}Sd6f)rF zV1rGYrA_NG%!N)^A(F(>DtFwLGMj!Lr{t-*#W0N>6`Go!imxgxje^(V_Qvm-$WV^y zsDIJ2D+3Ycy7EO*6O?vQywrMyHO*NX(nQ}xk5cbFJXuCG+=IEz$b)v9fZW=)c{sc8 z9sbjSm>3gbGXt&~BohYztLnxL+-ig{d%8;ua_#NoXOEoA)W^)(I(PEPPvnz+hv$I+ zuClF>jS9yc=^3s{y9Ny$*z5CHA^PTkjW+q65erxRFFaFsscgE|h!L)`w=@vPLc>_K z3JtXI#eiy28Mia|#+?`V5!fzjcGkwmO}T)O{O*V6)sG8Y%fYOUIbRZ-SJ|I9uD%6c zJpFjvvct98KGiPy#}Jq^6fjTtZ%lE%;-8vte~8yqh+NO03&4@~0v;F0Eq#MK8zKKD zOh;%P05%!i5c5|?F^+Jwf#^U@rx93k_vOP= zYXHIE#9xJ60qLCski?NQcnGn;w_|+^tAuHlp2}OuvZ@WbMMn4ZcG&06UvDjhU4r6s? z*$3YGo=d~+T=!LmsPAle8@^&WP)@>Gth#Cnv0MD4b8kGYz&}y%Kklq3gx<;zEV}C> zpn6fqd{trBF@rgRLu7&Ubn_-TGuxD#O0v=>o;oKD<)pwQ(O-*|N#OP66s&hP&5oymp62nWvgh{ zbM=LG zwTNbt4GLlL_m10LvSnkD5!Q8^qKFrUZz~q zj$-a!aORAGmR9eyQfgOx2allFIC{Eq!-tWX1&MQQr6tl0zwr60xAJPJ&Q38veLXu zqKZgi_;BX5M;DJ34E(~-&VCEctkstnadtt0oTh)T{yMS8ffwt&!;M_)+-4nKP z(fpY(Hiaj^8Dy(SkYc7i6u_7=ATiF+bB}JhPvXcbRe_UJR1bn>*Ymhp8u*^6Edfyf z1CBj}dOULE6YduN3^hPJZ1O_Jc+y}kc@fCloSH<=r*6+s`d_4OcGM?Np8DeA35=MU z+VS`G2^{^=$gmALFTq|)92stZ{6EEl#EzKPzfBBiVR5a}Tk7Q02z&(zSvYVoyTBI@ zp$?`%Ou=4#`Uc4gnwszhvQff90DF2(vC5R?enZ1KB5|Zcu%&yKl$1mhM}vu>xeM-f z93_Sv0&LqxfI%RByk@gO=Y!S9G1CxYQ!(n}XU@}ZKm_L?qJTx2j%y~+?qgSFauL>g z_E_ubDI61YG>PMv`9HlH1B*wj#2k=nh1W1HZ}#T z@9SbgvUssap#v`+mzsKkl}nd5e1^X_e^F4^F-m&S(7=bOYH0)c8#G`5=S>^Vg~Bw9 zkX1RAExVsG#)#=UV1jA%KX_!-bMjNZ{hPGhGTO$qkW$PMNk1WsWx2nLk2!AQLsJEU zFdj!vcB$+8rGC=osJ&9Hp981DeMc9)XxXwYEEC480y+qB9_j>?bYCJ3{u@K>a8+Kv z8fs<0P3d*#GlsaWKb+kYnT{)Q)IqvozLl+?XQ=Ltd2+?(ireXiDJnO={JHMmx{_1K zM|LNFeaD`%Wbv7hwy`j+A8ekL?%Idy4=-gN9=AnMbtWa-D2DarVPGO+pgQXQVHaS$ z9aHe8J9^5cpRVX8e#-i|;>+(Y#7=NHvR$TT%!l(C# z-{veuRx#?)o|DqOZ@KilmylMVBs2UWM~il0XK~Xk>g}c4g+9J7BnqT=ZBM*D=&XzT z`-}m<6fezG{Ow;l7+ViP_X(D;(8xb)!0P`UM19_U+eGt6#8LvPLpEvI`noFuN^o6! z#5RdNY8+ajEmvk3|5wA+j8K*Zonzd!?C!)D5@xn~@*=dE$be5b41+W+R?e{-1C_%U zNp;;@f9=T>@^TTQG&PB%r<;&80lmN|2Wg~V31+;xxs~pdD*pJxAoUiUU@G1i3q(i3 z>g>8gP&9HTwE+WmxH>>AgH#V+eRB|AW#LAEL~kW=w6g;a3I)* z%IH(c#b8>Icpdr=@PMFHd;z}%;T9(xRQ>Yu5dn&3z!nq(>())6L1=15HT3H3Tj~({ zYHbu?cCzIt-*Nb=e(qN2(CzK@a{XCAvE%pYl!(payQp&KuW(Em4qpdLPv(%XDkhLv zi|gv%T6>z0fr%kCQjO=4#jgWq769@7%fTiT!DRjVkL3}9?tnHI>qT;Gpl34H08@4Z zmU`8*v_MkPta8S{uHO17sYyv9g*BysUtRb=q9(#mN8w83f7R9b9yCls=mRy}PUU2wSs^_Vkf z4wW^?4z4}s*;UomgGG{%!=O8W;81`=SQenNNxu-cxnTSDu6y|l`Og4q*W9~5^J=bj zyc*vSno%Zq2+h%^LsiDLXT$X6uC61X{=aYP8B&%s(JkCOd)1mX^DQih3SyUsXAilZ z{f@U|o!wUN;B#Yg#r5F9+Ry+I_9?>(q8cFL(rf7?d}}J}rJFc|i#%v2xR3%wrKL6g z`RDJ81fqac=c1 zIS<#HjSJZ3;6W5ygA^5U(&LW9C+Ch+U@>xtDFZ0MmPHWhkT}DxFVOU_vP4>La8EWF zHd0Q6n!-c1>+vfM2;kHL%!b6zF{T}bBkO_kW<@0> z9%I%fS>}9HZr`l;037r-{rmRCjyZs3;C;TYj0~_gV9@4s6QbG{TP(IrGP`kM#PuJ6vjJn8w|9LngA87-JU}X!Qy&1BQqd^Z|3@=l$ z_`*mCON>k#fJOB~(Ni2g2Mg1o8c$k72P%B=*=dUB@4v?Hk8v$_?B?0*69v*jQ7K#g zaq|V@7 z@HD8Wum1S^Yhd)#Th-MI=FJ<`@d$Yzj%}QFUl$S!-|Yy{xovfqc7_~-LCv@-0v7NoCx}@@_6|FBzF&$r8^HCtZJb`GqEK z>6&rlmHKuMe_nq&aMR=VmmQm|vHyG;Hc=Mgl=@;K>G`M)Z%;K~P!$aW;H^IgzLJvp z$QUSDdc7#B$;#bDLQ7u*Odu0Iu_sXVqJGv_Gl@gS~ zxbh-QY8;GF2er`T)A+lGlu^MjHskld9=@YM{KfqIZtSX0gP*+riKS4oDQPJB^;5Xf zIV0m80=6>X&{Me?(7N2ookDMn(ymDK=P+4^@;oEkoIiEq#NTQs+V=&!*0HxPNS*%6=>`-*pehU$I%ZCW7TAqYL3dEM zkN=ndB8W?Z9LD|5C_hGf;zVEBZ=p=*I3w7lm?SW_#@YDVwQJ0=I3#DBZs;JvDCOo~ zXhGQff^OOH0jRf;1Cq?cvH6LzexmYj_74EXC5soII(ZU5WnY+KLW%G9%yQPOa`r1N zt0W(0GpdyWbqfaodPC+I=no&l75j&!3$(?!iFO$q{*T`~5Iz0|N{(MOEH`+>e`9}l z)ak-E2yB$oSHNUQuBASQ#sb9*vNG6IN_x68rdW_)Z{IGU;HL=K&Q^rW6gL>%GRu*J z0sMz!k7E7-BN6KFWhCp?*9!(O`YBtV{Lu&78D4}qVyJCw*TGNi@MPo~;8MVF-|Jcj zVbBOqEuz_Q1%oWjt5K}uLx8xb6}AGmh--jC#A&^A?_RJcf@ja-)<}~}8?}|mI=z4Z z=dv+!&ABz60*wrYDOJbKn*{ouA^CvdTPTUYGpXXn71f{jZ6ROfSK5%!&``c0HhK8$ zYyP3%{X`qXFdiccF_Z;5B?0pc6qslefgOAdfM4%L1&It&Zo&k6{i$1MgjJDrkFZ`dvnyZ4A zd6~B23T3JQAV?6Q`r+K>_0t(Z1O^(are6+q-(d`u30yc1erK{~T%=&_2@sWIuY-o% zSe=AvxXb3*Jf;SjKo&GZu(E*7)#Y(|ji!;n+`(a-lD#Gn0QOhvBC9wOcK*@VU(;w# zA|(Xi8jxqhD|;psu62~&jJ4TC*8kD$ld<1GUth^O799*=)Oq+&H1cwl-C(!DT=0Ei zNPE|-*vGGLZY8y{b#DLu{iy)=$qu*tW5l3tV2PQn!CX11{!^;O?hJ~JM{6?8_tX>I z-|~(TuHo(n8O36>uYsy+B^+Z&`q~)gQ&x4;0+p)pjpKqipi*NsPs3$A$T$#r(U z+4^;f{gOZ1k8aA!TcP7|sE3KU*`6myYe6QqO zd&%eDw%&SFT{H#Mqj!UuT*N?`Fr-Tm$-o`Y%hYb>2uQpR235KlU8c==l3|#!e7OjJ zqV;n`xhn@X{PAX*ieA@r@AZ?GTcf8kCFQ2U-U!nXjC-0VqSP7cC}(hz_D;D3uSZ}+ z?L#%58B-(5k=4+aUS~|}s?2I(!@cU#(9$+L+jdvQNJSYGjl?CtT#q72A+pD%jX7<% zQ>xsvYCL^HO-dx5EQ0ABIh%tfq>Oxrf>u5rR);xb;T{GIFBgZDkw$#ExqxH*7sJ3Y zMfIwOwG1cjTx5H|VE3V{lk6){`Xx;)Vp;Ii2MUovXFDJ{U2rWA*J}OB&I7#exo#a# zy%5GebGy;LO6X+(-vBo7X!;7`6(3h5_zT)DU|9_K|DAwEjzE;(kXp(7ZL2>!9X2bO z0foFMI76jk(TbfT!j*-8ILnHH4ZvT(`PtLYGwtY8*9WQLHy{f%zQEql6y(>~<@^%x z3*<4A!UT=Ec+9sL`~YVwZ)LsCjm=iEDSVyR$a8mIWk_uhfYLgasrt^sM8^{O7WDl-9_}gVohJ5N4cgtgXnX zx-#JM#6RR`$?}i#3DVsei%fCU)Y8+^jCyKy$}c8=4z?sMjBwBZrO=@Kc)M=<(7}U0 zV;#VIZH4{LHzdU8akLe2*I_R>e}vMEyd(U>gGvA&Q+d z1|P?cf8yr1v|d2diWNmREtJ4UhChLLAHGzgK&NJa195=gpZd?7VVu%yxMui`2@&f8 z9*C@oW#hyOsZRR|`HcZ{m0GW@Fw#KO=csM9cXT`tP|MdoY?_}ttV)JI&fC8J0{3Cv z_U{cG9#|AiAhI00gEP!QghjOZ(<@=LVz}uR1Dn10B{Yd^3<;wqaQ;P|q<@V)t#m@R@pyOWJqm?%l^+A(ueNVLA=A1B`N#<*{|U z0L2?oCXjHn#@DjmYI*jD78rdM##0Pm;Kcu60wfqJK``t1bbR|1l|8(y6V~XwEMkIo zzI6CyTWKK}{xBT>%1402z#Uv3IU5UyA7<+Ef=EHoHvrllT67rt-Fir($R3DdML7GM zo}ZpNZfkj`j(kI(1uCQgUwybEdaJs8k4J`Ae7 zk5{qLqVxry%-B_aJ?^Oofja%GY4mZ4BMBT~3mt}buPxyp;x=`W#GN3hWVK$YL6*~e zrrEfJ=d550l(_>5*UZ*pTey6@S5sR6TwQf}UR^odWVcM4&W~6x9B?wpcQv2#{(A>3 z+e3FG`!ylFAGoutF*v~m#WA2yw*PrbAW%%N}=N*!lbfULo&&Q(8ArmBu<53%b z6yN#q{?~CcHm~TuFFZkcH{6tYSRok@=|l)$Y5|Mv?_)vBWoPydF#$wuIfHMHew_Wm zDO_8h;fiR*)2r2zvkRR8-I>wqI|3wv{|C)G3?qQ`_BbbI|D7eFRh-K93!d)Ae*y5|$aZG-B9 zEvKc}DNm`W5X-m?4$JRlbB+xyZp~Fi5?bWnEjTrzCCEA#CaQ1A!z%r!Gkf`87U~s- zM^{?fw!IoFF%>8M-*a-%V^JqW&JHk4>o!whnxHPSF&wn3!YG|N9WW7uw8OPBRpINW zFF$BEO;rv_WgE;uegeY^$lMB%OpGo#Ay_p~m3#V;Rtb)mq8ZF#a&ttI#yzCV4nQ-A z$~bJJ4Ib|>4*CTyQX;9o3ji9$!&CigPL? zykNd}U>1+zPlBbS2|ls3{^uS^>`+&g16<47^3?wv42158yNr=|H1-Kb@C6i`v0CaF z=akZ}Fl<;4z?L}SFwVvlacYLPWeF5n8rdvIM_tw%n)DLKV~App-#=`x!-)%+)lI&g zjfm=Ct(TP9#A^X5H(3o9u~wFreg>*>TdO<&9?;TffvS01=yN7G=&I3JbMD&f;CDKC z(j*!e*yDn?onTH@wS{P^?;p~;9zJ-0B_iPV2W-iRq=SS9rvHT<*I;jT%G6e3b(ce+ zWhcO5=xQ|tXbNip_Ju9Lkev-yw`Eo7`pC!;l@_9 zcLw#N+6@poa3F!aTC<*vbrROr6=Y^)xSZ&hoJIYLsTmu|LamXxX%}HxK(InO8E|6! zfwP`#)?6T@35l@xEb|cS+zAkTu_653_q}#$7LtBex37((;}50}984_Mg^C0r!^)+C z7Z$k*d@aT-48*6@hyPgFWY9@8&9?UXl}x#}03m4_5BUhn6zw6f?{M5HUJCpMq699= zf6-59E0VOMxT}JZ0=0Z;4Im5Caf){4`m)lqbQ6Cy_$@Y;*g47_n!FQ5MGUFHzL>}3 z;|WtdSRKp?IRFbBjBx7I!FqW)cB{O+USTq!F0ZYlGg4$qQCU$zKh9Qjba4umaB?y@ z21qZcKL zYruaK+4M6%{gmZoTWmhYR?p|~Dt-WY)@nUv@!VKmdWW%#kB^vcZo&lYmXHyOouE{7 zbP@(8Y4X$$b0tci>1UXlje>sXXbXlUFJehDL_jl1NvxCLVt7WdpvcKVzY$U1{PJ!t zmR0ET=>KeNnC|k}V+MdR9+4@PEtnzmL7`?p*7}~-F?!UMfobjx?3U;xVC+|X@+59~ zZ(wvd6?ybimFgoI%t5QwD)aQg07;5bvYp2%F$^L_Y*>uMn9-_oLNHNr@rI`>QG8JW zBt}OYS3FS;2UcF#*NI@GRjbC_8xrxDLlSoeTt5yCv>9bA9}0ixN{c~bef=g#-(S$H z!gs)9GJAb9`592a=vU3#N6CxW)Evg8Ju!5}O%&@qN(fV^({P5c@-_#W^5m$BN)~#(1>c1}uv)y$${xVHBrNpzk zx}Ri}!|@zTqqsTIZ%A*XZ+L%x`FZ!Sy)A5XWiD|1xqj+S;1A8XpMeEf&_a)!o$W@v z7bV<7b`4v_t>h*HT?s;F3IIR>!Lx!FrPkoAXC&rV5(q8=xrDa=>a}Z!^7Bh5R%rVv zub7<*;Q=(lg6$&W>-_vkjVfSp@CD}A$H+y5SI@&@b4kb)qkO}Y?p2@kncFY&!@vJ7 zqy^G_Z|A8(1kEYYf?79JU7 zIlvtP&EN;Vp&;C{dGnt*c{3w<`(TQGicocNS;GC`CUHOTyCi|j8Px-C!S0I41u!Qn z>jk79j~hw0xTE0!37&JWwsz5yB{Na_fzN_xz`-j_eJ`ngYG9gPw8qO1Ur`Zba28Q+ zGf?>&ybk?Wi(bVA9m<*=n^W1+^X5ii&GI4v}eCv+SBH>}R8erSPhshBqzZAM@ms zd#pls$FSDNpmY#_*|ImxHc68pRc3YQ-E!LO*I~c$bVJ5e=A>5$rY3n{qtwaSw)V&G zhtP{wwq!a&$c9#MUR)_Aa1`HgF_ys#j|J&imiGSLk%-eVONtOEz%W3f zXn#EI)tcI?XW-qS>gYCzG72dxZT5i+V{1Dg@j5z2<6|5yZ1N0G#q;6oVHZQNl=>EQ zpjdtXe()gR4idQHrL|rgR<6Xi8>;;Mm+N_eOT7S=pMUr&lrH!$4clX07LYWDX-7sq zCyt9Q?mTcA!2VVg*11o@>V+(6$dYu>0lgUHxMuw!_KupP(d?tFb7+?TP4|=!>q1RO z;Ibh<+dwrfc!FWBNGzlt5&tw{!n#))vzUISS`Ut#oz~vgRg6V@(~Olm=29<;f`g)EE893|2(P?uI39v#t3g! zArkwq7>zzdZW-+5+=|wiCKfk+_=-UXgexvmTMmW;cix7-qZn4+Omj-@`;dv}0{hz5Az}k~mQ5x*jH44025tE`T*@e24eSKIQOe^V z9vCBbzm;DJ7mWc&`hf%Aij-%lRxY%&a~QXnZ+Y$7carXN%8&ic9b(Fc^mD@b_oiU# zlmJ+Ul()3;iPRNka15NRr-u>*0}@+AecUaOY>EO#lo0;SvTOJYbPQ_Sz6hl_I0ZWg z!5(;v*Tb8oO#tt74rrFTs>)cg5yy0@d$i|h00f91--5b2Ebw1(FSyr)5<}BrY|6PT zxSb&iJbikqo}MA$O`LY*ZyrGec6u!*1#?GGs3VjDBo=vk=J9!s9%aZ4s=u_zV~>qC zR3`jD8^DiXH^Y^HEX%cm!aU+)7A+bbR|R(`!nF=ADna)EV32~4E%Kg=oSlWJOi(Z( z&;vsY>V6;}`T^Wyp!xF9&}-1B2x1z%&Ah!4*36wZZ^rgc!@02lCq%#_K%h9~Z406!7fJRzq@Q@s2SVw8ZlgDI|qn=?gG}%v#H7E#KqkxWB1yM#Yz~r9d zwgMr7NjsP6Sh&IrpJk>}G*r{-r@on>>L{1{b@4K9EyGn5Weia zli*-tCn^wLO&^wOy>WUf!@|S0hzz0iVI79iG!T-H!9&7@E?gch8mTM`lO_6c)V_Ta zw6*ERnUJAx$QGEaGGR@R5SSqcVuu9669u!P_uce}(}-;OvT&2jlb$8T{2`B)%MW|w zz`*m&^&}-0Z0Xx^sE1pnM-eQm+*@^-+B(7*P32)1tNfmn#wq9@f^plc9Ji~_{B#rN z#k#+#*&^%GFWAgPGj9H=X@&4N zvQ9Q}vdSJDNl%?xtdl^FUr1SWe7vMYjmBJr=-D-SHndqf053kO2(IBe5~1|g-%Xhm znz{0!lp5fn`5#$g@Fxx(vg9QsdZNFGv5=QUHp>x%#X!O}%3$pLF=C9IjX!|HxLY@F zgxZL;w7BQ_wXXyQz5RpkU}h(tnPe;Jii7lnlqsWI!CvMo;l*7K{AkJde^R8P_tt1{xh*+}CQ5 zq)ApyUU~CvFT$Y*tMphX)!3t#mSn)?fj*1Bxf$1Z?>5h-UGx66vmXXNwl>?8a`NZ) zEO^npKW(}bd>O^VUauUcNcD`X(yrMtH=<%iPw4}|KqZdChAri3Wt>xq%{_9-piyihMkJjd%NnE%x7*jaonw%%UjggDelAT;9=_6@w=3II;%s14t=Za}S zT#IdY~ zn{%HM_kH|mUsIs3|8jv!&?dpK~}6>MX;HN>9;$VB=3;j4Ww zo+5b>ipq=ws(QWJUd7zZ5V(R<^cj&*Fj-rpULO-zMN~PFSGa8sS5YyQe@anJl~vx1 z!he2SsyJ|tO;C<>-^w-$yxX56G)iH$M4q%%moIQQV!Id!Q__T<HF_96)UT5 z^aT!KKjwqq^gxzxoo-89^zfR?`e8NK`>Cnt=kmM&W+ zm|u3sf23NYHq_r^jyj#Dj{?M7{~UH+$TB(bGh&32G*;u>xpTyPG1f-SyKEW#-m)SO z!pH&5Zn9M^SU~rIBKE`yOs7ttJSi!$11Tg0@q-5kqN58|RNxTne!2k%Rf|}LL&P_6 zc86Xk-Ua|}%Y{ZNH0~~A6|llsjS>WuBBq}2`%XA-EI*q>1)?vJ$aPQij^yPrx8itH z4yVb5-bciqQM&W;?ia&k<1viI=vD=z;K6KzbB< z@|sj%C6Y0G@DUt8H4`!7lxG=96F@qBek#c@Ude&@&ZnX zL7JXQ>H*8|mozjqHU41V3I_?GnHOe-EI^@LrD{FBrokVEFns`?K)Kgc>00moxlwSk zKL0^3Z?L)uQGx5MUFti{vojCuxOW$qPQ0P#$7<+-;AOsmKnnoi5%jNMx2 z6O?`+H^RH;EaFr1*^P{hnDt*7xJ{AWJMns$*^aYSkJf&MJu>xiAUUse%q%v|FP#V> zI2g;DOQZDbtq)|uXn>Yf-i*^njMJ+ZFARSDYj>5qrG-TR(<#caX)(QbmO2ezT^r9x zf-jZrl1Im&ZGpA*Up@xR0tJ65!g81|o%!db;^I%V30x%L<4vS&v@O)qae(0bjDload&4>$ zTq%ZuGcV#PC5#b?4WTAQaQ(i1W%`gkS6~n^maI1VK5pvNjUeiR5fmx};;f)0Zh(Fd zkMCW>=?TPqK#_me7Vxh!i)9E}BoXy8Cv@bO?tI$dhe9{)s-uk%J|J+PU zYBpoq8ew8e{>EbjV%!1#?s~2mxx-jp-FLj~d`rvCxQFuqen)CWh1^!3^_l{Ug8{en{$dayg5CrREhM4e5{`+4|O z!o2lz-wA?+83{0ut|+mAH6Y%zkq7eDXy93}+cDSm(z{{VG*(4u>5{a6@M`Am2~rE~8_W@($q zD~B^kI;1;bZ;N&m>`Sdy_HxtqzEZDjl)R>x><1RAM*3~4#@xD~C@ zdpo(WkI%2Z=10@UNUGoV6A>?bgIYyHCf#$vKNHYKtZZz^j`dTmL8tT2Qhz@h82B=M z04_}3(y!+q_I!-Rh3erpu>7L>4D-vOKTAa}ayuI3s^~JQkEDd+m|iCG2x;9S)OS+J z8>kMnNpsg|Qk-y&(-qdWbVy>he4h_R&OX>!<$oF4l{d2yEJG`_m7z3 zrT53{PkTScVv!;6+U3f{%I6{<_92oAG1DINIX_SNrRQWr6M1n+m}zGEw5E}r%MZs;1+|ElG8SFS!3ZlFig9Rd;D!pl|A@F z7hb@)E@@3^03^VE1T<`zCUPF}G+ZqxwfB{MuVs=(Lxr!Cj;^zk53OurjAy^jrv!1} z>4wZgaIno6;@!#u-Vd@DOD!pVCRCr#Mlr?}7RU}``N-LLm#)ztnsU?J7AIL-Nd?yN z)8%E3y=H#z*j7|;`0nHMNhjvm-XqseXR&ngy{6~gHYPZ5-N+O_+I?gl`aNhhutYcY zGo_P5s{xIrVp+I{@j+vG$-fNnBXOU^J9us!A(DviFCPd0DkEoR{j84$r5h#frpl5d z*Ykp8R4ZhgZcC!C6CX~F)o}fFUaVjMG^x2Vtlpb8$>vFGH{xKUXlA?qX^3>iI-H`+ za*z}<#G!S?0j1J$tg76sj2Rv5f*4fYpznLK(ipcYnvvnb{PU|_ ztOiv>!&{_=Y|;S%b&! zO;5^A^l7c1;g`W)~(OXNt5*M=RgUGyCyZdPr_4Jl*Q5+(}I{DzSI&5z`6|t0Z`OmVWxY! zVSb6kZm5+_b}w$eT#qaaQ!+zCt0DbO#=Y=HVWYH*g7?Z<3FXTK6kV;&-W|~hWv@7| z;{CuK>Y})M6@e`QyO2~NqHr0`F@9q| z_MDN}1IzqD83B(jZ=6x?-MOF2pML-tVzxa(6^{crsPuvd&TKMtLIlRy)=l8KE$g=} z<3=An07;~?xqZEF|HlOwr?jx+kIG7Xk$W!kW+=l9WtMynwjfkH9!1IBV}D#1tbK1S zFi>SDR1PN#vD{^YzrO%>&@lVRHn#;pMwu@^8(xfwN!euQtF51>PMwNR@hDMjTAC9k zCP_;NNSbg9uiBlC3F;^MtP?QzaIMp&Z8#4!hE zin=;a{gfT1m;;=s%$XEbu_Ea%`=zPrWvc%ul7Ltm4vH{rNCw6?3CxJfPW|vzkD}$5 zw*90kw`9?xj-=euxBeuvnc-E(cMgT__cCA`3B!r}QP^4gWjC?V3 zYK+Cnt=}=V*bK;s&GN+L8=&FSQ#&CUn@=pPm`7D&%zQf`8|71O@KV(8zmUyMeH$4wR4a*7DtmP-e* zMyNPoCSs+Mdl%_msQS)7|6I(ZZcT&!wJ$hQLOp;UOvp1#bLANLSv9QCDN~p!^M|O& z_(QUQ_a`QzIL<3oC|?i}(J^a;?5?+=TK#B#wV=l`_dSR>yiSZTg{t z7PNG_i8yCrgW^&EOy%Z==rfe2MW|s1RkqiiU(34@My?5C4$PzC<3HYLoocN4k*5o6a_rc{ z%rr>zuxEs2+0tT%Go`g{nz8gt*vZKeS_N6jk*phj9f1!$k}Y2pjm3RM>0K zG0J2mlj!bOcu@IKy02Ps*8Ed(zia!bvVCV1_i^GGJn_xS+T6G9jyy|)zLUG1kY zeQIy-q&nWmQoz814Oh_YK6tR1-VZ*`Dh2|y$ijW=trlqGD9tRj9GK;%#QpMC;Yf*fms{Swt@m3?ZS>;y)z^@U^`pXx{{KUzY6@qsZ)i^;ZzYW zN8lGupWgZUQs?1}j3z$7rMa;`Zm!#wZLfnJgi!61hbn|_@Xh0~*Tq^BIy8jStj6&2 zX2JiC;XR%nvzRUk_Y&vbBeZ<^&ub-e1%34FpHKKglYvb7`=YOP{5 zqOznzTpzx95mQwiojmza`<<&Ny-=b|O3pjtVY36;m%aabWWW!6)x-L)9`WL@eK*d9 zPoJgOI#}@0!GU1TTU~9r$?kK=p&rv|t$fii4>iV=J_IogX?Kna6lpYN?vlu zbT#d$y}xO=DNBLZ$%MJs;^CJO(^JFPv&UUcjpUhsJ#3yS@nwqmn|2hAYn2w_%a`ZG z=G1$qJ(<#1a{z`@e@BmbwWrpLNQO~~=c$iBf8VY#wYTUu@tSWPot4Lbp~|#KTQGFW zd?g>%2%oDhZ4mDI1Zc@7_Bw{z3+8&p+@3Y5k6U?oFnhu;Y@~#=*8jsGMGnF8HngjE~Ya6ZCpCWEdR0 z`x4#DZ9GHEo@GpZ`*gq+O+@(P9n+f-49hkw;f2Y?;G6<`aPBtm;m+O{_64p zyW2|Tdi-_o%(0+G?RR?j+=CmnSK3{fC8uv9&sXMI8{cN{mR>!Tu<30*E#xClt=l|N zU~&+z7?5fa`xN3=R2G90n_mVDZ_#S?dfKa()Z;6APHi<(8@IIdfX}%{*(xr|c%&Xk zPlt0cOm2>|vs(0YsuB2S8A^@-KFBZOR-AhTc{;QTCd0y^%abkv4x&4RJbw2jOp;9V z>@u;{$e5?kpL4heG|f5jGDxN8DIv(gI_b@b&8nzQ3{=B2`blF4PUbd~oPbMZ?x0YU zi%y&n1qYn^mL+LothcVvA#VU)9KomG-MjuZrpL>~7_d|&8`Efob+hD|USsgb8Hp(D z_ANN?T$i^#i*Dx7n?ucP^L`gK2N1)?2TH~yB^kWSSNe@WFTDb< z?q*o4Z^1^12{9VU2?7{~zP7$eoO7dK{y2aON-Y=!&|#2Vv6IFn1q?=hceVL^4sNJuwvZ1)HWJ6{@~ z0|#UR{jRFNe@44872hJ8b4$MsJ~Zjh zLbn;sbISpp1)e{#6?b1^I0`oc^z|*%>1H-^`LLOrmc-xc&D%xJ#y;=i8&AHmx!3KB zY$M(&L~4MeLHp~1Qik-{WaU2fo!m>#4SaC{I}05Q-LC9L7CScK8bSk}`e1b$>^E*S zq_am7G-6?4fpmSQ-_xCT`G%W6YVZ6`{p-)l%d z!|@4U9hmP1R%PD@kkqCqgZB&_&N$=m1KurqZ$}dcUy{ybuj;f(q)K=cEji-QMqMyi zQISV-X38tOdGoIGlIPBzb(tEL^@3jE$F?r2la)7;CZ4)b{XE3tCuX%mafaMW$C4x~ z$miB&@awt|1rX;s)Fc`P=@RFy#pL23zpj_8=5lyRC~ugN2CLgxPgaOTBvXi)ZPvEk zCuAJ@*yZc(AJ(BAq$320SX=M4(i|lksjGV|C+8{LIc`9tIfdwYKx&TuILm|8`;|z! z6T*-?e{9OL<;z)m)Cjv&+%Ea3mCJ`9$?CRJhqqcdr_~moH7=KssmG7+cV0tj7h59L zZ@|YF|HzHdf1IPLVK%XHp1tPW6BjRb0&24P_$a>fF~DkgMA?RinUR9KXh8g;h3H(2 zhn=Ae=PTFg)b zK(Hp^LO}Rp4x?Jh4M~WPKe@7cIL0;3&dzprCs_T6g&Dn)<#na95~q_8+_PxEJc>%F z#_6l!MB-tH#1q#S))pKFQV9@-pnwx}F$)$vhB%2C0`CrOg1CXl|Bt6P52$f%-@hxB zN-9Z05|Sh&Ns=a0?4(GNG)dYCA*n>Ol&B;TDuvidk|a|RDj^|>L@JpnW2WBE-Shpu z{&)t~aIdwl`?}8aIFA8pLPNtv=6hpPHepN|X7=gEpfz|e(Cwn%g~Y&1QX%R%oH84h z*l=!bkMedj$bfh}fPpa&ptyxZRh>E!(&igJoJ>^a`SSzK6VTF*(9nR`$aI_sLs_@1 zKAD&2a>k28;(Xv|&4?=jIJBIwUx{3ujAFPtd`y@s7z32{)FgBJ9RB23Bjh=>f6*`RkH+ggg~1?O3LEJ)tzq@a{0!H zT%sjpt)V|q$ib-Q-rw}{A0%>&pkF7dOTG9S#9eCkucuR&js4X3W4`2wRouIJNyb?$ zUlm-bZ5;g1^NZ3uwc%`ExUghwN?8aOK^<|>+JzGK+_b)O(X$r!D?1nZ8oNQ?zx}a` zQBw+xv7>{D3KQh6W1I<}DmHYLBsm4qR3K6J*`3u3%np=)r7<|x5lbsjK4E9#So{+A8c>8wr zxN)RJ;apsfF9CHwDT+VnQIa$kJ33;yiB#nD>C@!1;|}%!PbIwdcwM~aX6M!6-Ai;1 z{o|hUW`xq90%>W2``xVrlMC?5fC*fGdIZcb=*ePXt{^Vr<`CK2+S-VbY^Ecm41=b0 zkY_MyA`X=DjPT{-cJRFTdGL6F?1$D690ov!zX$4}Uo>S3H+|T?i7S<3Gr1+%ixGp- zt)w}P6&e|WK_F|x;>Qpi!yxEQfOd>~;634FN(Y1$Fnb4HYp^IeWf{1TfWcQpDkUZ+ zEHfSq?}{A*Tu39Sl5l3Cj|FteI6yt6YPnuLcT4NKK<>K@8@@8IzLRdcrqGcZk^vmQ zw@egNB0P|pB=gOYL&Y}e8f+E3wp+QR$%Cx3DJ>Z%y!Qtm(RxHX56+r?aY$^bWaSKu z+??KjO*Eba>|En@Y|KMTtcw!$m#LPM<2mO@W@97;|E%`b(COkg;$Kvm@6t8?hETWR zpRz@vo>1^k)Ov^Yb=OrnRxk5Pe|NA{YwU_1caLaE4wk@^G;r=RQOuuu>s>x~W>gbSaoEOrjA=;kA9^yz?a?vOa1qH)m+^g)=X@PLLUPoL@liHf zUyk+by)AWFZt7_fZ>@?e#@>3JB@+GIEUsuc{BXTW<<1?lx@eieho%x#`j;6Gzk?TB zOH5gl$Z}wOi}BX#f6dl_c2~Fc6carrD_(W1yg4k?Krse?B&j(OSJXA`q1siN0oC+D z@2JLOYc*yo4zofpQs@|_bqG@QIvZv_nd2yt2D~H=Lr*O>2^Q&IEA?TS;j0ujXTM^Ha(lqVa{c{COMb&v!FT0qpzd!?d=%K9f%TS|V%Epx zIb%60CP;k8HJp(@%%3mT>MJ2;&eC@{Pi!{{=(Gt}Tz~I%-_=*daPW}j+WT*(aX-Mu z8!x*(KEC?S9kpL$cnnd((PcWyqfJdojoC5xa@6@?7=iGYd>mX09WmjAa>sB4l~1kdxoaMJ&_~T`0k*3B z`%l7O-!>*S{{#3kt-f7>lLqN^)$a}lhTdBQwWoCbo@#A*KC*uAex$L zbTiCwCle4nWSO{Ke6e;>x|hBYCf3lFcg&oy=Rb^32*kE^cE-d__sx+J7xlMK4T|q+ zWmB>D$MkNg4U{Ui_>}Z?`Emcw+H%)JPqhDT>+C9z)4<(pi*CYL8k<63Zv50pSWi?Z zM{2y-aQ8MMa1_}>ccO^jZ3x+vvbB(AU~+? z*xpH-o;9ndZv%pagVy85j>S=qmxU7#M#lG(l@-DEY;PZaI>SzT#O%{>NEM`R;b~ai zw$aZ|K|CM4iS)*r8qr$)elilXcd@R3th2HZ>F6vztpSCEEZXbWArP`a0gIfA(RH`m2*z*y5a`XJ(j~sZr-)5pUicTQMWGLH~6IUSN}Bm22c)VNm^V(1h6E>0Jj7`%u$&oygy3W2s-h>9drppy=Ko8neUCRioIape*3UXxV6`O1|9thiSnd zAaNb#s+D<{;ON36T8SeCG#h-;DCtg~KOY2a&i&%EdbQw9&Di1c?~Z@e;=jXj!j)tT zRy@g*oA2M7B{RdSl>r{s8qOKT6y!1pnqpCRhs_o#?MHgA(d}uTtZ%m z20c|jJo%=hx4h}SeoE@~GjnQ@Dw#`!uibbx!Df18`p)U<3OKUEN^NeBbDT9QC&RV0 zd)C_a*-d4p!nH>|R~)W^~{%qWPC7S>C zdy^tEe#L{`zqE4PRiqu9d{u{BI2U(VZ^uD{gVxzZ$*HJ-O7K3-?KVmu5<~SYm(9yi z5C?tDzJH}xQT}~Th#sR}a%WwUjc+!*<=TAyMVGSgWCUsBhC<9$$TNFT+PV%pIcoS_ z1c<`6gl1BvYZ=SnKjDn5q6YX6AuboabyXN8kki21OcstHt-1i)MB@dlyp+{Zhn(b~orK=${OCB8NMt`d~PdIhI=MItE?l zM=L$9>c&;Ix}OeS3@*3ZWFXr-1?xL&5KaeR41cppUn8ndIzaG4XoWZp;FH;OO1dRml{ z?{%%_Lz8Tlr!#R`6ei4C5Ck(0HT&a2YMn6xg;1&Xw|3UisRzvVrM=iNm^3lzXUK$J>ih zY2wgfo+=rx4hUYhOJl8SbifQS^d&k9Z$jsL*zFo5`=!FO8NmbI6HylCy^WBjl?>T4 zGrFwLpbO<9$Cj5)8?;1bwT9)c$Uf!@*E|bsE8h^U+GsPhYyX?sgu=3hK4)pjiqIOl z=R=`nvY=P6_VB{^k4<&5#~ONd$aLB6I+$v3C|2}H3D%$H{evEyk*=LGq@<7)j?EBY@#uD00l?|hM3n?nwNlC1Va;@@MutwXpU2`$q~p5xFkYwrHtR%KZt ziHaUB3zoI{8HHtbu8&DAmFBT84%p_&Y>_E_AU-el{_6)``ZhLrH;28&oXj!zY`u@h z?D=zgqL_^I;7X&*N)JVqZ7y_tPk7-otoNR)OBDoSYv6x zu}v8AgkMot%?hoyRl?uNW>v3;i|Nn?EmPh;@n(Q;6x5AoR_a!_j5Mi}BDQJyH_G~y zIxG@dJaD%SP>P`{9=Oc|j6uPHh(345|5t3Z0l6v@11%*)`dw>JeF+kTQly-Os|%Br1)t5-?=n}f zUCI8+v8$6*sUV(M)ylY*geBEY=S&o_CuZQvnRnRZQXlcKWiz-_6=Sv>EV`Q%%KA?E zJ6la(X@($AdiD%#v(h6xY27Xj#8Vtpy=GO=-qcjFgXjRrA`AaDi75(n0-}!vc9i+bl`BDnl6r}e zvn2q#EAFKIP;j0!#Qv`c#7{Lc*w`_~n%&R=zSB^|Ae1BjeR}}B*g**I4jhoZgaeUe z(GzUvV%00adR7@c5$bCT3prIom_$a8ah&#+a0#!D+H(SIMU z^`|7HXj|E2ywQFG+T2yBcA^K$MDPsX{U@u8vW9k{(M>x!*3 z!T+Fq<>d4-Pk_)HHcCrrPGDehy$|V6i>b_jpoVsMA#dcwk?W+kXY>KMs~7`w<1Js| z(+km=UW*qGICBHksj3Q%(#n;iJw6kGaXzp7-I^g7-BjP@LNQzdb@to1F$88dBM+Qj zrzy0M9w;Lxhx+;3MDro)T3S-hXYhMnuej{TAoW|=KU<7?JTe4(nZJ+&ASusMxJH&t zYK?n7*0p5t44F{_M$d?6+7!@#NXw1M&zf~7Pac(0#r`UA>K5i$h|7^7(W}>z1Jk@r zM2-x5aQM%R(eNoyb3q&*DurhDV#*~%hIB-Rs$+)@8^(8~r?<;Y9qtB^W-QqH`nn-o zEe_#_K>QMBN$rZ537^`ZDxY&*_LHKOCjKlPmCH}6Pk00OKxC0>qm?m!P~hYW+t*TQ z3h-Q16iGM?Fqba<)6!R~pdKeyH-r5Gwf(~W@Q4VAzXz@3w`~hJ9AqpaZVtN=I?(*% zAfqLQ6?hRdYbY--ADW_btpYraeFR#IxH)wCNvj?!4Icd7|H7a_gNWxv`7UEaie#9l;zq_^7V>IcF-Sh0 zf~^wl@tb$Gj2<()*3C?;tj=3;V{{GK~%f$bk1K0|5bYl|} z!P?$dYd3D~w;Y0);{5#fw-5x7Gv59dwq3uz-utph|A9!dX_^(+|h%Y|y-2f*gEN4H+=?pfMi z!l1pXbxWEF4nStlcg#8R^ZFftI-`TD?}Sa7{^!aCm+bp&^Ikn;7a9l7#fLJ|9hh~^ zxx$owQa;LU3aRo8Xd|O?@W&mlAvtP!j>%fyQ0mg*YY%0pL(>^rVcmKS!Dyi_& z6J#pVtPdIt9a-IIqsfWiqSVk>RP+izQC0G-?-e&ARXLoTZ}<4L<%`&@DZeH)eto0L z^r^nRs5JRN1oXHW@8zo|hGve$!2=A0m>W73-!FWwCGW7XOu> z2IXzOxGFr>`_6)li68H`8Q-ZQtmJC-`pb0(hP?bDbw;uzvg_{)Bi+!hzT*B@O{QTh z6t2$va?TMw4UKC)287X4C}I|>tCFU=v~x)mjO@8$oShR7j>Pggbc^J-2?bqvWsR5J ze>=Urd1_}SmKBW2&9C);HSJ}Y=og~8hNC<8J@an4#OMt!gDU5V7O!_*`t?-u^KCbC z4D51h<8Li_$#2?!`*qj`a3|FjZk6mgam6+C*I21N#2io<+gpZR-X!K)AQQOYrH&Hn z0FS$2T~Y6b&wIESf7HZ8X67KAW}_wzkyE!GG^3Upc&URL0h9 z@~m3)3%bM=uhpOY*ncXy;OLDqX7!7i{@FNGB(bTYV%sDGR>;*7s?@OK-wlt|dIP8m zuB(5_?86Ij4*((?x$*}Vujtk(Yr@qt_#S$Luo@ZhrFXk~fZ@N8NZYdzm2&&Z_3UwC zuOhEZgw@gBj@v9OmlG@nCp?5(K6eIPBJjj4*|7VGB%t2Hyaf@kSq)AB3?MYZNfu*u zdl#Or_fZguXxZfLJ%`xfdY_zH0(L03CpAdUU&5hb84S+@`qRuT64HY%ZCSVOUXw2j zK+6$k8j6$;EiH$Eyrre{9dvj-AA{(~NRdEsb2JN5n-9hI1X_IiRaFkAv1lOFlteHh znQdJoH8ts`(B)TpyjWL^_{-4H;gC&eM?-VFnTqN5>s%Bo#mqUYCZG})snQI73ht{8 z{Nka=aS5IUw7J|J>x$K*#N*48s#>Y=%+$(GG2Tj^GjaTQ*v>4}efvmtLYH2_-K9%o zNz4oXZ~nE;pwh82-K!GWGOhrypz+y95Jc4h)qJX+o`t#slWT^To9Eu`Db>4o)ZSXs z98B{vS&&zvh~vBST1QG2egC(yS3=s)IgU+%KZ?P&x)9KrcJXV6nD+A~-*bSn?9pc7 z(=pCDWW&k-|F#{Z4T>=o2=YsgqXpw2Z=6JAZPcQ==1@0>S+k<;v}f4TV})<|*94~H z@slS>`1wph#bjAmHbVF8tkW{3y*??Th%+$oztdYSr7AZs@4L)qv~X;jNgt&-o=Ms{ ztWCJW-ZpCoZm4^kP;T8_Y%>6b!}S|C?u@$EH?+TZVJbu2*I%HLPmVxQ418Jy@c3&G z>hhrH<>p#Sjg0I4^b_{3Fj2)S$Igf(%kPj%ZIpntkk-QW*<+J5%?JprV#VviPsVP2T}4OU~R6 zNrO~ib3gpHXZ3iB0TN4)b*HUZ;4A;BMQL%o_*OR@M@S;4QY#g`_bv3JjNh|nv+Vmr z-4v554=fu|P!DguYpCr3r?Jtp{#^<*m9JhM!*U865kb?X^rbW2qhDx$CZ*GdO})1Y z8sBj{MATENCpd|lyHA$^G1{BSCm~x%F3;G zcSpHPREE#vGslTjb$5S31s*c;RUqP%xQoEZVc1XA3j>`s!Ocwz ziCa8o$UKfM0$J%rT776Wgoxm$f=xR&AM5zIT@dS-{TE@xyLayxd_d&-#nr)1q{HJl zrJrF0$Bvw^Fq?!6D(953OQ9%1Cjik0+NYyiQs})98A*+oabO4b;X(M#sn6rKZ+~(za6P^#a1qe96T_lU$E2%kgH9kd)p5}x zJ}rXxsSI%ul>kEln)n&g<*|z59=?CSfJp>&5`#&Trum-~*|JJFGw}Wv84!x< zN=iJT1>fRhJwMIUxwEAQ+8DUVdLMrUe(*w;@1}CNW#57s&_dq&oey*#`{!-w{4m7R z9DKtP%_8yLTq^X7sL2)NkK1UeomG^*DlxoAT}48J0|WX#g=WvDipoTZd0^KRV%@S0 zw~6f2&%3Y(g=1p2g2L8jM8NiN@lU!OTG!oyiM5pOboRCTxl~sZ0PVhWOttOqpl(D{*?ou!qmN`#d8`PqTQhB_4rBz1F&&s zAH00$;!J(e8Ww?q)WttiD^+C680rgYtSMN>_v5PoIp(JHEZ`D~oiK*Y_>nX-D@-qv zG|~$#Wvp}~E2dW;$g!l3fUTfoGiG|u&irZ*KK75%F9oGW_ zua;7fi%es=XyD!Byll6%YQ{u`QxKnz1@tV`1z_2IIBl+4i?z+t0dIPRD)ewfC(j$M zl=+yd;N6Eb4g6jA8ymv{rDQx7O2({>mUz{s-o2KHc-^kc+K{h)s_(Y}SQT9@D-%TW zH_F`eTUuLb_AG{8zJ6Rk;!UEEi-kAHqeMZx-AK!!flm`% zHlDPdgqRl>w?|GMezR`o&*cF*9^)Pv^|aQ)NR<1|TW=qvRN8OuP^j7H;A3L2Sm8GH zE;JfF8c?3i9|l=k+DX>k*hLNw1be`Nq7mct0t}E@!Wlv1-_0OSOi0k3I(0{;7l{Bn zX1@LS5y&3iB#;!kElUkF?A-}clruI;44+mL*+Dk8jF99{2p&>ZjP4|3FO-*9R zIAVey@gudgxT-vS_H17EeReYND!FL3OL##LpB!@yFx_FG@e|t-KX`ai77F432IB|r z;PL{Dx460r7I`aHa6dwH)Jz%xk7D9P%3EIQiV}KHp3ZXB*+{6ggASjH=7OjB`r72$ zukiG|qnT%)15!c>2H6?7FL9S{JAB8<1ak*afmPM>wB*EaJwkfG&!0g7t!83P62qC&;K@epEir1AmQu6; zzJ@|y!}^}BF&~pE3kxywthAGvR)z+RQP~4%s4_I3dAgJXG1T2Z>Rm*s8- zB^&`PE9^;EtZ0LxsJ=1BLC0BFvoS`p(v@laKC5p=pGDLpd9Qp25538HdWt8I*TDh- zylPlIsbSX`*}h6Mcxkc6WPaU0?Y-{8(}KFmy%YwsTC6pbdiCnXEcXe=44g5(o87xf zLZ&^Esa?szkapleFvD7q5;l7-1xV%@#{nEbX1W@Ruc6#f>;riNz!er2GVT=OI%pZ^Y60lw7+dOD;g+V6F>@R_m(!?pet*??U@U zi|`4Cyoir71pz~l56GOLP$Pl_OyXFOe;3(bM8I52+dhLX4(Qj9!UO=%+FI_gV_>ZH zq^|1r2T!F@OpjYg#)pZCTl_>#c3i0ItI_g}LM zvE}toi`$qP_9SxqL;8o(e{~M$h0gAewt3K?x9f`0%|=f%ftwh zC(_)`EPEgxXL|c^&9t!rzzkEZqRem_yOD@DiWBaBx#($HN)~-K(3ZCcu-&O^7*hWj z84a9a3sGwRe8s_oSLy9j@1w7A8j?{>O%30-v05I1LOjO()IKZC=rS-M{efeMdDBdy zDNy}F`LK198Rjl^0+B>!@6~+A;K6LJ$BEhdj{Ka&nN6RHj|g7KV|8$ zt8h)$*$dPa5C{;~Cv^;O66ygBMeg5#O2$J|dEYW!fFxDbxXfctV;PX~boK>)4O3H7 zZS9+!)YFGaM)XlrBU6{Xf%w44^{BJq@L;5XTOK7xb|WB-zP?hK?r}RAiSz7v7=N>K z;0Z@|BjH2auZPDqi2i;oY<|)S|J+uV#)2ujtlhHng?p*b!B1iblK+n0n=36XBV(cL z(~iu)T_a5l zY}5)dBR7Q>l-dzjT#KFzu^;zqi2b^;dc<6BRx)D{$f&=Xp~9ErM~qs&~sZ<`HLy_4hX4)UP<>P}D;+5#tqs z?`rRci#X)fZEC%yF0%E{$b{&Aee7n6cen=LwTKYei-D`~n~S!Xix|)9)q67gm2_;T zy2!ViG1O3d#T?;~!CiQgTBj6$-{J{*(5nmr^A0?!-X8PUQ^EJANf`|RQ$pZd1~ioS zzJ^Zx_CJ0Y#%9j@NBLUU`dfEO-n0!UP`h(aHYTrsnsiGIWFiQs9(sLZuFdj1BUjo> zX~xh^*+m~Y&GYO_xd5@>t}V^&Kg>S78oA7RYar23IXbh{XNKNk5Xf;meVD|$S*D`8 zH5V7BqJhJ(C;3U_cb(WwXM542PVqpGJ4G}f2}ZsC;NU)&d|%Pix|Va z3!Br-SC1a4;OTJxHGJ`bJ6_Ueum@p3WwjA;hN0@oOP8KDw-Y04ZF=?I|KkGGtuDe% z8yw=swQHsS+TuDIn~7?;;I`)zGIiDBQEJJ{$UM$p77eWAr4LS{7N33L!jsp205pT6 zg`K~TR3sxT#+U5XR9%pb0K($S3rJ$}!bA>zX3rTl{F{(^x1@+27X>WwR>vwi9Fe_b zOq7Y552yS7Yrbtrq!bHCf&z?fO6ebNzxT(~v#!aPMtK(Z#>|-r%9Lhce%WJ4=ye0N z_>Zq%F+GHAO(}#Z+~u0Gn?=?foZ6K)k}y1UVd%8u;v(;ahiCSx7AKJH`tyS_Un6<> z{sK~d@oOZr%F;PZDv3Udlzm{oBPQmGZrp9pzEY7hru=D(nfx`hG+jql0_v z3t%F_U0b~ZejwEc%(nXvAAU3K`fSShqY=khn$nGwFAUtT-ME2tELvQw39SLS-1s5k z>+q+kEc*XOkb=Yfz7=VmU?$0PT6tOO^uJ`B!cc~1RmGVq^vvVNJ>y(|_V-&6r{c3e zA2w3jakbc=7;XCILyD*n_(CH}xk4oZm~_xMkP7rO3gc_K?|5rsEJ=oR&Ue4gF;5&E zM?O&tofxABGfTpXoyiZhU&LVB;^KtF9_XSF%W`md0-zMktyrtL_l_Sgcy&!zXsKP~ zg1ZRxQ77Oi!DRQ@kNTb12PI@90+7+ zQTX=CntX}Q84hcf5D6+*469C%kW8?PkVW_PD~`Msw{QPp;^gS)7(CTAq}%zKCR1*N|_^srQ+GXsiLFAVGStk06NfBhP-cfdXL&cI~~{3enD} z6^tjZxHB?xz`5y?bBST}-C(k{+N|`YE_6r_$f+fBighWDBg{!*?MmtVb)z7(+djqRaj*d|diqlPbLL z>+Wlf4nhZ>^3puw{HIUW`g{LkGXHO2E9jSO8G`GJh5bu6V%t?853h;@8GVv@k#yj* z^4jmQj{&BWYi1VIqgEgW{o)8WThS4_J@Xbd_2_=6APpB)gL}VFyPw|K&G?ry8` z(om4Pn`)mEb;`r{CHF?_I`fs7k*%#-mQ*QjTaVls($k$GPBO-F$`+sIa_D(9Z`yk? zWzb$Ra|I>?uDXnFns0edxMn+TWx_y7f!rRRG&;=BCG5G%*Qy>o9HL={b}@E4s? zkueb;ho#r~1fh35-MWWzu*Jq6EJL*nGfrjd7F`#lfj=ShDX*-s{_ zR`~7E^%(s_Fp$ag!-xwdjUlshdYsc__0 z4%2jkC-2MdRd6Y?(qq1M@@2&Zx6`~%l}B9DHt93Zq+e(Z#g~$d1WCs-=_d8kWsS47 zlQXqsP8h4j6UOrS`%d{o^N$0AJY9|SLHFgMZ?CUTAiYjyYuKE{Sv9=F-76;jR^RWI zpBT2ItEE%vEeDRlkRjK8%EXDw3+ge^!y%`}>r_%pd%&C{yJlwLVv6p;O(l5_Hr-Te zcfQjk?w&J(pLIX^2V`6z+$wbJU0Z<5t;Uw}CSSQ|U{6RIMh8#Uy+!?2?*nv#sp%YJ ziw|1GPD}`NW%sA1vMTfk&IP~$j!>L(?9L2z1(5gnazgKD2D9&T={dEeXkv?5<2Bv( zLF+o8o>9q|%Dx#vvJHcwFJJUE^u+&6z%#``hvLyOcMmbUc-ZVPQ^(l`>c9wkSrVVg zeb|L{ChS4uegx82dU)s!u)^i1R0-yw)lelFNRBBNXJ&~muww8g>Onmy*RvwxE=4B1 zO8tRhzp;K{HlOd%YjLG}%`gF05k|ypq5z`U#S`L z3Q9^)IWd*=@Hm`4YZg*(9Fq#_K@t4yeSJ^OJ989N<+?jZFStBzNP-O(seO;S8)4_X zp37aS*&U>veN2Y-h?$g?nW-y_ytrVo#3#$r>HIG$<%Fg87hOoH?>h!4A@V4!5BAl| z2D{S9LIFnBP9E5&Pag{SLPunId6`*mndW}_j6G~;yS|w!M`1(^f~5vlZR$vOrLfKn z&{TiFGd4EdJpdiu^kE!1#{D*v;KURF)@b+r9hM9agg=<-^R-iCtX@5qu%*Q(o~~Zw z?Ty9?AMNltM`$o&w{0^F{&C7iYqzCFXJ==C@#PB__5(4~^FgOOeteXM1_S=#dize$ zhJtc}xu@>k%lrIqK)_VNO7k-hASH+glYT*rFL^0ZSK0Nsc6v4V4NMw(qyzkNfY=U8 zgilSv1|T}q4?LB$b}=b}Scvc!n=Q1sxW?F@aG-~$;)2|O*5{vpdL=|ZWDq9!4HKRI z`0@FmuinEFAKkw{O+zt#^S8z965Cg)KVubOzv5l1eM|&j0kM_=vXTjFRZrQh@c%kTFghh0x5D^4oK#P2teuyK}{HFl* zC@a5Q8EzuN=zGJM2h+X_Gv>THR>3iKnS-r4Uxu>obR;_m32>oScfo@~9U;Y2B?sx2 zqb5VAX(mzrn62%(I7RvWm-LaYl+I@o5)v{p)XAY4z2p147|F|c`T^ZY`dy9hVWqFP zkAbYJva)BPBllUJo+pv3^m|&?{|rmau-qUlG3#uG;o&N3C-@P9lf4vuCFd)Vb5{0hvF87inBf;SSbS9qmsCe=4IsH&;`y*WCM9mV;Ae=aNG%$YB1LVgKoRSA|a%rt%@ zdpP~%J<3i_A83}CS7Gi7W9%oqOp3;2{;TBAw4U_(ZubC4b{XerExq!}po1 zDR^MwA;Fg+Q0@6gbOlT^wtT6X1ujeHfUGl&Ub!2KHtR#RYu1k{1rI;VfgFjqZp8_h zp?BfH%xOq|(%W`&!rDZNym=}bnC>-q=wlp-VZz5uhd+D5KF4XS%m0lN)b;1*)Vhvv zNyg?;yi7OW;axu+f)~f-h^SHM1YIJa@3lZkZpzV~Q!sMigSOD{0heDicX5mw?5DX$ zqmrA^y&p0@NUDTyjm-pSqD}3~QBmmf2kuap>ev~WzHLrMEOr%FbvYyP1wPjL+3wuj zy9Q-Ov#?V$^V2u9Qdn(vdngvOIdds&?6l3V!!Rf4NlHi$?andtELePGzPZMyvbPJ@ ztfWmS)4kh2^uob2ByQs2p<%4mOd~C*OUW&G=z+c*J22@3tAx*&9Z(9TiJs`uY^?w~??GB6=pQO!nnA*jLG ze&?ou68|#`=+*Sr7S%J7EfgvMmS01cDygf7oxg2j0mPF$XYk;`3y<5OC-T3rIUvA6 zJK5rK^7Z09V*B(D+j16PKKfZBv>@WQ^WDW1A#;w6)9tIb?-sQAe&PoXn<+yTKLnjNjL`VUp0PSSD=`|7@Mu|z#(8X`3i}ZpRD%i zEDl%Sma?^~mBp;Gwe!C-aa}zclulH+^`NpN2duwI+W<;Ex1q6_2@^#KvmV{ef*F@m zpJ!~WmX7lO(+ZfFW4j4A(^Bf+f6J~|75=d!=#)gj>(bLy41}z4RWL4z%QG;L471Ic zE3vP%qC#q`8)HQH9v&X>D`rif4xQqd7emgOGiOqqxVvXwcONi#@P=Y1xL+`iUi;zu zfLfq+9Y-IL2c)wP9*o~RYaH8iKR=}xZ>WwKphTB(z(CyLr6ILaRr7D=348ad9Jix6 zQV;O(@v%BGAConrfa7-VBo~*9V;o>)Bs0=JMOtab$Hiehz;nn{F*1T;gO?#cOKhgi+6d;uUw^)O<%N}^fdPv>>^C2@8!Pwq zRaRD(Jc`>p7mSs&j}H+((`U^hngCcj^&r5)k@?IEpv0HoxPjY%g+;hyE+fP+vr}MZ z7oMv1=@VAgG;`K0;)Fr8YrIqk3@}&F0QS>R{8xXVi~OS*VWohkzHs6yDk^|I;AN1| zZLWH~r9}h!sJuKw{tjm7IK7x{bL91@o%@JWi(%iQsVQl+{feu{^5tWG7wS?*-V3B; zlUWMH!>QN3zz$mXY)@#6xzXfHFv@t@B>{SDW&AcCdiBsqGH@FZ|M@{$N?!hZkTff< z=n1wd1kKTILkr!$y~p65r(|Sgu<4VZKFd_DJK&iUi{UJ;7DZ3MBGUq2?u#;wA?vPzIqBP>ASRr{r@_u%&@ib+th2pw5bIkv@8HS zCxS9CrgI8?^$HF8-J7HbLrz##fBFa~2nZ7T)vIZ*{eGe)1Xc#qrZ1!n#9J7WCI_OO zo!zu)m=nS86$byBJrj?)sOeg|FP0T8({cEje888LXQjk)AaXvFMld4ZDg&5IzO&Pw{5Ne$_>)T2$BER>|j;K$)YA zm5biL>Ikg?6;z08)UAQGqQ;7@BZwlfvD2Q&;W%Q%^`a9zPJkhWqTPKbZeHyaBPQc| z40?5;^SN75C5$xHou;QO($tEi%Wkc_A@Mw}tVuoO^mX_8)64&1r(zOA!xIxj+9)c& zG0|n1xIcL92OiE`kU#$ulOk_(!4(spH`(aS{?JmVrZPZXd^xxiT#-e}+j@Gwgyb`0 zSPgnu8zq>1(}#^8KAdnyHk_81FKJ`Yj370~M1kkv3Ewy78nYY(WaG!<7DSAlU%w^0EtTbsK*-EM_DiAZ^aP;`x+GUu{P=GL22ZW57&WWuR z>$!Y+H@PtpJ9Z`#q^zvr*;L|?qoDhK4=@I}1qfkC%gx30@Qtx&vpgALTwL3{)j?;g z$~fW_GiS_zcZ|U+^;m;v0r6tvmYmh$(xJcj`JFj@ z*n_SHJj-{XT4~-6p@0`zD|U>sThwwE&QaH^=qZE(D5H?RH`wG^bba3~qw-$=9!ydN?xupF)CbcO zY28W>tE?Ip{J2nS6}9N!c?N2V0~~Vg=^9t6?2T`%6<85T+DbBqY@|*Ph7y@lWq!KX z+l3Wg;QkpCAI%KESN;TEa37hdgk;tZ69d*Kt)zvh9HGoXF2RWFwBR=s)XU~Vz63NJ zAs@b^!cb&J3|xutM|7i&E1*P-_j>$4%Ea}vfF-FGlq5SwJle9Ua@tA?A>nl&b(_)X zN*G&b)rbVHS*aK!{@+o2Jo9od9u?^rn^NUtz=ZCQ&8vwL#&@2i&I^B_JW|a1*@{;m zKgRFavGh{V#3+l`@7^JRg~o&MQ*2&SPU_gp5@MhVX;W4g^i$SH=99q$MbqVe z=alZQSjcb7sIBw+tpxAiOnvX|myG_?TXHvRfMFqfjE5a>-zSZb88W4Gj%UU_CvznyKr6%Ey;)^!Ml3XPbN8{)0^t(BH-; z!$u2I0f#IKA&k)KeYowI%jV=%z4!0muOHF~GAbb@vO9tCWP17g8zfr7gSw`R`3fF` zNayub;)uNCHmddJHnCO0OqhCyS-PEeAp-yCvQ@Yuy9H}71=cRmLuV;TJm%_xP5pHf=93vSL zM952l@r1i9WToxbg$#81ON4Jzr}i$o0w&F%STf=er>S`YAKU04!BUR+OX#ZX8N2jN zdjJ|K)S3*_U;71NW!jw~J2R`DX91mX%mM;5x08dhYx*#lW_U9~5=*K2itPi&xA@~e z+E?~;-NubYl^%|G8OKbgx1%=Tx|!B+-JEsIH!$4${&nx4_rnEX2)+sV7WNFrpFI=Y zKOqd{Uqo@xS_KTeeep=ypZloW1deTc0F@0PU4fsEcIlKi?KK!TZd^v+En;RPa<)x)7%`d$(-DDgRfkDjtFm8VlJVw1^j zLzpv94@7u_gBmj+s0`ptNZ^C1r-9qR+9IQ)Lpmx)vJf#*_3?R!jzjQ<!l$8IlmXFlG!nE~goo0RDg91W0WYpeGiD*0Vryh1##%?o zRinCt2S|#Z6D$`B1SSv6Ezz7X2^PqT$#Y8hD4Z{7Kaiti-jR*_8(MxWl~mN!@MgpB zR6vldtZgI|4J?eY;2f??81cb{kb)vn%8XP1^H2m z+tMHz)&e*5FLYeW!qwYHn8atMW`d6^dkH9lFt@=I0nN;P40R#JQvUq^!V;U`5oYQz z;vugUIx-sPc5jG7k1CAE*o6md-e7cao?_>nA>E!jOl;{FR*qed=fjSf&E2rI(lTG8 zg9M@+viXsEr%N71v5!GdYHf^ayYvwr8hxzLjWbU*b2&ac}tOecqP5ir*=mnK>72>ZBfnc0jJ z7>Nz6SzSbv5?zL9({sOF_I>k{|Dt+Hs${q2qYT$5da|Re2}_{zW=chFm?QJ)thJH= zo|#F6nU(6wI!?2-%c`N4V;Zkw?SFxi$?T~*TI;f=FF}_`P-$-elzP@N_mkna(fDC= zdKtg>>9{-a_cXqrm=u(^ul-J)mqhayYP=VdpJv~4^(~MItu%Wq2&fz`m09bJ2G>~5 zO02XqMf0FEW12S;o56I=rvu^pV}vxEnn32ZptI4sr^>>bq~o%1CVvv z8+5f>fy^66T%jGy7^Z(!UhV*K56KFzn?eWJd+qraDBG;=WCi`}w)Gh!^ z1&whjRd5RsZwC-$G68_!TmksH?empIm_yPoYQ4m9kVFgP)j>gySv3$znKH0#7fx{d z{My$L<5R$&`Nx6wU3G71n({9z>Y26pKfjB2Ha`K~S#{ffE6rnrkJPV|TzE{xy z2{WP@w#*T-@2@i0fB&_Tl=$-u^%k{?h*6=&UWYCnwZRX6fmxGFvD3~>vdu&mly->) z(m1vdEt+DiPwjwJ&t9?f(pI7pN4m@XyIsFSG_6~TI1es+c09pv>t}q|5Bak6-GB~1`RE|E;+}OvQSCMhOoMl06cls}_ozbDod~61k9} zkkH-Lm=R|rt}4@#d5tv3@T627O3Rg}%pPr&cXc|mEjXVUl77nLn; zqv64_AnH1tJCtN_D4@W@{QpO7ie~1VCZ0UJ0iwfeW`xlgHiN_&3R-`WYiZT8uxRld0M* zHSR4){QjhM9bbt<8)q5ndzW7^-6JrB9skw75oY9+rN4eO$HNYL7SP;VGbs=|um9;h z=w?1LtR|Ry9;F6W^}<<(V@KnE7cj4vy#Rir@w~q)HvEU2&^}a}2oS34E zx@b#rFaH;{1MGNEaU#GNNm!9v@nlWOn3O8PNhYcC3tCkgFOps}PoDgc7xL$=;4lsy z0gEaYJN?>NIzMV8IT;z@7{nR}Is$$h@~Vcu^i7=ed?KQXFM?vLZ2f~PJ9$Hl--SFU zoRoxtJBeVsXV1o! zb~?uCjGNjiF;aH#7L>0PgGfHNGw&h+b;rypWK=Qx!N&d+pBKiY6D*D6$6s$O`StX_ zg*li9qB?)`R`i0_Cndw3&$ORg)6co79IboH{CcaKf->g`_m$8Zb|)U9SL84-tsm7x zNC$hB5YNxh~{U47qB0T(&&)KS0#Bh=kfI`aV3a}gW2ZBcnpOZngw*`});$9+C z3u?VL|Ck5vK`zL?Tcx#kuZlR2!9?(E>xzwV7;z<>S2JVuv5HXReO4@MDXA{HQ1rle8XHRL#I%QKgJ+ep@YKJ zrw@Z^Gw!kL*ZQM-d%%?FudneM4rVXih`-XP3CNnxcStC=(x?3qd`)hezR@KDNz2k! zNkaatZj*?@mtJpGnVh@4UnFsE8;b?Z_Mr8o@#96Cc!J8+{pb#V{5Ut~2v7$AI-QDl zA^LYD5s=Q+6&PK61yO(_p-ripNNQ_h;=mn}+FdoT{m^A(Y6V=3iIK+TxlbQA{ee(G z%9^C)T9SLKQg6?abJc%nf1H{qyf4DzH)>Oar-Jgh?L?5E;&QuB+MH^ z6{seL*p?cS5n&dG5Lk{)A;AZyt9l;v+? z&Z!lHU@}U1JL3eye7?24dx@BYdCWA!T!C?YdjN+ST!vjlp${8ok!#PUgYQ}P{ccb_ zCFP=h4t=3`2LWSRT9(?$99LANgarh{^e510T`_SY#>Nf*m_PxQ@B84-H-)>><5XY1 ziiE;j>|OgGwK55SrTWierf=*gT}6xw-cDz0R`-v zRGw3@*h;B!8AE7njMD#<*ymjGe?M^d2I$g+z#uOEJ<-ao&~YWGr?>Y@)qCv5$tfx2 z*RCP70DT9_g2_UAul2HhrEa^J%o_R@h(;!DE)S*~f0!bM`NR@?du3HsU?M@0fBw8t zH_E>jh8dn_E?@WG8A7|vAP|&xbVAfg}DJFbVtWI z+4pg%50*7gpgW;f0RnMZ-!f{QM9*lP5F%#MO~st*3;o}wHQ{G;DLXsbQiD2yrNYXCrVR%l$mEdCUNqPP2GrNq0=|7$`I(q-18+;^KA4pTF!P?i08Y=n_#VIyKDOsl%BdQ-U_P zgVr)~z$duAg-^|Rh>O*gUBXkt)sd}HE>4<+%ka(}I{=}_;Oy(=WjQv5ewi&0<*BM1 z>owax2LVWCR+d1^c7oyo;tKiT!<#pVH{oeB7spl-C<=p3ps1==z835?g!0AiKbm4< zC^7Qz72VpJIm2w^yJfKL$rwKa8lIKajLY0&GJsfGJQwhYULyTtkB||ifkQpyKCSPC zxi>g6D|qVf>}}h&EzGeuKP&BW-${w_6=(YXy?YTXb9aqE#y$Tyw3^^xRikZInps+J z+J<}InFJ2gqr*4t#pn(IJndwL->>{Iy7_{TPNc6x2#i-+IG}08m@n1i5z_E8(c>3{ zfRvF_*=zB%E%_3%WelJm!6tuC&dZ|H(A3@Y&oP(S=}SCZ+4b=Iuc>N*s+kuL9eRk| z#kvm@3mu<6e0ZbnGgA!iZ6=t1uiu~aV<)4Jc&m`!QS;P?#5w4kJbs+qHCXn{*T1J% zN{m_oW`Rbh4*J2$y0KkNXG=q6i@5270!Csq5A^1CgmVAV1T-985I+7c8-K~!l%t}- zMrmrmr;Lr6kQ)~bOC*D=zq0a+_JF*i^z1TtKCDQ*Fc}-dUbv!+!$Yr!lYuO+xaydV zU471QDM}H30o;)AdBmH8OwEN$mcXHM+0wbZ*hv^(@@o;v&8MoZO-@gDft*xRGoHwz zhV|7bp1{M{#(^E7E(B8_GDiWaVp#(6!_uIZ6S6*$NTp6(dCutr)l~lh0}vvBtFj;s zRyVN5A2l@SC`e%y`Nr2!V46bMfsDfd2cZZc2E75K3XnEn8{P|#jzsJ1yrmb;Ubyg! zY7@xa1SO(6?6ANke%@&2zS zRm14UsEEu^t#DiOL`9qF<8Nqa-q6?Gu&!(Crn*ZjpKe%@+v%}flK@xG)0z`%95PiB zcPdHj9%eZ%`u?Vm?>ApIHGcN)t8-6{>)RR!rKc-Q`gQ61eg93))$18RGy@5-;gBQ% z)+xj}Fz|z#+T%bTlglw<2q|Jjgp1_)ZgwlOsm7u;Lp0o;!h?mC!Y+y%5C~jncHq1r z6Oo`@s`>Fn>e6-(RWqU`FjKjCUkGb_J+lPa^+cve<@G z{A+qzRM;+Pf zee^|cTAIzjo6Z2=dxP>T8!hp5zsK9Al1jMwadSI5NgVjK960qe8YOvZky)Vu8~mhGqcd>l5?J8 z?v`~o&JyXePkrNuRB_Lh`3@uv)`Y_|OzNv)c}qoX^?^!{nJTHyd2p6YYuzlCE|x9B zIB!h(4UN~bQ5MuVDza20$L-FGuDN>3By+IlIZgN{>xxU=n6Q*QTT?{0H(99zY6(;V z__vo3Xi)V}Rg-_Wh^zLw2Wv!R3EveK4i}y_`8ssNKRmI}v2`6zQd_Id*L<3M>6tNg`Vx`yVo+(0uOZ~2p$-IWV9GjX;>3Psx)+|30+C%O=))=1 zQC_yUuj3v~;w!*(W)~C{hsdFZ1j@!6LXZH2!K4JXLXB!4J<%pDep=*I!U478g&>tGlqg zN*SL-6O#|0JN-YvOEKcy4K#N4|Nm$@?|>fH|NplnNlTLUARUsB%4$hvB_wf3g(M*f zN!rtB$O@@sL^{gMh^DNTL}ts%Dl;wp9&exDx4#@Z?{VMPeO<5D^Yt8?FC&L?(BqXb zC4fKz41>9>l2lxL{QT38sDEh~zxo%uPl|ihd zqe6qfTRYCeUw#HK2GXokd2!&cSc^l#Z{l`uZz*vN>1YHfw&@PAGJs(#-=T9QT+hRU z6x6k(dK9{XbBvaiKrm9X?g}*{qB?;+@#xX0M^Mm`AeG+C^_3D6p(ewjaOf=dAl0wCE9_CKkCCR2y-3D0Sgt76)MF*7;PPlW%ne-lQyi z^9D}&r|%u?jz$eWrbL4G?(~-Ypj}i6os5%r!vNqndI`}^5|~hD6xqSc1}8HX3Dsn0 zKXp?FClbNdj^6FWyw8MIgKdPLUxA`QK%*p&l|?}Lg_+)~pIxv9-j9hc_ZU8GSWnXp z`Y9x~=ryQ;a6KhJ4}OJGtTq4H^*U(|Z6Fn#f|NM92V9Sa1^aC>)`qBHJ=FG#_X2WZ zQm*lBc3q1fCEe5?){K29)v^2DJX& zOa$wtOPeU|m=YpFLDQ;h9sG`C|;?v(ZO z_1z@(_;&(x|I?>oR#1a6tR=V46etRJ2OJdzH5->S#XR_EapMgjEr>t#b<}Bej~|fb zkQnd#+Ky2cAR09rHwnriS>rq=lw)ksnD{ZGiq|j?0-obrFot753wlV)Nw&yl7;`61 zti;&SHcs^_>5;5b3PCalctN6pSPGmgD7|P5Vc9;fug6^6iT=dF!3Sg$^*xtGTqKn1 ztjj`2^uv|qThP|Ra_#wYy%mqW)NNm`vJcX>la9)$Y&+aj@IV0%$jghc91q?UG!Cac zE*${5vBmJwmCpZ>A`yc=-h-)r% zt$O!;N@IE{PPO^_xbw*F9z7yEuK!`fON+?@Pwkef>ot*hBwlQ&Dkw8QEZJ!qNB(;6 zwDX!?^i=`7!rMCnAxIou>7#1tVzJn6-qRijhqlfEi5~#xTl~C?l$mpVxVP@Xtl-Ingc}(jyZuKpHj^RV zILvj9_iG<7o6�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�h&a7gFGqo30EP=7r+%Z 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

    RPD#(|230+Rloo{LyfUB6C|)Y#B~{`I+ZDO8ak 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 aWu~gVMWrc7qoD_XSG#UeT7#5 literal 0 HcmV?d00001 diff --git a/docs/screen_mish.png b/docs/screen_mish.png new file mode 100644 index 0000000000000000000000000000000000000000..36ec0202d44fd40224296e245fc381a509a128fb GIT binary patch literal 83093 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 literal 0 HcmV?d00001 diff --git a/docs/screen_total.png b/docs/screen_total.png new file mode 100644 index 0000000000000000000000000000000000000000..785a2d61312a99f813e92a98c77119be7fb7db72 GIT binary patch literal 214691 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%0D=-PBu&{ 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

    t{GVzT*WUhU>N*S-D!@jA{mzETcBr zv~gHQyi~DsTkF(#_xls~dq0Z3SKo~+=%O3_+Mevu*^C`m(XUdr2tU@>9O2uR6l{_v zjE#$X9O&qW`l_8N;&_|%aknWN_)^Echt|97u|XT3T2r;cO|VLe5cGTB=lO`a-YjeA z56{9AaKh(*_E&{CN#+Pv?B z?{%aAx9x?xZfnae_Z@ws*W|;e^=k}ne+*O7IZ|zKNrjWs6p3 zz9g6TL?(8OM#UMudd!uxEp(5hvC8a7#-OU?#2@!NO#SwAm-|7eWz1PlCMyQ%@=@Bn zOKBUq`baLGl8qnDJ$!20XP!i|%c|V?Wg*wL_cs6J2{J~xj)93EN3W!?%>LqV#OlZm zN8VR|yyt)80YOo8SsuHs<-}NLaXad0WMC7~dFPtr@Kby$alOy6cV|C%_fFb9Bf)Dv zz&Q43D>N)79DpbfeMsnUD}KC>sUfrd+Zgld!O1hhE zybaG`GSPX)NcR^l=o7)JBg&Deeau?QirR#$sat89dw`xG%98%>FkOe>z) zbKdT~SCndOpE=rlH5W4dXEOy6IZBV(dq>X$9kc*+G^)G4wrQho74e>~+I|vg z%bU`wt6rasX2vV|U4x8y^IY59VSm*nxsohRz3Tc!SvzIJS~RW<_&|r|CdLY8BswzM z&mzT&xmO6AhO5f9XSE-HS-WPjj-0y3?|F{L8tmJjD?+9x*!IM(B5Dr%t>1&aW0vb= z|7hL-2|)4JuX|&~YPXXg*Ou-CD4yEx8X7go-p1wh>8rmKOXNpNwwBg*9Hp=E9inBh zjIyLI2)OqF?e?^{73b!;*|$q-G43MDkk|};8P_m+%iS_7f>fG5*;l&J^!y%LtVAc8 zjZ0f-VXr>>z8-w-vDj(Rb4zML+rx?6BS%5Pc8|qw_t-hY#&;L5Xdm$#&Q7F7Ow6IF z+g)1Y*7t|9;16}@fW{`4|7m1KZuYU>^SYdeS5}v&E+dv+>v^yHgvTEjuhg>og1&nA zlkEMZLdKi9;)LdYRe$EC#ZAsyFQbIEv@TB@YipMGQ9>geO{YiM4*?x71P!cZ9b;M zvrO%_ESIy_M|;_riA=WJU_SYr;snb@9thO@cAbrfi z@A++@e#6))$Lq2s{&pUj?ARmbb2w+;857p~d96WL>`@DNqYbbQAHV*j=dBk^eNV3n z)*r4lzF}W7a^nUBLAKVmwWDjJIcy*#%TtZ6(@uHM_BuXP@@_W_^?SE{ak8TA z_Dse(N49*K+;i>w5=)X7EVt*|G?H>efz6z2t2wvWJTeqkeRi8|&)9xN_MxGOZ;O&Gq)B%#On%6{MeAAis~%*Z@_T+4 zOC&;4vGCLjV~Xn0mo3^LxwSKk$9?@9N1v+n81jk(9sQno;zx~}jwfrXnelM-9QJGP zM{hQs@$jA_2p``*eoxBRS+985Djt^F_J8`SdOLfb)pNPlx4*Fswr>98n0yGs!)0ba z*xz^g_So42S*8xK)Yo;pTqD`j|M1?K_se*}R>eBWJM9hH?FpBZ1!o+bIMSkMGdY8J zshr|c`ka?F0sxlgzL7w%9`YwsB+nqUz*)++7WlIX}A+N@!Z-HJVINkUnvl*C45`>15oD(jnI z#u~59Io0^%|EXsI+GnrpPZL#*F)xLBq5xjN4(2=epynG(dw!<4@0A??8pLWrl2A#D zE&I6fjxI7cUoYJ?b$hL#{sD4i-vrAEf1+iBFW(_R;`??O=>&7_H}FNt{m{x+dS!z zd|hVfhbiH0_|V7qk6p$&d!81lAAIjOe|_e;^Zq`L3(sUF#xZcRe5`|5(S3&%iIzEj z;NbUaGUw0uTS&1stt1vc#M608>7u+os!5(`&dnYUJZ5z`zw*J`a=)Y8p|3vUv)~zy z*S=zV%ok{2P#-KZHX~WRSoYx+$IXny|&vqH#I77^gQ0YW6

      ;@enH`FZ*5_qQXW5KtiC=;-n8Z*z?4mwf@4!I}W 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 z<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW z<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW z<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW z<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW z<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<$vXW<^TKV z2EYC{{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N z{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N z{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N z{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N z{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N{x|+N z{x|+N{x|+N{x|+N{x|+N{x|+N?l;~y-Z$Pi-Z$Pi-Z$Pi-Z$Pi-Z$Pi-Z$Pi-Z$Pi z-Z$Pi-Z$Pi-Z#!S&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C z&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C z&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C z&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3C&Nt3?&Uemt&Uemt&Uemt z&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt z&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt z&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt z&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt z&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt&Uemt z&Uemt&Ufeeo%h{&e&>GYe&>GYe&>GYe&>GYe&>GYe&>GYe&>GYedm1VeCK@Ue0N^o zdEa^8dEa^8dEa^8dEa^8dEa^8dEa^8dEa^8dEYtTIo~f!TsQVa6h;o+z;*t_k;Vv{osB$ z&kz0w|AYU*|KNY{KlmT~5B>-Lga5(*;D7Kx_#gZa{s;eq|H1#@fABx}AN&vg2mgcr z!T;cY@IUw;{15&I|AYU*|KNY{KlmT~5B>-Lga5(*;D7Kx_#gZa{s;eq|H1#@fABx} zAN&vg2mgcr!T;cY@IUw;{15&I|AYU*|KNY{KlmT~5B>-Lga5(*;D7Qz`Jenx{wM#F z|H=R4fAT;1pZrh$C;yZG$^Ybk@;~{X{7?QT|C9g8|Kxx2Klz{hPyQ$WlmE&8b z{Ga@PKNxRaeg04WPySE-PySE-PyW9jeDyf$^MCSx^8fu{;r@60e?O>au0H=K|KAUI z`MUk*|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV z|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV z|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV|K$JV z|K$JV|K$JV|K$JV|K$JV|K$JV|K$JsL7e^b%>T*%$^Xg!$^Xg!$^Xg!$^Xg!$^Xg! z$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg! z$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg! z$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg! z$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^Xg! z$^Xg!$^Xg!$^Xg!$^Xg!$^Xg!$^XUw_g0v{$AR~TmbTl!_x_dU+yBM?<@|r~e>wkO z{9pWE&i@zxm-GL{|Mw=J`|hJ!4=j!kNf9LA&{(tA{@BV-1>hJ!4=j!kNf9LA& z{(tA{@BV)ezq|ftzyEpXyZ&eY{^OnR`k(##k9WT7fA;&IcfRX?_WPfAzUzPX`=58d z>wot9pLf3NfA;&I_pq=2e*g2%)!*-b-nshw{m(o1c>Dd#JNJ0|{mjdN$J>4T9{%_1 z_St>=&iCu~*?s%Y_v`lAef!S$>-O1w`_A|4_St>^^g_&# z=j!b~edp@!K7Hrv?LK|yr=I=Vefn~>_sjhrUaofC_j9TL@4cV#d;6=Oc?MSAKh4`K z@89N~K|g~ygFJ(A1|H}A3q32J|IXk!gK`Fc&fw<^{+_|VGx(gr$@4jRJ}1xT3o;>yBsV7f8dFshiPo8%2w3DZu zJniIZCr>-o+o{z~t#)d)Q>&d??bPb0RzJ1+snt)derolz@BQq1Kh^u$_kQ-hpFI8K z=_gM=dHTuIPo6k=;^c{wCr+L?dE(@WlP6A|ICQ(~PG>$k)!*1z8!{0@G1 z@H_b3!SCRA2j9VN#_!;_`gibK{X6)r{vG^Q{|;Mcje^S&G@eDX8aCLp52V!m6K;T<9Frc+0FP}IeB(7epgPO-HhLrlV>;M zcjY`kyBWVL=lR*q_^#|`{0`3Zvzzg|a-N@d^0f2(?DqWroAdm%lV>;V_e&?wZrJb2 z$+H{wyK?gEhJ9Cd!+r-R&u-Z7%E_}E_PcWO?1ufWoIJbr-j&^Y-@$q2ck6vu&NIJT z@4IsLbhqAj9MMT{(NYTkl=jt@j9MMT{(NY zTkpGa_H?)2cjfHqZoTiyZ|i*rCr_TA%shGW{AA|IGk*K@{jPDIpK_gML%lpvu9h^M-(DYq7dG?{{yK?gEL(_NVoA1xf_vhyObMyVV`F?J`pPTRJ=KHz%er~>>oA2l5`?>jk zZoZ$J@8{zMq@#=jQvl`TpK~e{a6OH{aiz@9)j`_vZV1^ZmW~{@#3lZ@#}b z-`|_>@6Gr3=KFi|{k{4A-F*LUzJE90znkyh&G+x-`*-vGyZQdzeE)8~e>dO1oA2Mv z_wVNWck}(b`93$_=jQv|e4m@|bMt*}zR%6~x%oaf-{o;G&`Qqk_n=fv@xcTDdi<>WQ zzPS0~=8KyzZoatr;^vE+FK)iL`SRw=n=fy^y!rCx%bPE6zP$PJ=F6KeZ@#?w^5)B% zFK@oQ`NqvRZoYBzjhk=WeBXLQ`PR+1ZoYN%t($M%eCy_0H{ZJX*3GwW XzIF4hn{VBG>*iZG-&+6s-~av(%il(i literal 0 HcmV?d00001 diff --git a/fonts/ProggyClean.ttf b/fonts/ProggyClean.ttf new file mode 100644 index 0000000000000000000000000000000000000000..0270cdfe3caa811e1b252cdcc5b179989c1b8ad6 GIT binary patch literal 41208 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 +# +# SPDX-License-Identifier: Apache-2.0 + +SHELL = /bin/bash + +SOV = 1 +VERSION = 0.10 +PKG = 1 + +TARGET = libmish +DESC = Program Shell Access + +ifneq ($(CC), emcc) +BASE_LDFLAGS += -lutil +endif +BASE_LDFLAGS += -lpthread +EXTRA_LDFLAGS = $(BASE_LDFLAGS) + +# Auto load all the .c files dependencies, and object files +LIBSRC := ${notdir ${wildcard src/*.c}} + +# Tell make/gcc to find the files in VPATH +VPATH = src +VPATH += tests +IPATH = src + +include ./Makefile.common + +TOOLS = +TESTS = ${BIN}/mish_test \ + ${BIN}/mish_vt_test ${BIN}/mish_cmd_test \ + ${BIN}/mish_input_test \ + ${BIN}/mish_argv_make_test + +all : tools tests + +debug: all ${BIN}/mish_debug_test + @echo "*** mish_debug_test is dangerous, do not install anywhere" + +.PHONY: static shared tools tests +static: $(LIB)/$(TARGET).a +shared: ${LIB}/$(TARGET).so.$(SOV) +tools: $(TOOLS) +tests: $(TESTS) + +LIBOBJ := ${patsubst %, ${OBJ}/%, ${notdir ${LIBSRC:.c=.o}}} + +$(LIB)/$(TARGET).a : $(LIBOBJ) | $(LIB) +$(LIB)/$(TARGET).so.$(SOV) : $(LIBOBJ) | $(LIB)/$(TARGET).a + +# This rule OUGHT to be enough, but somehow it fails to take into account +# the 'shared' dependency, if its written explicitely as it is now, it +# works. I see no reason why it should not work, as the one a line down +# has no problem!! +#$(BIN)/%: | shared +$(TOOLS) $(TESTS): | shared +ifeq ($(CC), emcc) +$(BIN)/%: LDFLAGS_TARGET+=-L${LIB} +endif +$(BIN)/%: LDFLAGS_TARGET += -lmish -lrt + +$(BIN)/mish_input_test: LDFLAGS_TARGET = + +clean:: + rm -f $(LIB)/$(TARGET).* $(TOOLS) $(TESTS) + + +install: + mkdir -p $(DESTDIR)/bin/ $(DESTDIR)/lib/ $(DESTDIR)/include/ + for bin in $(TOOLS); do $(INSTALL) -m 0755 $$bin $(DESTDIR)/bin/$$(basename $$bin) ; done + $(INSTALL) -m 644 $(LIB)/$(TARGET).a $(DESTDIR)/lib/ + $(INSTALL) -m 644 src/mish.h $(DESTDIR)/include/ + rm -rf $(DESTDIR)/lib/$(TARGET).so* + $(INSTALL) -m 644 $(LIB)/$(TARGET).so.$(VERSION).$(SOV) $(DESTDIR)/lib/ + cp -f -d $(LIB)/{$(TARGET).so.$(SOV),$(TARGET).so} $(DESTDIR)/lib/ + mkdir -p $(DESTDIR)/lib/pkgconfig + sed -e "s|PREFIX|$(PREFIX)|" -e "s|VERSION|$(VERSION)|" \ + mish.pc >$(DESTDIR)/lib/pkgconfig/mish.pc + +deb : + rm -rf /tmp/$(TARGET) *.deb + make clean && make all && make install DESTDIR=/tmp/$(TARGET)/usr + mkdir -p $(BUILD)/debian; (cd $(BUILD)/debian; \ + fpm -s dir -t deb -C /tmp/$(TARGET) -n $(TARGET) -v $(VERSION) \ + --iteration $(PKG) \ + --description "$(DESC)" \ + usr/lib/{$(TARGET).so.$(SOV),$(TARGET).so.$(VERSION).$(SOV),$(TARGET).so} && \ + fpm -s dir -t deb -C /tmp/$(TARGET) -n $(TARGET)-dev -v $(VERSION) \ + --iteration $(PKG) \ + --description "$(DESC) - development files" \ + -d "$(TARGET) (= $(VERSION))" \ + usr/lib/$(TARGET).a \ + usr/lib/pkgconfig \ + usr/include ; \ + ) diff --git a/libmish/Makefile.common b/libmish/Makefile.common new file mode 100644 index 0000000..937c0c1 --- /dev/null +++ b/libmish/Makefile.common @@ -0,0 +1,97 @@ +# Makefile.common +# +# Copyright (C) 2012 Michel Pollet +# + +SHELL = /bin/bash +INSTALL ?= install +CC ?= gcc +CFLAGS ?= -O2 -Wall + +O ?= . +PREFIX ?= /usr/local + +ARCH := $(shell $(CC) -dumpmachine) +BUILDNAME := build-$(ARCH) +BUILD := $(O)/$(BUILDNAME) +OBJ = $(BUILD)/obj/$(TARGET) +BIN = $(BUILD)/bin +LIB = $(BUILD)/lib + +DESTDIR = $(O)/build-$(ARCH) + +EXTRA_CFLAGS += -g -fPIC --std=gnu99 +EXTRA_CFLAGS += -ffunction-sections -fdata-sections +EXTRA_CFLAGS += ${patsubst %,-I%,${subst :, ,${IPATH}}} + +ifeq (${shell uname},Linux) +EXTRA_LDFLAGS += -Wl,--relax,--gc-sections +READLINK = readlink -f +endif +ifeq (${shell uname},Darwin) +READLINK = echo +endif + +ifeq ($(V),1) +Q := +else +Q := @ +endif + +EXTRA_LDFLAGS += -L$(LIB) -Wl,-rpath,${shell $(READLINK) ${LIB}} + +all: ${OBJ} + +# +# Generic rules +# +$(OBJ) $(BIN) $(LIB): + +$(Q)echo " MKDIR" $@ && mkdir -p $@ + +$(LIB)/%.a : | $(LIB) + $(Q)echo " LIB ${@}" && \ + $(AR) cr $@ $^ \ + || echo Error: $(AR) cru $@ $^ + +.SECONDARY: + +$(OBJ)/%.o: %.c | $(OBJ) + $(Q)echo " CC" ${filter -O%, ${EXTRA_CFLAGS} $(CFLAGS) ${CFLAGS_TARGET}} "${<}" && \ + ${CC} -MMD ${EXTRA_CFLAGS} ${CPPFLAGS} ${CFLAGS} ${CFLAGS_TARGET} -c -o ${@} ${<} \ + || echo Error: ${CC} -MD ${EXTRA_CFLAGS} ${CPPFLAGS} ${CFLAGS} ${CFLAGS_TARGET} -c -o ${@} ${<} + +$(BIN)/%: $(OBJ)/%.o | $(BIN) + $(Q)echo " LD ${*}" && \ + ${CC} -o ${@} $(filter %.o %.a,$^) \ + ${EXTRA_LDFLAGS} ${BASE_LDFLAGS} ${LDFLAGS_TARGET} ${LDFLAGS} ${LIBS_${*}} \ + || echo Error: ${CC} -o $(filter %.o %.a,$^) \ + ${EXTRA_LDFLAGS} ${BASE_LDFLAGS} ${LDFLAGS_TARGET} ${LDFLAGS} ${LIBS_${*}} + +ifeq (${shell uname},Linux) +define soname + "-Wl,-soname,$(1)" +endef +else +define soname +endef +endif + +$(LIB)/%.so.$(SOV) $(LIB)/%.so.$(VERSION).$(SOV) $(LIB)/%.so: | $(LIB) + $(Q)echo " LDSO $@" && \ + { \ + naked=${shell basename ${basename $@}}; \ + ${CC} -shared \ + ${call soname,$$naked} \ + -o $(LIB)/$$naked.$(VERSION).$(SOV) \ + $(filter %.o %.a,$^) \ + ${EXTRA_LDFLAGS} ${BASE_LDFLAGS} ${LDFLAGS} && \ + ln -sf $$naked.$(VERSION).$(SOV) ${LIB}/$$naked.$(SOV) && \ + ln -sf $$naked.$(SOV) ${LIB}/$$naked ; \ + } || echo ERROR: $@ -- relaunch with V=1 + +clean:: +# rm -rf $(OBJ) $(BIN)/$(TARGET) + rm -rf $(BUILD) + +# Include autogenerated dependencies +-include ${wildcard $(OBJ)/*.d} diff --git a/libmish/README.md b/libmish/README.md new file mode 100644 index 0000000..f9607b6 --- /dev/null +++ b/libmish/README.md @@ -0,0 +1,111 @@ + +## libmish TL;DR : +*libmish* is a library that allows you to add a command prompt to any of your own program. It captures the standard output and standard error file descriptor, create a log with this, and displays it back to you, with a command prompt. + +You can then add your own commands to interract with your (running) program. Oh, *libmish* can also serve this to incoming telnet sessions (on a custom port), so you can connect to detached processes too. + +## Demo +Consider this program. The only "new" things are the #include, and the mish_prepare() call. That gives you telnet access and will log all output, but not much else. + +```C +#include "mish.h" + +int cnt = 0; + +int main() +{ + mish_prepare(0); + + while (1) { + sleep(1); + printf("Count %d\n", cnt++); + } +} +``` + +Now add this at the bottom of the file: + +```C +/* And here is a command line action that can reset the 'cnt' variable */ +static void _test_set_cnt(void * param, int argc, const char * argv[]) +{ + if (argc > 1) { + cnt = atoi(argv[1]); + } else { + fprintf(stderr, + "%s: syntax 'set XXX' to set the variable\n", argv[0]); + } +} + +MISH_CMD_NAMES(set, "set"); +MISH_CMD_HELP(set, + "set 'cnt' variable", + "test command for libmish!"); +MISH_CMD_REGISTER(set, _test_set_cnt); +``` + +And here you go: +![Demo of libmish](doc/demo.gif) + +As you can see, the stderr output is colorized. The program also told you the telnet port to call into (but you can also see it via the 'env' command later on). + +Calling the 'set' command will change the main variable. Of course it doesn't been to be thread safe in this instance, if you want your command to run in a thread safe way, you have to use mish_cmd_poll() from your thread, this will run pending commands in your own context. + +## Ok what's going on here, why do I need this? +Let's say, you have that program that runs for days. Or months, or years, and it has it's log in a log file and all is very well, but sometime, you'd like to just *interract* with it, say, check statistics, internal state, or just change a parameter or so. Or just pet it for the good job it's doing. + +Traditionally, you'd just restart the program with new parameters, or use a *host* of other complicated methods to send commands to the running program, like signals, UNIX sockets and countless stuff like that. + +*libmish* allows you to that poking around, without having to bother that much about it. Just add *libmish*, register some of your own commands, and you'll be able to 'connect' to your running program, check it's output history (without having to deal with log files) and use your own commands on your own running program. + +## What does work? +Well, its' already quite useful: + + * You can browse the history of the log of your program with Beg/Page Up/Down/End + * You can telnet in, and check the log too. + * You can display command history and use control-P/N to navigate it + * You can easily "register" your commands, with their own 'help'. + * It only requires one single "mish_prepare(...)" call at the start of yout main() to work. + +## Security? What security? +Obviously, using mish in your program is an obvious security risk, you're +allowing anyone on that machine to temper with your program via telnet, there's no +safegards in place. *libmish* is really made for developement purpose on +machine that you trust. + +Also, as much as I don't think I code like a dork, I didn't go mega full paranoia on security in the internals, so there's bound checking, but I can almost guarantee there must be ways of fooling the various parsers into crashing. Again this was all written in the space of 3 days, so I went for the goalpost as a hare, not as a tank! + +If you want to make sure *libmish* is disabled on machine that you *don't* trust (ie, production), you can set an environment variable MISH_OFF=1 before launching the programs and it will prevent the library starting. But again, buyers beware. + +As to why I use a TCP port (bound to 127.0.0.1), well it's because: + + * I want to be able to use 'telnet' to connect... + * 'telnet' on linux doesn't handle UNIX sockets + * I need 'telnet' because it gives me the terminal window size. + +... otherwise, I wouldn't have! + +## Issues & todos & caveats +This is a brand new library, a whole ton of things works, but quite a few things don't, just yet. + +Some bits I know I want but didn't *need* and some I've tried to fix, but haven't spent enough time on it to nail them down. + +**TODO:** + + * Currently the main thread uses select(), because it's portable. Need to add an epool() alternative one for linux. + * Display a timestamp for lines in the backlog. + * Display some sort of progressy-bar thing at the bottom when navigating the log. + * Add a UNIX stream socket access, but we'll have to use socat/netcat, stty raw and some sort of helper command line. + * Make the backlog expire after X hours/days. A stamp is already collected, but not used. + +**BUGS:** + +* Find a way to cleany quit without screwing up the terminal settings (telnet). + - If you have that problem, use 'resize' or 'reset' to make your terminal work again. + - Or better, use 'screen telnet xxx yyy' as screen is awesome at cleaning up. + - or __betterer__, use the "dis" disconnect command, that works. + - Backlog navigation doesn't take into account line wrapping. + +## Why is it called *libmish* anyway, sounds silly. +Well since you think you're clever, "lib" is for library, "sh" is for *shell* and "mi" is for **me** aka, **michel** pronunced *me* *shell*. Geddit? + diff --git a/libmish/doc/Makefile b/libmish/doc/Makefile new file mode 100644 index 0000000..bb02aae --- /dev/null +++ b/libmish/doc/Makefile @@ -0,0 +1,21 @@ +# +# Copyright 2008, 2009 Michel Pollet +# +# This file is part of libmish. +# +# SPDX-License-Identifier: Apache-2.0 + +# For the callgraph, you need Graphviz, ruby and exuberant ctags. +# This is not generated in the normal code build + + +all: libmish_callgraph.pdf + +libmish_callgraph.pdf: + ctags -f .tags ../src/*.[ch] 2>/dev/null && \ + ruby ./tags_to_dot.rb .tags \ + ../src/*.c ../src/mish.h >.tags.dot && \ + dot -Tpdf .tags.dot -o $@ + +clean: + rm -f .tags* diff --git a/libmish/doc/demo.gif b/libmish/doc/demo.gif new file mode 100644 index 0000000000000000000000000000000000000000..1dd89f6b3b3031ca73934db91e7ee154d5ce849c GIT binary patch literal 1432512 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[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

      -kxze>lgw%bxU1_ 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 (sg=YBi<0lvUZ{GcYVm)C;GcAK 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 z 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%0A~?Pvdwi`k9Wk3``jX#Yriqv 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

      ES>2^g#l*b5Jv(A3gLJ;(`*&Tkg5(u1l>e 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 z QncMvYtE7!PTiQ-|_#EYQWk0vH^*Qra-h!WaqUeW29%@l~Y=OpZTM@nNVAf|=~ zF`DTpfQPA*)L9g?GHo{ji2k_~(&C@g z_M0Yoa2vs(O9B!f3ZlWeejVDM5-OrPk)qs0peov;A^M_CscRQn6cNgx30jI3=%0DW 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�l?dLJmO<6P2Jw5xy%z+l-6s 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

      v)B(3)U|e$2CWotB;j*Mr_{YN`;Se@Z;P2? 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 E0UIKXDF6Tf literal 0 HcmV?d00001 diff --git a/libmish/doc/libmish_callgraph.pdf b/libmish/doc/libmish_callgraph.pdf new file mode 100644 index 0000000000000000000000000000000000000000..c6fb1b30f5c33519062812e0d65d139df9b26990 GIT binary patch literal 21786 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

      oQMX-ro5(){+0b5bnOQO*ZKcqfrdfet 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 literal 0 HcmV?d00001 diff --git a/libmish/doc/tags_to_dot.rb b/libmish/doc/tags_to_dot.rb new file mode 100755 index 0000000..df04cd0 --- /dev/null +++ b/libmish/doc/tags_to_dot.rb @@ -0,0 +1,99 @@ +#!/usr/bin/ruby +# +# Copyright 2008, 2009 Michel Pollet +# +# This file is part of libmish. +# +# SPDX-License-Identifier: Apache-2.0 + +$files = Hash.new +$syms = Hash.new + +tags = File.new(ARGV[0]) + +key = Array.new + +while !tags.eof? + next unless tags.readline.chomp.match(/([^\t]+)\t([^\t]+)\t(.*)\$\/;"\t([^\t]+)/); + key[0] = $1; + key[1] = $2; + key[3] = $3; + key[4] = $4; + + next if key[4] == 'm' or key[4] == 't' or key[4] == 's' or key[4] == 'e' or key[4] == 'v'; + next if key[0].match(/[us]?int[0-9]+_t/); + next if key[0] == "ROM_BASED"; + + key[1].gsub!(/.*\/|\.[ch]$/,""); + + unless $files.key? key[1] + $files[key[1]] = Hash.new + end + unless $files[key[1]].key? key[0] + $files[key[1]][key[0]] = Hash.new + $syms[key[0]] = key[1] + end + #puts key[0] + " = '#{key[4]}'" +end + +puts "digraph dump { node [shape=rect]; compound=true; nodesep=.1; ranksep=2; rankdir=LR; concentrate=true; " + +modules = Hash.new; +links = Array.new; + +1.upto(ARGV.length-1) { |i| + + use = File.new(ARGV[i]) +# puts "<<<<<<<>>" + line + words = line.split(/[ \t]+/); + words.each { |w| + if $syms.key? w and $syms[w] != fil + unless $files[$syms[w]][w].key? fil + # puts w + " is in " + $syms[w] + $files[$syms[w]][w][fil] = 1 + + sym=w + unless modules.key? fil + modules[fil] = Array.new + end + modules[fil] += [ "\"cc_#{fil}_#{sym}\" [label=\"#{sym}\",color=\"gray\",height=\".08\",style=dotted];" ] + links += ["\"cc_#{fil}_#{sym}\" -> \"dd_#{$syms[w]}_#{sym}\";"] + end + end + } + end +} + +$files.keys.each { |fil| +# puts "File #{fil} ?" + $files[fil].keys.each { |sym| + # puts "\tSym #{sym} : #{$files[fil][sym].length} ?" + if $files[fil][sym].length > 0 + unless modules.key? fil + modules[fil] = Array.new + end + modules[fil] += [ "\"dd_#{fil}_#{sym}\" [label=\"#{sym}\"];" ] + end + } +} +modules.keys.each {|fil| + puts "\tsubgraph cluster_#{fil} {\n\t\tlabel=\"#{fil}\"; fontsize=\"18\"; " + modules[fil].each { |lin| + puts "\t\t#{lin}" + } + puts "\t}" +} +links.each { |lin| + puts "\t#{lin}" +} +puts "}" diff --git a/libmish/mish.pc b/libmish/mish.pc new file mode 100644 index 0000000..4b3a409 --- /dev/null +++ b/libmish/mish.pc @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: Apache-2.0 + +mish.pc: +prefix=PREFIX +exec_prefix=${prefix} +includedir=${prefix}/include +libdir=${exec_prefix}/lib + +Name: libmish +Description: Adds command prompt for your program(s) +Version: VERSION +Cflags: -I${includedir} +Libs: -L${libdir} -lmish -lrt diff --git a/libmish/src/bsd_queue.h b/libmish/src/bsd_queue.h new file mode 100644 index 0000000..2e16cbc --- /dev/null +++ b/libmish/src/bsd_queue.h @@ -0,0 +1,860 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)queue.h 8.5 (Berkeley) 8/20/94 + * $FreeBSD$ + */ + +#ifndef _SYS_QUEUE_H_ +#define _SYS_QUEUE_H_ + +//#include + +/* + * This file defines four types of data structures: singly-linked lists, + * singly-linked tail queues, lists and tail queues. + * + * A singly-linked list is headed by a single forward pointer. The elements + * are singly linked for minimum space and pointer manipulation overhead at + * the expense of O(n) removal for arbitrary elements. New elements can be + * added to the list after an existing element or at the head of the list. + * Elements being removed from the head of the list should use the explicit + * macro for this purpose for optimum efficiency. A singly-linked list may + * only be traversed in the forward direction. Singly-linked lists are ideal + * for applications with large datasets and few or no removals or for + * implementing a LIFO queue. + * + * A singly-linked tail queue is headed by a pair of pointers, one to the + * head of the list and the other to the tail of the list. The elements are + * singly linked for minimum space and pointer manipulation overhead at the + * expense of O(n) removal for arbitrary elements. New elements can be added + * to the list after an existing element, at the head of the list, or at the + * end of the list. Elements being removed from the head of the tail queue + * should use the explicit macro for this purpose for optimum efficiency. + * A singly-linked tail queue may only be traversed in the forward direction. + * Singly-linked tail queues are ideal for applications with large datasets + * and few or no removals or for implementing a FIFO queue. + * + * A list is headed by a single forward pointer (or an array of forward + * pointers for a hash table header). The elements are doubly linked + * so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before + * or after an existing element or at the head of the list. A list + * may be traversed in either direction. + * + * A tail queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or + * after an existing element, at the head of the list, or at the end of + * the list. A tail queue may be traversed in either direction. + * + * For details on the use of these macros, see the queue(3) manual page. + * + * Below is a summary of implemented functions where: + * + means the macro is available + * - means the macro is not available + * s means the macro is available but is slow (runs in O(n) time) + * + * SLIST LIST STAILQ TAILQ + * _HEAD + + + + + * _CLASS_HEAD + + + + + * _HEAD_INITIALIZER + + + + + * _ENTRY + + + + + * _CLASS_ENTRY + + + + + * _INIT + + + + + * _EMPTY + + + + + * _FIRST + + + + + * _NEXT + + + + + * _PREV - + - + + * _LAST - - + + + * _FOREACH + + + + + * _FOREACH_FROM + + + + + * _FOREACH_SAFE + + + + + * _FOREACH_FROM_SAFE + + + + + * _FOREACH_REVERSE - - - + + * _FOREACH_REVERSE_FROM - - - + + * _FOREACH_REVERSE_SAFE - - - + + * _FOREACH_REVERSE_FROM_SAFE - - - + + * _INSERT_HEAD + + + + + * _INSERT_BEFORE - + - + + * _INSERT_AFTER + + + + + * _INSERT_TAIL - - + + + * _CONCAT s s + + + * _REMOVE_AFTER + - + - + * _REMOVE_HEAD + - + - + * _REMOVE s + s + + * _SWAP + + + + + * + */ +#ifdef QUEUE_MACRO_DEBUG +#warn Use QUEUE_MACRO_DEBUG_TRACE and/or QUEUE_MACRO_DEBUG_TRASH +#define QUEUE_MACRO_DEBUG_TRACE +#define QUEUE_MACRO_DEBUG_TRASH +#endif + +#ifdef QUEUE_MACRO_DEBUG_TRACE +/* Store the last 2 places the queue element or head was altered */ +struct qm_trace { + unsigned long lastline; + unsigned long prevline; + const char *lastfile; + const char *prevfile; +}; + +#define TRACEBUF struct qm_trace trace; +#define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } , + +#define QMD_TRACE_HEAD(head) do { \ + (head)->trace.prevline = (head)->trace.lastline; \ + (head)->trace.prevfile = (head)->trace.lastfile; \ + (head)->trace.lastline = __LINE__; \ + (head)->trace.lastfile = __FILE__; \ +} while (0) + +#define QMD_TRACE_ELEM(elem) do { \ + (elem)->trace.prevline = (elem)->trace.lastline; \ + (elem)->trace.prevfile = (elem)->trace.lastfile; \ + (elem)->trace.lastline = __LINE__; \ + (elem)->trace.lastfile = __FILE__; \ +} while (0) + +#else /* !QUEUE_MACRO_DEBUG_TRACE */ +#define QMD_TRACE_ELEM(elem) +#define QMD_TRACE_HEAD(head) +#define TRACEBUF +#define TRACEBUF_INITIALIZER +#endif /* QUEUE_MACRO_DEBUG_TRACE */ + +#ifdef QUEUE_MACRO_DEBUG_TRASH +#define TRASHIT(x) do {(x) = (void *)-1;} while (0) +#define QMD_IS_TRASHED(x) ((x) == (void *)(intptr_t)-1) +#else /* !QUEUE_MACRO_DEBUG_TRASH */ +#define TRASHIT(x) +#define QMD_IS_TRASHED(x) 0 +#endif /* QUEUE_MACRO_DEBUG_TRASH */ + +#if defined(QUEUE_MACRO_DEBUG_TRACE) || defined(QUEUE_MACRO_DEBUG_TRASH) +#define QMD_SAVELINK(name, link) void **name = (void *)&(link) +#else /* !QUEUE_MACRO_DEBUG_TRACE && !QUEUE_MACRO_DEBUG_TRASH */ +#define QMD_SAVELINK(name, link) +#endif /* QUEUE_MACRO_DEBUG_TRACE || QUEUE_MACRO_DEBUG_TRASH */ + +#ifdef __cplusplus +/* + * In C++ there can be structure lists and class lists: + */ +#define QUEUE_TYPEOF(type) type +#else +#define QUEUE_TYPEOF(type) struct type +#endif + +/* + * Singly-linked List declarations. + */ +#define SLIST_HEAD(name, type) \ +struct name { \ + struct type *slh_first; /* first element */ \ +} + +#define SLIST_CLASS_HEAD(name, type) \ +struct name { \ + class type *slh_first; /* first element */ \ +} + +#define SLIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define SLIST_ENTRY(type) \ +struct { \ + struct type *sle_next; /* next element */ \ +} + +#define SLIST_CLASS_ENTRY(type) \ +struct { \ + class type *sle_next; /* next element */ \ +} + +/* + * Singly-linked List functions. + */ +#if (defined(_KERNEL) && defined(INVARIANTS)) +#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) do { \ + if (*(prevp) != (elm)) \ + panic("Bad prevptr *(%p) == %p != %p", \ + (prevp), *(prevp), (elm)); \ +} while (0) +#else +#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) +#endif + +#define SLIST_CONCAT(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head1); \ + if (curelm == NULL) { \ + if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \ + SLIST_INIT(head2); \ + } else if (SLIST_FIRST(head2) != NULL) { \ + while (SLIST_NEXT(curelm, field) != NULL) \ + curelm = SLIST_NEXT(curelm, field); \ + SLIST_NEXT(curelm, field) = SLIST_FIRST(head2); \ + SLIST_INIT(head2); \ + } \ +} while (0) + +#define SLIST_EMPTY(head) ((head)->slh_first == NULL) + +#define SLIST_FIRST(head) ((head)->slh_first) + +#define SLIST_FOREACH(var, head, field) \ + for ((var) = SLIST_FIRST((head)); \ + (var); \ + (var) = SLIST_NEXT((var), field)) + +#define SLIST_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ + (var); \ + (var) = SLIST_NEXT((var), field)) + +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = SLIST_FIRST((head)); \ + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ + for ((varp) = &SLIST_FIRST((head)); \ + ((var) = *(varp)) != NULL; \ + (varp) = &SLIST_NEXT((var), field)) + +#define SLIST_INIT(head) do { \ + SLIST_FIRST((head)) = NULL; \ +} while (0) + +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ + SLIST_NEXT((slistelm), field) = (elm); \ +} while (0) + +#define SLIST_INSERT_HEAD(head, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ + SLIST_FIRST((head)) = (elm); \ +} while (0) + +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) + +#define SLIST_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ + if (SLIST_FIRST((head)) == (elm)) { \ + SLIST_REMOVE_HEAD((head), field); \ + } \ + else { \ + QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \ + while (SLIST_NEXT(curelm, field) != (elm)) \ + curelm = SLIST_NEXT(curelm, field); \ + SLIST_REMOVE_AFTER(curelm, field); \ + } \ + TRASHIT(*oldnext); \ +} while (0) + +#define SLIST_REMOVE_AFTER(elm, field) do { \ + SLIST_NEXT(elm, field) = \ + SLIST_NEXT(SLIST_NEXT(elm, field), field); \ +} while (0) + +#define SLIST_REMOVE_HEAD(head, field) do { \ + SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ +} while (0) + +#define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \ + QMD_SLIST_CHECK_PREVPTR(prevp, elm); \ + *(prevp) = SLIST_NEXT(elm, field); \ + TRASHIT((elm)->field.sle_next); \ +} while (0) + +#define SLIST_SWAP(head1, head2, type) do { \ + QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \ + SLIST_FIRST(head1) = SLIST_FIRST(head2); \ + SLIST_FIRST(head2) = swap_first; \ +} while (0) + +/* + * Singly-linked Tail queue declarations. + */ +#define STAILQ_HEAD(name, type) \ +struct name { \ + struct type *stqh_first;/* first element */ \ + struct type **stqh_last;/* addr of last next element */ \ +} + +#define STAILQ_CLASS_HEAD(name, type) \ +struct name { \ + class type *stqh_first; /* first element */ \ + class type **stqh_last; /* addr of last next element */ \ +} + +#define STAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).stqh_first } + +#define STAILQ_ENTRY(type) \ +struct { \ + struct type *stqe_next; /* next element */ \ +} + +#define STAILQ_CLASS_ENTRY(type) \ +struct { \ + class type *stqe_next; /* next element */ \ +} + +/* + * Singly-linked Tail queue functions. + */ +#define STAILQ_CONCAT(head1, head2) do { \ + if (!STAILQ_EMPTY((head2))) { \ + *(head1)->stqh_last = (head2)->stqh_first; \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_INIT((head2)); \ + } \ +} while (0) + +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) + +#define STAILQ_FIRST(head) ((head)->stqh_first) + +#define STAILQ_FOREACH(var, head, field) \ + for((var) = STAILQ_FIRST((head)); \ + (var); \ + (var) = STAILQ_NEXT((var), field)) + +#define STAILQ_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ + (var); \ + (var) = STAILQ_NEXT((var), field)) + +#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = STAILQ_FIRST((head)); \ + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define STAILQ_INIT(head) do { \ + STAILQ_FIRST((head)) = NULL; \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ +} while (0) + +#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_NEXT((tqelm), field) = (elm); \ +} while (0) + +#define STAILQ_INSERT_HEAD(head, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_FIRST((head)) = (elm); \ +} while (0) + +#define STAILQ_INSERT_TAIL(head, elm, field) do { \ + STAILQ_NEXT((elm), field) = NULL; \ + *(head)->stqh_last = (elm); \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ +} while (0) + +#define STAILQ_LAST(head, type, field) \ + (STAILQ_EMPTY((head)) ? NULL : \ + __containerof((head)->stqh_last, \ + QUEUE_TYPEOF(type), field.stqe_next)) + +#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) + +#define STAILQ_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ + if (STAILQ_FIRST((head)) == (elm)) { \ + STAILQ_REMOVE_HEAD((head), field); \ + } \ + else { \ + QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \ + while (STAILQ_NEXT(curelm, field) != (elm)) \ + curelm = STAILQ_NEXT(curelm, field); \ + STAILQ_REMOVE_AFTER(head, curelm, field); \ + } \ + TRASHIT(*oldnext); \ +} while (0) + +#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ + if ((STAILQ_NEXT(elm, field) = \ + STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ +} while (0) + +#define STAILQ_REMOVE_HEAD(head, field) do { \ + if ((STAILQ_FIRST((head)) = \ + STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ +} while (0) + +#define STAILQ_SWAP(head1, head2, type) do { \ + QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \ + QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \ + STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_FIRST(head2) = swap_first; \ + (head2)->stqh_last = swap_last; \ + if (STAILQ_EMPTY(head1)) \ + (head1)->stqh_last = &STAILQ_FIRST(head1); \ + if (STAILQ_EMPTY(head2)) \ + (head2)->stqh_last = &STAILQ_FIRST(head2); \ +} while (0) + + +/* + * List declarations. + */ +#define LIST_HEAD(name, type) \ +struct name { \ + struct type *lh_first; /* first element */ \ +} + +#define LIST_CLASS_HEAD(name, type) \ +struct name { \ + class type *lh_first; /* first element */ \ +} + +#define LIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define LIST_ENTRY(type) \ +struct { \ + struct type *le_next; /* next element */ \ + struct type **le_prev; /* address of previous next element */ \ +} + +#define LIST_CLASS_ENTRY(type) \ +struct { \ + class type *le_next; /* next element */ \ + class type **le_prev; /* address of previous next element */ \ +} + +/* + * List functions. + */ + +#if (defined(_KERNEL) && defined(INVARIANTS)) +/* + * QMD_LIST_CHECK_HEAD(LIST_HEAD *head, LIST_ENTRY NAME) + * + * If the list is non-empty, validates that the first element of the list + * points back at 'head.' + */ +#define QMD_LIST_CHECK_HEAD(head, field) do { \ + if (LIST_FIRST((head)) != NULL && \ + LIST_FIRST((head))->field.le_prev != \ + &LIST_FIRST((head))) \ + panic("Bad list head %p first->prev != head", (head)); \ +} while (0) + +/* + * QMD_LIST_CHECK_NEXT(TYPE *elm, LIST_ENTRY NAME) + * + * If an element follows 'elm' in the list, validates that the next element + * points back at 'elm.' + */ +#define QMD_LIST_CHECK_NEXT(elm, field) do { \ + if (LIST_NEXT((elm), field) != NULL && \ + LIST_NEXT((elm), field)->field.le_prev != \ + &((elm)->field.le_next)) \ + panic("Bad link elm %p next->prev != elm", (elm)); \ +} while (0) + +/* + * QMD_LIST_CHECK_PREV(TYPE *elm, LIST_ENTRY NAME) + * + * Validates that the previous element (or head of the list) points to 'elm.' + */ +#define QMD_LIST_CHECK_PREV(elm, field) do { \ + if (*(elm)->field.le_prev != (elm)) \ + panic("Bad link elm %p prev->next != elm", (elm)); \ +} while (0) +#else +#define QMD_LIST_CHECK_HEAD(head, field) +#define QMD_LIST_CHECK_NEXT(elm, field) +#define QMD_LIST_CHECK_PREV(elm, field) +#endif /* (_KERNEL && INVARIANTS) */ + +#define LIST_CONCAT(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *curelm = LIST_FIRST(head1); \ + if (curelm == NULL) { \ + if ((LIST_FIRST(head1) = LIST_FIRST(head2)) != NULL) { \ + LIST_FIRST(head2)->field.le_prev = \ + &LIST_FIRST((head1)); \ + LIST_INIT(head2); \ + } \ + } else if (LIST_FIRST(head2) != NULL) { \ + while (LIST_NEXT(curelm, field) != NULL) \ + curelm = LIST_NEXT(curelm, field); \ + LIST_NEXT(curelm, field) = LIST_FIRST(head2); \ + LIST_FIRST(head2)->field.le_prev = &LIST_NEXT(curelm, field); \ + LIST_INIT(head2); \ + } \ +} while (0) + +#define LIST_EMPTY(head) ((head)->lh_first == NULL) + +#define LIST_FIRST(head) ((head)->lh_first) + +#define LIST_FOREACH(var, head, field) \ + for ((var) = LIST_FIRST((head)); \ + (var); \ + (var) = LIST_NEXT((var), field)) + +#define LIST_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ + (var); \ + (var) = LIST_NEXT((var), field)) + +#define LIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = LIST_FIRST((head)); \ + (var) && ((tvar) = LIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ + (var) && ((tvar) = LIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define LIST_INIT(head) do { \ + LIST_FIRST((head)) = NULL; \ +} while (0) + +#define LIST_INSERT_AFTER(listelm, elm, field) do { \ + QMD_LIST_CHECK_NEXT(listelm, field); \ + if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ + LIST_NEXT((listelm), field)->field.le_prev = \ + &LIST_NEXT((elm), field); \ + LIST_NEXT((listelm), field) = (elm); \ + (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ +} while (0) + +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ + QMD_LIST_CHECK_PREV(listelm, field); \ + (elm)->field.le_prev = (listelm)->field.le_prev; \ + LIST_NEXT((elm), field) = (listelm); \ + *(listelm)->field.le_prev = (elm); \ + (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ +} while (0) + +#define LIST_INSERT_HEAD(head, elm, field) do { \ + QMD_LIST_CHECK_HEAD((head), field); \ + if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ + LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ + LIST_FIRST((head)) = (elm); \ + (elm)->field.le_prev = &LIST_FIRST((head)); \ +} while (0) + +#define LIST_NEXT(elm, field) ((elm)->field.le_next) + +#define LIST_PREV(elm, head, type, field) \ + ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \ + __containerof((elm)->field.le_prev, \ + QUEUE_TYPEOF(type), field.le_next)) + +#define LIST_REMOVE(elm, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.le_next); \ + QMD_SAVELINK(oldprev, (elm)->field.le_prev); \ + QMD_LIST_CHECK_NEXT(elm, field); \ + QMD_LIST_CHECK_PREV(elm, field); \ + if (LIST_NEXT((elm), field) != NULL) \ + LIST_NEXT((elm), field)->field.le_prev = \ + (elm)->field.le_prev; \ + *(elm)->field.le_prev = LIST_NEXT((elm), field); \ + TRASHIT(*oldnext); \ + TRASHIT(*oldprev); \ +} while (0) + +#define LIST_SWAP(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \ + LIST_FIRST((head1)) = LIST_FIRST((head2)); \ + LIST_FIRST((head2)) = swap_tmp; \ + if ((swap_tmp = LIST_FIRST((head1))) != NULL) \ + swap_tmp->field.le_prev = &LIST_FIRST((head1)); \ + if ((swap_tmp = LIST_FIRST((head2))) != NULL) \ + swap_tmp->field.le_prev = &LIST_FIRST((head2)); \ +} while (0) + +/* + * Tail queue declarations. + */ +#define TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_HEAD(name, type) \ +struct name { \ + class type *tqh_first; /* first element */ \ + class type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER } + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_ENTRY(type) \ +struct { \ + class type *tqe_next; /* next element */ \ + class type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +/* + * Tail queue functions. + */ +#if (defined(_KERNEL) && defined(INVARIANTS)) +/* + * QMD_TAILQ_CHECK_HEAD(TAILQ_HEAD *head, TAILQ_ENTRY NAME) + * + * If the tailq is non-empty, validates that the first element of the tailq + * points back at 'head.' + */ +#define QMD_TAILQ_CHECK_HEAD(head, field) do { \ + if (!TAILQ_EMPTY(head) && \ + TAILQ_FIRST((head))->field.tqe_prev != \ + &TAILQ_FIRST((head))) \ + panic("Bad tailq head %p first->prev != head", (head)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_TAIL(TAILQ_HEAD *head, TAILQ_ENTRY NAME) + * + * Validates that the tail of the tailq is a pointer to pointer to NULL. + */ +#define QMD_TAILQ_CHECK_TAIL(head, field) do { \ + if (*(head)->tqh_last != NULL) \ + panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_NEXT(TYPE *elm, TAILQ_ENTRY NAME) + * + * If an element follows 'elm' in the tailq, validates that the next element + * points back at 'elm.' + */ +#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \ + if (TAILQ_NEXT((elm), field) != NULL && \ + TAILQ_NEXT((elm), field)->field.tqe_prev != \ + &((elm)->field.tqe_next)) \ + panic("Bad link elm %p next->prev != elm", (elm)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_PREV(TYPE *elm, TAILQ_ENTRY NAME) + * + * Validates that the previous element (or head of the tailq) points to 'elm.' + */ +#define QMD_TAILQ_CHECK_PREV(elm, field) do { \ + if (*(elm)->field.tqe_prev != (elm)) \ + panic("Bad link elm %p prev->next != elm", (elm)); \ +} while (0) +#else +#define QMD_TAILQ_CHECK_HEAD(head, field) +#define QMD_TAILQ_CHECK_TAIL(head, headname) +#define QMD_TAILQ_CHECK_NEXT(elm, field) +#define QMD_TAILQ_CHECK_PREV(elm, field) +#endif /* (_KERNEL && INVARIANTS) */ + +#define TAILQ_CONCAT(head1, head2, field) do { \ + if (!TAILQ_EMPTY(head2)) { \ + *(head1)->tqh_last = (head2)->tqh_first; \ + (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ + (head1)->tqh_last = (head2)->tqh_last; \ + TAILQ_INIT((head2)); \ + QMD_TRACE_HEAD(head1); \ + QMD_TRACE_HEAD(head2); \ + } \ +} while (0) + +#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) + +#define TAILQ_FIRST(head) ((head)->tqh_first) + +#define TAILQ_FOREACH(var, head, field) \ + for ((var) = TAILQ_FIRST((head)); \ + (var); \ + (var) = TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ + (var); \ + (var) = TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = TAILQ_FIRST((head)); \ + (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ + (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for ((var) = TAILQ_LAST((head), headname); \ + (var); \ + (var) = TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ + for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var); \ + (var) = TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ + for ((var) = TAILQ_LAST((head), headname); \ + (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \ + for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ + (var) = (tvar)) + +#define TAILQ_INIT(head) do { \ + TAILQ_FIRST((head)) = NULL; \ + (head)->tqh_last = &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ +} while (0) + +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + QMD_TAILQ_CHECK_NEXT(listelm, field); \ + if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ + TAILQ_NEXT((elm), field)->field.tqe_prev = \ + &TAILQ_NEXT((elm), field); \ + else { \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + } \ + TAILQ_NEXT((listelm), field) = (elm); \ + (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + QMD_TAILQ_CHECK_PREV(listelm, field); \ + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ + TAILQ_NEXT((elm), field) = (listelm); \ + *(listelm)->field.tqe_prev = (elm); \ + (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ + QMD_TAILQ_CHECK_HEAD(head, field); \ + if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ + TAILQ_FIRST((head))->field.tqe_prev = \ + &TAILQ_NEXT((elm), field); \ + else \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + TAILQ_FIRST((head)) = (elm); \ + (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ + QMD_TAILQ_CHECK_TAIL(head, field); \ + TAILQ_NEXT((elm), field) = NULL; \ + (elm)->field.tqe_prev = (head)->tqh_last; \ + *(head)->tqh_last = (elm); \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) + +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) + +#define TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) + +#define TAILQ_REMOVE(head, elm, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ + QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ + QMD_TAILQ_CHECK_NEXT(elm, field); \ + QMD_TAILQ_CHECK_PREV(elm, field); \ + if ((TAILQ_NEXT((elm), field)) != NULL) \ + TAILQ_NEXT((elm), field)->field.tqe_prev = \ + (elm)->field.tqe_prev; \ + else { \ + (head)->tqh_last = (elm)->field.tqe_prev; \ + QMD_TRACE_HEAD(head); \ + } \ + *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ + TRASHIT(*oldnext); \ + TRASHIT(*oldprev); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_SWAP(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \ + QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \ + (head1)->tqh_first = (head2)->tqh_first; \ + (head1)->tqh_last = (head2)->tqh_last; \ + (head2)->tqh_first = swap_first; \ + (head2)->tqh_last = swap_last; \ + if ((swap_first = (head1)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head1)->tqh_first; \ + else \ + (head1)->tqh_last = &(head1)->tqh_first; \ + if ((swap_first = (head2)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head2)->tqh_first; \ + else \ + (head2)->tqh_last = &(head2)->tqh_first; \ +} while (0) + +#endif /* !_SYS_QUEUE_H_ */ diff --git a/libmish/src/fifo_declare.h b/libmish/src/fifo_declare.h new file mode 100644 index 0000000..73706a5 --- /dev/null +++ b/libmish/src/fifo_declare.h @@ -0,0 +1,211 @@ +/* + fido_declare.h + Copyright (C) 2003-2012 Michel Pollet + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/* + * FIFO helpers, aka circular buffers + * + * these macros define accessories for FIFOs of any name, type and + * any (power of two) size + */ + +#ifndef __FIFO_DECLARE__ +#define __FIFO_DECLARE__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + doing a : + DECLARE_FIFO(uint8_t, myfifo, 128); + + will declare : + enum : myfifo_overflow_f + type : myfifo_t + functions: + // write a byte into the fifo, return 1 if there was room, 0 if there wasn't + int myfifo_write(myfifo_t *c, uint8_t b); + // reads a byte from the fifo, return 0 if empty. Use myfifo_isempty() to check beforehand + uint8_t myfifo_read(myfifo_t *c); + int myfifo_isfull(myfifo_t *c); + int myfifo_isempty(myfifo_t *c); + // returns number of items to read now + uint16_t myfifo_get_read_size(myfifo_t *c); + // read item at offset o from read cursor, no cursor advance + uint8_t myfifo_read_at(myfifo_t *c, uint16_t o); + // write b at offset o compared to current write cursor, no cursor advance + void myfifo_write_at(myfifo_t *c, uint16_t o, uint8_t b); + + In your .c you need to 'implement' the fifo: + DEFINE_FIFO(uint8_t, myfifo) + + To use the fifo, you must declare at least one : + myfifo_t fifo = FIFO_NULL; + + while (!myfifo_isfull(&fifo)) + myfifo_write(&fifo, 0xaa); + .... + while (!myfifo_isempty(&fifo)) + b = myfifo_read(&fifo); + */ + +#include + +#if __AVR__ +#define FIFO_CURSOR_TYPE uint8_t +#define FIFO_BOOL_TYPE char +#define FIFO_INLINE +#define FIFO_SYNC +#endif + +#ifndef FIFO_CURSOR_TYPE +#define FIFO_CURSOR_TYPE uint16_t +#endif +#ifndef FIFO_BOOL_TYPE +#define FIFO_BOOL_TYPE int +#endif +#ifndef FIFO_INLINE +#define FIFO_INLINE inline +#endif + +/* We should not need volatile */ +#ifndef FIFO_VOLATILE +#define FIFO_VOLATILE +#endif +#ifndef FIFO_SYNC +#define FIFO_SYNC __sync_synchronize() +#endif + +#ifndef FIFO_ZERO_INIT +#define FIFO_ZERO_INIT {0} +#endif +#define FIFO_NULL { FIFO_ZERO_INIT, 0, 0, 0 } + +/* New compilers don't like unused static functions. However, + * we do like 'static inlines' for these small accessors, + * so we mark them as 'unused'. It stops it complaining */ +#ifdef __GNUC__ +#define FIFO_DECL static __attribute__ ((unused)) +#else +#define FIFO_DECL static +#endif + +#define DECLARE_FIFO(__type, __name, __size) \ +enum { __name##_overflow_f = (1 << 0) }; \ +enum { __name##_fifo_size = (__size) }; \ +typedef struct __name##_t { \ + __type buffer[__name##_fifo_size]; \ + FIFO_VOLATILE FIFO_CURSOR_TYPE read; \ + FIFO_VOLATILE FIFO_CURSOR_TYPE write; \ + FIFO_VOLATILE uint8_t flags; \ +} __name##_t + +/* + * This allow declaring a FIFO without the functions that use + * pass-by-value arguments. The compiler isn't too happy using + * some of the variable length array these days and outputs a warning. + * Also, it is not efficient, so if your FIFO member is a big struct, + * you should use the pass by pointer instead. + */ +#define DEFINE_PTR_FIFO(__type, __name) \ +FIFO_DECL FIFO_INLINE FIFO_BOOL_TYPE __name##_isfull(__name##_t *c)\ +{\ + FIFO_CURSOR_TYPE next = (c->write + 1) & (__name##_fifo_size-1);\ + return c->read == next;\ +}\ +FIFO_DECL FIFO_INLINE FIFO_BOOL_TYPE __name##_isempty(__name##_t * c)\ +{\ + return c->read == c->write;\ +}\ +FIFO_DECL FIFO_INLINE FIFO_CURSOR_TYPE __name##_get_read_size(__name##_t *c)\ +{\ + return ((c->write + __name##_fifo_size) - c->read) & (__name##_fifo_size-1);\ +}\ +FIFO_DECL FIFO_INLINE FIFO_CURSOR_TYPE __name##_get_write_size(__name##_t *c)\ +{\ + return (__name##_fifo_size-1) - __name##_get_read_size(c);\ +}\ +FIFO_DECL FIFO_INLINE void __name##_read_offset(__name##_t *c, FIFO_CURSOR_TYPE o)\ +{\ + FIFO_SYNC; \ + c->read = (c->read + o) & (__name##_fifo_size-1);\ +}\ +FIFO_DECL FIFO_INLINE void __name##_write_offset(__name##_t *c, FIFO_CURSOR_TYPE o)\ +{\ + FIFO_SYNC; \ + c->write = (c->write + o) & (__name##_fifo_size-1);\ +}\ +FIFO_DECL FIFO_INLINE void __name##_reset(__name##_t *c)\ +{\ + FIFO_SYNC; \ + c->read = c->write = c->flags = 0;\ +}\ +FIFO_DECL FIFO_INLINE __type * __name##_write_ptr(__name##_t * c) \ +{\ + return c->buffer + c->write;\ +}\ +FIFO_DECL FIFO_INLINE __type * __name##_read_ptr(__name##_t * c) \ +{\ + return c->buffer + c->read;\ +}\ +struct __name##_t + +/* + * And this declares the whole FIFO, including the pass-by-value functions + */ +#define DEFINE_FIFO(__type, __name) \ +DEFINE_PTR_FIFO(__type, __name); \ +FIFO_DECL FIFO_INLINE FIFO_BOOL_TYPE __name##_write(__name##_t * c, __type b)\ +{\ + FIFO_CURSOR_TYPE now = c->write;\ + FIFO_CURSOR_TYPE next = (now + 1) & (__name##_fifo_size-1);\ + if (c->read != next) { \ + c->buffer[now] = b;\ + FIFO_SYNC; \ + c->write = next;\ + return 1;\ + }\ + return 0;\ +}\ +FIFO_DECL FIFO_INLINE __type __name##_read(__name##_t * c)\ +{\ + __type res = FIFO_ZERO_INIT; \ + FIFO_CURSOR_TYPE read = c->read;\ + if (read == c->write)\ + return res;\ + res = c->buffer[read];\ + FIFO_SYNC; \ + c->read = (read + 1) & (__name##_fifo_size-1);\ + return res;\ +}\ +FIFO_DECL FIFO_INLINE __type __name##_read_at(__name##_t *c, FIFO_CURSOR_TYPE o)\ +{\ + return c->buffer[(c->read + o) & (__name##_fifo_size-1)];\ +}\ +FIFO_DECL FIFO_INLINE void __name##_write_at(__name##_t *c, FIFO_CURSOR_TYPE o, __type b)\ +{\ + c->buffer[(c->write + o) & (__name##_fifo_size-1)] = b;\ +}\ +struct __name##_t + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/libmish/src/minipt.h b/libmish/src/minipt.h new file mode 100644 index 0000000..8ca7d21 --- /dev/null +++ b/libmish/src/minipt.h @@ -0,0 +1,138 @@ +/* + * minipt.h + * + * Created on: 1 Apr 2018 + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef MPTOOLS_INCLUDE_MINIPT_H_ +#define MPTOOLS_INCLUDE_MINIPT_H_ + +/* + * Mini Protothread. + * + * A thread or a coroutine would use a stack; this won't, + * Use an old gcc trick of being able to goto and indirect label. + * There are a few caveats: no persistent local variables, as you can't + * have a consistent stack frame. It's easy to work around tho. + */ +#define _CONCAT2(s1, s2) s1##s2 +#define _CONCAT(s1, s2) _CONCAT2(s1, s2) + +/* this wierd thing with the union is for gcc 12, which doesn't like us + * storing the address of a 'local variable' (which is the label!) */ +static inline void _set_gcc_ptr_workaround(void **d, void *s) { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdangling-pointer" + *d = s; +#pragma GCC diagnostic pop +} +#define pt_start(_pt) do { \ + if (_pt) goto *_pt; \ + } while (0); +#define pt_end(_pt) do { \ + (_pt) = NULL; \ + _pt_exit: ; \ + } while(0); +#define pt_yield(_pt) do { \ + _set_gcc_ptr_workaround(&(_pt), &&_CONCAT(_label, __LINE__));\ + goto _pt_exit;\ + _CONCAT(_label, __LINE__): ; \ + } while (0); + +#define pt_wait(_pt, _condition) do { \ + while (!(_condition)) \ + pt_yield(_pt); \ + } while (0); + + +#ifdef NEVER +/* + * This version is superior as it allows calling functions and keeping + * a context, but I never actually had a /need/ for this, yet + */ + +struct pt_t { + unsigned int sp; + void * st[32]; + void * ctx[32]; +} pt_t; + +#define pt_start(_pt) do { \ + if ((_pt)->st[(_pt)->sp]) goto *((_pt)->st[(_pt)->sp]); \ + } while (0); +#define pt_end(_pt) do { (_pt)->st[(_pt)->sp] = NULL; return; } while(0); +#define pt_yield(_pt) do { \ + (_pt)->st[(_pt)->sp] = &&_CONCAT(_label, __LINE__);\ + return;\ + _CONCAT(_label, __LINE__): ; \ + } while (0); +#define pt_wait(_pt, _condition) do { \ + while (!(_condition)) \ + pt_yield(_pt); \ + } while (0); +#define pt_call(_pt, _func) do { \ + (_pt)->sp++; \ + (_pt)->st[(_pt)->sp] = NULL; \ + do { \ + _func(_pt); \ + } while ((_pt)->st[(_pt)->sp]); \ + (_pt)->sp--; \ + } while (0); +#define pt_ctx(_pt) ((_pt)->ctx[(_pt)->sp]) + +void my_minit_func(struct pt_t * p) { + pt_start(p); + pt_ctx(p) = calloc(1, sizeof(int)); + printf("%s start %p\n", __func__, pt_ctx(p)); + pt_yield(p); + int * ctx = pt_ctx(p); + printf("%s loop %p\n", __func__, pt_ctx(p)); + for (; *ctx < 10; ctx[0]++) { + printf(" loop %d\n", *ctx); + pt_yield(p); + ctx = pt_ctx(p); + } + printf("%s done %p\n", __func__, pt_ctx(p)); + free(pt_ctx(p)); + pt_ctx(p) = NULL; + pt_end(p); +} + +void my_minit(struct pt_t * p) { + pt_start(p); + printf("%s start\n", __func__); + pt_call(p, my_minit_func); + printf("%s done\n", __func__); + pt_end(p); +} + +int main() { + struct pt_t pt = {}; + + pt_call(&pt, my_minit); +} +/* +tcc -run pt_call_test.c +my_minit start +my_minit_func start 0x555a68d970b0 +my_minit_func loop 0x555a68d970b0 + loop 0 + loop 1 + loop 2 + loop 3 + loop 4 + loop 5 + loop 6 + loop 7 + loop 8 + loop 9 +my_minit_func done 0x555a68d970b0 +my_minit done +*/ + +#endif // NEVER + +#endif /* MPTOOLS_INCLUDE_MINIPT_H_ */ diff --git a/libmish/src/mish.h b/libmish/src/mish.h new file mode 100644 index 0000000..d12e4d4 --- /dev/null +++ b/libmish/src/mish.h @@ -0,0 +1,113 @@ +/* + * mish.h + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef LIBMISH_SRC_MISH_H_ +#define LIBMISH_SRC_MISH_H_ + +#ifndef _LIBMISH_HAS_CMD_HANDLER_ +/* + * If you register with a non NULL parameter, you get that, otherwise + * you get an (opaque) mish_client_p + */ +typedef void (*mish_cmd_handler_p)( + void * param, + int argc, + const char *argv[]); +#endif + +enum { + MISH_CAP_NO_STDERR = (1 << 0), + MISH_CAP_NO_TELNET = (1 << 2), + MISH_CAP_FORCE_PTY = (1 << 1), +}; + +/*! + * Starts the mish thread, recover the stdout/err discriptor, and starts + * displaying a prompt for your process. + */ +struct mish_t * +mish_prepare( + unsigned long caps ); +//! Returns the flags you passed to mish_prepare() +unsigned long +mish_get_flags( + struct mish_t * m); +/*! + * This is normally called automatically at exit() time + */ +void +mish_terminate( + struct mish_t * m); + +/* + * Register a command; please use the macros, don't call this directly. + * + * Symbol is weak, so you can have mish commands in a dynamic library, + * without having to drag libmish into programs that use it; the commands + * won't register, but if you then link with a program that uses libmish, + * they will. + */ +void +mish_register_cmd( + const char ** cmd_names, + const char ** cmd_help, + mish_cmd_handler_p cmd_handler, + void * handler_param, + int safe) __attribute__((weak)); +/*! + * Poll the mish threads for pending commands, and call their handlers. + * This is only necessary for 'safe' commands that needs to be run on the + * main thread + */ +int +mish_cmd_poll(); + +/* + * This is how to add a command to your program: + * + * #include + * + * static void _my_command(void * yours, int argc, const char * argv[] ) { + * // do something here, like in main() + * } + * + * MISH_CMD_NAMES(_my_cmd, "cmd", "cmd_alias"); + * MISH_CMD_HELP(_my_cmd, "Short help one liner", "Extra help for help ") + * MISH_CMD_REGISTER(_my_cmd, _my_command); + * + * That's it! + */ + +#define MISH_CMD_NAMES(_n, args...) \ + static const char * _cmd_##_n[] = { args, 0 } +#define MISH_CMD_HELP(_n, args...) \ + static const char * _help_##_n[] = { args, 0 } +/* This gymnastic is required becase GCC has decided that it'll ignore + * ((weak)) symbols can be NULL, and throw me an error instead */ +static inline int _gcc_warning_false_pos_workaround(void * func) { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Waddress" + return func != NULL; +#pragma GCC diagnostic pop +} +//! These are called on libmish thread, immediately. +#define MISH_CMD_REGISTER(_d, _handler) \ + __attribute__((constructor,used)) \ + static void _mish_register_##_d() { \ + if (_gcc_warning_false_pos_workaround(mish_register_cmd)) \ + mish_register_cmd(_cmd_##_d,_help_##_d,_handler,0,0);\ + } +//! These are called when the main program calls mish_cmd_poll() +#define MISH_CMD_REGISTER_SAFE(_d, _handler) \ + __attribute__((constructor,used)) \ + static void _mish_register_##_d() { \ + if (_gcc_warning_false_pos_workaround(mish_register_cmd)) \ + mish_register_cmd(_cmd_##_d,_help_##_d,_handler,0,1);\ + } + +#endif /* LIBMISH_SRC_MISH_H_ */ diff --git a/libmish/src/mish_capture_select.c b/libmish/src/mish_capture_select.c new file mode 100644 index 0000000..cdde25a --- /dev/null +++ b/libmish/src/mish_capture_select.c @@ -0,0 +1,86 @@ +/* + * mish_capture_select.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include "mish_priv.h" +#include "mish.h" + +/* + * This is a select() based capture thread, it's not /ideal/ in terms of + * performances, but it's portable and should work on OSX/BSD Linux etc. + */ +void * +_mish_capture_select( + void *param) +{ + mish_p m = param; + + while (!(m->flags & MISH_QUIT)) { + mish_client_p c; + /* + * Call each client state machine, handle new output, + * new input, draw prompts etc etc. + * Also allow clients to tweak their 'output request' flag here + */ + TAILQ_FOREACH(c, &m->clients, self) + c->cr.process(m, c); + + fd_set r = m->select.read; + fd_set w = m->select.write; + struct timeval tv = { .tv_sec = 1 }; + int max = select(m->select.max, &r, &w, NULL, &tv); + if (max == 0) + continue; + if (max == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + // real error here? + continue; + } + /* check the telnet listen socket */ + mish_telnet_in_check(m, &r); + /* + * Get any input from the original terminals, it has been split + * into lines already and queue all into the main backlog. + */ + for (int i = 0; i < 1 + !(m->flags & MISH_CAP_NO_STDERR); i++) { + _mish_input_read(m, &r, &m->origin[i]); + + mish_line_p l; + while ((l = TAILQ_FIRST(&m->origin[i].backlog)) != NULL) { + l->err = i == 1; // mark stderr as such + TAILQ_REMOVE(&m->origin[i].backlog, l, self); + TAILQ_INSERT_TAIL(&m->backlog.log, l, self); + m->backlog.size++; + m->backlog.alloc += sizeof(*l) + l->size; + } + } + mish_client_p safe; + // check if any client has input, or was closed down, and remove them + TAILQ_FOREACH_SAFE(c, &m->clients, self, safe) { + _mish_input_read(m, &r, &c->input); + if (c->input.fd == -1 || (c->flags & MISH_CLIENT_DELETE)) + mish_client_delete(m, c); + } + } + if ((m->flags & MISH_CONSOLE_TTY) && + tcsetattr(0, TCSAFLUSH, &m->orig_termios)) + perror("thread tcsetattr"); + /* + * Try to be nice and tell all clients to cleanup + */ + mish_client_p c; + while ((c = TAILQ_FIRST(&m->clients)) != NULL) + mish_client_delete(m, c); + m->flags &= ~MISH_QUIT; + m->capture = 0; // mark the thread done + exit(0); // this calls mish_terminate, on main thread +// return NULL; +} diff --git a/libmish/src/mish_client.c b/libmish/src/mish_client.c new file mode 100644 index 0000000..1cd19cc --- /dev/null +++ b/libmish/src/mish_client.c @@ -0,0 +1,384 @@ +/* + * mish_client.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include "mish_priv.h" +#include "mish.h" +#include "minipt.h" + + +mish_client_p +mish_client_new( + mish_p m, + int in, + int out, + int is_tty) +{ + mish_client_p c = (mish_client_p)calloc(1, sizeof(*c)); + + _mish_input_init(m, &c->input, in); + if (is_tty) { + c->input.process_char = _mish_client_vt_parse_input; + c->cr.process = _mish_client_interractive_cr; + } else { + c->cr.process = _mish_client_dumb_cr; + } + c->input.refcon = c; + c->output.fd = out; + c->mish = m; // pointer to parent + c->footer_height = 2; + /* + * Mark the in & out descriptors (could be the same, if a socket) + * as non blocking. + */ + int fds[2] = { in, out}; + for (int i = 0; i < 2; i++) { + int fd = fds[i]; + if (fd >= m->select.max - 1) + m->select.max = fd +1; + int flags = fcntl(fd, F_GETFL, NULL); + if (flags == 1) { + perror("mish: input F_GETFL"); + flags = 0; + } + if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) + perror("mish: input F_SETFL"); + } + + TAILQ_INSERT_TAIL(&m->clients, c, self); + return c; +} + +void +mish_client_delete( + mish_p m, + mish_client_p c) +{ + /* + * Turn back synchronous IO here, I don't want to have to deal with EAGAIN + * when I'm actually trying to be nice and close as quickly as I can + */ + int fds[2] = { c->input.fd, c->output.fd }; + for (int i = 0; i < 2; i++) { + if (fds[i] == -1) + continue; + FD_CLR(fds[i], &m->select.read); + FD_CLR(fds[i], &m->select.write); + int flags; + if (fcntl(fds[i], F_GETFL, &flags) == 0) { + flags &= ~O_NONBLOCK; + if (fcntl(fds[i], F_SETFL, &flags)) + /* don't care */; + } + } + const char * restore = "\033[4l\033[;r\033[999;1H"; + if (write(c->output.fd, restore, strlen(restore))) + ; + close(c->output.fd); + + TAILQ_REMOVE(&m->clients, c, self); + if (c == m->console) + m->console = NULL; + _mish_input_clear(m, &c->input); + free(c); +} + +/* + * this calculates the number of glyphs in the prompt, it's needed + * so we know where to position the cursor when displaying the input line. + * Since prompt can have escape sequences like colors, or UTF8 glyphs + */ +static void +_mish_client_set_prompt( + mish_client_p c, + const char *p) +{ + if (p != c->prompt) + strncpy(c->prompt, p, sizeof(c->prompt)-1); + + mish_vt_sequence_t sq = {}; + char *s = c->prompt; + c->prompt_gc = 0; + while (*s) { + if (_mish_vt_sequence_char(&sq, *s)) + if (sq.glyph) + c->prompt_gc++; + s++; + } +} + +/* + * Remember, NO LOCALS in here -- this is a coroutine with no stack! + * + * Interactive 'client' prompt handling + */ +void +_mish_client_interractive_cr( + mish_p m, + mish_client_p c) +{ + pt_start(c->cr.state); + + if (c->input.is_telnet) + mish_telnet_send_init(c); + /* + * move cursor to 999;999 then asks the cursor position. That tells + * us the window size! (handy) + */ + _mish_send_queue(c, + "\033[999;999H\033[6n"); + while (_mish_send_flush(m, c)) + pt_yield(c->cr.state); + /* remember when we started */ + c->output.sqb->stamp = _mish_stamp_ms(); + /* Wait for the input handler to get the right sequence */ + /* can be either the terminal response OR the telnet sequence */ + while (!(c->flags & + (MISH_CLIENT_HAS_CURSOR_POS | MISH_CLIENT_HAS_WINDOW_SIZE)) && + (_mish_stamp_ms() - c->output.sqb->stamp) < (2 * 1000)) + pt_yield(c->cr.state); + + if (c->flags & MISH_CLIENT_HAS_CURSOR_POS) { + c->window_size.w = c->cursor_pos.x; + c->window_size.h = c->cursor_pos.y; + c->flags |= MISH_CLIENT_HAS_WINDOW_SIZE; + } + if (!(c->flags & MISH_CLIENT_HAS_WINDOW_SIZE)) { + printf("mish: no window size, falling back to dumb scrollback\n"); + c->cr.process = _mish_client_dumb_cr; + goto finish; + } + /* We are live scrolling, and we are at the last line of scrollback */ + c->flags |= MISH_CLIENT_INIT_SENT | MISH_CLIENT_SCROLLING; + c->bottom = TAILQ_LAST(&m->backlog.log, mish_line_queue_t); + /* + * This is where we arrive to draw the entire screen; to start up, + * and each time you do a control-l (TODO: or if the window is resized) + * Or use the scrollback (page Up/down etc) + */ +redraw: + c->flags |= MISH_CLIENT_UPDATE_PROMPT; + c->sending = c->bottom; + c->current_vpos = c->window_size.h - c->footer_height; + /* + * walk back from the 'bottom' line we want until we reach the top of the + * screen, or ran out of lines. + */ + while (c->sending && c->current_vpos >= 1) { + mish_line_p p = TAILQ_PREV(c->sending, mish_line_queue_t, self); + if (p) { + c->sending = p; + c->current_vpos--; + } else + break; + } + /* + * Now, we've just connected here, and there might be backlog, and we want + * just enough of that to fill our screen + */ + /* Set the scrolling region to all minus the 2 bottom lines */ + _mish_send_queue_fmt(c, "\033D\033[1;%dr", + c->window_size.h - c->footer_height); + _mish_send_queue_fmt(c, + "\033[%d;1H" + "\033[J", // clear to bottom of scrolling area + c->current_vpos); + do { + if (c->flags & MISH_CLIENT_UPDATE_WINDOW) { + c->flags &= ~MISH_CLIENT_UPDATE_WINDOW; + goto redraw; + } + /* + * If there isn't anything to send from the stdout/stderr, do + * prompt editing input handling. + */ + if (c->flags & MISH_CLIENT_UPDATE_PROMPT) { + c->flags &= ~MISH_CLIENT_UPDATE_PROMPT; + sprintf(c->prompt, ">>: "); + _mish_client_set_prompt(c, c->prompt); + + _mish_send_queue_fmt(c, + // "_" // draw a fake cursor and end of scrolling text + "\033[%d;1H" /* reposition the cursor to prompt area */ + "%s" // print prompt + "\033[J" // Clear to end of screen + "\033[4h", // Set insert mode + c->window_size.h - c->footer_height + 1, c->prompt); + if (c->cmd && c->cmd->len) { + _mish_send_queue_fmt(c, "%s", c->cmd->line); + /* if cursor is inside the line, move it back */ + if (c->cmd->len > c->cmd->done) + _mish_send_queue_fmt(c, "\033[%dD", + c->cmd->len - c->cmd->done); + } + } + /* + * Now, flush everything we had from the last iteration (inc prompt) + * from the scatter gather vector. + */ + if (c->output.count) { + while (_mish_send_flush(m, c)) + pt_yield(c->cr.state); + } else + pt_yield(c->cr.state); + + if (!c->sending) { + /* we're starting up, pool the backlog for a line to display */ + if (!c->bottom) { + c->bottom = TAILQ_LAST(&m->backlog.log, mish_line_queue_t); + c->sending = c->bottom; + } else { + // we WERE at the bottom, so find a possible next line + mish_line_p next = TAILQ_NEXT(c->bottom, self); + if (c->flags & MISH_CLIENT_SCROLLING) { + if (next) { + c->bottom = c->sending = next; + } + } + } + } + if (!c->sending) // bah, no new output, loop on + continue; + /* Remember you can't yield() until we're out of the while() loop */ + size_t start = c->output.total; + /* + * Now there is something to send, reposition the cursor in the + * scrolling area, and start sending backlog lines. + */ + _mish_send_queue_fmt(c, + "\033[s" /* Save cursor position (from the prompt area) */ + "\x8\033[%d;1H" /* pos cursor at bottom of scroll area */ + "\033[8l" /* replace mode */, + c->current_vpos); + /* + * Send until there's nothing else OR we sent a screen worth + * this allow a chance to service the input prompt + */ + size_t screen_worth = (c->window_size.h * c->window_size.w) / 1; + do { + if (c->sending->err) + _mish_send_queue(c, MISH_COLOR_RED); + _mish_send_queue_line(c, c->sending); + if (c->sending->err) + _mish_send_queue(c, "\033[m"); + // if we reach the bottom mark, stop + c->sending = c->sending == c->bottom ? + NULL : TAILQ_NEXT(c->sending, self); + } while (c->sending && + (c->output.total - start) <= screen_worth); + // update cursor position here -- SHOULD update it with each lines, + // to handle word wrapping, but for now it's OK + // TODO: Update cursor V pos handling line wrap + if (!c->sending) + c->current_vpos = c->window_size.h - c->footer_height; + /* Restore the cursor to the prompt area */ + _mish_send_queue(c, "\033[u"); + } while(1); +finish: + pt_end(c->cr.state); +} + +/* + * this is the dump pooler; just sends the lines, as is, as they appear. + * Still try to max up the buffer if possible, but that's about it. + */ +void +_mish_client_dumb_cr( + mish_p m, + mish_client_p c) +{ + pt_start(c->cr.state); + printf(MISH_COLOR_RED "mish: Started dumb console\n" MISH_COLOR_RESET); + do { + pt_yield(c->cr.state); + + if (!c->sending) { + /* we're starting up, pool the backlog for a line to display */ + if (!c->bottom) { + c->bottom = TAILQ_LAST(&m->backlog.log, mish_line_queue_t); + c->sending = c->bottom; + } else { + // we WERE at the bottom, so find a possible next line + mish_line_p next = TAILQ_NEXT(c->bottom, self); + if (next) { + c->sending = next; + c->bottom = TAILQ_LAST(&m->backlog.log, mish_line_queue_t); + } + } + } + if (!c->sending) // bah, no new output, loop on + continue; + + do { + _mish_send_queue_line(c, c->sending); + // if we reach the bottom mark, stop + c->sending = c->sending == c->bottom ? + NULL : TAILQ_NEXT(c->sending, self); + } while (c->sending); + + while (_mish_send_flush(m, c)) + pt_yield(c->cr.state); + } while(1); + + pt_end(c->cr.state); +} + +static void +_mish_cmd_history( + void * param, + int argc, + const char * argv[]) +{ + mish_client_p c = param; + mish_input_p in = &c->input; + mish_line_p l; + int i = 0; + TAILQ_FOREACH(l, &in->backlog, self) { + printf("%3d %s\n", i+1, l->line); + i++; + } + printf(MISH_COLOR_GREEN + "mish: %d history" + MISH_COLOR_RESET "\n", i); +} + +MISH_CMD_NAMES(history, "history"); +MISH_CMD_HELP(history, + "Display the history of commands."); +MISH_CMD_REGISTER(history, _mish_cmd_history); + + +static void +_mish_cmd_disconnect( + void * param, + int argc, + const char * argv[]) +{ + mish_client_p c = param; + + if (c == c->mish->console) { + printf(MISH_COLOR_RED + "mish: can't disconnect console" + MISH_COLOR_RESET "\n"); + return; + } + printf(MISH_COLOR_GREEN + "mish: telnet: logout" + MISH_COLOR_RESET "\n"); + c->flags |= MISH_CLIENT_DELETE; +} + +MISH_CMD_NAMES(disconnect, "dis", "disconnect", "logout"); +MISH_CMD_HELP(disconnect, + "Disconnect this telnet session. If appropriate"); +MISH_CMD_REGISTER(disconnect, _mish_cmd_disconnect); + diff --git a/libmish/src/mish_client_input.c b/libmish/src/mish_client_input.c new file mode 100644 index 0000000..b297fda --- /dev/null +++ b/libmish/src/mish_client_input.c @@ -0,0 +1,233 @@ +/* + * mish_client_input.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include + +#include "mish_priv.h" +#include "mish_priv_cmd.h" +#include "mish.h" + +/* + * Don't assume this handles every key combination in the world, it doesn't, + * it handles mostly the one I use most from bash! + * You like VI syntax, saaaaad story :-) + */ +//! Parse current input buffer +int +_mish_client_vt_parse_input( + struct mish_t *m, + struct mish_input_t *in, + uint8_t ich) +{ + mish_client_p c = in->refcon; + + /* + * if the sequence buffer is currently being flushed, we need to store + * the input until it's done. + * So lets store it into the input buffer, and once that output is finished + * we can process it as before. + */ + if (c->output.sqb->done) + return MISH_IN_STORE; + // now flush what was stored, plus the one we just received + for (int i = 0; i <= in->line->done; i++) { + uint8_t ch = i == in->line->done ? ich : in->line->line[i]; + + if (in->is_telnet) { + if (_mish_telnet_parse(c, ch)) + continue; + } + if (!_mish_vt_sequence_char(&c->vts, ch)) + continue; + // if no command is editing, create an empty one, add it to history + if (!c->cmd) { + _mish_line_reserve(&c->cmd, 4); + TAILQ_INSERT_TAIL(&in->backlog, c->cmd, self); + } else { + /* + * we need to detach the element if we're going to resize it, + * otherwise the list is completely fubar as the pointer changes + */ + if (c->cmd->size - c->cmd->len <= 4) { + mish_line_p next = TAILQ_NEXT(c->cmd, self); + TAILQ_REMOVE(&in->backlog, c->cmd, self); + _mish_line_reserve(&c->cmd, 4); + if (next) + TAILQ_INSERT_BEFORE(next, c->cmd, self); + else + TAILQ_INSERT_TAIL(&in->backlog, c->cmd, self); + } + } + switch (c->vts.seq) { + case MISH_VT_SEQ(CSI, '~'): { + mish_line_p cursor = c->bottom; + if (c->vts.p[0] == 1) // GNU screen HOME seq + goto kb_home; + else if (c->vts.p[0] == 4) // GNU screen END seq + goto kb_end; + if (c->vts.p[0] == 5) { // Page UP + for (int i = 0; i < c->window_size.h - 3 && cursor; i++) + cursor = TAILQ_PREV(cursor, mish_line_queue_t, self); + if (cursor) { + c->bottom = cursor; + c->flags |= MISH_CLIENT_UPDATE_WINDOW; + c->flags &= ~MISH_CLIENT_SCROLLING; + } + } else if (c->vts.p[0] == 6) { // down + for (int i = 0; i < c->window_size.h - 3 && cursor; i++) + cursor = TAILQ_NEXT(cursor, self); + c->bottom = cursor; + c->flags |= MISH_CLIENT_UPDATE_WINDOW; + if (!c->bottom) + c->flags |= MISH_CLIENT_SCROLLING; + } + } break; + case MISH_VT_SEQ(CSI, 'H'): { // Home +kb_home: + // don't bother if there's not enough backlog + if (m->backlog.size < c->window_size.h - 2) + break; + c->bottom = TAILQ_FIRST(&m->backlog.log); + for (i = 0; i < c->window_size.h - 2 - 1 && c->bottom; i++) + c->bottom = TAILQ_NEXT(c->bottom, self); + c->flags |= MISH_CLIENT_UPDATE_WINDOW; + if (c->bottom) + c->flags &= ~MISH_CLIENT_SCROLLING; + } break; + case MISH_VT_SEQ(CSI, 'F'): { // END +kb_end: + c->flags |= MISH_CLIENT_UPDATE_WINDOW | MISH_CLIENT_SCROLLING; + c->bottom = NULL; + } break; + case MISH_VT_SEQ(CSI, 'R'): + c->flags |= MISH_CLIENT_HAS_CURSOR_POS; + c->cursor_pos.y = c->vts.p[0]; + c->cursor_pos.x = c->vts.p[1]; + break; + case MISH_VT_SEQ(RAW, 16): { // CTRL-P Prev history + if (TAILQ_FIRST(&in->backlog) != c->cmd) { + c->flags |= MISH_CLIENT_UPDATE_PROMPT; + c->cmd = TAILQ_PREV(c->cmd, mish_line_queue_t, self); + } + } break; + case MISH_VT_SEQ(RAW, 14): // CTRL-N Next history + if (TAILQ_LAST(&in->backlog, mish_line_queue_t) != c->cmd) { + c->flags |= MISH_CLIENT_UPDATE_PROMPT; + c->cmd = TAILQ_NEXT(c->cmd, self); + } + break; + case MISH_VT_SEQ(RAW, 1): // CTRL-A Start of line + if (c->cmd->done) { + _mish_send_queue_fmt(c, "\033[%dD", c->cmd->done); + c->cmd->done = 0; + } + break; + case MISH_VT_SEQ(RAW, 5): // CTRL-E End of Line + if (c->cmd->done < c->cmd->len) { + _mish_send_queue_fmt(c, "\033[%dC", + c->cmd->len - c->cmd->done); + c->cmd->done = c->cmd->len; + } + break; + case MISH_VT_SEQ(RAW, 2): // CTRL-B Prev char + if (c->cmd->done) { + c->cmd->done--; + _mish_send_queue_fmt(c, "\033[%dD", 1); + } + break; + case MISH_VT_SEQ(RAW, 6): // CTRL-F Next Char + if (c->cmd->done < c->cmd->len) { + c->cmd->done++; + _mish_send_queue_fmt(c, "\033[%dC", 1); + } + break; + case MISH_VT_SEQ(RAW, 23): { // CTRL-W Delete prev word + int old_pos = c->cmd->done; + while (c->cmd->done && c->cmd->line[c->cmd->done-1] == ' ') + c->cmd->done--; + while (c->cmd->done && c->cmd->line[c->cmd->done-1] != ' ') + c->cmd->done--; + + if (old_pos - c->cmd->done) { + int del = old_pos - c->cmd->done; + memmove(c->cmd->line + c->cmd->done, + c->cmd->line + old_pos, + c->cmd->len - old_pos + 1); + c->cmd->len -= del; + // move back del characters, and delete them + _mish_send_queue_fmt(c, "\033[%dD\033[%dP", del, del); + } + } break; + case MISH_VT_SEQ(RAW, 0x7f): // DEL + case MISH_VT_SEQ(RAW, 8): // CTRL-H + if (c->cmd->done) { + c->cmd->done--; + memmove(c->cmd->line + c->cmd->done, + c->cmd->line + c->cmd->done + 1, + c->cmd->len - c->cmd->done + 1); + c->cmd->len--; + // backspace plus Delete (1) Character + _mish_send_queue(c, "\x8\033[P"); + } + break; + case MISH_VT_SEQ(RAW, 11): // CTRL-K Kill rest of line + c->cmd->len = c->cmd->done; + c->cmd->line[c->cmd->len] = 0; + _mish_send_queue(c, "\033[K"); + break; + case MISH_VT_SEQ(RAW, 12): // CTRL-L Redraw + c->flags |= MISH_CLIENT_UPDATE_WINDOW; + break; + case MISH_VT_SEQ(RAW, 13): // CTRL-M aka return + c->cmd->line[c->cmd->len] = 0; + if (0) { // debug + fprintf(stdout, "CMD: '%.*s", c->cmd->done, c->cmd->line); + fprintf(stdout, "\033[7m%.*s\033[0m", 1, + c->cmd->line + c->cmd->done); + if (c->cmd->done < c->cmd->len) + fprintf(stdout, "%s", c->cmd->line + c->cmd->done+1); + fprintf(stdout, "'\n"); + } + mish_cmd_call(c->cmd->line, c); + c->cmd = NULL; // new one + { // reuse the last empty one + mish_line_p last = TAILQ_LAST(&in->backlog, mish_line_queue_t); + if (last && last->len == 0) + c->cmd = last; + } + c->flags |= MISH_CLIENT_UPDATE_PROMPT; + break; + default: + if (c->vts.seq & ~0xff) { + printf(MISH_COLOR_RED + "mish: Unknown sequence: %08x ", c->vts.seq); + for (int i = 0; i < c->vts.pc; i++) + printf(":%d", c->vts.p[i]); + printf("'%c%c'", c->vts.seq >> 8, c->vts.seq & 0xff); + printf(MISH_COLOR_RESET "\n"); + } + break; + } + if (c->vts.glyph && c->vts.glyph >= ' ' && c->vts.glyph < 0x7f) { + memmove(c->cmd->line + c->cmd->done + 1, + c->cmd->line + c->cmd->done, + c->cmd->len - c->cmd->done); + c->cmd->line[c->cmd->done] = c->vts.glyph; + c->cmd->done++; + c->cmd->len++; + c->cmd->line[c->cmd->len] = 0; + // no need to explicitly insert, terminal should already be setup + _mish_send_queue_fmt(c, "%lc", c->vts.glyph); + } + } + // remove any buffered input. + in->line->len = 0; + return MISH_IN_SKIP; +} diff --git a/libmish/src/mish_cmd.c b/libmish/src/mish_cmd.c new file mode 100644 index 0000000..a4c9eed --- /dev/null +++ b/libmish/src/mish_cmd.c @@ -0,0 +1,307 @@ +/* + * mish_cmd.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include "mish_priv_cmd.h" +#include "mish_priv.h" +#include "mish.h" + +#include "fifo_declare.h" + + +#ifndef offsetof +#define offsetof(type, member) __builtin_offsetof (type, member) +#endif +#ifndef container_of +#define container_of(ptr, type, member) ({ \ + const char *__mptr = (const char *)(ptr); \ + (type *)(__mptr - offsetof(type, member) );}) +#endif + +typedef struct mish_cmd_t { + TAILQ_ENTRY(mish_cmd_t) self; + mish_cmd_handler_p cmd_cb; + void * param_cb; + uint32_t safe : 1; + + const char ** names; // list of aliases for the command + const char ** help; +} mish_cmd_t, *mish_cmd_p; + +typedef struct mish_cmd_call_t { + mish_cmd_p cmd; + char ** argv; + int argc; +} mish_cmd_call_t; + +DECLARE_FIFO(mish_cmd_call_t, mish_call_queue, 4); +DEFINE_FIFO(mish_cmd_call_t, mish_call_queue); + +static TAILQ_HEAD(,mish_cmd_t) _cmd_list = TAILQ_HEAD_INITIALIZER(_cmd_list); +static mish_call_queue_t _cmd_fifo = {0}; + +void __attribute__((weak)) +mish_register_cmd( + const char ** cmd_names, + const char ** cmd_help, + mish_cmd_handler_p cmd_handler, + void * handler_param, + int safe) +{ + if (!cmd_names || !cmd_help || !cmd_handler) { + fprintf(stderr, "%s invalid parameters\n", __func__); + return; + } + mish_cmd_p cmd = calloc(1, sizeof(*cmd)); + + cmd->names = cmd_names; + cmd->help = cmd_help; + cmd->cmd_cb = cmd_handler; + cmd->param_cb = handler_param; + cmd->safe = safe; + + // keep the list roughtly sorted + mish_cmd_p c, s; + TAILQ_FOREACH_SAFE(c, &_cmd_list, self, s) { + if (strcmp(cmd_names[0], c->names[0]) < 0) { + TAILQ_INSERT_BEFORE(c, cmd, self); + return; + } + } + TAILQ_INSERT_TAIL(&_cmd_list, cmd, self); +} + +/* + * Returns the length of the first word of cmd_line + */ +static int +first_word_length( + const char * cmd_line) +{ + const char *d = cmd_line; + while (*d && *d != ' ') + d++; + return d - cmd_line; +} + +mish_cmd_p +mish_cmd_lookup( + const char * cmd_line) +{ + if (!cmd_line) + return NULL; + int l = first_word_length(cmd_line); + mish_cmd_p cmd; + TAILQ_FOREACH(cmd, &_cmd_list, self) { + for (int i = 0; cmd->names && cmd->names[i]; i++) + if (!strncmp(cmd->names[i], cmd_line, l)) + return cmd; + } + return NULL; +} + +typedef struct _mish_argv_t { + char * line; + int ac; + char * av[0]; +} _mish_argv_t; + +/* + * Duplicate 'line', split it into words, store word pointers in an array, + * NULL terminate it. Also return the number of words in the array in argc. + * + * The returned value is made of two malloc()ed blocks. use mish_argv_free + * to free the memory. + * It's OK to change any of the pointers. But no not try to realloc() the + * vector as it hides a structure + */ +static char ** +mish_argv_make( + const char * line, + int * argc ) +{ + const char separator = ' '; + _mish_argv_t * r = calloc(1, sizeof(*r)); + r->line = strdup(line); + char *dup = r->line; + char quote; + enum { s_newarg = 0, s_startarg, s_copyquote, s_skip, s_copy }; + int state = s_newarg; + do { + switch (state) { + case s_newarg: + r = realloc(r, sizeof(*r) + ((r->ac + 2) * sizeof(char*))); + while (*dup == ' ' || *dup == separator) + dup++; + r->av[r->ac++] = dup; + state = s_startarg; + break; + case s_startarg: + if (*dup == '"' || *dup == '\'') { + quote = *dup++; + state = s_copyquote; + } else + state = s_copy; + break; + case s_copyquote: + if (*dup == '\\') + state = s_skip; + else if (*dup == quote) { + state = s_newarg; + dup++; + if (*dup) *dup++ = 0; + } else if (*dup) + dup++; + break; + case s_skip: + dup++; + state = s_copyquote; + break; + case s_copy: + if (*dup == 0) + break; + if (*dup != separator) + dup++; + else { + state = s_newarg; + if (*dup) *dup++ = 0; + } + break; + } + } while (*dup); + r->av[r->ac] = NULL; + if (argc) + *argc = r->ac; + return r->av; +} + +/* + * Free memory allocated by a mish_argv_make + */ +void +mish_argv_free( + char **_av) +{ + if (!_av) + return; + _mish_argv_t * r = container_of(_av, _mish_argv_t, av); + free((void*)r->line); + free((void*)r); +} + +int +mish_cmd_call( + const char * cmd_line, + void * c) +{ + if (!cmd_line || !*cmd_line) + return -1; + + mish_cmd_p cmd = mish_cmd_lookup(cmd_line); + if (!cmd) { + int l = first_word_length(cmd_line); + printf(MISH_COLOR_RED + "mish: '%.*s' not found. type 'help'." + MISH_COLOR_RESET "\n", + l, cmd_line); + return -1; + } + int ac = 0; + char ** av = mish_argv_make(cmd_line, &ac); + + if (cmd->safe) { + if (!mish_call_queue_isfull(&_cmd_fifo)) { + mish_cmd_call_t fe = { + .cmd = cmd, + .argv = av, + .argc = ac, + }; + mish_call_queue_write(&_cmd_fifo, fe); + } else { + fprintf(stderr, + "mish: cmd FIFO full, make sure to call mish_cmd_poll()!\n"); + } + } else { + cmd->cmd_cb(cmd->param_cb ? cmd->param_cb : c, ac, (const char**)av); + mish_argv_free(av); + } + return 0; +} + +int +mish_cmd_poll() +{ + int res = 0; + + while (!mish_call_queue_isempty(&_cmd_fifo)) { + mish_cmd_call_t c = mish_call_queue_read(&_cmd_fifo); + + c.cmd->cmd_cb( + c.cmd->param_cb, c.argc, (const char**)c.argv); + mish_argv_free(c.argv); + res++; + } + return res; +} + +static const char *_help[] = { + "A few of the typical EMACS keys work for editing commands.", + "like, ^A-^E, ^W, ^K - ^P,^N to navigate history and ^L to", + "redraw.", + "BEG/PGUP/DOWN/END to change the view of the backlog buffer.", + 0, +}; +static void +_mish_cmd_help( + void * param, + int argc, + const char * argv[]) +{ + mish_cmd_p cmd; + + if (argc < 2) { + printf(MISH_COLOR_GREEN "mish: Key binding\n"); + for (int i = 0; _help[i]; i++) + printf(" %s\n", _help[i]); + printf(MISH_COLOR_GREEN "List of commands\n"); + + TAILQ_FOREACH(cmd, &_cmd_list, self) { + printf(" "); + for (int i = 0; cmd->names && cmd->names[i]; i++) + printf("%s%s", i > 0 ? "," : "", cmd->names[i]); + printf(" - %s\n", cmd->help[0]); + } + printf(MISH_COLOR_RESET); + } else { + for (int i = 1; i < argc; i++) { + mish_cmd_p cmd = mish_cmd_lookup(argv[i]); + + if (!cmd) { + printf(MISH_COLOR_RED + "mish: Unknown command '%s'" + MISH_COLOR_RESET "\n", argv[i]); + continue; + } + printf(MISH_COLOR_GREEN); + for (int i = 0; cmd->names && cmd->names[i]; i++) + printf("%s%s", i > 0 ? "," : "", cmd->names[i]); + printf("\n"); + for (int i = 0; cmd->help && cmd->help[i]; i++) + printf(" %s\n", cmd->help[i]); + printf(MISH_COLOR_RESET); + } + } +} + +MISH_CMD_NAMES(help, "help"); +MISH_CMD_HELP(help, + "[cmd...] - Display command list, or help for commands", + "(optional) [cmd...] will display all the help for [cmd]"); +MISH_CMD_REGISTER(help, _mish_cmd_help); diff --git a/libmish/src/mish_cmd_env.c b/libmish/src/mish_cmd_env.c new file mode 100644 index 0000000..26dfa3c --- /dev/null +++ b/libmish/src/mish_cmd_env.c @@ -0,0 +1,72 @@ +/* + * mish_cmd_env.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include "mish.h" + +extern char ** environ; + +static void +_mish_cmd_env( + void * param, + int argc, + const char * argv[]) +{ + if (argc < 2) { + for (int i = 0; environ[i]; i++) + if (strncmp(environ[i], "LS_COLORS=", 10)) + printf("%s\n", environ[i]); + return; + } + for (int i = 0; environ[i]; i++) + for (int ei = 1; ei < argc; ei++) { + int l = strlen(argv[ei]); + if (!strncmp(environ[i], argv[ei], l)) + printf("%s\n", environ[i]); + } +} + +MISH_CMD_NAMES(env, "env"); +MISH_CMD_HELP(env, + "[names ...] display all environment, or variables", + "Apart from LS_COLORS: that is just spam.", + "If you specify names it'll just show the ones whose name", + "start with that prefix"); +MISH_CMD_REGISTER(env, _mish_cmd_env); + +static void +_mish_cmd_setenv( + void * param, + int argc, + const char * argv[]) +{ + for (int ei = 1; ei < argc; ei++) { + char *equal = strchr(argv[ei], '='); + if (!equal) { + printf("mish: setenv: '%s' requires an '='\n", argv[ei]); + return; + } + *equal++ = 0; + printf("mish: %s%s%s%s\n", *equal ? "" : "unset ", + argv[ei], *equal ? " = ": "", + *equal ? equal : ""); + if (!*equal) + unsetenv(argv[ei]); + else + setenv(argv[ei], equal, 1); + } +} + +MISH_CMD_NAMES(setenv, "setenv"); +MISH_CMD_HELP(setenv, + "[=...] set/clear environment variable(s)", + "Set to .. if is omitted, clears it.", + "The '=' is required, even when clearing."); +MISH_CMD_REGISTER(setenv, _mish_cmd_setenv); diff --git a/libmish/src/mish_input.c b/libmish/src/mish_input.c new file mode 100644 index 0000000..964c1d5 --- /dev/null +++ b/libmish/src/mish_input.c @@ -0,0 +1,139 @@ +/* + * mish_input.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include "mish_priv.h" +#include "mish_priv_line.h" + +#ifdef MISH_INPUT_TEST +#define D(_w) _w +#else +#define D(_w) +#endif + +void +_mish_input_init( + mish_p m, + mish_input_p in, + int fd) +{ + TAILQ_INIT(&in->backlog); +// fprintf(stderr, "%s %d\n", __func__, fd); + in->fd = fd; + in->line = NULL; + FD_SET(in->fd, &m->select.read); + if (in->fd >= m->select.max - 1) + m->select.max = in->fd +1; + + int flags = fcntl(fd, F_GETFL, NULL); + if (flags == 1) { + perror("mish: input F_GETFL"); + flags = 0; + } + if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) + perror("mish: input F_SETFL"); +} + +void +_mish_input_clear( + mish_p m, + mish_input_p in) +{ + mish_line_p l; + while ((l = TAILQ_FIRST(&in->backlog)) != NULL) { + TAILQ_REMOVE(&in->backlog, l, self); + free(l); + } + if (in->line) + free(in->line); + in->line = NULL; + if (in->fd != -1) { + FD_CLR(in->fd, &m->select.read); + FD_CLR(in->fd, &m->select.write); + close(in->fd); + in->fd = -1; + } +} + +int +_mish_input_read( + mish_p m, + fd_set * fds, + mish_input_p in) +{ + if (!FD_ISSET(in->fd, fds)) + return 0; + do { + if (_mish_line_reserve(&in->line, 80)) { + D(printf(" reserve bailed us\n");) + break; + } + ssize_t rd = read(in->fd, + in->line->line + in->line->len, + in->line->size - in->line->len - 1); + if (rd == -1 && (errno == EWOULDBLOCK || errno == EAGAIN)) + break; + if (rd <= 0) { + close(in->fd); + FD_CLR(in->fd, &m->select.read); + FD_CLR(in->fd, &m->select.write); + in->fd = -1; + printf(MISH_COLOR_RED "mish: telnet: disconnected" + MISH_COLOR_RESET "\n"); + return -1; + } + in->line->len += rd; + } while (1); + uint8_t * s = (uint8_t*) in->line->line + in->line->done; + uint8_t * d = s; + int added = in->line->len - in->line->done; + D(printf(" buffer added %d done %d len %d size %d\n", added, + (int)in->line->done, (int)in->line->len, (int)in->line->size); + if (in->line->done) + printf(" buffer: '%.*s'\n", in->line->done, in->line->line);) + /* + * This loop re-parse the data, passes it to the optional handler, + * and then store processed lines into the backlog. This is not super + * optimal in the case there isn't a process_char() callback, so perhaps + * I should make another less 'generic' input parser that doesn't copy + * stuff around (in place, often). + */ + while (added) { + int r = MISH_IN_STORE; + if (in->process_char) + r = in->process_char(m, in, *s); + else + r = *s == '\n' ? MISH_IN_SPLIT : MISH_IN_STORE; + + if (r == MISH_IN_STORE || r == MISH_IN_SPLIT) { + *d++ = *s; + in->line->done++; + } + if (r == MISH_IN_SPLIT) { + D(printf(" split size %d remains %d : '%.*s'\n", in->line->done, + (int)added, in->line->done-1, in->line->line);) + _mish_line_add(&in->backlog, in->line->line, in->line->done); + d = (uint8_t*)in->line->line; + in->line->len = in->line->done = 0; + } + s++; added--; + } + *d = 0; // NUL terminate for debug purpose! + D(printf(" exit added %d done %d len %d size %d\n", added, + (int)in->line->done, (int)in->line->len, (int)in->line->size); + in->line->len = in->line->done; + if (in->line->done) + printf(" buffer: '%s'\n", in->line->line);) + + return TAILQ_FIRST(&in->backlog) != NULL; +} diff --git a/libmish/src/mish_line.c b/libmish/src/mish_line.c new file mode 100644 index 0000000..69b17bb --- /dev/null +++ b/libmish/src/mish_line.c @@ -0,0 +1,59 @@ +/* + * mish_line.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "mish_priv.h" +#include "mish_priv_line.h" + +static const mish_line_t zero = {}; + +mish_line_p +_mish_line_add( + mish_line_queue_t * q, + char * buffer, + size_t length ) +{ + size_t l = length + 1; + mish_line_p nl = (mish_line_p)malloc(sizeof(*nl) + l); + *nl = zero; + nl->size = l; + nl->len = length; + memcpy(nl->line, buffer, length); + nl->line[l] = 0; + nl->stamp = _mish_stamp_ms(); + TAILQ_INSERT_TAIL(q, nl, self); + return nl; +} + +int +_mish_line_reserve( + mish_line_p *line, + uint32_t count) +{ + if (!line) + return -1; + mish_line_p l = *line; + if (count < 40) + count = 40; + if (!l) { + l = (mish_line_p)calloc(1, sizeof(mish_line_t) + count); + *l = zero; + l->size = count; + *line = l; + } + if (l->size + count >= MISH_MAX_LINE_SIZE) + return 1; + if (l->size - l->len < count) { + l = (mish_line_p)realloc(l, + sizeof(mish_line_t) + l->size + count); + l->size += count; + *line = l; + } + return 0; +} diff --git a/libmish/src/mish_priv.h b/libmish/src/mish_priv.h new file mode 100644 index 0000000..1509ae3 --- /dev/null +++ b/libmish/src/mish_priv.h @@ -0,0 +1,273 @@ +/* + * mish_priv.h + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef LIBMISH_SRC_MISH_PRIV_H_ +#define LIBMISH_SRC_MISH_PRIV_H_ + +#include +#include +#include +#include +#include "bsd_queue.h" +#include "mish_priv_vt.h" +#include "mish_priv_line.h" + +struct mish_t; + +/* + * The process_char callback of mish_input_t returns one of these. + */ +enum { + MISH_IN_SKIP = 0, // skip current character (don't store) + MISH_IN_STORE, // store current character in input buffer + MISH_IN_SPLIT, // store current line, add it to backlog +}; + +/* + * This receives stuff from a file descriptor, 'processes' it, and split it + * into lines to eventually store new lines into the 'backlog'. + */ +typedef struct mish_input_t { + // lines read from fd are queued in here when \n has been received + mish_line_queue_t backlog; + uint32_t is_telnet : 1, flush_on_nl : 1; + + // return 1 for the character to be stored, 0 for it to be skipped + int (*process_char)( + struct mish_t *m, + struct mish_input_t *i, + uint8_t ch); + void * refcon; // reference constant, for the callbacks + int fd; + mish_line_p line; +} mish_input_t, *mish_input_p; + +/* various internal states for the client */ +enum { + MISH_CLIENT_INIT_SENT = (1 << 0), + MISH_CLIENT_HAS_WINDOW_SIZE = (1 << 1), + MISH_CLIENT_HAS_CURSOR_POS = (1 << 2), + MISH_CLIENT_UPDATE_PROMPT = (1 << 3), + MISH_CLIENT_UPDATE_WINDOW = (1 << 4), + MISH_CLIENT_SCROLLING = (1 << 5), + MISH_CLIENT_DELETE = (1 << 6), +}; + +typedef struct mish_client_t { + TAILQ_ENTRY(mish_client_t) self; + struct mish_t * mish; + uint32_t flags; + + // "coroutine" processing received lines from the stdout/err + struct { + void * state; // state for the prompt coroutine + // _mish_client_interractive_cr() or _mish_client_dumb_cr() + void (*process)( + struct mish_t * m, + struct mish_client_t* c); + } cr; + int footer_height; // # static lines at bottom of screen + int current_vpos; + mish_line_p bottom; + // Line we are currently sending (or NULL) + mish_line_p sending; + + /* + * Output sent to the client is made of bits we want to send to move + * the cursor and so on, and, the actual lines we captured from the program. + * So a vector list is built as the output is built, and it's made of bits + * we've copied in "sqb" as well as lines from the mish backlog. + * Once we deem a good time to output stuff, we send that vector and wait + * until it's all gone before starting again. + */ + struct { + int fd; // index of fd we writev to + struct iovec *v; // starts at NULL + int count;// how many are filled in + int size; // how many are allocated + // temporary sequence buffer, for composite output. + mish_line_p sqb; + size_t total; // total bytes we sent + } output; + + char prompt[64]; + /* Since the prompt will contains more bytes than displayed glyphs, + * we keep track of the number of glyphs so we can reposition the + * cursor accurately. */ + int prompt_gc; // prompt real glyph count + + /* + * Unfiltered console input from the client. This get stored in there + * until the input code notices any output has been sent. Then it is + * passed down to 'vts' + */ + mish_input_t input; + /* + * this handles the vt sequences received at the command prompt, + * like direction keys etc -also handles UTF8 sequences- (but doesn't do + * anything with them). It is also subverted by the telnet decoder to + * do it's own things, separately. + * Sequences coming out are processed in mish_client_input. + */ + mish_vt_sequence_t vts; + /* + * Stuff received from 'input' side gets filtered via 'vts' and + * stored in this. + * Once a command has been validated, it is added back to the input + * backlog to make this client 'history' + */ + mish_line_p cmd; + + struct { + int w, h; } window_size; // valid if MISH_CLIENT_HAS_WINDOW_SIZE + struct { + int x, y; } cursor_pos; // valid if MISH_CLIENT_HAS_CURSOR_POS +} mish_client_t, *mish_client_p; + +// supplement the public ones from mish.h +enum { + MISH_QUIT = (1 << 31), + // the process console we started was a tty, so has terminal settings + MISH_CONSOLE_TTY = (1 << 30), +}; + +typedef struct mish_t { + uint32_t flags; + struct termios orig_termios; // original terminal settings + int originals[2]; // backup the original 1,2 fds + /* These are the ones we use to read the output from the main program. */ + mish_input_t origin[2]; + uint64_t stamp_start; + + TAILQ_HEAD(, mish_client_t) clients; + mish_client_p console; // client that is also the original terminal. + + pthread_t capture; // libmish main thread + pthread_t main; // todo: allow pause/stop/resume? + + struct { + mish_line_queue_t log; + unsigned int size; // number of lines in backlog + size_t alloc; // number of bytes in the backlog + } backlog; + struct { + int listen; // listen socket + int port; // port we're listening on + } telnet; + // Used by the select thread in mish_capture_select.c + struct { + fd_set read, write; + int max; + } select; +} mish_t, *mish_p; + +mish_client_p +mish_client_new( + mish_p m, + int in, + int out, + int is_tty); +void +mish_client_delete( + mish_p m, + mish_client_p c); + +/* + * Sequence buffer handling + */ +int +_mish_send_flush( + mish_p m, + mish_client_p c); +void +_mish_send_queue( + mish_client_p c, + const char * b); +void +_mish_send_queue_fmt( + mish_client_p c, + const char *fmt, ...); +void +_mish_send_queue_line( + mish_client_p c, + mish_line_p line ); + +//! Parse current input buffer fro VT sequences, like keys. +int +_mish_client_vt_parse_input( + struct mish_t *m, + struct mish_input_t *in, + uint8_t ich); + +/* + * This is the main interactive client coroutine. This one is interesting. + */ +void +_mish_client_interractive_cr( + mish_p m, + mish_client_p c); +void +_mish_client_dumb_cr( + mish_p m, + mish_client_p c); + +uint64_t +_mish_stamp_ms(); + +/* + * telnet handling + */ +int +mish_telnet_prepare( + mish_p m, + uint16_t port); +int +mish_telnet_in_check( + mish_p m, + fd_set * r); +void +mish_telnet_send_init( + mish_client_p c); +int +_mish_telnet_parse( + mish_client_p c, + uint8_t ch); + +/* + * input handling + */ +void +_mish_input_init( + mish_p m, + mish_input_p in, + int fd); +void +_mish_input_clear( + mish_p m, + mish_input_p in); +int +_mish_input_read( + mish_p m, + fd_set * fds, + mish_input_p in); + +/* + * Capture thread function + */ +void * +_mish_capture_select( + void *param); + +/* + * https://en.wikipedia.org/wiki/ANSI_escape_code#Terminal_output_sequences + */ +#define MISH_COLOR_RED "\033[38;5;125m" +#define MISH_COLOR_GREEN "\033[38;5;28m" +#define MISH_COLOR_RESET "\033[0m" + +#endif /* LIBMISH_SRC_MISH_PRIV_H_ */ diff --git a/libmish/src/mish_priv_cmd.h b/libmish/src/mish_priv_cmd.h new file mode 100644 index 0000000..7542580 --- /dev/null +++ b/libmish/src/mish_priv_cmd.h @@ -0,0 +1,37 @@ +/* + * mish_priv_cmd.h + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef LIBMISH_SRC_MISH_PRIV_CMD_H_ +#define LIBMISH_SRC_MISH_PRIV_CMD_H_ + +/* + * I decided that the command list would't be attached to the mish_t, + * + * In any other API I would, for consistency sake, but here I'm more + * interested in having a convenient way to add commands, regardless of the + * state of mish_t, and have macro that register them before main() is called + * and that sort of things. + * + * In the same vein, I also don't provide a way to remove a command, I don't + * think it's terribly necessary at the minute + */ +#include "bsd_queue.h" + +typedef void (*mish_cmd_handler_p)( + void * param, + int argc, + const char *argv[]); +#define _LIBMISH_HAS_CMD_HANDLER_ + +int +mish_cmd_call( + const char * cmd_line, + void * c); + + +#endif /* LIBMISH_SRC_MISH_PRIV_CMD_H_ */ diff --git a/libmish/src/mish_priv_line.h b/libmish/src/mish_priv_line.h new file mode 100644 index 0000000..c7dcbb5 --- /dev/null +++ b/libmish/src/mish_priv_line.h @@ -0,0 +1,47 @@ +/* + * mish_priv_line.h + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef LIBMISH_SRC_MISH_PRIV_LINE_H_ +#define LIBMISH_SRC_MISH_PRIV_LINE_H_ + +#include +#include "bsd_queue.h" + +#define MISH_MAX_LINE_SIZE 0xffff + +struct mish_line_t { + TAILQ_ENTRY(mish_line_t) self; + /* The stamp is made with _mish_get_stamp, which returns epoch + * milliseconds, so we don't need the 64 bits for the stamp here, + * lets say 34 bits seconds + 10 bits milliseconds + */ + uint64_t stamp : 44; + uint64_t err: 1, use: 4, draw_stamp: 1, + size : 16, len: 16, // len <= size + done: 16; // done <= len + char line[0]; +}; + +typedef struct mish_line_t mish_line_t, *mish_line_p; + +typedef TAILQ_HEAD(mish_line_queue_t, mish_line_t) mish_line_queue_t; + +/* + * mish_line tools + */ +int +_mish_line_reserve( + mish_line_p *line, + uint32_t count); +mish_line_p +_mish_line_add( + mish_line_queue_t * q, + char * buffer, + size_t length ); + +#endif /* LIBMISH_SRC_MISH_PRIV_LINE_H_ */ diff --git a/libmish/src/mish_priv_vt.h b/libmish/src/mish_priv_vt.h new file mode 100644 index 0000000..4ca1fdd --- /dev/null +++ b/libmish/src/mish_priv_vt.h @@ -0,0 +1,48 @@ +/* + * mish_priv_vt.h + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef LIBMISH_SRC_MISH_PRIV_VT_H_ +#define LIBMISH_SRC_MISH_PRIV_VT_H_ + +#include + +/* + * Input sequence decoder, deals with all the ESC bits and + * any UTF8 bits that gets encountered + */ +#define MISH_VT_RAW 0 +#define MISH_VT_TELNET (0xff) +#define MISH_VT_ESC (0x1b) +#define MISH_VT_CSI ((MISH_VT_ESC << 8) | ('[')) +#define MISH_VT_CSIQ ((MISH_VT_CSI << 8) | ('?')) +#define MISH_VT_UTF8 0x80 + +// allow writing MISH_VT_SEQ(CSI, 'H') +#define MISH_VT_SEQ(_kind, _ch) (((MISH_VT_ ## _kind) << 8) | (_ch)) + +typedef struct mish_vt_sequence_t { + uint32_t seq; // ESC, CSI, CSI? + int p[8]; + union { + struct { + uint32_t pc : 4, // CSI; parameter count + seq_want : 4, // how many more bytes we want (UTF8) + done : 1, // sequence is done + error : 1; // sequence was not valid + }; + uint32_t flags; + }; + uint32_t glyph; // for RAW and UTF8 +} mish_vt_sequence_t, *mish_vt_sequence_p; + +int +_mish_vt_sequence_char( + mish_vt_sequence_p s, + uint8_t ch); + +#endif /* LIBMISH_SRC_MISH_PRIV_VT_H_ */ diff --git a/libmish/src/mish_send.c b/libmish/src/mish_send.c new file mode 100644 index 0000000..7bb417f --- /dev/null +++ b/libmish/src/mish_send.c @@ -0,0 +1,200 @@ +/* + * mish_send.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include "mish_priv.h" +#include "mish_priv_line.h" + +/* + * We arrive here with an array of iovec buffers already prepared by + * _mish_send_queue_*(); + * This is called repeatedly, and we continually call writev, gather how + * many bytes have been written, and mark each corresponding buffer as done. + * Once all the iovec buffers have been filled, we're done! + * + * All of this is made to reduce to the max the number of 'write' system + * calls. + * + * There are two kinds of buffers in the vectors: + * 1) the "backlog" lines themselves. These have a pointer, all is well and good. + * 2) sequences we are making up on the fly, like prompt, colors etc; these + * are allocated in a 'sqb' (sequence buffer) which can grow (via realloc) + * as more stuff is added. + * Therefore, we can't pre-populate the vector array with the iov_base + * pointers, we keep these to NULL, and in this function, the first thing + * we do is derivate the pointers from their 'iov_len' in the current 'sqb'. + * + * Oh and we "lock" sqb to prevent any other things to be added. + */ +int +_mish_send_flush( + mish_p m, + mish_client_p c) +{ + /* If it's a new sequence, 'lock' it and prepare it's iovec pointers */ + if (c->output.sqb) { + if (!c->output.sqb->done) { + /* + * Here we construct the base address of out character buffers. + * They start with a NULL address as the sqb could grow when + * adding sequences. + * So once we are ready to send, we need to compute the + * base addresses of everyone that ought to point into the sqb, + * then we 'lock' it by marking it 'done'. + */ + char * base = c->output.sqb->line; + for (int i = 0; i < c->output.count; i++) { + if (!c->output.v[i].iov_base) { + c->output.v[i].iov_base = base; + base += c->output.v[i].iov_len; + } + } + c->output.sqb->done = 1; // "lock" the sqb until all is sent. + } + } + if (!c->output.count) + return 0; + /* if we don't have 'permission' to write yet, ask for it */ + if (!FD_ISSET(c->output.fd, &m->select.write)) { + FD_SET(c->output.fd, &m->select.write); + return 1; + } + /* skip what we've already done */ + struct iovec * io = c->output.v; + int ioc = c->output.count; + while (io->iov_len == 0 && ioc) { + io++; ioc--; + } + int res = 1; + if (ioc) { + ssize_t got = writev(c->output.fd, io, ioc); + if (got == -1) { + if (errno != EAGAIN && errno != EWOULDBLOCK) { + // we've been close down? + FD_CLR(c->output.fd, &m->select.write); + goto done; + } + } + /* fill up vectors with what was written */ + while (got > 0) { + ssize_t b = got > io->iov_len ? io->iov_len : got; + io->iov_len -= b; + io->iov_base += b; + if (io->iov_len == 0) { + io++; + ioc--; + } + got -= b; + } + } + if (ioc == 0) { // done! +done: + res = 0; + c->output.count = 0; + // also flush out temporary buffers, and unlock it + if (c->output.sqb) { + c->output.sqb->done = 0; + c->output.sqb->len = 0; + } + /* if nothing else is ready to send, clear us from the select loop */ + if (!c->sending) + FD_CLR(c->output.fd, &m->select.write); + } + return res; +} + +/* + * Add up a bit of output to something we want to send as a sequence + */ +static char * +_mish_send_prep( + mish_client_p c, + size_t l) +{ + if (c->output.sqb && c->output.sqb->done) { + fprintf(stderr, "%s problem\n", __func__); + abort(); + } + c->output.total += l; + /* allocate enough in the character buffer */ + _mish_line_reserve(&c->output.sqb, l + 1); + /* allocate enough in the vector buffer */ + if (c->output.count == c->output.size) { + c->output.size += 8; + c->output.v = realloc(c->output.v, c->output.size * sizeof(c->output.v[0])); + } + /* this is where the calling function will copy it's data */ + char * res = (char*)c->output.sqb->line + c->output.sqb->len; + c->output.sqb->len += l; + /* try to concatenate buffers together, if they are 'ours' */ + if (c->output.count && c->output.v[c->output.count-1].iov_base == NULL) { + struct iovec *v = c->output.v + c->output.count - 1; + v->iov_len += l; + } else { + struct iovec *v = c->output.v + c->output.count; + v->iov_base = NULL; // important, see top of the file for details + v->iov_len = l; + v++; + c->output.count++; + } + return res; +} + +/* + * Add up a bit of output to something we want to send as a sequence + */ +void +_mish_send_queue( + mish_client_p c, + const char * b) +{ + int l = strlen(b); + char *d = _mish_send_prep(c, l); + + strcpy(d, b); +} + +/* + * Same as above, but with formatting. + */ +void +_mish_send_queue_fmt( + mish_client_p c, + const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + int l = vsnprintf(NULL, 0, fmt, ap); + va_end(ap); + char *d = _mish_send_prep(c, l); + va_start(ap, fmt); + vsnprintf(d, l + 1, fmt, ap); + va_end(ap); +} + +void +_mish_send_queue_line( + mish_client_p c, + mish_line_p line ) +{ + /* allocate enough in the vector buffer */ + if (c->output.count == c->output.size) { + c->output.size += 8; + c->output.v = realloc(c->output.v, c->output.size * sizeof(c->output.v[0])); + } + struct iovec *v = c->output.v + c->output.count; + v->iov_base = line->line; + v->iov_len = line->len; + c->output.count++; + c->output.total += line->len; +} diff --git a/libmish/src/mish_session.c b/libmish/src/mish_session.c new file mode 100644 index 0000000..47228ae --- /dev/null +++ b/libmish/src/mish_session.c @@ -0,0 +1,282 @@ +/* + * mish_session.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include // for isatty etc + +#ifdef __MACH__ +#include +#include +#include // for openpty +#endif + +#ifdef __linux__ +#include +#endif + +#include "mish_priv.h" +#include "mish.h" + +/* + * get a localtime equivalent, with milliseconds added + */ +uint64_t +_mish_stamp_ms() +{ + struct timespec tim; +#ifdef __MACH__ + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); + clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + tim.tv_sec = mts.tv_sec; + tim.tv_nsec = mts.tv_nsec; +#else + clock_gettime(CLOCK_REALTIME, &tim); +#endif + + uint64_t res = (tim.tv_sec * 1000) + (tim.tv_nsec / 1000000); + return res; +} + +/* + * need to keep this around for atexit() + */ +static mish_p _mish = NULL; + +static void +_mish_atexit() +{ + if (_mish) + mish_terminate(_mish); +} + +mish_p +mish_prepare( + unsigned long caps ) +{ + /* In production, of if you want to make sure mish is disabled without + * re-linking, set this env variable. + */ + if (getenv("MISH_OFF")) { + if (atoi(getenv("MISH_OFF"))) { + unsetenv("MISH_TELNET_PORT"); + printf("mish: Disabled my MISH_OFF\n"); + return NULL; + } + } + + mish_p m = (mish_p)calloc(1, sizeof(*m)); + + FD_ZERO(&m->select.read); + FD_ZERO(&m->select.write); + TAILQ_INIT(&m->backlog.log); + TAILQ_INIT(&m->clients); + m->flags = caps; + int tty = 0; + if (getenv("MISH_TTY")) { + tty = atoi(getenv("MISH_TTY")); + } else + tty = (isatty(0) && isatty(1) && isatty(2)) || + (caps & MISH_CAP_FORCE_PTY); + int io[2]; // stdout pipe + int ie[2]; // stderr pipe +#if !defined(__wasm__) + { + char pty[80]; + if (openpty(&io[0], &io[1], pty, NULL, NULL) == -1) { + perror("openpty"); + goto error; + } + if (!(caps & MISH_CAP_NO_STDERR)) { + if (openpty(&ie[0], &ie[1], pty, NULL, NULL) == -1) { + perror("openpty"); + goto error; + } + } + if (tty) + m->flags |= MISH_CONSOLE_TTY; + if (tcgetattr(0, &m->orig_termios)) + perror("tcgetattr"); + struct termios raw = m->orig_termios; + raw.c_iflag &= ~(ICRNL | IXON); + raw.c_lflag &= ~(ECHO | ICANON | IEXTEN); // ISIG + if (tcsetattr(0, TCSAFLUSH, &raw)) + perror("tcsetattr"); + } +#endif + if (!(caps & MISH_CAP_NO_TELNET)) { + uint16_t port = 0; // suggested telnet port + if (getenv("MISH_TELNET_PORT")) + port = atoi(getenv("MISH_TELNET_PORT")); + + if (mish_telnet_prepare(m, port) == 0) { + char port[8]; + snprintf(port, sizeof(port), "%d", m->telnet.port); + setenv("MISH_TELNET_PORT", port, 1); + } else + unsetenv("MISH_TELNET_PORT"); + } + + // backup the existing descriptors, to make a 'client', we replace + // the original 1,2 with out own pipe/pty + m->originals[0] = dup(1); + m->originals[1] = dup(2); + // we do another dup(0,1) here, as that client will close() them + m->console = mish_client_new(m, dup(0), dup(1), tty); + m->stamp_start = _mish_stamp_ms(); + + _mish_input_init(m, &m->origin[0], io[0]); + if (dup2(io[1], 1) == -1) { + perror("dup2"); + goto error; + } + if (!(caps & MISH_CAP_NO_STDERR)) { + _mish_input_init(m, &m->origin[1], ie[0]); + if (dup2(ie[1], 2) == -1) { + perror("dup2"); + goto error; + } + } + atexit(_mish_atexit); +// m->main = pthread_self(); + // TODO: Make an epoll polling thread for linux + pthread_create(&m->capture, NULL, _mish_capture_select, m); + + _mish = m; + return m; +error: + if (io[0]) { + close(io[0]); + close(io[1]); + } + if (ie[0]) { + close(ie[0]); + close(ie[1]); + } + free(m); + return NULL; +} + +unsigned long +mish_get_flags( + struct mish_t *m) +{ + return m ? m->flags : 0; +} + +/* + * This can be called at any time; if the thread is running, tell it to + * close everything and exit... then wait for a little bit for it to + * terminate, then restore the terminal. + */ +void +mish_terminate( + mish_p m) +{ + if (!_mish) + return; + // restore normal IOs + dup2(m->originals[0], 1); + dup2(m->originals[1], 2); + // the thread does this, but we also do it in case this function is + // called from another exit(x) +#if !defined(__wasm__) + if ((m->flags & MISH_CONSOLE_TTY) && + tcsetattr(0, TCSAFLUSH, &m->orig_termios)) + perror("mish_terminate tcsetattr"); +#endif + close(m->originals[0]); close(m->originals[1]); + if (m->capture) { + m->flags |= MISH_QUIT; + // this will wake the select() call from sleep + if (write(1, "\n", 1)) + ; + + time_t start = time(NULL); + time_t now; + while (((now = time(NULL)) - start < 2) && m->capture) + usleep(1000); + } + printf("\033[4l\033[;r\033[999;1H"); fflush(stdout); + printf("%s done\n", __func__); + free(m); + _mish = NULL; +} + +static void +_mish_cmd_quit( + void * param, + int argc, + const char * argv[]) +{ + printf(MISH_COLOR_RED + "mish: Quitting." + MISH_COLOR_RESET "\n"); + + mish_p m = ((mish_client_p)param)->mish; + m->flags |= MISH_QUIT; +} + +MISH_CMD_NAMES(quit, "q", "quit"); +MISH_CMD_HELP(quit, + "exit running program", + "Close all clients and exit(0)"); +MISH_CMD_REGISTER(quit, _mish_cmd_quit); + +#define VT_COL(_c) "\033[" #_c "G" + +static void +_mish_cmd_mish( + void * param, + int argc, + const char * argv[]) +{ + printf(MISH_COLOR_RED + "mish: mish command." + MISH_COLOR_RESET "\n"); + + mish_p m = ((mish_client_p)param)->mish; + printf("Backlog: %6d lines (%5dKB)" VT_COL(40) "Telnet Port: %5d\n", + m->backlog.size, + (int)m->backlog.alloc / 1024, + m->telnet.port); +#if 0 + printf(" read: "); + for (int i = 0; i < m->select.max; i++) + if (FD_ISSET(i, &m->select.read)) printf("%d ", i); + printf(VT_COL(40) " write: "); + for (int i = 0; i < m->select.max; i++) + if (FD_ISSET(i, &m->select.write)) printf("%d ", i); + printf("\n"); +#endif + mish_client_p c; + TAILQ_FOREACH(c, &m->clients, self) { + printf(" Client: r: %d w: %d %s %s\n", + c->input.fd, c->output.fd, + c->input.is_telnet ? "telnet session" : + c == m->console ? "console" : "*unknown*", + c == m->console ? + m->flags & MISH_CONSOLE_TTY ? "(tty)": "(dumb)" + : ""); + printf(" max sizes: vector: %d input: %d\n", + c->output.size, c->input.line ? c->input.line->size : 0); + } + +} + +MISH_CMD_NAMES(mish, "mish"); +MISH_CMD_HELP(mish, + "Displays mish status.", + "Show status and a few bits of internals."); +MISH_CMD_REGISTER(mish, _mish_cmd_mish); + diff --git a/libmish/src/mish_telnet.c b/libmish/src/mish_telnet.c new file mode 100644 index 0000000..febd93c --- /dev/null +++ b/libmish/src/mish_telnet.c @@ -0,0 +1,241 @@ +/* + * mish_telnet.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "mish_priv.h" + +#ifdef DEBUG_TELNET +#define TELCMDS +#define TELOPTS +#define TV(w) w +#else +#define TV(w) +#endif +#include + +/* + * Ask remote telnet client to turn off echo, and send us the NAWS + */ +void +mish_telnet_send_init( + mish_client_p c) +{ + const unsigned char init[] = { + IAC, DO, TELOPT_ECHO, + IAC, DO, TELOPT_NAWS, + IAC, WILL, TELOPT_ECHO, + IAC, WILL, TELOPT_SGA, + 0, + }; + _mish_send_queue(c, (char*)init); +} + +/* + * This looks for the TELNET IAC prefix, and handles /some/ of them. + * The one we're really interested in anyway is the NAWS aka Window Size + * sequence. + * All the other ones are ignored, but parsed. Ish. + */ +int +_mish_telnet_parse( + mish_client_p c, + uint8_t ch) +{ + TV(printf("%02x(%d) %s (seq %06x)\n", + ch, ch, ch >= xEOF ? telcmds[ch-xEOF] : "", + c->vts.seq);) + /* + * To handle telnet sequences, we pause the VT decoder + */ + switch (c->vts.seq) { + case MISH_VT_RAW: + if (ch == IAC) { + c->vts.seq = MISH_VT_TELNET; + return 1; + } + break; + case MISH_VT_TELNET: { + switch (ch) { + case WILL: + case WONT: + case DO: + case DONT: + case SB: + c->vts.seq = c->vts.seq << 8 | ch; + return 1; + default: + case SE: + c->vts.seq = MISH_VT_RAW; + return 1; + } + } break; + case MISH_VT_SEQ(TELNET, IAC): + TV(printf("IAC %d %s\n\n", ch, telopts[ch]);) + c->vts.seq = MISH_VT_RAW; + break; // let this one thru!!! + case MISH_VT_SEQ(TELNET, WILL): + TV(printf("WILL %d %s\n\n", ch, telopts[ch]);) + c->vts.seq = MISH_VT_RAW; + return 1; + case MISH_VT_SEQ(TELNET, WONT): + TV(printf("WONT %d %s\n", ch, telopts[ch]);) + c->vts.seq = MISH_VT_RAW; + return 1; + case MISH_VT_SEQ(TELNET, DO): + TV(printf("DO %d %s\n", ch, telopts[ch]);) + c->vts.seq = MISH_VT_RAW; + return 1; + case MISH_VT_SEQ(TELNET, DONT): + TV(printf("DONT %d %s\n", ch, telopts[ch]);) + c->vts.seq = MISH_VT_RAW; + return 1; + case MISH_VT_SEQ(TELNET, SB): + TV(printf("SB %d %s\n", ch, telopts[ch]);) + c->vts.seq_want = 0; + c->vts.p[0] = 0; + switch (ch) { + case TELOPT_NAWS: + c->vts.seq = c->vts.seq << 8 | ch; + return 1; + default: + if (ch == IAC) { + c->vts.seq = MISH_VT_TELNET; + return 1; + } + } + return 1; + case (MISH_VT_SEQ(TELNET, SB) << 8 | (TELOPT_NAWS)): { + switch (c->vts.seq_want++) { + case 0: + c->vts.p[0] = 0; + c->vts.p[1] = ch; + return 1; + case 1: c->vts.p[1] = (c->vts.p[1] << 8) | ch; return 1; + case 2: c->vts.p[0] = ch; return 1; + case 3: c->vts.p[0] = (c->vts.p[0] << 8) | ch; /* fallthru */ + } + if (c->vts.seq_want == 4) { + TV(printf("GOT NAWS: %dx%d\n", c->vts.p[0], c->vts.p[1]);) + c->window_size.h = c->vts.p[0]; + c->window_size.w = c->vts.p[1]; + c->flags |= MISH_CLIENT_HAS_WINDOW_SIZE | + MISH_CLIENT_UPDATE_WINDOW; + c->vts.seq = MISH_VT_RAW; + c->vts.done = 1; + return 1; + } + } return 1; + } + return 0; +} + +extern const char *__progname; + +/* + * not going to go thru all the bits regarding sockets here, you know it. + * + * We allocate a random port, and listen to it, then add it to the + * main select() thread. + */ +int +mish_telnet_prepare( + mish_p m, + uint16_t port) +{ + m->telnet.listen = socket(AF_INET, SOCK_STREAM, 0); + int flag = 1; + + signal(SIGPIPE, SIG_IGN); + if (setsockopt(m->telnet.listen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) + perror("SO_REUSEADDR"); + + struct sockaddr_in b = { + .sin_family = AF_INET, + .sin_addr.s_addr = htonl(INADDR_LOOPBACK), + }; + // attempts to generate a pseudo random port based on the executable name + // before having to rely on random(). This gives a chance of 'unique' ports + // per programs. + if (port == 0) { + for (int i = 0; __progname[i]; i++) + port += __progname[i] + i; + if (port < 1024) + port += 1024; + port = port & 0x3fff; + } + + int tries = 5; + do { + b.sin_port = htons(port); + if (bind(m->telnet.listen, (struct sockaddr *)&b, sizeof(b)) == -1) { + fprintf(stderr, "%s can't bind %d\n", __func__, ntohs(b.sin_port)); + port = port + (random() & 0x3ff); + continue; + } + m->telnet.port = ntohs(b.sin_port); + printf(MISH_COLOR_GREEN + "mish: telnet port on %d" + MISH_COLOR_RESET "\n", + m->telnet.port); + break; + } while (tries-- > 0); + if (tries) { + if (listen(m->telnet.listen, 2) == -1) { + perror("mish_telnet_prepare listen"); + goto error; + } + FD_SET(m->telnet.listen, &m->select.read); + return 0; + } + fprintf(stderr, "mish: %s failed\n", __func__); +error: + close(m->telnet.listen); + m->telnet.listen = -1; + return -1; +} + +/* + * Accept a new connection from the telnet port, add a new client + */ +int +mish_telnet_in_check( + mish_p m, + fd_set * r) +{ + if (!FD_ISSET(m->telnet.listen, r)) + return 0; + + struct sockaddr_in a = {}; + socklen_t al = sizeof(a); + int tf = accept(m->telnet.listen, (struct sockaddr *) &a, &al); + if (tf < 0) { + perror(__func__); + return -1; + } + /* + * it is necessary to have TWO file descriptors here, otherwise + * the FD_SET/FD_CLR logic could be confusing as using the same bits. + * a dup() isn't terribly expensive and guarantees we don't have to + * worry about it. + */ + mish_client_p c = mish_client_new(m, tf, dup(tf), 1 /* tty */); + c->input.is_telnet = 1; + + printf(MISH_COLOR_GREEN + "mish: telnet: connected." + MISH_COLOR_RESET "\n"); + + return 0; +} diff --git a/libmish/src/mish_vt.c b/libmish/src/mish_vt.c new file mode 100644 index 0000000..61d4864 --- /dev/null +++ b/libmish/src/mish_vt.c @@ -0,0 +1,105 @@ +/* + * mish_vt.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "mish_priv_vt.h" + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(_a) (sizeof(_a) / sizeof((_a)[0])) +#endif + +/* + * Handle sequences of VT100 and UTF8 chars. + * + * Uses the sequence 's' as temporary buffer, and returns 1 when a complete + * sequence OR a glyph has been decoded. + */ +int +_mish_vt_sequence_char( + mish_vt_sequence_p s, + uint8_t ch) +{ + // if previous sequence was done, reset it. + if (s->done) + s->flags = s->seq = s->glyph = s->pc = s->p[0] = 0; + switch (s->seq) { + case MISH_VT_RAW: { + switch (ch) { + case 0x1b: + s->seq = MISH_VT_ESC; + break; + default: { + if (ch & 0x80) { // UTF8 !??! + int mask = 0x40; + s->seq_want = 0; + while ((ch & mask) && s->seq_want < 5) { + s->seq_want++; + mask >>= 1; + } + // clear header bits (ought to be 2; 1 allows encoding of 0xffffff) + s->glyph = ch & (0xff >> (s->seq_want + 1)); + s->seq = MISH_VT_UTF8; + } else { + s->seq = (s->seq << 8) | ch; + s->glyph = ch; // technically it's a glyph + s->done = 1; + } + } + } + } break; + case MISH_VT_ESC: { + if (ch == '[') + s->seq = MISH_VT_CSI; + else { + s->seq = (s->seq << 8) | ch; + s->done = 1; + } + } break; + case MISH_VT_CSIQ: + case MISH_VT_CSI: { + switch (ch) { + case '?': { + // note this would still accept somelike like CSI ? 00?; 1 + if ((s->seq == MISH_VT_CSIQ) || s->pc) { + s->done = s->error = 1; + } else + s->seq = MISH_VT_CSIQ; + } break; + case '0' ... '9': + s->p[s->pc] = (s->p[s->pc] * 10) + (ch - '0'); + break; + case ';': { + if (s->pc < ARRAY_SIZE(s->p)) { + s->pc++; + s->p[s->pc] = 0; + } else { + s->done = s->error = 1; + } + } break; + default: + if (s->p[s->pc]) + s->pc++; + s->seq = (s->seq << 8) | ch; + s->done = 1; + break; + } + } break; + case MISH_VT_UTF8: { + s->glyph = (s->glyph << 6) | (ch & 0x3f); + if (s->seq_want) s->seq_want--; + s->done = s->seq_want == 0; + } break; + } +#ifdef MISH_VT_DEBUG + if (s->done) + fprintf(stderr, "in %x(%c) state %x done:%d error:%d pc:%d/%d\n", + ch, ch < ' '?'.':ch,s->seq, s->done, s->error, + s->pc, (int)ARRAY_SIZE(s->p)); +#endif + return s->done; +} diff --git a/libmish/tests/mish_argv_make_test.c b/libmish/tests/mish_argv_make_test.c new file mode 100644 index 0000000..3fabd23 --- /dev/null +++ b/libmish/tests/mish_argv_make_test.c @@ -0,0 +1,95 @@ +// small test unit for mish_argv_make +#include +#include +#include + + +typedef struct _mish_argv_t { + char * line; + int ac; + char * av[0]; +} _mish_argv_t; +/* + * Duplicate 'line', split it into words, store word pointers in an array, + * NULL terminate it. Also return the number of words in the array in argc. + * + * The returned value is made of two malloc()ed blocks. use mish_argv_free + * to free the memory. + * It's OK to change any of the pointers. But no not try to realloc() the + * vector as it hides a structure + */ +static char ** +mish_argv_make( + const char * line, + int * argc ) +{ + const char separator = ' '; + _mish_argv_t * r = calloc(1, sizeof(*r)); + r->line = strdup(line); + char *dup = r->line; + char quote; + enum { s_newarg = 0, s_startarg, s_copyquote, s_skip, s_copy }; + int state = s_newarg; + do { + switch (state) { + case s_newarg: + r = realloc(r, sizeof(*r) + ((r->ac + 2) * sizeof(char*))); + while (*dup == ' ' || *dup == separator) + dup++; + r->av[r->ac++] = dup; + state = s_startarg; + break; + case s_startarg: + if (*dup == '"' || *dup == '\'') { + quote = *dup++; + state = s_copyquote; + } else + state = s_copy; + break; + case s_copyquote: + if (*dup == '\\') + state = s_skip; + else if (*dup == quote) { + state = s_newarg; + dup++; + if (*dup) *dup++ = 0; + } else if (*dup) + dup++; + break; + case s_skip: + dup++; + state = s_copyquote; + break; + case s_copy: + if (*dup == 0) + break; + if (*dup != separator) + dup++; + else { + state = s_newarg; + if (*dup) *dup++ = 0; + } + break; + } + } while (*dup); + r->av[r->ac] = NULL; + if (argc) + *argc = r->ac; + return r->av; +} + +int main() { + int argc = 0; + char **argv = mish_argv_make("testing \"one escape two\" lala ", &argc); + + printf("argc = %d\n", argc); + for (int i = 0; argv[i]; i++) + printf("%2d:'%s'\n", i, argv[i]); + + argv = mish_argv_make("command with some \" quoted\\\"words \" should work\n", &argc); + + printf("argc = %d\n", argc); + for (int i = 0; argv[i]; i++) + printf("%2d:'%s'\n", i, argv[i]); + +} diff --git a/libmish/tests/mish_cmd_test.c b/libmish/tests/mish_cmd_test.c new file mode 100644 index 0000000..d48de73 --- /dev/null +++ b/libmish/tests/mish_cmd_test.c @@ -0,0 +1,20 @@ +/* + * mish_cmd_test.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "mish_cmd.c" + +int main() +{ + int argc; + char ** argv = mish_argv_make( + "command with some \" quoted\\\"words \" should work\n", &argc); + + for (int i = 0; i < argc; i++) + printf("%2d: '%s'\n", i, argv[i]); + mish_argv_free(argv); +} diff --git a/libmish/tests/mish_debug_test.c b/libmish/tests/mish_debug_test.c new file mode 100644 index 0000000..c32e559 --- /dev/null +++ b/libmish/tests/mish_debug_test.c @@ -0,0 +1,94 @@ +/* + * mish_debug_test.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/* + * NOTE this program is made for debug purpose only, it basically give you + * telnet command access remotely + * IT IS JUST MADE TO DEBUG LIBMISH, DO NOT USE IN PROD! + */ +#define _GNU_SOURCE // for asprintf +#include +#include +#include +#include +#include +#include +#include +#include "mish.h" + +static void +sigchld_handler(int s) +{ + int status = 0; + pid_t pid = waitpid(-1, &status, WNOHANG); + if (pid > 0) { + if (WIFEXITED(status) && WEXITSTATUS(status)) + fprintf(stderr, "pid %d returned %d\n", (int)pid, WEXITSTATUS(status)); + if (WIFSIGNALED(status)) + fprintf(stderr, "pid %d terminated with %s\n", + (int)pid, strsignal(WTERMSIG(status))); + } +} + +int main() +{ + signal(SIGCHLD, sigchld_handler); + mish_prepare(0); + + while (1) { + sleep(1); + } +} + +static const char * +_shell_which( + const char * cmd) +{ + if (cmd[0] == '.' || cmd[0] == '/') + return strdup(cmd); + char * path = strdup(getenv("PATH")); + char * cur = path, *e; + while ((e = strsep(&cur, ":")) != NULL) { + char *pe; + asprintf(&pe, "%s/%s", e, cmd); + struct stat st = {}; + if (stat(pe, &st) == 0) { + return pe; + } + free(pe); + } + fprintf(stderr, "%s: command not found\n", cmd); + return NULL; +} + +static void +_test_shell_cnt( + void * param, + int argc, + const char * argv[]) +{ + const char * av[argc + 1]; + av[0] = _shell_which(argv[1]); + if (av[0] == NULL) + return; + for (int ai = 1; ai <= argc; ai++) + av[ai] = argv[ai+1]; + pid_t pid = fork(); + if (pid == 0) { + execv(av[0], (void*)av); + perror(av[0]); + close(0);close(1);close(2); + exit(1); + } +} + +MISH_CMD_NAMES(shell, "shell"); +MISH_CMD_HELP(shell, + "run a shell command", + "test command for libmish!"); +MISH_CMD_REGISTER(shell, _test_shell_cnt); diff --git a/libmish/tests/mish_input_test.c b/libmish/tests/mish_input_test.c new file mode 100644 index 0000000..3cf0aea --- /dev/null +++ b/libmish/tests/mish_input_test.c @@ -0,0 +1,146 @@ +/* + * This is a stress/scenario test for the mish_input_read function + */ +#define MISH_INPUT_TEST + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mish.h" + +static uint8_t *words = NULL; +static size_t words_size = 0; +static size_t words_offset = 0; + +static int ccount = 0; + +static ssize_t _test_read(int fd, void *w, size_t count) { + errno = 0; + + if (!(ccount++ % 17)) { + errno = EAGAIN; + printf("%s fake EAGAIN\n", __func__); + return -1; + } + + if (words_offset + count > words_size) + count = words_size - words_offset; + + memcpy(w, words + words_offset, count); + words_offset += count; + if (!count) { + printf("%s all input sent\n", __func__); + } + return count; +} + +#define read(_a,_b,_c) _test_read(_a,_b,_c) + +#include "mish_input.c" +#include "mish_line.c" + +#undef read + +/* duplicate from mish_session.c */ +/* + * get a localtime equivalent, with milliseconds added + */ +uint64_t +_mish_stamp_ms() +{ + return 0; +} + + +int main() +{ + const char *filen = "/usr/share/dict/american-english"; + struct stat st; + int fd; + if ((lstat(filen, &st) == -1) || (fd = open(filen, O_RDONLY)) == -1) { + perror(filen); + exit(1); + } + words_size = st.st_size; + words = malloc(words_size + 1); + if (read(fd, words, st.st_size) != st.st_size) { + perror("EOF unexpected"); + exit(1); + } + words[words_size] = 0; + printf("File %s read\n", filen); + + /* That's not needed for the test, but init() relies on it */ + mish_t mish = {}; + mish_p m = &mish; + FD_ZERO(&m->select.read); + FD_ZERO(&m->select.write); + TAILQ_INIT(&m->backlog.log); + TAILQ_INIT(&m->clients); + + /* we don't need the file descriptor as we bypass "read" but the + * init function relies on it so here is a socketpair for it to play + * with */ + int sk[2]; + if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk)) { + perror("socketpair"); + exit(1); + } + mish_input_t input = {}; + _mish_input_init(m, &input, sk[0]); + + uint8_t *cursor = words; + int linec = 0; + mish_line_p ln = NULL; + + /* + * Right so now we can actually test the function. We keep a running + * pointer on the source data, and the "last" line we compared, and + * compared line's content with the source buffer. If all goes + * well, they should match exactly. + */ + do { + _mish_input_read(m, &m->select.read, &input); + printf(" read up to o: %d/%d\n", (int)words_offset, (int)words_size); + + if (!ln) + ln = TAILQ_FIRST(&input.backlog); + else if (TAILQ_NEXT(ln, self)) + ln = TAILQ_NEXT(ln, self); + else + continue; + while (ln) { + linec++; + // printf("line %4d: %s", linec, ln->line); + + uint8_t * l = (uint8_t*)ln->line; + for (int ic = 0; ic < ln->len; ic++, cursor++) { + if (l[ic] != *cursor) { + printf("ERROR: Mismatch Offset %ld char #%d/%d (%x/%x) line %d: %s\n", + cursor - words, ic, + ln->len, + l[ic], *cursor, + linec, l); + goto done; + } + } + + if (TAILQ_LAST(&input.backlog, mish_line_queue_t) == ln) + break; + ln = TAILQ_NEXT(ln, self); + } + } while (words_offset < words_size); + printf("%d lines were read and compared\n", linec); +done: + exit(0); + +} + diff --git a/libmish/tests/mish_test.c b/libmish/tests/mish_test.c new file mode 100644 index 0000000..2ce0306 --- /dev/null +++ b/libmish/tests/mish_test.c @@ -0,0 +1,43 @@ +/* + * mish_test.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include + +#include "mish.h" + +int cnt = 0; + +int main() +{ + mish_prepare(0); + + while (1) { + sleep(1); + printf("Count %d\n", cnt++); + } +} + + +/* And here is a command line action that can reset the 'cnt' variable */ +static void _test_set_cnt(void * param, int argc, const char * argv[]) +{ + if (argc > 1) { + cnt = atoi(argv[1]); + } else { + fprintf(stderr, + "%s: syntax 'set XXX' to set the variable\n", argv[0]); + } +} + +MISH_CMD_NAMES(set, "set"); +MISH_CMD_HELP(set, + "set 'cnt' variable", + "test command for libmish!"); +MISH_CMD_REGISTER(set, _test_set_cnt); diff --git a/libmish/tests/mish_vt_test.c b/libmish/tests/mish_vt_test.c new file mode 100644 index 0000000..19f3fd6 --- /dev/null +++ b/libmish/tests/mish_vt_test.c @@ -0,0 +1,33 @@ +/* + * mish_vt_test.c + * + * Copyright (C) 2020 Michel Pollet + * + * SPDX-License-Identifier: Apache-2.0 + */ + + +#include +#include +#include "../src/mish_vt.c" + +/* small test unit for the VT decoder, mostly for UTF8 */ +int main() +{ + const char * input = "Hello 😈 \033[1mThere\033[0m"; + + mish_vt_sequence_t sq = {}; + + printf("%s\n", input); + const char *s = input; + int cg = 0; + while (*s) { + if (_mish_vt_sequence_char(&sq, *s)) { + printf("glyph s:%08x g:%08x\n", sq.seq, sq.glyph); + if (sq.glyph) + cg++; + } + s++; + } + printf("%d glyphs in string\n", cg); +} diff --git a/nuklear/mii_emu.c b/nuklear/mii_emu.c new file mode 100644 index 0000000..a7f88ee --- /dev/null +++ b/nuklear/mii_emu.c @@ -0,0 +1,322 @@ +/* + * mii_emu.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define NK_INCLUDE_FIXED_TYPES +#define NK_INCLUDE_STANDARD_IO +#define NK_INCLUDE_STANDARD_VARARGS +#define NK_INCLUDE_DEFAULT_ALLOCATOR +#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT +#define NK_INCLUDE_FONT_BAKING +#define NK_INCLUDE_DEFAULT_FONT +#define NK_BUTTON_TRIGGER_ON_RELEASE +#include "nuklear.h" + +#define NK_XLIB_GL3_IMPLEMENTATION +#define NK_XLIB_LOAD_OPENGL_EXTENSIONS +#include "nuklear_xlib_gl3.h" + +#include "mii.h" +#include "mish.h" + +#define WINDOW_WIDTH 1280 +#define WINDOW_HEIGHT 720 // (10 + (192) * 3) + +#define MAX_VERTEX_BUFFER 512 * 1024 +#define MAX_ELEMENT_BUFFER 128 * 1024 + +void +mii_nuklear( + mii_t *mii, + struct nk_context *ctx); +void +mii_nuklear_init( + mii_t *mii, + struct nk_context *ctx); +/* =============================================================== + * + * DEMO + * + * ===============================================================*/ +struct XWindow { + Display *dpy; + Window win; + XVisualInfo *vis; + Colormap cmap; + XSetWindowAttributes swa; + XWindowAttributes attr; + GLXFBConfig fbc; + Atom wm_delete_window; + int width, height; +}; +static int gl_err = nk_false; +static int gl_error_handler(Display *dpy, XErrorEvent *ev) +{NK_UNUSED(dpy); NK_UNUSED(ev); gl_err = nk_true;return 0;} + +static void +die(const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fputs("\n", stderr); + exit(EXIT_FAILURE); +} + +static int +has_extension(const char *string, const char *ext) +{ + const char *start, *where, *term; + where = strchr(ext, ' '); + if (where || *ext == '\0') + return nk_false; + + for (start = string;;) { + where = strstr((const char*)start, ext); + if (!where) break; + term = where + strlen(ext); + if (where == start || *(where - 1) == ' ') { + if (*term == ' ' || *term == '\0') + return nk_true; + } + start = term; + } + return nk_false; +} + +struct nk_font *nk_main_font = NULL; + +/* global now, mish commands use it */ +mii_t g_mii = {}; + +int +main( + int argc, + const char *argv[]) +{ + /* Platform */ + int running = 1; + struct XWindow win; + GLXContext glContext; + struct nk_context *ctx; + struct nk_colorf bg; + + mii_init(&g_mii); + int idx = 0; + uint32_t flags = MII_INIT_DEFAULT; + int r = mii_argv_parse(&g_mii, argc, argv, &idx, &flags); + if (r == 0) { + printf("mii: Invalid argument %s, skipped\n", argv[idx]); + } else if (r == -1) + exit(1); + mii_prepare(&g_mii, flags); + mish_prepare(1); + printf("MISH_TELNET_PORT = %s\n", getenv("MISH_TELNET_PORT")); + + memset(&win, 0, sizeof(win)); + win.dpy = XOpenDisplay(NULL); + if (!win.dpy) die("Failed to open X display\n"); + { + /* check glx version */ + int glx_major, glx_minor; + if (!glXQueryVersion(win.dpy, &glx_major, &glx_minor)) + die("[X11]: Error: Failed to query OpenGL version\n"); + if ((glx_major == 1 && glx_minor < 3) || (glx_major < 1)) + die("[X11]: Error: Invalid GLX version!\n"); + } + { + /* find and pick matching framebuffer visual */ + int fb_count; + static GLint attr[] = { + GLX_X_RENDERABLE, True, + GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, + GLX_RENDER_TYPE, GLX_RGBA_BIT, + GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, + GLX_RED_SIZE, 8, + GLX_GREEN_SIZE, 8, + GLX_BLUE_SIZE, 8, + GLX_ALPHA_SIZE, 8, + GLX_DEPTH_SIZE, 24, + GLX_STENCIL_SIZE, 8, + GLX_DOUBLEBUFFER, True, + None + }; + GLXFBConfig *fbc; + fbc = glXChooseFBConfig(win.dpy, DefaultScreen(win.dpy), attr, &fb_count); + if (!fbc) die("[X11]: Error: failed to retrieve framebuffer configuration\n"); + { + /* pick framebuffer with most samples per pixel */ + int i; + int fb_best = -1, best_num_samples = -1; + for (i = 0; i < fb_count; ++i) { + XVisualInfo *vi = glXGetVisualFromFBConfig(win.dpy, fbc[i]); + if (vi) { + int sample_buffer, samples; + glXGetFBConfigAttrib(win.dpy, fbc[i], GLX_SAMPLE_BUFFERS, &sample_buffer); + glXGetFBConfigAttrib(win.dpy, fbc[i], GLX_SAMPLES, &samples); + if ((fb_best < 0) || (sample_buffer && samples > best_num_samples)) + fb_best = i, best_num_samples = samples; + XFree(vi); + } + } + win.fbc = fbc[fb_best]; + XFree(fbc); + win.vis = glXGetVisualFromFBConfig(win.dpy, win.fbc); + } + } + { + /* create window */ + win.cmap = XCreateColormap(win.dpy, RootWindow(win.dpy, win.vis->screen), win.vis->visual, AllocNone); + win.swa.colormap = win.cmap; + win.swa.background_pixmap = None; + win.swa.border_pixel = 0; + win.swa.event_mask = + ExposureMask | KeyPressMask | KeyReleaseMask | + ButtonPress | ButtonReleaseMask| ButtonMotionMask | + Button1MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask| + PointerMotionMask| StructureNotifyMask; + win.win = XCreateWindow(win.dpy, RootWindow(win.dpy, win.vis->screen), 0, 0, + WINDOW_WIDTH, WINDOW_HEIGHT, 0, win.vis->depth, InputOutput, + win.vis->visual, CWBorderPixel|CWColormap|CWEventMask, &win.swa); + if (!win.win) die("[X11]: Failed to create window\n"); + XFree(win.vis); + + char title[128]; + sprintf(title, "MII //e Emulator"); + char *telnet = getenv("MISH_TELNET_PORT"); + if (telnet) + sprintf(title + strlen(title), " (telnet port %s)", telnet); + else + sprintf(title + strlen(title), " (telnet disabled)"); + XStoreName(win.dpy, win.win, title); + XMapWindow(win.dpy, win.win); + win.wm_delete_window = XInternAtom(win.dpy, "WM_DELETE_WINDOW", False); + XSetWMProtocols(win.dpy, win.win, &win.wm_delete_window, 1); + } + { + /* create opengl context */ + typedef GLXContext(*glxCreateContext)(Display*, GLXFBConfig, GLXContext, Bool, const int*); + int(*old_handler)(Display*, XErrorEvent*) = XSetErrorHandler(gl_error_handler); + const char *extensions_str = glXQueryExtensionsString(win.dpy, DefaultScreen(win.dpy)); + glxCreateContext create_context = (glxCreateContext) + glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB"); + + gl_err = nk_false; + if (!has_extension(extensions_str, "GLX_ARB_create_context") || !create_context) { + fprintf(stdout, "[X11]: glXCreateContextAttribARB() not found...\n"); + fprintf(stdout, "[X11]: ... using old-style GLX context\n"); + glContext = glXCreateNewContext(win.dpy, win.fbc, GLX_RGBA_TYPE, 0, True); + } else { + GLint attr[] = { + GLX_CONTEXT_MAJOR_VERSION_ARB, 3, + GLX_CONTEXT_MINOR_VERSION_ARB, 0, + None + }; + glContext = create_context(win.dpy, win.fbc, 0, True, attr); + XSync(win.dpy, False); + if (gl_err || !glContext) { + /* Could not create GL 3.0 context. Fallback to old 2.x context. + * If a version below 3.0 is requested, implementations will + * return the newest context version compatible with OpenGL + * version less than version 3.0.*/ + attr[1] = 1; attr[3] = 0; + gl_err = nk_false; + fprintf(stdout, "[X11] Failed to create OpenGL 3.0 context\n"); + fprintf(stdout, "[X11] ... using old-style GLX context!\n"); + glContext = create_context(win.dpy, win.fbc, 0, True, attr); + } + } + XSync(win.dpy, False); + XSetErrorHandler(old_handler); + if (gl_err || !glContext) + die("[X11]: Failed to create an OpenGL context\n"); + glXMakeCurrent(win.dpy, win.win, glContext); + } +//extern const unsigned char mii_proggy_data[]; +//extern const unsigned int mii_proggy_size; +extern const unsigned char mii_droid_data[]; +extern const unsigned int mii_droid_size; + + ctx = nk_x11_init(win.dpy, win.win); + /* Load Fonts: if none of these are loaded a default font will be used */ + { + struct nk_font_atlas *atlas; + nk_x11_font_stash_begin(&atlas); + struct nk_font_config cfg = nk_font_config(0); +#if 0 + nk_rune ranges[] = { + 0x0020, 0x007E, /* Ascii */ + 0x00A1, 0x00FF, /* Symbols + Umlaute */ + 0 + }; +#endif + cfg.range = nk_font_default_glyph_ranges(); + cfg.oversample_h = cfg.oversample_v = 1; + cfg.pixel_snap = true; + nk_main_font = nk_font_atlas_add_from_memory(atlas, + (void*)mii_droid_data, mii_droid_size, 20, &cfg); + nk_x11_font_stash_end(); + /*nk_style_load_all_cursors(ctx, atlas->cursors);*/ + if (nk_main_font) + nk_style_set_font(ctx, &nk_main_font->handle); + } + + mii_nuklear_init(&g_mii, ctx); + + bg.r = 0.0f; bg.g = 0.0f; bg.b = 0.0f; bg.a = 1.0f; +// bg.r = 0.8f; bg.g = 0.8f; bg.b = 0.8f; bg.a = 1.0f; + while (running) { + /* Input */ + XEvent evt; + nk_input_begin(ctx); + while (XPending(win.dpy)) { + XNextEvent(win.dpy, &evt); + if (evt.type == ClientMessage) goto cleanup; + if (XFilterEvent(&evt, win.win)) continue; + nk_x11_handle_event(&evt); + } + nk_input_end(ctx); + + /* GUI */ + mii_nuklear(&g_mii, ctx); + + /* Draw */ + XGetWindowAttributes(win.dpy, win.win, &win.attr); + glViewport(0, 0, win.width, win.height); + glClear(GL_COLOR_BUFFER_BIT); + glClearColor(bg.r, bg.g, bg.b, bg.a); + /* IMPORTANT: `nk_x11_render` modifies some global OpenGL state + * with blending, scissor, face culling, depth test and viewport and + * defaults everything back into a default state. + * Make sure to either a.) save and restore or b.) reset your own state after + * rendering the UI. */ + nk_x11_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER); + glXSwapBuffers(win.dpy, win.win); + } + +cleanup: + nk_x11_shutdown(); + glXMakeCurrent(win.dpy, 0, 0); + glXDestroyContext(win.dpy, glContext); + XUnmapWindow(win.dpy, win.win); + XFreeColormap(win.dpy, win.cmap); + XDestroyWindow(win.dpy, win.win); + XCloseDisplay(win.dpy); + return 0; + +} diff --git a/nuklear/mii_fonts.c b/nuklear/mii_fonts.c new file mode 100644 index 0000000..c6cc735 --- /dev/null +++ b/nuklear/mii_fonts.c @@ -0,0 +1,9 @@ + + +#define INCBIN_STYLE INCBIN_STYLE_SNAKE +#define INCBIN_PREFIX mii_ +#include "incbin.h" + +INCBIN(proggy, "fonts/ProggyClean.ttf"); +INCBIN(droid, "fonts/DroidSans.ttf"); + diff --git a/nuklear/mii_mish.c b/nuklear/mii_mish.c new file mode 100644 index 0000000..c8c9c0c --- /dev/null +++ b/nuklear/mii_mish.c @@ -0,0 +1,436 @@ +/* + * mii_mish.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" +#include "mii_sw.h" +#include "mii_65c02_ops.h" +#include "mii_65c02_disasm.h" + +extern mii_t g_mii; + +void +_mii_mish_text( + void * param, + int argc, + const char * argv[]) +{ + // load 0x400, calculate the 24 line addresses from the code in video + // and show the 40 or 80 chars, depending on col80 + mii_t * mii = &g_mii; + uint16_t a = 0x400; + int page2 = mii_read_one(mii, SWPAGE2); +// int col80 = mii_read_one(mii, SW80COL); + for (int li = 0; li < 24; li++) { + int i = li; + a = (0x400 + (0x400 * page2)); + a += ((i & 0x07) << 7) | ((i >> 3) << 5) | ((i >> 3) << 3); + printf("%04x: ", a); + for (int ci = 0; ci < 40; ci++) { + uint8_t c = (mii_read_one(mii, a++) & 0x3f); + printf("%c", c >= 0x20 && c < 0x7f ? c : '.'); + } + printf("\n"); + } +} + +static void +_mii_mish_cmd( + void * param, + int argc, + const char * argv[]) +{ + const char * state[] = { "RUNNING", "STOPPED", "STEP" }; + mii_t * mii = &g_mii; + if (!argv[1]) { +show_state: + printf("mii: %s Target speed: %.3fMHz Current: %.3fMHz\n", + state[mii->state], mii->speed, mii->speed_current); + mii_dump_run_trace(mii); + mii_dump_trace_state(mii); + + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + bool text = !!mii_bank_peek(main, SWTEXT); + bool page2 = !!mii_bank_peek(main, SWPAGE2); + bool col80 = !!mii_bank_peek(main, SW80COL); + bool mixed = !!mii_bank_peek(main, SWMIXED); + bool hires = !!mii_bank_peek(main, SWHIRES); + bool dhires = !!mii_bank_peek(main, SWRDDHIRES); + + printf("text:%d page2:%d col80:%d mixed:%d hires:%d dhires:%d\n", + text, page2, col80, mixed, hires, dhires); + return; + } + if (!strcmp(argv[1], "reset")) { + mii_reset(mii, 0); + return; + } + if (!strcmp(argv[1], "mem")) { + for (int i = 0; i < 16; i++) { + printf("%02x: ", i * 16); + for (int j = 0; j < 16; j++) + printf("%d:%d ", mii->mem[(i * 16) + j].read, + mii->mem[(i * 16) + j].write); + printf("\n"); + } + return; + } + if (!strcmp(argv[1], "trace")) { + mii->trace_cpu = !mii->trace_cpu; + printf("trace_cpu %d\n", mii->trace_cpu); + return; + } + if (!strcmp(argv[1], "poke")) { + if (argc < 4) { + printf("poke: missing argument\n"); + return; + } + uint16_t addr = strtol(argv[2], NULL, 16); + uint8_t val = strtol(argv[3], NULL, 16); + mii_mem_access(mii, addr, &val, false, true); + return; + } + if (!strcmp(argv[1], "peek")) { + if (argc < 3) { + printf("peek: missing argument\n"); + return; + } + uint16_t addr = strtol(argv[2], NULL, 16); + uint8_t val; + mii_mem_access(mii, addr, &val, false, false); + printf("%04x: %02x\n", addr, val); + return; + } + if (!strcmp(argv[1], "speed")) { + if (argc < 3) { + printf("speed: missing argument\n"); + return; + } + float speed = atof(argv[2]); + if (speed < 0.1 || speed > 30.0) { + printf("speed: speed must be between 0.0 and 30.0\n"); + return; + } + mii->speed = speed; + printf("speed: %.3fMHz\n", speed); + return; + } + if (!strcmp(argv[1], "stop")) { + mii->state = MII_STOPPED; + goto show_state; + } + printf("mii: unknown command %s\n", argv[1]); +} + +void +_mii_mish_bp( + void * param, + int argc, + const char * argv[]) +{ + mii_t * mii = &g_mii; + if (!argv[1] || !strcmp(argv[1], "list")) { + printf("breakpoints: map %04x\n", mii->debug.bp_map); + for (int i = 0; i < (int)sizeof(mii->debug.bp_map)*8; i++) { + printf("%2d %c %04x %c%c%c size:%2d\n", i, + (mii->debug.bp_map & (1 << i)) ? '*' : ' ', + mii->debug.bp[i].addr, + (mii->debug.bp[i].kind & MII_BP_R) ? 'r' : '-', + (mii->debug.bp[i].kind & MII_BP_W) ? 'w' : '-', + (mii->debug.bp[i].kind & MII_BP_STICKY) ? 's' : '-', + mii->debug.bp[i].size); + } + return; + } + const char *p = argv[1]; + if (p[0] == '+') { + p++; + int addr = strtol(p, NULL, 16); + int kind = 0; + if (strchr(p, 'r')) + kind |= MII_BP_R; + if (strchr(p, 'w')) + kind |= MII_BP_W; + if (strchr(p, 's')) + kind |= MII_BP_STICKY; + if (!kind || kind == MII_BP_STICKY) + kind |= MII_BP_R; + int size = 1; + if (argv[2]) + size = strtol(argv[2], NULL, 16); + if (!size) size++; + for (int i = 0; i < (int)sizeof(mii->debug.bp_map)*8; i++) { + if (!(mii->debug.bp_map & (1 << i)) || mii->debug.bp[i].addr == addr) { + mii->debug.bp_map |= 1 << i; + mii->debug.bp[i].addr = addr; + mii->debug.bp[i].kind = kind; + mii->debug.bp[i].size = size; + printf("breakpoint %d set at %04x size %d\n", i, addr, size); + break; + } + } + return; + } + if (p[0] == '-') { + p++; + int idx = strtol(p, NULL, 10); + if (idx >= 0 && idx < 7) { + mii->debug.bp_map &= ~(1 << idx); + printf("breakpoint %d cleared\n", idx); + } + } +} + + +static void +_mii_mish_il( + void * param, + int argc, + const char * argv[]) +{ + static uint16_t addr = 0x800; + if (argv[1]) { + addr = strtol(argv[1], NULL, 16); + if (addr >= 0xffff) + addr = 0xfff0; + } + mii_t * mii = &g_mii; + + for (int li = 0; li < 20; li++) { + uint8_t op[16]; + for (int bi = 0; bi < 4; bi++) + mii_mem_access(mii, addr + bi, op + bi, false, false); + char dis[64]; + addr += mii_cpu_disasm_one(op, addr, dis, sizeof(dis), + MII_DUMP_DIS_PC | MII_DUMP_DIS_DUMP_HEX); + printf("%s\n", dis); + } +} + +static void +_mii_mish_dm( + void * param, + int argc, + const char * argv[]) +{ + static uint16_t addr = 0x800; + if (argv[1]) { + addr = strtol(argv[1], NULL, 16); + if (addr >= 0xffff) + addr = 0xfff0; + } + mii_t * mii = &g_mii; + if (!strcmp(argv[0], "dm")) { + printf("dm: %04x\n", addr); + for (int i = 0; i < 8; i++) { + printf("%04x: ", addr); + for (int j = 0; j < 16; j++) + printf("%02x ", mii_read_one(mii, addr++)); + printf("\n"); + } + return; + } + if (!strcmp(argv[0], "db")) { + printf("%s: %04x: ", argv[0], addr); + printf("%02x ", mii_read_one(mii, addr++)); + printf("\n"); + return; + } + if (!strcmp(argv[0], "dw") || !strcmp(argv[0], "da")) { + printf("%s: %04x: ", argv[0], addr); + uint8_t l = mii_read_one(mii, addr++); + uint8_t h = mii_read_one(mii, addr++); + printf("%02x%02x", h, l); + printf("\n"); + return; + } +} + + +static void +_mii_mish_step( + void * param, + int argc, + const char * argv[]) +{ + if (argv[0][0] == 's') { + mii_t * mii = &g_mii; + if (argv[1]) { + int n = strtol(argv[1], NULL, 10); + mii->trace.step_inst = n; + } else + mii->trace.step_inst = 1; + mii->state = MII_STEP; + return; + } + if (argv[0][0] == 'n') { + mii_t * mii = &g_mii; + // read current opcode, find how how many bytes it take, + // then put a temporary breakpoint to the next PC. + // all of that if this is not a relative branch of course, in + // which case we use a normal 'step' behaviour + uint8_t op; + mii_mem_access(mii, mii->cpu.PC, &op, false, false); + if (op == 0x20) { + // set a temp breakpoint on reading 3 bytes from PC + for (int i = 0; i < (int)sizeof(mii->debug.bp_map) * 8; i++) { + if ((mii->debug.bp_map & (1 << i))) + continue; + mii->debug.bp[i].addr = mii->cpu.PC + 3; + mii->debug.bp[i].kind = MII_BP_R; + mii->debug.bp[i].size = 1; + mii->debug.bp[i].silent = 1; + mii->debug.bp_map |= 1 << i; + mii->state = MII_RUNNING; + return; + } + printf("no more breakpoints available\n"); + } else { + mii->trace.step_inst = 1; + mii->state = MII_STEP; + } + return; + } + if (argv[0][0] == 'c') { + mii_t * mii = &g_mii; + mii->trace.step_inst = 0; + mii->state = MII_RUNNING; + return; + } + if (argv[0][0] == 'h') { + mii_t * mii = &g_mii; + mii->trace.step_inst = 0; + mii->state = MII_STOPPED; + return; + } +} + +extern int g_mii_audio_record_fd; + +#include + +static void +_mii_mish_audio( + void * param, + int argc, + const char * argv[]) +{ + if (argc < 2) { + printf("audio: missing argument\n"); + return; + } + if (!strcmp(argv[1], "record")) { + if (g_mii_audio_record_fd != -1) { + close(g_mii_audio_record_fd); + g_mii_audio_record_fd = -1; + printf("audio: stop recording\n"); + } else { + g_mii_audio_record_fd = open("audio.raw", + O_WRONLY | O_CREAT | O_TRUNC, 0644); + printf("audio: start recording\n"); + } + } else if (!strcmp(argv[1], "mute")) { + if (argv[2] && !strcmp(argv[2], "off")) + g_mii.speaker.muted = false; + else if (argv[2] && !strcmp(argv[2], "on")) + g_mii.speaker.muted = true; + else if (!argv[2] || (argv[2] && !strcmp(argv[2], "toggle"))) + g_mii.speaker.muted = !g_mii.speaker.muted; + printf("audio: %s\n", g_mii.speaker.muted ? "muted" : "unmuted"); + } else if (!strcmp(argv[1], "volume")) { + if (argc < 3) { + printf("audio: missing volume\n"); + return; + } + // convert a linear volume from 0 to 10 into a float from 0.0 to 1.0 + float vol = atof(argv[2]); + if (vol < 0) vol = 0; + else if (vol > 10) vol = 10; + mii_speaker_volume(&g_mii.speaker, vol); + printf("audio: volume %.3f (amp: %.4f)\n", + vol, g_mii.speaker.vol_multiplier); + } else { + printf("audio: unknown command %s\n", argv[1]); + } +} + +#include "mish.h" + +MISH_CMD_NAMES(mii, "mii"); +MISH_CMD_HELP(mii, + "mii: access internals, trace, reset, speed, etc", + " : dump current state", + " reset : reset the cpu", + " t|trace : toggle trace_cpu (WARNING HUGE traces!))", + " mem : dump memory and bank map", + " poke : poke a value in memory (respect SW)", + " peek : peek a value in memory (respect SW)", + " speed : set speed in MHz", + " stop : stop the cpu" + ); +MISH_CMD_REGISTER(mii, _mii_mish_cmd); + +MISH_CMD_NAMES(bp, "bp"); +MISH_CMD_HELP(bp, + "mii: breakpoints. 'sticky' means the breakpoint is re-armed after hit", + " : dump state", + " +[r|w][s] [size]: add at for read/write, sticky", + " - : disable (don't clear) breakpoint " + ); +MISH_CMD_REGISTER(bp, _mii_mish_bp); + +MISH_CMD_NAMES(il, "il"); +MISH_CMD_HELP(il, + "mii: disassembly", + " : list next 20 instructions.", + " [addr]: start at address addr" + ); +MISH_CMD_REGISTER(il, _mii_mish_il); + +MISH_CMD_NAMES(dm, "dm","db","dw","da"); +MISH_CMD_HELP(dm, + "mii: dump memory, byte, word, address", + " |dm : dump 64 bytes.", + " db []: dump one byte.", + " dw []: dump one word.", + " da []: dump one address.", + " [addr]: start at address addr" + ); +MISH_CMD_REGISTER(dm, _mii_mish_dm); + +MISH_CMD_NAMES(step, "s","step","n","next","cont","h","halt"); +MISH_CMD_HELP(step, + "mii: step instructions", + " s|step [num]: step [num, or one] instruction.", + " n|next : step one instruction, skip subroutines.", + " cont : continue execution." + ); +MISH_CMD_REGISTER(step, _mii_mish_step); + +MISH_CMD_NAMES(text, "text"); +MISH_CMD_HELP(text, + "mii: show text page [buggy]", + " : that's it" + ); +MISH_CMD_REGISTER(text, _mii_mish_text); + +MISH_CMD_NAMES(audio, "audio"); +MISH_CMD_HELP(audio, + "audio: audio control/debug", + " record: record/stop debug file.", + " mute: mute/unmute audio.", + " volume: set volume (0.0 to 1.0)." + ); +MISH_CMD_REGISTER(audio, _mii_mish_audio); diff --git a/nuklear/mii_mish_dd.c b/nuklear/mii_mish_dd.c new file mode 100644 index 0000000..42d7052 --- /dev/null +++ b/nuklear/mii_mish_dd.c @@ -0,0 +1,46 @@ +/* + * mii_mish_dd.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" + +extern mii_t g_mii; + + +static void +_mii_mish_dd( + void * param, + int argc, + const char * argv[]) +{ + if (!argv[1] || !strcmp(argv[1], "list")) { + mii_dd_t *d = g_mii.dd.drive; + printf(" ID %-16s %-20s\n", "Card", "Name"); + while (d) { + printf("%d:%d %-16s %-20s : %s\n", + d->slot_id, d->drive, + d->slot->drv->desc, + d->name, d->file ? d->file->pathname : "*empty*"); + d = d->next; + } + return; + } +} + +#include "mish.h" + +MISH_CMD_NAMES(dd, "dd", "disk"); +MISH_CMD_HELP(dd, + "mii: disk commands", + " |list: list all disk drives" + ); +MISH_CMD_REGISTER(dd, _mii_mish_dd); \ No newline at end of file diff --git a/nuklear/mii_nuklear.c b/nuklear/mii_nuklear.c new file mode 100644 index 0000000..935f857 --- /dev/null +++ b/nuklear/mii_nuklear.c @@ -0,0 +1,626 @@ +/* + * mii_nuklear.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" +#include "mii_sw.h" + +#define NK_INCLUDE_FIXED_TYPES +#define NK_INCLUDE_STANDARD_IO +#define NK_INCLUDE_STANDARD_VARARGS +#define NK_INCLUDE_DEFAULT_ALLOCATOR +#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT +#define NK_INCLUDE_FONT_BAKING +#define NK_INCLUDE_DEFAULT_FONT +#define NK_BUTTON_TRIGGER_ON_RELEASE +#include "nuklear.h" +#include "nuklear_xlib_gl3.h" +//#include "stb_image_write.h" +#include +#include + +#define _NK_RGBA(_r,_g,_b,_a) {.r=_r,.g=_g,.b=_b,.a=_a} +static const struct nk_color style[NK_COLOR_COUNT] = { + [NK_COLOR_TEXT] = _NK_RGBA(0, 0, 0, 255), + [NK_COLOR_WINDOW] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_HEADER] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_BORDER] = _NK_RGBA(0, 0, 0, 255), + [NK_COLOR_BUTTON] = _NK_RGBA(185, 185, 185, 255), + [NK_COLOR_BUTTON_HOVER] = _NK_RGBA(170, 170, 170, 255), + [NK_COLOR_BUTTON_ACTIVE] = _NK_RGBA(160, 160, 160, 255), + [NK_COLOR_TOGGLE] = _NK_RGBA(150, 150, 150, 255), + [NK_COLOR_TOGGLE_HOVER] = _NK_RGBA(120, 120, 120, 255), + [NK_COLOR_TOGGLE_CURSOR] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_SELECT] = _NK_RGBA(190, 190, 190, 255), + [NK_COLOR_SELECT_ACTIVE] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_SLIDER] = _NK_RGBA(190, 190, 190, 255), + [NK_COLOR_SLIDER_CURSOR] = _NK_RGBA(80, 80, 80, 255), + [NK_COLOR_SLIDER_CURSOR_HOVER] = _NK_RGBA(70, 70, 70, 255), + [NK_COLOR_SLIDER_CURSOR_ACTIVE] = _NK_RGBA(60, 60, 60, 255), + [NK_COLOR_PROPERTY] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_EDIT] = _NK_RGBA(150, 150, 150, 255), + [NK_COLOR_EDIT_CURSOR] = _NK_RGBA(0, 0, 0, 255), + [NK_COLOR_COMBO] = _NK_RGBA(175, 175, 175, 255), + [NK_COLOR_CHART] = _NK_RGBA(160, 160, 160, 255), + [NK_COLOR_CHART_COLOR] = _NK_RGBA(45, 45, 45, 255), + [NK_COLOR_CHART_COLOR_HIGHLIGHT] = _NK_RGBA( 255, 0, 0, 255), + [NK_COLOR_SCROLLBAR] = _NK_RGBA(180, 180, 180, 255), + [NK_COLOR_SCROLLBAR_CURSOR] = _NK_RGBA(140, 140, 140, 255), + [NK_COLOR_SCROLLBAR_CURSOR_HOVER] = _NK_RGBA(150, 150, 150, 255), + [NK_COLOR_SCROLLBAR_CURSOR_ACTIVE] = _NK_RGBA(160, 160, 160, 255), + [NK_COLOR_TAB_HEADER] = _NK_RGBA(180, 180, 180, 255), +}; + +static GLuint screen_texture; +static struct nk_image screen_nk; + + +#include + +typedef uint64_t mii_time_t; +enum { + MII_TIME_RES = 1, + MII_TIME_SECOND = 1000000, + MII_TIME_MS = (MII_TIME_SECOND/1000), +}; +mii_time_t +mii_get_time() +{ + struct timespec tim; + clock_gettime(CLOCK_MONOTONIC_RAW, &tim); + uint64_t time = ((uint64_t)tim.tv_sec) * (1000000 / MII_TIME_RES) + + tim.tv_nsec / (1000 * MII_TIME_RES); + return time; +} + +#include +#include "fifo_declare.h" + +static pthread_t mii_thread; +static bool mii_thread_running = false; +//static mii_trace_t mii_trace = {}; +float default_fps = 60; + +enum { + SIGNAL_RESET, + SIGNAL_STOP, + SIGNAL_STEP, + SIGNAL_RUN, +}; + +typedef struct { + uint8_t cmd; + uint8_t data; +} signal_t; + +DECLARE_FIFO(signal_t, signal_fifo, 16); +DEFINE_FIFO(signal_t, signal_fifo); + +signal_fifo_t signal_fifo; + +static void *mii_thread_func(void *arg) +{ + mii_t *mii = (mii_t *) arg; + mii_thread_running = true; + __uint128_t last_cycles = mii->cycles; + uint32_t running = 1; + unsigned long target_fps_us = 1000000 / default_fps; + long sleep_time = target_fps_us; + + //mii_time_t base = mii_get_time(NULL); + uint32_t last_frame = mii->video.frame_count; + mii_time_t last_frame_stamp = mii_get_time(); + while (mii_thread_running) { + signal_t sig; + while (!signal_fifo_isempty(&signal_fifo)) { + sig = signal_fifo_read(&signal_fifo); + switch (sig.cmd) { + case SIGNAL_RESET: + mii_reset(mii, sig.data); + break; + case SIGNAL_STOP: + mii_dump_run_trace(mii); + mii_dump_trace_state(mii); + mii->state = MII_STOPPED; + break; + case SIGNAL_STEP: + mii->state = MII_STEP; + running = 1; + break; + case SIGNAL_RUN: + mii->state = MII_RUNNING; + last_frame_stamp = mii_get_time(); + running = 1; + break; + } + } + if (mii->state != MII_STOPPED) + mii_run(mii); + + switch (mii->state) { + case MII_STOPPED: + usleep(1000); + break; + case MII_STEP: + if (running) { + running--; + mii_dump_trace_state(mii); + usleep(1000); + running = 1; + if (mii->trace.step_inst) + mii->trace.step_inst--; + if (mii->trace.step_inst == 0) + mii->state = MII_STOPPED; + } + break; + case MII_RUNNING: + break; + } + + if (mii->video.frame_count != last_frame) { + sleep_time = target_fps_us; + mii_time_t now = mii_get_time(); + if (mii->state == MII_RUNNING) { + mii_time_t delta = now - last_frame_stamp; + // printf("frame time %d/%d sleep time %d\n", + // (int)delta, (int)target_fps_us, + // (int)target_fps_us - delta); + sleep_time = target_fps_us - delta; + if (sleep_time < 0) + sleep_time = 0; + last_frame = mii->video.frame_count; + while (last_frame_stamp <= now) + last_frame_stamp += target_fps_us; + + // calculate the MHz + __uint128_t cycles = mii->cycles; + __uint128_t delta_cycles = cycles - last_cycles; + last_cycles = cycles; + mii->speed_current = delta_cycles / (float)target_fps_us; + } + usleep(sleep_time); + } + } + return NULL; +} + +extern struct nk_font *nk_main_font; +struct nk_font *nk_mono_font = NULL; + +extern const unsigned char mii_proggy_data[]; +extern const unsigned int mii_proggy_size; +extern const unsigned char mii_droid_data[]; +extern const unsigned int mii_droid_size; + +void +mii_nuklear_init( + mii_t *mii, + struct nk_context *ctx) +{ + nk_style_from_table(ctx, style); + + { + struct nk_font_atlas *atlas; + nk_x11_font_stash_begin(&atlas); + struct nk_font_config cfg = nk_font_config(0); + #if 0 + nk_rune ranges[] = { + 0x0020, 0x007E, /* Ascii */ + 0x00A1, 0x00FF, /* Symbols + Umlaute */ + 0 + }; + #endif + cfg.range = nk_font_default_glyph_ranges(); + cfg.oversample_h = cfg.oversample_v = 1; + cfg.pixel_snap = true; + struct nk_font *nkf = nk_font_atlas_add_from_memory(atlas, + (void*)mii_proggy_data, mii_proggy_size, 20, &cfg); + nk_x11_font_stash_end(); + nk_mono_font = nkf; + } + + glGenTextures(1, &screen_texture); + glBindTexture(GL_TEXTURE_2D, screen_texture); + + glTexImage2D(GL_TEXTURE_2D, 0, 4, + MII_VRAM_WIDTH, + MII_VRAM_HEIGHT, 0, GL_RGBA, + GL_UNSIGNED_BYTE, + mii->video.pixels); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +// printf("%s texture created %d\n", __func__, screen_texture); +// display opengl error + GLenum err = glGetError(); + if (err != GL_NO_ERROR) { + printf("Error creating texture: %d\n", err); + } + screen_nk = nk_subimage_id( + screen_texture, MII_VRAM_WIDTH, MII_VRAM_HEIGHT, + nk_rect(0, 0, MII_VIDEO_WIDTH, MII_VIDEO_HEIGHT)); + + /* start the thread */ + pthread_create(&mii_thread, NULL, mii_thread_func, mii); + +} + + +extern int disk2_debug; +int show_zero_page = 0; + +static void +mii_nuklear_handle_input( + mii_t *mii, + struct nk_context *ctx) +{ + struct nk_input *in = &ctx->input; + if (in->keyboard.text_len) { + // printf("INPUT %d %s\n", in->keyboard.text_len, in->keyboard.text); + if (in->keyboard.text_len < 4) { + mii_keypress(mii, in->keyboard.text[0]); + } else if (in->keyboard.text_len > 1) { + uint32_t *raw = ((uint32_t *) in->keyboard.text); + for (int ki = 0; ki < in->keyboard.text_len / 4; ki ++) { + uint32_t key = (raw[ki] >> 16) & 0xffff; + uint8_t down = raw[ki] & 0xff; + printf("KEY %04x %s\n", key, down ? "down" : "up"); + if (down) { + if (key == 0xffc9) { // F12 + if (nk_input_is_key_down(in, NK_KEY_CTRL)) { + signal_t sig = { + .cmd = SIGNAL_RESET, + .data = nk_input_is_key_down(in, NK_KEY_SHIFT) + }; + signal_fifo_write(&signal_fifo, sig); + printf("RESET\n"); + } + } else if (key == 0xffc8) { // F11 + if (nk_input_is_key_down(in, NK_KEY_CTRL)) { + signal_t sig = { + .cmd = SIGNAL_STOP, + }; + signal_fifo_write(&signal_fifo, sig); + printf("STOP\n"); + } + } else if (key == 0xffc7) { // F10 + if (nk_input_is_key_down(in, NK_KEY_CTRL)) { + signal_t sig = { + .cmd = SIGNAL_STEP, + }; + signal_fifo_write(&signal_fifo, sig); + printf("STEP\n"); + } + } else if (key == 0xffc6) { // F9 + if (nk_input_is_key_down(in, NK_KEY_CTRL)) { + signal_t sig = { + .cmd = SIGNAL_RUN, + }; + signal_fifo_write(&signal_fifo, sig); + printf("RUN\n"); + } + } else if (key == 0xffc2) { // F5 + mii->speed = 1.0; + printf("Speed Normal (1MHz)\n"); + } else if (key == 0xffc3) { // F6 + mii->speed = 4; + printf("Speed Fast (4MHz)\n"); + } + } + if (key == 0xffeb || key == 0xffec) { // super left/right + key -= 0xffeb; + mii_bank_t *bank = &mii->bank[MII_BANK_MAIN]; + uint8_t old = mii_bank_peek(bank, 0xc061 + key); + mii_bank_poke(bank, 0xc061 + key, down ? 0x80 : 0); + if (!!down != !!old) { + printf("Apple %s %s\n", key ? "Open" : "Close", + down ? "down" : "up"); + } + } + } + } + in->keyboard.text_len = 0; + } else { + signal_t sig = {.cmd = -1 }; + if (nk_input_is_key_pressed(in, NK_KEY_ENTER)) + sig.data = 0x0d; + else if (nk_input_is_key_pressed(in, NK_KEY_BACKSPACE)) + sig.data = 0x08; + else if (nk_input_is_key_pressed(in, NK_KEY_DEL)) + sig.data = 0x7f; + else if (nk_input_is_key_pressed(in, NK_KEY_UP)) + sig.data = 'K' - 'A' + 1; + else if (nk_input_is_key_pressed(in, NK_KEY_DOWN)) + sig.data = 'J' - 'A' + 1; + else if (nk_input_is_key_pressed(in, NK_KEY_LEFT)) + sig.data = 'H' - 'A' + 1; + else if (nk_input_is_key_pressed(in, NK_KEY_RIGHT)) + sig.data = 'U' - 'A' + 1; + else if (nk_input_is_key_pressed(in, NK_KEY_ESCAPE)) + sig.data = 0x1b; + if (sig.data) { + // signal_fifo_write(&signal_fifo, sig); + // printf("Key %d\n", sig.data); + mii_keypress(mii, sig.data); + } + } +} + +void +mii_nuklear( + mii_t *mii, + struct nk_context *ctx) +{ + if (mii->video.frame_count != mii->video.frame_drawn) { + mii->video.frame_drawn = mii->video.frame_count; + // update texture with new pixels; we only need 192 lines, the others + // are padding for the power of 2 texture + glBindTexture(GL_TEXTURE_2D, screen_texture); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, + MII_VRAM_WIDTH, + MII_VIDEO_HEIGHT, GL_RGBA, + GL_UNSIGNED_BYTE, + mii->video.pixels); + } + mii_nuklear_handle_input(mii, ctx); + int height = 720 - 8; + int width = MII_VIDEO_WIDTH * (height / (float)MII_VIDEO_HEIGHT); + int xpos = 1280 / 2 - width / 2; + { + struct nk_style *s = &ctx->style; + nk_style_push_color(ctx, &s->window.background, + nk_rgba(0,0,0, 255)); + nk_style_push_style_item(ctx, &s->window.fixed_background, + nk_style_item_color(nk_rgba(0,0,0, 255))); + if (nk_begin(ctx, "Apple //e Enhanced", + nk_rect(xpos, 0, width + 10, height + 20), + NK_WINDOW_NO_SCROLLBAR)) { + nk_layout_row_static(ctx, height, width, 1); + static int was_in = -1; + if (nk_widget_is_hovered(ctx) && mii->mouse.enabled) { + if (was_in != 1) { + was_in = 1; + ctx->input.mouse.grab = 1; + // printf("IN\n"); + } + struct nk_rect bounds = nk_widget_bounds(ctx); + // normalize mouse coordinates + double x = ctx->input.mouse.pos.x - bounds.x; + double y = ctx->input.mouse.pos.y - bounds.y; + // get mouse button state + int button = ctx->input.mouse.buttons[NK_BUTTON_LEFT].down; + // clamp coordinates inside bounds + double vw = bounds.w; + double vh = bounds.h; + double mw = mii->mouse.max_x - mii->mouse.min_x; + double mh = mii->mouse.max_y - mii->mouse.min_y; + mii->mouse.x = mii->mouse.min_x + (x * mw / vw) + 0.5; + mii->mouse.y = mii->mouse.min_y + (y * mh / vh) + 0.5; + mii->mouse.button = button; + // printf("Mouse is %d %d\n", (int)mii->mouse.x, (int)mii->mouse.y); + } else { + if (was_in == 1) { + was_in = 0; + ctx->input.mouse.ungrab = 1; + // printf("OUT\n"); + } + } + nk_image(ctx, screen_nk); + nk_end(ctx); + nk_style_pop_color(ctx); + nk_style_pop_style_item(ctx); + } + } + + struct nk_rect bounds = { .x = 0, .y = 0, .w = xpos, .h = height }; +// nk_window_get_bounds(ctx); + bool in = nk_input_is_mouse_hovering_rect(&ctx->input, bounds); + static bool menu_open = false; + + if (in || menu_open) { + struct nk_style *s = &ctx->style; + nk_style_push_color(ctx, &s->window.background, + nk_rgba(175, 175, 175, 255)); + nk_style_push_style_item(ctx, &s->window.fixed_background, + nk_style_item_color(nk_rgba(175, 175, 175, 255))); + + if (nk_begin(ctx, "Left Bar", + nk_rect(0, 0, xpos, height + 20), + NK_WINDOW_NO_SCROLLBAR)) { +#if 0 + nk_menubar_begin(ctx); + nk_layout_row_begin(ctx, NK_STATIC, 25, 2); + nk_layout_row_push(ctx, 60); + bool menu = false; + if (nk_menu_begin_label(ctx, "MII", NK_TEXT_LEFT, + nk_vec2(140, 200))) { + static size_t prog = 40; + static float slider = 0.5; + 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_float(ctx, 0.01, &slider, 1.0, 0.05); + nk_checkbox_label(ctx, "Mute", &check); + nk_menu_end(ctx); + menu = true; + } + menu_open = menu; + nk_menubar_end(ctx); + nk_layout_space_end(ctx); +#endif + int rw = xpos - 8; + // nk_layout_row_dynamic(ctx, 4, 1); + // nk_spacing(ctx, 1); + + nk_layout_row_static(ctx, 30, rw, 1); + if (nk_button_label(ctx, "C-RESET")) + mii_reset(mii, false); + if (nk_button_label(ctx, "C-OA-RESET")) + mii_reset(mii, true); +// nk_layout_row_dynamic(ctx, 0, 1); + nk_layout_row_begin(ctx, NK_STATIC, 30, 2); + nk_layout_row_push(ctx, 20); + nk_label(ctx, "V:", NK_TEXT_LEFT); + nk_layout_row_push(ctx, rw - 20 - 4); + const char *video_modes[] = { + "Color", + "Green", + "Amber", + }; + mii->video.color_mode = nk_combo(ctx, + video_modes, NK_LEN(video_modes), + mii->video.color_mode, 25, nk_vec2(80,200)); + nk_layout_space_end(ctx); + + nk_layout_row_begin(ctx, NK_STATIC, 30, 1); + nk_layout_row_push(ctx, rw); + const char *speed[] = { + "1 MHz", + "Slow", + "Fast", + }; + nk_label(ctx, "Speed:", NK_TEXT_LEFT); + nk_layout_row_push(ctx, 100); + int spi = 0; + spi = nk_combo(ctx, + speed, NK_LEN(speed), + spi, 25, nk_vec2(80,200)); + nk_layout_space_end(ctx); + + } + nk_end(ctx); + nk_style_pop_color(ctx); + nk_style_pop_style_item(ctx); + } + if ( 0 && nk_begin(ctx, "Controls", + nk_rect(width, 0, 350, 10 + 192 * 3), + NK_WINDOW_NO_SCROLLBAR)) { + nk_layout_row_static(ctx, 30, 110, 2); + if (nk_button_label(ctx, "C-RESET")) + mii_reset(mii, false); + if (nk_button_label(ctx, "C-OA-RESET")) + mii_reset(mii, true); + #if 0 + if (nk_button_label(ctx, "Screenshot")) { + stbi_write_png("screen.png", + MII_VIDEO_WIDTH, MII_VIDEO_HEIGHT, 4, mii->video.pixels, + MII_VRAM_WIDTH * 4); + printf("Screenshot taken\n"); + } + #endif + nk_layout_row_dynamic(ctx, 30, 4); + nk_label(ctx, "Speed:", NK_TEXT_CENTERED); + if (nk_option_label(ctx, "Slow", mii->speed < 0.9)) mii->speed = 0.2; + if (nk_option_label(ctx, "1 MHz", mii->speed > .95 && mii->speed < 1.05)) mii->speed = 1.0; + if (nk_option_label(ctx, "Fast", mii->speed > 1.1 && mii->speed < 4.1)) mii->speed = 4.0; + + nk_layout_row_dynamic(ctx, 30, 4); + nk_label(ctx, "Video:", NK_TEXT_CENTERED); + if (nk_option_label(ctx, "Color", mii->video.color_mode == MII_VIDEO_COLOR)) + mii->video.color_mode = MII_VIDEO_COLOR; + if (nk_option_label(ctx, "Green", mii->video.color_mode == MII_VIDEO_GREEN)) + mii->video.color_mode = MII_VIDEO_GREEN; + if (nk_option_label(ctx, "Amber", mii->video.color_mode == MII_VIDEO_AMBER)) + mii->video.color_mode = MII_VIDEO_AMBER; + +#if 0 + nk_layout_row_dynamic(ctx, 20, 1); + nk_style_set_font(ctx, &nk_mono_font->handle); + struct nk_color save = ctx->style.window.background; + + ctx->style.window.background = (struct nk_color)_NK_RGBA(0, 0, 0, 255); + struct nk_color fore = (struct nk_color)_NK_RGBA(0, 255, 0, 255); + char label[64]; + mii_dasm_t _dasm = {}; + mii_dasm_t *dasm = &_dasm; + mii_dasm_init(dasm, mii, 0); + dasm->mii = mii; + // display the last few cycles up to the PC + for (int di = 0; di < 3; di++) { + int pci = (mii_trace.idx + MII_PC_LOG_SIZE - 3 + di) % MII_PC_LOG_SIZE; + dasm->pc = mii_trace.log[pci]; + mii_dasm_step(dasm, label, sizeof(label)); + if (di == 2) + label[0] = '*'; + nk_label_colored(ctx, label, NK_TEXT_LEFT, fore); + } + // and the (potentially) next instruction here + mii_dasm_step(dasm, label, sizeof(label)); + nk_label_colored(ctx, label, NK_TEXT_LEFT, fore); + + sprintf(label, "A:%02X X:%02X Y:%02X S:%02X", + mii->cpu.A, mii->cpu.X, mii->cpu.Y, mii->cpu.S); + nk_label_colored(ctx, label, NK_TEXT_CENTERED, fore); + char n[] = {'C','Z','I','D','B','V','N'}; + label[0] = 0; + sprintf(label, "%04x ", mii->cpu.PC); + for (int i = 0; i < 7; i++) + sprintf(label + strlen(label), "%c%d ", n[i], + mii->cpu.P.P[i]); + nk_label_colored(ctx, label, NK_TEXT_CENTERED, fore); + + ctx->style.window.background = save; + nk_style_set_font(ctx, &nk_main_font->handle); +#endif + nk_layout_row_static(ctx, 30, 30, 3); + + if (nk_button_symbol(ctx, NK_SYMBOL_RECT_SOLID)) { + signal_fifo_write(&signal_fifo, (signal_t){.cmd = SIGNAL_STOP}); + } + if (nk_button_symbol(ctx, NK_SYMBOL_PLUS)) { + signal_fifo_write(&signal_fifo, (signal_t){.cmd = SIGNAL_STEP}); + } + if (nk_button_symbol(ctx, NK_SYMBOL_TRIANGLE_RIGHT)) { + signal_fifo_write(&signal_fifo, (signal_t){.cmd = SIGNAL_RUN}); + } + nk_layout_row_dynamic(ctx, 20, 3); + { + char label[32]; + sprintf(label, "CPU: %.1fMHz", mii->speed_current); + nk_label(ctx, label, NK_TEXT_CENTERED); + } +#if 0 + nk_layout_row_dynamic(ctx, 20, 2); + nk_checkbox_label(ctx, "Disk II Debug", &disk2_debug); + nk_checkbox_label(ctx, "Slowmo", &mii_SLOW); +// nk_checkbox_label(ctx, "Zero Page", &show_zero_page); +#endif + nk_end(ctx); + } + if (show_zero_page) { + if (nk_begin(ctx, "Zero Page", + nk_rect(0, 10 + 192 * 3, 600, 10 + 16 * 20), + 0 )) { + nk_layout_row_dynamic(ctx, 20, 1); + nk_style_set_font(ctx, &nk_mono_font->handle); + struct nk_color fore = (struct nk_color)_NK_RGBA(0, 255, 0, 255); + uint8_t *zp = mii->bank[0].mem; + char label[128]; + for (int ri = 0; ri < (256 / 16); ri++) { + sprintf(label, "%02x: ", ri * 16); + for (int ci = 0; ci < 16; ci++) { + sprintf(label + strlen(label), "%02X ", + zp[ri * 16 + ci]); + } + nk_label_colored(ctx, label, NK_TEXT_LEFT, fore); + } + nk_style_set_font(ctx, &nk_main_font->handle); + nk_end(ctx); + } + } +} diff --git a/nuklear/mii_stb_implement.c b/nuklear/mii_stb_implement.c new file mode 100644 index 0000000..32fa1f8 --- /dev/null +++ b/nuklear/mii_stb_implement.c @@ -0,0 +1,22 @@ +/* + * mii_stb.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + + +#define NK_INCLUDE_FIXED_TYPES +#define NK_INCLUDE_STANDARD_IO +#define NK_INCLUDE_STANDARD_VARARGS +#define NK_INCLUDE_DEFAULT_ALLOCATOR +#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT +#define NK_INCLUDE_FONT_BAKING +#define NK_INCLUDE_DEFAULT_FONT +#define NK_BUTTON_TRIGGER_ON_RELEASE +#define NK_IMPLEMENTATION +#include "nuklear.h" + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "stb_image_write.h" diff --git a/nuklear/nuklear.h b/nuklear/nuklear.h new file mode 100644 index 0000000..4012fda --- /dev/null +++ b/nuklear/nuklear.h @@ -0,0 +1,30034 @@ +/* +/// # 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 +/// - [Code available on github](https://github.com/Immediate-Mode-UI/Nuklear/) +/// +/// ## 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 #including 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 float 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_INV_SQRT | You can define this to your own inverse 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 float 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_float(&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__) || defined(__aarch64__) + #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__) || defined(__aarch64__) + #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 {float r,g,b,a;}; +struct nk_vec2 {float x,y;}; +struct nk_vec2i {short x, y;}; +struct nk_rect {float 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; nk_handle unit; nk_ushort w, h; nk_ushort region[4];}; +struct nk_nine_slice {struct nk_image img; nk_ushort l, t, r, b;}; +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 transitions. +/// 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_ALT, + NK_KEY_DEL, + NK_KEY_ENTER, + NK_KEY_TAB, + NK_KEY_BACKSPACE, + NK_KEY_ESCAPE, + 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 +/// { +/// float pos[2]; // important to keep it to 2 floats +/// float 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_FLOAT, NK_OFFSETOF(struct your_vertex, pos)}, +/// {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, 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.tex_null = dev->tex_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 { + float 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 tex_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 call +/// 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 indices 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 visible until maximized +/// __NK_MAXIMIZED__| UI section is extended and visible 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 +/// float 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 float 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 +/// float 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 float 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 float ratio[] = {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 float 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 float 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*, float 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*, float 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 +/// float nk_layout_ratio_from_pixel(struct nk_context*, float 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 float nk_layout_ratio_from_pixel(struct nk_context*, float 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, float 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, float 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, float 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, float 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, float 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, float 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*, float 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*, float 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, float height, int cols, const float *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, float height, int cols, const float *ratio); +/*/// #### nk_layout_row_template_begin +/// Begins the row template declaration +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_layout_row_template_begin(struct nk_context*, float 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*, float 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*, float 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*, float 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*, float 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*, float 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, float 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, float 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); + +/*/// #### nk_spacer +/// Spacer is a dummy widget that consumes space as usual but doesn't draw anything +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// void nk_spacer(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_spacer(struct nk_context* ); + + +/* ============================================================================= + * + * 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 corresponding `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 separated 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 collapsible +/// UI section that can be either in a hidden or visible 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 +/// collapsible 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 collapsible 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 collapsible UI section with internal state management +/// nk_tree_push_id | Start a collapsible UI section with internal state management callable in a look +/// nk_tree_push_hashed | Start a collapsible UI section with internal state management with full control over internal unique ID use to store state +/// nk_tree_image_push | Start a collapsible UI section with image and label header +/// nk_tree_image_push_id | Start a collapsible UI section with image and label header and internal state management callable in a look +/// nk_tree_image_push_hashed | Start a collapsible 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 collapsible UI section +// +/// nk_tree_state_push | Start a collapsible UI section with external state management +/// nk_tree_state_image_push | Start a collapsible 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 collapsible UI section +/// NK_TREE_TAB | Non-highlighted tree header closer to tree representations +*/ +/*/// #### nk_tree_push +/// Starts a collapsible UI section with internal state management +/// !!! WARNING +/// To keep track of the runtime tree collapsible 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,nk_strlen(NK_FILE_LINE),__LINE__) +/*/// #### nk_tree_push_id +/// Starts a collapsible 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,nk_strlen(NK_FILE_LINE),id) +/*/// #### nk_tree_push_hashed +/// Start a collapsible 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 collapsible UI section with image and label header +/// !!! WARNING +/// To keep track of the runtime tree collapsible 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,nk_strlen(NK_FILE_LINE),__LINE__) +/*/// #### nk_tree_image_push_id +/// Start a collapsible 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,nk_strlen(NK_FILE_LINE),id) +/*/// #### nk_tree_image_push_hashed +/// Start a collapsible 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 collapsible 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 collapsible 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,nk_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,nk_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 float nk_widget_width(struct nk_context*); +NK_API float 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_float(struct nk_context*, const char *prefix, float); +NK_API void nk_value_color_byte(struct nk_context*, const char *prefix, struct nk_color); +NK_API void nk_value_color_float(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 float nk_slide_float(struct nk_context*, float min, float val, float max, float step); +NK_API int nk_slide_int(struct nk_context*, int min, int val, int max, int step); +NK_API nk_bool nk_slider_float(struct nk_context*, float min, float *val, float max, float 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 identification 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 property 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 modifying a passed in value +/// nk_property_float | Float property directly modifying a passed in value +/// nk_property_double | Double property directly modifying a passed in value +/// nk_propertyi | Integer property returning the modified int value +/// nk_propertyf | Float property returning the modified float value +/// nk_propertyd | Double property returning the modified double value +/// +*/ +/*/// #### nk_property_int +/// Integer property directly modifying 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, float 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, float inc_per_pixel); +/*/// #### nk_property_float +/// Float property directly modifying 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_float(struct nk_context *ctx, const char *name, float min, float *val, float max, float step, float 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__ | Float 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_float(struct nk_context*, const char *name, float min, float *val, float max, float step, float inc_per_pixel); +/*/// #### nk_property_double +/// Double property directly modifying 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, float inc_per_pixel); +/*/// #### nk_propertyi +/// Integer property modifying 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, float 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, float inc_per_pixel); +/*/// #### nk_propertyf +/// Float property modifying 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 +/// float nk_propertyf(struct nk_context *ctx, const char *name, float min, float val, float max, float step, float 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 float 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 float value +*/ +NK_API float nk_propertyf(struct nk_context*, const char *name, float min, float val, float max, float step, float inc_per_pixel); +/*/// #### nk_propertyd +/// Float property modifying 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 +/// float 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, float 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, float min, float 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, float min, float max); +NK_API void nk_chart_add_slot(struct nk_context *ctx, const enum nk_chart_type, int count, float min_value, float 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, float min_value, float max_value); +NK_API nk_flags nk_chart_push(struct nk_context*, float); +NK_API nk_flags nk_chart_push_slot(struct nk_context*, float, int); +NK_API void nk_chart_end(struct nk_context*); +NK_API void nk_plot(struct nk_context*, enum nk_chart_type, const float *values, int count, int offset); +NK_API void nk_plot_function(struct nk_context*, enum nk_chart_type, void *userdata, float(*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*, float 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_float(struct nk_context*, float*, float); +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_float(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(float r, float g, float b); +NK_API struct nk_color nk_rgb_fv(const float *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(float r, float g, float b, float a); +NK_API struct nk_color nk_rgba_fv(const float *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(float h, float s, float v, float a); +NK_API struct nk_colorf nk_hsva_colorfv(float *c); +NK_API void nk_colorf_hsva_f(float *out_h, float *out_s, float *out_v, float *out_a, struct nk_colorf in); +NK_API void nk_colorf_hsva_fv(float *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(float h, float s, float v); +NK_API struct nk_color nk_hsv_fv(const float *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(float h, float s, float v, float a); +NK_API struct nk_color nk_hsva_fv(const float *hsva); + +/* color (conversion nuklear --> user) */ +NK_API void nk_color_f(float *r, float *g, float *b, float *a, struct nk_color); +NK_API void nk_color_fv(float *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(float *out_h, float *out_s, float *out_v, struct nk_color); +NK_API void nk_color_hsv_fv(float *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(float *out_h, float *out_s, float *out_v, float *out_a, struct nk_color); +NK_API void nk_color_hsva_fv(float *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*, nk_ushort w, nk_ushort h, struct nk_rect sub_region); +NK_API struct nk_image nk_subimage_id(int, nk_ushort w, nk_ushort h, struct nk_rect sub_region); +NK_API struct nk_image nk_subimage_handle(nk_handle, nk_ushort w, nk_ushort h, struct nk_rect sub_region); +/* ============================================================================= + * + * 9-SLICE + * + * ============================================================================= */ +NK_API struct nk_nine_slice nk_nine_slice_handle(nk_handle, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +NK_API struct nk_nine_slice nk_nine_slice_ptr(void*, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +NK_API struct nk_nine_slice nk_nine_slice_id(int, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +NK_API int nk_nine_slice_is_sub9slice(const struct nk_nine_slice* img); +NK_API struct nk_nine_slice nk_sub9slice_ptr(void*, nk_ushort w, nk_ushort h, struct nk_rect sub_region, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +NK_API struct nk_nine_slice nk_sub9slice_id(int, nk_ushort w, nk_ushort h, struct nk_rect sub_region, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +NK_API struct nk_nine_slice nk_sub9slice_handle(nk_handle, nk_ushort w, nk_ushort h, struct nk_rect sub_region, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b); +/* ============================================================================= + * + * 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, float pad_x, float pad_y, enum nk_heading); + +NK_API struct nk_vec2 nk_vec2(float x, float y); +NK_API struct nk_vec2 nk_vec2i(int x, int y); +NK_API struct nk_vec2 nk_vec2v(const float *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(float x, float y, float w, float 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 float *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 float 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 +/// 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. +// +/// #### 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. +/// +/// ```c +/// float your_text_width_calculation(nk_handle handle, float height, const char *text, int len) +/// { +/// your_font_type *type = handle.ptr; +/// float 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); +/// ``` +/// #### 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. +/// +/// ```c +/// float your_text_width_calculation(nk_handle handle, float height, const char *text, int len) +/// { +/// your_font_type *type = handle.ptr; +/// float text_width = ...; +/// return text_width; +/// } +/// void query_your_font_glyph(nk_handle handle, float 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); +/// ``` +/// +/// #### 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. +/// +/// ```c +/// 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: +/// +/// ```c +/// 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 float(*nk_text_width_f)(nk_handle, float h, const char*, int len); +typedef void(*nk_query_font_glyph_f)(nk_handle handle, float 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 */ + float width, height; + /* size of the glyph */ + float xadvance; + /* offset to the next glyph */ +}; +#endif + +struct nk_user_font { + nk_handle userdata; + /* user provided font handle */ + float 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 { + float height; + /* height of the font */ + float 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 high quality for sub-pixel position */ + unsigned char padding[3]; + + float 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; + float xadvance; + float x0, y0, x1, y1, w, h; + float u0, v0, u1, v1; +}; + +struct nk_font { + struct nk_font *next; + struct nk_user_font handle; + struct nk_baked_font info; + float 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(float 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*, float 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, float 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, float 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, float height, const struct nk_font_config*); +NK_API struct nk_font* nk_font_atlas_add_compressed_base85(struct nk_font_atlas*, const char *data, float 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 + * + * ===============================================================*/ +/*/// ### 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 */ + float 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 + * + * ===============================================================*/ +/*/// ### 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; + float 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_float(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 + * + * ===============================================================*/ +/*/// ### 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`: +/// +/// ```c +/// 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; + float a[2]; + struct nk_color color; +}; + +struct nk_command_arc_filled { + struct nk_command header; + short cx, cy; + unsigned short r; + float 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; + float 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, float x0, float y0, float x1, float y1, float line_thickness, struct nk_color); +NK_API void nk_stroke_curve(struct nk_command_buffer*, float, float, float, float, float, float, float, float, float line_thickness, struct nk_color); +NK_API void nk_stroke_rect(struct nk_command_buffer*, struct nk_rect, float rounding, float line_thickness, struct nk_color); +NK_API void nk_stroke_circle(struct nk_command_buffer*, struct nk_rect, float line_thickness, struct nk_color); +NK_API void nk_stroke_arc(struct nk_command_buffer*, float cx, float cy, float radius, float a_min, float a_max, float line_thickness, struct nk_color); +NK_API void nk_stroke_triangle(struct nk_command_buffer*, float, float, float, float, float, float, float line_thichness, struct nk_color); +NK_API void nk_stroke_polyline(struct nk_command_buffer*, float *points, int point_count, float line_thickness, struct nk_color col); +NK_API void nk_stroke_polygon(struct nk_command_buffer*, float*, int point_count, float line_thickness, struct nk_color); + +/* filled shades */ +NK_API void nk_fill_rect(struct nk_command_buffer*, struct nk_rect, float 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*, float cx, float cy, float radius, float a_min, float a_max, struct nk_color); +NK_API void nk_fill_triangle(struct nk_command_buffer*, float x0, float y0, float x1, float y1, float x2, float y2, struct nk_color); +NK_API void nk_fill_polygon(struct nk_command_buffer*, float*, 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_nine_slice(struct nk_command_buffer*, struct nk_rect, const struct nk_nine_slice*, 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; +#ifdef NK_BUTTON_TRIGGER_ON_RELEASE + struct nk_vec2 down_pos; +#endif + 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_in_button_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 +/* ### Draw List +/// 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_FLOAT, + 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_FLOAT, + 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, float radius, int a_min, int a_max); +NK_API void nk_draw_list_path_arc_to(struct nk_draw_list*, struct nk_vec2 center, float radius, float a_min, float 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, float 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, float 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, float thickness); +NK_API void nk_draw_list_stroke_rect(struct nk_draw_list*, struct nk_rect rect, struct nk_color, float rounding, float 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, float thickness); +NK_API void nk_draw_list_stroke_circle(struct nk_draw_list*, struct nk_vec2 center, float radius, struct nk_color, unsigned int segs, float 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, float 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, float 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, float 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, float 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, float 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, + NK_STYLE_ITEM_NINE_SLICE +}; + +union nk_style_item_data { + struct nk_color color; + struct nk_image image; + struct nk_nine_slice slice; +}; + +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 */ + float border; + float 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; + float spacing; + float 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 */ + float 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 */ + float border; + float rounding; + float 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 */ + float rounding; + float border; + float cursor_border; + float 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 */ + float border; + float rounding; + float border_cursor; + float 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 */ + float border; + float rounding; + float cursor_size; + struct nk_vec2 scrollbar_size; + struct nk_vec2 padding; + float 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 */ + float border; + float 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 */ + float border; + float 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 */ + float border; + float 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 */ + float border; + float rounding; + float 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; + + float border; + float combo_border; + float contextual_border; + float menu_border; + float group_border; + float tooltip_border; + float popup_border; + float min_row_height_padding; + + float 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_color(struct nk_color); +NK_API struct nk_style_item nk_style_item_image(struct nk_image img); +NK_API struct nk_style_item nk_style_item_nine_slice(struct nk_nine_slice slice); +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; + float min, max, range; + int count; + struct nk_vec2 last; + int index; +}; + +struct nk_chart { + int slot; + float 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; + float height; + float min_height; + int columns; + const float *ratio; + float item_width; + float item_height; + float item_offset; + float filled; + struct nk_rect item; + int tree_depth; + float 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 { + float 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; + float at_x, at_y, max_x; + float footer_height; + float header_height; + float 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; + float 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 + * =============================================================*/ +/*/// ### 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, float 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_FLOAT_STACK_SIZE +#define NK_FLOAT_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_float float +NK_CONFIGURATION_STACK_TYPE(struct nk, style_item, style_item); +NK_CONFIGURATION_STACK_TYPE(nk ,float, float); +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(float, NK_FLOAT_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_float floats; + 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; + float 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_FLOAT_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)))) + +#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(__clang__) +#define NK_OFFSETOF(st,m) (__builtin_offsetof(st,m)) +#else +#define NK_OFFSETOF(st,m) ((nk_ptr)&(((st*)0)->m)) +#endif + +#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) +#else +#define NK_ALIGNOF(t) NK_OFFSETOF(struct {char c; t _h;}, _h) +#endif + +#define NK_CONTAINER_OF(ptr,type,member)\ + (type*)((void*)((char*)(1 ? (ptr): &((type*)0)->member) - NK_OFFSETOF(type, member))) + + + +#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_FLOAT_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 */ +#ifndef NK_INV_SQRT +NK_LIB float nk_inv_sqrt(float n); +#endif +#ifndef NK_SIN +NK_LIB float nk_sin(float x); +#endif +#ifndef NK_COS +NK_LIB float nk_cos(float 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, float 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, float x0, float y0, float x1, float y1); +NK_LIB double nk_pow(double x, int n); +NK_LIB int nk_ifloord(double x); +NK_LIB int nk_ifloorf(float x); +NK_LIB int nk_iceilf(float 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_float_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, float space, int *glyphs, float *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, float 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, float 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, float x, float y, const struct nk_user_font *font, float row_height); +NK_LIB void nk_textedit_drag(struct nk_text_edit *state, float x, float y, const struct nk_user_font *font, float 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, float 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 float 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 float nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type, float total_space, int columns); +NK_LIB void nk_panel_layout(const struct nk_context *ctx, struct nk_window *win, float height, int cols); +NK_LIB void nk_row_layout(struct nk_context *ctx, enum nk_layout_format fmt, float 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 float nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor, struct nk_rect *visual_cursor, struct nk_input *in, struct nk_rect bounds, float slider_min, float slider_max, float slider_value, float slider_step, float 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, float min, float value, float max); +NK_LIB float nk_do_slider(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, float min, float val, float max, float step, const struct nk_style_slider *style, struct nk_input *in, const struct nk_user_font *font); + +/* scrollbar */ +NK_LIB float 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, float scroll_offset, float target, float 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 float nk_do_scrollbarv(nk_flags *state, struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, float offset, float target, float step, float button_pixel_inc, const struct nk_style_scrollbar *style, struct nk_input *in, const struct nk_user_font *font); +NK_LIB float nk_do_scrollbarh(nk_flags *state, struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, float offset, float target, float step, float 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, float pos_x, float pos_y, float x_offset, const char *text, int byte_len, float 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_FLOAT +}; +enum nk_property_kind { + NK_PROPERTY_INT, + NK_PROPERTY_FLOAT, + NK_PROPERTY_DOUBLE +}; +union nk_property { + int i; + float 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_float(float value, float min_value, float max_value, float 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, float 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, float 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, float 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, float 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 + * + * ===============================================================*/ +/*/// ### Math +/// Since nuklear is supposed to work on all systems providing floating 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 float 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 +*/ +#ifndef NK_INV_SQRT +#define NK_INV_SQRT nk_inv_sqrt +NK_LIB float +nk_inv_sqrt(float n) +{ + float x2; + const float threehalfs = 1.5f; + union {nk_uint i; float 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; +} +#endif +#ifndef NK_SIN +#define NK_SIN nk_sin +NK_LIB float +nk_sin(float x) +{ + NK_STORAGE const float a0 = +1.91059300966915117e-31f; + NK_STORAGE const float a1 = +1.00086760103908896f; + NK_STORAGE const float a2 = -1.21276126894734565e-2f; + NK_STORAGE const float a3 = -1.38078780785773762e-1f; + NK_STORAGE const float a4 = -2.67353392911981221e-2f; + NK_STORAGE const float a5 = +2.08026600266304389e-2f; + NK_STORAGE const float a6 = -3.03996055049204407e-3f; + NK_STORAGE const float 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 float +nk_cos(float x) +{ + /* New implementation. Also generated using lolremez. */ + /* Old version significantly deviated from expected results. */ + NK_STORAGE const float a0 = 9.9995999154986614e-1f; + NK_STORAGE const float a1 = 1.2548995793001028e-3f; + NK_STORAGE const float a2 = -5.0648546280678015e-1f; + NK_STORAGE const float a3 = 1.2942246466519995e-2f; + NK_STORAGE const float a4 = 2.8668384702547972e-2f; + NK_STORAGE const float a5 = 7.3726485210586547e-3f; + NK_STORAGE const float a6 = -3.8510875386947414e-3f; + NK_STORAGE const float a7 = 4.7196604604366623e-4f; + NK_STORAGE const float 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) +{ + 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) +{ + /* 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) +{ + x = (double)((int)x - ((x < 0.0) ? 1 : 0)); + return (int)x; +} +NK_LIB int +nk_ifloorf(float x) +{ + x = (float)((int)x - ((x < 0.0f) ? 1 : 0)); + return (int)x; +} +NK_LIB int +nk_iceilf(float x) +{ + if (x >= 0) { + int i = (int)x; + return (x > i) ? i+1: i; + } else { + int t = (int)x; + float r = x - (float)t; + return (r > 0.0f) ? t+1: t; + } +} +NK_LIB int +nk_log10(double n) +{ + 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) +{ + return nk_null_rect; +} +NK_API struct nk_rect +nk_rect(float x, float y, float w, float h) +{ + 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) +{ + struct nk_rect r; + r.x = (float)x; + r.y = (float)y; + r.w = (float)w; + r.h = (float)h; + return r; +} +NK_API struct nk_rect +nk_recta(struct nk_vec2 pos, struct nk_vec2 size) +{ + return nk_rect(pos.x, pos.y, size.x, size.y); +} +NK_API struct nk_rect +nk_rectv(const float *r) +{ + return nk_rect(r[0], r[1], r[2], r[3]); +} +NK_API struct nk_rect +nk_rectiv(const int *r) +{ + return nk_recti(r[0], r[1], r[2], r[3]); +} +NK_API struct nk_vec2 +nk_rect_pos(struct nk_rect r) +{ + 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) +{ + 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, float amount) +{ + 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) +{ + 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(float x, float y) +{ + struct nk_vec2 ret; + ret.x = x; ret.y = y; + return ret; +} +NK_API struct nk_vec2 +nk_vec2i(int x, int y) +{ + struct nk_vec2 ret; + ret.x = (float)x; + ret.y = (float)y; + return ret; +} +NK_API struct nk_vec2 +nk_vec2v(const float *v) +{ + return nk_vec2(v[0], v[1]); +} +NK_API struct nk_vec2 +nk_vec2iv(const int *v) +{ + return nk_vec2i(v[0], v[1]); +} +NK_LIB void +nk_unify(struct nk_rect *clip, const struct nk_rect *a, float x0, float y0, + float x1, float y1) +{ + 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, + float pad_x, float pad_y, enum nk_heading direction) +{ + float 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) +{ + 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) +{ + #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) +{ + NK_ASSERT(ptr); + NK_MEMSET(ptr, 0, size); +} +NK_API int +nk_strlen(const char *str) +{ + int siz = 0; + NK_ASSERT(str); + while (str && *str++ != '\0') siz++; + return siz; +} +NK_API int +nk_strtoi(const char *str, const char **endptr) +{ + 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) +{ + 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 float +nk_strtof(const char *str, const char **endptr) +{ + float float_value; + double double_value; + double_value = NK_STRTOD(str, endptr); + float_value = (float)double_value; + return float_value; +} +NK_API int +nk_stricmp(const char *s1, const char *s2) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + /* + 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) +{ + /* 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) +{ + return nk_strmatch_fuzzy_text(str, nk_strlen(str), pattern, out_score); +} +NK_LIB int +nk_string_float_limit(char *string, int prec) +{ + 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) +{ + int len = nk_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) +{ + 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) +{ + 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_FLOAT_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 = nk_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') { + /* floating 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 = nk_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) +{ + 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 +NK_API nk_hash +nk_murmur_hash(const void * key, int len, nk_hash seed) +{ + /* 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) +{ + 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, float space, int *glyphs, float *text_width, + nk_rune *sep_list, int sep_count) +{ + int i = 0; + int glyph_len = 0; + float last_width = 0; + nk_rune unicode = 0; + float width = 0; + int len = 0; + int g = 0; + float s; + + int sep_len = 0; + int sep_g = 0; + float sep_width = 0; + sep_count = NK_MAX(sep_count,0); + + glyph_len = nk_utf_decode(text, &unicode, text_len); + while (glyph_len && (width < space) && (len < text_len)) { + len += glyph_len; + s = font->width(font->userdata, font->height, text, len); + 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; + glyph_len = nk_utf_decode(&text[len], &unicode, text_len - 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; + } +} +NK_LIB struct nk_vec2 +nk_text_calculate_text_bounds(const struct nk_user_font *font, + const char *begin, int byte_len, float row_height, const char **remaining, + struct nk_vec2 *out_offset, int *glyphs, int op) +{ + float line_height = row_height; + struct nk_vec2 text_size = nk_vec2(0,0); + float line_width = 0.0f; + + float 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 += (float)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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + #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) +{ + #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) +{ + return nk_rgba(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgba_bv(const nk_byte *c) +{ + return nk_rgba(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgb(int r, int g, int b) +{ + 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) +{ + return nk_rgb(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgb_bv(const nk_byte* c) +{ + return nk_rgb(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgba_u32(nk_uint in) +{ + 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(float r, float g, float b, float a) +{ + 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 float *c) +{ + return nk_rgba_f(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_rgba_cf(struct nk_colorf c) +{ + return nk_rgba_f(c.r, c.g, c.b, c.a); +} +NK_API struct nk_color +nk_rgb_f(float r, float g, float b) +{ + 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 float *c) +{ + return nk_rgb_f(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_rgb_cf(struct nk_colorf c) +{ + return nk_rgb_f(c.r, c.g, c.b); +} +NK_API struct nk_color +nk_hsv(int h, int s, int v) +{ + return nk_hsva(h, s, v, 255); +} +NK_API struct nk_color +nk_hsv_iv(const int *c) +{ + return nk_hsv(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_hsv_bv(const nk_byte *c) +{ + return nk_hsv(c[0], c[1], c[2]); +} +NK_API struct nk_color +nk_hsv_f(float h, float s, float v) +{ + return nk_hsva_f(h, s, v, 1.0f); +} +NK_API struct nk_color +nk_hsv_fv(const float *c) +{ + 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) +{ + float hf = ((float)NK_CLAMP(0, h, 255)) / 255.0f; + float sf = ((float)NK_CLAMP(0, s, 255)) / 255.0f; + float vf = ((float)NK_CLAMP(0, v, 255)) / 255.0f; + float af = ((float)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) +{ + return nk_hsva(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_hsva_bv(const nk_byte *c) +{ + return nk_hsva(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_colorf +nk_hsva_colorf(float h, float s, float v, float a) +{ + int i; + float 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 - (float)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(float *c) +{ + return nk_hsva_colorf(c[0], c[1], c[2], c[3]); +} +NK_API struct nk_color +nk_hsva_f(float h, float s, float v, float a) +{ + 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 float *c) +{ + return nk_hsva_f(c[0], c[1], c[2], c[3]); +} +NK_API nk_uint +nk_color_u32(struct nk_color in) +{ + 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(float *r, float *g, float *b, float *a, struct nk_color in) +{ + NK_STORAGE const float s = 1.0f/255.0f; + *r = (float)in.r * s; + *g = (float)in.g * s; + *b = (float)in.b * s; + *a = (float)in.a * s; +} +NK_API void +nk_color_fv(float *c, struct nk_color in) +{ + nk_color_f(&c[0], &c[1], &c[2], &c[3], in); +} +NK_API struct nk_colorf +nk_color_cf(struct nk_color in) +{ + 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) +{ + 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) +{ + nk_color_d(&c[0], &c[1], &c[2], &c[3], in); +} +NK_API void +nk_color_hsv_f(float *out_h, float *out_s, float *out_v, struct nk_color in) +{ + float a; + nk_color_hsva_f(out_h, out_s, out_v, &a, in); +} +NK_API void +nk_color_hsv_fv(float *out, struct nk_color in) +{ + float a; + nk_color_hsva_f(&out[0], &out[1], &out[2], &a, in); +} +NK_API void +nk_colorf_hsva_f(float *out_h, float *out_s, + float *out_v, float *out_a, struct nk_colorf in) +{ + float chroma; + float K = 0.0f; + if (in.g < in.b) { + const float t = in.g; in.g = in.b; in.b = t; + K = -1.f; + } + if (in.r < in.g) { + const float 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(float *hsva, struct nk_colorf in) +{ + nk_colorf_hsva_f(&hsva[0], &hsva[1], &hsva[2], &hsva[3], in); +} +NK_API void +nk_color_hsva_f(float *out_h, float *out_s, + float *out_v, float *out_a, struct nk_color in) +{ + 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(float *out, struct nk_color in) +{ + 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) +{ + float 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + int i, j, len, type=0; + nk_rune udecoded; + + NK_ASSERT(c); + NK_ASSERT(u); + + if (!c || !u) return 0; + if (!clen) return 0; + *u = NK_UTF_INVALID; + + udecoded = nk_utf_decode_byte(c[0], &len); + if (!NK_BETWEEN(len, 1, NK_UTF_SIZE)) + return 1; + + for (i = 1, j = 1; i < clen && j < len; ++i, ++j) { + udecoded = (udecoded << 6) | nk_utf_decode_byte(c[i], &type); + if (type != 0) + return j; + } + if (j < len) + return 0; + *u = udecoded; + nk_utf_validate(u, len); + return len; +} +NK_INTERN char +nk_utf_encode_byte(nk_rune u, int i) +{ + return (char)((nk_utfbyte[i]) | ((nk_byte)u & ~nk_utfmask[i])); +} +NK_API int +nk_utf_encode(nk_rune u, char *c, int clen) +{ + int len, i; + len = nk_utf_validate(&u, 0); + if (clen < len || !len || len > NK_UTF_SIZE) + return 0; + + for (i = len - 1; i != 0; --i) { + c[i] = nk_utf_encode_byte(u, 0); + u >>= 6; + } + c[0] = nk_utf_encode_byte(u, len); + return len; +} +NK_API int +nk_utf_len(const char *str, int len) +{ + const char *text; + int glyphs = 0; + int text_len; + int glyph_len; + int src_len = 0; + nk_rune unicode; + + NK_ASSERT(str); + if (!str || !len) return 0; + + text = str; + text_len = len; + glyph_len = nk_utf_decode(text, &unicode, text_len); + while (glyph_len && src_len < len) { + glyphs++; + src_len = src_len + glyph_len; + glyph_len = nk_utf_decode(text + src_len, &unicode, text_len - src_len); + } + return glyphs; +} +NK_API const char* +nk_utf_at(const char *buffer, int length, int index, + nk_rune *unicode, int *len) +{ + 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) +{ + NK_UNUSED(unused); + NK_UNUSED(old); + return malloc(size); +} +NK_LIB void +nk_mfree(nk_handle unused, void *ptr) +{ + NK_UNUSED(unused); + free(ptr); +} +NK_API void +nk_buffer_init_default(struct nk_buffer *buffer) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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)((float)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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(buffer); + if (!buffer) return 0; + return buffer->memory.ptr; +} +NK_API const void* +nk_buffer_memory_const(const struct nk_buffer *buffer) +{ + NK_ASSERT(buffer); + if (!buffer) return 0; + return buffer->memory.ptr; +} +NK_API nk_size +nk_buffer_total(struct nk_buffer *buffer) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_str_append_text_char(s, str, nk_strlen(str)); +} +NK_API int +nk_str_append_text_utf8(struct nk_str *str, const char *text, int len) +{ + 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) +{ + 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 num_runes; +} +NK_API int +nk_str_append_text_runes(struct nk_str *str, const nk_rune *text, int len) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_str_insert_text_utf8(str, pos, text, nk_strlen(text)); +} +NK_API int +nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len) +{ + 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) +{ + 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_insert_at_rune(str, pos, text, byte_len); + return num_runes; +} +NK_API int +nk_str_insert_text_runes(struct nk_str *str, int pos, const nk_rune *runes, int len) +{ + 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) +{ + 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_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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); + 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 const char* +nk_str_at_char_const(const struct nk_str *s, int pos) +{ + 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) +{ + 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); + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(str); + nk_buffer_clear(&str->buffer); + str->len = 0; +} +NK_API void +nk_str_free(struct nk_str *str) +{ + 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) +{ + 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) +{ + 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) +{ + NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_command); + struct nk_command *cmd; + nk_size alignment; + void *unaligned; + void *memory; + + NK_ASSERT(b); + NK_ASSERT(b->base); + 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) +{ + 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, float x0, float y0, + float x1, float y1, float line_thickness, struct nk_color c) +{ + struct nk_command_line *cmd; + NK_ASSERT(b); + 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, float ax, float ay, + float ctrl0x, float ctrl0y, float ctrl1x, float ctrl1y, + float bx, float by, float line_thickness, struct nk_color col) +{ + 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, + float rounding, float line_thickness, struct nk_color c) +{ + 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->rounding = (unsigned short)rounding; + 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, + float rounding, struct nk_color c) +{ + 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->rounding = (unsigned short)rounding; + 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) +{ + 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, + float line_thickness, struct nk_color c) +{ + 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) +{ + 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, float cx, float cy, float radius, + float a_min, float a_max, float line_thickness, struct nk_color c) +{ + 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, float cx, float cy, float radius, + float a_min, float a_max, struct nk_color c) +{ + 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, float x0, float y0, float x1, + float y1, float x2, float y2, float line_thickness, struct nk_color c) +{ + 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, float x0, float y0, float x1, + float y1, float x2, float y2, struct nk_color c) +{ + 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, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + 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, float *points, int point_count, + struct nk_color col) +{ + 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, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + 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) +{ + 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_draw_nine_slice(struct nk_command_buffer *b, struct nk_rect r, + const struct nk_nine_slice *slc, struct nk_color col) +{ + struct nk_image img; + const struct nk_image *slcimg = (const struct nk_image*)slc; + nk_ushort rgnX, rgnY, rgnW, rgnH; + rgnX = slcimg->region[0]; + rgnY = slcimg->region[1]; + rgnW = slcimg->region[2]; + rgnH = slcimg->region[3]; + + /* top-left */ + img.handle = slcimg->handle; + img.w = slcimg->w; + img.h = slcimg->h; + img.region[0] = rgnX; + img.region[1] = rgnY; + img.region[2] = slc->l; + img.region[3] = slc->t; + + nk_draw_image(b, + nk_rect(r.x, r.y, (float)slc->l, (float)slc->t), + &img, col); + +#define IMG_RGN(x, y, w, h) img.region[0] = (nk_ushort)(x); img.region[1] = (nk_ushort)(y); img.region[2] = (nk_ushort)(w); img.region[3] = (nk_ushort)(h); + + /* top-center */ + IMG_RGN(rgnX + slc->l, rgnY, rgnW - slc->l - slc->r, slc->t); + nk_draw_image(b, + nk_rect(r.x + (float)slc->l, r.y, (float)(r.w - slc->l - slc->r), (float)slc->t), + &img, col); + + /* top-right */ + IMG_RGN(rgnX + rgnW - slc->r, rgnY, slc->r, slc->t); + nk_draw_image(b, + nk_rect(r.x + r.w - (float)slc->r, r.y, (float)slc->r, (float)slc->t), + &img, col); + + /* center-left */ + IMG_RGN(rgnX, rgnY + slc->t, slc->l, rgnH - slc->t - slc->b); + nk_draw_image(b, + nk_rect(r.x, r.y + (float)slc->t, (float)slc->l, (float)(r.h - slc->t - slc->b)), + &img, col); + + /* center */ + IMG_RGN(rgnX + slc->l, rgnY + slc->t, rgnW - slc->l - slc->r, rgnH - slc->t - slc->b); + nk_draw_image(b, + nk_rect(r.x + (float)slc->l, r.y + (float)slc->t, (float)(r.w - slc->l - slc->r), (float)(r.h - slc->t - slc->b)), + &img, col); + + /* center-right */ + IMG_RGN(rgnX + rgnW - slc->r, rgnY + slc->t, slc->r, rgnH - slc->t - slc->b); + nk_draw_image(b, + nk_rect(r.x + r.w - (float)slc->r, r.y + (float)slc->t, (float)slc->r, (float)(r.h - slc->t - slc->b)), + &img, col); + + /* bottom-left */ + IMG_RGN(rgnX, rgnY + rgnH - slc->b, slc->l, slc->b); + nk_draw_image(b, + nk_rect(r.x, r.y + r.h - (float)slc->b, (float)slc->l, (float)slc->b), + &img, col); + + /* bottom-center */ + IMG_RGN(rgnX + slc->l, rgnY + rgnH - slc->b, rgnW - slc->l - slc->r, slc->b); + nk_draw_image(b, + nk_rect(r.x + (float)slc->l, r.y + r.h - (float)slc->b, (float)(r.w - slc->l - slc->r), (float)slc->b), + &img, col); + + /* bottom-right */ + IMG_RGN(rgnX + rgnW - slc->r, rgnY + rgnH - slc->b, slc->r, slc->b); + nk_draw_image(b, + nk_rect(r.x + r.w - (float)slc->r, r.y + r.h - (float)slc->b, (float)slc->r, (float)slc->b), + &img, col); + +#undef IMG_RGN +} +NK_API void +nk_push_custom(struct nk_command_buffer *b, struct nk_rect r, + nk_command_custom_callback cb, nk_handle usr) +{ + 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) +{ + float 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; + float txt_width = (float)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'; +} + + + + + +/* =============================================================== + * + * VERTEX + * + * ===============================================================*/ +#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT +NK_API void +nk_draw_list_init(struct nk_draw_list *list) +{ + 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 float a = ((float)i / (float)NK_LEN(list->circle_vtx)) * 2 * NK_PI; + list->circle_vtx[i].x = (float)NK_COS(a); + list->circle_vtx[i].y = (float)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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(list); + if (!list) return; + if (!list->cmd_count) { + nk_draw_list_push_command(list, rect, list->config.tex_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) +{ + 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) +{ + list->userdata = userdata; +} +#endif +NK_INTERN void* +nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) +{ + 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 indices or rather vertexes. + * To solve this issue please change typedef `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 specifying `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 vertices for 16-bit vertex indices. 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) +{ + 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) +{ + return (element->attribute == NK_VERTEX_ATTRIBUTE_COUNT || + element->format == NK_FORMAT_COUNT); +} +NK_INTERN void +nk_draw_vertex_color(void *attr, const float *vals, + enum nk_draw_vertex_layout_format format) +{ + /* if this triggers you tried to provide a value format for a color */ + float 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: 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]*(float)NK_USHORT_MAX); + col[1] = (nk_ushort)(val[1]*(float)NK_USHORT_MAX); + col[2] = (nk_ushort)(val[2]*(float)NK_USHORT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R16G15B16A16: { + nk_ushort col[4]; + col[0] = (nk_ushort)(val[0]*(float)NK_USHORT_MAX); + col[1] = (nk_ushort)(val[1]*(float)NK_USHORT_MAX); + col[2] = (nk_ushort)(val[2]*(float)NK_USHORT_MAX); + col[3] = (nk_ushort)(val[3]*(float)NK_USHORT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32: { + nk_uint col[3]; + col[0] = (nk_uint)(val[0]*(float)NK_UINT_MAX); + col[1] = (nk_uint)(val[1]*(float)NK_UINT_MAX); + col[2] = (nk_uint)(val[2]*(float)NK_UINT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32A32: { + nk_uint col[4]; + col[0] = (nk_uint)(val[0]*(float)NK_UINT_MAX); + col[1] = (nk_uint)(val[1]*(float)NK_UINT_MAX); + col[2] = (nk_uint)(val[2]*(float)NK_UINT_MAX); + col[3] = (nk_uint)(val[3]*(float)NK_UINT_MAX); + NK_MEMCPY(attr, col, sizeof(col)); + } break; + case NK_FORMAT_R32G32B32A32_FLOAT: + NK_MEMCPY(attr, val, sizeof(float)*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 float *values, int value_count, + enum nk_draw_vertex_layout_format format) +{ + 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((float)NK_SCHAR_MIN, values[value_index], (float)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((float)NK_SSHORT_MIN, values[value_index], (float)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((float)NK_SINT_MIN, values[value_index], (float)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((float)NK_UCHAR_MIN, values[value_index], (float)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((float)NK_USHORT_MIN, values[value_index], (float)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((float)NK_UINT_MIN, values[value_index], (float)NK_UINT_MAX); + NK_MEMCPY(attribute, &value, sizeof(value)); + attribute = (void*)((char*)attribute + sizeof(nk_uint)); + } break; + case NK_FORMAT_FLOAT: + NK_MEMCPY(attribute, &values[value_index], sizeof(values[value_index])); + attribute = (void*)((char*)attribute + sizeof(float)); + 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) +{ + void *result = (void*)((char*)dst + config->vertex_size); + const struct nk_draw_vertex_layout_element *elem_iter = config->vertex_layout; + 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, + float thickness, enum nk_anti_aliasing aliasing) +{ + 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)((float)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)((float)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 float 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]); + float 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; + float 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) { + float 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.tex_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 float 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); + float dmr2 = dm.x * dm.x + dm.y* dm.y; + if (dmr2 > 0.000001f) { + float 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.tex_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) { + float dx, dy; + const struct nk_vec2 uv = list->config.tex_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); + float 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) +{ + 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)((float)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 float 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 */ + float 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.tex_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); + float dmr2 = dm.x*dm.x + dm.y*dm.y; + if (dmr2 > 0.000001f) { + float 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.tex_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) +{ + 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) +{ + 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.tex_null.texture.ptr) + nk_draw_list_push_image(list, list->config.tex_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, + float radius, int a_min, int a_max) +{ + 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 float x = center.x + c.x * radius; + const float 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, + float radius, float a_min, float a_max, unsigned int segments) +{ + 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 float d_angle = (a_max - a_min) / (float)segments; + const float sin_d = (float)NK_SIN(d_angle); + const float cos_d = (float)NK_COS(d_angle); + + float cx = (float)NK_COS(a_min) * radius; + float cy = (float)NK_SIN(a_min) * radius; + for(i = 0; i <= segments; ++i) { + float new_cx, new_cy; + const float x = center.x + cx; + const float 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, float rounding) +{ + float 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) +{ + float 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/(float)num_segments; + for (i_step = 1; i_step <= num_segments; ++i_step) { + float t = t_step * (float)i_step; + float u = 1.0f - t; + float w1 = u*u*u; + float w2 = 3*u*u*t; + float w3 = 3*u*t*t; + float w4 = t * t *t; + float x = w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x; + float 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) +{ + 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, float thickness) +{ + 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, float thickness) +{ + 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, float rounding) +{ + 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, float rounding, float thickness) +{ + 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) +{ + 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.tex_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.tex_null.uv, col_left); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y), list->config.tex_null.uv, col_top); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y + rect.h), list->config.tex_null.uv, col_right); + vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x, rect.y + rect.h), list->config.tex_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) +{ + 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, float thickness) +{ + 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, + float radius, struct nk_color col, unsigned int segs) +{ + float a_max; + NK_ASSERT(list); + if (!list || !col.a) return; + a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)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, + float radius, struct nk_color col, unsigned int segs, float thickness) +{ + float a_max; + NK_ASSERT(list); + if (!list || !col.a) return; + a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)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, float thickness) +{ + 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) +{ + 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) +{ + 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 = (float)texture.region[0]/(float)texture.w; + uv[0].y = (float)texture.region[1]/(float)texture.h; + uv[1].x = (float)(texture.region[0] + texture.region[2])/(float)texture.w; + uv[1].y = (float)(texture.region[1] + texture.region[3])/(float)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, float font_height, + struct nk_color fg) +{ + float 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)((float)fg.a * list->config.global_alpha); + while (text_len < len && glyph_len) { + float gx, gy, gh, gw; + float 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) +{ + 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, (float)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, (float)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((float)c->x + (float)c->w/2, + (float)c->y + (float)c->h/2), (float)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((float)c->x + (float)c->w/2, + (float)c->y + (float)c->h/2), (float)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((float)p->points[i].x, (float)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((float)p->points[i].x, (float)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((float)p->points[i].x, (float)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) +{ + 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) +{ + 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) +{ + return nk__draw_list_next(cmd, buffer, &ctx->draw_list); +} +#endif + + +/* stb_rect_pack.h - v1.01 - public domain - rectangle packing */ +/* Sean Barrett 2014 */ +/* */ +/* Useful for e.g. packing rectangular textures into an atlas. */ +/* Does not do rotation. */ +/* */ +/* Before #including, */ +/* */ +/* #define STB_RECT_PACK_IMPLEMENTATION */ +/* */ +/* in the file that you want to have the implementation. */ +/* */ +/* 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.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section */ +/* 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; + +typedef int stbrp_coord; + +#define STBRP__MAXVAL 0x7fffffff +/* Mostly for internal use, but this is the maximum supported coordinate value. */ + +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) +#define STBRP__CDECL __cdecl +#else +#define STBRP__NOTUSED(v) (void)sizeof(v) +#define STBRP__CDECL +#endif + +enum +{ + STBRP__INIT_skyline = 1 +}; + +STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) +{ + 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) +{ + 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) +{ + int i; + + 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; + context->extra[1].y = (1<<30); + 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) +{ + 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; + 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) +{ + 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; + 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) +{ + /* 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; + } + + /* 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 STBRP__CDECL rect_height_compare(const void *a, const void *b) +{ + 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 STBRP__CDECL rect_original_order(const void *a, const void *b) +{ + 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); +} + +STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) +{ + 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.26 - public domain */ +/* authored from 2009-2021 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.26 (2021-08-28) fix broken rasterizer */ +/* 1.25 (2021-07-11) many fixes */ +/* 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.t0); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t1); 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) +{ + 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) +{ + stbtt_fontinfo font; + int i,j,ascent,baseline,ch=0; + float 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; + float x_shift = xpos - (float) 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 */ + float xoff,yoff,xadvance; +} stbtt_bakedchar; + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, /* font location (use offset=0 for plain .ttf) */ + float 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 +{ + float x0,y0,s0,t0; /* top-left */ + float 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 */ + float *xpos, float *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, float size, float *ascent, float *descent, float *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 */ + float xoff,yoff,xadvance; + float 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, float 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 +{ + float 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 */ + float *xpos, float *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 float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float 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 float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float 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 unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl); +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, float scale_x, float 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, float scale_x, float scale_y, float shift_x, float 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, float scale_x, float 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, float scale_x, float scale_y, float shift_x, float 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, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *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, float scale_x, float 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, float scale_x, float scale_y, float shift_x, float 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, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float 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, float scale_x, float 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, float scale_x, float scale_y, float shift_x, float 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, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float 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 */ + float 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 */ + float scale_x, float scale_y, /* scale applied to input vertices */ + float shift_x, float 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, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float 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) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor++]; +} + +static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor]; +} + +static void stbtt__buf_seek(stbtt__buf *b, int o) +{ + 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) +{ + stbtt__buf_seek(b, b->cursor + o); +} + +static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) { + 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) +{ + 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) +{ + 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) +{ + stbtt__buf_seek(b, 0); + return stbtt__buf_get16(b); +} + +static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) +{ + 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) +{ + /* 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) +{ + 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) +{ + /* 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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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, last; + stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); + + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + last = ttUSHORT(data + endCount + 2*item); + if (unicode_codepoint < start || unicode_codepoint > last) + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) +{ + 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) +{ + 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) +{ + 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; + float 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 = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (float) 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 && vertices) 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; + float first_x, first_y; + float 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) +{ + 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) +{ + 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) +{ + 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, float dx, float dy) +{ + 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, float dx, float dy) +{ + 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, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) +{ + float cx1 = ctx->x + dx1; + float cy1 = ctx->y + dy1; + float cx2 = cx1 + dx2; + float 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) +{ + 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) +{ + 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) +{ + int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; + int has_subrs = 0, clear_stack; + float s[48]; + stbtt__buf subr_stack[10], subrs = info->subrs, b; + float f; + +#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 */ + float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; + float 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) + return STBTT__CSERR("reserved operator"); + + /* push immediate */ + if (b0 == 255) { + f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; + } else { + stbtt__buf_skip(&b, -1); + f = (float)(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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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: return -1; /* unsupported */ + } + + return -1; +} + +static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) +{ + 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)); + 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); + } + break; + } + + default: + return -1; /* Unsupported definition type, return an error. */ + } + + /* "All glyphs not assigned to a class fall into class 0". (OpenType spec) */ + return 0; +} + +/* 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) +{ + stbtt_uint16 lookupListOffset; + stbtt_uint8 *lookupList; + stbtt_uint16 lookupCount; + stbtt_uint8 *data; + stbtt_int32 i, sti; + + 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= pairSetCount) return 0; + + needle=glyph2; + r=pairValueCount-1; + l=0; + + /* Binary search. */ + while (l <= r) { + stbtt_uint16 secondGlyph; + stbtt_uint8 *pairValue; + m = (l + r) >> 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; + } + } + } else + return 0; + break; + } + + case 2: { + stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); + stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); + if (valueFormat1 == 4 && valueFormat2 == 0) { /* Support more formats? */ + 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_uint8 *class1Records, *class2Records; + stbtt_int16 xAdvance; + + if (glyph1class < 0 || glyph1class >= class1Count) return 0; /* malformed */ + if (glyph2class < 0 || glyph2class >= class2Count) return 0; /* malformed */ + + class1Records = table + 16; + class2Records = class1Records + 2 * (glyph1class * class2Count); + xAdvance = ttSHORT(class2Records + 2 * glyph2class); + return xAdvance; + } else + return 0; + break; + } + + default: + return 0; /* Unsupported position format */ + } + } + } + + return 0; +} + +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) +{ + 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) +{ + 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) +{ + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + 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) +{ + 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) +{ + *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 float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) +{ + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (float) height / fheight; +} + +STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels) +{ + int unitsPerEm = ttUSHORT(info->data + info->head + 18); + return pixels / unitsPerEm; +} + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + STBTT_free(v, info->userdata); +} + +STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) +{ + 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) +{ + 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) +{ + return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); +} + +/* //////////////////////////////////////////////////////////////////////////// */ +/* */ +/* antialiasing software rasterizer */ +/* */ + +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + 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, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + 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, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + 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, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + 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) +{ + 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) +{ + *(void **) p = hh->first_free; + hh->first_free = p; +} + +static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) +{ + stbtt__hheap_chunk *c = hh->head; + while (c) { + stbtt__hheap_chunk *n = c->next; + STBTT_free(c, userdata); + c = n; + } +} + +typedef struct stbtt__edge { + float 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; + float ey; + int direction; + #elif STBTT_RASTERIZER_VERSION==2 + float fx,fdx,fdy; + float direction; + float sy; + float 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, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float 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, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float 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) +{ + /* 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) +{ + 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) * (float) 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 */ + float 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(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) +{ + 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 float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width) +{ + STBTT_assert(top_width >= 0); + STBTT_assert(bottom_width >= 0); + return (top_width + bottom_width) / 2.0f * height; +} + +static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1) +{ + return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0); +} + +static float stbtt__sized_triangle_area(float height, float width) +{ + return height * width / 2; +} + +static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top) +{ + float 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) { + float 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 { + float x0 = e->fx; + float dx = e->fdx; + float xb = x0 + dx; + float x_top, x_bottom; + float sy0,sy1; + float 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) { + float height; + /* simple case, only spans one pixel */ + int x = (int) x_top; + height = (sy1 - sy0) * e->direction; + STBTT_assert(x >= 0 && x < len); + scanline[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f); + scanline_fill[x] += height; /* everything right of this pixel is filled */ + } else { + int x,x1,x2; + float y_crossing, y_final, step, sign, area; + /* covers 2+ pixels */ + if (x_top > x_bottom) { + /* flip scanline vertically; signed area is the same */ + float 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; + } + STBTT_assert(dy >= 0); + STBTT_assert(dx >= 0); + + x1 = (int) x_top; + x2 = (int) x_bottom; + /* compute intersection with y axis at x1+1 */ + y_crossing = y_top + dy * (x1+1 - x0); + + /* compute intersection with y axis at x2 */ + y_final = y_top + dy * (x2 - x0); + + /* x1 x_top x2 x_bottom */ + /* y_top +------|-----+------------+------------+--------|---+------------+ */ + /* | | | | | | */ + /* | | | | | | */ + /* sy0 | Txxxxx|............|............|............|............| */ + /* y_crossing | *xxxxx.......|............|............|............| */ + /* | | xxxxx..|............|............|............| */ + /* | | /- xx*xxxx........|............|............| */ + /* | | dy < | xxxxxx..|............|............| */ + /* y_final | | \- | xx*xxx.........|............| */ + /* sy1 | | | | xxxxxB...|............| */ + /* | | | | | | */ + /* | | | | | | */ + /* y_bottom +------------+------------+------------+------------+------------+ */ + /* */ + /* goal is to measure the area covered by '.' in each pixel */ + + /* if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 */ + /* @TODO: maybe test against sy1 rather than y_bottom? */ + if (y_crossing > y_bottom) + y_crossing = y_bottom; + + sign = e->direction; + + /* area of the rectangle covered from sy0..y_crossing */ + area = sign * (y_crossing-sy0); + + /* area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) */ + scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top); + + /* check if final y_crossing is blown up; no test case for this */ + if (y_final > y_bottom) { + y_final = y_bottom; + dy = (y_final - y_crossing ) / (x2 - (x1+1)); /* if denom=0, y_final = y_crossing, so y_final <= y_bottom */ + } + + /* in second pixel, area covered by line segment found in first pixel */ + /* is always a rectangle 1 wide * the height of that line segment; this */ + /* is exactly what the variable 'area' stores. it also gets a contribution */ + /* from the line segment within it. the THIRD pixel will get the first */ + /* pixel's rectangle contribution, the second pixel's rectangle contribution, */ + /* and its own contribution. the 'own contribution' is the same in every pixel except */ + /* the leftmost and rightmost, a trapezoid that slides down in each pixel. */ + /* the second pixel's contribution to the third pixel will be the */ + /* rectangle 1 wide times the height change in the second pixel, which is dy. */ + + step = sign * dy * 1; /* dy is dy/dx, change in y for every 1 change in x, */ + /* which multiplied by 1-pixel-width is how much pixel area changes for each step in x */ + /* so the area advances by 'step' every time */ + + for (x = x1+1; x < x2; ++x) { + scanline[x] += area + step/2; /* area of trapezoid is 1*step/2 */ + area += step; + } + STBTT_assert(STBTT_fabs(area) <= 1.01f); /* accumulated error from area += step unless we round step down */ + STBTT_assert(sy1 > y_final-0.01f); + + /* area covered in the last pixel is the rectangle from all the pixels to the left, */ + /* plus the trapezoid filled by the line segment in this pixel all the way to the right edge */ + scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f); + + /* the rest of the line is filled based on the total height of the line segment in this pixel */ + 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 */ + /* note though that this does happen some of the time because */ + /* x_top and x_bottom can be extrapolated at the top & bottom of */ + /* the shape and actually lie outside the bounding box */ + 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 */ + float y0 = y_top; + float x1 = (float) (x); + float x2 = (float) (x+1); + float x3 = xb; + float 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 */ + float y1 = (x - x0) / dx + y_top; + float 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) +{ + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0, i; + float scanline_data[129], *scanline, *scanline2; + + STBTT__NOTUSED(vsubsample); + + if (result->w > 64) + scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata); + else + scanline = scanline_data; + + scanline2 = scanline + result->w; + + y = off_y; + e[n].y0 = (float) (off_y + result->h) + 1; + + while (j < result->h) { + /* find center of pixel for this scanline */ + float scan_y_top = y + 0.0f; + float 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); + + { + float sum = 0; + for (i=0; i < result->w; ++i) { + float k; + int m; + sum += scanline2[i]; + k = scanline[i] + sum; + k = (float) 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) +{ + 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) +{ + /* 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) +{ + stbtt__sort_edges_quicksort(p, n); + stbtt__sort_edges_ins_sort(p, n); +} + +typedef struct +{ + float x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) +{ + float 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, float x, float y) +{ + 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, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) +{ + /* midpoint */ + float mx = (x0 + 2*x1 + x2)/4; + float my = (y0 + 2*y1 + y2)/4; + /* versus directly drawn line */ + float dx = (x0+x2)/2 - mx; + float 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, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) +{ + /* @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough */ + float dx0 = x1-x0; + float dy0 = y1-y0; + float dx1 = x2-x1; + float dy1 = y2-y1; + float dx2 = x3-x2; + float dy2 = y3-y2; + float dx = x3-x0; + float dy = y3-y0; + float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); + float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); + float flatness_squared = longlen*longlen-shortlen*shortlen; + + if (n > 16) /* 65536 segments on one curve better be enough! */ + return; + + if (flatness_squared > objspace_flatness_squared) { + float x01 = (x0+x1)/2; + float y01 = (y0+y1)/2; + float x12 = (x1+x2)/2; + float y12 = (y1+y2)/2; + float x23 = (x2+x3)/2; + float y23 = (y2+y3)/2; + + float xa = (x01+x12)/2; + float ya = (y01+y12)/2; + float xb = (x12+x23)/2; + float yb = (y12+y23)/2; + + float mx = (xa+xb)/2; + float 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, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + stbtt__point *points=0; + int num_points=0; + + float 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) { + float 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, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) +{ + float 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) +{ + STBTT_free(bitmap, userdata); +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + 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, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + 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, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) +{ + 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, float scale_x, float scale_y, int glyph) +{ + 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, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + 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, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint) +{ + 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, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) +{ + 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, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + 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, float scale_x, float scale_y, int codepoint) +{ + 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) */ + float 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) +{ + float 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 = (float) x0; + chardata[i].yoff = (float) 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, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + float d3d_bias = opengl_fillrule ? 0 : -0.5f; + float 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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 float stbtt__oversample_shift(int oversample) +{ + 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 (float)-(oversample - 1) / (2.0f * (float)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) +{ + int i,j,k; + int missing_glyph_added = 0; + + k=0; + for (i=0; i < num_ranges; ++i) { + float fh = ranges[i].font_size; + float 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, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph) +{ + 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) +{ + 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) { + float fh = ranges[i].font_size; + float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + float 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 = (float) x0 * recip_h + sub_x; + bc->yoff = (float) 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) +{ + 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) +{ + 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, float font_size, + int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) +{ + 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, float size, float *ascent, float *descent, float *lineGap) +{ + int i_ascent, i_descent, i_lineGap; + float 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 = (float) i_ascent * scale; + *descent = (float) i_descent * scale; + *lineGap = (float) i_lineGap * scale; +} + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer) +{ + float ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_packedchar *b = chardata + char_index; + + if (align_to_integer) { + float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f); + float y = (float) 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(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2]) +{ + float q0perp = q0[1]*ray[0] - q0[0]*ray[1]; + float q1perp = q1[1]*ray[0] - q1[0]*ray[1]; + float q2perp = q2[1]*ray[0] - q2[0]*ray[1]; + float roperp = orig[1]*ray[0] - orig[0]*ray[1]; + + float a = q0perp - 2*q1perp + q2perp; + float b = q1perp - q0perp; + float c = q0perp - roperp; + + float s0 = 0., s1 = 0.; + int num_s = 0; + + if (a != 0.0) { + float discr = b*b - a*c; + if (discr > 0.0) { + float rcpna = -1 / a; + float d = (float) 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 { + float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); + float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; + + float q0d = q0[0]*rayn_x + q0[1]*rayn_y; + float q1d = q1[0]*rayn_x + q1[1]*rayn_y; + float q2d = q2[0]*rayn_x + q2[1]*rayn_y; + float rod = orig[0]*rayn_x + orig[1]*rayn_y; + + float q10d = q1d - q0d; + float q20d = q2d - q0d; + float 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(float *a, float *b) +{ + return (a[0] == b[0] && a[1] == b[1]); +} + +static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts) +{ + int i; + float orig[2], ray[2] = { 1, 0 }; + float y_frac; + int winding = 0; + + /* make sure y never passes through a vertex of the shape */ + y_frac = (float) STBTT_fmod(y, 1.0f); + if (y_frac < 0.01f) + y += 0.01f; + else if (y_frac > 0.99f) + y -= 0.01f; + + orig[0] = x; + 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)) { + float 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) { + float q0[2],q1[2],q2[2]; + float hits[2][2]; + q0[0] = (float)x0; + q0[1] = (float)y0; + q1[0] = (float)x1; + q1[1] = (float)y1; + q2[0] = (float)x2; + q2[1] = (float)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)) { + float 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 float stbtt__cuberoot( float x ) +{ + if (x<0) + return -(float) STBTT_pow(-x,1.0f/3.0f); + else + return (float) STBTT_pow( x,1.0f/3.0f); +} + +/* x^3 + a*x^2 + b*x + c = 0 */ +static int stbtt__solve_cubic(float a, float b, float c, float* r) +{ + float s = -a / 3; + float p = b - a*a / 3; + float q = a * (2*a*a - 9*b) / 27 + c; + float p3 = p*p*p; + float d = q*q + 4*p3 / 27; + if (d >= 0) { + float z = (float) STBTT_sqrt(d); + float u = (-q + z) / 2; + float v = (-q - z) / 2; + u = stbtt__cuberoot(u); + v = stbtt__cuberoot(v); + r[0] = s + u + v; + return 1; + } else { + float u = (float) STBTT_sqrt(-p/3); + float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; /* p3 must be negative, since d is negative */ + float m = (float) STBTT_cos(v); + float n = (float) 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, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + float 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; + float *precompute; + stbtt_vertex *verts; + int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); + data = (unsigned char *) STBTT_malloc(w * h, info->userdata); + precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata); + + for (i=0,j=num_verts-1; i < num_verts; j=i++) { + if (verts[i].type == STBTT_vline) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; + float dist = (float) 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) { + float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; + float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; + float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float 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) { + float val; + float min_dist = 999999.0f; + float sx = (float) x + 0.5f; + float sy = (float) y + 0.5f; + float x_gspace = (sx / scale_x); + float 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) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + + if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) { + float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; + + float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + /* 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) */ + dist = (float) 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) */ + float dx = x1-x0, dy = y1-y0; + float 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 */ + float 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) { + float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; + float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; + float box_x0 = STBTT_min(STBTT_min(x0,x1),x2); + float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); + float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); + float 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; + float ax = x1-x0, ay = y1-y0; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float mx = x0 - sx, my = y0 - sy; + float res[3] = {0.f,0.f,0.f}; + float px,py,t,it,dist2; + float a_inv = precompute[i]; + if (a_inv == 0.0) { /* if a_inv is 0, it's 2nd degree so use quadratic formula */ + float a = 3*(ax*bx + ay*by); + float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); + float 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 { + float discriminant = b*b - 4*a*c; + if (discriminant < 0) + num = 0; + else { + float root = (float) 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 { + float b = 3*(ax*bx + ay*by) * a_inv; /* could precompute this as it doesn't depend on sample point */ + float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; + float d = (mx*ax+my*ay) * a_inv; + num = stbtt__solve_cubic(b, c, d, res); + } + dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + 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 = (float) 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 = (float) 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 = (float) 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, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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, + float pixel_height, unsigned char *pixels, int pw, int ph, + int first_char, int num_chars, stbtt_bakedchar *chardata) +{ + 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) +{ + return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); +} + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) +{ + return stbtt_GetNumberOfFonts_internal((unsigned char *) data); +} + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) +{ + return stbtt_InitFont_internal(info, (unsigned char *) data, offset); +} + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) +{ + 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) +{ + 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.25 (2021-07-11) many fixes */ +/* 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) 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) +{ + 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) +{ + 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) +{ + NK_STORAGE const nk_rune ranges[] = {0x0020, 0x00FF, 0}; + return ranges; +} +NK_API const nk_rune* +nk_font_chinese_glyph_ranges(void) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) { + it = config_iter; + do { + struct stbtt_fontinfo *font_info = &baker->build[i++].info; + font_info->userdata = alloc; + + if (!stbtt_InitFont(font_info, (const unsigned char*)it->ttf_blob, stbtt_GetFontOffsetForIndex((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) +{ + 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; + + float 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 = ((float)unscaled_ascent * font_scale); + dst_font->descent = ((float)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; + float 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]; + 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 * (float)width; + glyph->v0 = q.t0 * (float)height; + glyph->u1 = q.s1 * (float)width; + glyph->v1 = q.t1 * (float)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 = (float)(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) +{ + 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) +{ + 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 float +nk_font_text_width(nk_handle handle, float height, const char *text, int len) +{ + nk_rune unicode; + int text_len = 0; + float text_width = 0; + int glyph_len = 0; + float 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, float height, + struct nk_user_font_glyph *glyph, nk_rune codepoint, nk_rune next_codepoint) +{ + float 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) +{ + 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, float pixel_height, + nk_rune fallback_codepoint, struct nk_font_glyph *glyphs, + const struct nk_baked_font *baked_font, nk_handle atlas) +{ + 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 = (float)pixel_height / (float)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-VWAg      TlGW'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) +{ + 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) +{ + /* 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) +{ + 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) +{ + #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) +{ + 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) +{ + 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) +{ + return (unsigned int)((c >= '\\') ? c-36 : c-35); +} +NK_INTERN void +nk_decode_85(unsigned char* dst, const unsigned char* src) +{ + 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(float pixel_height) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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, float height, const struct nk_font_config *config) +{ + 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, + float height, const struct nk_font_config *config) +{ + 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, float height, + const struct nk_font_config *config) +{ + 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, float height, const struct nk_font_config *config) +{ + 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)nk_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, + float pixel_height, const struct nk_font_config *config) +{ + 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) +{ + 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; + NK_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 *tex_null) +{ + int i = 0; + struct nk_font *font_iter; + NK_ASSERT(atlas); + if (!atlas) { + if (!tex_null) return; + tex_null->texture = texture; + tex_null->uv = nk_vec2(0.5f,0.5f); + } + if (tex_null) { + tex_null->texture = texture; + tex_null->uv.x = (atlas->custom.x + 0.5f)/(float)atlas->tex_width; + tex_null->uv.y = (atlas->custom.y + 0.5f)/(float)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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + struct nk_input *in; + NK_ASSERT(ctx); + if (!ctx) return; + in = &ctx->input; + in->mouse.pos.x = (float)x; + in->mouse.pos.y = (float)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) +{ + 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) +{ + 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 = (float)x; + btn->clicked_pos.y = (float)y; + btn->down = down; + btn->clicked++; + + /* Fix Click-Drag for touch events. */ + in->mouse.delta.x = 0; + in->mouse.delta.y = 0; +#ifdef NK_BUTTON_TRIGGER_ON_RELEASE + if (down == 1 && id == NK_BUTTON_LEFT) + { + in->mouse.down_pos.x = btn->clicked_pos.x; + in->mouse.down_pos.y = btn->clicked_pos.y; + } +#endif +} +NK_API void +nk_input_scroll(struct nk_context *ctx, struct nk_vec2 val) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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_in_button_rect(const struct nk_input *i, enum nk_buttons id, + struct nk_rect b) +{ + const struct nk_mouse_button *btn; + if (!i) return nk_false; + btn = &i->mouse.buttons[id]; +#ifdef NK_BUTTON_TRIGGER_ON_RELEASE + if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h) + || !NK_INBOX(i->mouse.down_pos.x,i->mouse.down_pos.y,b.x,b.y,b.w,b.h)) +#else + if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h)) +#endif + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_color_names[c]; +} +NK_API struct nk_style_item +nk_style_item_color(struct nk_color col) +{ + 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_image(struct nk_image img) +{ + 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_nine_slice(struct nk_nine_slice slice) +{ + struct nk_style_item i; + i.type = NK_STYLE_ITEM_NINE_SLICE; + i.data.slice = slice; + return i; +} +NK_API struct nk_style_item +nk_style_item_hide(void) +{ + 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) +{ + 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.0f; + win->contextual_border = 1.0f; + win->menu_border = 1.0f; + win->group_border = 1.0f; + win->tooltip_border = 1.0f; + win->popup_border = 1.0f; + win->border = 2.0f; + 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) +{ + 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) +{ + 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) +{ + 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,float, floats) +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(float,floats) +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) +{ + 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) +{ + ctx->style.cursor_visible = nk_true; +} +NK_API void +nk_style_hide_cursor(struct nk_context *ctx) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + if (!ctx) return; + ctx->userdata = handle; + if (ctx->current) + ctx->current->buffer.userdata = handle; +} +#endif +NK_API void +nk_free(struct nk_context *ctx) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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 = (unsigned)(1 + (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) +{ + 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) +{ + 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) +{ + /* 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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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 float +nk_panel_get_border(const struct nk_style *style, nk_flags flags, + enum nk_panel_type type) +{ + 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) +{ + 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) +{ + return (type & NK_PANEL_SET_SUB)?1:0; +} +NK_LIB nk_bool +nk_panel_is_nonblock(enum nk_panel_type type) +{ + 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) +{ + 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)) { + nk_bool left_mouse_down; + unsigned 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 = 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 = 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; + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0,0,0,0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + text.background = background->data.color; + nk_fill_rect(out, header, 0, background->data.color); + break; + } + + /* 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 = nk_strlen(title); + struct nk_rect label = {0,0,0,0}; + float 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); + + switch(style->window.fixed_background.type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, body, &style->window.fixed_background.data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, body, &style->window.fixed_background.data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + nk_fill_rect(out, body, 0, style->window.fixed_background.data.color); + break; + } + } + + /* 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;} + return !(layout->flags & NK_WINDOW_HIDDEN) && !(layout->flags & NK_WINDOW_MINIMIZED); +} +NK_LIB void +nk_panel_end(struct nk_context *ctx) +{ + 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; + float scroll_target; + float scroll_offset; + float scroll_step; + float 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 = (float)*layout->offset_y; + scroll_step = scroll.h * 0.10f; + scroll_inc = scroll.h * 0.01f; + scroll_target = (float)(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 = (float)*layout->offset_x; + scroll_target = (float)(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 float 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) { + float 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) +{ + 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) +{ + /* 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) +{ + struct nk_window *iter; + iter = ctx->begin; + while (iter) { + NK_ASSERT(iter != iter->next); + if (iter->name == hash) { + int max_len = nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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)nk_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; + float 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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 float +nk_window_get_width(const struct nk_context *ctx) +{ + NK_ASSERT(ctx); + NK_ASSERT(ctx->current); + if (!ctx || !ctx->current) return 0; + return ctx->current->bounds.w; +} +NK_API float +nk_window_get_height(const struct nk_context *ctx) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(ctx); + NK_ASSERT(ctx->current); + if (!ctx || !ctx->current || (ctx->current->flags & NK_WINDOW_HIDDEN)) + return 0; + else { + struct nk_rect actual_bounds = ctx->current->bounds; + if (ctx->begin->flags & NK_WINDOW_MINIMIZED) { + actual_bounds.h = ctx->current->layout->header_height; + } + return nk_input_is_mouse_hovering_rect(&ctx->input, actual_bounds); + } +} +NK_API nk_bool +nk_window_is_any_hovered(struct nk_context *ctx) +{ + 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) +{ + 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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return 0; + + title_len = (int)nk_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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return 1; + + title_len = (int)nk_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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return 1; + + title_len = (int)nk_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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return 0; + + title_len = (int)nk_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) +{ + int title_len; + nk_hash title_hash; + title_len = (int)nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)nk_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) +{ + 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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)nk_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) +{ + 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) +{ + int title_len; + nk_hash title_hash; + struct nk_window *win; + NK_ASSERT(ctx); + if (!ctx) return; + + title_len = (int)nk_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) +{ + 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)nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_contextual_item_text(ctx, label, nk_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) +{ + 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) +{ + return nk_contextual_item_image_text(ctx, img, label, nk_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) +{ + 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) +{ + return nk_contextual_item_symbol_text(ctx, symbol, text, nk_strlen(text), align); +} +NK_API void +nk_contextual_close(struct nk_context *ctx) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + int is_open = 0; + int is_active = 0; + struct nk_rect body; + struct nk_window *popup; + nk_hash hash = nk_murmur_hash(id, (int)nk_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) +{ + 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) +{ + return nk_menu_begin_text(ctx, text, nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_menu_begin_image_text(ctx, title, nk_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) +{ + 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 ) +{ + return nk_menu_begin_symbol_text(ctx, title, nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_contextual_item_symbol_label(ctx, sym, label, align); +} +NK_API void nk_menu_close(struct nk_context *ctx) +{ + nk_contextual_close(ctx); +} +NK_API void +nk_menu_end(struct nk_context *ctx) +{ + nk_contextual_end(ctx); +} + + + + + +/* =============================================================== + * + * LAYOUT + * + * ===============================================================*/ +NK_API void +nk_layout_set_min_row_height(struct nk_context *ctx, float 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) +{ + 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 float +nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type, + float total_space, int columns) +{ + float panel_spacing; + float panel_space; + + struct nk_vec2 spacing; + + NK_UNUSED(type); + + spacing = style->window.spacing; + + /* calculate the usable panel space */ + panel_spacing = (float)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, + float height, int cols) +{ + 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, + float height, int cols, int width) +{ + /* 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 = (float)width; +} +NK_API float +nk_layout_ratio_from_pixel(struct nk_context *ctx, float pixel_width) +{ + 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, float height, int cols) +{ + nk_row_layout(ctx, NK_DYNAMIC, height, cols, 0); +} +NK_API void +nk_layout_row_static(struct nk_context *ctx, float height, int item_width, int cols) +{ + 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, + float row_height, int cols) +{ + 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, float ratio_or_width) +{ + 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) { + float 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) +{ + 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, + float height, int cols, const float *ratio) +{ + 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 */ + float 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 / (float)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, float 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; + 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) +{ + 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, float min_width) +{ + 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, float width) +{ + 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) +{ + struct nk_window *win; + struct nk_panel *layout; + + int i = 0; + int variable_count = 0; + int min_variable_count = 0; + float min_fixed_width = 0.0f; + float total_fixed_width = 0.0f; + float 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) { + float 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) { + float space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type, + layout->bounds.w, layout->row.columns); + float var_width = (NK_MAX(space-min_fixed_width,0.0f)) / (float)variable_count; + int enough_space = var_width >= max_variable_width; + if (!enough_space) + var_width = (NK_MAX(space-total_fixed_width,0)) / (float)min_variable_count; + for (i = 0; i < layout->row.columns; ++i) { + float *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, + float height, int widget_count) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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 - (float)*layout->offset_x; + ret.y += layout->at_y - (float)*layout->offset_y; + return ret; +} +NK_API struct nk_vec2 +nk_layout_space_to_local(struct nk_context *ctx, struct nk_vec2 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 + (float)*layout->offset_x; + ret.y += -layout->at_y + (float)*layout->offset_y; + return ret; +} +NK_API struct nk_rect +nk_layout_space_rect_to_screen(struct nk_context *ctx, 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 - (float)*layout->offset_x; + ret.y += layout->at_y - (float)*layout->offset_y; + return ret; +} +NK_API struct nk_rect +nk_layout_space_rect_to_local(struct nk_context *ctx, 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 + (float)*layout->offset_x; + ret.y += -layout->at_y + (float)*layout->offset_y; + return ret; +} +NK_LIB void +nk_panel_alloc_row(const struct nk_context *ctx, struct nk_window *win) +{ + struct nk_panel *layout = win->layout; + struct nk_vec2 spacing = ctx->style.window.spacing; + const float 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) +{ + struct nk_panel *layout; + const struct nk_style *style; + + struct nk_vec2 spacing; + + float item_offset = 0; + float item_width = 0; + float item_spacing = 0; + float 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 - (float)(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 */ + float w = NK_MAX(1.0f,panel_space) / (float)layout->row.columns; + item_offset = (float)layout->row.index * w; + item_width = w + NK_FRAC(item_offset); + item_spacing = (float)layout->row.index * spacing.x; + } break; + case NK_LAYOUT_DYNAMIC_ROW: { + /* scaling single ratio widget width */ + float 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 -= (float)*layout->offset_x; + bounds->y = layout->at_y + (layout->row.height * layout->row.item.y); + bounds->y -= (float)*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 */ + float 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 = (float)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 = (float)layout->row.index * item_width; + item_spacing = (float)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 = (float)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 -= (float)*layout->offset_x; + bounds->y = layout->at_y + layout->row.item.y; + bounds->y -= (float)*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 = (float)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*/ + float 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 = (float)layout->row.index * spacing.x; + if (modify) layout->row.item_offset += w; + } break; + #undef NK_FRAC + default: 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 - (float)*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 -= (float)*layout->offset_x; +} +NK_LIB void +nk_panel_alloc_space(struct nk_rect *bounds, const struct nk_context *ctx) +{ + 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) +{ + float 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) { + *bounds = nk_rect(0,0,0,0); + 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; +} +NK_API void +nk_spacer(struct nk_context *ctx ) +{ + struct nk_rect dummy_rect = { 0, 0, 0, 0 }; + nk_panel_alloc_space( &dummy_rect, ctx ); +} + + + + +/* =============================================================== + * + * 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) +{ + 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; + float 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; + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_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); + break; + } + } 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, nk_strlen(title), &text, + NK_TEXT_LEFT, style->font);} + + /* increase x-axis cursor widget position pointer */ + if (*state == NK_MAXIMIZED) { + layout->at_x = header.x + (float)*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) +{ + 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)nk_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) +{ + 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) +{ + return nk_tree_state_base(ctx, type, &img, title, state); +} +NK_API void +nk_tree_state_pop(struct nk_context *ctx) +{ + 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 + (float)*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) +{ + 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) +{ + return nk_tree_base(ctx, type, &img, title, initial_state, hash, len, seed); +} +NK_API void +nk_tree_pop(struct nk_context *ctx) +{ + 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) +{ + 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; + float row_height; + struct nk_vec2 padding; + + int text_len; + float 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; + + switch (background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_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); + break; + } + } + + 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 = nk_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 + (float)*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) +{ + 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)nk_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, + nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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)nk_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) +{ + return nk_group_begin_titled(ctx, title, title, flags); +} +NK_API void +nk_group_end(struct nk_context *ctx) +{ + 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) +{ + 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)nk_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) +{ + 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)nk_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) +{ + 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)nk_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(((float)view->scroll_value / (float)row_height), 0.0f); + view->count = (int)NK_MAX(nk_iceilf((layout->clip.h)/(float)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) +{ + 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 + (float)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) +{ + 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) +{ + 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) +{ + 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 float +nk_widget_width(struct nk_context *ctx) +{ + 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 float +nk_widget_height(struct nk_context *ctx) +{ + 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) +{ + 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 = (float)((int)c.x); + c.y = (float)((int)c.y); + c.w = (float)((int)c.w); + c.h = (float)((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) +{ + 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 = (float)((int)c.x); + c.y = (float)((int)c.y); + c.w = (float)((int)c.w); + c.h = (float)((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) +{ + 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 = (float)((int)c.x); + c.y = (float)((int)c.y); + c.w = (float)((int)c.w); + c.h = (float)((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) +{ + 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 floating point errors */ + bounds->x = (float)((int)bounds->x); + bounds->y = (float)((int)bounds->y); + bounds->w = (float)((int)bounds->w); + bounds->h = (float)((int)bounds->h); + + c.x = (float)((int)c.x); + c.y = (float)((int)c.y); + c.w = (float)((int)c.w); + c.h = (float)((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) +{ + /* 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) +{ + 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) +{ + struct nk_rect label; + float text_width; + + NK_ASSERT(o); + NK_ASSERT(t); + 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 + (float)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 + (float)text_width)); + label.w = (float)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 - (float)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) +{ + float 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) +{ + 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) +{ + 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, ...) +{ + 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, ...) +{ + 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, ...) +{ + 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,...) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + nk_labelf(ctx, NK_TEXT_LEFT, "%s: %u", prefix, value); +} +NK_API void +nk_value_float(struct nk_context *ctx, const char *prefix, float 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) +{ + 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_float(struct nk_context *ctx, const char *p, struct nk_color color) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + nk_text(ctx, str, nk_strlen(str), alignment); +} +NK_API void +nk_label_colored(struct nk_context *ctx, const char *str, nk_flags align, + struct nk_color color) +{ + nk_text_colored(ctx, str, nk_strlen(str), align, color); +} +NK_API void +nk_label_wrap(struct nk_context *ctx, const char *str) +{ + nk_text_wrap(ctx, str, nk_strlen(str)); +} +NK_API void +nk_label_colored_wrap(struct nk_context *ctx, const char *str, struct nk_color color) +{ + nk_text_wrap_colored(ctx, str, nk_strlen(str), color); +} + + + + + +/* =============================================================== + * + * IMAGE + * + * ===============================================================*/ +NK_API nk_handle +nk_handle_ptr(void *ptr) +{ + nk_handle handle = {0}; + handle.ptr = ptr; + return handle; +} +NK_API nk_handle +nk_handle_id(int id) +{ + nk_handle handle; + nk_zero_struct(handle); + handle.id = id; + return handle; +} +NK_API struct nk_image +nk_subimage_ptr(void *ptr, nk_ushort w, nk_ushort h, struct nk_rect r) +{ + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle.ptr = ptr; + s.w = w; s.h = h; + s.region[0] = (nk_ushort)r.x; + s.region[1] = (nk_ushort)r.y; + s.region[2] = (nk_ushort)r.w; + s.region[3] = (nk_ushort)r.h; + return s; +} +NK_API struct nk_image +nk_subimage_id(int id, nk_ushort w, nk_ushort h, struct nk_rect r) +{ + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle.id = id; + s.w = w; s.h = h; + s.region[0] = (nk_ushort)r.x; + s.region[1] = (nk_ushort)r.y; + s.region[2] = (nk_ushort)r.w; + s.region[3] = (nk_ushort)r.h; + return s; +} +NK_API struct nk_image +nk_subimage_handle(nk_handle handle, nk_ushort w, nk_ushort h, struct nk_rect r) +{ + struct nk_image s; + nk_zero(&s, sizeof(s)); + s.handle = handle; + s.w = w; s.h = h; + s.region[0] = (nk_ushort)r.x; + s.region[1] = (nk_ushort)r.y; + s.region[2] = (nk_ushort)r.w; + s.region[3] = (nk_ushort)r.h; + return s; +} +NK_API struct nk_image +nk_image_handle(nk_handle 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(img); + return !(img->w == 0 && img->h == 0); +} +NK_API void +nk_image(struct nk_context *ctx, struct nk_image img) +{ + 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) +{ + 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); +} + + + + + +/* =============================================================== + * + * 9-SLICE + * + * ===============================================================*/ +NK_API struct nk_nine_slice +nk_sub9slice_ptr(void *ptr, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + i->handle.ptr = ptr; + i->w = w; i->h = h; + i->region[0] = (nk_ushort)rgn.x; + i->region[1] = (nk_ushort)rgn.y; + i->region[2] = (nk_ushort)rgn.w; + i->region[3] = (nk_ushort)rgn.h; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API struct nk_nine_slice +nk_sub9slice_id(int id, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + i->handle.id = id; + i->w = w; i->h = h; + i->region[0] = (nk_ushort)rgn.x; + i->region[1] = (nk_ushort)rgn.y; + i->region[2] = (nk_ushort)rgn.w; + i->region[3] = (nk_ushort)rgn.h; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API struct nk_nine_slice +nk_sub9slice_handle(nk_handle handle, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + i->handle = handle; + i->w = w; i->h = h; + i->region[0] = (nk_ushort)rgn.x; + i->region[1] = (nk_ushort)rgn.y; + i->region[2] = (nk_ushort)rgn.w; + i->region[3] = (nk_ushort)rgn.h; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API struct nk_nine_slice +nk_nine_slice_handle(nk_handle handle, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + i->handle = handle; + i->w = 0; i->h = 0; + i->region[0] = 0; + i->region[1] = 0; + i->region[2] = 0; + i->region[3] = 0; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API struct nk_nine_slice +nk_nine_slice_ptr(void *ptr, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + NK_ASSERT(ptr); + i->handle.ptr = ptr; + i->w = 0; i->h = 0; + i->region[0] = 0; + i->region[1] = 0; + i->region[2] = 0; + i->region[3] = 0; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API struct nk_nine_slice +nk_nine_slice_id(int id, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b) +{ + struct nk_nine_slice s; + struct nk_image *i = &s.img; + nk_zero(&s, sizeof(s)); + i->handle.id = id; + i->w = 0; i->h = 0; + i->region[0] = 0; + i->region[1] = 0; + i->region[2] = 0; + i->region[3] = 0; + s.l = l; s.t = t; s.r = r; s.b = b; + return s; +} +NK_API int +nk_nine_slice_is_sub9slice(const struct nk_nine_slice* slice) +{ + NK_ASSERT(slice); + return !(slice->img.w == 0 && slice->img.h == 0); +} + + + + + +/* ============================================================== + * + * 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, + float border_width, const struct nk_user_font *font) +{ + 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) +{ + 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_button_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) +{ + 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; + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case 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); + break; + } + 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) +{ + struct nk_rect bounds; + NK_ASSERT(style); + NK_ASSERT(state); + NK_ASSERT(out); + 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) +{ + struct nk_text text; + const struct nk_style_item *background; + background = nk_draw_button(out, bounds, state, style); + + /* select correct colors/images */ + 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, *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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_button_text_styled(ctx, style, title, nk_strlen(title)); +} +NK_API nk_bool nk_button_label(struct nk_context *ctx, const char *title) +{ + return nk_button_text(ctx, title, nk_strlen(title)); +} +NK_API nk_bool +nk_button_color(struct nk_context *ctx, struct nk_color 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_button_symbol_text(ctx, symbol, label, nk_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) +{ + return nk_button_symbol_text_styled(ctx, style, symbol, title, nk_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) +{ + 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) +{ + 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) +{ + return nk_button_image_text(ctx, img, label, nk_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) +{ + return nk_button_image_text_styled(ctx, style, img, label, nk_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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_check_text(ctx, label, nk_strlen(label), active); +} +NK_API unsigned int nk_check_flags_label(struct nk_context *ctx, const char *label, + unsigned int flags, unsigned int value) +{ + return nk_check_flags_text(ctx, label, nk_strlen(label), flags, value); +} +NK_API nk_bool nk_checkbox_label(struct nk_context *ctx, const char *label, nk_bool *active) +{ + return nk_checkbox_text(ctx, label, nk_strlen(label), active); +} +NK_API nk_bool nk_checkbox_flags_label(struct nk_context *ctx, const char *label, + unsigned int *flags, unsigned int value) +{ + return nk_checkbox_flags_text(ctx, label, nk_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) +{ + 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) +{ + 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) +{ + return nk_option_text(ctx, label, nk_strlen(label), active); +} +NK_API nk_bool +nk_radio_label(struct nk_context *ctx, const char *label, nk_bool *active) +{ + return nk_radio_text(ctx, label, nk_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) +{ + 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 */ + switch (background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + text.background = background->data.color; + nk_fill_rect(out, *bounds, style->rounding, background->data.color); + break; + } + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_selectable_symbol_text(ctx, sym, title, nk_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) +{ + 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) +{ + return nk_selectable_text(ctx, str, nk_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) +{ + return nk_selectable_image_text(ctx, img, str, nk_strlen(str), align, value); +} +NK_API nk_bool nk_select_label(struct nk_context *ctx, const char *str, nk_flags align, nk_bool value) +{ + nk_selectable_text(ctx, str, nk_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) +{ + nk_selectable_image_text(ctx, img, str, nk_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) +{ + 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) +{ + 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) +{ + return nk_select_symbol_text(ctx, sym, title, nk_strlen(title), align, value); +} + + + + + +/* =============================================================== + * + * SLIDER + * + * ===============================================================*/ +NK_LIB float +nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor, + struct nk_rect *visual_cursor, struct nk_input *in, + struct nk_rect bounds, float slider_min, float slider_max, float slider_value, + float slider_step, float slider_steps) +{ + 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) { + float ratio = 0; + const float d = in->mouse.pos.x - (visual_cursor->x+visual_cursor->w*0.5f); + const float 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 float steps = (float)((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, float min, float value, float max) +{ + 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 */ + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case 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); + break; + } + + /* 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 float +nk_do_slider(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect bounds, + float min, float val, float max, float step, + const struct nk_style_slider *style, struct nk_input *in, + const struct nk_user_font *font) +{ + float slider_range; + float slider_min; + float slider_max; + float slider_value; + float slider_steps; + float 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_float(struct nk_context *ctx, float min_value, float *value, float max_value, + float value_step) +{ + struct nk_window *win; + struct nk_panel *layout; + struct nk_input *in; + const struct nk_style *style; + + int ret = 0; + float 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 float +nk_slide_float(struct nk_context *ctx, float min, float val, float max, float step) +{ + nk_slider_float(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) +{ + float value = (float)val; + nk_slider_float(ctx, (float)min, &value, (float)max, (float)step); + return (int)value; +} +NK_API nk_bool +nk_slider_int(struct nk_context *ctx, int min, int *val, int max, int step) +{ + int ret; + float value = (float)*val; + ret = nk_slider_float(ctx, (float)min, &value, (float)max, (float)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) +{ + 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) { + float ratio = NK_MAX(0, (float)(in->mouse.pos.x - cursor.x)) / (float)cursor.w; + value = (nk_size)NK_CLAMP(0, (float)max * ratio, (float)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) +{ + 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 */ + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case 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); + break; + } + + /* draw cursor */ + switch(cursor->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *scursor, &cursor->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *scursor, &cursor->data.slice, nk_white); + break; + case 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); + break; + } +} +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) +{ + float 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 = (float)value / (float)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) +{ + 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) +{ + nk_progress(ctx, &cur, max, modifyable); + return cur; +} + + + + + +/* =============================================================== + * + * SCROLLBAR + * + * ===============================================================*/ +NK_LIB float +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, float scroll_offset, + float target, float scroll_step, enum nk_orientation o) +{ + nk_flags ws = 0; + int left_mouse_down; + unsigned int left_mouse_clicked; + int left_mouse_click_in_cursor; + float 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 */ + float pixel, delta; + *state = NK_WIDGET_STATE_ACTIVE; + if (o == NK_VERTICAL) { + float 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 { + float 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) +{ + 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 */ + switch (background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case 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); + break; + } + + /* draw cursor */ + switch (cursor->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, *scroll, &cursor->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, *scroll, &cursor->data.slice, nk_white); + break; + case 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); + break; + } +} +NK_LIB float +nk_do_scrollbarv(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, + float offset, float target, float step, float button_pixel_inc, + const struct nk_style_scrollbar *style, struct nk_input *in, + const struct nk_user_font *font) +{ + struct nk_rect empty_north; + struct nk_rect empty_south; + struct nk_rect cursor; + + float scroll_step; + float scroll_offset; + float scroll_off; + float 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; + float 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 float +nk_do_scrollbarh(nk_flags *state, + struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling, + float offset, float target, float step, float button_pixel_inc, + const struct nk_style_scrollbar *style, struct nk_input *in, + const struct nk_user_font *font) +{ + struct nk_rect cursor; + struct nk_rect empty_west; + struct nk_rect empty_east; + + float scroll_step; + float scroll_offset; + float scroll_off; + float 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; + float 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 { + float x,y; /* position of n'th character */ + float 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 { + float x0,x1; + /* starting x location, end x location (allows for align=right, etc) */ + float baseline_y_delta; + /* position of baseline relative to previous row's baseline*/ + float 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 float +nk_textedit_get_width(const struct nk_text_edit *edit, int line_start, int char_id, + const struct nk_user_font *font) +{ + 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, float row_height, const struct nk_user_font *font) +{ + 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, float x, float y, + const struct nk_user_font *font, float row_height) +{ + struct nk_text_edit_row r; + int n = edit->string.len; + float 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) { + float 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, float x, float y, + const struct nk_user_font *font, float row_height) +{ + /* 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, float x, float y, + const struct nk_user_font *font, float row_height) +{ + /* 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, float row_height) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + /* 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) +{ + /* 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) +{ + /* 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) +{ + 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 = NK_MIN(state->cursor + 1, state->string.len); + 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, float row_height) +{ +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) + { + float x; + float 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) { + float 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 */ + float x; + float 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) { + float 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) +{ + 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) +{ + /* 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) +{ +/* 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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + nk_textedit_createundo(&state->undo, where, 0, length); +} +NK_INTERN void +nk_textedit_makeundo_delete(struct nk_text_edit *state, int where, int length) +{ + 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) +{ + 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) +{ + /* 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) +{ + 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) +{ + 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) +{ + 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) +{ + NK_ASSERT(state); + state->select_start = 0; + state->select_end = state->string.len; +} +NK_API void +nk_textedit_free(struct nk_text_edit *state) +{ + 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) +{ + 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) +{ + NK_UNUSED(box); + if (unicode > 128) return nk_false; + else return nk_true; +} +NK_API nk_bool +nk_filter_float(const struct nk_text_edit *box, nk_rune unicode) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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, float pos_x, float pos_y, + float x_offset, const char *text, int byte_len, float row_height, + const struct nk_user_font *font, struct nk_color background, + struct nk_color foreground, nk_bool is_selected) +{ + 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; + float line_width = 0; + float glyph_width; + const char *line = text; + float 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 += (float)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) +{ + struct nk_rect area; + nk_flags ret = 0; + float 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 float mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x; + const float 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; + } + + /* 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 */ + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(out, bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(out, bounds, &background->data.slice, nk_white); + break; + case 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); + break; + }} + + + area.w = NK_MAX(0, area.w - style->cursor_size); + if (edit->active) + { + 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 */ + float line_width = 0.0f; + if (text && len) + { + /* utf8 encoding */ + float 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 = (float)(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 = (float)(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 = (float)(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 += (float)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 = (float)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 float scroll_increment = area.w * 0.25f; + if (cursor_pos.x < edit->scrollbar.x) + edit->scrollbar.x = (float)(int)NK_MAX(0.0f, cursor_pos.x - scroll_increment); + if (cursor_pos.x >= edit->scrollbar.x + area.w) + edit->scrollbar.x = (float)(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 + row_height) + 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; + float scroll_target; + float scroll_offset; + float scroll_step; + float 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); + if (*state & NK_WIDGET_STATE_ACTIVED) { + background = &style->active; + text_color = style->text_active; + } else if (*state & NK_WIDGET_STATE_HOVER) { + background = &style->hover; + text_color = style->text_hover; + } else { + background = &style->normal; + text_color = style->text_normal; + } + if (background->type == NK_STYLE_ITEM_IMAGE) + background_color = nk_rgba(0,0,0,0); + else + 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) +{ + 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) +{ + 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) +{ + 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); + + 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 = (float)win->edit.scrollbar.x; + edit->scrollbar.y = (float)win->edit.scrollbar.y; + edit->active = nk_true; + } else edit->active = nk_false; + + max = NK_MAX(1, max); + *len = NK_MIN(*len, max-1); + 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); + 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; + } 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) +{ + 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; + 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; + } 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) +{ + nk_flags result; + int len = nk_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, + float inc_per_pixel) +{ + 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) { + float 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_FLOAT: + variant->value.f = variant->value.f + (float)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, + float inc_per_pixel) +{ + 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) +{ + 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 */ + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_image(out, *bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + + /* 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, + float 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) +{ + const nk_plugin_filter filters[] = { + nk_filter_decimal, + nk_filter_float + }; + nk_bool active, old; + int num_len = 0, name_len; + char string[NK_MAX_NUMBER_BUFFER]; + float 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 = nk_strlen(name); + size = font->width(font->userdata, font->height, name, name_len); + label.x = left.x + left.w + style->padding.x; + label.w = (float)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 = nk_strlen(string); + break; + case NK_PROPERTY_FLOAT: + NK_DTOA(string, (double)variant->value.f); + num_len = nk_string_float_limit(string, NK_MAX_FLOAT_PRECISION); + break; + case NK_PROPERTY_DOUBLE: + NK_DTOA(string, variant->value.d); + num_len = nk_string_float_limit(string, NK_MAX_FLOAT_PRECISION); + break; + } + size = font->width(font->userdata, font->height, string, num_len); + dst = string; + length = &num_len; + } + + edit.w = (float)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_FLOAT: + 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_FLOAT: + 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_FLOAT: + nk_string_float_limit(buffer, NK_MAX_FLOAT_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_float_limit(buffer, NK_MAX_FLOAT_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) +{ + 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_float(float value, float min_value, float max_value, float step) +{ + struct nk_property_variant result; + result.kind = NK_PROPERTY_FLOAT; + 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) +{ + 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, + float inc_per_pixel, const enum nk_property_filter filter) +{ + 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)nk_strlen(name), win->property.seq++); + name++; /* special number hash */ + } else hash = nk_murmur_hash(name, (int)nk_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, float 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.i; +} +NK_API void +nk_property_float(struct nk_context *ctx, const char *name, + float min, float *val, float max, float step, float 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_float(*val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT); + *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, float 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_double(*val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT); + *val = variant.value.d; +} +NK_API int +nk_propertyi(struct nk_context *ctx, const char *name, int min, int val, + int max, int step, float inc_per_pixel) +{ + 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 float +nk_propertyf(struct nk_context *ctx, const char *name, float min, + float val, float max, float step, float inc_per_pixel) +{ + struct nk_property_variant variant; + NK_ASSERT(ctx); + NK_ASSERT(name); + + if (!ctx || !ctx->current || !name) return val; + variant = nk_property_variant_float(val, min, max, step); + nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT); + 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, float inc_per_pixel) +{ + 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_FLOAT); + 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, float min_value, float max_value) +{ + 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; + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(&win->buffer, bounds, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(&win->buffer, bounds, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + return 1; +} +NK_API nk_bool +nk_chart_begin(struct nk_context *ctx, const enum nk_chart_type type, + int count, float min_value, float max_value) +{ + 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, float min_value, float max_value) +{ + 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, float min_value, float max_value) +{ + 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, float value, int slot) +{ + 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; + float step; + float range; + float ratio; + + NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT); + step = g->w / (float)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 * (float)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 + (float)(step * (float)g->slots[slot].index); + cur.y = (g->y + g->h) - (ratio * (float)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, float value, int slot) +{ + struct nk_command_buffer *out = &win->buffer; + const struct nk_input *in = &ctx->input; + struct nk_panel *layout = win->layout; + + float 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) { + float padding = (float)(chart->slots[slot].count-1); + item.w = (chart->w - padding) / (float)(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 + ((float)chart->slots[slot].index * item.w); + item.x = item.x + ((float)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, float value, int 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, float value) +{ + return nk_chart_push_slot(ctx, value, 0); +} +NK_API void +nk_chart_end(struct nk_context *ctx) +{ + 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 float *values, + int count, int offset) +{ + int i = 0; + float min_value; + float 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, + float(*value_getter)(void* user, int index), int count, int offset) +{ + int i = 0; + float min_value; + float 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) { + float 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) +{ + float 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) +{ + 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 float crosshair_size = 7.0f; + struct nk_color temp; + float hsva[4]; + float 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 + (float)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 = (float)(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) { + float alpha = NK_SATURATE(col.a); + line_y = (float)(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; float S = hsva[1]; float V = hsva[2]; + p.x = (float)(int)(matrix->x + S * matrix->w); + p.y = (float)(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) +{ + int ret = 0; + struct nk_rect matrix; + struct nk_rect hue_bar; + struct nk_rect alpha_bar; + float 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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; + } + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + { + /* 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) +{ + return nk_combo_begin_text(ctx, selected, nk_strlen(selected), size); +} +NK_API nk_bool +nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_vec2 size) +{ + 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; + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_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); + break; + } + { + 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) +{ + 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; + } + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + sym_background = nk_rgba(0, 0, 0, 0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + sym_background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + { + 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) +{ + 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; + } + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + { + 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) +{ + 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; + + switch (background->type) { + case NK_STYLE_ITEM_IMAGE: + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_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); + break; + } + { + 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) +{ + 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; + } + + switch(background->type) { + case NK_STYLE_ITEM_IMAGE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_image(&win->buffer, header, &background->data.image, nk_white); + break; + case NK_STYLE_ITEM_NINE_SLICE: + text.background = nk_rgba(0, 0, 0, 0); + nk_draw_nine_slice(&win->buffer, header, &background->data.slice, nk_white); + break; + case NK_STYLE_ITEM_COLOR: + 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); + break; + } + { + 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) +{ + return nk_combo_begin_symbol_text(ctx, selected, nk_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) +{ + return nk_combo_begin_image_text(ctx, selected, nk_strlen(selected), img, size); +} +NK_API nk_bool +nk_combo_item_text(struct nk_context *ctx, const char *text, int len,nk_flags align) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + return nk_contextual_item_symbol_label(ctx, sym, label, alignment); +} +NK_API void nk_combo_end(struct nk_context *ctx) +{ + nk_contextual_end(ctx); +} +NK_API void nk_combo_close(struct nk_context *ctx) +{ + 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) +{ + 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, (float)max_height); + if (nk_combo_begin_label(ctx, items[selected], size)) { + nk_layout_row_dynamic(ctx, (float)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) +{ + 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, (float)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, (float)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) +{ + 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) +{ + 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, (float)max_height); + + item_getter(userdata, selected, &item); + if (nk_combo_begin_label(ctx, item, size)) { + nk_layout_row_dynamic(ctx, (float)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) +{ + *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) +{ + *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) +{ + *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) +{ + *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, float width) +{ + 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 = (float)x; + bounds.y = (float)y; + bounds.w = (float)w; + bounds.h = (float)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) +{ + 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) +{ + const struct nk_style *style; + struct nk_vec2 padding; + + int text_len; + float text_width; + float 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 = nk_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, (float)text_width)) { + nk_layout_row_dynamic(ctx, (float)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, ...) +{ + 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) +{ + 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.y.z]) - [description] +/// - [date]: date on which the change has been pushed +/// - [x.y.z]: Version string, represented in Semantic Versioning format +/// - [x]: Major version with API and library breaking changes +/// - [y]: Minor version with non-breaking API and library changes +/// - [z]: Patch version with no direct changes to the API +/// +/// - 2022/12/23 (4.10.6) - Fix incorrect glyph index in nk_font_bake() +/// - 2022/12/17 (4.10.5) - Fix nk_font_bake_pack() using TTC font offset incorrectly +/// - 2022/10/24 (4.10.4) - Fix nk_str_{append,insert}_str_utf8 always returning 0 +/// - 2022/09/03 (4.10.3) - Renamed the `null` texture variable to `tex_null` +/// - 2022/08/01 (4.10.2) - Fix Apple Silicon with incorrect NK_SITE_TYPE and NK_POINTER_TYPE +/// - 2022/08/01 (4.10.1) - Fix cursor jumping back to beginning of text when typing more than +/// nk_edit_xxx limit +/// - 2022/05/27 (4.10.0) - Add nk_input_has_mouse_click_in_button_rect() to fix window move bug +/// - 2022/04/18 (4.9.7) - Change button behavior when NK_BUTTON_TRIGGER_ON_RELEASE is defined to +/// only trigger when the mouse position was inside the same button on down +/// - 2022/02/03 (4.9.6) - Allow overriding the NK_INV_SQRT function, similar to NK_SIN and NK_COS +/// - 2021/12/22 (4.9.5) - Revert layout bounds not accounting for padding due to regressions +/// - 2021/12/22 (4.9.4) - Fix checking hovering when window is minimized +/// - 2021/12/22 (4.09.3) - Fix layout bounds not accounting for padding +/// - 2021/12/19 (4.09.2) - Update to stb_rect_pack.h v1.01 and stb_truetype.h v1.26 +/// - 2021/12/16 (4.09.1) - Fix the majority of GCC warnings +/// - 2021/10/16 (4.09.0) - Added nk_spacer() widget +/// - 2021/09/22 (4.08.6) - Fix "may be used uninitialized" warnings in nk_widget +/// - 2021/09/22 (4.08.5) - GCC __builtin_offsetof only exists in version 4 and later +/// - 2021/09/15 (4.08.4) - Fix "'num_len' may be used uninitialized" in nk_do_property +/// - 2021/09/15 (4.08.3) - Fix "Templates cannot be declared to have 'C' Linkage" +/// - 2021/09/08 (4.08.2) - Fix warnings in C89 builds +/// - 2021/09/08 (4.08.1) - Use compiler builtins for NK_OFFSETOF when possible +/// - 2021/08/17 (4.08.0) - Implemented 9-slice scaling support for widget styles +/// - 2021/08/16 (4.07.5) - Replace usage of memset in nk_font_atlas_bake with NK_MEMSET +/// - 2021/08/15 (4.07.4) - Fix conversion and sign conversion warnings +/// - 2021/08/08 (4.07.3) - Fix crash when baking merged fonts +/// - 2021/08/08 (4.07.2) - Fix Multiline Edit wrong offset +/// - 2021/03/17 (4.07.1) - Fix warning about unused parameter +/// - 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 separated 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 float and byte color representation. +/// Color pickers now use floating 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 formatted 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: Modifying window position and size functions now +/// require the name of the window and must happen outside the window +/// building process (between function call nk_begin and nk_end). +/// - 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 boundaries. +/// - 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 float 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 programmatic way to 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 glyphs. +/// - 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 committing. +/// - 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 glyphs 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 float and instead +/// work directly on the given values. +/// - 2016/08/09 (1.08.0) - Added additional define to overwrite library internal +/// floating pointer number to string conversion for additional +/// precision. +/// - 2016/08/09 (1.08.0) - Added additional define to overwrite library internal +/// string to floating 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 floating point error inside `nk_widget` leading +/// to wrong wiget width calculation which results in widgets falsely +/// becoming 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 dependent button +/// behavior instead of passing it for every function call. +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// ## 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/nuklear_xlib_gl3.h b/nuklear/nuklear_xlib_gl3.h new file mode 100644 index 0000000..f2cdbba --- /dev/null +++ b/nuklear/nuklear_xlib_gl3.h @@ -0,0 +1,756 @@ +/* + * Nuklear - v1.17 - public domain + * no warrenty implied; use at your own risk. + * authored from 2015-2016 by Micha Mettke + */ +/* + * ============================================================== + * + * API + * + * =============================================================== + */ +#ifndef NK_XLIB_GL3_H_ +#define NK_XLIB_GL3_H_ + +#include +NK_API struct nk_context* nk_x11_init(Display *dpy, Window win); +NK_API void nk_x11_font_stash_begin(struct nk_font_atlas **atlas); +NK_API void nk_x11_font_stash_end(void); +NK_API int nk_x11_handle_event(XEvent *evt); +NK_API void nk_x11_render(enum nk_anti_aliasing, int max_vertex_buffer, int max_element_buffer); +NK_API void nk_x11_shutdown(void); +NK_API int nk_x11_device_create(void); +NK_API void nk_x11_device_destroy(void); + +#endif +/* + * ============================================================== + * + * IMPLEMENTATION + * + * =============================================================== + */ +#ifdef NK_XLIB_GL3_IMPLEMENTATION +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#ifndef NK_X11_DOUBLE_CLICK_LO +#define NK_X11_DOUBLE_CLICK_LO 20 +#endif +#ifndef NK_X11_DOUBLE_CLICK_HI +#define NK_X11_DOUBLE_CLICK_HI 200 +#endif + +#ifdef NK_XLIB_LOAD_OPENGL_EXTENSIONS +#include + +/* GL_ARB_vertex_buffer_object */ +typedef void(*nkglGenBuffers)(GLsizei, GLuint*); +typedef void(*nkglBindBuffer)(GLenum, GLuint); +typedef void(*nkglBufferData)(GLenum, GLsizeiptr, const GLvoid*, GLenum); +typedef void(*nkglBufferSubData)(GLenum, GLintptr, GLsizeiptr, const GLvoid*); +typedef void*(*nkglMapBuffer)(GLenum, GLenum); +typedef GLboolean(*nkglUnmapBuffer)(GLenum); +typedef void(*nkglDeleteBuffers)(GLsizei, GLuint*); +/* GL_ARB_vertex_array_object */ +typedef void (*nkglGenVertexArrays)(GLsizei, GLuint*); +typedef void (*nkglBindVertexArray)(GLuint); +typedef void (*nkglDeleteVertexArrays)(GLsizei, const GLuint*); +/* GL_ARB_vertex_program / GL_ARB_fragment_program */ +typedef void(*nkglVertexAttribPointer)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*); +typedef void(*nkglEnableVertexAttribArray)(GLuint); +typedef void(*nkglDisableVertexAttribArray)(GLuint); +/* GL_ARB_framebuffer_object */ +typedef void(*nkglGenerateMipmap)(GLenum target); +/* GLSL/OpenGL 2.0 core */ +typedef GLuint(*nkglCreateShader)(GLenum); +typedef void(*nkglShaderSource)(GLuint, GLsizei, const GLchar**, const GLint*); +typedef void(*nkglCompileShader)(GLuint); +typedef void(*nkglGetShaderiv)(GLuint, GLenum, GLint*); +typedef void(*nkglGetShaderInfoLog)(GLuint, GLsizei, GLsizei*, GLchar*); +typedef void(*nkglDeleteShader)(GLuint); +typedef GLuint(*nkglCreateProgram)(void); +typedef void(*nkglAttachShader)(GLuint, GLuint); +typedef void(*nkglDetachShader)(GLuint, GLuint); +typedef void(*nkglLinkProgram)(GLuint); +typedef void(*nkglUseProgram)(GLuint); +typedef void(*nkglGetProgramiv)(GLuint, GLenum, GLint*); +typedef void(*nkglGetProgramInfoLog)(GLuint, GLsizei, GLsizei*, GLchar*); +typedef void(*nkglDeleteProgram)(GLuint); +typedef GLint(*nkglGetUniformLocation)(GLuint, const GLchar*); +typedef GLint(*nkglGetAttribLocation)(GLuint, const GLchar*); +typedef void(*nkglUniform1i)(GLint, GLint); +typedef void(*nkglUniform1f)(GLint, GLfloat); +typedef void(*nkglUniformMatrix3fv)(GLint, GLsizei, GLboolean, const GLfloat*); +typedef void(*nkglUniformMatrix4fv)(GLint, GLsizei, GLboolean, const GLfloat*); + +static nkglGenBuffers glGenBuffers; +static nkglBindBuffer glBindBuffer; +static nkglBufferData glBufferData; +static nkglBufferSubData glBufferSubData; +static nkglMapBuffer glMapBuffer; +static nkglUnmapBuffer glUnmapBuffer; +static nkglDeleteBuffers glDeleteBuffers; +static nkglGenVertexArrays glGenVertexArrays; +static nkglBindVertexArray glBindVertexArray; +static nkglDeleteVertexArrays glDeleteVertexArrays; +static nkglVertexAttribPointer glVertexAttribPointer; +static nkglEnableVertexAttribArray glEnableVertexAttribArray; +static nkglDisableVertexAttribArray glDisableVertexAttribArray; +static nkglGenerateMipmap glGenerateMipmap; +static nkglCreateShader glCreateShader; +static nkglShaderSource glShaderSource; +static nkglCompileShader glCompileShader; +static nkglGetShaderiv glGetShaderiv; +static nkglGetShaderInfoLog glGetShaderInfoLog; +static nkglDeleteShader glDeleteShader; +static nkglCreateProgram glCreateProgram; +static nkglAttachShader glAttachShader; +static nkglDetachShader glDetachShader; +static nkglLinkProgram glLinkProgram; +static nkglUseProgram glUseProgram; +static nkglGetProgramiv glGetProgramiv; +static nkglGetProgramInfoLog glGetProgramInfoLog; +static nkglDeleteProgram glDeleteProgram; +static nkglGetUniformLocation glGetUniformLocation; +static nkglGetAttribLocation glGetAttribLocation; +static nkglUniform1i glUniform1i; +static nkglUniform1f glUniform1f; +static nkglUniformMatrix3fv glUniformMatrix3fv; +static nkglUniformMatrix4fv glUniformMatrix4fv; + +enum graphics_card_vendors { + VENDOR_UNKNOWN, + VENDOR_NVIDIA, + VENDOR_AMD, + VENDOR_INTEL +}; + +struct opengl_info { + /* info */ + const char *vendor_str; + const char *version_str; + const char *extensions_str; + const char *renderer_str; + const char *glsl_version_str; + enum graphics_card_vendors vendor; + /* version */ + float version; + int major_version; + int minor_version; + /* extensions */ + int glsl_available; + int vertex_buffer_obj_available; + int vertex_array_obj_available; + int map_buffer_range_available; + int fragment_program_available; + int frame_buffer_object_available; +}; +#endif + +struct nk_x11_vertex { + float position[2]; + float uv[2]; + nk_byte col[4]; +}; + +struct nk_x11_device { +#ifdef NK_XLIB_LOAD_OPENGL_EXTENSIONS + struct opengl_info info; +#endif + struct nk_buffer cmds; + struct nk_draw_null_texture tex_null; + GLuint vbo, vao, ebo; + GLuint prog; + GLuint vert_shdr; + GLuint frag_shdr; + GLint attrib_pos; + GLint attrib_uv; + GLint attrib_col; + GLint uniform_tex; + GLint uniform_proj; + GLuint font_tex; +}; + +static struct nk_x11 { + struct nk_x11_device ogl; + struct nk_context ctx; + struct nk_font_atlas atlas; + Cursor cursor; + Display *dpy; + Window win; + long last_button_click; +} x11; + +#ifdef __APPLE__ + #define NK_SHADER_VERSION "#version 150\n" +#else + #define NK_SHADER_VERSION "#version 300 es\n" +#endif + +#ifdef NK_XLIB_LOAD_OPENGL_EXTENSIONS +#include + +NK_INTERN long +nk_timestamp(void) +{ + struct timeval tv; + if (gettimeofday(&tv, NULL) < 0) return 0; + return (long)((long)tv.tv_sec * 1000 + (long)tv.tv_usec/1000); +} + +NK_INTERN int +nk_x11_stricmpn(const char *a, const char *b, int len) +{ + int i = 0; + for (i = 0; i < len && a[i] && b[i]; ++i) + if (a[i] != b[i]) return 1; + if (i != len) return 1; + return 0; +} + +NK_INTERN int +nk_x11_check_extension(struct opengl_info *GL, const char *ext) +{ + const char *start, *where, *term; + where = strchr(ext, ' '); + if (where || *ext == '\0') + return nk_false; + + for (start = GL->extensions_str;;) { + where = strstr((const char*)start, ext); + if (!where) break; + term = where + strlen(ext); + if (where == start || *(where - 1) == ' ') { + if (*term == ' ' || *term == '\0') + return nk_true; + } + start = term; + } + return nk_false; +} + +#define GL_EXT(name) (nk##name)nk_gl_ext(#name) +NK_INTERN __GLXextFuncPtr +nk_gl_ext(const char *name) +{ + __GLXextFuncPtr func; + func = glXGetProcAddress((const GLubyte*)name); + if (!func) { + fprintf(stdout, "[GL]: failed to load extension: %s", name); + return NULL; + } + return func; +} + +NK_INTERN int +nk_load_opengl(struct opengl_info *gl) +{ + int failed = nk_false; + gl->version_str = (const char*)glGetString(GL_VERSION); + glGetIntegerv(GL_MAJOR_VERSION, &gl->major_version); + glGetIntegerv(GL_MINOR_VERSION, &gl->minor_version); + if (gl->major_version < 2) { + fprintf(stderr, "[GL]: Graphics card does not fulfill minimum OpenGL 2.0 support\n"); + return 0; + } + gl->version = (float)gl->major_version + (float)gl->minor_version * 0.1f; + gl->renderer_str = (const char*)glGetString(GL_RENDERER); + gl->extensions_str = (const char*)glGetString(GL_EXTENSIONS); + gl->glsl_version_str = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION); + gl->vendor_str = (const char*)glGetString(GL_VENDOR); + if (!nk_x11_stricmpn(gl->vendor_str, "ATI", 4) || + !nk_x11_stricmpn(gl->vendor_str, "AMD", 4)) + gl->vendor = VENDOR_AMD; + else if (!nk_x11_stricmpn(gl->vendor_str, "NVIDIA", 6)) + gl->vendor = VENDOR_NVIDIA; + else if (!nk_x11_stricmpn(gl->vendor_str, "Intel", 5)) + gl->vendor = VENDOR_INTEL; + else gl->vendor = VENDOR_UNKNOWN; + + /* Extensions */ + gl->glsl_available = (gl->version >= 2.0f); + if (gl->glsl_available) { + /* GLSL core in OpenGL > 2 */ + glCreateShader = GL_EXT(glCreateShader); + glShaderSource = GL_EXT(glShaderSource); + glCompileShader = GL_EXT(glCompileShader); + glGetShaderiv = GL_EXT(glGetShaderiv); + glGetShaderInfoLog = GL_EXT(glGetShaderInfoLog); + glDeleteShader = GL_EXT(glDeleteShader); + glCreateProgram = GL_EXT(glCreateProgram); + glAttachShader = GL_EXT(glAttachShader); + glDetachShader = GL_EXT(glDetachShader); + glLinkProgram = GL_EXT(glLinkProgram); + glUseProgram = GL_EXT(glUseProgram); + glGetProgramiv = GL_EXT(glGetProgramiv); + glGetProgramInfoLog = GL_EXT(glGetProgramInfoLog); + glDeleteProgram = GL_EXT(glDeleteProgram); + glGetUniformLocation = GL_EXT(glGetUniformLocation); + glGetAttribLocation = GL_EXT(glGetAttribLocation); + glUniform1i = GL_EXT(glUniform1i); + glUniform1f = GL_EXT(glUniform1f); + glUniformMatrix3fv = GL_EXT(glUniformMatrix3fv); + glUniformMatrix4fv = GL_EXT(glUniformMatrix4fv); + } + gl->vertex_buffer_obj_available = nk_x11_check_extension(gl, "GL_ARB_vertex_buffer_object"); + if (gl->vertex_buffer_obj_available) { + /* GL_ARB_vertex_buffer_object */ + glGenBuffers = GL_EXT(glGenBuffers); + glBindBuffer = GL_EXT(glBindBuffer); + glBufferData = GL_EXT(glBufferData); + glBufferSubData = GL_EXT(glBufferSubData); + glMapBuffer = GL_EXT(glMapBuffer); + glUnmapBuffer = GL_EXT(glUnmapBuffer); + glDeleteBuffers = GL_EXT(glDeleteBuffers); + } + gl->fragment_program_available = nk_x11_check_extension(gl, "GL_ARB_fragment_program"); + if (gl->fragment_program_available) { + /* GL_ARB_vertex_program / GL_ARB_fragment_program */ + glVertexAttribPointer = GL_EXT(glVertexAttribPointer); + glEnableVertexAttribArray = GL_EXT(glEnableVertexAttribArray); + glDisableVertexAttribArray = GL_EXT(glDisableVertexAttribArray); + } + gl->vertex_array_obj_available = nk_x11_check_extension(gl, "GL_ARB_vertex_array_object"); + if (gl->vertex_array_obj_available) { + /* GL_ARB_vertex_array_object */ + glGenVertexArrays = GL_EXT(glGenVertexArrays); + glBindVertexArray = GL_EXT(glBindVertexArray); + glDeleteVertexArrays = GL_EXT(glDeleteVertexArrays); + } + gl->frame_buffer_object_available = nk_x11_check_extension(gl, "GL_ARB_framebuffer_object"); + if (gl->frame_buffer_object_available) { + /* GL_ARB_framebuffer_object */ + glGenerateMipmap = GL_EXT(glGenerateMipmap); + } + if (!gl->vertex_buffer_obj_available) { + fprintf(stdout, "[GL] Error: GL_ARB_vertex_buffer_object is not available!\n"); + failed = nk_true; + } + if (!gl->fragment_program_available) { + fprintf(stdout, "[GL] Error: GL_ARB_fragment_program is not available!\n"); + failed = nk_true; + } + if (!gl->vertex_array_obj_available) { + fprintf(stdout, "[GL] Error: GL_ARB_vertex_array_object is not available!\n"); + failed = nk_true; + } + if (!gl->frame_buffer_object_available) { + fprintf(stdout, "[GL] Error: GL_ARB_framebuffer_object is not available!\n"); + failed = nk_true; + } + return !failed; +} +#endif + +NK_API int +nk_x11_device_create(void) +{ + GLint status; + static const GLchar *vertex_shader = + NK_SHADER_VERSION + "uniform mat4 ProjMtx;\n" + "in vec2 Position;\n" + "in vec2 TexCoord;\n" + "in vec4 Color;\n" + "out vec2 Frag_UV;\n" + "out vec4 Frag_Color;\n" + "void main() {\n" + " Frag_UV = TexCoord;\n" + " Frag_Color = Color;\n" + " gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n" + "}\n"; + static const GLchar *fragment_shader = + NK_SHADER_VERSION + "precision mediump float;\n" + "uniform sampler2D Texture;\n" + "in vec2 Frag_UV;\n" + "in vec4 Frag_Color;\n" + "out vec4 Out_Color;\n" + "void main(){\n" + " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n" + "}\n"; + + struct nk_x11_device *dev = &x11.ogl; +#ifdef NK_XLIB_LOAD_OPENGL_EXTENSIONS + if (!nk_load_opengl(&dev->info)) return 0; +#endif + nk_buffer_init_default(&dev->cmds); + + dev->prog = glCreateProgram(); + dev->vert_shdr = glCreateShader(GL_VERTEX_SHADER); + dev->frag_shdr = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(dev->vert_shdr, 1, &vertex_shader, 0); + glShaderSource(dev->frag_shdr, 1, &fragment_shader, 0); + glCompileShader(dev->vert_shdr); + glCompileShader(dev->frag_shdr); + glGetShaderiv(dev->vert_shdr, GL_COMPILE_STATUS, &status); + assert(status == GL_TRUE); + glGetShaderiv(dev->frag_shdr, GL_COMPILE_STATUS, &status); + assert(status == GL_TRUE); + glAttachShader(dev->prog, dev->vert_shdr); + glAttachShader(dev->prog, dev->frag_shdr); + glLinkProgram(dev->prog); + glGetProgramiv(dev->prog, GL_LINK_STATUS, &status); + assert(status == GL_TRUE); + + dev->uniform_tex = glGetUniformLocation(dev->prog, "Texture"); + dev->uniform_proj = glGetUniformLocation(dev->prog, "ProjMtx"); + dev->attrib_pos = glGetAttribLocation(dev->prog, "Position"); + dev->attrib_uv = glGetAttribLocation(dev->prog, "TexCoord"); + dev->attrib_col = glGetAttribLocation(dev->prog, "Color"); + + { + /* buffer setup */ + GLsizei vs = sizeof(struct nk_x11_vertex); + size_t vp = offsetof(struct nk_x11_vertex, position); + size_t vt = offsetof(struct nk_x11_vertex, uv); + size_t vc = offsetof(struct nk_x11_vertex, col); + + glGenBuffers(1, &dev->vbo); + glGenBuffers(1, &dev->ebo); + glGenVertexArrays(1, &dev->vao); + + glBindVertexArray(dev->vao); + glBindBuffer(GL_ARRAY_BUFFER, dev->vbo); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo); + + glEnableVertexAttribArray((GLuint)dev->attrib_pos); + glEnableVertexAttribArray((GLuint)dev->attrib_uv); + glEnableVertexAttribArray((GLuint)dev->attrib_col); + + glVertexAttribPointer((GLuint)dev->attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp); + glVertexAttribPointer((GLuint)dev->attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt); + glVertexAttribPointer((GLuint)dev->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc); + } + + glBindTexture(GL_TEXTURE_2D, 0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glBindVertexArray(0); + return 1; +} + +NK_INTERN void +nk_x11_device_upload_atlas(const void *image, int width, int height) +{ + struct nk_x11_device *dev = &x11.ogl; + glGenTextures(1, &dev->font_tex); + glBindTexture(GL_TEXTURE_2D, dev->font_tex); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, image); +} + +NK_API void +nk_x11_device_destroy(void) +{ + struct nk_x11_device *dev = &x11.ogl; + glDetachShader(dev->prog, dev->vert_shdr); + glDetachShader(dev->prog, dev->frag_shdr); + glDeleteShader(dev->vert_shdr); + glDeleteShader(dev->frag_shdr); + glDeleteProgram(dev->prog); + glDeleteTextures(1, &dev->font_tex); + glDeleteBuffers(1, &dev->vbo); + glDeleteBuffers(1, &dev->ebo); + nk_buffer_free(&dev->cmds); +} + +NK_API void +nk_x11_render(enum nk_anti_aliasing AA, int max_vertex_buffer, int max_element_buffer) +{ + int width, height; + XWindowAttributes attr; + struct nk_x11_device *dev = &x11.ogl; + GLfloat ortho[4][4] = { + {2.0f, 0.0f, 0.0f, 0.0f}, + {0.0f,-2.0f, 0.0f, 0.0f}, + {0.0f, 0.0f,-1.0f, 0.0f}, + {-1.0f,1.0f, 0.0f, 1.0f}, + }; + XGetWindowAttributes(x11.dpy, x11.win, &attr); + width = attr.width; + height = attr.height; + + ortho[0][0] /= (GLfloat)width; + ortho[1][1] /= (GLfloat)height; + + /* setup global state */ + glEnable(GL_BLEND); + glBlendEquation(GL_FUNC_ADD); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glDisable(GL_CULL_FACE); + glDisable(GL_DEPTH_TEST); + glEnable(GL_SCISSOR_TEST); + glActiveTexture(GL_TEXTURE0); + + /* setup program */ + glUseProgram(dev->prog); + glUniform1i(dev->uniform_tex, 0); + glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]); + glViewport(0,0,(GLsizei)width,(GLsizei)height); + { + /* convert from command queue into draw list and draw to screen */ + const struct nk_draw_command *cmd; + void *vertices, *elements; + const nk_draw_index *offset = NULL; + struct nk_buffer vbuf, ebuf; + + /* allocate vertex and element buffer */ + glBindVertexArray(dev->vao); + glBindBuffer(GL_ARRAY_BUFFER, dev->vbo); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo); + + glBufferData(GL_ARRAY_BUFFER, max_vertex_buffer, NULL, GL_STREAM_DRAW); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, max_element_buffer, NULL, GL_STREAM_DRAW); + + /* load draw vertices & elements directly into vertex + element buffer */ + vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + elements = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY); + { + /* fill convert configuration */ + struct nk_convert_config config; + static const struct nk_draw_vertex_layout_element vertex_layout[] = { + {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_x11_vertex, position)}, + {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_x11_vertex, uv)}, + {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_x11_vertex, col)}, + {NK_VERTEX_LAYOUT_END} + }; + memset(&config, 0, sizeof(config)); + config.vertex_layout = vertex_layout; + config.vertex_size = sizeof(struct nk_x11_vertex); + config.vertex_alignment = NK_ALIGNOF(struct nk_x11_vertex); + config.tex_null = dev->tex_null; + config.circle_segment_count = 22; + config.curve_segment_count = 22; + config.arc_segment_count = 22; + config.global_alpha = 1.0f; + config.shape_AA = AA; + config.line_AA = AA; + + /* setup buffers to load vertices and elements */ + nk_buffer_init_fixed(&vbuf, vertices, (size_t)max_vertex_buffer); + nk_buffer_init_fixed(&ebuf, elements, (size_t)max_element_buffer); + nk_convert(&x11.ctx, &dev->cmds, &vbuf, &ebuf, &config); + } + glUnmapBuffer(GL_ARRAY_BUFFER); + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + + /* iterate over and execute each draw command */ + nk_draw_foreach(cmd, &x11.ctx, &dev->cmds) + { + if (!cmd->elem_count) continue; +// GLint unit = cmd->texture.id + glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id); + glScissor( + (GLint)(cmd->clip_rect.x), + (GLint)((height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h))), + (GLint)(cmd->clip_rect.w), + (GLint)(cmd->clip_rect.h)); + glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, offset); + offset += cmd->elem_count; + } + nk_clear(&x11.ctx); + nk_buffer_clear(&dev->cmds); + } + + /* default OpenGL state */ + glUseProgram(0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glBindVertexArray(0); + glDisable(GL_BLEND); + glDisable(GL_SCISSOR_TEST); +} + +NK_API void +nk_x11_font_stash_begin(struct nk_font_atlas **atlas) +{ + nk_font_atlas_init_default(&x11.atlas); + nk_font_atlas_begin(&x11.atlas); + *atlas = &x11.atlas; +} + +NK_API void +nk_x11_font_stash_end(void) +{ + const void *image; int w, h; + image = nk_font_atlas_bake(&x11.atlas, &w, &h, NK_FONT_ATLAS_RGBA32); + nk_x11_device_upload_atlas(image, w, h); + nk_font_atlas_end(&x11.atlas, nk_handle_id((int)x11.ogl.font_tex), &x11.ogl.tex_null); + if (x11.atlas.default_font) + nk_style_set_font(&x11.ctx, &x11.atlas.default_font->handle); +} + +NK_API int +nk_x11_handle_event(XEvent *evt) +{ + struct nk_context *ctx = &x11.ctx; + + /* optional grabbing behavior */ + if (ctx->input.mouse.grab) { + XDefineCursor(x11.dpy, x11.win, x11.cursor); + ctx->input.mouse.grab = 0; + } else if (ctx->input.mouse.ungrab) { + XWarpPointer(x11.dpy, None, x11.win, 0, 0, 0, 0, + (int)ctx->input.mouse.pos.x, (int)ctx->input.mouse.pos.y); + XUndefineCursor(x11.dpy, x11.win); + ctx->input.mouse.ungrab = 0; + } + + if (evt->type == KeyPress || evt->type == KeyRelease) + { + /* Key handler */ + int ret, down = (evt->type == KeyPress); + KeySym *code = XGetKeyboardMapping(x11.dpy, (KeyCode)evt->xkey.keycode, 1, &ret); + if (*code == XK_Shift_L || *code == XK_Shift_R) nk_input_key(ctx, NK_KEY_SHIFT, down); + else if (*code == XK_Control_L || *code == XK_Control_R) nk_input_key(ctx, NK_KEY_CTRL, down); + else if (*code == XK_Alt_L || *code == XK_Alt_R) nk_input_key(ctx, NK_KEY_ALT, down); + else if (*code == XK_Delete) nk_input_key(ctx, NK_KEY_DEL, down); + else if (*code == XK_Return) nk_input_key(ctx, NK_KEY_ENTER, down); + else if (*code == XK_Tab) nk_input_key(ctx, NK_KEY_TAB, down); + else if (*code == XK_Left) nk_input_key(ctx, NK_KEY_LEFT, down); + else if (*code == XK_Right) nk_input_key(ctx, NK_KEY_RIGHT, down); + else if (*code == XK_Up) nk_input_key(ctx, NK_KEY_UP, down); + else if (*code == XK_Down) nk_input_key(ctx, NK_KEY_DOWN, down); + else if (*code == XK_BackSpace) nk_input_key(ctx, NK_KEY_BACKSPACE, down); + else if (*code == XK_Escape) nk_input_key(ctx, NK_KEY_ESCAPE, down); + // else if (*code == XK_space && !down) nk_input_char(ctx, ' '); + else if (*code == XK_Page_Up) nk_input_key(ctx, NK_KEY_SCROLL_UP, down); + else if (*code == XK_Page_Down) nk_input_key(ctx, NK_KEY_SCROLL_DOWN, down); + else if (*code == XK_Home) { + nk_input_key(ctx, NK_KEY_TEXT_START, down); + nk_input_key(ctx, NK_KEY_SCROLL_START, down); + } else if (*code == XK_End) { + nk_input_key(ctx, NK_KEY_TEXT_END, down); + nk_input_key(ctx, NK_KEY_SCROLL_END, down); + } else { + if (*code == 'c' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_COPY, down); + else if (*code == 'v' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_PASTE, down); + else if (*code == 'x' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_CUT, down); + else if (*code == 'z' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_UNDO, down); + else if (*code == 'r' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_REDO, down); + else if (*code == XK_Left && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, down); + else if (*code == XK_Right && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, down); + else if (*code == 'b' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_LINE_START, down); + else if (*code == 'e' && (evt->xkey.state & ControlMask)) + nk_input_key(ctx, NK_KEY_TEXT_LINE_END, down); + else { + if (*code == 'i') + nk_input_key(ctx, NK_KEY_TEXT_INSERT_MODE, down); + else if (*code == 'r') + nk_input_key(ctx, NK_KEY_TEXT_REPLACE_MODE, down); + + char buf[32]; + KeySym keysym = 0; + if (XLookupString((XKeyEvent*)evt, buf, 32, &keysym, NULL) != NoSymbol) { + if (down) + nk_input_glyph(ctx, buf); + } else { +// printf("Unknown key %lx, pass on RAW %d\n", *code, +// ctx->input.keyboard.text_len); + uint32_t *d = (uint32_t *) ctx->input.keyboard.text; + d[ctx->input.keyboard.text_len / 4] = + (*code << 16) | !!down; + ctx->input.keyboard.text_len += 4; + } + } + } + XFree(code); + return 1; + } else if (evt->type == ButtonPress || evt->type == ButtonRelease) { + /* Button handler */ + int down = (evt->type == ButtonPress); + const int x = evt->xbutton.x, y = evt->xbutton.y; + if (evt->xbutton.button == Button1) { + if (down) { /* Double-Click Button handler */ + long dt = nk_timestamp() - x11.last_button_click; + if (dt > NK_X11_DOUBLE_CLICK_LO && dt < NK_X11_DOUBLE_CLICK_HI) + nk_input_button(ctx, NK_BUTTON_DOUBLE, x, y, nk_true); + x11.last_button_click = nk_timestamp(); + } else nk_input_button(ctx, NK_BUTTON_DOUBLE, x, y, nk_false); + nk_input_button(ctx, NK_BUTTON_LEFT, x, y, down); + } else if (evt->xbutton.button == Button2) + nk_input_button(ctx, NK_BUTTON_MIDDLE, x, y, down); + else if (evt->xbutton.button == Button3) + nk_input_button(ctx, NK_BUTTON_RIGHT, x, y, down); + else if (evt->xbutton.button == Button4) + nk_input_scroll(ctx, nk_vec2(0,1.0f)); + else if (evt->xbutton.button == Button5) + nk_input_scroll(ctx, nk_vec2(0,-1.0f)); + else return 0; + return 1; + } else if (evt->type == MotionNotify) { + /* Mouse motion handler */ + const int x = evt->xmotion.x, y = evt->xmotion.y; + nk_input_motion(ctx, x, y); + if (ctx->input.mouse.grabbed) { + ctx->input.mouse.pos.x = ctx->input.mouse.prev.x; + ctx->input.mouse.pos.y = ctx->input.mouse.prev.y; + XWarpPointer(x11.dpy, None, x11.win, 0, 0, 0, 0, (int)ctx->input.mouse.pos.x, (int)ctx->input.mouse.pos.y); + } + return 1; + } else if (evt->type == KeymapNotify) { + XRefreshKeyboardMapping(&evt->xmapping); + return 1; + } + return 0; +} + +NK_API struct nk_context* +nk_x11_init(Display *dpy, Window win) +{ + if (!setlocale(LC_ALL,"")) return 0; + if (!XSupportsLocale()) return 0; + if (!XSetLocaleModifiers("@im=none")) return 0; + if (!nk_x11_device_create()) return 0; + + x11.dpy = dpy; + x11.win = win; + + /* create invisible cursor */ + {static XColor dummy; char data[1] = {0}; + Pixmap blank = XCreateBitmapFromData(dpy, win, data, 1, 1); + if (blank == None) return 0; + x11.cursor = XCreatePixmapCursor(dpy, blank, blank, &dummy, &dummy, 0, 0); + XFreePixmap(dpy, blank);} + + nk_init_default(&x11.ctx, 0); + return &x11.ctx; +} + +NK_API void +nk_x11_shutdown(void) +{ + nk_font_atlas_clear(&x11.atlas); + nk_free(&x11.ctx); + nk_x11_device_destroy(); + XFreeCursor(x11.dpy, x11.cursor); + memset(&x11, 0, sizeof(x11)); +} + +#endif diff --git a/src/drivers/mii_disk2.c b/src/drivers/mii_disk2.c new file mode 100644 index 0000000..8cf522b --- /dev/null +++ b/src/drivers/mii_disk2.c @@ -0,0 +1,379 @@ +/* + * mii_disk2.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +// Shamelesly lifted from periph/disk2.c +// +// Copyright (c) 2023 Micah John Cowan. +// This code is licensed under the MIT license. +// See the accompanying LICENSE file for details. + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" +#include "mii_disk2.h" +#include "mii_rom_disk2.h" +#include "mii_disk_format.h" + +//#define DISK_DEBUG +#ifdef DISK_DEBUG +# define D2DBG(...) do { \ + if (c->pr_count == 1) \ + fprintf(stderr, __VA_ARGS__); \ + } while(0) +#else +# define D2DBG(...) +#endif + +typedef struct mii_card_disk2_t { + uint32_t timer; + bool motor_on; + bool drive_two; + bool write_mode; + union { + struct { + DiskFormatDesc disk1; + DiskFormatDesc disk2; + }; + DiskFormatDesc disk[2]; + }; + uint8_t data_register; // only used for write + bool steppers[4]; + int cog1; + int cog2; +// int pr_count; // debug print +} mii_card_disk2_t; + +//static const size_t dsk_disksz = 143360; + +int disk2_debug = 0; + +static DiskFormatDesc * +active_disk_obj( + mii_card_disk2_t *c) +{ + return c->drive_two ? &c->disk2 : &c->disk1; +} + +#if 0 +bool +drive_spinning( + mii_card_disk2_t *c) +{ + return c->motor_on; +} + +int +active_disk( + mii_card_disk2_t *c) +{ + return c->drive_two ? 2 : 1; +} +int +eject_disk( + mii_card_disk2_t *c, + int drive) +{ + if (c->motor_on && active_disk(c) == drive) { + return -1; + } + init(c); // to make sure + + if (drive == 1) { + c->disk1.eject(&c->disk1); + c->disk1 = disk_format_load(NULL); + } else if (drive == 2) { + c->disk2.eject(&c->disk2); + c->disk2 = disk_format_load(NULL); + } + return 0; +} + +int +insert_disk( + mii_card_disk2_t *c, + int drive, + const char *path) +{ + int err = eject_disk(c, drive); + if (err != 0) return err; + + // Make sure we're inserted to slot 6 + // XXX should check for error/distinguish if we're already in that slot + (void) periph_slot_reg(6, &disk2card); + + if (err) { + return -1; // XXX should be a distinguishable err code + } + if (drive == 1) { + c->disk1 = disk_format_load(path); + } else if (drive == 2) { + c->disk2 = disk_format_load(path); + } + + return 0; +} +#endif + +// NOTE: cog "left" and "right" refers only to the number line, +// and not the physical cog or track head movement. +static bool +cogleft( + mii_card_disk2_t *c, + int *cog) +{ + int cl = ((*cog) + 3) % 4; // position to the "left" of cog + return (!c->steppers[(*cog)] && c->steppers[cl]); +} + +// NOTE: cog "left" and "right" refers only to the number line, +// and not the physical cog or track head movement. +static bool +cogright( + mii_card_disk2_t *c, + int *cog) +{ + int cr = ((*cog) + 1) % 4; // position to the "right" of cog + return (!c->steppers[(*cog)] && c->steppers[cr]); +} + +static int * +active_cog( + mii_card_disk2_t *c) +{ + return c->drive_two? &c->cog2 : &c->cog1; +} + +static void +adjust_track( + mii_card_disk2_t *c) +{ + DiskFormatDesc *disk = active_disk_obj(c); + int *cog = active_cog(c); + D2DBG("halftrack: "); + if (cogleft(c, cog)) { + *cog = ((*cog) + 3) % 4; + if (disk->halftrack > 0) --disk->halftrack; + D2DBG("dec to %d", disk->halftrack); + } else if (cogright(c, cog)) { + *cog = ((*cog) + 1) % 4; + if (disk->halftrack < 69) ++disk->halftrack; + D2DBG("inc to %d", disk->halftrack); + } else { + D2DBG("no change (%d)", disk->halftrack); + } +} + +static void +stepper_motor( + mii_card_disk2_t *c, + uint8_t psw) +{ + uint8_t phase = psw >> 1; + bool onoff = (psw & 1) != 0; + + D2DBG("phase %d %s ", (int)phase, onoff? "on, " : "off,"); + c->steppers[phase] = onoff; + adjust_track(c); +} + +static inline uint8_t encode4x4(mii_card_disk2_t *c, uint8_t orig) +{ + return (orig | 0xAA); +} + +static void turn_off_motor(mii_card_disk2_t *c) +{ + c->motor_on = false; + DiskFormatDesc *disk = active_disk_obj(c); + disk->spin(disk, false); +// event_fire_disk_active(0); +} + +static int +_mii_disk2_init( + mii_t * mii, + struct mii_slot_t *slot ) +{ + mii_card_disk2_t *c = calloc(1, sizeof(*c)); + + slot->drv_priv = c; + c->disk1 = disk_format_load(NULL); + c->disk2 = disk_format_load(NULL); + printf("%s loading in slot %d\n", __func__, slot->id + 1); + uint16_t addr = 0xc100 + (slot->id * 0x100); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr, mii_rom_disk2, 256); + + return 0; +} + +static void +_mii_disk2_run( + mii_t * mii, + struct mii_slot_t *slot) +{ + mii_card_disk2_t *c = slot->drv_priv; + if (c->timer && c->timer <= mii->video.frame_count) { + printf("%s turning off motor\n", __func__); + c->timer = 0; + turn_off_motor(c); + } +} + +static uint8_t +_mii_disk2_access( + mii_t * mii, struct mii_slot_t *slot, + uint16_t addr, uint8_t byte, bool write) +{ + mii_card_disk2_t *c = slot->drv_priv; + uint8_t ret = 0; + + int psw = addr & 0x0F; + + if (c->timer) + c->timer = mii->video.frame_count + 60; + uint8_t last = -1; + if (disk2_debug && last != psw + (write? 0x10 : 0)) + printf("disk sw $%02X, PC = $%04X\n", psw, mii->cpu.PC); + last = psw + (write? 0x10 : 0); + if (write) + c->data_register = byte; // ANY write sets data register + if (psw < 8) { + stepper_motor(c, psw); + } else switch (psw) { + case 0x08: + if (c->motor_on) { + c->timer = mii->video.frame_count + 60; + //frame_timer(60, turn_off_motor); + } + break; + case 0x09: { +// frame_timer_cancel(turn_off_motor); + c->timer = 0; + c->motor_on = true; + DiskFormatDesc *disk = active_disk_obj(c); + disk->spin(disk, true); + if (disk2_debug) + printf("%s turning on motor %d\n", __func__, c->drive_two); + // event_fire_disk_active(drive_two? 2 : 1); + } break; + case 0x0A: + if (c->motor_on && c->drive_two) { + c->disk2.spin(&c->disk2, false); + c->disk1.spin(&c->disk1, true); + } + c->drive_two = false; + if (c->motor_on) { + // event_fire_disk_active(1); + } + break; + case 0x0B: + if (c->motor_on && !c->drive_two) { + c->disk1.spin(&c->disk1, false); + c->disk2.spin(&c->disk2, true); + } + c->drive_two = true; + if (c->motor_on) { + // event_fire_disk_active(2); + } + break; + case 0x0C: { + DiskFormatDesc *disk = active_disk_obj(c); + if (!c->motor_on) { + // do nothing + } else if (c->write_mode) { + // XXX ignores timing + disk->write_byte(disk, c->data_register); + c->data_register = 0; // "shifted out". + } else { + // XXX any even-numbered switch can be used + // to read a byte. But for now we do so only + // through the sanctioned switch for that purpose. + ret = c->data_register = disk->read_byte(disk); + // printf("read byte %02X\n", ret); + } + } break; + case 0x0D: +#if 0 + if (!motor_on || drive_two) { + // do nothing + } else if (write_mode) { + data_register = (val == -1? 0: val); + } else { + // XXX should return whether disk is write-protected... + } +#endif + break; + case 0x0E: + c->write_mode = false; + if (disk2_debug) + printf("%s write mode off\n", __func__); + break; + case 0x0F: + c->write_mode = true; + if (disk2_debug) + printf("%s write mode on\n", __func__); + break; + default: + ; + } + + D2DBG("\n"); + + return ret; +} + +static int +_mii_disk2_command( + mii_t * mii, + struct mii_slot_t *slot, + uint8_t cmd, + void * param) +{ + mii_card_disk2_t *c = slot->drv_priv; + switch (cmd) { + case MII_SLOT_DRIVE_COUNT: + if (param) + *(int *)param = 2; + break; + case MII_SLOT_DRIVE_LOAD ... MII_SLOT_DRIVE_LOAD + 2 - 1: + if (param) { + int drive = cmd - MII_SLOT_DRIVE_LOAD; + const char *filename = param; + if (c->disk[drive].privdat) { + c->disk[drive].eject(&c->disk[drive]); + } + printf("%s: drive %d loading %s\n", __func__, drive, + filename); + c->disk[drive] = disk_format_load(filename); + return 0; + } + break; + } + return 0; +} + +static mii_slot_drv_t _driver = { + .name = "disk2", + .desc = "Apple Disk ][", + .init = _mii_disk2_init, + .access = _mii_disk2_access, + .run = _mii_disk2_run, + .command = _mii_disk2_command, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/drivers/mii_disk2.h b/src/drivers/mii_disk2.h new file mode 100644 index 0000000..a90d993 --- /dev/null +++ b/src/drivers/mii_disk2.h @@ -0,0 +1,9 @@ +/* + * mii_disk2.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once diff --git a/src/drivers/mii_epromcard.c b/src/drivers/mii_epromcard.c new file mode 100644 index 0000000..855d6c5 --- /dev/null +++ b/src/drivers/mii_epromcard.c @@ -0,0 +1,89 @@ +/* + * mii_epromcard.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + * + * This is a driver for these eprom/flash cards from + * Terence J. Boldt and the likes + */ +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" + +typedef struct mii_card_ee_t { + uint8_t * file; + uint16_t latch; +} mii_card_ee_t; + +int mmapfile(const char *fname, uint8_t **buf, size_t *sz, int flags); + +static int +_mii_ee_init( + mii_t * mii, + struct mii_slot_t *slot ) +{ + uint8_t * file; + size_t sz; + const char *fname = "disks/Apple IIe Diagnostic 2.1.po"; + //const char *fname = "disks/GamesWithFirmware.po"; + + if (mmapfile(fname, &file, &sz, O_RDONLY) != 0) { + printf("Failed to load %s\n", fname); + return -1; + } + mii_card_ee_t *c = calloc(1, sizeof(*c)); + + slot->drv_priv = c; + c->file = file; + printf("%s loading in slot %d\n", __func__, slot->id); + uint16_t addr = 0xc100 + (slot->id * 0x100); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr, c->file + 0x300, 256); + + return 0; +} + +static uint8_t +_mii_ee_access( + mii_t * mii, struct mii_slot_t *slot, + uint16_t addr, uint8_t byte, bool write) +{ + mii_card_ee_t *c = slot->drv_priv; + +// printf("%s PC:%04x addr %04x %02x wr:%d\n", __func__, +// mii->cpu.PC, addr, byte, write); + int psw = addr & 0x0F; + if (write) { + switch (psw) { + case 0: + c->latch = (c->latch & 0xff00) | byte; + break; + case 1: + c->latch = (c->latch & 0x00ff) | (byte << 8); + break; + } + } else { + return c->file[(c->latch << 4) + psw]; + } + return 0; +} + +static mii_slot_drv_t _driver = { + .name = "eecard", + .desc = "EEPROM 1MB card", + .init = _mii_ee_init, + .access = _mii_ee_access, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/drivers/mii_mouse.c b/src/drivers/mii_mouse.c new file mode 100644 index 0000000..3fe518d --- /dev/null +++ b/src/drivers/mii_mouse.c @@ -0,0 +1,187 @@ + + +#include "mii.h" + +// https://github.com/ivanizag/izapple2/blob/master/cardMouse.go +// https://hackaday.io/project/19925-aiie-an-embedded-apple-e-emulator/log/188017-entry-23-here-mousie-mousie-mousie +// https://github.com/ct6502/apple2ts/blob/main/src/emulator/mouse.ts + +#include +#include +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" + + +enum { + CLAMP_MIN_LO = 0x478, + CLAMP_MIN_HI = 0x578, + CLAMP_MAX_LO = 0x4F8, + CLAMP_MAX_HI = 0x5F8, + + // RAM Locations + // (Add $Cn where n is slot to these) + MOUSE_X_LO = 0x03B8, + MOUSE_X_HI = 0x04B8, + MOUSE_Y_LO = 0x0438, + MOUSE_Y_HI = 0x0538, + MOUSE_STATUS = 0x06B8, + MOUSE_MODE = 0x0738, +}; + +enum { + mouseEnabled = 1, + mouseIntMoveEnabled = 2, + mouseIntButtonEnabled = 4, + mouseIntVBlankEnabled = 8, +}; + +typedef struct mii_card_mouse_t { + struct mii_slot_t * slot; + uint8_t slot_offset; + uint8_t mode; // cached mode byte + struct { + uint16_t x, y; + bool button; + } last; +} mii_card_mouse_t; + +static int +_mii_mouse_init( + mii_t * mii, + struct mii_slot_t *slot ) +{ + mii_card_mouse_t *c = calloc(1, sizeof(*c)); + c->slot = slot; + slot->drv_priv = c; + + printf("%s loading in slot %d\n", __func__, slot->id + 1); + + c->slot_offset = slot->id + 1 + 0xc0; + uint8_t data[256] = {}; + + // Identification as a mouse card + // From Technical Note Misc #8, "Pascal 1.1 Firmware Protocol ID Bytes": + data[0x05] = 0x38; + data[0x07] = 0x18; + data[0x0b] = 0x01; + data[0x0c] = 0x20; + // From "AppleMouse // User's Manual", Appendix B: + //data[0x0c] = 0x20 + data[0xfb] = 0xd6; + + // Set 8 entrypoints to sofstwitches 2 to 1f + for (int i = 0; i < 14; i++) { + uint8_t base = 0x60 + 0x05 * i; + data[0x12+i] = base; + data[base+0] = 0x8D; // STA $C0x2 + data[base+1] = 0x82 + i + ((slot->id + 1) << 4); + data[base+2] = 0xC0; + data[base+3] = 0x18; // CLC ;no error + data[base+4] = 0x60; // RTS + } + + uint16_t addr = 0xc100 + (slot->id * 0x100); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr, data, 256); + + return 0; +} + +static uint8_t +_mii_mouse_access( + mii_t * mii, + struct mii_slot_t *slot, + uint16_t addr, + uint8_t byte, + bool write) +{ + mii_card_mouse_t *c = slot->drv_priv; + + int psw = addr & 0x0F; + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + switch (psw) { + case 2: { + if (write) { + byte &= 0xf; + mii_bank_poke(main, MOUSE_MODE + c->slot_offset, byte); + printf("%s: mouse mode %02x\n", __func__, byte); + mii->mouse.enabled = byte & mouseEnabled; + printf("Mouse %s\n", mii->mouse.enabled ? "enabled" : "disabled"); + printf(" Interupt: %s\n", byte & mouseIntMoveEnabled ? "enabled" : "disabled"); + printf(" Button: %s\n", byte & mouseIntButtonEnabled ? "enabled" : "disabled"); + printf(" VBlank: %s\n", byte & mouseIntVBlankEnabled ? "enabled" : "disabled"); + c->mode = byte; + mii->video.vbl_irq = !!(byte & mouseIntVBlankEnabled); + } + } break; + case 4: {// read mouse + if (!mii->mouse.enabled) + break; + uint8_t status = 0; + if (mii->mouse.button) + status |= 1 << 7; + if (c->last.button) { + status |= 1 << 6; + } + if ((mii->mouse.x != c->last.x) || (mii->mouse.y != c->last.y)) { + status |= 1 << 5; + } + mii_bank_poke(main, MOUSE_X_HI + c->slot_offset, mii->mouse.x >> 8); + mii_bank_poke(main, MOUSE_Y_HI + c->slot_offset, mii->mouse.y >> 8); + mii_bank_poke(main, MOUSE_X_LO + c->slot_offset, mii->mouse.x); + mii_bank_poke(main, MOUSE_Y_LO + c->slot_offset, mii->mouse.y); + mii_bank_poke(main, MOUSE_STATUS + c->slot_offset, status); + // mii_bank_poke(main, MOUSE_MODE + c->slot_offset, 0xf); // already in place + c->last.x = mii->mouse.x; + c->last.y = mii->mouse.y; + c->last.button = mii->mouse.button; + } break; + case 5: // clear mouse + break; + case 7: // set mouse + if (byte == 0) { + mii->mouse.min_x = mii_bank_peek(main, CLAMP_MIN_LO) | + (mii_bank_peek(main, CLAMP_MIN_HI) << 8); + mii->mouse.max_x = mii_bank_peek(main, CLAMP_MAX_LO) | + (mii_bank_peek(main, CLAMP_MAX_HI) << 8); + } else if (byte == 1) { + mii->mouse.min_y = mii_bank_peek(main, CLAMP_MIN_LO) | + (mii_bank_peek(main, CLAMP_MIN_HI) << 8); + mii->mouse.max_y = mii_bank_peek(main, CLAMP_MAX_LO) | + (mii_bank_peek(main, CLAMP_MAX_HI) << 8); + } + printf("Mouse clamp to %d,%d - %d,%d\n", + mii->mouse.min_x, mii->mouse.min_y, + mii->mouse.max_x, mii->mouse.max_y); + break; + case 8: // home mouse + mii->mouse.x = mii->mouse.min_x; + mii->mouse.y = mii->mouse.min_y; + break; + case 0xc: // init mouse + mii->mouse.min_x = mii->mouse.min_y = 0; + mii->mouse.max_x = mii->mouse.max_y = 1023; + mii->mouse.enabled = 0; + mii_bank_poke(main, MOUSE_MODE + c->slot_offset, 0x0); + break; + default: + printf("%s PC:%04x addr %04x %02x wr:%d\n", __func__, + mii->cpu.PC, addr, byte, write); + break; + } + return 0; +} + +static mii_slot_drv_t _driver = { + .name = "mouse", + .desc = "Mouse card", + .init = _mii_mouse_init, + .access = _mii_mouse_access, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/drivers/mii_mouse.h b/src/drivers/mii_mouse.h new file mode 100644 index 0000000..b3bd521 --- /dev/null +++ b/src/drivers/mii_mouse.h @@ -0,0 +1,21 @@ +/* + * mii_mouse.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include +#include + + // mins/max are set by the card, x,y,button are set by the UI +typedef struct mii_mouse_t { + bool enabled; // read only, set by driver + uint16_t min_x, max_x, + min_y, max_y; // set by driver when enabled + uint16_t x, y; + bool button; +} mii_mouse_t; diff --git a/src/drivers/mii_noslotclock.c b/src/drivers/mii_noslotclock.c new file mode 100644 index 0000000..64e0ee6 --- /dev/null +++ b/src/drivers/mii_noslotclock.c @@ -0,0 +1,177 @@ +/* + * mii_noslotclock.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + * + */ +// http://ctrl.pomme.reset.free.fr/index.php/hardware/no-slot-clock-ds1216e/ +// Disassembly: +// https://gist.github.com/mgcaret/ae2860c754fd029d2640107c4fe0bffd + + +#include +#include +#include +#include +#include +#include +#include +#include "mii.h" +#include "mii_bank.h" +#include "minipt.h" + +const uint64_t nsc_pattern = 0x5CA33AC55CA33AC5ULL; + +typedef struct mii_nsc_t { + mii_t * mii; + uint64_t pattern; + void * state; // protothread state + int bitcount; + int mode; // read or write; +} mii_nsc_t; + +static void +_mii_nsc_maketime( + mii_nsc_t *nsc) +{ + uint64_t ret = 0; + + time_t now = time(NULL); + struct tm t; + localtime_r(&now, &t); + + int year = t.tm_year % 100; + ret = year / 10; + ret <<= 4; + ret += year % 10; + ret <<= 4; + + int month = t.tm_mon + 1; + ret += month / 10; + ret <<= 4; + ret += month % 10; + ret <<= 4; + + int day = t.tm_mday; + ret += day / 10; + ret <<= 4; + ret += day % 10; + ret <<= 4; + + // Bits 4 and 5 of the day ret are used to control the RST and oscillator + // functions. These bits are shipped from the factory set to logic 1. + ret += 0x0; //0x3, but zero on read. + ret <<= 4; + ret += t.tm_wday + 1; // uint64(now.Weekday()) + 1 + ret <<= 4; + + int hour = t.tm_hour; + ret += 0x0; // 0x8 for 24 hour mode, but zero on read. + ret += hour / 10; + ret <<= 4; + ret += hour % 10; + ret <<= 4; + + int minute = t.tm_min; + ret += minute / 10; + ret <<= 4; + ret += minute % 10; + ret <<= 4; + + int second = t.tm_sec; + ret += second / 10; + ret <<= 4; + ret += second % 10; + ret <<= 4; + + int centisecond = 0; + ret += centisecond / 10; + ret <<= 4; + ret += centisecond % 10; + nsc->pattern = ret; +} + +/* + * this is a protothread, so remember no locals that will survive a yield() + */ +static bool +_mii_nsc_access( + struct mii_bank_t *bank, + void *param, + uint16_t addr, + uint8_t * byte, + bool write) +{ + mii_nsc_t * nsc = param; +// printf("%s PC:%04x access %s addr %04x byte %02x write %d\n", +// __func__, nsc->mii->cpu.PC, +// bank->name, addr, *byte, write); + int rd = (addr & 0x4); + int bit = addr & 1; + bool res = false; + pt_start(nsc->state); + do { + if (rd) { + nsc->pattern = 0; + } else { + nsc->pattern = (nsc->pattern >> 1) | ((uint64_t)bit << 63); + int match = nsc->pattern == nsc_pattern; + if (match) { + // printf("pattern %016lx %s\n", nsc->pattern, match ? "match" : ""); + break; + } + } + pt_yield(nsc->state); + } while (1); + nsc->bitcount = 0; + pt_yield(nsc->state); + nsc->mode = rd; +// printf("%s in %s mode\n", __func__, rd ? "read" : "write"); + if (nsc->mode) { + _mii_nsc_maketime(nsc); + // printf("time %016lx\n", nsc->pattern); + } + do { + if (nsc->mode) { + *byte = (nsc->pattern >> nsc->bitcount) & 1; + } else { + nsc->pattern |= ((uint64_t)bit << nsc->bitcount); + } + res = true; // don't call ROM handler + pt_yield(nsc->state); + nsc->bitcount++; + } while (nsc->bitcount < 64 && nsc->mode == rd); +// printf("%s done\n", __func__); + pt_end(nsc->state); + return res; +} + +static int +_mii_nsc_probe( + mii_t *mii, + uint32_t flags) +{ + printf("%s %s\n", __func__, flags & MII_INIT_NSC ? "enabled" : "disabled"); + if (!(flags & MII_INIT_NSC)) + return 0; + mii_nsc_t * nsc = calloc(1, sizeof(*nsc)); + nsc->mii = mii; + // This worked fine with NS.CLOCK.SYSTEM but... +// mii_bank_install_access_cb(&mii->bank[MII_BANK_CARD_ROM], +// _mii_nsc_access, nsc, 0xc1, 0); + /* ... A2Desktop requires the NSC to be on the main rom, the source + * claims it probe the slots, but in fact, it doesnt */ + mii_bank_install_access_cb(&mii->bank[MII_BANK_ROM], + _mii_nsc_access, nsc, 0xc3, 0); + return 1; +} + +static mii_slot_drv_t _driver = { + .name = "nsc", + .desc = "No Slot Clock", + .enable_flag = MII_INIT_NSC, + .probe = _mii_nsc_probe, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/drivers/mii_smartport.c b/src/drivers/mii_smartport.c new file mode 100644 index 0000000..2c45081 --- /dev/null +++ b/src/drivers/mii_smartport.c @@ -0,0 +1,342 @@ +/* + * mii_smartport.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + * + * This is shamelessly inspired from: + * https:github.com/ct6502/apple2ts/blob/main/src/emulator/harddrivedata.ts + * http://www.1000bit.it/support/manuali/apple/technotes/smpt/tn.smpt.1.html + */ +#define _GNU_SOURCE // for asprintf +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" +#include "mii_dd.h" +#include "mii_slot.h" + +#define INCBIN_STYLE INCBIN_STYLE_SNAKE +#define INCBIN_PREFIX mii_ +#include "incbin.h" + +INCBIN(smartport_rom, "test/asm/mii_smartport_driver.bin"); + +extern const unsigned char mii_smartport_rom_data[]; + +#define MII_SM_DRIVE_COUNT 2 + +typedef struct mii_card_sm_t { + struct mii_card_sm_t *next; + mii_dd_t drive[MII_SM_DRIVE_COUNT]; + struct mii_slot_t *slot; + uint8_t * file; +} mii_card_sm_t; + +static void +_mii_hd_callback( + mii_t *mii, + uint8_t trap) +{ + int sid = ((mii->cpu.PC >> 8) & 0xf) - 1; + mii_card_sm_t *c = mii->slot[sid].drv_priv; + + uint8_t command = mii_read_one(mii, 0x42); + uint8_t unit = mii_read_one(mii, 0x43); + uint16_t buffer = mii_read_word(mii, 0x44); + uint16_t blk = mii_read_word(mii, 0x46); + + unit >>= 7; // last bit is the one we want, drive 0/1 + switch (command) { + case 0: { // get status + if (!c->drive[unit].file) { + mii->cpu.X = mii->cpu.Y = 0; + mii->cpu.P.C = 1; + } else { + int nblocks = (c->drive[unit].file->size + 511) / 512; + mii->cpu.X = nblocks & 0xff; + mii->cpu.Y = nblocks >> 8; + mii->cpu.P.C = 0; + } + } break; + case 1: {// read block + if (!c->drive[unit].file) { + mii->cpu.P.C = 1; + break; + } + if (blk >= c->drive[unit].file->size / 512) { + mii->cpu.P.C = 1; + break; + } + mii_bank_t * bank = &mii->bank[mii->mem[buffer >> 8].write]; + mii->cpu.P.C = mii_dd_read( + &c->drive[unit], bank, buffer, blk, 1) != 0; + } break; + case 2: {// write block + if (!c->drive[unit].file) { + mii->cpu.P.C = 1; + break; + } + if (blk >= c->drive[unit].file->size / 512) { + mii->cpu.P.C = 1; + break; + } + mii_bank_t * bank = &mii->bank[mii->mem[buffer >> 8].read]; + mii->cpu.P.C = mii_dd_write( + &c->drive[unit], bank, buffer, blk, 1) != 0; + } break; + default: { + printf("%s cmd %02x unit %02x buffer %04x blk %04x\n", __func__, + command, unit, buffer, blk); + printf("*** %s: unhandled command %02x\n", __func__, command); + mii->cpu.P.C = 1; + } + } +} + +static void +_mii_sm_callback( + mii_t *mii, + uint8_t trap) +{ + printf("%s\n", __func__); + int sid = ((mii->cpu.PC >> 8) & 0xf) - 1; + mii_card_sm_t *c = mii->slot[sid].drv_priv; + + uint16_t sp = 0x100 + mii->cpu.S + 1; + uint16_t call_addr = mii_read_word(mii, sp); + uint8_t spCommand = mii_read_one(mii, call_addr + 1); + uint16_t spParams = mii_read_word(mii, call_addr + 2); + call_addr += 3; + mii_write_word(mii, sp, call_addr); + + uint8_t spPCount = mii_read_one(mii, spParams + 0); + uint8_t spUnit = mii_read_one(mii, spParams + 1); + uint16_t spBuffer = mii_read_word(mii, spParams + 2); + + printf("%s cmd %02x params %04x pcount %d unit %02x buffer %04x\n", __func__, + spCommand, spParams, spPCount, spUnit, spBuffer); + switch (spCommand) { + case 0: { // get status + if (spPCount != 3) { + mii->cpu.P.C = 1; + break; + } + uint8_t status = mii_read_one(mii, spParams + 4); + printf("%s: unit %d status %02x \n", __func__, spUnit, status); + uint8_t st = 0x80 | 0x40 | 0x20; + uint32_t bsize = 0; + if (spUnit) spUnit--; + if (spUnit < MII_SM_DRIVE_COUNT && c->drive[spUnit].file) { + st |= 0x10; + bsize = (c->drive[spUnit].file->size + 511) / 512; + } + if (status == 0) { + mii->cpu.P.C = 0; + /* Apple IIc reference says this ought to be a status byte, + * but practice and A2Desktop says it ought to be a drive + * count, so here goes... */ +// mii_write_one(mii, spBuffer++, st); + mii_write_one(mii, spBuffer++, MII_SM_DRIVE_COUNT); + mii_write_one(mii, spBuffer++, bsize); + mii_write_one(mii, spBuffer++, bsize >> 8); + mii_write_one(mii, spBuffer++, bsize >> 16); + } else if (status == 3 && spUnit < MII_SM_DRIVE_COUNT) { + mii->cpu.P.C = 0; + mii_write_one(mii, spBuffer++, st); + mii_write_one(mii, spBuffer++, bsize); + mii_write_one(mii, spBuffer++, bsize >> 8); + mii_write_one(mii, spBuffer++, bsize >> 16); + char dname[17] = "\x8MII HD 0 "; + dname[8] = '0' + spUnit; + for (int i = 0; i < 17; i++) + mii_write_one(mii, spBuffer++, dname[i]); + mii_write_one(mii, spBuffer++, 0x02); // Profile + mii_write_one(mii, spBuffer++, 0x00); // Profile + mii_write_one(mii, spBuffer++, 0x01); // Version + mii_write_one(mii, spBuffer++, 0x13); + } else { + printf("%s: unit %d bad status %d\n", + __func__, spUnit, status); + mii->cpu.P.C = 1; + } + } break; + case 1: { // read + if (spPCount != 3) { + printf("%s: unit %d bad pcount %d\n", + __func__, spUnit, spPCount); + mii->cpu.P.C = 1; + break; + } + if (spUnit >= MII_SM_DRIVE_COUNT) { + printf("%s: unit %d out of range\n", + __func__, spUnit); + mii->cpu.P.C = 1; + break; + } + uint32_t blk = mii_read_word(mii, spParams + 3) | + (mii_read_one(mii, spParams + 4) << 16) | + (mii_read_one(mii, spParams + 5) << 24); + printf("%s read block %x\n", __func__, blk); + if (!c->drive[spUnit].file) { + mii->cpu.P.C = 1; + break; + } + if (blk >= c->drive[spUnit].file->size / 512) { + printf("%s: block %d out of range\n", + __func__, blk); + mii->cpu.P.C = 1; + break; + } + mii_bank_t * bank = &mii->bank[mii->mem[spBuffer >> 8].write]; + mii->cpu.P.C = mii_dd_read( + &c->drive[spUnit], bank, spBuffer, blk, 1) != 0; + // mii->cpu.P.C = 0; + } break; + case 2: { // write + if (spPCount != 3) { + printf("%s: unit %d bad pcount %d\n", + __func__, spUnit, spPCount); + mii->cpu.P.C = 1; + break; + } + if (spUnit >= MII_SM_DRIVE_COUNT) { + printf("%s: unit %d out of range\n", + __func__, spUnit); + mii->cpu.P.C = 1; + break; + } + uint32_t blk = mii_read_word(mii, spParams + 3) | + (mii_read_one(mii, spParams + 4) << 16) | + (mii_read_one(mii, spParams + 5) << 24); + printf("%s write block %x\n", __func__, blk); + if (!c->drive[spUnit].file) { + mii->cpu.P.C = 1; + break; + } + if (blk >= c->drive[spUnit].file->size / 512) { + printf("%s: block %d out of range\n", + __func__, blk); + mii->cpu.P.C = 1; + break; + } + mii_bank_t * bank = &mii->bank[mii->mem[spBuffer >> 8].read]; + mii->cpu.P.C = mii_dd_write( + &c->drive[spUnit], bank, spBuffer, blk, 1) != 0; + } break; + } +} + +static int +_mii_sm_init( + mii_t * mii, + struct mii_slot_t *slot ) +{ + mii_card_sm_t *c = calloc(1, sizeof(*c)); + c->slot = slot; + slot->drv_priv = c; + + printf("%s loading in slot %d\n", __func__, slot->id); + uint16_t addr = 0xc100 + (slot->id * 0x100); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr, mii_smartport_rom_data, 256); + + uint8_t trap_hd = mii_register_trap(mii, _mii_hd_callback); + uint8_t trap_sm = mii_register_trap(mii, _mii_sm_callback); + printf("%s: traps %02x %02x\n", __func__, trap_hd, trap_sm); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr + 0xd2, &trap_hd, 1); + mii_bank_write( + &mii->bank[MII_BANK_CARD_ROM], + addr + 0xe2, &trap_sm, 1); + + for (int i = 0; i < MII_SM_DRIVE_COUNT; i++) { + mii_dd_t *dd = &c->drive[i]; + dd->slot_id = slot->id + 1; + dd->drive = i + 1; + dd->slot = slot; + asprintf((char **)&dd->name, "SmartPort S:%d D:%d", + dd->slot_id, dd->drive); + } + mii_dd_register_drives(&mii->dd, c->drive, MII_SM_DRIVE_COUNT); + + return 0; +} + +static int +_mii_sm_command( + mii_t * mii, + struct mii_slot_t *slot, + uint8_t cmd, + void * param) +{ + mii_card_sm_t *c = slot->drv_priv; + switch (cmd) { + case MII_SLOT_DRIVE_COUNT: + if (param) + *(int *)param = MII_SM_DRIVE_COUNT; + break; + case MII_SLOT_DRIVE_LOAD ... MII_SLOT_DRIVE_LOAD + MII_SM_DRIVE_COUNT - 1: + if (param) { + int drive = cmd - MII_SLOT_DRIVE_LOAD; + const char *filename = param; + mii_dd_file_t *file = NULL; + if (filename) { + file = mii_dd_file_load(&mii->dd, filename, 0); + if (!file) + return -1; + } + mii_dd_drive_load(&c->drive[drive], file); + return 0; + } + break; + } + return 0; +} + +static uint8_t +_mii_sm_access( + mii_t * mii, struct mii_slot_t *slot, + uint16_t addr, uint8_t byte, bool write) +{ + #if 0 + mii_card_sm_t *c = slot->drv_priv; + + printf("%s PC:%04x addr %04x %02x wr:%d\n", __func__, + mii->cpu.PC, addr, byte, write); + int psw = addr & 0x0F; + if (write) { + switch (psw) { + case 0: + // c->latch = (c->latch & 0xff00) | byte; + break; + case 1: + // c->latch = (c->latch & 0x00ff) | (byte << 8); + break; + } + } else { + // return c->file[(c->latch << 4) + psw]; + } + #endif + return 0; +} + +static mii_slot_drv_t _driver = { + .name = "smartport", + .desc = "SmartPort card", + .init = _mii_sm_init, + .access = _mii_sm_access, + .command = _mii_sm_command, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/drivers/mii_titan_iie.c b/src/drivers/mii_titan_iie.c new file mode 100644 index 0000000..ca54a27 --- /dev/null +++ b/src/drivers/mii_titan_iie.c @@ -0,0 +1,79 @@ +/* + * mii_titan_iie.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" + +/* + * This is a mini driver for the Titan Accelerator IIe, not very common, + * but it's a nice card, and it's a good example of a driver that needs + * to use a softswitch ovverride to work. + * Also, I own one of these, and none of the other fancy ones, so this one + * gets the love. + */ +static bool +_mii_titan_access( + struct mii_bank_t *bank, + void *param, + uint16_t addr, + uint8_t * byte, + bool write) +{ + mii_t *mii = param; + bool res = false; + mii_bank_t *main = &mii->bank[MII_BANK_MAIN]; + if (write) { + printf("titan: write %02x to %04x\n", *byte, addr); + switch (*byte) { + case 5: + mii->speed = 3.58; + mii_bank_poke(main, 0xc086, *byte); + break; + case 1: + mii_bank_poke(main, 0xc086, *byte); + mii->speed = 1; + break; + case 0xa: // supposed to lock it too... + mii_bank_poke(main, 0xc086, *byte); + mii->speed = 1; + break; + default: + printf("titan: unknown speed %02x\n", *byte); + break; + } + } + return res; +} + +static int +_mii_titan_probe( + mii_t *mii, + uint32_t flags) +{ + printf("%s %s\n", __func__, flags & MII_INIT_TITAN ? "enabled" : "disabled"); + if (!(flags & MII_INIT_TITAN)) + return 0; + // this override a read-only soft switch, but we only handle writes + // so it's fine + mii_set_sw_override(mii, 0xc086, _mii_titan_access, mii); + mii->speed = 3.58; + return 1; +} + +static mii_slot_drv_t _driver = { + .name = "titan", + .desc = "Titan Accelerator IIe", + .enable_flag = MII_INIT_TITAN, + .probe = _mii_titan_probe, +}; +MI_DRIVER_REGISTER(_driver); diff --git a/src/format/dsk.c b/src/format/dsk.c new file mode 100644 index 0000000..38de340 --- /dev/null +++ b/src/format/dsk.c @@ -0,0 +1,472 @@ +// format/dsk.c +// +// Copyright (c) 2023 Micah John Cowan. +// This code is licensed under the MIT license. +// See the accompanying LICENSE file for details. + +#include +#include +#include +#include +#include +#include + +#include "mii_disk_format.h" + +#define NIBBLE_SECTOR_SIZE 416 +#define NIBBLE_TRACK_SIZE 6656 +#define DSK_SECTOR_SIZE 256 +#define MAX_SECTORS 16 +#define VOLUME_NUMBER 254 +#define DSK_TRACK_SIZE (DSK_SECTOR_SIZE * MAX_SECTORS) + +#define byte uint8_t + +struct dskprivdat { + const char *path; + byte *realbuf; + byte *buf; + const byte *secmap; + int bytenum; + uint64_t dirty_tracks; +}; +static const struct dskprivdat datinit = { 0 }; + +static const size_t nib_disksz = 232960; +static const size_t dsk_disksz = 143360; + +// DOS 3.3 Physical sector order (index is physical sector, +// value is DOS sector) +const byte DO[] = { + 0x0, 0x7, 0xE, 0x6, 0xD, 0x5, 0xC, 0x4, + 0xB, 0x3, 0xA, 0x2, 0x9, 0x1, 0x8, 0xF +}; + +// ProDOS Physical sector order (index is physical sector, +// value is ProDOS sector). +const byte PO[] = { + 0x0, 0x8, 0x1, 0x9, 0x2, 0xa, 0x3, 0xb, + 0x4, 0xc, 0x5, 0xd, 0x6, 0xe, 0x7, 0xf +}; + +const byte TRANS62[] = { + 0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6, + 0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3, + 0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc, + 0xbd, 0xbe, 0xbf, 0xcb, 0xcd, 0xce, 0xcf, 0xd3, + 0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, + 0xdf, 0xe5, 0xe6, 0xe7, 0xe9, 0xea, 0xeb, 0xec, + 0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, + 0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff +}; + +static const int DETRANS62[] = { + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 0x00, 0x01, + -1, -1, 0x02, 0x03, -1, 0x04, 0x05, 0x06, + -1, -1, -1, -1, -1, -1, 0x07, 0x08, + -1, -1, -1, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + -1, -1, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, + -1, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 0x1B, -1, 0x1C, 0x1D, 0x1E, + -1, -1, -1, 0x1F, -1, -1, 0x20, 0x21, + -1, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, + -1, -1, -1, -1, -1, 0x29, 0x2A, 0x2B, + -1, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, + -1, -1, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, + -1, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F +}; + +static void realign_tracks(DiskFormatDesc *desc) +{ + /* + When we unpack a .dsk into nibblized form, it's + automatically aligned neatly within our track-storage + boundaries within the disk buffer, because that's how + we laid 'em out. + + When a sector is written or updated, it will + tend to stay aligned, because the program had to + find the existing sector to write to, to keep things + in order. + + However, in the event of reformatting, there are no + guarantees about the track being aligned conveniently. + The formatting program can start at any old position + and just start writing, because no existing data is going + to be preserved. + + To deal with this, we could either: + 1) Be prepared to loop back around our track's buffer, + mid-sector + 2) Re-align the track at our convenience, to start + somewhere that we know for sure can't be the middle of + sector data. + + I've opted for option (2). It would be a bad option if + we're reading and writing a .nib file, because we'd be + unnecessarily altering the file's structure (in cases + where it had NOT been reformatted), but it's perfectly + fine when we'll be discarding the nibblized format anyway. + + We handle this by seeking forward to the first sector-field + start boundary (D5 AA 96) that we can find, and make that + the new "start" of our track. It doesn't matter if it's a + false-start that doesn't start a real sector-field, because one + thing we know for *sure* is that first D5 can't be found + in the middle of a legitimate header or data field. + */ + + struct dskprivdat *dat = desc->privdat; + byte *buf = dat->buf; + byte *secbuf = malloc(NIBBLE_TRACK_SIZE); + for (int t=0; t != NUM_TRACKS; ++t) { + byte *tstart = buf + (t * NIBBLE_TRACK_SIZE); + byte *tend = buf + ((t + 1) * NIBBLE_TRACK_SIZE); + byte *talign; + for (talign = tstart; talign <= (tend - 3); ++talign) { + if (talign[0] == 0xD5 && talign[1] == 0xAA && talign[2] == 0x96) { + if (talign == tstart) { + // Nothing to do, already aligned. + } else { + size_t rollsz = talign - tstart; + memcpy(secbuf, tstart, rollsz); + memmove(tstart, talign, tend-talign); + memcpy(tend - rollsz, secbuf, rollsz); + } + break; // handle next track + } + } + } + free(secbuf); +} + +static void implodeDo(DiskFormatDesc *desc) +{ + struct dskprivdat *dat = desc->privdat; + + realign_tracks(desc); + + const byte *rd = dat->buf; // nibble buf + const byte *end = dat->buf + nib_disksz; + + bool warned = false; + + for (;;) { + // Scan forward for a sector header + const int sector_hdr_sz = 11; // counts prologue, but not epilogue + for (;;) { + // This is the only place we're "allowed" to end processing. + if (rd >= (end - sector_hdr_sz)) goto done; + if (rd[0] == 0xD5 && rd[1] == 0xAA && rd[2] == 0x96) break; + ++rd; + } + +header: + rd += 3; + int v = ((rd[0] << 1) | 0x1) & rd[1]; + rd += 2; + int t = ((rd[0] << 1) | 0x1) & rd[1]; + rd += 2; + int s = ((rd[0] << 1) | 0x1) & rd[1]; + rd += 2; + int checkSum = ((rd[0] << 1) | 0x1) & rd[1]; + rd += 2; + + if (checkSum != (v ^ t ^ s)) { + WARN("Sector header checksum failed, t=%d s=%d" + " at nibblized byte %zu.\n", t, s, rd - dat->buf); + WARN("Probable disk corruption for %s\n", dat->path); + } + + byte truet = (rd - dat->buf)/NIBBLE_TRACK_SIZE; + if (t != truet) { + WARN("Sector header lying about track number" + " at nibblized pos %zu\n", (size_t)(rd - dat->buf)); + WARN(" (says %d but we're on track %d). Skipping sector.\n", + (int)t, (int)truet); + continue; + } + if (s >= MAX_SECTORS) { + WARN("Sector header sec# too high (%d; max is %d).\n", + (int)s, (int)MAX_SECTORS); + WARN(" Skipping sector.\n"); + continue; + } + + const int data_field_sz = 0x15A; //counts prologue, not epilogue + for (;;) { + if (rd >= (end - 0x15A)) goto bail; + if (rd[0] == 0xD5 && rd[1] == 0xAA) { + if (rd[2] == 0x96) goto header; + if (rd[2] == 0xAD) break; + } + ++rd; + } + + rd += 3; + + // Translate sector data field + { + int s_ = dat->secmap[s]; + byte *data = dat->realbuf + (t * DSK_TRACK_SIZE) + + (s_ * DSK_SECTOR_SIZE); + byte data2[0x56]; + byte last = 0; + int val; + + if (0) { + WARN("Translating track %d, phys sec %d (image sec %d)\n", + t, s, s_); + WARN(" starting at dsk pos %zu\n", (size_t)(data - dat->realbuf)); + } + + for (int j = 0x55; j >= 0; --j) { + val = DETRANS62[*rd - 0x80]; + if (val == -1 && !warned) { + warned = true; + WARN("Untranslatable nibble at (nibblized) pos %zu," + " disk %s.\n", (size_t)(rd - dat->buf), dat->path); + if (rd <= end - 4) { + WARN("%02X %02X %02X %02X [%02X] %02X %02X %02X\n", + rd[-4], rd[-3], rd[-2], rd[-1], + rd[0], rd[1], rd[2], rd[3]); + } + WARN("CORRUPT DISK SAVE TO %s\n", dat->path); + } + val ^= last; + data2[j] = val; + last = val; + ++rd; + } + + for (int j = 0; j < 0x100; ++j) { + val = DETRANS62[*rd - 0x80]; + if (val == -1 && !warned) { + warned = true; + WARN("Untranslatable nibble at t=%d, phys s=%d," + " disk %s.\n", t, s, dat->path); + WARN("CORRUPT DISK SAVE TO %s\n", dat->path); + } + val ^= last; + data[j] = val; + last = val; + ++rd; + } + + int checkSum = DETRANS62[*rd++ - 0x80]; + if (checkSum != -1) checkSum ^= last; + if (checkSum != 0) { + WARN("Bad sector data checksum at t=%d, phys s=%d," + " disk %s.\n", t, s, dat->path); + } + + for (int k = 0, j = 0x55; k < 0x100; ++k) { + data[k] <<= 1; + if ((data2[j] & 0x1) != 0) { + data[k] |= 0x01; + } + data2[j] >>= 1; + + data[k] <<= 1; + if ((data2[j] & 0x01) != 0) { + data[k] |= 0x01; + } + data2[j] >>= 0x01; + + if (--j < 0) j = 0x55; + } + } + } + +bail: + WARN("Error translating to dsk: ended mid-sector!\n"); + WARN("Probable disk corruption for %s\n", dat->path); +done: + return; +} + +static void spin(DiskFormatDesc *desc, bool b) +{ + struct dskprivdat *dat = desc->privdat; + if (!b && dat->dirty_tracks != 0) { + implodeDo(desc); + // For now, sync the entire disk + errno = 0; + int err = msync(dat->realbuf, dsk_disksz, MS_SYNC); + if (err < 0) { + DIE(1,"Couldn't sync to disk file %s: %s\n", + dat->path, strerror(errno)); + } + dat->dirty_tracks = 0; + } +} + +static byte read_byte(DiskFormatDesc *desc) +{ + struct dskprivdat *dat = desc->privdat; + size_t pos = (desc->halftrack/2) * NIBBLE_TRACK_SIZE; + pos += (dat->bytenum % NIBBLE_TRACK_SIZE); + byte val = dat->buf[pos]; + dat->bytenum = (dat->bytenum + 1) % NIBBLE_TRACK_SIZE; + return val; +} + +static void write_byte(DiskFormatDesc *desc, byte val) +{ + struct dskprivdat *dat = desc->privdat; + if ((val & 0x80) == 0) { + // D2DBG("dodged write $%02X", val); + return; // must have high bit + } + dat->dirty_tracks |= 1 << (desc->halftrack/2); + size_t pos = (desc->halftrack/2) * NIBBLE_TRACK_SIZE; + pos += (dat->bytenum % NIBBLE_TRACK_SIZE); + + //D2DBG("write byte $%02X at pos $%04zX", (unsigned int)val, pos); + + dat->buf[pos] = val; + dat->bytenum = (dat->bytenum + 1) % NIBBLE_TRACK_SIZE; +} + +static void eject(DiskFormatDesc *desc) +{ + // free dat->path and dat, and unmap disk image + struct dskprivdat *dat = desc->privdat; + (void) munmap(dat->buf, dsk_disksz); + free((void*)dat->path); + free(dat); +} + +// This function is derived from Scullin Steel Co.'s apple2js code +// https://github.com/whscullin/apple2js/blob/e280c3d/js/formats/format_utils.ts#L140 +static void explodeSector(byte vol, byte track, byte sector, + byte **nibSec, const byte *data) +{ + byte *wr = *nibSec; + unsigned int gap; + + // Gap 1/3 (40/0x28 bytes) + + if (sector == 0) // Gap 1 + gap = 0x80; + else { // Gap 3 + gap = track == 0? 0x28 : 0x26; + } + + for (uint8_t i = 0; i != gap; ++i) { + *wr++ = 0xFF; + } + + // Address Field + const byte checksum = vol ^ track ^ sector; + *wr++ = 0xD5; *wr++ = 0xAA; *wr++ = 0x96; // Address Prolog D5 AA 96 + *wr++ = (vol >> 1) | 0xAA; *wr++ = vol | 0xAA; + *wr++ = (track >> 1) | 0xAA; *wr++ = track | 0xAA; + *wr++ = (sector >> 1) | 0xAA; *wr++ = sector | 0xAA; + *wr++ = (checksum >> 1) | 0xAA; *wr++ = checksum | 0xAA; + *wr++ = 0xDE; *wr++ = 0xAA; *wr++ = 0xEB; // Epilogue DE AA EB + + // Gap 2 (5 bytes) + for (int i = 0; i != 5; ++i) { + *wr++ = 0xFF; + } + + // Data Field + *wr++ = 0xD5; *wr++ = 0xAA; *wr++ = 0xAD; // Data Prolog D5 AA AD + + byte *nibbles = wr; + const unsigned ptr2 = 0; + const unsigned ptr6 = 0x56; + + for (int i = 0; i != 0x156; ++i) { + nibbles[i] = 0; + } + + int i2 = 0x55; + for (int i6 = 0x101; i6 >= 0; --i6) { + byte val6 = data[i6 % 0x100]; + byte val2 = nibbles[ptr2 + i2]; + + val2 = (val2 << 1) | (val6 & 1); + val6 >>= 1; + val2 = (val2 << 1) | (val6 & 1); + val6 >>= 1; + + nibbles[ptr6 + i6] = val6; + nibbles[ptr2 + i2] = val2; + + if (--i2 < 0) + i2 = 0x55; + } + + byte last = 0; + for (int i = 0; i != 0x156; ++i) { + const byte val = nibbles[i]; + nibbles[i] = TRANS62[last ^ val]; + last = val; + } + wr += 0x156; // advance write-pointer + *wr++ = TRANS62[last]; + + *wr++ = 0xDE; *wr++ = 0xAA; *wr++ = 0xEB; // Epilogue DE AA EB + + // Gap 3 + *wr++ = 0xFF; + + *nibSec = wr; +} + +static void explodeDsk(byte *nibbleBuf, byte *dskBuf, const byte *secmap) +{ + for (int t = 0; t < NUM_TRACKS; ++t) { + byte *writePtr = nibbleBuf; + for (int phys_sector = 0; phys_sector < MAX_SECTORS; ++phys_sector) { + const byte dos_sector = secmap[phys_sector]; + const size_t off = ((MAX_SECTORS * t + dos_sector) + * DSK_SECTOR_SIZE); + explodeSector(VOLUME_NUMBER, t, phys_sector, + &writePtr, &dskBuf[off]); + } + assert(writePtr - nibbleBuf <= NIBBLE_TRACK_SIZE); + for (; writePtr != (nibbleBuf + NIBBLE_TRACK_SIZE); ++writePtr) { + *writePtr = 0xFF; + } + nibbleBuf += NIBBLE_TRACK_SIZE; + } +} + +DiskFormatDesc dsk_insert(const char *path, byte *buf, size_t sz) +{ + if (sz != dsk_disksz) { + DIE(0,"Wrong disk image size for %s:\n", path); + DIE(1," Expected %zu, got %zu.\n", dsk_disksz, sz); + } + + struct dskprivdat *dat = malloc(sizeof *dat); + *dat = datinit; + dat->realbuf = buf; + dat->path = strdup(path); + dat->buf = calloc(1, nib_disksz); + + const char *ext = rindex(path, '.'); + ext = ext ? ext+1 : ""; + if (!strcasecmp(ext, "PO")) { + INFO("Opening %s as PO.\n", dat->path); + dat->secmap = PO; + } else { + INFO("Opening %s as DO.\n", dat->path); + dat->secmap = DO; + } + explodeDsk(dat->buf, dat->realbuf, dat->secmap); + + return (DiskFormatDesc){ + .privdat = dat, + .spin = spin, + .read_byte = read_byte, + .write_byte = write_byte, + .eject = eject, + }; +} diff --git a/src/format/empty.c b/src/format/empty.c new file mode 100644 index 0000000..6643fe3 --- /dev/null +++ b/src/format/empty.c @@ -0,0 +1,36 @@ +// format/empty.c +// +// Copyright (c) 2023 Micah John Cowan. +// This code is licensed under the MIT license. +// See the accompanying LICENSE file for details. + +#include "mii_disk_format.h" + + +#define byte uint8_t + +void spin(DiskFormatDesc *d, bool b) +{ +} + +byte read_byte(DiskFormatDesc *d) +{ + // A real disk can never send a low byte. + // But an empty disk must never send a legitimate byte. + return 0x00; +} + +void write_byte(DiskFormatDesc *d, byte b) +{ +} + +void eject(DiskFormatDesc *d) +{ +} + +DiskFormatDesc empty_disk_desc = { + .spin = spin, + .read_byte = read_byte, + .write_byte = write_byte, + .eject = eject, +}; diff --git a/src/format/mii_dd.c b/src/format/mii_dd.c new file mode 100644 index 0000000..41f4c9a --- /dev/null +++ b/src/format/mii_dd.c @@ -0,0 +1,399 @@ +/* + * mii_dd.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mii_bank.h" +#include "mii_dd.h" +#include "md5.h" + +#ifndef FCC +#define FCC(_a,_b,_c,_d) (((_a)<<24)|((_b)<<16)|((_c)<<8)|(_d)) +#endif + +int +mii_dd_overlay_load( + mii_dd_t * dd ); +int +mii_dd_overlay_prepare( + mii_dd_t * dd ); + + +void +mii_dd_system_init( + mii_dd_system_t *dd ) +{ + dd->drive = NULL; + dd->file = NULL; +} + +void +mii_dd_system_dispose( + mii_dd_system_t *dd ) +{ + while (dd->file) + mii_dd_file_dispose(dd, dd->file); + dd->file = NULL; + dd->drive = NULL; +} + +void +mii_dd_register_drives( + mii_dd_system_t *dd, + mii_dd_t * drives, + uint8_t count ) +{ + for (int i = 0; i < count; i++) { + mii_dd_t *d = &drives[i]; + d->dd = dd; + d->next = dd->drive; + dd->drive = d; + } +} + +void +mii_dd_file_dispose( + mii_dd_system_t *dd, + mii_dd_file_t *file ) +{ + // remove it from dd's file queue + if (dd->file == file) + dd->file = file->next; + else { + mii_dd_file_t *f = dd->file; + while (f) { + if (f->next == file) { + f->next = file->next; + break; + } + f = f->next; + } + } + if (file->dd) { + file->dd->file = NULL; + file->dd = NULL; + } + if (file->fd >= 0) { + close(file->fd); + file->fd = -1; + file->map = NULL; + } + if (file->map) { + free(file->map); + file->map = NULL; + } + if (file->pathname) { + free(file->pathname); + file->pathname = NULL; + } + free(file); +} + +int +mii_dd_drive_load( + mii_dd_t *dd, + mii_dd_file_t *file ) +{ + if (dd->file == file) + return 0; + if (dd->file) { + printf("%s: %s unloading %s\n", __func__, + dd->name, + dd->file->pathname); + mii_dd_file_dispose(dd->dd, dd->file); + dd->file = NULL; + } + if (!file) + return 0; + dd->file = file; + printf("%s: %s loading %s\n", __func__, + dd->name, file->pathname); + if (mii_dd_overlay_load(dd) < 0) { + printf("%s: No overlay to load, we're fine for now\n", __func__); + // no overlay.. what to do? + } + return 0; +} + +mii_dd_file_t * +mii_dd_file_load( + mii_dd_system_t *dd, + const char *pathname, + uint16_t flags) +{ + if (!flags) + flags = O_RDONLY; + int err; + int fd = open(pathname, flags); + if (fd < 0) { + perror(pathname); + return NULL; + } + struct stat st; + err = fstat(fd, &st); + if (err < 0) { + perror(pathname); + goto bail; + } + int protect = PROT_READ; + int mflags = MAP_PRIVATE; + if (flags & (O_RDWR | O_WRONLY)) { + protect |= PROT_WRITE; + mflags = MAP_SHARED; + } + uint8_t *buf = mmap(NULL, st.st_size, protect, mflags, fd, 0); + if (buf == NULL || buf == MAP_FAILED) { + perror(pathname); + // err = errno; + goto bail; + } + mii_dd_file_t * res = calloc(1, sizeof(*res)); + res->pathname = strdup(pathname); + res->fd = fd; + res->map = buf; + res->start = buf; + res->size = st.st_size; + res->dd = NULL; + res->next = dd->file; + dd->file = res; + char *suffix = strrchr(pathname, '.'); + if (suffix && !strcasecmp(suffix, ".2mg")) { + res->format = MII_DD_FILE_2MG; + res->map += 64; + } + return res; +bail: + close(fd); + return NULL; +} + +mii_dd_file_t * +mii_dd_file_in_ram( + mii_dd_system_t *dd, + const char *pathname, + uint32_t size, + uint16_t flags) +{ + mii_dd_file_t * res = calloc(1, sizeof(*res)); + res->pathname = strdup(pathname); + res->fd = -1; + res->map = calloc(1, size); + res->start = res->map; + res->size = size; + res->dd = NULL; + res->next = dd->file; + dd->file = res; + res->format = MII_DD_FILE_RAM; + return res; +} + +int +mii_dd_overlay_load( + mii_dd_t * dd ) +{ + if (dd->overlay.file) + return 0; + if (!dd->file) + return -1; + + char *filename = NULL; + char *suffix = strrchr(dd->file->pathname, '.'); + if (suffix) { + asprintf(&filename, "%.*s.miov", (int)(suffix - dd->file->pathname), dd->file->pathname); + } else { + asprintf(&filename, "%s.miov", dd->file->pathname); + } + int fd = open(filename, O_RDWR, 0666); + if (fd == -1) { + fprintf(stderr, "%s: overlay %s: %s\n", __func__, + filename, strerror(errno)); + free(filename); + return -1; + } + mii_dd_file_t * file = mii_dd_file_load(dd->dd, filename, O_RDWR); + close(fd); + if (!file) + return -1; + mii_dd_overlay_header_t * h = (mii_dd_overlay_header_t *)file->start; + + if (h->magic != FCC('M','I','O','V')) { + fprintf(stderr, "Overlay file %s has invalid magic\n", filename); + mii_dd_file_dispose(dd->dd, file); + return -1; + } + if (h->version != 1) { + fprintf(stderr, "Overlay file %s has invalid version\n", filename); + mii_dd_file_dispose(dd->dd, file); + return -1; + } + if (h->size != dd->file->size / 512) { + fprintf(stderr, "Overlay file %s has invalid size\n", filename); + mii_dd_file_dispose(dd->dd, file); + return -1; + } + + MD5_CTX d5 = {}; + MD5_Init(&d5); + MD5_Update(&d5, dd->file->start, dd->file->size); + uint8_t md5[16]; + MD5_Final(md5, &d5); + + if (memcmp(md5, h->src_md5, 16)) { + fprintf(stderr, "Overlay file %s has mismatched HASH!\n", filename); + mii_dd_file_dispose(dd->dd, file); + return -1; + } + uint32_t bitmap_size = (h->size + 63) / 64; + dd->overlay.file = file; + dd->overlay.file->map += sizeof(*h) + bitmap_size; + dd->overlay.header = (mii_dd_overlay_header_t *)dd->overlay.file->start; + dd->overlay.bitmap = (uint64_t*)(dd->overlay.file->start + sizeof(*h)); + dd->overlay.blocks = dd->overlay.file->map; + + return 0; +} + +int +mii_dd_overlay_prepare( + mii_dd_t * dd ) +{ + if (dd->overlay.file) + return 0; + if (!dd->file) + return -1; + printf("%s: %s Preparing Overlay file\n", __func__, dd->name); + uint32_t src_blocks = dd->file->size / 512; + uint32_t bitmap_size = (src_blocks + 63) / 64; + uint32_t blocks_size = src_blocks * 512; + uint32_t size = sizeof(mii_dd_overlay_header_t) + bitmap_size + blocks_size; + + char *filename = NULL; + char *suffix = strrchr(dd->file->pathname, '.'); + if (suffix) { + asprintf(&filename, "%.*s.miov", (int)(suffix - dd->file->pathname), dd->file->pathname); + } else { + asprintf(&filename, "%s.miov", dd->file->pathname); + } + int fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0666); + if (fd == -1) { + fprintf(stderr, "%s: Failed to create overlay file %s: %s\n", __func__, + filename, strerror(errno)); + fprintf(stderr, "%s: Allocating a RAM one, lost on quit!\n", __func__); + dd->overlay.file = mii_dd_file_in_ram(dd->dd, filename, size, O_RDWR); + } else { + ftruncate(fd, size); + dd->overlay.file = mii_dd_file_load(dd->dd, filename, O_RDWR); + } + if (fd != -1) + close(fd); + free(filename); + mii_dd_overlay_header_t h = { + .magic = FCC('M','I','O','V'), + .version = 1, + .size = src_blocks, + }; + // hash the whole of the file, including header + MD5_CTX d5 = {}; + MD5_Init(&d5); + MD5_Update(&d5, dd->file->start, dd->file->size); + MD5_Final(h.src_md5, &d5); + *((mii_dd_overlay_header_t *)dd->overlay.file->start) = h; + dd->overlay.file->map += sizeof(h) + bitmap_size; + dd->overlay.header = (mii_dd_overlay_header_t *)dd->overlay.file->start; + dd->overlay.bitmap = (uint64_t*)(dd->overlay.file->start + sizeof(h)); + dd->overlay.blocks = dd->overlay.file->map; + return 0; +} + +int +mii_dd_read( + mii_dd_t * dd, + struct mii_bank_t *bank, + uint16_t addr, + uint32_t blk, + uint16_t blockcount) +{ + if (!dd || !dd->file || !dd->file->map) + return -1; + +// printf("%s: %s read %d blocks at %d\n", +// __func__, dd->name, blockcount, blk); + if (dd->overlay.file) { + uint64_t *bitmap = dd->overlay.bitmap; + for (int i = 0; i < blockcount; i++) { + uint32_t b = blk + i; +// printf(" overlay block %4d : %016llx\n", b, +// (unsigned long long)be64toh(bitmap[b/64])); + if (b >= dd->overlay.header->size) + break; + if (be64toh(bitmap[b / 64]) & (1ULL << (63 - (b & 63)))) { +// printf("%s: reading %4d from overlay\n", __func__, b); + mii_bank_write( bank, + addr + (i * 512), + dd->overlay.blocks + (b * 512), + 512); + } else { + mii_bank_write( bank, + addr + (i * 512), + dd->file->map + (b * 512), + 512); + } + } + } else { + mii_bank_write( + bank, + addr, dd->file->map + blk * 512, + blockcount * 512); + } + return 0; +} + +int +mii_dd_write( + mii_dd_t * dd, + struct mii_bank_t *bank, + uint16_t addr, + uint32_t blk, + uint16_t blockcount) +{ + if (!dd || !dd->file || !dd->file->map) + return -1; +// printf("%s: %s write %d blocks at %d\n", +// __func__, dd->name, blockcount, blk); + mii_dd_overlay_prepare(dd); + if (dd->overlay.file) { + uint64_t *bitmap = dd->overlay.bitmap; + for (int i = 0; i < blockcount; i++) { + uint32_t b = blk + i; + if (b >= dd->overlay.header->size) + break; + bitmap[b / 64] = htobe64( + be64toh(bitmap[b/64]) | (1ULL << (63 - (b & 63)))); +// printf("%s: writing %d to overlay map: %016llx\n", __func__, b, +// (unsigned long long)be64toh(bitmap[b/64])); + } + mii_bank_read( + bank, + addr, dd->overlay.blocks + blk * 512, + blockcount * 512); + } else { + mii_bank_read( + bank, + addr, dd->file->map + blk * 512, + blockcount * 512); + } + return 0; +} + diff --git a/src/format/mii_dd.h b/src/format/mii_dd.h new file mode 100644 index 0000000..dbaf828 --- /dev/null +++ b/src/format/mii_dd.h @@ -0,0 +1,124 @@ +/* + * mii_dd.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include + +struct mii_dd_t; + +enum { + MII_DD_FILE_OVERLAY = 1, + MII_DD_FILE_RAM, + MII_DD_FILE_2MG = 5, +}; + +// a disk image file (or chunck of ram, if ramdisk is used) +typedef struct mii_dd_file_t { + struct mii_dd_file_t *next; + char * pathname; + uint8_t format; + uint8_t * start; // start of the file + uint8_t * map; // start of the blocks + + int fd; // if fd >= 0, map is mmaped, otherwise it's malloced + uint32_t size; + struct mii_dd_t * dd; +} mii_dd_file_t; + +/* + * Overlays are made to provide what looks like read/write on files, but + * without commiting any of the changes to the real primary file, instead + * alld the changed blocks are kept into a sparse file and reloaded when + * the 'real' block is read. + * That way you can keep your disk images fresh and clean, while having + * multiple version of them if you like. + */ +typedef union mii_dd_overlay_header_t { + struct { + uint32_t magic; // 'MIOV' + uint32_t version; // 1 for now + uint32_t flags; // unused for now + uint32_t size; // size in blocks of original file + uint8_t src_md5[16]; // md5 of the SOURCE disk + }; + uint32_t raw[16]; +} mii_dd_overlay_header_t; + +typedef struct mii_dd_overlay_t { + mii_dd_overlay_header_t *header; // points to the file mapped in memory + uint64_t * bitmap; // usage bitmap + uint8_t * blocks; // raw block data + mii_dd_file_t *file; // overlay file mapping +} mii_dd_overlay_t; + +struct mii_slot_t; +struct mii_dd_system_t; + +// a disk drive, with a slot, a drive number, and a file +typedef struct mii_dd_t { + struct mii_dd_t *next; + struct mii_dd_system_t *dd; + const char * name; // ie "Disk ][ D:2" + uint8_t slot_id : 4, drive : 4; + struct mii_slot_t *slot; + unsigned int ro : 1, wp : 1, can_eject : 1; + mii_dd_file_t * file; + mii_dd_overlay_t overlay; +} mii_dd_t; + +typedef struct mii_dd_system_t { + mii_dd_t * drive; // list of all drives on all slots + mii_dd_file_t * file; // list of all open files (inc overlays) +} mii_dd_system_t; + +/* + * register drives with the system -- these are not allocated, they are + * statically defined in the driver code in their own structures + */ +void +mii_dd_register_drives( + mii_dd_system_t *dd, + mii_dd_t * drives, + uint8_t count ); +int +mii_dd_drive_load( + mii_dd_t *dd, + mii_dd_file_t *file ); + +/* + * unmap, close and dispose of 'file', clear it from the drive, if any + */ +void +mii_dd_file_dispose( + mii_dd_system_t *dd, + mii_dd_file_t *file ); +mii_dd_file_t * +mii_dd_file_load( + mii_dd_system_t *dd, + const char *filename, + uint16_t flags); + +struct mii_bank_t; +// read blocks from blk into bank's address 'addr' +int +mii_dd_read( + mii_dd_t * dd, + struct mii_bank_t *bank, + uint16_t addr, + uint32_t blk, + uint16_t blockcount); + +int +mii_dd_write( + mii_dd_t * dd, + struct mii_bank_t *bank, + uint16_t addr, + uint32_t blk, + uint16_t blockcount); + diff --git a/src/format/mii_disk_format.c b/src/format/mii_disk_format.c new file mode 100644 index 0000000..af99174 --- /dev/null +++ b/src/format/mii_disk_format.c @@ -0,0 +1,95 @@ +/* + * mii_disk_format.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mii_disk_format.h" + + +#define byte uint8_t + +static const size_t nib_disksz = 232960; +static const size_t dsk_disksz = 143360; + +extern DiskFormatDesc nib_insert(const char*, byte *, size_t); +extern DiskFormatDesc dsk_insert(const char *, byte *, size_t); +extern DiskFormatDesc empty_disk_desc; + +int mmapfile(const char *fname, byte **buf, size_t *sz, int flags); + +DiskFormatDesc disk_format_load(const char *path) +{ + if (path == NULL) { + return empty_disk_desc; + } + byte *buf; + size_t sz; + int err = mmapfile(path, &buf, &sz, O_RDWR); + if (buf == NULL) { + DIE(1,"Couldn't load/mmap disk %s: %s\n", + path, strerror(err)); + } + printf("%s loaded %s dz = %d\n", __func__, path, (int)sz); + if (sz == nib_disksz) { + return nib_insert(path, buf, sz); + } else if (sz == dsk_disksz) { + return dsk_insert(path, buf, sz); + } else { + DIE(2,"Unrecognized disk format for %s.\n", path); + } +} + +int mmapfile(const char *fname, byte **buf, size_t *sz, int flags) +{ + int err; + int fd; + + *buf = NULL; + + errno = 0; + fd = open(fname, flags); + if (fd < 0) { + return errno; + } + + struct stat st; + errno = 0; + err = fstat(fd, &st); + if (err < 0) { + goto bail; + } + + errno = 0; + int protect = PROT_READ; + int mflags = MAP_PRIVATE; + if (flags & O_RDWR || flags & O_WRONLY) { + protect |= PROT_WRITE; + mflags = MAP_SHARED; + } + *buf = mmap(NULL, st.st_size, protect, mflags, fd, 0); + if (*buf == NULL) { + err = errno; + goto bail; + } + close(fd); // safe to close now. + + *sz = st.st_size; + return 0; +bail: + close(fd); + return err; +} diff --git a/src/format/mii_disk_format.h b/src/format/mii_disk_format.h new file mode 100644 index 0000000..e157189 --- /dev/null +++ b/src/format/mii_disk_format.h @@ -0,0 +1,35 @@ +/* + * mii_disk_format.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +#pragma once + +#include +#include +#include + +/********** FORMATS **********/ +#define NUM_TRACKS 35 +#define SECTOR_SIZE 256 +typedef struct DiskFormatDesc DiskFormatDesc; +typedef struct DiskFormatDesc { + void *privdat; + bool writeprot; + unsigned int halftrack; + void (*spin)(DiskFormatDesc *, bool); + uint8_t (*read_byte)(DiskFormatDesc *); + void (*write_byte)(DiskFormatDesc *, uint8_t); + void (*eject)(DiskFormatDesc *); +} DiskFormatDesc; + +DiskFormatDesc disk_format_load(const char *path); + +#define WARN(...) fprintf(stderr, __VA_ARGS__) +#define INFO(...) fprintf(stderr, __VA_ARGS__) +#define DIE(code, ...) do { \ + WARN(__VA_ARGS__); \ + if (code) exit(code); \ + } while(0) diff --git a/src/format/nib.c b/src/format/nib.c new file mode 100644 index 0000000..d2be1db --- /dev/null +++ b/src/format/nib.c @@ -0,0 +1,100 @@ +// format/nib.c +// +// Copyright (c) 2023 Micah John Cowan. +// This code is licensed under the MIT license. +// See the accompanying LICENSE file for details. + +#include "mii_disk_format.h" + +#include +#include +#include +#include + +#define byte uint8_t + +#define NIBBLE_TRACK_SIZE 6656 +#define NIBBLE_SECTOR_SIZE 416 +#define MAX_SECTORS 16 + +struct nibprivdat { + const char *path; + byte *buf; + int bytenum; + uint64_t dirty_tracks; +}; +static const struct nibprivdat datinit = { 0 }; + +static const size_t nib_disksz = 232960; + +static void spin(DiskFormatDesc *desc, bool b) +{ + struct nibprivdat *dat = desc->privdat; + if (!b && dat->dirty_tracks != 0) { + // For now, sync the entire disk + errno = 0; + int err = msync(dat->buf, nib_disksz, MS_SYNC); + if (err < 0) { + DIE(1,"Couldn't sync to disk file %s: %s\n", + dat->path, strerror(errno)); + } + dat->dirty_tracks = 0; + } +} + +static byte read_byte(DiskFormatDesc *desc) +{ + struct nibprivdat *dat = desc->privdat; + size_t pos = (desc->halftrack/2) * NIBBLE_TRACK_SIZE; + pos += (dat->bytenum % NIBBLE_TRACK_SIZE); + byte val = dat->buf[pos]; + dat->bytenum = (dat->bytenum + 1) % NIBBLE_TRACK_SIZE; + return val; +} + +static void write_byte(DiskFormatDesc *desc, byte val) +{ + struct nibprivdat *dat = desc->privdat; + if ((val & 0x80) == 0) { + // D2DBG("dodged write $%02X", val); + return; // must have high bit + } + dat->dirty_tracks |= 1 << (desc->halftrack/2); + size_t pos = (desc->halftrack/2) * NIBBLE_TRACK_SIZE; + pos += (dat->bytenum % NIBBLE_TRACK_SIZE); + + //D2DBG("write byte $%02X at pos $%04zX", (unsigned int)val, pos); + + dat->buf[pos] = val; + dat->bytenum = (dat->bytenum + 1) % NIBBLE_TRACK_SIZE; +} + +static void eject(DiskFormatDesc *desc) +{ + // free dat->path and dat, and unmap disk image + struct nibprivdat *dat = desc->privdat; + (void) munmap(dat->buf, nib_disksz); + free((void*)dat->path); + free(dat); +} + +DiskFormatDesc nib_insert(const char *path, byte *buf, size_t sz) +{ + if (sz != nib_disksz) { + DIE(0,"Wrong disk image size for %s:\n", path); + DIE(1," Expected %zu, got %zu.\n", nib_disksz, sz); + } + + struct nibprivdat *dat = malloc(sizeof *dat); + *dat = datinit; + dat->buf = buf; + dat->path = strdup(path); + + return (DiskFormatDesc){ + .privdat = dat, + .spin = spin, + .read_byte = read_byte, + .write_byte = write_byte, + .eject = eject, + }; +} diff --git a/src/mii.c b/src/mii.c new file mode 100644 index 0000000..43e142c --- /dev/null +++ b/src/mii.c @@ -0,0 +1,714 @@ +/* + * mii.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii_rom_iiee.h" +#include "mii.h" +#include "mii_bank.h" +#include "mii_video.h" +#include "mii_sw.h" +#include "mii_65c02.h" +#include "minipt.h" + + +mii_slot_drv_t * mii_slot_drv_list = NULL; + +static const mii_bank_t _mii_banks_init[MII_BANK_COUNT] = { + [MII_BANK_MAIN] = { + .name = "MAIN", + .base = 0x0000, + .size = 0xd0, // 208 pages, 48KB + }, + [MII_BANK_BSR] = { + .name = "BSR", + .base = 0xd000, + .size = 64, + }, + [MII_BANK_BSR_P2] = { + .name = "BSR P2", + .base = 0xd000, + .size = 16, + }, + [MII_BANK_AUX] = { + .name = "AUX", + .base = 0x0000, + .size = 0xd0, // 208 pages, 48KB + }, + [MII_BANK_AUX_BSR] = { + .name = "AUX BSR", + .base = 0xd000, + .size = 64, + }, + [MII_BANK_AUX_BSR_P2] = { + .name = "AUX BSR P2", + .base = 0xd000, + .size = 16, + }, + [MII_BANK_ROM] = { + .name = "ROM", + .base = 0xc000, + .size = 0x40, // 64 pages, 16KB + .ro = 1, + }, + [MII_BANK_CARD_ROM] = { + .name = "CARD ROM", + .base = 0xc100, + .size = 15, + .ro = 1, + }, +}; + + +#include "mii_65c02_ops.h" +#include "mii_65c02_disasm.h" + +void +mii_dump_trace_state( + mii_t *mii) +{ + mii_cpu_t * cpu = &mii->cpu; + mii_cpu_state_t s = mii->cpu_state; + printf("PC:%04X A:%02X X:%02X Y:%02X S:%02x #%d %c AD:%04X D:%02x %c ", + cpu->PC, cpu->A, cpu->X, cpu->Y, cpu->S, cpu->cycle, + s.sync ? 'I' : ' ', s.addr, s.data, s.w ? 'W' : 'R'); + // display the S flags + static const char *s_flags = "CZIDBRVN"; + for (int i = 0; i < 8; i++) + printf("%c", cpu->P.P[7-i] ? s_flags[7-i] : tolower(s_flags[7-i])); + if (s.sync) { + uint8_t op[16]; + for (int i = 0; i < 4; i++) { + mii_mem_access(mii, mii->cpu.PC + i, op + i, false, false); + } + mii_op_t d = mii_cpu_op[op[0]]; + printf(" "); + char dis[32]; + mii_cpu_disasm_one(op, cpu->PC, dis, sizeof(dis), + MII_DUMP_DIS_DUMP_HEX); + printf(": %s", dis); + if (d.desc.branch) { + if (cpu->P.P[d.desc.s_bit] == d.desc.s_bit_value) + printf(" ; taken"); + } + printf("\n"); + } else + printf("\n"); +} + +void +mii_dump_run_trace( + mii_t *mii) +{ + // walk all the previous PC values in mii->trace, and display a line + // of disassebly for all of them + for (int li = 0; li < MII_PC_LOG_SIZE; li++) { + int idx = (mii->trace.idx + li) & (MII_PC_LOG_SIZE - 1); + uint16_t pc = mii->trace.log[idx]; + uint8_t op[16]; + for (int i = 0; i < 4; i++) + mii_mem_access(mii, pc + i, op + i, false, false); +// mii_op_t d = mii_cpu_op[op[0]]; + char dis[64]; + mii_cpu_disasm_one(op, pc, dis, sizeof(dis), + MII_DUMP_DIS_PC | MII_DUMP_DIS_DUMP_HEX); + printf("%s\n", dis); + } +} + +#define _SAME 0xf + +static inline void +mii_page_set( + mii_t * mii, + uint8_t read, + uint8_t write, + uint8_t bank, + uint8_t end ) +{ + for (int i = bank; i <= end; i++) { + if (read != _SAME) + mii->mem[i].read = read; + if (write != _SAME) + mii->mem[i].write = write; + } +} + +static inline uint8_t +mii_sw( + mii_t *mii, + uint16_t sw) +{ + return mii_bank_peek(&mii->bank[MII_BANK_MAIN], sw); +} + +static void +mii_page_table_update( + mii_t *mii) +{ + if (!mii->mem_dirty) + return; + mii->mem_dirty = 0; + int altzp = mii_sw(mii, SWALTPZ); + int page2 = mii_sw(mii, SWPAGE2); + int store80 = mii_sw(mii, SW80STORE); + int hires = mii_sw(mii, SWHIRES); + int ramrd = mii_sw(mii, SWRAMRD); + int ramwrt = mii_sw(mii, SWRAMWRT); + int intcxrom = mii_sw(mii, SWINTCXROM); + int slotc3rom = mii_sw(mii, SWSLOTC3ROM); + + if (mii->trace_cpu) + printf("%04x: page table update altzp:%02x page2:%02x store80:%02x hires:%02x ramrd:%02x ramwrt:%02x intcxrom:%02x slotc3rom:%02x\n", + mii->cpu.PC, + altzp, page2, store80, hires, ramrd, ramwrt, intcxrom, slotc3rom); + // clean slate + mii_page_set(mii, MII_BANK_MAIN, MII_BANK_MAIN, 0x00, 0xc0); + mii_page_set(mii, MII_BANK_ROM, MII_BANK_ROM, 0xc1, 0xff); + if (altzp) + mii_page_set(mii, MII_BANK_AUX, MII_BANK_AUX, 0x00, 0x01); + mii_page_set(mii, + ramrd ? MII_BANK_AUX : MII_BANK_MAIN, + ramwrt ? MII_BANK_AUX : MII_BANK_MAIN, 0x02, 0xbf); + if (store80) { + mii_page_set(mii, + page2 ? MII_BANK_AUX : MII_BANK_MAIN, + page2 ? MII_BANK_AUX : MII_BANK_MAIN, 0x04, 0x07); + if (hires) + mii_page_set(mii, + page2 ? MII_BANK_AUX : MII_BANK_MAIN, + page2 ? MII_BANK_AUX : MII_BANK_MAIN, 0x20, 0x3f); + } + if (!intcxrom) + mii_page_set(mii, MII_BANK_CARD_ROM, _SAME, 0xc1, 0xc7); + mii_page_set(mii, + slotc3rom ? MII_BANK_CARD_ROM : MII_BANK_ROM, _SAME, 0xc3, 0xc3); + mii_page_set(mii, + mii->bsr_mode.read ? + altzp ? MII_BANK_AUX_BSR : MII_BANK_BSR : + MII_BANK_ROM, + mii->bsr_mode.write ? + altzp ? MII_BANK_AUX_BSR : MII_BANK_BSR : + MII_BANK_ROM, + 0xd0, 0xff); + // BSR P2 + mii_page_set(mii, + mii->bsr_mode.read ? + (altzp ? MII_BANK_AUX_BSR : MII_BANK_BSR) + + mii->bsr_mode.page2 : MII_BANK_ROM, + mii->bsr_mode.write ? + (altzp ? MII_BANK_AUX_BSR : MII_BANK_BSR) + + mii->bsr_mode.page2 : MII_BANK_ROM, + 0xd0, 0xdf); +} + +void +mii_set_sw_override( + mii_t *mii, + uint16_t sw_addr, + mii_bank_access_cb cb, + void *param) +{ + if (!mii->soft_switches_override) + mii->soft_switches_override = calloc(256, + sizeof(*mii->soft_switches_override)); + sw_addr &= 0xff; + mii->soft_switches_override[sw_addr].cb = cb; + mii->soft_switches_override[sw_addr].param = param; +} + +static bool +mii_access_soft_switches( + mii_t *mii, + uint16_t addr, + uint8_t * byte, + bool write) +{ + if (!(addr >= 0xc000 && addr <= 0xc0ff) || addr == 0xcfff) + return false; + bool res = false; + uint8_t on = 0; + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + + /* + * This allows driver (titan accelerator etc) to have their own + * soft switches, and override/supplement any default ones. + */ + if (mii->soft_switches_override && mii->soft_switches_override[addr & 0xff].cb) { + res = mii->soft_switches_override[addr & 0xff].cb( + main, mii->soft_switches_override[addr & 0xff].param, + addr, byte, write); + if (res) + return res; + } + switch (addr) { + case 0xc090 ... 0xc0ff: { + res = true; + int slot = ((addr >> 4) & 7) - 1; +#if 0 + printf("SLOT %d addr %04x write %d %02x drv %s\n", + slot, addr, write, *byte, + mii->slot[slot].drv ? mii->slot[slot].drv->name : "none"); +#endif + if (mii->slot[slot].drv) { + on = mii->slot[slot].drv->access(mii, + &mii->slot[slot], addr, *byte, write); + if (!write) + *byte = on; + } + } break; + case 0xc080 ... 0xc08f: { + res = true; + uint8_t mode = addr & 0x0f; + static const int write_modes[4] = { 0, 1, 0, 1, }; + static const int read_modes[4] = { 1, 0, 0, 1, }; + uint8_t rd = read_modes[mode & 3]; + uint8_t wr = write_modes[mode & 3]; + mii->bsr_mode.write = wr; + mii->bsr_mode.read = rd; + mii->bsr_mode.page2 = mode & 0x08 ? 0 : 1; + mii->mem_dirty = 1; + if (mii->trace_cpu) + printf("%04x: BSR mode addr %04x:%02x read:%s write:%s %s altzp:%02x\n", + mii->cpu.PC, addr, + mode, + rd ? "BSR" : "ROM", + wr ? "BSR" : "ROM", + mii->bsr_mode.page2 ? "page2" : "page1", + mii_sw(mii, SWALTPZ)); + } break; + case 0xcfff: + res = true; + mii->mem_dirty = 1; + printf("%s TODO reset SLOT roms\n", __func__); + break; + case SWPAGE2OFF: + case SWPAGE2ON: + res = true; + mii_bank_poke(main, SWPAGE2, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWHIRESOFF: + case SWHIRESON: + res = true; + mii_bank_poke(main, SWHIRES, (addr & 1) << 7); + mii->mem_dirty = 1; + // printf("HIRES %s\n", (addr & 1) ? "ON" : "OFF"); + break; + case SWSPEAKER: + res = true; + mii_speaker_click(&mii->speaker); + break; + case 0xc068: + res = true; + // IIgs register, read by prodos tho + break; + } + if (res && !mii->mem_dirty) + return res; + if (write) { + switch (addr) { + case SW80STOREOFF: + case SW80STOREON: + res = true; + mii_bank_poke(main, SW80STORE, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWRAMRDOFF: + case SWRAMRDON: + res = true; + mii_bank_poke(main, SWRAMRD, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWRAMWRTOFF: + case SWRAMWRTON: + res = true; + mii_bank_poke(main, SWRAMWRT, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWALTPZOFF: + case SWALTPZON: + res = true; + mii_bank_poke(main, SWALTPZ, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWINTCXROMOFF: + case SWINTCXROMON: + res = true; + mii_bank_poke(main, SWINTCXROM, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + case SWSLOTC3ROMOFF: + case SWSLOTC3ROMON: + res = true; + mii_bank_poke(main, SWSLOTC3ROM, (addr & 1) << 7); + mii->mem_dirty = 1; + break; + } + } else { + switch (addr) { + case SWBSRBANK2: + *byte = mii->bsr_mode.page2 ? 0x80 : 0; + res = true; + break; + case SWBSRREADRAM: + *byte = mii->bsr_mode.read ? 0x80 : 0; + res = true; + break; + case SWRAMRD: + case SWRAMWRT: + case SW80STORE: + case SWINTCXROM: + case SWALTPZ: + case SWSLOTC3ROM: + res = true; + *byte = mii_bank_peek(main, addr); + break; + case 0xc020: // toggle TAPE output ?!?! + case 0xc064: // Analog Input 0 (paddle 0) + case 0xc065: // Analog Input 1 (paddle 1) + case 0xc079: // Analog Input Reset + res = true; + break; + case 0xc068: + res = true; + // IIgs register, read by prodos tho + break; + } + } + if (!res) { + // printf("%s addr %04x write %d %02x\n", __func__, addr, write, *byte); + // mii->state = MII_STOPPED; + } + mii_page_table_update(mii); + return res; +} + +static bool +mii_access_keyboard( + mii_t *mii, + uint16_t addr, + uint8_t * byte, + bool write) +{ + bool res = false; + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + switch (addr) { + case SWKBD: + if (!write) { + /* If fifo not empty, peek at the next key to process, it already + * has the 0x80 bit on -- otherwise, return 0 */ + res = true; + #if 1 + *byte = mii_bank_peek(main, SWKBD); + #else + if (mii_key_fifo_isempty(&mii->keys)) + *byte = 0; + else + *byte = mii_key_fifo_read_at(&mii->keys, 0).key; + #endif + } + break; + case SWAKD: + res = true; +#if 1 + { + uint8_t r = mii_bank_peek(main, SWAKD); + if (!write) + *byte = r; + r &= 0x7f; + mii_bank_poke(main, SWAKD, r); + mii_bank_poke(main, SWKBD, r); + } +#else + // if (write) { + /* clear latch, and replace it immediately with the new key + * if there's one in the FIFO */ + if (!mii_key_fifo_isempty(&mii->keys)) { + mii_key_t k = mii_key_fifo_read(&mii->keys); + mii_bank_poke(main, SWAKD, k.key); + } else + mii_bank_poke(main, SWAKD, + mii_bank_peek(main, SWAKD) & ~0x80); + // } else + if (!write) + *byte = mii_bank_peek(main, SWAKD); +#endif + break; + case 0xc061 ... 0xc063: // Push Button 0, 1, 2 (Apple Keys) + res = true; + if (!write) + *byte = mii_bank_peek(main, addr); + break; + } + return res; +} + +void +mii_keypress( + mii_t *mii, + uint8_t key) +{ + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + key |= 0x80; + mii_bank_poke(main, SWAKD, key); + mii_bank_poke(main, SWKBD, key); +#if 0 + mii_key_t k = { + .key = key | 0x80, + }; + if (!mii_key_fifo_isfull(&mii->keys)) + mii_key_fifo_write(&mii->keys, k); + else { + printf("%s key fifo full\n", __func__); + } +#endif +} + + +void +mii_init( + mii_t *mii ) +{ + memset(mii, 0, sizeof(*mii)); + mii->speed = 1.0; + for (int i = 0; i < MII_BANK_COUNT; i++) + mii->bank[i] = _mii_banks_init[i]; + mii->bank[MII_BANK_ROM].mem = (uint8_t*)&iie_enhanced_rom_bin[0]; + mii->cpu.trap = MII_TRAP; + mii_reset(mii, true); + mii_speaker_init(mii, &mii->speaker); + mii->cpu_state = mii_cpu_init(&mii->cpu); + for (int i = 0; i < 7; i++) + mii->slot[i].id = i; +} + +void +mii_prepare( + mii_t *mii, + uint32_t flags ) +{ + printf("%s driver table\n", __func__); + mii_slot_drv_t * drv = mii_slot_drv_list; + while (drv) { + printf("%s driver: %s\n", __func__, drv->name); + if (drv->probe && drv->probe(mii, flags)) { + printf("%s %s probe done\n", __func__, drv->name); + } + drv = drv->next; + } +} + +void +mii_reset( + mii_t *mii, + bool cold) +{ +// printf("%s cold %d\n", __func__, cold); + mii->cpu_state.reset = 1; + mii->bsr_mode.write = 1; + mii->bsr_mode.read = 0; + mii->bsr_mode.page2 = 1; + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + mii_bank_poke(main, SWSLOTC3ROM, 0); + mii_bank_poke(main, SWRAMRD, 0); + mii_bank_poke(main, SWRAMWRT, 0); + mii_bank_poke(main, SWALTPZ, 0); + mii_bank_poke(main, SW80STORE, 0); + mii_bank_poke(main, SW80COL, 0); + mii->mem_dirty = 1; + if (cold) { + /* these HAS to be reset in that state somehow */ + mii_bank_poke(main, SWINTCXROM, 0); + uint8_t z[2] = {0x55,0x55}; + mii_bank_write(main, 0x3f2, z, 2); + } + mii->mem_dirty = 1; + mii_page_table_update(mii); + for (int i = 0; i < 7; i++) { + if (mii->slot[i].drv && mii->slot[i].drv->reset) + mii->slot[i].drv->reset(mii, &mii->slot[i]); + } +} + +void +mii_mem_access( + mii_t *mii, + uint16_t addr, + uint8_t * d, + bool wr, + bool do_sw) +{ + if (!do_sw && addr >= 0xc000 && addr <= 0xc0ff) + return; + uint8_t done = + mii_access_keyboard(mii, addr, d, wr) || + mii_access_video(mii, addr, d, wr) || + mii_access_soft_switches(mii, addr, d, wr); + if (!done) { + uint8_t page = addr >> 8; + if (wr) { + uint8_t m = mii->mem[page].write; + mii_bank_t * b = &mii->bank[m]; + if (b->ro) { + // printf("%s write to RO bank %s %04x:%02x\n", + // __func__, b->name, addr, *d); + } else + mii_bank_write(b, addr, d, 1); + } else { + uint8_t m = mii->mem[page].read; + mii_bank_t * b = &mii->bank[m]; + *d = mii_bank_peek(b, addr); + } + } +} + +static void +_mii_handle_trap( + mii_t *mii) +{ +// printf("%s TRAP hit PC: %04x\n", __func__, mii->cpu.PC); + mii->cpu_state.sync = 1; + mii->cpu_state.trap = 0; + mii->cpu.state = NULL; + uint8_t trap = mii_read_one(mii, mii->cpu.PC); + mii->cpu.PC += 1; +// printf("%s TRAP %02x return PC %04x\n", __func__, trap, mii->cpu.PC); + if (mii->trap.map & (1 << trap)) { + if (mii->trap.trap[trap].cb) + mii->trap.trap[trap].cb(mii, trap); + } else { + printf("%s TRAP %02x not handled\n", __func__, trap); + mii->state = MII_STOPPED; + } +// mii->state = MII_STOPPED; +} + +uint8_t +mii_register_trap( + mii_t *mii, + mii_trap_handler_cb cb) +{ + if (mii->trap.map == 0xffff) { + printf("%s no more traps!!\n", __func__); + return 0xff; + } + for (int i = 0; i < (int)sizeof(mii->trap.map) * 8; i++) { + if (!(mii->trap.map & (1 << i))) { + mii->trap.map |= 1 << i; + mii->trap.trap[i].cb = cb; + return i; + } + } + return 0xff; +} + +void +mii_run( + mii_t *mii) +{ + /* this runs all cycles for one instruction */ + do { + if (mii->trace_cpu) + mii_dump_trace_state(mii); + mii->cpu_state = mii_cpu_run(&mii->cpu, mii->cpu_state); + mii_video_run(mii); + mii_speaker_run(&mii->speaker); + // extract 16-bit address from pin mask + const uint16_t addr = mii->cpu_state.addr; + const uint8_t data = mii->cpu_state.data; + int wr = mii->cpu_state.w; + uint8_t d = data; + if (mii->debug.bp_map) { + for (int i = 0; i < (int)sizeof(mii->debug.bp_map) * 8; i++) { + if (!(mii->debug.bp_map & (1 << i))) + continue; + if (addr >= mii->debug.bp[i].addr && + addr < mii->debug.bp[i].addr + mii->debug.bp[i].size) { + if (((mii->debug.bp[i].kind & MII_BP_R) && !wr) || + ((mii->debug.bp[i].kind & MII_BP_W) && wr)) { + + if (1 || !mii->debug.bp[i].silent) { + printf("BREAKPOINT %d at %04x PC:%04x\n", + i, addr, mii->cpu.PC); + mii_dump_run_trace(mii); + mii_dump_trace_state(mii); + mii->state = MII_STOPPED; + } + } + if (!(mii->debug.bp[i].kind & MII_BP_STICKY)) + mii->debug.bp_map &= ~(1 << i); + mii->debug.bp[i].kind |= MII_BP_HIT; + } + } + } + mii_mem_access(mii, addr, &d, wr, true); + if (!wr) + mii->cpu_state.data = d; + if (mii->cpu_state.trap) { + _mii_handle_trap(mii); + } + } while (!(mii->cpu_state.sync)); + mii->cycles += mii->cpu.cycle; + // log PC for the running disassembler display + mii->trace.log[mii->trace.idx] = mii->cpu.PC; + mii->trace.idx = (mii->trace.idx + 1) & (MII_PC_LOG_SIZE - 1); + for (int i = 0; i < 7; i++) { + if (mii->slot[i].drv && mii->slot[i].drv->run) + mii->slot[i].drv->run(mii, &mii->slot[i]); + } +} + +//! Read one byte from and addres, using the current memory mapping +uint8_t +mii_read_one( + mii_t *mii, + uint16_t addr) +{ + uint8_t d = 0; + mii_mem_access(mii, addr, &d, 0, false); + return d; +} +//! Read a word from addr, using current memory mapping (little endian) +uint16_t +mii_read_word( + mii_t *mii, + uint16_t addr) +{ + uint8_t d = 0; + uint16_t res = 0; + mii_mem_access(mii, addr, &d, 0, false); + res = d; + mii_mem_access(mii, addr + 1, &d, 0, false); + res |= d << 8; + return res; +} +/* same accessors, for write + */ +void +mii_write_one( + mii_t *mii, + uint16_t addr, + uint8_t d) +{ + mii_mem_access(mii, addr, &d, 1, false); +} +void +mii_write_word( + mii_t *mii, + uint16_t addr, + uint16_t w) +{ + uint8_t d = w; + mii_mem_access(mii, addr, &d, 1, false); + d = w >> 8; + mii_mem_access(mii, addr + 1, &d, 1, false); +} diff --git a/src/mii.h b/src/mii.h new file mode 100644 index 0000000..b403a05 --- /dev/null +++ b/src/mii.h @@ -0,0 +1,274 @@ +/* + * mii.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +#pragma once + +#include +#include + +#include "mii_65c02.h" +#include "fifo_declare.h" +#include "mii_dd.h" +#include "mii_bank.h" +#include "mii_slot.h" +#include "mii_video.h" +#include "mii_speaker.h" +#include "mii_mouse.h" + +enum { + MII_BANK_MAIN = 0, // main 48K address space + MII_BANK_BSR, // 0xd000 - 0xffff bank switched RAM 16KB + MII_BANK_BSR_P2, // 0xd000 - 0xe000 bank switched RAM aux 4KB + + MII_BANK_AUX, // aux 48K address space (80 cols card) + MII_BANK_AUX_BSR, // 0xd000 - 0xffff bank switched RAM aux 16KB + MII_BANK_AUX_BSR_P2, // 0xd000 - 0xe000 bank switched RAM aux 4KB (aux bank) + + MII_BANK_ROM, // 0xc000 - 0xffff 16K ROM + MII_BANK_CARD_ROM, // 0xc100 - 0xcfff Card ROM access + MII_BANK_COUNT, +}; + + +typedef void (*mii_trap_handler_cb)( + mii_t * mii, + uint8_t trap); +typedef struct mii_trap_t { + uint16_t map; + struct { + mii_trap_handler_cb cb; + } trap[16]; +} mii_trap_t; + +// state of the emulator +enum { + MII_RUNNING = 0, // default + MII_STOPPED, + MII_STEP, +}; + +enum { + MII_BP_PC = (1 << 0), // breakpoint on PC + MII_BP_W = (1 << 1), // breakpoint on write + MII_BP_R = (1 << 2), // breakpoint on read + MII_BP_HIT = (1 << 3), // breakpoint was hit + MII_BP_SILENT = (1 << 4), // don't dump state (used for the 'next' command) + MII_BP_STICKY = (1 << 7), // breakpoint is sticky (rearms itself) +}; + +#define MII_PC_LOG_SIZE 16 + +/* + * this keeps track of the last few PC values, for the debugger + */ +typedef struct mii_trace_t { + uint16_t log[MII_PC_LOG_SIZE]; + uint8_t idx; + // when in MII_STEP, do not fall back to MII_STOPPED until these + // run out + uint32_t step_inst; +} mii_trace_t; + +/* + * principal emulator state, for a faceless emulation + */ +typedef struct mii_t { + unsigned int state; + __uint128_t cycles; + /* this is the video frame/VBL rate vs 60hz, default to 1.0 */ + float speed; + float speed_current; // calculated speed + mii_cpu_t cpu; + mii_cpu_state_t cpu_state; + /* + * bank index for each memory page number, this is recalculated + * everytime a soft switch is triggered + */ + struct { + uint8_t read : 4, write : 4; + } mem[256]; + int mem_dirty; // recalculate mem[] on next access + struct { + int write, read, page2; + } bsr_mode; + + mii_trace_t trace; + int trace_cpu; + mii_trap_t trap; + /* + * Used for debugging only + */ + struct { + uint16_t bp_map; + struct { + uint32_t kind : 8, + addr : 16, + size : 8, + silent : 1; + } bp[16]; + } debug; + mii_bank_t bank[MII_BANK_COUNT]; + // the page c000 can have individual callbacks to override/supplement + // existing default behaviour. This is currently used for the titan + // accelerator 'card' + mii_bank_access_t * soft_switches_override; + mii_slot_t slot[7]; + mii_video_t video; + mii_speaker_t speaker; + mii_mouse_t mouse; + mii_dd_system_t dd; +} mii_t; + +enum { + MII_INIT_NSC = (1 << 0), // Install no slot clock + MII_INIT_TITAN = (1 << 1), // Install Titan 'card' + MII_INIT_DEFAULT = MII_INIT_NSC, +}; + +/* + * Call this first, to initialize the emulator state + * This doesn't initializes any driver. + */ +void +mii_init( + mii_t *mii ); + +/* + * Call this to prepare the emulator, instantiate and install drivers + * etc. Presumably after you have used mii_argv_parse or loaded a config + * file to set up the drivers. + * flags is a combination of MII_INIT_* + */ +void +mii_prepare( + mii_t *mii, + uint32_t flags ); + +/* + * Parses arguments until in finds one that isn't for mii, and returns + * the index of that argument in *index. + * Return value is 0 if there's an argument that wasn't handled or 1 + * if all the arguments were parsed (and *index == argc) + * mii parameter is the state AFTER mii_init() has been called. + * + * ioFlags is a combination of MII_INIT_*, it will be updated with the + * flags found in the arguments. Pass this to mii_prepare() + */ +int +mii_argv_parse( + mii_t *mii, + int argc, + const char *argv[], + int *index, + uint32_t *ioFlags ); +/* + * Locate driver_name, and attempt to register it with slot_id slot. + * Returns 0 on success, -1 on failure + */ +int +mii_slot_drv_register( + mii_t *mii, + uint8_t slot_id, + const char *driver_name); +/* returns the driver registered for slot slot_id (or NULL) */ +mii_slot_drv_t * +mii_slot_drv_get( + mii_t *mii, + uint8_t slot_id); + +/* + * Reset the emulator, cold reset if cold is true, otherwise warm reset + */ +void +mii_reset( + mii_t *mii, + bool cold); +/* Execute one instruction, respecting breakpoints, runs the video code, + * Check for traps and other associated debug stuff. + */ +void +mii_run( + mii_t *mii); +// this one is thread safe, there's a FIFO behind it. +void +mii_keypress( + mii_t *mii, + uint8_t key); + +/* read a byte as the processor would (ex softwitches!), this will + * respect the status of slot ROMs, language card, 80 columns etc */ +uint8_t +mii_read_one( + mii_t *mii, + uint16_t addr); +/* write a byte as the processor would (ex softwitches!), this will + * respect the status of slot ROMs, language card, 80 columns etc */ +void +mii_write_one( + mii_t *mii, + uint16_t addr, + uint8_t d); +/* read a word as the processor would (ex softwitches!), this will + * respect the status of slot ROMs, language card, 80 columns etc */ +uint16_t +mii_read_word( + mii_t *mii, + uint16_t addr); +/* write a word as the processor would (ex softwitches!), this will + * respect the status of slot ROMs, language card, 80 columns etc */ +void +mii_write_word( + mii_t *mii, + uint16_t addr, + uint16_t w); + +/* lower level call to access memory -- this one can trigger softswitches + * if specified. Otherwise behaves as the previous ones, one byte at a time + */ +void +mii_mem_access( + mii_t *mii, + uint16_t addr, + uint8_t * byte, + bool write, + bool do_sw); +/* register a callback to call when a specific soft switches is hit, + * this allows overriding/supplementing/tracing access to sw. + */ +void +mii_set_sw_override( + mii_t *mii, + uint16_t sw_addr, + mii_bank_access_cb cb, + void *param); + +void +mii_dump_trace_state( + mii_t *mii); +void +mii_dump_run_trace( + mii_t *mii); + +extern mii_slot_drv_t * mii_slot_drv_list; + +#define MI_DRIVER_REGISTER(_mii_driver)\ + __attribute__((constructor,unused)) \ + static void _mii_register_##_mii_driver() { \ + _mii_driver.next = mii_slot_drv_list; \ + mii_slot_drv_list = &_mii_driver; \ + } + +#define MII_TRAP 0xdbfb +/* + * Request a trap ID for the given callback. Calling code is responsible + * for setting up the trap using the 2 magic NOPs in sequence. See mii_smartport.c + * for an example. + */ +uint8_t +mii_register_trap( + mii_t *mii, + mii_trap_handler_cb cb); diff --git a/src/mii_65c02.c b/src/mii_65c02.c new file mode 100644 index 0000000..53a9cff --- /dev/null +++ b/src/mii_65c02.c @@ -0,0 +1,581 @@ + +#include +#include +#include + +#include "minipt.h" +#include "mii_65c02.h" +#define MII_CPU_65C02_IMPL +#include "mii_65c02_ops.h" + +mii_cpu_state_t +mii_cpu_init( + mii_cpu_t *cpu ) +{ + mii_cpu_state_t s = { + .addr = 0, + .reset = 1, + }; + cpu->state = NULL; + return s; +} + +#define _FETCH(_val) { \ + s.addr = _val; s.w = 0; cpu->cycle++; \ + pt_yield(cpu->state); \ + } while (0); +#define _STORE(_addr, _val) { \ + s.addr = _addr; s.data = _val; s.w = 1; cpu->cycle++; \ + pt_yield(cpu->state); \ + } while (0); + +#define _SET_P(_byte) { \ + for (int _pi = 0; _pi < 8; _pi++) \ + cpu->P.P[_pi] = _pi == B_B || _pi == B_X || \ + ((_byte) & (1 << _pi)); \ + } +#define _NZC(_val) { \ + uint16_t v = (_val); \ + cpu->P.N = !!(v & 0x80); \ + cpu->P.Z = (v & 0xff) == 0; \ + cpu->P.C = !!(v & 0xff00); \ + } while (0) +#define _NZ(_val) { \ + uint16_t v = (_val); \ + cpu->P.N = !!(v & 0x80); \ + cpu->P.Z = (v & 0xff) == 0; \ + } while (0) +#define _C(_val) { \ + cpu->P.C = !!(_val); \ + } while (0) + +mii_cpu_state_t +mii_cpu_run( + mii_cpu_t *cpu, + mii_cpu_state_t s) +{ + mii_op_desc_t d = mii_cpu_op[cpu->IR].desc; + pt_start(cpu->state); +next_instruction: + if (s.reset) { + s.reset = 0; + _FETCH(0xfffc); cpu->_P = s.data; + _FETCH(0xfffd); cpu->_P |= s.data << 8; + cpu->PC = cpu->_P; + cpu->S = 0xFF; + _SET_P(0); + } + if (s.irq) { + s.irq = 0; + cpu->P.P[B_B] = cpu->IRQ == 2; + cpu->IRQ = 1; + cpu->_D = cpu->PC + 1; + _STORE(0x0100 | cpu->S--, cpu->_D >> 8); + _STORE(0x0100 | cpu->S--, cpu->_D & 0xff); + uint8_t p = 0; + for (int i = 0; i < 8; i++) + p |= (i == B_X || cpu->P.P[i]) << i; + _STORE(0x0100 | cpu->S--, p); + cpu->P.P[B_I] = 1; + } + if (cpu->IRQ) { + cpu->IRQ = 0; + _FETCH(0xfffe); cpu->_P = s.data; + _FETCH(0xffff); cpu->_P |= s.data << 8; + cpu->PC = cpu->_P; + } + s.sync = 1; + // we dont' reset the cycle here, that way calling code has a way of knowing + // how many cycles were used by the previous instruction + _FETCH(cpu->PC); + s.sync = 0; + cpu->cycle = 0; + cpu->PC++; + cpu->IR = s.data; + d = mii_cpu_op[cpu->IR].desc; + cpu->ir_log = (cpu->ir_log << 8) | cpu->IR; + s.trap = cpu->trap && (cpu->ir_log & 0xffff) == cpu->trap; + if (s.trap) + cpu->ir_log = 0; + switch (d.mode) { + case IMM: + _FETCH(cpu->PC++); cpu->_D = s.data; + break; + case BRANCH: // BEQ/BNE etc + case ZP_REL: // $(xx) + _FETCH(cpu->PC++); cpu->_P = s.data; + break; + case ZP_X: // $xx,X + _FETCH(cpu->PC++); cpu->_P = (s.data + cpu->X) & 0xff; + break; + case ZP_Y: // $xx,Y + _FETCH(cpu->PC++); cpu->_P = (s.data + cpu->Y) & 0xff; + break; + case ABS: { // $xxxx + _FETCH(cpu->PC++); cpu->_P = s.data; + _FETCH(cpu->PC++); cpu->_P |= s.data << 8; + } break; + case ABS_X: { // $xxxx,X + _FETCH(cpu->PC++); cpu->_P = s.data; + _FETCH(cpu->PC++); cpu->_P |= s.data << 8; + cpu->_P += cpu->X; + if ((cpu->_P & 0xff00) != (s.data << 8)) + cpu->cycle++; + } break; + case ABS_Y: { // $xxxx,Y + _FETCH(cpu->PC++); cpu->_P = s.data; + _FETCH(cpu->PC++); cpu->_P |= s.data << 8; + cpu->_P += cpu->Y; + if ((cpu->_P & 0xff00) != (s.data << 8)) + cpu->cycle++; + } break; + case IND_X: { // ($xx,X) + _FETCH(cpu->PC++); cpu->_D = s.data; + cpu->_D += cpu->X; + _FETCH(cpu->_D & 0xff); cpu->_P = s.data; + cpu->_D++; + _FETCH(cpu->_D & 0xff); cpu->_P |= s.data << 8; + } break; + case IND_Y: { // ($xx),Y + _FETCH(cpu->PC++); cpu->_D = s.data; + _FETCH(cpu->_D); cpu->_P = s.data; + _FETCH((cpu->_D + 1) & 0xff); + cpu->_P |= s.data << 8; + cpu->_P += cpu->Y; + } break; + case IND: { // ($xxxx) + _FETCH(cpu->PC++); cpu->_D = s.data; + _FETCH(cpu->PC++); cpu->_D |= s.data << 8; + _FETCH(cpu->_D); cpu->_P = s.data; + _FETCH(cpu->_D + 1); cpu->_P |= s.data << 8; + } break; + case IND_Z: { // ($xx) + _FETCH(cpu->PC++); cpu->_D = s.data; + _FETCH(cpu->_D); cpu->_P = s.data; + _FETCH(cpu->_D + 1); cpu->_P |= s.data << 8; + } break; + case IND_AX: { // ($xxxx,X) + _FETCH(cpu->PC++); cpu->_D = s.data; + _FETCH(cpu->PC++); cpu->_D |= s.data << 8; + cpu->_D += cpu->X; + if ((cpu->_D & 0xff00) != (s.data << 8)) + cpu->cycle++; + _FETCH(cpu->_D); cpu->_P = s.data; + _FETCH(cpu->_D + 1); cpu->_P |= s.data << 8; + } break; + } + if (d.r) { + _FETCH(cpu->_P); + cpu->_D = s.data; + } + switch (cpu->IR) { + case 0x69: case 0x65: case 0x75: case 0x6D: case 0x7D: + case 0x79: case 0x61: case 0x71: case 0x72: + { // ADC + // Handle adding in BCD with bit D + if (cpu->P.D) { + uint8_t lo = (cpu->A & 0x0f) + (cpu->_D & 0x0f) + !!cpu->P.C; + if (lo > 9) lo += 6; + uint8_t hi = (cpu->A >> 4) + (cpu->_D >> 4) + (lo > 0x0f); + cpu->P.Z = ((uint8_t)(cpu->A + cpu->_D + cpu->P.C)) == 0; + // that is 6502 behaviour +// cpu->P.N = !!(hi & 0xf8); + cpu->P.V = !!((!((cpu->A ^ cpu->_D) & 0x80) && + ((cpu->A ^ (hi << 4))) & 0x80)); + if (hi > 9) hi += 6; + cpu->P.C = hi > 15; + cpu->A = (hi << 4) | (lo & 0x0f); + // THAT is 65c02 behaviour + cpu->P.N = !!(cpu->A & 0x80); + } else { + uint16_t sum = cpu->A + cpu->_D + !!cpu->P.C; + cpu->P.V = cpu->P.C = 0; + if (~(cpu->A ^ cpu->_D) & (cpu->A ^ sum) & 0x80) + cpu->P.V = 1; + _NZC(sum); + cpu->A = sum; + } + } break; + case 0x29: case 0x25: case 0x35: case 0x2D: case 0x3D: + case 0x39: case 0x21: case 0x31: case 0x32: + { // AND + cpu->A &= cpu->_D; + _NZ(cpu->A); + } break; + case 0x0A: + { // ASL + cpu->P.C = !!(cpu->A & 0x80); + cpu->A <<= 1; + _NZ(cpu->A); + } break; + case 0x06: case 0x16: case 0x0E: case 0x1E: + { // ASL + cpu->P.C = !!(cpu->_D & 0x80); + cpu->_D <<= 1; + _NZ(cpu->_D); + } break; + case 0x0f: case 0x1f: case 0x2f: case 0x3f: case 0x4f: + case 0x5f: case 0x6f: case 0x7f: case 0x8f: case 0x9f: + case 0xaf: case 0xbf: case 0xcf: case 0xdf: case 0xef: + case 0xff: + { // BBR/BBS + _FETCH(cpu->PC++); // relative branch + if (((cpu->_D >> d.s_bit) & 1) == d.s_bit_value) { + cpu->_P = cpu->PC + (int8_t)cpu->_P; + if ((cpu->_P & 0xff00) != (cpu->PC & 0xff00)) + cpu->cycle++; + cpu->PC = cpu->_P; + cpu->cycle++; + } + } break; + case 0x90: case 0xB0: case 0xF0: case 0x30: + case 0xD0: case 0x10: case 0x50: case 0x70: + { // BCC, BCS, BEQ, BMI, BNE, BPL, BVC, BVS + if (d.s_bit_value == cpu->P.P[d.s_bit]) { + cpu->_P = cpu->PC + (int8_t)cpu->_P; + if ((cpu->_P & 0xff00) != (cpu->PC & 0xff00)) + cpu->cycle++; + cpu->PC = cpu->_P; + cpu->cycle++; + } + } break; + case 0x80: + { // BRA + cpu->PC = cpu->PC + (int8_t)cpu->_P; cpu->cycle++; + } break; + case 0x89: + { // BIT immediate -- does not change N & V! + cpu->P.Z = !(cpu->A & cpu->_D); + } break; + case 0x24: case 0x2C: case 0x34: case 0x3C: + { // BIT + cpu->P.Z = !(cpu->A & cpu->_D); + cpu->P.N = !!(cpu->_D & 0x80); + cpu->P.V = !!(cpu->_D & 0x40); + } break; + case 0x00: + { // BRK + s.irq = 1; + cpu->IRQ = 2; // IRQ interrupt + // cpu->P.P[B_D] = 0; // 65c02 clears this + } break; + case 0x18: case 0xD8: case 0x58: case 0xB8: + { // CLC, CLD, CLI, CLV + cpu->P.P[d.s_bit] = 0; + } break; + case 0xC9: case 0xC5: case 0xD5: case 0xCD: case 0xDD: + case 0xD9: case 0xC1: case 0xD1: case 0xD2: + { // CMP + cpu->P.C = !!(cpu->A >= cpu->_D); + uint8_t d = cpu->A - cpu->_D; + _NZ(d); + } break; + case 0xE0: case 0xE4: case 0xEC: + { // CPX + cpu->P.C = !!(cpu->X >= cpu->_D); + uint8_t d = cpu->X - cpu->_D; + _NZ(d); + } break; + case 0xC0: case 0xC4: case 0xCC: + { // CPY + cpu->P.C = !!(cpu->Y >= cpu->_D); + uint8_t d = cpu->Y - cpu->_D; + _NZ(d); + } break; + case 0x3A: + { // DEC + _NZ(--cpu->A); + } break; + case 0xC6: case 0xD6: case 0xCE: case 0xDE: + { // DEC + _NZ(--cpu->_D); + } break; + case 0xCA: + { // DEX + _NZ(--cpu->X); + } break; + case 0x88: + { // DEY + _NZ(--cpu->Y); + } break; + case 0x49: case 0x45: case 0x55: case 0x4D: case 0x5D: + case 0x59: case 0x41: case 0x51: case 0x52: + { // EOR + cpu->A ^= cpu->_D; + _NZ(cpu->A); + } break; + case 0x1A: + { // INC + _NZ(++cpu->A); + } break; + case 0xE6: case 0xF6: case 0xEE: case 0xFE: + { // INC + _NZ(++cpu->_D); + } break; + case 0xE8: + { // INX + _NZ(++cpu->X); + } break; + case 0xC8: + { // INY + _NZ(++cpu->Y); + } break; + case 0x4C: case 0x6C: case 0x7C: + { // JMP + cpu->PC = cpu->_P; + } break; + case 0x20: + { // JSR + cpu->_D = cpu->PC - 1; + _STORE(0x0100 | cpu->S--, cpu->_D >> 8); + _STORE(0x0100 | cpu->S--, cpu->_D & 0xff); + cpu->PC = cpu->_P; + } break; + case 0xA9: case 0xA5: case 0xB5: case 0xAD: case 0xBD: + case 0xB9: case 0xA1: case 0xB1: case 0xB2: + { // LDA + cpu->A = cpu->_D; + _NZ(cpu->A); + } break; + case 0xA2: case 0xA6: case 0xB6: case 0xAE: case 0xBE: + { // LDX + cpu->X = cpu->_D; + _NZ(cpu->X); + } break; + case 0xA0: case 0xA4: case 0xB4: case 0xAC: case 0xBC: + { // LDY + cpu->Y = cpu->_D; + _NZ(cpu->Y); + } break; + case 0x4A: + { // LSR + cpu->P.C = !!(cpu->A & 0x01); + cpu->A >>= 1; + _NZ(cpu->A); + } break; + case 0x46: case 0x56: case 0x4E: case 0x5E: + { // LSR + cpu->P.C = !!(cpu->_D & 0x01); + cpu->_D >>= 1; + _NZ(cpu->_D); + } break; + case 0xEA: + { // NOP + } break; + case 0x09: case 0x05: case 0x15: case 0x0D: case 0x1D: + case 0x19: case 0x01: case 0x11: case 0x12: + { // ORA + cpu->A |= cpu->_D; + _NZ(cpu->A); + } break; + case 0x48: + { // PHA + _STORE(0x0100 | cpu->S--, cpu->A); cpu->cycle++; + } break; + case 0x08: + { // PHP + uint8_t p = 0; + for (int i = 0; i < 8; i++) + p |= (i == B_X || cpu->P.P[i]) << i; + p |= (1 << B_B); + _STORE(0x0100 | cpu->S--, p); cpu->cycle++; + } break; + case 0xDA: + { // PHX + _STORE(0x0100 | cpu->S--, cpu->X);cpu->cycle++; + } break; + case 0x5A: + { // PHY + _STORE(0x0100 | cpu->S--, cpu->Y);cpu->cycle++; + } break; + case 0x68: + { // PLA + _FETCH(0x0100 | ++cpu->S);cpu->cycle++; + cpu->A = s.data;cpu->cycle++; + _NZ(cpu->A); + } break; + case 0x28: + { // PLP + _FETCH(0x0100 | ++cpu->S);cpu->cycle++; + _SET_P(s.data);cpu->cycle++; + } break; + case 0xFA: + { // PLX + _FETCH(0x0100 | ++cpu->S); + cpu->X = s.data; + _NZ(cpu->X); + } break; + case 0x7A: + { // PLY + _FETCH(0x0100 | ++cpu->S); + cpu->Y = s.data; + _NZ(cpu->Y); + } break; + case 0x2A: + { // ROL + uint8_t c = cpu->P.C; + cpu->P.C = !!(cpu->A & 0x80); + cpu->A <<= 1; + cpu->A |= c; + _NZ(cpu->A); + } break; + case 0x26: case 0x36: case 0x2E: case 0x3E: + { // ROL + uint8_t c = cpu->P.C; + cpu->P.C = !!(cpu->_D & 0x80); + cpu->_D <<= 1; + cpu->_D |= c; + _NZ(cpu->_D); + } break; + case 0x6A: + { // ROR + uint8_t c = cpu->P.C; + cpu->P.C = !!(cpu->A & 0x01); + cpu->A >>= 1; + cpu->A |= c << 7; + _NZ(cpu->A); + } break; + case 0x66: case 0x76: case 0x6E: case 0x7E: + { // ROR + uint8_t c = cpu->P.C; + cpu->P.C = !!(cpu->_D & 0x01); + cpu->_D >>= 1; + cpu->_D |= c << 7; + _NZ(cpu->_D); + } break; + case 0x40: + { // RTI + _FETCH(0x0100 | ((++cpu->S) & 0xff)); + for (int i = 0; i < 8; i++) + cpu->P.P[i] = i == B_B || (s.data & (1 << i)); + cpu->P._R = 1; + _FETCH(0x0100 | ((++cpu->S) & 0xff)); + cpu->_P = s.data; + _FETCH(0x0100 | ((++cpu->S) & 0xff)); + cpu->_P = (s.data << 8) | (cpu->_P ); + cpu->PC = cpu->_P; + } break; + case 0x60: + { // RTS + _FETCH(0x0100 | ((++cpu->S) & 0xff));cpu->cycle++; + cpu->_P = s.data; + _FETCH(0x0100 | ((++cpu->S) & 0xff));cpu->cycle++; + cpu->_P |= s.data << 8; + cpu->PC = cpu->_P + 1; cpu->cycle++; + } break; + case 0xE9: case 0xE5: case 0xF5: case 0xED: case 0xFD: + case 0xF9: case 0xE1: case 0xF1: case 0xF2: + { // SBC + // Handle subbing in BCD with bit D + if (cpu->P.D) { + uint8_t lo = (cpu->A & 0x0f) - (cpu->_D & 0x0f) - !cpu->P.C; + if (lo & 0x10) lo -= 6; + uint8_t hi = (cpu->A >> 4) - (cpu->_D >> 4) - (lo & 0x10); + if (hi & 0x10) hi -= 6; + cpu->P.Z = ((uint8_t)(cpu->A - cpu->_D - !cpu->P.C)) == 0; + cpu->P.N = !!(hi & 0x8); + cpu->P.V = !!(((cpu->A ^ cpu->_D) & + ((cpu->A ^ (hi << 4))) & 0x80)); + cpu->P.C = !(hi & 0x10); + cpu->A = (hi << 4) | (lo & 0x0f); + } else { + cpu->_D = (~cpu->_D) & 0xff; + uint16_t sum = cpu->A + cpu->_D + !!cpu->P.C; + cpu->P.V = cpu->P.C = 0; + if (~(cpu->A ^ cpu->_D) & (cpu->A ^ sum) & 0x80) + cpu->P.V = 1; + _NZC(sum); + cpu->A = sum; + } + } break; + case 0x38: case 0xF8: case 0x78: + { // SEC, SED, SEI + cpu->P.P[d.s_bit] = 1; + } break; + case 0x85: case 0x95: case 0x8D: case 0x9D: + case 0x99: case 0x81: case 0x91: case 0x92: + { // STA + cpu->_D = cpu->A; + } break; + case 0x86: case 0x96: case 0x8E: + { // STX + cpu->_D = cpu->X; + } break; + case 0x84: case 0x94: case 0x8C: + { // STY + cpu->_D = cpu->Y; + } break; + case 0x64: case 0x74: case 0x9C: case 0x9E: + { // STZ + cpu->_D = 0; + } break; + case 0x14: case 0x1c: + { // TRB + cpu->P.Z = !(cpu->A & cpu->_D); + cpu->_D &= ~cpu->A; + } break; + case 0x04: case 0x0c: + { // TSB + cpu->P.Z = !(cpu->A & cpu->_D); + cpu->_D |= cpu->A; + } break; + case 0xAA: + { // TAX + cpu->X = cpu->A; + _NZ(cpu->X); + } break; + case 0xA8: + { // TAY + cpu->Y = cpu->A; + _NZ(cpu->Y); + } break; + case 0xBA: + { // TSX + cpu->X = cpu->S; + _NZ(cpu->X); + } break; + case 0x8A: + { // TXA + cpu->A = cpu->X; + _NZ(cpu->A); + } break; + case 0x9A: + { // TXS + cpu->S = cpu->X; + } break; + case 0x98: + { // TYA + cpu->A = cpu->Y; + _NZ(cpu->A); + } break; + case 0x07: case 0x17: case 0x27: case 0x37: case 0x47: + case 0x57: case 0x67: case 0x77: case 0x87: case 0x97: + case 0xA7: case 0xB7: case 0xC7: case 0xD7: case 0xE7: + case 0xF7: + { // RMB/SMB + cpu->_D = (cpu->_D & ~(1 << d.s_bit)) | (d.s_bit_value << d.s_bit); + } break; + /* Apparently these NOPs use 3 bytes, according to the tests */ + case 0x5c: case 0xdc: case 0xfc: + _FETCH(cpu->PC++); + /* Apparently these NOPs use 2 bytes, according to the tests */ + case 0x02: case 0x22: case 0x42: case 0x62: case 0x82: + case 0xC2: case 0xE2: case 0x44: case 0x54: case 0xD4: + case 0xF4: + _FETCH(cpu->PC++); // consume that byte + break; + case 0xdb: case 0xfb: + // trap NOPs + break; + default: + printf("%04x %02x UNKNOWN INSTRUCTION\n", cpu->PC, cpu->IR); + // exit(1); + break; + } + if (d.w) { + _STORE(cpu->_P, cpu->_D); + } + goto next_instruction; + pt_end(cpu->state); + return s; +} diff --git a/src/mii_65c02.h b/src/mii_65c02.h new file mode 100644 index 0000000..7d370b7 --- /dev/null +++ b/src/mii_65c02.h @@ -0,0 +1,88 @@ +#pragma once + +#include + +/* + * State structure used to 'talk' to the CPU emulator. + * It works like this: + * mii_cpu_state_t s = { .reset = 1 }; + * do { + * s = mii_cpu_run(cpu, s); + * if (s.w) + * write_memory(s.addr, s.data); + * else + * s.data = read_memory(s.addr); + * } while (1); + * s.sync will be 1 when we are fetching a new instruction + * s.reset will be 1 when the CPU is in reset (fetching vector) + * will turn to zero when done + * You check then the cpu->cycle to know what cycle you're in the current + * instruction. + * + * If you want to 'jump' to a new PC, you need to + * s.addr = new_pc; + * s.sync = 1; + * this will stop the current instruction and start fetching at new_pc + * + */ +typedef union mii_cpu_state_t { + struct { + uint32_t addr : 16, + data : 8, + w : 1, + sync : 1, + reset : 1, + irq : 1, + nmi : 1, + trap : 1; + }; + uint32_t raw; +} mii_cpu_state_t; + +/* CPU state machine */ +typedef struct mii_cpu_t { + uint8_t A, X, Y, S; + /* internal 16bit registers for fetch etc + * _D is the 'data' register, used for 16bit operations + * _P is the 'pointer' register, used for 16bit addressing + * This is not set hard in stone, but typically addressing modes that + * are 'indirect' and load from memory will set _P and read in _D + * so the opcode doesn't have to handle s.data at all */ + uint16_t _D, _P; + /* My experience with simavr shows that maintaining a 8 bits bitfield + * for a status register is a lot slower than having discrete flags + * and 'constructing' the matching 8 biots register when needed */ + union { + struct { + uint8_t C, Z, I, D, B, _R, V, N; + }; + uint8_t P[8]; + } P; + uint16_t PC; + uint8_t IR; + uint8_t IRQ; // IRQ (0) or NMI (1) or BRK (2) + uint8_t cycle; // for current instruction + /* State of the CPU state machine */ + void * state; + + /* sequence of instruction that will trigger a trap flag. + * this is used to trigger 'call backs' to the main code + * typically use a pair of NOPs sequence that is unlikely to exist in + * real code. */ + uint16_t trap; + // last 4 instructions, as a shift register, used for traps or debug + uint32_t ir_log; + + /* Debug only; the callback is called every cycles, with the current + * state of the cpu. */ + uint8_t * ram; // DEBUG +} mii_cpu_t; + +mii_cpu_state_t +mii_cpu_init( + mii_cpu_t *cpu ); + +mii_cpu_state_t +mii_cpu_run( + mii_cpu_t *cpu, + mii_cpu_state_t s); diff --git a/src/mii_65c02_asm.c b/src/mii_65c02_asm.c new file mode 100644 index 0000000..c31cf61 --- /dev/null +++ b/src/mii_65c02_asm.c @@ -0,0 +1,503 @@ +/* + * mii_65c02_asm.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii_65c02.h" +#include "mii_65c02_ops.h" +#include "mii_65c02_asm.h" + +static char * +_mii_extract_token( + char *position, + char *dst, + int dst_len) +{ + if (!position) + return NULL; + while (*position == ' ' || *position == '\t') + position++; + char *kw = strsep(&position, " \t"); + if (kw) + strncpy(dst, kw, dst_len); + return position; +} + + +static char * +_mii_extract_name( + char *src, + char *dst, + int dst_len) +{ + char *end = src; + while (isalnum(*end) || *end == '_') + *dst++ = *end++; + *dst = 0; + return end; +} + +static char * +_mii_extract_value_or_name( + mii_cpu_asm_line_t *l, + char *src) +{ + static const char * const hex = "0123456789abcdef"; + char *end = src; + l->op_value = 0; + if (*end == '<') { + l->op_low = 1; + end++; + } else if (*end == '>') { + l->op_high = 1; + end++; + } + if (*end == '$') { + end++; + while (isxdigit(*end)) + l->op_value = (l->op_value << 4) + + (strchr(hex, tolower(*end++)) - hex); + } else if (isdigit(*end)) { + while (isdigit(*end)) + l->op_value = (l->op_value << 4) + + (strchr(hex, tolower(*end++)) - hex); + } else { + end = _mii_extract_name(end, l->op_name, sizeof(l->op_name)); + l->label_resolved = 0; + } + return end; +} + +static int +_mii_resolve_symbol( + mii_cpu_asm_program_t *p, + mii_cpu_asm_line_t *l, + int optional) +{ + if (!l->op_name[0] || l->label_resolved) + return 1; + mii_cpu_asm_line_t *l2 = p->sym; + while (l2) { + if (!strcasecmp(l->op_name, l2->label)) { + l->op_value = l2->op_value; + l->label_resolved = 1; + goto found; + } + l2 = l2->sym_next; + } + if (!optional) + printf("%s symbol %s not found\n", __func__, l->op_name); + return 0; +found: + if (l->op_low) + l->op_value &= 0xff; + else if (l->op_high) + l->op_value >>= 8; + return 1; +} + +void +mii_cpu_asm_load( + mii_cpu_asm_program_t *p, + const char *prog) +{ + const char *current = prog; + int line_count = 0; + do { + const char *lend = strchr(current, '\n'); + int len = lend ? (int)(lend - current) : (int)strlen(current); + + mii_cpu_asm_line_t *l = calloc(1, sizeof(mii_cpu_asm_line_t) + len + 1); + l->line_index = line_count++; + sprintf(l->line, "%.*s", len, current); + if (p->prog_tail) { + p->prog_tail->next = l; + p->prog_tail = l; + } else { + p->prog = p->prog_tail = l; + } + char *dup = strdup(l->line); + char * comment = strrchr(dup, ';'); + if (comment) + *comment = 0; + if (!*dup) { + goto next_line; + } + char * position = dup; + if (position[0] != ' ' && position[0] != '\t') { + char *start = position; + char *kw = strsep(&position, " \t="); + if (kw) { + // strip spaces + char *ke = kw + strlen(kw); + while (ke > start && (ke[-1] <= ' ' || ke[-1] == ':')) + *--ke = 0; + strncpy(l->label, kw, sizeof(l->label)-1); + } + } + position = _mii_extract_token(position, l->mnemonic, sizeof(l->mnemonic)); + + if (!strcmp(l->mnemonic, ".db") || !strcmp(l->mnemonic, "byte")) { + /* remaining of the line is comma separated hex values OR symbols + * that can be resolved immediately */ + char *kw = position; + while (*kw == ' ' || *kw == '\t') kw++; + char *cur = kw; + while ((cur = strsep(&kw, ",")) != NULL) { + while (*cur == ' ' || *cur == '\t') cur++; + char *ke = cur + strlen(cur); + while (ke > cur && (ke[-1] <= ' ' || ke[-1] == ':')) + *--ke = 0; + if (!*cur) + break; + _mii_extract_value_or_name(l, cur); + if (_mii_resolve_symbol(p, l, 0) == 0) + printf("ERROR -- sorry code symbols don't work, just EQUs\n"); + else + l->opcodes[l->opcode_count++] = l->op_value; + } + goto next_line; + } + position = _mii_extract_token(position, l->operand, sizeof(l->operand)); + if (l->operand[0] == '.' || l->operand[0] == '=') { + // a directive that has been not aligned on the first line, re-adjust + snprintf(l->label, sizeof(l->label), "%s", l->mnemonic); + snprintf(l->mnemonic, sizeof(l->mnemonic), "%s", l->operand); + position = _mii_extract_token(position, l->operand, sizeof(l->operand)); + } + if (l->mnemonic[0] == '=' || + !strcasecmp(l->mnemonic, "equ") || + !strcasecmp(l->mnemonic, ".equ")) { + l->symbol = 1; + if (p->sym_tail) + p->sym_tail->sym_next = l; + else + p->sym = l; + _mii_extract_value_or_name(l, l->operand); + if (_mii_resolve_symbol(p, l, 0) == 0) + printf("ERROR -- sorry code symbols don't work, just EQUs\n"); + } + // printf(">L:%s M:%s O:%s\n", l->label, l->mnemonic, l->operand); +next_line: + free(dup); + current = lend ? lend+1 : NULL; + } while (current); + +} + + +static int +mii_cpu_opcode_has_mode( + const char *mnemonic, + int mode) +{ + for (int i = 0; i < 256; i++) { + if (!strncasecmp(mnemonic, mii_cpu_op[i].name, 4)) { + if (mode == mii_cpu_op[i].desc.mode) { + return i; + } + } + } + return -1; +} + +static int +_mii_cpu_asm_parse_operand( + mii_cpu_asm_program_t *p, + mii_cpu_asm_line_t *l) +{ + l->mode = IMPLIED; + if (!l->operand[0]) + return 0; + + char sep = 0; // (parenthesis) + char *src = l->operand; + switch (*src) { + case '#': + l->mode = IMM; + src = _mii_extract_value_or_name(l, src + 1); + break; + case '$': + l->mode = ABS; + src = _mii_extract_value_or_name(l, src); + break; + case '(': + l->mode = IND; + sep = ')'; + src = _mii_extract_value_or_name(l, src + 1); + break; + default: { + l->mode = ABS; + src = _mii_extract_value_or_name(l, src); + _mii_resolve_symbol(p, l, 1); + } break; + } + while (*src == ' ' || *src == '\t') src++; + switch (*src) { + case ',': + src++; + while (*src == ' ' || *src == '\t') src++; + switch (tolower(*src)) { + case 'x': + l->mode = ABS_X; + if (sep) { + // special case for JMP ($xxxx,x) + if (!strcasecmp(l->mnemonic, "JMP")) + l->mode = IND_AX; + else + l->mode = IND_X; + break; + } + break; + case 'y': + l->mode = ABS_Y; + break; + default: + l->mode = ABS; + break; + } + break; + case ')': + src++; + switch (*src) { + case ',': + src++; + while (*src == ' ' || *src == '\t') src++; + switch (tolower(*src)) { + case 'x': + l->mode = IND_X; + break; + default: + l->mode = IND_Y; + break; + } + break; + default: + l->mode = IND; + break; + } + break; + } + switch (l->mode) { + case ABS: { + if (l->op_value < 0x100) { + int newo = mii_cpu_opcode_has_mode(l->mnemonic, ZP_REL); + if (newo != -1) { + l->mode = ZP_REL; + l->opcodes[0] = mii_cpu_op[newo].desc.op; + l->opcode_count = mii_cpu_op[newo].desc.pc; + } + } + } break; + case ABS_X: { + if (l->op_value < 0x100) { + int newo = mii_cpu_opcode_has_mode(l->mnemonic, ZP_X); + if (newo != -1) { + l->mode = ZP_X; + l->opcodes[0] = mii_cpu_op[newo].desc.op; + l->opcode_count = mii_cpu_op[newo].desc.pc; + } + } + } break; + case ABS_Y: { + if (l->op_value < 0x100) { + int newo = mii_cpu_opcode_has_mode(l->mnemonic, ZP_Y); + if (newo != -1) { + l->mode = ZP_Y; + l->opcodes[0] = mii_cpu_op[newo].desc.op; + l->opcode_count = mii_cpu_op[newo].desc.pc; + } + } + } break; + case IND: if (1) { + if (l->op_value < 0x100) { + // printf("Testing if IND opcode %s can be IND_Z operand %s (%04x)\n", + // l->mnemonic, l->operand, l->op_value); + int newo = mii_cpu_opcode_has_mode(l->mnemonic, IND_Z); + if (newo != -1) { + // printf("YES replace %02x with %02x\n", + // l->opcodes[0], newo); + l->mode = IND_Z; + l->opcodes[0] = mii_cpu_op[newo].desc.op; + l->opcode_count = mii_cpu_op[newo].desc.pc; + } + } + } break; + } + return 0; +} + +int +mii_cpu_asm_assemble( + mii_cpu_asm_program_t *p ) +{ + mii_cpu_asm_line_t *l = p->prog; + int error = 0; + + // fix symbols + l = p->sym; + while (l) { + _mii_extract_value_or_name(l, l->operand); + // printf("SYM %s = %04x\n", l->label, l->op_value); + l = l->sym_next; + } + l = p->prog; + while (l) { + if (!l->mnemonic[0] || l->symbol) { + l = l->next; + continue; + } + l->mode = IMPLIED; + _mii_cpu_asm_parse_operand(p, l); + if (!strcasecmp(l->mnemonic, ".org")) { + if (p->verbose) + printf("%s origin set to $%04x\n", __func__, l->op_value); + if (l->mode == ABS) { + if (!p->org) + p->org = l->op_value; + l->addr_set = 1; + l->addr = l->op_value; + } + l = l->next; + continue; + } else if (!strcasecmp(l->mnemonic, ".verbose")) { + p->verbose = 1; + l = l->next; + continue; + } else if (l->mnemonic[0] == '.') { + l = l->next; + continue; + } + int found = -1; + for (int i = 0; i < 256; i++) { + if (!strncasecmp(l->mnemonic, mii_cpu_op[i].name, 4)) { + if (mii_cpu_op[i].desc.branch) { + l->mode = mii_cpu_op[i].desc.mode; + found = i; + break; + } else if (l->mode == mii_cpu_op[i].desc.mode) { + found = i; + break; + } + } + } + if (found == -1) { + printf("ERROR: %d: %s %s %s\n", + l->line_index, l->label, l->mnemonic, l->operand); + printf(" Missing opcode for %s %d\n", l->mnemonic, l->mode); + error = 1; + break; + } + // printf("FOUND %02x for '%s' '%s' '%s' name:'%s'\n", + // found, l->label, l->mnemonic, l->operand, l->op_name); + l->opcodes[0] = mii_cpu_op[found].desc.op; + l->opcode_count = mii_cpu_op[found].desc.pc; + l = l->next; + } + if (error) + return error; + uint16_t pc = p->org; + /* + * We (should) know all instruction size by now, so lets sets + * the addresses for all the lines + */ + l = p->prog; + while (l) { + if (l->addr_set) + pc = l->addr; + else + l->addr = pc; + if (l->mnemonic[0] != '.') { + // this sets the ones we know about, and clears the ones we dont + for (int i = 1; i < l->opcode_count; i++) + l->opcodes[i] = l->op_value >> (8 * (i - 1)); + } + pc += l->opcode_count; + l = l->next; + } + /* + * Now resolve all the operand labels + */ + l = p->prog; + while (l) { + if (l->op_name[0] && !l->label_resolved) { + mii_cpu_asm_line_t *l2 = p->prog; + while (l2) { + int32_t value = 0; + if (!strcasecmp(l->op_name, l2->label)) { + value = l2->op_value; + if (!l2->symbol) + value = l2->addr; + else + value = l2->op_value; + l->op_value = value; + l->label_resolved = 1; + if (mii_cpu_op[l->opcodes[0]].desc.branch) + l->op_value = l2->addr - l->addr - 2; + else if (l->op_low) + l->op_value &= 0xff; + else if (l->op_high) + l->op_value >>= 8; + for (int i = 1; i < l->opcode_count; i++) + l->opcodes[i] = l->op_value >> (8 * (i - 1)); + break; + } + l2 = l2->next; + } + if (!l->label_resolved) { + printf("ERROR: Missing label %d: %s %s %s\n", + l->line_index, l->label, l->mnemonic, l->operand); + error = 1; + break; + } + } + l = l->next; + } + if (error) + return error; + p->output_len = p->prog_tail->addr + p->prog_tail->opcode_count - p->org; + if (p->verbose) + printf("%s program at $%04x size %d bytes\n", __func__, + p->org, p->output_len); + p->output = calloc(1, p->output_len); + l = p->prog; + while (l) { + for (int i = 0; i < l->opcode_count; i++) + p->output[l->addr - p->org + i] = l->opcodes[i]; + l = l->next; + } + return error; +} + +int +mii_cpu_asm( + mii_cpu_asm_program_t *p, + const char *prog) +{ + mii_cpu_asm_load(p, prog); + + return mii_cpu_asm_assemble(p); +} + +void +mii_cpu_asm_free( + mii_cpu_asm_program_t *p) +{ + mii_cpu_asm_line_t *l = p->prog; + while (l) { + mii_cpu_asm_line_t *next = l->next; + free(l); + l = next; + } + if (p->output) + free(p->output); + memset(p, 0, sizeof(*p)); +} diff --git a/src/mii_65c02_asm.h b/src/mii_65c02_asm.h new file mode 100644 index 0000000..72b7dec --- /dev/null +++ b/src/mii_65c02_asm.h @@ -0,0 +1,47 @@ +#pragma once + +#include + + +typedef struct mii_cpu_asm_line_t { + struct mii_cpu_asm_line_t *next; + struct mii_cpu_asm_line_t *sym_next; + uint16_t line_index; + uint8_t symbol : 1, + label_resolved : 1, + addr_set : 1, op_low : 1, op_high : 1; + uint16_t addr; // address of the instruction (if resolved) + uint8_t mode; // mode of the instruction + uint8_t opcode_count; // number of bytes for the opcode + uint8_t opcodes[32]; // or .byte statements + + char label[64]; + char mnemonic[64]; + char operand[64]; + + char op_name[64]; + int op_value; + + char line[]; // actual line read ends up here, untouched +} mii_cpu_asm_line_t; + +typedef struct mii_cpu_asm_program_t { + uint8_t verbose; + uint16_t org; // origin, can be set before, or with .org + mii_cpu_asm_line_t *sym; + mii_cpu_asm_line_t *sym_tail; + + mii_cpu_asm_line_t *prog; + mii_cpu_asm_line_t *prog_tail; + + uint8_t * output; + uint16_t output_len; +} mii_cpu_asm_program_t; + +int +mii_cpu_asm( + mii_cpu_asm_program_t *p, + const char *prog); +void +mii_cpu_asm_free( + mii_cpu_asm_program_t *p); diff --git a/src/mii_65c02_disasm.c b/src/mii_65c02_disasm.c new file mode 100644 index 0000000..703c70f --- /dev/null +++ b/src/mii_65c02_disasm.c @@ -0,0 +1,124 @@ + +#include +#include +#include +#include "mii_65c02.h" +#include "mii_65c02_ops.h" +#include "mii_65c02_disasm.h" + +int +mii_cpu_disasm_one( + const uint8_t *prog, + uint16_t addr, + char *out, + size_t out_len, + uint16_t flags) +{ + uint16_t pc = addr; + int i = 0; + + uint8_t op = prog[i]; + mii_op_desc_t d = mii_cpu_op[op].desc; + if (!d.pc) + d.pc = 1; + *out = 0; + int len = out_len; + if (flags & MII_DUMP_DIS_PC) + len -= snprintf(out + strlen(out), len, "%04X: ", pc + i); + if (flags & MII_DUMP_DIS_DUMP_HEX) { + char hex[32] = {0}; + for (int oi = 0; oi < d.pc; oi++) + sprintf(hex + (oi * 3), "%02X ", prog[i + oi]); + len -= snprintf(out + strlen(out), len, "%-9s ", hex); + } + len -= snprintf(out + strlen(out), len, "%.4s ", + mii_cpu_op[op].name[0] ? + mii_cpu_op[op].name : "???"); + i++; + switch (d.mode) { + case IMM: + len -= snprintf(out + strlen(out), len, + "#$%02X", prog[i++]); + break; + case BRANCH: + case ZP_REL: + if ((op & 0xf) == 0xf) { + uint16_t base = pc + i + 1; + uint16_t dest = base + (int8_t)prog[i++]; + len -= snprintf(out + strlen(out), len, + "%d,$%04X", d.s_bit, dest); + } else if (d.branch) { + uint16_t base = pc + i + 1; + uint16_t dest = base + (int8_t)prog[i++]; + len -= snprintf(out + strlen(out), len, + "$%04X", dest); + } else + len -= snprintf(out + strlen(out), len, + "$%02X", prog[i++]); + break; + case ZP_X: + len -= snprintf(out + strlen(out), len, + "$%02X,X", prog[i++]); + break; + case ZP_Y: + len -= snprintf(out + strlen(out), len, + "$%02X,Y", prog[i++]); + break; + case ABS: + len -= snprintf(out + strlen(out), len, + "$%02X%02X", prog[i + 1], prog[i]); + i += 2; + break; + case ABS_X: + len -= snprintf(out + strlen(out), len, + "$%02X%02X,X", prog[i + 1], prog[i]); + i += 2; + break; + case ABS_Y: + len -= snprintf(out + strlen(out), len, + "$%02X%02X,Y", prog[i + 1], prog[i]); + i += 2; + break; + case IND_X: + len -= snprintf(out + strlen(out), len, + "($%02X,X)", prog[i++]); + break; + case IND_AX: + len -= snprintf(out + strlen(out), len, + "($%02X%02X,X)", prog[i + 1], prog[i]); + i += 2; + break; + case IND_Y: + len -= snprintf(out + strlen(out), len, + "($%02X),Y", prog[i++]); + break; + case IND_Z: + len -= snprintf(out + strlen(out), len, + "($%02X)", prog[i++]); + break; + case IND: + len -= snprintf(out + strlen(out), len, + "($%02X%02X)", prog[i + 1], prog[i]); + i += 2; + break; + case IMPLIED: + break; + } + return d.pc; +} + +void +mii_cpu_disasm( + const uint8_t *prog, + uint16_t addr, + uint16_t len) +{ + uint16_t pc = addr; + int i = 0; + while (i < len) { + char out[256] = {0}; + i += mii_cpu_disasm_one(prog + i, pc + i, out, sizeof(out), + MII_DUMP_DIS_PC | MII_DUMP_DIS_DUMP_HEX); + printf("%s\n", out); + } +} diff --git a/src/mii_65c02_disasm.h b/src/mii_65c02_disasm.h new file mode 100644 index 0000000..f32fa9e --- /dev/null +++ b/src/mii_65c02_disasm.h @@ -0,0 +1,24 @@ +#pragma once + +#include + + +enum { + MII_DUMP_DIS_PC = (1 << 0), + MII_DUMP_DIS_DUMP_HEX = (1 << 1), +}; + + +int +mii_cpu_disasm_one( + const uint8_t *prog, + uint16_t addr, + char *out, + size_t out_len, + uint16_t flags); + +void +mii_cpu_disasm( + const uint8_t *prog, + uint16_t addr, + uint16_t len); diff --git a/src/mii_65c02_ops.h b/src/mii_65c02_ops.h new file mode 100644 index 0000000..a66a418 --- /dev/null +++ b/src/mii_65c02_ops.h @@ -0,0 +1,308 @@ +#pragma once + +#include + +typedef struct mii_op_desc_t { + uint32_t op : 8, + mode : 4, + pc : 2, + branch : 1, // relative branch + ch_pc : 1, // change PC + s_bit : 3, + s_bit_value : 1, + r : 1, + w : 1; +} mii_op_desc_t; + +typedef struct mii_op_t { + char name[4]; + mii_op_desc_t desc; +} mii_op_t; + +enum { + B_C = 0, + B_Z, + B_I, + B_D, + B_B, + B_X, + B_V, + B_N, +}; + +enum { + IMPLIED, // BRK + IMM, // LDA #$01 + ZP_REL, // LDA $C0 or BCC $FF + ZP_X, // LDA $C0,X + ZP_Y, // LDX $C0,Y + ABS, // LDA $1234 + ABS_X, // LDA $1234,X + ABS_Y, // LDA $1234,Y + IND_X, // LDA ($FF,X) + IND_AX, // JMP ($1234,X) + IND_Y, // LDA ($FF),Y + IND, // JMP ($1234) + IND_Z, // LDA ($C0) + BRANCH, // BEQ/BNE etc +}; + +#define PCODE_(_name, _mode, _op, _pc, _r, _w, _br, _sb, _sv, _cpc) \ + [_op] = { \ + .name = #_name, \ + .desc = { \ + .op = _op, .mode = _mode, .pc = _pc, .r = _r, .w = _w, \ + .branch = _br, .s_bit = _sb, .s_bit_value = _sv, .ch_pc = _cpc } \ + }, + +#ifndef MII_CPU_65C02_IMPL +extern const mii_op_t mii_cpu_op[256]; + +#else // MII_CPU_65C02_IMPL + +#define PCODE_R_(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 1, 0, 0, 0, 0, 0) +#define PCODE__W(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 0, 1, 0, 0, 0, 0) + +#define PCODE___(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 0, 0, 0, 0, 0, 0) + +#define PCODE_RW(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 1, 1, 0, 0, 0, 0) +#define PCODE__W(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 0, 1, 0, 0, 0, 0) + +#define PCODE_BR(_name, _op, _pc, _sb, _sv) \ + PCODE_(_name, BRANCH, _op, _pc, 0, 0, 1, B_##_sb, _sv, 1) +#define PCODE_PC(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 1, 0, 0, 0, 0, 1) +#define PCODE_RT(_name, _mode, _op, _pc) \ + PCODE_(_name, _mode, _op, _pc, 0, 0, 0, 0, 0, 1) + +#define PCODE_SB(_name, _mode, _op, _pc, _sb, _sv) \ + PCODE_(_name, _mode, _op, _pc, 0, 0, 0, B_##_sb, _sv, 0) +// for RMBx SMBx +#define PCODE_MB(_name, _op, _sb, _sv) \ + PCODE_(_name, ZP_REL, _op, 2, 1, 1, 0, _sb, _sv, 0) +// for BBRx BBSx +#define PCODE_BB(_name, _op, _sb, _sv) \ + PCODE_(_name, ZP_REL, _op, 3, 1, 0, 1, _sb, _sv, 0) + +const mii_op_t mii_cpu_op[256] = { + PCODE___(ADC, IMM, 0x69, 2) + PCODE_R_(ADC, ZP_REL, 0x65, 2) + PCODE_R_(ADC, ZP_X, 0x75, 2) + PCODE_R_(ADC, ABS, 0x6D, 3) + PCODE_R_(ADC, ABS_X, 0x7D, 3) + PCODE_R_(ADC, ABS_Y, 0x79, 3) + PCODE_R_(ADC, IND_X, 0x61, 2) + PCODE_R_(ADC, IND_Y, 0x71, 2) + PCODE_R_(ADC, IND_Z, 0x72, 2) + PCODE___(AND, IMM, 0x29, 2) + PCODE_R_(AND, ZP_REL, 0x25, 2) + PCODE_R_(AND, ZP_X, 0x35, 2) + PCODE_R_(AND, ABS, 0x2D, 3) + PCODE_R_(AND, ABS_X, 0x3D, 3) + PCODE_R_(AND, ABS_Y, 0x39, 3) + PCODE_R_(AND, IND_X, 0x21, 2) + PCODE_R_(AND, IND_Y, 0x31, 2) + PCODE_R_(AND, IND_Z, 0x32, 2) + PCODE___(ASL, IMPLIED, 0x0A, 1) + PCODE_RW(ASL, ZP_REL, 0x06, 2) + PCODE_RW(ASL, ZP_X, 0x16, 2) + PCODE_RW(ASL, ABS, 0x0E, 3) + PCODE_RW(ASL, ABS_X, 0x1E, 3) + PCODE_BB(BBR0, 0x0F, 0, 0) + PCODE_BB(BBR1, 0x1F, 1, 0) + PCODE_BB(BBR2, 0x2F, 2, 0) + PCODE_BB(BBR3, 0x3F, 3, 0) + PCODE_BB(BBR4, 0x4F, 4, 0) + PCODE_BB(BBR5, 0x5F, 5, 0) + PCODE_BB(BBR6, 0x6F, 6, 0) + PCODE_BB(BBR7, 0x7F, 7, 0) + PCODE_BB(BBS0, 0x8F, 0, 1) + PCODE_BB(BBS1, 0x9F, 1, 1) + PCODE_BB(BBS2, 0xAF, 2, 1) + PCODE_BB(BBS3, 0xBF, 3, 1) + PCODE_BB(BBS4, 0xCF, 4, 1) + PCODE_BB(BBS5, 0xDF, 5, 1) + PCODE_BB(BBS6, 0xEF, 6, 1) + PCODE_BB(BBS7, 0xFF, 7, 1) + PCODE_BR(BCC, 0x90, 2, C, 0) + PCODE_BR(BCS, 0xB0, 2, C, 1) + PCODE_BR(BEQ, 0xF0, 2, Z, 1) + PCODE_BR(BMI, 0x30, 2, N, 1) + PCODE_BR(BNE, 0xD0, 2, Z, 0) + PCODE_BR(BPL, 0x10, 2, N, 0) + PCODE_BR(BVC, 0x50, 2, V, 0) + PCODE_BR(BVS, 0x70, 2, V, 1) + PCODE_BR(BRA, 0x80, 2, X, 1) + PCODE_R_(BIT, ZP_REL, 0x24, 2) + PCODE_R_(BIT, ABS, 0x2C, 3) + PCODE___(BIT, IMM, 0x89, 2) + PCODE_R_(BIT, ZP_X, 0x34, 2) + PCODE_R_(BIT, ABS_X, 0x3C, 3) + PCODE_RT(BRK, IMPLIED, 0x00, 1) + PCODE_SB(CLC, IMPLIED, 0x18, 1, C, 0) + PCODE_SB(CLD, IMPLIED, 0xD8, 1, D, 0) + PCODE_SB(CLI, IMPLIED, 0x58, 1, I, 0) + PCODE_SB(CLV, IMPLIED, 0xB8, 1, V, 0) + PCODE___(CMP, IMM, 0xC9, 2) + PCODE_R_(CMP, ZP_REL, 0xC5, 2) + PCODE_R_(CMP, ZP_X, 0xD5, 2) + PCODE_R_(CMP, ABS_X, 0xDD, 3) + PCODE_R_(CMP, ABS, 0xCD, 3) + PCODE_R_(CMP, ABS_Y, 0xD9, 3) + PCODE_R_(CMP, IND_X, 0xC1, 2) + PCODE_R_(CMP, IND_Y, 0xD1, 2) + PCODE_R_(CMP, IND_Z, 0xD2, 2) + PCODE___(CPX, IMM, 0xE0, 2) + PCODE_R_(CPX, ZP_REL, 0xE4, 2) + PCODE_R_(CPX, ABS, 0xEC, 3) + PCODE___(CPY, IMM, 0xC0, 2) + PCODE_R_(CPY, ZP_REL, 0xC4, 2) + PCODE_R_(CPY, ABS, 0xCC, 3) + PCODE___(DEC, IMPLIED, 0x3A, 1) + PCODE_RW(DEC, ZP_REL, 0xC6, 2) + PCODE_RW(DEC, ZP_X, 0xD6, 2) + PCODE_RW(DEC, ABS, 0xCE, 3) + PCODE_RW(DEC, ABS_X, 0xDE, 3) + PCODE___(DEX, IMPLIED, 0xCA, 1) + PCODE___(DEY, IMPLIED, 0x88, 1) + PCODE___(EOR, IMM, 0x49, 2) + PCODE_R_(EOR, ZP_REL, 0x45, 2) + PCODE_R_(EOR, ZP_X, 0x55, 2) + PCODE_R_(EOR, ABS, 0x4D, 3) + PCODE_R_(EOR, ABS_X, 0x5D, 3) + PCODE_R_(EOR, ABS_Y, 0x59, 3) + PCODE_R_(EOR, IND_X, 0x41, 2) + PCODE_R_(EOR, IND_Y, 0x51, 2) + PCODE_R_(EOR, IND_Z, 0x52, 2) + PCODE___(INC, IMPLIED, 0x1A, 1) + PCODE_RW(INC, ZP_REL, 0xE6, 2) + PCODE_RW(INC, ZP_X, 0xF6, 2) + PCODE_RW(INC, ABS, 0xEE, 3) + PCODE_RW(INC, ABS_X, 0xFE, 3) + PCODE___(INX, IMPLIED, 0xE8, 1) + PCODE___(INY, IMPLIED, 0xC8, 1) + PCODE_PC(JMP, ABS, 0x4C, 3) + PCODE_PC(JMP, IND, 0x6C, 3) + PCODE_PC(JMP, IND_AX, 0x7C, 3) + PCODE_PC(JSR, ABS, 0x20, 3) + PCODE___(LDA, IMM, 0xA9, 2) + PCODE_R_(LDA, ZP_REL, 0xA5, 2) + PCODE_R_(LDA, ZP_X, 0xB5, 2) + PCODE_R_(LDA, ABS, 0xAD, 3) + PCODE_R_(LDA, ABS_X, 0xBD, 3) + PCODE_R_(LDA, ABS_Y, 0xB9, 3) + PCODE_R_(LDA, IND_X, 0xA1, 2) + PCODE_R_(LDA, IND_Y, 0xB1, 2) + PCODE_R_(LDA, IND_Z, 0xB2, 2) + PCODE___(LDX, IMM, 0xA2, 2) + PCODE_R_(LDX, ZP_REL, 0xA6, 2) + PCODE_R_(LDX, ZP_Y, 0xB6, 2) + PCODE_R_(LDX, ABS, 0xAE, 3) + PCODE_R_(LDX, ABS_Y, 0xBE, 3) + PCODE___(LDY, IMM, 0xA0, 2) + PCODE_R_(LDY, ZP_REL, 0xA4, 2) + PCODE_R_(LDY, ZP_X, 0xB4, 2) + PCODE_R_(LDY, ABS, 0xAC, 3) + PCODE_R_(LDY, ABS_X, 0xBC, 3) + PCODE___(LSR, IMPLIED, 0x4A, 1) + PCODE_RW(LSR, ZP_REL, 0x46, 2) + PCODE_RW(LSR, ZP_X, 0x56, 2) + PCODE_RW(LSR, ABS, 0x4E, 3) + PCODE_RW(LSR, ABS_X, 0x5E, 3) + PCODE___(NOP, IMPLIED, 0xEA, 1) + PCODE___(ORA, IMM, 0x09, 2) + PCODE_R_(ORA, ZP_REL, 0x05, 2) + PCODE_R_(ORA, ZP_X, 0x15, 2) + PCODE_R_(ORA, ABS, 0x0D, 3) + PCODE_R_(ORA, ABS_X, 0x1D, 3) + PCODE_R_(ORA, ABS_Y, 0x19, 3) + PCODE_R_(ORA, IND_X, 0x01, 2) + PCODE_R_(ORA, IND_Y, 0x11, 2) + PCODE_R_(ORA, IND_Z, 0x12, 2) + PCODE___(PHA, IMPLIED, 0x48, 1) + PCODE___(PHP, IMPLIED, 0x08, 1) + PCODE___(PHX, IMPLIED, 0xDA, 1) + PCODE___(PHY, IMPLIED, 0x5A, 1) + PCODE___(PLA, IMPLIED, 0x68, 1) + PCODE___(PLP, IMPLIED, 0x28, 1) + PCODE___(PLX, IMPLIED, 0xFA, 1) + PCODE___(PLY, IMPLIED, 0x7A, 1) + // these fill the opcode name without terminating zero + PCODE_MB(RMB0, 0x07, 0, 0) + PCODE_MB(RMB1, 0x17, 1, 0) + PCODE_MB(RMB2, 0x27, 2, 0) + PCODE_MB(RMB3, 0x37, 3, 0) + PCODE_MB(RMB4, 0x47, 4, 0) + PCODE_MB(RMB5, 0x57, 5, 0) + PCODE_MB(RMB6, 0x67, 6, 0) + PCODE_MB(RMB7, 0x77, 7, 0) + PCODE___(ROL, IMPLIED, 0x2A, 1) + PCODE_RW(ROL, ZP_REL, 0x26, 2) + PCODE_RW(ROL, ZP_X, 0x36, 2) + PCODE_RW(ROL, ABS, 0x2E, 3) + PCODE_RW(ROL, ABS_X, 0x3E, 3) + PCODE___(ROR, IMPLIED, 0x6A, 1) + PCODE_RW(ROR, ZP_REL, 0x66, 2) + PCODE_RW(ROR, ZP_X, 0x76, 2) + PCODE_RW(ROR, ABS, 0x6E, 3) + PCODE_RW(ROR, ABS_X, 0x7E, 3) + PCODE_RT(RTI, IMPLIED, 0x40, 1) + PCODE_RT(RTS, IMPLIED, 0x60, 1) + PCODE___(SBC, IMM, 0xE9, 2) + PCODE_R_(SBC, ZP_REL, 0xE5, 2) + PCODE_R_(SBC, ZP_X, 0xF5, 2) + PCODE_R_(SBC, ABS, 0xED, 3) + PCODE_R_(SBC, ABS_X, 0xFD, 3) + PCODE_R_(SBC, ABS_Y, 0xF9, 3) + PCODE_R_(SBC, IND_X, 0xE1, 2) + PCODE_R_(SBC, IND_Y, 0xF1, 2) + PCODE_R_(SBC, IND_Z, 0xF2, 2) + PCODE_SB(SEC, IMPLIED, 0x38, 1, C, 1) + PCODE_SB(SED, IMPLIED, 0xF8, 1, D, 1) + PCODE_SB(SEI, IMPLIED, 0x78, 1, I, 1) + // these fill the opcode name without terminating zero + PCODE_MB(SMB0, 0x87, 0, 1) + PCODE_MB(SMB1, 0x97, 1, 1) + PCODE_MB(SMB2, 0xa7, 2, 1) + PCODE_MB(SMB3, 0xb7, 3, 1) + PCODE_MB(SMB4, 0xc7, 4, 1) + PCODE_MB(SMB5, 0xd7, 5, 1) + PCODE_MB(SMB6, 0xe7, 6, 1) + PCODE_MB(SMB7, 0xf7, 7, 1) + PCODE__W(STA, ZP_REL, 0x85, 2) + PCODE__W(STA, ZP_X, 0x95, 2) + PCODE__W(STA, ABS, 0x8D, 3) + PCODE__W(STA, ABS_X, 0x9D, 3) + PCODE__W(STA, ABS_Y, 0x99, 3) + PCODE__W(STA, IND_X, 0x81, 2) + PCODE__W(STA, IND_Y, 0x91, 2) + PCODE__W(STA, IND_Z, 0x92, 2) + PCODE__W(STX, ZP_REL, 0x86, 2) + PCODE__W(STX, ZP_Y, 0x96, 2) + PCODE__W(STX, ABS, 0x8E, 3) + PCODE__W(STY, ZP_REL, 0x84, 2) + PCODE__W(STY, ZP_X, 0x94, 2) + PCODE__W(STY, ABS, 0x8C, 3) + PCODE__W(STZ, ZP_REL, 0x64, 2) + PCODE__W(STZ, ZP_X, 0x74, 2) + PCODE__W(STZ, ABS, 0x9C, 3) + PCODE__W(STZ, ABS_X, 0x9E, 3) + PCODE___(TAX, IMPLIED, 0xAA, 1) + PCODE___(TAY, IMPLIED, 0xA8, 1) + PCODE_RW(TRB, ZP_REL, 0x14, 2) + PCODE_RW(TRB, ABS, 0x1c, 3) + PCODE___(TSX, IMPLIED, 0xBA, 1) + PCODE_RW(TSB, ZP_REL, 0x04, 2) + PCODE_RW(TSB, ABS, 0x0c, 3) + PCODE___(TXA, IMPLIED, 0x8A, 1) + PCODE___(TXS, IMPLIED, 0x9A, 1) + PCODE___(TYA, IMPLIED, 0x98, 1) +}; + + +#endif // MII_CPU_65C02_IMPL diff --git a/src/mii_argv.c b/src/mii_argv.c new file mode 100644 index 0000000..514c208 --- /dev/null +++ b/src/mii_argv.c @@ -0,0 +1,199 @@ +/* + * mii_argv.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" + +extern mii_slot_drv_t * mii_slot_drv_list; + +static void +_mii_usage( + const char *progname) +{ + printf("Usage: %s [options]\n", progname); + printf("Options:\n"); + printf(" -h, --help\tThis help\n"); + printf(" -v, --verbose\tVerbose output\n"); + printf(" -m, --mute\tMute the speaker\n"); + printf(" -vol, --volume \tSet speaker volume (0.0 to 10.0)\n"); + printf(" -speed, --speed \tSet the CPU speed in MHz\n"); + printf(" -s, --slot :\tSpecify a slot and driver\n"); + printf("\t\tSlot id is 1..7\n"); + printf(" -d, --drive ::\tLoad a drive\n"); + printf("\t\tSlot id is 1..7, drive is 1..2\n"); + printf("\t\tAlternate syntax: : \n"); + printf(" -L, --list-drivers\tList available drivers, exit\n"); + printf(" -def, --default\tUse a set of default cards:\n"); + printf("\t\tSlot 4: mouse\n"); + printf("\t\tSlot 6: disk2\n"); + printf("\t\tSlot 7: smartport\n"); + printf(" -nsc[=0|1]\tEnable/Disable No Slot Clock:\n"); + printf("\t\t0: disable\n"); + printf("\t\t1: enable [Enabled by default]\n"); + printf(" -titan[=0|1]\tEnable/Disable Titan Accelerator IIe:\n"); + printf("\t\t0: disable [default]\n"); + printf("\t\t1: enable [Start at 3.58MHz]\n"); +} + +int +mii_argv_parse( + mii_t *mii, + int argc, + const char *argv[], + int *index, + uint32_t *ioFlags) +{ + if (*index == 0) + *index += 1; + for (int i = *index; i < argc; i++) { + const char *arg = argv[i]; + + if (!strcmp(arg, "-h") || !strcmp(arg, "--help")) { + _mii_usage(argv[0]); + exit(0); + } else if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose")) { + // mii->verbose++; + // continue; + } else if ((!strcmp(arg, "-s") || !strcmp(arg, "--slot")) && i < argc-1) { + // for mat for slot is 1..8: where name is the driver name + const char *p = argv[++i]; + int slot = 0; + char *drv = NULL; + if (sscanf(p, "%d:%ms", &slot, &drv) != 2) { + printf("mii: invalid slot specification %s\n", p); + return 1; + } + if (slot < 1 || slot > 8) { + printf("mii: invalid slot number %d\n", slot); + return 1; + } + if (drv == NULL) { + printf("mii: missing driver name for slot %d\n", slot); + return 1; + } + if (mii_slot_drv_register(mii, slot, drv) < 0) { + printf("mii: failed to register driver %s for slot %d\n", drv, slot); + return 1; + } + } else if ((!strcmp(arg, "-d") || !strcmp(arg, "--drive")) && i < argc-1) { + // drive takes 2 following arguments, the : and a filename + const char *p = argv[++i]; + int slot = 0; + int drive = 0; + const char *filename = NULL; + int got = sscanf(p, "%d:%d:%ms", &slot, &drive, &filename); + if (got == 2) { + if (i < argc-1) { + filename = argv[++i]; + got = 3; + } else { + printf("mii: missing filename for drive %d:%d\n", slot, drive); + return 1; + } + } else if (got != 3) { + printf("mii: invalid drive specification %s\n", p); + return 1; + } + if (slot < 1 || slot > 8) { + printf("mii: invalid slot number %d\n", slot); + return 1; + } + if (drive < 1 || drive > 2) { + printf("mii: invalid drive number %d\n", drive); + return 1; + } + if (filename == NULL) { + printf("mii: missing filename for drive %d:%d\n", slot, drive); + return 1; + } + mii_slot_command(mii, slot, + MII_SLOT_DRIVE_LOAD + drive - 1, + (void*)filename); + } else if (!strcmp(arg, "-def") || !strcmp(arg, "--default")) { + mii_slot_drv_register(mii, 4, "mouse"); + mii_slot_drv_register(mii, 6, "disk2"); + mii_slot_drv_register(mii, 7, "smartport"); + } else if (!strcmp(arg, "-L") || !strcmp(arg, "--list-drivers")) { + mii_slot_drv_t * drv = mii_slot_drv_list; + printf("mii: available drivers:\n"); + while (drv) { + printf("%10.10s - %s\n", drv->name, drv->desc); + drv = drv->next; + } + exit(0); + } else if (!strcmp(arg, "-m") || !strcmp(arg, "--mute")) { + mii->speaker.muted = true; + } else if (!strcmp(arg, "-vol") || !strcmp(arg, "--volume")) { + if (i < argc-1) { + float vol = atof(argv[++i]); + if (vol < 0) vol = 0; + else if (vol > 10) vol = 10; + mii_speaker_volume(&mii->speaker, vol); + } else { + printf("mii: missing volume value\n"); + return 1; + } + } else if (!strcmp(arg, "-speed") || !strcmp(arg, "--speed")) { + if (i < argc-1) { + mii->speed = atof(argv[++i]); + if (mii->speed < 0.0) + mii->speed = 1.0; + } else { + printf("mii: missing speed value\n"); + return 1; + } + } else { + if (argv[i][0] == '-') { + char dup[128]; + snprintf(dup, sizeof(dup), "%s", argv[i] + 1); + char *equal = dup; + char *name = strsep(&equal, "="); + int enable = 1; + if (equal && *equal) { + if (!strcmp(equal, "0")) + enable = 0; + else if (!strcmp(equal, "1")) + enable = 1; + else { + printf("mii: invalid flag %s\n", argv[i]); + return 1; + } + } + // printf("%s lookup driver %s to %s\n", __func__, + // name, enable ? "enable" : "disable"); + mii_slot_drv_t * drv = mii_slot_drv_list; + int done = 0; + while (drv) { + printf("%10.10s - %s\n", drv->name, drv->desc); + if (drv->enable_flag) { + if (!strcmp(name, drv->name)) { + *ioFlags = (*ioFlags & ~drv->enable_flag) | + (enable ? drv->enable_flag : 0); + printf("mii: %s %s\n", name, enable ? "enabled" : "disabled"); + break; + } + } + drv = drv->next; + } + if (!done && equal) { + printf("mii: no driver found %s\n", argv[i]); + return 1; + } + continue; + } + printf("mii: unknown argument %s\n", argv[i]); + return 1; + } + } + *index = argc; + return 1; +} \ No newline at end of file diff --git a/src/mii_bank.c b/src/mii_bank.c new file mode 100644 index 0000000..51fcf9c --- /dev/null +++ b/src/mii_bank.c @@ -0,0 +1,105 @@ +/* + * mii_bank.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" + + +void +mii_bank_write( + mii_bank_t *bank, + uint16_t addr, + const uint8_t *data, + uint16_t len) +{ + if ((addr < bank->base) || + ((addr + len) > (uint32_t)(bank->base + (bank->size * 256)))) { + printf("%s %s INVALID write addr %04x len %d %04x:%04x\n", + __func__, bank->name, addr, (int)len, + bank->base, bank->base + (bank->size * 256)); + return; + } + uint8_t page_index = (addr - bank->base) >> 8; + if (bank->access && bank->access[page_index].cb) { + if (bank->access[page_index].cb(bank, bank->access[page_index].param, + addr, (uint8_t *)data, true)) + return; + } + if (!bank->mem) { + bank->alloc = 1; + bank->mem = calloc(1, bank->size * 256); + } + addr -= bank->base; + for (uint16_t i = 0; i < len; i++, addr++) { + bank->mem[addr] = data[i]; + } +} + +void +mii_bank_read( + mii_bank_t *bank, + uint16_t addr, + uint8_t *data, + uint16_t len) +{ + if (addr < bank->base || + (addr + len) > (uint32_t)(bank->base + (bank->size * 256))) { + printf("%s %s INVALID read addr %04x len %d %04x-%04x\n", + __func__, bank->name, addr, (int)len, + bank->base, bank->base + (bank->size * 256)); + return; + } + uint8_t page_index = (addr - bank->base) >> 8; + if (bank->access && bank->access[page_index].cb) { + if (bank->access[page_index].cb(bank, bank->access[page_index].param, + addr, data, false)) + return; + } + if (!bank->mem) { + bank->alloc = 1; + bank->mem = calloc(1, bank->size * 256); + } + addr -= bank->base; + for (uint16_t i = 0; i < len; i++, addr++) { + data[i] = bank->mem[addr]; + } +} + + +void +mii_bank_install_access_cb( + mii_bank_t *bank, + mii_bank_access_cb cb, + void *param, + uint8_t page, + uint8_t end) +{ + if (!end) + end = page; + if ((page << 8) < bank->base || (end << 8) > (bank->base + bank->size * 256)) { + printf("%s %s INVALID install access cb %p param %p page %02x-%02x\n", + __func__, bank->name, cb, param, page, end); + return; + } + page -= bank->base >> 8; + end -= bank->base >> 8; + if (!bank->access) { + bank->access = calloc(1, bank->size * sizeof(bank->access[0])); + } + printf("%s %s install access cb page %02x:%02x\n", + __func__, bank->name, page, end); + for (int i = page; i <= end; i++) { + bank->access[i].cb = cb; + bank->access[i].param = param; + } +} diff --git a/src/mii_bank.h b/src/mii_bank.h new file mode 100644 index 0000000..4c7c509 --- /dev/null +++ b/src/mii_bank.h @@ -0,0 +1,81 @@ +/* + * mii_bank.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once +#include +#include + +struct mii_bank_t; +typedef bool (*mii_bank_access_cb)( + struct mii_bank_t *bank, + void *param, + uint16_t addr, + uint8_t * byte, + bool write); + +typedef struct mii_bank_access_t { + mii_bank_access_cb cb; + void *param; +} mii_bank_access_t; + +typedef struct mii_bank_t { + uint64_t base : 16, // base address + size : 9, // in pages + alloc : 1, // been calloced() + ro : 1; // read only + char * name; + mii_bank_access_t * access; + uint8_t *mem; +} mii_bank_t; + +void +mii_bank_write( + mii_bank_t *bank, + uint16_t addr, + const uint8_t *data, + uint16_t len); +void +mii_bank_read( + mii_bank_t *bank, + uint16_t addr, + uint8_t *data, + uint16_t len); + +/* return the number of pages dirty (written into since last time) between + * addr1 and addr2 (inclusive) */ +uint8_t +mii_bank_is_dirty( + mii_bank_t *bank, + uint16_t addr1, + uint16_t addr2); +void +mii_bank_install_access_cb( + mii_bank_t *bank, + mii_bank_access_cb cb, + void *param, + uint8_t page, + uint8_t end); + +static inline void +mii_bank_poke( + mii_bank_t *bank, + uint16_t addr, + const uint8_t data) +{ + mii_bank_write(bank, addr, &data, 1); +} + +static inline uint8_t +mii_bank_peek( + mii_bank_t *bank, + uint16_t addr) +{ + uint8_t res = 0; + mii_bank_read(bank, addr, &res, 1); + return res; +} diff --git a/src/mii_slot.c b/src/mii_slot.c new file mode 100644 index 0000000..eeaa785 --- /dev/null +++ b/src/mii_slot.c @@ -0,0 +1,86 @@ +/* + * mii_slot.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +#include +#include +#include +#include + +#include "mii.h" + +mii_slot_drv_t * +mii_slot_drv_find( + mii_t *mii, + const char * name) +{ + mii_slot_drv_t * drv = mii_slot_drv_list; + while (drv) { + if (!strcmp(drv->name, name)) + return drv; + drv = drv->next; + } + return NULL; +} + +int +mii_slot_drv_register( + mii_t *mii, + uint8_t slot_id, + const char *driver_name) +{ + if (!mii || !driver_name) { + printf("%s invalid args\n", __func__); + return -1; + } + if (slot_id < 1 || slot_id > 7) { + printf("%s invalid slot id %d\n", __func__, slot_id); + return -1; + } + if (mii->slot[slot_id - 1].drv) { + printf("%s slot %d already has a driver (%s)\n", + __func__, slot_id, mii->slot[slot_id - 1].drv->name); + return -1; + } + mii_slot_drv_t * drv = mii_slot_drv_find(mii, driver_name); + if (!drv) { + printf("%s driver %s not found\n", __func__, driver_name); + return -1; + } + if (drv->init) { + if (drv->init(mii, &mii->slot[slot_id - 1]) != 0) { + printf("%s driver %s init failed\n", __func__, driver_name); + return -1; + } + } + mii->slot[slot_id - 1].drv = drv; + return 0; +} + +mii_slot_drv_t * +mii_slot_drv_get( + mii_t *mii, + uint8_t slot_id) +{ + if (!mii || slot_id < 1 || slot_id > 7) + return NULL; + return (mii_slot_drv_t *)mii->slot[slot_id - 1].drv; +} + +int +mii_slot_command( + mii_t *mii, + uint8_t slot_id, + uint8_t cmd, + void * param) +{ + mii_slot_drv_t * drv = mii_slot_drv_get(mii, slot_id); + if (!drv) + return -1; + if (drv->command) + return drv->command(mii, &mii->slot[slot_id - 1], cmd, param); + return -1; +} diff --git a/src/mii_slot.h b/src/mii_slot.h new file mode 100644 index 0000000..6d2a621 --- /dev/null +++ b/src/mii_slot.h @@ -0,0 +1,74 @@ +/* + * mii_slot.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +#pragma once + +#include + +typedef struct mii_slot_drv_t mii_slot_drv_t; + +typedef struct mii_slot_t { + uint8_t id; + void * drv_priv; // for driver use + const mii_slot_drv_t * drv; +} mii_slot_t; + +typedef struct mii_t mii_t; + +/* + * That won't handle secondary ROM banks, we'll do that if we ever need it + */ +typedef struct mii_slot_drv_t { + struct mii_slot_drv_t *next; // in global driver queue + uint32_t enable_flag; // if there is a MII_INIT_xxx flag + const char * name; + const char * desc; + int (*probe)(mii_t * mii, uint32_t flags); + int (*init)(mii_t * mii, struct mii_slot_t *slot); + void (*reset)(mii_t * mii, struct mii_slot_t *slot); /* optional */ + void (*run)(mii_t * mii, struct mii_slot_t *slot); /* optional */ + uint8_t (*access)( + mii_t * mii, + struct mii_slot_t *slot, + uint16_t addr, uint8_t data, bool write); + // arbitrary command for load/save etc /* optional */ + int (*command)( + mii_t * mii, + struct mii_slot_t *slot, + uint8_t cmd, + void * param); +} mii_slot_drv_t; + +// get driver installed in slot_id +mii_slot_drv_t * +mii_slot_drv_get( + mii_t *mii, + uint8_t slot_id); +// install driver 'driver_name' in slot_id slot +int +mii_slot_drv_register( + mii_t *mii, + uint8_t slot_id, + const char *driver_name); +// find a driver 'name' in the global list +mii_slot_drv_t * +mii_slot_drv_find( + mii_t *mii, + const char * name); + +enum { + MII_SLOT_DRIVE_COUNT = 0x01, + MII_SLOT_DRIVE_LOAD = 0x20, // + drive index 0...n +}; + +// send a command to a slot/driver. Return >=0 if ok, -1 if error +int +mii_slot_command( + mii_t *mii, + uint8_t slot_id, + uint8_t cmd, + void * param); diff --git a/src/mii_speaker.c b/src/mii_speaker.c new file mode 100644 index 0000000..d98833e --- /dev/null +++ b/src/mii_speaker.c @@ -0,0 +1,212 @@ +/* + * mii_speaker.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" +#include "mii_speaker.h" + +// one frame of audio per frame of video? +#define MII_SPEAKER_FRAME_SIZE (MII_SPEAKER_FREQ / 60) + +// TODO Make some sort of driver for audio and move alsa code there +#ifdef HAS_ALSA +#include + +#define PCM_DEVICE "default" + +static int +_alsa_init( + mii_speaker_t *s) +{ + int pcm; + unsigned int rate = 44100, channels = 1; + snd_pcm_t *alsa; + snd_pcm_hw_params_t *params; + snd_pcm_uframes_t frames; + + /* Open the PCM device in playback mode */ + if ((pcm = snd_pcm_open(&alsa, PCM_DEVICE, + SND_PCM_STREAM_PLAYBACK, 0)) < 0) + printf("ERROR: Can't open \"%s\" PCM device. %s\n", + PCM_DEVICE, snd_strerror(pcm)); + + /* Allocate parameters object and fill it with default values*/ + snd_pcm_hw_params_alloca(¶ms); + snd_pcm_hw_params_any(alsa, params); + + /* Set parameters */ + if ((pcm = snd_pcm_hw_params_set_access(alsa, params, + SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) + printf("ERROR: Can't set interleaved mode. %s\n", + snd_strerror(pcm)); + + if ((pcm = snd_pcm_hw_params_set_format(alsa, params, + SND_PCM_FORMAT_S16_LE)) < 0) + printf("ERROR: Can't set format. %s\n", + snd_strerror(pcm)); + if ((pcm = snd_pcm_hw_params_set_channels(alsa, params, channels)) < 0) + printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm)); + + if ((pcm = snd_pcm_hw_params_set_rate_near(alsa, params, &rate, 0)) < 0) + printf("ERROR: Can't set rate. %s\n", + snd_strerror(pcm)); + frames = MII_SPEAKER_FRAME_SIZE; + /* Write parameters */ + if ((pcm = snd_pcm_hw_params(alsa, params)) < 0) + printf("ERROR: Can't set harware parameters. %s\n", + snd_strerror(pcm)); +// printf("%s frames want %d got %ld\n", +// __func__, MII_SPEAKER_FRAME_SIZE, frames); + + snd_pcm_sw_params_t *sw_params; + snd_pcm_sw_params_alloca (&sw_params); + snd_pcm_sw_params_current (alsa, sw_params); + snd_pcm_sw_params_set_start_threshold(alsa, sw_params, frames * 4); + snd_pcm_sw_params_set_avail_min(alsa, sw_params, frames*4); + snd_pcm_sw_params(alsa, sw_params); + + s->fsize = frames; + s->alsa_pcm = alsa; + snd_pcm_prepare(s->alsa_pcm); + return 0; +} +#endif + +// Initialize the speaker with the frame size in samples +void +mii_speaker_init( + struct mii_t * mii, + mii_speaker_t *s) +{ + s->mii = mii; + s->fsize = MII_SPEAKER_FRAME_SIZE; +#ifdef HAS_ALSA + _alsa_init(s); // this can/will change fsize +#endif + s->vol_multiplier = 0.2; + s->sample = 0x8000; + s->findex = 0; + for (int i = 0; i < MII_SPEAKER_FRAME_COUNT; i++) + s->frame[i].audio = calloc(sizeof(s->frame[i].audio[0]), s->fsize); + s->frame[0].start = mii->cycles; +} + +// Called when $c030 is touched, place a sample at the 'appropriate' time +void +mii_speaker_click( + mii_speaker_t *s) +{ + // if CPU speed has changed, recalculate the number of cycles per sample + if (s->cpu_speed != s->mii->speed) { + s->cpu_speed = s->mii->speed; + s->clk_per_sample = ((1000000.0 /* / s->mii->speed */) / + (float)MII_SPEAKER_FREQ) + 0.5f; + printf("%s: %d cycles per sample\n", __func__, s->clk_per_sample); + } + mii_audio_frame_t *f = &s->frame[s->findex]; + // if we had stopped playing for 2 frames, restart + if (f->start == 0 || + (s->mii->cycles - f->start) > (2 * s->fsize * s->clk_per_sample)) { + // printf("Restarting playback\n"); +#ifdef HAS_ALSA + snd_pcm_prepare(s->alsa_pcm); +#endif + f->start = s->mii->cycles - (s->clk_per_sample * 8); + f->fill = 0; + // add a small attack to the start of the frame to soften the beeps + // we are going to flip the sample, so we need to preemptively + // flip the attack as well + mii_audio_sample_t attack = s->sample ^ 0xffff; + for (int i = 8; i >= 1; i--) + f->audio[f->fill++] = (attack / i) * s->vol_multiplier; + s->fplay = s->findex; // restart here + } + + long sample_index = (s->mii->cycles - f->start) / s->clk_per_sample; + // fill from last sample to here with the current sample + for (; f->fill < sample_index && f->fill < s->fsize; f->fill++) + f->audio[f->fill] = s->sample * s->vol_multiplier; + + // if we've gone past the end of the frame, switch to the next one + if (sample_index >= s->fsize) { + sample_index = sample_index % s->fsize; + __uint128_t newstart = s->mii->cycles - (sample_index * s->clk_per_sample); + s->findex = (s->findex + 1) % MII_SPEAKER_FRAME_COUNT; + f = &s->frame[s->findex]; + f->start = newstart; + f->fill = 0; + // fill from start of this frame to newly calculated sample_index + for (; f->fill < sample_index && f->fill < s->fsize; f->fill++) + f->audio[f->fill] = s->sample * s->vol_multiplier; + } + s->sample ^= 0xffff; + f->audio[sample_index] = s->sample * s->vol_multiplier; +} + +int g_mii_audio_record_fd = -1; + +// Check to see if there's a new frame to send, send it +void +mii_speaker_run( + mii_speaker_t *s) +{ + mii_audio_frame_t *f = &s->frame[s->fplay]; + + // here we check if the frame we want to play is filled, and if it's + // been long enough since we started filling it to be sure we have + // enough samples to play. + // There's also the case were we stopped playing and the last frame + // wasn't complete, in which case we flush it as well + if (f->fill && ((s->mii->cycles - f->start) > + (s->fsize * s->clk_per_sample * 2))) { + s->fplaying = s->fplay; + s->fplay = (s->fplay + 1) % MII_SPEAKER_FRAME_COUNT; + f = &s->frame[s->fplaying]; + if (!s->muted) { +#ifdef HAS_ALSA + int pcm; + if (g_mii_audio_record_fd != -1) + write(g_mii_audio_record_fd, f->audio, + f->fill * sizeof(s->frame[0].audio[0])); + if ((pcm = snd_pcm_writei(s->alsa_pcm, + f->audio, f->fill)) == -EPIPE) { + printf("%s Underrun.\n", __func__); + snd_pcm_recover(s->alsa_pcm, pcm, 1); + } +#endif + } + f->fill = 0; + } +} + +// this is here so we dont' have to drag in libm math library. +double fastPow(double a, double b) { + union { double d; int32_t x[2]; } u = { .d = a }; + u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447); + u.x[0] = 0; + return u.d; +} + +// take the volume from 0 to 10, save it, convert it to a multiplier +void +mii_speaker_volume( + mii_speaker_t *s, + float volume) +{ + if (volume < 0) volume = 0; + else if (volume > 10) volume = 10; + double mul = (fastPow(10.0, volume / 10.0) / 10.0) - 0.09; + s->vol_multiplier = mul; + s->volume = volume; + +// printf("audio: speaker volume set to %.3f (%.4f)\n", volume, mul); +} \ No newline at end of file diff --git a/src/mii_speaker.h b/src/mii_speaker.h new file mode 100644 index 0000000..25b0ecc --- /dev/null +++ b/src/mii_speaker.h @@ -0,0 +1,58 @@ +/* + * mii_speaker.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once +#include + +#define MII_SPEAKER_FREQ (44100) +#define MII_SPEAKER_FRAME_COUNT 4 + +struct mii_t; +struct snd_pcm_t; +typedef int16_t mii_audio_sample_t; + +typedef struct mii_audio_frame_t { + __uint128_t start; + uint16_t fill; + mii_audio_sample_t * audio; +} mii_audio_frame_t; + +typedef struct mii_speaker_t { + struct mii_t * mii; + void * alsa_pcm; // alsa pcm handle + bool muted; // if true, don't play anything + float volume; // volume, 0.0 to 10.0 + float vol_multiplier; // sample multiplier, 0.0 to 1.0 + float cpu_speed; // CPU speed in MHz, to calculate clk_per_sample + uint8_t fplay; // frame we want to play + uint8_t fplaying; // index of the current playing frame + uint16_t fsize; // size in samples of a frame + uint8_t findex; // frame we are currently filling + uint16_t clk_per_sample; // number of cycles per sample (at current CPU speed) + mii_audio_sample_t sample; // current value for the speaker output + mii_audio_frame_t frame[MII_SPEAKER_FRAME_COUNT]; +} mii_speaker_t; + +// Initialize the speaker with the frame size in samples +void +mii_speaker_init( + struct mii_t * mii, + mii_speaker_t *speaker); +// Called when $c030 is touched, place a sample at the 'appropriate' time +void +mii_speaker_click( + mii_speaker_t *speaker); +// Check to see if there's a new frame to send, send it +void +mii_speaker_run( + mii_speaker_t *speaker); +// volume from 0 to 10, sets the audio sample multiplier. +void +mii_speaker_volume( + mii_speaker_t *s, + float volume); diff --git a/src/mii_sw.h b/src/mii_sw.h new file mode 100644 index 0000000..88efa76 --- /dev/null +++ b/src/mii_sw.h @@ -0,0 +1,59 @@ + + +#pragma once + +enum { + SW80STOREOFF = 0xc000, + SW80STOREON = 0xc001, + SWALTCHARSETOFF = 0xc00e, + SWALTCHARSETON = 0xc00f, + + SW80STORE = 0xc018, + SWVBL = 0xc019, + SW80COL = 0xc01f, + SWTEXT = 0xc01a, + SWMIXED = 0xc01b, + SWPAGE2 = 0xc01c, + SWHIRES = 0xc01d, + SWALTCHARSET = 0xc01e, + + SW80COLOFF = 0xc00c, + SW80COLON = 0xc00d, + SWTEXTOFF = 0xc050, // (AKA LORES ON) + SWTEXTON = 0xc051, + SWMIXEDOFF = 0xc052, + SWMIXEDON = 0xc053, + SWPAGE2OFF = 0xc054, + SWPAGE2ON = 0xc055, + SWHIRESOFF = 0xc056, + SWHIRESON = 0xc057, + + // this one is inverted, the ON is the even address + SWDHIRESOFF = 0xc05f, // AN3_ON + SWDHIRESON = 0xc05e, // AN3_OFF + SWAN3 = 0xc05e, // AN3 status + SWAN3_REGISTER = 0xc05f, // AN3 register for video mode + SWRDDHIRES = 0xc07f, + + SWRAMRDOFF = 0xc002, + SWRAMRDON = 0xc003, + SWRAMWRTOFF = 0xc004, + SWRAMWRTON = 0xc005, + SWALTPZOFF = 0xc008, + SWALTPZON = 0xc009, + SWINTCXROMOFF = 0xc006, + SWINTCXROMON = 0xc007, + SWSLOTC3ROMOFF = 0xc00a, + SWSLOTC3ROMON = 0xc00b, + SWBSRBANK2 = 0xc011, + SWBSRREADRAM = 0xc012, + SWRAMRD = 0xc013, + SWRAMWRT = 0xc014, + SWINTCXROM = 0xc015, + SWALTPZ = 0xc016, + SWSLOTC3ROM = 0xc017, + SWSPEAKER = 0xc030, + SWKBD = 0xc000, + SWAKD = 0xc010, + +}; diff --git a/src/mii_video.c b/src/mii_video.c new file mode 100644 index 0000000..8494551 --- /dev/null +++ b/src/mii_video.c @@ -0,0 +1,415 @@ +/* + * mii_video.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include + +#include "mii.h" +#include "mii_bank.h" +#include "mii_rom_iiee_video.h" +#include "mii_sw.h" +#include "minipt.h" + +#define VIDEO_RESOLUTION_X 280 +#define VIDEO_RESOLUTION_Y 192 + +#define VIDEO_BYTES_PER_LINE 40 +#define SCREEN_LINE_OFFSET 0x80 +#define VIDEO_SEGMENT_OFFSET 0x28 + + +enum { + // https://rich12345.tripod.com/aiivideo/vbl.html + MII_VBL_DOWN_CYCLES = 12480, + MII_VBL_UP_CYCLES = 4550, + MII_VIDEO_H_CYCLES = 40, + MII_VIDEO_HB_CYCLES = 25, +}; + +/* + * Colors were lifted from + * https://comp.sys.apple2.narkive.com/lTSrj2ZI/apple-ii-colour-rgb + */ +#define HI_RGB(r,g,b) (0xff000000 | ((b) << 16) | ((g) << 8) | (r)) +static const uint32_t lores_colors[] = { + [0x0] = HI_RGB(0x00, 0x00, 0x00), // black + [0x1] = HI_RGB(0xe3, 0x1e, 0x60), // magenta + [0x2] = HI_RGB(0x60, 0x4e, 0xbd), // dark blue + [0x3] = HI_RGB(0xff, 0x44, 0xfd), // purple + [0x4] = HI_RGB(0x00, 0xa3, 0x60), // dark green + [0x5] = HI_RGB(0x9c, 0x9c, 0x9c), // gray 1 + [0x6] = HI_RGB(0x14, 0xcf, 0xfd), // medium blue + [0x7] = HI_RGB(0xd0, 0xc3, 0xff), // light blue + [0x8] = HI_RGB(0x60, 0x72, 0x03), // brown + [0x9] = HI_RGB(0xff, 0x6a, 0x3c), // orange + [0xa] = HI_RGB(0x9c, 0x9c, 0x9c), // gray 2 + [0xb] = HI_RGB(0xff, 0xa0, 0xd0), // pink + [0xc] = HI_RGB(0x14, 0xf5, 0x3c), // light green + [0xd] = HI_RGB(0xd0, 0xdd, 0x8d), // yellow + [0xe] = HI_RGB(0x72, 0xff, 0xd0), // aqua + [0xf] = HI_RGB(0xff, 0xff, 0xff), // white +}; + +enum { + C_BLACK = HI_RGB(0x00, 0x00, 0x00), // black + C_PURPLE = HI_RGB(0xff, 0x44, 0xfd), // purple + C_GREEN = HI_RGB(0x14, 0xf5, 0x3c), // green + C_BLUE = HI_RGB(0x14, 0xcf, 0xfd), // blue + C_ORANGE = HI_RGB(0xff, 0x6a, 0x3c), // orange + C_WHITE = HI_RGB(0xff, 0xff, 0xff), // white +}; + +static const uint32_t hires_colors[] = { + C_BLACK, + C_PURPLE, + C_GREEN, + C_GREEN, + C_PURPLE, + C_BLUE, + C_ORANGE, + C_ORANGE, + C_BLUE, + C_WHITE, +}; + +static const uint32_t dhires_colors[] = { + [0x0] = HI_RGB(0x00, 0x00, 0x00), // black + [0x1] = HI_RGB(0xe3, 0x1e, 0x60), // magenta + [0x2] = HI_RGB(0x60, 0x72, 0x03), // brown + [0x3] = HI_RGB(0xff, 0x6a, 0x3c), // orange + [0x4] = HI_RGB(0x00, 0xa3, 0x60), // dark green + [0x5] = HI_RGB(0x9c, 0x9c, 0x9c), // gray 1 + [0x6] = HI_RGB(0x14, 0xf5, 0x3c), // light green + [0x7] = HI_RGB(0xd0, 0xdd, 0x8d), // yellow + [0x8] = HI_RGB(0x60, 0x4e, 0xbd), // dark blue + [0x9] = HI_RGB(0xff, 0x44, 0xfd), // purple + [0xa] = HI_RGB(0x9c, 0x9c, 0x9c), // gray 2 + [0xb] = HI_RGB(0xff, 0xa0, 0xd0), // pink + [0xc] = HI_RGB(0x14, 0xcf, 0xfd), // medium blue + [0xd] = HI_RGB(0xd0, 0xc3, 0xff), // light blue + [0xe] = HI_RGB(0x72, 0xff, 0xd0), // aqua + [0xf] = HI_RGB(0xff, 0xff, 0xff), // white +}; + +static const uint32_t mono[3][2] = { + { 0xff000000, C_WHITE }, + { 0xff000000, C_GREEN }, + { 0xff000000, C_ORANGE }, +}; + + +/* this 'dims' the colors for every second line of pixels */ +#define C_SCANLINE_MASK 0xffc0c0c0 + +static inline uint16_t +_mii_line_to_video_addr( + uint16_t addr, + uint8_t line) +{ + addr += ((line & 0x07) << 10) | + (((line >> 3) & 7) << 7) | + ((line >> 6) << 5) | ((line >> 6) << 3); + return addr; +} +/* + * This is the state of the video output + * All timings lifted from https://rich12345.tripod.com/aiivideo/vbl.html + * + * This is a 'protothread' basically cooperative scheduling using an + * old compiler trick. It's not a real thread, but it's a way to + * write code that looks like a thread, and is easy to read. + * The 'pt_start' macro starts the thread, and pt_yield() yields + * the thread to the main loop. + * The pt_end() macro ends the thread. + * Remeber you cannot have locals in the thread, they must be + * static or global. + * *everything* before the pt_start call is ran every time, so you can use + * that to reload some sort of state, as here, were we reload all the + * video mode softwsitches. + */ +void +mii_video_run( + mii_t *mii) +{ + // no need to do anything, we're waiting cycles + if (mii->video.wait) { + if (mii->video.wait > mii->cycles) + return; + // extra cycles we waited are kept around for next delay + mii->video.wait = mii->cycles - mii->video.wait; + } + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + bool text = !!mii_bank_peek(main, SWTEXT); + bool page2 = !!mii_bank_peek(main, SWPAGE2); + bool col80 = !!mii_bank_peek(main, SW80COL); + bool store80 = !!mii_bank_peek(main, SW80STORE); + bool mixed = !!mii_bank_peek(main, SWMIXED); + bool hires = !!mii_bank_peek(main, SWHIRES); + bool dhires = !!mii_bank_peek(main, SWRDDHIRES); + + pt_start(mii->video.state); + /* + We cheat and draw a whole line at a time, then 'wait' until + horizontal blanking, then wait until vertical blanking. + */ + do { + // 'clear' VBL flag. Flag is 0 during retrace + mii_bank_poke(main, SWVBL, 0x80); + if (mixed && !text) { + text = mii->video.line >= 192 - (4 * 8); + hires = 0; + } + // http://www.1000bit.it/support/manuali/apple/technotes/aiie/tn.aiie.03.html + if (hires && !text && col80 && dhires) { + if (store80) + page2 = 0; + uint8_t reg = mii_bank_peek(main, SWAN3_REGISTER); + uint16_t a = (0x2000 + (0x2000 * page2)); + a = _mii_line_to_video_addr(a, mii->video.line); + uint32_t * screen = mii->video.pixels + + (mii->video.line * MII_VRAM_WIDTH * 2); + uint32_t * l2 = screen + MII_VRAM_WIDTH; + + mii_bank_t * aux = &mii->bank[MII_BANK_AUX]; + + if (reg == 0 || mii->video.color_mode != MII_VIDEO_COLOR) { + for (int x = 0; x < 40; x += 1) { + uint32_t ext = (mii_bank_peek(aux, a + x) & 0x7f) | + ((mii_bank_peek(main, a + x) & 0x7f) << 7); + for (int bi = 0; bi < 14; bi++) { + uint8_t pixel = (ext >> bi) & 1; + uint32_t col = pixel ? + mono[mii->video.color_mode][1] : + mono[mii->video.color_mode][0]; + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + } + } + } else { // color mode + int x = 0, dx = 0; + do { + uint64_t run = 0; + // get 8 bytes, so we get 8*7=56 bits for 14 pixels + for (int bx = 0; bx < 8 && x < 80; bx++, x++) { + uint8_t b = mii_bank_peek( + x & 1 ? main : aux, a + (x / 2)); + run |= ((uint64_t)(b & 0x7f) << (bx * 7)); + } + for (int px = 0; px < 14 && dx < 80*2; px++, dx++) { + uint8_t pixel = run & 0xf; + run >>= 4; + uint32_t col = dhires_colors[pixel]; + *screen++ = col; + *screen++ = col; + *screen++ = col; + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + *l2++ = col & C_SCANLINE_MASK; + *l2++ = col & C_SCANLINE_MASK; + *l2++ = col & C_SCANLINE_MASK; + } + } while (x < 80); + } + } else if (hires && !text) { + if (store80) + page2 = 0; + uint16_t a = (0x2000 + (0x2000 * page2)); + a = _mii_line_to_video_addr(a, mii->video.line); + uint32_t * screen = mii->video.pixels + + (mii->video.line * MII_VRAM_WIDTH * 2); + uint32_t * l2 = screen + MII_VRAM_WIDTH; + + uint8_t b0 = 0; + uint8_t b1 = mii_bank_peek(main, a + 0); + for (int x = 0; x < 40; x++) { + uint8_t b2 = mii_bank_peek(main, a + x + 1); + // last 2 pixels, current 7 pixels, next 2 pixels + uint16_t run = ((b0 & 0x60) >> ( 5 )) | + ((b1 & 0x7f) << ( 2 )) | + ((b2 & 0x03) << ( 9 )); + int odd = (x & 1) << 1; + int offset = (b1 & 0x80) >> 5; + + if (mii->video.color_mode == MII_VIDEO_COLOR) { + for (int i = 0; i < 7; i++) { + uint8_t left = (run >> (1 + i)) & 1; + uint8_t pixel = (run >> (2 + i)) & 1; + uint8_t right = (run >> (3 + i)) & 1; + + int idx = 0; // black + if (pixel) { + if (left || right) { + idx = 9; // white + } else { + idx = offset + odd + (i & 1) + 1; + } + } else { + if (left && right) { + idx = offset + odd + 1 - (i & 1) + 1; + } + } + uint32_t col = hires_colors[idx]; + *screen++ = col; + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + *l2++ = col & C_SCANLINE_MASK; + } + } else { + for (int i = 0; i < 7; i++) { + uint8_t pixel = (run >> (2 + i)) & 1; + uint32_t col = pixel ? + mono[mii->video.color_mode][1] : + mono[mii->video.color_mode][0]; + *screen++ = col; + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + *l2++ = col & C_SCANLINE_MASK; + } + } + b0 = b1; + b1 = b2; + } + } else { + if (store80) + page2 = 0; + uint16_t a = (0x400 + (0x400 * page2)); + int i = mii->video.line >> 3; + a += ((i & 0x07) << 7) | ((i >> 3) << 5) | ((i >> 3) << 3); + + mii_bank_t * aux = &mii->bank[MII_BANK_AUX]; + uint32_t * screen = mii->video.pixels + + (mii->video.line * MII_VRAM_WIDTH * 2); + uint32_t * l2 = screen + MII_VRAM_WIDTH; + for (int x = 0; x < 40 + (40 * col80); x++) { + uint8_t c = 0; + if (col80) + c = mii_bank_peek( + x & 1 ? main : aux, a + (x >> 1)); + else + c = mii_bank_peek(main, a + x); + if (text) { + const uint8_t * rom = iie_enhanced_video + (c << 3); + uint8_t bits = rom[mii->video.line & 0x07]; + for (int pi = 0; pi < 7; pi++) { + uint8_t pixel = (bits >> pi) & 1; + uint32_t col = pixel ? + mono[mii->video.color_mode][0] : + mono[mii->video.color_mode][1]; + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + if (!col80) { + *screen++ = col; + *l2++ = col & C_SCANLINE_MASK; + } + } + } else { // lores graphics + int lo_line = mii->video.line / 4; + c = c >> ((lo_line & 1) * 4); + uint32_t pixel = lores_colors[c & 0x0f]; + for (int pi = 0; pi < 7; pi++) { + *screen++ = pixel; + *l2++ = pixel & C_SCANLINE_MASK; + if (!col80) { + *screen++ = pixel; + *l2++ = pixel & C_SCANLINE_MASK; + } + } + } + } + } + mii->video.line++; + if (mii->video.line == 192) { + mii->video.line = 0; + mii->video.wait = mii->cycles - mii->video.wait + + MII_VIDEO_H_CYCLES * mii->speed; + pt_yield(mii->video.state); + mii_bank_poke(main, SWVBL, 0x00); + if (mii->video.vbl_irq) + mii->cpu_state.irq = 1; + mii->video.wait = mii->cycles - mii->video.wait + + MII_VBL_UP_CYCLES * mii->speed; + mii->video.frame_count++; + pt_yield(mii->video.state); + } else { + mii->video.wait = mii->cycles - mii->video.wait + + (MII_VIDEO_H_CYCLES + MII_VIDEO_HB_CYCLES) * + mii->speed; + pt_yield(mii->video.state); + } + } while (1); + pt_end(mii->video.state); + return; +} + +bool +mii_access_video( + mii_t *mii, + uint16_t addr, + uint8_t * byte, + bool write) +{ + bool res = false; + mii_bank_t * main = &mii->bank[MII_BANK_MAIN]; + switch (addr) { + case SWALTCHARSETOFF: + case SWALTCHARSETON: + if (!write) break; + res = true; + mii_bank_poke(main, SWALTCHARSET, (addr & 1) << 7); + break; + case SWVBL: + case SW80COL: + case SWTEXT: + case SWMIXED: + case SWPAGE2: + case SWHIRES: + case SWALTCHARSET: + case SWRDDHIRES: + res = true; + if (!write) + *byte = mii_bank_peek(main, addr); + break; + case SW80COLOFF: + case SW80COLON: + if (!write) break; + res = true; + mii_bank_poke(main, SW80COL, (addr & 1) << 7); +// printf("80COL %s\n", on ? "ON" : "OFF"); + break; + case SWDHIRESOFF: // 0xc05f, + case SWDHIRESON: { // = 0xc05e, + res = true; + uint8_t an3 = !!mii_bank_peek(main, SWAN3); + bool an3_on = !!(addr & 1); // 5f is ON, 5e is OFF + uint8_t reg = mii_bank_peek(main, SWAN3_REGISTER); + if (an3_on && !an3) { + uint8_t bit = !!mii_bank_peek(main, SW80COL); + reg = ((reg << 1) | bit) & 3; + printf("VIDEO 80:%d REG now %x\n", bit, reg); + mii_bank_poke(main, SWAN3_REGISTER, reg); + } + mii_bank_poke(main, SWAN3, an3_on); + printf("DHRES IS %s mode:%d\n", + (addr & 1) ? "OFF" : "ON", reg); + mii_bank_poke(main, SWRDDHIRES, (!(addr & 1)) << 7); + } break; + case SWTEXTOFF: + case SWTEXTON: + res = true; + mii_bank_poke(main, SWTEXT, (addr & 1) << 7); + break; + case SWMIXEDOFF: + case SWMIXEDON: + res = true; + mii_bank_poke(main, SWMIXED, (addr & 1) << 7); + break; + } + return res; +} diff --git a/src/mii_video.h b/src/mii_video.h new file mode 100644 index 0000000..dd5fc56 --- /dev/null +++ b/src/mii_video.h @@ -0,0 +1,55 @@ +/* + * mii_video.h + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include +#include + + +// TODO move VRAM stuff to somewhere else +/* + These are currently way bigger than needed, because they need to be + a power of two to easily map to an opengl texture. + */ +#define MII_VRAM_WIDTH 1024 +#define MII_VRAM_HEIGHT 512 + +#define MII_VIDEO_WIDTH (280 * 2) +#define MII_VIDEO_HEIGHT (192 * 2) + +enum { + MII_VIDEO_COLOR = 0, + MII_VIDEO_GREEN, + MII_VIDEO_AMBER, +}; + +struct mii_t; + +typedef struct mii_video_t { + void * state; // protothread state in mii_video.c + uint8_t line; // current line + bool vbl_irq; // VBL IRQ emabled (set by mouse card) + __uint128_t wait; // 'wait until' cycle marker + uint32_t pixels[MII_VRAM_WIDTH * MII_VRAM_HEIGHT]; + uint32_t frame_count; // incremented every frame + uint32_t frame_drawn; + uint8_t color_mode; // color, green, amber +} mii_video_t; + +bool +mii_access_video( + struct mii_t *mii, + uint16_t addr, + uint8_t * byte, + bool write); +void +mii_video_run( + struct mii_t *mii); + + diff --git a/src/roms/mii_rom_disk2.h b/src/roms/mii_rom_disk2.h new file mode 100644 index 0000000..4dae73f --- /dev/null +++ b/src/roms/mii_rom_disk2.h @@ -0,0 +1,26 @@ +#pragma once +static const unsigned char mii_rom_disk2[] = { + 0xa2, 0x20, 0xa0, 0x00, 0xa2, 0x03, 0x86, 0x3c, 0x8a, 0x0a, 0x24, 0x3c, + 0xf0, 0x10, 0x05, 0x3c, 0x49, 0xff, 0x29, 0x7e, 0xb0, 0x08, 0x4a, 0xd0, + 0xfb, 0x98, 0x9d, 0x56, 0x03, 0xc8, 0xe8, 0x10, 0xe5, 0x20, 0x58, 0xff, + 0xba, 0xbd, 0x00, 0x01, 0x0a, 0x0a, 0x0a, 0x0a, 0x85, 0x2b, 0xaa, 0xbd, + 0x8e, 0xc0, 0xbd, 0x8c, 0xc0, 0xbd, 0x8a, 0xc0, 0xbd, 0x89, 0xc0, 0xa0, + 0x50, 0xbd, 0x80, 0xc0, 0x98, 0x29, 0x03, 0x0a, 0x05, 0x2b, 0xaa, 0xbd, + 0x81, 0xc0, 0xa9, 0x56, 0x20, 0xa8, 0xfc, 0x88, 0x10, 0xeb, 0x85, 0x26, + 0x85, 0x3d, 0x85, 0x41, 0xa9, 0x08, 0x85, 0x27, 0x18, 0x08, 0xbd, 0x8c, + 0xc0, 0x10, 0xfb, 0x49, 0xd5, 0xd0, 0xf7, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, + 0xc9, 0xaa, 0xd0, 0xf3, 0xea, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0x96, + 0xf0, 0x09, 0x28, 0x90, 0xdf, 0x49, 0xad, 0xf0, 0x25, 0xd0, 0xd9, 0xa0, + 0x03, 0x85, 0x40, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0x2a, 0x85, 0x3c, 0xbd, + 0x8c, 0xc0, 0x10, 0xfb, 0x25, 0x3c, 0x88, 0xd0, 0xec, 0x28, 0xc5, 0x3d, + 0xd0, 0xbe, 0xa5, 0x40, 0xc5, 0x41, 0xd0, 0xb8, 0xb0, 0xb7, 0xa0, 0x56, + 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10, 0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x3c, + 0x88, 0x99, 0x00, 0x03, 0xd0, 0xee, 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10, + 0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x3c, 0x91, 0x26, 0xc8, 0xd0, 0xef, 0xbc, + 0x8c, 0xc0, 0x10, 0xfb, 0x59, 0xd6, 0x02, 0xd0, 0x87, 0xa0, 0x00, 0xa2, + 0x56, 0xca, 0x30, 0xfb, 0xb1, 0x26, 0x5e, 0x00, 0x03, 0x2a, 0x5e, 0x00, + 0x03, 0x2a, 0x91, 0x26, 0xc8, 0xd0, 0xee, 0xe6, 0x27, 0xe6, 0x3d, 0xa5, + 0x3d, 0xcd, 0x00, 0x08, 0xa6, 0x2b, 0x90, 0xdb, 0x4c, 0x01, 0x08, 0x00, + 0x00, 0x00, 0x00, 0x00 +}; +static const unsigned int mii_rom_disk2_len = 256; diff --git a/src/roms/mii_rom_iiee.h b/src/roms/mii_rom_iiee.h new file mode 100644 index 0000000..872b4d1 --- /dev/null +++ b/src/roms/mii_rom_iiee.h @@ -0,0 +1,1370 @@ +#pragma once +static const unsigned char iie_enhanced_rom_bin[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x4c, 0x13, 0xc2, 0xa4, 0x24, 0xa5, 0x25, 0x48, + 0x20, 0x03, 0xce, 0x20, 0xf4, 0xc1, 0xa0, 0x00, 0x68, 0x69, 0x00, 0xc5, + 0x23, 0x90, 0xf0, 0xb0, 0x34, 0xa5, 0x22, 0x85, 0x25, 0xa0, 0x00, 0x84, + 0x24, 0xf0, 0xe4, 0xa5, 0x22, 0x48, 0x20, 0x03, 0xce, 0xa5, 0x28, 0x85, + 0x2a, 0xa5, 0x29, 0x85, 0x2b, 0xa4, 0x21, 0x88, 0x68, 0x69, 0x01, 0xc5, + 0x23, 0xb0, 0x0d, 0x48, 0x20, 0x03, 0xce, 0xb1, 0x28, 0x91, 0x2a, 0x88, + 0x10, 0xf9, 0x30, 0xe1, 0xa0, 0x00, 0x20, 0xf4, 0xc1, 0xa5, 0x25, 0x4c, + 0x03, 0xce, 0xa9, 0x28, 0x85, 0x21, 0xa9, 0x18, 0x85, 0x23, 0xa9, 0x17, + 0x85, 0x25, 0xd0, 0xef, 0xa4, 0x2a, 0x4c, 0xf4, 0xc1, 0x4c, 0xeb, 0xcb, + 0x4c, 0x9a, 0xcc, 0xa4, 0x2a, 0x4c, 0x9d, 0xcc, 0x4c, 0x74, 0xcc, 0x4c, + 0xa0, 0xc2, 0x4c, 0xb0, 0xc2, 0x4c, 0xf2, 0xc2, 0x20, 0x90, 0xcc, 0xad, + 0x7b, 0x05, 0x85, 0x24, 0x8d, 0x7b, 0x04, 0x4c, 0xfe, 0xcd, 0xb4, 0x00, + 0xf0, 0x0f, 0xc0, 0x1b, 0xf0, 0x0e, 0x20, 0x80, 0xcd, 0xb4, 0x00, 0xf0, + 0x04, 0xa9, 0xfd, 0x95, 0x01, 0xb5, 0x01, 0x60, 0xa5, 0x37, 0xc9, 0xc3, + 0xd0, 0xf3, 0x4c, 0x32, 0xc8, 0xa4, 0x24, 0xb1, 0x28, 0x48, 0x29, 0x3f, + 0x09, 0x40, 0x91, 0x28, 0x68, 0x60, 0xa8, 0xa5, 0x28, 0x20, 0xba, 0xca, + 0x90, 0x4c, 0x20, 0x14, 0xce, 0xa0, 0x03, 0xd9, 0xee, 0xc2, 0xd0, 0x03, + 0xb9, 0xa4, 0xc9, 0x88, 0x10, 0xf5, 0x30, 0x3a, 0x20, 0x70, 0xc8, 0x4c, + 0x0a, 0xc2, 0x8a, 0x29, 0x03, 0x85, 0x2f, 0xa5, 0x2a, 0x29, 0x8f, 0x4c, + 0x71, 0xca, 0x20, 0xf0, 0xfc, 0x8a, 0x85, 0x34, 0x60, 0xac, 0x7b, 0x05, + 0x20, 0x44, 0xce, 0x09, 0x80, 0x60, 0xa4, 0x24, 0xa9, 0xa0, 0x2c, 0x1e, + 0xc0, 0x10, 0x06, 0x24, 0x32, 0x30, 0x02, 0xa9, 0x20, 0x4c, 0xa8, 0xcc, + 0xa8, 0xa5, 0x28, 0x20, 0x03, 0xce, 0x28, 0x30, 0x03, 0x4c, 0xc5, 0xfe, + 0x4c, 0xc8, 0xfe, 0x88, 0x30, 0xba, 0x88, 0x30, 0xa5, 0x88, 0x30, 0x9a, + 0x88, 0x30, 0x3d, 0x88, 0x30, 0xe2, 0xa9, 0xc2, 0x48, 0xa9, 0x09, 0x48, + 0xad, 0xfb, 0x04, 0x29, 0xd6, 0xd0, 0x0d, 0x98, 0x18, 0x69, 0x0c, 0x48, + 0x20, 0x50, 0xc8, 0x20, 0xfe, 0xcd, 0x68, 0xa8, 0xa9, 0xc1, 0x48, 0xb9, + 0x44, 0xc2, 0x48, 0x60, 0x18, 0x22, 0xf1, 0x5f, 0x75, 0x02, 0xa8, 0x51, + 0xe1, 0x94, 0xe8, 0xd5, 0x7b, 0x64, 0x67, 0x6a, 0x75, 0x6f, 0x78, 0x72, + 0xe1, 0x89, 0xe8, 0xd5, 0x2c, 0x1f, 0xc0, 0x10, 0x06, 0x20, 0x74, 0xc8, + 0x4c, 0x0a, 0xc2, 0xa8, 0x8a, 0x48, 0x98, 0x48, 0x48, 0x68, 0xc9, 0xff, + 0xf0, 0x04, 0xa9, 0xff, 0xd0, 0x02, 0x68, 0x48, 0x48, 0xa4, 0x24, 0x91, + 0x28, 0xe6, 0x4e, 0xd0, 0x0a, 0xa5, 0x4f, 0xe6, 0x4f, 0x45, 0x4f, 0x29, + 0x40, 0xd0, 0xe2, 0xad, 0x00, 0xc0, 0x10, 0xed, 0x68, 0x68, 0xa4, 0x24, + 0x91, 0x28, 0x68, 0xaa, 0xad, 0x00, 0xc0, 0x8d, 0x10, 0xc0, 0x30, 0xc4, + 0x20, 0x52, 0xc1, 0x2c, 0x1f, 0xc0, 0x10, 0x02, 0x06, 0x21, 0xa5, 0x25, + 0x8d, 0xfb, 0x05, 0x60, 0xa9, 0xff, 0x8d, 0xfb, 0x04, 0xad, 0x5d, 0xc0, + 0xad, 0x5f, 0xc0, 0xad, 0x62, 0xc0, 0x10, 0x03, 0x4c, 0x00, 0xc6, 0xad, + 0x61, 0xc0, 0x10, 0x1a, 0xa0, 0xb0, 0xa9, 0x00, 0x85, 0x3c, 0xa9, 0xbf, + 0x38, 0x85, 0x3d, 0x48, 0xa9, 0xa0, 0x91, 0x3c, 0x88, 0x91, 0x3c, 0x68, + 0xe9, 0x01, 0xc9, 0x01, 0xd0, 0xef, 0x8d, 0x0b, 0xc0, 0x20, 0x89, 0xca, + 0xd0, 0x03, 0x8d, 0x0a, 0xc0, 0x60, 0x88, 0x95, 0x8a, 0x8b, 0xa4, 0x24, + 0xb1, 0x28, 0x2c, 0x1f, 0xc0, 0x30, 0xf2, 0x4c, 0x26, 0xce, 0x00, 0x00, + 0x2c, 0x43, 0xce, 0x70, 0x12, 0x38, 0x90, 0x18, 0xb8, 0x50, 0x0c, 0x01, + 0x88, 0x4a, 0x50, 0x56, 0x5c, 0x4c, 0x76, 0xc3, 0x4c, 0xc3, 0xc3, 0x8d, + 0x7b, 0x06, 0x98, 0x48, 0x8a, 0x48, 0x08, 0xad, 0xfb, 0x04, 0x2c, 0xf8, + 0x07, 0x30, 0x05, 0x09, 0x08, 0x8d, 0xfb, 0x04, 0x20, 0x6d, 0xc3, 0x28, + 0x70, 0x15, 0x90, 0x10, 0xaa, 0x10, 0x0d, 0x20, 0x5b, 0xcd, 0x68, 0xaa, + 0x68, 0xa8, 0xad, 0x7b, 0x06, 0x6c, 0x38, 0x00, 0x4c, 0x7c, 0xc8, 0x4c, + 0x03, 0xc8, 0x20, 0x6d, 0xc3, 0x4c, 0xb4, 0xc9, 0x20, 0x6d, 0xc3, 0x4c, + 0xd6, 0xc9, 0x20, 0x6d, 0xc3, 0x4c, 0xf0, 0xc9, 0xaa, 0xf0, 0x08, 0xca, + 0xd0, 0x07, 0x2c, 0x00, 0xc0, 0x10, 0x04, 0x38, 0x60, 0xa2, 0x03, 0x18, + 0x60, 0xa2, 0xc3, 0x8e, 0xf8, 0x07, 0xae, 0xff, 0xcf, 0x60, 0x48, 0x98, + 0x48, 0xad, 0x13, 0xc0, 0x48, 0xad, 0x14, 0xc0, 0x48, 0x90, 0x08, 0x8d, + 0x02, 0xc0, 0x8d, 0x05, 0xc0, 0xb0, 0x06, 0x8d, 0x04, 0xc0, 0x8d, 0x03, + 0xc0, 0xa0, 0x00, 0xb1, 0x3c, 0x91, 0x42, 0xe6, 0x42, 0xd0, 0x02, 0xe6, + 0x43, 0xa5, 0x3c, 0xc5, 0x3e, 0xa5, 0x3d, 0xe5, 0x3f, 0xe6, 0x3c, 0xd0, + 0x02, 0xe6, 0x3d, 0x90, 0xe6, 0x8d, 0x04, 0xc0, 0x68, 0x10, 0x03, 0x8d, + 0x05, 0xc0, 0x8d, 0x02, 0xc0, 0x68, 0x10, 0x03, 0x8d, 0x03, 0xc0, 0x68, + 0xa8, 0x68, 0x60, 0x48, 0xad, 0xed, 0x03, 0x48, 0xad, 0xee, 0x03, 0x48, + 0x90, 0x08, 0x8d, 0x03, 0xc0, 0x8d, 0x05, 0xc0, 0xb0, 0x06, 0x8d, 0x02, + 0xc0, 0x8d, 0x04, 0xc0, 0x68, 0x8d, 0xee, 0x03, 0x68, 0x8d, 0xed, 0x03, + 0x68, 0x70, 0x05, 0x8d, 0x08, 0xc0, 0x50, 0x03, 0x8d, 0x09, 0xc0, 0x6c, + 0xed, 0x03, 0x00, 0x00, 0x8d, 0x81, 0xc0, 0x4c, 0x7a, 0xfc, 0x2c, 0x15, + 0xc0, 0x8d, 0x07, 0xc0, 0xd8, 0x38, 0x30, 0x01, 0x18, 0x48, 0x48, 0x48, + 0x8a, 0xba, 0xe8, 0xe8, 0xe8, 0xe8, 0x48, 0x98, 0x48, 0xbd, 0x00, 0x01, + 0x29, 0x10, 0xa8, 0xad, 0x18, 0xc0, 0x2d, 0x1c, 0xc0, 0x29, 0x80, 0xf0, + 0x05, 0xa9, 0x20, 0x8d, 0x54, 0xc0, 0x2a, 0x2c, 0x13, 0xc0, 0x10, 0x05, + 0x8d, 0x02, 0xc0, 0x09, 0x20, 0x2c, 0x14, 0xc0, 0x10, 0x05, 0x8d, 0x04, + 0xc0, 0x09, 0x10, 0x2c, 0x12, 0xc0, 0x10, 0x0c, 0x09, 0x0c, 0x2c, 0x11, + 0xc0, 0x10, 0x02, 0x49, 0x06, 0x8d, 0x81, 0xc0, 0x2c, 0x16, 0xc0, 0x10, + 0x0d, 0xba, 0x8e, 0x01, 0x01, 0xae, 0x00, 0x01, 0x9a, 0x8d, 0x08, 0xc0, + 0x09, 0x80, 0x88, 0x30, 0x0c, 0x85, 0x44, 0x68, 0xa8, 0x68, 0xaa, 0x68, + 0x68, 0x68, 0x4c, 0x47, 0xfa, 0x48, 0xad, 0xf8, 0x07, 0x48, 0xa9, 0xc3, + 0x48, 0xa9, 0xf4, 0x48, 0x08, 0x4c, 0x74, 0xfc, 0xad, 0x81, 0xc0, 0x68, + 0x10, 0x07, 0x8d, 0x09, 0xc0, 0xae, 0x01, 0x01, 0x9a, 0xa0, 0x06, 0x10, + 0x06, 0xbe, 0xc1, 0xc4, 0xfe, 0x00, 0xc0, 0x88, 0x30, 0x03, 0x0a, 0xd0, + 0xf2, 0x0a, 0x0a, 0x68, 0xa8, 0xba, 0xa9, 0x40, 0x48, 0xa9, 0xc0, 0x48, + 0xa9, 0x06, 0x69, 0x00, 0x48, 0xa9, 0x8d, 0x48, 0x9a, 0x8a, 0x69, 0x03, + 0xaa, 0x38, 0xe9, 0x07, 0x9d, 0x00, 0x01, 0xe8, 0xa9, 0x01, 0x9d, 0x00, + 0x01, 0x68, 0xaa, 0x68, 0x60, 0x83, 0x8b, 0x8b, 0x05, 0x03, 0x55, 0x00, + 0x20, 0x13, 0xff, 0x84, 0x34, 0xdd, 0xb4, 0xf9, 0xd0, 0x13, 0x20, 0x13, + 0xff, 0xdd, 0xba, 0xf9, 0xf0, 0x0d, 0xbd, 0xba, 0xf9, 0xf0, 0x07, 0xc9, + 0xa4, 0xf0, 0x03, 0xa4, 0x34, 0x18, 0x88, 0x26, 0x44, 0xe0, 0x03, 0xd0, + 0x0d, 0x20, 0xa7, 0xff, 0xa5, 0x3f, 0xf0, 0x01, 0xe8, 0x86, 0x35, 0xa2, + 0x03, 0x88, 0x86, 0x3d, 0xca, 0x10, 0xc9, 0x60, 0x90, 0x48, 0xa9, 0x00, + 0x85, 0x3d, 0x85, 0x3f, 0xa0, 0x50, 0x84, 0x3c, 0xc8, 0x84, 0x3e, 0x20, + 0xd1, 0xc5, 0x18, 0xa5, 0x73, 0xaa, 0xca, 0x86, 0x3e, 0xe5, 0x50, 0x48, + 0xa5, 0x74, 0xa8, 0xe8, 0xd0, 0x01, 0x88, 0x84, 0x3f, 0xe5, 0x51, 0xc5, + 0x6e, 0x90, 0x02, 0xd0, 0x02, 0x38, 0x60, 0x85, 0x74, 0x85, 0x70, 0x85, + 0x3d, 0x85, 0xe9, 0x68, 0x85, 0xe8, 0x85, 0x73, 0x85, 0x6f, 0x85, 0x3c, + 0x20, 0x98, 0xc5, 0xa9, 0x03, 0x20, 0xd6, 0xc5, 0x18, 0x60, 0xa5, 0x9b, + 0x65, 0x50, 0x85, 0x3e, 0xa5, 0x9c, 0x65, 0x51, 0x85, 0x3f, 0xa0, 0x04, + 0xb1, 0x9b, 0x20, 0xef, 0xe0, 0xa5, 0x94, 0x85, 0x3c, 0xa5, 0x95, 0x85, + 0x3d, 0x18, 0x60, 0xa0, 0x4b, 0x20, 0x79, 0xc5, 0xd0, 0xf9, 0x69, 0xfe, + 0xb0, 0xf5, 0xa0, 0x21, 0x20, 0x79, 0xc5, 0xc8, 0xc8, 0x88, 0xd0, 0xfd, + 0x90, 0x05, 0xa0, 0x32, 0x88, 0xd0, 0xfd, 0xac, 0x20, 0xc0, 0xa0, 0x2c, + 0xca, 0x60, 0xa2, 0x08, 0x48, 0x20, 0x98, 0xc5, 0x68, 0x2a, 0xa0, 0x3a, + 0xca, 0xd0, 0xf5, 0x60, 0x20, 0x9b, 0xc5, 0x88, 0xad, 0x60, 0xc0, 0x45, + 0x2f, 0x10, 0xf8, 0x45, 0x2f, 0x85, 0x2f, 0xc0, 0x80, 0x60, 0x20, 0x67, + 0xc5, 0xa0, 0x27, 0xa2, 0x00, 0x41, 0x3c, 0x48, 0xa1, 0x3c, 0x20, 0xc8, + 0xc5, 0x20, 0xba, 0xfc, 0xa0, 0x1d, 0x68, 0x90, 0xee, 0xa0, 0x22, 0x20, + 0xc8, 0xc5, 0xf0, 0x08, 0xa2, 0x10, 0x0a, 0x20, 0x74, 0xc5, 0xd0, 0xfa, + 0x60, 0x20, 0x98, 0xc5, 0xa9, 0x16, 0x20, 0x67, 0xc5, 0x85, 0x2e, 0x20, + 0x98, 0xc5, 0xa0, 0x24, 0x20, 0x9b, 0xc5, 0xb0, 0xf9, 0x20, 0x9b, 0xc5, + 0xa0, 0x3b, 0x20, 0x8a, 0xc5, 0x81, 0x3c, 0x45, 0x2e, 0x85, 0x2e, 0x20, + 0xba, 0xfc, 0xa0, 0x35, 0x90, 0xf0, 0x20, 0x8a, 0xc5, 0xc5, 0x2e, 0x60, + 0x8d, 0x50, 0xc0, 0xa0, 0x04, 0xa2, 0x00, 0x18, 0x79, 0xb4, 0xc7, 0x95, + 0x00, 0xe8, 0xd0, 0xf7, 0x18, 0x79, 0xb4, 0xc7, 0xd5, 0x00, 0xd0, 0x10, + 0xe8, 0xd0, 0xf5, 0x6a, 0x2c, 0x19, 0xc0, 0x10, 0x02, 0x49, 0xa5, 0x88, + 0x10, 0xe1, 0x30, 0x06, 0x55, 0x00, 0x18, 0x4c, 0xcd, 0xc6, 0x86, 0x01, + 0x86, 0x02, 0x86, 0x03, 0xa2, 0x04, 0x86, 0x04, 0xe6, 0x01, 0xa8, 0x8d, + 0x83, 0xc0, 0x8d, 0x83, 0xc0, 0xa5, 0x01, 0x29, 0xf0, 0xc9, 0xc0, 0xd0, + 0x0c, 0xad, 0x8b, 0xc0, 0xad, 0x8b, 0xc0, 0xa5, 0x01, 0x69, 0x0f, 0xd0, + 0x02, 0xa5, 0x01, 0x85, 0x03, 0x98, 0xa0, 0x00, 0x18, 0x7d, 0xb4, 0xc7, + 0x91, 0x02, 0xca, 0x10, 0x02, 0xa2, 0x04, 0xc8, 0xd0, 0xf2, 0xe6, 0x01, + 0xd0, 0xcc, 0xe6, 0x01, 0xa8, 0xad, 0x83, 0xc0, 0xad, 0x83, 0xc0, 0xa5, + 0x01, 0x29, 0xf0, 0xc9, 0xc0, 0xd0, 0x09, 0xad, 0x8b, 0xc0, 0xa5, 0x01, + 0x69, 0x0f, 0xd0, 0x02, 0xa5, 0x01, 0x85, 0x03, 0x98, 0xa0, 0x00, 0x18, + 0x7d, 0xb4, 0xc7, 0x51, 0x02, 0xd0, 0x35, 0xb1, 0x02, 0xca, 0x10, 0x02, + 0xa2, 0x04, 0xc8, 0xd0, 0xee, 0xe6, 0x01, 0xd0, 0xcb, 0x6a, 0x2c, 0x19, + 0xc0, 0x10, 0x02, 0x49, 0xa5, 0xc6, 0x04, 0x10, 0x87, 0xaa, 0x20, 0x8d, + 0xc9, 0xd0, 0x07, 0x0e, 0x00, 0x0c, 0x0a, 0xcd, 0x00, 0x0c, 0xd0, 0x76, + 0xcd, 0x00, 0x08, 0xf0, 0x71, 0x8a, 0x8d, 0x09, 0xc0, 0x4c, 0x03, 0xc6, + 0x38, 0xaa, 0xad, 0x13, 0xc0, 0xb8, 0x10, 0x03, 0x2c, 0xb4, 0xc7, 0xa9, + 0xa0, 0xa0, 0x06, 0x99, 0xfe, 0xbf, 0x99, 0x06, 0xc0, 0x88, 0x88, 0xd0, + 0xf6, 0x8d, 0x51, 0xc0, 0x8d, 0x54, 0xc0, 0x99, 0x00, 0x04, 0x99, 0x00, + 0x05, 0x99, 0x00, 0x06, 0x99, 0x00, 0x07, 0xc8, 0xd0, 0xf1, 0x8a, 0xf0, + 0x27, 0xa0, 0x03, 0xb0, 0x02, 0xa0, 0x05, 0xa9, 0xaa, 0x50, 0x03, 0x8d, + 0xb0, 0x05, 0xb9, 0xea, 0xc7, 0x99, 0xb1, 0x05, 0x88, 0x10, 0xf7, 0xa0, + 0x10, 0x8a, 0x4a, 0xaa, 0xa9, 0x58, 0x2a, 0x99, 0xb6, 0x05, 0x88, 0x88, + 0xd0, 0xf3, 0xf0, 0xfe, 0xa0, 0x02, 0xb9, 0xf0, 0xc7, 0x90, 0x03, 0xb9, + 0xf3, 0xc7, 0x99, 0xb8, 0x05, 0x88, 0x10, 0xf2, 0x30, 0xfe, 0xa0, 0x01, + 0xa9, 0x7f, 0x6a, 0xbe, 0xb9, 0xc7, 0xf0, 0x0f, 0x90, 0x03, 0xbe, 0xc9, + 0xc7, 0x9d, 0xff, 0xbf, 0xc8, 0xd0, 0xef, 0xae, 0x30, 0xc0, 0x2a, 0x88, + 0xbe, 0xd9, 0xc7, 0xf0, 0x13, 0x30, 0xf4, 0x2a, 0x90, 0x07, 0x1e, 0x00, + 0xc0, 0x90, 0x17, 0xb0, 0xee, 0x1e, 0x00, 0xc0, 0xb0, 0x10, 0x90, 0xe7, + 0x2a, 0xc8, 0x38, 0xe9, 0x01, 0xb0, 0xcb, 0x88, 0xd0, 0x0b, 0xa0, 0x09, + 0xd0, 0xc2, 0xa2, 0x00, 0xc0, 0x0a, 0x4c, 0xd7, 0xc6, 0x46, 0x80, 0xd0, + 0xb5, 0xa9, 0xa0, 0xa0, 0x00, 0x99, 0x00, 0x04, 0x99, 0x00, 0x05, 0x99, + 0x00, 0x06, 0x99, 0x00, 0x07, 0xc8, 0xd0, 0xf1, 0xad, 0x61, 0xc0, 0x2d, + 0x62, 0xc0, 0x0a, 0xe6, 0xff, 0xa5, 0xff, 0x90, 0x03, 0x4c, 0x00, 0xc6, + 0xad, 0x51, 0xc0, 0xa0, 0x08, 0xb9, 0xf6, 0xc7, 0x99, 0xb8, 0x05, 0x88, + 0x10, 0xf7, 0x30, 0xe0, 0x53, 0x43, 0x2b, 0x29, 0x07, 0x00, 0x89, 0x31, + 0x03, 0x05, 0x09, 0x0b, 0x01, 0x00, 0x83, 0x51, 0x53, 0x55, 0x57, 0x0f, + 0x0d, 0x00, 0x81, 0x31, 0x04, 0x06, 0x0a, 0x0c, 0x02, 0x00, 0x84, 0x52, + 0x54, 0x56, 0x58, 0x10, 0x0e, 0x00, 0x11, 0xff, 0x13, 0x14, 0x16, 0x17, + 0x18, 0x00, 0x12, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x00, 0xd2, 0xc1, + 0xcd, 0xa0, 0xda, 0xd0, 0xcd, 0xcd, 0xd5, 0xc9, 0xcf, 0xd5, 0xd3, 0xf9, + 0xf3, 0xf4, 0xe5, 0xed, 0xa0, 0xcf, 0xcb, 0x00, 0x4c, 0xb0, 0xc9, 0x20, + 0xf4, 0xce, 0x20, 0x2a, 0xc8, 0x20, 0x2e, 0xcd, 0xa9, 0x01, 0x8d, 0xfb, + 0x04, 0x20, 0x90, 0xca, 0xd0, 0x08, 0x06, 0x21, 0x8d, 0x01, 0xc0, 0x8d, + 0x0d, 0xc0, 0x8d, 0x0f, 0xc0, 0x20, 0x90, 0xcc, 0xac, 0x7b, 0x05, 0x4c, + 0x7e, 0xc8, 0xa9, 0x07, 0x85, 0x36, 0xa9, 0xc3, 0x85, 0x37, 0xa9, 0x05, + 0x85, 0x38, 0xa9, 0xc3, 0x85, 0x39, 0x60, 0xe6, 0x4e, 0xd0, 0x02, 0xe6, + 0x4f, 0xad, 0x00, 0xc0, 0x10, 0xf5, 0x8d, 0x10, 0xc0, 0x60, 0x00, 0x00, + 0x00, 0x4c, 0x50, 0xc3, 0xa5, 0x25, 0x8d, 0xfb, 0x05, 0xa4, 0x24, 0xcc, + 0x7b, 0x04, 0xf0, 0x03, 0x8c, 0x7b, 0x05, 0xa5, 0x21, 0x18, 0xed, 0x7b, + 0x05, 0xb0, 0x05, 0xa0, 0x00, 0x8c, 0x7b, 0x05, 0xac, 0x7b, 0x05, 0x60, + 0xa4, 0x35, 0x18, 0xb0, 0x38, 0x8d, 0x7b, 0x06, 0x98, 0x48, 0x8a, 0x48, + 0xb0, 0x5e, 0x20, 0x50, 0xc8, 0xad, 0x7b, 0x06, 0xc9, 0x8d, 0xd0, 0x18, + 0xae, 0x00, 0xc0, 0x10, 0x13, 0xe0, 0x93, 0xd0, 0x0f, 0x2c, 0x10, 0xc0, + 0xae, 0x00, 0xc0, 0x10, 0xfb, 0xe0, 0x83, 0xf0, 0x03, 0x2c, 0x10, 0xc0, + 0x29, 0x7f, 0xc9, 0x20, 0xb0, 0x06, 0x20, 0xd2, 0xca, 0x4c, 0xbd, 0xc8, + 0xad, 0x7b, 0x06, 0x20, 0x38, 0xce, 0xc8, 0x8c, 0x7b, 0x05, 0xc4, 0x21, + 0x90, 0x03, 0x20, 0x51, 0xcb, 0xad, 0xfb, 0x04, 0x29, 0xf7, 0x8d, 0xfb, + 0x04, 0xad, 0x7b, 0x05, 0x2c, 0x1f, 0xc0, 0x10, 0x02, 0xa9, 0x00, 0x85, + 0x24, 0x8d, 0x7b, 0x04, 0x68, 0xaa, 0x68, 0xa8, 0xad, 0x7b, 0x06, 0x60, + 0xa4, 0x24, 0xad, 0x7b, 0x06, 0x91, 0x28, 0x20, 0x50, 0xc8, 0x20, 0x26, + 0xce, 0x20, 0x3b, 0xc8, 0x8d, 0x7b, 0x06, 0x20, 0x26, 0xce, 0xa8, 0xad, + 0xfb, 0x04, 0x29, 0x08, 0xf0, 0xcb, 0xc0, 0x8d, 0xd0, 0x08, 0xad, 0xfb, + 0x04, 0x29, 0xf7, 0x8d, 0xfb, 0x04, 0xc0, 0x9b, 0xf0, 0x11, 0xc0, 0x95, + 0xd0, 0xb7, 0xac, 0x7b, 0x05, 0x20, 0x44, 0xce, 0x09, 0x80, 0x8d, 0x7b, + 0x06, 0xd0, 0xaa, 0x20, 0xb1, 0xce, 0x20, 0x3b, 0xc8, 0x20, 0xc4, 0xce, + 0x20, 0x14, 0xce, 0x29, 0x7f, 0xa0, 0x10, 0xd9, 0x7c, 0xc9, 0xf0, 0x05, + 0x88, 0x10, 0xf8, 0x30, 0x0f, 0xb9, 0x6b, 0xc9, 0x29, 0x7f, 0x20, 0xd6, + 0xca, 0xb9, 0x6b, 0xc9, 0x30, 0xd9, 0x10, 0xa2, 0xa8, 0xad, 0xfb, 0x04, + 0xc0, 0x11, 0xd0, 0x0b, 0x20, 0x4d, 0xcd, 0xa9, 0x98, 0x8d, 0x7b, 0x06, + 0x4c, 0xc5, 0xc8, 0xc0, 0x05, 0xd0, 0x08, 0x29, 0xdf, 0x8d, 0xfb, 0x04, + 0x4c, 0xe6, 0xc8, 0xc0, 0x04, 0xd0, 0xf9, 0x09, 0x20, 0xd0, 0xf2, 0x0c, + 0x1c, 0x08, 0x0a, 0x1f, 0x1d, 0x0b, 0x9f, 0x88, 0x9c, 0x8a, 0x11, 0x12, + 0x88, 0x8a, 0x9f, 0x9c, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x49, + 0x4a, 0x4b, 0x4d, 0x34, 0x38, 0x08, 0x0a, 0x0b, 0x15, 0x2c, 0x13, 0xc0, + 0x30, 0x11, 0xa9, 0xee, 0x8d, 0x05, 0xc0, 0x8d, 0x03, 0xc0, 0x8d, 0x00, + 0x0c, 0x8d, 0x00, 0x08, 0xcd, 0x00, 0x0c, 0x60, 0xca, 0xcb, 0xcd, 0xc9, + 0x00, 0x00, 0xad, 0x7b, 0x06, 0x4c, 0x56, 0xc3, 0xa9, 0x83, 0xd0, 0x02, + 0xa9, 0x81, 0x48, 0x20, 0x90, 0xca, 0xf0, 0x04, 0x68, 0xa2, 0x09, 0x60, + 0x68, 0x8d, 0xfb, 0x04, 0x8d, 0x01, 0xc0, 0x8d, 0x0d, 0xc0, 0x8d, 0x0f, + 0xc0, 0x20, 0xd4, 0xce, 0x20, 0x90, 0xcc, 0x4c, 0x1f, 0xca, 0x20, 0xd4, + 0xce, 0x20, 0x3b, 0xc8, 0x29, 0x7f, 0x8d, 0x7b, 0x06, 0xa2, 0x00, 0xad, + 0xfb, 0x04, 0x29, 0x02, 0xf0, 0x02, 0xa2, 0xc3, 0xad, 0x7b, 0x06, 0x60, + 0x29, 0x7f, 0xaa, 0x20, 0xd4, 0xce, 0xa9, 0x08, 0x2c, 0xfb, 0x04, 0xd0, + 0x32, 0x8a, 0x2c, 0x2e, 0xca, 0xf0, 0x50, 0xac, 0x7b, 0x05, 0x24, 0x32, + 0x10, 0x02, 0x09, 0x80, 0x20, 0x70, 0xce, 0xc8, 0x8c, 0x7b, 0x05, 0xc4, + 0x21, 0x90, 0x08, 0xa9, 0x00, 0x8d, 0x7b, 0x05, 0x20, 0xd8, 0xcb, 0xa5, + 0x28, 0x8d, 0x7b, 0x07, 0xa5, 0x29, 0x8d, 0xfb, 0x07, 0x20, 0x1f, 0xce, + 0xa2, 0x00, 0x60, 0x20, 0x1f, 0xce, 0x8a, 0x38, 0xe9, 0x20, 0x2c, 0xfb, + 0x06, 0x30, 0x30, 0x8d, 0xfb, 0x05, 0x85, 0x25, 0x20, 0xba, 0xca, 0xad, + 0xfb, 0x06, 0x8d, 0x7b, 0x05, 0xa9, 0xf7, 0x2d, 0xfb, 0x04, 0x8d, 0xfb, + 0x04, 0xd0, 0xcc, 0x20, 0x1f, 0xce, 0x8a, 0xc9, 0x1e, 0xf0, 0x06, 0x20, + 0xd6, 0xca, 0x4c, 0x1f, 0xca, 0xa9, 0x08, 0x0d, 0xfb, 0x04, 0x8d, 0xfb, + 0x04, 0xa9, 0xff, 0x8d, 0xfb, 0x06, 0x4c, 0x29, 0xca, 0xaa, 0xa5, 0x2a, + 0xa0, 0x03, 0xe0, 0x8a, 0xf0, 0x0b, 0x4a, 0x90, 0x08, 0x4a, 0x4a, 0x09, + 0x20, 0x88, 0xd0, 0xfa, 0xc8, 0x88, 0xd0, 0xf2, 0x60, 0x20, 0xb7, 0xf8, + 0xd0, 0x02, 0xc8, 0x60, 0xad, 0x1c, 0xc0, 0x0a, 0xa9, 0x88, 0x2c, 0x18, + 0xc0, 0x8d, 0x01, 0xc0, 0x08, 0x8d, 0x55, 0xc0, 0xac, 0x00, 0x04, 0x8d, + 0x00, 0x04, 0xad, 0x00, 0x04, 0x8c, 0x00, 0x04, 0x28, 0xb0, 0x03, 0x8d, + 0x54, 0xc0, 0x30, 0x03, 0x8d, 0x00, 0xc0, 0xc9, 0x88, 0x60, 0x48, 0x4a, + 0x29, 0x03, 0x09, 0x04, 0x85, 0x29, 0x68, 0x29, 0x18, 0x90, 0x02, 0x69, + 0x7f, 0x85, 0x28, 0x0a, 0x0a, 0x05, 0x28, 0x85, 0x28, 0x60, 0x2c, 0x06, + 0xcb, 0x50, 0xb8, 0x8d, 0x7b, 0x07, 0x48, 0x98, 0x48, 0xac, 0x7b, 0x07, + 0xc0, 0x05, 0x90, 0x13, 0xb9, 0xb4, 0xcb, 0xf0, 0x0e, 0x50, 0x12, 0x30, + 0x10, 0x8d, 0x7b, 0x07, 0xad, 0xfb, 0x04, 0x29, 0x28, 0xf0, 0x03, 0x38, + 0xb0, 0x09, 0xad, 0x7b, 0x07, 0x09, 0x80, 0x20, 0x07, 0xcb, 0x18, 0x68, + 0xa8, 0x68, 0x60, 0x48, 0xb9, 0x99, 0xcb, 0x48, 0x60, 0xad, 0xfb, 0x04, + 0x10, 0x05, 0x29, 0xef, 0x8d, 0xfb, 0x04, 0x60, 0xad, 0xfb, 0x04, 0x10, + 0xfa, 0x09, 0x10, 0xd0, 0xf3, 0xa9, 0x40, 0x20, 0x34, 0xcb, 0xa0, 0xc0, + 0xa9, 0x0c, 0x20, 0x34, 0xcb, 0xad, 0x30, 0xc0, 0x88, 0xd0, 0xf5, 0x60, + 0x38, 0x48, 0xe9, 0x01, 0xd0, 0xfc, 0x68, 0xe9, 0x01, 0xd0, 0xf6, 0x60, + 0xce, 0x7b, 0x05, 0x10, 0x0b, 0xa5, 0x21, 0x8d, 0x7b, 0x05, 0xce, 0x7b, + 0x05, 0x20, 0x79, 0xcb, 0x60, 0xa9, 0x00, 0x8d, 0x7b, 0x05, 0xad, 0xfb, + 0x04, 0x30, 0x03, 0x20, 0xd8, 0xcb, 0x60, 0xa5, 0x22, 0x85, 0x25, 0xa9, + 0x00, 0x8d, 0x7b, 0x05, 0x4c, 0xfe, 0xcd, 0xee, 0x7b, 0x05, 0xad, 0x7b, + 0x05, 0xc5, 0x21, 0x90, 0x03, 0x20, 0x51, 0xcb, 0x60, 0xa5, 0x22, 0xc5, + 0x25, 0xb0, 0x1e, 0xc6, 0x25, 0x4c, 0xfe, 0xcd, 0xad, 0xfb, 0x04, 0x10, + 0x02, 0x29, 0xfb, 0xa0, 0xff, 0xd0, 0x09, 0xad, 0xfb, 0x04, 0x10, 0x02, + 0x09, 0x04, 0xa0, 0x7f, 0x8d, 0xfb, 0x04, 0x84, 0x32, 0x60, 0x0c, 0x17, + 0x20, 0x3f, 0x00, 0xd7, 0x73, 0x8f, 0x50, 0x83, 0x8e, 0x00, 0xe9, 0xfb, + 0x00, 0x00, 0x4c, 0xd3, 0xea, 0x3c, 0x5e, 0x95, 0x43, 0x6a, 0x99, 0x00, + 0x78, 0x4b, 0x4b, 0xcb, 0xcb, 0x00, 0xcb, 0x4c, 0x4c, 0xcb, 0x4b, 0x4b, + 0x00, 0x4c, 0x4c, 0x00, 0x00, 0x4d, 0x4b, 0x4b, 0x4d, 0x4b, 0x4c, 0x4d, + 0x4b, 0x4c, 0x00, 0x4b, 0xa0, 0x00, 0xf0, 0x15, 0xe6, 0x25, 0xa5, 0x25, + 0x8d, 0xfb, 0x05, 0xc5, 0x23, 0xb0, 0x03, 0x4c, 0x03, 0xce, 0xce, 0xfb, + 0x05, 0xc6, 0x25, 0xa0, 0x01, 0x8a, 0x48, 0x8c, 0x7b, 0x07, 0xa5, 0x21, + 0x48, 0x2c, 0x1f, 0xc0, 0x10, 0x1c, 0x8d, 0x01, 0xc0, 0x4a, 0xaa, 0xa5, + 0x20, 0x4a, 0xb8, 0x90, 0x03, 0x2c, 0x06, 0xcb, 0x2a, 0x45, 0x21, 0x4a, + 0x70, 0x03, 0xb0, 0x01, 0xca, 0x86, 0x21, 0xad, 0x1f, 0xc0, 0x08, 0xa6, + 0x22, 0x98, 0xd0, 0x03, 0xa6, 0x23, 0xca, 0x8a, 0x20, 0x03, 0xce, 0xa5, + 0x28, 0x85, 0x2a, 0xa5, 0x29, 0x85, 0x2b, 0xad, 0x7b, 0x07, 0xf0, 0x32, + 0xe8, 0xe4, 0x23, 0xb0, 0x32, 0x8a, 0x20, 0x03, 0xce, 0xa4, 0x21, 0x28, + 0x08, 0x10, 0x1e, 0xad, 0x55, 0xc0, 0x98, 0xf0, 0x07, 0xb1, 0x28, 0x91, + 0x2a, 0x88, 0xd0, 0xf9, 0x70, 0x04, 0xb1, 0x28, 0x91, 0x2a, 0xad, 0x54, + 0xc0, 0xa4, 0x21, 0xb0, 0x04, 0xb1, 0x28, 0x91, 0x2a, 0x88, 0x10, 0xf9, + 0x30, 0xc1, 0xca, 0xe4, 0x22, 0x10, 0xce, 0x28, 0x68, 0x85, 0x21, 0x20, + 0x96, 0xcc, 0x20, 0xfe, 0xcd, 0x68, 0xaa, 0x60, 0x20, 0x9a, 0xcc, 0xa5, + 0x25, 0x48, 0x10, 0x06, 0x20, 0x03, 0xce, 0x20, 0x96, 0xcc, 0xe6, 0x25, + 0xa5, 0x25, 0xc5, 0x23, 0x90, 0xf2, 0x68, 0x85, 0x25, 0x4c, 0xfe, 0xcd, + 0x20, 0x5f, 0xcb, 0x4c, 0x74, 0xcc, 0xa0, 0x00, 0xf0, 0x03, 0xac, 0x7b, + 0x05, 0xa5, 0x32, 0x29, 0x80, 0x09, 0x20, 0x2c, 0x1f, 0xc0, 0x30, 0x15, + 0x91, 0x28, 0xc8, 0xc4, 0x21, 0x90, 0xf9, 0x60, 0x86, 0x2a, 0xa2, 0xd8, + 0xa0, 0x14, 0xa5, 0x32, 0x29, 0xa0, 0x4c, 0xd5, 0xcc, 0x86, 0x2a, 0x48, + 0x98, 0x48, 0x38, 0xe5, 0x21, 0xaa, 0x98, 0x4a, 0xa8, 0x68, 0x45, 0x20, + 0x6a, 0xb0, 0x03, 0x10, 0x01, 0xc8, 0x68, 0xb0, 0x0b, 0x2c, 0x55, 0xc0, + 0x91, 0x28, 0x2c, 0x54, 0xc0, 0xe8, 0xf0, 0x06, 0x91, 0x28, 0xc8, 0xe8, + 0xd0, 0xef, 0xa6, 0x2a, 0x38, 0x60, 0xad, 0xfb, 0x04, 0x30, 0x4d, 0x20, + 0x31, 0xcd, 0x2c, 0x1f, 0xc0, 0x10, 0x12, 0x20, 0x91, 0xcd, 0x90, 0x0d, + 0x20, 0x90, 0xca, 0xd0, 0x3b, 0x2c, 0x1f, 0xc0, 0x30, 0x03, 0x20, 0xc4, + 0xcd, 0xad, 0x7b, 0x05, 0x18, 0x65, 0x20, 0x2c, 0x1f, 0xc0, 0x30, 0x06, + 0xc9, 0x28, 0x90, 0x02, 0xa9, 0x27, 0x8d, 0x7b, 0x05, 0x85, 0x24, 0xa5, + 0x25, 0x20, 0xba, 0xca, 0x2c, 0x1f, 0xc0, 0x10, 0x05, 0x20, 0x71, 0xcd, + 0xf0, 0x03, 0x20, 0x6d, 0xcd, 0xa9, 0x00, 0x2c, 0x1a, 0xc0, 0x30, 0x02, + 0xa9, 0x14, 0x85, 0x22, 0x60, 0xad, 0xfb, 0x04, 0x09, 0x01, 0xd0, 0x05, + 0xad, 0xfb, 0x04, 0x29, 0xfe, 0x8d, 0xfb, 0x04, 0x60, 0xad, 0xfb, 0x04, + 0x30, 0x1a, 0x20, 0x2e, 0xcd, 0x20, 0x80, 0xcd, 0x20, 0x64, 0xcd, 0xa9, + 0xfd, 0x85, 0x39, 0xa9, 0x1b, 0x85, 0x38, 0x60, 0xa9, 0xfd, 0x85, 0x37, + 0xa9, 0xf0, 0x85, 0x36, 0x60, 0xa9, 0x28, 0xd0, 0x02, 0xa9, 0x50, 0x85, + 0x21, 0xa9, 0x18, 0x85, 0x23, 0xa9, 0x00, 0x85, 0x22, 0x85, 0x20, 0x60, + 0x2c, 0x1f, 0xc0, 0x10, 0x03, 0x20, 0xef, 0xcc, 0x8d, 0x0e, 0xc0, 0xa9, + 0xff, 0x8d, 0xfb, 0x04, 0x60, 0x8a, 0x48, 0xa2, 0x17, 0x8d, 0x01, 0xc0, + 0x8a, 0x20, 0xba, 0xca, 0xa0, 0x27, 0x84, 0x2a, 0x98, 0x4a, 0xb0, 0x03, + 0x2c, 0x55, 0xc0, 0xa8, 0xb1, 0x28, 0x2c, 0x54, 0xc0, 0xa4, 0x2a, 0x91, + 0x28, 0x88, 0x10, 0xea, 0xca, 0x30, 0x04, 0xe4, 0x22, 0xb0, 0xdd, 0x8d, + 0x00, 0xc0, 0x8d, 0x0c, 0xc0, 0x4c, 0xf8, 0xcd, 0x8a, 0x48, 0xa2, 0x17, + 0x8a, 0x20, 0xba, 0xca, 0xa0, 0x00, 0x8d, 0x01, 0xc0, 0xb1, 0x28, 0x84, + 0x2a, 0x48, 0x98, 0x4a, 0xb0, 0x03, 0x8d, 0x55, 0xc0, 0xa8, 0x68, 0x91, + 0x28, 0x8d, 0x54, 0xc0, 0xa4, 0x2a, 0xc8, 0xc0, 0x28, 0x90, 0xe6, 0x20, + 0xb0, 0xcc, 0xca, 0x30, 0x04, 0xe4, 0x22, 0xb0, 0xd3, 0x8d, 0x0d, 0xc0, + 0x20, 0xfe, 0xcd, 0x68, 0xaa, 0x60, 0xa5, 0x25, 0x8d, 0xfb, 0x05, 0x20, + 0xba, 0xca, 0xa5, 0x20, 0x2c, 0x1f, 0xc0, 0x10, 0x01, 0x4a, 0x18, 0x65, + 0x28, 0x85, 0x28, 0x60, 0xc9, 0xe1, 0x90, 0x06, 0xc9, 0xfb, 0xb0, 0x02, + 0x29, 0xdf, 0x60, 0xad, 0xfb, 0x04, 0x29, 0x10, 0xd0, 0x11, 0x48, 0x98, + 0x48, 0xac, 0x7b, 0x05, 0x20, 0x44, 0xce, 0x49, 0x80, 0x20, 0x70, 0xce, + 0x68, 0xa8, 0x68, 0x60, 0x48, 0x24, 0x32, 0x30, 0x02, 0x29, 0x7f, 0x20, + 0x70, 0xce, 0x68, 0x60, 0xb1, 0x28, 0x2c, 0x1f, 0xc0, 0x10, 0x19, 0x8d, + 0x01, 0xc0, 0x84, 0x2a, 0x98, 0x45, 0x20, 0x6a, 0xb0, 0x04, 0xad, 0x55, + 0xc0, 0xc8, 0x98, 0x4a, 0xa8, 0xb1, 0x28, 0x2c, 0x54, 0xc0, 0xa4, 0x2a, + 0x2c, 0x1e, 0xc0, 0x10, 0x06, 0xc9, 0x20, 0xb0, 0x02, 0x09, 0x40, 0x60, + 0x48, 0x29, 0xff, 0x30, 0x16, 0xad, 0xfb, 0x04, 0x6a, 0x68, 0x48, 0x90, + 0x0e, 0x2c, 0x1e, 0xc0, 0x10, 0x09, 0x49, 0x40, 0x2c, 0xac, 0xce, 0xf0, + 0x02, 0x49, 0x40, 0x2c, 0x1f, 0xc0, 0x10, 0x1d, 0x8d, 0x01, 0xc0, 0x48, + 0x84, 0x2a, 0x98, 0x45, 0x20, 0x4a, 0xb0, 0x04, 0xad, 0x55, 0xc0, 0xc8, + 0x98, 0x4a, 0xa8, 0x68, 0x91, 0x28, 0xad, 0x54, 0xc0, 0xa4, 0x2a, 0x68, + 0x60, 0x91, 0x28, 0x68, 0x60, 0x48, 0x98, 0x48, 0xac, 0x7b, 0x05, 0x20, + 0x44, 0xce, 0x8d, 0x7b, 0x06, 0x29, 0x80, 0x49, 0xab, 0x4c, 0xcd, 0xce, + 0x48, 0x98, 0x48, 0xac, 0x7b, 0x05, 0xad, 0x7b, 0x06, 0x20, 0x70, 0xce, + 0x68, 0xa8, 0x68, 0x60, 0x20, 0x71, 0xcd, 0xa9, 0xff, 0x85, 0x32, 0xad, + 0xfb, 0x04, 0x29, 0x04, 0xf0, 0x02, 0x46, 0x32, 0xad, 0x7b, 0x07, 0x85, + 0x28, 0xad, 0xfb, 0x07, 0x85, 0x29, 0xad, 0xfb, 0x05, 0x85, 0x25, 0x60, + 0x2c, 0x12, 0xc0, 0x10, 0x3d, 0xa9, 0x06, 0xcd, 0xb3, 0xfb, 0xf0, 0x36, + 0xa2, 0x03, 0x2c, 0x11, 0xc0, 0x30, 0x02, 0xa2, 0x0b, 0x8d, 0xb3, 0xfb, + 0x2c, 0x80, 0xc0, 0xad, 0xb3, 0xfb, 0xc9, 0x06, 0xf0, 0x01, 0xe8, 0x2c, + 0x81, 0xc0, 0x2c, 0x81, 0xc0, 0xa0, 0x00, 0xa9, 0xf8, 0x85, 0x37, 0x84, + 0x36, 0xb1, 0x36, 0x91, 0x36, 0xc8, 0xd0, 0xf9, 0xe6, 0x37, 0xd0, 0xf5, + 0xbd, 0x80, 0xc0, 0xbd, 0x80, 0xc0, 0x60, 0x00, 0x00, 0x00, 0xe9, 0x81, + 0x4a, 0xd0, 0x14, 0xa4, 0x3f, 0xa6, 0x3e, 0xd0, 0x01, 0x88, 0xca, 0x8a, + 0x18, 0xe5, 0x3a, 0x85, 0x3e, 0x10, 0x01, 0xc8, 0x98, 0xe5, 0x3b, 0xd0, + 0x40, 0xa4, 0x2f, 0xb9, 0x3d, 0x00, 0x91, 0x3a, 0x88, 0x10, 0xf8, 0x20, + 0x48, 0xf9, 0x20, 0x1a, 0xfc, 0x20, 0x1a, 0xfc, 0x4c, 0xe3, 0xfc, 0xa5, + 0x3d, 0x20, 0x8e, 0xf8, 0xaa, 0xbd, 0x00, 0xfa, 0xc5, 0x42, 0xd0, 0x13, + 0xbd, 0xc0, 0xf9, 0xc5, 0x43, 0xd0, 0x0c, 0xa5, 0x44, 0xa4, 0x2e, 0xc0, + 0x9d, 0xf0, 0xb3, 0xc5, 0x2e, 0xf0, 0xca, 0xc6, 0x3d, 0xd0, 0xdc, 0xe6, + 0x44, 0xc6, 0x35, 0xf0, 0xd6, 0xa4, 0x34, 0x98, 0xaa, 0x4c, 0xd2, 0xfc, + 0x20, 0xc7, 0xff, 0xad, 0x00, 0x02, 0xc9, 0xa0, 0xf0, 0x12, 0xc9, 0x8d, + 0xd0, 0x01, 0x60, 0x20, 0xa7, 0xff, 0xc9, 0x93, 0xd0, 0xe5, 0x8a, 0xf0, + 0xe2, 0x20, 0x78, 0xfe, 0xa9, 0x03, 0x85, 0x3d, 0x20, 0x13, 0xff, 0x0a, + 0xe9, 0xbe, 0xc9, 0xc2, 0x90, 0xd1, 0x0a, 0x0a, 0xa2, 0x04, 0x0a, 0x26, + 0x42, 0x26, 0x43, 0xca, 0x10, 0xf8, 0xc6, 0x3d, 0xf0, 0xf4, 0x10, 0xe4, + 0xa2, 0x05, 0x20, 0xc8, 0xc4, 0xa5, 0x44, 0x0a, 0x0a, 0x05, 0x35, 0xc9, + 0x20, 0xb0, 0x06, 0xa6, 0x35, 0xf0, 0x02, 0x09, 0x80, 0x85, 0x44, 0x84, + 0x34, 0xb9, 0x00, 0x02, 0xc9, 0xbb, 0xf0, 0x04, 0xc9, 0x8d, 0xd0, 0xb4, + 0x4c, 0x6b, 0xcf, 0xdf, 0x6f, 0xd8, 0x65, 0xd7, 0xf8, 0xdc, 0x94, 0xd9, + 0xb1, 0xdb, 0x30, 0xf3, 0xd8, 0xdf, 0xe1, 0xdb, 0x8f, 0xf3, 0x98, 0xf3, + 0xe4, 0xf1, 0xdd, 0xf1, 0xd4, 0xf1, 0x24, 0xf2, 0x31, 0xf2, 0x40, 0xf2, + 0xd7, 0xf3, 0xe1, 0xf3, 0xe8, 0xf6, 0xfd, 0xf6, 0x68, 0xf7, 0x6e, 0xf7, + 0xe6, 0xf7, 0x57, 0xfc, 0x20, 0xf7, 0x26, 0xf7, 0x74, 0xf7, 0x6c, 0xf2, + 0x6e, 0xf2, 0x72, 0xf2, 0x76, 0xf2, 0x7f, 0xf2, 0x4e, 0xf2, 0x6a, 0xd9, + 0x55, 0xf2, 0x85, 0xf2, 0xa5, 0xf2, 0xca, 0xf2, 0x17, 0xf3, 0xbb, 0xf3, + 0x9e, 0xf3, 0x61, 0xf2, 0x45, 0xda, 0x3d, 0xd9, 0x11, 0xd9, 0xc8, 0xd9, + 0x48, 0xd8, 0xf4, 0x03, 0x20, 0xd9, 0x6a, 0xd9, 0xdb, 0xd9, 0x6d, 0xd8, + 0xeb, 0xd9, 0x83, 0xe7, 0xc8, 0xd8, 0xaf, 0xd8, 0x12, 0xe3, 0x7a, 0xe7, + 0xd4, 0xda, 0x95, 0xd8, 0xa4, 0xd6, 0x69, 0xd6, 0x9f, 0xdb, 0x48, 0xd6, + 0x90, 0xeb, 0x23, 0xec, 0xaf, 0xeb, 0x0a, 0x00, 0xde, 0xe2, 0x12, 0xd4, + 0xcd, 0xdf, 0xff, 0xe2, 0x8d, 0xee, 0xae, 0xef, 0x41, 0xe9, 0x09, 0xef, + 0xea, 0xef, 0xf1, 0xef, 0x3a, 0xf0, 0x9e, 0xf0, 0x64, 0xe7, 0xd6, 0xe6, + 0xc5, 0xe3, 0x07, 0xe7, 0xe5, 0xe6, 0x46, 0xe6, 0x5a, 0xe6, 0x86, 0xe6, + 0x91, 0xe6, 0x79, 0xc0, 0xe7, 0x79, 0xa9, 0xe7, 0x7b, 0x81, 0xe9, 0x7b, + 0x68, 0xea, 0x7d, 0x96, 0xee, 0x50, 0x54, 0xdf, 0x46, 0x4e, 0xdf, 0x7f, + 0xcf, 0xee, 0x7f, 0x97, 0xde, 0x64, 0x64, 0xdf, 0x45, 0x4e, 0xc4, 0x46, + 0x4f, 0xd2, 0x4e, 0x45, 0x58, 0xd4, 0x44, 0x41, 0x54, 0xc1, 0x49, 0x4e, + 0x50, 0x55, 0xd4, 0x44, 0x45, 0xcc, 0x44, 0x49, 0xcd, 0x52, 0x45, 0x41, + 0xc4, 0x47, 0xd2, 0x54, 0x45, 0x58, 0xd4, 0x50, 0x52, 0xa3, 0x49, 0x4e, + 0xa3, 0x43, 0x41, 0x4c, 0xcc, 0x50, 0x4c, 0x4f, 0xd4, 0x48, 0x4c, 0x49, + 0xce, 0x56, 0x4c, 0x49, 0xce, 0x48, 0x47, 0x52, 0xb2, 0x48, 0x47, 0xd2, + 0x48, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0xbd, 0x48, 0x50, 0x4c, 0x4f, 0xd4, + 0x44, 0x52, 0x41, 0xd7, 0x58, 0x44, 0x52, 0x41, 0xd7, 0x48, 0x54, 0x41, + 0xc2, 0x48, 0x4f, 0x4d, 0xc5, 0x52, 0x4f, 0x54, 0xbd, 0x53, 0x43, 0x41, + 0x4c, 0x45, 0xbd, 0x53, 0x48, 0x4c, 0x4f, 0x41, 0xc4, 0x54, 0x52, 0x41, + 0x43, 0xc5, 0x4e, 0x4f, 0x54, 0x52, 0x41, 0x43, 0xc5, 0x4e, 0x4f, 0x52, + 0x4d, 0x41, 0xcc, 0x49, 0x4e, 0x56, 0x45, 0x52, 0x53, 0xc5, 0x46, 0x4c, + 0x41, 0x53, 0xc8, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0xbd, 0x50, 0x4f, 0xd0, + 0x56, 0x54, 0x41, 0xc2, 0x48, 0x49, 0x4d, 0x45, 0x4d, 0xba, 0x4c, 0x4f, + 0x4d, 0x45, 0x4d, 0xba, 0x4f, 0x4e, 0x45, 0x52, 0xd2, 0x52, 0x45, 0x53, + 0x55, 0x4d, 0xc5, 0x52, 0x45, 0x43, 0x41, 0x4c, 0xcc, 0x53, 0x54, 0x4f, + 0x52, 0xc5, 0x53, 0x50, 0x45, 0x45, 0x44, 0xbd, 0x4c, 0x45, 0xd4, 0x47, + 0x4f, 0x54, 0xcf, 0x52, 0x55, 0xce, 0x49, 0xc6, 0x52, 0x45, 0x53, 0x54, + 0x4f, 0x52, 0xc5, 0xa6, 0x47, 0x4f, 0x53, 0x55, 0xc2, 0x52, 0x45, 0x54, + 0x55, 0x52, 0xce, 0x52, 0x45, 0xcd, 0x53, 0x54, 0x4f, 0xd0, 0x4f, 0xce, + 0x57, 0x41, 0x49, 0xd4, 0x4c, 0x4f, 0x41, 0xc4, 0x53, 0x41, 0x56, 0xc5, + 0x44, 0x45, 0xc6, 0x50, 0x4f, 0x4b, 0xc5, 0x50, 0x52, 0x49, 0x4e, 0xd4, + 0x43, 0x4f, 0x4e, 0xd4, 0x4c, 0x49, 0x53, 0xd4, 0x43, 0x4c, 0x45, 0x41, + 0xd2, 0x47, 0x45, 0xd4, 0x4e, 0x45, 0xd7, 0x54, 0x41, 0x42, 0xa8, 0x54, + 0xcf, 0x46, 0xce, 0x53, 0x50, 0x43, 0xa8, 0x54, 0x48, 0x45, 0xce, 0x41, + 0xd4, 0x4e, 0x4f, 0xd4, 0x53, 0x54, 0x45, 0xd0, 0xab, 0xad, 0xaa, 0xaf, + 0xde, 0x41, 0x4e, 0xc4, 0x4f, 0xd2, 0xbe, 0xbd, 0xbc, 0x53, 0x47, 0xce, + 0x49, 0x4e, 0xd4, 0x41, 0x42, 0xd3, 0x55, 0x53, 0xd2, 0x46, 0x52, 0xc5, + 0x53, 0x43, 0x52, 0x4e, 0xa8, 0x50, 0x44, 0xcc, 0x50, 0x4f, 0xd3, 0x53, + 0x51, 0xd2, 0x52, 0x4e, 0xc4, 0x4c, 0x4f, 0xc7, 0x45, 0x58, 0xd0, 0x43, + 0x4f, 0xd3, 0x53, 0x49, 0xce, 0x54, 0x41, 0xce, 0x41, 0x54, 0xce, 0x50, + 0x45, 0x45, 0xcb, 0x4c, 0x45, 0xce, 0x53, 0x54, 0x52, 0xa4, 0x56, 0x41, + 0xcc, 0x41, 0x53, 0xc3, 0x43, 0x48, 0x52, 0xa4, 0x4c, 0x45, 0x46, 0x54, + 0xa4, 0x52, 0x49, 0x47, 0x48, 0x54, 0xa4, 0x4d, 0x49, 0x44, 0xa4, 0x00, + 0x4e, 0x45, 0x58, 0x54, 0x20, 0x57, 0x49, 0x54, 0x48, 0x4f, 0x55, 0x54, + 0x20, 0x46, 0x4f, 0xd2, 0x53, 0x59, 0x4e, 0x54, 0x41, 0xd8, 0x52, 0x45, + 0x54, 0x55, 0x52, 0x4e, 0x20, 0x57, 0x49, 0x54, 0x48, 0x4f, 0x55, 0x54, + 0x20, 0x47, 0x4f, 0x53, 0x55, 0xc2, 0x4f, 0x55, 0x54, 0x20, 0x4f, 0x46, + 0x20, 0x44, 0x41, 0x54, 0xc1, 0x49, 0x4c, 0x4c, 0x45, 0x47, 0x41, 0x4c, + 0x20, 0x51, 0x55, 0x41, 0x4e, 0x54, 0x49, 0x54, 0xd9, 0x4f, 0x56, 0x45, + 0x52, 0x46, 0x4c, 0x4f, 0xd7, 0x4f, 0x55, 0x54, 0x20, 0x4f, 0x46, 0x20, + 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0xd9, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x27, + 0x44, 0x20, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0xd4, 0x42, + 0x41, 0x44, 0x20, 0x53, 0x55, 0x42, 0x53, 0x43, 0x52, 0x49, 0x50, 0xd4, + 0x52, 0x45, 0x44, 0x49, 0x4d, 0x27, 0x44, 0x20, 0x41, 0x52, 0x52, 0x41, + 0xd9, 0x44, 0x49, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x20, 0x42, 0x59, + 0x20, 0x5a, 0x45, 0x52, 0xcf, 0x49, 0x4c, 0x4c, 0x45, 0x47, 0x41, 0x4c, + 0x20, 0x44, 0x49, 0x52, 0x45, 0x43, 0xd4, 0x54, 0x59, 0x50, 0x45, 0x20, + 0x4d, 0x49, 0x53, 0x4d, 0x41, 0x54, 0x43, 0xc8, 0x53, 0x54, 0x52, 0x49, + 0x4e, 0x47, 0x20, 0x54, 0x4f, 0x4f, 0x20, 0x4c, 0x4f, 0x4e, 0xc7, 0x46, + 0x4f, 0x52, 0x4d, 0x55, 0x4c, 0x41, 0x20, 0x54, 0x4f, 0x4f, 0x20, 0x43, + 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0xd8, 0x43, 0x41, 0x4e, 0x27, 0x54, 0x20, + 0x43, 0x4f, 0x4e, 0x54, 0x49, 0x4e, 0x55, 0xc5, 0x55, 0x4e, 0x44, 0x45, + 0x46, 0x27, 0x44, 0x20, 0x46, 0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0xce, + 0x20, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x07, 0x00, 0x20, 0x49, 0x4e, 0x20, + 0x00, 0x0d, 0x42, 0x52, 0x45, 0x41, 0x4b, 0x07, 0x00, 0xba, 0xe8, 0xe8, + 0xe8, 0xe8, 0xbd, 0x01, 0x01, 0xc9, 0x81, 0xd0, 0x21, 0xa5, 0x86, 0xd0, + 0x0a, 0xbd, 0x02, 0x01, 0x85, 0x85, 0xbd, 0x03, 0x01, 0x85, 0x86, 0xdd, + 0x03, 0x01, 0xd0, 0x07, 0xa5, 0x85, 0xdd, 0x02, 0x01, 0xf0, 0x07, 0x8a, + 0x18, 0x69, 0x12, 0xaa, 0xd0, 0xd8, 0x60, 0x20, 0xe3, 0xd3, 0x85, 0x6d, + 0x84, 0x6e, 0x38, 0xa5, 0x96, 0xe5, 0x9b, 0x85, 0x5e, 0xa8, 0xa5, 0x97, + 0xe5, 0x9c, 0xaa, 0xe8, 0x98, 0xf0, 0x23, 0xa5, 0x96, 0x38, 0xe5, 0x5e, + 0x85, 0x96, 0xb0, 0x03, 0xc6, 0x97, 0x38, 0xa5, 0x94, 0xe5, 0x5e, 0x85, + 0x94, 0xb0, 0x08, 0xc6, 0x95, 0x90, 0x04, 0xb1, 0x96, 0x91, 0x94, 0x88, + 0xd0, 0xf9, 0xb1, 0x96, 0x91, 0x94, 0xc6, 0x97, 0xc6, 0x95, 0xca, 0xd0, + 0xf2, 0x60, 0x0a, 0x69, 0x36, 0xb0, 0x35, 0x85, 0x5e, 0xba, 0xe4, 0x5e, + 0x90, 0x2e, 0x60, 0xc4, 0x70, 0x90, 0x28, 0xd0, 0x04, 0xc5, 0x6f, 0x90, + 0x22, 0x48, 0xa2, 0x09, 0x98, 0x48, 0xb5, 0x93, 0xca, 0x10, 0xfa, 0x20, + 0x84, 0xe4, 0xa2, 0xf7, 0x68, 0x95, 0x9d, 0xe8, 0x30, 0xfa, 0x68, 0xa8, + 0x68, 0xc4, 0x70, 0x90, 0x06, 0xd0, 0x05, 0xc5, 0x6f, 0xb0, 0x01, 0x60, + 0xa2, 0x4d, 0x24, 0xd8, 0x10, 0x03, 0x4c, 0xe9, 0xf2, 0x20, 0xfb, 0xda, + 0x20, 0x5a, 0xdb, 0xbd, 0x60, 0xd2, 0x48, 0x20, 0x5c, 0xdb, 0xe8, 0x68, + 0x10, 0xf5, 0x20, 0x83, 0xd6, 0xa9, 0x50, 0xa0, 0xd3, 0x20, 0x3a, 0xdb, + 0xa4, 0x76, 0xc8, 0xf0, 0x03, 0x20, 0x19, 0xed, 0x20, 0xfb, 0xda, 0xa2, + 0xdd, 0x20, 0x2e, 0xd5, 0x86, 0xb8, 0x84, 0xb9, 0x46, 0xd8, 0x20, 0xb1, + 0x00, 0xaa, 0xf0, 0xec, 0xa2, 0xff, 0x86, 0x76, 0x90, 0x06, 0x20, 0x59, + 0xd5, 0x4c, 0x05, 0xd8, 0xa6, 0xaf, 0x86, 0x69, 0xa6, 0xb0, 0x86, 0x6a, + 0x20, 0x0c, 0xda, 0x20, 0x59, 0xd5, 0x84, 0x0f, 0x20, 0x1a, 0xd6, 0x90, + 0x44, 0xa0, 0x01, 0xb1, 0x9b, 0x85, 0x5f, 0xa5, 0x69, 0x85, 0x5e, 0xa5, + 0x9c, 0x85, 0x61, 0xa5, 0x9b, 0x88, 0xf1, 0x9b, 0x18, 0x65, 0x69, 0x85, + 0x69, 0x85, 0x60, 0xa5, 0x6a, 0x69, 0xff, 0x85, 0x6a, 0xe5, 0x9c, 0xaa, + 0x38, 0xa5, 0x9b, 0xe5, 0x69, 0xa8, 0xb0, 0x03, 0xe8, 0xc6, 0x61, 0x18, + 0x65, 0x5e, 0x90, 0x03, 0xc6, 0x5f, 0x18, 0xb1, 0x5e, 0x91, 0x60, 0xc8, + 0xd0, 0xf9, 0xe6, 0x5f, 0xe6, 0x61, 0xca, 0xd0, 0xf2, 0xad, 0x00, 0x02, + 0xf0, 0x38, 0xa5, 0x73, 0xa4, 0x74, 0x85, 0x6f, 0x84, 0x70, 0xa5, 0x69, + 0x85, 0x96, 0x65, 0x0f, 0x85, 0x94, 0xa4, 0x6a, 0x84, 0x97, 0x90, 0x01, + 0xc8, 0x84, 0x95, 0x20, 0x93, 0xd3, 0xa5, 0x50, 0xa4, 0x51, 0x8d, 0xfe, + 0x01, 0x8c, 0xff, 0x01, 0xa5, 0x6d, 0xa4, 0x6e, 0x85, 0x69, 0x84, 0x6a, + 0xa4, 0x0f, 0xb9, 0xfb, 0x01, 0x88, 0x91, 0x9b, 0xd0, 0xf8, 0x20, 0x65, + 0xd6, 0xa5, 0x67, 0xa4, 0x68, 0x85, 0x5e, 0x84, 0x5f, 0x18, 0xa0, 0x01, + 0xb1, 0x5e, 0xd0, 0x0b, 0xa5, 0x69, 0x85, 0xaf, 0xa5, 0x6a, 0x85, 0xb0, + 0x4c, 0x3c, 0xd4, 0xa0, 0x04, 0xc8, 0xb1, 0x5e, 0xd0, 0xfb, 0xc8, 0x98, + 0x65, 0x5e, 0xaa, 0xa0, 0x00, 0x91, 0x5e, 0xa5, 0x5f, 0x69, 0x00, 0xc8, + 0x91, 0x5e, 0x86, 0x5e, 0x85, 0x5f, 0x90, 0xd2, 0xa2, 0x80, 0x86, 0x33, + 0x20, 0x6a, 0xfd, 0xe0, 0xef, 0x90, 0x02, 0xa2, 0xef, 0xa9, 0x00, 0x9d, + 0x00, 0x02, 0x8a, 0xf0, 0x0b, 0xbd, 0xff, 0x01, 0x29, 0x7f, 0x9d, 0xff, + 0x01, 0xca, 0xd0, 0xf5, 0xa9, 0x00, 0xa2, 0xff, 0xa0, 0x01, 0x60, 0x20, + 0x0c, 0xfd, 0x29, 0x7f, 0x60, 0xa6, 0xb8, 0xca, 0xa0, 0x04, 0x84, 0x13, + 0x24, 0xd6, 0x10, 0x08, 0x68, 0x68, 0x20, 0x65, 0xd6, 0x4c, 0xd2, 0xd7, + 0xe8, 0x20, 0x8c, 0xf7, 0x24, 0x13, 0x70, 0x04, 0xc9, 0x20, 0xf0, 0xf4, + 0x85, 0x0e, 0xc9, 0x22, 0xf0, 0x74, 0x70, 0x4d, 0xc9, 0x3f, 0xd0, 0x04, + 0xa9, 0xba, 0xd0, 0x45, 0xc9, 0x30, 0x90, 0x04, 0xc9, 0x3c, 0x90, 0x3d, + 0x84, 0xad, 0xa9, 0xd0, 0x85, 0x9d, 0xa9, 0xcf, 0x85, 0x9e, 0xa0, 0x00, + 0x84, 0x0f, 0x88, 0x86, 0xb8, 0xca, 0xc8, 0xd0, 0x02, 0xe6, 0x9e, 0xe8, + 0x20, 0x8c, 0xf7, 0xc9, 0x20, 0xf0, 0xf8, 0x38, 0xf1, 0x9d, 0xf0, 0xee, + 0xc9, 0x80, 0xd0, 0x41, 0x05, 0x0f, 0xc9, 0xc5, 0xd0, 0x0d, 0x20, 0x87, + 0xf7, 0xc9, 0x4e, 0xf0, 0x34, 0xc9, 0x4f, 0xf0, 0x30, 0xa9, 0xc5, 0xa4, + 0xad, 0xe8, 0xc8, 0x99, 0xfb, 0x01, 0xb9, 0xfb, 0x01, 0xf0, 0x39, 0x38, + 0xe9, 0x3a, 0xf0, 0x04, 0xc9, 0x49, 0xd0, 0x02, 0x85, 0x13, 0x38, 0xe9, + 0x78, 0xd0, 0x86, 0x85, 0x0e, 0x20, 0x8c, 0xf7, 0xf0, 0xdf, 0xc5, 0x0e, + 0xf0, 0xdb, 0xc8, 0x99, 0xfb, 0x01, 0xe8, 0xd0, 0xf0, 0xa6, 0xb8, 0xe6, + 0x0f, 0xb1, 0x9d, 0xc8, 0xd0, 0x02, 0xe6, 0x9e, 0x0a, 0x90, 0xf6, 0xb1, + 0x9d, 0xd0, 0x9d, 0x20, 0x9a, 0xf7, 0x10, 0xbb, 0x99, 0xfd, 0x01, 0xc6, + 0xb9, 0xa9, 0xff, 0x85, 0xb8, 0x60, 0xa5, 0x67, 0xa6, 0x68, 0xa0, 0x01, + 0x85, 0x9b, 0x86, 0x9c, 0xb1, 0x9b, 0xf0, 0x1f, 0xc8, 0xc8, 0xa5, 0x51, + 0xd1, 0x9b, 0x90, 0x18, 0xf0, 0x03, 0x88, 0xd0, 0x09, 0xa5, 0x50, 0x88, + 0xd1, 0x9b, 0x90, 0x0c, 0xf0, 0x0a, 0x88, 0xb1, 0x9b, 0xaa, 0x88, 0xb1, + 0x9b, 0xb0, 0xd7, 0x18, 0x60, 0xd0, 0xfd, 0xa9, 0x00, 0x85, 0xd6, 0xa8, + 0x91, 0x67, 0xc8, 0x91, 0x67, 0xa5, 0x67, 0x69, 0x02, 0x85, 0x69, 0x85, + 0xaf, 0xa5, 0x68, 0x69, 0x00, 0x85, 0x6a, 0x85, 0xb0, 0x20, 0x97, 0xd6, + 0xa9, 0x00, 0xd0, 0x2a, 0xa5, 0x73, 0xa4, 0x74, 0x85, 0x6f, 0x84, 0x70, + 0xa5, 0x69, 0xa4, 0x6a, 0x85, 0x6b, 0x84, 0x6c, 0x85, 0x6d, 0x84, 0x6e, + 0x20, 0x49, 0xd8, 0xa2, 0x55, 0x86, 0x52, 0x68, 0xa8, 0x68, 0xa2, 0xf8, + 0x9a, 0x48, 0x98, 0x48, 0xa9, 0x00, 0x85, 0x7a, 0x85, 0x14, 0x60, 0x18, + 0xa5, 0x67, 0x69, 0xff, 0x85, 0xb8, 0xa5, 0x68, 0x69, 0xff, 0x85, 0xb9, + 0x60, 0x90, 0x0a, 0xf0, 0x08, 0xc9, 0xc9, 0xf0, 0x04, 0xc9, 0x2c, 0xd0, + 0xe5, 0x20, 0x0c, 0xda, 0x20, 0x1a, 0xd6, 0x20, 0xb7, 0x00, 0xf0, 0x10, + 0xc9, 0xc9, 0xf0, 0x04, 0xc9, 0x2c, 0xd0, 0x84, 0x20, 0xb1, 0x00, 0x20, + 0x0c, 0xda, 0xd0, 0xca, 0x68, 0x68, 0xa5, 0x50, 0x05, 0x51, 0xd0, 0x06, + 0xa9, 0xff, 0x85, 0x50, 0x85, 0x51, 0xa0, 0x01, 0xb1, 0x9b, 0xf0, 0x44, + 0x20, 0x58, 0xd8, 0x20, 0xfb, 0xda, 0xc8, 0xb1, 0x9b, 0xaa, 0xc8, 0xb1, + 0x9b, 0xc5, 0x51, 0xd0, 0x04, 0xe4, 0x50, 0xf0, 0x02, 0xb0, 0x2d, 0x84, + 0x85, 0x20, 0xaa, 0xf7, 0xa9, 0x20, 0xa4, 0x85, 0x29, 0x7f, 0x20, 0x5c, + 0xdb, 0x20, 0xb4, 0xf7, 0xea, 0x90, 0x07, 0x20, 0xfb, 0xda, 0xa9, 0x05, + 0x85, 0x24, 0xc8, 0xb1, 0x9b, 0xd0, 0x1d, 0xa8, 0xb1, 0x9b, 0xaa, 0xc8, + 0xb1, 0x9b, 0x86, 0x9b, 0x85, 0x9c, 0xd0, 0xb6, 0xa9, 0x0d, 0x20, 0x5c, + 0xdb, 0x4c, 0xd2, 0xd7, 0xc8, 0xd0, 0x02, 0xe6, 0x9e, 0xb1, 0x9d, 0x60, + 0x10, 0xcc, 0x38, 0xe9, 0x7f, 0xaa, 0x84, 0x85, 0xa0, 0xd0, 0x84, 0x9d, + 0xa0, 0xcf, 0x84, 0x9e, 0xa0, 0xff, 0xca, 0xf0, 0x07, 0x20, 0x2c, 0xd7, + 0x10, 0xfb, 0x30, 0xf6, 0xa9, 0x20, 0x20, 0x5c, 0xdb, 0x20, 0x2c, 0xd7, + 0x30, 0x05, 0x20, 0x5c, 0xdb, 0xd0, 0xf6, 0x20, 0x5c, 0xdb, 0xa9, 0x20, + 0xd0, 0x98, 0xa9, 0x80, 0x85, 0x14, 0x20, 0x46, 0xda, 0x20, 0x65, 0xd3, + 0xd0, 0x05, 0x8a, 0x69, 0x0f, 0xaa, 0x9a, 0x68, 0x68, 0xa9, 0x09, 0x20, + 0xd6, 0xd3, 0x20, 0xa3, 0xd9, 0x18, 0x98, 0x65, 0xb8, 0x48, 0xa5, 0xb9, + 0x69, 0x00, 0x48, 0xa5, 0x76, 0x48, 0xa5, 0x75, 0x48, 0xa9, 0xc1, 0x20, + 0xc0, 0xde, 0x20, 0x6a, 0xdd, 0x20, 0x67, 0xdd, 0xa5, 0xa2, 0x09, 0x7f, + 0x25, 0x9e, 0x85, 0x9e, 0xa9, 0xaf, 0xa0, 0xd7, 0x85, 0x5e, 0x84, 0x5f, + 0x4c, 0x20, 0xde, 0xa9, 0x13, 0xa0, 0xe9, 0x20, 0xf9, 0xea, 0x20, 0xb7, + 0x00, 0xc9, 0xc7, 0xd0, 0x06, 0x20, 0xb1, 0x00, 0x20, 0x67, 0xdd, 0x20, + 0x82, 0xeb, 0x20, 0x15, 0xde, 0xa5, 0x86, 0x48, 0xa5, 0x85, 0x48, 0xa9, + 0x81, 0x48, 0xba, 0x86, 0xf8, 0x20, 0x58, 0xd8, 0xa5, 0xb8, 0xa4, 0xb9, + 0xa6, 0x76, 0xe8, 0xf0, 0x04, 0x85, 0x79, 0x84, 0x7a, 0xa0, 0x00, 0xb1, + 0xb8, 0xd0, 0x57, 0xa0, 0x02, 0xb1, 0xb8, 0x18, 0xf0, 0x34, 0xc8, 0xb1, + 0xb8, 0x85, 0x75, 0xc8, 0xb1, 0xb8, 0x85, 0x76, 0x98, 0x65, 0xb8, 0x85, + 0xb8, 0x90, 0x02, 0xe6, 0xb9, 0x24, 0xf2, 0x10, 0x14, 0xa6, 0x76, 0xe8, + 0xf0, 0x0f, 0xa9, 0x23, 0x20, 0x5c, 0xdb, 0xa6, 0x75, 0xa5, 0x76, 0x20, + 0x24, 0xed, 0x20, 0x57, 0xdb, 0x20, 0xb1, 0x00, 0x20, 0x28, 0xd8, 0x4c, + 0xd2, 0xd7, 0xf0, 0x62, 0xf0, 0x2d, 0xe9, 0x80, 0x90, 0x11, 0xc9, 0x40, + 0xb0, 0x14, 0x0a, 0xa8, 0xb9, 0x01, 0xd0, 0x48, 0xb9, 0x00, 0xd0, 0x48, + 0x4c, 0xb1, 0x00, 0x4c, 0x46, 0xda, 0xc9, 0x3a, 0xf0, 0xbf, 0x4c, 0xc9, + 0xde, 0x38, 0xa5, 0x67, 0xe9, 0x01, 0xa4, 0x68, 0xb0, 0x01, 0x88, 0x85, + 0x7d, 0x84, 0x7e, 0x60, 0xad, 0x00, 0xc0, 0xc9, 0x83, 0xf0, 0x01, 0x60, + 0x20, 0x53, 0xd5, 0xa2, 0xff, 0x24, 0xd8, 0x10, 0x03, 0x4c, 0xe9, 0xf2, + 0xc9, 0x03, 0xb0, 0x01, 0x18, 0xd0, 0x3c, 0xa5, 0xb8, 0xa4, 0xb9, 0xa6, + 0x76, 0xe8, 0xf0, 0x0c, 0x85, 0x79, 0x84, 0x7a, 0xa5, 0x75, 0xa4, 0x76, + 0x85, 0x77, 0x84, 0x78, 0x68, 0x68, 0xa9, 0x5d, 0xa0, 0xd3, 0x90, 0x03, + 0x4c, 0x31, 0xd4, 0x4c, 0x3c, 0xd4, 0xd0, 0x17, 0xa2, 0xd2, 0xa4, 0x7a, + 0xd0, 0x03, 0x4c, 0x12, 0xd4, 0xa5, 0x79, 0x85, 0xb8, 0x84, 0xb9, 0xa5, + 0x77, 0xa4, 0x78, 0x85, 0x75, 0x84, 0x76, 0x60, 0x38, 0xa5, 0xaf, 0xe5, + 0x67, 0x85, 0x50, 0xa5, 0xb0, 0xe5, 0x68, 0x85, 0x51, 0x20, 0xf0, 0xd8, + 0x20, 0xcd, 0xfe, 0x20, 0x01, 0xd9, 0x4c, 0xcd, 0xfe, 0x20, 0xf0, 0xd8, + 0x20, 0xfd, 0xfe, 0x18, 0xa5, 0x67, 0x65, 0x50, 0x85, 0x69, 0xa5, 0x68, + 0x65, 0x51, 0x85, 0x6a, 0xa5, 0x52, 0x85, 0xd6, 0x20, 0x01, 0xd9, 0x20, + 0xfd, 0xfe, 0x24, 0xd6, 0x10, 0x03, 0x4c, 0x65, 0xd6, 0x4c, 0xf2, 0xd4, + 0xa9, 0x50, 0xa0, 0x00, 0x85, 0x3c, 0x84, 0x3d, 0xa9, 0x52, 0x85, 0x3e, + 0x84, 0x3f, 0x84, 0xd6, 0x60, 0xa5, 0x67, 0xa4, 0x68, 0x85, 0x3c, 0x84, + 0x3d, 0xa5, 0x69, 0xa4, 0x6a, 0x85, 0x3e, 0x84, 0x3f, 0x60, 0x08, 0xc6, + 0x76, 0x28, 0xd0, 0x03, 0x4c, 0x65, 0xd6, 0x20, 0x6c, 0xd6, 0x4c, 0x35, + 0xd9, 0xa9, 0x03, 0x20, 0xd6, 0xd3, 0xa5, 0xb9, 0x48, 0xa5, 0xb8, 0x48, + 0xa5, 0x76, 0x48, 0xa5, 0x75, 0x48, 0xa9, 0xb0, 0x48, 0x20, 0xb7, 0x00, + 0x20, 0x3e, 0xd9, 0x4c, 0xd2, 0xd7, 0x20, 0x0c, 0xda, 0x20, 0xa6, 0xd9, + 0xa5, 0x76, 0xc5, 0x51, 0xb0, 0x0b, 0x98, 0x38, 0x65, 0xb8, 0xa6, 0xb9, + 0x90, 0x07, 0xe8, 0xb0, 0x04, 0xa5, 0x67, 0xa6, 0x68, 0x20, 0x1e, 0xd6, + 0x90, 0x1e, 0xa5, 0x9b, 0xe9, 0x01, 0x85, 0xb8, 0xa5, 0x9c, 0xe9, 0x00, + 0x85, 0xb9, 0x60, 0xd0, 0xfd, 0xa9, 0xff, 0x85, 0x85, 0x20, 0x65, 0xd3, + 0x9a, 0xc9, 0xb0, 0xf0, 0x0b, 0xa2, 0x16, 0x2c, 0xa2, 0x5a, 0x4c, 0x12, + 0xd4, 0x4c, 0xc9, 0xde, 0x68, 0x68, 0xc0, 0x42, 0xf0, 0x3b, 0x85, 0x75, + 0x68, 0x85, 0x76, 0x68, 0x85, 0xb8, 0x68, 0x85, 0xb9, 0x20, 0xa3, 0xd9, + 0x98, 0x18, 0x65, 0xb8, 0x85, 0xb8, 0x90, 0x02, 0xe6, 0xb9, 0x60, 0xa2, + 0x3a, 0x2c, 0xa2, 0x00, 0x86, 0x0d, 0xa0, 0x00, 0x84, 0x0e, 0xa5, 0x0e, + 0xa6, 0x0d, 0x85, 0x0d, 0x86, 0x0e, 0xb1, 0xb8, 0xf0, 0xe8, 0xc5, 0x0e, + 0xf0, 0xe4, 0xc8, 0xc9, 0x22, 0xd0, 0xf3, 0xf0, 0xe9, 0x68, 0x68, 0x68, + 0x60, 0x20, 0x7b, 0xdd, 0x20, 0xb7, 0x00, 0xc9, 0xab, 0xf0, 0x05, 0xa9, + 0xc4, 0x20, 0xc0, 0xde, 0xa5, 0x9d, 0xd0, 0x05, 0x20, 0xa6, 0xd9, 0xf0, + 0xb7, 0x20, 0xb7, 0x00, 0xb0, 0x03, 0x4c, 0x3e, 0xd9, 0x4c, 0x28, 0xd8, + 0x20, 0xf8, 0xe6, 0x48, 0xc9, 0xb0, 0xf0, 0x04, 0xc9, 0xab, 0xd0, 0x89, + 0xc6, 0xa1, 0xd0, 0x04, 0x68, 0x4c, 0x2a, 0xd8, 0x20, 0xb1, 0x00, 0x20, + 0x0c, 0xda, 0xc9, 0x2c, 0xf0, 0xee, 0x68, 0x60, 0xa2, 0x00, 0x86, 0x50, + 0x86, 0x51, 0xb0, 0xf7, 0xe9, 0x2f, 0x85, 0x0d, 0xa5, 0x51, 0x85, 0x5e, + 0xc9, 0x19, 0xb0, 0xd4, 0xa5, 0x50, 0x0a, 0x26, 0x5e, 0x0a, 0x26, 0x5e, + 0x65, 0x50, 0x85, 0x50, 0xa5, 0x5e, 0x65, 0x51, 0x85, 0x51, 0x06, 0x50, + 0x26, 0x51, 0xa5, 0x50, 0x65, 0x0d, 0x85, 0x50, 0x90, 0x02, 0xe6, 0x51, + 0x20, 0xb1, 0x00, 0x4c, 0x12, 0xda, 0x20, 0xe3, 0xdf, 0x85, 0x85, 0x84, + 0x86, 0xa9, 0xd0, 0x20, 0xc0, 0xde, 0xa5, 0x12, 0x48, 0xa5, 0x11, 0x48, + 0x20, 0x7b, 0xdd, 0x68, 0x2a, 0x20, 0x6d, 0xdd, 0xd0, 0x18, 0x68, 0x10, + 0x12, 0x20, 0x72, 0xeb, 0x20, 0x0c, 0xe1, 0xa0, 0x00, 0xa5, 0xa0, 0x91, + 0x85, 0xc8, 0xa5, 0xa1, 0x91, 0x85, 0x60, 0x4c, 0x27, 0xeb, 0x68, 0xa0, + 0x02, 0xb1, 0xa0, 0xc5, 0x70, 0x90, 0x17, 0xd0, 0x07, 0x88, 0xb1, 0xa0, + 0xc5, 0x6f, 0x90, 0x0e, 0xa4, 0xa1, 0xc4, 0x6a, 0x90, 0x08, 0xd0, 0x0d, + 0xa5, 0xa0, 0xc5, 0x69, 0xb0, 0x07, 0xa5, 0xa0, 0xa4, 0xa1, 0x4c, 0xb7, + 0xda, 0xa0, 0x00, 0xb1, 0xa0, 0x20, 0xd5, 0xe3, 0xa5, 0x8c, 0xa4, 0x8d, + 0x85, 0xab, 0x84, 0xac, 0x20, 0xd4, 0xe5, 0xa9, 0x9d, 0xa0, 0x00, 0x85, + 0x8c, 0x84, 0x8d, 0x20, 0x35, 0xe6, 0xa0, 0x00, 0xb1, 0x8c, 0x91, 0x85, + 0xc8, 0xb1, 0x8c, 0x91, 0x85, 0xc8, 0xb1, 0x8c, 0x91, 0x85, 0x60, 0x20, + 0x3d, 0xdb, 0x20, 0xb7, 0x00, 0xf0, 0x24, 0xf0, 0x29, 0xc9, 0xc0, 0xf0, + 0x3c, 0xc9, 0xc3, 0x18, 0xf0, 0x37, 0xc9, 0x2c, 0x18, 0xf0, 0x1c, 0xc9, + 0x3b, 0xf0, 0x44, 0x20, 0x7b, 0xdd, 0x24, 0x11, 0x30, 0xdd, 0x20, 0x34, + 0xed, 0x20, 0xe7, 0xe3, 0x4c, 0xcf, 0xda, 0xa9, 0x0d, 0x20, 0x5c, 0xdb, + 0x49, 0xff, 0x60, 0x20, 0xb4, 0xf7, 0x30, 0x09, 0xc9, 0x18, 0x90, 0x05, + 0x20, 0xfb, 0xda, 0xd0, 0x1e, 0x69, 0x10, 0x29, 0xf0, 0xaa, 0x38, 0xb0, + 0x0c, 0x08, 0x20, 0xf5, 0xe6, 0xc9, 0x29, 0xd0, 0x62, 0x28, 0x90, 0x07, + 0xca, 0x20, 0xc3, 0xf7, 0x90, 0x05, 0xaa, 0xe8, 0xca, 0xd0, 0x06, 0x20, + 0xb1, 0x00, 0x4c, 0xd7, 0xda, 0x20, 0x57, 0xdb, 0xd0, 0xf2, 0x20, 0xe7, + 0xe3, 0x20, 0x00, 0xe6, 0xaa, 0xa0, 0x00, 0xe8, 0xca, 0xf0, 0xbb, 0xb1, + 0x5e, 0x20, 0x5c, 0xdb, 0xc8, 0xc9, 0x0d, 0xd0, 0xf3, 0x20, 0x00, 0xdb, + 0x4c, 0x44, 0xdb, 0xa9, 0x20, 0x2c, 0xa9, 0x3f, 0x09, 0x80, 0xc9, 0xa0, + 0x90, 0x02, 0x05, 0xf3, 0x20, 0xed, 0xfd, 0x29, 0x7f, 0x48, 0xa5, 0xf1, + 0x20, 0xa8, 0xfc, 0x68, 0x60, 0xa5, 0x15, 0xf0, 0x12, 0x30, 0x04, 0xa0, + 0xff, 0xd0, 0x04, 0xa5, 0x7b, 0xa4, 0x7c, 0x85, 0x75, 0x84, 0x76, 0x4c, + 0xc9, 0xde, 0x68, 0x24, 0xd8, 0x10, 0x05, 0xa2, 0xfe, 0x4c, 0xe9, 0xf2, + 0xa9, 0xef, 0xa0, 0xdc, 0x20, 0x3a, 0xdb, 0xa5, 0x79, 0xa4, 0x7a, 0x85, + 0xb8, 0x84, 0xb9, 0x60, 0x20, 0x06, 0xe3, 0xa2, 0x01, 0xa0, 0x02, 0xa9, + 0x00, 0x8d, 0x01, 0x02, 0xa9, 0x40, 0x20, 0xeb, 0xdb, 0x60, 0xc9, 0x22, + 0xd0, 0x0e, 0x20, 0x81, 0xde, 0xa9, 0x3b, 0x20, 0xc0, 0xde, 0x20, 0x3d, + 0xdb, 0x4c, 0xc7, 0xdb, 0x20, 0x5a, 0xdb, 0x20, 0x06, 0xe3, 0xa9, 0x2c, + 0x8d, 0xff, 0x01, 0x20, 0x2c, 0xd5, 0xad, 0x00, 0x02, 0xc9, 0x03, 0xd0, + 0x10, 0x4c, 0x63, 0xd8, 0x20, 0x5a, 0xdb, 0x4c, 0x2c, 0xd5, 0xa6, 0x7d, + 0xa4, 0x7e, 0xa9, 0x98, 0x2c, 0xa9, 0x00, 0x85, 0x15, 0x86, 0x7f, 0x84, + 0x80, 0x20, 0xe3, 0xdf, 0x85, 0x85, 0x84, 0x86, 0xa5, 0xb8, 0xa4, 0xb9, + 0x85, 0x87, 0x84, 0x88, 0xa6, 0x7f, 0xa4, 0x80, 0x86, 0xb8, 0x84, 0xb9, + 0x20, 0xb7, 0x00, 0xd0, 0x1e, 0x24, 0x15, 0x50, 0x0e, 0x20, 0x0c, 0xfd, + 0x29, 0x7f, 0x8d, 0x00, 0x02, 0xa2, 0xff, 0xa0, 0x01, 0xd0, 0x08, 0x30, + 0x7f, 0x20, 0x5a, 0xdb, 0x20, 0xdc, 0xdb, 0x86, 0xb8, 0x84, 0xb9, 0x20, + 0xb1, 0x00, 0x24, 0x11, 0x10, 0x31, 0x24, 0x15, 0x50, 0x09, 0xe8, 0x86, + 0xb8, 0xa9, 0x00, 0x85, 0x0d, 0xf0, 0x0c, 0x85, 0x0d, 0xc9, 0x22, 0xf0, + 0x07, 0xa9, 0x3a, 0x85, 0x0d, 0xa9, 0x2c, 0x18, 0x85, 0x0e, 0xa5, 0xb8, + 0xa4, 0xb9, 0x69, 0x00, 0x90, 0x01, 0xc8, 0x20, 0xed, 0xe3, 0x20, 0x3d, + 0xe7, 0x20, 0x7b, 0xda, 0x4c, 0x72, 0xdc, 0x48, 0xad, 0x00, 0x02, 0xf0, + 0x30, 0x68, 0x20, 0x4a, 0xec, 0xa5, 0x12, 0x20, 0x63, 0xda, 0x20, 0xb7, + 0x00, 0xf0, 0x07, 0xc9, 0x2c, 0xf0, 0x03, 0x4c, 0x71, 0xdb, 0xa5, 0xb8, + 0xa4, 0xb9, 0x85, 0x7f, 0x84, 0x80, 0xa5, 0x87, 0xa4, 0x88, 0x85, 0xb8, + 0x84, 0xb9, 0x20, 0xb7, 0x00, 0xf0, 0x33, 0x20, 0xbe, 0xde, 0x4c, 0xf1, + 0xdb, 0xa5, 0x15, 0xd0, 0xcc, 0x4c, 0x86, 0xdb, 0x20, 0xa3, 0xd9, 0xc8, + 0xaa, 0xd0, 0x12, 0xa2, 0x2a, 0xc8, 0xb1, 0xb8, 0xf0, 0x5f, 0xc8, 0xb1, + 0xb8, 0x85, 0x7b, 0xc8, 0xb1, 0xb8, 0xc8, 0x85, 0x7c, 0xb1, 0xb8, 0xaa, + 0x20, 0x98, 0xd9, 0xe0, 0x83, 0xd0, 0xdd, 0x4c, 0x2b, 0xdc, 0xa5, 0x7f, + 0xa4, 0x80, 0xa6, 0x15, 0x10, 0x03, 0x4c, 0x53, 0xd8, 0xa0, 0x00, 0xb1, + 0x7f, 0xf0, 0x07, 0xa9, 0xdf, 0xa0, 0xdc, 0x4c, 0x3a, 0xdb, 0x60, 0x3f, + 0x45, 0x58, 0x54, 0x52, 0x41, 0x20, 0x49, 0x47, 0x4e, 0x4f, 0x52, 0x45, + 0x44, 0x0d, 0x00, 0x3f, 0x52, 0x45, 0x45, 0x4e, 0x54, 0x45, 0x52, 0x0d, + 0x00, 0xd0, 0x04, 0xa0, 0x00, 0xf0, 0x03, 0x20, 0xe3, 0xdf, 0x85, 0x85, + 0x84, 0x86, 0x20, 0x65, 0xd3, 0xf0, 0x04, 0xa2, 0x00, 0xf0, 0x69, 0x9a, + 0xe8, 0xe8, 0xe8, 0xe8, 0x8a, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0x86, + 0x60, 0xa0, 0x01, 0x20, 0xf9, 0xea, 0xba, 0xbd, 0x09, 0x01, 0x85, 0xa2, + 0xa5, 0x85, 0xa4, 0x86, 0x20, 0xbe, 0xe7, 0x20, 0x27, 0xeb, 0xa0, 0x01, + 0x20, 0xb4, 0xeb, 0xba, 0x38, 0xfd, 0x09, 0x01, 0xf0, 0x17, 0xbd, 0x0f, + 0x01, 0x85, 0x75, 0xbd, 0x10, 0x01, 0x85, 0x76, 0xbd, 0x12, 0x01, 0x85, + 0xb8, 0xbd, 0x11, 0x01, 0x85, 0xb9, 0x4c, 0xd2, 0xd7, 0x8a, 0x69, 0x11, + 0xaa, 0x9a, 0x20, 0xb7, 0x00, 0xc9, 0x2c, 0xd0, 0xf1, 0x20, 0xb1, 0x00, + 0x20, 0xff, 0xdc, 0x20, 0x7b, 0xdd, 0x18, 0x24, 0x38, 0x24, 0x11, 0x30, + 0x03, 0xb0, 0x03, 0x60, 0xb0, 0xfd, 0xa2, 0xa3, 0x4c, 0x12, 0xd4, 0xa6, + 0xb8, 0xd0, 0x02, 0xc6, 0xb9, 0xc6, 0xb8, 0xa2, 0x00, 0x24, 0x48, 0x8a, + 0x48, 0xa9, 0x01, 0x20, 0xd6, 0xd3, 0x20, 0x60, 0xde, 0xa9, 0x00, 0x85, + 0x89, 0x20, 0xb7, 0x00, 0x38, 0xe9, 0xcf, 0x90, 0x17, 0xc9, 0x03, 0xb0, + 0x13, 0xc9, 0x01, 0x2a, 0x49, 0x01, 0x45, 0x89, 0xc5, 0x89, 0x90, 0x61, + 0x85, 0x89, 0x20, 0xb1, 0x00, 0x4c, 0x98, 0xdd, 0xa6, 0x89, 0xd0, 0x2c, + 0xb0, 0x7b, 0x69, 0x07, 0x90, 0x77, 0x65, 0x11, 0xd0, 0x03, 0x4c, 0x97, + 0xe5, 0x69, 0xff, 0x85, 0x5e, 0x0a, 0x65, 0x5e, 0xa8, 0x68, 0xd9, 0xb2, + 0xd0, 0xb0, 0x67, 0x20, 0x6a, 0xdd, 0x48, 0x20, 0xfd, 0xdd, 0x68, 0xa4, + 0x87, 0x10, 0x17, 0xaa, 0xf0, 0x56, 0xd0, 0x5f, 0x46, 0x11, 0x8a, 0x2a, + 0xa6, 0xb8, 0xd0, 0x02, 0xc6, 0xb9, 0xc6, 0xb8, 0xa0, 0x1b, 0x85, 0x89, + 0xd0, 0xd7, 0xd9, 0xb2, 0xd0, 0xb0, 0x48, 0x90, 0xd9, 0xb9, 0xb4, 0xd0, + 0x48, 0xb9, 0xb3, 0xd0, 0x48, 0x20, 0x10, 0xde, 0xa5, 0x89, 0x4c, 0x86, + 0xdd, 0x4c, 0xc9, 0xde, 0xa5, 0xa2, 0xbe, 0xb2, 0xd0, 0xa8, 0x68, 0x85, + 0x5e, 0xe6, 0x5e, 0x68, 0x85, 0x5f, 0x98, 0x48, 0x20, 0x72, 0xeb, 0xa5, + 0xa1, 0x48, 0xa5, 0xa0, 0x48, 0xa5, 0x9f, 0x48, 0xa5, 0x9e, 0x48, 0xa5, + 0x9d, 0x48, 0x6c, 0x5e, 0x00, 0xa0, 0xff, 0x68, 0xf0, 0x23, 0xc9, 0x64, + 0xf0, 0x03, 0x20, 0x6a, 0xdd, 0x84, 0x87, 0x68, 0x4a, 0x85, 0x16, 0x68, + 0x85, 0xa5, 0x68, 0x85, 0xa6, 0x68, 0x85, 0xa7, 0x68, 0x85, 0xa8, 0x68, + 0x85, 0xa9, 0x68, 0x85, 0xaa, 0x45, 0xa2, 0x85, 0xab, 0xa5, 0x9d, 0x60, + 0xa9, 0x00, 0x85, 0x11, 0x20, 0xb1, 0x00, 0xb0, 0x03, 0x4c, 0x4a, 0xec, + 0x20, 0x7d, 0xe0, 0xb0, 0x64, 0xc9, 0x2e, 0xf0, 0xf4, 0xc9, 0xc9, 0xf0, + 0x55, 0xc9, 0xc8, 0xf0, 0xe7, 0xc9, 0x22, 0xd0, 0x0f, 0xa5, 0xb8, 0xa4, + 0xb9, 0x69, 0x00, 0x90, 0x01, 0xc8, 0x20, 0xe7, 0xe3, 0x4c, 0x3d, 0xe7, + 0xc9, 0xc6, 0xd0, 0x10, 0xa0, 0x18, 0xd0, 0x38, 0xa5, 0x9d, 0xd0, 0x03, + 0xa0, 0x01, 0x2c, 0xa0, 0x00, 0x4c, 0x01, 0xe3, 0xc9, 0xc2, 0xd0, 0x03, + 0x4c, 0x54, 0xe3, 0xc9, 0xd2, 0x90, 0x03, 0x4c, 0x0c, 0xdf, 0x20, 0xbb, + 0xde, 0x20, 0x7b, 0xdd, 0xa9, 0x29, 0x2c, 0xa9, 0x28, 0x2c, 0xa9, 0x2c, + 0xa0, 0x00, 0xd1, 0xb8, 0xd0, 0x03, 0x4c, 0xb1, 0x00, 0xa2, 0x10, 0x4c, + 0x12, 0xd4, 0xa0, 0x15, 0x68, 0x68, 0x4c, 0xd7, 0xdd, 0x20, 0xe3, 0xdf, + 0x85, 0xa0, 0x84, 0xa1, 0xa6, 0x11, 0xf0, 0x05, 0xa2, 0x00, 0x86, 0xac, + 0x60, 0xa6, 0x12, 0x10, 0x0d, 0xa0, 0x00, 0xb1, 0xa0, 0xaa, 0xc8, 0xb1, + 0xa0, 0xa8, 0x8a, 0x4c, 0xf2, 0xe2, 0x4c, 0xf9, 0xea, 0x20, 0xb1, 0x00, + 0x20, 0xec, 0xf1, 0x8a, 0xa4, 0xf0, 0x20, 0x71, 0xf8, 0xa8, 0x20, 0x01, + 0xe3, 0x4c, 0xb8, 0xde, 0xc9, 0xd7, 0xf0, 0xe9, 0x0a, 0x48, 0xaa, 0x20, + 0xb1, 0x00, 0xe0, 0xcf, 0x90, 0x20, 0x20, 0xbb, 0xde, 0x20, 0x7b, 0xdd, + 0x20, 0xbe, 0xde, 0x20, 0x6c, 0xdd, 0x68, 0xaa, 0xa5, 0xa1, 0x48, 0xa5, + 0xa0, 0x48, 0x8a, 0x48, 0x20, 0xf8, 0xe6, 0x68, 0xa8, 0x8a, 0x48, 0x4c, + 0x3f, 0xdf, 0x20, 0xb2, 0xde, 0x68, 0xa8, 0xb9, 0xdc, 0xcf, 0x85, 0x91, + 0xb9, 0xdd, 0xcf, 0x85, 0x92, 0x20, 0x90, 0x00, 0x4c, 0x6a, 0xdd, 0xa5, + 0xa5, 0x05, 0x9d, 0xd0, 0x0b, 0xa5, 0xa5, 0xf0, 0x04, 0xa5, 0x9d, 0xd0, + 0x03, 0xa0, 0x00, 0x2c, 0xa0, 0x01, 0x4c, 0x01, 0xe3, 0x20, 0x6d, 0xdd, + 0xb0, 0x13, 0xa5, 0xaa, 0x09, 0x7f, 0x25, 0xa6, 0x85, 0xa6, 0xa9, 0xa5, + 0xa0, 0x00, 0x20, 0xb2, 0xeb, 0xaa, 0x4c, 0xb0, 0xdf, 0xa9, 0x00, 0x85, + 0x11, 0xc6, 0x89, 0x20, 0x00, 0xe6, 0x85, 0x9d, 0x86, 0x9e, 0x84, 0x9f, + 0xa5, 0xa8, 0xa4, 0xa9, 0x20, 0x04, 0xe6, 0x86, 0xa8, 0x84, 0xa9, 0xaa, + 0x38, 0xe5, 0x9d, 0xf0, 0x08, 0xa9, 0x01, 0x90, 0x04, 0xa6, 0x9d, 0xa9, + 0xff, 0x85, 0xa2, 0xa0, 0xff, 0xe8, 0xc8, 0xca, 0xd0, 0x07, 0xa6, 0xa2, + 0x30, 0x0f, 0x18, 0x90, 0x0c, 0xb1, 0xa8, 0xd1, 0x9e, 0xf0, 0xef, 0xa2, + 0xff, 0xb0, 0x02, 0xa2, 0x01, 0xe8, 0x8a, 0x2a, 0x25, 0x16, 0xf0, 0x02, + 0xa9, 0x01, 0x4c, 0x93, 0xeb, 0x20, 0xfb, 0xe6, 0x20, 0x1e, 0xfb, 0x4c, + 0x01, 0xe3, 0x20, 0xbe, 0xde, 0xaa, 0x20, 0xe8, 0xdf, 0x20, 0xb7, 0x00, + 0xd0, 0xf4, 0x60, 0xa2, 0x00, 0x20, 0xb7, 0x00, 0x86, 0x10, 0x85, 0x81, + 0x20, 0xb7, 0x00, 0x20, 0x7d, 0xe0, 0xb0, 0x03, 0x4c, 0xc9, 0xde, 0xa2, + 0x00, 0x86, 0x11, 0x86, 0x12, 0x4c, 0x07, 0xe0, 0x4c, 0x28, 0xf1, 0x4c, + 0x3c, 0xd4, 0xc4, 0x20, 0xb1, 0x00, 0x90, 0x05, 0x20, 0x7d, 0xe0, 0x90, + 0x0b, 0xaa, 0x20, 0xb1, 0x00, 0x90, 0xfb, 0x20, 0x7d, 0xe0, 0xb0, 0xf6, + 0xc9, 0x24, 0xd0, 0x06, 0xa9, 0xff, 0x85, 0x11, 0xd0, 0x10, 0xc9, 0x25, + 0xd0, 0x13, 0xa5, 0x14, 0x30, 0xc6, 0xa9, 0x80, 0x85, 0x12, 0x05, 0x81, + 0x85, 0x81, 0x8a, 0x09, 0x80, 0xaa, 0x20, 0xb1, 0x00, 0x86, 0x82, 0x38, + 0x05, 0x14, 0xe9, 0x28, 0xd0, 0x03, 0x4c, 0x1e, 0xe1, 0x24, 0x14, 0x30, + 0x02, 0x70, 0xf7, 0xa9, 0x00, 0x85, 0x14, 0xa5, 0x69, 0xa6, 0x6a, 0xa0, + 0x00, 0x86, 0x9c, 0x85, 0x9b, 0xe4, 0x6c, 0xd0, 0x04, 0xc5, 0x6b, 0xf0, + 0x22, 0xa5, 0x81, 0xd1, 0x9b, 0xd0, 0x08, 0xa5, 0x82, 0xc8, 0xd1, 0x9b, + 0xf0, 0x6c, 0x88, 0x18, 0xa5, 0x9b, 0x69, 0x07, 0x90, 0xe1, 0xe8, 0xd0, + 0xdc, 0xc9, 0x41, 0x90, 0x05, 0xe9, 0x5b, 0x38, 0xe9, 0xa5, 0x60, 0x68, + 0x48, 0xc9, 0xd7, 0xd0, 0x0f, 0xba, 0xbd, 0x02, 0x01, 0xc9, 0xde, 0xd0, + 0x07, 0xa9, 0x9a, 0xa0, 0xe0, 0x60, 0x00, 0x00, 0xa5, 0x6b, 0xa4, 0x6c, + 0x85, 0x9b, 0x84, 0x9c, 0xa5, 0x6d, 0xa4, 0x6e, 0x85, 0x96, 0x84, 0x97, + 0x18, 0x69, 0x07, 0x90, 0x01, 0xc8, 0x85, 0x94, 0x84, 0x95, 0x20, 0x93, + 0xd3, 0xa5, 0x94, 0xa4, 0x95, 0xc8, 0x85, 0x6b, 0x84, 0x6c, 0xa0, 0x00, + 0xa5, 0x81, 0x91, 0x9b, 0xc8, 0xa5, 0x82, 0x91, 0x9b, 0xa9, 0x00, 0xc8, + 0x91, 0x9b, 0xc8, 0x91, 0x9b, 0xc8, 0x91, 0x9b, 0xc8, 0x91, 0x9b, 0xc8, + 0x91, 0x9b, 0xa5, 0x9b, 0x18, 0x69, 0x02, 0xa4, 0x9c, 0x90, 0x01, 0xc8, + 0x85, 0x83, 0x84, 0x84, 0x60, 0xa5, 0x0f, 0x0a, 0x69, 0x05, 0x65, 0x9b, + 0xa4, 0x9c, 0x90, 0x01, 0xc8, 0x85, 0x94, 0x84, 0x95, 0x60, 0x90, 0x80, + 0x00, 0x00, 0x20, 0xb1, 0x00, 0x20, 0x67, 0xdd, 0xa5, 0xa2, 0x30, 0x0d, + 0xa5, 0x9d, 0xc9, 0x90, 0x90, 0x09, 0xa9, 0xfe, 0xa0, 0xe0, 0x20, 0xb2, + 0xeb, 0xd0, 0x7e, 0x4c, 0xf2, 0xeb, 0xa5, 0x14, 0xd0, 0x47, 0xa5, 0x10, + 0x05, 0x12, 0x48, 0xa5, 0x11, 0x48, 0xa0, 0x00, 0x98, 0x48, 0xa5, 0x82, + 0x48, 0xa5, 0x81, 0x48, 0x20, 0x02, 0xe1, 0x68, 0x85, 0x81, 0x68, 0x85, + 0x82, 0x68, 0xa8, 0xba, 0xbd, 0x02, 0x01, 0x48, 0xbd, 0x01, 0x01, 0x48, + 0xa5, 0xa0, 0x9d, 0x02, 0x01, 0xa5, 0xa1, 0x9d, 0x01, 0x01, 0xc8, 0x20, + 0xb7, 0x00, 0xc9, 0x2c, 0xf0, 0xd2, 0x84, 0x0f, 0x20, 0xb8, 0xde, 0x68, + 0x85, 0x11, 0x68, 0x85, 0x12, 0x29, 0x7f, 0x85, 0x10, 0xa6, 0x6b, 0xa5, + 0x6c, 0x86, 0x9b, 0x85, 0x9c, 0xc5, 0x6e, 0xd0, 0x04, 0xe4, 0x6d, 0xf0, + 0x3f, 0xa0, 0x00, 0xb1, 0x9b, 0xc8, 0xc5, 0x81, 0xd0, 0x06, 0xa5, 0x82, + 0xd1, 0x9b, 0xf0, 0x16, 0xc8, 0xb1, 0x9b, 0x18, 0x65, 0x9b, 0xaa, 0xc8, + 0xb1, 0x9b, 0x65, 0x9c, 0x90, 0xd7, 0xa2, 0x6b, 0x2c, 0xa2, 0x35, 0x4c, + 0x12, 0xd4, 0xa2, 0x78, 0xa5, 0x10, 0xd0, 0xf7, 0xa5, 0x14, 0xf0, 0x02, + 0x38, 0x60, 0x20, 0xed, 0xe0, 0xa5, 0x0f, 0xa0, 0x04, 0xd1, 0x9b, 0xd0, + 0xe1, 0x4c, 0x4b, 0xe2, 0xa5, 0x14, 0xf0, 0x05, 0xa2, 0x2a, 0x4c, 0x12, + 0xd4, 0x20, 0xed, 0xe0, 0x20, 0xe3, 0xd3, 0xa9, 0x00, 0xa8, 0x85, 0xae, + 0xa2, 0x05, 0xa5, 0x81, 0x91, 0x9b, 0x10, 0x01, 0xca, 0xc8, 0xa5, 0x82, + 0x91, 0x9b, 0x10, 0x02, 0xca, 0xca, 0x86, 0xad, 0xa5, 0x0f, 0xc8, 0xc8, + 0xc8, 0x91, 0x9b, 0xa2, 0x0b, 0xa9, 0x00, 0x24, 0x10, 0x50, 0x08, 0x68, + 0x18, 0x69, 0x01, 0xaa, 0x68, 0x69, 0x00, 0xc8, 0x91, 0x9b, 0xc8, 0x8a, + 0x91, 0x9b, 0x20, 0xad, 0xe2, 0x86, 0xad, 0x85, 0xae, 0xa4, 0x5e, 0xc6, + 0x0f, 0xd0, 0xdc, 0x65, 0x95, 0xb0, 0x5d, 0x85, 0x95, 0xa8, 0x8a, 0x65, + 0x94, 0x90, 0x03, 0xc8, 0xf0, 0x52, 0x20, 0xe3, 0xd3, 0x85, 0x6d, 0x84, + 0x6e, 0xa9, 0x00, 0xe6, 0xae, 0xa4, 0xad, 0xf0, 0x05, 0x88, 0x91, 0x94, + 0xd0, 0xfb, 0xc6, 0x95, 0xc6, 0xae, 0xd0, 0xf5, 0xe6, 0x95, 0x38, 0xa5, + 0x6d, 0xe5, 0x9b, 0xa0, 0x02, 0x91, 0x9b, 0xa5, 0x6e, 0xc8, 0xe5, 0x9c, + 0x91, 0x9b, 0xa5, 0x10, 0xd0, 0x62, 0xc8, 0xb1, 0x9b, 0x85, 0x0f, 0xa9, + 0x00, 0x85, 0xad, 0x85, 0xae, 0xc8, 0x68, 0xaa, 0x85, 0xa0, 0x68, 0x85, + 0xa1, 0xd1, 0x9b, 0x90, 0x0e, 0xd0, 0x06, 0xc8, 0x8a, 0xd1, 0x9b, 0x90, + 0x07, 0x4c, 0x96, 0xe1, 0x4c, 0x10, 0xd4, 0xc8, 0xa5, 0xae, 0x05, 0xad, + 0x18, 0xf0, 0x0a, 0x20, 0xad, 0xe2, 0x8a, 0x65, 0xa0, 0xaa, 0x98, 0xa4, + 0x5e, 0x65, 0xa1, 0x86, 0xad, 0xc6, 0x0f, 0xd0, 0xca, 0x85, 0xae, 0xa2, + 0x05, 0xa5, 0x81, 0x10, 0x01, 0xca, 0xa5, 0x82, 0x10, 0x02, 0xca, 0xca, + 0x86, 0x64, 0xa9, 0x00, 0x20, 0xb6, 0xe2, 0x8a, 0x65, 0x94, 0x85, 0x83, + 0x98, 0x65, 0x95, 0x85, 0x84, 0xa8, 0xa5, 0x83, 0x60, 0x84, 0x5e, 0xb1, + 0x9b, 0x85, 0x64, 0x88, 0xb1, 0x9b, 0x85, 0x65, 0xa9, 0x10, 0x85, 0x99, + 0xa2, 0x00, 0xa0, 0x00, 0x8a, 0x0a, 0xaa, 0x98, 0x2a, 0xa8, 0xb0, 0xa4, + 0x06, 0xad, 0x26, 0xae, 0x90, 0x0b, 0x18, 0x8a, 0x65, 0x64, 0xaa, 0x98, + 0x65, 0x65, 0xa8, 0xb0, 0x93, 0xc6, 0x99, 0xd0, 0xe3, 0x60, 0xa5, 0x11, + 0xf0, 0x03, 0x20, 0x00, 0xe6, 0x20, 0x84, 0xe4, 0x38, 0xa5, 0x6f, 0xe5, + 0x6d, 0xa8, 0xa5, 0x70, 0xe5, 0x6e, 0xa2, 0x00, 0x86, 0x11, 0x85, 0x9e, + 0x84, 0x9f, 0xa2, 0x90, 0x4c, 0x9b, 0xeb, 0xa4, 0x24, 0xa9, 0x00, 0x38, + 0xf0, 0xec, 0xa6, 0x76, 0xe8, 0xd0, 0xa1, 0xa2, 0x95, 0x2c, 0xa2, 0xe0, + 0x4c, 0x12, 0xd4, 0x20, 0x41, 0xe3, 0x20, 0x06, 0xe3, 0x20, 0xbb, 0xde, + 0xa9, 0x80, 0x85, 0x14, 0x20, 0xe3, 0xdf, 0x20, 0x6a, 0xdd, 0x20, 0xb8, + 0xde, 0xa9, 0xd0, 0x20, 0xc0, 0xde, 0x48, 0xa5, 0x84, 0x48, 0xa5, 0x83, + 0x48, 0xa5, 0xb9, 0x48, 0xa5, 0xb8, 0x48, 0x20, 0x95, 0xd9, 0x4c, 0xaf, + 0xe3, 0xa9, 0xc2, 0x20, 0xc0, 0xde, 0x09, 0x80, 0x85, 0x14, 0x20, 0xea, + 0xdf, 0x85, 0x8a, 0x84, 0x8b, 0x4c, 0x6a, 0xdd, 0x20, 0x41, 0xe3, 0xa5, + 0x8b, 0x48, 0xa5, 0x8a, 0x48, 0x20, 0xb2, 0xde, 0x20, 0x6a, 0xdd, 0x68, + 0x85, 0x8a, 0x68, 0x85, 0x8b, 0xa0, 0x02, 0xb1, 0x8a, 0x85, 0x83, 0xaa, + 0xc8, 0xb1, 0x8a, 0xf0, 0x99, 0x85, 0x84, 0xc8, 0xb1, 0x83, 0x48, 0x88, + 0x10, 0xfa, 0xa4, 0x84, 0x20, 0x2b, 0xeb, 0xa5, 0xb9, 0x48, 0xa5, 0xb8, + 0x48, 0xb1, 0x8a, 0x85, 0xb8, 0xc8, 0xb1, 0x8a, 0x85, 0xb9, 0xa5, 0x84, + 0x48, 0xa5, 0x83, 0x48, 0x20, 0x67, 0xdd, 0x68, 0x85, 0x8a, 0x68, 0x85, + 0x8b, 0x20, 0xb7, 0x00, 0xf0, 0x03, 0x4c, 0xc9, 0xde, 0x68, 0x85, 0xb8, + 0x68, 0x85, 0xb9, 0xa0, 0x00, 0x68, 0x91, 0x8a, 0x68, 0xc8, 0x91, 0x8a, + 0x68, 0xc8, 0x91, 0x8a, 0x68, 0xc8, 0x91, 0x8a, 0x68, 0xc8, 0x91, 0x8a, + 0x60, 0x20, 0x6a, 0xdd, 0xa0, 0x00, 0x20, 0x36, 0xed, 0x68, 0x68, 0xa9, + 0xff, 0xa0, 0x00, 0xf0, 0x12, 0xa6, 0xa0, 0xa4, 0xa1, 0x86, 0x8c, 0x84, + 0x8d, 0x20, 0x52, 0xe4, 0x86, 0x9e, 0x84, 0x9f, 0x85, 0x9d, 0x60, 0xa2, + 0x22, 0x86, 0x0d, 0x86, 0x0e, 0x85, 0xab, 0x84, 0xac, 0x85, 0x9e, 0x84, + 0x9f, 0xa0, 0xff, 0xc8, 0xb1, 0xab, 0xf0, 0x0c, 0xc5, 0x0d, 0xf0, 0x04, + 0xc5, 0x0e, 0xd0, 0xf3, 0xc9, 0x22, 0xf0, 0x01, 0x18, 0x84, 0x9d, 0x98, + 0x65, 0xab, 0x85, 0xad, 0xa6, 0xac, 0x90, 0x01, 0xe8, 0x86, 0xae, 0xa5, + 0xac, 0xf0, 0x04, 0xc9, 0x02, 0xd0, 0x0b, 0x98, 0x20, 0xd5, 0xe3, 0xa6, + 0xab, 0xa4, 0xac, 0x20, 0xe2, 0xe5, 0xa6, 0x52, 0xe0, 0x5e, 0xd0, 0x05, + 0xa2, 0xbf, 0x4c, 0x12, 0xd4, 0xa5, 0x9d, 0x95, 0x00, 0xa5, 0x9e, 0x95, + 0x01, 0xa5, 0x9f, 0x95, 0x02, 0xa0, 0x00, 0x86, 0xa0, 0x84, 0xa1, 0x88, + 0x84, 0x11, 0x86, 0x53, 0xe8, 0xe8, 0xe8, 0x86, 0x52, 0x60, 0x46, 0x13, + 0x48, 0x49, 0xff, 0x38, 0x65, 0x6f, 0xa4, 0x70, 0xb0, 0x01, 0x88, 0xc4, + 0x6e, 0x90, 0x11, 0xd0, 0x04, 0xc5, 0x6d, 0x90, 0x0b, 0x85, 0x6f, 0x84, + 0x70, 0x85, 0x71, 0x84, 0x72, 0xaa, 0x68, 0x60, 0xa2, 0x4d, 0xa5, 0x13, + 0x30, 0xb8, 0x20, 0x84, 0xe4, 0xa9, 0x80, 0x85, 0x13, 0x68, 0xd0, 0xd0, + 0xa6, 0x73, 0xa5, 0x74, 0x86, 0x6f, 0x85, 0x70, 0xa0, 0x00, 0x84, 0x8b, + 0xa5, 0x6d, 0xa6, 0x6e, 0x85, 0x9b, 0x86, 0x9c, 0xa9, 0x55, 0xa2, 0x00, + 0x85, 0x5e, 0x86, 0x5f, 0xc5, 0x52, 0xf0, 0x05, 0x20, 0x23, 0xe5, 0xf0, + 0xf7, 0xa9, 0x07, 0x85, 0x8f, 0xa5, 0x69, 0xa6, 0x6a, 0x85, 0x5e, 0x86, + 0x5f, 0xe4, 0x6c, 0xd0, 0x04, 0xc5, 0x6b, 0xf0, 0x05, 0x20, 0x19, 0xe5, + 0xf0, 0xf3, 0x85, 0x94, 0x86, 0x95, 0xa9, 0x03, 0x85, 0x8f, 0xa5, 0x94, + 0xa6, 0x95, 0xe4, 0x6e, 0xd0, 0x07, 0xc5, 0x6d, 0xd0, 0x03, 0x4c, 0x62, + 0xe5, 0x85, 0x5e, 0x86, 0x5f, 0xa0, 0x00, 0xb1, 0x5e, 0xaa, 0xc8, 0xb1, + 0x5e, 0x08, 0xc8, 0xb1, 0x5e, 0x65, 0x94, 0x85, 0x94, 0xc8, 0xb1, 0x5e, + 0x65, 0x95, 0x85, 0x95, 0x28, 0x10, 0xd3, 0x8a, 0x30, 0xd0, 0xc8, 0xb1, + 0x5e, 0xa0, 0x00, 0x0a, 0x69, 0x05, 0x65, 0x5e, 0x85, 0x5e, 0x90, 0x02, + 0xe6, 0x5f, 0xa6, 0x5f, 0xe4, 0x95, 0xd0, 0x04, 0xc5, 0x94, 0xf0, 0xba, + 0x20, 0x23, 0xe5, 0xf0, 0xf3, 0xb1, 0x5e, 0x30, 0x35, 0xc8, 0xb1, 0x5e, + 0x10, 0x30, 0xc8, 0xb1, 0x5e, 0xf0, 0x2b, 0xc8, 0xb1, 0x5e, 0xaa, 0xc8, + 0xb1, 0x5e, 0xc5, 0x70, 0x90, 0x06, 0xd0, 0x1e, 0xe4, 0x6f, 0xb0, 0x1a, + 0xc5, 0x9c, 0x90, 0x16, 0xd0, 0x04, 0xe4, 0x9b, 0x90, 0x10, 0x86, 0x9b, + 0x85, 0x9c, 0xa5, 0x5e, 0xa6, 0x5f, 0x85, 0x8a, 0x86, 0x8b, 0xa5, 0x8f, + 0x85, 0x91, 0xa5, 0x8f, 0x18, 0x65, 0x5e, 0x85, 0x5e, 0x90, 0x02, 0xe6, + 0x5f, 0xa6, 0x5f, 0xa0, 0x00, 0x60, 0xa6, 0x8b, 0xf0, 0xf7, 0xa5, 0x91, + 0x29, 0x04, 0x4a, 0xa8, 0x85, 0x91, 0xb1, 0x8a, 0x65, 0x9b, 0x85, 0x96, + 0xa5, 0x9c, 0x69, 0x00, 0x85, 0x97, 0xa5, 0x6f, 0xa6, 0x70, 0x85, 0x94, + 0x86, 0x95, 0x20, 0x9a, 0xd3, 0xa4, 0x91, 0xc8, 0xa5, 0x94, 0x91, 0x8a, + 0xaa, 0xe6, 0x95, 0xa5, 0x95, 0xc8, 0x91, 0x8a, 0x4c, 0x88, 0xe4, 0xa5, + 0xa1, 0x48, 0xa5, 0xa0, 0x48, 0x20, 0x60, 0xde, 0x20, 0x6c, 0xdd, 0x68, + 0x85, 0xab, 0x68, 0x85, 0xac, 0xa0, 0x00, 0xb1, 0xab, 0x18, 0x71, 0xa0, + 0x90, 0x05, 0xa2, 0xb0, 0x4c, 0x12, 0xd4, 0x20, 0xd5, 0xe3, 0x20, 0xd4, + 0xe5, 0xa5, 0x8c, 0xa4, 0x8d, 0x20, 0x04, 0xe6, 0x20, 0xe6, 0xe5, 0xa5, + 0xab, 0xa4, 0xac, 0x20, 0x04, 0xe6, 0x20, 0x2a, 0xe4, 0x4c, 0x95, 0xdd, + 0xa0, 0x00, 0xb1, 0xab, 0x48, 0xc8, 0xb1, 0xab, 0xaa, 0xc8, 0xb1, 0xab, + 0xa8, 0x68, 0x86, 0x5e, 0x84, 0x5f, 0xa8, 0xf0, 0x0a, 0x48, 0x88, 0xb1, + 0x5e, 0x91, 0x71, 0x98, 0xd0, 0xf8, 0x68, 0x18, 0x65, 0x71, 0x85, 0x71, + 0x90, 0x02, 0xe6, 0x72, 0x60, 0x20, 0x6c, 0xdd, 0xa5, 0xa0, 0xa4, 0xa1, + 0x85, 0x5e, 0x84, 0x5f, 0x20, 0x35, 0xe6, 0x08, 0xa0, 0x00, 0xb1, 0x5e, + 0x48, 0xc8, 0xb1, 0x5e, 0xaa, 0xc8, 0xb1, 0x5e, 0xa8, 0x68, 0x28, 0xd0, + 0x13, 0xc4, 0x70, 0xd0, 0x0f, 0xe4, 0x6f, 0xd0, 0x0b, 0x48, 0x18, 0x65, + 0x6f, 0x85, 0x6f, 0x90, 0x02, 0xe6, 0x70, 0x68, 0x86, 0x5e, 0x84, 0x5f, + 0x60, 0xc4, 0x54, 0xd0, 0x0c, 0xc5, 0x53, 0xd0, 0x08, 0x85, 0x52, 0xe9, + 0x03, 0x85, 0x53, 0xa0, 0x00, 0x60, 0x20, 0xfb, 0xe6, 0x8a, 0x48, 0xa9, + 0x01, 0x20, 0xdd, 0xe3, 0x68, 0xa0, 0x00, 0x91, 0x9e, 0x68, 0x68, 0x4c, + 0x2a, 0xe4, 0x20, 0xb9, 0xe6, 0xd1, 0x8c, 0x98, 0x90, 0x04, 0xb1, 0x8c, + 0xaa, 0x98, 0x48, 0x8a, 0x48, 0x20, 0xdd, 0xe3, 0xa5, 0x8c, 0xa4, 0x8d, + 0x20, 0x04, 0xe6, 0x68, 0xa8, 0x68, 0x18, 0x65, 0x5e, 0x85, 0x5e, 0x90, + 0x02, 0xe6, 0x5f, 0x98, 0x20, 0xe6, 0xe5, 0x4c, 0x2a, 0xe4, 0x20, 0xb9, + 0xe6, 0x18, 0xf1, 0x8c, 0x49, 0xff, 0x4c, 0x60, 0xe6, 0xa9, 0xff, 0x85, + 0xa1, 0x20, 0xb7, 0x00, 0xc9, 0x29, 0xf0, 0x06, 0x20, 0xbe, 0xde, 0x20, + 0xf8, 0xe6, 0x20, 0xb9, 0xe6, 0xca, 0x8a, 0x48, 0x18, 0xa2, 0x00, 0xf1, + 0x8c, 0xb0, 0xb8, 0x49, 0xff, 0xc5, 0xa1, 0x90, 0xb3, 0xa5, 0xa1, 0xb0, + 0xaf, 0x20, 0xb8, 0xde, 0x68, 0xa8, 0x68, 0x85, 0x91, 0x68, 0x68, 0x68, + 0xaa, 0x68, 0x85, 0x8c, 0x68, 0x85, 0x8d, 0xa5, 0x91, 0x48, 0x98, 0x48, + 0xa0, 0x00, 0x8a, 0xf0, 0x1d, 0x60, 0x20, 0xdc, 0xe6, 0x4c, 0x01, 0xe3, + 0x20, 0xfd, 0xe5, 0xa2, 0x00, 0x86, 0x11, 0xa8, 0x60, 0x20, 0xdc, 0xe6, + 0xf0, 0x08, 0xa0, 0x00, 0xb1, 0x5e, 0xa8, 0x4c, 0x01, 0xe3, 0x4c, 0x99, + 0xe1, 0x20, 0xb1, 0x00, 0x20, 0x67, 0xdd, 0x20, 0x08, 0xe1, 0xa6, 0xa0, + 0xd0, 0xf0, 0xa6, 0xa1, 0x4c, 0xb7, 0x00, 0x20, 0xdc, 0xe6, 0xd0, 0x03, + 0x4c, 0x4e, 0xe8, 0xa6, 0xb8, 0xa4, 0xb9, 0x86, 0xad, 0x84, 0xae, 0xa6, + 0x5e, 0x86, 0xb8, 0x18, 0x65, 0x5e, 0x85, 0x60, 0xa6, 0x5f, 0x86, 0xb9, + 0x90, 0x01, 0xe8, 0x86, 0x61, 0xa0, 0x00, 0xb1, 0x60, 0x48, 0xa9, 0x00, + 0x91, 0x60, 0x20, 0xb7, 0x00, 0x20, 0x4a, 0xec, 0x68, 0xa0, 0x00, 0x91, + 0x60, 0xa6, 0xad, 0xa4, 0xae, 0x86, 0xb8, 0x84, 0xb9, 0x60, 0x20, 0x67, + 0xdd, 0x20, 0x52, 0xe7, 0x20, 0xbe, 0xde, 0x4c, 0xf8, 0xe6, 0xa5, 0x9d, + 0xc9, 0x91, 0xb0, 0x9a, 0x20, 0xf2, 0xeb, 0xa5, 0xa0, 0xa4, 0xa1, 0x84, + 0x50, 0x85, 0x51, 0x60, 0xa5, 0x50, 0x48, 0xa5, 0x51, 0x48, 0x20, 0x52, + 0xe7, 0xa0, 0x00, 0xb1, 0x50, 0xa8, 0x68, 0x85, 0x51, 0x68, 0x85, 0x50, + 0x4c, 0x01, 0xe3, 0x20, 0x46, 0xe7, 0x8a, 0xa0, 0x00, 0x91, 0x50, 0x60, + 0x20, 0x46, 0xe7, 0x86, 0x85, 0xa2, 0x00, 0x20, 0xb7, 0x00, 0xf0, 0x03, + 0x20, 0x4c, 0xe7, 0x86, 0x86, 0xa0, 0x00, 0xb1, 0x50, 0x45, 0x86, 0x25, + 0x85, 0xf0, 0xf8, 0x60, 0xa9, 0x64, 0xa0, 0xee, 0x4c, 0xbe, 0xe7, 0x20, + 0xe3, 0xe9, 0xa5, 0xa2, 0x49, 0xff, 0x85, 0xa2, 0x45, 0xaa, 0x85, 0xab, + 0xa5, 0x9d, 0x4c, 0xc1, 0xe7, 0x20, 0xf0, 0xe8, 0x90, 0x3c, 0x20, 0xe3, + 0xe9, 0xd0, 0x03, 0x4c, 0x53, 0xeb, 0xa6, 0xac, 0x86, 0x92, 0xa2, 0xa5, + 0xa5, 0xa5, 0xa8, 0xf0, 0xce, 0x38, 0xe5, 0x9d, 0xf0, 0x24, 0x90, 0x12, + 0x84, 0x9d, 0xa4, 0xaa, 0x84, 0xa2, 0x49, 0xff, 0x69, 0x00, 0xa0, 0x00, + 0x84, 0x92, 0xa2, 0x9d, 0xd0, 0x04, 0xa0, 0x00, 0x84, 0xac, 0xc9, 0xf9, + 0x30, 0xc7, 0xa8, 0xa5, 0xac, 0x56, 0x01, 0x20, 0x07, 0xe9, 0x24, 0xab, + 0x10, 0x57, 0xa0, 0x9d, 0xe0, 0xa5, 0xf0, 0x02, 0xa0, 0xa5, 0x38, 0x49, + 0xff, 0x65, 0x92, 0x85, 0xac, 0xb9, 0x04, 0x00, 0xf5, 0x04, 0x85, 0xa1, + 0xb9, 0x03, 0x00, 0xf5, 0x03, 0x85, 0xa0, 0xb9, 0x02, 0x00, 0xf5, 0x02, + 0x85, 0x9f, 0xb9, 0x01, 0x00, 0xf5, 0x01, 0x85, 0x9e, 0xb0, 0x03, 0x20, + 0x9e, 0xe8, 0xa0, 0x00, 0x98, 0x18, 0xa6, 0x9e, 0xd0, 0x4a, 0xa6, 0x9f, + 0x86, 0x9e, 0xa6, 0xa0, 0x86, 0x9f, 0xa6, 0xa1, 0x86, 0xa0, 0xa6, 0xac, + 0x86, 0xa1, 0x84, 0xac, 0x69, 0x08, 0xc9, 0x20, 0xd0, 0xe4, 0xa9, 0x00, + 0x85, 0x9d, 0x85, 0xa2, 0x60, 0x65, 0x92, 0x85, 0xac, 0xa5, 0xa1, 0x65, + 0xa9, 0x85, 0xa1, 0xa5, 0xa0, 0x65, 0xa8, 0x85, 0xa0, 0xa5, 0x9f, 0x65, + 0xa7, 0x85, 0x9f, 0xa5, 0x9e, 0x65, 0xa6, 0x85, 0x9e, 0x4c, 0x8d, 0xe8, + 0x69, 0x01, 0x06, 0xac, 0x26, 0xa1, 0x26, 0xa0, 0x26, 0x9f, 0x26, 0x9e, + 0x10, 0xf2, 0x38, 0xe5, 0x9d, 0xb0, 0xc7, 0x49, 0xff, 0x69, 0x01, 0x85, + 0x9d, 0x90, 0x0e, 0xe6, 0x9d, 0xf0, 0x42, 0x66, 0x9e, 0x66, 0x9f, 0x66, + 0xa0, 0x66, 0xa1, 0x66, 0xac, 0x60, 0xa5, 0xa2, 0x49, 0xff, 0x85, 0xa2, + 0xa5, 0x9e, 0x49, 0xff, 0x85, 0x9e, 0xa5, 0x9f, 0x49, 0xff, 0x85, 0x9f, + 0xa5, 0xa0, 0x49, 0xff, 0x85, 0xa0, 0xa5, 0xa1, 0x49, 0xff, 0x85, 0xa1, + 0xa5, 0xac, 0x49, 0xff, 0x85, 0xac, 0xe6, 0xac, 0xd0, 0x0e, 0xe6, 0xa1, + 0xd0, 0x0a, 0xe6, 0xa0, 0xd0, 0x06, 0xe6, 0x9f, 0xd0, 0x02, 0xe6, 0x9e, + 0x60, 0xa2, 0x45, 0x4c, 0x12, 0xd4, 0xa2, 0x61, 0xb4, 0x04, 0x84, 0xac, + 0xb4, 0x03, 0x94, 0x04, 0xb4, 0x02, 0x94, 0x03, 0xb4, 0x01, 0x94, 0x02, + 0xa4, 0xa4, 0x94, 0x01, 0x69, 0x08, 0x30, 0xe8, 0xf0, 0xe6, 0xe9, 0x08, + 0xa8, 0xa5, 0xac, 0xb0, 0x14, 0x16, 0x01, 0x90, 0x02, 0xf6, 0x01, 0x76, + 0x01, 0x76, 0x01, 0x76, 0x02, 0x76, 0x03, 0x76, 0x04, 0x6a, 0xc8, 0xd0, + 0xec, 0x18, 0x60, 0x81, 0x00, 0x00, 0x00, 0x00, 0x03, 0x7f, 0x5e, 0x56, + 0xcb, 0x79, 0x80, 0x13, 0x9b, 0x0b, 0x64, 0x80, 0x76, 0x38, 0x93, 0x16, + 0x82, 0x38, 0xaa, 0x3b, 0x20, 0x80, 0x35, 0x04, 0xf3, 0x34, 0x81, 0x35, + 0x04, 0xf3, 0x34, 0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0x31, 0x72, 0x17, + 0xf8, 0x20, 0x82, 0xeb, 0xf0, 0x02, 0x10, 0x03, 0x4c, 0x99, 0xe1, 0xa5, + 0x9d, 0xe9, 0x7f, 0x48, 0xa9, 0x80, 0x85, 0x9d, 0xa9, 0x2d, 0xa0, 0xe9, + 0x20, 0xbe, 0xe7, 0xa9, 0x32, 0xa0, 0xe9, 0x20, 0x66, 0xea, 0xa9, 0x13, + 0xa0, 0xe9, 0x20, 0xa7, 0xe7, 0xa9, 0x18, 0xa0, 0xe9, 0x20, 0x5c, 0xef, + 0xa9, 0x37, 0xa0, 0xe9, 0x20, 0xbe, 0xe7, 0x68, 0x20, 0xd5, 0xec, 0xa9, + 0x3c, 0xa0, 0xe9, 0x20, 0xe3, 0xe9, 0xd0, 0x03, 0x4c, 0xe2, 0xe9, 0x20, + 0x0e, 0xea, 0xa9, 0x00, 0x85, 0x62, 0x85, 0x63, 0x85, 0x64, 0x85, 0x65, + 0xa5, 0xac, 0x20, 0xb0, 0xe9, 0xa5, 0xa1, 0x20, 0xb0, 0xe9, 0xa5, 0xa0, + 0x20, 0xb0, 0xe9, 0xa5, 0x9f, 0x20, 0xb0, 0xe9, 0xa5, 0x9e, 0x20, 0xb5, + 0xe9, 0x4c, 0xe6, 0xea, 0xd0, 0x03, 0x4c, 0xda, 0xe8, 0x4a, 0x09, 0x80, + 0xa8, 0x90, 0x19, 0x18, 0xa5, 0x65, 0x65, 0xa9, 0x85, 0x65, 0xa5, 0x64, + 0x65, 0xa8, 0x85, 0x64, 0xa5, 0x63, 0x65, 0xa7, 0x85, 0x63, 0xa5, 0x62, + 0x65, 0xa6, 0x85, 0x62, 0x66, 0x62, 0x66, 0x63, 0x66, 0x64, 0x66, 0x65, + 0x66, 0xac, 0x98, 0x4a, 0xd0, 0xd6, 0x60, 0x85, 0x5e, 0x84, 0x5f, 0xa0, + 0x04, 0xb1, 0x5e, 0x85, 0xa9, 0x88, 0xb1, 0x5e, 0x85, 0xa8, 0x88, 0xb1, + 0x5e, 0x85, 0xa7, 0x88, 0xb1, 0x5e, 0x85, 0xaa, 0x45, 0xa2, 0x85, 0xab, + 0xa5, 0xaa, 0x09, 0x80, 0x85, 0xa6, 0x88, 0xb1, 0x5e, 0x85, 0xa5, 0xa5, + 0x9d, 0x60, 0xa5, 0xa5, 0xf0, 0x1f, 0x18, 0x65, 0x9d, 0x90, 0x04, 0x30, + 0x1d, 0x18, 0x2c, 0x10, 0x14, 0x69, 0x80, 0x85, 0x9d, 0xd0, 0x03, 0x4c, + 0x52, 0xe8, 0xa5, 0xab, 0x85, 0xa2, 0x60, 0xa5, 0xa2, 0x49, 0xff, 0x30, + 0x05, 0x68, 0x68, 0x4c, 0x4e, 0xe8, 0x4c, 0xd5, 0xe8, 0x20, 0x63, 0xeb, + 0xaa, 0xf0, 0x10, 0x18, 0x69, 0x02, 0xb0, 0xf2, 0xa2, 0x00, 0x86, 0xab, + 0x20, 0xce, 0xe7, 0xe6, 0x9d, 0xf0, 0xe7, 0x60, 0x84, 0x20, 0x00, 0x00, + 0x00, 0x20, 0x63, 0xeb, 0xa9, 0x50, 0xa0, 0xea, 0xa2, 0x00, 0x86, 0xab, + 0x20, 0xf9, 0xea, 0x4c, 0x69, 0xea, 0x20, 0xe3, 0xe9, 0xf0, 0x76, 0x20, + 0x72, 0xeb, 0xa9, 0x00, 0x38, 0xe5, 0x9d, 0x85, 0x9d, 0x20, 0x0e, 0xea, + 0xe6, 0x9d, 0xf0, 0xba, 0xa2, 0xfc, 0xa9, 0x01, 0xa4, 0xa6, 0xc4, 0x9e, + 0xd0, 0x10, 0xa4, 0xa7, 0xc4, 0x9f, 0xd0, 0x0a, 0xa4, 0xa8, 0xc4, 0xa0, + 0xd0, 0x04, 0xa4, 0xa9, 0xc4, 0xa1, 0x08, 0x2a, 0x90, 0x09, 0xe8, 0x95, + 0x65, 0xf0, 0x32, 0x10, 0x34, 0xa9, 0x01, 0x28, 0xb0, 0x0e, 0x06, 0xa9, + 0x26, 0xa8, 0x26, 0xa7, 0x26, 0xa6, 0xb0, 0xe6, 0x30, 0xce, 0x10, 0xe2, + 0xa8, 0xa5, 0xa9, 0xe5, 0xa1, 0x85, 0xa9, 0xa5, 0xa8, 0xe5, 0xa0, 0x85, + 0xa8, 0xa5, 0xa7, 0xe5, 0x9f, 0x85, 0xa7, 0xa5, 0xa6, 0xe5, 0x9e, 0x85, + 0xa6, 0x98, 0x4c, 0xa6, 0xea, 0xa9, 0x40, 0xd0, 0xce, 0x0a, 0x0a, 0x0a, + 0x0a, 0x0a, 0x0a, 0x85, 0xac, 0x28, 0x4c, 0xe6, 0xea, 0xa2, 0x85, 0x4c, + 0x12, 0xd4, 0xa5, 0x62, 0x85, 0x9e, 0xa5, 0x63, 0x85, 0x9f, 0xa5, 0x64, + 0x85, 0xa0, 0xa5, 0x65, 0x85, 0xa1, 0x4c, 0x2e, 0xe8, 0x85, 0x5e, 0x84, + 0x5f, 0xa0, 0x04, 0xb1, 0x5e, 0x85, 0xa1, 0x88, 0xb1, 0x5e, 0x85, 0xa0, + 0x88, 0xb1, 0x5e, 0x85, 0x9f, 0x88, 0xb1, 0x5e, 0x85, 0xa2, 0x09, 0x80, + 0x85, 0x9e, 0x88, 0xb1, 0x5e, 0x85, 0x9d, 0x84, 0xac, 0x60, 0xa2, 0x98, + 0x2c, 0xa2, 0x93, 0xa0, 0x00, 0xf0, 0x04, 0xa6, 0x85, 0xa4, 0x86, 0x20, + 0x72, 0xeb, 0x86, 0x5e, 0x84, 0x5f, 0xa0, 0x04, 0xa5, 0xa1, 0x91, 0x5e, + 0x88, 0xa5, 0xa0, 0x91, 0x5e, 0x88, 0xa5, 0x9f, 0x91, 0x5e, 0x88, 0xa5, + 0xa2, 0x09, 0x7f, 0x25, 0x9e, 0x91, 0x5e, 0x88, 0xa5, 0x9d, 0x91, 0x5e, + 0x84, 0xac, 0x60, 0xa5, 0xaa, 0x85, 0xa2, 0xa2, 0x05, 0xb5, 0xa4, 0x95, + 0x9c, 0xca, 0xd0, 0xf9, 0x86, 0xac, 0x60, 0x20, 0x72, 0xeb, 0xa2, 0x06, + 0xb5, 0x9c, 0x95, 0xa4, 0xca, 0xd0, 0xf9, 0x86, 0xac, 0x60, 0xa5, 0x9d, + 0xf0, 0xfb, 0x06, 0xac, 0x90, 0xf7, 0x20, 0xc6, 0xe8, 0xd0, 0xf2, 0x4c, + 0x8f, 0xe8, 0xa5, 0x9d, 0xf0, 0x09, 0xa5, 0xa2, 0x2a, 0xa9, 0xff, 0xb0, + 0x02, 0xa9, 0x01, 0x60, 0x20, 0x82, 0xeb, 0x85, 0x9e, 0xa9, 0x00, 0x85, + 0x9f, 0xa2, 0x88, 0xa5, 0x9e, 0x49, 0xff, 0x2a, 0xa9, 0x00, 0x85, 0xa1, + 0x85, 0xa0, 0x86, 0x9d, 0x85, 0xac, 0x85, 0xa2, 0x4c, 0x29, 0xe8, 0x46, + 0xa2, 0x60, 0x85, 0x60, 0x84, 0x61, 0xa0, 0x00, 0xb1, 0x60, 0xc8, 0xaa, + 0xf0, 0xc4, 0xb1, 0x60, 0x45, 0xa2, 0x30, 0xc2, 0xe4, 0x9d, 0xd0, 0x21, + 0xb1, 0x60, 0x09, 0x80, 0xc5, 0x9e, 0xd0, 0x19, 0xc8, 0xb1, 0x60, 0xc5, + 0x9f, 0xd0, 0x12, 0xc8, 0xb1, 0x60, 0xc5, 0xa0, 0xd0, 0x0b, 0xc8, 0xa9, + 0x7f, 0xc5, 0xac, 0xb1, 0x60, 0xe5, 0xa1, 0xf0, 0x28, 0xa5, 0xa2, 0x90, + 0x02, 0x49, 0xff, 0x4c, 0x88, 0xeb, 0xa5, 0x9d, 0xf0, 0x4a, 0x38, 0xe9, + 0xa0, 0x24, 0xa2, 0x10, 0x09, 0xaa, 0xa9, 0xff, 0x85, 0xa4, 0x20, 0xa4, + 0xe8, 0x8a, 0xa2, 0x9d, 0xc9, 0xf9, 0x10, 0x06, 0x20, 0xf0, 0xe8, 0x84, + 0xa4, 0x60, 0xa8, 0xa5, 0xa2, 0x29, 0x80, 0x46, 0x9e, 0x05, 0x9e, 0x85, + 0x9e, 0x20, 0x07, 0xe9, 0x84, 0xa4, 0x60, 0xa5, 0x9d, 0xc9, 0xa0, 0xb0, + 0x20, 0x20, 0xf2, 0xeb, 0x84, 0xac, 0xa5, 0xa2, 0x84, 0xa2, 0x49, 0x80, + 0x2a, 0xa9, 0xa0, 0x85, 0x9d, 0xa5, 0xa1, 0x85, 0x0d, 0x4c, 0x29, 0xe8, + 0x85, 0x9e, 0x85, 0x9f, 0x85, 0xa0, 0x85, 0xa1, 0xa8, 0x60, 0xa0, 0x00, + 0xa2, 0x0a, 0x94, 0x99, 0xca, 0x10, 0xfb, 0x90, 0x0f, 0xc9, 0x2d, 0xd0, + 0x04, 0x86, 0xa3, 0xf0, 0x04, 0xc9, 0x2b, 0xd0, 0x05, 0x20, 0xb1, 0x00, + 0x90, 0x5b, 0xc9, 0x2e, 0xf0, 0x2e, 0xc9, 0x45, 0xd0, 0x30, 0x20, 0xb1, + 0x00, 0x90, 0x17, 0xc9, 0xc9, 0xf0, 0x0e, 0xc9, 0x2d, 0xf0, 0x0a, 0xc9, + 0xc8, 0xf0, 0x08, 0xc9, 0x2b, 0xf0, 0x04, 0xd0, 0x07, 0x66, 0x9c, 0x20, + 0xb1, 0x00, 0x90, 0x5c, 0x24, 0x9c, 0x10, 0x0e, 0xa9, 0x00, 0x38, 0xe5, + 0x9a, 0x4c, 0xa0, 0xec, 0x66, 0x9b, 0x24, 0x9b, 0x50, 0xc3, 0xa5, 0x9a, + 0x38, 0xe5, 0x99, 0x85, 0x9a, 0xf0, 0x12, 0x10, 0x09, 0x20, 0x55, 0xea, + 0xe6, 0x9a, 0xd0, 0xf9, 0xf0, 0x07, 0x20, 0x39, 0xea, 0xc6, 0x9a, 0xd0, + 0xf9, 0xa5, 0xa3, 0x30, 0x01, 0x60, 0x4c, 0xd0, 0xee, 0x48, 0x24, 0x9b, + 0x10, 0x02, 0xe6, 0x99, 0x20, 0x39, 0xea, 0x68, 0x38, 0xe9, 0x30, 0x20, + 0xd5, 0xec, 0x4c, 0x61, 0xec, 0x48, 0x20, 0x63, 0xeb, 0x68, 0x20, 0x93, + 0xeb, 0xa5, 0xaa, 0x45, 0xa2, 0x85, 0xab, 0xa6, 0x9d, 0x4c, 0xc1, 0xe7, + 0xa5, 0x9a, 0xc9, 0x0a, 0x90, 0x09, 0xa9, 0x64, 0x24, 0x9c, 0x30, 0x11, + 0x4c, 0xd5, 0xe8, 0x0a, 0x0a, 0x18, 0x65, 0x9a, 0x0a, 0x18, 0xa0, 0x00, + 0x71, 0xb8, 0x38, 0xe9, 0x30, 0x85, 0x9a, 0x4c, 0x87, 0xec, 0x9b, 0x3e, + 0xbc, 0x1f, 0xfd, 0x9e, 0x6e, 0x6b, 0x27, 0xfd, 0x9e, 0x6e, 0x6b, 0x28, + 0x00, 0xa9, 0x58, 0xa0, 0xd3, 0x20, 0x31, 0xed, 0xa5, 0x76, 0xa6, 0x75, + 0x85, 0x9e, 0x86, 0x9f, 0xa2, 0x90, 0x38, 0x20, 0xa0, 0xeb, 0x20, 0x34, + 0xed, 0x4c, 0x3a, 0xdb, 0xa0, 0x01, 0xa9, 0x2d, 0x88, 0x24, 0xa2, 0x10, + 0x04, 0xc8, 0x99, 0xff, 0x00, 0x85, 0xa2, 0x84, 0xad, 0xc8, 0xa9, 0x30, + 0xa6, 0x9d, 0xd0, 0x03, 0x4c, 0x57, 0xee, 0xa9, 0x00, 0xe0, 0x80, 0xf0, + 0x02, 0xb0, 0x09, 0xa9, 0x14, 0xa0, 0xed, 0x20, 0x7f, 0xe9, 0xa9, 0xf7, + 0x85, 0x99, 0xa9, 0x0f, 0xa0, 0xed, 0x20, 0xb2, 0xeb, 0xf0, 0x1e, 0x10, + 0x12, 0xa9, 0x0a, 0xa0, 0xed, 0x20, 0xb2, 0xeb, 0xf0, 0x02, 0x10, 0x0e, + 0x20, 0x39, 0xea, 0xc6, 0x99, 0xd0, 0xee, 0x20, 0x55, 0xea, 0xe6, 0x99, + 0xd0, 0xdc, 0x20, 0xa0, 0xe7, 0x20, 0xf2, 0xeb, 0xa2, 0x01, 0xa5, 0x99, + 0x18, 0x69, 0x0a, 0x30, 0x09, 0xc9, 0x0b, 0xb0, 0x06, 0x69, 0xff, 0xaa, + 0xa9, 0x02, 0x38, 0xe9, 0x02, 0x85, 0x9a, 0x86, 0x99, 0x8a, 0xf0, 0x02, + 0x10, 0x13, 0xa4, 0xad, 0xa9, 0x2e, 0xc8, 0x99, 0xff, 0x00, 0x8a, 0xf0, + 0x06, 0xa9, 0x30, 0xc8, 0x99, 0xff, 0x00, 0x84, 0xad, 0xa0, 0x00, 0xa2, + 0x80, 0xa5, 0xa1, 0x18, 0x79, 0x6c, 0xee, 0x85, 0xa1, 0xa5, 0xa0, 0x79, + 0x6b, 0xee, 0x85, 0xa0, 0xa5, 0x9f, 0x79, 0x6a, 0xee, 0x85, 0x9f, 0xa5, + 0x9e, 0x79, 0x69, 0xee, 0x85, 0x9e, 0xe8, 0xb0, 0x04, 0x10, 0xde, 0x30, + 0x02, 0x30, 0xda, 0x8a, 0x90, 0x04, 0x49, 0xff, 0x69, 0x0a, 0x69, 0x2f, + 0xc8, 0xc8, 0xc8, 0xc8, 0x84, 0x83, 0xa4, 0xad, 0xc8, 0xaa, 0x29, 0x7f, + 0x99, 0xff, 0x00, 0xc6, 0x99, 0xd0, 0x06, 0xa9, 0x2e, 0xc8, 0x99, 0xff, + 0x00, 0x84, 0xad, 0xa4, 0x83, 0x8a, 0x49, 0xff, 0x29, 0x80, 0xaa, 0xc0, + 0x24, 0xd0, 0xaa, 0xa4, 0xad, 0xb9, 0xff, 0x00, 0x88, 0xc9, 0x30, 0xf0, + 0xf8, 0xc9, 0x2e, 0xf0, 0x01, 0xc8, 0xa9, 0x2b, 0xa6, 0x9a, 0xf0, 0x2e, + 0x10, 0x08, 0xa9, 0x00, 0x38, 0xe5, 0x9a, 0xaa, 0xa9, 0x2d, 0x99, 0x01, + 0x01, 0xa9, 0x45, 0x99, 0x00, 0x01, 0x8a, 0xa2, 0x2f, 0x38, 0xe8, 0xe9, + 0x0a, 0xb0, 0xfb, 0x69, 0x3a, 0x99, 0x03, 0x01, 0x8a, 0x99, 0x02, 0x01, + 0xa9, 0x00, 0x99, 0x04, 0x01, 0xf0, 0x08, 0x99, 0xff, 0x00, 0xa9, 0x00, + 0x99, 0x00, 0x01, 0xa9, 0x00, 0xa0, 0x01, 0x60, 0x80, 0x00, 0x00, 0x00, + 0x00, 0xfa, 0x0a, 0x1f, 0x00, 0x00, 0x98, 0x96, 0x80, 0xff, 0xf0, 0xbd, + 0xc0, 0x00, 0x01, 0x86, 0xa0, 0xff, 0xff, 0xd8, 0xf0, 0x00, 0x00, 0x03, + 0xe8, 0xff, 0xff, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x0a, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x63, 0xeb, 0xa9, 0x64, 0xa0, 0xee, 0x20, 0xf9, 0xea, 0xf0, + 0x70, 0xa5, 0xa5, 0xd0, 0x03, 0x4c, 0x50, 0xe8, 0xa2, 0x8a, 0xa0, 0x00, + 0x20, 0x2b, 0xeb, 0xa5, 0xaa, 0x10, 0x0f, 0x20, 0x23, 0xec, 0xa9, 0x8a, + 0xa0, 0x00, 0x20, 0xb2, 0xeb, 0xd0, 0x03, 0x98, 0xa4, 0x0d, 0x20, 0x55, + 0xeb, 0x98, 0x48, 0x20, 0x41, 0xe9, 0xa9, 0x8a, 0xa0, 0x00, 0x20, 0x7f, + 0xe9, 0x20, 0x09, 0xef, 0x68, 0x4a, 0x90, 0x0a, 0xa5, 0x9d, 0xf0, 0x06, + 0xa5, 0xa2, 0x49, 0xff, 0x85, 0xa2, 0x60, 0x81, 0x38, 0xaa, 0x3b, 0x29, + 0x07, 0x71, 0x34, 0x58, 0x3e, 0x56, 0x74, 0x16, 0x7e, 0xb3, 0x1b, 0x77, + 0x2f, 0xee, 0xe3, 0x85, 0x7a, 0x1d, 0x84, 0x1c, 0x2a, 0x7c, 0x63, 0x59, + 0x58, 0x0a, 0x7e, 0x75, 0xfd, 0xe7, 0xc6, 0x80, 0x31, 0x72, 0x18, 0x10, + 0x81, 0x00, 0x00, 0x00, 0x00, 0xa9, 0xdb, 0xa0, 0xee, 0x20, 0x7f, 0xe9, + 0xa5, 0xac, 0x69, 0x50, 0x90, 0x03, 0x20, 0x7a, 0xeb, 0x85, 0x92, 0x20, + 0x66, 0xeb, 0xa5, 0x9d, 0xc9, 0x88, 0x90, 0x03, 0x20, 0x2b, 0xea, 0x20, + 0x23, 0xec, 0xa5, 0x0d, 0x18, 0x69, 0x81, 0xf0, 0xf3, 0x38, 0xe9, 0x01, + 0x48, 0xa2, 0x05, 0xb5, 0xa5, 0xb4, 0x9d, 0x95, 0x9d, 0x94, 0xa5, 0xca, + 0x10, 0xf5, 0xa5, 0x92, 0x85, 0xac, 0x20, 0xaa, 0xe7, 0x20, 0xd0, 0xee, + 0xa9, 0xe0, 0xa0, 0xee, 0x20, 0x72, 0xef, 0xa9, 0x00, 0x85, 0xab, 0x68, + 0x20, 0x10, 0xea, 0x60, 0x85, 0xad, 0x84, 0xae, 0x20, 0x21, 0xeb, 0xa9, + 0x93, 0x20, 0x7f, 0xe9, 0x20, 0x76, 0xef, 0xa9, 0x93, 0xa0, 0x00, 0x4c, + 0x7f, 0xe9, 0x85, 0xad, 0x84, 0xae, 0x20, 0x1e, 0xeb, 0xb1, 0xad, 0x85, + 0xa3, 0xa4, 0xad, 0xc8, 0x98, 0xd0, 0x02, 0xe6, 0xae, 0x85, 0xad, 0xa4, + 0xae, 0x20, 0x7f, 0xe9, 0xa5, 0xad, 0xa4, 0xae, 0x18, 0x69, 0x05, 0x90, + 0x01, 0xc8, 0x85, 0xad, 0x84, 0xae, 0x20, 0xbe, 0xe7, 0xa9, 0x98, 0xa0, + 0x00, 0xc6, 0xa3, 0xd0, 0xe4, 0x60, 0x98, 0x35, 0x44, 0x7a, 0x68, 0x28, + 0xb1, 0x46, 0x20, 0x82, 0xeb, 0xaa, 0x30, 0x18, 0xa9, 0xc9, 0xa0, 0x00, + 0x20, 0xf9, 0xea, 0x8a, 0xf0, 0xe7, 0xa9, 0xa6, 0xa0, 0xef, 0x20, 0x7f, + 0xe9, 0xa9, 0xaa, 0xa0, 0xef, 0x20, 0xbe, 0xe7, 0xa6, 0xa1, 0xa5, 0x9e, + 0x85, 0xa1, 0x86, 0x9e, 0xa9, 0x00, 0x85, 0xa2, 0xa5, 0x9d, 0x85, 0xac, + 0xa9, 0x80, 0x85, 0x9d, 0x20, 0x2e, 0xe8, 0xa2, 0xc9, 0xa0, 0x00, 0x4c, + 0x2b, 0xeb, 0xa9, 0x66, 0xa0, 0xf0, 0x20, 0xbe, 0xe7, 0x20, 0x63, 0xeb, + 0xa9, 0x6b, 0xa0, 0xf0, 0xa6, 0xaa, 0x20, 0x5e, 0xea, 0x20, 0x63, 0xeb, + 0x20, 0x23, 0xec, 0xa9, 0x00, 0x85, 0xab, 0x20, 0xaa, 0xe7, 0xa9, 0x70, + 0xa0, 0xf0, 0x20, 0xa7, 0xe7, 0xa5, 0xa2, 0x48, 0x10, 0x0d, 0x20, 0xa0, + 0xe7, 0xa5, 0xa2, 0x30, 0x09, 0xa5, 0x16, 0x49, 0xff, 0x85, 0x16, 0x20, + 0xd0, 0xee, 0xa9, 0x70, 0xa0, 0xf0, 0x20, 0xbe, 0xe7, 0x68, 0x10, 0x03, + 0x20, 0xd0, 0xee, 0xa9, 0x75, 0xa0, 0xf0, 0x4c, 0x5c, 0xef, 0x20, 0x21, + 0xeb, 0xa9, 0x00, 0x85, 0x16, 0x20, 0xf1, 0xef, 0xa2, 0x8a, 0xa0, 0x00, + 0x20, 0xe7, 0xef, 0xa9, 0x93, 0xa0, 0x00, 0x20, 0xf9, 0xea, 0xa9, 0x00, + 0x85, 0xa2, 0xa5, 0x16, 0x20, 0x62, 0xf0, 0xa9, 0x8a, 0xa0, 0x00, 0x4c, + 0x66, 0xea, 0x48, 0x4c, 0x23, 0xf0, 0x81, 0x49, 0x0f, 0xda, 0xa2, 0x83, + 0x49, 0x0f, 0xda, 0xa2, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x05, 0x84, 0xe6, + 0x1a, 0x2d, 0x1b, 0x86, 0x28, 0x07, 0xfb, 0xf8, 0x87, 0x99, 0x68, 0x89, + 0x01, 0x87, 0x23, 0x35, 0xdf, 0xe1, 0x86, 0xa5, 0x5d, 0xe7, 0x28, 0x83, + 0x49, 0x0f, 0xda, 0xa2, 0xa6, 0xd3, 0xc1, 0xc8, 0xd4, 0xc8, 0xd5, 0xc4, + 0xce, 0xca, 0xa5, 0xa2, 0x48, 0x10, 0x03, 0x20, 0xd0, 0xee, 0xa5, 0x9d, + 0x48, 0xc9, 0x81, 0x90, 0x07, 0xa9, 0x13, 0xa0, 0xe9, 0x20, 0x66, 0xea, + 0xa9, 0xce, 0xa0, 0xf0, 0x20, 0x5c, 0xef, 0x68, 0xc9, 0x81, 0x90, 0x07, + 0xa9, 0x66, 0xa0, 0xf0, 0x20, 0xa7, 0xe7, 0x68, 0x10, 0x03, 0x4c, 0xd0, + 0xee, 0x60, 0x0b, 0x76, 0xb3, 0x83, 0xbd, 0xd3, 0x79, 0x1e, 0xf4, 0xa6, + 0xf5, 0x7b, 0x83, 0xfc, 0xb0, 0x10, 0x7c, 0x0c, 0x1f, 0x67, 0xca, 0x7c, + 0xde, 0x53, 0xcb, 0xc1, 0x7d, 0x14, 0x64, 0x70, 0x4c, 0x7d, 0xb7, 0xea, + 0x51, 0x7a, 0x7d, 0x63, 0x30, 0x88, 0x7e, 0x7e, 0x92, 0x44, 0x99, 0x3a, + 0x7e, 0x4c, 0xcc, 0x91, 0xc7, 0x7f, 0xaa, 0xaa, 0xaa, 0x13, 0x81, 0x00, + 0x00, 0x00, 0x00, 0xe6, 0xb8, 0xd0, 0x02, 0xe6, 0xb9, 0xad, 0x60, 0xea, + 0xc9, 0x3a, 0xb0, 0x0a, 0xc9, 0x20, 0xf0, 0xef, 0x38, 0xe9, 0x30, 0x38, + 0xe9, 0xd0, 0x60, 0x80, 0x4f, 0xc7, 0x52, 0x58, 0xa2, 0xff, 0x86, 0x76, + 0xa2, 0xfb, 0x9a, 0xa9, 0x28, 0xa0, 0xf1, 0x85, 0x01, 0x84, 0x02, 0x85, + 0x04, 0x84, 0x05, 0x20, 0x73, 0xf2, 0xa9, 0x4c, 0x85, 0x00, 0x85, 0x03, + 0x85, 0x90, 0x85, 0x0a, 0xa9, 0x99, 0xa0, 0xe1, 0x85, 0x0b, 0x84, 0x0c, + 0xa2, 0x1c, 0xbd, 0x0a, 0xf1, 0x95, 0xb0, 0x86, 0xf1, 0xca, 0xd0, 0xf6, + 0x86, 0xf2, 0x8a, 0x85, 0xa4, 0x85, 0x54, 0x48, 0xa9, 0x03, 0x85, 0x8f, + 0x20, 0xfb, 0xda, 0xa9, 0x01, 0x8d, 0xfd, 0x01, 0x8d, 0xfc, 0x01, 0xa2, + 0x55, 0x86, 0x52, 0xa9, 0x00, 0xa0, 0x08, 0x85, 0x50, 0x84, 0x51, 0xa0, + 0x00, 0xe6, 0x51, 0xb1, 0x50, 0x49, 0xff, 0x91, 0x50, 0xd1, 0x50, 0xd0, + 0x08, 0x49, 0xff, 0x91, 0x50, 0xd1, 0x50, 0xf0, 0xec, 0xa4, 0x50, 0xa5, + 0x51, 0x29, 0xf0, 0x84, 0x73, 0x85, 0x74, 0x84, 0x6f, 0x85, 0x70, 0xa2, + 0x00, 0xa0, 0x08, 0x86, 0x67, 0x84, 0x68, 0xa0, 0x00, 0x84, 0xd6, 0x98, + 0x91, 0x67, 0xe6, 0x67, 0xd0, 0x02, 0xe6, 0x68, 0xa5, 0x67, 0xa4, 0x68, + 0x20, 0xe3, 0xd3, 0x20, 0x4b, 0xd6, 0xa9, 0x3a, 0xa0, 0xdb, 0x85, 0x04, + 0x84, 0x05, 0xa9, 0x3c, 0xa0, 0xd4, 0x85, 0x01, 0x84, 0x02, 0x6c, 0x01, + 0x00, 0x20, 0x67, 0xdd, 0x20, 0x52, 0xe7, 0x6c, 0x50, 0x00, 0x20, 0xf8, + 0xe6, 0x8a, 0x4c, 0x8b, 0xfe, 0x20, 0xf8, 0xe6, 0x8a, 0x4c, 0x95, 0xfe, + 0x20, 0xf8, 0xe6, 0xe0, 0x30, 0xb0, 0x13, 0x86, 0xf0, 0xa9, 0x2c, 0x20, + 0xc0, 0xde, 0x20, 0xf8, 0xe6, 0xe0, 0x30, 0xb0, 0x05, 0x86, 0x2c, 0x86, + 0x2d, 0x60, 0x4c, 0x99, 0xe1, 0x20, 0xec, 0xf1, 0xe4, 0xf0, 0xb0, 0x08, + 0xa5, 0xf0, 0x85, 0x2c, 0x85, 0x2d, 0x86, 0xf0, 0xa9, 0xc5, 0x20, 0xc0, + 0xde, 0x20, 0xf8, 0xe6, 0xe0, 0x30, 0xb0, 0xe2, 0x60, 0x20, 0xec, 0xf1, + 0x8a, 0xa4, 0xf0, 0xc0, 0x28, 0xb0, 0xd7, 0x4c, 0x00, 0xf8, 0x20, 0x09, + 0xf2, 0x8a, 0xa4, 0x2c, 0xc0, 0x28, 0xb0, 0xca, 0xa4, 0xf0, 0x4c, 0x19, + 0xf8, 0x20, 0x09, 0xf2, 0x8a, 0xa8, 0xc0, 0x28, 0xb0, 0xbc, 0xa5, 0xf0, + 0x4c, 0x28, 0xf8, 0x20, 0xf8, 0xe6, 0x8a, 0x4c, 0x64, 0xf8, 0x20, 0xf8, + 0xe6, 0xca, 0x8a, 0xc9, 0x18, 0xb0, 0xa7, 0x4c, 0x5b, 0xfb, 0x20, 0xf8, + 0xe6, 0x8a, 0x49, 0xff, 0xaa, 0xe8, 0x86, 0xf1, 0x60, 0x38, 0x90, 0x18, + 0x66, 0xf2, 0x60, 0xa9, 0xff, 0xd0, 0x02, 0xa9, 0x3f, 0xa2, 0x00, 0x85, + 0x32, 0x86, 0xf3, 0x60, 0xa9, 0x7f, 0xa2, 0x40, 0xd0, 0xf5, 0x20, 0x67, + 0xdd, 0x20, 0x52, 0xe7, 0xa5, 0x50, 0xc5, 0x6d, 0xa5, 0x51, 0xe5, 0x6e, + 0xb0, 0x03, 0x4c, 0x10, 0xd4, 0xa5, 0x50, 0x85, 0x73, 0x85, 0x6f, 0xa5, + 0x51, 0x85, 0x74, 0x85, 0x70, 0x60, 0x20, 0x67, 0xdd, 0x20, 0x52, 0xe7, + 0xa5, 0x50, 0xc5, 0x73, 0xa5, 0x51, 0xe5, 0x74, 0xb0, 0xe0, 0xa5, 0x50, + 0xc5, 0x69, 0xa5, 0x51, 0xe5, 0x6a, 0x90, 0xd6, 0xa5, 0x50, 0x85, 0x69, + 0xa5, 0x51, 0x85, 0x6a, 0x4c, 0x6c, 0xd6, 0xa9, 0xab, 0x20, 0xc0, 0xde, + 0xa5, 0xb8, 0x85, 0xf4, 0xa5, 0xb9, 0x85, 0xf5, 0x38, 0x66, 0xd8, 0xa5, + 0x75, 0x85, 0xf6, 0xa5, 0x76, 0x85, 0xf7, 0x20, 0xa6, 0xd9, 0x4c, 0x98, + 0xd9, 0x86, 0xde, 0xa6, 0xf8, 0x86, 0xdf, 0xa5, 0x75, 0x85, 0xda, 0xa5, + 0x76, 0x85, 0xdb, 0xa5, 0x79, 0x85, 0xdc, 0xa5, 0x7a, 0x85, 0xdd, 0xa5, + 0xf4, 0x85, 0xb8, 0xa5, 0xf5, 0x85, 0xb9, 0xa5, 0xf6, 0x85, 0x75, 0xa5, + 0xf7, 0x85, 0x76, 0x20, 0xb7, 0x00, 0x20, 0x3e, 0xd9, 0x4c, 0xd2, 0xd7, + 0xa5, 0xda, 0x85, 0x75, 0xa5, 0xdb, 0x85, 0x76, 0xa5, 0xdc, 0x85, 0xb8, + 0xa5, 0xdd, 0x85, 0xb9, 0xa6, 0xdf, 0x9a, 0x4c, 0xd2, 0xd7, 0x4c, 0xc9, + 0xde, 0xb0, 0xfb, 0xa6, 0xaf, 0x86, 0x69, 0xa6, 0xb0, 0x86, 0x6a, 0x20, + 0x0c, 0xda, 0x20, 0x1a, 0xd6, 0xa5, 0x9b, 0x85, 0x60, 0xa5, 0x9c, 0x85, + 0x61, 0xa9, 0x2c, 0x20, 0xc0, 0xde, 0x20, 0x0c, 0xda, 0xe6, 0x50, 0xd0, + 0x02, 0xe6, 0x51, 0x20, 0x1a, 0xd6, 0xa5, 0x9b, 0xc5, 0x60, 0xa5, 0x9c, + 0xe5, 0x61, 0xb0, 0x01, 0x60, 0xa0, 0x00, 0xb1, 0x9b, 0x91, 0x60, 0xe6, + 0x9b, 0xd0, 0x02, 0xe6, 0x9c, 0xe6, 0x60, 0xd0, 0x02, 0xe6, 0x61, 0xa5, + 0x69, 0xc5, 0x9b, 0xa5, 0x6a, 0xe5, 0x9c, 0xb0, 0xe6, 0xa6, 0x61, 0xa4, + 0x60, 0xd0, 0x01, 0xca, 0x88, 0x86, 0x6a, 0x84, 0x69, 0x4c, 0xf2, 0xd4, + 0xad, 0x56, 0xc0, 0xad, 0x53, 0xc0, 0x4c, 0x40, 0xfb, 0xad, 0x54, 0xc0, + 0x4c, 0x39, 0xfb, 0x20, 0xd9, 0xf7, 0xa0, 0x03, 0xb1, 0x9b, 0xaa, 0x88, + 0xb1, 0x9b, 0xe9, 0x01, 0xb0, 0x01, 0xca, 0x85, 0x50, 0x86, 0x51, 0x20, + 0xcd, 0xfe, 0x20, 0x77, 0xf7, 0x4c, 0xcd, 0xfe, 0x20, 0xd9, 0xf7, 0x20, + 0xfd, 0xfe, 0xa0, 0x02, 0xb1, 0x9b, 0xc5, 0x50, 0xc8, 0xb1, 0x9b, 0xe5, + 0x51, 0xb0, 0x03, 0x4c, 0x10, 0xd4, 0x20, 0x77, 0xf7, 0x4c, 0xfd, 0xfe, + 0x2c, 0x55, 0xc0, 0x2c, 0x52, 0xc0, 0xa9, 0x40, 0xd0, 0x08, 0xa9, 0x20, + 0x2c, 0x54, 0xc0, 0x2c, 0x53, 0xc0, 0x85, 0xe6, 0xad, 0x57, 0xc0, 0xad, + 0x50, 0xc0, 0xa9, 0x00, 0x85, 0x1c, 0xa5, 0xe6, 0x85, 0x1b, 0xa0, 0x00, + 0x84, 0x1a, 0xa5, 0x1c, 0x91, 0x1a, 0x20, 0x7e, 0xf4, 0xc8, 0xd0, 0xf6, + 0xe6, 0x1b, 0xa5, 0x1b, 0x29, 0x1f, 0xd0, 0xee, 0x60, 0x85, 0xe2, 0x86, + 0xe0, 0x84, 0xe1, 0x48, 0x29, 0xc0, 0x85, 0x26, 0x4a, 0x4a, 0x05, 0x26, + 0x85, 0x26, 0x68, 0x85, 0x27, 0x0a, 0x0a, 0x0a, 0x26, 0x27, 0x0a, 0x26, + 0x27, 0x0a, 0x66, 0x26, 0xa5, 0x27, 0x29, 0x1f, 0x05, 0xe6, 0x85, 0x27, + 0x8a, 0xc0, 0x00, 0xf0, 0x05, 0xa0, 0x23, 0x69, 0x04, 0xc8, 0xe9, 0x07, + 0xb0, 0xfb, 0x84, 0xe5, 0xaa, 0xbd, 0xb9, 0xf4, 0x85, 0x30, 0x98, 0x4a, + 0xa5, 0xe4, 0x85, 0x1c, 0xb0, 0x28, 0x60, 0x20, 0x11, 0xf4, 0xa5, 0x1c, + 0x51, 0x26, 0x25, 0x30, 0x51, 0x26, 0x91, 0x26, 0x60, 0x10, 0x23, 0xa5, + 0x30, 0x4a, 0xb0, 0x05, 0x49, 0xc0, 0x85, 0x30, 0x60, 0x88, 0x10, 0x02, + 0xa0, 0x27, 0xa9, 0xc0, 0x85, 0x30, 0x84, 0xe5, 0xa5, 0x1c, 0x0a, 0xc9, + 0xc0, 0x10, 0x06, 0xa5, 0x1c, 0x49, 0x7f, 0x85, 0x1c, 0x60, 0xa5, 0x30, + 0x0a, 0x49, 0x80, 0x30, 0xdd, 0xa9, 0x81, 0xc8, 0xc0, 0x28, 0x90, 0xe0, + 0xa0, 0x00, 0xb0, 0xdc, 0x18, 0xa5, 0xd1, 0x29, 0x04, 0xf0, 0x25, 0xa9, + 0x7f, 0x25, 0x30, 0x31, 0x26, 0xd0, 0x19, 0xe6, 0xea, 0xa9, 0x7f, 0x25, + 0x30, 0x10, 0x11, 0x18, 0xa5, 0xd1, 0x29, 0x04, 0xf0, 0x0e, 0xb1, 0x26, + 0x45, 0x1c, 0x25, 0x30, 0xd0, 0x02, 0xe6, 0xea, 0x51, 0x26, 0x91, 0x26, + 0xa5, 0xd1, 0x65, 0xd3, 0x29, 0x03, 0xc9, 0x02, 0x6a, 0xb0, 0x92, 0x30, + 0x30, 0x18, 0xa5, 0x27, 0x2c, 0xb9, 0xf5, 0xd0, 0x22, 0x06, 0x26, 0xb0, + 0x1a, 0x2c, 0xcd, 0xf4, 0xf0, 0x05, 0x69, 0x1f, 0x38, 0xb0, 0x12, 0x69, + 0x23, 0x48, 0xa5, 0x26, 0x69, 0xb0, 0xb0, 0x02, 0x69, 0xf0, 0x85, 0x26, + 0x68, 0xb0, 0x02, 0x69, 0x1f, 0x66, 0x26, 0x69, 0xfc, 0x85, 0x27, 0x60, + 0x18, 0xa5, 0x27, 0x69, 0x04, 0x2c, 0xb9, 0xf5, 0xd0, 0xf3, 0x06, 0x26, + 0x90, 0x18, 0x69, 0xe0, 0x18, 0x2c, 0x08, 0xf5, 0xf0, 0x12, 0xa5, 0x26, + 0x69, 0x50, 0x49, 0xf0, 0xf0, 0x02, 0x49, 0xf0, 0x85, 0x26, 0xa5, 0xe6, + 0x90, 0x02, 0x69, 0xe0, 0x66, 0x26, 0x90, 0xd1, 0x48, 0xa9, 0x00, 0x85, + 0xe0, 0x85, 0xe1, 0x85, 0xe2, 0x68, 0x48, 0x38, 0xe5, 0xe0, 0x48, 0x8a, + 0xe5, 0xe1, 0x85, 0xd3, 0xb0, 0x0a, 0x68, 0x49, 0xff, 0x69, 0x01, 0x48, + 0xa9, 0x00, 0xe5, 0xd3, 0x85, 0xd1, 0x85, 0xd5, 0x68, 0x85, 0xd0, 0x85, + 0xd4, 0x68, 0x85, 0xe0, 0x86, 0xe1, 0x98, 0x18, 0xe5, 0xe2, 0x90, 0x04, + 0x49, 0xff, 0x69, 0xfe, 0x85, 0xd2, 0x84, 0xe2, 0x66, 0xd3, 0x38, 0xe5, + 0xd0, 0xaa, 0xa9, 0xff, 0xe5, 0xd1, 0x85, 0x1d, 0xa4, 0xe5, 0xb0, 0x05, + 0x0a, 0x20, 0x65, 0xf4, 0x38, 0xa5, 0xd4, 0x65, 0xd2, 0x85, 0xd4, 0xa5, + 0xd5, 0xe9, 0x00, 0x85, 0xd5, 0xb1, 0x26, 0x45, 0x1c, 0x25, 0x30, 0x51, + 0x26, 0x91, 0x26, 0xe8, 0xd0, 0x04, 0xe6, 0x1d, 0xf0, 0x62, 0xa5, 0xd3, + 0xb0, 0xda, 0x20, 0xd3, 0xf4, 0x18, 0xa5, 0xd4, 0x65, 0xd0, 0x85, 0xd4, + 0xa5, 0xd5, 0x65, 0xd1, 0x50, 0xd9, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, + 0xc0, 0x1c, 0xff, 0xfe, 0xfa, 0xf4, 0xec, 0xe1, 0xd4, 0xc5, 0xb4, 0xa1, + 0x8d, 0x78, 0x61, 0x49, 0x31, 0x18, 0xff, 0xa5, 0x26, 0x0a, 0xa5, 0x27, + 0x29, 0x03, 0x2a, 0x05, 0x26, 0x0a, 0x0a, 0x0a, 0x85, 0xe2, 0xa5, 0x27, + 0x4a, 0x4a, 0x29, 0x07, 0x05, 0xe2, 0x85, 0xe2, 0xa5, 0xe5, 0x0a, 0x65, + 0xe5, 0x0a, 0xaa, 0xca, 0xa5, 0x30, 0x29, 0x7f, 0xe8, 0x4a, 0xd0, 0xfc, + 0x85, 0xe1, 0x8a, 0x18, 0x65, 0xe5, 0x90, 0x02, 0xe6, 0xe1, 0x85, 0xe0, + 0x60, 0x86, 0x1a, 0x84, 0x1b, 0xaa, 0x4a, 0x4a, 0x4a, 0x4a, 0x85, 0xd3, + 0x8a, 0x29, 0x0f, 0xaa, 0xbc, 0xba, 0xf5, 0x84, 0xd0, 0x49, 0x0f, 0xaa, + 0xbc, 0xbb, 0xf5, 0xc8, 0x84, 0xd2, 0xa4, 0xe5, 0xa2, 0x00, 0x86, 0xea, + 0xa1, 0x1a, 0x85, 0xd1, 0xa2, 0x80, 0x86, 0xd4, 0x86, 0xd5, 0xa6, 0xe7, + 0xa5, 0xd4, 0x38, 0x65, 0xd0, 0x85, 0xd4, 0x90, 0x04, 0x20, 0xb3, 0xf4, + 0x18, 0xa5, 0xd5, 0x65, 0xd2, 0x85, 0xd5, 0x90, 0x03, 0x20, 0xb4, 0xf4, + 0xca, 0xd0, 0xe5, 0xa5, 0xd1, 0x4a, 0x4a, 0x4a, 0xd0, 0xd4, 0xe6, 0x1a, + 0xd0, 0x02, 0xe6, 0x1b, 0xa1, 0x1a, 0xd0, 0xca, 0x60, 0x86, 0x1a, 0x84, + 0x1b, 0xaa, 0x4a, 0x4a, 0x4a, 0x4a, 0x85, 0xd3, 0x8a, 0x29, 0x0f, 0xaa, + 0xbc, 0xba, 0xf5, 0x84, 0xd0, 0x49, 0x0f, 0xaa, 0xbc, 0xbb, 0xf5, 0xc8, + 0x84, 0xd2, 0xa4, 0xe5, 0xa2, 0x00, 0x86, 0xea, 0xa1, 0x1a, 0x85, 0xd1, + 0xa2, 0x80, 0x86, 0xd4, 0x86, 0xd5, 0xa6, 0xe7, 0xa5, 0xd4, 0x38, 0x65, + 0xd0, 0x85, 0xd4, 0x90, 0x04, 0x20, 0x9c, 0xf4, 0x18, 0xa5, 0xd5, 0x65, + 0xd2, 0x85, 0xd5, 0x90, 0x03, 0x20, 0x9d, 0xf4, 0xca, 0xd0, 0xe5, 0xa5, + 0xd1, 0x4a, 0x4a, 0x4a, 0xd0, 0xd4, 0xe6, 0x1a, 0xd0, 0x02, 0xe6, 0x1b, + 0xa1, 0x1a, 0xd0, 0xca, 0x60, 0x20, 0x67, 0xdd, 0x20, 0x52, 0xe7, 0xa4, + 0x51, 0xa6, 0x50, 0xc0, 0x01, 0x90, 0x06, 0xd0, 0x1d, 0xe0, 0x18, 0xb0, + 0x19, 0x8a, 0x48, 0x98, 0x48, 0xa9, 0x2c, 0x20, 0xc0, 0xde, 0x20, 0xf8, + 0xe6, 0xe0, 0xc0, 0xb0, 0x09, 0x86, 0x9d, 0x68, 0xa8, 0x68, 0xaa, 0xa5, + 0x9d, 0x60, 0x4c, 0x06, 0xf2, 0x20, 0xf8, 0xe6, 0xe0, 0x08, 0xb0, 0xf6, + 0xbd, 0xf6, 0xf6, 0x85, 0xe4, 0x60, 0x00, 0x2a, 0x55, 0x7f, 0x80, 0xaa, + 0xd5, 0xff, 0xc9, 0xc1, 0xf0, 0x0d, 0x20, 0xb9, 0xf6, 0x20, 0x57, 0xf4, + 0x20, 0xb7, 0x00, 0xc9, 0xc1, 0xd0, 0xe6, 0x20, 0xc0, 0xde, 0x20, 0xb9, + 0xf6, 0x84, 0x9d, 0xa8, 0x8a, 0xa6, 0x9d, 0x20, 0x3a, 0xf5, 0x4c, 0x08, + 0xf7, 0x20, 0xf8, 0xe6, 0x86, 0xf9, 0x60, 0x20, 0xf8, 0xe6, 0x86, 0xe7, + 0x60, 0x20, 0xf8, 0xe6, 0xa5, 0xe8, 0x85, 0x1a, 0xa5, 0xe9, 0x85, 0x1b, + 0x8a, 0xa2, 0x00, 0xc1, 0x1a, 0xf0, 0x02, 0xb0, 0xa5, 0x0a, 0x90, 0x03, + 0xe6, 0x1b, 0x18, 0xa8, 0xb1, 0x1a, 0x65, 0x1a, 0xaa, 0xc8, 0xb1, 0x1a, + 0x65, 0xe9, 0x85, 0x1b, 0x86, 0x1a, 0x20, 0xb7, 0x00, 0xc9, 0xc5, 0xd0, + 0x09, 0x20, 0xc0, 0xde, 0x20, 0xb9, 0xf6, 0x20, 0x11, 0xf4, 0xa5, 0xf9, + 0x60, 0x20, 0x2d, 0xf7, 0x4c, 0x05, 0xf6, 0x20, 0x2d, 0xf7, 0x4c, 0x61, + 0xf6, 0x38, 0x90, 0x18, 0x8d, 0x07, 0xc0, 0x20, 0x00, 0xc5, 0x8d, 0x06, + 0xc0, 0xb0, 0x01, 0x60, 0x4c, 0x10, 0xd4, 0xbd, 0x01, 0x02, 0x10, 0x11, + 0xa5, 0x0e, 0xf0, 0x16, 0xc9, 0x22, 0xf0, 0x12, 0xa5, 0x13, 0xc9, 0x49, + 0xf0, 0x0c, 0xbd, 0x00, 0x02, 0x08, 0xc9, 0x61, 0x90, 0x02, 0x29, 0x5f, + 0x28, 0x60, 0xbd, 0x00, 0x02, 0x60, 0x48, 0xa9, 0x20, 0x20, 0x5c, 0xdb, + 0x68, 0x4c, 0x24, 0xed, 0xa5, 0x24, 0xc9, 0x21, 0x2c, 0x1f, 0xc0, 0x10, + 0x05, 0xad, 0x7b, 0x05, 0xc9, 0x49, 0x60, 0x8a, 0x2c, 0x1f, 0xc0, 0x30, + 0x08, 0x2c, 0x85, 0x24, 0x38, 0x8a, 0xe5, 0x24, 0x60, 0xed, 0x7b, 0x05, + 0x60, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x40, 0x85, 0x14, 0x20, 0xe3, 0xdf, + 0xa9, 0x00, 0x85, 0x14, 0x4c, 0xf0, 0xd8, 0x20, 0xf8, 0xe6, 0xca, 0xa9, + 0x28, 0xc5, 0x21, 0xb0, 0x02, 0xa5, 0x21, 0x20, 0xca, 0xf7, 0x86, 0x24, + 0x90, 0xd6, 0xaa, 0x20, 0xfb, 0xda, 0xd0, 0xeb, 0x4a, 0x08, 0x20, 0x47, + 0xf8, 0x28, 0xa9, 0x0f, 0x90, 0x02, 0x69, 0xe0, 0x85, 0x2e, 0xb1, 0x26, + 0x45, 0x30, 0x25, 0x2e, 0x51, 0x26, 0x91, 0x26, 0x60, 0x20, 0x00, 0xf8, + 0xc4, 0x2c, 0xb0, 0x11, 0xc8, 0x20, 0x0e, 0xf8, 0x90, 0xf6, 0x69, 0x01, + 0x48, 0x20, 0x00, 0xf8, 0x68, 0xc5, 0x2d, 0x90, 0xf5, 0x60, 0xa0, 0x2f, + 0xd0, 0x02, 0xa0, 0x27, 0x84, 0x2d, 0xa0, 0x27, 0xa9, 0x00, 0x85, 0x30, + 0x20, 0x28, 0xf8, 0x88, 0x10, 0xf6, 0x60, 0x48, 0x4a, 0x29, 0x03, 0x09, + 0x04, 0x85, 0x27, 0x68, 0x29, 0x18, 0x90, 0x02, 0x69, 0x7f, 0x85, 0x26, + 0x0a, 0x0a, 0x05, 0x26, 0x85, 0x26, 0x60, 0xa5, 0x30, 0x18, 0x69, 0x03, + 0x29, 0x0f, 0x85, 0x30, 0x0a, 0x0a, 0x0a, 0x0a, 0x05, 0x30, 0x85, 0x30, + 0x60, 0x4a, 0x08, 0x20, 0x47, 0xf8, 0xb1, 0x26, 0x28, 0x90, 0x04, 0x4a, + 0x4a, 0x4a, 0x4a, 0x29, 0x0f, 0x60, 0xa6, 0x3a, 0xa4, 0x3b, 0x20, 0x96, + 0xfd, 0x20, 0x48, 0xf9, 0xa1, 0x3a, 0xa8, 0x4a, 0x90, 0x09, 0x6a, 0xb0, + 0x10, 0xc9, 0xa2, 0xf0, 0x0c, 0x29, 0x87, 0x4a, 0xaa, 0xbd, 0x62, 0xf9, + 0x20, 0x79, 0xf8, 0xd0, 0x04, 0xa0, 0x80, 0xa9, 0x00, 0xaa, 0xbd, 0xa6, + 0xf9, 0x85, 0x2e, 0xaa, 0x84, 0x2a, 0xa0, 0x10, 0x4c, 0xb4, 0xfb, 0x8d, + 0x06, 0xc0, 0xa2, 0x02, 0xbd, 0x05, 0xc3, 0xdd, 0x9c, 0xfc, 0xd0, 0x07, + 0xca, 0xca, 0x10, 0xf4, 0x88, 0xd0, 0xef, 0x8d, 0x07, 0xc0, 0x60, 0x00, + 0x20, 0x82, 0xf8, 0x48, 0xb1, 0x3a, 0x20, 0xda, 0xfd, 0xa2, 0x01, 0x20, + 0x4a, 0xf9, 0xc4, 0x2f, 0xc8, 0x90, 0xf1, 0xa2, 0x03, 0xc0, 0x04, 0x90, + 0xf2, 0x68, 0xa8, 0xb9, 0xc0, 0xf9, 0x85, 0x2c, 0xb9, 0x00, 0xfa, 0x85, + 0x2d, 0xa9, 0x00, 0xa0, 0x05, 0x06, 0x2d, 0x26, 0x2c, 0x2a, 0x88, 0xd0, + 0xf8, 0x69, 0xbf, 0x20, 0xed, 0xfd, 0xca, 0xd0, 0xec, 0x20, 0x48, 0xf9, + 0xa4, 0x2f, 0xa2, 0x06, 0xe0, 0x03, 0xf0, 0x1c, 0x06, 0x2e, 0x90, 0x0e, + 0xbd, 0xb3, 0xf9, 0x20, 0xed, 0xfd, 0xbd, 0xb9, 0xf9, 0xf0, 0x03, 0x20, + 0xed, 0xfd, 0xca, 0xd0, 0xe7, 0x60, 0x88, 0x30, 0xe7, 0x20, 0xda, 0xfd, + 0xa5, 0x2e, 0xc9, 0xe8, 0xb1, 0x3a, 0x90, 0xf2, 0x20, 0x56, 0xf9, 0xaa, + 0xe8, 0xd0, 0x01, 0xc8, 0x98, 0x20, 0xda, 0xfd, 0x8a, 0x4c, 0xda, 0xfd, + 0xa2, 0x03, 0xa9, 0xa0, 0x20, 0xed, 0xfd, 0xca, 0xd0, 0xf8, 0x60, 0x38, + 0xa5, 0x2f, 0xa4, 0x3b, 0xaa, 0x10, 0x01, 0x88, 0x65, 0x3a, 0x90, 0x01, + 0xc8, 0x60, 0x04, 0x20, 0x54, 0x30, 0x0d, 0x80, 0x04, 0x90, 0x03, 0x22, + 0x54, 0x33, 0x0d, 0x80, 0x04, 0x90, 0x04, 0x20, 0x54, 0x33, 0x0d, 0x80, + 0x04, 0x90, 0x04, 0x20, 0x54, 0x3b, 0x0d, 0x80, 0x04, 0x90, 0x00, 0x22, + 0x44, 0x33, 0x0d, 0xc8, 0x44, 0x00, 0x11, 0x22, 0x44, 0x33, 0x0d, 0xc8, + 0x44, 0xa9, 0x01, 0x22, 0x44, 0x33, 0x0d, 0x80, 0x04, 0x90, 0x01, 0x22, + 0x44, 0x33, 0x0d, 0x80, 0x04, 0x90, 0x26, 0x31, 0x87, 0x9a, 0x00, 0x21, + 0x81, 0x82, 0x00, 0x00, 0x59, 0x4d, 0x91, 0x92, 0x86, 0x4a, 0x85, 0x9d, + 0xac, 0xa9, 0xac, 0xa3, 0xa8, 0xa4, 0xd9, 0x00, 0xd8, 0xa4, 0xa4, 0x00, + 0x1c, 0x8a, 0x1c, 0x23, 0x5d, 0x8b, 0x1b, 0xa1, 0x9d, 0x8a, 0x1d, 0x23, + 0x9d, 0x8b, 0x1d, 0xa1, 0x00, 0x29, 0x19, 0xae, 0x69, 0xa8, 0x19, 0x23, + 0x24, 0x53, 0x1b, 0x23, 0x24, 0x53, 0x19, 0xa1, 0x00, 0x1a, 0x5b, 0x5b, + 0xa5, 0x69, 0x24, 0x24, 0xae, 0xae, 0xa8, 0xad, 0x29, 0x00, 0x7c, 0x00, + 0x15, 0x9c, 0x6d, 0x9c, 0xa5, 0x69, 0x29, 0x53, 0x84, 0x13, 0x34, 0x11, + 0xa5, 0x69, 0x23, 0xa0, 0xd8, 0x62, 0x5a, 0x48, 0x26, 0x62, 0x94, 0x88, + 0x54, 0x44, 0xc8, 0x54, 0x68, 0x44, 0xe8, 0x94, 0x00, 0xb4, 0x08, 0x84, + 0x74, 0xb4, 0x28, 0x6e, 0x74, 0xf4, 0xcc, 0x4a, 0x72, 0xf2, 0xa4, 0x8a, + 0x00, 0xaa, 0xa2, 0xa2, 0x74, 0x74, 0x74, 0x72, 0x44, 0x68, 0xb2, 0x32, + 0xb2, 0x00, 0x22, 0x00, 0x1a, 0x1a, 0x26, 0x26, 0x72, 0x72, 0x88, 0xc8, + 0xc4, 0xca, 0x26, 0x48, 0x44, 0x44, 0xa2, 0xc8, 0x85, 0x45, 0xa5, 0x45, + 0x4c, 0xfa, 0xc3, 0x8d, 0x06, 0xc0, 0x85, 0x45, 0x28, 0x20, 0x4c, 0xff, + 0x68, 0x85, 0x3a, 0x68, 0x85, 0x3b, 0x6c, 0xf0, 0x03, 0x20, 0x82, 0xf8, + 0x20, 0xda, 0xfa, 0x4c, 0x65, 0xff, 0xd8, 0x20, 0x84, 0xfe, 0x20, 0x2f, + 0xfb, 0x20, 0x93, 0xfe, 0x20, 0x89, 0xfe, 0xad, 0x58, 0xc0, 0xad, 0x5a, + 0xc0, 0xa0, 0x09, 0x20, 0xb4, 0xfb, 0xea, 0xad, 0xff, 0xcf, 0x2c, 0x10, + 0xc0, 0xd8, 0x20, 0x3a, 0xff, 0xad, 0xf3, 0x03, 0x49, 0xa5, 0xcd, 0xf4, + 0x03, 0xd0, 0x17, 0xad, 0xf2, 0x03, 0xd0, 0x0f, 0xa9, 0xe0, 0xcd, 0xf3, + 0x03, 0xd0, 0x08, 0xa0, 0x03, 0x8c, 0xf2, 0x03, 0x4c, 0x00, 0xe0, 0x6c, + 0xf2, 0x03, 0x20, 0x60, 0xfb, 0xa2, 0x05, 0xbd, 0xfc, 0xfa, 0x9d, 0xef, + 0x03, 0xca, 0xd0, 0xf7, 0xa9, 0xc8, 0x86, 0x00, 0x85, 0x01, 0xa0, 0x05, + 0xc6, 0x01, 0xa5, 0x01, 0xc9, 0xc0, 0xf0, 0xd7, 0x8d, 0xf8, 0x07, 0xb1, + 0x00, 0xd9, 0x01, 0xfb, 0xd0, 0xec, 0x88, 0x88, 0x10, 0xf5, 0x6c, 0x00, + 0x00, 0x00, 0x00, 0x20, 0x8e, 0xfd, 0xa9, 0x45, 0x85, 0x40, 0xa9, 0x00, + 0x85, 0x41, 0xa2, 0xfb, 0xa9, 0xa0, 0x20, 0xed, 0xfd, 0xbd, 0x1e, 0xfa, + 0x20, 0xed, 0xfd, 0xa9, 0xbd, 0x20, 0xed, 0xfd, 0xb5, 0x4a, 0x20, 0xda, + 0xfd, 0xe8, 0x30, 0xe8, 0x60, 0x59, 0xfa, 0x00, 0xe0, 0x45, 0x20, 0xff, + 0x00, 0xff, 0x03, 0xff, 0x3c, 0xc1, 0xf0, 0xf0, 0xec, 0xe5, 0xa0, 0xdd, + 0xdb, 0xc4, 0xc2, 0xc1, 0xff, 0xc3, 0xff, 0xff, 0xff, 0xc1, 0xd8, 0xd9, + 0xd0, 0xd3, 0xad, 0x70, 0xc0, 0xa0, 0x00, 0xea, 0xea, 0xbd, 0x64, 0xc0, + 0x10, 0x04, 0xc8, 0xd0, 0xf8, 0x88, 0x60, 0xa9, 0x00, 0x85, 0x48, 0xad, + 0x56, 0xc0, 0xad, 0x54, 0xc0, 0xad, 0x51, 0xc0, 0xa9, 0x00, 0xf0, 0x0b, + 0xad, 0x50, 0xc0, 0xad, 0x53, 0xc0, 0x20, 0x36, 0xf8, 0xa9, 0x14, 0x85, + 0x22, 0xa9, 0x00, 0x85, 0x20, 0xa0, 0x0c, 0xd0, 0x5f, 0xa9, 0x18, 0x85, + 0x23, 0xa9, 0x17, 0x85, 0x25, 0x4c, 0x22, 0xfc, 0x20, 0x58, 0xfc, 0xa0, + 0x09, 0xb9, 0x09, 0xff, 0x99, 0x0e, 0x04, 0x88, 0xd0, 0xf7, 0x60, 0xad, + 0xf3, 0x03, 0x49, 0xa5, 0x8d, 0xf4, 0x03, 0x60, 0xc9, 0x8d, 0xd0, 0x18, + 0xac, 0x00, 0xc0, 0x10, 0x13, 0xc0, 0x93, 0xd0, 0x0f, 0x2c, 0x10, 0xc0, + 0xac, 0x00, 0xc0, 0x10, 0xfb, 0xc0, 0x83, 0xf0, 0x03, 0x2c, 0x10, 0xc0, + 0x4c, 0xfd, 0xfb, 0x38, 0x4c, 0x2c, 0xfc, 0xa8, 0xb9, 0x48, 0xfa, 0x20, + 0x97, 0xfb, 0x20, 0x21, 0xfd, 0xc9, 0xce, 0xb0, 0xee, 0xc9, 0xc9, 0x90, + 0xea, 0xc9, 0xcc, 0xf0, 0xe6, 0xd0, 0xe8, 0x06, 0x2c, 0x15, 0xc0, 0x08, + 0x8d, 0x07, 0xc0, 0x4c, 0x00, 0xc1, 0x00, 0x00, 0xe0, 0x48, 0x4a, 0x29, + 0x03, 0x09, 0x04, 0x85, 0x29, 0x68, 0x29, 0x18, 0x90, 0x02, 0x69, 0x7f, + 0x85, 0x28, 0x0a, 0x0a, 0x05, 0x28, 0x85, 0x28, 0x60, 0xc9, 0x87, 0xd0, + 0x12, 0xa9, 0x40, 0x20, 0xa8, 0xfc, 0xa0, 0xc0, 0xa9, 0x0c, 0x20, 0xa8, + 0xfc, 0xad, 0x30, 0xc0, 0x88, 0xd0, 0xf5, 0x60, 0xa4, 0x24, 0x91, 0x28, + 0xe6, 0x24, 0xa5, 0x24, 0xc5, 0x21, 0xb0, 0x66, 0x60, 0xc9, 0xa0, 0xb0, + 0xef, 0xa8, 0x10, 0xec, 0xc9, 0x8d, 0xf0, 0x5a, 0xc9, 0x8a, 0xf0, 0x5a, + 0xc9, 0x88, 0xd0, 0xc9, 0xc6, 0x24, 0x10, 0xe8, 0xa5, 0x21, 0x85, 0x24, + 0xc6, 0x24, 0xa5, 0x22, 0xc5, 0x25, 0xb0, 0xdc, 0xc6, 0x25, 0xa5, 0x25, + 0x85, 0x28, 0x98, 0xa0, 0x04, 0xd0, 0x89, 0x00, 0x49, 0xc0, 0xf0, 0x28, + 0x69, 0xfd, 0x90, 0xc0, 0xf0, 0xda, 0x69, 0xfd, 0x90, 0x2c, 0xf0, 0xde, + 0x69, 0xfd, 0x90, 0x5c, 0xd0, 0xba, 0xa0, 0x0a, 0xd0, 0xe3, 0x2c, 0x1f, + 0xc0, 0x10, 0x04, 0xa0, 0x00, 0xf0, 0x0b, 0x98, 0x48, 0x20, 0x78, 0xfb, + 0x68, 0xa4, 0x35, 0x60, 0xa0, 0x05, 0x4c, 0xb4, 0xfb, 0x53, 0x5c, 0x5c, + 0x00, 0x00, 0xa9, 0x00, 0x85, 0x24, 0xe6, 0x25, 0xa5, 0x25, 0xc5, 0x23, + 0x90, 0xb6, 0xc6, 0x25, 0xa0, 0x06, 0xd0, 0xb5, 0x8d, 0x06, 0xc0, 0x6c, + 0xfe, 0x03, 0x68, 0x8d, 0xf8, 0x07, 0xc9, 0xc1, 0x90, 0x0d, 0x8d, 0xff, + 0xcf, 0xa0, 0x00, 0xa6, 0x01, 0x85, 0x01, 0xb1, 0x00, 0x86, 0x01, 0x8d, + 0x07, 0xc0, 0x4c, 0x7c, 0xc4, 0x90, 0x02, 0x25, 0x32, 0x4c, 0xf7, 0xfd, + 0x38, 0x90, 0x18, 0x84, 0x2a, 0xa0, 0x07, 0xb0, 0x78, 0xc8, 0xd0, 0x75, + 0x38, 0x48, 0xe9, 0x01, 0xd0, 0xfc, 0x68, 0xe9, 0x01, 0xd0, 0xf6, 0x60, + 0xe6, 0x42, 0xd0, 0x02, 0xe6, 0x43, 0xa5, 0x3c, 0xc5, 0x3e, 0xa5, 0x3d, + 0xe5, 0x3f, 0xe6, 0x3c, 0xd0, 0x02, 0xe6, 0x3d, 0x60, 0x8d, 0x07, 0xc0, + 0x20, 0x67, 0xc5, 0x4c, 0xc5, 0xfe, 0x8d, 0x06, 0xc0, 0x20, 0x4a, 0xf9, + 0xa9, 0xde, 0x20, 0xed, 0xfd, 0x20, 0x3a, 0xff, 0x4c, 0xf0, 0xfc, 0x8d, + 0x06, 0xc0, 0x20, 0xd0, 0xf8, 0x20, 0x53, 0xf9, 0x84, 0x3b, 0x85, 0x3a, + 0xa9, 0xa1, 0x85, 0x33, 0x20, 0x67, 0xfd, 0x8d, 0x07, 0xc0, 0x4c, 0x9c, + 0xcf, 0xb9, 0x00, 0x02, 0xc8, 0xc9, 0xe1, 0x90, 0x06, 0xc9, 0xfb, 0xb0, + 0x02, 0x29, 0xdf, 0x60, 0xa0, 0x0b, 0xd0, 0x03, 0x4c, 0x18, 0xfd, 0x20, + 0xb4, 0xfb, 0xea, 0xea, 0x6c, 0x38, 0x00, 0xa0, 0x03, 0x4c, 0xb4, 0xfb, + 0xea, 0x20, 0x0c, 0xfd, 0xa0, 0x01, 0xd0, 0xf5, 0x4e, 0xf8, 0x07, 0x4c, + 0x0c, 0xfd, 0xea, 0x20, 0x21, 0xfd, 0x20, 0xa5, 0xfb, 0x20, 0x28, 0xfd, + 0xc9, 0x9b, 0xf0, 0xf3, 0x60, 0xa0, 0x0f, 0x20, 0xb4, 0xfb, 0xa4, 0x24, + 0x9d, 0x00, 0x02, 0x20, 0xed, 0xfd, 0xea, 0xea, 0xea, 0xbd, 0x00, 0x02, + 0xc9, 0x88, 0xf0, 0x1d, 0xc9, 0x98, 0xf0, 0x0a, 0xe0, 0xf8, 0x90, 0x03, + 0x20, 0x3a, 0xff, 0xe8, 0xd0, 0x13, 0xa9, 0xdc, 0x20, 0xed, 0xfd, 0x20, + 0x8e, 0xfd, 0xa5, 0x33, 0x20, 0xed, 0xfd, 0xa2, 0x01, 0x8a, 0xf0, 0xf3, + 0xca, 0x20, 0x35, 0xfd, 0xc9, 0x95, 0xd0, 0x08, 0xb1, 0x28, 0x2c, 0x1f, + 0xc0, 0x30, 0xba, 0xea, 0x9d, 0x00, 0x02, 0xc9, 0x8d, 0xd0, 0xbc, 0x20, + 0x9c, 0xfc, 0xa9, 0x8d, 0xd0, 0x5b, 0xa4, 0x3d, 0xa6, 0x3c, 0x20, 0x8e, + 0xfd, 0x20, 0x40, 0xf9, 0xa0, 0x00, 0xa9, 0xad, 0x4c, 0xed, 0xfd, 0xa5, + 0x3c, 0x09, 0x07, 0x85, 0x3e, 0xa5, 0x3d, 0x85, 0x3f, 0xa5, 0x3c, 0x29, + 0x07, 0xd0, 0x03, 0x20, 0x92, 0xfd, 0xa9, 0xa0, 0x20, 0xed, 0xfd, 0xb1, + 0x3c, 0x20, 0xda, 0xfd, 0x20, 0xba, 0xfc, 0x90, 0xe8, 0x60, 0x4a, 0x90, + 0xea, 0x4a, 0x4a, 0xa5, 0x3e, 0x90, 0x02, 0x49, 0xff, 0x65, 0x3c, 0x48, + 0xa9, 0xbd, 0x20, 0xed, 0xfd, 0x68, 0x48, 0x4a, 0x4a, 0x4a, 0x4a, 0x20, + 0xe5, 0xfd, 0x68, 0x29, 0x0f, 0x09, 0xb0, 0xc9, 0xba, 0x90, 0x02, 0x69, + 0x06, 0x6c, 0x36, 0x00, 0x48, 0xc9, 0xa0, 0x4c, 0x95, 0xfc, 0x48, 0x84, + 0x35, 0xa8, 0x68, 0x4c, 0x46, 0xfc, 0xea, 0xea, 0xc6, 0x34, 0xf0, 0x9f, + 0xca, 0xd0, 0x16, 0xc9, 0xba, 0xd0, 0xbb, 0x85, 0x31, 0xa5, 0x3e, 0x91, + 0x40, 0xe6, 0x40, 0xd0, 0x02, 0xe6, 0x41, 0x60, 0xa4, 0x34, 0xb9, 0xff, + 0x01, 0x85, 0x31, 0x60, 0xa2, 0x01, 0xb5, 0x3e, 0x95, 0x42, 0x95, 0x44, + 0xca, 0x10, 0xf7, 0x60, 0xb1, 0x3c, 0x91, 0x42, 0x20, 0xb4, 0xfc, 0x90, + 0xf7, 0x60, 0xb1, 0x3c, 0xd1, 0x42, 0xf0, 0x1c, 0x20, 0x92, 0xfd, 0xb1, + 0x3c, 0x20, 0xda, 0xfd, 0xa9, 0xa0, 0x20, 0xed, 0xfd, 0xa9, 0xa8, 0x20, + 0xed, 0xfd, 0xb1, 0x42, 0x20, 0xda, 0xfd, 0xa9, 0xa9, 0x20, 0xed, 0xfd, + 0x20, 0xb4, 0xfc, 0x90, 0xd9, 0x60, 0x20, 0x75, 0xfe, 0xa9, 0x14, 0x48, + 0x20, 0xd0, 0xf8, 0x20, 0x53, 0xf9, 0x85, 0x3a, 0x84, 0x3b, 0x68, 0x38, + 0xe9, 0x01, 0xd0, 0xef, 0x60, 0x8a, 0xf0, 0x07, 0xb5, 0x3c, 0x95, 0x3a, + 0xca, 0x10, 0xf9, 0x60, 0xa0, 0x3f, 0xd0, 0x02, 0xa0, 0xff, 0x84, 0x32, + 0x60, 0xa9, 0x00, 0x85, 0x3e, 0xa2, 0x38, 0xa0, 0x1b, 0xd0, 0x08, 0xa9, + 0x00, 0x85, 0x3e, 0xa2, 0x36, 0xa0, 0xf0, 0xa5, 0x3e, 0x29, 0x0f, 0xf0, + 0x04, 0x09, 0xc0, 0xa0, 0x00, 0x94, 0x00, 0x95, 0x01, 0xa0, 0x0e, 0x4c, + 0xb4, 0xfb, 0xea, 0x00, 0x4c, 0x00, 0xe0, 0x4c, 0x03, 0xe0, 0x20, 0x75, + 0xfe, 0x20, 0x3f, 0xff, 0x6c, 0x3a, 0x00, 0x4c, 0xd7, 0xfa, 0x60, 0xea, + 0x60, 0x8d, 0x06, 0xc0, 0x60, 0xea, 0x4c, 0xf8, 0x03, 0xa9, 0x40, 0x8d, + 0x07, 0xc0, 0x20, 0xaa, 0xc5, 0xf0, 0x2c, 0xa0, 0x01, 0xa5, 0x43, 0xf0, + 0x04, 0xd1, 0x3c, 0xd0, 0x0a, 0x88, 0xa5, 0x42, 0xd1, 0x3c, 0xd0, 0x03, + 0x20, 0x92, 0xfd, 0x20, 0xba, 0xfc, 0x90, 0xe7, 0x60, 0xa0, 0x0d, 0x20, + 0xb4, 0xfb, 0x20, 0x00, 0xfe, 0x68, 0x68, 0xd0, 0x6c, 0x8d, 0x07, 0xc0, + 0x20, 0xd1, 0xc5, 0x8d, 0x06, 0xc0, 0xf0, 0x32, 0xd0, 0x23, 0xc1, 0xf0, + 0xf0, 0xec, 0xe5, 0xa0, 0xaf, 0xaf, 0xe5, 0x20, 0xfd, 0xfc, 0xc9, 0xa0, + 0xf0, 0xf9, 0x60, 0xb0, 0x6d, 0xc9, 0xa0, 0xd0, 0x28, 0xb9, 0x00, 0x02, + 0xa2, 0x07, 0xc9, 0x8d, 0xf0, 0x7d, 0xc8, 0xd0, 0x63, 0xa9, 0xc5, 0x20, + 0xed, 0xfd, 0xa9, 0xd2, 0x20, 0xed, 0xfd, 0x20, 0xed, 0xfd, 0xa9, 0x87, + 0x4c, 0xed, 0xfd, 0xa5, 0x48, 0x48, 0xa5, 0x45, 0xa6, 0x46, 0xa4, 0x47, + 0x28, 0x60, 0x85, 0x45, 0x86, 0x46, 0x84, 0x47, 0x08, 0x68, 0x85, 0x48, + 0xba, 0x86, 0x49, 0xd8, 0x60, 0x20, 0x84, 0xfe, 0x20, 0x2f, 0xfb, 0x20, + 0x93, 0xfe, 0x20, 0x89, 0xfe, 0xd8, 0x20, 0x3a, 0xff, 0xa9, 0xaa, 0x85, + 0x33, 0x20, 0x67, 0xfd, 0x20, 0xc7, 0xff, 0x20, 0xa7, 0xff, 0x84, 0x34, + 0xa0, 0x17, 0x88, 0x30, 0xe8, 0xd9, 0xcc, 0xff, 0xd0, 0xf8, 0x20, 0xbe, + 0xff, 0xa4, 0x34, 0x4c, 0x73, 0xff, 0xa2, 0x03, 0x0a, 0x0a, 0x0a, 0x0a, + 0x0a, 0x26, 0x3e, 0x26, 0x3f, 0xca, 0x10, 0xf8, 0xa5, 0x31, 0xd0, 0x06, + 0xb5, 0x3f, 0x95, 0x3d, 0x95, 0x41, 0xe8, 0xf0, 0xf3, 0xd0, 0x06, 0xa2, + 0x00, 0x86, 0x3e, 0x86, 0x3f, 0x20, 0xfd, 0xfc, 0xea, 0x49, 0xb0, 0xc9, + 0x0a, 0x90, 0xd3, 0x69, 0x88, 0xc9, 0xfa, 0x4c, 0x1b, 0xff, 0xa9, 0xfe, + 0x48, 0xb9, 0xe3, 0xff, 0x48, 0xa5, 0x31, 0xa0, 0x00, 0x84, 0x31, 0x60, + 0xbc, 0xb2, 0xbe, 0x9a, 0xef, 0xc4, 0xec, 0xa9, 0xbb, 0xa6, 0xa4, 0x06, + 0x95, 0x07, 0x02, 0x05, 0xf0, 0x00, 0xeb, 0x93, 0xa7, 0xc6, 0x99, 0xb2, + 0xc9, 0xbe, 0xf0, 0x35, 0x8c, 0xd6, 0x96, 0xaf, 0x17, 0x17, 0x2b, 0x1f, + 0x83, 0x7f, 0x5d, 0xcc, 0xb5, 0xfc, 0x17, 0x17, 0xf5, 0x03, 0xfb, 0x03, + 0x62, 0xfa, 0xfa, 0xc3 +}; +static const unsigned int iie_enhanced_rom_bin_len = 16384; diff --git a/src/roms/mii_rom_iiee_video.h b/src/roms/mii_rom_iiee_video.h new file mode 100644 index 0000000..f47de65 --- /dev/null +++ b/src/roms/mii_rom_iiee_video.h @@ -0,0 +1,346 @@ +#pragma once +static const unsigned char iie_enhanced_video[] = { + 0x1c, 0x22, 0x2a, 0x3a, 0x1a, 0x02, 0x3c, 0x00, 0x08, 0x14, 0x22, 0x22, + 0x3e, 0x22, 0x22, 0x00, 0x1e, 0x22, 0x22, 0x1e, 0x22, 0x22, 0x1e, 0x00, + 0x1c, 0x22, 0x02, 0x02, 0x02, 0x22, 0x1c, 0x00, 0x1e, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x1e, 0x00, 0x3e, 0x02, 0x02, 0x1e, 0x02, 0x02, 0x3e, 0x00, + 0x3e, 0x02, 0x02, 0x1e, 0x02, 0x02, 0x02, 0x00, 0x3c, 0x02, 0x02, 0x02, + 0x32, 0x22, 0x3c, 0x00, 0x22, 0x22, 0x22, 0x3e, 0x22, 0x22, 0x22, 0x00, + 0x1c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x22, 0x1c, 0x00, 0x22, 0x12, 0x0a, 0x06, 0x0a, 0x12, 0x22, 0x00, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x3e, 0x00, 0x22, 0x36, 0x2a, 0x2a, + 0x22, 0x22, 0x22, 0x00, 0x22, 0x22, 0x26, 0x2a, 0x32, 0x22, 0x22, 0x00, + 0x1c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00, 0x1e, 0x22, 0x22, 0x1e, + 0x02, 0x02, 0x02, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x2a, 0x12, 0x2c, 0x00, + 0x1e, 0x22, 0x22, 0x1e, 0x0a, 0x12, 0x22, 0x00, 0x1c, 0x22, 0x02, 0x1c, + 0x20, 0x22, 0x1c, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x14, 0x08, 0x00, 0x22, 0x22, 0x22, 0x2a, 0x2a, 0x36, 0x22, 0x00, + 0x22, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00, 0x22, 0x22, 0x14, 0x08, + 0x08, 0x08, 0x08, 0x00, 0x3e, 0x20, 0x10, 0x08, 0x04, 0x02, 0x3e, 0x00, + 0x3e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x3e, 0x00, 0x00, 0x02, 0x04, 0x08, + 0x10, 0x20, 0x00, 0x00, 0x3e, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3e, 0x00, + 0x00, 0x00, 0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x14, 0x14, 0x14, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x14, 0x14, 0x3e, 0x14, 0x3e, 0x14, 0x14, 0x00, + 0x08, 0x3c, 0x0a, 0x1c, 0x28, 0x1e, 0x08, 0x00, 0x06, 0x26, 0x10, 0x08, + 0x04, 0x32, 0x30, 0x00, 0x04, 0x0a, 0x0a, 0x04, 0x2a, 0x12, 0x2c, 0x00, + 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x02, 0x02, + 0x02, 0x04, 0x08, 0x00, 0x08, 0x10, 0x20, 0x20, 0x20, 0x10, 0x08, 0x00, + 0x08, 0x2a, 0x1c, 0x08, 0x1c, 0x2a, 0x08, 0x00, 0x00, 0x08, 0x08, 0x3e, + 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x04, 0x00, + 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00, + 0x1c, 0x22, 0x32, 0x2a, 0x26, 0x22, 0x1c, 0x00, 0x08, 0x0c, 0x08, 0x08, + 0x08, 0x08, 0x1c, 0x00, 0x1c, 0x22, 0x20, 0x18, 0x04, 0x02, 0x3e, 0x00, + 0x3e, 0x20, 0x10, 0x18, 0x20, 0x22, 0x1c, 0x00, 0x10, 0x18, 0x14, 0x12, + 0x3e, 0x10, 0x10, 0x00, 0x3e, 0x02, 0x1e, 0x20, 0x20, 0x22, 0x1c, 0x00, + 0x38, 0x04, 0x02, 0x1e, 0x22, 0x22, 0x1c, 0x00, 0x3e, 0x20, 0x10, 0x08, + 0x04, 0x04, 0x04, 0x00, 0x1c, 0x22, 0x22, 0x1c, 0x22, 0x22, 0x1c, 0x00, + 0x1c, 0x22, 0x22, 0x3c, 0x20, 0x10, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x08, 0x04, 0x00, + 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00, 0x00, 0x3e, 0x00, + 0x3e, 0x00, 0x00, 0x00, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x00, + 0x1c, 0x22, 0x10, 0x08, 0x08, 0x00, 0x08, 0x00, 0xef, 0xf7, 0xc9, 0x80, + 0xc0, 0xc0, 0x81, 0xc9, 0xef, 0xf7, 0xc9, 0xbe, 0xde, 0xde, 0xb5, 0xc9, + 0xff, 0xff, 0xfd, 0xf9, 0xf1, 0xe1, 0xc9, 0xbd, 0x80, 0xdd, 0xeb, 0xf7, + 0xf7, 0xeb, 0xd5, 0x80, 0xff, 0xbf, 0xdf, 0xee, 0xf5, 0xfb, 0xfb, 0xff, + 0x80, 0xc0, 0xa0, 0x93, 0x8a, 0x84, 0x84, 0x80, 0x8f, 0x9f, 0x81, 0xce, + 0x86, 0xcf, 0xc0, 0xfd, 0xff, 0xe7, 0xf8, 0xff, 0xf8, 0xf3, 0xf7, 0x8f, + 0xf7, 0xfb, 0xfd, 0x80, 0xfd, 0xfb, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd5, 0xf7, 0xf7, 0xf7, 0xf7, 0xb6, 0xd5, 0xe3, 0xf7, + 0xf7, 0xe3, 0xd5, 0xb6, 0xf7, 0xf7, 0xf7, 0xf7, 0x80, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbf, 0xbf, 0xbf, 0xbb, 0xb9, 0x80, 0xf9, 0xfb, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xec, 0xe7, 0xe3, 0x81, + 0xe3, 0xe7, 0xef, 0x90, 0x9b, 0xf3, 0xe3, 0xc0, 0xe3, 0xf3, 0xfb, 0x84, + 0xbf, 0xb7, 0xf7, 0x80, 0xc1, 0xe3, 0xb7, 0xbf, 0xbf, 0xb7, 0xe3, 0xc1, + 0x80, 0xf7, 0xb7, 0xbf, 0xff, 0xff, 0xff, 0x80, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x80, 0xf7, 0xef, 0xdf, 0x80, + 0xdf, 0xef, 0xf7, 0xff, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, + 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xff, 0xc1, 0xbe, 0xfe, + 0xfe, 0xfe, 0x80, 0xff, 0xff, 0xff, 0xc0, 0xbf, 0xbf, 0xbf, 0x80, 0xff, + 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xf7, 0xe3, 0xc1, 0x80, + 0xc1, 0xe3, 0xf7, 0xff, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xeb, 0xeb, 0x88, 0xff, 0x88, 0xeb, 0xeb, 0xff, 0x80, 0xbf, 0xbf, 0xb3, + 0xb3, 0xbf, 0xbf, 0x80, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0x04, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, + 0x3c, 0x22, 0x3c, 0x00, 0x02, 0x02, 0x1e, 0x22, 0x22, 0x22, 0x1e, 0x00, + 0x00, 0x00, 0x3c, 0x02, 0x02, 0x02, 0x3c, 0x00, 0x20, 0x20, 0x3c, 0x22, + 0x22, 0x22, 0x3c, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x3e, 0x02, 0x3c, 0x00, + 0x18, 0x24, 0x04, 0x1e, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x1c, 0x22, + 0x22, 0x3c, 0x20, 0x1c, 0x02, 0x02, 0x1e, 0x22, 0x22, 0x22, 0x22, 0x00, + 0x08, 0x00, 0x0c, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x10, 0x00, 0x18, 0x10, + 0x10, 0x10, 0x12, 0x0c, 0x02, 0x02, 0x22, 0x12, 0x0e, 0x12, 0x22, 0x00, + 0x0c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x00, 0x00, 0x36, 0x2a, + 0x2a, 0x2a, 0x22, 0x00, 0x00, 0x00, 0x1e, 0x22, 0x22, 0x22, 0x22, 0x00, + 0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x1e, 0x22, + 0x22, 0x1e, 0x02, 0x02, 0x00, 0x00, 0x3c, 0x22, 0x22, 0x3c, 0x20, 0x20, + 0x00, 0x00, 0x3a, 0x06, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x02, + 0x1c, 0x20, 0x1e, 0x00, 0x04, 0x04, 0x1e, 0x04, 0x04, 0x24, 0x18, 0x00, + 0x00, 0x00, 0x22, 0x22, 0x22, 0x32, 0x2c, 0x00, 0x00, 0x00, 0x22, 0x22, + 0x22, 0x14, 0x08, 0x00, 0x00, 0x00, 0x22, 0x22, 0x2a, 0x2a, 0x36, 0x00, + 0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x22, 0x22, + 0x22, 0x3c, 0x20, 0x1c, 0x00, 0x00, 0x3e, 0x10, 0x08, 0x04, 0x3e, 0x00, + 0x38, 0x0c, 0x0c, 0x06, 0x0c, 0x0c, 0x38, 0x00, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x0e, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0e, 0x00, + 0x2c, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x14, 0x2a, + 0x14, 0x2a, 0x00, 0x00, 0xe3, 0xdd, 0xd5, 0xc5, 0xe5, 0xfd, 0xc3, 0xff, + 0xf7, 0xeb, 0xdd, 0xdd, 0xc1, 0xdd, 0xdd, 0xff, 0xe1, 0xdd, 0xdd, 0xe1, + 0xdd, 0xdd, 0xe1, 0xff, 0xe3, 0xdd, 0xfd, 0xfd, 0xfd, 0xdd, 0xe3, 0xff, + 0xe1, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xe1, 0xff, 0xc1, 0xfd, 0xfd, 0xe1, + 0xfd, 0xfd, 0xc1, 0xff, 0xc1, 0xfd, 0xfd, 0xe1, 0xfd, 0xfd, 0xfd, 0xff, + 0xc3, 0xfd, 0xfd, 0xfd, 0xcd, 0xdd, 0xc3, 0xff, 0xdd, 0xdd, 0xdd, 0xc1, + 0xdd, 0xdd, 0xdd, 0xff, 0xe3, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xe3, 0xff, + 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdd, 0xe3, 0xff, 0xdd, 0xed, 0xf5, 0xf9, + 0xf5, 0xed, 0xdd, 0xff, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xc1, 0xff, + 0xdd, 0xc9, 0xd5, 0xd5, 0xdd, 0xdd, 0xdd, 0xff, 0xdd, 0xdd, 0xd9, 0xd5, + 0xcd, 0xdd, 0xdd, 0xff, 0xe3, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xe3, 0xff, + 0xe1, 0xdd, 0xdd, 0xe1, 0xfd, 0xfd, 0xfd, 0xff, 0xe3, 0xdd, 0xdd, 0xdd, + 0xd5, 0xed, 0xd3, 0xff, 0xe1, 0xdd, 0xdd, 0xe1, 0xf5, 0xed, 0xdd, 0xff, + 0xe3, 0xdd, 0xfd, 0xe3, 0xdf, 0xdd, 0xe3, 0xff, 0xc1, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xe3, 0xff, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xeb, 0xf7, 0xff, 0xdd, 0xdd, 0xdd, 0xd5, + 0xd5, 0xc9, 0xdd, 0xff, 0xdd, 0xdd, 0xeb, 0xf7, 0xeb, 0xdd, 0xdd, 0xff, + 0xdd, 0xdd, 0xeb, 0xf7, 0xf7, 0xf7, 0xf7, 0xff, 0xc1, 0xdf, 0xef, 0xf7, + 0xfb, 0xfd, 0xc1, 0xff, 0xc1, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xc1, 0xff, + 0xff, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xff, 0xff, 0xc1, 0xcf, 0xcf, 0xcf, + 0xcf, 0xcf, 0xc1, 0xff, 0xff, 0xff, 0xf7, 0xeb, 0xdd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xff, 0xf7, 0xff, + 0xeb, 0xeb, 0xeb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xeb, 0xeb, 0xc1, 0xeb, + 0xc1, 0xeb, 0xeb, 0xff, 0xf7, 0xc3, 0xf5, 0xe3, 0xd7, 0xe1, 0xf7, 0xff, + 0xf9, 0xd9, 0xef, 0xf7, 0xfb, 0xcd, 0xcf, 0xff, 0xfb, 0xf5, 0xf5, 0xfb, + 0xd5, 0xed, 0xd3, 0xff, 0xf7, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xfb, 0xfd, 0xfd, 0xfd, 0xfb, 0xf7, 0xff, 0xf7, 0xef, 0xdf, 0xdf, + 0xdf, 0xef, 0xf7, 0xff, 0xf7, 0xd5, 0xe3, 0xf7, 0xe3, 0xd5, 0xf7, 0xff, + 0xff, 0xf7, 0xf7, 0xc1, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xf7, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xdf, 0xef, 0xf7, + 0xfb, 0xfd, 0xff, 0xff, 0xe3, 0xdd, 0xcd, 0xd5, 0xd9, 0xdd, 0xe3, 0xff, + 0xf7, 0xf3, 0xf7, 0xf7, 0xf7, 0xf7, 0xe3, 0xff, 0xe3, 0xdd, 0xdf, 0xe7, + 0xfb, 0xfd, 0xc1, 0xff, 0xc1, 0xdf, 0xef, 0xe7, 0xdf, 0xdd, 0xe3, 0xff, + 0xef, 0xe7, 0xeb, 0xed, 0xc1, 0xef, 0xef, 0xff, 0xc1, 0xfd, 0xe1, 0xdf, + 0xdf, 0xdd, 0xe3, 0xff, 0xc7, 0xfb, 0xfd, 0xe1, 0xdd, 0xdd, 0xe3, 0xff, + 0xc1, 0xdf, 0xef, 0xf7, 0xfb, 0xfb, 0xfb, 0xff, 0xe3, 0xdd, 0xdd, 0xe3, + 0xdd, 0xdd, 0xe3, 0xff, 0xe3, 0xdd, 0xdd, 0xc3, 0xdf, 0xef, 0xf1, 0xff, + 0xff, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, + 0xf7, 0xf7, 0xfb, 0xff, 0xef, 0xf7, 0xfb, 0xfd, 0xfb, 0xf7, 0xef, 0xff, + 0xff, 0xff, 0xc1, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xef, 0xdf, + 0xef, 0xf7, 0xfb, 0xff, 0xe3, 0xdd, 0xef, 0xf7, 0xf7, 0xff, 0xf7, 0xff, + 0xe3, 0xdd, 0xd5, 0xc5, 0xe5, 0xfd, 0xc3, 0xff, 0xf7, 0xeb, 0xdd, 0xdd, + 0xc1, 0xdd, 0xdd, 0xff, 0xe1, 0xdd, 0xdd, 0xe1, 0xdd, 0xdd, 0xe1, 0xff, + 0xe3, 0xdd, 0xfd, 0xfd, 0xfd, 0xdd, 0xe3, 0xff, 0xe1, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xe1, 0xff, 0xc1, 0xfd, 0xfd, 0xe1, 0xfd, 0xfd, 0xc1, 0xff, + 0xc1, 0xfd, 0xfd, 0xe1, 0xfd, 0xfd, 0xfd, 0xff, 0xc3, 0xfd, 0xfd, 0xfd, + 0xcd, 0xdd, 0xc3, 0xff, 0xdd, 0xdd, 0xdd, 0xc1, 0xdd, 0xdd, 0xdd, 0xff, + 0xe3, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xe3, 0xff, 0xdf, 0xdf, 0xdf, 0xdf, + 0xdf, 0xdd, 0xe3, 0xff, 0xdd, 0xed, 0xf5, 0xf9, 0xf5, 0xed, 0xdd, 0xff, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xc1, 0xff, 0xdd, 0xc9, 0xd5, 0xd5, + 0xdd, 0xdd, 0xdd, 0xff, 0xdd, 0xdd, 0xd9, 0xd5, 0xcd, 0xdd, 0xdd, 0xff, + 0xe3, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xe3, 0xff, 0xe1, 0xdd, 0xdd, 0xe1, + 0xfd, 0xfd, 0xfd, 0xff, 0xe3, 0xdd, 0xdd, 0xdd, 0xd5, 0xed, 0xd3, 0xff, + 0xe1, 0xdd, 0xdd, 0xe1, 0xf5, 0xed, 0xdd, 0xff, 0xe3, 0xdd, 0xfd, 0xe3, + 0xdf, 0xdd, 0xe3, 0xff, 0xc1, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xff, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xe3, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xeb, 0xf7, 0xff, 0xdd, 0xdd, 0xdd, 0xd5, 0xd5, 0xc9, 0xdd, 0xff, + 0xdd, 0xdd, 0xeb, 0xf7, 0xeb, 0xdd, 0xdd, 0xff, 0xdd, 0xdd, 0xeb, 0xf7, + 0xf7, 0xf7, 0xf7, 0xff, 0xc1, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xc1, 0xff, + 0xc1, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xc1, 0xff, 0xff, 0xfd, 0xfb, 0xf7, + 0xef, 0xdf, 0xff, 0xff, 0xc1, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xc1, 0xff, + 0xff, 0xff, 0xf7, 0xeb, 0xdd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0xfb, 0xf7, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0xdf, 0xc3, 0xdd, 0xc3, 0xff, 0xfd, 0xfd, 0xe1, 0xdd, + 0xdd, 0xdd, 0xe1, 0xff, 0xff, 0xff, 0xc3, 0xfd, 0xfd, 0xfd, 0xc3, 0xff, + 0xdf, 0xdf, 0xc3, 0xdd, 0xdd, 0xdd, 0xc3, 0xff, 0xff, 0xff, 0xe3, 0xdd, + 0xc1, 0xfd, 0xc3, 0xff, 0xe7, 0xdb, 0xfb, 0xe1, 0xfb, 0xfb, 0xfb, 0xff, + 0xff, 0xff, 0xe3, 0xdd, 0xdd, 0xc3, 0xdf, 0xe3, 0xfd, 0xfd, 0xe1, 0xdd, + 0xdd, 0xdd, 0xdd, 0xff, 0xf7, 0xff, 0xf3, 0xf7, 0xf7, 0xf7, 0xe3, 0xff, + 0xef, 0xff, 0xe7, 0xef, 0xef, 0xef, 0xed, 0xf3, 0xfd, 0xfd, 0xdd, 0xed, + 0xf1, 0xed, 0xdd, 0xff, 0xf3, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xe3, 0xff, + 0xff, 0xff, 0xc9, 0xd5, 0xd5, 0xd5, 0xdd, 0xff, 0xff, 0xff, 0xe1, 0xdd, + 0xdd, 0xdd, 0xdd, 0xff, 0xff, 0xff, 0xe3, 0xdd, 0xdd, 0xdd, 0xe3, 0xff, + 0xff, 0xff, 0xe1, 0xdd, 0xdd, 0xe1, 0xfd, 0xfd, 0xff, 0xff, 0xc3, 0xdd, + 0xdd, 0xc3, 0xdf, 0xdf, 0xff, 0xff, 0xc5, 0xf9, 0xfd, 0xfd, 0xfd, 0xff, + 0xff, 0xff, 0xc3, 0xfd, 0xe3, 0xdf, 0xe1, 0xff, 0xfb, 0xfb, 0xe1, 0xfb, + 0xfb, 0xdb, 0xe7, 0xff, 0xff, 0xff, 0xdd, 0xdd, 0xdd, 0xcd, 0xd3, 0xff, + 0xff, 0xff, 0xdd, 0xdd, 0xdd, 0xeb, 0xf7, 0xff, 0xff, 0xff, 0xdd, 0xdd, + 0xd5, 0xd5, 0xc9, 0xff, 0xff, 0xff, 0xdd, 0xeb, 0xf7, 0xeb, 0xdd, 0xff, + 0xff, 0xff, 0xdd, 0xdd, 0xdd, 0xc3, 0xdf, 0xe3, 0xff, 0xff, 0xc1, 0xef, + 0xf7, 0xfb, 0xc1, 0xff, 0xc7, 0xf3, 0xf3, 0xf9, 0xf3, 0xf3, 0xc7, 0xff, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf1, 0xe7, 0xe7, 0xcf, + 0xe7, 0xe7, 0xf1, 0xff, 0xd3, 0xe5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0xeb, 0xd5, 0xeb, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xee, 0xbb, 0xfe, 0xfe, 0xff, 0xff, + 0xfd, 0xfd, 0xdd, 0x77, 0xfd, 0xfd, 0xff, 0xff, 0xfc, 0xfc, 0xcc, 0x33, + 0xfc, 0xfc, 0xff, 0xff, 0xfb, 0xfb, 0xbb, 0xee, 0xfb, 0xfb, 0xff, 0xff, + 0xfa, 0xfa, 0xaa, 0xaa, 0xfa, 0xfa, 0xff, 0xff, 0xf9, 0xf9, 0x99, 0x66, + 0xf9, 0xf9, 0xff, 0xff, 0xf8, 0xf8, 0x88, 0x22, 0xf8, 0xf8, 0xff, 0xff, + 0xf7, 0xf7, 0x77, 0xdd, 0xf7, 0xf7, 0xff, 0xff, 0xf6, 0xf6, 0x66, 0x99, + 0xf6, 0xf6, 0xff, 0xff, 0xf5, 0xf5, 0x55, 0x55, 0xf5, 0xf5, 0xff, 0xff, + 0xf4, 0xf4, 0x44, 0x11, 0xf4, 0xf4, 0xff, 0xff, 0xf3, 0xf3, 0x33, 0xcc, + 0xf3, 0xf3, 0xff, 0xff, 0xf2, 0xf2, 0x22, 0x88, 0xf2, 0xf2, 0xff, 0xff, + 0xf1, 0xf1, 0x11, 0x44, 0xf1, 0xf1, 0xff, 0xff, 0xf0, 0xf0, 0x00, 0x00, + 0xf0, 0xf0, 0xff, 0xff, 0xef, 0xef, 0xff, 0xff, 0xef, 0xef, 0xee, 0xbb, + 0xee, 0xee, 0xee, 0xbb, 0xee, 0xee, 0xee, 0xbb, 0xed, 0xed, 0xdd, 0x77, + 0xed, 0xed, 0xee, 0xbb, 0xec, 0xec, 0xcc, 0x33, 0xec, 0xec, 0xee, 0xbb, + 0xeb, 0xeb, 0xbb, 0xee, 0xeb, 0xeb, 0xee, 0xbb, 0xea, 0xea, 0xaa, 0xaa, + 0xea, 0xea, 0xee, 0xbb, 0xe9, 0xe9, 0x99, 0x66, 0xe9, 0xe9, 0xee, 0xbb, + 0xe8, 0xe8, 0x88, 0x22, 0xe8, 0xe8, 0xee, 0xbb, 0xe7, 0xe7, 0x77, 0xdd, + 0xe7, 0xe7, 0xee, 0xbb, 0xe6, 0xe6, 0x66, 0x99, 0xe6, 0xe6, 0xee, 0xbb, + 0xe5, 0xe5, 0x55, 0x55, 0xe5, 0xe5, 0xee, 0xbb, 0xe4, 0xe4, 0x44, 0x11, + 0xe4, 0xe4, 0xee, 0xbb, 0xe3, 0xe3, 0x33, 0xcc, 0xe3, 0xe3, 0xee, 0xbb, + 0xe2, 0xe2, 0x22, 0x88, 0xe2, 0xe2, 0xee, 0xbb, 0xe1, 0xe1, 0x11, 0x44, + 0xe1, 0xe1, 0xee, 0xbb, 0xe0, 0xe0, 0x00, 0x00, 0xe0, 0xe0, 0xee, 0xbb, + 0xdf, 0xdf, 0xff, 0xff, 0xdf, 0xdf, 0xdd, 0x77, 0xde, 0xde, 0xee, 0xbb, + 0xde, 0xde, 0xdd, 0x77, 0xdd, 0xdd, 0xdd, 0x77, 0xdd, 0xdd, 0xdd, 0x77, + 0xdc, 0xdc, 0xcc, 0x33, 0xdc, 0xdc, 0xdd, 0x77, 0xdb, 0xdb, 0xbb, 0xee, + 0xdb, 0xdb, 0xdd, 0x77, 0xda, 0xda, 0xaa, 0xaa, 0xda, 0xda, 0xdd, 0x77, + 0xd9, 0xd9, 0x99, 0x66, 0xd9, 0xd9, 0xdd, 0x77, 0xd8, 0xd8, 0x88, 0x22, + 0xd8, 0xd8, 0xdd, 0x77, 0xd7, 0xd7, 0x77, 0xdd, 0xd7, 0xd7, 0xdd, 0x77, + 0xd6, 0xd6, 0x66, 0x99, 0xd6, 0xd6, 0xdd, 0x77, 0xd5, 0xd5, 0x55, 0x55, + 0xd5, 0xd5, 0xdd, 0x77, 0xd4, 0xd4, 0x44, 0x11, 0xd4, 0xd4, 0xdd, 0x77, + 0xd3, 0xd3, 0x33, 0xcc, 0xd3, 0xd3, 0xdd, 0x77, 0xd2, 0xd2, 0x22, 0x88, + 0xd2, 0xd2, 0xdd, 0x77, 0xd1, 0xd1, 0x11, 0x44, 0xd1, 0xd1, 0xdd, 0x77, + 0xd0, 0xd0, 0x00, 0x00, 0xd0, 0xd0, 0xdd, 0x77, 0xcf, 0xcf, 0xff, 0xff, + 0xcf, 0xcf, 0xcc, 0x33, 0xce, 0xce, 0xee, 0xbb, 0xce, 0xce, 0xcc, 0x33, + 0xcd, 0xcd, 0xdd, 0x77, 0xcd, 0xcd, 0xcc, 0x33, 0xcc, 0xcc, 0xcc, 0x33, + 0xcc, 0xcc, 0xcc, 0x33, 0xcb, 0xcb, 0xbb, 0xee, 0xcb, 0xcb, 0xcc, 0x33, + 0xca, 0xca, 0xaa, 0xaa, 0xca, 0xca, 0xcc, 0x33, 0xc9, 0xc9, 0x99, 0x66, + 0xc9, 0xc9, 0xcc, 0x33, 0xc8, 0xc8, 0x88, 0x22, 0xc8, 0xc8, 0xcc, 0x33, + 0xc7, 0xc7, 0x77, 0xdd, 0xc7, 0xc7, 0xcc, 0x33, 0xc6, 0xc6, 0x66, 0x99, + 0xc6, 0xc6, 0xcc, 0x33, 0xc5, 0xc5, 0x55, 0x55, 0xc5, 0xc5, 0xcc, 0x33, + 0xc4, 0xc4, 0x44, 0x11, 0xc4, 0xc4, 0xcc, 0x33, 0xc3, 0xc3, 0x33, 0xcc, + 0xc3, 0xc3, 0xcc, 0x33, 0xc2, 0xc2, 0x22, 0x88, 0xc2, 0xc2, 0xcc, 0x33, + 0xc1, 0xc1, 0x11, 0x44, 0xc1, 0xc1, 0xcc, 0x33, 0xc0, 0xc0, 0x00, 0x00, + 0xc0, 0xc0, 0xcc, 0x33, 0xbf, 0xbf, 0xff, 0xff, 0xbf, 0xbf, 0xbb, 0xee, + 0xbe, 0xbe, 0xee, 0xbb, 0xbe, 0xbe, 0xbb, 0xee, 0xbd, 0xbd, 0xdd, 0x77, + 0xbd, 0xbd, 0xbb, 0xee, 0xbc, 0xbc, 0xcc, 0x33, 0xbc, 0xbc, 0xbb, 0xee, + 0xbb, 0xbb, 0xbb, 0xee, 0xbb, 0xbb, 0xbb, 0xee, 0xba, 0xba, 0xaa, 0xaa, + 0xba, 0xba, 0xbb, 0xee, 0xb9, 0xb9, 0x99, 0x66, 0xb9, 0xb9, 0xbb, 0xee, + 0xb8, 0xb8, 0x88, 0x22, 0xb8, 0xb8, 0xbb, 0xee, 0xb7, 0xb7, 0x77, 0xdd, + 0xb7, 0xb7, 0xbb, 0xee, 0xb6, 0xb6, 0x66, 0x99, 0xb6, 0xb6, 0xbb, 0xee, + 0xb5, 0xb5, 0x55, 0x55, 0xb5, 0xb5, 0xbb, 0xee, 0xb4, 0xb4, 0x44, 0x11, + 0xb4, 0xb4, 0xbb, 0xee, 0xb3, 0xb3, 0x33, 0xcc, 0xb3, 0xb3, 0xbb, 0xee, + 0xb2, 0xb2, 0x22, 0x88, 0xb2, 0xb2, 0xbb, 0xee, 0xb1, 0xb1, 0x11, 0x44, + 0xb1, 0xb1, 0xbb, 0xee, 0xb0, 0xb0, 0x00, 0x00, 0xb0, 0xb0, 0xbb, 0xee, + 0xaf, 0xaf, 0xff, 0xff, 0xaf, 0xaf, 0xaa, 0xaa, 0xae, 0xae, 0xee, 0xbb, + 0xae, 0xae, 0xaa, 0xaa, 0xad, 0xad, 0xdd, 0x77, 0xad, 0xad, 0xaa, 0xaa, + 0xac, 0xac, 0xcc, 0x33, 0xac, 0xac, 0xaa, 0xaa, 0xab, 0xab, 0xbb, 0xee, + 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xa9, 0xa9, 0x99, 0x66, 0xa9, 0xa9, 0xaa, 0xaa, 0xa8, 0xa8, 0x88, 0x22, + 0xa8, 0xa8, 0xaa, 0xaa, 0xa7, 0xa7, 0x77, 0xdd, 0xa7, 0xa7, 0xaa, 0xaa, + 0xa6, 0xa6, 0x66, 0x99, 0xa6, 0xa6, 0xaa, 0xaa, 0xa5, 0xa5, 0x55, 0x55, + 0xa5, 0xa5, 0xaa, 0xaa, 0xa4, 0xa4, 0x44, 0x11, 0xa4, 0xa4, 0xaa, 0xaa, + 0xa3, 0xa3, 0x33, 0xcc, 0xa3, 0xa3, 0xaa, 0xaa, 0xa2, 0xa2, 0x22, 0x88, + 0xa2, 0xa2, 0xaa, 0xaa, 0xa1, 0xa1, 0x11, 0x44, 0xa1, 0xa1, 0xaa, 0xaa, + 0xa0, 0xa0, 0x00, 0x00, 0xa0, 0xa0, 0xaa, 0xaa, 0x9f, 0x9f, 0xff, 0xff, + 0x9f, 0x9f, 0x99, 0x66, 0x9e, 0x9e, 0xee, 0xbb, 0x9e, 0x9e, 0x99, 0x66, + 0x9d, 0x9d, 0xdd, 0x77, 0x9d, 0x9d, 0x99, 0x66, 0x9c, 0x9c, 0xcc, 0x33, + 0x9c, 0x9c, 0x99, 0x66, 0x9b, 0x9b, 0xbb, 0xee, 0x9b, 0x9b, 0x99, 0x66, + 0x9a, 0x9a, 0xaa, 0xaa, 0x9a, 0x9a, 0x99, 0x66, 0x99, 0x99, 0x99, 0x66, + 0x99, 0x99, 0x99, 0x66, 0x98, 0x98, 0x88, 0x22, 0x98, 0x98, 0x99, 0x66, + 0x97, 0x97, 0x77, 0xdd, 0x97, 0x97, 0x99, 0x66, 0x96, 0x96, 0x66, 0x99, + 0x96, 0x96, 0x99, 0x66, 0x95, 0x95, 0x55, 0x55, 0x95, 0x95, 0x99, 0x66, + 0x94, 0x94, 0x44, 0x11, 0x94, 0x94, 0x99, 0x66, 0x93, 0x93, 0x33, 0xcc, + 0x93, 0x93, 0x99, 0x66, 0x92, 0x92, 0x22, 0x88, 0x92, 0x92, 0x99, 0x66, + 0x91, 0x91, 0x11, 0x44, 0x91, 0x91, 0x99, 0x66, 0x90, 0x90, 0x00, 0x00, + 0x90, 0x90, 0x99, 0x66, 0x8f, 0x8f, 0xff, 0xff, 0x8f, 0x8f, 0x88, 0x22, + 0x8e, 0x8e, 0xee, 0xbb, 0x8e, 0x8e, 0x88, 0x22, 0x8d, 0x8d, 0xdd, 0x77, + 0x8d, 0x8d, 0x88, 0x22, 0x8c, 0x8c, 0xcc, 0x33, 0x8c, 0x8c, 0x88, 0x22, + 0x8b, 0x8b, 0xbb, 0xee, 0x8b, 0x8b, 0x88, 0x22, 0x8a, 0x8a, 0xaa, 0xaa, + 0x8a, 0x8a, 0x88, 0x22, 0x89, 0x89, 0x99, 0x66, 0x89, 0x89, 0x88, 0x22, + 0x88, 0x88, 0x88, 0x22, 0x88, 0x88, 0x88, 0x22, 0x87, 0x87, 0x77, 0xdd, + 0x87, 0x87, 0x88, 0x22, 0x86, 0x86, 0x66, 0x99, 0x86, 0x86, 0x88, 0x22, + 0x85, 0x85, 0x55, 0x55, 0x85, 0x85, 0x88, 0x22, 0x84, 0x84, 0x44, 0x11, + 0x84, 0x84, 0x88, 0x22, 0x83, 0x83, 0x33, 0xcc, 0x83, 0x83, 0x88, 0x22, + 0x82, 0x82, 0x22, 0x88, 0x82, 0x82, 0x88, 0x22, 0x81, 0x81, 0x11, 0x44, + 0x81, 0x81, 0x88, 0x22, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x88, 0x22, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x77, 0xdd, 0xfe, 0xfe, 0xee, 0xbb, + 0xfe, 0xfe, 0x77, 0xdd, 0xfd, 0xfd, 0xdd, 0x77, 0xfd, 0xfd, 0x77, 0xdd, + 0xfc, 0xfc, 0xcc, 0x33, 0xfc, 0xfc, 0x77, 0xdd, 0xfb, 0xfb, 0xbb, 0xee, + 0xfb, 0xfb, 0x77, 0xdd, 0xfa, 0xfa, 0xaa, 0xaa, 0xfa, 0xfa, 0x77, 0xdd, + 0xf9, 0xf9, 0x99, 0x66, 0xf9, 0xf9, 0x77, 0xdd, 0xf8, 0xf8, 0x88, 0x22, + 0xf8, 0xf8, 0x77, 0xdd, 0xf7, 0xf7, 0x77, 0xdd, 0xf7, 0xf7, 0x77, 0xdd, + 0xf6, 0xf6, 0x66, 0x99, 0xf6, 0xf6, 0x77, 0xdd, 0xf5, 0xf5, 0x55, 0x55, + 0xf5, 0xf5, 0x77, 0xdd, 0xf4, 0xf4, 0x44, 0x11, 0xf4, 0xf4, 0x77, 0xdd, + 0xf3, 0xf3, 0x33, 0xcc, 0xf3, 0xf3, 0x77, 0xdd, 0xf2, 0xf2, 0x22, 0x88, + 0xf2, 0xf2, 0x77, 0xdd, 0xf1, 0xf1, 0x11, 0x44, 0xf1, 0xf1, 0x77, 0xdd, + 0xf0, 0xf0, 0x00, 0x00, 0xf0, 0xf0, 0x77, 0xdd, 0xef, 0xef, 0xff, 0xff, + 0xef, 0xef, 0x66, 0x99, 0xee, 0xee, 0xee, 0xbb, 0xee, 0xee, 0x66, 0x99, + 0xed, 0xed, 0xdd, 0x77, 0xed, 0xed, 0x66, 0x99, 0xec, 0xec, 0xcc, 0x33, + 0xec, 0xec, 0x66, 0x99, 0xeb, 0xeb, 0xbb, 0xee, 0xeb, 0xeb, 0x66, 0x99, + 0xea, 0xea, 0xaa, 0xaa, 0xea, 0xea, 0x66, 0x99, 0xe9, 0xe9, 0x99, 0x66, + 0xe9, 0xe9, 0x66, 0x99, 0xe8, 0xe8, 0x88, 0x22, 0xe8, 0xe8, 0x66, 0x99, + 0xe7, 0xe7, 0x77, 0xdd, 0xe7, 0xe7, 0x66, 0x99, 0xe6, 0xe6, 0x66, 0x99, + 0xe6, 0xe6, 0x66, 0x99, 0xe5, 0xe5, 0x55, 0x55, 0xe5, 0xe5, 0x66, 0x99, + 0xe4, 0xe4, 0x44, 0x11, 0xe4, 0xe4, 0x66, 0x99, 0xe3, 0xe3, 0x33, 0xcc, + 0xe3, 0xe3, 0x66, 0x99, 0xe2, 0xe2, 0x22, 0x88, 0xe2, 0xe2, 0x66, 0x99, + 0xe1, 0xe1, 0x11, 0x44, 0xe1, 0xe1, 0x66, 0x99, 0xe0, 0xe0, 0x00, 0x00, + 0xe0, 0xe0, 0x66, 0x99, 0xdf, 0xdf, 0xff, 0xff, 0xdf, 0xdf, 0x55, 0x55, + 0xde, 0xde, 0xee, 0xbb, 0xde, 0xde, 0x55, 0x55, 0xdd, 0xdd, 0xdd, 0x77, + 0xdd, 0xdd, 0x55, 0x55, 0xdc, 0xdc, 0xcc, 0x33, 0xdc, 0xdc, 0x55, 0x55, + 0xdb, 0xdb, 0xbb, 0xee, 0xdb, 0xdb, 0x55, 0x55, 0xda, 0xda, 0xaa, 0xaa, + 0xda, 0xda, 0x55, 0x55, 0xd9, 0xd9, 0x99, 0x66, 0xd9, 0xd9, 0x55, 0x55, + 0xd8, 0xd8, 0x88, 0x22, 0xd8, 0xd8, 0x55, 0x55, 0xd7, 0xd7, 0x77, 0xdd, + 0xd7, 0xd7, 0x55, 0x55, 0xd6, 0xd6, 0x66, 0x99, 0xd6, 0xd6, 0x55, 0x55, + 0xd5, 0xd5, 0x55, 0x55, 0xd5, 0xd5, 0x55, 0x55, 0xd4, 0xd4, 0x44, 0x11, + 0xd4, 0xd4, 0x55, 0x55, 0xd3, 0xd3, 0x33, 0xcc, 0xd3, 0xd3, 0x55, 0x55, + 0xd2, 0xd2, 0x22, 0x88, 0xd2, 0xd2, 0x55, 0x55, 0xd1, 0xd1, 0x11, 0x44, + 0xd1, 0xd1, 0x55, 0x55, 0xd0, 0xd0, 0x00, 0x00, 0xd0, 0xd0, 0x55, 0x55, + 0xcf, 0xcf, 0xff, 0xff, 0xcf, 0xcf, 0x44, 0x11, 0xce, 0xce, 0xee, 0xbb, + 0xce, 0xce, 0x44, 0x11, 0xcd, 0xcd, 0xdd, 0x77, 0xcd, 0xcd, 0x44, 0x11, + 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc, 0x44, 0x11, 0xcb, 0xcb, 0xbb, 0xee, + 0xcb, 0xcb, 0x44, 0x11, 0xca, 0xca, 0xaa, 0xaa, 0xca, 0xca, 0x44, 0x11, + 0xc9, 0xc9, 0x99, 0x66, 0xc9, 0xc9, 0x44, 0x11, 0xc8, 0xc8, 0x88, 0x22, + 0xc8, 0xc8, 0x44, 0x11, 0xc7, 0xc7, 0x77, 0xdd, 0xc7, 0xc7, 0x44, 0x11, + 0xc6, 0xc6, 0x66, 0x99, 0xc6, 0xc6, 0x44, 0x11, 0xc5, 0xc5, 0x55, 0x55, + 0xc5, 0xc5, 0x44, 0x11, 0xc4, 0xc4, 0x44, 0x11, 0xc4, 0xc4, 0x44, 0x11, + 0xc3, 0xc3, 0x33, 0xcc, 0xc3, 0xc3, 0x44, 0x11, 0xc2, 0xc2, 0x22, 0x88, + 0xc2, 0xc2, 0x44, 0x11, 0xc1, 0xc1, 0x11, 0x44, 0xc1, 0xc1, 0x44, 0x11, + 0xc0, 0xc0, 0x00, 0x00, 0xc0, 0xc0, 0x44, 0x11, 0xbf, 0xbf, 0xff, 0xff, + 0xbf, 0xbf, 0x33, 0xcc, 0xbe, 0xbe, 0xee, 0xbb, 0xbe, 0xbe, 0x33, 0xcc, + 0xbd, 0xbd, 0xdd, 0x77, 0xbd, 0xbd, 0x33, 0xcc, 0xbc, 0xbc, 0xcc, 0x33, + 0xbc, 0xbc, 0x33, 0xcc, 0xbb, 0xbb, 0xbb, 0xee, 0xbb, 0xbb, 0x33, 0xcc, + 0xba, 0xba, 0xaa, 0xaa, 0xba, 0xba, 0x33, 0xcc, 0xb9, 0xb9, 0x99, 0x66, + 0xb9, 0xb9, 0x33, 0xcc, 0xb8, 0xb8, 0x88, 0x22, 0xb8, 0xb8, 0x33, 0xcc, + 0xb7, 0xb7, 0x77, 0xdd, 0xb7, 0xb7, 0x33, 0xcc, 0xb6, 0xb6, 0x66, 0x99, + 0xb6, 0xb6, 0x33, 0xcc, 0xb5, 0xb5, 0x55, 0x55, 0xb5, 0xb5, 0x33, 0xcc, + 0xb4, 0xb4, 0x44, 0x11, 0xb4, 0xb4, 0x33, 0xcc, 0xb3, 0xb3, 0x33, 0xcc, + 0xb3, 0xb3, 0x33, 0xcc, 0xb2, 0xb2, 0x22, 0x88, 0xb2, 0xb2, 0x33, 0xcc, + 0xb1, 0xb1, 0x11, 0x44, 0xb1, 0xb1, 0x33, 0xcc, 0xb0, 0xb0, 0x00, 0x00, + 0xb0, 0xb0, 0x33, 0xcc, 0xaf, 0xaf, 0xff, 0xff, 0xaf, 0xaf, 0x22, 0x88, + 0xae, 0xae, 0xee, 0xbb, 0xae, 0xae, 0x22, 0x88, 0xad, 0xad, 0xdd, 0x77, + 0xad, 0xad, 0x22, 0x88, 0xac, 0xac, 0xcc, 0x33, 0xac, 0xac, 0x22, 0x88, + 0xab, 0xab, 0xbb, 0xee, 0xab, 0xab, 0x22, 0x88, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0x22, 0x88, 0xa9, 0xa9, 0x99, 0x66, 0xa9, 0xa9, 0x22, 0x88, + 0xa8, 0xa8, 0x88, 0x22, 0xa8, 0xa8, 0x22, 0x88, 0xa7, 0xa7, 0x77, 0xdd, + 0xa7, 0xa7, 0x22, 0x88, 0xa6, 0xa6, 0x66, 0x99, 0xa6, 0xa6, 0x22, 0x88, + 0xa5, 0xa5, 0x55, 0x55, 0xa5, 0xa5, 0x22, 0x88, 0xa4, 0xa4, 0x44, 0x11, + 0xa4, 0xa4, 0x22, 0x88, 0xa3, 0xa3, 0x33, 0xcc, 0xa3, 0xa3, 0x22, 0x88, + 0xa2, 0xa2, 0x22, 0x88, 0xa2, 0xa2, 0x22, 0x88, 0xa1, 0xa1, 0x11, 0x44, + 0xa1, 0xa1, 0x22, 0x88, 0xa0, 0xa0, 0x00, 0x00, 0xa0, 0xa0, 0x22, 0x88, + 0x9f, 0x9f, 0xff, 0xff, 0x9f, 0x9f, 0x11, 0x44, 0x9e, 0x9e, 0xee, 0xbb, + 0x9e, 0x9e, 0x11, 0x44, 0x9d, 0x9d, 0xdd, 0x77, 0x9d, 0x9d, 0x11, 0x44, + 0x9c, 0x9c, 0xcc, 0x33, 0x9c, 0x9c, 0x11, 0x44, 0x9b, 0x9b, 0xbb, 0xee, + 0x9b, 0x9b, 0x11, 0x44, 0x9a, 0x9a, 0xaa, 0xaa, 0x9a, 0x9a, 0x11, 0x44, + 0x99, 0x99, 0x99, 0x66, 0x99, 0x99, 0x11, 0x44, 0x98, 0x98, 0x88, 0x22, + 0x98, 0x98, 0x11, 0x44, 0x97, 0x97, 0x77, 0xdd, 0x97, 0x97, 0x11, 0x44, + 0x96, 0x96, 0x66, 0x99, 0x96, 0x96, 0x11, 0x44, 0x95, 0x95, 0x55, 0x55, + 0x95, 0x95, 0x11, 0x44, 0x94, 0x94, 0x44, 0x11, 0x94, 0x94, 0x11, 0x44, + 0x93, 0x93, 0x33, 0xcc, 0x93, 0x93, 0x11, 0x44, 0x92, 0x92, 0x22, 0x88, + 0x92, 0x92, 0x11, 0x44, 0x91, 0x91, 0x11, 0x44, 0x91, 0x91, 0x11, 0x44, + 0x90, 0x90, 0x00, 0x00, 0x90, 0x90, 0x11, 0x44, 0x8f, 0x8f, 0xff, 0xff, + 0x8f, 0x8f, 0x00, 0x00, 0x8e, 0x8e, 0xee, 0xbb, 0x8e, 0x8e, 0x00, 0x00, + 0x8d, 0x8d, 0xdd, 0x77, 0x8d, 0x8d, 0x00, 0x00, 0x8c, 0x8c, 0xcc, 0x33, + 0x8c, 0x8c, 0x00, 0x00, 0x8b, 0x8b, 0xbb, 0xee, 0x8b, 0x8b, 0x00, 0x00, + 0x8a, 0x8a, 0xaa, 0xaa, 0x8a, 0x8a, 0x00, 0x00, 0x89, 0x89, 0x99, 0x66, + 0x89, 0x89, 0x00, 0x00, 0x88, 0x88, 0x88, 0x22, 0x88, 0x88, 0x00, 0x00, + 0x87, 0x87, 0x77, 0xdd, 0x87, 0x87, 0x00, 0x00, 0x86, 0x86, 0x66, 0x99, + 0x86, 0x86, 0x00, 0x00, 0x85, 0x85, 0x55, 0x55, 0x85, 0x85, 0x00, 0x00, + 0x84, 0x84, 0x44, 0x11, 0x84, 0x84, 0x00, 0x00, 0x83, 0x83, 0x33, 0xcc, + 0x83, 0x83, 0x00, 0x00, 0x82, 0x82, 0x22, 0x88, 0x82, 0x82, 0x00, 0x00, + 0x81, 0x81, 0x11, 0x44, 0x81, 0x81, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, + 0x80, 0x80, 0x00, 0x00 +}; +static const unsigned int iie_enhanced_video_len = 4096; diff --git a/test/asm/001_jmp_indirect.asm b/test/asm/001_jmp_indirect.asm new file mode 100644 index 0000000..0b309a8 --- /dev/null +++ b/test/asm/001_jmp_indirect.asm @@ -0,0 +1,17 @@ +; 65c02 Indirect Indexed JMP ($xxx,X) + .org $2000 +jump_ad = $3000 + ;.verbose + JMP skip +ind LDA #$99 ; $2003 + BRA pass +skip: LDA #ind + STA jump_ad,Y + LDX #$02 + JMP ($3000,X) ; JMP -> $2003 +fail BRK ; JMP Failed! +pass BRK diff --git a/test/asm/002_jsr_rts.asm b/test/asm/002_jsr_rts.asm new file mode 100644 index 0000000..a25a908 --- /dev/null +++ b/test/asm/002_jsr_rts.asm @@ -0,0 +1,25 @@ +; 65c02 JSR/RTS/SBC/BEQ + .org $2000 + ;.verbose + CLC + LDA #$00 + JSR skip + SEC + SBC #$03 + BEQ back + JMP fail +skip LDA #$03 + RTS +fail BRK ; JSR Failed! +; now test setting some address on the stack and call RTS +jump LDA #>pass + PHA + LDA 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 $70) + asl ; We need this for the ProDOS unit number (below). + asl ; Format = bits DSSS0000 + asl ; D = drive number (0), SSS = slot number (1-7) + sta unit ; Store ProDOS unit number here + lda #$08 ; Store block (512 bytes) at address $0800 + sta bufhi ; Address high byte + stz buflo ; Address low byte + stz blklo ; Block 0 low byte + stz blkhi ; Block 0 high byte + jsr $07FD ; Read the block (will jmp to our driver and trigger it) + bcs error + lda #$0A ; Store block (512 bytes) at address $0A00 + sta bufhi ; Address high byte + lda #$01 + sta blklo ; Block 1 low byte + jsr $07FD ; Read + bcs error + lda $0801 ; Should be nonzero + beq error + lda #$01 ; Should always be 1 + cmp $0800 + bne error + ldx unit ; ProDOS block 0 code wants ProDOS unit number in X + jmp $801 ; Continue reading the disk +error jmp $E000 ; Out to BASIC on error + + .org $c0c0 +; jump back to mii code +entryHD nop ; Hard drive driver address + bra magicHD + bra magicSM + + .org $c0d0 +magicHD .db $db, $fb, $0 + bra done + + .org $c0e0 +magicSM .db $db, $fb, $0 + bra done + + .org $c0f0 +DONE bcs ERR + lda #$00 + rts +ERR lda #$27 + rts + +; $CnFE status byte +; bit 7 - Medium is removable. +; bit 6 - Device is interruptable. +; bit 5-4 - Number of volumes on the device (0-3). +; bit 3 - The device supports formatting. +; bit 2 - The device can be written to. +; bit 1 - The device can be read from (must be on). +; bit 0 - The device's status can be read (must be on). + .org $c0fe + .db $17 + .db entryOffset ; entry point offset diff --git a/test/asm/mii_smartport_driver.bin b/test/asm/mii_smartport_driver.bin new file mode 100644 index 0000000000000000000000000000000000000000..a67c1b953964b0df96fc5d5152d32c2af88e34d7 GIT binary patch literal 256 zcmZ3au##aB^GXJt|K}Glw79gmwYZ;Xaa!rq`{m;$?1g*|1 zIa*y)TvFUp+!g+^Z;)Hb)#|#EvDFR45nRj2@quS0<5>od3#`kWeHb}>7#=Xt7`$rW dZIDK? + * + * SPDX-License-Identifier: MIT + * + * Small command line assembler for our own drivers + * + */ + +#include +#include +#include +#include + +#include "mii_65c02.h" +#include "mii_65c02_asm.h" +#include "mii_65c02_disasm.h" +#include "mii_65c02_ops.h" + +int +main( + int argc, + const char * argv[]) +{ + const char *infile = NULL; + const char *outfile = NULL; + int verbose = 0; + // parse arguments + for (int i = 1; i < argc; i++) { + if (!strcmp(argv[i], "-o")) { + if (i + 1 >= argc) { + fprintf(stderr, "%s Missing argument for -o\n", argv[0]); + exit(1); + } + outfile = argv[++i]; + } else if (!strcmp(argv[i], "-v")) { + verbose = 1; + } else if (!infile) { + infile = argv[i]; + } else { + fprintf(stderr, "%s Unknown argument %s\n", argv[0], argv[i]); + exit(1); + } + } + if (!infile || !outfile) { + fprintf(stderr, "Usage: mii_asm [-v] -o outfile infile\n"); + exit(1); + } + char *prog = calloc(1, 65536); + if (verbose) + printf("%s Loading %s\n", argv[0], infile); + FILE *f = fopen(infile, "r"); + if (!f) { + perror(infile); + exit(1); + + } + fread(prog, 1, 65536, f); + fclose(f); + + mii_cpu_asm_program_t p = {}; + p.verbose = verbose; + if (mii_cpu_asm(&p, prog) == 0) { + if (verbose) + mii_cpu_disasm(p.output, p.org, p.output_len); + if (verbose) + printf("%s Writing %s\n", argv[0], outfile); + f = fopen(outfile, "w"); + if (!f) { + perror(outfile); + exit(1); + } + fwrite(p.output, 1, p.output_len, f); + fclose(f); + } else { + fprintf(stderr, "%s: %s error, no output\n", argv[0], infile); + exit(1); + } + + return 0; +} diff --git a/test/mii_cpu_test.c b/test/mii_cpu_test.c new file mode 100644 index 0000000..5145ca9 --- /dev/null +++ b/test/mii_cpu_test.c @@ -0,0 +1,521 @@ +/* + * mii_cpu_test.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + * + * This was heavily inspired and converted from + * https://github.com/ct6502/apple2ts/blob/main/src/emulator/instructions.test.ts + * + */ + +#include +#include +#include +#include + +#include "mii_65c02.h" +#include "mii_65c02_asm.h" +#include "mii_65c02_disasm.h" +#include "mii_65c02_ops.h" + + +static void +_run_one_dump_state( + mii_cpu_t *cpu, + mii_cpu_state_t s, + void *p) +{ + printf("PC:%04X A:%02X X:%02X Y:%02X S:%02x #%d %s AD:%04X D:%02x %s ", + cpu->PC, cpu->A, cpu->X, cpu->Y, cpu->S, cpu->cycle, + s.sync ? "I" : " ", s.addr, s.data, s.w ? "W" : "R"); + // display the S flags + static const char *s_flags = "CZIDBRVN"; + for (int i = 0; i < 8; i++) + printf("%c", cpu->P.P[i] ? s_flags[i] : tolower(s_flags[i])); + if (s.sync) { + mii_op_t d = mii_cpu_op[cpu->ram[cpu->PC]]; + printf(" "); + char dis[64]; + mii_cpu_disasm_one(cpu->ram + cpu->PC, cpu->PC, dis, sizeof(dis), + MII_DUMP_DIS_PC | MII_DUMP_DIS_DUMP_HEX); + printf("%s", dis); + if (d.desc.branch) { + if (cpu->P.P[d.desc.s_bit] == d.desc.s_bit_value) + printf(" ; taken"); + } + printf("\n"); + } else + printf("\n"); +} + + +static int +_run_one_test( + const char *prog, + int verbose) +{ + uint8_t *ram = calloc(1, 0x10000); + mii_cpu_asm_program_t p = {}; + { + p.verbose = verbose; + if (mii_cpu_asm(&p, prog) == 0) { + // uint8_t *o = p.output; + if (verbose || p.verbose) + mii_cpu_disasm(p.output, p.org, p.output_len); + memcpy(ram + p.org, p.output, p.output_len); + } else { + printf("error\n"); + exit(1); + } + } + mii_cpu_t cpu = {0}; + mii_cpu_state_t s = {0}; + verbose += p.verbose; + cpu.ram = ram; + if (verbose) { + // cpu.debug = _run_one_dump_state; + } + cpu.P.P[5] = 1; + cpu.S = 0xFF; + cpu.PC = p.org; + cpu.A = 0x01; + int count = 1000; + int error = 1; + do { + s = mii_cpu_run(&cpu, s); + if (s.w) ram[s.addr] = s.data; + else s.data = ram[s.addr]; + if (verbose) + _run_one_dump_state(&cpu, s, NULL); + if (s.sync && !s.w && s.data == 0x00) { + mii_cpu_asm_line_t *l = p.prog; + while (l) { + if (l->addr == s.addr) + break; + l = l->next; + } + if (l && !strcasecmp(l->label, "pass")) { + printf("TEST %-40.40s: PASS\n", p.prog->line + 2); + error = 0; + } else if (l) { + printf("TEST %-40.40s: FAIL\n", p.prog->line + 2); + printf("\t%s\n", l->line); + _run_one_dump_state(&cpu, s, NULL); + } else { + printf("TEST %-40.40s: FAIL (out of program!)\n", + p.prog->line + 2); + _run_one_dump_state(&cpu, s, NULL); + } + break; + } + } while (count--); + if (!count) { + printf("TEST %-40.40s: FAIL (out of _run_this cycles!)\n", + p.prog->line + 2); + _run_one_dump_state(&cpu, s, NULL); + } + free(ram); + return error; +} + +int +_run_this_one( + const char *desc, + const char *prog, + uint8_t expexted_A, + uint8_t expected_flags, + int verbose ) +{ + uint8_t *ram = calloc(1, 0x10000); + mii_cpu_asm_program_t p = {.org = 0x2000}; + { + if (mii_cpu_asm(&p, prog) == 0) { + // uint8_t *o = p.output; + if (verbose || p.verbose) + mii_cpu_disasm(p.output, p.org, p.output_len); + memcpy(ram + p.org, p.output, p.output_len); + } else { + printf("error\n"); + exit(1); + } + } + mii_cpu_t cpu = {0}; + mii_cpu_state_t s = {0}; + verbose += p.verbose; + cpu.ram = ram; + cpu.P.P[B_X] = 1; + expected_flags |= (1 << B_X); + cpu.S = 0xFF; + cpu.PC = p.org; + cpu.A = 0x01; + int count = 1000; + do { + s = mii_cpu_run(&cpu, s); + if (s.w) ram[s.addr] = s.data; + else s.data = ram[s.addr]; + if (verbose) + _run_one_dump_state(&cpu, s, NULL); + if (s.sync && !s.w && s.data == 0x00) { + if (cpu.A == expexted_A) { + int err = 0; + static const char *s_flags = "CZIDBRVN"; + for (int i = 0; i < 8; i++) + if (cpu.P.P[i] != ((expected_flags >> i) & 1)) { + printf("** S bit %c mismatch %d want %d\n", + s_flags[i], cpu.P.P[i], (expected_flags >> i) & 1); + err++; + } + if (err) + goto fail; + printf("TEST %-40.40s: PASS\n", desc); + break; + } else { + printf("** A Mismatch %02x vs %02x\n", cpu.A, expexted_A); +fail: + printf("TEST %-40.40s: FAIL\n", desc); + return -1; + } + } + } while (count--); + free(ram); + return 0; +} + +void +_run_this( + const char *desc, + const char *prog, + uint8_t expexted_A, + uint8_t expected_flags, + int verbose ) +{ + int e = _run_this_one(desc, prog, expexted_A, expected_flags, verbose); + if (e && !verbose) { + if (_run_this_one(desc, prog, expexted_A, expected_flags, 1)) + exit(1); + } +} + +static char * indirect(char *prefix, uint8_t A, uint8_t mem, char *suffix) { + char *s = calloc(1, 256); + sprintf(s, + " %s\n" + " LDA #$01\n" + " STA $12\n" + " LDA #$30\n" + " STA $13\n" + " LDA #$%02x\n" + " STA $3001\n" + " LDA #$%02x\n" + " %s\n", prefix, mem, A, suffix); + return s; +} +static char * doSED_ADC(uint8_t a, uint8_t b) { + char *s = calloc(1, 256); + sprintf(s, + " SED\n" + " LDA #$%02x\n" + " ADC #$%02x\n", + a, b); + return s; +} + +#include +int main() +{ + glob_t globbuf; + glob("test/asm/0*.asm", 0, NULL, &globbuf); + for (int i = 0; i < (int)globbuf.gl_pathc; i++) { + printf("Loading %s\n", globbuf.gl_pathv[i]); + FILE *f = fopen(globbuf.gl_pathv[i], "r"); + if (f) { + char *prog = calloc(1, 65536); + fread(prog, 1, 65536, f); + fclose(f); + _run_one_test(prog, 0); + free(prog); + } + } + globfree(&globbuf); + enum { + C = (1 << B_C), + Z = (1 << B_Z), + I = (1 << B_I), + D = (1 << B_D), + B = (1 << B_B), + X = (1 << B_X), + V = (1 << B_V), + N = (1 << B_N), + }; + _run_this("RMB $12", + " lda #$FF\n" + " sta $12\n" + " rmb1 $12\n" + " lda $12\n", + 0xfd, N, 0); + _run_this("RMB1 $ea", + " ldx $EA\n" + " lda #$FF\n" + " sta $EA\n" + " rmb1 $EA\n" + " cmp $EA\n" + " stx $EA\n", + 0xff, C, 0); + _run_this("ASL Carry", + " clc\n lda #$80\n asl\n", + 0x00, Z|C, 0); + _run_this("ROL Base", + " sec\n lda #$80\n rol\n", + 0x01, C, 0); + + _run_this("SBC Over+", + " sec\n lda #$d0\n sbc #$70\n", + 0x60, V|C, 0); + _run_this("SBC Neg3", + " sec\n lda #$d0\n sbc #$30\n", + 0xA0, N|C, 0); + _run_this("LDA ($aa,X)", + " LDX #$E9\n" + " LDY #$81\n" + " STY $3104\n" + " LDY #$04\n" + " STY $003A\n" + " LDY #$31\n" + " STY $003B\n" + " LDA ($51,X)\n", + 0x81, N, 0); + _run_this("LDA ($aa),Y", + " LDY #$E9\n" + " LDX #$BB\n" + " STX $403A\n" + " LDX #$51\n" + " STX $00A4\n" + " LDX #$3F\n" + " STX $00A5\n" + " LDA ($A4),Y\n", + 0xBB, N, 0); + _run_this("JMP ($3000,X)", + " JMP skip\n" + " LDA #$99 ; $2003\n" + " JMP done\n" + "skip LDA #$03\n" + " STA $3002\n" + " LDA #$20\n" + " STA $3003\n" + " LDX #$02\n" + " JMP ($3000,X) ; JMP -> $2003\n" + " LDA #$01 ; should not reach here\n" + "done NOP ;\n", + 0x99, N, 0); + _run_this("DEC", + " LDA #99\n" " DEC\n", + 0x98, N, 0); + _run_this("PLX", + " LDX #$97\n" " PHX\n" " PLX\n" " TXA\n", + 0x97, N, 0); + + _run_this("ASL", " LDA #$80\n ASL\n", 0x00, Z | C, 0); + _run_this("ROR", " LDA #$81\n ROR\n", 0x40, C, 0); + _run_this("ROL Z", " LDA #$80\n ROL\n", 0x00, Z | C, 0); + _run_this("ROL", " LDA #$81\n ROL\n", 0x02, C, 0); + + + _run_this("LDA ($12)", + indirect("", 0x99, 0xFC, "LDA ($12)"), + 0xFC, N, 0); + _run_this("ADC ($12)", + indirect("", 0x7E, 0xAF, "ADC ($12)"), + 0x2D, C, 0); + _run_this("ADC ($12) SED", + indirect("SED", 0x75, 0x25, "ADC ($12)"), + 0x00, V | C | D, 0); + _run_this("AND ($12)", + indirect("", 0x3F, 0xFC, "AND ($12)"), + 0x3C, 0, 0); + _run_this("CMP ($12)", + indirect("", 0xFC, 0x3F, "CMP ($12)"), + 0xFC, C | N, 0); + _run_this("EOR ($12)", + indirect("", 0x3F, 0xFC, "EOR ($12)"), + 0xC3, N, 0); + _run_this("ORA ($12)", + indirect("", 0x0E, 0xFC, "ORA ($12)"), + 0xFE, N, 0); + _run_this("SBC ($12)", + indirect("SEC", 0xFF, 0xC0, "SBC ($12)"), + 0x3F, C, 0); + _run_this("SBC ($12) SED", + indirect("SEC\n SED", 0x75, 0x25, "SBC ($12)"), + 0x50, C | D, 0); + _run_this("STA ($12)", + indirect("", 0xF1, 0xC0, "STA ($12)\n LDA $3001"), + 0xF1, N, 0); + + _run_this("BIT #$F0", + " LDA #$0F\n BIT #$F0\n", + 0x0F, Z , 0); + _run_this("BIT #$80", + " LDA #$0F\n BIT #$80", 0x0F, Z, 0); + _run_this("BIT #$70", + " LDA #$0F\n BIT #$70", + 0x0F, Z, 0); + _run_this("BIT #$FF", + " LDA #$0F\n BIT #$FF", + 0x0F, 0, 0); + _run_this("BIT $12,X", + " LDY #$F0\n" + " STY $14\n" + " LDA #$0F\n" + " LDX #$02\n" + " BIT $12,X\n", + 0x0F, Z | V | N, 0); + _run_this("BIT $1234,X", + " LDY #$F0\n" + " STY $1236\n" + " LDA #$0F\n" + " LDX #$02\n" + " BIT $1234,X\n", + 0x0F, Z | V | N, 0); + _run_this("DEC $xx", + " LDA #$FF\n" + " STA $12\n" + " DEC $12\n" + " LDA $12\n", + 0xFE, N, 0); + _run_this("INC $xxxx", + " LDA #$FF\n" + " STA $3000\n" + " INC $3000\n" + " LDA $3000\n", + 0x00, Z, 0); + + _run_this("LDA ($9d),Y", + " LDX #$90\n" + " STX $90\n" + " LDY #$D\n" + " STZ $91\n" + " LDX #$de\n" + " STX $9D\n" + " LDA ($90),y\n", + 0xde, N, 0); + + _run_this("LDA ($aa,X)", + " LDX #$E9\n" + " LDY #$81\n" + " STY $3104\n" + " LDY #$04\n" + " STY $003A\n" + " LDY #$31\n" + " STY $003B\n" + " LDA ($51,X)\n", + 0x81, N, 0); + _run_this("LDA ($aa),Y", + " LDY #$E9\n" + " LDX #$BB\n" + " STX $403A\n" + " LDX #$51\n" + " STX $00A4\n" + " LDX #$3F\n" + " STX $00A5\n" + " LDA ($A4),Y\n", + 0xBB, N, 0); + _run_this("LDA ($aa)", + " LDX #$AA\n" + " STX $3F51\n" + " LDX #$51\n" + " STX $00A4\n" + " LDX #$3F\n" + " STX $00A5\n" + " LDA ($A4)\n", + 0xAA, N, 0); + + _run_this("SED ADC 0", doSED_ADC(0, 0), 0x0, Z | D, 0); + _run_this("SED ADC 1", doSED_ADC(1, 0), 0x01, D, 0); + _run_this("SED ADC 9", doSED_ADC(9, 0), 0x09, D, 0); + _run_this("SED ADC 10", doSED_ADC(0x10, 0), 0x10, D, 0); + _run_this("SED ADC 1D", doSED_ADC(0x1D, 0), 0x23, D, 0); + _run_this("SED ADC 99", doSED_ADC(0x99, 0), 0x99, N | D, 0); + _run_this("SED ADC 99", doSED_ADC(0x99, 1), 0x00, C | D, 0); + _run_this("SED ADC BD", doSED_ADC(0xBD, 0), 0x23, C | D, 0); +#if 0 +// _run_this("SED ADC FF", doSED_ADC(0xFF, 0), 0x65, C | D | N, 0); + + _run_this("SED ADC 0,1", doSED_ADC(0, 1), 0x01, D, 0); + _run_this("SED ADC 0,9", doSED_ADC(0, 9), 0x09, D, 0); + _run_this("SED ADC 0,10", doSED_ADC(0, 0x10), 0x10, D, 0); + _run_this("SED ADC 0,1D", doSED_ADC(0, 0x1D), 0x23, D, 0); + _run_this("SED ADC 0,99", doSED_ADC(0, 0x99), 0x99, N | D, 0); + _run_this("SED ADC 0,BD", doSED_ADC(0, 0xBD), 0x23, C | D, 0); +// _run_this("SED ADC 0,FF", doSED_ADC(0, 0xFF), 0x65, C | D, 0); + + _run_this("SED ADC 99,1", doSED_ADC(0x99, 1), 0x0, Z | C | D, 0); + _run_this("SED ADC 35,35", doSED_ADC(0x35, 0x35), 0x70, D, 0); + _run_this("SED ADC 45,45", doSED_ADC(0x45, 0x45), 0x90, N | V | D, 0); + _run_this("SED ADC 50,50", doSED_ADC(0x50, 0x50), 0x0, V | Z | C | D, 0); + _run_this("SED ADC 99,99", doSED_ADC(0x99, 0x99), 0x98, N | V | C | D, 0); +// _run_this("SED ADC B1,C1", doSED_ADC(0xB1, 0xC1), 0xD2, N | V | C | D, 0); +#endif + // create an emulator, load the binary file 6502_functional_test.bin at $0000 + // and run it until we hit a BRK + const char *bigtest[] = { + // "test/asm/6502_functional_test.bin", + // "test/asm/65C02_extended_opcodes_test.bin", + NULL, + }; + for (int ti = 0; bigtest[ti]; ti++) { + FILE *f = fopen(bigtest[ti], "r"); + if (!f) { + fprintf(stderr, "Cannot open %s\n", bigtest[ti]); + continue; + } + printf("TEST %s\n", bigtest[ti]); + uint8_t *ram = calloc(1, 0x10000); + fread(ram + 0x000, 1, 0x10000 - 0x400, f); + fclose(f); + mii_cpu_t cpu = {0}; + mii_cpu_state_t s = {0}; + cpu.ram = ram; +// cpu.debug = _run_one_dump_state; + cpu.P.P[B_X] = 1; + cpu.P.P[B_I] = 1; + cpu.S = 0xFF; + cpu.PC = 0x400; + cpu.A = 0x00; + int count = 100000000; + int same_pc_count = 0; + uint16_t prev_pc = 0; + do { + s = mii_cpu_run(&cpu, s); + if (s.w) ram[s.addr] = s.data; + else s.data = ram[s.addr]; + if (s.sync && !s.w) { + if (cpu.PC == prev_pc) { + same_pc_count++; + if (same_pc_count > 3) { + printf("TEST %s: FAIL (stuck at %04X)\n", + bigtest[ti], cpu.PC); + _run_one_dump_state(&cpu, s, NULL); + printf(" Failed instruction is %c%c%c\n", + cpu.A, cpu.X, cpu.Y); + break; + } + } else { + same_pc_count = 0; + prev_pc = cpu.PC; + } + } + // if (s.sync) + _run_one_dump_state(&cpu, s, NULL); + } while (count--); + printf("TEST run with %d spare\n", count); + _run_one_dump_state(&cpu, s, NULL); + if (!count) { + printf("TEST %s: FAIL (out of _run_this cycles!)\n", + bigtest[ti]); + _run_one_dump_state(&cpu, s, NULL); + } + free(ram); + } +} diff --git a/test/mii_test.c b/test/mii_test.c new file mode 100644 index 0000000..9c1193d --- /dev/null +++ b/test/mii_test.c @@ -0,0 +1,61 @@ +/* + * mii_test.c + * + * Copyright (C) 2023 Michel Pollet + * + * SPDX-License-Identifier: MIT + */ +/* + * This is just a small example on how to use mii as a library + */ +#include +#include +#include +#include +#include + +#include "mii.h" +#include "mish.h" + +// so mii_mish_cmd can access the global mii_t +mii_t g_mii; + +void +_mii_mish_bp( + void * param, + int argc, + const char * argv[]); + +int main() +{ + mii_t *mii = &g_mii; + mii_init(mii); + mii_prepare(mii, MII_INIT_DEFAULT); +// int count = 100000; + + mish_prepare(0); + + // add a breakpoint + const char *av[] = {"bp", "+d5fdr", NULL}; + _mii_mish_bp(NULL, 2, av); + do { + if (mii->state != MII_STOPPED) + mii_run(mii); + if (mii->state == MII_STEP) { +// if (mii->trace_cpu) + mii_dump_trace_state(mii); + if (mii->trace.step_inst) + mii->trace.step_inst--; + if (mii->trace.step_inst == 0) + mii->state = MII_STOPPED; + } + if (mii->state != MII_RUNNING) { + // if (!mii->trace_cpu) { + // printf("mii: stopped\n"); + // mii->trace_cpu = 1; + // } + usleep(1000); + } + } while (1); + return 0; +} diff --git a/utils/clangd_gen.sh b/utils/clangd_gen.sh new file mode 100644 index 0000000..49ba734 --- /dev/null +++ b/utils/clangd_gen.sh @@ -0,0 +1,57 @@ +#!/bin/bash +# Generate a JSON file compatible with clangd for indexing. Parses +# the output of the make process, extract gcc lines, and convert to JSON +# using (gnu) AWK +# Join lines that finish by \ -- then split the large command lines around +# && and ||, then look for gcc, then split and look for a .c argument. +# when found, populate the compile_commands.json file +gawk -v dir="$(pwd)" ' +BEGIN { + acc="";line=0; + print "["; +} +END { + print "]"; +} +/\\ *$/ { + $0 = gensub(/\\ *$/, "", "g", $0); + acc = acc $0 + next; +} +/\|\| *$/ { + acc = acc $0 + next; +} +/^g?make\[([0-9]+)]/ { + if ($2 != "Entering") + next; + dir = gensub(/'\''/, "", "g", $4) + next; +} +{ + acc = acc $0 + acc = gensub(/([^\\])"/, "\\1\\\\\"", "g", acc); + acc = gensub(/ +/, " ", "g", acc); + cnt = split(acc, e, / *\|\| *| *&& */); + acc = ""; + for (cmd in e) { + e[cmd] = gensub(/[ |\t]+$/, "", "g", e[cmd]); + split(e[cmd], arg, / +/); + if (!match(arg[1], /g?cc$/)) + continue; + c_file="" + for (ai in arg) { + if (match(arg[ai], /\.c$/)) { + c_file = arg[ai]; + break; + } + } + if (c_file != "") { + if (line > 0) printf ","; + line++; + printf "{\"directory\":\"%s\",\"file\":\"%s\",\"command\":\"%s\"}\n", + dir, c_file, e[cmd]; + } + } +} +'

      hx;D961D;1QOI{)l{vy|FaF<;g;97?`VDTi``? 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 z{|o;M{|o;M{|o;M{|o;M{|o;M{|o<%`~SlK!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm z!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm!vDhm z!vDhm!vDhm!vEs_zwp2Czwp2Czwp2CzqtP|{4e}3{4e}3{4e}3{4e}3?*9w_3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM z3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;zrM3;*{&H~90v z^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G z^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G z^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G z^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G z^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G^1t%G z^1t%G^1t%G^1t%G^1t%Ga=-Gv^1kxE^1kxE^1kxE^1kxE^1kxE^1kxE^1kxE^1kxE z^1kxE^1gDua=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voD za=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voD za=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voD za=voDa=voDa=voDa=voDa=voDa=voDa=voDa=voDa=vmtI3Ju3&Ijj%^TGMxd~iNE zADj=)2j_$H!TI2Pa6UL6oDa?i=Y#XX`QUtTJ~$to56%bYgY&`p;CygCI3Ju3&Ijj% z^TGMxd~iNEADj=)2j_$H!TI2Pa6UL6oDa?i=Y#XX`QUtTJ~$to56%bYgY&`p;CygC zI3Ju3&Ijj%^TGMxd~iNEADj=)2j_$H!TI2Pa6UL6oDa?i=Y#XX`QUtTJ~$to56%bY zgY&`p;CygCI3Ju3&Ijj%^TGMxd~iNEADj=)2j_$H!TI2Pa6UL6oDa?i=Y#XX`QUtT zJ~$to56%bYgY&`p;CygCI3Ju3&Ijj%^TGMxd~iNEADj=)hx`2CeYnpL?g#gS`@#L- zesDjyAKVY_2ls>f!TsQV@IE*noDa?i=fiz{@IH7Sybs<7?}PWj``~@>K6oFz58emw zgZIJv;CygCI3Ju3&Ijj%^TGMxd~iNEADj=)2j_$H!TI2Pa6UL6oDa?i=Y#XX`QUtT zJ~$to56%bYgY&`p;CygCI3Ju3&Ijj%^TGMxd~iNEADj=)2j_$H!TI2Pa6UL6oDa?i z=Y#XX`QUtTJ~$to56%bYgY&`p;CygCI3Ju3&Ijj%^TGMxd~iNEADj=)H_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWC zH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWCH_kWr_l@_>{e9zp z<9_3Q<9_3Q<9_3Q<9_3Q<9_3Q<9_3Q<9_3Q<9_3Q<9_3Q<9>6W-}vA7-}vA7-}vA7 z-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7 z-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7 z-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA7-}vA8-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9 z-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}&G9-}yiIKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR zKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfRKlnfR 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 D2>n@| literal 0 HcmV?d00001 diff --git a/fonts/PrintChar21.ttf b/fonts/PrintChar21.ttf new file mode 100644 index 0000000000000000000000000000000000000000..7204e971878966081d007e0fbf644e1d99e28086 GIT binary patch literal 501992 zcmeFa3wT{swZ}WwUTbdx1_)3fNRada6p0d~N`;730v4?hF=~XMK>|c660~B}08t7A zs2HJ0)uuk5A|eB9&x?&zLm&Z zCUWB1#h0FcUhSN&Mv<3}(jK_vypHyLej*c$mqB0s*7Gj8;QR57x62+ghR}CZ`=xJR zGTd<&?PrdQy#KGFwt~N&dB~-2+_&zp635l_$WOoX@^gyiw%)4ExdGZLQ#st<+`zV8 zk;4{=JXK${IrO_h{j<;A+QZ*J%d=f)E*-K;KAss(NM0naR;^KwmC_o$!HBf%61nFr zdE&7obiU%HZ*7o4sou8D+kkDY)xol8!dXgFWZO3VYyY%AHxSiO4k^b}xPJPqbmM_; zy1r8WYTQ8Nj8|^7^Q+kVk3GWm-vr|i> zv%1-%r6JI$j5O{#W;`b2A1O_Tmj4LH16iv~4`uy7gsCwJpmZ z>ba)r`<-tlGtj1S+C|&wtSr@Q{Z{U3+~}+1jU(>5Jh+U@eLH0P(&na$@6y^|l-WV#+0cm0{tjRiUz%l2h? zOY7U|m_}bIPuhMuw52}otgSKH9obo$Y<*|4cQ7_3Zc1bGl&xEzl{*_Vnq8FJ(BC=oTpowEG?fd@4tfnU#&kg4{0v^Ute)u z{C_kSJ6vy?gS+d~)1lp6ng2((`|-Ei(rnop8dhe zz6@-Sw$hD-eQ~Fqsx{``;11m=N+Ha-R z%|GprdPFo9Jnd@Tw@z9s=Syq(CTZPoi?klXx;&s;TK6B6)`QEX^}tHsKCn|-4<$}B z8t8A=_(nDP8BvYORp0cP*Z)4E8f+K>YLD4Onf7PKT%U~@eP%qBVPm1(PL}bg|0T4g zZPQuW|Fqkt(@NEC^->!${i*Frlj;9Q^ry1SZz(L$97y|3zLo}~)wb5HZFTy$i;>Y< zX|@}W`Ad5{UdGZs z{b?*|ySn)`UAZ&gjDKe|I~p@xS^IWGyQBV{@v8hC@oB&5FQwT9pNp62-39Fw{YGnL zR_}Cu+3}s#OLR+iG39PPKd(PqmmpV4WlG>oNj zus-7rv=(30;p(A3)mhrk@@MNxm$lXSvNTrLQpc?{TJt4Kx4U)YHMv>7>H2KkbWcY! zU7zt$rm@w&oza$#Svy;5y%f{QosP$BGX8Aa>eH3e$ub$)u`F-4-)L=ociKivna0oZ zM#oHkhHksKn4aA&Rel!6XL>2smed~8t>aoZ-cZldxw^^QMd@f&hSHgAtD6pM8=c9t zw$d4m)s3dK4UgGsW$KIR+ew+_$<}vQM#^LMsSjCL|Bg!YIm=^p<*~Yz>Pu0Fv!Y6JDOKNEY`XJdgb&3EIUrrb`J$ut?$ z@YsBtPHX?erRr3DS>0AI)t~84ZC9F1|I@Yu-c**_5s+&t)~zpFIv!}XG+HaObZK2} zG(Sy`>9)3(=1;cI>e+Z0t@hctm8J2pe&Z=^PbVX*D_d7ylV2(?OP8%@^;tbTo~>tP zm)3X2o24~6Ewi$Br>;C%S;n&?S*FYAc2*kgzoN|QQF|4oa+RjE@1JQ0o#}cpy}MCv z$CI@K{_VzhBy$&jJ2@)b=(2jOzqGHkZM^?Pxt%{xS5~P_W_wnS(Pa9ZUTtUNXX6%U zYiCQPpGMx4I4XT9joD@W*)l8N`c1}kWtKiWuJx>aSy{$oeO3m3+mkgeX>J%zw#@3w z_Wvi<%|^2+w9{O({#}$ij6+6VDl?l$q3*_%mUgKui+7qQCAJv7mPTvkv^+NNR;s*d z^p@s_=~0ty#(5qgv!Ra)bY;3G=cS?=L?$GTnP1cUA52mMd z{NLP8=LtQou66`lY%GnZ`e=6U#NSdmyThX~HhuqeywygHo7tMJm)dPKrTR@qDgExW z;Z0+ZnZIZv*p=x^*9CnRXDy93E$PeB{;TRvm&z{jOTTe2Wll660nSdN*FLLf%S^wc zH-4qDy2c^Pv!i-O)-LI%qs{hZ>lX9r^k(UHRNoa}={R!I*qO{7rAuGWjF3zIYK;!yLWzshP-1z^Sb7Xc-W7F=&E46(WGD_*JZRJk&shzu!zsqs+H6zREo@Omh zD{C75lrAGv=Ww@k!DRlkzWpEnKc64}7sLO>7z#%SkK9sf`kmV<%Dq@&OC`y*(f*Kh zNkI;ht7KbrT=dfD)zNuTM|5R$bMC0z3Ayj&9*&pCpNBtL@I$-qR(QQ9J_!rxLd&6&+{q~cOedMv;$3FkZZGZd3;|D%| z_~Si~fA{f6A0OXxz?N-K=G^ygt7Rp2y(Bs-YQe56u9==a*T*0G z;@`R+m&dEHYu)1;uxo$pineXr_RDP#Y`b~e)!UYAYuk3#wllV!w6$;RhqpdsYyPP- zpE~KOqn|o*^nXUbKRPt}t?Q#Upz>eC5NJKYZcC7d(8*!~2iSA1NEz<7b!s?9!h;F!Nh8@0)qg%)6@Y zs=Bl4Q&p>~?x?!G>XQe}Jn;Slzjoj&4y-)zpaTmtes#d#_j{uBo72qgf5yLZH6y7E z#=MrY8e9c5H&+7ve)ai$@%lIqd4TdI;HC7hqdW_|n)-v3E#N%rd=EY9@Q{ZnuK-ul z{~gMkJ>QD6x!HL+xnyan@FQSgW)%6}xo|5n8E24tP%!56mJt(U^^t<;n zXL&?>QsT=@bVaP+nY>9n^A_qvcjgy7B5av?uSc|>$gG@4v_B;}W+6K|fO20zUvwa4 zK*a0Evz`f_MZcEEfag#@oN^&JojSJ6Y5^BepCdAxIaNe_Gk^A>9ua)AkMM|UDDUxz zkTrWP_&W5@rDQ%7(LBlx9?|nD|Kbt7fS)Nqjv`{-DCCG+sn4f;5a|5Fe*|-{h?vJC z$%`Z3M4kCO@&a%n^Z)mv5!K%|Z4)hVmnTc&G#su1W!?ajB=ZU?EQPGkZN!h{ePfb39xOS zGjM#mf8>L-fl20NC38RyCqFJr8% zpSSL30Oaje2^N7Kk!QgBj0P}59GUIZ$F+$(4_}|RM&x*S<_YKq z<08*r0ygkdCUm}FrN{};odEp_@XfCU=$eo07xwb|CFP(~8cL!6uQHG=njI2W6?qDd;$bvL3p6Cl|MN#y12BCo)fS9F8*B8ytVh{!7&!Kla?O#q+HoCA6RGz~Mr zVnF|^8o-#yS@6G_{#UOSX{-l*BCjb2*z}q~k=G_*A!q~8zIFhNi@a_g=m5~a4qKZl z!F&K;6Z)DaL|#7^(0=`}$k}zEU*sI<&S?T2U?(0u=S1TY?%+BY1txj-U^X7;s2YUKfeqhw-w)7k$u5puukMc z#G?0rYn=eg!sMf&MFo0qra20LHJxmMeP!JXfOs zsu=(|SG9s=pdXBgbS0n$Gz0p(1_1Q$tpbZcCs++eMBY~p>H&T4qwjs2M6QPJYUr+} z?`rz4hHfczOY6X5&;eOS0TFA9R8Nkq^-RKqFWVn3EoC=xGOQL_UbkA6y8!0s3yP1HB@*AoG?c zp!HFa<#Pb^w=({rd7u$20n0%@7zPs}x6J_aKr_Ie+pzgI#%^P51!F51ThR!XfaRbc z41)=g56=MeKqFWJmVpM(B$ z4FHY zf^X}fU$HwqMp3DRAeH$6yCKlhG6nUr$!1vGwZd2f0 z-z@T7#=pCY+mkMl?_>A(R{&@?G=dRsPpUzm$bZ*@2B39#f7k-Hhzuj|M*^Vx(L%6+ z+n9|aKN;oMw`xEe=oa}|8K?vO0KSpRfJKypA`ip+@H&x4Xg|^=@+k5i#fH(jU>RrP z6#%-Qk8(Cf#xI6Neu?~FLiPYsJ~ zT?FXgM*p@o5=jCUgF%U+W-uaAZV?!eC|(FQNtCpJRT6P7jq?2x6*x;5)=IQTE$9Q2 z{H)p%iS}#)oU!+61sf%LMk5%KsJsCnzkF1pz2^YN_bCJD*q5=2N`S5kWbQW?z`H*> z_HPI1-JkXW*mMB=Gim{R2QC1V2SInx8i@`@#=)y4s${$pTPo3eNE7Jg_757)n$e-i zJ`|d&YS05VNp#pe&H-_MP3!>hRAX=T3NR_rOytcRlV}!Wv&+FEuu`Hq zGeEaQN7Mm$jzrFp?Ev{l!G9F|N3E4;ZW+L~xf>)pn*O8Fbu{vx-3;hErW$kt_&8%m zHLE3hP6c56IfD{Cw+f*9x$7l5b^%x;Q7yV_(Orw2<5o)aJOSu<9x{%v1dJWe*u2dW zJ%71GFM$6Av`@gE`HKL0UpN;mmgq!yPiz3tp40`9SC@b}pkJaF)q^34PKNJf#!qJa z#q)TyQ76$UjGaRJ6lB+z1M2mI5}iu_spvd)1wiMilMj-RKa z`{mg3@?MEv!PqN?C0bMlHc9kK=wI0ZMkG1|eP=*(2D;8{1{)=6Kxe}uK>w?dbr$Wj z*6^66QKH5KER*OpwE&r%DWlh6*XuS*)YJ*KNc8%pU`(R3k#{!o&Oz2W0}?gY0DL(Y z{pZ5>hIs(FZ=|2|U)0h9u#aR075?oCEqKx(MADjY-tj zA<>%?uu7u0Apb2ZCAt`ziw7lIya=G@68bMe?S_ki33Wg-&tQU2(O7yM-^hosXT8Z9M2awg-1hAoV zg2z$V;Q-AQ;7aJOTmsfhbX5gdBT*N8UGTkkvqbO1=Btr;bu(BA1_O|_bS@Z>=$aNl z9Il1;+6@w2hY#05+r1FL-wjPS^13G_x*i*^hxUdV0R4@~xN$jPY#DYe8RLhW3^!&Or4GA8rDJ5`APoVEiM{bJmGIO8ukV0G+*a0rvK;mFQy$ zXaVaa`Zzj1-VO#N`a~7Lw@*O7vKlmleu+MbtWPciJz$GOx6^<78j0?x1dAnF1>Y)U ztRfblng<#Ie0P>fbQipL^-0v%AD_vpN0RkV-l@iF45m---NiIJqxx!k>mDNaY&p94@^-FG_QOQ++1BN7b;Bv`TR!Z*BTFE`DMRGIeN^Z_7 z$#IRz9StwfBXYGpk~_XiaxW0coq(O`unDCoYuSN${UECb_yk$-Ssiawk^+ z?0Rtn*eJOLbpRO)wn*+J&0t(|FQt77eC+SJdhDx*|5WOy)l2SW^uKIWatk{ocltcA zR&p<={)+j4`l3Yu8L#XNSVOrr)-0XDQS-m*+`=ON=fY&lQs6OwyVv*gZa?0j^d zKPI_W{ApbZ(02j#3+ezmFBp;Bg>wP2E~I|Ze1MFLHcPIp2B4c~0l7EB^X5hX|C`4p z_ZD=$WjPp?9M_24#qeCbUUG}eKs(qdIj$4AOOW~21)vWMN$%2GutIX}=(`MEZ(9R4 zN$%|n!Ad}V3G$XK1<=1^OmdfZgK^2dvqN$nGr(%ey^H$0D?mNa`Uc6pXD(<1(7&fo za-9OGUxBxy?>SD zZmI+;B=>=8K-p6cko`f*54Hp7Z(abPy?L|bZm9uF0s59xUycp8BKua_A6f)x--Zt> z(6wTXm0HbD6?^n6?Zbf2L7L=V^^xs@G&@{{!6PXF!o zpc{-z?v6QNt>jkKfrdj}-b9Kpwj1++=-kuuOHxkncQ;xXC+ zHcRg3*!XkGU(o&qw*ImQFun;JeuWLcS^}_{>tpWM==$}TVc^vtF zssbw|$2B$gXJq^Zn!nILu>ipL*F~UDa(}A;@IH?2$5((6$!%!_j6K2F6VN@u_!AS7 z`}<;h99=B(^bI}d0>;ooIT>1iveru7J@#Bn;HSMug9;~ zBj@ZYKtJcM_?(pzH&=skiO;PCV-mjs-EXV_y%M)D*3tnsN_<`&fd5T%z<|W(w@BRD z02sTV9rR0l;Q|27MT-DB+K|(>Mq)loiQl{ej7a>JM!?v`j9m=f#f)D(A@SnH5?@jY zv>cT9t&F{OmBg2pfo8By;&#T{8E;3&WsF}2-`jd5etQ*ID)ACzF6ox|9Wwy*mt*HU zs{v#0+$?d&Jg{2gcg+V)pcjlw{O)!zBJq1_!Fq{18zsIX0rg;5;w$m%%6>2@@m0+L znl5&=)De|*U|1CllXe-*F%3pIe_N| zk@%B~z_7%(F9pc>r?E-mI}$Jl)Pq*A6s!ef z60af#tI)lw8(`O`W`Mtwk=+-2l4-m`Gw*l(h&&OXFkob$u z0Q&w0K>J>F-HXh7$0YtzE$9aHf0_O-L;L0BU{vC@b)W+fhp!<2EA;@rudDzg5`Puj zz6$+U`@yipUz-b-fYo4&!~>0>2W*h|>s0{SuXlnqU_#<=%m?jYlf?JIGq?~?-VfjX z8zufPWIX`i1MsiwllYqzV5!6p)_`G&InTvI)Q7sjW{JN|EWW)`;)fD2De-r(m9t#D zz8)a&yU>1jmBime@Au&S-fD@zUk(;ayaApK$oTCLBmN6AC&~crzry#|wG#iWUgF2$f1LW3 zW{IDm{|WT|y+>lsSn-n^B%Y-HR0E*CwN>J6$k?_#V2E;366uj7nkPxFL6Ud|pdR;1 zk|bamST9LlKs8tZXcrm*?{n@^0ifMuSdy~209j=tlI+s)__ftJYx|U zlB67-@^MM_M$X;?lI(;0eUQCR2iPphzHW(|x&d|^Lj4f<4jGf=neaYy z85or0&;-D9Xul*?@K-f}J}@E4VG96y4}<4fHJ}Y_kmPXeJ$$ny)yS+~Dap(-FcV6tqVn=ctX6%q;`+B{{klVE57VJsZ29jV{h?$#dak&o`9VB^8o!XTnOMfk-ig` zfQ^!z)CwjfscQp6lDr6gFIooZJGmWoGY>?y>Y&vC= zB=z$EW2aVwK1oia{xbMpwpNmblnar)a7>cZvE}qtlDxbObO3lcgC(zke$iZjyhY=Z zymB#EC&?N3f5vJ_&V>F<=+9g)Nkb)ADaos#f7J#_&Z-A%!Kfs!rtj6rZ>#{=*f=1` zYq0G#-2l0-?F7)hZVi}_qzOGulajo?6)=8wFQ7aJndiXMTn-ii=+CVH(DBSGdBak$ zQIa>-faQ|3U{lM0B?yb(#>)FH|F(4UXI*7<<;1p?Mf!dWc2a7dDiYC*pwZRluQ zDGATAk~bsw&Et~1Wuqh)BlqIXk}RGJ+CU$meF^-RtdQib^T0B&L6S?MxpXmD4d8Fb zj`p=+Op?p+Pi@-{N4ezN2$m_(m&QVFOr~-AM2aHH^C9rD z|8)sKS9cYF_WF5XK$066yOH{h@GL{tGRpT?0LE^@hMQJO@&WokK-q)sJ!>WTApIYt zeKY+xQ{F=VEy%oOOp@ibpc|~0&lz;)1DQG@L-<=hpU6Q+~J8YJu51Kw`K3xm2j4vz+)exLaY^p!0HczuX#@0sp7?ye6Cm>o$o#?zNxoPP8US|oW7oZNKr0|F_imBo zON&6CBwwxr{gQBQO4g$1D`kLKeYFy-k>qQ&U{I2QxnP+jUq|*g7{9Mxl0j$(;TeQ( za03{ZUmq_wMd>KZ^Ftk5fBgv2H|DRe(He$<0`hK!XlAm@< z@-uiwnk0F+QIbdIN%Cl&B%{#%yhf5=ECg);*}t3t)=IKzlO(@^jx$U0+vSox2LJD< zk0qcP^aJGoz6|t%Et32ZzVUUE{AogxKaWWA7y2jA^Vc~5-G3!se_b!h-)R30d5?EX zvSlt<1vX0ZL^)UhmVzNk_*^FWJMF)(0LXq4KcAcr@cGFuuo4V{QAs8RAZxM#bO6RC z>3^yW;OA3KpbPW?WIwf8lC6yKY$@5=1BNBpRtfNJ8@$^#NnYlHW-u)Is0_>pZD0i$ zl6@?Ed>OhpE9LiW z1<2ov@x9RXj0(^#`SNl=dv9d!jl8|Fai4_%o_!ktJQa;#Js6Yxe$@b3`_aGu9KhKA zYbAd`4Oj_=B|l>>K<|t-l0R?;=mdk3KL{NM%?Ic^Xrts0t^|t#IxEXTJAnTXWF68W z`DZ48zGp&vXc<@p`Xygg1=dUcuz6sG-Y>0O~V0NPZSJ%vvk?+1N9? zNAh#9cTP7Lm;4df#B-?pkxRg+q~8)nK*c zpHl(4B>&tQ0KQ|9Q(Fo8B!65Z7?%9=%0Qjuk5^#J@dJ{dR|TlgTLzFbZ@uK7Uk8x! z{0)+SK`mGVHcS45`Ct{mj`?i>nJ+{p&z|xx>;=%Dh&?AR2hg8H|4GO^XP3Fd_LDF97f@r~qAH4H%dFOXzU_kOO zuL8{gpEx_^UqSs9Ba&ZK13H1$Cnf*NW-tgwC4UC;&Zq_p06NYEwWy>S@KQGB>#GNUOy=L zv+?b0`p)T=d~?6#&xQWnVadM%`Zq3?d<)|()LYg|{=6nICV9?G`Sa%jXwP3K`PKzs zRPq-f^8)BESOS&<{JRj|3*os4+b)8pZ4rRy&2^wx@^69XEi1vWE&y#OK6j$$in###E0KF; z2Y~LXdH{bHeOM|Gp-$O7d4Hpc70;ekn4SZjt;oDtk(0J3jF)(0v9?GLO1 zG11kXjf3Ox%zgYk@H!lYpC4Wm5Xap<4sN{JbmS5fhXy2NE2G9$(Nd7~_;X^%u z`fV)$n%l5p#eC2S1||Ptcs{%s3`_na=;thz|7blx#z&#;T?FX+*b;zUA0u8LF9Y;{ z9NC|!0?Pn8RwCn*==tQB8zg^M zBY^I%Udi{(k^EfwaDdJQ~oQf0X}_o31Iwd z^T0B&N%8~m4lDf3K)AR0gYf4VCHkSBSR?tLQvR$(@*_Qxe;B?; z#wGtKem#o+kD_<90gOog=WSp@^1tYk{4c8kw40Vn{#Vfcx*Tkf{BPC*csT3jHzVh_ zoq*UqhK$EHOa6E8jwPTQ3`_p^6@dEh*Gv8nt0e!&G63KBM#=vP-aj+`=SDCj`M<1| z{6vrB|Jow?ztu|q@hX76E%QJd*dX~Q<^yP+z=pps0myx_37~6o4xn#xo#daI0a`)7 z7`x$Gb zP~I0rngUeHG(XtEF&QE$9Tuc^36&Es?_E@Kr-I6P}rE0J*aU zr7#=%IST>wbJl=SDI8G^;5mxEqnAqI*;Sxl3N`4hSucg>ESAD^8>MjUd@0nHfsIl) z4q4Az04R?im%{Ur@qz{^oX`a(r7*u1tdPPB1vCNZPOJmVrEn6oC-q99j{1v+rEu~L zFb^~Wcuq$Ci#w&T02vF`N#P~Sz;i*Qc+CvZ4JM`V+BH&m9Xzi?&g(Ww zp$Yj-@V_4Z*VlkffNf{j1NzTK*Ez^LXM+@)>1)QW=5Z;U3*WgLrSOJouoN)<#(AIz zpu1%O=$FEIa{#)}L-(7IbN&pl1fZi88Li6zV;3-XVKYGgg@aPK2wfK;zm2{&^u4(j z3`^lH@V^E57el|8vBfLEdMRAe2cUmz9at%aO9eo4=^81tSA$-#K?;{u0QxUO*4t>m z9b1-Ef*~oqqXA4v;c{fYbCDD}%D`$VylVj%kixqcf;Ccj5AxoFyiR0wc7bszT+s^9 zeU#s?Vhfv#s%3LixF z&DeYMDljPp&L#!UC57dEQn(e_x2}`Ihw1_C+jtiusu9uO=8;(T5ZQB&s7GX5uZXl- z>07y`t>sWoFp`s@sK@<=iSf{@REFFDyQrvSE8#(&`#q*Z<#6;Io@*-78=u!?dc6(G zXK-}T8P;5Ok*W_t6#=hol*0^g;`-3iT zO{=zu9J8gh)K-lf*jn!Sk>%-Bj(V@&YPpy8yE&X{%i%Ixj>4j&knA|aU$w%uO-gE! z)9>{7@jwT)=N}5CZ;?q(0xfTe$%V?zgyoVO51HV6G5Qc;no(3k?)rR}J!8xEG-LCs zIb9Dv-m>QbMi=Y~ao8rq z#{3F1`5C=lg7YWUqiZkZd63~}w$j%GGw{RYg!y#5Lzdg=T6go0WcDPTH^yyGvVDv})j$q8N!#X| zPl8T<;i(DRV|20`=*rkyp3XJ7qB7C!#?yXVqZ(Upb8$T|hc*YcE>nFrtD!7ihuG(1 zQo8P@&f&hc{++d~akbJ`mg+KnX0NqPerb;S+)*kok(?^`QeDhlZa5i{i?RMDoSP%l z@2$?vuEj@Vm(DpeUQo)Ai+jr6vY#9%hYvw+J zK2e-&oBI$I;W=#92EUuio(HQ1&RZ9~t?e2Mi>dZ&-Nl&^M;CUUtcP$xsn|9jdM$M) z^=0w;r(VmR2il&cUZk2dn`tYL;|puR`{nbO5u>6sN^}pUoQd{^I2U&?&29Cf$9bnY zp#i}?L z-m<6q%r<8a&+b$I^5XMI_T0~}y5JL1l@>ZD(aKaZy<6K|G-?7xF{;9Kmhp7YoN~=I z2`b&$juMTINm2b;Pkk-P7uy@iT4$Nx=VXW#=VG9Lb%cMuT^eJ(`nwnh{~%O5wB_t@ zSr9x!lCESYPi3lI;re3wQ++y~T0o}hxzL^Rw%bpkblQR>n_c*0m7pg>$K&^i9-9eo zul~()yLdUhe%!}CJzH)U`#|Mq*Z+09jrIGe`j+h!meFbK`z$7bE1Wh=hL*0bYj%k1 zgZGECv94JcQ3Plv*nR_Dhzj=O&Gflr`YmE^J!{#mZh`Pmd4NJ zWAGrfr|h@IvtwAHE=PJihg#xl!IEH4FEq|C+iT5YPKxMrUaPM8YN6{f&5~K8w$r;k zPpM3b%Jy^PJforO+%nc=TIn;@>rJyaT(My-?g^GN_-T8r$`2O1RpP8r53JW&qI2rB zJD>avJ6nfrZ#B!|cX2^L@g5>}XLEOkqd$zhC=;EuWIxc%3D!7GJ}*?Zvn!Mu^Ps(S z574Vt(38r=!zj$A`DJ@iY5toRc4qW<1bAM&MrpQi3R6qnj;iyL)!^0~=KyE1UlB^n zKRw6!{0|a5pP$!MUX7d8)YGEp8U8)7U{8M)*0@aNRjH=m`BR(+pXsvazRKa^Oq9JB z;cszI4D+ti{OM1v=XwJtUQO#um^r`Ox>;6V%pT`0Z8B72fo8Xt6{G1idArigE}oar zn`Tb=l-$b9h*Dsk)2)A1j-Eq{*Jvl-k59dp+1;bN1IJ58L;QT%YrdtjUBB&eW`E+-M#^O33W-LzM-O=bNt*5tG;)~~3 zi!&5qR_XJ-={h&6qOE%ruc289+j@((PL*v|s1CR1`W>h|onfxs)aP@bfNj&9%fj;z zJDcfTI?ZOA_Xt;gzuk!hPmBE_3)K$QXxCPir)^ssw$f}oJz3b^IzMFJ4rA{%E0wb| z-1VWyS!#QY?LdLb-3O@cZcW0g{~Ui&PdL>ay9NiIDErsKqC&d9-@H>Nhn7 z^AIw?p3)i><6$IoZB6spts~7#X3yud*3=HXQ9Gx3*5cxgP8VlqiRW;Bss|x1sRj0A zF~rTz;zmEMU09*xsv|exvJ6c@v)Wa>NAUZldj{m~F!??*_+s;w?hkGjkmo6o<~+9E zbWQQ`;+nKa@woI>4UYgRHq?FoS0W61ApPOGt=OO@4dSB*zb$g1p zjj?c|busqVZl_^-dzfLRG(X^V()2l@@74VE8DJ7i?9r!MJdJQ`zK5~xA~xlY$4d`u zLM2*k?aZDzm*_s8p8Iu9ZBNnIC|{8mwaB#Vt)cggAi$t zUD-4?{44IQI(OM;jUlUw{yDF`9`AwE9IOvI?AguMa$Om=5}jq90)8i_c;6B3p`b2} zke#t?AIqGxiGaTra5`0w)Cz@@5n^Ebn7?Co{&I~;W9OcPx|oMKcQTzdYN6$h%}U4? z)xnx|qm*_}5AROS%UmOz_a-x4IS6p_DP1PpPUP}1H3BCslU2m)H#OY^**=V45%Dz;*Cv%ZvRI>!1RF;=VpW8!y%XIir7bjc!aHda} ziq|8*FS)y=qCDl+mT7X44H0(nFITNbAF^tP@d|8Ta|4s3EUfCx88ob2)#*I5$g90X-y$D0@2-Ag z$W^b&>DLphe+uEa%{#M|w(Hj`jvv#%M&(zRYwfN6BeMyg>=a?Sd6XO@$I9{OIo{Sl zQHGag(N%2<=PhMAC(a7j?`sx`Ob$9pW}D51%>!IsZm>P%e7ZA-bGcpDlvXKi+}2Lf z?l8~0e19ffAtzGF?wX<36Ji=Z&EZUF;N_G81Dg|loNt^qO$3-Z;`i4)}gOt=0v&in6+-DNo z=SlcX!f6T~q0eb>k)dXuV4a_vFvGfMYL8`%@$orlusFmhy*3hqDbKas{t@!X=D}GK zG-T$)Y1SyHOrH}a9NLdXuGi)!L<2j04>^;r|B`pE{A}9WD7qiG2#S=c&S{@t@Gg~I zD{RM3HHFzysTvK7ox9Ft+UZpiOPz1w9f>ry?cOf$H#D|dTpU!Jp6zw@hx`hkl{vk7 zl2hBmnb~ZhmpeD@4?M*=@$VBI!+vp$WxAb5%u?2+Mb(uq-e|ErG5R#Gyp0bi>JNdP07iibT>5qK&`QLQZ1^P*>e4M zH8kz%?4(a)yd=wGi>gIT&GxYfCBdTYpTD@z5Oh?%R!*#-<>EM`bUS_5XD=0<$wj|I z?p`K(ZN-f7HijL`GRf9V>T{R@i;=~Q7&}fs+r~|#!)Y$f#9^OL#n>nzOXePSY zq-&CAM#`!AYb%latEtb7{7Jz0ZB9aFBh$}q_}t%VpvUZ2ok4H$K0ll;cC^E~b-`?f zlUcY1svf_(?dn2XpKsNKb!BH3wbZXAXGfT8mxC(9{8XCMI#0=8dWteL_ZLN4=S^4v zK@7;F3xV=p$c-sIhwuKzlX)A^Ha|_mPd}ye-f>-Lp(IsoUU-i(CfR;KT3CAb~EGV z(Y?ww0-Ln^~x4=0ePXGeVpIjrE|8k5~+?5 z7q!{#2zm7+^Xw;$v&%{MzNwR>y5P~eYX^Uw@ATVFmDw3x7GtTuKJE5it%_8tUAata zINNZVwy9m3i&m<{f6BJ>o`3h^X1ZNg_{{XP9%ANVyBqPdEP~#7K-4wzydxUy z$iCxQoaM|rM>b1vO|hW3qXkJJ%J#gLac8&97*uXXy?!UHs5^U>blIhTTcm7H@RD3_ zIu>NwE@}N@r zI|6S+!B5Ik+QF(5bsJX}ld+fw%p1V0yYUV=EMCmVMXLH(NTY)M~3mTxIU2A1YIA4AIK!FdBH&uubXHdtKLN9Kh0*_v!TGavq1k$Df*ELItT-bINy+Cj9G zN~Ndtp0Ai+CG%lcI1N~~y+)<5j5a&cykggJ8Bexm_GJG#g1?f;o-@;(DM&Y+CIy|& zn{dr=v9k4#^x&ztO*2e0wDhh~`&6#Vw3Dn^?fMzx-_*~KHQwoJvz2C2RIf=giyckL zDT@8r?J4&8Rq)2gau@pGbl$1;yVmDDbZ=NP$J6R7UKjmm2HRhKER(`{%zNauYu!9H zi)^h}zG{5E&EapF?T(voviN8~HPse>RXB`u#bLU)d1^0XYIMDqrFK9Q^1xFUGhEwd zmD1?7WU4K;mu_d1oy{`O%1uwOFFku$fAJZ(TBz?nczd~L3-(Rz_tv5r$D!E%IeqrC zMi*Hx&s`C1&HK#O3`U2>*Q9ERrA~9E-?y<(N9>*`J^$I>VJC7c9hb@u(#hR$UEg!+ z3Cqu(*^sqK``ilD6_Mt&r_}yXGfy;vu_)A{K5GZHCQYyW;SP~{hWi*STbkf z^RjexW_BcRzs*}{1)DA3?Og2gOs^Ss!Vk~W+=-EX+riw~L?c$b7V7s)+#5MwgX2Jp z#yIs@_r#EwtaftI@>qEsRA!Q{l{oYCkA2SP)>L`Qm3r;>F16YD;IqYasBdvKD^hjn zH+=nkXXnkoS6K3`&!WX4W6+qc|8g(IyhJlT8(cKmrF=xvoDNrEyDHmzM8w1EPrs#T zaZ`C=CAxX@a@7j2OX;T9?4xSeeKK14Ez^tn>h{Ol}0 z!kw?#V0p1KTXdgsewF4$h*C*@>_ofEdd*HJ&&hO|k@3@c8uYOq^cq?+J8pFlWjiZo z-*d~JJ2KZ7H-E z(p*F#v`h*8UT1nwT^n0r|qvc6Y1Wr z`;?DJ%9&;&erERh{p_2y-fp)yV5|4CM61pPyk4`{uyc)0X5iZHI(9&DUzpDCu=}JM z{rO|6MLY7JIrOssjd$5dqN@mG@ z7Bl5@xUAoSLo>&7rCH{80POSqVZL`qX5iR9FTyo7vvR#`J};eOr#)YBd7#o9D4ew> z*ZNB=&PaEB7D3qUnMYGtfByZfsakAp*e+5c-OZP3=AW}>`ZJAv56~=dw7Q1ePLj#; z;F*s@y5ENxnsOSD*33!H(UUbgEA#E#Woy)xjFha0z3o>aj2;S;l6ZJs>Kjxc2B{tCIoDfihbS^sGyG_qmlwO4(ohe!p_Gg94* z7Wa0g<<5xJpN%oxfzFR3E1QRQ_Yi&&%JvS^W^)UdvE;*pxw1xNSy^Y05@71QB6-!SaTpt`K%xVkuV2Rgmv$OqE5I-KM;dX02 zd%x{|14ljOd6eBNcwNQsqB!r+43$dKb>!}Wi|43xeXBl=r_Qd@8c#Zd;lA9_X)J>5 z5F;XFJxak{dir^4kmtQu9dO$25u{nZ52WXb(%-OvCp>qyOj8?O?jhglMpm%NtqJF| z%6E5fj(;cj#CDFER<9~>lC+#oe~DhZ*4p=2ndK?^(>%)h8@@s7Emo_icx)LMW;nGX z6L*WNpE)n5^cq5*k&)BhGuyQ!&FHC?*xFLf4j~7ia+c~}2P|^?AuC1=X#=hS3v8JIYzDKV2%i%eY?k?#Y=jN@G zLtatZ6;t`~n)j|#&t3f0G>w0DU6tffi7!DS@n@B}Ct1!mB>0lQ&cBivvLCq^xY%Kd z&Y`n6e2<5A`c}-;xRiKR{0z-~3*7B;*|i+3QS1DCsWsZN8CU7ZEPj6|{dCIonnqV@ zbb`z@n&~~W?XDTw#b+7eDH!>y>n+5?WI6v`f4WO$Y;-n<>{BaLg3mig9nSQ`GW+{d z?u{hPTjkEe@2yUbMJhazF>9PY)o&|8XUM%Dq*rJ^)9H-u^7>|L$JvsJpGr5WT6dXc zR~zj1+WlYKv(xB@v!EY^SDzN*rHifl8^(8a?fs9jt+>jj{_cRSFQ28UU&P8~q0NG| z-Se*yOScxnb=2iDvA4ad_{`a7Q|3HsCzS1evC_?tuA`9uF5;nO^GH61Y;#${x8sz` zX355A+gU!$v-+WcSU|>JAcCpcmC?{T-gr645Yih+l4%Z zp93GeZM|++)@-(WB71kAClZdHIJx~S%!AFXi!vHqySSr5Wh;;S5ql%u&R50f0rs3y z--=|f$Tt%vV0u84E4mz_ieL&IvIBFW!kk=6k`^o+ujoCcS6GZl=_Y* zx&pnQf4=j?6LoK=y^G8`HhKKsnEs-y`H}hlfLUOaSZ#js-e{^b{T_vlDj!yOTC-B) zrN91Zdi=Yi_Uypq25R%c)^jFa+sP=6mszpB)xjVA9a8UadTm#pkVV^lV(i|b&CqA{ zg*b;9QYk>?dq0DZ7RNB|X2;*LP3;Lev#a@L++15>7_L#p2QpwI1L&U4+Nc~{EU z-EUg@y*BKsnd_wf4rBIiS#1e>qtEH0_kO?Dw%;F7Z~4hTMoOtqJ$0U_ zhwBY9n0^P;_)OY#vP*5yNT`2B3$fWUAe^Pq;nt5@V*7#0FcZqb3&~Ixb?C3VHx$te($x*#V>o?W7_tJO{kXeC8_jfPX zN*_6Q&p{L&&yZdLGkSsrrbnZ$G4_9*b<^zo!RjyT~di+K%KpihpjeaBIMS_o8HHOIHyFxH+)Z5$q!BzUKD~dly5g zcVzEB8;9aOu3fv`IWnwBf7ZZOTdTGzz4h2tF#Je+V9T*M&U;A zJWJsu_*Fyw`hc|9v%gQ);&6!u_kAS{U&$*NSquYnk8o9FOg9ZYFI%OW&)3Jglv$QuKVWv+wkjsjkd9 z%U>PBlU}@b_G@H(EkrhRho}5$6oM7jw)Ji6$jufrraPF{kr})R(nDtYcX=K4)3eWF z;P0u4u$Sw#pp$>vvm^V|Pt~g9TAH0UM;7gjeeOAVy8qh!p4|_dJ-!SrwIJB#X1XXf z*cq(0=-d5e>P^TTlab2%Px?(;&VTc zXB%4`oQ6z?jsx@6myRoQwhwYL&xIVFWvfQi`N216Gi!FryMAsD3ww`0H#xnY&)eWv zUf9XpdUpBFvpG9c1p9qVI4PyiM}il@?xJ_zOS`X7y^fOK5tWv3nyZ{mdfR=D%C%{PEXj z;_K!^^K-y^U+!0op#R^*<|Qktz6|1gVTmP5wq zTyMwWDDA3c`>@$-wy7PuH=$Rr>FKAnx(;k^vXZT?r5g|aBiHF8le~p?dUK^xYqpzI z_YUt=Pm1yIzipkq0~s_0YRz}MBCDq2Rox=u?b0z1v($RD&DAPAhs(spYbeHJ%DmVa z&vTn>%5WW{=H|@Sy2Uwj2Occa7!V7aPsin`ynfqX!*4J$FK+#+^`)NpRqOW`Hx@iD zTBla1}1Hr*Qsc;)=Y2Uj9PcZ;8sXtMgO! z%C8xs{0g@ZhIZ<=MoazBe{j3HmSj2nnI2cC*HdU@w8jaFK4QG9=OKDc$i5#@`~*?8 z>o@Y8Jkzh#t|yeXKiS@kRyS_ZbhECK3P8_e*>^zPnz3jS5yxqo>lJ#zc!gQr^%G#(aTdz{3HkL$6Z7^M~9#$c%EM(F4Hmcq!k()q*QHQY| z+Nk?q>2LG8H$XIsW{WFBD`?V|i>AvCwAdV5RMTjLYrW%B-%_b=4*9hZ@=mYeHjDl| zq1v6)K(BnXO}oz#=ck|3FqT?jCk)dbuA8ZKZnoh!y5i?^-WK<6k=IEE_>2s9GWH}& zcNDcp3`$M z{qKFLb!L}Y;xoZ|)4cQ2%}OiN%n6n{%^6893&?5n+N}4|Tr9mN+q=#B;%C59&csvp ze)OmvsmCfw*H2g@mYqH~eAGj1GS)f^@mb$1@}qYBU^QbE&$aCOkayOB~Twe7$b3D>7%J>Cj$ul5!#WF*Aa#X0MR`mHmU=*X03aqfFWW~VQq z^QZXKdauoP6@1cIy3b3TrtrSxlxH!SJ2myiEJd{A4fd#wsRvG0$S6DcTO5?%aoP@- z%3+P+^%S3iZrw$uL?`fQpT^Oy)4@A@F7Y#*aL5{Gv)Mo^_@JK%P1%pK&mWGK=Wv~V zPMR;qqaHIKmJ2G&B$_3*KcUfQak!6x$4P!WnDs2+M7n4bZyTaRUf&4B4vPRHZ_ zI&SUBjJrOIsk1XPp2`cH>Z9Wi|Eq~x|GEx%A|HH9cVx{L(_?g2dKo6mm+4%nJZxYN z!YVVXT**9G-emjTHOg5@ulJVo{!TxKbN2)8IgtB20j9~ISMr_@<|Njl#=Yl?lj63c6nI7`}oN`4BnP&GxP)!}D!+GxP zcl!Uu_sp98)4e;OUK5*a9^0?@6@P;^WRG3h-Aso*>MoDf`cnLR^V!8KSm8BWk1uza z*Z+V0?On~?oqdL_xvOXJ?LXsY&62_4vo%{A{_3C^9&*T!`_CG}XL-8X({VCh-)eI5 z^`xioUUBtzD?41Vm@~I$vm3Z|$*5mf6mC|L;qFng?|>#Q>mELz33Bqed1`umqt z=F7`;8j9XKi|vZ4vK$q0aB_>W4DX?v1)+3vXx32fTCU4Sm(M)K;r~k`vgx(e&9~aZ z4DXzds3_O=bebD#kFEoreR)~x(=_sw&eQ5&lSdzWGW`D!d+#5*?UtSOJ(Kfe=FOZW z#zc)x#DqzRX(CagAz7nBtKN6&h(uEw$9*NK;Jdlq#LlNG-KA zqNNAw9~O?#f`utqu#kc+DaK!MG?`>F)9Z6x>)LzY&-eR%&pXLf)7bCJ^WM+B@4eT$ z*0t7Nd*A#1@fcqu!3o!Z^#5xq$(V80+cgv8uF17>P4pWna4EiJ>N4y zL>VVr=e1o=CGuB}$6oftVdN2qk(amMP}BDr+{s(@mOT2jb57+k=9(9cuKG39BmOpr zSkK%f{Jcl~iJcdyFD&uV)AE2pPTiPz+%2X>u2z!W%-b{}`& zx$<%44}F(5Cx6b*t}i}}U@^FJbZoLcFH}EPzIXkJuZe*dum7n0_7D7lEi)$6yWHy} z-Z%ay>TeI-)kkLghkfo5JKy9H-NSs9|D5^@|K#JvKQnyC2obmDM3hL6q8e2A_MBfA;#roBaCT_MiQ2 z#ho->`{~5S`1!>DpuKd5tw(fU+xz*#)gOiS;=^UbgHoY;K|e-Dd7PZHA4%vhG+{T*ai?o(U{DR|l$Oyfdvx`4t({j7JxMH5 z>+>GoU*GdEexFmnjox30vE10hxtG7S=Xrfo_Z-t-bZm_a9PbAUcg}F%$L5a)quS;7 z0J+lf4o7Lny%aFzexq|fVR%iL-)u=R$r8sp&vr$(N~9}Ci&Z&C_V&ZoHPuKv&gp{L zW495DANxeVzau%qgB)6efH?6vmYcy)LU`wlLb$gw~S*xrzihaIz&ok|$iHM1$ za1pD8S?5(gKUzGKPmOCVyqp&j4`5R)tnSltIpLEm0_*$CCNd6P1rZ_yz^kC zvxV7*TyumoI`v#I%qq3g}ho$-v zTi}Ev$m3)CDs^JMc1gE>*I*dCiULNWEv;)KQU=ZPm9QZ{kuAHX|IO-YB<{Gc zeU(IPjrYes?3%tmJy>h3Zy-0i(a-0>IfyZcr>p~K&1u4grEw_YAZaa@~)St2bq5SQE)1QxX@R)y#ZMH9ia@OHKsCzDR zwcJ*mIM8+VxHLY=k}V=4jtFp^HOkd@vd*Q_y`KJwFjl^M&5@dBWma#=5!9Lf$9TMC zsMO3^2Ce4)C$w8i{?Bi=jSNN_=YhL*eX$oW=znY_^HEaIs!XMl%5%CIlNOGnZtAFM zIGi>}HmAh6q-w4;eu#|TIg)1-B18WhN6)bjJ}CEJwyCcI+dMdp>8PjiIQ7=G?y3JA zERx|iBX?y3S>bZ~Mc?YPL&p_MZ5STPHQXY}vmE@Vv!F+Lxx3z&R%GMa6oh>qV@lWP zsh)1UA2FdL%x&1N+|&BgYF!KJoe)z_52c;-IS%;W$ersv z8&THMv;KJ>@<+;V*2O1oeLVJZoLKL=x%-BWV`s8K>SbPV%8y>@p?B%}2AF(Z!1}e< z_{Z|sX+Lw5;G^#fyTSzH&^{0#n# z!Ly$4(qd6Gfk!iuJ9+5f2)HIz$OhFR&KdKoEJW&x>F9i7eO`)6z%Ws(AS0 zyGN_#Umxe0(4)Qd48PNU-4hV`vh^Dz-|K3$*WO+GtN!}G_}oLVeDH~fyY}=vMe`ij z-u>~|(c^dbJmhU6n&aen-T_hjB>8%L&dugHKDj%dyxil?;o_b-nC0*I$385-Yp<-l z@x$EpI1##!n|Z$trShM5Pe{hEwpVPt4Fci>gtr&|O)@d;T+qw|N=kYySF!HnLBGo> z^=C#n^rKxYy8isXNaJ8!?|_WN#s;PwaAL-YyG z;)}Q37mQ!}ye(e~*ZoK%d`3F*j!f_N$hCbRk3D>!kB^t9>fiOFzc{iNU8lazY6eBe z2`Nd*9znK#e@lLH)?&Z+_TqPR)gQgTulA3WHBvX;oQq8f8$7{`u)#G<6!-Ab$weI_06(nWS2W3FgB1>A6xeMkgI)cMqTy?TWlKawOz66 z@^V;PmychgZzGXf;^d(wtmUz;6CI&(9bR>v*>XY~E_pGS7}7&*WGf!|@ItkMU& zPwr_s+cMm;_{AI!=jZpcH`fO`zOReDJXrSoq5Z4Rk%|s~$TPxW-_03a?%`)8sWlG0 zGe>7`%~8&je3Y|Gp>%%E^I|^}-r4x_*tFlL?02h`m+@rQ@O=GqjwI3#ubC@&R$1So z?AGF6e|p|kal>;)x#RVCvW6CxN`%a;Q7tm+?0L>a628PYv_d92JP!DHXSHiq=yTVJ z*V{8a`P!Bbx5cowLaw=>Nhl^V4`VUtYeV(g) zwtqLgI&vk)4A9G9d%uHty^CnG*>-Hp@`=6QU2mQH&R#w6z~b@DI$kZ&q5pS3ScA8q1kzvHZ`c{Ly*ehi+f1IQZI*M73V>EXl3WuzQWmbu`C2A{FW6 zw#w-UD4bzy*S9BDZ{m3U#+LnqVeM)yj}^|Y(X_{`i1j;AjMYeyIrE~U*}q1kq6!*>6ckny~JJXg*8vG~1#+p{lD<{O*DCw0}@61!cJRr=|-$ET^W zS$*!9TM0-vb}4C3aoNPjvh^-rnxEIT#(B%HdYm~}J`JANA8@?pqhp`+gM&Tea1@MX zvVYG&!(~?>s(w-MX_K|ubc=_L0yZQ=0 z^*;Xk>Gb|Z`s{v>3HKMiDYl7T{SgUkUeY)tc4W=nxIX#1zAt0+ZsOB_u)1cp!@iO0n%8D{Pq>5iO0_%Ip?R%}pzM{k~bZ*!qrlq%_AOf4FfkF$x%J zsjz}ZIUn!Zrg+#`bta$IMXo*bqPqJWBJXND-uO)$vn+PjR`E{cL|!x{E|5)Ww{Sk% zALd!#SA?7;R~D|TL}M4ZaC6M;Dq3qr=ZuOlB)xW=qxG&A%0Y}@P7U^2&NbE`H4>?OZ?z@BKSTX&D6dnNq#>=(*P*Aai&_WD6FOjc`_J663TJOA$Nl_t*8+)|2|xL`{zJM z?c^5^WudIaO8-`oH0%4$QO(B_rH-2BV%jLWmj_pL)CzN#yh$XBbSzuB_V(-x_8a$B z&z&pbi5BE99`MTCX{2x0cxf)}`9|zeH6+--@u|xjC-vcu?=aC(r1w3o_>ib%{^@tM z_~dK-I%=a8JOcVbmYlqW!(* zf!3vZ)vh+dI(LVwt2U4y<{{^TXWX47@QmcZiSZZZ3Ip+$nRZ zU)F_VVLxk(SLL0Qg3vKyf2qyJdi3v8f@UJa=V&mueD4Px&bi4z>KB8mtMJdL`N+JC zYl2!2>DV|uPl88(EYf~Th|?nTw&n6U`{2N19b4N^+Be$MdVI|+h8xWd;AaxHYy#TBgfdf;@SO(z9X!OXTBjv)_^nXL(QFQ4unqgJUVF6tf2Cg7H?M;*NiUK zwEm;G;0|2QnvOEb9E-uV&k@$yw)-ax+`mDq{+f7R{NNBt9klTc$lIsp`haT8y?1yx z5pN50?scrmXYRGGT90gPkPmXV87}l4O}b~9t)36#nV~tWrf&VhQ6j=^ku#jATzmao zd+M5#J~Bo{8tp1+)%FO`7)GD{>w40(ajx9voDyu3H#1su9JCKKJdQ^mrY4xiQcKGn za<)+Mn+T}HJ3PZ1aZZ0(a>Bf2Z+noaz3CH33|bJ(x1AfYb;UgWzp(>1)ZT5?UNSr0 zI-_9G$4^gMYqH48XtUpYg~4YrXKl^}W3jXtb+dt4Q3>+wdwm6oqwGMb;?4P-U$kwx zWa~0#@#Z+BS{we%IxlOG#Hi;wSeABXKsfjd8~GouR0IcaH`8n1cCYJLJn5iyr1p-= zR6YDdKV)m3%d8^7T&RwZbYzR??{awN-Z}eDt7*G>O!Qb^SQzwEuPZK}evO_n@fl>P zf#v$99Hwu!YdsHFYb??A7BlMMwA%A*F|eP>db2hU%U~1-9k+7EY zTV|e+ldi^2y#m_Ez4%)GnS9io|HynoHv*aPN#^^?dNd+++kv|i{oUtm_x>=OiQ zO;&uCvz0T5nMUH)KVg%GO=RWfrbE zYM$Ej)pD&a?L2>+({FjSwuaHP*p(&b|24F>zCFut4d|$I-5ozuFDz{25@8+KtYiJ` zd41b0J@Nd;zWNd|PJ5Wa=E_|ts_N|8Jm_T@vT}K3lfHR_cHBI9IbJQ7`coq?!BkCFQdxA$KgMz14UMh z)OPc_&J|YAoLEwmC2RVj?TtP4lh?+v#>db?T_4@&TIo9GN(=&He{da@^0P_vB{0<=qH#9d)waB$>QPWg(T-gUUnbUhnUhNf+c8p6TOazp;$eJL6p|S^9nCimY+-e5?!6oNM~oIh@tyj`k>$!; zk>8BuEiI0eS{xFzt}&6fp2WKLu>)7+Kb~JWcBeyH z97!DEqd&aSd{Ixg4>r%VysNy+OJ{yrv9#xtje_QoIX3I4zODc7F&pX0x+IuY zpH0B+&T$Jv5W+ONpUb%QRr^AR+=u*G8WM&0ib3(pv(jSH@!WjZ^G?ly)zHb#QS1i2E>EZVNd9nZhc~U)qj*9Xa3adsOdHw*T)F*zx#0N4X$3@ zn0g)EACu#DUfZbltl3!y*(3TQX+~d-iQe}(LR@@2dTY1rP5t3xU0L3<4I@`8*XvgJ zyx;ipyig@Up;~wRmQQC;;aH>j%w{UDd`gb8n&)C~DnrdGBPHl1ht(rm0TCz6YWPGx zqYL%?$5!)WWT^(S^aeWbBSlAH#Q42O1n7=~y&m`izf)nH|FoVZ-gAHQrtYx=jb{S3 z8B1fMO2=B}&x4t@wa?M}i5M|qk0{fBjsQH-SVJX9JSKI0wzJ4$rWGIk*~>!AnvUeE z)bkpTYr2wo%;RDga~IWp&*yPw#r+dqfkzb*JV#^9(G>>GZ|G5@lL+Cn_)~4Z>v!m; zKRWhi>~BqKn2)JVx$k8OBUwkyyzh~D@#;}(ed@Q~=$1aopK~W6aLvx-)Z@m2APswS zUZt8VvvE)P{dM8XUC6b)Inr_^0o(Ac&{;Eb*lX{r-`g%{ejpx+Ypq?ryqu$Wjw1B7 z`?O*-fM7U@#*vvUbFq6Na;aNMe`855L=G_nZpW1S5H|S8jIVvVWnxiHZXdvonb&7^ zz4Mja8RlGcS!Kb@~D&GfpgS-wwK|tw_AvcT5Xi)+lXLW`4wA zWcC`|(s|>l1T}0-Zl81xc6;{qjr29o9Hf$3R=sVMG)`K7#dUkr__S;I+rqT0uZcEn zY&0!vrU!04sYhLN!adcj){-yQbr!hqm;}4Sa@)iQ>ErtT)LB%$^5XBMfjxXS*w(W? zl*E_D>?=L&cf8(y-nGoejKj61^PI|8ZQD{-%d))Xa(u?OYG2-&cv|fDO2#l$#@f;{ zB8Rp2+|QBo4wYgxXoW(1a4)^8r}LNm1`X%Mb0;!L&4J!)a*4(EE}oS8dgbWnMPjt= zh#4D`u^LJ3Gt1`jKshRB?y<;nA8czeJu4C`5@&9;xfy-6NCYI)cI=`hBS?Fq#^vih zD7muG_Vr19FuCH)G4VrUi2wb~xj_Gs3+U5YD>LS1QKEn1!2LqricDM52yw6O=%NE_A7>|5dVO9@i^(U0X9VZj~B$Wcr9DJ&^tAeLYh@ zT37#Hy|X#3Ye?sHxRpb;P7pS$V&~w@)~Lj&A_!lz7L-0fEun4Zp6hb*5qH4&38(hz zNNmq=yWH81?BN6X_Wt;b@jdaUt*^hCuXvhgIQVwT z6Nioym^R-p{0^~dDmxE6s|rP78)v`uq|rFr{@~+MUKzo!y|JVmKiE#hbZu-!5cY|o z`+T;2HyV1*dETG<$PC6d4Hi&kA1nB_j*iuhPVMevg9s0_Z*@c~J9;W!67fHuu3c{)X!(d8=+mMIv+c-^J|<@Ym=Pep?W|@>ack zJ~O(RJf2~4zc_kU_jg7cJi~IYTIjfO*JG+B1o@wD`rEqCxuoaEjU#F{Cq$C9?HG#8 zX33VPba}A0cZAv4)hyon?KSMf*B<@tVZ~$4hmFj8 zsyF95jq5wij5F){#*>)an`|>@(bng4Z@wM9aAG006=x&7c7Vkg#~Tadc}{$}UPk`J z;%Z_pfrLs1g^w$zvDLmgZjT@bQ?j20X3u)vi&x%qE7jfi(9F};mY}*LeUL|LIFMH7 zWP3^9Tsn9<>Re(PYdS5 zW52$_#hfcYxQF%rJRn#ad$+fK;*E}Nm2TUx4{WFG-boma!KK*5lF9^UJ*t_YCG4zt z%3V6|b!6tKXrVT8%Q!aH=cmp_$YBRE!8mN4dNm`|k>P61(OlaR_n1W^O)G!zVG)rS zd-Tn7!L1>-fNId8bM%5VM`n!LEUp@ArRU1zbGOGYpQVmUYOZ=($3pno>ySxlT^Wvs z@`8=>33l}O;g5_J^ZcwmKWrgm>bpcfdV(!#9V|`zBZlw%Q54o7WaVgUq=s#ftd_30 zdVQ_Mp5sXFOUy`ed-hc;GmZ4>tQ6@q&KWbzRr|mC(^wj8_?!sc;|9kwW*`@toyiup z%XLhDbMLF-xYsCGZ);Dh6y#P?5yvOls|WWl2XRz7V@q`vyiB0*q z_upRh?Xf)eWn}alQi+T0!N+C;KK_x>GKkt&YAyVNR2=00744DUXCzeXilukp>E5O_ z63(jcmEGts^JQk~TXWdd3%;TP6JyC03;L|%9#iLLGnYQ?Dp&XV_Zm0|d6puwbQP2`be(m=wC_pi8BuQ`Ci}XY0uGm&ZGM7`pIK4DamG5 zQ4q_*U^VXfK`qGfLt~hEEywl0k%*Uv`RU%qa3c;+pO(9FS=fqc-|J zvei4gDssdMJiDtAC$Bd+-y5m5a7zbufY1_!2GPq!zYuh2FS%W0>XX|LwOtr^tDm-kFHh zY6{|s7|B}wUo%vW6^*`Yub=eV#%v?3qj38&_KrWJe_d~UM7tSiHfXF;?{Upz`HcG$ ztJAk0*gbDHeIdJ}(Uzh;K7R^Dj@Ewd*^0K3HQ7J?a5)Qo=!ZMYt-pLW@|K<_eNsf| zUy;pNh|{&2*{bE4BxPjp(IW!g`NowjuJ zsXs7=-g$@UQ12-k?M-}&k8|FkEFIpmwGP@@YJICM^7xZx*g%`MwT$~Vzf4H+7Ex{d)nSWdnJ!OBbDR0Q4<%N&>A@8_8Rz#u$*5mP~`BzP|h7EjsJ{yDG zEmWUt<~jdPyyf{Ovs=5T1(B0hE6T7$^Z3pZCK_Kv=15u*wc=t%o1^DOr>>V?aIV?M z=^@z@iIuCiv7$Bv@gd#E%b@vC8_hrZPUA=TSiN^fo_p-}7n=2Fy^qgnexb%;-YZlD zuInC7COM+q7PQvN_ha{EHoyv1m~HGSYVgYIop)8Pw>omyAHG0WBc1WQ?rlwnlF>`Z`f98AZJR2R>`v@P=g>9-e94s8oBE3&#@FH*7 zyWc5)(HD!dO5j*g|D)Yw`s(M^-v-B^ilsfbt-i~7wh>7IOu(!&gL@fA;^BJikScrh z9=SaltFG3m6-g(@YCZLkWv6bXPHkI#qB%Y`# zu8e9~!=9{P=QiajYxT#qtHa)SMB{^7sxesfeUL=zIQmDK&JKK6$vD zj`iqJ%ZVZ5RsHs_ch-DjX5h%Grdf9$-&2ZAAFbZOJ;COhUIC#g#d&}>~5XG4pC?XkD?mL#y_Z`t! zB;^v#{)}f-%iP)z@E}CahwAB+byhdn^k#$Mvaxt_V7=+HX>AON62FsD$IyY?`hNCn z`QrYK=u!NshI~J7J7Mj3)`7?_9yyU!Yb{6n+I9v(ds)r>ytSOI|KQ&oPQU7WcsRVX zWhC~l+r`~o{N8h@d}Ms)PMYzd@#;QG>E-^&FPuk=B#QVewx~XG~`ih43gygx6i-NZqYXRRz-I&}ZA{h>QYoL6R%{p>txt?Jo|hiooicapb8cIXGrAvnx$TM@ z4Uy3!z23Verv}UxYcBM z&9-v1=(OdSGpXCC8OQv6KcDA&@KkCB*KcWVUy$Q?0$6{IGqzosPm9b<9ASfp>Y#GI zS`r-D;P1z^;pmJZaeS_c>nUuE#@kPXEr_c49=4sv|Sv?ikR~FqOV@ zw4S~ctnM+pU#=)f{EMSO*8OZR{qUHlkXgm>_QjXv9Vu!h%PQ+}D}_g+H#3RWgGc?s zdi(T9SW!OqySAdQxo@>5B2OQa|8svu+18fYE59q(*LNEAdREn*NNq68=N?B}-s8B# z;MF~qIit6YEv=nJCp|OrV#zVfT&+~T`kh)aMttfAJi56BS{}=}*i7AKQ16d+WK+)Z zFo~}zsa@56w&FXVi|^;{BRX=4xU*fgUCQ`98nsB@sU)|Es#tTY>o4>7WN>zwe2i^;o4=*PTHG|}E;^YbI7wIA7D z_&T&yo3WoZ9%mjIfpV6S_mr~IL_hr058w~C#qa3dv2L60=eE?Z$4?6{I1c>s{jtaQ z7qVoxc@TfX=m<4x)pMi{Bd4xfbsevZlbZd0=DbQsPq2)Wla*~95z<5r&pM|tJhbqzEPU3Yau`dzciOP#KxpG=W5w7NJ3$8KN-Q_sO7iB!Z+-?K?JN_I z%gfEJ8(o=tRF1E>TF%L>@VGxn_CuK`r}mb3r0if|$Lt-KMOxHoLBka-CFHA5{lH6K zY5hd^wtaIc%t*3!)mdJC(*Fm>N95TrMzc9xNS!OY?u4dloB8R>l+3gDAJnYyLz)-r zX`e{KiY-YsiSY5`Z&s@#Dh&>my^hP1} zubA)}XLVPnf?D-D{^tI{nexgtYW)NglGIuC!i(3AS6DAT7HkkCFGt6=={@spY@Aq;uVn2$97_C zI8Z5(QWn}Tax_=ttDkxgb*gO1u8wnCPPg8dzVeE$M^=AVzDchQwnOJH%x^fC*Lxc) z>D1rv=ds*fu=*GGaER4%@BlHrR>zTKDaU@LZ^YEl-vi&c^zg%KS-(hXF=h)-#p1ch z^xa_9UB}bHlEAlP^vhZCsK%ZHQZ_ZxI6?-h0yr~)w&?JHnM3F2>$W$fu{|Ww z`W(!8@4s4{TJI6<-?OckWQt zuajD(>h-RdpuJ+tJ#$@2lf=WD%Lijk_m7xa=W?Jxa;>l&u?gC@ZG4DCR}K7T<*)Jl@2p3zZWjfOiCiutjAG29>#EepB&{mxTJ zf0%&}8@Q8Nzsn;TE6W+9?_xVGs#nm1zVY|bcYH)*(C=7Xey@$#V-q9?%%DbneAKq2b07Ug`{v4Q-$xD7<^xJTSR?DV{(ZhI`>G?JR&B>( z^Hg&%wPsedxrCG=c;Y|A3x&r$W3qpe^<2CaY*0( zAAk5c+V-W*_nqumf8v(D;dF6guTgXRL3kd@esF!V8KJC%naXXRru4K?)}4Gm%s2<% z?d#RRwW*X<%h@l`#K*Q^&)DSh9os9Xws*8$WvzC@0UD#P4At_sq(yy*6ve~#$z2~n z#s%f%Xv;!lW7TJC=je6M#zn`n%46ugjI zHEv_8wp}Wvglr{diH%^=Rde+_q)$ zfADg)*focZ)25{nWUblOF1w3jj!mDzS97#mw>+YQ{kuN1?m0mE_3lFReSS>YNa1*H4}ss>hPK+iXJu0pZN2$d5+Zd%!EbjB9^cf%NwErFE=h zcHuTimgny88Lqtb2D)HIvS=QR_^{)PN&QrfAtIOBuDsr}ARkj`c^!w%yU1zJ-s8vRJ@;X*f)AKcUZA=cRimY=Fv?1oAB?a$W|8L^ADZ~$Tj_UI!_5QP@=C_sYV;KeLg<4Xx={pMIN`mDSQquR8C`J#g(OC(~O0Z;av? zxf_*q+~K-sAAb3?x9b_b=^G2#t zk>>fxy-i}U{*s^QrSI-1{oEH+21C?3*|>g(TcV(`<~YIsr!Qa9irKt!jcY&C2yaFp9uEwxA^SHp zRQL{B$cpqfWawP`6JcBj@_xj3RLk+NU!D6t)qImSZn@+C%qELnnXs z<*;4jnWe|$lsihIFOnSVeul{VcpC)0N33?s-qasH`gE#FU4Ha;?@NZaveVn1|ExYZ zxbFEapYQ_?;jR3OJhk(_tp5sXeh%Wm^4eePzr)`?UOey!zIEs0_#56Sk5}}~^Iu^d zp0>TNF}UhpV5A{iDTk z#dq;%iK{=X)p>Znnc8+>U@0Xja1jIAHqB+@BIf}n} z$+=DYX2$P$pExdR_kZcU%AOVJ%BHpRWqzyES+g=FT$aOb-;FqPjr^8L=Nf9WR&chi zCv&Z3B6mKI=UQ;hXT=#j9(~ovUm(|Ne#A&1?+V@JI;fD#_Ki6?Sl7g1r`f~yzY!k5 zO!@NQyu*U=gL;Wjx71#1;`g>-oBK{24fT=6UgFOf_qZo~vRRU-OYat1?fD~-J}Z1M z?!g)}i#0F2yZ*a;wa5G8Y~+d)S!h9CzTY&P0*Q09KvC}eHTRQqtoC|jmA&J~YQ`yAvp$b4`t}j=_(s~Ea$O5QQb$|Y zhi&b{xVYE1wpa*jgSWCibv7pMQTTGjojydNB+RG~$;hjPmCshaLK0JgF0nFL>LFUT z#VJ8$!EpL!?*6V!YVbKSU1Xti*_`}@zF1w&Zmn9&Q{_O2TyvzjzUtM_lHGF^e*fgr zCuyq-o7;cTgDmZDUe|N5iJW^j@ba<{3?qs#nm_N9&&n35{1>RrN1$I#sfO*0d0p1KO=p3TN1|RvW`qX zTd(GExl*lCYS)_9yskBzv4+gUch`H*hc~1c!yqhfx1E^YoNb*Ohq#-WRY!?K=hx`% z5Whk^{)%nS$z!cQ<+kiZ)#Gz)IBO|ej^s|yqf}+xE4J=mw2Zu#wa&SX$JZQrw^*K? zc-Z})IYobK@f|W*d&lwQh%z1?vro^wes>-QlFUGol_Y6wJJy_u+n+ycqn}OejxF)H z{$CcY8I{>J21OL-zkC;hqow0Ur5xG5CU&x7F37+{G77+E=#ujwKjS7ze|fp z<(@Sz^42vy&lO(_#WpM-*~}b~v0222IlFCHTWPzq;^da&*h15?wtsB<@Eoi0MeQ?>9y#gmxtYp+ zp1vMqD-HUe5AwxX&iU`S;dmvV+qTV{6&vgF6@NRf?=j-N(Rxbj_a5_BNODHNUNK&3 zynv*{na`&baYW@{-2LEdHFEQ=2qU{k(tWn%wKKLTJM;7vTaR8#H=D)sSpTZlwpG-> zOiPawxoY?2Lak41qMm!)ocXA}N?7fobo$!z#UvYNeb9w;$l{c33~IrS}kj9Yj}9L74nwS~94FP(43rIy-J;~o`d=&xVU6^q;A zM4}Au+QXEj&bkcJx9%^_drY#v9Lu8JHmmMx&(&P*yIe^6eO3g)qAb3Sss?Cmsag@u z96Lu}*VQ48IR8Gl51iVx^tQ}bi?N*9>pr(uH(O!Zde;1Rp&|yK(u1w~9CIn`cx`N( zqtWo$g-@t&*hpEmBe3bMwKw%bnfd1J?n zU43CzDfjxslA|kc*jf9Elm0~=c@9g*T5r$u4$c+lmmgCfE$efiLx)!#uRLjZByV~K z?)-E}XjX~zj&JONbFg0KM=sy|oc&r+#?j_xzMs4!)v@vDJAgP^zE;bzD12Gg>6=rx zn6(YEt>{nPMr~~9;F{Hn!{PRYbnkI~jiK@>a)&W*g&O`l78utYxBdRUo?bp!DoWXV z;T#FY*BF9j%8t1^d@y(NZ@rzU_P_Yuw20dxQ{;cj)op0{c@RTD$({`?wlzUTH17vGi%Z zSN@;UN4a&1OY{zBAU%isPXSH}{v-Dg~E-zj=T))|N<&eE6@YpvTyC3z!U0bnz z>@zron%FyX+3_x#G6oa&q_)VqV`d@goF)93L-qDcY&WkQs2XFEY|k8H?Ky|?ePU?0 zTzogV>0+JB?w@nYmG-Q>pS6+X&-kv=*o2%)T@}HC<7c7LBJ>6rl%+rzB&jF!<3e%qDo`(CR=hlI_HnFi;X2cO72P&&l$tTXoqiN zgqrrZ_WfP^LmAqpwyA$da8_u?X8hrnMlNZG<%g zaHRHR2(<+5{aGtD@6o#T#**hv^c$~|oAz^lvF)Qp?cqE3xg?4o%mfFqSvlDWY8{oF z7t(E=4<-Cmb-#>Nj>$gXkYClq!eRD;eGrV*b8gJMWiv4TIDB=%j)WB(@rKR=5)(a} zKVz7lvgTWrgtp>4*EgOYAsnS8Qd-m29e8T3>!{vi(V`ju!x;Wa-$%NcyY}!RsGUW& zZJ)fkeb{GJ?tTlPXDyaw>zP$WoARoCEsMM*&sy`@Kc85gK;A|Zk5J~B%WL$AdU~-9 zZ_>l3{WW^iy3&v`Y)oBar@u`6jFiu##PQ41zPhGOES?e<0<@;R?Ua65+AN|L&Yz8B zv~YaSwH7aGea3{Oe%2V&W<{^<5H2Hm4-CnUW&&#tBnO816{>q4U>hB5&7mx;?o*aM-`f(Md~XCD=+69pjQXxE{cNktt<`h*i>Ia+ z_*!>+5nJn{l$bupkPFkbGcybcJ#?Y77_9&8?1yPeM)$4-Gtno+i}B7p^lbS1J~H#0 zJ{#_{nfhW!M|3NKj7R0cHIf`XD(Uk%MS6OkGWKbyzYjdBn|si?3a+OTsaZX4tCH$b zzli?1qo94HbFbF3?dVnZM4tcQyRX_>tIjJ~(W(Ewap8 zqJVGr(Gf4npYt1LWwKmpKb+)$%kZ&A>rZ#CzEE6!!-IZ&|Lm*YDbwfmk}>!{QK4A0 z?b$0|VpF-}F-BF-_1hEL?}o>f2kH??v7EIXrrW;{59G)kU-Hz@*z!O9Y-$wolK<1) zSNeVAOI}%b(P|{Q*p6kfIpy_HIoxMT!@1w0rqMoRE*+40k&pMP7ZQ^#|oU z-o=KO`@d0mwxw_6qi?w8$~9~7S@M1tcBRq2ay@I)n7?B9c&2dGpZA!^s?M1iH+vs| zm@9v^Lki5NT6oJEE#Hpv$>QZNys_t!W(AK`%unug&sc?})Ndas4)It2MX&nODR<$S zQA5XyH}$4``@yZ(dHL!y=3n^UT=?`H*h0}cLbY4R$wH*E-g;*v=Ok)n&f0o7S=blH zKN)Pa@n`a^@Mr&iwEn;YY}a#NxB92Zzs9ON?#?+~822>;eml5PF}!!KFn*~Oi3R$^ z)ZfuCoYynMd^6%tcdj&6asIbrHTmz6vFgcw#cW$_l_7o0{={ngKU?aQ!7{sM0cEs3 z~2O=iE2#e){JXja8St@}6T=Iaj;b-Wk+boK;HA zJ7!cUhxJiBX2xEA5GS)ng5;ImrZ+9QeV2(xEY*8BW@)Ta{Jl`F1eK#^ja2Mu)SB~C z$M7*$<>U1mTm8|pAML)6S=z+A`a`3AMeHlsxcbAolG1u%rgGUkq_ekr zOAt59^erT-SG)qdcYeJ+`;wjUx7^y^t+iSg($do^zcC@bs-YIPXX!cO9IQnz)UcHn zYm2_>T-#kQwHs5)V!?%^w)B=3@=}h@_Fc`&+`c2H@{}YA=bL#qfb6K8v;B(gCDHzu zROKZ6CRXQp#pN*_1V`43HR4S^SFv<*E})uPMbo=MxT30Fuv#iskSSz7zRJhP<~Er3 zJYPPn585xw9Tpl(Ig>U@+7Iiq2mS8qL#`=a)*7kbo>k_NTfEg@`S&rppCPpU`fby$ z=_4hvVHxi;$K-uK-hy-cVys!o|B4|J=JR~*^% zJp*jXq}lHA53BVn4b52~ulH(6CAJU5F7~LgYVlpt`3P5M=Um@X$?&{07_t3vqQce@ zGqOe3?O%(8^4#cvk+7;-s=a#bx*mDqGHbFIE~}?KZsn?K1cML>t+_N?(z$&RWO-vj zv519j-z$2z!Ms~Oy>4uhRO(A|*q`l^Y{tf?sj*q*UB8>Zz1FM1UkeBJue9sWoIK!oRua}Yp^DgnwZ`En7|VpJ-UT0@wyXZ7kK@sp z|CtwhmiHi^s;0Hg3T3^k_AeoUnW5VxN2q_q6Z`+OHU5g;91r(vZkgyk^4-*m%tLa^ z}uQ#7I%_um&TS}y&zsWRC5JAL+DjSsO$b7T6f8I=HHsrg3rh85u#2Wz~&;IIBN z=Kc)t{Ly~RY)Ah@RpV>=%C6T{I6USoG8WAKCExBi);bi}9V2s|2okp)B!h<)0Nd4E zTf}{{wT_}|z17rv^t&?$HPbuip`}ug9Us^-?Ktlr*@4D8=Z`J1`9=Wrm6MzcJ54$a9=3yn1; zF6x7B;oSP(eUJkVJs0`oO=-7X?pwAj=y&`DU+0X;xQgpNM$J_u$BBBV{UQ#p@8Hus zAbRka*==)RL$) z?>)l?uX&mOXB477C4E!M~$USo^97M$1at+yjgBtfob$d!|qY? zCq97#vqW?c|CXfVZ1IK5x3Bfqt7osQ?5aB91ZlEq^T4~8+s8(G{IO$wWLrk?;EV0s z6*WTUH#NBrelB$2ZQJKxEoeX1)rj76|1w7}W5YzLqo%nSTwyR4uIQ*0v6%m7EZY5+ zT&v$4I(iK~Ptq0!dyA6A176Wt5&!FRjhE)q&V7PN)sR4ax4VlIqf*Ts-|)CNZ%jDPei{6|LZBCbH}h-dLu-qWH4r-De)=jysH;chk?r zM|hh3r^lT#m-=O0c+$Rp)t)(sSLL0wTm3xV=j>WF-7k**ebrGuM}y_^y&odSIX4+d z8GcY{?AG_!b)HZi`&|9FgSBHLzO?3IQ>*M}yU&vD%H?zFInPLA$JX|f=Fs-E9$zzy z;YM@AMBjOy+PPci7DiOxx4rbZy#3t08%bjaeG=^MlP;elThA*xtIzo0nG@E)`t=NP z@zXeM-xvS&h5RrPz}RT^T07B9pMNBtk?p=Ctchn((_Yqq^O3a{^DWEG^Z3es7=M%( zT3c3E7T1g}_{_^wxZqCm(4jo>Ml2o8;M(U1VbE(pLEgE3+DO;vZ9Ff2Q~`v8a=a!P z?NhUkuNqmaa-1jPZGq0cjy3t7d)a136tel#7UXWT&wE_2{ZPl(Sv7U*7ute5jBQR- zj`aD|GWO;F&Pg8`qauxZWp~x~2+$ZtpZ)84(lq%(*j8?HP6@W?1-JG)mORk#I39VJ znqV4BEsb@;u~3nn2&lw6JpH9R)uX>HIbq&Xwmspfy#9aXV!UHgIsf+jl&EG2Y>$FnZ)7MW_nez-N#yk-@I+y zjX3P;2%K|W^IT>X394aD{=XwzJbyQSuG}gOX*F#Vr%R9Zg@xEq9bLQ0GdB~T$qc%ok}}nXBhO1o5OlM{+Zf<8b1A#Sk^nUny!? zhLEl}UQEpBNxbV%_B|#G&C!Zn`N|mi-=Fam^EF!@nVYM-{xPi=y3JSo(#VkX8P6qk z&vRx?!u?1*d#m1SKdQ;tJ_uc^`@XX6wTTNG;^~r?_BolE(ov#BHX$Q&ROTF-z5EZ? zd^1n&`D(dVmv){{Ub6SMJX*6?O^aPwV*X!4YwO#yZ$Hh?)C&t6xkOk8HrIQWAJl6e zxAnyH8~f@@c-o#6Gqm3Fs@oU`HMOUYqnC)8Iqb!^#~fDWL7)HO#os#bZYGxQ)`(Sm z9$;I0v{6-l*>cQSkT4#0FVj9YVM+B6BbRZ-{tIuBbQx6+J`Vq>Vq{K_+PtoFh1D~q z+q|lcaSGG40#jFTS&?Ti3c`)xOI;7jv{& zx4)r#?R|mj-OtY(oBd6j+p}+K9~h<=;<8(7Y^{zipG-}a=UbULV$j$d!SzP{pjNb8 z`D|i-W#$>rIzJyR^g!!dFQI^Y8Jzr0PH-9Rq=DIJ<|E5z!wIEsMc(-UI*gNXf!~?RT^nDowDR@! zO1F|^e1pPvFjm>B<4AF$Wm@ED*`M|K^exRGkBnctCWZzxjDWlRMJn=Puk)+g^Xi8s zh2LTf^ZDf@MH#qg3FdOzzDl{i8>eleXU>OGKGNgkzMo(nH7b{{`jcN29gFjkmVMWj zzK`Ig8G#P(;mcT@R^Y)#v{T;IBb9hv&h`>#^elcE;G5(~3+d`J1 z?6D_}DF3k^LY`a63TH6y>H9)Qjhs(7`%XRZbAL_R>wih(7n;CjJ7rrvt6x0UUa=Al zYu(+k`u@MZe9Nx@;#`PC0c`lr5&ZN3L>v=PHDogSX7A7(i6V}BeZsSDc52#dO6 zDxWOL@Al}#o?1TI|9rQKn3BEbKp3ilegEm$>R+%oF-^T>mopN~(#srkpXFI~o|BxX z^B;@pH4|A32ZQ5Db|ju2k5l_+@SL9byf;A)8C$9HdTtwj=TJ01Vn z%%9rxvAnT?{p2NLg4PpL>soLm=G@qkr7@JqXI}4p`k(vw@)7UE%CG7A7bAYM`CA!H z=$KnI7LAY5#O2w;u;6%#_tb`GS`ZOLTXF+j)bf2K9Np*ZSN@1$5FW-cEU* zjH&HcudALJ?kW*@s-rU4I+C2%hMTYLZ;1b-S$W&?CHu68GmAzo#~Tl~w>s*n{zAA~ zz6cAd^Vk?*d3fT;{p1+2U}p4fkKwP(y>GmU%J0{H^~1xB>M}lqd7+y2*kd2*khv8S z>NsO*i)EC@ZY1C<9etM)BDfx=#U7`-iq%Y(bsViSo!S5Fugo9wCY!I(xUBhO$Ie>% zsUKKA5uVuc(ht@LIX3abQQId>-m2EJLH5|fS!MDadA3D%S&AaFQn4w$H2U}-{yiU1 zJ+n8QNUCGd`G>LWLwRHPD}S>VSh{MnPuxdlxsCSseM3EUt!+%p2K(R*m8nNu;zp7? z2BD>K!`NmCMoepvzwaBc4?UFV&$)f@=eNk;!-gOK{sNOyFn?kKt|ns1OCDLkJAG|3 zA0@RjK7_YbD$Dp@&c%(S>a7)vo9xg3QbUx<4?f?8ml??>+iH#p7L}(3c1{cXD;`7w zTG?A@rk&cWwd0k{2^t;Y(^VLiI)AKlxG!+r9=||Ot6C&UBg5-%whq)m>0eFt-eN>G zXz|h?ORchbKXNyUtxKHT+oNBse&aFQ@6YINKN|_3|M$fMbCaCWFr$3@w{LIHe(MLm zccUMMKKkR|@3PD;CN|8Q>@35?J>0(h7gG0=e}!#7pvb4pz4E2(Yy9xIa(hcU;-ksq z!|X@j?~Eupl8vuF^<`;?UiSGbhGN3=)@J=2<($V}|HOD-+tL48y!lit^=t{;$ft*; zWwy@uvXsAi)B48_w}Xk98>yPt7w5c->saJ?W-i}!`(_>d=5^-vW#JFY!>N^6`%6Da z3HFEKX3lsjWvabcPyNiS+ylhWLath%obybv<@T~w+nH_BrdGq0|Lnh@XkTLsDzhn> z`DJzF)kl(Ik4{eIZD`Efn6>%5vuho++4v*TWsk5S^vlvR!q!N21iwsl*|yGKdoFR< z@aC?`Sw!tZ^F-I0eyNd(+r$B@tgJQU{E3|WYj3~q z_U(#?Z*OL%NhMgDJcM6f`oYJoAG~gJ*7)(?U>?^~!)ot3E**BujO-Ui9hq_?S4r)v zwYu6jXw3EYx9Vn0dV-|~^QB1CNajd-B9lADkn36>i9MPVi&vP={xJ_^?TYi$WWA%0 z745V*BW^4n`{Uo&f8q^l?tYj14k)`ykhjfS`7-~K*m?W(zTr%3H1CWLRAOnfC2ESG z{SNJo%dkXbtajjj{ji;RS0l^oSg(F~cq4m&z(`Z}(2~P%#dc>cct%DftyM{+J+zGT zMro7xdW_c0HR`{o#|UF&YZKs+p}L>cVQRZVOu)(e&g-8+5u>TZ#en06(7|Md(}!w_Fw(jv9u6-$&BaO=CUn$K51JepPh$?ur&lM&Wz&NXxF7?)H5?sE9dIz3z;$J%%M3tJ>hqY?cd$iGJMwz=m;FEGM9ssdLYca z{{xTr73@uo;a5ogCwWc`AK=YZDUT3XYgPrl2D3zAp_Yt2b!giD+DSmlaGxFnEWPu>H63v;(5;3*2G4I-r^~h*cbuP;|0cy#7TWGxo z1%BZc8hyLwdagiZ&XUp9EA^3#CQCw^KE1*T1L5UbPos<3`-wNor!>we272WE*bjxj zQ^G4>x-^-waBN0oOJq9sz=4;2PnF|cNXneXSJ_)!jn->Q1w+IdLOMY3%IEq{{cS)8_Isr})8?vZ}rGj-Me3@a{f z?{Pr#uveDm*mq{Xj8#YDjarVIi@n!4tA{$zs4vRg9wCFn{a5kVt6F}B#9Zcn4Cmpy zS>A(l!4H6J*7V@_@%u795-YGn^#5#wy)n?paqEdQv%C7D zG&-V-Bm2~$4Gh^@g#b0?oTuy39dTaZ{I-ae9`H&tV{_1Dn;zKO^1vrj-r1K{@>5^! zVX8SHSa(l)>dqNQmU9L+Y6bh~>7Ebi9+gBva?4uZ^cw94zE_cz>k8lKnfk90F~8=$ z&U|bQEXPOmM$pe5`l2)IB(9Uv%t+7>fn_nxKEnQ<86Q zz4A9B{gdB;bbVK}@a>g9Qmvmewk$u<<1D`HYIK<$F_~N?PSwJn+s)tSyo8x{`xNJa zEBj6~+pcM8ojG?!l5KK-u#a+1F!ec>p46JH4I;|i$F)^TQn8ua+9GYMEGnR^o70+s)d}Iq0*NI2rNPS|5s6N*% z@_fa)CiTt3>~B%;{Vf`$jJ#_f=O~2q#^G?yXm4($N85ZKtIRiX0J_d4dM%?i=&af8 z)mE5ywEyUj#-@%+%6QmhnTPzwO>*g5lJ1B}OZL4=QA3o$r zTB%LHjYUOcc{gQBmCxGI7wPRNT|4@wIhVXW`?Xkmu%$#v_qSa)PLct{&%U4f*X`S_QxqPUc9R7q+v{X02z!s zmfACH`Zgu9+2xhXnYd+pC6TtNw^wL#{EUx%X3)~|lD5d(d|q<^Ejr^;ZDVb}(J}8A zk-aOl`t$XViN{%wy!zqI5Sqp#&s_nU^D48V7D5n?9p9892VQ0+M=O;^ zS%!0rt21dCuYCIB4^}jv7|Wl(G8FwV3J$j6x}*Evt4FEBAN6HP7`>bGM$%m4gJIvp z?>R3k68bHaXFosZ07y%eIeRa5A|HOw5gfgXH?_?9#73P~+zAvr93>t{k2U$+SJ{li zIs5I|FYj4Qo%N@v-+LvtG;CvS0rWRL+0|^oB1wu=RE}6H{El&+q18$PuYS!__t-6gIn8U zS0!}B$Art%8(*3;*UGdcQ5PPZl_^~;}s~;;5MgP!4vQ7BFboCv+Hqtq| zYP}g*`rpS_%sWyw3e36*eycBStIuqN2R0?MxtcoV)4jY`dlQ2TosTJc?1`Tl@3C}T zu5q7h6?^3%E01S<>IzZgvh&x@>BOqpYVS8kl!#}z^`G{e$GS$5YYwWS2d4PCn>{Nbp zXV!exUhQZPAK8wK$;X1?F=XZkj34|e^vSu`)b|xLTVz~d+jqh^!sn?ptyk%5$%i@7q=FvT6Rr-LN-)X3n;9w791|HQ@lR5-*fI z?CV$G?A}(tlyh3!2lFgB`W$1U3#P4;ygkpddY+Jb1(?}toO)^<#h!eGL20-A=Z#y3 z?eA=+e&UU%=K8>MRB3zVBNjSl&bbEn%rcieXBu-~5fFk!Mn7_&ab0^s(#pr(+H0Pv;I3fKUUaufX9v|)eYLkZJG-_0;=JW(rp-@$ zpCcbntg9NTJ6tDH*7eHdaXc4$moJc1B#wY-A5`eXVr=A(QfDFYl=XtUHRe8J%Jqob zvv280WX~&t-B&;nE&Ciz`;@gj+OZ+ul$C{hpW!-=Rll(UzSOKwtILRG0b7pE_NjaE zXWk66@$kqMG+L|NIP?~F$3Xi=GwbEqte@jq{q5OTfs%HX`VEnUrD8+>8Se62%OR%~7^Ii=Mh|`_zheS8Y_^R#tcNZY?&lj9(Iq-HnPe7VOPF?7?;J zGxgk!d!IR{IGzrwj1#@u#20f%;bsN9>`j=NPi)2BM6vyA`+YC8YV~d(A$q{kW9LVb zOg+!C>R+_&Oy#5L<8P>3z9BNpH;B@c!J-uz9Y=qx%|C$BBLClk)VFnsM^XVGg|!bj3h}>t4r?ki0%4~e&pHWv8&I~fCH%< zgT3QE<2<{ZXDP|kw`ae&^K?lo8gWK@_Pv^w^1ie0?%a@?e9mjn^3%wQ6#c(^N8S3g z{Q|yd!JlP~W#{=>vokR;Y@gTD^J~%>d-nD8zu=n1B39EU&NxAzV*}-?sW~jZeD^7@ z->*UDP5wsjHhimn=s_Afx{dd`2cA_Td|X=yj^>2;F_?(zdLOt;&pV0tw&`3+RXhh; zYhOIm`&IJ#S7p2cS7Oz1viJ#FTOxecjXFGpbt?0BZB8cREo2sBtn3vBB0BnHWA9|y zYje4Nso%tSih1{+r!d0se2OzDiw9nbx2NaWPdzn%jQ`j3UY=9ndRU&Zbkqa|2+$iV z`PLPZg>7m$nswa#!w%7{{q_jXg3oNiy^WTRHr3asy6#w)9O?{?C!fjln*?@lY>!i0 z%iTRW*+$r0-s{`Nn>h1an|t#z;?A3&-J-ofwqc**#&Yj3&a2CCR6LFR z+g_Xd;JoMliP=4}%;Yd~KNct|;LzT8y*bDATMTIFj3+s=A#z@3yUu-huY#W6Y%PxUW1VZBh&DKn z$6$ox{q*jzT@opKF44AlQ!;|ZJpvicPhkk@&13QZnoqoAn<2+}%JH4|VK}ypZsBU? zJ}p9<{;a=Rt1oY)i0{mptv#+N`I$@S?%eO16*vECP-JGlg^nP>+Hz#g(u;164hKe} z@3T#Bqiz{UJM;FScj%bgwfE7+(I%&IWX-pE@?c*V)D@0An`7AzJ*)V7Y!yQN!rJav zAEZ$-%-dLzdR=Yktb!W0?44{^e+Wl<|GS{&pn7N2J9g{qBfW3;vL~RvCD&Xx>Bg zL6Pvm>(#^dT<-pe{9Q8pYX98dgqioNDR#JD;6VfgjVuFO*jQU|n(?!I*Sl~BXS9!` zw)B=3;yXuY`|$U4zkB-A z^|rZIb&gSUc5bBf9=HS%f7&9$j8A;b9{t@o8y`Ev+MBAa?VPO%cWhecEu%-mk}+)E z#}&syaCtBJUYmO}$a;mWaV-(W7d-SQY)Gl^dO$ne7)9f!XCh;B<7>qe^M@TzFZ!Ds z(saDX^H^J~--ii-8GD2^--@_)PR+Ug-WAgNW96)OQ?D}E`n&V)j1k<+az68=v%BWA z;%a-O@sVHje^_=OjsGbNr{Yax0qjj=NWz2BMHM+p|Dz>VKbA#0syXXQ zqPJ?dB4gGqtf zT90W)&v^&7bG`z$Pkx7)czs<3{EoDH^m*zxBDLo}LT;J8bKu9mIx=TQ^X{u3Lj!eU zTjp28GJH;qG}kQOOpfZ6%9i)eP3qgnw&08w|CXAhb_9}UjpeIH3r*&u`~ITI4(D3S zGhcm!b>*$pw;jl}J&tcI9~(M$;$Lh6k&c<0@#>{->zqzG23ad2EbDx43rCIH_d6ba z_W4f+8k`atmMK7zVv87$Do=iXaoAu``49h*BncbNsGuoan+-}p8NbO**gZo z1Rsx%s&D$}dZ&`~t=I(>D3*6;&H56vj5MsvALqZ#28-23%WE)cp4SyaI4<)-5|7VJ zwJ{+KDOc6S?>jR)R+*WylvufvR&+JAGgr4z z9UXJcuC8X@BV5z|5=)MuvfM4J#MbCp2o`k&0k0Xn-OSX*51IE|u8@>Jtw#|5+>aR) zo!|Vx*rtQ@5`R=<#o3psO#9O7cC}4=ku!d(?O^3QTWVzQxI)sAeeUmCcRiD-gb>?k zfB0|Tr%EzcqkFWDyRoSj7|n3RcRuy;Q|M+E^X6ca#Ypa3-}nwr zXS1>Qv%~q+966(FBSO8PXQ5B9NKN;RJETDuTaEUed>3ZN#<7OUJn-vt=dN4HRwNn& zevp0B6Kd(MVc*x|;#Ei3>$3uQiG9t3bOhda-OSD@Yd#?gGKS=v_FR%0YP%vGd_kzW zGMNzR{vE}v|3j9cUw7S zzd14U&+_0}E03rYRPtXCkP$5J9Q%6}=F4-%&sjp4U2m+XH5x2MhuC(UY&P;$2Wg|; z(|sHSJn@`bVnP}u&DRBx2m?sRr}5`8rsO@b=~ccnN*vg}V(qx{bPkYIwNQQQ?Rm1F z4^esdRcCOGt%DQKaRe){z+8=2oeO3>Q7vcba;amM*ZNrKXn5?JJ9m9?edzY=SGJdz z6{PfIAABPC=3ZA_SGHtHkG@^|+}FFN=WQy_jo*pWebyPDnI#=dkG!$M`%qgrPWHgo zvG>IMRNN9z`tv#U`#Cpd?cf)vFZ*3@Fo*|>#Vm@IYaX>8`E2)WFnsE}Xl4H1?Rn(v z53jTjJe|lGI_L*}bb6rK~lWJl>J~>hKd)TIpK2wKd zW%V3fpK)O6UT7BIw)8nY4r?!?s^q)Peun~M zK<*cR`26m#zx}4$Z&l>|)~CkxzAN!l-?gI&l=ZCrjnAuh?D^!Z2dVG+h`ehnKk&=4 z{n76U&OQ~QXUW3C*xI+^^3EqD@HQ=K{OI>g|YKxw|~IX&pUlRQ~5F`-&e_Pvicp%*eR|FHcN-`|UUC zokhR<_Iq!C==Mi%|IY2-zx}D(e|YArSGWJ>_7`ve-R*z8{k7Zw zeEVN+|Lg64yZ!IC|Ks+5-u~~~-?{w*dGH^6@h=I}Kk_eUD`e7WJHY?o8GtYPGt}E& zZGZnqKdXItxBcL6&iBv%6O}ECSD)7iufE2S|LdbU{@QnEzZyR9sUXplt_#(cu7UD< zQ~vk9H|=|tvujgM)TK8@da>W$`iFljHB(F9<&!V{el%Fi>wo*(qV4C(|Hjnl*jF`N zPLy%{ID4~q|L%9D{m*)tqqn#I?qAQ=&re8;_f!*fp!)gqG~z%07gDde>;s?5KKPLM zkN!s5KKrZL7f#Fil0P1OpZt!L|M2jyy;vj^9<#;^&Z)AAXgho6S)bTPYR}<7f*08~ zqFu)pr~Dijv#K~A0RQS+!K${y1g*-%k?p(AB7U$RU9Kt2o*ljse8bQMXENqJ+Id<) z@;vioEB+fhUDqfo9eoY!yNcMgUHB>ov@b{0&avw4HmtCR9jzBBxz6D7k4N*mYU{V2 zVs$KR^h&3BL#p{#=u+~9e?uj#-LZnqJ7LdftNLcA-+TN0w|_-BMGf><2_)=KQtz%4Ok+x$FS@ovo!16RD z%dhXI=AG1cM~dtmKLwNa&C|r!iZe$WdqzGhxZuyeP_6d1VZD?2_GM`LdAwPIJGJwM zyUY?9uYcQ&694Ay-@g638Y%vR+n-+J#O>Lid+obzo$NtMKaSS7dbMUDm>RuGQ{H~~ zFW=XQ%n$x%wylNi^q9=TQU|NFa-n0N`KZPXBlz3j)}D2H_qDIcF~wc_kNRBu;Pjhl zkRO{D(;|GK<%j=rHK(kIUi(|Asqw`6`^#G7SxS6mNpgMk_0-XMlKdTf?@8;ucv!BH41{Uo@KsQ)N~V}WD|8OQm<4zzY& zv2sZmrHY>?eeJtdi#gHH_nJ=5iTZw-#Cv8&w`ae%eP`BJ24npv{mWBj)K@GQzxE*( zgHf%Ok1V6}o1m@-Zg2hLKa=mWKe}LE_#2lz%ghnthV75c{NUA(WgldX!Cu4BjMlPX zzO&SNsatsC4_z&bmo9s%#e2Qu!+IF$L|?ST2Y86~)>->4om%$hYdVH?+!0iv-{?*&RcKg?F|Hkd# z(p>l7yZuQq`X@UFL=GR@F8e?5%i@E7_!TX|3f{~H7p=Kt;2-_rlr{IXMqAIAG@i`S zjD1;CIO`*|bFcd`?F;{KaP_&C_Ce;3$mrWKI_CBG7ygYL?_9Tc?0(>v#b(XFZGFc) zjfum?y@#83>cMNCkd_rYjhZvA8jp#V%F1tzS5w=;cu=&&(dhW2JlQSy*(ahXv!~>x z^nLqFYf2MuYrIQFY5ozC#NlhvS>AfQ`RF`@wq#Aa(fwt-D>L^CHJ9-2c+RhwEpdLu zsChlR`iqLdzt}r>YKKOXWkIYLB4K;!E8CZ>S2`UD@BW<+H^!*l&u2dRvtI7^N=dzc z@b}Y_cMMYU#U@xi~WI%4wk|Gsry3hnYKNJgl<*}LX3;v~G@61hmX#ePI?!9eo*)!itHqIMP zty@UXZ8F$df-OiQ^Egt+HjlZ9Nwe>BkB>~fx$-R8sclr*Lw4dBwi<7~lK4PA{RAFc z6YH976Ol+u|H&B!`gYmqUovcmGBaA~2aaz4&RlpyQ+`=2S5n%uI9jCDAY`^Ky)9bp z|F5Fy?_Fvro%iDi_`)_Z5N&Vz6-S-o( zWQ!B5ENZr&{EofPu^un($>6&4Eyrw!*n0KD$pEkX%`;v;^HJ7Y|KjxV`nmp6%+_yM9o6lHIrItSb>e5Zv*$&gOqs z@YT+Vw43^tT7TyC_kU-OeB#e%TdZ9b==Hz%&+0D14ug zqvFC}XH&>un8jIRo0i~q-%xz!jGCJ1EtDiG%YZ%Tdq!5IX`@p)tVovD>D02kQIg)#b-d|;Q#<(7%dD@xlvaF@*$A(# zfA4!!SMzA;(Hq&nGnJ0MH`CsHLy|coAEb8j- zL+JjwJT1yKbJh}g@-xqU|7y>PSVzj7{G5-oqHyN?|Nizrc;)%_?5|~&NjdS4*|%?X z#Rjd-v&IV!Po!RI zMH>>kn)=1xld`^v=G71HIw0ZmsV@sAbn;CRDG3ktb*%W3ujcq?K3bV=-{+H6_8a63mBWmY0qU_xHzQL)ukuw}W}^RB#UY1n8oj3|?-+XnYlqNbhUZb1V;w()4pU z`la75$^4Eozcb5kn*A!hvHZ9AI?wN)v*15^>pI?_(%kA#J@p2s>&jbx%?o?0wOBka z7Z>I2AOD%MB2UBn@YFe2_baFI+E%s9Z5@FlTXHymxvxk4FZ>(PuD21|qpbA#8|_~Y z(vD&pEd~*}IQ2VDKl@!A`^@YA4|{L#@>`ajiM`!*TisW>t(K75vatmcLWrSTh(R_} zMlvIC2hJQ!;0hgdU~p2w4A_~SO<-`r;H(1&10(Q1;GhD7lMW{A(1r;d%FGzoc)(~R zKc8#ubKc*3@2yf#tJV?K2#4(j6- z5wHHpT04HKmpc-(&iVaOuS!!U>T}R}F}AlXQE~asTGxX}Ydxm;Jz7Ph&#B!(ty6;P z$Rq!mVmR=csQ+8c)tGe~k4QuElUJ{12Y~Ys`oL+Zn|?z5XBS0i-IgAl{(m z86s2r6aOFXEY{Zhg+H+b9S^WnYw)P`BBZGtt~+xymo43Vb8#-~|Eqs$di9(2T;@Lg zuxq{L$#R}GSDU~55!R0-71mk2+}+Y611i(}T_b(TJX+ z)e6HeR8LH6M{+yM_k6q;a;nVJ({C~FyZ<)iIL9M=U&r~D+rJm@tZ(uz$A7Q896J|% zdi_6j|J0lR#{AEF%dnSZsw|ZoYkBg;@BEL>@xAiqe(n3e@F%Y4dtxkerGQ>u_Gt9# z{oil>`!3hr3EsWHvVZXt-m6$o!oySlGx*Xs+e!__RF^NB-K?=H8G9D?Ncs}7SF0TLGkL3U7bGaRn_jxRi%DGm_ z7Qhwqoniiytio_a{=Z)Kf;_$c-`gU7<)2!*O2nh0G5iryLx#WnQKNQIY@hq9(;v(8 z=ou=n)ofh7{?AR-<7MaBc256=f9y1l(V6mR|CQ6bqv5mv#QBZD-e2T0=H>jZ`j_6x zgXM@QYyF@9xDxuBR{6z$;d4fT`f+<1wiI$;tK_j?T)5Mr_TKH{7D$SaMLhon=#qDL z+;lEL-(Wh&^5xqZZSQo0C%FFQkACAP=Kn8$rMkV1% z=cIP0&^6ljNR)s$$usHGAu&0`Rtz8KSFEzM=$NW`{iGe-_g#| zf)@LWpZxPb-xSJIslW5bKKp4m?C$yy?Ob$G9(45-fUf!cW@)bHNl)Zg zmZkcC{dcU*cI0|(Ex+(5*K6zy5nbLnWo^Y#aBlhDEkn<&e6$zIgZYe(DEWzN$-9XQ zYX9pW+CfYQwWQ*)???^@>eNY6Ypv@Hj@+XH<~-*y|37Vw6mB~S3~SxI)4xFbEZ zVo<0~_RRD8?x&z?{WX$nJhjuBde#^|Kz@Y`OAO5HX`@+iGTj*>jl=p(h&#dbgi$YNag?ihoVJf+uzQ7-lL;vKH<{IP5Q+5cufzx?+})%Wh1QV;A}B-1Eu=M#;h z?Mb?irE>;yU zL{Mf)N&Wps?atfODsFswr?oqvi#rh~ze%qxFZM+~bR>6TWY6(^C)OpuMn2}&GkRp6 zxp;3bdGA{TTZ&IF^4!mPkRRwuSFA?RI$Zx&8^PbNGyenbUuGZYx4I!$nyXGE*7vN7 z7-i*8bW)1v(ka)-r*uC+>OI20VOc#V;&(4}?V7Vi-_wVU={MqW;17;&SD#3~a9aBn zyUIo_c;4&E%R6*Dr;qbEZ#Vc~ToUyTuC2Xy`r49==Wqq)DC@mSxyKg%&XH|Bub^bC zhdUA<$3ki;wwqhbSdOw_b<5X8lhRRcN>;1)$b6P`E=&16dU_`hpOwIytdxqJa#nek zwD(0?My=Woy^eAr^Ec8q=ZWp<`KrI=f@~ULNzP(esTN@&CT%cR31>c83T(i?k}Bt* zUr#FvvUD+jJ+kg|a>p~jkXJI<%PX0 zXtc5_=7;fN)MWTh%Df8tQZA$0q7f4~+6Wq(Oso>iLq`_9h`igIEgX3#PTNr|# z`-c{oIctTfHysqY_bb zmdDQ=zD|9G1?Mh!bD(!VwLI4GK2CYn+w|eMEn#pel9C0&Nmt_i8hehPUVmpi1kxKj zV%b{Q1FqP_+KXm=SEaBqXlOD*(f{VHhpH$4=sF?lSleh#p8O@%aU1L$#U^H>F*bzn)Z?+#F}wjP{Y z_j<(mrl{H*sQc2V9^bmiboSMFvr@;f?V}=>M((nCdgTN6V60p{M@)YD7v9dTUa3+4zl-7oJu-B9|qp?T_(+Bs!##$9=yNtpq-U4AkHib&&1o+kA4!tr&Em zy}jFrd!2%H@a&#x-0YcnN!wk0tX4lc^SnRM++ktIz5d;8)hg?{(VOPc^cVkTL!A#PsLdoc=IKv_}wSlzZ@nPba_3$_5_y)bttnqL@S`TB}t&Ku2A^&0G0j|is_+b@_^ioO^paQS&zoXQS zGruwK_RBbv4kzi!!|Nu8r^L#M3jFXXVZnBjPDLxQ;BuOZ}<2P1{3xOG6selQjlwrm^PLKRr&rMPt^j%!60@ zy}M7k{hWBQ=K%QwG=VA=8(1Y~;TFoQXmBJX6icZ` zXpy#7l+AM@MbT;>)|MH69qVLVQ);CD=vR~=*N#(mY=`gQq9sVu%JcFFvL5%KM~;-I z1mI{ystMZ9%rmw(^XT%UNIxsC+Y3JQPvoy^Q@UHB(a?>YuYu@_+NclQuQJ>7avRNm-T+RLcobr~8 zd?&ZxCEquw&OEHOmZNo&yur*e5Q(<=zVA!OFC-lEtD-6AC)y( zr}R|cJ}2apo)QyV?lq#va8Leln<%mLR2FkuS~vFD`AF9_y$A4*5RCD|KhT8*O+7qn z!K5DkU|#j185eCV+|9@X4Vt@%T0^ zqY`>A?5uO#v3bjiqH3pwP{K-5jSe5PPL0jJLaVZbtjM#YygZ}hV&yy5sTZ2^wKj}} zHSf>T{+?ccurUy2iPJauciNhDz&>l@-XLabsMA{FTI$*t8IIyNmS|tn*#m3H7UoZ` zJga<9f7Ne%=>8cj_x*{RwFnqfc1R}6Z*N1MZ~ZO^d?BqDqdWRSWsg;_*o`mLwvF>C zO?-@Ij`SI(G)5H*a#fw!N;dKwn>OOxjk@x1=~F`8bwRiCmVfEreQ@7UOo{leN{#?1 z1u3F*+xOSx`|O+0t8dR#`hK>#TA{AKt&@1L(ZK5zN7OSP@&jT*Xb^}l?Ok{FW66w@ z@5oUKv{u)qQw+7Gb0TC`;`l*ectv{+k5jyxqJ_)2EA>)4a@ zF&C^Xrs;KI`9bIa1xbx^qDxdz(`o)&1ib5qY5d8Pis8!s4a`%%4ZXkJ7!!#lA0$%U z?1V+y;eXcYlh0*K5Li^#hP?w{-WO1c-5NVYHepMS2R2J zX1?T>2Y?&nn?`vP-^K<;Y)8VTg*qQlMve?sM|YenNn=25)!M>CnuQAcJM0F9t>_;U z<60i*Sd+F4uvN|CM6B{-I(1UM|1uJ~{ulX1%uBMRFE!`sd2tz}GFqrCJ+|FeH(E=w zpK+`hbdQGZL&Tt+%WphND%+&AocQ&pD($vOR9=o-@4V;im`xhxZravH@`HDEQI8uB zrrw$R(L%LgEfU{^{pAn*OKMB0X!>Y=-hW34x}TyR$23U>UnZTzV%;OE4wl?rV#LgE zaMP3fZjqP08Ry)=-(Ss`?4)9SO`U#DuHh&R-S$acvgSzM;iz|A-ujU6Au2;ZV>Cia zN@`O?_}<#tI}p*2Ed^({xO#KoLvO=A5v5aN*jSv(K@>aJRP69-C5jHl`DR+=uq{pL z4Xgm|AmuZikNWDP7^^onSg&hc$^}UlBgc8Jl0Lou?qE&+#DsW73)vz)7Ny2-e68_V z7C;`x%lHcldE4C~XOJRg<7tbyd~HLl#2ft7r)G?Y^vf7;-qW)EmRr91Tww++NY(MB z2uA){GnTGzDoS?WeJbBkxuWg{*LDQ%v3Rx1A z+P0zjkH)V@0)LWL>%Sg5C6Y^DMspyvZG?5SXV$#2Hm7#B@$}*NOMHO$Am8y= z+c~I_U+kKaT=|ookr@lT$R`{ck3O7h(H*QRZz(Dlw39Af>7n|T-le_mE;{YpvOKh> z&MKc#0fBfIdcsJaa!CiKOjoM}2JKthIvO|qJUw>3r|<2(jftmTC;#!$pWX1ckI;7{ zN7p-c1}ljbb%b? zy^CZ0!*lx2AgAZ_Z2!Q1~SsFSW*`#F{~aG=O1K=_?xJDaDc>*nXh>(z3%#!`&E3_P`;iP2Pv{H0qyNK>=&W0CC(AWcYUp^sHXUK7=Nhj>lQxzJkK+KwNLfjKIq z9Hlv44;3Ukj<;67GEKW>2})clsM)cms3RxZDq4c35Iyy~&?0AZC0%G`D)=jXW9|03 zp}BJ1{64iuxBg2XN-ZE?Q+cT;q% zw?r0Oi}J=Ro37S_^l2L%i=45aBbrOAw2bn7wt?~d$a;Bk+$hG*AZc{5bpGY&wY<{X^MU#Lf3vcqe>L8T+l|gf7ja0OLAmfAsW&w zI!vsOJj4LJYVY>eNUeWa9;}pL?D^@%uZZiXLF-mtD53@PAI}>DI`=@brRvzYYe3&d z`hDzuK7qu&2T!m6kg z2%yLEi|@95t=yqYe0PoJ*c)OUiXWqVEH_8#T7T&=Ufp_)xr`E$Up<{_MkAifYVm)c zcWyzxD*fv$rEeiUk1zWT^FPX)F8SW>r`P{!-+Nt@>Xo%t-y>72{P{mKx0b7%iRXG# z0Mq*BJZL59QC`RL>HDu6_4=-zt_^{o@#0^$>Y#^n(ZQY~_H&=GbrLyY;(kf_DCOfs zN0$ekrcW!PF7iUQ3g?2KxXwKijO0sq%BTcfgLOaWy?>8EIq$vPFEB;vLY={}KeWzB zSA-@mvDBh7@d9H$q+-nHJqbqymnPG@Sg&YHexYSdiwp9LOky~$?Pp$BQf?)$tWzg3 zb*Nw*%bhOJzvGJWaMtM$F`rsPqNaoc$H91Z2lai&IBkcyaGwsB@MnC2=r){I{xl#f@Nk0^GHBm5_&kB{>Q>d~oezi-al1Cz^J?G3NYW;Zd z$Z}m@-PKipQyu+?+H8*D3C5Nj8cJqrPKu4EtYb`qOy}{bN2#6TbD> z@~=D;OmvHiF)G*X=gPei>J@9sPkJu~yF!2=(2{P6@1)JXRbHTX6iWYK3KD}xZO@eU z#;nbB)K)pKQ*f0dQunzYKQlpFxNq;?eAH*n{z$LLnP%uxyZF}nvt*wrT_0mAYbnM= zzO&@?s52K(ydX;1HQGLqwTw$73>rw6wzgGyY2>K%`uQma%ee~*J1yn$)s z0k1}v17Z3POG%bn%dww1_bt*^p2%G}LN%@BB_ANXip7^T9@iy*%2gltmGaOhAMsne z#lkOAOr6gEwHJvyO^$e-8INivD%9ugQG9FHRhDoWZ-Gp&(AFN&l_bUuwSohpm(s_> zA}>n#EZ3mR`#~O$yARdV{N+zPw+7FS6t|W1!LYyYJ?CuzEeHCjgLy^rDG}E*>vtSq zysQ`HkSz5cNI)r8FH2e*;tIJ+d&QFJH~E%>>^5}y)2mry@CzUA`Z67sH&vFyy%w}( zo$*RmPYEG2wdhl{#m{Hog!QbTsADjbIy`UWt+qWD#jY6)R(Y-nt!36Y6+eIy>vjxE zD=JbXoxD04FwbI5`B<}ZB0Vk8mIG(36J28J`J|hki*&3XKWzQ<`=rh>fNU*Z?B&Sc z?}K-G_@^#oAX7Bnp#NxZyU^jCIAPhiIrFWd9mID{*dv)QPag&OFL7=5S<7ZbCXv0m z(kg8|M6P~QTsP_&SK6OG)7IUQpL0RK_WmO4^@yL5zw2chlaO|Qk=8ax>EqgZOiJVT zQ9^n3$)=OCTS0V~_#gj0_pTn}HX>S-Qgfv0HIGGfd+p}7Cy-5mE7SR{W#@0JvX=PE z{Ta{KWqdcnyeBqVJ6elpYALW9C>tfv;nlQ;L`>k2bRvRUE)61GJB8hAo8Q6M2X8&TfYP~M4Qq{}LFA}s+pAh2_0Nx-??2;`bR3kg8i*{>^xe-jb(Pp}*OxbZi=LT<3LKlQp%uUNFj4E7&~Zn5sHq}LG5cbtJe=i%pbSJ8S}Y3++b z1n8KPuGM}InSAGtyuSEXO6UaJ#rlkn#WgauQPxq_EG&Y0V8dd?$%?&DaeDL&Q$de74H_T+WHK}mIL@z9#KoM_52lnUtStX@9l zQXjd_Z!gq28t5>mt)z2z($sIPaMJ}!qMr97XdfM^G}glwqKP^`X1TXMgYr4{{|5gD zy|FMT-t`#vve2VCy}#$MR{aJ@-h1btSdQl&8h*q^$jFEITupqwtwrN?uT6Cw74raM zrr++1lc!Y@psMI*?vyZcboVa#f`<04=w8akNR22|TQ&(FQHF&}k@PJA(r9_EQB}^a z?!kkidE||s=c+og4CxN-c%bH5rrG}V-sy;Vo>s@%jc{ko=zidMU#%zY4y@Z&m<}yS`6oc~W+SFkSH2CwW%T?W z-dYE5@SG~+&X%O_sek2;A?$BuTwMJ2taQdl4?3))dt8l!U0c*%@QsDC6jg_W(oe0; z*Rl}OXS}}=ik?OLT30?($+_6M-)isqsK*eW`j7i~a>74xJy0Df$T{t!Rw6>7WdBJV zX%EulMCp#lDtY{L`1Y<9=W+O#KJPY{U=Fcpze5XLrC3VYMNs^B_w5q5h4&pkfvTU_jp1glGPb0Bp`MisF`yxco_v8JFvdnn= z*YLeF?*$hM6Hne);|JU!yJaiq+LYhmd_j9-f|~eu^7jhq@y@H-=^5W5CZq><#8h*9 ziT7Pb$@*B1_d`FHrhG)9^j|{1^6gml;%Bir_2KV*wRXgM?q`*z78z~vPP~a5(v#QX zs8NBmfw#6Eb4a~oI{K?M=3kalF3x++60IdF_qKeW+XK7KcH9@0B97Z9nP$hPStG8G zw1t!}W#Kt`6v@vxs4`HUDe`&Bk=-)eJ}C>zzCr!!(Ys=^TZZ!WM_j@c<(Z0q%i{y{ z=;((u-^OdLR{H1h;C1D(Ph`;^j9}1Fzvyu1Sw8U9mEU^Aq9@2GQS<%#-jm2ZY?eh&duYUz%4{7uex-h}+Xu9J=Caud$g-m1zr;mnD_5wL2G-y& zG`vfz(X3QDmLfU&)9s!GM>6yykqp=%y)D-uAC!;@L?UIQt4=Bhpu|UXJ zzJq)082#yudao;2@>pAR?$54WR=!yRC8fpSXxkypaZwd(NQuo zM{$ZiWT_&XVh(U-s&e}NqqALK=Hf1=XpegJkjfk?SRR5~i%k4M1#&?Mfs?CVP=sI!kit|LRkDcCrp(_-$H*H;f>)VzLbt?0YzvkN; zXZs_<#-|=sv?LuQ?DdY>&AGA4C0a`S_Z_Z%9^|{8Pob>nvGj5-J>=20_T}zJVFF8k zmJuv*oBLI;kZfD8$BGlZgj9Au_4;w&z?x%Woa_3COiqD58n-ZaYphQh@5(VAaOMAP zyeDAhld@V+Cx7|)^s^7-c)-7{Y`y0y2dHe^;9BdiK6HhsB%yNjl!sRYf!1Qg zclnm#l~RB|;u*^0>MjT0koffaH)+oYNT|-x8DFt|%LkMn$P(U(w=JvV+vIr<%hbE- z5yUHL59AO6{7Qv%sYkSZUi|W{elfFw&xL}yzovM}~r{Hz;ZX-=R%5fKT`H!?a50%FbXRILk zyxzxp;Tk@OVjLgetWKK!QBtqvl`i$yyQi#GGRU1=sxLJyYp$=p>1s$K!vRaI`JMJ<5Xoc8V{tfWvT^hr`AQ1 zs~nFtD^!9I+y|$lo%qZC@_ec|| z#J{}A7wH|t_+4&HsU(z~?@{r!*DXc$^w$Tos*@`@mR=(d(#++hsF5#o-Dg*~_IhgU z$bdFLUgbwFkN7`mr_tIq@ALX+cKy}7 z+TP6jAm_Xq>tua1a_0f{0AhFXMZ`i~um8TDT~ylPc6y6S&WKyqX}_O7zWlm6U0#Z> zD8oATVYPAi7)v1Prl%%1rf^K5y4xRjj*zz%Fn9f@ksh@|F|#e{xAB7Q4ej@%;Bm%_ z7wB)#V9J&7q<{FWwCSuFH5S*>pOxp)pwTC-wBEl6Nor|waFU+SX0PwWtNM%{5AZ4% z-xs>zwfeku9k0=wTxxsidy8}B3VPT@S{GoXFYOaT50tf`6$t!(XWP`*-Ruj+nVo*^q!#*s_pJt zfoBjj*Q0MnTdqW_UGpKAJ?CtLJ5I@6+XtFnq`7l{tg+?jY~qM6k9>F5SE3i>q!jC) z)aj14`7&p$o0%i2sI|dsI+{@074L5za~b1#@MR0AO)vOoBwb0byv2pw^P>&kx*y@P zx+UbZqlkL-H`Ew8V&VEmM=8asD-n=CI*|&W^7hfv2;Fy&6~2tJBr+Ws(^E7jriSl< zi>#9YlJRi;0Mv;ZSdg4$Ye#uY%;>}h6BR1Xr<7dhHz7FhmvOB!h5+Zp# z-Bfc1&=eaUl{_V``yT6JJrRWZSun zL^|FiYW(TD)i^SixOROFY3iFl_$~A_?oZD5XMu}2LW0ud^J>CU?N(>#hnFXc9*kFHsrPt;S;r`kR)QvWT*qKD;*8exs(6`t&rfiDVvwG*qY;LFA?onduBCU)bjF-lOO7X}rl^2`dWp3g+Z61^i10|$Qt@cA z8ubXxvc?L++fJ*~G0v>!7?U5KW{pTqemR;*R%$BWtPI59u-odedx?UY>y<9?KXt1| zUstMGs(ST!)9E{V-^LO~?!B7}3n2$qeyru*CE-38>k}RIUUX8uXnW2N);A?*xd>VG zlrwt-cWIbD$Pnf#4QQN_Rej;gDdk)Eyu-Dpoi|; z)h}&@k@&V+-_fILL-ia%zmkDFDDtXuz-uR^eP~m3qy=+N|KbA=#7{2a&J-NiiGP|^I8kqJfCBA zet!Qx%gIY<&>se!&NN>1i^^+jfw55uHnffGd(PL3#Sv{D`9$qodEVv=v&*I9t24Iw zPT2!)qa|z>x!=d`d!K4;z4~3&liZ^T0r`i#t$u?euaPSov>n>FR0sDVeQeYoEKdEN z_eSxnyME?li@b+_L#otx?%T`%7~|FdqLpe>V(K70{P%~_5Y)X_Z{p!+D8*KexA$1< zdH}BMrRSPK?>BnqZ)6>Oig7qzq+nT%0!d%8;X9jGj+l{264W#2-D|v2Jv>DL8dhsl zGIo`R?@Cx4*iTLlv@RZ{BnlXMQBLjer3dGooF{eFix-ieu4jB3$*m#fLqD!Q2S>zc z)SLbCwxLIy(zlYtZm`(!6_;w$^jhlKZqc6=AHCm}Z=Ap^0Ql%Fq+V|SN=+IV`%Qn08SwBs>5ATd9@*OHMluHtN$~ z!ST@GHX^{q!lPBj)4j^H72BvNZe@V9qOD76q%Ec+G1nr z@m7=JMGmH$BXb<3Os8#7S~VJ^2Fup#y4q69Kwp=7>7A5}%c!5fJ2qnyYu?7K@^bJ8 z(xTheQGB@Hl%qw&5Vj$&=v<$mR=v`ld;is6{Rh_&jZN=u6<4IXe)o&&YV{{hj9;{y zD8LhXWX-M%$ac7<$1s2J#oEh5`Hyd;SOW48Wl)j!c;+nE@c~>(y3tWr^h%dwPa#?F zGQ@i+6HAV48HcES6kG2jH|5YjTY>6^o~c2mXL7Ke9Nb!>_0D+@$9MRKnrc9{wh#3^ zi~ykB{x)qw+Kr#|`GN=QIF*ZN_B@EwI1TR{=9q;jGrt~c&!YSs z2MpEr7xY_eh}J#1s9#N;=D&!hu^l-~FTHsAn+lrIvxaKT8{CLlWv4un5_JCc59k$+ zRK*!mL2o@r`TE%k66%<;XrNqpHGQxv7sNs!Bi~RN)&3#+OkAn$KEyAjL@g4=7T_!V zRQK?Z3uY{PYawh4)*IR`Er08PF+`T2RN*}s@mg(oP*(&@i%IL}yCOLT_|zjT^14V= zy5Vdd!>RH#cWLi@z`Z%2J<$_^Q@5zzj@SI!yGLr!n81?JLUyVjh(hnZuAg1r(cij* zD5M~*`scNM7G2eXH>)Loe2iJD;~8mU57v=HvP*XqEJb?Bv_DCq(%K!)GubROWSMjQ z&vUKBnqtu!Jz5vG!moYS`4q+r)?@E4RENBosS((|r}+F{mTGJL!WM%s1+Q16k$&6pQdKYxmG2%Wx7ZZ$^^FbomSUB4_-C99An+hVqUbhc=M_8S(jT*B$>~ zR_ZBL{jfZOt}T{0yJIic=+1}f!+utL*8f+Z-v4hzkgaLiQ=|Hr?|MS#(JY?OCv5Id zoPmt+zOIkC_3hmH-!$+0{WFe2Z|kP8j5N<*jRSdZ9AMS7zSuiu?J->mxj%I_=^po? zzW_zoJfBxwTl{s)^or_gOwn=rU(fqz{hk)S$KGZ-qMRI*>ji4P(&OXn93^_){eN`1)E8i|Uu0>*dX zl>UHE#pM2`rAd!~66zUnEVcFmDkjRrZ;Mg_gOUr6q^# zGQIC7mhPAxow{{Z1*N3hU_nZZH`EaPgXYBX^g$>i-7ohcY`@kE;<)|fl4DaZNK5bSlTjRN9kACyP$KiQ03Q zQscd_V9SDi`H!;TT!>n`n_wB%$HS`djGU_;Szj=1$3w#h)Ml}NO0;m7{b<1*&C03T*CxnqxTNt&`FM3r|dJ$3Ry-j+Zb@kt-4<1*4Lfw=`oE81f zqQA_tA?9m7z%~2Ee6%!aqWir(lQ-$P&}hgwlxK&Dm-TJWa_J)(;dD>KHNg$&lx8D0 zdV!?YHe-u;C(~JLTI<be9`b>V( zM9ucpK+G8TorBzO#GOD{PfclB0=25W_iRd1(3{jqq!zsNgnP$lQ#Nwynv_FlSLpAk zi5pvtH8_2F=L>T`JA8zJD21OQ^gEwI4<_lU`fNDcE$Ken&%g1fbLC@~gKDtVX9iJe zhDUHM0`ccJ^^Iq}VD7yeySFJA= zdI#5wWon5^G92H>Khs`V$9`!oYUSuOZDX}Fms*SVU<&3cpHP#oRw2!(yqAAYw239& zA;rbQEc;dou6^|9vc3HZ)Ds~V1@k;?4;=8c$VW~e?Z1%iU*LMT{bP>jSl+8!*}qAQ zcBa8A{$%?f!RO<{DusO|$bmgOW34yL=;7YxpY=Yb<8k<3iO;vlJ9Evo-K>oUtKLraYi*3gqcL|fzUZgT{Y5iSt zSUOTtkBc>yL5*1ChqP!zT4#wlKim12MUG?5{uv&$Vzf)I7GE){cN{zqbRH3?wP-zJ zfPZU;pDo{AcQ5Xm$34@yk?b8F03Cq~#?D{R6Y8(WTGp3KuDz$rIHD(&AlFQ(>QC?uE`h zigMqF##NLaUPw=ttT^!4*rK#ti=)PUvrnk&YBT>=nfl2M6_S=ziEADgC{{&Q)t*^_ z-+Zuf1M<4uL==}Vo$MjxGbP+-z&ADG2>{1JJ(*w)krFzJkmv3KKt;|Otq6#i-K z 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�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%0Dw~UCs zYDIEG1-6vZ8sinMiT7zOSNB0=kFL}g-7W7_TXnWWebRWrT=5>cXFgHveyUj)2Ei@M%3C zCZx!f4?(Q@67?ISROObn@tVB`&ZsS~2Y`pG@9x&WwM~A@Jy1tb#h3oa{%Z7J%#+?u z{P^i0iBb|ppbUE`QY_~W`q^294rwV)_1DHY0W@GfMB@a}qHD-g_cUO=?3)&XL_%MkzzZVJr9Ob&@vr#M+aNMY>u7|A&DVo zA`R>t&3C1M~Sc$_(I>Q z;|qGlRwfN4zi6Q&dC|Vuj&_47a+ALy1K@%!L0{k-q-Ve(Gyo0Dt7@uWgk&m&UFnIa zbto@#CGJ3!`X72V=^3eDTtG>1T%uk=G<0kOJwr1>uJy)u-P~?kUVbKpvDU3e$P3WA zynC!iNgi#K&Vd8puKoX%m`n#6G2PH+`5*4LBXcJ}r*Pe$Y ztj6;*68+G#&IF$DM=ALUTrg(9L|D~Iru+uKlw)ro%w!>G2U!0d&rISyF3_WlDYSE; z^$K|FFqd-@d6puHOncqEqWf(pi%V! z!P;9#eHHwZv8woi zbm0)`RqTR(NBl%8Dpm1?@@3qbUOpKrv61L;KSx=pKFR{Lkc*@mFZMOaSN5jXoI@?4 zm5Kl*B~^zanSou!1k!iu1%nlBYVp5=2_)0&M*Wp0)Qi{!ZEZ@ebfNMf#*i+sKIY4s zP+hV8X*>WO@$W^0=c_Mv@W`zw)VDy5V!nR=Nn3_Ev88y1@qf|QFgn%s{r{xC1$JcF zXg`zs4E7s7#8)uIJ_o5$D!ohcAbQFib+FnW1xlKh)G|}#t-M1xnWf+pik{wYMRJUz zogZV%x+tS+NKXU_fCtb63OKeYdFiSifgr&Y>+%fDklUz1_-I_$^h^m9CX>F~&Afv1 zcKCSgC3+n^@uTD*TsRXesddB`e~-kpuiEt@$qac6l#(m)ldo}HB>HS$=+lG`_;U@K zUrOsTg)`BX)RdG^kpJN<9V03{+srNXb6W5&6Rt&cIpZqJQ9hnmL3@eQ&UBt>lKe9) zhjkXuU9mmu(`XO(q&cRl`_Lp$Sq^axR`uYM3P1ac_$c}tatFFpE>B4!PLdVN@i*9U z&W`li+hj&S{)+2+i`}*iy>11h6jzqisgz`2816 zpCzQ<8ikn@(8rv1<%|P=?_JBSd>Or<57Z~ELpk_**5EDMyz1`v?8K?2vv@K zv95iF8Y$cBu|(tt?@$qp+IK;_a9^D9vu0Mj8sH&&N{^OnS*<~-vbU@XpC^BpT$=e| zjvUfnWBy?V%!_aVk5ks0*S6@ftY`F3iVk`onzE2T~JyD%EkG+e>|F3+-?v zr|3#MtBa1^kh9qyui>u%?N`^W z?e%5Fy|G7-bl3`MJulZRGwViV5neP01|91BjCBAsu%*~u%SwGm_VS>vcqi*x`wq7k zSs9J?A;gEA@Q?WLb8>=~qL0u}^*|TcS83enysv>SfF!l-%zw(2lj0__iyw%rGUADy zs`i)qB12V|x}4?EGFAHv62Lm*pWv73TBTTwNToeoE~s=takFz>{QWbo#AnvCjmlr7 z4~hN7N5SKi1=%kDhn{V$U&nPA88Et__ejrFJ(~OpeabkL{1Ua$>rig#!4hS~3-x?X zMk^UL_!=ma)+8FT4wYvESHy+9q&Gr2)t7eF-X?g2zd{GKfrcK#+uy;((Zq^Z(mMf! zs*{<$#s<7`{|D%ze(+4R04*sWuBDvPc4H^DfdliYCiHoS!0D3;#<> zwvuw7s;)U#*Dqy&r|noT)zy6sG*UDDLe4dH#Z!+8r5+fs*tinObUiLtHpDhKTf(&c zf&M{!g%)c<{1s9{1Kvrg_^0-RQcj#x$XDBzu~x81PSg~(q(7$3QV<&QL$HjQC)THS z$d$249YqnY2$4`G=_v=S%$y{pnSWiL_Ly?SRn%l1RGFRVdm-vQXucT$f&rJaFxfIN-iwrc#v)Ioe`M3wrLv7M6CJ z9_b2NE4u>$)$Z@+=Q48y8dl~m--iHwa>zVCUJJ1)j1%1i=XS`R_eiX)en7RI=9VS5XH+qwiQE-V~`colb9CGhT^j4KyUyGh3W&MiZbgB=iPaJt3FL6Y0%7`ZI(GFN2{Y~_S*J2ka z_0U`E_7}`=REXb}_9032T&I$c@Q@GudH5t!T|Wo9vQ8x|Xh%K}6XDYHV4}irD}XlH zE=U(!>EEB0=S*2nQ*NXn{Y+7Z96bXR`pA{e0WbD5uz>6v(6dHd%6SV%tI!!#zP7r_cwR8LZ& zufFY5*KZUSd9GOTWs4%UDjK|&c%b8x9?z(@@(Zjd`)=HijdiEe6vriz5>Q6UZtZ-C z@O7pw=32&SrYjZ{ZAn`7BJp&wvSAAUcE;=L| z%%mMU8_%>pN}DUWs=mbYN|{#xmU@|3wwbkqDGU3Oxp&d=d>g(mKhu5U@8pqq!hJ*J z694MVHZv=q=(Phm@jj1wrdK`ZIlY|qV3d&-D#8dIu{B)(Pd+d0pl?%*|KI-xPKo9J zf8UpaJ8o=;|C#UqsC65>V+sCvEUxxwyyP()eNqnbOPykHgxCuG1V>JcB2-t!X&FUz zZH!*VG3%Qt_4*JUinbv(kXC8+jk+!UqMQc~MvbDTvDFMUPP&I$6v;8}5Fex~qoZLP z!2q?}VZfO_j4=PZ-xTlwH{!r&6aHU&|GvbY!k)?E=GWY0kJsoYY!$Hxres4}YfG+C zU-woSJ-H6hk+xDBufY?bq&;7mcTgRkn|9P5^C%z8p=}~x*e4sYr*S>1Yj_;_EbYRI z7Yjv5X+B5zz{3eOJc+_~S6?PruJW!L$^vy|ZANV%uN+^II?mY)E?Q$!yG+&ZV;glV zh;T2@ln>))*;?U{)@Ht(OIbY?paJtEma~3MT<+h}@9$uHoW*d;U%OLRqzUT1NFDnz z%zLQ6(=})X;u~ zi#h2s-b00K6C=)5=OmQy24^{5D!n2dJn)xT;0$D>s|jjUh1$@MuvE^ll=2W|W$z5j z5WQL}lN|87g(?sJhp_;5Z{)pF{muo_F7Ik9Ua~Jk7)c*Y8)z6lCT|ti^+jbd>6wUv zbSu__Ym}7c$wXQFA32Bw<~gh(!CMX79eveOwM5SWD!M20bx9Y|kY0$FaMR^bUzMto z>YQKpM1ejbH}5^vQwEC4l1f6fA)LwDKzv@~#C7sa%7}VJTBtSA5~0<)t4H!rWdz)W zSvi> zP&yUM2nDeVq?KCQ2A$fjDqG1xXc^SSqCicxlU+8g+X{b)eu7ljgLgzZrl{}R==F?_ ztsIS{ziBj8>#-HI7U9iJHDV~-@ciXq6_F4FJ}axRNPUe=_JG=di$UEdqhE+reE{1K zF1R!$6zPN}AV9Q$K;@JktvnebKa~RwN`agM@|W-V!+mqn2b78SRU7^iH)Qkg=FoU7 z`!ecFH-r)qB3g-9f>OT^!nPEYFf$?l7IcV>bVw-Gp#UpoU;;g;nPkV z99i)lS3?JUU#6WNST>PHsKYu|p%-d2i=w<4=n3U(hrbgJRs7-spe1F+@_R_;Ja7j7 zBQl6ZE; zk9PVKox+S0ThFX?fTCmn6Dj|(enoci#J|(8M$q1eX1%XNvq!XbM~9wUs)zwr7u|Dh zdd7$DVa|GAr%p$xCpfszptd+ir<6DAeI1A+v)W{+b#c9b zHOW_J*arPb{b~a4XZ$y|fz<-YMDrZsQ*!HA9`XYtdE-TlvuL`9~x4gP3SMS1CrPy2WkoLxY zC+3QMfEv|;Yh9n($$AnsMYQ^;R)R~-D*!QWu?4p3a z5NloBmgjq_-;Ot*e-(+)BebKLO$959? zh<-$$=#7X6BMwp||A!QPk93250j}lw6FnZWJ;?8&9R6m#pT-`obb-DD+A-It|f%M5*btrsKql2+Vz6E^ha%|AM0{e z5A$$-ifQ{pMmtRl>A``xI3>!^J1Ldkt?U2)?EN&*!~gzsbFfb8aNaxXxqi?~2XhqO zbEe+G(Odi*{a^J8Dy6S!lBes@O6Ajf1$z*W3i_TTkIvAB`iD-zM*nA?>-P{#-8u>P z_+eZo+0_5Eo?ywj$1BODr)$X}FsOF3-m_6L68FP!jS8`0*0Ww}zDg^0oWY@|7zgzd z^fH;<;a7)PcmLVXdd>8E6%vt9FNWq+p99TtoT2AcxW7`Ktb_GzfoBOYi@;b0agTZ} ztPfNQ>jvuQ+?&xd>Y7uo4Ut3fg#Tw+2ALxxXORJ^8@yCLM_Gw6B7>~WOU$aJlnZuQ zyI0o)zzcU5_-QL(%WH>!B130(sLD{CrNInI>9Ml^(U~1Yc0&ebPu9EWkn~47{Chjd zo`>k(OlQgt|NZZV;9m0od+$uldQSnK69LPShoUF_+kdB6Ki7k_aUDYY0!ADWU)KEr z`-JKj)XyO{P~S(8SXadiJ>E#|N;>O3h0>;^P1d1k8=@iQ;Jle4)~xpw_p72V1;2ept;@YoO;6>^>Q8XVwcycvelnITuBa-; z!Su^H6LHq^%e#mYw|Jgo%%#ld&1XFm4|u=aI=; zsA+TNL7JCXB=-FGKab4!-(hv6pXtHzNuCTKn<5JHTUyWtze^0Y+O^@9yr!bqkMRt` zJbh;c?M+W^=n|lfQmc1T*oSa72j7Oq-wgy@{4NXXLk{#UKKKkvBw~{0%;yU9(}0Lh zcvNZ0vlj46PO_Q;nqm>6xga9Ya?j`+S~I?vM}0)bMd`EEaSL!#J;5vEq^_SSeJD); zKD~xi?XVu6m3`XO*?(dD1Z|KOh$_Ysx+083SpE=k7Mpg*DrF~;x(peTG8ryk$`X8aZX$+(PqM_S?yT9327IZ7JVu^g^YPjbjz zAC>bTeNWdz59W9<6Z^9qWk1$Ea@P6*dWrNK9be>`f&aesLuB}=yu+jYRo_wO zyInHgC`*FvsJCMrM9adj`cC5IB%8JA?=RphJgRZ2aiLdXC8Z#B_KHN$cLKjYgp zv))r(&gcy~l97MYmG)Wg6B6qnpJ!V#D{9}1R4>u9BJMpB4Un=>!?w7>#k_VasQ>i$ zRH3i&{#a*wO#d0*IZ)5f;~I+IbK_XZF;RO0L|j_47~`txgEaS5Q50LU4@wP_iuj}C z@$>tdzlz#YDydNFDCIgGAg(?^WVWVf^RZ1A8k5TJ70lfCVxd$=ZYEG2~MEfck{6@=X=N zDWkA%C;Ee(DbX9Y7k>t7|K<0DH7}Y?6E2iu)_eS*Yv})a=aB3?yqy1#Z61~gFzY>j z@uSW(Cixi4(0AdF{0veLuJJn%v)4k8er*P|mxO&Nv6!q`Kwovx>1CC-gh3-JW>2BOPcWOU)TAapdY zjOL&bq9ajL@S+B>1b!_R{;%_^j-T>h%^CpjoDL}0S|Y7VK@Q@BSCk|4ITd{Uk?>A0s!OdNa7GR@?{dvS@BFqaFYlS)E)o1 zomt%JMFc<@Ba51smpn8D@lTY24yuiq(2|O-N`X@OtcZGF%!(J6I|0lCTGP5mcmh?n zpQ0{Y^jnW8MZNyu8d~F8gw`tDZ;%QdIEz5)oWd-X&cuEOM)me6f2|vN2n}hE(ji(* zbr~ZR`er++2YFf!gzuISR9`_KTw)SzmdKy`uLGa5zW&CZ*u9<` zqhLAf=?M~)RnC?4imRM=&QEGoTVuZDmG~v+AMxuB7R4{w8x*Ttkwd3F1Z`kQ&uz&P zV(T)cnqW6XgRmD#TZMz<>a

    f00YS?E%xHrv~ZV<$_iU{o|rDXkvyM+FY2^m zHj0?RMmY9=!68-7cNI1KX(OTl+q&Uhk9cyf8878>Uw&^VaS523oCt8^7!q~{y-e=0 zo1tSq_&f|{$dQx~_^db6Rb>NC%lCzsN6i~o%~Ve;9BrS_BG*XnxxFWfm>kW{(2qV| zPf`Ts4G6v~>7h>kio3n+0#ps=pY%dDm{Ow6xY!UQ;qU97Jr`L-1l=CnQ*^N*!?)9` znH8oLFZ)e|h)+ckM@C(GJl^z+rDvB*d^?Esizr zHhh&}7Iu+DUC}_au=w|XKVaT(@Cqhb&a86~*v17jWvsseahT&F3Uqz>W%-*a=^=%WEB`N&j9tHw(JeZPy4R09;dPcy#Jlc9t z!4#Dk+qB5hY!^$Ts3*pL*mu*h^-MCF5sNi?Y~$h(I=dAFwit)M9#+t#erki56m%YS z$v`x^7$z}Z&ed{-gPACvoUv@MtMJe_D2<{&`GS&ib_1G$MlSRNUShIMQY13Lcj3P@ z-id`gZkimcOqzn6dIel^=c7Z6RKwc_eF6WXaQ~~kaMOPBec*215Tl@la{o$E06An( zgFPsK-F|qZh574lM~FuYq7OE6-Yf`FWiivsKAb;uFvZ)694sBZh=`7yaNAY+7viMm zI`*yXn(F7VdKx}qB)D%L?XCF0Le2L$^@8!vT91~OKG;ljv)#q_66aG$@INu;#_|an zH$48OjsQ@Q#JN6yIZX4ihgXbU)=y~zFNLq)9Fd!X`WE`yWID!rvufR1P<^f~uE1{a zEQcJ{l0-P41|I!F)pAf_XO1ABNT&WZ1D{l1FZ+OBHj01rU%{NQdkM-1ER$1fdJ9|( z03T;&$?on>sWTNnb}Id&*@qa1f;4uK9KY|^@RVHaDlZll>v^TFuuOlXpfETJJgkvl+GGPgbSv{%Qb_94g?Goz8|rMj8Zym$+=wnh=Y6-WUa*E z|5miLBY|_w!l4IOgq&E&aIe5#4}{3bE&=nVuBAI&PxH-bO|_c*C;d~ zn09O370>9F*Fad#3ET8iS@_NDZozw$lb_E0w?wqZ*}tl}D7Izc4S(Fh3;Mxm*yv4@ zH;@;I2KR-M$HQ%prh6JB4Ey;ZO+U*@^x=;Wl`n;Pb_-^iO-)diT$lexcv% z)7%UIx}tzhj|Blp~gMRcG+| zzbVmkBWwJx7hZJ&A9DWg-T$a1Qk&VWxB7%H{>@jXCj=8tk&;_(pnV>WkL$LJuwfu# zCji#?bu$J}(OZN7PzKBzchU{85|NYOj37IO*;uQ2E&Kt|uLR%PqBta`Po`*9p{4); z)6I|m=f$^x{z~4*dWkLX>4#Uq3ipNv&#RMbj64)9Hl!sMXp6yVz$RGNC*Jp9`T=xq zAEbZ*kb;7{yG3dqM3~G((I0r9G4U<8^0=OnfD`ZtB0zs46J#mYo!mX+l=%GZ9HqVe zo#>U)T*9quOnf(1xlVxl;@LJjqZeS{Louzu!@L#VupLK|T^IyiNEIp_|WoxCm$` z(qi4X=P^k-C_wYqFH{}N?~5@tbv1LLXM{{;pw~C-zdRvcT@TEiLWqFn%1SsI?Mc>w z$J-I3r^2lPqhow!lM`&Ftc48-Zyu5D#MWZ!{Sw9L2ghla?9IY|Y>oKIM1_ z>OWO(9j9|p-F$@00TIK;SsMJ%+>Ng5LlG-`gV`wwS55-L=j>is_U}m8fP$&lrmV2n za`|_CsAD@q8GsAu_C7Gj43qo?dkn(Gj`vi~rWbr$lvG8s#GKEzLh=2zv24QTdKlo7 z{u&&fpuXz%#r5$>xhJ>dQEJTlZHCF$foXp)$5sp5e( zPQwRTo8`>5{Xwpi3=yEC#Z!@6HO^*`mHYqVNs;vo%@FiRl#7iR1+R-Nik3aSX4O>$ za#7JMm7m2MXzhrkfDb6tdU}{;Nc*+!kY@4Obb(K37)VX@bI>qpmMM)md?!j&hLy5Yk0aZ3+RL2MOwar0Bv0l(2Bl(w&(JK z`d_#1+0eFTG*+4J*yNLm8S*r=;k-3%*&ES(7elbems^*qfV{JRN!y4CRDVDNmH!h4 zQ?-KrdrhnwQ&BAU%ZU*f^Hic_0g5Nu@NvT=YPo*4@Cc;575qT zW0CvW?KJnJ+wF8hRiWtrd*Q!#td3@?qp1GBKM@bS#wq+^^WPT!=SCOo|3BZ>(Xt0> zCKMyVD&YlO3|&n0i2O{xeHjOVLL1C^YXExu>eY5yw)2s*5g$-+{^m$1&>pgx=DU{D zq4@_h7{2t=#oeO>iDi5XR!8_SG9c7hfh_9V9wb5T8&>f>h|&yA9q!~YYcQr9#;n`= zq6Mt<+LgViTl*p-ii2T4Y-0#&r&D*Pha0;7Z#9)h3K0?BZIz0d#Ru8{oFX;DS9ZYU zLd+l#V@Ad5V7tatU;?0Exboz(8juc7^`h}LRZYnQ?!1D-bl!e8 z;{%E}SO3@ql*kS}$ntiF2N3(S-fA{vrIxKzx99BbHNgVAH(DJvUmq!|JR|YZ_e8jI%hM&o zqeCcGcxh^x91({iA34%8lmvuPWQ=;I(oe@E8!dXuA2eMrK9)ZjgH@obj*h9$D*L0?r! z2jqkeg=-Pk3!;kED z&-mz}D)PRWaQJ8XOTS?Y{x(h23?0&(^y8DSnd_2My?6`XcGoQ*ANctBpXlBj@q3k8 zYJV?Xhy15WUFzx6klMv>8`0N!%*O`id5#Y`BiyGY~NZ0UuMXyfHhdvk$O;+mp*zxh~y%V}T_G}%S zZ99KbKS^Y^eFqQ{bFsxY`q!`CrO(=V8zB35xxN)yuC?yZS$&e&`KK}-Ka0%KXxQnt-(_KpRud&5N<`BC`aP%@vLmc2Kb+zg4*IVz+>Wn((J zc`~kD&?!J1StjWpt~=})>kv3DgHMl;R3L70+McX{;osEoUO;-iY0$skm0xx-*>9n{E+dcJOF6XpP?|60H455(v>bu+=y1 zM-#5uly`(*(AFtjrv@eio(cDt(rZ@G-QSMG=C`{0Bru#=yEkTiAN1oGK1A#GBf8@*g7YPVTN`sGWpo1gP75}ns0r5Iya`a*0}Fw(S08S1}2I< zYJ(-(>9*^{pGE5Oj}jJ@A9VvPh&^EE!m|!uIX!>p)Yi-ca816|d#hbP@4o>a7en0i zd^S1B=j;|lG)_fYQGjQZOHB%A0@7D)+UHNLwCbgNzxL>;J;;DA$oAu8;r%=&VDZ~6 z7pCRU&)24N{^S~=$x+s|*VJhrr=W&+MDhNi?K@&d8t$2fP%{Xpt1NJ7xg2m%4cs8mv58%4l9&C?vP2i6HZ2n3vwKio?MDWzH4YE;L@8 z7ta+R-$7<$_BPpvzN3`A*v8&l^8QXOc840}W}6__)XjQ#v|OD+mM+@UU!9-J|iU+j<;-gA8qs%Rk0E*FSsN zdYu?|-s*#Aj#A*3g!7|2J1Um?G9{~Z5mp3HdeL4y)zX%_)@EHU^7dzR_sY%u2{Ld} zy6nVljZGZ6hU=N|7lT1pc49x3zb}V zcy)r;ctuC3`|tz-=))Im^&89_WFr5>PIWm*zNGEOyy(ypSytax=l9M6J-#C+397ks zeY=#GJj5E1qQ)70W7Ze&3=cqi_J3Vwl)ZUszi*1G-17w&(uA>N!hm(PF z{mp4)thnH&!-jMtYti_fg)lw+)N6EFP*DZKlfpK~`CE?i9p zZ2j`kqD?z(pDntd_oE@ln%V2erGPH|rA4H`IsX%v$}-uHe%;ga)_b+_20R-JOV)1+ z*HJ!G0p~Es=i@0Lzf53H!?W2-YF$WeqN_NeISnpfiaib@VZJs#X0YO8K0Ub3^B7NV zTh+XH7M$mxi7Mvp{YQt$5Z-FoM|NVP?tnM~yjL`pjdON~nG+&p>%>4tYBZ#HqDtt9 zg{<->P#o4fXZ0ry%yhr%_t}H;F`!AY)F4u5)Nm?P1Y&;O;$-Ki_(2ZjUoQzLL{_iyA69 zkKfBzlI8Wf_uO{!F%<=>=vW&PXzjV*;Nk%8D217bn#Q-8%^ z2i+&_l5<_Id84CnMvius(wF#y1rwkGKCG=0n8Euoc9Eh6mWzpzXqZRVZDe?d=`;IR zZ1_N`&=NeAnrz?~EfHxEq)QeBe=M?k4ty@X(zUn_`DCp|4H<;RU(wQ`0U@ za1PBwLz*mly2ojy?Cj{B1^5WmjR%UvhL3VyvW>XLPki939vBY2#TT!j zCF}j34a$+{hnYEl$@NQ|guhboBSPjmw+MqdRW6&HSbedDIjZzIh+)A^8@!+OP;fOg z{`{c_E6GHnj{0W)u7??Mb(}rwS(K1o4R}d&^J~dMu1vZEwbf-EI+_#1;U$nc{3PL_ zSsXAVCd<>Tp`7iJ=x%I&Ms3fb(BLate2`4^&5h`RTYY1$O+#LjtP;J182g>3itLqQ z;qc^Sb3$?B2wTf{_NbQH*<|3HUp}nw#!nwQV8&JM9{Q<^E(h|O?(|eom~$8GDyiWo zNYS_IqM{n#J)WiKpi7@vRAhfUBPFxDT;lT25JP4_KB4%x6dGV2yIos-R}%7cg~Vd>!r|*@N2(cMC+m&mIe;-ynfV>LF13&V{T4z^V zT)jOP58xj`h4jPS;ctLq$5srWO63zek?5ON`UM0=A|nwV)*dxbP{NZI2)o9uA>ICl z@z*zzpvgC;2qS^3GaUQk0y$strFnY(;urWB^0@YIM13v8SOEYpbi>$L{DELmY~BXv z@qzsWW*M&JCcJYf&2&Y5@}cx?beB|SR>~ePSu;o{JBwwv_nd!f%b{9`)_bP&h3*Qb zVOu5#CyAvYI%2-eUT+`-wc=Jj)8Ld)r2#VQa8V;JIk4YLxSRi%f9r9Q6ui}q#H@>O zfLNQIMejhmU8|Q>BD?zP_Ye0aL55+Cg`Kd9FapUSfgJp}0(C>rL!vnSezr11ppmIz1W zD3HiW?ms~vH^tdBa(LbMOldWPnx&0npnn)-UzQ;&OTj+M`5I*DknK4F?Fz>HX(U#y z44R?o@csUow@L9g21Qf`jS|jOzS_IXueFx1%Jl9Ck6nd%!aO$gPwuo)Me?#3)MeEZ ze)%{Xfw|}kT-m$%aS)qa@BC-??k90S+Iu%mEQGbGR$DT(sqVNqCq;g0Kt(70Vbo3QES-g;zN{_~~HTnqo>7jUV7 z2!7cMZfX9}rad65ShW0Re;a1w^EhkhF1+AL_GgH$`t^BE-y6(C9}dPs{|*uRf4nT< z4Ue50lld&{xI(i(Bhu#1!@8$g@{5SJh z;L%Pv%UFdVYI%hRhYzWIw|$)f)Xy@jO9)RQ87OQvzggLO?H?|gpNCL@@rdZT%$_r) z_*O#gd8cD8&`yco0R@{P(aOga92)@bV2eZ z4kMxVj}e*z_8cLd68>m_a}M#5X5K#ewPT}O^dC$%h!5-A<#R!;Q?nI;b}zB+Mfc0_ z7jS@$m`rKKb%lj;Xy;~mXlJMK=~JcwoisGeVd1Z%vPLJ(I6KKhhbfsY;SK4pk_E_l zED0Z^t#x;K$w$V?E(+30VqxX(tPWhvXLX4TI6erE2xqOcoFJ8}@64bAub?{fC)U=A z^u=;9b07I%^O->CY=7^dT>w5+TWv-&41@TQ{V3>VOF;-&Km2 z38!j&q3Xq0&vr^sIz?v#d9(wlqC5=zpw@7YAg3*pRLO0OJ8?hd}ut^*th$n6^1}eG8nz43ymq zW{lY=QDo<1@hTxg(2-~*@#Z*hn^(hhuH6lSNyOC3)1;onmIkD%m(+SHEuiVCl{({H z|I9R9JQb3*L&Og$5c38I5yCKn2r}>?!BWK=nJ9e-#z&?@($ldjv_B)a znDyP>dtKJvo8YF6aQBAh$_76FD372(TXREXdgr*TlDd*yx?X{@7 zcxdRcVjKe zJG~GOvHZckFq>-`i3+wPm#L)*DXRxhTS6Y8#>&wjZZ+>KB~1n*qFbNYv%q_T*&!Ad_^Ei-ot*)} zCZbvwEEG-+nYe_*Kx~*2N6BD1#8-le_mBq!udsoo@#dr<^1XW_1HphrVli_3(~ofE zU~A@b=MI|7wUKf9euo3S(LdpNn(Xs09X4K7SQyuS&!!IQ#=mk9?6>H9H6P}%5uL-V zQ@q|EW)*!aIDM+W{9999(}PRPDGrBuEGn;-O7pXkm7@%$A-HcO?XgEhLS1%b7%PEz zYKYhxEm2osFk^P+^=mw|W(e{&Hld=eaAIvXSsXqdax+?ULjvVr{N_Ef(QY56;vYs^ z`urRI&IuwWAulY>DfHu(GnL=56dPzV?&ffCO^(JrZE}$5bnE!*y`p+P4_qH`s2&(^dp#i|>r!dsj>TGf+fQN5Uz_q8u{i>nu9M;?Boc77 z8tc|t2L&Q(%-l9$QdePe4m;iD%k0(*rquK%E3+f7eiznGq15E1+1~aGn^mujQy^&k zZq9O~%QCqTADlcniJCK#^V3sVPOs3Qp*-A&BCSD@wGTGV-x`)Tv?sdD$04&UL7jiH zV>5Czd96S?T>@XseX8yM99;o3r9<-h+UP2~yJR;rDc_ZXvWTJKo9l;7eVgsWoKm^scXNJ$>S1EZG>jcz z8#%ei0th$wgmyc#sa(0cIfnxtCWjlE9I^5Oma$)L1+&B>f{jEnf4lSwDquaWq$aIO@>NKmi5w+>BkqlhUtyB^QZhfi7jY* zD+a>LJhQ|+EdqdVWU(B}qXSShDti2hi{_}DES+RXZT5I?5w{uciC^?*E)tuDvzmU9 zEE)R56NZLYO3_^gTfT1iRfqO^YjCS4ivaX;UTK!4>8<~flw=&gDMeos8F1BA-kdK@ zaYz`;W{qCF?HEp;0D;H5erINd2rbY`ibAg@JuND03Yf5;{Hi*nu4-R`1kBmv-4zRB zVk#koj@9dxka(=?s-WhC1+orQ3c=5KENC#Z8O|oWiLFp6uiR=XU8CC@0LosZr*kZ4 z@_8X`@>?>^`K?RG?23s_6fI3TV&Ar>d-x>0Y^6cy&-)x3( z=@7{QiOb&F8Ns#O_PEK6vTHC`!uYA;$SBR+a_X+jEbB(<l5pk0{PDgN62Wt>@O8LmB0=HHp`!+w%-bQ;+(&D*eb|NIRdT7%TpDQoR zz7;|{ulcz<8rH8hM_Ky)P`%3Im<$(9#9@#7Re7e79t+tJw6*ZW8l77gquG(_yj7_z zMuDffeGD5wT1A#`k>{@D_O~xkLs@OKDiOo%h>Lh%flcMlaxDv4pV<4eS_yjiSwJr* zCI$P$#n(pK*j6Qt*%3V$3BE)9dQ~%10FzDlCf+2t;6Y2%t^1dGk&=Q?{mxEp24B$5 zyK418Jyo;Pz@U|r$C_#JQ9u=qHAZZsUcQ9t4OSBdYo&v0X1_mn^tsHqDOq5vLmdHE zQGj0IFtZ#@03JR+%Jt-ecaJFL>b-oH{8RVisc%<*m{h98V0&K}TEojT_;>1I=Y32w z90j8v9xN2BV_$hom5RcGI{j8-grF&W={by131Jk~Ph(b{oYI*44{nZQ}%jQY1K`iM~>1eJel$ zj9ogdf#ZeZ13@QTm37C8v3eugxYm>y&G%}{7tTDOoyQQ&-+|&zg&RGP`Xk##ns>o*Yp6?R zz1Q0g7c3>z4Uo24+ye^`n`BHr(SyEev&>FCQ6l7hS!W<|m#s@H?*H7n;T1LB+c-wW=PvDF3xcexT{^v-`M}TIUx3QX`7r?uW1W9Av4>+Gx+$aKQ3( zCii(d^HyqrJ!Tu3WV$((8!)ri9j>W<0bQA^Z5kJCVEFAA9-V*H?w~n?PmjM8tg-rB z8x_nsL$2DmIPjL5AwCu{k-&4(p3&SqDCb%>+#*vv3Agc767Qs6o_OUZh|>fk3CMTJ}vtmpeuQb=>` z0e(lj1x_Jo#Q1*dz~N;qsl|uPMV_GfsN4=Os{M?-=7Pzuv~*c>Am}F z+@XSL^LYV%n51FMRupc$>MC%fN(lh6XR41;)XiJ!F6aDa@N?2e|JBuuEL)x^?$He| zZBpa7G-BbGD$)^>wPnCg--g%Hg-LwMjvA4?xe)me)-T*KFSd`s`Xv)4x_46Yfqjud zNxadISelg*rjy9`BA15Y!ia3^0hc+>b$(SgS^-@WmXodop>ST1$P+>)I`r)d(po7(Q?4S0<$>H~T5waY7*8Wh;uuHTIlk!#K zPjaus1eLG$$?TGGUP4UBb}YIgF2mY@%+}M=67Zs&Cl5*|pnQ#YRH@t* zwRcS!5NDd?H~$lBgeg1PPszQ9V=p0q zO_sDkj8OVSS4Fm1T897Ab=Er6WB?qpnIXyKq8mOiEngh_25Yco*Ca>TU$~_H=dE7_ zdoov)KRF*3c7$9^vC07V^^RB4J;w%TO#7-B52vf4b?84`NR%V(_li77fyDd8Dq`MG zIO8rFoBF9&e;=!qdds&%)#4KLeO3BDUK_KKaY>1X=Yy8pc$)dI;G5Z&=|zL#-kMrf z3w=B;zs|Q^rY54FMXS)=J_WB1BtB(rStn%Xxf|ik{lZcI6%asEEi7cIu&<t5>@%>v$<^fDFO>g>;^M1gptHvBquo!g`&k)UE5%u|zCXk^20hJqx z#@BbocCX!svJlq{0pQr0S>1EOhZl0c+|?{Da5sa_8Lm^MMuJXez7cvmrO}k7Dv1I& z&IKq+#67BVg zGQh_Ee8IZU?t2oJn}fW~iYfbgs1~u#w4Ptr&Xe{y|jfS+V^SSd{x(nwk)4)HX7D=B6H7^F!gTq_k* zvo2qlyzsai9FSqNa$AprLjkj3(qLN1xFVUa8G<8d!OqSbrIH5kd26&KurWoI&`^C2Ju!t*8vauprAtw61z(~Y3!cLx~*BmS<&m{E~)1fd@A2$Ya3I% zK}%LDIYA@H-v(iIIDi*g4KsuGidi3`@ubl`{&s2MaJ@S#jzK6}nbBFRPi-WXbY&*3 z;|NTQjqS@-Tn!W?bgjVj!um6(bzF|t?f{jIAd1_A-Y=HA*(c*Sv<^M#8R~=pz3JvR z*2@G$ZY z;%R42PLq0MKD!^(BN)M$D*?CuK_b||jS8QMlj>0L*s2|YZY zMJW#J-d@VjPwM^8hh%1-)8-Fa6-_Sx%K{kSo$oRbtz{m!d8$6CVfx&j3ErRlL=8eJ zFw!7%qNj{cVj?1_vS;xWU}(OA@LPb&7nR*5!ti~HxtkwLd4C@WET)*qf?i+$zOEIz zRB{Bi_P<_bQl&31oRv|)YP!>N=SaS#tuLa$WJJVXOj;FnVoA-6f=OElNSkOO8UaeIn~guGS-rJH09`3xyFjXZ@(!n6Tq&dvTjNERaFPbVmnwY3$3 z|2kLQNB4gEJKJA5s^ysz?`IB<+ZL_Muzf@EUu|<|-p0X6(bUP0<6RzRPLuJx4gAL$ z5}0;#JGzFYkc^@aQ+rEG@ZM|MH?mK1xwf`+K(U(_wOn^P#p;aI!-;F#Ps=g=4w-F# z*EH6(y~CmnmVY1C9Yfb5uL@6#laQ+B-WmGhRqM9n^@g6$WHzOJyj6@Oi)P1ZWp?@G zyp}XrhIHSY_iuXPZCe{1M6i}EJ#{Y<;(GMC_*dWe!pBi=Ep;T{wmLd2f;@{PC1&va z)7kUJ+PhC{FGNn9t~WAauXDM_?V24~`gi&_!vb26CA9mjow(2zZ}_YhyO8dSzk73H%i*fNhpxStiNaUq0Ocl~ zhdU(9WR6Rkmda{@nHbsU&XLwe<}x_(-ttJc_X4Ie4ZEcmSS?wZVX0vh_<_%lhM|U_m>Bn8(guFIRW% zlK5Du6^E>R*)(zwnJVG+>|afTUfb-XbxL)i1_p?b`NX%ZCgvL)F_VRi1B7Rq8{IrN zd_Skn?%myik$^b7ppQ!VI@T!9mvAHVm}YB|eiMs6ST@S%D&Q`) z_89_CC#Yj|7fZ}o*P(4Jc~}GbB4ftq**LFD+u{V9p9hH^hJ000wn!iH!A3v=%IRN4 z;1`afUtMMP9(7Hnt6HRgmM)t-y>bF249U84QX+~yi7!6yd(J5>OxMOIDJXz`-ltu| zv@Z9Vfg6p?Hr`c`C=JP=t}_Mqs!_pd)?dqV<&xUAI_!3*t)7=(E&Rr#PnTm@{ zC6rKhde5JAB_HKc0Z*IaHeOe)dEJ^WT;|M4LyaIXgL2j8F}(7sfc^U5*9y!l_$s|` zM#}n#BnI!GQyr{AXxuE+vdOp`9Wp+F^mUR)O?uL7lQ${V#&?~kOtNt4!WlcCRx^5* zvXr;7xw_fs@Iy~o5R-0WGU^GpIlghPqdG~J% zxI7v^;LD&wYhS=DQHdf9CO*P zB!`z7Y%PSM7KH4Uhhp5r1<98i=(Nvp1$d@Bj6$o!VIs?jy233~4I(dbX-FdALZI;LXkg)imHseiiUX@aH5K*?MbzAEr03WTb92t z^Q!Br&>Os(aOmES9?)uJ(X7vedQc62)VAtO;<2=>0ez7dn7e@ss&T^=-Z8qvs7hnpwIvzI)M<3mDQ zdgoBoWKm_H$wSt}iHUYZlH5f=(LR^Gp2-&h)a$7@u~f)GT|A_51f9UlpJ9nysh1Zv z2<=1b`a6CGLdhqIVxkLGETw->Ei8D*XUCCzNDNt+qf0}!PH&07cPJTmmM83*S8^Tf zuVVPTjF~od9jbIF_gk04`Z#aFQJKd8Oi!0qdiVSQlVH8(UE26v>FD;3RI-TI%G=_m zhxaO;*Xqz^Slx&R2f0A+TPz^^1d)G`ZV>Kk^=WmJTtb*6XfzUeZjsm1v#Y z!fbsxwsZTV1%Cdi_)J#q)eEVC zSKe(~Ip*`MtaYV}Dw7vVJA~(?P%ft0SxgK0r9ea9B#}8U*7)A4qB(Dz6{6F3E?Wsi zY(aJ>=7#jI5^wdCcrvWui+iBj)Hp*r@lBVI(qK`U&P)aTxgKmeDx^}bSa*~=pz{6N zp2n9R2SLQZ`$_rbfF3zsnIU3a+uuO#E(IbPfBP$)JhW|znw3k)W~8fe8TL4 z4LNCg269|^rU*XNVI;rF23SHal_mTn>Q=#Y+ZOnZnu`l8R(6%&|8l+*6V#|Zsi-g_ zA5#Wa>e-Ma^DhUx!>Y46{O7c5$pTGg?trrq~ zHy@_Zo#jYh#%tHh#lBaR8$pbO9}B{c5a4DTfM~tiPy8fJYGu;B!01PhdB41ik#0z*T*MT_@>PQ=ih7mc;pfJ(UU;Eo7L02QqLa^pCnl0_t!3P^`3!JO zbV3BsL)AFb&B(PHjCh7pWC#0|T-tY|We<2OmOry0ajaDHN;MjV62v>1{xOcj*XtqK zQsc0Ab1o}^7o7Yc9bI3vBT5h_GAiiYTSkYLr%WAiFt)u+GBCGu`#To_E9G}rGM}g5 zD64{K`*r*|+W}kc@=sgPhjv%nKxPf&wQt~JBU6K|Dq8MMfj{q}{mAI9lHc)K4KKvg zA=g0+h{cK>_0V6+hsN>M&j0EQ%TDULWcpN2JbXrdUv5Nb#d_<^2{CM)FPlzeHNk%S;dn$joV0p9R>tBbI z4xKP7Ga0uGdK{Ypp>>vnLrsm?m_B6*yx}~nshbPpG zY+Epvt8HB`-l^K98C>gqHS!1kc-S_&=aOHM2s z!U0^;c z&!0b^lOsbf9q--~-mT*;1btbV#5&4{CrrH4jl0{{c<;)%>U{ke@08iwBcC7GmtR7C1o?DnqGl#{lc%UG0UqK zM0vkKbAL>Dq#T2 zyQ=YvHl2D3!w=Bq*-M?dyj&aUyup_d@2G$NhVQ5zg0*mFzei6Dof~}JQ&sN}i0o>G zRrD{t?_J_vnFzVpJ{b~NDysn{um<-%I}VlQ{@Qq)l0Vr-o%n5KQTf~y?|HJ<@dNk7 zbS0QJkxBDTpxqmB&qrfw2dY68Gftc6a!B^v;X9+cP-%)Qrh0{PFVOVl?`ige&T%fE zt2^!D`Jmlk+eUfA^Cu`-?i%Cv=WjooRZgq5{`rZiH)L}utxoGD9U37_;nbm zgfF(t3jeb93<%sN-&1coZ`FA0?L8|O0 zTSbw!t?%DwO{R{>LV|_!QVuaVXUll4_F8h*pEomSz6w_DE?-t%W9cROr6eT*7hV-N zjHJipeZkx_n`>omYLC(aF58(i=e)JE?!mLmn7oeWyk2y&4~(R?7|kzt0JYgu;h^B?p9clk zl^f7WA(w3#R<2AQBR(UVfG`9ZNxtN^!(_aYL1mU@kltg5N7Va?C>A!;eQ|^Ex8%pY z!H&S}67MAoBi2&UC(e3rNx>6dZTQL{UbcuvPCAz6F!|;g?#+=zG(u z_S3WAdFXSN=ksCHFT=?33+tglV+jDh&p#rAo0*UEyO?p%`Pp-wxvV6c-?W2;|Idmc z-GHh66Qqr-?fD?~mg@JbwBf0!-~A#ow1N~qUx+^|?=p&j04cQp)6!K&wbeDnqSc^LpDDGYy0u-l6a4Qsdw=d7TzWmC{I$7u5qceN<%%%sN zMFkqhtY4LJo}*nQjjAqwQmCv{cKp0dL?fksa;0$eW>`EIwgljF+NXo3hH+oxpk{bWHoF#D7 zdi+W}V_io%Kb)nu^d~uao!Me|RkcQo{FbiRIp&8R_ewRBjk4iO5I$S1GBAdS@}~xs zXZRfx)7lXdZa}!zJ(&jjB#Ua#wp|NdXyOGvC0BrVA-s#E@jIz(mdHwK?WjVR0)bFHE3X;njnEY)>B`h1H3Q!0Rl!;kCE30skx^w@* zQ$tITjkK4xXhv4MmaL?JR^Y$M+ETw!v95wX$)GB2+TZU{n8zA7V)T)QeGbGbrs_@2 zhRKTH+ofwEm8h0`<_~24iD5hv>|j;I19BvkC&i7S2rv@Ji+HE!?M*QDzIS8CR#enI3cED z{R+k${suzrNShk`4?8*VH;e2Oha!zWorv=r`ISt)vd>w;TZfu|F@3Bq%qX6m^_BP& zCLqzs8m+GS)Tw;?XVNqY2riR4x0Y@E@mv!F|0zcPd!l?RTFS!k_)Z$ze@L*s$x2qG zp*Sd)3J0OJYuEkInGCk%AjY2{{hw0Wc}ea}Z}5Mp88I^w;u}{` za(3Qy9r8v53|pnNwt2s{G=T+hx3aVY3s60s;oturOY`qwFza2+B(=IxPfz@8C*~4a z%3B>06Wc|8Mc+NxIY1cly)@1td0>yF(SW>}^wzB5yoYjTrU~#0w^SQuy)C`rF9Lgy zIi+gdpfu!S9T%Z_oWYniNmH;NcfB9d|0)CHRrqbC(L_P%d6zxf6wvc~h64p)tGZ`c z!_Vw}B4&Pg1(8{(;luvO9LV&}LWA3tFfT`K+m&}jt^#N*6qf!jMkN7+Vd0X}*xuGZ zRx)iX$9fK4WgpL(vea8K(DP>^SOWexP>Owh@qE={Glm02bYPd+V&KcK7;|SNh(UDp z?({wmIwHtvQTFR8(Yd#&v!Kg0ad_1%+~LgapPW6v5Q+P@lRltt`4#g(XJp48DPtv6 z#7dlMS)NBZ`tfLYa2du3;TrX(w3yJcUgj2Ib6we(`EN!uHI&4bdMaAznX_eCGI_Vi zI&4SZ89gkGJV!(XG=oB@4o4Pq7}G=jj{21My~Vhpbbs{2e-=&UP!r4wxU7s4swBwY zsDlCi%>}$Zbdwsy5-pvJD6d(>_%hN-go(lLU@?-6p!WdW#j`4+5Seps^bY@2Wb`-a z3c62sE~0GA$(SBa{a$;zHR;8n$l%p8S@!9RV@9qu2pCsG3LhOBD^OV-@ATOw88`ed zlhc)FO@A%i4gGBKQi6|_sP`08Z`cV?&}t%rUs4gya%uKq+%f|j9+b97ko<7PlnuCi z<$UwjOrch(VB3`)vg1IKOPgW}Eh`;*pZ4p#a=w}4H-oM_WUswq%v#Ja=<%hcF_On90!K{hI^D}&Yy(U&D&0uX>6nUx$GW+K*1Ay$lC&6^ z&~Q=Q!>%iR_e)-l+-%+ax<4BJIH@nrhXsl@(I{^s75zP3mSMA?AKOBT(#cRWY>>~u z=*K_{hO-bE-`&D{pf|XGyw+5TW&rR~JjEcRgES;BF04Nne; z%umen5bZM1YpAlnc>dw29~wW1tO8#U7z@{k=$kLgiV>5Iv)nge-){?`osBK&?w)9+ z(YP9E;-b?L^S@jLks8L+wzG%s%<^3DsbKgxGFU`!Gxu{E>MzOuRKs6wDzjB2OyyMG zx`{a^xo8iMGB!-Qb~e%~((AsJ6vF~~+TPM9vGymIhK7B7-J}M%Q4TekYx3~Wm(3-d z?2fm?Uf$h6$jHz)kB{b!MG7Naz7599%O;E-5^wr7g^Bu96nsb@c&S_UR4F3tJuyC; zp(BL(P%hB4#Z=>~zIlv%={ExGJ~j+XG)Dn6j&qitJIqYlGF9}giAew!9A#9i!?ABcETmc=1L+NCMTWT&E>Q2UT&x4+f)OdF zxSD%+DmFIWowom}Q89mAq-Um|+n+yOFEILxnA51j;oGvMYl(b}z@3n4QK&E4^yoEM zut&~po2OT-dy9fu1Mgse!ebaLMs`H3ViT#ZB{7ks*0gl(cRL`S$07(5_Huvm_Y2eh zrQYpk@}aW-Yx{D-Uvy_5ON{&S=AfOwKx&n(4fR3nx4dO@kdwd9)vz^MorGrXmhXm{ zg!v&sZ@MtiB)KMye)|>$-gfzaj@&JVr#=u^@GeR++dD7W2%dbv#X(XrTsmgDXe`%j znftlg&GJ@!!BC_CJ|mm-)be$=Wd{W0hrsgpl-dnO-9f4=mp*nWIc_X)f*>-)z`C(w zPT=s?7$4^un(|0b9R!TEPZ*n}bZJ#r_|)A&(dn)b;vy1#!19(sEMi-w?#@6>_w0bm z4uhq>)yMw($lrsgPL-CM4bEeQz5Q10sn*IlJFggTL#sx})vHa-jRci+(sLmG>uJKu zJ}KOOKY$DQM1GLxgtfVB*=gebyiqysHL9yITxC3-#W4Owq&}|l{37lO-L3SF2#OWE|!!rw%!9#as_<`b$96c?c-9zZ1gh9{GRvr$fpBm=C}Vslf5A zYhs36(62MQ`s6S)sK9X-mDV=T-TAHuvpolV&3Axw#;%cGe5WKmzT^pC#i$5DNwZ^LP$;ALBxB81(VDc+z1KLP!{W*pzp0A3^t zakE8VdDHkFy^_y~VJcDnvNq*5MVw*#!*N`+G@ft82o+nzYC0U-PInsFcZx%D1}w+-9Tuqu7agqlp$e-*3J05 zb`~zqXf-i&fEk~oa_ry4>oc0<#LI^xTjuSQGvVz+aZlgIB1F39iaiL&oOfVB)X9WS zPTra#o<5d^!?M2#PA6>mCSBbtow-ms=!cVIuVy{>NxlXYX#5X%PAq)-h9(+O^#JRa zySx))04em$4#v@>#6LW^BL_cD{P>=N)xb_=Xi2pHEZ z&%S8(I5AXmu@La#tm=hgk@kmM^{;H~FJ_1Ph_0h(l2*unOcC9T`KwI0bP1-U17~II zNeBU>Q`X3iaoN4ioNMp(`d$ACPGZATSNeYBU8H9#ru2Qsk$3g~ikSDMC#;Xq!Etj& zID>J)LxDp6d=UK}><&`ajn0@n@{uM_XNTK%BF7Tc3A&sgqEliu4-7Ho`EZV9r8{@Q z3EQm!auvLT_vq--h`B^1E=v~uhs`Q+TD2Zm^oj}p2(kfjVrv{ z0wdF{DJiF6h7kUZ93yEGHz+MNcOx%scEUhNPLOz#&aK-y?uFl1lTw`$E8is+0AIRA z7V@$$u0{*x??PH;e^kr#mEhH<^H8D}WIDne0WQZ{ekn1RdD5VoUkvRCfaSQRY;G*P z5jjl{gE9iB4r)qy2oJ~pGZf;lNf0bL_dsBN`&^F1V%)*dE&yoGu@TB~)pIUi zC1x~~rwG#E;R!9)8iyRsV``Swg(1<}d(1g%>ejk3rxVK?b1epFk&q|`R-{`=b*VYq zR+u>TGEf^lpVvLh`8Ty||F&MDaQ3Tw7^;sjXPdXvF#WuFU*5pbPK~9+V8LU_4S#G7 zm?NS~j#5SWV2WXH-FF-9a0Z{;h5eXn)E>cIeHAh|mi-1|%mn#VK92!04%sGhF4Zv< znfaonkS6S+hKxvA8M zaiey)2yC*F^4)=X{|;--Dv=RQup=?v72!JEN_Cm*e;PhVGYQs$*cmdw2pF?zMZ35Mn9aaAv&Ja(lC*TayIZ!qF9E^Nqbps+x(;FCrJXrOr*K`r zH8KOPMg!-t@P!lP$VfGd$U4mAgX5I$*=q8mr>H7hOYh9#(VhGw;OJ!K;he8R9o#a&bBGn6sm8n$m+b*e z<br1%OWLw+j6%rZG*{IHZwr&EPls)PkAh3 zWnkzZb#%c!q8=_1VJ~$wwfsCs(dp9HE}K$?M#lb4AIj6%(ukefc)} zo4eP1?oyqHKR1KO1+aF-LeUKcQ`L7Bez8!DHYj7r6lYd#Y(#k$yJfOn!kw2Uk=|*z z<28*BP0sX}iS=HAfCm+GU(@^!#vK7LzlhyKx&*kSu~mnsH@MvebYN#|oDr2*KKHVK zbWR{(k^MqLvdc#IpY>7I2_$?LleJEHVvLw}+bvgUu+4t^SXd1-<;x=q&|5m#2m6r+ zQ~=d66`?;*7+z5bTcdCBL-S*2xtZL#Bv4iJrY zc3F$ance*6r-b2IT)`q&TL*LB@+AX^f<_7K9SYwa-wtC?11Zv;>|J4AH4aMY#k7fv z@l6!fOA8I?w^#tt3B#MC5M{qDv+OrCtc>i{z$ZI4pn7P9T;On&gnl!J?H zio6=cTz>-AzGYg~Ffx2&2CyP0+0IYD7Lzei^N&ZXpC2pvCych}+HBgF(F}7x@?`~x zaw_#=5sc5iys_;?G7y(_U}IHQPX^gyP{`YM!)cm3N`%^Tb`u;U7B-IhR8og3pXCzc zx80`*G%m(6?w{^yVpL|`f!}_Sb*%hoS^FkpeoYR^qPG$I_6s*SV?57O{@-8F=6jwr z_u86G;8=DSC&3aU2sL0@D;pk8Kd>^Qkl)XjPlPiDGD#NnD~Gl%KHfTjl&P1Q1dOUU zRZztX7$Yn9OarGD$QlM*lUKHUJhB+~Ygz1kzH%w`4pp(-F4I^w{C%%TemjCa9@^oM zT-=Wjy+@&J!Q~ubq!)sFf-MZJxlf4jA)~4q+WsVW$m6pU;S1U(UwAeH!(`M&{v{EJ zxikB=`+Z@jS5U|mAt34;tr!U)m-y~9XPrfu4jbFs-w5U1M44xvM)8Qna4R!{gEwJa zXpB%HcUxFcG9z`8zKR8KqTamI8`d23S@+iZnGOQ zu3V>{t=H>n?1>XIQ;Rq?2CoCL_9fMF77rU8g%V~4*nJO~RR&g> zRIjW$(`de&!iI-OZFF3+g2KQ(1^RPiFXZ=ifPOFUAYN#t-I)8O={f zETpleP~k1UAFL2qnCUPm5a6i-UonnGTg(M9dG+*`|5}(Wb>L@K<<4oACv8BAEyxocc*XOO>)}mKv>u@(P9GASwg^UPp-3koG~Y0><*M zRY8!cvPY_A3LQ2&8IaTOlP(EO!y!p*i|vtIW|TLE%IL(90JHmCte0MNkx{QYz6X=X z8vrAGuzn(aX&8vd_5lkU{)EIEjoVOkEnb5t-~CyDpZO!=iVf$9c9viF3io}<68LUc zxc-0|fp7%vb6}^mkrXq!cYTNwZL}xTu^5Cw;0;xo^y=`% zAEyr3&QX0_NzRA7bY~^H5c9JmW=hMH;rQG#C4c-!3~cF%nEn+jh41ZBVACwwyXVX#UAMG?29Nf3cO&)O zq%_XMA=>w1lj{;!CqfASe);TPQ}SxSL$Z+98zVafAwifQ3Oqgz*kTFWpo+YJ+5zfS zRqAiCyloUPYG$ubJU~g=v>~nDImUgq`_zGu7D(q!c@=OuUmXh}cE$7~f8eI(MSnhZD?q0e9E+qIvyMctL z)Yd9N?%BVBhLaeWo>$*wRHhfgZcdM4k@gRKkd@0(n43CYRyhU0<~f3&c<*7pXAq?O ze8!Yp93L}K6>yUl6xN5XUG#SyM&d=N>NrnrOD=x;ak^>atoBP^4u~0bIakAYQ2lhA zuUpr(T^mKpMNMvMsJJ#}TYd<(jwAfly)0B>^>%Fq;Y$~h<>|q)Zi^y@!LL;vi~5_A zYhM?4+LOoZ`ja?5o-f?Tzc*BII$PWU>CRAChwn|+4}!H-0@Rp8K}T$XAwXKJGu%9+ zr>^mzeM6u>FY1HX^at;S=Gdoujwv*N1N7Q#-A#^^7;ojWC%K|6=BDSDE?RK*t=r3y za$ODcWecw8jxBlf6Lgb{aEmPv{`%;*=IjMZ5+9%Ox^_rfq3F#)a$VnE+*g^HQSlx< zr6yFm>wkAyk^IPqo7{JJ=8ZDP~mW#b%>>Tk_c*DfnfD-Op=1#}=bn;l#NT^%VH+)?d&vNw9*H zbp8T9?F@qiSxs_easbTr%iHQtCw{V)7bji!JA}b^KWV+81y9rDd{-<(Fh5kWr7673h1ZL?x9APw;KEz8B|Vo&9rD(-G`Lr#c$zcy>vsS5cvZ8eCy1l2>BHa2_jg z%C&SBe&<;!Av8o1{8U{er`U-2&N>X(tphmZ$r#pS z?>U8Aonfo}?ax-%-mhOwfhBMIoszeTz^n?1m2(%W`4MA+Wd!9qW!n+68h~KN^C8J+ zy-1On9Lt9aO@B(jzv|M!8rGmX^qwKsfH?2ZYo1dFl6V5<98m2Q+JPBDYzt}Ppc|wb zSV`)Z3`I~xIZ+ClopD82rc1n*-*&mRu2M+*R5^F}9mwR_)qv7ROmG*~?SY##KY%W% zp&+mYDfp1{5!}O*ukhrb|I(?$8{sC&`aVcWsi-K9NgIkURiD zBiD}KvI4zlUIRbW6q9n9N}+H_z@@Tk;~f(KcR=-VEw9m5)zu`+Is6W-hxVsdk$QSz z2?%4t^(qV>%BY!A-oj89)hj@`UOS*36r@6fVvuO~K)T?V+QBb{9I{|n#AL)bYy4dV zEm>;S-h(!ZJSkO{iY{6b zd?E_EsUh$Wd@Ct-^@pZ$AOS@o`X&*XKpxS9CWAi#0KDf1e-p8JxyQ@zgF?Rtmk$Op ze`qx@8F+m5Y)VEqkbe2J`uO`T+Ex9`EAK>$s`Pz0LA}5Wr3}D1a@*)fU<+$dTl7=p zzXZHn-K}XhmqyvIw=p}MX(Lpj76Ag(HTH|8OfrQ!mrIU!eF7t(x6_gaM*tq66D3&*w_x&~5EE`*j7KOxE zH014%hvSlmctHRQ)=RVt3NmA0fzpYD()Hf&otK`=mweX1`nShNz+U-(2Zxw+{w4y; zg@5Y=n4_Y44mT$~bS)ai+FtdtmS%FS9{#d^KnHB)!gmxCyl_UpENg(0p*6)5+!jhY zLz+8KQ*8Gs`L)Gn+g|j?AnPJ66X1|M1C2rr{;ZQ;h-WXrI#YL{)xe?u0o))}X=^_b zRH?wgvlFh!#WrS%>@!|sGnXVx!Ps-dx*Oj4fsUST;J;HO$$fDa$_H>#yCVPF?{HK^ zN_{uBRHksxj8W8Jj*pLi1bnZeXOr^Q_rV(@*l&sX`*^!v=GDZ$H(JlNCMWclMM_e@ zw|o_#2lM+;LyF0wO9H!3q>Ji?6V~-GmoJb#z@7icg&&F@GZK>!d4QqBZz!0%As4b* zgrzAxnc;KpDHy$dsVSlZSaC7MNQ0p40z(n=V3yXWmVHab&zJ#X2t6e2NAFGfvSe7u zlX|9LdVg7fY4MRaKq<%Z3*EAY{o0y@e#6y1LMy>o)xapFFMXcmL@9#x4ugcYf!T2x z*A_?AKWy+PE>H69qsQfelsKcRY;wT=J$E5Wwg{g|@A(z@0N)oIsz?$PzHFflY(^u= za^Yu!;QKoXZUaB}@;Ec@5>cWmQaWZblKfyrkzHUiNK=+u7@SU*#ro>}271r_!Ds`x zXC|qbdhi@{UPd`42CFVfy6|_6y{;uXX|d3SS?(js7oxdSnCbP^kEEkBtYVZl{k1*!%Yk| zWHK&#A!iB$>`uW_SG~E627qjg+TPkp`UT|96%C51ua4sGPTYO^}A< z=qUJpWXF9UESM>8ouB|>tW8k{PLxa+5%F%m=VkS7k^&m+%ESBe2`MrfJb%wCEF8h= zx{|B(A1{Up(!XqvW-YkMC^8-OMouxU*|t4-dd5JEYoFv|JCPFq3`Cm+u=A} z2!e~D*uL@am38ZXh~(aFt-nK9Cj6};?y&%YfU9zM*U5hgs%PYY4f}U0sHF}j5C?`( zRHam?-wMO=iz)bH52DF?PL-Xhj38{&j{qRT#QQnys{1`wPI!HNL?l44I^!yk_Y`zd5`T=h@&4VN!!hrh#xIz_+L9lZUzei)F+<7NAQvGt{*E`{FI54Zuz7 z>AlA1m%qdF4DY_g^{MIp%o4tA!_`9rKzn@7y&iK0y11k;qe7f%B|h~d*?-^}L6~x}8-voV*qF6MoCw%eF;Hg+k5ZX%x@HSs*3gYLxjyYQdiOdb z^bc;CKc0~Gia<*BgS_Kvz5^qeAST%cJdprSwZ#H*C@9*zd*B?-!%m%Lzw7&#pp0?M zRRoO7u7`uZ^Sf$2Xm^_eE=qYl=W_#HE%1he;z?q)z9HK}qi8b@CecS740k<*cg8>3 z+xSeglv zFYV=71V^_5DRunqq}=M(W)Q zOKoYC5mKZvh0z0ciz0rNBGJ6`$&R^nd43Vv;XI`8KK)sX#PkrQvF{a#z{CmfJTl8@ zpD(ib(jn`;=aapWl{IpAkzm;(i*w6%lbi}}urAM$2LX?BYjWhvn&$1Qeh}uO)J$@e$k#%PUMfzT?C-`0 z%6tRztnPv->f@_q{S2Vq!>Rm5;j_uT;Z4|idh$91`0umfI+0e`hJy6p_qEf`H?Ihh W4d1l)1Awvr{Q{Czk*Svc68e83VhAw+ literal 0 HcmV?d00001 diff --git a/docs/screen_main.png b/docs/screen_main.png new file mode 100644 index 0000000000000000000000000000000000000000..f833753ceec067c643743e8400d397969afb6de1 GIT binary patch literal 521714 zcmY)W1z1&4w>AuK5b097JETEMx{(G!=|)PVyBq255|Hk0kd_9K?(XjXCeMG)^PYcS z7}tiq){HU7xMM7W73C#S5b+Tq5D1FYN3l;3$m>@S2=pyHGtEbnwVNT zX`YqI@-F)0g=?!A!_|FDH6z)77VUpNpd2~6PX^y@u|1*#w zkFe2oc^SD{jZ$_w3@xVm@_Y;hc*FlQ#izhN98TSD>F-TY6Gyj|F<)E9ng0KF=07)C zm}X($yuLR}*|KfaqQmVDWcfb>II^M*L4@^Vmy0Dtg*zq)1KWB1VJRYA@VTSi>)%#$ zX!ZXL^csm>?me>T1bZT-l=rj*xc|^2a!&EXNo<0!jeihcZU@Qp!8XRgKkHvbG>)5F z?kFa8UpuJ0!3A-L_+QISa51jli=V%Qi`yI5n*~WXCWHjOQ$0sq)~(M=OUlQDdkStV zm4CU3TlODl+?Y=iE#~a_0D zg-<;qV7a_z3Q-gGxA@0xA3YRSoUSfI3f2MO^H}R@2=W zb}XwB8rG$bz>wBH`RV;GlBcEm0mF|FT&MZf>BzbBdJAX=fMIDLlnIz)(I#H;04h2AV#Go@BS z-g`Vk7Fj~oLdd4c04vTaKC6heK)_{gJDQ0>)Wps$Q_tj12^NDNvl9zHakE^wAXNZaC zO+1y-!q`3T{bl6ynHO()5;QWYb4|b9I&}T9c|Wq*xu9JC`1z;lxCC_ut`fIK2qz z+S^w|O*2k=;i{d6p6Ax&^Vr4*;Z_f8UZ_{MP?7>B>bL8fU$7+X!1j=mfAKnR5B7Sx zIz0dE^_ZJ_H-0T+YpE?JxYWxe`8ZMMzMeXN9!I&a?v0*X z@-#P^yFk+Bxb=`)?h$vA!<-w|*n$sA$&tEg%2Lx|vXa8#<4Wl}_pt<;jFF+F`{U;; zxkfEiNCj_t`|aa1XRTJ|jk4ts!usTYj@T>owG;TGil@IpUV`bDkDClK<93gJT=M4c zvQ!T28uRZ8+rHhS*4}X=pncC^rZ`$DQFYq2&;)x}qlS@K{p+CPQfBK%Q6=;Mz7+HhftcI)n&?OuKxJiXjMY3AAG3ydJaxWfXWGtlFY}(DtB}KZZLZP ze4fF1e|u~(jLmv_R)|VTBRfE`0=)97jSK(hh!EVx|?tTB&g3_1T_hm99ZBFJ%Z;UM-M`F)6 zU?3}31`9n%28r(Lr;nK`TINKyY%zZ>UKiJUn0;=#!0zvrd%ju=04eD4aoDcqFOkAF zEP*_sfO}r!JRxR)cs@?Ng^p$%x548XCF1SvF>^gpaaxi^+RW$3@0a$43FVq83zwrv zwTJ7f+U7s+^m1^l*QQGb-!A=0{IYKdZ_}I2K#8A4my|iu>b%4;W2L_(+1VAg`_Iiv z*9Ky9SLgM7Me!~t;jLt~b6>mT<->Moa1qWj&_~<94+I7xg|L5?$D)YwN{O;C$7dg$G;dcBu zSAr921cF}r=cQr#SBAvp z`&kkNdpEq9_*n;{S~s52FVpO;e0S}ZdUz2|nbyTGm+zV~O33Jb7Q|dC{dOTmQZ;SMesbT$ z!XWp@FKyAsuD0=zfT=G>eBX_^D+%gLgWD@Vh7#+B@j44<#{ZTpv_L#NN!AW`gpGpH zGrb?1j6JSHgVDKFx|N&QuiK4eUZQ1Q99Oez$qKfS=5u2vI&Rt}`o@7`&yiWg@UVB? z-o}Y7=ObSgbva#xs-VWn*0SPb0#Grj^ZnfZcRr0t44BTA$#0gP%)i9w$RH>43{0@J zmj8I?%xlNIS3VkLr%Ju%xjJs%gZZ1CpW(%=E_C}YrVsD?Z;7PJ+vv3v!7q-4i;ER| zx`^V}Gck4m=QI*ke5dTM{*1LVlZ{2S^H1e;uiWdh^w_;V-)g1Z^AwTvN5<0APC&fEhhpr%- z_L*pAVpTzt9q;As%c_VdEvU@UBOhY1jxCBzF-(EWbVmC3?0k|6o6Y6z+E$kH&wXCo zJPjWrpLaTXc2~9B`U<@smirQi4)0Mp%AYkdq8#qw1u5;FhloLvez@n_yAbwV_***q zopB`MElk+qUq4wDF{fJPcZjHWIi#H<_l9 zF|A+hij|Rk_o1k`u8tl8^PzZ9IZAcc*KQc1%uJM&E#*bBAVEZ>}2lCp~z+oEcNHjDY~5e!7W3zta4Wgsb&+^H6I>D{kSbuus7;$pDgM~npqNBYY7OidxeN(LC z{)}$^0@!0nj?Y2umD>7*4D9W$G!b%po0CN6 zmcwHo)@ZEirrgyUnM@2f3cgue{lIB?>TUNpM7cunC8*ug)$!nzbYG_fl(OZ6g8Oj* zBP$^Uf^NchvXDS8_gvzH#(S3Wv?xRMh7tn#Xgi?melr*9WmQvOf2G`LM)*6!$=LFp zzh*@B)93;N{b;}|$@xd2O1-{FT@6?#+BFH|lIJ}qj+OlOBK*AZ)|jLgan=mIMcqh; z_f`JcR7hP2Nm1oC&onp(LP>R-g1Sp-&?eNmN-p0rZ_SXO;mXqpOP+2fYR`!kZWu0L z*JI0Wu2iRJkf8KFR?4#NY34X25};sq4C_RdldIu`y$f{mWi}N;?*b|MFAovlaj=-I@sK$M@suw94UP^aE;?ta%x_8%yu$68y}n}c#{40!Rc^S_+0o9SbNKXx zmdViYH7O+aQ&RB<`yuN`^H8r-5vbn)vW>nea3P%CkS}e;`{gU2A3oatCd{XAz43sv zOv@E6n++M_-EG(TLJ16`-q5$5SqCOnW_WIway^}Hy&+=kciFi8dr}x#u=8!v=_DmF zOtZbwGz?*Nd<3?651)Y@k6%#Je0)D>%ql4@m1tBSng~TM;glD}m((htYxUG6>vsJY zCS&-MMM6XrRjxR?_sUmBP0Z8TT7SNGtZ6Vc!^Sxszu@h)TK4p~m5Mo+o0OQz=-sU^ zwT@u&mVDDqn3ByzDlPWs;xrF1M0l*uMH``oP|})N{$R&qR2ML4JEt1GnmZE4k6N|+ zM8o;awTsg&rCq@u!XYS4`zb~RM(=`aH+Ihc+Wn_ucIq_M% zqc;T}4%;6dnU9|ynV)ZtO}>cPc|6kSx|Mg>d~>l~SB`0bSs%Z`r&iy6IhAca2DOiU z3SP6blj(6uNpVRtf-EOFna_U>YUTJ|CuIJI_Zq{?52YMNPCg!#PTl$CLy=`%Z@j0^ z$y-7-4y(=lf{(lF8%_|zjUhP59SBQ={1f)-@eb}@B7Vuda!iO{zP)4E{RwSZ)2Ug` z0p8~X`#fOftN{k{>*Js1OO{MH$WLD=mUp;8!rR91o@)y?isJ}!ds!td^Mzo`2AZ+gyH$sE8KbaytC*=^6v4!L3ByE^RB1CZ z+>wgQN!=NW!hibvNu+*;irsFav!An7$K;ofy(^;2UzP;BzHdY9Sy~k~{ftnvxbr>j zZB6Gf@tIXy^v`!U+0LxOy!S;*UXPc1P3;fz*r&_$wqg)P>hxe}Z&*kxGidRoI0$z0to$o$tM5F%9eM)OVOWzc*KW^gb8zGA zk7KdA8B;9}*H)g(<&)G@)K90A%MeK0W%}{;#nsaTSNr`UvlmYXrlndZWJN9xh!(~? z2nfBRy%rB=z3&B=7O~N{_?isA!??&$@X5QE1WOK`)sx)R^oaHfJP1WYhc!5-Rr}~g zLBVjjFLl;LvnC<VH&77s zpP_|hLm=LR>tPGn$tyNsmsFy%``*~96p+4#KnRZt2=F6hP1cxAAK38r-#Mv3QD?~E ziUtf)N$T{k+Cm`ga;(Z4f1H|v{&90e{mtN>+ki^*kKwo#xl-@7zMD~}?~?I2;pN5d zi-NFt$5F=d-#ZwNMhYI3&U!uh9AMe{BEURA(Es|1pZ_X>JHZZntp>9t?(vmuYx-bY;-bCf*w=TAaNLRcG?YZqNC{!ldV9~7k_`p%?xK>cJ%?|k z3zKA7>S)t1V!2Cj;q1*l+^D( z8&+@+3?yuR)8IGllN?1)LnsdWmm`VWd(?@{71(L6fo|Rcjxm?YdhB)+YrP~`|4&#F zY%j}Od3&`}=%Oi4xQ_%ad=*&Lph;1oEa4Yy?9KLp)%W|F9r-q8$PeP{v8Z5JHdM0D ze-Ku-PF=`??VPnB5OJk?L@8b(CfF#0LR`H|WWcD&9P;TT`2}W{-+zuIm0Hts=qbq0 z;|%<=SU4c`+lp<^ECd=7<$b&T{21J~zHFvb@t?FX#J5n;89vWxRGe>kn$y1iJAas% z&3MrdDXyC+18b;1wTq^p%&>2ck3v2W)*|CIe6$D|IpixYzJXO7I^o{*xHo!HT<3Tx zm#4;&mVoeeTFK7Ik}dg+?q`QdK_Aa3!FubAA3rZ9C7IN%TGRecd%BMIM}<5*bn|L+ z$o` zMvYcJ`-C*b;&>QH#8HN(mg_rh$#OV!!deYsXb5-Ztld|b?`D=$Rr?HvO-tO}5H=px zt%NV$oTm34$ijhr@}d_I0DHuZE80!|E&mhv3gFMb<+$yh0s?13%qwm3%@%XM1 zb-ipqAGh1^nI7|9Y?D|%4=4y6J{jb8qT00GZj6A z3u+=n)`RGoN)Gxg#&@xk^$#d)hGmdusWn+fr~HJAY;ksP3k6D6`U#~erNg%M0fmydTtMb<6 ztyeJ%a`Xm2-Z5_Q#)PM9eDoFmKAa`NywY8wk;;hJ8W5&c!=MQRoqn(Dajz8_YXE_t zbCYj7onCCkjM_@TdItqTUK!P_CC?bVAinDpWJ=as@~its^5C#s3s4&tb11ddtw?Ih zovBc7e!fhwx>dso+B5h%nkMldTwQ3IfqRkJm65vc49O1}->-T}zTM$FF{=&=TdH!2 zw%z!;o(VFV2;cFz*F4WjsKQ+N(NmXIXv%ue7<$^a&hr8(rRGQ!^f|uk9C!P|Kl&9jX^yh~>G;qdU4pxeIf{i@)zOfDOzM9(!c+76)r>`8WF z>&4~gaTsa+8or1K7AyUTjR%*<#`nW$`I}4lL*^>1M>nro>!U-2;F5WZAvqyj@?ZKZ z{=i>PI(eQx@~0Ghv>9XnRey{3JDk?T@?Lr}9Ea<3fO~#b)<4U~kB^Lf#csYrQPr+; zowNgQv(#@p-xCSCJZep!KHod`2=LxHe!4_E3bRCLzg$=}wkPa(p$U|y2Z33_Ig=J_D4N>BKE_KSjLYt)tG5HJ zsupkgq&2+?7vB&Twqn32B-c61>A*yia>qS&_H>-&Ztnk8H+!Sy^_&~J)jgStoiD8( zWAo}&Vj1pQf|YuPtzA9Mrw{oo3cFKRD0>Xp)wAZ;??vQ#_h{O$){2~=eEy!>r(2yG zmCRL1CQ9PUrgAN8L{(8J{sbbxLjzC3MSpFTlW50$L;Bj zRMgm)uSZ2g8N?}*ja_K!n=mzyJ$M~X>r?rQ+_}xCTJ^y0%XhU5QtG2$&|yl_IV*<( z=VpGc~LY>^TQhpL^x%Q%BmLX2}5(L zVQidVrZ1$X`5ynBeLOO~j*hvxrMKnqA2eoHKgfW*`#Z#_QTw<*DiGJPgdJKuqNa$x zwYPsnLdc1xNhlzaQSSDv?7L z6B`>zBET}=`C>8||ApaMep)TR+NB_Q7*}u{T3wu-Rnmi&kF}h^+ZgPm`1k1u<|s+Y zS3Y)pBfBA{g0}Vs)m<|A=O7#30Zi4&3CsB6Z5o?!8Ek%vy9t$r_fCp4C@q>DQ}_NFEY-Cnr_OP zf1FS@(I5g=XZLNk`1Zw~?lpS#B%FRl1_bsYp5!&{XV zZkh3yMnv0P9h|ED6mcx>Bg>gS#Wws0x>Bz|d*4&NOcae2GeF_F4IRSbN?T$xYG6zt zzY$XY*vxZOI(?0_S#J~|Vwflojf9mcCWp$T{adL`dg=e4R_QrjMeOI`4p zn8;rSOZH=9W5Y1$YP1gbWfeR0gnpZyBVb);s9tTH>@!W(*xDvwi!CU?KK<*sv5+TC zT*Xy?p^>8hGMaxp`UC0%MijIng>{`(`6rT21B+u`WT6WkI>4gt>kBbuCg!Gn^>W?+ z@eJG4tU*P(`uN{BfEb1Y+rWdL`m(A2`*XM1-l~#7C;Q)bwnAUyKz<(XXMAVgeE|L@KQ9Yij)=3?Sh zYlmjDHIyv)xT{dj*z>4RK-J=OtW!RH??>_=l>2G8&LY!_0ejHxxb=Eml7#>9Vj@Q; zDmAs)a3}KV`E|}@c2H{#t(FNcUO*t^cVz)u+Fpn zpAY`1OrvL2mMNejBqHLUCtp+zQ_jE-rxp&ZAzRj4tDii#>{luYkm-nzRB=+a`og<-vg!3#Wf<`c-Y zO8W)_?IT2ba_fG=7DFjc{ze#`I5H@k76Qo}#R(Rp{BU@$3I`2!p-3CQe0=TN`jIY% zlAlx&23PbG?=ca*@3M?iz%;9 z1$^=o{;E~mM(}>u>d!$%?ewF!erGJmqUipLw3zTP$}tm#0guG9KT{MY*ezJ~f`fYu zh$Fd(Vpx#Z&u?d_s4)@qAKo2|J}*5qy{H1jK8t!012v9_=#JZ-IMVoj*H=J8KAzhy`{eE+K=PA!6iAiM(GTv5{f(6}xKG7$#KDaAE5FO;F;cu`n>+ z*P5{*+Z`=5rlh3!`ubwge}RYb?a$x6bS*9}R>%|>wp5(4=1$9%No3NfDJU%59ZG%= zLY0rt{qgS7pt7N=s;ayk4Wg)`Qe!-f->4<9m^-($5IfCcGn1FBzs0bs$FgJF$VZGucp3eXGKVfgAanH4u}cY?IFbev5ty_o7Q!au zmy}WiMr_>g#FXL|EkVdrN+AY_fYuTc)+ueKM5KrX|KIDU#zI~(gPY1nuY@LQ`i*!z zADo??8$`0Aq;q2xCM@f(FE0;gtNS)>!(GAY`VkSq#Kd%Tc(~Z=R^PY&j+WN@a6AAB zr>Lk10%1!&=zt?hgUSp_NJs#UDCxXT5rdl&Vq$R#38=`(2lMr#tJX#)CSZfLO26nf z+3((*u0tSMiZ^4TXp7%6aOLyQ{}n1TGBO_cB_}6?RZC}8^6OZ++@E$jT0nr%($j0U zdp^RD9NIRTo123W|Mkhtz#v;BD=9{yf7SZp`ucdWnd_I`T#L*3)^KXHML}89;!#UW zOFX@*ymBxr@+-lbrKP2rnVEwFi&~BFyu4$gnd9hik*t}jub}_|NmVsB->*jsqQXEU zVKadHrRKdwf`NwhTm2JF0kThUaPaNz?ZoNNk&%(}?a@pg2SmtE6*_(5d_B_MJ)uY=4-{f&2dX;K58l^o3K8cNsmg(}_m#*4OI4y(5)hNiwVeQ?n z(qp^!Ct2)rqJ=}o)zkX{pYV`ji6gh|d1gO_$Cj&uJmt@@3k7lJBlhcH*~Btt2$RSe zHuhuVP9Mq2%0dv(D4!Nx^$^IMwKzIH&Ww=;Cq$yuA2mp{crv>d4YZE|WvThn_3E1e<4HT4<0(@+Zg~OjYt~mA!>fFy5KDwq}sRQ(_$yN$}iMRIfNTzw&`d z#bAf#wzn^v*LEsvlulXJSKDz#%R`xs=U|6+t>O|A#`PPGy$v(~)h1_rW_nr@y?bS4 z1=BomSy?UX zn`>)p3k#)~5=YZ{69+dtt6f}Nz&8|+{bjEBiAR$`?-hwaT6}zbYAO<>LZj3)>sif7 zTwMJ0_CbhrY;n=!_H0u;6uYOl_sqE^Ia%VwnGZF{5D^2!jzrG5LFKR9-2P45`gtOQ zjb$PLdbZCyVnDG2kcSM3lbbL?I`{1UQ98G(q5>?9goFg>Y0I#^zJHX@x8vb^C2HNg z_-FUE0A}(srg-Dx5m-MQoOu%!6JL1AJrpiGYC+t}pPs`Y|$0*km3 zb!=gC^SmiLVnCAzG{e&||;bf4TtmOLq zw3t-?YztBmlY{eb_bfbNFCqeMkq|Bc0>z63cf*>yva%A?8yI1Ll+a;VOL;)D6~U)I zz@I5HBt^I8NjL3y-@Sc~7cS8tUD?`7RE8-^2iNiqtV(U|q(S8$qbe|z_T}a2>HO*a za-G(cq$KVUd?v^3kxg5DB?x4}(n(i0bJF~~rKK^hMCq5D!3R$-1%=U`P#gr`ox?-% zJZ?-+HeRyT=!IncIY#|f9j}8K*7oIgP`JawkOM@7mEwkt3Hn~^lA>c`VSy9@P;psV zS){;SL0g*u85vaB<>vVY{?7M=%?FK->vpDE5Z}9N&Krj#xG#m6F2I~8Z=xb?dsjA|bLvPr+ z7#NVBZKny;XfV3&O6R_vJG6Fa1vM%pL<1ZQdwX^Zrb%-LEv<#t9C}fjc`zgp2w>X$ zPdDpei;b%f=W6#sVjr{ldVh7OtodEyb;LJ|nF=TfX}t9M`Z`U+pWC_GZxwt}F)D>B zAl=1k5y>h2tNk`D0IrabfL*9^x8jFZrdc2HQWzuZmt2wR&Ntb6zv|4De=?X+);ZbpSf2isGWW!BZFpUil z1Huzz3X4frGBPqF-oGH1dfZ>73wjYl^f*&dU|;DK5+VjbGg%2ZpXjNoPA@dtIUUUC zbEYnPTxzB;GeVYeZVgAr_EtrNK zALU@25LFWJAQKZB$nRbI?5~q!@R_oFqzhid$P<MgzV80qS63t znx^?Ps6vPoKoSrwV6>&BrKW4Xlu`hYybYeIV<$uj`SC+&&rD4Xmv>m{ScHx@>>hEQ zaa7G&Cx$Zri$mS4g`Aw6c`XkYmlI-s?X2hA+h9rx3PTXAIXa;Abp|SAhTdGy*yOj0 zo(vL+bPOe*2s(^Z3}S#m+7426=-_6P=cB8g-FvARuuvdr;)nMdu>lC|+Pbv0WgH*^ z*nsg*TygU8v=4TGtl8yrMKC-|Nh2lFaj>%^qo7bxQiA-+s9xny3SX&K@~MzXr^S>l z8K7<25Z_S)IO~iyx;_?UX}qc8J#Fpu(e2RS;QpZ@|IE^1<5=n3^z?M> z(ATJDS#L%0lBr$B65;a>CoAY7!syp?GN3#rxxvLt2PE7$I5>2u!}thA#l%!OpRSpq z;Dvij<3A8^%&l{+`w0CkF8=n*?R`^H-fl()u_@g)0K;2bd-goRVt;36&1yApn01DZ zIz+v-u^tGpUI%r7=48NbjjLxZIP>%Kl`#Wc*>|AkrlzoC{%v6Sxv?N`d-T_6c7k06 z>q<|*fApmnAoTkAVFBoA@}@=0n|RRI4G`-3>Dt;F4=?Xa8q3UNj+Yj7WXHQKn_avF z#q9Tut#W`)IVc&NsipPxPKZuqc04chWr9Avb>~U9^fmZat5H+)N}A)#Q0Y4(Yio4I zmLLH#<7zyF^6CBjx}p385V}!stLG2Frx@!1Ed-G5+7|o5m7l?DCx3Bb;(dSZ!WaQu zSv(>Pv_#IE-p48P+Jdjv+=Lz;9>kGwQ=c0~_9FK7wDs8Wv!2l|ybt&Gn)1V#)a>+> zoLhBNFvomI7PK5u6Wy`~^U57T9fdX?SxTKoDL+3yTk?=8dp6dhWxZzcB!0NW4s8&7 zY$fzSXNS|j&mGyMQnq?}5VH!!qSe*aQx9)__|Zx&VH)VPqh49A37v5Ou09nKnx#aD zlA`Y%9|zq}I664&UfuyBLnewJsMYRxh)?(}I6Pb%AhnN_bWBW~sl#xnggbkC(tuPc zC`cAR^)`M>2qA(%8nli!rZ?v->Of|@sZEm210^K1XKijy13LiW4@wj)=s+4c(x>;izn69)yeE`oaFw9y6_R3 z4`-bKoYL4hYs3Zx0g(X0AAny{bW^ZudwU}Cfpqb7^z=ybrGRs2w|g$GpPo3kfCE)A z-H{@j2M(H#5R27POTXkEXcYhG97Cxe+;3Fn>kA#Ij~f^q78Vu}0Tva|2Qoh*XdhCr zx*tB^5drXaFzC#uqoJW;Zcg`h$%2!Miz{__D+)U8y@|ZNy}hO;!GabU1B1m`Jg2cQYl1JsjblVSXXnG!>dFB`R(2)q88viJ1#SUUv)Dp9C1 zx4gUzXvO$Aly3I0F@S7u51Pm+D7J@F;c~R>9UN-w>x1m|>W6c*m_`Q%d|m#T*Mf0^ zq*PJw*t`h-%YrM=5=Qz1Fl+VFFFP}7DJgT))6R8vJo)ZpgU#>Pj=w-?-@J+`N7;@k&sfhb_L#8=}v z1Q6ROw)hGf8X6eFC%Sm#uHWP+!9j3_*qxh#kD#}5co+;sG0UcT5e!T*LrIX`k*9)n z_52pRT~XHC*9Q*&x7s;S>4Zo@;$>rFQ=$88XLk zj7LI(1_3A%+!oXyD){-yQ^q}Xl-R!Y%3AIi%0?|qU0q#C$)M$99K-;{dfgW1N{v!j zh-vK{z-dCWQ3D;0wvlxkH5VC|`UTfSd zpWkZL9V~S$H9tV`+KQjtKLQx7TCU^Jyy)3Zax@X}mJHrE&&)_t7zuRBd^IwPqMTh= zaKGG}%*&(34d(~&$kQ-qiKAJZ1P||ni$Wu)<8v=B4TzA9%_$Odi=wLP^^)7Mdg&Ap zOSUt;+Db}53pB^P0&de>1YO;trJ()JSo3k){`I~7ISv6qXfOWHOluXDxJh$<>y_X4 z$L*2iNmV+IY0y3aKTIkPY#5_m*eOWEJp4lQ~{vdVzZN|9|i(<2KNuX)B7qnvCpQd7;*QQ1@q5J3!{f1!#EZ~?AvZrihtJX89yGD7>`fM1 ztIZucW(s&T6&41Q{up|B$@-E;5c4CdHVOhn2N?bF?k>PxPJF})?(Xg)BEAwig#Zf| z7aIzSkVo^K553RL%~fU-F{#y%bbv$z2dh`;L5V9_2Yj%H4@v}iw<`#(>%#*;h)lX| ze4L!vdB&Wn*GG%@t3f2$)b;>x0Pp~yAEr1^2o4t--y40T;^pN9Nl&0AH}~uF)5{^W zKKQ+AoyOy^2jnw|cS{T3MHUAq=Mj(vOih2J%S%g3o0}Jjkrx&ecoR?vUW|z%;V|)e zJw1R>Ikx7`&dJerKkWf*1885w0`4=W?41OuDJfw28??$k6+Y~#wrhO((z|Ipi$X0z zizxsUV=5}D_voRhK-@YKjM2 zh$;;Y4L3K=Gu~YVLSV=zOyK#Uq4%S4adBZJY;AQ^{+hkw0C=>rh;Gerkt6gs2U)Caw?XC3_r`p?;j#-MjYW1oQisa~7PGd({F{dPG zlFj`jys9*e)(C+;0-_s$bcGb)FV8yDalj)H8PJm+fiMbyR~-aD zJW$)f&(F^kH7%PqXB-}hg^lg65nH7oJFXK98FuLEpoqhy9*Y`70zgrK)Xt0`16gOF zWYT;*91M;rDikQojAV&}U%8UtgTXa{&h6~KjyXMm#+#5VT6S)Ay=l3 z&FMh*hvgH?@h*;A-AY;KbNUsyYt0=+zHxqQ!AW3oxSIVnwjYMTapqn$o>&L@Gipkn z=p9E;mros*9xm(_>g89m-?g(R3=0ZS=HnKH51#FdmL|t4Y;=k@{oN56P>~|YNl-Fs zIpbOY1sPNVn+1K_s!$~*E$!g?9>G_yFAoDA=Jo5>KqLhr4)VPtz_0G^d>XEZ{L|wn zSOmVLfE~-rqy8(yCm`Umn1LL|+8m`Yf>>DHn`rja$8C7Vunnr1wb0hq27$6?*P(~L z=MHKmTW`h0E+`OxVik)gJAXs0J>XsQQG>dStFw~MfDUwgO_9E|Yj0kwQ4rD9NYUU< zg$@tW%F>cfuvn+%_z`$U##=+Ec~O9!-T#*_6A4hLlbhx9G48PDEjR&KW~bc(}NLOoJi^Lbc)!h{IeHsV$imU8~;od3wYk#movf z>b;n$j?F|mu)5fUCnD6D^7($eus~n;5&As>?Y;=s-I}U&)*^6&H5jl}ekr~}g7p*08auwu zL1EEb1k)bV4b{h;(G!_|^^XqNO8FBXSXfx_;$Odb9PK}i35!SoC@dgg!$qcWWB+xK zESm?mxxkh*+&7!{mn{&cY+TtB2LnExyS9R}2jG&rH!u~TvH=T2>JP z#2fbH_it}mY62iqM06|q2q%&a8xacXJ1Pm)BKAf&@}yVnU)(=}K)e(_AP&!_1wE%I zc5Jaw&Vs8in$_yT!2u{=p*YOIOYoOX>G=9e5rM!=T!?G>;o$*PKO-Zfjjb*Du^$1& zPh#ZbH#r>D5x^9X^|uEwZnZN2;4u&&&cA@T|J&ykm{kP=7$0D{ApQVk92yvC+J^&3 zBUsG0<{>2oe+D@>FAsPaBC045Z$(trN0|Nt7Q&X*O*V(t40V0(^A-f^|Oouf@Ar%8wg@KOF95@T*<$_*M zd_i66jkdWWSp}t~{6L}rIM3435=d>Dn)9>OCcuX97a<#32aW_N@%-%UanaFAU%mt` zQDlyej*NUMp8P|%a()X2v4wi~j+B1HvR?J`XMoyORaNgFp8%>15b@!pi~UFm5^St} zW}cbrY}Hqhtcs!{#I5ModVK&|%*+abiDA~%(4fYE4L%LzlTNu(FyV=b2`C5{3ea|} zk?Mg}Q#5JLeh>O?Q~>>;kcd1KX8QzR-)v@Rc0qnMVmd`U9 zKoSA)P&%mDGzu99yTAq+$`thK3BmeQs6vV^6lvPP`2sIY*LuNa@j zGB|<^cFX6>BT%qiu^s+1ur=;__Q~?bfv3%T=ItOp5njn3_M7EhK4QPJJ$?BS#gR9nhS{MyWLWL?4;^N^X z44QQZz=H*T7O(??F5jWU1Nonu8^-d;9r%QE^Yii2xw6#f&U`Fq(x67(;YzfA z>*bWi$5MlK^5B)50Q@x5^X?sfF;Hs)*A)~8ubuh8v2$wFdU5!M`~c{arS>aL8a4(& z;d{8ACzlFjZ>0h9X!suS^;2iMc=KPwF2K_EgF{0FQXe&SnR+#~pkRA_{q7n zf^=>w=l7JbH1t{x6cR)@F+I1SUx0v{*WxE9Di+<{z0ij1>+8PW-ZG6^bFlFsMFB;c z7x>4Dv<%G5sb3Arum*16M!*Z3|MLfgX?S?}beZ-(&{5L+ zfI>U&CiYqeT})WGBZ7z*$my{lA*As-jjW$C08O5Op`@(rXrn(C^i2S}n%D7w+wnjR z6f+Nx))#1ES0V8*l8C!Cc4<$N00HE%`%VVOW6B)?{ z+8h|m+2$Y!O-dT<`Xed`V)vk08D=pEUW+~ zyGAW=5XRmv)tF5Hp&bfhof1tc@G16f%emi55G2d56G=v}6uLxiNKzyuABv{krJ#he}A z2*Kp**F*5AYIiUO@Pt@8Kvn6VrV7*t_#K=TWLO{;ihlh{<))G`x(%dqR&sJ^)S51H zY$BpZpz;I5psud2si_HQj6Z(-0Jj0418g}yav(V6z@i2g8_-9#XDSUPa+H`7!HYsh zElUx2-wAPXKm!IGj+oamY;?O^yV(&Gr4JuIK)mnnToVU#6=^{x&u~AJvbK{Z#P1(- zYpaInd`QIQkvb`KAnT7iuah;L_FA)(XpTGcz9p=8b}e7KCvF z1Wk^luV24L3O;dTB2-9Rm^g7kfy1B7sMy!HY7G#fiV9|xf3(JHh>$U5vm|In!C}(k z_Iv>T8{q8om4+`Y<7E{@{U*%=I;i{pUP+oKQA%Zhwlb*X2K^Phyl#NPT6rp0n z@f1)pWf)<04h{!LM-ds^qMxz5!}$(0CddY$)&p4r^oaoal@5q{WhGe2uEIG`Q|G79 zm=aT?qAKin|AIXGZ+g01x1AWWa(xeuC1Bgg?ew4oexK*8pGPsV08aJveyth<5Fd)a zl!}ma6*y(NRH%0tR93Xk9bqG(=7dx zE+14P-MkpVGf-vu?=q{Y;#gGR&$*cKs*{`2=rH2_Jd+gsrqf;7i{oGf@P>9_*08;M+DUVnz@8lbfhmL zL0wQmXe*uXuMFNdU?xBMQr~t|`5b*xbiT5=X?zV01?B}@`lId+y{K&39ThZY(M(2$ zPgi}u(*GY*e*z74|M!pMWjACeiOCj{G$C7KO-K?hp(txe$d>H8keH-R2uVniBqZ5G zS)-ze38|DNCCc)9O!xQmKmX3T&$&K#G4FZ5w&(M)z1Sarl{mnDTr{mcx2G^SPd~Km;i;<*Y)YxlUAj|T@o(amjp`4Y4TM|?~Z6cB8O602i2D zYHUb2K@#D!pbtoH;~_3Zn|8+c?isj38qbxf*j9AFgWAij`UeF#UDkg+UCG|Y;Lpq0 z(pLr>-<_y9+Pf#tj_WUdlzXy;Y#ird89p>6(~=z~(vp;KJTb4Onk&yA%TKlNpeNpO zsW`g#o$&2&ogxg6L&eEcr(&#(Bzcq`Q9!2I84rYUc|1zhB)iY=u`B=;ij7;DM2cLP ziTgfpeU)UZyW6!(IG`YLp%$yzr93EeVbH5GPc-YnOyqMlo2V!%Y2X^VrZOd7)$k1= zN`?E1Eo3F1nis{!(JQ7{FkWs=75e0y>7}b&U2n{*=&;zZ65{0KMCIbPEmnSG#SO7S zWlroxNmdOL1C5t1I5NCt>E+Kj6=-!GGkrR@^SV@HQxnyz@GNt7_m+s^B3pR~g~o8a zVz-nkCqufE6K3h?g(DuS3HO$6YGlo0%#J672HL#a>#Xn|}Tr+Mou3 zPKZ>t1y`kT|D(Ub&wTtSb>uERJ-r)08i$1Bu3r~?3(j3h6t?6#k)WU&AuZR3he7_G<09! zr*l*3O5Y}ZBqg?d#PbNAVINxdg%;tCvx%x8yCzUkoMmk+z;g$y{anwU{S6HKVZiry z$e6loardGTidXJSrP`w2ADa_VedVops(hb(Tt)6YdR*%*s=_AL*4CDm=+ckX2Jfa# zNpysbsiKc6dF5U;H|zD=aB^^*>kqwR#Mn(>h=wi&5255mxBU<}=y%(U@_LQ$oUq4Q zu0W^u@S%eL?Pt$cq4IS;AIGLGd#p|IC7F1_;;SCOexN_qtt-=XjAfwpRZ8rkVMb z!9R;dnSN&{?xy%hr^K50OUSYqy2Ua@>2v$^AIWPwHg#_I@9?U#&pMCQRdBgx`cHOs zh^#kgs24OfyY#9}CilxZlh?VrR$Xd0|3nO&`fz6T@ar9~MAb7V|2y-`1|^Z!-_Ds2 zd-!ypMDJo@yj`^+^fz1DU*3_EZ(L-r1Y7xSjLQCSc1eGJeObu|rs#&zA?X2>kY!~) zAa>^aS?_t~Y~)R9fnX0bWLWqv;nv=LdZIU)sG_W5qa=o#EhIUCq^K!II=<@>;^H_Q zK3r?ChhR#Q4BZd1Zrnn**`dDP@-GE$HbC&Jo7| zD7>&}!j?J{sSY zAzsGKlL$Oa)$bGgi>S+cRVb}{OV@2;IiYZ5)$nSki{E)}dQDzdIs;qh*d>Oj)l}~2 zbs$l^HPGq^Jf*u}*Atk)hy}XXG3lyfT+mmzG+8H+ z(W##}!gk|exT~(kw!1qD&hXao0m=Q)k{z+S^wut71Cw^HDUQcyK31s=tUQvdWl{P{ zpR>hoiZ4TL@!?MnNl|g{&*>O>w9xM)m!!3uV5+8y-gLe954-*BBi z!rlaISN;F=cdX_&#i?R@)h~g{hMH~gHh>`jnQHCY@_W+S`3P}6d!9S);tJ=my1G<9 z_3PGD%|)lk&kN~mDFBakb92si=*V6{*qKxs>x5wB*^W*5m@`kV(yImDHs7|e_Iu+C z9VH=@uNPUEn@GZ~VVWa9fBqzw%XBgs4rq_>B2svhNsz60JQlWzyUbahzG)U($I%-C zk8%K_EWbZE=z+DYyQ{5h_wL>M$h`XcpMU?wI($2|Pi3|tUs%K_URR6;HrANEV`_UD zrg9k!`iqB5)#4Cdj?5TzzHuq%c8ZBPBSsZV;-|E}>?Pk0k|bnneOZ5^Ya!*cyzrvi z!9#~87Y#Z)I>yO-XQVEcZ*b2@PZwiSRuM{8TN2zMaG*;C18%M{vNbMER42Om_ZGL& zm(B{LGkWw;t7SQvLi$E?N^ENtj%oA|U05KU$!y}is2Wgz8CnMIQC69Cyn>fQcv^i* z-|hkSX&|t*^8LX~dcMqkF;{;uYkuUS-}^dLxH;2gQY7bUvr3dL>xiOr`QXxcP@_-i zbiS2xMvG78XOXawHfM#;I)feo%4NBNWs-Bfvpauo$mj&E_r^`BQ2W?1k(h?-5g)hb znzCH0#97$kG7oVZ@RmXgcNAA>hK!{ozHZRdbu72O2dD{+fqU`&`z~eHYCEIdMOQ;_ zdeDVxj`a6is0!aPm65$-RQgsiy(2WrH7&l-{bw?*a*EUvb9Xce5^nX2?G_Vh^@(rV zg^^KE;GwkA*iu2|R6~dtbcvF$}b)38yYqY&r%a=Y76i5b+-n-E|UU%$GSSpGfsJQ1VGkT}EnNpSHKkf; z5DHny=9_Q(ac$j*7If{6GJNN8-s+IN;rZApD|;hC^H7|wnT^d~=+c)LD(gf91tEP! zrlSns!q1-`!%r%zssep|FMXaUd^?qT$PkkMt2=D42}imE*+B(?6LoqhT7|_|PiLlW za{i3^v6CmikmKqg(?&r71%z&{X>f4xRka^^Cy-j zvkf>Dl!UPJg%v-oLUTIs{*=-U@Cd6DJ0n<`Vlb~leoub~yA%hR;{_477h*h#sQtPa zm@?fGT3nJg=m-x@Uf<`cu<4`lx(%VQTDW>=?;y{X*lSiN>>pD1wQ2+@HaS1hp=&rq z9KHM8V=eA_Q{}NBh4jpj;%yn7jS`=#c}ygEJ}Ym#>o@Iqk%2{_s9xoZzYw8bU}H=J za62`zJE8_%p?WQ=#Nne-X@Ft@V5BCa$A>nm$O31H%wegt{ZeU$vesKa88Vi#Yeju; z*Ari#k@8tY%&vbqj`N?E%{Q##@nal1EaORhY;?RT+o-*MZZ})Uie7&eK4cZh_>;Gd zaks&GLkq>-yRjF5U@(+?S5p;&Rvj%3oUfDjY*+ ztd^j%N@D+ODRH!G?BiTj-xuLco6z=SYO6V9&l@OR-_6au?Rt97{9%iGqkRtA?VIpL zW7#-D^=cdPCKYe+{&(_HRY==0)~R2A04+iCoywXunFuf0!u!+RJ|?P%v>XchSl_z2 z)@b?^EXPWuCXCETKgsR-Bz@t06sM<>(7tC|b4}YE%S0obW_P4tzb^WQWaHNG{y&c1 zEPk?@w6yd#KBH$5+k90~A2H^?@DbjfZj940Qx>?ooB+Mm`z1R)W@*>Ujvw5VnCRBS zc$Ro*8%nBYjRWhn(6XbpSYnNlmR@9y@r#yEQ@*AiXu8NuBN!=+8s zQQvB}7g3D?T-(yLRTriE%b%szOz?cA8EP(>oWorxh^UT?y=+wa$XkzO7aJ$vr$`}ZNRwq>s^PhxMy zO#PYhMB_R%8SU-pq2Ux7d;taGQf6)6m!GeTt=QrkVH?eC*$nZU_9H6PQ->`rKP-&N-()?*-1O(?0?wvZ-M7jqTh&?G38*uY}bb-Jcrm|j~ zc-7NG6F1@4f`^oYB`+_}Y3^eS*F39}bNEZJ{H1lPH>#pwHbsAi5tj26 zt@4)>$jHnD&<7Z|XX+PBJvcPgv!-o^*S00VkwxouUw_4Rmy(=Z3lSQr9-18V%h0Gn z!-w;{e31P-6r=zhfZPici7pE1kQn3lfSciAVL;VIh`Uu+7ZDu%r-@Tb?`$rlcLxq6 zSr#9w^uqQ8jtxRezzf_TVPjF=y&Le(_|Xn~5?+KtdTcy?9q2$_X_E)m_q{jGky?%yxl!wU(0)+@oF~_#!RV!TQXZ-KniGF}OK9 zGc@1nb?Z^;F;N|jZd}byj_N4TV)z$EVzNMCpcG~1aaGuRC zK|cYk4lGhqQc~~1kc2wCufz?vVdBfni!sWN-T^<=$T#Eoh3MeE)<+P>j6|N`CU}MnHlh%vB zk>X-WXiU-*|9RP4b@{cG9c)lPd*&#h%<#-!4HH3`zU?(hp|X>RZZB0Ok}P>i{kC=?dz)`kOT?y?o)4Y=tM~Z9D}34Spkd>RKWcd z!0OOQ#}k7KA3b_>_wEb0F@OJtRZQs> zpRFv3k8d=Mp?H+xGg8meFRceNEqet*%v2ay@W~~XHa%g-Pir}*j8>3oQfb_Zx=k%Jfn)#>TLMR;fY|}gTiV(FaPXdf-br`&^ZI!ZmTH{& z%17qDPr7GUw^}`Uv+s+4uNxR`(d354>wc`8HVYuMVk9iEXv- z%!gW#o}hL?7s`}~7v35*66}<&-wd0y|AFjRsWl zdq+>bK|!Cx=-zU=eDfn#Rt2UqQqs~i!cap)B&o&z^hW(hpmf3Ly?SL{J_xPwVZ&GJ z>i|TnXWbvoA#F}LNfpcX#u$L$RL+RIeGusQ|BoEQP8J4a)40Uw4#KzsC>f@*|Jf)=AtjDcBw;mH8k02k6~-T(7%V z1Z##ja!p=p9@dYNutTTx+I_M-K-_0L3j-Zv+Kuq-Tw#*Fkz=Zo+P*cz^Fde?z%aZw zZp||3mI@#V>b3k67OZnMSwy@5*mJyqWfl7~1|7B^=K^iz-->K~Xx{WcEdV(!Y9NwJ z5|~6iqZ4}*0IC!Vuu^Ixph9n1953A{zphC^3ZRfUxBqEql(g0J-IUaA2vP6XRZTUI z&1L@Ghnn~qL_lpJ4E$J*-lv4JPR8&aNYP@4kiBLY=8V5JbJ~t#AOEYb6RI^+NXM~< z3W|86(}nHXY4KFBX3dVNhHzSRPP%i^DP*`Q89g;xXJV9a8D2w<_(XlfN3RD1C7(sZ z_36n$$~BdNF`ICc6-Y=G@!a_dkIfs$xsP)7vZS?3ep3V6D{NCM5lpYOpe?F>Pv9rh z{(@V*GVa5g*_2Kfi9!5#+qs_<`6h`@<`|t@vXH6ueUbYt4Wm>}d9>rwFpC=?LT*oe zY;?n31HYIz`9hItlJ^eBmb;KB`NlMO9TaZSvGh0#t9&Q?4QTthkDZw7C|oaU^mgi5 z&wWB4b8q0+mJo_GDF9;@4V(mDvoJn>ztCKOJ5cq3^rivmP3`HLoE03-(T@pTuDT)P{HVo9_NV6UazR< zPB|yES0*M_EZ)1m|;J%VRBA?d&b14)L z^w@Ad8(18m*R13!VzNF}>B=I=vd(7u`H1rOO z&MqzctAGC$jK+F7snexNnfY5+mlQlL3$W}yX9>BlnzARWYtO@a$m;B4)f%KDMQ=w~ z_phfcJ-%Tm=`zNRxDipIcs=n3A6rqb+kGcLE+})GvNvJoUN)Bc9uSi93pGYGxskBp zpwuXb8tO=IRr}(z-dgDX#fXVH=0&4p4By<8gsP?>&oVFKQ`juS)H=gQ*q7Iv6Q+VK zMZ;P-105$Gciaby@|RyVYjq zf@|5C@RSg2;*{rf36(5&SK5@DE}@ziS5qd zI*1hDe)tA_PdCLm48(A17WTT0Dy!bk?b`GOMI_;ewT%s1%+}Dpp`oYn6IPu%27i>f zxi7PXAcQL*o<>uVw_Rw=j*O8G(#UAnA&sr1I$xL;d}+Ous<# z;EiC~cDif{{w!8vnSql~(N{t{L~h$Qzy*2|lDCSB56EAev=xu+(krrX6x1*1YuK1& z9SI)e<)pW&oB*52I$-dlBB`>EPmh=w*R9u{2`un8p&fHts`sGNpN=Zc%iAlS+ObQ~ zfp$5H%A}xQijIRaxQ>A<&q?TJ8zhshwZ&6WzGxshV5#neLOML=u)-VVpVzyEqZ>}N z+_g{agmQ<87gzi^rv=Y7)T4{>WzxLv&{$MuSzLm`hI`c}>Z!=eaHP4V)ql#EdL$S)1FE4fHKy?RP{*rwjZm-D}I;Fa_`d^mVm%aisH+y`pa8 zsn+tKZc@FKbOGS}@e2EtGmcSv7!6O|+)3gY707?le)Z;m>%3cAy4HxbZO}_bER<&- zdm5OkpSLnDt+iAT@kjczyx)hPo2Syhm*lQ9J75|U z7HEq@nOEjZ@>dpv5ypeaVz~Kf5DZ&`Xmi5tal{sk+p? zwzdlUKWPb?zFWuM1Yl^FyH?^BhI^LVcO|`oD`Kd+VLuIjp%p>=ZE{8<8vuV{qOScZ zT{Du8ndGdhn?r_D=wrHeXWx{XJC!NWg;xD2cw7iKC($p zOhj{Yh4&E?zKA$jB5wfz&PQO3twlfSUh(A7BY*S>U;JqW5#M>Nl0D%gmzrziS{!v! z}J+76l_pgzneN+S~M=nxwS{C1mF-9!4%Cn=Sd#Ti{+IBjc zku6~aV9Ud~WhaSNkLjvBg~XZ-mvngk_mm+V3Q4atV(?ZoGoQXSzqm+kfM-C