#include "MainFram.h"
#include "Winuser.h"
#include "Dialogs.h"
#include "Child.h"
#include "Util.h"
#include "resource.h"
#include "math.h"
extern HWND hWndFrame,hWndClient;
extern HMENU hMenuInit,hChildMenu,hContextMenu;
extern HMENU hMenuInitWindow,hChildMenuWindow;
extern L_BOOL gbPaste;

L_BOOL bInScroll = FALSE;

#define CHILDCREATELPARAM(lpCreateStruct) (((LPMDICREATESTRUCT) ((lpCreateStruct)->lpCreateParams))->lParam)
#define RECTWIDTH(lpRect) (((LPRECT) lpRect)->right - ((LPRECT) lpRect)->left)
#define RECTHEIGHT(lpRect) (((LPRECT) lpRect)->bottom - ((LPRECT) lpRect)->top)

#define FACTOR 100.0
#define MIN_WIDTH  10
#define MIN_HEIGHT 10
extern HINSTANCE hInst;
static void MatchAspectRatio (LPRECT pRect, int nWidth, int nHeight)
{
   int cxRect, cyRect;
   cyRect = RECTHEIGHT (pRect);
   cxRect = MulDiv (cyRect, nWidth, nHeight);

   if (cxRect > RECTWIDTH (pRect))
   {
      cxRect = RECTWIDTH (pRect);
      cyRect = MulDiv (cxRect, nHeight, nWidth);
   }

   pRect->bottom = pRect->top + cyRect;
   pRect->right = pRect->left + cxRect;

   return;
}

/*====(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_KEYDOWN,          Child_OnKeyDown);
      /* For Palette */
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,   Child_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,  Child_OnQueryNewPalette);
   }

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

