#include "MainFram.h"
#include "Dialogs.h"
#include "resource.h"
#include "stdio.h"

/*======[ResizeWHDlgProc]===============================================

   Syntax:     L_BOOL CALLBACK ResizeWHDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam);

=========================================================================*/

L_BOOL CALLBACK ResizeWHDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
   int nRet,nScrollInc;

   HWND hCtl;
   static SCROLLDLGDATA DlgData;
   static LPSCROLLDLGDATA  pDlgData;

   switch (msg)
   {
   case WM_INITDIALOG :
      pDlgData=(LPSCROLLDLGDATA)lparam;
      DlgData=*pDlgData;
      hCtl=GetDlgItem(hDlg,IDC_HSCROLLBAR);
      SetScrollRange(hCtl,SB_CTL,DlgData.MinRange,DlgData.MaxRange,TRUE);
      SetScrollPos(hCtl,SB_CTL,DlgData.Value,TRUE);

      SetDlgItemInt(hDlg,IDC_EDIT,DlgData.Value,FALSE);
      SetWindowText(hDlg,(LPTSTR)DlgData.szDlgText);
      hCtl=GetDlgItem(hDlg,IDC_MSG_TEXT);
      SetWindowText(hCtl,(LPTSTR)DlgData.szDlgMessage);


      return TRUE;
   case WM_HSCROLL :
      
      hCtl= (HWND) lparam;
      switch (LOWORD(wparam))
      {
         /* Decrement by current scroll position */
      case SB_LEFT:
         nScrollInc = DlgData.MinRange -DlgData.Value;
         break;

         /* Increment by the difference between Max scroll and current scroll
            position */
      case SB_RIGHT:
         nScrollInc =DlgData.MaxRange - DlgData.Value;
         break;

         /* Decrement by one step */
      case SB_LINELEFT:
         nScrollInc = -DlgData.Step;
         break;

         /* Increment by one step */
      case SB_LINERIGHT:
         nScrollInc = DlgData.Step;
         break;

         /* Decrement by Maximum */
      case SB_PAGELEFT:
         nScrollInc = -max (DlgData.Step, (DlgData.MaxRange- DlgData.Step));
         break;

         /* Increment by Maximum */
      case SB_PAGERIGHT:
         nScrollInc = max (DlgData.Step, (DlgData.MaxRange - DlgData.Step));
         break;

         /* Increment by difference between current scroll position and THUMB
            position */
      case SB_THUMBPOSITION:
      case SB_THUMBTRACK:
         nScrollInc = (L_INT)HIWORD(wparam)- DlgData.Value;
         break;

         /* No Increment */
      default:
         nScrollInc = 0;
         break;
      }

      nScrollInc = max (DlgData.MinRange-DlgData.Value,
                   min (nScrollInc, (DlgData.MaxRange - DlgData.Value)));

      /* if Scroll increment is greater than nScrollInc, Increment scroll
         position by nScrollInc */

      DlgData.Value += nScrollInc;
      /* Set new scroll position at current scroll position; */
      SetScrollPos (hCtl, SB_CTL, DlgData.Value, TRUE);
      SetDlgItemInt(hDlg,IDC_EDIT,DlgData.Value,FALSE);

      return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam))
      {
      case IDOK:
         DlgData.Value=GetDlgItemInt(hDlg,IDC_EDIT,&nRet,FALSE);
         if(nRet)
         {
            if(DlgData.Value >= DlgData.MinRange && DlgData.Value <= DlgData.MaxRange)
            {
               pDlgData->Value=DlgData.Value;
               EndDialog(hDlg,TRUE);
            }
            else
               MessageBox(hDlg, TEXT("The entered value must be within the range"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }
         else
            MessageBox(hDlg, TEXT("You must enter a positive Integer Value"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);

         return TRUE;

      case IDCANCEL:
         EndDialog(hDlg,FALSE);
         return TRUE;

      case IDC_EDIT:
         switch(HIWORD(wparam))
         {
         case EN_CHANGE:
            DlgData.Value=GetDlgItemInt(hDlg,IDC_EDIT,&nRet,FALSE);
            if(nRet)
            {
               if(DlgData.Value >= DlgData.MinRange  && DlgData.Value <= DlgData.MaxRange)
               {
                  hCtl=GetDlgItem(hDlg,IDC_HSCROLLBAR);
                  SetScrollPos (hCtl, SB_CTL,DlgData.Value , TRUE);
               }
               else
               {
                  hCtl=GetDlgItem(hDlg,IDC_HSCROLLBAR);
                  DlgData.Value= GetScrollPos (hCtl, SB_CTL);
               }
            }

            return TRUE;
         }
      }
   }
   return FALSE;
}

/*======[CurFileDlgProc]===============================================

   Syntax:     L_BOOL CALLBACK CurFileDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam);

=========================================================================*/

L_BOOL CALLBACK CurFileDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
   static TCHAR  FileName[260];
   static HCURSOR TmpCur,* pTmpCur;
   int nRet;
   HWND hCtl;
   switch (msg)
   {
   case WM_INITDIALOG :
      pTmpCur=(HCURSOR *) lparam;
      TmpCur= * pTmpCur;
      hCtl=GetDlgItem(hDlg,IDC_CURFILE_NAME);
      SetWindowText(hCtl,FileName);
      return TRUE;

   case WM_COMMAND :
      switch(LOWORD(wparam))
      {
      case IDOK:
         hCtl=GetDlgItem(hDlg,IDC_CURFILE_NAME);
         nRet=GetWindowText(hCtl,FileName,sizeof(FileName));
         if(nRet)
         {
            TmpCur= LoadCursorFromFile(FileName);
            if (TmpCur!=NULL)
            {
               *pTmpCur=TmpCur;
               EndDialog(hDlg,TRUE);
            }
            else
            {
               MessageBox(hDlg, TEXT("Error Loading Cursor File!"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }
         }
         else
            MessageBox(hDlg, TEXT("Error in Reading File Name!"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
         return TRUE;
      case IDCANCEL:
         EndDialog(hDlg,FALSE);
         return TRUE;
      }
   }

   return FALSE;
}

/*======[RoundRectDlgProc]===============================================

   Syntax:     L_BOOL CALLBACK RoundRectDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam);

=========================================================================*/

L_BOOL CALLBACK RoundRectDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam)
{

   static UPDATESHAPEDATA TmpRound;
   static LPUPDATESHAPEDATA pTmpRound;
   int nRet;

   switch (msg)
   {
   case WM_INITDIALOG :
      pTmpRound=(LPUPDATESHAPEDATA) lparam;
      TmpRound= * pTmpRound;
      SetDlgItemInt(hDlg,IDC_ROUNDRECT_WIDTH,TmpRound.right,FALSE);
      SetDlgItemInt(hDlg,IDC_ROUNDRECT_HEIGHT,TmpRound.bottom,FALSE);
      SetDlgItemInt(hDlg,IDC_ROUNDELLIPSE_WIDTH,TmpRound.nWidth,FALSE);
      SetDlgItemInt(hDlg,IDC_ROUNDELLIPSE_HEIGHT,TmpRound.nHeight,FALSE);
      return TRUE;

   case WM_COMMAND :
      switch(LOWORD(wparam))
      {
      case IDOK:
         TmpRound.right=GetDlgItemInt(hDlg,IDC_ROUNDRECT_WIDTH,&nRet,FALSE);
         if(nRet)
         {
            if(TmpRound.right<1)
            {
               MessageBox(hDlg, TEXT("The rectangle width must be positive nonzero value !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }

            if(TmpRound.right>MAX_ROUNDRECTWIDTH)
            {
               MessageBox(hDlg, TEXT("The rectangle width must be within the range !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }
         }
         else
         {
            MessageBox(hDlg, TEXT("You must enter a positive Integer Value"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }

         TmpRound.bottom=GetDlgItemInt(hDlg,IDC_ROUNDRECT_HEIGHT,&nRet,FALSE);
         if(nRet)
         {
            if(TmpRound.bottom<1)
            {
               MessageBox(hDlg, TEXT("The rectangle height must be positive nonzero value !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }

            if(TmpRound.bottom>MAX_ROUNDRECTWIDTH)
            {
               MessageBox(hDlg, TEXT("The rectangle height must be within the range !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }
         }
         else
         {
            MessageBox(hDlg, TEXT("You must enter a positive Integer Value"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }

         TmpRound.nWidth=GetDlgItemInt(hDlg,IDC_ROUNDELLIPSE_WIDTH,&nRet,FALSE);
         if(nRet)
         {
            if(TmpRound.nWidth>TmpRound.right)
            {
               MessageBox(hDlg, TEXT("The ellipses width must be less than the rectangle width !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }
         }
         else
         {
            MessageBox(hDlg, TEXT("You must enter a positive Integer Value"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }

         TmpRound.nHeight=GetDlgItemInt(hDlg,IDC_ROUNDELLIPSE_HEIGHT,&nRet,FALSE);
         if(nRet)
         {
            if(TmpRound.nHeight>TmpRound.bottom)
            {
               MessageBox(hDlg, TEXT("The ellipses height must be less than the rectangle Height !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
               return TRUE;
            }
         }
         else
         {
            MessageBox(hDlg, TEXT("You must enter a positive Integer Value"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }

         * pTmpRound=TmpRound;

         EndDialog(hDlg,TRUE);
         return TRUE;
      case IDCANCEL:
         EndDialog(hDlg,FALSE);
         return TRUE;
      }
   }
   return FALSE;
}

/*======[FreeHandDlgProc]===============================================

   Syntax:     L_BOOL CALLBACK FreeHandDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam);

=========================================================================*/

L_BOOL CALLBACK FreeHandDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
   static HRGN TmpFree;
   static HRGN * pTmpFree;
   static RECT Rect,PaintWndRect;
   static POINT prvPoint,RectPoint;
   static L_INT nbStart=0;
   static POINT  pPoints[1000];
   static L_INT NOPoints=0;

   POINT TmpPoint;
   HWND hCtl;

   switch (msg)
   {
   case WM_INITDIALOG :
      pTmpFree=(HRGN *) lparam;
      TmpFree= * pTmpFree;
      hCtl=GetDlgItem(hDlg,IDC_PAINT);
      GetClientRect( hCtl, &Rect);
      GetWindowRect( hCtl, &PaintWndRect);
      RectPoint.x=PaintWndRect.left;
      RectPoint.y=PaintWndRect.top;
      ScreenToClient(hDlg,&RectPoint);
      NOPoints=0;
      nbStart=0;
      memset(pPoints,0,sizeof(pPoints));

      return TRUE;
   case WM_LBUTTONDOWN:
      TmpPoint.x=LOWORD(lparam)-RectPoint.x;
      TmpPoint.y=HIWORD(lparam)-RectPoint.y;

      if(PtInRect(&Rect,TmpPoint) && nbStart<1)
      {
         prvPoint.x=TmpPoint.x;
         prvPoint.y=TmpPoint.y;
         nbStart=1;
         NOPoints++;
         AddNewPoint(pPoints,NOPoints,TmpPoint);
      }
      SetCapture(hDlg);
      return TRUE;
   case WM_MOUSEMOVE:
      if(nbStart==1)
      {
         TmpPoint.x=LOWORD(lparam)-RectPoint.x;
         TmpPoint.y=HIWORD(lparam)-RectPoint.y;
         if(PtInRect(&Rect,TmpPoint))
         {
            NOPoints++;
            AddNewPoint(pPoints,NOPoints,TmpPoint);
            hCtl=GetDlgItem(hDlg,IDC_PAINT);
            DrawShape(hCtl,prvPoint,TmpPoint);
            prvPoint.x=TmpPoint.x;
            prvPoint.y=TmpPoint.y;
         }
      }
      return TRUE;

   case WM_LBUTTONUP:
      if(nbStart==1)
         nbStart=2;

      ReleaseCapture();
      return TRUE;
   case WM_PAINT:
      hCtl=GetDlgItem(hDlg,IDC_PAINT);
      if(NOPoints)
         PaintTheShape (hCtl,pPoints,NOPoints);
      return FALSE;

   case WM_COMMAND :
      switch(LOWORD(wparam))
      {
      case IDM_CLEAR:
         memset(pPoints,0,sizeof(pPoints));
         NOPoints=0;
         nbStart=0;
         hCtl=GetDlgItem(hDlg,IDC_PAINT);
         InvalidateRect (hCtl, NULL, TRUE) ;
         UpdateWindow (hCtl) ;
         break;

      case IDOK:
         TmpFree=CreatePolygonRgn(pPoints,NOPoints,WINDING);
         if(TmpFree!=NULL)
         {
            * pTmpFree=TmpFree;
            EndDialog(hDlg,TRUE);
            return TRUE;
         }
         else
         {
            MessageBox(hDlg, TEXT("Error While creating region !"), TEXT("Error"), MB_ICONEXCLAMATION | MB_OK);
            return TRUE;
         }

      case IDCANCEL:
         EndDialog(hDlg,FALSE);
         return TRUE;
      }
   }
   return FALSE;
}

/*======[AddNewPoint]===============================================

   Syntax:     L_VOID AddNewPoint(POINT *pPoints,L_INT NOPoints,POINT point);

=========================================================================*/

L_VOID AddNewPoint(POINT *pPoints,L_INT NOPoints,POINT point)
{
   pPoints[NOPoints-1].x=point.x;
   pPoints[NOPoints-1].y=point.y;
}

/*======[DrawShape]===============================================

   Syntax:     L_VOID DrawShape(HWND hwnd,POINT prvPoint,POINT TmpPoint);

=========================================================================*/

L_VOID DrawShape(HWND hwnd,POINT prvPoint,POINT TmpPoint)
{
   HDC hdc;
   hdc=GetDC(hwnd);
   MoveToEx(hdc,prvPoint.x,prvPoint.y,NULL);
   LineTo(hdc,TmpPoint.x,TmpPoint.y);
   ReleaseDC(hwnd,hdc);
}

/*======[PaintTheShape]===============================================

   Syntax:     L_VOID PaintTheShape(HWND hwnd,POINT * pPoints,L_INT NOPoints);

=========================================================================*/

L_VOID PaintTheShape(HWND hwnd,POINT *pPoints ,L_INT NOPoints)
{
   HDC hdc;
   InvalidateRect (hwnd, NULL, TRUE) ;
   UpdateWindow (hwnd) ;
   hdc=GetDC(hwnd);
   Polyline(hdc,pPoints,NOPoints);
   ReleaseDC(hwnd,hdc);
}

/*======[AboutDlgProc]===============================================

   Syntax:     L_BOOL CALLBACK AboutDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam);

=========================================================================*/

L_BOOL CALLBACK AboutDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
   L_CHAR      szText[_MAX_PATH];
   VERSIONINFO VersionInfo;

   L_VersionInfo(&VersionInfo,sizeof(VersionInfo));

   switch (msg)
   {
   case WM_INITDIALOG:
      /* Get the Product name */
      strcpy(szText, (LPSTR)VersionInfo.Product);
      /* Get the Toolkit level */
      if(VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT)
         strcat(szText, (LPSTR)"\nExpress Edition.");
      else if(VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL)
         strcat(szText, (LPSTR)"\nMedical Express Edition.");
      else
         strcat(szText, (LPSTR)"\nProfessional Edition.");
      /* Get Version Major and Minor numbers */
      sprintf(szText,
               "%s\nVersion %d.%d\n",
               szText, VersionInfo.MajorNumber, VersionInfo.MinorNumber);
      /* Get Date of building toolkit */
      sprintf(szText, "%sDate: %s\n", szText, (LPSTR)VersionInfo.Date);
      /* Get Time of building toolkit */
      sprintf(szText, "%sTime: %s\n", szText, (LPSTR)VersionInfo.Time);
      /* Displaying the toolkit info */
      SetDlgItemTextA(hDlg, IDC_STATIC_VERSIONINFO, szText);
      return TRUE;

   case WM_COMMAND :
      switch(LOWORD(wparam))
      {
      case IDOK:
      case IDCANCEL:
         EndDialog(hDlg,FALSE);
         return TRUE;
      }
   }

   return FALSE;
}