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

#include "CSDem32.h"

/*--------------------Handle Message function decleration ---------------------*/
static  L_BOOL Child_OnCreate          (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static  L_VOID Child_OnPaint           (HWND hWnd);
static  L_VOID Child_OnCommand         (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify);
        L_VOID Child_OnSize            (HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy);
static  L_VOID Child_OnMDIActivate     (HWND hWnd, L_BOOL fActive, HWND hWndActivate, HWND hWndDeactivate);
static  L_VOID Child_OnClose           (HWND hWnd);
static  L_VOID Child_OnDestroy         (HWND hWnd);
static  L_VOID Child_OnHScroll         (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static  L_VOID Child_OnVScroll         (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static  L_BOOL Child_OnEraseBkgnd      (HWND hWnd, HDC hDC);
static  L_VOID Child_OnPaletteChanged  (HWND hWnd, HWND hWndPaletteChange);
static  L_BOOL Child_OnQueryNewPalette (HWND hWnd);
static  L_VOID Child_OnMouseMove       (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags);

/*-----------------------functions decleration---------------------------------*/
L_INT L_FAR L_EXPORT 
        StatusBarProgressCallBack      (L_INT nPercent, L_VOID L_FAR * pUserData);
L_INT   SaveBitmapFile                 (HWND hWnd);
L_VOID  SetStatusBarText               (LPTSTR pTitle, pBITMAPHANDLE pBitmap, LPTSTR szPos, LPTSTR szColor);
L_INT   OpenBitmapChild                (LPSTR szFileName);
L_VOID  SetStatusColorAndPixel         (HWND hWnd);
L_INT   GetProcPixel                   (pBITMAPHANDLE pBitmap);
L_VOID  CleanOpenDlgParam              (LPOPENDLGPARAMS pFOParam);
L_INT   ShowICCProfileLoadDialog       (HWND hWnd);

/*--------global variable -----*/

COLORREF       crColor;
L_BOOL         bInScroll = FALSE;
static L_INT   nCount = 0;

/*-----------------------------*/
/*====(ChildWindowProc)====================================================
Description: Processes child window messages.

Syntax     : LRESULT CALLBACK L_EXPORT ChildWindowProc(HWND hWnd, L_UINT Msg, 
                                                       WPARAM wParam, 
                                                       LPARAM lParam)

Prototype  : demo.h

Parameters : hWnd          Handle of a window.
             Msg           Message to be processed.
             wParam        First uMessage parameter.
             lParam        Second uMessage parameter.

Return Value: Depends on the uMessage.
==========================================================================*/
LRESULT CALLBACK ChildWndProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
      HANDLE_MSG (hWnd, WM_CREATE,          Child_OnCreate);
      HANDLE_MSG (hWnd, WM_PAINT,           Child_OnPaint);
      HANDLE_MSG (hWnd, WM_COMMAND,         Child_OnCommand);
      HANDLE_MSG (hWnd, WM_SIZE,            Child_OnSize);
      HANDLE_MSG (hWnd, WM_MDIACTIVATE,     Child_OnMDIActivate);
      HANDLE_MSG (hWnd, WM_CLOSE,           Child_OnClose);
      HANDLE_MSG (hWnd, WM_DESTROY,         Child_OnDestroy);
      HANDLE_MSG (hWnd, WM_HSCROLL,         Child_OnHScroll);
      HANDLE_MSG (hWnd, WM_VSCROLL,         Child_OnVScroll);
      HANDLE_MSG (hWnd, WM_ERASEBKGND,      Child_OnEraseBkgnd);
      HANDLE_MSG (hWnd, WM_PALETTECHANGED,  Child_OnPaletteChanged);
      HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette);
      HANDLE_MSG (hWnd, WM_MOUSEMOVE,       Child_OnMouseMove);

   case WM_USER_CHANGECURSOR:
      SetCursor(LoadCursor((HINSTANCE)wParam, (LPTSTR)lParam));
      break;
   }
   return DefMDIChildProc(hWnd, uMessage, wParam, lParam);
}

/*====(Child_OnCreate)=====================================================
Description: Creates an MDI child window. The image can come from a file or
             the clipboard.

Syntax     : BOOL Child_OnCreate(HWND hWnd, CREATESTRUCT FAR* lpCreateStruct)

Parameters : hWnd             Handle of a window.
             lpCreateStruct   Pointer to CREATESTRUCT

Return Value: TRUE            The function was successful.
              FALSE           The function was not successful.
==========================================================================*/
static L_BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
   HANDLE       hMem;
   HDC          hdcCompatibile;
   pCHILDDATA   pData;
   LPCREATEDATA pCreateData;

   //Allocate memory for window private data
   pCreateData = (LPCREATEDATA)CHILDCREATELPARAM(lpCreateStruct);

   if(!pCreateData)
      return FALSE;

   hMem = GlobalAlloc (GHND, sizeof (CHILDDATA));
   SETCHILDDATA (hWnd, hMem);
   if(!hMem)
      return(FALSE);

   pData = LOCKCHILDDATA (hWnd);

   pData->pszTitle         = GlobalAllocPtr(GHND, ( (lstrlen(pCreateData->pszTitle) + 1) * sizeof(L_TCHAR)));
   pData->hBitmapWnd       = hWnd;
   IsDecimal               = 1;

   if(pData->pszTitle)
      lstrcpy(pData->pszTitle, pCreateData->pszTitle);

   L_CopyBitmapHandle(&pData->LeadBitmap, pCreateData->pBitmap, sizeof(BITMAPHANDLE));
   pData->nBitmapFormat = pCreateData->nBitmapFormat;
   hdcCompatibile = GetDC(hWnd);
   pData->hPalette = L_CreatePaintPalette(hdcCompatibile, &pData->LeadBitmap);

   ReleaseDC(hWnd, hdcCompatibile);

   SetRect(&pData->rcView, 0, 0, BITMAPWIDTH(&pData->LeadBitmap), BITMAPHEIGHT(&pData->LeadBitmap));
   SetWindowLong(hWnd, GWL_USERDATA, (long)pData);

   // Save some window handles
   hWndClient = GetParent(hWnd);
   hWndFrame  = GetParent(hWndClient);
   memset(szColor, 0, 20);
   memset(szPos, 0, 20);
   FileInit(hWnd);
   pData->bAutoHandle = TRUE;

   Child_OnQueryNewPalette(hWnd);
   UNLOCKCHILDDATA(hWnd);
   //UNDOLIST//
   L_UndoList_Init (hWnd, FreeFun, 20);
   return TRUE;
}

/*====(Child_OnPaint)======================================================
Description: Paints the child window.

Syntax     : VOID Child_OnPaint(HWND hWnd)

Parameters : hWnd          Handle of the child window.

Return Value: None.
==========================================================================*/

