#include "ImgPF.h"

static L_BOOL AddFreHndNois_OnInitDialog  (HWND, HWND, LPARAM);
static L_BOOL AddFreHndNois_OnPaint       (HWND);
static L_VOID AddFreHndNois_OnCommand     (HWND, L_INT , HWND  , L_UINT);
static L_VOID AddFreHndNois_OnHScroll     (HWND, HWND  , L_UINT, L_INT);
static L_BOOL AddFreHndNois_OnMouseMove   (HWND, L_INT , L_INT , L_UINT);
static L_BOOL AddFreHndNois_OnMouseUp     (HWND, L_INT , L_INT , L_UINT);
static L_BOOL AddFreHndNois_OnMouseDown   (HWND, L_BOOL, L_INT , L_INT, L_UINT);
static L_VOID AddFreHndNois_OnTimer       (HWND hWnd, L_INT nID);

static L_VOID L_ApplyFilter               (HWND);
static L_BOOL ChangeptUserPoints          (L_INT,   L_INT,         LPFREHNDNOISDLGDATA);
static L_VOID DeleteptUserPoint           (L_INT,   L_INT,         LPFREHNDNOISDLGDATA);
static L_VOID GetHandWavBuf               (HWND,                   LPFREHNDNOISDLGDATA);
static L_VOID AddPoint                    (L_INT,   L_INT,         LPFREHNDNOISDLGDATA);
static L_VOID InitptUserPoint             (HWND,                   LPFREHNDNOISDLGDATA);
static L_VOID PointTrans                  (LPPOINT,                LPFREHNDNOISDLGDATA);
static L_VOID RotatePoint                 (LPPOINT, POINT, L_BOOL, LPFREHNDNOISDLGDATA);
static L_VOID RotateBuffer                (LPPOINT, L_INT, POINT,  LPFREHNDNOISDLGDATA);
static L_VOID EnableDlgItems              (HWND,    L_UINT);

L_BOOL CALLBACK AddFreHndNoisDlgProc(HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG(hWnd, WM_INITDIALOG , AddFreHndNois_OnInitDialog);
      HANDLE_MSG(hWnd, WM_PAINT      , AddFreHndNois_OnPaint);
      HANDLE_MSG(hWnd, WM_COMMAND    , AddFreHndNois_OnCommand);
      HANDLE_MSG(hWnd, WM_HSCROLL    , AddFreHndNois_OnHScroll);
      HANDLE_MSG(hWnd, WM_MOUSEMOVE  , AddFreHndNois_OnMouseMove);
      HANDLE_MSG(hWnd, WM_LBUTTONUP  , AddFreHndNois_OnMouseUp);
      HANDLE_MSG(hWnd, WM_LBUTTONDOWN, AddFreHndNois_OnMouseDown);
      HANDLE_MSG(hWnd, WM_TIMER      , AddFreHndNois_OnTimer);

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

   return FALSE;
}

