2004-04-09 09:05:39 -04:00
|
|
|
/* ====================================================================
|
2006-12-22 14:18:16 -05:00
|
|
|
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
|
2004-04-09 09:05:39 -04:00
|
|
|
|
|
|
|
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.
|
|
|
|
==================================================================== */
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
package org.apache.poi.hpsf;
|
|
|
|
|
2003-10-23 16:44:24 -04:00
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.Map;
|
|
|
|
|
2003-08-02 15:02:28 -04:00
|
|
|
import org.apache.poi.hpsf.wellknown.PropertyIDMap;
|
2006-03-03 11:57:55 -05:00
|
|
|
import org.apache.poi.hpsf.wellknown.SectionIDMap;
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
/**
|
2002-12-10 01:15:20 -05:00
|
|
|
* <p>Convenience class representing a DocumentSummary Information stream in a
|
|
|
|
* Microsoft Office document.</p>
|
2002-02-13 23:00:59 -05:00
|
|
|
*
|
2003-08-30 05:13:53 -04:00
|
|
|
* @author Rainer Klute <a
|
|
|
|
* href="mailto:klute@rainer-klute.de"><klute@rainer-klute.de></a>
|
2002-12-10 01:15:20 -05:00
|
|
|
* @author Drew Varner (Drew.Varner closeTo sc.edu)
|
2003-10-23 16:44:24 -04:00
|
|
|
* @author robert_flaherty@hyperion.com
|
2002-12-10 01:15:20 -05:00
|
|
|
* @see SummaryInformation
|
|
|
|
* @version $Id$
|
|
|
|
* @since 2002-02-09
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public class DocumentSummaryInformation extends SpecialPropertySet
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
|
2003-02-22 09:27:16 -05:00
|
|
|
/**
|
|
|
|
* <p>The document name a document summary information stream
|
|
|
|
* usually has in a POIFS filesystem.</p>
|
|
|
|
*/
|
|
|
|
public static final String DEFAULT_STREAM_NAME =
|
|
|
|
"\005DocumentSummaryInformation";
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
/**
|
2002-12-10 01:15:20 -05:00
|
|
|
* <p>Creates a {@link DocumentSummaryInformation} from a given
|
|
|
|
* {@link PropertySet}.</p>
|
2002-02-13 23:00:59 -05:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @param ps A property set which should be created from a
|
|
|
|
* document summary information stream.
|
|
|
|
* @throws UnexpectedPropertySetTypeException if <var>ps</var>
|
|
|
|
* does not contain a document summary information stream.
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
|
|
|
public DocumentSummaryInformation(final PropertySet ps)
|
2003-08-02 15:02:28 -04:00
|
|
|
throws UnexpectedPropertySetTypeException
|
2002-12-10 01:15:20 -05:00
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
super(ps);
|
2002-12-10 01:15:20 -05:00
|
|
|
if (!isDocumentSummaryInformation())
|
2002-02-13 23:00:59 -05:00
|
|
|
throw new UnexpectedPropertySetTypeException
|
2003-08-02 15:02:28 -04:00
|
|
|
("Not a " + getClass().getName());
|
2002-02-13 23:00:59 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the category (or <code>null</code>).</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @return The category value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public String getCategory()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return (String) getProperty(PropertyIDMap.PID_CATEGORY);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the category.</p>
|
|
|
|
*
|
|
|
|
* @param category The category to set.
|
|
|
|
*/
|
|
|
|
public void setCategory(final String category)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_CATEGORY, category);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the category.</p>
|
|
|
|
*/
|
|
|
|
public void removeCategory()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_CATEGORY);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the presentation format (or
|
2002-12-10 01:15:20 -05:00
|
|
|
* <code>null</code>).</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The presentation format value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public String getPresentationFormat()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return (String) getProperty(PropertyIDMap.PID_PRESFORMAT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the presentation format.</p>
|
|
|
|
*
|
|
|
|
* @param presentationFormat The presentation format to set.
|
|
|
|
*/
|
|
|
|
public void setPresentationFormat(final String presentationFormat)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_PRESFORMAT, presentationFormat);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the presentation format.</p>
|
|
|
|
*/
|
|
|
|
public void removePresentationFormat()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_PRESFORMAT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the byte count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a byte count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @return The byteCount value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getByteCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_BYTECOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the byte count.</p>
|
|
|
|
*
|
|
|
|
* @param byteCount The byte count to set.
|
|
|
|
*/
|
|
|
|
public void setByteCount(final int byteCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_BYTECOUNT, byteCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the byte count.</p>
|
|
|
|
*/
|
|
|
|
public void removeByteCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_BYTECOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the line count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a line count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The line count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getLineCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_LINECOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the line count.</p>
|
|
|
|
*
|
|
|
|
* @param lineCount The line count to set.
|
|
|
|
*/
|
|
|
|
public void setLineCount(final int lineCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_LINECOUNT, lineCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the line count.</p>
|
|
|
|
*/
|
|
|
|
public void removeLineCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_LINECOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the par count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a par count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The par count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getParCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_PARCOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the par count.</p>
|
|
|
|
*
|
|
|
|
* @param parCount The par count to set.
|
|
|
|
*/
|
|
|
|
public void setParCount(final int parCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_PARCOUNT, parCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the par count.</p>
|
|
|
|
*/
|
|
|
|
public void removeParCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_PARCOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the slide count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a slide count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The slide count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getSlideCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_SLIDECOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the slideCount.</p>
|
|
|
|
*
|
|
|
|
* @param slideCount The slide count to set.
|
|
|
|
*/
|
|
|
|
public void setSlideCount(final int slideCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_SLIDECOUNT, slideCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the slide count.</p>
|
|
|
|
*/
|
|
|
|
public void removeSlideCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_SLIDECOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the note count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a note count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The note count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getNoteCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_NOTECOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the note count.</p>
|
|
|
|
*
|
|
|
|
* @param noteCount The note count to set.
|
|
|
|
*/
|
|
|
|
public void setNoteCount(final int noteCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_NOTECOUNT, noteCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the noteCount.</p>
|
|
|
|
*/
|
|
|
|
public void removeNoteCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_NOTECOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the hidden count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a hidden
|
|
|
|
* count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The hidden count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getHiddenCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_HIDDENCOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the hidden count.</p>
|
|
|
|
*
|
|
|
|
* @param hiddenCount The hidden count to set.
|
|
|
|
*/
|
|
|
|
public void setHiddenCount(final int hiddenCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getSections().get(0);
|
|
|
|
s.setProperty(PropertyIDMap.PID_HIDDENCOUNT, hiddenCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the hidden count.</p>
|
|
|
|
*/
|
|
|
|
public void removeHiddenCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_HIDDENCOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the mmclip count or 0 if the {@link
|
2002-12-10 01:15:20 -05:00
|
|
|
* DocumentSummaryInformation} does not contain a mmclip
|
|
|
|
* count.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The mmclip count value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public int getMMClipCount()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return getPropertyIntValue(PropertyIDMap.PID_MMCLIPCOUNT);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the mmclip count.</p>
|
|
|
|
*
|
|
|
|
* @param mmClipCount The mmclip count to set.
|
|
|
|
*/
|
|
|
|
public void setMMClipCount(final int mmClipCount)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_MMCLIPCOUNT, mmClipCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the mmclip count.</p>
|
|
|
|
*/
|
|
|
|
public void removeMMClipCount()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_MMCLIPCOUNT);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2002-12-10 01:15:20 -05:00
|
|
|
* <p>Returns <code>true</code> when scaling of the thumbnail is
|
|
|
|
* desired, <code>false</code> if cropping is desired.</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @return The scale value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public boolean getScale()
|
|
|
|
{
|
2002-05-03 03:29:09 -04:00
|
|
|
return getPropertyBooleanValue(PropertyIDMap.PID_SCALE);
|
2002-02-13 23:00:59 -05:00
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the scale.</p>
|
|
|
|
*
|
|
|
|
* @param scale The scale to set.
|
|
|
|
*/
|
|
|
|
public void setScale(final boolean scale)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_SCALE, scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the scale.</p>
|
|
|
|
*/
|
|
|
|
public void removeScale()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_SCALE);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the heading pair (or <code>null</code>)
|
2002-12-10 01:15:20 -05:00
|
|
|
* <strong>when this method is implemented. Please note that the
|
|
|
|
* return type is likely to change!</strong>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The heading pair value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public byte[] getHeadingPair()
|
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
notYetImplemented("Reading byte arrays ");
|
2002-02-13 23:00:59 -05:00
|
|
|
return (byte[]) getProperty(PropertyIDMap.PID_HEADINGPAIR);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the heading pair.</p>
|
|
|
|
*
|
|
|
|
* @param headingPair The heading pair to set.
|
|
|
|
*/
|
|
|
|
public void setHeadingPair(final byte[] headingPair)
|
|
|
|
{
|
|
|
|
notYetImplemented("Writing byte arrays ");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the heading pair.</p>
|
|
|
|
*/
|
|
|
|
public void removeHeadingPair()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_HEADINGPAIR);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the doc parts (or <code>null</code>)
|
2002-12-10 01:15:20 -05:00
|
|
|
* <strong>when this method is implemented. Please note that the
|
|
|
|
* return type is likely to change!</strong>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The doc parts value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public byte[] getDocparts()
|
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
notYetImplemented("Reading byte arrays");
|
2002-02-13 23:00:59 -05:00
|
|
|
return (byte[]) getProperty(PropertyIDMap.PID_DOCPARTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Sets the doc parts.</p>
|
|
|
|
*
|
|
|
|
* @param docparts The doc parts to set.
|
|
|
|
*/
|
|
|
|
public void setDocparts(final byte[] docparts)
|
|
|
|
{
|
|
|
|
notYetImplemented("Writing byte arrays");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the doc parts.</p>
|
|
|
|
*/
|
|
|
|
public void removeDocparts()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_DOCPARTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Returns the manager (or <code>null</code>).</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @return The manager value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public String getManager()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return (String) getProperty(PropertyIDMap.PID_MANAGER);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the manager.</p>
|
|
|
|
*
|
|
|
|
* @param manager The manager to set.
|
|
|
|
*/
|
|
|
|
public void setManager(final String manager)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_MANAGER, manager);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the manager.</p>
|
|
|
|
*/
|
|
|
|
public void removeManager()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_MANAGER);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Returns the company (or <code>null</code>).</p>
|
2002-05-11 10:47:24 -04:00
|
|
|
*
|
2002-12-10 01:15:20 -05:00
|
|
|
* @return The company value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public String getCompany()
|
|
|
|
{
|
2002-02-13 23:00:59 -05:00
|
|
|
return (String) getProperty(PropertyIDMap.PID_COMPANY);
|
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the company.</p>
|
|
|
|
*
|
|
|
|
* @param company The company to set.
|
|
|
|
*/
|
|
|
|
public void setCompany(final String company)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_COMPANY, company);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the company.</p>
|
|
|
|
*/
|
|
|
|
public void removeCompany()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_COMPANY);
|
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2004-08-15 11:20:08 -04:00
|
|
|
* <p>Returns <code>true</code> if the custom links are dirty.</p> <p>
|
2002-05-03 03:29:09 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The links dirty value
|
2002-02-13 23:00:59 -05:00
|
|
|
*/
|
2002-12-10 01:15:20 -05:00
|
|
|
public boolean getLinksDirty()
|
|
|
|
{
|
2002-05-03 03:29:09 -04:00
|
|
|
return getPropertyBooleanValue(PropertyIDMap.PID_LINKSDIRTY);
|
2002-02-13 23:00:59 -05:00
|
|
|
}
|
|
|
|
|
2006-03-03 11:57:55 -05:00
|
|
|
/**
|
|
|
|
* <p>Sets the linksDirty.</p>
|
|
|
|
*
|
|
|
|
* @param linksDirty The links dirty value to set.
|
|
|
|
*/
|
|
|
|
public void setLinksDirty(final boolean linksDirty)
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.setProperty(PropertyIDMap.PID_LINKSDIRTY, linksDirty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the links dirty.</p>
|
|
|
|
*/
|
|
|
|
public void removeLinksDirty()
|
|
|
|
{
|
|
|
|
final MutableSection s = (MutableSection) getFirstSection();
|
|
|
|
s.removeProperty(PropertyIDMap.PID_LINKSDIRTY);
|
|
|
|
}
|
|
|
|
|
2003-10-23 16:44:24 -04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-03-03 11:57:55 -05:00
|
|
|
* <p>Gets the custom properties.</p>
|
2003-10-23 16:44:24 -04:00
|
|
|
*
|
2006-03-03 11:57:55 -05:00
|
|
|
* @return The custom properties.
|
|
|
|
* @since 2006-02-09
|
2003-10-23 16:44:24 -04:00
|
|
|
*/
|
2006-03-03 11:57:55 -05:00
|
|
|
public CustomProperties getCustomProperties()
|
2003-10-23 16:44:24 -04:00
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
CustomProperties cps = null;
|
2003-10-23 16:44:24 -04:00
|
|
|
if (getSectionCount() >= 2)
|
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
cps = new CustomProperties();
|
2003-10-23 16:44:24 -04:00
|
|
|
final Section section = (Section) getSections().get(1);
|
2006-03-03 11:57:55 -05:00
|
|
|
final Map dictionary = section.getDictionary();
|
|
|
|
final Property[] properties = section.getProperties();
|
|
|
|
int propertyCount = 0;
|
|
|
|
for (int i = 0; i < properties.length; i++)
|
2003-10-23 16:44:24 -04:00
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
final Property p = properties[i];
|
|
|
|
final long id = p.getID();
|
|
|
|
if (id != 0 && id != 1)
|
2003-10-23 16:44:24 -04:00
|
|
|
{
|
2006-03-03 11:57:55 -05:00
|
|
|
propertyCount++;
|
|
|
|
final CustomProperty cp = new CustomProperty(p,
|
|
|
|
(String) dictionary.get(new Long(id)));
|
|
|
|
cps.put(cp.getName(), cp);
|
2003-10-23 16:44:24 -04:00
|
|
|
}
|
|
|
|
}
|
2006-03-03 11:57:55 -05:00
|
|
|
if (cps.size() != propertyCount)
|
|
|
|
cps.setPure(false);
|
|
|
|
}
|
|
|
|
return cps;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Sets the custom properties.</p>
|
|
|
|
*
|
|
|
|
* @param customProperties The custom properties
|
|
|
|
* @since 2006-02-07
|
|
|
|
*/
|
|
|
|
public void setCustomProperties(final CustomProperties customProperties)
|
|
|
|
{
|
|
|
|
ensureSection2();
|
|
|
|
final MutableSection section = (MutableSection) getSections().get(1);
|
|
|
|
final Map dictionary = customProperties.getDictionary();
|
|
|
|
section.clear();
|
|
|
|
|
|
|
|
/* Set the codepage. If both custom properties and section have a
|
|
|
|
* codepage, the codepage from the custom properties wins, else take the
|
|
|
|
* one that is defined. If none is defined, take Unicode. */
|
|
|
|
int cpCodepage = customProperties.getCodepage();
|
|
|
|
if (cpCodepage < 0)
|
|
|
|
cpCodepage = section.getCodepage();
|
|
|
|
if (cpCodepage < 0)
|
|
|
|
cpCodepage = Constants.CP_UNICODE;
|
|
|
|
customProperties.setCodepage(cpCodepage);
|
|
|
|
section.setCodepage(cpCodepage);
|
|
|
|
section.setDictionary(dictionary);
|
|
|
|
for (final Iterator i = customProperties.values().iterator(); i.hasNext();)
|
|
|
|
{
|
|
|
|
final Property p = (Property) i.next();
|
|
|
|
section.setProperty(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Creates section 2 if it is not already present.</p>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
private void ensureSection2()
|
|
|
|
{
|
|
|
|
if (getSectionCount() < 2)
|
|
|
|
{
|
|
|
|
MutableSection s2 = new MutableSection();
|
|
|
|
s2.setFormatID(SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID[1]);
|
|
|
|
addSection(s2);
|
2003-10-23 16:44:24 -04:00
|
|
|
}
|
2006-03-03 11:57:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Removes the custom properties.</p>
|
|
|
|
*
|
|
|
|
* @since 2006-02-08
|
|
|
|
*/
|
|
|
|
public void removeCustomProperties()
|
|
|
|
{
|
|
|
|
if (getSectionCount() >= 2)
|
|
|
|
getSections().remove(1);
|
|
|
|
else
|
|
|
|
throw new HPSFRuntimeException("Illegal internal format of Document SummaryInformation stream: second section is missing.");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Throws an {@link UnsupportedOperationException} with a message text
|
|
|
|
* telling which functionality is not yet implemented.</p>
|
|
|
|
*
|
|
|
|
* @param msg text telling was leaves to be implemented, e.g.
|
|
|
|
* "Reading byte arrays".
|
|
|
|
*/
|
|
|
|
private void notYetImplemented(final String msg)
|
|
|
|
{
|
|
|
|
throw new UnsupportedOperationException(msg + " is not yet implemented.");
|
2003-10-23 16:44:24 -04:00
|
|
|
}
|
|
|
|
|
2002-02-13 23:00:59 -05:00
|
|
|
}
|