FastReport

1
using System;
2
using System.Collections;
3
using FastReport.Data;
4

5
namespace FastReport.CrossView
6
{
7
    /// <summary>
8
    /// Contains a set of properties and methods to hold and manipulate the CrossView descriptors.
9
    /// </summary>
10
    /// <remarks>
11
    /// This class contains three collections of descriptors such as <see cref="Columns"/>,
12
    /// <see cref="Rows"/> and <see cref="Cells"/>. Descriptors are filled from FastCube Slice.
13
    /// </remarks>
14
    public class CrossViewData
15
    {
16
        #region Fields
17
        private CrossViewHeader columns;
18
        private CrossViewHeader rows;
19
        private CrossViewCells cells;
20
        internal int[] columnDescriptorsIndexes;
21
        internal int[] rowDescriptorsIndexes;
22
        internal int[] columnTerminalIndexes;
23
        internal int[] rowTerminalIndexes;
24
        #endregion
25

26
        #region FastCube properties (temporary)
27
        private CubeSourceBase cubeSource;
28
        /// <summary>
29
        /// 
30
        /// </summary>
31
        public int XAxisFieldsCount { get { return cubeSource != null ? cubeSource.XAxisFieldsCount : 0; } }
32
        /// <summary>
33
        /// 
34
        /// </summary>
35
        public int YAxisFieldsCount { get { return cubeSource != null ? cubeSource.YAxisFieldsCount : 0; } }
36
        /// <summary>
37
        /// 
38
        /// </summary>
39
        public int MeasuresCount { get { return cubeSource != null ? cubeSource.MeasuresCount : 0; } }
40
        /// <summary>
41
        /// 
42
        /// </summary>
43
        public int MeasuresLevel { get { return cubeSource != null ? cubeSource.MeasuresLevel : 0; } }
44
        /// <summary>
45
        /// 
46
        /// </summary>
47
        public bool MeasuresInXAxis { get { return cubeSource != null ? cubeSource.MeasuresInXAxis : false; } }
48
        /// <summary>
49
        /// 
50
        /// </summary>
51
        public bool MeasuresInYAxis { get { return cubeSource != null ? cubeSource.MeasuresInYAxis : false; } }
52
        /// <summary>
53
        /// 
54
        /// </summary>
55
        public int DataColumnCount { get { return cubeSource != null ? cubeSource.DataColumnCount : 0; } }
56
        /// <summary>
57
        /// 
58
        /// </summary>
59
        public int DataRowCount { get { return cubeSource != null ? cubeSource.DataRowCount : 0; } }
60
        /// <summary>
61
        /// 
62
        /// </summary>
63
        public bool SourceAssigned { get { return cubeSource != null; } }
64
#if !DOTNET_4
65
    private string intArrayToString(int[] intArray)
66
    {
67
      string res = "";
68
      foreach (int item in intArray)
69
      {
70
        if (res != "")
71
          res += ",";
72
        res += item.ToString();
73
      }
74
      return res;
75
    }
76
    private int[] stringToIntArray(string str)
77
    {
78
      string[] strArray = str.Split(',');
79
      int[] res = new int[strArray.Length];
80
      for (int i = 0; i < strArray.Length; i++)
81
      {
82
        res[i] = int.Parse(strArray[i]);
83
      }
84
      return res;
85
    }
86
#endif
87
        /// <summary>
88
        /// 
89
        /// </summary>
90
        public string ColumnDescriptorsIndexes
91
        {
92
#if DOTNET_4
93
            get { return string.Join(",", columnDescriptorsIndexes); }
94
            set { columnDescriptorsIndexes = Array.ConvertAll(value.Split(','), int.Parse); }
95
#else
96
      get { return intArrayToString(columnDescriptorsIndexes); }
97
      set { columnDescriptorsIndexes = stringToIntArray(value); }
98
#endif
99
        }
100
        /// <summary>
101
        /// 
102
        /// </summary>
103
        public string RowDescriptorsIndexes
104
        {
105
#if DOTNET_4
106
            get { return string.Join(",", rowDescriptorsIndexes); }
107
            set { rowDescriptorsIndexes = Array.ConvertAll(value.Split(','), int.Parse); }
108
#else
109
      get { return intArrayToString(rowDescriptorsIndexes); }
110
      set { rowDescriptorsIndexes = stringToIntArray(value); }
111
#endif
112
        }
113
        /// <summary>
114
        /// 
115
        /// </summary>
116
        public string ColumnTerminalIndexes
117
        {
118
#if DOTNET_4
119
            get { return string.Join(",", columnTerminalIndexes); }
120
            set { columnTerminalIndexes = Array.ConvertAll(value.Split(','), int.Parse); }
121
#else
122
      get { return intArrayToString(columnTerminalIndexes); }
123
      set { columnTerminalIndexes = stringToIntArray(value); }
124
#endif
125
        }
126
        /// <summary>
127
        /// 
128
        /// </summary>
129
        public string RowTerminalIndexes
130
        {
131
#if DOTNET_4
132
            get { return string.Join(",", rowTerminalIndexes); }
133
            set { rowTerminalIndexes = Array.ConvertAll(value.Split(','), int.Parse); }
134
#else
135
      get { return intArrayToString(rowTerminalIndexes); }
136
      set { rowTerminalIndexes = stringToIntArray(value); }
137
#endif
138
        }
139
        internal CubeSourceBase CubeSource
140
        {
141
            get { return cubeSource; }
142
            set
143
            {
144
                if (cubeSource != value)
145
                {
146
                    cubeSource = value;
147
                }
148
            }
149
        }
150
        internal void CreateDescriptors()
151
        {
152
            columnDescriptorsIndexes = new int[0];
153
            rowDescriptorsIndexes = new int[0];
154
            columnTerminalIndexes = new int[0];
155
            rowTerminalIndexes = new int[0];
156
            CrossViewHeaderDescriptor crossViewHeaderDescriptor;
157
            Columns.Clear();
158
            Rows.Clear();
159
            Cells.Clear();
160

161
            if (!SourceAssigned)
162
                return;
163
            int cell = 0;
164
            for (int i = 0; i < XAxisFieldsCount; i++)
165
            {
166
                cell = 0;
167
                if (MeasuresInXAxis && (MeasuresLevel <= i))
168
                {
169
                    if (MeasuresLevel == i)
170
                    {
171
                        for (int k = 0; k <= i; k++)
172
                        {
173
                            for (int j = 0; j < MeasuresCount; j++)
174
                            {
175
                                if (k == i)
176
                                {
177
                                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", CubeSource.GetMeasureName(j), false, false, true);
178
                                    crossViewHeaderDescriptor.cellsize = 1;
179
                                    crossViewHeaderDescriptor.levelsize = XAxisFieldsCount - i;
180
                                }
181
                                else
182
                                {
183
                                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(k), CubeSource.GetMeasureName(j), false, false, true);
184
                                    crossViewHeaderDescriptor.cellsize = (XAxisFieldsCount - i);
185
                                    crossViewHeaderDescriptor.levelsize = 1;
186
                                }
187
                                crossViewHeaderDescriptor.level = i;
188
                                crossViewHeaderDescriptor.cell = cell;
189
                                cell += crossViewHeaderDescriptor.cellsize;
190
                                Columns.Add(crossViewHeaderDescriptor);
191
                                if ((j == 0) && (k == 0))
192
                                {
193
                                    Array.Resize(ref rowDescriptorsIndexes, rowDescriptorsIndexes.Length + 1);
194
                                    rowDescriptorsIndexes[rowDescriptorsIndexes.Length - 1] = Columns.Count - 1;
195
                                }
196
                                if ((k == i) || (i == (XAxisFieldsCount - 1)))
197
                                {
198
                                    Array.Resize(ref columnTerminalIndexes, columnTerminalIndexes.Length + 1);
199
                                    columnTerminalIndexes[columnTerminalIndexes.Length - 1] = Columns.Count - 1;
200
                                }
201
                            }
202
                        }
203
                    }
204
                    else
205
                    {
206
                        for (int j = 0; j < MeasuresCount; j++)
207
                        {
208
                            crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(i), "", false, false, false);
209
                            crossViewHeaderDescriptor.level = i;
210
                            crossViewHeaderDescriptor.levelsize = 1;
211
                            crossViewHeaderDescriptor.cell = cell;
212
                            crossViewHeaderDescriptor.cellsize = XAxisFieldsCount - i;
213
                            cell += crossViewHeaderDescriptor.cellsize;
214
                            Columns.Add(crossViewHeaderDescriptor);
215
                            if (j == 0)
216
                            {
217
                                Array.Resize(ref rowDescriptorsIndexes, rowDescriptorsIndexes.Length + 1);
218
                                rowDescriptorsIndexes[rowDescriptorsIndexes.Length - 1] = Columns.Count - 1;
219
                            }
220

221
                            if (i == 1)
222
                            {
223
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
224
                            }
225
                            else
226
                            if (i == (MeasuresLevel + 1))
227
                            {
228
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(i - 2), "", true, false, false);
229
                            }
230
                            else
231
                            {
232
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(i - 1), "", true, false, false);
233
                            }
234
                            crossViewHeaderDescriptor.level = i;
235
                            crossViewHeaderDescriptor.levelsize = XAxisFieldsCount - i;
236
                            crossViewHeaderDescriptor.cell = cell;
237
                            crossViewHeaderDescriptor.cellsize = 1;
238
                            cell += crossViewHeaderDescriptor.cellsize;
239
                            Columns.Add(crossViewHeaderDescriptor);
240

241
                            if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == XAxisFieldsCount))
242
                            {
243
                                Array.Resize(ref columnTerminalIndexes, columnTerminalIndexes.Length + 1);
244
                                columnTerminalIndexes[columnTerminalIndexes.Length - 1] = Columns.Count - 1;
245
                            }
246
                        }
