Struct nuklear_rust::NkContext

pub struct NkContext { /* fields omitted */ }

Methods

impl NkContext

fn new(alloc: &mut NkAllocator, font: &NkUserFont) -> NkContext

fn input(&mut self) -> NkInput

fn style(&mut self) -> NkStyle

fn draw_list(&mut self) -> NkDrawList

fn clear(&mut self)

fn free(&mut self)

fn begin(&mut self, title: NkString, bounds: NkRect, flags: NkFlags) -> bool

fn begin_titled(&mut self,
                name: NkString,
                title: NkString,
                bounds: NkRect,
                flags: NkFlags)
                -> i32

fn end(&mut self)

fn window_find(&mut self, name: NkString) -> Option<NkWindow>

fn window_get_bounds(&self) -> NkRect

fn window_get_size(&self) -> NkVec2

fn window_get_position(&self) -> NkVec2

fn window_get_width(&self) -> f32

fn window_get_height(&self) -> f32

fn window_get_panel(&mut self) -> Option<NkPanelRef>

fn window_get_content_region(&mut self) -> NkRect

fn window_get_content_region_min(&mut self) -> NkVec2

fn window_get_content_region_max(&mut self) -> NkVec2

fn window_get_content_region_size(&mut self) -> NkVec2

fn window_get_canvas(&mut self) -> Option<NkCommandBuffer>

fn window_has_focus(&self) -> bool

fn window_is_collapsed(&mut self, name: NkString) -> bool

fn window_is_closed(&mut self, name: NkString) -> bool

fn window_is_hidden(&mut self, name: NkString) -> bool

fn window_is_active(&mut self, name: NkString) -> bool

fn window_is_hovered(&mut self) -> bool

fn window_is_any_hovered(&mut self) -> bool

fn item_is_any_active(&mut self) -> bool

fn window_set_bounds(&mut self, bounds: NkRect)

fn window_set_position(&mut self, pos: NkVec2)

fn window_set_size(&mut self, size: NkVec2)

fn window_set_focus(&mut self, name: NkString)

fn window_close(&mut self, name: NkString)

fn window_collapse(&mut self, name: NkString, state: NkCollapseState)

fn window_collapse_if(&mut self,
                      name: NkString,
                      state: NkCollapseState,
                      cond: bool)

fn window_show(&mut self, name: NkString, state: NkShowState)

fn window_show_if(&mut self, name: NkString, state: NkShowState, cond: bool)

fn layout_row_dynamic(&mut self, height: f32, cols: i32)

fn layout_row_static(&mut self, height: f32, item_width: i32, cols: i32)

fn layout_row_begin(&mut self, fmt: NkLayoutFormat, row_height: f32, cols: i32)

fn layout_row_push(&mut self, value: f32)

fn layout_row_end(&mut self)

fn layout_row(&mut self, fmt: NkLayoutFormat, height: f32, cols_ratio: &[f32])

fn layout_space_begin(&mut self,
                      fmt: NkLayoutFormat,
                      height: f32,
                      widget_count: i32)

fn layout_space_push(&mut self, space: NkRect)

fn layout_space_end(&mut self)

fn layout_space_bounds(&mut self) -> NkRect

fn layout_space_to_screen(&mut self, space: NkVec2) -> NkVec2

fn layout_space_to_local(&mut self, space: NkVec2) -> NkVec2

fn layout_space_rect_to_screen(&mut self, space: NkRect) -> NkRect

fn layout_space_rect_to_local(&mut self, space: NkRect) -> NkRect

fn layout_ratio_from_pixel(&mut self, pixel_width: f32) -> f32

fn nk_group_begin(&mut self, title: NkString, flags: NkFlags) -> i32

fn group_end(&mut self)

fn tree_push_hashed(&mut self,
                    ty: NkTreeType,
                    title: NkString,
                    initial_state: NkCollapseState,
                    hash: NkString,
                    len: i32,
                    seed: i32)
                    -> i32

