#![cfg_attr(feature = "cargo-clippy", allow(clippy::transmute_ptr_to_ptr))]
#![cfg_attr(feature = "cargo-clippy", allow(clippy::transmute_ptr_to_ref))]
#![cfg_attr(feature = "cargo-clippy", allow(clippy::needless_pass_by_value))]
#![cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
#![cfg_attr(feature = "cargo-clippy", allow(clippy::trivially_copy_pass_by_ref))]
#![cfg_attr(feature = "cargo-clippy", allow(clippy::cast_ptr_alignment))]
#![cfg_attr(feature = "cargo-clippy", allow(non_upper_case_globals))]
#![allow(non_upper_case_globals)]
#[macro_use]
extern crate log;
#[cfg(feature = "input-device")]
use input_device::{
ElementState, Event as InputEvent, KeyboardInput, MouseButton as InputMouseButton,
VirtualKeyCode,
};
mod alloc_heap;
mod alloc_vec;
pub mod compr;
pub mod object_pool;
use std::borrow::Cow;
use std::convert::TryFrom;
use std::default::Default;
use std::fmt::Debug;
use std::fs::File;
use std::io::Read;
use std::os::raw::*;
use std::path::Path;
use nuki_sys::*;
pub use nuki_sys as ffi;
pub type AllocationType = nuki_sys::nk_allocation_type;
pub type DrawListStroke = nuki_sys::nk_draw_list_stroke;
pub type Flags = nuki_sys::nk_flags;
pub type FontCoordType = nuki_sys::nk_font_coord_type;
pub type PanelRowLayoutType = nuki_sys::nk_panel_row_layout_type;
pub type PanelType = nuki_sys::nk_panel_type;
pub type StyleColor = nuki_sys::nk_style_colors;
pub type StyleCursor = nuki_sys::nk_style_cursor;
pub type StyleHeaderAlign = nuki_sys::nk_style_header_align;
pub type WidgetLayoutState = nuki_sys::nk_widget_layout_states;
pub type ChartSlot = nuki_sys::nk_chart_slot;
pub type Color = nuki_sys::nk_color;
pub type ColorF = nuki_sys::nk_colorf;
pub type MenuState = nuki_sys::nk_menu_state;
pub type PopupBuffer = nuki_sys::nk_popup_buffer;
pub type Rect = nuki_sys::nk_rect;
pub type Recti = nuki_sys::nk_recti;
pub type Scroll = nuki_sys::nk_scroll;
pub type Size = nuki_sys::nk_size;
pub type StyleText = nuki_sys::nk_style_text;
pub type Vec2 = nuki_sys::nk_vec2;
pub type Vec2i = nuki_sys::nk_vec2i;
pub type Glyph = nuki_sys::nk_glyph;
pub type PluginCopy = nuki_sys::nk_plugin_copy;
pub type PluginFilter = nuki_sys::nk_plugin_filter;
pub type PluginPaste = nuki_sys::nk_plugin_paste;
pub const NK_FILTER_DEFAULT: PluginFilter = Some(nk_filter_default);
pub const NK_FILTER_ASCII: PluginFilter = Some(nk_filter_ascii);
pub const NK_FILTER_FLOAT: PluginFilter = Some(nk_filter_float);
pub const NK_FILTER_DECIMAL: PluginFilter = Some(nk_filter_decimal);
pub const NK_FILTER_HEX: PluginFilter = Some(nk_filter_hex);
pub const NK_FILTER_OCT: PluginFilter = Some(nk_filter_oct);
pub const NK_FILTER_BINARY: PluginFilter = Some(nk_filter_binary);
pub const ALIGNMENT: usize = 16;
macro_rules! wrapper_impls {
($name:ident, $typ:ty) => {
impl AsRef<$typ> for $name {
fn as_ref(&self) -> &$typ {
&self.internal
}
}
impl AsMut<$typ> for $name {
fn as_mut(&mut self) -> &mut $typ {
&mut self.internal
}
}
impl AsRef<$name> for $typ {
fn as_ref(&self) -> &$name {
unsafe { &*(self as *const $typ as *const $name) }
}
}
impl AsMut<$name> for $typ {
fn as_mut(&mut self) -> &mut $name {
unsafe { &mut *(self as *mut $typ as *mut $name) }
}
}
impl Default for $name {
fn default() -> Self {
$name {
internal: unsafe { ::std::mem::zeroed() },
}
}
}
};
}
macro_rules! wrapper_type {
($name:ident, $typ:ty) => {
#[derive(Clone)]
#[repr(C)]
pub struct $name {
internal: $typ,
}
wrapper_impls!($name, $typ);
};
}
macro_rules! wrapper_type_no_clone {
($name:ident, $typ:ty) => {
#[repr(C)]
pub struct $name {
internal: $typ,
}
wrapper_impls!($name, $typ);
};
}
macro_rules! from_into_enum {
($name:ident, $typ:ty) => {
impl From<$name> for $typ {
fn from(a: $name) -> $typ {
a as $typ
}
}
impl From<$typ> for $name {
fn from(a: $typ) -> $name {
unsafe { ::std::mem::transmute(a) }
}
}
impl<'a> From<&'a $typ> for &'a $name {
fn from(a: &'a $typ) -> &'a $name {
unsafe { ::std::mem::transmute(a) }
}
}
};
}
#[derive(Debug)]
pub struct FlagsBuilder;
impl FlagsBuilder {
#[inline]
pub fn align() -> AlignFlagsBuilder {
AlignFlagsBuilder { flags: 0 }
}
#[inline]
pub fn panel() -> PanelFlagsBuilder {
PanelFlagsBuilder { flags: 0 }
}
}
#[derive(Debug)]
pub struct AlignFlagsBuilder {
flags: isize,
}
impl From<AlignFlagsBuilder> for Flags {
fn from(val: AlignFlagsBuilder) -> Flags {
val.flags as Flags
}
}
impl AlignFlagsBuilder {
#[inline]
pub fn clear(mut self) -> Self {
self.flags = 0;
self
}
#[inline]
pub fn left(mut self) -> Self {
self.flags |= TextAlign::Left as isize;
self
}
#[inline]
pub fn centered(mut self) -> Self {
self.flags |= TextAlign::Centered as isize;
self
}
#[inline]
pub fn right(mut self) -> Self {
self.flags |= TextAlign::Right as isize;
self
}
#[inline]
pub fn top(mut self) -> Self {
self.flags |= TextAlign::Top as isize;
self
}
#[inline]
pub fn middle(mut self) -> Self {
self.flags |= TextAlign::Middle as isize;
self
}
#[inline]
pub fn bottom(mut self) -> Self {
self.flags |= TextAlign::Bottom as isize;
self
}
}
#[derive(Debug)]
pub struct PanelFlagsBuilder {
flags: isize,
}
impl From<PanelFlagsBuilder> for Flags {
fn from(val: PanelFlagsBuilder) -> Flags {
val.flags as Flags
}
}
impl PanelFlagsBuilder {
#[inline]
pub fn clear(mut self) -> Self {
self.flags = 0;
self
}
#[inline]
pub fn border(mut self) -> Self {
self.flags |= PanelFlags::Border as isize;
self
}
#[inline]
pub fn movable(mut self) -> Self {
self.flags |= PanelFlags::Movable as isize;
self
}
#[inline]
pub fn scalable(mut self) -> Self {
self.flags |= PanelFlags::Scalable as isize;
self
}
#[inline]
pub fn closable(mut self) -> Self {
self.flags |= PanelFlags::Closable as isize;
self
}
#[inline]
pub fn minimizable(mut self) -> Self {
self.flags |= PanelFlags::Minimizable as isize;
self
}
#[inline]
pub fn no_scroll_bar(mut self) -> Self {
self.flags |= PanelFlags::NoScrollbar as isize;
self
}
#[inline]
pub fn title(mut self) -> Self {
self.flags |= PanelFlags::Title as isize;
self
}
#[inline]
pub fn scroll_auto_hide(mut self) -> Self {
self.flags |= PanelFlags::ScrollAutoHide as isize;
self
}
#[inline]
pub fn background(mut self) -> Self {
self.flags |= PanelFlags::Background as isize;
self
}
#[inline]
pub fn scroll_left(mut self) -> Self {
self.flags |= PanelFlags::ScaleLeft as isize;
self
}
#[inline]
pub fn no_input(mut self) -> Self {
self.flags |= PanelFlags::NoInput as isize;
self
}
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum CommandType {
Nop = nk_command_type_NK_COMMAND_NOP as isize,
Scissor = nk_command_type_NK_COMMAND_SCISSOR as isize,
Line = nk_command_type_NK_COMMAND_LINE as isize,
Curve = nk_command_type_NK_COMMAND_CURVE as isize,
Rect = nk_command_type_NK_COMMAND_RECT as isize,
RectFilled = nk_command_type_NK_COMMAND_RECT_FILLED as isize,
RectMultiColor = nk_command_type_NK_COMMAND_RECT_MULTI_COLOR as isize,
Circle = nk_command_type_NK_COMMAND_CIRCLE as isize,
CircleFilled = nk_command_type_NK_COMMAND_CIRCLE_FILLED as isize,
Arc = nk_command_type_NK_COMMAND_ARC as isize,
ArcFilled = nk_command_type_NK_COMMAND_ARC_FILLED as isize,
Triangle = nk_command_type_NK_COMMAND_TRIANGLE as isize,
TriangleFilled = nk_command_type_NK_COMMAND_TRIANGLE_FILLED as isize,
Polygon = nk_command_type_NK_COMMAND_POLYGON as isize,
PolygonFilled = nk_command_type_NK_COMMAND_POLYGON_FILLED as isize,
Polyline = nk_command_type_NK_COMMAND_POLYLINE as isize,
Text = nk_command_type_NK_COMMAND_TEXT as isize,
Image = nk_command_type_NK_COMMAND_IMAGE as isize,
Custom = nk_command_type_NK_COMMAND_CUSTOM as isize,
}
from_into_enum!(CommandType, nk_command_type);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum SymbolType {
None = nk_symbol_type_NK_SYMBOL_NONE as isize,
X = nk_symbol_type_NK_SYMBOL_X as isize,
Underscore = nk_symbol_type_NK_SYMBOL_UNDERSCORE as isize,
CircleSolid = nk_symbol_type_NK_SYMBOL_CIRCLE_SOLID as isize,
CircleOutline = nk_symbol_type_NK_SYMBOL_CIRCLE_OUTLINE as isize,
RectSolid = nk_symbol_type_NK_SYMBOL_RECT_SOLID as isize,
RectOutline = nk_symbol_type_NK_SYMBOL_RECT_OUTLINE as isize,
TriangleUp = nk_symbol_type_NK_SYMBOL_TRIANGLE_UP as isize,
TriangleDown = nk_symbol_type_NK_SYMBOL_TRIANGLE_DOWN as isize,
TriangleLeft = nk_symbol_type_NK_SYMBOL_TRIANGLE_LEFT as isize,
TriangleRight = nk_symbol_type_NK_SYMBOL_TRIANGLE_RIGHT as isize,
Plus = nk_symbol_type_NK_SYMBOL_PLUS as isize,
Minus = nk_symbol_type_NK_SYMBOL_MINUS as isize,
Max = nk_symbol_type_NK_SYMBOL_MAX as isize,
}
from_into_enum!(SymbolType, nk_symbol_type);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum EditFlag {
Default = nk_edit_flags_NK_EDIT_DEFAULT as isize,
ReadOnly = nk_edit_flags_NK_EDIT_READ_ONLY as isize,
AutoSelect = nk_edit_flags_NK_EDIT_AUTO_SELECT as isize,
SigEnter = nk_edit_flags_NK_EDIT_SIG_ENTER as isize,
AllowTab = nk_edit_flags_NK_EDIT_ALLOW_TAB as isize,
NoCursor = nk_edit_flags_NK_EDIT_NO_CURSOR as isize,
Selectable = nk_edit_flags_NK_EDIT_SELECTABLE as isize,
Clipboard = nk_edit_flags_NK_EDIT_CLIPBOARD as isize,
CtrlEnterNewline = nk_edit_flags_NK_EDIT_CTRL_ENTER_NEWLINE as isize,
NoHorizontalScroll = nk_edit_flags_NK_EDIT_NO_HORIZONTAL_SCROLL as isize,
AlwaysInsertMode = nk_edit_flags_NK_EDIT_ALWAYS_INSERT_MODE as isize,
Multiline = nk_edit_flags_NK_EDIT_MULTILINE as isize,
GoToEndOnActivate = nk_edit_flags_NK_EDIT_GOTO_END_ON_ACTIVATE as isize,
}
from_into_enum!(EditFlag, nk_edit_flags);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum EditType {
Simple = nk_edit_types_NK_EDIT_SIMPLE as isize,
Field = nk_edit_types_NK_EDIT_FIELD as isize,
Box = nk_edit_types_NK_EDIT_BOX as isize,
Editor = nk_edit_types_NK_EDIT_EDITOR as isize,
}
from_into_enum!(EditType, nk_edit_types);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum EditEvent {
Active = nk_edit_events_NK_EDIT_ACTIVE as isize,
Inactive = nk_edit_events_NK_EDIT_INACTIVE as isize,
Activated = nk_edit_events_NK_EDIT_ACTIVATED as isize,
Deactivated = nk_edit_events_NK_EDIT_DEACTIVATED as isize,
Commited = nk_edit_events_NK_EDIT_COMMITED as isize,
}
from_into_enum!(EditEvent, nk_edit_events);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum PanelFlags {
Border = nk_panel_flags_NK_WINDOW_BORDER as isize,
Movable = nk_panel_flags_NK_WINDOW_MOVABLE as isize,
Scalable = nk_panel_flags_NK_WINDOW_SCALABLE as isize,
Closable = nk_panel_flags_NK_WINDOW_CLOSABLE as isize,
Minimizable = nk_panel_flags_NK_WINDOW_MINIMIZABLE as isize,
NoScrollbar = nk_panel_flags_NK_WINDOW_NO_SCROLLBAR as isize,
Title = nk_panel_flags_NK_WINDOW_TITLE as isize,
ScrollAutoHide = nk_panel_flags_NK_WINDOW_SCROLL_AUTO_HIDE as isize,
Background = nk_panel_flags_NK_WINDOW_BACKGROUND as isize,
ScaleLeft = nk_panel_flags_NK_WINDOW_SCALE_LEFT as isize,
NoInput = nk_panel_flags_NK_WINDOW_NO_INPUT as isize,
}
from_into_enum!(PanelFlags, nk_panel_flags);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Heading {
Up = nk_heading_NK_UP as isize,
Right = nk_heading_NK_RIGHT as isize,
Down = nk_heading_NK_DOWN as isize,
Left = nk_heading_NK_LEFT as isize,
}
from_into_enum!(Heading, nk_heading);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ButtonBehavior {
Default = nk_button_behavior_NK_BUTTON_DEFAULT as isize,
Repeater = nk_button_behavior_NK_BUTTON_REPEATER as isize,
}
from_into_enum!(ButtonBehavior, nk_button_behavior);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Modify {
Fixed = nk_modify_NK_FIXED as isize,
Modifiable = nk_modify_NK_MODIFIABLE as isize,
}
from_into_enum!(Modify, nk_modify);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Orientation {
Vertical = nk_orientation_NK_VERTICAL as isize,
Horizontal = nk_orientation_NK_HORIZONTAL as isize,
}
from_into_enum!(Orientation, nk_orientation);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum CollapseState {
Minimized = nk_collapse_states_NK_MINIMIZED as isize,
Maximized = nk_collapse_states_NK_MAXIMIZED as isize,
}
from_into_enum!(CollapseState, nk_collapse_states);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ShowState {
Hidden = nk_show_states_NK_HIDDEN as isize,
Shown = nk_show_states_NK_SHOWN as isize,
}
from_into_enum!(ShowState, nk_show_states);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ChartType {
Lines = nk_chart_type_NK_CHART_LINES as isize,
Column = nk_chart_type_NK_CHART_COLUMN as isize,
Max = nk_chart_type_NK_CHART_MAX as isize,
}
from_into_enum!(ChartType, nk_chart_type);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ChartEvent {
Hovering = nk_chart_event_NK_CHART_HOVERING as isize,
Clicked = nk_chart_event_NK_CHART_CLICKED as isize,
}
from_into_enum!(ChartEvent, nk_chart_event);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ColorFormat {
Rgb = nk_color_format_NK_RGB as isize,
Rgba = nk_color_format_NK_RGBA as isize,
}
from_into_enum!(ColorFormat, nk_color_format);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum PopupType {
Static = nk_popup_type_NK_POPUP_STATIC as isize,
Dynamic = nk_popup_type_NK_POPUP_DYNAMIC as isize,
}
from_into_enum!(PopupType, nk_popup_type);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum LayoutFormat {
Dynamic = nk_layout_format_NK_DYNAMIC as isize,
Static = nk_layout_format_NK_STATIC as isize,
}
from_into_enum!(LayoutFormat, nk_layout_format);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum TreeType {
Node = nk_tree_type_NK_TREE_NODE as isize,
Tab = nk_tree_type_NK_TREE_TAB as isize,
}
from_into_enum!(TreeType, nk_tree_type);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum TextAlign {
Left = nk_text_align_NK_TEXT_ALIGN_LEFT as isize,
Centered = nk_text_align_NK_TEXT_ALIGN_CENTERED as isize,
Right = nk_text_align_NK_TEXT_ALIGN_RIGHT as isize,
Top = nk_text_align_NK_TEXT_ALIGN_TOP as isize,
Middle = nk_text_align_NK_TEXT_ALIGN_MIDDLE as isize,
Bottom = nk_text_align_NK_TEXT_ALIGN_BOTTOM as isize,
}
from_into_enum!(TextAlign, nk_text_align);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum TextAlignment {
Left = nk_text_alignment_NK_TEXT_LEFT as isize,
Centered = nk_text_alignment_NK_TEXT_CENTERED as isize,
Right = nk_text_alignment_NK_TEXT_RIGHT as isize,
}
from_into_enum!(TextAlignment, nk_text_alignment);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Key {
None = nk_keys_NK_KEY_NONE as isize,
Shift = nk_keys_NK_KEY_SHIFT as isize,
Ctrl = nk_keys_NK_KEY_CTRL as isize,
Del = nk_keys_NK_KEY_DEL as isize,
Enter = nk_keys_NK_KEY_ENTER as isize,
Tab = nk_keys_NK_KEY_TAB as isize,
Backspace = nk_keys_NK_KEY_BACKSPACE as isize,
Copy = nk_keys_NK_KEY_COPY as isize,
Cut = nk_keys_NK_KEY_CUT as isize,
Paste = nk_keys_NK_KEY_PASTE as isize,
Up = nk_keys_NK_KEY_UP as isize,
Down = nk_keys_NK_KEY_DOWN as isize,
Left = nk_keys_NK_KEY_LEFT as isize,
Right = nk_keys_NK_KEY_RIGHT as isize,
InsertMode = nk_keys_NK_KEY_TEXT_INSERT_MODE as isize,
ReplaceMode = nk_keys_NK_KEY_TEXT_REPLACE_MODE as isize,
ResetMode = nk_keys_NK_KEY_TEXT_RESET_MODE as isize,
LineStart = nk_keys_NK_KEY_TEXT_LINE_START as isize,
LineEnd = nk_keys_NK_KEY_TEXT_LINE_END as isize,
TextStart = nk_keys_NK_KEY_TEXT_START as isize,
TextEnd = nk_keys_NK_KEY_TEXT_END as isize,
TextUndo = nk_keys_NK_KEY_TEXT_UNDO as isize,
TextRedo = nk_keys_NK_KEY_TEXT_REDO as isize,
TextSelectAll = nk_keys_NK_KEY_TEXT_SELECT_ALL as isize,
TextWordLeft = nk_keys_NK_KEY_TEXT_WORD_LEFT as isize,
TextWordRight = nk_keys_NK_KEY_TEXT_WORD_RIGHT as isize,
ScrollStart = nk_keys_NK_KEY_SCROLL_START as isize,
ScrollEnd = nk_keys_NK_KEY_SCROLL_END as isize,
ScrollDown = nk_keys_NK_KEY_SCROLL_DOWN as isize,
ScrollUp = nk_keys_NK_KEY_SCROLL_UP as isize,
}
from_into_enum!(Key, nk_keys);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Button {
Left = nk_buttons_NK_BUTTON_LEFT as isize,
Middle = nk_buttons_NK_BUTTON_MIDDLE as isize,
Right = nk_buttons_NK_BUTTON_RIGHT as isize,
Double = nk_buttons_NK_BUTTON_DOUBLE as isize,
Max = nk_buttons_NK_BUTTON_MAX as isize,
}
from_into_enum!(Button, nk_buttons);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum AntiAliasing {
Off = nk_anti_aliasing_NK_ANTI_ALIASING_OFF as isize,
On = nk_anti_aliasing_NK_ANTI_ALIASING_ON as isize,
}
from_into_enum!(AntiAliasing, nk_anti_aliasing);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum DrawVertexLayoutFormat {
Char = nk_draw_vertex_layout_format_NK_FORMAT_SCHAR as isize,
Short = nk_draw_vertex_layout_format_NK_FORMAT_SSHORT as isize,
Int = nk_draw_vertex_layout_format_NK_FORMAT_SINT as isize,
Uchar = nk_draw_vertex_layout_format_NK_FORMAT_UCHAR as isize,
Ushort = nk_draw_vertex_layout_format_NK_FORMAT_USHORT as isize,
Uint = nk_draw_vertex_layout_format_NK_FORMAT_UINT as isize,
Float = nk_draw_vertex_layout_format_NK_FORMAT_FLOAT as isize,
Double = nk_draw_vertex_layout_format_NK_FORMAT_DOUBLE as isize,
R8G8B8 = nk_draw_vertex_layout_format_NK_FORMAT_R8G8B8 as isize,
R16G16B16 = nk_draw_vertex_layout_format_NK_FORMAT_R16G15B16 as isize,
R32G32B32 = nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32 as isize,
R8G8B8A8 = nk_draw_vertex_layout_format_NK_FORMAT_R8G8B8A8 as isize,
B8G8R8A8 = nk_draw_vertex_layout_format_NK_FORMAT_B8G8R8A8 as isize,
R16G15B16A16 = nk_draw_vertex_layout_format_NK_FORMAT_R16G15B16A16 as isize,
R32G32B32A32 = nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32 as isize,
R32G32B32A32Float = nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32_FLOAT as isize,
R32G32B32A32Double = nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32_DOUBLE as isize,
Rgb32 = nk_draw_vertex_layout_format_NK_FORMAT_RGB32 as isize,
Rgba32 = nk_draw_vertex_layout_format_NK_FORMAT_RGBA32 as isize,
Count = nk_draw_vertex_layout_format_NK_FORMAT_COUNT as isize,
}
from_into_enum!(DrawVertexLayoutFormat, nk_draw_vertex_layout_format);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum DrawVertexLayoutAttribute {
Position = nk_draw_vertex_layout_attribute_NK_VERTEX_POSITION as isize,
Color = nk_draw_vertex_layout_attribute_NK_VERTEX_COLOR as isize,
TexCoord = nk_draw_vertex_layout_attribute_NK_VERTEX_TEXCOORD as isize,
AttributeCount = nk_draw_vertex_layout_attribute_NK_VERTEX_ATTRIBUTE_COUNT as isize,
}
from_into_enum!(DrawVertexLayoutAttribute, nk_draw_vertex_layout_attribute);
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum FontAtlasFormat {
Alpha8 = nk_font_atlas_format_NK_FONT_ATLAS_ALPHA8 as isize,
Rgba32 = nk_font_atlas_format_NK_FONT_ATLAS_RGBA32 as isize,
Argb32 = nk_font_atlas_format_NK_FONT_ATLAS_ARGB32 as isize,
}
from_into_enum!(FontAtlasFormat, nk_font_atlas_format);
unsafe extern "C" fn nk_filter_custom(
arg1: *const nk_text_edit,
unicode: nk_rune,
) -> ::std::os::raw::c_int {
if let Some(f) = CUSTOM_EDIT_FILTER {
if f(
&*(arg1 as *const TextEdit),
::std::char::from_u32_unchecked(unicode),
) {
1
} else {
0
}
} else {
1
}
}
static mut CUSTOM_EDIT_FILTER: Option<fn(&TextEdit, char) -> bool> = None;
#[derive(Clone)]
pub struct String<'a> {
bytes: Cow<'a, [u8]>,
}
impl<'a> String<'a> {
pub unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> String<'a> {
String {
bytes: Cow::Borrowed(bytes),
}
}
pub fn as_ptr(&self) -> *const c_char {
self.bytes.as_ptr() as *const c_char
}
}
impl<'a> From<&'a str> for String<'a> {
fn from(value: &'a str) -> String<'a> {
let mut bytes: Vec<u8> = value.bytes().collect();
bytes.push(0);
String {
bytes: Cow::Owned(bytes),
}
}
}
impl<'a> From<::std::string::String> for String<'a> {
fn from(mut value: ::std::string::String) -> String<'a> {
value.push('\0');
String {
bytes: Cow::Owned(value.into_bytes()),
}
}
}
#[macro_export]
macro_rules! nk_string {
($e:tt) => ({
let value = concat!($e, "\0");
unsafe { $crate::String::from_bytes_unchecked(value.as_bytes()) }
});
($e:tt, $($arg:tt)*) => ({
$crate::String::from(format!($e, $($arg)*))
})
}
#[derive(Clone)]
pub struct StringArray<'a> {
arr: Vec<String<'a>>,
ptrs: Vec<*const c_char>,
}
impl<'a> StringArray<'a> {
pub fn as_ptr(&self) -> *const *const c_char {
self.ptrs.as_slice() as *const _ as *const *const c_char
}
pub fn as_mut(&mut self) -> *mut *const c_char {
self.ptrs.as_mut_slice() as *mut _ as *mut *const c_char
}
pub fn len(&self) -> usize {
self.ptrs.len()
}
pub fn is_empty(&self) -> bool {
self.len() < 1
}
}
impl<'a> From<&'a [&'a str]> for StringArray<'a> {
fn from(value: &[&'a str]) -> StringArray<'a> {
let mut r = StringArray {
arr: Vec::with_capacity(value.len()),
ptrs: Vec::with_capacity(value.len()),
};
for s in value {
r.arr.push(String::from(*s));
r.ptrs.push(r.arr[r.arr.len() - 1].as_ptr());
}
r
}
}
#[derive(Debug, Clone, PartialEq, Copy)]
enum HandleKind {
Empty,
Ptr,
Id,
Unknown,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct Handle {
internal: nk_handle,
kind: HandleKind,
}
impl Debug for Handle {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
unsafe {
match self.kind {
HandleKind::Empty => write!(f, "Handle {{}}"),
HandleKind::Ptr => write!(f, "Handle {{ Ptr: {:?} }}", self.internal.ptr),
HandleKind::Id => write!(f, "Handle {{ Id: {:?} }}", self.internal.id),
HandleKind::Unknown => write!(
f,
"Handle {{ Ptr: {:?}, Id: {:?} }}",
self.internal.ptr, self.internal.id
),
}
}
}
}
impl Default for Handle {
fn default() -> Self {
Handle {
kind: HandleKind::Empty,
internal: nk_handle::default(),
}
}
}
impl Handle {
pub fn id(&mut self) -> Option<i32> {
match self.kind {
HandleKind::Id | HandleKind::Unknown => Some(unsafe { self.internal.id }),
_ => None,
}
}
pub fn ptr(&mut self) -> Option<*mut c_void> {
match self.kind {
HandleKind::Ptr | HandleKind::Unknown => Some(unsafe { self.internal.ptr }),
_ => None,
}
}
pub fn from_id(value: i32) -> Handle {
Handle {
kind: HandleKind::Id,
internal: unsafe { nk_handle_id(value) },
}
}
pub unsafe fn from_ptr(value: *mut c_void) -> Handle {
Handle {
kind: HandleKind::Ptr,
internal: nk_handle_ptr(value),
}
}
}
wrapper_type!(Clipboard, nk_clipboard);
impl Clipboard {
pub unsafe fn userdata_ptr(&self) -> Handle {
Handle::from_ptr(self.internal.userdata.ptr)
}
pub unsafe fn userdata_id(&self) -> Handle {
Handle::from_id(self.internal.userdata.id)
}
pub fn paste(&self) -> PluginPaste {
self.internal.paste
}
pub fn set_paste(&mut self, plug: PluginPaste) {
self.internal.paste = plug;
}
pub fn copy(&self) -> PluginCopy {
self.internal.copy
}
pub fn set_copy(&mut self, plug: PluginCopy) {
self.internal.copy = plug;
}
}
wrapper_type!(Input, nk_input);
impl Input {
pub fn mouse(&self) -> Mouse {
Mouse {
internal: self.internal.mouse,
}
}
pub fn has_mouse_click(&self, b: Button) -> bool {
unsafe { nk_input_has_mouse_click(&self.internal, b.into()) != 0 }
}
pub fn has_mouse_click_in_rect(&self, b: Button, rect: Rect) -> bool {
unsafe { nk_input_has_mouse_click_in_rect(&self.internal, b.into(), rect) != 0 }
}
pub fn has_mouse_click_down_in_rect(&self, b: Button, rect: Rect, down: bool) -> bool {
unsafe {
nk_input_has_mouse_click_down_in_rect(
&self.internal,
b.into(),
rect,
if down { 1 } else { 0 },
) != 0
}
}
pub fn is_mouse_click_in_rect(&self, b: Button, rect: Rect) -> bool {
unsafe { nk_input_is_mouse_click_in_rect(&self.internal, b.into(), rect) != 0 }
}
pub fn is_mouse_click_down_in_rect(&self, b: Button, rect: Rect, down: bool) -> bool {
unsafe {
nk_input_is_mouse_click_down_in_rect(
&self.internal,
b.into(),
rect,
down as ::std::os::raw::c_int,
) != 0
}
}
pub fn any_mouse_click_in_rect(&self, rect: Rect) -> bool {
unsafe { nk_input_any_mouse_click_in_rect(&self.internal, rect) != 0 }
}
pub fn is_mouse_prev_hovering_rect(&self, rect: Rect) -> bool {
unsafe { nk_input_is_mouse_prev_hovering_rect(&self.internal, rect) != 0 }
}
pub fn is_mouse_hovering_rect(&self, rect: Rect) -> bool {
unsafe { nk_input_is_mouse_hovering_rect(&self.internal, rect) != 0 }
}
pub fn is_mouse_clicked(&self, b: Button, rect: Rect) -> bool {
unsafe { nk_input_mouse_clicked(&self.internal, b.into(), rect) != 0 }
}
pub fn is_mouse_down(&self, b: Button) -> bool {
unsafe { nk_input_is_mouse_down(&self.internal, b.into()) != 0 }
}
pub fn is_mouse_pressed(&self, b: Button) -> bool {
unsafe { nk_input_is_mouse_pressed(&self.internal, b.into()) != 0 }
}
pub fn is_mouse_released(&self, b: Button) -> bool {
unsafe { nk_input_is_mouse_released(&self.internal, b.into()) != 0 }
}
pub fn is_key_pressed(&self, k: Key) -> bool {
unsafe { nk_input_is_key_pressed(&self.internal, k.into()) != 0 }
}
pub fn is_key_released(&self, k: Key) -> bool {
unsafe { nk_input_is_key_released(&self.internal, k.into()) != 0 }
}
pub fn is_key_down(&self, k: Key) -> bool {
unsafe { nk_input_is_key_down(&self.internal, k.into()) != 0 }
}
}
wrapper_type!(DrawCommand, nk_draw_command);
impl DrawCommand {
pub fn clip_rect(&self) -> &Rect {
&self.internal.clip_rect
}
pub fn elem_count(&self) -> u32 {
self.internal.elem_count
}
pub fn texture(&self) -> Handle {
Handle {
kind: HandleKind::Unknown,
internal: self.internal.texture,
}
}
}
#[derive(Copy, Clone, Debug)]
pub struct MouseButton {
pub down: bool,
pub clicked: bool,
pub clicked_pos: Vec2,
}
impl MouseButton {
fn from_native(n: nk_mouse_button) -> MouseButton {
MouseButton {
down: n.down > 0,
clicked: n.clicked > 0,
clicked_pos: n.clicked_pos,
}
}
}
wrapper_type!(Mouse, nk_mouse);
impl Mouse {
pub fn pos(&self) -> &Vec2 {
&self.internal.pos
}
pub fn prev(&self) -> &Vec2 {
&self.internal.prev
}
pub fn delta(&self) -> &Vec2 {
&self.internal.delta
}
pub fn scroll_delta(&self) -> &Vec2 {
&self.internal.scroll_delta
}
pub fn buttons(&self) -> [MouseButton; 3] {
[
MouseButton::from_native(self.internal.buttons[0]),
MouseButton::from_native(self.internal.buttons[1]),
MouseButton::from_native(self.internal.buttons[2]),
]
}
pub fn grabbed(&self) -> bool {
self.internal.grabbed > 0
}
}
wrapper_type!(Style, nk_style);
impl Style {
pub fn window_mut(&mut self) -> &mut StyleWindow {
unsafe { ::std::mem::transmute(&mut self.internal.window) }
}
pub fn font_mut(&mut self) -> &mut UserFont {
unsafe { ::std::mem::transmute(self.internal.font) }
}
pub fn cursors_mut(&mut self) -> &mut CursorMap {
unsafe { ::std::mem::transmute(&mut self.internal.cursors) }
}
pub fn cursor_active_mut(&mut self) -> &mut Cursor {
unsafe { ::std::mem::transmute(&mut self.internal.cursor_active) }
}
pub fn set_cursor_visible(&mut self, value: bool) {
self.internal.cursor_visible = if value { 1 } else { 0 }
}
pub fn text_mut(&mut self) -> &mut StyleText {
&mut self.internal.text
}
pub fn button_mut(&mut self) -> &mut StyleButton {
unsafe { ::std::mem::transmute(&mut self.internal.button) }
}
pub fn contextual_button_mut(&mut self) -> &mut StyleButton {
unsafe { ::std::mem::transmute(&mut self.internal.contextual_button) }
}
pub fn menu_button_mut(&mut self) -> &mut StyleButton {
unsafe { ::std::mem::transmute(&mut self.internal.menu_button) }
}
pub fn option_mut(&mut self) -> &mut StyleToggle {
unsafe { ::std::mem::transmute(&mut self.internal.option) }
}
pub fn checkbox_mut(&mut self) -> &mut StyleToggle {
unsafe { ::std::mem::transmute(&mut self.internal.checkbox) }
}
pub fn selectable_mut(&mut self) -> &mut StyleSelectable {
unsafe { ::std::mem::transmute(&mut self.internal.selectable) }
}
pub fn slider_mut(&mut self) -> &mut StyleSlider {
unsafe { ::std::mem::transmute(&mut self.internal.slider) }
}
pub fn progress_mut(&mut self) -> &mut StyleProgress {
unsafe { ::std::mem::transmute(&mut self.internal.progress) }
}
pub fn property_mut(&mut self) -> &mut StyleProperty {
unsafe { ::std::mem::transmute(&mut self.internal.property) }
}
pub fn edit_mut(&mut self) -> &mut StyleEdit {
unsafe { ::std::mem::transmute(&mut self.internal.edit) }
}
pub fn chart_mut(&mut self) -> &mut StyleChart {
unsafe { ::std::mem::transmute(&mut self.internal.chart) }
}
pub fn scroll_h_mut(&mut self) -> &mut StyleScrollbar {
unsafe { ::std::mem::transmute(&mut self.internal.scrollh) }
}
pub fn scroll_v_mut(&mut self) -> &mut StyleScrollbar {
unsafe { ::std::mem::transmute(&mut self.internal.scrollv) }
}
pub fn tab_mut(&mut self) -> &mut StyleTab {
unsafe { ::std::mem::transmute(&mut self.internal.tab) }
}
pub fn combo_mut(&mut self) -> &mut StyleCombo {
unsafe { ::std::mem::transmute(&mut self.internal.combo) }
}
pub fn window(&self) -> &StyleWindow {
unsafe { ::std::mem::transmute(&self.internal.window) }
}
pub fn font(&self) -> &UserFont {
unsafe { ::std::mem::transmute(self.internal.font) }
}
pub fn cursors(&self) -> &CursorMap {
unsafe { ::std::mem::transmute(&self.internal.cursors) }
}
pub fn cursor_active(&self) -> &Cursor {
unsafe { ::std::mem::transmute(&self.internal.cursor_active) }
}
pub fn cursor_visible(&self) -> bool {
self.internal.cursor_visible > 0
}
pub fn text(&self) -> &StyleText {
&self.internal.text
}
pub fn button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.button) }
}
pub fn contextual_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.contextual_button) }
}
pub fn menu_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.menu_button) }
}
pub fn option(&self) -> &StyleToggle {
unsafe { ::std::mem::transmute(&self.internal.option) }
}
pub fn checkbox(&self) -> &StyleToggle {
unsafe { ::std::mem::transmute(&self.internal.checkbox) }
}
pub fn selectable(&self) -> &StyleSelectable {
unsafe { ::std::mem::transmute(&self.internal.selectable) }
}
pub fn slider(&self) -> &StyleSlider {
unsafe { ::std::mem::transmute(&self.internal.slider) }
}
pub fn progress(&self) -> &StyleProgress {
unsafe { ::std::mem::transmute(&self.internal.progress) }
}
pub fn property(&self) -> &StyleProperty {
unsafe { ::std::mem::transmute(&self.internal.property) }
}
pub fn edit(&self) -> &StyleEdit {
unsafe { ::std::mem::transmute(&self.internal.edit) }
}
pub fn chart(&self) -> &StyleChart {
unsafe { ::std::mem::transmute(&self.internal.chart) }
}
pub fn scroll_h(&self) -> &StyleScrollbar {
unsafe { ::std::mem::transmute(&self.internal.scrollh) }
}
pub fn scroll_v(&self) -> &StyleScrollbar {
unsafe { ::std::mem::transmute(&self.internal.scrollv) }
}
pub fn tab(&self) -> &StyleTab {
unsafe { ::std::mem::transmute(&self.internal.tab) }
}
pub fn combo(&self) -> &StyleCombo {
unsafe { ::std::mem::transmute(&self.internal.combo) }
}
}
wrapper_type!(StyleCombo, nk_style_combo);
impl StyleCombo {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn label_normal(&self) -> &Color {
&self.internal.label_normal
}
pub fn label_hover(&self) -> &Color {
&self.internal.label_hover
}
pub fn label_active(&self) -> &Color {
&self.internal.label_active
}
pub fn symbol_normal(&self) -> &Color {
&self.internal.symbol_normal
}
pub fn symbol_hover(&self) -> &Color {
&self.internal.symbol_hover
}
pub fn symbol_active(&self) -> &Color {
&self.internal.symbol_active
}
pub fn button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.button) }
}
pub fn sym_normal(&self) -> &SymbolType {
(&self.internal.sym_normal).into()
}
pub fn sym_hover(&self) -> &SymbolType {
(&self.internal.sym_hover).into()
}
pub fn sym_active(&self) -> &SymbolType {
(&self.internal.sym_active).into()
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn content_padding(&self) -> &Vec2 {
&self.internal.content_padding
}
pub fn button_padding(&self) -> &Vec2 {
&self.internal.button_padding
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_label_normal(&mut self, c: Color) {
self.internal.label_normal = c
}
pub fn set_label_hover(&mut self, c: Color) {
self.internal.label_hover = c
}
pub fn set_label_active(&mut self, c: Color) {
self.internal.label_active = c
}
pub fn set_symbol_normal(&mut self, c: Color) {
self.internal.symbol_normal = c
}
pub fn set_symbol_hover(&mut self, c: Color) {
self.internal.symbol_hover = c
}
pub fn set_symbol_active(&mut self, c: Color) {
self.internal.symbol_active = c
}
pub fn set_button(&mut self, s: StyleButton) {
self.internal.button = s.internal
}
pub fn set_sym_normal(&mut self, t: SymbolType) {
self.internal.sym_normal = t.into()
}
pub fn set_sym_hover(&mut self, t: SymbolType) {
self.internal.sym_hover = t.into()
}
pub fn set_sym_active(&mut self, t: SymbolType) {
self.internal.sym_active = t.into()
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_content_padding(&mut self, v: Vec2) {
self.internal.content_padding = v
}
pub fn set_button_padding(&mut self, v: Vec2) {
self.internal.button_padding = v
}
pub fn set_spacing(&mut self, v: Vec2) {
self.internal.spacing = v
}
}
wrapper_type!(StyleTab, nk_style_tab);
impl StyleTab {
pub fn background(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.background) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn text(&self) -> &Color {
&self.internal.text
}
pub fn tab_maximize_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.tab_maximize_button) }
}
pub fn tab_minimize_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.tab_minimize_button) }
}
pub fn node_maximize_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.node_maximize_button) }
}
pub fn node_minimize_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.node_minimize_button) }
}
pub fn sym_minimize(&self) -> &SymbolType {
(&self.internal.sym_minimize).into()
}
pub fn sym_maximize(&self) -> &SymbolType {
(&self.internal.sym_maximize).into()
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn indent(&self) -> f32 {
self.internal.indent
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn set_background(&mut self, i: StyleItem) {
self.internal.background = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_text(&mut self, c: Color) {
self.internal.text = c
}
pub fn set_tab_maximize_button(&mut self, s: StyleButton) {
self.internal.tab_maximize_button = s.internal
}
pub fn set_tab_minimize_button(&mut self, s: StyleButton) {
self.internal.tab_minimize_button = s.internal
}
pub fn set_node_maximize_button(&mut self, s: StyleButton) {
self.internal.node_maximize_button = s.internal
}
pub fn set_node_minimize_button(&mut self, s: StyleButton) {
self.internal.node_minimize_button = s.internal
}
pub fn set_sym_minimize(&mut self, t: SymbolType) {
self.internal.sym_minimize = t.into()
}
pub fn set_sym_maximize(&mut self, t: SymbolType) {
self.internal.sym_maximize = t.into()
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_indent(&mut self, v: f32) {
self.internal.indent = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_spacing(&mut self, v: Vec2) {
self.internal.spacing = v
}
}
wrapper_type!(StyleScrollbar, nk_style_scrollbar);
impl StyleScrollbar {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn cursor_normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_normal) }
}
pub fn cursor_hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_hover) }
}
pub fn cursor_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_active) }
}
pub fn cursor_border_color(&self) -> &Color {
&self.internal.cursor_border_color
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn border_cursor(&self) -> f32 {
self.internal.border_cursor
}
pub fn rounding_cursor(&self) -> f32 {
self.internal.rounding_cursor
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn show_buttons(&self) -> bool {
self.internal.show_buttons > 0
}
pub fn inc_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.inc_button) }
}
pub fn dec_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.dec_button) }
}
pub fn inc_symbol(&self) -> &SymbolType {
(&self.internal.inc_symbol).into()
}
pub fn dec_symbol(&self) -> &SymbolType {
(&self.internal.dec_symbol).into()
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_cursor_normal(&mut self, i: StyleItem) {
self.internal.cursor_normal = i.internal;
}
pub fn set_cursor_hover(&mut self, i: StyleItem) {
self.internal.cursor_hover = i.internal;
}
pub fn set_cursor_active(&mut self, i: StyleItem) {
self.internal.cursor_active = i.internal;
}
pub fn set_cursor_border_color(&mut self, c: Color) {
self.internal.cursor_border_color = c
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_border_cursor(&mut self, v: f32) {
self.internal.border_cursor = v
}
pub fn set_rounding_cursor(&mut self, v: f32) {
self.internal.rounding_cursor = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_show_buttons(&mut self, show: bool) {
self.internal.show_buttons = if show { 1 } else { 0 }
}
pub fn set_inc_button(&mut self, s: StyleButton) {
self.internal.inc_button = s.internal
}
pub fn set_dec_button(&mut self, s: StyleButton) {
self.internal.dec_button = s.internal
}
pub fn set_inc_symbol(&mut self, t: SymbolType) {
self.internal.inc_symbol = t.into()
}
pub fn set_dec_symbol(&mut self, t: SymbolType) {
self.internal.dec_symbol = t.into()
}
}
wrapper_type!(StyleChart, nk_style_chart);
impl StyleChart {
pub fn background(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.background) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn selected_color(&self) -> &Color {
&self.internal.selected_color
}
pub fn color(&self) -> &Color {
&self.internal.color
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn set_background(&mut self, i: StyleItem) {
self.internal.background = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_selected_color(&mut self, c: Color) {
self.internal.selected_color = c
}
pub fn set_color(&mut self, c: Color) {
self.internal.color = c
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
}
wrapper_type!(StyleEdit, nk_style_edit);
impl StyleEdit {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn scrollbar(&self) -> &StyleScrollbar {
unsafe { ::std::mem::transmute(&self.internal.scrollbar) }
}
pub fn cursor_normal(&self) -> &Color {
&self.internal.cursor_normal
}
pub fn cursor_hover(&self) -> &Color {
&self.internal.cursor_hover
}
pub fn cursor_text_normal(&self) -> &Color {
&self.internal.cursor_text_normal
}
pub fn cursor_text_hover(&self) -> &Color {
&self.internal.cursor_text_hover
}
pub fn text_normal(&self) -> &Color {
&self.internal.text_normal
}
pub fn text_hover(&self) -> &Color {
&self.internal.text_hover
}
pub fn text_active(&self) -> &Color {
&self.internal.text_active
}
pub fn selected_normal(&self) -> &Color {
&self.internal.selected_normal
}
pub fn selected_hover(&self) -> &Color {
&self.internal.selected_hover
}
pub fn selected_text_normal(&self) -> &Color {
&self.internal.selected_text_normal
}
pub fn selected_text_hover(&self) -> &Color {
&self.internal.selected_text_hover
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn cursor_size(&self) -> f32 {
self.internal.cursor_size
}
pub fn scrollbar_size(&self) -> &Vec2 {
&self.internal.scrollbar_size
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn row_padding(&self) -> f32 {
self.internal.row_padding
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_cursor_normal(&mut self, i: Color) {
self.internal.cursor_normal = i;
}
pub fn set_cursor_hover(&mut self, i: Color) {
self.internal.cursor_hover = i;
}
pub fn set_cursor_text_normal(&mut self, i: Color) {
self.internal.cursor_text_normal = i;
}
pub fn set_cursor_text_hover(&mut self, i: Color) {
self.internal.cursor_text_hover = i;
}
pub fn set_text_normal(&mut self, i: Color) {
self.internal.text_normal = i;
}
pub fn set_text_hover(&mut self, i: Color) {
self.internal.text_hover = i;
}
pub fn set_text_active(&mut self, i: Color) {
self.internal.text_active = i;
}
pub fn set_selected_normal(&mut self, i: Color) {
self.internal.selected_normal = i;
}
pub fn set_selected_hover(&mut self, i: Color) {
self.internal.selected_hover = i;
}
pub fn set_selected_text_normal(&mut self, i: Color) {
self.internal.selected_text_normal = i;
}
pub fn set_selected_text_hover(&mut self, i: Color) {
self.internal.selected_text_hover = i;
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_cursor_size(&mut self, v: f32) {
self.internal.cursor_size = v
}
pub fn set_scrollbar_size(&mut self, v: Vec2) {
self.internal.scrollbar_size = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_row_padding(&mut self, v: f32) {
self.internal.row_padding = v
}
}
wrapper_type!(StyleProperty, nk_style_property);
impl StyleProperty {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn label_normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.label_normal) }
}
pub fn label_hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.label_hover) }
}
pub fn label_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.label_active) }
}
pub fn sym_left(&self) -> &SymbolType {
(&self.internal.sym_left).into()
}
pub fn sym_right(&self) -> &SymbolType {
(&self.internal.sym_right).into()
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn edit(&self) -> &StyleEdit {
unsafe { ::std::mem::transmute(&self.internal.edit) }
}
pub fn inc_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.inc_button) }
}
pub fn dec_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.dec_button) }
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_label_normal(&mut self, c: Color) {
self.internal.label_normal = c
}
pub fn set_label_hover(&mut self, c: Color) {
self.internal.label_hover = c
}
pub fn set_label_active(&mut self, c: Color) {
self.internal.label_active = c
}
pub fn set_sym_left(&mut self, t: SymbolType) {
self.internal.sym_left = t.into()
}
pub fn set_sym_right(&mut self, t: SymbolType) {
self.internal.sym_right = t.into()
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_inc_button(&mut self, s: StyleButton) {
self.internal.inc_button = s.internal
}
pub fn set_dec_button(&mut self, s: StyleButton) {
self.internal.dec_button = s.internal
}
}
wrapper_type!(StyleProgress, nk_style_progress);
impl StyleProgress {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn cursor_normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_normal) }
}
pub fn cursor_hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_hover) }
}
pub fn cursor_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_active) }
}
pub fn cursor_border_color(&self) -> &Color {
&self.internal.cursor_border_color
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn cursor_border(&self) -> f32 {
self.internal.cursor_border
}
pub fn cursor_rounding(&self) -> f32 {
self.internal.cursor_rounding
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_cursor_normal(&mut self, i: StyleItem) {
self.internal.cursor_normal = i.internal;
}
pub fn set_cursor_hover(&mut self, i: StyleItem) {
self.internal.cursor_hover = i.internal;
}
pub fn set_cursor_active(&mut self, i: StyleItem) {
self.internal.cursor_active = i.internal;
}
pub fn set_cursor_border_color(&mut self, c: Color) {
self.internal.cursor_border_color = c
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_cursor_border(&mut self, v: f32) {
self.internal.cursor_border = v
}
pub fn set_cursor_rounding(&mut self, v: f32) {
self.internal.cursor_rounding = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
}
wrapper_type!(StyleSlider, nk_style_slider);
impl StyleSlider {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn bar_normal(&self) -> &Color {
&self.internal.bar_normal
}
pub fn bar_hover(&self) -> &Color {
&self.internal.bar_hover
}
pub fn bar_active(&self) -> &Color {
&self.internal.bar_active
}
pub fn bar_filled(&self) -> &Color {
&self.internal.bar_filled
}
pub fn cursor_normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_normal) }
}
pub fn cursor_hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_hover) }
}
pub fn cursor_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_active) }
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn bar_height(&self) -> f32 {
self.internal.bar_height
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn cursor_size(&self) -> &Vec2 {
&self.internal.cursor_size
}
pub fn show_buttons(&self) -> bool {
self.internal.show_buttons > 0
}
pub fn inc_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.inc_button) }
}
pub fn dec_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.dec_button) }
}
pub fn inc_symbol(&self) -> &SymbolType {
(&self.internal.inc_symbol).into()
}
pub fn dec_symbol(&self) -> &SymbolType {
(&self.internal.dec_symbol).into()
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_bar_normal(&mut self, c: Color) {
self.internal.bar_normal = c
}
pub fn set_bar_hover(&mut self, c: Color) {
self.internal.bar_hover = c
}
pub fn set_bar_active(&mut self, c: Color) {
self.internal.bar_active = c
}
pub fn set_bar_filled(&mut self, c: Color) {
self.internal.bar_filled = c
}
pub fn set_cursor_normal(&mut self, i: StyleItem) {
self.internal.cursor_normal = i.internal;
}
pub fn set_cursor_hover(&mut self, i: StyleItem) {
self.internal.cursor_hover = i.internal;
}
pub fn set_cursor_active(&mut self, i: StyleItem) {
self.internal.cursor_active = i.internal;
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_bar_height(&mut self, v: f32) {
self.internal.bar_height = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_spacing(&mut self, v: Vec2) {
self.internal.spacing = v
}
pub fn set_cursor_size(&mut self, v: Vec2) {
self.internal.cursor_size = v
}
pub fn set_show_buttons(&mut self, show: bool) {
self.internal.show_buttons = if show { 1 } else { 0 }
}
pub fn set_inc_button(&mut self, s: StyleButton) {
self.internal.inc_button = s.internal
}
pub fn set_dec_button(&mut self, s: StyleButton) {
self.internal.dec_button = s.internal
}
pub fn set_inc_symbol(&mut self, t: SymbolType) {
self.internal.inc_symbol = t.into()
}
pub fn set_dec_symbol(&mut self, t: SymbolType) {
self.internal.dec_symbol = t.into()
}
}
wrapper_type!(StyleSelectable, nk_style_selectable);
impl StyleSelectable {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn pressed(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.pressed) }
}
pub fn normal_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal_active) }
}
pub fn hover_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover_active) }
}
pub fn pressed_active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.pressed_active) }
}
pub fn text_normal(&self) -> &Color {
&self.internal.text_normal
}
pub fn text_hover(&self) -> &Color {
&self.internal.text_hover
}
pub fn text_pressed(&self) -> &Color {
&self.internal.text_pressed
}
pub fn text_normal_active(&self) -> &Color {
&self.internal.text_normal_active
}
pub fn text_hover_active(&self) -> &Color {
&self.internal.text_hover_active
}
pub fn text_pressed_active(&self) -> &Color {
&self.internal.text_pressed_active
}
pub fn text_background(&self) -> &Color {
&self.internal.text_background
}
pub fn text_alignment(&self) -> u32 {
self.internal.text_alignment
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn touch_padding(&self) -> &Vec2 {
&self.internal.touch_padding
}
pub fn image_padding(&self) -> &Vec2 {
&self.internal.image_padding
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_pressed(&mut self, i: StyleItem) {
self.internal.pressed = i.internal;
}
pub fn set_normal_active(&mut self, i: StyleItem) {
self.internal.normal_active = i.internal;
}
pub fn set_hover_active(&mut self, i: StyleItem) {
self.internal.hover_active = i.internal;
}
pub fn set_pressed_active(&mut self, i: StyleItem) {
self.internal.pressed_active = i.internal;
}
pub fn set_text_normal(&mut self, c: Color) {
self.internal.text_normal = c
}
pub fn set_text_hover(&mut self, c: Color) {
self.internal.text_hover = c
}
pub fn set_text_pressed(&mut self, c: Color) {
self.internal.text_pressed = c
}
pub fn set_text_normal_active(&mut self, c: Color) {
self.internal.text_normal_active = c
}
pub fn set_text_hover_active(&mut self, c: Color) {
self.internal.text_hover_active = c
}
pub fn set_text_pressed_active(&mut self, c: Color) {
self.internal.text_pressed_active = c
}
pub fn set_text_background(&mut self, c: Color) {
self.internal.text_background = c
}
pub fn set_text_alignment(&mut self, v: u32) {
self.internal.text_alignment = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_touch_padding(&mut self, v: Vec2) {
self.internal.touch_padding = v
}
pub fn set_image_padding(&mut self, v: Vec2) {
self.internal.image_padding = v
}
}
wrapper_type!(StyleButton, nk_style_button);
impl StyleButton {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn text_background(&self) -> &Color {
&self.internal.text_background
}
pub fn text_normal(&self) -> &Color {
&self.internal.text_normal
}
pub fn text_hover(&self) -> &Color {
&self.internal.text_hover
}
pub fn text_active(&self) -> &Color {
&self.internal.text_active
}
pub fn text_alignment(&self) -> u32 {
self.internal.text_alignment
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn touch_padding(&self) -> &Vec2 {
&self.internal.touch_padding
}
pub fn image_padding(&self) -> &Vec2 {
&self.internal.image_padding
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_text_background(&mut self, c: Color) {
self.internal.text_background = c
}
pub fn set_text_normal(&mut self, c: Color) {
self.internal.text_normal = c
}
pub fn set_text_hover(&mut self, c: Color) {
self.internal.text_hover = c
}
pub fn set_text_active(&mut self, c: Color) {
self.internal.text_active = c
}
pub fn set_text_alignment(&mut self, c: u32) {
self.internal.text_alignment = c
}
pub fn set_border(&mut self, c: f32) {
self.internal.border = c
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_touch_padding(&mut self, v: Vec2) {
self.internal.touch_padding = v
}
pub fn set_image_padding(&mut self, v: Vec2) {
self.internal.image_padding = v
}
}
wrapper_type!(StyleToggle, nk_style_toggle);
impl StyleToggle {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn cursor_normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_normal) }
}
pub fn cursor_hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.cursor_hover) }
}
pub fn text_normal(&self) -> &Color {
&self.internal.text_normal
}
pub fn text_hover(&self) -> &Color {
&self.internal.text_hover
}
pub fn text_active(&self) -> &Color {
&self.internal.text_active
}
pub fn text_background(&self) -> &Color {
&self.internal.text_background
}
pub fn text_alignment(&self) -> u32 {
self.internal.text_alignment
}
pub fn spacing(&self) -> f32 {
self.internal.spacing
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn touch_padding(&self) -> &Vec2 {
&self.internal.touch_padding
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_border_color(&mut self, c: Color) {
self.internal.border_color = c
}
pub fn set_cursor_normal(&mut self, i: StyleItem) {
self.internal.cursor_normal = i.internal;
}
pub fn set_cursor_hover(&mut self, i: StyleItem) {
self.internal.cursor_hover = i.internal;
}
pub fn set_text_background(&mut self, c: Color) {
self.internal.text_background = c
}
pub fn set_text_normal(&mut self, c: Color) {
self.internal.text_normal = c
}
pub fn set_text_hover(&mut self, c: Color) {
self.internal.text_hover = c
}
pub fn set_text_active(&mut self, c: Color) {
self.internal.text_active = c
}
pub fn set_text_alignment(&mut self, c: u32) {
self.internal.text_alignment = c
}
pub fn set_spacing(&mut self, v: f32) {
self.internal.spacing = v
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_touch_padding(&mut self, v: Vec2) {
self.internal.touch_padding = v
}
}
wrapper_type!(StyleWindowHeader, nk_style_window_header);
impl StyleWindowHeader {
pub fn normal(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.normal) }
}
pub fn hover(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.hover) }
}
pub fn active(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.active) }
}
pub fn close_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.close_button) }
}
pub fn minimize_button(&self) -> &StyleButton {
unsafe { ::std::mem::transmute(&self.internal.minimize_button) }
}
pub fn close_symbol(&self) -> &SymbolType {
(&self.internal.close_symbol).into()
}
pub fn minimize_symbol(&self) -> &SymbolType {
(&self.internal.minimize_symbol).into()
}
pub fn maximize_symbol(&self) -> &SymbolType {
(&self.internal.maximize_symbol).into()
}
pub fn label_normal(&self) -> &Color {
&self.internal.label_normal
}
pub fn label_hover(&self) -> &Color {
&self.internal.label_hover
}
pub fn label_active(&self) -> &Color {
&self.internal.label_active
}
pub fn align(&self) -> &StyleHeaderAlign {
&self.internal.align
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn label_padding(&self) -> &Vec2 {
&self.internal.label_padding
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn set_normal(&mut self, i: StyleItem) {
self.internal.normal = i.internal;
}
pub fn set_hover(&mut self, i: StyleItem) {
self.internal.hover = i.internal;
}
pub fn set_active(&mut self, i: StyleItem) {
self.internal.active = i.internal;
}
pub fn set_close_symbol(&mut self, t: SymbolType) {
self.internal.close_symbol = t.into()
}
pub fn set_minimize_symbol(&mut self, t: SymbolType) {
self.internal.minimize_symbol = t.into()
}
pub fn set_maximize_symbol(&mut self, t: SymbolType) {
self.internal.maximize_symbol = t.into()
}
pub fn set_label_normal(&mut self, c: Color) {
self.internal.label_normal = c
}
pub fn set_label_hover(&mut self, c: Color) {
self.internal.label_hover = c
}
pub fn set_label_active(&mut self, c: Color) {
self.internal.label_active = c
}
pub fn set_align(&mut self, c: StyleHeaderAlign) {
self.internal.align = c
}
pub fn set_padding(&mut self, v: Vec2) {
self.internal.padding = v
}
pub fn set_label_padding(&mut self, v: Vec2) {
self.internal.label_padding = v
}
pub fn set_spacing(&mut self, v: Vec2) {
self.internal.spacing = v
}
}
wrapper_type!(StyleWindow, nk_style_window);
impl StyleWindow {
pub fn header(&self) -> &StyleWindowHeader {
unsafe { ::std::mem::transmute(&self.internal.header) }
}
pub fn fixed_background(&self) -> StyleItem {
StyleItem {
internal: self.internal.fixed_background,
}
}
pub fn background(&self) -> &Color {
&self.internal.background
}
pub fn border_color(&self) -> &Color {
&self.internal.border_color
}
pub fn popup_border_color(&self) -> &Color {
&self.internal.popup_border_color
}
pub fn combo_border_color(&self) -> &Color {
&self.internal.combo_border_color
}
pub fn contextual_border_color(&self) -> &Color {
&self.internal.contextual_border_color
}
pub fn menu_border_color(&self) -> &Color {
&self.internal.menu_border_color
}
pub fn group_border_color(&self) -> &Color {
&self.internal.group_border_color
}
pub fn tooltip_border_color(&self) -> &Color {
&self.internal.tooltip_border_color
}
pub fn scaler(&self) -> &StyleItem {
unsafe { ::std::mem::transmute(&self.internal.scaler) }
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn combo_border(&self) -> f32 {
self.internal.combo_border
}
pub fn contextual_border(&self) -> f32 {
self.internal.contextual_border
}
pub fn menu_border(&self) -> f32 {
self.internal.menu_border
}
pub fn group_border(&self) -> f32 {
self.internal.group_border
}
pub fn tooltip_border(&self) -> f32 {
self.internal.tooltip_border
}
pub fn popup_border(&self) -> f32 {
self.internal.popup_border
}
pub fn rounding(&self) -> f32 {
self.internal.rounding
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn scrollbar_size(&self) -> &Vec2 {
&self.internal.scrollbar_size
}
pub fn min_size(&self) -> &Vec2 {
&self.internal.min_size
}
pub fn padding(&self) -> &Vec2 {
&self.internal.padding
}
pub fn group_padding(&self) -> &Vec2 {
&self.internal.group_padding
}
pub fn popup_padding(&self) -> &Vec2 {
&self.internal.popup_padding
}
pub fn combo_padding(&self) -> &Vec2 {
&self.internal.combo_padding
}
pub fn contextual_padding(&self) -> &Vec2 {
&self.internal.contextual_padding
}
pub fn menu_padding(&self) -> &Vec2 {
&self.internal.menu_padding
}
pub fn tooltip_padding(&self) -> &Vec2 {
&self.internal.tooltip_padding
}
pub fn set_fixed_background(&mut self, item: StyleItem) {
self.internal.fixed_background = item.internal;
}
pub fn set_background(&mut self, color: Color) {
self.internal.background = color;
}
pub fn set_border_color(&mut self, color: Color) {
self.internal.border_color = color;
}
pub fn set_popup_border_color(&mut self, color: Color) {
self.internal.popup_border_color = color;
}
pub fn set_combo_border_color(&mut self, color: Color) {
self.internal.combo_border_color = color;
}
pub fn set_contextual_border_color(&mut self, color: Color) {
self.internal.contextual_border_color = color;
}
pub fn set_menu_border_color(&mut self, color: Color) {
self.internal.menu_border_color = color;
}
pub fn set_group_border_color(&mut self, color: Color) {
self.internal.group_border_color = color;
}
pub fn set_tooltip_border_color(&mut self, color: Color) {
self.internal.tooltip_border_color = color;
}
pub fn set_scaler(&mut self, i: StyleItem) {
self.internal.scaler = i.internal;
}
pub fn set_combo_border(&mut self, v: f32) {
self.internal.combo_border = v
}
pub fn set_border(&mut self, v: f32) {
self.internal.border = v
}
pub fn set_contextual_border(&mut self, v: f32) {
self.internal.contextual_border = v
}
pub fn set_menu_border(&mut self, v: f32) {
self.internal.menu_border = v
}
pub fn set_group_border(&mut self, v: f32) {
self.internal.group_border = v
}
pub fn set_tooltip_border(&mut self, v: f32) {
self.internal.tooltip_border = v
}
pub fn set_popup_border(&mut self, v: f32) {
self.internal.popup_border = v
}
pub fn set_rounding(&mut self, v: f32) {
self.internal.rounding = v
}
pub fn set_spacing(&mut self, spacing: Vec2) {
self.internal.spacing = spacing;
}
pub fn set_scrollbar_size(&mut self, s: Vec2) {
self.internal.scrollbar_size = s;
}
pub fn set_min_size(&mut self, s: Vec2) {
self.internal.min_size = s;
}
pub fn set_padding(&mut self, padding: Vec2) {
self.internal.padding = padding;
}
pub fn set_group_padding(&mut self, padding: Vec2) {
self.internal.group_padding = padding;
}
pub fn set_popup_padding(&mut self, padding: Vec2) {
self.internal.popup_padding = padding;
}
pub fn set_combo_padding(&mut self, padding: Vec2) {
self.internal.combo_padding = padding;
}
pub fn set_contextual_padding(&mut self, padding: Vec2) {
self.internal.contextual_padding = padding;
}
pub fn set_menu_padding(&mut self, padding: Vec2) {
self.internal.menu_padding = padding;
}
pub fn set_tooltip_padding(&mut self, padding: Vec2) {
self.internal.tooltip_padding = padding;
}
}
wrapper_type!(DrawList, nk_draw_list);
impl DrawList {
pub fn init(&mut self) {
unsafe {
nk_draw_list_init(&mut self.internal);
}
}
pub fn setup(
&mut self,
config: &ConvertConfig,
cmds: &mut Buffer,
vertices: &mut Buffer,
elements: &mut Buffer,
line_aa: AntiAliasing,
shape_aa: AntiAliasing,
) {
unsafe {
nk_draw_list_setup(
&mut self.internal,
&config.internal as *const nk_convert_config,
&mut cmds.internal as *mut nk_buffer,
&mut vertices.internal as *mut nk_buffer,
&mut elements.internal as *mut nk_buffer,
line_aa.into(),
shape_aa.into(),
)
}
}
pub fn begin(&self, buf: &Buffer) -> &DrawCommand {
unsafe { ::std::mem::transmute(nk__draw_list_begin(&self.internal, &buf.internal)) }
}
pub fn next(&self, buf: &Buffer, prev: &DrawCommand) -> &DrawCommand {
unsafe {
::std::mem::transmute(nk__draw_list_next(
&prev.internal,
&buf.internal,
&self.internal,
))
}
}
pub fn path_clear(&mut self) {
unsafe {
nk_draw_list_path_clear(&mut self.internal);
}
}
pub fn path_line_to(&mut self, pos: Vec2) {
unsafe {
nk_draw_list_path_line_to(&mut self.internal, pos);
}
}
pub fn path_arc_to_fast(&mut self, center: Vec2, radius: f32, a_min: i32, a_max: i32) {
unsafe {
nk_draw_list_path_arc_to_fast(&mut self.internal, center, radius, a_min, a_max);
}
}
pub fn path_arc_to(
&mut self,
center: Vec2,
radius: f32,
a_min: f32,
a_max: f32,
segments: u32,
) {
unsafe {
nk_draw_list_path_arc_to(&mut self.internal, center, radius, a_min, a_max, segments);
}
}
pub fn path_rect_to(&mut self, a: Vec2, b: Vec2, rounding: f32) {
unsafe {
nk_draw_list_path_rect_to(&mut self.internal, a, b, rounding);
}
}
pub fn path_curve_to(&mut self, p2: Vec2, p3: Vec2, p4: Vec2, num_segments: u32) {
unsafe { nk_draw_list_path_curve_to(&mut self.internal, p2, p3, p4, num_segments) }
}
pub fn path_fill(&mut self, col: Color) {
unsafe {
nk_draw_list_path_fill(&mut self.internal, col);
}
}
pub fn path_stroke(&mut self, arg2: Color, closed: DrawListStroke, thickness: f32) {
unsafe {
nk_draw_list_path_stroke(&mut self.internal, arg2, closed, thickness);
}
}
pub fn stroke_line(&mut self, a: Vec2, b: Vec2, arg2: Color, thickness: f32) {
unsafe {
nk_draw_list_stroke_line(&mut self.internal, a, b, arg2, thickness);
}
}
pub fn stroke_rect(&mut self, rect: Rect, arg2: Color, rounding: f32, thickness: f32) {
unsafe {
nk_draw_list_stroke_rect(&mut self.internal, rect, arg2, rounding, thickness);
}
}
pub fn stroke_triangle(&mut self, a: Vec2, b: Vec2, c: Vec2, arg2: Color, thickness: f32) {
unsafe {
nk_draw_list_stroke_triangle(&mut self.internal, a, b, c, arg2, thickness);
}
}
pub fn stroke_circle(
&mut self,
center: Vec2,
radius: f32,
arg2: Color,
segs: u32,
thickness: f32,
) {
unsafe {
nk_draw_list_stroke_circle(&mut self.internal, center, radius, arg2, segs, thickness);
}
}
pub fn stroke_curve(
&mut self,
p0: Vec2,
cp0: Vec2,
cp1: Vec2,
p1: Vec2,
arg2: Color,
segments: u32,
thickness: f32,
) {
unsafe {
nk_draw_list_stroke_curve(
&mut self.internal,
p0,
cp0,
cp1,
p1,
arg2,
segments,
thickness,
);
}
}
pub fn stroke_poly_line(
&mut self,
points: &[Vec2],
arg2: Color,
arg3: DrawListStroke,
thickness: f32,
aa: AntiAliasing,
) {
unsafe {
nk_draw_list_stroke_poly_line(
&mut self.internal,
points.as_ptr(),
points.len() as u32,
arg2,
arg3,
thickness,
aa.into(),
);
}
}
pub fn fill_rect(&mut self, rect: Rect, arg2: Color, rounding: f32) {
unsafe {
nk_draw_list_fill_rect(&mut self.internal, rect, arg2, rounding);
}
}
pub fn fill_rect_multi_color(
&mut self,
rect: Rect,
left: Color,
top: Color,
right: Color,
bottom: Color,
) {
unsafe {
nk_draw_list_fill_rect_multi_color(&mut self.internal, rect, left, top, right, bottom);
}
}
pub fn fill_triangle(&mut self, a: Vec2, b: Vec2, c: Vec2, arg2: Color) {
unsafe {
nk_draw_list_fill_triangle(&mut self.internal, a, b, c, arg2);
}
}
pub fn fill_circle(&mut self, center: Vec2, radius: f32, col: Color, segs: u32) {
unsafe {
nk_draw_list_fill_circle(&mut self.internal, center, radius, col, segs);
}
}
pub fn fill_poly_convex(&mut self, points: &[Vec2], arg2: Color, arg3: AntiAliasing) {
unsafe {
nk_draw_list_fill_poly_convex(
&mut self.internal,
points.as_ptr(),
points.len() as u32,
arg2,
arg3.into(),
);
}
}
pub fn add_image(&mut self, texture: Image, rect: Rect, arg2: Color) {
unsafe {
nk_draw_list_add_image(&mut self.internal, texture.internal, rect, arg2);
}
}
pub fn add_text(
&mut self,
arg2: &UserFont,
arg3: Rect,
text: String,
font_height: f32,
arg4: Color,
) {
unsafe {
nk_draw_list_add_text(
&mut self.internal,
&arg2.internal,
arg3,
text.as_ptr(),
text.bytes.len() as i32,
font_height,
arg4,
);
}
}
}
#[derive(Clone, Copy)]
pub struct ColorMap {
internal: [nk_color; 28],
}
impl Default for ColorMap {
fn default() -> Self {
ColorMap {
internal: [nk_color::default(); 28],
}
}
}
impl From<[Color; 28usize]> for ColorMap {
fn from(value: [Color; 28usize]) -> ColorMap {
ColorMap { internal: value }
}
}
impl ColorMap {
pub fn set(&mut self, target: StyleColor, color: Color) {
self.internal[target as usize] = color;
}
}
pub struct CursorMap<'a> {
internal: [Option<&'a Cursor>; 7],
}
impl<'a> Default for CursorMap<'a> {
fn default() -> Self {
unsafe {
let mut map = CursorMap {
internal: [::std::mem::zeroed(); 7],
};
for i in &mut map.internal {
::std::ptr::write(i, None);
}
map
}
}
}
impl<'a> CursorMap<'a> {
pub fn set(&mut self, target: StyleCursor, res: Option<&'a Cursor>) {
self.internal[target as usize] = res;
}
}
wrapper_type!(Cursor, nk_cursor);
impl Cursor {
pub fn img(&self) -> &Image {
unsafe { ::std::mem::transmute(&self.internal.img) }
}
pub fn size(&self) -> &Vec2 {
&self.internal.size
}
pub fn offset(&self) -> &Vec2 {
&self.internal.offset
}
}
wrapper_type!(Allocator, nk_allocator);
impl Debug for Allocator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", &self.internal)
}
}
impl Allocator {
pub fn new_heap() -> Allocator {
let mut a = Allocator::default();
a.internal.alloc = Some(alloc_heap::alloc);
a.internal.free = Some(alloc_heap::free);
a.internal.userdata = nk_handle::default();
a.internal.userdata.ptr = ::std::ptr::null_mut();
a
}
pub fn new_vec() -> Allocator {
let mut a = Allocator::default();
a.internal.alloc = Some(alloc_vec::alloc);
a.internal.free = Some(alloc_vec::free);
a.internal.userdata = nk_handle::default();
a.internal.userdata.ptr = ::std::ptr::null_mut();
a
}
}
wrapper_type!(ConvertConfig, nk_convert_config);
impl Debug for ConvertConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", &self.internal)
}
}
impl ConvertConfig {
pub fn set_global_alpha(&mut self, val: f32) {
self.internal.global_alpha = val;
}
pub fn set_line_aa(&mut self, val: AntiAliasing) {
self.internal.line_AA = val.into();
}
pub fn set_shape_aa(&mut self, val: AntiAliasing) {
self.internal.shape_AA = val.into();
}
pub fn set_circle_segment_count(&mut self, val: u32) {
self.internal.circle_segment_count = val;
}
pub fn set_arc_segment_count(&mut self, val: u32) {
self.internal.arc_segment_count = val;
}
pub fn set_curve_segment_count(&mut self, val: u32) {
self.internal.curve_segment_count = val;
}
pub fn set_null(&mut self, val: DrawNullTexture) {
self.internal.null = val.internal;
}
pub fn set_vertex_layout(&mut self, val: &DrawVertexLayoutElements) {
self.internal.vertex_layout = &val.arr.as_slice()[0];
}
pub fn set_vertex_size(&mut self, val: Size) {
self.internal.vertex_size = val;
}
}
#[derive(Debug, Default, Clone)]
pub struct DrawVertexLayoutElements {
arr: Vec<nk_draw_vertex_layout_element>,
}
impl DrawVertexLayoutElements {
pub fn new(
var: &[(DrawVertexLayoutAttribute, DrawVertexLayoutFormat, Size)],
) -> DrawVertexLayoutElements {
DrawVertexLayoutElements {
arr: var
.iter()
.map(|&(a, f, o)| nk_draw_vertex_layout_element {
attribute: a.into(),
format: f.into(),
offset: o,
})
.collect::<Vec<_>>(),
}
}
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum StyleItemType {
Image = nk_style_item_type_NK_STYLE_ITEM_IMAGE as isize,
Color = nk_style_item_type_NK_STYLE_ITEM_COLOR as isize,
}
from_into_enum!(StyleItemType, nk_style_item_type);
wrapper_type!(StyleItem, nk_style_item);
impl TryFrom<StyleItem> for Image {
type Error = &'static str;
fn try_from(value: StyleItem) -> Result<Self, Self::Error> {
unsafe {
if value.internal.type_ == StyleItemType::Image as u32 {
Ok(value.internal.data.image.into())
} else {
Err("Typeof(StyleItem) != StyleItemType::Image")
}
}
}
}
impl TryFrom<StyleItem> for Color {
type Error = &'static str;
fn try_from(value: StyleItem) -> Result<Self, Self::Error> {
unsafe {
if value.internal.type_ == StyleItemType::Color as u32 {
Ok(value.internal.data.color)
} else {
Err("Typeof(StyleItem) != StyleItemType::Color")
}
}
}
}
impl StyleItem {
pub fn image(img: Image) -> StyleItem {
unsafe {
StyleItem {
internal: nk_style_item_image(img.internal),
}
}
}
pub fn color(col: Color) -> StyleItem {
unsafe {
StyleItem {
internal: nk_style_item_color(col),
}
}
}
#[inline]
pub fn color_rgb(r: i32, g: i32, b: i32) -> Self {
Self::color(color_rgb(r, g, b))
}
#[inline]
pub fn color_rgb_f(r: f32, g: f32, b: f32) -> Self {
Self::color(color_rgb_f(r, g, b))
}
#[inline]
pub fn color_rgb_bv(bv: &u8) -> Self {
Self::color(color_rgb_bv(bv))
}
#[inline]
pub fn color_rgba(r: i32, g: i32, b: i32, a: i32) -> Self {
Self::color(color_rgba(r, g, b, a))
}
#[inline]
pub fn color_rgba_f(r: f32, g: f32, b: f32, a: f32) -> Self {
Self::color(color_rgba_f(r, g, b, a))
}
#[inline]
pub fn color_rgba_bv(bv: &u8) -> Self {
Self::color(color_rgba_bv(bv))
}
#[inline]
pub fn color_hsv(h: i32, s: i32, v: i32) -> Self {
Self::color(color_hsv(h, s, v))
}
#[inline]
pub fn color_hsv_f(h: f32, s: f32, v: f32) -> Self {
Self::color(color_hsv_f(h, s, v))
}
#[inline]
pub fn color_hsv_bv(bv: &u8) -> Self {
Self::color(color_hsv_bv(bv))
}
#[inline]
pub fn color_hsva(h: i32, s: i32, v: i32, a: i32) -> Self {
Self::color(color_hsva(h, s, v, a))
}
#[inline]
pub fn color_hsva_f(h: f32, s: f32, v: f32, a: f32) -> Self {
Self::color(color_hsva_f(h, s, v, a))
}
#[inline]
pub fn color_hsva_bv(bv: &u8) -> Self {
Self::color(color_hsva_bv(bv))
}
pub fn hide() -> StyleItem {
unsafe {
StyleItem {
internal: nk_style_item_hide(),
}
}
}
}
wrapper_type_no_clone!(TextEdit, nk_text_edit);
impl Drop for TextEdit {
fn drop(&mut self) {
unsafe {
nk_textedit_free(&mut self.internal);
}
}
}
impl TextEdit {
pub fn init(&mut self, arg2: &mut Allocator, size: Size) {
unsafe {
nk_textedit_init(
&mut self.internal,
&mut arg2.internal as *mut nk_allocator,
size,
);
}
}
pub fn text(&mut self, arg2: &str) {
unsafe {
nk_textedit_text(
&mut self.internal,
arg2.as_ptr() as *const ::std::os::raw::c_char,
arg2.as_bytes().len() as ::std::os::raw::c_int,
);
}
}
pub fn delete(&mut self, where_: u32, len: u32) {
unsafe {
nk_textedit_delete(
&mut self.internal,
where_ as ::std::os::raw::c_int,
len as ::std::os::raw::c_int,
);
}
}
pub fn delete_selection(&mut self) {
unsafe {
nk_textedit_delete_selection(&mut self.internal);
}
}
pub fn select_all(&mut self) {
unsafe {
nk_textedit_select_all(&mut self.internal);
}
}
pub fn cut(&mut self) -> bool {
unsafe { nk_textedit_cut(&mut self.internal) != 0 }
}
pub fn paste(&mut self, arg2: &str) -> bool {
unsafe {
nk_textedit_paste(
&mut self.internal,
arg2.as_ptr() as *const ::std::os::raw::c_char,
arg2.as_bytes().len() as ::std::os::raw::c_int,
) != 0
}
}
pub fn undo(&mut self) {
unsafe {
nk_textedit_undo(&mut self.internal);
}
}
pub fn redo(&mut self) {
unsafe {
nk_textedit_redo(&mut self.internal);
}
}
}
wrapper_type!(FontConfig, nk_font_config);
impl FontConfig {
pub fn with_size(pixel_height: f32) -> FontConfig {
unsafe {
FontConfig {
internal: nk_font_config(pixel_height),
}
}
}
pub fn is_ttf_data_owned_by_atlas(&self) -> bool {
self.internal.ttf_data_owned_by_atlas > 0
}
pub fn size(&self) -> f32 {
self.internal.size
}
pub fn oversample_v(&self) -> u8 {
self.internal.oversample_v
}
pub fn oversample_h(&self) -> u8 {
self.internal.oversample_h
}
pub fn glyph_range(&self) -> Option<&[(u32, u32)]> {
if self.internal.range.is_null() {
None
} else {
Some(raw_glyph_ranges_to_safe(self.internal.range))
}
}
pub fn padding(&self) -> [u8; 3] {
self.internal.padding
}
pub fn fallback_glyph(&self) -> char {
unsafe { ::std::char::from_u32_unchecked(self.internal.fallback_glyph) }
}
pub fn spacing(&self) -> &Vec2 {
&self.internal.spacing
}
pub fn coord_type(&self) -> &FontCoordType {
&self.internal.coord_type
}
pub fn is_pixel_snap(&self) -> bool {
self.internal.pixel_snap > 0
}
pub fn is_merge_mode(&self) -> bool {
self.internal.merge_mode > 0
}
pub fn set_ttf_data_owned_by_atlas(&mut self, yes: bool) {
self.internal.ttf_data_owned_by_atlas = if yes { 1 } else { 0 };
}
pub fn set_size(&mut self, size: f32) {
self.internal.size = size;
}
pub fn set_oversample_v(&mut self, v: u8) {
self.internal.oversample_v = v;
}
pub fn set_oversample_h(&mut self, h: u8) {
self.internal.oversample_h = h;
}
pub fn set_glyph_range<'a>(&'a mut self, ranges: &'a [(u32, u32)]) {
self.internal.range = ranges as *const _ as *const u32;
}
pub fn set_ttf<'a>(&'a mut self, font_bytes: &'a [u8]) {
self.internal.ttf_size = font_bytes.len() as Size;
self.internal.ttf_blob = font_bytes as *const _ as *mut c_void;
}
pub fn set_padding(&mut self, p: [u8; 3]) {
self.internal.padding = p;
}
pub fn set_fallback_glyph(&mut self, g: char) {
self.internal.fallback_glyph = g as u32;
}
pub fn set_spacing(&mut self, s: Vec2) {
self.internal.spacing = s;
}
pub fn set_coord_type(&mut self, t: FontCoordType) {
self.internal.coord_type = t;
}
pub fn set_pixel_snap(&mut self, s: bool) {
self.internal.pixel_snap = if s { 1 } else { 0 };
}
pub fn set_merge_mode(&mut self, m: bool) {
self.internal.merge_mode = if m { 1 } else { 0 };
}
}
wrapper_type!(FontAtlas, nk_font_atlas);
pub type FontID = usize;
impl Drop for FontAtlas {
fn drop(&mut self) {
self.clear();
}
}
impl FontAtlas {
pub fn new(alloc: &Allocator) -> FontAtlas {
let mut a = FontAtlas::default();
a.init(alloc);
a
}
pub fn add_font_with_config(&mut self, cfg: &FontConfig) -> Option<FontID> {
unsafe {
if self.internal.font_num < 1 {
nk_font_atlas_begin(&mut self.internal as *mut nk_font_atlas);
}
let current = self.internal.font_num;
let ret = nk_font_atlas_add(
&mut self.internal as *mut nk_font_atlas,
&cfg.internal as *const nk_font_config,
);
if !ret.is_null() && (self.internal.font_num - current) == 1 {
Some(current as FontID)
} else {
None
}
}
}
pub fn add_font_with_bytes(&mut self, font_bytes: &[u8], font_size: f32) -> Option<FontID> {
let mut cfg = FontConfig::with_size(font_size);
cfg.internal.ttf_size = font_bytes.len() as Size;
cfg.internal.ttf_blob = font_bytes as *const _ as *mut c_void;
cfg.internal.size = font_size;
cfg.internal.ttf_data_owned_by_atlas = 0;
self.add_font_with_config(&cfg)
}
pub fn add_font_with_file<P: AsRef<Path>>(
&mut self,
path: P,
font_size: f32,
) -> Option<FontID> {
let mut f = File::open(path).unwrap();
let mut buffer = Vec::new();
f.read_to_end(&mut buffer).unwrap();
self.add_font_with_bytes(&buffer, font_size)
}
pub fn bake(&mut self, format: FontAtlasFormat) -> (&[u8], u32, u32) {
let mut width: i32 = 0;
let mut height: i32 = 0;
let image = unsafe {
nk_font_atlas_bake(
&mut self.internal as *mut nk_font_atlas,
&mut width as *mut c_int,
&mut height as *mut c_int,
format.into(),
)
};
if width < 1 || height < 1 {
return (&[], width as u32, height as u32);
}
let size = (match format {
FontAtlasFormat::Alpha8 => 1,
FontAtlasFormat::Rgba32 => 4,
FontAtlasFormat::Argb32 => 4,
} * width
* height) as usize;
(
unsafe { ::std::slice::from_raw_parts(image as *const u8, size) },
width as u32,
height as u32,
)
}
pub fn end(&mut self, hnd: Handle, null_texture: Option<&mut DrawNullTexture>) {
let nullt = match null_texture {
Some(n) => &mut n.internal as *mut nk_draw_null_texture,
None => ::std::ptr::null_mut(),
};
unsafe {
nk_font_atlas_end(
&mut self.internal as *mut nk_font_atlas,
hnd.internal,
nullt,
);
}
}
pub fn cleanup(&mut self) {
unsafe {
nk_font_atlas_cleanup(&mut self.internal as *mut nk_font_atlas);
}
}
fn clear(&mut self) {
unsafe {
nk_font_atlas_clear(&mut self.internal as *mut nk_font_atlas);
}
}
fn init(&mut self, alloc: &Allocator) {
unsafe {
nk_font_atlas_init(
&mut self.internal as *mut nk_font_atlas,
&alloc.internal as *const nk_allocator as *mut nk_allocator,
);
}
}
#[allow(dead_code)]
fn init_custom(&mut self, persistent: &Allocator, transient: &Allocator) {
unsafe {
nk_font_atlas_init_custom(
&mut self.internal as *mut nk_font_atlas,
&persistent.internal as *const nk_allocator as *mut nk_allocator,
&transient.internal as *const nk_allocator as *mut nk_allocator,
);
}
}
pub fn begin(&mut self) {
unsafe {
nk_font_atlas_begin(&mut self.internal as *mut nk_font_atlas);
}
}
pub fn pixels(&self) -> &[u8] {
unsafe {
::std::slice::from_raw_parts(
self.internal.pixel as *const _ as *const u8,
(self.internal.tex_width * self.internal.tex_height * 4) as usize,
)
}
}
pub fn tex_width(&self) -> u16 {
self.internal.tex_width as u16
}
pub fn tex_height(&self) -> u16 {
self.internal.tex_height as u16
}
pub fn custom(&self) -> Recti {
self.internal.custom
}
pub fn cursors(&self) -> &[Cursor] {
unsafe {
::std::slice::from_raw_parts(
self.internal.cursors.as_ptr() as *const Cursor,
self.internal.cursors.len(),
)
}
}
pub fn glyphs(&self) -> &[FontGlyph] {
unsafe {
::std::slice::from_raw_parts(
self.internal.glyphs as *const _ as *const FontGlyph,
self.internal.glyph_count as usize,
)
}
}
pub fn fonts_iterator(&self) -> FontIterator {
FontIterator { ctx: self }
}
pub fn font(&self, id: FontID) -> Option<&Font> {
let id = self.internal.font_num as usize - id - 1;
self.fonts_iterator().into_iter().nth(id)
}
}
pub struct FontIterator<'a> {
ctx: &'a FontAtlas,
}
impl<'a> IntoIterator for FontIterator<'a> {
type Item = &'a Font;
type IntoIter = FontIntoIter<'a>;
fn into_iter(self) -> Self::IntoIter {
let font = if self.ctx.internal.fonts.is_null() {
None
} else {
Some(unsafe { ::std::mem::transmute(self.ctx.internal.fonts) })
};
FontIntoIter { font }
}
}
pub struct FontIntoIter<'a> {
font: Option<&'a Font>,
}
impl<'a> Iterator for FontIntoIter<'a> {
type Item = &'a Font;
fn next(&mut self) -> Option<&'a Font> {
let r = self.font;
self.font = if let Some(p) = self.font {
if p.internal.next.is_null() {
None
} else {
Some(unsafe { ::std::mem::transmute(p.internal.next) })
}
} else {
None
};
r
}
}
wrapper_type!(DrawNullTexture, nk_draw_null_texture);
impl Debug for DrawNullTexture {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", &self.internal)
}
}
const DEFAULT_BUFFER_SIZE: usize = 8096;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BufferAllocationType {
Front,
Back,
Max,
}
impl Into<u32> for BufferAllocationType {
fn into(self) -> u32 {
match self {
BufferAllocationType::Front => 0,
BufferAllocationType::Back => 1,
BufferAllocationType::Max => 2,
}
}
}
wrapper_type!(Buffer, nk_buffer);
impl Drop for Buffer {
fn drop(&mut self) {
unsafe {
nk_buffer_free(&mut self.internal);
}
}
}
impl Debug for Buffer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", &self.internal)
}
}
impl Buffer {
pub fn new(alloc: &Allocator) -> Buffer {
Buffer::with_size(alloc, DEFAULT_BUFFER_SIZE)
}
pub fn with_size(alloc: &Allocator, buffer_size: usize) -> Buffer {
let mut a = Buffer::default();
unsafe {
nk_buffer_init(
&mut a.internal as *mut nk_buffer,
&alloc.internal as *const nk_allocator,
buffer_size as Size,
);
}
a
}
pub fn with_fixed(memory: &mut [u8]) -> Buffer {
let mut a = Buffer::default();
unsafe {
nk_buffer_init_fixed(
&mut a.internal as *mut nk_buffer,
memory as *mut _ as *mut ::std::os::raw::c_void,
memory.len() as Size,
);
}
a
}
pub fn total(&self) -> usize {
unsafe { nk_buffer_total(&self.internal as *const nk_buffer as *mut nk_buffer) as usize }
}
pub fn info(&self) -> (usize, usize, usize, usize) {
let mut s = nk_memory_status::default();
unsafe {
nk_buffer_info(&mut s, &self.internal as *const nk_buffer as *mut nk_buffer);
}
(
s.size as usize,
s.allocated as usize,
s.needed as usize,
s.calls as usize,
)
}
pub fn memory(&mut self) -> *mut c_void {
unsafe { nk_buffer_memory(&mut self.internal as *mut nk_buffer) }
}
pub fn memory_const(&self) -> *const c_void {
unsafe { nk_buffer_memory_const(&self.internal as *const nk_buffer) }
}
pub fn mark(&mut self, type_: BufferAllocationType) {
unsafe { nk_buffer_mark(&mut self.internal as *mut nk_buffer, type_.into()) }
}
pub fn reset(&mut self, type_: BufferAllocationType) {
unsafe { nk_buffer_reset(&mut self.internal as *mut nk_buffer, type_.into()) }
}
pub fn clear(&mut self) {
unsafe { nk_buffer_clear(&mut self.internal as *mut nk_buffer) }
}
pub fn as_bytes(&self) -> &[u8] {
let (_, len, _, _) = self.info();
unsafe { std::slice::from_raw_parts::<u8>(self.memory_const() as *const u8, len) }
}
}
pub struct Context {
internal: nk_context,
}
impl Debug for Context {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Context {{}}")
}
}
impl Default for Context {
fn default() -> Self {
Context {
internal: nk_context::default(),
}
}
}
impl Drop for Context {
fn drop(&mut self) {
unsafe {
nk_free(&mut self.internal as *mut nk_context);
}
}
}
impl Context {
pub fn new(alloc: &Allocator, font: &UserFont) -> Context {
let mut a = Context::default();
unsafe {
nk_init(
&mut a.internal as *mut nk_context,
&alloc.internal as *const nk_allocator as *mut nk_allocator,
&font.internal,
);
}
a
}
pub fn clip_mut(&mut self) -> &mut Clipboard {
unsafe { ::std::mem::transmute(&mut self.internal.clip) }
}
pub fn clip(&self) -> &Clipboard {
unsafe { ::std::mem::transmute(&self.internal.clip) }
}
pub fn last_widget_state(&self) -> Flags {
self.internal.last_widget_state
}
pub fn delta_time_seconds(&self) -> f32 {
self.internal.delta_time_seconds
}
pub fn button_behavior(&self) -> ButtonBehavior {
self.internal.button_behavior.into()
}
pub fn set_button_behavior(&mut self, bb: ButtonBehavior) {
self.internal.button_behavior = bb.into()
}
pub fn input_mut(&mut self) -> &mut Input {
unsafe { ::std::mem::transmute(&mut self.internal.input) }
}
pub fn style_mut(&mut self) -> &mut Style {
unsafe { ::std::mem::transmute(&mut self.internal.style) }
}
pub fn draw_list_mut(&mut self) -> &mut DrawList {
unsafe { ::std::mem::transmute(&mut self.internal.draw_list) }
}
pub fn input(&self) -> &Input {
unsafe { ::std::mem::transmute(&self.internal.input) }
}
pub fn style(&self) -> &Style {
unsafe { ::std::mem::transmute(&self.internal.style) }
}
pub fn draw_list(&self) -> &DrawList {
unsafe { ::std::mem::transmute(&self.internal.draw_list) }
}
pub fn clear(&mut self) {
unsafe {
nk_clear(&mut self.internal as *mut nk_context);
}
}
pub fn begin(&mut self, title: String, bounds: Rect, flags: Flags) -> bool {
unsafe {
nk_begin(
&mut self.internal as *mut nk_context,
title.as_ptr(),
bounds,
flags,
) != 0
}
}
pub fn begin_titled(&mut self, name: String, title: String, bounds: Rect, flags: Flags) -> i32 {
unsafe {
nk_begin_titled(
&mut self.internal as *mut nk_context,
name.as_ptr(),
title.as_ptr(),
bounds,
flags,
)
}
}
pub fn end(&mut self) {
unsafe {
nk_end(&mut self.internal as *mut nk_context);
}
}
pub fn window_find<S: AsRef<str>>(&self, name: S) -> Option<&Window> {
let w = unsafe {
nk_window_find(
&self.internal as *const _ as *mut nk_context,
name.as_ref().as_ptr() as *const ::std::os::raw::c_char,
)
};
unsafe {
if w.is_null() {
None
} else {
Some(::std::mem::transmute(w))
}
}
}
pub fn window_find_mut(&mut self, name: String) -> Option<&mut Window> {
let w = unsafe { nk_window_find(&mut self.internal as *mut nk_context, name.as_ptr()) };
unsafe {
if w.is_null() {
None
} else {
Some(::std::mem::transmute(w))
}
}
}
pub fn window_get_bounds(&self) -> Rect {
unsafe { nk_window_get_bounds(&self.internal as *const nk_context) }
}
pub fn window_get_size(&self) -> Vec2 {
unsafe { nk_window_get_size(&self.internal as *const nk_context) }
}
pub fn window_get_position(&self) -> Vec2 {
unsafe { nk_window_get_position(&self.internal as *const nk_context) }
}
pub fn window_get_width(&self) -> f32 {
unsafe { nk_window_get_width(&self.internal as *const nk_context) }
}
pub fn window_get_height(&self) -> f32 {
unsafe { nk_window_get_height(&self.internal as *const nk_context) }
}
pub fn window_get_panel_mut(&mut self) -> Option<&mut Panel> {
let p = unsafe { nk_window_get_panel(&mut self.internal as *mut nk_context) };
unsafe {
if p.is_null() {
None
} else {
Some(::std::mem::transmute(p))
}
}
}
pub fn window_get_panel(&self) -> Option<&Panel> {
let p = unsafe { nk_window_get_panel(&self.internal as *const _ as *mut nk_context) };
unsafe {
if p.is_null() {
None
} else {
Some(::std::mem::transmute(p))
}
}
}
pub fn window_get_content_region(&self) -> Rect {
unsafe { nk_window_get_content_region(&self.internal as *const _ as *mut nk_context) }
}
pub fn window_get_content_region_min(&self) -> Vec2 {
unsafe { nk_window_get_content_region_min(&self.internal as *const _ as *mut nk_context) }
}
pub fn window_get_content_region_max(&self) -> Vec2 {
unsafe { nk_window_get_content_region_max(&self.internal as *const _ as *mut nk_context) }
}
pub fn window_get_content_region_size(&self) -> Vec2 {
unsafe { nk_window_get_content_region_size(&self.internal as *const _ as *mut nk_context) }
}
pub fn window_get_canvas_mut(&mut self) -> Option<&mut CommandBuffer> {
let b = unsafe { nk_window_get_canvas(&mut self.internal as *mut nk_context) };
unsafe {
if b.is_null() {
None
} else {
Some(::std::mem::transmute(b))
}
}
}
pub fn window_get_canvas(&self) -> Option<&CommandBuffer> {
let b = unsafe { nk_window_get_canvas(&self.internal as *const _ as *mut nk_context) };
unsafe {
if b.is_null() {
None
} else {
Some(::std::mem::transmute(b))
}
}
}
pub fn window_get_scroll(&self) -> (u32, u32) {
let mut x: u32 = 0;
let mut y: u32 = 0;
unsafe { nk_window_get_scroll(&self.internal, &mut x, &mut y) }
(x, y)
}
pub fn window_has_focus(&self) -> bool {
unsafe { nk_window_has_focus(&self.internal as *const nk_context) > 0 }
}
pub fn window_is_collapsed(&self, name: String) -> bool {
unsafe {
nk_window_is_collapsed(&self.internal as *const _ as *mut nk_context, name.as_ptr()) > 0
}
}
pub fn window_is_closed(&self, name: String) -> bool {
unsafe {
nk_window_is_closed(&self.internal as *const _ as *mut nk_context, name.as_ptr()) > 0
}
}
pub fn window_is_hidden(&self, name: String) -> bool {
unsafe {
nk_window_is_hidden(&self.internal as *const _ as *mut nk_context, name.as_ptr()) > 0
}
}
pub fn window_is_active(&self, name: String) -> bool {
unsafe {
nk_window_is_active(&self.internal as *const _ as *mut nk_context, name.as_ptr()) > 0
}
}
pub fn window_is_hovered(&self) -> bool {
unsafe { nk_window_is_hovered(&self.internal as *const _ as *mut nk_context) > 0 }
}
pub fn window_is_any_hovered(&self) -> bool {
unsafe { nk_window_is_any_hovered(&self.internal as *const _ as *mut nk_context) > 0 }
}
pub fn item_is_any_active(&self) -> bool {
unsafe { nk_item_is_any_active(&self.internal as *const _ as *mut nk_context) > 0 }
}
pub fn window_set_bounds<S: AsRef<str>>(&mut self, name: S, bounds: Rect) {
unsafe {
nk_window_set_bounds(
&mut self.internal as *mut nk_context,
name.as_ref().as_ptr() as *const ::std::os::raw::c_char,
bounds,
);
}
}
pub fn window_set_position<S: AsRef<str>>(&mut self, name: S, pos: Vec2) {
unsafe {
nk_window_set_position(
&mut self.internal as *mut nk_context,
name.as_ref().as_ptr() as *const ::std::os::raw::c_char,
pos,
);
}
}
pub fn window_set_size<S: AsRef<str>>(&mut self, name: S, size: Vec2) {
unsafe {
nk_window_set_size(
&mut self.internal as *mut nk_context,
name.as_ref().as_ptr() as *const ::std::os::raw::c_char,
size,
);
}
}
pub fn window_set_focus(&mut self, name: String) {
unsafe {
nk_window_set_focus(&mut self.internal as *mut nk_context, name.as_ptr());
}
}
pub fn window_set_scroll(&mut self, x: u32, y: u32) {
unsafe {
nk_window_set_scroll(&mut self.internal as *mut nk_context, x, y);
}
}
pub fn window_close(&mut self, name: String) {
unsafe {
nk_window_close(&mut self.internal as *mut nk_context, name.as_ptr());
}
}
pub fn window_collapse(&mut self, name: String, state: CollapseState) {
unsafe {
nk_window_collapse(
&mut self.internal as *mut nk_context,
name.as_ptr(),
state.into(),
);
}
}
pub fn window_collapse_if(&mut self, name: String, state: CollapseState, cond: bool) {
unsafe {
nk_window_collapse_if(
&mut self.internal as *mut nk_context,
name.as_ptr(),
state.into(),
if cond { 1 } else { 0 },
);
}
}
pub fn window_show(&mut self, name: String, state: ShowState) {
unsafe {
nk_window_show(
&mut self.internal as *mut nk_context,
name.as_ptr(),
state.into(),
);
}
}
pub fn window_show_if(&mut self, name: String, state: ShowState, cond: bool) {
unsafe {
nk_window_show_if(
&mut self.internal as *mut nk_context,
name.as_ptr(),
state.into(),
if cond { 1 } else { 0 },
);
}
}
pub fn layout_row_dynamic(&mut self, height: f32, cols: i32) {
unsafe {
nk_layout_row_dynamic(&mut self.internal as *mut nk_context, height, cols);
}
}
pub fn layout_row_static(&mut self, height: f32, item_width: i32, cols: i32) {
unsafe {
nk_layout_row_static(
&mut self.internal as *mut nk_context,
height,
item_width,
cols,
);
}
}
pub fn layout_row_begin(&mut self, fmt: LayoutFormat, row_height: f32, cols: i32) {
unsafe {
nk_layout_row_begin(
&mut self.internal as *mut nk_context,
fmt.into(),
row_height,
cols,
);
}
}
pub fn layout_row_push(&mut self, value: f32) {
unsafe {
nk_layout_row_push(&mut self.internal as *mut nk_context, value);
}
}
pub fn layout_row_end(&mut self) {
unsafe {
nk_layout_row_end(&mut self.internal as *mut nk_context);
}
}
pub fn layout_row(&mut self, fmt: LayoutFormat, height: f32, cols_ratio: &[f32]) {
unsafe {
nk_layout_row(
&mut self.internal as *mut nk_context,
fmt.into(),
height,
cols_ratio.len() as i32,
cols_ratio.as_ptr(),
);
}
}
pub fn layout_row_colored(
&mut self,
fmt: LayoutFormat,
height: f32,
cols_ratio: &[f32],
color: Color,
) {
unsafe {
nk_layout_row_colored(
&mut self.internal as *mut nk_context,
fmt.into(),
height,
cols_ratio.len() as i32,
cols_ratio.as_ptr(),
color,
);
}
}
pub fn layout_space_begin(&mut self, fmt: LayoutFormat, height: f32, widget_count: i32) {
unsafe {
nk_layout_space_begin(
&mut self.internal as *mut nk_context,
fmt.into(),
height,
widget_count,
);
}
}
pub fn layout_space_colored_begin(
&mut self,
fmt: LayoutFormat,
height: f32,
widget_count: i32,
color: Color,
) {
unsafe {
nk_layout_space_colored_begin(
&mut self.internal as *mut nk_context,
fmt.into(),
height,
widget_count,
color,
);
}
}
pub fn layout_space_push(&mut self, space: Rect) {
unsafe {
nk_layout_space_push(&mut self.internal as *mut nk_context, space);
}
}
pub fn layout_space_end(&mut self) {
unsafe {
nk_layout_space_end(&mut self.internal as *mut nk_context);
}
}
pub fn layout_space_bounds(&mut self) -> Rect {
unsafe { nk_layout_space_bounds(&mut self.internal as *mut nk_context) }
}
pub fn layout_space_to_screen(&mut self, space: Vec2) -> Vec2 {
unsafe { nk_layout_space_to_screen(&mut self.internal as *mut nk_context, space) }
}
pub fn layout_space_to_local(&mut self, space: Vec2) -> Vec2 {
unsafe { nk_layout_space_to_local(&mut self.internal as *mut nk_context, space) }
}
pub fn layout_space_rect_to_screen(&mut self, space: Rect) -> Rect {
unsafe { nk_layout_space_rect_to_screen(&mut self.internal as *mut nk_context, space) }
}
pub fn layout_space_rect_to_local(&mut self, space: Rect) -> Rect {
unsafe { nk_layout_space_rect_to_local(&mut self.internal as *mut nk_context, space) }
}
pub fn layout_ratio_from_pixel(&mut self, pixel_width: f32) -> f32 {
unsafe { nk_layout_ratio_from_pixel(&mut self.internal as *mut nk_context, pixel_width) }
}
pub fn group_begin(&mut self, title: String, flags: Flags) -> i32 {
unsafe { nk_group_begin(&mut self.internal as *mut nk_context, title.as_ptr(), flags) }
}
pub fn group_end(&mut self) {
unsafe {
nk_group_end(&mut self.internal as *mut nk_context);
}
}
pub fn tree_push_hashed(
&mut self,
ty: TreeType,
title: String,
initial_state: CollapseState,
hash: String,
len: i32,
seed: i32,
) -> i32 {
unsafe {
nk_tree_push_hashed(
&mut self.internal as *mut nk_context,
ty.into(),
title.as_ptr(),
initial_state.into(),
hash.as_ptr(),
len,
seed,
)
}
}
pub fn tree_image_push_hashed(
&mut self,
ty: TreeType,
i: Image,
title: String,
initial_state: CollapseState,
hash: String,
len: i32,
seed: i32,
) -> i32 {
unsafe {
nk_tree_image_push_hashed(
&mut self.internal as *mut nk_context,
ty.into(),
i.internal,
title.as_ptr(),
initial_state.into(),
hash.as_ptr(),
len,
seed,
)
}
}
pub fn tree_pop(&mut self) {
unsafe {
nk_tree_pop(&mut self.internal as *mut nk_context);
}
}
pub fn text(&mut self, text: &str, flags: Flags) {
unsafe {
nk_text(
&mut self.internal as *mut nk_context,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
flags,
);
}
}
pub fn text_colored(&mut self, text: &str, flags: Flags, color: Color) {
unsafe {
nk_text_colored(
&mut self.internal as *mut nk_context,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
flags,
color,
);
}
}
pub fn text_wrap(&mut self, text: &str) {
unsafe {
nk_text_wrap(
&mut self.internal as *mut nk_context,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
);
}
}
pub fn text_wrap_colored(&mut self, text: &str, color: Color) {
unsafe {
nk_text_wrap_colored(
&mut self.internal as *mut nk_context,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
color,
);
}
}
pub fn label(&mut self, text: String, flags: Flags) {
unsafe {
nk_label(&mut self.internal as *mut nk_context, text.as_ptr(), flags);
}
}
pub fn label_colored(&mut self, text: String, flags: Flags, color: Color) {
unsafe {
nk_label_colored(
&mut self.internal as *mut nk_context,
text.as_ptr(),
flags,
color,
);
}
}
pub fn label_wrap(&mut self, text: String) {
unsafe {
nk_label_wrap(&mut self.internal as *mut nk_context, text.as_ptr());
}
}
pub fn label_colored_wrap(&mut self, text: String, color: Color) {
unsafe {
nk_label_colored_wrap(&mut self.internal as *mut nk_context, text.as_ptr(), color);
}
}
pub fn image(&mut self, img: Image) {
unsafe {
nk_image(&mut self.internal as *mut nk_context, img.internal);
}
}
pub fn button_text(&mut self, text: &str) -> bool {
unsafe {
nk_button_text(
&mut self.internal as *mut nk_context,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
) != 0
}
}
pub fn button_label(&mut self, title: String) -> bool {
unsafe { nk_button_label(&mut self.internal as *mut nk_context, title.as_ptr()) != 0 }
}
pub fn button_color(&mut self, color: Color) -> bool {
unsafe { nk_button_color(&mut self.internal as *mut nk_context, color) != 0 }
}
pub fn button_symbol(&mut self, ty: SymbolType) -> bool {
unsafe { nk_button_symbol(&mut self.internal as *mut nk_context, ty.into()) != 0 }
}
pub fn button_image(&mut self, img: Image) -> bool {
unsafe { nk_button_image(&mut self.internal as *mut nk_context, img.internal) != 0 }
}
pub fn button_symbol_label(
&mut self,
ty: SymbolType,
title: String,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_symbol_label(
&mut self.internal as *mut nk_context,
ty.into(),
title.as_ptr(),
text_alignment,
) != 0
}
}
pub fn button_symbol_text(
&mut self,
ty: SymbolType,
title: &str,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_symbol_text(
&mut self.internal as *mut nk_context,
ty.into(),
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
text_alignment,
) != 0
}
}
pub fn button_image_label(&mut self, img: Image, title: String, text_alignment: Flags) -> bool {
unsafe {
nk_button_image_label(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr(),
text_alignment,
) != 0
}
}
pub fn button_image_text(&mut self, img: Image, title: &str, text_alignment: Flags) -> bool {
unsafe {
nk_button_image_text(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
text_alignment,
) != 0
}
}
pub fn button_text_styled(&mut self, style: &StyleButton, text: &str) -> bool {
unsafe {
nk_button_text_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as i32,
) != 0
}
}
pub fn button_label_styled(&mut self, style: &StyleButton, title: String) -> bool {
unsafe {
nk_button_label_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
title.as_ptr(),
) != 0
}
}
pub fn button_symbol_styled(&mut self, style: &StyleButton, ty: SymbolType) -> bool {
unsafe {
nk_button_symbol_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
ty.into(),
) != 0
}
}
pub fn button_image_styled(&mut self, style: &StyleButton, img: Image) -> bool {
unsafe {
nk_button_image_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
img.internal,
) != 0
}
}
pub fn button_symbol_text_styled(
&mut self,
style: &StyleButton,
ty: SymbolType,
title: &str,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_symbol_text_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
ty.into(),
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
text_alignment,
) != 0
}
}
pub fn button_symbol_label_styled(
&mut self,
style: &StyleButton,
ty: SymbolType,
title: String,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_symbol_label_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
ty.into(),
title.as_ptr(),
text_alignment,
) != 0
}
}
pub fn button_image_label_styled(
&mut self,
style: &StyleButton,
img: Image,
title: String,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_image_label_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
img.internal,
title.as_ptr(),
text_alignment,
) != 0
}
}
pub fn button_image_text_styled(
&mut self,
style: &StyleButton,
img: Image,
title: &str,
text_alignment: Flags,
) -> bool {
unsafe {
nk_button_image_text_styled(
&mut self.internal as *mut nk_context,
&style.internal as *const nk_style_button,
img.internal,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
text_alignment,
) != 0
}
}
pub fn button_set_behavior(&mut self, b: ButtonBehavior) {
unsafe {
nk_button_set_behavior(&mut self.internal as *mut nk_context, b.into());
}
}
pub fn button_push_behavior(&mut self, b: ButtonBehavior) -> i32 {
unsafe { nk_button_push_behavior(&mut self.internal as *mut nk_context, b.into()) }
}
pub fn button_pop_behavior(&mut self) -> i32 {
unsafe { nk_button_pop_behavior(&mut self.internal as *mut nk_context) }
}
pub fn check_label(&mut self, title: String, active: bool) -> i32 {
unsafe {
nk_check_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
if active { 1 } else { 0 },
)
}
}
pub fn check_text(&mut self, title: &str, active: bool) -> i32 {
unsafe {
nk_check_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
if active { 1 } else { 0 },
)
}
}
pub fn check_flags_label(&mut self, title: String, flags: u32, value: u32) -> u32 {
unsafe {
nk_check_flags_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
flags,
value,
)
}
}
pub fn check_flags_text(&mut self, title: &str, flags: u32, value: u32) -> u32 {
unsafe {
nk_check_flags_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
flags,
value,
)
}
}
pub fn checkbox_label(&mut self, title: String, active: &mut bool) -> bool {
let mut i = if *active { 1 } else { 0 };
let r = unsafe {
nk_checkbox_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
&mut i as *mut i32,
) != 0
};
*active = i != 0;
r
}
pub fn checkbox_text(&mut self, title: &str, active: &mut bool) -> bool {
let mut i = if *active { 1 } else { 0 };
let r = unsafe {
nk_checkbox_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
&mut i as *mut i32,
) != 0
};
*active = i != 0;
r
}
pub fn checkbox_flags_label(&mut self, title: String, flags: &mut u32, value: u32) -> bool {
unsafe {
nk_checkbox_flags_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
flags,
value,
) != 0
}
}
pub fn checkbox_flags_text(&mut self, title: &str, flags: &mut u32, value: u32) -> bool {
unsafe {
nk_checkbox_flags_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
flags,
value,
) != 0
}
}
pub fn radio_label(&mut self, title: String, active: &mut bool) -> bool {
let mut i = if *active { 1 } else { 0 };
let r = unsafe {
nk_radio_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
&mut i as *mut i32,
) != 0
};
*active = i != 0;
r
}
pub fn radio_text(&mut self, title: &str, active: &mut bool) -> bool {
let mut i = if *active { 1 } else { 0 };
let r = unsafe {
nk_radio_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
&mut i as *mut i32,
) != 0
};
*active = i != 0;
r
}
pub fn option_label(&mut self, title: String, active: bool) -> bool {
unsafe {
nk_option_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
if active { 1 } else { 0 },
) > 0
}
}
pub fn option_text(&mut self, title: &str, active: bool) -> bool {
unsafe {
nk_option_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
if active { 1 } else { 0 },
) > 0
}
}
pub fn selectable_label(&mut self, title: String, align: Flags, value: &mut i32) -> bool {
unsafe {
nk_selectable_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
align,
value,
) != 0
}
}
pub fn selectable_text(&mut self, title: &str, align: Flags, value: &mut i32) -> bool {
unsafe {
nk_selectable_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
align,
value,
) != 0
}
}
pub fn selectable_image_label(
&mut self,
img: Image,
title: String,
align: Flags,
value: &mut i32,
) -> bool {
unsafe {
nk_selectable_image_label(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr(),
align,
value,
) != 0
}
}
pub fn selectable_image_text(
&mut self,
img: Image,
title: &str,
align: Flags,
value: &mut i32,
) -> bool {
unsafe {
nk_selectable_image_text(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
align,
value,
) != 0
}
}
pub fn select_label(&mut self, title: String, align: Flags, value: i32) -> i32 {
unsafe {
nk_select_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
align,
value,
)
}
}
pub fn select_text(&mut self, title: &str, align: Flags, value: i32) -> i32 {
unsafe {
nk_select_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
align,
value,
)
}
}
pub fn select_image_label(
&mut self,
img: Image,
title: String,
align: Flags,
value: i32,
) -> i32 {
unsafe {
nk_select_image_label(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr(),
align,
value,
)
}
}
pub fn select_image_text(&mut self, img: Image, title: &str, align: Flags, value: i32) -> i32 {
unsafe {
nk_select_image_text(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr() as *const ::std::os::raw::c_char,
title.as_bytes().len() as i32,
align,
value,
)
}
}
pub fn slide_float(&mut self, min: f32, val: f32, max: f32, step: f32) -> f32 {
unsafe { nk_slide_float(&mut self.internal as *mut nk_context, min, val, max, step) }
}
pub fn slide_int(&mut self, min: i32, val: i32, max: i32, step: i32) -> i32 {
unsafe { nk_slide_int(&mut self.internal as *mut nk_context, min, val, max, step) }
}
pub fn slider_float(&mut self, min: f32, val: &mut f32, max: f32, step: f32) -> bool {
unsafe { nk_slider_float(&mut self.internal as *mut nk_context, min, val, max, step) != 0 }
}
pub fn slider_int(&mut self, min: i32, val: &mut i32, max: i32, step: i32) -> bool {
unsafe { nk_slider_int(&mut self.internal as *mut nk_context, min, val, max, step) != 0 }
}
pub fn progress(&mut self, cur: &mut Size, max: Size, is_modifyable: bool) -> bool {
unsafe {
nk_progress(
&mut self.internal as *mut nk_context,
cur,
max,
if is_modifyable { 1 } else { 0 },
) != 0
}
}
pub fn prog(&mut self, cur: Size, max: Size, is_modifyable: bool) -> usize {
unsafe {
nk_prog(
&mut self.internal as *mut nk_context,
cur,
max,
if is_modifyable { 1 } else { 0 },
) as usize
}
}
pub fn color_picker(&mut self, color: ColorF, fmt: ColorFormat) -> ColorF {
unsafe { nk_color_picker(&mut self.internal as *mut nk_context, color, fmt.into()) }
}
pub fn color_pick(&mut self, fmt: ColorFormat) -> (bool, ColorF) {
let mut c = ColorF::default();
let changed = unsafe {
nk_color_pick(
&mut self.internal as *mut nk_context,
&mut c as *mut nk_colorf,
fmt.into(),
)
};
(changed != 0, c)
}
pub fn property_int(
&mut self,
name: String,
min: i32,
val: &mut i32,
max: i32,
step: i32,
inc_per_pixel: f32,
) {
unsafe {
nk_property_int(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
);
}
}
pub fn property_float(
&mut self,
name: String,
min: f32,
val: &mut f32,
max: f32,
step: f32,
inc_per_pixel: f32,
) {
unsafe {
nk_property_float(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
)
}
}
pub fn property_double(
&mut self,
name: String,
min: f64,
val: &mut f64,
max: f64,
step: f64,
inc_per_pixel: f32,
) {
unsafe {
nk_property_double(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
)
}
}
pub fn propertyi(
&mut self,
name: String,
min: i32,
val: i32,
max: i32,
step: i32,
inc_per_pixel: f32,
) -> i32 {
unsafe {
nk_propertyi(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
)
}
}
pub fn propertyf(
&mut self,
name: String,
min: f32,
val: f32,
max: f32,
step: f32,
inc_per_pixel: f32,
) -> f32 {
unsafe {
nk_propertyf(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
)
}
}
pub fn propertyd(
&mut self,
name: String,
min: f64,
val: f64,
max: f64,
step: f64,
inc_per_pixel: f32,
) -> f64 {
unsafe {
nk_propertyd(
&mut self.internal as *mut nk_context,
name.as_ptr(),
min,
val,
max,
step,
inc_per_pixel,
)
}
}
pub fn edit_string_custom_filter(
&mut self,
flags: Flags,
buffer: &mut [u8],
len: &mut i32,
filter: fn(&TextEdit, char) -> bool,
) -> Flags {
unsafe {
CUSTOM_EDIT_FILTER = Some(filter);
nk_edit_string(
&mut self.internal as *mut nk_context,
flags,
&mut buffer[0] as *mut _ as *mut ::std::os::raw::c_char,
len,
buffer.len() as i32,
Some(nk_filter_custom),
)
}
}
pub fn edit_string(
&mut self,
flags: Flags,
buffer: &mut [u8],
len: &mut i32,
filter: PluginFilter,
) -> Flags {
unsafe {
nk_edit_string(
&mut self.internal as *mut nk_context,
flags,
&mut buffer[0] as *mut _ as *mut ::std::os::raw::c_char,
len,
buffer.len() as i32,
filter,
)
}
}
pub fn edit_buffer(
&mut self,
flags: Flags,
editor: &mut TextEdit,
filter: PluginFilter,
) -> Flags {
unsafe {
nk_edit_buffer(
&mut self.internal as *mut nk_context,
flags,
&mut editor.internal,
filter,
)
}
}
pub fn chart_begin(&mut self, ty: ChartType, num: i32, min: f32, max: f32) -> bool {
unsafe {
nk_chart_begin(
&mut self.internal as *mut nk_context,
ty.into(),
num,
min,
max,
) > 0
}
}
pub fn chart_begin_colored(
&mut self,
ty: ChartType,
color: Color,
active: Color,
num: i32,
min: f32,
max: f32,
) -> bool {
unsafe {
nk_chart_begin_colored(
&mut self.internal as *mut nk_context,
ty.into(),
color,
active,
num,
min,
max,
) > 0
}
}
pub fn chart_add_slot(&mut self, ty: ChartType, count: i32, min_value: f32, max_value: f32) {
unsafe {
nk_chart_add_slot(
&mut self.internal as *mut nk_context,
ty.into(),
count,
min_value,
max_value,
);
}
}
pub fn chart_add_slot_colored(
&mut self,
ty: ChartType,
color: Color,
active: Color,
count: i32,
min_value: f32,
max_value: f32,
) {
unsafe {
nk_chart_add_slot_colored(
&mut self.internal as *mut nk_context,
ty.into(),
color,
active,
count,
min_value,
max_value,
);
}
}
pub fn chart_push(&mut self, value: f32) -> Flags {
unsafe { nk_chart_push(&mut self.internal as *mut nk_context, value) }
}
pub fn chart_push_slot(&mut self, value: f32, count: i32) -> Flags {
unsafe { nk_chart_push_slot(&mut self.internal as *mut nk_context, value, count) }
}
pub fn chart_end(&mut self) {
unsafe {
nk_chart_end(&mut self.internal as *mut nk_context);
}
}
pub fn plot(&mut self, ty: ChartType, values: &[f32]) {
unsafe {
nk_plot(
&mut self.internal as *mut nk_context,
ty.into(),
values.as_ptr(),
values.len() as i32,
0,
);
}
}
pub fn popup_begin(
&mut self,
ty: PopupType,
title: String,
flags: Flags,
bounds: Rect,
) -> bool {
unsafe {
nk_popup_begin(
&mut self.internal as *mut nk_context,
ty.into(),
title.as_ptr(),
flags,
bounds,
) > 0
}
}
pub fn popup_close(&mut self) {
unsafe {
nk_popup_close(&mut self.internal as *mut nk_context);
}
}
pub fn popup_end(&mut self) {
unsafe {
nk_popup_end(&mut self.internal as *mut nk_context);
}
}
pub fn popup_get_scroll(&mut self, offset_x: &mut nk_uint, offset_y: &mut nk_uint) {
unsafe {
nk_popup_get_scroll(&mut self.internal as *mut nk_context, offset_x, offset_y);
}
}
pub fn popup_set_scroll(&mut self, offset_x: nk_uint, offset_y: nk_uint) {
unsafe {
nk_popup_set_scroll(&mut self.internal as *mut nk_context, offset_x, offset_y);
}
}
pub fn combo(
&mut self,
items: &mut StringArray,
selected: i32,
item_height: i32,
size: Vec2,
) -> i32 {
unsafe {
nk_combo(
&mut self.internal as *mut nk_context,
items.as_mut(),
items.len() as i32,
selected,
item_height,
size,
)
}
}
pub fn combo_separator(
&mut self,
items_separated_by_separator: String,
separator: char,
selected: i32,
item_height: i32,
size: Vec2,
) -> i32 {
let len =
::std::string::String::from_utf8_lossy(items_separated_by_separator.bytes.as_ref())
.as_ref()
.split(separator)
.count();
unsafe {
nk_combo_separator(
&mut self.internal as *mut nk_context,
items_separated_by_separator.as_ptr(),
separator as i32,
selected,
len as i32,
item_height,
size,
)
}
}
pub fn combo_begin_label(&mut self, selected: String, size: Vec2) -> bool {
unsafe {
nk_combo_begin_label(
&mut self.internal as *mut nk_context,
selected.as_ptr(),
size,
) > 0
}
}
pub fn combo_begin_text(&mut self, selected: &str, size: Vec2) -> bool {
unsafe {
nk_combo_begin_text(
&mut self.internal as *mut nk_context,
selected.as_ptr() as *const ::std::os::raw::c_char,
selected.as_bytes().len() as i32,
size,
) > 0
}
}
pub fn combo_begin_color(&mut self, color: Color, size: Vec2) -> bool {
unsafe { nk_combo_begin_color(&mut self.internal as *mut nk_context, color, size) > 0 }
}
pub fn combo_begin_symbol(&mut self, sym: SymbolType, size: Vec2) -> bool {
unsafe {
nk_combo_begin_symbol(&mut self.internal as *mut nk_context, sym.into(), size) > 0
}
}
pub fn combo_begin_symbol_label(&mut self, label: String, sym: SymbolType, size: Vec2) -> bool {
unsafe {
nk_combo_begin_symbol_label(
&mut self.internal as *mut nk_context,
label.as_ptr(),
sym.into(),
size,
) > 0
}
}
pub fn combo_begin_symbol_text(&mut self, label: &str, sym: SymbolType, size: Vec2) -> bool {
unsafe {
nk_combo_begin_symbol_text(
&mut self.internal as *mut nk_context,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
sym.into(),
size,
) > 0
}
}
pub fn combo_begin_image(&mut self, img: Image, size: Vec2) -> bool {
unsafe {
nk_combo_begin_image(&mut self.internal as *mut nk_context, img.internal, size) > 0
}
}
pub fn combo_begin_image_label(&mut self, label: String, img: Image, size: Vec2) -> bool {
unsafe {
nk_combo_begin_image_label(
&mut self.internal as *mut nk_context,
label.as_ptr(),
img.internal,
size,
) > 0
}
}
pub fn combo_begin_image_text(&mut self, label: &str, img: Image, size: Vec2) -> bool {
unsafe {
nk_combo_begin_image_text(
&mut self.internal as *mut nk_context,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
img.internal,
size,
) > 0
}
}
pub fn combo_item_label(&mut self, label: String, alignment: Flags) -> bool {
unsafe {
nk_combo_item_label(
&mut self.internal as *mut nk_context,
label.as_ptr(),
alignment,
) > 0
}
}
pub fn combo_item_text(&mut self, label: &str, alignment: Flags) -> bool {
unsafe {
nk_combo_item_text(
&mut self.internal as *mut nk_context,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
alignment,
) > 0
}
}
pub fn combo_item_image_label(&mut self, img: Image, label: String, alignment: Flags) -> bool {
unsafe {
nk_combo_item_image_label(
&mut self.internal as *mut nk_context,
img.internal,
label.as_ptr(),
alignment,
) > 0
}
}
pub fn combo_item_image_text(&mut self, img: Image, label: &str, alignment: Flags) -> bool {
unsafe {
nk_combo_item_image_text(
&mut self.internal as *mut nk_context,
img.internal,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
alignment,
) > 0
}
}
pub fn combo_item_symbol_label(
&mut self,
sym: SymbolType,
label: String,
alignment: Flags,
) -> bool {
unsafe {
nk_combo_item_symbol_label(
&mut self.internal as *mut nk_context,
sym.into(),
label.as_ptr(),
alignment,
) > 0
}
}
pub fn combo_item_symbol_text(
&mut self,
sym: SymbolType,
label: &str,
alignment: Flags,
) -> bool {
unsafe {
nk_combo_item_symbol_text(
&mut self.internal as *mut nk_context,
sym.into(),
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
alignment,
) > 0
}
}
pub fn combo_close(&mut self) {
unsafe {
nk_combo_close(&mut self.internal as *mut nk_context);
}
}
pub fn combo_end(&mut self) {
unsafe {
nk_combo_end(&mut self.internal as *mut nk_context);
}
}
pub fn contextual_begin(&mut self, flags: Flags, bounds: Vec2, trigger_bounds: Rect) -> bool {
unsafe {
nk_contextual_begin(
&mut self.internal as *mut nk_context,
flags,
bounds,
trigger_bounds,
) > 0
}
}
pub fn contextual_item_label(&mut self, label: String, align: Flags) -> bool {
unsafe {
nk_contextual_item_label(&mut self.internal as *mut nk_context, label.as_ptr(), align)
> 0
}
}
pub fn contextual_item_text(&mut self, label: &str, align: Flags) -> bool {
unsafe {
nk_contextual_item_text(
&mut self.internal as *mut nk_context,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
align,
) > 0
}
}
pub fn contextual_item_image_label(&mut self, img: Image, label: String, align: Flags) -> bool {
unsafe {
nk_contextual_item_image_label(
&mut self.internal as *mut nk_context,
img.internal,
label.as_ptr(),
align,
) > 0
}
}
pub fn contextual_item_image_text(&mut self, img: Image, label: &str, align: Flags) -> bool {
unsafe {
nk_contextual_item_image_text(
&mut self.internal as *mut nk_context,
img.internal,
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
align,
) > 0
}
}
pub fn contextual_item_symbol_label(
&mut self,
sym: SymbolType,
label: String,
align: Flags,
) -> bool {
unsafe {
nk_contextual_item_symbol_label(
&mut self.internal as *mut nk_context,
sym.into(),
label.as_ptr(),
align,
) > 0
}
}
pub fn contextual_item_symbol_text(
&mut self,
sym: SymbolType,
label: &str,
align: Flags,
) -> bool {
unsafe {
nk_contextual_item_symbol_text(
&mut self.internal as *mut nk_context,
sym.into(),
label.as_ptr() as *const ::std::os::raw::c_char,
label.as_bytes().len() as i32,
align,
) > 0
}
}
pub fn contextual_close(&mut self) {
unsafe {
nk_contextual_close(&mut self.internal as *mut nk_context);
}
}
pub fn contextual_end(&mut self) {
unsafe {
nk_contextual_end(&mut self.internal as *mut nk_context);
}
}
pub fn tooltip(&mut self, text: String) {
unsafe {
nk_tooltip(&mut self.internal as *mut nk_context, text.as_ptr());
}
}
pub fn tooltip_begin(&mut self, width: f32) -> bool {
unsafe { nk_tooltip_begin(&mut self.internal as *mut nk_context, width) > 0 }
}
pub fn tooltip_end(&mut self) {
unsafe {
nk_tooltip_end(&mut self.internal as *mut nk_context);
}
}
pub fn menubar_begin(&mut self) {
unsafe {
nk_menubar_begin(&mut self.internal as *mut nk_context);
}
}
pub fn menubar_end(&mut self) {
unsafe {
nk_menubar_end(&mut self.internal as *mut nk_context);
}
}
pub fn menu_begin_label(&mut self, title: String, align: Flags, size: Vec2) -> bool {
unsafe {
nk_menu_begin_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
align,
size,
) > 0
}
}
pub fn menu_begin_text(&mut self, title: &str, align: Flags, size: Vec2) -> bool {
unsafe {
nk_menu_begin_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
size,
) > 0
}
}
pub fn menu_begin_image(&mut self, title: String, img: Image, size: Vec2) -> bool {
unsafe {
nk_menu_begin_image(
&mut self.internal as *mut nk_context,
title.as_ptr(),
img.internal,
size,
) > 0
}
}
pub fn menu_begin_image_label(
&mut self,
title: String,
align: Flags,
img: Image,
size: Vec2,
) -> bool {
unsafe {
nk_menu_begin_image_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
align,
img.internal,
size,
) > 0
}
}
pub fn menu_begin_image_text(
&mut self,
title: &str,
align: Flags,
img: Image,
size: Vec2,
) -> bool {
unsafe {
nk_menu_begin_image_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
img.internal,
size,
) > 0
}
}
pub fn menu_begin_symbol(&mut self, title: String, sym: SymbolType, size: Vec2) -> bool {
unsafe {
nk_menu_begin_symbol(
&mut self.internal as *mut nk_context,
title.as_ptr(),
sym.into(),
size,
) > 0
}
}
pub fn menu_begin_symbol_label(
&mut self,
title: String,
align: Flags,
sym: SymbolType,
size: Vec2,
) -> bool {
unsafe {
nk_menu_begin_symbol_label(
&mut self.internal as *mut nk_context,
title.as_ptr(),
align,
sym.into(),
size,
) > 0
}
}
pub fn menu_begin_symbol_text(
&mut self,
title: &str,
align: Flags,
sym: SymbolType,
size: Vec2,
) -> bool {
unsafe {
nk_menu_begin_symbol_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
sym.into(),
size,
) > 0
}
}
pub fn menu_item_label(&mut self, title: String, align: Flags) -> bool {
unsafe {
nk_menu_item_label(&mut self.internal as *mut nk_context, title.as_ptr(), align) > 0
}
}
pub fn menu_item_text(&mut self, title: &str, align: Flags) -> bool {
unsafe {
nk_menu_item_text(
&mut self.internal as *mut nk_context,
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
) > 0
}
}
pub fn menu_item_image_label(&mut self, img: Image, title: String, align: Flags) -> bool {
unsafe {
nk_menu_item_image_label(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr(),
align,
) > 0
}
}
pub fn menu_item_image_text(&mut self, img: Image, title: &str, align: Flags) -> bool {
unsafe {
nk_menu_item_image_text(
&mut self.internal as *mut nk_context,
img.internal,
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
) > 0
}
}
pub fn menu_item_symbol_label(&mut self, sym: SymbolType, title: String, align: Flags) -> bool {
unsafe {
nk_menu_item_symbol_label(
&mut self.internal as *mut nk_context,
sym.into(),
title.as_ptr(),
align,
) > 0
}
}
pub fn menu_item_symbol_text(&mut self, sym: SymbolType, title: &str, align: Flags) -> bool {
unsafe {
nk_menu_item_symbol_text(
&mut self.internal as *mut nk_context,
sym.into(),
title.as_ptr() as *const ::std::os::raw::c_char,
title.len() as i32,
align,
) > 0
}
}
pub fn menu_close(&mut self) {
unsafe {
nk_menu_close(&mut self.internal as *mut nk_context);
}
}
pub fn menu_end(&mut self) {
unsafe {
nk_menu_end(&mut self.internal as *mut nk_context);
}
}
pub fn convert(
&mut self,
cmds: &mut Buffer,
vertices: &mut Buffer,
elements: &mut Buffer,
config: &ConvertConfig,
) {
unsafe {
nk_convert(
&mut self.internal as *mut nk_context,
&mut cmds.internal as *mut nk_buffer,
&mut vertices.internal as *mut nk_buffer,
&mut elements.internal as *mut nk_buffer,
&config.internal as *const nk_convert_config,
);
}
}
pub fn input_begin(&mut self) {
unsafe {
nk_input_begin(&mut self.internal as *mut nk_context);
}
}
pub fn input_motion(&mut self, x: i32, y: i32) {
unsafe {
nk_input_motion(&mut self.internal as *mut nk_context, x, y);
}
}
pub fn input_key(&mut self, key: Key, down: bool) {
unsafe {
nk_input_key(
&mut self.internal as *mut nk_context,
key.into(),
if down { 1 } else { 0 },
);
}
}
pub fn input_button(&mut self, b: Button, x: i32, y: i32, down: bool) {
unsafe {
nk_input_button(
&mut self.internal as *mut nk_context,
b.into(),
x,
y,
if down { 1 } else { 0 },
);
}
}
pub fn input_scroll(&mut self, y: Vec2) {
unsafe {
nk_input_scroll(&mut self.internal as *mut nk_context, y);
}
}
pub fn input_char(&mut self, c: u8) {
unsafe {
nk_input_char(
&mut self.internal as *mut nk_context,
c as ::std::os::raw::c_char,
);
}
}
pub fn input_glyph(&mut self, g: Glyph) {
unsafe {
nk_input_glyph(
&mut self.internal as *mut nk_context,
&g[0] as *const _ as *mut ::std::os::raw::c_char,
);
}
}
pub fn input_unicode(&mut self, r: char) {
unsafe {
nk_input_unicode(&mut self.internal as *mut nk_context, r as u32);
}
}
pub fn input_end(&mut self) {
unsafe {
nk_input_end(&mut self.internal as *mut nk_context);
}
}
pub fn style_default(&mut self) {
unsafe {
nk_style_default(&mut self.internal as *mut nk_context);
}
}
pub fn style_from_table(&mut self, table: &ColorMap) {
unsafe {
nk_style_from_table(
&mut self.internal as *mut nk_context,
&table.internal[0] as *const nk_color,
);
}
}
pub fn style_load_cursor(&mut self, cur: StyleCursor, res: &Cursor) {
unsafe {
nk_style_load_cursor(&mut self.internal as *mut nk_context, cur, &res.internal);
}
}
pub fn style_load_all_cursors(&mut self, table: &mut CursorMap) {
unsafe {
nk_style_load_all_cursors(
&mut self.internal as *mut nk_context,
table.internal.as_mut_ptr() as *mut nk_cursor,
);
}
}
pub fn style_set_font(&mut self, font: &UserFont) {
unsafe {
nk_style_set_font(&mut self.internal as *mut nk_context, &font.internal);
}
}
pub fn style_set_cursor(&mut self, cur: StyleCursor) -> bool {
unsafe { nk_style_set_cursor(&mut self.internal as *mut nk_context, cur) > 0 }
}
pub fn style_show_cursor(&mut self) {
unsafe {
nk_style_show_cursor(&mut self.internal as *mut nk_context);
}
}
pub fn style_hide_cursor(&mut self) {
unsafe {
nk_style_hide_cursor(&mut self.internal as *mut nk_context);
}
}
pub fn style_push_font(&mut self, font: &mut UserFont) -> bool {
unsafe { nk_style_push_font(&mut self.internal as *mut nk_context, &font.internal) > 0 }
}
pub fn style_push_float(&mut self, addr: &mut f32, val: f32) -> bool {
unsafe {
nk_style_push_float(&mut self.internal as *mut nk_context, addr as *mut f32, val) > 0
}
}
pub fn style_push_vec2(&mut self, addr: &mut Vec2, val: Vec2) -> bool {
unsafe {
nk_style_push_vec2(
&mut self.internal as *mut nk_context,
addr as *mut nk_vec2,
val,
) > 0
}
}
pub fn style_push_style_item(&mut self, addr: &mut StyleItem, val: StyleItem) -> bool {
unsafe {
nk_style_push_style_item(
&mut self.internal as *mut nk_context,
&mut addr.internal as *mut nk_style_item,
val.internal,
) > 0
}
}
pub fn style_push_flags(&mut self, addr: &mut Flags, val: Flags) -> bool {
unsafe {
nk_style_push_flags(
&mut self.internal as *mut nk_context,
addr as *mut nk_flags,
val,
) > 0
}
}
pub fn style_push_color(&mut self, addr: &mut Color, val: Color) -> bool {
unsafe {
nk_style_push_color(
&mut self.internal as *mut nk_context,
addr as *mut nk_color,
val,
) > 0
}
}
pub fn style_pop_font(&mut self) -> bool {
unsafe { nk_style_pop_font(&mut self.internal as *mut nk_context) > 0 }
}
pub fn style_pop_float(&mut self) -> bool {
unsafe { nk_style_pop_float(&mut self.internal as *mut nk_context) > 0 }
}
pub fn style_pop_vec2(&mut self) -> bool {
unsafe { nk_style_pop_vec2(&mut self.internal as *mut nk_context) > 0 }
}
pub fn style_pop_style_item(&mut self) -> bool {
unsafe { nk_style_pop_style_item(&mut self.internal as *mut nk_context) > 0 }
}
pub fn style_pop_flags(&mut self) -> bool {
unsafe { nk_style_pop_flags(&mut self.internal as *mut nk_context) > 0 }
}
pub fn style_pop_color(&mut self) -> bool {
unsafe { nk_style_pop_color(&mut self.internal as *mut nk_context) > 0 }
}
pub fn widget_bounds(&mut self) -> Rect {
unsafe { nk_widget_bounds(&mut self.internal as *mut nk_context) }
}
pub fn widget_position(&mut self) -> Vec2 {
unsafe { nk_widget_position(&mut self.internal as *mut nk_context) }
}
pub fn widget_size(&mut self) -> Vec2 {
unsafe { nk_widget_size(&mut self.internal as *mut nk_context) }
}
pub fn widget_width(&mut self) -> f32 {
unsafe { nk_widget_width(&mut self.internal as *mut nk_context) }
}
pub fn widget_height(&mut self) -> f32 {
unsafe { nk_widget_height(&mut self.internal as *mut nk_context) }
}
pub fn widget_is_hovered(&mut self) -> bool {
unsafe { nk_widget_is_hovered(&mut self.internal as *mut nk_context) > 0 }
}
pub fn widget_is_mouse_clicked(&mut self, b: Button) -> bool {
unsafe { nk_widget_is_mouse_clicked(&mut self.internal as *mut nk_context, b.into()) > 0 }
}
pub fn widget_has_mouse_click_down(&mut self, b: Button, down: bool) -> bool {
unsafe {
nk_widget_has_mouse_click_down(
&mut self.internal as *mut nk_context,
b.into(),
if down { 1 } else { 0 },
) > 0
}
}
pub fn widget(&self, arg1: &mut Rect) -> WidgetLayoutState {
unsafe { nk_widget(arg1, &self.internal as *const nk_context) }
}
pub fn spacing(&mut self, cols: i32) {
unsafe {
nk_spacing(&mut self.internal as *mut nk_context, cols);
}
}
pub fn draw_begin(&self, buf: &Buffer) -> Option<&DrawCommand> {
let n = unsafe { nk__draw_begin(&self.internal, &buf.internal) };
unsafe {
if n.is_null() {
None
} else {
Some(::std::mem::transmute(n))
}
}
}
pub fn draw_next<'a>(&self, prev: &DrawCommand, buf: &Buffer) -> Option<&'a DrawCommand> {
let n = unsafe { nk__draw_next(&prev.internal, &buf.internal, &self.internal) };
unsafe {
if n.is_null() {
None
} else {
Some(::std::mem::transmute(n))
}
}
}
pub fn next_cmd<'a, 'b>(&self, arg2: &'b Command) -> Option<&'a Command> {
let r = unsafe {
nk__next(
&self.internal as *const _ as *mut nk_context,
&arg2.internal,
)
};
unsafe {
if r.is_null() {
None
} else {
Some(::std::mem::transmute(r))
}
}
}
pub fn begin_cmd(&self) -> Option<&Command> {
let r = unsafe { nk__begin(&self.internal as *const _ as *mut nk_context) };
unsafe {
if r.is_null() {
None
} else {
Some(::std::mem::transmute(r))
}
}
}
pub fn draw_command_iterator<'a>(&'a mut self, buf: &'a Buffer) -> DrawCommandIterator<'a> {
DrawCommandIterator { ctx: self, buf }
}
pub fn command_iterator(&mut self) -> CommandIterator {
CommandIterator { ctx: self }
}
}
pub struct CommandIterator<'a> {
ctx: &'a Context,
}
impl<'a> IntoIterator for CommandIterator<'a> {
type Item = &'a Command;
type IntoIter = CommandIntoIter<'a>;
fn into_iter(self) -> Self::IntoIter {
let cmd = self.ctx.begin_cmd();
CommandIntoIter { ctx: self.ctx, cmd }
}
}
pub struct CommandIntoIter<'a> {
ctx: &'a Context,
cmd: Option<&'a Command>,
}
impl<'a> Iterator for CommandIntoIter<'a> {
type Item = &'a Command;
fn next(&mut self) -> Option<&'a Command> {
let r = self.cmd;
self.cmd = if let Some(p) = self.cmd {
self.ctx.next_cmd(p)
} else {
None
};
r
}
}
pub struct DrawCommandIterator<'a> {
ctx: &'a mut Context,
buf: &'a Buffer,
}
impl<'a> IntoIterator for DrawCommandIterator<'a> {
type Item = &'a DrawCommand;
type IntoIter = DrawCommandIntoIter<'a>;
fn into_iter(self) -> Self::IntoIter {
let cmd = self.ctx.draw_begin(self.buf);
DrawCommandIntoIter {
ctx: self.ctx,
buf: self.buf,
cmd,
}
}
}
pub struct DrawCommandIntoIter<'a> {
ctx: &'a Context,
buf: &'a Buffer,
cmd: Option<&'a DrawCommand>,
}
impl<'a> Iterator for DrawCommandIntoIter<'a> {
type Item = &'a DrawCommand;
fn next(&mut self) -> Option<&'a DrawCommand> {
let r = self.cmd;
self.cmd = if let Some(ref p) = self.cmd {
self.ctx.draw_next(p, self.buf)
} else {
None
};
r
}
}
wrapper_type_no_clone!(Window, nk_window);
impl Window {
pub fn seq(&self) -> u32 {
self.internal.seq
}
pub fn name(&self) -> &str {
unsafe {
let name = ::std::mem::transmute::<&[::std::os::raw::c_char], &[u8]>(
&self.internal.name_string,
);
let mut len = name.len();
let mut ch = 0;
while ch == 0 && len > 0 {
len -= 1;
ch = name[len];
}
if len < name.len() {
len += 1;
}
::std::str::from_utf8_unchecked(&name[0..len])
}
}
pub fn flags(&self) -> &Flags {
&self.internal.flags
}
pub fn bounds(&self) -> &Rect {
&self.internal.bounds
}
pub fn scrollbar(&self) -> &Scroll {
&self.internal.scrollbar
}
pub fn scrollbar_hiding_timer(&self) -> f32 {
self.internal.scrollbar_hiding_timer
}
pub fn buffer(&self) -> &CommandBuffer {
unsafe { ::std::mem::transmute(&self.internal.buffer) }
}
pub fn layout(&self) -> &Panel {
unsafe { ::std::mem::transmute(self.internal.layout) }
}
pub fn layout_mut(&mut self) -> &mut Panel {
unsafe { ::std::mem::transmute(self.internal.layout) }
}
pub fn property(&self) -> &PropertyState {
unsafe { ::std::mem::transmute(&self.internal.property) }
}
pub fn popup(&self) -> &PopupState {
unsafe { ::std::mem::transmute(&self.internal.popup) }
}
pub fn edit(&self) -> &EditState {
unsafe { ::std::mem::transmute(&self.internal.edit) }
}
pub fn scrolled(&self) -> u32 {
self.internal.scrolled
}
pub fn tables(&self) -> &[Table] {
unsafe {
::std::slice::from_raw_parts(
self.internal.tables as *mut _ as *const Table,
self.internal.table_count as usize,
)
}
}
pub fn prev(&self) -> &Window {
unsafe { ::std::mem::transmute(self.internal.prev) }
}
pub fn next(&self) -> &Window {
unsafe { ::std::mem::transmute(self.internal.next) }
}
pub fn parent(&self) -> &Window {
unsafe { ::std::mem::transmute(self.internal.parent) }
}
pub fn set_flags(&mut self, flags: Flags) {
self.internal.flags = flags;
}
pub fn set_bounds(&mut self, rect: Rect) {
self.internal.bounds = rect;
}
pub fn set_scrollbar(&mut self, scroll: Scroll) {
self.internal.scrollbar = scroll;
}
pub fn set_scrollbar_hiding_timer(&mut self, value: f32) {
self.internal.scrollbar_hiding_timer = value;
}
}
wrapper_type_no_clone!(PropertyState, nk_property_state);
wrapper_type!(PopupState, nk_popup_state);
wrapper_type!(EditState, nk_edit_state);
wrapper_type_no_clone!(Table, nk_table);
wrapper_type!(RowLayout, nk_row_layout);
impl RowLayout {
pub fn layout_type(&self) -> &PanelRowLayoutType {
&self.internal.type_
}
pub fn layout_type_mut(&mut self) -> &mut PanelRowLayoutType {
&mut self.internal.type_
}
pub fn index(&self) -> i32 {
self.internal.index
}
pub fn set_index(&mut self, i: i32) {
self.internal.index = i
}
pub fn height(&self) -> f32 {
self.internal.height
}
pub fn set_height(&mut self, i: f32) {
self.internal.height = i
}
pub fn columns(&self) -> i32 {
self.internal.columns
}
pub fn set_columns(&mut self, i: i32) {
self.internal.columns = i
}
pub fn ratio(&self) -> &f32 {
unsafe { &*self.internal.ratio }
}
pub fn item_width(&self) -> f32 {
self.internal.item_width
}
pub fn set_item_width(&mut self, i: f32) {
self.internal.item_width = i
}
pub fn item_height(&self) -> f32 {
self.internal.item_height
}
pub fn set_item_height(&mut self, i: f32) {
self.internal.item_height = i
}
pub fn item_offset(&self) -> f32 {
self.internal.item_offset
}
pub fn set_item_offset(&mut self, i: f32) {
self.internal.item_offset = i
}
pub fn filled(&self) -> f32 {
self.internal.filled
}
pub fn set_filled(&mut self, i: f32) {
self.internal.filled = i
}
pub fn item(&self) -> &Rect {
&self.internal.item
}
pub fn item_mut(&mut self) -> &mut Rect {
&mut self.internal.item
}
pub fn tree_depth(&self) -> i32 {
self.internal.tree_depth
}
pub fn set_tree_depth(&mut self, i: i32) {
self.internal.tree_depth = i
}
pub fn templates(&self) -> &[f32] {
&self.internal.templates
}
pub fn templates_mut(&mut self) -> &mut [f32] {
&mut self.internal.templates
}
}
wrapper_type!(Panel, nk_panel);
impl Panel {
pub fn bounds(&self) -> &Rect {
&self.internal.bounds
}
pub fn bounds_mut(&mut self) -> &mut Rect {
&mut self.internal.bounds
}
pub fn set_bounds(&mut self, b: Rect) {
self.internal.bounds = b
}
pub fn panel_type(&self) -> &PanelType {
&self.internal.type_
}
pub fn panel_type_mut(&mut self) -> &mut PanelType {
&mut self.internal.type_
}
pub fn set_panel_type(&mut self, t: PanelType) {
self.internal.type_ = t
}
pub fn flags(&self) -> &Flags {
&self.internal.flags
}
pub fn flags_mut(&mut self) -> &mut Flags {
&mut self.internal.flags
}
pub fn set_flags(&mut self, f: Flags) {
self.internal.flags = f
}
pub fn offset_x(&self) -> u32 {
unsafe { *self.internal.offset_x }
}
pub fn set_offset_x(&mut self, o: u32) {
unsafe { *self.internal.offset_x = o }
}
pub fn offset_y(&self) -> u32 {
unsafe { *self.internal.offset_y }
}
pub fn set_offset_y(&mut self, o: u32) {
unsafe { *self.internal.offset_y = o }
}
pub fn at_x(&self) -> f32 {
self.internal.at_x
}
pub fn set_at_x(&mut self, f: f32) {
self.internal.at_x = f
}
pub fn at_y(&self) -> f32 {
self.internal.at_y
}
pub fn set_at_y(&mut self, f: f32) {
self.internal.at_y = f
}
pub fn max_x(&self) -> f32 {
self.internal.max_x
}
pub fn set_max_x(&mut self, f: f32) {
self.internal.max_x = f
}
pub fn footer_height(&self) -> f32 {
self.internal.footer_height
}
pub fn set_footer_height(&mut self, f: f32) {
self.internal.footer_height = f
}
pub fn header_height(&self) -> f32 {
self.internal.header_height
}
pub fn set_header_height(&mut self, f: f32) {
self.internal.header_height = f
}
pub fn border(&self) -> f32 {
self.internal.border
}
pub fn set_border(&mut self, f: f32) {
self.internal.border = f
}
pub fn has_scrolling(&self) -> bool {
self.internal.has_scrolling == nk_true as u32
}
pub fn set_has_scrolling(&mut self, f: bool) {
self.internal.has_scrolling = if f { nk_true as u32 } else { nk_false as u32 }
}
pub fn clip(&self) -> &Rect {
&self.internal.clip
}
pub fn clip_mut(&mut self) -> &mut Rect {
&mut self.internal.clip
}
pub fn set_clip(&mut self, f: Rect) {
self.internal.clip = f
}
pub fn menu(&self) -> &MenuState {
&self.internal.menu
}
pub fn menu_mut(&mut self) -> &mut MenuState {
&mut self.internal.menu
}
pub fn set_menu(&mut self, f: MenuState) {
self.internal.menu = f
}
pub fn row(&self) -> &RowLayout {
unsafe { ::std::mem::transmute(&self.internal.row) }
}
pub fn chart(&self) -> &Chart {
unsafe { ::std::mem::transmute(&self.internal.chart) }
}
pub fn buffer(&self) -> Option<&CommandBuffer> {
unsafe {
let ptr = self.internal.buffer;
if !ptr.is_null() {
Some(::std::mem::transmute(ptr))
} else {
None
}
}
}
pub fn parent(&self) -> Option<&Panel> {
unsafe {
let ptr = self.internal.parent;
if !ptr.is_null() {
Some(::std::mem::transmute(ptr))
} else {
None
}
}
}
}
wrapper_type!(Chart, nk_chart);
impl Chart {
pub fn x(&self) -> f32 {
self.internal.x
}
pub fn set_x(&mut self, f: f32) {
self.internal.x = f
}
pub fn y(&self) -> f32 {
self.internal.y
}
pub fn set_y(&mut self, f: f32) {
self.internal.y = f
}
pub fn w(&self) -> f32 {
self.internal.w
}
pub fn set_w(&mut self, f: f32) {
self.internal.w = f
}
pub fn h(&self) -> f32 {
self.internal.h
}
pub fn set_h(&mut self, f: f32) {
self.internal.h = f
}
pub fn slot(&self) -> u32 {
self.internal.slot as u32
}
pub fn slots(&self) -> &[ChartSlot] {
&self.internal.slots
}
}
macro_rules! emit_nk_command {
($rs_ty:ident, $nat_ty:ty) => {
wrapper_type!($rs_ty, $nat_ty);
impl AsRef<$rs_ty> for Command {
fn as_ref(&self) -> &$rs_ty {
unsafe { ::std::mem::transmute(&self.internal) }
}
}
impl $rs_ty {
pub fn header(&self) -> &Command {
unsafe { ::std::mem::transmute(&self.internal.header) }
}
}
};
}
wrapper_type!(Command, nk_command);
impl Command {
pub fn get_type(&self) -> CommandType {
self.internal.type_.into()
}
}
emit_nk_command!(CommandScissor, nk_command_scissor);
impl CommandScissor {
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
pub fn rect(&self) -> (i32, i32, u32, u32) {
(
self.internal.x as i32,
self.internal.y as i32,
self.internal.w as u32,
self.internal.h as u32,
)
}
}
emit_nk_command!(CommandLine, nk_command_line);
impl CommandLine {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn begin(&self) -> Vec2i {
self.internal.begin
}
pub fn end(&self) -> Vec2i {
self.internal.end
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandCurve, nk_command_curve);
impl CommandCurve {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn begin(&self) -> Vec2i {
self.internal.begin
}
pub fn end(&self) -> Vec2i {
self.internal.end
}
pub fn color(&self) -> Color {
self.internal.color
}
pub fn ctrl(&self) -> &[Vec2i] {
&self.internal.ctrl
}
}
emit_nk_command!(CommandRect, nk_command_rect);
impl CommandRect {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn rounding(&self) -> u16 {
self.internal.rounding
}
pub fn color(&self) -> Color {
self.internal.color
}
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
}
emit_nk_command!(CommandRectFilled, nk_command_rect_filled);
impl CommandRectFilled {
pub fn rounding(&self) -> u16 {
self.internal.rounding
}
pub fn color(&self) -> Color {
self.internal.color
}
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
}
emit_nk_command!(CommandRectMultiColor, nk_command_rect_multi_color);
impl CommandRectMultiColor {
pub fn left(&self) -> Color {
self.internal.left
}
pub fn top(&self) -> Color {
self.internal.top
}
pub fn right(&self) -> Color {
self.internal.right
}
pub fn bottom(&self) -> Color {
self.internal.bottom
}
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
}
emit_nk_command!(CommandTriangle, nk_command_triangle);
impl CommandTriangle {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn a(&self) -> Vec2i {
self.internal.a
}
pub fn b(&self) -> Vec2i {
self.internal.b
}
pub fn c(&self) -> Vec2i {
self.internal.c
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandTriangleFilled, nk_command_triangle_filled);
impl CommandTriangleFilled {
pub fn a(&self) -> Vec2i {
self.internal.a
}
pub fn b(&self) -> Vec2i {
self.internal.b
}
pub fn c(&self) -> Vec2i {
self.internal.c
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandCircle, nk_command_circle);
impl CommandCircle {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandCircleFilled, nk_command_circle_filled);
impl CommandCircleFilled {
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandArc, nk_command_arc);
impl CommandArc {
pub fn cx(&self) -> i16 {
self.internal.cx
}
pub fn cy(&self) -> i16 {
self.internal.cy
}
pub fn r(&self) -> u16 {
self.internal.r
}
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn a(&self) -> &[f32] {
&self.internal.a
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandArcFilled, nk_command_arc_filled);
impl CommandArcFilled {
pub fn cx(&self) -> i16 {
self.internal.cx
}
pub fn cy(&self) -> i16 {
self.internal.cy
}
pub fn r(&self) -> u16 {
self.internal.r
}
pub fn a(&self) -> &[f32] {
&self.internal.a
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandPolygon, nk_command_polygon);
impl CommandPolygon {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn points(&self) -> &[Vec2i] {
unsafe {
::std::slice::from_raw_parts(
self.internal.points.as_ptr(),
self.internal.point_count as usize,
)
}
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandPolygonFilled, nk_command_polygon_filled);
impl CommandPolygonFilled {
pub fn points(&self) -> &[Vec2i] {
unsafe {
::std::slice::from_raw_parts(
self.internal.points.as_ptr(),
self.internal.point_count as usize,
)
}
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandPolyline, nk_command_polyline);
impl CommandPolyline {
pub fn line_thickness(&self) -> u16 {
self.internal.line_thickness
}
pub fn points(&self) -> &[Vec2i] {
unsafe {
::std::slice::from_raw_parts(
self.internal.points.as_ptr(),
self.internal.point_count as usize,
)
}
}
pub fn color(&self) -> Color {
self.internal.color
}
}
emit_nk_command!(CommandImage, nk_command_image);
impl CommandImage {
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
pub fn col(&self) -> Color {
self.internal.col
}
pub fn img(&self) -> Image {
Image {
internal: self.internal.img,
}
}
}
emit_nk_command!(CommandText, nk_command_text);
impl CommandText {
pub fn x(&self) -> i16 {
self.internal.x
}
pub fn y(&self) -> i16 {
self.internal.y
}
pub fn w(&self) -> u16 {
self.internal.w
}
pub fn h(&self) -> u16 {
self.internal.h
}
pub fn height(&self) -> f32 {
self.internal.height
}
pub fn chars(&self) -> &[u8] {
unsafe {
::std::slice::from_raw_parts(
self.internal.string.as_ptr() as *const u8,
self.internal.length as usize,
)
}
}
pub fn background(&self) -> Color {
self.internal.background
}
pub fn foreground(&self) -> Color {
self.internal.foreground
}
pub fn font(&self) -> &UserFont {
unsafe { ::std::mem::transmute(self.internal.font) }
}
}
wrapper_type!(CommandBuffer, nk_command_buffer);
impl CommandBuffer {
pub fn stroke_line(
&mut self,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
line_thickness: f32,
color: Color,
) {
unsafe {
nk_stroke_line(&mut self.internal, x0, y0, x1, y1, line_thickness, color);
}
}
pub fn stroke_curve(
&mut self,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
x3: f32,
y3: f32,
line_thickness: f32,
color: Color,
) {
unsafe {
nk_stroke_curve(
&mut self.internal,
x0,
y0,
x1,
y1,
x2,
y2,
x3,
y3,
line_thickness,
color,
);
}
}
pub fn stroke_rect(&mut self, bounds: Rect, rounding: f32, line_thickness: f32, color: Color) {
unsafe {
nk_stroke_rect(&mut self.internal, bounds, rounding, line_thickness, color);
}
}
pub fn stroke_circle(&mut self, arg2: Rect, line_thickness: f32, color: Color) {
unsafe {
nk_stroke_circle(&mut self.internal, arg2, line_thickness, color);
}
}
pub fn stroke_arc(
&mut self,
cx: f32,
cy: f32,
radius: f32,
a_min: f32,
a_max: f32,
line_thickness: f32,
color: Color,
) {
unsafe {
nk_stroke_arc(
&mut self.internal,
cx,
cy,
radius,
a_min,
a_max,
line_thickness,
color,
);
}
}
pub fn stroke_triangle(
&mut self,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
line_thichness: f32,
color: Color,
) {
unsafe {
nk_stroke_triangle(
&mut self.internal,
x0,
y0,
x1,
y1,
x2,
y2,
line_thichness,
color,
);
}
}
pub fn stroke_polyline(&mut self, points: &mut [f32], line_thickness: f32, color: Color) {
unsafe {
nk_stroke_polyline(
&mut self.internal,
&mut points[0] as *mut f32,
points.len() as ::std::os::raw::c_int,
line_thickness,
color,
);
}
}
pub fn stroke_polygon(&mut self, points: &mut [f32], line_thickness: f32, color: Color) {
unsafe {
nk_stroke_polygon(
&mut self.internal,
&mut points[0] as *mut f32,
points.len() as ::std::os::raw::c_int,
line_thickness,
color,
);
}
}
pub fn fill_rect(&mut self, arg2: Rect, rounding: f32, color: Color) {
unsafe {
nk_fill_rect(&mut self.internal, arg2, rounding, color);
}
}
pub fn fill_rect_multi_color(
&mut self,
arg2: Rect,
left: Color,
top: Color,
right: Color,
bottom: Color,
) {
unsafe {
nk_fill_rect_multi_color(&mut self.internal, arg2, left, top, right, bottom);
}
}
pub fn fill_circle(&mut self, arg2: Rect, color: Color) {
unsafe {
nk_fill_circle(&mut self.internal, arg2, color);
}
}
pub fn fill_arc(
&mut self,
cx: f32,
cy: f32,
radius: f32,
a_min: f32,
a_max: f32,
color: Color,
) {
unsafe {
nk_fill_arc(&mut self.internal, cx, cy, radius, a_min, a_max, color);
}
}
pub fn fill_triangle(
&mut self,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
color: Color,
) {
unsafe {
nk_fill_triangle(&mut self.internal, x0, y0, x1, y1, x2, y2, color);
}
}
pub fn fill_polygon(&mut self, points: &mut [f32], color: Color) {
unsafe {
nk_fill_polygon(
&mut self.internal,
&mut points[0] as *mut f32,
points.len() as ::std::os::raw::c_int,
color,
);
}
}
pub fn push_scissor(&mut self, arg2: Rect) {
unsafe {
nk_push_scissor(&mut self.internal, arg2);
}
}
pub fn draw_image(&mut self, arg2: Rect, arg3: &Image, arg4: Color) {
unsafe {
nk_draw_image(
&mut self.internal,
arg2,
&arg3.internal as *const nk_image,
arg4,
);
}
}
pub fn draw_text(&mut self, arg2: Rect, text: &str, arg3: &UserFont, arg4: Color, arg5: Color) {
unsafe {
nk_draw_text(
&mut self.internal,
arg2,
text.as_ptr() as *const ::std::os::raw::c_char,
text.as_bytes().len() as ::std::os::raw::c_int,
&arg3.internal,
arg4,
arg5,
);
}
}
}
pub fn color_rgb(r: i32, g: i32, b: i32) -> Color {
unsafe { nk_rgb(r, g, b) }
}
pub fn color_rgb_iv(rgb: &i32) -> Color {
unsafe { nk_rgb_iv(rgb as *const i32) }
}
pub fn color_rgb_bv(rgb: &u8) -> Color {
unsafe { nk_rgb_bv(rgb as *const u8) }
}
pub fn color_rgb_fv(rgb: &f32) -> Color {
unsafe { nk_rgb_fv(rgb as *const f32) }
}
pub fn color_rgb_f(r: f32, g: f32, b: f32) -> Color {
unsafe { nk_rgb_f(r, g, b) }
}
pub fn color_rgb_hex(rgb: String) -> Color {
unsafe { nk_rgb_hex(rgb.as_ptr()) }
}
pub fn color_rgba(r: i32, g: i32, b: i32, a: i32) -> Color {
unsafe { nk_rgba(r, g, b, a) }
}
pub fn color_rgba_u32(rgba: u32) -> Color {
unsafe { nk_rgba_u32(rgba) }
}
pub fn color_rgba_iv(rgba: &i32) -> Color {
unsafe { nk_rgba_iv(rgba as *const i32) }
}
pub fn color_rgba_bv(rgb: &u8) -> Color {
unsafe { nk_rgba_bv(rgb as *const u8) }
}
pub fn color_rgba_fv(rgb: &f32) -> Color {
unsafe { nk_rgba_fv(rgb as *const f32) }
}
pub fn color_rgba_f(r: f32, g: f32, b: f32, a: f32) -> Color {
unsafe { nk_rgba_f(r, g, b, a) }
}
pub fn color_rgba_hex(rgba: String) -> Color {
unsafe { nk_rgba_hex(rgba.as_ptr()) }
}
pub fn color_hsv(h: i32, s: i32, v: i32) -> Color {
unsafe { nk_hsv(h, s, v) }
}
pub fn color_hsv_iv(hsv: &i32) -> Color {
unsafe { nk_hsv_iv(hsv as *const i32) }
}
pub fn color_hsv_bv(hsv: &u8) -> Color {
unsafe { nk_hsv_bv(hsv as *const u8) }
}
pub fn color_hsv_fv(hsv: &f32) -> Color {
unsafe { nk_hsv_fv(hsv as *const f32) }
}
pub fn color_hsv_f(h: f32, s: f32, v: f32) -> Color {
unsafe { nk_hsv_f(h, s, v) }
}
pub fn color_hsva(h: i32, s: i32, v: i32, a: i32) -> Color {
unsafe { nk_hsva(h, s, v, a) }
}
pub fn color_hsva_iv(hsva: &i32) -> Color {
unsafe { nk_hsva_iv(hsva as *const i32) }
}
pub fn color_hsva_bv(hsv: &u8) -> Color {
unsafe { nk_hsva_bv(hsv as *const u8) }
}
pub fn color_hsva_fv(hsv: &f32) -> Color {
unsafe { nk_hsva_fv(hsv as *const f32) }
}
pub fn color_hsva_f(h: f32, s: f32, v: f32, a: f32) -> Color {
unsafe { nk_hsva_f(h, s, v, a) }
}
pub fn style_get_color_by_name(c: StyleColor) -> Cow<'static, str> {
unsafe {
::std::ffi::CStr::from_ptr(nk_style_get_color_by_name(c)).to_string_lossy()
}
}
pub fn rect(x: f32, y: f32, w: f32, h: f32) -> Rect {
Rect { x, y, w, h }
}
pub fn recti(x: i32, y: i32, w: i32, h: i32) -> Rect {
Rect {
x: x as f32,
y: y as f32,
w: w as f32,
h: h as f32,
}
}
pub fn recta(pos: Vec2, size: Vec2) -> Rect {
Rect {
x: pos.x,
y: pos.y,
w: size.x,
h: size.y,
}
}
pub fn rectv(v: &[f32]) -> Rect {
assert!(v.len() >= 4);
unsafe { nk_rectv(v.as_ptr()) }
}
pub fn rectiv(v: &[i32]) -> Rect {
assert!(v.len() >= 4);
unsafe { nk_rectiv(v.as_ptr()) }
}
pub fn rect_pos(rect: Rect) -> Vec2 {
Vec2 {
x: rect.x,
y: rect.y,
}
}
pub fn rect_size(rect: Rect) -> Vec2 {
Vec2 {
x: rect.w,
y: rect.h,
}
}
pub fn vec2(x: f32, y: f32) -> Vec2 {
Vec2 { x, y }
}
pub fn vec2i(x: i32, y: i32) -> Vec2 {
Vec2 {
x: x as f32,
y: y as f32,
}
}
pub fn vec2v(v: &[f32]) -> Vec2 {
assert!(v.len() >= 2);
Vec2 { x: v[0], y: v[1] }
}
pub fn vec2iv(v: &[i32]) -> Vec2 {
assert!(v.len() >= 2);
Vec2 {
x: v[0] as f32,
y: v[1] as f32,
}
}
wrapper_type!(Image, nk_image);
impl From<nk_image> for Image {
fn from(value: nk_image) -> Self {
Self { internal: value }
}
}
impl Image {
pub fn with_id(id: i32) -> Image {
Image {
internal: unsafe { nk_image_id(id) },
}
}
pub unsafe fn with_ptr(ptr: *mut c_void) -> Image {
Image {
internal: nk_image_ptr(ptr),
}
}
pub fn id(&mut self) -> i32 {
unsafe { self.internal.handle.id }
}
pub fn ptr(&mut self) -> *mut c_void {
unsafe { self.internal.handle.ptr }
}
}
wrapper_type!(FontGlyph, nk_font_glyph);
impl FontGlyph {
pub fn codepoint(&self) -> char {
::std::char::from_u32(self.internal.codepoint).unwrap()
}
pub fn xadvance(&self) -> f32 {
self.internal.xadvance
}
pub fn x0(&self) -> f32 {
self.internal.x0
}
pub fn y0(&self) -> f32 {
self.internal.y0
}
pub fn x1(&self) -> f32 {
self.internal.x1
}
pub fn y1(&self) -> f32 {
self.internal.y1
}
pub fn w(&self) -> f32 {
self.internal.w
}
pub fn h(&self) -> f32 {
self.internal.h
}
pub fn u0(&self) -> f32 {
self.internal.u0
}
pub fn v0(&self) -> f32 {
self.internal.v0
}
pub fn u1(&self) -> f32 {
self.internal.u1
}
pub fn v1(&self) -> f32 {
self.internal.v1
}
pub fn xy(&self) -> (f32, f32, f32, f32) {
(
self.internal.x0,
self.internal.y0,
self.internal.x1,
self.internal.y1,
)
}
pub fn xy0(&self) -> (f32, f32) {
(self.internal.x0, self.internal.y0)
}
pub fn xy1(&self) -> (f32, f32) {
(self.internal.x1, self.internal.y1)
}
pub fn rect(&self) -> (f32, f32, f32, f32) {
(
self.internal.x0,
self.internal.y0,
self.internal.w,
self.internal.h,
)
}
pub fn size(&self) -> (f32, f32) {
(self.internal.w, self.internal.h)
}
pub fn uv(&self) -> (f32, f32, f32, f32) {
(
self.internal.u0,
self.internal.v0,
self.internal.u1,
self.internal.v1,
)
}
pub fn uv0(&self) -> (f32, f32) {
(self.internal.u0, self.internal.v0)
}
pub fn uv1(&self) -> (f32, f32) {
(self.internal.u1, self.internal.v1)
}
}
wrapper_type!(Font, nk_font);
impl Font {
pub fn find_glyph(&self, unicode: char) -> &FontGlyph {
unsafe {
::std::mem::transmute(nk_font_find_glyph(
&self.internal as *const _ as *mut nk_font,
unicode as u32,
))
}
}
pub fn handle(&self) -> &UserFont {
unsafe { ::std::mem::transmute(&self.internal.handle as *const _ as *mut nk_user_font) }
}
pub fn texture(&self) -> Handle {
Handle {
internal: self.internal.texture,
kind: HandleKind::Unknown,
}
}
}
wrapper_type!(UserFont, nk_user_font);
impl AsRef<Font> for UserFont {
fn as_ref(&self) -> &Font {
unsafe { ::std::mem::transmute(self.internal.userdata.ptr as *const _ as *mut nk_font) }
}
}
impl UserFont {
pub unsafe fn userdata_ptr(&self) -> Handle {
Handle::from_ptr(self.internal.userdata.ptr)
}
pub unsafe fn userdata_id(&self) -> Handle {
Handle::from_id(self.internal.userdata.id)
}
}
#[cfg(feature = "input-device")]
pub trait TranslateInputEvent {
fn translate_input_event(&mut self, event: &InputEvent);
}
#[cfg(feature = "input-device")]
fn translate_keyboard_input(ctx: &mut Context, key: &KeyboardInput) {
let down = key.state != ElementState::Released;
match key.virtual_keycode {
Some(VirtualKeyCode::Up) => {
ctx.input_key(Key::Up, down);
}
Some(VirtualKeyCode::Down) => {
ctx.input_key(Key::Down, down);
}
Some(VirtualKeyCode::Left) => {
ctx.input_key(Key::Left, down);
}
Some(VirtualKeyCode::Right) => {
ctx.input_key(Key::Right, down);
}
_ => {}
}
}
#[cfg(feature = "input-device")]
fn translate_mouse_button(ctx: &mut Context, button: InputMouseButton, state: ElementState) {
let down = state != ElementState::Released;
match button {
InputMouseButton::Left => {
ctx.input_button(Button::Left, 0, 0, down);
}
InputMouseButton::Right => {
ctx.input_button(Button::Right, 0, 0, down);
}
InputMouseButton::Middle => {
ctx.input_button(Button::Middle, 0, 0, down);
}
_ => {}
}
}
#[cfg(feature = "input-device")]
impl TranslateInputEvent for Context {
fn translate_input_event(&mut self, event: &InputEvent) {
match event {
InputEvent::MouseButton { button, state } => {
translate_mouse_button(self, *button, *state);
}
InputEvent::Key(key) => {
translate_keyboard_input(self, key);
}
_ => {}
}
}
}
fn raw_glyph_ranges_to_safe<'a>(arg: *const nk_rune) -> &'a [(u32, u32)] {
unsafe {
let len32 = (::std::mem::size_of::<(u32, u32)>() / ::std::mem::size_of::<u32>()) as isize;
let mut raw2 = arg;
let mut i = 0xffff;
let mut len = 0;
while i > 0 {
i = *raw2;
raw2 = raw2.offset(len32);
if i > 0 {
len += 1;
}
}
::std::slice::from_raw_parts(arg as *const (u32, u32), len)
}
}
pub fn font_default_glyph_ranges<'a>() -> &'a [(u32, u32)] {
unsafe { raw_glyph_ranges_to_safe(nk_font_default_glyph_ranges()) }
}
pub fn font_chinese_glyph_ranges<'a>() -> &'a [(u32, u32)] {
unsafe { raw_glyph_ranges_to_safe(nk_font_chinese_glyph_ranges()) }
}
pub fn font_cyrillic_glyph_ranges<'a>() -> &'a [(u32, u32)] {
unsafe { raw_glyph_ranges_to_safe(nk_font_cyrillic_glyph_ranges()) }
}
pub fn font_korean_glyph_ranges<'a>() -> &'a [(u32, u32)] {
unsafe { raw_glyph_ranges_to_safe(nk_font_korean_glyph_ranges()) }
}