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

#include "ImgPF.h"

typedef struct tagCENTERST
{
   WNDPROC  OldWndProc;
} CENTERST, L_FAR * LPCENTERST;

static L_BOOL ConvolutionDialog_OnCommand    (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify);
static L_BOOL ConvolutionDialog_OnHScroll    (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static L_BOOL ConvolutionDialog_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_VOID L_ApplyFilter                  (HWND hWnd);
static L_BOOL ConvolutionDialog_OnPaint      (HWND hWnd);
static L_VOID ConvolutionDialog_OnTimer      (HWND hWnd, L_INT nID);
static L_VOID Set_Matrix_Border_Row          (HWND hWnd , LPCONDLGDATA pConDlgData);
static L_VOID Set_Matrix_Border_Col          (HWND hWnd , LPCONDLGDATA pConDlgData);
static L_VOID View_Matrix_Data               (HWND hWnd , LPCONDLGDATA pConDlgData);

LRESULT CALLBACK CenterProc                  (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam);

L_BOOL CALLBACK ConDlgProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG (hWnd, WM_COMMAND,    ConvolutionDialog_OnCommand);
      HANDLE_MSG (hWnd, WM_INITDIALOG, ConvolutionDialog_OnInitDialog);
      HANDLE_MSG (hWnd, WM_HSCROLL,    ConvolutionDialog_OnHScroll);
      HANDLE_MSG (hWnd, WM_VSCROLL,    ConvolutionDialog_OnHScroll);
      HANDLE_MSG (hWnd, WM_TIMER,      ConvolutionDialog_OnTimer);
      HANDLE_MSG (hWnd, WM_PAINT,      ConvolutionDialog_OnPaint);

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

L_VOID Alloc_Conv_Matrix(L_INT L_FAR * L_FAR * L_FAR * pMatrix, 
                         L_INT                         nCol,
                         L_INT                         nRow)
{
   L_INT i, j;

   (*pMatrix) = (L_INT L_FAR * L_FAR *) malloc(nRow * sizeof(L_INT L_FAR * ));

   for(i = 0; i < nRow; i++)
   {
      (*pMatrix)[i] = (L_INT L_FAR *) malloc(nCol * sizeof(L_INT));
      for(j = 0; j < nCol; j++)
      {
         (*pMatrix)[i][j] = 1;
      }
   }
}

L_VOID Init_Matrix_Range(HWND hWnd , LPCONDLGDATA pConDlgData)
{
   L_INT nNewPos;
   L_INT m = max(0, pConDlgData->nRowSize - 3);
   Trackbar_SetRange(GetDlgItem(hWnd, IDC_CON_ROW_SLD), TRUE, 0, m);
   nNewPos = min(m, Trackbar_GetPos(GetDlgItem(hWnd, IDC_CON_ROW_SLD)));
   Trackbar_SetPos(GetDlgItem(hWnd, IDC_CON_ROW_SLD), TRUE, nNewPos);
   pConDlgData->nRow = nNewPos;

   m = max(0, pConDlgData->nColSize - 3);
   nNewPos = min(m, Trackbar_GetPos(GetDlgItem(hWnd, IDC_CON_COL_SLD)));
   Trackbar_SetRange(GetDlgItem(hWnd, IDC_CON_COL_SLD), TRUE, 0, m);
   Trackbar_SetPos(GetDlgItem(hWnd, IDC_CON_COL_SLD), TRUE, nNewPos);
   pConDlgData->nCol = nNewPos;

   Set_Matrix_Border_Row(hWnd , pConDlgData);
   Set_Matrix_Border_Col(hWnd , pConDlgData);
   View_Matrix_Data(hWnd , pConDlgData);
   InvalidateRect(hWnd, NULL, FALSE);

}

L_VOID View_Matrix_Data(HWND hWnd , LPCONDLGDATA pConDlgData)
{
   L_INT i, j, k;
   for(i = 0, k = 0; i < 3; i++)
   {
      for(j = 0; j < 3; j++, k++)
      {
         SetDlgItemInt(hWnd, IDC_CON_MAT_EDT_1 + k , pConDlgData->pMatrix[i + pConDlgData->nRow][j + pConDlgData->nCol], TRUE);
      }
   }
}

L_VOID Set_Matrix_Border_Row(HWND hWnd , LPCONDLGDATA pConDlgData)
{
   L_INT i;

   for(i = 0; i < 3; i++)
   {
      SetDlgItemInt(hWnd, IDC_CON_ROW_TXT_1 + i, i + pConDlgData->nRow, FALSE);
   }
}

L_VOID Set_Matrix_Border_Col(HWND hWnd , LPCONDLGDATA pConDlgData)
{
   L_INT i;

   for(i = 0; i < 3; i++)
   {
      SetDlgItemInt(hWnd, IDC_CON_COL_TXT_1 + i, i + pConDlgData->nCol, FALSE);
   }
}

static L_BOOL ConvolutionDialog_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
   LPCONDLGDATA pConDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   LPCENTERST   pCenterSt;
   L_INT        nSlider, i, j;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pConDlgData = (LPCONDLGDATA)lParam;
   MoveDialogToMiddle(hWnd);

   SetWindowLong(hWnd, GWL_USERDATA, (LONG)pConDlgData);

   //MEMDISK...//
   MemorizeAndCopyBitmap (hWndParent, &pConDlgData->Bitmap);

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

   pConDlgData->nRow     = 0;
   pConDlgData->nCol     = 0;

   pConDlgData->nRowSize = 3;
   pConDlgData->nColSize = 3;

   pConDlgData->uDivisor = 9;
   pConDlgData->uOffset  = 0;
   pConDlgData->uFlag    = 0;

   pConDlgData->nSlideNum    = 2;
   pConDlgData->nEdtBaseID   = IDC_CON_ROW_EDT;

   Alloc_Conv_Matrix(&pConDlgData->pMatrix, max(3, pConDlgData->nColSize), max(3, pConDlgData->nRowSize));
   SetDlgItemInt(hWnd, IDC_CON_COL_EDT, 3, FALSE);
   SetNumericEditBox(GetDlgItem(hWnd, IDC_CON_COL_EDT), 1, 100, 1, 0, FALSE);
   SetDlgItemInt(hWnd, IDC_CON_ROW_EDT, 3, FALSE);
   SetNumericEditBox(GetDlgItem(hWnd, IDC_CON_ROW_EDT), 1, 100, 1, 0, FALSE);
   Init_Matrix_Range(hWnd , pConDlgData);

   ComboBox_AddString(GetDlgItem(hWnd, IDC_CON_TYP_COM), TEXT("Sum"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_CON_TYP_COM), TEXT("Max"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_CON_TYP_COM), TEXT("Min"));
   ComboBox_SetCurSel(GetDlgItem(hWnd, IDC_CON_TYP_COM), 0);

   SetDlgItemInt(hWnd, IDC_CON_DIV_EDT, 9, FALSE);
   SetNumericEditBox(GetDlgItem(hWnd, IDC_CON_DIV_EDT), 1, 10000000, 1, 0, FALSE);
   SetDlgItemInt(hWnd, IDC_CON_OFS_EDT, 0, FALSE);
   SetNumericEditBox(GetDlgItem(hWnd, IDC_CON_OFS_EDT), 0, 10000000, 1, 0, FALSE);

   pConDlgData->ptCenter.x = 1;
   pConDlgData->ptCenter.y = 1;

   for (nSlider = 0, j = 0; nSlider < 3; nSlider++)
   {
      for (i = 0; i < 3; i++, j++)
      {
         SetDlgItemInt(hWnd, IDC_CON_MAT_EDT_1 + j, pConDlgData->pMatrix[nSlider][i], FALSE);
         SetNumericEditBox(GetDlgItem(hWnd, IDC_CON_MAT_EDT_1 + j), -10000, 10000, 1, 0, FALSE);
      }
   }

   for(i = 0; i < 9; i++)
   {
      pCenterSt = (LPCENTERST) malloc (sizeof(CENTERST));
      memset (pCenterSt, 0, sizeof(CENTERST));

      SetWindowLong (GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), GWL_USERDATA, (LONG) pCenterSt);
      pCenterSt->OldWndProc = (WNDPROC) GetWindowLong(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), GWL_WNDPROC);
      SetWindowLong (GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), GWL_WNDPROC, (LONG)CenterProc);
   }

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

