3rdpartylibs/fastreports.wpf/FastReport.Base/Matrix/MatrixHeaderItem.cs

using System;
using System.Collections.Generic;
using System.Text;
using FastReport.Table;

namespace FastReport.Matrix
{
    internal class MatrixHeaderItem : MatrixDescriptor
    {
        private MatrixHeaderItem parent;
        private List<MatrixHeaderItem> items;
        private object value;
        private int index;
        private bool isTotal;
        private int dataRowNo;
        private bool pageBreak;
        private bool isSplitted;

        public MatrixHeaderItem Parent
        {
            get { return parent; }
        }

        public List<MatrixHeaderItem> Items
        {
            get { return items; }
        }

        public object Value
        {
            get { return value; }
            set { this.value = value; }
        }

        public int Index
        {
            get { return index; }
            set { index = value; }
        }

        public int Span
        {
            get
            {
                List<MatrixHeaderItem> terminalItems = new List<MatrixHeaderItem>();
                GetTerminalItems(terminalItems);
                return terminalItems.Count;
            }
        }

        public bool IsTotal
        {
            get { return isTotal; }
            set { isTotal = value; }
        }

        public object[] Values
        {
            get
            {
                int count = 0;
                MatrixHeaderItem item = this;

                while (item.Parent != null)
                {
                    count++;
                    item = item.Parent;
                }

                object[] values = new object[count];
                item = this;
                int index = count - 1;

                while (item.Parent != null)
                {
                    values[index] = item.Value;
                    index--;
                    item = item.Parent;
                }

                return values;
            }
        }

        public int DataRowNo
        {
            get { return dataRowNo; }
            set { dataRowNo = value; }
        }

        public bool PageBreak
        {
            get { return pageBreak; }
            set { pageBreak = value; }
        }

        internal bool IsSplitted
        {
            get { return isSplitted; }
            set { isSplitted = value; }
        }

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

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

                    int result = 0;
                    if (i1 != null)
                        result = i1.CompareTo(value);
                    else if (value != null)
                        result = -1;

                    if (result == 0)
                        return i;
                }
                return ~Items.Count;
            }
            else
            {
                MatrixHeaderItem header = new MatrixHeaderItem(null);
                header.Value = value;
                return Items.BinarySearch(header, new HeaderComparer(sort));
            }
        }

        public void Clear()
        {
            Items.Clear();
        }

        private void GetTerminalItems(List<MatrixHeaderItem> list)
        {
            if (Items.Count == 0 && !IsSplitted)
                list.Add(this);
            else
            {
                foreach (MatrixHeaderItem item in Items)
                {
                    item.GetTerminalItems(list);
                }
            }
        }

        public List<MatrixHeaderItem> GetTerminalItems()
        {
            List<MatrixHeaderItem> result = new List<MatrixHeaderItem>();
            GetTerminalItems(result);
            return result;
        }

        public MatrixHeaderItem(MatrixHeaderItem parent)
        {
            this.parent = parent;
            items = new List<MatrixHeaderItem>();
            isSplitted = false;
        }


        private class HeaderComparer : IComparer<MatrixHeaderItem>
        {
            private SortOrder sort;

            public int Compare(MatrixHeaderItem x, MatrixHeaderItem y)
            {
                int result = 0;
                IComparable i1 = x.Value as IComparable;
                IComparable i2 = y.Value as IComparable;

                if (i1 != null)
                    result = i1.CompareTo(i2);
                else if (i2 != null)
                    result = -1;
                if (sort == SortOrder.Descending)
                    result = -result;

                return result;
            }

            public HeaderComparer(SortOrder sort)
            {
                this.sort = sort;
            }
        }
    }
}