示例#1
0
 public SubTitleCmdArgs(RptItemBase p_parent, RptMtxSubtitle p_title = null, int p_newSpan = -1)
 {
     Parent   = p_parent;
     SubTitle = p_title;
     NewSpan  = p_newSpan;
     InitData();
 }
示例#2
0
文件: RptMatrix.cs 项目: Daoting/dt
 /// <summary>
 /// 获取最大ID的转换方法
 /// </summary>
 /// <param name="p_item"></param>
 /// <param name="p_preName"></param>
 /// <returns></returns>
 int GetValidInt(RptItemBase p_item, string p_preName)
 {
     if (p_item is RptMtxSubtotal)
     {
         RptMtxSubtotal total = p_item as RptMtxSubtotal;
         if (total.Item.Val.Length < p_preName.Length)
         {
             return(0);
         }
         int id = 0;
         if (int.TryParse(total.Item.Val.Substring(p_preName.Length), out id))
         {
             return(id);
         }
         return(0);
     }
     else
     {
         RptMtxSubtitle title = p_item as RptMtxSubtitle;
         if (title.Item.Val.Length < p_preName.Length)
         {
             return(0);
         }
         int id = 0;
         if (int.TryParse(title.Item.Val.Substring(p_preName.Length), out id))
         {
             return(id);
         }
         return(0);
     }
 }
示例#3
0
 /// <summary>
 /// 小计参数
 /// </summary>
 /// <param name="p_parent">小计所属上级</param>
 /// <param name="p_total">当前操作的小计</param>
 /// <param name="p_newSpan"></param>
 public SubTotalCmdArgs(RptItemBase p_parent, RptMtxSubtotal p_total = null, int p_newSpan = -1)
 {
     Parent   = p_parent;
     SubTotal = p_total;
     NewSpan  = p_newSpan;
     InitData();
 }
示例#4
0
 public RptMtxSubtitle(RptItemBase p_parent)
 {
     _parent   = p_parent;
     Item      = new RptText(this);
     SubTitles = new List <RptMtxSubtitle>();
     // 所占行数/列数
     _data.AddCell("span", 1);
 }
示例#5
0
 public RptMatrixInst(RptItemBase p_item)
     : base(p_item)
 {
     _cellInsts     = new List <RptTextInst>();
     RowHeaderInsts = new List <RptMtxHeaderInst>();
     ColHeaderInsts = new List <RptMtxHeaderInst>();
     _rowUsed       = new List <int>();
     _colUsed       = new List <int>();
 }
示例#6
0
        /// <summary>
        /// 输出单列表头表尾可重复表格布局
        /// </summary>
        void OutputTable()
        {
            _region.RowSpan = 0;
            _data.Current   = 0;
            RptRootInst root = Inst;
            RptRegion   region;

            if (_header != null)
            {
                _header.Output();
                region          = _header.Region;
                _region.RowSpan = region.Row + region.RowSpan - _region.Row;
            }

            root.VerPageBegin += OnPageBegin;
            root.VerPageEnd   += OnPageEnd;
            RptTable tbl = _item as RptTable;

            if (tbl.Footer != null && tbl.RepeatFooter)
            {
                root.TblFooterHeight = tbl.Footer.Height;
            }

            foreach (RptTblPartInst inst in _rows)
            {
                _curPart = inst;
                RptItemBase item = inst.Item;
                region = new RptRegion(
                    _region.Row + _region.RowSpan,
                    _region.Col,
                    item.RowSpan,
                    item.ColSpan);
                inst.Region = region;
                inst.Output();
                _region.RowSpan = region.Row + region.RowSpan - _region.Row;
            }

            _curPart             = null;
            root.TblFooterHeight = 0.0;
            root.VerPageBegin   -= OnPageBegin;
            root.VerPageEnd     -= OnPageEnd;

            if (_footer != null)
            {
                RptItemBase item = _footer.Item;
                region = new RptRegion(
                    _region.Row + _region.RowSpan,
                    _region.Col,
                    item.RowSpan,
                    item.ColSpan);
                _footer.Region = region;
                _footer.Output();
                _region.RowSpan = region.Row + region.RowSpan - _region.Row;
            }
            _data.Current = 0;
        }
示例#7
0
        public RptMtxHeaderInst(RptItemBase p_item)
            : base(p_item)
        {
            RptMatrix mat = p_item.Parent as RptMatrix;

            HeaderType = p_item is RptMtxRowHeader ? RptMtxHeaderType.Row : RptMtxHeaderType.Col;
            Visible    = HeaderType == RptMtxHeaderType.Row ? !mat.HideRowHeader : !mat.HideColHeader;
            TxtInsts   = new List <RptTextInst>();
            Filter     = new Dictionary <string, string>();
        }
