/*[]=====================================================================[]*/
/*[]     FRAME Run Time Library - Version 12                             []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1990-2001  by LEAD Technologies, Inc.             []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

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

#include "Segdem.h"

// Global Segmentation and Compression Options variables
SEGMENTATIONOPTIONS  gSegOpt;
SEGMENTEXTOPTIONS    gSegExt;
SEGMENTEXTOPTIONS    gInputImgUserDef;
SEGMENTEXTOPTIONS    gOutputImgUserDef;
PDFDPIOPTIONS        DPIOptions;
L_UINT               uInputImageType;
L_UINT               uOutputImageType;
L_UINT32             guSegFactor;
L_INT                gnQFactor;
L_INT                gnGSQFactor;
L_INT                gnMaskCoder;
L_INT                gnPictureCoder;
L_INT                gnTextCoder2Bit;
L_INT                gnGrayscale8BitCoder;
L_INT                gnGrayscale2BitCoder;
L_BOOL               gbShowSegmentType;
COLORREF             gcrBground;
COLORREF             gcrFground;
L_INT                gnPdfPictureCoder;
L_INT                gnPdfTextCoder2Bit;
L_INT                gnPdfMaskCoder;
L_INT                gnPdfQFactor;
L_INT                bFirstPdfLoaded;

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 fSystemMenu);
static L_BOOL        FRAME_OnCreate          (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static L_VOID        FRAME_OnDestroy         (HWND hWnd);
static L_VOID        FRAME_OnClose           (HWND hWnd);
static BOOL          FRAME_OnQueryNewPalette (HWND hwnd);
static VOID          FRAME_OnPaletteChanging (HWND hwnd, HWND hwndPaletteChange);
static VOID          FRAME_OnPaletteChanged  (HWND hwnd, HWND hwndPaletteChange);
static VOID          FRAME_SysColorChange    (HWND hwnd);
static L_VOID        FRAME_OnDropFiles       (HWND hWnd, HDROP hdrop);

      L_INT          OpenBitmap              (HWND hWnd);
      L_VOID         LoadBitmapFile          (HWND hWnd, L_TCHAR szFileName[MAX_PATH], L_INT nPageNumber);
      L_INT          OpenMRCBitmap           (HWND hWnd);
      L_INT          PasteBitmap             (HWND hWnd);
L_BOOL CALLBACK PdfDPIOptionsProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

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_PALETTECHANGED,   FRAME_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,  FRAME_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_PALETTEISCHANGING,FRAME_OnPaletteChanging);
      HANDLE_MSG (hwnd, WM_SYSCOLORCHANGE,   FRAME_SysColorChange);
      HANDLE_MSG (hwnd, WM_COMMAND,          FRAME_OnCommand);
      HANDLE_MSG (hwnd, WM_CLOSE,            FRAME_OnClose);
      HANDLE_MSG (hwnd, WM_DROPFILES,        FRAME_OnDropFiles);
   }
   return DefFrameProc (hwnd, hwndClient, message, wParam, lParam);
}

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

   switch (id)
   {
   case IDM_FILE_OPENMRC:
      OpenMRCBitmap(hWnd);
      return;
   case IDM_FILE_OPENBITMAP:
      OpenBitmap(hWnd);
      return;
   case IDM_FILE_CLOSE:
      hwndChild = (HWND) SendMessage(hwndClient, WM_MDIGETACTIVE, 0, 0);

      if (SendMessage(hwndChild, WM_QUERYENDSESSION, 0, 0))
         SendMessage (hwndClient, WM_MDIDESTROY, (WPARAM) hwndChild, 0);
      return;
   case IDM_FILE_EXIT:
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      return;
   case IDM_EDIT_PASTE:
      PasteBitmap(hWnd);
      return;
   case IDM_WINDOW_TILEHORZ:
      FORWARD_WM_MDITILE(hwndClient, MDITILE_HORIZONTAL, SendMessage);
      return;
   case IDM_WINDOW_TILEVERT:
      FORWARD_WM_MDITILE(hwndClient, MDITILE_VERTICAL, SendMessage);
      return;
   case IDM_WINDOW_CASCADE:
      SendMessage(hwndClient, WM_MDICASCADE, 0, 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:
      hwndChild = (HWND) SendMessage (hwndClient, WM_MDIGETACTIVE, 0, 0);

   if (IsWindow (hwndChild))
      SendMessage(hwndChild, 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 FAR * lpCreateStruct)
{
   CLIENTCREATESTRUCT clientcreate;

   SET_SIZE(&gSegOpt);
   gSegOpt.uCombineFlags   = COMBINE_TRY;
   gSegOpt.uCombineFactor  = 30;

   SET_SIZE(&gSegExt);
   gSegExt.uBackGroundThreshold = 15;
   gSegExt.uSegmentQuality = 50;
   gSegExt.uColorThreshold = 25;
   gSegExt.uCleanSize = 7;
   gSegExt.uCombineThreshold = 100;
   gSegExt.uFlags = 0;
   gSegExt.uFlags = SGM_FAVOR_TWOBIT | SGM_WITHOUTBKGRND;
   uInputImageType  = 0;
   uOutputImageType = 0;
   DPIOptions.nXResolution = 150;
   DPIOptions.nYResolution = 150;

   bFirstPdfLoaded = FALSE;

   gInputImgUserDef  = gSegExt;
   gOutputImgUserDef = gSegExt;

   gbShowSegmentType       = TRUE;

   gnPdfQFactor          = 50;
   gnQFactor             = 50;
   gnGSQFactor           = 50;
   gnMaskCoder           = MRC_MASK_COMPRESSION_JBIG;
   gnPictureCoder        = MRC_PICTURE_COMPRESSION_JPEG_YUV411;
   gnTextCoder2Bit       = MRC_TEXT_COMPRESSION_JBIG_2BIT;
   gnGrayscale8BitCoder  = MRC_GRAYSCALE_COMPRESSION_GRAYSCALE_JPEG_8BIT;
   gnGrayscale2BitCoder  = MRC_GRAYSCALE_COMPRESSION_JBIG_2BIT;
   gcrBground            = RGB(255, 255, 255);
   gcrFground            = RGB(0, 0, 0);

   gnPdfPictureCoder     = 2;

   clientcreate.hWindowMenu  = hMenuInitWindow;
   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,
                             hInstMain,
                             (PSTR) &clientcreate);

   if (hwndClient)
      UNLOCKSUPPORT();

   /* Enable Drag and Drop Files */
   DragAcceptFiles(hWnd, TRUE);

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

