/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id: FOEventHandler.java 1465599 2013-04-08 11:51:52Z vhennebert $ */

package org.apache.fop.fo;

import org.xml.sax.SAXException;

import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.FormattingResults;
import org.apache.fop.fo.extensions.ExternalDocument;
import org.apache.fop.fo.flow.BasicLink;
import org.apache.fop.fo.flow.Block;
import org.apache.fop.fo.flow.BlockContainer;
import org.apache.fop.fo.flow.Character;
import org.apache.fop.fo.flow.ExternalGraphic;
import org.apache.fop.fo.flow.Footnote;
import org.apache.fop.fo.flow.FootnoteBody;
import org.apache.fop.fo.flow.Inline;
import org.apache.fop.fo.flow.InstreamForeignObject;
import org.apache.fop.fo.flow.Leader;
import org.apache.fop.fo.flow.ListBlock;
import org.apache.fop.fo.flow.ListItem;
import org.apache.fop.fo.flow.ListItemBody;
import org.apache.fop.fo.flow.ListItemLabel;
import org.apache.fop.fo.flow.PageNumber;
import org.apache.fop.fo.flow.PageNumberCitation;
import org.apache.fop.fo.flow.PageNumberCitationLast;
import org.apache.fop.fo.flow.RetrieveMarker;
import org.apache.fop.fo.flow.RetrieveTableMarker;
import org.apache.fop.fo.flow.Wrapper;
import org.apache.fop.fo.flow.table.Table;
import org.apache.fop.fo.flow.table.TableBody;
import org.apache.fop.fo.flow.table.TableCell;
import org.apache.fop.fo.flow.table.TableColumn;
import org.apache.fop.fo.flow.table.TableFooter;
import org.apache.fop.fo.flow.table.TableHeader;
import org.apache.fop.fo.flow.table.TableRow;
import org.apache.fop.fo.pagination.Flow;
import org.apache.fop.fo.pagination.PageSequence;
import org.apache.fop.fo.pagination.Root;
import org.apache.fop.fo.pagination.StaticContent;
import org.apache.fop.fonts.FontEventAdapter;
import org.apache.fop.fonts.FontInfo;

Abstract class defining what should be done with SAX events that map to
XSL-FO input. The events are actually captured by fo/FOTreeBuilder, passed
to the various fo Objects, which in turn, if needed, pass them to an instance
of FOEventHandler.
Sub-classes will generally fall into one of two categories:
1) a handler that actually builds an FO Tree from the events, or 2) a
handler that builds a structured (as opposed to formatted) document, such
as our MIF and RTF output targets.
/**
 * Abstract class defining what should be done with SAX events that map to
 * XSL-FO input. The events are actually captured by fo/FOTreeBuilder, passed
 * to the various fo Objects, which in turn, if needed, pass them to an instance
 * of FOEventHandler.
 *
 * Sub-classes will generally fall into one of two categories:
 * 1) a handler that actually builds an FO Tree from the events, or 2) a
 * handler that builds a structured (as opposed to formatted) document, such
 * as our MIF and RTF output targets.
 */
