/*[]=====================================================================[]*/
/*[]     LeadTools Run Time Library - Version 14                         []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2005 by LEAD Technologies, Inc.              []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

#define  STRICT
#include <windows.h>
#include <windowsx.h>

#include "Twain.h"

static BOOL  Child_OnCreate         (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static VOID  Child_OnCommand        (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify);
static VOID  Child_OnSize           (HWND hWnd, UINT nState, int nCx, int nCy); 
static VOID  Child_OnPaint          (HWND hWnd);
static VOID  Child_OnMDIActivate    (HWND hWnd, BOOL fActive, HWND hWndActivate,HWND hWndDeactivate);
static VOID  Child_OnDestroy        (HWND hWnd);
static VOID  Child_OnVScroll        (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos);
static VOID  Child_OnHScroll        (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos);
static BOOL  Child_OnEraseBkgnd     (HWND hWnd, HDC hDC);
static VOID  Child_OnClose          (HWND hWnd);
static VOID  Child_OnSetFocus       (HWND hWnd, HWND hwndOldFocus);
static VOID  Child_OnKillFocus      (HWND hWnd, HWND hwndNewFocus);
static BOOL  Child_OnQueryNewPalette(HWND hWnd);
static VOID  Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange);
       L_INT SaveBitmap             (HWND hWnd);

static HWND hwndClient, hwndFrame;
       BOOL bInScroll;

LRESULT CALLBACK ChildWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
      HANDLE_MSG (hwnd, WM_CREATE,          Child_OnCreate);
      HANDLE_MSG (hwnd, WM_COMMAND,         Child_OnCommand);
      HANDLE_MSG (hwnd, WM_SIZE,            Child_OnSize);
      HANDLE_MSG (hwnd, WM_MDIACTIVATE,     Child_OnMDIActivate);
      HANDLE_MSG (hwnd, WM_PAINT,           Child_OnPaint);
      HANDLE_MSG (hwnd, WM_DESTROY,         Child_OnDestroy);
      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_CLOSE,           Child_OnClose);
      HANDLE_MSG (hwnd, WM_SETFOCUS,        Child_OnSetFocus);
      HANDLE_MSG (hwnd, WM_KILLFOCUS,       Child_OnKillFocus);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,  Child_OnPaletteChanged);
   }

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

static BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
   LPCHILDDATA    pChldData;
   LPCREATEDATA   pCreateData;
   // Allocate memory for window private data

   pCreateData = (LPCREATEDATA) CHILDCREATELPARAM(lpCreateStruct);
   pChldData = (LPCHILDDATA) GlobalAllocPtr (GHND, sizeof (CHILDDATA));

   pChldData->nVscrollPos = 0;
   pChldData->nVscrollMax = 0;
   pChldData->nVscrollStep= 0;
   pChldData->nHscrollPos = 0;
   pChldData->nHscrollMax = 0;
   pChldData->nHscrollStep= 0;
   pChldData->cxClient    = 0;
   pChldData->cyClient    = 0;
   pChldData->bIsFile     = FALSE;
   pChldData->hPalette    = NULL;
   pChldData->pszTitle    = (TCHAR*)GlobalAllocPtr(GHND, ((lstrlen(pCreateData->pszTitle) + 1) * sizeof(TCHAR)));
   if (pChldData->pszTitle)
      lstrcpy(pChldData->pszTitle, pCreateData->pszTitle);

   L_CopyBitmap(&pChldData->Bitmap, pCreateData->pBitmap, sizeof(BITMAPHANDLE));
   SetWindowLong (hWnd, GWL_USERDATA, (long) pChldData);

   // Save some window handles
   hwndClient = GetParent (hWnd);
   hwndFrame  = GetParent (hwndClient);

   FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
   return TRUE;
}

static VOID Child_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify)
{
   HCURSOR     hOldCur;
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   switch (id)
   {
   case IDM_FILE_SAVE:
      SaveBitmap(hWnd);
      break;
   }

   SetCursor(hOldCur);
   return;
}

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

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

   if (!fSizeInUse)
   {
      fSizeInUse = TRUE;

      if (!IsIconic(hWnd)) // if window is normal
      {
         if (!pData->Bitmap.Flags.Allocated)
         {
            /* if bitmap is not allocated then set width and height to ZERO */
            nWidth = 0;
            nHeight = 0;
         }
         else // if bitmap is allocated, then set the width and height to bitmap width and height
         {
            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);
         nVScroll = GetSystemMetrics (SM_CXVSCROLL); // Get Vertical scroll arrow width
         nHScroll = GetSystemMetrics (SM_CXHSCROLL); // Get Horizontal scroll arrow width

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

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

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

         pData->nVscrollStep = max (1, pData->cyClient / SCROLL_RATIO);
         pData->nVscrollMax = max(0, (nHeight - pData->cyClient - 1));
         pData->nVscrollPos = max (0, min (pData->nVscrollPos, pData->nVscrollMax));
         pData->nHscrollStep = max (1, pData->cxClient / SCROLL_RATIO);
         pData->nHscrollMax = max (0, (nWidth - pData->cxClient - 1));
         pData->nHscrollPos = max (0, min (pData->nHscrollPos, pData->nHscrollMax));

         if (pData->Bitmap.Flags.Allocated)
         {
            SetRect (&pData->rcView, 0, 0, nWidth, nHeight);
            OffsetRect (&pData->rcView, -pData->nHscrollPos, -pData->nVscrollPos);
         }

         SetScrollRange (hWnd, SB_HORZ, 0, pData->nHscrollMax, TRUE);
         SetScrollPos (hWnd, SB_HORZ, pData->nHscrollPos, TRUE);
         SetScrollRange (hWnd, SB_VERT, 0, pData->nVscrollMax, TRUE);
         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);
}

