#include "MainFram.h"
#include "Winuser.h"
#include "Dialogs.h"
#include "Child.h"
#include "Util.h"
#include "resource.h"


extern HWND hWndFrame,hWndClient;
extern HMENU hMenuInit,hChildMenu,hContextMenu;
extern HMENU hMenuInitWindow,hChildMenuWindow;
extern L_BOOL gbPaste;
extern HCURSOR hEllipseCur, hRectCur;

L_BOOL bInScroll = FALSE;


/*====(ChildWindowProc)====================================================
Description: 

Syntax:     static LRESULT CALLBACK ChildWindowProc(HWND hwnd, UINT msg, WPARAM wParam, 
                                                    LPARAM lParam)

==========================================================================*/


LRESULT CALLBACK ChildWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch(msg)
   {
      HANDLE_MSG (hwnd, WM_CREATE,           Child_OnCreate);
      HANDLE_MSG (hwnd, WM_PAINT,            Child_OnPaint);
      HANDLE_MSG (hwnd, WM_MDIACTIVATE,      Child_OnMDIActivate);
      HANDLE_MSG (hwnd, WM_DESTROY,          Child_OnDestroy);
      HANDLE_MSG (hwnd, WM_COMMAND,          Child_OnCommand);
      HANDLE_MSG (hwnd, WM_SIZE,             Child_OnSize);
      HANDLE_MSG (hwnd, WM_VSCROLL,          Child_OnVScroll);
      HANDLE_MSG (hwnd, WM_HSCROLL,          Child_OnHScroll);
      HANDLE_MSG (hwnd, WM_ERASEBKGND,       Child_OnEraseBkgnd);
      HANDLE_MSG (hwnd, WM_LBUTTONDOWN,      Child_OnLButtonDown);
      HANDLE_MSG (hwnd, WM_MOUSEMOVE,        Child_OnMouseMove);
      HANDLE_MSG (hwnd, WM_LBUTTONUP,        Child_OnLButtonUp);
      HANDLE_MSG (hwnd, WM_LBUTTONDBLCLK,    Child_OnLButtonDblClk);
      HANDLE_MSG (hwnd, WM_RBUTTONDOWN,      Child_OnRButtonDown);
      HANDLE_MSG (hwnd, WM_KILLFOCUS,        Child_OnKillFocus);
      HANDLE_MSG (hwnd, WM_SETCURSOR,        Child_OnSetCursor);
      /* For Palette */
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,   Child_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,  Child_OnQueryNewPalette);
   }

   return DefMDIChildProc(hwnd,msg,wParam,lParam);
}

/*====(Child_OnQueryNewPalette)=============================================
Description: 

Syntax:     L_BOOL Child_OnQueryNewPalette(HWND hwnd)

==========================================================================*/

L_BOOL Child_OnQueryNewPalette(HWND hwnd)
{
   HDC hDC;
   HPALETTE hPalette;
   L_INT nNoColors = 0;
   
   LPWINDOWDATA  pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   if (pData->hPalette)
   {
      DeleteObject (pData->hPalette);
      pData->hPalette = NULL;
   }

   if (pData->Bitmap.Flags.Allocated)
   {
      hDC = GetDC (hWndFrame);

      pData->hPalette = L_CreatePaintPalette (hDC, &pData->Bitmap);
      if (pData->hPalette)
      {
         hPalette = SelectPalette (hDC, pData->hPalette, FALSE);
         nNoColors = RealizePalette (hDC);
         if (nNoColors)
            InvalidateRect (hwnd, NULL, FALSE);
         SelectPalette (hDC, hPalette, TRUE);
      }
      ReleaseDC (hWndFrame, hDC);
   }
   
   return(nNoColors);
}

/*====(Child_OnPaletteChanged)=================================================
Description: 

Syntax:     L_VOID Child_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)

==========================================================================*/

L_VOID Child_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)
{
   HDC hDC;
   HPALETTE hPalette;

   LPWINDOWDATA  pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   if (hwnd == hwndPaletteChange)
      return;

   if (pData->hPalette)
   {
      DeleteObject (pData->hPalette);
      pData->hPalette = NULL;
   }

   hDC = GetDC (hwnd);

   pData->hPalette = L_CreatePaintPalette (hDC, &pData->Bitmap);

   hPalette = SelectPalette (hDC, pData->hPalette, TRUE);
   RealizePalette (hDC);
   InvalidateRect (hwnd, NULL, FALSE);

   SelectPalette (hDC, hPalette, TRUE);

   ReleaseDC (hwnd, hDC);
}


/*====(Child_OnDestroy)=================================================
Description: 

Syntax:     L_VOID Child_OnDestroy(HWND hwnd)

==========================================================================*/

L_VOID Child_OnDestroy(HWND hwnd)
{
   LPWINDOWDATA  pData = (LPWINDOWDATA) GetWindowLong(hwnd, GWL_USERDATA);

   if (pData)
   {
      if (pData->hPalette)
         DeletePalette(pData->hPalette);

      if (pData->Bitmap.Flags.Allocated)
         L_FreeBitmap(&pData->Bitmap);

      if (pData->MagGlassData.UpdateBitmap.Flags.Allocated)
         L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
   }

   GlobalFreePtr(pData);
}

/*====(Child_OnCreate)=================================================
Description: 

Syntax:     void Child_OnCreate(HWND hwnd,CREATESTRUCT * Createst)

==========================================================================*/

L_BOOL Child_OnCreate(HWND hwnd,CREATESTRUCT * pCreatest)
{
   LPWINDOWDATA      pCd;
   LPWINDOWDATA      pTmpData;
   MDICREATESTRUCT*  pMdics = NULL;

   pTmpData = (LPWINDOWDATA) GlobalAllocPtr(GHND,sizeof(WINDOWDATA));
 
   pMdics =(MDICREATESTRUCT*) pCreatest->lpCreateParams;

   pCd = (LPWINDOWDATA) pMdics->lParam;

   memcpy(pTmpData, pCd, sizeof(WINDOWDATA));

   L_CopyBitmap(&pTmpData->Bitmap,&pCd->Bitmap, sizeof(BITMAPHANDLE));

   pTmpData->hWnd = hwnd;

   if (L_IsGrayScaleBitmap(&pTmpData->Bitmap) && 
      ((pTmpData->Bitmap.BitsPerPixel == 12) || (pTmpData->Bitmap.BitsPerPixel == 16)))
      pTmpData->Flags.bWindowLevel = TRUE;
   else
      pTmpData->Flags.bWindowLevel = FALSE;

   pTmpData->MagGlassData.bStart=FALSE;
   Child_ResetMagGlassData(pTmpData);

   SetWindowLong(hwnd, GWL_USERDATA, (LONG)pTmpData);

   return TRUE;
}

/*====(Child_OnPaint)=================================================
Description: 

Syntax:     L_VOID Child_OnPaint(HWND hwnd)

==========================================================================*/

L_VOID Child_OnPaint(HWND hwnd)
{
   LPWINDOWDATA  pData=NULL;
   HDC hDC;                     /* Handle to Device Context */
   PAINTSTRUCT ps;              /* Paint structure Data */
   HPALETTE hOldPal = 0;        /* Palette handle */
   hDC = BeginPaint (hwnd, &ps);/* Get DC */

   pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);   
  
   if (pData->Bitmap.Flags.Allocated) /* Do we have an image? */
   {

      /* for palette */
      if (pData->hPalette)
         hOldPal = SelectPalette (ps.hdc, pData->hPalette, TRUE);
      /* Paint it */
      L_PaintDC (ps.hdc, &pData->Bitmap, NULL, NULL, &pData->rcView, &ps.rcPaint, SRCCOPY);

      /* for Palette */
      if (pData->hPalette)
         SelectPalette (ps.hdc, hOldPal, TRUE);
   }

   EndPaint (hwnd, &ps);
}

/*====(Child_OnEraseBkgnd)=================================================
Description: 

Syntax:     L_BOOL Child_OnEraseBkgnd(HWND hWnd, HDC hDC)

==========================================================================*/

L_BOOL Child_OnEraseBkgnd(HWND hWnd, HDC hDC)
{
   RECT           rcView, rcClient;
   HRGN           hFillRgn = NULL;
   HRGN           hClientRgn = NULL;
   HGDIOBJ        hBrush;
   LPWINDOWDATA   pData;

   pData = (LPWINDOWDATA)GetWindowLong(hWnd, GWL_USERDATA);

   if(IsIconic(GetParent(hWnd)))
      hBrush = GetStockObject(BLACK_BRUSH);
   else
      hBrush = (HBRUSH) GetClassLong(hWnd, GCL_HBRBACKGROUND);

   GetClientRect(hWnd, &rcClient);
   GetUpdateRect(hWnd, &rcView, 0);

   if (bInScroll || pData)
   {
      IntersectRect(&rcView, &pData->rcView, &rcClient);
      hClientRgn = CreateRectRgnIndirect(&rcClient);
      hFillRgn = CreateRectRgnIndirect(&rcView);
      CombineRgn(hFillRgn, hClientRgn, hFillRgn, RGN_DIFF);
      FillRgn(hDC, hFillRgn, (HBRUSH)hBrush);
      DeleteObject(hFillRgn);
      DeleteObject(hClientRgn);
   }
   else
      FillRect(hDC, &rcClient, (HBRUSH)hBrush);

   return TRUE;
}

