FastReport

1
using System;
2
using System.Collections.Generic;
3
using System.Text;
4
using FastReport.Table;
5

6
namespace FastReport.Matrix
7
{
8
    internal class MatrixHeaderItem : MatrixDescriptor
9
    {
10
        private MatrixHeaderItem parent;
11
        private List<MatrixHeaderItem> items;
12
        private object value;
13
        private int index;
14
        private bool isTotal;
15
        private int dataRowNo;
16
        private bool pageBreak;
17
        private bool isSplitted;
18

19
        public MatrixHeaderItem Parent
20
        {
21
            get { return parent; }
22
        }
23

24
        public List<MatrixHeaderItem> Items
25
        {
26
            get { return items; }
27
        }
28

29
        public object Value
30
        {
31
            get { return value; }
32
            set { this.value = value; }
33
        }
34

35
        public int Index
36
        {
37
            get { return index; }
38
            set { index = value; }
39
        }
40

41
        public int Span
42
        {
43
            get
44
            {
45
                List<MatrixHeaderItem> terminalItems = new List<MatrixHeaderItem>();
46
                GetTerminalItems(terminalItems);
47
                return terminalItems.Count;
48
            }
49
        }
50

51
        public bool IsTotal
52
        {
53
            get { return isTotal; }
54
            set { isTotal = value; }
55
        }
56

57
        public object[] Values
58
        {
59
            get
60
            {
61
                int count = 0;
62
                MatrixHeaderItem item = this;
63

64
                while (item.Parent != null)
65
                {
66
                    count++;
67
                    item = item.Parent;
68
                }
69

70
                object[] values = new object[count];
71
                item = this;
72
                int index = count - 1;
73

74
                while (item.Parent != null)
75
                {
76
                    values[index] = item.Value;
77
                    index--;
78
                    item = item.Parent;
79
                }
80

81
                return values;
82
            }
83
        }
84

85
        public int DataRowNo
86
        {
87
            get { return dataRowNo; }
88
            set { dataRowNo = value; }
89
        }
90

91
        public bool PageBreak
92
        {
93
            get { return pageBreak; }
94
            set { pageBreak = value; }
95
        }
96

97
        internal bool IsSplitted
98
        {
99
            get { return isSplitted; }
100
            set { isSplitted = value; }
101
        }
102

103
        public int Find(object value, SortOrder sort)
104
        {
105
            if (Items.Count == 0)
106
                return -1;
107

108
            if (sort == SortOrder.None)
109
            {
110
                for (int i = 0; i < Items.Count; i++)
111
                {
112
                    IComparable i1 = Items[i].Value as IComparable;
113

114
                    int result = 0;
115
                    if (i1 != null)
116
                        result = i1.CompareTo(value);
117
                    else if (value != null)
118
                        result = -1;
119

120
                    if (result == 0)
121
                        return i;
122
                }
123
                return ~Items.Count;
124
            }
125
            else
126
            {
127
                MatrixHeaderItem header = new MatrixHeaderItem(null);
128
                header.Value = value;
129
                return Items.BinarySearch(header, new HeaderComparer(sort));
130
            }
131
        }
132

133
        public void Clear()
134
        {
135
            Items.Clear();
136
        }
137

138
        private void GetTerminalItems(List<MatrixHeaderItem> list)
139
        {
140
            if (Items.Count == 0 && !IsSplitted)
141
                list.Add(this);
142
            else
143
            {
144
                foreach (MatrixHeaderItem item in Items)
145
                {
146
                    item.GetTerminalItems(list);
147
                }
148
            }
149
        }
150

151
        public List<MatrixHeaderItem> GetTerminalItems()
152
        {
153
            List<MatrixHeaderItem> result = new List<MatrixHeaderItem>();
154
            GetTerminalItems(result);
155
            return result;
156
        }
157

158
        public MatrixHeaderItem(MatrixHeaderItem parent)
159
        {
160
            this.parent = parent;
161
            items = new List<MatrixHeaderItem>();
162
            isSplitted = false;
163
        }
164

165

166
        private class HeaderComparer : IComparer<MatrixHeaderItem>
167
        {
168
            private SortOrder sort;
169

170
            public int Compare(MatrixHeaderItem x, MatrixHeaderItem y)
171
            {
172
                int result = 0;
173
                IComparable i1 = x.Value as IComparable;
174
                IComparable i2 = y.Value as IComparable;
175

176
                if (i1 != null)
177
                    result = i1.CompareTo(i2);
178
                else if (i2 != null)
179
                    result = -1;
180
                if (sort == SortOrder.Descending)
181
                    result = -result;
182

183
                return result;
184
            }
185

186
            public HeaderComparer(SortOrder sort)
187
            {
188
                this.sort = sort;
189
            }
190
        }
191
    }
192
}
193