private void SetSlideSettings(Presentation presentation, SlideSettings settings)
{
try
{
MessageFilter.Register();
presentation.PageSetup.SlideWidth = (float)settings.SlideSize.Width * 72;
presentation.PageSetup.SlideHeight = (float)settings.SlideSize.Height * 72;
switch (settings.SlideSize.Orientation)
{
case SlideOrientationEnum.Landscape:
presentation.PageSetup.SlideOrientation = MsoOrientation.msoOrientationHorizontal;
break;
case SlideOrientationEnum.Portrait:
presentation.PageSetup.SlideOrientation = MsoOrientation.msoOrientationVertical;
break;
}
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public void AppendSlidesFromFile(string filePath, bool firstSlide)
{
if (!File.Exists(filePath))
{
return;
}
try
{
var thread = new Thread(delegate()
{
MessageFilter.Register();
var presentation = _powerPointObject.Presentations.Open(filePath, WithWindow: MsoTriState.msoFalse);
AppendSlide(presentation, -1, null, firstSlide);
presentation.Close();
});
thread.Start();
while (thread.IsAlive)
{
System.Windows.Forms.Application.DoEvents();
}
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public int GetActiveSlideIndex()
{
var slideIndex = -1;
try
{
MessageFilter.Register();
_powerPointObject.Activate();
var activeWindow = _powerPointObject.ActiveWindow;
if (activeWindow != null)
{
var view = activeWindow.View;
var slide = (Slide)view.Slide;
slideIndex = slide.SlideIndex;
Utilities.ReleaseComObject(slide);
Utilities.ReleaseComObject(view);
}
Utilities.ReleaseComObject(activeWindow);
}
catch { }
finally
{
MessageFilter.Revoke();
}
return(slideIndex);
}
public void BuildPdf(string targetFileName, IEnumerable <string> presentationFiles)
{
try
{
var thread = new Thread(delegate()
{
MessageFilter.Register();
if (presentationFiles == null || !presentationFiles.Any())
{
return;
}
var sourceFileName = String.Empty;
if (presentationFiles.Count() > 1)
{
sourceFileName = Path.GetTempFileName();
SavePrevSlideIndex();
var presentations = _powerPointObject.Presentations;
var presentation = presentations.Add(MsoTriState.msoFalse);
SetSlideSettings(presentation, SlideSettingsManager.Instance.SlideSettings);
var slideIndex = 0;
foreach (var presentationFile in presentationFiles)
{
var sourcePresentation = _powerPointObject.Presentations.Open(presentationFile, WithWindow: MsoTriState.msoFalse);
AppendSlide(sourcePresentation, -1, presentation, slideIndex == 0, slideIndex);
sourcePresentation.Close();
slideIndex++;
}
presentation.SaveAs(sourceFileName);
Utilities.ReleaseComObject(presentation);
Utilities.ReleaseComObject(presentations);
RestorePrevSlideIndex();
}
else
{
sourceFileName = presentationFiles.FirstOrDefault();
}
if (!String.IsNullOrEmpty(sourceFileName))
{
ConvertToPDF(sourceFileName, targetFileName);
}
});
thread.Start();
while (thread.IsAlive)
{
System.Windows.Forms.Application.DoEvents();
}
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public void ConvertToHtml(string oldFileName, string newFileName)
{
try
{
MessageFilter.Register();
Document document = _wordObject.Documents.Open(oldFileName);
document.SaveAs(newFileName, WdSaveFormat.wdFormatHTML);
(document).Close(false);
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public void ConvertToHtml(string oldFileName, string newFileName)
{
try
{
MessageFilter.Register();
var workbook = ExcelObject.Workbooks.Open(oldFileName, ReadOnly: true);
workbook.SaveAs(newFileName, XlFileFormat.xlHtml);
workbook.Close(false);
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public void PreparePresentation(string fileName, Action <Presentation> buildPresentation, bool generateImages = true)
{
try
{
var thread = new Thread(delegate()
{
SavePrevSlideIndex();
var presentation = _powerPointObject.Presentations.Open(SlideSettingsManager.Instance.GetLauncherTemplatePath(), MsoTriState.msoFalse, MsoTriState.msoFalse, MsoTriState.msoFalse);
if (presentation.Slides.Count > 0)
{
presentation.Slides[1].Delete();
}
buildPresentation(presentation);
MessageFilter.Register();
presentation.SaveAs(fileName, PpSaveAsFileType.ppSaveAsOpenXMLPresentation, MsoTriState.msoCTrue);
if (generateImages)
{
var destinationFolder = fileName.Replace(Path.GetExtension(fileName), string.Empty);
if (!Directory.Exists(destinationFolder))
{
Directory.CreateDirectory(destinationFolder);
}
if (presentation.Slides.Count > 0)
{
presentation.Export(destinationFolder, "PNG");
}
}
presentation.Close();
Utilities.ReleaseComObject(presentation);
RestorePrevSlideIndex();
});
thread.Start();
while (thread.IsAlive)
{
System.Windows.Forms.Application.DoEvents();
}
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public Presentation GetActivePresentation(bool create = true)
{
try
{
_activePresentation = _powerPointObject.ActivePresentation;
}
catch
{
_activePresentation = null;
if (create)
{
try
{
MessageFilter.Register();
if (_powerPointObject.Presentations.Count == 0)
{
var presentations = _powerPointObject.Presentations;
_activePresentation = presentations.Add(MsoTriState.msoCTrue);
Utilities.ReleaseComObject(presentations);
Slides slides = _activePresentation.Slides;
slides.Add(1, PpSlideLayout.ppLayoutTitle);
Utilities.ReleaseComObject(slides);
}
else
{
var presentations = _powerPointObject.Presentations;
_activePresentation = presentations[1];
Utilities.ReleaseComObject(presentations);
}
}
catch
{
_activePresentation = null;
}
finally
{
MessageFilter.Revoke();
}
}
}
return(_activePresentation);
}
public void ConvertToPDF(string originalFileName, string pdfFileName)
{
try
{
MessageFilter.Register();
if (_powerPointObject == null)
{
return;
}
Presentation presentationObject = _powerPointObject.Presentations.Open(originalFileName, MsoTriState.msoFalse, MsoTriState.msoFalse, MsoTriState.msoFalse);
presentationObject.SaveAs(pdfFileName, PpSaveAsFileType.ppSaveAsPDF, MsoTriState.msoCTrue);
presentationObject.Close();
Utilities.ReleaseComObject(presentationObject);
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public virtual bool Connect(bool forceNewObject = false)
{
try
{
MessageFilter.Register();
_powerPointObject = GetExistedPowerPoint();
if (forceNewObject && _powerPointObject == null)
{
_powerPointObject = CreateNewPowerPoint();
_isFirstLaunch = true;
}
_powerPointObject.DisplayAlerts = PpAlertLevel.ppAlertsNone;
}
catch
{
_powerPointObject = null;
}
finally
{
MessageFilter.Revoke();
}
return(_powerPointObject != null);
}
public SlideSettings GetActiveSlideSettings()
{
try
{
MessageFilter.Register();
var settings = new SlideSettings();
if (_powerPointObject?.ActivePresentation == null)
{
return(null);
}
settings.SlideSize.Width = Math.Round(Convert.ToDecimal(_powerPointObject.ActivePresentation.PageSetup.SlideWidth / 72), 3);
settings.SlideSize.Height = Math.Round(Convert.ToDecimal(_powerPointObject.ActivePresentation.PageSetup.SlideHeight / 72), 3);
return(settings);
}
catch
{
return(null);
}
finally
{
MessageFilter.Revoke();
}
}
public void AppendSlideMaster(string presentationTemplatePath, Presentation destinationPresentation = null)
{
try
{
var thread = new Thread(delegate()
{
MessageFilter.Register();
var presentation = _powerPointObject.Presentations.Open(presentationTemplatePath, WithWindow: MsoTriState.msoFalse);
AppendSlide(presentation, -1, destinationPresentation);
presentation.Close();
});
thread.Start();
while (thread.IsAlive)
{
System.Windows.Forms.Application.DoEvents();
}
}
catch { }
finally
{
MessageFilter.Revoke();
}
}
public void PrintPresentation(string presentationPath, int currentSlideIndex, Action <Action> printActionWrapper)
{
using (var dlg = new PrintDialog
{
AllowCurrentPage = true,
AllowPrintToFile = false,
AllowSelection = false,
AllowSomePages = true,
ShowNetwork = true,
UseEXDialog = true
})
{
if (dlg.ShowDialog() != DialogResult.OK)
{
return;
}
var fromPage = dlg.PrinterSettings.FromPage;
var toPage = 1;
var collate = dlg.PrinterSettings.Collate;
var copies = dlg.PrinterSettings.Copies;
var printRange = dlg.PrinterSettings.PrintRange;
var printerName = dlg.PrinterSettings.PrinterName;
printActionWrapper(() =>
{
try
{
MessageFilter.Register();
var presentation = PowerPointObject.Presentations.Open(presentationPath, WithWindow: MsoTriState.msoFalse);
switch (printRange)
{
case System.Drawing.Printing.PrintRange.AllPages:
fromPage = 1;
toPage = presentation.Slides.Count;
break;
case System.Drawing.Printing.PrintRange.CurrentPage:
fromPage = currentSlideIndex;
toPage = currentSlideIndex;
break;
case System.Drawing.Printing.PrintRange.SomePages:
if (fromPage < 1)
{
fromPage = 1;
}
toPage = currentSlideIndex;
if (toPage > presentation.Slides.Count)
{
toPage = presentation.Slides.Count;
}
break;
}
presentation.PrintOptions.PrintInBackground = MsoTriState.msoFalse;
presentation.PrintOptions.ActivePrinter = printerName;
presentation.PrintOptions.NumberOfCopies = copies;
presentation.PrintOut(
fromPage,
toPage,
String.Empty,
copies,
collate ? MsoTriState.msoTrue : MsoTriState.msoFalse);
presentation.Close();
Utilities.ReleaseComObject(presentationPath);
}
catch { }
finally
{
MessageFilter.Revoke();
}
});
}
}
public void AppendSlide(Presentation sourcePresentation,
int slideIndex,
Presentation destinationPresentation = null,
bool firstSlide = false,
int indexToPaste = 0)
{
MessageFilter.Register();
var tempPresentationPath = Path.GetTempFileName();
try
{
sourcePresentation.SaveAs(tempPresentationPath);
}
catch
{
tempPresentationPath = sourcePresentation.FullName;
}
if (destinationPresentation == null)
{
GetActivePresentation();
destinationPresentation = _activePresentation;
indexToPaste = GetActiveSlideIndex();
}
else if (!firstSlide)
{
indexToPaste = destinationPresentation.Slides.Count;
}
if (firstSlide)
{
indexToPaste = 0;
}
Slide addedSlide = null;
var slides = sourcePresentation.Slides;
for (var i = 1; i <= slides.Count; i++)
{
if ((i != slideIndex) && (slideIndex != -1))
{
continue;
}
var slide = slides[i];
var activeSlides = destinationPresentation.Slides;
activeSlides.InsertFromFile(tempPresentationPath, indexToPaste, i, i);
indexToPaste++;
addedSlide = activeSlides[indexToPaste];
var design = GetDesignFromSlide(slide, destinationPresentation);
if (design != null)
{
addedSlide.Design = design;
}
else
{
var slideDesign = sourcePresentation.SlideMaster.Design;
addedSlide.Design = slideDesign;
Utilities.ReleaseComObject(slideDesign);
}
var colorScheme = slide.ColorScheme;
addedSlide.ColorScheme = colorScheme;
Utilities.ReleaseComObject(colorScheme);
Utilities.ReleaseComObject(design);
Utilities.ReleaseComObject(slide);
Utilities.ReleaseComObject(activeSlides);
}
if (addedSlide != null)
{
addedSlide.Select();
}
Utilities.ReleaseComObject(addedSlide);
Utilities.ReleaseComObject(slides);
MessageFilter.Revoke();
try
{
File.Delete(tempPresentationPath);
}
catch { }
}
