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

/*-------------------------------------------------------------------------
  We have made the assumption that the user has the knowledge of programming
  in C and Windows.

  This demo program demonstrates the use of Bar Code functions,
  builds a complete application that uses the Windows MDI capabilities,
  and shows methods of interaction with the Windows environment.
  --------------------------------------------------------------------------*/

#define STRICT

#include <windows.h>
#include <windowsx.h>
#include "resource.h"
#include "BarCode.h"

// Global variables

L_TCHAR    szFrameClass[] = TEXT ("MDIFrame");
L_TCHAR    szChildClass[] = TEXT ("MDIBarChild");
HMENU     hMenuInitWindow, hMenuChildWindow;
HMENU     hMenuInit, hMenuChild;
HINSTANCE hInstMain;
HWND      hwndFrame, hwndClient;


int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, 
                    PSTR szCmdLine, int iCmdShow)
{
   HACCEL   hAccel;
   MSG      msg;
   WNDCLASS wndclass;

   hInstMain = hInstance;

   // Register the frame window class

   wndclass.style         = CS_HREDRAW | CS_VREDRAW;
   wndclass.lpfnWndProc   = FrameWndProc;
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = 0;
   wndclass.hInstance     = hInstance;
   wndclass.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_MAINFRAME));
   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wndclass.hbrBackground = (HBRUSH) GetStockObject(DKGRAY_BRUSH);
   wndclass.lpszMenuName  = NULL;
   wndclass.lpszClassName = szFrameClass;
     
   if (!RegisterClass (&wndclass))
      return 0;
        
   // Register the child window class

   wndclass.style         = 0;/*CS_HREDRAW | CS_VREDRAW*/;
   wndclass.lpfnWndProc   = ChildWndProc;
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = sizeof (HANDLE);
   wndclass.hInstance     = hInstance;
   wndclass.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_CHILDFRAME));
   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wndclass.hbrBackground = (HBRUSH) GetStockObject (GRAY_BRUSH);
   wndclass.lpszMenuName  = NULL;
   wndclass.lpszClassName = szChildClass;

   if (!RegisterClass (&wndclass))
      return 0;

   // Obtain handles to three possible menus & submenus  
   hMenuInit  = LoadMenu (hInstance, MAKEINTRESOURCE(IDR_MAINFRAME));
   hMenuChild = LoadMenu (hInstance, MAKEINTRESOURCE(IDR_CHILDFRAME));

   hMenuInitWindow  = GetSubMenu (hMenuInit,   INIT_MENU_POS);
   hMenuChildWindow = GetSubMenu (hMenuChild, CHILD_MENU_POS);

   // Load accelerator table

   hAccel = LoadAccelerators (hInstance, MAKEINTRESOURCE(IDC_MAINACCEL));

   // Create the frame window

   hwndFrame = CreateWindow(szFrameClass,
                            TEXT ("Bar Code Demo"),
                            WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            NULL,
                            hMenuInit,
                            hInstance,
                            NULL);

   ShowWindow (hwndFrame, iCmdShow);
   UpdateWindow (hwndFrame);

   // Enter the modified message loop
     
   while (GetMessage (&msg, NULL, 0, 0))
   {
      if ((!TranslateMDISysAccel (hwndClient, &msg)) &&
          (!TranslateAccelerator (hwndFrame, hAccel, &msg)))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   }

   // Clean up by deleting unattached menus
   DestroyMenu (hMenuChild);

   return msg.wParam;
}
     
L_BOOL CALLBACK CloseEnumProc (HWND hwnd, LPARAM lParam)
{
   if (GetWindow (hwnd, GW_OWNER))         // Check for icon title
      return TRUE;

   SendMessage (GetParent (hwnd), WM_MDIRESTORE, (WPARAM) hwnd, 0);

   if (!SendMessage (hwnd, WM_QUERYENDSESSION, 0, 0))
      return TRUE;

   SendMessage (GetParent (hwnd), WM_MDIDESTROY, (WPARAM) hwnd, 0);
   return TRUE;
}