/*====(Child_OnMDIActivate)=================================================
Description: 

Syntax:     L_VOID Child_OnMDIActivate(HWND hwnd, L_BOOL activate, HWND hactivate,
                                       HWND hdeactivate)

==========================================================================*/

L_VOID Child_OnMDIActivate(HWND hwnd, L_BOOL activate, HWND hactivate,HWND hdeactivate)
{
   LPWINDOWDATA pWndData = NULL;

   pWndData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   if (activate)
   {
      pWndData->Flags.bCopy=TRUE;

      if (L_ClipboardReady())
         gbPaste=TRUE;
      else
         gbPaste=FALSE;

      Check_Menu_Items(hChildMenu,&(pWndData->Flags));

      FORWARD_WM_QUERYNEWPALETTE (hwnd, SendMessage); /* for palette*/

      FORWARD_WM_MDISETMENU(hWndClient,
                            TRUE,
                            hChildMenu,
                            hChildMenuWindow,
                            SendMessage);
   }
   else
   {
      if (L_ClipboardReady())
         gbPaste=TRUE;
      else
         gbPaste=FALSE;

      Check_Menu_Items(hMenuInit,NULL);

      FORWARD_WM_MDISETMENU(hWndClient,
                            TRUE,
                            hMenuInit,
                            hMenuInitWindow,
                            SendMessage);
   }

   DrawMenuBar(hWndFrame);
}

/*====(Child_OnCommand)=================================================
Description: 

Syntax:     L_VOID Child_OnCommand(HWND hwnd,L_INT id,HWND hwndCtl,UINT codeNotify)

==========================================================================*/

L_VOID Child_OnCommand(HWND hwnd,L_INT id,HWND hwndCtl,UINT codeNotify)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   switch(id)
   {
   case IDM_COPY:
      Child_Copy(hwnd);
      break;

   case IDM_START_MAGGLASS:
      Child_StartMagGlass(pData);
      pData->Flags.bStartMagGlass=pData->MagGlassData.bStart;
      Check_Menu_Items(hChildMenu,&(pData->Flags));
      Child_CheckMenuItems(hContextMenu, &(pData->Flags));
      break;

   case IDM_STOP_MAGGLASS:
      Child_StopMagGlass(pData);
      pData->Flags.bStartMagGlass=pData->MagGlassData.bStart;
      if (pData->MagGlassData.UpdateBitmap.Flags.Allocated)
         L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
      pData->Flags.bUpdateSourceBitmap = FALSE;
      Check_Menu_Items(hChildMenu, &(pData->Flags));
      Child_CheckMenuItems(hContextMenu, &(pData->Flags));
      break;

   case IDM_MANUAL_UPDATE:
      Child_ManualUpdate(pData);
      break;

   case IDM_UPDATE_BITMAP:
      Child_UpdateMagGlassBitmap(hwnd);
      break;

   case IDM_WINDOWLEVEL:
      Child_WindowLevel(hwnd);
      break;
   case IDM_UPDATE_SOURCE_BITMAP:
      Child_UpdateSourceMagGlassBitmap(hwnd);
      break;

   case IDM_RESIZE_MAG_WIDTH:
      ChDialog_OnResizeWidth(hwnd);
      break;

   case IDM_RESIZE_MAG_HEIGHT:
      ChDialog_OnResizeHeight(hwnd);
      break;

   case IDM_MAG_GLASS_BORDER:
      ChDialog_OnResizeBorder(hwnd);
      break;

   case IDM_MAG_GLASS_ZOOM:
      ChDialog_OnZoomFactor(hwnd);
      break;

   case IDM_BORDER_COLOR:
      ChDialog_BorderColor(hwnd);
      break;

   case IDM_BACK_COLOR:
      ChDialog_BackColor(hwnd);
      break;

   case IDM_BORDER_TYPE:
      Child_BorderType(hwnd);
      break;

   case IDM_NONE:
   case IDM_FINE:
   case IDM_INVERTPEN:
   case IDM_INVERTSCREEN:
      Child_CrossHair(hwnd,id);
      break;

   case IDM_MAG_GLASS_CENTER:
   case IDM_MAG_GLASS_TOPLEFTCORNER:
      Child_MagCenter(hwnd,id);
      break;

   case IDM_ORDEREDDITHER:
   case IDM_RESET_FLAGS:
   case IDM_FASTPAINT:
   case IDM_INDEXEDPAINT:
   case IDM_DITHEREDPAINT:
   case IDM_SCALETOGRAY:
   case IDM_HALFTONEPRINT:
   case IDM_FAVORBLACK:
   case IDM_FIXEDPALETTE:
   case IDM_NETSCAPEPALETTE:
   case IDM_RESAMPLE:
   case IDM_BICUBIC:
      Child_MagPaint(hwnd,id);
      break;

   case IDM_PAINT_INTENSITY:
      ChDialog_OnPaintIntensity(hwnd);
      break;

   case IDM_PAINT_GAMMA:
      ChDialog_OnPaintGamma(hwnd);
      break;

   case IDM_PAINT_CONTRAST:
      ChDialog_OnPaintContrast(hwnd);
      break;

   case IDM_RECTANGLE:
   case IDM_ELLIPSE:
   case IDM_CURFILE:
      Child_MagCursor(hwnd,id);
      break;

   case IDM_UPDATE_RECTANGLE:
      Child_UpdateRectangle(hwnd);
      break;

   case IDM_UPDATE_ELLIPSE:
      Child_UpdateEllipse(hwnd);
      break;

   case IDM_UPDATE_ROUNDRECTANGLE:
      Child_UpdateRoundRectangle(hwnd,TRUE);
      break;

   case IDM_UPDATE_FREEHAND:
      Child_UpdateFreeHand(hwnd,TRUE);
      break;
   }
}

/*====(Child_Copy)=================================================
Description: 

Syntax:     L_VOID Child_Copy(HWND hwnd)

==========================================================================*/

L_VOID Child_Copy(HWND hwnd)
{
   LPWINDOWDATA  pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   L_CopyToClipboard(hwnd, &pData->Bitmap,COPY2CB_EMPTY|COPY2CB_DIB);
   gbPaste=TRUE;
   Check_Menu_Items(hChildMenu,&(pData->Flags));
}

/*====(Child_OnSize)=================================================
Description: 

Syntax:     L_VOID Child_OnSize(HWND hWnd, UINT nState, L_INT nCx, L_INT nCy)

==========================================================================*/

L_VOID Child_OnSize(HWND hWnd, UINT nState, L_INT nCx, L_INT nCy)
{
   static L_BOOL fSizeInUse = FALSE;
   L_INT nWidth, nHeight, nVScroll, nHScroll;
   DWORD dwStyle;

   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hWnd,GWL_USERDATA);

   if (!fSizeInUse)
   {
      fSizeInUse = TRUE;

      if (nState != SIZEICONIC) /* If window is normal */
      {
         nWidth = BITMAPWIDTH(&pData->Bitmap);
         nHeight = BITMAPHEIGHT(&pData->Bitmap);

         /* Set client dimensions to current width and height */
         pData->cxClient = nCx;
         pData->cyClient = nCy;

         dwStyle = GetWindowLong (hWnd, GWL_STYLE);

         /* Get Vertical scroll arrow width */
         nVScroll = GetSystemMetrics (SM_CXVSCROLL);

         /* Get Horizontal scroll arrow width */
         nHScroll = GetSystemMetrics (SM_CXHSCROLL);

         /* If Vertical scroll */
         if (WS_VSCROLL & dwStyle)
            pData->cxClient += nVScroll;

         /* If Horizontal scroll */
         if (WS_HSCROLL & dwStyle)
            pData->cyClient += nHScroll;

         /* If client width  < current width  */
         if (pData->cxClient < nWidth)
         {
            pData->cyClient -= nHScroll;
            if (pData->cyClient < nHeight)
               pData->cxClient -= nVScroll;
         }

         /* If client height < current height */
         else if (pData->cyClient < nHeight)
         {
            pData->cxClient -= nVScroll;
            if (pData->cxClient < nWidth)
               pData->cyClient -= nHScroll;
         }

         /* Set Vertical scroll step = 1/10 of client height, if > 1 */
         pData->nVScrollStep = max (1, pData->cyClient / SCROLL_RATIO);

         /* Set vetical scroll range */
         pData->nVScrollMax = max (0, (nHeight - pData->cyClient /*- 1*/));

         /* Set vertical scroll position */
         pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax));

         /* Set Horizontal scroll step = 1/10 of client width, if > 1 */
         pData->nHScrollStep = max (1, pData->cxClient / SCROLL_RATIO);

         /* Set horizontal scroll range */
         pData->nHScrollMax = max (0, (nWidth - pData->cxClient /*- 1*/));

         /* Set horizontal scroll position */
         pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax));

         /* If Flags allocated */
         if (pData->Bitmap.Flags.Allocated)
         {
            /* Set rcView to new width and new height   */
            SetRect (&pData->rcView, 0, 0, nWidth, nHeight);

            /* Set offset by current scroll position */
            OffsetRect (&pData->rcView, -pData->nHScrollPos, -pData->nVScrollPos);
         }
         /* Set horizontal scroll range = nHScrollMax */
         SetScrollRange (hWnd, SB_HORZ, 0, pData->nHScrollMax, FALSE);

         /* Set horintal scroll position */
         SetScrollPos (hWnd, SB_HORZ, pData->nHScrollPos, TRUE);

         /* Set vertical scroll range = nVScrollMax */
         SetScrollRange (hWnd, SB_VERT, 0, pData->nVScrollMax, FALSE);

         /* Set vertical scroll position */
         SetScrollPos (hWnd, SB_VERT, pData->nVScrollPos, TRUE);
      }
      else                      /* If window is iconized */
      {
         /* Retain the x-client and y-client area */
         pData->cxClient = nCx;
         pData->cyClient = nCy;

         /* set client area  */
         SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient);
      }

      fSizeInUse = FALSE;
   }

   FORWARD_WM_SIZE(hWnd,nState,nCx,nCy,DefMDIChildProc);
}

