FastReport

1
using FastReport.Table;
2
using FastReport.Utils;
3
using System.Drawing;
4

5
namespace FastReport.CrossView
6
{
7
    internal partial class CrossViewHelper
8
    {
9
        private CrossViewObject crossView;
10
        private int headerWidth;
11
        private int headerHeight;
12
        private int templateBodyWidth;
13
        private int templateBodyHeight;
14
        private bool designTime;
15
        private TableResult resultTable;
16
        private CrossViewDescriptor titleDescriptor;
17
        private CrossViewDescriptor xAxisFieldCaptionDescriptor;
18
        private CrossViewDescriptor yAxisFieldCaptionDescriptor;
19
        private CrossViewHeaderDescriptor noColumnsDescriptor;
20
        private CrossViewHeaderDescriptor noRowsDescriptor;
21
        private CrossViewCellDescriptor noCellsDescriptor;
22
        private int resultBodyWidth;
23
        private int resultBodyHeight;
24

25
        #region Properties
26
        public CrossViewObject CrossView
27
        {
28
            get { return crossView; }
29
        }
30

31
        public Report Report
32
        {
33
            get { return CrossView.Report; }
34
        }
35

36
        public TableResult ResultTable
37
        {
38
            get { return designTime ? resultTable : CrossView.ResultTable; }
39
        }
40

41
        public int HeaderHeight
42
        {
43
            get { return headerHeight; }
44
        }
45

46
        public int HeaderWidth
47
        {
48
            get { return headerWidth; }
49
        }
50

51
        public int TemplateBodyWidth
52
        {
53
            get { return templateBodyWidth; }
54
        }
55

56
        public int TemplateBodyHeight
57
        {
58
            get { return templateBodyHeight; }
59
        }
60

61
        public int ResultBodyWidth
62
        {
63
            get { return resultBodyWidth; }
64
        }
65

66
        public int ResultBodyHeight
67
        {
68
            get { return resultBodyHeight; }
69
        }
70

71
        #endregion
72

73
        #region Private Methods
74

75
        /// <summary>
76
        /// Updates HeaderWidth, HeaderHeight, BodyWidth, BodyHeight properties.
77
        /// </summary>
78
        private void UpdateTemplateSizes()
79
        {
80
            if (CrossView.Data.SourceAssigned)
81
            {
82
                headerWidth = CrossView.Data.YAxisFieldsCount;
83
                headerHeight = CrossView.Data.XAxisFieldsCount;
84
            }
85
            else
86
            {
87
                headerWidth = 1;
88
                headerHeight = 1;
89
            }
90
            if (CrossView.ShowXAxisFieldsCaption)
91
                headerHeight++;
92
            if (CrossView.ShowTitle)
93
                headerHeight++;
94
            if (headerHeight == 0)
95
                if (CrossView.ShowYAxisFieldsCaption)
96
                    headerHeight = 1;
97
            templateBodyWidth = 1 + CrossView.Data.XAxisFieldsCount;
98
            if (CrossView.Data.MeasuresInXAxis)
99
                templateBodyWidth = (templateBodyWidth - 1) * CrossView.Data.MeasuresCount;
100
            templateBodyHeight = 1 + CrossView.Data.YAxisFieldsCount;
101
            if (CrossView.Data.MeasuresInYAxis)
102
                templateBodyHeight = (templateBodyHeight - 1) * CrossView.Data.MeasuresCount;
103
        }
104

105
        private void UpdateColumnDescriptors()
106
        {
107
            int left = HeaderWidth;
108
            int top = 0;
109
            if (CrossView.ShowTitle)
110
                top++;
111
            if (CrossView.ShowXAxisFieldsCaption)
112
                top++;
113

114
            foreach (CrossViewHeaderDescriptor descr in CrossView.Data.Columns)
115
            {
116
                descr.TemplateColumn = CrossView.Columns[left + descr.cell];
117
                descr.TemplateRow = CrossView.Rows[top + descr.level];
118
                descr.TemplateCell = CrossView[left + descr.cell, top + descr.level];
119
            }
120
        }
121

122
        private void UpdateRowDescriptors()
123
        {
124
            int left = 0;
125
            int top = HeaderHeight;
126

127
            foreach (CrossViewHeaderDescriptor descr in CrossView.Data.Rows)
128
            {
129
                descr.TemplateColumn = CrossView.Columns[left + descr.level];
130
                descr.TemplateRow = CrossView.Rows[top + descr.cell];
131
                descr.TemplateCell = CrossView[left + descr.level, top + descr.cell];
132
            }
133
        }
134

135
        private void UpdateCellDescriptors()
136
        {
137
            int x = HeaderWidth;
138
            int y = HeaderHeight;
139

140
            foreach (CrossViewCellDescriptor descr in CrossView.Data.Cells)
141
            {
142
                descr.TemplateColumn = CrossView.Columns[x + descr.x];
143
                descr.TemplateRow = CrossView.Rows[y + descr.y];
144
                descr.TemplateCell = CrossView[x + descr.x, y + descr.y];
145
            }
146
        }
147

148
        private void UpdateOtherDescriptors()
149
        {
150
            titleDescriptor.TemplateColumn = null;
151
            titleDescriptor.TemplateRow = null;
152
            titleDescriptor.TemplateCell = null;
153
            if (CrossView.ShowTitle)
154
            {
155
                titleDescriptor.TemplateColumn = CrossView.Columns[HeaderWidth];
156
                titleDescriptor.TemplateRow = CrossView.Rows[0];
157
                titleDescriptor.TemplateCell = CrossView[HeaderWidth, 0];
158
            }
159

160
            xAxisFieldCaptionDescriptor.TemplateColumn = null;
161
            xAxisFieldCaptionDescriptor.TemplateRow = null;
162
            xAxisFieldCaptionDescriptor.TemplateCell = null;
163
            if (CrossView.ShowXAxisFieldsCaption)
164
            {
165
                xAxisFieldCaptionDescriptor.TemplateColumn = CrossView.Columns[HeaderWidth];
166
                xAxisFieldCaptionDescriptor.TemplateRow = CrossView.Rows[(CrossView.ShowTitle ? 1 : 0)];
167
                xAxisFieldCaptionDescriptor.TemplateCell = CrossView[HeaderWidth, (CrossView.ShowTitle ? 1 : 0)];
168
            }
169

170
        }
171

172
        private void ApplyStyle(TableCell cell, string styleName)
173
        {
174
            Style style = null;
175
            int styleIndex = CrossView.StyleSheet.IndexOf(CrossView.Style);
176
            if (styleIndex != -1)
177
            {
178
                StyleCollection styles = CrossView.StyleSheet[styleIndex];
179
                style = styles[styles.IndexOf(styleName)];
180
            }
181
            if (style != null)
182
                cell.ApplyStyle(style);
183
        }
184

185
        private TableCell CreateCell(string text)
186
        {
187
            TableCell cell = new TableCell();
188
            cell.AllowExpressions = false;
189
            cell.Font = DrawUtils.DefaultReportFont;
190
            cell.Text = text;
191
            cell.HorzAlign = HorzAlign.Center;
192
            cell.VertAlign = VertAlign.Center;
193
            ApplyStyle(cell, "Header");
194
            return cell;
195
        }
196

197
        private TableCell CreateDataCell()
198
        {
199
            TableCell cell = new TableCell();
200
            cell.AllowExpressions = false;
201
            cell.Font = DrawUtils.DefaultReportFont;
202
            cell.HorzAlign = HorzAlign.Right;
203
            cell.VertAlign = VertAlign.Center;
204
            ApplyStyle(cell, "Body");
205
            return cell;
206
        }
207

208
        private void SetHint(TableCell cell, string text)
209
        {
210
            cell.Assign(CrossView.Styles.DefaultStyle);
211
            cell.Text = text;
212
            cell.Font = DrawUtils.DefaultReportFont;
213
            cell.TextFill = new SolidFill(Color.Gray);
214
            cell.HorzAlign = HorzAlign.Center;
215
            cell.VertAlign = VertAlign.Center;
216
            cell.SetFlags(Flags.CanEdit, false);
217
        }
218

219
        private void InitTemplateTable()
220
        {
221
            TableColumn column;
222
            CrossViewDescriptor descr;
223
            for (int i = 0; i < headerWidth + templateBodyWidth; i++)
224
            {
225
                column = new TableColumn();
226
                descr = CrossView.Data.GetColumnDescriptor(i);
227
                if (descr.TemplateColumn != null)
228
                    column.Assign(descr.TemplateColumn);
229
                ResultTable.Columns.Add(column);
230
            }
231
            TableRow row;
232
            for (int i = 0; i < headerHeight + templateBodyHeight; i++)
233
            {
234
                row = new TableRow();
235
                int rowindex = i;
236
                if (crossView.ShowTitle)
237
                    rowindex--;
238
                if (crossView.ShowXAxisFieldsCaption)
239
                    rowindex--;
240
                if (rowindex >= 0)
241
                {
242
                    descr = CrossView.Data.GetRowDescriptor(rowindex);
243
                }
244
                else
245
                {
246
                    if (crossView.ShowTitle)
247
                    {
248
                        if (i == 0)
249
                        {
250
                            descr = titleDescriptor;
251
                        }
252
                        else
253
                        {
254
                            descr = xAxisFieldCaptionDescriptor;
255
                        }
256
                    }
257
                    else
258
                    {
259
                        descr = xAxisFieldCaptionDescriptor;
260
                    }
261
                }
262
                if (descr.TemplateRow != null)
263
                    row.Assign(descr.TemplateRow);
264
                ResultTable.Rows.Add(row);
265
            }
266
        }
267

268
        private void InitResultTable()
269
        {
270
            //todo
271
            TableColumn column;
272
            CrossViewDescriptor descr;
273
            for (int i = 0; i < headerWidth + resultBodyWidth; i++)
274
            {
275
                column = new TableColumn();
276

277
                descr = CrossView.Data.GetColumnDescriptor(0); // temp 0 !!!
278

279
                if (descr.TemplateColumn != null)
280
                    column.Assign(descr.TemplateColumn);
281
                ResultTable.Columns.Add(column);
282
            }
283
            TableRow row;
284
            for (int i = 0; i < headerHeight + resultBodyHeight; i++)
285
            {
286
                row = new TableRow();
287
                int rowindex = i;
288
                if (crossView.ShowTitle)
289
                    rowindex--;
290
                if (crossView.ShowXAxisFieldsCaption)
291
                    rowindex--;
292
                if (rowindex >= 0)
293
                {
294
                    descr = CrossView.Data.GetRowDescriptor(0); // temp 0 !!! (rowindex)
295
                }
296
                else
297
                {
298
                    if (crossView.ShowTitle)
299
                    {
300
                        if (i == 0)
301
                        {
302
                            descr = titleDescriptor;
303
                        }
304
                        else
305
                        {
306
                            descr = xAxisFieldCaptionDescriptor;
307
                        }
308
                    }
309
                    else
310
                    {
311
                        descr = xAxisFieldCaptionDescriptor;
312
                    }
313
                }
314
                if (descr.TemplateRow != null)
315
                    row.Assign(descr.TemplateRow);
316
                ResultTable.Rows.Add(row);
317
            }
318
        }
319

320
        private void PrintHeaders()
321
        {
322
            if (CrossView.ShowTitle)
323
                PrintTitle();
324
            PrintCorner();
325
            if (CrossView.ShowXAxisFieldsCaption)
326
                PrintXAxisFieldsCaption();
327
        }
328

329
        private void PrintTitle()
330
        {
331
            TableCell templateCell = titleDescriptor.TemplateCell;
332
            if (titleDescriptor.TemplateCell == null)
333
                templateCell = CreateCell(Res.Get("ComponentsMisc,Matrix,Title"));
334

335
            TableCellData resultCell = ResultTable.GetCellData(HeaderWidth, 0);
336
            templateCell.SaveState();
337
            templateCell.GetData();
338
            resultCell.RunTimeAssign(templateCell, true);
339
            resultCell.ColSpan = ResultTable.ColumnCount - HeaderWidth;
340
            templateCell.RestoreState();
341

342
            // print left-top cell
343
            if (titleDescriptor.TemplateCell == null)
344
                templateCell.Text = "";
345
            else
346
                templateCell = CrossView[0, 0];
347

348
            resultCell = ResultTable.GetCellData(0, 0);
349
            templateCell.SaveState();
350
            templateCell.GetData();
351
            resultCell.RunTimeAssign(templateCell, true);
352
            templateCell.RestoreState();
353
            resultCell.ColSpan = HeaderWidth;
354
        }
355

356
        private void PrintCorner()
357
        {
358
            int left = 0;
359
            int top = (CrossView.ShowTitle ? 1 : 0);
360
            int templateTop = titleDescriptor.TemplateRow != null ? 1 : 0;
361
            if (CrossView.ShowYAxisFieldsCaption)
362
            {
363

364
                for (int i = 0; i < HeaderWidth; i++)
365
                {
366
                    TableCell templateCell = null;
367
                    CrossViewHeaderDescriptor descr = crossView.Data.GetColumnDescriptor(i);
368
                    if (descr.TemplateColumn != null)
369
                        templateCell = CrossView[0, templateTop];
370
                    else
371
                        templateCell = CreateCell(descr.GetName());
372

373
                    TableCellData resultCell = ResultTable.GetCellData(left, top);
374
                    templateCell.SaveState();
375
                    templateCell.GetData();
376
                    resultCell.RunTimeAssign(templateCell, true);
377
                    templateCell.RestoreState();
378

379
                    resultCell.RowSpan = HeaderHeight - top;
380
                    resultCell.Text = descr.GetName();
381
                    left++;
382
                }
383
            }
384
            else
385
            {
386
                TableCell templateCell = CreateCell("");
387
                TableCellData resultCell = ResultTable.GetCellData(left, top);
388
                templateCell.SaveState();
389
                templateCell.GetData();
390
                resultCell.RunTimeAssign(templateCell, true);
391
                templateCell.RestoreState();
392
                resultCell.ColSpan = HeaderWidth;
393
                resultCell.RowSpan = HeaderHeight - top;
394
            }
395
        }
396

397
        private void PrintXAxisFieldsCaption()
398
        {
399
            int top = (CrossView.ShowTitle ? 1 : 0);
400
            int templateTop = titleDescriptor.TemplateRow != null ? 1 : 0;
401
            string captions = "";
402
            for (int i = 0; i < CrossView.Data.XAxisFieldsCount; i++)
403
            {
404
                CrossViewHeaderDescriptor descr = crossView.Data.GetRowDescriptor(i);
405
                if (captions != "")
406
                    captions += ", ";
407
                captions += descr.GetName();
408
            }
409
            TableCell templateCell = xAxisFieldCaptionDescriptor.TemplateCell;
410
            if (xAxisFieldCaptionDescriptor.TemplateCell == null)
411
                templateCell = CreateCell(captions);
412
            TableCellData resultCell = ResultTable.GetCellData(HeaderWidth, top);
413
            templateCell.SaveState();
414
            templateCell.GetData();
415
            resultCell.RunTimeAssign(templateCell, true);
416
            resultCell.ColSpan = ResultTable.ColumnCount - HeaderWidth;
417
            templateCell.RestoreState();
418
        }
419

420
        private void PrintXAxisTemplate()
421
        {
422
            int left = headerWidth;
423
            int top = (CrossView.ShowTitle ? 1 : 0) + (CrossView.ShowXAxisFieldsCaption ? 1 : 0);
424
            for (int i = 0; i < CrossView.Data.Columns.Count; i++)
425
            {
426
                CrossViewHeaderDescriptor crossViewHeaderDescriptor = CrossView.Data.Columns[i];
427
                TableCellData resultCell = ResultTable.GetCellData(left + crossViewHeaderDescriptor.cell, top + crossViewHeaderDescriptor.level);
428
                resultCell.ColSpan = crossViewHeaderDescriptor.cellsize;
429
                resultCell.RowSpan = crossViewHeaderDescriptor.levelsize;
430
                TableCell templateCell = crossViewHeaderDescriptor.TemplateCell;
431
                if (templateCell != null)
432
                    templateCell.Text = "[" + crossViewHeaderDescriptor.GetName() + "]";
433
                else
434
                    templateCell = CreateCell("[" + crossViewHeaderDescriptor.GetName() + "]");
435
                resultCell.RunTimeAssign(templateCell, true);
436
            }
437
        }
438

439
        private void PrintYAxisTemplate()
440
        {
441
            int left = 0;
442
            int top = headerHeight;
443
            for (int i = 0; i < CrossView.Data.Rows.Count; i++)
444
            {
445
                CrossViewHeaderDescriptor crossViewHeaderDescriptor = CrossView.Data.Rows[i];
446
                TableCellData resultCell = ResultTable.GetCellData(left + crossViewHeaderDescriptor.level, top + crossViewHeaderDescriptor.cell);
447
                resultCell.ColSpan = crossViewHeaderDescriptor.levelsize;
448
                resultCell.RowSpan = crossViewHeaderDescriptor.cellsize;
449
                TableCell templateCell = crossViewHeaderDescriptor.TemplateCell;
450
                if (templateCell != null)
451
                    templateCell.Text = "[" + crossViewHeaderDescriptor.GetName() + "]";
452
                else
453
                    templateCell = CreateCell("[" + crossViewHeaderDescriptor.GetName() + "]");
454
                resultCell.RunTimeAssign(templateCell, true);
455
            }
456
        }
457

458
        private void PrintDataTemplate()
459
        {
460
            CrossViewCellDescriptor crossViewCellDescriptor;
461
            int top = headerHeight;
462
            int left = headerWidth;
463
            TableCell templateCell = null;
464
            TableCellData resultCell = null;
465
            for (int i = 0; i < CrossView.Data.columnTerminalIndexes.Length; i++)
466
            {
467
                for (int j = 0; j < CrossView.Data.rowTerminalIndexes.Length; j++)
468
                {
469
                    crossViewCellDescriptor = CrossView.Data.Cells[i * CrossView.Data.rowTerminalIndexes.Length + j];
470
                    resultCell = ResultTable.GetCellData(left + i, top + j);
471

472
                    templateCell = crossViewCellDescriptor.TemplateCell;
473
                    if (templateCell == null)
474
                        templateCell = CreateDataCell();
475
                    templateCell.Text = "0";
476
                    resultCell.RunTimeAssign(templateCell, true);
477
                }
478
            }
479
        }
480
        #endregion
481

482
        #region Public Methods
483
        public void BuildTemplate()
484
        {
485
            // create temporary descriptors
486
            if (!CrossView.Data.SourceAssigned)
487
            {
488
                CrossView.Data.columnDescriptorsIndexes = new int[] { 0 };
489
                CrossView.Data.rowDescriptorsIndexes = new int[] { 0 };
490
                CrossView.Data.columnTerminalIndexes = new int[] { 0 };
491
                CrossView.Data.rowTerminalIndexes = new int[] { 0 };
492
                CrossView.Data.Columns.Add(noColumnsDescriptor);
493
                CrossView.Data.Rows.Add(noRowsDescriptor);
494
                CrossView.Data.Cells.Add(noCellsDescriptor);
495
            }
496

497
            UpdateTemplateSizes();
498

499
            // create the result table
500
            designTime = true;
501
            resultTable = new TableResult();
502
            InitTemplateTable();
503
            PrintHeaders();
504
            PrintXAxisTemplate();
505
            PrintYAxisTemplate();
506
            PrintDataTemplate();
507

508
            // copy the result table to the Matrix
509
            CrossView.ColumnCount = ResultTable.ColumnCount;
510
            CrossView.RowCount = ResultTable.RowCount;
511
            CrossView.FixedColumns = HeaderWidth;
512
            CrossView.FixedRows = HeaderHeight;
513
            CrossView.CreateUniqueNames();
514

515
            for (int x = 0; x < CrossView.ColumnCount; x++)
516
            {
517
                CrossView.Columns[x].Assign(ResultTable.Columns[x]);
518
            }
519
            for (int y = 0; y < CrossView.RowCount; y++)
520
            {
521
                CrossView.Rows[y].Assign(ResultTable.Rows[y]);
522
            }
523
            for (int x = 0; x < CrossView.ColumnCount; x++)
524
            {
525
                for (int y = 0; y < CrossView.RowCount; y++)
526
                {
527
                    TableCell cell = CrossView[x, y];
528
                    cell.AssignAll(ResultTable[x, y]);
529
                    cell.SetFlags(Flags.CanEdit, true);
530
                }
531
            }
532
            UpdateDescriptors();
533
            resultTable.Dispose();
534

535
            // clear temporary descriptors, set hints
536
            if (!CrossView.Data.SourceAssigned)
537
            {
538
                SetHint(CrossView[HeaderWidth, (CrossView.ShowTitle ? 1 : 0) + (CrossView.ShowXAxisFieldsCaption ? 1 : 0)], Res.Get("ComponentsMisc,CrossView,SetSource"));
539
                CrossView.Data.Columns.Clear();
540
                SetHint(CrossView[0, HeaderHeight], Res.Get("ComponentsMisc,CrossView,SetSource"));
541
                CrossView.Data.Rows.Clear();
542
                SetHint(CrossView[HeaderWidth, HeaderHeight], Res.Get("ComponentsMisc,CrossView,SetSource"));
543
                CrossView.Data.Cells.Clear();
544
                CrossView.Data.columnDescriptorsIndexes = new int[0];
545
                CrossView.Data.rowDescriptorsIndexes = new int[0];
546
                CrossView.Data.columnTerminalIndexes = new int[0];
547
                CrossView.Data.rowTerminalIndexes = new int[0];
548
            }
549
            else
550
            {
551
                noColumnsDescriptor.TemplateColumn = CrossView.Data.Columns[0].TemplateColumn;
552
                noColumnsDescriptor.TemplateRow = CrossView.Data.Columns[0].TemplateRow;
553
                noColumnsDescriptor.TemplateCell = CrossView.Data.Columns[0].TemplateCell;
554
                noRowsDescriptor.TemplateColumn = CrossView.Data.Rows[0].TemplateColumn;
555
                noRowsDescriptor.TemplateRow = CrossView.Data.Rows[0].TemplateRow;
556
                noRowsDescriptor.TemplateCell = CrossView.Data.Rows[0].TemplateCell;
557
                noCellsDescriptor.TemplateColumn = CrossView.Data.Cells[0].TemplateColumn;
558
                noCellsDescriptor.TemplateRow = CrossView.Data.Cells[0].TemplateRow;
559
                noCellsDescriptor.TemplateCell = CrossView.Data.Cells[0].TemplateCell;
560
            }
561
        }
562

563
        public void UpdateDescriptors()
564
        {
565
            bool needClearTemporaryDescriptors = false;
566
            if (!CrossView.Data.SourceAssigned && (CrossView.Data.Columns.Count == 0))
567
            {
568
                needClearTemporaryDescriptors = true;
569
                CrossView.Data.columnDescriptorsIndexes = new int[] { 0 };
570
                CrossView.Data.rowDescriptorsIndexes = new int[] { 0 };
571
                CrossView.Data.columnTerminalIndexes = new int[] { 0 };
572
                CrossView.Data.rowTerminalIndexes = new int[] { 0 };
573
                CrossView.Data.Columns.Add(noColumnsDescriptor);
574
                CrossView.Data.Rows.Add(noRowsDescriptor);
575
                CrossView.Data.Cells.Add(noCellsDescriptor);
576
            }
577

578
            UpdateTemplateSizes();
579
            CrossView.FixedColumns = HeaderWidth;
580
            CrossView.FixedRows = HeaderHeight;
581
            UpdateColumnDescriptors();
582
            UpdateRowDescriptors();
583
            UpdateCellDescriptors();
584
            UpdateOtherDescriptors();
585

586
            // clear temporary descriptors
587
            if (needClearTemporaryDescriptors)
588
            {
589
                CrossView.Data.Columns.Clear();
590
                CrossView.Data.Rows.Clear();
591
                CrossView.Data.Cells.Clear();
592
                CrossView.Data.columnDescriptorsIndexes = new int[0];
593
                CrossView.Data.rowDescriptorsIndexes = new int[0];
594
                CrossView.Data.columnTerminalIndexes = new int[0];
595
                CrossView.Data.rowTerminalIndexes = new int[0];
596
            }
597
        }
598

599
        public void UpdateStyle()
600
        {
601
            for (int y = 0; y < CrossView.RowCount; y++)
602
            {
603
                for (int x = 0; x < CrossView.ColumnCount; x++)
604
                {
605
                    string style = x < HeaderWidth || y < HeaderHeight ? "Header" : "Body";
606
                    ApplyStyle(CrossView[x, y], style);
607
                }
608
            }
609
        }
610

611
        public void StartPrint()
612
        {
613
            //todo
614
            /*
615
                  if ((Matrix.Data.Columns.Count == 0 && Matrix.Data.Rows.Count == 0) || Matrix.Data.Cells.Count == 0)
616
                    throw new Exception(String.Format(Res.Get("Messages,MatrixError"), Matrix.Name));
617
            */
618
            designTime = false;
619
            /*
620
                  FNoColumns = Matrix.Data.Columns.Count == 0;
621
                  FNoRows = Matrix.Data.Rows.Count == 0;
622

623
                  // create temporary descriptors
624
                  if (FNoColumns)
625
                    Matrix.Data.Columns.Add(FNoColumnsDescriptor);
626
                  if (FNoRows)
627
                    Matrix.Data.Rows.Add(FNoRowsDescriptor);
628
            */
629
            OnProgressInternal();
630
            /*
631
                  Matrix.Data.Clear();
632
                  Matrix.OnManualBuild(EventArgs.Empty);
633
            */
634
            resultBodyHeight = CrossView.Data.DataRowCount;
635
            resultBodyWidth = CrossView.Data.DataColumnCount;
636
        }
637

638

639

640

641
        public void AddData()
642
        {
643

644
        }
645

646
        public void FinishPrint()
647
        {
648
            //todo
649
            UpdateDescriptors();
650
            ResultTable.FixedColumns = HeaderWidth;
651
            ResultTable.FixedRows = HeaderHeight;
652

653
            InitResultTable();
654
            //todo
655
            //temp
656
            PrintHeaders();
657
            PrintXAxisResult();
658
            PrintYAxisResult();
659
            PrintResultData();
660

661

662

663
            //      PrintData();
664
            /*
665
                  // clear temporary descriptors
666
                  if (FNoColumns)
667
                    Matrix.Data.Columns.Clear();
668
                  if (FNoRows)
669
                    Matrix.Data.Rows.Clear();
670
            */
671
        }
672

673
        private int axisLeft;
674
        private int axisTop;
675
        public bool XAxisDrawCellHandler(CrossViewAxisDrawCell crossViewAxisDrawCell)
676
        {
677
            CrossViewHeaderDescriptor crossViewHeaderDescriptor = CrossView.Data.Columns[0]; // temp - 0 todoCUBE
678
            TableCellData resultCell = ResultTable.GetCellData(axisLeft + crossViewAxisDrawCell.Cell, axisTop + crossViewAxisDrawCell.Level);
679
            resultCell.ColSpan = crossViewAxisDrawCell.SizeCell;
680
            resultCell.RowSpan = crossViewAxisDrawCell.SizeLevel;
681
            TableCell templateCell = crossViewHeaderDescriptor.TemplateCell;
682
            if (templateCell != null)
683
                templateCell.Text = crossViewAxisDrawCell.Text;
684
            else
685
                templateCell = CreateCell(crossViewAxisDrawCell.Text);
686
            resultCell.RunTimeAssign(templateCell, true);
687
            return false;
688
        }
689

690
        private void PrintXAxisResult()
691
        {
692

693
            axisLeft = headerWidth;
694
            axisTop = (CrossView.ShowTitle ? 1 : 0) + (CrossView.ShowXAxisFieldsCaption ? 1 : 0);
695

696
            CrossView.CubeSource.TraverseXAxis(XAxisDrawCellHandler);
697
        }
698

699
        public bool YAxisDrawCellHandler(CrossViewAxisDrawCell crossViewAxisDrawCell)
700
        {
701
            CrossViewHeaderDescriptor crossViewHeaderDescriptor = CrossView.Data.Rows[0]; // temp - 0 todoCUBE
702
            TableCellData resultCell = ResultTable.GetCellData(axisLeft + crossViewAxisDrawCell.Level, axisTop + crossViewAxisDrawCell.Cell);
703
            resultCell.ColSpan = crossViewAxisDrawCell.SizeLevel;
704
            resultCell.RowSpan = crossViewAxisDrawCell.SizeCell;
705
            TableCell templateCell = crossViewHeaderDescriptor.TemplateCell;
706
            if (templateCell != null)
707
                templateCell.Text = crossViewAxisDrawCell.Text;
708
            else
709
                templateCell = CreateCell(crossViewAxisDrawCell.Text);
710
            resultCell.RunTimeAssign(templateCell, true);
711
            return false;
712
        }
713

714
        private void PrintYAxisResult()
715
        {
716

717
            axisLeft = 0;
718
            axisTop = headerHeight;
719

720
            CrossView.CubeSource.TraverseYAxis(YAxisDrawCellHandler);
721
        }
722

723
        private void PrintResultData()
724
        {
725
            CrossViewCellDescriptor crossViewCellDescriptor;
726
            int top = headerHeight;
727
            int left = headerWidth;
728
            TableCell templateCell = null;
729
            TableCellData resultCell = null;
730
            CrossViewMeasureCell cubeMeasureCell;
731
            for (int i = 0; i < CrossView.Data.DataColumnCount; i++)
732
            {
733
                for (int j = 0; j < CrossView.Data.DataRowCount; j++)
734
                {
735
                    cubeMeasureCell = CrossView.CubeSource.GetMeasureCell(i, j);
736
                    crossViewCellDescriptor = CrossView.Data.Cells[0]; // todoCUBE temp 0 !!!
737
                    resultCell = ResultTable.GetCellData(left + i, top + j);
738

739
                    templateCell = crossViewCellDescriptor.TemplateCell;
740
                    if (templateCell == null)
741
                        templateCell = CreateDataCell();
742
                    templateCell.Text = cubeMeasureCell.Text;
743
                    resultCell.RunTimeAssign(templateCell, true);
744
                }
745
            }
746
        }
747

748
        internal void CreateOtherDescriptor()
749
        {
750
            titleDescriptor = new CrossViewDescriptor();
751
            xAxisFieldCaptionDescriptor = new CrossViewDescriptor();
752
            yAxisFieldCaptionDescriptor = new CrossViewDescriptor();
753
            noColumnsDescriptor = new CrossViewHeaderDescriptor();
754
            noColumnsDescriptor.cell = 0;
755
            noColumnsDescriptor.cellsize = 1;
756
            noColumnsDescriptor.level = 0;
757
            noColumnsDescriptor.levelsize = 1;
758
            noRowsDescriptor = new CrossViewHeaderDescriptor();
759
            noRowsDescriptor.cell = 0;
760
            noRowsDescriptor.cellsize = 1;
761
            noRowsDescriptor.level = 0;
762
            noRowsDescriptor.levelsize = 1;
763
            noCellsDescriptor = new CrossViewCellDescriptor();
764
        }
765
        #endregion
766

767
        public CrossViewHelper(CrossViewObject crossView)
768
        {
769
            this.crossView = crossView;
770
            CreateOtherDescriptor();
771
        }
772
    }
773
}