// MagView.cpp : implementation of the CMagGlassView class
//

#include "stdafx.h"
#include "resource.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern CMagGlassApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CMagGlassView

IMPLEMENT_DYNCREATE(CMagGlassView, CFormView)

BEGIN_MESSAGE_MAP(CMagGlassView, CFormView)
	//{{AFX_MSG_MAP(CMagGlassView)
	ON_MESSAGE(WM_DOREALIZE, OnDoRealize)
	ON_WM_SIZE()
	ON_WM_CLOSE()
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
	ON_COMMAND(ID_MAGGLASS_START, OnStartMagGlass)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_START, OnUpdateStartMagGlass)
	ON_COMMAND(ID_MAGGLASS_STOP, OnStopMagGlass)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_STOP, OnUpdateStopMagGlass)
	ON_COMMAND(ID_MAGGLASS_MANUAL_UPDATE, OnMagGlassManualUpdate)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_MANUAL_UPDATE, OnUpdateMagGlassManualUpdate)
	ON_COMMAND(ID_MAGGLASS_UPDATE_BITMAP, OnUpdateMagGlassBitmap)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_UPDATE_BITMAP, OnUpdateUpdateMagGlassBitmap)
	ON_COMMAND(ID_MAGGLASS_UPDATE_SOURCE, OnUpdateSourceBitmap)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_UPDATE_SOURCE, OnUpdateUpdateSourceBitmap)
	ON_COMMAND(ID_MAGGLASS_RESIZE_WIDTH, OnMagglassResizeWidth)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_RESIZE_WIDTH, OnUpdateMagglassResizeWidth)
	ON_COMMAND(ID_MAGGLASS_RESIZE_HEIGHT, OnMagglassResizeHeight)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_RESIZE_HEIGHT, OnUpdateMagglassResizeHeight)
	ON_COMMAND(ID_MAGGLASS_RESIZE_BORDER, OnMagglassResizeBorder)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_RESIZE_BORDER, OnUpdateMagglassResizeBorder)
	ON_COMMAND(ID_MAGGLASS_ZOOM_FACTOR, OnMagglassZoomFactor)
	ON_COMMAND(ID_COLORS_BORDER, OnColorsBorder)
	ON_COMMAND(ID_COLORS_BACK, OnColorsBack)
	ON_COMMAND(ID_OPTIONS_3D, OnOptions3d)
	ON_UPDATE_COMMAND_UI(ID_OPTIONS_3D, OnUpdateOptions3d)
	ON_COMMAND(ID_CROSSHAIR_NONE, OnCrosshairNone)
	ON_UPDATE_COMMAND_UI(ID_CROSSHAIR_NONE, OnUpdateCrosshairNone)
	ON_COMMAND(ID_CROSSHAIR_FINE, OnCrosshairFine)
	ON_UPDATE_COMMAND_UI(ID_CROSSHAIR_FINE, OnUpdateCrosshairFine)
	ON_COMMAND(ID_CROSSHAIR_INVERT_PEN, OnCrosshairInvertPen)
	ON_UPDATE_COMMAND_UI(ID_CROSSHAIR_INVERT_PEN, OnUpdateCrosshairInvertPen)
	ON_COMMAND(ID_CROSSHAIR_INVERT_SCREEN, OnCrosshairInvertScreen)
	ON_UPDATE_COMMAND_UI(ID_CROSSHAIR_INVERT_SCREEN, OnUpdateCrosshairInvertScreen)
	ON_COMMAND(ID_AREA_CENTER, OnAreaCenter)
	ON_UPDATE_COMMAND_UI(ID_AREA_CENTER, OnUpdateAreaCenter)
	ON_COMMAND(ID_AREA_TOPLEFT, OnAreaTopleft)
	ON_UPDATE_COMMAND_UI(ID_AREA_TOPLEFT, OnUpdateAreaTopleft)
	ON_COMMAND(ID_PALETTE_AUTO, OnPaletteAuto)
	ON_UPDATE_COMMAND_UI(ID_PALETTE_AUTO, OnUpdatePaletteAuto)
	ON_COMMAND(ID_PALETTE_FIXED, OnPaletteFixed)
	ON_UPDATE_COMMAND_UI(ID_PALETTE_FIXED, OnUpdatePaletteFixed)
	ON_COMMAND(ID_DITHERING_ORDERED, OnDitheringOrdered)
	ON_UPDATE_COMMAND_UI(ID_DITHERING_ORDERED, OnUpdateDitheringOrdered)
	ON_COMMAND(ID_DITHERING_ERROR_DIFFUSION, OnDitheringErrorDiffusion)
	ON_UPDATE_COMMAND_UI(ID_DITHERING_ERROR_DIFFUSION, OnUpdateDitheringErrorDiffusion)
	ON_COMMAND(ID_BITONALSCALING_NORMAL, OnBitonalscalingNormal)
	ON_UPDATE_COMMAND_UI(ID_BITONALSCALING_NORMAL, OnUpdateBitonalscalingNormal)
	ON_COMMAND(ID_BITONALSCALING_FAVOR_BLACK, OnBitonalscalingFavorBlack)
	ON_UPDATE_COMMAND_UI(ID_BITONALSCALING_FAVOR_BLACK, OnUpdateBitonalscalingFavorBlack)
	ON_COMMAND(ID_BITONALSCALING_SCALE_TO_GRAY, OnBitonalscalingScaleToGray)
	ON_UPDATE_COMMAND_UI(ID_BITONALSCALING_SCALE_TO_GRAY, OnUpdateBitonalscalingScaleToGray)
	ON_COMMAND(ID_PAINTSCALING_NORMAL, OnPaintscalingNormal)
	ON_UPDATE_COMMAND_UI(ID_PAINTSCALING_NORMAL, OnUpdatePaintscalingNormal)
	ON_COMMAND(ID_PAINTSCALING_RESAMPLE, OnPaintscalingResample)
	ON_UPDATE_COMMAND_UI(ID_PAINTSCALING_RESAMPLE, OnUpdatePaintscalingResample)
	ON_COMMAND(ID_PAINTSCALING_BICUBIC, OnPaintscalingBicubic)
	ON_UPDATE_COMMAND_UI(ID_PAINTSCALING_BICUBIC, OnUpdatePaintscalingBicubic)
	ON_COMMAND(ID_PAINT_INTENSITY, OnPaintIntensity)
	ON_COMMAND(ID_PAINT_GAMMA, OnPaintGamma)
	ON_COMMAND(ID_PAINT_CONTRAST, OnPaintContrast)
	ON_COMMAND(ID_CURSOR_RECTANGLE, OnCursorRectangle)
	ON_UPDATE_COMMAND_UI(ID_CURSOR_RECTANGLE, OnUpdateCursorRectangle)
	ON_COMMAND(ID_CURSOR_ELLIPSE, OnCursorEllipse)
	ON_UPDATE_COMMAND_UI(ID_CURSOR_ELLIPSE, OnUpdateCursorEllipse)
	ON_COMMAND(ID_SHAPE_RECTANGLE, OnShapeRectangle)
	ON_UPDATE_COMMAND_UI(ID_SHAPE_RECTANGLE, OnUpdateShapeRectangle)
	ON_COMMAND(ID_SHAPE_ELLIPSE, OnShapeEllipse)
	ON_UPDATE_COMMAND_UI(ID_SHAPE_ELLIPSE, OnUpdateShapeEllipse)
	ON_COMMAND(ID_SHAPE_ROUND_RECTANGLE, OnShapeRoundRectangle)
	ON_UPDATE_COMMAND_UI(ID_SHAPE_ROUND_RECTANGLE, OnUpdateShapeRoundRectangle)
	ON_COMMAND(ID_SHAPE_FREEHAND, OnShapeFreehand)
	ON_UPDATE_COMMAND_UI(ID_SHAPE_FREEHAND, OnUpdateShapeFreehand)
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
	ON_COMMAND(ID_MAGGLASS_WINDOWLEVEL, OnMagglassWindowlevel)
	ON_UPDATE_COMMAND_UI(ID_MAGGLASS_WINDOWLEVEL, OnUpdateMagglassWindowlevel)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMagGlassView construction/destruction

