LayoutEntityType

Inheritance: java.lang.Object

public class LayoutEntityType

Types of the layout entities.

Examples:

Shows ways of traversing a document’s layout entities.

 public void layoutEnumerator() throws Exception {
     // Open a document that contains a variety of layout entities.
     // Layout entities are pages, cells, rows, lines, and other objects included in the LayoutEntityType enum.
     // Each layout entity has a rectangular space that it occupies in the document body.
     Document doc = new Document(getMyDir() + "Layout entities.docx");

     // Create an enumerator that can traverse these entities like a tree.
     LayoutEnumerator layoutEnumerator = new LayoutEnumerator(doc);

     Assert.assertEquals(doc, layoutEnumerator.getDocument());

     layoutEnumerator.moveParent(LayoutEntityType.PAGE);

     Assert.assertEquals(LayoutEntityType.PAGE, layoutEnumerator.getType());
     Assert.assertThrows(IllegalStateException.class, () -> System.out.println(layoutEnumerator.getText()));

     // We can call this method to make sure that the enumerator will be at the first layout entity.
     layoutEnumerator.reset();

     // There are two orders that determine how the layout enumerator continues traversing layout entities
     // when it encounters entities that span across multiple pages.
     // 1 -  In visual order:
     // When moving through an entity's children that span multiple pages,
     // page layout takes precedence, and we move to other child elements on this page and avoid the ones on the next.
     System.out.println("Traversing from first to last, elements between pages separated:");
     traverseLayoutForward(layoutEnumerator, 1);

     // Our enumerator is now at the end of the collection. We can traverse the layout entities backwards to go back to the beginning.
     System.out.println("Traversing from last to first, elements between pages separated:");
     traverseLayoutBackward(layoutEnumerator, 1);

     // 2 -  In logical order:
     // When moving through an entity's children that span multiple pages,
     // the enumerator will move between pages to traverse all the child entities.
     System.out.println("Traversing from first to last, elements between pages mixed:");
     traverseLayoutForwardLogical(layoutEnumerator, 1);

     System.out.println("Traversing from last to first, elements between pages mixed:");
     traverseLayoutBackwardLogical(layoutEnumerator, 1);
 }

 /// 
 /// Enumerate through layoutEnumerator's layout entity collection front-to-back,
 /// in a depth-first manner, and in the "Visual" order.
 /// 
 private static void traverseLayoutForward(LayoutEnumerator layoutEnumerator, int depth) throws Exception {
     do {
         printCurrentEntity(layoutEnumerator, depth);

         if (layoutEnumerator.moveFirstChild()) {
             traverseLayoutForward(layoutEnumerator, depth + 1);
             layoutEnumerator.moveParent();
         }
     } while (layoutEnumerator.moveNext());
 }

 /// 
 /// Enumerate through layoutEnumerator's layout entity collection back-to-front,
 /// in a depth-first manner, and in the "Visual" order.
 /// 
 private static void traverseLayoutBackward(LayoutEnumerator layoutEnumerator, int depth) throws Exception {
     do {
         printCurrentEntity(layoutEnumerator, depth);

         if (layoutEnumerator.moveLastChild()) {
             traverseLayoutBackward(layoutEnumerator, depth + 1);
             layoutEnumerator.moveParent();
         }
     } while (layoutEnumerator.movePrevious());
 }

 /// 
 /// Enumerate through layoutEnumerator's layout entity collection front-to-back,
 /// in a depth-first manner, and in the "Logical" order.
 /// 
 private static void traverseLayoutForwardLogical(LayoutEnumerator layoutEnumerator, int depth) throws Exception {
     do {
         printCurrentEntity(layoutEnumerator, depth);

         if (layoutEnumerator.moveFirstChild()) {
             traverseLayoutForwardLogical(layoutEnumerator, depth + 1);
             layoutEnumerator.moveParent();
         }
     } while (layoutEnumerator.moveNextLogical());
 }

 /// 
 /// Enumerate through layoutEnumerator's layout entity collection back-to-front,
 /// in a depth-first manner, and in the "Logical" order.
 /// 
 private static void traverseLayoutBackwardLogical(LayoutEnumerator layoutEnumerator, int depth) throws Exception {
     do {
         printCurrentEntity(layoutEnumerator, depth);

         if (layoutEnumerator.moveLastChild()) {
             traverseLayoutBackwardLogical(layoutEnumerator, depth + 1);
             layoutEnumerator.moveParent();
         }
     } while (layoutEnumerator.movePreviousLogical());
 }

 /// 
 /// Print information about layoutEnumerator's current entity to the console, while indenting the text with tab characters
 /// based on its depth relative to the root node that we provided in the constructor LayoutEnumerator instance.
 /// The rectangle that we process at the end represents the area and location that the entity takes up in the document.
 /// 
 private static void printCurrentEntity(LayoutEnumerator layoutEnumerator, int indent) throws Exception {
     String tabs = StringUtils.repeat("\t", indent);

     System.out.println(layoutEnumerator.getKind().equals("")
             ? MessageFormat.format("{0}-> Entity type: {1}", tabs, layoutEnumerator.getType())
             : MessageFormat.format("{0}-> Entity type & kind: {1}, {2}", tabs, layoutEnumerator.getType(), layoutEnumerator.getKind()));

     // Only spans can contain text.
     if (layoutEnumerator.getType() == LayoutEntityType.SPAN)
         System.out.println("{tabs}   Span contents: \"{layoutEnumerator.Text}\"");

     Rectangle2D.Float leRect = layoutEnumerator.getRectangle();
     System.out.println(MessageFormat.format("{0}   Rectangle dimensions {1}x{2}, X={3} Y={4}", tabs, leRect.getWidth(), leRect.getHeight(), leRect.getX(), leRect.getY()));
     System.out.println(MessageFormat.format("{0}   Page {1}", tabs, layoutEnumerator.getPageIndex()));
 }
 