static L_VOID Child_OnPaint (HWND hWnd)
{
   HDC          hdc;
   HPALETTE     hSavedPalette = NULL;
   HPALETTE     hPalette = NULL;
   PAINTSTRUCT  ps;
   pCHILDDATA   pData;
   BITMAPHANDLE TmpBitmapHandle;
   RECT         rcView;
   HBITMAP      hBitmap;

   pData = LOCKCHILDDATA (hWnd);
   if (!pData->LeadBitmap.Flags.Allocated)
      return;

   hdc = BeginPaint(hWnd, &ps);
   hPalette = L_CreatePaintPalette(hdc, &pData->LeadBitmap);
   if (hPalette)
   {
      hSavedPalette = SelectPalette (hdc, hPalette, FALSE);
      RealizePalette (hdc);
   }
   
   if(StatusProc.bStillWork)
   {
      if((abs(StatusProc.nStatusCnt - StatusProc.nOldStatusCnt)  > StatusProc.nPercent))
      {
         L_PaintDC(hdc, &pData->LeadBitmap, NULL, NULL, &pData->rcView, NULL, SRCCOPY);
         StatusProc.nOldStatusCnt = StatusProc.nStatusCnt;
      }
   }
   else
   {
      L_PaintDC(hdc, &pData->LeadBitmap, NULL, NULL, &pData->rcView, NULL, SRCCOPY);
   }

   
   if (pData->bCross)
   {
      hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_CROSS));
      L_ConvertFromDDB(hdc, &TmpBitmapHandle, sizeof(BITMAPHANDLE), hBitmap, NULL);
      rcView.left   = pData->ptCenter.x + pData->rcView.left  - 15;
      rcView.top    = pData->ptCenter.y + pData->rcView.top - 15;
      rcView.right  = pData->ptCenter.x + pData->rcView.left + 15;
      rcView.bottom = pData->ptCenter.y + pData->rcView.top + 15;
      
      L_PaintDC(hdc, &TmpBitmapHandle, NULL, NULL, &rcView, NULL, SRCINVERT);
      L_FreeBitmap(&TmpBitmapHandle);
      DeleteBitmap(hBitmap);
   }

   if (hSavedPalette)
      SelectPalette (hdc, hSavedPalette, FALSE);
   if(hPalette)
         DeleteObject (hPalette);
   EndPaint(hWnd, &ps);

   UNLOCKCHILDDATA(hWnd);

}
/*====(Child_OnPaletteChanged)==============================================
Description: Processes WM_PALETTECHANGED uMessage for a child window.

Syntax     : VOID Child_OnPaletteChanged(HWND hWnd, HWND hWndPaletteChange)

Parameters : hWnd                 Handle of a window.
             hWndPaletteChange    Handle of the window that has the palette
                                  realized.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   HDC        hDC;
   HPALETTE   hOldPal;
   pCHILDDATA pData;

   if(hWnd == hWndPaletteChange)
      return;

   pData = LOCKCHILDDATA (hWnd);
   if(pData->hPalette)
   {
      hDC = GetDC(hWnd);
      hOldPal = SelectPalette(hDC, pData->hPalette, TRUE);
      RealizePalette(hDC);
      InvalidateRect(hWnd, NULL, FALSE);
      SelectPalette(hDC, hOldPal, TRUE);
      ReleaseDC(hWnd, hDC);
   }
   UNLOCKCHILDDATA(hWnd);
}
/*====(BmpWnd_OnVScroll)====================================================
Description: Scrolls the child window vertically.

Syntax     : VOID BmpWnd_OnVScroll(HWND hWnd, HWND hWndCtl, L_UINT nCode, 
                                  L_INT nPos)

Parameters : hWnd          Handle of a window.
             hWndCtl       Not used.
             nCode         Amount/Direction to be scrolled.
             npos          The new position of the thumb.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   L_INT      nScrollInc;
   pCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = LOCKCHILDDATA (hWnd);
   bInScroll = TRUE;

   switch (nCode)
   {
   case SB_BOTTOM:
      nScrollInc = pData->nVScrollMax - pData->nVScrollPos;
      break;
   case SB_TOP:
      nScrollInc = -pData->nVScrollPos; 
      break;
   case SB_LINEDOWN:
      nScrollInc = pData->nVScrollStep;
      break;
   case SB_LINEUP:
      nScrollInc = -pData->nVScrollStep;
      break;
   case SB_PAGEDOWN:
      nScrollInc = max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep));
      break;
   case SB_PAGEUP:
      nScrollInc = -max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep));
      break;
   case SB_THUMBTRACK:
   case SB_THUMBPOSITION:
      nScrollInc = nPos - pData->nVScrollPos;
      break;
   default:
      nScrollInc = 0;
      break;
   }
   nScrollInc = max(-pData->nVScrollPos, 
                min(nScrollInc, (pData->nVScrollMax - pData->nVScrollPos)));
   if(nScrollInc)
   {
      pData->nVScrollPos += nScrollInc;
      OffsetRect(&pData->rcView, 0, -nScrollInc);
      ScrollWindow(hWnd, 0, -nScrollInc, NULL, NULL);
      SetScrollPos(hWnd, SB_VERT, pData->nVScrollPos, TRUE);
      UpdateWindow(hWnd);
   }
   bInScroll = FALSE;
   UNLOCKCHILDDATA(hWnd);
}
/*====(BmpWnd_OnHScroll)====================================================
Description: Scrolls the child window horizontally.

Syntax     : VOID BmpWnd_OnHScroll(HWND hWnd, HWND hWndCtl, L_UINT nCode, 
                                  L_INT npos)

Parameters : hWnd          Handle of a window.
             hWndCtl       Not used.
             nCode         Amount/Direction to be scrolled.
             npos          The new position of the thumb.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   L_INT      nHScrollInc;
   pCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = LOCKCHILDDATA (hWnd);
   if(!pData)
      return;
   bInScroll = TRUE;

   switch (nCode)
   {
   case SB_LEFT:
      nHScrollInc = -pData->nHScrollPos;
      break;
   case SB_RIGHT:
      nHScrollInc = pData->nHScrollMax - pData->nHScrollPos;
      break;
   case SB_LINELEFT:
      nHScrollInc = -pData->nHScrollStep;
      break;
   case SB_LINERIGHT:
      nHScrollInc = pData->nHScrollStep;
      break;
   case SB_PAGELEFT:
      nHScrollInc = -max(pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep));
      break;
   case SB_PAGERIGHT:
      nHScrollInc = max(pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep));
      break;
   case SB_THUMBPOSITION:
   case SB_THUMBTRACK:
      nHScrollInc = nPos - pData->nHScrollPos;
      break;
   default:
      nHScrollInc = 0;
      break;
   }
   nHScrollInc = max (-pData->nHScrollPos, min (nHScrollInc, (pData->nHScrollMax - pData->nHScrollPos)));
   if (nHScrollInc)
   {
      pData->nHScrollPos += nHScrollInc;
      OffsetRect(&pData->rcView, -nHScrollInc, 0);
      ScrollWindow(hWnd, -nHScrollInc, 0, NULL, NULL);
      SetScrollPos(hWnd, SB_HORZ, pData->nHScrollPos, TRUE);
      UpdateWindow(hWnd);
   }
   bInScroll = FALSE;
   UNLOCKCHILDDATA(hWnd);
}

/*====(BmpWnd_OnEraseBkgnd)=================================================
Description: Erases the background of a child window.

Syntax     : BOOL BmpWnd_OnEraseBkgnd(HWND hWnd, HDC hDC)

Parameters : hWnd          Handle to the child window.
             hDC           Handle to the device context.

Return Value: TRUE         The function was successful.
==========================================================================*/
static L_BOOL Child_OnEraseBkgnd (HWND hWnd, HDC hDC)
{
   HRGN       hClientRgn, hFillRgn;
   RECT       rcView, rcClient;
   HGDIOBJ    hBrush;
   pCHILDDATA pData;

   pData = LOCKCHILDDATA (hWnd);

   if(IsIconic(hWnd))
      hBrush = GetStockObject(BLACK_BRUSH);
   else
      hBrush = GETHBRBACKGROUND(hWnd);

   GetClientRect(hWnd, &rcClient);
   GetUpdateRect(hWnd, &rcView, 0);

   if(bInScroll || pData->LeadBitmap.Flags.Allocated)
   {
      IntersectRect(&rcView, &pData->rcView, &rcClient);
      hClientRgn = CreateRectRgnIndirect(&rcClient);
      hFillRgn = CreateRectRgnIndirect(&rcView);
      CombineRgn(hFillRgn, hClientRgn, hFillRgn, RGN_DIFF);
      FillRgn(hDC, hFillRgn, hBrush);
      DeleteObject(hFillRgn);
      DeleteObject(hClientRgn);
   }
   else
      FillRect(hDC, &rcClient, hBrush);
   UNLOCKCHILDDATA(hWnd);
   return TRUE;
}

L_VOID MySetScrollRange(HWND hwnd, L_INT nBar, L_INT32 nMinPos, L_INT32 nMaxPos, L_INT32 lStep, BOOL bRedraw)
{
#ifdef WIN32
   SCROLLINFO  ScrollInfo;
   ScrollInfo.cbSize = sizeof(SCROLLINFO);
   ScrollInfo.fMask = SIF_RANGE|SIF_PAGE;
   ScrollInfo.nPage = lStep;
   ScrollInfo.nMin = nMinPos;
   ScrollInfo.nMax = nMaxPos + ScrollInfo.nPage - 1;
   SetScrollInfo (hwnd, nBar, &ScrollInfo, bRedraw);
#else
   SetScrollRange(hwnd, nBar, (int)nMinPos, (int)nMaxPos, bRedraw);
#endif
}

