// ------------------------------------------------------------------
        // Dump Cell specific data.
        // ------------------------------------------------------------------
        private static void DumpTableCell(XmlTextWriter writer, ParagraphResult paragraph, Visual cellVisual, Visual tableVisual)
        {
            Type paragraphResultType = paragraph.GetType();
            System.Reflection.FieldInfo fieldOfParaClient = paragraphResultType.GetField("_paraClient", 
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

            if (fieldOfParaClient == null)
            {
                return;
            }

            CellParaClient cellParaClient = (CellParaClient) fieldOfParaClient.GetValue(paragraph);
            CellParagraph cellParagraph = cellParaClient.CellParagraph;
            TableCell cell = cellParagraph.Cell;

            writer.WriteStartElement("Cell");

            Type typeOfCell = cell.GetType();

            System.Reflection.PropertyInfo propOfColumnIndex = typeOfCell.GetProperty("ColumnIndex", 
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.DeclaredOnly);
            if (propOfColumnIndex != null)
            {
                int columnIndex = (int)propOfColumnIndex.GetValue(cell, null);
                writer.WriteAttributeString("ColumnIndex", columnIndex.ToString(CultureInfo.InvariantCulture));
            }

            System.Reflection.PropertyInfo propOfRowIndex = typeOfCell.GetProperty("RowIndex", 
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.DeclaredOnly);
            if (propOfRowIndex != null)
            {
                int rowIndex = (int)propOfRowIndex.GetValue(cell, null);
                writer.WriteAttributeString("RowIndex", rowIndex.ToString(CultureInfo.InvariantCulture));
            }

            writer.WriteAttributeString("ColumnSpan", cell.ColumnSpan.ToString(CultureInfo.InvariantCulture));
            writer.WriteAttributeString("RowSpan", cell.RowSpan.ToString(CultureInfo.InvariantCulture));

            Rect rect = cellParaClient.Rect.FromTextDpi();
            DumpRect(writer, "LayoutBox", rect);

            bool hasTextContent;
            DumpParagraphResults(writer, "Paragraphs", cellParaClient.GetColumnResults(out hasTextContent)[0].Paragraphs, cellParaClient.Visual);

            writer.WriteEndElement();
        }
Example #2
0
        /// <summary> 
        /// Retrieves a position matching a point from a given paragraph 
        /// </summary>
        /// <param name="paragraph"> 
        /// Para containing position
        /// </param>
        /// <param name="point">
        /// Point in pixel coordinates to test. 
        /// </param>
        /// <param name="snapToText"> 
        /// If true, this method must always return a positioned text position 
        /// (the closest position as calculated by the control's heuristics).
        /// If false, this method should return null position, if the test 
        /// point does not fall within any character bounding box.
        /// </param>
        private ITextPointer GetTextPositionFromPoint(ParagraphResult paragraph, Point point, bool snapToText)
        { 
            ITextPointer position = null;
            Rect paragraphBox = paragraph.LayoutBox; 
            // Position is retrieved differently for different paragraph types: 
            // a) ContainerParagraph, FigureParagraph, FloaterParagraph - hittest colleciton of nested paragraphs.
            // b) TextParagraph - hittest line collection. 
            // c) TableParagraph - hittest in table
            // d) Other paragraphs - return position before/after paragraph element.
            if (paragraph is ContainerParagraphResult)
            { 
                // a) ContainerParagraph - hittest colleciton of nested paragraphs.
                ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((ContainerParagraphResult)paragraph).Paragraphs; 
                // Paragraphs collection may be null in case of empty List element, 
                Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null.");
                if (nestedParagraphs.Count > 0) 
                {
                    position = GetTextPositionFromPoint(nestedParagraphs, _emptyParagraphCollection, point, snapToText, /* snap to text for floating elements*/ false);
                }
                else 
                {
                    // Return position before/after paragraph element. 
                    if (point.X <= paragraphBox.Width) 
                    {
                        position = paragraph.StartPosition.CreatePointer(LogicalDirection.Forward); 
                    }
                    else
                    {
                        position = paragraph.EndPosition.CreatePointer(LogicalDirection.Backward); 
                    }
                } 
            } 
            else if (paragraph is TextParagraphResult)
            { 
                // b) TextParagraph - hittest line collection.
                ReadOnlyCollection<LineResult> lines = ((TextParagraphResult)paragraph).Lines;
                Invariant.Assert(lines != null, "Lines collection is null");
                if (!((TextParagraphResult)paragraph).HasTextContent) 
                {
                    position = null; 
                } 
                else
                { 
                    position = TextParagraphView.GetTextPositionFromPoint(lines, point, snapToText);
                }
            }
            else if (paragraph is TableParagraphResult) 
            {
                ReadOnlyCollection<ParagraphResult> rowParagraphs = ((TableParagraphResult)paragraph).Paragraphs; 
                Invariant.Assert(rowParagraphs != null, "Paragraph collection is null."); 

                int index = GetParagraphFromPoint(rowParagraphs, point, snapToText); 
                if (index != -1)
                {
                    ParagraphResult rowResult = rowParagraphs[index];
 
                    if (point.X > rowResult.LayoutBox.Right)
                    { 
                        position = ((TextElement)rowResult.Element).ElementEnd; 
                    }
                    else 
                    {
                        ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((TableParagraphResult)paragraph).GetParagraphsFromPoint(point, snapToText);

                        position = GetTextPositionFromPoint(nestedParagraphs, _emptyParagraphCollection, point, snapToText, false); 
                    }
                } 
                else 
                {
                    // Table is empty. 
                    position = null;
                    // When snap to text is enabled a valid text position is required.
                    if (snapToText)
                    { 
                        position = ((TextElement)paragraph.Element).ContentStart;
                    } 
                } 
            }
            else if (paragraph is SubpageParagraphResult) 
            {
                // Subpage implies new coordinate system.
                SubpageParagraphResult subpageParagraphResult = (SubpageParagraphResult)paragraph;
                point.X -= subpageParagraphResult.ContentOffset.X; 
                point.Y -= subpageParagraphResult.ContentOffset.Y;
 
                // WOOT! COLUMNS! 
                position = GetTextPositionFromPoint(subpageParagraphResult.Columns, subpageParagraphResult.FloatingElements, point, snapToText);
            } 
            else if (paragraph is FigureParagraphResult || paragraph is FloaterParagraphResult)
            {
                ReadOnlyCollection<ColumnResult> columns;
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements; 
                if (paragraph is FloaterParagraphResult)
                { 
                    FloaterParagraphResult floaterParagraphResult = (FloaterParagraphResult)paragraph; 
                    columns = floaterParagraphResult.Columns;
                    nestedFloatingElements = floaterParagraphResult.FloatingElements; 
                    TransformToSubpage(ref point, floaterParagraphResult.ContentOffset);
                }
                else
                { 
                    FigureParagraphResult figureParagraphResult = (FigureParagraphResult)paragraph;
                    columns = figureParagraphResult.Columns; 
                    nestedFloatingElements = figureParagraphResult.FloatingElements; 
                    TransformToSubpage(ref point, figureParagraphResult.ContentOffset);
                } 

                // Paragraphs collection may be null in case of empty List element,
                Invariant.Assert(columns != null, "Columns collection is null.");
                Invariant.Assert(nestedFloatingElements != null, "Floating elements collection is null."); 
                if (columns.Count > 0 || nestedFloatingElements.Count > 0)
                { 
                    position = GetTextPositionFromPoint(columns, nestedFloatingElements, point, snapToText); 
                }
                else 
                {
                    position = null;
                }
            } 
            else if (paragraph is UIElementParagraphResult)
            { 
                BlockUIContainer blockUIContainer = paragraph.Element as BlockUIContainer; 
                if (blockUIContainer != null)
                { 
                    position = null;
                    if (paragraphBox.Contains(point) || snapToText)
                    {
                        // Point is with  BUIC's layout box. Return paragraph's ContentStart/End as appropriate 
                        if (DoubleUtil.LessThanOrClose(point.X, paragraphBox.X + paragraphBox.Width / 2))
                        { 
                            position = blockUIContainer.ContentStart.CreatePointer(LogicalDirection.Forward); 
                        }
                        else 
                        {
                            position = blockUIContainer.ContentEnd.CreatePointer(LogicalDirection.Backward);
                        }
                    } 
                }
            } 
            else 
            {
                // d) Other paragraphs - return position before/after paragraph element. 
                if (point.X <= paragraphBox.Width)
                {
                    position = paragraph.StartPosition.CreatePointer(LogicalDirection.Forward);
                } 
                else
                { 
                    position = paragraph.EndPosition.CreatePointer(LogicalDirection.Backward); 
                }
            } 
            return position;
        }
        // ------------------------------------------------------------------
        // Dump paragraph offset.
        // ------------------------------------------------------------------
        private static Visual DumpParagraphOffset(XmlTextWriter writer, ParagraphResult paragraph, Visual visualParent)
        {
            Type paragraphResultType = paragraph.GetType();
            System.Reflection.FieldInfo field = paragraphResultType.GetField("_paraClient", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
            object paraClient = field.GetValue(paragraph);
            Type paraClientType = paraClient.GetType();
            System.Reflection.PropertyInfo prop = paraClientType.GetProperty("Visual", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
            Visual visual = (Visual)prop.GetValue(paraClient, null);

            // Dump transform relative to its parent
            if(visualParent.IsAncestorOf(visual))
            {
                GeneralTransform g = visual.TransformToAncestor(visualParent);
                Point point = new Point(0.0f, 0.0f);
                g.TryTransform(point, out point);

                if (point.X != 0 || point.Y != 0)
                {
                    DumpPoint(writer, "Origin", point);
                }
            }

            return visual;
        }
Example #4
0
        /// <summary>
        /// Returns the layout box edge associated with this block if a text position is located at the end of the block element with appropriate
        /// Logical direction. 
        /// </summary>
        /// <param name="paragraphResult">Result to check edges.</param> 
        /// <param name="textPointer">Text Pointer to compare against</param> 
        /// <returns>
        /// Returns rect for edge, or Rect.Empty if textposition not on edge 
        /// </returns>
        private Rect GetRectangleFromEdge(ParagraphResult paragraphResult, ITextPointer textPointer)
        {
            TextElement textElement = paragraphResult.Element as TextElement; 

            if (textElement != null) 
            { 
                if (textPointer.LogicalDirection == LogicalDirection.Forward && textPointer.CompareTo(textElement.ElementStart) == 0)
                { 
                    return new Rect(paragraphResult.LayoutBox.Left, paragraphResult.LayoutBox.Top, 0.0, paragraphResult.LayoutBox.Height);
                }

                if (textPointer.LogicalDirection == LogicalDirection.Backward && textPointer.CompareTo(textElement.ElementEnd) == 0) 
                {
                    return new Rect(paragraphResult.LayoutBox.Right, paragraphResult.LayoutBox.Top, 0.0, paragraphResult.LayoutBox.Height); 
                } 
            }
 
            return Rect.Empty;
        }
Example #5
0
        /// <summary> 
        /// Returns the layout box edge associated with this block if a text position is located at the end of the block content
        /// This is for elements like BlockUIContainer where the content start/end (regardless of direction)has the same rectangle as 
        /// the element start/end, we treat BUC as a line with 2 positions at start and end 
        /// </summary>
        /// <param name="paragraphResult">Result to check edges.</param> 
        /// <param name="textPointer">Text Pointer to compare against</param>
        /// <returns>
        /// Returns rect for edge, or Rect.Empty if textposition not on edge
        /// </returns> 
        private Rect GetRectangleFromContentEdge(ParagraphResult paragraphResult, ITextPointer textPointer)
        { 
            TextElement textElement = paragraphResult.Element as TextElement; 
            if (textElement != null)
            { 
                // We enable this only for BlockUIContainer, it would be wrong to return layout box Rect from other elements' Content start/end
                Invariant.Assert(textElement is BlockUIContainer, "Expecting BlockUIContainer");

                // No need to consider position's LogicalDirection here, ContentStart's backward context for BUIC should be ElementStart, for which 
                // we also want the same rectangle; the same applies to ContentEnd
                if (textPointer.CompareTo(textElement.ContentStart) == 0) 
                { 
                    return new Rect(paragraphResult.LayoutBox.Left, paragraphResult.LayoutBox.Top, 0.0, paragraphResult.LayoutBox.Height);
                } 

                if (textPointer.CompareTo(textElement.ContentEnd) == 0)
                {
                    return new Rect(paragraphResult.LayoutBox.Right, paragraphResult.LayoutBox.Top, 0.0, paragraphResult.LayoutBox.Height); 
                }
            } 
 
            return Rect.Empty;
        } 
Example #6
0
        /// <summary>
        /// Returns a TextSegment that spans the line on which position is located. 
        /// </summary> 
        /// <param name="paragraph">Paragraph to search</param>
        /// <param name="position">Any oriented text position on the line.</param> 
        private TextSegment GetLineRangeFromPosition(ParagraphResult paragraph, ITextPointer position)
        {
            TextSegment lineRange = TextSegment.Null;
 
            // Each paragraph type is handled differently:
            // a) ContainerParagraph - process nested paragraphs. 
            // b) TextParagraph - find line index of a line containing input text position 
            //    and then return its range.
            // c) TableParagraph - process nested paragraphs. 
            if (paragraph is ContainerParagraphResult)
            {
                // a) ContainerParagraph - process nested paragraphs.
                ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((ContainerParagraphResult)paragraph).Paragraphs; 
                // Paragraphs collection may be null in case of empty List.
                Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null."); 
                if (nestedParagraphs.Count > 0) 
                {
                    lineRange = GetLineRangeFromPosition(nestedParagraphs, _emptyParagraphCollection, position); 
                }
            }
            else if (paragraph is TextParagraphResult)
            { 
                // b) TextParagraph - find line index of a line containing input text position
                //    and then return its range. 
                ReadOnlyCollection<LineResult> lines = ((TextParagraphResult)paragraph).Lines; 
                Invariant.Assert(lines != null, "Lines collection is null");
                if (!((TextParagraphResult)paragraph).HasTextContent) 
                {
                    // Paragraph has no lines.
                    //
 

                    lineRange = new TextSegment(((TextParagraphResult)paragraph).EndPosition, ((TextParagraphResult)paragraph).EndPosition, true); 
                } 
                else
                { 
                    // Get index of the line that contains position.
                    int lineIndex = TextParagraphView.GetLineFromPosition(lines, position);
                    Invariant.Assert(lineIndex >= 0 && lineIndex < lines.Count, "Line not found.");
                    lineRange = new TextSegment(lines[lineIndex].StartPosition, lines[lineIndex].GetContentEndPosition(), true); 
                }
            } 
            else if (paragraph is TableParagraphResult) 
            {
                // c) TableParagraph - process nested paragraphs. 
                ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((TableParagraphResult)paragraph).GetParagraphsFromPosition(position);
                // Paragraphs collection may be null in case of empty List.
                Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null.");
                if (nestedParagraphs.Count > 0) 
                {
                    lineRange = GetLineRangeFromPosition(nestedParagraphs, _emptyParagraphCollection, position); 
                } 
            }
            else if (paragraph is SubpageParagraphResult) 
            {
                SubpageParagraphResult subpageParagraphResult = (SubpageParagraphResult)paragraph;
                ReadOnlyCollection<ColumnResult> columns = subpageParagraphResult.Columns;
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements = subpageParagraphResult.FloatingElements; 
                Invariant.Assert(columns != null, "Column collection is null.");
                Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null."); 
                if (columns.Count > 0 || nestedFloatingElements.Count > 0) 
                {
                    lineRange = GetLineRangeFromPosition(columns, nestedFloatingElements, position); 
                }
            }
            else if (paragraph is FigureParagraphResult)
            { 
                FigureParagraphResult figureParagraphResult = (FigureParagraphResult)paragraph;
                ReadOnlyCollection<ColumnResult> columns = figureParagraphResult.Columns; 
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements = figureParagraphResult.FloatingElements; 
                Invariant.Assert(columns != null, "Column collection is null.");
                Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null."); 
                if (columns.Count > 0 || nestedFloatingElements.Count > 0)
                {
                    lineRange = GetLineRangeFromPosition(columns, nestedFloatingElements, position);
                } 
            }
            else if (paragraph is FloaterParagraphResult) 
            { 
                FloaterParagraphResult floaterParagraphResult = (FloaterParagraphResult)paragraph;
                ReadOnlyCollection<ColumnResult> columns = floaterParagraphResult.Columns; 
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements = floaterParagraphResult.FloatingElements;
                Invariant.Assert(columns != null, "Column collection is null.");
                Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
                if (columns.Count > 0 || nestedFloatingElements.Count > 0) 
                {
                    lineRange = GetLineRangeFromPosition(columns, nestedFloatingElements, position); 
                } 
            }
            else if (paragraph is UIElementParagraphResult) 
            {
                // UIElement paragraph result - return content range between BlockUIContainer.ContentStart and ContentEnd
                BlockUIContainer blockUIContainer = paragraph.Element as BlockUIContainer;
                if (blockUIContainer != null) 
                {
                    lineRange = new TextSegment(blockUIContainer.ContentStart.CreatePointer(LogicalDirection.Forward), blockUIContainer.ContentEnd.CreatePointer(LogicalDirection.Backward)); 
                } 
            }
            return lineRange; 
        }
Example #7
0
 /// <summary>
 /// Finds and returns the backspace position of a caret unit
 /// </summary> 
 /// <param name="paragraph">Paragraph to search.</param>
 /// <param name="position">Position of an object/character.</param> 
 private ITextPointer GetBackspaceCaretUnitPosition(ParagraphResult paragraph, ITextPointer position) 
 {
     ITextPointer backspaceCaretPosition = position; 
     if (paragraph is ContainerParagraphResult)
     {
         // a) ContainerParagraph - go to collection of nested paragraphs.
         ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((ContainerParagraphResult)paragraph).Paragraphs; 
         // Paragraphs collection may be null in case of empty List.
         Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null."); 
         if (nestedParagraphs.Count > 0) 
         {
             backspaceCaretPosition = GetBackspaceCaretUnitPosition(nestedParagraphs, _emptyParagraphCollection, position); 
         }
     }
     else if (paragraph is TextParagraphResult)
     { 
         // b) TextParagraph - search inside it
         backspaceCaretPosition = ((TextParagraphResult)paragraph).GetBackspaceCaretUnitPosition(position); 
     } 
     else if (paragraph is TableParagraphResult)
     { 
         ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((TableParagraphResult)paragraph).GetParagraphsFromPosition(position);
         Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null.");
         if (nestedParagraphs.Count > 0)
         { 
             backspaceCaretPosition = GetBackspaceCaretUnitPosition(nestedParagraphs, _emptyParagraphCollection, position);
         } 
     } 
     else if (paragraph is SubpageParagraphResult)
     { 
         SubpageParagraphResult subpageParagraphResult = (SubpageParagraphResult)paragraph;
         ReadOnlyCollection<ColumnResult> columns = subpageParagraphResult.Columns;
         ReadOnlyCollection<ParagraphResult> nestedFloatingElements = subpageParagraphResult.FloatingElements;
         Invariant.Assert(columns != null, "Column collection is null."); 
         Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
         if (columns.Count > 0 || nestedFloatingElements.Count > 0) 
         { 
             backspaceCaretPosition = GetBackspaceCaretUnitPosition(columns, nestedFloatingElements, position);
         } 
     }
     else if (paragraph is FigureParagraphResult)
     {
         FigureParagraphResult figureParagraphResult = (FigureParagraphResult)paragraph; 
         ReadOnlyCollection<ColumnResult> columns = figureParagraphResult.Columns;
         ReadOnlyCollection<ParagraphResult> nestedFloatingElements = figureParagraphResult.FloatingElements; 
         Invariant.Assert(columns != null, "Column collection is null."); 
         Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
         if (columns.Count > 0 || nestedFloatingElements.Count > 0) 
         {
             backspaceCaretPosition = GetBackspaceCaretUnitPosition(columns, nestedFloatingElements, position);
         }
     } 
     else if (paragraph is FloaterParagraphResult)
     { 
         FloaterParagraphResult floaterParagraphResult = (FloaterParagraphResult)paragraph; 
         ReadOnlyCollection<ColumnResult> columns = floaterParagraphResult.Columns;
         ReadOnlyCollection<ParagraphResult> nestedFloatingElements = floaterParagraphResult.FloatingElements; 
         Invariant.Assert(columns != null, "Column collection is null.");
         Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
         if (columns.Count > 0 || nestedFloatingElements.Count > 0)
         { 
             backspaceCaretPosition = GetBackspaceCaretUnitPosition(columns, nestedFloatingElements, position);
         } 
     } 
     return backspaceCaretPosition;
 } 
Example #8
0
 // Retreives a layout box for the paragraphResult
 private static Rect GetLayoutBox(ParagraphResult paragraph)
 { 
     if (!(paragraph is SubpageParagraphResult) && !(paragraph is RowParagraphResult))
     { 
         return paragraph.LayoutBox; 
     }
     return Rect.Empty; 
 }
Example #9
0
        /// <summary> 
        /// Retrieves the height and offset, in pixels, of the edge of 
        /// the object/character represented by position.
        /// </summary> 
        /// <param name="paragraph">Paragraph to search</param>
        /// <param name="position">Position of an object/character.</param>
        private Rect GetRectangleFromTextPosition(ParagraphResult paragraph, ITextPointer position)
        { 
            Rect rect = Rect.Empty;
 
            // Rectangle is retrieved differently for different paragraph types: 
            // a) ContainerParagraph - get rectangle from nested paragraphs.
            // b) TextParagraph - get rectangle from text paragraph's content. 
            // c) TableParagraph - get rectangle from nested paras
            if (paragraph is ContainerParagraphResult)
            {
                rect = GetRectangleFromEdge(paragraph, position); 

                if (rect == Rect.Empty) 
                { 
                    // a) ContainerParagraph - check collection of nested paragraphs.
                    ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((ContainerParagraphResult)paragraph).Paragraphs; 
                    Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null.");

                    if (nestedParagraphs.Count > 0)
                    { 
                        rect = GetRectangleFromTextPosition(nestedParagraphs, _emptyParagraphCollection, position);
                    } 
                } 
            }
            else if (paragraph is TextParagraphResult) 
            {
                rect = ((TextParagraphResult)paragraph).GetRectangleFromTextPosition(position);
            }
            else if (paragraph is TableParagraphResult) 
            {
                // c) TableParagraph - get rectangle from nested paras 
 
                rect = GetRectangleFromEdge(paragraph, position);
 
                if (rect == Rect.Empty)
                {
                    ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((TableParagraphResult)paragraph).GetParagraphsFromPosition(position);
                    Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null."); 
                    if (nestedParagraphs.Count > 0)
                    { 
                        rect = GetRectangleFromTextPosition(nestedParagraphs, _emptyParagraphCollection, position); 
                    }
                    else if (position is TextPointer && ((TextPointer)position).IsAtRowEnd) 
                    {
                        rect = ((TableParagraphResult)paragraph).GetRectangleFromRowEndPosition(position);
                    }
                } 
            }
            else if (paragraph is SubpageParagraphResult) 
            { 
                // Subpage implies new coordinate system.
                SubpageParagraphResult subpageParagraphResult = (SubpageParagraphResult)paragraph; 
                rect = GetRectangleFromTextPosition(subpageParagraphResult.Columns, subpageParagraphResult.FloatingElements, position);
                if (rect != Rect.Empty)
                {
                    rect.X += subpageParagraphResult.ContentOffset.X; 
                    rect.Y += subpageParagraphResult.ContentOffset.Y;
                } 
            } 
            else if (paragraph is FloaterParagraphResult)
            { 
                FloaterParagraphResult floaterParagraphResult = (FloaterParagraphResult)paragraph;
                ReadOnlyCollection<ColumnResult> columns = floaterParagraphResult.Columns;
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements = floaterParagraphResult.FloatingElements;
                Invariant.Assert(columns != null, "Columns collection is null."); 
                Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
                if (nestedFloatingElements.Count > 0 || columns.Count > 0) 
                { 
                    rect = GetRectangleFromTextPosition(columns, nestedFloatingElements, position);
                    // Add content offset to rect 
                    TransformFromSubpage(ref rect, floaterParagraphResult.ContentOffset);
                }
            }
            else if (paragraph is FigureParagraphResult) 
            {
                FigureParagraphResult figureParagraphResult = (FigureParagraphResult)paragraph; 
                ReadOnlyCollection<ColumnResult> columns = figureParagraphResult.Columns; 
                ReadOnlyCollection<ParagraphResult> nestedFloatingElements = figureParagraphResult.FloatingElements;
                Invariant.Assert(columns != null, "Columns collection is null."); 
                Invariant.Assert(nestedFloatingElements != null, "Paragraph collection is null.");
                if (nestedFloatingElements.Count > 0 || columns.Count > 0)
                {
                    rect = GetRectangleFromTextPosition(columns, nestedFloatingElements, position); 
                    // Add content offset to rect
                    TransformFromSubpage(ref rect, figureParagraphResult.ContentOffset); 
                } 
            }
            else if (paragraph is UIElementParagraphResult) 
            {
                rect = GetRectangleFromEdge(paragraph, position);
                if (rect == Rect.Empty)
                { 
                    // For a UIElementParagraph, we should check if element is either at Element start/end or Content Start end
                    // This is needed to enable selection of embedded object w/ mouse click 
                    rect = GetRectangleFromContentEdge(paragraph, position); 
                }
            } 
            return rect;
        }
Example #10
0
        /// <summary>
        /// Returns a cellinfo class for a point that may be inside of a cell 
        /// </summary>
        /// <param name="paragraph"> 
        /// Para to hit test into 
        /// </param>
        /// <param name="point"> 
        /// Point to hit test
        /// </param>
        /// <param name="tableFilter">
        /// Filter out all results not specific to a given table 
        /// </param>
        private CellInfo GetCellInfoFromPoint(ParagraphResult paragraph, Point point, Table tableFilter) 
        { 
            // Figure out which paragraph is the closest to the input pixel position.
            CellInfo cellInfo = null; 
            if (paragraph is ContainerParagraphResult)
            {
                // a) ContainerParagraph - hittest colleciton of nested paragraphs.
                ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((ContainerParagraphResult)paragraph).Paragraphs; 
                // Paragraphs collection may be empty, but should never be null
                Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null"); 
                if (nestedParagraphs.Count > 0) 
                {
                    cellInfo = GetCellInfoFromPoint(nestedParagraphs, _emptyParagraphCollection, point, tableFilter); 
                }
            }
            else if (paragraph is TableParagraphResult)
            { 
                ReadOnlyCollection<ParagraphResult> nestedParagraphs = ((TableParagraphResult)paragraph).GetParagraphsFromPoint(point, false);
                Invariant.Assert(nestedParagraphs != null, "Paragraph collection is null"); 
                if (nestedParagraphs.Count > 0) 
                {
                    cellInfo = GetCellInfoFromPoint(nestedParagraphs, _emptyParagraphCollection, point, tableFilter); 
                }
                if (cellInfo == null)
                {
                    cellInfo = ((TableParagraphResult)paragraph).GetCellInfoFromPoint(point); 
                }
            } 
            else if (paragraph is SubpageParagraphResult) 
            {
                // Subpage implies new coordinate system. 
                SubpageParagraphResult subpageParagraphResult = (SubpageParagraphResult)paragraph;
                point.X -= subpageParagraphResult.ContentOffset.X;
                point.Y -= subpageParagraphResult.ContentOffset.Y;
 
                // WOOT! COLUMNS!
                cellInfo = GetCellInfoFromPoint(subpageParagraphResult.Columns, subpageParagraphResult.FloatingElements, point, tableFilter); 
                if (cellInfo != null) 
                {
                    cellInfo.Adjust(new Point(subpageParagraphResult.ContentOffset.X, subpageParagraphResult.ContentOffset.Y)); 
                }
            }
            else if (paragraph is FigureParagraphResult)
            { 
                // Subpage implies new coordinate system.
                FigureParagraphResult figureParagraphResult = (FigureParagraphResult)paragraph; 
                TransformToSubpage(ref point, figureParagraphResult.ContentOffset); 
                cellInfo = GetCellInfoFromPoint(figureParagraphResult.Columns, figureParagraphResult.FloatingElements, point, tableFilter);
                if (cellInfo != null) 
                {
                    cellInfo.Adjust(new Point(figureParagraphResult.ContentOffset.X, figureParagraphResult.ContentOffset.Y));
                }
            } 
            else if (paragraph is FloaterParagraphResult)
            { 
                // Subpage implies new coordinate system. 
                FloaterParagraphResult floaterParagraphResult = (FloaterParagraphResult)paragraph;
                TransformToSubpage(ref point, floaterParagraphResult.ContentOffset); 
                cellInfo = GetCellInfoFromPoint(floaterParagraphResult.Columns, floaterParagraphResult.FloatingElements, point, tableFilter);
                if (cellInfo != null)
                {
                    cellInfo.Adjust(new Point(floaterParagraphResult.ContentOffset.X, floaterParagraphResult.ContentOffset.Y)); 
                }
            } 
 
            if (tableFilter != null && cellInfo != null && cellInfo.Cell.Table != tableFilter)
            { 
                cellInfo = null; // Clear out result if not matching input filter
            }
            return cellInfo;
        }