3rdpartylibs/fastreports.wpf/FastReport.Base/DataBand.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using FastReport.Utils;
using FastReport.Data;
using System.Drawing.Design;

namespace FastReport
{
    /// <summary>
    /// This class represents the Data band.
    /// </summary>
    /// <remarks>
    /// Use the <see cref="DataSource"/> property to connect the band to a datasource. Set the
    /// <see cref="Filter"/> property if you want to filter data rows. The <see cref="Sort"/>
    /// property can be used to sort data rows.
    /// </remarks>
    public partial class DataBand : BandBase
    {
        #region Fields
        private DataHeaderBand header;
        private DataFooterBand footer;
        private BandCollection bands;
        private DataSourceBase dataSource;
        private SortCollection sort;
        private string filter;
        private BandColumns columns;
        private bool printIfDetailEmpty;
        private bool printIfDatasourceEmpty;
        private bool keepTogether;
        private bool keepDetail;
        private string idColumn;
        private string parentIdColumn;
        private float indent;
        private bool keepSummary;
        private Relation relation;
        private bool collectChildRows;
        private int rowCount;
        private int maxRows;
        private bool resetPageNumber;
        #endregion

        #region Properties
        /// <summary>
        /// Gets or sets a header band.
        /// </summary>
        [Browsable(false)]
        public DataHeaderBand Header
        {
            get { return header; }
            set
            {
                SetProp(header, value);
                header = value;
            }
        }

        /// <summary>
        /// Gets a collection of detail bands.
        /// </summary>
        [Browsable(false)]
        public BandCollection Bands
        {
            get { return bands; }
        }

        /// <summary>
        /// Gets or sets a footer band.
        /// </summary>
        [Browsable(false)]
        public DataFooterBand Footer
        {
            get { return footer; }
            set
            {
                SetProp(footer, value);
                footer = value;
            }
        }

        /// <summary>
        /// Gets or sets a data source.
        /// Please note: data source have to be enabled.
        /// </summary>
        [Category("Data")]
        public DataSourceBase DataSource
        {
            get
            {
                if (dataSource != null && !dataSource.Enabled)
                    return null;
                return dataSource;
            }
            set
            {
                if (dataSource != value)
                {
                    if (dataSource != null)
                        dataSource.Disposed -= new EventHandler(DataSource_Disposed);
                    if (value != null)
                        value.Disposed += new EventHandler(DataSource_Disposed);
                }
                dataSource = value;
            }
        }

        /// <summary>
        /// Gets or sets a number of rows in the virtual data source.
        /// </summary>
        /// <remarks>
        /// Use this property if your data band is not connected to any data source. In this case
        /// the virtual data source with the specified number of rows will be used.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(1)]
        public int RowCount
        {
            get { return rowCount; }
            set { rowCount = value; }
        }

        /// <summary>
        /// Limits the maximum number of rows in a datasource. 0 means no limit.
        /// </summary>
        [Category("Data")]
        [DefaultValue(0)]
        public int MaxRows
        {
            get { return maxRows; }
            set { maxRows = value; }
        }

        /// <summary>
        /// Gets or sets a relation used to establish a master-detail relationship between
        /// this band and its parent.
        /// </summary>
        /// <remarks>
        /// Use this property if there are several relations exist between two data sources.
        /// If there is only one relation (in most cases it is), you can leave this property empty.
        /// </remarks>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.RelationEditor, FastReport", typeof(UITypeEditor))]
        public Relation Relation
        {
            get { return relation; }
            set { relation = value; }
        }

        /// <summary>
        /// Gets the collection of sort conditions.
        /// </summary>
        [Browsable(false)]
        public SortCollection Sort
        {
            get { return sort; }
        }

        /// <summary>
        /// Gets the row filter expression.
        /// </summary>
        /// <remarks>
        /// This property can contain any valid boolean expression. If the expression returns <b>false</b>,
        /// the corresponding data row will not be printed.
        /// </remarks>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string Filter
        {
            get { return filter; }
            set { filter = value; }
        }

        /// <summary>
        /// Gets the band columns.
        /// </summary>
        [Category("Appearance")]
        [Editor("FastReport.TypeEditors.DataBandColumnEditor, FastReport", typeof(UITypeEditor))]
        public BandColumns Columns
        {
            get { return columns; }
        }