static L_BOOL ConvolutionDialog_OnPaint(HWND hWnd)
{
   HDC          hDC;
   PAINTSTRUCT  ps;
   RECT         rcImage;
   LPCONDLGDATA pConDlgData;
   L_INT        x, y, i;
   HBRUSH       hBrush;

   pConDlgData = (LPCONDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   x = pConDlgData->ptCenter.x - pConDlgData->nRow;
   y = pConDlgData->ptCenter.y - pConDlgData->nCol;

   for(i = 0; i < 9; i++)
   {
      if(i == (x * 3 + y ))
         continue;
      hDC = BeginPaint(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), &ps);
      GetClientRect(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), &rcImage);
      FillRect(hDC, &rcImage, (HBRUSH)COLOR_WINDOW);
      EndPaint(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + i), &ps);
   }

   if(x < 0 || y < 0 || x >= 3 || y >= 3)
      return FALSE;
   else
   {
      hDC = BeginPaint(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + x * 3 + y ), &ps);
      GetClientRect(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + x * 3 + y ), &rcImage);
      hBrush = CreateSolidBrush(RGB(0,255,0));
      FillRect(hDC, &rcImage, hBrush);
      EndPaint(GetDlgItem(hWnd, IDC_CON_MAT_TXT_1 + x * 3 + y ), &ps);
   }
   return FALSE;
}

