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

#include "ImgPF.h"

LRESULT CALLBACK ButtonProc           (HWND hEditWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam);
static L_BOOL RepClrDlg_OnCommand     (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT codeNotify);  
static L_BOOL RepClrDlg_OnHScroll     (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);  
static L_BOOL RepClrDlg_OnInitDialog  (HWND hWnd, HWND hWndFocus, LPARAM lParam);  
static L_VOID RepClrDlg_OnTimer       (HWND hWnd, L_INT nID);  
static L_BOOL RepClrDlg_OnPaint       (HWND hWnd);  
static L_BOOL RepClrDlg_OnInitDialog  (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_BOOL RepClrDlg_OnLButtonDown (HWND hWnd, L_BOOL bDoubleClick, L_INT nX, L_INT nY, L_UINT uKeyFlags);
static L_BOOL RepClrDlg_OnMouseMove   (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags);
static L_BOOL RepClrDlg_OnLButtonUp   (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags);
static L_VOID L_ApplyFilter           (HWND hWnd);
static L_VOID L_GetSelectionImage     (HWND hWnd);
static L_VOID Paint_Button            (HWND hWnd, L_BOOL bBegin);
static L_INT  GetProcPixel            (pBITMAPHANDLE pBitmap);
static LRESULT CALLBACK Mouse         (L_INT nCode, WPARAM wParam, LPARAM lParam);

L_BOOL CALLBACK ReplaceColorDlgProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG (hWnd, WM_COMMAND,     RepClrDlg_OnCommand);
      HANDLE_MSG (hWnd, WM_INITDIALOG,  RepClrDlg_OnInitDialog);
      HANDLE_MSG (hWnd, WM_HSCROLL,     RepClrDlg_OnHScroll);
      HANDLE_MSG (hWnd, WM_PAINT,       RepClrDlg_OnPaint);
      HANDLE_MSG (hWnd, WM_TIMER,       RepClrDlg_OnTimer);
      HANDLE_MSG (hWnd, WM_LBUTTONDOWN, RepClrDlg_OnLButtonDown);
      HANDLE_MSG (hWnd, WM_LBUTTONUP,   RepClrDlg_OnLButtonUp);
      HANDLE_MSG (hWnd, WM_MOUSEMOVE,   RepClrDlg_OnMouseMove);

   case WM_USER_UPDATEVIEW:
      StatusProc.ProgressValue = 100;
      L_ApplyFilter(hWnd);
      break;
   }
   return FALSE;
}


