prdlgctl.cpp

Go to the documentation of this file.

// $Id: prdlgctl.cpp 1742 2006-09-05 17:25:58Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */
// Custom Print Dialog

/*
*/

#include "camtypes.h"

//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "prdlgctl.h"
//#include "printdlg.h"
#include "printprg.h"
#include "princomp.h"
#include "optsprin.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "printmsg.h"
#include "prnprefs.h"   // PrintPrefsDlg;;InvokeDialog
#include "helpuser.h"
#include "camelot.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ccdc.h"
#include "ctrlhelp.h"
//#include "richard2.h"
#include "progress.h"
//#include "markn.h"
#include "unicdman.h"
//#include "fonts.h"
#include "printctl.h"
#include "prnmks.h"
#include "psdc.h"
//#include "jason.h"        // Error messages
//#include "resource.h" // _R(IDS_OK)/CANCEL
//#include "simon.h"        // _R(IDS_HELP)

#ifdef _DEBUG
#include "optsprin.h"
#include "keypress.h"
#endif

#define Swap(a,b)       { (a)^=(b), (b)^=(a), (a)^=(b); }

PORTNOTE("printing", "Disabled message map stuff")
#ifndef EXCLUDE_FROM_XARALX
//---------------------------------

//  WEBSTER-ranbirr-12/11/96
#ifndef WEBSTER
BEGIN_MESSAGE_MAP(CCPrintDialog, CPrintDialog)
    //{{AFX_MSG_MAP(CPrintDialog)
    ON_COMMAND_EX(_R(IDC_ALLOBJECTS),       OnCommand)
    ON_COMMAND_EX(_R(IDC_SELECTEDOBJECTS),  OnCommand)
    ON_COMMAND_EX(_R(IDC_DPSBOTH),          OnCommand)
    ON_COMMAND_EX(_R(IDC_DPSLEFTPAGES),     OnCommand)
    ON_COMMAND_EX(_R(IDC_DPSRIGHTPAGES),    OnCommand)
    ON_COMMAND_EX(_R(IDC_PRINTOPTIONS),     OnCommand)
    ON_COMMAND_EX(_R(IDC_PRINTHELP),        OnCommand)
    ON_COMMAND(psh1, OnPrintSetup) // print setup button when print is displayed
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

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

#endif //webster
#endif

IMPLEMENT_DYNAMIC_CLASS(CCPrintDialog, wxPrintDialog)
CC_IMPLEMENT_DYNAMIC(PrintMsg,Msg)


//---------------------------------
// This is the new Win95-compatible DOCINFO structure that has two extra fields, lpszDatatype & fwType.
// We don't have the new header files yet, so we need to implement this struct ourselves.
// This new struct is utilised by the func CCPrintInfo::SetUpDocInfo(DOCINFO* pDocInfo)

typedef struct _NEW_DOCINFOA {
    INT32     cbSize;
    LPCSTR   lpszDocName;
    LPCSTR   lpszOutput;
    LPCSTR   lpszDatetype;
    DWORD    fwType;
} NEW_DOCINFOA;
typedef struct _NEW_DOCINFOW {
    INT32     cbSize;
    LPCWSTR  lpszDocName;
    LPCWSTR  lpszOutput;
    LPCWSTR  lpszDatetype;
    DWORD    fwType;
} NEW_DOCINFOW;
#ifdef UNICODE
typedef NEW_DOCINFOW NEW_DOCINFO;
#else
typedef NEW_DOCINFOA NEW_DOCINFO;
#endif // UNICODE

#ifndef DI_APPBANDING
#define DI_APPBANDING   0x0001
#endif

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

// CCPrintDialog static vars
//CCPrintDialog* CCPrintDialog::pInfoPrintDlg = NULL;       // Used to get settings for the default printer
//  WEBSTER-ranbirr-12/11/96
#ifndef WEBSTER

BOOL    CCPrintDialog::GotPrinterSettings   = FALSE;
wxSize  CCPrintDialog::PrPaperSize;
BOOL    CCPrintDialog::PrPortrait           = TRUE;
INT32   CCPrintDialog::PrScale              = 100;
BOOL    CCPrintDialog::PrMultiCopies        = FALSE;

INT32   CCPrintDialog::PrResolution         = 300;
INT32   CCPrintDialog::PrResolutionX        = 300;
INT32   CCPrintDialog::PrResolutionY        = 300;

INT32   CCPrintDialog::PrLeftMargin         = 0;    //0x32a0;
INT32   CCPrintDialog::PrTopMargin          = 0;    //0x2ee0;
INT32   CCPrintDialog::PrRightMargin        = 0;    //0x3750;
INT32   CCPrintDialog::PrBottomMargin       = 0;    //0x2ee0;

BOOL    CCPrintDialog::PrPostscript         = FALSE;

BOOL    CCPrintDialog::ReopenMainDlg        = FALSE;
BOOL    CCPrintDialog::InformPrinterReset   = FALSE;
BOOL    CCPrintDialog::IgnorePrntData       = FALSE;

wxPrintDialogData CCPrintInfo::m_DefaultDialogData;
BOOL CCPrintInfo::m_HaveSavedDefaultDialogData = FALSE;


CCPrintInfo*   CCPrintInfo::pCurrent            = NULL; // Ptr to the last constructed CCPrintInfo
#endif //webster

#ifndef EXCLUDE_FROM_XARALX
TCHAR   CCPrintToFileDialog::FileName[FILENAMEBUFSIZE]  = {_T('\0')};
//  WEBSTER-ranbirr-12/11/96
#ifndef WEBSTER
CCPrintDialog* CCPrintDialog::pCurrentCCPrintDialog = NULL;
wxPrintDialog*  CCPrintDialog::pDlgSetup                = NULL;
#endif //webster
#endif

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

