//=============================================================================
//    (c) Copyright Wang Laboratories, Inc. 1995  All rights reserved.
//-----------------------------------------------------------------------------
//  Project:    Norway - Page Options Dialog DLL
//
//  Component:  Size Tab
//
//  File Name:  sizepge.cpp
//
//  Class:      CSizePage
//
//  Functions:
//-----------------------------------------------------------------------------
//  Maintenance Log:
/*
$Header:   S:\norway\wangcmn\sizepge.cpv   1.13   12 Oct 1995 12:04:30   MFH  $
$Log:   S:\norway\wangcmn\sizepge.cpv  $

      Rev 1.13   12 Oct 1995 12:04:30   MFH
   Added context sensitive help support

      Rev 1.12   12 Oct 1995 10:14:32   MFH
   Changes for MFC 4.0

      Rev 1.11   03 Oct 1995 14:30:42   MFH
   Changed conversions to round off better

      Rev 1.10   22 Sep 1995 19:26:12   MFH
   Added special page size cases for international

      Rev 1.9   19 Sep 1995 10:17:08   MFH
   Uses registered decimal symbol to display sizes (in addition to
      allowing it in when entering a custom size)

      Rev 1.8   14 Sep 1995 15:45:14   MFH
   New paper sizes.  No more CheckOk.  Validation done when user
   tries to leave tab.  uses Miki's edit control class to only
   allow numbers.

      Rev 1.7   08 Sep 1995 15:18:24   MFH
   Defaults to A4 paper size for metric setting in control panel.

      Rev 1.6   05 Sep 1995 17:47:30   MFH
   Default handling changed so that better defaults are given if calling
   app does not specify defaults and/or does not show window
   SetHeight and SetWidth moved to here because no longer inline
   Saves Height and Width as inches instead of pixels or metric
   Create/Destroy window message handlers gone
   ShowWindow handler added
   Shows millimeters instead of centimeters
   New Error handling to be consistent with resolution page:
     Gives error as OK is grayed then no error until OK enabled then
     grayed again.
   ConvertSize changed for millimeters and inches saved.

      Rev 1.5   03 Aug 1995 16:35:58   MFH
   Use IDOK instead of 1 to reference OK control.
   Added comments

      Rev 1.4   31 Jul 1995 11:38:46   MFH
   "Custom" string in combo box is no longer shared with Resolution tab

      Rev 1.3   20 Jul 1995 16:24:48   MFH
   Now loads strings into size combobox at InitDialog

      Rev 1.2   20 Jul 1995 11:26:18   MFH
   Fixed bug of not setting default size so it could be retrieved
   even if the tab is not shown.  Also grays OK button if 0 height or
   width

      Rev 1.1   19 Jul 1995 14:55:14   MFH
   Fixed custom sizes on size page

      Rev 1.0   11 Jul 1995 14:20:10   MFH
   Initial entry

      Rev 1.2   30 Jun 1995 14:45:50   MFH
   Added units combo box.  Does conversion from pixels to desired
   units.  Gets default from registry.  More standard sizes

      Rev 1.1   23 May 1995 15:22:20   MFH
   change from pagedll.h to pageopts.h

      Rev 1.0   23 May 1995 13:45:50   MFH
   Initial entry
*/
//=============================================================================
// sizepge.cpp : implementation file
//

#include "stdafx.h"
#include "pageopts.h"
#include "sizepge.h"
#include "ctlhids.h"

#include <math.h>

#define UNIT_METRIC 0x30
#define UNIT_INCH   0x31
#define MM_PER_INCH 25.40005

#define UNIT_COMBO_INCHES 0
#define UNIT_COMBO_METRIC 1
#define UNIT_COMBO_PIXELS 2

#define MIN_SIZE 1
#define MAX_SIZE 18000

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

// For context-sensitive help:
// An array of dword pairs, where the first of each
// pair is the control ID, and the second is the
// context ID for a help topic, which is used
// in the help file.

static const DWORD aMenuHelpIDs[] =
{
    IDC_UNITS_TEXT,     HIDC_UNITS_TEXT,
    IDC_SIZE_UNITS,     HIDC_SIZE_UNITS,
    IDC_SIZE_TEXT,      HIDC_SIZE_TEXT,
    IDC_SIZE_COMBO,     HIDC_SIZE_COMBO,
    IDC_WIDTH_TEXT,     HIDC_WIDTH_TEXT,
    IDC_SIZE_WIDTH,     HIDC_SIZE_WIDTH,
    IDC_HEIGHT_TEXT,    HIDC_HEIGHT_TEXT,
    IDC_SIZE_HEIGHT,    HIDC_SIZE_HEIGHT,
    0,  0
};

