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

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

#include "BarCode.h"


static BOOL  Child_OnCreate         (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
static VOID  Child_OnCommand        (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify);
static VOID  Child_OnSize           (HWND hWnd, UINT nState, int nCx, int nCy); 
static VOID  Child_OnPaint          (HWND hWnd);
static VOID  Child_OnMDIActivate    (HWND hWnd, BOOL fActive, HWND hWndActivate,HWND hWndDeactivate);
static VOID  Child_OnDestroy        (HWND hWnd);
static VOID  Child_OnVScroll        (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos);
static VOID  Child_OnHScroll        (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos);
static BOOL  Child_OnEraseBkgnd     (HWND hWnd, HDC hDC);
static VOID  Child_OnLButtonDown    (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags);
static VOID  Child_OnLButtonUp      (HWND hWnd, L_INT x, L_INT y, UINT keyFlags);
static VOID  Child_OnMouseMove      (HWND hWnd, L_INT x, L_INT y, UINT keyFlags);
static VOID  Child_OnTimer          (HWND hWnd, UINT id);
static VOID  Child_OnClose          (HWND hWnd);
static VOID  Child_OnSetFocus       (HWND hWnd, HWND hwndOldFocus);
static VOID  Child_OnKillFocus      (HWND hWnd, HWND hwndNewFocus);
static BOOL  Child_OnQueryNewPalette(HWND hWnd);
static VOID  Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange);

       L_INT SaveBitmap             (HWND hWnd);
       VOID  SetRgnRect             (HWND hWnd);
       VOID  DrawRect               (HWND hWnd, RECT rcDraw);
       VOID  DisplayBarCodeInfo     (HWND hWnd, L_INT nIndex);
       VOID  GetBarUnitsStr         (L_INT nUnits, L_TCHAR * pszBarUnits);
       VOID  GetBarTypeStr          (L_UINT32 ulBarType, L_TCHAR * pszBarStr);
       VOID  ReadBarCodes           (HWND hWnd);
       VOID  WriteBarCodes          (HWND hWnd);
       VOID  FindFirstDupilcate     (HWND hWnd);
       VOID  FindNextDupilcate      (HWND hWnd);
       VOID  ConvertNULLString      (L_CHAR L_FAR * pszSrcBuf, L_CHAR L_FAR * pszDestBuf, L_INT nBufCount);

static HWND hwndClient, hwndFrame;
       BOOL bInScroll;

LRESULT CALLBACK ChildWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
      HANDLE_MSG (hwnd, WM_CREATE,              Child_OnCreate);
      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_PAINT,               Child_OnPaint);
      HANDLE_MSG (hwnd, WM_DESTROY,             Child_OnDestroy);
      HANDLE_MSG (hwnd, WM_VSCROLL,             Child_OnVScroll);
      HANDLE_MSG (hwnd, WM_HSCROLL,             Child_OnHScroll);
      HANDLE_MSG (hwnd, WM_ERASEBKGND,          Child_OnEraseBkgnd);
      HANDLE_MSG (hwnd, WM_LBUTTONDOWN,         Child_OnLButtonDown);
      HANDLE_MSG (hwnd, WM_LBUTTONUP,           Child_OnLButtonUp);
      HANDLE_MSG (hwnd, WM_MOUSEMOVE,           Child_OnMouseMove);
      HANDLE_MSG (hwnd, WM_TIMER,               Child_OnTimer);
      HANDLE_MSG (hwnd, WM_CLOSE,               Child_OnClose);
      HANDLE_MSG (hwnd, WM_SETFOCUS,            Child_OnSetFocus);
      HANDLE_MSG (hwnd, WM_KILLFOCUS,           Child_OnKillFocus);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,     Child_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,      Child_OnPaletteChanged);
   }
   return DefMDIChildProc (hwnd, message, wParam, lParam);
}

static BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
   LPCHILDDATA    pChldData;
   LPCREATEDATA   pCreateData;
   // Allocate memory for window private data

   pCreateData = (LPCREATEDATA) CHILDCREATELPARAM(lpCreateStruct);
   pChldData = (LPCHILDDATA) GlobalAllocPtr (GHND, sizeof (CHILDDATA));

   pChldData->nVscrollPos = 0;
   pChldData->nVscrollMax = 0;
   pChldData->nVscrollStep= 0;
   pChldData->nHscrollPos = 0;
   pChldData->nHscrollMax = 0;
   pChldData->nHscrollStep= 0;
   pChldData->cxClient    = 0;
   pChldData->cyClient    = 0;
   pChldData->bIsFile     = FALSE;
   pChldData->bIsBarDup   = FALSE;
   pChldData->nDupBarIndex= 0;
   pChldData->pBarCodeData= NULL;
   pChldData->hPalette    = NULL;
   pChldData->uTimerID    = 0;
   pChldData->m_bCapWnd   = FALSE;
   pChldData->pszTitle    = (TCHAR*) GlobalAllocPtr(GHND, ( ( lstrlen (pCreateData->pszTitle) + 1 ) * sizeof(TCHAR)));
   if (pChldData->pszTitle)
      lstrcpy(pChldData->pszTitle, pCreateData->pszTitle);
   L_CopyBitmap(&pChldData->Bitmap, pCreateData->pBitmap, sizeof(BITMAPHANDLE));

   SetRect(&pChldData->rcFrame, 0, 0, 0, 0);
   SetRect(&pChldData->rcView, 0, 0, 0, 0);
   SetRect(&pChldData->rcRgn, 0, 0, 0, 0);
   SetWindowLong (hWnd, GWL_USERDATA, (long) pChldData);

   // Save some window handles
   hwndClient = GetParent (hWnd);
   hwndFrame  = GetParent (hwndClient);

   FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
   return TRUE;
}