247
                    }
248
                }
249
                else
250
                {
251
                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(i), "", false, false, false);
252
                    crossViewHeaderDescriptor.level = i;
253
                    crossViewHeaderDescriptor.levelsize = 1;
254
                    crossViewHeaderDescriptor.cell = cell;
255
                    if (MeasuresInXAxis)
256
                    {
257
                        crossViewHeaderDescriptor.cellsize = (XAxisFieldsCount - i - 1) * MeasuresCount;
258
                        if (crossViewHeaderDescriptor.cellsize == 0)
259
                            crossViewHeaderDescriptor.cellsize = MeasuresCount;
260
                    }
261
                    else
262
                    {
263
                        crossViewHeaderDescriptor.cellsize = XAxisFieldsCount - i;
264
                    }
265
                    cell += crossViewHeaderDescriptor.cellsize;
266
                    Columns.Add(crossViewHeaderDescriptor);
267
                    if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == XAxisFieldsCount))
268
                    {
269
                        Array.Resize(ref columnTerminalIndexes, columnTerminalIndexes.Length + 1);
270
                        columnTerminalIndexes[columnTerminalIndexes.Length - 1] = Columns.Count - 1;
271
                    }
272

273
                    Array.Resize(ref rowDescriptorsIndexes, rowDescriptorsIndexes.Length + 1);