static L_VOID FRAME_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, L_BOOL fSystemMenu)
{
   L_BOOL      bClipboardReady, bSelection, bSingleSelection;
   HWND        hChildWnd;
   LPCHILDDATA pData;

   bClipboardReady = L_ClipboardReady();
   
   hChildWnd = FORWARD_WM_MDIGETACTIVE (hwndClient, SendMessage);
   if (hChildWnd)
   {
      pData = (LPCHILDDATA) GetWindowLong(hChildWnd, GWL_USERDATA);
      if (pData)
      {
         bSelection = (FindSelectionCount(pData) > 0);
         bSingleSelection = (FindSelectionCount(pData) == 1);

         EnableMenuItem((HMENU)hMenu, ID_FILE_EXPORTSEGMENTS, (pData->hSegment != NULL) ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_UNDO, (pData->hPrevSegment != NULL) ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_AUTO_MANUAL_SEGMENTATION, pData->nSegments > 0 ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_DRAW_SEGMENT, pData->bDrawSegment ? MF_GRAYED : MF_ENABLED);
         EnableMenuItem((HMENU)hMenu, IDM_DRAW_CANCELRECT, pData->bDrawSegment ? MF_ENABLED : MF_GRAYED);

         EnableMenuItem((HMENU)hMenu, IDM_SEGMENTTYPE, bSingleSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_SEGMENTHISTOGRAM, bSingleSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_SHOWSEGPROP, bSingleSelection? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_SELECTALLSEGMENTS, (pData->nSegments > 0) && (FindSelectionCount(pData) != pData->nSegments) ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_DELETESEGMENT, bSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_DESELECTALL, bSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_SHOWINNEWWINDOW, bSingleSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_ENLARGESEGMENT, bSingleSelection ? MF_ENABLED : MF_GRAYED);

         EnableMenuItem((HMENU)hMenu, IDM_SEGMENTUNIQUECOLORS, bSingleSelection ? MF_ENABLED : MF_GRAYED);
         EnableMenuItem((HMENU)hMenu, IDM_COMBINESEGMENTS, FindSelectionCount(pData) > 1 ? MF_ENABLED : MF_GRAYED);

         CheckMenuItem ((HMENU)hMenu, IDM_SHOWSEGMENTTYPE, gbShowSegmentType ? MF_CHECKED : MF_UNCHECKED);
         CheckMenuItem ((HMENU)hMenu, IDM_DRAW_SEGMENT, pData->bDrawSegment? MF_CHECKED : MF_UNCHECKED);
         CheckMenuItem ((HMENU)hMenu, IDM_FITTOWINDOW, pData->bFitToWindow?  MF_CHECKED : MF_UNCHECKED);
         CheckMenuItem ((HMENU)hMenu, IDM_ZOOMING_NORMAL, !pData->bFitToWindow && (pData->fZoomVal == 100)?  MF_CHECKED : MF_UNCHECKED);
         if (pData->nSegments > 0)
             EnableMenuItem((HMENU)hMenu, IDM_CLEAR_SEGMENTS, MF_ENABLED);
         else
             EnableMenuItem((HMENU)hMenu, IDM_CLEAR_SEGMENTS, MF_GRAYED);
      }
   }
   EnableMenuItem(hMenu, IDM_EDIT_PASTE, MF_BYCOMMAND | ((bClipboardReady) ? MF_ENABLED : MF_GRAYED));
}