示例#8
0
        public RptMtxSubtotal(RptItemBase p_parent)
        {
            _parent   = p_parent;
            Item      = new RptText(this);
            SubTotals = new List <RptMtxSubtotal>();

            // 是否在层次前面
            _data.AddCell("beforelevel", "1");
            // 所占行数/列数
            _data.AddCell("span", 1);
        }
示例#9
0
        /// <summary>
        /// 克隆标题
        /// </summary>
        /// <param name="p_parent"></param>
        /// <returns></returns>
        public RptMtxSubtitle Clone(RptItemBase p_parent)
        {
            RptMtxSubtitle title = new RptMtxSubtitle(p_parent);

            title.Data.Copy(this.Data);
            title.Item.Data.Copy(Item.Data);
            foreach (RptMtxSubtitle sub in SubTitles)
            {
                title.SubTitles.Add(sub.Clone(title));
            }
            return(title);
        }
示例#10
0
        /// <summary>
        /// 克隆小计
        /// </summary>
        /// <param name="p_parent"></param>
        /// <returns></returns>
        public RptMtxSubtotal Clone(RptItemBase p_parent)
        {
            RptMtxSubtotal total = new RptMtxSubtotal(p_parent);

            total.Data.Copy(this.Data);
            total.Item.Data.Copy(Item.Data);
            foreach (RptMtxSubtotal sub in SubTotals)
            {
                total.SubTotals.Add(sub.Clone(total));
            }
            return(total);
        }
示例#11
0
文件: RptRoot.cs 项目: Daoting/dt
        /// <summary>
        /// 触发报表项属性值变化事件
        /// </summary>
        /// <param name="p_item"></param>
        /// <param name="p_cell"></param>
        public void OnItemValueChanged(RptItemBase p_item, Cell p_cell)
        {
            ValueChangedCmd cmd = RptCmds.ValueChanged;

            if (!cmd.IsSetting)
            {
                ItemValueChanged?.Invoke(p_cell, p_cell);
                if (p_item is RptText pt && TextChanged != null)
                {
                    TextChanged(pt, p_cell);
                }
                p_cell.AcceptChanges();
            }
        }
示例#12
0
文件: RptMatrix.cs 项目: Daoting/dt
 /// <summary>
 /// 创建小计
 /// </summary>
 /// <param name="totals"></param>
 /// <param name="p_header"></param>
 /// <param name="p_matInst"></param>
 /// <param name="p_curRow"></param>
 /// <param name="p_data"></param>
 /// <param name="p_loc"></param>
 void CreateTotalInst(List <RptMtxSubtotal> totals, RptMtxHeader p_header, RptMatrixInst p_matInst, Row p_curRow, RptData p_data, TotalLocation p_loc)
 {
     foreach (RptMtxSubtotal total in totals)
     {
         if (total.TotalLoc == p_loc)
         {
             if (total.SubTotals.Count > 0)
             {
                 CreateTotalInst(total.SubTotals, p_header, p_matInst, p_curRow, p_data, p_loc);
             }
             else
             {
                 RptMtxHeaderInst totalInst = new RptMtxHeaderInst(p_header);
                 for (int j = 0; j < p_header.Levels.IndexOf(total.Level); j++)
                 {
                     RptMtxLevel nLevel = p_header.Levels[j];
                     nLevel.Item.ColSpan = 1;
                     nLevel.Item.RowSpan = 1;
                     RptTextInst txtlevel = new RptTextInst(nLevel.Item);
                     totalInst.TxtInsts.Add(txtlevel);
                     totalInst.Filter.Add(nLevel.Field, p_curRow.Str(nLevel.Field));
                 }
                 RptItemBase parent = total.Parent;
                 while (parent is RptMtxSubtotal)
                 {
                     RptTextInst parTotal = new RptTextInst((parent as RptMtxSubtotal).Item);
                     totalInst.TxtInsts.Add(parTotal);
                     parent = parent.Parent;
                 }
                 RptTextInst txtTotal = new RptTextInst(total.Item);
                 totalInst.TxtInsts.Add(txtTotal);
                 totalInst.RptData         = p_data;
                 totalInst.RptData.Current = p_curRow.Index;
                 totalInst.Index           = p_curRow.Index;
                 if (p_header is RptMtxColHeader)
                 {
                     totalInst.MtxRowsCol = total.Col;
                     p_matInst.AddColHeader(totalInst);
                 }
                 else
                 {
                     totalInst.MtxRowsRow = total.Row;
                     p_matInst.AddRowHeader(totalInst);
                 }
             }
         }
     }
 }