POINT ChangeToZoom(HWND hWnd ,POINT *pt)
{
   LPWINDOWDATA  pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);
   POINT ptTemp;

   ptTemp.x = (L_INT32)(pt->x / pData->dFactor * FACTOR) ;
   ptTemp.y = (L_INT32)(pt->y / pData->dFactor * FACTOR);

   return ptTemp;
}
/*====(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);
}

static L_VOID HiliteMark(HWND hWnd, L_BOOL fUpdate)
{
   RECT rcSrc;
   HDC hdc;
   HPEN hPen=NULL;
   LPWINDOWDATA  pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);
   hdc = GetDC(hWnd);

   SetRect(&rcSrc, 
           min(pData->ptStart.x, pData->ptEnd.x), 
           min(pData->ptStart.y, pData->ptEnd.y), 
           max(pData->ptStart.x, pData->ptEnd.x), 
           max(pData->ptStart.y, pData->ptEnd.y));

   SetROP2(hdc,R2_NOTXORPEN);
   
   Rectangle(hdc, rcSrc.left, rcSrc.top, rcSrc.right, rcSrc.bottom);

   ReleaseDC(hWnd, hdc);
}

/*====(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->hDoubleBuffer)
      {
         L_DoubleBufferDestroyHandle(pData->hDoubleBuffer);
      }
      
      if(L_WindowHasZoomView(hwnd))
      {
         L_UINT uCount,i;
         L_GetZoomViewsCount(hwnd,&uCount);
         for(i=0; i < uCount;++i)
         {
            L_DestroyZoomView(hwnd,uCount-i-1);
         }
      }
   }

   GlobalFreePtr(pData);
}

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

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

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

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

   pTmpData = (LPWINDOWDATA) GlobalAllocPtr(GHND,sizeof(WINDOWDATA));
   pCreateData = (LPCREATEDATA) CHILDCREATELPARAM (pCreatest);

   memcpy(pTmpData, &pCreateData->Data, sizeof(WINDOWDATA));
   pTmpData->hWnd = hwnd;
   L_CopyBitmap(&pTmpData->Bitmap, pCreateData->pBitmap,sizeof(BITMAPHANDLE));

   if(pCreateData->hObject)
   {
      pTmpData->hContainer = pCreateData->hObject;
      L_AnnSetWnd(pTmpData->hContainer, hwnd);
      L_AnnSetUserMode(pTmpData->hContainer, ANNUSER_RUN);
      L_AnnCreate(ANNOBJECT_AUTOMATION, &pTmpData->hAutomation);
      L_AnnSetAutoContainer(pTmpData->hAutomation, pTmpData->hContainer);
      L_AnnSetActiveState(pTmpData->hAutomation, ANNACTIVE_DISABLED);
   }

   pTmpData->nZoom = 100;
   pTmpData->Flags.bHilite = FALSE;
   pTmpData->hDoubleBuffer = NULL;
   pTmpData->Flags.nBitonalFlags  = 0;
   L_DoubleBufferCreateHandle(&pTmpData->hDoubleBuffer);
   L_DoubleBufferEnable(pTmpData->hDoubleBuffer, TRUE);
   pTmpData->dFactor = 1;
   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 */
   HBRUSH hBrush;
   HDC hMemDC;

   pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);   
   GetWindowRect(hwnd, &pData->rcWindow);

   GetClientRect(hwnd, &pData->rcClient);
   hMemDC = L_DoubleBufferBegin(pData->hDoubleBuffer, ps.hdc, pData->rcClient.right, pData->rcClient.bottom);      
   
   hBrush = (HBRUSH) GetStockObject (GRAY_BRUSH);
   FillRect(hMemDC, &ps.rcPaint, hBrush);

   if (pData->Bitmap.Flags.Allocated) /* Do we have an image? */
   {
      L_UINT32 ulFlags;
      
      ulFlags = L_GetDisplayMode ();
      /* for palette */
      if (pData->hPalette)
         hOldPal = SelectPalette (hMemDC, pData->hPalette, TRUE);
      
      L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, pData->Flags.nBitonalFlags);
      
      /* Paint it */
      L_PaintDC (hMemDC, &pData->Bitmap, NULL, NULL, &pData->rcView, &ps.rcPaint, SRCCOPY);

      L_AnnDraw(hMemDC, &ps.rcPaint, pData->hContainer);

      if(pData->Flags.bHilite)
      {
         L_UINT uCount = 0;

         //Mark the area of the zoom view(s) in the main window
         L_GetZoomViewsCount(hwnd, &uCount);//do we have any zoom views?

         if(uCount > 0)
         {
            HBRUSH hBrush = NULL;
            HRGN hRgn = NULL;
            L_UINT n;

            hBrush = CreateSolidBrush(RGB(192,192,192));//create a brush for the 'hilite'
            //start with the entire client area

            hRgn = CreateRectRgn(pData->rcView.left, pData->rcView.top, pData->rcView.right, pData->rcView.bottom);

            for(n = 0; n < uCount; n++)//subtract out each zoom view source area
            {
               ZOOMVIEWPROPS ZoomViewProps;
               HRGN hRgnTemp=NULL;
               RECT rcSrc;

               memset(&ZoomViewProps, 0, sizeof(ZOOMVIEWPROPS));
               ZoomViewProps.uIndex = n;

               //get the zoom view props
               L_GetZoomViewProps(hwnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));
               if(ZoomViewProps.bEnabled)
               {
                  CopyRect(&rcSrc, &ZoomViewProps.rcSrc);

                  OffsetRect(&rcSrc, (L_INT32)(pData->rcView.left * FACTOR / pData->dFactor), (L_INT32)(pData->rcView.top * FACTOR / pData->dFactor));

                  rcSrc.top = (L_INT32)(rcSrc.top / FACTOR * pData->dFactor);
                  rcSrc.bottom = (L_INT32)(rcSrc.bottom / FACTOR * pData->dFactor);
                  rcSrc.left = (L_INT32)(rcSrc.left / FACTOR * pData->dFactor);
                  rcSrc.right = (L_INT32)(rcSrc.right / FACTOR * pData->dFactor);

                  hRgnTemp = CreateRectRgn(rcSrc.left ,rcSrc.top, rcSrc.right, rcSrc.bottom);
                  CombineRgn(hRgn, hRgn, hRgnTemp, RGN_DIFF);
                  DeleteObject(hRgnTemp);
               }
            }

            SaveDC(hMemDC);

            SetTextColor(hMemDC, RGB(0,0,0));
            SetBkColor(hMemDC, RGB(192,192,192));
            SetBkMode(hMemDC, OPAQUE);
            SetROP2(hMemDC, R2_MASKPEN);

            SelectObject(hMemDC, GetStockObject(NULL_PEN));
            SelectObject(hMemDC, hBrush);
            SelectClipRgn(hMemDC, hRgn);

            Rectangle(hMemDC, pData->rcView.left, pData->rcView.top, pData->rcView.right, pData->rcView.bottom);

            RestoreDC(hMemDC, -1);
            DeleteObject(hRgn);
            DeleteObject(hBrush);
         }
      }

      L_RenderZoomView(hMemDC,hwnd);

      L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags);
      /* for Palette */
      if (pData->hPalette)
         SelectPalette (hMemDC, hOldPal, TRUE);
   }

   if(ps.hdc != hMemDC)
   {
      SaveDC(ps.hdc);
      if (pData->hPalette)
         SelectPalette (ps.hdc, pData->hPalette, TRUE);
   }

   L_DoubleBufferEnd(pData->hDoubleBuffer, ps.hdc);

   if(ps.hdc != hMemDC)
      RestoreDC(ps.hdc, -1);

   EndPaint (hwnd, &ps);
}

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

