コード例 #1
0
  @Override
  protected void outputCharacters(Element pElement, CharacterRun characterRun, String text) {
    Element span = htmlDocumentFacade.document.createElement("span");
    pElement.appendChild(span);

    StringBuilder style = new StringBuilder();
    BlockProperies blockProperies = this.blocksProperies.peek();
    Triplet triplet = getCharacterRunTriplet(characterRun);

    if (WordToHtmlUtils.isNotEmpty(triplet.fontName)
        && !WordToHtmlUtils.equals(triplet.fontName, blockProperies.pFontName)) {
      style.append("font-family:" + triplet.fontName + ";");
    }
    if (characterRun.getFontSize() / 2 != blockProperies.pFontSize) {
      style.append("font-size:" + characterRun.getFontSize() / 2 + "pt;");
    }
    if (triplet.bold) {
      style.append("font-weight:bold;");
    }
    if (triplet.italic) {
      style.append("font-style:italic;");
    }

    WordToHtmlUtils.addCharactersProperties(characterRun, style);
    if (style.length() != 0) htmlDocumentFacade.addStyleClass(span, "s", style.toString());

    Text textNode = htmlDocumentFacade.createText(text);
    span.appendChild(textNode);
  }
コード例 #2
0
  protected void processSection(HWPFDocument wordDocument, Section section, int sectionCounter) {
    // TODO   解析章节
    Element div = htmlDocumentFacade.createBlock();
    htmlDocumentFacade.addStyleClass(div, "d", getSectionStyle(section));
    //      htmlDocumentFacade.body.appendChild( div );
    pageContainer.appendChild(div);

    processParagraphes(wordDocument, div, section, Integer.MIN_VALUE);
  }