示例#13
0
文件: RptMatrix.cs 项目: Daoting/dt
 /// <summary>
 /// 创建标题
 /// </summary>
 /// <param name="p_titles"></param>
 /// <param name="p_header"></param>
 /// <param name="p_matInst"></param>
 /// <param name="p_curRow"></param>
 /// <param name="p_data"></param>
 void CreateSubTiltelInst(List <RptMtxSubtitle> p_titles, RptMtxHeader p_header, RptMatrixInst p_matInst, Row p_curRow, RptData p_data)
 {
     foreach (RptMtxSubtitle title in p_titles)
     {
         if (title.SubTitles.Count > 0)
         {
             CreateSubTiltelInst(title.SubTitles, p_header, p_matInst, p_curRow, p_data);
         }
         else
         {
             RptMtxHeaderInst titleInst = new RptMtxHeaderInst(p_header);
             for (int j = 0; j <= p_header.Levels.IndexOf(title.Level); j++)
             {
                 RptMtxLevel nLevel = p_header.Levels[j];
                 nLevel.Item.ColSpan = 1;
                 nLevel.Item.RowSpan = 1;
                 RptTextInst txtlevel = new RptTextInst(nLevel.Item);
                 titleInst.TxtInsts.Add(txtlevel);
                 titleInst.Filter.Add(nLevel.Field, p_curRow.Str(nLevel.Field));
             }
             RptItemBase parent = title.Parent;
             while (parent is RptMtxSubtotal)
             {
                 RptTextInst parTotal = new RptTextInst((parent as RptMtxSubtotal).Item);
                 titleInst.TxtInsts.Add(parTotal);
                 parent = parent.Parent;
             }
             RptTextInst txtTotal = new RptTextInst(title.Item);
             titleInst.TxtInsts.Add(txtTotal);
             titleInst.RptData         = p_data;
             titleInst.RptData.Current = p_curRow.Index;
             titleInst.Index           = p_curRow.Index;
             if (p_header is RptMtxColHeader)
             {
                 titleInst.MtxRowsCol = title.Col;
                 p_matInst.AddColHeader(titleInst);
             }
             else
             {
                 titleInst.MtxRowsRow = title.Row;
                 p_matInst.AddRowHeader(titleInst);
             }
         }
     }
 }
示例#14
0
文件: RptBodyInst.cs 项目: Daoting/dt
        /// <summary>
        /// 按照位置整理出每个报表项的左上位置列表
        /// 两报表项之间位置关系有三种:
        /// 1. 无影响
        /// 2. 垂直依赖
        /// 3. 水平依赖
        /// </summary>
        void SortItems()
        {
            RptItemBase        item;
            RptItemInst        itemInst;
            List <RptItemInst> topList  = new List <RptItemInst>();
            List <RptItemInst> leftList = new List <RptItemInst>();

            for (int i = 0; i < _children.Count; i++)
            {
                item     = _children[i].Item;
                itemInst = _children[i];
                topList.Clear();
                leftList.Clear();

                // 查找所有上侧左侧的报表项
                for (int j = 0; j < _children.Count; j++)
                {
                    RptItemBase tgt     = _children[j].Item;
                    RptItemInst tgtInst = _children[j];
                    Type        tp      = tgtInst.GetType();
                    if ((tgt.Row + tgt.RowSpan - 1) < item.Row && item.IsCrossWithColumns(tgt.Col, tgt.ColSpan))
                    {
                        topList.Add(tgtInst);
                    }
                    else if ((tgt.Col + tgt.ColSpan - 1) < item.Col && item.IsCrossWithRows(tgt.Row, tgt.RowSpan))
                    {
                        leftList.Add(tgtInst);
                    }
                }

                if (topList.Count > 0)
                {
                    itemInst.TopItems = GetTopLeftItems(topList, true);
                }

                if (leftList.Count > 0)
                {
                    itemInst.LeftItems = GetTopLeftItems(leftList, false);
                }
            }
        }
示例#15
0
        /// <summary>
        /// 是否需要垂直分页
        /// </summary>
        /// <param name="p_item"></param>
        /// <returns></returns>
        public bool TestPageBreak(RptItemInst p_item)
        {
            RptRegion   region    = p_item.Region;
            PageDefine  rowPage   = Rows[Rows.Count - 1];
            int         lastRow   = rowPage.Start + rowPage.Count;
            int         deltaRow  = region.Row + region.RowSpan - lastRow;
            RptItemBase item      = p_item.Item;
            double      topHeight = 0;

            if (deltaRow > 0)
            {
                topHeight = rowPage.Size.Sum();
            }
            else
            {
                for (int i = 0; i < region.Row - rowPage.Start; i++)
                {
                    topHeight += rowPage.Size[i];
                }
            }
            return(topHeight + item.Height > BodyHeight - TblFooterHeight);
        }