static L_BOOL RepClrDlg_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
   LPREPDLGDATA pRepDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   L_INT        nRangeMax[] = { 300, 180,  100, 100 };
   L_INT        nRangeMin[] = { 1,  -180, -100, -100 };
   L_INT        nPosInit [] = { 100, 0,    0,   0   };
   L_INT        nSlider;
   RECT         rcImage, rcRect;
   L_INT        nBaseId;
   LPBUTTONST   pButtonSt;
   L_INT        nI;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pRepDlgData = (LPREPDLGDATA)lParam;
   hGlobalWnd  = hWnd;
   MoveDialogToMiddle(hWnd);
   
   SetWindowLong(hWnd, GWL_USERDATA, (LONG)pRepDlgData);

   //MEMDISK...//
   GetClientRect(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &rcImage);
   MemorizeAndCopyBitmap (hWndParent, &pRepDlgData->Bitmap);
   L_CopyBitmap(&pRepDlgData->pSelecSrc, &pData->LeadBitmap, sizeof(BITMAPHANDLE));
   FitImageToWindow(rcImage, &pData->LeadBitmap, &rcRect);
   L_SizeBitmap(&pRepDlgData->pSelecSrc, rcRect.right - rcRect.left, rcRect.bottom - rcRect.top, SIZE_NORMAL);

   Progress_SetRange(StatusProc.ProgWnd, 0, 100);
   Progress_SetPos(StatusProc.ProgWnd, 0);

   StatusProc.bProgress     = TRUE;
   StatusProc.bInvalidate   = FALSE;
   StatusProc.bEnd          = FALSE;
   StatusProc.DlgWnd        = hWnd;
   StatusProc.ProgressValue = 100;
   StatusProc.ProgWnd       = GetDlgItem(hWnd, IDC_REP_PROG);
   
   pRepDlgData->nHue        = 0;
   pRepDlgData->nSat        = 0;
   pRepDlgData->nVal        = 0;
   pRepDlgData->bPushed     = TRUE;
   pRepDlgData->bSel        = TRUE;

   pRepDlgData->nSlideNum   = 4;
   pRepDlgData->nSldBaseID  = IDC_REP_FUZ_SLD;
   pRepDlgData->nEdtBaseID  = IDC_REP_FUZ_EDT;

   Button_SetCheck(GetDlgItem(hWnd, IDC_REP_SEL_RAD), TRUE);

   nBaseId = IDC_REP_CLR_1;
   pRepDlgData->nSleIndex = 0;

   for(nI = 0; nI < 15; nI++)
   {
      pButtonSt = (LPBUTTONST) malloc (sizeof(BUTTONST));
      memset (pButtonSt, 0, sizeof(BUTTONST));

      pButtonSt->uFuzziness = 100;
      if(nI == 0)
      {
         pButtonSt->bUse   = TRUE;
         pButtonSt->bSelec = TRUE;
      }

      SetWindowLong (GetDlgItem(hWnd, nBaseId + nI), GWL_USERDATA, (LONG) pButtonSt);
      pButtonSt->OldWndProc = (WNDPROC) GetWindowLong(GetDlgItem(hWnd, nBaseId + nI), GWL_WNDPROC);
      SetWindowLong (GetDlgItem(hWnd, nBaseId + nI), GWL_WNDPROC, (LONG)ButtonProc);
   }
   
   for (nSlider = 0; nSlider < pRepDlgData->nSlideNum; nSlider++)
   {
      Trackbar_SetRange(GetDlgItem(hWnd, pRepDlgData->nSldBaseID + nSlider), TRUE, nRangeMin[nSlider], nRangeMax[nSlider]);
      SetDlgItemInt(hWnd, pRepDlgData->nEdtBaseID + nSlider, nPosInit[nSlider], TRUE);
      SetNumericEditBox(GetDlgItem(hWnd, pRepDlgData->nEdtBaseID + nSlider), nRangeMin[nSlider], nRangeMax[nSlider], 1, 0, FALSE);
   }

   pRepDlgData->hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_PICK));
   SendMessage(GetDlgItem(hWnd, IDC_REP_CLR_BTN), BM_SETIMAGE, IMAGE_ICON, (LPARAM)(HICON)pRepDlgData->hIcon);

   pRepDlgData->hMouseHook = SetWindowsHookEx(WH_MOUSE, Mouse, hInst, GetCurrentThreadId());
   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);
   L_GetSelectionImage(hWnd);
   return ( TRUE );
}