/*====(Child_OnSize)=======================================================
Description: Responds to WM_SIZE uMessage and sets the internal data
             accordingly. Also forwards the uMessage to DefMDIChildProc.

Syntax     : VOID Child_OnSize(HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy)

Parameters : hWnd          Handle to the child window.
             nState        State of resizing requested.
             nCx           Size to be used for the "x" direction.
             nCy           Size to be used for the "y" direction.

Return Value: None.
==========================================================================*/

L_VOID Child_OnSize (HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy)
{
   static L_BOOL fSizeInUse = FALSE;
   L_INT      nWidth;
   L_INT      nHeight;
   L_INT      nVScroll;
   L_INT      nHScroll;
   DWORD      dwStyle;
   pCHILDDATA pData;
   L_INT      nHScrollFactor;
   L_INT      nVScrollFactor;

   pData = LOCKCHILDDATA (hWnd);
   if(!pData)
      return;

   if (!fSizeInUse)
   {
      fSizeInUse = TRUE;

      if (!IsIconic(hWnd))// if window is normal
      {
         if (!pData->LeadBitmap.Flags.Allocated)
         {
            /* if bitmap is not allocated then set width and height to ZERO */
            nWidth = 0;
            nHeight = 0;
         }
         else // if bitmap is allocated, then set the width and height to bitmap width and height
         {
            nWidth = BITMAPWIDTH(&pData->LeadBitmap);
            nHeight= BITMAPHEIGHT(&pData->LeadBitmap);
         }

         // Set client dimensions to current width and height
         pData->cxClient = nCx;
         pData->cyClient = nCy;

         dwStyle  = GetWindowLong (hWnd, GWL_STYLE);
         nVScroll = GetSystemMetrics (SM_CXVSCROLL); // Get Vertical scroll arrow width
         nHScroll = GetSystemMetrics (SM_CXHSCROLL); // Get Horizontal scroll arrow width

         if (WS_VSCROLL & dwStyle)// if Vertical scroll
            pData->cxClient += nVScroll;

         if (WS_HSCROLL & dwStyle)// if Horizontal scroll
            pData->cyClient += nHScroll;

         if (pData->cxClient <= nWidth)// if client width  < current width
         {
            pData->cyClient -= nHScroll;
            if (pData->cyClient <= nHeight)
               pData->cxClient -= nVScroll;
         }
         else if (pData->cyClient <= nHeight)// if client height < current height
         {
            pData->cxClient -= nVScroll;
            if (pData->cxClient <= nWidth)
               pData->cyClient -= nHScroll;
         }

         pData->nVScrollStep = max (1, pData->cyClient / SCROLL_RATIO);
         pData->nHScrollStep = max (1, pData->cxClient / SCROLL_RATIO);

         pData->nVScrollMax  = max (0, (nHeight - pData->cyClient));
         pData->nHScrollMax  = max (0, (nWidth - pData->cxClient));

         pData->nVScrollPos  = max (0, min (pData->nVScrollPos, pData->nVScrollMax));
         pData->nHScrollPos  = max (0, min (pData->nHScrollPos, pData->nHScrollMax));

         if (pData->LeadBitmap.Flags.Allocated)
         {
            SetRect (&pData->rcView, 0, 0, nWidth, nHeight);
            OffsetRect (&pData->rcView, -pData->nHScrollPos, -pData->nVScrollPos);
         }

         nHScrollFactor = 0;
         while((pData->nHScrollMax >> nHScrollFactor) > 0x7FFF)
            nHScrollFactor++;

         MySetScrollRange (pData->hBitmapWnd, SB_HORZ, 0, pData->nHScrollMax >> nHScrollFactor, 
            max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)),
            FALSE);
         SetScrollPos (pData->hBitmapWnd, SB_HORZ, pData->nHScrollPos >> nHScrollFactor, TRUE);

         nVScrollFactor = 0;
         while((pData->nVScrollMax >> nVScrollFactor) > 0x7FFF)
            nVScrollFactor++;

         MySetScrollRange (pData->hBitmapWnd, SB_VERT, 0, pData->nVScrollMax >> nVScrollFactor, 
            max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)),
            FALSE);
         SetScrollPos (pData->hBitmapWnd, SB_VERT, pData->nVScrollPos >> nVScrollFactor, TRUE);
      }
      else // if window is iconized
      {
         // Retain the x-client and y-client area 
         pData->cxClient = nCx;
         pData->cyClient = nCy;
         // set client area 
         SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient);
      }
      fSizeInUse = FALSE;
   }
   UNLOCKCHILDDATA(hWnd);
   FORWARD_WM_SIZE(hWnd, nState, nCx, nCy, DefMDIChildProc);
}

/*====(Child_OnQueryNewPalette)============================================
Description: Processes WM_QUERYNEWPALETTE uMessage for a child window.

Syntax     : BOOL Child_OnQueryNewPalette(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: nNoColors    Number of colors changed in the palette.
==========================================================================*/
static L_BOOL Child_OnQueryNewPalette (HWND hWnd)
{
   HDC         hDC;
   L_INT       nNoColors = 0;
   HPALETTE    hOldPal;
   pCHILDDATA pData;
   
   pData = LOCKCHILDDATA (hWnd);

   if(pData->hPalette)
   {
      DeleteObject(pData->hPalette);
      pData->hPalette = NULL;
   }

   if(pData->LeadBitmap.Flags.Allocated)
   {
      hDC = GetDC(hWnd);

      pData->hPalette = L_CreatePaintPalette(hDC, &pData->LeadBitmap);

      if(pData->hPalette)
      {
         hOldPal = SelectPalette(hDC, pData->hPalette, FALSE);
         nNoColors = RealizePalette(hDC);
   
         if(nNoColors)
            InvalidateRect(hWnd, NULL, FALSE);
         SelectPalette(hDC, hOldPal, TRUE);
      }
      ReleaseDC(hWnd, hDC);
   }
   UNLOCKCHILDDATA(hWnd);
   return nNoColors;
}

L_VOID ShowStatusWindow(L_BOOL bStatus)
{
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG),         bStatus ? SW_HIDE : SW_SHOW);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_BITSPIXEL),    bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_INK),          bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR),        bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_DIMENSION),    bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MEMORY),       bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MOUSEPOS),     bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_REGIONBOUNDS), bStatus ? SW_SHOW : SW_HIDE);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_ESCAPE),       bStatus ? SW_HIDE : SW_SHOW);
   ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG),         bStatus ? SW_HIDE : SW_SHOW);
}

L_VOID InitDataAfterDlg(HWND hWnd, L_VOID L_FAR * pStructDlgData, pBITMAPHANDLE pLeadBitmap, pBITMAPHANDLE pBitmap, L_INT nDlgRet)
{
   HWND       hWndParent;
   pCHILDDATA pData;
   L_INT      nMin, nMax;

   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData      = LOCKCHILDDATA (hWndParent);


   if(StatusProc.ProgressValue != 100 || !nDlgRet)
   {
      L_FreeBitmap(pLeadBitmap);
      L_CopyBitmap (pLeadBitmap, pBitmap, sizeof(BITMAPHANDLE));
      L_FreeBitmap(pBitmap);
   }
   else
   {
      L_FreeBitmap(pBitmap);
      L_UndoList_AddBitmap (hWnd);
   }

   if(pStructDlgData)
      GlobalFreePtr(pStructDlgData);

   ShowStatusWindow(TRUE);
   StatusProc.bStillWork    = FALSE;
   StatusProc.bProgress     = FALSE;
   StatusProc.bKillProgress = TRUE ;
   StatusProc.ProgressValue = 100;
   InvalidateRect(hWnd, NULL, TRUE);
   InvalidateRect(hStatusWnd, NULL, FALSE);
   SetStatusColorAndPixel(hWnd);

   if(L_IsGrayScaleBitmap(pLeadBitmap) && (pLeadBitmap->BitsPerPixel == 12 || pLeadBitmap->BitsPerPixel == 16))
   {
      
      if (!pLeadBitmap->Flags.UseLUT)
      {
         L_GetMinMaxBits(pLeadBitmap, &nMin, &nMax);
         pLeadBitmap->LowBit = nMin;
         pLeadBitmap->HighBit = nMax;
      }
      else
      {
         pLeadBitmap->LowBit = 0;
         pLeadBitmap->HighBit = (pLeadBitmap->BitsPerPixel) - 1;
      }
      
   }
}

