In our documentation framework the table
element can have
cells that span over multiple columns and rows. As explained in the
Styling the Table
Element section which describes the CSS properties needed for
defining a table, we need to indicate oXygen Author a method to
determine the cell spanning. If we use the cell element attributes
rowspan and colspan or rows and
cols, oXygen can determine the cell
spanning automatically. In our example the td
element uses
the attributes row_span and column_span that are not recognized by
default. We will need to implement a Java extension class for defining
the cell spanning.
Create a new Java project, in your IDE.
Create the lib
directory in the Java
project directory and copy in it the oxygen.jar
file from the {oXygen_installation_directory}/lib
directory.
Create the class
simple.documentation.framework.TableCellSpanProvider
.
This class must implement the
ro.sync.ecss.extensions.api.AuthorTableCellSpanProvider
interface.
import ro.sync.ecss.extensions.api.AuthorTableCellSpanProvider; import ro.sync.ecss.extensions.api.node.AttrValue; import ro.sync.ecss.extensions.api.node.AuthorElement; public class TableCellSpanProvider implements AuthorTableCellSpanProvider {
The method init
is taking as argument
the AuthorElement
that represents the XML
table
element. In our case the cell span is
specified for each of the cells so we leave this method empty.
However there are cases like the table CALS model when the cell
spanning is specified in the table
element. In such
cases you must collect the span information by analyzing the
table
element.
public void init(AuthorElement table) { }
The method getColSpan
is taking as
argument the table cell. The table layout engine will ask this
AuthorTableSpanSupport
implementation what is the column span and the row span for each
XML element from the table that was marked as cell in the CSS
using the property display:table-cell
. The
implementation is simple and just parses the value of column_span attribute. The method
must return null
for all the cells that do not
change the span specification.
public Integer getColSpan(AuthorElement cell) { Integer colSpan = null; AttrValue attrValue = cell.getAttribute("column_span"); if(attrValue != null) { // The attribute was found. String cs = attrValue.getValue(); if(cs != null) { try { colSpan = new Integer(cs); } catch (NumberFormatException ex) { // The attribute value was not a number. } } } return colSpan; }
The row span is determined in a similar manner:
public Integer getRowSpan(AuthorElement cell) { Integer rowSpan = null; AttrValue attrValue = cell.getAttribute("row_span"); if(attrValue != null) { // The attribute was found. String rs = attrValue.getValue(); if(rs != null) { try { rowSpan = new Integer(rs); } catch (NumberFormatException ex) { // The attribute value was not a number. } } } return rowSpan; }
The complete source code of our implementation is found in the Example Files Listings, the Java Files section.
Package the compiled class into a jar file.
Copy the jar file into the frameworks/sdf
directory.
Add the jar file to the Author class path.
Register the Java class by clicking on the Table
support label. Press the button and select from the displayed
dialog the name of the class:
TableCellSpanProvider
.
In the listing below, the XML document contains the table element:
<table> <header> <td>C1</td> <td>C2</td> <td>C3</td> <td>C4</td> </header> <tr> <td>cs=1, rs=1</td> <td column_span="2" row_span="2">cs=2, rs=2</td> <td row_span="3">cs=1, rs=3</td> </tr> <tr> <td>cs=1, rs=1</td> </tr> <tr> <td column_span="3">cs=3, rs=1</td> </tr> </table>
When no table cell span provider is specified, the table has the following layout:
When the above implementation is configured, the table has the correct layout: