wxiscanframe.cpp

Go to the documentation of this file.

/*************************************************************
 * Name:      wxiscanframe.cpp
 * Purpose:   Code for application frame (the main) window
 * Author:    Daniel Nell (daniel.nell@nellresearch.de)
 * Created:   2008-05-04
 * Copyright: Daniel Nell (www.nellresearch.de)
 * License:   GPL
 **************************************************************/

// Include precompiled headers.
#include "wx_pch.h"

//(*InternalHeaders(wxIScanFrame)
#include <wx/string.h>
#include <wx/intl.h>
#include <wx/bitmap.h>
#include <wx/icon.h>
#include <wx/image.h>
#include <wx/artprov.h>
//*)

// wxWidgets headers
#include <wx/accel.h>
#include <wx/clipbrd.h>
#include <wx/config.h>
#include <wx/fileconf.h>
#include <wx/filename.h>
#if __WXPDFDOC__
#   include <wx/pdfdoc.h>
#endif // __WXPDFDOC__
#include <wx/print.h>
#include <wx/printdlg.h>
#if __DEBUG__
#   include <wx/stdpaths.h>
#endif // __DEBUG__
#include <wx/txtstrm.h>

// Private headers
#include "wxextprocess.h"
#include "wxiscanabout.h"
#include "wxiscanapp.h"
#include "wxiscanframe.h"
#include "wxiscanglobals.h"
#if __WXLUASCRIPT__
#   include "wxiscanluascript.h"
#endif // __WXLUASCRIPT__
#include "wxiscanresources.h"
#include "wxchainlogtextctrl.h"
#include "wxiviewprintout.h"
#include "wxoptionsdialog.h"
#include "wxtextctrlcolourizer.h"

#if __WXLUASCRIPT__
// Include Lua header file(s).
#   include "lua5.1/lua.hpp"
#endif // WXLUASCRIPT__

// Resources
//}

//(*IdInit(wxIScanFrame)
const long wxIScanFrame::ID_CANVAS = wxNewId();
const long wxIScanFrame::ID_PAGES = wxNewId();
const long wxIScanFrame::ID_VSPLITTERWINDOW = wxNewId();
const long wxIScanFrame::ID_LOGTEXTCTRL = wxNewId();
const long wxIScanFrame::ID_HSPLITTERWINDOW = wxNewId();
const long wxIScanFrame::ID_FILESCANIMAGE = wxNewId();
const long wxIScanFrame::ID_FILEOPEN = wxNewId();
const long wxIScanFrame::ID_FILESAVEAS = wxNewId();
const long wxIScanFrame::ID_FILEPRINT = wxNewId();
const long wxIScanFrame::ID_FILEPRINTPREVIEW = wxNewId();
const long wxIScanFrame::ID_FILEPRINTSETUP = wxNewId();
const long wxIScanFrame::ID_FILEQUIT = wxNewId();
const long wxIScanFrame::ID_EDITCOPY = wxNewId();
const long wxIScanFrame::ID_EDITPASTE = wxNewId();
const long wxIScanFrame::ID_EDITSETTINGS = wxNewId();
const long wxIScanFrame::ID_EDITSETTINGSFILE = wxNewId();
const long wxIScanFrame::ID_EDITSCANSCANNERS = wxNewId();
const long wxIScanFrame::ID_EDITCLEARLOG = wxNewId();
const long wxIScanFrame::ID_EDITCLEARHISTORY = wxNewId();
const long wxIScanFrame::ID_VIEWFULLSCREEN = wxNewId();
const long wxIScanFrame::ID_VIEWFITWIDTH = wxNewId();
const long wxIScanFrame::ID_VIEWFITWINDOW = wxNewId();
const long wxIScanFrame::ID_VIEWFULLSIZE = wxNewId();
const long wxIScanFrame::ID_VIEWCUSTOMSIZE = wxNewId();
const long wxIScanFrame::ID_VIEWZOOMIN = wxNewId();
const long wxIScanFrame::ID_VIEWZOOMOUT = wxNewId();
const long wxIScanFrame::ID_VIEWZOOMSELECTION = wxNewId();
const long wxIScanFrame::ID_VIEWCLOSEDEBUGWINDOW = wxNewId();
const long wxIScanFrame::ID_VIEWCLOSEPREVIEWPANEL = wxNewId();
const long wxIScanFrame::ID_DOCUMENTCOPYTEXT = wxNewId();
const long wxIScanFrame::ID_DOCUMENTREADTEXT = wxNewId();
const long wxIScanFrame::ID_CMDSTOP = wxNewId();
const long wxIScanFrame::ID_DOCUMENTFIRSTPAGE = wxNewId();
const long wxIScanFrame::ID_DOCUMENTPREVIOUSPAGE = wxNewId();
const long wxIScanFrame::ID_DOCUMENTNEXTPAGE = wxNewId();
const long wxIScanFrame::ID_DOCUMENTLASTPAGE = wxNewId();
const long wxIScanFrame::ID_DOCUMENTROTATE90LEFT = wxNewId();
const long wxIScanFrame::ID_DOCUMENTROTATE90RIGHT = wxNewId();
const long wxIScanFrame::ID_DOCUMENTCROP = wxNewId();
const long wxIScanFrame::ID_DOCUMENTAPPLYPROFILE = wxNewId();
const long wxIScanFrame::ID_MENUDOCUMENTPROFILES = wxNewId();
const long wxIScanFrame::ID_PDFBEGINPDF = wxNewId();
const long wxIScanFrame::ID_PDFADDPAGE = wxNewId();
const long wxIScanFrame::ID_PDFSAVEASPDF = wxNewId();
const long wxIScanFrame::ID_HELPABOUT = wxNewId();
const long wxIScanFrame::ID_FILESCANIMAGE_TB = wxNewId();
const long wxIScanFrame::ID_FILEOPEN_TB = wxNewId();
const long wxIScanFrame::ID_FILESAVEAS_TB = wxNewId();
const long wxIScanFrame::ID_FILEPRINT_TB = wxNewId();
const long wxIScanFrame::ID_PDFBEGINPDF_TB = wxNewId();
const long wxIScanFrame::ID_PDFADDPAGE_TB = wxNewId();
const long wxIScanFrame::ID_PDFSAVEASPDF_TB = wxNewId();
const long wxIScanFrame::ID_DOCUMENTFIRSTPAGE_TB = wxNewId();
const long wxIScanFrame::ID_DOCUMENTPREVIOUSPAGE_TB = wxNewId();
const long wxIScanFrame::ID_DOCUMENTNEXTPAGE_TB = wxNewId();
const long wxIScanFrame::ID_DOCUMENTLASTPAGE_TB = wxNewId();
const long wxIScanFrame::ID_DOCUMENTREADTEXT_TB = wxNewId();
const long wxIScanFrame::ID_CMDSTOP_TB = wxNewId();
//*)
#if __WXLUASCRIPT__
const long wxIScanFrame::ID_DOCUMENTREADTEXTSYNC= wxNewId();
#endif // __WXLUASCRIPT__
const long wxIScanFrame::ID_TEXTCTRLPAGE= wxNewId();
#ifdef __WXSCANSANE__
const long wxIScanFrame::ID_CHOICESCANNER= wxNewId();
#endif // __WXSCANSANE__
const long wxIScanFrame::ID_DOCUMENTPROFILE0= wxNewId();


//////////////////////////////////////////////////////////
// Strings and other (global) constants
//
static const wxString cstrwxFrame= wxT( "wxIScanFrame" );


//////////////////////////////////////////////////////////
// Class wxIScanFrame
//
// Event table
//
BEGIN_EVENT_TABLE( wxIScanFrame, wxFrame )
    //(*EventTable(wxIScanFrame)
    //*)
    // File history handling.
    EVT_MENU_RANGE( wxID_FILE1, wxID_FILE9, wxIScanFrame::OnMRUFiles )
#if __WXLUASCRIPT__
    EVT_MENU_RANGE( ID_DOCUMENTPROFILE0 + 1000, ID_DOCUMENTPROFILE0 + 1999, wxIScanFrame::OnScriptStartScript )
    EVT_MENU( ID_DOCUMENTREADTEXTSYNC, wxIScanFrame::OnDocumentReadText )
#endif // __WXLUASCRIPT__
    // File drop event
    EVT_EXTFILEDROP( wxIScanFrame::OnFileDrop )
    // Handle canvas size changes.
    EVT_IVIEWCANVASSIZE( wxIScanFrame::OnCanvasSize )
    // Handle canvas selection changes.
    EVT_IVIEWCANVASSELECTED( wxIScanFrame::OnCanvasSelected )
    // Handle process events.
    EVT_END_PROCESS( wxISCAN_PROCESS, wxIScanFrame::OnProcessTerminated )
    // Handle page number editor field events.
    EVT_TEXT_ENTER( ID_TEXTCTRLPAGE, wxIScanFrame::OnTextCtrlPageProcessEnter )
#ifdef __WXSCANSANE__
    // Handle thread events.
    EVT_MENU( wxExtThread::ID_EXIT, wxIScanFrame::OnThreadExit )
#endif // __WXSCANSANE__
END_EVENT_TABLE()


// Standard constructor.
//
wxIScanFrame::wxIScanFrame( wxWindow* parent, wxWindowID id )
  :
  m_bUILocked( false ),
  m_poScanner( NULL ),
  m_nScaleFactor( 1.0 ),
  m_nZoomFactor( 0.1 ),
  m_nProfileIndex( 0 ),
#if __WXPDFDOC__
  m_poPdfDoc( NULL ),
  m_nPdfPages( 0 ),
  m_bPdfDirty( false ),
#endif
#if __WXLUASCRIPT__
  bLuaReturnFromEventHandler( true ),
#endif // __WXLUASCRIPT__
  m_poRunningProcess( NULL ),
  m_oTextValidatorTextCtrlPage( wxFILTER_NUMERIC )
{
    //(*Initialize(wxIScanFrame)
    wxMenuItem* poOnDocumentZoom;
    wxMenu* poMenuHelp;
    wxMenuItem* poMenuSavePdf;
    wxMenuItem* poViewCustomSize;
    wxMenuItem* poDocumentRotate90Left;
    wxMenuItem* poViewZoomOut;
    wxMenuItem* poMenuFileOpen;
    wxMenuItem* poMenuFileSaveAs;
    wxMenuItem* poHelpAbout;
    wxMenuItem* poMenuCmdStop;
    wxMenuItem* poFileQuit;
    wxMenuItem* poMenuPdfBeginPdf;
    wxMenuItem* poMenuFileScanImage;
    wxMenuItem* poViewFitWidth;
    wxMenuItem* poMenuDocumentPreviousPage;
    wxMenuItem* poEditSettingsFile;
    wxMenuItem* poMenuFilePrint;
    wxMenuItem* poViewFullSize;
    wxMenuItem* poOnDocumentCrop;
    wxMenuItem* poEditClearHistory;
    wxMenu* poMenuDocument;
    wxMenuItem* poMenuFilePrintPreview;
    wxStatusBar* poStatusBar;
    wxMenuItem* poViewClosePreviewPanel;
    wxMenuItem* poMenuDocumentLastPage;
    wxMenuItem* poMenuDocumentReadText;
    wxMenuItem* poViewFullScreen;
    wxMenuItem* poViewFitWindow;
    wxMenuItem* poMenuPdfAddPage;
    wxMenuItem* poViewZoomIn;
    wxMenuItem* poEditSettings;
    wxToolBar* poToolBar;
    wxMenu* poMenuDocumentProfiles;
    wxMenuItem* poViewCloseDebugWindow;
    wxMenuItem* poDocumentApplyProfile;
    wxMenuItem* poMenuDocumentCopyText;
    wxMenuItem* poEditCopy;
    wxMenu* poMenuFile;
    wxMenu* poMenuPdf;
    wxMenuBar* poMenuBar;
    wxMenu* poView;
    wxMenuItem* poMenuFilePrintSetup;
    wxMenuItem* poEditPaste;
    wxMenuItem* poEditClearLog;
    wxMenuItem* poDocumentRotate90Right;
    wxMenuItem* poMenuDocumentFirstPage;
    wxMenuItem* poEditScanScanners;
    wxMenuItem* poMenuDocumentNextPage;

    Create(parent, wxID_ANY, _("wxIScan"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("wxID_ANY"));
    {
        wxIcon FrameIcon;
        FrameIcon.CopyFromBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_NORMAL_FILE")),wxART_FRAME_ICON));
        SetIcon(FrameIcon);
    }
    m_poHSplitterWindow = new wxSplitterWindow(this, ID_HSPLITTERWINDOW, wxDefaultPosition, wxDefaultSize, wxSP_3D|wxSP_LIVE_UPDATE, _T("ID_HSPLITTERWINDOW"));
    m_poHSplitterWindow->SetMinSize(wxSize(1,1));
    m_poHSplitterWindow->SetMinimumPaneSize(1);
    m_poHSplitterWindow->SetSashGravity(0);
    m_poVSplitterWindow = new wxSplitterWindow(m_poHSplitterWindow, ID_VSPLITTERWINDOW, wxDefaultPosition, wxDefaultSize, wxSP_3D|wxSP_LIVE_UPDATE, _T("ID_VSPLITTERWINDOW"));
    m_poVSplitterWindow->SetMinSize(wxSize(1,1));
    m_poVSplitterWindow->SetMinimumPaneSize(1);
    m_poVSplitterWindow->SetSashGravity(0);
    m_poCanvas = new wxIViewCanvas(m_poVSplitterWindow, ID_CANVAS, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxVSCROLL|wxHSCROLL, _T("ID_CANVAS"));
    m_poPanelPages = new wxImagePanel(m_poVSplitterWindow, ID_PAGES, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxVSCROLL|wxHSCROLL, _T("ID_PAGES"));
    m_poVSplitterWindow->SplitVertically(m_poCanvas, m_poPanelPages);
    m_poVSplitterWindow->SetSashPosition(1);
    m_poLogTextCtrl = new wxTextCtrl(m_poHSplitterWindow, ID_LOGTEXTCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY|wxTE_RICH|wxTE_AUTO_URL|wxTE_DONTWRAP, wxDefaultValidator, _T("ID_LOGTEXTCTRL"));
    m_poHSplitterWindow->SplitHorizontally(m_poVSplitterWindow, m_poLogTextCtrl);
    m_poHSplitterWindow->SetSashPosition(250);
    poMenuBar = new wxMenuBar();
    poMenuFile = new wxMenu();
    poMenuFileScanImage = new wxMenuItem(poMenuFile, ID_FILESCANIMAGE, _("Scan &Image\tCtrl+I"), _("Scan an image"), wxITEM_NORMAL);
    poMenuFile->Append(poMenuFileScanImage);
    poMenuFileScanImage= poMenuFile->Remove( ID_FILESCANIMAGE );
    poMenuFileScanImage->SetBitmap( filescanimagebmp_xpm );
    poMenuFile->Append( poMenuFileScanImage );
    poMenuFile->AppendSeparator();
    poMenuFileOpen = new wxMenuItem(poMenuFile, ID_FILEOPEN, _("&Open...\tCtrl+O"), _("Open an image file."), wxITEM_NORMAL);
    poMenuFileOpen->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_OPEN")),wxART_MENU));
    poMenuFile->Append(poMenuFileOpen);
    poMenuFileSaveAs = new wxMenuItem(poMenuFile, ID_FILESAVEAS, _("Save &as...\tCtrl+S"), _("Save scanned image to file."), wxITEM_NORMAL);
    poMenuFileSaveAs->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_SAVE_AS")),wxART_MENU));
    poMenuFile->Append(poMenuFileSaveAs);
    poMenuFileSaveAs->Enable(false);
    poMenuFile->AppendSeparator();
    poMenuFilePrint = new wxMenuItem(poMenuFile, ID_FILEPRINT, _("&Print...\tCtrl+P"), _("Print the current image."), wxITEM_NORMAL);
    poMenuFilePrint->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_PRINT")),wxART_MENU));
    poMenuFile->Append(poMenuFilePrint);
    poMenuFilePrint->Enable(false);
    poMenuFilePrintPreview = new wxMenuItem(poMenuFile, ID_FILEPRINTPREVIEW, _("Print pre&view\tCtrl+Alt+P"), _("Show a print preview of the current image."), wxITEM_NORMAL);
    poMenuFile->Append(poMenuFilePrintPreview);
    poMenuFilePrintPreview->Enable(false);
    poMenuFilePrintPreview= poMenuFile->Remove( ID_FILEPRINTPREVIEW );
    poMenuFilePrintPreview->SetBitmap( fileprintpreviewbmp_xpm );
    poMenuFile->Append( poMenuFilePrintPreview );
    poMenuFilePrintSetup = new wxMenuItem(poMenuFile, ID_FILEPRINTSETUP, _("Page setup"), _("Show page setup dialog."), wxITEM_NORMAL);
    poMenuFile->Append(poMenuFilePrintSetup);
    poMenuFilePrintSetup= poMenuFile->Remove( ID_FILEPRINTSETUP );
    poMenuFilePrintSetup->SetBitmap( fileprintsetupbmp_xpm );
    poMenuFile->Append( poMenuFilePrintSetup );
    poMenuFile->AppendSeparator();
    poFileQuit = new wxMenuItem(poMenuFile, ID_FILEQUIT, _("&Quit\tCtrl+Q"), _("Quit the application"), wxITEM_NORMAL);
    poFileQuit->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_QUIT")),wxART_MENU));
    poMenuFile->Append(poFileQuit);
    poMenuBar->Append(poMenuFile, _("&File"));
    poMenuEdit = new wxMenu();
    poEditCopy = new wxMenuItem(poMenuEdit, ID_EDITCOPY, _("&Copy\tCtrl+C"), _("Copy image to clipboard"), wxITEM_NORMAL);
    poEditCopy->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_COPY")),wxART_MENU));
    poMenuEdit->Append(poEditCopy);
    poEditCopy->Enable(false);
    poEditPaste = new wxMenuItem(poMenuEdit, ID_EDITPASTE, _("&Paste\tCtrl-V"), _("Inserts the content of the clipboard."), wxITEM_NORMAL);
    poEditPaste->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_PASTE")),wxART_TOOLBAR));
    poMenuEdit->Append(poEditPaste);
    poMenuEdit->AppendSeparator();
    poEditSettings = new wxMenuItem(poMenuEdit, ID_EDITSETTINGS, _("&Settings...\tCtrl-Alt-O"), _("Edit (most) settings in a dialog window."), wxITEM_NORMAL);
    poEditSettings->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_EXECUTABLE_FILE")),wxART_MENU));
    poMenuEdit->Append(poEditSettings);
    poEditSettingsFile = new wxMenuItem(poMenuEdit, ID_EDITSETTINGSFILE, _("Edit settings &file"), _("Edit settings file in a text editor."), wxITEM_NORMAL);
    poEditSettingsFile->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_HELP_SETTINGS")),wxART_MENU));
    poMenuEdit->Append(poEditSettingsFile);
    poMenuEdit->AppendSeparator();
    poEditScanScanners = new wxMenuItem(poMenuEdit, ID_EDITSCANSCANNERS, _("Scan for scanne&rs\tF4"), _("Scan for available scanning devices (USB, network etc.)."), wxITEM_NORMAL);
    poMenuEdit->Append(poEditScanScanners);
    poEditScanScanners= poMenuEdit->Remove( ID_EDITSCANSCANNERS );
    poEditScanScanners->SetBitmap( filescanimagebmp_xpm );
    poMenuEdit->Append( poEditScanScanners );
    poMenuEdit->AppendSeparator();
    poEditClearLog = new wxMenuItem(poMenuEdit, ID_EDITCLEARLOG, _("Clear &log\tF5"), _("Clear log window."), wxITEM_NORMAL);
    poEditClearLog->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_DELETE")),wxART_MENU));
    poMenuEdit->Append(poEditClearLog);
    poEditClearHistory = new wxMenuItem(poMenuEdit, ID_EDITCLEARHISTORY, _("Clear file &history"), _("Clear the file history."), wxITEM_NORMAL);
    poEditClearHistory->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_DEL_BOOKMARK")),wxART_MENU));
    poMenuEdit->Append(poEditClearHistory);
    poMenuBar->Append(poMenuEdit, _("&Edit"));
    poView = new wxMenu();
    poViewFullScreen = new wxMenuItem(poView, ID_VIEWFULLSCREEN, _("&Full screen\tF12"), _("View in full screen mode (no frame, no caption etc.)"), wxITEM_CHECK);
    poView->Append(poViewFullScreen);
    poView->AppendSeparator();
    poViewFitWidth = new wxMenuItem(poView, ID_VIEWFITWIDTH, _("Fit image to window w&idth\tI"), _("Zoom image to fit the window width."), wxITEM_CHECK);
    poView->Append(poViewFitWidth);
    poViewFitWindow = new wxMenuItem(poView, ID_VIEWFITWINDOW, _("Fit image to &window\tW"), _("Zoom image to fit the window size."), wxITEM_CHECK);
    poView->Append(poViewFitWindow);
    poViewFullSize = new wxMenuItem(poView, ID_VIEWFULLSIZE, _("View image in &original size\tO"), _("Show image in its original size (without any zooming)."), wxITEM_CHECK);
    poView->Append(poViewFullSize);
    poViewCustomSize = new wxMenuItem(poView, ID_VIEWCUSTOMSIZE, _("View image in &custom size\tC"), _("Zoom image to an explicit given (fixed) zoom factor."), wxITEM_CHECK);
    poView->Append(poViewCustomSize);
    poView->AppendSeparator();
    poViewZoomIn = new wxMenuItem(poView, ID_VIEWZOOMIN, _("Zoom &in\t+"), _("Zoom into the image."), wxITEM_NORMAL);
    poView->Append(poViewZoomIn);
    poViewZoomOut = new wxMenuItem(poView, ID_VIEWZOOMOUT, _("Zoom &out\t-"), _("Zoom out of the image."), wxITEM_NORMAL);
    poView->Append(poViewZoomOut);
    poOnDocumentZoom = new wxMenuItem(poView, ID_VIEWZOOMSELECTION, _("&Zoom selection\tZ"), _("Zoom the image along selection rectangle."), wxITEM_NORMAL);
    poView->Append(poOnDocumentZoom);
    poOnDocumentZoom->Enable(false);
    poView->AppendSeparator();
    poViewCloseDebugWindow = new wxMenuItem(poView, ID_VIEWCLOSEDEBUGWINDOW, _("Close the &debug window\tF2"), _("Close the debug window."), wxITEM_NORMAL);
    poView->Append(poViewCloseDebugWindow);
    poViewClosePreviewPanel = new wxMenuItem(poView, ID_VIEWCLOSEPREVIEWPANEL, _("Close the preview &panel\tF3"), _("Close the PDF preview panel."), wxITEM_NORMAL);
    poView->Append(poViewClosePreviewPanel);
    poMenuBar->Append(poView, _("&View"));
    poMenuDocument = new wxMenu();
    poMenuDocumentCopyText = new wxMenuItem(poMenuDocument, ID_DOCUMENTCOPYTEXT, _("Copy &text\tCtrl-Alt-C"), _("Copies via OCR detected text to the clipboard."), wxITEM_NORMAL);
    poMenuDocumentCopyText->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_COPY")),wxART_MENU));
    poMenuDocument->Append(poMenuDocumentCopyText);
    poMenuDocumentCopyText->Enable(false);
    poMenuDocumentReadText = new wxMenuItem(poMenuDocument, ID_DOCUMENTREADTEXT, _("&Read out document\tCtrl+Alt+R"), _("Reads the document through TTS."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuDocumentReadText);
    poMenuDocumentReadText->Enable(false);
    poMenuDocumentReadText= poMenuDocument->Remove( ID_DOCUMENTREADTEXT );
    poMenuDocumentReadText->SetBitmap( documentreadtext_xpm );
    poMenuDocument->Append( poMenuDocumentReadText );
    poMenuCmdStop = new wxMenuItem(poMenuDocument, ID_CMDSTOP, _("&Stop\tCtrl-Alt-E"), _("Stop background action."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuCmdStop);
    poMenuCmdStop->Enable(false);
    poMenuCmdStop= poMenuDocument->Remove( ID_CMDSTOP );
    poMenuCmdStop->SetBitmap( cmdstop_xpm );
    poMenuDocument->Append( poMenuCmdStop );
    poMenuDocument->AppendSeparator();
    poMenuDocumentFirstPage = new wxMenuItem(poMenuDocument, ID_DOCUMENTFIRSTPAGE, _("&First page\tCtrl+Home"), _("Go to first document page."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuDocumentFirstPage);
    poMenuDocumentFirstPage->Enable(false);
    poMenuDocumentFirstPage= poMenuDocument->Remove( ID_DOCUMENTFIRSTPAGE );
    poMenuDocumentFirstPage->SetBitmap( documentfirstpage_xpm );
    poMenuDocument->Append( poMenuDocumentFirstPage );
    poMenuDocumentPreviousPage = new wxMenuItem(poMenuDocument, ID_DOCUMENTPREVIOUSPAGE, _("&Previous page\tCtrl+PageUp"), _("Go to previous document page."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuDocumentPreviousPage);
    poMenuDocumentPreviousPage->Enable(false);
    poMenuDocumentPreviousPage= poMenuDocument->Remove( ID_DOCUMENTPREVIOUSPAGE );
    poMenuDocumentPreviousPage->SetBitmap( documentpreviouspage_xpm );
    poMenuDocument->Append( poMenuDocumentPreviousPage );
    poMenuDocumentNextPage = new wxMenuItem(poMenuDocument, ID_DOCUMENTNEXTPAGE, _("&Next page\tCtrl+PageDown"), _("Go to next document page."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuDocumentNextPage);
    poMenuDocumentNextPage->Enable(false);
    poMenuDocumentNextPage= poMenuDocument->Remove( ID_DOCUMENTNEXTPAGE );
    poMenuDocumentNextPage->SetBitmap( documentnextpage_xpm );
    poMenuDocument->Append( poMenuDocumentNextPage );
    poMenuDocumentLastPage = new wxMenuItem(poMenuDocument, ID_DOCUMENTLASTPAGE, _("&Last page\tCtrl+End"), _("Go to last document page."), wxITEM_NORMAL);
    poMenuDocument->Append(poMenuDocumentLastPage);
    poMenuDocumentLastPage->Enable(false);
    poMenuDocumentLastPage= poMenuDocument->Remove( ID_DOCUMENTLASTPAGE );
    poMenuDocumentLastPage->SetBitmap( documentlastpage_xpm );
    poMenuDocument->Append( poMenuDocumentLastPage );
    poMenuDocument->AppendSeparator();
    poDocumentRotate90Left = new wxMenuItem(poMenuDocument, ID_DOCUMENTROTATE90LEFT, _("Rotate 90 degress &left\tL"), _("Rotate 90 degress left"), wxITEM_NORMAL);
    poDocumentRotate90Left->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_UNDO")),wxART_MENU));
    poMenuDocument->Append(poDocumentRotate90Left);
    poDocumentRotate90Left->Enable(false);
    poDocumentRotate90Right = new wxMenuItem(poMenuDocument, ID_DOCUMENTROTATE90RIGHT, _("Rotate 90 degress &right\tR"), _("Rotate 90 degress right"), wxITEM_NORMAL);
    poDocumentRotate90Right->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_REDO")),wxART_MENU));
    poMenuDocument->Append(poDocumentRotate90Right);
    poDocumentRotate90Right->Enable(false);
    poOnDocumentCrop = new wxMenuItem(poMenuDocument, ID_DOCUMENTCROP, _("&Crop selection\tCtrl+Y"), _("Crop the image along selection rectangle."), wxITEM_NORMAL);
    poOnDocumentCrop->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_CUT")),wxART_MENU));
    poMenuDocument->Append(poOnDocumentCrop);
    poOnDocumentCrop->Enable(false);
    poMenuDocument->AppendSeparator();
    poDocumentApplyProfile = new wxMenuItem(poMenuDocument, ID_DOCUMENTAPPLYPROFILE, _("&Apply profile\tp"), _("Apply the current selected image profile to the image."), wxITEM_NORMAL);
    poMenuDocument->Append(poDocumentApplyProfile);
    poDocumentApplyProfile->Enable(false);
    poMenuDocumentProfiles = new wxMenu();
    poMenuDocumentProfiles->AppendSeparator();
    poMenuDocument->Append(ID_MENUDOCUMENTPROFILES, _("&Profiles"), poMenuDocumentProfiles, wxEmptyString);
    poMenuBar->Append(poMenuDocument, _("&Document"));
    poMenuPdf = new wxMenu();
    poMenuPdfBeginPdf = new wxMenuItem(poMenuPdf, ID_PDFBEGINPDF, _("&Begin PDF\tCtrl+Alt+N"), _("Start a new PDF document."), wxITEM_NORMAL);
    poMenuPdfBeginPdf->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_NEW")),wxART_MENU));
    poMenuPdf->Append(poMenuPdfBeginPdf);
    poMenuPdfBeginPdf->Enable(false);
    poMenuPdfAddPage = new wxMenuItem(poMenuPdf, ID_PDFADDPAGE, _("&Add Page\tCtrl++"), _("Add image as new page to the PDF document."), wxITEM_NORMAL);
    poMenuPdfAddPage->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_ADD_BOOKMARK")),wxART_MENU));
    poMenuPdf->Append(poMenuPdfAddPage);
    poMenuPdfAddPage->Enable(false);
    poMenuPdf->AppendSeparator();
    poMenuSavePdf = new wxMenuItem(poMenuPdf, ID_PDFSAVEASPDF, _("Save &PDF...\tCtrl+Shift+S"), _("Save image as PDF file."), wxITEM_NORMAL);
    poMenuSavePdf->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_SAVE")),wxART_MENU));
    poMenuPdf->Append(poMenuSavePdf);
    poMenuSavePdf->Enable(false);
    poMenuBar->Append(poMenuPdf, _("&PDF"));
    poMenuHelp = new wxMenu();
    poHelpAbout = new wxMenuItem(poMenuHelp, ID_HELPABOUT, _("&About\tCtrl-Alt-I"), _("Show info about this application"), wxITEM_NORMAL);
    poHelpAbout->SetBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_INFORMATION")),wxART_MENU));
    poMenuHelp->Append(poHelpAbout);
    poMenuBar->Append(poMenuHelp, _("&Help"));
    SetMenuBar(poMenuBar);
    poStatusBar = new wxStatusBar(this, wxID_ANY, 0, _T("wxID_ANY"));
    int __wxStatusBarWidths_1[4] = { -3, 80, 80, -2 };
    int __wxStatusBarStyles_1[4] = { wxSB_FLAT, wxSB_FLAT, wxSB_FLAT, wxSB_FLAT };
    poStatusBar->SetFieldsCount(4,__wxStatusBarWidths_1);
    poStatusBar->SetStatusStyles(4,__wxStatusBarStyles_1);
    SetStatusBar(poStatusBar);
    poToolBar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_VERTICAL|wxNO_BORDER, _T("wxID_ANY"));
    ToolBarItem1 = poToolBar->AddTool(ID_FILESCANIMAGE_TB, _("Scan"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_MISSING_IMAGE")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Scan"), _("Scan an image"));
    poToolBar->AddSeparator();
    ToolBarItem2 = poToolBar->AddTool(ID_FILEOPEN_TB, _("Open"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_OPEN")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Open file"), _("Open an image file."));
    ToolBarItem3 = poToolBar->AddTool(ID_FILESAVEAS_TB, _("Save as"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_SAVE_AS")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Save as"), _("Save scanned image to file."));
    ToolBarItem4 = poToolBar->AddTool(ID_FILEPRINT_TB, _("Print"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_PRINT")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Print"), _("Print the current image."));
    poToolBar->AddSeparator();
    ToolBarItem5 = poToolBar->AddTool(ID_PDFBEGINPDF_TB, _("Begin PDF"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_NEW")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Begin PDF"), _("Start a new PDF document."));
    ToolBarItem6 = poToolBar->AddTool(ID_PDFADDPAGE_TB, _("Add Page"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_ADD_BOOKMARK")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Add PDF Page"), _("Add image as new page to the PDF document."));
    ToolBarItem7 = poToolBar->AddTool(ID_PDFSAVEASPDF_TB, _("Save PDF"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_SAVE_AS")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Save PDF"), _("Save image as PDF file."));
    poToolBar->AddSeparator();
    ToolBarItem8 = poToolBar->AddTool(ID_DOCUMENTFIRSTPAGE_TB, _("First page"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_BACK")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("First page"), _("Go To first document page."));
    ToolBarItem9 = poToolBar->AddTool(ID_DOCUMENTPREVIOUSPAGE_TB, _("Previous page"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_BACK")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Previous page"), _("Go to previous document page."));
    ToolBarItem10 = poToolBar->AddTool(ID_DOCUMENTNEXTPAGE_TB, _("Next page"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_FORWARD")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Next page"), _("Go to next document page."));
    ToolBarItem11 = poToolBar->AddTool(ID_DOCUMENTLASTPAGE_TB, _("Last page"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_FORWARD")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Last page"), _("Go to last document page."));
    poToolBar->AddSeparator();
    ToolBarItem12 = poToolBar->AddTool(ID_DOCUMENTREADTEXT_TB, _("Read out"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_HELP_BOOK")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Read out document via TTS."), _("Read out document via text-to-speach system."));
    ToolBarItem13 = poToolBar->AddTool(ID_CMDSTOP_TB, _("Stop"), wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_ERROR")),wxART_TOOLBAR), wxNullBitmap, wxITEM_NORMAL, _("Stop background action."), _("Stop background action."));
    poToolBar->Realize();
    SetToolBar(poToolBar);

    Connect(ID_FILESCANIMAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFileScanImage);
    Connect(ID_FILEOPEN,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFileOpen);
    Connect(ID_FILESAVEAS,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFileSaveAs);
    Connect(ID_FILEPRINT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFilePrint);
    Connect(ID_FILEPRINTPREVIEW,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFilePrintPreview);
    Connect(ID_FILEPRINTSETUP,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFilePrintSetup);
    Connect(ID_FILEQUIT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnFileQuit);
    Connect(ID_EDITCOPY,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditCopy);
    Connect(ID_EDITPASTE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditPaste);
    Connect(ID_EDITSETTINGS,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditSettings);
    Connect(ID_EDITSETTINGSFILE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditSettingsFile);
    Connect(ID_EDITSCANSCANNERS,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditScanScanners);
    Connect(ID_EDITCLEARLOG,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditClearLog);
    Connect(ID_EDITCLEARHISTORY,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnEditClearHistory);
    Connect(ID_VIEWFULLSCREEN,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFullScreen);
    Connect(ID_VIEWFITWIDTH,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWFITWINDOW,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWFULLSIZE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWCUSTOMSIZE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWZOOMIN,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWZOOMOUT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewFit);
    Connect(ID_VIEWZOOMSELECTION,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentZoom);
    Connect(ID_VIEWCLOSEDEBUGWINDOW,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewCloseDebugWindow);
    Connect(ID_VIEWCLOSEPREVIEWPANEL,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnViewClosePreviewPanel);
    Connect(ID_DOCUMENTCOPYTEXT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentCopyText);
    Connect(ID_DOCUMENTREADTEXT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentReadText);
    Connect(ID_CMDSTOP,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnCmdStop);
    Connect(ID_DOCUMENTFIRSTPAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentFirstPage);
    Connect(ID_DOCUMENTPREVIOUSPAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentPreviousPage);
    Connect(ID_DOCUMENTNEXTPAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentNextPage);
    Connect(ID_DOCUMENTLASTPAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentLastPage);
    Connect(ID_DOCUMENTROTATE90LEFT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentRotate90Left);
    Connect(ID_DOCUMENTROTATE90RIGHT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentRotate90Right);
    Connect(ID_DOCUMENTCROP,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentCrop);
    Connect(ID_DOCUMENTAPPLYPROFILE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentApplyProfile);
    Connect(ID_PDFBEGINPDF,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnPdfBeginPdf);
    Connect(ID_PDFADDPAGE,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnPdfAddPage);
    Connect(ID_PDFSAVEASPDF,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnPdfSavePdf);
    Connect(ID_HELPABOUT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&wxIScanFrame::OnHelpAbout);
    Connect(ID_FILESCANIMAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnFileScanImage);
    Connect(ID_FILEOPEN_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnFileOpen);
    Connect(ID_FILESAVEAS_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnFileSaveAs);
    Connect(ID_FILEPRINT_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnFilePrint);
    Connect(ID_PDFBEGINPDF_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnPdfBeginPdf);
    Connect(ID_PDFADDPAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnPdfAddPage);
    Connect(ID_PDFSAVEASPDF_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnPdfSavePdf);
    Connect(ID_DOCUMENTFIRSTPAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentFirstPage);
    Connect(ID_DOCUMENTPREVIOUSPAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentPreviousPage);
    Connect(ID_DOCUMENTNEXTPAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentNextPage);
    Connect(ID_DOCUMENTLASTPAGE_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentLastPage);
    Connect(ID_DOCUMENTREADTEXT_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnDocumentReadText);
    Connect(ID_CMDSTOP_TB,wxEVT_COMMAND_TOOL_CLICKED,(wxObjectEventFunction)&wxIScanFrame::OnCmdStop);
    Connect(wxID_ANY,wxEVT_CLOSE_WINDOW,(wxObjectEventFunction)&wxIScanFrame::OnClose);
    //*)

    // Custom tool bar icons.
    GetToolBar()->SetToolNormalBitmap( ID_CMDSTOP_TB,              wxBitmap( cmdstop_xpm              ) );
    GetToolBar()->SetToolNormalBitmap( ID_DOCUMENTREADTEXT_TB,     wxBitmap( documentreadtext_xpm     ) );
    GetToolBar()->SetToolNormalBitmap( ID_DOCUMENTFIRSTPAGE_TB,    wxBitmap( documentfirstpage_xpm    ) );
    GetToolBar()->SetToolNormalBitmap( ID_DOCUMENTPREVIOUSPAGE_TB, wxBitmap( documentpreviouspage_xpm ) );
    GetToolBar()->SetToolNormalBitmap( ID_DOCUMENTNEXTPAGE_TB,     wxBitmap( documentnextpage_xpm     ) );
    GetToolBar()->SetToolNormalBitmap( ID_DOCUMENTLASTPAGE_TB,     wxBitmap( documentlastpage_xpm     ) );
    GetToolBar()->SetToolNormalBitmap( ID_FILESCANIMAGE_TB,        wxBitmap( filescanimagebmp_xpm     ) );

    // Insert a text editor control to switch to a given page.
    m_poTextCtrlPage= new wxTextCtrl( GetToolBar(), ID_TEXTCTRLPAGE,
                                      wxEmptyString, wxDefaultPosition,
                                      wxSize( GetToolBar()->IsVertical() ? 22 : 44, -1 ),
                                      wxTE_PROCESS_ENTER,
                                      m_oTextValidatorTextCtrlPage );
    GetToolBar()->InsertControl( 12, m_poTextCtrlPage );
    GetToolBar()->SetToolShortHelp( ID_TEXTCTRLPAGE, _( "Current page" ) );

#if __WXSCANSANE__
    // Insert a wxChoice object to change the scanning device in the toolbar.
    m_poChoiceScanner= new wxChoice( GetToolBar(), ID_CHOICESCANNER,
                                     wxDefaultPosition,
                                     wxSize( GetToolBar()->IsVertical() ? 22 : 150, -1 ) );
    GetToolBar()->InsertControl( 1, m_poChoiceScanner );
    GetToolBar()->SetToolShortHelp( ID_CHOICESCANNER, _( "Select a scanner" ) );
#endif // __WXSCANSANE__

    // Validate the toolbar.
    GetToolBar()->Realize();

    // Custom splitter window (sash) configuration.
    m_poHSplitterWindow->SetSashGravity( 1.0 );
    m_poVSplitterWindow->SetSashGravity( 1.0 );

//    // Custom key accelerators.
//    wxAcceleratorEntry aoAcceleratorEntries[1];
//    aoAcceleratorEntries[0].Set( wxACCEL_NORMAL, 'a', ID_CMDSTOP_TB );
//    wxAcceleratorTable oAcceleratorTable( WXSIZEOF( aoAcceleratorEntries ),
//                                          aoAcceleratorEntries );
//    SetAcceleratorTable( oAcceleratorTable );

    // Custom Initializations:
    //
    m_poCanvas->SetOptions(   wxIViewCanvas::wxICANVAS_MOUSE_SCROLL
                            | wxIViewCanvas::wxICANVAS_MOUSEWHEEL_SCROLL
                            | wxIViewCanvas::wxICANVAS_MOUSE_SELECTION );

    // Reset the image count, the page number and the image filename.
    ResetFileName();

#if defined( __WXPDFDOC__ ) && __WXPDFDOC__ >= 1
    // Initialize a new pdf document object.
    if( !CreateNewPdfDocument() )
    {
        wxLogFatalError( _( "Failed to create wxPdfDocument object." ) );
    }
#endif

    // Complete status bar information.
    SetStatusText( cstrStatusCopyRight, 3 );

    // Give the window an icon.
    SetIcon( wxiscanico_xpm );

    // Restore (most) settings.
    RestoreSettings();

    // Restore some additional settings (which should not be initialized twice).
    wxConfigBase *poConfig = wxConfigBase::Get();
    poConfig->SetRecordDefaults();
    poConfig->SetPath( wxT( "/" )  );
    poConfig->SetPath( cstrwxFrame );

    // Set style attributes to log text control:
    //
    // Read the font size from config file, ...
    int nFontSize= poConfig->Read( wxT( "FontSize" ), 8 );

    // ... get default text style parameters, and ...
    wxTextAttr oStyle( m_poLogTextCtrl->GetDefaultStyle() );

    // ... set some styling options (e. g. font).
    wxFont oFont( nFontSize, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL );

    oStyle.SetFont( oFont );
    m_poLogTextCtrl->SetDefaultStyle( oStyle );

    // Redirect logging to text control.
    int nMaxLogLevel= poConfig->Read( wxT( "MaxLogLevel" ), 2 );
    new wxChainLogTextCtrl( m_poLogTextCtrl, nMaxLogLevel );

    // Output a program version info to the log.
    wxLogMessage( wxT( "%s %s" ), cstrAppName.c_str(), cstrVersionString.c_str() );
    wxLogMessage( wxT( "----------------------------------------------------------" ) );

    // Restore profile settings.
    int nProfileIndex= poConfig->Read( wxT( "ProfileIndex" ), (long)0 );

    for( int i= 0; i < 999; i++ )
    {
        wxString strMenuItemText;
        wxString strProfileConfigPath= wxString::Format( wxT( "/Profile/%d" ), i );

        if( !poConfig->Exists( strProfileConfigPath ) )
        {
            break;
        }

        poConfig->SetPath( strProfileConfigPath );

        wxString strProfileName= poConfig->Read( wxT( "ProfileName" ), wxString::Format( wxT( "%d" ), i ) );

        if( i <= 9 )
        {
            strMenuItemText= wxString::Format( wxT( "&%d " ), i ) + strProfileName + wxString::Format( wxT( "\tCtrl+%d" ), i );
        }
        else
        {
            strMenuItemText= wxString::Format( wxT( "%d " ), i ) + strProfileName;
        }

        int nMenuID= ID_DOCUMENTPROFILE0 + i;

        poMenuDocumentProfiles->AppendCheckItem( nMenuID, strMenuItemText );
        Connect( nMenuID, wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxIScanFrame::OnDocumentProfilesChooseProfile );
    }
    SetProfile( nProfileIndex );

#if __WXLUASCRIPT__
    GetMenuBar()->Insert( wxISCAN_SCRIPTMENUPOS, new wxMenu, _( "&Scripts" ) );

    // Restore scripting settings.
    m_nLuaCount= 0;
    for( int i= 0; i < 999; i++ )
    {
        if( !poConfig->Exists( wxString::Format( wxT( "/Script/%d" ), i ) ) )
        {
            break;
        }

        // Switch to the scripting sub section.
        poConfig->SetPath( wxString::Format( wxT( "/Script/%d" ), i ) );

        // Get the string for the menu entry and its help string.
        wxString strMenuItemText= poConfig->Read( wxT( "MenuEntry" ), wxString::Format( wxT( "Script%d" ), i ) );
        wxString strMenuItemHelpText= poConfig->Read( wxT( "MenuEntryHelp" ), wxEmptyString );

        // Get the menu from config file where the new menu entry should appear, ...
        wxString strMenuPosition= poConfig->Read( wxT( "MenuPosition" ), wxT( "&Scripts" ) );

        // ... get its position number in the menu bar, ...
        int nMenuPos= GetMenuBar()->FindMenu( ::wxGetTranslation( strMenuPosition ) );

        // ... check its existence, ...
        if( nMenuPos == wxNOT_FOUND )
        {
            wxLogError( _( "Cannot find menu '%s'. "
                             "The according script will not be reachable by menu entry '%s'." ),
                          strMenuPosition.c_str(),
                          strMenuItemText.c_str()
                        );
            break;
        }

        // ... gets the position of the menu item after it, and ..
        int nMenuItem= poConfig->Read( wxT( "MenuItem" ), 0L );

        // ... gets its menu ID.
        int nMenuID= ID_DOCUMENTPROFILE0 + 1000 + i;

        // Create the menu entry and connect its ID to the scripting event handler.
        GetMenuBar()->GetMenu( nMenuPos )->Insert( nMenuItem, nMenuID, strMenuItemText, strMenuItemHelpText );
        Connect( nMenuID, wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxIScanFrame::OnScriptStartScript );

        // Adjust script number counter.
        m_nLuaCount++;
    }
#endif // __WXLUASCRIPT__

    // Reset file history.
    poConfig->SetPath( wxT( "/Files" ) );
    m_oFileHistory.Load( *poConfig );

    // Delete file history entries of files that do not exist.
    for( int i= m_oFileHistory.GetCount() - 1; i >= 0; i-- )
    {
        wxString strFileName= m_oFileHistory.GetHistoryFile( i );

        if( !::wxFileExists( strFileName ) )
        {
            m_oFileHistory.RemoveFileFromHistory( i );
        }
    }

    // Add file history to the 'files' menu.
    m_oFileHistory.AddFilesToMenu( poMenuFile );
    m_oFileHistory.UseMenu( poMenuFile );

    // Set drop target.
    SetDropTarget( new wxExtFileDropTarget( this ) );

#if __WXSCANSANE__
    // Scan for scanning devices and create a scanner object.
    //
    // Note: A new wxScan object is created and EnableControls() called
    //       implicidly in an independent thread by ScanForScanners().
    //       So we don't have to do it here again.
    ScanForScanners( true );
#else
    // Create a scanner object.
    m_poScanner= new wxScan;

    // Switch (mostly disable) controls.
    EnableControls();
#endif // __WXSCANSANE__
}

// Destructor.
//
wxIScanFrame::~wxIScanFrame()
{
    // Destroy an existing scanner object.
    if( m_poScanner )
    {
        delete m_poScanner;
        m_poScanner= NULL;
    }

    // Terminate a possibly running concurrent process.
    if( m_poRunningProcess )
    {
        m_poRunningProcess->Kill( wxSIGTERM, wxKILL_CHILDREN );
        delete m_poRunningProcess;
        m_poRunningProcess= NULL;
    }

#if __WXPDFDOC__
    // Destroy pending PDF documents.
    if( m_poPdfDoc )
    {
        delete m_poPdfDoc;
        m_poPdfDoc= NULL;
    }
#endif // __WXPDFDOC__

    // Save configuration data.
    SaveSettings();

    //(*Destroy(wxIScanFrame)
    //*)

    // Save the log to a text file.
    if( m_poLogTextCtrl )
    {
        wxFileName oFileName( wxStandardPaths::Get().GetDocumentsDir(), ::wxGetApp().GetAppName(), wxT( "log" ) );

        m_poLogTextCtrl->SaveFile( oFileName.GetFullPath() );
    }
}

// Event handlers.
//
/// \brief Handle window closing requests.
//
void wxIScanFrame::OnClose( wxCloseEvent& oEvent )
{
    // Check if the content is "dirty" and veto closing
    // (if it is not forbidden).
    if( CanClose( oEvent.CanVeto() ) )
    {
        this->Destroy();
    }
    else
    {
        if( oEvent.CanVeto() )
        {
            oEvent.Veto();
        }
        else
        {
            this->Destroy();
        }
    }
}

// Handle file dropping events (by opening the given file name).
//
void wxIScanFrame::OnFileDrop( wxExtFileDropEvent &oEvent )
{
    // Open file.
    OpenImage( oEvent.GetFileName() );
}

/// \brief Handle menu command "File|Scan image".
//
void wxIScanFrame::OnFileScanImage( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Scan image.
#if __WXLUASCRIPT__
    bLuaReturnFromEventHandler= ScanImage();
#else
    ScanImage();
#endif // __WXLUASCRIPT__

    // Enable (additional) menu options after the 1st scan.
    EnableControls();
}

/// \brief Handle menu command "File|Open...".
//
void wxIScanFrame::OnFileOpen( wxCommandEvent& oEvent )
{
    // Open an "Open file" dialog an let the user choose a filename.
    wxFileDialog oDlg( this,
                       _( "Open file" ),
                       wxT( "" ),
                       wxT( "" ),
                       ::wxGetApp().GetImageFilter(),
#if wxCHECK_VERSION( 2, 9, 0 )
                       wxFD_OPEN | wxFD_FILE_MUST_EXIST | wxFD_CHANGE_DIR );
#else
                       wxOPEN | wxFILE_MUST_EXIST | wxCHANGE_DIR );
#endif // wxCHECK_VERSION

    if( oDlg.ShowModal() == wxID_OK )
    {
        // Open file.
        OpenImage( oDlg.GetPath() );
    }
}

/// \brief Handle menu command "File|Save as...".
//
void wxIScanFrame::OnFileSaveAs( wxCommandEvent& oEvent )
{
    // Open a "Save file" dialog and let the user choose a filename.
    wxFileDialog oDlg( this,
                       _( "Save as" ),
                       wxT( "" ),
                       m_strImageFileName,
                       ::wxGetApp().GetImageFilter(),
#if wxCHECK_VERSION( 2, 9, 0 )
                       wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR );
#else
                       wxSAVE | wxOVERWRITE_PROMPT | wxCHANGE_DIR );
#endif // wxCHECK_VERSION

    if( oDlg.ShowModal() == wxID_OK )
    {
        // Show hourglass cursor.
        wxBusyCursor oWait;

        // Save file.
        if( !GetImageSelection().SaveFile( oDlg.GetPath() ) )
        {
            // On error warn the user.
            wxLogError( wxT( "Image cannot be written to file '%s'." ), oDlg.GetPath().c_str() );
            return;
        }

        // Save the filename.
        m_strImageFileName= oDlg.GetPath();
        SetTitle( m_strImageFileName + wxT( " - " ) + cstrAppName );
    }
}

/// \brief Handle menu command "File|Print".
//
void wxIScanFrame::OnFilePrint( wxCommandEvent& oEvent )
{
    // ...
    AdjustOrientation();

    // Data object representing the print dialog's values.
    wxPrintDialogData oPrintDialogData( m_oPrintData );

    // Set the printer dialog's maximal page.
    oPrintDialogData.SetMaxPage( m_nImageCount );

    // Printer object.
    wxPrinter oPrinter( &oPrintDialogData );

    // ...
    wxIViewPrintout oPrintout( this, m_strImageFileName, false, m_nResolution, m_nResolution );

    // Create cancel dialog.
    oPrinter.CreateAbortWindow( this, &oPrintout );

    // Print.
    if( oPrinter.Print( this, &oPrintout, true ) )
    {
        m_oPrintData= oPrinter.GetPrintDialogData().GetPrintData();
    }
    else
    {
        if( wxPrinter::GetLastError() == wxPRINTER_ERROR )
        {
            wxLogError( _( "An error occured while printing." ) );
#if __WXLUASCRIPT__
            // Signal error to Lua.
            bLuaReturnFromEventHandler= false;
#endif // __WXLUASCRIPT__
        }
    }

    // Destroy the print image (for to release MBs of memory).
    m_oPrintImage.Destroy();
}

/// \brief Handle menu command "File|Print Preview".
//
void wxIScanFrame::OnFilePrintPreview( wxCommandEvent& oEvent )
{
    // ...
    AdjustOrientation();

    // Data object representing the print dialog's values.
    wxPrintDialogData oPrintDialogData( m_oPrintData );

    // Pass two printout objects: for preview, and possible printing.
    wxPrintPreview *poPreview = new wxPrintPreview(
        new wxIViewPrintout( this, m_strImageFileName, false, m_nResolution, m_nResolution ),
        new wxIViewPrintout( this, m_strImageFileName, false, m_nResolution, m_nResolution ),
        &oPrintDialogData );

    if ( !poPreview || !poPreview->Ok() )
    {
        if( poPreview )
        {
            delete poPreview;
        }
        wxLogError( _( "An error occured while creating print preview object.") );
        return;
    }

    // Set the zoom factor to 100%.
    poPreview->SetZoom( 100 );

    int x, y, w, h;

    // Get the frame window position and size and create a print preview
    // window with the same postion and size.
    GetSize( &w, &h );
    GetPosition( &x, &y );
    wxIViewPreviewFrame *poPreviewFrame= new wxIViewPreviewFrame(
                                          poPreview,
                                          this,
                                          _( "Print Preview" ),
                                          wxPoint( x, y ),
                                          wxSize( w, h ) );
    if( !poPreviewFrame )
    {
        delete poPreview;
        wxLogError( _( "An error occured while creating print preview window.") );
        return;
    }
    poPreviewFrame->Initialize();
    poPreviewFrame->Show();

    // Destory the print image (for to save MBs memory).
    m_oPrintImage.Destroy();
}

/// \brief Handle menu command "File|Page Setup ".
//
void wxIScanFrame::OnFilePrintSetup( wxCommandEvent& oEvent )
{
    // ...
    AdjustOrientation();

    wxPageSetupDialogData oPageSetupData( m_oPrintData );

    oPageSetupData.EnableOrientation( false );

    wxPageSetupDialog oPageSetupDialog( this, &oPageSetupData );

    if( oPageSetupDialog.ShowModal() == wxID_OK )
    {
        m_oPrintData= oPageSetupDialog.GetPageSetupData().GetPrintData();
    }
}

/// \brief Handle menu command "File|Quit".
//
void wxIScanFrame::OnFileQuit( wxCommandEvent& oEvent )
{
    Close();
}

// Handle menu command "File|[MOST RECENTLY USED FILE #X]".
//
void wxIScanFrame::OnMRUFiles( wxCommandEvent &oEvent )
{
    // Get the filename from history menu index, ...
    int nId= oEvent.GetId() - wxID_FILE1;
    wxString strFilename = m_oFileHistory.GetHistoryFile( nId );

    // ... check if it is valid, and reopen the image file.
    if( strFilename.IsEmpty() || !::wxFileExists( strFilename ) || !OpenImage( strFilename ) )
    {
        // Otherwise remove the file from the file name history, ...
        m_oFileHistory.RemoveFileFromHistory( nId );

        // and signal an error.
        wxLogError( wxString::Format( _( "File '%s' does not exist (any more) or cannot be opened." ),
                                        strFilename.c_str() ) );
    }
}

/// \brief Begin an new (empty) PDF document.
//
void wxIScanFrame::OnPdfBeginPdf( wxCommandEvent& oEvent )
{
#if defined( __WXPDFDOC__ ) && __WXPDFDOC__ >= 1
    if( !CanClose() )
    {
        return;
    }

    if( !CreateNewPdfDocument() )
    {
        return;
    }

    // Remove all thumbs from the the pages panel.
    m_poPanelPages->Reset();

    // Enable (additional) menu options.
    EnableControls();
#else
    wxLogError( _( "PDF support is not enabled." ) );
#endif
}

/// \brief Add the current image as a new page to the current PDF
///        document.
//
void wxIScanFrame::OnPdfAddPage( wxCommandEvent& oEvent )
{
#if defined( __WXPDFDOC__ ) && __WXPDFDOC__ >= 1
    bool bAddAllPages= false;

    // On multipage images ask for permission to add all pages.
    if( ( m_nImageCount > 1 ) && ( m_nPage == 0 ) )
    {

        switch( ::wxMessageBox( _( "This is a multipage image. Do you want to "
                                   "add all image pages to the PDF file?" ),
                                ::wxGetApp().GetAppName(),
                                wxYES_DEFAULT | wxYES_NO | wxCANCEL | wxICON_QUESTION  ) )
        {
            case wxYES    : bAddAllPages= true;
                            break;
            case wxCANCEL : return;
        }
    }

    // Show busy cursor (until the automatic variable is destroyed).
    wxBusyCursor oWait;

    // Apply a profile automatically after loading a page from a
    // multi page file.
    if( bAddAllPages and m_bAutoApplyProfileOnMultiPage )
    {
        ApplyProfile();
    }

    // Add page to PDF document.
    AddPdfPage();

    // Add the following pages (if wished).
    if( bAddAllPages )
    {
        while( m_nPage < ( m_nImageCount - 1 ) )
        {
            // Load next image page.
            OnDocumentNextPage( oEvent );

            // Optionally apply a profile automatically after loading
            // a page from a multi page file.
            if( m_bAutoApplyProfileOnMultiPage )
            {
                ApplyProfile();
            }

            // Add page to PDF document.
            AddPdfPage();
        }
    }

    // Enable (additional) menu options.
    EnableControls();
#else
    wxLogError( _( "PDF support is not enabled." ) );
#endif
}

/// \brief Save the current PDF document as a PDF file.
//
void wxIScanFrame::OnPdfSavePdf( wxCommandEvent& oEvent )
{
#if defined( __WXPDFDOC__ ) && __WXPDFDOC__ >= 1
    if( !m_poPdfDoc )
    {
        wxLogError( _( "wxPdfDocument is NULL" ) );
        return;
    }

    // Open a "Save file" dialog and let the user choose a filename.
    wxFileDialog oDlg( this,
                       _( "Save as" ),
                       wxT( "" ),
                       _( "unknown.pdf" ),
                       _( "PDF file" ) + wxString( wxT( " (*.pdf)|*.pdf|" ) )
                       + _( "All files" ) + wxString( wxT( "|*.*" ) ),
#if wxCHECK_VERSION( 2, 9, 0 )
                       wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR );
#else
                       wxSAVE | wxOVERWRITE_PROMPT | wxCHANGE_DIR );
#endif // wxCHECK_VERSION( 2, 9, 0 )

    if( oDlg.ShowModal() == wxID_OK )
    {
        // Show busy cursor (until the automatic variable is destroyed).
        wxBusyCursor oWait;

        // Save file.
        //
        // NOTE: At the moment there is no error checking on writing the
        //       PDF file. Does anyone know a (real) workaround?
        m_poPdfDoc->SaveAsFile( oDlg.GetPath() );

        // Mark PDF document as 'clean'.
        m_bPdfDirty= false;

        // Create a new PDF document.
        OnPdfBeginPdf( oEvent );
    }
#else
    wxLogError( _( "PDF support is not enabled." ) );
#endif
}

/// \brief Copy the (selected part of the) image to the system
///        clipboard.
//
void wxIScanFrame::OnEditCopy( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Copy the (selected part of the) image to the system clipboard.
    ::CopyImage2Clipboard( GetImageSelection() );
}

/// \brief Replace the image by the content of the system clipboard.
//
void wxIScanFrame::OnEditPaste( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    wxBitmapDataObject oBitmapData;

    // Open the clipboard.
    //
    // Note: There is a global object ::wxTheClipboard.
    //
    if( !wxTheClipboard->Open() )
    {
        wxLogError( wxString( wxT( "wxIScanFrame::CopyImage2Clipboard -- " ) )
              + _( "Failed to open clipboard." ) );
    }

    // If there is bitmap data in the clipboard get it.
    if( wxTheClipboard->GetData( oBitmapData ) )
    {
        // Get the image from the bitmap data in the clipboard.
        wxBitmap oBitmap= oBitmapData.GetBitmap();

        m_oImage= oBitmap.ConvertToImage();
        UpdateBitmap();

        // Enable/disable menu options according to the actual state.
        EnableControls();
    }

    // Close the clipboard.
    wxTheClipboard->Close();

    // Reset the filename.
    ResetFileName();
}

/// \brief Edit program settings (using an wxOptionsDialog window).
//
void wxIScanFrame::OnEditSettings( wxCommandEvent& oEvent )
{
    // Get the global configuration object.
    wxConfigBase *poConfig = wxConfigBase::Get();
    poConfig->SetPath( wxT( "/Global" ) );

    // Get internationalization state flag directly from configuration.
    bool bI18n= (bool)poConfig->Read( wxT( "I18n" ), (long)true );

    // Get splashscreen state flag directly from configuration.
    bool bSplashscreen= (bool)poConfig->Read( wxT( "Splashscreen" ), (long)true );

    // Create, setup and display the options dialog (as a modal dialog).
#if __NOTYETRELEASED__ >= 2
    wxOptionsBookDialog oDialog( this, wxT( "Common" ) );
#else // __NOTYETRELEASED__
    wxOptionsDialog oDialog( this );
#endif // __NOTYETRELEASED__

    // Create, setup and display the options dialog (as a modal dialog).
    oDialog.AppendOption( new wxOptionCheckBox( _( "Use internationalization on next program start." ), &bI18n ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Show splashscreen at program startup." ), &bSplashscreen ) );
#if __WXLUASCRIPT__
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable Lua scripting." ), &m_bLua ) );
#endif // __WXLUASCRIPT__
    oDialog.AppendOption( new wxOptionCheckBox( _( "Automatically apply profile after scanning." ), &m_bAutoApplyProfile ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Automatically apply profile after loading a page from a multi page file." ), &m_bAutoApplyProfileOnMultiPage ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Mime type of image exported:" ), &m_strBitmapMimeType, 150 ) );
    oDialog.AppendOption( new wxOptionStaticLine );
#if __WXPDFDOC__
    oDialog.AppendOption( new wxOptionCheckBox( _( "Use OCR when adding text to a PDF page." ), &m_bOCR ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Mime type of image exported to a PDF page:" ), &m_strPdfBitmapMimeType, 150 ) );
    oDialog.AppendOption( new wxOptionStaticLine );
#endif // __WXPDFDOC__
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable OCR command." ), &m_bCmdOcrEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "OCR command:" ), &m_strCmdOcr ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Output extension of the extracted text:" ), &m_strOcrOutputExtension, 150 ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable hOCR processing." ), &m_bHocrEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "OCR command to create hOCR output:" ), &m_strCmdOcrUseHocr ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Output extension of the hOCR output file:" ), &m_strOcrOutputExtensionHocr, 150 ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "hOCR class in HOCR file to extract:" ), &m_strHocrClass, 150 ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Use smart hOCR processing." ), &m_bSmartHocrEnable ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable HTML to XHTML conversion." ), &m_bCmdHtml2XhtmlEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "HTML to XHTML conversion command:" ), &m_strCmdHtml2Xhtml ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable image convertion command." ), &m_bCmdConvertEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Bitmap conversion command:" ), &m_strCmdConvert ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable clean up command." ), &m_bCmdCleanUpEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Clean up command:" ), &m_strCmdCleanUp ) );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable additional clean up after hOCR processing." ), &m_bCmdHocrCleanUpEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Additional clean up command after hOCR processing:" ), &m_strCmdHocrCleanUp ) );
    oDialog.AppendOption( new wxOptionStaticLine );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable TTS command." ), &m_bCmdTtsEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "TTS command:" ), &m_strCmdTts, 500 ) );
    oDialog.AppendOption( new wxOptionStaticLine );
    oDialog.AppendOption( new wxOptionCheckBox( _( "Enable editor command." ), &m_bCmdEditEnable ) );
    oDialog.AppendOption( new wxOptionComboBox( _( "Editor command:" ), &m_strCmdEdit ) );
    // ... (Add another options.)

    oDialog.SetupDialog();

    if( oDialog.ShowModal() == wxID_OK )
    {
        // Get the global configuration object and set the config path.
        //
        // NOTE: We do this because wxConfigBase::Get() returns a global object
        //       that could have been changed by the option dialog itself.
        //
        poConfig= wxConfigBase::Get();
        poConfig->SetPath( wxT( "/Global" ) );

        // Set i18n flag state directly in configuration (file or registry).
        poConfig->Write( wxT( "I18n" ), (long)bI18n );

        // Set splashscreen flag state directly in configuration (file or registry).
        poConfig->Write( wxT( "Splashscreen" ), (long)bSplashscreen );

        // ... (Handle another options.)

        // Adjust control states.
        EnableControls();
    }
}

/// \brief Start the configured editor to edit the configuration file.
//
void wxIScanFrame::OnEditSettingsFile( wxCommandEvent& oEvent )
{
    // Save programme settings.
    SaveSettings();

    // Open settings editor.
    wxFileConfig *poConfig = (wxFileConfig *)wxConfigBase::Get();
    wxString strConfigFilename= wxFileConfig::GetLocalFileName( poConfig->GetAppName() );
    wxString strCommand= wxString::Format( m_strCmdEdit, strConfigFilename.c_str() );

#if __DEBUG__
    wxLogMessage( wxT( "wxIScanFrame::OnEditSettings - strCommand == '%s'" ), strCommand.c_str() );
#endif
    Execute( strCommand );

    // Restore settings (from file).
    RestoreSettings();
}

/// \brief Scan for scanning devices and fill the corresponding
///        wxChoice control in the toolbar.
//
void wxIScanFrame::OnEditScanScanners(wxCommandEvent& event)
{
#ifdef __WXSCANSANE__
    // Scan for scanning devices.
    ScanForScanners( true );
#endif // __WXSCANSANE__
}

/// \brief Wipe out the log window.
//
void wxIScanFrame::OnEditClearLog( wxCommandEvent& oEvent )
{
    m_poLogTextCtrl->Clear();
}

/// \brief Wipe out the file name history (under file menu).
//
void wxIScanFrame::OnEditClearHistory( wxCommandEvent& oEvent )
{
    // Delete file history entries.
    for( int i= m_oFileHistory.GetCount() - 1; i >= 0; i-- )
    {
        m_oFileHistory.RemoveFileFromHistory( i );
    }
}

/// \brief Do OCR on the loaded/scanned image and copy the text
///        to the system clipboard.
//
void wxIScanFrame::OnDocumentCopyText( wxCommandEvent& oEvent )
{
    // Save image in a temporary JPEG file.
    wxString strTempFileName= wxFileName::CreateTempFileName( wxT( "" ) );

    GetImageSelection().SaveFile( strTempFileName, m_strBitmapMimeType );

    // Do OCR (and get the file name of the generated text file).
    wxString strOcrTextFileName= OCR( strTempFileName );

    // Remove the temporary JPEG file.
    ::wxRemoveFile( strTempFileName );

    // Get the text and copy it to the clipboard.
    if( !strOcrTextFileName.IsEmpty() )
    {
        // Copy text (from text file) to clipboard.
        ::CopyText2Clipboard( ::GetTextFromFile( strOcrTextFileName ) );

        // Remove the temporary text file
        ::wxRemoveFile( strOcrTextFileName );
    }
#if __WXLUASCRIPT__
    else
    {
        // Signal error to Lua.
        bLuaReturnFromEventHandler= false;
    }
#endif // __WXLUASCRIPT__
}

/// \brief Do OCR on the loaded/scanned image and read the text
///        out loud.
//
void wxIScanFrame::OnDocumentReadText( wxCommandEvent& oEvent )
{
#if __WXLUASCRIPT__
    bLuaReturnFromEventHandler= ReadOut( oEvent.GetId() != ID_DOCUMENTREADTEXTSYNC );
#else
    ReadOut();
#endif // __WXLUASCRIPT__

    // Enable/disable menu options according to the actual state.
    EnableControls();
}

/// \brief Go to first page of a multipage document.
//
void wxIScanFrame::OnDocumentFirstPage( wxCommandEvent& oEvent )
{
    m_nPage= 0;
    OnDocumentPageChanged();
}

/// \brief Go to previous page of a multipage document.
//
void wxIScanFrame::OnDocumentPreviousPage( wxCommandEvent& oEvent )
{
    if( m_nPage > 0 )
    {
        m_nPage--;
        OnDocumentPageChanged();
    }
#if __WXLUASCRIPT__
    else
    {
            // Signal error to Lua.
            bLuaReturnFromEventHandler= false;
    }
#endif // __WXLUASCRIPT__
}

/// \brief Go to next page of a multipage document.
//
void wxIScanFrame::OnDocumentNextPage( wxCommandEvent& oEvent )
{
    if( m_nPage < ( m_nImageCount - 1 ) )
    {
        m_nPage++;
        OnDocumentPageChanged();
    }
#if __WXLUASCRIPT__
    else
    {
            // Signal error to Lua.
            bLuaReturnFromEventHandler= false;
    }
#endif // __WXLUASCRIPT__
}

/// \brief Go to last page of a multipage document.
//
void wxIScanFrame::OnDocumentLastPage( wxCommandEvent& oEvent )
{
    m_nPage= m_nImageCount - 1;
    OnDocumentPageChanged();
}

/// \brief Crop the image to the selected rectangle.
//
void wxIScanFrame::OnDocumentCrop( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Get the selected subimage.
    m_oImage= GetImageSelection();

    // Replace the image by the selected subimage.
    UpdateBitmap();

    // Set the file name to unknown (because the main image changed).
    ResetFileName();

    // Enable/disable menu options according to the actual state.
    EnableControls();
}

/// \brief Zoom the image to the selected rectangle to fit the
///        canvas size.
//
void wxIScanFrame::OnDocumentZoom( wxCommandEvent& oEvent )
{
    // If there is nothing selected there is nothing to do at all.
    if( !m_poCanvas->IsSelected() )
    {
        // So just return.
        return;
    }

    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Calculate the new zoom factor.
    wxRect oSelection= m_poCanvas->GetSelection();
    wxSize oWindowSize= m_poCanvas->GetClientSize();
    double nScaleFactorX= (double)oWindowSize.GetWidth()  / (double)oSelection.GetWidth();
    double nScaleFactorY= (double)oWindowSize.GetHeight() / (double)oSelection.GetHeight();
    double nScaleFactor= ( nScaleFactorX < nScaleFactorY ) ? nScaleFactorX : nScaleFactorY;

    // Scale old zoom factor by the new one.
    m_nScaleFactor *= nScaleFactor;

    // Set zooming to fixed size.
    m_nFit= wxCANVASCUSTOMSIZE;

    // Rezoom the image.
    UpdateBitmap();

    // Scroll left upper corner of selection to the beginning of
    // the visuable part of the canvas.
    int nXUnit, nYUnit;
    m_poCanvas->GetScrollPixelsPerUnit( &nXUnit, &nYUnit );
    m_poCanvas->Scroll( (double)oSelection.GetX() * nScaleFactor / (double)nXUnit,
                        (double)oSelection.GetY() * nScaleFactor / (double)nYUnit );

    // Enable/disable menu options according to the actual state.
    EnableControls();
}

/// \brief Rotate image by 90° to the left.
//
void wxIScanFrame::OnDocumentRotate90Left( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Rotate image and change image orientation.
    m_oImage= m_oImage.Rotate90( false );
    UpdateBitmap();
}

/// \brief Rotate image by 90° to the right.
//
void wxIScanFrame::OnDocumentRotate90Right( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Rotate image and change image orientation.
    m_oImage= m_oImage.Rotate90( true );
    UpdateBitmap();
}

/// \brief Apply a previously selected profile to the image.
//
void wxIScanFrame::OnDocumentApplyProfile( wxCommandEvent& oEvent )
{
    // Apply an image profile (crop, convert to monochrome etc.), and ...
    ApplyProfile();

    // ... reset the image on the canvas window.
    UpdateBitmap();
}

/// \brief Select a profile from the corresponding sub menu.
//
void wxIScanFrame::OnDocumentProfilesChooseProfile( wxCommandEvent& oEvent )
{
    SetProfile( oEvent.GetId() - ID_DOCUMENTPROFILE0 );
}

/// \brief Select an image fitting option.
//
void wxIScanFrame::OnViewFit( wxCommandEvent& oEvent )
{
    // Save the old fitting state and the old scalation
    // factor (for optimizing see below).
    int nFitOld= m_nFit;
    double nScaleFactorOld= m_nScaleFactor;

    // Transform the given event into an option value.
    if( oEvent.GetId() == ID_VIEWFITWIDTH )
    {
        m_nFit= wxCANVASFITWIDTH;
    }
    else if( oEvent.GetId() == ID_VIEWFITWINDOW )
    {
        m_nFit= wxCANVASFITWINDOW;
    }
    else if( oEvent.GetId() == ID_VIEWFULLSIZE )
    {
        m_nFit= wxCANVASFULLSIZE;
    }
    else if( oEvent.GetId() == ID_VIEWCUSTOMSIZE )
    {
        m_nFit= wxCANVASCUSTOMSIZE;
    }
    else if( oEvent.GetId() == ID_VIEWZOOMIN )
    {
        m_nFit= wxCANVASCUSTOMSIZE;
        m_nScaleFactor *= ( 1.0 + m_nZoomFactor );
    }
    else if( oEvent.GetId() == ID_VIEWZOOMOUT )
    {
        m_nFit= wxCANVASCUSTOMSIZE;
        m_nScaleFactor /= ( 1.0 + m_nZoomFactor );
    }

    // Optimization: If the fitting state and the scalation
    // factor hasn't changed just do nothing.
    if( ( nFitOld != m_nFit ) || ( nScaleFactorOld != m_nScaleFactor ) )
    {
        // Otherwise (re)zoom the image.
        UpdateBitmap();
    }

    // Enable/disable menu options according to the actual state.
    EnableControls();
}

/// \brief Toggle full screen mode.
//
void wxIScanFrame::OnViewFullScreen( wxCommandEvent& oEvent )
{
    // Toggle full screen mode.
    ToggleFullScreen();
}

/// \brief Close the debug window.
//
void wxIScanFrame::OnViewCloseDebugWindow( wxCommandEvent& oEvent )
{
    // Close the debug window by moving the the sash downwards.
    m_poHSplitterWindow->SetSashPosition( -1 );
}

/// \brief Close the preview panel window.
//
void wxIScanFrame::OnViewClosePreviewPanel( wxCommandEvent& oEvent )
{
    // Close the preview panel window by moving the the sash right.
    m_poVSplitterWindow->SetSashPosition( -1 );
}

#if __WXLUASCRIPT__
// Handle menu command "Scrips|[SCRIPT NAME]".
//
void wxIScanFrame::OnScriptStartScript( wxCommandEvent& oEvent )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Let the system do the showing the hourglass cursor.
    ::wxSafeYield();

    // Get the script index, ...
    int nIndex= oEvent.GetId() - ( ID_DOCUMENTPROFILE0 + 1000 );

    // ... and get the filename and the start up ("main") function.
    wxConfigBase *poConfig= wxConfigBase::Get();

    poConfig->SetPath( wxString::Format( wxT( "/Script/%d" ), nIndex ) );

    wxString strScriptStartupFunction= poConfig->Read( wxT( "Function" ), wxT( "" ) );
    wxString strScriptFileName= poConfig->Read( wxT( "Script" ), wxT( "" ) );

    if( strScriptStartupFunction.IsEmpty() )
    {
        // Signal error.
        wxLogError( wxString( wxT( "wxIScanFrame::OnScriptStartScript -- " ) )
                      + _( "Script startup function is empty." ) );
        return;
    }
    else
    {
        // Run script
        StartScript( strScriptStartupFunction, strScriptFileName );
    }

    // Enable/disable menu options according to the actual state.
    EnableControls();
}
#endif // __WXLUASCRIPT__

/// \brief Handle (sub-)process killing.
//
void wxIScanFrame::OnCmdStop( wxCommandEvent& oEvent )
{
    // Check if the (sub-)process is running.
    if( m_poRunningProcess )
    {
        // Log process's output.
        LogProcessOutput( m_poRunningProcess );

        // Try to terminate the (sub-)process.
        //
        // NOTE: In case the process is not terminated properly
        //       it is at least detached and released from the
        //       the main process.
        m_poRunningProcess->Kill( wxSIGTERM, wxKILL_CHILDREN );
        m_poRunningProcess->Detach();

        // Mark (sub-)process pointer as "clean".
        m_poRunningProcess= NULL;
   }

   // Enable/disable menu options according to the actual state.
   EnableControls();
}

/// \brief Handle menu command "Help|About...".
//
void wxIScanFrame::OnHelpAbout( wxCommandEvent& oEvent )
{
    // Create an show the program's about box.
    wxIScanAbout oAboutBox( this );

    oAboutBox.ShowModal();
}

// Handle bitmap resizing introduced by canvas resizing.
//
void wxIScanFrame::OnCanvasSize( wxIViewCanvasSizeEvent & WXUNUSED( oEvent ) )
{
    if( ( m_nFit == wxCANVASFITWIDTH ) || ( m_nFit == wxCANVASFITWINDOW ) )
    {
        UpdateBitmap();
    }
}

// Handle canvas selection events.
//
void wxIScanFrame::OnCanvasSelected( wxIViewCanvasSelectedEvent& oEvent )
{
    // Check if the CTRL key was pressed when the selection was finished.
    if( oEvent.m_bCtrl )
    {
        wxCommandEvent oDummyEvent;

        // Zoom the selected rect to fit in the canvas window.
        OnDocumentZoom( oDummyEvent );
    }

    // Check if the ALT key was pressed when the selection was finished.
    else if( oEvent.m_bAlt )
    {
        wxCommandEvent oDummyEvent;

        // Crop the selected rect.
        OnDocumentCrop( oDummyEvent );
    }

#if __NOTYETRELEASED__
    // Check if the SHIFT key was pressed when the selection was finished.
    else if( oEvent.m_bShift )
    {
        // ...
double nHeight= (double)( oEvent.m_oSelection.GetTop() - oEvent.m_oSelection.GetBottom() );//oEvent.m_oSelection.GetHeight();
double nWidth= (double)oEvent.m_oSelection.GetWidth();
double nAngle= asin( nHeight / sqrt( nHeight * nHeight + nWidth * nWidth ) );
m_oImage= ::RotateImage( m_oImage, nAngle );

        // ...
        UpdateBitmap();
    }
#endif // __NOTYETRELEASED__
}

// Handle process termination.
//
void wxIScanFrame::OnProcessTerminated( wxProcessEvent & WXUNUSED( oEvent ) )
{
    if( m_poRunningProcess )
    {
        // Log process's output.
        LogProcessOutput( m_poRunningProcess );

        // Delete the process and set its pointer to NULL.
        delete m_poRunningProcess;
        m_poRunningProcess= NULL;
    }

    // Enable/disable menu options according to the actual state.
    EnableControls();
}

// Handle page number editor field events.
//
void wxIScanFrame::OnTextCtrlPageProcessEnter( wxCommandEvent & WXUNUSED( oEvent ) )
{
    long nNewPage;

    if( m_poTextCtrlPage->GetValue().ToLong( &nNewPage )
        && ( 0 < nNewPage )
        && ( nNewPage <=  m_nImageCount ) )
    {
        m_nPage= nNewPage - 1;
        OnDocumentPageChanged();
    }
}

// Handle window closing requests.
//
bool wxIScanFrame::CanClose( bool bCanVeto )
{
#if __WXPDFDOC__
    if( IsPdfDirty() )
    {
        switch( ::wxMessageBox( _( "The changes to the current PDF document have not yet been saved. "
                                   "Do you want to save the PDF document now?" ),
                                ::wxGetApp().GetAppName(),
                                wxYES_NO | ( bCanVeto ? wxCANCEL : 0 ) | wxICON_QUESTION ) )
        {
            case wxYES: {
                            wxCommandEvent oDummyEvent( wxEVT_COMMAND_MENU_SELECTED, ID_PDFSAVEASPDF );

                            OnPdfSavePdf  ( oDummyEvent );
                        }
                        return !IsPdfDirty();
            case wxNO : return true;
            default:    return false;
        }
    }
    else
    {
        return true;
    }
#else
    return true;
#endif
}

// Helper functions.
//
// Open an image using the given name.
//
bool wxIScanFrame::OpenImage( const wxString &strFileName, bool bSetFileName )
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Save the filename.
    wxFileName oFileName( strFileName );
    oFileName.Normalize();
    wxString strFileNameFullPath= oFileName.GetFullPath();

    // Open file.
    if( !m_oImage.LoadFile( strFileNameFullPath ) )
    {
        // Signal error;
        return false;
    }

    // Set filename to new one (if indicated).
    if( bSetFileName )
    {
        m_strImageFileName= strFileNameFullPath;
        SetTitle( m_strImageFileName + wxT( " - " ) + cstrAppName );
    }

    // Get the image count and reset the page number.
    m_nImageCount= m_oImage.GetImageCount( m_strImageFileName );
    m_nPage= 0;

    // Update the page number info in the statusbar and in the toolbar.
    UpdatePageNumber();

    // Get the image resolution (or use the resolution value of the last
    // acquired/loaded image by not changing the resolution).
    if( m_oImage.HasOption( wxIMAGE_OPTION_RESOLUTION ) )
    {
        m_nResolution= m_oImage.GetOptionInt( wxIMAGE_OPTION_RESOLUTION );
    }
    else if( m_oImage.HasOption( wxIMAGE_OPTION_RESOLUTIONX ) )
    {
        m_nResolution= m_oImage.GetOptionInt( wxIMAGE_OPTION_RESOLUTIONX );
    }
    else if( m_oImage.HasOption( wxIMAGE_OPTION_RESOLUTIONY ) )
    {
        m_nResolution= m_oImage.GetOptionInt( wxIMAGE_OPTION_RESOLUTIONY );
    }

    // Show the image on the canvas window.
    UpdateBitmap();

    // Enable (additional) menu options after the 1st scan.
    EnableControls();

    // Add filename to file history.
    m_oFileHistory.AddFileToHistory( m_strImageFileName );

    // Signal success.
    return true;
}

// (Re)loads the (zero based) page number given in m_nPage.
//
bool wxIScanFrame::OnDocumentPageChanged()
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Load the image by name and page number.
    if( !m_oImage.LoadFile( m_strImageFileName, wxBITMAP_TYPE_ANY, m_nPage ) )
    {
        // Signal error.
        return false;
    }

    // Get the image direction.
//    m_bPortrait= ( m_oImage.GetHeight() > m_oImage.GetWidth() );

    // Update the page number info in the statusbar and in the toolbar.
    UpdatePageNumber();

    // Show the image
    UpdateBitmap();

    // Update the menu and toolbar controls.
    EnableControls();

    // Signal success.
    return true;
}

// Update the canvas bitmap.
//
void wxIScanFrame::UpdateBitmap()
{
    // Some little optimization for empty images.
    if( !m_oImage.IsOk() )
    {
        return;
    }

    // Resize image (if necessary).
    switch( m_nFit )
    {
        case wxCANVASFITWIDTH   : {
                                      int x, nDummy;

                                      m_poCanvas->GetClientSize( &x, &nDummy );

                                      m_nScaleFactor= (double)x / (double)m_oImage.GetWidth();
                                  }
                                  break;
        case wxCANVASFITWINDOW  : {
                                      int x, y;

                                      m_poCanvas->GetClientSize( &x, &y );

                                      double nScaleFactorX= (double)x / (double)m_oImage.GetWidth();
                                      double nScaleFactorY= (double)y / (double)m_oImage.GetHeight();

                                      m_nScaleFactor= nScaleFactorX > nScaleFactorY ? nScaleFactorY : nScaleFactorX;
                                  }
                                  break;
        case wxCANVASCUSTOMSIZE : break;
        default                 : m_nScaleFactor= 1.0;
                                  break;
    }

    // Some little optimization:
    //  - A scalation factor of 1.0 means there is no scalation at all.
    if( m_nScaleFactor == 1.0 )
    {
        m_poCanvas->SetBitmap( m_oImage );
    }
    else
    {
        // Show busy cursor (until the automatic variable is destroyed).
        wxBusyCursor oWait;

        m_poCanvas->SetBitmap( m_oImage.Scale(
            (int)( (double)m_oImage.GetWidth()  * m_nScaleFactor ),
            (int)( (double)m_oImage.GetHeight() * m_nScaleFactor ),
            wxIMAGE_QUALITY_HIGH ) );
    }
}

// Get the selected sub image.
//
wxImage wxIScanFrame::GetImageSelection()
{
    if( m_poCanvas->IsSelected() )
    {
        wxRect oSelection= m_poCanvas->GetSelection();

        oSelection.x     = int( (double)oSelection.x      / m_nScaleFactor );
        oSelection.y     = int( (double)oSelection.y      / m_nScaleFactor );
        oSelection.width = int( (double)oSelection.width  / m_nScaleFactor );
        oSelection.height= int( (double)oSelection.height / m_nScaleFactor );

        int nWidth= m_oImage.GetWidth();
        if( nWidth < ( oSelection.x + oSelection.width ) )
        {
            oSelection.width= nWidth - oSelection.x;
        }

        int nHeight= m_oImage.GetHeight();
        if( nHeight < ( oSelection.y + oSelection.height ) )
        {
            oSelection.height= nHeight - oSelection.y;
        }

        return m_oImage.GetSubImage( oSelection );
    }
    else
    {
        return m_oImage;
    }
}

// Get an image from scanner.
//
bool wxIScanFrame::ScanImage()
{
#ifdef __WXSCANSANE__
    // Enter critical section to protect m_poScanner.
    m_oCriticalSectionScanner.Enter();

    // ...
    if( !m_poScanner->SetDeviceIndex( m_poChoiceScanner->GetSelection() ) )
    {
        wxLogWarning( ( m_poScanner->GetDeviceCount() ? _( "The selected scanning device is invald." )
                                                        : _( "No scanning device found." ) )
                        + wxString( wxT( " " ) )
                        + _( "Rescanning for scanning devices..." ) );

        // Leave the critical section that protects m_poScanner.
        //
        // Note: We do this because ScanForScanners() enters the
        //       the same critical section.
        //
        m_oCriticalSectionScanner.Leave();

        // Rescan for scanning devices.
        ScanForScanners();

        if( !m_poScanner->SetDeviceIndex( m_poChoiceScanner->GetSelection() ) )
        {
            wxLogError( m_poScanner->GetDeviceCount() ? _( "The selected scanning device is invald." )
                                                        : _( "No scanning device found." ) );
            return false;
        }

        // Reenter critical section to protect m_poScanner.
        m_oCriticalSectionScanner.Enter();
    }
#endif // __WXSCANSANE__

    // Check if the scanner object initialization was successful.
    if( !m_poScanner->IsOk() )
    {
        wxLogError( _( "Cannot initialize scanner object." ) );
        return false;
    }

    // Scan an image, ...
    if( !m_poScanner->ScanImage( m_oImage ) )
    {
        wxLogError( _( "An error occured while scanning." ) );
        return false;
    }

    // ... get its resolution, ...
    m_nResolution= m_poScanner->GetResolution();

#ifdef __WXSCANSANE__
    // Leave the critical section that protects m_poScanner.
    m_oCriticalSectionScanner.Leave();
#endif // __WXSCANSANE__

    // ... apply an image profile (crop, convert to monochrome etc.), and ...
    if( m_bAutoApplyProfile )
    {
        ApplyProfile();
    }

    // ... show the image on the canvas window.
    UpdateBitmap();

    // Reset the image count, the page number and the image filename.
    ResetFileName();

    // Signal success.
    return true;
}