static VOID Child_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify)
{
   HCURSOR     hOldCur;
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   switch (id)
   {
   case IDM_FILE_SAVEAS:
      SaveBitmap(hWnd);
      break;
   case IDM_EDIT_COPY:
      L_CopyToClipboard(hWnd, &pData->Bitmap, COPY2CB_EMPTY|COPY2CB_DIB);
      break;
   case IDM_ACTIONS_READ:
      if (DoDialogBoxParam(IDD_BAR_READ, hWnd, (DLGPROC) ReadDlgProc, 0) == IDOK)
         ReadBarCodes (hWnd);
      break;
   case IDM_ACTIONS_WRITE:
      if (DoDialogBoxParam(IDD_BAR_WRITE, hWnd, (DLGPROC) WriteDlgProc, 0) == IDOK)
         WriteBarCodes (hWnd);
      break;
   case IDM_ACTIONS_DUPINFO_FIRST:
      if (DoDialogBoxParam(IDD_DUP_INDEX, hWnd, (DLGPROC) GetIndexDlgProc, 0) == IDOK)
         FindFirstDupilcate (hWnd);
      break;
   case IDM_ACTIONS_DUPINFO_NEXT:
      FindNextDupilcate (hWnd);
      break;
   }

   SetCursor(hOldCur);
   return;
}

static VOID Child_OnSize (HWND hWnd, UINT nState, int nCx, int nCy)
{
   static BOOL fSizeInUse = FALSE;
   L_INT nWidth, nHeight, nVScroll, nHScroll;
   DWORD dwStyle;

   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!fSizeInUse)
   {
      fSizeInUse = TRUE;

      if (!IsIconic(hWnd)) // if window is normal
      {
         if (!pData->Bitmap.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->Bitmap);
            nHeight= BITMAPHEIGHT(&pData->Bitmap);
         }

         // 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->nVscrollMax = max(0, (nHeight - pData->cyClient - 1));
         pData->nVscrollPos = max (0, min (pData->nVscrollPos, pData->nVscrollMax));
         pData->nHscrollStep = max (1, pData->cxClient / SCROLL_RATIO);
         pData->nHscrollMax = max (0, (nWidth - pData->cxClient - 1));
         pData->nHscrollPos = max (0, min (pData->nHscrollPos, pData->nHscrollMax));

         if (pData->Bitmap.Flags.Allocated)
         {
            SetRect (&pData->rcView, 0, 0, nWidth, nHeight);
            OffsetRect (&pData->rcView, -pData->nHscrollPos, -pData->nVscrollPos);
         }

         SetScrollRange (hWnd, SB_HORZ, 0, pData->nHscrollMax, TRUE);
         SetScrollPos (hWnd, SB_HORZ, pData->nHscrollPos, TRUE);
         SetScrollRange (hWnd, SB_VERT, 0, pData->nVscrollMax, TRUE);
         SetScrollPos (hWnd, SB_VERT, pData->nVscrollPos, 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;
   }

   FORWARD_WM_SIZE(hWnd,nState, nCx, nCy, DefMDIChildProc);
}

static VOID Child_OnPaint (HWND hWnd)
{
   LPCHILDDATA pChldData;
   HPALETTE    oldPalette;
   PAINTSTRUCT ps;
   HDC         hdc;

   hdc = BeginPaint (hWnd, &ps);

   pChldData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if ((pChldData->Bitmap.Flags.Allocated))
   {
      if (pChldData->hPalette)
      {
         oldPalette = SelectPalette(hdc, pChldData->hPalette, TRUE);
         RealizePalette(hdc);
      }

      L_PaintDC(hdc, &pChldData->Bitmap, NULL, NULL, &pChldData->rcView, &ps.rcPaint, SRCCOPY);

      if(pChldData->hPalette)
         SelectPalette(hdc, oldPalette, TRUE);
   }
   EndPaint (hWnd, &ps);
}

static VOID Child_OnMDIActivate (HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate)
{
   if (fActive)
   {
      Child_OnQueryNewPalette(hWnd);
      SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuChild, (LPARAM) hMenuChildWindow);
   }
   else
      SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuInit, (LPARAM) hMenuInitWindow);
 
   DrawMenuBar (hwndFrame);
   EnableActionsMenu(hwndFrame, hwndFrame);
}