/*====(Child_OnVScroll)=================================================
Description: 

Syntax:     L_VOID Child_OnVScroll(HWND hWnd, HWND hWndCtl, UINT nCode, L_INT nPos)

==========================================================================*/

L_VOID Child_OnVScroll(HWND hWnd, HWND hWndCtl, UINT nCode, L_INT nPos)
{
   L_INT nScrollInc;  /* Vertical Increment for Scroll */

   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hWnd,GWL_USERDATA);

   bInScroll = TRUE;

   switch (nCode)
   {
   case SB_BOTTOM:
      /* Increment by Difference between Max scroll and current scroll
         position */
      nScrollInc = pData->nVScrollMax - pData->nVScrollPos;
      break;
   case SB_TOP:
      /* Decrement by current scroll position */
      nScrollInc = -pData->nVScrollPos;
      break;
   case SB_LINEDOWN:
      /* Increment by one step */
      nScrollInc = pData->nVScrollStep;
      break;
   case SB_LINEUP:
      /* Decrement by one step */
      nScrollInc = -pData->nVScrollStep;
      break;
   case SB_PAGEDOWN:
      /* Increment by Maximum */
      nScrollInc = max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep));
      break;
   case SB_PAGEUP:
      /* Decrement by Maximum */
      nScrollInc = -max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep));
      break;
   case SB_THUMBPOSITION:
      /* Increment by Difference between Current scroll position and THUMB
         position */
      nScrollInc = nPos - pData->nVScrollPos;
      break;
   default:
      /* No increment  */
      nScrollInc = 0;
      break;
   }

   nScrollInc = max (-pData->nVScrollPos,
                     min (nScrollInc, (pData->nVScrollMax - pData->nVScrollPos)));

   /* if Scroll increment is greater than nScrollInc, Increment scroll
         position by nScrollInc */
   pData->nVScrollPos += nScrollInc;

   /* Reposition the picture at (0, -nScrollInc) */
   OffsetRect (&pData->rcView, 0, -nScrollInc);

   /* Scroll up the window by nSrollInc */
   ScrollWindow (hWnd, 0, -nScrollInc, NULL, NULL);

   /* Set new scroll position at current scroll position */
   SetScrollPos (hWnd, SB_VERT, pData->nVScrollPos, TRUE);

   /* Update window */
   UpdateWindow (hWnd);
   /* Update The Mag Glass*/
   if (pData->MagGlassData.bStart)
      L_UpdateMagGlassRect(pData->hWnd, &pData->rcView);

   bInScroll = FALSE;
}


/*======[Window_OnHScroll]===============================================

Syntax:     L_VOID Child_OnHScroll(HWND hWnd, HWND hWndCtl, UINT nCode,
                                   L_INT nPos)

=========================================================================*/

L_VOID Child_OnHScroll(HWND hWnd, HWND hWndCtl, UINT nCode, L_INT nPos)
{
   L_INT nScrollInc;            /* Horizontal Increment for scroll */

   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hWnd,GWL_USERDATA);

   bInScroll = TRUE;

   switch (nCode)
   {
      /* Decrement by current scroll position */
   case SB_LEFT:
      nScrollInc = -pData->nHScrollPos;
      break;

      /* Increment by the difference between Max scroll and current scroll
         position */
   case SB_RIGHT:
      nScrollInc = pData->nHScrollMax - pData->nHScrollPos;
      break;

      /* Decrement by one step */
   case SB_LINELEFT:
      nScrollInc = -pData->nHScrollStep;
      break;

      /* Increment by one step */
   case SB_LINERIGHT:
      nScrollInc = pData->nHScrollStep;
      break;

      /* Decrement by Maximum */
   case SB_PAGELEFT:
      nScrollInc = -max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep));
      break;

      /* Increment by Maximum */
   case SB_PAGERIGHT:
      nScrollInc = max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep));
      break;

      /* Increment by difference between current scroll position and THUMB
         position */
   case SB_THUMBPOSITION:
      nScrollInc = nPos - pData->nHScrollPos;
      break;

      /* No Increment */
   default:
      nScrollInc = 0;
      break;
   }

   nScrollInc = max (-pData->nHScrollPos,
                   min (nScrollInc, (pData->nHScrollMax - pData->nHScrollPos)));

   /* if Scroll increment is greater than nScrollInc, Increment scroll
       position by nScrollInc */
   pData->nHScrollPos += nScrollInc;

   /* Reposition the picture at (0, -nScrollInc) */
   OffsetRect (&pData->rcView, -nScrollInc, 0);

   /* Scroll left  the window by nSrollInc */
   ScrollWindow (hWnd, -nScrollInc, 0, NULL, NULL);

   /* Set new scroll position at current scroll position; */
   SetScrollPos (hWnd, SB_HORZ, pData->nHScrollPos, TRUE);

   /* Update window */
   UpdateWindow (hWnd);
   /* Update The Mag Glass*/
   if (pData->MagGlassData.bStart)
      L_UpdateMagGlassRect(pData->hWnd, &pData->rcView);

   bInScroll = FALSE;
}

/*======[Child_OnLButtonDown]==============================================

Syntax:     L_VOID Child_OnLButtonDown(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y,
                                       L_UINT keyFlags)

=========================================================================*/

L_VOID Child_OnLButtonDown(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y, L_UINT keyFlags)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!pData->MagGlassData.bStart || !pData->Flags.bManualUpdate)
      return;

   SetCapture(hWnd);
   ShowCursor(FALSE);

   nRet = L_SetMagGlassPos(hWnd, x, y);
   if (nRet != SUCCESS)
   {
      L_FileError(hWnd, nRet, TEXT("Displaying Magnifying Glass"), pData->szFilename);
      return;
   }

   nRet = L_ShowMagGlass(hWnd, TRUE);
   if (nRet != SUCCESS)
   {
      L_FileError(hWnd, nRet, TEXT("Displaying Magnifying Glass"), pData->szFilename);
      return;
   }

   pData->Flags.bLeftBtnDown = TRUE;
}

/*======[Child_OnMouseMove]===============================================

Syntax:     L_VOID Child_OnMouseMove(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)

=========================================================================*/

L_VOID Child_OnMouseMove(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!pData->MagGlassData.bStart || !pData->Flags.bManualUpdate || !pData->Flags.bLeftBtnDown)
      return;

   nRet = L_SetMagGlassPos(hWnd, x, y);
   if (nRet != SUCCESS)
      L_FileError(hWnd, nRet, TEXT("Moving Magnifying Glass"), pData->szFilename);
}

/*======[Child_OnLButtonUp]===============================================

Syntax:     L_VOID Child_OnLButtonUp(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)

=========================================================================*/

L_VOID Child_OnLButtonUp(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!pData->MagGlassData.bStart || !pData->Flags.bManualUpdate || !pData->Flags.bLeftBtnDown)
      return;

   ReleaseCapture();

   nRet = L_ShowMagGlass(hWnd, FALSE);
   if (nRet != SUCCESS)
      L_FileError(hWnd, nRet, TEXT("Hiding Magnifying Glass"), pData->szFilename);

   ShowCursor(TRUE);

   pData->Flags.bLeftBtnDown = FALSE;
}

/*======[Child_OnLButtonDblClk]============================================

Syntax:     L_VOID Child_OnLButtonDblClk(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y,
                                       L_UINT keyFlags)

=========================================================================*/

L_VOID Child_OnLButtonDblClk(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y, L_UINT keyFlags)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!pData->MagGlassData.bStart || !pData->Flags.bManualUpdate)
      return;

   SetCapture(hWnd);
   ShowCursor(FALSE);

   nRet = L_SetMagGlassPos(hWnd, x, y);
   if (nRet != SUCCESS)
   {
      L_FileError(hWnd, nRet, TEXT("Displaying Magnifying Glass"), pData->szFilename);
      return;
   }

   nRet = L_ShowMagGlass(hWnd, TRUE);
   if (nRet != SUCCESS)
   {
      L_FileError(hWnd, nRet, TEXT("Displaying Magnifying Glass"), pData->szFilename);
      return;
   }

   pData->Flags.bLeftBtnDown = TRUE;
}

/*======[Child_OnRButtonDown]==============================================

Syntax:     L_VOID Child_OnRButtonDown(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y,
                                       L_UINT keyFlags)

=========================================================================*/

L_VOID Child_OnRButtonDown(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y, L_UINT keyFlags)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   /* Restore screen */
   if (pData->MagGlassData.bStart && pData->Flags.bManualUpdate && pData->Flags.bLeftBtnDown)
   {
      ReleaseCapture();

      pData->Flags.bLeftBtnDown = FALSE;

      nRet = L_ShowMagGlass(hWnd, FALSE);
      if (nRet != SUCCESS)
         L_FileError(hWnd, nRet, TEXT("Hiding Magnifying Glass"), pData->szFilename);

      ShowCursor(TRUE);
   }
}