L_VOID InitDataBeforDlg(L_INT nPercent)
{
   
   ShowStatusWindow(TRUE);

   StatusProc.bStillWork    = FALSE;
   StatusProc.nStatusCnt    = 0;
   StatusProc.nOldStatusCnt = 0;
   StatusProc.nPercent      = nPercent;
   StatusProc.bOneTick      = FALSE;
}

L_VOID SetChildText(HWND hWnd, L_UINT uType)
{
   pCHILDDATA        pData;
   L_INT             nI;
   L_TCHAR L_FAR *   strTitle    = (L_TCHAR L_FAR *) malloc (sizeof(L_TCHAR) * 100);
   L_TCHAR L_FAR *   strTypeBuff = (L_TCHAR L_FAR *) malloc (sizeof(L_TCHAR) * 10 );

   pData = LOCKCHILDDATA (hWnd);
   memset(strTitle   , 0, sizeof(L_TCHAR) * 100);
   memset(strTypeBuff, 0, sizeof(L_TCHAR) * 10 );

   nI = 0 ;

   switch(uType)
   {
   case CCS_RGB : wsprintf(strTypeBuff, TEXT("(RGB)") ); break;
   case CCS_YUV : wsprintf(strTypeBuff, TEXT("(YUV)") ); break;
   case CCS_HSV : wsprintf(strTypeBuff, TEXT("(HSV)") ); break;
   case CCS_HLS : wsprintf(strTypeBuff, TEXT("(HLS)") ); break;
   case CCS_YIQ : wsprintf(strTypeBuff, TEXT("(YIQ)") ); break;
   case CCS_CMY : wsprintf(strTypeBuff, TEXT("(CMY)") ); break;
   case CCS_LAB : wsprintf(strTypeBuff, TEXT("(LAB)") ); break;
   case CCS_XYZ : wsprintf(strTypeBuff, TEXT("(XYZ)") ); break;
   case CCS_BGR : wsprintf(strTypeBuff, TEXT("(BGR)") ); break;
   case CCS_YCC : wsprintf(strTypeBuff, TEXT("(YCC)") ); break;
   case CCS_CMYK: wsprintf(strTypeBuff, TEXT("(CMYK)")); break;
   case CCS_YUY2: wsprintf(strTypeBuff, TEXT("(YUY2)")); break;
   case CCS_YVU9: wsprintf(strTypeBuff, TEXT("(YVU9)")); break;
   case CCS_UYVY: wsprintf(strTypeBuff, TEXT("(UYVY)")); break;
   }

   wsprintf(strTitle, TEXT("%s %s"), pData->pszTitle, strTypeBuff);

   SetWindowText(hWnd, strTitle);

   free(strTypeBuff);
   free(strTitle);
}