Syntax:     L_BOOL Child_OnEraseBkgnd(HWND hWnd, HDC hDC)

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

L_BOOL Child_OnEraseBkgnd(HWND hWnd, HDC hDC)
{
   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_SAVE_FILE:
      SaveBitmapFile(hwnd);
      break;

   case IDM_COPY:
      Child_Copy(hwnd);
      break;

   case IDM_ZOOMVIEW_OPTION:
      ChDialog_OnZoomViewOptions(hwnd);
      break;

   case IDM_ZOOMVIEW_DELETE:
      L_DestroyZoomView(hwnd, pData->nActiveZoomView);
      pData->nActiveZoomView = -1;
      break;
   
   case IDM_VIEW_NORMAL:
      pData->Flags.bFitImage = FALSE;
      SetZoomFactor (hwnd, 100);
      Child_SizeChange (hwnd, TRUE);
      break;

   case IDM_VIEW_ZOOM:
      pData->Flags.bFitImage = FALSE;
      SetZoomFactor (hwnd, GetZoomFactor(hwnd, pData->nZoom));
      Child_SizeChange (hwnd, TRUE);
      break;
   
   case IDM_VIEW_FITIMAGE:
      pData->Flags.bFitImage = TRUE;
      pData->nZoom = 100;
      Child_SizeChange(hwnd, TRUE);
      break;

   case IDM_VIEW_HILITE:
      pData->Flags.bHilite = !pData->Flags.bHilite;
      Check_Menu_Items(hChildMenu, &pData->Flags);
      InvalidateRect(hwnd, NULL, FALSE);
      break;

   case IDM_BITONALNORMAL:
      pData->Flags.nBitonalFlags = 0;
      Check_Menu_Items(hChildMenu, &pData->Flags);
      InvalidateRect(hwnd, NULL, FALSE);
      break;

   case IDM_SCALETOGRAY:
      pData->Flags.nBitonalFlags = DISPLAYMODE_SCALETOGRAY;
      Check_Menu_Items(hChildMenu, &pData->Flags);
      InvalidateRect(hwnd, NULL, FALSE);
      break;

   case IDM_FAVORBLACK:
      pData->Flags.nBitonalFlags = DISPLAYMODE_FAVORBLACK;
      Check_Menu_Items(hChildMenu, &pData->Flags);
      InvalidateRect(hwnd, NULL, FALSE);
      break;
   }
}

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

Syntax:     L_VOID Child_Copy(HWND hwnd)

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