/*======[Child_OnKillFocus]===============================================

Syntax:     L_VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus)

=========================================================================*/

L_VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus)
{
   L_INT          nRet;
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   /* Restore screen */
   if (pData->MagGlassData.bStart && pData->Flags.bManualUpdate && pData->Flags.bLeftBtnDown)
   {
      ReleaseCapture();

      pData->Flags.bLeftBtnDown = FALSE;

      nRet = L_ShowMagGlass(hWnd, FALSE);
      if (nRet != SUCCESS)
         L_FileError(hWnd, nRet, TEXT("Hiding Magnifying Glass"), pData->szFilename);

      //InvalidateRect(hWnd, NULL, TRUE);
      ShowCursor(TRUE);
   }
}

/*======[Child_OnSetCursor]===============================================

Syntax:     L_BOOL Child_OnSetCursor(HWND hWnd, HWND hWndCursor, L_UINT codeHitTest, L_UINT msg)

=========================================================================*/

L_BOOL Child_OnSetCursor(HWND hWnd, HWND hWndCursor, L_UINT codeHitTest, L_UINT msg)
{
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (codeHitTest != HTCLIENT)
      return (FORWARD_WM_SETCURSOR(hWnd, hWndCursor, codeHitTest, msg, DefMDIChildProc));

   if (pData->MagGlassData.bStart && pData->Flags.bManualUpdate && !pData->Flags.bLeftBtnDown)
   {
      if (pData->Flags.bCurEllipse)
         SetCursor(hEllipseCur);
      else if (!pData->Flags.bCurFile)
         SetCursor(hRectCur);
      else
         SetCursor(pData->MagGlassData.hMagCursor);
   }

   return TRUE;
}

/*======[Child_ResetMagGlassData]=========================================

Syntax:     L_VOID Child_ResetMagGlassData(LPWINDOWDATA pData)

=========================================================================*/

L_VOID Child_ResetMagGlassData(LPWINDOWDATA pData)
{
   pData->MagGlassData.nWidth=150;
   pData->MagGlassData.nHeight=100;
   pData->MagGlassData.nZoom=400;
   pData->MagGlassData.clrPen=0;
   pData->MagGlassData.hMagCursor=NULL;
   pData->MagGlassData.clrBack=RGB(128,128,128);
   pData->MagGlassData.bEllipse=FALSE;
   pData->MagGlassData.nBorderSize=1;
   pData->MagGlassData.b3D=TRUE;
   pData->MagGlassData.uPaintFlags=0; 
   pData->MagGlassData.uMaskCount=0;
   pData->MagGlassData.uMagGlassFlags=MAGGLASS_MASK_NORMAL;
   pData->MagGlassData.nCrosshair=CROSSHAIR_FINE;
   pData->MagGlassData.bIgnoreRgn=TRUE;
   pData->MagGlassData.bCenter=TRUE;
   pData->MagGlassData.MagGlassPntOptions.nContrast = L_GetPaintContrast(&pData->Bitmap);
   pData->MagGlassData.MagGlassPntOptions.nGamma = L_GetPaintGamma(&pData->Bitmap);
   pData->MagGlassData.MagGlassPntOptions.nIntensity = L_GetPaintIntensity(&pData->Bitmap);

   /* The corosponding Flags */
   pData->Flags.bBorderType=TRUE;
   pData->Flags.bCurRect=TRUE;
   pData->Flags.bCenter=TRUE;
   pData->Flags.bUpdateRect=TRUE;
   pData->Flags.nCrossHairStyle=CROSSHAIR_FINE;
   pData->Flags.b3DBorder=TRUE;
   pData->Flags.bResizeBorder=FALSE;
   pData->Flags.bResizeWidth=TRUE;
   pData->Flags.bResizeHeight=TRUE;

   Child_CheckMenuItems(hContextMenu, &(pData->Flags));
}

/*======[Child_StartMagGlass]==============================================

Syntax:     L_VOID Child_StartMagGlass(LPWINDOWDATA pData)

=========================================================================*/

L_VOID Child_StartMagGlass(LPWINDOWDATA pData)
{
   L_INT    nRet;

   if (!pData->MagGlassData.bStart)
   {
      MAGGLASSOPTIONS magOpt;
      memset(&magOpt,0,sizeof(MAGGLASSOPTIONS));

      magOpt.uStructSize    = sizeof(MAGGLASSOPTIONS);
      magOpt.nWidth         = pData->MagGlassData.nWidth,
      magOpt.nHeight        = pData->MagGlassData.nHeight,
      magOpt.nZoom          = pData->MagGlassData.nZoom,
      magOpt.clrPen         = pData->MagGlassData.clrPen,
      magOpt.hMagCursor     = pData->MagGlassData.hMagCursor,
      magOpt.clrBack        = pData->MagGlassData.clrBack,
      magOpt.bEllipse       = pData->MagGlassData.bEllipse,
      magOpt.nBorderSize    = pData->MagGlassData.nBorderSize,
      magOpt.b3D            = pData->MagGlassData.b3D,
      magOpt.uPaintFlags    = pData->MagGlassData.uPaintFlags,
      magOpt.uMaskCount     = pData->MagGlassData.uMaskCount,
      magOpt.uMagGlassFlags = pData->MagGlassData.uMagGlassFlags,
      magOpt.nCrosshair     = pData->MagGlassData.nCrosshair,
      magOpt.bIgnoreRgn     = pData->MagGlassData.bIgnoreRgn,
      magOpt.bCenter        = pData->MagGlassData.bCenter,

      nRet = L_StartMagGlass(pData->hWnd,&pData->Bitmap,&pData->rcView,&magOpt,NULL,NULL);

      if (nRet != SUCCESS)
         L_FileError(pData->hWnd, nRet, TEXT("Starting Magnifying Glass"), pData->szFilename);
      else
      {
         pData->MagGlassData.bStart=TRUE;
         if (pData->Flags.bUpdateRect)
            Child_UpdateRectangle(pData->hWnd);

         if (pData->Flags.bUpdateEllipse)
            Child_UpdateEllipse(pData->hWnd);

         if (pData->Flags.bUpdateRoundRect)
            Child_UpdateRoundRectangle(pData->hWnd,FALSE);

         if (pData->Flags.bUpdateFreeHand)
            Child_UpdateFreeHand(pData->hWnd,FALSE);

         nRet = L_SetMagGlassPaintOptions(pData->hWnd, &pData->MagGlassData.MagGlassPntOptions);
         if (nRet != SUCCESS)
            L_FileError(pData->hWnd, nRet, TEXT("Setting Magnifying Glass paint options"), pData->szFilename);

         if (pData->Flags.bManualUpdate && pData->MagGlassData.UpdateBitmap.Flags.Allocated)
         {
            nRet = L_UpdateMagGlassBitmap(pData->hWnd, &pData->MagGlassData.UpdateBitmap, pData->Flags.bUpdateSourceBitmap);
            if (nRet != SUCCESS)
            {
               L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
               L_FileError(pData->hWnd, nRet, TEXT("Updating Magnifying Glass Bitmap"), pData->szFilename);
            }
         }
      }
   }
}

/*======[Child_StopMagGlass]=====================================================

Syntax:     L_VOID Child_StopMagGlass(LPWINDOWDATA pData)

=========================================================================*/

L_VOID Child_StopMagGlass(LPWINDOWDATA pData)
{
   if (pData->MagGlassData.bStart)
   {
      L_StopMagGlass(pData->hWnd);
      pData->MagGlassData.bStart = FALSE;
   }
}