static VOID Child_OnClose  (HWND hWnd)
{
   LPCHILDDATA pChldData;
   pChldData = (LPCHILDDATA) GetWindowLong (hWnd, GWL_USERDATA);
   if (pChldData)
   {
      if (pChldData->hPalette)
      {
         DeleteObject(pChldData->hPalette);
         pChldData->hPalette = NULL;
      }

      if (pChldData->uTimerID)
         KillTimer(hWnd, pChldData->uTimerID);
      if (pChldData->Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&pChldData->Bitmap);
         L_InitBitmap(&pChldData->Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

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

   FORWARD_WM_CLOSE(hWnd, DefMDIChildProc);
}

static VOID Child_OnDestroy (HWND hWnd)
{
   LPCHILDDATA pChldData;
   pChldData = (LPCHILDDATA) GetWindowLong (hWnd, GWL_USERDATA);
   if (pChldData)
   {
      if (pChldData->hPalette)
      {
         DeleteObject(pChldData->hPalette);
         pChldData->hPalette = NULL;
      }

      if (pChldData->uTimerID)
         KillTimer(hWnd, pChldData->uTimerID);
      if (pChldData->Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&pChldData->Bitmap);
         L_InitBitmap(&pChldData->Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

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

static VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos)
{
   L_INT       nScrollInc;
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   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;
}

static VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos)
{
	L_INT nHScrollInc;
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER(hWndCtl);
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   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:
		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;
}

static BOOL Child_OnEraseBkgnd (HWND hWnd, HDC hDC)
{
   if (!bInScroll)
	   return ((BOOL) FORWARD_WM_ERASEBKGND (hWnd, hDC, DefWindowProc));
   return TRUE;
}

static VOID Child_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags)
{
   LPCHILDDATA pData;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (!pData->m_bCapWnd)
   {
      SetCapture(hWnd);
      pData->m_bCapWnd = TRUE;
   }

   if(pData->uTimerID)
      KillTimer(hWnd, pData->uTimerID);

   if (L_BitmapHasRgn(&pData->Bitmap))
   {
      L_FreeBitmapRgn(&pData->Bitmap);
      InvalidateRect(hWnd, NULL, TRUE);
      UpdateWindow(hWnd);
   }
 
   bLMDown = TRUE;

   pData->rcFrame.right  = pData->rcFrame.left = x;
   pData->rcFrame.bottom = pData->rcFrame.top = y;
   DrawRect(hWnd, pData->rcFrame);
}

static VOID Child_OnLButtonUp (HWND hWnd, L_INT x, L_INT y, UINT keyFlags)
{
   LPCHILDDATA pData;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   bLMDown = FALSE;
   
   if (pData->m_bCapWnd)
   {
      ReleaseCapture();
      pData->m_bCapWnd = FALSE;
   }

   DrawRect(hWnd, pData->rcFrame);

   if ((pData->rcFrame.left == pData->rcFrame.right) || (pData->rcFrame.top == pData->rcFrame.bottom))
      return;

   SetRect(&pData->rcRgn,
            min(pData->rcFrame.left, pData->rcFrame.right),
            min(pData->rcFrame.top,  pData->rcFrame.bottom),
            max(pData->rcFrame.left, pData->rcFrame.right),
            max(pData->rcFrame.top,  pData->rcFrame.bottom));

   SetRgnRect(hWnd);
   SetRectEmpty(&pData->rcRgn);
}

static VOID Child_OnMouseMove (HWND hWnd, L_INT x, L_INT y, UINT keyFlags)
{
   LPCHILDDATA pData;
   L_INT       nBmpWidth, nBmpHeight;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (pData->m_bCapWnd)
      if (GetCapture() != hWnd)
         SetCapture(hWnd);

   if (bLMDown)
   {
      DrawRect(hWnd, pData->rcFrame);

      nBmpWidth = BITMAPWIDTH(&pData->Bitmap);
      nBmpHeight = BITMAPHEIGHT(&pData->Bitmap);

      pData->rcFrame.right = (x > nBmpWidth) ? nBmpWidth : ((x < 0) ? 0 : x);
      pData->rcFrame.bottom= (y > nBmpHeight) ? nBmpHeight : ((y < 0) ? 0 : y);

      DrawRect(hWnd, pData->rcFrame);
   }
}

static VOID Child_OnTimer (HWND hWnd, UINT id)
{
   static L_INT nCount=0;
   RGNXFORM     XForm;
   LPCHILDDATA  pData;
   HDC          hDC;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   if (pData->uTimerID != id)
      return;

   hDC = GetDC(hWnd);
   if (!hDC) return;

   XForm.uViewPerspective = TOP_LEFT;
   XForm.nXScalarNum = 1;
   XForm.nXScalarDen = 1;
   XForm.nYScalarNum = 1;
   XForm.nYScalarDen = 1;
   XForm.nXOffset = -GetScrollPos(hWnd, SB_HORZ);
   XForm.nYOffset = -GetScrollPos(hWnd, SB_VERT);

   if (nCount++>7) nCount=0;

   L_FrameBitmapRgn(hDC, &pData->Bitmap, &XForm, L_FRAME_MOVING0 + nCount);

   ReleaseDC(hWnd, hDC);
}

VOID SetRgnRect(HWND hWnd)
{
   LPCHILDDATA pData;
   RGNXFORM    XForm;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
     
   XForm.uViewPerspective = TOP_LEFT;
   XForm.nXScalarNum = 1;
   XForm.nXScalarDen = 1;
   XForm.nYScalarNum = 1;
   XForm.nYScalarDen = 1;
   XForm.nXOffset = GetScrollPos(hWnd, SB_HORZ);
   XForm.nYOffset = GetScrollPos(hWnd, SB_VERT);

   L_SetBitmapRgnRect(&pData->Bitmap, &XForm, &pData->rcRgn, L_RGN_AND);

   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);
}

VOID DrawRect(HWND hWnd, RECT rcDraw)
{
   HDC hDC;

   hDC = GetDC(hWnd);
   
   SetROP2(hDC, R2_NOT);
   MoveToEx(hDC, rcDraw.left, rcDraw.top, NULL);
   LineTo(hDC, rcDraw.right, rcDraw.top);
   LineTo(hDC, rcDraw.right, rcDraw.bottom);
   LineTo(hDC, rcDraw.left, rcDraw.bottom);
   LineTo(hDC, rcDraw.left, rcDraw.top);

   ReleaseDC(hWnd, hDC);
}

L_VOID EnableActionsMenu (HWND hWndFrame, HWND hWnd)
{
   LPCHILDDATA pData;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   EnableMenuItem(GetMenu(hWndFrame), IDM_ACTIONS_DUPINFO_FIRST,  MF_BYCOMMAND | ((pData && pData->pBarCodeData) ? MF_ENABLED : MF_GRAYED));
   EnableMenuItem(GetMenu(hWndFrame), IDM_ACTIONS_DUPINFO_NEXT ,  MF_BYCOMMAND | ((pData && pData->pBarCodeData && pData->bIsBarDup) ? MF_ENABLED : MF_GRAYED));
}

L_INT SaveBitmap(HWND hWnd)
{
   LPCHILDDATA   pData;
   OPENFILENAME  SaveFileName;
   SAVEDLGPARAMS FSParm;
   L_TCHAR        szBuffer[MAX_PATH];
   L_INT         nRet;

   memset(&SaveFileName, 0, sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));
   FSParm.uStructSize = sizeof(SAVEDLGPARAMS);
   memset(szBuffer, 0, sizeof(szBuffer));

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   FSParm.nQFactor      = 2;
   FSParm.pBitmap       = &pData->Bitmap;
   FSParm.uDlgFlags     =  DLG_SAVE_AUTOPROCESS |
                           DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE|
                           DLG_SAVE_AUTOPROCESS  |
                           DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS|
                           DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS|
                           DLG_SAVE_SHOW_FILEOPTIONS_STAMP|
                           DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE |
                           DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR;
      
   SaveFileName.lStructSize       = sizeof(OPENFILENAME);
   SaveFileName.lpstrInitialDir   = NULL;
   SaveFileName.lpstrTitle        = TEXT("Save As");
   SaveFileName.lpstrFile         = szBuffer;
   SaveFileName.nMaxFile          = sizeof(szBuffer)/sizeof(L_TCHAR);
   SaveFileName.lpstrFileTitle    = FSParm.szFileName;
   SaveFileName.nMaxFileTitle     = sizeof(FSParm.szFileName)/sizeof(L_TCHAR);
   SaveFileName.nFileOffset       = 0;
   SaveFileName.Flags             = 0;


   nRet = L_DlgSave (hWnd, &SaveFileName, &FSParm);

   if (nRet <= 0 )
   {
      memset(szBuffer, 0, sizeof(szBuffer));
      wsprintf(szBuffer, TEXT("Can not save file,\nError code = %d\n"), nRet);
      MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
   }

   return SUCCESS;
}