// Paper selections
// This data is taken from wingdi.h and defines the sizes of all the default paper size values
// that appear in the dmPaperSize member of DEVMODE
//
// If dmPaperSize is zero, dmPaperLength and dmPaperWidth define the paper size (in tenths of a millimetre)
//
// NOTE: The code must be tested on a dot matrix printer because the dmPaperLength can be arbitrary.
//
// NOTE: I have not found an automatic way of finding out the dimensions of a particular paper size.
// The closest I got was to use OpenPrinter() to get a handle of a printer, then use GetForm() to retrieve
// the dimensions of a paper size given the name of the paper (e.g. "A4").  However MSDN says that neither of
// these functions are supported under Win32s.

#define IN_TO_MP(n) (MILLIPOINT((double(IN_MP_VAL)*n)+0.5))
#define MM_TO_MP(n) (MILLIPOINT((double(MM_MP_VAL)*n)+0.5))

//#define wxPAPER_LISTEND (wxPAPER_LAST+1)
#define wxPAPER_LISTEND ((UINT32)(-1))

struct PaperSizesType
{
    UINT32      ID;
    MILLIPOINT  Width;
    MILLIPOINT  Height;
} pPaperSizes[] = 
{
    { wxPAPER_LETTER,       IN_TO_MP(8.5),      IN_TO_MP(11)    },  // Letter 8 1/2 x 11 in               
    { wxPAPER_LETTERSMALL,  IN_TO_MP(8.5),      IN_TO_MP(11)    },  // Letter Small 8 1/2 x 11 in         
    { wxPAPER_TABLOID,      IN_TO_MP(11),       IN_TO_MP(17)    },  // Tabloid 11 x 17 in                 
    { wxPAPER_LEDGER,       IN_TO_MP(17),       IN_TO_MP(11)    },  // Ledger 17 x 11 in                  
    { wxPAPER_LEGAL,        IN_TO_MP(8.5),      IN_TO_MP(14)    },  // Legal 8 1/2 x 14 in                
    { wxPAPER_STATEMENT,    IN_TO_MP(5.5),      IN_TO_MP(8.5)   },  // Statement 5 1/2 x 8 1/2 in         
    { wxPAPER_EXECUTIVE,    IN_TO_MP(7.25),     IN_TO_MP(10.5)  },  // Executive 7 1/4 x 10 1/2 in        

    { wxPAPER_A3,           MM_TO_MP(297),      MM_TO_MP(420)   },  // A3 297 x 420 mm                    
    { wxPAPER_A4,           MM_TO_MP(210),      MM_TO_MP(297)   },  // A4 210 x 297 mm                    
    { wxPAPER_A4SMALL,      MM_TO_MP(210),      MM_TO_MP(297)   },  // A4 Small 210 x 297 mm              
    { wxPAPER_A5,           MM_TO_MP(148),      MM_TO_MP(210)   },  // A5 148 x 210 mm                    
    { wxPAPER_B4,           MM_TO_MP(250),      MM_TO_MP(354)   },  // B4 250 x 354                       
    { wxPAPER_B5,           MM_TO_MP(182),      MM_TO_MP(257)   },  // B5 182 x 257 mm                    

    { wxPAPER_FOLIO,        IN_TO_MP(8.5),      IN_TO_MP(13)    },  // Folio 8 1/2 x 13 in                
    { wxPAPER_QUARTO,       MM_TO_MP(215),      MM_TO_MP(275)   },  // Quarto 215 x 275 mm                
    { wxPAPER_10X14,        IN_TO_MP(10),       IN_TO_MP(14)    },  // 10x14 in                           
    { wxPAPER_11X17,        IN_TO_MP(11),       IN_TO_MP(17)    },  // 11x17 in                           
    { wxPAPER_NOTE,         IN_TO_MP(8.5),      IN_TO_MP(11)    },  // Note 8 1/2 x 11 in                 

    { wxPAPER_ENV_9,        IN_TO_MP(3.875),    IN_TO_MP(8.875) },  // Envelope #9 3 7/8 x 8 7/8 in
    { wxPAPER_ENV_10,       IN_TO_MP(4.125),    IN_TO_MP(9.5)   },  // Envelope #10 4 1/8 x 9 1/2 in        
    { wxPAPER_ENV_11,       IN_TO_MP(4.5),      IN_TO_MP(10.375)},  // Envelope #11 4 1/2 x 10 3/8 in       
    { wxPAPER_ENV_12,       IN_TO_MP(4.75),     IN_TO_MP(11)    },  // Envelope #12 4 3/4 x 11 in          
    { wxPAPER_ENV_14,       IN_TO_MP(5),        IN_TO_MP(11.5)  },  // Envelope #14 5 x 11 1/2 in           

    { wxPAPER_CSHEET,       IN_TO_MP(17),       IN_TO_MP(22)    },  // C size sheet 17 x 22 in
    { wxPAPER_DSHEET,       IN_TO_MP(22),       IN_TO_MP(34)    },  // D size sheet 22 x 34 in
    { wxPAPER_ESHEET,       IN_TO_MP(34),       IN_TO_MP(44)    },  // E size sheet 34 x 44 in

    { wxPAPER_ENV_DL,       MM_TO_MP(110),      MM_TO_MP(220)   },  // Envelope DL 110 x 220mm            
    { wxPAPER_ENV_C5,       MM_TO_MP(162),      MM_TO_MP(229)   },  // Envelope C5 162 x 229 mm           
    { wxPAPER_ENV_C3,       MM_TO_MP(324),      MM_TO_MP(458)   },  // Envelope C3  324 x 458 mm          
    { wxPAPER_ENV_C4,       MM_TO_MP(229),      MM_TO_MP(324)   },  // Envelope C4  229 x 324 mm          
    { wxPAPER_ENV_C6,       MM_TO_MP(114),      MM_TO_MP(162)   },  // Envelope C6  114 x 162 mm          
    { wxPAPER_ENV_C65,      MM_TO_MP(114),      MM_TO_MP(229)   },  // Envelope C65 114 x 229 mm          

    { wxPAPER_ENV_B4,       MM_TO_MP(250),      MM_TO_MP(353)   },  // Envelope B4  250 x 353 mm          
    { wxPAPER_ENV_B5,       MM_TO_MP(176),      MM_TO_MP(250)   },  // Envelope B5  176 x 250 mm          
    { wxPAPER_ENV_B6,       MM_TO_MP(176),      MM_TO_MP(125)   },  // Envelope B6  176 x 125 mm          
    { wxPAPER_ENV_ITALY,    MM_TO_MP(110),      MM_TO_MP(230)   },  // Envelope 110 x 230 mm              

    { wxPAPER_ENV_MONARCH,  IN_TO_MP(3.875),    IN_TO_MP(7.5)   },  // Envelope Monarch 3.875 x 7.5 in    
    { wxPAPER_ENV_PERSONAL, IN_TO_MP(3.625),    IN_TO_MP(6.5)   },  // 6 3/4 Envelope 3 5/8 x 6 1/2 in    

    { wxPAPER_FANFOLD_US,           IN_TO_MP(14.875),   IN_TO_MP(11)    },  // US Std Fanfold 14 7/8 x 11 in      
    { wxPAPER_FANFOLD_STD_GERMAN,   IN_TO_MP(8.5),      IN_TO_MP(12)    },  // German Std Fanfold 8 1/2 x 12 in   
    { wxPAPER_FANFOLD_LGL_GERMAN,   IN_TO_MP(8.5),      IN_TO_MP(13)    },  // German Legal Fanfold 8 1/2 x 13 in 

#if(WINVER >= 0x0400)
    { wxPAPER_ISO_B4,               MM_TO_MP(250),      MM_TO_MP(353)   },  // B4 (ISO) 250 x 353 mm
    { wxPAPER_JAPANESE_POSTCARD,    MM_TO_MP(100),      MM_TO_MP(148)   },  // Japanese Postcard 100 x 148 mm     
    { wxPAPER_9X11,                 IN_TO_MP(9),        IN_TO_MP(11)    },  // 9 x 11 in                          
    { wxPAPER_10X11,                IN_TO_MP(10),       IN_TO_MP(11)    },  // 10 x 11 in                         
    { wxPAPER_15X11,                IN_TO_MP(15),       IN_TO_MP(11)    },  // 15 x 11 in                         
    { wxPAPER_ENV_INVITE,           MM_TO_MP(220),      MM_TO_MP(220)   },  // Envelope Invite 220 x 220 mm       
//  { wxPAPER_RESERVED_48,          MM_TO_MP(250),      MM_TO_MP(353)   },  // RESERVED--DO NOT USE               
//  { wxPAPER_RESERVED_49,          MM_TO_MP(250),      MM_TO_MP(353)   },  // RESERVED--DO NOT USE               
    { wxPAPER_LETTER_EXTRA,         IN_TO_MP(9.5),      IN_TO_MP(12)    },  // Letter Extra 9 \275 x 12 in        
    { wxPAPER_LEGAL_EXTRA,          IN_TO_MP(9.5),      IN_TO_MP(15)    },  // Legal Extra 9 \275 x 15 in         
    { wxPAPER_TABLOID_EXTRA,        IN_TO_MP(11.69),    IN_TO_MP(18)    },  // Tabloid Extra 11.69 x 18 in        
    { wxPAPER_A4_EXTRA,             IN_TO_MP(9.27),     IN_TO_MP(12.69) },  // A4 Extra 9.27 x 12.69 in           
    { wxPAPER_LETTER_TRANSVERSE,    IN_TO_MP(8.5),      IN_TO_MP(11)    },  // Letter Transverse 8 \275 x 11 in   
    { wxPAPER_A4_TRANSVERSE,        MM_TO_MP(210),      MM_TO_MP(297)   },  // A4 Transverse 210 x 297 mm         
    { wxPAPER_LETTER_EXTRA_TRANSVERSE,IN_TO_MP(9.5),    IN_TO_MP(12)    },  // Letter Extra Transverse 9\275 x 12 in 
    { wxPAPER_A_PLUS,               MM_TO_MP(227),      MM_TO_MP(356)   },  // SuperA/SuperA/A4 227 x 356 mm      
    { wxPAPER_B_PLUS,               MM_TO_MP(305),      MM_TO_MP(487)   },  // SuperB/SuperB/A3 305 x 487 mm      
    { wxPAPER_LETTER_PLUS,          IN_TO_MP(8.5),      IN_TO_MP(12.69) },  // Letter Plus 8.5 x 12.69 in         
    { wxPAPER_A4_PLUS,              MM_TO_MP(210),      MM_TO_MP(330)   },  // A4 Plus 210 x 330 mm               
    { wxPAPER_A5_TRANSVERSE,        MM_TO_MP(148),      MM_TO_MP(210)   },  // A5 Transverse 148 x 210 mm         
    { wxPAPER_B5_TRANSVERSE,        MM_TO_MP(182),      MM_TO_MP(257)   },  // B5 (JIS) Transverse 182 x 257 mm   
    { wxPAPER_A3_EXTRA,             MM_TO_MP(322),      MM_TO_MP(445)   },  // A3 Extra 322 x 445 mm              
    { wxPAPER_A5_EXTRA,             MM_TO_MP(174),      MM_TO_MP(235)   },  // A5 Extra 174 x 235 mm              
    { wxPAPER_B5_EXTRA,             MM_TO_MP(201),      MM_TO_MP(276)   },  // B5 (ISO) Extra 201 x 276 mm        
    { wxPAPER_A2,                   MM_TO_MP(420),      MM_TO_MP(594)   },  // A2 420 x 594 mm                    
    { wxPAPER_A3_TRANSVERSE,        MM_TO_MP(297),      MM_TO_MP(420)   },  // A3 Transverse 297 x 420 mm         
    { wxPAPER_A3_EXTRA_TRANSVERSE,  MM_TO_MP(322),      MM_TO_MP(445)   },  // A3 Extra Transverse 322 x 445 mm   
#endif 

    { wxPAPER_LISTEND,0,0 }
};