/*======[ChDialog_OnResizeWidth]===========================================

Syntax:     L_VOID ChDialog_OnResizeWidth(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_OnResizeWidth(HWND hwnd)
{
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);

   SCROLLDLGDATA TmpWidth;

   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);

   TmpWidth.Value= pData->MagGlassData.nWidth;;
   TmpWidth.MaxRange= MAX_RESIZE_WH;
   TmpWidth.MinRange= MIN_RESIZE_WH;
   TmpWidth.Step= STEP_RESIZE_WH;
   wsprintf((LPTSTR)TmpWidth.szDlgText,TEXT("Resize Magnifying Glass Width"));
   wsprintf((LPTSTR)TmpWidth.szDlgMessage,TEXT("The size range is between %d and %d pixels"),MIN_RESIZE_WH,MAX_RESIZE_WH);

   if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_RESIZE_WH),hwnd,(DLGPROC)ResizeWHDlgProc,(LONG) &TmpWidth))
   {
      pData->MagGlassData.nWidth= TmpWidth.Value;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[ChDialog_OnResizeHeight]==========================================

Syntax:     L_VOID ChDialog_OnResizeHeight(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_OnResizeHeight(HWND hwnd)
{
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   SCROLLDLGDATA TmpHeight;
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   TmpHeight.Value=pData->MagGlassData.nHeight;
   TmpHeight.MaxRange=MAX_RESIZE_WH;
   TmpHeight.MinRange=MIN_RESIZE_WH;
   TmpHeight.Step=STEP_RESIZE_WH;
   wsprintf((LPTSTR)TmpHeight.szDlgText,TEXT("Resize Magnifying Glass Height"));
   wsprintf((LPTSTR)TmpHeight.szDlgMessage,TEXT("The size range is between %d and %d pixels"),MIN_RESIZE_WH,MAX_RESIZE_WH);
   if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_RESIZE_WH),hwnd,(DLGPROC)ResizeWHDlgProc,(LONG)&TmpHeight))
   {
      pData->MagGlassData.nHeight=TmpHeight.Value;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[ChDialog_OnResizeBorder]==========================================

Syntax:     L_VOID ChDialog_OnResizeBorder(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_OnResizeBorder(HWND hwnd)
{
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   SCROLLDLGDATA TmpBorder;
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   TmpBorder.Value=pData->MagGlassData.nBorderSize;
   TmpBorder.MaxRange=MAX_BORDER_SIZE;
   TmpBorder.MinRange=MIN_BORDER_SIZE;
   TmpBorder.Step=STEP_BORDER_SIZE;
   wsprintf((LPTSTR)TmpBorder.szDlgText,TEXT("Resize Magnifying Glass Border"));
   wsprintf((LPTSTR)TmpBorder.szDlgMessage,TEXT("The size range is between %d and %d pixels"),MIN_BORDER_SIZE,MAX_BORDER_SIZE);
   if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_RESIZE_WH),hwnd,(DLGPROC)ResizeWHDlgProc,(LONG)&TmpBorder))
   {
      pData->MagGlassData.nBorderSize=TmpBorder.Value;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[ChDialog_OnZoomFactor]============================================

Syntax:     L_VOID ChDialog_OnZoomFactor(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_OnZoomFactor(HWND hwnd)
{
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   SCROLLDLGDATA TmpZoom;
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   TmpZoom.Value=pData->MagGlassData.nZoom;
   TmpZoom.MaxRange=MAX_ZOOM_FACTOR;
   TmpZoom.MinRange=MIN_ZOOM_FACTOR;
   TmpZoom.Step=STEP_ZOOM_FACTOR;
   wsprintf((LPTSTR)TmpZoom.szDlgText,TEXT("Magnifying Glass Zoom Factor"));
   wsprintf((LPTSTR)TmpZoom.szDlgMessage,TEXT("The zoom factor range is between %d and %d pixels"),MIN_ZOOM_FACTOR,MAX_ZOOM_FACTOR);
   if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_RESIZE_WH),hwnd,(DLGPROC)ResizeWHDlgProc,(LONG)&TmpZoom))
   {
      pData->MagGlassData.nZoom=TmpZoom.Value;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[ChDialog_BorderColor]=============================================

Syntax:     L_VOID ChDialog_BorderColor(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_BorderColor(HWND hwnd)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   CHOOSECOLOR cc;                 // common dialog box structure 
   static COLORREF acrCustClr[16]; // array of custom colors 
   // Initialize CHOOSECOLOR 
   ZeroMemory(&cc, sizeof(CHOOSECOLOR));
   cc.lStructSize = sizeof(CHOOSECOLOR);
   cc.hwndOwner = hwnd;
   cc.lpCustColors = (LPDWORD) acrCustClr;
   cc.rgbResult = pData->MagGlassData.clrPen;
   cc.Flags = CC_FULLOPEN | CC_RGBINIT;

   if (ChooseColor(&cc)==TRUE)
   {
      pData->MagGlassData.clrPen= cc.rgbResult;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[ChDialog_BackColor]===============================================

Syntax:     L_VOID ChDialog_BackColor(HWND hwnd)

=========================================================================*/

L_VOID ChDialog_BackColor(HWND hwnd)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   CHOOSECOLOR cc;                 // common dialog box structure 
   static COLORREF acrCustClr[16]; // array of custom colors 
   // Initialize CHOOSECOLOR 
   ZeroMemory(&cc, sizeof(CHOOSECOLOR));
   cc.lStructSize = sizeof(CHOOSECOLOR);
   cc.hwndOwner = hwnd;
   cc.lpCustColors = (LPDWORD) acrCustClr;
   cc.rgbResult = pData->MagGlassData.clrBack;
   cc.Flags = CC_FULLOPEN | CC_RGBINIT;

   if (ChooseColor(&cc)==TRUE)
   {
      pData->MagGlassData.clrBack= cc.rgbResult;
      if (pData->MagGlassData.bStart)
      {
         Child_StopMagGlass(pData);
         Child_StartMagGlass(pData);
      }
   }
}

/*======[Child_BorderType]=================================================

Syntax:     L_VOID Child_BorderType(HWND hwnd)

=========================================================================*/

L_VOID Child_BorderType(HWND hwnd)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   pData->MagGlassData.b3D=!pData->MagGlassData.b3D;
   pData->Flags.bBorderType= pData->MagGlassData.b3D;
   if (pData->Flags.bBorderType)
      pData->Flags.bResizeBorder=FALSE;
   else
      pData->Flags.bResizeBorder=TRUE;

   Check_Menu_Items(hChildMenu,&(pData->Flags));
   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}

/*======[Child_CrossHair]=================================================

Syntax:     L_VOID Child_CrossHair(HWND hwnd,L_INT id)

=========================================================================*/

L_VOID Child_CrossHair(HWND hwnd,L_INT id)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   switch(id)
   {
   case IDM_NONE:
      pData->MagGlassData.nCrosshair=CROSSHAIR_NONE;
      pData->Flags.nCrossHairStyle=CROSSHAIR_NONE;
      break;
   case IDM_FINE:
      pData->MagGlassData.nCrosshair=CROSSHAIR_FINE;
      pData->Flags.nCrossHairStyle=CROSSHAIR_FINE;
      break;
   case IDM_INVERTPEN:
      pData->MagGlassData.nCrosshair=CROSSHAIR_INVERTPEN;
      pData->Flags.nCrossHairStyle=CROSSHAIR_INVERTPEN;
      break;
   case IDM_INVERTSCREEN:
      pData->MagGlassData.nCrosshair=CROSSHAIR_INVERTSCREEN;
      pData->Flags.nCrossHairStyle=CROSSHAIR_INVERTSCREEN;
      break;
   }

   Check_Menu_Items(hChildMenu,&(pData->Flags));
   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}

/*======[Child_MagCenter]=================================================

Syntax:     L_VOID Child_MagCenter(HWND hwnd,L_INT id)

=========================================================================*/

L_VOID Child_MagCenter(HWND hwnd,L_INT id)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);

   if (id==IDM_MAG_GLASS_CENTER)
   {
      pData->Flags.bCenter=TRUE;
      pData->MagGlassData.bCenter=TRUE;
   }
   else
   {
      pData->Flags.bCenter=FALSE;
      pData->MagGlassData.bCenter=FALSE;
   }

   Check_Menu_Items(hChildMenu,&(pData->Flags));
   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}

/*======[Child_MagPaint]===================================================

Syntax:     L_VOID Child_MagPaint(HWND hwnd,L_INT id)

=========================================================================*/

L_VOID Child_MagPaint(HWND hwnd,L_INT id)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);
   switch(id)
   {
   case IDM_RESET_FLAGS:
      pData->MagGlassData.uPaintFlags=0;
      pData->Flags.PaintStyle=0;
      break;

   case IDM_ORDEREDDITHER:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_ORDEREDDITHER;
      pData->Flags.PaintStyle^=ORDEREDDITHER;
      break;

   case IDM_FASTPAINT:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_FASTPAINT;
      pData->Flags.PaintStyle^=FASTPAINT;
      break;

   case IDM_INDEXEDPAINT:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_INDEXEDPAINT;
      pData->Flags.PaintStyle^=INDEXEDPAINT;
      break;

   case IDM_DITHEREDPAINT:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_DITHEREDPAINT;
      pData->Flags.PaintStyle^=DITHEREDPAINT;
      break;

   case IDM_SCALETOGRAY:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_SCALETOGRAY;
      pData->Flags.PaintStyle^=SCALETOGRAY;
      break;

   case IDM_HALFTONEPRINT:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_HALFTONEPRINT;
      pData->Flags.PaintStyle^=HALFTONEPRINT;
      break;

   case IDM_FAVORBLACK:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_FAVORBLACK;
      pData->Flags.PaintStyle^=FAVORBLACK;
      break;

   case IDM_FIXEDPALETTE:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_FIXEDPALETTE;
      pData->Flags.PaintStyle^=FIXEDPALETTE;
      break;

   case IDM_NETSCAPEPALETTE:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_NETSCAPEPALETTE;
      pData->Flags.PaintStyle^=NETSCAPEPALETTE;
      break;

   case IDM_RESAMPLE:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_RESAMPLE;
      pData->Flags.PaintStyle^=RESAMPLE;
      break;

   case IDM_BICUBIC:
      pData->MagGlassData.uPaintFlags^=DISPLAYMODE_BICUBIC;
      pData->Flags.PaintStyle^=BICUBIC;
      break;
   }

   Check_Menu_Items(hChildMenu,&(pData->Flags));
   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}

/*======[Child_MagCursor]==================================================

Syntax:     L_VOID Child_MagCursor(HWND hwnd,L_INT id)

=========================================================================*/

L_VOID Child_MagCursor(HWND hwnd,L_INT id)
{
   HCURSOR TmpCur;
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);
   switch(id)
   {
   case IDM_RECTANGLE :

      pData->MagGlassData.bEllipse=FALSE;
      pData->MagGlassData.hMagCursor=NULL;

      pData->Flags.bCurRect=TRUE;
      pData->Flags.bCurEllipse=FALSE;
      pData->Flags.bCurFile=FALSE;
      break;

   case IDM_ELLIPSE :

      pData->MagGlassData.bEllipse=TRUE;
      pData->MagGlassData.hMagCursor=NULL;

      pData->Flags.bCurEllipse=TRUE;
      pData->Flags.bCurRect=FALSE;
      pData->Flags.bCurFile=FALSE;
      break;

   case IDM_CURFILE:
      if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_CURFILE),
      hwnd,(DLGPROC)CurFileDlgProc,(LONG)&TmpCur))
      {
         pData->MagGlassData.hMagCursor=TmpCur;

         pData->Flags.bCurEllipse=FALSE;
         pData->Flags.bCurRect=FALSE;
         pData->Flags.bCurFile=TRUE;

      }
      break;
   }

   Check_Menu_Items(hChildMenu,&(pData->Flags));
   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}