VOID ReadBarCodes (HWND hWnd)
{
   L_INT        nRet, i, nBarTotal, nRetError;
   LPCHILDDATA  pData;
   HCURSOR      hOldCur;
   L_TCHAR       szBuffer[MAX_BUFFER_SIZE];
   L_TCHAR       szError[MAX_BUFFER_SIZE];

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   pData   = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   memset(szBuffer, 0, MAX_BUFFER_SIZE);

   if (pData->pBarCodeData)
   {
      L_BarCodeFree(&pData->pBarCodeData);
      pData->pBarCodeData = NULL;
   }

   Bar1D.uStructSize = sizeof(BARCODE1D);
   BarRPDF.uStructSize = sizeof(BARCODEREADPDF);
   BarRColor.uStructSize = sizeof(BARCODECOLOR);

   nRet = L_BarCodeRead(&pData->Bitmap,
                        ((bUseRgn) ? NULL : &rcBarSearch),
                        ulSearchType,
                        nRUnits,
                        ulRFlags,
                        nMultiMax,
                        &Bar1D,
                        &BarRPDF,
                        &BarRColor,
                        &pData->pBarCodeData,
                        sizeof(BARCODEDATA));
   
   if (nRet == SUCCESS)
   {
      nBarTotal = pData->pBarCodeData[0].nTotalCount;

      wsprintf(szBuffer, TEXT("Total Bar Code Symbols Found is: %d\n\n"), nBarTotal);
      MessageBox(hWnd, szBuffer, TEXT("Notice!"), MB_OK);

      for (i=0; i< nBarTotal; i++)
         DisplayBarCodeInfo(hWnd, i);
   }
   else
   {
      
      memset(szError, 0, MAX_BUFFER_SIZE);

      wsprintf(szBuffer, TEXT("An error occurred in L_BarCodeRead,"));
      nRetError = GetBarErrorString(nRet, szError);
      
      if (nRetError == SUCCESS)
         wsprintf(szBuffer, TEXT("%s\nError Code is: %s\nError No. = %d\n"), szBuffer, szError, nRet);
      else
         wsprintf(szBuffer, TEXT("%s\nError No. = %d\n"), szBuffer, nRet);
      MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
   }

   EnableActionsMenu (hwndFrame, hWnd);
   SetCursor(hOldCur);
}

