#include "MainFram.h"
#include "Child.h"
#include "Dialogs.h"
#include "Util.h"
#include "resource.h"
#include "tchar.h"

L_BOOL gbPaste;


WINDOWDATA Data;

HWND hWndFrame,hWndClient;
HMENU hMenuInit,hChildMenu,hContextMenu;
HMENU hMenuInitWindow,hChildMenuWindow;

L_TCHAR szChildClass[]= TEXT("ChildWindow");
L_TCHAR szFrameClass[]= TEXT("FrameWindow");
HINSTANCE hInst;

LOADFILEOPTION LoadFileOption;
L_TCHAR szAnnFile[L_MAXPATH]=TEXT("");

#define ISTIF(nFormat)                    \
   ((nFormat) == FILE_JTIF ||             \
    (nFormat) == FILE_LEAD2JTIF ||        \
    (nFormat) == FILE_LEAD1JTIF ||        \
    (nFormat) == FILE_TIFLZW ||           \
    (nFormat) == FILE_TIFLZW_CMYK ||      \
    (nFormat) == FILE_TIFLZW_YCC ||       \
    (nFormat) == FILE_TIF ||              \
    (nFormat) == FILE_TIF_CMYK ||         \
    (nFormat) == FILE_TIF_YCC ||          \
    (nFormat) == FILE_TIF_PACKBITS ||     \
    (nFormat) == FILE_TIF_PACKBITS_CMYK ||\
    (nFormat) == FILE_TIF_PACKBITS_YCC || \
    (nFormat) == FILE_CCITT ||            \
    (nFormat) == FILE_CCITT_GROUP3_1DIM ||\
    (nFormat) == FILE_CCITT_GROUP3_2DIM ||\
    (nFormat) == FILE_CCITT_GROUP4 ||     \
    (nFormat) == FILE_TIF_CMP ||          \
    (nFormat) == FILE_TIF_JBIG)

/*====(WinMain)=================================================
Description: Registers Frame window and Client window.

Syntax:     L_INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                                 LPSTR lpstrCommandLine, L_INT nComShow)

==========================================================================*/

L_INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpstrCommandLine,
                     L_INT nComShow)
{
   MSG Msg;

   hInst = hInstance;

   if (!RegisterAllWindows())
      return FALSE;

   if (!InitInstance(nComShow))
      return FALSE;

   L_DlgInit(DLG_INIT_COLOR);
   /* Enter the modified message loop */
   while (GetMessage (&Msg, NULL, 0, 0))
   {
      if ((!TranslateMDISysAccel(hWndClient, &Msg)) /*&&
          (!TranslateAccelerator(hWndClient, hAccel, &msg))*/)
      {
         TranslateMessage (&Msg);
         DispatchMessage (&Msg);
      }
   }

   L_DlgFree();
   DestroyMenu(hChildMenu);
   DestroyMenu(hMenuInit);
   DestroyMenu(hContextMenu);
   DestroyMenu(hChildMenuWindow);
   DestroyMenu(hMenuInitWindow);

   if (Data.Bitmap.Flags.Allocated)
      L_FreeBitmap(&Data.Bitmap);

   return Msg.wParam;
}

/*====(RegisterAllWindows)=================================================
Description: Registers Frame window and Client window.

Syntax:     L_BOOL RegisterAllWindows(L_VOID)

==========================================================================*/

L_BOOL RegisterAllWindows(L_VOID)
{
   WNDCLASS wndClass;
   L_BOOL fRegistered;

   /* Register the frame window class */
   wndClass.style          = CS_HREDRAW | CS_VREDRAW;
   wndClass.lpfnWndProc    = (WNDPROC) FrameWndProc;
   wndClass.cbClsExtra     = 0;
   wndClass.cbWndExtra     = 0;
   wndClass.hInstance      = hInst;
   wndClass.hIcon          = LoadIcon(hInst, MAKEINTRESOURCE (IDI_LVICON));
   wndClass.hCursor        = LoadCursor(NULL, IDC_ARROW);
   wndClass.hbrBackground  = (HBRUSH) GetStockObject(DKGRAY_BRUSH);
   wndClass.lpszMenuName   = NULL;
   wndClass.lpszClassName  = szFrameClass;

   fRegistered = RegisterClass (&wndClass);
   if (!fRegistered)
      return FALSE;

   /* Register the child window class */
   wndClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
   wndClass.lpfnWndProc    = (WNDPROC) ChildWindowProc;
   wndClass.cbClsExtra     = 0;
   wndClass.cbWndExtra     = sizeof(HANDLE);
   wndClass.hInstance      = hInst;
   wndClass.hIcon          = LoadIcon(hInst, MAKEINTRESOURCE (IDI_LVICON));
   wndClass.hCursor        = LoadCursor(NULL, IDC_ARROW); 
   wndClass.hbrBackground  = (HBRUSH) GetStockObject(GRAY_BRUSH);
   wndClass.lpszMenuName   = NULL;
   wndClass.lpszClassName  = szChildClass;

   fRegistered = RegisterClass(&wndClass);
   if (!fRegistered)
      return FALSE;

   return TRUE;
}



