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

#include "ImgPF.h"

static L_BOOL LgtDlg_OnCommand       (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify);
static L_BOOL LgtDlg_OnHScroll       (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static L_BOOL LgtDlg_OnInitDialog    (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_BOOL LgtDlg_OnLButtonDown   (HWND hWnd, BOOL , L_INT, L_INT, L_UINT);
static L_BOOL LgtDlg_OnMouseMove     (HWND hWnd, L_INT nX, L_INT nY, L_UINT keyFlags);
static L_BOOL LgtDlg_OnLButtonUp     (HWND hWnd, L_INT, L_INT, UINT);
static L_BOOL LgtDlg_OnPaint         (HWND hWnd);
static L_VOID LgtDlg_OnTimer         (HWND hWnd, L_INT nID);
static L_VOID L_ApplyFilter          (HWND hWnd);
static L_VOID GetElpPnt              (HWND hWnd);
static L_VOID PaintEllips            (HWND hWnd);

#define LGTS_SPOTLIGHT 0x0000
#define LGTS_DIRELIGHT 0x0001

L_VOID RotatePoint(LPPOINT , POINT , LPLGTDLGDATA  , L_DOUBLE );
L_VOID RotateBuffer(LPPOINT       pRotBuf,
                    L_INT         uBufSize,
                    POINT         ptCenter,
                    LPLGTDLGDATA  pLgtDlgData,
                    L_DOUBLE      dAngle);


L_BOOL CALLBACK LightDlgProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG (hWnd, WM_COMMAND,    LgtDlg_OnCommand);
      HANDLE_MSG (hWnd, WM_INITDIALOG, LgtDlg_OnInitDialog);
      HANDLE_MSG (hWnd, WM_HSCROLL,    LgtDlg_OnHScroll);
      HANDLE_MSG (hWnd, WM_PAINT,      LgtDlg_OnPaint);
      HANDLE_MSG (hWnd, WM_LBUTTONDOWN,LgtDlg_OnLButtonDown);
      HANDLE_MSG (hWnd, WM_MOUSEMOVE,  LgtDlg_OnMouseMove);
      HANDLE_MSG (hWnd, WM_LBUTTONUP,  LgtDlg_OnLButtonUp); 
      HANDLE_MSG (hWnd, WM_TIMER,      LgtDlg_OnTimer);

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

L_VOID Init_Ellipes(HWND hWnd, LPLGTDLGDATA pLgtDlgData, L_INT nEllipse)
{
   RECT  rcClient;

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcClient);
   if(nEllipse == 0)
   {
      pLgtDlgData->LightInfo[nEllipse].ptCenter.x = (rcClient.right - rcClient.left)/2;
      pLgtDlgData->LightInfo[nEllipse].ptCenter.y = (rcClient.bottom - rcClient.top)/2;
      pLgtDlgData->LightInfo[nEllipse].uxSize    = 75;
      pLgtDlgData->LightInfo[nEllipse].uySize    = 30;
      
   }
   else
   {
      pLgtDlgData->LightInfo[nEllipse].ptCenter.x = (pLgtDlgData->LightInfo[nEllipse - 1].ptCenter.x + 10) % (rcClient.right - rcClient.left);
      pLgtDlgData->LightInfo[nEllipse].ptCenter.y = (pLgtDlgData->LightInfo[nEllipse - 1].ptCenter.y + 10) % (rcClient.bottom - rcClient.top);
      pLgtDlgData->LightInfo[nEllipse].uxSize    = pLgtDlgData->LightInfo[nEllipse - 1].uxSize;
      pLgtDlgData->LightInfo[nEllipse].uySize    = pLgtDlgData->LightInfo[nEllipse - 1].uySize;
   }

   pLgtDlgData->nPostionH[nEllipse][0] = 100;
   pLgtDlgData->nPostionH[nEllipse][1] = 100;
   pLgtDlgData->nPostionH[nEllipse][4] = 100;
   
   pLgtDlgData->LightInfo[nEllipse].uBright = 100;
   pLgtDlgData->LightInfo[nEllipse].uEdge        = 100;
   pLgtDlgData->LightInfo[nEllipse].uOpacity = 100;
   pLgtDlgData->LightInfo[nEllipse].crFill = RGB(255,255,255);

   pLgtDlgData->pEllipsPnts[nEllipse][0].x = pLgtDlgData->LightInfo[nEllipse].ptCenter.x - pLgtDlgData->LightInfo[nEllipse].uxSize;
   pLgtDlgData->pEllipsPnts[nEllipse][0].y = pLgtDlgData->LightInfo[nEllipse].ptCenter.y;

   pLgtDlgData->pEllipsPnts[nEllipse][1].x = pLgtDlgData->LightInfo[nEllipse].ptCenter.x + pLgtDlgData->LightInfo[nEllipse].uxSize;
   pLgtDlgData->pEllipsPnts[nEllipse][1].y = pLgtDlgData->LightInfo[nEllipse].ptCenter.y;

   pLgtDlgData->pEllipsPnts[nEllipse][2].x = pLgtDlgData->LightInfo[nEllipse].ptCenter.x;
   pLgtDlgData->pEllipsPnts[nEllipse][2].y = pLgtDlgData->LightInfo[nEllipse].ptCenter.y - pLgtDlgData->LightInfo[nEllipse].uySize;

   pLgtDlgData->pEllipsPnts[nEllipse][3].x = pLgtDlgData->LightInfo[nEllipse].ptCenter.x;
   pLgtDlgData->pEllipsPnts[nEllipse][3].y = pLgtDlgData->LightInfo[nEllipse].ptCenter.y + pLgtDlgData->LightInfo[nEllipse].uySize;

   pLgtDlgData->pEllipsPnts[nEllipse][4] = pLgtDlgData->LightInfo[nEllipse].ptCenter;

   pLgtDlgData->LightInfo[nEllipse].bUse = TRUE;
}

static L_BOOL LgtDlg_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   RECT         rcClient;
   L_INT        cxClient, cyClient;
   HICON        hIcon;
   L_INT        nI;
   L_INT        nSlider;
   L_INT        nRangeMax[] = {400, 100, 200, 400, 100};
   L_INT        nRangeMin[] = {0,   0,   0,   0,   0};
   L_INT        nPosInit[]  = {100, 100, 100, 100, 100};

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA)lParam;
   SetWindowLong(hWnd,GWL_USERDATA,(LONG)pLgtDlgData);
   MoveDialogToMiddle(hWnd);

   GetClientRect(GetDlgItem(hWnd, IDC_LGTS_DIS_TXT), &rcClient);
   cxClient = rcClient.right  - rcClient.left;
   cyClient = rcClient.bottom - rcClient.top;


   //MEMDISK...//
   MemorizeAndCopyBitmap (hWndParent, &pLgtDlgData->Bitmap);
   L_CopyBitmap(&pLgtDlgData->pTmpBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE));

   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_LGTS_PROG);

   
   for(nI = 0; nI < 8; nI++)
   {
      pLgtDlgData->LightInfo[nI].bUse = FALSE;
      pLgtDlgData->pNellipse[nI]  = (LPPOINT)malloc((L_INT)(hypot(cxClient, cyClient) + 1) * sizeof(POINT) * 4);
      pLgtDlgData->pPellipse[nI]  = (LPPOINT)malloc((L_INT)(hypot(cxClient, cyClient) + 1) * sizeof(POINT) * 4);
   }

   for(nI = 0; nI < 8; nI++)
   {
      memset(pLgtDlgData->nPostionH[nI], 0, 5 * sizeof(L_INT));
   }

   pLgtDlgData->nIndex         = 0;
   pLgtDlgData->uAmbient       = 100;
   pLgtDlgData->uBrightEllipes = 100;
   pLgtDlgData->bApply         = FALSE;
   pLgtDlgData->bEffect        = TRUE;
   pLgtDlgData->crAmbientClr   = RGB(255,255,255);
   pLgtDlgData->nSlideNum      = 5;
   pLgtDlgData->nSldBaseID     = IDC_LGTS_BRG_SLD;
   pLgtDlgData->nEdtBaseID     = IDC_LGTS_BRG_EDT;

   pLgtDlgData->nPostionH[0][2] = 100;
   pLgtDlgData->nPostionH[0][3] = 100;

   for(nI = 0; nI < 8; nI++)
   {
      pLgtDlgData->nPostionH[nI][0] = 100;
      pLgtDlgData->nPostionH[nI][1] = 100;
      pLgtDlgData->nPostionH[nI][4] = 100;
   }
   pLgtDlgData->nEllipesNo = 1;

   
   Init_Ellipes(hWnd, pLgtDlgData, 0);

   hIcon   = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ADD));
   SendMessage(GetDlgItem(hWnd, IDC_BRG_INS_BUT), BM_SETIMAGE, IMAGE_ICON, (LPARAM)(HICON)hIcon);

   hIcon   = LoadIcon(hInst, MAKEINTRESOURCE(IDI_SUB));
   SendMessage(GetDlgItem(hWnd, IDC_BRG_DEL_BUT), BM_SETIMAGE, IMAGE_ICON, (LPARAM)(HICON)hIcon);
   
   GetElpPnt(hWnd);

   for (nSlider = 0; nSlider < pLgtDlgData->nSlideNum; nSlider++)
   {
      Trackbar_SetRange(GetDlgItem(hWnd, pLgtDlgData->nSldBaseID + nSlider), TRUE, nRangeMin[nSlider], nRangeMax[nSlider]);
      SetDlgItemInt(hWnd, pLgtDlgData->nEdtBaseID + nSlider, nPosInit[nSlider], FALSE);
      SetNumericEditBox(GetDlgItem(hWnd, pLgtDlgData->nEdtBaseID + nSlider), nRangeMin[nSlider], nRangeMax[nSlider], 1, 0, FALSE);
   }
   
   EnableWindow(GetDlgItem(hWnd, IDC_BRG_DEL_BUT), FALSE);
   Button_SetCheck(GetDlgItem(hWnd, IDC_LGTS_SPT_RAD), TRUE);
   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);
   ShowWindow(hWnd, SW_SHOW);
   UpdateWindow(hWnd);
   L_ApplyFilter(hWnd);
   return ( TRUE );
}

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