static L_VOID FRAME_OnDropFiles(HWND hWnd, HDROP hdrop)
{
   L_TCHAR  szDropedFileName[256];
   L_INT    nFilesCount, nFiles;

   memset(szDropedFileName, 0, 256);
   // Get draged files count
   nFilesCount = DragQueryFile(hdrop, 0xFFFFFFFF, NULL, 0);

   for (nFiles = 0; nFiles < nFilesCount; nFiles++)
   {
      // Get File Name
      DragQueryFile(hdrop, nFiles, szDropedFileName, 256);
      
      // Load the file
      LoadBitmapFile(hWnd, szDropedFileName, 0);
   }
}

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

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

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 OpenMRCBitmap(HWND hWnd)
{
   HCURSOR        hOldCur;
   OPENFILENAME   OpenFileName;
   BITMAPHANDLE   Bitmap;
   L_TCHAR        szOpenFileFilter[] = TEXT("MRC\0")TEXT("*.mrc;*.tif\0");
   OPENDLGPARAMS  foParm;
   L_INT          nRet, nPage = 0;
   HWND           hChldWnd;
   
   memset(&foParm, 0, sizeof(OPENDLGPARAMS));

   foParm.uStructSize  = sizeof(OPENDLGPARAMS);

   memset(&OpenFileName, 0, sizeof(OPENFILENAME));
   
   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.hwndOwner         = hWnd;
   OpenFileName.lpstrFilter       = szOpenFileFilter;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 1;
   OpenFileName.lpstrFileTitle    = NULL;
   OpenFileName.nMaxFileTitle     = 0;
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Open MRC");
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = NULL;
   OpenFileName.lpfnHook          = NULL;
   foParm.uDlgFlags               = DLG_OPEN_SHOW_MULTIPAGE;

   nRet = L_DlgOpen(hWnd,&OpenFileName, &foParm);

   if (nRet == SUCCESS_DLG_OK)
   {
      hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
      
      L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE),0, 0, 0);
      
      nRet = L_MrcLoadBitmap(foParm.pFileData[ 0 ].szFileName, &Bitmap, sizeof(BITMAPHANDLE),foParm.pFileData[ 0 ].nPageNumber, NULL, NULL);
      if (nRet == SUCCESS)
      {
         L_FreeBitmapRgn(&Bitmap);
         hChldWnd = CreateChildWindow(foParm.pFileData[ 0 ].szFileName, &Bitmap, TRUE);
         FORWARD_WM_QUERYNEWPALETTE (hChldWnd, SendMessage);
         InvalidateRect (hChldWnd, NULL, TRUE);
      }
      else
         MessageBox(hWnd, TEXT("An error occurred while trying to load the MRC file."), TEXT("Error"), MB_OK);

      SetCursor(hOldCur);

      CleanOpenDlgParam(&foParm);
   }

   return nRet;
}

