예제 #1
0
        public static void PropertyBehavior(ref uint ws, nk_input _in_, RectangleF property, RectangleF label,
                                            RectangleF edit,
                                            RectangleF empty, ref int state, nk_property_variant *variant, float inc_per_pixel)
        {
            if (_in_ != null && state == NK_PROPERTY_DEFAULT)
            {
                if (ButtonBehavior(ref ws, edit, _in_, NK_BUTTON_DEFAULT))
                {
                    state = NK_PROPERTY_EDIT;
                }
                else if (nk_input_is_mouse_click_down_in_rect(_in_, NK_BUTTON_LEFT, label, true))
                {
                    state = NK_PROPERTY_DRAG;
                }
                else if (nk_input_is_mouse_click_down_in_rect(_in_, NK_BUTTON_LEFT, empty, true))
                {
                    state = NK_PROPERTY_DRAG;
                }
            }

            if (state == NK_PROPERTY_DRAG)
            {
                DrawBehavior(ref ws, _in_, property, variant, inc_per_pixel);
                if ((ws & NK_WIDGET_STATE_ACTIVED) == 0)
                {
                    state = NK_PROPERTY_DEFAULT;
                }
            }
        }
예제 #2
0
        public static void DrawBehavior(ref uint state, nk_input _in_, RectangleF drag,
                                        nk_property_variant *variant,
                                        float inc_per_pixel)
        {
            var left_mouse_down =
                _in_ != null && _in_.mouse.buttons[NK_BUTTON_LEFT].down;
            var left_mouse_click_in_cursor =
                _in_ != null &&
                nk_input_has_mouse_click_down_in_rect(_in_, NK_BUTTON_LEFT, drag, true);

            if ((state & NK_WIDGET_STATE_MODIFIED) != 0)
            {
                state = NK_WIDGET_STATE_INACTIVE | NK_WIDGET_STATE_MODIFIED;
            }
            else
            {
                state = NK_WIDGET_STATE_INACTIVE;
            }
            if (nk_input_is_mouse_hovering_rect(_in_, drag))
            {
                state = NK_WIDGET_STATE_HOVERED;
            }
            if (left_mouse_down && left_mouse_click_in_cursor)
            {
                float delta;
                float pixels;
                pixels = _in_.mouse.delta.X;
                delta  = pixels * inc_per_pixel;
                switch (variant->kind)
                {
                case NK_PROPERTY_INT:
                    variant->value.i = variant->value.i + (int)delta;
                    variant->value.i =
                        (variant->value.i < variant->max_value.i
                                                                ? variant->value.i
                                                                : variant->max_value.i) <
                        variant->min_value.i
                                                                ? variant->min_value.i
                                                                : variant->value.i < variant->max_value.i
                                                                        ? variant->value.i
                                                                        : variant->max_value.i;
                    break;

                case NK_PROPERTY_FLOAT:
                    variant->value.f = variant->value.f + delta;
                    variant->value.f =
                        (variant->value.f < variant->max_value.f
                                                                ? variant->value.f
                                                                : variant->max_value.f) <
                        variant->min_value.f
                                                                ? variant->min_value.f
                                                                : variant->value.f < variant->max_value.f
                                                                        ? variant->value.f
                                                                        : variant->max_value.f;
                    break;

                case NK_PROPERTY_DOUBLE:
                    variant->value.d = variant->value.d + delta;
                    variant->value.d =
                        (variant->value.d < variant->max_value.d
                                                                ? variant->value.d
                                                                : variant->max_value.d) <
                        variant->min_value.d
                                                                ? variant->min_value.d
                                                                : variant->value.d < variant->max_value.d
                                                                        ? variant->value.d
                                                                        : variant->max_value.d;
                    break;
                }

                state = NK_WIDGET_STATE_ACTIVE;
            }

            if ((state & NK_WIDGET_STATE_HOVER) != 0 &&
                !nk_input_is_mouse_prev_hovering_rect(_in_, drag))
            {
                state |= NK_WIDGET_STATE_ENTERED;
            }
            else if (nk_input_is_mouse_prev_hovering_rect(_in_, drag))
            {
                state |= NK_WIDGET_STATE_LEFT;
            }
        }