static L_BOOL LgtDlg_OnPaint(HWND hWnd)
{
   HDC          hDC;
   PAINTSTRUCT  ps;
   RECT         rcRect;
   HBRUSH       hBrush;
   LPLGTDLGDATA pLgtDlgData;

   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_CLR_TXT), &rcRect);
   hDC = BeginPaint(GetDlgItem(hWnd, IDC_LGTS_CLR_TXT),&ps);
   hBrush = CreateSolidBrush(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].crFill);
   FillRect(hDC, &rcRect,hBrush);
   DeleteObject (hBrush);
   EndPaint(GetDlgItem(hWnd, IDC_LGTS_CLR_TXT), &ps);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_AMB_CLR_TXT), &rcRect);
   hDC = BeginPaint(GetDlgItem(hWnd, IDC_LGTS_AMB_CLR_TXT),&ps);
   hBrush = CreateSolidBrush(pLgtDlgData->crAmbientClr);
   FillRect(hDC, &rcRect,hBrush);
   DeleteObject (hBrush);
   EndPaint(GetDlgItem(hWnd, IDC_LGTS_AMB_CLR_TXT), &ps);

   PaintEllips(hWnd);
   return FALSE;
}

L_VOID DeleteEllipes(LPLGTDLGDATA pLgtDlgData)
{
   LIGHTINFOINT   LightInfo[8] = {0};
   L_INT          nPostionH[8][5];
   POINT          pEllipsPnts[8][5];
   L_UINT         nPointIndx[8];

   L_INT          nLightNo = 0;
   L_INT          nI;

   for(nI = 0; nI < 8; nI++)
   {
      if(pLgtDlgData->LightInfo[nI].bUse)
      {
         LightInfo[nLightNo] = pLgtDlgData->LightInfo[nI];
         memcpy(nPostionH[nLightNo] , pLgtDlgData->nPostionH[nI], 5 * sizeof(L_INT));
         memcpy(pEllipsPnts[nLightNo] , pLgtDlgData->pEllipsPnts[nI], 5 * sizeof(POINT));
         nPointIndx[nLightNo] = pLgtDlgData->nPointIndx[nI];
         nLightNo++;
      }
   }

   for(nI = 0; nI < 8; nI++)
   {
      pLgtDlgData->LightInfo[nI].bUse    = FALSE;
      pLgtDlgData->LightInfo[nI].crFill  = 0;
      pLgtDlgData->LightInfo[nI].nAngle  = 0;
      pLgtDlgData->LightInfo[nI].ptCenter.x = 0;
      pLgtDlgData->LightInfo[nI].ptCenter.y = 0;
      pLgtDlgData->LightInfo[nI].uEdge   = 0;
      pLgtDlgData->LightInfo[nI].uBright = 0;
      pLgtDlgData->LightInfo[nI].uFlag    = 0;
      pLgtDlgData->LightInfo[nI].uOpacity = 0;
      pLgtDlgData->LightInfo[nI].uxSize   = 0;
      pLgtDlgData->LightInfo[nI].uySize   = 0;
   }

   for(nI = 0; nI < nLightNo; nI++)
   {
      pLgtDlgData->LightInfo[nI] = LightInfo[nI];
      memcpy( pLgtDlgData->nPostionH[nI], nPostionH[nI], 5 * sizeof(L_INT));
      memcpy(pLgtDlgData->pEllipsPnts[nI], pEllipsPnts[nI], 5 * sizeof(POINT));
      pLgtDlgData->nPointIndx[nI] = nPointIndx[nI];
   }

   pLgtDlgData->nEllipesNo = nLightNo ;
   pLgtDlgData->nIndex     = nLightNo - 1;
}

