LayoutEntityType (Aspose.Words for Java API Reference)

java.lang.Object
- com.aspose.words.LayoutEntityType

public class LayoutEntityType
extends java.lang.Object

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);
 }

 /// <summary>
 /// Enumerate through layoutEnumerator's layout entity collection front-to-back,
 /// in a depth-first manner, and in the "Visual" order.
 /// </summary>
 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());
 }

 /// <summary>
 /// Enumerate through layoutEnumerator's layout entity collection back-to-front,
 /// in a depth-first manner, and in the "Visual" order.
 /// </summary>
 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());
 }

 /// <summary>
 /// Enumerate through layoutEnumerator's layout entity collection front-to-back,
 /// in a depth-first manner, and in the "Logical" order.
 /// </summary>
 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());
 }

 /// <summary>
 /// Enumerate through layoutEnumerator's layout entity collection back-to-front,
 /// in a depth-first manner, and in the "Logical" order.
 /// </summary>
 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());
 }

 /// <summary>
 /// 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.
 /// </summary>
 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()));
 }

Field Summary

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

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`fromName(java.lang.String layoutEntityTypeName)`
`static int`	`fromNames(java.util.Set layoutEntityTypeNames)`
`static java.lang.String`	`getName(int layoutEntityType)`
`static java.util.Set`	`getNames(int layoutEntityType)`
`static int[]`	`getValues()`
`static java.lang.String`	`toString(int layoutEntityType)`
`static java.lang.String`	`toStringSet(int attr)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NONE
```
public static int NONE
```
    Default value.
  - PAGE
```
public static int PAGE
```
    Represents page of a document. Page may have COLUMN, HEADER_FOOTER and COMMENT 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.
  - ROW
```
public static int ROW
```
    Represents a table row. Row may have CELL as child entities.
  - CELL
```
public static int CELL
```
    Represents a table cell. Cell 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.
  - 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.
  - FOOTNOTE
```
public static int FOOTNOTE
```
    Represents placeholder for footnote content. Footnote may have NOTE child entities.
  - ENDNOTE
```
public static int ENDNOTE
```
    Represents placeholder for endnote content. Endnote may have NOTE child entities.
  - NOTE
```
public static int NOTE
```
    Represents placeholder for note content. Note may have LINE and ROW 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.
  - TEXT_BOX
```
public static int TEXT_BOX
```
    Represents text area inside of a shape. Textbox may have LINE and ROW child entities.
  - COMMENT
```
public static int COMMENT
```
    Represents placeholder for comment content. Comment 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.
  - length
```
public static int length
```
- Method Detail
  - getName
```
public static java.lang.String getName(int layoutEntityType)
```
  - getNames
```
public static java.util.Set getNames(int layoutEntityType)
```
  - toString
```
public static java.lang.String toString(int layoutEntityType)
```
  - toStringSet
```
public static java.lang.String toStringSet(int attr)
```
  - fromName
```
public static int fromName(java.lang.String layoutEntityTypeName)
```
  - fromNames
```
public static int fromNames(java.util.Set layoutEntityTypeNames)
```
  - getValues
```
public static int[] getValues()
```

Class LayoutEntityType

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NONE

PAGE

COLUMN

ROW

CELL

LINE

SPAN

FOOTNOTE

ENDNOTE

NOTE

HEADER_FOOTER

TEXT_BOX

COMMENT

NOTE_SEPARATOR

length

Method Detail

getName

getNames

toString

toStringSet

fromName

fromNames

getValues