static L_BOOL RepClrDlg_OnLButtonDown (HWND hWnd, L_BOOL bDoubleClick, L_INT nX, L_INT nY, L_UINT uKeyFlags)
{
   POINT        ptPoint;
   RECT         rcRect;
   RECT         rcRgn;
   RECT         rcImage;
   LPREPDLGDATA pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   HWND         hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   L_INT        nNewXPos;
   L_INT        nNewYPos;
   HWND         ButtWnd;
   LPBUTTONST   pButtonst;
   L_INT        nBitsPixel;
   L_UCHAR      nRed;

   ptPoint.x = nX;
   ptPoint.y = nY;

   ClientToScreen(hWnd, &ptPoint);
   ScreenToClient(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &ptPoint);
   GetClientRect(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &rcRect);
   FitImageToWindow(rcRect, &pRepDlgData->Bitmap, &rcImage);
   L_GetBitmapRgnBounds(&pRepDlgData->Bitmap, NULL, &rcRgn);
   if (PtInRect(&rcImage, ptPoint) && !pRepDlgData->bSel)
   {
      ptPoint.x -= rcImage.left;
      ptPoint.y -= rcImage.top;
      PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_PICK));


      nNewXPos = (ptPoint.x * (rcRgn.right - rcRgn.left) / (rcImage.right - rcImage.left));
      nNewYPos = (ptPoint.y * (rcRgn.bottom - rcRgn.top) / (rcImage.bottom - rcImage.top));

      ButtWnd = GetDlgItem(hGlobalWnd, pRepDlgData->nSleIndex + IDC_REP_CLR_1);
      pButtonst = (LPBUTTONST) GetWindowLong (ButtWnd, GWL_USERDATA);

      pButtonst->Color = L_GetPixelColor(&pRepDlgData->Bitmap, nNewYPos, nNewXPos);

      nBitsPixel = GetProcPixel(&pRepDlgData->Bitmap);

      if(nBitsPixel == 16)
      {
         if(pRepDlgData->Bitmap.BitsPerPixel == 16)
         {
            nRed = (L_UCHAR)((pButtonst->Color & 0x00FFFF) >> 8);
         }
         else
         {
            nRed = (L_UCHAR)(((pButtonst->Color & 0x00FFF0) >> 4) >> 4);
         }
         pButtonst->Color = ((L_UINT32)(((L_UCHAR)(nRed)|((L_UINT16)(nRed)<<8))|(((L_UINT32)(L_UCHAR)(nRed))<<16)));
      }
      Paint_Button(ButtWnd, FALSE);
      L_ApplyFilter(hWnd);
   }
   return TRUE;
}

static L_BOOL RepClrDlg_OnMouseMove (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags)
{
   RECT         rcRect;
   POINT        ptPoint;
   RECT         rcImage;
   LPREPDLGDATA pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   HWND         hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);

   ptPoint.x = nX;
   ptPoint.y = nY;

   ClientToScreen(hWnd, &ptPoint);
   ScreenToClient(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &ptPoint);
   GetClientRect(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &rcRect);
   FitImageToWindow(rcRect, &pRepDlgData->Bitmap, &rcImage);

   if (PtInRect(&rcImage, ptPoint) && !pRepDlgData->bSel)
   {
      PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_PICK));
   }
   return TRUE;
}

static L_BOOL RepClrDlg_OnLButtonUp (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags)
{
   RECT         rcRect;
   POINT        ptPoint;
   RECT         rcImage;
   LPREPDLGDATA pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   HWND         hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);

   ptPoint.x = nX;
   ptPoint.y = nY;

   ClientToScreen(hWnd, &ptPoint);
   ScreenToClient(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &ptPoint);
   GetClientRect(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &rcRect);
   FitImageToWindow(rcRect, &pRepDlgData->Bitmap, &rcImage);

   if (PtInRect(&rcImage, ptPoint) && !pRepDlgData->bSel)
   {
      PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_PICK));
   }

   return TRUE;
}

static L_BOOL RepClrDlg_OnPaint (HWND hWnd)
{
   RECT           rcRect;
   HDC            hDC;
   PAINTSTRUCT    ps;
   HPALETTE       hPalette, hSavedPalette;
   RECT           rcImage;
   pBITMAPHANDLE  pBitmap;
   LPREPDLGDATA   pRepDlgData;
   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   
   if(pRepDlgData->bSel)
      pBitmap = &pRepDlgData->pSelection;
   else
      pBitmap = &pRepDlgData->Bitmap;

   hDC = BeginPaint(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &ps);

   GetClientRect(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &rcImage);

   hPalette = L_CreatePaintPalette(hDC, pBitmap);
   hSavedPalette = SelectPalette(hDC, hPalette, TRUE);
   RealizePalette(hDC);
   FillRect(hDC, &rcImage, (HBRUSH) COLOR_WINDOW);
   FitImageToWindow(rcImage, &pRepDlgData->Bitmap, &rcRect);
   L_PaintDC(hDC, pBitmap, NULL, NULL, &rcRect, &ps.rcPaint, SRCCOPY);

   hPalette = SelectPalette(hDC, hSavedPalette, TRUE);

   DeletePalette(hPalette);

   EndPaint(GetDlgItem(hWnd, IDC_REP_SEL_TXT), &ps);

   return FALSE;
}