static L_BOOL LgtDlg_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify)
{
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   L_INT        nRangeMax[] = {400, 100, 400, 200 ,100};
   L_INT        nRangeMin[] = {0,   0,   0,   0,   0};
   pCHILDDATA   pData;
   L_INT        nValue;
   L_INT        nIndex;
   COLORREF     crColor;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

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

         switch (nIndex)
         {
         case 0:
            if(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uBright == nValue)
               return TRUE;
            pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uBright = nValue;
            break;
         case 1:
            if(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uEdge == (L_UINT)nValue)
               return TRUE;
            pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uEdge = nValue;
            break;
         case 2:
            if(pLgtDlgData->uAmbient == (L_UINT)nValue)
               return TRUE;
            pLgtDlgData->uAmbient = nValue;
            break;
         case 3:
            if(pLgtDlgData->uBrightEllipes == (L_UINT)nValue)
               return TRUE;
            pLgtDlgData->uBrightEllipes = nValue;
            break;
         case 4:
            if(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uOpacity == (L_UINT)nValue)
               return TRUE;
            pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uOpacity = nValue;
            break;
         }
         L_ApplyFilter(hWnd);
      }
   }

   switch (nID)
   {
   case IDC_LGTS_CLR_BUT:
      crColor = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].crFill;
      pLgtDlgData->LightInfo[pLgtDlgData->nIndex].crFill = ShowColorDialog(hWnd, crColor);

      if (pLgtDlgData->LightInfo[pLgtDlgData->nIndex].crFill != crColor)
      {
         InvalidateRect(hWnd,NULL,FALSE);
         L_ApplyFilter(hWnd);
      }
      break;

   case IDC_LGTS_AMB_CLR_BUT:
      crColor = pLgtDlgData->crAmbientClr;
      pLgtDlgData->crAmbientClr = ShowColorDialog(hWnd, crColor);

      if (crColor != pLgtDlgData->crAmbientClr)
      {
         InvalidateRect(hWnd, NULL, FALSE);
         L_ApplyFilter(hWnd);
      }
      break;

   case IDC_BRG_INS_BUT:
      Init_Ellipes(hWnd, pLgtDlgData, pLgtDlgData->nEllipesNo);
      if(pLgtDlgData->nEllipesNo + 1 >= 5)
         EnableWindow(GetDlgItem(hWnd, IDC_BRG_INS_BUT), FALSE);
      EnableWindow(GetDlgItem(hWnd, IDC_BRG_DEL_BUT), TRUE);
      pLgtDlgData->nIndex = pLgtDlgData->nEllipesNo;
      pLgtDlgData->nEllipesNo++;

      pLgtDlgData->bEffect = FALSE;

      SetDlgItemInt(hWnd, IDC_LGTS_BRG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uBright, FALSE);
      SetDlgItemInt(hWnd, IDC_LGTS_EDG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uEdge, FALSE);
      SetDlgItemInt(hWnd, IDC_LGTS_OPC_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uOpacity, FALSE);
      pLgtDlgData->bEffect = TRUE;

      GetElpPnt(hWnd);
      L_ApplyFilter(hWnd);

      break;

   case IDC_LGTS_SPT_RAD:
      pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uFlag = LGTS_SPOTLIGHT;
      L_ApplyFilter(hWnd);
      break;

   case IDC_LGTS_DIR_RAD:
      pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uFlag = LGTS_DIRELIGHT;
      L_ApplyFilter(hWnd);
      break;

   case IDC_BRG_DEL_BUT:
      if(pLgtDlgData->nEllipesNo == 2)
         EnableWindow(GetDlgItem(hWnd, IDC_BRG_DEL_BUT), FALSE);
      EnableWindow(GetDlgItem(hWnd, IDC_BRG_INS_BUT), TRUE);
      
      pLgtDlgData->LightInfo[pLgtDlgData->nIndex].bUse = FALSE;
      DeleteEllipes(pLgtDlgData);
      
      GetElpPnt(hWnd);
      //InvalidateRect(hWnd, NULL, FALSE);
      pLgtDlgData->bEffect = FALSE;

      SetDlgItemInt(hWnd, IDC_LGTS_BRG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uBright, FALSE);
      SetDlgItemInt(hWnd, IDC_LGTS_EDG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uEdge, FALSE);
      SetDlgItemInt(hWnd, IDC_LGTS_OPC_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uOpacity, FALSE);
      pLgtDlgData->bEffect = TRUE;
      L_ApplyFilter(hWnd);
      break;

   case IDCANCEL:
      for (nIndex = 0; nIndex < 8; nIndex++)
      {
         free(pLgtDlgData->pNellipse[nIndex]);
         free(pLgtDlgData->pPellipse[nIndex]);
      }

      StatusProc.bProgress = FALSE;
      StatusProc.bKillProgress = TRUE ;
      StatusProc.ProgressValue = 100 ;
      L_FreeBitmap(&pLgtDlgData->pTmpBitmap);
      EndDialog(hWnd, FALSE);
      break;

   case IDOK:
      ShowStatusWindow(FALSE);
      StatusProc.bStillWork  = TRUE;
      for (nIndex = 0; nIndex < 8; nIndex++)
      {
         free(pLgtDlgData->pNellipse[nIndex]);
         free(pLgtDlgData->pPellipse[nIndex]);
      }
      StatusProc.bInvalidate = TRUE;
      StatusProc.bEnd = TRUE;
      L_FreeBitmap(&pLgtDlgData->pTmpBitmap);
      EndDialog(hWnd, TRUE);
      break;
   }
   return TRUE;
}