274
                    rowDescriptorsIndexes[rowDescriptorsIndexes.Length - 1] = Columns.Count - 1;
275

276
                    if (i == 0)
277
                    {
278
                        crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
279
                    }
280
                    else
281
                    {
282
                        crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetXAxisFieldName(i - 1), "", true, false, false);
283
                    }
284
                    crossViewHeaderDescriptor.level = i;
285
                    crossViewHeaderDescriptor.cell = cell;
286
                    if (MeasuresInXAxis)
287
                    {
288
                        crossViewHeaderDescriptor.levelsize = MeasuresLevel - i;
289
                        crossViewHeaderDescriptor.cellsize = MeasuresCount;
290
                    }
291
                    else
292
                    {
293
                        crossViewHeaderDescriptor.levelsize = XAxisFieldsCount - i;
294
                        crossViewHeaderDescriptor.cellsize = 1;
295
                    }
296
                    cell += crossViewHeaderDescriptor.cellsize;
297
                    Columns.Add(crossViewHeaderDescriptor);
298

299
                    if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == XAxisFieldsCount))
300
                    {
301
                        Array.Resize(ref columnTerminalIndexes, columnTerminalIndexes.Length + 1);
302
                        columnTerminalIndexes[columnTerminalIndexes.Length - 1] = Columns.Count - 1;
303
                    }