/*======[Child_UpdateRectangle]============================================

Syntax:     L_VOID Child_UpdateRectangle(HWND hwnd)

=========================================================================*/

L_VOID Child_UpdateRectangle(HWND hwnd)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_RECT,NULL);
   pData->Flags.bUpdateRect=TRUE;
   pData->Flags.bUpdateEllipse=FALSE;
   pData->Flags.bUpdateRoundRect=FALSE;
   pData->Flags.bUpdateFreeHand=FALSE;
   pData->Flags.b3DBorder=TRUE;

   if (pData->Flags.bBorderType)
      pData->Flags.bResizeBorder=FALSE;
   else
      pData->Flags.bResizeBorder=TRUE;

   pData->Flags.bResizeWidth=TRUE;
   pData->Flags.bResizeHeight=TRUE;
   Check_Menu_Items(hChildMenu,&(pData->Flags));
}

/*======[Child_UpdateEllipse]==============================================

Syntax:     L_VOID Child_UpdateEllipse(HWND hwnd)

=========================================================================*/

L_VOID Child_UpdateEllipse(HWND hwnd)
{
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_ELLIPSE,NULL);
   pData->Flags.bUpdateEllipse=TRUE;
   pData->Flags.bUpdateRect=FALSE;
   pData->Flags.bUpdateRoundRect=FALSE;
   pData->Flags.bUpdateFreeHand=FALSE;
   pData->Flags.b3DBorder=FALSE;
   pData->Flags.bResizeBorder=TRUE;
   pData->Flags.bResizeWidth=TRUE;
   pData->Flags.bResizeHeight=TRUE;
   Check_Menu_Items(hChildMenu,&(pData->Flags));
}

/*======[Child_UpdateRoundRectangle]=======================================

Syntax:     L_VOID Child_UpdateRoundRectangle(HWND hwnd)

=========================================================================*/

L_VOID Child_UpdateRoundRectangle(HWND hwnd, L_BOOL NewDataRequest)
{
   HRGN hRoundRectRgn;
   static UPDATESHAPEDATA RoundData={100,100,50,50};

   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);

   if (NewDataRequest)
   {
      if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_ROUNDRECT),
                         hwnd,(DLGPROC)RoundRectDlgProc,(LONG)&RoundData))
      {
         hRoundRectRgn=CreateRoundRectRgn(0,0,RoundData.right,RoundData.bottom,RoundData.nWidth,RoundData.nHeight);
         L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_HRGN,hRoundRectRgn);

         pData->Flags.bUpdateEllipse=FALSE;
         pData->Flags.bUpdateRect=FALSE;
         pData->Flags.bUpdateRoundRect=TRUE;
         pData->Flags.bUpdateFreeHand=FALSE;
         pData->Flags.b3DBorder=FALSE;
         pData->Flags.bResizeBorder=FALSE;
         pData->Flags.bResizeWidth=FALSE;
         pData->Flags.bResizeHeight=FALSE;
         Check_Menu_Items(hChildMenu,&(pData->Flags));
         DeleteRgn(hRoundRectRgn);
      }
   }
   else
   {
      hRoundRectRgn=CreateRoundRectRgn(0,0,RoundData.right,RoundData.bottom,RoundData.nWidth,RoundData.nHeight);

      L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_HRGN,hRoundRectRgn);
      DeleteRgn(hRoundRectRgn);
   }
}

/*======[Child_UpdateFreeHand]=============================================

Syntax:     L_VOID Child_UpdateFreeHand(HWND hwnd)

=========================================================================*/

L_VOID Child_UpdateFreeHand(HWND hwnd, L_BOOL NewDataRequest)
{
   static HRGN hFreeHandRgn;
   RECT rcRegion;
   
   HINSTANCE hInst=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
   LPWINDOWDATA pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   
   if (NewDataRequest)
   {
      if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_FREEHAND), 
         hwnd,(DLGPROC)FreeHandDlgProc,(LONG)&hFreeHandRgn))
      {
         if (NULLREGION != GetRgnBox(hFreeHandRgn, &rcRegion))
         {
            L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_HRGN,hFreeHandRgn);
            pData->Flags.bUpdateEllipse=FALSE;
            pData->Flags.bUpdateRect=FALSE;
            pData->Flags.bUpdateRoundRect=FALSE;
            pData->Flags.bUpdateFreeHand=TRUE;
            pData->Flags.b3DBorder=FALSE;
            pData->Flags.bResizeBorder=FALSE;
            pData->Flags.bResizeWidth=FALSE;
            pData->Flags.bResizeHeight=FALSE;
            Check_Menu_Items(hChildMenu,&(pData->Flags));
         }
      }
   }
   else
   {
      if (NULLREGION != GetRgnBox(hFreeHandRgn, &rcRegion))
      {
         L_UpdateMagGlassShape(hwnd,MAGGLASS_SHAPE_HRGN,hFreeHandRgn);
      }
   }
}

/*====(Child_DisplayContextMenu)============================================

Syntax:     L_BOOL Child_DisplayContextMenu(HWND hWnd, POINT pt)

==========================================================================*/

L_BOOL Child_DisplayContextMenu(HWND hWnd, POINT pt)
{
   RECT           rc;
   HMENU          hmenuPopup;
   LPWINDOWDATA   pData;

   pData = (LPWINDOWDATA)GetWindowLong(hWnd, GWL_USERDATA);
   
   // Get the bounding rectangle of the client area of the child
   GetClientRect(hWnd, &rc);
   
   // Convert the mouse position to client coordinates
   ScreenToClient(hWnd, &pt);

   // Do the check menu part
   Child_CheckMenuItems(hContextMenu, &(pData->Flags));

   // If the mouse click was in the client area of this child window,
   // display the appropriate popup menu.
   if (PtInRect(&rc, pt))
   {
      hmenuPopup = GetSubMenu(hContextMenu, 0);

      ClientToScreen(hWnd, &pt);

      TrackPopupMenu(hmenuPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, hWndFrame, NULL);

      return TRUE;
   }
   
   // Otherwise, tell our caller that we don't handle it
   return FALSE;
}

/*======[Child_ManualUpdate]==============================================

Syntax:     L_VOID Child_ManualUpdate(LPWINDOWDATA pData)

=========================================================================*/

L_VOID Child_ManualUpdate(LPWINDOWDATA pData)
{
   pData->Flags.bManualUpdate = !pData->Flags.bManualUpdate;

   if (pData->Flags.bManualUpdate)
      pData->MagGlassData.uMagGlassFlags |= MAGGLASS_MANUAL_UPDATE;
   else
      pData->MagGlassData.uMagGlassFlags &= ~MAGGLASS_MANUAL_UPDATE;

   Check_Menu_Items(hChildMenu, &(pData->Flags));
   Child_CheckMenuItems(hContextMenu, &(pData->Flags));

   if (pData->MagGlassData.bStart)
   {
      Child_StopMagGlass(pData);
      Child_StartMagGlass(pData);
   }
}
/*======[CleanOpenDlgParam]=======================================

Syntax:     L_VOID CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam)

=========================================================================*/

L_VOID CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam)
{
   int i=0;

   if(pFOParam!=NULL && pFOParam->pFileData!= NULL )
   {
      for(i=0; i < pFOParam->nNumOfFiles; ++i )
      {
         if(pFOParam->pFileData[i].pBitmap != NULL)
         {
            L_FreeBitmap(pFOParam->pFileData[i].pBitmap);
            GlobalFreePtr(pFOParam->pFileData[i].pBitmap);
         }

         if(pFOParam->pFileData[i].pThumbnail != NULL)
         {
            L_FreeBitmap(pFOParam->pFileData[i].pThumbnail);
            GlobalFreePtr(pFOParam->pFileData[i].pThumbnail);
         }

         if(pFOParam->pFileData[i].pFileInfo != NULL)
         {
            GlobalFreePtr(pFOParam->pFileData[i].pFileInfo);
         }
      }

      GlobalFreePtr(pFOParam->pFileData);

      pFOParam->pFileData    =NULL;
      pFOParam->nNumOfFiles  = 0;
   }
}

/*======[Child_UpdateMagGlassBitmap]=======================================

Syntax:     L_VOID Child_UpdateMagGlassBitmap(HWND hWnd)

=========================================================================*/

