#include "ImgPF.h"

static L_BOOL TVPuzzle_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_VOID TVPuzzle_OnCommand    (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify);
static L_VOID TVPuzzle_OnHScroll    (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static L_VOID TVPuzzle_OnTimer      (HWND hWnd, L_INT nID);
static L_BOOL TVPuzzle_OnPaint      (HWND hWnd);
static L_VOID L_ApplyFilter         (HWND hWnd);

L_BOOL CALLBACK TVPuzzleDlgProc(HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG(hWnd, WM_INITDIALOG, TVPuzzle_OnInitDialog);
      HANDLE_MSG(hWnd, WM_COMMAND   , TVPuzzle_OnCommand);
      HANDLE_MSG(hWnd, WM_HSCROLL   , TVPuzzle_OnHScroll);
      HANDLE_MSG(hWnd, WM_PAINT     , TVPuzzle_OnPaint);
      HANDLE_MSG(hWnd, WM_TIMER     , TVPuzzle_OnTimer);

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

static L_BOOL TVPuzzle_OnInitDialog(HWND hWnd, HWND hWndFocus, LPARAM Data)
{
   HWND              hWndParent;
   pCHILDDATA        pData;
   LPTVPUZZLEDLGDATA pTVPuzzleDlgData;
   L_INT             nIndex, nCurSel = 0;
   L_INT             nRangeMin[] = {1, 1, 1  , 1, 1};
   L_INT             nRangeMax[] = {0, 0, 500, 0, 0};
   L_INT             nPosInit[]  = {1, 1, 1  , 1, 1};
   RECT              rcRgn;

   hWndParent       = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData            = LOCKCHILDDATA(hWndParent);
   pTVPuzzleDlgData = (LPTVPUZZLEDLGDATA)(Data);
   MoveDialogToMiddle(hWnd);

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

   L_GetBitmapRgnBounds(&pTVPuzzleDlgData->LeadBitmap, NULL, &rcRgn);
   nRangeMax[0] = (rcRgn.right - rcRgn.left);
   nRangeMax[1] = (rcRgn.bottom - rcRgn.top);
   nPosInit[0]  = (nRangeMax[0] / 2) + 1;
   nPosInit[1]  = (nRangeMax[1] / 2) + 1;
   nPosInit[3]  =  nRangeMax[3] = max(1, (rcRgn.right - rcRgn.left) / 15);
   nPosInit[4]  =  nRangeMax[4] = max(1, (rcRgn.bottom - rcRgn.top) / 15);

   pTVPuzzleDlgData->nEdtBaseID    = IDC_PZL_ROW_EDT;
   pTVPuzzleDlgData->nSldBaseID    = IDC_PZL_ROW_SLD;
   pTVPuzzleDlgData->nSlideNum     = 3;
   pTVPuzzleDlgData->uWidth        = nPosInit[0];
   pTVPuzzleDlgData->uHeight       = nPosInit[1];
   pTVPuzzleDlgData->nWBlockno     = nRangeMin[3];
   pTVPuzzleDlgData->nHBlockno     = nRangeMin[4];
   pTVPuzzleDlgData->nRandomise    = nRangeMin[2];
   pTVPuzzleDlgData->uFlags        = PUZZLE_SIZE | PUZZLE_SHUFFLE | BITMAP_RESIZE;
   pTVPuzzleDlgData->crBorderColor = RGB(255, 255, 255);

   StatusProc.bProgress            = TRUE;
   StatusProc.bInvalidate          = FALSE;
   StatusProc.bKillProgress        = FALSE;
   StatusProc.bEnd                 = FALSE;
   StatusProc.DlgWnd               = hWnd;
   StatusProc.ProgressValue        = 100;
   StatusProc.ProgWnd              = GetDlgItem(hWnd, IDC_PZL_PROG);

   Progress_SetRange(GetDlgItem(hWnd, IDC_PZL_PROG), 0, 100);
   Progress_SetPos  (GetDlgItem(hWnd, IDC_PZL_PROG), 0);

   ComboBox_AddString(GetDlgItem(hWnd, IDC_PZL_COM), TEXT("Period"));
   ComboBox_AddString(GetDlgItem(hWnd, IDC_PZL_COM), TEXT("Frequency"));
   ComboBox_SetCurSel(GetDlgItem(hWnd, IDC_PZL_COM), 0);

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

   pTVPuzzleDlgData->nRandomise = 0;
   EnableWindow(GetDlgItem(hWnd, IDC_PZL_CLR_BTN),  FALSE);
   EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_SLD), FALSE);
   EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_EDT), FALSE);
   Button_SetCheck(GetDlgItem(hWnd, IDC_PZL_RSIZ_CHK), BST_CHECKED);
   Button_SetCheck(GetDlgItem(hWnd, IDC_PZL_SHFL_CHK), BST_CHECKED); 

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

   return TRUE;
}

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