예제 #3
0
        public static void Property(this NuklearContext ctx, string name, nk_property_variant *variant,
                                    float inc_per_pixel,
                                    int filter)
        {
            var    bounds = new RectangleF();
            uint   hash;
            string dummy_buffer       = null;
            var    dummy_state        = NK_PROPERTY_DEFAULT;
            var    dummy_cursor       = 0;
            var    dummy_select_begin = 0;
            var    dummy_select_end   = 0;

            if (ctx == null || ctx.current == null || ctx.current.Layout == null)
            {
                return;
            }
            var win    = ctx.current;
            var layout = win.Layout;
            var style  = ctx.style;
            var s      = ctx.Widget(ref bounds);

            if (s == 0)
            {
                return;
            }
            if (name[0] == '#')
            {
                hash = nk_murmur_hash(name, win.Property.seq++);
                name = name + 1;
            }
            else
            {
                hash = nk_murmur_hash(name, 42);
            }

            var _in_ = s == NK_WIDGET_ROM && win.Property.active == 0 || (layout.Flags & NK_WINDOW_ROM) != 0
                                ? null
                                : ctx.input;

            int    old_state, state;
            string buffer;
            int    cursor, select_begin, select_end;

            if (win.Property.active != 0 && hash == win.Property.name)
            {
                old_state = win.Property.state;
                DoProperty(ref ctx.last_widget_state, win.Buffer, bounds, name, variant, inc_per_pixel,
                           ref win.Property.buffer, ref win.Property.state, ref win.Property.cursor,
                           ref win.Property.select_start, ref win.Property.select_end, style.property, filter, _in_,
                           style.font,
                           ctx.text_edit, ctx.button_behavior);
                state        = win.Property.state;
                buffer       = win.Property.buffer;
                cursor       = win.Property.cursor;
                select_begin = win.Property.select_start;
                select_end   = win.Property.select_end;
            }
            else
            {
                old_state = dummy_state;
                DoProperty(ref ctx.last_widget_state, win.Buffer, bounds, name, variant, inc_per_pixel,
                           ref dummy_buffer, ref dummy_state, ref dummy_cursor,
                           ref dummy_select_begin, ref dummy_select_end, style.property, filter, _in_, style.font,
                           ctx.text_edit, ctx.button_behavior);
                state        = dummy_state;
                buffer       = dummy_buffer;
                cursor       = dummy_cursor;
                select_begin = dummy_select_begin;
                select_end   = dummy_select_end;
            }

            ctx.text_edit.Clip = ctx.clip;
            if (_in_ != null && state != NK_PROPERTY_DEFAULT && win.Property.active == 0)
            {
                win.Property.active       = 1;
                win.Property.buffer       = buffer;
                win.Property.cursor       = cursor;
                win.Property.state        = state;
                win.Property.name         = hash;
                win.Property.select_start = select_begin;
                win.Property.select_end   = select_end;
                if (state == NK_PROPERTY_DRAG)
                {
                    ctx.input.mouse.grab    = nk_true;
                    ctx.input.mouse.grabbed = nk_true;
                }
            }

            if (state == NK_PROPERTY_DEFAULT && old_state != NK_PROPERTY_DEFAULT)
            {
                if (old_state == NK_PROPERTY_DRAG)
                {
                    ctx.input.mouse.grab    = nk_false;
                    ctx.input.mouse.grabbed = nk_false;
                    ctx.input.mouse.ungrab  = nk_true;
                }

                win.Property.select_start = 0;
                win.Property.select_end   = 0;
                win.Property.active       = 0;
            }
        }
