/************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
*
* Copyright 2008, 2010 Oracle and/or its affiliates. All rights reserved.
*
* Use is subject to license terms.
*
* Licensed 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. You can also
* obtain a copy of the License at http://odftoolkit.org/docs/license.txt
*
* 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.
*
************************************************************************/
package org.odftoolkit.odfdom.incubator.meta;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import org.odftoolkit.odfdom.dom.element.dc.DcCreatorElement;
import org.odftoolkit.odfdom.dom.element.dc.DcDateElement;
import org.odftoolkit.odfdom.dom.element.dc.DcDescriptionElement;
import org.odftoolkit.odfdom.dom.element.dc.DcLanguageElement;
import org.odftoolkit.odfdom.dom.element.dc.DcSubjectElement;
import org.odftoolkit.odfdom.dom.element.dc.DcTitleElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaAutoReloadElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaCreationDateElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaDocumentStatisticElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaEditingCyclesElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaEditingDurationElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaGeneratorElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaHyperlinkBehaviourElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaInitialCreatorElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaKeywordElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaPrintDateElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaPrintedByElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaTemplateElement;
import org.odftoolkit.odfdom.dom.element.meta.MetaUserDefinedElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeDocumentMetaElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeMetaElement;
import org.odftoolkit.odfdom.pkg.OdfElement;
import org.odftoolkit.odfdom.pkg.OdfFileDom;
import org.odftoolkit.odfdom.type.Duration;
/**
* <code>OdfOfficeMeta</code> represent the meta data feature in the ODF document.
* <p>
* It provides convenient method to get meta data info.
*
* @deprecated As of release 0.8.8, replaced by {@link org.odftoolkit.simple.meta.Meta} in Simple API.
*/
public class OdfOfficeMeta {
private OfficeMetaElement mOfficeMetaElement;
private boolean mAutomaticUpdate = true;
/**
* Constructor of <code>OdfOfficeMeta</code> feature.
*
* @param metaDom the file DOM element of meta.xml
*/
public OdfOfficeMeta(OdfFileDom metaDom) {
OfficeDocumentMetaElement metaEle = OdfElement.findFirstChildNode(OfficeDocumentMetaElement.class, metaDom);
mOfficeMetaElement = OdfElement.findFirstChildNode(OfficeMetaElement.class, metaEle);
}
/**
* Get the instance of <code>OfficeMetaElement</code> which represents this feature.
*
* @return the instance of OfficeMetaElement
*/
public OfficeMetaElement getOfficeMetaElement() {
return mOfficeMetaElement;
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaGeneratorElement</code> , See {@odf.element
* meta:generator}.
*
* @return the generator info of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getGenerator() {
MetaGeneratorElement metaGenerator = OdfElement.findFirstChildNode(
MetaGeneratorElement.class, mOfficeMetaElement);
if (metaGenerator != null) {
return metaGenerator.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaGeneratorElement</code> , See {@odf.element
* meta:generator}.
*
* @param generator set the specified document generator. NULL will remove the element from the meta.xml.
*/
public void setGenerator(String generator) {
MetaGeneratorElement metaGeneratorEle = OdfElement.findFirstChildNode(
MetaGeneratorElement.class, mOfficeMetaElement);
if (generator == null) {
if (metaGeneratorEle != null) {
mOfficeMetaElement.removeChild(metaGeneratorEle);
}
} else {
if (metaGeneratorEle == null) {
metaGeneratorEle = mOfficeMetaElement.newMetaGeneratorElement();
}
metaGeneratorEle.setTextContent(generator);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcTitleElement</code> , See {@odf.element dc:title}.
*
* @return the title of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getTitle() {
DcTitleElement titleEle = OdfElement.findFirstChildNode(
DcTitleElement.class, mOfficeMetaElement);
if (titleEle != null) {
return titleEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcTitleElement</code> , See {@odf.element dc:title}.
*
* @param title set the specified document title. NULL will remove the element from the meta.xml.
*/
public void setTitle(String title) {
DcTitleElement titleEle = OdfElement.findFirstChildNode(
DcTitleElement.class, mOfficeMetaElement);
if (title == null) {
if (titleEle != null) {
mOfficeMetaElement.removeChild(titleEle);
}
} else {
if (titleEle == null) {
titleEle = mOfficeMetaElement.newDcTitleElement();
}
titleEle.setTextContent(title);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcDescriptionElement</code> , See {@odf.element
* dc:description}.
*
* @return the description of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getDescription() {
DcDescriptionElement descEle = OdfElement.findFirstChildNode(
DcDescriptionElement.class, mOfficeMetaElement);
if (descEle != null) {
return descEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcDescriptionElement</code> , See {@odf.element
* dc:description}.
*
* @param description set the specified document description. NULL will remove the element from the meta.xml.
*/
public void setDescription(String description) {
DcDescriptionElement descEle = OdfElement.findFirstChildNode(
DcDescriptionElement.class, mOfficeMetaElement);
if (description == null) {
if (descEle != null) {
mOfficeMetaElement.removeChild(descEle);
}
} else {
if (descEle == null) {
descEle = mOfficeMetaElement.newDcDescriptionElement();
}
descEle.setTextContent(description);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcSubjectElement</code> , See {@odf.element
* dc:subject}.
*
* @return the subject of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getSubject() {
DcSubjectElement subjectEle = OdfElement.findFirstChildNode(
DcSubjectElement.class, mOfficeMetaElement);
if (subjectEle != null) {
return subjectEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcSubjectElement</code> , See {@odf.element
* dc:subject}.
*
* @param subject set the specified document subject. NULL will remove the element from the meta.xml.
*/
public void setSubject(String subject) {
DcSubjectElement subjectEle = OdfElement.findFirstChildNode(
DcSubjectElement.class, mOfficeMetaElement);
if (subject == null) {
if (subjectEle != null) {
mOfficeMetaElement.removeChild(subjectEle);
}
} else {
if (subjectEle == null) {
subjectEle = mOfficeMetaElement.newDcSubjectElement();
}
subjectEle.setTextContent(subject);
}
}
/**
* Receives the list value of the ODFDOM element representation
* <code>MetaKeywordElement</code> , See {@odf.element
* meta:keyword}.
*
* @return the keywords of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public List<String> getKeywords() {
List<String> keywords = new ArrayList<String>();
MetaKeywordElement keywordEle = OdfElement.findFirstChildNode(
MetaKeywordElement.class, mOfficeMetaElement);
if (keywordEle != null) {
keywords.add(keywordEle.getTextContent());
MetaKeywordElement keywordNext;
while ((keywordNext = OdfElement.findNextChildNode(
MetaKeywordElement.class, keywordEle)) != null) {
keywords.add(keywordNext.getTextContent());
keywordEle = keywordNext;
}
return keywords;
} else {
return null;
}
}
/**
* Sets the list value of the ODFDOM element representation
* <code>MetaKeywordElement</code> , See {@odf.element
* meta:keyword}.
*
* @param keyList set the specified list of keywords
*/
public void setKeywords(List<String> keyList) {
MetaKeywordElement keywordEle = OdfElement.findFirstChildNode(
MetaKeywordElement.class, mOfficeMetaElement);
List<MetaKeywordElement> toBeDeleted = new ArrayList<MetaKeywordElement>();
if (keywordEle != null) {
MetaKeywordElement keywordTmp;
toBeDeleted.add(keywordEle);
while ((keywordTmp = OdfElement.findNextChildNode(
MetaKeywordElement.class, keywordEle)) != null) {
keywordEle = keywordTmp;
toBeDeleted.add(keywordTmp);
}
}
// remove the original
for (MetaKeywordElement keyele : toBeDeleted) {
mOfficeMetaElement.removeChild(keyele);
}
// add new
for (int i = 0; i < keyList.size(); i++) {
MetaKeywordElement keywordElement = mOfficeMetaElement.newMetaKeywordElement();
keywordElement.setTextContent(keyList.get(i));
}
}
/**
* Add the keyword to the current document.
* Create child element {@odf.element meta:keyword}.
*
* @param keyword the value of child element {@odf.element
* meta:keyword}.
*/
public void addKeyword(String keyword) {
MetaKeywordElement keywordElement = mOfficeMetaElement.newMetaKeywordElement();
keywordElement.setTextContent(keyword);
}
/**
* Receives the list value of the ODFDOM element representation
* <code>MetaUserDefinedElement</code> , See {@odf.element
* meta:user-defined}.
*
* @return get the list of user-defined metadata names;
* <p>
* <code>null</code>, if the element is not set.
*/
public List<String> getUserDefinedDataNames() {
List<String> definedNames = new ArrayList<String>();
MetaUserDefinedElement definedEle = OdfElement.findFirstChildNode(
MetaUserDefinedElement.class, mOfficeMetaElement);
if (definedEle != null) {
definedNames.add(definedEle.getMetaNameAttribute());
MetaUserDefinedElement definedNext;
while ((definedNext = OdfElement.findNextChildNode(
MetaUserDefinedElement.class, definedEle)) != null) {
definedNames.add(definedNext.getMetaNameAttribute());
definedEle = definedNext;
}
return definedNames;
} else {
return null;
}
}
/**
* Receives the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name of the user-defined metadata
* @return the <code>MetaUserDefinedElement</code> which is identified by the specified name;
* <p>
* <code>null</code>, if the element is not set.
*/
public MetaUserDefinedElement getUserDefinedElementByAttributeName(
String name) {
MetaUserDefinedElement definedEle = OdfElement.findFirstChildNode(
MetaUserDefinedElement.class, mOfficeMetaElement);
if (definedEle != null) {
if (definedEle.getMetaNameAttribute().equals(name)) {
return definedEle;
}
MetaUserDefinedElement definedNext;
while ((definedNext = OdfElement.findNextChildNode(
MetaUserDefinedElement.class, definedEle)) != null) {
if (definedNext.getMetaNameAttribute().equals(name)) {
return definedNext;
}
definedEle = definedNext;
}
return null;
} else {
return null;
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name of the user-defined metadata
* @return the value of the user-defined metadata with the specified name;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getUserDefinedDataValue(String name) {
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
if (definedElement != null) {
return definedElement.getTextContent();
}
return null;
}
/**
* Receives the data type of the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name of the user-defined metadata
* @return the data type of the user-defined metadata with the specified name;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getUserDefinedDataType(String name) {
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
if (definedElement != null) {
return definedElement.getMetaValueTypeAttribute();
}
return null;
}
/**
* Remove the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name of the user-defined metadata
*/
public void removeUserDefinedDataByName(String name) {
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
if (definedElement != null) {
mOfficeMetaElement.removeChild(definedElement);
}
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name need to set for the user-defined metadata
* @param value the value need to set for the user-defined metadata
*/
public void setUserDefinedDataValue(String name, String value) {
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
if (definedElement != null) {
definedElement.setTextContent(value);
}
}
/**
* Sets the data type of the ODFDOM element representation
* <code>MetaUserDefinedElement</code> by attribute name, See {@odf.element
* meta:user-defined}.
*
* @param name the name need to set for the user-defined metadata
* @param value the value need to set for the user-defined metadata
*/
public void setUserDefinedDataType(String name, String value) {
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
if (definedElement != null) {
definedElement.setMetaValueTypeAttribute(value);
}
}
/**
* Sets the ODFDOM element representation
* <code>MetaUserDefinedElement</code> , See {@odf.element
* meta:user-defined} if the element with the attribute name exists,then
* update;or create a new element if type or value is null,the original will
* not be updated.
*
* @param name the name need to set for the user-defined metadata
* @param type the data type need to set for the user-defined metadata
* @param value the value need to set for the user-defined metadata
*/
public void setUserDefinedData(String name, String type, String value) {
// test if name exists
MetaUserDefinedElement definedElement = getUserDefinedElementByAttributeName(name);
// if exists, then update,if parameter is null, then don't change
if (definedElement != null) {
if (type != null) {
definedElement.setMetaValueTypeAttribute(type);
}
if (value != null) {
definedElement.setTextContent(value);
}
} else {
// if not exists, add
definedElement = mOfficeMetaElement.newMetaUserDefinedElement(name,
type);
definedElement.setTextContent(value);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaInitialCreatorElement</code> , See {@odf.element
* meta:initial-creator}.
*
* @return get the initial creator of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getInitialCreator() {
MetaInitialCreatorElement iniCreatorEle = OdfElement.findFirstChildNode(MetaInitialCreatorElement.class,
mOfficeMetaElement);
if (iniCreatorEle != null) {
return iniCreatorEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaInitialCreatorElement</code> , See {@odf.element
* meta:initial-creator}.
*
* @param initialCreator set the specified initial creator. NULL will remove the element from the meta.xml.
*/
public void setInitialCreator(String initialCreator) {
MetaInitialCreatorElement initialCreatorEle = OdfElement.findFirstChildNode(MetaInitialCreatorElement.class,
mOfficeMetaElement);
if (initialCreator == null) {
if (initialCreatorEle != null) {
mOfficeMetaElement.removeChild(initialCreatorEle);
}
} else {
if (initialCreatorEle == null) {
initialCreatorEle = mOfficeMetaElement.newMetaInitialCreatorElement();
}
initialCreatorEle.setTextContent(initialCreator);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcCreatorElement</code> , See {@odf.element
* dc:creator}
*
* @return the creator of the current document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getCreator() {
DcCreatorElement creatorEle = OdfElement.findFirstChildNode(
DcCreatorElement.class, mOfficeMetaElement);
if (creatorEle != null) {
return creatorEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcCreatorElement</code> , See {@odf.element
* dc:creator}.
*
* @param creator set the specified creator. NULL will remove the element from the meta.xml.
*/
public void setCreator(String creator) {
DcCreatorElement creatorEle = OdfElement.findFirstChildNode(
DcCreatorElement.class, mOfficeMetaElement);
if (creator == null) {
if (creatorEle != null) {
mOfficeMetaElement.removeChild(creatorEle);
}
} else {
if (creatorEle == null) {
creatorEle = mOfficeMetaElement.newDcCreatorElement();
}
creatorEle.setTextContent(creator);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaPrintedByElement</code> , See {@odf.element
* meta:printed-by}
*
* @return the name of the last person who printed the current document;
* <p>
* <code>null</code>, if element is not set
*/
public String getPrintedBy() {
MetaPrintedByElement printedByEle = OdfElement.findFirstChildNode(
MetaPrintedByElement.class, mOfficeMetaElement);
if (printedByEle != null) {
return printedByEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaPrintedByElement</code> , See {@odf.element
* meta:printed-by}.
*
* @param printedBy the name need to set for the last person who printed the current document. NULL will remove the element from the meta.xml.
*/
public void setPrintedBy(String printedBy) {
MetaPrintedByElement printedByEle = OdfElement.findFirstChildNode(
MetaPrintedByElement.class, mOfficeMetaElement);
if (printedBy == null) {
if (printedByEle != null) {
mOfficeMetaElement.removeChild(printedByEle);
}
} else {
if (printedByEle == null) {
printedByEle = mOfficeMetaElement.newMetaPrintedByElement();
}
printedByEle.setTextContent(printedBy);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaCreationDateElement</code> , See {@odf.element
* meta:creation-date}
*
* @return the date and time when the document was created initially;
* <p>
* <code>null</code>, if element is not set
*/
public Calendar getCreationDate() {
MetaCreationDateElement creationDateEle = OdfElement.findFirstChildNode(MetaCreationDateElement.class,
mOfficeMetaElement);
if (creationDateEle != null) {
return stringToCalendar(creationDateEle.getTextContent());
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaCreationDateElement</code> , See {@odf.element
* meta:creation-date}.
*
* @param creationDate the date and time need to set. NULL will remove the element from the meta.xml.
*/
public void setCreationDate(Calendar creationDate) {
MetaCreationDateElement creationDateEle = OdfElement.findFirstChildNode(MetaCreationDateElement.class,
mOfficeMetaElement);
if (creationDate == null) {
if (creationDateEle != null) {
mOfficeMetaElement.removeChild(creationDateEle);
}
} else {
if (creationDateEle == null) {
creationDateEle = mOfficeMetaElement.newMetaCreationDateElement();
}
creationDateEle.setTextContent(calendarToString(creationDate));
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcDateElement</code> , See {@odf.element dc:date}.
*
* @return the date and time when the document was last modified;
* <p>
* <code>null</code>, if the element is not set.
*/
public Calendar getDate() {
DcDateElement dcDateEle = OdfElement.findFirstChildNode(
DcDateElement.class, mOfficeMetaElement);
if (dcDateEle != null) {
return stringToCalendar(dcDateEle.getTextContent());
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcDateElement</code> , See {@odf.element dc:date}.
*
* @param date the date and time need to set. NULL will remove the element from the meta.xml.
*/
public void setDate(Calendar date) {
DcDateElement dcDateEle = OdfElement.findFirstChildNode(
DcDateElement.class, mOfficeMetaElement);
if (date == null) {
if (dcDateEle != null) {
mOfficeMetaElement.removeChild(dcDateEle);
}
} else {
if (dcDateEle == null) {
dcDateEle = mOfficeMetaElement.newDcDateElement();
}
dcDateEle.setTextContent(calendarToString(date));
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaPrintDateElement</code> , See {@odf.element
* meta:print-date}.
*
* @return the date and time when the document was last printed;
* <p>
* <code>null</code>, if the element is not set.
*/
public Calendar getPrintDate() {
MetaPrintDateElement printDateEle = OdfElement.findFirstChildNode(
MetaPrintDateElement.class, mOfficeMetaElement);
if (printDateEle != null) {
return stringToCalendar(printDateEle.getTextContent());
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaPrintDateElement</code> , See {@odf.element
* meta:print-date}.
*
* @param printDate the date and time need to set. NULL will remove the element from the meta.xml.
*/
public void setPrintDate(Calendar printDate) {
MetaPrintDateElement printDateEle = OdfElement.findFirstChildNode(
MetaPrintDateElement.class, mOfficeMetaElement);
if (printDate == null) {
if (printDateEle != null) {
mOfficeMetaElement.removeChild(printDateEle);
}
} else {
if (printDateEle == null) {
printDateEle = mOfficeMetaElement.newMetaPrintDateElement();
}
printDateEle.setTextContent(calendarToString(printDate));
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>DcLanguageElement</code> , See {@odf.element
* dc:language}.
*
* @return the default language of the document;
* <p>
* <code>null</code>, if the element is not set.
*/
public String getLanguage() {
DcLanguageElement languageEle = OdfElement.findFirstChildNode(
DcLanguageElement.class, mOfficeMetaElement);
if (languageEle != null) {
return languageEle.getTextContent();
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>DcLanguageElement</code> , See {@odf.element
* dc:language}.
*
* @param language the default language need to set fo the current document. NULL will remove the element from the meta.xml.
*/
public void setLanguage(String language) {
DcLanguageElement languageEle = OdfElement.findFirstChildNode(
DcLanguageElement.class, mOfficeMetaElement);
if (language == null) {
if (languageEle != null) {
mOfficeMetaElement.removeChild(languageEle);
}
} else {
if (languageEle == null) {
languageEle = mOfficeMetaElement.newDcLanguageElement();
}
languageEle.setTextContent(language);
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaEditingCyclesElement</code> , See {@odf.element
* meta:editing-cycles}.
*
* @return the number of times that the document has been edited;
* <p>
* <code>null</code>, if the element is not set.
*/
public Integer getEditingCycles() {
MetaEditingCyclesElement editingCyclesEle = OdfElement.findFirstChildNode(MetaEditingCyclesElement.class,
mOfficeMetaElement);
if (editingCyclesEle != null) {
return Integer.valueOf(editingCyclesEle.getTextContent());
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaEditingCyclesElement</code> , See {@odf.element
* meta:editing-cycles}.
*
* @param editingCycles set the specified edit times. NULL will remove the element from the meta.xml.
*/
public void setEditingCycles(Integer editingCycles) {
MetaEditingCyclesElement editingCyclesEle = OdfElement.findFirstChildNode(MetaEditingCyclesElement.class,
mOfficeMetaElement);
if (editingCycles == null) {
if (editingCyclesEle != null) {
mOfficeMetaElement.removeChild(editingCyclesEle);
}
} else {
if (editingCyclesEle == null) {
editingCyclesEle = mOfficeMetaElement.newMetaEditingCyclesElement();
}
editingCyclesEle.setTextContent(String.valueOf(editingCycles));
}
}
/**
* Receives the value of the ODFDOM element representation
* <code>MetaEditingDurationElement</code> , See {@odf.element
* meta:editing-duration}.
*
* @return the total time spent editing the document;
* <p>
* <code>null</code>, if the element is not set.
*/
public Duration getEditingDuration() {
MetaEditingDurationElement editiingDurationEle = OdfElement.findFirstChildNode(MetaEditingDurationElement.class,
mOfficeMetaElement);
if (editiingDurationEle != null) {
return Duration.valueOf(editiingDurationEle.getTextContent());
}
return null;
}
/**
* Sets the value of the ODFDOM element representation
* <code>MetaEditingDurationElement</code> , See {@odf.element
* meta:editing-duration}.
*
* @param editingDuration the time need to set. NULL will remove the element from the meta.xml.
*/
public void setEditingDuration(Duration editingDuration) {
MetaEditingDurationElement editingDurationEle = OdfElement.findFirstChildNode(MetaEditingDurationElement.class,
mOfficeMetaElement);
if (editingDuration == null) {
if (editingDurationEle != null) {
mOfficeMetaElement.removeChild(editingDurationEle);
}
} else {
if (editingDurationEle == null) {
editingDurationEle = mOfficeMetaElement.newMetaEditingDurationElement();
}
editingDurationEle.setTextContent(editingDuration.toString());
}
}
/**
* Receives the sub feature of OdfMetaDocumentStatistic.
*
* @return the statistics about the document which can be represented by
* <code>OdfMetaDocumentStatistic</code> feature;
* <p>
* <code>null</code>, if the feature is not exist.
*/
public OdfMetaDocumentStatistic getDocumentStatistic() {
MetaDocumentStatisticElement element = getDocumentStatisticElement();
if (element != null) {
return new OdfMetaDocumentStatistic(element);
} else {
return null;
}
}
/**
* Receives the OdfMetaHyperlinkBehaviour feature.
*
* @return the default behavior of hyperlinks in the current document
* which can be represented by <code>OdfMetaHyperlinkBehaviour</code> feature;
* <p>
* <code>null</code>, if the feature is not exist.
*/
public OdfMetaHyperlinkBehaviour getHyperlinkBehaviour() {
MetaHyperlinkBehaviourElement element = getHyperlinkBehaviourElement();
if (element != null) {
return new OdfMetaHyperlinkBehaviour(element);
} else {
return null;
}
}
/**
* Receives the OdfMetaAutoReload feature.
*
* @return the information whether the document is reloaded or replaced by another document
* after a certain period of time has elapsed.
* <p>
* It can be represented by <code>OdfMetaAutoReload</code> feature;
* <p>
* <code>null</code>, if the feature is not exist.
*/
public OdfMetaAutoReload getAutoReload() {
MetaAutoReloadElement element = getAutoReloadElement();
if (element != null) {
return new OdfMetaAutoReload(element);
} else {
return null;
}
}
/**
* Receives the OdfMetaTemplate feature.
*
* @return the information specified the URL for the document that was used to create a document.
* <p>
* It can be represented by <code>OdfMetaTemplate</code> feature;
* <p>
* <code>null</code>, if the feature is not exist.
*/
public OdfMetaTemplate getTemplate() {
MetaTemplateElement element = getTemplateElement();
if (element != null) {
return new OdfMetaTemplate(element);
} else {
return null;
}
}
private MetaDocumentStatisticElement getDocumentStatisticElement() {
return OdfElement.findFirstChildNode(
MetaDocumentStatisticElement.class, mOfficeMetaElement);
}
private MetaHyperlinkBehaviourElement getHyperlinkBehaviourElement() {
return OdfElement.findFirstChildNode(
MetaHyperlinkBehaviourElement.class, mOfficeMetaElement);
}
private MetaAutoReloadElement getAutoReloadElement() {
return OdfElement.findFirstChildNode(MetaAutoReloadElement.class,
mOfficeMetaElement);
}
private MetaTemplateElement getTemplateElement() {
return OdfElement.findFirstChildNode(MetaTemplateElement.class,
mOfficeMetaElement);
}
/**
* Change valid string of calendar to Calendar type.
*
* @param baseDate the string of a calender
* @return the object of Calender
*/
private Calendar stringToCalendar(String baseDate) {
// Calendar calendar=new GregorianCalendar();
Calendar calendar = Calendar.getInstance();
Date d1 = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
try {
d1 = sdf.parse(baseDate);
} catch (Exception e) {
// invalid format or null value in meta.xml
// d1=new Date();
}
calendar.setTime(d1);
return calendar;
}
/**
* Convert a <code>Canlender</code> object to <code>String</code> object.
* @param calendar an instanceof <code>Canlender</code>
* @return the String format(yyyy-MM-dd'T'HH:mm:ss) of Calendar.
*/
private String calendarToString(Calendar calendar) {
return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(calendar.getTime());
}
/**@param enableAutomaticUpdate If the automatic update of metadata is enabled, metadata such as last modified data is set during saving the document.
The default is <code>true</code>, disabling the default allows to load and save a document without changing any data.
*/
public void setAutomaticUpdate(boolean enableAutomaticUpdate) {
mAutomaticUpdate = enableAutomaticUpdate;
}
/**@return If the automatic update of metadata is enabled, metadata such as last modified data is set during saving the document.
The default is <code>true</code>, disabling the default allows to load and save a document without changing any data. */
public boolean hasAutomaticUpdate() {
return mAutomaticUpdate;
}
@Override
public String toString() {
if (mOfficeMetaElement != null) {
return mOfficeMetaElement.toString();
} else {
return null;
}
}
}