L_BOOL LgtDlg_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT nX, L_INT nY,UINT keyFlags)
{
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   L_INT        cxClient, cyClient;
   POINT        TmpPoint;
   L_INT        nCount;
   RECT         rcRect;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcRect);
   cxClient = rcRect.right  - rcRect.left;
   cyClient = rcRect.bottom - rcRect.top;

   TmpPoint.x = nX;
   TmpPoint.y = nY;

   ClientToScreen(hWnd, &TmpPoint);
   ScreenToClient( GetDlgItem(hWnd, IDC_LGTS_DIS_TXT), &TmpPoint);

   if (PtInRect(&rcRect, TmpPoint))
   {
      for(nCount = 0; nCount < pLgtDlgData->nEllipesNo; nCount++)
      {
         SetRect(&rcRect,  pLgtDlgData->pEllipsPnts[nCount][4].x - 5,
            pLgtDlgData->pEllipsPnts[nCount][4].y - 5,
            pLgtDlgData->pEllipsPnts[nCount][4].x + 5,
            pLgtDlgData->pEllipsPnts[nCount][4].y + 5);
         if (PtInRect(&rcRect, TmpPoint))
         {
            pLgtDlgData->nIndex = nCount;
            pLgtDlgData->bEffect = FALSE;

            if(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uFlag == LGTS_DIRELIGHT)
            {
               Button_SetCheck(GetDlgItem(hWnd, IDC_LGTS_DIR_RAD), TRUE);
               Button_SetCheck(GetDlgItem(hWnd, IDC_LGTS_SPT_RAD), FALSE);
            }
            else
            {
               Button_SetCheck(GetDlgItem(hWnd, IDC_LGTS_DIR_RAD), FALSE);
               Button_SetCheck(GetDlgItem(hWnd, IDC_LGTS_SPT_RAD), TRUE);
            }

            SetDlgItemInt(hWnd, IDC_LGTS_BRG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uBright, FALSE);
            SetDlgItemInt(hWnd, IDC_LGTS_EDG_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uEdge, FALSE);
            SetDlgItemInt(hWnd, IDC_LGTS_OPC_EDT, pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uOpacity, FALSE);
            pLgtDlgData->bEffect = TRUE;
         }
      }
   }

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcRect);

   if (PtInRect(&rcRect, TmpPoint))
   {
      for(nCount = 0; nCount < 5; nCount++)
      {
         SetRect(&rcRect,  pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nCount].x - 5,
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nCount].y - 5,
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nCount].x + 5,
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nCount].y + 5);
         if (PtInRect(&rcRect, TmpPoint))
         {
            pLgtDlgData->bChange = TRUE;
            pLgtDlgData->bApply  = TRUE;
            pLgtDlgData->nPointIndx[pLgtDlgData->nIndex] = nCount;
            return TRUE;
         }
      }
   }

   return TRUE;
}