L_VOID Free_Conv_Matrix(L_INT L_FAR * L_FAR *  pMatrix,
                        L_INT                  nCol,   
                        L_INT                  nRow)  
{
   L_INT i;
   for(i = 0; i < nRow; i++)
   {
      free(pMatrix[i]);
   }

   free(pMatrix);
}

L_VOID Copy_Conv_Matrix(L_INT L_FAR * L_FAR * pMatrix1,
                        L_INT L_FAR * L_FAR * pMatrix2,
                        L_INT    nCol1, 
                        L_INT    nRow1,
                        L_INT    nCol2, 
                        L_INT    nRow2)
{
   L_INT i, j;
   for(i = 0; i < nRow1; i++)
   {
      if(i >= nRow2)
         return;
      for(j = 0; j < nCol1; j++)
      {
         if(j >= nCol2)
            continue;
         pMatrix1[i][j] = pMatrix2[i][j];
      }
   }
}

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

static L_BOOL ConvolutionDialog_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify)
{
   LPCONDLGDATA pConDlgData;
   HWND         hWndParent;
   HWND         hCtl;
   pCHILDDATA   pData;
   L_INT        nValue;
   L_INT        nIndex;
   L_INT L_FAR * L_FAR * pTemp;
   L_INT        nTemp;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pConDlgData = (LPCONDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if ((uCodeNotify == CBN_SELCHANGE ) && (nID == IDC_CON_TYP_COM))
   {
      nIndex = ComboBox_GetCurSel(GetDlgItem(hWnd, IDC_CON_TYP_COM));
      if(pConDlgData->uFlag == (L_UINT)nIndex)
         return TRUE;
      pConDlgData->uFlag = nIndex;
      L_ApplyFilter(hWnd);
   }

   if (nID >= pConDlgData->nEdtBaseID && nID < pConDlgData->nEdtBaseID + pConDlgData->nSlideNum)
   {
      if(uCodeNotify == EN_CHANGE)
      {
         nValue = GetDlgItemInt(hWnd, nID, NULL, TRUE);
         hCtl   = GetDlgItem(hWnd,nID + pConDlgData->nSlideNum);
         nIndex = nID - pConDlgData->nEdtBaseID;
         switch (nIndex)
         {
         case 0:
            if(pConDlgData->nRowSize == nValue)
               return TRUE;
            nTemp = pConDlgData->nRowSize;
            pConDlgData->nRowSize = max(3, nValue);
            pConDlgData->ptCenter.x = pConDlgData->nRowSize / 2;
            Alloc_Conv_Matrix(&pTemp, pConDlgData->nColSize, pConDlgData->nRowSize);
            Copy_Conv_Matrix(pTemp, pConDlgData->pMatrix, pConDlgData->nColSize, pConDlgData->nRowSize, pConDlgData->nColSize, nTemp);
            Free_Conv_Matrix(pConDlgData->pMatrix, pConDlgData->nColSize, nTemp);
            pConDlgData->pMatrix = pTemp;
            Init_Matrix_Range(hWnd , pConDlgData);
            InvalidateRect(hWnd, NULL, FALSE);
            L_ApplyFilter(hWnd);
            break;

         case 1:
            if(pConDlgData->nColSize == nValue)
               return TRUE;
            nTemp = pConDlgData->nColSize;
            pConDlgData->nColSize =max(3, nValue);
            pConDlgData->ptCenter.y = pConDlgData->nColSize / 2;
            Alloc_Conv_Matrix(&pTemp, pConDlgData->nColSize, pConDlgData->nRowSize);

            Copy_Conv_Matrix(pTemp, pConDlgData->pMatrix, pConDlgData->nColSize, pConDlgData->nRowSize, nTemp, pConDlgData->nRowSize);
            Free_Conv_Matrix(pConDlgData->pMatrix, nTemp, pConDlgData->nRowSize);
            pConDlgData->pMatrix = pTemp;
            Init_Matrix_Range(hWnd , pConDlgData);
            InvalidateRect(hWnd, NULL, FALSE);
            L_ApplyFilter(hWnd);
            break;
         }
      }
   }

   if (nID >= IDC_CON_DIV_EDT && nID < IDC_CON_DIV_EDT + pConDlgData->nSlideNum)
   {
      if(uCodeNotify == EN_CHANGE)
      {
         nValue = GetDlgItemInt(hWnd, nID, NULL, TRUE);
         hCtl   = GetDlgItem(hWnd,nID + pConDlgData->nSlideNum);
         nIndex = nID - IDC_CON_DIV_EDT;

         switch (nIndex)
         {
         case 0:
            if(pConDlgData->uDivisor == (L_UINT)nValue)
               return TRUE;
            pConDlgData->uDivisor = nValue;
            L_ApplyFilter(hWnd);
            break;

         case 1:
            if(pConDlgData->uOffset == (L_UINT)nValue)
               return TRUE;
            pConDlgData->uOffset = nValue;
            L_ApplyFilter(hWnd);
            break;
         }
      }
   }

   if (nID >= IDC_CON_MAT_EDT_1 && nID < IDC_CON_MAT_EDT_1 + 9)
   {
      if(uCodeNotify == EN_CHANGE)
      {
         nValue = GetDlgItemInt(hWnd, nID, NULL, TRUE);
         hCtl   = GetDlgItem(hWnd,nID + pConDlgData->nSlideNum);
         nIndex = nID - IDC_CON_MAT_EDT_1;

         if(pConDlgData->pMatrix[pConDlgData->nRow + nIndex / 3][pConDlgData->nCol + nIndex % 3] == nValue)
            return TRUE;

         pConDlgData->pMatrix[pConDlgData->nRow + nIndex / 3][pConDlgData->nCol + nIndex % 3] = nValue;
         L_ApplyFilter(hWnd);
      }
   }

   switch (nID)
   {
   case IDC_CON_RST_BTN:
      {
         L_INT nI, nJ;

         for (nI = 0; nI < pConDlgData->nRowSize; nI++)
         {
            for (nJ = 0; nJ < pConDlgData->nColSize; nJ++)
            {
               pConDlgData->pMatrix[nI][nJ] = 1;
            }
         }

         for (nI = 0; nI < 9; nI++)
               SetDlgItemInt(hWnd, IDC_CON_MAT_EDT_1 + nI, 1, TRUE);

         L_ApplyFilter(hWnd);
      }
      break;

   case IDCANCEL:
      StatusProc.bProgress = FALSE;
      StatusProc.bKillProgress = TRUE ;
      StatusProc.ProgressValue = 100 ;
      EndDialog(hWnd, FALSE);
      break;

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

static L_BOOL ConvolutionDialog_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   LPCONDLGDATA pConDlgData;
   L_INT        nId;

   pConDlgData = (LPCONDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   nId = GetDlgCtrlID(hWndCtl);
   if(nId == IDC_CON_ROW_SLD || nId == IDC_CON_COL_SLD)
   {
      if(nId == IDC_CON_ROW_SLD)
         pConDlgData->nRow = Trackbar_GetPos(hWndCtl);

      if(nId == IDC_CON_COL_SLD)
         pConDlgData->nCol = Trackbar_GetPos(hWndCtl);
      
      Set_Matrix_Border_Row(hWnd , pConDlgData);
      Set_Matrix_Border_Col(hWnd , pConDlgData);
      View_Matrix_Data(hWnd , pConDlgData);
      InvalidateRect(hWnd, NULL, FALSE);
   }
/*   else
   {
      SetDlgItemInt(hWnd, GetDlgCtrlID(hWndCtl) - pConDlgData->nSlideNum , Trackbar_GetPos(hWndCtl), TRUE);
   }*/
   return TRUE;
}

L_VOID L_ApplyFilter(HWND hWnd)
{
   pCHILDDATA     pData;
   L_INT          nRet = 0;
   HWND           hWndParent;
   LPCONDLGDATA   pConDlgData;
   POINT          pCenter;
   LPUSERFLT      pUserFlt;
   L_INT          i, j;

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

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

   pCenter.x = pConDlgData->ptCenter.y;
   pCenter.y = pConDlgData->ptCenter.x;

   pUserFlt = malloc(sizeof(USERFLT) + pConDlgData->nColSize * pConDlgData->nRowSize * sizeof(L_INT));

   pUserFlt->uStructSize = sizeof(USERFLT);
   for(i = 0; i < pConDlgData->nRowSize; i++)
   {
      for(j = 0; j < pConDlgData->nColSize; j++)
      {
         pUserFlt->ufltMatrix[i * pConDlgData->nColSize + j] = pConDlgData->pMatrix[i][j];
      }
   }

   pUserFlt->ufltWidth   = pConDlgData->nColSize;
   pUserFlt->ufltHeight  = pConDlgData->nRowSize;
   pUserFlt->ufltCenter  = pCenter;
   pUserFlt->ufltDivisor = pConDlgData->uDivisor;
   pUserFlt->nfltOffset  = pConDlgData->uOffset;
   pUserFlt->ufltFlag    = pConDlgData->uFlag;

   nRet  = L_UserFilterBitmap(&pData->LeadBitmap, pUserFlt);

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

LRESULT CALLBACK CenterProc(HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   LPCENTERST     pCenterSt;
   LPCONDLGDATA   pConDlgData;
   HWND           hWndParent;
   L_INT          nID;
   POINT          Center;

   hWndParent  = GetParent(hWnd);
   pCenterSt   = (LPCENTERST)   GetWindowLong(hWnd, GWL_USERDATA);
   pConDlgData = (LPCONDLGDATA) GetWindowLong(hWndParent, GWL_USERDATA);

   nID = GetDlgCtrlID(hWnd);
   switch (uMessage)
   {
   case WM_LBUTTONDBLCLK:
      Center.x = pConDlgData->nRow + (GetDlgCtrlID(hWnd) - IDC_CON_MAT_TXT_1) / 3;
      Center.y = pConDlgData->nCol + (GetDlgCtrlID(hWnd) - IDC_CON_MAT_TXT_1) % 3;

      if(Center.x >= pConDlgData->nRowSize || Center.y >= pConDlgData->nColSize)
         break;
      else
         pConDlgData->ptCenter = Center;

      InvalidateRect(hWndParent, NULL, FALSE);
      L_ApplyFilter(hWndParent);
      break;
   }
   return CallWindowProc (pCenterSt->OldWndProc, hWnd, uMessage, wParam, lParam);
}