aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Popups/MethodPopup.cs
blob: 7c431f9b4ddb9c633005c3f40a882f376e9f642f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Tango.Scripting.Editors.Popups
{
    public class MethodPopup : Control
    {
        public List<MethodDescription> Methods { get; set; }

        public int CurrentMethodIndex
        {
            get { return (int)GetValue(CurrentMethodIndexProperty); }
            set { SetValue(CurrentMethodIndexProperty, value); }
        }
        public static readonly DependencyProperty CurrentMethodIndexProperty =
            DependencyProperty.Register("CurrentMethodIndex", typeof(int), typeof(MethodPopup), new PropertyMetadata(1));

        public MethodDescription CurrentMethod
        {
            get { return (MethodDescription)GetValue(CurrentMethodProperty); }
            set { SetValue(CurrentMethodProperty, value); }
        }
        public static readonly DependencyProperty CurrentMethodProperty =
            DependencyProperty.Register("CurrentMethod", typeof(MethodDescription), typeof(MethodPopup), new PropertyMetadata(null));

        public void IncrementMethod()
        {
            if (Methods.Count > 0)
            {
                if (CurrentMethodIndex < Methods.Count)
                {
                    CurrentMethodIndex++;
                    CurrentMethod = Methods[CurrentMethodIndex - 1];
                }
                else
                {
                    CurrentMethodIndex = 1;
                    CurrentMethod = Methods[0];
                }
            }
        }

        public void DecrementMethod()
        {
            if (Methods.Count > 0)
            {
                if (CurrentMethodIndex > 1)
                {
                    CurrentMethodIndex--;
                    CurrentMethod = Methods[CurrentMethodIndex - 1];
                }
                else
                {
                    CurrentMethodIndex = Methods.Count;
                    CurrentMethod = Methods[Methods.Count - 1];
                }
            }
        }

        public MethodPopup()
        {
            Methods = new List<MethodDescription>();
        }

        static MethodPopup()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(MethodPopup), new FrameworkPropertyMetadata(typeof(MethodPopup)));
        }
    }
}
n class="w"> /// <summary> /// Gets whether this segment is connected to a TextSegmentCollection and will automatically /// update its offsets. /// </summary> protected bool IsConnectedToCollection { get { return ownerTree != null; } } /// <summary> /// Gets/Sets the start offset of the segment. /// </summary> /// <remarks> /// When setting the start offset, the end offset will change, too: the Length of the segment will stay constant. /// </remarks> public int StartOffset { get { // If the segment is not connected to a tree, we store the offset in "nodeLength". // Otherwise, "nodeLength" contains the distance to the start offset of the previous node Debug.Assert(!(ownerTree == null && parent != null)); Debug.Assert(!(ownerTree == null && left != null)); TextSegment n = this; int offset = n.nodeLength; if (n.left != null) offset += n.left.totalNodeLength; while (n.parent != null) { if (n == n.parent.right) { if (n.parent.left != null) offset += n.parent.left.totalNodeLength; offset += n.parent.nodeLength; } n = n.parent; } return offset; } set { if (value < 0) throw new ArgumentOutOfRangeException("value", "Offset must not be negative"); if (this.StartOffset != value) { // need a copy of the variable because ownerTree.Remove() sets this.ownerTree to null ISegmentTree ownerTree = this.ownerTree; if (ownerTree != null) { ownerTree.Remove(this); nodeLength = value; ownerTree.Add(this); } else { nodeLength = value; } OnSegmentChanged(); } } } /// <summary> /// Gets/Sets the end offset of the segment. /// </summary> /// <remarks> /// Setting the end offset will change the length, the start offset will stay constant. /// </remarks> public int EndOffset { get { return StartOffset + Length; } set { int newLength = value - StartOffset; if (newLength < 0) throw new ArgumentOutOfRangeException("value", "EndOffset must be greater or equal to StartOffset"); Length = newLength; } } /// <summary> /// Gets/Sets the length of the segment. /// </summary> /// <remarks> /// Setting the length will change the end offset, the start offset will stay constant. /// </remarks> public int Length { get { return segmentLength; } set { if (value < 0) throw new ArgumentOutOfRangeException("value", "Length must not be negative"); if (segmentLength != value) { segmentLength = value; if (ownerTree != null) ownerTree.UpdateAugmentedData(this); OnSegmentChanged(); } } } /// <summary> /// This method gets called when the StartOffset/Length/EndOffset properties are set. /// It is not called when StartOffset/Length/EndOffset change due to document changes /// </summary> protected virtual void OnSegmentChanged() { } internal TextSegment LeftMost { get { TextSegment node = this; while (node.left != null) node = node.left; return node; } } internal TextSegment RightMost { get { TextSegment node = this; while (node.right != null) node = node.right; return node; } } /// <summary> /// Gets the inorder successor of the node. /// </summary> internal TextSegment Successor { get { if (right != null) { return right.LeftMost; } else { TextSegment node = this; TextSegment oldNode; do { oldNode = node; node = node.parent; // go up until we are coming out of a left subtree } while (node != null && node.right == oldNode); return node; } } } /// <summary> /// Gets the inorder predecessor of the node. /// </summary> internal TextSegment Predecessor { get { if (left != null) { return left.RightMost; } else { TextSegment node = this; TextSegment oldNode; do { oldNode = node; node = node.parent; // go up until we are coming out of a right subtree } while (node != null && node.left == oldNode); return node; } } } #if DEBUG internal string ToDebugString() { return "[nodeLength=" + nodeLength + " totalNodeLength=" + totalNodeLength + " distanceToMaxEnd=" + distanceToMaxEnd + " MaxEndOffset=" + (StartOffset + distanceToMaxEnd) + "]"; } #endif /// <inheritdoc/> public override string ToString() { return "[" + GetType().Name + " Offset=" + StartOffset + " Length=" + Length + " EndOffset=" + EndOffset + "]"; } } }