static L_BOOL AddFreHndNois_OnInitDialog(HWND hWnd, HWND hWndFocus, LPARAM Data)
{
   HWND                 hWndParent;
   pCHILDDATA           pData;
   LPFREHNDNOISDLGDATA  pAddFreHndNoisData;
   L_INT                nIndex;
   L_INT                nRangeMax[] = {100, 100, 100, 10000,  18000};
   L_INT                nRangeMin[] = {  0,   0,   0,     1, -18000};
   L_INT                nPosInit[]  = { 50,  50,  50,  1000,      0};
   L_INT                cxClient, cyClient;
   RECT                 ClientRect;
   
   hWndParent         = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData              = LOCKCHILDDATA(hWndParent);
   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA)(Data);
   MoveDialogToMiddle(hWnd);

   SetWindowLong(hWnd, GWL_USERDATA, (LONG)pAddFreHndNoisData);
   MemorizeAndCopyBitmap (hWndParent, &pAddFreHndNoisData->LeadBitmap);

   GetClientRect(GetDlgItem(hWnd, IDC_HNOIS_SHPDRW_TXT), &ClientRect);
   cxClient   = ClientRect.right - ClientRect.left;
   cyClient   = ClientRect.bottom - ClientRect.top;
   pAddFreHndNoisData->nRectWidth = (L_INT)(cxClient/sqrt(2.0));  

   pAddFreHndNoisData->rcWndRect.left   = (cxClient - pAddFreHndNoisData->nRectWidth)/2;
   pAddFreHndNoisData->rcWndRect.top    = (cyClient - pAddFreHndNoisData->nRectWidth)/2;
   pAddFreHndNoisData->rcWndRect.right  = pAddFreHndNoisData->nRectWidth + (cxClient - pAddFreHndNoisData->nRectWidth)/2;
   pAddFreHndNoisData->rcWndRect.bottom = pAddFreHndNoisData->nRectWidth + (cyClient - pAddFreHndNoisData->nRectWidth)/2;

   cxClient = pAddFreHndNoisData->rcWndRect.right  - pAddFreHndNoisData->rcWndRect.left + 1;
   cyClient = pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top  + 1;

   pAddFreHndNoisData->pCrvelm = (L_INT L_FAR *)malloc(cxClient * sizeof(L_INT));
   pAddFreHndNoisData->pBuf    = (L_INT L_FAR *)malloc(cxClient * sizeof(L_INT));
   pAddFreHndNoisData->nUserPntCnt= 2;
   
   InitptUserPoint(hWnd, pAddFreHndNoisData);   
   GetHandWavBuf(hWnd, pAddFreHndNoisData);

   pAddFreHndNoisData->pCrvPnt = (LPPOINT)malloc(cyClient * sizeof(POINT));
   pAddFreHndNoisData->uRamp      = nPosInit[0];
   pAddFreHndNoisData->uGamp      = nPosInit[1];
   pAddFreHndNoisData->uBamp      = nPosInit[2];
   pAddFreHndNoisData->uFreq      = nPosInit[3];
   pAddFreHndNoisData->nAngl      = nPosInit[4];  
   pAddFreHndNoisData->nSlideNum  = 5;
   pAddFreHndNoisData->nEdtBaseID = IDC_HNOIS_RAMP_EDT;
   pAddFreHndNoisData->nSldBaseID = IDC_HNOIS_RAMP_SLD;
   pAddFreHndNoisData->nOper      = FL_ADD;
   pAddFreHndNoisData->nShap      = FL_UNIDIRECTION;
   pAddFreHndNoisData->uFlag      = 0;
   
   StatusProc.bProgress     = TRUE;
   StatusProc.bInvalidate   = FALSE;
   StatusProc.bKillProgress = FALSE;
   StatusProc.bEnd          = FALSE;
   StatusProc.DlgWnd        = hWnd;
   StatusProc.ProgressValue = 100;
   StatusProc.ProgWnd       = GetDlgItem(hWnd, IDC_HNOIS_PROG);

   ComboBox_AddString(GetDlgItem(hWnd, IDC_HNOIS_SHP_COM), TEXT("Curve"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_HNOIS_SHP_COM), TEXT("Line"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_HNOIS_OPR_COM), TEXT("ADD"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_HNOIS_OPR_COM), TEXT("MUL"));
   ComboBox_SetCurSel(GetDlgItem(hWnd, IDC_HNOIS_SHP_COM), 0);
   ComboBox_SetCurSel(GetDlgItem(hWnd, IDC_HNOIS_OPR_COM), 0);

   Progress_SetRange(GetDlgItem(hWnd, IDC_HNOIS_PROG), 1, 100);
   Progress_SetPos  (GetDlgItem(hWnd, IDC_HNOIS_PROG), 1);
   
   for(nIndex = 0; nIndex < pAddFreHndNoisData->nSlideNum; nIndex++)
   {   
     Trackbar_SetTheRange(GetDlgItem(hWnd, pAddFreHndNoisData->nSldBaseID + nIndex), TRUE, nRangeMin[nIndex], nRangeMax[nIndex]);
     SetNumericEditBox(GetDlgItem(hWnd, pAddFreHndNoisData->nEdtBaseID + nIndex), nRangeMin[nIndex], nRangeMax[nIndex],1, 0, FALSE);
     SetDlgItemInt(hWnd, pAddFreHndNoisData->nEdtBaseID + nIndex, nPosInit[nIndex], TRUE);
   }

   if(L_IsGrayScaleBitmap(&pAddFreHndNoisData->LeadBitmap))
      EnableDlgItems(hWnd , FL_MUL);

   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);
   ShowWindow(hWnd, SW_SHOW);
   UpdateWindow(hWnd);

   return TRUE;
}

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