示例#16
0
        public override void Undo(object p_args)
        {
            SubTitleCmdArgs args   = (SubTitleCmdArgs)p_args;
            RptMtxSubtitle  title  = args.SubTitle;
            RptItemBase     parent = args.Parent;
            RptMatrix       mtx    = null;

            if (parent is RptMtxLevel)
            {
                RptMtxLevel pLevel = parent as RptMtxLevel;
                mtx = pLevel.Matrix;
                args.BackMtxRow();
                pLevel.SubTitles.Insert(args.TilteIndex, title);
            }
            else
            {
                RptMtxSubtitle pTotal = parent as RptMtxSubtitle;
                mtx = pTotal.Level.Matrix;
                args.BackMtxRow();
                pTotal.SubTitles.Insert(args.TilteIndex, title);
            }
            mtx.Update(true);
        }
示例#17
0
        public override void Undo(object p_args)
        {
            SubTitleCmdArgs args   = (SubTitleCmdArgs)p_args;
            RptMtxSubtitle  title  = args.SubTitle;
            RptItemBase     parent = args.Parent;
            RptMatrix       mtx    = null;

            if (parent is RptMtxLevel)
            {
                RptMtxLevel pLevel = parent as RptMtxLevel;
                mtx = pLevel.Matrix;
                args.DelMtxRows();
                pLevel.SubTitles.Remove(title);
            }
            else
            {
                RptMtxSubtitle pTitle = parent as RptMtxSubtitle;
                mtx = pTitle.Level.Matrix;
                args.DelMtxRows();
                pTitle.SubTitles.Remove(title);
            }
            mtx.Update(true);
        }
示例#18
0
        public override void Undo(object p_args)
        {
            SubTotalCmdArgs args   = (SubTotalCmdArgs)p_args;
            RptMtxSubtotal  total  = args.SubTotal;
            RptItemBase     parent = args.Parent;
            RptMatrix       mtx    = null;

            if (parent is RptMtxLevel)
            {
                RptMtxLevel pLevel = parent as RptMtxLevel;
                mtx = pLevel.Matrix;
                args.DelMtxRows();
                pLevel.SubTotals.Remove(total);
            }
            else
            {
                RptMtxSubtotal pTotal = parent as RptMtxSubtotal;
                mtx = pTotal.Level.Matrix;
                args.DelMtxRows();
                pTotal.SubTotals.Remove(total);
            }
            mtx.Update(true);
        }
示例#19
0
        public override object Execute(object p_args)
        {
            SubTitleCmdArgs  args       = (SubTitleCmdArgs)p_args;
            RptItemBase      parent     = args.Parent;
            RptMtxSubtitle   title      = args.SubTitle;
            RptMtxHeaderType headerType = RptMtxHeaderType.Col;
            RptMatrix        mtx        = null;

            args.InitData();
            if (parent is RptMtxLevel)
            {
                RptMtxLevel pLevel = parent as RptMtxLevel;
                mtx = pLevel.Matrix;
                if (pLevel.Parent is RptMtxRowHeader)
                {
                    headerType = RptMtxHeaderType.Row;
                }
                DelRows(args, headerType, mtx, title);
                args.TilteIndex = pLevel.SubTitles.IndexOf(title);
                pLevel.SubTitles.Remove(title);
            }
            else
            {
                RptMtxSubtitle pTotal = parent as RptMtxSubtitle;
                mtx = pTotal.Level.Matrix;
                if (pTotal.Level.Parent is RptMtxRowHeader)
                {
                    headerType = RptMtxHeaderType.Row;
                }
                DelRows(args, headerType, mtx, title);
                args.TilteIndex = pTotal.SubTitles.IndexOf(title);
                pTotal.SubTitles.Remove(title);
            }
            mtx.Update(true);
            return(null);
        }