コード例 #3
0
  /** 转换文档 */
  public static String convert(String filePath, String output) {

    HtmlDocumentFacade facade = null;

    //		File docFile = new File(docPath);
    try {
      facade =
          new HtmlDocumentFacade(
              DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument());

      String s1 = "background-color:gray";
      facade.addStyleClass(facade.body, "body", s1);

    } catch (Exception e) {
      e.printStackTrace();
    }

    if (AbstractWordUtils.isEmpty(filePath) || AbstractWordUtils.isEmpty(output)) {
      System.err.println("docPath OR output is empty. >>!quit");
      return "";
    }

    System.out.println("Converting " + filePath);
    System.out.println("Saving output to " + output);

    DocConverter.output =
        output
            .substring(0, output.lastIndexOf(".html"))
            .concat(File.separator)
            .concat("images")
            .concat(File.separator);
    // get fileName

    new File(DocConverter.output).mkdirs();

    try {
      Document doc = null;
      if (facade == null) doc = DocConverter.process(new File(filePath));
      else {
        Document document = facade.getDocument();
        Element window = document.createElement("div");
        Element center = document.createElement("center");
        center.appendChild(window);
        facade.addStyleClass(
            window,
            "window",
            "border:2px solid green;width:800px!important; margin:0 auto; background-color:#fff; text-align:left;");
        facade.body.appendChild(center);
        pageContainer = window;

        doc = DocConverter.process(new File(filePath), facade);
      }

      FileWriter out = new FileWriter(output);
      DOMSource domSource = new DOMSource(doc);
      StreamResult streamResult = new StreamResult(out);

      TransformerFactory tf = TransformerFactory.newInstance();
      Transformer serializer = tf.newTransformer();
      // TODO set encoding from a command argument
      serializer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
      serializer.setOutputProperty(OutputKeys.INDENT, "yes");
      serializer.setOutputProperty(OutputKeys.METHOD, "html");
      serializer.transform(domSource, streamResult);
      out.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return "";
  }
コード例 #4
0
  /** 解析table */
  protected void processTable(HWPFDocument hwpfDocument, Element flow, Table table) {
    Element tableHeader = htmlDocumentFacade.createTableHeader();
    Element tableBody = htmlDocumentFacade.createTableBody();

    final int[] tableCellEdges = WordToHtmlUtils.buildTableCellEdgesArray(table);
    final int tableRows = table.numRows();

    int maxColumns = Integer.MIN_VALUE;
    for (int r = 0; r < tableRows; r++) {
      maxColumns = Math.max(maxColumns, table.getRow(r).numCells());
    }

    for (int r = 0; r < tableRows; r++) {
      TableRow tableRow = table.getRow(r);

      Element tableRowElement = htmlDocumentFacade.createTableRow();
      StringBuilder tableRowStyle = new StringBuilder();

      WordToHtmlUtils.addTableRowProperties(tableRow, tableRowStyle);

      // index of current element in tableCellEdges[]
      int currentEdgeIndex = 0;
      final int rowCells = tableRow.numCells();
      for (int c = 0; c < rowCells; c++) {
        TableCell tableCell = tableRow.getCell(c);

        if (tableCell.isVerticallyMerged() && !tableCell.isFirstVerticallyMerged()) {
          currentEdgeIndex += getNumberColumnsSpanned(tableCellEdges, currentEdgeIndex, tableCell);
          continue;
        }

        Element tableCellElement;
        if (tableRow.isTableHeader()) {
          tableCellElement = htmlDocumentFacade.createTableHeaderCell();
        } else {
          tableCellElement = htmlDocumentFacade.createTableCell();
        }
        StringBuilder tableCellStyle = new StringBuilder();
        WordToHtmlUtils.addTableCellProperties(
            tableRow,
            tableCell,
            r == 0,
            r == tableRows - 1,
            c == 0,
            c == rowCells - 1,
            tableCellStyle);

        int colSpan = getNumberColumnsSpanned(tableCellEdges, currentEdgeIndex, tableCell);
        currentEdgeIndex += colSpan;

        if (colSpan == 0) continue;

        if (colSpan != 1) tableCellElement.setAttribute("colspan", String.valueOf(colSpan));

        final int rowSpan = getNumberRowsSpanned(table, tableCellEdges, r, c, tableCell);
        if (rowSpan > 1) tableCellElement.setAttribute("rowspan", String.valueOf(rowSpan));

        processParagraphes(hwpfDocument, tableCellElement, tableCell, table.getTableLevel());

        if (!tableCellElement.hasChildNodes()) {
          tableCellElement.appendChild(htmlDocumentFacade.createParagraph());
        }
        if (tableCellStyle.length() > 0)
          htmlDocumentFacade.addStyleClass(
              tableCellElement, tableCellElement.getTagName(), tableCellStyle.toString());

        tableRowElement.appendChild(tableCellElement);
      }

      if (tableRowStyle.length() > 0)
        tableRowElement.setAttribute(
            "class", htmlDocumentFacade.getOrCreateCssClass("r", tableRowStyle.toString()));

      if (tableRow.isTableHeader()) {
        tableHeader.appendChild(tableRowElement);
      } else {
        tableBody.appendChild(tableRowElement);
      }
    }

    final Element tableElement = htmlDocumentFacade.createTable();
    tableElement.setAttribute(
        "class",
        htmlDocumentFacade.getOrCreateCssClass(
            "t", "table-layout:fixed;border-collapse:collapse;border-spacing:0;"));
    if (tableHeader.hasChildNodes()) {
      tableElement.appendChild(tableHeader);
    }
    if (tableBody.hasChildNodes()) {
      tableElement.appendChild(tableBody);
      flow.appendChild(tableElement);
    } else {
      logger.log(
          POILogger.WARN,
          "Table without body starting at [",
          Integer.valueOf(table.getStartOffset()),
          "; ",
          Integer.valueOf(table.getEndOffset()),
          ")");
    }
  }
コード例 #5
0
  protected void processSingleSection(HWPFDocument wordDocument, Section section) {
    htmlDocumentFacade.addStyleClass(htmlDocumentFacade.body, "b", getSectionStyle(section));

    processParagraphes(wordDocument, htmlDocumentFacade.body, section, Integer.MIN_VALUE);
  }
コード例 #6
0
  protected void processParagraph(
      HWPFDocument hwpfDocument,
      Element parentElement,
      int currentTableLevel,
      Paragraph paragraph,
      String bulletText) {
    final Element pElement = htmlDocumentFacade.createParagraph();
    parentElement.appendChild(pElement);
    /*if(itemSymbol)
    System.out.println(itemSymbol);*/
    if (itemSymbol) {
      Element span = htmlDocumentFacade.getDocument().createElement("span");
      htmlDocumentFacade.addStyleClass(
          span,
          "itemSymbol",
          "font-size:12.0pt;line-height:150%;font-family:Wingdings;mso-ascii-font-family:Wingdings;mso-hide:none;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN;font-weight:normal;mso-bidi-font-weight:normal;font-style:normal;mso-bidi-font-style:normal;text-underline:windowtext none;text-decoration:none;background:transparent");
      span.setTextContent("Ø");
      pElement.appendChild(span);
      itemSymbol = false;
    }

    StringBuilder style = new StringBuilder();
    WordToHtmlUtils.addParagraphProperties(paragraph, style);

    final int charRuns = paragraph.numCharacterRuns();
    if (charRuns == 0) {
      return;
    }

    {
      final String pFontName;
      final int pFontSize;
      final CharacterRun characterRun = paragraph.getCharacterRun(0);
      if ("".equals(paragraph.text().trim())) {
        pElement.setTextContent(String.valueOf(UNICODECHAR_NO_BREAK_SPACE));
      }
      if (characterRun != null) {
        Triplet triplet = getCharacterRunTriplet(characterRun);
        pFontSize = characterRun.getFontSize() / 2;
        pFontName = triplet.fontName;
        WordToHtmlUtils.addFontFamily(pFontName, style);
        WordToHtmlUtils.addFontSize(pFontSize, style);
      } else {
        pFontSize = -1;
        pFontName = WordToHtmlUtils.EMPTY;
      }
      blocksProperies.push(new BlockProperies(pFontName, pFontSize));
    }
    try {
      if (WordToHtmlUtils.isNotEmpty(bulletText)) {
        if (bulletText.endsWith("\t")) {
          /*
           * We don't know how to handle all cases in HTML, but at
           * least simplest case shall be handled
           */
          final float defaultTab = TWIPS_PER_INCH / 2;
          float firstLinePosition =
              paragraph.getIndentFromLeft() + paragraph.getFirstLineIndent() + 20; // char have
          // some space

          float nextStop = (float) (Math.ceil(firstLinePosition / defaultTab) * defaultTab);

          final float spanMinWidth = nextStop - firstLinePosition;

          Element span = htmlDocumentFacade.getDocument().createElement("span");
          htmlDocumentFacade.addStyleClass(
              span,
              "s",
              "display: inline-block; text-indent: 0; min-width: "
                  + (spanMinWidth / TWIPS_PER_INCH)
                  + "in;");
          pElement.appendChild(span);

          Text textNode =
              htmlDocumentFacade.createText(
                  bulletText.substring(0, bulletText.length() - 1)
                      + UNICODECHAR_ZERO_WIDTH_SPACE
                      + UNICODECHAR_NO_BREAK_SPACE);
          span.appendChild(textNode);
        } else {
          Text textNode =
              htmlDocumentFacade.createText(bulletText.substring(0, bulletText.length() - 1));
          pElement.appendChild(textNode);
        }
      }

      processCharacters(hwpfDocument, currentTableLevel, paragraph, pElement);
    } finally {
      blocksProperies.pop();
    }

    if (style.length() > 0) htmlDocumentFacade.addStyleClass(pElement, "p", style.toString());

    WordToHtmlUtils.compactSpans(pElement);
    return;
  }
コード例 #7
0
  @SuppressWarnings("deprecation")
  protected void processImage(
      Element currentBlock, boolean inlined, Picture picture, String imageSourcePath) {
    final int aspectRatioX = picture.getHorizontalScalingFactor();
    final int aspectRatioY = picture.getVerticalScalingFactor();

    StringBuilder style = new StringBuilder();

    final float imageWidth;
    final float imageHeight;

    final float cropTop;
    final float cropBottom;
    final float cropLeft;
    final float cropRight;

    if (aspectRatioX > 0) {
      imageWidth = picture.getDxaGoal() * aspectRatioX / 1000 / TWIPS_PER_INCH;
      cropRight = picture.getDxaCropRight() * aspectRatioX / 1000 / TWIPS_PER_INCH;
      cropLeft = picture.getDxaCropLeft() * aspectRatioX / 1000 / TWIPS_PER_INCH;
    } else {
      imageWidth = picture.getDxaGoal() / TWIPS_PER_INCH;
      cropRight = picture.getDxaCropRight() / TWIPS_PER_INCH;
      cropLeft = picture.getDxaCropLeft() / TWIPS_PER_INCH;
    }

    if (aspectRatioY > 0) {
      imageHeight = picture.getDyaGoal() * aspectRatioY / 1000 / TWIPS_PER_INCH;
      cropTop = picture.getDyaCropTop() * aspectRatioY / 1000 / TWIPS_PER_INCH;
      cropBottom = picture.getDyaCropBottom() * aspectRatioY / 1000 / TWIPS_PER_INCH;
    } else {
      imageHeight = picture.getDyaGoal() / TWIPS_PER_INCH;
      cropTop = picture.getDyaCropTop() / TWIPS_PER_INCH;
      cropBottom = picture.getDyaCropBottom() / TWIPS_PER_INCH;
    }

    Element root;
    if (cropTop != 0 || cropRight != 0 || cropBottom != 0 || cropLeft != 0) {
      float visibleWidth = Math.max(0, imageWidth - cropLeft - cropRight);
      float visibleHeight = Math.max(0, imageHeight - cropTop - cropBottom);

      root = htmlDocumentFacade.createBlock();
      htmlDocumentFacade.addStyleClass(
          root,
          "d",
          "vertical-align:text-bottom;width:"
              + visibleWidth
              + "in;height:"
              + visibleHeight
              + "in;");

      // complex
      Element inner = htmlDocumentFacade.createBlock();
      htmlDocumentFacade.addStyleClass(
          inner,
          "d",
          "position:relative;width:"
              + visibleWidth
              + "in;height:"
              + visibleHeight
              + "in;overflow:hidden;");
      root.appendChild(inner);

      Element image = htmlDocumentFacade.createImage(imageSourcePath);
      htmlDocumentFacade.addStyleClass(
          image,
          "i",
          "position:absolute;left:-"
              + cropLeft
              + ";top:-"
              + cropTop
              + ";width:"
              + imageWidth
              + "in;height:"
              + imageHeight
              + "in;");
      inner.appendChild(image);

      style.append("overflow:hidden;");
    } else {
      root = htmlDocumentFacade.createImage(imageSourcePath);
      root.setAttribute(
          "style",
          "width:" + imageWidth + "in;height:" + imageHeight + "in;vertical-align:text-bottom;");
    }

    currentBlock.appendChild(root);
  }