static L_VOID RepClrDlg_OnTimer (HWND hWnd, L_INT nID)
{
   Dialog_Timer(nID);
}

static LRESULT CALLBACK Mouse(L_INT nCode, WPARAM wParam, LPARAM lParam) 
{
   LPREPDLGDATA      pRepDlgData;
   LPMOUSEHOOKSTRUCT pMouseHook;
   HWND              hWndParent;
   pCHILDDATA        pData;
   RECT              rcRect;
   POINT             TmpPoint;
   HWND              ButtWnd;
   LPBUTTONST        pButtonst;
   L_INT             nBitsPixel;
   L_UCHAR           nRed;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hGlobalWnd, GWL_USERDATA);
   pMouseHook  = (LPMOUSEHOOKSTRUCT)lParam;

   GetWindowRect(hGlobalWnd, &rcRect);
   if (PtInRect(&rcRect, pMouseHook->pt))
      return 0;

   switch(LOWORD(wParam))
   {
   case WM_NCMOUSEMOVE:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_PICK));
      ScreenToClient(hWndParent, &pMouseHook->pt);
      GetClientRect(hGlobalWnd, &rcRect);
      if (!PtInRect(&rcRect, pMouseHook->pt))
         SendMessage((hWndParent), WM_MOUSEMOVE, wParam, MAKELPARAM((pMouseHook->pt.x), (pMouseHook->pt.y)));
      break;

   case WM_NCLBUTTONDOWN:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      if (pRepDlgData->bPushed)
      {
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_PICK);
         ScreenToClient(hWndParent, &pMouseHook->pt);
         GetClientRect(hWndParent, &rcRect);
         if (PtInRect(&pData->rcView, pMouseHook->pt))
         {
            if (L_BitmapHasRgn(&pData->LeadBitmap))
            {
               L_GetBitmapRgnBounds(&pData->LeadBitmap, NULL, &rcRect);
               TmpPoint.x = pMouseHook->pt.x + pData->nHScrollPos;
               TmpPoint.y = pMouseHook->pt.y + pData->nVScrollPos;
               if (!PtInRect(&rcRect, TmpPoint))
                  return CallNextHookEx(pRepDlgData->hMouseHook , nCode, wParam, lParam); 
            }

            pData->ptCenter.x = pMouseHook->pt.x + pData->nHScrollPos;
            pData->ptCenter.y = pMouseHook->pt.y + pData->nVScrollPos;
            
            ButtWnd = GetDlgItem(hGlobalWnd, pRepDlgData->nSleIndex + IDC_REP_CLR_1);
            pButtonst = (LPBUTTONST) GetWindowLong (ButtWnd, GWL_USERDATA);

            pButtonst->Color = L_GetPixelColor(&pData->LeadBitmap, pData->ptCenter.y, pData->ptCenter.x);

            nBitsPixel = GetProcPixel(&pData->LeadBitmap);

            if(nBitsPixel == 16)
            {
               if(pData->LeadBitmap.BitsPerPixel == 16)
               {
                  nRed = (L_UCHAR)((pButtonst->Color & 0x00FFFF)/256);
               }
               else
               {
                  nRed = (L_UCHAR)(((pButtonst->Color & 0x00FFF0) >> 4)/16);
               }
               pButtonst->Color = ((L_UINT32)(((L_UCHAR)(nRed)|((L_UINT16)(nRed)<<8))|(((L_UINT32)(L_UCHAR)(nRed))<<16)));
            }

            Paint_Button(ButtWnd, FALSE);
            InvalidateRect(hWndParent, NULL, FALSE);
            L_ApplyFilter(hGlobalWnd);
            PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
         }
         else
         {
            PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_ARROW);
         }
      }
      else
      {
         PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_CURS11));
         ScreenToClient(hWndParent, &pMouseHook->pt);
         SendMessage(hWndParent, WM_LBUTTONDOWN, wParam, MAKELPARAM((pMouseHook->pt.x), (pMouseHook->pt.y)));
      }
      break;

   case WM_NCLBUTTONUP:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      if (pRepDlgData->bPushed)
      {
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
      }
      else
      {
         PostMessage(hWndParent, WM_USER_CHANGECURSOR, (WPARAM)hInst, (LONG)MAKEINTRESOURCE(IDC_CURS11));
         ScreenToClient(hWndParent, &pMouseHook->pt);
         GetClientRect(hGlobalWnd, &rcRect);
         if (!PtInRect(&rcRect, pMouseHook->pt))
            SendMessage(hWndParent, WM_LBUTTONUP, wParam, MAKELPARAM((pMouseHook->pt.x), (pMouseHook->pt.y)));
      }
      break;
   }
   
   if (pRepDlgData)
   {
      if (LOWORD(wParam) >= WM_NCMOUSEMOVE && LOWORD(wParam) <= WM_NCMBUTTONDBLCLK)
         return TRUE;
      else
         return CallNextHookEx(pRepDlgData->hMouseHook , nCode, wParam, lParam); 
   }
   else
      return FALSE;
}

