Example #1
0
        public override void Draw(Canvas canvas, IGuiDrawer drawer)
        {
            var panel_border_size = _layout.NavigatorPanelBorder;

            canvas.SetColor(Palette.WhiteColor);

            canvas.Text(DrawX + _layout.NavigatorFrameLabelOffsetX, DrawY + _layout.NavigatorFrameLabelOffsetY, $"Frame: {_current_source_rect.W}x{_current_source_rect.H}");

            canvas.SetColor(Palette.BlackColor);
            canvas.RectFill(DrawX, DrawY, Width, Height);

            canvas.Pixmap(CurrentSpritesheet, DrawX, DrawY, Rect.Empty, Width, Height);

            canvas.SetColor(Palette.WhiteColor);
            canvas.Rect(DrawX, DrawY, Width, Height, panel_border_size);

            var scale_factor = Width / CurrentSpritesheet.Width;

            canvas.Rect(
                (DrawX + _current_source_rect.X * scale_factor),
                (DrawY + _current_source_rect.Y * scale_factor),
                (_current_source_rect.W * scale_factor),
                (_current_source_rect.H * scale_factor),
                1 * scale_factor
                );

            canvas.SetColor(Palette.BlackColor);
            canvas.RectFill(
                x: DrawX - panel_border_size,
                y: DrawY + Height + panel_border_size,
                w: Width + panel_border_size * 2,
                h: panel_border_size);
        }
Example #2
0
        public override void Draw(Canvas blitter, IGuiDrawer drawer)
        {
            var icons_scale = AppLayout.Data.ToolBoxIconsScale;

            var idx = 0;

            var icon_shadow_offset = AppLayout.Data.ToolBoxIconsShadowOffset;

            blitter.SetSpriteSheet(_icons);

            foreach (var(index, tool_button) in _tool_buttons)
            {
                var icon_offset = 0;

                var rect = tool_button.Area;

                if (index == _current_pressed_action_index || index == _current_tool_index)
                {
                    icon_offset = icon_shadow_offset;
                }

                blitter.Sprite(
                    id: idx,
                    x: DrawX + rect.X,
                    y: DrawY + rect.Y + icon_shadow_offset,
                    tint: Palette.BlackColor,
                    scale: icons_scale
                    );
                blitter.Sprite(
                    id: idx,
                    x: DrawX + rect.X,
                    y: DrawY + rect.Y + icon_offset,
                    tint: _current_tool_index == index ? (byte)10 : Palette.NoColor,
                    scale: icons_scale
                    );

                ++idx;

                if (tool_button.Mode == ToolButton.ToolButtonMode.Tool && _current_tool_index == index)
                {
                    blitter.Sprite(
                        id: _down_arrow_sprite,
                        x: DrawX + rect.X,
                        y: DrawY - AppLayout.Data.ToolBoxPointerMargin + 2,
                        tint: Palette.BlackColor,
                        scale: icons_scale);

                    blitter.Sprite(
                        id: _down_arrow_sprite,
                        x: DrawX + rect.X,
                        y: DrawY - AppLayout.Data.ToolBoxPointerMargin,
                        tint: 10,
                        scale: icons_scale);
                }
            }
        }
Example #3
0
        public override void Draw(Canvas blitter, IGuiDrawer drawer)
        {
            if (DebugColor > 0)
            {
                blitter.SetColor(DebugColor);
                blitter.RectFill(DrawX, DrawY, Width, Height);
            }

            DrawChildren(blitter, drawer);
        }
Example #4
0
        protected void DrawChildren(IGuiDrawer drawer)
        {
            foreach (var widget in Children)
            {
                if (!widget.Visible)
                {
                    continue;
                }

                widget.Draw(drawer);
            }
        }
Example #5
0
        protected void DrawChildren(Canvas blitter, IGuiDrawer drawer)
        {
            foreach (var widget in Children)
            {
                if (!widget.Visible)
                {
                    continue;
                }

                widget.Draw(blitter, drawer);
            }
        }
Example #6
0
 public override void Draw(Canvas blitter, IGuiDrawer drawer)
 {
     DrawChildren(blitter, drawer);
 }
Example #7
0
        public override void Draw(IGuiDrawer drawer)
        {
            drawer.DrawPanel(this);

            DrawChildren(drawer);
        }
Example #8
0
        public override void Draw(Canvas blitter, IGuiDrawer drawer)
        {
            drawer.DrawPanel(blitter, this);

            DrawChildren(blitter, drawer);
        }
Example #9
0
 public override void Draw(IGuiDrawer drawer)
 {
     drawer.DrawListView(this);
 }
Example #10
0
 public void Add(IGuiDrawer drawer, bool shown = false)
 {
     _drawers.Add(drawer);
     _visibility.Add(shown);
 }
Example #11
0
 public override void Draw(IGuiDrawer drawer)
 {
     DrawChildren(drawer);
 }