/*====(Child_OnCommand)====================================================
Description: Processes the WM_COMMAND for a child window.

Syntax     : VOID Child_OnCommand(HWND hWnd, L_INT nID, HWND hWndCtl, 
                                  L_UINT codeNotify)

Parameters : hWnd          Handle to the child window.
             nID            Value of the command to be processed.
             hWndCtl       Not used.
             codeNotify    Not used.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnCommand (HWND hWnd, L_INT nID, HWND hwndCtl, L_UINT codeNotify)
{
   pCHILDDATA           pData;
   LPCONVTODLGDATA      pConvToDlgData;
   L_INT                nRet;
   L_TCHAR              szFileName[MAX_PATH]  = TEXT("\0");
   L_TCHAR              szImageDir[1024]      = TEXT("\0");

   L_UCHAR L_FAR *      pBuff ;

   pData = LOCKCHILDDATA (hWnd);
   pBuff = (L_UCHAR *) malloc (sizeof(L_UCHAR) * pData->LeadBitmap.BytesPerLine);

   StatusProc.hwndCtl = hwndCtl;

   switch(nID)
   {
   case IDM_FILE_SAVE:
      SaveBitmapFile (hWnd);
      break;

   case IDM_EDIT_REDO://UNDOLIST//
      L_UndoList_Redo (hWnd);
      MemorizeBitmap(hWnd);
      SetStatusColorAndPixel(hWnd);
      SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor);
      break;

   case IDM_EDIT_UNDO://UNDOLIST//
      L_UndoList_Undo (hWnd);
      MemorizeBitmap(hWnd);
      SetStatusColorAndPixel(hWnd);
      SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor);
      break;

   case IDM_EDIT_COPY:
      L_CopyToClipboard(hWnd, &pData->LeadBitmap, 0x1f);
      break;

  case IDM_EDIT_PASTE:
      PasteBitmap(hWnd);
      SetStatusColorAndPixel(hWnd);
      break;

  case IDM_CONVERT_CH_AUTO:
     pData->bAutoHandle = TRUE;
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_AUTO  , MF_CHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_CMYK, MF_UNCHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_LAB , MF_UNCHECKED);
     break;

  case IDM_CONVERT_CH_M_CMYK:
     pData->bAutoHandle = FALSE;
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_AUTO  , MF_UNCHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_CMYK, MF_CHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_LAB , MF_UNCHECKED);
     pData->bCMYKSetting = TRUE;
     break;

  case IDM_CONVERT_CH_M_LAB:
     pData->bAutoHandle = FALSE;
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_AUTO  , MF_UNCHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_CMYK, MF_UNCHECKED);
     CheckMenuItem(hMenuChild, IDM_CONVERT_CH_M_LAB , MF_CHECKED);
     pData->bCMYKSetting = FALSE;
     break;

   case ID_CONVERT_CONVERTTO:
      pConvToDlgData = (LPCONVTODLGDATA)GlobalAllocPtr(GHND, sizeof(CONVTODLGDATA));
      if (!pConvToDlgData)
         return;

      InitDataBeforDlg(10);
      nRet = DoDialogBoxParam(IDD_CONVTO_DLG, hWnd, (DLGPROC)ConvertToDlgProc, (LONG)pConvToDlgData);
      InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pConvToDlgData, &pData->LeadBitmap, &pConvToDlgData->Bitmap, nRet);

      if (nRet == SUCCESS)
      {
         SetChildText(hWnd, pData->uConvertType);
      }
      break;

   case IDM_ICCPROFILES:
      ShowICCProfileLoadDialog(hWnd);
      break;
   }
   UNLOCKCHILDDATA(hWnd);
   free (pBuff);
}

L_INT GetFileExtentionIndex(LPTSTR szTitle, L_INT nBits)
{
   L_TCHAR L_FAR * ptTitle = szTitle;

   while (ptTitle[0] != '.' && ptTitle[0] != '\0')
      ptTitle++;

   if ((!lstrcmp(_tcslwr(ptTitle), TEXT(".tif"))) || (!lstrcmp(_tcslwr(ptTitle), TEXT(".tiff"))))
      return 4;

   return 0;
}
/*====(SaveBitmapFile)=========================================================
Description: Save the image to file.

Syntax     : L_INT SaveBitmapFile (HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/
L_INT SaveBitmapFile (HWND hWnd)
{
   SAVEDLGPARAMS     DlgParams;
   OPENFILENAME      OpenFileName;
   SAVEFILEOPTION    SaveFileOption;
   pCHILDDATA        pData;
   L_INT             nRet;
   L_TCHAR           szFile[1024] = TEXT("");
   L_TCHAR           szBuffer[1024];

   pData = LOCKCHILDDATA (hWnd);

   memset(&DlgParams,    0, sizeof(SAVEDLGPARAMS));
   memset(&OpenFileName, 0, sizeof(OPENFILENAME));

   OpenFileName.lStructSize     = sizeof ( OPENFILENAME ) ;
   OpenFileName.lpstrInitialDir = NULL;
   OpenFileName.lpstrTitle      = TEXT("Save a File");
   OpenFileName.lpstrFilter     = TEXT("TIFF Files (*.tif;*.tiff)\0*.tif;*.tiff\0All files (*.*)\0*.*\0");
   DlgParams.uFileTypeIndex     = GetFileExtentionIndex(pData->pszTitle, pData->LeadBitmap.BitsPerPixel);
   DlgParams.uStructSize        = sizeof ( SAVEDLGPARAMS ) ;
   DlgParams.nQFactor           = 2;
   DlgParams.nPageNumber        = 1;
   DlgParams.nBitsPerPixel      = pData->LeadBitmap.BitsPerPixel;
   DlgParams.uSaveMulti         = MULTIPAGE_OPERATION_REPLACE ;
   DlgParams.uDlgFlags          = 0;

   nRet = L_DlgSave ( hWnd, &OpenFileName,  &DlgParams );

   if (nRet == SUCCESS_DLG_OK)
   {
      L_GetDefaultSaveFileOption(&SaveFileOption, sizeof(SAVEFILEOPTION));
      SaveFileOption.Flags &= ~(ESO_REPLACEPAGE|ESO_INSERTPAGE);

      switch(DlgParams.uSaveMulti)
      {
      case DLG_FILESAVEOPTIONS_IDSTR_OVERWRITE:
         SaveFileOption.PageNumber = 1;
         break;

      case DLG_FILESAVEOPTIONS_IDSTR_APPEND:
         SaveFileOption.PageNumber = 2;
         break;

      case DLG_FILESAVEOPTIONS_IDSTR_REPLACE:
         SaveFileOption.PageNumber = DlgParams.nPageNumber;
         SaveFileOption.Flags |= ESO_REPLACEPAGE;
         break;

      case DLG_FILESAVEOPTIONS_IDSTR_INSERT:
         SaveFileOption.PageNumber = DlgParams.nPageNumber;
         SaveFileOption.Flags |= ESO_INSERTPAGE;
         break;
      }

      if(DlgParams.bSaveWithStamp)
      {
         SaveFileOption.Flags |= ESO_SAVEWITHSTAMP;
         SaveFileOption.StampWidth = DlgParams.nStampWidth;
         SaveFileOption.StampHeight = DlgParams.nStampHeight;
         SaveFileOption.StampBits = DlgParams.nStampBits;
      }

      nRet = L_SaveBitmap(DlgParams.szFileName,
                         &pData->LeadBitmap,
                          DlgParams.nFormat,
                          DlgParams.nBitsPerPixel,
                          DlgParams.nQFactor,
                         &SaveFileOption);

      if (nRet != SUCCESS)
      {
         wsprintf  (szBuffer, TEXT("ERROR %d saving the file %s."), nRet, (LPSTR)szFile);
         MessageBox(hWnd, szBuffer, TEXT("ERROR"), MB_OK);
      }
      else
      {
         UNLOCKCHILDDATA(hWnd);
         return (TRUE);
      }
   }
   UNLOCKCHILDDATA(hWnd);
   return (FALSE);
}

/*====(Child_OnClose)====================================================
Description: Performs cleanup for the child window.

Syntax     : VOID Child_OnClose(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnClose (HWND hWnd)
{
   pCHILDDATA pData = LOCKCHILDDATA(hWnd);

   FORWARD_WM_CLOSE(hWnd, DefMDIChildProc);
}

/*====(Child_OnDestroy)====================================================
Description: Performs cleanup for the child window.

Syntax     : VOID Child_OnDestroy(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnDestroy (HWND hWnd)
{
   pCHILDDATA pData;
   //MEMDISK...//
   L_BOOL bDel = TRUE;
   L_UINT uMem;   //...MEMDISK//

   pData = LOCKCHILDDATA (hWnd);

   //MEMDISK...//
   L_GetBitmapMemoryInfo (&pData->LeadBitmap, &uMem, NULL, NULL, NULL, NULL, NULL);
   if (uMem == TYPE_DISK)
      bDel = FALSE; //...MEMDISK//

   L_UndoList_DestroyList (hWnd);//UNDOLIST//

   if(pData)
   {
      nCount--;

      if(pData->LeadBitmap.Flags.Allocated)
      {
         if (bDel)
            L_FreeBitmap(&pData->LeadBitmap);
         L_InitBitmap(&pData->LeadBitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

      if(pData->pszTitle)
      {
         GlobalFreePtr(pData->pszTitle);
         pData->pszTitle = NULL;
      }

      if(pData->hPalette)
         DeletePalette(pData->hPalette);

      UNLOCKCHILDDATA(hWnd);
   }
}
/*====(Child_OnMDIActivate)================================================
Description: Informs the child window it is going to receive the focus.

Syntax     : VOID Child_OnMDIActivate(HWND hWnd, BOOL fActive, HWND hWndActivate, 
                                      HWND hWndDeactivate)

Parameters : hWnd                 Handle of a window.
             fActive              Truth of "Is the window active".
             hWndActivate         Handle to the window to be activated.
             hWndDeactivate       Handle to the window to be deactivated.

Return Value: None.
==========================================================================*/
static L_VOID Child_OnMDIActivate (HWND hWnd, L_BOOL fActive, HWND hWndActivate, HWND hWndDeactivate)
{
   pCHILDDATA pData;
   pCHILDDATA pPrevData = LOCKCHILDDATA(hWndDeactivate);

   pData = LOCKCHILDDATA (hWnd);

   if(hWnd == GetCapture())
      ReleaseCapture();
   if(hWndActivate)
   {
      SetFocus(hWnd);
      SendMessage(hWndClient, WM_MDISETMENU, (WPARAM)hMenuChild, (LPARAM)hMenuChildWindow);
      Child_OnQueryNewPalette(hWnd);
      SetStatusColorAndPixel(hWnd);
      SetStatusBarText(TEXT("STATUS"), &pData->LeadBitmap, szPos, szColor);
   }
   else
   {
      SetStatusBarText(NULL, 0, szPos, szColor);
      SendMessage(hWndClient, WM_MDISETMENU, (WPARAM)hMenuInit, (LPARAM)hMenuInitWindow);
   }
   DrawMenuBar(hWndFrame);
   UNLOCKCHILDDATA(hWnd);
}



static HBITMAP ResizeToDDB( pCHILDDATA pData, HDC hDisplay, pBITMAPHANDLE pBitmap, 
                            L_INT xSrcLeft, L_INT ySrcTop, L_INT nNewWidth, L_INT nNewHeight, 
                            L_INT nClientWidth, L_INT nClientHeight )
{
   HDC hDisplayMem;
   HDC hdcDevice;
   HBITMAP hBitmap;
   HBITMAP hbmSave;
   L_UINT32 ulFlags;
   RECT rcDest, rcDestClip;
   HPALETTE hpalSave = NULL;

   hdcDevice = (hDisplay)? hDisplay : GetDC (NULL);
   hDisplayMem = CreateCompatibleDC (hdcDevice);

   if ((hBitmap = CreateCompatibleBitmap (hdcDevice, nNewWidth, nNewHeight))== 0)
   {
      if (!hDisplay)
         ReleaseDC (NULL, hdcDevice);
      return (NULL);
   }

   hbmSave = SelectObject(hDisplayMem, hBitmap);

   if (pData->hPalette)
   {
      hpalSave = SelectPalette (hDisplayMem, pData->hPalette, TRUE);
      RealizePalette(hDisplayMem);
   }

   ulFlags = L_GetDisplayMode ();

   L_SetDisplayMode (DISPLAYMODE_INDEXEDPAINT, 0);


   SetRect(&rcDestClip, 0, 0, nNewWidth, nNewHeight);
   SetRect(&rcDest, - xSrcLeft, - ySrcTop, nClientWidth - xSrcLeft, nClientHeight - ySrcTop);

   L_PaintDC (hDisplayMem, pBitmap, NULL, NULL, &rcDest, &rcDestClip, SRCCOPY);

   L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags);

   if (hpalSave)
      SelectPalette (hDisplayMem, hpalSave, TRUE);

   SelectObject(hDisplayMem, hbmSave); 
   DeleteDC(hDisplayMem);

   if (!hDisplay)
      ReleaseDC (NULL, hdcDevice);

   return (hBitmap);
}