        /// <summary>
        /// Gets or sets a value that determines whether to print a band if all its detail rows are empty.
        /// </summary>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool PrintIfDetailEmpty
        {
            get { return printIfDetailEmpty; }
            set { printIfDetailEmpty = value; }
        }

        /// <summary>
        /// Gets or sets a value that determines whether to print a band if its datasource is empty.
        /// </summary>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool PrintIfDatasourceEmpty
        {
            get { return printIfDatasourceEmpty; }
            set { printIfDatasourceEmpty = value; }
        }

        /// <summary>
        /// Gets or sets a value indicating that all band rows should be printed together on one page.
        /// </summary>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool KeepTogether
        {
            get { return keepTogether; }
            set { keepTogether = value; }
        }

        /// <summary>
        /// Gets or sets a value indicating that the band should be printed together with all its detail rows.
        /// </summary>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool KeepDetail
        {
            get { return keepDetail; }
            set { keepDetail = value; }
        }

        /// <summary>
        /// Gets or sets the key column that identifies the data row.
        /// </summary>
        /// <remarks>
        /// <para>This property is used when printing a hierarchic list.</para>
        /// <para>To print the hierarchic list, you have to setup three properties: <b>IdColumn</b>,
        /// <b>ParentIdColumn</b> and <b>Indent</b>. First two properties are used to identify the data
        /// row and its parent; the <b>Indent</b> property specifies the indent that will be used to shift
        /// the databand according to its hierarchy level.</para>
        /// <para/>When printing hierarchy, FastReport shifts the band to the right
        /// (by value specified in the <see cref="Indent"/> property), and also decreases the
        /// width of the band by the same value. You may use the <b>Anchor</b> property of the
        /// objects on a band to indicate whether the object should move with the band, or stay
        /// on its original position, or shrink.
        /// </remarks>
        [Category("Hierarchy")]
        [Editor("FastReport.TypeEditors.DataColumnEditor, FastReport", typeof(UITypeEditor))]
        public string IdColumn
        {
            get { return idColumn; }
            set { idColumn = value; }
        }

        /// <summary>
        /// Gets or sets the column that identifies the parent data row.
        /// </summary>
        /// <remarks>
        /// This property is used when printing a hierarchic list. See description of the
        /// <see cref="IdColumn"/> property for more details.
        /// </remarks>
        [Category("Hierarchy")]
        [Editor("FastReport.TypeEditors.DataColumnEditor, FastReport", typeof(UITypeEditor))]
        public string ParentIdColumn
        {
            get { return parentIdColumn; }
            set { parentIdColumn = value; }
        }

        /// <summary>
        /// Gets or sets the indent that will be used to shift the databand according to its hierarchy level.
        /// </summary>
        /// <remarks>
        /// This property is used when printing a hierarchic list. See description of the
        /// <see cref="IdColumn"/> property for more details.
        /// </remarks>
        [DefaultValue(37.8f)]
        [Category("Hierarchy")]
        [TypeConverter("FastReport.TypeConverters.UnitsConverter, FastReport")]
        public float Indent
        {
            get { return indent; }
            set { indent = value; }
        }

        /// <summary>
        /// Gets or sets a value indicating that the databand should collect child data rows.
        /// </summary>
        /// <remarks>
        /// This property determines how the master-detail report is printed. Default behavior is:
        /// <para/>MasterData row1
        /// <para/>-- DetailData row1
        /// <para/>-- DetailData row2
        /// <para/>-- DetailData row3
        /// <para/>MasterData row2
        /// <para/>-- DetailData row1
        /// <para/>-- DetailData row2
        /// <para/>When you set this property to <b>true</b>, the master databand will collect all child data rows
        /// under a single master data row:
        /// <para/>MasterData row1
        /// <para/>-- DetailData row1
        /// <para/>-- DetailData row2
        /// <para/>-- DetailData row3
        /// <para/>-- DetailData row4
        /// <para/>-- DetailData row5
        /// </remarks>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool CollectChildRows
        {
            get { return collectChildRows; }
            set { collectChildRows = value; }
        }

        /// <summary>
        /// Gets or sets a value that determines whether to reset the page numbers when this band starts print.
        /// </summary>
        /// <remarks>
        /// Typically you should set the <see cref="BandBase.StartNewPage"/> property to <b>true</b> as well.
        /// </remarks>
        [DefaultValue(false)]
        [Category("Behavior")]
        public bool ResetPageNumber
        {
            get { return resetPageNumber; }
            set { resetPageNumber = value; }
        }