L_VOID Child_UpdateMagGlassBitmap(HWND hWnd)
{
   L_INT          nRet;
   L_CHAR         szFile[256] = "";
   HCURSOR        hOldCur;
   OPENDLGPARAMS  FOParm;
   OPENFILENAME   OpenFileName;
   LPWINDOWDATA   pData;

   pData = (LPWINDOWDATA)GetWindowLong(hWnd, GWL_USERDATA);

   memset(&FOParm, 0, sizeof(OPENDLGPARAMS));
   memset(&OpenFileName, 0, sizeof(OPENFILENAME));

   FOParm.uStructSize    = sizeof(OPENDLGPARAMS);

   FOParm.uDlgFlags      =  DLG_OPEN_SHOW_FILEINFO |  
                            DLG_OPEN_SHOW_PREVIEW  | 
                            DLG_OPEN_USEFILESTAMP;

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.lpstrTitle        = TEXT("Update Magnifying Glass Bitmap");

   nRet = L_DlgOpen(hWnd,&OpenFileName,&FOParm);

   if (nRet == SUCCESS_DLG_OK)
   {
      hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));

      if (pData->MagGlassData.UpdateBitmap.Flags.Allocated)
         L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);

      nRet = L_LoadBitmap(FOParm.pFileData[0].szFileName, &pData->MagGlassData.UpdateBitmap,sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY, NULL, NULL);
      if (nRet != SUCCESS)
      {
         SetCursor(hOldCur);
         L_UpdateMagGlassBitmap(hWnd, NULL, FALSE);
         L_FileError(hWnd, nRet, TEXT("Updating Magnifying Glass Bitmap"), pData->szFilename);
         return;
      }

      nRet = L_UpdateMagGlassBitmap(hWnd, &pData->MagGlassData.UpdateBitmap, pData->Flags.bUpdateSourceBitmap);
      if (nRet != SUCCESS)
      {
         SetCursor(hOldCur);
         L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
         L_FileError(hWnd, nRet, TEXT("Updating Magnifying Glass Bitmap"), pData->szFilename);
         return;
      }

      SetCursor(hOldCur);

      CleanOpenDlgParam(&FOParm);
   }
   else if (nRet < 0 )
      L_FileError(hWnd, nRet, TEXT("Opening Bitmap to update Magnifying Glass Bitmap"), pData->szFilename);
}


/*======[Child_WindowLevel]===============================================

Syntax:     L_VOID Child_WindowLevel(HWND hWnd)

=========================================================================*/

L_VOID Child_WindowLevel(HWND hWnd)
{
   L_INT                   nRet;
   LPWINDOWDATA            pData;
   WINDOWLEVELDLGPARAMS    WindowLevelParams;
   L_INT nLowBit, nHighBit, nLow, nHigh;
   L_UINT32 nSize = 0;

   pData = (LPWINDOWDATA)GetWindowLong(hWnd, GWL_USERDATA);

   /* Free the UpdateBitmap if it is Allocated */
   if (pData->MagGlassData.UpdateBitmap.Flags.Allocated)
      L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);

   /* Copy the MagGlass bitmap to the UpdateBitmap */
   nRet = L_CopyBitmap(&pData->MagGlassData.UpdateBitmap, &pData->Bitmap, sizeof (BITMAPHANDLE));
   if (nRet != SUCCESS)
   {
      L_UpdateMagGlassBitmap(hWnd, NULL, FALSE);
      L_FileError(hWnd, nRet, TEXT("Error In Window Level process"), pData->szFilename);
      return;
   }
   
   /* Get min/max Bits */
   L_GetMinMaxBits(&pData->MagGlassData.UpdateBitmap, &nLowBit, &nHighBit);

   /* Get min/max Intensity Values */
   L_GetMinMaxVal(&pData->MagGlassData.UpdateBitmap, &nLow, &nHigh);

   pData->MagGlassData.UpdateBitmap.MinVal = nLow;
   pData->MagGlassData.UpdateBitmap.MaxVal = nHigh;

   /* now, let's set the range to somewhere in the middle */
   nSize = (L_UINT32)(1L<<(nHighBit-nLowBit + 1));
   
   memset(&WindowLevelParams, 0, sizeof(WINDOWLEVELDLGPARAMS));

   WindowLevelParams.pLUT = (RGBQUAD L_HUGE*)GlobalAllocPtr(GHND, nSize * sizeof(RGBQUAD));    
   if (!WindowLevelParams.pLUT)
   {
      L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
      L_UpdateMagGlassBitmap(hWnd, NULL, FALSE);
      L_FileError(hWnd, ERROR_NO_MEMORY, TEXT("No Memory"), pData->szFilename);
      return;
   }
   WindowLevelParams.uStructSize  = sizeof(WINDOWLEVELDLGPARAMS);
   WindowLevelParams.pBitmap  = &pData->MagGlassData.UpdateBitmap ;
   WindowLevelParams.uLUTLength = (L_UINT32)nSize;
   WindowLevelParams.uLowBit = nLowBit; 
   WindowLevelParams.uHighBit = nHighBit; 
   WindowLevelParams.nLow = nLow;
   WindowLevelParams.nHigh = nHigh;
   
   switch ( L_IsGrayScaleBitmap ( &pData->MagGlassData.UpdateBitmap ) )
   {
      case GRAY_ORDEREDNORMAL:
      {
         WindowLevelParams.crStart = RGB ( 0, 0, 0 ) ;
         WindowLevelParams.crEnd   = RGB ( 255, 255, 255 ) ;

         break ;
      }
      
      case GRAY_ORDEREDINVERSE:
      {
         WindowLevelParams.crStart = RGB ( 255, 255, 255 ) ;
         WindowLevelParams.crEnd   = RGB ( 0, 0, 0 ) ;

         break ;
      }      
      
      case GRAY_NOTORDERED:
      {
         WindowLevelParams.crStart = RGB ( 0, 0, 0 ) ;
         WindowLevelParams.crEnd   = RGB ( 255, 255, 255 ) ;

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

         return ;
      }
   }

   WindowLevelParams.uWindowLevelFlags = FILLLUT_OUTSIDE | FILLLUT_LINEAR ;
   WindowLevelParams.uDlgFlags  = DLG_WINDOWLEVEL_SHOW_PREVIEW |
                                  DLG_WINDOWLEVEL_SHOW_TOOL_ZOOMLEVEL | 
                                  DLG_WINDOWLEVEL_SHOW_RANGE ;

   nRet = L_DlgWindowLevel(hWnd, &WindowLevelParams);
   if(nRet == SUCCESS_DLG_OK)
   {
      nRet = L_WindowLevelBitmap(&pData->MagGlassData.UpdateBitmap,
                                 WindowLevelParams.uLowBit, WindowLevelParams.uHighBit,
                                 (RGBQUAD L_HUGE*)WindowLevelParams.pLUT,
                                 WindowLevelParams.uLUTLength,
                                 ORDER_BGR);

      if (nRet == SUCCESS)
         nRet = L_UpdateMagGlassBitmap(hWnd, &pData->MagGlassData.UpdateBitmap, pData->Flags.bUpdateSourceBitmap);
   }

   if (nRet != SUCCESS)
   {
      L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
      L_UpdateMagGlassBitmap(hWnd, NULL, FALSE);
      if (nRet != SUCCESS_DLG_CANCEL)
         L_FileError(hWnd, nRet, TEXT("Updating Magnifying Glass Bitmap using Window Level"), pData->szFilename);
   }

   GlobalFreePtr(WindowLevelParams.pLUT);
}

/*======[Child_UpdateSourceMagGlassBitmap]=================================

Syntax:     L_VOID Child_UpdateSourceMagGlassBitmap(HWND hWnd)

=========================================================================*/

L_VOID Child_UpdateSourceMagGlassBitmap(HWND hWnd)
{
   L_INT          nRet;
   LPWINDOWDATA   pData;

   pData = (LPWINDOWDATA)GetWindowLong(hWnd, GWL_USERDATA);

   pData->Flags.bUpdateSourceBitmap = !pData->Flags.bUpdateSourceBitmap;

   Check_Menu_Items(hChildMenu, &(pData->Flags));
   Child_CheckMenuItems(hContextMenu, &(pData->Flags));

   if (pData->MagGlassData.UpdateBitmap.Flags.Allocated)
   {
      nRet = L_UpdateMagGlassBitmap(hWnd, &pData->MagGlassData.UpdateBitmap, pData->Flags.bUpdateSourceBitmap);
      if (nRet != SUCCESS)
      {
         L_FreeBitmap(&pData->MagGlassData.UpdateBitmap);
         L_FileError(hWnd, nRet, TEXT("Updating Magnifying Glass Bitmap"), pData->szFilename);
      }
   }
}

/*======[Child_CheckMenuItems]=============================================

Syntax:     L_VOID Child_CheckMenuItems(HMENU hMenu, pFLAGSDATA pFlagsData)

=========================================================================*/