static VOID Child_OnPaint (HWND hWnd)
{
   LPCHILDDATA pChldData;
   HPALETTE    oldPalette;
   PAINTSTRUCT ps;
   HDC         hdc;

   hdc = BeginPaint (hWnd, &ps);

   pChldData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if ((pChldData->Bitmap.Flags.Allocated))
   {
      if (pChldData->hPalette)
      {
         oldPalette = SelectPalette(hdc, pChldData->hPalette, TRUE);
         RealizePalette(hdc);
      }

      L_PaintDC(hdc, &pChldData->Bitmap, NULL, NULL, &pChldData->rcView, &ps.rcPaint, SRCCOPY);

      if (pChldData->hPalette)
         SelectPalette(hdc, oldPalette, TRUE);
   }

   EndPaint (hWnd, &ps);
}

static VOID Child_OnMDIActivate (HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate)
{
   if (fActive)
   {
      Child_OnQueryNewPalette(hWnd);
      SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuChild, (LPARAM) hMenuChildWindow);
   }
   else
      SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuInit, (LPARAM) hMenuInitWindow);
 
   DrawMenuBar (hwndFrame);
}

static VOID Child_OnClose  (HWND hWnd)
{
   LPCHILDDATA pChldData;
   pChldData = (LPCHILDDATA) GetWindowLong (hWnd, GWL_USERDATA);
   if (pChldData)
   {
      if (pChldData->hPalette)
      {
         DeleteObject(pChldData->hPalette);
         pChldData->hPalette = NULL;
      }

      if (pChldData->Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&pChldData->Bitmap);
         L_InitBitmap(&pChldData->Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

      if (pChldData->pszTitle)
      {
         GlobalFreePtr(pChldData->pszTitle);
         pChldData->pszTitle = NULL;
      }
   }

   FORWARD_WM_CLOSE(hWnd, DefMDIChildProc);
}

static VOID Child_OnDestroy (HWND hWnd)
{
   LPCHILDDATA pChldData;
   pChldData = (LPCHILDDATA) GetWindowLong (hWnd, GWL_USERDATA);
   if (pChldData)
   {
      if (pChldData->hPalette)
      {
         DeleteObject(pChldData->hPalette);
         pChldData->hPalette = NULL;
      }

      if (pChldData->Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&pChldData->Bitmap);
         L_InitBitmap(&pChldData->Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

      if (pChldData->pszTitle)
      {
         GlobalFreePtr(pChldData->pszTitle);
         pChldData->pszTitle = NULL;
      }
   }
}

static VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos)
{
   L_INT       nScrollInc;
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   bInScroll = TRUE;

   switch (nCode)
   {
   case SB_BOTTOM:
      nScrollInc = pData->nVscrollMax - pData->nVscrollPos;
      break;
   case SB_TOP:
      nScrollInc = -pData->nVscrollPos;
      break;
   case SB_LINEDOWN:
      nScrollInc = pData->nVscrollStep;
      break;
   case SB_LINEUP:
      nScrollInc = -pData->nVscrollStep;
      break;
   case SB_PAGEDOWN:
      nScrollInc = max (pData->nVscrollStep, (pData->cyClient - pData->nVscrollStep));
      break;
   case SB_PAGEUP:
      nScrollInc = -max (pData->nVscrollStep, (pData->cyClient - pData->nVscrollStep));
      break;
   case SB_THUMBTRACK:
   case SB_THUMBPOSITION:
      nScrollInc = nPos - pData->nVscrollPos;
      break;
   default:
      nScrollInc = 0;
      break;
   }
   nScrollInc = max (-pData->nVscrollPos,
                min (nScrollInc, (pData->nVscrollMax - pData->nVscrollPos)));

   if(nScrollInc)
   {
      pData->nVscrollPos += nScrollInc;
      OffsetRect   (&pData->rcView, 0, -nScrollInc);
      ScrollWindow (hWnd, 0, -nScrollInc, NULL, NULL);
      SetScrollPos (hWnd, SB_VERT, pData->nVscrollPos, TRUE);
      UpdateWindow (hWnd);
   }
   bInScroll = FALSE;
}

static VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos)
{
   L_INT nHScrollInc;
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   bInScroll = TRUE;

   switch (nCode)
   {
   case SB_LEFT:
      nHScrollInc = -pData->nHscrollPos;
      break;
   case SB_RIGHT:
      nHScrollInc = pData->nHscrollMax - pData->nHscrollPos;
      break;
   case SB_LINELEFT:
      nHScrollInc = -pData->nHscrollStep;
      break;
   case SB_LINERIGHT:
      nHScrollInc = pData->nHscrollStep;
      break;
   case SB_PAGELEFT:
      nHScrollInc = -max(pData->nHscrollStep, (pData->cxClient - pData->nHscrollStep));
      break;
   case SB_PAGERIGHT:
      nHScrollInc = max(pData->nHscrollStep, (pData->cxClient - pData->nHscrollStep));
      break;
   case SB_THUMBPOSITION:
      nHScrollInc = nPos - pData->nHscrollPos;
      break;
   default:
      nHScrollInc = 0;
      break;
   }

   nHScrollInc = max (-pData->nHscrollPos, min (nHScrollInc, (pData->nHscrollMax - pData->nHscrollPos)));

   if (nHScrollInc)
   {
      pData->nHscrollPos += nHScrollInc;

      OffsetRect (&pData->rcView, -nHScrollInc, 0);
      ScrollWindow (hWnd, -nHScrollInc, 0, NULL, NULL);
      SetScrollPos (hWnd, SB_HORZ, pData->nHscrollPos, TRUE);
      UpdateWindow (hWnd);
   }
   bInScroll = FALSE;
}

