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

#include "ImgPF.h"


#define  BUFF_SIZE   100
#define  EDT_INT 0
#define  EDT_DBL 1

typedef struct tagEDITBOXDATA
{
   WNDPROC   wndProcOld;
   L_DOUBLE  dMin;
   L_DOUBLE  dMax;
   L_DOUBLE  dInc;
   L_UINT    uPrec;     // Precession. Eg if 2 then let number be X.00
   L_UINT    uType;     // 0 Integer values, 1 For floats
}
EDITBOXDATA, L_FAR* LPEDITBOXDATA;

LRESULT CALLBACK NullWndProc (HWND hWnd, L_UINT msg, WPARAM wParam, LPARAM lParam)
{
   return 0;
}

static L_VOID GetCurselInfo (HWND hEditWnd, L_UINT * uCurselStrt, L_UINT * uCurselEnd)
{
   L_UINT   uCurselPos;

   uCurselPos   = (L_UINT) SendMessage(hEditWnd,EM_GETSEL, 0, 0);
   *uCurselStrt = (~0L >> (sizeof (L_UINT) * 4)) & uCurselPos;
   *uCurselEnd  = uCurselPos >> (sizeof (L_UINT) * 4);
}

static L_VOID GetStringNotLast (TCHAR pOutStr[], const TCHAR pStr[])
{
   L_UINT   nCtr;
   
   if (!pStr[0])
   {
      pOutStr[0] = '\0';
      return;
   }

   nCtr = 0;
   while (TRUE)
   {
      if (!pStr[nCtr + 1])
      {
         pOutStr[nCtr] = '\0';
         break;
      }

      pOutStr[nCtr] = pStr[nCtr];
      nCtr++;
   }
}

static L_VOID GetStringNotFirst (TCHAR pOutStr[], const TCHAR pStr[])
{
   L_UINT   nCtr;
   
   nCtr = 0;
   while (TRUE)
   {
      if (!pStr[nCtr])
      {
         pOutStr[nCtr] = '\0';
         break;
      }

      pOutStr[nCtr] = pStr[nCtr + 1];
      nCtr++;
   }
}

static L_BOOL ParseStringSuccess (const TCHAR pStr[], LPEDITBOXDATA pEditBoxData)
{
   L_UINT   uCtr       = 0;
   L_UINT   uCtrPrec   = 0;
   L_BOOL   bFoundDot  = FALSE;
   L_BOOL   bCheckPrec = FALSE;

   if ((pStr[uCtr] == '+') || (pStr[uCtr] == '-'))
      uCtr++;

   while (pStr[uCtr])
   {
      if (pStr[uCtr] == '.')
      {
         if (pEditBoxData->uType == EDT_DBL)
         {
            if (!bFoundDot)
            {
               bCheckPrec = TRUE;
               bFoundDot  = TRUE;
            }
            else
               return FALSE;
         }
         else
         {
            return FALSE;
         }
      }
      else
      {
         if (!((pStr[uCtr] >= '0') && (pStr[uCtr] <= '9')))
            return FALSE;
      }

      if (bCheckPrec && (uCtrPrec++ > pEditBoxData->uPrec))
            return FALSE;

      uCtr ++;
   }
   return TRUE;
}

static L_VOID GetLeftRightStrings (HWND         hEditWnd,
                                   const TCHAR  szText[],
                                   TCHAR        szLeft[],
                                   TCHAR        szRight[])
{
   L_UINT   uCurselStrt,
            uCurselEnd;
   L_UINT   uLStrIdx,
            uRStrIdx,
            uCtr;

   GetCurselInfo (hEditWnd, &uCurselStrt, &uCurselEnd);
   
   for (uLStrIdx = 0; uLStrIdx < uCurselStrt; uLStrIdx++)
      szLeft[uLStrIdx] = szText[uLStrIdx];

   uRStrIdx = 0;
   uCtr = uCurselEnd;
   while (TRUE)
   {
      if (!szText[uCtr])
         break;
      szRight[uRStrIdx++] = szText[uCtr++];
   }
}

