示例#1
0
        //--------------------------------------------------------------------
        //
        // Private Methods
        //
        //---------------------------------------------------------------------


        #region Private methods

        private void _ProcessImage(DependencyObject obj, FixedNode fixedNode)
        {
            Debug.Assert(obj is Image || obj is Path);
            FixedSOMImage somImage = null;

            while (true)
            {
                Image image = obj as Image;
                if (image != null)
                {
                    somImage = FixedSOMImage.Create(_fixedPage, image, fixedNode);
                    break;
                }
                Path path = obj as Path;
                if (path != null)
                {
                    somImage = FixedSOMImage.Create(_fixedPage, path, fixedNode);
                    break;
                }
            }
            //Create a wrapper FixedBlock:

            FixedSOMFixedBlock fixedBlock = new FixedSOMFixedBlock(_fixedSOMPage);

            fixedBlock.AddImage(somImage);
            _fixedSOMPage.AddFixedBlock(fixedBlock);
            _currentFixedBlock = fixedBlock;
        }
示例#2
0
        // Token: 0x06002DF8 RID: 11768 RVA: 0x000CE9D4 File Offset: 0x000CCBD4
        private void _ProcessImage(DependencyObject obj, FixedNode fixedNode)
        {
            Image image;
            Path  path;

            for (;;)
            {
                image = (obj as Image);
                if (image != null)
                {
                    break;
                }
                path = (obj as Path);
                if (path != null)
                {
                    goto Block_1;
                }
            }
            FixedSOMImage image2 = FixedSOMImage.Create(this._fixedPage, image, fixedNode);

            goto IL_34;
Block_1:
            image2 = FixedSOMImage.Create(this._fixedPage, path, fixedNode);
IL_34:
            FixedSOMFixedBlock fixedSOMFixedBlock = new FixedSOMFixedBlock(this._fixedSOMPage);

            fixedSOMFixedBlock.AddImage(image2);
            this._fixedSOMPage.AddFixedBlock(fixedSOMFixedBlock);
            this._currentFixedBlock = fixedSOMFixedBlock;
        }
示例#3
0
        //Creates a FixedSOMTextRun, and updates containing structures
        private void _CreateTextRun(Rect boundingRect, GeneralTransform trans, Glyphs glyphs, FixedNode node, int startIndex, int endIndex)
        {
            if (startIndex < endIndex)
            {
                FixedSOMTextRun textRun = FixedSOMTextRun.Create(boundingRect,
                                                                 trans,
                                                                 glyphs,
                                                                 node,
                                                                 startIndex,
                                                                 endIndex,
                                                                 true);


                FixedSOMFixedBlock fixedBlock = _GetContainingFixedBlock(textRun);

                if (fixedBlock == null)
                {
                    fixedBlock = new FixedSOMFixedBlock(_fixedSOMPage);
                    fixedBlock.AddTextRun(textRun);
                    _fixedSOMPage.AddFixedBlock(fixedBlock);
                }
                else
                {
                    fixedBlock.AddTextRun(textRun);
                }
                _currentFixedBlock = fixedBlock;
            }
        }
示例#4
0
        //Find and return a FixedBlock that would contain this TextRun
        private FixedSOMFixedBlock _GetContainingFixedBlock(FixedSOMTextRun textRun)
        {
            FixedSOMFixedBlock fixedBlock = null;

            if (_currentFixedBlock == null)
            {
                return(null);
            }

            if (_currentFixedBlock != null && _IsCombinable(_currentFixedBlock, textRun))
            {
                fixedBlock = _currentFixedBlock;
            }
            else
            {
                //If this is aligned with the previous block, simply create a new block
                Rect textRunRect    = textRun.BoundingRect;
                Rect fixedBlockRect = _currentFixedBlock.BoundingRect;
                if (Math.Abs(textRunRect.Left - fixedBlockRect.Left) <= textRun.DefaultCharWidth ||
                    Math.Abs(textRunRect.Right - fixedBlockRect.Right) <= textRun.DefaultCharWidth)
                {
                    return(null);
                }
                foreach (FixedSOMSemanticBox box in _fixedSOMPage.SemanticBoxes)
                {
                    if ((box is FixedSOMFixedBlock) && _IsCombinable(box as FixedSOMFixedBlock, textRun))
                    {
                        fixedBlock = box as FixedSOMFixedBlock;
                    }
                }
            }
            return(fixedBlock);
        }
