Esempio n. 1
0
 public virtual void UpdateStat()
 {
     RetailSum             = Lines.Sum(x => x.RetailSum);
     SupplierSumWithoutNds = Lines.Sum(x => x.SupplierSumWithoutNds);
     SupplierSum           = Lines.Sum(x => x.SupplierSum);
     PosCount = Lines.Count();
 }
Esempio n. 2
0
 public void Calculate()
 {
     Total   = Lines.Sum(l => l.TotalExpense);
     Average = Total / Lines.Count();
     foreach (SharingLine line in Lines)
     {
         line.CalculateDebt(Average);
     }
 }
Esempio n. 3
0
        private void HandleControlKeyDown(object sender, KeyEventArgs e)
        {
            e.Handled = true;

            if (Keys.V == e.KeyCode)
            {
                VerifySelectionForTextInsert();

                string input = Clipboard.GetText(TextDataFormat.Text);
                InsertUserInput(input);
            }
            else if (Keys.C == e.KeyCode)
            {
                Copy();
            }
            else if (Keys.X == e.KeyCode)
            {
                Cut();
                if ((SelectionStart + SelectionLength) > _promptPosition)
                {
                    FlushInputBuffer();
                }
            }
            else if (Keys.Home == e.KeyCode)
            {
                SelectionStart = 0;
                ScrollToCaret();
            }
            else if (Keys.End == e.KeyCode)
            {
                SelectionStart = EndOfLinePosition;
                ScrollToCaret();
            }
            else if (Keys.Up == e.KeyCode)
            {
                int lineIndex = GetLineFromCharIndex(SelectionStart);
                lineIndex = Math.Max(0, lineIndex - 1);
                int charIndex = GetFirstCharIndexFromLine(lineIndex);
                Select(charIndex, 0);
                ScrollToCaret();
            }
            else if (Keys.Down == e.KeyCode)
            {
                int lineIndex = GetLineFromCharIndex(SelectionStart);
                lineIndex = Math.Min(Lines.Count() - 1, lineIndex + 1);
                int charIndex = GetFirstCharIndexFromLine(lineIndex);
                Select(charIndex, 0);
                ScrollToCaret();
            }
            else
            {
                e.Handled = false;
            }
        }
