#define  STRICT
#include <windows.h>
#include <windowsx.h>

#include "RgnDem.h"

static L_VOID  FRAME_OnCommand       (HWND hWnd, L_INT id, HWND hwndCtl, UINT codeNotify);
static L_VOID  FRAME_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, L_BOOL bSystemMenu);
static L_VOID  FRAME_OnDestroy       (HWND hWnd);
static L_BOOL  FRAME_OnCreate        (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static L_VOID  FRAME_OnClose         (HWND hWnd);
static BOOL    FRAME_OnQueryNewPalette (HWND hwnd);
static VOID    FRAME_OnPaletteChanged (HWND hwnd, HWND hwndPaletteChange);
static VOID    FRAME_OnPaletteChanging (HWND hwnd, HWND hwndPaletteChange);
static VOID    FRAME_SysColorChange(HWND hwnd);

L_BOOL CALLBACK L_EXPORT PaletteChangedAll (HWND hWnd, LPARAM lParam);

HWND     CreateChildWindow (L_TCHAR L_FAR * pszTitle, pBITMAPHANDLE pBitmap, L_INT nBitmapFormat, L_BOOL bIsFile);
L_INT    OpenBitmap        (HWND hWnd);

LRESULT CALLBACK FrameWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
      HANDLE_MSG (hwnd, WM_CREATE,          FRAME_OnCreate);
      HANDLE_MSG (hwnd, WM_INITMENUPOPUP,   FRAME_OnInitMenuPopup);
      HANDLE_MSG (hwnd, WM_DESTROY,         FRAME_OnDestroy);
      HANDLE_MSG (hwnd, WM_COMMAND,         FRAME_OnCommand);
      HANDLE_MSG (hwnd, WM_CLOSE,           FRAME_OnClose);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED, FRAME_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_PALETTEISCHANGING, FRAME_OnPaletteChanging);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE, FRAME_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_SYSCOLORCHANGE, FRAME_SysColorChange);

   }
   return DefFrameProc (hwnd, hWndClient, message, wParam, lParam);
}

static L_VOID FRAME_OnCommand (HWND hWnd, L_INT id, HWND hwndCtl, UINT codeNotify)
{
   HWND hChildWnd;

   switch(id)
   {
   case IDM_FILE_OPENFILE:

      OpenBitmap(hWnd);
      return;

   case IDM_FILE_CLOSE:

      hChildWnd = (HWND) SendMessage(hWndClient, WM_MDIGETACTIVE, 0, 0);
      if(SendMessage(hChildWnd, WM_QUERYENDSESSION, 0, 0))
         SendMessage(hWndClient, WM_MDIDESTROY, (WPARAM) hChildWnd, 0);
      return;

   case IDM_FILE_EXIT:
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      return;

   case IDM_EDIT_PASTE1:
      PasteBitmap(hWnd);
      return;
   case IDM_WINDOW_CASCADE:

      SendMessage(hWndClient, WM_MDICASCADE, 0, 0);
      return;

   case IDM_WINDOW_TILE_HORIZANTAL:

      SendMessage(hWndClient, WM_MDITILE, MDITILE_HORIZONTAL | MDITILE_SKIPDISABLED, 0);
      return;

   case IDM_WINDOW_TILE_VERTICAL:

      SendMessage(hWndClient, WM_MDITILE, MDITILE_VERTICAL | MDITILE_SKIPDISABLED, 0);
      return;

   case IDM_WINDOW_ARRANGE:

      SendMessage(hWndClient, WM_MDIICONARRANGE, 0, 0);
      return;

   case IDM_WINDOW_CLOSEALL:

      EnumChildWindows(hWndClient, CloseEnumProc, 0);
      return;

   case IDM_HELP_ABOUT:

      DoDialogBoxParam(IDD_ABOUTBOX, hWnd, (DLGPROC) AboutDlgProc, 0);
      return;

   default:

      hChildWnd = (HWND) SendMessage(hWndClient, WM_MDIGETACTIVE, 0, 0);

      if(IsWindow(hChildWnd))
         SendMessage(hChildWnd, WM_COMMAND, MAKEWPARAM((UINT)(id),(UINT)(codeNotify)), (LPARAM)(HWND)(hwndCtl));
      break;
   }
   DefFrameProc(hWnd, hWndClient, WM_COMMAND, MAKEWPARAM((UINT)(id),(UINT)(codeNotify)), (LPARAM)(HWND)(hwndCtl));
}

static L_BOOL FRAME_OnCreate (HWND hWnd, CREATESTRUCT L_FAR * lpCreateStruct)
{
   CLIENTCREATESTRUCT clientcreate;

   clientcreate.hWindowMenu  = hMenuChildWindow;
   memset(&clientcreate, 0, sizeof(CLIENTCREATESTRUCT));
   clientcreate.idFirstChild = IDM_FIRSTCHILD;

   hWndClient = CreateWindow(TEXT("MDICLIENT"),
                             NULL,
                             WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE |
                             WS_VSCROLL | WS_HSCROLL,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT, 
                             hWnd,
                             (HMENU) 1,
                             hInst,
                             (PSTR) &clientcreate);

   if(hWndClient)
   {
      UNLOCKSUPPORT();
   }

   return ((hWndClient) ? TRUE : FALSE);
}