static L_BOOL RepClrDlg_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT codeNotify)
{
   LPREPDLGDATA pRepDlgData;
   HWND         hWndParent;
   L_INT        nRangeMax[] = { 300, 180, 100, 100 };
   L_INT        nRangeMin[] = { 1,  -180, -100, -100 };
   pCHILDDATA   pData;
   L_INT        nValue;
   L_INT        nIndex;
   HWND         hWndtemp;
   LPBUTTONST   pButtonst;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (nID >= pRepDlgData->nEdtBaseID && nID < pRepDlgData->nEdtBaseID + pRepDlgData->nSlideNum)
   {
      if(codeNotify == EN_CHANGE)
      {
         nValue = GetDlgItemInt(hWnd, nID, NULL, TRUE);
         nIndex = nID - pRepDlgData->nEdtBaseID;
         Trackbar_SetPos(GetDlgItem(hWnd, nID + pRepDlgData->nSlideNum), TRUE, nValue);

         switch (nIndex)
         {
         case 0:
            hWndtemp  = GetDlgItem(hWnd, pRepDlgData->nSleIndex + IDC_REP_CLR_1);
            pButtonst = (LPBUTTONST) GetWindowLong(hWndtemp, GWL_USERDATA);

            if(pButtonst->uFuzziness == (L_UINT)nValue)
               return TRUE;
            pButtonst->uFuzziness = nValue;
            break;

         case 1:
            if(pRepDlgData->nHue == nValue)
               return TRUE;
            pRepDlgData->nHue = nValue;
            break;

         case 2:
            if(pRepDlgData->nSat == nValue)
               return TRUE;
            pRepDlgData->nSat = nValue;
            break;

         case 3:
            if(pRepDlgData->nVal == nValue)
               return TRUE;
            pRepDlgData->nVal = nValue;
            break;
         }
         L_ApplyFilter(hWnd);
      }
   }
   
   switch (nID)
   {
   case IDC_REP_SEL_RAD:
      pRepDlgData->bSel = TRUE;
      InvalidateRect(hWnd, NULL, FALSE);
      break;

   case IDC_REP_IMG_RAD:
      pRepDlgData->bSel = FALSE;
      InvalidateRect(hWnd, NULL, FALSE);
      break;

   case IDCANCEL:
      StatusProc.bProgress = FALSE;
      StatusProc.bKillProgress = TRUE ;
      StatusProc.ProgressValue = 100 ;
      UnhookWindowsHookEx(pRepDlgData->hMouseHook);
      EndDialog(hWnd, FALSE);
      break;

   case IDOK:
      UnhookWindowsHookEx(pRepDlgData->hMouseHook);
      ShowStatusWindow(FALSE);
      StatusProc.bStillWork  = TRUE;
      StatusProc.bInvalidate = TRUE;
      StatusProc.bEnd = TRUE;
      EndDialog(hWnd, TRUE);
      break;
   }
   return TRUE;
}