fn tree_image_push_hashed(&mut self,
                          ty: NkTreeType,
                          i: NkImage,
                          title: NkString,
                          initial_state: NkCollapseState,
                          hash: NkString,
                          len: i32,
                          seed: i32)
                          -> i32

fn tree_pop(&mut self)

fn text(&mut self, text: &str, flags: NkFlags)

fn text_colored(&mut self, text: &str, flags: NkFlags, color: NkColor)

fn text_wrap(&mut self, text: &str)

fn text_wrap_colored(&mut self, text: &str, color: NkColor)

fn label(&mut self, text: NkString, flags: NkFlags)

fn label_colored(&mut self, text: NkString, flags: NkFlags, color: NkColor)

fn label_wrap(&mut self, text: NkString)

fn label_colored_wrap(&mut self, text: NkString, color: NkColor)

fn image(&mut self, img: NkImage)

fn button_text(&mut self, text: &str) -> bool

fn button_label(&mut self, title: NkString) -> bool

fn button_color(&mut self, color: NkColor) -> bool

fn button_symbol(&mut self, ty: NkSymbolType) -> bool

fn button_image(&mut self, img: NkImage) -> bool

fn button_symbol_label(&mut self,
                       ty: NkSymbolType,
                       title: NkString,
                       text_alignment: NkFlags)
                       -> bool

fn button_symbol_text(&mut self,
                      ty: NkSymbolType,
                      title: &str,
                      text_alignment: NkFlags)
                      -> bool

fn button_image_label(&mut self,
                      img: NkImage,
                      title: NkString,
                      text_alignment: NkFlags)
                      -> bool

fn button_image_text(&mut self,
                     img: NkImage,
                     title: &str,
                     text_alignment: NkFlags)
                     -> bool

fn button_set_behavior(&mut self, b: NkButtonBehavior)

fn button_push_behavior(&mut self, b: NkButtonBehavior) -> i32

fn button_pop_behavior(&mut self) -> i32

fn check_label(&mut self, title: NkString, active: bool) -> i32

fn check_text(&mut self, title: &str, active: bool) -> i32

fn check_flags_label(&mut self, title: NkString, flags: u32, value: u32) -> u32

fn check_flags_text(&mut self, title: &str, flags: u32, value: u32) -> u32

fn checkbox_label(&mut self, title: NkString, active: &mut bool) -> bool

fn checkbox_text(&mut self, title: &str, active: &mut bool) -> bool

fn checkbox_flags_label(&mut self,
                        title: NkString,
                        flags: &mut u32,
                        value: u32)
                        -> bool

fn checkbox_flags_text(&mut self,
                       title: &str,
                       flags: &mut u32,
                       value: u32)
                       -> bool

fn radio_label(&mut self, title: NkString, active: &mut bool) -> bool

fn radio_text(&mut self, title: &str, active: &mut bool) -> bool

fn option_label(&mut self, title: NkString, active: bool) -> bool

fn option_text(&mut self, title: &str, active: bool) -> bool

fn selectable_label(&mut self,
                    title: NkString,
                    align: NkFlags,
                    value: &mut i32)
                    -> bool

fn selectable_text(&mut self,
                   title: &str,
                   align: NkFlags,
                   value: &mut i32)
                   -> bool

fn selectable_image_label(&mut self,
                          img: NkImage,
                          title: NkString,
                          align: NkFlags,
                          value: &mut i32)
                          -> bool

fn selectable_image_text(&mut self,
                         img: NkImage,
                         title: &str,
                         align: NkFlags,
                         value: &mut i32)
                         -> bool

fn select_label(&mut self, title: NkString, align: NkFlags, value: i32) -> i32

fn select_text(&mut self, title: &str, align: NkFlags, value: i32) -> i32

fn select_image_label(&mut self,
                      img: NkImage,
                      title: NkString,
                      align: NkFlags,
                      value: i32)
                      -> i32

fn select_image_text(&mut self,
                     img: NkImage,
                     title: &str,
                     align: NkFlags,
                     value: i32)
                     -> i32

fn slide_float(&mut self, min: f32, val: f32, max: f32, step: f32) -> f32