//---------------------------------
void Beep();
//---------------------------------

//  WEBSTER-ranbirr-12/11/96
#ifndef WEBSTER


/********************************************************************************************

>   CCPrintDialog::CCPrintDialog(Document* pDoc,BOOL PrintSetUpOnly = FALSE)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/95
    Inputs:     pDoc           = ptr to the document this print dialog is associated with
                PrintSetUpOnly = TRUE if you only want the print setup dialog only
    Purpose:    Creates a camelot print dialog, based on CPrintDialog
    SeeAlso:    CCPrintInfo

********************************************************************************************/

CCPrintDialog::CCPrintDialog(CCPrintInfo * pDialogData, Document* pDoc,BOOL PrintSetUpOnly) : wxPrintDialog(NULL, pDialogData)
{
    pDocument = pDoc;
    PrintPrefsOpen      = FALSE;
    PrintPrefsChanged   = FALSE;
}


/********************************************************************************************

>   CCPrintDialog::~CCPrintDialog()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/95
    Inputs:     -
    Purpose:    Default destructor
                This deletes the member DC using ::DeleteDC() as instructed by the help on 
                CPrintDialog::GetPrinterDC() (only if the DC is not NULL of course)

                Why CPrintDialog doesn't have a destructor to do this is a mystery.  I think it relies
                on you using CPrintInfo who's destructor DOES delete the DC if need be.

    SeeAlso:    CCPrintInfo

********************************************************************************************/