static L_VOID FRAME_OnClose (HWND hWnd)
{
   FORWARD_WM_COMMAND(hWnd, IDM_WINDOW_CLOSEALL, 0, 0, SendMessage);
   DestroyWindow(hWnd);
}

static L_VOID FRAME_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, L_BOOL fSystemMenu)
{
   L_BOOL bClipboardReady;

   bClipboardReady = L_ClipboardReady();

   CheckMenuItem(hMenu, IDM_TOOL_SETREGION_NONE, MF_BYCOMMAND             | (nRgnType==0)? MF_CHECKED :MF_UNCHECKED);
   CheckMenuItem(hMenu, IDM_TOOL_SETREGION_RECTANGLE, MF_BYCOMMAND        | (nRgnType==1)? MF_CHECKED :MF_UNCHECKED);
   CheckMenuItem(hMenu, IDM_TOOL_SETREGION_ROUNDEDRECTANGLE, MF_BYCOMMAND | (nRgnType==2)? MF_CHECKED :MF_UNCHECKED);
   CheckMenuItem(hMenu, IDM_TOOL_SETREGION_ELLIPSE, MF_BYCOMMAND          | (nRgnType==3)? MF_CHECKED :MF_UNCHECKED);
   CheckMenuItem(hMenu, IDM_TOOL_SETREGION_FREEHAND, MF_BYCOMMAND         | (nRgnType==4)? MF_CHECKED :MF_UNCHECKED);

   EnableMenuItem(hMenu, IDM_EDIT_PASTE,  MF_BYCOMMAND | ((bClipboardReady) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_EDIT_PASTE1, MF_BYCOMMAND | ((bClipboardReady) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(hMenu, IDM_TOOL_CANCLEREGION, MF_BYCOMMAND | (nRgn==5) ? MF_ENABLED : MF_GRAYED);
   EnableMenuItem(hMenu, IDM_SHOWSTATUS_STATUS, MF_BYCOMMAND | (nStat==6) ? MF_GRAYED : MF_ENABLED);
}

static L_VOID FRAME_OnDestroy (HWND hWnd) 
{
   PostQuitMessage(0);
}

HWND CreateChildWindow (L_TCHAR L_FAR * pszTitle, pBITMAPHANDLE pBitmap, L_INT nBitmapFormat, L_BOOL bIsFile)
{
   HWND            hWndChild;
   CREATEDATA      CreateData;
   MDICREATESTRUCT mdiCreateStruct;

   CreateData.pszTitle      = pszTitle;
   CreateData.pBitmap       = pBitmap;
   CreateData.nBitmapFormat = nBitmapFormat;
   CreateData.bIsFile       = bIsFile;

   mdiCreateStruct.szClass = szChildClass;
   mdiCreateStruct.szTitle = pszTitle;
   mdiCreateStruct.hOwner  = hInst;
   mdiCreateStruct.x       = CW_USEDEFAULT;
   mdiCreateStruct.y       = CW_USEDEFAULT;
   mdiCreateStruct.cx      = CW_USEDEFAULT;
   mdiCreateStruct.cy      = CW_USEDEFAULT;
   mdiCreateStruct.style   = MDIS_ALLCHILDSTYLES|WS_CLIPCHILDREN;
   mdiCreateStruct.lParam  = (LPARAM) (LPCREATEDATA) & CreateData;

   hWndChild = (HWND) SendMessage(hWndClient,
                                  WM_MDICREATE,
                                  0,
                                  (LPARAM) (LPMDICREATESTRUCT) &mdiCreateStruct);
   return hWndChild;
}

L_VOID CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam)
{
   int i=0;

   if(pFOParam!=NULL && pFOParam->pFileData!= NULL )
   {
      for(i=0; i < pFOParam->nNumOfFiles; ++i )
      {
         if(pFOParam->pFileData[i].pBitmap != NULL)
         {
            L_FreeBitmap(pFOParam->pFileData[i].pBitmap);
            GlobalFreePtr(pFOParam->pFileData[i].pBitmap);
         }

         if(pFOParam->pFileData[i].pThumbnail != NULL)
         {
            L_FreeBitmap(pFOParam->pFileData[i].pThumbnail);
            GlobalFreePtr(pFOParam->pFileData[i].pThumbnail);
         }

         if(pFOParam->pFileData[i].pFileInfo != NULL)
         {
            GlobalFreePtr(pFOParam->pFileData[i].pFileInfo);
         }
      }

      GlobalFreePtr(pFOParam->pFileData);

      pFOParam->pFileData    =NULL;
      pFOParam->nNumOfFiles  = 0;
   }
}

L_INT OpenBitmap (HWND hWnd)
{
   static L_INT   nOpenIndex = 0;
   HWND           hChldWnd;
   L_INT          nRet;
   HCURSOR        hOldCur;
   OPENFILENAME   OpenFileName;
   OPENDLGPARAMS  foParm;
   LOADFILEOPTION LoadFileOpt;

   _fmemset(&foParm, 0, sizeof(OPENDLGPARAMS));
   _fmemset(&OpenFileName, 0, sizeof(OPENFILENAME));
   

   foParm.uStructSize =  sizeof(OPENDLGPARAMS);

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.hwndOwner         = hWnd;
   OpenFileName.lpstrFilter       = NULL;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = nOpenIndex;
   OpenFileName.lpstrFileTitle    = NULL;
   OpenFileName.nMaxFileTitle     = 0;
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Open a File");
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = NULL;
   OpenFileName.lpfnHook          = NULL;
   OpenFileName.Flags             = 0;

   foParm.uDlgFlags               = DLG_OPEN_SHOW_PROGRESSIVE |
                                    DLG_OPEN_SHOW_FILEINFO    |
                                    DLG_OPEN_LOADBITMAP       |
                                    DLG_OPEN_SHOW_PREVIEW;

   if(L_DlgOpen(hWnd, &OpenFileName, &foParm) == SUCCESS_DLG_OK)
   {
      hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
      nOpenIndex = OpenFileName.nFilterIndex;

      L_GetDefaultLoadFileOption(&LoadFileOpt, sizeof(LOADFILEOPTION));
      LoadFileOpt.PageNumber = foParm.pFileData[0].nPageNumber;

      nRet = L_LoadBitmap(foParm.pFileData[0].szFileName, foParm.pFileData[0].pBitmap, sizeof(BITMAPHANDLE),0, ORDER_BGRORGRAY, &LoadFileOpt, NULL);

      L_ChangeBitmapViewPerspective(NULL, foParm.pFileData[0].pBitmap,sizeof(BITMAPHANDLE), TOP_LEFT);

      if(nRet == SUCCESS)
         hChldWnd = CreateChildWindow(foParm.pFileData[0].szFileName, foParm.pFileData[0].pBitmap, foParm.pFileData[0].pFileInfo->Format, TRUE);

      SetCursor(hOldCur);

      CleanOpenDlgParam(&foParm);
   }
   return nRet;
}

L_INT PasteBitmap (HWND hWnd)
{
   L_INT        nRet;
   L_TCHAR       szBuffer[256];
   HCURSOR      hOldCur;
   BITMAPHANDLE Bitmap;
   static L_INT nPasteNo = 0;
   
   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE),0, 0, 0);
   nRet = L_CopyFromClipboard(hWnd, &Bitmap,sizeof(BITMAPHANDLE));
   if(nRet == SUCCESS)
   {
      memset(szBuffer, 0, sizeof(szBuffer));
      wsprintf(szBuffer, TEXT("Clipboard Data: %d"), ++nPasteNo);

      L_ChangeBitmapViewPerspective(NULL, &Bitmap,sizeof(BITMAPHANDLE ),TOP_LEFT);

      CreateChildWindow(szBuffer, &Bitmap, 0, FALSE);
      L_FreeBitmap(&Bitmap);
   }
   SetCursor(hOldCur);
   return nRet;
}