CMagGlassView::CMagGlassView()
	: CFormView(CMagGlassView::IDD)
{
	//{{AFX_DATA_INIT(CMagGlassView)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

   m_nMaskCount = 0;

   m_hMagGlassRgn = NULL;

   m_b3D = TRUE;
   m_bCenter = TRUE;
   m_bEllipse = FALSE;
   m_bRectShape = TRUE;
   m_bIgnoreRgn = TRUE;
   m_bRectCursor = TRUE;
   m_bLeftBtnDown = FALSE;
   m_bManualUpdate = FALSE;
   m_bCustomCursor = FALSE;
   m_bEllipseShape = FALSE;
   m_bFreeHandShape = FALSE;
   m_bEllipseCursor = FALSE;
   m_bRoundRectShape = FALSE;
   m_bUpdateSrcBitmap = FALSE;

   m_iZoom = 400;
   m_iCrosshair = CROSSHAIR_FINE;
   m_iPaintDither = 0;
   m_iPaintScaling = 0;
   m_iPaintPalette = 0;
   m_iBitonalScaling = 0;
   m_iMagGlassFlags = 0;

   m_fWidth = 150.f;
   m_fHeight = 100.f;
   m_fBorderSize = 1.0f;

//   hCustomCursor = NULL;

   m_ulclrPen = 0;
   m_ulclrBack = RGB(128,128,128);
}

CMagGlassView::~CMagGlassView()
{
   if (m_hMagGlassRgn)
   {
      ::DeleteRgn(m_hMagGlassRgn);
      m_hMagGlassRgn = NULL;
   }
}

void CMagGlassView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CMagGlassView)
	DDX_Control(pDX, IDC_LEADCTRL1, m_Lead);
	DDX_Control(pDX, IDC_LEADCTRL2, m_LeadUpdate);
	//}}AFX_DATA_MAP
}

BOOL CMagGlassView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CFormView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMagGlassView diagnostics

#ifdef _DEBUG
void CMagGlassView::AssertValid() const
{
	CFormView::AssertValid();
}