#ifdef __WXSCANSANE__
// Scan for existing SANE scanners an fill the according wxChoice
// object in the tool bar.
//
void wxIScanFrame::ScanForScanners( bool bAsync )
{
    // Enter critical section to protect m_poScanner.
    //
    // Note: The corresponding ScanForScannersThreadExit().Leave() call
    //       is included in wxIScanFrame::ScanForScannersThreadEntry().
    //
    m_oCriticalSectionScanner.Enter();

    // If there is a current scanner object destroy it.
    if( m_poScanner )
    {
        delete m_poScanner;
        m_poScanner= NULL;
    }

    // Empty the wxChoice object for scanners.
    m_poChoiceScanner->Clear();

    // Enable/disable menu options according to the actual state.
    EnableControls();

    // Switch between asynchronous and synchronous version of
    // creating a new scanner object and filling the choice object.
    if( bAsync )
    {
        // Create a new thread that creates a new scanner object
        // (and scans therefore for available scanners).
        wxIScanFrameScanForScannersThread * poThread= new wxIScanFrameScanForScannersThread( this );

        poThread->Create();
        poThread->Run();
    }
    else
    {
        // Show hourglass cursor.
        wxBusyCursor oWait;

        // Create a new scanner object (and scan for scanning devices)
        ScanForScannersThreadEntry();

        // Fill the wxChoice object for scanners with a list of
        // available scanning devices.
        ScanForScannersThreadExit();
    }
}

// Create a new scanner object and scan for scanning devices.
//
// Note: This function should not be called directly.
//
void wxIScanFrame::ScanForScannersThreadEntry()
{
    // Create a new scanner object (and scan for scanning devices)
    m_poScanner= new wxScan;
}

// Fill the wxChoice object for scanners with a list of available
// scanning devices.
//
// Note: This function should not be called directly.
//
void wxIScanFrame::ScanForScannersThreadExit()
{
    // Check...
    if( !m_poScanner )
    {
        // Log an error message and leave.
        wxLogError( _( "Cannot create a scanning device object (wxScan)." ) );
    }

    // Fill the wxChoice object for scanners with a list of
    // available scanning devices.
    else if( m_poScanner->IsOk() )
    {
        int nCount= m_poScanner->GetDeviceCount();

        if( nCount > 0 )
        {
            for( int i= 0; i < nCount; i++ )
            {
                m_poChoiceScanner->Append(
                                           m_poScanner->GetDeviceModel( i )
                                           + wxT( " (" )
                                           + m_poScanner->GetDeviceName( i )
                                           + wxT( ")" )
                                         );
            }
            m_poChoiceScanner->SetSelection( m_poScanner->GetDeviceIndex() );
        }
        else
        {
            wxLogWarning( _( "No scanning device found." ) );
        }
    }

    // Leave the critical section that protects m_poScanner.
    m_oCriticalSectionScanner.Leave();

    // Enable/disable menu options according to the actual state.
    EnableControls();
}
#endif // __WXSCANSANE__

// Select a profile (by number).
//
void wxIScanFrame::SetProfile( int nProfileIndex )
{
    GetMenuBar()->Check( ID_DOCUMENTPROFILE0 + m_nProfileIndex, false );
    m_nProfileIndex= nProfileIndex;
    GetMenuBar()->Check( ID_DOCUMENTPROFILE0 + m_nProfileIndex, true  );
}

// Apply the selected profile to the image.
//
void wxIScanFrame::ApplyProfile()
{
    // Show hourglass cursor.
    wxBusyCursor oWait;

    // Get profile configuration.
    wxConfigBase *poConfig= wxConfigBase::Get();

    poConfig->SetRecordDefaults();
    poConfig->SetPath( wxString::Format( wxT( "/Profile/%d" ), m_nProfileIndex ) );

#if __WXLUASCRIPT__
    wxString strScriptStartupFunction= poConfig->Read( wxT( "Function" ), wxT( "" ) );

    if( m_bLua && !strScriptStartupFunction.IsEmpty() )
    {
        wxString strScriptFileName= poConfig->Read( wxT( "Script" ), wxT( "" ) );

        StartScript( strScriptStartupFunction, strScriptFileName );
    }
    else
#endif // __WXLUASCRIPT__
    {
        // Crop image to the corresponding image rect.
        bool bCrop= (bool)poConfig->Read( wxT( "Crop" ), (long)false );

        if( bCrop )
        {
            int x= poConfig->Read( wxT( "x" ), 0L );
            int y= poConfig->Read( wxT( "y" ), 0L );
            int w= poConfig->Read( wxT( "w" ), (long)( 210.0 / 25.4 * (double)m_nResolution ) );
            int h= poConfig->Read( wxT( "h" ), (long)( 297.0 / 25.4 * (double)m_nResolution ) );

            m_oImage= ::CropImage( m_oImage, x, y, w, h );
        }

        // Convert the image to greyscale.
        bool bGreyScale= (bool)poConfig->Read( wxT( "GreyScale" ), (long)false );

        if( bGreyScale )
        {
            m_oImage= ::Image2Grey( m_oImage );
        }

        // Convert the image to mono chrome.
        bool bMonoChrome= (bool)poConfig->Read( wxT( "MonoChrome" ), (long)false );

        if( bMonoChrome )
        {
            int nMonoThreshold= poConfig->Read( wxT( "MonoThreshold" ), 128L );

            m_oImage= ::Image2Mono( m_oImage, nMonoThreshold);
        }

        // Rotate the image 90° to the right (multiple times).
        int nRotate90Right= poConfig->Read( wxT( "Rotate90Right" ), 0L );

        for( int i= 0; i < nRotate90Right; i++ )
        {
            m_oImage= m_oImage.Rotate90();
        }
    }
}

// Call an external OCR software and return the filename
// of the resulting text file.
//
wxString wxIScanFrame::OCR( const wxString &strTempFileName, bool bUseHocr )
{
    wxString strCommand;            // Command line to execute as an external process.
    wxString strReturnFileName;     // ...

    // Check if OCR command is enabled.
    if( !m_bCmdOcrEnable )
    {
#if __DEBUG__
        wxLogWarning( wxString( wxT( "wxIScanFrame::OCR - " ) )
                        + _( "OCR command is disabled by option." ) );
#endif
        return wxEmptyString;
    }

    // Convert image to a monochrome version, ...
    if( m_bCmdConvertEnable )
    {
        // ... either by using an external command, ...
        strCommand.Printf( m_strCmdConvert,
                           strTempFileName.c_str(),
                           strTempFileName.c_str() );
#if __DEBUG__
        wxLogMessage( wxT( "wxIScanFrame::OCR - strCommand == '%s'" ), strCommand.c_str() );
#endif
        if( !Execute( strCommand ) )
        {
            wxLogError( wxString( wxT( "wxIScanFrame::OCR - " ) )
                          + _( "Monochrome file creation failed." ) );
            strReturnFileName.Empty();
            goto leave;
        }
    }
    else
    {
        // ... or by using an internal function (Image2Mono()).
        //
        // Note: Image2Mono() replaces the image in place, i. e.
        //       the monochrome image shows on the screen, too.
        //
        ::Image2Mono( GetImageSelection() ).SaveFile( strTempFileName, m_strBitmapMimeType );
    }

    // Do OCR using an external command.
    strCommand.Printf( bUseHocr ? m_strCmdOcrUseHocr : m_strCmdOcr,
                       strTempFileName.c_str(),
                       strTempFileName.c_str() );
#if __DEBUG__
    wxLogMessage( wxT( "wxIScanFrame::OCR - strCommand == '%s'" ), strCommand.c_str() );
#endif
    if( !Execute( strCommand ) )
    {
        wxLogError( wxString( wxT( "wxIScanFrame::OCR - " ) )
                      + _( "OCR failed." ) );
        strReturnFileName.Empty();
        goto leave;
    }

    strReturnFileName= strTempFileName + wxT( "." ) + ( bUseHocr ? m_strOcrOutputExtensionHocr : m_strOcrOutputExtension );

leave:
    // Clean up temporary image file.
    if(m_bCmdCleanUpEnable )
    {

        // Clean up.
        strCommand.Printf( m_strCmdCleanUp,
                           strTempFileName.c_str(),
                           strTempFileName.c_str() );
#if __DEBUG__
        wxLogMessage( wxT( "wxIScanFrame::OCR - strCommand == '%s'" ), strCommand.c_str() );
#endif
        Execute( strCommand );
    }

    // Clean up temporary hOCR file(s).
    if( bUseHocr && m_bCmdHocrCleanUpEnable )
    {

        // Clean up.
        strCommand.Printf( m_strCmdHocrCleanUp,
                           strTempFileName.c_str(),
                           strTempFileName.c_str() );
#if __DEBUG__
        wxLogMessage( wxT( "wxIScanFrame::OCR - strCommand == '%s'" ), strCommand.c_str() );
#endif
        Execute( strCommand );
    }

    // Return filename of the created text file (or an empty string on errors).
    return strReturnFileName;
}

// Do OCR and read out the returned text.
//
bool wxIScanFrame::ReadOut( bool bAsync )
{
    // Save image in a temporary JPEG file.
    wxString strTempFileName= wxFileName::CreateTempFileName( wxT( "" ) );

    GetImageSelection().SaveFile( strTempFileName, m_strBitmapMimeType );

    // Do OCR, and get the temporary text file name.
    wxString strTempTextFileName= OCR( strTempFileName );

    // Remove temporary JPEG file.
    ::wxRemoveFile( strTempFileName );

    // Read the text using a custom command (if it is not the empty string).
    if( strTempTextFileName.IsEmpty() )
    {
        // Signal error.
        return false;
    }

    wxString strCommand= wxString::Format( m_strCmdTts, strTempTextFileName.c_str() );

#if __DEBUG__
    wxLogMessage( wxT( "wxIScanFrame::ReadText - strCommand == '%s'" ), strCommand.c_str() );
#endif

    // Execute the read out process.
    return Execute( strCommand, bAsync, strTempTextFileName );
}

// Fork an external process.
//
bool wxIScanFrame::Execute( const wxString &strCommand, bool bAsync, const wxString &strTempTextFileName )
{
    if( bAsync )
    {
        // Check if an asynchronous process is still running.
        if( m_poRunningProcess )
        {
            // Log an error message.
            wxLogError( wxString( wxT( "wxIScanFrame::Execute - " ) )
                          + _( "Cannot create new asynchronous process. An old one is still running. "
                               "Please wait until it stops or press the STOP button in the taskbar." ) );

            // Signal error.
            return false;
        }

        // Create an asynchronous running process, ...
        if( strTempTextFileName.IsEmpty() )
        {
            m_poRunningProcess= new wxExtProcess( this, wxISCAN_PROCESS );
        }
        else
        {
            m_poRunningProcess= new wxExtProcessDelTempFile( this, wxISCAN_PROCESS, strTempTextFileName );
        }

        // ... check if is was created correctly, ...
        if( !m_poRunningProcess )
        {
            // Log an error message.
            wxLogError( wxString( wxT( "wxIScanFrame::Execute - " ) )
                          + _( "Cannot create process object." ) );

            // Signal error.
            return false;
        }

        // ... redirect its output, ...
//        m_poRunningProcess->Redirect();

        // ... and execute it.
        if( !m_poRunningProcess->Execute( strCommand, wxEXEC_ASYNC | wxEXEC_MAKE_GROUP_LEADER ) )
        {
            // Log an error message.
            wxLogError( wxString( wxT( "wxIScanFrame::Execute - " ) )
                          + wxString::Format( _( "Cannot start asynchronous process [%s]." ),
                                              strCommand.c_str() ) );

            // Signal error.
            return false;
        }
    }
    else
    {
        // Create a process, ...
        wxProcess oProcess( this );

        // ... redirect its output, ...
        oProcess.Redirect();

        // ... execute it synchronous, and await its ending.
        long nExitCode= ::wxExecute( strCommand, wxEXEC_SYNC, &oProcess );

       // Log process's output.
        LogProcessOutput( &oProcess );

        if( nExitCode )
        {
            // Log an error message.
            wxLogError( wxString( wxT( "wxIScanFrame::Execute - " ) )
                          + wxString::Format( _( "An error occured on synchronous process [%s]." ),
                                              strCommand.c_str() ) );

            // Signal error.
            return false;
        }
    }

    // Signal success.
    return true;
}

// Reset the filename to "unknown.jpg" etc.
//
void wxIScanFrame::ResetFileName()
{
    // Reset the file name.
    m_strImageFileName= _( "unknown.jpg" );
    SetTitle( cstrAppName );

    // Reset the image count, the page number and the image filename.
    m_nImageCount= 1;
    m_nPage= 0;

    // Update the page number info in the statusbar and in the toolbar.
    UpdatePageNumber();
}

// Write a sub process's stdout and stderr output to the program's log.
//
void wxIScanFrame::LogProcessOutput( wxProcess *poProcess )
{
    // Save the log text control's default colour.
    wxTextAttr oStyle( m_poLogTextCtrl->GetDefaultStyle() );
    wxColour oOldColor( oStyle.GetTextColour() );

    // Check if there is text on the process's stdout and stderr stream
    // and log it.
    //
    // Process's stdout in light blue:
    wxTextInputStream oIn( *poProcess->GetInputStream() );

    oStyle.SetTextColour( wxColour( 64, 64, 255 ) );
    m_poLogTextCtrl->SetDefaultStyle( oStyle );
    while( poProcess->IsInputAvailable() )
    {
        wxLogMessage( oIn.ReadLine() );
    }

    // Process's stderr in light violet:
    wxTextInputStream oErr( *poProcess->GetErrorStream() );

    oStyle.SetTextColour( wxColour( 192, 96, 192 ) );
    m_poLogTextCtrl->SetDefaultStyle( oStyle );
    while( poProcess->IsErrorAvailable() )
    {
        wxLogMessage( oErr.ReadLine() );
    }

    // Restore the log text control's default colour.
    oStyle.SetTextColour( oOldColor );
    m_poLogTextCtrl->SetDefaultStyle( oStyle );
}

// Update the page number info in the statusbar and in the toolbar.
//
void wxIScanFrame::UpdatePageNumber()
{
    SetStatusText( wxString::Format( wxT( "%d/%d" ),  m_nPage + 1, m_nImageCount ), 2 );
    m_poTextCtrlPage->SetValue( wxString::Format( wxT( "%d" ),  m_nPage + 1 ) );
}

