コード例 #1
0
            public void DataRender(Page _page, Func <IDATA, IPager> _pagerFunc, DataRender_WhilePageFunc _dataRender_WhilePageFunc, DataRender_WhilePage_TrGroupFunc _dataRender_WhilePage_TrGroupFunc)
            {
                string content = _page.template.ToString();

                for (int i = 0, iMax = _page.tables.Count; i < iMax; i++)
                {
                    _page.data.TemplateTableIndex = i;

                    Template.Table templateTable = _page.tables[i];

                    //if (i == 1)
                    //{
                    //    int debug = 0;
                    //}

                    //InnerDataRender innerDataRender = new InnerDataRender();

                    //innerDataRender.DataRender(_pagerFunc, templateTable, _page.data, i, 0, _dataReader_WhilePage_TrGroupFunc, _dataReader_WhilePageFunc, new DataRender_WhilePage_LoopFunc(_page.DataRender_WhilePage_Loop));

                    // ===

                    Page.InnerDataRender.DataRender2(_pagerFunc, templateTable, _page.data, i, 0, 0, _dataRender_WhilePage_TrGroupFunc, _dataRender_WhilePageFunc, new DataRender_WhilePage_LoopFunc(_page.DataRender_WhilePage_Loop));

                    templateTable.Combine();
                }

                _page.TableCombine();
            }
コード例 #2
0
        public static void TemplateInit(Page _page, Template _template, List <Template.Table> _tables)
        {
            string content = _template.ToString();

            string templateTag = Page.TemplateTag;

            string tableReplaceHolderTemplateTag = string.Format(Page.ReplaceHolderTemplateTag, "TABLE", "{0}");

            List <Template.BlockInfo> tableTemplateArray = Template.Blocks(ref content, templateTag, "Template_TABLE", "/Template_TABLE", _replaceHolderTemplateTag: tableReplaceHolderTemplateTag);

            _page.ContentRef(ref content);

            // ===

            int tableIndex = -1;

            foreach (var tableTemplateHolder in tableTemplateArray)
            {
                tableIndex++;

                // ===

                _tables.Add(new Template.Table(tableTemplateHolder, _template));

                Template.Table table = _tables[tableIndex];

                Page.TemplateInit_TemplateTableTrGroup(ref table, ref tableIndex, 0, 0, 0, tableTemplateHolder);
            }
        }
コード例 #3
0
        public void DataRender_WhilePage(Template.Table _templateTable, int _tableIndex, int _trGroupIndex, Pager _pager, IDATA _data, DataRender_WhilePage_LoopFunc _dataRender_WhilePage_LoopFunc)
        {
            Template.TR templateTr = null;

            int trIndex = -1;

            var emptyTR = _templateTable.GTRs[_trGroupIndex].TRs.FirstOrDefault(tr => !tr.IsRendered);

            if (emptyTR != null)
            {
                trIndex = _templateTable.GTRs[_trGroupIndex].TRs.IndexOf(emptyTR);
            }
            else
            {
                _templateTable.GTRs[_trGroupIndex].TRs.Add(new Template.TR(_templateTable.GTRs[_trGroupIndex].TRs[0]));

                trIndex = _templateTable.GTRs[_trGroupIndex].TRs.Count - 1;
            }

            _templateTable.TLogs.Add(new Template.Table.TLog(_trGroupIndex, trIndex));
            //
            templateTr = _templateTable.GTRs[_trGroupIndex].TRs[trIndex];

            #region ADD ref IDATA

            templateTr.DATA = _data;

            #endregion

            for (int ii = _pager.PagerInfo.DefaultPageInfo.beginIndex, iiIndex = 0; ii <= _pager.PagerInfo.DefaultPageInfo.endIndex; ii++, iiIndex++)
            {
                // td s -> loop
                //
                _dataRender_WhilePage_LoopFunc(templateTr, _pager, _data, ii, iiIndex);
            }

            templateTr.Combine();
        }