/////////////////////////////////////////////////////////////////////////////
// CSizePage dialog

CSizePage::CSizePage()
            : CPropertyPage(CSizePage::IDD)
{
    m_nInches = UNIT_COMBO_INCHES;
    m_nMetric = UNIT_COMBO_METRIC;
    m_nPixels = UNIT_COMBO_PIXELS;

	m_pParent = NULL;

    //{{AFX_DATA_INIT(CSizePage)
    m_nSel = -1;
	m_nUnitSel = m_nInches;
	//}}AFX_DATA_INIT

    m_acDec[0] = 0; // Initialize decimal string

    // Get whether to default to metric or inches defaults from registry
    LCID Locale = GetUserDefaultLCID();
    m_nSize = SIZE_CUSTOM;

    // First check locale.  If this is one of the following
    //  then can't use Metric vs. US since they are metric but
    //  default to letter sized paper.
    switch(Locale)
    {
        case 0x1009:    // Canada (English)
        case 0xC0C:     // Canada (French)
        case 0x416:     // Brazil
        case 0x2C0A:    // Argentina
        case 0x340A:    // Chile
        case 0x240A:    // Columbia
        case 0x140A:    // Costa Rica
        case 0x1C0A:    // Dominican Republic
        case 0x300A:    // Ecuador
        case 0x100A:    // Guatemala
        case 0x80A:     // Mexico
        case 0x180A:    // Panama
        case 0x3C0A:    // Paraguay
        case 0x280A:    // Peru
        case 0x380A:    // Uruguay
        case 0x200A:    // Venezuela
            m_dHeight = 11.0;
            m_dWidth = 8.5;
            m_nSize = SIZE_LETTER;
            break;
    } // end switch on locale

    // Use get Metric/US for default units and
    //  to determine initial paper size if not done above
    if (GetLocaleInfo(Locale, LOCALE_IMEASURE, (LPTSTR)m_acMeasureType,
                       sizeof (TCHAR) * LOCALE_INFO) == 0)
        *m_acMeasureType = 0;

    if (*m_acMeasureType == UNIT_METRIC)
    {
        if (m_nSize == SIZE_CUSTOM)
            m_nSize = SIZE_A4;
        ConvertSize();
    }
    else if (m_nSize == SIZE_CUSTOM)
    {
        m_dHeight = 11.0;
        m_dWidth = 8.5;
        m_nSize = SIZE_LETTER;
    }
}

void CSizePage::DoDataExchange(CDataExchange* pDX)
{
    CPropertyPage::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CSizePage)
    DDX_CBIndex(pDX, IDC_SIZE_COMBO, m_nSel);
	DDX_CBIndex(pDX, IDC_SIZE_UNITS, m_nUnitSel);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSizePage, CPropertyPage)
    //{{AFX_MSG_MAP(CSizePage)
    ON_CBN_SELCHANGE(IDC_SIZE_COMBO, OnChangeSize)
	ON_CBN_SELCHANGE(IDC_SIZE_UNITS, OnChangeUnits)
	ON_EN_CHANGE(IDC_SIZE_HEIGHT, OnChangeHeight)
	ON_EN_CHANGE(IDC_SIZE_WIDTH, OnChangeWidth)
	ON_WM_SHOWWINDOW()
	ON_EN_SETFOCUS(IDC_SIZE_HEIGHT, OnSetFocusHeight)
	ON_EN_SETFOCUS(IDC_SIZE_WIDTH, OnSetFocusWidth)
	ON_WM_CONTEXTMENU()
	ON_WM_HELPINFO()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CSizePage Operations

//***************************************************************************
//
//  GetHeight
//      Updates member data from controls (if window has been created).
//      Gets resolution from parent window (which gets it from the
//         resolution tab) in order to convert the height to pixels,
//      Returns height in pixels.
//
//***************************************************************************
long CSizePage::GetHeight()
{
    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;

    long lYRes = 100;           // 100 dpi default

    if (pParentWnd != NULL)     // Get final Y resolution value
          lYRes = pParentWnd->GetYRes();

    long lHeight;
    lHeight = (long)(m_dHeight * lYRes);  // Convert inches to pixels
    return lHeight;
}