void CMagGlassView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CMagGlassDoc* CMagGlassView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMagGlassDoc)));
	return (CMagGlassDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMagGlassView message handlers

void CMagGlassView::OnInitialUpdate() 
{
	CFormView::OnInitialUpdate();

   /* Get Height and Width of source bitmap */
   int xExt = (int) m_Lead.GetBitmapWidth();
   int yExt = (int) m_Lead.GetBitmapHeight();

   /* Make the CLead control to fit the bitmap and disable CLead's scrolling */
   // Make the form scroll if the window becomes smaller than the bitmap
   SetScrollSizes(MM_TEXT, CSize(xExt,yExt));

   /* Make the window fit the image */
   GetParentFrame()->RecalcLayout();
   ResizeParentToFit();

   /* Disable the scroll bars */
   SetScrollSizes(MM_TEXT, CSize(1,1));

   /* Don't Erase the background */
   m_Lead.SetBackErase(FALSE);

   m_LeadUpdate.ShowWindow(SW_HIDE);
}

void CMagGlassView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
{
   CLead* pLead = NULL;
      
   pLead = theApp.GetMainFrameLead();
   if (!pLead)
   {
      theApp.DisplayLEADError(ERROR_INV_PARAMETER);
      return;
   }

   m_Lead.SetAutoRepaint(FALSE);
   /* Copy the Document bitmap */
   m_Lead.SetBitmap(pLead->GetBitmap());
   m_Lead.SetPaintPalette(PAINTPALETTE_AUTO);
   m_Lead.SetPaintDither(PAINTDITHER_DIFFUSION);
   m_Lead.SetBitonalScaling(BITONALSCALING_NORMAL);

   m_Lead.SetAutoSize(TRUE);
   m_Lead.SetAutoRepaint(TRUE);
   m_Lead.SetEnableMethodErrors(FALSE);

   CView::OnUpdate(pSender, lHint, pHint);
}

LRESULT CMagGlassView::OnDoRealize(WPARAM wParam, LPARAM lParam)
{
   if (!IsWindow(m_Lead.m_hWnd))
      return FALSE;
   if(lParam)
   {
      return m_Lead.SendMessage(WM_PALETTECHANGED, wParam);
   }
   else
   {
      CDC* pdc;
      UINT nColorsChanged = 0;

      pdc = theApp.m_pMainWnd->GetDC();
      HPALETTE hpal = (HPALETTE)m_Lead.GetPalette((OLE_HANDLE) pdc->m_hDC);
      if(hpal)
      {
         CPalette pal;

         pal.Attach(hpal);
         CPalette* oldPalette = pdc->SelectPalette(&pal, (BOOL) lParam);
         nColorsChanged = pdc->RealizePalette();
         if (nColorsChanged > 0)
            m_Lead.InvalidateRect(NULL, FALSE);
         pdc->SelectPalette(oldPalette, TRUE);
      }
      theApp.m_pMainWnd->ReleaseDC(pdc);
      return ((LRESULT) (BOOL) (nColorsChanged > 0));
   }
}

void CMagGlassView::OnSize(UINT nType, int cx, int cy) 
{
	CFormView::OnSize(nType, cx, cy);
	
	if (IsWindow(m_Lead.m_hWnd))
   {
      m_Lead.MoveWindow(0, 0, cx, cy);
      m_Lead.SetBackErase(FALSE);
   }
}

void CMagGlassView::OnClose() 
{
   if (m_Lead.GetHasMagGlass())
      StopMagGlass();

	CFormView::OnClose();
}

BOOL CMagGlassView::OnEraseBkgnd(CDC* pDC) 
{
   return TRUE;
}

void CMagGlassView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
{
	CFormView::OnActivateView(bActivate, pActivateView, pDeactiveView);

	if (bActivate)
	{
		ASSERT(pActivateView == this);
		OnDoRealize((WPARAM)theApp.m_pMainWnd->m_hWnd, (LPARAM) FALSE);   // same as SendMessage(WM_DOREALIZE);
      if(m_Lead.GetBitmap())
         m_Lead.ForceRepaint();
	}
}

void CMagGlassView::StartMagGlass()
{
   int nRet;

   nRet = m_Lead.StartMagGlass(m_fWidth,
                               m_fHeight,
                               m_iZoom,
                               m_ulclrPen,
                               m_ulclrBack,
                               m_bEllipse,
                               m_fBorderSize,
                               m_b3D,
                               m_iCrosshair,
                               m_bIgnoreRgn,
                               m_bCenter);
   if (nRet)
      theApp.DisplayLEADError(nRet);
   else
   {
      if (m_bRectShape)
         UpdateRectShape(FALSE);
      else if (m_bEllipseShape)
         UpdateEllipseShape(FALSE);
      else if (m_bRoundRectShape)
         UpdateRoundRectShape(FALSE);
      else if (m_bFreeHandShape)
         UpdateFreeHandShape(FALSE);

      if (m_bManualUpdate && m_LeadUpdate.GetBitmap())
      {
         nRet = m_Lead.UpdateMagGlassFromHandle(m_LeadUpdate.GetBitmap(), m_bUpdateSrcBitmap);
         if(nRet)
         {
            m_LeadUpdate.SetBitmap(0);
            theApp.DisplayLEADError(nRet);
         }
      }
   }
}

void CMagGlassView::StopMagGlass()
{
   m_Lead.StopMagGlass();
}

void CMagGlassView::CheckMenuItems(CMenu *pMenu)
{
   HMENU hMenu = NULL;
   HMENU hChildMenu = NULL;

   if (!pMenu)
      return;

   hMenu = pMenu->GetSafeHmenu ();
   if (!hMenu)
      return;

   hChildMenu = GetSubMenu (hMenu, 12);

   if (m_Lead.GetHasMagGlass())
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_STOP,MF_ENABLED);
      EnableMenuItem(hMenu,ID_MAGGLASS_START,MF_GRAYED);
   }
   else
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_STOP,MF_GRAYED);
      EnableMenuItem(hMenu,ID_MAGGLASS_START,MF_ENABLED);
   }

   if (m_bManualUpdate)
      CheckMenuItem(hMenu,ID_MAGGLASS_MANUAL_UPDATE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_MAGGLASS_MANUAL_UPDATE,MF_UNCHECKED);

   if (m_Lead.GetHasMagGlass() && m_bManualUpdate)
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_UPDATE_BITMAP,MF_ENABLED);
      EnableMenuItem(hMenu,ID_MAGGLASS_UPDATE_SOURCE,MF_ENABLED);
   }
   else
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_UPDATE_BITMAP,MF_GRAYED);
      EnableMenuItem(hMenu,ID_MAGGLASS_UPDATE_SOURCE,MF_GRAYED);
   }

   if (m_bUpdateSrcBitmap)
      CheckMenuItem(hMenu,ID_MAGGLASS_UPDATE_SOURCE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_MAGGLASS_UPDATE_SOURCE,MF_UNCHECKED);

   if (!m_b3D)
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_BORDER,MF_ENABLED);
   else
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_BORDER,MF_GRAYED);

   if (m_bRectShape)
      CheckMenuItem(hMenu,ID_SHAPE_RECTANGLE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_SHAPE_RECTANGLE,MF_UNCHECKED);

   if (m_bEllipseShape)
      CheckMenuItem(hMenu,ID_SHAPE_ELLIPSE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_SHAPE_ELLIPSE,MF_UNCHECKED);

   if (m_bRoundRectShape)
      CheckMenuItem(hMenu,ID_SHAPE_ROUND_RECTANGLE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_SHAPE_ROUND_RECTANGLE,MF_UNCHECKED);

   if (m_bFreeHandShape)
      CheckMenuItem(hMenu,ID_SHAPE_FREEHAND,MF_CHECKED);
   else
      CheckMenuItem(hMenu,ID_SHAPE_FREEHAND,MF_UNCHECKED);

   if (m_bRoundRectShape || m_bFreeHandShape)
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_WIDTH,MF_GRAYED);
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_HEIGHT,MF_GRAYED);
   }
   else
   {
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_WIDTH,MF_ENABLED);
      EnableMenuItem(hMenu,ID_MAGGLASS_RESIZE_HEIGHT,MF_ENABLED);
   }

   if (hChildMenu)
   {
      if (m_iCrosshair == CROSSHAIR_NONE)
      {
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_NONE,MF_CHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_FINE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_PEN,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_SCREEN,MF_UNCHECKED);
      }
      else if (m_iCrosshair == CROSSHAIR_FINE)
      {
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_NONE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_FINE,MF_CHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_PEN,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_SCREEN,MF_UNCHECKED);
      }
      else if (m_iCrosshair == CROSSHAIR_INVERTPEN)
      {
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_NONE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_FINE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_PEN,MF_CHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_SCREEN,MF_UNCHECKED);
      }
      else
      {
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_NONE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_FINE,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_PEN,MF_UNCHECKED);
         CheckMenuItem(hChildMenu,ID_CROSSHAIR_INVERT_SCREEN,MF_CHECKED);
      }
   }

}