static BOOL FRAME_OnQueryNewPalette (HWND hwnd)
{
   HWND hWndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage);

   UNREFERENCED_PARAMETER(hwnd);
   if (IsWindow (hWndChild))
      FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage);
   return(TRUE);
}

L_BOOL CALLBACK L_EXPORT PaletteChangedAll (HWND hWnd, LPARAM lParam)
{
   if(GetParent(hWnd)!=hWndClient)
      return(TRUE);

   if (GetWindow (hWnd, GW_OWNER))
      return(TRUE);

   FORWARD_WM_PALETTECHANGED (hWnd, (HWND) (UINT) (lParam), SendMessage);

   return(TRUE);
}

static VOID FRAME_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteChangedAll, hInst);

   UNREFERENCED_PARAMETER(hWnd);
   EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, (LPARAM) (UINT) hWndPaletteChange);
   FreeProcInstance (lpfn);
   return;
}

VOID  FRAME_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   FRAME_OnPaletteChanged (hWnd, hWndPaletteChange);
}

L_BOOL CALLBACK L_EXPORT PaletteQueryAll(HWND hWnd, LPARAM lParam)
{
   if(GetParent(hWnd)!=hWndClient)
      return(TRUE);

   FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
   return(TRUE);
}

static VOID FRAME_SysColorChange(HWND hwnd)
{
   FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteQueryAll, hInst);

   EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, 0);
   FreeProcInstance (lpfn);
   FRAME_OnQueryNewPalette (hwnd);
   return;
}