static L_BOOL StringInRange (const TCHAR szText[], LPEDITBOXDATA pEditBoxData)
{
   L_DOUBLE    dVal;
   L_BOOL      bRet;
   L_INT       nVal;

   if (pEditBoxData->uType == EDT_DBL)
   {
      dVal = _tcstod (szText, NULL);

      if ((pEditBoxData->dMax >= dVal) && (pEditBoxData->dMin <= dVal))
         bRet = TRUE;
      else
         bRet = FALSE;
   }
   else
   {
      nVal = _ttoi (szText);

      if (((L_INT)(pEditBoxData->dMax) >= nVal) && ((L_INT)(pEditBoxData->dMin) <= nVal))
         bRet = TRUE;
      else
         bRet = FALSE;
   }
   return bRet;
}


static L_INT GetLengthSum (const TCHAR szFirst [],
                           const TCHAR szSecond[],
                           const TCHAR szThird [])
{
   L_INT nSum = 0;

   if (szFirst)
      nSum += lstrlen (szFirst);

   if (szSecond)
      nSum += lstrlen (szSecond);

   if (szThird)
      nSum += lstrlen (szThird);

   return ++nSum;
}

LRESULT CALLBACK EdtBxWP (HWND hEditWnd, L_UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPEDITBOXDATA  pEditBoxData;
   WNDPROC        wndProcOld;
   WNDPROC        oldWP;
   HGLOBAL        hCBData;
   L_UINT         uCurselStrt, uCurselEnd;
   L_BOOL         bRetTrue;
   L_BOOL         bInsertOn;
   TCHAR          szText [BUFF_SIZE] = TEXT("\0");
   TCHAR          szBuff [BUFF_SIZE] = TEXT("\0");
   TCHAR          szLeft [BUFF_SIZE] = TEXT("\0");
   TCHAR          szRight[BUFF_SIZE] = TEXT("\0");
   TCHAR          szTemp [BUFF_SIZE] = TEXT("\0");
   TCHAR          keyAscii;
   L_DOUBLE       dExtraNum;
   L_DOUBLE       dEdtBxVal, dNewEdtBxVal;
   L_INT          nEdtBxVal, nNewEdtBxVal;
   L_INT          nSign;
   L_INT          nDecPos;
   L_INT          nX, nIdxBuff;
   HWND           hDlg;

   pEditBoxData = (LPEDITBOXDATA) GetWindowLong (hEditWnd, GWL_USERDATA);
   wndProcOld   = pEditBoxData->wndProcOld;

   switch (msg)
   {
   case WM_CHAR:
      keyAscii = wParam;

      if (keyAscii == VK_BACK)
      {
         GetWindowText (hEditWnd, szText, BUFF_SIZE);
         GetCurselInfo (hEditWnd, &uCurselStrt, &uCurselEnd);
         GetLeftRightStrings (hEditWnd, szText, szLeft, szRight);

         if (uCurselStrt == uCurselEnd)
         {
            GetStringNotLast (szTemp, szLeft);
            wsprintf (szLeft, TEXT("%s"), szTemp);
         }

         wsprintf (szText, TEXT("%s%s"), szLeft, szRight);
         if (StringInRange(szText, pEditBoxData))
            break;
         else
            return 0;
      }

      if ((keyAscii >= 0) && (keyAscii <= 29))
         break;

      memset (szLeft,  0, BUFF_SIZE);
      memset (szRight, 0, BUFF_SIZE);

      GetWindowText (hEditWnd, szText, BUFF_SIZE);
      GetCurselInfo (hEditWnd, &uCurselStrt, &uCurselEnd);
      GetLeftRightStrings (hEditWnd, szText, szLeft, szRight);

      if (uCurselEnd - uCurselStrt)
      {
         // There is a selection
         if (keyAscii == VK_BACK)
         {
            wsprintf (szText, TEXT("%s%s"), szLeft, szRight);
         }
         else
         {
            if (GetLengthSum (szLeft, szRight, TEXT("x")) > BUFF_SIZE)
               return 0;
            else
               wsprintf (szText, TEXT("%s%c%s"), szLeft, keyAscii, szRight);
         }
      }
      else
      {
         // No selection
         if (keyAscii == VK_BACK)
         {
            GetStringNotLast (szTemp, szLeft);
            wsprintf (szText, TEXT("%s%s"), szTemp, szRight);
         }
         else
         {
            bInsertOn = GetKeyState (VK_INSERT) & 1;
            if (bInsertOn)
            {
               GetStringNotFirst (szTemp, szRight);
               wsprintf (szText, TEXT("%s%c%s"), szLeft, keyAscii, szTemp);
            }
            else
            {
               if (GetLengthSum (szLeft, szRight, TEXT("x")) > BUFF_SIZE)
                  return 0;
               else
                  wsprintf (szText, TEXT("%s%c%s"), szLeft, keyAscii, szRight);
            }
         }
      }

      if (!ParseStringSuccess (szText, pEditBoxData))
         return 0;

      if (StringInRange(szText, pEditBoxData))
      {
         hDlg = GetParent (hEditWnd);
         oldWP = (WNDPROC) SetWindowLong(hDlg, GWL_WNDPROC, (LONG) NullWndProc);
         SetWindowText (hEditWnd, szText);
         SetWindowLong(hDlg, GWL_WNDPROC, (LONG) oldWP);
         SendMessage (hEditWnd, EM_SETSEL, uCurselStrt + 1, uCurselStrt + 1);
         SendMessage (hDlg, WM_COMMAND, MAKEWPARAM((UINT)GetDlgCtrlID(hEditWnd),(UINT)EN_CHANGE), (LPARAM)(HWND)hEditWnd);
      }
      return 0;

   case WM_KEYDOWN:
      // If user presses Up arrow or Down then this edit box value will increase
      //    or decrease
      if (wParam == VK_DELETE)
      {
         GetWindowText (hEditWnd, szText, BUFF_SIZE);
         GetLeftRightStrings (hEditWnd, szText, szLeft, szRight);
         GetStringNotFirst (szTemp, szRight);
         wsprintf (szText, TEXT("%s%s"), szLeft, szTemp);
         if (StringInRange(szText, pEditBoxData))
            break;
         else
            return 0;
      }
      
      if ((wParam != VK_UP) && (wParam != VK_DOWN))
         break;

      dExtraNum = pEditBoxData->dInc;

      if (wParam == VK_DOWN)
         dExtraNum = -dExtraNum;

      GetWindowText (hEditWnd, szText, BUFF_SIZE);

      if (pEditBoxData->uType == EDT_DBL)
      {
         dEdtBxVal = _tcstod (szText, NULL);
         dNewEdtBxVal = max(pEditBoxData->dMin, 
                        min(pEditBoxData->dMax, dEdtBxVal + dExtraNum));

         if (dNewEdtBxVal == dEdtBxVal) 
            return 0;  // No need to process

         {
            LPSTR  pszTmp = NULL ;
            LPTSTR pszTmpBuff = NULL ;

            pszTmp = _fcvt (dNewEdtBxVal, pEditBoxData->uPrec, &nDecPos, &nSign);
         
            #ifdef UNICODE

               if ( NULL != pszTmp )
               {
                  pszTmpBuff = ( LPTSTR ) malloc ( strlen ( pszTmp ) * sizeof ( TCHAR ) ) ;
               
                  memset ( pszTmpBuff, 0, ( strlen ( pszTmp ) * sizeof ( TCHAR ) ) ) ;

                  MultiByteToWideChar ( CP_ACP, 
                                        MB_PRECOMPOSED, 
                                        pszTmp, 
                                        -1, 
                                        pszTmpBuff,
                                        ( strlen ( pszTmp ) * sizeof ( TCHAR ) ));
               }
            #else
               strcpy ( pszTmpBuff, pszTmp ) ;
            #endif

            nX = 0;
            nIdxBuff = 0;
            if (nSign)
               szText[nIdxBuff++] = '-';

            if (nDecPos <= 0)
            {
               nX = nDecPos;
               szText[nIdxBuff++] = '0';
               szText[nIdxBuff++] = '.';
               while (nX++)
                  szText[nIdxBuff++] = '0';
               nDecPos = -1;
               nX = 0;
            }
            while (TRUE)
            {
               if (nDecPos == nX)
                  szText[nIdxBuff++] = '.';

                  szText[nIdxBuff++] = *pszTmpBuff;

               if (*pszTmpBuff == '\0')
                  break;

               pszTmpBuff++;
               nX++;
            }

            #ifdef UNICODE
               if ( NULL != pszTmpBuff )
               {
                  free ( pszTmpBuff ) ;

                  pszTmpBuff = NULL ;
               }
            #endif
         }

         SetWindowText (hEditWnd, szText);
         return 0;
      }
      else
      if (pEditBoxData->uType == EDT_INT)
      {
         // Integer values
         nEdtBxVal = _ttoi (szText);
         nNewEdtBxVal = (L_INT)max(pEditBoxData->dMin, 
                        min(pEditBoxData->dMax, nEdtBxVal + (L_INT)(dExtraNum)));

         if (nNewEdtBxVal == nEdtBxVal)
            return 0;

         _itot (nNewEdtBxVal, szText, 10);
         SetWindowText (hEditWnd, szText);
         return 0;
      }
      break;

   case WM_PASTE:
      if (!IsClipboardFormatAvailable(CF_TEXT))
         return 0;

      if (!OpenClipboard(hEditWnd))
         return 0; 

      bRetTrue = FALSE;
      hCBData = GetClipboardData(CF_TEXT); 
      if (hCBData) 
      {
         LPTSTR szTmpBuff = NULL ;
            
         szTmpBuff = GlobalLock(hCBData);
         if (szTmpBuff) 
         {
            memset (szLeft,  0, BUFF_SIZE);
            memset (szRight, 0, BUFF_SIZE);
            GetWindowText (hEditWnd, szText, BUFF_SIZE);
            GetLeftRightStrings (hEditWnd, szText, szLeft, szRight);

            if (GetLengthSum (szLeft, szTmpBuff, szRight) > BUFF_SIZE)
            {
               GlobalUnlock (hCBData);
               CloseClipboard();
               return 0;
            }
            wsprintf (szText, TEXT("%s%s%s"), szLeft, szTmpBuff, szRight);
            bRetTrue = TRUE;

            if (!ParseStringSuccess(szText, pEditBoxData))
               bRetTrue = FALSE;


            if (pEditBoxData->uType == EDT_DBL)
            {
               dEdtBxVal = _tcstod (szText, NULL);
               if ((pEditBoxData->dMax >= dEdtBxVal) && (pEditBoxData->dMin <= dEdtBxVal) && bRetTrue)
                  bRetTrue = TRUE;
               else
                  bRetTrue = FALSE;
            }
            else
            {
               nEdtBxVal = _ttoi (szText);
               if (((L_INT)(pEditBoxData->dMax) >= nEdtBxVal) && ((L_INT)(pEditBoxData->dMin) <= nEdtBxVal) && bRetTrue)
                  bRetTrue = TRUE;
               else
                  bRetTrue = FALSE;
            }
         }

         GlobalUnlock(hCBData);
      }

      CloseClipboard();

      if (bRetTrue)
         break;
      else
         return 0;

   case WM_NCDESTROY:
      SetWindowLong (hEditWnd, GWL_WNDPROC, (LONG) pEditBoxData->wndProcOld);
      free (pEditBoxData);
      break;
   }

   return CallWindowProc (wndProcOld, hEditWnd, msg, wParam, lParam);
}