Fields

Field	Description
CELL	Represents a table cell.
COLUMN	Represents a column of text on a page.
COMMENT	Represents placeholder for comment content.
ENDNOTE	Represents placeholder for endnote content.
FOOTNOTE	Represents placeholder for footnote content.
HEADER_FOOTER	Represents placeholder for header/footer content on a page.
LINE	Represents line of characters of text and inline objects.
NONE	Default value.
NOTE	Represents placeholder for note content.
NOTE_SEPARATOR	Represents footnote/endnote separator.
PAGE	Represents page of a document.
ROW	Represents a table row.
SPAN	Represents one or more characters in a line.
TEXT_BOX	Represents text area inside of a shape.
length

Methods

Method	Description
fromName(String layoutEntityTypeName)
fromNames(Set layoutEntityTypeNames)
getName(int layoutEntityType)
getNames(int layoutEntityType)
getValues()
toString(int layoutEntityType)
toStringSet(int attr)

CELL

public static int CELL

Represents a table cell. Cell may have LINE and ROW child entities.

COLUMN

public static int COLUMN

Represents a column of text on a page. Column may have the same child entities as CELL, plus FOOTNOTE, ENDNOTE and NOTE_SEPARATOR entities.

COMMENT

public static int COMMENT

Represents placeholder for comment content. Comment may have LINE and ROW child entities.

ENDNOTE

public static int ENDNOTE

Represents placeholder for endnote content. Endnote may have NOTE child entities.

FOOTNOTE

public static int FOOTNOTE

Represents placeholder for footnote content. Footnote may have NOTE child entities.

HEADER_FOOTER

public static int HEADER_FOOTER

Represents placeholder for header/footer content on a page. HeaderFooter may have LINE and ROW child entities.

LINE

public static int LINE

Represents line of characters of text and inline objects. Line may have SPAN child entities.

NONE

public static int NONE

Default value.

NOTE

public static int NOTE

Represents placeholder for note content. Note may have LINE and ROW child entities.

NOTE_SEPARATOR

public static int NOTE_SEPARATOR

Represents footnote/endnote separator. NoteSeparator may have LINE and ROW child entities.

PAGE

public static int PAGE

Represents page of a document. Page may have COLUMN, HEADER_FOOTER and COMMENT child entities.

ROW

public static int ROW

Represents a table row. Row may have CELL as child entities.

SPAN

public static int SPAN

Represents one or more characters in a line. This include special characters like field start/end markers, bookmarks and comments. Span may not have child entities.

TEXT_BOX

public static int TEXT_BOX

Represents text area inside of a shape. Textbox may have LINE and ROW child entities.

length

public static int length

fromName(String layoutEntityTypeName)

public static int fromName(String layoutEntityTypeName)

Parameters:

Parameter	Type	Description
layoutEntityTypeName	java.lang.String

Returns: int

fromNames(Set layoutEntityTypeNames)

public static int fromNames(Set layoutEntityTypeNames)

Parameters:

Parameter	Type	Description
layoutEntityTypeNames	java.util.Set

Returns: int

getName(int layoutEntityType)

public static String getName(int layoutEntityType)

Parameters:

Parameter	Type	Description
layoutEntityType	int

Returns: java.lang.String

getNames(int layoutEntityType)

public static Set getNames(int layoutEntityType)

Parameters:

Parameter	Type	Description
layoutEntityType	int

Returns: java.util.Set

getValues()

public static int[] getValues()

Returns: int[]

toString(int layoutEntityType)

public static String toString(int layoutEntityType)

Parameters:

Parameter	Type	Description
layoutEntityType	int

Returns: java.lang.String

toStringSet(int attr)

public static String toStringSet(int attr)

Parameters:

Parameter	Type	Description
attr	int

Returns: java.lang.String