Example #12
0
        public override void Draw(Canvas blitter, IGuiDrawer drawer)
        {
            blitter.BeginDraw(_current_palette);
            blitter.Clip(DrawX, DrawY, Width, Height);

            blitter.SetColor(Palette.WhiteColor);
            blitter.RectFill(DrawX, DrawY, Width, Height);

            blitter.SetColor(Palette.BlackColor);
            blitter.RectFill(
                x: DrawX,
                y: DrawY + Height,
                w: Width,
                h: PanelBorderSize);


            for (int i = 0; i < _color_cells.Length; ++i)
            {
                var cell = _color_cells[i];

                blitter.SetColor(cell.Color);
                blitter.RectFill(
                    DrawX + cell.Rect.X,
                    DrawY + cell.Rect.Y,
                    cell.Rect.W,
                    cell.Rect.H
                    );
            }

            // Draw current color cell bigger

            var current_cell      = _color_cells[CurrentColor];
            var current_cell_rect = new Rect(
                DrawX + current_cell.Rect.X - PanelBorderSize,
                DrawY + current_cell.Rect.Y - PanelBorderSize,
                current_cell.Rect.W + 2 * PanelBorderSize,
                current_cell.Rect.H + 2 * PanelBorderSize
                );

            blitter.SetColor(current_cell.Color);
            blitter.RectFill(
                current_cell_rect.X,
                current_cell_rect.Y,
                current_cell_rect.W,
                current_cell_rect.H
                );

            blitter.SetColor(Palette.WhiteColor);
            blitter.Rect(
                current_cell_rect.X,
                current_cell_rect.Y,
                current_cell_rect.W,
                current_cell_rect.H,
                PanelBorderSize
                );

            blitter.SetColor(Palette.BlackColor);
            blitter.RectFill(
                x: current_cell_rect.X - PanelBorderSize,
                y: current_cell_rect.Y + current_cell_rect.H + PanelBorderSize,
                w: current_cell_rect.W + PanelBorderSize * 2,
                h: PanelBorderSize);


            var transparent_col_cell = _color_cells[0];

            blitter.SetColor(Palette.WhiteColor);
            blitter.Rect
            (
                DrawX + transparent_col_cell.Rect.X + transparent_col_cell.Rect.W / 2 - 2,
                DrawY + transparent_col_cell.Rect.Y + transparent_col_cell.Rect.H / 2 - 2,
                w: 4,
                h: 4,
                line_size: 1
            );

            blitter.Clip();
            blitter.EndDraw();

            DrawChildren(blitter, drawer);
        }
Example #13
0
 public override void Draw(Canvas blitter, IGuiDrawer drawer)
 {
     drawer.DrawSelectorSlider(blitter, this);
 }
Example #14
0
 public override void Draw(Canvas blitter, IGuiDrawer drawer)
 {
     drawer.DrawListView(blitter, this);
 }
Example #15
0
 public override void Draw(IGuiDrawer drawer)
 {
     drawer.DrawSelectorSlider(this);
 }
Example #16
0
        public override void Draw(Canvas blitter, IGuiDrawer drawer)
        {
            var source_rect           = _sprite_source_rect;
            var scale_factor          = (float)Width / CurrentSpritesheet.Width;
            var source_surface_factor = CurrentSpritesheet.Width / source_rect.W;
            var final_scale           = (int)scale_factor * source_surface_factor;
            var brush_size            = CurrentTool.BrushSize;
            var cursor_x           = (int)(DrawX + Calc.Snap(_mouse_x, brush_size * final_scale));
            var cursor_y           = (int)(DrawY + Calc.Snap(_mouse_y, brush_size * final_scale));
            var cursor_border_size = _layout.EditorCursorBorder;
            var panel_border_size  = _layout.EditorPanelBorder;

            DrawSpriteSheet();

            DrawBorders();

            /* ========================================= */
            /* SELECT MODE */
            /* ========================================= */

            if (!SelectionEmpty())
            {
                DrawSelectElements();
            }

            DrawOverlay();

            if (_mouse_inside && CurrentTool.ShowCursor)
            {
                DrawCursor();
            }

            /* ========================================= */
            /* DRAW ELEMENTS IMPLEMENTATION */
            /* ========================================= */

            void DrawSpriteSheet()
            {
                blitter.SetColor(2);
                blitter.RectFill(DrawX, DrawY, Width, Height);

                blitter.Pixmap(CurrentSpritesheet, DrawX, DrawY, source_rect, Width, Height);
            }

            void DrawOverlay()
            {
                blitter.Pixmap(_overlay_surface, DrawX, DrawY, Rect.Empty);
                blitter.SetColor(Palette.WhiteColor);
                blitter.Text(DrawX + _layout.EditorMousePosLabelOffsetX, DrawY + _layout.EditorMousePosLabelOffsetY, $"{_tool_action_params.PaintX},{_tool_action_params.PaintY}");
            }

            void DrawSelectElements()
            {
                blitter.SetSurface(_overlay_surface);

                blitter.Clear();

                if (_selection_surface_filled)
                {
                    var selection_source_rect = GetGlobalSelectionRect();

                    blitter.Pixmap(_select_surface,
                                   (_select_translate_x) * final_scale,
                                   (_select_translate_y) * final_scale,
                                   selection_source_rect,
                                   _select_width * final_scale,
                                   _select_height * final_scale);
                }

                _dashed_rect.Draw(
                    blitter,
                    _select_translate_x * final_scale,
                    _select_translate_y * final_scale,
                    _select_width * final_scale,
                    _select_height * final_scale
                    );

                blitter.SetSurface(null);
            }

            void DrawCursor()
            {
                blitter.SetColor(Palette.BlackColor);
                blitter.Rect(
                    (cursor_x + cursor_border_size),
                    (cursor_y + cursor_border_size),
                    ((brush_size * final_scale) - cursor_border_size * 2),
                    ((brush_size * final_scale) - cursor_border_size * 2),
                    cursor_border_size);

                blitter.SetColor(Palette.WhiteColor);
                blitter.Rect(cursor_x, cursor_y, (brush_size * final_scale), (brush_size * final_scale), cursor_border_size);
            }

            void DrawBorders()
            {
                blitter.SetColor(Palette.WhiteColor);
                blitter.Rect(
                    DrawX,
                    DrawY,
                    Width,
                    Height,
                    panel_border_size
                    );

                blitter.SetColor(Palette.BlackColor);
                blitter.RectFill(
                    x: DrawX - panel_border_size,
                    y: DrawY + Height + panel_border_size,
                    w: Width + panel_border_size * 2,
                    h: panel_border_size);
            }
        }