예제 #4
0
        public static void DoProperty(ref uint ws, CommandBuffer _out_, RectangleF property, string name,
                                      nk_property_variant *variant, float inc_per_pixel, ref string buffer, ref int state, ref int cursor,
                                      ref int select_begin, ref int select_end, nk_style_property style, int filter, nk_input _in_,
                                      nk_font font,
                                      nk_text_edit text_edit, int behavior)
        {
            var filters = new NkPluginFilter[2];

            filters[0] = nk_filter_decimal;
            filters[1] = nk_filter_float;

            bool   active;
            int    old;
            float  size;
            string dst   = null;
            var    left  = new RectangleF();
            var    right = new RectangleF();
            var    label = new RectangleF();
            var    edit  = new RectangleF();
            var    empty = new RectangleF();

            left.Height  = font.Size / 2;
            left.Width   = left.Height;
            left.X       = property.X + style.border + style.padding.X;
            left.Y       = property.Y + style.border + property.Height / 2.0f - left.Height / 2;
            size         = font.width(name);
            label.X      = left.X + left.Width + style.padding.X;
            label.Width  = size + 2 * style.padding.X;
            label.Y      = property.Y + style.border + style.padding.Y;
            label.Height = property.Height - (2 * style.border + 2 * style.padding.Y);
            right.Y      = left.Y;
            right.Width  = left.Width;
            right.Height = left.Height;
            right.X      = property.X + property.Width - (right.Width + style.padding.X);
            if (state == NK_PROPERTY_EDIT)
            {
                size = font.width(buffer);

                size += style.edit.Cursor_size;
                dst   = buffer;
            }
            else
            {
                var _string_ = string.Empty;
                switch (variant->kind)
                {
                case NK_PROPERTY_INT:
                    _string_ = variant->value.i.ToString();
                    break;

                case NK_PROPERTY_FLOAT:
                    _string_ = variant->value.f.ToString();
                    break;

                case NK_PROPERTY_DOUBLE:
                    _string_ = variant->value.d.ToString();
                    break;
                }

                size = font.width(_string_);
                dst  = _string_;
            }

            edit.Width = size + 2 * style.padding.X;
            edit.Width = edit.Width < right.X - (label.X + label.Width)
                                ? edit.Width
                                : right.X - (label.X + label.Width);
            edit.X       = right.X - (edit.Width + style.padding.X);
            edit.Y       = property.Y + style.border;
            edit.Height  = property.Height - 2 * style.border;
            empty.Width  = edit.X - (label.X + label.Width);
            empty.X      = label.X + label.Width;
            empty.Y      = property.Y;
            empty.Height = property.Height;
            old          = state == NK_PROPERTY_EDIT ? 1 : 0;
            PropertyBehavior(ref ws, _in_, property, label, edit,
                             empty,
                             ref state, variant, inc_per_pixel);
            if (style.draw_begin != null)
            {
                style.draw_begin(_out_);
            }
            _out_.DrawProperty(style, &property, &label, ws, name, font);
            if (style.draw_end != null)
            {
                style.draw_end(_out_);
            }
            if (
                DoButtonSymbol(ref ws, _out_, left, style.sym_left, behavior,
                               style.dec_button,
                               _in_, font))
            {
                switch (variant->kind)
                {
                case NK_PROPERTY_INT:
                    variant->value.i =
                        (variant->value.i - variant->step.i < variant->max_value.i
                                                                ? variant->value.i - variant->step.i
                                                                : variant->max_value.i) < variant->min_value.i
                                                                ? variant->min_value.i
                                                                : variant->value.i - variant->step.i < variant->max_value.i
                                                                        ? variant->value.i - variant->step.i
                                                                        : variant->max_value.i;
                    break;

                case NK_PROPERTY_FLOAT:
                    variant->value.f =
                        (variant->value.f - variant->step.f < variant->max_value.f
                                                                ? variant->value.f - variant->step.f
                                                                : variant->max_value.f) < variant->min_value.f
                                                                ? variant->min_value.f
                                                                : variant->value.f - variant->step.f < variant->max_value.f
                                                                        ? variant->value.f - variant->step.f
                                                                        : variant->max_value.f;
                    break;

                case NK_PROPERTY_DOUBLE:
                    variant->value.d =
                        (variant->value.d - variant->step.d < variant->max_value.d
                                                                ? variant->value.d - variant->step.d
                                                                : variant->max_value.d) < variant->min_value.d
                                                                ? variant->min_value.d
                                                                : variant->value.d - variant->step.d < variant->max_value.d
                                                                        ? variant->value.d - variant->step.d
                                                                        : variant->max_value.d;
                    break;
                }
            }

            if (
                DoButtonSymbol(ref ws, _out_, right, style.sym_right, behavior,
                               style.inc_button,
                               _in_, font))
            {
                switch (variant->kind)
                {
                case NK_PROPERTY_INT:
                    variant->value.i =
                        (variant->value.i + variant->step.i < variant->max_value.i
                                                                ? variant->value.i + variant->step.i
                                                                : variant->max_value.i) < variant->min_value.i
                                                                ? variant->min_value.i
                                                                : variant->value.i + variant->step.i < variant->max_value.i
                                                                        ? variant->value.i + variant->step.i
                                                                        : variant->max_value.i;
                    break;

                case NK_PROPERTY_FLOAT:
                    variant->value.f =
                        (variant->value.f + variant->step.f < variant->max_value.f
                                                                ? variant->value.f + variant->step.f
                                                                : variant->max_value.f) < variant->min_value.f
                                                                ? variant->min_value.f
                                                                : variant->value.f + variant->step.f < variant->max_value.f
                                                                        ? variant->value.f + variant->step.f
                                                                        : variant->max_value.f;
                    break;

                case NK_PROPERTY_DOUBLE:
                    variant->value.d =
                        (variant->value.d + variant->step.d < variant->max_value.d
                                                                ? variant->value.d + variant->step.d
                                                                : variant->max_value.d) < variant->min_value.d
                                                                ? variant->min_value.d
                                                                : variant->value.d + variant->step.d < variant->max_value.d
                                                                        ? variant->value.d + variant->step.d
                                                                        : variant->max_value.d;
                    break;
                }
            }

            if (old != NK_PROPERTY_EDIT && state == NK_PROPERTY_EDIT)
            {
                buffer = dst;
                cursor = buffer != null ? buffer.Length : 0;
                active = false;
            }
            else
            {
                active = state == NK_PROPERTY_EDIT;
            }

            nk_textedit_clear_state(text_edit, NK_TEXT_EDIT_SINGLE_LINE, filters[filter]);
            text_edit.Active = active;

            text_edit.Text.str = dst;

            var length = dst != null ? dst.Length : 0;

            text_edit.Cursor =
                (cursor < length ? cursor : length) < 0
                                        ? 0
                                        : cursor < length
                                                ? cursor
                                                : length;
            text_edit.SelectionStart =
                (select_begin < length ? select_begin : length) < 0
                                        ? 0
                                        : select_begin < length
                                                ? select_begin
                                                : length;
            text_edit.SelectionEnd =
                (select_end < length ? select_end : length) < 0
                                        ? 0
                                        : select_end < length
                                                ? select_end
                                                : length;
            text_edit.Mode = NK_TEXT_EDIT_MODE_INSERT;
            DoEdit(ref ws, _out_, edit, NK_EDIT_FIELD | NK_EDIT_AUTO_SELECT,
                   filters[filter], text_edit,
                   style.edit, state == NK_PROPERTY_EDIT ? _in_ : null, font);
            cursor       = text_edit.Cursor;
            select_begin = text_edit.SelectionStart;
            select_end   = text_edit.SelectionEnd;
            if (text_edit.Active && nk_input_is_key_pressed(_in_, NK_KEY_ENTER))
            {
                text_edit.Active = false;
            }
            if (active && !text_edit.Active)
            {
                state = NK_PROPERTY_DEFAULT;

                switch (variant->kind)
                {
                case NK_PROPERTY_INT:
                    int.TryParse(buffer, out variant->value.i);
                    variant->value.i =
                        (variant->value.i < variant->max_value.i
                                                                ? variant->value.i
                                                                : variant->max_value.i) <
                        variant->min_value.i
                                                                ? variant->min_value.i
                                                                : variant->value.i < variant->max_value.i
                                                                        ? variant->value.i
                                                                        : variant->max_value.i;
                    break;

                case NK_PROPERTY_FLOAT:
                    float.TryParse(buffer, out variant->value.f);
                    variant->value.f =
                        (variant->value.f < variant->max_value.f
                                                                ? variant->value.f
                                                                : variant->max_value.f) <
                        variant->min_value.f
                                                                ? variant->min_value.f
                                                                : variant->value.f < variant->max_value.f
                                                                        ? variant->value.f
                                                                        : variant->max_value.f;
                    break;

                case NK_PROPERTY_DOUBLE:
                    double.TryParse(buffer, out variant->value.d);
                    variant->value.d =
                        (variant->value.d < variant->max_value.d
                                                                ? variant->value.d
                                                                : variant->max_value.d) <
                        variant->min_value.d
                                                                ? variant->min_value.d
                                                                : variant->value.d < variant->max_value.d
                                                                        ? variant->value.d
                                                                        : variant->max_value.d;
                    break;
                }
            }
        }