VOID DisplayBarCodeInfo(HWND hWnd, L_INT nIndex)
{
   L_CHAR L_FAR *  pszDestBuff=NULL;
   L_TCHAR L_FAR * pszBuffer;
   L_TCHAR         szBarType[50];
   L_TCHAR         szUnits[50];
   LPCHILDDATA    pData;

   pData     = (LPCHILDDATA)    GetWindowLong(hWnd, GWL_USERDATA);
   pszBuffer = (L_TCHAR L_FAR *) GlobalAllocPtr(GHND, pData->pBarCodeData[nIndex].nSizeofBarCodeData + MAX_BUFFER_SIZE);

   if (!pszBuffer)
   {
      MessageBox(hWnd, TEXT("Not enough memory."), TEXT("Error!"), MB_OK);
      return;
   }

   memset(szBarType, 0, sizeof(szBarType));
   memset(szUnits, 0, sizeof(szUnits));  

   GetBarTypeStr(pData->pBarCodeData[nIndex].ulType, szBarType);
   GetBarUnitsStr(pData->pBarCodeData[nIndex].nUnits, szUnits);

   pszDestBuff = (L_CHAR L_FAR *)GlobalAllocPtr(GHND, pData->pBarCodeData[nIndex].nSizeofBarCodeData + 1);
   if (!pszDestBuff)
   {
      GlobalFreePtr(pszBuffer);
      MessageBox(hWnd, TEXT("Not enough memory."), TEXT("Error!"), MB_OK);
      return;
   }
   
   ConvertNULLString(pData->pBarCodeData[nIndex].pszBarCodeData, pszDestBuff, pData->pBarCodeData[nIndex].nSizeofBarCodeData);
   wsprintf(pszBuffer,
            TEXT("No. %d\nData is %hs\nType %s\nUnits %s\nPosX %d\nPosY %d\nWidth %d\nHeight %d\n\n"),
            nIndex,
            pszDestBuff,
            szBarType,
            szUnits,
            pData->pBarCodeData[nIndex].rcBarLocation.left,
            pData->pBarCodeData[nIndex].rcBarLocation.top,
            abs(pData->pBarCodeData[nIndex].rcBarLocation.right - pData->pBarCodeData[nIndex].rcBarLocation.left),
            abs(pData->pBarCodeData[nIndex].rcBarLocation.bottom - pData->pBarCodeData[nIndex].rcBarLocation.top));

   MessageBox(hWnd, pszBuffer, TEXT("BarCode Info."), MB_OK);

   GlobalFreePtr(pszBuffer);
   GlobalFreePtr(pszDestBuff);
}

