/*[]=====================================================================[]*/
/*[]     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 VOID          FRAME_OnCommand         (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify);
static VOID          FRAME_OnInitMenuPopup   (HWND hWnd, HMENU hMenu, L_INT nItem, BOOL fSystemMenu);
static VOID          FRAME_OnDestroy         (HWND hWnd);
static BOOL          FRAME_OnCreate          (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static VOID          FRAME_OnClose           (HWND hWnd);
static BOOL          FRAME_OnQueryNewPalette (HWND hwnd);
static VOID          FRAME_OnPaletteChanged  (HWND hwnd, HWND hwndPaletteChange);
static VOID          FRAME_SysColorChange    (HWND hwnd);
static VOID          FRAME_OnPaletteChanging (HWND hWnd, HWND hWndPaletteChange);

static L_VOID        TwainAcquire     (HWND hwnd);
L_INT                OpenBitmap       (HWND hWnd);
HWND                 CreateChildWindow(L_TCHAR L_FAR * pszTitle,
                                       pBITMAPHANDLE pBitmap,
                                       L_BOOL bIsFile);
L_INT L_FAR L_EXPORT TwainCallBack    (HTWAINSESSION hTwain,
                                       pBITMAPHANDLE pBitmap,
                                       L_VOID L_FAR * pUserData);

L_BOOL        g_bTWAINAvailable = FALSE;
HTWAINSESSION g_hTwain = NULL;
TW_UINT16     g_twXferMech = TWSX_NATIVE;
L_BOOL        g_bStartAcquire = FALSE;
ERRORLIST *   g_pErrorList = NULL;
L_INT         g_nErrorListCount = 0;
L_INT         g_nErrorListMaxCount = 0;

LRESULT CALLBACK FrameWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
      HANDLE_MSG (hwnd, WM_CREATE,            FRAME_OnCreate);
      HANDLE_MSG (hwnd, WM_INITMENUPOPUP,     FRAME_OnInitMenuPopup);
      HANDLE_MSG (hwnd, WM_DESTROY,           FRAME_OnDestroy);
      HANDLE_MSG (hwnd, WM_COMMAND,           FRAME_OnCommand);
      HANDLE_MSG (hwnd, WM_CLOSE,             FRAME_OnClose);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,    FRAME_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,   FRAME_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_SYSCOLORCHANGE,    FRAME_SysColorChange);
      HANDLE_MSG (hwnd, WM_PALETTEISCHANGING, FRAME_OnPaletteChanging);
   }

   return DefFrameProc (hwnd, hwndClient, message, wParam, lParam);
}

static VOID FRAME_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify)
{
   HWND hwndChild;

   switch (id)
   {
   case IDM_FILE_OPEN:
      OpenBitmap(hWnd);
      return;
   case IDM_FILE_CLOSE:
      hwndChild = (HWND) SendMessage(hwndClient, WM_MDIGETACTIVE, 0, 0);

      if (SendMessage(hwndChild, WM_QUERYENDSESSION, 0, 0))
         SendMessage (hwndClient, WM_MDIDESTROY, (WPARAM)hwndChild, 0);
      return;
   case IDM_TWAIN_SELECTSOURCE:
      L_TwainSelectSource(g_hTwain, NULL);
      return;
   case IDM_TWAIN_ACQUIRE:
      TwainAcquire(hWnd);
      return;
   case IDM_TEMPLATE_LEADTEMPLATE:
      DoDialogBoxParam(IDD_LEAD_TEMPLATE, hWnd, (DLGPROC)TemplateDlgProc, 0);
      return;
   case IDM_TEMPLATE_SHOWSUPPORTEDCAPABILITIES:
      DoDialogBoxParam(IDD_SUPPORTED_CAPS, hWnd, (DLGPROC)CapabilityDlgProc, 0);
      return;
   case IDM_TEMPLATE_SHOWERRORCODES:
      DoDialogBoxParam(IDD_ERROR_LIST, hWnd, (DLGPROC)ErrorListDlgProc, 0);
      return;
   case IDM_FILE_EXIT:
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      return;
   case IDM_WINDOW_TILE:
      SendMessage(hwndClient, WM_MDITILE, 0, 0);
      return;
   case IDM_WINDOW_CASCADE:
      SendMessage(hwndClient, WM_MDICASCADE, 0, 0);
      return;
   case IDM_WINDOW_ARRANGE:
      SendMessage(hwndClient, WM_MDIICONARRANGE, 0, 0);
      return;
   case IDM_WINDOW_CLOSEALL:
      EnumChildWindows(hwndClient, (WNDENUMPROC)CloseEnumProc, 0);
      return;
   case IDM_HELP_ABOUT:
      DoDialogBoxParam(IDD_ABOUTBOX, hWnd, (DLGPROC) AboutDlgProc, 0);
      return;
   default:
      hwndChild = (HWND) SendMessage (hwndClient, WM_MDIGETACTIVE, 0, 0);

   if (IsWindow (hwndChild))
      SendMessage(hwndChild, WM_COMMAND, MAKEWPARAM((UINT)(id),(UINT)(codeNotify)), (LPARAM)(HWND)(hwndCtl));
      break;
   }

   DefFrameProc(hWnd, hwndClient, WM_COMMAND, MAKEWPARAM((UINT)(id),(UINT)(codeNotify)), (LPARAM)(HWND)(hwndCtl));
}

static BOOL FRAME_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
   CLIENTCREATESTRUCT clientcreate;

   clientcreate.hWindowMenu  = hMenuInitWindow;
   clientcreate.idFirstChild = IDM_FIRSTCHILD;
   L_DlgInit(DLG_INIT_COLOR);
   hwndClient = CreateWindow(TEXT ("MDICLIENT"),
                             NULL,
                             WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT, 
                             hWnd,
                             (HMENU) 1,
                             hInstMain,
                             (PSTR) &clientcreate);

   if (hwndClient)
   {
      UNLOCKSUPPORT();
      g_bTWAINAvailable = L_IsTwainAvailable(hWnd);

      if (g_bTWAINAvailable)
      {
         APPLICATIONDATA AppData;
         AppData.hWnd = hWnd;
         lstrcpy (AppData.szManufacturerName, TEXT("LEAD Technologies, Inc.")); 
         lstrcpy (AppData.szAppProductFamily, TEXT("LEAD Demo"));
         lstrcpy (AppData.szVersionInfo,      TEXT("Version 1.0"));
         lstrcpy (AppData.szAppName,          TEXT("LEAD Demo"));
         AppData.uStructSize = sizeof(APPLICATIONDATA);

         L_TwainInitSession (&g_hTwain, &AppData);
      }
      else
         MessageBox(hWnd, TEXT("Twain driver is not installed!\nPlease, install it before run this demo."), TEXT("Twain Driver"), MB_OK | MB_ICONERROR);
   }

   return ((hwndClient) ? TRUE : FALSE);
}

static VOID FRAME_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, BOOL fSystemMenu)
{
   EnableMenuItem(hMenu, IDM_TWAIN_SELECTSOURCE,      MF_BYCOMMAND | ((g_bTWAINAvailable && !g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_TWAIN_ACQUIRE     ,      MF_BYCOMMAND | ((g_bTWAINAvailable && !g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_TEMPLATE_LEADTEMPLATE,   MF_BYCOMMAND | ((g_bTWAINAvailable && !g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_TEMPLATE_SHOWSUPPORTEDCAPABILITIES, MF_BYCOMMAND | ((g_bTWAINAvailable && !g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_TEMPLATE_SHOWERRORCODES, MF_BYCOMMAND | ((g_bTWAINAvailable && !g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));

   EnableMenuItem(hMenu, IDM_FILE_OPEN,       MF_BYCOMMAND | ((!g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_FILE_SAVE,       MF_BYCOMMAND | ((!g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_FILE_CLOSE,      MF_BYCOMMAND | ((!g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_FILE_EXIT,       MF_BYCOMMAND | ((!g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_WINDOW_CLOSEALL, MF_BYCOMMAND | ((!g_bStartAcquire) ? MF_ENABLED : MF_GRAYED));
}

static VOID FRAME_OnClose(HWND hWnd)
{
   FORWARD_WM_COMMAND (hWnd, IDM_WINDOW_CLOSEALL, 0, 0, SendMessage);
   DestroyWindow (hWnd);
}

static VOID FRAME_OnDestroy(HWND hWnd)
{
   L_DlgFree();
   if (g_bTWAINAvailable)
      L_TwainEndSession (&g_hTwain);

   if (g_pErrorList)
   {
      GlobalFreePtr(g_pErrorList);
      g_nErrorListCount = 0;
      g_nErrorListMaxCount = 0;
   }

   PostQuitMessage (0);
}

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 OpenBitmap(HWND hWnd)
{
   HCURSOR        hOldCur;
   OPENFILENAME   OpenFileName;
   LOADFILEOPTION LoadFileOpt;
   BITMAPHANDLE   Bitmap;
   OPENDLGPARAMS  foParm;
   L_INT          nRet;
   HWND           hChldWnd;

   memset(&OpenFileName, 0, sizeof(OPENFILENAME));
   memset(&foParm, 0, sizeof(OPENDLGPARAMS));
   foParm.uStructSize = sizeof(OPENDLGPARAMS);

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.hwndOwner         = hWnd;
   OpenFileName.lpstrFilter       = NULL;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 0;
   OpenFileName.lpstrFileTitle    = NULL;
   OpenFileName.nMaxFileTitle     = 0;
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Open a File");
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = NULL;
   OpenFileName.lpfnHook          = NULL;
   OpenFileName.Flags             = 0;

   foParm.uDlgFlags = DLG_OPEN_SHOW_MULTIPAGE | DLG_OPEN_SHOW_FILEINFO | DLG_OPEN_SHOW_PREVIEW;

   nRet = L_DlgOpen(hWnd, &OpenFileName, &foParm);
   if (nRet == SUCCESS_DLG_OK)
   {
      hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));

      L_GetDefaultLoadFileOption(&LoadFileOpt, sizeof(LOADFILEOPTION));
      LoadFileOpt.PageNumber = foParm.pFileData[0].nPageNumber;

      nRet = L_LoadBitmap(foParm.pFileData[0].szFileName, &Bitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY, &LoadFileOpt, NULL);
      if (nRet == SUCCESS)
         hChldWnd = CreateChildWindow(foParm.pFileData[0].szFileName, &Bitmap, TRUE);

      SetCursor(hOldCur);
      CleanOpenDlgParam(&foParm);
   }

   return nRet;
}

HWND CreateChildWindow(L_TCHAR L_FAR * pszTitle, pBITMAPHANDLE pBitmap, L_BOOL bIsFile)
{
   MDICREATESTRUCT mdiCreateStruct;
   CREATEDATA      CreateData;
   HWND            hWndChild;

   CreateData.pszTitle = pszTitle;
   CreateData.pBitmap  = pBitmap;
   CreateData.bIsFile  = bIsFile;

   mdiCreateStruct.szClass = szChildClass;
   mdiCreateStruct.szTitle = pszTitle;
   mdiCreateStruct.hOwner  = hInstMain;
   mdiCreateStruct.x       = CW_USEDEFAULT;
   mdiCreateStruct.y       = CW_USEDEFAULT;
   mdiCreateStruct.cx      = CW_USEDEFAULT;
   mdiCreateStruct.cy      = CW_USEDEFAULT;
   mdiCreateStruct.style   = MDIS_ALLCHILDSTYLES|WS_CLIPCHILDREN;
   mdiCreateStruct.lParam  = (LPARAM) (LPCREATEDATA) & CreateData;

   hWndChild = (HWND) SendMessage(hwndClient,
                                  WM_MDICREATE,
                                  0,
                                  (LPARAM) (LPMDICREATESTRUCT) &mdiCreateStruct);
   return(hWndChild);
}

static L_VOID TwainAcquire(HWND hwnd)
{
   HCURSOR hOldCur;
   L_INT   nRet;
   L_TCHAR szError[256];

   g_bStartAcquire = TRUE;
   HMENU hMenu = GetSystemMenu(hwndFrame, FALSE);
   EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);

   hOldCur = SetCursor(LoadCursor (NULL, IDC_WAIT));

   /* Make sure the default transfer mode is set correctly */
   L_TwainStartCapsNeg(g_hTwain);

   TW_CAPABILITY twCap;
   pTW_ONEVALUE pOneVal = NULL;
   twCap.Cap = ICAP_XFERMECH;
   twCap.ConType = TWON_ONEVALUE;
   twCap.hContainer = GlobalAlloc(GHND, sizeof(TW_ONEVALUE));

   pOneVal = (pTW_ONEVALUE)GlobalLock(twCap.hContainer);
   pOneVal->Item = g_twXferMech;
   pOneVal->ItemType = TWTY_UINT16;

   GlobalUnlock(twCap.hContainer);

   L_TwainSetCapability(g_hTwain, &twCap, LTWAIN_CAPABILITY_SET);
   L_TwainEndCapsNeg(g_hTwain);

   nRet = L_TwainAcquire(g_hTwain,
                         NULL,
                         sizeof(BITMAPHANDLE),
                         TwainCallBack,
                         LTWAIN_SHOW_USER_INTERFACE | LTWAIN_MODAL_USER_INTERFACE,
                         NULL, NULL);

   if (nRet == SUCCESS)
   {
      if (g_twXferMech == TWSX_FILE)
         MessageBox(hwndFrame, TEXT("Acquired page(s) is saved to file(s)"), TEXT("Acquire to File"), MB_OK);
   }
   else
   {
      memset(szError, 0, sizeof(szError));
      wsprintf(szError, TEXT("An error occurred in TWAIN Acquire..., Error No: %d\n"), nRet);
      AddErrorToErrorList(szError);
      MessageBox(hwnd, szError, TEXT("Error!"), MB_OK);
   }

   SetCursor(hOldCur);
   g_bStartAcquire = FALSE;
   EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_ENABLED);
}