示例#5
0
        // Token: 0x06002DFB RID: 11771 RVA: 0x000CED00 File Offset: 0x000CCF00
        private FixedSOMFixedBlock _GetContainingFixedBlock(FixedSOMTextRun textRun)
        {
            FixedSOMFixedBlock result = null;

            if (this._currentFixedBlock == null)
            {
                return(null);
            }
            if (this._currentFixedBlock != null && this._IsCombinable(this._currentFixedBlock, textRun))
            {
                result = this._currentFixedBlock;
            }
            else
            {
                Rect boundingRect  = textRun.BoundingRect;
                Rect boundingRect2 = this._currentFixedBlock.BoundingRect;
                if (Math.Abs(boundingRect.Left - boundingRect2.Left) <= textRun.DefaultCharWidth || Math.Abs(boundingRect.Right - boundingRect2.Right) <= textRun.DefaultCharWidth)
                {
                    return(null);
                }
                foreach (FixedSOMSemanticBox fixedSOMSemanticBox in this._fixedSOMPage.SemanticBoxes)
                {
                    if (fixedSOMSemanticBox is FixedSOMFixedBlock && this._IsCombinable(fixedSOMSemanticBox as FixedSOMFixedBlock, textRun))
                    {
                        result = (fixedSOMSemanticBox as FixedSOMFixedBlock);
                    }
                }
            }
            return(result);
        }
示例#6
0
        //--------------------------------------------------------------------
        //
        // Public methods
        //
        //---------------------------------------------------------------------

        public void AddContainer(FixedSOMPageElement pageElement)
        {
            FixedSOMFixedBlock block = pageElement as FixedSOMFixedBlock;

            if (block == null || (!block.IsFloatingImage && !block.IsWhiteSpace))
            {
                if (pageElement.IsRTL)
                {
                    _RTLCount++;
                }
                else
                {
                    _LTRCount++;
                }
            }

            _semanticBoxes.Add(pageElement);

            if (_boundingRect.IsEmpty)
            {
                _boundingRect = pageElement.BoundingRect;
            }
            else
            {
                _boundingRect.Union(pageElement.BoundingRect);
            }
        }
示例#7
0
        private void _CombinePass()
        {
            if (_fixedSOMPage.SemanticBoxes.Count < 2)
            {
                //Nothing to do
                return;
            }

            int prevBoxCount;

            do
            {
                prevBoxCount = _fixedSOMPage.SemanticBoxes.Count;

                List <FixedSOMSemanticBox> boxes = _fixedSOMPage.SemanticBoxes;
                for (int i = 0; i < boxes.Count; i++)
                {
                    FixedSOMTable table1 = boxes[i] as FixedSOMTable;
                    if (table1 != null)
                    {
                        //Check for nested tables
                        for (int j = i + 1; j < boxes.Count; j++)
                        {
                            FixedSOMTable table2 = boxes[j] as FixedSOMTable;
                            if (table2 != null &&
                                table1.AddContainer(table2))
                            {
                                boxes.Remove(table2);
                            }
                        }
                        continue;
                    }


                    FixedSOMFixedBlock box1 = boxes[i] as FixedSOMFixedBlock;
                    if (box1 == null || box1.IsFloatingImage)
                    {
                        continue;
                    }

                    for (int j = i + 1; j < boxes.Count; j++)
                    {
                        FixedSOMFixedBlock box2 = boxes[j] as FixedSOMFixedBlock;
                        if (box2 != null && !box2.IsFloatingImage &&
                            box2.Matrix.Equals(box1.Matrix) &&
                            (_IsSpatiallyCombinable(box1, box2, 0, 0)))
                        {
                            {
                                box1.CombineWith(box2);
                                boxes.Remove(box2);
                            }
                        }
                    }
                }
            } while (_fixedSOMPage.SemanticBoxes.Count > 1 && _fixedSOMPage.SemanticBoxes.Count != prevBoxCount);
        }