L_INT DoDialogBoxParam(L_INT nDialog, HWND hWnd, DLGPROC pfnDialog, LPARAM lParam)
{
   DLGPROC pfn;
   L_INT   nRet;

   pfn = (DLGPROC) MakeProcInstance((FARPROC) pfnDialog, hInstMain);
   nRet = DialogBoxParam (hInstMain, MAKEINTRESOURCE (nDialog), hWnd, pfn, lParam);
   FreeProcInstance((FARPROC) pfn);
   return(nRet);
}

L_VOID InitRWDialogs(L_VOID)
{
   /* Default values for Global Read Dialog */
   bRUseColors       = TRUE;
   bSearchAll        = TRUE;
   bUseRgn           = FALSE;
#ifdef UNICODE
   nRCurSelSymbType  = BAR_CODE_PDF;
#else
   nRCurSelSymbType  = BAR_CODE_1D;
#endif
   nRUnits           = BARCODE_SCANLINES_PER_PIXELS;
   nMultiMax         = 0;
   ulSearchType      = 0;
   SetRect(&rcBarSearch, 0, 0, 0, 0);
   memset(&BarRPDF, 0, sizeof(BARCODEREADPDF));
   memset(&Bar1D, 0, sizeof(BARCODE1D));
   memset(&BarRColor, 0, sizeof(BARCODECOLOR));

   Bar1D.nMinLength = 3;
   Bar1D.nGranularity = 9;
   Bar1D.nWhiteLines = 3;

   BarRColor.dwColorBar = RGB(0, 0, 0);
   BarRColor.dwColorSpace = RGB(255, 255, 255);

   /* Default values for Global Write Dialog */
   memset(&BarWColor, 0, sizeof(BARCODECOLOR));
   memset(&BarCodeData, 0, sizeof(BARCODEDATA));
   memset(&BarWPDF, 0, sizeof(BARCODEWRITEPDF));
   memset(&BarW1D, 0, sizeof(BARCODE1D));
   memset(&BarWDM, 0, sizeof(BARCODEWRITEDM));
   memset(&BarWQR, 0, sizeof(BARCODEWRITEQR));

   nWCurSelSymbType  = BAR_CODE_1D;
   nWBarCodeTypeSel  = 0;
   nCurQRSelEccLevel = 0;
   nCurSelEccLevel   = 0;
   nCurSelBarType    = 0;
   ulWFlags          = 0;
   bWUseColors       = TRUE;
   bWEnbleTranparent = FALSE;

   Bar1D.nDirection  = BARCODE_DIR_HORIZONTAL;
   BarRPDF.nDirection  = BARCODE_DIR_LEFT_TO_RIGHT;
   BarWColor.dwColorBar = RGB(0, 0, 0);
   BarWColor.dwColorSpace = RGB(255, 255, 255);

   BarCodeData.ulType = BARCODE_1D_EAN_13;
   BarCodeData.nUnits = BARCODE_SCANLINES_PER_PIXELS;
   SetRect(&BarCodeData.rcBarLocation, 50, 50, 400, 150);

   BarW1D.bOutShowText = TRUE;
   BarW1D.bErrorCheck  = TRUE;
   bReturnCheckDigit   = FALSE;
   BarWDM.nXModule     = 30;

   BarWQR.uStructSize = sizeof(BARCODEWRITEQR);
   BarWQR.nGroupNumber = 0;
   BarWQR.nGroupTotal = 0;
   BarWQR.nEccLevel = BARCODE_QR_ECC_L;
   BarWQR.nXModule = 30;
}

