Changeset 414


Ignore:
Timestamp:
10/07/11 16:16:37 (9 years ago)
Author:
michiel
Message:

Update of OfficeConvert? 1.3.1 + Readme

Location:
trunk/OfficeConvert
Files:
25 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/OfficeConvert/buildOffice2007/Readme.txt

    r361 r414  
    1 Office Convert 1.4 
     1Office Convert 1.1 
    22Copyright (c) 2010 FishDawg LLC 
    33 
  • trunk/OfficeConvert/buildOffice2007/Source/Converter.cs

    r361 r414  
    1111namespace FishDawg.OfficeConvert 
    1212{ 
    13         using System; 
    14         using System.Collections.Generic; 
    15         using System.Diagnostics; 
    16         using System.Globalization; 
    17         using System.IO; 
    18         using System.Text; 
    19  
    20         internal abstract class Converter : IDisposable 
    21         { 
    22                 #region Constructors 
    23  
    24                 protected Converter() 
    25                 { 
    26                 } 
    27  
    28                 #endregion 
    29  
    30                 #region Properties 
    31  
    32                 public abstract IList<FormatInfo> Formats 
    33                 { 
    34                         get; 
    35                 } 
    36  
    37                 #endregion 
    38  
    39                 #region Methods 
    40  
    41                 public static Converter Create(Options options) 
    42                 { 
    43                         if (options == null) 
    44                         { 
    45                                 throw new ArgumentNullException("options", "The options cannot be null."); 
    46                         } 
    47  
    48                         if (options.InputFilePath == null) 
    49                         { 
    50                                 throw new OptionException("No file specified."); 
    51                         } 
    52  
    53                         if (options.TypeName == null) 
    54                         { 
    55                                 string fileExtension = Path.GetExtension(options.InputFilePath); 
    56                                 return CreateFromFileExtension(fileExtension); 
    57                         } 
    58                         else 
    59                         { 
    60                                 return CreateFromTypeName(options.TypeName); 
    61                         } 
    62                 } 
    63  
    64                 public virtual FormatInfo GetBestFormat(string formatName) 
    65                 { 
    66                         if (this.Formats == null || this.Formats.Count == 0) 
    67                         { 
    68                                 throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
    69                         } 
    70  
    71                         if (formatName != null) 
    72                         { 
    73                                 // Find the specified format 
    74                                 foreach (FormatInfo format in this.Formats) 
    75                                 { 
    76                                         if (string.Compare(format.Name, formatName, StringComparison.OrdinalIgnoreCase) == 0) 
    77                                         { 
    78                                                 return format; 
    79                                         } 
    80                                 } 
    81  
    82                                 throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid format: {0}", formatName)); 
    83                         } 
    84  
    85                         // Use the default format 
    86                         return this.Formats[0]; 
    87                 } 
    88  
    89                 public virtual string GetBestOutputFilePath(string inputFilePath, FormatInfo format, string outputFilePath) 
    90                 { 
    91                         if (inputFilePath == null) 
    92                         { 
    93                                 throw new ArgumentNullException("inputFilePath", "The input file path cannot be null."); 
    94                         } 
    95  
    96                         if (format == null) 
    97                         { 
    98                                 throw new ArgumentNullException("format", "The format cannot be null."); 
    99                         } 
    100  
    101                         if (this.Formats == null || this.Formats.Count == 0) 
    102                         { 
    103                                 throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
    104                         } 
    105  
    106                         if (outputFilePath == null) 
    107                         { 
    108                                 return Path.ChangeExtension(inputFilePath, format.DefaultFileExtension); 
    109                         } 
    110                         else if (Directory.Exists(outputFilePath)) 
    111                         { 
    112                                 return Path.Combine(outputFilePath, Path.ChangeExtension(Path.GetFileName(inputFilePath), format.DefaultFileExtension)); 
    113                         } 
    114  
    115                         return outputFilePath; 
    116                 } 
    117  
    118                 public virtual void Initialize() 
    119                 { 
    120                         // Do nothing 
    121                 } 
    122  
    123                 public virtual void Convert(string inputFilePath, FormatInfo format, string outputFilePath, string password) 
    124                 { 
    125                         if (inputFilePath == null) 
    126                         { 
    127                                 throw new ArgumentNullException("inputFilePath", "The input file path cannot be null."); 
    128                         } 
    129  
    130                         if (format == null) 
    131                         { 
    132                                 throw new ArgumentNullException("format", "The format cannot be null."); 
    133                         } 
    134  
    135                         if (outputFilePath == null) 
    136                         { 
    137                                 throw new ArgumentNullException("outputFilePath", "The output file path cannot be null."); 
    138                         } 
    139  
    140                         if (this.Formats == null || this.Formats.Count == 0) 
    141                         { 
    142                                 throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
    143                         } 
    144  
    145                         // Do nothing 
    146                 } 
    147  
    148                 public void Dispose() 
    149                 { 
    150                         this.Dispose(true); 
    151  
    152                         // Suppress finalization in case a derived class implements a finalizer 
    153                         GC.SuppressFinalize(this); 
    154                 } 
    155  
    156                 protected virtual void Dispose(bool disposing) 
    157                 { 
    158                         // Do nothing 
    159                 } 
    160  
    161                 private static Converter CreateFromFileExtension(string fileExtension) 
    162                 { 
    163                         Debug.Assert(fileExtension != null); 
    164  
    165                         if (string.Compare(fileExtension, ".doc", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".docx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".docm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".odt", StringComparison.OrdinalIgnoreCase) == 0) 
    166                         { 
    167                                 return new WordConverter(); 
    168                         } 
    169                         else if (string.Compare(fileExtension, ".xls", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsb", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".ods", StringComparison.OrdinalIgnoreCase) == 0) 
    170                         { 
    171                                 return new ExcelConverter(); 
    172                         } 
    173                         else if (string.Compare(fileExtension, ".ppt", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pptx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pptm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pps", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".ppsx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".odp", StringComparison.OrdinalIgnoreCase) == 0) 
    174                         { 
    175                                 return new PowerPointConverter(); 
    176                         } 
    177  
    178                         throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Unrecognized file extension: {0}", fileExtension)); 
    179                 } 
    180  
    181                 private static Converter CreateFromTypeName(string typeName) 
    182                 { 
    183                         Debug.Assert(typeName != null); 
    184  
    185                         if (string.Compare(typeName, "word", StringComparison.OrdinalIgnoreCase) == 0) 
    186                         { 
    187                                 return new WordConverter(); 
    188                         } 
    189                         else if (string.Compare(typeName, "excel", StringComparison.OrdinalIgnoreCase) == 0) 
    190                         { 
    191                                 return new ExcelConverter(); 
    192                         } 
    193                         else if (string.Compare(typeName, "powerpoint", StringComparison.OrdinalIgnoreCase) == 0) 
    194                         { 
    195                                 return new PowerPointConverter(); 
    196                         } 
    197  
    198                         throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid type: {0}", typeName)); 
    199                 } 
    200  
    201                 #endregion 
    202         } 
     13    using System; 
     14    using System.Collections.Generic; 
     15    using System.Diagnostics; 
     16    using System.Globalization; 
     17    using System.IO; 
     18    using System.Text; 
     19    using System.Runtime.InteropServices; 
     20    using System.Security.Permissions; 
     21    using System.ComponentModel; 
     22 
     23    internal abstract class Converter : IDisposable 
     24    { 
     25        #region Constructors 
     26 
     27        protected Converter(Options options) 
     28        { 
     29            _options = options; 
     30        } 
     31 
     32        #endregion 
     33 
     34        #region Properties 
     35 
     36        private Options _options; 
     37        public Options Options 
     38        { 
     39            get { return _options; } 
     40            set { _options = value; } 
     41        } 
     42 
     43        public abstract IList<FormatInfo> Formats 
     44        { 
     45            get; 
     46        } 
     47 
     48        #endregion 
     49 
     50        #region Methods 
     51 
     52        public static Converter Create(Options options) 
     53        { 
     54            if (options == null) 
     55            { 
     56                throw new ArgumentNullException("options", "The options cannot be null."); 
     57            } 
     58 
     59            if (options.InputFilePath == null) 
     60            { 
     61                throw new OptionException("No file specified."); 
     62            } 
     63 
     64            if (options.TypeName == null) 
     65            { 
     66                string fileExtension = Path.GetExtension(options.InputFilePath); 
     67                return CreateFromFileExtension(fileExtension, options); 
     68            } 
     69            else 
     70            { 
     71                return CreateFromTypeName(options.TypeName, options); 
     72            } 
     73        } 
     74 
     75        public virtual FormatInfo GetBestFormat(string formatName) 
     76        { 
     77            if (this.Formats == null || this.Formats.Count == 0) 
     78            { 
     79                throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
     80            } 
     81 
     82            if (formatName != null) 
     83            { 
     84                // Find the specified format 
     85                foreach (FormatInfo format in this.Formats) 
     86                { 
     87                    if (string.Compare(format.Name, formatName, StringComparison.OrdinalIgnoreCase) == 0) 
     88                    { 
     89                        return format; 
     90                    } 
     91                } 
     92 
     93                throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid format: {0}", formatName)); 
     94            } 
     95 
     96            // Use the default format 
     97            return this.Formats[0]; 
     98        } 
     99 
     100        public virtual string GetBestOutputFilePath(string inputFilePath, FormatInfo format, string outputFilePath) 
     101        { 
     102            if (inputFilePath == null) 
     103            { 
     104                throw new ArgumentNullException("inputFilePath", "The input file path cannot be null."); 
     105            } 
     106 
     107            if (format == null) 
     108            { 
     109                throw new ArgumentNullException("format", "The format cannot be null."); 
     110            } 
     111 
     112            if (this.Formats == null || this.Formats.Count == 0) 
     113            { 
     114                throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
     115            } 
     116 
     117            if (outputFilePath == null) 
     118            { 
     119                return Path.ChangeExtension(inputFilePath, format.DefaultFileExtension); 
     120            } 
     121            else if (Directory.Exists(outputFilePath)) 
     122            { 
     123                return Path.Combine(outputFilePath, Path.ChangeExtension(Path.GetFileName(inputFilePath), format.DefaultFileExtension)); 
     124            } 
     125 
     126            return outputFilePath; 
     127        } 
     128 
     129        public virtual void Initialize() 
     130        { 
     131            // Do nothing 
     132        } 
     133 
     134        public virtual void Convert(string inputFilePath, FormatInfo format, string outputFilePath, string password) 
     135        { 
     136            if (inputFilePath == null) 
     137            { 
     138                throw new ArgumentNullException("inputFilePath", "The input file path cannot be null."); 
     139            } 
     140 
     141            if (format == null) 
     142            { 
     143                throw new ArgumentNullException("format", "The format cannot be null."); 
     144            } 
     145 
     146            if (outputFilePath == null) 
     147            { 
     148                throw new ArgumentNullException("outputFilePath", "The output file path cannot be null."); 
     149            } 
     150 
     151            if (this.Formats == null || this.Formats.Count == 0) 
     152            { 
     153                throw new InvalidOperationException("The converter cannot be used before it has been initialized."); 
     154            } 
     155 
     156            // Do nothing 
     157        } 
     158 
     159        protected void ConvertWithOdfConverter(string inputFilePath, string outputFilePath) 
     160        { 
     161            try 
     162            { 
     163                ProcessStartInfo psi = new ProcessStartInfo(); 
     164                psi.FileName = this.Options.OpenXmlOdfTranslatorPath; 
     165                psi.Arguments = " /I \"" + inputFilePath + "\" /O \"" + outputFilePath + "\" /F"; 
     166                psi.UseShellExecute = false; 
     167                psi.RedirectStandardOutput = true; 
     168                Process process = Process.Start(psi); 
     169                string output = process.StandardOutput.ReadToEnd(); 
     170                process.WaitForExit(); 
     171                Console.WriteLine(output); 
     172            } 
     173            catch (Exception ex) 
     174            { 
     175                throw new NotSupportedException("OpenXML/ODF Translator Add-in is not installed.", ex); 
     176            } 
     177        } 
     178 
     179        public void Dispose() 
     180        { 
     181            this.Dispose(true); 
     182 
     183            // Suppress finalization in case a derived class implements a finalizer 
     184            GC.SuppressFinalize(this); 
     185        } 
     186 
     187        protected virtual void Dispose(bool disposing) 
     188        { 
     189            // Do nothing 
     190        } 
     191 
     192        private static Converter CreateFromFileExtension(string fileExtension, Options options) 
     193        { 
     194            Debug.Assert(fileExtension != null); 
     195 
     196            if (string.Compare(fileExtension, ".doc", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".docx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".docm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".odt", StringComparison.OrdinalIgnoreCase) == 0) 
     197            { 
     198                return new WordConverter(options); 
     199            } 
     200            else if (string.Compare(fileExtension, ".xls", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".xlsb", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".ods", StringComparison.OrdinalIgnoreCase) == 0) 
     201            { 
     202                return new ExcelConverter(options); 
     203            } 
     204            else if (string.Compare(fileExtension, ".ppt", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pptx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pptm", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".pps", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".ppsx", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(fileExtension, ".odp", StringComparison.OrdinalIgnoreCase) == 0) 
     205            { 
     206                return new PowerPointConverter(options); 
     207            } 
     208 
     209            throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Unrecognized file extension: {0}", fileExtension)); 
     210        } 
     211 
     212        private static Converter CreateFromTypeName(string typeName, Options options) 
     213        { 
     214            Debug.Assert(typeName != null); 
     215 
     216            if (string.Compare(typeName, "word", StringComparison.OrdinalIgnoreCase) == 0) 
     217            { 
     218                return new WordConverter(options); 
     219            } 
     220            else if (string.Compare(typeName, "excel", StringComparison.OrdinalIgnoreCase) == 0) 
     221            { 
     222                return new ExcelConverter(options); 
     223            } 
     224            else if (string.Compare(typeName, "powerpoint", StringComparison.OrdinalIgnoreCase) == 0) 
     225            { 
     226                return new PowerPointConverter(options); 
     227            } 
     228 
     229            throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid type: {0}", typeName)); 
     230        } 
     231 
     232        public static string GetTempFileName(string extension) 
     233        { 
     234            string tempPath = Path.GetTempPath(); 
     235            new FileIOPermission(FileIOPermissionAccess.Write, tempPath).Demand(); 
     236            string tmpFileName = Path.Combine(tempPath, Guid.NewGuid().ToString() + extension); 
     237            using (File.Create(tmpFileName)) { } 
     238 
     239            return tmpFileName; 
     240        } 
     241 
     242        #endregion 
     243    } 
    203244} 
  • trunk/OfficeConvert/buildOffice2007/Source/ExcelConverter.cs

    r361 r414  
    1818        using Microsoft.Office.Core; 
    1919        using Excel = Microsoft.Office.Interop.Excel; 
     20    using System.IO; 
    2021 
    2122        internal class ExcelConverter : Converter 
     
    3738                #region Constructors 
    3839 
    39                 public ExcelConverter() 
     40                public ExcelConverter(Options options) 
     41            : base(options) 
    4042                { 
    4143                        this._application = new Excel.ApplicationClass(); 
     
    7678                        MsoAutomationSecurity originalAutomationSecurity = this._application.AutomationSecurity; 
    7779                        this._application.AutomationSecurity = MsoAutomationSecurity.msoAutomationSecurityForceDisable; 
    78  
    79                         object writeResPassword = Type.Missing; 
    80                         object addToMru = false; 
    81  
    82                         string sourceFileName = inputFilePath; 
    83                         object updateLinks = Type.Missing; 
    84                         object openReadOnly = true; 
    85                         object openFormat = Type.Missing; 
    86                         object openPassword = password ?? Type.Missing; 
    87                         object ignoreReadOnlyRecommended = Type.Missing; 
    88                         object origin = Type.Missing; 
    89                         object delimiter = Type.Missing; 
    90                         object editable = Type.Missing; 
    91                         object notify = Type.Missing; 
    92                         object Converter = Type.Missing; // 0 
    93                         object LocalDataStoreSlot = Type.Missing; 
    94                         object corruptLoad = Type.Missing; 
    95  
    96                         Excel.Workbook workbook = this._application.Workbooks.Open(sourceFileName, updateLinks, openReadOnly, openFormat, openPassword, writeResPassword, ignoreReadOnlyRecommended, origin, delimiter, editable, notify, Converter, addToMru, LocalDataStoreSlot, corruptLoad); 
    97  
    98                         if (format.SaveFormat != ExcelPdfFormat && format.SaveFormat != ExcelXpsFormat) 
    99                         { 
    100                                 object targetFileName = outputFilePath; 
    101                                 object saveFormat = format.SaveFormat; 
    102                                 object savePassword = password ?? Type.Missing; 
    103                                 object readOnlyRecommended = Type.Missing; 
    104                                 object createBackup = Type.Missing; 
    105                                 Excel.XlSaveAsAccessMode accessMode = Excel.XlSaveAsAccessMode.xlNoChange; 
    106                                 object conflictResolution = Type.Missing; 
    107                                 object textCodepage = Type.Missing; 
    108                                 object textVisualLayout = Type.Missing; 
    109                                 object local = Type.Missing; 
    110  
    111                                 workbook.SaveAs(targetFileName, saveFormat, savePassword, writeResPassword, readOnlyRecommended, createBackup, accessMode, conflictResolution, addToMru, textCodepage, textVisualLayout, local); 
    112                         } 
    113                         else 
    114                         { 
    115                                 Excel.XlFixedFormatType type; 
    116                                 switch (format.SaveFormat) 
    117                                 { 
    118                                         case ExcelXpsFormat: 
    119                                                 type = Excel.XlFixedFormatType.xlTypeXPS; 
    120                                                 break; 
    121                                         default: 
    122                                                 type = Excel.XlFixedFormatType.xlTypePDF; 
    123                                                 break; 
    124                                 } 
    125  
    126                                 object targetFileName = outputFilePath; 
    127                                 object quality = Type.Missing; 
    128                                 object includeDocProperties = Type.Missing; 
    129                                 object ignorePrintAreas = Type.Missing; 
    130                                 object from = Type.Missing; 
    131                                 object to = Type.Missing; 
    132                                 object openAfterPublish = Type.Missing; 
    133                                 object fixedFormatExtClassPtr = Type.Missing; 
    134  
    135                                 workbook.ExportAsFixedFormat(type, targetFileName, quality, includeDocProperties, ignorePrintAreas, from, to, openAfterPublish, fixedFormatExtClassPtr); 
    136                         } 
    137  
    138                         object saveChanges = false; 
    139                         object filename = Type.Missing; 
    140                         object routeWorkbook = true; 
    141  
    142                         workbook.Close(saveChanges, filename, routeWorkbook); 
    143  
     80            this._application.DisplayAlerts = false; 
     81 
     82            string tempFilePath = Converter.GetTempFileName(".xlsx"); 
     83            if (this.Options.UseAddin && Path.GetExtension(inputFilePath) == ".ods") 
     84            { 
     85                // convert ods to xlsx 
     86                this.ConvertWithOdfConverter(inputFilePath, tempFilePath); 
     87                inputFilePath = tempFilePath; 
     88            } 
     89 
     90            object writeResPassword = Type.Missing; 
     91            object addToMru = false; 
     92 
     93            string sourceFileName = inputFilePath; 
     94            object updateLinks = Type.Missing; 
     95            object openReadOnly = true; 
     96            object openFormat = Type.Missing; 
     97            object openPassword = password ?? Type.Missing; 
     98            object ignoreReadOnlyRecommended = Type.Missing; 
     99            object origin = Type.Missing; 
     100            object delimiter = Type.Missing; 
     101            object editable = Type.Missing; 
     102            object notify = Type.Missing; 
     103            object converter = Type.Missing; // 0 
     104            object localDataStoreSlot = Type.Missing; 
     105            object corruptLoad = Type.Missing; 
     106 
     107            Excel.Workbook workbook = this._application.Workbooks.Open(sourceFileName, updateLinks, openReadOnly, openFormat,  
     108                openPassword, writeResPassword, ignoreReadOnlyRecommended, origin, delimiter, editable,  
     109                notify, converter, addToMru, localDataStoreSlot, corruptLoad); 
     110 
     111            object targetFileName = outputFilePath; 
     112            object saveFormat = format.SaveFormat; 
     113            object savePassword = password ?? Type.Missing; 
     114            object readOnlyRecommended = Type.Missing; 
     115            object createBackup = Type.Missing; 
     116            Excel.XlSaveAsAccessMode accessMode = Excel.XlSaveAsAccessMode.xlNoChange; 
     117            object conflictResolution = Type.Missing; 
     118            object textCodepage = Type.Missing; 
     119            object textVisualLayout = Type.Missing; 
     120            object local = Type.Missing; 
     121            object saveChanges = false; 
     122            object filename = Type.Missing; 
     123            object routeWorkbook = true; 
     124 
     125            string tempFilePath2 = Converter.GetTempFileName(".xlsx"); 
     126            if (this.Options.UseAddin && format.SaveFormat == (int)Excel.XlFileFormat.xlOpenDocumentSpreadsheet) 
     127            { 
     128                // export to ods using addin 
     129                saveFormat = Excel.XlFileFormat.xlOpenXMLWorkbook; 
     130                object tempOpenXmlDocument = tempFilePath2; 
     131                workbook.SaveAs(tempOpenXmlDocument, saveFormat, savePassword, writeResPassword, readOnlyRecommended, createBackup, accessMode, conflictResolution, addToMru, textCodepage, textVisualLayout, local); 
     132                workbook.Close(saveChanges, filename, routeWorkbook); 
     133 
     134                this.ConvertWithOdfConverter(tempFilePath2, outputFilePath); 
     135            } 
     136            else if (format.SaveFormat != ExcelPdfFormat && format.SaveFormat != ExcelXpsFormat) 
     137            { 
     138                workbook.SaveAs(targetFileName, saveFormat, savePassword, writeResPassword, readOnlyRecommended, createBackup, accessMode, conflictResolution, addToMru, textCodepage, textVisualLayout, local); 
     139                workbook.Close(saveChanges, filename, routeWorkbook); 
     140            } 
     141            else 
     142            { 
     143                Excel.XlFixedFormatType type; 
     144                switch (format.SaveFormat) 
     145                { 
     146                    case ExcelXpsFormat: 
     147                        type = Excel.XlFixedFormatType.xlTypeXPS; 
     148                        break; 
     149                    default: 
     150                        type = Excel.XlFixedFormatType.xlTypePDF; 
     151                        break; 
     152                } 
     153 
     154                object quality = Type.Missing; 
     155                object includeDocProperties = Type.Missing; 
     156                object ignorePrintAreas = Type.Missing; 
     157                object from = Type.Missing; 
     158                object to = Type.Missing; 
     159                object openAfterPublish = Type.Missing; 
     160                object fixedFormatExtClassPtr = Type.Missing; 
     161 
     162                workbook.ExportAsFixedFormat(type, targetFileName, quality, includeDocProperties, ignorePrintAreas, from, to, openAfterPublish, fixedFormatExtClassPtr); 
     163                workbook.Close(saveChanges, filename, routeWorkbook); 
     164            } 
     165 
     166            if (File.Exists(tempFilePath)) 
     167            { 
     168                File.Delete(tempFilePath); 
     169            } 
     170            if (File.Exists(tempFilePath2)) 
     171            { 
     172                File.Delete(tempFilePath2); 
     173            } 
     174            this._application.DisplayAlerts = true; 
    144175                        this._application.AutomationSecurity = originalAutomationSecurity; 
    145176                } 
  • trunk/OfficeConvert/buildOffice2007/Source/OfficeConvert.csproj

    r361 r414  
    44    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> 
    55    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> 
    6     <ProductVersion>9.0.30729</ProductVersion> 
     6    <ProductVersion>9.0.21022</ProductVersion> 
    77    <SchemaVersion>2.0</SchemaVersion> 
    88    <ProjectGuid>{83804735-BF9B-4B57-9856-09DA8E7156A1}</ProjectGuid> 
     
    4343    <TreatWarningsAsErrors>true</TreatWarningsAsErrors> 
    4444    <RunCodeAnalysis>true</RunCodeAnalysis> 
     45    <PlatformTarget>x86</PlatformTarget> 
    4546  </PropertyGroup> 
    4647  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> 
  • trunk/OfficeConvert/buildOffice2007/Source/Options.cs

    r361 r414  
    1616        using System.Globalization; 
    1717        using System.Text; 
     18    using Microsoft.Win32; 
     19    using System.IO; 
    1820 
    1921        internal class Options 
     
    2628                private string _outputFilePath; 
    2729                private string _password; 
     30        private bool _useAddin; 
    2831                private bool _showFormats; 
    2932                private bool _showVersion; 
     
    103106                } 
    104107 
     108        public virtual bool UseAddin 
     109        { 
     110            get 
     111            { 
     112                return this._useAddin; 
     113            } 
     114            set 
     115            { 
     116                this._useAddin = value; 
     117            } 
     118        } 
     119 
     120        public string OpenXmlOdfTranslatorPath 
     121        { 
     122            get 
     123            { 
     124                string path; 
     125                using (RegistryKey key = Registry.ClassesRoot.OpenSubKey(@"CLSID\{F474D30D-3450-423E-AE62-BD3307544E86}\InprocServer32")) 
     126                { 
     127                    path = (string)key.GetValue(""); 
     128                } 
     129                if (!string.IsNullOrEmpty(path)) 
     130                { 
     131                    path = Path.GetDirectoryName(path); 
     132                } 
     133                return Path.Combine(path, "OdfConverter.exe"); 
     134            } 
     135        } 
     136         
    105137                public virtual bool ShowFormats 
    106138                { 
     
    288320                                                        } 
    289321                                                } 
     322                        else if (string.Compare(argumentName, "a", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(argumentName, "useAddin", StringComparison.OrdinalIgnoreCase) == 0) 
     323                        { 
     324                            this._useAddin = true; 
     325                        } 
    290326                                                else if (string.Compare(argumentName, "l", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(argumentName, "list", StringComparison.OrdinalIgnoreCase) == 0) 
    291327                                                { 
     
    296332                                                        this._showHelp = true; 
    297333                                                } 
    298                                                 else if (string.Compare(argumentName, "debug", StringComparison.OrdinalIgnoreCase) == 0) 
    299                                                 { 
    300                                                         this._enableDebug = true; 
    301                                                 } 
    302                                                 else 
    303                                                 { 
    304                                                         throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid argument: {0}", argument)); 
    305                                                 } 
     334                        else if (string.Compare(argumentName, "debug", StringComparison.OrdinalIgnoreCase) == 0) 
     335                        { 
     336                            this._enableDebug = true; 
     337                        } 
     338                        else 
     339                        { 
     340                            throw new OptionException(string.Format(CultureInfo.CurrentCulture, "Invalid argument: {0}", argument)); 
     341                        } 
    306342                                        } 
    307343                                        else 
     
    363399                                                        } 
    364400                                                } 
     401                        else if (string.Compare(argumentName, "useAddin", StringComparison.OrdinalIgnoreCase) == 0) 
     402                        { 
     403                            this._useAddin = true; 
     404                        } 
    365405                                                else if (string.Compare(argumentName, "list", StringComparison.OrdinalIgnoreCase) == 0) 
    366406                                                { 
  • trunk/OfficeConvert/buildOffice2007/Source/PowerPointConverter.cs

    r361 r414  
    1818        using Microsoft.Office.Core; 
    1919        using PowerPoint = Microsoft.Office.Interop.PowerPoint; 
     20    using System.IO; 
    2021 
    2122        internal class PowerPointConverter : Converter 
     
    3031                #region Constructors 
    3132 
    32                 public PowerPointConverter() 
     33                public PowerPointConverter(Options options) 
     34            : base(options) 
    3335                { 
    3436                        this._application = new PowerPoint.ApplicationClass(); 
     
    7072                        this._application.AutomationSecurity = MsoAutomationSecurity.msoAutomationSecurityForceDisable; 
    7173 
     74            string tempFilePath = Converter.GetTempFileName(".pptx"); 
     75            if (this.Options.UseAddin && Path.GetExtension(inputFilePath) == ".odp") 
     76            { 
     77                // convert odp to pptx 
     78                this.ConvertWithOdfConverter(inputFilePath, tempFilePath); 
     79                inputFilePath = tempFilePath; 
     80            } 
     81 
    7282                        string sourceFileName = inputFilePath; 
    7383                        MsoTriState openReadonly = MsoTriState.msoTrue; 
     
    8191                        MsoTriState embedTrueTypeFonts = MsoTriState.msoTriStateMixed; 
    8292 
    83                         presentation.SaveAs(targetFileName, saveFormat, embedTrueTypeFonts); 
     93            string tempFilePath2 = Converter.GetTempFileName(".pptx"); 
     94            if (this.Options.UseAddin && format.SaveFormat == (int)PowerPoint.PpSaveAsFileType.ppSaveAsOpenDocumentPresentation) 
     95            { 
     96                // export to odt using addin 
     97                saveFormat = PowerPoint.PpSaveAsFileType.ppSaveAsOpenXMLPresentation; 
     98                string tempOpenXmlDocument = tempFilePath2; 
     99                presentation.SaveAs(tempOpenXmlDocument, saveFormat, embedTrueTypeFonts); 
     100                presentation.Close(); 
    84101 
    85                         presentation.Close(); 
     102                this.ConvertWithOdfConverter(tempFilePath2, outputFilePath); 
     103            } 
     104            else 
     105            { 
     106                presentation.SaveAs(targetFileName, saveFormat, embedTrueTypeFonts); 
     107                presentation.Close(); 
     108            } 
    86109 
     110            if (File.Exists(tempFilePath)) 
     111            { 
     112                File.Delete(tempFilePath); 
     113            } 
     114            if (File.Exists(tempFilePath2)) 
     115            { 
     116                File.Delete(tempFilePath2); 
     117            } 
    87118                        this._application.AutomationSecurity = originalAutomationSecurity; 
    88119                } 
  • trunk/OfficeConvert/buildOffice2007/Source/Program.cs

    r361 r414  
    1717        using System.Reflection; 
    1818        using System.Text; 
     19    using System.Threading; 
    1920 
    2021        internal class Program 
     
    4041                        try 
    4142                        { 
     43                // set the culture to en-US to circumvent an OLE automation bug in Excel 
     44                Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); 
     45                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); 
    4246                                DisplayName(); 
    4347 
     
    5761                                        if (options.ShowFormats) 
    5862                                        { 
    59                                                 using (Converter converter = new WordConverter()) 
     63                                                using (Converter converter = new WordConverter(options)) 
    6064                                                { 
    6165                                                        converter.Initialize(); 
    6266                                                        DisplayFormats("Word", converter.Formats); 
    6367                                                } 
    64                                                 using (Converter converter = new ExcelConverter()) 
     68                                                using (Converter converter = new ExcelConverter(options)) 
    6569                                                { 
    6670                                                        converter.Initialize(); 
    6771                                                        DisplayFormats("Excel", converter.Formats); 
    6872                                                } 
    69                                                 using (Converter converter = new PowerPointConverter()) 
    70                                                 { 
    71                                                         converter.Initialize(); 
    72                                                         DisplayFormats("Powerpoint", converter.Formats); 
     73                                                using (Converter converter = new PowerPointConverter(options)) 
     74                                                { 
     75                                                        converter.Initialize(); 
     76                                                        DisplayFormats("PowerPoint", converter.Formats); 
    7377                                                } 
    7478                                        } 
     
    122126                        Console.WriteLine(); 
    123127                        Console.WriteLine("  source                  Specifies the file to convert."); 
    124                         Console.WriteLine("  /T type                 Specifies the type of document to convert. Inferred"); 
     128                        Console.WriteLine("  /T type                 SpecifiWorking Effectively with Legacy Codees the type of document to convert. Inferred"); 
    125129                        Console.WriteLine("                          from file extension if omitted."); 
    126130                        Console.WriteLine("                            Options: word, excel, powerpoint"); 
     
    129133                        Console.WriteLine("  /O destination          Specifies the location to output the converted file."); 
    130134                        Console.WriteLine("  /P password             Specifies the password used to open the file."); 
     135            Console.WriteLine("  /A or /useaddin         Specifies that the OpenXML/ODF Translator Add-in is to be used."); 
    131136                        Console.WriteLine("  /L                      Lists all supported formats."); 
    132137                        Console.WriteLine("  /?                      Displays this help."); 
     
    145150                        Console.WriteLine("  --output=FILE           Specifies the location to output the converted file."); 
    146151                        Console.WriteLine("  --password=PASSWORD     Specifies the password used to open the file."); 
     152            Console.WriteLine("  --useaddin              Specifies that the OpenXML/ODF Translator Add-in is to be used."); 
    147153                        Console.WriteLine("  --list                  Lists all supported formats."); 
    148154                        Console.WriteLine("  --version               Displays the version information."); 
  • trunk/OfficeConvert/buildOffice2007/Source/WordConverter.cs

    r361 r414  
    1111namespace FishDawg.OfficeConvert 
    1212{ 
    13         using System; 
    14         using System.Collections.Generic; 
    15         using System.Diagnostics; 
    16         using System.Globalization; 
    17         using System.Text; 
    18         using Microsoft.Office.Core; 
    19         using Word = Microsoft.Office.Interop.Word; 
    20  
    21         internal class WordConverter : Converter 
    22         { 
    23                 #region Fields 
    24  
    25                 private Word.Application _application; 
    26                 private List<FormatInfo> _formats; 
    27  
    28                 #endregion 
    29  
    30                 #region Constructors 
    31  
    32                 public WordConverter() 
    33                 { 
    34                         this._application = new Word.ApplicationClass(); 
    35                 } 
    36  
    37                 #endregion 
    38  
    39                 #region Properties 
    40  
    41                 public override IList<FormatInfo> Formats 
    42                 { 
    43                         get 
    44                         { 
    45                                 return this._formats; 
    46                         } 
    47                 } 
    48  
    49                 #endregion 
    50  
    51                 #region Methods 
    52  
    53                 public override void Initialize() 
    54                 { 
    55                         base.Initialize(); 
    56  
    57                         if (this._application == null) 
    58                         { 
    59                                 throw new ObjectDisposedException(this.GetType().Name); 
    60                         } 
    61  
    62                         this._formats = LoadFormats(); 
    63                 } 
    64  
    65                 public override void Convert(string inputFilePath, FormatInfo format, string outputFilePath, string password) 
    66                 { 
    67                         base.Convert(inputFilePath, format, outputFilePath, password); 
    68  
    69                         MsoAutomationSecurity originalAutomationSecurity = this._application.AutomationSecurity; 
    70                         this._application.AutomationSecurity = MsoAutomationSecurity.msoAutomationSecurityForceDisable; 
    71  
    72                         object addToRecentFiles = false; 
    73                         object encoding = Type.Missing; 
    74  
    75                         object sourceFileName = inputFilePath; 
    76                         object confirmConversions = Type.Missing; 
    77                         object openReadonly = true; 
    78                         object openPassword = password ?? Type.Missing; 
    79                         object templatePassword = Type.Missing; 
    80                         object revert = Type.Missing; 
    81                         object newDocumentPassword = Type.Missing; 
    82                         object newTemplatePassword = Type.Missing; 
    83                         object openFormat = Type.Missing; // Word.WdOpenFormat.wdOpenFormatAuto 
    84                         object visible = Type.Missing; 
    85                         object openAndRepair = Type.Missing; 
    86                         object documentDirection = Type.Missing; 
    87                         object noEncodingDialog = Type.Missing; 
    88                         object xmlTransform = Type.Missing; 
    89  
    90                         Word.Document document = this._application.Documents.Open(ref sourceFileName, ref confirmConversions, ref openReadonly, ref addToRecentFiles, ref openPassword, ref templatePassword, ref revert, ref newDocumentPassword, ref newTemplatePassword, ref openFormat, ref encoding, ref visible, ref openAndRepair, ref documentDirection, ref noEncodingDialog, ref xmlTransform); 
    91  
    92                         object targetFileName = outputFilePath; 
    93                         object saveFormat = format.SaveFormat; 
    94                         object lockComments = Type.Missing; 
    95                         object readPassword = password ?? Type.Missing; 
    96                         object writePassowrd = Type.Missing; 
    97                         object readOnlyRecommended = Type.Missing; 
    98                         object embedTrueTypeFonts = Type.Missing; 
    99                         object saveNativePictureFormat = Type.Missing; 
    100                         object saveFormsData = Type.Missing; 
    101                         object saveAsAOCELetter = Type.Missing; 
    102                         object insertLineBreaks = Type.Missing; 
    103                         object allowSubstitutions = Type.Missing; 
    104                         object lineEnding = Type.Missing; 
    105                         object addBiDiMarks = Type.Missing; 
    106  
    107                         document.SaveAs(ref targetFileName, ref saveFormat, ref lockComments, ref readPassword, ref addToRecentFiles, ref writePassowrd, ref readOnlyRecommended, ref embedTrueTypeFonts, ref saveNativePictureFormat, ref saveFormsData, ref saveAsAOCELetter, ref encoding, ref insertLineBreaks, ref allowSubstitutions, ref lineEnding, ref addBiDiMarks); 
    108  
    109                         object saveChanges = Word.WdSaveOptions.wdDoNotSaveChanges; 
    110                         object originalFormat = Word.WdOriginalFormat.wdOriginalDocumentFormat; 
    111                         object routeDocument = true; 
    112  
    113                         ((Word._Document)document).Close(ref saveChanges, ref originalFormat, ref routeDocument); 
    114  
    115                         this._application.AutomationSecurity = originalAutomationSecurity; 
    116                 } 
    117  
    118                 protected override void Dispose(bool disposing) 
    119                 { 
    120                         base.Dispose(disposing); 
    121                         QuitApplication(); 
    122                 } 
    123  
    124                 private List<FormatInfo> LoadFormats() 
    125                 { 
    126                         Debug.Assert(this._application != null); 
    127  
    128                         Word.FileConverters fileConverters = this._application.FileConverters; 
    129  
    130                         List<FormatInfo> formats = new List<FormatInfo>(11 + fileConverters.Count); 
    131                         formats.Add(new FormatInfo("docx", "Word 2007+ Document", "docx", Word.WdSaveFormat.wdFormatDocumentDefault)); 
    132                         formats.Add(new FormatInfo("doc", "Word 97-2003 Document", "doc", Word.WdSaveFormat.wdFormatDocument97)); 
    133                         formats.Add(new FormatInfo("pdf", "PDF Document", "pdf", Word.WdSaveFormat.wdFormatPDF)); 
    134                         formats.Add(new FormatInfo("xps", "XPS Document", "xps", Word.WdSaveFormat.wdFormatXPS)); 
    135                         formats.Add(new FormatInfo("mhtml", "Web Archive", "mht", Word.WdSaveFormat.wdFormatWebArchive)); 
    136                         formats.Add(new FormatInfo("html", "Web Page", "htm", Word.WdSaveFormat.wdFormatHTML)); 
    137                         formats.Add(new FormatInfo("fhtml", "Web Page, Filtered", "htm", Word.WdSaveFormat.wdFormatFilteredHTML)); 
    138                         formats.Add(new FormatInfo("rtf", "Rich Text Format", "rtf", Word.WdSaveFormat.wdFormatRTF)); 
    139                         formats.Add(new FormatInfo("txt", "Plain Text", "txt", Word.WdSaveFormat.wdFormatText)); 
    140                         formats.Add(new FormatInfo("xml", "XML Document", "xml", Word.WdSaveFormat.wdFormatXMLDocument)); 
    141                         formats.Add(new FormatInfo("odt", "OpenDocument Text", "odt", Word.WdSaveFormat.wdFormatOpenDocumentText)); 
    142  
    143                         foreach (Word.FileConverter fileConverter in fileConverters) 
    144                         { 
    145                                 if (fileConverter.CanSave && !string.IsNullOrEmpty(fileConverter.ClassName)) 
    146                                 { 
    147                                         string[] fileExtensions = fileConverter.Extensions.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); 
    148                                         if (fileExtensions.Length > 0) 
    149                                         { 
    150                                                 string name = fileConverter.ClassName.Trim().ToLower(CultureInfo.CurrentCulture); 
    151  
    152                                                 bool hasNameConflict; 
    153                                                 int customFormatNumber = 1; 
    154                                                 do 
    155                                                 { 
    156                                                         hasNameConflict = false; 
    157  
    158                                                         foreach (FormatInfo format in formats) 
    159                                                         { 
    160                                                                 if (string.Compare(format.Name, name, StringComparison.OrdinalIgnoreCase) == 0) 
    161                                                                 { 
    162                                                                         hasNameConflict = true; 
    163                                                                         ++customFormatNumber; 
    164                                                                         name = string.Format(CultureInfo.CurrentCulture, "{0}-{1}", fileConverter.ClassName.Trim().ToLower(CultureInfo.CurrentCulture), customFormatNumber); 
    165                                                                         break; 
    166                                                                 } 
    167                                                         } 
    168                                                 } 
    169                                                 while (hasNameConflict); 
    170  
    171                                                 formats.Add(new FormatInfo(name, fileConverter.FormatName, fileExtensions[0], fileConverter.SaveFormat)); 
    172                                         } 
    173                                 } 
    174                         } 
    175  
    176                         return formats; 
    177                 } 
    178  
    179                 private void QuitApplication() 
    180                 { 
    181                         object saveChanges = Word.WdSaveOptions.wdDoNotSaveChanges; 
    182                         object originalFormat = Type.Missing; 
    183                         object routeDocument = Type.Missing; 
    184  
    185                         ((Word._Application)this._application).Quit(ref saveChanges, ref originalFormat, ref routeDocument); 
    186  
    187                         this._application = null; 
    188                 } 
    189  
    190                 #endregion 
    191         } 
     13    using System; 
     14    using System.Collections.Generic; 
     15    using System.Diagnostics; 
     16    using System.Globalization; 
     17    using System.Text; 
     18    using Microsoft.Office.Core; 
     19    using Word = Microsoft.Office.Interop.Word; 
     20    using System.IO; 
     21 
     22    internal class WordConverter : Converter 
     23    { 
     24        #region Fields 
     25 
     26        private Word.Application _application; 
     27        private List<FormatInfo> _formats; 
     28 
     29        #endregion 
     30 
     31        #region Constructors 
     32 
     33        public WordConverter(Options options) 
     34            : base(options) 
     35        { 
     36            this._application = new Word.ApplicationClass(); 
     37        } 
     38 
     39        #endregion 
     40 
     41        #region Properties 
     42 
     43        public override IList<FormatInfo> Formats 
     44        { 
     45            get 
     46            { 
     47                return this._formats; 
     48            } 
     49        } 
     50 
     51        #endregion 
     52 
     53        #region Methods 
     54 
     55        public override void Initialize() 
     56        { 
     57            base.Initialize(); 
     58 
     59            if (this._application == null) 
     60            { 
     61                throw new ObjectDisposedException(this.GetType().Name); 
     62            } 
     63 
     64            this._formats = LoadFormats(); 
     65        } 
     66 
     67        public override void Convert(string inputFilePath, FormatInfo format, string outputFilePath, string password) 
     68        { 
     69            base.Convert(inputFilePath, format, outputFilePath, password); 
     70 
     71            MsoAutomationSecurity originalAutomationSecurity = this._application.AutomationSecurity; 
     72            this._application.AutomationSecurity = MsoAutomationSecurity.msoAutomationSecurityForceDisable; 
     73            this._application.DisplayAlerts = Microsoft.Office.Interop.Word.WdAlertLevel.wdAlertsNone; 
     74 
     75            string tempFilePath = Converter.GetTempFileName(".docx"); 
     76            if (this.Options.UseAddin && Path.GetExtension(inputFilePath) == ".odt") 
     77            { 
     78                // convert odt to docx 
     79                this.ConvertWithOdfConverter(inputFilePath, tempFilePath); 
     80                inputFilePath = tempFilePath; 
     81            } 
     82 
     83            object addToRecentFiles = false; 
     84            object encoding = Type.Missing; 
     85 
     86            object sourceFileName = inputFilePath; 
     87            object confirmConversions = Type.Missing; 
     88            object openReadonly = true; 
     89            object openPassword = password ?? Type.Missing; 
     90            object templatePassword = Type.Missing; 
     91            object revert = Type.Missing; 
     92            object newDocumentPassword = Type.Missing; 
     93            object newTemplatePassword = Type.Missing; 
     94            object openFormat = Type.Missing; // Word.WdOpenFormat.wdOpenFormatAuto 
     95            object visible = Type.Missing; 
     96            object openAndRepair = Type.Missing; 
     97            object documentDirection = Type.Missing; 
     98            object noEncodingDialog = Type.Missing; 
     99            object xmlTransform = Type.Missing; 
     100 
     101            Word.Document document = this._application.Documents.Open(ref sourceFileName, ref confirmConversions, ref openReadonly, ref addToRecentFiles, ref openPassword, ref templatePassword, ref revert, ref newDocumentPassword, ref newTemplatePassword, ref openFormat, ref encoding, ref visible, ref openAndRepair, ref documentDirection, ref noEncodingDialog, ref xmlTransform); 
     102 
     103            object targetFileName = outputFilePath; 
     104            object saveFormat = format.SaveFormat; 
     105            object lockComments = Type.Missing; 
     106            object readPassword = password ?? Type.Missing; 
     107            object writePassowrd = Type.Missing; 
     108            object readOnlyRecommended = Type.Missing; 
     109            object embedTrueTypeFonts = Type.Missing; 
     110            object saveNativePictureFormat = Type.Missing; 
     111            object saveFormsData = Type.Missing; 
     112            object saveAsAOCELetter = Type.Missing; 
     113            object insertLineBreaks = Type.Missing; 
     114            object allowSubstitutions = Type.Missing; 
     115            object lineEnding = Type.Missing; 
     116            object addBiDiMarks = Type.Missing; 
     117            object saveChanges = Word.WdSaveOptions.wdDoNotSaveChanges; 
     118            object originalFormat = Word.WdOriginalFormat.wdOriginalDocumentFormat; 
     119            object routeDocument = true; 
     120 
     121 
     122            string tempFilePath2 = Converter.GetTempFileName(".docx"); 
     123            if (this.Options.UseAddin && format.SaveFormat == (int)Word.WdSaveFormat.wdFormatOpenDocumentText) 
     124            { 
     125                // export to odt using addin 
     126                saveFormat = Word.WdSaveFormat.wdFormatXMLDocument; 
     127                object tempOpenXmlDocument = tempFilePath2; 
     128                document.SaveAs(ref tempOpenXmlDocument, ref saveFormat, ref lockComments, ref readPassword, ref addToRecentFiles, ref writePassowrd, ref readOnlyRecommended, ref embedTrueTypeFonts, ref saveNativePictureFormat, ref saveFormsData, ref saveAsAOCELetter, ref encoding, ref insertLineBreaks, ref allowSubstitutions, ref lineEnding, ref addBiDiMarks); 
     129                ((Word._Document)document).Close(ref saveChanges, ref originalFormat, ref routeDocument); 
     130 
     131                this.ConvertWithOdfConverter(tempFilePath2, outputFilePath); 
     132            } 
     133            else 
     134            { 
     135                document.SaveAs(ref targetFileName, ref saveFormat, ref lockComments, ref readPassword, ref addToRecentFiles, ref writePassowrd, ref readOnlyRecommended, ref embedTrueTypeFonts, ref saveNativePictureFormat, ref saveFormsData, ref saveAsAOCELetter, ref encoding, ref insertLineBreaks, ref allowSubstitutions, ref lineEnding, ref addBiDiMarks); 
     136                ((Word._Document)document).Close(ref saveChanges, ref originalFormat, ref routeDocument); 
     137            } 
     138 
     139            if (File.Exists(tempFilePath)) 
     140            { 
     141                File.Delete(tempFilePath); 
     142            } 
     143            if (File.Exists(tempFilePath2)) 
     144            { 
     145                File.Delete(tempFilePath2); 
     146            } 
     147            this._application.DisplayAlerts = Microsoft.Office.Interop.Word.WdAlertLevel.wdAlertsAll; 
     148            this._application.AutomationSecurity = originalAutomationSecurity; 
     149        } 
     150 
     151        protected override void Dispose(bool disposing) 
     152        { 
     153            base.Dispose(disposing); 
     154            QuitApplication(); 
     155        } 
     156 
     157        private List<FormatInfo> LoadFormats() 
     158        { 
     159            Debug.Assert(this._application != null); 
     160 
     161            Word.FileConverters fileConverters = this._application.FileConverters; 
     162 
     163            List<FormatInfo> formats = new List<FormatInfo>(11 + fileConverters.Count); 
     164            formats.Add(new FormatInfo("docx", "Word 2007+ Document", "docx", Word.WdSaveFormat.wdFormatDocumentDefault)); 
     165            formats.Add(new FormatInfo("doc", "Word 97-2003 Document", "doc", Word.WdSaveFormat.wdFormatDocument97)); 
     166            formats.Add(new FormatInfo("pdf", "PDF Document", "pdf", Word.WdSaveFormat.wdFormatPDF)); 
     167            formats.Add(new FormatInfo("xps", "XPS Document", "xps", Word.WdSaveFormat.wdFormatXPS)); 
     168            formats.Add(new FormatInfo("mhtml", "Web Archive", "mht", Word.WdSaveFormat.wdFormatWebArchive)); 
     169            formats.Add(new FormatInfo("html", "Web Page", "htm", Word.WdSaveFormat.wdFormatHTML)); 
     170            formats.Add(new FormatInfo("fhtml", "Web Page, Filtered", "htm", Word.WdSaveFormat.wdFormatFilteredHTML)); 
     171            formats.Add(new FormatInfo("rtf", "Rich Text Format", "rtf", Word.WdSaveFormat.wdFormatRTF)); 
     172            formats.Add(new FormatInfo("txt", "Plain Text", "txt", Word.WdSaveFormat.wdFormatText)); 
     173            formats.Add(new FormatInfo("xml", "XML Document", "xml", Word.WdSaveFormat.wdFormatXMLDocument)); 
     174            formats.Add(new FormatInfo("odt", "OpenDocument Text", "odt", Word.WdSaveFormat.wdFormatOpenDocumentText)); 
     175 
     176            foreach (Word.FileConverter fileConverter in fileConverters) 
     177            { 
     178                if (fileConverter.CanSave && !string.IsNullOrEmpty(fileConverter.ClassName)) 
     179                { 
     180                    string[] fileExtensions = fileConverter.Extensions.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); 
     181                    if (fileExtensions.Length > 0) 
     182                    { 
     183                        string name = fileConverter.ClassName.Trim().ToLower(CultureInfo.CurrentCulture); 
     184 
     185                        bool hasNameConflict; 
     186                        int customFormatNumber = 1; 
     187                        do 
     188                        { 
     189                            hasNameConflict = false; 
     190 
     191                            foreach (FormatInfo format in formats) 
     192                            { 
     193                                if (string.Compare(format.Name, name, StringComparison.OrdinalIgnoreCase) == 0) 
     194                                { 
     195                                    hasNameConflict = true; 
     196                                    ++customFormatNumber; 
     197                                    name = string.Format(CultureInfo.CurrentCulture, "{0}-{1}", fileConverter.ClassName.Trim().ToLower(CultureInfo.CurrentCulture), customFormatNumber); 
     198                                    break; 
     199                                } 
     200                            } 
     201                        } 
     202                        while (hasNameConflict); 
     203 
     204                        formats.Add(new FormatInfo(name, fileConverter.FormatName, fileExtensions[0], fileConverter.SaveFormat)); 
     205                    } 
     206                } 
     207            } 
     208 
     209            return formats; 
     210        } 
     211 
     212        private void QuitApplication() 
     213        { 
     214            object saveChanges = Word.WdSaveOptions.wdDoNotSaveChanges; 
     215            object originalFormat = Type.Missing; 
     216            object routeDocument = Type.Missing; 
     217 
     218            ((Word._Application)this._application).Quit(ref saveChanges, ref originalFormat, ref routeDocument); 
     219 
     220            this._application = null; 
     221        } 
     222 
     223        #endregion 
     224    } 
    192225} 
Note: See TracChangeset for help on using the changeset viewer.