fn slide_int(&mut self, min: i32, val: i32, max: i32, step: i32) -> i32

fn slider_float(&mut self, min: f32, val: &mut f32, max: f32, step: f32) -> bool

fn slider_int(&mut self, min: i32, val: &mut i32, max: i32, step: i32) -> bool

fn progress(&mut self, cur: &mut usize, max: usize, is_modifyable: bool) -> bool

fn prog(&mut self, cur: usize, max: usize, is_modifyable: bool) -> usize

fn color_picker(&mut self, color: NkColor, fmt: NkColorFormat) -> NkColor

fn color_pick(&mut self, fmt: NkColorFormat) -> (bool, NkColor)

fn property_int(&mut self,
                name: NkString,
                min: i32,
                val: &mut i32,
                max: i32,
                step: i32,
                inc_per_pixel: f32)

fn property_float(&mut self,
                  name: NkString,
                  min: f32,
                  val: &mut f32,
                  max: f32,
                  step: f32,
                  inc_per_pixel: f32)

fn property_double(&mut self,
                   name: NkString,
                   min: f64,
                   val: &mut f64,
                   max: f64,
                   step: f64,
                   inc_per_pixel: f32)

fn propertyi(&mut self,
             name: NkString,
             min: i32,
             val: i32,
             max: i32,
             step: i32,
             inc_per_pixel: f32)
             -> i32

fn propertyf(&mut self,
             name: NkString,
             min: f32,
             val: f32,
             max: f32,
             step: f32,
             inc_per_pixel: f32)
             -> f32

fn propertyd(&mut self,
             name: NkString,
             min: f64,
             val: f64,
             max: f64,
             step: f64,
             inc_per_pixel: f32)
             -> f64

fn edit_string_custom_filter(&mut self,
                             flags: NkFlags,
                             buffer: &mut [u8],
                             len: &mut i32,
                             filter: fn(_: NkTextEdit, _: char) -> bool)
                             -> NkFlags

fn edit_string(&mut self,
               flags: NkFlags,
               buffer: &mut [u8],
               len: &mut i32,
               filter: NkPluginFilter)
               -> NkFlags

fn edit_buffer(&mut self,
               flags: NkFlags,
               editor: &NkTextEdit,
               filter: NkPluginFilter)
               -> NkFlags

fn chart_begin(&mut self, ty: NkChartType, num: i32, min: f32, max: f32) -> bool

fn chart_begin_colored(&mut self,
                       ty: NkChartType,
                       color: NkColor,
                       active: NkColor,
                       num: i32,
                       min: f32,
                       max: f32)
                       -> bool

fn chart_add_slot(&mut self,
                  ty: NkChartType,
                  count: i32,
                  min_value: f32,
                  max_value: f32)

fn chart_add_slot_colored(&mut self,
                          ty: NkChartType,
                          color: NkColor,
                          active: NkColor,
                          count: i32,
                          min_value: f32,
                          max_value: f32)

fn chart_push(&mut self, value: f32) -> NkFlags

fn chart_push_slot(&mut self, value: f32, count: i32) -> nk_flags

fn chart_end(&mut self)

fn plot(&mut self, ty: NkChartType, values: &[f32])

fn popup_begin(&mut self,
               ty: NkPopupType,
               title: NkString,
               flags: NkFlags,
               bounds: NkRect)
               -> bool

fn popup_close(&mut self)

fn popup_end(&mut self)

fn combo(&mut self,
         items: &mut NkStringArray,
         selected: i32,
         item_height: i32,
         size: NkVec2)
         -> i32

fn combo_separator(&mut self,
                   items_separated_by_separator: NkString,
                   separator: char,
                   selected: i32,
                   item_height: i32,
                   size: NkVec2)
                   -> i32

fn combo_begin_label(&mut self, selected: NkString, size: NkVec2) -> bool

fn combo_begin_text(&mut self, selected: &str, size: NkVec2) -> bool

fn combo_begin_color(&mut self, color: NkColor, size: NkVec2) -> bool