CCPrintDialog::~CCPrintDialog()
{
}

/********************************************************************************************

>   PrintControl* CCPrintDialog::GetPrintControl()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/4/95
    Inputs:     -
    Returns:    Ptr to the print control
    Purpose:    Returns the ptr to the print control attached to the doc associated with this dialog
    SeeAlso:    CCPrintInfo

********************************************************************************************/

PrintControl* CCPrintDialog::GetPrintControl()
{
    PrintControl* pPrCtrl = NULL;

    if (pDocument != NULL)
    {
        PrintComponent* pComp = (PrintComponent*)pDocument->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent));

        if (pComp != NULL)
            pPrCtrl = pComp->GetPrintControl();
    }

    ERROR3IF(pPrCtrl == NULL,"Unable to find the print control object");

    return pPrCtrl;
}

// Here's how we might one-day run help

// Yes, run the help system and don't process this message any more.  As we don't
// have any C++ object associated with the Print Problems page we must use the
// bodgey raw help function here.
// _HelpUser(TEXT("PrintProblems"));
// _HelpUser(TEXT("CCPrintSetupDialog"));

#ifndef EXCLUDE_FROM_XARALX

/********************************************************************************************

>   INT32 CCPrintDialog::DoModal()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/3/95
    Inputs:     -
    Returns:    See CPrintDialog::DoModal() for return values
    Purpose:    This calls CPrintDialog::DoModal() and returns the value that it returns

                This func allows us to detect when the print dialog has been displayed, and which
                button the user clicked on to close it (i.e. OK or Cancel)

    SeeAlso:    CPrintDialog::DoModal

********************************************************************************************/

INT32 CCPrintDialog::DoModal()
{
    ERROR2IF(pDocument == NULL,IDCANCEL,"NULL doc ptr");

    ERROR3IF(pCurrentCCPrintDialog != NULL,"pCurrentCCPrintDialog is not NULL");
    pCurrentCCPrintDialog = this;

    // Get a copy of the print control in the associated document
    PrintControl* pPrCtrl = GetPrintControl();
    ERROR2IF(pPrCtrl == NULL,IDCANCEL,"Unable to find the print control");
    LocalPrintControl = *pPrCtrl;

    // Inform the user if we have switched to using the default printer on the system
    InformResetToDefaultPrinter(FALSE);

    // Initialise the custom dlg template
    ERROR2IF(!InitCustomDlg(),IDCANCEL,"Unable to init the print dlg with our custom template");

    // Update our details about this printer
    UpdatePrinterSettings(FALSE);

    // Set the print control to print the selected spread
    // Do this after UpdatePrinterSettings() to make sure it uses the right values!
    LocalPrintControl.SetUp(Document::GetSelectedSpread());

    // Display the dlg to the user, and return the result
    BOOL ok = FALSE;
    BOOL Reopen = FALSE;
    do
    {
        // If we are reopening the main print dlg, update the printer settings first
        // (NB: This should only happen in Win3.1 after the print setup dlg has been used. 
        //  See CCPrintDialog::OnPrintSetup())
        if (Reopen)
            UpdatePrinterSettings();

        // Keep Control Helper system informed
        ControlHelper::InformModalDialogOpened();

        // Open the main print dlg (uses ::PrintDlg() in the depths of MFC)
        ok = CPrintDialog::DoModal();
        FixFPControlRegister();

        // Keep Control Helper system informed
        ControlHelper::InformModalDialogClosed();

        Reopen = ReopenMainDlg;     // Do we need to reopen the main print dlg?
        ReopenMainDlg = FALSE;      // Make sure this flag is cleared, or we'll be here all day

    } while (Reopen);

    // If we are to ignore the printer data (because the selected printer has been deleted, renamed, etc)
    // then we must reset the global memory handles that hold the data, as the settings they contain
    // no longer refer to a printer known by the host system
    if (IgnorePrintData())
    {
        FreeGlobalHandle(&m_pd.hDevMode);
        FreeGlobalHandle(&m_pd.hDevNames);
        ResetIgnorePrintData();
    }

    ERROR3IF(pCurrentCCPrintDialog == NULL,"pCurrentCCPrintDialog is NULL");
    pCurrentCCPrintDialog = NULL;

    return ok;
}
#endif

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