L_BOOL LgtDlg_OnMouseMove (HWND hWnd, L_INT nX, L_INT nY, UINT keyFlags)
{
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   L_INT        cxClient, cyClient;
   POINT        TmpPoint;
   RECT         rcRect;
   L_DOUBLE     dTheta;
   L_INT        nI;

   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcRect);
   cxClient = rcRect.right  - rcRect.left;
   cyClient = rcRect.bottom - rcRect.top;

   TmpPoint.x = nX;
   TmpPoint.y = nY;

   ClientToScreen(hWnd, &TmpPoint);
   ScreenToClient( GetDlgItem(hWnd, IDC_LGTS_DIS_TXT), &TmpPoint);
   if(pLgtDlgData->bChange)
   {
      switch(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex])
      {
      case 0:
      case 1:

         if(((L_UINT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1) < pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize)
         {
            return TRUE;
         }

         if(((L_UINT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1) < 5)
         {
            return TRUE;
         }
         pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize = (L_INT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][pLgtDlgData->nPointIndx[pLgtDlgData->nIndex]] = TmpPoint;
         dTheta = atan2(TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y, TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x);

         if(!(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex]))
         {
            dTheta -= 3.14;
         }

         if(dTheta > (2 * 3.14))
         {
            dTheta -= (2 * 3.14);
         }
         if(dTheta < 0)
         {
            dTheta += (2 * 3.14);
         }

         if(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex])
         {
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize;
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;
         }
         else
         {
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize;
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;
         }

         if(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex])
            RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);
         else
            RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);

         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize;

         RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);

         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize;

         RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);
         pLgtDlgData->bApply = TRUE;
         GetElpPnt(hWnd);
         break;

      case 2:
      case 3:
         if(((L_UINT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1) > pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize)
         {
            return TRUE;
         }

         if(((L_UINT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1) < 5)
         {
            return TRUE;
         }

         pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize = (L_INT)hypot(TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x, TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y) + 1;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][pLgtDlgData->nPointIndx[pLgtDlgData->nIndex]] = TmpPoint;
         dTheta = atan2(TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y, TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x);

         if(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex] == 3)
         {
            dTheta -= (3.14/2);
         }
         else
         {
            dTheta -= (3.14 + 3.14/2);
         }

         if(dTheta > (2 * 3.14))
         {
            dTheta -= (2 * 3.14);
         }
         if(dTheta < 0)
         {
            dTheta += (2 * 3.14);
         }
         
         if(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex] == 2)
         {
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize;
         }
         else
         {
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize;
         }

         if(pLgtDlgData->nPointIndx[pLgtDlgData->nIndex] == 2)
            RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][3], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);
         else
            RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][2], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);

         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;

         RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][0], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);

         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize;
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;

         RotatePoint(&pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1], pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dTheta);
         pLgtDlgData->bApply = TRUE;
         GetElpPnt(hWnd);
         break;

      case 4:
         for(nI = 0; nI < 4; nI++)
         {
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nI].x += TmpPoint.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;
            pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][nI].y += TmpPoint.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;
         }
         pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][4] = TmpPoint;
         pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter = TmpPoint;
         pLgtDlgData->bApply = TRUE;
         GetElpPnt(hWnd);
         break;

      }
   }

   return TRUE;
}
L_BOOL LgtDlg_OnLButtonUp (HWND hWnd, L_INT nX, L_INT nY, UINT keyFlags)
{
   LPLGTDLGDATA pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);
   RECT         rcRect, rcImage;
   L_INT        nIndex, nI;
   POINT        ptPoint;

   GetClientRect(GetDlgItem(hWnd, IDC_LGTS_DIS_TXT), &rcRect);
   FitImageToWindow(rcRect, &pLgtDlgData->Bitmap, &rcImage);

   for (nIndex = 0; nIndex < 8; nIndex++)
   {
      ptPoint.x = pLgtDlgData->LightInfo[nIndex].ptCenter.x;
      ptPoint.y = pLgtDlgData->LightInfo[nIndex].ptCenter.y;

      pLgtDlgData->LightInfo[nIndex].ptCenter.x = max(rcImage.left, min(rcImage.right, pLgtDlgData->LightInfo[nIndex].ptCenter.x)); 
      pLgtDlgData->LightInfo[nIndex].ptCenter.y = max(rcImage.top, min(rcImage.bottom, pLgtDlgData->LightInfo[nIndex].ptCenter.y)); 

      for (nI = 0; nI < 4; nI++)
      {
         pLgtDlgData->pEllipsPnts[nIndex][nI].x -= (ptPoint.x - pLgtDlgData->LightInfo[nIndex].ptCenter.x);
         pLgtDlgData->pEllipsPnts[nIndex][nI].y -= (ptPoint.y - pLgtDlgData->LightInfo[nIndex].ptCenter.y);
      }

      pLgtDlgData->pEllipsPnts[nIndex][4] = pLgtDlgData->LightInfo[nIndex].ptCenter;
   }

   GetElpPnt(hWnd);
   InvalidateRect(hWnd, NULL, FALSE);

   if(pLgtDlgData->bApply)
   {
      pLgtDlgData->bEffect = TRUE;
      pLgtDlgData->bChange = FALSE;
      L_ApplyFilter(hWnd);
      pLgtDlgData->bApply = FALSE;
      pLgtDlgData->bChange = TRUE;
   }
   if( pLgtDlgData->bChange )
   {
      pLgtDlgData->bChange = FALSE;
   }
   return TRUE;
}

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