//***************************************************************************
//
//  SetHeight
//      Takes input as pixels and converts to inches to save internally.
//      Makes sure set size is within boundaries.
//      When it needs to be displayed according to the current unit selection,
//      or when GetHeight is called, the inch value is converted to desired
//      units or pixels respectively.
//
//***************************************************************************
void CSizePage::SetHeight(long lHeight)
{
    if (lHeight < MIN_SIZE)
        lHeight = MIN_SIZE;
    else if (lHeight > MAX_SIZE)
        lHeight = MAX_SIZE;

    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;

    long lYRes = 100;           // 100 dpi default

    if (pParentWnd != NULL)     // Get final Y resolution value
          lYRes = pParentWnd->GetYRes();

    // Pixels -> Inches = Pels / Res (dpi)
    m_dHeight = ((double)lHeight) / lYRes;
    return;
}

//***************************************************************************
//
//  GetWidth
//      Updates member data from controls (if window has been created).
//      Gets resolution from parent window (which gets it from the
//         resolution tab) in order to convert the width to pixels
//         if not in pixels already.
//      Returns width in pixels.
//
//***************************************************************************
long CSizePage::GetWidth()
{
    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;
    long lXRes = 100;           // 100 dpi default

    if (pParentWnd != NULL)     // Get final Y resolution value
          lXRes = pParentWnd->GetXRes();

    long lWidth = (long)(m_dWidth * lXRes);    // Convert inches to pixels
    return lWidth;
}

//***************************************************************************
//
//  SetWidth
//      Takes input as pixels and converts to inches to save internally.
//      Makes sure set size is within boundaries.
//      When it needs to be displayed according to the current unit selection,
//      or when GetWidth is called, the inch value is converted to desired
//      units or pixels respectively.
//
//***************************************************************************
void CSizePage::SetWidth(long lWidth)
{
    if (lWidth < MIN_SIZE)
        lWidth = MIN_SIZE;
    else if (lWidth > MAX_SIZE)
        lWidth = MAX_SIZE;

    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;

    long lXRes = 100;           // 100 dpi default

    if (pParentWnd != NULL)     // Get final Y resolution value
          lXRes = pParentWnd->GetXRes();

    m_dWidth = ((double)lWidth) / lXRes;    // Convert inches to pixels
    return;
}

//***************************************************************************
//
//  SetSize
//      Set size to a standard size (see PageSht.h for definition of
//      the enumerated value PageSize).
//
//***************************************************************************
void CSizePage::SetSize(PageSize StdSize)
{
    m_nSize = StdSize;      // Set current size selection
    ConvertSize();          // Get standard size and convert units
}


/////////////////////////////////////////////////////////////////////////////
// CSizePage private functions

//***************************************************************************
//
//  FillEditBoxes
//      Fills the Height and Width edit boxes according to the size
//      and units selections.  Unless the size selection is Custom,
//      the edit boxes are set to be read-only.
//
//***************************************************************************
void CSizePage::FillEditBoxes()
{
    CString szHeight, szWidth;

    // Get height/width for selected size and in appropriate units
    ConvertSize();

    CString szUnits;    // Get units string to append if not custom size
    if (m_nSize != SIZE_CUSTOM)
    {
        if (m_nUnitSel == m_nInches)
            szUnits.LoadString(IDS_ABBREV_INCH);
        else if (m_nUnitSel == m_nMetric)
            szUnits.LoadString(IDS_ABBREV_MM);
        else szUnits.LoadString(IDS_ABBREV_PELS);
    }
    else szUnits.Empty();

    if (m_nUnitSel == m_nPixels)   // Pixels are longs not doubles (no decimal)
    {
        sprintf(szHeight.GetBuffer(NUMSIZE), "%ld", (long)m_dEditHeight);
        sprintf(szWidth.GetBuffer(NUMSIZE), "%ld", (long)m_dEditWidth);
    }
    else
    {
        int DecimalPlace, Sign, Count;
        if (m_nUnitSel == m_nMetric)   // Metric precision to one decimal
            Count = 1;
        else Count = 2;                 // Decimal to two decimals
        szHeight = _fcvt(m_dEditHeight, Count, &DecimalPlace, &Sign);
        if (DecimalPlace < 0)
            DecimalPlace = 0;
        szHeight = szHeight.Left(DecimalPlace) + m_acDec[0] + szHeight.Mid(DecimalPlace);
        szWidth = _fcvt(m_dEditWidth, Count, &DecimalPlace, &Sign);
        if (DecimalPlace < 0)
            DecimalPlace = 0;
        szWidth = szWidth.Left(DecimalPlace) + m_acDec[0] + szWidth.Mid(DecimalPlace);
    }

    // Append units string
    szHeight.ReleaseBuffer();
    szHeight += szUnits;
    szWidth.ReleaseBuffer();
    szWidth += szUnits;

    m_HeightCtl.SetWindowText(szHeight);
    m_WidthCtl.SetWindowText(szWidth);

    // Set read-only == FALSE if custom size selected
    if (m_nSize == SIZE_CUSTOM)
    {
        m_WidthCtl.SetReadOnly(FALSE);
        m_HeightCtl.SetReadOnly(FALSE);
        return;
    }

    m_WidthCtl.SetReadOnly(TRUE);
    m_HeightCtl.SetReadOnly(TRUE);
    return;
}