L_INT L_FAR L_EXPORT TwainCallBack (HTWAINSESSION hTwain, pBITMAPHANDLE pBitmap, L_VOID L_FAR * pUserData)
{
   static L_INT nTwainNo = 0;
   L_TCHAR      szTitle[256];
   HCURSOR      hOldCur;

   UNREFERENCED_PARAMETER(hTwain);
   UNREFERENCED_PARAMETER(pUserData);

   if (g_twXferMech != TWSX_FILE)
   {
      memset(szTitle, 0, sizeof(szTitle));
      wsprintf(szTitle, TEXT("Twain Data: %d"), ++nTwainNo);

      hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
      CreateChildWindow(szTitle, pBitmap, FALSE);

      L_FreeBitmap(pBitmap);
      SetCursor (hOldCur);
   }

   return SUCCESS;
}

L_BOOL CALLBACK L_EXPORT PaletteChangedAll (HWND hWnd, LPARAM lParam)
{
   if(GetParent(hWnd)!=hwndClient)
      return(TRUE);

   if (GetWindow (hWnd, GW_OWNER))
      return(TRUE);

   FORWARD_WM_PALETTECHANGED (hWnd, (HWND) (UINT) (lParam), SendMessage);

   return(TRUE);
}

L_BOOL CALLBACK L_EXPORT PaletteQueryAll(HWND hWnd, LPARAM lParam)
{
   if(GetParent(hWnd)!=hwndClient)
      return(TRUE);

   FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
   return(TRUE);
}