VOID GetBarTypeStr(L_UINT32 ulBarType, L_TCHAR * pszBarStr)
{
   switch (ulBarType)
   {
   case BARCODE_1D_EAN_13:          wsprintf(pszBarStr, TEXT("EAN 13")); break;
   case BARCODE_1D_EAN_8:           wsprintf(pszBarStr, TEXT("EAN 8")); break;
   case BARCODE_1D_UPC_A:           wsprintf(pszBarStr, TEXT("UPC A")); break;
   case BARCODE_1D_UPC_E:           wsprintf(pszBarStr, TEXT("UPC E")); break;
   case BARCODE_1D_CODE_3_OF_9:     wsprintf(pszBarStr, TEXT("Code 3 of 9")); break;
   case BARCODE_1D_CODE_128:        wsprintf(pszBarStr, TEXT("Code 128")); break;
   case BARCODE_1D_CODE_I2_OF_5:    wsprintf(pszBarStr, TEXT("Interleaved 2 of 5")); break;
   case BARCODE_1D_CODA_BAR:        wsprintf(pszBarStr, TEXT("CODABAR")); break;
   case BARCODE_1D_UCCEAN_128:      wsprintf(pszBarStr, TEXT("UCCEAN 128")); break;
   case BARCODE_1D_CODE_93:         wsprintf(pszBarStr, TEXT("Code 93")); break;
   case BARCODE_PDF417:             wsprintf(pszBarStr, TEXT("PDF417")); break;
   case BARCODE_DM_DEF:             wsprintf(pszBarStr, TEXT("DM Default")); break;
   case BARCODE_DM_10x10:           wsprintf(pszBarStr, TEXT("DM 10x10")); break;
   case BARCODE_DM_12x12:           wsprintf(pszBarStr, TEXT("DM 12x12")); break;
   case BARCODE_DM_14x14:           wsprintf(pszBarStr, TEXT("DM 14x14")); break;
   case BARCODE_DM_16x16:           wsprintf(pszBarStr, TEXT("DM 16x16")); break;
   case BARCODE_DM_18x18:           wsprintf(pszBarStr, TEXT("DM 18x18")); break;
   case BARCODE_DM_20x20:           wsprintf(pszBarStr, TEXT("DM 20x20")); break;
   case BARCODE_DM_22x22:           wsprintf(pszBarStr, TEXT("DM 22x22")); break;
   case BARCODE_DM_24x24:           wsprintf(pszBarStr, TEXT("DM 24x24")); break;
   case BARCODE_DM_26x26:           wsprintf(pszBarStr, TEXT("DM 26x26")); break;
   case BARCODE_DM_32x32:           wsprintf(pszBarStr, TEXT("DM 32x32")); break;
   case BARCODE_DM_36x36:           wsprintf(pszBarStr, TEXT("DM 36x36")); break;
   case BARCODE_DM_40x40:           wsprintf(pszBarStr, TEXT("DM 40x40")); break;
   case BARCODE_DM_44x44:           wsprintf(pszBarStr, TEXT("DM 44x44")); break;
   case BARCODE_DM_48x48:           wsprintf(pszBarStr, TEXT("DM 48x48")); break;
   case BARCODE_DM_52x52:           wsprintf(pszBarStr, TEXT("DM 52x52")); break;
   case BARCODE_DM_64x64:           wsprintf(pszBarStr, TEXT("DM 64x64")); break;
   case BARCODE_DM_72x72:           wsprintf(pszBarStr, TEXT("DM 72x72")); break;
   case BARCODE_DM_80x80:           wsprintf(pszBarStr, TEXT("DM 80x80")); break;
   case BARCODE_DM_88x88:           wsprintf(pszBarStr, TEXT("DM 88x88")); break;
   case BARCODE_DM_96x96:           wsprintf(pszBarStr, TEXT("DM 96x96")); break;
   case BARCODE_DM_104x104:         wsprintf(pszBarStr, TEXT("DM 10x104")); break;
   case BARCODE_DM_120x120:         wsprintf(pszBarStr, TEXT("DM 120x120")); break;
   case BARCODE_DM_132x132:         wsprintf(pszBarStr, TEXT("DM 132x132")); break;
   case BARCODE_DM_144x144:         wsprintf(pszBarStr, TEXT("DM 144x144")); break;
   case BARCODE_DM_8x18:            wsprintf(pszBarStr, TEXT("DM 8x18")); break;
   case BARCODE_DM_8x32:            wsprintf(pszBarStr, TEXT("DM 8x32")); break;
   case BARCODE_DM_12x26:           wsprintf(pszBarStr, TEXT("DM 12x26")); break;
   case BARCODE_DM_12x36:           wsprintf(pszBarStr, TEXT("DM 12x36")); break;
   case BARCODE_DM_16x36:           wsprintf(pszBarStr, TEXT("DM 16x36")); break;
   case BARCODE_DM_16x48:           wsprintf(pszBarStr, TEXT("DM 48x48")); break;
   case BARCODE_DM_WRITE_RECTANGLE: wsprintf(pszBarStr, TEXT("DM Default Rect")); break;
   case BARCODE_QR_DEF:             wsprintf(pszBarStr, TEXT("QR DEF")); break;
   case BARCODE_QR_M2_1:            wsprintf(pszBarStr, TEXT("QR M2 1")); break;
   case BARCODE_QR_M2_2:            wsprintf(pszBarStr, TEXT("QR M2 2")); break;
   case BARCODE_QR_M2_3:            wsprintf(pszBarStr, TEXT("QR M2 3")); break;
   case BARCODE_QR_M2_4:            wsprintf(pszBarStr, TEXT("QR M2 4")); break;
   case BARCODE_QR_M2_5:            wsprintf(pszBarStr, TEXT("QR M2 5")); break;
   case BARCODE_QR_M2_6:            wsprintf(pszBarStr, TEXT("QR M2 6")); break;
   case BARCODE_QR_M2_7:            wsprintf(pszBarStr, TEXT("QR M2 7")); break;
   case BARCODE_QR_M2_8:            wsprintf(pszBarStr, TEXT("QR M2 8")); break;
   case BARCODE_QR_M2_9:            wsprintf(pszBarStr, TEXT("QR M2 9")); break;
   case BARCODE_QR_M2_10:           wsprintf(pszBarStr, TEXT("QR M2 10")); break;
   case BARCODE_QR_M2_11:           wsprintf(pszBarStr, TEXT("QR M2 11")); break;
   case BARCODE_QR_M2_12:           wsprintf(pszBarStr, TEXT("QR M2 12")); break;
   case BARCODE_QR_M2_13:           wsprintf(pszBarStr, TEXT("QR M2 13")); break;
   case BARCODE_QR_M2_14:           wsprintf(pszBarStr, TEXT("QR M2 14")); break;
   case BARCODE_QR_M2_15:           wsprintf(pszBarStr, TEXT("QR M2 15")); break;
   case BARCODE_QR_M2_16:           wsprintf(pszBarStr, TEXT("QR M2 16")); break;
   case BARCODE_QR_M2_17:           wsprintf(pszBarStr, TEXT("QR M2 17")); break;
   case BARCODE_QR_M2_18:           wsprintf(pszBarStr, TEXT("QR M2 18")); break;
   case BARCODE_QR_M2_19:           wsprintf(pszBarStr, TEXT("QR M2 19")); break;
   case BARCODE_QR_M2_20:           wsprintf(pszBarStr, TEXT("QR M2 20")); break;
   case BARCODE_QR_M2_21:           wsprintf(pszBarStr, TEXT("QR M2 21")); break;
   case BARCODE_QR_M2_22:           wsprintf(pszBarStr, TEXT("QR M2 22")); break;
   case BARCODE_QR_M2_23:           wsprintf(pszBarStr, TEXT("QR M2 23")); break;
   case BARCODE_QR_M2_24:           wsprintf(pszBarStr, TEXT("QR M2 24")); break;
   case BARCODE_QR_M2_25:           wsprintf(pszBarStr, TEXT("QR M2 25")); break;
   case BARCODE_QR_M2_26:           wsprintf(pszBarStr, TEXT("QR M2 26")); break;
   case BARCODE_QR_M2_27:           wsprintf(pszBarStr, TEXT("QR M2 27")); break;
   case BARCODE_QR_M2_28:           wsprintf(pszBarStr, TEXT("QR M2 28")); break;
   case BARCODE_QR_M2_29:           wsprintf(pszBarStr, TEXT("QR M2 29")); break;
   case BARCODE_QR_M2_30:           wsprintf(pszBarStr, TEXT("QR M2 30")); break;
   case BARCODE_QR_M2_31:           wsprintf(pszBarStr, TEXT("QR M2 31")); break;
   case BARCODE_QR_M2_32:           wsprintf(pszBarStr, TEXT("QR M2 32")); break;
   case BARCODE_QR_M2_33:           wsprintf(pszBarStr, TEXT("QR M2 33")); break;
   case BARCODE_QR_M2_34:           wsprintf(pszBarStr, TEXT("QR M2 34")); break;
   case BARCODE_QR_M2_35:           wsprintf(pszBarStr, TEXT("QR M2 35")); break;
   case BARCODE_QR_M2_36:           wsprintf(pszBarStr, TEXT("QR M2 36")); break;
   case BARCODE_QR_M2_37:           wsprintf(pszBarStr, TEXT("QR M2 37")); break;
   case BARCODE_QR_M2_38:           wsprintf(pszBarStr, TEXT("QR M2 38")); break;
   case BARCODE_QR_M2_39:           wsprintf(pszBarStr, TEXT("QR M2 39")); break;
   case BARCODE_QR_M2_40:           wsprintf(pszBarStr, TEXT("QR M2 40")); break;
   case BARCODE_QR_M1_1:            wsprintf(pszBarStr, TEXT("QR M1 1")); break;
   case BARCODE_QR_M1_2:            wsprintf(pszBarStr, TEXT("QR M1 2")); break;
   case BARCODE_QR_M1_3:            wsprintf(pszBarStr, TEXT("QR M1 3")); break;
   case BARCODE_QR_M1_4:            wsprintf(pszBarStr, TEXT("QR M1 4")); break;
   case BARCODE_QR_M1_5:            wsprintf(pszBarStr, TEXT("QR M1 5")); break;
   case BARCODE_QR_M1_6:            wsprintf(pszBarStr, TEXT("QR M1 6")); break;
   case BARCODE_QR_M1_7:            wsprintf(pszBarStr, TEXT("QR M1 7")); break;
   case BARCODE_QR_M1_8:            wsprintf(pszBarStr, TEXT("QR M1 8")); break;
   case BARCODE_QR_M1_9:            wsprintf(pszBarStr, TEXT("QR M1 9")); break;
   case BARCODE_QR_M1_10:           wsprintf(pszBarStr, TEXT("QR M1 10")); break;
   case BARCODE_QR_M1_11:           wsprintf(pszBarStr, TEXT("QR M1 11")); break;
   case BARCODE_QR_M1_12:           wsprintf(pszBarStr, TEXT("QR M1 12")); break;
   case BARCODE_QR_M1_13:           wsprintf(pszBarStr, TEXT("QR M1 13")); break;
   case BARCODE_QR_M1_14:           wsprintf(pszBarStr, TEXT("QR M1 14")); break;
   case BARCODE_QR_M1_DEF:          wsprintf(pszBarStr, TEXT("QR M1 DEF")); break;
   }
}