void CMagGlassView::UpdateRectShape(BOOL bUpdateShape) 
{
   int   nRet;
   BOOL  bUpdate = FALSE;

   if (bUpdateShape)
   {
      if (!m_bRectShape)
         bUpdate = TRUE;
   }
   else
      bUpdate = TRUE;

   if (bUpdate)
   {
      BeginWaitCursor();

      if (m_Lead.GetHasMagGlass())
      {
         nRet = m_Lead.UpdateMagGlassShape(MAGGLASS_SHAPE_RECT, NULL);
         if (nRet)
            theApp.DisplayLEADError(nRet);
      }

      m_bRectShape = TRUE;

      m_bEllipseShape = FALSE;
      m_bFreeHandShape = FALSE;
      m_bRoundRectShape = FALSE;

      EndWaitCursor();
   }
}

void CMagGlassView::UpdateEllipseShape(BOOL bUpdateShape) 
{
   int   nRet;
   BOOL  bUpdate = FALSE;

   if (bUpdateShape)
   {
      if (!m_bEllipseShape)
         bUpdate = TRUE;
   }
   else
      bUpdate = TRUE;

   if (bUpdate)
   {
      BeginWaitCursor();

      if (m_Lead.GetHasMagGlass())
      {
         nRet = m_Lead.UpdateMagGlassShape(MAGGLASS_SHAPE_ELLIPSE, NULL);
         if (nRet)
            theApp.DisplayLEADError(nRet);
      }

      m_bEllipseShape = TRUE;

      m_bRectShape = FALSE;
      m_bFreeHandShape = FALSE;
      m_bRoundRectShape = FALSE;

      EndWaitCursor();
   }
}

void CMagGlassView::UpdateRoundRectShape(BOOL bUpdateShape) 
{
   int            nRet;
   BOOL           bUpdate = FALSE;
   CRoundRectDlg  RoundRectDlg;

   if (bUpdateShape)
   {
      if (RoundRectDlg.DoModal() == IDOK)
      {
         if (m_hMagGlassRgn)
         {
            ::DeleteRgn(m_hMagGlassRgn);
            m_hMagGlassRgn = NULL;
         }
         m_hMagGlassRgn = ::CreateRectRgn(0, 0, 0, 0);
         ::CombineRgn(m_hMagGlassRgn,
                      RoundRectDlg.m_hRoundRectRgn,
                      NULL,
                      RGN_COPY);

         bUpdate = TRUE;
      }
   }
   else if (m_bRoundRectShape)
      bUpdate = TRUE;

   if (bUpdate)
   {
      BeginWaitCursor();

      if (m_Lead.GetHasMagGlass())
      {
         nRet = m_Lead.UpdateMagGlassShape(MAGGLASS_SHAPE_HRGN, (long)m_hMagGlassRgn);
         if (nRet)
            theApp.DisplayLEADError(nRet);
      }

      m_bRoundRectShape = TRUE;

      m_bRectShape = FALSE;
      m_bEllipseShape = FALSE;
      m_bFreeHandShape = FALSE;

      EndWaitCursor();
   }
}

void CMagGlassView::UpdateFreeHandShape(BOOL bUpdateShape) 
{
   int            nRet;
   BOOL           bUpdate = FALSE;
   CFreeHandDlg   FreeHandDlg;

   if (bUpdateShape)
   {
      if (FreeHandDlg.DoModal() == IDOK)
      {
         if (m_hMagGlassRgn)
         {
            ::DeleteRgn(m_hMagGlassRgn);
            m_hMagGlassRgn = NULL;
         }

         m_hMagGlassRgn = ::CreateRectRgn(0, 0, 0, 0);
         if (m_hMagGlassRgn && FreeHandDlg.m_hFreeHandRgn)
         {
            ::CombineRgn(m_hMagGlassRgn,
                         FreeHandDlg.m_hFreeHandRgn,
                         NULL,
                         RGN_COPY);

            bUpdate = TRUE;
         }
      }
   }
   else if (m_bFreeHandShape)
      bUpdate = TRUE;

   if (bUpdate)
   {
      BeginWaitCursor();

      if (m_Lead.GetHasMagGlass())
      {
         nRet = m_Lead.UpdateMagGlassShape(MAGGLASS_SHAPE_HRGN, (long)m_hMagGlassRgn);
         if (nRet)
            theApp.DisplayLEADError(nRet);
      }

      m_bFreeHandShape = TRUE;

      m_bRectShape = FALSE;
      m_bEllipseShape = FALSE;
      m_bRoundRectShape = FALSE;

      EndWaitCursor();
   }
}

void CMagGlassView::OnEditCopy() 
{
   int nRet;

   BeginWaitCursor();
   
   nRet = m_Lead.Copy(COPY_DIB | COPY_DDB | COPY_PALETTE);
   if (nRet)
      theApp.DisplayLEADError(nRet);

   EndWaitCursor();
}