static L_BOOL AddFreHndNois_OnPaint(HWND hWnd)
{ 
   LPFREHNDNOISDLGDATA  pAddFreHndNoisData;
   PAINTSTRUCT          ps;
   HDC                  hdc, hdcMemo;
   RECT                 Rect, ClntRect;
   L_INT                cxClient, cyClient;
   HBITMAP              hBitmap;
   HPEN                 hPen;
   HPEN                 hOldPen;
   HBRUSH               hOldBrush;
   HBRUSH               hbrush;
   L_INT                nCount, nBufCnt;
   L_INT                nDivCnt;
   POINT                ptCenter, pTmp;
   L_INT                x1, y1, x2, y2;
   LPPOINT              pPntBuf;

   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_HNOIS_SHPDRW_TXT), &ClntRect);
   
   Rect = pAddFreHndNoisData->rcWndRect;
   cxClient = Rect.right  - Rect.left;
   cyClient = Rect.bottom - Rect.top;
   nDivCnt  = 6;
   
   pPntBuf = (LPPOINT)malloc((cxClient + 1) * sizeof(POINT));
   ptCenter.x = cxClient/2 + Rect.left;
   ptCenter.y = cyClient/2 + Rect.top;

   hdc = BeginPaint(GetDlgItem(hWnd, IDC_HNOIS_SHPDRW_TXT), &ps);

   hBitmap = CreateCompatibleBitmap(hdc, ClntRect.right - ClntRect.left, 
                                         ClntRect.bottom - ClntRect.top);
   hdcMemo = CreateCompatibleDC(hdc);
   
   SelectObject(hdcMemo, hBitmap);
   FillRect(hdcMemo, &ClntRect, (HBRUSH) (COLOR_WINDOW + 2));
   
   hbrush = CreateSolidBrush(RGB(0, 0, 0));
   SelectObject(hdcMemo, hbrush);
   
   hPen = CreatePen(PS_SOLID, 0, RGB(150, 0, 0));
   SelectObject(hdcMemo, hPen);

   Ellipse(hdcMemo, 0, 0, ClntRect.right - ClntRect.left, ClntRect.bottom - ClntRect.top);

   for(nCount=0 ; nCount <= nDivCnt; nCount++)
   {
      x1 = Rect.left;
      y1 = nCount * (cyClient)/nDivCnt + Rect.top;

      x2 = (cxClient) + Rect.left;
      y2 = nCount * (cyClient)/nDivCnt + Rect.top;

      for(nBufCnt = 0; nBufCnt <= cxClient; nBufCnt++)
      {
         pPntBuf[nBufCnt].y = (L_INT)(((((L_DOUBLE)y2 - y1)/(x2 - x1)) * (nBufCnt - x1)) + y1);
         pPntBuf[nBufCnt].x = nBufCnt + Rect.left;
      }
      RotateBuffer(pPntBuf, cxClient + 1, ptCenter, pAddFreHndNoisData);
      Polyline(hdcMemo, pPntBuf, cxClient + 1);
   }


   for(nCount=0;nCount <= nDivCnt; nCount++)
   {
      x1 = nCount*(cxClient)/nDivCnt + Rect.left;
      y1 = Rect.top;

      x2 = nCount*(cxClient)/nDivCnt + Rect.left;
      y2 = cyClient + Rect.top;

      for(nBufCnt = 0; nBufCnt <= cxClient; nBufCnt++)
      {
         pPntBuf[nBufCnt].x = (L_INT)(((((L_DOUBLE)x2 - x1)/(y2 - y1)) * (nBufCnt - y1)) + x1);
         pPntBuf[nBufCnt].y = nBufCnt + Rect.top;
      }
      RotateBuffer(pPntBuf, cxClient + 1, ptCenter, pAddFreHndNoisData);
      Polyline(hdcMemo, pPntBuf, cxClient + 1);
   }
   hbrush = CreateSolidBrush(RGB(255, 255, 0));
   hOldBrush = SelectObject(hdcMemo, hbrush);
   
   for(nCount=0;nCount<(L_INT) pAddFreHndNoisData->nUserPntCnt;nCount++)
   {
      pTmp.x = pAddFreHndNoisData->ptUserPoint[nCount].x + Rect.left;
      pTmp.y = pAddFreHndNoisData->ptUserPoint[nCount].y + Rect.top;
      RotatePoint(&pTmp, ptCenter, FALSE, pAddFreHndNoisData);
      Ellipse(hdcMemo,  pTmp.x - 3, 
                        pTmp.y - 3, 
                        pTmp.x + 3, 
                        pTmp.y + 3);
   }

   hPen = CreatePen(PS_SOLID, 0, RGB(100, 255, 130));
   hOldPen = SelectObject(hdcMemo, hPen);

   for(nCount = 0; nCount <= cxClient; nCount++)
   {
       pAddFreHndNoisData->pCrvPnt[nCount].x = nCount + Rect.left;
       pAddFreHndNoisData->pCrvPnt[nCount].y = (L_INT) (pAddFreHndNoisData->pCrvelm[nCount]) + Rect.left;
   }
   RotateBuffer(pAddFreHndNoisData->pCrvPnt, cxClient + 1, ptCenter, pAddFreHndNoisData);
   Polyline(hdcMemo, pAddFreHndNoisData->pCrvPnt, cxClient + 1);

   StretchBlt(hdc, 0, 0, ClntRect.right - ClntRect.left, ClntRect.bottom - ClntRect.top, hdcMemo, 
      0, 0, ClntRect.right - ClntRect.left, ClntRect.bottom, SRCCOPY);
   DeleteDC    (hdcMemo);
   DeleteBitmap(hBitmap);
   DeletePen   (hPen);
   DeleteBrush (hbrush);
   DeleteBrush (hOldBrush);
   DeletePen   (hOldPen);
   EndPaint(GetDlgItem(hWnd, IDC_HNOIS_SHPDRW_TXT), &ps);
   
   if(pPntBuf)
      free(pPntBuf);
   return FALSE;
}