示例#8
0
 // Token: 0x06002DBC RID: 11708 RVA: 0x000CDC50 File Offset: 0x000CBE50
 public void CombineWith(FixedSOMFixedBlock block)
 {
     foreach (FixedSOMSemanticBox fixedSOMSemanticBox in block.SemanticBoxes)
     {
         FixedSOMTextRun fixedSOMTextRun = fixedSOMSemanticBox as FixedSOMTextRun;
         if (fixedSOMTextRun != null)
         {
             this.AddTextRun(fixedSOMTextRun);
         }
         else
         {
             base.Add(fixedSOMSemanticBox);
         }
     }
 }
示例#9
0
 public void CombineWith(FixedSOMFixedBlock block)
 {
     foreach (FixedSOMSemanticBox box in block.SemanticBoxes)
     {
         FixedSOMTextRun run = box as FixedSOMTextRun;
         if (run != null)
         {
             AddTextRun(run);
         }
         else
         {
             base.Add(box);
         }
     }
 }
示例#10
0
        // Token: 0x06002E01 RID: 11777 RVA: 0x000CF564 File Offset: 0x000CD764
        private void _CombinePass()
        {
            if (this._fixedSOMPage.SemanticBoxes.Count < 2)
            {
                return;
            }
            int count;

            do
            {
                count = this._fixedSOMPage.SemanticBoxes.Count;
                List <FixedSOMSemanticBox> semanticBoxes = this._fixedSOMPage.SemanticBoxes;
                for (int i = 0; i < semanticBoxes.Count; i++)
                {
                    FixedSOMTable fixedSOMTable = semanticBoxes[i] as FixedSOMTable;
                    if (fixedSOMTable != null)
                    {
                        for (int j = i + 1; j < semanticBoxes.Count; j++)
                        {
                            FixedSOMTable fixedSOMTable2 = semanticBoxes[j] as FixedSOMTable;
                            if (fixedSOMTable2 != null && fixedSOMTable.AddContainer(fixedSOMTable2))
                            {
                                semanticBoxes.Remove(fixedSOMTable2);
                            }
                        }
                    }
                    else
                    {
                        FixedSOMFixedBlock fixedSOMFixedBlock = semanticBoxes[i] as FixedSOMFixedBlock;
                        if (fixedSOMFixedBlock != null && !fixedSOMFixedBlock.IsFloatingImage)
                        {
                            for (int k = i + 1; k < semanticBoxes.Count; k++)
                            {
                                FixedSOMFixedBlock fixedSOMFixedBlock2 = semanticBoxes[k] as FixedSOMFixedBlock;
                                if (fixedSOMFixedBlock2 != null && !fixedSOMFixedBlock2.IsFloatingImage && fixedSOMFixedBlock2.Matrix.Equals(fixedSOMFixedBlock.Matrix) && this._IsSpatiallyCombinable(fixedSOMFixedBlock, fixedSOMFixedBlock2, 0.0, 0.0))
                                {
                                    fixedSOMFixedBlock.CombineWith(fixedSOMFixedBlock2);
                                    semanticBoxes.Remove(fixedSOMFixedBlock2);
                                }
                            }
                        }
                    }
                }
            }while (this._fixedSOMPage.SemanticBoxes.Count > 1 && this._fixedSOMPage.SemanticBoxes.Count != count);
        }
示例#11
0
        public bool AddContainer(FixedSOMContainer container)
        {
            Rect bounds = container.BoundingRect;


            //Allow couple pixels margin
            double verticalOverlap   = bounds.Height * 0.2;
            double horizontalOverlap = bounds.Width * 0.2;

            bounds.Inflate(-horizontalOverlap, -verticalOverlap);

            if (this.BoundingRect.Contains(bounds))
            {
                foreach (FixedSOMTableRow row in this.SemanticBoxes)
                {
                    if (row.BoundingRect.Contains(bounds))
                    {
                        foreach (FixedSOMTableCell cell in row.SemanticBoxes)
                        {
                            if (cell.BoundingRect.Contains(bounds))
                            {
                                cell.AddContainer(container);
                                FixedSOMFixedBlock block = container as FixedSOMFixedBlock;
                                if (block != null)
                                {
                                    if (block.IsRTL)
                                    {
                                        _RTLCount++;
                                    }
                                    else
                                    {
                                        _LTRCount++;
                                    }
                                }
                                return(true);
                            }
                        }
                    }
                }
            }
            return(false);
        }
