I simplified a lot of API calls by pulling panel memory management
inside the library. All API calls which previously required a panel
as parameter are now handling their panel themself.
Previously every widget border was drawn by two overlapping rectangles
to limit the number of primitives required to be supported by any
potential backend. The biggest problem from using this approach
is drawing overhead and no real way to get widget transparency. So
I changed border drawing to use stroked rectangles instead of a
second filled rectangle drawing call.
using memcmp and decide whether to draw a new frame or not:
* added NK_ZERO_COMMAND_MEMORY macro
* when NK_ZERO_COMMAND_MEMORY is defined, inside
nk_command_buffer_push function there is an additional call
to NK_MEMSET after allocating memory for new drawing command
For more information please look inside the changelog. This is more of
an internal fix and hopefully does not break any existing code. I also
removed `nk_strfmt` from the API and made it internal only.
If you had any kind of popups like for example comboboxes inside a
deeper panel structure using nk_group, then `nk_xxx_close` would only
unblock input for the first level and not the whole panel stack. This is
now fixed and works correctly.
This is a breaking change which fixes bad closing behavior in
non-blocking popups. If the maximum size of a non-blocking popup was
not reached and you clicked to close the popup under it could happen
that it wouldn't be closed. This is now fixed in combination with
more popup control by allowing to set both the maximum height as
well as popup width.
Since it is not as clear on how to use the menubar correctly as I
thought added an assert into `nk_menubar_begin` with explainations on
how to use it correctly and stop wrong ussage.
Since it was not as apparent as I thought it is I added some
documentation warning to set the same flags each time you
include "nuklear.h" except `NK_IMPLEMENTATION` which is only
allowed to be defined once in *one* source file.
Functions `nk_combo`, `nk_combo_seperator`, `nk_combo_string`,
`nk_combo_callback`, `nk_combobox`, `nk_combobox_seperator`, `nk_combobox_string`,
`nk_combobox_callback` all calculated the the height of the combo box
panel wrong and forces a scrollbar even if it was not required. The
calculation is now fixed and should produce the right result.
This is basically a hack to fill the gaps. I have absoultly no idea why
I get some of these gaps but hopefully it is fixed and does not come
back to hunt me in the future.
I removed the default vertex type and instead create an API to allow the
user to specify the vertex struct layout. Of course you are still
bound on what the library actual has on vertex data but the type and
sequence of the data is now configurable. This commit is quite
experiental and could introduce some bugs, but so far it look fine.
This commit fixed some bugs from the last commit as well as some general
changes and fixes of some old bugs. For overview of all changes please
look inside `CHANGELOG.md`.
This is a rather experiemental commit to remove some internal complexity
that build up over time handling panel padding and border. There still
could be some bugs but I tried my best to keep everything working.
Previously it was only possible to scroll windows and groups by mouse.
No it is possible to scroll popups, as well as nonblocking popups like
menus, contextuals and comboboxes. In addition I fixed a drawing bug
in dynamically growing panels.
To account for hash collisions which can be quite nasty I added
the string representation of the window name for additional
assurance. I also added an assert to check and alert if two windows
have the same name.
It is now possible to temporarily push some style values like color,
style items, font, ... into a stack modify the value and as soon as
you are done just pop the changes. Main benefit is less boilerplate
code to manually save and restore configuration properties.
SDL iOs implementation provides key press and release in
one frame and while nuklear previously was keeping track
of transistions it did not check it. It hopefully should now be
possible to correctly interpret up and down key in the same frame.
Edit widget width `NK_EDIT_SIG_ENTER` flag now keep their active
state after enter was pressed. Main reason is to be able to keep
typing after commiting.
`nk_window_is_closed` previously checked if the window is hidden
instead of checking if it is closed. This behavior is now fixed and I
added an additional function `nk_window_is_hidden` to check if a
window is currently hidden.
Nuklear now has three different property versions for int, float and
added by this commit a double version. Internally an additional change
happend. Now the type of the property is actually taken into account
and floating pointer errors due to casting are less of an issue.
Since floating point to and from string conversion is a total pain
and really complex it is really hard to provide a realtive simple
non-standard library solution. But to solve both problems I now added
a way to overwrite the library intern float to string conversion
implementation if you really need more precision.
Since nuklear internal string to number conversion is quite imprecise,
and a correct solution is way to complex (I dare you to look at the
implementation of strtod, dtoa, ...) I now provide a new define to
overwrite the library function with either your own or the standard
libray implementation.
Under certain circumstances it is possible that because of floating
point error `nk_widget` will mark a widget as read only if used in
combination with `nk_layout_row`. The fix is rather simple in this
case since the additional floating point precision is not really needed
it is possible to just cast to int and remove the problem all togther.
There is now a difference between hiding a window with
`nk_window_show` and closing a window by clicking the close button in
the window header or calling `nk_window_close`. Only in the case of
activly closing a window will be removed at the end of the frame
besides getting removed if not updated inside the frame.
To support both string formats with string combined with length as
well as zero terminated strings I added a zero terminated string
version to `nk_edit_xxxx` with `nk_edit_string_zero_terminated`.
Fixed scrollbar auto hiding behavior to also work correctly if
the window is not hovered or manipulated in any way.
In addition I fixed a small panel padding bug in `nk_layout_widget`
for all panels outside windows which require a test on
`layout->flags` instead of `window->flags`.
The dynamic immediate mode layout API with `nk_layout_row_begin`,
`nk_layout_row_push` and `nk_layout_row_end` caused an infinite
scrollbar bug by wrongfully calculating the required widget sizes.
This bug is now fixed and everything is correctly calculated.
Previously I packed standard library variable arguments as well as
file operation into one define `NK_INCLUDE_STANDARD_IO`. This caused
some problems and I split the define into two. So if you want the old
behavior you need to define `NK_INCLUDE_STANDARD_IO` as well as
`NK_INCLUDE_STANDARD_VARARGS`. If you only want file operations but
not variable arguments only define `NK_INCLUDE_STANDARD_IO` and
if you only want varargs but not file operations please only define
`NK_INCLUDE_STANDARD_VARARGS`.
If you move the cursor to fast while scaling a window there is a
chance the mouse will miss the scaler and the scaling operation will
halt. Dragging in itself is quite hard but I implemented the hack I
use for property, window moving and slider for the window scaler and
scaling hopefully now works correctly.
This is quite an old bug and a result of being nearly stateless.
If you move/scale a window and another window is behind it the other
window will be acitvated and the move/scale operation will be stopped.
To fix this I now require no mouse down for activating by hovering.
I hope this does not cause any problems and fixes the problem for good.
I had a long standing bug inside nuklear which prevents you from
swapping out a font while the code is being build. This bug is now
fixed but the fix requires _ALL_ `nk_user_font` data structures
provided by `nk_style_set_font` to be persistent.
A previous push request added some macros into the header file and
I missed that it was outside the header include guard. This should
now be fixed and not cause problem if included multiple times in
different location.
Window scrollbar will if enabled by window flag hide if no user
interaction happens for a set time duration.
In addition the internal window/table data structs are now located
inside the header part of nuklear to remove the need to allocate a
pool and therefore simplify memory management.
Hopefully I finally fixed the hole inside combobox popup which only
occur if you set the window border size greater one. In addition
I fixed some subpixel drawing artifacts that come up if you use
antialising in combination with vertex buffer output.
I completely forgot to add the edit scrollbar style and
had a incorrect scrollbar bounds calculation. Both bugs
should now be fixed. Furthermore the edit ROM flag know
prevents any manipulating input instead of all input.
So it should be possible to move or copy inside the edit
field but not to modify the content.
For gui elements like tree tabs, tree nodes and windows themselves,
you can repeatedly click the same "minimize" region and it keeps
toggling that element. This was not the case with "popup" type of
elements. This commit slightly changes how the popups close once
they are already open.
Like before, the user can close the popup by just clicking outside
the popups region. Now the user can also close the popup by clicking
the "header" region of the popup.
