Table of Contents

Custom previewing (C++)

Note

This demo is available in your FlexCel installation at <FlexCel Install Folder>\Demo\Cpp\Modules\25.Printing and Exporting\20.CustomPreview and also at https:​//​github.​com/​tmssoftware/​TMS-​FlexCel.​VCL-​demos/​tree/​master/​Cpp/​Modules/​25.​Printing and Exporting/​20.​Custom​Preview

Overview

FlexCel comes with a full featured viewer that you can use to display a preview of Excel files in your application, and without having any printer installed.

Concepts

  • How to create a preview form that you can embed inside your application, including thumbnails, navigation, etc.

  • How to Export to PDF from a thread, allowing the user to cancel it.

Files

CustomPreview.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <tchar.h>
//---------------------------------------------------------------------------

USEFORM("UCustomPreview.cpp", FCustomPreview);
USEFORM("UPasswordDialog.cpp", PasswordDialog);
//---------------------------------------------------------------------------
int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
	try
	{
		Application->Initialize();
		Application->MainFormOnTaskBar = true;
		Application->CreateForm(__classid(TFCustomPreview), &FCustomPreview);
		Application->Run();
	}
	catch (Exception &exception)
	{
		Application->ShowException(&exception);
	}
	catch (...)
	{
		try
		{
			throw Exception("");
		}
		catch (Exception &exception)
		{
			Application->ShowException(&exception);
		}
	}
	return 0;
}
//---------------------------------------------------------------------------