/*====(InitInstance)=================================================
Description: 

Syntax:     L_BOOL InitInstance(L_INT nCmdShow)

==========================================================================*/

L_BOOL InitInstance(L_INT nCmdShow)
{
   L_GetDefaultLoadFileOption(&LoadFileOption, sizeof(LOADFILEOPTION));
   /* Obtain handles to three possible menus */
   hMenuInit      = LoadMenu(hInst, MAKEINTRESOURCE(IDR_INIT_FRAME_MENU));
   hChildMenu     = LoadMenu(hInst, MAKEINTRESOURCE(IDR_CHILD_MENU));
   hContextMenu   = LoadMenu(hInst, MAKEINTRESOURCE(IDR_CONTEXT_MENU));

   /* Obtain handles to two possible submenus */
   hMenuInitWindow   = GetSubMenu(hMenuInit, INIT_MENU_POS);
   hChildMenuWindow  = GetSubMenu(hChildMenu, CHILD_MENU_POS);

   /* Create the frame window */
   hWndFrame = CreateWindow(szFrameClass,
                            TEXT("Zoom View Demo"),
                            WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            NULL,
                            hMenuInit,
                            hInst,
                            NULL);
   if (hWndFrame)
   {
      ShowWindow(hWndFrame, nCmdShow);
      UpdateWindow(hWndFrame);
      return TRUE;
   }

   return FALSE;
}

/*====(CloseEnumFunc)=================================================
Description: 

Syntax:     L_BOOL CALLBACK CloseEnumFunc(HWND hwnd, LPARAM lParam)

==========================================================================*/


L_BOOL CALLBACK CloseEnumFunc(HWND hwnd, LPARAM lParam)
{
   if (GetWindow(hwnd,GW_OWNER))
      return TRUE;

   FORWARD_WM_MDIRESTORE(hWndClient,hwnd,SendMessage);

   if (!FORWARD_WM_QUERYENDSESSION(hwnd,SendMessage))
      return TRUE;

   FORWARD_WM_MDIDESTROY(hWndClient,hwnd,SendMessage);

   return TRUE;
}

/*====(FrameWndProc)=================================================
Description: 

Syntax:     LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

==========================================================================*/

LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch(msg)
   {
      HANDLE_MSG (hwnd, WM_CREATE,              MainFrame_OnCreate);
      HANDLE_MSG (hwnd, WM_COMMAND,             MainFrame_OnCommand);
      HANDLE_MSG (hwnd, WM_CLOSE,               MainFrame_OnCloseQuery);
      HANDLE_MSG (hwnd, WM_QUERYENDSESSION,     MainFrame_OnCloseQuery);
      HANDLE_MSG (hwnd, WM_SETFOCUS,            MainFrame_OnSetFocus);
      HANDLE_MSG (hwnd, WM_CONTEXTMENU,         MainFrame_OnContextMenu);
      /* For Palette*/
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,      MainFrame_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE,     MainFrame_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_PALETTEISCHANGING,   MainFrame_OnPaletteChanging);
      HANDLE_MSG (hwnd, WM_SYSCOLORCHANGE,      MainFrame_SysColorChange);

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

/*====(PaletteChangedAll)=================================================
Description: 

Syntax:     L_BOOL CALLBACK PaletteChangedAll(HWND hwnd, LPARAM lParam)

==========================================================================*/

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

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

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

   return TRUE;
}

/*====(MainFrame_OnPaletteChanged)=================================================
Description: 

Syntax:     L_VOID MainFrame_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)

==========================================================================*/