/*====(OutlineBitmapRgn)======================================================
Description: Draws a frame around the current region

Syntax     : L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc)

Parameters : hWnd          Handle of the child window.
             HDC           DC to use for drawing (may be null)

Return Value: None.
==========================================================================*/

L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc)
{
   pCHILDDATA pData;
   HDC hdcDraw;
   RGNXFORM XForm;

   pData = LOCKCHILDDATA(hWnd);

   if(L_BitmapHasRgn(&pData->LeadBitmap))
   {
      if(hdc)
         hdcDraw = hdc;
      else
         hdcDraw = GetDC(pData->hBitmapWnd);
      XForm.uViewPerspective = TOP_LEFT;
      XForm.nXScalarNum = RECTWIDTH(&pData->rcView);
      XForm.nXScalarDen = BITMAPWIDTH(&pData->LeadBitmap);
      XForm.nYScalarNum = RECTHEIGHT(&pData->rcView);
      XForm.nYScalarDen = BITMAPHEIGHT(&pData->LeadBitmap);
      XForm.nXOffset = pData->rcView.left;
      XForm.nYOffset = pData->rcView.top;
      if(!hdc)
         ReleaseDC(pData->hBitmapWnd, hdcDraw);
   }
   UNLOCKCHILDDATA(hWnd);
}

/*====(YClientToBitmap)===================================================
Description: Helps find the corresponding pixel in the bitmap for a
               point on the screen.

Syntax     : L_INT YClientToBitmap(LPCHILDDATA pData, L_INT y)

Parameters : pData         Child window's data
             x             X coordinate of a point in the client window
             y             Y coordinate of a point in the client window

Return Value: The corresponding Y coordinate in bitmap coordinates
==========================================================================*/
static L_INT YClientToBitmap(pCHILDDATA pData, L_INT x, L_INT y)
{
   x = (L_INT)((L_INT32)(x - pData->rcView.left)*BITMAPWIDTH(&pData->LeadBitmap)/RECTWIDTH(&pData->rcView));
   y = (L_INT)((L_INT32)(y - pData->rcView.top)*BITMAPHEIGHT(&pData->LeadBitmap)/RECTHEIGHT(&pData->rcView));

   L_PointToBitmap(&pData->LeadBitmap, TOP_LEFT, &x, &y);
   return y;
}

/*====(XClientToBitmap)===================================================
Description: Helps find the corresponding pixel in the bitmap for a
               point on the screen.

Syntax     : L_INT XClientToBitmap(LPCHILDDATA pData, L_INT x)

Parameters : pData         Child window's data
             x             X coordinate of a point in the client window
             y             Y coordinate of a point in the client window

Return Value: The corresponding X coordinate in bitmap coordinates
==========================================================================*/
static L_INT XClientToBitmap(pCHILDDATA pData, L_INT x, L_INT y)
{
   x = (L_INT)((L_INT32)(x - pData->rcView.left)*BITMAPWIDTH(&pData->LeadBitmap)/RECTWIDTH(&pData->rcView));
   y = (L_INT)((L_INT32)(y - pData->rcView.top)*BITMAPHEIGHT(&pData->LeadBitmap)/RECTHEIGHT(&pData->rcView));

   L_PointToBitmap(&pData->LeadBitmap, TOP_LEFT, &x, &y);
   return x;
}

L_VOID FitImageToWindow(RECT rcImage, pBITMAPHANDLE pBitmap, LPRECT Rect)
{
   L_INT Dy, Dx;
   L_INT nOffsetx, nOffsety;

   if(pBitmap->Height >= pBitmap->Width)
   {
      Dy = rcImage.bottom - rcImage.top;
      Dx = MulDiv ( Dy, pBitmap->Width, pBitmap->Height );
      nOffsety = 0;
      nOffsetx = (rcImage.right - rcImage.left - Dx)/2;
   }
   else
   {
      Dx = rcImage.right- rcImage.left;
      Dy = MulDiv ( Dx, pBitmap->Height, pBitmap->Width );
      nOffsety = (rcImage.bottom- rcImage.top - Dy)/2;
      nOffsetx = 0;
   }
   SetRect(Rect, 0, 0, Dx, Dy);
   OffsetRect(Rect, nOffsetx, nOffsety);
}

L_VOID SetStatusColorAndPixel(HWND hWnd)
{
   pCHILDDATA pData  = LOCKCHILDDATA (hWnd);
   POINT      TmpPoint;
   L_INT      nViewP;

   GetCursorPos(&TmpPoint);
   ScreenToClient(hWnd, &TmpPoint);

   if (!((TmpPoint.x >= pData->LeadBitmap.Width) || (TmpPoint.y >= pData->LeadBitmap.Height)))
   {
      L_UCHAR nComp[8];

      nViewP = pData->LeadBitmap.ViewPerspective;
      L_ChangeBitmapViewPerspective(&pData->LeadBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE), TOP_LEFT);

      crColor = L_GetPixelColor(&pData->LeadBitmap, TmpPoint.y + pData->nVScrollPos, TmpPoint.x + pData->nHScrollPos);

      // for release version
      if(GetProcPixel(&pData->LeadBitmap) == 16)
      {
         L_INT      nRed;
         if(pData->LeadBitmap.BitsPerPixel == 16)
         {
            nRed = (L_UCHAR)((crColor & 0x00FFFF) >> 8);
         }
         else
         {
            nRed = (L_UCHAR)(((crColor & 0x00FFF0) >> 4) >> 4);
         }
         crColor = ((L_UINT32)(((L_UCHAR)(nRed)|((L_UINT16)(nRed) << 8))|(((L_UINT32)(L_UCHAR)(nRed)) << 16)));
      }

      nComp[2] = (L_UCHAR) (crColor);
      nComp[1] = (L_UCHAR)((crColor) >> 8);
      nComp[0] = (L_UCHAR)((crColor) >> 16);

      L_ChangeBitmapViewPerspective(&pData->LeadBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE), nViewP);
      if (IsDecimal)
         wsprintf(szColor, TEXT("%d, %d, %d"), nComp[0], nComp[1], nComp[2]);
      else
         wsprintf(szColor, TEXT("%X, %X, %X"), nComp[0], nComp[1], nComp[2]);
      wsprintf(szPos, TEXT("%d, %d"), TmpPoint.x + pData->nHScrollPos, TmpPoint.y + pData->nVScrollPos);
      SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR,    szColor);
      SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS, szPos);
   }
}

/*--------------------------------------------------------------------------+
| Function :Child_OnMouseMove 
| Desc     :continues dragging the splitter
| Return   :void 
| Notes    :
+--------------------------------------------------------------------------*/
static L_VOID Child_OnMouseMove (HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags)
{
   pCHILDDATA pData;
   POINT      TmpPoint;
   RECT       TmpRect;

   pData = LOCKCHILDDATA (hWnd);
   TmpPoint.x = x;
   TmpPoint.y = y;

   SetStatusColorAndPixel(hWnd);

   InvalidateRect(hStatusWnd, NULL, FALSE);

   GetClientRect(hWnd, &TmpRect);
   IntersectRect(&TmpRect , &TmpRect, &pData->rcView);
   UNLOCKCHILDDATA(hWnd);
}