VOID GetBarUnitsStr(L_INT nUnits, L_TCHAR * pszBarUnits)
{
   switch (nUnits)
   {
   case BARCODE_SCANLINES_PER_PIXELS:
      wsprintf(pszBarUnits, TEXT("Scans/pixels"));
      break;
   case BARCODE_INCHES:
      wsprintf(pszBarUnits, TEXT("Inches"));
      break;
   case BARCODE_MILLIMETERS:
      wsprintf(pszBarUnits, TEXT("Millimeters"));
      break;
   }
}

VOID WriteBarCodes (HWND hWnd)
{
   L_INT       nRet, nRetError;
   LPCHILDDATA pData;
   HCURSOR     hOldCur;
   L_TCHAR      szBuffer[MAX_BUFFER_SIZE];
   L_TCHAR      szError[MAX_BUFFER_SIZE];

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   pData   = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   BarCodeData.uStructSize = sizeof(BARCODEDATA);
   BarWColor.uStructSize = sizeof(BARCODECOLOR);
   BarW1D.uStructSize = sizeof(BARCODE1D);
   BarWPDF.uStructSize = sizeof(BARCODEWRITEPDF);
   BarWDM.uStructSize = sizeof(BARCODEWRITEDM);
   BarWQR.uStructSize = sizeof(BARCODEWRITEQR);

   nRet = L_BarCodeWriteExt2(&pData->Bitmap,
                             &BarCodeData,
                             &BarWColor,
                             ulWFlags,
                             &BarW1D,
                             &BarWPDF,
                             &BarWDM,
                             &BarWQR,
                             NULL);

   if (nRet == SUCCESS)
      RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
   else
   {
      memset(szBuffer, 0, MAX_BUFFER_SIZE);
      memset(szError, 0, MAX_BUFFER_SIZE);

      wsprintf(szBuffer, TEXT("An error occurred in L_BarCodeWriteExt2,"));
      nRetError = GetBarErrorString(nRet, szError);
      if (nRetError == SUCCESS)
         wsprintf(szBuffer, TEXT("%s\nError Code is %s\nError No. = %d\n"), szBuffer, szError, nRet);
      else
         wsprintf(szBuffer, TEXT("%s\nError No. = %d\n"), szError, nRet);
      MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
   }
   SetCursor(hOldCur);
}