/********************************************************************************************

>   static BOOL CCPrintDialog::GetPrinterSettings(BOOL RedrawPrintBorders = TRUE)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/4/95
    Inputs:     RedrawPrintBorders if a force redraw should be issued (Defaults to TRUE)
    Returns:    TRUE if OK, FALSE otherwise
    Purpose:    This function ensures that we have a valid set of printer settings.

                If this is the first time this function has been called, it uses a CCPrintDialog
                to get the default settings from the printer driver.

                If we already have a set of valid settings, this func does nothing

    SeeAlso:    -

********************************************************************************************/

BOOL CCPrintDialog::GetPrinterSettings(BOOL RedrawPrintBorders)
{
    if (!GotPrinterSettings)
    {
        Progress Hourglass(_R(IDS_UPDATE_PRINTER_SETTINGS),-1,FALSE);
        Hourglass.Update();

        CCPrintInfo * pPrintInfo = CCPrintInfo::GetCurrent();
        BOOL Local=FALSE;
        if (!pPrintInfo)
        {
            pPrintInfo = new CCPrintInfo(Document::GetSelected(), NULL);
            ERROR2IF(!pPrintInfo, FALSE, "Cannot get print info");
            Local = TRUE;
        }
        
        //CCPrintDialog PrintDlg(pPrintInfo);       // Use CCPrintDialog to get hold of printer's DEVMODE settings

        pPrintInfo->UpdatePrinterSettings(RedrawPrintBorders);

        if (Local)
            delete pPrintInfo;

    }

    return (GotPrinterSettings);
}

/********************************************************************************************

>   static void CCPrintDialog::ResetToDefaultPrinter()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/2/96
    Inputs:     -
    Returns:    -
    Purpose:    Use this function to tell the printing system that the printer data has been reset
                so that it will use the default printer next time you print.

                If there are any print-related dialogs open, they will be closed.

                If a dialog is closed, the function will display a warning to the user.

                If a dialog is not closed, a flag is set so that the warning will be displayed when 
                the user next tries to print something.

    SeeAlso:    CCamApp::ResetToDefaultPrinter()

********************************************************************************************/

void CCPrintDialog::ResetToDefaultPrinter()
{
    if (GotPrinterSettings)
    {
        GotPrinterSettings = FALSE;         // We need new printer settings
        InformPrinterReset = TRUE;          // We need to inform the use about what's happening

        // Close any print dlgs that may be open
        ClosePrintDialogs();

        // Get the default printer settings
        GetPrinterSettings();
    }
}

/********************************************************************************************

>   static void CCPrintDialog::ClosePrintDialogs()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/2/96
    Inputs:     -
    Returns:    -
    Purpose:    Closes any print-related dlgs that may be open.
                If any dlgs are closed, and it is due to resetting to the default printer,
                a warning will be issued to the user informing them of this fact.

    SeeAlso:    static BOOL ResetToDefaultPrinter()

********************************************************************************************/

void CCPrintDialog::ClosePrintDialogs()
{
    // Close the print prefs tabbed dlg
    PrintPrefsDlg::CloseCurrentDlg();

#ifndef EXCLUDE_FROM_XARALX
    // Close the print setup dlg that's opened from the main print dlg
    if (pDlgSetup != NULL)
    {
        IgnorePrntData = TRUE;  // We are forcing the closure of the print dlgs
        // Inform the user if we have switched to using the default printer on the system
        // before closing dialog
        InformResetToDefaultPrinter(TRUE);
        delete pDlgSetup;
        pDlgSetup = NULL;
    }

    // Close the main print dlg
    if (pCurrentCCPrintDialog != NULL)
    {
        IgnorePrntData = TRUE;  // We are forcing the closure of the print dlgs
        // Inform the user if we have switched to using the default printer on the system
        // before closing dialog
        InformResetToDefaultPrinter(TRUE);
        delete pCurrentCCPrintDialog;
        pCurrentCCPrintDialog = NULL;
    }
#endif

}

#endif

/********************************************************************************************

>   static void CCPrintDialog::InformResetToDefaultPrinter(BOOL ClosingDlgs)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/2/96
    Inputs:     ClosingDlgs - TRUE if the caller will also close any print dlgs too.
    Returns:    -
    Purpose:    Displays a warning to the user saying that we have switched to the default printer.

                It only does this if the flag InformPrinterReset is TRUE.
                
                After displaying the warning, InformPrinterReset is set to FALSE, so you can call this
                func as often as you like - it will only get displayed once until the next time we
                switch to the default printer.

                If this is called just before closing any print dlgs, call with ClosingDlgs=TRUE.
                This will display a slightly different warning explaining the dlgs will be closed.

    SeeAlso:    static BOOL ResetToDefaultPrinter()

********************************************************************************************/

