public static int Write(HWPFStream tableStream, String[] entries) { byte[] header = new byte[6]; LittleEndian.PutShort(header, 0, unchecked ((short)0xffff)); if (entries == null || entries.Length == 0) { LittleEndian.PutInt(header, 2, 0); tableStream.Write(header); return(6); } LittleEndian.PutInt(header, 2, entries.Length); tableStream.Write(header); int size = 6; foreach (String entry in entries) { byte[] buf = new byte[entry.Length * 2 + 2]; LittleEndian.PutShort(buf, 0, (short)entry.Length); StringUtil.PutUnicodeLE(entry, buf, 2); tableStream.Write(buf); size += buf.Length; } return(size); }
public void WriteTo(HWPFStream out1) { int offset = 0; // add two bytes so we can prepend the stylesheet w/ its size byte[] buf = new byte[_stshiLength + 2]; LittleEndian.PutShort(buf, offset, (short)_stshiLength); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_styleDescriptions.Length); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_baseLength); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_flags); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_maxIndex); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_maxFixedIndex); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_stylenameVersion); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_rgftc[0]); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_rgftc[1]); offset += LittleEndianConsts.SHORT_SIZE; LittleEndian.PutShort(buf, offset, (short)_rgftc[2]); out1.Write(buf); byte[] sizeHolder = new byte[2]; for (int x = 0; x < _styleDescriptions.Length; x++) { if (_styleDescriptions[x] != null) { byte[] std = _styleDescriptions[x].ToArray(); // adjust the size so it is always on a word boundary LittleEndian.PutShort(sizeHolder, (short)((std.Length) + (std.Length % 2))); out1.Write(sizeHolder); out1.Write(std); // Must always start on a word boundary. if (std.Length % 2 == 1) { out1.Write('\0'); } } else { sizeHolder[0] = 0; sizeHolder[1] = 0; out1.Write(sizeHolder); } } }
public void WriteTo(HWPFStream wordDocumentStream, HWPFStream tableStream) { tableStream.Write(TEXT_PIECE_TABLE_TYPE); byte[] table = _tpt.WriteTo(wordDocumentStream); byte[] numHolder = new byte[LittleEndianConsts.INT_SIZE]; LittleEndian.PutInt(numHolder, 0, table.Length); tableStream.Write(numHolder); tableStream.Write(table); }
public void WriteTo(HWPFFileSystem sys, int fcMin) { HWPFStream docStream = sys.GetStream("WordDocument"); Stream tableStream = sys.GetStream("1Table"); PlexOfCps binTable = new PlexOfCps(4); // each FKP must start on a 512 byte page. int docOffset = docStream.Offset; int mod = docOffset % POIFSConstants.SMALLER_BIG_BLOCK_SIZE; if (mod != 0) { byte[] pAdding = new byte[POIFSConstants.SMALLER_BIG_BLOCK_SIZE - mod]; docStream.Write(pAdding); } // get the page number for the first fkp docOffset = docStream.Offset; int pageNum = docOffset / POIFSConstants.SMALLER_BIG_BLOCK_SIZE; // get the ending fc int endingFc = ((PropertyNode)_textRuns[_textRuns.Count - 1]).End; endingFc += fcMin; List <CHPX> overflow = _textRuns; do { PropertyNode startingProp = (PropertyNode)overflow[0]; int start = startingProp.Start + fcMin; CHPFormattedDiskPage cfkp = new CHPFormattedDiskPage(); cfkp.Fill(overflow); byte[] bufFkp = cfkp.ToArray(fcMin); docStream.Write(bufFkp); overflow = cfkp.GetOverflow(); int end = endingFc; if (overflow != null) { end = ((PropertyNode)overflow[0]).Start + fcMin; } byte[] intHolder = new byte[4]; LittleEndian.PutInt(intHolder, pageNum++); binTable.AddProperty(new GenericPropertyNode(start, end, intHolder)); }while (overflow != null); byte[] bytes = binTable.ToByteArray(); tableStream.Write(bytes, 0, bytes.Length); }
public void WriteTo(HWPFStream docStream, HWPFStream tableStream, CharIndexTranslator translator) { PlexOfCps binTable = new PlexOfCps(4); // each FKP must start on a 512 byte page. int docOffset = docStream.Offset; int mod = docOffset % POIFSConstants.SMALLER_BIG_BLOCK_SIZE; if (mod != 0) { byte[] pAdding = new byte[POIFSConstants.SMALLER_BIG_BLOCK_SIZE - mod]; docStream.Write(pAdding); } // get the page number for the first fkp docOffset = docStream.Offset; int pageNum = docOffset / POIFSConstants.SMALLER_BIG_BLOCK_SIZE; // get the ending fc int endingFc = ((PropertyNode)_paragraphs[_paragraphs.Count - 1]).End; List <PAPX> overflow = _paragraphs; do { PropertyNode startingProp = (PropertyNode)overflow[0]; int start = translator.GetByteIndex(startingProp.Start); PAPFormattedDiskPage pfkp = new PAPFormattedDiskPage(_dataStream); pfkp.Fill(overflow); byte[] bufFkp = pfkp.ToByteArray(tableStream, translator); docStream.Write(bufFkp); overflow = pfkp.GetOverflow(); int end = endingFc; if (overflow != null) { end = translator.GetByteIndex(overflow[0].Start); } byte[] intHolder = new byte[4]; LittleEndian.PutInt(intHolder, pageNum++); binTable.AddProperty(new GenericPropertyNode(start, end, intHolder)); }while (overflow != null); byte[] bytes = binTable.ToByteArray(); tableStream.Write(bytes, 0, bytes.Length); }
public void WriteTo(HWPFFileSystem sys) { HWPFStream tableStream = sys.GetStream("1Table"); byte[] buf = new byte[LittleEndianConsts.SHORT_SIZE]; LittleEndian.PutShort(buf, 0, _stringCount); tableStream.Write(buf); LittleEndian.PutShort(buf, 0, _extraDataSz); tableStream.Write(buf); for (int i = 0; i < _fontNames.Length; i++) { tableStream.Write(_fontNames[i].ToArray()); } }
/** * Writes this table to the table stream. * * @param tableStream the table stream to write to. * @throws IOException if an error occurs while writing. */ public void WriteTo(HWPFStream tableStream) { byte[] header = new byte[6]; LittleEndian.PutShort(header, 0, fExtend); LittleEndian.PutShort(header, 2, cData); LittleEndian.PutShort(header, 4, cbExtra); tableStream.Write(header); foreach (String name in entries) { byte[] buf = new byte[name.Length * 2 + 2]; LittleEndian.PutShort(buf, 0, (short)name.Length); StringUtil.PutUnicodeLE(name, buf, 2); tableStream.Write(buf); } }
private void WriteStringValue(HWPFStream tableStream, String value) { byte[] buf = new byte[value.Length * 2 + 2]; LittleEndian.PutShort(buf, 0, (short)value.Length); StringUtil.PutUnicodeLE(value, buf, 2); tableStream.Write(buf); }
internal void WriteTo(byte[] mainStream, int offset, HWPFStream tableStream) { int length = _fields.Length / 2; LittleEndian.PutShort(mainStream, offset, (short)length); offset += LittleEndianConsts.SHORT_SIZE; for (int x = 0; x < length; x++) { UnhandledDataStructure ds = (UnhandledDataStructure)_unknownMap[x]; if (ds != null) { LittleEndian.PutInt(mainStream, offset, tableStream.Offset); offset += LittleEndianConsts.INT_SIZE; byte[] buf = ds.GetBuf(); tableStream.Write(buf); LittleEndian.PutInt(mainStream, offset, buf.Length); offset += LittleEndianConsts.INT_SIZE; } else { LittleEndian.PutInt(mainStream, offset, _fields[x * 2]); offset += LittleEndianConsts.INT_SIZE; LittleEndian.PutInt(mainStream, offset, _fields[(x * 2) + 1]); offset += LittleEndianConsts.INT_SIZE; } } }
public void WriteTo(HWPFFileSystem sys, int fcMin) { HWPFStream docStream = sys.GetStream("WordDocument"); HWPFStream tableStream = sys.GetStream("1Table"); int offset = docStream.Offset; int len = _sections.Count; PlexOfCps plex = new PlexOfCps(SED_SIZE); for (int x = 0; x < len; x++) { SEPX sepx = _sections[x]; byte[] grpprl = sepx.GetGrpprl(); // write the sepx to the document stream. starts with a 2 byte size // followed by the grpprl byte[] shortBuf = new byte[2]; LittleEndian.PutShort(shortBuf, (short)grpprl.Length); docStream.Write(shortBuf); docStream.Write(grpprl); // set the fc in the section descriptor SectionDescriptor sed = sepx.GetSectionDescriptor(); sed.SetFc(offset); // add the section descriptor bytes to the PlexOfCps. // original line - //GenericPropertyNode property = new GenericPropertyNode(sepx.Start, sepx.End, sed.ToArray()); // Line using Ryan's FCtoCP() conversion method - // unable to observe any effect on our testcases when using this code - piers GenericPropertyNode property = new GenericPropertyNode(tpt.GetCharIndex(sepx.StartBytes), tpt.GetCharIndex(sepx.EndBytes), sed.ToArray()); plex.AddProperty(property); offset = docStream.Offset; } tableStream.Write(plex.ToByteArray()); }
/** * Writes this table to the table stream. * * @param tableStream the table stream to write to. * @throws IOException if an error occurs while writing. */ public void WriteTo(HWPFStream tableStream) { byte[] header = new byte[6]; LittleEndian.PutShort(header, 0, unknownValue); LittleEndian.PutInt(header, 2, entries.Length * 2); tableStream.Write(header); for (int i = 0; i < entries.Length; i++) { WriteStringValue(tableStream, entries[i].GetUserName()); WriteStringValue(tableStream, entries[i].GetSaveLocation()); } }
public byte[] WriteTo(HWPFStream docStream) { PlexOfCps textPlex = new PlexOfCps(PieceDescriptor.SizeInBytes); // int fcMin = docStream.Getoffset(); int size = _textPieces.Count; for (int x = 0; x < size; x++) { TextPiece next = _textPieces[x]; PieceDescriptor pd = next.PieceDescriptor; int offset = docStream.Offset; int mod = (offset % POIFSConstants.SMALLER_BIG_BLOCK_SIZE); if (mod != 0) { mod = POIFSConstants.SMALLER_BIG_BLOCK_SIZE - mod; byte[] buf = new byte[mod]; docStream.Write(buf); } // set the text piece position to the current docStream offset. pd.FilePosition = (docStream.Offset); // write the text to the docstream and save the piece descriptor to // the // plex which will be written later to the tableStream. docStream.Write(next.RawBytes); // The TextPiece is already in characters, which // Makes our life much easier int nodeStart = next.Start; int nodeEnd = next.End; textPlex.AddProperty(new GenericPropertyNode(nodeStart, nodeEnd, pd.ToByteArray())); } return textPlex.ToByteArray(); }
public void TestReadWriteFromNonZeroOffset() { HWPFFileSystem fileSys = new HWPFFileSystem(); HWPFStream tableOut = fileSys.GetStream("1Table"); tableOut.Write(new byte[20]); // 20 bytes of whatever at the front. _styleSheet.WriteTo(tableOut); byte[] newTableStream = tableOut.ToArray(); StyleSheet newStyleSheet = new StyleSheet(newTableStream, 20); Assert.AreEqual(newStyleSheet, _styleSheet); }
public void WriteListDataTo(HWPFStream tableStream) { int listSize = _listMap.Count; // use this stream as a buffer for the levels since their size varies. MemoryStream levelBuf = new MemoryStream(); byte[] shortHolder = new byte[2]; LittleEndian.PutShort(shortHolder, 0, (short)listSize); tableStream.Write(shortHolder); //TODO:: sort the keys foreach (int x in _listMap.Keys) { ListData lst = _listMap[x]; tableStream.Write(lst.ToArray()); ListLevel[] lvls = lst.GetLevels(); for (int y = 0; y < lvls.Length; y++) { byte[] bytes = lvls[y].ToArray(); levelBuf.Write(bytes, 0, bytes.Length); } } tableStream.Write(levelBuf.ToArray()); }
public void WriteListOverridesTo(HWPFStream tableStream) { // use this stream as a buffer for the levels since their size varies. MemoryStream levelBuf = new MemoryStream(); int size = _overrideList.Count; byte[] intHolder = new byte[4]; LittleEndian.PutInt(intHolder, 0, size); tableStream.Write(intHolder); for (int x = 0; x < size; x++) { ListFormatOverride lfo = _overrideList[x]; tableStream.Write(lfo.ToArray()); ListFormatOverrideLevel[] lfolvls = lfo.GetLevelOverrides(); for (int y = 0; y < lfolvls.Length; y++) { byte[] bytes = lfolvls[y].ToArray(); levelBuf.Write(bytes, 0, bytes.Length); } } tableStream.Write(levelBuf.ToArray()); }
public void WriteRef(FileInformationBlock fib, HWPFStream tableStream) { if (descriptors == null || descriptors.Length == 0) { fib.SetNotesDescriptorsOffset(noteType, tableStream.Offset); fib.SetNotesDescriptorsSize(noteType, 0); return; } int start = tableStream.Offset; byte[] data = descriptors.ToByteArray(); tableStream.Write(data); int end = tableStream.Offset; fib.SetNotesDescriptorsOffset(noteType, start); fib.SetNotesDescriptorsSize(noteType, end - start); }
public void WriteTxt(FileInformationBlock fib, HWPFStream tableStream) { if (textPositions == null || textPositions.Length == 0) { fib.SetNotesTextPositionsOffset(noteType, tableStream.Offset); fib.SetNotesTextPositionsSize(noteType, 0); return; } int start = tableStream.Offset; byte[] data = textPositions.ToByteArray(); tableStream.Write(data); int end = tableStream.Offset; fib.SetNotesTextPositionsOffset(noteType, start); fib.SetNotesTextPositionsSize(noteType, end - start); }
public void WritePlcfBkmkl(FileInformationBlock fib, HWPFStream tableStream) { if (descriptorsLim == null || descriptorsLim.Length == 0) { fib.SetFcPlcfbkl(0); fib.SetLcbPlcfbkl(0); return; } int start = tableStream.Offset; tableStream.Write(descriptorsLim.ToByteArray()); int end = tableStream.Offset; fib.SetFcPlcfbkl(start); fib.SetLcbPlcfbkl(end - start); }
private int SavePlex(FileInformationBlock fib, FieldsDocumentPart part, PlexOfCps plexOfCps, HWPFStream outputStream) { if (plexOfCps == null || plexOfCps.Length == 0) { fib.SetFieldsPlcfOffset(part, outputStream.Offset); fib.SetFieldsPlcfLength(part, 0); return(0); } byte[] data = plexOfCps.ToByteArray(); int start = outputStream.Offset; int length = data.Length; outputStream.Write(data); fib.SetFieldsPlcfOffset(part, start); fib.SetFieldsPlcfLength(part, length); return(length); }
/** * Creates a byte array representation of this data structure. Suitable for * writing to a Word document. * * @param fcMin The file offset in the main stream where text begins. * @return A byte array representing this data structure. */ internal byte[] ToByteArray(HWPFStream dataStream, CharIndexTranslator translator) { byte[] buf = new byte[512]; int size = _papxList.Count; int grpprlOffset = 0; int bxOffset = 0; int fcOffset = 0; byte[] lastGrpprl = new byte[0]; // total size is currently the size of one FC int totalSize = FC_SIZE; int index = 0; for (; index < size; index++) { byte[] grpprl = ((PAPX)_papxList[index]).GetGrpprl(); int grpprlLength = grpprl.Length; // is grpprl huge? if (grpprlLength > 488) { grpprlLength = 8; // set equal to size of sprmPHugePapx grpprl } // check to see if we have enough room for an FC, a BX, and the grpprl // and the 1 byte size of the grpprl. int addition = 0; if (!Arrays.Equals(grpprl, lastGrpprl)) { addition = (FC_SIZE + BX_SIZE + grpprlLength + 1); } else { addition = (FC_SIZE + BX_SIZE); } totalSize += addition; // if size is uneven we will have to add one so the first grpprl falls // on a word boundary if (totalSize > 511 + (index % 2)) { totalSize -= addition; break; } // grpprls must fall on word boundaries if (grpprlLength % 2 > 0) { totalSize += 1; } else { totalSize += 2; } lastGrpprl = grpprl; } // see if we couldn't fit some if (index != size) { _overFlow = new List <PAPX>(); _overFlow.AddRange(_papxList.GetRange(index, size - index)); } // index should equal number of papxs that will be in this fkp now. buf[511] = (byte)index; bxOffset = (FC_SIZE * index) + FC_SIZE; grpprlOffset = 511; PAPX papx = null; lastGrpprl = new byte[0]; for (int x = 0; x < index; x++) { papx = _papxList[x]; byte[] phe = papx.GetParagraphHeight().ToArray(); byte[] grpprl = papx.GetGrpprl(); // is grpprl huge? if (grpprl.Length > 488) { /* * // if so do we have storage at GetHugeGrpprloffset() * int hugeGrpprlOffset = papx.GetHugeGrpprlOffset(); * if (hugeGrpprlOffset == -1) // then we have no storage... * { * throw new InvalidOperationException( * "This Paragraph has no dataStream storage."); * } * // we have some storage... * * // get the size of the existing storage * int maxHugeGrpprlSize = LittleEndian.GetUShort(_dataStream, hugeGrpprlOffset); * * if (maxHugeGrpprlSize < grpprl.Length - 2) * { // grpprl.Length-2 because we don't store the istd * throw new InvalidOperationException( * "This Paragraph's dataStream storage is too small."); * } * * * // store grpprl at hugeGrpprlOffset * Array.Copy(grpprl, 2, _dataStream, hugeGrpprlOffset + 2, * grpprl.Length - 2); // grpprl.Length-2 because we don't store the istd * LittleEndian.PutUShort(_dataStream, hugeGrpprlOffset, grpprl.Length - 2); */ byte[] hugePapx = new byte[grpprl.Length - 2]; System.Array.Copy(grpprl, 2, hugePapx, 0, grpprl.Length - 2); int dataStreamOffset = dataStream.Offset; dataStream.Write(hugePapx); // grpprl = grpprl Containing only a sprmPHugePapx2 int istd = LittleEndian.GetUShort(grpprl, 0); grpprl = new byte[8]; LittleEndian.PutUShort(grpprl, 0, istd); LittleEndian.PutUShort(grpprl, 2, 0x6646); // sprmPHugePapx2 LittleEndian.PutInt(grpprl, 4, dataStreamOffset); } bool same = Arrays.Equals(lastGrpprl, grpprl); if (!same) { grpprlOffset -= (grpprl.Length + (2 - grpprl.Length % 2)); grpprlOffset -= (grpprlOffset % 2); } LittleEndian.PutInt(buf, fcOffset, translator.GetByteIndex(papx.Start)); buf[bxOffset] = (byte)(grpprlOffset / 2); Array.Copy(phe, 0, buf, bxOffset + 1, phe.Length); // refer to the section on PAPX in the spec. Places a size on the front // of the PAPX. Has to do with how the grpprl stays on word // boundaries. if (!same) { int copyOffset = grpprlOffset; if ((grpprl.Length % 2) > 0) { buf[copyOffset++] = (byte)((grpprl.Length + 1) / 2); } else { buf[++copyOffset] = (byte)((grpprl.Length) / 2); copyOffset++; } Array.Copy(grpprl, 0, buf, copyOffset, grpprl.Length); lastGrpprl = grpprl; } bxOffset += BX_SIZE; fcOffset += FC_SIZE; } LittleEndian.PutInt(buf, fcOffset, translator.GetByteIndex(papx.End)); return(buf); }