/// <summary>
/// Creates a new summary information
/// </summary>
/// <returns>the new summary information.</returns>
public static SummaryInformation CreateSummaryInformation()
{
MutablePropertySet ps = new MutablePropertySet();
MutableSection s = (MutableSection)ps.FirstSection;
s.SetFormatID(SectionIDMap.SUMMARY_INFORMATION_ID);
try
{
return new SummaryInformation(ps);
}
catch (UnexpectedPropertySetTypeException ex)
{
/* This should never happen. */
throw new HPSFRuntimeException(ex);
}
}
/// <summary>
/// Creates a new document summary information.
/// </summary>
/// <returns>the new document summary information.</returns>
public static DocumentSummaryInformation CreateDocumentSummaryInformation()
{
MutablePropertySet ps = new MutablePropertySet();
MutableSection s = (MutableSection)ps.FirstSection;
s.SetFormatID(SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID1);
try
{
return(new DocumentSummaryInformation(ps));
}
catch (UnexpectedPropertySetTypeException ex)
{
/* This should never happen. */
throw new HPSFRuntimeException(ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecialPropertySet"/> class.
/// </summary>
/// <param name="ps">The mutable property Set To be encapsulated by the <c>SpecialPropertySet</c></param>
public SpecialPropertySet(MutablePropertySet ps)
{
delegate1 = ps;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecialPropertySet"/> class.
/// </summary>
/// <param name="ps">The property Set To be encapsulated by the <c>SpecialPropertySet</c></param>
public SpecialPropertySet(PropertySet ps)
{
delegate1 = new MutablePropertySet(ps);
}
/// <summary>
/// Writes out a given ProperySet
/// </summary>
/// <param name="name">the (POIFS Level) name of the property to Write.</param>
/// <param name="Set">the PropertySet to Write out.</param>
/// <param name="outFS">the POIFSFileSystem to Write the property into.</param>
protected void WritePropertySet(String name, PropertySet Set, POIFSFileSystem outFS)
{
try
{
MutablePropertySet mSet = new MutablePropertySet(Set);
MemoryStream bOut = new MemoryStream();
mSet.Write(bOut);
byte[] data = bOut.ToArray();
MemoryStream bIn = new MemoryStream(data);
outFS.CreateDocument(bIn, name);
//logger.Log(POILogger.INFO, "Wrote property Set " + name + " of size " + data.Length);
}
catch (WritingNotSupportedException)
{
Console.Error.WriteLine("Couldn't Write property Set with name " + name + " as not supported by HPSF yet");
}
}
public void TestDictionaryWithInvalidCodepage()
{
try
{
FileStream copy = File.Create( @"\Test-HPSF.ole2");
//copy.deleteOnExit();
/* Write: */
FileStream out1 = copy;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps1 = new MutablePropertySet();
MutableSection s = (MutableSection)ps1.Sections[0];
Hashtable m = new Hashtable(3, 1.0f);
m[1] = "String 1";
m[2] = "String 2";
m[3] = "String 3";
s.Dictionary = (m);
s.SetFormatID(SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID1);
int codepage = 12345;
s.SetProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2,
codepage);
poiFs.CreateDocument(ps1.GetStream(), "Test");
poiFs.WriteFileSystem(out1);
out1.Close();
Assert.Fail("This Testcase did not detect the invalid codepage value.");
}
catch (IllegalPropertySetDataException)
{
//Assert.IsTrue(true);
}
}
public void TestDictionary()
{
FileStream copy = File.Create( @"\Test-HPSF.ole2");
//copy.deleteOnExit();
/* Write: */
FileStream out1 = copy;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps1 = new MutablePropertySet();
MutableSection s = (MutableSection)ps1.Sections[0];
Hashtable m = new Hashtable(3, 1.0f);
m[1] = "String 1";
m[2] = "String 2";
m[3] = "String 3";
s.Dictionary = (m);
s.SetFormatID(SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID1);
int codepage = (int)Constants.CP_UNICODE;
s.SetProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2,
codepage);
poiFs.CreateDocument(ps1.GetStream(), "Test");
poiFs.WriteFileSystem(out1);
/* Read back: */
POIFile[] psf = Util.ReadPropertySets(copy);
Assert.AreEqual(1, psf.Length);
byte[] bytes = psf[0].GetBytes();
Stream in1 = new ByteArrayInputStream(bytes);
PropertySet ps2 = PropertySetFactory.Create(in1);
/* Check if the result is a DocumentSummaryInformation stream, as
* specified. */
Assert.IsTrue(ps2.IsDocumentSummaryInformation);
/* Compare the property Set stream with the corresponding one
* from the origin file and check whether they are equal. */
Assert.IsTrue(ps1.Equals(ps2));
out1.Close();
copy.Close();
File.Delete( @"\Test-HPSF.ole2");
}
/**
* Performs the check described in {@link #TestReCreate()} for a single
* POI filesystem.
*
* @param f the POI filesystem to check
*/
private void TestRecreate(FileInfo f)
{
Console.WriteLine("Recreating file \"" + f.Name + "\"");
/* Read the POI filesystem's property Set streams: */
POIFile[] psf1 = Util.ReadPropertySets(_samples.GetFile(f.Name));
/* Create a new POI filesystem containing the origin file's
* property Set streams: */
FileInfo fi = new FileInfo(f.Name);
FileStream copy = File.Create(fi.Name);
//copy.deleteOnExit();
FileStream out1 = copy;
POIFSFileSystem poiFs = new POIFSFileSystem();
for (int i = 0; i < psf1.Length; i++)
{
Stream in1 =
new ByteArrayInputStream(psf1[i].GetBytes());
PropertySet psIn = PropertySetFactory.Create(in1);
MutablePropertySet psOut = new MutablePropertySet(psIn);
MemoryStream psStream =
new MemoryStream();
psOut.Write(psStream);
psStream.Close();
byte[] streamData = psStream.ToArray();
poiFs.CreateDocument(new ByteArrayInputStream(streamData),
psf1[i].GetName());
poiFs.WriteFileSystem(out1);
}
/* Read the property Set streams from the POI filesystem just
* Created. */
POIFile[] psf2 = Util.ReadPropertySets(copy);
for (int i = 0; i < psf2.Length; i++)
{
byte[] bytes1 = psf1[i].GetBytes();
byte[] bytes2 = psf2[i].GetBytes();
Stream in1 = new ByteArrayInputStream(bytes1);
Stream in2 = new ByteArrayInputStream(bytes2);
PropertySet ps1 = PropertySetFactory.Create(in1);
PropertySet ps2 = PropertySetFactory.Create(in2);
/* Compare the property Set stream with the corresponding one
* from the origin file and check whether they are equal. */
Assert.AreEqual(ps1, ps2, "Equality for file " + f.Name);
}
out1.Close();
}
public void TestUnicodeWrite8Bit()
{
String TITLE = "This is a sample title";
MutablePropertySet mps = new MutablePropertySet();
MutableSection ms = (MutableSection)mps.Sections[0];
ms.SetFormatID(SectionIDMap.SUMMARY_INFORMATION_ID);
MutableProperty p = new MutableProperty();
p.ID = PropertyIDMap.PID_TITLE;
p.Type = Variant.VT_LPSTR;
p.Value = TITLE;
ms.SetProperty(p);
Exception t = null;
try
{
MemoryStream out1 = new MemoryStream();
mps.Write(out1);
out1.Close();
byte[] bytes = out1.ToArray();
PropertySet psr = new PropertySet(bytes);
Assert.IsTrue(psr.IsSummaryInformation);
Section sr = (Section)psr.Sections[0];
String title = (String)sr.GetProperty(PropertyIDMap.PID_TITLE);
Assert.AreEqual(TITLE, title);
}
catch (WritingNotSupportedException e)
{
t = e;
}
catch (IOException e)
{
t = e;
}
catch (NoPropertySetStreamException e)
{
t = e;
}
if (t != null)
Assert.Fail(t.Message);
}
public void TestWriteTwoSections()
{
String STREAM_NAME = "PropertySetStream";
String SECTION1 = "Section 1";
String SECTION2 = "Section 2";
FileInfo fi = TempFile.CreateTempFile(POI_FS, ".doc");
FileStream file = new FileStream(fi.FullName, FileMode.Open, FileAccess.ReadWrite);
//filename.deleteOnExit();
FileStream out1 = file;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps = new MutablePropertySet();
ps.ClearSections();
ClassID formatID = new ClassID();
formatID.Bytes = new byte[]{0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15};
MutableSection s1 = new MutableSection();
s1.SetFormatID(formatID);
s1.SetProperty(2, SECTION1);
ps.AddSection(s1);
MutableSection s2 = new MutableSection();
s2.SetFormatID(formatID);
s2.SetProperty(2, SECTION2);
ps.AddSection(s2);
poiFs.CreateDocument(ps.GetStream(), STREAM_NAME);
poiFs.WriteFileSystem(out1);
//out1.Close();
/* Read the POIFS: */
psa = new PropertySet[1];
POIFSReader reader2 = new POIFSReader();
//reader2.StreamReaded += new POIFSReaderEventHandler(reader2_StreamReaded);
POIFSReaderListener2 prl = new POIFSReaderListener2();
reader2.RegisterListener(prl);
reader2.Read(file);
Assert.IsNotNull(psa[0]);
Section s = (Section)(psa[0].Sections[0]);
Assert.AreEqual(s.FormatID, formatID);
Object p = s.GetProperty(2);
Assert.AreEqual(SECTION1, p);
s = (Section)(psa[0].Sections[1]);
p = s.GetProperty(2);
Assert.AreEqual(SECTION2, p);
file.Close();
//File.Delete(dataDir + POI_FS);
try
{
File.Delete(fi.FullName);
}
catch
{
}
}
public void TestWriteSimplePropertySet()
{
String AUTHOR = "Rainer Klute";
String TITLE = "Test Document";
FileInfo fi = TempFile.CreateTempFile(POI_FS, ".doc");
FileStream file = new FileStream(fi.FullName, FileMode.Open, FileAccess.ReadWrite);
FileStream out1 = file;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps = new MutablePropertySet();
MutableSection si = new MutableSection();
si.SetFormatID(SectionIDMap.SUMMARY_INFORMATION_ID);
ps.Sections[0] = si;
MutableProperty p = new MutableProperty();
p.ID = PropertyIDMap.PID_AUTHOR;
p.Type = Variant.VT_LPWSTR;
p.Value = AUTHOR;
si.SetProperty(p);
si.SetProperty(PropertyIDMap.PID_TITLE, Variant.VT_LPSTR, TITLE);
poiFs.CreateDocument(ps.GetStream(),
SummaryInformation.DEFAULT_STREAM_NAME);
poiFs.WriteFileSystem(out1);
//out1.Close();
file.Position = 0;
POIFSReader reader1 = new POIFSReader();
//reader1.StreamReaded += new POIFSReaderEventHandler(reader1_StreamReaded);
POIFSReaderListener1 psl = new POIFSReaderListener1();
reader1.RegisterListener(psl);
reader1.Read(file);
Assert.IsNotNull(psa[0]);
Assert.IsTrue(psa[0].IsSummaryInformation);
Section s = (Section)(psa[0].Sections[0]);
Object p1 = s.GetProperty(PropertyIDMap.PID_AUTHOR);
Object p2 = s.GetProperty(PropertyIDMap.PID_TITLE);
Assert.AreEqual(AUTHOR, p1);
Assert.AreEqual(TITLE, p2);
file.Close();
try
{
File.Delete(fi.FullName);
}
catch
{
}
}
public void TestWriteEmptyPropertySet()
{
FileInfo fi = TempFile.CreateTempFile(POI_FS, ".doc");
using (FileStream file = new FileStream(fi.FullName, FileMode.Open, FileAccess.ReadWrite))
{
//filename.deleteOnExit();
/* Create a mutable property Set and Write it to a POIFS: */
FileStream out1 = file;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps = new MutablePropertySet();
MutableSection s = (MutableSection)ps.Sections[0];
s.SetFormatID(SectionIDMap.SUMMARY_INFORMATION_ID);
MemoryStream psStream = new MemoryStream();
ps.Write(psStream);
psStream.Close();
byte[] streamData = psStream.ToArray();
poiFs.CreateDocument(new MemoryStream(streamData),
SummaryInformation.DEFAULT_STREAM_NAME);
poiFs.WriteFileSystem(out1);
//out1.Close();
file.Position = 0;
/* Read the POIFS: */
POIFSReader reader3 = new POIFSReader();
reader3.StreamReaded += new POIFSReaderEventHandler(reader3_StreamReaded);
reader3.Read(file);
file.Close();
//File.Delete(dataDir + POI_FS);
}
try
{
File.Delete(fi.FullName);
}
catch
{
}
}
public void TestNoFormatID()
{
FileInfo fi = TempFile.CreateTempFile(POI_FS, ".doc");
using (FileStream file = new FileStream(fi.FullName, FileMode.Open, FileAccess.ReadWrite))
{
//FileStream filename = File.OpenRead(dataDir + POI_FS);
//filename.deleteOnExit();
/* Create a mutable property Set with a section that does not have the
* formatID Set: */
FileStream out1 = file;
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps = new MutablePropertySet();
ps.ClearSections();
ps.AddSection(new MutableSection());
/* Write it to a POIFS and the latter to disk: */
try
{
MemoryStream psStream = new MemoryStream();
ps.Write(psStream);
psStream.Close();
byte[] streamData = psStream.ToArray();
poiFs.CreateDocument(new MemoryStream(streamData),
SummaryInformation.DEFAULT_STREAM_NAME);
poiFs.WriteFileSystem(out1);
out1.Close();
Assert.Fail("Should have thrown a NoFormatIDException.");
}
catch (Exception ex)
{
Assert.IsTrue(ex is NoFormatIDException);
}
finally
{
out1.Close();
}
}
try
{
File.Delete(fi.FullName);
}
catch
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecialPropertySet"/> class.
/// </summary>
/// <param name="ps">The mutable property Set To be encapsulated by the <c>SpecialPropertySet</c></param>
public SpecialPropertySet(MutablePropertySet ps)
{
delegate1 = ps;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecialPropertySet"/> class.
/// </summary>
/// <param name="ps">The property Set To be encapsulated by the <c>SpecialPropertySet</c></param>
public SpecialPropertySet(PropertySet ps)
{
delegate1 = new MutablePropertySet(ps);
}
public void TestDictionaryWithInvalidCodepage()
{
using (FileStream copy = File.Create(@".\Test-HPSF.ole2"))
{
/* Write: */
POIFSFileSystem poiFs = new POIFSFileSystem();
MutablePropertySet ps1 = new MutablePropertySet();
MutableSection s = (MutableSection)ps1.Sections[0];
Hashtable m = new Hashtable(3, 1.0f);
m[1] = "String 1";
m[2] = "String 2";
m[3] = "String 3";
try
{
s.Dictionary = m;
s.SetFormatID(SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID1);
s.SetProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2, 12345);
poiFs.CreateDocument(ps1.ToInputStream(), "Test");
poiFs.WriteFileSystem(copy);
Assert.Fail("This Testcase did not detect the invalid codepage value.");
}
catch (IllegalPropertySetDataException)
{
Assert.IsTrue(true);
}
}
if (File.Exists(@".\Test-HPSF.ole2"))
{
File.Delete(@".\Test-HPSF.ole2");
}
}