コード例 #4
0
            public static void DataRender2(Func <IDATA, IPager> _pagerFunc, Template.Table _templateTable, IDATA _data, int _tableIndex, int _zIndex, int _innerTableIndex, DataRender_WhilePage_TrGroupFunc _dataRender_WhilePage_TrGroupFunc, DataRender_WhilePageFunc _dataRender_WhilePageFunc, DataRender_WhilePage_LoopFunc _dataRender_WhilePage_LoopFunc)
            {
                Pager pager = (Pager)_pagerFunc(_data);

                while (pager.Next())
                {
                    //if (pager.CurrentPage == 3)
                    //{
                    //    int debug = 0;
                    //}

                    //if (pager.CurrentPage == 5)
                    //{
                    //    int debug = 0;
                    //}

                    //if (pager.CurrentPage == 6)
                    //{
                    //    int debug = 0;
                    //}

                    //if (pager.CurrentPage == 1)
                    //{
                    //    int debug = 0;
                    //}

                    //if (pager.CurrentPage == 2)
                    //{
                    //    int debug = 0;
                    //}

                    int trGroupIndex = 0;

                    //try
                    //{
                    trGroupIndex = _dataRender_WhilePage_TrGroupFunc(_templateTable, _tableIndex, _zIndex, _innerTableIndex, pager, _data);

                    //    // int trGroupIndex = _templateTable.PrepareTrGroup(((Page.DATA2)_data)[_tableIndex][_innerTableIndex]);

                    //}
                    //catch (Exception e)
                    //{
                    //    int __debug__ = 0;
                    //}

                    if (_templateTable.GTRs[trGroupIndex].TRs != null)
                    {
                        //try
                        //{
                        //    // data1 : 1p <=> n datarow
                        //    // data2 : 1p <=> 1 rowitems => n items
                        //    //
                        _dataRender_WhilePageFunc(_templateTable, _tableIndex, trGroupIndex, pager, _data, _dataRender_WhilePage_LoopFunc);
                        //    //
                        //    ////((DATA)_data).DataLayers.Add(new DATA.Layer() { ZIndex = _zIndex, Page = pager.CurrentPage, Begin = pager.PagerInfo.DefaultPageInfo.beginIndex, End = pager.PagerInfo.DefaultPageInfo.endIndex, InnerTableIndex = _innerTableIndex, TrGroupIndex = trGroupIndex, IsEndPoint = true });
                        //}
                        //catch (Exception e2)
                        //{
                        //    int __debug2__ = 0;
                        //}
                    }
                    else if (_templateTable.GTRs[trGroupIndex].InnerTables != null)
                    {
                        /* for DATA2 */

                        for (int i = 0, iMax = _templateTable.GTRs[trGroupIndex].InnerTables.Count; i < iMax; i++)
                        {
                            Template.Table innerTable = _templateTable.GTRs[trGroupIndex].InnerTables[i];

                            var innerDATA = ((DATA2)(_data))[_tableIndex][pager.CurrentPage - 1].InnerRowItems[i];

                            if (innerDATA == null)
                            {
                                throw new ArgumentException(string.Format("InnerTables DATA NULL [trGroupIndex:{0}] [tableIndex:{1}] [currentPage:{2}]", trGroupIndex, _tableIndex, pager.CurrentPage));
                            }

                            DATA2 innerDATA2 = new DATA2((DATA2)_data);

                            innerDATA2.Add(0, innerDATA);

                            //InnerDataRender innerDataRender = new InnerDataRender();

                            ////((DATA)_data).DataLayers.Add(new DATA.Layer() { ZIndex = _zIndex, Page = pager.CurrentPage, Begin = pager.PagerInfo.DefaultPageInfo.beginIndex, End = pager.PagerInfo.DefaultPageInfo.endIndex, InnerTableIndex = i, TrGroupIndex = trGroupIndex, IsEndPoint = false });
                            //
                            Page.InnerDataRender.DataRender2(_pagerFunc, innerTable, innerDATA2, _tableIndex, (_zIndex + 1), (i), _dataRender_WhilePage_TrGroupFunc, _dataRender_WhilePageFunc, _dataRender_WhilePage_LoopFunc);
                            //
                            // # 2018.06.07 # disabled
                            //
                            //_templateTable.TLogs.Add(new Template.Table.TLog(trGroupIndex, -1));
                            //
                        }
                        //
                        // # 2018.06.07 # enable
                        //
                        _templateTable.TLogs.Add(new Template.Table.TLog(trGroupIndex, -1));
                        //
                    }

                    //if (pager.CurrentPage == 3)
                    //{
                    //    int debug = 0;
                    //}
                }
            }