void CMagGlassView::OnStartMagGlass() 
{
   if (!m_Lead.GetHasMagGlass())
   {
      BeginWaitCursor();

      m_Lead.SetMagGlassMaskCount(m_nMaskCount);

      m_Lead.SetPanWinPaintDither(m_iPaintDither);
      m_Lead.SetPanWinPaintScaling(m_iPaintScaling);
      m_Lead.SetPanWinPaintPalette(m_iPaintPalette);
      m_Lead.SetPanWinBitonalScaling(m_iBitonalScaling);

      StartMagGlass();

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateStartMagGlass(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_Lead.GetHasMagGlass());
}

void CMagGlassView::OnStopMagGlass() 
{
   if (m_Lead.GetHasMagGlass())
   {
      BeginWaitCursor();

      StopMagGlass();

      if (m_LeadUpdate.GetBitmap())
         m_LeadUpdate.SetBitmap(0);

      m_bUpdateSrcBitmap = FALSE;

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateStopMagGlass(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_Lead.GetHasMagGlass());
}

void CMagGlassView::OnMagGlassManualUpdate() 
{
   BeginWaitCursor();

   m_bManualUpdate = !m_bManualUpdate;

   if (m_bManualUpdate)
      m_iMagGlassFlags |= MAGGLASS_MANUAL_UPDATE;
   else
      m_iMagGlassFlags = MAGGLASS_MASK_NORMAL;

   m_Lead.SetMagGlassFlags(m_iMagGlassFlags);

   if (m_Lead.GetHasMagGlass())
   {
      StopMagGlass();
      StartMagGlass();
   }

   EndWaitCursor();
}

void CMagGlassView::OnUpdateMagGlassManualUpdate(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bManualUpdate);
}

void CMagGlassView::OnUpdateMagGlassBitmap() 
{
   int nRet =0;
   theApp.m_pRasterFileDlg->PutDialogTitle("Update Magnifying Glass Bitmap");
   
   theApp.m_pRasterFileDlg->PutUIFlags(OPEN_SHOW_FILEINFO  |
                                       OPEN_SHOW_MULTIPAGE |
                                       OPEN_SHOW_DELPAGE   |
                                       OPEN_SHOW_PREVIEW   |
                                       OPEN_USEFILESTAMP);

   nRet = theApp.m_pRasterFileDlg->ShowOpenDlg((long)m_hWnd);
   if(nRet != 0)
   {
      theApp.DisplayLEADError(nRet);
      return;
   }
   
   if(theApp.m_pRasterFileDlg->GetDialogStatus()==DLG_CANCEL)
      return;

   BeginWaitCursor();
   nRet = m_LeadUpdate.Load(theApp.m_pRasterFileDlg->GetFileName(),
                            0,
                            theApp.m_pRasterFileDlg->GetPageNumber(),
                            1);
   if(nRet)
   {
      m_Lead.UpdateMagGlassFromHandle(0, m_bUpdateSrcBitmap);
      theApp.DisplayLEADError(nRet);
   }
   else
   {
      nRet = m_Lead.UpdateMagGlassFromHandle(m_LeadUpdate.GetBitmap(), m_bUpdateSrcBitmap);
      if(nRet)
      {
         m_LeadUpdate.SetBitmap(0);
         theApp.DisplayLEADError(nRet);
      }
   }

   EndWaitCursor();
}

void CMagGlassView::OnUpdateUpdateMagGlassBitmap(CCmdUI* pCmdUI) 
{   
   pCmdUI->Enable(m_Lead.GetHasMagGlass() && m_bManualUpdate);
}

void CMagGlassView::OnUpdateSourceBitmap() 
{
   int nRet;
   
   m_bUpdateSrcBitmap= !m_bUpdateSrcBitmap;

   if (m_LeadUpdate.GetBitmap())
   {
      BeginWaitCursor();

      nRet = m_Lead.UpdateMagGlassFromHandle(m_LeadUpdate.GetBitmap(), m_bUpdateSrcBitmap );
      if(nRet)
      {
         m_LeadUpdate.SetBitmap(0);
         theApp.DisplayLEADError(nRet);
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateUpdateSourceBitmap(CCmdUI* pCmdUI) 
{

   if (m_Lead.GetHasMagGlass() && m_bManualUpdate)
   {
      pCmdUI->Enable();
      pCmdUI->SetCheck(m_bUpdateSrcBitmap);
   }
   else
   {
      m_bUpdateSrcBitmap = FALSE;
      pCmdUI->Enable(FALSE);
      pCmdUI->SetCheck(FALSE);
   }
}

void CMagGlassView::OnMagglassResizeWidth() 
{
   CResizeDlg ResizeWidthDlg((int)m_fWidth, WIDTH_RESIZE_DLG);

   if (ResizeWidthDlg.DoModal() == IDOK)
   {
      BeginWaitCursor();

      m_fWidth = (float)ResizeWidthDlg.m_nValue;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateMagglassResizeWidth(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bRoundRectShape && !m_bFreeHandShape);
}

void CMagGlassView::OnMagglassResizeHeight() 
{
   CResizeDlg ResizeHeightDlg((int)m_fHeight, HEIGHT_RESIZE_DLG);

   if (ResizeHeightDlg.DoModal() == IDOK)
   {
      BeginWaitCursor();

      m_fHeight = (float)ResizeHeightDlg.m_nValue;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateMagglassResizeHeight(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bRoundRectShape && !m_bFreeHandShape);
}

void CMagGlassView::OnMagglassResizeBorder() 
{
   CResizeDlg ResizeBorderDlg((int)m_fBorderSize, BORDER_RESIZE_DLG);

   if (ResizeBorderDlg.DoModal() == IDOK)
   {
      BeginWaitCursor();

      m_fBorderSize = (float)ResizeBorderDlg.m_nValue;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateMagglassResizeBorder(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_b3D);
}

void CMagGlassView::OnMagglassZoomFactor() 
{
   CResizeDlg ZoomFactorDlg(m_iZoom, ZOOM_RESIZE_DLG);

   if (ZoomFactorDlg.DoModal() == IDOK)
   {
      BeginWaitCursor();

      m_iZoom = ZoomFactorDlg.m_nValue;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnColorsBorder() 
{
   int nRet;

   theApp.m_pRasterClrDlg->UIFlags = COLOR_SHOW_OLDCOLOR         |
                                COLOR_SHOW_NEWCOLOR              |
                                COLOR_SHOW_NAME                  |
                                COLOR_COLORSPACE_SHOW_HUE        |
                                COLOR_COLORSPACE_SHOW_BRIGHTNESS |
                                COLOR_COLORSPACE_SHOW_WHEEL      |
                                COLOR_COLORSPACE_SHOW_RGB        |
                                COLOR_COLORSPACE_SHOW_CMY        |
                                COLOR_COLORSPACE_SHOW_CMYK       |
                                COLOR_COLORSPACE_SHOW_LAB        |
                                COLOR_COLORMODEL_SHOW_RGB        |
                                COLOR_COLORMODEL_SHOW_HSB        |
                                COLOR_COLORMODEL_SHOW_HLS        |
                                COLOR_COLORMODEL_SHOW_CMY        |
                                COLOR_COLORMODEL_SHOW_CMYK       |
                                COLOR_COLORMODEL_SHOW_LAB;
   
   nRet= theApp.m_pRasterClrDlg->ShowColorDlg ((long)this->m_hWnd);
   
   if ( nRet == 0 && theApp.m_pRasterClrDlg->DialogStatus ==DLG_OK )   
   {
      BeginWaitCursor();
      m_ulclrPen = theApp.m_pRasterClrDlg->SelectedColor;
      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }
      EndWaitCursor();
   }
}

void CMagGlassView::OnColorsBack() 
{
   int nRet;

   theApp.m_pRasterClrDlg->UIFlags = COLOR_SHOW_OLDCOLOR         |
                                COLOR_SHOW_NEWCOLOR              |
                                COLOR_SHOW_NAME                  |
                                COLOR_COLORSPACE_SHOW_HUE        |
                                COLOR_COLORSPACE_SHOW_BRIGHTNESS |
                                COLOR_COLORSPACE_SHOW_WHEEL      |
                                COLOR_COLORSPACE_SHOW_RGB        |
                                COLOR_COLORSPACE_SHOW_CMY        |
                                COLOR_COLORSPACE_SHOW_CMYK       |
                                COLOR_COLORSPACE_SHOW_LAB        |
                                COLOR_COLORMODEL_SHOW_RGB        |
                                COLOR_COLORMODEL_SHOW_HSB        |
                                COLOR_COLORMODEL_SHOW_HLS        |
                                COLOR_COLORMODEL_SHOW_CMY        |
                                COLOR_COLORMODEL_SHOW_CMYK       |
                                COLOR_COLORMODEL_SHOW_LAB;
   
   nRet= theApp.m_pRasterClrDlg->ShowColorDlg ((long)this->m_hWnd);
   
   if ( nRet == 0 && theApp.m_pRasterClrDlg->DialogStatus ==DLG_OK )   
   {
      BeginWaitCursor();
      m_ulclrBack = theApp.m_pRasterClrDlg->SelectedColor;
      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }
      EndWaitCursor();
   }
}

void CMagGlassView::OnOptions3d() 
{
   BeginWaitCursor();

   m_b3D = !m_b3D;

   if (m_Lead.GetHasMagGlass())
   {
      StopMagGlass();
      StartMagGlass();
   }

   EndWaitCursor();
}

void CMagGlassView::OnUpdateOptions3d(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_b3D);
}

void CMagGlassView::OnCrosshairNone() 
{
   if (m_iCrosshair != CROSSHAIR_NONE)
   {
      BeginWaitCursor();

      m_iCrosshair = CROSSHAIR_NONE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCrosshairNone(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iCrosshair == CROSSHAIR_NONE);
}

void CMagGlassView::OnCrosshairFine() 
{
   if (m_iCrosshair != CROSSHAIR_FINE)
   {
      BeginWaitCursor();

      m_iCrosshair = CROSSHAIR_FINE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCrosshairFine(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iCrosshair == CROSSHAIR_FINE);
}

void CMagGlassView::OnCrosshairInvertPen() 
{
   if (m_iCrosshair != CROSSHAIR_INVERTPEN)
   {
      BeginWaitCursor();

      m_iCrosshair = CROSSHAIR_INVERTPEN;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCrosshairInvertPen(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iCrosshair == CROSSHAIR_INVERTPEN);
}

void CMagGlassView::OnCrosshairInvertScreen() 
{
   if (m_iCrosshair != CROSSHAIR_INVERTSCREEN)
   {
      BeginWaitCursor();

      m_iCrosshair = CROSSHAIR_INVERTSCREEN;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCrosshairInvertScreen(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iCrosshair == CROSSHAIR_INVERTSCREEN);
}

void CMagGlassView::OnAreaCenter() 
{
   if (!m_bCenter)
   {
      BeginWaitCursor();

      m_bCenter = TRUE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateAreaCenter(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bCenter);
}

void CMagGlassView::OnAreaTopleft() 
{
   if (m_bCenter)
   {
      BeginWaitCursor();

      m_bCenter = FALSE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateAreaTopleft(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(!m_bCenter);
}

void CMagGlassView::OnPaletteAuto() 
{
   if (m_iPaintPalette != PAINTPALETTE_AUTO)
   {
      BeginWaitCursor();
      m_iPaintPalette = PAINTPALETTE_AUTO;
      m_Lead.SetPanWinPaintPalette(m_iPaintPalette);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdatePaletteAuto(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintPalette == PAINTPALETTE_AUTO);
}

void CMagGlassView::OnPaletteFixed() 
{
   if (m_iPaintPalette != PAINTPALETTE_FIXED)
   {
      BeginWaitCursor();
      m_iPaintPalette = PAINTPALETTE_FIXED;
      m_Lead.SetPanWinPaintPalette(m_iPaintPalette);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdatePaletteFixed(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintPalette == PAINTPALETTE_FIXED);
}

void CMagGlassView::OnDitheringOrdered() 
{
   if (m_iPaintDither != PAINTDITHER_ORDERED)
   {
      BeginWaitCursor();
      m_iPaintDither = PAINTDITHER_ORDERED;
      m_Lead.SetPanWinPaintDither(m_iPaintDither);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateDitheringOrdered(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintDither == PAINTDITHER_ORDERED);
}

void CMagGlassView::OnDitheringErrorDiffusion() 
{
   if (m_iPaintDither != PAINTDITHER_DIFFUSION)
   {
      BeginWaitCursor();
      m_iPaintDither = PAINTDITHER_DIFFUSION;
      m_Lead.SetPanWinPaintDither(m_iPaintDither);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateDitheringErrorDiffusion(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintDither == PAINTDITHER_DIFFUSION);
}

void CMagGlassView::OnBitonalscalingNormal() 
{
   if (m_iBitonalScaling != BITONALSCALING_NORMAL)
   {
      BeginWaitCursor();
      m_iBitonalScaling = BITONALSCALING_NORMAL;
      m_Lead.SetPanWinBitonalScaling(m_iBitonalScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateBitonalscalingNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iBitonalScaling == BITONALSCALING_NORMAL);
}

void CMagGlassView::OnBitonalscalingFavorBlack() 
{
   if (m_iBitonalScaling != BITONALSCALING_FAVORBLACK)
   {
      BeginWaitCursor();
      m_iBitonalScaling = BITONALSCALING_FAVORBLACK;
      m_Lead.SetPanWinBitonalScaling(m_iBitonalScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateBitonalscalingFavorBlack(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iBitonalScaling == BITONALSCALING_FAVORBLACK);
}

void CMagGlassView::OnBitonalscalingScaleToGray() 
{
   if (m_iBitonalScaling != BITONALSCALING_SCALETOGRAY)
   {
      BeginWaitCursor();
      m_iBitonalScaling = BITONALSCALING_SCALETOGRAY;
      m_Lead.SetPanWinBitonalScaling(m_iBitonalScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateBitonalscalingScaleToGray(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iBitonalScaling == BITONALSCALING_SCALETOGRAY);
}

void CMagGlassView::OnPaintscalingNormal() 
{
   if (m_iPaintScaling != PAINTSCALING_NORMAL)
   {
      BeginWaitCursor();
      m_iPaintScaling = PAINTSCALING_NORMAL;
      m_Lead.SetPanWinPaintScaling(m_iPaintScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdatePaintscalingNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintScaling == PAINTSCALING_NORMAL);
}

void CMagGlassView::OnPaintscalingResample() 
{
   if (m_iPaintScaling != PAINTSCALING_RESAMPLE)
   {
      BeginWaitCursor();
      m_iPaintScaling = PAINTSCALING_RESAMPLE;
      m_Lead.SetPanWinPaintScaling(m_iPaintScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdatePaintscalingResample(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintScaling == PAINTSCALING_RESAMPLE);
}

void CMagGlassView::OnPaintscalingBicubic() 
{
   if (m_iPaintScaling != PAINTSCALING_BICUBIC)
   {
      BeginWaitCursor();
      m_iPaintScaling = PAINTSCALING_BICUBIC;
      m_Lead.SetPanWinPaintScaling(m_iPaintScaling);
      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdatePaintscalingBicubic(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_iPaintScaling == PAINTSCALING_BICUBIC);
}

void CMagGlassView::OnPaintIntensity() 
{
   int nRet;
   //assign the bitmap for preview
   theApp.m_pRasterClrDlg->PutBitmap(m_Lead.GetBitmap());
   theApp.m_pRasterClrDlg->PutChange(m_Lead.GetMagGlassPaintIntensity() / 10);
   theApp.m_pRasterClrDlg->PutUIFlags(BRIGHTNESS_SHOW_PREVIEW | BRIGHTNESS_SHOW_TOOL_ZOOMLEVEL);
   nRet = theApp.m_pRasterClrDlg->ShowBrightnessDlg((long)this->m_hWnd); /* the method */
   if(nRet == 0 && theApp.m_pRasterClrDlg->GetDialogStatus() == DLG_OK)
   {
      
      BeginWaitCursor();
      m_Lead.SetMagGlassPaintIntensity(theApp.m_pRasterClrDlg->GetChange()); /* GetChange: The property */

      EndWaitCursor();   
   }
   else 
      theApp.DisplayLEADError(nRet);
}

void CMagGlassView::OnPaintGamma() 
{
   int nRet;

   theApp.m_pRasterClrDlg->PutGammaRedValue(m_Lead.GetMagGlassPaintGamma());
   theApp.m_pRasterClrDlg->PutBitmap(m_Lead.GetBitmap());
   theApp.m_pRasterClrDlg->PutUIFlags(GAMMAADJUSTMENT_SHOW_PREVIEW | 
                                      GAMMAADJUSTMENT_SHOW_TOOL_ZOOMLEVEL | 
                                      GAMMAADJUSTMENT_FORCELINKCHANNELS
                                     );
   nRet = theApp.m_pRasterClrDlg->ShowGammaAdjustmentDlg((long)this->m_hWnd); /* the method */
   
   if(nRet == 0 && theApp.m_pRasterClrDlg->GetDialogStatus() == DLG_OK)
   {
      BeginWaitCursor();
      m_Lead.SetMagGlassPaintGamma(theApp.m_pRasterClrDlg->GetGammaRedValue()); /* GetChange: The property */
      EndWaitCursor();
   }
   else
      theApp.DisplayLEADError(nRet);
}

void CMagGlassView::OnPaintContrast() 
{
   int nRet;
   //assign the bitmap for preview
   theApp.m_pRasterClrDlg->PutBitmap(m_Lead.GetBitmap());
   theApp.m_pRasterClrDlg->PutChange(m_Lead.GetMagGlassPaintContrast() / 10); 
   theApp.m_pRasterClrDlg->PutUIFlags(CONTRAST_SHOW_PREVIEW|CONTRAST_SHOW_TOOL_ZOOMLEVEL);

   nRet = theApp.m_pRasterClrDlg->ShowContrastDlg((long)this->m_hWnd);
   if(nRet == 0 && theApp.m_pRasterClrDlg->GetDialogStatus() == DLG_OK)
   {
      BeginWaitCursor();
      m_Lead.SetMagGlassPaintContrast(theApp.m_pRasterClrDlg->GetChange());  /* GetChange: The property */
      
      EndWaitCursor();
   }
   else 
      theApp.DisplayLEADError(nRet);
}

void CMagGlassView::OnCursorRectangle() 
{
   if (!m_bRectCursor)
   {
      BeginWaitCursor();

      /* Set the Rectangle cursor */
      m_bRectCursor = TRUE;

      /* Disable any other cursor */
      m_bCustomCursor = FALSE;
      m_bEllipseCursor = FALSE;

      m_bEllipse = FALSE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCursorRectangle(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bRectCursor);
}

void CMagGlassView::OnCursorEllipse() 
{
   if (!m_bEllipseCursor)
   {
      BeginWaitCursor();

      /* Set the Ellipse cursor */
      m_bEllipseCursor = TRUE;

      /* Disable any other cursor */
      m_bRectCursor = FALSE;
      m_bCustomCursor = FALSE;

      m_bEllipse = TRUE;

      if (m_Lead.GetHasMagGlass())
      {
         StopMagGlass();
         StartMagGlass();
      }

      EndWaitCursor();
   }
}

void CMagGlassView::OnUpdateCursorEllipse(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bEllipseCursor);
}

void CMagGlassView::OnShapeRectangle() 
{
   UpdateRectShape(TRUE);
}

void CMagGlassView::OnUpdateShapeRectangle(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bRectShape);
}

void CMagGlassView::OnShapeEllipse() 
{
   UpdateEllipseShape(TRUE);
}

void CMagGlassView::OnUpdateShapeEllipse(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bEllipseShape);
}

void CMagGlassView::OnShapeRoundRectangle() 
{
   UpdateRoundRectShape(TRUE);
}

void CMagGlassView::OnUpdateShapeRoundRectangle(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bRoundRectShape);
}

void CMagGlassView::OnShapeFreehand() 
{
   UpdateFreeHandShape(TRUE);
}

void CMagGlassView::OnUpdateShapeFreehand(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bFreeHandShape);
}

void CMagGlassView::OnAppAbout() 
{
   theApp.OnAppAbout();
}

BEGIN_EVENTSINK_MAP(CMagGlassView, CFormView)
    //{{AFX_EVENTSINK_MAP(CMagGlassView)
	ON_EVENT(CMagGlassView, IDC_LEADCTRL1, -605 /* MouseDown */, OnMouseDownLeadctrl1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CMagGlassView, IDC_LEADCTRL1, -606 /* MouseMove */, OnMouseMoveLeadctrl1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CMagGlassView, IDC_LEADCTRL1, -607 /* MouseUp */, OnMouseUpLeadctrl1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CMagGlassView, IDC_LEADCTRL1, 44 /* MagGlassCursor */, OnMagGlassCursorLeadctrl1, VTS_NONE)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

void CMagGlassView::OnMouseDownLeadctrl1(short Button, short Shift, long x, long y) 
{
   int nRet;

   // check for left mouse button
   if (Button == 1) 
      m_bLeftBtnDown = TRUE;

   // Detect right click to show context menu
   if (Button == 2 && !m_bLeftBtnDown)
   {
      RECT rc;
      CMenu ContextMenu;
      CMenu * pMenu = NULL;

      GetWindowRect (&rc);

      if (ContextMenu.LoadMenu (IDR_CONTEXT_MENU))
      {
         if (pMenu = ContextMenu.GetSubMenu (0))
         {
            CheckMenuItems (pMenu);
            pMenu->TrackPopupMenu (TPM_LEFTALIGN, rc.left + x, rc.top + y, this);
         }
      }
   }

   if (Button!=1 || !m_Lead.GetHasMagGlass() || !m_bManualUpdate)
      return;

   nRet = m_Lead.SetMagGlassPos((float)x, (float)y);
   if (nRet != 0)
   {
      theApp.DisplayLEADError(nRet);
      return;
   }

   nRet = m_Lead.ShowMagGlass(TRUE);
   if (nRet != 0)
   {
      theApp.DisplayLEADError(nRet);
      return;
   }

   ::ShowCursor(FALSE);
}

void CMagGlassView::OnMouseMoveLeadctrl1(short Button, short Shift, long x, long y) 
{
   int nRet;

   if (!m_Lead.GetHasMagGlass() || !m_bManualUpdate || !m_bLeftBtnDown)
      return;

   nRet = m_Lead.SetMagGlassPos((float)x, (float)y);
   if (nRet != 0)
      theApp.DisplayLEADError(nRet);
}

void CMagGlassView::OnMouseUpLeadctrl1(short Button, short Shift, long x, long y) 
{
   int nRet;

   // check for left mouse button
   if (Button == 1) 
      m_bLeftBtnDown = FALSE;

   if (Button!=1 || !m_Lead.GetHasMagGlass() || !m_bManualUpdate)
      return;

   nRet = m_Lead.ShowMagGlass(FALSE);
   if (nRet != 0)
   {
      theApp.DisplayLEADError(nRet);
      return;
   }

   ::ShowCursor(TRUE);
}

void CMagGlassView::OnMagGlassCursorLeadctrl1() 
{
   if (m_Lead.GetHasMagGlass() && m_bManualUpdate && !m_bLeftBtnDown)
   {
      if (m_bRectCursor)
         SetCursor(theApp.m_hRectCur);
      else 
         SetCursor(theApp.m_hEllipseCur);
   }
}

void CMagGlassView::OnMagglassWindowlevel() 
{
   int nRet;
   long MaxVal;
   long MinVal;
   m_LeadUpdate.SetBitmap(m_Lead.GetBitmap());
   m_LeadUpdate.GetMinMaxBits();
   theApp.m_pRasterClrDlg->PutLowBit(m_LeadUpdate.GetMinBit());
   theApp.m_pRasterClrDlg->PutHighBit(m_LeadUpdate.GetMaxBit());
   m_LeadUpdate.GetMinMaxVal();
   MinVal = m_LeadUpdate.GetMinVal();
   MaxVal = m_LeadUpdate.GetMaxVal();
   theApp.m_pRasterClrDlg->PutWindowLevelLow(MinVal);
   theApp.m_pRasterClrDlg->PutWindowLevelHigh(MaxVal); 

   switch ( m_LeadUpdate.GetIsGrayscale())
   {
      case GRAY_ORDEREDNORMAL:
      {
         theApp.m_pRasterClrDlg->StartColor = RGB ( 0, 0, 0 ) ;
         theApp.m_pRasterClrDlg->EndColor   = RGB ( 255, 255, 255 ) ;

         break ;
      }
      
      case GRAY_ORDEREDINVERSE:
      {
         theApp.m_pRasterClrDlg->StartColor = RGB ( 255, 255, 255 ) ;
         theApp.m_pRasterClrDlg->EndColor   = RGB ( 0, 0, 0 ) ;

         break ;
      }      
      
      case GRAY_NOTORDERED:
      {
         theApp.m_pRasterClrDlg->StartColor = RGB ( 0, 0, 0 ) ;
         theApp.m_pRasterClrDlg->EndColor   = RGB ( 255, 255, 255 ) ;

      break ;
      }
      
      default:
      {
         MessageBox ( TEXT ( "Window Level is not supported for this bitmap order" ), 
                      TEXT ( "Window Level Error" ),
                      MB_OK ) ;

         return;
      }
   }
     
   theApp.m_pRasterClrDlg->PutBitmap(m_LeadUpdate.GetBitmap());
   theApp.m_pRasterClrDlg->PutWindowLevelFlags ( FILLLUT_OUTSIDE | 
                                                 FILLLUT_LINEAR );
   theApp.m_pRasterClrDlg->PutUIFlags ( WINDOWLEVEL_SHOW_PREVIEW |
                                        WINDOWLEVEL_SHOW_TOOL_ZOOMLEVEL | 
                                        WINDOWLEVEL_SHOW_RANGE |
                                        WINDOWLEVEL_AUTOPROCESS );

   nRet = theApp.m_pRasterClrDlg->ShowWindowLevelDlg((long)this->m_hWnd);

   m_Lead.UpdateMagGlassFromHandle(m_LeadUpdate.GetBitmap(), m_bUpdateSrcBitmap);
   
   if(nRet != 0 )
      theApp.DisplayLEADError(nRet);
}

void CMagGlassView::OnUpdateMagglassWindowlevel(CCmdUI* pCmdUI) 
{
   BOOL bVal;

   bVal = FALSE;
   if((m_Lead.GetBitmapBits() == 12) || (m_Lead.GetBitmapBits() == 16))
      bVal = TRUE;
   if(m_Lead.GetIsGrayscale() == GRAY_NO)
      bVal = FALSE;
   pCmdUI->Enable(bVal);
}