/////////////////////////////////////////////////////////////////////////////
// CSizePage message handlers

//***************************************************************************
//
//  OnInitDialog
//      Fill the combo boxes with strings
//      Initialize the controls according to default selections.
//      Units default to localization value in registry
//
//***************************************************************************
BOOL CSizePage::OnInitDialog()
{
    CString szSize, szPixels;
    m_nSel = m_nSize;

    // Fill in Sizes in Size combo box
    CComboBox *pSizeCombo = (CComboBox*)GetDlgItem(IDC_SIZE_COMBO);
    pSizeCombo->ResetContent();
    szSize.LoadString(IDS_SIZE_LETTER);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_TABLOID);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_LEDGER);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_LEGAL);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_STATEMENT);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_EXECUTIVE);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_A3);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_A4);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_A5);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_B4_ISO);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_B4_JIS);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_B5_ISO);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_B5_JIS);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_FOLIO);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_QUARTO);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_SIZE_10X14);
    pSizeCombo->AddString(szSize);
    szSize.LoadString(IDS_CUSTOM_SIZE);
    pSizeCombo->AddString(szSize);

    // Fill in Units combo box
    CComboBox *pUnitsCombo = (CComboBox*)GetDlgItem(IDC_SIZE_UNITS);
    pUnitsCombo->ResetContent();
    szSize.LoadString(IDS_UNITS_INCHES);
    m_nInches = pUnitsCombo->AddString(szSize);

    szSize.LoadString(IDS_UNITS_METRIC);
    m_nMetric = pUnitsCombo->AddString(szSize);

    szSize.LoadString(IDS_UNITS_PIXELS);
    m_nPixels = pUnitsCombo->AddString(szSize);

    // Set default units according to registry
    if (*m_acMeasureType == UNIT_METRIC)
        m_nUnitSel = m_nMetric;
    else if (*m_acMeasureType == UNIT_INCH)
        m_nUnitSel = m_nInches;
    else m_nUnitSel = m_nPixels;

    // Initialize with values set above
    CPropertyPage::OnInitDialog();

    GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, (LPTSTR)m_acDec,
                    sizeof (TCHAR) * LOCALE_INFO);

    m_WidthCtl.cAllow1 = m_acDec[0];
	m_HeightCtl.cAllow1 = m_acDec[0];

    m_WidthCtl.SubclassDlgItem (IDC_SIZE_WIDTH, this);
    m_HeightCtl.SubclassDlgItem (IDC_SIZE_HEIGHT, this);

    // Initial height and width should already be set in inches

    // Fill in edit boxes according to inches or metric
    FillEditBoxes();
    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
}

//***************************************************************************
//
//  OnChangeSize
//      If the user changes the size selection, then the edit boxes need
//      to be updated to reflect the new size.  If 'Custom' is selected
//      then the edit boxes become modifiable.
//
//***************************************************************************
void CSizePage::OnChangeSize()
{
    UpdateData(TRUE);
    m_nSize = (PageSize)m_nSel;
    FillEditBoxes();
}

//***************************************************************************
//
//  OnChangeUnits
//      If the user changes the desired units, then the sizes in the
//      edit boxes need to be converted to the new units.
//
//***************************************************************************
void CSizePage::OnChangeUnits()
{
    UpdateData(TRUE);
    FillEditBoxes();
    if (m_nUnitSel == m_nPixels)
    {
        m_WidthCtl.cAllow1 = NULL;
    	m_HeightCtl.cAllow1 = NULL;
        return;
    }
    m_WidthCtl.cAllow1 = m_acDec[0];
	m_HeightCtl.cAllow1 = m_acDec[0];
}