void CCPrintDialog::InformResetToDefaultPrinter(BOOL ClosingDlgs)
{
    if (InformPrinterReset)
    {
        if (ClosingDlgs)
            InformWarning(_R(IDS_RESET_PRINTER_REOPEN));
        else
            InformWarning(_R(IDS_RESET_PRINTER));

        InformPrinterReset = FALSE;
    }
}

#ifndef EXCLUDE_FROM_XARALX

/********************************************************************************************

>   static void CCPrintDialog::GetSelectedPrinterName(LPTSTR pName,INT32 BufferSize)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/2/96
    Inputs:     pName = ptr to buffer to place name in
                BufferSize = size of buffer pointed to by BufferSize
    Returns:    -
    Purpose:    This will return what is considered to be the name of the app's selected printer

                If the main print dlg or the print setup dlg (opened via the File menu) are open,
                the name is taken from them.

                Otherwise, the app's cached printer data is used, and this is gained vai CCamApp::GetDevNames()

                If no printer is found, pName == "" (i.e. pName[0] == 0).

    SeeAlso:    static BOOL ResetToDefaultPrinter()

********************************************************************************************/

void CCPrintDialog::GetSelectedPrinterName(LPTSTR pName,INT32 BufferSize)
{
    // Enough of these silly values
    ERROR3IF(pName == NULL || BufferSize < 1,"How about some senisble input params eh?");
    if (pName == NULL || BufferSize < 1)
        return;

    CCamApp *pCamApp = (CCamApp *)AfxGetApp();
    
    // Default to the app's DEVMODE structure
    HGLOBAL hDevNames = NULL;
    if(pCamApp != NULL)
        hDevNames = pCamApp->GetDevNames();

    // If we have a main print dlg up, look at the selected printer within the dlg
    if (pCurrentCCPrintDialog != NULL)
        hDevNames = pCurrentCCPrintDialog->m_pd.hDevNames;

    // If we have the print setup dlg open from the file menu, look at the selected printer within it
    if (pCamApp != NULL && pCamApp->GetFilePrintSetupDlg() != NULL)
        hDevNames = pCamApp->GetFilePrintSetupDlg()->m_pd.hDevNames;

    // NULL terminate now, just in case things go wrong
    pName[0] = 0;

    if (hDevNames != NULL)
    {
        // Get a ptr to the memory block defined by hDevNames
        DEVNAMES* pDevNames = (DEVNAMES*)::GlobalLock(hDevNames);
        if (pDevNames != NULL)
        {
            // Copy the name from the DEVNAMES field into the buffer provided
            camStrncpy(pName,LPTSTR(pDevNames) + pDevNames->wDeviceOffset,BufferSize);
            ::GlobalUnlock(hDevNames);
        }
    }
}

#endif

/********************************************************************************************

>   BOOL CCPrintInfo::UpdatePrinterSettings(BOOL RedrawPrintBorders = TRUE)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/4/95
    Inputs:     RedrawPrintBorders = TRUE if you want any visible print borders redrawing
    Returns:    TRUE if ok, FALSE otherwise
    Purpose:    Updates the static members that represent the current printer settings Camelot
                is interested in, such a paper size, orientation, etc.
                It uses the DEVMODE structure returned by GetDevMode(), plus member funcs for
                driver, device and port names.

                This sets the static member GotPrinterSettings to TRUE if successful

    SeeAlso:    static BOOL UpdatePrinterSettings()

********************************************************************************************/

BOOL CCPrintInfo::UpdatePrinterSettings(BOOL RedrawPrintBorders)
{
    wxDC * dc = MakeDCFromPrintData(&GetPrintData());
    BOOL ret=CCPrintDialog::UpdatePrinterSettings(m_pNativePrintData,dc,pDocument,RedrawPrintBorders);
    delete dc;
    return ret;
}

/********************************************************************************************

>   static BOOL CCPrintDialog::UpdatePrinterSettings(wxPrintData * pPrintData, wxDC * pDC, Document* pDocument, BOOL RedrawPrintBorders)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/4/95
    Inputs:     pDevMode = ptr to a DEVMODE used to extract printer settings from
                hdc      = printer device context (can be NULL)
                pDocument= ptr to associated doc (NULL means use current doc)
                RedrawPrintBorders = TRUE if you want any visible print borders redrawing
    Returns:    TRUE if ok, FALSE otherwise
    Purpose:    Updates the static members that represent the current printer settings Camelot
                is interested in, such a paper size, orientation, etc.

                This sets the static member GotPrinterSettings to TRUE if successful

                It will also redraw all views in the given doc that are showing print borders

    SeeAlso:    -

********************************************************************************************/