示例#20
0
        public override object Execute(object p_args)
        {
            SubTitleCmdArgs  args       = (SubTitleCmdArgs)p_args;
            RptItemBase      parent     = args.Parent;
            RptMtxHeaderType headerType = RptMtxHeaderType.Col;
            RptMtxSubtitle   title      = args.SubTitle;
            RptMatrix        mtx        = null;

            if (title == null)
            {
                title = new RptMtxSubtitle(parent);
                args.InitData();
                if (parent is RptMtxLevel)
                {
                    RptMtxLevel pLevel = parent as RptMtxLevel;
                    mtx = pLevel.Matrix;
                    if (pLevel.Parent is RptMtxRowHeader)
                    {
                        headerType = RptMtxHeaderType.Row;
                    }
                    title.Item.Val = string.Format("subtitle{0}", mtx.GetMaxTitle());

                    RptMtxHeader header = pLevel.Parent as RptMtxHeader;
                    if (pLevel.SubTitles.Count > 0 || header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
                    {
                        int curIndex = 0;
                        if (headerType == RptMtxHeaderType.Row)
                        {
                            int subLevelSpan = 0;
                            if (header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
                            {
                                subLevelSpan = header.Levels[header.Levels.IndexOf(pLevel) + 1].RowSpan;
                            }

                            curIndex = pLevel.Row - mtx.ColHeader.Row - mtx.ColHeader.RowSpan + subLevelSpan + pLevel.GetTitleSpan(pLevel.SubTitles);
                            args.OpsRows.Add(InsertNewRow(mtx, curIndex));
                        }
                        else
                        {
                            int subLevelSpan = 0;
                            if (header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
                            {
                                subLevelSpan = header.Levels[header.Levels.IndexOf(pLevel) + 1].ColSpan;
                            }

                            curIndex = pLevel.Col - mtx.RowHeader.Col - mtx.RowHeader.ColSpan + subLevelSpan + pLevel.GetTitleSpan(pLevel.SubTitles);
                            foreach (RptMtxRow row in mtx.Rows)
                            {
                                args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
                            }
                        }
                        args.CurIndex = curIndex;
                    }
                    pLevel.SubTitles.Add(title);
                }
                else
                {
                    RptMtxSubtitle pTitle = parent as RptMtxSubtitle;
                    mtx = pTitle.Level.Matrix;
                    if (pTitle.Level.Parent is RptMtxRowHeader)
                    {
                        headerType = RptMtxHeaderType.Row;
                    }
                    title.Item.Val = string.Format("subtitle{0}", mtx.GetMaxTitle());
                    if (pTitle.SubTitles.Count > 0)
                    {
                        int curIndex = 0;
                        if (headerType == RptMtxHeaderType.Row)
                        {
                            curIndex = pTitle.Row + pTitle.RowSpan - mtx.ColHeader.Row - mtx.ColHeader.RowSpan;
                            args.OpsRows.Add(InsertNewRow(mtx, curIndex));
                        }
                        else
                        {
                            curIndex = pTitle.Col + pTitle.ColSpan - mtx.RowHeader.Col - mtx.RowHeader.ColSpan;
                            foreach (RptMtxRow row in mtx.Rows)
                            {
                                args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
                            }
                        }
                        args.CurIndex = curIndex;
                    }
                    pTitle.SubTitles.Add(title);
                }
                args.SubTitle = title;
            }
            else
            {
                mtx = title.Level.Matrix;
                if (parent is RptMtxLevel)
                {
                    args.BackMtxRow();
                    (parent as RptMtxLevel).SubTitles.Add(title);
                }
                else
                {
                    (parent as RptMtxSubtitle).SubTitles.Add(title);
                }
            }
            mtx.Update(true);
            return(title);
        }
示例#21
0
 public RptTableInst(RptItemBase p_item)
     : base(p_item)
 {
     _rows = new List <RptTblPartInst>();
 }
示例#22
0
        /// <summary>
        /// 输出单列布局
        /// </summary>
        void OutputList()
        {
            RptItemBase      tempItem;
            RptRootInst      root    = Inst;
            List <RptRegion> regions = new List <RptRegion>();
            RptRegion        region  = new RptRegion(_region.Row, _region.Col, 0, _item.ColSpan);

            regions.Add(region);

            if (_header != null)
            {
                _header.Output();
                region.RowSpan += _header.Region.RowSpan;
            }

            RptTable tbl      = _item as RptTable;
            int      rowCount = tbl.RowBreakCount;
            int      colCount = tbl.ColBreakCount;
            int      rowNum   = 0;

            foreach (RptTblPartInst tabInst in _rows)
            {
                RptItemBase item = tabInst.Item;
                tabInst.Region = new RptRegion(
                    region.Row + region.RowSpan,
                    region.Col,
                    item.RowSpan,
                    item.ColSpan);

                bool rowBreak = false;
                bool colBreak = false;
                if (rowCount == -1)
                {
                    // 自动计算重复行数
                    if (root.TestPageBreak(tabInst))
                    {
                        // 需要换页
                        if (colCount != 0 && (regions.Count % colCount) == 0)
                        {
                            rowBreak = true;
                            colBreak = true;
                        }
                        else
                        {
                            rowBreak = false;
                            colBreak = true;
                        }
                    }
                }
                else if (rowNum == rowCount)
                {
                    // 应该换列
                    if (colCount != 0 && (regions.Count % colCount) == 0)
                    {
                        rowBreak = true;
                        colBreak = true;
                    }
                    else
                    {
                        rowBreak = false;
                        colBreak = true;
                    }
                }

                if (colBreak)
                {
                    // 换新列,重新累计行数
                    rowNum = 0;
                    if (rowBreak)
                    {
                        // 列数达到后换行显示
                        RptRegion region2 = regions[regions.Count - colCount];
                        region = new RptRegion(
                            region2.Row + region2.RowSpan,
                            region2.Col,
                            0,
                            region2.ColSpan);
                        regions.Add(region);
                    }
                    else
                    {
                        RptRegion region3 = regions[regions.Count - 1];
                        region = new RptRegion(
                            region3.Row,
                            region3.Col + region3.ColSpan,
                            0,
                            region3.ColSpan);
                        regions.Add(region);
                    }

                    // 输出表头
                    if (_header != null)
                    {
                        RptTblHeaderInst header = _header.Clone() as RptTblHeaderInst;
                        header.Region         = region.Clone() as RptRegion;
                        header.Region.RowSpan = header.Item.RowSpan;
                        header.Output();
                        region.RowSpan = (header.Region.Row + header.Region.RowSpan) - region.Row;
                    }

                    tempItem       = tabInst.Item;
                    tabInst.Region = new RptRegion(
                        region.Row + region.RowSpan,
                        region.Col,
                        tempItem.RowSpan,
                        tempItem.ColSpan);
                    tabInst.Output();
                }
                else
                {
                    tabInst.Output();
                }

                region.RowSpan = (tabInst.Region.Row + tabInst.Region.RowSpan) - region.Row;
                if (((tabInst.Region.Row + tabInst.Region.RowSpan) - _region.Row) > _region.RowSpan)
                {
                    _region.RowSpan = (tabInst.Region.Row + tabInst.Region.RowSpan) - _region.Row;
                }

                if (((tabInst.Region.Col + tabInst.Region.ColSpan) - _region.Col) > _region.ColSpan)
                {
                    _region.ColSpan = (tabInst.Region.Col + tabInst.Region.ColSpan) - _region.Col;
                }
                rowNum++;
            }

            if (_footer != null)
            {
                region = _region;
                if (regions.Count > 0)
                {
                    region = regions[regions.Count - 1];
                }
                tempItem       = _footer.Item;
                _footer.Region = new RptRegion(
                    region.Row + region.RowSpan,
                    region.Col,
                    tempItem.RowSpan,
                    tempItem.ColSpan);
                _footer.Output();

                if (((_footer.Region.Row + _footer.Region.RowSpan) - _region.Row) > _region.RowSpan)
                {
                    _region.RowSpan = (_footer.Region.Row + _footer.Region.RowSpan) - _region.Row;
                }

                if (((_footer.Region.Col + _footer.Region.ColSpan) - _region.Col) > _region.ColSpan)
                {
                    _region.ColSpan = (_footer.Region.Col + _footer.Region.ColSpan) - _region.Col;
                }
            }
        }
示例#23
0
文件: RptText.cs 项目: Daoting/dt
 public RptText(RptItemBase p_parent)
     : this(p_parent.Part)
 {
     _parent = p_parent;
 }
示例#24
0
 public RptTblGroupFooterInst(RptItemBase p_item)
     : base(p_item)
 {
 }
示例#25
0
文件: RptTextInst.cs 项目: Daoting/dt
 public RptTextInst(RptItemBase p_item)
     : base(p_item)
 {
 }
示例#26
0
 public RptItemInst(RptItemBase p_item)
 {
     _item   = p_item;
     Visible = true;
 }
示例#27
0
 public RptOutputInst(RptItemBase p_item)
     : base(p_item)
 {
 }
示例#28
0
        public override object Execute(object p_args)
        {
            SubTotalCmdArgs  args       = (SubTotalCmdArgs)p_args;
            RptItemBase      parent     = args.Parent;
            RptMtxHeaderType headerType = RptMtxHeaderType.Col;
            RptMtxSubtotal   total      = args.SubTotal;
            RptMatrix        mtx        = null;

            if (total == null)
            {
                total = new RptMtxSubtotal(parent);
                args.InitData();
                if (parent is RptMtxLevel)
                {
                    RptMtxLevel pLevel = parent as RptMtxLevel;
                    mtx = pLevel.Matrix;
                    if (pLevel.Parent is RptMtxRowHeader)
                    {
                        headerType = RptMtxHeaderType.Row;
                    }
                    total.Item.Val = string.Format("subtotal{0}", mtx.GetMaxTotal());
                    int curIndex = 0;
                    if (headerType == RptMtxHeaderType.Row)
                    {
                        curIndex = pLevel.Row;
                        if (!mtx.HideRowHeader && !mtx.HideColHeader)
                        {
                            curIndex -= (mtx.Corner.Row + mtx.Corner.RowSpan);
                        }
                        args.OpsRows.Add(InsertNewRow(mtx, curIndex));
                    }
                    else
                    {
                        curIndex = pLevel.Col - mtx.Rows[0].Col;
                        foreach (RptMtxRow row in mtx.Rows)
                        {
                            args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
                        }
                    }
                    args.CurIndex = curIndex;
                }
                else
                {
                    RptMtxSubtotal pTotal = parent as RptMtxSubtotal;
                    mtx = pTotal.Level.Matrix;
                    if (pTotal.Level.Parent is RptMtxRowHeader)
                    {
                        headerType = RptMtxHeaderType.Row;
                    }
                    total.Item.Val = string.Format("subtotal{0}", mtx.GetMaxTotal());
                    if (pTotal.SubTotals.Count > 0)
                    {
                        int curIndex = 0;
                        if (headerType == RptMtxHeaderType.Row)
                        {
                            curIndex = pTotal.Row + pTotal.GetCount();
                            if (!mtx.HideColHeader && !mtx.HideRowHeader)
                            {
                                curIndex -= (mtx.Corner.Row + mtx.Corner.RowSpan);
                            }
                            args.OpsRows.Add(InsertNewRow(mtx, curIndex));
                        }
                        else
                        {
                            curIndex = pTotal.Col - mtx.Rows[0].Col + pTotal.GetCount();
                            foreach (RptMtxRow row in mtx.Rows)
                            {
                                args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
                            }
                        }
                        args.CurIndex = curIndex;
                    }
                }
            }
            else
            {
                mtx = total.Level.Matrix;
                args.BackMtxRow();
            }
            if (parent is RptMtxLevel)
            {
                (parent as RptMtxLevel).SubTotals.Add(total);
            }
            else
            {
                (parent as RptMtxSubtotal).SubTotals.Add(total);
            }
            args.SubTotal = total;
            mtx.Update(true);
            return(total);
        }
示例#29
0
 public RptTblGroupHeaderInst(RptItemBase p_item)
     : base(p_item)
 {
 }
示例#30
0
        /// <summary>
        /// 补充报表项及左上的行列定义,处理分页
        /// </summary>
        /// <param name="p_item"></param>
        void PrepareItem(RptItemInst p_item)
        {
            RptRegion   region   = p_item.Region;
            RptItemBase item     = p_item.Item;
            PageDefine  rowPage  = Rows[Rows.Count - 1];
            PageDefine  colPage  = Cols[Cols.Count - 1];
            int         lastRow  = rowPage.Start + rowPage.Count;
            int         lastCol  = colPage.Start + colPage.Count;
            int         deltaRow = region.Row + region.RowSpan - lastRow;
            int         deltaCol = region.Col + region.ColSpan - lastCol;

            //已经垂直分页
            if (region.Row < rowPage.Start && region.Row + region.RowSpan > rowPage.Start)
            {
                deltaRow   = region.RowSpan - rowPage.Count;
                region.Row = rowPage.Start;
            }
            //已经水平分页
            if (region.Col < colPage.Start && region.Col + region.ColSpan > colPage.Start)
            {
                deltaCol   = region.ColSpan - colPage.Count;
                region.Col = colPage.Start;
            }

            // 无需补充
            if (deltaRow <= 0 && deltaCol <= 0)
            {
                return;
            }

            // 补充行定义
            if (deltaRow > 0)
            {
                // 页面已有的总高
                double topHeight = rowPage.Size.Sum();
                int    blankRow  = deltaRow - region.RowSpan;
                double heights   = 0;
                if (blankRow < 0)
                {
                    for (int i = 0; i < deltaRow; i++)
                    {
                        heights += item.Part.GetRowHeight(item.Row + item.RowSpan - deltaRow + i);
                    }

                    //需要分页
                    if (!_pageEnding && topHeight + heights > (BodyHeight - TblFooterHeight) && region.Row != rowPage.Start)
                    {
                        VerPageBreak(ref rowPage, ref topHeight);

                        //从元素的起始位置开始分页
                        for (int j = 0; j < region.RowSpan; j++)
                        {
                            double height = item.Part.GetRowHeight(item.Row + j);
                            rowPage.Size.Add(height);
                            topHeight += height;
                        }
                    }
                    else
                    {
                        //不需要分页
                        for (int i = 0; i < deltaRow; i++)
                        {
                            double height = item.Part.GetRowHeight(item.Row + item.RowSpan - deltaRow + i);
                            if (topHeight + height > (BodyHeight - TblFooterHeight))//元素高度大于页面高度,截断
                            {
                                height = (BodyHeight - TblFooterHeight - topHeight) < 0 ? 0 : BodyHeight - TblFooterHeight - topHeight;
                            }
                            rowPage.Size.Add(height);
                            topHeight += height;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < deltaRow; i++)
                    {
                        double height = item.Part.GetRowHeight(item.Row + item.RowSpan - deltaRow + i);
                        if (i == blankRow)
                        {
                            for (int j = i; j < deltaRow; j++)
                            {
                                heights += item.Part.GetRowHeight(item.Row + item.RowSpan - deltaRow + j);
                            }
                        }

                        // 在报表项上
                        bool inItem = lastRow + i >= region.Row;
                        if (height > BodyHeight - TblFooterHeight)
                        {
                            height = BodyHeight - TblFooterHeight;
                        }
                        if (i == blankRow && heights > BodyHeight - TblFooterHeight)
                        {
                            heights = BodyHeight - TblFooterHeight;
                        }

                        // 需要垂直分页
                        bool verBreak = (i == blankRow) ? (topHeight + heights > BodyHeight - TblFooterHeight)
                            : (topHeight + height > BodyHeight - TblFooterHeight);
                        if (!_pageEnding && verBreak)
                        {
                            VerPageBreak(ref rowPage, ref topHeight, inItem);
                        }
                        rowPage.Size.Add(height);
                        topHeight += height;
                    }
                }

                // 重新计算行位置
                region.Row = rowPage.Start + rowPage.Count - region.RowSpan;
            }

            //补充列定义
            if (deltaCol > 0)
            {
                // 页面已有的宽度
                double leftWidth = colPage.Size.Sum();
                int    blankCol  = deltaCol - region.ColSpan;
                double widths    = 0;

                //不需要补充空行
                if (blankCol < 0)
                {
                    for (int i = 0; i < deltaCol; i++)
                    {
                        widths += Info.Root.Cols[item.Col + item.ColSpan - deltaCol + i];
                    }

                    //需要分页
                    if (!_pageEnding && leftWidth + widths > BodyWidth && region.Col != colPage.Start)
                    {
                        HorPageBreak(ref colPage, ref leftWidth);

                        //从元素的起始位置开始分页
                        for (int j = 0; j < region.ColSpan; j++)
                        {
                            double width = Info.Root.Cols[item.Col + j];
                            colPage.Size.Add(width);
                            leftWidth += width;
                        }
                    }
                    else
                    {
                        //不需要分页
                        for (int i = 0; i < deltaCol; i++)
                        {
                            double width = Info.Root.Cols[item.Col + item.ColSpan - deltaCol + i];
                            if (leftWidth + width > BodyWidth)//元素宽度大于页面宽度,截断
                            {
                                width = (BodyWidth - leftWidth) < 0 ? 0 : BodyWidth - leftWidth;
                            }
                            colPage.Size.Add(width);
                            leftWidth += width;
                        }
                    }
                }
                else
                {
                    //需要空行补充
                    for (int i = 0; i < deltaCol; i++)
                    {
                        double width = Info.Root.Cols[item.Col + item.ColSpan - deltaCol + i];
                        if (i == blankCol)
                        {
                            for (int j = i; j < deltaCol; j++)
                            {
                                widths += Info.Root.Cols[item.Col + item.ColSpan - deltaCol + j];
                            }
                        }

                        // 在报表项上
                        bool inItem = lastCol + i >= region.Col;
                        // 需要水平分页
                        bool horBreak = (i == blankCol) ? (leftWidth + widths > BodyWidth) : (leftWidth + width > BodyWidth);
                        if (!_pageEnding && horBreak)
                        {
                            HorPageBreak(ref colPage, ref leftWidth, inItem);
                        }
                        colPage.Size.Add(width);
                        leftWidth += width;
                    }
                }

                // 重新计算列位置
                region.Col = colPage.Start + colPage.Count - region.ColSpan;
            }
        }