VOID FindFirstDupilcate (HWND hWnd)
{
   L_INT       nRet;
   LPCHILDDATA pData;
   HCURSOR     hOldCur;
   L_TCHAR      szBuffer[MAX_BUFFER_SIZE];
   L_TCHAR      szError[MAX_BUFFER_SIZE];

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   pData   = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   memset  (szBuffer, 0, MAX_BUFFER_SIZE);
   memset  (szError, 0, MAX_BUFFER_SIZE);

   if ((nDupIndex >= 0) && (nDupIndex < pData->pBarCodeData[0].nTotalCount))
   {
      pData->bIsBarDup = L_BarCodeIsDuplicated(&pData->pBarCodeData[nDupIndex]);

      if (pData->bIsBarDup)
      {
         pData->nDupBarIndex = L_BarCodeGetFirstDuplicated(pData->pBarCodeData, nDupIndex);

         if (pData->nDupBarIndex < 0)
         {
            pData->bIsBarDup = FALSE;
  
            wsprintf(szBuffer, TEXT("An error occurred in L_BarCodeGetFirstDuplicated,"));
            nRet = GetBarErrorString(pData->nDupBarIndex, szError);
            if (nRet == SUCCESS)
               wsprintf(szBuffer, TEXT("%s\nError Code is %s\nError No. = %d\n"), szBuffer, szError, pData->nDupBarIndex);
            else
               wsprintf(szBuffer, TEXT("%s\nError No. = %d\n"), szBuffer, pData->nDupBarIndex);

            MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
         }
         else
            DisplayBarCodeInfo(hWnd, pData->nDupBarIndex);
      }
      else
      {
         wsprintf(szBuffer, TEXT("The Bar Code selected by index was not duplicated"));
         MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
      }
   }

   EnableActionsMenu (hwndFrame, hWnd);
   SetCursor(hOldCur);
}

VOID FindNextDupilcate (HWND hWnd)
{
   L_INT       nRet;
   LPCHILDDATA pData;
   HCURSOR     hOldCur;
   L_TCHAR      szBuffer[MAX_BUFFER_SIZE];
   L_TCHAR      szError[MAX_BUFFER_SIZE];

   hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
   pData   = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);
   memset (szBuffer, 0, MAX_BUFFER_SIZE);
   memset (szError, 0, MAX_BUFFER_SIZE);

   pData->nDupBarIndex = L_BarCodeGetNextDuplicated(pData->pBarCodeData, pData->nDupBarIndex);
   if (pData->nDupBarIndex < 0)
   {
      pData->bIsBarDup = FALSE;

      wsprintf(szBuffer, TEXT("An error occurred in L_BarCodeGetNextDuplicated,"));
      nRet = GetBarErrorString(pData->nDupBarIndex, szError);
      if (nRet == SUCCESS)
         wsprintf(szBuffer, TEXT("%s\nError Code is %s\nError No. = %d\n"), szBuffer, szError, pData->nDupBarIndex);
      else
         wsprintf(szBuffer, TEXT("%s\nError No. = %d\n"), szBuffer, pData->nDupBarIndex);

      MessageBox(hWnd, szBuffer, TEXT("Error!"), MB_OK);
   }
   else
      DisplayBarCodeInfo(hWnd, pData->nDupBarIndex);

   EnableActionsMenu (hwndFrame, hWnd);
   SetCursor(hOldCur);
}

static VOID Child_OnSetFocus(HWND hWnd, HWND hWndOldFocus)
{
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if(L_BitmapHasRgn(&pData->Bitmap))
      SetTimer(hWnd, 1, 100, NULL);
}

static VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus)
{
   LPCHILDDATA pData;
   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if(L_BitmapHasRgn(&pData->Bitmap))
      KillTimer(hWnd, 1);
}

BOOL Child_OnQueryNewPalette (HWND hWnd)
{
   HDC         hDC;
   HPALETTE    hPalette;
   L_INT       nColors = 0;
   LPCHILDDATA pData;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

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

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

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

      if (pData->hPalette)
      {
         hPalette = SelectPalette (hDC, pData->hPalette, FALSE);
         nColors = RealizePalette (hDC);

         if (nColors)
            InvalidateRect(hWnd, NULL, FALSE);

         SelectPalette (hDC, hPalette, TRUE);
      }
      ReleaseDC (hWnd, hDC);
   }
   return (nColors);
}

VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   HDC         hDC;
   HPALETTE    hPalette;
   LPCHILDDATA pData;

   pData = (LPCHILDDATA) GetWindowLong(hWnd, GWL_USERDATA);

   if (hWnd == hWndPaletteChange)
      return;

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

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

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

      hPalette = SelectPalette (hDC, pData->hPalette, TRUE);
      RealizePalette (hDC);

      InvalidateRect (hWnd, NULL, FALSE);
      SelectPalette (hDC, hPalette, TRUE);
      ReleaseDC (hWnd, hDC);
   }
   return;
}

VOID ConvertNULLString(L_CHAR L_FAR * pszSrcBuf, L_CHAR L_FAR * pszDestBuf, L_INT nBufCount)
{
   int n = 0;

   while (n < nBufCount)
   {
      if(pszSrcBuf[n] == '\0')
         pszDestBuf[n] = ' ';
      else
         pszDestBuf[n] = pszSrcBuf[n];

      n++;
   }

   //pszDestBuf[nBufCount - 1] = '\0';
}