L_VOID L_ApplyFilter(HWND hWnd)
{
   pCHILDDATA     pData;
   L_INT          nRet = 0;
   HWND           hWndParent;
   LPLGTDLGDATA   pLgtDlgData;
   RECT           rcClient, SizeRect;
   LIGHTINFO      LightInfo[5];
   L_INT          nI;

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcClient);

   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);
   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);

   if ( 100 != StatusProc.ProgressValue/* || !pLgtDlgData->bEffect*/)
   {
      StatusProc.bKillProgress = TRUE ;
      return ;
   }

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

   FitImageToWindow(rcClient , &pData->LeadBitmap, &SizeRect);

   for(nI = 0; nI < pLgtDlgData->nEllipesNo; nI++)
   {
      LightInfo[nI].ptCenter.x  = (pLgtDlgData->LightInfo[nI].ptCenter.x - SizeRect.left) * pData->LeadBitmap.Width  / (SizeRect.right - SizeRect.left);
      LightInfo[nI].ptCenter.y  = (pLgtDlgData->LightInfo[nI].ptCenter.y - SizeRect.top ) * pData->LeadBitmap.Height / (SizeRect.bottom - SizeRect.top);
      LightInfo[nI].uWidth      = 2 * (pLgtDlgData->LightInfo[nI].uxSize) * pData->LeadBitmap.Width  / (SizeRect.right - SizeRect.left);
      LightInfo[nI].uHeight     = 2 * (pLgtDlgData->LightInfo[nI].uySize) * pData->LeadBitmap.Height / (SizeRect.bottom - SizeRect.top);
      LightInfo[nI].nAngle      = (L_INT)((18000 / 3.14) * atan2(pLgtDlgData->LightInfo[nI].ptCenter.y - pLgtDlgData->pEllipsPnts[nI][1].y,  pLgtDlgData->pEllipsPnts[nI][1].x - pLgtDlgData->LightInfo[nI].ptCenter.x));
      LightInfo[nI].crFill      = pLgtDlgData->LightInfo[nI].crFill;
      LightInfo[nI].uEdge       = pLgtDlgData->LightInfo[nI].uEdge;
      LightInfo[nI].uBright     = pLgtDlgData->LightInfo[nI].uBright;
      LightInfo[nI].uOpacity    = pLgtDlgData->LightInfo[nI].uOpacity;
      LightInfo[nI].uFlag       = pLgtDlgData->LightInfo[nI].uFlag;
      LightInfo[nI].uStructSize = sizeof(LIGHTINFO);

   }

   nRet = L_LightBitmap(&pData->LeadBitmap,
                         LightInfo,
                         pLgtDlgData->nEllipesNo,
                         pLgtDlgData->uBrightEllipes,
                         pLgtDlgData->uAmbient,
                         pLgtDlgData->crAmbientClr);

   if(nRet == SUCCESS)
   {
      L_FreeBitmap(&pLgtDlgData->pTmpBitmap);
      L_CopyBitmap(&pLgtDlgData->pTmpBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE));

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