static L_BOOL RepClrDlg_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   LPREPDLGDATA pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   SetDlgItemInt(hWnd,  GetDlgCtrlID(hWndCtl) - pRepDlgData->nSlideNum , Trackbar_GetPos(hWndCtl), TRUE);
   return TRUE;
}

L_VOID L_GetSelectionImage(HWND hWnd)
{
   pCHILDDATA     pData;
   L_INT          nRet = 0;
   HWND           hWndParent;
   LPREPDLGDATA   pRepDlgData;
   LPBUTTONST     pButtonst;
   COLORREPLACE   pColorReplace[15];
   L_UINT         ColorCount = 0;
   L_INT          nI;

   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);


   StatusProc.bProgress = FALSE;
   L_FreeBitmap(&pRepDlgData->pSelection);
   L_CopyBitmap(&pRepDlgData->pSelection, &pRepDlgData->pSelecSrc, sizeof(BITMAPHANDLE));

   for(nI = 0; nI < 15; nI++)
   {
      pButtonst = (LPBUTTONST) GetWindowLong (GetDlgItem(hWnd, IDC_REP_CLR_1 + nI), GWL_USERDATA);
      pColorReplace[0].uStructSize = sizeof(COLORREPLACE);
      if(pButtonst->bUse)
      {
         pColorReplace[ColorCount].crColor = pButtonst->Color;
         pColorReplace[ColorCount].uFuzziness = pButtonst->uFuzziness; 
         ColorCount++;
      }
   }

   nRet = L_ColorReplaceWeightsBitmap(&pRepDlgData->pSelection, pColorReplace, ColorCount);

   StatusProc.bProgress = TRUE;
   InvalidateRect(hWnd, NULL, FALSE);
}

L_VOID L_ApplyFilter(HWND hWnd)
{
   pCHILDDATA     pData;
   L_INT          nRet = 0;
   HWND           hWndParent;
   LPREPDLGDATA   pRepDlgData;
   LPBUTTONST     pButtonst;
   COLORREPLACE   pColorReplace[15];
   L_UINT         ColorCount = 0;
   L_INT          nI;

   L_GetSelectionImage(hWnd);
   if (100 != StatusProc.ProgressValue)
   {
      StatusProc.bKillProgress = TRUE ;
      return ;
   }
   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);

   FreeMemorizedBitmap (hWndParent);
   L_CopyBitmap(&pData->LeadBitmap, &pRepDlgData->Bitmap, sizeof(BITMAPHANDLE));

   for(nI = 0; nI < 15; nI++)
   {
      pButtonst = (LPBUTTONST) GetWindowLong (GetDlgItem(hWnd, IDC_REP_CLR_1 + nI), GWL_USERDATA);
      pColorReplace[0].uStructSize            = sizeof(COLORREPLACE);
      if(pButtonst->bUse)
      {
         pColorReplace[ColorCount].crColor    = pButtonst->Color;
         pColorReplace[ColorCount].uFuzziness = pButtonst->uFuzziness;
         ColorCount++;
      }
   }

   nRet = L_ColorReplaceBitmap(&pData->LeadBitmap,
                                pColorReplace,
                                ColorCount,
                                pRepDlgData->nHue * 100,
                                pRepDlgData->nSat * 10,
                                pRepDlgData->nVal * 10);

   if(nRet == SUCCESS)
   {
      InvalidateRect(hWndParent, NULL, FALSE);
      StatusProc.ProgressValue = 100;
      Progress_SetPos(StatusProc.ProgWnd , 0);
      if(StatusProc.bEnd)
      {
         StatusProc.bProgress = FALSE;
         StatusProc.bKillProgress = TRUE ;
      }
   }
}