static BOOL Child_OnEraseBkgnd (HWND hWnd, HDC hDC)
{
   RECT rcClient;
   GetClientRect(hWnd, &rcClient);
   HBRUSH hBrush = CreateSolidBrush(GetSysColor(DKGRAY_BRUSH));

   FillRect(hDC, &rcClient, hBrush);

   /*if (!bInScroll)
      return ((BOOL) FORWARD_WM_ERASEBKGND (hWnd, hDC, DefWindowProc));*/

   return TRUE;
}

L_INT SaveBitmap(HWND hWnd)
{
   LPCHILDDATA   pData;
   OPENFILENAME  SaveFileName;
   SAVEDLGPARAMS FSParm;
   L_TCHAR        szBuffer[MAX_PATH];
   L_INT         nRet;

   memset(&SaveFileName, 0, sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));
   FSParm.uStructSize = sizeof(SAVEDLGPARAMS);
   memset(szBuffer, 0, sizeof(szBuffer));

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

   FSParm.nQFactor      = 2;
   FSParm.pBitmap       = &pData->Bitmap;
   FSParm.uDlgFlags     =  DLG_SAVE_AUTOPROCESS |
                           DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE|
                           DLG_SAVE_AUTOPROCESS  |
                           DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS|
                           DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS|
                           DLG_SAVE_SHOW_FILEOPTIONS_STAMP|
                           DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE |
                           DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR;
      
   SaveFileName.lStructSize       = sizeof(OPENFILENAME);
   SaveFileName.lpstrInitialDir   = NULL;
   SaveFileName.lpstrTitle        = TEXT("Save As");
   SaveFileName.lpstrFile         = szBuffer;
   SaveFileName.nMaxFile          = sizeof(szBuffer)/sizeof(L_TCHAR);
   SaveFileName.lpstrFileTitle    = FSParm.szFileName;
   SaveFileName.nMaxFileTitle     = sizeof(FSParm.szFileName)/sizeof(L_TCHAR);
   SaveFileName.nFileOffset       = 0;
   SaveFileName.Flags             = 0;

   nRet = L_DlgSave (hWnd, &SaveFileName, &FSParm);
   if (nRet <= 0)
   {
      memset(szBuffer, 0, sizeof(szBuffer));
      wsprintf(szBuffer, TEXT("Can not save file,\nError code = %d\n"), nRet);
      MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
   }

   return SUCCESS;
}

static VOID Child_OnSetFocus(HWND hWnd, HWND hWndOldFocus)
{
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if(L_BitmapHasRgn(&pData->Bitmap))
      SetTimer(hWnd, 1, 100, NULL);
}

static VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus)
{
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if(L_BitmapHasRgn(&pData->Bitmap))
      KillTimer(hWnd, 1);
}

BOOL Child_OnQueryNewPalette (HWND hWnd)
{
   HDC         hDC;
   HPALETTE    hPalette;
   L_INT       nColors = 0;
   LPCHILDDATA pData;

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

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

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

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

      if (pData->hPalette)
      {
         hPalette = SelectPalette (hDC, pData->hPalette, FALSE);
         nColors = RealizePalette (hDC);

         if (nColors)
            InvalidateRect(hWnd, NULL, FALSE);

         SelectPalette (hDC, hPalette, TRUE);
      }
      ReleaseDC (hWnd, hDC);
   }
   return (nColors);
}

VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   HDC         hDC;
   HPALETTE    hPalette;
   LPCHILDDATA pData;

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

   if (hWnd == hWndPaletteChange)
      return;

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

   if (pData->Bitmap.Flags.Allocated)
   {
      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);
   }
   return;
}