public WorkbookStream(string filePath) { using (var fs = new FileStream(filePath, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); try { var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); _biffRecords = RecordHelper.ParseBiffStreamBytes(wbBytes); } catch (StreamNotFoundException) { var wbStream = ssr.GetStream("Book"); Console.WriteLine("WARNING: Main stream is in a Book record indicating legacy Excel 5 BIFF format. This may not parse correctly."); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); try { _biffRecords = RecordHelper.ParseBiffStreamBytes(wbBytes); } catch (Exception) { throw new NotImplementedException("Error parsing Book stream: Macrome currently doesn't support the Excel 5 BIFF format."); } } } }
/// <summary> /// return MainDocumentPart from doc /// </summary> /// <param name="docData"></param> /// <returns></returns> public static XmlDocument GetXMLContent(byte[] docData) { using (Stream stream = new MemoryStream(docData)) { using (StructuredStorageReader reader = new StructuredStorageReader(stream)) { //parse the input document WordDocument doc = new WordDocument(reader); //prepare the output document OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(doc); //string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType); WordprocessingDocument docx = WordprocessingDocument.Create(outType); //start time //DateTime start = DateTime.Now; //TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile); //convert the document return(Converter.Convert(doc, docx)); //DateTime end = DateTime.Now; //TimeSpan diff = end.Subtract(start); //TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } } }
public void ParseabilityTest() { foreach (var inputFile in this.files) { var reader = new StructuredStorageReader(inputFile.FullName); var doc = new WordDocument(reader); } }
public MemoryStream ConvertFromStreamToDocxMemoryStream(Stream stream) { StructuredStorageReader reader = new StructuredStorageReader(stream); WordDocument doc = new WordDocument(reader); var docx = WordprocessingDocument.Create("docx", DocumentType.Document); Converter.Convert(doc, docx); return(new MemoryStream(docx.CloseWithoutSavingFile())); }
public WorkbookStream(string filePath) { using (var fs = new FileStream(filePath, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); _biffRecords = RecordHelper.ParseBiffStreamBytes(wbBytes); } }
public void SaveTest() { foreach (var inputFile in this.files) { var reader = new StructuredStorageReader(inputFile.FullName); var doc = new WordDocument(reader); // Create the output DOCX var docx = WordprocessingDocument.Create(inputFile.FullName + "x", DocumentType.Document); b2xtranslator.WordprocessingMLMapping.Converter.Convert(doc, docx); } }
public void DoTheMagic() { try { using (StructuredStorageReader reader = new StructuredStorageReader(this.Options.InputDocument)) { IStreamReader workbookReader = new VirtualStreamReader(reader.GetStream("Workbook")); using (StreamWriter sw = this.Options.Mode == BiffViewerMode.File ? File.CreateText(this.Options.OutputFileName) : new StreamWriter(Console.OpenStandardOutput())) { sw.AutoFlush = true; if (this.Options.PrintTextOnly) { PrintText(sw, workbookReader); } else { PrintHtml(sw, workbookReader); } if (!_isCancelled && this.Options.ShowInBrowser && this.Options.Mode == BiffViewerMode.File) { Util.VisitLink(this.Options.OutputFileName); } } } } catch (MagicNumberException ex) { if (this.Options.ShowErrors) { MessageBox.Show(string.Format("This file is not a valid Excel file ({0})", ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { Console.WriteLine(ex.ToString()); } } catch (Exception ex) { if (this.Options.ShowErrors) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { Console.WriteLine(ex.ToString()); } } }
private static WorkbookStream LoadDecoyDocument(string decoyDocPath) { using (var fs = new FileStream(decoyDocPath, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); WorkbookStream wbs = new WorkbookStream(wbBytes); return(wbs); } }
public static WorkbookStream GetMacroLoopWorkbookStream() { string template = AssemblyDirectory + Path.DirectorySeparatorChar + @"TestDocs\macro-loop.xls"; using (var fs = new FileStream(template, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); return(new WorkbookStream(wbBytes)); } }
public static byte[] GetAutoOpenTestBytes() { string template = AssemblyDirectory + Path.DirectorySeparatorChar + @"TestDocs\auto_open_test.xls"; using (var fs = new FileStream(template, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); return(wbBytes); } }
public static WorkbookStream GetMassSelectUDFArgumentSheet() { string template = AssemblyDirectory + Path.DirectorySeparatorChar + @"TestDocs\bug_report_1_mass_select_argument.xls"; using (var fs = new FileStream(template, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); return(new WorkbookStream(wbBytes)); } }
public void TestParseability() { foreach (FileInfo inputFile in this.files) { try { StructuredStorageReader reader = new StructuredStorageReader(inputFile.FullName); WordDocument doc = new WordDocument(reader); Console.WriteLine("PASSED TestParseability " + inputFile.FullName); } catch (Exception e) { throw new AssertionException(e.Message + inputFile.FullName, e); } } }
private static List<BiffRecord> GetDefaultMacroSheetRecords() { string defaultMacroPath = AssemblyDirectory + Path.DirectorySeparatorChar + @"default_macro_template.xls"; using (var fs = new FileStream(defaultMacroPath, FileMode.Open)) { StructuredStorageReader ssr = new StructuredStorageReader(fs); var wbStream = ssr.GetStream("Workbook"); byte[] wbBytes = new byte[wbStream.Length]; wbStream.Read(wbBytes, 0, wbBytes.Length, 0); WorkbookStream wbs = new WorkbookStream(wbBytes); //The last BOF/EOF set is our Macro sheet. List<BiffRecord> sheetRecords = wbs.GetRecordsForBOFRecord(wbs.GetAllRecordsByType<BOF>().Last()); return sheetRecords; } }
/// <summary> /// Converts from .doc to .docx and returns output (.docx) file name /// </summary> /// <param name="context"></param> /// <returns></returns> public string Convert(IConnectionContext context) { var outFile = Path.GetTempPath() + Guid.NewGuid() + ".docx"; var fileInfo = new FileInfo(context.Connection.File); context.Info("Converting doc to docx"); using (var reader = new StructuredStorageReader(fileInfo.FullName)) { var doc = new WordDocument(reader); var outType = Converter.DetectOutputType(doc); var conformOutputFile = Converter.GetConformFilename(outFile, outType); var docx = WordprocessingDocument.Create(conformOutputFile, outType); Converter.Convert(doc, docx); } return(outFile); }
private static void processFile(String InputFile) { // copy processing file ProcessingFile procFile = new ProcessingFile(InputFile); //make output file name if (ChoosenOutputFile == null) { if (InputFile.Contains(".")) { ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".pptx"; } else { ChoosenOutputFile = InputFile + ".pptx"; } } //open the reader using (StructuredStorageReader reader = new StructuredStorageReader(procFile.File.FullName)) { // parse the ppt document PowerpointDocument ppt = new PowerpointDocument(reader); // detect document type and name OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(ppt); string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType); // create the pptx document PresentationDocument pptx = PresentationDocument.Create(conformOutputFile, outType); //start time DateTime start = DateTime.Now; TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile); // convert Converter.Convert(ppt, pptx); // stop time DateTime end = DateTime.Now; TimeSpan diff = end.Subtract(start); TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } }
/// <summary> /// Ctor /// </summary> /// <param name="file"></param> public XlsDocument(StructuredStorageReader reader) { this.WorkBookData = new WorkBookData(); this.Storage = reader; if (reader.FullNameOfAllStreamEntries.Contains("\\" + WORKBOOK)) { this.workBookStreamReader = new VirtualStreamReader(reader.GetStream(WORKBOOK)); } else if (reader.FullNameOfAllStreamEntries.Contains("\\" + ALTERNATE1)) { this.workBookStreamReader = new VirtualStreamReader(reader.GetStream(ALTERNATE1)); } else { throw new ExtractorException(ExtractorException.WORKBOOKSTREAMNOTFOUND); } this.workBookExtr = new WorkbookExtractor(this.workBookStreamReader, this.WorkBookData); }
static void Main(string[] args) { TraceLogger.LogLevel = TraceLogger.LoggingLevel.DebugInternal; const string outputDir = "dumps"; if (Directory.Exists(outputDir)) { Directory.Delete(outputDir, true); } Directory.CreateDirectory(outputDir); string inputFile = args[0]; ProcessingFile procFile = new ProcessingFile(inputFile); StructuredStorageReader file = new StructuredStorageReader(procFile.File.FullName); PowerpointDocument pptDoc = new PowerpointDocument(file); // Dump unknown records foreach (Record record in pptDoc) { if (record is UnknownRecord) { string filename = String.Format(@"{0}\{1}.record", outputDir, record.GetIdentifier()); using (FileStream fs = new FileStream(filename, FileMode.Create)) { record.DumpToStream(fs); } } } // Output record tree Console.WriteLine(pptDoc); Console.WriteLine(); // Let's make development as easy as pie. System.Diagnostics.Debugger.Break(); }
public override RadDocument Import(Stream input) { using (StructuredStorageReader structuredStorageReader = new StructuredStorageReader(input)) { WordDocument wordDocument = new WordDocument(structuredStorageReader); OpenXmlPackage.DocumentType documentType = Converter.DetectOutputType(wordDocument); string tempFileName = Path.GetTempFileName(); WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Create(tempFileName, documentType); Converter.Convert(wordDocument, wordprocessingDocument); RadDocument document; using (FileStream stream = File.OpenRead(tempFileName)) { document = this.docxProvider.Import(stream); } File.Delete(tempFileName); return(document); } }
public override RadDocument Import(Stream input) { using (StructuredStorageReader structuredStorageReader = new StructuredStorageReader(input)) { WordDocument wordDocument = new WordDocument(structuredStorageReader); OpenXmlPackage.DocumentType documentType = Converter.DetectOutputType(wordDocument); string tempFileName = Path.GetTempFileName(); WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Create(tempFileName, documentType); Converter.Convert(wordDocument, wordprocessingDocument); RadDocument document; using (FileStream stream = File.OpenRead(tempFileName)) { document = this.docxProvider.Import(stream); } File.Delete(tempFileName); return document; } }
public OleObject(CharacterPropertyExceptions chpx, StructuredStorageReader docStorage) { this._docStorage = docStorage; this.ObjectId = getOleEntryName(chpx); this.Path = "\\ObjectPool\\" + this.ObjectId + "\\"; processOleStream(this.Path + "\u0001Ole"); if (this.fLinked) { processLinkInfoStream(this.Path + "\u0003LinkInfo"); } else { processCompObjStream(this.Path + "\u0001CompObj"); } //get the storage entries of this object this.Streams = new Dictionary <string, VirtualStream>(); foreach (string streamname in docStorage.FullNameOfAllStreamEntries) { if (streamname.StartsWith(this.Path)) { this.Streams.Add(streamname.Substring(streamname.LastIndexOf("\\") + 1), docStorage.GetStream(streamname)); } } //find the class if of this object foreach (DirectoryEntry entry in docStorage.AllEntries) { if (entry.Name == this.ObjectId) { this.ClassId = entry.ClsId; break; } } }
static void Main(string[] args) { const int bytesToReadAtOnce = 512; char[] invalidChars = Path.GetInvalidFileNameChars(); TraceLogger.LogLevel = TraceLogger.LoggingLevel.Error; ConsoleTraceListener consoleTracer = new ConsoleTraceListener(); Trace.Listeners.Add(consoleTracer); Trace.AutoFlush = true; if (args.Length < 1) { Console.WriteLine("No parameter found. Please specify one or more compound document file(s)."); return; } foreach (string file in args) { StructuredStorageReader storageReader = null; DateTime begin = DateTime.Now; TimeSpan extractionTime = new TimeSpan(); try { // init StorageReader storageReader = new StructuredStorageReader(file); // read stream _entries ICollection <DirectoryEntry> streamEntries = storageReader.AllStreamEntries; //ICollection<DirectoryEntry> allEntries = storageReader.AllEntries; //allEntries.Add(storageReader.RootDirectoryEntry); List <DirectoryEntry> allEntries = new List <DirectoryEntry>(); allEntries.AddRange(storageReader.AllEntries); allEntries.Sort( delegate(DirectoryEntry a, DirectoryEntry b) { return(a.Sid.CompareTo(b.Sid)); } ); //foreach (DirectoryEntry entry in allEntries) //{ // Console.WriteLine(entry.Sid + ":"); // Console.WriteLine("{0}: {1}", entry.Name, entry.LengthOfName); // Console.WriteLine("CLSID: " + entry.ClsId); // string hexName = ""; // for (int i = 0; i < entry.Name.Length; i++) // { // hexName += String.Format("{0:X2} ", (UInt32)entry.Name[i]); // } // Console.WriteLine("{0}", hexName); // UInt32 left = entry.LeftSiblingSid; // UInt32 right = entry.RightSiblingSid; // UInt32 child = entry.ChildSiblingSid; // Console.WriteLine("{0:X02}: Left: {2:X02}, Right: {3:X02}, Child: {4:X02}, Name: {1}, Color: {5}", entry.Sid, entry.Name, (left > 0xFF) ? 0xFF : left, (right > 0xFF) ? 0xFF : right, (child > 0xFF) ? 0xFF : child, entry.Color.ToString()); // Console.WriteLine("----------"); // Console.WriteLine(""); //} // create valid path names Dictionary <DirectoryEntry, KeyValuePair <string, Guid> > pathNames1 = new Dictionary <DirectoryEntry, KeyValuePair <string, Guid> >(); foreach (DirectoryEntry entry in allEntries) { string name = entry.Path; for (int i = 0; i < invalidChars.Length; i++) { name = name.Replace(invalidChars[i], '_'); } pathNames1.Add(entry, new KeyValuePair <string, Guid>(name, entry.ClsId)); } // Create Directory Structure StructuredStorageWriter sso = new StructuredStorageWriter(); sso.RootDirectoryEntry.setClsId(storageReader.RootDirectoryEntry.ClsId); foreach (DirectoryEntry entry in pathNames1.Keys) { StorageDirectoryEntry sde = sso.RootDirectoryEntry; string[] storages = entry.Path.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < storages.Length; i++) { if (entry.Type == DirectoryEntryType.STGTY_ROOT) { continue; } if (entry.Type == DirectoryEntryType.STGTY_STORAGE || i < storages.Length - 1) { StorageDirectoryEntry result = sde.AddStorageDirectoryEntry(storages[i]); sde = (result == null) ? sde : result; if (i == storages.Length - 1) { sde.setClsId(entry.ClsId); } continue; } VirtualStream vstream = storageReader.GetStream(entry.Path); sde.AddStreamDirectoryEntry(storages[i], vstream); } } // Write sso to stream MemoryStream myStream = new MemoryStream(); sso.write(myStream); // Close input storage storageReader.Close(); storageReader = null; // Write stream to file byte[] array = new byte[bytesToReadAtOnce]; int bytesRead; string outputFileName = Path.GetFileNameWithoutExtension(file) + "_output" + Path.GetExtension(file); string path = Path.GetDirectoryName(Path.GetFullPath(file)); outputFileName = path + "\\" + outputFileName; FileStream outputFile = new FileStream(outputFileName, FileMode.Create, FileAccess.Write); myStream.Seek(0, SeekOrigin.Begin); do { bytesRead = myStream.Read(array, 0, bytesToReadAtOnce); outputFile.Write(array, 0, bytesRead); } while (bytesRead == array.Length); outputFile.Close(); // --------- extract streams from written file storageReader = new StructuredStorageReader(outputFileName); // read stream _entries streamEntries = storageReader.AllStreamEntries; // create valid path names Dictionary <string, string> pathNames2 = new Dictionary <string, string>(); foreach (DirectoryEntry entry in streamEntries) { string name = entry.Path; for (int i = 0; i < invalidChars.Length; i++) { name = name.Replace(invalidChars[i], '_'); } pathNames2.Add(entry.Path, name); } // create output directory string outputDir = '_' + (Path.GetFileName(outputFileName)).Replace('.', '_'); outputDir = outputDir.Replace(':', '_'); outputDir = Path.GetDirectoryName(outputFileName) + "\\" + outputDir; Directory.CreateDirectory(outputDir); // for each stream foreach (string key in pathNames2.Keys) { // get virtual stream by path name IStreamReader streamReader = new VirtualStreamReader(storageReader.GetStream(key)); // read bytes from stream, write them back to disk FileStream fs = new FileStream(outputDir + "\\" + pathNames2[key] + ".stream", FileMode.Create); BinaryWriter writer = new BinaryWriter(fs); array = new byte[bytesToReadAtOnce]; do { bytesRead = streamReader.Read(array); writer.Write(array, 0, bytesRead); writer.Flush(); } while (bytesRead == array.Length); writer.Close(); fs.Close(); } // close storage storageReader.Close(); storageReader = null; extractionTime = DateTime.Now - begin; Console.WriteLine("Streams extracted in " + String.Format("{0:N2}", extractionTime.TotalSeconds) + "s. (File: " + file + ")"); } catch (Exception e) { Console.WriteLine("*** Error: " + e.Message + " (File: " + file + ")"); Console.WriteLine("*** StackTrace: " + e.StackTrace + " (File: " + file + ")"); } finally { if (storageReader != null) { storageReader.Close(); } } } }
static void Main(string[] args) { const int bytesToReadAtOnce = 1024; char[] invalidChars = Path.GetInvalidFileNameChars(); TraceLogger.LogLevel = TraceLogger.LoggingLevel.Error; ConsoleTraceListener consoleTracer = new ConsoleTraceListener(); Trace.Listeners.Add(consoleTracer); Trace.AutoFlush = true; if (args.Length < 1) { Console.WriteLine("No parameter found. Please specify one or more compound document file(s)."); return; } foreach (string file in args) { StructuredStorageReader storageReader = null; DateTime begin = DateTime.Now; TimeSpan extractionTime = new TimeSpan(); try { // init StorageReader storageReader = new StructuredStorageReader(file); // read stream _entries ICollection <DirectoryEntry> streamEntries = storageReader.AllStreamEntries; // create valid path names Dictionary <string, string> PathNames = new Dictionary <string, string>(); foreach (DirectoryEntry entry in streamEntries) { string name = entry.Path; for (int i = 0; i < invalidChars.Length; i++) { name = name.Replace(invalidChars[i], '_'); } PathNames.Add(entry.Path, name); } // create output directory string outputDir = '_' + file.Replace('.', '_'); outputDir = outputDir.Replace(':', '_'); Directory.CreateDirectory(outputDir); // for each stream foreach (string key in PathNames.Keys) { // get virtual stream by path name IStreamReader streamReader = new VirtualStreamReader(storageReader.GetStream(key)); // read bytes from stream, write them back to disk FileStream fs = new FileStream(outputDir + "\\" + PathNames[key] + ".stream", FileMode.Create); BinaryWriter writer = new BinaryWriter(fs); byte[] array = new byte[bytesToReadAtOnce]; int bytesRead; do { bytesRead = streamReader.Read(array); writer.Write(array, 0, bytesRead); writer.Flush(); } while (bytesRead == array.Length); writer.Close(); fs.Close(); } // close storage storageReader.Close(); storageReader = null; extractionTime = DateTime.Now - begin; Console.WriteLine("Streams extracted in " + String.Format("{0:N2}", extractionTime.TotalSeconds) + "s. (File: " + file + ")"); } catch (Exception e) { Console.WriteLine("*** Error: " + e.Message + " (File: " + file + ")"); } finally { if (storageReader != null) { storageReader.Close(); } } } }
void Parse(StructuredStorageReader reader, int fibFC) { this.Storage = reader; this.WordDocumentStream = reader.GetStream("WordDocument"); //parse FIB this.WordDocumentStream.Seek(fibFC, System.IO.SeekOrigin.Begin); this.FIB = new FileInformationBlock(new VirtualStreamReader(this.WordDocumentStream)); //check the file version if ((int)this.FIB.nFib != 0) { if (this.FIB.nFib < FileInformationBlock.FibVersion.Fib1997Beta) { throw new ByteParseException("Could not parse the file because it was created by an unsupported application (Word 95 or older)."); } } else { if (this.FIB.nFibNew < FileInformationBlock.FibVersion.Fib1997Beta) { throw new ByteParseException("Could not parse the file because it was created by an unsupported application (Word 95 or older)."); } } //get the streams this.TableStream = reader.GetStream(this.FIB.fWhichTblStm ? "1Table" : "0Table"); try { this.DataStream = reader.GetStream("Data"); } catch (StreamNotFoundException) { this.DataStream = null; } //Read all needed STTBs this.RevisionAuthorTable = new StringTable(typeof(string), this.TableStream, this.FIB.fcSttbfRMark, this.FIB.lcbSttbfRMark); this.FontTable = new StringTable(typeof(FontFamilyName), this.TableStream, this.FIB.fcSttbfFfn, this.FIB.lcbSttbfFfn); this.BookmarkNames = new StringTable(typeof(string), this.TableStream, this.FIB.fcSttbfBkmk, this.FIB.lcbSttbfBkmk); this.AutoTextNames = new StringTable(typeof(string), this.TableStream, this.FIB.fcSttbfGlsy, this.FIB.lcbSttbfGlsy); //this.ProtectionUsers = new StringTable(typeof(String), this.TableStream, this.FIB.fcSttbProtUser, this.FIB.lcbSttbProtUser); // this.UserVariables = new StwStructure(this.TableStream, this.FIB.fcStwUser, this.FIB.lcbStwUser); //Read all needed PLCFs this.AnnotationsReferencePlex = new Plex <AnnotationReferenceDescriptor>(30, this.TableStream, this.FIB.fcPlcfandRef, this.FIB.lcbPlcfandRef); this.TextboxBreakPlex = new Plex <BreakDescriptor>(6, this.TableStream, this.FIB.fcPlcfTxbxBkd, this.FIB.lcbPlcfTxbxBkd); this.TextboxBreakPlexHeader = new Plex <BreakDescriptor>(6, this.TableStream, this.FIB.fcPlcfTxbxHdrBkd, this.FIB.lcbPlcfTxbxHdrBkd); this.OfficeDrawingPlex = new Plex <FileShapeAddress>(26, this.TableStream, this.FIB.fcPlcSpaMom, this.FIB.lcbPlcSpaMom); this.OfficeDrawingPlexHeader = new Plex <FileShapeAddress>(26, this.TableStream, this.FIB.fcPlcSpaHdr, this.FIB.lcbPlcSpaHdr); this.SectionPlex = new Plex <SectionDescriptor>(12, this.TableStream, this.FIB.fcPlcfSed, this.FIB.lcbPlcfSed); this.BookmarkStartPlex = new Plex <BookmarkFirst>(4, this.TableStream, this.FIB.fcPlcfBkf, this.FIB.lcbPlcfBkf); this.EndnoteReferencePlex = new Plex <short>(2, this.TableStream, this.FIB.fcPlcfendRef, this.FIB.lcbPlcfendRef); this.FootnoteReferencePlex = new Plex <short>(2, this.TableStream, this.FIB.fcPlcffndRef, this.FIB.lcbPlcffndRef); // PLCFs without types this.BookmarkEndPlex = new Plex <Exception>(0, this.TableStream, this.FIB.fcPlcfBkl, this.FIB.lcbPlcfBkl); this.AutoTextPlex = new Plex <Exception>(0, this.TableStream, this.FIB.fcPlcfGlsy, this.FIB.lcbPlcfGlsy); //read the FKPs this.AllPapxFkps = FormattedDiskPagePAPX.GetAllPAPXFKPs(this.FIB, this.WordDocumentStream, this.TableStream, this.DataStream); this.AllChpxFkps = FormattedDiskPageCHPX.GetAllCHPXFKPs(this.FIB, this.WordDocumentStream, this.TableStream); //read custom tables this.DocumentProperties = new DocumentProperties(this.FIB, this.TableStream); this.Styles = new StyleSheet(this.FIB, this.TableStream, this.DataStream); this.ListTable = new ListTable(this.FIB, this.TableStream); this.ListFormatOverrideTable = new ListFormatOverrideTable(this.FIB, this.TableStream); this.OfficeArtContent = new OfficeArtContent(this.FIB, this.TableStream); this.HeaderAndFooterTable = new HeaderAndFooterTable(this); this.AnnotationReferenceExtraTable = new AnnotationReferenceExtraTable(this.FIB, this.TableStream); this.CommandTable = new CommandTable(this.FIB, this.TableStream); this.AnnotationOwners = new AnnotationOwnerList(this.FIB, this.TableStream); //parse the piece table and construct a list that contains all chars this.PieceTable = new PieceTable(this.FIB, this.TableStream); this.Text = this.PieceTable.GetAllChars(this.WordDocumentStream); //build a dictionaries of all PAPX this.AllPapx = new Dictionary <int, ParagraphPropertyExceptions>(); for (int i = 0; i < this.AllPapxFkps.Count; i++) { for (int j = 0; j < this.AllPapxFkps[i].grppapx.Length; j++) { this.AllPapx.Add(this.AllPapxFkps[i].rgfc[j], this.AllPapxFkps[i].grppapx[j]); } } //build a dictionary of all SEPX this.AllSepx = new Dictionary <int, SectionPropertyExceptions>(); for (int i = 0; i < this.SectionPlex.Elements.Count; i++) { //Read the SED var sed = (SectionDescriptor)this.SectionPlex.Elements[i]; int cp = this.SectionPlex.CharacterPositions[i + 1]; //Get the SEPX var wordReader = new VirtualStreamReader(this.WordDocumentStream); this.WordDocumentStream.Seek(sed.fcSepx, System.IO.SeekOrigin.Begin); short cbSepx = wordReader.ReadInt16(); var sepx = new SectionPropertyExceptions(wordReader.ReadBytes(cbSepx - 2)); this.AllSepx.Add(cp, sepx); } //read the Glossary if (this.FIB.pnNext > 0) { this.Glossary = new WordDocument(this.Storage, (int)(this.FIB.pnNext * 512)); } }
public WordDocument(StructuredStorageReader reader, int fibFC = 0) { Parse(reader, fibFC); }
static void Main(string[] args) { ParseArgs(args, ToolName); InitializeLogger(); PrintWelcome(ToolName, RevisionResource); try { //copy processing file var procFile = new ProcessingFile(InputFile); //make output file name if (ChoosenOutputFile == null) { if (InputFile.Contains(".")) { ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".xlsx"; } else { ChoosenOutputFile = InputFile + ".xlsx"; } } //parse the document using (var reader = new StructuredStorageReader(procFile.File.FullName)) { var xlsDoc = new XlsDocument(reader); var outType = Converter.DetectOutputType(xlsDoc); string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType); using (var spreadx = SpreadsheetDocument.Create(conformOutputFile, outType)) { //start time var start = DateTime.Now; TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile); Converter.Convert(xlsDoc, spreadx); var end = DateTime.Now; var diff = end.Subtract(start); TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } } } catch (ParseException ex) { TraceLogger.Error("Could not convert {0} because it was created by an unsupported application (Excel 95 or older).", InputFile); TraceLogger.Debug(ex.ToString()); } catch (DirectoryNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (FileNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (Exception ex) { TraceLogger.Error("Conversion of file {0} failed.", InputFile); TraceLogger.Debug(ex.ToString()); } }
static void Main(string[] args) { ParseArgs(args, ToolName); InitializeLogger(); PrintWelcome(ToolName, RevisionResource); if (CreateContextMenuEntry) { // create context menu entry try { TraceLogger.Info("Creating context menu entry for xls2x ..."); RegisterForContextMenu(GetContextMenuKey(ContextMenuInputExtension, ContextMenuText)); TraceLogger.Info("Succeeded."); } catch (Exception) { TraceLogger.Info("Failed. Sorry :("); } } else { try { //copy processing file ProcessingFile procFile = new ProcessingFile(InputFile); //make output file name if (ChoosenOutputFile == null) { if (InputFile.Contains(".")) { ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".xlsx"; } else { ChoosenOutputFile = InputFile + ".xlsx"; } } //parse the document using (StructuredStorageReader reader = new StructuredStorageReader(procFile.File.FullName)) { XlsDocument xlsDoc = new XlsDocument(reader); OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(xlsDoc); string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType); using (SpreadsheetDocument spreadx = SpreadsheetDocument.Create(conformOutputFile, outType)) { //start time DateTime start = DateTime.Now; TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile); Converter.Convert(xlsDoc, spreadx); DateTime end = DateTime.Now; TimeSpan diff = end.Subtract(start); TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } } } catch (ParseException ex) { TraceLogger.Error("Could not convert {0} because it was created by an unsupported application (Excel 95 or older).", InputFile); TraceLogger.Debug(ex.ToString()); } catch (DirectoryNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (FileNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (ZipCreationException ex) { TraceLogger.Error("Could not create output file {0}.", ChoosenOutputFile); TraceLogger.Debug(ex.ToString()); } catch (Exception ex) { TraceLogger.Error("Conversion of file {0} failed.", InputFile); TraceLogger.Debug(ex.ToString()); } } }
public WordDocument(StructuredStorageReader reader) { parse(reader, 0); }
public static void Main(string[] args) { ParseArgs(args, ToolName); InitializeLogger(); PrintWelcome(ToolName, RevisionResource); // convert try { //copy processing file var procFile = new ProcessingFile(InputFile); //make output file name if (ChoosenOutputFile == null) { if (InputFile.Contains(".")) { ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".docx"; } else { ChoosenOutputFile = InputFile + ".docx"; } } //open the reader using (var reader = new StructuredStorageReader(procFile.File.FullName)) { //parse the input document var doc = new WordDocument(reader); //prepare the output document var outType = Converter.DetectOutputType(doc); string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType); var docx = WordprocessingDocument.Create(conformOutputFile, outType); //start time var start = DateTime.Now; TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile); //convert the document Converter.Convert(doc, docx); var end = DateTime.Now; var diff = end.Subtract(start); TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } } catch (DirectoryNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (FileNotFoundException ex) { TraceLogger.Error(ex.Message); TraceLogger.Debug(ex.ToString()); } catch (ReadBytesAmountMismatchException ex) { TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile); TraceLogger.Debug(ex.ToString()); } catch (MagicNumberException ex) { TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile); TraceLogger.Debug(ex.ToString()); } catch (UnspportedFileVersionException ex) { TraceLogger.Error("File {0} has been created with a Word version older than Word 97.", InputFile); TraceLogger.Debug(ex.ToString()); } catch (ByteParseException ex) { TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile); TraceLogger.Debug(ex.ToString()); } catch (MappingException ex) { TraceLogger.Error("There was an error while converting file {0}: {1}", InputFile, ex.Message); TraceLogger.Debug(ex.ToString()); } catch (Exception ex) { TraceLogger.Error("Conversion of file {0} failed.", InputFile); TraceLogger.Debug(ex.ToString()); } }
public WordDocument(StructuredStorageReader reader, Int32 fibFC) { parse(reader, fibFC); }
public void SetUp() { this.reader = new StructuredStorageReader(this.file); this.doc = new WordDocument(this.reader); }
public PowerpointDocument(StructuredStorageReader file) { try { this.CurrentUserStream = file.GetStream("Current User"); var rec = Record.ReadRecord(this.CurrentUserStream); if (rec is CurrentUserAtom) { this.CurrentUserAtom = (CurrentUserAtom)rec; } else { this.CurrentUserStream.Position = 0; var bytes = new byte[this.CurrentUserStream.Length]; this.CurrentUserStream.Read(bytes); string s = Encoding.UTF8.GetString(bytes).Replace("\0", ""); } } catch (InvalidRecordException e) { throw new InvalidStreamException("Current user stream is not valid", e); } // Optional 'Pictures' stream if (file.FullNameOfAllStreamEntries.Contains("\\Pictures")) { try { this.PicturesStream = file.GetStream("Pictures"); this.PicturesContainer = new Pictures(new BinaryReader(this.PicturesStream), (uint)this.PicturesStream.Length, 0, 0, 0); } catch (InvalidRecordException e) { throw new InvalidStreamException("Pictures stream is not valid", e); } } this.PowerpointDocumentStream = file.GetStream("PowerPoint Document"); try { this.DocumentSummaryInformationStream = file.GetStream("DocumentSummaryInformation"); ScanDocumentSummaryInformation(); } catch (StructuredStorage.Common.StreamNotFoundException) { //ignore } if (this.CurrentUserAtom != null) { this.PowerpointDocumentStream.Seek(this.CurrentUserAtom.OffsetToCurrentEdit, SeekOrigin.Begin); this.LastUserEdit = (UserEditAtom)Record.ReadRecord(this.PowerpointDocumentStream); } this.ConstructPersistObjectDirectory(); this.IdentifyDocumentPersistObject(); this.IdentifyMasterPersistObjects(); this.IdentifySlidePersistObjects(); this.IdentifyOlePersistObjects(); this.IdentifyVbaProjectObject(); }