L_VOID FILL_Active(HWND hWnd, L_BOOL bBegin)
{
   HDC         hDC;
   HBRUSH      hBrush;
   RECT        rcImage;
   PAINTSTRUCT ps;

   LPBUTTONST pButtonst;
   pButtonst = (LPBUTTONST) GetWindowLong (hWnd, GWL_USERDATA);

   GetClientRect(hWnd, &rcImage);
   if(bBegin)
      hDC = BeginPaint(hWnd, &ps);
   else
      hDC = GetDC(hWnd);

   hBrush   = CreateSolidBrush(pButtonst->Color);
   FillRect(hDC, &rcImage, (HBRUSH) (COLOR_WINDOW));
   rcImage.left   += 5;
   rcImage.top    += 5;
   rcImage.right  -= 5;
   rcImage.bottom -= 5;

   FillRect(hDC, &rcImage, hBrush);

   if(bBegin)
      EndPaint(hWnd, &ps);
   else
      ReleaseDC(hWnd, hDC);
   DeleteBrush(hBrush);
}

L_VOID FILL_NonActive(HWND hWnd, L_BOOL bBegin)
{
   HDC         hDC;
   RECT        rcImage;
   PAINTSTRUCT ps;
   LPBUTTONST  pButtonst;

   pButtonst = (LPBUTTONST) GetWindowLong (hWnd, GWL_USERDATA);

   GetClientRect(hWnd, &rcImage);
   if(bBegin)
      hDC = BeginPaint(hWnd, &ps);
   else
      hDC = GetDC(hWnd);

   FillRect(hDC, &rcImage, (HBRUSH) (COLOR_WINDOW));

   MoveToEx(hDC, rcImage.left, rcImage.top, NULL);
   LineTo(hDC, rcImage.right, rcImage.bottom);
   MoveToEx(hDC, rcImage.left, rcImage.bottom, NULL);
   LineTo(hDC, rcImage.right, rcImage.top);

   if(bBegin)
      EndPaint(hWnd, &ps);
   else
      ReleaseDC(hWnd, hDC);
}

L_VOID FILL_Sel(HWND hWnd, L_BOOL bBegin)
{
   HDC         hDC;
   RECT        rcImage;
   PAINTSTRUCT ps;
   LPBUTTONST  pButtonst;
   HPEN        hPen, hOldPen;

   pButtonst = (LPBUTTONST) GetWindowLong (hWnd, GWL_USERDATA);


   GetClientRect(hWnd, &rcImage);
   if(bBegin)
      hDC = BeginPaint(hWnd, &ps);
   else
      hDC = GetDC(hWnd);

   rcImage.left   += 1;
   rcImage.right  -= 1;
   rcImage.top    += 1;
   rcImage.bottom -= 1;

   hPen = CreatePen(PS_DASH, 1, RGB(0, 0, 255));
   hOldPen = SelectPen(hDC, hPen);
   MoveToEx(hDC, rcImage.left, rcImage.top, NULL);

   LineTo(hDC, rcImage.right, rcImage.top);
   LineTo(hDC, rcImage.right, rcImage.bottom);
   LineTo(hDC, rcImage.left, rcImage.bottom);
   LineTo(hDC, rcImage.left, rcImage.top);

   SelectPen(hDC, hOldPen);
   if(bBegin)
      EndPaint(hWnd, &ps);
   else
      ReleaseDC(hWnd, hDC);
   DeletePen(hPen);
}

L_VOID Paint_Button(HWND hWnd, L_BOOL bBegin)
{
   LPBUTTONST pButtonst;
   pButtonst = (LPBUTTONST) GetWindowLong (hWnd, GWL_USERDATA);

   if(pButtonst->bUse)
   {
      FILL_Active(hWnd, bBegin);
   }
   else
   {
      FILL_NonActive(hWnd, bBegin);
   }

   if(pButtonst->bSelec)
   {
      FILL_Sel(hWnd, FALSE);
   }
}