static L_VOID AddFreHndNois_OnCommand(HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify)
{
   HWND                 hWndParent;
   LPFREHNDNOISDLGDATA  pAddFreHndNoisData;
   pCHILDDATA           pData;
   L_INT                nCurSel, nValue, nIndex;
   L_INT                nRangeMin[] = {0, 0, 0, 1, -18000};
   L_INT                nRangeMax[] = {100, 100, 100, 10000, 18000};
   L_BOOL               Signed[]    ={FALSE, FALSE, FALSE, FALSE, TRUE };

   hWndParent         = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData              = (pCHILDDATA)GetWindowLong(hWndParent, GWL_USERDATA);
   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA)GetWindowLong(hWnd, GWL_USERDATA);
   
   switch(nID)
   {
   case IDOK:
      ShowStatusWindow(FALSE);
      StatusProc.bStillWork  = TRUE;
      StatusProc.bInvalidate = TRUE;
      StatusProc.bEnd = TRUE;
      EndDialog(hWnd, TRUE);
      break;

   case IDCANCEL:
      StatusProc.bProgress     = FALSE;
      StatusProc.bKillProgress = TRUE ;
      StatusProc.ProgressValue = 100 ;

      if(pAddFreHndNoisData->pCrvelm)
      {
         free(pAddFreHndNoisData->pCrvelm);
         pAddFreHndNoisData->pCrvelm = NULL;

      }
      if(pAddFreHndNoisData->pBuf)
      {
         free(pAddFreHndNoisData->pBuf);
         pAddFreHndNoisData->pBuf = NULL;

      }
      EndDialog(hWnd, FALSE);
      break;

   case IDC_HNOIS_SHP_COM:
      if(uCodeNotify == CBN_SELCHANGE)
      {
        nCurSel = ComboBox_GetCurSel(hWndCtl);
        if((1<<(nCurSel + 8)) == pAddFreHndNoisData->nShap)
           return;

        pAddFreHndNoisData->uFlag = nCurSel;
        pAddFreHndNoisData->nShap = 1<<(nCurSel + 8);
        GetHandWavBuf(hWnd,  pAddFreHndNoisData);
        InvalidateRect(hWnd, NULL, FALSE);
        InvalidateRect(hWndCtl, NULL, FALSE);
        L_ApplyFilter (hWnd);
      }
      break;
      
   case IDC_HNOIS_OPR_COM:
      if(uCodeNotify == CBN_SELCHANGE)
      {
        nCurSel = ComboBox_GetCurSel(hWndCtl);
        if((1<<(nCurSel + 6)) == pAddFreHndNoisData->nOper)
           return;

        pAddFreHndNoisData->nOper = 1<<(nCurSel + 6);
        if(L_IsGrayScaleBitmap(&pAddFreHndNoisData->LeadBitmap))
        {
           EnableDlgItems(hWnd , FL_MUL);
        }  
        else
           EnableDlgItems(hWnd , pAddFreHndNoisData->nOper);

        InvalidateRect(hWndCtl, NULL, FALSE);
        L_ApplyFilter (hWnd);
      }
      break;
   }

   if(nID >= (L_INT)pAddFreHndNoisData->nEdtBaseID && nID <(L_INT)(pAddFreHndNoisData->nEdtBaseID + pAddFreHndNoisData->nSlideNum))
   {
      if(uCodeNotify == EN_CHANGE)
      {
         nIndex = nID - pAddFreHndNoisData->nEdtBaseID;
         nValue = GetDlgItemInt(hWnd, nID, NULL, Signed[nIndex]);

         Trackbar_SetPos(GetDlgItem(hWnd, nID + pAddFreHndNoisData->nSlideNum), TRUE, nValue);

         switch(nIndex)
         {
         case 0:
            if(pAddFreHndNoisData->uRamp == (L_UINT)nValue)
               return;
            pAddFreHndNoisData->uRamp = (L_UINT)nValue;
            break;
         case 1:
            if(pAddFreHndNoisData->uGamp == (L_UINT)nValue)
               return;
            pAddFreHndNoisData->uGamp = (L_UINT)nValue;
            break;
         case 2:
            if(pAddFreHndNoisData->uBamp == (L_UINT)nValue)
               return;
            pAddFreHndNoisData->uBamp = (L_UINT)nValue;
            break;
         case 3:
            if(pAddFreHndNoisData->uFreq == (L_UINT)nValue)
               return;
            pAddFreHndNoisData->uFreq = (L_UINT)nValue;
            break;
         case 4:
            if(pAddFreHndNoisData->nAngl == nValue)
               return;
            pAddFreHndNoisData->nAngl = nValue;
            InvalidateRect(hWnd, NULL, FALSE);
            break;
         }
         L_ApplyFilter (hWnd);
      }
   }
}