L_INT OpenBitmap(HWND hWnd)
{
   OPENFILENAME   OpenFileName;
   L_TCHAR        szOpenFileFilter[] = TEXT("ALL\0")TEXT("*.*\0");
   OPENDLGPARAMS  foParm;
   L_INT          nRet;
   FILEPDFOPTIONS PdfOptions;
   
   memset(&foParm, 0, sizeof(foParm));

   foParm.uStructSize = sizeof(foParm);

   memset(&OpenFileName, 0, sizeof(OpenFileName));
   
   L_GetPDFOptions( &PdfOptions, sizeof(FILEPDFOPTIONS) );
   PdfOptions.nXResolution = DPIOptions.nXResolution;
   PdfOptions.nYResolution = DPIOptions.nYResolution;
   L_SetPDFOptions( &PdfOptions );

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.hwndOwner         = hWnd;
   OpenFileName.lpstrFilter       = szOpenFileFilter;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 1;
   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;

   
    if(bFirstPdfLoaded)
    {
       foParm.uDlgFlags                 = DLG_OPEN_SHOW_PREVIEW |
                                          DLG_OPEN_SHOW_MULTIPAGE |
                                          DLG_OPEN_SHOW_PROGRESSIVE|
                                          DLG_OPEN_SHOW_LOADROTATED|
                                          DLG_OPEN_SHOW_LOADCOMPRESSED|
                                          DLG_OPEN_SHOW_FILEINFO|
                                          DLG_OPEN_USEFILESTAMP|
                                          DLG_OPEN_SHOW_PDFOPTIONS|
                                          DLG_OPEN_SHOW_LOADOPTIONS ;
    }
    else
    {
       foParm.uDlgFlags                 = DLG_OPEN_SHOW_PREVIEW |
                                          DLG_OPEN_SHOW_MULTIPAGE |
                                          DLG_OPEN_SHOW_PROGRESSIVE|
                                          DLG_OPEN_SHOW_LOADROTATED|
                                          DLG_OPEN_SHOW_LOADCOMPRESSED|
                                          DLG_OPEN_SHOW_FILEINFO|
                                          DLG_OPEN_USEFILESTAMP|
                                          DLG_OPEN_SHOW_LOADOPTIONS ;
    }
   
   nRet = L_DlgOpen(hWnd, &OpenFileName, &foParm);

   if (nRet == SUCCESS_DLG_OK)
   {
      if( FILE_RAS_PDF == foParm.pFileData->FileOptions.nType )
      {
          if(!bFirstPdfLoaded)
         {
             nRet =  DoDialogBoxParam(IDD_PDFDPIOPTIONS, hWnd, (DLGPROC) PdfDPIOptionsProc, 0);
             if( nRet == IDOK )
             {
                ( ( LPOPENDLGOPTIONS_PDF ) foParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions.nXResolution =  DPIOptions.nXResolution;
                ( ( LPOPENDLGOPTIONS_PDF ) foParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions.nYResolution =  DPIOptions.nYResolution;
                bFirstPdfLoaded = TRUE;
             }
          }
          
          DPIOptions.nXResolution = ( ( LPOPENDLGOPTIONS_PDF )foParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions.nXResolution;
          DPIOptions.nYResolution = ( ( LPOPENDLGOPTIONS_PDF )foParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions.nYResolution;
         L_SetPDFOptions( &( ( LPOPENDLGOPTIONS_PDF ) foParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions );
      }

      LoadBitmapFile(hWnd, foParm.pFileData[0].szFileName, foParm.pFileData[0].nPageNumber);
      CleanOpenDlgParam(&foParm);
   }
   return nRet;
}

L_VOID LoadBitmapFile(HWND hWnd, L_TCHAR szFileName[MAX_PATH], L_INT nPageNumber)
{
   L_INT          nRet;
   HCURSOR        hOldCur;
   BITMAPHANDLE   Bitmap;
   LOADFILEOPTION LoadFileOpt;
   HWND           hChldWnd;

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   
   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE),0, 0, 0);

   L_GetDefaultLoadFileOption(&LoadFileOpt, sizeof(LoadFileOpt));
   LoadFileOpt.PageNumber = nPageNumber;
   
   nRet = L_LoadBitmap(szFileName, &Bitmap, sizeof(BITMAPHANDLE),0, ORDER_BGRORGRAY, &LoadFileOpt, NULL);
   
   if (nRet == SUCCESS)
   {
      L_FreeBitmapRgn(&Bitmap);
      hChldWnd = CreateChildWindow(szFileName, &Bitmap, TRUE);
      FORWARD_WM_QUERYNEWPALETTE (hChldWnd, SendMessage);
      InvalidateRect (hChldWnd, NULL, TRUE);
   }
   else
      if(nRet == ERROR_PDF_BAD_INITIALIZATION_FILES)
      {
         if( IDYES == MessageBox ( hWnd,TEXT("LEADTOOLS PDF plugin is not found, do you want to download the plugin now?"),
                                   TEXT("Open File"),MB_ICONEXCLAMATION | MB_YESNO))
         {
            ShellExecute(hWnd, TEXT("open"), TEXT("http://www.leadtools.com/ReleaseDownloads/v14/LEADTOOLSPDFRuntime.exe"), 
                         NULL, NULL, SW_SHOWNORMAL);
         }
      }
      else
         MessageBox(hWnd, TEXT("Could not load the bitmap."), TEXT("Error"), MB_OK);
   SetCursor(hOldCur);
}

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

   memset (&CreateData, 0, sizeof(CREATEDATA));
   memset (&mdiCreateStruct, 0, sizeof(MDICREATESTRUCT));

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

   mdiCreateStruct.szClass = szChildClass;
   mdiCreateStruct.szTitle = pszTitle;
   mdiCreateStruct.hOwner  = hInstMain;
   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_INT PasteBitmap(HWND hWnd)
{
   static L_INT nPasteNo = 0;
   HCURSOR      hOldCur;
   BITMAPHANDLE Bitmap;
   L_TCHAR      szBuffer[256];
   L_BOOL       bRet;

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE),0, 0, 0);
   bRet = L_CopyFromClipboard(hWnd, &Bitmap,sizeof(BITMAPHANDLE));
   if (bRet == TRUE)
   {
      memset(szBuffer, 0, sizeof(szBuffer));
      wsprintf(szBuffer, TEXT("Clipboard Data: %d."), ++nPasteNo);
      L_FreeBitmapRgn(&Bitmap);
      CreateChildWindow(szBuffer, &Bitmap, FALSE);
      L_FreeBitmap(&Bitmap);
   }

   SetCursor(hOldCur);
   return bRet;
}

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

   EnumChildWindows (hwndClient, (WNDENUMPROC) lpfn, (LPARAM) (UINT) hWndPaletteChange);
   FreeProcInstance (lpfn);
   return;
}
static VOID  FRAME_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   FRAME_OnPaletteChanged (hWnd, hWndPaletteChange);
}


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

   if (IsWindow (hWndChild))
   {
      FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage);
      return(TRUE);
   }
   return FALSE;
}

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

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

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

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

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