L_VOID MainFrame_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)
{
   FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteChangedAll, hInst);
   EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, (LPARAM) (UINT) hwndPaletteChange);
   FreeProcInstance (lpfn);
   return;
}


/*====(MainFrame_OnQueryNewPalette)=================================================
Description: 

Syntax:     L_BOOL MainFrame_OnQueryNewPalette(HWND hwnd)

==========================================================================*/

L_BOOL MainFrame_OnQueryNewPalette(HWND hwnd)
{
   HWND hwndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage);

   if (hwndChild)
      FORWARD_WM_QUERYNEWPALETTE (hwndChild, SendMessage);

   return TRUE;
}

/*====(MainFrame_OnPaletteChanging)==========================================
Description: Enumerates all child windows and asks them to realize their
             logical palettes beside the physical palette.

Syntax     : VOID MainFrame_OnPaletteChanging(HWND hwnd, HWND hWndPaletteChange)

Parameters : hwnd                 Handle to a window.
             hWndPaletteChange    Handle to a window that has the palette
                                  realized.

Return Value: None.
==========================================================================*/
L_VOID  MainFrame_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   MainFrame_OnPaletteChanged (hWnd, hWndPaletteChange);
}

L_VOID MainFrame_SysColorChange(HWND hwnd)
{
   MainFrame_OnQueryNewPalette (hwnd);
}


/*====(MainFrame_OnCloseQuery)=================================================
Description: 

Syntax:     L_VOID MainFrame_OnCloseQuery(HWND hwnd)

==========================================================================*/

L_BOOL MainFrame_OnCloseQuery(HWND hwnd)
{
   FORWARD_WM_COMMAND(hwnd,IDM_CLOSE_ALL,0,0,SendMessage);
   PostQuitMessage(0);
   return TRUE;
}

/*====(MainFrame_OnCreate)=================================================
Description: 

Syntax:     L_VOID MainFrame_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)

==========================================================================*/

L_BOOL MainFrame_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
   CLIENTCREATESTRUCT ClientCreate;

   ClientCreate.hWindowMenu   = hMenuInit;
   ClientCreate.idFirstChild  = ID_FIRSTCHILD;

   gbPaste=FALSE;

   Check_Menu_Items(hMenuInit,NULL);

   hWndClient = CreateWindow(TEXT("MDICLIENT"),
                             NULL,
                             WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             hwnd,
                             (HMENU) 1,
                             hInst, 
                             (PSTR) &ClientCreate);
   if (hWndClient)
   {
      /* Unlocks the support for LEAD features */
      UNLOCKSUPPORT();

      return TRUE;
   }

   return FALSE;
}

/*====(MainFrame_OnSetFocus)=================================================
Description: 

Syntax:     L_VOID MainFrame_OnSetFocus(HWND hwnd,HWND oldhwnd)

==========================================================================*/

L_VOID MainFrame_OnSetFocus(HWND hwnd,HWND oldhwnd)
{
   if (L_ClipboardReady())
   {
      gbPaste=TRUE;
      Check_Menu_Items(hMenuInit,NULL);
      Check_Menu_Items(hChildMenu,NULL);
   }
   else
   {
      gbPaste=FALSE;
      Check_Menu_Items(hMenuInit,NULL);
      Check_Menu_Items(hChildMenu,NULL);
   }
}


/*====(MainFrame_OnCommand)=================================================
Description: 

Syntax:     L_VOID MainFrame_OnCommand(HWND hwnd, L_INT id, HWND hwndCtl, UINT codeNotify)

==========================================================================*/