示例#12
0
        // Token: 0x06002E21 RID: 11809 RVA: 0x000D05D4 File Offset: 0x000CE7D4
        public bool AddContainer(FixedSOMContainer container)
        {
            Rect   boundingRect = container.BoundingRect;
            double num          = boundingRect.Height * 0.2;
            double num2         = boundingRect.Width * 0.2;

            boundingRect.Inflate(-num2, -num);
            if (base.BoundingRect.Contains(boundingRect))
            {
                foreach (FixedSOMSemanticBox fixedSOMSemanticBox in base.SemanticBoxes)
                {
                    FixedSOMTableRow fixedSOMTableRow = (FixedSOMTableRow)fixedSOMSemanticBox;
                    if (fixedSOMTableRow.BoundingRect.Contains(boundingRect))
                    {
                        foreach (FixedSOMSemanticBox fixedSOMSemanticBox2 in fixedSOMTableRow.SemanticBoxes)
                        {
                            FixedSOMTableCell fixedSOMTableCell = (FixedSOMTableCell)fixedSOMSemanticBox2;
                            if (fixedSOMTableCell.BoundingRect.Contains(boundingRect))
                            {
                                fixedSOMTableCell.AddContainer(container);
                                FixedSOMFixedBlock fixedSOMFixedBlock = container as FixedSOMFixedBlock;
                                if (fixedSOMFixedBlock != null)
                                {
                                    if (fixedSOMFixedBlock.IsRTL)
                                    {
                                        this._RTLCount++;
                                    }
                                    else
                                    {
                                        this._LTRCount++;
                                    }
                                }
                                return(true);
                            }
                        }
                    }
                }
                return(false);
            }
            return(false);
        }
        // Token: 0x06002DC3 RID: 11715 RVA: 0x000CDE50 File Offset: 0x000CC050
        public void AddContainer(FixedSOMPageElement pageElement)
        {
            FixedSOMFixedBlock fixedSOMFixedBlock = pageElement as FixedSOMFixedBlock;

            if (fixedSOMFixedBlock == null || (!fixedSOMFixedBlock.IsFloatingImage && !fixedSOMFixedBlock.IsWhiteSpace))
            {
                if (pageElement.IsRTL)
                {
                    this._RTLCount++;
                }
                else
                {
                    this._LTRCount++;
                }
            }
            this._semanticBoxes.Add(pageElement);
            if (this._boundingRect.IsEmpty)
            {
                this._boundingRect = pageElement.BoundingRect;
                return;
            }
            this._boundingRect.Union(pageElement.BoundingRect);
        }