UCustomPreview.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "UCustomPreview.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TFCustomPreview *FCustomPreview;
//---------------------------------------------------------------------------
__fastcall TFCustomPreview::TFCustomPreview(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::FormCreate(TObject *Sender)
{
  Xls = new TXlsFile(1, false);
  Xls->Protection->OnPassword = GetPassword;
  ImgExport = new TFlexCelImgExport(Xls, false);
  ImgExport->AllVisibleSheets = false;
  MainPreview->Document = ImgExport;
  Thumbs->Document = ImgExport;
  RegisterForHDPI(this, DPIChanged);
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::FormDestroy(TObject *Sender)
{
  PrintingThread->Free();
  PdfThread->Free();
  ImgExport->Free();
  Xls->Free(); //after freeing the threads, so we don't free the xls object while they are working.
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::ActionCloseExecute(TObject *Sender)
{
  Close();
}
//---------------------------------------------------------------------------

#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older, this should be "TOnPasswordEventArgs * const e".
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
void __fastcall TFCustomPreview::GetPassword(const TOnPasswordEventArgs* e)
{
  TPasswordDialog* Pwd = new TPasswordDialog(NULL);
  try
  {
	Pwd->SetFileName(OpenDialog->FileName);
	if (Pwd->ShowModal() != mrOk) return;

	//We need this cast because the delphi object is a constant pointer, not a pointer to a constant.
	const_cast<TOnPasswordEventArgs*>(e)->Password = Pwd->Password();
  }
  __finally
  {
	Pwd->Free();
  }
}
#else
//XE3 has fixed the bug, now we need to define the event correctly
void __fastcall TFCustomPreview::GetPassword(TOnPasswordEventArgs* const e)
{
  TPasswordDialog* Pwd = new TPasswordDialog(NULL);
  try
  {
	Pwd->SetFileName(OpenDialog->FileName);
	if (Pwd->ShowModal() != mrOk) return;

	e->Password = Pwd->Password();
  }
  __finally
  {
	Pwd->Free();
  }
}
#endif


void __fastcall TFCustomPreview::ActionOpenExecute(TObject *Sender)
{
  if (!(OpenDialog->Execute())) return;
  LoadFile(OpenDialog->FileName);
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::LoadFile(String FileName)
{
  PanelPdfOk->Visible = false;
  PanelPdfError->Visible = false;
  PanelPdf->Visible = false;
  PanelPrintingOk->Visible = false;
  PanelPrintingError->Visible = false;
  PanelPrinting->Visible = false;


  OpenDialog->FileName = FileName;
  lbSheets->Items->Clear();

  try
  {
	Xls->Open(FileName);
  }
  catch (Exception* ex)
  {
	EnableCommonActions(false);
	ActionPrint->Enabled = false;
	ActionPdf->Enabled = false;
	ActionZoom->Enabled = false;
	ActionAutofit->Enabled = false;
	ActionOpen->Enabled = true;
	PanelSelectPage->Visible = false;
	Xls->NewFile(1, TExcelFileFormat::v2019);
	Caption = "Custom Preview";
	ShowMessage("Error opening file: " + ex->Message);
	MainPreview->InvalidatePreview();
	return;
  }

  for (int i = 1; i <= Xls->SheetCount; i++)
  {
	lbSheets->Items->Add(Xls->GetSheetName(i));
  }
  lbSheets->ItemIndex = Xls->ActiveSheet - 1;

  EnableCommonActions(true);
  ActionPrint->Enabled = true;
  ActionPdf->Enabled = true;
  ActionZoom->Enabled = true;
  ActionAutofit->Enabled = true;
  Caption = "Custom Preview: " + OpenDialog->FileName;
  PanelSelectPage->Visible = true;
  ToolBarAutofit->Left = PanelSelectPage->Left + 10; //Make the panel appear to the left of the toolbar.
  MainPreview->InvalidatePreview();
}


void __fastcall TFCustomPreview::cbAllSheetsClick(TObject *Sender)
{
  PanelSheets->Visible = !cbAllSheets->Checked;
  ImgExport->AllVisibleSheets = cbAllSheets->Checked;
  MainPreview->InvalidatePreview();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::lbSheetsClick(TObject *Sender)
{
  if (lbSheets->Items->Count > Xls->SheetCount) return;
  Xls->ActiveSheet = lbSheets->ItemIndex + 1;
  MainPreview->InvalidatePreview();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::EnableCommonActions(bool Enable)
{
  if (Enable) DisabledCount--; else DisabledCount++;
  if (DisabledCount < 0) DisabledCount = 0;
  if (Enable && DisabledCount > 0) return; //we would be both printing and exporting to pdf, if one finishes, the buttons shouldn't be enabled util the other finishes too.


  ActionOpen->Enabled = Enable;
  ActionGridLines->Enabled = Enable;
  ActionHeadings->Enabled = Enable;
  ActionRecalc->Enabled = Enable;
}

void __fastcall TFCustomPreview::PdfProgressFeedback(int Progress, String Msg)
{
  PdfProgressBar->Position = Progress;
  lblPdfPage->Caption = Msg;
}

void __fastcall TFCustomPreview::PdfFinalFeedback(bool Ok, String Msg)
{
  PanelPdf->Visible = false;
  if (!Ok)
  {
	PanelPdfError->Visible = true;
	lblPdfError->Caption = "Error exporting to PDF: " + Msg;
  }
  else
  {
	PanelPdfOk->Visible = true;
  }

  EnableCommonActions(true);
  ActionPdf->Enabled = true;
}

void __fastcall TFCustomPreview::ActionPdfExecute(TObject *Sender)
{
  if (!(PdfSaveDialog->Execute())) return;

  PdfProgressBar->Position = 0;
  lblPdfPage->Caption = "Initializing";
  EnableCommonActions(false);
  ActionPdf->Enabled = false;
  btnPdfCancel->Enabled = true;
  btnPdfCancel->Caption = "Cancel";

  PanelPdfOk->Visible = false;
  PanelPdfError->Visible = false;
  PanelPdf->Visible = true;

  PdfThread->Free();

  PdfThread = new TPdfThread(
	Xls,
	PdfProgressFeedback,
	PdfFinalFeedback,
	PdfSaveDialog->FileName,
	cbAllSheets->Checked);

  PdfThread->Start();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::PrintProgressFeedback(int Progress, String Msg)
{
  PrintProgressBar->Position = Progress;
  lblPrintPage->Caption = Msg;
}

void __fastcall TFCustomPreview::PrintFinalFeedback(bool Ok, String Msg)
{
  PanelPrinting->Visible = false;
  if (!Ok)
  {
	PanelPrintingError->Visible = true;
	lblPrintingError->Caption = "Error printing: " + Msg;
  }
  else
  {
	PanelPrintingOk->Visible = true;
  }

  EnableCommonActions(true);
  ActionPrint->Enabled = true;
}

void __fastcall TFCustomPreview::ActionPrintExecute(TObject *Sender)
{
  if (!(PrintDialog->Execute())) return;

  PrintProgressBar->Position = 0;
  lblPrintPage->Caption = "Initializing";
  EnableCommonActions(false);
  ActionPrint->Enabled = false;

  btnPrintCancel->Enabled = true;
  btnPrintCancel->Caption = "Cancel";

  PanelPrintingOk->Visible = false;
  PanelPrintingError->Visible = false;
  PanelPrinting->Visible = true;

  PrintingThread->Free();
  PrintingThread = new TPrintingThread(
	Xls,
	&PrintProgressFeedback,
	&PrintFinalFeedback,
	"",
	cbAllSheets->Checked);

  PrintingThread->Start();

}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnOpenGeneratedFileClick(TObject *Sender)
{
  ShellExecute(0, L"open", PdfSaveDialog->FileName.c_str(), L"", L"", SW_SHOWNORMAL);
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPdfCancelClick(TObject *Sender)
{
  if (PdfThread == NULL) //it shouldn't really happen
  {
	PanelPdf->Visible = false;
	return;
  }
  btnPdfCancel->Enabled = false;
  btnPdfCancel->Caption = "Canceling...";
  PdfThread->Terminate(); //FlexCel will check that we set terminated, and exit as fast as it can.
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPrintCancelClick(TObject *Sender)
{
  if (PrintingThread == NULL) //it shouldn't really happen
  {
	PanelPrinting->Visible = false;
	return;
  }
  btnPrintCancel->Enabled = false;
  btnPrintCancel->Caption = "Canceling...";
  PrintingThread->Terminate(); //FlexCel will check that we set terminated, and exit as fast as it can.
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPdfErrorCloseClick(TObject *Sender)
{
  PanelPdfError->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPrintingErrorCloseClick(TObject *Sender)
{
  PanelPrintingError->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPrintOkCloseClick(TObject *Sender)
{
  PanelPrintingOk->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btnPdfOkCloseClick(TObject *Sender)
{
  PanelPdfOk->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::UpdatePages()
{
  edPage->Text = IntToStr(MainPreview->StartPage);
  lblTotalPages->Caption = "of " + IntToStr(MainPreview->TotalPages);
}

void __fastcall TFCustomPreview::ChangePages()
{
  int pn;
  if (TryStrToInt(Trim(edPage->Text), pn)) MainPreview->StartPage = pn;
}

void __fastcall TFCustomPreview::DPIChanged()
{
  MainPreview->InvalidatePreview();
}

void __fastcall TFCustomPreview::MainPreviewStartPageChanged(TObject *Sender)
{
  UpdatePages();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::edPageExit(TObject *Sender)
{
  ChangePages();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::edPageKeyPress(TObject *Sender, System::WideChar &Key)

{
  if (Key == (char)13)
  {
	ChangePages();
	Key = (char)0;
  }
  else if (Key == (char)27)
  {
	UpdatePages();
	Key = (char)0;
  }
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::UpdateZoom()
{
  ActionZoom->Caption = IntToStr((int)(MainPreview->Zoom * 100)) + "%";
  if (MainPreview->AutofitPreview == TAutofitPreview::None) UpdateAutofitText();
  ChangingZoom = true;
  __try
  {
	TrackBarZoom->Position = (int)(MainPreview->Zoom * 100);
  }
  __finally
  {
	ChangingZoom = false;
  }
}
void __fastcall TFCustomPreview::MainPreviewZoomChanged(TObject *Sender)
{
   UpdateZoom();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::ActionZoomExecute(TObject *Sender)
{
  System::Types::TPoint p;
  p.X = ToolButtonZoom->Left;
  p.Y = ToolButtonZoom->Top + ToolButtonZoom->Height;
  p = ToolButtonZoom->ClientToParent(p, FCustomPreview);

  PanelZoom->Left = p.X;
  PanelZoom->Top = p.Y;
  PanelZoom->Visible = true;
  ActiveControl = TrackBarZoom;

}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btn25Click(TObject *Sender)
{
  MainPreview->Zoom = 0.25;
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btn50Click(TObject *Sender)
{
  MainPreview->Zoom = 0.50;
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btn75Click(TObject *Sender)
{
  MainPreview->Zoom = 0.75;
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btn100Click(TObject *Sender)
{
  MainPreview->Zoom = 1;
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::btn150Click(TObject *Sender)
{
  MainPreview->Zoom = 1.5;
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::TrackBarZoomChange(TObject *Sender)
{
  if (ChangingZoom) return; //avoid recursive calls.
  MainPreview->Zoom = TrackBarZoom->Position / 100.0;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::TrackBarZoomEnter(TObject *Sender)
{
  PanelZoom->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::PanelZoomExit(TObject *Sender)
{
  PanelZoom->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::UpdateAutofitText()
{
  switch (MainPreview->AutofitPreview)
  {
	case TAutofitPreview::None: ActionAutofit->Caption = "No Autofit"; break;
	case TAutofitPreview::Width: ActionAutofit->Caption = "Fit to Width"; break;
	case TAutofitPreview::Height: ActionAutofit->Caption = "Fit to Height"; break;
	case TAutofitPreview::Full: ActionAutofit->Caption = "Fit to Page"; break;
  }
}


void __fastcall TFCustomPreview::ActionAutofitExecute(TObject *Sender)
{
  if (!(dynamic_cast<TControl* >(Sender))) return;

  System::Types::TPoint PopPoint;
  PopPoint.X = ((TControl*)Sender)->Left;
  PopPoint.Y = ((TControl*)Sender)->Top + ((TControl*)Sender)->Height;
  PopPoint = ClientToScreen(PopPoint);
  AutofitMenu->Popup(PopPoint.X, PopPoint.Y);

}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::NoAutofit1Click(TObject *Sender)
{
  MainPreview->AutofitPreview = TAutofitPreview::None;
  UpdateAutofitText();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::FittoWidth1Click(TObject *Sender)
{
  MainPreview->AutofitPreview = TAutofitPreview::Width;
  UpdateAutofitText();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::FittoHeight1Click(TObject *Sender)
{
  MainPreview->AutofitPreview = TAutofitPreview::Height;
  UpdateAutofitText();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::FittoPage1Click(TObject *Sender)
{
  MainPreview->AutofitPreview = TAutofitPreview::Full;
  UpdateAutofitText();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::ActionRecalcExecute(TObject *Sender)
{
  Xls->Recalc();
  MainPreview->InvalidatePreview();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::ActionGridLinesExecute(TObject *Sender)
{
  if (cbAllSheets->Checked)
  {
	int SaveActiveSheet = Xls->ActiveSheet;
	for (int i = 1; i <= Xls->SheetCount; i++)
	{
	  Xls->ActiveSheet = i;
	  Xls->PrintGridLines = ActionGridLines->Checked;
	}
	Xls->ActiveSheet = SaveActiveSheet;
  }
  else
  {
	Xls->PrintGridLines = ActionGridLines->Checked;
  }
  MainPreview->InvalidatePreview();
}
//---------------------------------------------------------------------------

void __fastcall TFCustomPreview::ActionHeadingsExecute(TObject *Sender)
{
  if (cbAllSheets->Checked)
  {
	int SaveActiveSheet = Xls->ActiveSheet;
	for (int i = 1; i <= Xls->SheetCount; i++)
	{
	  Xls->ActiveSheet = i;
	  Xls->PrintHeadings = ActionHeadings->Checked;
	}
	Xls->ActiveSheet = SaveActiveSheet;
  }
  else
  {
	Xls->PrintHeadings = ActionHeadings->Checked;
  }
  MainPreview->InvalidatePreview();
}
//---------------------------------------------------------------------------

UPasswordDialog.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "UPasswordDialog.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

//---------------------------------------------------------------------------
__fastcall TPasswordDialog::TPasswordDialog(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

String __fastcall TPasswordDialog::Password()
{
   return edPassword->Text;
}

void __fastcall TPasswordDialog::SetFileName(const String FileName)
{
  lblFileName->Caption = ExtractFileName(FileName);
}

UPdfExporting.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "UPdfExporting.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

__fastcall TPdfThread::TPdfThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets)
	  : TProgressThread(aXls, aProgressFeedback, aFinalFeedback, aFileName, aAllSheets)
{
}


void __fastcall TPdfThread::Execute()
{
  TFlexCelPdfExport* pdf = new TFlexCelPdfExport(Xls, true);
  try
  {
	pdf->AfterGeneratePage = ShowProgress;

	if (AllSheets)
	{
	  TFileStream* fs = new TFileStream(FileName, fmCreate);
	  try
	  {
		pdf->BeginExport(fs);
		pdf->PageLayout = TPageLayout::Outlines;
		pdf->ExportAllVisibleSheets(false, TPath::GetFileNameWithoutExtension(FileName));
		pdf->EndExport();
	  }
	  __finally
	  {
		fs->Free();
	  }
	}
	else
	{
	  pdf->Export(FileName);
	}
  }
  __finally
  {
	pdf->Free();
  }
}

#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
void __fastcall TPdfThread::ShowProgress(const TObject* sender, const TPageEventArgs* e)
#else
void __fastcall TPdfThread::ShowProgress(TObject* const sender, TPageEventArgs* const e)
#endif
{
  TFlexCelPdfExportProgress* Prog = ((TFlexCelPdfExport*)sender)->Progress;
  int Percent;
  if (Prog->TotalPage == 0) Percent = 100; else Percent = (int)(Prog->Page * 100.0 / Prog->TotalPage);

  ProgressFeedback_percent = Percent;
  ProgressFeedback_msg = String(L"Page ") + IntToStr(Prog->Page) + L" of " + IntToStr(Prog->TotalPage);
  Synchronize(&DoProgressFeedback);

}

UPrinting.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "UPrinting.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

__fastcall TPrintingThread::TPrintingThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets)
	  : TProgressThread(aXls, aProgressFeedback, aFinalFeedback, aFileName, aAllSheets)
{
}


void __fastcall TPrintingThread::Execute()
{
  TFlexCelPrintDocument* doc = new TFlexCelPrintDocument(Xls);
  try
  {
	doc->AfterGeneratePage = ShowProgress;

	if (AllSheets)
	{
		doc->BeginPrint();
		try
		{
		  doc->PrintAllVisibleSheets(false);
		}
		__finally
		{
		  doc->EndPrint();
		}
	}
	else
	{
	  doc->Print();
	}
  }
  __finally
  {
	doc->Free();
  }
}

#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
void __fastcall TPrintingThread::ShowProgress(const TObject* sender, const TPrintPageEventArgs* e)
#else
void __fastcall TPrintingThread::ShowProgress(TObject* const sender, TPrintPageEventArgs* const e)
#endif
{
  TFlexCelPrintingProgress* Prog = ((TFlexCelPrintDocument*)sender)->Progress;
  int Percent;
  if (Prog->TotalPage == 0) Percent = 100; else Percent = (int)(Prog->Page * 100.0 / Prog->TotalPage);

  ProgressFeedback_percent = Percent;
  ProgressFeedback_msg = String(L"Page ") + IntToStr(Prog->Page) + L" of " + IntToStr(Prog->TotalPage);
  Synchronize(&DoProgressFeedback);
}

UProgressThread.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "UProgressThread.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

__fastcall TProgressThread::TProgressThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets): TThread(true)
{
  FreeOnTerminate = false;
  Canceled = false;
  Xls = aXls;
  ProgressFeedback = aProgressFeedback;
  FinalFeedback = aFinalFeedback;
  FileName = aFileName;
  AllSheets = aAllSheets;

}

void __fastcall TProgressThread::TerminatedSet()
{
  TThread::TerminatedSet();
  Canceled = true;
}
//---------------------------------------------------------------------------

void __fastcall TProgressThread::DoTerminate()
{
  TThread::DoTerminate();
  FinalFeedback_msg = "";
  FinalFeedback_ok = !Canceled;
  if (FatalException != NULL)
  {
	FinalFeedback_ok = false;
	if (dynamic_cast<Exception*>(FatalException))
	{
	  FinalFeedback_msg = ((Exception*)FatalException)->Message;
	}
	else FinalFeedback_msg = "Unexpected error: " + FatalException->ClassName();
  }

  if (Canceled) FinalFeedback_msg = "Operation canceled by the user.";


  //DoTerminate runs in the thread context, not the main thread context as OnTerminate.
  Synchronize(&DoFinalFeedback);

}
//---------------------------------------------------------------------------

void __fastcall TProgressThread::DoFinalFeedback()
{
	FinalFeedback(FinalFeedback_ok, FinalFeedback_msg);
}

void __fastcall TProgressThread::DoProgressFeedback()
{
	ProgressFeedback(ProgressFeedback_percent, ProgressFeedback_msg);
}

UCustomPreview.h

//---------------------------------------------------------------------------

#ifndef UCustomPreviewH
#define UCustomPreviewH
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Forms.hpp>
#include <Vcl.ActnList.hpp>
#include <Vcl.ComCtrls.hpp>
#include <Vcl.Dialogs.hpp>
#include <Vcl.ExtCtrls.hpp>
#include <Vcl.ImgList.hpp>
#include <Vcl.Menus.hpp>
#include <Vcl.ToolWin.hpp>
#include "FlexCel.Preview.hpp"
#include "FlexCel.Render.hpp"
#include "FlexCel.XlsAdapter.hpp"
#include "FlexCel.VCLSupport.hpp"
#include "FlexCel.Core.hpp"
#include "UPdfExporting.h"
#include "UPrinting.h"
#include "UPasswordDialog.h"
#include "UFlexCelHDPI.hpp"
//---------------------------------------------------------------------------
class TFCustomPreview : public TForm
{
__published:	// IDE-managed Components
	TSplitter *Splitter1;
	TPanel *Panel1;
	TSplitter *Splitter2;
	TPanel *Panel3;
	TCheckBox *cbAllSheets;
	TPanel *Panel4;
	TPanel *Panel5;
	TPanel *Panel6;
	TFlexCelPreviewer *Thumbs;
	TPanel *PanelSheets;
	TListBox *lbSheets;
	TPanel *Panel2;
	TFlexCelPreviewer *MainPreview;
	TPanel *PanelPrinting;
	TLabel *lblProgressTask;
	TLabel *lblPrintPage;
	TProgressBar *PrintProgressBar;
	TButton *btnPrintCancel;
	TPanel *PanelPdf;
	TLabel *Label1;
	TLabel *lblPdfPage;
	TProgressBar *PdfProgressBar;
	TButton *btnPdfCancel;
	TPanel *PanelPdfError;
	TLabel *lblPdfError;
	TButton *btnPdfErrorClose;
	TPanel *PanelPrintingError;
	TLabel *lblPrintingError;
	TButton *btnPrintingErrorClose;
	TPanel *PanelPrintingOk;
	TLabel *Label2;
	TButton *btnPrintOkClose;
	TPanel *PanelPdfOk;
	TLabel *Label3;
	TButton *btnPdfOkClose;
	TButton *btnOpenGeneratedFile;
	TPanel *FlowPanel1;
	TToolBar *ToolBar2;
	TToolButton *ToolButton14;
	TToolButton *ToolButton15;
	TToolButton *ToolButton16;
	TToolButton *ToolButton17;
	TToolButton *ToolButton18;
	TPanel *PanelSelectPage;
	TLabel *Label4;
	TLabel *lblTotalPages;
	TEdit *edPage;
	TToolBar *ToolBar4;
	TToolButton *ToolButtonZoom;
	TToolButton *ToolButton27;
	TToolButton *ToolButton28;
	TToolButton *ToolButton29;
	TToolButton *ToolButton30;
	TToolButton *ToolButton31;
	TToolButton *ToolButton32;
	TPanel *PanelZoom;
	TTrackBar *TrackBarZoom;
	TButton *btn25;
	TButton *btn50;
	TButton *btn75;
	TButton *btn100;
	TButton *btn150;
	TPanel *PanelPrint;
	TButton *btnPrint;
	TActionList *Actions;
	TAction *ActionOpen;
	TAction *ActionAutofit;
	TAction *ActionRecalc;
	TAction *ActionHeadings;
	TAction *ActionPdf;
	TAction *ActionPrint;
	TAction *ActionGridLines;
	TAction *ActionClose;
	TAction *ActionZoom;
	TOpenDialog *OpenDialog;
	TImageList *ToolbarImages;
	TImageList *ToolbarImagesDisabled;
	TSaveDialog *PdfSaveDialog;
	TPrintDialog *PrintDialog;
	TPopupMenu *AutofitMenu;
	TMenuItem *NoAutofit1;
	TMenuItem *FittoWidth1;
	TMenuItem *FittoHeight1;
	TMenuItem *FittoPage1;
	TImageList *ToolbarImages_100Scale;
	TImageList *ToolbarImages_300Scale;
	TToolBar *ToolBarAutofit;
	TToolButton *ToolButton1;
	void __fastcall FormCreate(TObject *Sender);
	void __fastcall ActionCloseExecute(TObject *Sender);
	void __fastcall ActionOpenExecute(TObject *Sender);
	void __fastcall cbAllSheetsClick(TObject *Sender);
	void __fastcall lbSheetsClick(TObject *Sender);
	void __fastcall ActionPdfExecute(TObject *Sender);
	void __fastcall ActionPrintExecute(TObject *Sender);
	void __fastcall btnOpenGeneratedFileClick(TObject *Sender);
	void __fastcall btnPdfCancelClick(TObject *Sender);
	void __fastcall btnPrintCancelClick(TObject *Sender);
	void __fastcall btnPdfErrorCloseClick(TObject *Sender);
	void __fastcall btnPrintingErrorCloseClick(TObject *Sender);
	void __fastcall btnPrintOkCloseClick(TObject *Sender);
	void __fastcall btnPdfOkCloseClick(TObject *Sender);
	void __fastcall MainPreviewStartPageChanged(TObject *Sender);
	void __fastcall edPageExit(TObject *Sender);
	void __fastcall edPageKeyPress(TObject *Sender, System::WideChar &Key);
	void __fastcall MainPreviewZoomChanged(TObject *Sender);
	void __fastcall ActionZoomExecute(TObject *Sender);
	void __fastcall btn25Click(TObject *Sender);
	void __fastcall btn50Click(TObject *Sender);
	void __fastcall btn75Click(TObject *Sender);
	void __fastcall btn100Click(TObject *Sender);
	void __fastcall btn150Click(TObject *Sender);
	void __fastcall TrackBarZoomChange(TObject *Sender);
	void __fastcall TrackBarZoomEnter(TObject *Sender);
	void __fastcall PanelZoomExit(TObject *Sender);
	void __fastcall ActionAutofitExecute(TObject *Sender);
	void __fastcall NoAutofit1Click(TObject *Sender);
	void __fastcall FittoWidth1Click(TObject *Sender);
	void __fastcall FittoHeight1Click(TObject *Sender);
	void __fastcall FittoPage1Click(TObject *Sender);
	void __fastcall ActionRecalcExecute(TObject *Sender);
	void __fastcall ActionGridLinesExecute(TObject *Sender);
	void __fastcall ActionHeadingsExecute(TObject *Sender);
	void __fastcall FormDestroy(TObject *Sender);
private:	// User declarations
	TExcelFile *Xls;
	TFlexCelImgExport *ImgExport;
	TPrintingThread *PrintingThread;
	TPdfThread *PdfThread;
	int DisabledCount;
	bool ChangingZoom;
	void __fastcall EnableCommonActions(bool Enable);
	void __fastcall LoadFile(String FileName);
#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older, this should be "TOnPasswordEventArgs * const e".
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
	void __fastcall GetPassword(const TOnPasswordEventArgs *e);
#else
	void __fastcall GetPassword(TOnPasswordEventArgs* const e);
#endif

	void __fastcall UpdateZoom();
	void __fastcall UpdateAutofitText();
	void __fastcall UpdatePages();
	void __fastcall ChangePages();
	void __fastcall DPIChanged();
	void __fastcall PdfFinalFeedback(bool Ok, String  Msg);
	void __fastcall PdfProgressFeedback(int Progress, String Msg);
	void __fastcall PrintFinalFeedback(bool Ok, String  Msg);
	void __fastcall PrintProgressFeedback(int Progress, String Msg);

public:		// User declarations
	__fastcall TFCustomPreview(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TFCustomPreview *FCustomPreview;
//---------------------------------------------------------------------------
#endif

UPasswordDialog.h

//---------------------------------------------------------------------------

#ifndef UPasswordDialogH
#define UPasswordDialogH
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Forms.hpp>
//---------------------------------------------------------------------------
class TPasswordDialog : public TForm
{
__published:	// IDE-managed Components
	TLabel *Label1;
	TLabel *lblFileName;
	TButton *Button1;
	TButton *Button2;
	TEdit *edPassword;
private:	// User declarations
public:		// User declarations
	__fastcall TPasswordDialog(TComponent* Owner);

	__fastcall String Password();
	__fastcall void SetFileName(const String FileName);

};
//---------------------------------------------------------------------------
extern PACKAGE TPasswordDialog *PasswordDialog;
//---------------------------------------------------------------------------
#endif

UPdfExporting.h

//---------------------------------------------------------------------------

#ifndef UPdfExportingH
#define UPdfExportingH
//---------------------------------------------------------------------------

#include <IOUtils.hpp>
#include "UProgressThread.h"
#include "FlexCel.Pdf.hpp"
#include "FlexCel.Render.hpp"
#include "FlexCel.Core.hpp"
//---------------------------------------------------------------------------
class TPdfThread: public TProgressThread
{
  public:
	__fastcall TPdfThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets);


  virtual void __fastcall Execute();
#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
void __fastcall ShowProgress(const TObject* sender, const TPageEventArgs* e);
#else
void __fastcall ShowProgress(TObject* const sender, TPageEventArgs* const e);
#endif
};
//---------------------------------------------------------------------------

#endif

UPrinting.h

//---------------------------------------------------------------------------

#ifndef UPrintingH
#define UPrintingH
//---------------------------------------------------------------------------
#include "UProgressThread.h"
#include "FlexCel.Render.hpp"
//---------------------------------------------------------------------------
class TPrintingThread: public TProgressThread
{
  public:
	__fastcall TPrintingThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets);


  virtual void __fastcall Execute();
#if (__BORLANDC__ < 0x0650) //XE2 or older
//C++ builder header translations are wrong for XE2 or older
//see http://qc.embarcadero.com/wc/qcmain.aspx?d=42782
void __fastcall ShowProgress(const TObject* sender, const TPrintPageEventArgs* e);
#else
void __fastcall ShowProgress(TObject* const sender, TPrintPageEventArgs* const e);
#endif
};
//---------------------------------------------------------------------------
#endif

UProgressThread.h

//---------------------------------------------------------------------------

#ifndef UProgressThreadH
#define UProgressThreadH
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include "FlexCel.Core.hpp"

typedef void __fastcall (__closure *TFeedbackMethod)(int Progress, String Msg);
typedef void __fastcall (__closure *TFinalFeedbackMethod)(bool Ok, String Msg);

//---------------------------------------------------------------------------
class TProgressThread: public TThread
{
  private:
	String FinalFeedback_msg;
	bool FinalFeedback_ok;
	void __fastcall DoFinalFeedback();
  protected:
	String ProgressFeedback_msg;
	bool ProgressFeedback_percent;
	void __fastcall DoProgressFeedback();

  protected:
	TFeedbackMethod ProgressFeedback;
	TFinalFeedbackMethod FinalFeedback;
	TExcelFile *Xls;
	String FileName;
	bool AllSheets;
	bool Canceled;

	virtual void __fastcall TerminatedSet();
	virtual void __fastcall DoTerminate();

  public:
	__fastcall TProgressThread(TExcelFile *aXls, TFeedbackMethod aProgressFeedback,
	  TFinalFeedbackMethod aFinalFeedback, String aFileName, bool aAllSheets);

};
//---------------------------------------------------------------------------
#endif