コード例 #1
0
ファイル: TextParser.cs プロジェクト: leonchen09/poc
        public void ReplaceXsl(PartBookmark bookmark)
        {
            if (bookmark == null)
            {
                return;
            }

            int    lineIndex = bookmark.LineIndex;
            string line      = Lines[lineIndex];

            line             = line.Replace(bookmark.Content, bookmark.XslString);
            Lines[lineIndex] = line;
        }
コード例 #2
0
ファイル: TextParser.cs プロジェクト: leonchen09/poc
        private void ParseBookmark()
        {
            Dictionary <string, bool> checks = new Dictionary <string, bool>();

            Bookmarks = new List <PartBookmark>();

            if (Lines == null)
            {
                return;
            }

            for (int lineIndex = 0; lineIndex < Lines.Length; lineIndex++)
            {
                string line = Lines[lineIndex];

                if (string.IsNullOrEmpty(line))
                {
                    continue;
                }

                int prefixLength = 0;
                while (line.Contains(Core.MarkupConstant.PrefixBookmark) && line.Contains(Core.MarkupConstant.SuffixEndBookmark))
                {
                    PartBookmark bookmark = new PartBookmark();
                    bookmark.LineIndex = lineIndex;

                    int startIndex = Mht.PartBookmark.FindString(line, Core.MarkupConstant.PrefixBookmark);
                    int endIndex   = Mht.PartBookmark.FindString(line, Core.MarkupConstant.SuffixEndBookmark, startIndex) +
                                     Core.MarkupConstant.SuffixEndBookmark.Length;
                    bookmark.StartCharIndex = startIndex + prefixLength;
                    bookmark.EndCharIndex   = endIndex + prefixLength;
                    bookmark.Content        = line.Substring(startIndex, endIndex - startIndex);

                    if (!string.IsNullOrEmpty(bookmark.Key) && !string.IsNullOrEmpty(bookmark.BizName))
                    {
                        if (!checks.ContainsKey(bookmark.Key))
                        {
                            Bookmarks.Add(bookmark);
                            checks.Add(bookmark.Key, true);
                        }
                    }

                    prefixLength = prefixLength + endIndex;
                    line         = line.Substring(endIndex);
                }
            }
        }
コード例 #3
0
 private void UpdateBookmarkPart(PartBookmark bookmark)
 {
     _textParser.ReplaceXsl(bookmark);
 }
コード例 #4
0
        private void ReplaceBookmarkTag()
        {
            _foreach = new List <ForeachItem>();
            for (int index = 0; index < _textParser.Bookmarks.Count; index++)
            {
                PartBookmark  bookmark       = _textParser.Bookmarks[index];
                List <string> selectedTables = GetSelectedTables(bookmark);
                Relations     relations      = GetRelations(bookmark);
                if (!bookmark.IsDelete)
                {
                    string xslPath = string.Empty;
                    switch (bookmark.Type)
                    {
                    case Core.BookmarkType.EndForeach:
                        bookmark.XslString = Mht.XslContent.XslFormat.XslEndForeach;
                        if (_foreach.Count > 0)
                        {
                            _foreach.RemoveAt(_foreach.Count - 1);
                        }
                        UpdateBookmarkPart(bookmark);
                        break;

                    case Core.BookmarkType.EndIf:
                        bookmark.XslString = Mht.XslContent.XslFormat.XslEndIf;
                        UpdateBookmarkPart(bookmark);
                        break;

                    case Core.BookmarkType.Image:
                        break;

                    case Core.BookmarkType.Select:
                        xslPath            = GetXslPath(bookmark, bookmark.BizName, false, selectedTables, relations);
                        bookmark.XslString = Mht.XslContent.XslValueOfTag(xslPath, false);
                        UpdateBookmarkPart(bookmark);
                        break;

                    case Core.BookmarkType.StartIf:
                        xslPath            = GetXslPath(bookmark, bookmark.BizName, true, selectedTables, relations);
                        bookmark.XslString = Mht.XslContent.XslStartIfTag(xslPath, false);
                        UpdateBookmarkPart(bookmark);
                        break;

                    case Core.BookmarkType.StartForeach:
                        int    indexForeach = _foreach.Count + 1;
                        string variant      = Core.MarkupConstant.XslVariableImage + index.ToString();
                        InternalBookmarkDomain ibmDomain = _ibm.GetInternalBookmarkDomainByItemKey(bookmark.Key);
                        ForeachItem            fItem     = new ForeachItem(index, _textParser.Bookmarks.Cast <Base.BaseBookmark>(),
                                                                           relations, ibmDomain.SelectedTables,
                                                                           indexForeach, variant, string.Empty);
                        _foreach.Add(fItem);

                        xslPath = GetXslPath(bookmark, string.Empty, false, selectedTables, relations);
                        InternalBookmarkItem ibmItem = _ibm.GetInternalBookmarkItem(bookmark.Key);
                        string sort = GetSortXsl(bookmark.BizName, ibmItem.DomainName, selectedTables, relations, false);
                        bookmark.XslString = Mht.XslContent.XslStartForeachTag(xslPath,
                                                                               variant, Core.MarkupConstant.XslMultiPosition, sort, false);
                        fItem.XslString = bookmark.XslString;

                        UpdateBookmarkPart(bookmark);
                        break;

                    default:
                        break;
                    }
                }
            }
        }