304
                }
305
            }
306
            if (Columns.Count == 0)
307
            {
308
                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
309
                crossViewHeaderDescriptor.level = 0;
310
                crossViewHeaderDescriptor.levelsize = 1;
311
                crossViewHeaderDescriptor.cell = 0;
312
                crossViewHeaderDescriptor.cellsize = 1;
313
                Columns.Add(crossViewHeaderDescriptor);
314
                Array.Resize(ref rowDescriptorsIndexes, rowDescriptorsIndexes.Length + 1);
315
                rowDescriptorsIndexes[rowDescriptorsIndexes.Length - 1] = Columns.Count - 1;
316
                Array.Resize(ref columnTerminalIndexes, columnTerminalIndexes.Length + 1);
317
                columnTerminalIndexes[columnTerminalIndexes.Length - 1] = Columns.Count - 1;
318
            }
319

320
            for (int i = 0; i < YAxisFieldsCount; i++)
321
            {
322
                cell = 0;
323
                if (MeasuresInYAxis && (MeasuresLevel <= i))
324
                {
325
                    if (MeasuresLevel == i)
326
                    {
327
                        for (int k = 0; k <= i; k++)
328
                        {
329
                            for (int j = 0; j < MeasuresCount; j++)
330
                            {
331
                                if (k == i)
332
                                {
333
                                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", CubeSource.GetMeasureName(j), false, false, true);
334
                                    crossViewHeaderDescriptor.cellsize = 1;
335
                                    crossViewHeaderDescriptor.levelsize = YAxisFieldsCount - i;
336
                                }
337
                                else
338
                                {
339
                                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(k), CubeSource.GetMeasureName(j), false, false, true);
340
                                    crossViewHeaderDescriptor.cellsize = (YAxisFieldsCount - i);
341
                                    crossViewHeaderDescriptor.levelsize = 1;
342
                                }
343
                                crossViewHeaderDescriptor.level = i;
344
                                crossViewHeaderDescriptor.cell = cell;
345
                                cell += crossViewHeaderDescriptor.cellsize;
346
                                Rows.Add(crossViewHeaderDescriptor);
347
                                if ((j == 0) && (k == 0))
348
                                {
349
                                    Array.Resize(ref columnDescriptorsIndexes, columnDescriptorsIndexes.Length + 1);
350
                                    columnDescriptorsIndexes[columnDescriptorsIndexes.Length - 1] = Rows.Count - 1;
351
                                }
352
                                if ((k == i) || (i == (YAxisFieldsCount - 1)))
353
                                {
354
                                    Array.Resize(ref rowTerminalIndexes, rowTerminalIndexes.Length + 1);
355
                                    rowTerminalIndexes[rowTerminalIndexes.Length - 1] = Rows.Count - 1;
356
                                }
357
                            }
358
                        }
359
                    }
360
                    else
361
                    {
362
                        for (int j = 0; j < MeasuresCount; j++)
363
                        {
364
                            crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(i), "", false, false, false);
365
                            crossViewHeaderDescriptor.level = i;
366
                            crossViewHeaderDescriptor.levelsize = 1;
367
                            crossViewHeaderDescriptor.cell = cell;
368
                            crossViewHeaderDescriptor.cellsize = YAxisFieldsCount - i;
369
                            cell += crossViewHeaderDescriptor.cellsize;
370
                            Rows.Add(crossViewHeaderDescriptor);
371
                            if (j == 0)
372
                            {
373
                                Array.Resize(ref columnDescriptorsIndexes, columnDescriptorsIndexes.Length + 1);
374
                                columnDescriptorsIndexes[columnDescriptorsIndexes.Length - 1] = Rows.Count - 1;
375
                            }
376

377
                            if (i == 1)
378
                            {
379
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
380
                            }
381
                            else
382
                            if (i == (MeasuresLevel + 1))
383
                            {
384
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(i - 2), "", true, false, false);
385
                            }
386
                            else
387
                            {
388
                                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(i - 1), "", true, false, false);
389
                            }