L_VOID MainFrame_OnCommand(HWND hwnd, L_INT id, HWND hwndCtl, UINT codeNotify)
{
   HWND hwndChild;

   switch(id)
   {
   case IDM_OPEN_FILE:
      OpenFile(hwnd);
      break;

   case IDM_EXIT:
      FORWARD_WM_CLOSE(hwnd,SendMessage);
      break;

   case IDM_CLOSE_ALL:
      EnumChildWindows(hWndClient,(WNDENUMPROC)CloseEnumFunc,0);
      break;

   case IDM_ARRANGE:
      FORWARD_WM_MDIICONARRANGE(hWndClient,SendMessage);
      break;

   case IDM_CASCADE:
      FORWARD_WM_MDICASCADE(hWndClient,0,SendMessage);
      break;

   case IDM_TILE:
      FORWARD_WM_MDITILE(hWndClient,0,SendMessage);
      break;

   case IDM_PASTE:
      MainFrame_Paste(hwnd);
      break;

   case IDM_ABOUT:
      DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_ABOUT),hwnd,(DLGPROC)AboutDlgProc,NULL);
      break;

   default:
      hwndChild=(HWND) SendMessage(hWndClient,WM_MDIGETACTIVE,0,0);
      if (IsWindow(hwndChild))
         FORWARD_WM_COMMAND(hwndChild,id,hwndCtl,codeNotify,SendMessage);

      DefFrameProc(hwnd,hWndClient,WM_COMMAND,MAKEWPARAM((UINT)(id),(UINT)(codeNotify)),(LPARAM)(HWND)(hwndCtl));
      break;
   }
   return;
}

/*====(MainFrame_OnContextMenu==============================================
Description: 

Syntax:     L_BOOL  MainFrame_OnContextMenu(HWND hWnd, HWND hwndCtl, L_INT xPos, L_INT yPos)

==========================================================================*/

L_BOOL MainFrame_OnContextMenu(HWND hWnd, HWND hwndCtl, L_INT xPos, L_INT yPos)
{
   RECT  rcClient;
   HWND  hWndChild;
   POINT pt;
   
   // Get the position of mouse click
   pt.x = xPos;
   pt.y = yPos;

   hWndChild = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);

   if (hWndChild)
   {
      if (Child_DisplayContextMenu(hWndChild, pt))
         return TRUE;
   }

   // Get the bounding rectangle of the client area. 
   GetClientRect(hWnd, &rcClient);
   
   // Convert the mouse position to client coordinates. 
   ScreenToClient(hWnd, &pt);
   
   if (PtInRect(&rcClient, pt))
   {
      if (DisplayContextMenu(hWnd, pt))
         return TRUE;
   }

   // Otherwise forward the message for default processing
   FORWARD_WM_CONTEXTMENU(hWnd, hwndCtl, xPos, yPos, DefWindowProc);

   return TRUE;
}

/*====(CreateChildWindow)=================================================
Description: 

Syntax:     HWND CreateChildWindow()

==========================================================================*/