// Enable or disable controls according to the actual progam state.
//
void wxIScanFrame::EnableControls()
{
    // Enable/disable menu items (on first call).
    bool bImageOk= !m_bUILocked && m_oImage.IsOk();

    GetMenuBar()->Enable(     ID_FILESAVEAS,                bImageOk );
    GetToolBar()->EnableTool( ID_FILESAVEAS_TB,             bImageOk );
    GetMenuBar()->Enable(     ID_FILEPRINT,                 bImageOk );
    GetToolBar()->EnableTool( ID_FILEPRINT_TB,              bImageOk );
    GetMenuBar()->Enable(     ID_FILEPRINTPREVIEW,          bImageOk );
    GetMenuBar()->Enable(     ID_FILEPRINTSETUP,            bImageOk );
    GetMenuBar()->Enable(     ID_EDITCOPY,                  bImageOk );
    GetMenuBar()->Enable(     ID_VIEWZOOMIN,                bImageOk );
    GetMenuBar()->Enable(     ID_VIEWZOOMOUT,               bImageOk );
    GetMenuBar()->Enable(     ID_VIEWZOOMSELECTION,         bImageOk );
#if __WXPDFDOC__
    GetMenuBar()->Enable(     ID_PDFBEGINPDF,               true     );
    GetToolBar()->EnableTool( ID_PDFBEGINPDF_TB,            true     );
    GetMenuBar()->Enable(     ID_PDFADDPAGE,                bImageOk );
    GetToolBar()->EnableTool( ID_PDFADDPAGE_TB,             bImageOk );
#else
    GetMenuBar()->Enable(     ID_PDFBEGINPDF,               false    );
    GetToolBar()->EnableTool( ID_PDFBEGINPDF_TB,            false    );
    GetMenuBar()->Enable(     ID_PDFADDPAGE,                false    );
    GetToolBar()->EnableTool( ID_PDFADDPAGE_TB,             false    );
#endif // __WXPDFDOC__
    GetMenuBar()->Enable(     ID_DOCUMENTROTATE90LEFT,      bImageOk );
    GetMenuBar()->Enable(     ID_DOCUMENTROTATE90RIGHT,     bImageOk );
    GetMenuBar()->Enable(     ID_DOCUMENTCROP,              bImageOk );
    GetMenuBar()->Enable(     ID_DOCUMENTAPPLYPROFILE,      bImageOk );

#if __WXPDFDOC__
    // Enable/disable PDF file save controls.
    bool bCanSavePdfFile= !m_bUILocked && ( m_nPdfPages > 0 );

    GetMenuBar()->Enable(     ID_PDFSAVEASPDF,              bCanSavePdfFile );
    GetToolBar()->EnableTool( ID_PDFSAVEASPDF_TB,           bCanSavePdfFile );
#else
    GetMenuBar()->Enable(     ID_PDFSAVEASPDF,              false );
    GetToolBar()->EnableTool( ID_PDFSAVEASPDF_TB,           false );
#endif // __WXPDFDOC__

    // ...
    bool bCopyText= bImageOk && m_bCmdOcrEnable;

    GetMenuBar()->Enable(     ID_DOCUMENTCOPYTEXT,         bCopyText );

    // ...
    GetMenuBar()->Enable(     ID_EDITSETTINGSFILE ,        m_bCmdEditEnable );

    // Enable text-to-speach controls
    bool bTTS= bImageOk
                && m_bCmdOcrEnable
                && m_bCmdTtsEnable
                && ( m_poRunningProcess ? false : true );

    GetMenuBar()->Enable(     ID_DOCUMENTREADTEXT,          bTTS );
    GetToolBar()->EnableTool( ID_DOCUMENTREADTEXT_TB,       bTTS );

    // Enable/disable page controls
    bool bNotFirstPage= ( m_nPage > 0 );
    bool bNotLastPage=  ( m_nPage < ( m_nImageCount - 1 ) );

    GetMenuBar()->Enable(     ID_DOCUMENTFIRSTPAGE,         bImageOk && bNotFirstPage );
    GetToolBar()->EnableTool( ID_DOCUMENTFIRSTPAGE_TB,      bImageOk && bNotFirstPage );
    GetMenuBar()->Enable(     ID_DOCUMENTPREVIOUSPAGE,      bImageOk && bNotFirstPage );
    GetToolBar()->EnableTool( ID_DOCUMENTPREVIOUSPAGE_TB,   bImageOk && bNotFirstPage );
    GetMenuBar()->Enable(     ID_DOCUMENTNEXTPAGE,          bImageOk && bNotLastPage  );
    GetToolBar()->EnableTool( ID_DOCUMENTNEXTPAGE_TB,       bImageOk && bNotLastPage  );
    GetMenuBar()->Enable(     ID_DOCUMENTLASTPAGE,          bImageOk && bNotLastPage  );
    GetToolBar()->EnableTool( ID_DOCUMENTLASTPAGE_TB,       bImageOk && bNotLastPage  );
    GetToolBar()->EnableTool( ID_TEXTCTRLPAGE,              bImageOk                  );

    // Enable process killer.
    GetMenuBar()->Enable(     ID_CMDSTOP,                   m_poRunningProcess );
    GetToolBar()->EnableTool( ID_CMDSTOP_TB,                m_poRunningProcess );

    // Enable scanning.
    bool bScanEnabled= !m_bUILocked && m_poScanner && m_poScanner->IsOk();

    GetMenuBar()->Enable(     ID_FILESCANIMAGE,             bScanEnabled );
    GetToolBar()->EnableTool( ID_FILESCANIMAGE_TB,          bScanEnabled );
#ifdef __WXSCANSANE__
    GetMenuBar()->Enable(     ID_EDITSCANSCANNERS ,         !m_bUILocked && m_poScanner /*bScanEnabled*/ );
    GetToolBar()->EnableTool( ID_CHOICESCANNER,             bScanEnabled );
#else // __WXSCANSANE__
    GetMenuBar()->Enable(     ID_EDITSCANSCANNERS ,         false );
#endif // __WXSCANSANE__

    // Lock ...
    GetMenuBar()->Enable(     ID_FILEOPEN,                  !m_bUILocked );
    GetToolBar()->EnableTool( ID_FILEOPEN_TB,               !m_bUILocked );
    GetMenuBar()->Enable(     ID_EDITPASTE,                 !m_bUILocked );

    // Check the active viewing (fitting) option.
    GetMenuBar()->Check( ID_VIEWFITWIDTH,   false );
    GetMenuBar()->Check( ID_VIEWFITWINDOW,  false );
    GetMenuBar()->Check( ID_VIEWFULLSIZE,   false );
    GetMenuBar()->Check( ID_VIEWCUSTOMSIZE, false );
    switch( m_nFit )
    {
        case wxCANVASFITWIDTH   : GetMenuBar()->Check( ID_VIEWFITWIDTH,   true );
                                  break;
        case wxCANVASFITWINDOW  : GetMenuBar()->Check( ID_VIEWFITWINDOW,  true );
                                  break;
        case wxCANVASFULLSIZE   : GetMenuBar()->Check( ID_VIEWFULLSIZE,   true );
                                  break;
        case wxCANVASCUSTOMSIZE : GetMenuBar()->Check( ID_VIEWCUSTOMSIZE, true );
                                  break;
    }

    // ... file history... .
    for( unsigned i= 0; i <  m_oFileHistory.GetCount(); i++ )
    {
        GetMenuBar()->Enable( m_oFileHistory.GetBaseId() + i, !m_bUILocked );
    }

#if __WXLUASCRIPT__
    // Enable/disable Lua script menu.
    GetMenuBar()->EnableTop( wxISCAN_SCRIPTMENUPOS, m_bLua );
    for( int i= 0; i < m_nLuaCount; i++ )
    {
        GetMenuBar()->Enable( ID_DOCUMENTPROFILE0 + 1000 + i, m_bLua );
    }
#endif // __WXLUASCRIPT__

    // Disable (by compiler option) not implemented controls .
#if defined( __WXPDFDOC__ ) && __WXPDFDOC__ >= 1
    GetMenuBar()->Enable(     ID_PDFBEGINPDF,               !m_bUILocked );
    GetToolBar()->EnableTool( ID_PDFBEGINPDF_TB,            !m_bUILocked );
#else
    GetMenuBar()->Enable(     ID_PDFBEGINPDF,               false );
    GetToolBar()->EnableTool( ID_PDFBEGINPDF_TB,            false );
#endif
}

#if __WXPDFDOC__
// PDF creation functions.
//
// Create (and initialize) a new PDF document.
//
bool wxIScanFrame::CreateNewPdfDocument()
{
    // Delete any old PDF documents.
    if( m_poPdfDoc  )
    {
        delete m_poPdfDoc;
    }
    SetStatusText( wxString( wxT( "PDF: " ) ) + _( "empty" ), 1 );

    // Create a new PDF document in portrait mode on A4 paper using mm
    // as measurement unit.
    m_poPdfDoc= new wxPdfDocument( wxPORTRAIT,
                                   wxString( _T( "mm" ) ),
                                   m_oPrintData.GetPaperId() );
    m_nPdfPages= 0;
    m_bPdfDirty= false;
    if( !m_poPdfDoc )
    {
        wxLogError( _( "Cannot create wxPdfDocument." ) );
    }
    m_poPdfDoc->SetCreator( ::wxGetApp().GetAppName() );
    m_poPdfDoc->SetAutoPageBreak( false );
    m_poPdfDoc->SetCompression( true );
    return true;
}

// Add a new image/OCR text page to the existing PDF document.
//
bool wxIScanFrame::AddPdfPage()
{
    if( !m_poPdfDoc )
    {
        wxLogError( wxString( wxT( "wxIScanFrame::AddPdfPage - " ) )
                      + _( "wxPdfDocument is NULL" ) );
        return false;
    }

    // Save image in a temporary file.
    wxString strTempFileName= wxFileName::CreateTempFileName( wxEmptyString );

    m_oImage.SaveFile( strTempFileName, m_strPdfBitmapMimeType );

#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 1
    wxLogMessage( wxT( "PDF PARAMETERS" ) );
    wxLogMessage( wxT( "\tGetPageWidth == %.2f mm (%f)"  ), m_poPdfDoc->GetPageWidth(),  m_poPdfDoc->GetPageWidth()  / m_oImage.GetWidth() );
    wxLogMessage( wxT( "\tGetPageHeight == %.2f mm (%f)" ), m_poPdfDoc->GetPageHeight(), m_poPdfDoc->GetPageHeight() / m_oImage.GetHeight() );
    wxLogMessage( wxT( "\tGetImageScale == %f (new: %f)" ), m_poPdfDoc->GetImageScale(), (double)m_nResolution / 72.0 );
    wxLogMessage( wxT( "\tGetScaleFactor == %f" ), m_poPdfDoc->GetScaleFactor() );
    wxLogMessage( wxT( "\tm_nResolution == %.2f DPI (%.2f/mm)" ), (double)m_nResolution, (double)m_nResolution / 25.4 );
    wxLogMessage( wxT( "============" ) );
    ::wxSafeYield();
#endif

    // Add a page, ...
    m_poPdfDoc->AddPage( IsPortrait() ? wxPORTRAIT : wxLANDSCAPE );

    // ... do some OCR and include the recognized text if enabled, and ...
    if( m_bOCR )
    {
        wxString strOcrTextFileName= OCR( strTempFileName, m_bHocrEnable );

        if( !strOcrTextFileName.IsEmpty() )
        {
            m_poPdfDoc->SetFont( wxT( "Times" ), wxPDF_FONTSTYLE_REGULAR, 8 );
            m_poPdfDoc->SetTextRenderMode( wxPDF_TEXT_RENDER_INVISIBLE );

            if( m_bHocrEnable )
            {
                wxXmlDocument oXmlDoc;

                // Try to load the OCR result file as XML (XHTML).
                {
                    // Suppress the error message if wxXmlDocument::Load(...) fails.
                    //
                    // Note: We want to suppress only the logging of
                    //       wxXmlDocument::Load(...). Therefore we use a local
                    //       variable oLogNull in an additional inner context
                    //       which is automatically destroyed after leaving this
                    //       context.
                    //
                    wxLogNull oLogNull;

                    // Load the XML file.
                    //
                    // Note: We need the flag wxXMLDOC_KEEP_WHITESPACE_NODES
                    //       because we need the whitespace for flushing!
                    oXmlDoc.Load( strOcrTextFileName, wxT( "UTF-8" ), wxXMLDOC_KEEP_WHITESPACE_NODES );
                }

                // If this was not successfull convert try to convert from HTML to XHTML.
                if( !oXmlDoc.IsOk() && m_bCmdHtml2XhtmlEnable )
                {
                    // Try to convert the file from HTML to XHTML.
                    wxString strCommand= wxString::Format( m_strCmdHtml2Xhtml, strOcrTextFileName.c_str() );
#if __DEBUG__
                    wxLogMessage( wxT( "wxIScanFrame::AddPdfPage - strCommand == '%s'" ), strCommand.c_str() );
#endif
                    Execute( strCommand );

                    // Retry to load the file as XHTML file.
                    {
                        // Suppress the error message if wxXmlDocument::Load(...)
                        // fails.
                        wxLogNull oLogNull;

                        // Load the XML file.
                        //
                        // Note: We need the flag wxXMLDOC_KEEP_WHITESPACE_NODES
                        //       because we need the whitespace for flushing!
                        oXmlDoc.Load( strOcrTextFileName, wxT( "UTF-8" ), wxXMLDOC_KEEP_WHITESPACE_NODES );
                    }

                    // In case of an error use the fallback action.
                    if( !oXmlDoc.IsOk() )
                    {
                        // Do a fallback by treating the file as unformated text.
                        goto FallBack;
                    }
                }

                // Traverse DOM tree and draw the text on the PDF document.
                if( m_bSmartHocrEnable )
                {
                    wxIScanSmartHocr2Pdf oHocr2Pdf( &oXmlDoc, m_poPdfDoc, m_nResolution, m_strHocrClass );

                    oHocr2Pdf.Run();
                }
                else
                {
                    wxIScanHocr2Pdf oHocr2Pdf( &oXmlDoc, m_poPdfDoc, m_nResolution, m_strHocrClass );

                    oHocr2Pdf.Run();
                }

                // On success leave out the fall back code.
                goto GoOn;
            }

FallBack:
            // Handle unformated text file (non-hocr-files).
            //
            m_poPdfDoc->MultiCell( 0, 3, ::GetTextFromFile( strOcrTextFileName ), wxPDF_BORDER_NONE, wxPDF_ALIGN_LEFT, 1 );

GoOn:
            // Remove the text file created by the OCR program.
            ::wxRemoveFile( strOcrTextFileName );
        }
    }

    // ... put the image onto the current PDF page.
    m_poPdfDoc->SetImageScale(  (double)m_nResolution / 72.0 );
    m_poPdfDoc->Image( strTempFileName, 0 , 0, 0, 0, m_strPdfBitmapMimeType );

    // Remove temporary file.
    ::wxRemoveFile( strTempFileName );

    // Incremement the page counter and mark the PDF document as 'dirty'.;
    m_nPdfPages++;
    m_bPdfDirty= true;
    SetStatusText( wxString::Format( wxT( "PDF: %d" ), m_nPdfPages ), 1 );

    // Add a thumb to the pages panel.
    m_poPanelPages->AddImage( m_oImage );

    // Signal success.
    return true;
}
#endif // __WXPDFDOC__

#if __WXLUASCRIPT__
// Start a Lua script from a given file.
//
void wxIScanFrame::StartScript( const wxString &strScriptStartupFunction, wxString strScriptFileName )
{
    // Create the final script ...
    wxString strScriptCode; // Contains the Lua script code.

    if( strScriptFileName.IsEmpty() )
    {
        // ... by using the given main function call(s) (chunk).
        strScriptCode= strScriptStartupFunction + wxT( "\n" );
    }
    else
    {
        // Search for the directory containing the script file:
        //
        // Check...
        if( !::wxFileExists( strScriptFileName ) )
        {
            // If the script file does not exist replace its directory part by the
            // user's home directory.
            //
            // Signal a warning.
            wxLogWarning( wxString( wxT( "wxIScanFrame::StartScript -- " ) )
                            + _( "Script file does not exist. I try searching in the home directory." ) );

            // Replace the directory part of the script file name
            // by the user's home directory.
            wxFileName oScriptFileName( strScriptFileName );

            strScriptFileName= oScriptFileName.GetFullName();
            oScriptFileName.AssignHomeDir();
            oScriptFileName.SetFullName( strScriptFileName );

            strScriptFileName= oScriptFileName.GetFullPath();
    #if __DEBUG__
            wxLogWarning( wxT( "wxIScanFrame::StartScript -- strScriptFileName == '%s'" ),
                            strScriptFileName.c_str() );
    #endif // __DEBUG

                // Check...
            if( !::wxFileExists( strScriptFileName ) )
            {
                // If the script file does not exist replace its directory
                // part by the data directory.
                //
                // Display (log) a warning.
                wxLogWarning( wxString( wxT( "wxIScanFrame::StartScript -- " ) )
                                + _( "Script file does not exist. I try searching in the data directory." ) );

                // Replace the directory part of the script file name
                // by the program's data directory.
                wxFileName oScriptFileName( strScriptFileName );

                strScriptFileName= oScriptFileName.GetFullName();
                oScriptFileName.AssignDir( wxStandardPaths::Get().GetDataDir() );
                oScriptFileName.SetFullName( strScriptFileName );

                strScriptFileName= oScriptFileName.GetFullPath();
    #if __DEBUG__
                wxLogWarning( wxT( "wxIScanFrame::StartScript -- strScriptFileName == '%s'" ),
                                strScriptFileName.c_str() );
    #endif // __DEBUG
            }
        }

        // ... by concatinating the file content and the main
        // function call(s) (chunk).
        strScriptCode= ::GetTextFromFile( strScriptFileName ) + wxT( "\n\n" ) +
                       strScriptStartupFunction + wxT( "\n" );
    }

    // Create the Lua scripting object, ...
    wxIScanLuaScript oScript( strScriptCode, this, cstrAppName, &bLuaReturnFromEventHandler );

#if __WXLUASCRIPT_DYNAMIC__
    // Check if the script object is initialized correctly. This is only done
    // on dynamic loading of the Lua library because only there the library
    // may not be loaded correctly.
    if( !oScript.IsOk() )
    {
        // Log an error message, ...
        wxLogError( wxString( wxT( "wxIScanFrame::StartScript -- " ) )
                      + _( "Cannot initialize wxIScanLuaScript object." ) );

        // ... and leave.
        return;
    }
#endif // __WXLUASCRIPT_DYNAMIC__

    // ..., register menu id constants, ...
    oScript.RegisterConstant( wxT( "ID_FILESCANIMAGE" ), ID_FILESCANIMAGE );
    oScript.RegisterConstant( wxT( "ID_FILEOPEN" ), ID_FILEOPEN );
    oScript.RegisterConstant( wxT( "ID_FILESAVEAS" ), ID_FILESAVEAS );
    oScript.RegisterConstant( wxT( "ID_FILEPRINT" ), ID_FILEPRINT );
    oScript.RegisterConstant( wxT( "ID_FILEPRINTPREVIEW" ), ID_FILEPRINTPREVIEW );
    oScript.RegisterConstant( wxT( "ID_FILEPRINTSETUP" ), ID_FILEPRINTSETUP );
    oScript.RegisterConstant( wxT( "ID_FILEQUIT" ), ID_FILEQUIT );
    oScript.RegisterConstant( wxT( "ID_EDITCOPY" ), ID_EDITCOPY );
    oScript.RegisterConstant( wxT( "ID_EDITPASTE" ), ID_EDITPASTE );
    oScript.RegisterConstant( wxT( "ID_EDITSETTINGS" ), ID_EDITSETTINGS );
    oScript.RegisterConstant( wxT( "ID_EDITSETTINGSFILE" ), ID_EDITSETTINGSFILE );
    oScript.RegisterConstant( wxT( "ID_VIEWFITWIDTH" ), ID_VIEWFITWIDTH );
    oScript.RegisterConstant( wxT( "ID_VIEWFITWINDOW" ), ID_VIEWFITWINDOW );
    oScript.RegisterConstant( wxT( "ID_VIEWFULLSIZE" ), ID_VIEWFULLSIZE );
    oScript.RegisterConstant( wxT( "ID_VIEWCUSTOMSIZE" ), ID_VIEWCUSTOMSIZE );
    oScript.RegisterConstant( wxT( "ID_VIEWFULLSCREEN" ), ID_VIEWFULLSCREEN );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTCOPYTEXT" ), ID_DOCUMENTCOPYTEXT );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTREADTEXT" ), ID_DOCUMENTREADTEXT );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTREADTEXT" ), ID_DOCUMENTREADTEXT );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTREADTEXTSYNC" ), ID_DOCUMENTREADTEXTSYNC );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTPREVIOUSPAGE" ), ID_DOCUMENTPREVIOUSPAGE );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTNEXTPAGE" ), ID_DOCUMENTNEXTPAGE );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTLASTPAGE" ), ID_DOCUMENTLASTPAGE );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTCROP" ), ID_DOCUMENTCROP );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTROTATE90LEFT" ), ID_DOCUMENTROTATE90LEFT );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTROTATE90RIGHT" ), ID_DOCUMENTROTATE90RIGHT );
    oScript.RegisterConstant( wxT( "ID_DOCUMENTAPPLYPROFILE" ), ID_DOCUMENTAPPLYPROFILE );