예제 #5
0
        public static void nk_property_(nk_context ctx, char *name, nk_property_variant *variant, float inc_per_pixel,
                                        int filter)
        {
            var    bounds = new nk_rect();
            uint   hash;
            string dummy_buffer       = null;
            var    dummy_state        = NK_PROPERTY_DEFAULT;
            var    dummy_cursor       = 0;
            var    dummy_select_begin = 0;
            var    dummy_select_end   = 0;

            if ((ctx == null) || (ctx.current == null) || (ctx.current.layout == null))
            {
                return;
            }
            var win    = ctx.current;
            var layout = win.layout;
            var style  = ctx.style;
            var s      = nk_widget(&bounds, ctx);

            if (s == 0)
            {
                return;
            }
            if (name[0] == '#')
            {
                hash = nk_murmur_hash(name, nk_strlen(name), win.property.seq++);
                name++;
            }
            else
            {
                hash = nk_murmur_hash(name, nk_strlen(name), 42);
            }

            var _in_ = ((s == NK_WIDGET_ROM) && (win.property.active == 0)) || ((layout.flags & NK_WINDOW_ROM) != 0)
                                ? null
                                : ctx.input;

            int    old_state, state;
            string buffer;
            int    cursor, select_begin, select_end;

            if ((win.property.active != 0) && (hash == win.property.name))
            {
                old_state = win.property.state;
                nk_do_property(ref ctx.last_widget_state, win.buffer, bounds, name, variant, inc_per_pixel,
                               ref win.property.buffer, ref win.property.state, ref win.property.cursor,
                               ref win.property.select_start, ref win.property.select_end, style.property, filter, _in_, style.font,
                               ctx.text_edit, ctx.button_behavior);
                state        = win.property.state;
                buffer       = win.property.buffer;
                cursor       = win.property.cursor;
                select_begin = win.property.select_start;
                select_end   = win.property.select_end;
            }
            else
            {
                old_state = dummy_state;
                nk_do_property(ref ctx.last_widget_state, win.buffer, bounds, name, variant, inc_per_pixel,
                               ref dummy_buffer, ref dummy_state, ref dummy_cursor,
                               ref dummy_select_begin, ref dummy_select_end, style.property, filter, _in_, style.font,
                               ctx.text_edit, ctx.button_behavior);
                state        = dummy_state;
                buffer       = dummy_buffer;
                cursor       = dummy_cursor;
                select_begin = dummy_select_begin;
                select_end   = dummy_select_end;
            }

            ctx.text_edit.clip = ctx.clip;
            if ((_in_ != null) && (state != NK_PROPERTY_DEFAULT) && (win.property.active == 0))
            {
                win.property.active       = 1;
                win.property.buffer       = buffer;
                win.property.cursor       = cursor;
                win.property.state        = state;
                win.property.name         = hash;
                win.property.select_start = select_begin;
                win.property.select_end   = select_end;
                if (state == NK_PROPERTY_DRAG)
                {
                    ctx.input.mouse.grab    = nk_true;
                    ctx.input.mouse.grabbed = nk_true;
                }
            }

            if ((state == NK_PROPERTY_DEFAULT) && (old_state != NK_PROPERTY_DEFAULT))
            {
                if (old_state == NK_PROPERTY_DRAG)
                {
                    ctx.input.mouse.grab    = nk_false;
                    ctx.input.mouse.grabbed = nk_false;
                    ctx.input.mouse.ungrab  = nk_true;
                }
                win.property.select_start = 0;
                win.property.select_end   = 0;
                win.property.active       = 0;
            }
        }