コード例 #5
0
        public static void FillTRContainerTemplate(ref Template.Table table, ref int tableIndex, ref int trGroupIndex, ref int trIndex, ref int tdIndex, Template.BlockInfo sourceTemplateHolder, ref string templateTag)
        {
            #region new TR Container || not ( Default: new TR TemplateHolder )

            List <Template.BlockInfo> trContainerTemplateArray = Template.Blocks(sourceTemplateHolder.Value, templateTag, "Template_Container", "/Template_Container", _searchBeforeTag: "Template_TR");

            List <Template.BlockInfo> trTemplateArray = null;

            Template.BlockInfo trContainer = null;

            if (trContainerTemplateArray.Count >= 1)
            {
                trContainer = trContainerTemplateArray[0];

                trTemplateArray = Template.Blocks(trContainer.Value, templateTag, "Template_TR", "Template_TR");
            }
            else
            {
                trContainer = null;

                trTemplateArray = Template.Blocks(sourceTemplateHolder.Value, templateTag, "Template_TR", "Template_TR");
            }

            if (table.GTRs[trGroupIndex] == null)
            {
                table.GTRs[trGroupIndex] = new Template.Block <Template.TR> .TGroup <Template.TR>();
            }

            #region new TR s ( Container & TemplateHolder )

            trIndex = -1;

            foreach (var trTemplateHolder in trTemplateArray)
            {
                trIndex++;

                //if (trIndex == 0)
                //{
                //    int __debug__ = 0;
                //}

                if (trIndex == 0)
                {
                    trTemplateHolder.FillTemplateRef(table);
                    trContainer.FillTemplateRef(table);
                    //
                    // # DATA Item & Template.TagInfo #
                    //
                    // debug pause
                    //
                    //trTemplateHolder.FillTagInfos();
                    //trContainer.FillTagInfos();
                }

                var TRsList = table.GTRs[trGroupIndex].TRs;

                TRsList.Add(new Template.TR(trTemplateHolder, trContainer));

                var TRz = TRsList[TRsList.Count - 1];

                #region new TD Container || not ( Default: new TD TemplateHolder )

                List <Template.BlockInfo> tdContainerTemplateArray = Template.Blocks(trTemplateHolder.Value, templateTag, "Template_Container", "/Template_Container", _searchBeforeTag: "Template_TD");

                List <Template.BlockInfo> tdTemplateArray = null;

                Template.BlockInfo tdContainer = null;

                if (tdContainerTemplateArray.Count >= 1)
                {
                    tdContainer = tdContainerTemplateArray[0];

                    tdTemplateArray = Template.Blocks(tdContainer.Value, templateTag, "Template_TD", "Template_TD");
                }
                else
                {
                    tdContainer = null;

                    tdTemplateArray = Template.Blocks(trTemplateHolder.Value, templateTag, "Template_TD", "Template_TD");
                }

                #region new TD s ( Container & TemplateHolder )

                tdIndex = -1;

                foreach (var tdTemplateHolder in tdTemplateArray)
                {
                    tdIndex++;

                    if (tdIndex == 0)
                    {
                        tdTemplateHolder.FillTemplateRef(table);
                        tdContainer.FillTemplateRef(table);
                        //
                        // # DATA Item & Template.TagInfo #
                        //
                        tdTemplateHolder.FillTagInfos();
                        //
                        // debug pause
                        //
                        //tdContainer.FillTagInfos();
                    }

                    var TDsList = TRsList[trIndex].TDs;

                    TDsList.Add(new Template.TD(null, tdTemplateHolder, tdContainer));

                    var TDz = TDsList[TDsList.Count - 1];

                    #region TD Pair

                    TDz.Pairs = TDz.Container.ToPairs(tdTemplateHolder);

                    #endregion
                }

                #endregion

                #endregion

                #region TR Pair s

                var TDzFirst = TRz.TDs[0];
                var TDzLast  = TRz.TDs[TRz.TDs.Count - 1];

                var pairs = TRz.TemplateHolder.ToPairs(TDzFirst.Container ?? TDzFirst.TemplateHolder, TDzLast.Container ?? TDzLast.TemplateHolder);

                TRz.Pairs = TRz.Pairs.Append(pairs);

                if (TRz.Container != null)
                {
                    TRz.Pairs = TRz.Pairs.Append(TRz.Container.ToPairs(TRz.TemplateHolder));
                }

                #endregion
            }

            #endregion

            #endregion
        }