390
                            crossViewHeaderDescriptor.level = i;
391
                            crossViewHeaderDescriptor.levelsize = YAxisFieldsCount - i;
392
                            crossViewHeaderDescriptor.cell = cell;
393
                            crossViewHeaderDescriptor.cellsize = 1;
394
                            cell += crossViewHeaderDescriptor.cellsize;
395
                            Rows.Add(crossViewHeaderDescriptor);
396

397
                            if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == YAxisFieldsCount))
398
                            {
399
                                Array.Resize(ref rowTerminalIndexes, rowTerminalIndexes.Length + 1);
400
                                rowTerminalIndexes[rowTerminalIndexes.Length - 1] = Rows.Count - 1;
401
                            }
402
                        }
403
                    }
404
                }
405
                else
406
                {
407
                    crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(i), "", false, false, false);
408
                    crossViewHeaderDescriptor.level = i;
409
                    crossViewHeaderDescriptor.levelsize = 1;
410
                    crossViewHeaderDescriptor.cell = cell;
411
                    if (MeasuresInYAxis)
412
                    {
413
                        crossViewHeaderDescriptor.cellsize = (YAxisFieldsCount - i - 1) * MeasuresCount;
414
                        if (crossViewHeaderDescriptor.cellsize == 0)
415
                            crossViewHeaderDescriptor.cellsize = MeasuresCount;
416
                    }
417
                    else
418
                    {
419
                        crossViewHeaderDescriptor.cellsize = YAxisFieldsCount - i;
420
                    }
421
                    cell += crossViewHeaderDescriptor.cellsize;
422
                    Rows.Add(crossViewHeaderDescriptor);
423
                    if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == YAxisFieldsCount))
424
                    {
425
                        Array.Resize(ref rowTerminalIndexes, rowTerminalIndexes.Length + 1);
426
                        rowTerminalIndexes[rowTerminalIndexes.Length - 1] = Rows.Count - 1;
427
                    }
428

429
                    Array.Resize(ref columnDescriptorsIndexes, columnDescriptorsIndexes.Length + 1);
430
                    columnDescriptorsIndexes[columnDescriptorsIndexes.Length - 1] = Rows.Count - 1;
431

432
                    if (i == 0)
433
                    {
434
                        crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
435
                    }
436
                    else
437
                    {
438
                        crossViewHeaderDescriptor = new CrossViewHeaderDescriptor(CubeSource.GetYAxisFieldName(i - 1), "", true, false, false);
439
                    }
440
                    crossViewHeaderDescriptor.level = i;
441
                    crossViewHeaderDescriptor.cell = cell;
442
                    if (MeasuresInYAxis)
443
                    {
444
                        crossViewHeaderDescriptor.levelsize = MeasuresLevel - i;
445
                        crossViewHeaderDescriptor.cellsize = MeasuresCount;
446
                    }
447
                    else
448
                    {
449
                        crossViewHeaderDescriptor.levelsize = YAxisFieldsCount - i;
450
                        crossViewHeaderDescriptor.cellsize = 1;
451
                    }
452
                    cell += crossViewHeaderDescriptor.cellsize;
453
                    Rows.Add(crossViewHeaderDescriptor);
454

455
                    if ((crossViewHeaderDescriptor.level + crossViewHeaderDescriptor.levelsize == YAxisFieldsCount))
456
                    {
457
                        Array.Resize(ref rowTerminalIndexes, rowTerminalIndexes.Length + 1);
458
                        rowTerminalIndexes[rowTerminalIndexes.Length - 1] = Rows.Count - 1;
459
                    }
460
                }
461
            }
462
            if (Rows.Count == 0)
463
            {
464
                crossViewHeaderDescriptor = new CrossViewHeaderDescriptor("", "", false, true, false);
465
                crossViewHeaderDescriptor.level = 0;
466
                crossViewHeaderDescriptor.levelsize = 1;
467
                crossViewHeaderDescriptor.cell = 0;
468
                crossViewHeaderDescriptor.cellsize = 1;
469
                Rows.Add(crossViewHeaderDescriptor);
470
                Array.Resize(ref columnDescriptorsIndexes, columnDescriptorsIndexes.Length + 1);
471
                columnDescriptorsIndexes[columnDescriptorsIndexes.Length - 1] = Rows.Count - 1;
472
                Array.Resize(ref rowTerminalIndexes, rowTerminalIndexes.Length + 1);
473
                rowTerminalIndexes[rowTerminalIndexes.Length - 1] = Rows.Count - 1;
474
            }