fn combo_begin_symbol(&mut self, sym: NkSymbolType, size: NkVec2) -> bool

fn combo_begin_symbol_label(&mut self,
                            label: NkString,
                            sym: NkSymbolType,
                            size: NkVec2)
                            -> bool

fn combo_begin_symbol_text(&mut self,
                           label: &str,
                           sym: NkSymbolType,
                           size: NkVec2)
                           -> bool

fn combo_begin_image(&mut self, img: NkImage, size: NkVec2) -> bool

fn combo_begin_image_label(&mut self,
                           label: NkString,
                           img: NkImage,
                           size: NkVec2)
                           -> bool

fn combo_begin_image_text(&mut self,
                          label: &str,
                          img: NkImage,
                          size: NkVec2)
                          -> bool

fn combo_item_label(&mut self, label: NkString, alignment: NkFlags) -> bool

fn combo_item_text(&mut self, label: &str, alignment: NkFlags) -> bool

fn combo_item_image_label(&mut self,
                          img: NkImage,
                          label: NkString,
                          alignment: NkFlags)
                          -> bool

fn combo_item_image_text(&mut self,
                         img: NkImage,
                         label: &str,
                         alignment: NkFlags)
                         -> bool

fn combo_item_symbol_label(&mut self,
                           sym: NkSymbolType,
                           label: NkString,
                           alignment: NkFlags)
                           -> bool

fn combo_item_symbol_text(&mut self,
                          sym: NkSymbolType,
                          label: &str,
                          alignment: NkFlags)
                          -> bool

fn combo_close(&mut self)

fn combo_end(&mut self)

fn contextual_begin(&mut self,
                    flags: NkFlags,
                    bounds: NkVec2,
                    trigger_bounds: NkRect)
                    -> bool

fn contextual_item_label(&mut self, label: NkString, align: NkFlags) -> bool

fn contextual_item_text(&mut self, label: &str, align: NkFlags) -> bool

fn contextual_item_image_label(&mut self,
                               img: NkImage,
                               label: NkString,
                               align: NkFlags)
                               -> bool

fn contextual_item_image_text(&mut self,
                              img: NkImage,
                              label: &str,
                              align: NkFlags)
                              -> bool

fn contextual_item_symbol_label(&mut self,
                                sym: NkSymbolType,
                                label: NkString,
                                align: NkFlags)
                                -> bool

fn contextual_item_symbol_text(&mut self,
                               sym: NkSymbolType,
                               label: &str,
                               align: NkFlags)
                               -> bool

fn contextual_close(&mut self)

fn contextual_end(&mut self)

fn tooltip(&mut self, text: NkString)

fn tooltip_begin(&mut self, width: f32) -> bool

fn tooltip_end(&mut self)

fn menubar_begin(&mut self)

fn menubar_end(&mut self)

fn menu_begin_label(&mut self,
                    title: NkString,
                    align: NkFlags,
                    size: NkVec2)
                    -> bool

fn menu_begin_text(&mut self, title: &str, align: NkFlags, size: NkVec2) -> bool

fn menu_begin_image(&mut self,
                    title: NkString,
                    img: NkImage,
                    size: NkVec2)
                    -> bool

fn menu_begin_image_label(&mut self,
                          title: NkString,
                          align: NkFlags,
                          img: NkImage,
                          size: NkVec2)
                          -> bool

fn menu_begin_image_text(&mut self,
                         title: &str,
                         align: NkFlags,
                         img: NkImage,
                         size: NkVec2)
                         -> bool

fn menu_begin_symbol(&mut self,
                     title: NkString,
                     sym: NkSymbolType,
                     size: NkVec2)
                     -> bool

fn menu_begin_symbol_label(&mut self,
                           title: NkString,
                           align: NkFlags,
                           sym: NkSymbolType,
                           size: NkVec2)
                           -> bool

fn menu_begin_symbol_text(&mut self,
                          title: &str,
                          align: NkFlags,
                          sym: NkSymbolType,
                          size: NkVec2)
                          -> bool

fn menu_item_label(&mut self, title: NkString, align: NkFlags) -> bool