L_INT SetNumericEditBox (HWND     hEditWnd,
                         L_DOUBLE dMinRange,
                         L_DOUBLE dMaxRange,
                         L_DOUBLE dIncrement,
                         L_UINT   uPrecesion,
                         L_BOOL   bIsDouble)
{
   LPEDITBOXDATA  pEditBoxData;
   L_DOUBLE       dTmp;

   if (dMinRange > dMaxRange)
   {
      dTmp = dMinRange;
      dMinRange = dMaxRange;
      dMaxRange = dTmp;
   }
   
   pEditBoxData = (LPEDITBOXDATA) malloc (sizeof(EDITBOXDATA));
   memset (pEditBoxData, 0, sizeof(EDITBOXDATA));

   if (!pEditBoxData)
      return 0;

   pEditBoxData->uType = (bIsDouble ? EDT_DBL : EDT_INT);
   pEditBoxData->dMin  = dMinRange;
   pEditBoxData->dMax  = dMaxRange;
   pEditBoxData->dInc  = dIncrement;
   pEditBoxData->uPrec = uPrecesion;

   SetWindowLong (hEditWnd, GWL_USERDATA, (LONG) pEditBoxData);
   pEditBoxData->wndProcOld = (WNDPROC) GetWindowLong(hEditWnd, GWL_WNDPROC);
   SetWindowLong (hEditWnd, GWL_WNDPROC, (LONG)EdtBxWP);
   return 1;
}