public abstract class FOEventHandler {

    
The FOUserAgent for this process
/**
     * The FOUserAgent for this process
     */
    protected FOUserAgent foUserAgent;

    
The Font information relevant for this document
/**
     * The Font information relevant for this document
     */
    protected FontInfo fontInfo;

    
Main constructor
Params:
foUserAgent – the apps.FOUserAgent instance for this process/**
     * Main constructor
     * @param foUserAgent the apps.FOUserAgent instance for this process
     */
    public FOEventHandler(FOUserAgent foUserAgent) {
        this.foUserAgent = foUserAgent;
        this.fontInfo = new FontInfo();
        this.fontInfo.setEventListener(new FontEventAdapter(foUserAgent.getEventBroadcaster()));
    }

    
Constructor for sub-classes that do not need an FOUserAgent instance. /** Constructor for sub-classes that do not need an {@link FOUserAgent} instance. */
    protected FOEventHandler() {
    }

    
Returns the User Agent object associated with this FOEventHandler.
Returns:
the User Agent object/**
     * Returns the User Agent object associated with this FOEventHandler.
     * @return the User Agent object
     */
    public FOUserAgent getUserAgent() {
        return foUserAgent;
    }

    
Retrieve the font information for this document
Returns:
the FontInfo instance for this document/**
     * Retrieve the font information for this document
     * @return the FontInfo instance for this document
     */
    public FontInfo getFontInfo() {
        return this.fontInfo;
    }

    
This method is called to indicate the start of a new document run.
Throws:
SAXException – In case of a problem/**
     * This method is called to indicate the start of a new document run.
     * @throws SAXException In case of a problem
     */
    public void startDocument() throws SAXException {
    }

    
This method is called to indicate the end of a document run.
Throws:
SAXException – In case of a problem/**
     * This method is called to indicate the end of a document run.
     * @throws SAXException In case of a problem
     */
    public void endDocument() throws SAXException {
    }

    
Called upon start of root element.
Params:
root – element/**
     * Called upon start of root element.
     * @param root element
     */
    public void startRoot(Root root) {
    }

    
Called upon end of root element.
Params:
root – element/**
     * Called upon end of root element.
     * @param root element
     */
    public void endRoot(Root root) {
    }

    
Params:
pageSeq – PageSequence that is starting./**
     *
     * @param pageSeq PageSequence that is starting.
     */
    public void startPageSequence(PageSequence pageSeq) {
    }

    
Params:
pageSeq – PageSequence that is ending./**
     * @param pageSeq PageSequence that is ending.
     */
    public void endPageSequence(PageSequence pageSeq) {
    }

    
Params:
pagenum – PageNumber that is starting./**
     *
     * @param pagenum PageNumber that is starting.
     */
    public void startPageNumber(PageNumber pagenum) {
    }

    
Params:
pagenum – PageNumber that is ending./**
     *
     * @param pagenum PageNumber that is ending.
     */
    public void endPageNumber(PageNumber pagenum) {
    }

    
Params:
pageCite – PageNumberCitation that is starting./**
     *
     * @param pageCite PageNumberCitation that is starting.
     */
    public void startPageNumberCitation(PageNumberCitation pageCite) {
    }

    
Params:
pageCite – PageNumberCitation that is ending./**
     *
     * @param pageCite PageNumberCitation that is ending.
     */
    public void endPageNumberCitation(PageNumberCitation pageCite) {
    }

    
Params:
pageLast – PageNumberCitationLast that is starting./**
     *
     * @param pageLast PageNumberCitationLast that is starting.
     */
    public void startPageNumberCitationLast(PageNumberCitationLast pageLast) {
    }

    
Params:
pageLast – PageNumberCitationLast that is ending./**
     *
     * @param pageLast PageNumberCitationLast that is ending.
     */
    public void endPageNumberCitationLast(PageNumberCitationLast pageLast) {
    }

    
Process start of a Static.
Params:
staticContent – StaticContent that is starting/**
     * Process start of a Static.
     * @param staticContent StaticContent that is starting
     */
    public void startStatic(StaticContent staticContent) {
    }

    
Process end of a Static.
Params:
staticContent – StaticContent that is ending/**
     * Process end of a Static.
     * @param staticContent StaticContent that is ending
     */
    public void endStatic(StaticContent staticContent) {
    }

    
This method is called to indicate the start of a new fo:flow
or fo:static-content.
This method also handles fo:static-content tags, because the
StaticContent class is derived from the Flow class.
Params:
fl – Flow that is starting./**
     * This method is called to indicate the start of a new fo:flow
     * or fo:static-content.
     * This method also handles fo:static-content tags, because the
     * StaticContent class is derived from the Flow class.
     *
     * @param fl Flow that is starting.
     */
    public void startFlow(Flow fl) {
    }

    
Params:
fl – Flow that is ending./**
     *
     * @param fl Flow that is ending.
     */
    public void endFlow(Flow fl) {
    }

    
Params:
bl – Block that is starting./**
     *
     * @param bl Block that is starting.
     */
    public void startBlock(Block bl) {
    }

    
Params:
bl – Block that is ending./**
     *
     * @param bl Block that is ending.
     */
    public void endBlock(Block bl) {
    }

    
Params:
blc – BlockContainer that is starting./**
    *
    * @param blc BlockContainer that is starting.
    */
    public void startBlockContainer(BlockContainer blc) {
    }

    
Params:
blc – BlockContainer that is ending./**
    *
    * @param blc BlockContainer that is ending.
    */
    public void endBlockContainer(BlockContainer blc) {
    }

    
Params:
inl – Inline that is starting./**
     *
     * @param inl Inline that is starting.
     */
    public void startInline(Inline inl) {
    }

    
Params:
inl – Inline that is ending./**
     *
     * @param inl Inline that is ending.
     */
    public void endInline(Inline inl) {
    }