static BOOL FRAME_OnQueryNewPalette (HWND hwnd)
{
   HWND hWndChild = FORWARD_WM_MDIGETACTIVE (hwndClient, SendMessage);

   UNREFERENCED_PARAMETER(hwnd);
   if (IsWindow (hWndChild))
      FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage);
   return(TRUE);
}

static VOID FRAME_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteChangedAll, hInst);

   UNREFERENCED_PARAMETER(hWnd);
   EnumChildWindows (hwndClient, (WNDENUMPROC) lpfn, (LPARAM) (UINT) hWndPaletteChange);
   FreeProcInstance (lpfn);
   return;
}

static VOID FRAME_SysColorChange(HWND hwnd)
{
   FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteQueryAll, hInst);

   EnumChildWindows (hwndClient, (WNDENUMPROC) lpfn, 0);
   FreeProcInstance (lpfn);
   FRAME_OnQueryNewPalette (hwnd);
   return;
}

VOID FRAME_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   FRAME_OnPaletteChanged (hWnd, hWndPaletteChange);
}

L_VOID AddErrorToErrorList(L_TCHAR * pszError)
{
   if (g_nErrorListMaxCount == 0 || !g_pErrorList)
   {
      g_nErrorListMaxCount = 10;
      g_pErrorList = (ERRORLIST *)GlobalAllocPtr(GHND, sizeof(ERRORLIST) * g_nErrorListMaxCount);
      if (!g_pErrorList)
         g_nErrorListMaxCount = 0;

      g_nErrorListCount = 0;
   }
   else
   {
      if (g_nErrorListCount >= g_nErrorListMaxCount)
      {
         g_nErrorListMaxCount += 10;
         g_pErrorList = (ERRORLIST *)GlobalReAllocPtr(g_pErrorList, g_nErrorListMaxCount * sizeof(ERRORLIST), GHND); 
         if (!g_pErrorList)
         {
            g_nErrorListCount = 0;
            g_nErrorListMaxCount = 0;
         }
      }
   }

   lstrcpy(g_pErrorList[g_nErrorListCount].szError, pszError);
   g_nErrorListCount++;
}