L_VOID Child_Copy(HWND hwnd)
{
   HANNOBJECT TopContainer; /* Root container */
   LPWINDOWDATA  pData = (LPWINDOWDATA)GetWindowLong(hwnd,GWL_USERDATA);
   
   L_CopyToClipboard(hwnd, &pData->Bitmap, COPY2CB_DIB);
   /* Copy all annotations to the clipboard */
   if(pData->hContainer)
   {
      L_AnnGetTopContainer(pData->hContainer, &TopContainer);
      L_AnnCopyToClipboard(TopContainer, ANNFMT_NATIVE, FALSE, FALSE, FALSE);
   }

   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)
{
   Child_ProcessSize(hWnd,nState,nCx,nCy);
   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);

   if(pData->hContainer)
   {
      L_AnnSetOffsetY(pData->hContainer, (L_DOUBLE) pData->rcView.top, ANNFLAG_NOINVALIDATE);
   }

   /* 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);

   if(L_WindowHasZoomView(hWnd))
   {
      L_UINT uCount;
      L_UINT i;
      ZOOMVIEWPROPS ZoomViewProps;

      L_GetZoomViewsCount(hWnd,&uCount);
      for(i = 0;i<uCount;++i)
      {
         ZoomViewProps.uIndex = i;
         L_GetZoomViewProps(hWnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));
         ZoomViewProps.rcView = pData->rcView;
         L_UpdateZoomView(hWnd, &ZoomViewProps);
      }
   }

   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);
   
   if(pData->hContainer)
   {
      L_AnnSetOffsetX(pData->hContainer, (L_DOUBLE) pData->rcView.left, ANNFLAG_NOINVALIDATE);
   }
   /* 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);

   if(L_WindowHasZoomView(hWnd))
   {
      L_UINT uCount;
      L_UINT i;
      ZOOMVIEWPROPS ZoomViewProps;

      L_GetZoomViewsCount(hWnd,&uCount);
      for(i = 0;i<uCount;++i)
      {
         ZoomViewProps.uIndex = i;
         L_GetZoomViewProps(hWnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));
         ZoomViewProps.rcView = pData->rcView;
         L_UpdateZoomView(hWnd, &ZoomViewProps);
      }
   }

   /* Update window */
   UpdateWindow (hWnd);

   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)
{
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);
   L_UINT uCount,i;
   ZOOMVIEWPROPS ZoomViewProps;
   POINT tmpPoint;
   
   pData->Flags.bHiliteMarker = TRUE;
   pData->Flags.bMoveSrc = FALSE;
   pData->Flags.bMoveDst = FALSE;

   pData->ptStart.x = pData->ptEnd.x = (L_INT32)(x);
   pData->ptStart.y = pData->ptEnd.y = (L_INT32)(y);

   pData->ptMove.x = x;
   pData->ptMove.y = y;

   tmpPoint.x = (pData->ptMove.x + pData->nHScrollPos);
   tmpPoint.y = (pData->ptMove.y + pData->nVScrollPos);

   SetCapture(hWnd);
   SetFocus(hWnd);

   if(L_WindowHasZoomView(hWnd))
   {
      L_GetZoomViewsCount(hWnd,&uCount);
      for(i = 0; i < uCount; ++i)
      {
         ZoomViewProps.uIndex = uCount-i-1;
         L_GetZoomViewProps(hWnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));

         if(PtInRect(&ZoomViewProps.rcDst ,ChangeToZoom(hWnd,&tmpPoint)))
         {
            POINT pt;
            RECT rcClient;
            
            pt.x = pData->rcClient.top;
            pt.y = pData->rcClient.left;
            
            rcClient = pData->rcClient;
            ClientToScreen(hWnd ,&pt);
            OffsetRect(&rcClient , pt.x, pt.y);
            
            GetClipCursor(&pData->rcOldClip);
            ClipCursor(&rcClient);

            pData->Flags.bMoveSrc = FALSE;
            pData->Flags.bMoveDst = TRUE;
            pData->Flags.bHiliteMarker = FALSE;
            
            pData->nActiveZoomView = uCount-i-1;
            break;
         }

         if(PtInRect(&ZoomViewProps.rcSrc ,ChangeToZoom(hWnd,&tmpPoint)))
         {
            pData->Flags.bMoveSrc = TRUE;
            pData->Flags.bMoveDst = FALSE;
            pData->Flags.bHiliteMarker = FALSE;
            
            pData->nActiveZoomView = uCount-i-1;

            pData->ptMove.x = x;
            pData->ptMove.y = y;

            break;
         }
      }
   }
   HiliteMark(hWnd, FALSE);
}