    // Tables
    
Params:
tbl – Table that is starting./**
     *
     * @param tbl Table that is starting.
     */
    public void startTable(Table tbl) {
    }

    
Params:
tbl – Table that is ending./**
     *
     * @param tbl Table that is ending.
     */
    public void endTable(Table tbl) {
    }

    
Params:
tc – TableColumn that is starting;/**
     *
     * @param tc TableColumn that is starting;
     */
    public void startColumn(TableColumn tc) {
    }

    
Params:
tc – TableColumn that is ending;/**
     *
     * @param tc TableColumn that is ending;
     */
    public void endColumn(TableColumn tc) {
    }

    
Params:
header – TableHeader that is starting;/**
     *
     * @param header TableHeader that is starting;
     */
    public void startHeader(TableHeader header) {
    }

    
Params:
header – TableHeader that is ending./**
     *
     * @param header TableHeader that is ending.
     */
    public void endHeader(TableHeader header) {
    }

    
Params:
footer – TableFooter that is starting./**
     *
     * @param footer TableFooter that is starting.
     */
    public void startFooter(TableFooter footer) {
    }

    
Params:
footer – TableFooter that is ending./**
     *
     * @param footer TableFooter that is ending.
     */
    public void endFooter(TableFooter footer) {
    }

    
Params:
body – TableBody that is starting./**
     *
     * @param body TableBody that is starting.
     */
    public void startBody(TableBody body) {
    }

    
Params:
body – TableBody that is ending./**
     *
     * @param body TableBody that is ending.
     */
    public void endBody(TableBody body) {
    }

    
Params:
tr – TableRow that is starting./**
     *
     * @param tr TableRow that is starting.
     */
    public void startRow(TableRow tr) {
    }

    
Params:
tr – TableRow that is ending./**
     *
     * @param tr TableRow that is ending.
     */
    public void endRow(TableRow tr) {
    }

    
Params:
tc – TableCell that is starting./**
     *
     * @param tc TableCell that is starting.
     */
    public void startCell(TableCell tc) {
    }

    
Params:
tc – TableCell that is ending./**
     *
     * @param tc TableCell that is ending.
     */
    public void endCell(TableCell tc) {
    }


