Package org.jfree.layouting.renderer

## Class PrototypeBuildingRenderer

- java.lang.Object
- - org.jfree.layouting.renderer.PrototypeBuildingRenderer

- All Implemented Interfaces:
    `Renderer`, `StatefullComponent`

      public class PrototypeBuildingRenderer
      extends java.lang.Object
      implements Renderer

  This renderer does not build real output. This renderer fills in prototype element definitions and is later used to spit them out when requested. Prototypes are filled in in the first stage of the renderering and are reused in all subsequent stages. This class needs to be implemented later.
  Author:
    Thomas Morgner

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `PrototypeBuildingRenderer​(LayoutProcess layoutProcess)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addContent​(LayoutContext context, ContentToken content)` |
    `void` | `addPassThroughContent​(LayoutContext context, ContentToken content)` |
    `void` | `finishedBlock​()` |
    `void` | `finishedDocument​()` |
    `void` | `finishedFlow​()` |
    `void` | `finishedInline​()` |
    `void` | `finishedMarker​()` |
    `void` | `finishedPassThrough​()` |
    `void` | `finishedRootInline​()` |
    `void` | `finishedTable​()` |
    `void` | `finishedTableCaption​()` |
    `void` | `finishedTableCell​()` |
    `void` | `finishedTableColumn​()` |
    `void` | `finishedTableColumnGroup​()` |
    `void` | `finishedTableRow​()` |
    `void` | `finishedTableSection​()` |
    `void` | `handlePageBreak​(PageContext pageContext)` | A call-back that informs the renderer, that a new page must be started.
    `State` | `saveState​()` |
    `void` | `startedBlock​(LayoutContext context)` |
    `void` | `startedDocument​(PageContext pageContext)` | Starts the document and initalizes the default page context.
    `void` | `startedFlow​(LayoutContext context)` | Starts a floating, absolute or static element.
    `void` | `startedInline​(LayoutContext context)` |
    `void` | `startedMarker​(LayoutContext context)` |
    `void` | `startedPassThrough​(LayoutContext context)` |
    `void` | `startedRootInline​(LayoutContext context)` |
    `void` | `startedTable​(LayoutContext layoutContext)` |
    `void` | `startedTableCaption​(LayoutContext context)` |
    `void` | `startedTableCell​(LayoutContext layoutContext)` |
    `void` | `startedTableColumn​(LayoutContext context)` |
    `void` | `startedTableColumnGroup​(LayoutContext context)` |
    `void` | `startedTableRow​(LayoutContext layoutContext)` |
    `void` | `startedTableSection​(LayoutContext layoutContext)` |

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### PrototypeBuildingRenderer

          public PrototypeBuildingRenderer​(LayoutProcess layoutProcess)

  - ### Method Detail

    - #### startedDocument

          public void startedDocument​(PageContext pageContext)

      Starts the document and initalizes the default page context.
      Specified by:
        `startedDocument` in interface `Renderer`
      Parameters:
        `pageContext` -

    - #### startedFlow

          public void startedFlow​(LayoutContext context)
                           throws NormalizationException

      Starts a floating, absolute or static element. This establishes a new normal flow for the element.
      Specified by:
        `startedFlow` in interface `Renderer`
      Parameters:
        `context` -
      Throws:
        `NormalizationException`

    - #### startedTable

          public void startedTable​(LayoutContext layoutContext)
                            throws NormalizationException

      Specified by:
        `startedTable` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedTableColumnGroup

          public void startedTableColumnGroup​(LayoutContext context)
                                       throws NormalizationException

      Specified by:
        `startedTableColumnGroup` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedTableColumn

          public void startedTableColumn​(LayoutContext context)
                                  throws NormalizationException

      Specified by:
        `startedTableColumn` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedTableSection

          public void startedTableSection​(LayoutContext layoutContext)
                                   throws NormalizationException

      Specified by:
        `startedTableSection` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedTableRow

          public void startedTableRow​(LayoutContext layoutContext)
                               throws NormalizationException

      Specified by:
        `startedTableRow` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedTableCell

          public void startedTableCell​(LayoutContext layoutContext)
                                throws NormalizationException

      Specified by:
        `startedTableCell` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedBlock

          public void startedBlock​(LayoutContext context)
                            throws NormalizationException

      Specified by:
        `startedBlock` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedMarker

          public void startedMarker​(LayoutContext context)
                             throws NormalizationException

      Specified by:
        `startedMarker` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedRootInline

          public void startedRootInline​(LayoutContext context)
                                 throws NormalizationException

      Specified by:
        `startedRootInline` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### startedInline

          public void startedInline​(LayoutContext context)
                             throws NormalizationException

      Specified by:
        `startedInline` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### addContent

          public void addContent​(LayoutContext context,
                                 ContentToken content)
                          throws NormalizationException

      Specified by:
        `addContent` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedInline

          public void finishedInline​()
                              throws NormalizationException

      Specified by:
        `finishedInline` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedRootInline

          public void finishedRootInline​()
                                  throws NormalizationException

      Specified by:
        `finishedRootInline` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedMarker

          public void finishedMarker​()
                              throws NormalizationException

      Specified by:
        `finishedMarker` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedBlock

          public void finishedBlock​()
                             throws NormalizationException

      Specified by:
        `finishedBlock` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableCell

          public void finishedTableCell​()
                                 throws NormalizationException

      Specified by:
        `finishedTableCell` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableRow

          public void finishedTableRow​()
                                throws NormalizationException

      Specified by:
        `finishedTableRow` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableSection

          public void finishedTableSection​()
                                    throws NormalizationException

      Specified by:
        `finishedTableSection` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableColumnGroup

          public void finishedTableColumnGroup​()
                                        throws NormalizationException

      Specified by:
        `finishedTableColumnGroup` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableColumn

          public void finishedTableColumn​()
                                   throws NormalizationException

      Specified by:
        `finishedTableColumn` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTable

          public void finishedTable​()
                             throws NormalizationException

      Specified by:
        `finishedTable` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedFlow

          public void finishedFlow​()
                            throws NormalizationException

      Specified by:
        `finishedFlow` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedDocument

          public void finishedDocument​()
                                throws NormalizationException

      Specified by:
        `finishedDocument` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### handlePageBreak

          public void handlePageBreak​(PageContext pageContext)

      A call-back that informs the renderer, that a new page must be started. This closes the old page context and copies all pending content to the new context.

      This method is triggered by a call to 'LayoutProcess.pageBreakEncountered'
      Specified by:
        `handlePageBreak` in interface `Renderer`
      Parameters:
        `pageContext` -

    - #### startedPassThrough

          public void startedPassThrough​(LayoutContext context)

      Specified by:
        `startedPassThrough` in interface `Renderer`

    - #### addPassThroughContent

          public void addPassThroughContent​(LayoutContext context,
                                            ContentToken content)

      Specified by:
        `addPassThroughContent` in interface `Renderer`

    - #### finishedPassThrough

          public void finishedPassThrough​()

      Specified by:
        `finishedPassThrough` in interface `Renderer`

    - #### saveState

          public State saveState​()
                          throws StateException

      Specified by:
        `saveState` in interface `StatefullComponent`
      Throws:
        `StateException`

    - #### startedTableCaption

          public void startedTableCaption​(LayoutContext context)
                                   throws NormalizationException

      Specified by:
        `startedTableCaption` in interface `Renderer`
      Throws:
        `NormalizationException`

    - #### finishedTableCaption

          public void finishedTableCaption​()
                                    throws NormalizationException

      Specified by:
        `finishedTableCaption` in interface `Renderer`
      Throws:
        `NormalizationException`