static L_VOID AddFreHndNois_OnHScroll(HWND hWnd, HWND hWndCtl, L_UINT code, L_INT pos)
{
   LPFREHNDNOISDLGDATA pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   SetDlgItemInt(hWnd, GetDlgCtrlID(hWndCtl) - pAddFreHndNoisData->nSlideNum , Trackbar_GetPos(hWndCtl), TRUE);
}

static L_BOOL AddFreHndNois_OnMouseMove(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)
{
   POINT      TmpPoint;
   RECT       Rect;
   L_INT      nyPos;
   L_INT      cxClient;
   L_INT      cyClient;
   L_INT      nCount;
   POINT      ptCenter;
   L_BOOL     bCurs = FALSE;
   LPFREHNDNOISDLGDATA  pAddFreHndNoisData;
   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   
   Rect = pAddFreHndNoisData->rcWndRect;
   OffsetRect(&Rect, -1 * Rect.left, -1 * Rect.top);
   
   cxClient = pAddFreHndNoisData->rcWndRect.right  - pAddFreHndNoisData->rcWndRect.left;
   cyClient = pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top;

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

   TmpPoint.x = x;
   TmpPoint.y = y;

   ClientToScreen(hWnd, &TmpPoint);
   ScreenToClient( GetDlgItem(hWnd, IDC_HNOIS_SHPDRW_TXT), &TmpPoint);
   
   PointTrans(&TmpPoint, pAddFreHndNoisData);
   RotatePoint(&TmpPoint, ptCenter, TRUE, pAddFreHndNoisData);
   
   if (PtInRect(&Rect, TmpPoint))
   {
      nyPos = (L_INT) pAddFreHndNoisData->pCrvelm[TmpPoint.x];
      
      if(TmpPoint.y < nyPos + 30 && TmpPoint.y > nyPos - 30)
      {
         SetCursor(LoadCursor(NULL, IDC_CROSS));
      }

      for(nCount = 0; nCount <= (L_INT) pAddFreHndNoisData->nUserPntCnt; nCount++)
      {
         SetRect(&Rect,  pAddFreHndNoisData->ptUserPoint[nCount].x - 5, 
                         pAddFreHndNoisData->ptUserPoint[nCount].y - 30, 
                         pAddFreHndNoisData->ptUserPoint[nCount].x + 5, 
                         pAddFreHndNoisData->ptUserPoint[nCount].y + 30);
         if (PtInRect(&Rect, TmpPoint))
         {
            bCurs = TRUE;
            break;
         }
      }
      if(bCurs)
         SetCursor(LoadCursor(NULL, IDC_SIZEALL));

      if( pAddFreHndNoisData->bChange)
      {
         if(!ChangeptUserPoints(TmpPoint.x, TmpPoint.y, pAddFreHndNoisData))
            DeleteptUserPoint(TmpPoint.x, TmpPoint.y, pAddFreHndNoisData);
         GetHandWavBuf(hWnd,  pAddFreHndNoisData);
         InvalidateRect(hWnd, NULL, FALSE);
      }
      return FALSE;
   }
   return FALSE;
}

static L_BOOL AddFreHndNois_OnMouseUp(HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)
{
   LPFREHNDNOISDLGDATA  pAddFreHndNoisData;
   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   ReleaseCapture();
   if( pAddFreHndNoisData->bChange ||  pAddFreHndNoisData->bAdd || pAddFreHndNoisData->bDel)
   {
      SetCursor(LoadCursor(NULL, IDC_SIZEALL));
      pAddFreHndNoisData->bChange = FALSE;
      pAddFreHndNoisData->bAdd = FALSE;
      pAddFreHndNoisData->bDel = FALSE;
      L_ApplyFilter (hWnd);
   }
   return TRUE;
}