//***************************************************************************
//
// ConvertSize:  If the user has selected a standard sized page,
//                 need to get standard size and convert it to selected units
//                 to be displayed in the edit boxes for height and width.
//
//***************************************************************************

void CSizePage::ConvertSize()
{
    int nUnits;

    switch(m_nSize)     // Switch on selected size
    {
        case SIZE_LETTER:            // Letter 8 1/2 x 11 in
            nUnits = m_nInches;
            m_dEditWidth = 8.5;
            m_dEditHeight = 11;
            break;
        case SIZE_TABLOID:           // Tabloid 11 x 17 in
            nUnits = m_nInches;
            m_dEditWidth = 11;
            m_dEditHeight = 17;
            break;
        case SIZE_LEDGER:            // Ledger 17 x 11 in
            nUnits = m_nInches;
            m_dEditWidth = 17;
            m_dEditHeight = 11;
            break;
        case SIZE_LEGAL:             // Legal 8 1/2 x 14 in
            nUnits = m_nInches;
            m_dEditWidth = 8.5;
            m_dEditHeight = 14;
            break;
        case SIZE_STATEMENT:         // Statement 5 1/2 x 8 1/2 in
            nUnits = m_nInches;
            m_dEditWidth = 5.5;
            m_dEditHeight = 8.5;
            break;
        case SIZE_EXECUTIVE:         // Executive 7 1/4 x 10 1/2 in
            nUnits = m_nInches;
            m_dEditWidth = 7.25;
            m_dEditHeight = 10.5;
            break;
        case SIZE_A3:                // A3 297 x 420 mm
            nUnits = m_nMetric;
            m_dEditWidth = 297.0;
            m_dEditHeight = 420.0;
            break;
        case SIZE_A4:                // A4 210 x 297 mm
            nUnits = m_nMetric;
            m_dEditWidth = 210.;
            m_dEditHeight = 297.;
            break;
        case SIZE_A5:                // A5 148 x 210 mm
            nUnits = m_nMetric;
            m_dEditWidth = 148.;
            m_dEditHeight = 210.;
            break;
        case SIZE_B4_ISO:            // B4 (ISO) 250 x 353 mm
            nUnits = m_nMetric;
            m_dEditWidth = 250.;
            m_dEditHeight = 353.;
            break;
        case SIZE_B4_JIS:            // B4 (JIS) 257 x 364 mm
            nUnits = m_nMetric;
            m_dEditWidth = 257.;
            m_dEditHeight = 364.;
            break;
        case SIZE_B5_ISO:            // B5 (ISO) 176 x 250 mm
            nUnits = m_nMetric;
            m_dEditWidth = 176.;
            m_dEditHeight = 250.;
            break;
        case SIZE_B5_JIS:            // B5 (JIS) 182 x 257 mm
            nUnits = m_nMetric;
            m_dEditWidth = 182.;
            m_dEditHeight = 257.;
            break;
        case SIZE_FOLIO:             // Folio 8 1/2 x 13 in
            nUnits = m_nInches;
            m_dEditWidth = 8.5;
            m_dEditHeight = 13;
            break;
        case SIZE_QUARTO:            // Quarto 215 x 275 mm
            nUnits = m_nMetric;
            m_dEditWidth = 215.;
            m_dEditHeight = 275.;
            break;
        case SIZE_10X14:             // 10x14 in
            nUnits = m_nInches;
            m_dEditWidth = 10;
            m_dEditHeight = 14;
            break;
        case SIZE_CUSTOM:            // Custom size (default)
        default:
            nUnits = m_nInches;      // Convert from inches to whatever
            m_dEditWidth = m_dWidth;
            m_dEditHeight = m_dHeight;
            break;
    } // end switch on selected size

    // If units are inches
    if (nUnits == m_nInches)
    {
        m_dWidth = m_dEditWidth;    // Save current values in inches
        m_dHeight = m_dEditHeight;

        if (m_nUnitSel == m_nInches) // If want inches displayed
            return;                  // All set so return;
    }

    // Note, nUnits can never be pixels since it is only set to
    //   inches or metric above.

    if (nUnits != m_nInches)    // Have metric, need inches
    {
        // Metric -> Inches = MM / MM_PER_INCH
        m_dWidth = m_dEditWidth / MM_PER_INCH;
        m_dHeight = m_dEditHeight / MM_PER_INCH;

        // If want to display inches, set edit box values and return
        if (m_nUnitSel == m_nInches)
        {
            m_dEditWidth = m_dWidth;
            m_dEditHeight = m_dHeight;
            return;
        }
    }

    if (m_nUnitSel == m_nMetric) // Want metric
    {
        if (nUnits == m_nMetric)    // Have metric.  All set
            return;

        // Convert inches to Metric
        m_dEditHeight = m_dHeight * MM_PER_INCH;
        m_dEditWidth = m_dWidth * MM_PER_INCH;
        return;     // All done
    }

    // Otherwise want pixels, use inches value to get pixels
    // Inches to Pels -> Inches * dpi
    // Need to convert to inches, then if needed convert to desired units
    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;

    long lXRes = 100;  // 100 dpi default
    long lYRes = 100;

    if (pParentWnd != NULL)
    {
        lXRes = pParentWnd->GetXRes();     // dpi or pixels/inch
        lYRes = pParentWnd->GetYRes();
    }

    m_dEditHeight = m_dHeight * lYRes;
    m_dEditWidth = m_dWidth * lXRes;

    if (((long)m_dEditWidth) == 0)
        m_dEditWidth = 0;
    if (((long)m_dEditHeight) == 0)
        m_dEditHeight = 0;

    // Round off properly
    double dInteger;
    double dFraction = modf(m_dEditWidth, &dInteger);
    if (dFraction < 0.50)
        m_dEditWidth = dInteger;
    else m_dEditWidth = ceil(m_dEditWidth);
    dFraction = modf(m_dEditHeight, &dInteger);
    if (dFraction < 0.50)
        m_dEditHeight = dInteger;
    else m_dEditHeight = ceil(m_dEditHeight);
    return;
}