/*====(StatusCallBack)==============================================
Description:Track The Processes witch come from LEADTOOLS API's

Syntax     : L_INT L_FAR StatusCallBack (L_INT nPercent, L_VOID L_FAR *pUserData)
                              
                               

Parameters : nPercent   How Much Done From The Process.
             
             
Return Value: SUCCESS Or 0.
==========================================================================*/
L_INT L_FAR L_EXPORT StatusCallBack (L_INT nPercent, L_VOID L_FAR *pUserData)
{
    MSG msg;
   HWND hWndParent;
   L_INT nRet = 0;

   if (StatusProc.bStillWork)
   {
      nRet = StatusBarProgressCallBack(nPercent, pUserData);
   }

   if(nRet == ERROR_USER_ABORT)
      return nRet;
   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   if(StatusProc.bProgress)
   {
      StatusProc.ProgressValue = nPercent;
      while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
      {
         if ( msg.message == WM_QUIT )
         {
            PostQuitMessage ( 0 ); 
            StatusProc.ProgressValue = 100;
            return ERROR_USER_ABORT;
         }
         else
         {
            TranslateMessage ( &msg );
            DispatchMessage ( &msg );
         }
      }
      if ( StatusProc.bKillProgress )
      {
         StatusProc.bKillProgress = FALSE ;   
         StatusProc.ProgressValue = 100 ;
         PostMessage ( StatusProc.DlgWnd , WM_USER_UPDATEVIEW, 0, 0 );
         return ERROR_USER_ABORT ;
      }
      if (StatusProc.ProgressValue != 100)
      {

         Progress_SetPos(StatusProc.ProgWnd , StatusProc.ProgressValue);
         if(StatusProc.bOneTick)
            StatusProc.nStatusCnt = StatusProc.ProgressValue;
         else
            StatusProc.nStatusCnt = SendMessage(StatusProc.ProgWnd, PBM_GETPOS, 0, 0);

         if(StatusProc.bInvalidate)
         {
            InvalidateRect(hWndParent, NULL, FALSE);
         }
      }
      return (SUCCESS);
   }
   else
   {
      return SUCCESS ;
   }
}

/*====(ProgressBarProc)====================================================
Description: Processes messages for the Progress Bar.

Syntax     : LRESULT CALLBACK L_EXPORT ProgressBarProc (HWND hWnd,
                                                        L_UINT uMessage,
                                                        WPARAM wParam,
                                                        LPARAM lParam)

Prototype  : demo.h

Parameters : hWnd            Window handle.
             uMessage         Windows uMessage to process.
             wParam          Windows word parameter.
             lParam          Windows long parameter.

Return Value: 0              WM_PAINT uMessage processed.
              DefWindowProc  A different uMessage processed.
==========================================================================*/
LRESULT CALLBACK L_EXPORT ProgressBarProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   PAINTSTRUCT ps;
   L_TCHAR     szPercent[5];
   RECT        rcClient;
   RECT        rcClip;
   L_INT       nLen;
   L_INT       xCenter;
   HRGN        hRgn;

   switch (uMessage)
   {
   case WM_PAINT:
      BeginPaint (hWnd, &ps);

      if (StatusProc.ProgressValue > 100)
         break;
      SaveDC(ps.hdc);

      GetClientRect (hWnd, &rcClient);

      nLen = wsprintf ((LPTSTR) szPercent, TEXT("%d%%"), StatusProc.ProgressValue);

      SetTextAlign(ps.hdc, TA_CENTER);
      SetTextColor(ps.hdc, RGB(255, 255, 255));
      SetBkColor(ps.hdc, RGB(0, 0, 255));

      hRgn = CreateRectRgnIndirect(&rcClient);
      SelectObject(ps.hdc, hRgn);

      SetRect(&rcClip, 0, 0, MulDiv(StatusProc.ProgressValue, RECTWIDTH(&rcClient), 100), RECTHEIGHT(&rcClient));
      OffsetRect(&rcClip, rcClient.left, rcClient.top);
      xCenter = (rcClient.left + rcClient.right + 1) / 2;
      IntersectClipRect(ps.hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom);

      ExtTextOut(ps.hdc, xCenter, 0, ETO_OPAQUE, &rcClient, szPercent, nLen, NULL);

      SetTextColor(ps.hdc, RGB(0, 0, 255));
      SetBkColor(ps.hdc, RGB(255, 255, 255));

      SelectObject(ps.hdc, hRgn);
      ExcludeClipRect(ps.hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom);

      ExtTextOut(ps.hdc, xCenter, 0, ETO_OPAQUE, &rcClient, szPercent, nLen, NULL);
      DeleteObject(hRgn);
      RestoreDC(ps.hdc, -1);

      EndPaint (hWnd, &ps);
      return (0);
   }
   return (DefWindowProc (hWnd, uMessage, wParam, lParam));
}


/*====(SetStatusBarProgress)===============================================
Description: Paints the Progress Bar.

Syntax     : L_VOID SetStatusBarProgress(L_INT nPercent)

Prototype  : demo.h

Parameters : nPercent    Percent of processing complete.

Return Value: None.
==========================================================================*/
L_VOID SetStatusBarProgress(L_INT nPercent)
{
   HWND hWnd;

   StatusProc.ProgressValue = nPercent;

   hWnd = GetDlgItem (hStatusWnd, IDC_STATUS_PROG);
   InvalidateRect (hWnd, NULL, FALSE);
   UpdateWindow (hWnd);
   return;
}


/*====(StatusBarProc)======================================================
Description: Processes messages for the Status Bar.

Syntax     : L_BOOL CALLBACK L_EXPORT StatusBarProc (HWND hDlg,
                                                     L_UINT uMessage,
                                                     WPARAM wParam,
                                                     LPARAM lParam)

Prototype  : demo.h

Parameters : hDlg        Window handle.
             uMessage     Windows uMessage to process.
             wParam      Windows word parameter.
             lParam      Windows long parameter.

Return Value: TRUE       WM_INITDIALOG or WM_PAINT uMessage processed.
              FALSE      A different uMessage processed.
==========================================================================*/
L_BOOL CALLBACK L_EXPORT StatusBarProc (HWND hDlg, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   static L_INT x = 0;
   RECT        rcRect;
   HBRUSH      hBrush;
   HDC         hDC, hDC1;
   PAINTSTRUCT ps;
   
   switch(uMessage)
   {
   case WM_INITDIALOG:
      hStatusWnd = hDlg;
      SetStatusBarText(NULL, NULL, szPos, szColor);
      return TRUE;

   case WM_PAINT:
      GetClientRect(GetDlgItem(hDlg, IDC_STATUS_INK), &rcRect);

      hDC = BeginPaint(hStatusWnd, &ps); 

      hDC1 = GetDC(GetDlgItem(hDlg, IDC_STATUS_INK));
      hBrush = CreateSolidBrush(crColor);
      FillRect(hDC1, &rcRect, hBrush);
      DeleteBrush(hBrush);

      ReleaseDC(GetDlgItem(hDlg, IDC_STATUS_INK), hDC1);

      EndPaint(hStatusWnd, &ps);
      return TRUE;
   }
   return (FALSE);
}

/*====(SetStatusBarText)===================================================
Description: Sets text into various controls on the Status Bar of the Frame.

Syntax     : L_VOID SetStatusBarText(LPSTR pTitle,
                                     pBITMAPHANDLE pBitmap,
                                     L_INT nZoom)

Prototype  : demo.h

Parameters : pTitle      Text for the Title control.
             pBitmap     Bitmap currently being processed.
             nZoom       Zoom factor the image is displayed as.

Return Value: None.
==========================================================================*/
L_VOID SetStatusBarText(LPTSTR pTitle, pBITMAPHANDLE pBitmap, LPTSTR szPos, LPTSTR szColor)
{
   L_TCHAR        szText[80];
   L_TCHAR L_FAR* p;
   HDC            hDC;
   RECT           rcRect;
   L_TCHAR        szColorSpace[8][6] = {TEXT("RGB"), TEXT("HSV"), TEXT("HLS"), TEXT("XYZ"), TEXT("YCrCb"), TEXT("YUV"), TEXT("LAB"), TEXT("CMY")};

   if(pTitle)
   {
      wsprintf(szText, TEXT("%u X %u"), pBitmap->Width, pBitmap->Height);
      SetDlgItemText(hStatusWnd, IDC_STATUS_DIMENSION, szText);

      wsprintf(szText, TEXT("%u BPP"), pBitmap->BitsPerPixel);
      SetDlgItemText(hStatusWnd, IDC_STATUS_BITSPIXEL, szText);

      p = (pBitmap->Flags.Compressed      ? TEXT("COMP"): 
           pBitmap->Flags.SuperCompressed ? TEXT("SUP.CMP"): 
           pBitmap->Flags.Tiled           ? TEXT("TILED"): 
          (pBitmap->Flags.DiskMemory      ? TEXT("DISK"): TEXT("MEMORY")));

      if (pBitmap->Size < 100000)
         wsprintf(szText, TEXT("%lu bytes, %s"), pBitmap->Size, p);
      else
      {
         if(pBitmap->Size < 10000000)
            wsprintf(szText, TEXT("%lu KB, %s"), pBitmap->Size >> 10, p);
         else                          // > 100MB
            wsprintf(szText, TEXT("%lu MB, %s"), pBitmap->Size >> 20, p);
      }

      SetDlgItemText(hStatusWnd, IDC_STATUS_MEMORY, szText);

      wsprintf(szText, L_IsGrayScaleBitmap(pBitmap) ? TEXT("GrayScale Bitmap") : TEXT("Colored Bitmap"));

      SetDlgItemText(hStatusWnd, IDC_STATUS_REGIONBOUNDS, szText);

      SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR, szColor);

      SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS, szPos);
   }
   else
   {
      SetDlgItemText(hStatusWnd, IDC_STATUS_DIMENSION,    TEXT(""));
      SetDlgItemText(hStatusWnd, IDC_STATUS_BITSPIXEL,    TEXT(""));
      SetDlgItemText(hStatusWnd, IDC_STATUS_MEMORY,       TEXT(""));
      SetDlgItemText(hStatusWnd, IDC_STATUS_REGIONBOUNDS, TEXT(""));
      SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR,        TEXT(""));
      SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS,     TEXT(""));

      GetClientRect(GetDlgItem(hStatusWnd, IDC_STATUS_INK), &rcRect);
      hDC = GetDC(GetDlgItem(hStatusWnd, IDC_STATUS_INK));
      FillRect(hDC, &rcRect, (HBRUSH)COLOR_WINDOW);
      ReleaseDC(GetDlgItem(hStatusWnd, IDC_STATUS_INK), hDC);
   }
   return;
}