コード例 #6
0
        public static void TemplateInit_TemplateTableTrGroup(ref Template.Table table, ref int tableIndex, int trGroupIndex, int trIndex, int tdIndex, Template.BlockInfo tableTemplateHolder)
        {
            table.GTRs = new Template.Block <Template.TR> .Group <Template.TR>();

            List <Template.BlockInfo> trGroupTemplateArray = Template.Blocks(tableTemplateHolder.Value, Page.TemplateTag, "Template_TRGroup", "/Template_TRGroup");

            #region None Template_TRGroup

            if (trGroupTemplateArray.Count == 0)
            {
                trGroupIndex = 0;

                Page.FillTRContainerTemplate(ref table, ref tableIndex, ref trGroupIndex, ref trIndex, ref tdIndex, tableTemplateHolder, ref Page.TemplateTag);

                #region GTR Pair <= Tr

                var pTRz = table.GTRs[trGroupIndex];

                var TRzFirst = pTRz.TRs[0];
                var TRzLast  = pTRz.TRs[pTRz.TRs.Count - 1];

                pTRz.Pairs = pTRz.Pairs.Append(pTRz.TemplateHolder.ToPairs(TRzFirst.Container ?? TRzFirst.TemplateHolder, TRzLast.Container ?? TRzLast.TemplateHolder));

                #endregion

                // return => outside (for) continue
                //
                return;
            }

            #endregion

            trGroupIndex = -1;

            foreach (var trGroupTemplateHolder in trGroupTemplateArray)
            {
                trGroupIndex++;

                string templateSource = trGroupTemplateHolder.Value;

                List <Template.BlockInfo> innerTableTemplateArray = Template.Blocks(ref templateSource, Page.TemplateTag, "Template_TABLE", "/Template_TABLE");

                if (innerTableTemplateArray.Count == 0)
                {
                    #region None Table Template

                    table.GTRs[trGroupIndex] = new Template.Block <Template.TR> .TGroup <Template.TR>(trGroupTemplateHolder);

                    Page.FillTRContainerTemplate(ref table, ref tableIndex, ref trGroupIndex, ref trIndex, ref tdIndex, trGroupTemplateHolder, ref Page.TemplateTag);

                    #region GTR Pair <= Tr

                    var pTRz = table.GTRs[trGroupIndex];

                    var TRzFirst = pTRz.TRs[0];
                    var TRzLast  = pTRz.TRs[pTRz.TRs.Count - 1];

                    pTRz.Pairs = pTRz.Pairs.Append(pTRz.TemplateHolder.ToPairs(TRzFirst.Container ?? TRzFirst.TemplateHolder, TRzLast.Container ?? TRzLast.TemplateHolder));

                    #endregion

                    #endregion
                }
                else
                {
                    //// for 1 Template_TABLE
                    ////
                    //foreach (var innerTableTemplateHolder in innerTableTemplateArray)
                    //{
                    //    table.GTRs[trGroupIndex] = new Template.Block<Template.TR>.TGroup<Template.TR>(trGroupTemplateHolder, innerTableTemplateHolder);

                    //    Template.Table innerTable = table.GTRs[trGroupIndex].InnerTable;

                    //    Page.TemplateInit_TemplateTableTrGroup(ref innerTable, ref tableIndex, 0, 0, 0, innerTableTemplateHolder);
                    //}

                    #region n || 1 Table s Template

                    table.GTRs[trGroupIndex] = new Template.Block <Template.TR> .TGroup <Template.TR>(trGroupTemplateHolder, innerTableTemplateArray);

                    for (int i = 0, iMax = table.GTRs[trGroupIndex].InnerTables.Count; i < iMax; i++)
                    {
                        Template.Table innerTable = table.GTRs[trGroupIndex].InnerTables[i];

                        Page.TemplateInit_TemplateTableTrGroup(ref innerTable, ref tableIndex, 0, 0, 0, innerTable.TemplateHolder);
                    }

                    #region GTR Pair <= Table s

                    var pTRz = table.GTRs[trGroupIndex];

                    var tableTemplateFirst = pTRz.InnerTables[0];
                    var tableTemplateLast  = pTRz.InnerTables[pTRz.InnerTables.Count - 1];

                    pTRz.Pairs = pTRz.Pairs.Append(pTRz.TemplateHolder.ToPairs(tableTemplateFirst.TemplateHolder, tableTemplateLast.TemplateHolder));

                    #endregion

                    #endregion
                }
            }

            return;
        }