    // Lists
    
Params:
lb – ListBlock that is starting./**
     *
     * @param lb ListBlock that is starting.
     */
    public void startList(ListBlock lb) {
    }

    
Params:
lb – ListBlock that is ending./**
     *
     * @param lb ListBlock that is ending.
     */
    public void endList(ListBlock lb) {
    }

    
Params:
li – ListItem that is starting./**
     *
     * @param li ListItem that is starting.
     */
    public void startListItem(ListItem li) {
    }

    
Params:
li – ListItem that is ending./**
     *
     * @param li ListItem that is ending.
     */
    public void endListItem(ListItem li) {
    }

    
Process start of a ListLabel.
Params:
listItemLabel – ListItemLabel that is starting/**
     * Process start of a ListLabel.
     * @param listItemLabel ListItemLabel that is starting
     */
    public void startListLabel(ListItemLabel listItemLabel) {
    }

    
Process end of a ListLabel.
Params:
listItemLabel – ListItemLabel that is ending/**
     * Process end of a ListLabel.
     * @param listItemLabel ListItemLabel that is ending
     */
    public void endListLabel(ListItemLabel listItemLabel) {
    }

    
Process start of a ListBody.
Params:
listItemBody – ListItemBody that is starting/**
     * Process start of a ListBody.
     * @param listItemBody ListItemBody that is starting
     */
    public void startListBody(ListItemBody listItemBody) {
    }

    
Process end of a ListBody.
Params:
listItemBody – ListItemBody that is ending/**
     * Process end of a ListBody.
     * @param listItemBody ListItemBody that is ending
     */
    public void endListBody(ListItemBody listItemBody) {
    }

    
Process start of a Markup.
/**
     * Process start of a Markup.
     */
    public void startMarkup() {
    }

    
Process end of a Markup.
/**
     * Process end of a Markup.
     */
    public void endMarkup() {
    }

    
Process start of a Link.
Params:
basicLink – BasicLink that is starting/**
     * Process start of a Link.
     * @param basicLink BasicLink that is starting
     */
    public void startLink(BasicLink basicLink) {
    }

    
Process end of a Link.
Params:
basicLink – BasicLink that is ending/**
     * Process end of a Link.
     * @param basicLink BasicLink that is ending
     */
    public void endLink(BasicLink basicLink) {
    }

    
Process an ExternalGraphic.
Params:
eg – ExternalGraphic to process./**
     * Process an ExternalGraphic.
     * @param eg ExternalGraphic to process.
     */
    public void image(ExternalGraphic eg) {
    }

    
Process a pageRef.
/**
     * Process a pageRef.
     */
    public void pageRef() {
    }

    
Process the start of an InstreamForeignObject.
Params:
ifo – InstreamForeignObject that is starting/**
     * Process the start of an InstreamForeignObject.
     * @param ifo InstreamForeignObject that is starting
     */
    public void startInstreamForeignObject(InstreamForeignObject ifo) {
    }

    
Process the end of an InstreamForeignObject.
Params:
ifo – InstreamForeignObject that is ending/**
     * Process the end of an InstreamForeignObject.
     * @param ifo InstreamForeignObject that is ending
     */
    public void endInstreamForeignObject(InstreamForeignObject ifo) {
    }

    
Process the start of a footnote.
Params:
footnote – Footnote that is starting/**
     * Process the start of a footnote.
     * @param footnote Footnote that is starting
     */
    public void startFootnote(Footnote footnote) {
    }

    
Process the ending of a footnote.
Params:
footnote – Footnote that is ending/**
     * Process the ending of a footnote.
     * @param footnote Footnote that is ending
     */
    public void endFootnote(Footnote footnote) {
    }

    
Process the start of a footnote body.
Params:
body – FootnoteBody that is starting/**
     * Process the start of a footnote body.
     * @param body FootnoteBody that is starting
     */
    public void startFootnoteBody(FootnoteBody body) {
    }

    
Process the ending of a footnote body.
Params:
body – FootnoteBody that is ending/**
     * Process the ending of a footnote body.
     * @param body FootnoteBody that is ending
     */
    public void endFootnoteBody(FootnoteBody body) {
    }

    
Process the start of a Leader.
Params:
l – Leader that is starting/**
     * Process the start of a Leader.
     * @param l Leader that is starting
     */
    public void startLeader(Leader l) {
    }

    
Process the end of a Leader.
Params:
l – Leader that is ending/**
     * Process the end of a Leader.
     * @param l Leader that is ending
     */
    public void endLeader(Leader l) {
    }

    
Process the start of a wrapper.
Params:
wrapper – wrapper that is starting/**
     * Process the start of a wrapper.
     *
     * @param wrapper wrapper that is starting
     */
    public void startWrapper(Wrapper wrapper) {
    }

    
Process the ending of a wrapper.
Params:
wrapper – wrapper that is ending/**
     * Process the ending of a wrapper.
     *
     * @param wrapper wrapper that is ending
     */
    public void endWrapper(Wrapper wrapper) {
    }

    
Process the start of a retrieve-marker.
Params:
retrieveMarker – the retrieve-marker that is starting/**
     * Process the start of a retrieve-marker.
     *
     * @param retrieveMarker the retrieve-marker that is starting
     */
    public void startRetrieveMarker(RetrieveMarker retrieveMarker) {
    }


    
Process the ending of a retrieve-marker.
Params:
retrieveMarker – the retrieve-marker that is ending/**
     * Process the ending of a retrieve-marker.
     *
     * @param retrieveMarker the retrieve-marker that is ending
     */
    public void endRetrieveMarker(RetrieveMarker retrieveMarker) {
    }

    
Restore the state of this event handler as it was when the given fo:retrieve-marker
element was processed. This method is called at marker retrieval time, so that
events for the marker descendants are fired within the proper context.
The default implementation of this method does nothing.
Params:
retrieveMarker – the fo:retrieve-marker element that is retrieving markers/**
     * Restore the state of this event handler as it was when the given fo:retrieve-marker
     * element was processed. This method is called at marker retrieval time, so that
     * events for the marker descendants are fired within the proper context.
     * <p>The default implementation of this method does nothing.</p>
     *
     * @param retrieveMarker the fo:retrieve-marker element that is retrieving markers
     */
    public void restoreState(RetrieveMarker retrieveMarker) {
    }

    
Process the start of a retrieve-table-marker.
Params:
retrieveTableMarker – the retrieve-table-marker that is starting/**
     * Process the start of a retrieve-table-marker.
     *
     * @param retrieveTableMarker the retrieve-table-marker that is starting
     */
    public void startRetrieveTableMarker(RetrieveTableMarker retrieveTableMarker) {
    }

    
Process the ending of a retrieve-table-marker.
Params:
retrieveTableMarker – the retrieve-table-marker that is ending/**
     * Process the ending of a retrieve-table-marker.
     *
     * @param retrieveTableMarker the retrieve-table-marker that is ending
     */
    public void endRetrieveTableMarker(RetrieveTableMarker retrieveTableMarker) {
    }

    
See restoreState(RetrieveMarker). /**
     * See {@link #restoreState(RetrieveMarker)}.
     */
    public void restoreState(RetrieveTableMarker retrieveTableMarker) {
    }

    
Process a Character.
Params:
c – Character to process./**
     * Process a Character.
     * @param c Character to process.
     */
    public void character(Character c) {
    }

    
Process character data.
Params:
foText – text to process/**
     * Process character data.
     * @param foText text to process
     */
    public void characters(FOText foText) {
    }

    
Process the start of the external-document extension.
Params:
document – the external-document node/**
     * Process the start of the external-document extension.
     * @param document the external-document node
     */
    public void startExternalDocument(ExternalDocument document) {
    }

    
Process the end of the external-document extension.
Params:
document – the external-document node/**
     * Process the end of the external-document extension.
     * @param document the external-document node
     */
    public void endExternalDocument(ExternalDocument document) {
    }

    
Get formatting results.
Returns:
the FormattingResults instance for this document/**
     * Get formatting results.
     * @return the FormattingResults instance for this document
     */
    public FormattingResults getResults() {
        return null;
    }

}