示例#14
0
        private bool _IsCombinable(FixedSOMFixedBlock fixedBlock, FixedSOMTextRun textRun)
        {
            Debug.Assert(fixedBlock.SemanticBoxes.Count > 0);
            if (fixedBlock.SemanticBoxes.Count == 0)
            {
                return(false);
            }

            //Currently we do not support inline images
            if (fixedBlock.IsFloatingImage)
            {
                return(false);
            }

            Rect textRunRect    = textRun.BoundingRect;
            Rect fixedBlockRect = fixedBlock.BoundingRect;

            FixedSOMTextRun compareLine = null;
            FixedSOMTextRun lastLine    = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMTextRun;

            if (lastLine != null && textRunRect.Bottom <= lastLine.BoundingRect.Top)
            {
                //This run is above the last run of the fixed block. Can't be the same paragraph
                return(false);
            }

            bool fixedBlockBelow = false;
            bool textRunBelow    = false;
            //Allow 20% overlap
            double verticalOverlap = textRunRect.Height * 0.2;

            if (textRunRect.Bottom - verticalOverlap < fixedBlockRect.Top)
            {
                fixedBlockBelow = true;
                compareLine     = fixedBlock.SemanticBoxes[0] as FixedSOMTextRun;
            }
            else if (textRunRect.Top + verticalOverlap > fixedBlockRect.Bottom)
            {
                textRunBelow = true;
                compareLine  = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMTextRun;
            }

            if ((fixedBlock.IsWhiteSpace || textRun.IsWhiteSpace) &&
                (fixedBlock != _currentFixedBlock || compareLine != null || !_IsSpatiallyCombinable(fixedBlockRect, textRunRect, textRun.DefaultCharWidth * 3, 0))
                )
            {
                //When combining with white spaces, they need to be consecutive in markup and need to be on the same line.
                return(false);
            }
            if (fixedBlock.Matrix.M11 != textRun.Matrix.M11 ||
                fixedBlock.Matrix.M12 != textRun.Matrix.M12 ||
                fixedBlock.Matrix.M21 != textRun.Matrix.M21 ||
                fixedBlock.Matrix.M22 != textRun.Matrix.M22)
            {
                //We don't allow combining TextRuns with different scale/rotation properties
                return(false);
            }

            Debug.Assert(textRunRect.Height != 0 && fixedBlock.LineHeight != 0);

            //Rect textRunRect = textRun.BoundingRect;

            if (compareLine != null) //Most probably different lines
            {
                double ratio = fixedBlock.LineHeight / textRunRect.Height;
                if (ratio < 1.0)
                {
                    ratio = 1.0 / ratio;
                }
                //Allow 10% height difference
                if ((ratio > 1.1) &&
                    !(FixedTextBuilder.IsSameLine(compareLine.BoundingRect.Top - textRunRect.Top, textRunRect.Height, compareLine.BoundingRect.Height)))
                {
                    return(false);
                }
            }

            double width = textRun.DefaultCharWidth;

            if (width < 1.0)
            {
                width = 1.0;
            }

            double dHorInflate = 0;
            double heightRatio = fixedBlock.LineHeight / textRunRect.Height;

            if (heightRatio < 1.0)
            {
                heightRatio = 1.0 / heightRatio;
            }

            //If consecutive in markup and seem to be on the same line, almost discard horizontal distance
            if (fixedBlock == _currentFixedBlock &&
                compareLine == null &&
                heightRatio < 1.5
                )
            {
                dHorInflate = 200;
            }
            else
            {
                dHorInflate = width * 1.5;
            }

            if (!_IsSpatiallyCombinable(fixedBlockRect, textRunRect, dHorInflate, textRunRect.Height * 0.7))
            {
                return(false);
            }

            //If these two have originated from the same Glyphs element, this means we intentionally separated them (separated by vertical lines).
            //Don't combine in this case.
            FixedSOMElement element = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMElement;

            if (element != null && element.FixedNode.CompareTo(textRun.FixedNode) == 0)
            {
                return(false);
            }

            //Are these seperated by a line? Check only if they are not considered overlapping
            if (fixedBlockBelow || textRunBelow)
            {
                double bottom = 0.0;
                double top    = 0.0;
                double margin = textRunRect.Height * 0.2;

                if (textRunBelow)
                {
                    top    = fixedBlockRect.Bottom - margin;
                    bottom = textRunRect.Top + margin;
                }
                else
                {
                    top    = textRunRect.Bottom - margin;
                    bottom = fixedBlockRect.Top + margin;
                }
                double left  = (fixedBlockRect.Left > textRunRect.Left) ? fixedBlockRect.Left : textRunRect.Left;
                double right = (fixedBlockRect.Right < textRunRect.Right) ? fixedBlockRect.Right: textRunRect.Right;
                return(!_lines.IsHorizontallySeparated(left, top, right, bottom));
            }
            else
            {
                //These two overlap vertically. Let's check whether there is a vertical separator in between
                double left  = (fixedBlockRect.Right < textRunRect.Right) ? fixedBlockRect.Right: textRunRect.Right;
                double right = (fixedBlockRect.Left > textRunRect.Left) ? fixedBlockRect.Left: textRunRect.Left;
                if (left > right)
                {
                    double temp = left;
                    left  = right;
                    right = temp;
                }
                return(!_lines.IsVerticallySeparated(left, textRunRect.Top, right, textRunRect.Bottom));
            }
        }