BOOL CCPrintDialog::UpdatePrinterSettings(wxPrintData * pPrintData, wxDC * pDC, Document* pDocument, BOOL RedrawPrintBorders)
{
    if (pPrintData == NULL)
    {
        TRACE( _T("CCPrintDialog::UpdatePrinterSettings() - pPrintData is NULL"));
        GotPrinterSettings = FALSE;
        return FALSE;
    }

    BOOL InitPaperSize = FALSE;

    // First, look-up the paper size if we can, as this is more accurate than using the DC to get the
    // physical width & height plus X & Y dpi
    if (!InitPaperSize)
    {
        // The dmPaperSize field has been initialised, so look up the paper dimensions
        // if this value is not 0
        // Note: I discovered a page in MSDN on 7/2/96 that states that a paper size value
        // of wxPAPER_USER means "get size from dmPaperWidth & dmPaperLength"
        if (pPrintData->GetPaperId() != wxPAPER_NONE)
            InitPaperSize = LookUpPaperSize(pPrintData->GetPaperId(),&PrPaperSize);
    }

    // Use the DC to find out the paper size
    if (!InitPaperSize && pDC)
    {
        double xdpi = pDC->GetPPI().GetWidth();     // Get X & Y dots (pixels) per inch
        double ydpi = pDC->GetPPI().GetHeight();

        ERROR3IF(xdpi == 0,"(papersize) xdpi == 0");
        ERROR3IF(ydpi == 0,"(papersize) ydpi == 0");

        // Find the width and height in inches
        double width  =double(pDC->GetSize().GetWidth())  / xdpi; // 2479.0 
        double height =double(pDC->GetSize().GetHeight()) / ydpi; // 3504.0 

        PrPaperSize = wxSize(IN_TO_MP(width), IN_TO_MP(height));
        InitPaperSize = TRUE;
    }

    if (!InitPaperSize)
    {
        // If we still haven't managed to get the paper size, then error in debug builds
        // and set the paper size to a sensible default
        ERROR3("Unable to extract paper size");
        LookUpPaperSize(wxPAPER_A4,&PrPaperSize);
    }

    // ---------------------------------
    // Extract paper orientation
    //

    // Has the orientation field been initialised?
    PrPortrait = (pPrintData->GetOrientation() == wxPORTRAIT);
    
    // ---------------------------------
    // Extract print quality (i.e. resolution in dots per inch)
    //
    // It turns out that the printer quality setting isn't always set in the DEVMODE structure. If this is the
    // case, the hdc param is used to extract the device x & y resolution

    // Set PrResolution to a value that means "yet to find printer resolution"
    PrResolution = -1;

    // Use the DC to find the resolution, in preference to using the DEVMODE structure
    // (Overall DPI is the smallest between the X and Y resolution of the device)
    if (PrResolution <= 0 && pDC)
    {
        PrResolutionX = pDC->GetPPI().GetWidth();
        PrResolutionY = pDC->GetPPI().GetHeight();

        PrResolution = min(PrResolutionX,PrResolutionY);
    }

    // If we failed to get the printer resolution using the DC, try the DEVMODE structure
    if (PrResolution <= 0)
    {
        PrResolution = pPrintData->GetQuality();
        PrResolutionX = PrResolutionY = PrResolution;   // The X & Y res are the same
    }

    // If all else fails, fall back on a default value
    if (PrResolution <= 0)
    {
        ERROR3IF(pDC == NULL,"hdc is NULL. Try supplying one in order to get printer resolution.");
        ERROR3("Unable to find the printer resolution");
        PrResolution = 300;
        PrResolutionX = PrResolutionY = PrResolution;   // The X & Y res are the same
    }

    // ---------------------------------
    // Extract the margins of the printable area on the paper
    // (we can only do this via the DC)

#ifndef EXCLUDE_FROM_XARALX
    if (hdc != NULL)
    {
        // Find out the various printer bits and bobs, all measured in pixels
        double left,top,width,height;

        if (IsWindows31()) //IsWin32s() && !IsWin32c())
        {
            POINT offsets,size;
            ::Escape(hdc,GETPRINTINGOFFSET,NULL,NULL,&offsets);
            ::Escape(hdc,GETPHYSPAGESIZE,NULL,NULL,&size);

            left    = double(offsets.x); // 54.0
            top     = double(offsets.y); // 50.0
            width   = double(size.x);    // 2479.0
            height  = double(size.y);    // 3504.0

            //TRACE( _T("GETPRINTINGOFFSET.x = %ld\n"),offsets.x);
            //TRACE( _T("GETPRINTINGOFFSET.y = %ld\n"),offsets.y);
            //TRACE( _T("GETPHYSPAGESIZE.x   = %ld\n"),size.x);
            //TRACE( _T("GETPHYSPAGESIZE.y   = %ld\n"),size.y);
            //TRACE( _T("\n"));
        }
        else
        {
            left    = double(::GetDeviceCaps(hdc,PHYSICALOFFSETX)); // left margin      // 54.0  
            top     = double(::GetDeviceCaps(hdc,PHYSICALOFFSETY)); // top margin       // 50.0  
            width   = double(::GetDeviceCaps(hdc,PHYSICALWIDTH));   // width of paper   // 2479.0
            height  = double(::GetDeviceCaps(hdc,PHYSICALHEIGHT));  // height of paper  // 3504.0

            //TRACE( _T("PHYSICALOFFSETX = %ld\n"),INT32(left));
            //TRACE( _T("PHYSICALOFFSETY = %ld\n"),INT32(top)); 
            //TRACE( _T("PHYSICALWIDTH   = %ld\n"),INT32(width));   
            //TRACE( _T("PHYSICALHEIGHT  = %ld\n"),INT32(height));
        }

        double hres = double(::GetDeviceCaps(hdc,HORZRES));         // width of printable area              2366.0
        double yres = double(::GetDeviceCaps(hdc,VERTRES));         // height of printable area             3404.0
        double xdpi = double(::GetDeviceCaps(hdc,LOGPIXELSX));      // Get X & Y dots (pixels) per inch     300.0
        double ydpi = double(::GetDeviceCaps(hdc,LOGPIXELSY));      //                                      300.0

        ERROR3IF(xdpi == 0,"xdpi == 0");
        ERROR3IF(ydpi == 0,"ydpi == 0");

        //TRACE( _T("HORZRES         = %ld\n"),INT32(hres));            
        //TRACE( _T("VERTRES         = %ld\n"),INT32(yres));            
        //TRACE( _T("LOGPIXELSX      = %ld\n"),INT32(xdpi));
        //TRACE( _T("LOGPIXELSY      = %ld\n"),INT32(ydpi));

        PrLeftMargin    = IN_TO_MP(left / xdpi);
        PrTopMargin     = IN_TO_MP(top  / ydpi);
        PrRightMargin   = IN_TO_MP((width-hres-left) / xdpi);
        PrBottomMargin  = IN_TO_MP((height-yres-top) / ydpi);
    }
    else
#endif
    {
        PrLeftMargin    = 0;
        PrTopMargin     = 0;
        PrRightMargin   = 0;
        PrBottomMargin  = 0;
    }

    // ---------------------------------
    // Is printer a Postscript printer?
    //
    PrPostscript = pDC->IsKindOf(CLASSINFO(wxPostScriptDC));

#ifndef EXCLUDE_FROM_XARALX
    // ---------------------------------
    // Extract the scale factor
    //
    if (Fields & DM_SCALE)
    {
        PrScale = pDevMode->dmScale;

        // is the value sensible?
        if (PrScale <= 0)
        {
            ERROR3_PF(("Bad printer scale factor (%d)",PrScale));
            PrScale = 100;
        }
    }
    else
#endif
    {
        // We haven't managed to get the print scale, so error in debug builds
        // and set the scale to a sensible default
        //ERROR3("Unable to extract print scale from given DEVMODE");
        PrScale = 100;
    }

    // ---------------------------------
    // Extract the printer's ability to do multiple copies.
    //
    PrMultiCopies = 1; // ((Fields & DM_COPIES) != 0);

    // ---------------------------------
    // Final processing on extracted data 
    //

    if (!PrPortrait)
    {
        // If landscape printing, swap the width and height of the paper to which we will print to
        PrPaperSize=wxSize(PrPaperSize.GetHeight(),PrPaperSize.GetWidth());
    }

    if (PrScale != 100)
    {
        // If the printer driver is applying a scale factor, scale the real paper size to the apparent 
        // size of the paper after scaling

        double w = PrPaperSize.GetWidth();          // w = width of paper
        double h = PrPaperSize.GetHeight();         // h = height of paper
        double f = 100/double(PrScale);     // f = scale factor applied by printer driver

        PrPaperSize = wxSize(MILLIPOINT((w*f)+0.5), MILLIPOINT((h*f)+0.5));
    }

    GotPrinterSettings = TRUE;  // Note that we have a set of valid printer settings now

    // Tell everyone that the print settings have changed
    BROADCAST_TO_ALL(PrintMsg(PrintMsg::SETTINGSCHANGED));

    // Update the document's print control to make sure it recalculates scale factors etc, and
    // redraw any views that are showing their print borders
    if (pDocument == NULL)
        pDocument = Document::GetSelected();

    if (pDocument != NULL)
    {
        PrintControl* pPrCtrl = NULL;
        PrintComponent* pComp = (PrintComponent*)pDocument->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent));
        if (pComp != NULL)
            pPrCtrl = pComp->GetPrintControl();

        if (pPrCtrl != NULL)
            pPrCtrl->SetUp(pDocument->GetSelectedSpread());

        if (RedrawPrintBorders)
        {
            CBitmapCache* pBC = Camelot.GetBitmapCache();
            pBC->DeInitialise();                            // Brute force cache clear

            // Redraw all views that are showing their print borders
            FRDocViewFunc pFunc = PrintControl::RedrawPrintableArea;
            pDocument->ForceRedraw(pFunc);
        }
    }

    return (TRUE);
}