static L_VOID TVPuzzle_OnCommand(HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify)
{
   HWND              hWndParent;
   LPTVPUZZLEDLGDATA pTVPuzzleDlgData;
   pCHILDDATA        pData;
   L_INT             nValue, nIndex;
   L_INT             nRangeMin[] = {1, 1, 1,   1, 1};
   L_INT             nRangeMax[] = {0, 0, 500, 0, 0};
   L_INT             nPosInit[]  = {0, 0, 0,   0, 0};
   L_UINT            uCurSel;
   RECT              rcRgn;
   COLORREF          crColor;

   hWndParent       = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData            = LOCKCHILDDATA(hWndParent);
   pTVPuzzleDlgData = (LPTVPUZZLEDLGDATA)GetWindowLong(hWnd, GWL_USERDATA);

   L_GetBitmapRgnBounds(&pTVPuzzleDlgData->LeadBitmap, NULL, &rcRgn);
   nRangeMax[0] = (rcRgn.right - rcRgn.left);
   nRangeMax[1] = (rcRgn.bottom - rcRgn.top);
   nRangeMax[3] = max(1, (rcRgn.right - rcRgn.left) / 15);
   nRangeMax[4] = max(1, (rcRgn.bottom - rcRgn.top) / 15);

   switch(nID)
   {
   case IDOK:
      ShowStatusWindow(FALSE);
      StatusProc.bStillWork  = TRUE;
      StatusProc.bInvalidate = TRUE;
      StatusProc.bEnd = TRUE;
      InvalidateRect(hWndParent, NULL, FALSE);
      EndDialog(hWnd, TRUE);
      break;

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

   case IDC_PZL_COM:
      if(uCodeNotify == CBN_SELCHANGE)
      {
         uCurSel = ComboBox_GetCurSel(hWndCtl);
         uCurSel = (uCurSel + 1) << 4;
         if(uCurSel & pTVPuzzleDlgData->uFlags)
            return;

         pTVPuzzleDlgData->uFlags &= 0xFF0F;
         pTVPuzzleDlgData->uFlags |= uCurSel;

         uCurSel = (pTVPuzzleDlgData->uFlags & PUZZLE_SIZE) ? 0 : 3;
         pTVPuzzleDlgData->uWidth  = nPosInit[0] = min(nRangeMax[0 + uCurSel], (L_INT)pTVPuzzleDlgData->uWidth);/*nPosInit[0 + uCurSel];*/
         pTVPuzzleDlgData->uHeight = nPosInit[1] = min(nRangeMax[1 + uCurSel], (L_INT)pTVPuzzleDlgData->uHeight); /*nPosInit[1 + uCurSel];*/

         for(nIndex = 0; nIndex < 2; nIndex++)
         {
            Trackbar_SetTheRange(GetDlgItem(hWnd, pTVPuzzleDlgData->nSldBaseID + nIndex),
                                 TRUE,
                                 nRangeMin[uCurSel + nIndex],
                                 nRangeMax[uCurSel + nIndex]);

            EditNumericEditBox  (GetDlgItem(hWnd, pTVPuzzleDlgData->nSldBaseID + nIndex),
                                 nRangeMin[uCurSel + nIndex],
                                 nRangeMax[uCurSel + nIndex],
                                 1,
                                 0,
                                 FALSE,
                                 EDT_MODFY_MAX | EDT_MODFY_MIN);

            SetDlgItemInt(hWnd, IDC_PZL_ROW_EDT + nIndex, nPosInit[nIndex], TRUE);
         }
         InvalidateRect(hWndCtl, NULL, FALSE);
         L_ApplyFilter(hWnd);
      }
      break;

   case IDC_PZL_RSIZ_CHK:
      pTVPuzzleDlgData->uFlags ^= BITMAP_RESIZE;
      L_ApplyFilter(hWnd);
      break;

   case IDC_PZL_SHFL_CHK:
      pTVPuzzleDlgData->uFlags ^= PUZZLE_SHUFFLE;
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_CHK), Button_GetCheck(hWndCtl));
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_SLD), Button_GetCheck(hWndCtl) && (pTVPuzzleDlgData->nRandomise));
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_EDT), Button_GetCheck(hWndCtl) && (pTVPuzzleDlgData->nRandomise));
      L_ApplyFilter(hWnd);
      break;

   case IDC_PZL_RND_BTN:
      L_ApplyFilter(hWnd);
      break;

   case IDC_PZL_BRDR_CHK:
      pTVPuzzleDlgData->uFlags ^= PUZZLE_BORDER;
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_CLR_BTN), Button_GetCheck(hWndCtl));
      InvalidateRect(hWnd, NULL, FALSE);
      L_ApplyFilter(hWnd);
      break;

   case IDC_PZL_CLR_BTN:
      crColor = pTVPuzzleDlgData->crBorderColor;
      pTVPuzzleDlgData->crBorderColor = ShowColorDialog(hWnd, crColor);
      if (crColor != pTVPuzzleDlgData->crBorderColor)
      {
         InvalidateRect(hWnd, NULL, FALSE);
         L_ApplyFilter(hWnd);
      }
      break;

   case IDC_PZL_RNDF_CHK:
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_SLD), Button_GetCheck(hWndCtl));
      EnableWindow(GetDlgItem(hWnd, IDC_PZL_RNDF_EDT), Button_GetCheck(hWndCtl));
      pTVPuzzleDlgData->nRandomise = Button_GetCheck(hWndCtl) ? GetDlgItemInt(hWnd, IDC_PZL_RNDF_EDT, NULL, 0) : 0;
      L_ApplyFilter(hWnd);
      break;
   }

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

         switch(nIndex)
         {
         case 0:
            if(pTVPuzzleDlgData->uWidth == (L_UINT)nValue)
               return;
            pTVPuzzleDlgData->uWidth = (L_UINT)nValue;
            break;
         case 1:
            if(pTVPuzzleDlgData->uHeight == (L_UINT)nValue)
               return;
            pTVPuzzleDlgData->uHeight = (L_UINT)nValue;
            break;
         case 2:
            if(pTVPuzzleDlgData->nRandomise == nValue)
               return;
            pTVPuzzleDlgData->nRandomise = nValue;
            break;
         }
         L_ApplyFilter(hWnd);
      }
   }
}