static L_BOOL AddFreHndNois_OnMouseDown(HWND hWnd, L_BOOL fDoubleClick, L_INT x, L_INT y, L_UINT keyFlags)
{
   LPFREHNDNOISDLGDATA pAddFreHndNoisData;
   POINT               TmpPoint;
   RECT                Rect;
   L_INT               nyPos;
   L_INT               cxClient;
   L_INT               cyClient;
   L_INT               nCount;
   POINT               ptCenter;
   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   Rect = pAddFreHndNoisData->rcWndRect;
   OffsetRect(&Rect, -1 * Rect.left, -1 * Rect.top);
   
   cxClient = pAddFreHndNoisData->rcWndRect.right  - pAddFreHndNoisData->rcWndRect.left;
   cyClient = pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top;

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

   TmpPoint.x = x;
   TmpPoint.y = y;

   ClientToScreen(hWnd, &TmpPoint);
   ScreenToClient( GetDlgItem(hWnd, IDC_HNOIS_SHPDRW_TXT), &TmpPoint);
   
   PointTrans(&TmpPoint, pAddFreHndNoisData);
   RotatePoint(&TmpPoint, ptCenter, TRUE, pAddFreHndNoisData);
   
   if (PtInRect(&Rect, TmpPoint))
   {
      nyPos = (L_INT) pAddFreHndNoisData->pCrvelm[TmpPoint.x];

      SetCapture(hWnd);
      if(TmpPoint.y < nyPos + 30 && TmpPoint.y > nyPos - 30)
      {
         SetCursor(LoadCursor(NULL, IDC_SIZEALL));
         for(nCount=0; nCount <= (L_INT) pAddFreHndNoisData->nUserPntCnt;nCount++)
         {
            SetRect(&Rect,  pAddFreHndNoisData->ptUserPoint[nCount].x - 5, 
                            pAddFreHndNoisData->ptUserPoint[nCount].y - 30, 
                            pAddFreHndNoisData->ptUserPoint[nCount].x + 5, 
                            pAddFreHndNoisData->ptUserPoint[nCount].y + 30);
            if (PtInRect(&Rect, TmpPoint))
            {
                pAddFreHndNoisData->bChange = TRUE;
                pAddFreHndNoisData->nPoint = nCount;
               if(TmpPoint.x <  pAddFreHndNoisData->ptUserPoint[0].x)
               {
                   pAddFreHndNoisData->nPoint= nCount;
               }
               if(TmpPoint.x >  pAddFreHndNoisData->ptUserPoint[ pAddFreHndNoisData->nUserPntCnt - 1].x)
                   pAddFreHndNoisData->nPoint=  pAddFreHndNoisData->nUserPntCnt - 1;

               if(!ChangeptUserPoints(TmpPoint.x, TmpPoint.y, pAddFreHndNoisData))
                  DeleteptUserPoint(TmpPoint.x, TmpPoint.y, pAddFreHndNoisData);
                  GetHandWavBuf(hWnd,  pAddFreHndNoisData);
                  InvalidateRect(hWnd, NULL, FALSE);
                  return TRUE;
            }
         }
          pAddFreHndNoisData->nUserPntCnt++;
         AddPoint(TmpPoint.x, TmpPoint.y,  pAddFreHndNoisData);
         GetHandWavBuf(hWnd,  pAddFreHndNoisData);
         InvalidateRect(hWnd, NULL, FALSE);
         return TRUE;
      }
   }
   return FALSE;
}