static L_VOID PaintEllips(HWND hWnd)
{
   PAINTSTRUCT  ps;
   HDC          hDC;
   HDC          hDCMemo;
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   RECT         rcClient;
   L_INT        cxClient, cyClient;
   HBITMAP      hBitmap;
   HPEN         hPenRed, hPenGrn, hPenBlu;
   HBRUSH       hBrush;
   L_INT        nCount, nI;
   POINT        pTmp;
   RECT         SizeRect;
   HPALETTE     hSavedPalette = NULL;
   HPALETTE     hPalette = NULL;

   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcClient);
   cxClient = rcClient.right  - rcClient.left;
   cyClient = rcClient.bottom - rcClient.top;

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

   hBitmap = CreateCompatibleBitmap(hDC, rcClient.right - rcClient.left,
                                         rcClient.bottom - rcClient.top);
   hDCMemo = CreateCompatibleDC(hDC);
   SelectObject(hDCMemo, hBitmap);

   FillRect(hDCMemo, &rcClient,(HBRUSH) (COLOR_WINDOW + 3));

   hBrush = CreateSolidBrush(RGB(255,255,0));
   SelectObject(hDCMemo,hBrush);
   
   FitImageToWindow(rcClient , &pData->LeadBitmap, &SizeRect);

   hPenRed = CreatePen(PS_SOLID , 0, RGB(255, 0, 0));
   hPenGrn = CreatePen(PS_SOLID , 0, RGB(0, 255, 0));
   hPenBlu = CreatePen(PS_SOLID , 0, RGB(0, 0, 255));
   
   hPalette = L_CreatePaintPalette(hDCMemo, &pLgtDlgData->pTmpBitmap);
   if (hPalette)
   {
      hSavedPalette = SelectPalette (hDCMemo, hPalette, FALSE);
      RealizePalette (hDCMemo);
   }

   L_PaintDC(hDCMemo, &pLgtDlgData->pTmpBitmap, NULL, NULL, &SizeRect, &ps.rcPaint, SRCCOPY);

   
   for(nI = 0; nI < pLgtDlgData->nEllipesNo; nI++)
   {
      if(pLgtDlgData->LightInfo[nI].uFlag == LGTS_SPOTLIGHT)
      {
         SelectObject(hDCMemo, hPenBlu);

         pTmp.x = pLgtDlgData->pEllipsPnts[nI][0].x;
         pTmp.y = pLgtDlgData->pEllipsPnts[nI][0].y;

         Ellipse(hDCMemo,  pTmp.x - 3, pTmp.y - 3, pTmp.x + 3, pTmp.y + 3);

         SelectObject(hDCMemo, hPenGrn);
         for(nCount = 0; nCount < 4 ; nCount++)
         {
            pTmp.x = pLgtDlgData->pEllipsPnts[nI][nCount].x;
            pTmp.y = pLgtDlgData->pEllipsPnts[nI][nCount].y;
            Ellipse(hDCMemo,  pTmp.x - 3, pTmp.y - 3, pTmp.x + 3, pTmp.y + 3);
         }

         SelectObject(hDCMemo, hPenRed);

         pTmp.x = pLgtDlgData->pEllipsPnts[nI][4].x;
         pTmp.y = pLgtDlgData->pEllipsPnts[nI][4].y;
         Ellipse(hDCMemo,  pTmp.x - 3, pTmp.y - 3, pTmp.x + 3, pTmp.y + 3);

         SelectObject(hDCMemo, hPenGrn);

         Polyline(hDCMemo, pLgtDlgData->pPellipse[nI], (max( 2 * pLgtDlgData->LightInfo[nI].uxSize , 2 * pLgtDlgData->LightInfo[nI].uySize) + 1));
         Polyline(hDCMemo, pLgtDlgData->pNellipse[nI], (max( 2 * pLgtDlgData->LightInfo[nI].uxSize , 2 * pLgtDlgData->LightInfo[nI].uySize) + 1));
      }
      else
      {
         SelectObject(hDCMemo, hPenBlu);

         pTmp.x = pLgtDlgData->pEllipsPnts[nI][4].x;
         pTmp.y = pLgtDlgData->pEllipsPnts[nI][4].y;
         Ellipse(hDCMemo,  pTmp.x - 7, pTmp.y - 7, pTmp.x + 7, pTmp.y + 7);
      }
   }

   StretchBlt(hDC,0,0,rcClient.right - rcClient.left,rcClient.bottom - rcClient.top,hDCMemo,
                 0,0,rcClient.right - rcClient.left,rcClient.bottom,SRCCOPY);
   DeleteDC(hDCMemo);
   DeleteObject(hPenRed);
   DeleteObject(hPenGrn);
   DeleteObject(hPenBlu);
   DeleteObject(hBrush);
   DeleteObject (hBitmap);
   if (hSavedPalette)
      SelectPalette (hDCMemo, hSavedPalette, FALSE);
   if(hPalette)
         DeleteObject (hPalette);

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

}
static L_VOID GetElpPnt(HWND hWnd)
{
   LPLGTDLGDATA pLgtDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   RECT         rcClient;
   L_INT        cxClient, cyClient;
   L_INT        nCount;
   L_INT        nX, nY;
   L_DOUBLE     dA2, dB2, dAngle;


   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData = LOCKCHILDDATA (hWndParent);
   pLgtDlgData = (LPLGTDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   GetClientRect(GetDlgItem(hWnd , IDC_LGTS_DIS_TXT), &rcClient);
   cxClient = rcClient.right  - rcClient.left;
   cyClient = rcClient.bottom - rcClient.top;

   for(nCount = 0; nCount <= (L_INT)max( 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize , 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize); nCount++)
   {
      dA2 = (L_DOUBLE)pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize;
      dB2 = (L_DOUBLE)pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize;
      if(pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize > pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize)
      {
         nX  = pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].x = (pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize) + nCount;
         pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].y = (L_INT)sqrt(dB2 - ((dB2/dA2) *
            (nX - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x)* (nX - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x))) + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y;

         pLgtDlgData->pNellipse[pLgtDlgData->nIndex][nCount].x = pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].x;
         pLgtDlgData->pNellipse[pLgtDlgData->nIndex][nCount].y = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y +
                                           (pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y - pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].y) ;
      }
      else
      {
         nY  = pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].y = (pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize) + nCount;
         pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].x = (L_INT)sqrt(dA2 - ((dA2/dB2) *
            (nY - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y)* (nY - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y))) + pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x;

         pLgtDlgData->pNellipse[pLgtDlgData->nIndex][nCount].y = pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].y;
         pLgtDlgData->pNellipse[pLgtDlgData->nIndex][nCount].x = pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x -
                                           (pLgtDlgData->pPellipse[pLgtDlgData->nIndex][nCount].x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x) ;
      }
   }

   dAngle = atan2(pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].y - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.y,
                  pLgtDlgData->pEllipsPnts[pLgtDlgData->nIndex][1].x - pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter.x);

   RotateBuffer(pLgtDlgData->pPellipse[pLgtDlgData->nIndex],max( 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize , 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize) + 1,
                pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dAngle);
   RotateBuffer(pLgtDlgData->pNellipse[pLgtDlgData->nIndex],max( 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uxSize , 2 * pLgtDlgData->LightInfo[pLgtDlgData->nIndex].uySize) + 1,
                pLgtDlgData->LightInfo[pLgtDlgData->nIndex].ptCenter, pLgtDlgData, dAngle);
   InvalidateRect(hWnd, NULL, FALSE);   
}

L_VOID RotatePoint(LPPOINT       pRotPoint,
                   POINT         ptCenter,
                   LPLGTDLGDATA  pLgtDlgData,
                   L_DOUBLE      dAngle)
{
   L_DOUBLE dcos, dsin;
   POINT    nTmp;

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

   dcos = cos( dAngle );
   dsin = sin( dAngle );
   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);
}

L_VOID RotateBuffer(LPPOINT       pRotBuf,
                    L_INT         uBufSize,
                    POINT         ptCenter,
                    LPLGTDLGDATA  pLgtDlgData,
                    L_DOUBLE      dAngle)
{
   L_DOUBLE dcos, dsin;
   POINT    nTmp;
   L_INT    nCount;
   
   dcos = cos(dAngle);
   dsin = sin( dAngle);
   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);
   }
}