//***************************************************************************
//
//  OnChangeHeight
//      Get new height value and check if 'OK' on parent window should
//      be enabled or disabled.  If the Height or Width on this
//      tab or the X resolution or Y resolution on the Resolution tab
//      is 0 or a non-numeric value, then the 'OK' button on the parent
//      window is disabled.
//
//***************************************************************************
void CSizePage::OnChangeHeight()
{
    UpdateData();

    CString szHeight;
    m_HeightCtl.GetWindowText(szHeight);

    // Replace decimal char with '.' for internal number
    if ((m_acDec[0] != '.') && (m_acDec[0] != '\0'))
    {
        int nDecIndex;
        nDecIndex = szHeight.Find(m_acDec[0]);
        if (nDecIndex != -1)
            szHeight.SetAt(nDecIndex, '.');
    }

    char *pEndChar;
    if (m_nUnitSel == m_nPixels)
    {
        m_dEditHeight = (double)strtol(szHeight, &pEndChar, 10);
        // Save as inches
        CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;
        long lYRes = 100;
        if (pParentWnd != NULL)
            lYRes = pParentWnd->GetYRes();
        m_dHeight = m_dEditHeight / lYRes;
    }
    else
    {
        m_dEditHeight = strtod(szHeight, &pEndChar);
        if (m_nUnitSel == m_nMetric)    // Save as inches
            m_dHeight = m_dEditHeight / MM_PER_INCH;
        else m_dHeight = m_dEditHeight;
    }
}

//***************************************************************************
//
//  OnChangeWidth
//      Get new Width value and check if 'OK' on parent window should
//      be enabled or disabled.  If the Height or Width on this
//      tab or the X resolution or Y resolution on the Resolution tab
//      is 0 or a non-numeric value, then the 'OK' button on the parent
//      window is disabled.
//
//***************************************************************************
void CSizePage::OnChangeWidth()
{
    UpdateData();

    CString szWidth;
    m_WidthCtl.GetWindowText(szWidth);

    // Replace decimal char with '.' for internal number
    if ((m_acDec[0] != '.') && (m_acDec[0] != '\0'))
    {
        int nDecIndex;
        nDecIndex = szWidth.Find(m_acDec[0]);
        if (nDecIndex != -1)
            szWidth.SetAt(nDecIndex, '.');
    }

    char *pEndChar;
    if (m_nUnitSel == m_nPixels)
    {
        m_dEditWidth = (double)strtol(szWidth, &pEndChar, 10);
        // Save as inches
        CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;
        long lXRes = 100;
        if (pParentWnd != NULL)
            lXRes = pParentWnd->GetXRes();
        m_dWidth = m_dEditWidth / lXRes;
    }
    else
    {
        m_dEditWidth = strtod(szWidth, &pEndChar);
        if (m_nUnitSel == m_nMetric)    // Save as inches
            m_dWidth = m_dEditWidth / MM_PER_INCH;
        else m_dWidth = m_dEditWidth;
    }
}