L_VOID Strip(LPTSTR StripName, LPTSTR pszTitle)
{
   L_INT   nEndPos = 0;
   L_INT   nSlashPos;
   L_INT   nCount;
   L_TCHAR cX = '\0';

   memset(StripName, 0, (lstrlen(StripName)*sizeof(L_TCHAR)));

   while(pszTitle[nEndPos] != cX)
   {
      nEndPos++;
   }

   for(nSlashPos = nEndPos; nSlashPos >= 0; nSlashPos--)
   {
      if(pszTitle[nSlashPos ] == '\\')
         break;
   }

   for(nCount = 0, nSlashPos++; nSlashPos < nEndPos; nSlashPos++, nCount++)
   {
      if (pszTitle[nSlashPos] == '.')
         break;
      StripName[nCount] = pszTitle[nSlashPos];
   }
}

/*====(StatusCallBack)======================================================
Description: Performs as a callback for the Progress Bar.

Syntax     : STATUSCALLBACK L_EXPORT StatusCallBack( L_INT nPercent );

Prototype  : demo.h

Parameters : nPercent      Percent of operation complete.

Return Value: SUCCESS           The function was successful.
              ERROR_USER_ABORT  User wants to cancel the operation.
==========================================================================*/
L_INT L_FAR L_EXPORT StatusBarProgressCallBack (L_INT nPercent, L_VOID L_FAR * pUserData)
{
   MSG msg;

   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
   {
      if ((msg.message == WM_CHAR) && (msg.wParam == 27))
      {
         return ERROR_USER_ABORT;
      }
      else
      {
         TranslateMessage (&msg);
         if (msg.message == WM_PAINT)
           DispatchMessage (&msg);
      }
   }
   SetStatusBarProgress(nPercent);
   return (SUCCESS);
}

L_VOID MoveDialogToMiddle(HWND hWnd)
{
   RECT  rcDlgPos;
   RECT  rcDlgSize;
   POINT ptPoint;

   GetWindowRect(hWndClient, &rcDlgPos);
   GetWindowRect(hWnd, &rcDlgSize);

   ptPoint.x = (RECTWIDTH(&rcDlgPos)  >> 1) - (RECTWIDTH(&rcDlgSize)  >> 1);
   ptPoint.y = (RECTHEIGHT(&rcDlgPos) >> 1) - (RECTHEIGHT(&rcDlgSize) >> 1);

   ClientToScreen(hWndFrame, &ptPoint);
   MoveWindow(hWnd, ptPoint.x , ptPoint.y, RECTWIDTH(&rcDlgSize), RECTHEIGHT(&rcDlgSize), TRUE);
}

L_INT GetProcPixel(pBITMAPHANDLE pBitmap)
{
   if(pBitmap->BitsPerPixel >= 48)
      return 48;

   if(pBitmap->BitsPerPixel <= 8 && L_IsGrayScaleBitmap(pBitmap))
      return 8;

   if((pBitmap->BitsPerPixel == 16 || pBitmap->BitsPerPixel == 12) && (ISGRAY(pBitmap) & L_IsGrayScaleBitmap(pBitmap)))
      return 16;

   return 24;
}

L_BOOL CALLBACK SetFontEnumProce ( HWND hWnd, LPARAM lParam )
{ 
   SendMessage ( hWnd, WM_SETFONT, ( WPARAM ) lParam, ( LPARAM ) TRUE ) ;
   
   return TRUE ;
}

L_VOID SetControlFont ( HWND hWnd, HFONT hFont )
{
   if ( NULL != hFont )
   {
      EnumChildWindows ( hWnd, SetFontEnumProce, ( LPARAM ) hFont ) ;
   }
}

L_VOID GenerateDefaultFont ( HFONT* phFont )
{
   HFONT   hDefFont = NULL ;
   HDC     hDC      = NULL ;   
   LOGFONT LogFont ;


   hDC = GetDC ( NULL ) ;

   LogFont.lfHeight = -MulDiv ( 8, GetDeviceCaps ( hDC, LOGPIXELSY ), 72 ) ;

   ReleaseDC ( NULL, hDC ) ;

   LogFont.lfWidth          = 0 ; 
   LogFont.lfEscapement     = 0 ; 
   LogFont.lfOrientation    = 0 ;
   LogFont.lfWeight         = FW_NORMAL ; 
   LogFont.lfItalic         = FALSE ; 
   LogFont.lfUnderline      = FALSE ; 
   LogFont.lfStrikeOut      = FALSE ; 
   LogFont.lfCharSet        = DEFAULT_CHARSET ; 
   LogFont.lfOutPrecision   = OUT_STROKE_PRECIS ; 
   LogFont.lfClipPrecision  = CLIP_STROKE_PRECIS ; 
   LogFont.lfQuality        = DRAFT_QUALITY ; 
   LogFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE ;

   lstrcpy ( LogFont.lfFaceName, _T ( "Tahoma" ) ) ;

   *phFont = CreateFontIndirect ( &LogFont ) ;
}

L_VOID MakeRectangleWindow(HWND hWnd, L_INT nID)
{
   RECT rcRect;
   POINT pt ;
   L_INT nSize = 0 ;

   ZeroMemory ( &rcRect, sizeof(rcRect));

   GetWindowRect (GetDlgItem(hWnd, nID), &rcRect);
   pt.x = rcRect.left ;
   pt.y = rcRect.top ;

   nSize = min((rcRect.right - rcRect.left), (rcRect.bottom - rcRect.top));
   ScreenToClient (hWnd, &pt);

   MoveWindow (GetDlgItem(hWnd, nID),pt.x, pt.y, nSize, nSize, TRUE);
}
 
L_INT ShowICCProfileLoadDialog ( HWND hWnd )
{
   ICCPROFILEDLGPARAMS dlgParams ;

   ZeroMemory ( &dlgParams, sizeof ( ICCPROFILEDLGPARAMS ) ) ;
   dlgParams.uStructSize = sizeof ( ICCPROFILEDLGPARAMS ) ;
   lstrcpy (dlgParams.szLoadFile, TEXT("C:\\"));
   lstrcpy (dlgParams.szSaveFile, TEXT("C:\\"));
   dlgParams.uDlgFlags = DLG_ICCPROFILE_SHOW_LOAD|DLG_ICCPROFILE_SHOW_SAVE ;

   return L_DlgICCProfile ( hWnd, &dlgParams ) ;
}