static L_VOID L_ApplyFilter (HWND hWnd)
{
   pCHILDDATA          pData;
   L_INT               nRet = 0;
   HWND                hWndParent;
   LPFREHNDNOISDLGDATA pAddFreHndNoisData;
   LIGHTPARAMS         LightParams;

   if ( 100 != StatusProc.ProgressValue )
   {
      StatusProc.bKillProgress = TRUE ;
      return ;
   }

   pAddFreHndNoisData = (LPFREHNDNOISDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   hWndParent         = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData              = (pCHILDDATA)GetWindowLong(hWndParent, GWL_USERDATA);

   FreeMemorizedBitmap (hWndParent); //MEMDISK//
   L_CopyBitmap(&pData->LeadBitmap, &pAddFreHndNoisData->LeadBitmap, sizeof(BITMAPHANDLE));

   LightParams.uStructSize = sizeof(LIGHTPARAMS);
   LightParams.uFreq       = pAddFreHndNoisData->uFreq;
   LightParams.uRAmp       = pAddFreHndNoisData->uRamp;
   LightParams.uGAmp       = pAddFreHndNoisData->uGamp;
   LightParams.uBAmp       = pAddFreHndNoisData->uBamp;
   LightParams.nAngle      = pAddFreHndNoisData->nAngl;
   LightParams.uFlags      = pAddFreHndNoisData->nOper | FL_FREEHAND;
   LightParams.uBuffCount  = pAddFreHndNoisData->rcWndRect.right - pAddFreHndNoisData->rcWndRect.left;
   LightParams.pBuff       = pAddFreHndNoisData->pBuf;

   nRet = L_FunctionalLightBitmap(&pData->LeadBitmap, &LightParams);

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

static L_VOID InitptUserPoint(HWND hWnd, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   pAddFreHndNoisData->bChange  = FALSE;
   pAddFreHndNoisData->bAdd     = FALSE;
   
   pAddFreHndNoisData->ptUserPoint[0].x = 0;
   pAddFreHndNoisData->ptUserPoint[0].y = (pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top)/2;
   pAddFreHndNoisData->ptUserPoint[1].x = (pAddFreHndNoisData->rcWndRect.right  - pAddFreHndNoisData->rcWndRect.left);
   pAddFreHndNoisData->ptUserPoint[1].y = (pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top)/2;
}

static L_VOID GetHandWavBuf(HWND hWnd, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   L_INT    cxClient;
   L_INT    cyClient;
   L_INT    nCount;
   L_INT    nPtCurveNo;

   
   cxClient= pAddFreHndNoisData->rcWndRect.right  - pAddFreHndNoisData->rcWndRect.left;
   cyClient= pAddFreHndNoisData->rcWndRect.bottom - pAddFreHndNoisData->rcWndRect.top;
   L_GetCurvePoints( pAddFreHndNoisData->pBuf, 
                    pAddFreHndNoisData->ptUserPoint, 
                    pAddFreHndNoisData->nUserPntCnt, 
                    &nPtCurveNo, 
                    pAddFreHndNoisData->uFlag);
   for(nCount = 0;nCount < nPtCurveNo;nCount++)
      {
          pAddFreHndNoisData->pBuf[nCount] = pAddFreHndNoisData->pBuf[nCount];
          pAddFreHndNoisData->pCrvelm[nCount] = pAddFreHndNoisData->pBuf[nCount]/1000;
          pAddFreHndNoisData->pBuf[nCount] = (cyClient/2) * 1000 - pAddFreHndNoisData->pBuf[nCount];
      }
}

L_VOID RotateBuffer(LPPOINT             pRotBuf, 
                    L_INT               uBufSize, 
                    POINT               ptCenter, 
                    LPFREHNDNOISDLGDATA  pAddFreHndNoisData)
{
   L_DOUBLE dcos, dsin, dAngle;
   POINT    nTmp;
   L_INT    nCount;
   
   dAngle = -1 * (pAddFreHndNoisData->nAngl /100.0 ) + 90.0;
   
   dcos = cos( dAngle  * 3.14 / 180.0);
   dsin = sin( dAngle * 3.14 / 180.0);
   for(nCount = 0; nCount < uBufSize; nCount++)
   {
      nTmp.x = pRotBuf[nCount].x;
      nTmp.y = pRotBuf[nCount].y;
      
      pRotBuf[nCount].x = (long)(dcos * (nTmp.x - ptCenter.x) - dsin * (nTmp.y - ptCenter.y) + ptCenter.x);
      pRotBuf[nCount].y = (long)(dsin * (nTmp.x - ptCenter.x) + dcos * (nTmp.y - ptCenter.y) + ptCenter.y);
   }
}

L_VOID RotatePoint(LPPOINT          pRotPoint, 
                   POINT            ptCenter, 
                   L_BOOL           bNegative, 
                   LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   L_DOUBLE dcos, dsin, dAngle;
   POINT    nTmp;

   nTmp.x = pRotPoint->x;
   nTmp.y = pRotPoint->y;

   if(bNegative)
      dAngle = (pAddFreHndNoisData->nAngl /100.0) - 90;
   else
      dAngle = -1 * (pAddFreHndNoisData->nAngl /100.0) + 90;
   
   dcos = cos( dAngle * 3.14 / 180.0);
   dsin = sin( dAngle * 3.14 / 180.0);
   pRotPoint->x = (long)(dcos * (nTmp.x - ptCenter.x) - dsin * (nTmp.y - ptCenter.y) + ptCenter.x);
   pRotPoint->y = (long)(dsin * (nTmp.x - ptCenter.x) + dcos * (nTmp.y - ptCenter.y) + ptCenter.y);
}

static L_VOID PointTrans(LPPOINT  TmpPoint, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   TmpPoint->x = TmpPoint->x - pAddFreHndNoisData->rcWndRect.left;
   TmpPoint->y = TmpPoint->y - pAddFreHndNoisData->rcWndRect.top;
}

static L_BOOL ChangeptUserPoints(L_INT x, L_INT y, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   if(pAddFreHndNoisData->nPoint == 0 || pAddFreHndNoisData->nPoint == (L_INT)pAddFreHndNoisData->nUserPntCnt - 1)
   {

      if(pAddFreHndNoisData->nPoint == (L_INT) pAddFreHndNoisData->nUserPntCnt-1 &&
         x <  pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nUserPntCnt - 2].x + 5)
         return TRUE;

      if(pAddFreHndNoisData->nPoint == 0 && x > pAddFreHndNoisData->ptUserPoint[1].x - 5)
         return TRUE;
       pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nPoint].y = y;
      return TRUE;
   }
   if(x <=  pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nPoint-1].x || x >=  pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nPoint+1].x)
      return FALSE;
   
    pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nPoint].x = x;
    pAddFreHndNoisData->ptUserPoint[pAddFreHndNoisData->nPoint].y = y;
   return TRUE;
}

