/**
   * Imports the Cell properties into the PatchRtfCell
   *
   * @param cell The Cell to import
   */
  private void importCell(Cell cell) {
    this.content = new ArrayList<RtfBasicElement>();

    if (cell == null) {
      this.borders =
          new PatchRtfBorderGroup(
              this.document,
              PatchRtfBorder.CELL_BORDER,
              this.parentRow.getParentTable().getBorders());
      return;
    }

    if (cell instanceof PatchRtfCell) {
      PatchRtfCell rtfCell = (PatchRtfCell) cell;
      this.minimumHeight = rtfCell.minimumHeight;
    }

    this.colspan = cell.getColspan();
    this.rowspan = cell.getRowspan();
    if (cell.getRowspan() > 1) {
      this.mergeType = MERGE_VERT_PARENT;
    }
    if (cell instanceof PatchRtfCell) {
      this.borders =
          new PatchRtfBorderGroup(
              this.document, PatchRtfBorder.CELL_BORDER, ((PatchRtfCell) cell).getBorders());
    } else {
      this.borders =
          new PatchRtfBorderGroup(
              this.document,
              PatchRtfBorder.CELL_BORDER,
              cell.getBorder(),
              cell.getBorderWidth(),
              cell.getBorderColor());
    }
    this.verticalAlignment = cell.getVerticalAlignment();
    if (cell.getBackgroundColor() == null) {
      this.backgroundColor = new RtfColor(this.document, 255, 255, 255);
    } else {
      this.backgroundColor = new RtfColor(this.document, cell.getBackgroundColor());
    }

    this.cellPadding = (int) this.parentRow.getParentTable().getCellPadding();

    Iterator cellIterator = cell.getElements();
    Paragraph container = null;
    while (cellIterator.hasNext()) {
      try {
        Element element = (Element) cellIterator.next();
        // should we wrap it in a paragraph
        if (!(element instanceof Paragraph) && !(element instanceof List)) {
          if (container != null) {
            container.add(element);
          } else {
            container = new Paragraph();
            container.setAlignment(cell.getHorizontalAlignment());
            container.add(element);
          }
        } else {
          if (container != null) {
            RtfBasicElement[] rtfElements = this.document.getMapper().mapElement(container);
            for (int i = 0; i < rtfElements.length; i++) {
              rtfElements[i].setInTable(true);
              this.content.add(rtfElements[i]);
            }
            container = null;
          }
          // if horizontal alignment is undefined overwrite
          // with that of enclosing cell
          if (element instanceof Paragraph
              && ((Paragraph) element).getAlignment() == Element.ALIGN_UNDEFINED) {
            ((Paragraph) element).setAlignment(cell.getHorizontalAlignment());
          }

          RtfBasicElement[] rtfElements = this.document.getMapper().mapElement(element);
          for (int i = 0; i < rtfElements.length; i++) {
            rtfElements[i].setInTable(true);
            this.content.add(rtfElements[i]);
          }
        }
      } catch (DocumentException de) {
        de.printStackTrace();
      }
    }
    if (container != null) {
      try {
        RtfBasicElement[] rtfElements = this.document.getMapper().mapElement(container);
        for (int i = 0; i < rtfElements.length; i++) {
          rtfElements[i].setInTable(true);
          this.content.add(rtfElements[i]);
        }
      } catch (DocumentException de) {
        de.printStackTrace();
      }
    }
  }