//***************************************************************************
//
//  OnShowWindow
//      When window is shown, it could be that the resolution has changed.
//      If the current unit selection is pixels, then the pixels need to
//      be updated to reflect the new resolution.
//
//***************************************************************************
void CSizePage::OnShowWindow(BOOL bShow, UINT nStatus)
{
	CPropertyPage::OnShowWindow(bShow, nStatus);
	
    if (bShow == TRUE)
    {
        if (m_nUnitSel == m_nPixels)
            FillEditBoxes();
    }
}

//***************************************************************************
//
//  OnKillActive
//      Called by the framework when this tab is losing the active focus.
//      It is called before the OK button is clicked as well.  TRUE is
//      returned if the data on the tab is valid.  Otherwise, set focus
//      to the offending data and return FALSE.
//
//***************************************************************************
BOOL CSizePage::OnKillActive()
{
    CPagePropSheet *pParentWnd = (CPagePropSheet *)m_pParent;
    if (pParentWnd == NULL)
        return FALSE;

    long lXRes = pParentWnd->GetXRes();     // Get resolutions
    long lYRes = pParentWnd->GetYRes();

    CString szSizeError;
    CString szTitle;

    // Check Width
    // If pixels is < 1 or > 18,000, invalid
    if (((m_dWidth * lXRes) < MIN_SIZE) ||
        ((m_dWidth * lXRes) > MAX_SIZE))
    {
        if (m_nUnitSel == m_nPixels)
            szSizeError.LoadString(IDS_ERROR_SIZEPIX);
        else szSizeError.LoadString(IDS_ERROR_SIZECONVERT);
        pParentWnd->GetWindowText(szTitle);
        MessageBox(szSizeError, szTitle);
        m_WidthCtl.SetFocus();
        return FALSE;
    }

    // If pixels is < 1 or > 18,000, invalid
    if (((m_dHeight * lYRes) < MIN_SIZE) ||
        ((m_dHeight * lYRes) > MAX_SIZE))
    {
        if (m_nUnitSel == m_nPixels)
            szSizeError.LoadString(IDS_ERROR_SIZEPIX);
        else szSizeError.LoadString(IDS_ERROR_SIZECONVERT);
        pParentWnd->GetWindowText(szTitle);
        MessageBox(szSizeError, szTitle);
        m_HeightCtl.SetFocus();
        return FALSE;
    }
    return TRUE;
}

//***************************************************************************
//
//  OnSetFocusHeight
//      When the Height edit box gets the focus, select the text
//
//***************************************************************************
void CSizePage::OnSetFocusHeight()
{
    m_HeightCtl.SetSel(0, -1);
}

//***************************************************************************
//
//  OnSetFocusWidth
//      When the Width edit box gets the focus, select the text
//
//***************************************************************************
void CSizePage::OnSetFocusWidth()
{
    m_WidthCtl.SetSel(0, -1);
}

void CSizePage::OnContextMenu(CWnd* pWnd, CPoint point)
{
		// All tabs have same ID so can't give tab specific help
    if (::GetDlgCtrlID(pWnd->GetSafeHwnd()) == AFX_IDC_TAB_CONTROL)
        return;

	::WinHelp (pWnd->GetSafeHwnd(),"wangocx.hlp", HELP_CONTEXTMENU,
                      (DWORD)(LPVOID)aMenuHelpIDs);
    return;
}

BOOL CSizePage::OnHelpInfo(HELPINFO* pHelpInfo)
{
    // All tabs have same ID so can't give tab specific help
    if (pHelpInfo->iCtrlId == AFX_IDC_TAB_CONTROL)
        return 0L;

    if (pHelpInfo->iContextType == HELPINFO_WINDOW)   // must be for a control
    {
        ::WinHelp ((HWND)pHelpInfo->hItemHandle, "wangocx.hlp",
                   HELP_WM_HELP,
                   (DWORD)(LPVOID)aMenuHelpIDs);
    }
    return 1L;
}