/*======[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)
{
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);
   ZOOMVIEWPROPS ZoomViewProps;
   L_DOUBLE dx, dy;
   POINT tmpPoint;
 
   tmpPoint.x = x + pData->nHScrollPos;
   tmpPoint.y = y + pData->nVScrollPos;

   if((GetCapture() == hWnd) && (keyFlags & MK_LBUTTON))
   {
      if(pData->Flags.bHiliteMarker)
         HiliteMark(hWnd, FALSE);

      if(L_WindowHasZoomView(hWnd))
      {
         ZoomViewProps.uIndex = pData->nActiveZoomView;
         L_GetZoomViewProps(hWnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));

         if(pData->Flags.bMoveDst)
         {
            dx = x - pData->ptMove.x;
            dy = y - pData->ptMove.y;
            
            OffsetRect(&ZoomViewProps.rcDst, (L_INT32)(dx * FACTOR / pData->dFactor), (L_INT32)(dy * FACTOR /pData->dFactor));
            CopyRect(&ZoomViewProps.rcView,&pData->rcView);
            L_UpdateZoomView(hWnd, &ZoomViewProps);

            pData->ptMove.x = x;
            pData->ptMove.y = y;
         }

         if(pData->Flags.bMoveSrc && (pData->nActiveZoomView > -1))
         {
            L_INT nRet;
            
            dx = x - pData->ptMove.x;
            dy = y - pData->ptMove.y;
            
            OffsetRect(&ZoomViewProps.rcSrc, (L_INT32)(dx * FACTOR / pData->dFactor), (L_INT32)(dy * FACTOR / pData->dFactor));
            CopyRect(&ZoomViewProps.rcView,&pData->rcView);
            nRet = L_UpdateZoomView(hWnd, &ZoomViewProps);
            
            if(nRet != SUCCESS)
            {
               POINT pt;
               pt = pData->ptMove;
               ClientToScreen(hWnd ,&pt);
               SetCursorPos(pt.x , pt.y);
            }
            else
            {
               pData->ptMove.x = x;
               pData->ptMove.y = y;
            }
         }
      }

      if(!PtInRect(&pData->rcView, pData->ptMove) && pData->Flags.bMoveSrc)
      {
         pData->Flags.bMoveSrc = FALSE;
         pData->Flags.bHiliteMarker = FALSE;
      }

      pData->ptEnd.x = x;
      pData->ptEnd.y = y;

      if(pData->ptEnd.x == pData->ptStart.x)
         return;

      if(pData->ptEnd.y == pData->ptStart.y)
         return;

      if(pData->Flags.bHiliteMarker)
         HiliteMark(hWnd, FALSE);
   }
}

/*======[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)
{
   LPWINDOWDATA   pData = (LPWINDOWDATA) GetWindowLong(hWnd, GWL_USERDATA);

   ZOOMVIEWPROPS ZoomViewProps;
   RECT rcSrc;
   
   if(!IsRectEmpty(&pData->rcOldClip))
      ClipCursor(&pData->rcOldClip);
   
   if((pData->ptStart.x == pData->ptEnd.x) || (pData->ptStart.y == pData->ptEnd.y))
   {
      ReleaseCapture();
      return;
   }

   pData->nActiveZoomView = -1;
   memset(&ZoomViewProps, 0, sizeof(ZOOMVIEWPROPS));
   ZoomViewProps.uStructSize = sizeof(ZOOMVIEWPROPS);

   SetRect(&rcSrc, 
           min(pData->ptStart.x, pData->ptEnd.x), 
           min(pData->ptStart.y, pData->ptEnd.y), 
           max(pData->ptStart.x, pData->ptEnd.x), 
           max(pData->ptStart.y, pData->ptEnd.y));


   if((RECTWIDTH(&rcSrc) >= MIN_WIDTH) && (RECTHEIGHT(&rcSrc) >= MIN_HEIGHT) && (GetCapture() == hWnd))
   {
      L_INT nRet =0;
      ReleaseCapture();

      rcSrc.top = (L_INT32)((rcSrc.top - pData->rcView.top) / pData->dFactor * FACTOR);
      rcSrc.left = (L_INT32)((rcSrc.left - pData->rcView.left) / pData->dFactor * FACTOR);
      rcSrc.bottom = (L_INT32)((rcSrc.bottom - pData->rcView.top) / pData->dFactor * FACTOR);
      rcSrc.right = (L_INT32)((rcSrc.right - pData->rcView.left) / pData->dFactor * FACTOR);

      CopyRect(&ZoomViewProps.rcSrc, &rcSrc);

      SetRect(&ZoomViewProps.rcDst, rcSrc.right + 10, rcSrc.top , 0,0);

      CopyRect(&ZoomViewProps.rcView, &pData->rcView);

      ZoomViewProps.nZoom     = 200;
      ZoomViewProps.bForceDst = FALSE;
      ZoomViewProps.bEnabled  = TRUE;

      ZoomViewProps.uZoomViewBorderStyle  = ZOOMVIEWBORDERSTYLE_3D;
      ZoomViewProps.crZoomViewBorder      = RGB(255,0,0);
      ZoomViewProps.nZoomViewPenStyle     = PS_SOLID;

      ZoomViewProps.uSrcBorderStyle    = SOURCEBORDERSTYLE_3D;
      ZoomViewProps.crSrcBorder        = RGB(255,0,0);
      ZoomViewProps.nSrcPenStyle       = PS_SOLID;

      ZoomViewProps.bCallouts          = TRUE;
      ZoomViewProps.crCallout          = RGB(255,0,0);
      ZoomViewProps.nCalloutPenStyle   = PS_DASH;
      ZoomViewProps.hAnnContainer      = pData->hContainer;

      if(pData->Flags.bHiliteMarker)
      {
         nRet = L_CreateZoomView(hWnd, &pData->Bitmap, &ZoomViewProps);
      }

      pData->ptStart.x = pData->ptEnd.x = x;
      pData->ptStart.y = pData->ptEnd.y = y;
   }

   if(pData->Flags.bHiliteMarker)
   {
      HiliteMark(hWnd, FALSE);
      InvalidateRect(hWnd, 0,0);
   }
}

/*====(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;
   POINT          tmpPoint;

   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);

   // If the mouse click was in the client area of this child window,
   // display the appropriate popup menu.

   tmpPoint.x = (pt.x + pData->nHScrollPos);
   tmpPoint.y = (pt.y + pData->nVScrollPos);

   tmpPoint = ChangeToZoom(hWnd , &tmpPoint);

   pData->nActiveZoomView = PointInZoomView(hWnd, tmpPoint);
   
   if (pData->nActiveZoomView >= 0)
   {
      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 TRUE;
}

/*======[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;
   }
}

L_INT PointInZoomView(HWND hWnd, POINT pt)
{
   L_UINT uCount, i;

   ZOOMVIEWPROPS ZoomViewProps;

   if(L_WindowHasZoomView(hWnd))
   {
      L_GetZoomViewsCount(hWnd, &uCount);

      for(i=0; i < uCount; ++i)
      {
         ZoomViewProps.uIndex = uCount-i-1;
         L_GetZoomViewProps(hWnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));

         if(PtInRect(&ZoomViewProps.rcDst ,pt) || PtInRect(&ZoomViewProps.rcSrc ,pt))
         {
            return uCount-i-1;
         }
      }
   }

   return -1;
}


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

Syntax:     L_VOID ChDialog_OnZoomViewOptions(HWND hwnd)

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

L_VOID ChDialog_OnZoomViewOptions(HWND hwnd)
{
   ZOOMVIEWPROPS ZoomViewProps;
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);

   ZoomViewProps.uIndex = pData->nActiveZoomView;
   L_GetZoomViewProps(hwnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));

   if (DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_ZOOMVIEW_OPTIONS),hwnd,(DLGPROC)ZoomViewWHDlgProc,(LONG)&ZoomViewProps))
   {
      L_UpdateZoomView(hwnd, &ZoomViewProps);
      InvalidateRect(hwnd, NULL, TRUE);
   }
}

void Child_SizeChange(HWND hwnd, BOOL fInvalidate)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);
   RECT rcClient;

   if (fInvalidate)
      InvalidateRect (hwnd, NULL, TRUE);
   GetClientRect (hwnd, &rcClient);
   Child_ProcessSize (hwnd, IsIconic (hwnd) ? SIZEICONIC : SIZENORMAL,
                      RECTWIDTH (&rcClient), RECTHEIGHT (&rcClient));

   pData->Flags.bZoom = (pData->nZoom == 100) ? FALSE : TRUE;
   Check_Menu_Items(hChildMenu, &pData->Flags);
}

void Child_ProcessSize(HWND hwnd, UINT state, int cx, int cy)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);
   static BOOL fSizeInUse = FALSE;
   int nWidth, nHeight, nVScroll, nHScroll;
   DWORD dwStyle;
   L_INT cxOldClient, cyOldClient;

   if (!fSizeInUse)
   {
      fSizeInUse = TRUE;

      if (state != SIZEICONIC)
      {
         if (pData->Flags.bFitImage)
         {
            nWidth = 0;
            nHeight = 0;
         }
         else
         {
            nWidth = MulDiv (BITMAPWIDTH(&pData->Bitmap), pData->nZoom, 100);
            nHeight = MulDiv (BITMAPHEIGHT(&pData->Bitmap), pData->nZoom, 100);
         }

         cxOldClient = pData->cxClient;
         cyOldClient = pData->cyClient;
         pData->cxClient = cx;
         pData->cyClient = cy;

         dwStyle = GetWindowLong (hwnd, GWL_STYLE);

         nVScroll = GetSystemMetrics (SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER);
         nHScroll = GetSystemMetrics (SM_CYHSCROLL) - GetSystemMetrics(SM_CYBORDER);

         if (WS_VSCROLL & dwStyle)
            pData->cxClient += nVScroll;
         if (WS_HSCROLL & dwStyle)
            pData->cyClient += nHScroll;

         if (pData->cxClient < nWidth)
         {
            pData->cyClient -= nHScroll;
            if (pData->cyClient < nHeight)
               pData->cxClient -= nVScroll;
         }
         else if (pData->cyClient < nHeight)
         {
            pData->cxClient -= nVScroll;
            if (pData->cxClient < nWidth)
               pData->cyClient -= nHScroll;
         }

         pData->nHScrollStep = max (1, pData->cxClient / 10);
         pData->nVScrollStep = max (1, pData->cyClient / 10);

         pData->nVScrollMax = max (0, (nHeight - pData->cyClient /*- 1*/));
         pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax));

         pData->nHScrollMax = max (0, (nWidth - pData->cxClient /*- 1*/));
         pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax));

         if (pData->Flags.bFitImage)
         {
            SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient);
            MatchAspectRatio (&pData->rcView, BITMAPWIDTH(&pData->Bitmap), BITMAPHEIGHT(&pData->Bitmap));
         }
         else
         {
            RECT  rcView = pData->rcView;
            SetRect (&pData->rcView, 0, 0, nWidth, nHeight);
            OffsetRect (&pData->rcView, -pData->nHScrollPos, -pData->nVScrollPos);
            // check if I can avoid repainting the old window
            if(EqualRect(&pData->rcView, &rcView))
            {
               RECT  rc;
               // I don't have to redraw the old portion if the top-left corner of the window hasn't moved
               GetWindowRect(hwnd, &rc);
               if(rc.left == pData->rcWindow.left && rc.top == pData->rcWindow.top)
               {
                  SetRect(&rc, 0, 0, cxOldClient, cyOldClient);
                  IntersectRect(&rc, &rc, &pData->rcClient);
                  ValidateRect(hwnd, &rc);
               }
            }
         }

         SetScrollRange (hwnd, SB_HORZ, 0, pData->nHScrollMax, FALSE);
         SetScrollPos (hwnd, SB_HORZ, pData->nHScrollPos, TRUE);

         SetScrollRange (hwnd, SB_VERT, 0, pData->nVScrollMax, FALSE);
         SetScrollPos (hwnd, SB_VERT, pData->nVScrollPos, TRUE);

         L_AnnSetOffsetX(pData->hContainer, (L_DOUBLE) pData->rcView.left, ANNFLAG_NOINVALIDATE);
         L_AnnSetOffsetY(pData->hContainer, (L_DOUBLE) pData->rcView.top, ANNFLAG_NOINVALIDATE);

         L_AnnSetScalarX(pData->hContainer, (L_DOUBLE) RECTWIDTH(&pData->rcView) / BITMAPWIDTH(&pData->Bitmap), ANNFLAG_NOINVALIDATE);
         L_AnnSetScalarY(pData->hContainer, (L_DOUBLE) RECTHEIGHT(&pData->rcView) / BITMAPHEIGHT(&pData->Bitmap), ANNFLAG_NOINVALIDATE);
      }
      fSizeInUse = FALSE;
   }

   pData->dFactor = (L_DOUBLE)((((L_DOUBLE)RECTWIDTH(&pData->rcView) / (L_DOUBLE)pData->Bitmap.Width) * 100.0)) / 100.0;
   
   if(L_WindowHasZoomView(hwnd))
   {
      L_UINT uCount = 0;
      L_INT nRet = 0;
      ZOOMVIEWPROPS ZoomViewProps;

      L_GetZoomViewsCount(hwnd,&uCount);
      memset(&ZoomViewProps, 0, sizeof(ZOOMVIEWPROPS));

      for(L_UINT i = 0; i < uCount; ++i)
      {
         ZoomViewProps.uIndex = i;
         L_GetZoomViewProps(hwnd, &ZoomViewProps, sizeof(ZOOMVIEWPROPS));
         
         ZoomViewProps.rcView = pData->rcView;
         L_UpdateZoomView(hwnd, &ZoomViewProps);
      }
   }
}