static HWND CreateChildWindow (LPTSTR pszTitle, pBITMAPHANDLE pBitmap,HANNOBJECT hObject)
{
   HWND              hWndChild;
   MDICREATESTRUCT   mdiCreateStruct;
   CREATEDATA CreateData;

   CreateData.pszTitle = pszTitle;
   CreateData.pBitmap = pBitmap;
   CreateData.hObject = hObject;
   memcpy(&CreateData.Data , &Data, sizeof(Data));

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

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

/*====(OpenFile)=================================================
Description: 

Syntax:     L_BOOL OpenFile(HWND hwnd)

==========================================================================*/

L_VOID OpenFile(HWND hwnd)
{
   HANNOBJECT hObject = NULL;
   int nRet =0;
   if (GetOpenFile(hwnd))
     if (LoadImage(hwnd))
     {
        GetAnnFile(szAnnFile, Data.szFilename, 1, -1);
        nRet = L_AnnLoad(szAnnFile, &hObject, NULL);
        CreateChildWindow (Data.szFilename, &Data.Bitmap, hObject);
     }
}

/*====(GetOpenFile)=================================================
Description: 

Syntax:     WINDOWDATA GetOpenFile(HWND hWnd)

==========================================================================*/

L_BOOL GetOpenFile(HWND hWnd)
{
   L_INT nRet;
   OPENFILENAME OpenFileName;
   OPENDLGPARAMS FOParm;

   memset (&OpenFileName, 0, sizeof (OPENFILENAME));
   memset(&FOParm, 0, sizeof(OPENDLGPARAMS));

   FOParm.uStructSize      = sizeof(OPENDLGPARAMS);
   FOParm.bPreviewEnabled  = TRUE;
   FOParm.uDlgFlags        = DLG_OPEN_SHOW_FILEINFO| 
                             DLG_OPEN_SHOW_PREVIEW | 
                             DLG_OPEN_USEFILESTAMP;

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 0;

   OpenFileName.lpstrTitle        = TEXT("Open a File");
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = NULL;

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

   if (nRet == SUCCESS_DLG_OK)
   {
      nRet = L_FileInfo(FOParm.pFileData[0].szFileName, &Data.FileInfo,sizeof(FILEINFO), 0, NULL);
      if (nRet != SUCCESS)
      {
         L_FileError(hWnd, nRet, TEXT("Open Bitmap File"), FOParm.pFileData[0].szFileName);
         return FALSE;
      }
      else
      {
         lstrcpy(Data.szFilename, FOParm.pFileData[0].szFileName);
         return TRUE;
      }
      CleanOpenDlgParam(&FOParm);
   }
   else
      return FALSE;
}

/*====(ImageLoad)=================================================
Description: 

Syntax:     L_BOOL ImageLoad(HWND hWnd)

==========================================================================*/

L_BOOL LoadImage(HWND hWnd)
{
   HDC hDC;
   HCURSOR hCursor;
   LOADFILEOPTION LoadFileOption;
   L_INT nRet;
   L_INT nDeviceBits;
   L_INT nFlags = LOADFILE_ALLOCATE | LOADFILE_STORE;

   L_GetDefaultLoadFileOption(&LoadFileOption, sizeof(LOADFILEOPTION));
   
   hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));

   /* Compute Device Bits -- Device color mode */
   hDC = GetDC (hWnd);
   nDeviceBits = GetDeviceCaps (hDC, BITSPIXEL) * GetDeviceCaps (hDC, PLANES);

   /* If Device bits is > 8, set device bits to 24 */
   if (nDeviceBits > 8)
      nDeviceBits = 24;
   ReleaseDC (hWnd, hDC);

   if (Data.Bitmap.Flags.Allocated)
      L_FreeBitmap (&Data.Bitmap);

   /* Get Image file information and load it to FileInfo structure */
   if ((nRet = L_FileInfo (Data.szFilename, &Data.FileInfo,sizeof(FILEINFO), 0, NULL)) != SUCCESS)
   {
      SetCursor (hCursor);
      return (FALSE);
   }

   /* Initialize Bitmap */
   L_InitBitmap (&Data.Bitmap, sizeof(BITMAPHANDLE),Data.FileInfo.Width, Data.FileInfo.Height,Data.FileInfo.BitsPerPixel);

   if (nDeviceBits <= 4)
      nFlags |= LOADFILE_FIXEDPALETTE; 

   /* Load the file to the bitmap */
   if ((Data.FileInfo.Order==1)||(	Data.FileInfo.Order==0))
      nRet = L_LoadFile (Data.szFilename, &Data.Bitmap, sizeof(BITMAPHANDLE),Data.FileInfo.BitsPerPixel,
                         ORDER_BGR, nFlags, NULL, NULL, NULL, &Data.FileInfo);
   else
      nRet = L_LoadFile (Data.szFilename, &Data.Bitmap, sizeof(BITMAPHANDLE),Data.FileInfo.BitsPerPixel,
                         Data.FileInfo.Order, nFlags, NULL, NULL, NULL, &Data.FileInfo);

   SetCursor (hCursor);
   if (nRet != SUCCESS)
      return (nRet);

   return (TRUE);
}

/*====(Check_Menu_Items)=================================================
Description: 

Syntax:     L_VOID Check_Menu_Items(HMEN hmenu, pFLAGSDATA pFlagsData)

==========================================================================*/