/********************************************************************************************

>   static BOOL CCPrintDialog::IsPostscript()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/6/95
    Inputs:     -
    Returns:    TRUE means the printer is a Postscript printer, FALSE otherwise
    Purpose:    Use this to find out if the printer is a Postscript one or not.
    SeeAlso:    -

********************************************************************************************/

BOOL CCPrintDialog::IsPostscript()
{
PORTNOTE("printing", "Make printer always appear to be postscript")
#ifndef EXCLUDE_FROM_XARALX
    GetPrinterSettings();
    return PrPostscript;
#else
    return TRUE;
#endif
}


/********************************************************************************************

>   static BOOL CCPrintDialog::LookUpPaperSize(UINT32 PaperSizeID,wxSize* pPaperSize)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/4/95
    Inputs:     PaperSizeID = ID of the paper, i.e. wxPAPER_?
                pPaperSize  = ptr to place to put dimensions in (defined in MILLIPOINTS)
    Returns:    TRUE means found, FALSE otherwise
    Purpose:    This looks up the paper size in our table of standard paper sizes, and puts the dimensions
                in pPaperSize.

                If PaperSizeID > 0, and it's not found, then we're in trouble!

    SeeAlso:    -

********************************************************************************************/

BOOL CCPrintDialog::LookUpPaperSize(UINT32 PaperSizeID,wxSize* pPaperSize)
{
    ERROR2IF(pPaperSize == NULL,FALSE,"pPaperSize is NULL");

    for(INT32 i=0;pPaperSizes[i].ID != wxPAPER_LISTEND;i++)
    {
        if (pPaperSizes[i].ID == PaperSizeID)
        {
            *pPaperSize = wxSize(pPaperSizes[i].Width, pPaperSizes[i].Height);
            return TRUE;
        }
    }

    ERROR3_PF(("Couldn't find paper size for paper ID %d",PaperSizeID));

    return FALSE;
}

/********************************************************************************************

>   static BOOL CCPrintDialog::GetPaperSize(wxSize* pPaperSize, BOOL RedrawPrintBorders = TRUE)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/4/95
    Inputs:     pPaperSize = ptr to a wxSize struct to place the size of the paper into
                RedrawPrintBorders  - True (Default) to force a redraw of docs
    Returns:    TRUE means OK, FALSE otherwise
    Purpose:    Retrieves the physical size of the printer's paper, in MILLIPOINTS

                This size takes into account any processing that is done by t