LRESULT CALLBACK ButtonProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   LPBUTTONST     pButtonst;
   LPREPDLGDATA   pRepDlgData;
   LPBUTTONST     pButtonstTemp;
   HWND           hWndParent;
   L_INT          nI;
   L_BOOL         bDoubleClick = FALSE;

   hWndParent  = GetParent(hWnd);
   pButtonst   = (LPBUTTONST)   GetWindowLong(hWnd, GWL_USERDATA);
   pRepDlgData = (LPREPDLGDATA) GetWindowLong(hWndParent, GWL_USERDATA);

   switch (uMessage)
   {
   case WM_PAINT:  
      Paint_Button(hWnd, TRUE);
      break;

   case WM_LBUTTONDBLCLK:

      bDoubleClick = TRUE;
      pButtonst->bUse = !pButtonst->bUse;
      if(!pButtonst->bUse)
      {
         L_BOOL   bUseOther = FALSE;
         for(nI = 0; nI < 15; nI++)
         {
            HWND hWndtemp   = GetDlgItem(hWndParent, nI + IDC_REP_CLR_1);
            pButtonstTemp   = (LPBUTTONST) GetWindowLong (hWndtemp, GWL_USERDATA);

            if(pButtonstTemp->bUse)
            {
               bUseOther = TRUE;
               if(pButtonst->bSelec)
               {
                  pButtonstTemp->bSelec = TRUE;
                  Trackbar_SetPos(GetDlgItem(hWndParent, IDC_REP_FUZ_SLD), TRUE, pButtonstTemp->uFuzziness);
                  SetDlgItemInt(hWndParent, IDC_REP_FUZ_EDT, pButtonst->uFuzziness, TRUE);
                  Paint_Button(hWndtemp, FALSE);
                  pRepDlgData->nSleIndex = nI;
               }
               break;
            }
         }

         if(!bUseOther)
         {
            pButtonst->bUse = !pButtonst->bUse;
            break;
         }
         pButtonst->bSelec = 0;
         Paint_Button(hWnd, FALSE);
         L_ApplyFilter(hWndParent);
         break;
      }

   case WM_LBUTTONDOWN:
      if(pButtonst->bUse)
      {
         HWND hWndtemp   = GetDlgItem(hWndParent, pRepDlgData->nSleIndex + IDC_REP_CLR_1);
         pButtonstTemp   = (LPBUTTONST) GetWindowLong(hWndtemp, GWL_USERDATA);
         pButtonstTemp->bSelec = FALSE;
         Paint_Button(hWndtemp, FALSE);
         pRepDlgData->nSleIndex = GetDlgCtrlID(hWnd) - IDC_REP_CLR_1;
         pButtonst->bSelec = TRUE;
         Trackbar_SetPos(GetDlgItem(hWndParent, IDC_REP_FUZ_SLD), TRUE, pButtonst->uFuzziness);
         SetDlgItemInt(hWndParent, IDC_REP_FUZ_EDT, pButtonst->uFuzziness, TRUE);
         Paint_Button(hWnd, FALSE);

         if(bDoubleClick)
            L_ApplyFilter(hWndParent);
      }
      break;
   }
   return CallWindowProc (pButtonst->OldWndProc, hWnd, uMessage, wParam, lParam);
}

L_INT GetProcPixel(pBITMAPHANDLE pBitmap)
{
   if(pBitmap->BitsPerPixel >= 48)
      return 48;

   if(pBitmap->BitsPerPixel <= 8 && L_IsGrayScaleBitmap(pBitmap))
      return 8;

   if((pBitmap->BitsPerPixel == 16 || pBitmap->BitsPerPixel == 12) && (ISGRAY(pBitmap) & L_IsGrayScaleBitmap(pBitmap)))
      return 16;

   return 24;
}