475
            CrossViewCellDescriptor crossViewCellDescriptor;
476
            for (int i = 0; i < columnTerminalIndexes.Length; i++)
477
            {
478
                for (int j = 0; j < rowTerminalIndexes.Length; j++)
479
                {
480
                    crossViewCellDescriptor = new CrossViewCellDescriptor(Columns[columnTerminalIndexes[i]].fieldName, Rows[rowTerminalIndexes[j]].fieldName, Columns[columnTerminalIndexes[i]].measureName + Rows[rowTerminalIndexes[j]].measureName, Columns[columnTerminalIndexes[i]].isTotal, Rows[rowTerminalIndexes[j]].isTotal, Columns[columnTerminalIndexes[i]].isGrandTotal, Rows[rowTerminalIndexes[j]].isGrandTotal);
481
                    crossViewCellDescriptor.x = i;
482
                    crossViewCellDescriptor.y = j;
483
                    Cells.Add(crossViewCellDescriptor);
484
                }
485
            }
486
        }
487

488
        internal CrossViewHeaderDescriptor GetRowDescriptor(int index)
489
        {
490
            int tempXAxisFieldsCount = (!SourceAssigned) ? 1 : XAxisFieldsCount;
491
            if (index < tempXAxisFieldsCount)
492
            {
493
                return Columns[rowDescriptorsIndexes[index]];
494
            }
495
            else
496
            {
497
                return Rows[rowTerminalIndexes[index - tempXAxisFieldsCount]];
498
            }
499
        }
500

501
        internal CrossViewHeaderDescriptor GetColumnDescriptor(int index)
502
        {
503
            int tempYAxisFieldsCount = (!SourceAssigned) ? 1 : YAxisFieldsCount;
504
            if (index < tempYAxisFieldsCount)
505
            {
506
                return Rows[columnDescriptorsIndexes[index]];
507
            }
508
            else
509
            {
510
                return Columns[columnTerminalIndexes[index - tempYAxisFieldsCount]];
511
            }
512
        }
513
        #endregion
514

515
        #region Properties
516
        /// <summary>
517
        /// Gets a collection of column descriptors.
518
        /// </summary>
519
        /// <remarks>
520
        /// Note: after you change something in this collection, call the 
521
        /// <see cref="CrossViewObject.BuildTemplate"/> method to refresh the CrossView.
522
        /// </remarks>
523
        public CrossViewHeader Columns
524
        {
525
            get { return columns; }
526
        }
527

528
        /// <summary>
529
        /// Gets a collection of row descriptors.
530
        /// </summary>
531
        /// <remarks>
532
        /// Note: after you change something in this collection, call the 
533
        /// <see cref="CrossViewObject.BuildTemplate"/> method to refresh the CrossView.
534
        /// </remarks>
535
        public CrossViewHeader Rows
536
        {
537
            get { return rows; }
538
        }
539

540
        /// <summary>
541
        /// Gets a collection of data cell descriptors.
542
        /// </summary>
543
        /// <remarks>
544
        /// Note: after you change something in this collection, call the 
545
        /// <see cref="CrossViewObject.BuildTemplate"/> method to refresh the CrossView.
546
        /// </remarks>
547
        public CrossViewCells Cells
548
        {
549
            get { return cells; }
550
        }
551

552
        #endregion
553

554
        #region Public Methods
555
        #endregion
556

557
        internal CrossViewData()
558
        {
559
            columns = new CrossViewHeader();
560
            columns.Name = "CrossViewColumns";
561
            rows = new CrossViewHeader();
562
            rows.Name = "CrossViewRows";
563
            cells = new CrossViewCells();
564
            cells.Name = "CrossViewCells";
565
            CreateDescriptors();
566
        }
567
    }
568
}