public static void GeneratePreview(string extension, Stream docStream, IPreviewGenerationContext context)
{
IPreviewImageGenerator provider;
if (!Providers.TryGetValue(extension.ToLowerInvariant(), out provider))
throw new ApplicationException(SR.F(SR.UnknownProvider_1, extension));
provider.GeneratePreview(docStream, context);
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
docStream.Seek(0, SeekOrigin.Begin);
var document = Image.Load(docStream);
if (context.StartIndex == 0)
{
context.SetPageCount(1);
}
using (var imgStream = new MemoryStream())
{
var options = new PngOptions();
document.Save(imgStream, options);
try
{
context.SavePreviewAndThumbnail(imgStream, 1);
}
catch (Exception ex)
{
if (Tools.IsTerminatorError(ex as WebException))
{
context.LogWarning(1, SR.Exceptions.NotFound);
return;
}
// the preview generator tool will handle the error
throw;
}
}
}
/// <summary>
/// Logs exceptions thrown during iterating through document pages. It also
/// saves an empty image in place of the one that failed.
/// </summary>
/// <returns>True if the process should be terminated.</returns>
public static bool HandlePageError(Exception ex, int page, IPreviewGenerationContext context, bool logEvent)
{
if (ContentNotFound(ex as WebException))
{
context.LogWarning(page, SR.Exceptions.NotFound + ex);
return(true);
}
if (IsTerminatorError(ex as WebException))
{
// We log this because this may be a network problem that
// prevents us from accessing the portal.
context.LogWarning(page, SerializeException(ex));
return(true);
}
// We must not log an error here, because that would set the status of
// the whole document to 'Error', and we would loose all previously
// generated pages and the page count information.
// We write only the first warning message instead to avoid overloading the event log.
if (logEvent)
{
context.LogWarning(page, SerializeException(ex));
}
// Substitute the wrong image with an empty one. This will prevent the
// viewer plugin from registering preview tasks for missing images over and
// over again.
context.SaveEmptyPreview(page);
return(false);
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
docStream.Seek(0, SeekOrigin.Begin);
var document = Image.Load(docStream);
if (context.StartIndex == 0)
{
await context.SetPageCountAsync(1, cancellationToken).ConfigureAwait(false);
}
using (var imgStream = new MemoryStream())
{
var options = new PngOptions();
document.Save(imgStream, options);
try
{
await context.SavePreviewAndThumbnailAsync(imgStream, 1, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
if (Tools.IsTerminatorError(ex as WebException))
{
context.LogWarning(1, SR.Exceptions.NotFound);
return;
}
// the preview generator tool will handle the error
throw;
}
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
var document = new Document(docStream);
var pc = document.PageCount;
// save the document only if this is the first round
if (context.StartIndex == 0 || pc < 1)
{
await context.SetPageCountAsync(pc, cancellationToken).ConfigureAwait(false);
}
if (pc <= 0)
{
return;
}
var loggedPageError = false;
context.SetIndexes(pc, out var firstIndex, out var lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
using (var imgStream = new MemoryStream())
{
var options = new ImageSaveOptions(SaveFormat.Png)
{
PageIndex = i,
Resolution = context.PreviewResolution
};
document.Save(imgStream, options);
if (imgStream.Length == 0)
{
continue;
}
await context.SavePreviewAndThumbnailAsync(imgStream, i + 1, cancellationToken)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (await Tools.HandlePageErrorAsync(ex, i + 1, context, !loggedPageError,
cancellationToken).ConfigureAwait(false))
{
return;
}
loggedPageError = true;
}
}
}
public static Task GeneratePreviewAsync(string extension, Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
if (!Providers.TryGetValue(extension.ToLowerInvariant(), out var provider))
{
throw new ApplicationException(SR.F(SR.UnknownProvider_1, extension));
}
return(provider.GeneratePreviewAsync(docStream, context, cancellationToken));
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var document = new Aspose.Words.Document(docStream);
var pc = document.PageCount;
// save the document only if this is the first round
if (context.StartIndex == 0 || pc < 1)
{
context.SetPageCount(pc);
}
if (pc <= 0)
{
return;
}
int firstIndex;
int lastIndex;
var loggedPageError = false;
context.SetIndexes(pc, out firstIndex, out lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
try
{
using (var imgStream = new MemoryStream())
{
var options = new Aspose.Words.Saving.ImageSaveOptions(Aspose.Words.SaveFormat.Png)
{
PageIndex = i,
Resolution = context.PreviewResolution
};
document.Save(imgStream, options);
if (imgStream.Length == 0)
{
continue;
}
context.SavePreviewAndThumbnail(imgStream, i + 1);
}
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, i + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var email = MailMessage.Load(docStream);
using (var emailStream = new MemoryStream())
{
email.Save(emailStream, SaveOptions.DefaultMhtml);
emailStream.Position = 0;
new WordPreviewImageGenerator().GeneratePreview(emailStream, context);
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
var email = MailMessage.Load(docStream);
using (var emailStream = new MemoryStream())
{
email.Save(emailStream, SaveOptions.DefaultMhtml);
emailStream.Position = 0;
await new WordPreviewImageGenerator().GeneratePreviewAsync(emailStream, context,
cancellationToken).ConfigureAwait(false);
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
docStream.Seek(0, SeekOrigin.Begin);
var pres = new Presentation(docStream);
if (context.StartIndex == 0)
{
await context.SetPageCountAsync(pres.Slides.Count, cancellationToken).ConfigureAwait(false);
}
var loggedPageError = false;
context.SetIndexes(pres.Slides.Count, out var firstIndex, out var lastIndex);
// calculate size based on the original aspect ratio and the expected image size.
var sizeF = pres.SlideSize.Size;
var ratio = Math.Min((float)Common.PREVIEW_WIDTH / sizeF.Width,
(float)Common.PREVIEW_HEIGHT / sizeF.Height);
var size = new Size((int)Math.Round(sizeF.Width * ratio),
(int)Math.Round(sizeF.Height * ratio));
for (var i = firstIndex; i <= lastIndex; i++)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
var slide = pres.Slides[i];
// generate image
using (var image = slide.GetThumbnail(size))
{
await context.SaveImageAsync(image, i + 1, cancellationToken).ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (await Tools.HandlePageErrorAsync(ex, i + 1, context, !loggedPageError,
cancellationToken).ConfigureAwait(false))
{
return;
}
loggedPageError = true;
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var document = new Project(docStream);
// This is the simplest way to create a reasonably readable
// preview from a project file: convert it to a PDF first.
using (var pdfStream = new MemoryStream())
{
// save project file in memory as a pdf document
document.Save(pdfStream, SaveFileFormat.PDF);
// generate previews from the pdf document
new PdfPreviewImageGenerator().GeneratePreview(pdfStream, context);
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var document = new Diagram(docStream);
if (context.StartIndex == 0)
{
context.SetPageCount(document.Pages.Count);
}
int firstIndex;
int lastIndex;
var loggedPageError = false;
context.SetIndexes(document.Pages.Count, out firstIndex, out lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
try
{
using (var imgStream = new MemoryStream())
{
var options = new ImageSaveOptions(SaveFileFormat.PNG)
{
PageIndex = i,
Resolution = context.PreviewResolution
};
document.Save(imgStream, options);
if (imgStream.Length == 0)
{
continue;
}
context.SavePreviewAndThumbnail(imgStream, i + 1);
}
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, i + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
docStream.Seek(0, SeekOrigin.Begin);
var pres = new Presentation(docStream);
if (context.StartIndex == 0)
{
context.SetPageCount(pres.Slides.Count);
}
int firstIndex;
int lastIndex;
var loggedPageError = false;
context.SetIndexes(pres.Slides.Count, out firstIndex, out lastIndex);
// calculate size based on the original aspect ratio and the expected image size.
var sizeF = pres.SlideSize.Size;
var ratio = Math.Min((float)Common.PREVIEW_WIDTH / sizeF.Width,
(float)Common.PREVIEW_HEIGHT / sizeF.Height);
var size = new Size((int)Math.Round(sizeF.Width * ratio),
(int)Math.Round(sizeF.Height * ratio));
for (var i = firstIndex; i <= lastIndex; i++)
{
try
{
var slide = pres.Slides[i];
// generate image
using (var image = slide.GetThumbnail(size))
{
context.SaveImage(image, i + 1);
}
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, i + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
}
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
var document = new Document(docStream);
if (context.StartIndex == 0)
{
await context.SetPageCountAsync(document.Pages.Count, cancellationToken).ConfigureAwait(false);
}
var loggedPageError = false;
context.SetIndexes(document.Pages.Count, out var firstIndex, out var lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
cancellationToken.ThrowIfCancellationRequested();
using (var imgStream = new MemoryStream())
{
try
{
var pngDevice = new PngDevice(new Resolution(context.PreviewResolution, context.PreviewResolution));
pngDevice.Process(document.Pages[i + 1], imgStream);
if (imgStream.Length == 0)
{
continue;
}
await context.SavePreviewAndThumbnailAsync(imgStream, i + 1, cancellationToken)
.ConfigureAwait(false);
}
catch (Exception ex)
{
if (await Tools.HandlePageErrorAsync(ex, i + 1, context, !loggedPageError,
cancellationToken).ConfigureAwait(false))
{
return;
}
loggedPageError = true;
}
}
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
docStream.Seek(0, SeekOrigin.Begin);
var document = (TiffImage)Image.Load(docStream);
if (context.StartIndex == 0)
{
await context.SetPageCountAsync(document.Frames.Length, cancellationToken).ConfigureAwait(false);
}
var loggedPageError = false;
context.SetIndexes(document.Frames.Length, out var firstIndex, out var lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
document.ActiveFrame = document.Frames[i];
using (var imgStream = new MemoryStream())
{
var options = new PngOptions();
document.Save(imgStream, options);
await context.SavePreviewAndThumbnailAsync(imgStream, i + 1, cancellationToken)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (await Tools.HandlePageErrorAsync(ex, i + 1, context, !loggedPageError,
cancellationToken).ConfigureAwait(false))
{
return;
}
loggedPageError = true;
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var document = new Document(docStream);
if (context.StartIndex == 0)
{
context.SetPageCount(document.Pages.Count);
}
int firstIndex;
int lastIndex;
var loggedPageError = false;
context.SetIndexes(document.Pages.Count, out firstIndex, out lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
using (var imgStream = new MemoryStream())
{
try
{
var pngDevice = new PngDevice(new Resolution(context.PreviewResolution, context.PreviewResolution));
pngDevice.Process(document.Pages[i + 1], imgStream);
if (imgStream.Length == 0)
{
continue;
}
context.SavePreviewAndThumbnail(imgStream, i + 1);
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, i + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
}
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
docStream.Seek(0, SeekOrigin.Begin);
var document = (TiffImage)Image.Load(docStream);
if (context.StartIndex == 0)
{
context.SetPageCount(document.Frames.Length);
}
int firstIndex;
int lastIndex;
var loggedPageError = false;
context.SetIndexes(document.Frames.Length, out firstIndex, out lastIndex);
for (var i = firstIndex; i <= lastIndex; i++)
{
try
{
document.ActiveFrame = document.Frames[i];
using (var imgStream = new MemoryStream())
{
var options = new PngOptions();
document.Save(imgStream, options);
context.SavePreviewAndThumbnail(imgStream, i + 1);
}
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, i + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
}
}
}
public override void GeneratePreview(Stream docStream, IPreviewGenerationContext context)
{
var document = new Workbook(docStream);
var printOptions = new ImageOrPrintOptions
{
ImageFormat = Common.PREVIEWIMAGEFORMAT,
OnePagePerSheet = false,
HorizontalResolution = context.PreviewResolution,
VerticalResolution = context.PreviewResolution
};
// every worksheet may contain multiple pages (as set by Excel
// automatically, or by the user using the print layout)
var estimatedPageCount = document.Worksheets.Select(w => new SheetRender(w, printOptions).PageCount).Sum();
if (context.StartIndex == 0)
{
context.SetPageCount(estimatedPageCount);
}
int firstIndex;
int lastIndex;
context.SetIndexes(estimatedPageCount, out firstIndex, out lastIndex);
var workbookPageIndex = 0;
var worksheetIndex = 0;
var loggedPageError = false;
// iterate through worksheets
while (worksheetIndex < document.Worksheets.Count)
{
try
{
var worksheet = document.Worksheets[worksheetIndex];
var sheetRender = new SheetRender(worksheet, printOptions);
// if we need to start preview generation on a subsequent worksheet, skip the previous ones
if (workbookPageIndex + sheetRender.PageCount < context.StartIndex)
{
workbookPageIndex += sheetRender.PageCount;
worksheetIndex++;
continue;
}
// iterate through pages inside a worksheet
for (var worksheetPageIndex = 0; worksheetPageIndex < sheetRender.PageCount; worksheetPageIndex++)
{
// if the desired page interval contains this page, generate the image
if (workbookPageIndex >= firstIndex && workbookPageIndex <= lastIndex)
{
using (var imgStream = new MemoryStream())
{
sheetRender.ToImage(worksheetPageIndex, imgStream);
// handle empty sheets
if (imgStream.Length == 0)
{
context.SaveEmptyPreview(workbookPageIndex + 1);
}
else
{
context.SavePreviewAndThumbnail(imgStream, workbookPageIndex + 1);
}
}
}
workbookPageIndex++;
}
}
catch (Exception ex)
{
if (Tools.HandlePageError(ex, workbookPageIndex + 1, context, !loggedPageError))
{
return;
}
loggedPageError = true;
workbookPageIndex++;
}
worksheetIndex++;
}
// set the real count if some of the sheets turned out to be empty
if (workbookPageIndex < estimatedPageCount)
{
context.SetPageCount(workbookPageIndex);
}
}
public override async Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
var document = new Workbook(docStream);
var printOptions = new ImageOrPrintOptions
{
ImageType = GetImageType(),
OnePagePerSheet = false,
HorizontalResolution = context.PreviewResolution,
VerticalResolution = context.PreviewResolution
};
// every worksheet may contain multiple pages (as set by Excel
// automatically, or by the user using the print layout)
var estimatedPageCount = document.Worksheets.Select(w => new SheetRender(w, printOptions).PageCount).Sum();
if (context.StartIndex == 0)
{
await context.SetPageCountAsync(estimatedPageCount, cancellationToken).ConfigureAwait(false);
}
context.SetIndexes(estimatedPageCount, out var firstIndex, out var lastIndex);
var workbookPageIndex = 0;
var worksheetIndex = 0;
var loggedPageError = false;
// iterate through worksheets
while (worksheetIndex < document.Worksheets.Count)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
var worksheet = document.Worksheets[worksheetIndex];
var sheetRender = new SheetRender(worksheet, printOptions);
// if we need to start preview generation on a subsequent worksheet, skip the previous ones
if (workbookPageIndex + sheetRender.PageCount < context.StartIndex)
{
workbookPageIndex += sheetRender.PageCount;
worksheetIndex++;
continue;
}
// iterate through pages inside a worksheet
for (var worksheetPageIndex = 0; worksheetPageIndex < sheetRender.PageCount; worksheetPageIndex++)
{
// if the desired page interval contains this page, generate the image
if (workbookPageIndex >= firstIndex && workbookPageIndex <= lastIndex)
{
using (var imgStream = new MemoryStream())
{
sheetRender.ToImage(worksheetPageIndex, imgStream);
// handle empty sheets
if (imgStream.Length == 0)
{
await context.SaveEmptyPreviewAsync(workbookPageIndex + 1, cancellationToken)
.ConfigureAwait(false);
}
else
{
await context.SavePreviewAndThumbnailAsync(imgStream, workbookPageIndex + 1,
cancellationToken).ConfigureAwait(false);
}
}
}
workbookPageIndex++;
}
}
catch (Exception ex)
{
if (await Tools.HandlePageErrorAsync(ex, workbookPageIndex + 1, context, !loggedPageError,
cancellationToken).ConfigureAwait(false))
{
return;
}
loggedPageError = true;
workbookPageIndex++;
}
worksheetIndex++;
}
// set the real count if some of the sheets turned out to be empty
if (workbookPageIndex < estimatedPageCount)
{
await context.SetPageCountAsync(workbookPageIndex, cancellationToken).ConfigureAwait(false);
}
}
public abstract void GeneratePreview(Stream docStream, IPreviewGenerationContext context);
public override async System.Threading.Tasks.Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken)
{
var document = new Project(docStream);
// This is the simplest way to create a reasonably readable
// preview from a project file: convert it to a PDF first.
using (var pdfStream = new MemoryStream())
{
// save project file in memory as a pdf document
document.Save(pdfStream, SaveFileFormat.PDF);
// generate previews from the pdf document
await new PdfPreviewImageGenerator().GeneratePreviewAsync(pdfStream, context, cancellationToken)
.ConfigureAwait(false);
}
}
public abstract Task GeneratePreviewAsync(Stream docStream, IPreviewGenerationContext context,
CancellationToken cancellationToken);