#if __WXPDFDOC__
    oScript.RegisterConstant( wxT( "ID_PDFBEGINPDF" ), ID_PDFBEGINPDF );
    oScript.RegisterConstant( wxT( "ID_PDFADDPAGE" ), ID_PDFADDPAGE );
    oScript.RegisterConstant( wxT( "ID_PDFSAVEASPDF" ), ID_PDFSAVEASPDF );
#endif // __WXPDFDOC__
    oScript.RegisterConstant( wxT( "ID_HELPABOUT" ), ID_HELPABOUT );
    oScript.RegisterConstant( wxT( "ID_CMDSTOP" ), ID_CMDSTOP );

    // ..., register variables, ...
    oScript.RegisterVariable( wxT( "Resolution" ), &m_nResolution );
    oScript.RegisterVariable( wxT( "Page" ), &m_nPage );
    oScript.RegisterVariable( wxT( "ImageCount" ), &m_nImageCount );
    oScript.RegisterVariable( wxT( "PdfPages" ), &m_nPdfPages );
    oScript.RegisterVariable( wxT( "ProfileIndex" ), &m_nProfileIndex );
    oScript.RegisterVariable( wxT( "ImageFileName" ), &m_strImageFileName );
    oScript.RegisterVariable( wxT( "BitmapMimeType" ), &m_strBitmapMimeType );
    oScript.RegisterVariable( wxT( "ScaleFactor" ), &m_nScaleFactor );
    oScript.RegisterVariable( wxT( "ZoomFactor" ), &m_nZoomFactor );
    oScript.RegisterVariable( wxT( "AutoApplyProfile" ), &m_bAutoApplyProfile );
    oScript.RegisterVariable( wxT( "AutoApplyProfileOnMultiPage" ), &m_bAutoApplyProfileOnMultiPage );
    oScript.RegisterVariable( wxT( "OCR" ), &m_bOCR );
    oScript.RegisterVariable( wxT( "CmdConvertEnable" ), &m_bCmdConvertEnable );
    oScript.RegisterVariable( wxT( "CmdConvert" ), &m_strCmdConvert );
    oScript.RegisterVariable( wxT( "CmdOcrEnable" ), &m_bCmdOcrEnable );
    oScript.RegisterVariable( wxT( "CmdOcr" ), &m_strCmdOcr );
    oScript.RegisterVariable( wxT( "CmdCleanUpEnable" ), &m_bCmdCleanUpEnable );
    oScript.RegisterVariable( wxT( "CmdCleanUp" ), &m_strCmdCleanUp );
    oScript.RegisterVariable( wxT( "HocrEnable" ), &m_bHocrEnable );
    oScript.RegisterVariable( wxT( "HocrClass" ), &m_strHocrClass );
    oScript.RegisterVariable( wxT( "SmartHocrEnable" ), &m_bSmartHocrEnable );
    oScript.RegisterVariable( wxT( "CmdOcrUseHocr" ), &m_strCmdOcrUseHocr );
    oScript.RegisterVariable( wxT( "CmdHtml2XhtmlEnable" ), &m_bCmdHtml2XhtmlEnable );
    oScript.RegisterVariable( wxT( "CmdHtml2Xhtml" ), &m_strCmdHtml2Xhtml );
    oScript.RegisterVariable( wxT( "CmdHocrCleanUpEnable" ), &m_bCmdHocrCleanUpEnable );
    oScript.RegisterVariable( wxT( "CmdHocrCleanUp" ), &m_strCmdHocrCleanUp );
    oScript.RegisterVariable( wxT( "CmdTtsEnable" ), &m_bCmdTtsEnable );
    oScript.RegisterVariable( wxT( "CmdTts" ), &m_strCmdTts );
    oScript.RegisterVariable( wxT( "CmdEditEnable" ), &m_bCmdEditEnable );
    oScript.RegisterVariable( wxT( "CmdEdit" ), &m_strCmdEdit );
    oScript.RegisterVariable( wxT( "PdfDirty" ), &m_bPdfDirty );
#if __WXPDFDOC__
    oScript.RegisterVariable( wxT( "PdfBitmapMimeType" ), &m_strPdfBitmapMimeType );
#endif // __WXPDFDOC__

    // ... and run the script.
#if __DEBUG__
    wxLogMessage( wxT( "wxIScanFrame::StartScript - " )
                    + wxString::Format( _( "Running Lua Script '%s' starting function '%s'." ),
                                        strScriptFileName.c_str(),
                                        strScriptStartupFunction.c_str() ) );
#endif // __DEBUG__
    oScript.Run();
}
#endif // __WXLUASCRIPT__

// Setting functions.
//
// Restore program settings from config file.
//
void wxIScanFrame::RestoreSettings()
{
    // Reset window settings.
    wxConfigBase *poConfig = wxConfigBase::Get();
    poConfig->SetRecordDefaults();
    poConfig->SetPath( wxT( "/" )  );
    poConfig->SetPath( cstrwxFrame );

    int x= poConfig->Read( wxT( "x" ),   5 );
    int y= poConfig->Read( wxT( "y" ),   5 );
    int w= poConfig->Read( wxT( "w" ), 630 );
    int h= poConfig->Read( wxT( "h" ), 470 );
    bool bMaximized= (bool)poConfig->Read( wxT( "Maximized"  ), (long)false );
    bool bIconized= (bool)poConfig->Read( wxT( "Iconized"  ), (long)false );
    bool bFullScreen= (bool)poConfig->Read( wxT( "FullScreen"  ), (long)false );

    // Reset window position, size, maximization and full screen state.
    Move( x, y );
    SetSize( w, h );
    Maximize( bMaximized );
    Iconize( bIconized );
    if( bFullScreen )
    {
        ToggleFullScreen();
    }

    // Reset ...
    m_oPrintData.SetPaperId( (wxPaperSize)poConfig->Read( wxT( "PaperSize" ), (long)wxPAPER_A4 ) );
    m_nFit= poConfig->Read( wxT( "Fit" ), wxCANVASFITWINDOW );
    poConfig->Read( wxT( "ScaleFactor" ), &m_nScaleFactor );
    poConfig->Read( wxT( "ZoomFactor" ), &m_nZoomFactor );

    // Reset bitmap mimetype for everything but pdf export.
    m_strBitmapMimeType= poConfig->Read( wxT( "BitmapMimeType" ), wxT( "image/tiff" ) );

#if __WXPDFDOC__
    // Reset bitmap mimetype for pdf export.
    m_strPdfBitmapMimeType= poConfig->Read( wxT( "PdfBitmapMimeType" ), wxT( "image/png" ) );
#endif // __WXPDFDOC__

    // Get OCR and tts configuration.
    m_bAutoApplyProfile= (bool)poConfig->Read( wxT( "AutoApplyProfile" ), (long)false );
    m_bAutoApplyProfileOnMultiPage= (bool)poConfig->Read( wxT( "AutoApplyProfileOnMultiPage" ), (long)false );
    m_strOcrOutputExtension= poConfig->Read( wxT( "OcrOutputExtension" ), wxT( "txt" ) );
    m_bCmdConvertEnable= poConfig->Read( wxT( "CmdConvertEnable" ), (long)false );
    m_strCmdConvert= poConfig->Read( wxT( "CmdConvert" ), wxT( "convert %s -compress Group4 %s.tif" ) );
    m_bCmdOcrEnable= poConfig->Read( wxT( "CmdOcrEnable" ), (long)false );
    m_strCmdOcr= poConfig->Read( wxT( "CmdOcr" ), wxT( "cuneiform -f text -o %s.txt %s.tif" ) );
    m_bOCR= (bool)poConfig->Read( wxT( "OCR" ), (long)false );
#if __WXLUASCRIPT__
    m_bLua= (bool)poConfig->Read( wxT( "Lua" ), (long)false );
#endif // __WXLUASCRIPT__
    m_bCmdCleanUpEnable= poConfig->Read( wxT( "CmdCleanUpEnable" ), (long)false );
    m_strCmdCleanUp= poConfig->Read( wxT( "CmdCleanUp" ), wxT( "rm %s.tif" ) );
    m_bCmdTtsEnable= poConfig->Read( wxT( "CmdTtsEnable" ), (long)false );
    m_strCmdTts= poConfig->Read( wxT( "CmdTts" ), wxT( "espeak -f %s" ) );
    m_bCmdEditEnable= poConfig->Read( wxT( "CmdEditEnable" ), (long)false );
    m_strCmdEdit= poConfig->Read( wxT( "CmdEdit" ), wxT( "scite %s" ) );
    m_bHocrEnable= poConfig->Read( wxT( "HocrEnable" ), (long)false );
    m_strHocrClass= poConfig->Read( wxT( "HocrClass" ), wxT( "ocr_line" ) );
    m_bSmartHocrEnable= poConfig->Read( wxT( "SmartHocrEnable" ), (long)false );
    m_strCmdOcrUseHocr= poConfig->Read( wxT( "CmdOcrUseHocr" ), wxT( "cuneiform -f hocr -o %s.html %s.tif" ) );
    m_strOcrOutputExtensionHocr= poConfig->Read( wxT( "OcrOutputExtensionHocr" ), wxT( "html" ) );
    m_bCmdHtml2XhtmlEnable= poConfig->Read( wxT( "CmdHtml2XhtmlEnable" ), (long)false );
    m_strCmdHtml2Xhtml= poConfig->Read( wxT( "CmdHtml2Xhtml" ), wxT( "tidy -q -m -numeric -asxhtml -utf8 %s" ) );
    m_bCmdHocrCleanUpEnable= poConfig->Read( wxT( "CmdHocrCleanUpEnable" ), (long)false );
    m_strCmdHocrCleanUp= poConfig->Read( wxT( "CmdHocrCleanUp" ), wxT( "rm -r %s_files" ) );

    // Restore the standard resolution.
    m_nResolution= poConfig->Read( wxT( "Resolution" ), 300 );

    // Reset sash positions and splitting options.
    RestoreSashSettings();
}

// Restore sash settings from config file.
//
void wxIScanFrame::RestoreSashSettings()
{
    // Reset window settings.
    wxConfigBase *poConfig = wxConfigBase::Get();
    poConfig->SetRecordDefaults();
    poConfig->SetPath( wxT( "/" )  );
    poConfig->SetPath( cstrwxFrame );

    // Reset sash positions and splitting options.
    int nHSashPos= poConfig->Read( wxT( "HSashPos" ), -1 );
    int nVSashPos= poConfig->Read( wxT( "VSashPos" ), -1 );

    m_poHSplitterWindow->SetSashPosition( nHSashPos );
    m_poVSplitterWindow->SetSashPosition( nVSashPos );
}

// Save program settings in config file.
//
void wxIScanFrame::SaveSettings()
{
    // Save configuration data.
    wxConfigBase *poConfig= wxConfigBase::Get();

    poConfig->SetPath( wxT( "/" ) );
    poConfig->SetPath( cstrwxFrame );

    // Save iconifization state.
    poConfig->Write( wxT( "Iconized" ),  (long)IsIconized() );
    if( IsIconized() )
    {
        Iconize( false );
    }

    // Save maximization state.
    poConfig->Write( wxT( "Maximized" ),  (long)IsMaximized() );
    if( IsMaximized() )
    {
        Maximize( false );
        ::wxSafeYield();
        ::wxSafeYield();
    }

    // Save full screen state.
    poConfig->Write( wxT( "FullScreen" ),  (long)IsFullScreen() );
    if( IsFullScreen() )
    {
        ToggleFullScreen();
        ::wxSafeYield();
        ::wxSafeYield();
        ::wxSafeYield();
    }

    // Save window position and size.
    //
    int x, y, w, h;

    GetSize( &w, &h );
    GetPosition( &x, &y );
    poConfig->Write( wxT( "x" ), (long)x );
    poConfig->Write( wxT( "y" ), (long)y );
    poConfig->Write( wxT( "w" ), (long)w );
    poConfig->Write( wxT( "h" ), (long)h );

    // Save the sash positions.
    poConfig->Write( wxT( "HSashPos" ), (long)m_poHSplitterWindow->GetSashPosition() );
    poConfig->Write( wxT( "VSashPos" ), (long)m_poVSplitterWindow->GetSashPosition() );

    // Save the resolution as standard resolution.
    poConfig->Write( wxT( "Resolution" ), (long)m_nResolution );

    // ...
    poConfig->Write( wxT( "PaperSize" ), (long)m_oPrintData.GetPaperId() );
    poConfig->Write( wxT( "Fit" ), (long)m_nFit );
    poConfig->Write( wxT( "ScaleFactor" ), m_nScaleFactor );
    poConfig->Write( wxT( "ZoomFactor" ), m_nZoomFactor );

    // ...
    poConfig->Write( wxT( "BitmapMimeType" ), m_strBitmapMimeType );

#if __WXPDFDOC__
    // ...
    poConfig->Write( wxT( "PdfBitmapMimeType" ), m_strPdfBitmapMimeType );
#endif // __WXPDFDOC__

    // ...
    poConfig->Write( wxT( "AutoApplyProfile" ), (long)m_bAutoApplyProfile );
    poConfig->Write( wxT( "AutoApplyProfileOnMultiPage" ), (long)m_bAutoApplyProfileOnMultiPage );
    poConfig->Write( wxT( "OCR" ), (long)m_bOCR );
#if __WXLUASCRIPT__
    poConfig->Write( wxT( "Lua" ), (long)m_bLua );
#endif // __WXLUASCRIPT__
    poConfig->Write( wxT( "CmdConvertEnable" ), (long)m_bCmdConvertEnable );
    poConfig->Write( wxT( "CmdConvert" ), m_strCmdConvert );
    poConfig->Write( wxT( "CmdOcrEnable" ), (long)m_bCmdOcrEnable );
    poConfig->Write( wxT( "CmdOcr" ), m_strCmdOcr );
    poConfig->Write( wxT( "OcrOutputExtension" ), m_strOcrOutputExtension );
    poConfig->Write( wxT( "CmdCleanUpEnable" ), (long)m_bCmdCleanUpEnable );
    poConfig->Write( wxT( "CmdCleanUp" ), m_strCmdCleanUp );
    poConfig->Write( wxT( "CmdTtsEnable" ), (long)m_bCmdTtsEnable );
    poConfig->Write( wxT( "CmdTts" ), m_strCmdTts );
    poConfig->Write( wxT( "CmdEditEnable" ), (long)m_bCmdEditEnable );
    poConfig->Write( wxT( "CmdEdit" ), m_strCmdEdit );
    poConfig->Write( wxT( "HocrEnable" ), (long)m_bHocrEnable );
    poConfig->Write( wxT( "HocrClass" ), m_strHocrClass );
    poConfig->Write( wxT( "SmartHocrEnable" ), (long)m_bSmartHocrEnable );
    poConfig->Write( wxT( "CmdOcrUseHocr" ), m_strCmdOcrUseHocr );
    poConfig->Write( wxT( "OcrOutputExtensionHocr" ), m_strOcrOutputExtensionHocr );
    poConfig->Write( wxT( "CmdHtml2XhtmlEnable" ), (long)m_bCmdHtml2XhtmlEnable );
    poConfig->Write( wxT( "CmdHtml2Xhtml" ), m_strCmdHtml2Xhtml );
    poConfig->Write( wxT( "CmdHocrCleanUpEnable" ), (long)m_bCmdHocrCleanUpEnable );
    poConfig->Write( wxT( "CmdHocrCleanUp" ), m_strCmdHocrCleanUp );

    // ...
    poConfig->Write( wxT( "ProfileIndex" ), m_nProfileIndex );

    // Save file history to config file.
    poConfig->SetPath( wxT( "/Files" ) );
    m_oFileHistory.Save( *poConfig );
}

// Printing support.
//
// Paints the image while printing or print previewing.
//
// NOTE: The painting on the screen is done by void wxIViewCanvas::Paint( wxDC& oDc )!
//
bool wxIScanFrame::Paint( wxDC& oDc )
{
    // If there is a bitmap connected to this canvas window (re)paint it.
#if wxCHECK_VERSION( 2, 9, 0 )
    if( oDc.IsOk() && m_oPrintImage.Ok() )
#else
    if( oDc.Ok() && m_oPrintImage.Ok() )
#endif // wxCHECK_VERSION( 2, 9, 0 )

    {
        // Repaint the bitmap.
        oDc.DrawBitmap( wxBitmap( m_oPrintImage ), 0, 0 );
        return true;
    }
    else
    {
        return false;
    }
}

// Calculates the image extents in mm while printing or print previewing.
//
bool wxIScanFrame::GetPageSizeMM( int *pnWidth, int *pnHeight )
{
     if( m_oPrintImage.Ok() )
     {
         (*pnWidth)=  (int)( (double)m_oPrintImage.GetWidth()  / (double)m_nResolution * 25.4 );
         (*pnHeight)= (int)( (double)m_oPrintImage.GetHeight() / (double)m_nResolution * 25.4 );
         return true;
     }
     else
     {
         return false;
     }
}

// Go to a given printer page.
//
bool wxIScanFrame::GotoPage( int nPage )
{
    // NOTE: The wxPrintOut object passes pages one-based. We need it
    //        zero-based. Therefore we decrement the page number by 1.
    //
    nPage--;

    // Avoid loading an already loaded image.
    if( nPage == m_nPage )
    {
        m_oPrintImage= m_oImage;
        return true;
    }
    else
    {
        return m_oPrintImage.LoadFile( m_strImageFileName, wxBITMAP_TYPE_ANY, nPage );
    }
}