<person id="NB" name="Nick Burch" email="nick@torchbox.com"/>
<person id="POI-DEVELOPERS" name="POI Developers" email="dev@poi.apache.org"/>
<person id="RK" name="Rainer Klute" email="klute@apache.org"/>
+ <person id="UC" name="Ugo Cei" email="ugo@apache.org"/>
<person id="YK" name="Yegor Kozlov" email="yegor@apache.org"/>
</developers>
<changes>
<release version="3.6-beta1" date="2009-??-??">
+ <action dev="POI-DEVELOPERS" type="add">47942 - added implementation of protection features to XLSX and DOCX files</action>
<action dev="POI-DEVELOPERS" type="fix">48070 - preserve leading and trailing white spaces in XSSFRichTextString</action>
<action dev="POI-DEVELOPERS" type="add">48044 - added implementation for CountBlank function</action>
<action dev="POI-DEVELOPERS" type="fix">48036 - added IntersectionEval to allow evaluation of the intersection formula operator</action>
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetData;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetFormatPr;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetPr;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetProtection;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetView;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetViews;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorksheet;
* @return true => protection enabled; false => protection disabled
*/
public boolean getProtect() {
- return worksheet.isSetSheetProtection() && worksheet.getSheetProtection().getSheet();
+ return worksheet.isSetSheetProtection() && sheetProtectionEnabled();
}
/**
worksheet.save(out, xmlOptions);
}
+
+ /**
+ * @return true when Autofilters are locked and the sheet is protected.
+ */
+ public boolean isAutoFilterLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getAutoFilter();
+ }
+
+ /**
+ * @return true when Deleting columns is locked and the sheet is protected.
+ */
+ public boolean isDeleteColumnsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getDeleteColumns();
+ }
+
+ /**
+ * @return true when Deleting rows is locked and the sheet is protected.
+ */
+ public boolean isDeleteRowsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getDeleteRows();
+ }
+
+ /**
+ * @return true when Formatting cells is locked and the sheet is protected.
+ */
+ public boolean isFormatCellsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getFormatCells();
+ }
+
+ /**
+ * @return true when Formatting columns is locked and the sheet is protected.
+ */
+ public boolean isFormatColumnsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getFormatColumns();
+ }
+
+ /**
+ * @return true when Formatting rows is locked and the sheet is protected.
+ */
+ public boolean isFormatRowsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getFormatRows();
+ }
+
+ /**
+ * @return true when Inserting columns is locked and the sheet is protected.
+ */
+ public boolean isInsertColumnsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getInsertColumns();
+ }
+
+ /**
+ * @return true when Inserting hyperlinks is locked and the sheet is protected.
+ */
+ public boolean isInsertHyperlinksLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getInsertHyperlinks();
+ }
+
+ /**
+ * @return true when Inserting rows is locked and the sheet is protected.
+ */
+ public boolean isInsertRowsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getInsertRows();
+ }
+
+ /**
+ * @return true when Pivot tables are locked and the sheet is protected.
+ */
+ public boolean isPivotTablesLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getPivotTables();
+ }
+
+ /**
+ * @return true when Sorting is locked and the sheet is protected.
+ */
+ public boolean isSortLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getSort();
+ }
+
+ /**
+ * @return true when Objects are locked and the sheet is protected.
+ */
+ public boolean isObjectsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getObjects();
+ }
+
+ /**
+ * @return true when Scenarios are locked and the sheet is protected.
+ */
+ public boolean isScenariosLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getScenarios();
+ }
+
+ /**
+ * @return true when Selection of locked cells is locked and the sheet is protected.
+ */
+ public boolean isSelectLockedCellsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getSelectLockedCells();
+ }
+
+ /**
+ * @return true when Selection of unlocked cells is locked and the sheet is protected.
+ */
+ public boolean isSelectUnlockedCellsLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getSelectUnlockedCells();
+ }
+
+ /**
+ * @return true when Sheet is Protected.
+ */
+ public boolean isSheetLocked() {
+ createProtectionFieldIfNotPresent();
+ return sheetProtectionEnabled() && worksheet.getSheetProtection().getSheet();
+ }
+
+ /**
+ * Enable sheet protection
+ */
+ public void enableLocking() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setSheet(true);
+ }
+
+ /**
+ * Disable sheet protection
+ */
+ public void disableLocking() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setSheet(false);
+ }
+
+ /**
+ * Enable Autofilters locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockAutoFilter() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setAutoFilter(true);
+ }
+
+ /**
+ * Enable Deleting columns locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockDeleteColumns() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setDeleteColumns(true);
+ }
+
+ /**
+ * Enable Deleting rows locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockDeleteRows() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setDeleteRows(true);
+ }
+
+ /**
+ * Enable Formatting cells locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockFormatCells() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setDeleteColumns(true);
+ }
+
+ /**
+ * Enable Formatting columns locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockFormatColumns() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setFormatColumns(true);
+ }
+
+ /**
+ * Enable Formatting rows locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockFormatRows() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setFormatRows(true);
+ }
+
+ /**
+ * Enable Inserting columns locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockInsertColumns() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setInsertColumns(true);
+ }
+
+ /**
+ * Enable Inserting hyperlinks locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockInsertHyperlinks() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setInsertHyperlinks(true);
+ }
+
+ /**
+ * Enable Inserting rows locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockInsertRows() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setInsertRows(true);
+ }
+
+ /**
+ * Enable Pivot Tables locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockPivotTables() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setPivotTables(true);
+ }
+
+ /**
+ * Enable Sort locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockSort() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setSort(true);
+ }
+
+ /**
+ * Enable Objects locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockObjects() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setObjects(true);
+ }
+
+ /**
+ * Enable Scenarios locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockScenarios() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setScenarios(true);
+ }
+
+ /**
+ * Enable Selection of locked cells locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockSelectLockedCells() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setSelectLockedCells(true);
+ }
+
+ /**
+ * Enable Selection of unlocked cells locking.
+ * This does not modify sheet protection status.
+ * To enforce this locking, call {@link #enableLocking()}
+ */
+ public void lockSelectUnlockedCells() {
+ createProtectionFieldIfNotPresent();
+ worksheet.getSheetProtection().setSelectUnlockedCells(true);
+ }
+
+ private void createProtectionFieldIfNotPresent() {
+ if (worksheet.getSheetProtection() == null) {
+ worksheet.setSheetProtection(CTSheetProtection.Factory.newInstance());
+ }
+ }
+
+ private boolean sheetProtectionEnabled() {
+ return worksheet.getSheetProtection().getSheet();
+ }
}
public MapInfo getMapInfo(){
return mapInfo;
}
+
+
+ /**
+ * Specifies a boolean value that indicates whether structure of workbook is locked. <br/>
+ * A value true indicates the structure of the workbook is locked. Worksheets in the workbook can't be moved,
+ * deleted, hidden, unhidden, or renamed, and new worksheets can't be inserted.<br/>
+ * A value of false indicates the structure of the workbook is not locked.<br/>
+ *
+ * @return true if structure of workbook is locked
+ */
+ public boolean isStructureLocked() {
+ return workbookProtectionPresent() && workbook.getWorkbookProtection().getLockStructure();
+ }
+
+ /**
+ * Specifies a boolean value that indicates whether the windows that comprise the workbook are locked. <br/>
+ * A value of true indicates the workbook windows are locked. Windows are the same size and position each time the
+ * workbook is opened.<br/>
+ * A value of false indicates the workbook windows are not locked.
+ *
+ * @return true if windows that comprise the workbook are locked
+ */
+ public boolean isWindowsLocked() {
+ return workbookProtectionPresent() && workbook.getWorkbookProtection().getLockWindows();
+ }
+
+ /**
+ * Specifies a boolean value that indicates whether the workbook is locked for revisions.
+ *
+ * @return true if the workbook is locked for revisions.
+ */
+ public boolean isRevisionLocked() {
+ return workbookProtectionPresent() && workbook.getWorkbookProtection().getLockRevision();
+ }
+
+ /**
+ * Locks the structure of workbook.
+ */
+ public void lockStructure() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockStructure(true);
+ }
+
+ /**
+ * Unlocks the structure of workbook.
+ */
+ public void unLockStructure() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockStructure(false);
+ }
+
+ /**
+ * Locks the windows that comprise the workbook.
+ */
+ public void lockWindows() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockWindows(true);
+ }
+
+ /**
+ * Unlocks the windows that comprise the workbook.
+ */
+ public void unLockWindows() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockWindows(false);
+ }
+
+ /**
+ * Locks the workbook for revisions.
+ */
+ public void lockRevision() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockRevision(true);
+ }
+
+ /**
+ * Unlocks the workbook for revisions.
+ */
+ public void unLockRevision() {
+ createProtectionFieldIfNotPresent();
+ workbook.getWorkbookProtection().setLockRevision(false);
+ }
+
+ private boolean workbookProtectionPresent() {
+ return workbook.getWorkbookProtection() != null;
+ }
+
+ private void createProtectionFieldIfNotPresent() {
+ if (workbook.getWorkbookProtection() == null){
+ workbook.setWorkbookProtection(CTWorkbookProtection.Factory.newInstance());
+ }
+ }
}
import org.apache.poi.openxml4j.exceptions.OpenXML4JException;
import org.apache.poi.openxml4j.opc.*;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.*;
-
import javax.xml.namespace.QName;
/**
public class XWPFDocument extends POIXMLDocument {
private CTDocument1 ctDocument;
+ private XWPFSettings settings;
protected List<XWPFComment> comments;
protected List<XWPFHyperlink> hyperlinks;
protected List<XWPFParagraph> paragraphs;
}
// Sort out headers and footers
- headerFooterPolicy = new XWPFHeaderFooterPolicy(this);
+ if (doc.getDocument().getBody().getSectPr() != null)
+ headerFooterPolicy = new XWPFHeaderFooterPolicy(this);
for(POIXMLDocumentPart p : getRelations()){
String relation = p.getPackageRelationship().getRelationshipType();
comments.add(new XWPFComment(ctcomment));
}
}
+ else if(relation.equals(XWPFRelation.SETTINGS.getRelation())){
+ settings = (XWPFSettings)p;
+ }
}
initHyperlinks();
ctDocument = CTDocument1.Factory.newInstance();
ctDocument.addNewBody();
+
+ settings = (XWPFSettings) createRelationship(XWPFRelation.SETTINGS, XWPFFactory.getInstance());
POIXMLProperties.ExtendedProperties expProps = getProperties().getExtendedProperties();
expProps.getUnderlyingProperties().setApplication(DOCUMENT_CREATOR);
}
}
}
+
+ /**
+ * Verifies that the documentProtection tag in settings.xml file <br/>
+ * specifies that the protection is enforced (w:enforcement="1") <br/>
+ * and that the kind of protection is readOnly (w:edit="readOnly")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="readOnly" w:enforcement="1"/>
+ * </pre>
+ *
+ * @return true if documentProtection is enforced with option readOnly
+ */
+ public boolean isEnforcedReadonlyProtection() {
+ return settings.isEnforcedWith(STDocProtect.READ_ONLY);
+ }
+
+ /**
+ * Verifies that the documentProtection tag in settings.xml file <br/>
+ * specifies that the protection is enforced (w:enforcement="1") <br/>
+ * and that the kind of protection is forms (w:edit="forms")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="forms" w:enforcement="1"/>
+ * </pre>
+ *
+ * @return true if documentProtection is enforced with option forms
+ */
+ public boolean isEnforcedFillingFormsProtection() {
+ return settings.isEnforcedWith(STDocProtect.FORMS);
+ }
+
+ /**
+ * Verifies that the documentProtection tag in settings.xml file <br/>
+ * specifies that the protection is enforced (w:enforcement="1") <br/>
+ * and that the kind of protection is comments (w:edit="comments")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="comments" w:enforcement="1"/>
+ * </pre>
+ *
+ * @return true if documentProtection is enforced with option comments
+ */
+ public boolean isEnforcedCommentsProtection() {
+ return settings.isEnforcedWith(STDocProtect.COMMENTS);
+ }
+
+ /**
+ * Verifies that the documentProtection tag in settings.xml file <br/>
+ * specifies that the protection is enforced (w:enforcement="1") <br/>
+ * and that the kind of protection is trackedChanges (w:edit="trackedChanges")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="trackedChanges" w:enforcement="1"/>
+ * </pre>
+ *
+ * @return true if documentProtection is enforced with option trackedChanges
+ */
+ public boolean isEnforcedTrackedChangesProtection() {
+ return settings.isEnforcedWith(STDocProtect.TRACKED_CHANGES);
+ }
+
+ /**
+ * Enforces the readOnly protection.<br/>
+ * In the documentProtection tag inside settings.xml file, <br/>
+ * it sets the value of enforcement to "1" (w:enforcement="1") <br/>
+ * and the value of edit to readOnly (w:edit="readOnly")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="readOnly" w:enforcement="1"/>
+ * </pre>
+ */
+ public void enforceReadonlyProtection() {
+ settings.setEnforcementEditValue(STDocProtect.READ_ONLY);
+ }
+
+ /**
+ * Enforce the Filling Forms protection.<br/>
+ * In the documentProtection tag inside settings.xml file, <br/>
+ * it sets the value of enforcement to "1" (w:enforcement="1") <br/>
+ * and the value of edit to forms (w:edit="forms")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="forms" w:enforcement="1"/>
+ * </pre>
+ */
+ public void enforceFillingFormsProtection() {
+ settings.setEnforcementEditValue(STDocProtect.FORMS);
+ }
+
+ /**
+ * Enforce the Comments protection.<br/>
+ * In the documentProtection tag inside settings.xml file,<br/>
+ * it sets the value of enforcement to "1" (w:enforcement="1") <br/>
+ * and the value of edit to comments (w:edit="comments")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="comments" w:enforcement="1"/>
+ * </pre>
+ */
+ public void enforceCommentsProtection() {
+ settings.setEnforcementEditValue(STDocProtect.COMMENTS);
+ }
+
+ /**
+ * Enforce the Tracked Changes protection.<br/>
+ * In the documentProtection tag inside settings.xml file, <br/>
+ * it sets the value of enforcement to "1" (w:enforcement="1") <br/>
+ * and the value of edit to trackedChanges (w:edit="trackedChanges")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="trackedChanges" w:enforcement="1"/>
+ * </pre>
+ */
+ public void enforceTrackedChangesProtection() {
+ settings.setEnforcementEditValue(STDocProtect.TRACKED_CHANGES);
+ }
+
+ /**
+ * Remove protection enforcement.<br/>
+ * In the documentProtection tag inside settings.xml file <br/>
+ * it sets the value of enforcement to "0" (w:enforcement="0") <br/>
+ */
+ public void removeProtectionEnforcement() {
+ settings.removeEnforcement();
+ }
+
}
"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings",
"/word/settings.xml",
- null
+ XWPFSettings.class
);
public static final XWPFRelation STYLES = new XWPFRelation(
"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
--- /dev/null
+/* ====================================================================
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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
+
+ 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.apache.poi.xwpf.usermodel;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.poi.POIXMLDocumentPart;
+import org.apache.poi.openxml4j.opc.PackagePart;
+import org.apache.poi.openxml4j.opc.PackageRelationship;
+import org.apache.xmlbeans.XmlOptions;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDocProtect;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSettings;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.STDocProtect;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.STOnOff;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.SettingsDocument;
+
+public class XWPFSettings extends POIXMLDocumentPart {
+
+ private CTSettings ctSettings;
+
+ public XWPFSettings(PackagePart part, PackageRelationship rel) throws IOException {
+ super(part, rel);
+ readFrom(part.getInputStream());
+ }
+
+ public XWPFSettings() {
+ super();
+ ctSettings = CTSettings.Factory.newInstance();
+ }
+
+
+ /**
+ * Verifies the documentProtection tag inside settings.xml file <br/>
+ * if the protection is enforced (w:enforcement="1") <br/>
+ * and if the kind of protection equals to passed (STDocProtect.Enum editValue) <br/>
+ *
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="readOnly" w:enforcement="1"/>
+ * </pre>
+ *
+ * @return true if documentProtection is enforced with option readOnly
+ */
+ public boolean isEnforcedWith(STDocProtect.Enum editValue) {
+ CTDocProtect ctDocProtect = ctSettings.getDocumentProtection();
+
+ if (ctDocProtect == null) {
+ return false;
+ }
+
+ return ctDocProtect.getEnforcement().equals(STOnOff.X_1) && ctDocProtect.getEdit().equals(editValue);
+ }
+
+ /**
+ * Enforces the protection with the option specified by passed editValue.<br/>
+ * <br/>
+ * In the documentProtection tag inside settings.xml file <br/>
+ * it sets the value of enforcement to "1" (w:enforcement="1") <br/>
+ * and the value of edit to the passed editValue (w:edit="[passed editValue]")<br/>
+ * <br/>
+ * sample snippet from settings.xml
+ * <pre>
+ * <w:settings ... >
+ * <w:documentProtection w:edit="[passed editValue]" w:enforcement="1"/>
+ * </pre>
+ */
+ public void setEnforcementEditValue(org.openxmlformats.schemas.wordprocessingml.x2006.main.STDocProtect.Enum editValue) {
+ safeGetDocumentProtection().setEnforcement(STOnOff.X_1);
+ safeGetDocumentProtection().setEdit(editValue);
+ }
+
+ /**
+ * Removes protection enforcement.<br/>
+ * In the documentProtection tag inside settings.xml file <br/>
+ * it sets the value of enforcement to "0" (w:enforcement="0") <br/>
+ */
+ public void removeEnforcement() {
+ safeGetDocumentProtection().setEnforcement(STOnOff.X_0);
+ }
+
+ @Override
+ protected void commit() throws IOException {
+
+ XmlOptions xmlOptions = new XmlOptions(DEFAULT_XML_OPTIONS);
+ xmlOptions.setSaveSyntheticDocumentElement(new QName(CTSettings.type.getName().getNamespaceURI(), "settings"));
+ Map<String, String> map = new HashMap<String, String>();
+ map.put("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "w");
+ xmlOptions.setSaveSuggestedPrefixes(map);
+
+ PackagePart part = getPackagePart();
+ OutputStream out = part.getOutputStream();
+ ctSettings.save(out, xmlOptions);
+ out.close();
+ }
+
+ private CTDocProtect safeGetDocumentProtection() {
+ CTDocProtect documentProtection = ctSettings.getDocumentProtection();
+ if (documentProtection == null) {
+ documentProtection = CTDocProtect.Factory.newInstance();
+ ctSettings.setDocumentProtection(documentProtection);
+ }
+ return ctSettings.getDocumentProtection();
+ }
+
+ private void readFrom(InputStream inputStream) {
+ try {
+ ctSettings = SettingsDocument.Factory.parse(inputStream).getSettings();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+}
--- /dev/null
+/* ====================================================================
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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
+
+ 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.apache.poi.xssf;
+
+import org.apache.poi.xssf.usermodel.XSSFSheet;
+
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+
+import junit.framework.TestCase;
+
+public class TestSheetProtection extends TestCase {
+ private XSSFSheet sheet;
+
+ @Override
+ protected void setUp() throws Exception {
+ XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("sheetProtection_not_protected.xlsx");
+ sheet = workbook.getSheetAt(0);
+ }
+
+ public void testShouldReadWorkbookProtection() throws Exception {
+ assertFalse(sheet.isAutoFilterLocked());
+ assertFalse(sheet.isDeleteColumnsLocked());
+ assertFalse(sheet.isDeleteRowsLocked());
+ assertFalse(sheet.isFormatCellsLocked());
+ assertFalse(sheet.isFormatColumnsLocked());
+ assertFalse(sheet.isFormatRowsLocked());
+ assertFalse(sheet.isInsertColumnsLocked());
+ assertFalse(sheet.isInsertHyperlinksLocked());
+ assertFalse(sheet.isInsertRowsLocked());
+ assertFalse(sheet.isPivotTablesLocked());
+ assertFalse(sheet.isSortLocked());
+ assertFalse(sheet.isObjectsLocked());
+ assertFalse(sheet.isScenariosLocked());
+ assertFalse(sheet.isSelectLockedCellsLocked());
+ assertFalse(sheet.isSelectUnlockedCellsLocked());
+ assertFalse(sheet.isSheetLocked());
+
+ sheet = XSSFTestDataSamples.openSampleWorkbook("sheetProtection_allLocked.xlsx").getSheetAt(0);
+
+ assertTrue(sheet.isAutoFilterLocked());
+ assertTrue(sheet.isDeleteColumnsLocked());
+ assertTrue(sheet.isDeleteRowsLocked());
+ assertTrue(sheet.isFormatCellsLocked());
+ assertTrue(sheet.isFormatColumnsLocked());
+ assertTrue(sheet.isFormatRowsLocked());
+ assertTrue(sheet.isInsertColumnsLocked());
+ assertTrue(sheet.isInsertHyperlinksLocked());
+ assertTrue(sheet.isInsertRowsLocked());
+ assertTrue(sheet.isPivotTablesLocked());
+ assertTrue(sheet.isSortLocked());
+ assertTrue(sheet.isObjectsLocked());
+ assertTrue(sheet.isScenariosLocked());
+ assertTrue(sheet.isSelectLockedCellsLocked());
+ assertTrue(sheet.isSelectUnlockedCellsLocked());
+ assertTrue(sheet.isSheetLocked());
+ }
+
+ public void testWriteAutoFilter() throws Exception {
+ assertFalse(sheet.isAutoFilterLocked());
+ sheet.lockAutoFilter();
+ assertFalse(sheet.isAutoFilterLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isAutoFilterLocked());
+ }
+
+ public void testWriteDeleteColumns() throws Exception {
+ assertFalse(sheet.isDeleteColumnsLocked());
+ sheet.lockDeleteColumns();
+ assertFalse(sheet.isDeleteColumnsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isDeleteColumnsLocked());
+ }
+
+ public void testWriteDeleteRows() throws Exception {
+ assertFalse(sheet.isDeleteRowsLocked());
+ sheet.lockDeleteRows();
+ assertFalse(sheet.isDeleteRowsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isDeleteRowsLocked());
+ }
+
+ public void testWriteFormatCells() throws Exception {
+ assertFalse(sheet.isFormatCellsLocked());
+ sheet.lockFormatCells();
+ assertFalse(sheet.isFormatCellsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isFormatCellsLocked());
+ }
+
+ public void testWriteFormatColumns() throws Exception {
+ assertFalse(sheet.isFormatColumnsLocked());
+ sheet.lockFormatColumns();
+ assertFalse(sheet.isFormatColumnsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isFormatColumnsLocked());
+ }
+
+ public void testWriteFormatRows() throws Exception {
+ assertFalse(sheet.isFormatRowsLocked());
+ sheet.lockFormatRows();
+ assertFalse(sheet.isFormatRowsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isFormatRowsLocked());
+ }
+
+ public void testWriteInsertColumns() throws Exception {
+ assertFalse(sheet.isInsertColumnsLocked());
+ sheet.lockInsertColumns();
+ assertFalse(sheet.isInsertColumnsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isInsertColumnsLocked());
+ }
+
+ public void testWriteInsertHyperlinks() throws Exception {
+ assertFalse(sheet.isInsertHyperlinksLocked());
+ sheet.lockInsertHyperlinks();
+ assertFalse(sheet.isInsertHyperlinksLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isInsertHyperlinksLocked());
+ }
+
+ public void testWriteInsertRows() throws Exception {
+ assertFalse(sheet.isInsertRowsLocked());
+ sheet.lockInsertRows();
+ assertFalse(sheet.isInsertRowsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isInsertRowsLocked());
+ }
+
+ public void testWritePivotTables() throws Exception {
+ assertFalse(sheet.isPivotTablesLocked());
+ sheet.lockPivotTables();
+ assertFalse(sheet.isPivotTablesLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isPivotTablesLocked());
+ }
+
+ public void testWriteSort() throws Exception {
+ assertFalse(sheet.isSortLocked());
+ sheet.lockSort();
+ assertFalse(sheet.isSortLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isSortLocked());
+ }
+
+ public void testWriteObjects() throws Exception {
+ assertFalse(sheet.isObjectsLocked());
+ sheet.lockObjects();
+ assertFalse(sheet.isObjectsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isObjectsLocked());
+ }
+
+ public void testWriteScenarios() throws Exception {
+ assertFalse(sheet.isScenariosLocked());
+ sheet.lockScenarios();
+ assertFalse(sheet.isScenariosLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isScenariosLocked());
+ }
+
+ public void testWriteSelectLockedCells() throws Exception {
+ assertFalse(sheet.isSelectLockedCellsLocked());
+ sheet.lockSelectLockedCells();
+ assertFalse(sheet.isSelectLockedCellsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isSelectLockedCellsLocked());
+ }
+
+ public void testWriteSelectUnlockedCells() throws Exception {
+ assertFalse(sheet.isSelectUnlockedCellsLocked());
+ sheet.lockSelectUnlockedCells();
+ assertFalse(sheet.isSelectUnlockedCellsLocked());
+ sheet.enableLocking();
+ assertTrue(sheet.isSelectUnlockedCellsLocked());
+ }
+
+ public void testWriteSelectEnableLocking() throws Exception {
+ sheet = XSSFTestDataSamples.openSampleWorkbook("sheetProtection_allLocked.xlsx").getSheetAt(0);
+
+ assertTrue(sheet.isAutoFilterLocked());
+ assertTrue(sheet.isDeleteColumnsLocked());
+ assertTrue(sheet.isDeleteRowsLocked());
+ assertTrue(sheet.isFormatCellsLocked());
+ assertTrue(sheet.isFormatColumnsLocked());
+ assertTrue(sheet.isFormatRowsLocked());
+ assertTrue(sheet.isInsertColumnsLocked());
+ assertTrue(sheet.isInsertHyperlinksLocked());
+ assertTrue(sheet.isInsertRowsLocked());
+ assertTrue(sheet.isPivotTablesLocked());
+ assertTrue(sheet.isSortLocked());
+ assertTrue(sheet.isObjectsLocked());
+ assertTrue(sheet.isScenariosLocked());
+ assertTrue(sheet.isSelectLockedCellsLocked());
+ assertTrue(sheet.isSelectUnlockedCellsLocked());
+ assertTrue(sheet.isSheetLocked());
+
+ sheet.disableLocking();
+
+ assertFalse(sheet.isAutoFilterLocked());
+ assertFalse(sheet.isDeleteColumnsLocked());
+ assertFalse(sheet.isDeleteRowsLocked());
+ assertFalse(sheet.isFormatCellsLocked());
+ assertFalse(sheet.isFormatColumnsLocked());
+ assertFalse(sheet.isFormatRowsLocked());
+ assertFalse(sheet.isInsertColumnsLocked());
+ assertFalse(sheet.isInsertHyperlinksLocked());
+ assertFalse(sheet.isInsertRowsLocked());
+ assertFalse(sheet.isPivotTablesLocked());
+ assertFalse(sheet.isSortLocked());
+ assertFalse(sheet.isObjectsLocked());
+ assertFalse(sheet.isScenariosLocked());
+ assertFalse(sheet.isSelectLockedCellsLocked());
+ assertFalse(sheet.isSelectUnlockedCellsLocked());
+ assertFalse(sheet.isSheetLocked());
+ }
+}
--- /dev/null
+/* ====================================================================
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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
+
+ 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.apache.poi.xssf;
+
+import java.io.File;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+
+public class TestWorkbookProtection extends TestCase {
+
+ public void testShouldReadWorkbookProtection() throws Exception {
+ XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_not_protected.xlsx");
+ assertFalse(workbook.isStructureLocked());
+ assertFalse(workbook.isWindowsLocked());
+ assertFalse(workbook.isRevisionLocked());
+
+ workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_workbook_structure_protected.xlsx");
+ assertTrue(workbook.isStructureLocked());
+ assertFalse(workbook.isWindowsLocked());
+ assertFalse(workbook.isRevisionLocked());
+
+ workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_workbook_windows_protected.xlsx");
+ assertTrue(workbook.isWindowsLocked());
+ assertFalse(workbook.isStructureLocked());
+ assertFalse(workbook.isRevisionLocked());
+
+ workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_workbook_revision_protected.xlsx");
+ assertTrue(workbook.isRevisionLocked());
+ assertFalse(workbook.isWindowsLocked());
+ assertFalse(workbook.isStructureLocked());
+ }
+
+ public void testShouldWriteStructureLock() throws Exception {
+ XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_not_protected.xlsx");
+ assertFalse(workbook.isStructureLocked());
+
+ workbook.lockStructure();
+
+ assertTrue(workbook.isStructureLocked());
+
+ workbook.unLockStructure();
+
+ assertFalse(workbook.isStructureLocked());
+ }
+
+ public void testShouldWriteWindowsLock() throws Exception {
+ XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_not_protected.xlsx");
+ assertFalse(workbook.isWindowsLocked());
+
+ workbook.lockWindows();
+
+ assertTrue(workbook.isWindowsLocked());
+
+ workbook.unLockWindows();
+
+ assertFalse(workbook.isWindowsLocked());
+ }
+
+ public void testShouldWriteRevisionLock() throws Exception {
+ XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("workbookProtection_not_protected.xlsx");
+ assertFalse(workbook.isRevisionLocked());
+
+ workbook.lockRevision();
+
+ assertTrue(workbook.isRevisionLocked());
+
+ workbook.unLockRevision();
+
+ assertFalse(workbook.isRevisionLocked());
+ }
+
+ public void testIntegration() throws Exception {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ wb.createSheet("Testing purpose sheet");
+ assertFalse(wb.isRevisionLocked());
+
+ wb.lockRevision();
+
+ File tempFile = File.createTempFile("workbookProtection", ".xlsx");
+ FileOutputStream out = new FileOutputStream(tempFile);
+ wb.write(out);
+ out.close();
+
+ FileInputStream inputStream = new FileInputStream(tempFile);
+ XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
+ inputStream.close();
+
+ assertTrue(workbook.isRevisionLocked());
+ }
+}
--- /dev/null
+/* ====================================================================
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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
+
+ 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.apache.poi.xwpf;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.apache.poi.xwpf.usermodel.XWPFParagraph;
+import org.apache.poi.xwpf.usermodel.XWPFRun;
+
+public class TestDocumentProtection extends TestCase {
+
+ public void testShouldReadEnforcementProperties() throws Exception {
+
+ XWPFDocument documentWithoutDocumentProtectionTag = XWPFTestDataSamples.openSampleDocument("documentProtection_no_protection.docx");
+ assertFalse(documentWithoutDocumentProtectionTag.isEnforcedReadonlyProtection());
+ assertFalse(documentWithoutDocumentProtectionTag.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithoutDocumentProtectionTag.isEnforcedCommentsProtection());
+ assertFalse(documentWithoutDocumentProtectionTag.isEnforcedTrackedChangesProtection());
+
+ XWPFDocument documentWithoutEnforcement = XWPFTestDataSamples.openSampleDocument("documentProtection_no_protection_tag_existing.docx");
+ assertFalse(documentWithoutEnforcement.isEnforcedReadonlyProtection());
+ assertFalse(documentWithoutEnforcement.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithoutEnforcement.isEnforcedCommentsProtection());
+ assertFalse(documentWithoutEnforcement.isEnforcedTrackedChangesProtection());
+
+ XWPFDocument documentWithReadonlyEnforcement = XWPFTestDataSamples.openSampleDocument("documentProtection_readonly_no_password.docx");
+ assertTrue(documentWithReadonlyEnforcement.isEnforcedReadonlyProtection());
+ assertFalse(documentWithReadonlyEnforcement.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithReadonlyEnforcement.isEnforcedCommentsProtection());
+ assertFalse(documentWithReadonlyEnforcement.isEnforcedTrackedChangesProtection());
+
+ XWPFDocument documentWithFillingFormsEnforcement = XWPFTestDataSamples.openSampleDocument("documentProtection_forms_no_password.docx");
+ assertTrue(documentWithFillingFormsEnforcement.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithFillingFormsEnforcement.isEnforcedReadonlyProtection());
+ assertFalse(documentWithFillingFormsEnforcement.isEnforcedCommentsProtection());
+ assertFalse(documentWithFillingFormsEnforcement.isEnforcedTrackedChangesProtection());
+
+ XWPFDocument documentWithCommentsEnforcement = XWPFTestDataSamples.openSampleDocument("documentProtection_comments_no_password.docx");
+ assertFalse(documentWithCommentsEnforcement.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithCommentsEnforcement.isEnforcedReadonlyProtection());
+ assertTrue(documentWithCommentsEnforcement.isEnforcedCommentsProtection());
+ assertFalse(documentWithCommentsEnforcement.isEnforcedTrackedChangesProtection());
+
+ XWPFDocument documentWithTrackedChangesEnforcement = XWPFTestDataSamples.openSampleDocument("documentProtection_trackedChanges_no_password.docx");
+ assertFalse(documentWithTrackedChangesEnforcement.isEnforcedFillingFormsProtection());
+ assertFalse(documentWithTrackedChangesEnforcement.isEnforcedReadonlyProtection());
+ assertFalse(documentWithTrackedChangesEnforcement.isEnforcedCommentsProtection());
+ assertTrue(documentWithTrackedChangesEnforcement.isEnforcedTrackedChangesProtection());
+
+ }
+
+ public void testShouldEnforceForReadOnly() throws Exception {
+ // XWPFDocument document = createDocumentFromSampleFile("test-data/document/documentProtection_no_protection.docx");
+ XWPFDocument document = XWPFTestDataSamples.openSampleDocument("documentProtection_no_protection.docx");
+ assertFalse(document.isEnforcedReadonlyProtection());
+
+ document.enforceReadonlyProtection();
+
+ assertTrue(document.isEnforcedReadonlyProtection());
+ }
+
+ public void testShouldEnforceForFillingForms() throws Exception {
+ XWPFDocument document = createDocumentFromSampleFile("test-data/document/documentProtection_no_protection.docx");
+ assertFalse(document.isEnforcedFillingFormsProtection());
+
+ document.enforceFillingFormsProtection();
+
+ assertTrue(document.isEnforcedFillingFormsProtection());
+ }
+
+ public void testShouldEnforceForComments() throws Exception {
+ XWPFDocument document = createDocumentFromSampleFile("test-data/document/documentProtection_no_protection.docx");
+ assertFalse(document.isEnforcedCommentsProtection());
+
+ document.enforceCommentsProtection();
+
+ assertTrue(document.isEnforcedCommentsProtection());
+ }
+
+ public void testShouldEnforceForTrackedChanges() throws Exception {
+ XWPFDocument document = createDocumentFromSampleFile("test-data/document/documentProtection_no_protection.docx");
+ assertFalse(document.isEnforcedTrackedChangesProtection());
+
+ document.enforceTrackedChangesProtection();
+
+ assertTrue(document.isEnforcedTrackedChangesProtection());
+ }
+
+ public void testShouldUnsetEnforcement() throws Exception {
+ XWPFDocument document = createDocumentFromSampleFile("test-data/document/documentProtection_readonly_no_password.docx");
+ assertTrue(document.isEnforcedReadonlyProtection());
+
+ document.removeProtectionEnforcement();
+
+ assertFalse(document.isEnforcedReadonlyProtection());
+ }
+
+ public void testIntegration() throws Exception {
+ XWPFDocument doc = new XWPFDocument();
+
+ XWPFParagraph p1 = doc.createParagraph();
+
+ XWPFRun r1 = p1.createRun();
+ r1.setText("Lorem ipsum dolor sit amet.");
+ doc.enforceCommentsProtection();
+
+ File tempFile = File.createTempFile("documentProtectionFile", ".docx");
+ FileOutputStream out = new FileOutputStream(tempFile);
+
+ doc.write(out);
+ out.close();
+
+ FileInputStream inputStream = new FileInputStream(tempFile);
+ XWPFDocument document = new XWPFDocument(inputStream);
+ inputStream.close();
+
+ assertTrue(document.isEnforcedCommentsProtection());
+ }
+
+ private XWPFDocument createDocumentFromSampleFile(String fileName) throws FileNotFoundException, IOException {
+ File file = new File(fileName);
+ FileInputStream in = new FileInputStream(file);
+ byte[] bytes = new byte[(int) file.length()];
+ in.read(bytes);
+
+ ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
+ XWPFDocument document = new XWPFDocument(inputStream);
+ return document;
+ }
+
+}
projects / poi.git / commitdiff