Esempio n. 4
0
 public bool NextLine()
 {
     if (Lines.Count() <= lineCount + 1)
     {
         lineCount++;
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 5
0
 public void SelectLastLine()
 {
     if (Lines.Any())
     {
         var line = Lines.Count() - 1;
         var s1   = GetFirstCharIndexOfCurrentLine();
         var s2   = line < Lines.Count() - 1 ?
                    GetFirstCharIndexFromLine(line + 1) - 1 :
                    Text.Length;
         Select(s1, s2 - s1);
     }
 }
        public MarkupString ToMarkupString()
        {
            List <string> retInfo = new List <string>();

            retInfo.Add($"Scene Key: {SceneKey}");
            retInfo.Add($"Scene Line Count: {Lines.Count()}");
            retInfo.Add($"Scene Action Count: {Actions.Count()}");
            foreach (var action in Actions)
            {
                retInfo.Add(action.ToString());
            }

            return((MarkupString)string.Join("<br />", retInfo));
        }
        /// <summary>
        ///     Processes all lines in the text box
        /// </summary>
        /// <param name="force">Forces the recoloring of all lines.
        /// Otherwise, already colored lines are not processed again</param>
        public void ProcessAllLines(bool force = false)
        {
            if (ApplyPatterns)
            {
                CanPaint = false;

                if (Lines.Count() < 300)
                {
                    if (force)
                    {
                        _processedLines.Clear();
                    }

                    int lineNumber = 0;
                    int start      = 0;
                    foreach (string line in Lines)
                    {
                        lineNumber = lineNumber + 1;
                        if (!_processedLines.Contains(lineNumber))
                        {
                            ProcessLine(start, line);
                            _processedLines.Add(lineNumber);
                        }

                        start = start + line.Length + 1;
                    }
                }
                else
                {
                    // For longer text, it takes too much time to apply to coloring algorithm.
                    // Don't color anything in that case
                    int   savedSelectionStart  = SelectionStart;
                    int   savedSelectionLength = SelectionLength;
                    Color savedSelectionColor  = SelectionBackColor;

                    SelectionStart  = 0;
                    SelectionLength = TextLength;
                    SelectionColor  = Color.Black;
                    SelectionFont   = RegularFont;

                    SelectionStart  = savedSelectionStart;
                    SelectionLength = savedSelectionLength;
                    SelectionColor  = savedSelectionColor;
                }
                CanPaint = true;
            }
        }
Esempio n. 8
0
 public void ApplyQuantityDiscounts()
 {
     //Assumption here - one discount per order line, and only the best one gets counted.
     foreach (var orderLine in Lines)
     {
         var validDiscount = Discounts.FirstOrDefault(d =>
                                                      Lines.Count() >= d.QuantityRequired && orderLine.BaseLinePrice >= d.QualifyingPrice);
         if (validDiscount != null)
         {
             orderLine.AdjustedLinePrice = orderLine.BaseLinePrice * validDiscount.Multiplier;
         }
         else
         {
             orderLine.AdjustedLinePrice = orderLine.BaseLinePrice;
         }
     }
 }
Esempio n. 9
0
 public Location GetChoppingBoardLocation()
 {
     for (int i = 0; i < Lines.Count(); i++)
     {
         for (int j = 0; j < Lines[i].Count(); j++)
         {
             if (Lines[i][j].Equals('C'))
             {
                 return(new Location
                 {
                     X = j,
                     Y = i
                 });
             }
         }
     }
     return(null);
 }
Esempio n. 10
0
 public Location GetStrawberriesLocation()
 {
     for (int i = 0; i < Lines.Count(); i++)
     {
         for (int j = 0; j < Lines[i].Count(); j++)
         {
             if (Lines[i][j].Equals('S'))
             {
                 return(new Location
                 {
                     X = j,
                     Y = i
                 });
             }
         }
     }
     return(null);
 }
Esempio n. 11
0
 public Location GetIcecreamLocation()
 {
     for (int i = 0; i < Lines.Count(); i++)
     {
         for (int j = 0; j < Lines[i].Count(); j++)
         {
             if (Lines[i][j].Equals('I'))
             {
                 return(new Location
                 {
                     X = j,
                     Y = i
                 });
             }
         }
     }
     return(null);
 }
Esempio n. 12
0
        void SelectCurrentLine()
        {
            if (Lines == null || !Lines.Any())
            {
                return;
            }

            for (int i = 0; i < Lines.Count(); i++)
            {
                if (Lines.ElementAt(i).LineNumber == LineNumber)
                {
                    RTB.Document.Blocks.ElementAt(i).Background = _currentMatchedLineBackgroundBrush;
                    break;
                }
                else
                {
                    RTB.Document.Blocks.ElementAt(i).Background = null;
                }
            }
        }
Esempio n. 13
0
        public override string Solve()
        {
            List <int[][]> puzzles = new List <int[][]>();

            for (int i = 1; i < Lines.Count(); i += 10) // 9 lines for puzzle + 1 for header
            {
                // take 9 lines of puzzle, for each line get each column and convert to digit
                int[][] puzzle = Lines.Skip(i).Take(9).Select(x => x.Trim().Select(c => c - '0').ToArray()).ToArray();
                puzzles.Add(puzzle);
            }

            int counter = 0;

            foreach (int[][] puzzle in puzzles)
            {
                SudokuSolver.SudokuSolver.Solve(puzzle);
                counter += puzzle[0][0] * 100 + puzzle[0][1] * 10 + puzzle[0][2];
            }

            return(counter.ToString(CultureInfo.InvariantCulture));
        }
Esempio n. 14
0
        public void BeginGetAll(Func <IMarkGeometry, bool> callback)
        {
            Parallel.For(0, Points.Count(),
                         index =>
            {
                callback(Points[index]);
            }
                         );

            Parallel.For(0, Lines.Count(),
                         index =>
            {
                callback(Lines[index]);
            }
                         );

            Parallel.For(0, Arcs.Count(),
                         index =>
            {
                callback(Arcs[index]);
            }
                         );

            Parallel.For(0, Circles.Count(),
                         index =>
            {
                callback(Circles[index]);
            }
                         );

            Parallel.For(0, Paths.Count(),
                         index =>
            {
                callback(Paths[index]);
            }
                         );
        }
Esempio n. 15
0
        /// <summary>
        ///     Applies function to all geometries
        /// </summary>
        /// <param name="function">The function apply to all geometries</param>
        public void MapFunc(Func <IMarkGeometry, IMarkGeometry> function)
        {
            Parallel.For(0, Points.Count(),
                         index =>
            {
                Points[index] = function(Points[index]) as MarkGeometryPoint;
            }
                         );

            Parallel.For(0, Lines.Count(),
                         index =>
            {
                Lines[index] = function(Lines[index]) as MarkGeometryLine;
            }
                         );

            Parallel.For(0, Arcs.Count(),
                         index =>
            {
                Arcs[index] = function(Arcs[index]) as MarkGeometryArc;
            }
                         );

            Parallel.For(0, Circles.Count(),
                         index =>
            {
                Circles[index] = function(Circles[index]) as MarkGeometryCircle;
            }
                         );

            Parallel.For(0, Paths.Count(),
                         index =>
            {
                Paths[index] = function(Paths[index]) as MarkGeometryPath;
            }
                         );
        }
 public virtual void UpdateStat()
 {
     SupplierSum = Lines.Sum(x => x.SupplierSum);
     PosCount    = Lines.Count();
 }
Esempio n. 17
0
        /// <summary>
        /// Check if operation is same as previous operation 
        /// If previous operation is move node (by arrow forexample) is better group operation like one big move instead of many small moves.
        /// </summary>
        public bool isSame(string type, Nodes nodes, Lines lines)
        {
            if (operations.Count()>0)
            {

                UndoOperation operation = operations.First();

                if (operation.type == type)
                {

                    if (operation.nodes.Count() == 0 && nodes == null)
                    {
                    }
                    else if ((operation.nodes == null && nodes != null) || (operation.nodes != null && nodes == null))
                    {
                        return false;
                    }
                    else if (operation.nodes.Count() == nodes.Count())
                    {
                        for (int i = 0; i < nodes.Count(); i++)
                        {
                            if (operation.nodes[i].id != nodes[i].id)
                            {
                                return false;
                            }
                        }
                    }
                    else
                    {
                        return false;
                    }

                    if (operation.lines.Count() == 0 && lines == null)
                    {
                    }
                    else if ((operation.lines == null && lines != null) || (operation.lines != null && lines == null))
                    {
                        return false;
                    }
                    else if (operation.lines.Count() == lines.Count())
                    {
                        for (int i = 0; i < lines.Count(); i++)
                        {
                            if (operation.lines[i].start != lines[i].start || operation.lines[i].end != lines[i].end)
                            {
                                return false;
                            }
                        }
                    }
                    else
                    {
                        return false;
                    }

                    return true;
                }
            }

            return false;
        }
Esempio n. 18
0
        public override void SetExtents()
        {
            Extents.MinX = double.MaxValue;
            Extents.MaxX = double.MinValue;

            Extents.MinY = double.MaxValue;
            Extents.MaxY = double.MinValue;

            Extents.MinZ = double.MaxValue;
            Extents.MaxZ = double.MinValue;

            int[] ns =
            {
                Points.Count(),
                Arcs.Count(),
                Circles.Count(),
                Lines.Count(),
                Paths.Count()
            };

            int n = GeometricArithmeticModule.Max <int>(ns);

            for (int i = 0; i < n; i++)
            {
                if (i < Points.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Points[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Points[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Points[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Points[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Points[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Points[i].Extents.MinZ);
                }

                if (i < Arcs.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Arcs[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Arcs[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Arcs[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Arcs[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Arcs[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Arcs[i].Extents.MinZ);
                }

                if (i < Circles.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Circles[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Circles[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Circles[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Circles[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Circles[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Circles[i].Extents.MinZ);
                }

                if (i < Lines.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Lines[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Lines[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Lines[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Lines[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Lines[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Lines[i].Extents.MinZ);
                }

                if (i < Paths.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Paths[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Paths[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Paths[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Paths[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Paths[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Paths[i].Extents.MinZ);
                }
            }

            GridWidth  = Extents.MaxX - Extents.MinX;
            GridHeight = Extents.MaxY - Extents.MinY;
            GridDepth  = Extents.MaxZ - Extents.MinZ;

            Origin = new MarkGeometryPoint(
                Extents.MinX + (0.5 * GridWidth),
                Extents.MinY + (0.5 * GridHeight),
                Extents.MinZ + (0.5 * GridDepth)
                );
        }
Esempio n. 19
0
        // EVENT Mouse Up                                                                              // [MOUSE] [UP] [EVENT]
        public void DiagramApp_MouseUp(object sender, MouseEventArgs e)
        {
            #if DEBUG
            this.logEvent("MouseUp");
            #endif

            this.actualMousePos.set(e.X, e.Y);
            Position mouseTranslation = new Position(this.actualMousePos).subtract(this.startMousePos);

            // States
            bool mousemove = ((this.actualMousePos.x != this.startMousePos.x) || (this.actualMousePos.y != this.startMousePos.y)); // mouse change position
            bool buttonleft = e.Button == MouseButtons.Left;
            bool buttonright = e.Button == MouseButtons.Right;
            bool buttonmiddle = e.Button == MouseButtons.Middle;
            bool isreadonly = this.diagram.options.readOnly;
            bool keyalt = this.keyalt;
            bool keyctrl = this.keyctrl;
            bool keyshift = this.keyshift;
            bool dblclick = this.stateDblclick;
            bool finishdraging = this.stateDragSelection;
            bool finishadding = this.stateAddingNode;
            bool finishselecting = mousemove && this.stateSelectingNodes;

            MoveTimer.Enabled = false;

            if(dblclick)
            {
                this.stateSelectingNodes = false;
            }
            else
            // KEY DRAG
            if (finishdraging) // drag node
            {
                if (!this.diagram.options.readOnly)
                {
                    if (this.sourceNode != null && !keyctrl) // return node to starting position after connection is created
                    {
                        Position translation = new Position(this.startNodePos)
                            .subtract(sourceNode.position);

                        if (this.selectedNodes.Count > 0)
                        {
                            foreach (Node node in this.selectedNodes)
                            {
                                node.position.add(translation);
                            }
                        }

                        this.diagram.InvalidateDiagram();
                    }
                }
            }
            else
            // KEY DRAG-MMIDDLE
            if (finishadding)
            {
                this.diagram.InvalidateDiagram();
            }
            else
            // KEY DRAG+MLEFT select nodes with selection rectangle
            if (finishselecting)
            {
                if (mousemove)
                {
                    Position a = new Position(this.startMousePos)
                        .scale(this.scale)
                        .add(this.shift)
                        .subtract(this.startShift);

                    Position b = new Position(this.actualMousePos)
                        .scale(this.scale);

                    int temp;
                    if (b.x < a.x) { temp = a.x; a.x = b.x; b.x = temp; }
                    if (b.y < a.y) { temp = b.y; b.y = a.y; a.y = temp; }

                    if (!this.keyshift) this.ClearSelection();
                    foreach (Node rec in this.currentLayer.nodes)
                    {
                        if (
                            (rec.layer == this.currentLayer.id || rec.id == this.currentLayer.id)
                            && -this.shift.x + a.x <= rec.position.x
                            && rec.position.x + rec.width <= -this.shift.x + b.x
                            && -this.shift.y + a.y <= rec.position.y
                            && rec.position.y + rec.height <= -this.shift.y + b.y) // get all nodes in selection rectangle
                        {
                            if (keyshift && !keyctrl && !keyalt) // KEY SHIFT+MLEFT Invert selection
                            {
                                if (rec.selected)
                                {
                                    this.RemoveNodeFromSelection(rec);
                                }
                                else
                                {
                                    this.SelectNode(rec);
                                }
                            }

                            if (!keyshift && !keyctrl && !keyalt) // KEY MLEFT select nodes
                            {
                                this.SelectNode(rec);
                            }
                        }
                    }

                    this.diagram.InvalidateDiagram();
                }
            }

            Node TargetNode = this.findNodeInMousePosition(new Position(e.X, e.Y));

            if (buttonleft) // MLEFT
            {

                if (!keyalt && keyctrl && !keyshift && TargetNode != null && TargetNode.selected) // CTRL+CLICK add node to selection
                {
                    this.RemoveNodeFromSelection(TargetNode);
                    this.diagram.InvalidateDiagram();
                }
                else
                if (!keyalt && keyctrl && !keyshift && TargetNode != null && !TargetNode.selected) // CTRL+CLICK remove node from selection
                {
                    this.SelectNode(TargetNode);
                    this.diagram.InvalidateDiagram();
                }
                else
                if (this.stateCoping && mousemove) // CTRL+DRAG copy part of diagram
                {
                    this.stateCoping = false;

                    DiagramBlock newBlock = this.diagram.duplicatePartOfDiagram(this.selectedNodes, this.currentLayer.id);

                    Position vector = new Position(this.actualMousePos)
                        .scale(this.scale)
                        .subtract(this.vmouse)
                        .subtract(this.shift)
                        .subtract(this.sourceNode.position);

                    // filter only top nodes fromm all new created nodes. NewNodes containing sublayer nodes.
                    Nodes topNodes = new Nodes();

                    foreach (Node node in newBlock.nodes)
                    {
                        if (node.layer == this.currentLayer.id)
                        {
                            topNodes.Add(node);
                        }
                    }

                    foreach (Node node in topNodes)
                    {
                        node.position.add(vector);
                    }

                    this.diagram.unsave("create", newBlock.nodes, newBlock.lines);

                    this.SelectNodes(topNodes);

                    this.diagram.unsave();
                    this.diagram.InvalidateDiagram();
                }
                else
                if (bottomScrollBar != null
                    && rightScrollBar != null
                    && (bottomScrollBar.MouseUp() || rightScrollBar.MouseUp()))
                {
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY MLEFT clear selection
                if (!mousemove
                    && TargetNode == null
                    && this.sourceNode == null
                    && this.selectedNodes.Count() > 0
                    && !keyalt
                    && !keyctrl
                    && !keyshift)
                {
                    this.ClearSelection();
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY CTRL+ALT+DRAG create node and conect with existing node
                if (!isreadonly
                    && !keyshift
                    && keyctrl
                    && keyalt
                    && TargetNode == null
                    && this.sourceNode != null)
                {
                    var s = this.sourceNode;
                    var node = this.CreateNode(new Position(e.X, e.Y));
                    node.shortcut = s.id;
                    this.diagram.Connect(s, node);
                    this.diagram.unsave("create", node, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY CTRL+ALT+DRAG create shortcut beetwen objects
                if (!isreadonly
                    && !keyshift
                    && keyctrl
                    && keyalt
                    && TargetNode != null
                    && this.sourceNode != null
                    && TargetNode != this.sourceNode)
                {
                    this.diagram.unsave("edit", this.sourceNode, this.shift, this.currentLayer.id);
                    this.sourceNode.link = "#" + TargetNode.id.ToString();
                    this.diagram.unsave();
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY DRAG move node
                if
                (
                    !isreadonly
                    && (
                        (TargetNode == null && this.sourceNode != null)
                        || (
                            TargetNode != null
                            && this.sourceNode != TargetNode
                            && TargetNode.selected
                        )
                        || (TargetNode != null && this.sourceNode == TargetNode)
                    )
                    && Math.Sqrt(mouseTranslation.x * mouseTranslation.x + mouseTranslation.y * mouseTranslation.y) > 5
                )
                {
                    Position vector = new Position(this.actualMousePos)
                        .scale(this.scale)
                        .subtract(this.vmouse)
                        .subtract(this.shift)
                        .subtract(this.sourceNode.position);

                    if (this.selectedNodes.Count > 0)
                    {
                        this.diagram.undoOperations.add("edit", this.selectedNodes, null, this.shift, this.currentLayer.id);

                        foreach (Node node in this.selectedNodes)
                        {
                            node.position.add(vector);
                        }

                        this.diagram.unsave();
                    }

                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY DRAG+CTRL create node and conect with existing node
                if (!isreadonly
                    && !keyshift
                    && !keyctrl
                    && keyalt
                    && TargetNode != null
                    && this.sourceNode == null)
                {
                    Node node = this.CreateNode(
                            new Position(
                                +this.shift.x - startShift.x + this.startMousePos.x,
                                +this.shift.y - startShift.y + this.startMousePos.y
                            )
                        );

                    Line line = this.diagram.Connect(
                        node,
                        TargetNode
                    );

                    this.diagram.unsave("create", node, line, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY CTRL+ALT+DRAG create node and make shortcut to target node
                if (!isreadonly
                    && keyalt
                    && keyctrl
                    && !keyshift
                    && TargetNode != null
                    && this.sourceNode == null)
                {
                    Node newrec = this.CreateNode(
                        new Position(this.shift).subtract(startShift).add(this.startMousePos)
                    );

                    newrec.link = "#" + TargetNode.id;
                    this.diagram.unsave("create", newrec, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY DBLCLICK open link or edit window after double click on node [dblclick] [open] [edit]
                if (dblclick
                    && this.sourceNode != null
                    && !keyctrl
                    && !keyalt
                    && !keyshift)
                {
                    this.resetStates();
                    this.OpenLinkAsync(this.sourceNode);
                }
                else
                // KEY SHIFT+DBLCLICK open node edit form
                if (dblclick
                    && this.sourceNode != null
                    && !keyctrl
                    && !keyalt
                    && keyshift)
                {
                    this.diagram.EditNode(this.sourceNode);
                }
                else
                // KEY CTRL+DBLCLICK open link in node
                if (dblclick
                    && this.sourceNode != null
                    && keyctrl
                    && !keyalt
                    && !keyshift)
                {
                    if (this.sourceNode.link != "")
                    {
                        Os.openPathInSystem(this.sourceNode.link);
                    }
                }
                else
                // KEY DBLCLICK+SPACE change position in zoom view mode
                if (this.stateZooming
                    && dblclick
                    && !keyctrl
                    && !keyalt
                    && !keyshift)
                {
                    this.shift
                        .subtract(
                            this.actualMousePos
                            .clone()
                            .scale(this.scale)
                            )
                        .add(
                            (this.ClientSize.Width * this.scale) / 2,
                            (this.ClientSize.Height * this.scale) / 2
                        );
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY CTRL+SHIFT+MLEFT conect with selected nodes new node or selected node
                if (!isreadonly
                    && keyshift
                    && keyctrl
                    && this.selectedNodes.Count() > 0
                    && e.X == this.startMousePos.x
                    && e.Y == this.startMousePos.y)
                {
                    // TODO Still working this?
                    Node newrec = TargetNode;

                    Nodes newNodes = new Nodes();
                    if (newrec == null)
                    {
                        newrec = this.CreateNode(this.actualMousePos.clone().subtract(10), false);
                        newNodes.Add(newrec);
                    }

                    Lines newLines = new Lines();
                    foreach (Node rec in this.selectedNodes)
                    {
                        Line line = this.diagram.Connect(rec, newrec);
                        newLines.Add(line);
                    }

                    this.SelectOnlyOneNode(newrec);
                    this.diagram.unsave("create", newNodes, newLines, this.shift, this.currentLayer.id);
                }
                else
                // KEY ALT+MLEFT
                // KEY DBLCLICK create new node
                if (!isreadonly
                    && (dblclick || keyalt)
                    && !keyshift
                    && !keyctrl
                    && TargetNode == null
                    && this.sourceNode == null
                    && e.X == this.startMousePos.x
                    && e.Y == this.startMousePos.y)
                {
                    Node newNode = this.CreateNode(this.actualMousePos.clone().subtract(10), false);
                    this.diagram.unsave("create", newNode, this.shift, this.currentLayer.id);
                }
                else
                // KEY DRAG+ALT copy style from node to other node
                if (!isreadonly
                    && !keyshift
                    && !keyctrl
                    && keyalt
                    && TargetNode != null
                    && this.sourceNode != null
                    && this.sourceNode != TargetNode)
                {
                    if (this.selectedNodes.Count() > 1)
                    {
                        this.diagram.undoOperations.add("edit", this.selectedNodes, null, this.shift, this.currentLayer.id);
                        foreach (Node rec in this.selectedNodes)
                        {
                            rec.copyNodeStyle(TargetNode);
                        }
                        this.diagram.unsave();
                    }

                    if (this.selectedNodes.Count() == 1
                        || (this.selectedNodes.Count() == 0 && this.sourceNode != null))
                    {
                        this.diagram.undoOperations.add("edit", TargetNode, this.shift, this.currentLayer.id);

                        TargetNode.copyNodeStyle(this.sourceNode);

                        if (this.selectedNodes.Count() == 1 && this.selectedNodes[0] != this.sourceNode)
                        {
                            this.ClearSelection();
                            this.SelectNode(this.sourceNode);
                        }
                        this.diagram.unsave();
                    }
                }
                else
                // KEY DRAG make link between two nodes
                if (!isreadonly
                    && !keyctrl
                    && !keyalt
                    && TargetNode != null
                    && this.sourceNode != null
                    && this.sourceNode != TargetNode)
                {
                    bool arrow = false;
                    if (keyshift)
                    {
                        arrow = true;
                    }

                    Lines newLines = new Lines();
                    Lines removeLines = new Lines();
                    if (this.selectedNodes.Count() > 0)
                    {
                        foreach (Node rec in this.selectedNodes)
                        {
                            if (rec != TargetNode)
                            {
                                if (this.diagram.hasConnection(rec, TargetNode))
                                {
                                    Line removeLine = this.diagram.getLine(rec, TargetNode);
                                    removeLines.Add(removeLine);
                                    this.diagram.Disconnect(rec, TargetNode);

                                }
                                else
                                {
                                    Line newLine = this.diagram.Connect(rec, TargetNode, arrow, null);
                                    newLines.Add(newLine);
                                }
                            }
                        }
                    }

                    if (newLines.Count() > 0 && removeLines.Count() > 0)
                    {
                        this.diagram.undoOperations.startGroup();
                        this.diagram.undoOperations.add("create", null, newLines, this.shift, this.currentLayer.id);
                        this.diagram.undoOperations.add("delete", null, removeLines, this.shift, this.currentLayer.id);
                        this.diagram.undoOperations.endGroup();
                        this.diagram.unsave();
                    }
                    else if (newLines.Count() > 0)
                    {
                        this.diagram.undoOperations.add("create", null, newLines, this.shift, this.currentLayer.id);
                    }
                    else if (removeLines.Count() > 0)
                    {
                        this.diagram.undoOperations.add("delete", null, removeLines, this.shift, this.currentLayer.id);
                    }

                    this.diagram.InvalidateDiagram();
                }
                // KEY SHIFT+MLEFT add node to selected nodes
                else
                if (!keyctrl
                    && keyshift
                    && !keyalt
                    && this.sourceNode == TargetNode
                    && TargetNode != null
                    && !TargetNode.selected)
                {
                    this.SelectNode(TargetNode);
                    this.diagram.InvalidateDiagram();
                }
                // KEY SHIFT+MLEFT remove node from selected nodes
                else
                if (!keyctrl
                    && keyshift
                    && !keyalt
                    && TargetNode != null
                    && (this.sourceNode == TargetNode || TargetNode.selected))
                {
                    this.RemoveNodeFromSelection(TargetNode);
                    this.diagram.InvalidateDiagram();
                }
                else
                if (this.sourceNode == TargetNode
                    && this.stateSourceNodeAlreadySelected)
                {
                    this.rename();
                }

            }
            else
            if (buttonright) // KEY MRIGHT
            {
                this.stateMoveView = false; // show popup menu
                if (e.X == this.startMousePos.x
                    && e.Y == this.startMousePos.y
                    && this.startShift.x == this.shift.x
                    && this.startShift.y == this.shift.y)
                {
                    Node temp = this.findNodeInMousePosition(new Position(e.X, e.Y));

                    if (temp == null || (this.sourceNode != temp && !temp.selected))
                    {
                        this.ClearSelection();
                        this.SelectOnlyOneNode(temp);
                    }

                    this.diagram.InvalidateDiagram();
                    PopupMenu.Show(this.Left + e.X, this.Top + e.Y); // [POPUP] show popup
                }
                else { // KEY DRAG+MRIGHT move view
                    this.shift.x = (int)(this.startShift.x + (e.X - this.startMousePos.x) * this.scale);
                    this.shift.y = (int)(this.startShift.y + (e.Y - this.startMousePos.y) * this.scale);
                    this.diagram.InvalidateDiagram();
                }
            }
            else
            if (buttonmiddle) // MMIDDLE
            {
                // KEY DRAG+MMIDDLE conect two existing nodes
                if (this.sourceNode != null && TargetNode != null) {

                    Line newLine = this.diagram.Connect(
                        sourceNode,
                        TargetNode
                    );

                    if (newLine != null) {
                        this.diagram.unsave("create", newLine, this.shift, this.currentLayer.id);
                        this.diagram.InvalidateDiagram();
                    }
                }
                else
                // KEY DRAG+MMIDDLE connect exixting node with new node
                if (this.sourceNode != null && TargetNode == null)
                {

                    Node newNode = this.CreateNode(this.actualMousePos.clone().subtract(10));

                    Line newLine = this.diagram.Connect(
                        sourceNode,
                        newNode
                    );

                    this.diagram.unsave("create", newNode, newLine, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY DRAG+MMIDDLE create new node and conect id with existing node
                if (!isreadonly && TargetNode != null)
                {
                    Node newNode = this.CreateNode(
                        (new Position(this.shift)).subtract(this.startShift).add(this.startMousePos)
                    );

                    Line newLine = this.diagram.Connect(
                        newNode,
                        TargetNode
                    );

                    this.diagram.unsave("create", newNode, newLine, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
                else
                // KEY DRAG+MMIDDLE create new node and conect with new node (create line)
                if (!isreadonly && TargetNode == null)
                {
                    Nodes nodes = new Nodes();
                    Lines lines = new Lines();

                    Node node1 = this.CreateNode(
                            (new Position(this.shift)).subtract(this.startShift).add(this.startMousePos),
                            false
                        );

                    nodes.Add(node1);

                    Node node2 = this.CreateNode(
                        this.actualMousePos.clone().subtract(10)
                    );

                    nodes.Add(node2);

                    lines.Add(this.diagram.Connect(
                        node1,
                        node2
                    ));

                    this.diagram.unsave("create", nodes, lines, this.shift, this.currentLayer.id);
                    this.diagram.InvalidateDiagram();
                }
            }

            this.resetStates();
        }
Esempio n. 20
0
        private void FConsole_KeyDown(object sender, KeyEventArgs e)
        {
            if (State == ConsoleState.Closing)
            {
                e.SuppressKeyPress = true;
                return;
            }

            if ((e.KeyCode == Keys.Up || e.KeyCode == Keys.Down) && State == ConsoleState.ReadLine)
            {
                if (recentlist.Count != 0)
                {
                    var recentText = string.Empty;
                    if (e.KeyCode == Keys.Up)
                    {
                        recentText = RecentUndo();
                    }
                    else if (e.KeyCode == Keys.Down)
                    {
                        recentText = RecentRedo();
                    }
                    SelectLastLine();
                    SelectedText = recentText;
                }
                e.SuppressKeyPress = true;
                return;
            }
            else
            {
                Select(TextLength, 0);
                if (e.KeyData == (Keys.Control | Keys.V))
                {
                    MultiplePaste();
                    e.SuppressKeyPress = true;
                }
                else if ((int)e.KeyCode == (int)Keys.Enter && InputEnable == true && State == ConsoleState.ReadLine)
                {
                    Cursor      = Cursors.WaitCursor;
                    ReadOnly    = true;
                    CurrentLine = Lines[Lines.Count() - 1];
                    recentlist.Add(CurrentLine);
                    WriteLine("");
                    InputEnable        = false;
                    e.SuppressKeyPress = true;
                }
                else if (InputEnable == true && State == ConsoleState.ReadKey)
                {
                    ReadOnly    = true;
                    CurrentKey  = (char)e.KeyCode;
                    InputEnable = false;
                }
                else if ((int)e.KeyCode == (int)Keys.Escape && InputEnable == false)//esc exit
                {
                    Pause = false;
                }
                else if ((int)e.KeyCode == (int)Keys.Space && InputEnable == false)//space pause
                {
                    Pause = !Pause;
                }
                else if ((int)e.KeyCode == (int)Keys.Back && InputEnable == true && ReadPoint + 1 > TextLength)
                {
                    e.SuppressKeyPress = true;
                }
            }
        }