static L_VOID DeleteptUserPoint(L_INT x, L_INT y, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   L_INT nCount;

   if (pAddFreHndNoisData->nPoint == 0 || pAddFreHndNoisData->nPoint == (L_INT) pAddFreHndNoisData->nUserPntCnt)
      return;
   pAddFreHndNoisData->bDel = TRUE;
   for(nCount = pAddFreHndNoisData->nPoint; nCount < (L_INT) pAddFreHndNoisData->nUserPntCnt; nCount++)
   {
       pAddFreHndNoisData->ptUserPoint[nCount].x =  pAddFreHndNoisData->ptUserPoint[nCount+1].x;
       pAddFreHndNoisData->ptUserPoint[nCount].y =  pAddFreHndNoisData->ptUserPoint[nCount+1].y;
   }
    pAddFreHndNoisData->bChange = FALSE;
    pAddFreHndNoisData->nUserPntCnt--;
}

static L_VOID AddPoint(L_INT x, L_INT y, LPFREHNDNOISDLGDATA pAddFreHndNoisData)
{
   L_INT nCount;
   L_INT nShift;

   for(nCount = 0;nCount < (L_INT) pAddFreHndNoisData->nUserPntCnt;nCount++)
   {
      if (x <  pAddFreHndNoisData->ptUserPoint[nCount].x)
         break;
   }

   for(nShift =  pAddFreHndNoisData->nUserPntCnt - 1;nShift > nCount;nShift--)
   {
       pAddFreHndNoisData->ptUserPoint[nShift].x = pAddFreHndNoisData->ptUserPoint[nShift-1].x;
       pAddFreHndNoisData->ptUserPoint[nShift].y = pAddFreHndNoisData->ptUserPoint[nShift-1].y;
   }

    pAddFreHndNoisData->ptUserPoint[nCount].x = x;
    pAddFreHndNoisData->ptUserPoint[nCount].y = y;
    pAddFreHndNoisData->nPoint                = nCount;  
    pAddFreHndNoisData->bChange               = TRUE;  
    pAddFreHndNoisData->bAdd                  = FALSE;  
}

static L_VOID EnableDlgItems(HWND hWnd, L_UINT uFlags)
{
   L_BOOL bVal;
   switch(uFlags)
   {
      case FL_ADD :
         bVal = TRUE;
         Static_SetText(GetDlgItem(hWnd, IDC_HNOIS_RAMP_TXT), TEXT("RAmplitude"));
         break;
      case FL_MUL :
         bVal = FALSE;
         Static_SetText(GetDlgItem(hWnd, IDC_HNOIS_RAMP_TXT), TEXT("Amplitude"));
         break;
   }

   EnableWindow(GetDlgItem(hWnd, IDC_HNOIS_GAMP_SLD),  bVal);
   EnableWindow(GetDlgItem(hWnd, IDC_HNOIS_BAMP_SLD),  bVal);
   EnableWindow(GetDlgItem(hWnd, IDC_HNOIS_GAMP_EDT),  bVal);
   EnableWindow(GetDlgItem(hWnd, IDC_HNOIS_BAMP_EDT),  bVal);
}