L_BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
   BARCODEVERSION BarVerInfo;
   L_TCHAR        szBuffer[1024];
   HWND           hwndVerInfo;
   HWND           hwndParent;
   RECT           rcDlg, rcCenter;
   int            xLeft, yTop;

   UNREFERENCED_PARAMETER(lParam);
   switch (message)
   {
   case WM_INITDIALOG:
      L_BarCodeVersionInfo (&BarVerInfo, sizeof(BARCODEVERSION));
   
      wsprintf(szBuffer, TEXT("LEAD Product: %hs\nVersion %d.%d\nDate: %hs\nTime: %hs"),
               (L_TCHAR L_FAR *)BarVerInfo.Product,
               BarVerInfo.MajorNumber,
               BarVerInfo.MinorNumber,
               (L_TCHAR L_FAR *)BarVerInfo.Date,
               (L_TCHAR L_FAR *)BarVerInfo.Time);

      hwndVerInfo = GetDlgItem(hDlg, IDC_STATIC_VERSIONINFO);
      if (hwndVerInfo)
         SetWindowText(hwndVerInfo, szBuffer);

      hwndParent = GetParent(hDlg);
      if (hwndParent)
      {
         GetClientRect(hwndParent, &rcCenter);
         GetClientRect(hDlg, &rcDlg);

	      xLeft = ((rcCenter.left + rcCenter.right) / 2) - ((rcDlg.right - rcDlg.left) / 2);
	      yTop  = (rcCenter.bottom - rcCenter.top) - (rcDlg.bottom - rcDlg.top);
	      yTop  = rcCenter.top + yTop / 5;

         // if the dialog is outside the screen, move it inside
	      if (xLeft < rcCenter.left)
		      xLeft = rcCenter.left;
	      else if ((xLeft + (rcDlg.right - rcDlg.left)) > rcCenter.right)
		      xLeft = rcCenter.right - (rcDlg.right - rcDlg.left);

	      if (yTop < rcCenter.top)
		      yTop = rcCenter.top;
	      else if ((yTop + (rcDlg.bottom - rcDlg.top)) > rcCenter.bottom)
		      yTop = rcCenter.bottom - (rcDlg.bottom - rcDlg.top);

         SetWindowPos(hDlg,
                      NULL,
                      xLeft,
                      yTop,
                      -1,
                      -1,
                      SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
      }
      return(TRUE);
   case WM_COMMAND:
      switch (LOWORD(wParam))
      {
      case IDOK:
      case IDCANCEL:
         EndDialog (hDlg, 0);
         return(TRUE);
      }
   }
   return(FALSE);
}

L_BOOL CALLBACK GetIndexDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
   HWND     hwndCtrl, hwndOkBtn;
   L_TCHAR   szText[MAX_BUFFER_SIZE];

   memset(szText, 0, MAX_BUFFER_SIZE);

   UNREFERENCED_PARAMETER(lParam);
   switch (message)
   {
   case WM_INITDIALOG:
      wsprintf(szText, TEXT("%d"), nDupIndex);
      hwndCtrl = GetDlgItem(hDlg, IDC_INDEX);
      SetWindowText(hwndCtrl, szText);
      return TRUE;
   case WM_COMMAND:
      switch (LOWORD(wParam))
      {
      case IDC_INDEX:
         switch (HIWORD(wParam))
         {
         case EN_CHANGE:
            hwndCtrl = (HWND)lParam;
            GetWindowText(hwndCtrl, szText, MAX_BUFFER_SIZE);

            hwndOkBtn = GetDlgItem(hDlg, IDOK);
            EnableWindow(hwndOkBtn, (lstrlen(szText) == 0) ? FALSE : TRUE);
            break;
         }
         return TRUE;
      case IDOK:
         hwndCtrl = GetDlgItem(hDlg, IDC_INDEX);
         GetWindowText(hwndCtrl, szText, MAX_BUFFER_SIZE);
         nDupIndex = _ttoi(szText);
         EndDialog (hDlg, IDOK);
         return TRUE;
      case IDCANCEL:
         EndDialog (hDlg, IDCANCEL);
         return TRUE;
      }
   }
   return FALSE;
}

L_INT GetBarErrorString(L_INT nErrCode, L_TCHAR * pszError)
{
   if ((nErrCode > -410) || (nErrCode < -430))
      return FAILURE;

   lstrcpy(pszError, BAR_CODE_ERRORS_STR[abs(nErrCode + 410)]);
   return SUCCESS;
}