L_VOID Check_Menu_Items(HMENU hmenu, pFLAGSDATA pFlagsData)
{
   /*the following flags are shared by all windows*/
   if (gbPaste)
      EnableMenuItem(hmenu,IDM_PASTE,MF_ENABLED);
   else
      EnableMenuItem(hmenu,IDM_PASTE,MF_GRAYED);

   /*the following are private flags dependent on the type of the window*/

   if (pFlagsData)
   {
      /* Add your code here */
      if (pFlagsData->bCopy)
         EnableMenuItem(hmenu,IDM_COPY,MF_ENABLED);
      else
         EnableMenuItem(hmenu,IDM_COPY,MF_GRAYED);

      CheckMenuItem (hmenu, IDM_VIEW_NORMAL, (!pFlagsData->bFitImage && !pFlagsData->bZoom) ? MF_CHECKED: MF_UNCHECKED);
      CheckMenuItem (hmenu, IDM_VIEW_ZOOM, (!pFlagsData->bFitImage && pFlagsData->bZoom) ? MF_CHECKED: MF_UNCHECKED);
      CheckMenuItem (hmenu, IDM_VIEW_FITIMAGE, (pFlagsData->bFitImage) ? MF_CHECKED: MF_UNCHECKED);
      CheckMenuItem (hmenu, IDM_VIEW_HILITE, pFlagsData->bHilite ? MF_CHECKED: MF_UNCHECKED);
      CheckMenuItem (hmenu, IDM_BITONALNORMAL, (pFlagsData->nBitonalFlags == 0 ? MF_CHECKED: MF_UNCHECKED));
      CheckMenuItem (hmenu, IDM_SCALETOGRAY, (pFlagsData->nBitonalFlags == DISPLAYMODE_SCALETOGRAY) ? MF_CHECKED: MF_UNCHECKED);
      CheckMenuItem (hmenu, IDM_FAVORBLACK, (pFlagsData->nBitonalFlags == DISPLAYMODE_FAVORBLACK) ? MF_CHECKED: MF_UNCHECKED);
   }
}

/*====(MainFrame_Paste)=================================================
Description: 

Syntax:     L_VOID MainFrame_Paste(HWND hwnd)

==========================================================================*/

L_VOID MainFrame_Paste(HWND hwnd)
{
   static L_INT nNoPaste=0;
   L_BOOL GoodData; 
   L_AnnClipboardReady(&GoodData);
   HANNOBJECT TmpContainer = NULL;

   /* Copy the annotations, if they exist */
   if (GoodData)
   {
      L_AnnCopyFromClipboard(hwnd, &TmpContainer);
      /* The following code inserts the copied annotations and allows you to see the results.  */ 
      //..L_AnnInsert(hContainer, TmpContainer, TRUE);
   }

   if (L_ClipboardReady())
   {
      nNoPaste++;
      memset(&Data,0,sizeof(WINDOWDATA));
      L_CopyFromClipboard(hwnd,&Data.Bitmap,sizeof(BITMAPHANDLE));
      wsprintf(Data.szFilename,TEXT("Clipboard Data: %d"),nNoPaste);
      CreateChildWindow(Data.szFilename, &Data.Bitmap ,TmpContainer);
   }
   else
   {
      gbPaste = FALSE;
      Check_Menu_Items(hMenuInit,NULL);
   }
}

/*====(DisplayContextMenu)=================================================
Description: 

Syntax:     L_BOOL DisplayContextMenu(HWND hWnd, POINT pt)

==========================================================================*/

L_BOOL DisplayContextMenu(HWND hWnd, POINT pt)
{
   L_INT nItems;
   HMENU hmenuBar, hmenuPopup;
   
   // Get main menu handle
   hmenuBar = GetMenu(hWnd);
   
   // Get the count of items on the main menu
   nItems = GetMenuItemCount(hmenuBar);
   
   hmenuPopup = GetSubMenu(hmenuBar, nItems - 1);

   // Convert click location to screen coordinates
   ClientToScreen(hWnd, &pt);
   
   return TrackPopupMenu(hmenuPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, hWnd, NULL);
}

/*====(GetAnnFile)=================================================
Description: 

Syntax:     L_VOID GetAnnFile(LPTSTR pDest, LPTSTR pSource, L_UINT nPage, L_INT nFormat)

==========================================================================*/

L_VOID GetAnnFile(LPTSTR pDest, LPTSTR pSource, L_UINT nPage, L_INT nFormat)
{
   LPTSTR p;
   L_UINT16 uType;
   L_UINT32 uCount;
   L_INT    nOldPage;

   nOldPage = LoadFileOption.PageNumber;
   LoadFileOption.PageNumber = nPage;

   if(nFormat < 0 && L_ReadFileTag(pSource, ANNTAG_TIFF, &uType, &uCount, NULL, &LoadFileOption) > 0 ||
      ISTIF(nFormat))
      /* the file has annotation data! */
      lstrcpy(pDest, pSource);
   else
   {  
      /* else look for a .ANN file */
      lstrcpy(pDest, pSource);
      p = _tcsrchr(pDest, '.');
      if(!p)
         p = _tcsrchr(pDest, '\0');
      lstrcpy(p, TEXT(".ann"));
   }
   LoadFileOption.PageNumber = nOldPage;
}