L_VOID SetZoomFactor (HWND hwnd, int nZoom)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);
   DWORD dwStyle;
   int nHScroll, nVScroll;
   int nHeight, nWidth;
   RECT rcClient;
   int cxClient, cyClient;
   int x, y;


   GetClientRect (hwnd, &rcClient);
   cxClient = RECTWIDTH (&rcClient);
   cyClient = RECTHEIGHT (&rcClient);

   x = cxClient / 2;
   y = cyClient / 2;

   nWidth = MulDiv (BITMAPWIDTH(&pData->Bitmap), nZoom, 100);
   nHeight = MulDiv (BITMAPHEIGHT(&pData->Bitmap), nZoom, 100);

   dwStyle = GetWindowLong (hwnd, GWL_STYLE);

   nVScroll = GetSystemMetrics (SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER);
   nHScroll = GetSystemMetrics (SM_CYHSCROLL) - GetSystemMetrics(SM_CYBORDER);

   if (dwStyle & WS_VSCROLL)
      cxClient += nVScroll;
   if (dwStyle & WS_HSCROLL)
      cyClient += nHScroll;

   if (cxClient < nWidth)
   {
      cyClient -= nHScroll;
      if (cyClient < nHeight)
         cxClient -= nVScroll;
   }
   else if (cyClient < nHeight)
   {
      cxClient -= nVScroll;
      if (cxClient < nWidth)
         cyClient -= nHScroll;
   }

   pData->nVScrollMax = max (0, (int) nHeight - (int) cyClient /*- 1*/);
   pData->nHScrollMax = max (0, (int) nWidth - (int) cxClient /*- 1*/);

   pData->nVScrollStep = max (1, cyClient / 10);
   pData->nHScrollStep = max (1, cxClient / 10);

   if(RECTWIDTH(&pData->rcView))
      pData->nHScrollPos = (int) ((long) (x - pData->rcView.left) * nWidth / RECTWIDTH(&pData->rcView)) - (cxClient / 2);
   if(RECTHEIGHT(&pData->rcView))
      pData->nVScrollPos = (int) ((long) (y - pData->rcView.top) * nHeight / RECTHEIGHT(&pData->rcView)) - (cyClient / 2);

   pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax));
   pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax));

   pData->nZoom = nZoom;
   return;
}