Example #2
0
  /**
   * Constructs a <CODE>PdfCell</CODE>-object.
   *
   * @param cell the original <CODE>Cell</CODE>
   * @param rownumber the number of the <CODE>Row</CODE> the <CODE>Cell</CODE> was in.
   * @param left the left border of the <CODE>PdfCell</CODE>
   * @param right the right border of the <CODE>PdfCell</CODE>
   * @param top the top border of the <CODE>PdfCell</CODE>
   * @param cellspacing the cellspacing of the <CODE>Table</CODE>
   * @param cellpadding the cellpadding of the <CODE>Table</CODE>
   */
  public PdfCell(
      Cell cell,
      int rownumber,
      float left,
      float right,
      float top,
      float cellspacing,
      float cellpadding) {
    // constructs a Rectangle (the bottomvalue will be changed afterwards)
    super(left, top, right, top);
    // copying the other Rectangle attributes from class Cell
    cloneNonPositionParameters(cell);
    this.cellpadding = cellpadding;
    this.cellspacing = cellspacing;
    this.verticalAlignment = cell.verticalAlignment();
    this.useAscender = cell.isUseAscender();
    this.useDescender = cell.isUseDescender();
    this.useBorderPadding = cell.isUseBorderPadding();

    // initialisation of some parameters
    PdfChunk chunk;
    Element element;
    PdfChunk overflow;
    lines = new ArrayList();
    images = new ArrayList();
    leading = cell.leading();
    int alignment = cell.horizontalAlignment();
    left += cellspacing + cellpadding;
    right -= cellspacing + cellpadding;

    left += getBorderWidthInside(LEFT);
    right -= getBorderWidthInside(RIGHT);

    contentHeight = 0;

    rowspan = cell.rowspan();

    ArrayList allActions;
    int aCounter;
    // we loop over all the elements of the cell
    for (Iterator i = cell.getElements(); i.hasNext(); ) {
      element = (Element) i.next();
      switch (element.type()) {
        case Element.JPEG:
        case Element.IMGRAW:
        case Element.IMGTEMPLATE:
          addImage((Image) element, left, right, 0.4f * leading, alignment); //
          break;
          // if the element is a list
        case Element.LIST:
          if (line != null && line.size() > 0) {
            line.resetAlignment();
            addLine(line);
          }
          allActions = new ArrayList();
          processActions(element, null, allActions);
          aCounter = 0;
          ListItem item;
          // we loop over all the listitems
          for (Iterator items = ((List) element).getItems().iterator(); items.hasNext(); ) {
            item = (ListItem) items.next();
            line = new PdfLine(left + item.indentationLeft(), right, alignment, item.leading());
            line.setListItem(item);
            for (Iterator j = item.getChunks().iterator(); j.hasNext(); ) {
              chunk = new PdfChunk((Chunk) j.next(), (PdfAction) (allActions.get(aCounter++)));
              while ((overflow = line.add(chunk)) != null) {
                addLine(line);
                line = new PdfLine(left + item.indentationLeft(), right, alignment, item.leading());
                chunk = overflow;
              }
              line.resetAlignment();
              addLine(line);
              line = new PdfLine(left + item.indentationLeft(), right, alignment, leading);
            }
          }
          line = new PdfLine(left, right, alignment, leading);
          break;
          // if the element is something else
        default:
          allActions = new ArrayList();
          processActions(element, null, allActions);
          aCounter = 0;

          float currentLineLeading = leading;
          float currentLeft = left;
          float currentRight = right;
          if (element instanceof Phrase) {
            currentLineLeading = ((Phrase) element).leading();
          }
          if (element instanceof Paragraph) {
            Paragraph p = (Paragraph) element;
            currentLeft += p.indentationLeft();
            currentRight -= p.indentationRight();
          }
          if (line == null) {
            line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
          }
          // we loop over the chunks
          ArrayList chunks = element.getChunks();
          if (chunks.isEmpty()) {
            addLine(line); // add empty line - all cells need some lines even if they are empty
            line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
          } else {
            for (Iterator j = chunks.iterator(); j.hasNext(); ) {
              Chunk c = (Chunk) j.next();
              chunk = new PdfChunk(c, (PdfAction) (allActions.get(aCounter++)));
              while ((overflow = line.add(chunk)) != null) {
                addLine(line);
                line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
                chunk = overflow;
              }
            }
          }
          // if the element is a paragraph, section or chapter, we reset the alignment and add the
          // line
          switch (element.type()) {
            case Element.PARAGRAPH:
            case Element.SECTION:
            case Element.CHAPTER:
              line.resetAlignment();
              flushCurrentLine();
          }
      }
    }
    flushCurrentLine();
    if (lines.size() > cell.getMaxLines()) {
      while (lines.size() > cell.getMaxLines()) {
        removeLine(lines.size() - 1);
      }
      if (cell.getMaxLines() > 0) {
        String more = cell.getShowTruncation();
        if (more != null && more.length() > 0) {
          // Denote that the content has been truncated
          lastLine = (PdfLine) lines.get(lines.size() - 1);
          if (lastLine.size() >= 0) {
            PdfChunk lastChunk = lastLine.getChunk(lastLine.size() - 1);
            float moreWidth = new PdfChunk(more, lastChunk).width();
            while (lastChunk.toString().length() > 0
                && lastChunk.width() + moreWidth > right - left) {
              // Remove characters to leave room for the 'more' indicator
              lastChunk.setValue(lastChunk.toString().substring(0, lastChunk.length() - 1));
            }
            lastChunk.setValue(lastChunk.toString() + more);
          } else {
            lastLine.add(new PdfChunk(new Chunk(more), null));
          }
        }
      }
    }
    // we set some additional parameters
    if (useDescender && lastLine != null) {
      contentHeight -= lastLine.getDescender();
    }

    // adjust first line height so that it touches the top
    if (lines.size() > 0) {
      firstLine = (PdfLine) lines.get(0);
      float firstLineRealHeight = firstLineRealHeight();
      contentHeight -= firstLine.height();
      firstLine.height = firstLineRealHeight;
      contentHeight += firstLineRealHeight;
    }

    float newBottom = top - contentHeight - (2f * cellpadding()) - (2f * cellspacing());
    newBottom -= getBorderWidthInside(TOP) + getBorderWidthInside(BOTTOM);
    setBottom(newBottom);

    this.rownumber = rownumber;
  }