        internal bool IsDeepmostDataBand
        {
            get { return Bands.Count == 0; }
        }

        internal bool KeepSummary
        {
            get { return keepSummary; }
            set { keepSummary = value; }
        }

        internal bool IsHierarchical
        {
            get
            {
                return !String.IsNullOrEmpty(IdColumn) && !String.IsNullOrEmpty(ParentIdColumn);
            }
        }

        internal bool IsDatasourceEmpty
        {
            get { return DataSource == null || DataSource.RowCount == 0; }
        }
        #endregion

        #region Private Methods
        private void DataSource_Disposed(object sender, EventArgs e)
        {
            dataSource = null;
        }
        #endregion

        #region Protected Methods
        /// <inheritdoc/>
        protected override void DeserializeSubItems(FRReader reader)
        {
            if (String.Compare(reader.ItemName, "Sort", true) == 0)
                reader.Read(Sort);
            else
                base.DeserializeSubItems(reader);
        }
        #endregion

        #region IParent
        /// <inheritdoc/>
        public override void GetChildObjects(ObjectCollection list)
        {
            base.GetChildObjects(list);
            if (IsRunning)
                return;

            list.Add(header);
            foreach (BandBase band in bands)
            {
                list.Add(band);
            }
            list.Add(footer);
        }

        /// <inheritdoc/>
        public override bool CanContain(Base child)
        {
            return base.CanContain(child) || (child is DataHeaderBand || child is DataFooterBand ||
              child is DataBand || child is GroupHeaderBand);
        }

        /// <inheritdoc/>
        public override void AddChild(Base child)
        {
            if (IsRunning)
            {
                base.AddChild(child);
                return;
            }
            if (child is DataHeaderBand)
                Header = child as DataHeaderBand;
            else if (child is DataFooterBand)
                Footer = child as DataFooterBand;
            else if (child is DataBand || child is GroupHeaderBand)
                bands.Add(child as BandBase);
            else
                base.AddChild(child);
        }

        /// <inheritdoc/>
        public override void RemoveChild(Base child)
        {
            base.RemoveChild(child);
            if (IsRunning)
                return;

            if (child is DataHeaderBand && header == child as DataHeaderBand)
                Header = null;
            if (child is DataFooterBand && footer == child as DataFooterBand)
                Footer = null;
            if (child is DataBand || child is GroupHeaderBand)
                bands.Remove(child as BandBase);
        }

        /// <inheritdoc/>
        public override int GetChildOrder(Base child)
        {
            if (child is BandBase && !IsRunning)
                return bands.IndexOf(child as BandBase);
            return base.GetChildOrder(child);
        }

        /// <inheritdoc/>
        public override void SetChildOrder(Base child, int order)
        {
            if (child is BandBase && !IsRunning)
            {
                if (order > bands.Count)
                    order = bands.Count;
                int oldOrder = child.ZOrder;
                if (oldOrder != -1 && order != -1 && oldOrder != order)
                {
                    if (oldOrder <= order)
                        order--;
                    bands.Remove(child as BandBase);
                    bands.Insert(order, child as BandBase);
                }
            }
            else
                base.SetChildOrder(child, order);
        }
        #endregion

        #region Public Methods
        /// <inheritdoc/>
        public override void Assign(Base source)
        {
            base.Assign(source);

            DataBand src = source as DataBand;
            DataSource = src.DataSource;
            RowCount = src.RowCount;
            MaxRows = src.MaxRows;
            Relation = src.Relation;
            Sort.Assign(src.Sort);
            Filter = src.Filter;
            Columns.Assign(src.Columns);
            PrintIfDetailEmpty = src.PrintIfDetailEmpty;
            PrintIfDatasourceEmpty = src.PrintIfDatasourceEmpty;
            KeepTogether = src.KeepTogether;
            KeepDetail = src.KeepDetail;
            IdColumn = src.IdColumn;
            ParentIdColumn = src.ParentIdColumn;
            Indent = src.Indent;
            CollectChildRows = src.CollectChildRows;
            ResetPageNumber = src.ResetPageNumber;
        }

        internal override void UpdateWidth()
        {
            if (Columns.Count > 1)
            {
                Width = Columns.ActualWidth;
            }
            else if (!String.IsNullOrEmpty(IdColumn) && !String.IsNullOrEmpty(ParentIdColumn))
            {
                if (PageWidth != 0)
                    Width = PageWidth - Left;
            }
            else
                base.UpdateWidth();
        }

        /// <inheritdoc/>
        public override void Serialize(FRWriter writer)
        {
            DataBand c = writer.DiffObject as DataBand;
            base.Serialize(writer);
            if (writer.SerializeTo == SerializeTo.Preview)
                return;

            if (DataSource != c.DataSource)
                writer.WriteRef("DataSource", DataSource);
            if (RowCount != c.RowCount)
                writer.WriteInt("RowCount", RowCount);
            if (MaxRows != c.MaxRows)
                writer.WriteInt("MaxRows", MaxRows);
            if (Relation != c.Relation)
                writer.WriteRef("Relation", Relation);
            if (Sort.Count > 0)
                writer.Write(Sort);
            if (Filter != c.Filter)
                writer.WriteStr("Filter", Filter);
            Columns.Serialize(writer, c.Columns);
            if (PrintIfDetailEmpty != c.PrintIfDetailEmpty)
                writer.WriteBool("PrintIfDetailEmpty", PrintIfDetailEmpty);
            if (PrintIfDatasourceEmpty != c.PrintIfDatasourceEmpty)
                writer.WriteBool("PrintIfDatasourceEmpty", PrintIfDatasourceEmpty);
            if (KeepTogether != c.KeepTogether)
                writer.WriteBool("KeepTogether", KeepTogether);
            if (KeepDetail != c.KeepDetail)
                writer.WriteBool("KeepDetail", KeepDetail);
            if (IdColumn != c.IdColumn)
                writer.WriteStr("IdColumn", IdColumn);
            if (ParentIdColumn != c.ParentIdColumn)
                writer.WriteStr("ParentIdColumn", ParentIdColumn);
            if (FloatDiff(Indent, c.Indent))
                writer.WriteFloat("Indent", Indent);
            if (CollectChildRows != c.CollectChildRows)
                writer.WriteBool("CollectChildRows", CollectChildRows);
            if (ResetPageNumber != c.ResetPageNumber)
                writer.WriteBool("ResetPageNumber", ResetPageNumber);
        }

        /// <inheritdoc/>
        public override string[] GetExpressions()
        {
            List<string> list = new List<string>();
            foreach (Sort sort in Sort)
            {
                list.Add(sort.Expression);
            }
            list.Add(Filter);
            return list.ToArray();
        }

        /// <summary>
        /// Initializes the data source connected to this band.
        /// </summary>
        public void InitDataSource()
        {
            if (DataSource == null)
            {
                DataSource = new VirtualDataSource();
                DataSource.SetReport(Report);
            }

            if (DataSource is VirtualDataSource)
                (DataSource as VirtualDataSource).VirtualRowsCount = RowCount;

            DataSourceBase parentDataSource = ParentDataBand == null ? null : ParentDataBand.DataSource;
            bool collectChildRows = ParentDataBand == null ? false : ParentDataBand.CollectChildRows;
            if (Relation != null)
                DataSource.Init(Relation, Filter, Sort, collectChildRows);
            else
                DataSource.Init(parentDataSource, Filter, Sort, collectChildRows);
        }

        internal bool IsDetailEmpty()
        {
            if (PrintIfDetailEmpty || Bands.Count == 0)
                return false;

            foreach (BandBase band in Bands)
            {
                if (!band.IsEmpty())
                    return false;
            }
            return true;
        }

        internal override bool IsEmpty()
        {
            InitDataSource();
            if (IsDatasourceEmpty)
                return !PrintIfDatasourceEmpty;

            DataSource.First();
            while (DataSource.HasMoreRows)
            {
                if (!IsDetailEmpty())
                    return false;
                DataSource.Next();
            }
            return true;
        }

        /// <inheritdoc/>
        public override void InitializeComponent()
        {
            base.InitializeComponent();
            KeepSummary = false;
        }
        #endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="DataBand"/> class.
        /// </summary>
        public DataBand()
        {
            bands = new BandCollection(this);
            sort = new SortCollection();
            filter = "";
            columns = new BandColumns(this);
            idColumn = "";
            parentIdColumn = "";
            indent = 37.8f;
            rowCount = 1;
            SetFlags(Flags.HasSmartTag, true);
        }
    }
}