fn menu_item_text(&mut self, title: &str, align: NkFlags) -> bool

fn menu_item_image_label(&mut self,
                         img: NkImage,
                         title: NkString,
                         align: NkFlags)
                         -> bool

fn menu_item_image_text(&mut self,
                        img: NkImage,
                        title: &str,
                        align: NkFlags)
                        -> bool

fn menu_item_symbol_label(&mut self,
                          sym: NkSymbolType,
                          title: NkString,
                          align: NkFlags)
                          -> bool

fn menu_item_symbol_text(&mut self,
                         sym: NkSymbolType,
                         title: &str,
                         align: NkFlags)
                         -> bool

fn menu_close(&mut self)

fn menu_end(&mut self)

fn convert(&mut self,
           cmds: &mut NkBuffer,
           vertices: &mut NkBuffer,
           elements: &mut NkBuffer,
           config: &NkConvertConfig)

fn input_begin(&mut self)

fn input_motion(&mut self, x: i32, y: i32)

fn input_key(&mut self, key: NkKey, down: bool)

fn input_button(&mut self, b: NkButton, x: i32, y: i32, down: bool)

fn input_scroll(&mut self, y: f32)

fn input_char(&mut self, c: u8)

fn input_glyph(&mut self, g: NkGlyph)

fn input_unicode(&mut self, r: char)

fn input_end(&mut self)

fn style_default(&mut self)

fn style_from_table(&mut self, table: &NkColorMap)

fn style_load_cursor(&mut self, cur: NkStyleCursor, res: NkCursor)

fn style_load_all_cursors(&mut self, table: &mut NkCursorMap)

fn style_set_font(&mut self, font: &NkUserFont)

fn style_set_cursor(&mut self, cur: NkStyleCursor) -> bool

fn style_show_cursor(&mut self)

fn style_hide_cursor(&mut self)

fn style_push_font(&mut self, font: &mut NkUserFont) -> bool

fn style_push_float(&mut self, addr: &mut f32, val: f32) -> bool

fn style_push_vec2(&mut self, addr: &mut NkVec2, val: NkVec2) -> bool

fn style_push_style_item(&mut self,
                         addr: &mut NkStyleItem,
                         val: NkStyleItem)
                         -> bool

fn style_push_flags(&mut self, addr: &mut NkFlags, val: NkFlags) -> bool

fn style_push_color(&mut self, addr: &mut NkColor, val: NkColor) -> bool

fn style_pop_font(&mut self) -> bool

fn style_pop_float(&mut self) -> bool

fn style_pop_vec2(&mut self) -> bool

fn style_pop_style_item(&mut self) -> bool

fn style_pop_flags(&mut self) -> bool

fn style_pop_color(&mut self) -> bool

fn widget_bounds(&mut self) -> NkRect

fn widget_position(&mut self) -> NkVec2

fn widget_size(&mut self) -> NkVec2

fn widget_width(&mut self) -> f32

fn widget_height(&mut self) -> f32

fn widget_is_hovered(&mut self) -> bool

fn widget_is_mouse_clicked(&mut self, b: NkButton) -> bool

fn widget_has_mouse_click_down(&mut self, b: NkButton, down: bool) -> bool

fn widget(&self, arg1: &mut NkRect) -> NkWidgetLayoutState

fn spacing(&mut self, cols: i32)

fn draw_begin(&self, buf: &NkBuffer) -> Option<NkDrawCommand>

fn draw_next(&self,
             prev: &NkDrawCommand,
             buf: &NkBuffer)
             -> Option<NkDrawCommand>

fn next_cmd(&mut self, arg2: &NkCommand) -> Option<NkCommand>

fn begin_cmd(&mut self) -> Option<NkCommand>

fn draw_command_iterator<'a>(&'a mut self,
                             buf: &'a NkBuffer)
                             -> NkDrawCommandIterator<'a>

fn command_iterator<'a>(&'a mut self) -> NkCommandIterator<'a>

Trait Implementations

impl Default for NkContext

fn default() -> Self

Returns the "default value" for a type.