Cell.java

  1. /*
  2.  * Copyright 2012 The Apache Software Foundation.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.odftoolkit.odfdom.changes;

  18. import static org.odftoolkit.odfdom.changes.JsonOperationConsumer.addParagraph;
  19. import static org.odftoolkit.odfdom.changes.JsonOperationConsumer.addStyle;
  20. import static org.odftoolkit.odfdom.changes.JsonOperationConsumer.addText;
  21. import static org.odftoolkit.odfdom.changes.OperationConstants.OPK_STYLE_ID;

  23. import java.util.logging.Level;
  24. import java.util.logging.Logger;
  25. import org.json.JSONException;
  26. import org.json.JSONObject;
  27. import org.odftoolkit.odfdom.dom.OdfDocumentNamespace;
  28. import org.odftoolkit.odfdom.dom.element.number.DataStyleElement;
  29. import org.odftoolkit.odfdom.dom.element.number.NumberBooleanStyleElement;
  30. import org.odftoolkit.odfdom.dom.element.number.NumberTextStyleElement;
  31. import org.odftoolkit.odfdom.dom.element.table.TableTableCellElement;
  32. import org.odftoolkit.odfdom.dom.element.text.TextAElement;
  33. import org.odftoolkit.odfdom.dom.element.text.TextPElement;
  34. import org.odftoolkit.odfdom.dom.element.text.TextParagraphElementBase;
  35. import org.odftoolkit.odfdom.dom.style.props.OdfStylePropertiesSet;
  36. import org.odftoolkit.odfdom.incubator.doc.number.OdfNumberCurrencyStyle;
  37. import org.odftoolkit.odfdom.incubator.doc.number.OdfNumberDateStyle;
  38. import org.odftoolkit.odfdom.incubator.doc.number.OdfNumberPercentageStyle;
  39. import org.odftoolkit.odfdom.incubator.doc.number.OdfNumberStyle;
  40. import org.odftoolkit.odfdom.incubator.doc.number.OdfNumberTimeStyle;
  41. import org.odftoolkit.odfdom.incubator.doc.style.OdfStyle;
  42. import org.odftoolkit.odfdom.pkg.OdfElement;
  43. import org.odftoolkit.odfdom.pkg.OdfFileDom;
  44. import org.w3c.dom.Node;
  45. import org.w3c.dom.NodeList;

  47. /**
  48.  * A MultiCoomponent uses a single XML element to represent multiple components. This container can
  49.  * be used for spreadsheet row and cell components using repeated elements via an attribute.
  50.  *
  51.  * @author svante.schubertATgmail.com
  52.  * @param <T>
  53.  */
  54. class Cell<T> extends Component {

  56.   private static final String FORMULA_PREFIX = "of:";

  58.   public Cell(OdfElement componentElement, Component parent) {
  59.     super(componentElement, parent);
  60.   }

  62.   /**
  63.    * A multiple components can be represented by a single XML element
  64.    *
  65.    * @return the number of components the elements represents
  66.    */
  67.   @Override
  68.   public int repetition() {
  69.     return mRootElement.getRepetition();
  70.   }

  72.   // CELL ONLY
  73.   //    Map<String, Object> mInnerCellStyle = null;
  74.   //
  75.   //    /** The inner style of a cell will be temporary saved at the cell.
  76.   //     Whenever the cell content is deleted, the style is being merged/applied to the cell style */
  77.   //    public Map<String, Object> getInternalCellStyle(){
  78.   //        return mInnerCellStyle;
  79.   //    }
  80.   //
  81.   //
  82.   //    /** The inner style of a cell will be temporary saved at the cell.
  83.   //     Whenever the cell content is deleted, the style is being merged/applied to the cell style */
  84.   //    public void setInternalCellStyle(Map<String, Object> newStyles){
  85.   //        mInnerCellStyle = newStyles;
  86.   //    }
  87.   //
  88.   /** Adds the given component to the root element */
  89.   @Override
  90.   public void addChild(int index, Component c) {
  91.     mRootElement.insert(c.getRootElement(), index);
  92.     // 2DO: Svante: ARE THE ABOVE AND THE BELOW EQUIVALENT?
  93.     //      OdfElement rootElement = c.getRootElement();
  94.     //      if (index >= 0) {
  95.     //          mRootElement.insertBefore(rootElement, ((OdfElement) mRootElement).receiveNode(index));
  96.     //      } else {
  97.     //          mRootElement.appendChild(rootElement);
  98.     //      }
  99.   }

  101.   /** @return either a text node of size 1 or an element being the root element of a component */
  102.   @Override
  103.   public Node getChildNode(int index) {
  104.     return mRootElement.receiveNode(index);
  105.   }

  107.   /**
  108.    * Removes a component from the text element container. Removes either an element representing a
  109.    * component or text node of size 1
  110.    */
  111.   @Override
  112.   public Node remove(int index) {
  113.     Node removedNode = null;
  114.     Node node = this.getChildNode(index);
  115.     if (node != null) {
  116.       removedNode = mRootElement.removeChild(node);
  117.     }
  118.     return removedNode;
  119.   }

  121.   /**
  122.    * All children of the root element will be traversed. If it is a text node the size is added, if
  123.    * it is an element and a component a size of one is added, if it is a marker, for known text
  124.    * marker elements (text:span, text:bookmark) the children are recursive checked
  125.    *
  126.    * @return the number of child components
  127.    */
  128.   @Override
  129.   public int size() {
  130.     return mRootElement.componentSize();
  131.   }

  133.   private static final String FLOAT = "float";
  134.   private static final String STRING = "string";
  135.   private static final String CURRENCY = "currency";
  136.   private static final String DATE = "date";
  137.   private static final String TIME = "time";
  138.   private static final String PERCENTAGE = "percentage";
  139.   private static final String BOOLEAN = "boolean";

  141.   /**
  142.    * Adding cell content: either as formula or paragraph and text content, latter with default
  143.    * styles
  144.    */
  145.   public TableTableCellElement addCellStyleAndContent(
  146.       Component rootComponent, Object value, JSONObject attrs) {
  147.     // see if the cell is repeated
  148.     TableTableCellElement cell = (TableTableCellElement) this.getRootElement();
  149.     OdfFileDom ownerDoc = (OdfFileDom) rootComponent.getOwnerDocument();
  150.     // save the URL as everyting else will be deleted
  151.     String url = reuseCellHyperlink(cell, attrs);
  152.     boolean setValueType = true;
  153.     boolean isNumberValue = true;
  154.     // exchanges the content if requested
  155.     if (value != null) {
  156.       cell.removeContent();
  157.       // if there is new content..
  158.       if (!value.equals(JSONObject.NULL)) {
  159.         String valueString = value.toString();
  160.         if (valueString.startsWith(Constants.EQUATION)) {
  161.           // How am I able to set the other values? What is the OOXML solution for this?
  162.           cell.setAttributeNS(OdfDocumentNamespace.OFFICE.getUri(), "office:value-type", FLOAT);
  163.           cell.setAttributeNS(
  164.               OdfDocumentNamespace.TABLE.getUri(),
  165.               "table:formula",
  166.               FORMULA_PREFIX.concat(valueString));
  167.         } else {
  168.           // insert a paragraph to store the text within..
  169.           TextParagraphElementBase newParagraph = addParagraph(this, 0, attrs);
  170.           if (url != null) {
  171.             attrs = addUrlToCharacterProps(attrs, url);
  172.           }
  173.           // if the formula was masked
  174.           if (value instanceof String
  175.               && valueString.startsWith(Constants.APOSTROPHE_AND_EQUATION)) {
  176.             // cut the first apostrophe
  177.             valueString = valueString.substring(1);
  178.           }
  179.           // addChild the text & removes existing values
  180.           addText(newParagraph, 0, attrs, valueString);
  181.           if (value instanceof Integer || value instanceof Double || value instanceof Float) {
  182.             isNumberValue = true;
  183.             cell.setAttributeNS(OdfDocumentNamespace.OFFICE.getUri(), "office:value", valueString);
  184.           } else if (value instanceof String) {
  185.             cell.setAttributeNS(OdfDocumentNamespace.OFFICE.getUri(), "office:value-type", STRING);
  186.             setValueType = false;
  187.           }
  188.         }
  189.       }
  190.     }
  191.     if (attrs != null) {
  192.       // Format: Adding Styles to the element
  193.       addStyle(attrs, cell, ownerDoc);
  194.       if (cell.hasChildNodes()) {
  195.         NodeList children = cell.getChildNodes();
  196.         for (int i = 0; i < children.getLength(); i++) {
  197.           Node child = children.item(i);
  198.           if (child instanceof OdfElement) {
  199.             ((OdfElement) child).markText(0, Integer.MAX_VALUE - 1, attrs);
  200.           }
  201.         }
  202.       } else {
  203.         if (url != null) {
  204.           TextPElement containerElement1 = new TextPElement(ownerDoc);
  205.           TextAElement containerElement2 = new TextAElement(ownerDoc);
  206.           containerElement2.setXlinkHrefAttribute(url);
  207.           cell.appendChild(containerElement1);
  208.           containerElement1.appendChild(containerElement2);
  209.         }
  210.       }
  211.     }
  212.     // value-type has to be set if
  213.     // - a number is set replacing a previous string-type
  214.     // - if a number is changed to a string (already done above ) or vice-versa
  215.     // - if attributes have been set (that contain a number format or a new style)
  216.     //
  217.     if (setValueType) {
  218.       String currentValueType = cell.getOfficeValueTypeAttribute();
  219.       boolean isStringType = currentValueType != null && currentValueType.equals("String");
  220.       boolean changedToNumber = isNumberValue && isStringType;
  221.       boolean numberFormatChanged = false;
  222.       if (attrs != null) {
  223.         JSONObject cellAttrs = attrs.optJSONObject("cell");
  224.         if (cellAttrs != null) {
  225.           numberFormatChanged = cellAttrs.has("formatCode");
  226.         }
  227.         if (!numberFormatChanged) {
  228.           String styleId = attrs.optString(OPK_STYLE_ID);
  229.           numberFormatChanged = styleId != null;
  230.         }
  231.       }
  232.       if (currentValueType == null || changedToNumber || numberFormatChanged) {
  233.         DataStyleElement dataStyle = cell.getOwnDataStyle();
  234.         if (dataStyle != null) {
  235.           String valueType = "";
  236.           String currencySymbol = "";
  237.           if (dataStyle instanceof OdfNumberStyle) {
  238.             valueType = FLOAT;
  239.           } else if (dataStyle instanceof OdfNumberCurrencyStyle) {
  240.             currencySymbol =
  241.                 ((OdfNumberCurrencyStyle) dataStyle).getCurrencySymbolElement().getTextContent();
  242.             valueType = CURRENCY;
  243.           } else if (dataStyle instanceof NumberTextStyleElement) {
  244.             valueType = STRING;
  245.           } else if (dataStyle instanceof OdfNumberDateStyle) {
  246.             valueType = DATE;
  247.           } else if (dataStyle instanceof OdfNumberTimeStyle) {
  248.             valueType = TIME;
  249.           } else if (dataStyle instanceof OdfNumberPercentageStyle) {
  250.             valueType = PERCENTAGE;
  251.           } else if (dataStyle instanceof NumberBooleanStyleElement) {
  252.             valueType = BOOLEAN;
  253.           }
  254.           if (!valueType.isEmpty()) {
  255.             cell.setOfficeValueTypeAttribute(valueType);
  256.             cell.setCalcextValueTypeAttribute(valueType);
  257.             cell.setOfficeCurrencyAttribute(currencySymbol);
  258.             // make sure that an appropriate value is available:
  259.             if (value == null && cell.getOfficeValueAttribute() == null) {
  260.               String oldDateValue = cell.getOfficeDateValueAttribute();
  261.               String oldTimeValue = cell.getOfficeTimeValueAttribute();
  262.               Boolean oldBooleanValue = cell.getOfficeBooleanValueAttribute();
  263.               Double newValue = null;
  264.               if (oldDateValue != null) {
  265.                 newValue = new Double(MapHelper.dateToDouble(oldDateValue));
  266.               } else if (oldTimeValue != null) {
  267.                 newValue = new Double(MapHelper.timeToDouble(oldTimeValue));
  268.               } else if (oldBooleanValue != null) {
  269.                 newValue = new Double(oldBooleanValue.booleanValue() ? 1 : 0);
  270.               }

  272.               if (newValue != null) {
  273.                 cell.setOfficeValueAttribute(newValue);
  274.               }
  275.             }
  276.           }
  277.         }
  278.       }
  279.     }
  280.     return cell;
  281.   }

  283.   /**
  284.    * To be able to reuse existing style on the full table, new cell hyperlinks will be stored in the
  285.    * cell text style properties as @xlink:href attribute and taken back when nothing new is set.
  286.    */
  287.   private static String reuseCellHyperlink(TableTableCellElement cell, JSONObject attrs) {
  288.     String cellURL = null;
  289.     if (attrs != null) { // apply style changes to the cell
  290.       // apply new styles to the cell (modifying not overwriting)
  291.       if (attrs.has("character")) {
  292.         JSONObject charProps = attrs.optJSONObject("character");
  293.         if (charProps != null) {
  294.           if (charProps.has("url") && !charProps.get("url").equals(JSONObject.NULL)) {
  295.             cellURL = charProps.optString("url");
  296.           } else if (charProps.has("url")) {
  297.             // removeAnchors();
  298.           }
  299.         }
  300.       }
  301.     }
  302.     // if there is no new hyperlink given, check for an existing cached (in the properties)
  303.     if (cellURL == null || cellURL.isEmpty()) {
  304.       // check if there is still one given at the cell
  305.       OdfStyle autoStyle = cell.getAutomaticStyle();
  306.       if (autoStyle != null) {
  307.         OdfElement textProps = autoStyle.getPropertiesElement(OdfStylePropertiesSet.TextProperties);
  308.         if (textProps != null
  309.             && textProps.hasAttributeNS(OdfDocumentNamespace.XLINK.getUri(), "href")) {
  310.           cellURL = textProps.getAttributeNS(OdfDocumentNamespace.XLINK.getUri(), "href");
  311.         }
  312.       }
  313.     }
  314.     return cellURL;
  315.   }

  317.   private static JSONObject addUrlToCharacterProps(JSONObject attrs, String cellURL) {
  318.     JSONObject charProps = null;
  319.     if (cellURL != null && !cellURL.isEmpty()) {
  320.       if (attrs == null) {
  321.         attrs = new JSONObject();
  322.       }
  323.       if (!attrs.has("character")) {
  324.         charProps = new JSONObject();
  325.         try {
  326.           attrs.put("character", charProps);
  327.         } catch (JSONException ex) {
  328.           Logger.getLogger(JsonOperationConsumer.class.getName()).log(Level.SEVERE, null, ex);
  329.         }
  330.       } else {
  331.         charProps = attrs.optJSONObject("character");
  332.       }
  333.       try {
  334.         charProps.put("url", cellURL);
  335.       } catch (JSONException ex) {
  336.         Logger.getLogger(JsonOperationConsumer.class.getName()).log(Level.SEVERE, null, ex);
  337.       }
  338.     }
  339.     return attrs;
  340.   }
  341. }
Created with JaCoCo 0.8.7.202105040129