Esempio n. 1
0
        private void UseTool(List <Coordinates> mouseMoveCords, BitmapOperationTool tool, Color color)
        {
            if (Keyboard.IsKeyDown(Key.LeftShift) && !MouseCordsNotInLine(mouseMoveCords))
            {
                mouseMoveCords = GetSquareCoordiantes(mouseMoveCords);
            }

            if (!tool.RequiresPreviewLayer)
            {
                LayerChange[] modifiedLayers  = tool.Use(Manager.ActiveLayer, mouseMoveCords.ToArray(), color);
                LayerChange[] oldPixelsValues = new LayerChange[modifiedLayers.Length];
                for (int i = 0; i < modifiedLayers.Length; i++)
                {
                    Layer layer = Manager.ActiveDocument.Layers.First(x => x.LayerGuid == modifiedLayers[i].LayerGuid);
                    oldPixelsValues[i] = ApplyToLayer(layer, modifiedLayers[i]);

                    BitmapChanged?.Invoke(this, new BitmapChangedEventArgs(
                                              modifiedLayers[i].PixelChanges,
                                              oldPixelsValues[i].PixelChanges,
                                              modifiedLayers[i].LayerGuid));
                }
            }
            else
            {
                UseToolOnPreviewLayer(mouseMoveCords, tool.ClearPreviewLayerOnEachIteration);
            }
        }
Esempio n. 2
0
        /// <summary>
        ///     Executes tool Use() method with given parameters. NOTE: mouseMove is reversed inside function!
        /// </summary>
        /// <param name="newPos">Most recent coordinates</param>
        /// <param name="mouseMove">Last mouse movement coordinates</param>
        /// <param name="tool">Tool to execute</param>
        public void ExecuteTool(Coordinates newPos, List <Coordinates> mouseMove, BitmapOperationTool tool)
        {
            if (Manager.ActiveDocument != null && tool != null && tool.ToolType != ToolType.None)
            {
                if (Manager.ActiveDocument.Layers.Count == 0 || mouseMove.Count == 0)
                {
                    return;
                }
                mouseMove.Reverse();
                UseTool(mouseMove, tool, Manager.PrimaryColor);

                _lastMousePos = newPos;
            }
        }
        public void UseTool(IReadOnlyList <Coordinates> recordedMouseMovement, BitmapOperationTool tool, SKColor color)
        {
            if (Manager.ActiveDocument.Layers.Count == 0)
            {
                return;
            }

            if (!tool.RequiresPreviewLayer)
            {
                tool.Use(Manager.ActiveLayer, null, Manager.ActiveDocument.Layers, recordedMouseMovement, color);
                BitmapChanged?.Invoke(this, null);
            }
            else
            {
                UseToolOnPreviewLayer(recordedMouseMovement, tool.ClearPreviewLayerOnEachIteration);
            }
        }
Esempio n. 4
0
        private void UseTool(List <Coordinates> mouseMoveCords, BitmapOperationTool tool, Color color)
        {
            if (sizeSetting == null)
            {
                sizeSetting = tool.Toolbar.GetSetting <SizeSetting>("ToolSize");
            }

            int thickness = sizeSetting != null ? sizeSetting.Value : 1;

            bool shiftDown = Keyboard.IsKeyDown(Key.LeftShift);

            if (shiftDown && tool.UsesShift)
            {
                bool mouseInLine = MouseCordsNotInLine(mouseMoveCords, thickness);

                if (!mouseInLine)
                {
                    mouseMoveCords = GetSquareCoordiantes(mouseMoveCords);
                }
                else
                {
                    mouseMoveCords = GetLineCoordinates(mouseMoveCords, thickness);
                }
            }

            if (!tool.RequiresPreviewLayer)
            {
                LayerChange[] modifiedLayers  = tool.Use(Manager.ActiveLayer, mouseMoveCords, color);
                LayerChange[] oldPixelsValues = new LayerChange[modifiedLayers.Length];
                for (int i = 0; i < modifiedLayers.Length; i++)
                {
                    Layer layer = Manager.ActiveDocument.Layers.First(x => x.LayerGuid == modifiedLayers[i].LayerGuid);
                    oldPixelsValues[i] = ApplyToLayer(layer, modifiedLayers[i]);

                    BitmapChanged?.Invoke(this, new BitmapChangedEventArgs(
                                              modifiedLayers[i].PixelChanges,
                                              oldPixelsValues[i].PixelChanges,
                                              modifiedLayers[i].LayerGuid));
                }
            }
            else
            {
                UseToolOnPreviewLayer(mouseMoveCords, tool.ClearPreviewLayerOnEachIteration);
            }
        }