static L_BOOL TVPuzzle_OnPaint(HWND hWnd)
{
   HBRUSH             hBrush;
   LPTVPUZZLEDLGDATA  pTVPuzzleDlgData;
   PAINTSTRUCT        ps;
   HDC                hDC;
   RECT               rcRect;

   pTVPuzzleDlgData = (LPTVPUZZLEDLGDATA)GetWindowLong(hWnd, GWL_USERDATA);
   GetClientRect(GetDlgItem(hWnd, IDC_PZL_CLR_TXT), &rcRect);

   hDC    = BeginPaint(GetDlgItem(hWnd, IDC_PZL_CLR_TXT), &ps);
   hBrush = CreateSolidBrush(pTVPuzzleDlgData->crBorderColor);
   FillRect(hDC, &rcRect, (Button_GetCheck(GetDlgItem(hWnd, IDC_PZL_BRDR_CHK)) ?  hBrush : (HBRUSH)COLOR_WINDOW));
   DeleteBrush(hBrush);
   EndPaint(GetDlgItem(hWnd, IDC_PZL_CLR_TXT), &ps);
   return FALSE;
}

static L_VOID TVPuzzle_OnHScroll(HWND hWnd, HWND hWndCtl, L_UINT code, L_INT pos)
{
   LPTVPUZZLEDLGDATA  pTVPuzzleDlgData = (LPTVPUZZLEDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   SetDlgItemInt(hWnd, GetDlgCtrlID(hWndCtl) - pTVPuzzleDlgData->nSlideNum, Trackbar_GetPos(hWndCtl), FALSE);
}

static L_VOID L_ApplyFilter(HWND hWnd)
{
   pCHILDDATA        pData;
   L_INT             nRet = 0;
   HWND              hWndParent;
   LPTVPUZZLEDLGDATA pTVPuzzleDlgData;

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

   pTVPuzzleDlgData = (LPTVPUZZLEDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   hWndParent       = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData            = (pCHILDDATA)GetWindowLong(hWndParent, GWL_USERDATA);

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

   nRet = L_PuzzleEffectBitmap(&pData->LeadBitmap,
                                pTVPuzzleDlgData->uWidth,
                                pTVPuzzleDlgData->uHeight,
                                (L_UINT)pTVPuzzleDlgData->nRandomise,
                                pTVPuzzleDlgData->uFlags,
                                pTVPuzzleDlgData->crBorderColor);

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