L_VOID Child_CheckMenuItems(HMENU hMenu, pFLAGSDATA pFlagsData)
{
   if (!hMenu || !pFlagsData)
      return;

   if (pFlagsData->bStartMagGlass)
   {
      EnableMenuItem(hMenu,IDM_STOP_MAGGLASS,MF_ENABLED);
      EnableMenuItem(hMenu,IDM_START_MAGGLASS,MF_GRAYED);
   }
   else
   {
      EnableMenuItem(hMenu,IDM_STOP_MAGGLASS,MF_GRAYED);
      EnableMenuItem(hMenu,IDM_START_MAGGLASS,MF_ENABLED);
   }

   if (pFlagsData->bManualUpdate)
      CheckMenuItem(hMenu,IDM_MANUAL_UPDATE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_MANUAL_UPDATE,MF_UNCHECKED);

   if (pFlagsData->bStartMagGlass && pFlagsData->bManualUpdate)
   {
      EnableMenuItem(hMenu,IDM_UPDATE_BITMAP,MF_ENABLED);
      EnableMenuItem(hMenu,IDM_UPDATE_SOURCE_BITMAP,MF_ENABLED);
   }
   else
   {
      EnableMenuItem(hMenu,IDM_UPDATE_BITMAP,MF_GRAYED);
      EnableMenuItem(hMenu,IDM_UPDATE_SOURCE_BITMAP,MF_GRAYED);
   }

   if (pFlagsData->bUpdateSourceBitmap)
      CheckMenuItem(hMenu,IDM_UPDATE_SOURCE_BITMAP,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_UPDATE_SOURCE_BITMAP,MF_UNCHECKED);

   if (pFlagsData->bResizeBorder)
      EnableMenuItem(hMenu,IDM_MAG_GLASS_BORDER,MF_ENABLED);
   else
      EnableMenuItem(hMenu,IDM_MAG_GLASS_BORDER,MF_GRAYED);

   if (pFlagsData->bResizeWidth)
      EnableMenuItem(hMenu,IDM_RESIZE_MAG_WIDTH,MF_ENABLED);
   else
      EnableMenuItem(hMenu,IDM_RESIZE_MAG_WIDTH,MF_GRAYED);

   if (pFlagsData->bResizeHeight)
      EnableMenuItem(hMenu,IDM_RESIZE_MAG_HEIGHT,MF_ENABLED);
   else
      EnableMenuItem(hMenu,IDM_RESIZE_MAG_HEIGHT,MF_GRAYED);

   if (pFlagsData->bUpdateRect)
      CheckMenuItem(hMenu,IDM_UPDATE_RECTANGLE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_UPDATE_RECTANGLE,MF_UNCHECKED);

   if (pFlagsData->bUpdateEllipse)
      CheckMenuItem(hMenu,IDM_UPDATE_ELLIPSE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_UPDATE_ELLIPSE,MF_UNCHECKED);

   if (pFlagsData->bUpdateRoundRect)
      CheckMenuItem(hMenu,IDM_UPDATE_ROUNDRECTANGLE,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_UPDATE_ROUNDRECTANGLE,MF_UNCHECKED);

   if (pFlagsData->bUpdateFreeHand)
      CheckMenuItem(hMenu,IDM_UPDATE_FREEHAND,MF_CHECKED);
   else
      CheckMenuItem(hMenu,IDM_UPDATE_FREEHAND,MF_UNCHECKED);

   if (pFlagsData->nCrossHairStyle==CROSSHAIR_NONE)
   {
      CheckMenuItem(hChildMenu,IDM_NONE,MF_CHECKED);
      CheckMenuItem(hChildMenu,IDM_FINE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTPEN,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTSCREEN,MF_UNCHECKED);
   }
   else if (pFlagsData->nCrossHairStyle==CROSSHAIR_FINE)
   {
      CheckMenuItem(hChildMenu,IDM_NONE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_FINE,MF_CHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTPEN,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTSCREEN,MF_UNCHECKED);
   }
   else if (pFlagsData->nCrossHairStyle==CROSSHAIR_INVERTPEN)
   {
      CheckMenuItem(hChildMenu,IDM_NONE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_FINE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTPEN,MF_CHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTSCREEN,MF_UNCHECKED);
   }
   else
   {
      CheckMenuItem(hChildMenu,IDM_NONE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_FINE,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTPEN,MF_UNCHECKED);
      CheckMenuItem(hChildMenu,IDM_INVERTSCREEN,MF_CHECKED);
   }

   if (pFlagsData->bStartMagGlass && pFlagsData->bManualUpdate && pFlagsData->bWindowLevel)
      EnableMenuItem(hMenu, IDM_WINDOWLEVEL, MF_ENABLED);
   else
      EnableMenuItem(hMenu, IDM_WINDOWLEVEL, MF_GRAYED);
}

/*======[ChDialog_OnPaintIntensity]========================================

Syntax:     L_VOID ChDialog_OnPaintIntensity(HWND hWnd)

=========================================================================*/

L_VOID ChDialog_OnPaintIntensity(HWND hWnd)
{
   L_INT                     nRet;
   LPWINDOWDATA              pData;
   BRIGHTNESSDLGPARAMS       DlgParams;

   pData = (LPWINDOWDATA) GetWindowLong(hWnd,GWL_USERDATA);

   memset(&DlgParams,0,sizeof(BRIGHTNESSDLGPARAMS));

   DlgParams.uStructSize = sizeof(BRIGHTNESSDLGPARAMS);
   DlgParams.pBitmap     = &pData->Bitmap,
   DlgParams.nChange     = pData->MagGlassData.MagGlassPntOptions.nIntensity / 10;
   DlgParams.uDlgFlags   = DLG_INTENSITYDETECT_SHOW_PREVIEW|
                           DLG_INTENSITYDETECT_SHOW_TOOL_ZOOMLEVEL;

   /* Fill the GETCHANGEDLGPARM structure */
   L_DlgSetString (DLG_BRIGHTNESS_IDSTR_CAPTION , TEXT("Magnifying Glass Paint Intensity"));

   if (L_DlgBrightness ( hWnd, &DlgParams ) == SUCCESS_DLG_OK)
   {
      if (DlgParams.nChange >= -1000 && DlgParams.nChange <= 1000)
      {
         pData->MagGlassData.MagGlassPntOptions.nIntensity = DlgParams.nChange;

         if (pData->MagGlassData.bStart)
         {
            nRet = L_SetMagGlassPaintOptions(pData->hWnd, &pData->MagGlassData.MagGlassPntOptions);
            if (nRet != SUCCESS)
               L_FileError(hWnd, nRet, TEXT("Setting Magnifying Glass paint options"), pData->szFilename);
         }
      }
   }
}

/*======[ChDialog_OnPaintGamma]============================================

Syntax:     L_VOID ChDialog_OnPaintGamma(HWND hWnd)

=========================================================================*/

L_VOID ChDialog_OnPaintGamma(HWND hWnd)
{
   L_INT             nRet;
   L_UINT            uGamma;
   LPWINDOWDATA      pData;
   GAMMAADJUSTMENTDLGPARAMS  DlgParams;

   pData = (LPWINDOWDATA) GetWindowLong(hWnd,GWL_USERDATA);

   /* Gets the current gamma correction value */
   //uGamma = pData->MagGlassData.MagGlassPntOptions.nGamma;
   uGamma = 150;

   memset(&DlgParams, 0, sizeof(GAMMAADJUSTMENTDLGPARAMS));

   DlgParams.uStructSize = sizeof(GAMMAADJUSTMENTDLGPARAMS);
   DlgParams.pBitmap     = &pData->Bitmap;
   DlgParams.nBlueValue  = uGamma;
   DlgParams.nGreenValue = uGamma;
   DlgParams.nRedValue   = uGamma;
   DlgParams.bAllChannels= TRUE;
   DlgParams.uDlgFlags   = DLG_GAMMAADJUSTMENT_SHOW_PREVIEW|
                           DLG_GAMMAADJUSTMENT_SHOW_TOOL_ZOOMLEVEL | 
                           DLG_GAMMAADJUSTMENT_FORCELINKCHANNELS;


   if(L_DlgGammaAdjustment ( hWnd, &DlgParams ) == SUCCESS_DLG_OK)
   {
      pData->MagGlassData.MagGlassPntOptions.nGamma = DlgParams.nRedValue;

      if (pData->MagGlassData.bStart)
      {
         nRet = L_SetMagGlassPaintOptions(pData->hWnd, &pData->MagGlassData.MagGlassPntOptions);
         if (nRet != SUCCESS)
            L_FileError(hWnd, nRet, TEXT("Setting Magnifying Glass paint options"), pData->szFilename);
      }
   }
}

/*======[ChDialog_OnPaintContrast]=========================================

Syntax:     L_VOID ChDialog_OnPaintContrast(HWND hWnd)

=========================================================================*/

L_VOID ChDialog_OnPaintContrast(HWND hWnd)
{
   L_INT             nRet;
   LPWINDOWDATA      pData;
   CONTRASTDLGPARAMS DlgParams;

   pData = (LPWINDOWDATA) GetWindowLong(hWnd,GWL_USERDATA);
   memset(&DlgParams, 0, sizeof(CONTRASTDLGPARAMS));

   DlgParams.uStructSize = sizeof(CONTRASTDLGPARAMS);
   DlgParams.pBitmap     = &pData->Bitmap;
   DlgParams.nChange     = pData->MagGlassData.MagGlassPntOptions.nContrast / 10;
   DlgParams.uDlgFlags   = DLG_CONTRAST_SHOW_PREVIEW|
                           DLG_CONTRAST_SHOW_TOOL_ZOOMLEVEL ;

   /* Fill the GETCHANGEDLGPARM structure */
   L_DlgSetString (DLG_CONTRAST_IDSTR_CAPTION, TEXT("Magnifying Glass Paint Contrast"));

   if (L_DlgContrast ( hWnd, &DlgParams )== SUCCESS_DLG_OK)
   {
      if (DlgParams.nChange >= -1000 && DlgParams.nChange <= 1000)
      {
         pData->MagGlassData.MagGlassPntOptions.nContrast = DlgParams.nChange;

         if (pData->MagGlassData.bStart)
         {
            nRet = L_SetMagGlassPaintOptions(pData->hWnd, &pData->MagGlassData.MagGlassPntOptions);
            if (nRet != SUCCESS)
               L_FileError(hWnd, nRet, TEXT("Setting Magnifying Glass paint options"), pData->szFilename);
         }
      }
   }
}