/*======[Child_OnKeyDown]===============================================

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

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

L_VOID Child_OnKeyDown(HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags)
{
   LPWINDOWDATA pData = (LPWINDOWDATA) GetWindowLong(hwnd,GWL_USERDATA);

   if (fDown)
   {
      switch (vk)
      {
      case VK_DELETE:
         if(pData->nActiveZoomView >=0)
         {
            L_DestroyZoomView(hwnd,pData->nActiveZoomView);
            pData->nActiveZoomView = -1;
         }
         break;
      }
   }
}

/*====(SaveBitmapFile)=========================================================
Description: Save the image to file.

Syntax     : L_INT SaveBitmapFile (HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/

L_INT SaveBitmapFile (HWND hWnd)
{
   SAVEDLGPARAMS  DlgParams;
   OPENFILENAME   OpenFileName;
   SAVEFILEOPTION SaveFileOption;
   LPWINDOWDATA   pData;
   L_INT          nRet;
   L_TCHAR        szFile[1024] = TEXT("");
   pDIMENSION     pOldResolutions = NULL;
   pDIMENSION     pJBIGResolutions = NULL;

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

   memset(&DlgParams,    0, sizeof(SAVEDLGPARAMS));
   memset(&OpenFileName, 0, sizeof(OPENFILENAME));
   memset(&SaveFileOption, 0, sizeof(SAVEFILEOPTION));

   OpenFileName.lStructSize     = sizeof ( OPENFILENAME ) ;
   OpenFileName.lpstrTitle      = TEXT("Save a File");
   DlgParams.uStructSize        = sizeof ( SAVEDLGPARAMS ) ;
   DlgParams.nQFactor           = 2;
   DlgParams.nPageNumber        = 1;
   DlgParams.nBitsPerPixel      = pData->Bitmap.BitsPerPixel;
   DlgParams.uSaveMulti         = MULTIPAGE_OPERATION_APPEND;
   DlgParams.pBitmap            = &pData->Bitmap;
   DlgParams.uDlgFlags          = DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE     |
                                  DLG_SAVE_AUTOPROCESS                      |
                                  DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE       |
                                  DLG_SAVE_SHOW_FILEOPTIONS_STAMP           |
                                  DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR         |
                                  DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS      |
                                  DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS ;

   nRet = L_DlgSave ( hWnd, &OpenFileName,  &DlgParams );

   return TRUE;
}