示例#15
0
        // Token: 0x06002DFC RID: 11772 RVA: 0x000CEDF0 File Offset: 0x000CCFF0
        private bool _IsCombinable(FixedSOMFixedBlock fixedBlock, FixedSOMTextRun textRun)
        {
            if (fixedBlock.SemanticBoxes.Count == 0)
            {
                return(false);
            }
            if (fixedBlock.IsFloatingImage)
            {
                return(false);
            }
            Rect            boundingRect     = textRun.BoundingRect;
            Rect            boundingRect2    = fixedBlock.BoundingRect;
            FixedSOMTextRun fixedSOMTextRun  = null;
            FixedSOMTextRun fixedSOMTextRun2 = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMTextRun;

            if (fixedSOMTextRun2 != null && boundingRect.Bottom <= fixedSOMTextRun2.BoundingRect.Top)
            {
                return(false);
            }
            bool   flag  = false;
            bool   flag2 = false;
            double num   = boundingRect.Height * 0.2;

            if (boundingRect.Bottom - num < boundingRect2.Top)
            {
                flag            = true;
                fixedSOMTextRun = (fixedBlock.SemanticBoxes[0] as FixedSOMTextRun);
            }
            else if (boundingRect.Top + num > boundingRect2.Bottom)
            {
                flag2           = true;
                fixedSOMTextRun = (fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMTextRun);
            }
            if ((fixedBlock.IsWhiteSpace || textRun.IsWhiteSpace) && (fixedBlock != this._currentFixedBlock || fixedSOMTextRun != null || !this._IsSpatiallyCombinable(boundingRect2, boundingRect, textRun.DefaultCharWidth * 3.0, 0.0)))
            {
                return(false);
            }
            if (fixedBlock.Matrix.M11 != textRun.Matrix.M11 || fixedBlock.Matrix.M12 != textRun.Matrix.M12 || fixedBlock.Matrix.M21 != textRun.Matrix.M21 || fixedBlock.Matrix.M22 != textRun.Matrix.M22)
            {
                return(false);
            }
            if (fixedSOMTextRun != null)
            {
                double num2 = fixedBlock.LineHeight / boundingRect.Height;
                if (num2 < 1.0)
                {
                    num2 = 1.0 / num2;
                }
                if (num2 > 1.1 && !FixedTextBuilder.IsSameLine(fixedSOMTextRun.BoundingRect.Top - boundingRect.Top, boundingRect.Height, fixedSOMTextRun.BoundingRect.Height))
                {
                    return(false);
                }
            }
            double num3 = textRun.DefaultCharWidth;

            if (num3 < 1.0)
            {
                num3 = 1.0;
            }
            double num4 = fixedBlock.LineHeight / boundingRect.Height;

            if (num4 < 1.0)
            {
                num4 = 1.0 / num4;
            }
            double inflateH;

            if (fixedBlock == this._currentFixedBlock && fixedSOMTextRun == null && num4 < 1.5)
            {
                inflateH = 200.0;
            }
            else
            {
                inflateH = num3 * 1.5;
            }
            if (!this._IsSpatiallyCombinable(boundingRect2, boundingRect, inflateH, boundingRect.Height * 0.7))
            {
                return(false);
            }
            FixedSOMElement fixedSOMElement = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMElement;

            if (fixedSOMElement != null && fixedSOMElement.FixedNode.CompareTo(textRun.FixedNode) == 0)
            {
                return(false);
            }
            if (flag || flag2)
            {
                double num5 = boundingRect.Height * 0.2;
                double top;
                double bottom;
                if (flag2)
                {
                    top    = boundingRect2.Bottom - num5;
                    bottom = boundingRect.Top + num5;
                }
                else
                {
                    top    = boundingRect.Bottom - num5;
                    bottom = boundingRect2.Top + num5;
                }
                double left  = (boundingRect2.Left > boundingRect.Left) ? boundingRect2.Left : boundingRect.Left;
                double right = (boundingRect2.Right < boundingRect.Right) ? boundingRect2.Right : boundingRect.Right;
                return(!this._lines.IsHorizontallySeparated(left, top, right, bottom));
            }
            double num6 = (boundingRect2.Right < boundingRect.Right) ? boundingRect2.Right : boundingRect.Right;
            double num7 = (boundingRect2.Left > boundingRect.Left) ? boundingRect2.Left : boundingRect.Left;

            if (FrameworkAppContextSwitches.OptOutOfFixedDocumentModelConstructionFix)
            {
                if (num6 > num7)
                {
                    double num8 = num6;
                    num6 = num7;
                    num7 = num8;
                }
                return(!this._lines.IsVerticallySeparated(num6, boundingRect.Top, num7, boundingRect.Bottom));
            }
            return(num6 >= num7 || !this._lines.IsVerticallySeparated(num6, boundingRect.Top, num7, boundingRect.Bottom));
        }
        private bool _IsCombinable(FixedSOMFixedBlock fixedBlock, FixedSOMTextRun textRun)
        { 
            Debug.Assert (fixedBlock.SemanticBoxes.Count > 0);
            if (fixedBlock.SemanticBoxes.Count == 0)
            {
                return false; 
            }
 
            //Currently we do not support inline images 
            if (fixedBlock.IsFloatingImage)
            { 
                return false;
            }

            Rect textRunRect = textRun.BoundingRect; 
            Rect fixedBlockRect = fixedBlock.BoundingRect;
 
            FixedSOMTextRun compareLine = null; 
            FixedSOMTextRun lastLine = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMTextRun;
 
            if (lastLine != null && textRunRect.Bottom <= lastLine.BoundingRect.Top)
            {
                //This run is above the last run of the fixed block. Can't be the same paragraph
                return false; 
            }
 
            bool fixedBlockBelow = false; 
            bool textRunBelow = false;
            //Allow 20% overlap 
            double verticalOverlap = textRunRect.Height * 0.2;
            if (textRunRect.Bottom - verticalOverlap < fixedBlockRect.Top)
            {
                fixedBlockBelow = true; 
                compareLine = fixedBlock.SemanticBoxes[0] as FixedSOMTextRun;
            } 
            else if (textRunRect.Top + verticalOverlap > fixedBlockRect.Bottom) 
            {
                textRunBelow = true; 
                compareLine = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count-1] as FixedSOMTextRun;
            }

            if ( (fixedBlock.IsWhiteSpace || textRun.IsWhiteSpace) && 
                 (fixedBlock != _currentFixedBlock || compareLine != null || !_IsSpatiallyCombinable(fixedBlockRect, textRunRect, textRun.DefaultCharWidth * 3, 0))
                 ) 
            { 
                //When combining with white spaces, they need to be consecutive in markup and need to be on the same line.
                return false; 
            }
            if (fixedBlock.Matrix.M11 != textRun.Matrix.M11 ||
                fixedBlock.Matrix.M12 != textRun.Matrix.M12 ||
                fixedBlock.Matrix.M21 != textRun.Matrix.M21 || 
                fixedBlock.Matrix.M22 != textRun.Matrix.M22)
            { 
                //We don't allow combining TextRuns with different scale/rotation properties 
                return false;
            } 

            Debug.Assert(textRunRect.Height != 0 && fixedBlock.LineHeight != 0);

            //Rect textRunRect = textRun.BoundingRect; 

            if (compareLine != null) //Most probably different lines 
            { 
                double ratio = fixedBlock.LineHeight / textRunRect.Height;
                if (ratio<1.0) 
                {
                    ratio = 1.0 / ratio;
                }
                //Allow 10% height difference 
                if ((ratio > 1.1) &&
                    !(FixedTextBuilder.IsSameLine(compareLine.BoundingRect.Top - textRunRect.Top, textRunRect.Height, compareLine.BoundingRect.Height))) 
                { 
                    return false;
                } 
            }

            double width = textRun.DefaultCharWidth;
            if (width < 1.0) 
            {
                width = 1.0; 
            } 

            double dHorInflate = 0; 
            double heightRatio = fixedBlock.LineHeight / textRunRect.Height;
            if (heightRatio < 1.0)
            {
                heightRatio = 1.0 / heightRatio; 
            }
 
            //If consecutive in markup and seem to be on the same line, almost discard horizontal distance 
            if (fixedBlock == _currentFixedBlock &&
                compareLine == null && 
                heightRatio < 1.5
                )
            {
                dHorInflate = 200; 
            }
            else 
            { 
                dHorInflate = width*1.5;
            } 

            if (!_IsSpatiallyCombinable(fixedBlockRect, textRunRect, dHorInflate, textRunRect.Height*0.7))
            {
                return false; 
            }
 
            //If these two have originated from the same Glyphs element, this means we intentionally separated them (separated by vertical lines). 
            //Don't combine in this case.
            FixedSOMElement element = fixedBlock.SemanticBoxes[fixedBlock.SemanticBoxes.Count - 1] as FixedSOMElement; 

            if (element!=null && element.FixedNode.CompareTo(textRun.FixedNode) == 0)
            {
                return false; 
            }
 
            //Are these seperated by a line? Check only if they are not considered overlapping 
            if (fixedBlockBelow || textRunBelow)
            { 
                double bottom = 0.0;
                double top = 0.0;
                double margin = textRunRect.Height * 0.2;
 
                if (textRunBelow)
                { 
                    top = fixedBlockRect.Bottom - margin; 
                    bottom = textRunRect.Top + margin;
                } 
                else
                {
                    top = textRunRect.Bottom - margin ;
                    bottom = fixedBlockRect.Top + margin; 
                }
                double left = (fixedBlockRect.Left > textRunRect.Left) ? fixedBlockRect.Left : textRunRect.Left; 
                double right = (fixedBlockRect.Right < textRunRect.Right) ? fixedBlockRect.Right: textRunRect.Right; 
                return (!_lines.IsHorizontallySeparated(left, top, right, bottom));
            } 
            else
            {
                //These two overlap vertically. Let's check whether there is a vertical separator in between
                double left = (fixedBlockRect.Right < textRunRect.Right) ? fixedBlockRect.Right: textRunRect.Right; 
                double right =(fixedBlockRect.Left > textRunRect.Left) ? fixedBlockRect.Left: textRunRect.Left;
                if (left > right) 
                { 
                    double temp = left;
                    left = right; 
                    right = temp;
                }
                return (!_lines.IsVerticallySeparated(left, textRunRect.Top, right, textRunRect.Bottom));
            } 
        }
        //Creates a FixedSOMTextRun, and updates containing structures 
        private void _CreateTextRun(Rect boundingRect, GeneralTransform trans, Glyphs glyphs, FixedNode node, int startIndex, int endIndex)
        { 
            if (startIndex < endIndex) 
            {
                FixedSOMTextRun textRun = FixedSOMTextRun.Create(boundingRect, 
                                                                 trans,
                                                                 glyphs,
                                                                 node,
                                                                 startIndex, 
                                                                 endIndex,
                                                                 true); 
 

                FixedSOMFixedBlock fixedBlock = _GetContainingFixedBlock(textRun); 

                if (fixedBlock == null)
                {
                    fixedBlock= new FixedSOMFixedBlock(_fixedSOMPage); 
                    fixedBlock.AddTextRun(textRun);
                    _fixedSOMPage.AddFixedBlock(fixedBlock); 
                 } 
                else
                { 
                    fixedBlock.AddTextRun(textRun);
                }
                _currentFixedBlock = fixedBlock;
            } 
        }
        //--------------------------------------------------------------------
        //
        // Private Methods
        // 
        //---------------------------------------------------------------------
 
 
        #region Private methods
 
        private void _ProcessImage(DependencyObject obj, FixedNode fixedNode)
        {
            Debug.Assert(obj is Image || obj is Path);
            FixedSOMImage somImage = null; 

            while (true) 
            { 
                Image image = obj as Image;
                if (image != null) 
                {
                    somImage = FixedSOMImage.Create(_fixedPage, image, fixedNode);
                    break;
                } 
                Path path = obj as Path;
                if (path != null) 
                { 
                    somImage = FixedSOMImage.Create(_fixedPage, path, fixedNode);
                    break; 
                }
            }
            //Create a wrapper FixedBlock:
 
            FixedSOMFixedBlock fixedBlock = new FixedSOMFixedBlock(_fixedSOMPage);
            fixedBlock.AddImage(somImage); 
            _fixedSOMPage.AddFixedBlock(fixedBlock); 
            _currentFixedBlock = fixedBlock;
 
        }
示例#19
0
 public void AddFixedBlock(FixedSOMFixedBlock fixedBlock) 
 {
     base.Add(fixedBlock); 
 } 
示例#20
0
 // Token: 0x06002DDE RID: 11742 RVA: 0x000CE42C File Offset: 0x000CC62C
 public void AddFixedBlock(FixedSOMFixedBlock fixedBlock)
 {
     base.Add(fixedBlock);
 }
示例#21
0
 public void CombineWith(FixedSOMFixedBlock block)
 { 
     foreach (FixedSOMSemanticBox box in block.SemanticBoxes)
     { 
         FixedSOMTextRun run = box as FixedSOMTextRun; 
         if (run != null)
         { 
             AddTextRun(run);
         }
         else
         { 
             base.Add(box);
         } 
     } 
 }