home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 5 Developer's Kit / vb5 dev kit.iso / dev / imglib12 / tstapp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-20  |  72.8 KB  |  2,478 lines
  1. /****************************************************************************
  2.     Copyright (c) 1994, 1995 by SimSoft
  3.     PROGRAM: testapp.c
  4.     PURPOSE: Test program to exercise the functionality of ImgLib
  5.  
  6.     Revision History:
  7.     Nov  6, 94  Beta release
  8.     Dec 18, 94  Release 1.0
  9.     Feb 19, 95  Release 1.1:  Added support for file saving, scrolling, sizing
  10.                               printing
  11.     Mar 25, 95  Release 1.2:  Removed references to unsupported image types.
  12.                               Added clipdoard operations by utilizing ClipDIB
  13.                               Added the "Zoom x5" feature.
  14.                               Simplified palette handling.
  15. ****************************************************************************/
  16.  
  17. #include <windows.h>
  18. #include <commdlg.h>
  19. #ifndef WIN32
  20. #include <print.h>
  21. #endif
  22. #include <malloc.h>
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include "tstapp.h"
  26. #include "imglib.h"
  27. #ifdef USE_WING
  28. #include <wing.h>
  29. typedef HDC (WINGAPI *WINGCREATEDC) (void);
  30. typedef HBITMAP (WINGAPI *WINGCREATEBITMAP) (HDC, BITMAPINFO const FAR *, void FAR *FAR *);
  31. typedef BOOL (WINGAPI *WINGSTRETCHBLT) (HDC, int, int, int, int, HDC, int, int, int, int);
  32.  
  33. WINGSTRETCHBLT fpWinGStretchBlt;
  34. WINGCREATEBITMAP fpWinGCreateBitmap;
  35. WINGCREATEDC fpWinGCreateDC;
  36. #endif
  37.  
  38. #ifdef WIN32
  39. #define huge
  40. #define CONTROL_ID(w) (LOWORD (w))
  41. #define allocmem(s) (malloc (s))
  42. #define freemem(p) (free (p))
  43. #define copymem(d, s, c) (memcpy (d, s, c))
  44. #else
  45. #define CONTROL_ID(w) (w)
  46. #define allocmem(s) (GlobalLock (GlobalAlloc (GHND, (DWORD)s)))
  47. #define freemem(p) (GlobalFree (LOWORD (GlobalHandle (HIWORD (p)))))
  48. #define copymem(d, s, c) (hmemcpy (d, s, c))
  49. #endif
  50.  
  51. typedef char huge * HPSTR;
  52.  
  53. #define WINDOW_NAME "ImgLib Test App"
  54. #define MENU_POSITION_ROTATE      5
  55. #define MENU_POSITION_MIRROR      6
  56. #define MENU_POSITION_TC_OPT      0
  57.  
  58. static HWND       hwndMain;
  59. static HINSTANCE  hInst;
  60. static char       szBuffer[256];
  61. static HINSTANCE  hWinGInst;
  62. static HACCEL     hAccel;
  63. static LPVOID     lpDIB1, lpDIB2, lpDIBDisplay;
  64. static HPALETTE   hPalette;
  65. static LPPRINTDLG pPrintDlgStruct;
  66. static BOOL       bHalftoneImgLib, bFillPage;
  67. static unsigned int uPrintCopies = 1;
  68. static RECT       rcSelection;
  69. static POINT      ptAnchor;
  70. static BOOL       bDrawSelection, bPasting;
  71. static HDC        hdcWinG;
  72. static HBITMAP    hbmpWinG, hbmpWinGOld;
  73.  
  74. static BOOL       InitApplication (HANDLE);
  75. static BOOL       InitInstance (HANDLE, int);
  76. LRESULT CALLBACK  MainWndProc (HWND, UINT, WPARAM, LPARAM);
  77. BOOL CALLBACK     AboutProc (HWND, UINT, WPARAM, LPARAM);
  78. BOOL CALLBACK     FileTypeProc (HWND, UINT, WPARAM, LPARAM);
  79. BOOL CALLBACK     BrightnessProc (HWND, UINT, WPARAM, LPARAM);
  80. BOOL CALLBACK     PrintProc (HWND, UINT, WPARAM, LPARAM);
  81. static BOOL       GetOpenFile (LPSTR);
  82. static BOOL       GetSaveFile (LPSTR);
  83. LPVOID            CreateDisplayDIB (HWND, LPVOID*, HPALETTE *);
  84. static void       UpdateWindowTitle (LPSTR, BOOL);
  85. static void       ResizeWindowToDIB (HWND, LPVOID);
  86. static void       HandleVerticalScroll (WPARAM, LPARAM);
  87. static void       HandleHorizontalScroll (WPARAM, LPARAM);
  88. static void       HandleWindowSizing (LPVOID, WPARAM, LPARAM);
  89. static void       HandlePrinting (LPVOID);
  90. static void       HandleMenuPopup (WPARAM, LPARAM);
  91. static void       InitializePrintStruct (void);
  92. static void       HandleLButtonDown (WPARAM, LPARAM);
  93. static void       HandleLButtonUp (WPARAM, LPARAM);
  94. static void       HandleMouseMove (WPARAM, LPARAM);
  95. static void       HandleRButtonDown (WPARAM, LPARAM);
  96. static void       HandleCharacter (WPARAM, LPARAM);
  97. static void       HandlePasting (WPARAM, LPARAM);
  98. static void       HandleCopying (WPARAM, LPARAM);
  99. static void       HandleZoomin (WPARAM, LPARAM);
  100. static void       DrawSelectionBox (void);
  101. static void       EraseSelectionBox (void);
  102. static void       ProcessNewDIB (LPVOID);
  103. static LRESULT    HandlePaintingAndUpdates (UINT, WPARAM, LPARAM);
  104. #ifdef USE_WING
  105. static void       InitializeWinG (void);
  106. static void       UpdateWinGBitmap (LPVOID);
  107. #endif
  108.  
  109. /****************************************************************************
  110.     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  111.     PURPOSE: calls initialization function, processes message loop
  112. ****************************************************************************/
  113.  
  114. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  115. { 
  116. MSG               msg;
  117.  
  118.   hInst = hInstance;
  119.  
  120.   if (!hPrevInstance)
  121.   {
  122.     if (!InitApplication (hInstance))
  123.       return (FALSE);
  124.   }
  125.   if (!InitInstance (hInstance, nCmdShow))
  126.     return (FALSE);
  127.   
  128.   while (GetMessage (&msg, NULL, 0, 0xffff))
  129.   {
  130.     if (!TranslateAccelerator (hwndMain, hAccel, &msg))
  131.     {
  132.       TranslateMessage (&msg);
  133.       DispatchMessage (&msg);
  134.     }
  135.   }
  136.   return (0);
  137. }
  138.  
  139.  
  140. /****************************************************************************
  141.     FUNCTION: InitApplication(HANDLE)
  142.     PURPOSE: Initializes window data and registers window class
  143. ****************************************************************************/
  144.  
  145. BOOL InitApplication (HANDLE hInstance)
  146. {
  147. WNDCLASS          wc;
  148.  
  149.   wc.style = 0;
  150.   wc.lpfnWndProc = MainWndProc;
  151.   wc.cbClsExtra = 0;
  152.   wc.cbWndExtra = 0;
  153.   wc.hInstance = hInstance;
  154.   wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  155.   wc.hCursor = LoadCursor (NULL, IDC_ARROW);
  156.   wc.hbrBackground = GetStockObject (WHITE_BRUSH);
  157.   wc.lpszMenuName = "tstappmenu";
  158.   wc.lpszClassName = "Test App";
  159.   
  160.   return (RegisterClass (&wc));
  161. }
  162.  
  163.  
  164. /****************************************************************************
  165.     FUNCTION:  InitInstance(HANDLE, int)
  166.     PURPOSE:  Saves instance handle and creates main window
  167. ****************************************************************************/
  168.  
  169. BOOL InitInstance (HANDLE hInstance, int nCmdShow)
  170. {
  171. UINT              uErrMode;
  172. HMENU             hMenu;
  173. HDC               hDC;
  174.  
  175.   hAccel = LoadAccelerators (hInstance, "tstappaccel");
  176.  
  177.   if (!hAccel)
  178.     return (FALSE);
  179.  
  180.   /*
  181.    * Just use default size and location.  It's easier to size an already
  182.    * created window for the specific client area size.
  183.    */
  184.    
  185.   hwndMain = CreateWindow ("Test App", WINDOW_NAME,
  186.         WS_OVERLAPPEDWINDOW,
  187.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  188.         NULL, NULL, hInstance, NULL);
  189.  
  190.   if (!hwndMain)
  191.     return (FALSE);
  192.  
  193.   ShowWindow (hwndMain, nCmdShow);
  194.   UpdateWindow (hwndMain);
  195.   hDC = GetDC (hwndMain);
  196.  
  197.   if (GetDeviceCaps (hDC, RASTERCAPS) & RC_PALETTE)
  198.   {
  199.     uErrMode = SetErrorMode (SEM_NOOPENFILEERRORBOX);
  200. #ifdef WIN32
  201.     hWinGInst = LoadLibrary ("wing32.dll");
  202. #else
  203.     hWinGInst = LoadLibrary ("wing.dll");
  204.   
  205.     if (hWinGInst < HINSTANCE_ERROR)
  206.       hWinGInst = 0;
  207. #endif
  208.     SetErrorMode (uErrMode);
  209.   }
  210.   else
  211.     hWinGInst = NULL;
  212.   
  213.   ReleaseDC (hwndMain, hDC);
  214.   hMenu = GetMenu (hwndMain);
  215.  
  216. #ifdef USE_WING
  217.   if (hWinGInst)
  218.   {
  219.     InitializeWinG ();
  220.     CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND | MF_CHECKED);
  221.     CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_IMGLIB, MF_BYCOMMAND | MF_UNCHECKED);
  222.   }
  223.   else
  224. #endif
  225.     EnableMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND | MF_GRAYED);
  226.   
  227.   return (TRUE);
  228. }
  229.  
  230. /****************************************************************************
  231.     FUNCTION: MainWndProc(HWND, UINT, WPARAM, LPARAM)
  232.     PURPOSE:  Processes messages
  233. ****************************************************************************/
  234.  
  235. LRESULT CALLBACK MainWndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  236. {
  237. int               iCount, iBrightness;
  238. static char       szFileName[260], szOldTitle[256];
  239. LPVOID            lpDIBNew;
  240. HMENU             hMenu;
  241. DWORD             dwStartTime;
  242. static short      nFileType;
  243. PRINTDLG          PrintDlgStruct;
  244.  
  245.   switch (message)
  246.   {
  247.     case WM_QUERYNEWPALETTE:
  248.     case WM_PALETTECHANGED:
  249.     case WM_PAINT:
  250.       
  251.       return (HandlePaintingAndUpdates (message, wParam, lParam));
  252.       break;
  253.  
  254.     case WM_CHAR:
  255.       
  256.       HandleCharacter (wParam, lParam);
  257.       break;
  258.  
  259.     case WM_LBUTTONDOWN:
  260.       
  261.       HandleLButtonDown (wParam, lParam);
  262.       break;
  263.  
  264.     case WM_RBUTTONDOWN:
  265.       
  266.       HandleRButtonDown (wParam, lParam);
  267.       break;
  268.  
  269.     case WM_LBUTTONUP:
  270.       
  271.       HandleLButtonUp (wParam, lParam);
  272.       break;
  273.  
  274.     case WM_MOUSEMOVE:
  275.       
  276.       HandleMouseMove (wParam, lParam);
  277.       break;
  278.  
  279.     case WM_INITMENUPOPUP:
  280.  
  281.       HandleMenuPopup (wParam, lParam);
  282.       break;
  283.  
  284.     case WM_VSCROLL:
  285.  
  286.       HandleVerticalScroll (wParam, lParam);
  287.       break;
  288.  
  289.     case WM_HSCROLL:
  290.  
  291.       HandleHorizontalScroll (wParam, lParam);
  292.       break;
  293.  
  294.     case WM_SIZE:
  295.  
  296.       HandleWindowSizing (lpDIBDisplay, wParam, lParam);
  297.       break;
  298.  
  299.     case WM_COMMAND:
  300.  
  301.       switch (CONTROL_ID (wParam))
  302.       {
  303.         case ID_FILE_PRINT:
  304.  
  305.           if (lpDIB1)
  306.             HandlePrinting (lpDIB1);
  307.           break;
  308.  
  309.         case ID_FILE_PRINT_SETUP:
  310.  
  311.           if (!pPrintDlgStruct)
  312.             InitializePrintStruct ();
  313.  
  314.           if (!pPrintDlgStruct)
  315.             break;
  316.  
  317.           PrintDlgStruct = *pPrintDlgStruct;
  318.           PrintDlgStruct.hwndOwner = hWnd;
  319.           PrintDlgStruct.Flags = PD_PRINTSETUP;
  320.           
  321.           if (PrintDlg (&PrintDlgStruct) == TRUE)
  322.             *pPrintDlgStruct = PrintDlgStruct;
  323.           break;
  324.  
  325.         case ID_FILE_SAVE:
  326.  
  327.           if (lpDIB1)
  328.           {
  329.             if (GetSaveFile (szFileName) == FALSE)
  330.               break;
  331.  
  332.             if (DialogBoxParam (hInst, "IDD_FILETYPE", hWnd, FileTypeProc, (LPARAM)(LPINT)&nFileType) != TRUE)
  333.               break;
  334.  
  335.             UpdateWindowTitle (szFileName, TRUE);
  336.  
  337.             if (WriteDIBToFile (lpDIB1, szFileName, nFileType) == FALSE)
  338.             {
  339.               switch (GetLastImgLibError ())
  340.               {
  341.                 case ERROR_WRITE_ACCESS_DENIED:
  342.                   wsprintf ((LPSTR)szBuffer, (LPSTR)"Error writing to file \"%s\"", (LPSTR)szFileName);
  343.                   break;
  344.                 case ERROR_INVALID_POINTER:
  345.                   wsprintf ((LPSTR)szBuffer, (LPSTR)"Error accessing one of the pointer parameters", (LPSTR)szFileName);
  346.                   break;
  347.                 case ERROR_INCOMPATIBLE_IMAGE:
  348.                   wsprintf ((LPSTR)szBuffer, (LPSTR)"Image format incompatible with the selected file type", (LPSTR)szFileName);
  349.                   break;
  350.               }
  351.               MessageBox (NULL, szBuffer, "Save Error", MB_TASKMODAL | MB_ICONSTOP | MB_OK);
  352.             }
  353.           }
  354.           break;
  355.  
  356.         case ID_FILE_OPEN:
  357.         
  358.           if (GetOpenFile (szFileName) == FALSE)
  359.             break;
  360.  
  361.           SetCursor (LoadCursor (NULL, IDC_WAIT));
  362.           lpDIBNew = ReadFileIntoDIB (szFileName);
  363.           
  364.           if (lpDIBNew)
  365.           {
  366.             bDrawSelection = FALSE;
  367.             UpdateWindowTitle (szFileName, TRUE);
  368.             ProcessNewDIB (lpDIBNew);;
  369.           }
  370.           SetCursor (LoadCursor (NULL, IDC_ARROW));
  371.  
  372.           if (!lpDIBNew)
  373.           {
  374.             switch (GetLastImgLibError ())
  375.             {
  376.               case ERROR_UNSUPPORTED_IMAGE:
  377.                 MessageBox (hWnd, "Unsupported image type", WINDOW_NAME, MB_OK | MB_ICONSTOP);
  378.                 break;
  379.               case ERROR_NO_MEMORY:
  380.                 MessageBox (hWnd, "Out of memory reading image", WINDOW_NAME, MB_OK | MB_ICONSTOP);
  381.                 break;
  382.               case ERROR_INVALID_POINTER:
  383.                 MessageBox (hWnd, "Access violation", WINDOW_NAME, MB_OK | MB_ICONSTOP);
  384.                 break;
  385.             }
  386.           }
  387.           break;
  388.  
  389.         case ID_OPTIONS_TIME:
  390.         
  391.           if (GetOpenFile (szFileName) == FALSE)
  392.             break;
  393.  
  394.           SetCursor (LoadCursor (NULL, IDC_WAIT));
  395.           GetWindowText (hWnd, szOldTitle, sizeof (szOldTitle));
  396.           dwStartTime = GetTickCount ();
  397.  
  398.           for (iCount = 0;iCount < 10;iCount++)
  399.           {
  400.             wsprintf ((LPSTR)szBuffer, (LPSTR)"Testing image loading speed \"%s\" -- %d", (LPSTR)szFileName, iCount);
  401.             UpdateWindowTitle (szBuffer, FALSE);
  402.             lpDIBNew = ReadFileIntoDIB (szFileName);
  403.  
  404.             if (lpDIBNew)
  405.             {
  406.               DIBFree (lpDIBNew);
  407.             }
  408.             else
  409.             {
  410.               break;
  411.             }
  412.           }
  413.           SetWindowText (hWnd, szOldTitle);
  414.           SetCursor (LoadCursor (NULL, IDC_ARROW));
  415.           
  416.           if (iCount == 10)
  417.             wsprintf ((LPSTR)szBuffer, (LPSTR)"File \"%s\" loaded 10 times in %ld milliseconds", (LPSTR)szFileName, GetTickCount () - dwStartTime);
  418.           else
  419.             wsprintf ((LPSTR)szBuffer, (LPSTR)"File \"%s\" failed to load 10 times", (LPSTR)szFileName);
  420.  
  421.           MessageBox (hWnd, szBuffer, "ImgLib Timing Results", MB_OK);
  422.           break;
  423.  
  424.         case ID_FILE_EXIT:
  425.  
  426.           DestroyWindow (hWnd);
  427.           break;
  428.  
  429.         case ID_EDIT_UNDO:
  430.  
  431.           if (lpDIB1 && lpDIB2)
  432.           {
  433.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  434.  
  435.             if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  436.               DIBFree (lpDIBDisplay);
  437.  
  438.             lpDIBNew = lpDIB2;
  439.             lpDIB2 = lpDIB1;
  440.             lpDIB1 = lpDIBNew;
  441.  
  442.             if (hPalette)
  443.             {
  444.               DeleteObject (hPalette);
  445.               hPalette = NULL;
  446.             }
  447.             
  448.             lpDIBDisplay = CreateDisplayDIB (hWnd, &lpDIB1, &hPalette);
  449.             bDrawSelection = FALSE;
  450.             ResizeWindowToDIB (hWnd, lpDIBDisplay);
  451.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  452.           }
  453.           break;
  454.  
  455.         case ID_EDIT_PASTE:
  456.  
  457.           HandlePasting (wParam, lParam);
  458.           break;
  459.  
  460.         case ID_EDIT_COPY:
  461.  
  462.           HandleCopying (wParam, lParam);
  463.           break;
  464.  
  465.         case ID_EDIT_ZOOM:
  466.  
  467.           HandleZoomin (wParam, lParam);
  468.           break;
  469.  
  470.         case ID_EDIT_EMPTY:
  471.  
  472.           if (OpenClipboard (hWnd))
  473.           {
  474.             EmptyClipboard ();
  475.             CloseClipboard ();
  476.           }
  477.           break;
  478.  
  479.         case ID_PROCESS_BRIGHTNESS:
  480.  
  481.           if (lpDIB1)
  482.           {
  483.             iBrightness = DialogBox (hInst, "IDD_BRIGHTNESS", hWnd, BrightnessProc);
  484.  
  485.             if (iBrightness)
  486.             {
  487.               SetCursor (LoadCursor (NULL, IDC_WAIT));
  488.               lpDIBNew = BrightenDIB (lpDIB1, (short)iBrightness);
  489.               ProcessNewDIB (lpDIBNew);
  490.               SetCursor (LoadCursor (NULL, IDC_ARROW));
  491.             }
  492.           }
  493.           break;
  494.  
  495.         case ID_PROCESS_SMOOTH:
  496.  
  497.           if (lpDIB1)
  498.           {
  499.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  500.             lpDIBNew = SmoothDIB (lpDIB1, 1);
  501.             ProcessNewDIB (lpDIBNew);
  502.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  503.           }
  504.           break;
  505.  
  506.         case ID_PROCESS_HALFTONE:
  507.  
  508.           if (lpDIB1)
  509.           {
  510.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  511.             lpDIBNew = HalftoneDIB (lpDIB1);
  512.             ProcessNewDIB (lpDIBNew);
  513.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  514.           }
  515.           break;
  516.  
  517.         case ID_PROCESS_GRAY:
  518.  
  519.           if (lpDIB1)
  520.           {
  521.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  522.             lpDIBNew = GrayDIB (lpDIB1);
  523.             ProcessNewDIB (lpDIBNew);
  524.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  525.           }
  526.           break;
  527.  
  528.         case ID_PROCESS_EXPAND:
  529.  
  530.           if (lpDIB1)
  531.           {
  532.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  533.             lpDIBNew = ExpandToTrueDIB (lpDIB1);
  534.             ProcessNewDIB (lpDIBNew);
  535.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  536.           }
  537.           break;
  538.  
  539.         case ID_PROCESS_ROT90:
  540.         case ID_PROCESS_ROT180:
  541.         case ID_PROCESS_ROT270:
  542.  
  543.           if (lpDIB1)
  544.           {
  545.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  546.  
  547.             switch (CONTROL_ID (wParam))
  548.             {
  549.               case ID_PROCESS_ROT90:
  550.  
  551.                 lpDIBNew = RotateDIB (lpDIB1, 90);
  552.                 break;
  553.               case ID_PROCESS_ROT180:
  554.  
  555.                 lpDIBNew = RotateDIB (lpDIB1, 180);
  556.                 break;
  557.               case ID_PROCESS_ROT270:
  558.  
  559.                 lpDIBNew = RotateDIB (lpDIB1, 270);
  560.                 break;
  561.             }
  562.             ProcessNewDIB (lpDIBNew);
  563.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  564.           }
  565.           break;
  566.  
  567.         case ID_PROCESS_MIRRORH:
  568.         case ID_PROCESS_MIRRORV:
  569.  
  570.           if (lpDIB1)
  571.           {
  572.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  573.  
  574.             switch (CONTROL_ID (wParam))
  575.             {
  576.               case ID_PROCESS_MIRRORH:
  577.  
  578.                 lpDIBNew = MirrorDIB (lpDIB1, FALSE);
  579.                 break;
  580.               case ID_PROCESS_MIRRORV:
  581.  
  582.                 lpDIBNew = MirrorDIB (lpDIB1, TRUE);
  583.                 break;
  584.             }
  585.             ProcessNewDIB (lpDIBNew);
  586.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  587.           }
  588.           break;
  589.  
  590.         case ID_OPTIONS_TC_DISPLAY_GDI:
  591.  
  592.           hMenu = GetMenu (hWnd);
  593.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_GDI, MF_BYCOMMAND | MF_CHECKED);
  594.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND | MF_UNCHECKED);
  595.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_IMGLIB, MF_BYCOMMAND | MF_UNCHECKED);
  596.  
  597.           if (lpDIB1)
  598.           {
  599.             if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  600.               DIBFree (lpDIBDisplay);
  601.  
  602.             lpDIBDisplay = CreateDisplayDIB (hWnd, &lpDIB1, &hPalette);
  603.             InvalidateRect (hWnd, (LPRECT) (NULL), FALSE);
  604.           }
  605.           break;
  606.  
  607.         case ID_OPTIONS_TC_DISPLAY_WING:
  608.  
  609.           hMenu = GetMenu (hWnd);
  610.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_GDI, MF_BYCOMMAND | MF_UNCHECKED);
  611.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND | MF_CHECKED);
  612.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_IMGLIB, MF_BYCOMMAND | MF_UNCHECKED);
  613.  
  614.           if (lpDIB1)
  615.           {
  616.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  617.  
  618.             if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  619.               DIBFree (lpDIBDisplay);
  620.  
  621.             lpDIBDisplay = CreateDisplayDIB (hWnd, &lpDIB1, &hPalette);
  622.             InvalidateRect (hWnd, (LPRECT) (NULL), FALSE);
  623.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  624.           }
  625.           break;
  626.  
  627.         case ID_OPTIONS_TC_DISPLAY_IMGLIB:
  628.  
  629.           hMenu = GetMenu (hWnd);
  630.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_GDI, MF_BYCOMMAND | MF_UNCHECKED);
  631.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND | MF_UNCHECKED);
  632.           CheckMenuItem (hMenu, ID_OPTIONS_TC_DISPLAY_IMGLIB, MF_BYCOMMAND | MF_CHECKED);
  633.  
  634.           if (lpDIB1)
  635.           {
  636.             SetCursor (LoadCursor (NULL, IDC_WAIT));
  637.  
  638.             if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  639.               DIBFree (lpDIBDisplay);
  640.  
  641.             lpDIBDisplay = CreateDisplayDIB (hWnd, &lpDIB1, &hPalette);
  642.             InvalidateRect (hWnd, (LPRECT) (NULL), FALSE);
  643.             SetCursor (LoadCursor (NULL, IDC_ARROW));
  644.           }
  645.           break;
  646.  
  647.         case ID_OPTIONS_RETAIN_TC:
  648.  
  649.           hMenu = GetMenu (hWnd);
  650.           if (GetMenuState (hMenu, ID_OPTIONS_RETAIN_TC, MF_BYCOMMAND) & MF_CHECKED)
  651.           {
  652.             CheckMenuItem (hMenu, ID_OPTIONS_RETAIN_TC, MF_BYCOMMAND | MF_UNCHECKED);
  653.  
  654.             if (lpDIBDisplay && lpDIB1 != lpDIBDisplay)
  655.             {
  656.               DIBFree (lpDIB1);
  657.               lpDIB1 = lpDIBDisplay;
  658.             }
  659.           }
  660.           else
  661.           {
  662.             CheckMenuItem (hMenu, ID_OPTIONS_RETAIN_TC, MF_BYCOMMAND | MF_CHECKED);
  663.           }
  664.  
  665.           break;
  666.  
  667.         case ID_HELP_ABOUT:
  668.  
  669.           DialogBox (hInst, "IDD_ABOUT_DIALOG", hWnd, AboutProc);
  670.           break;
  671.  
  672.         default:
  673.           return (DefWindowProc (hWnd, message, wParam, lParam));
  674.       }
  675.       break;
  676.  
  677.     case WM_DESTROY:
  678.  
  679.       if (lpDIB1)
  680.         DIBFree (lpDIB1);
  681.  
  682.       if (lpDIB2)
  683.         DIBFree (lpDIB2);
  684.  
  685.       if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  686.         DIBFree (lpDIBDisplay);
  687.  
  688.       if (hPalette)
  689.       {
  690.         DeleteObject (hPalette);
  691.         hPalette = NULL;
  692.       }
  693.  
  694.       if (hWinGInst)
  695.       {
  696.         if (hbmpWinG)
  697.         {
  698.           SelectObject (hdcWinG, hbmpWinGOld);
  699.           DeleteObject (hbmpWinG);
  700.         }
  701.         DeleteDC (hdcWinG);
  702.         FreeLibrary (hWinGInst);
  703.       }
  704.       PostQuitMessage(0);
  705.       break;
  706.  
  707.     default:
  708.       return (DefWindowProc (hWnd, message, wParam, lParam));
  709.   }
  710.   return (0);
  711. }
  712.  
  713. /****************************************************************************
  714.     FUNCTION: AboutProc(HWND, UINT, WPARAM, LPARAM)
  715.     PURPOSE:  Processes messages for the About dialog
  716. ****************************************************************************/
  717.  
  718. BOOL CALLBACK AboutProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  719. {
  720. HWND              hwndStatic;
  721. char              szImgLibVer[512];
  722.  
  723.   switch (message)
  724.   {
  725.     case WM_INITDIALOG:
  726.  
  727.       hwndStatic = GetDlgItem (hDlg, IDC_ABOUT_STRING);
  728.       GetImgLibVersion (szImgLibVer, sizeof (szImgLibVer));
  729.       SetWindowText (hwndStatic, szImgLibVer);
  730.       return (TRUE);
  731.  
  732.     case WM_COMMAND:
  733.       if (CONTROL_ID (wParam) == IDOK)
  734.       {
  735.         EndDialog(hDlg, TRUE);
  736.         return (TRUE);
  737.       }
  738.       break;
  739.   }
  740.   return (FALSE);
  741. }
  742.  
  743. /****************************************************************************
  744.     FUNCTION: BrightnessProc(HWND, UINT, WPARAM, LPARAM)
  745.     PURPOSE:  Processes messages for the Brightness Control dialog
  746. ****************************************************************************/
  747.  
  748. BOOL CALLBACK BrightnessProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  749. {
  750. HWND              hwndStatic, hwndScroll;
  751. char              szMessage[32];
  752. int               iScrollCode, iNewPos;
  753. static LPVOID     lpDIBSave;
  754. LPVOID            lpDIBNew;
  755. HBITMAP           hbmpTemp;
  756.  
  757.   switch (message)
  758.   {
  759.     case WM_INITDIALOG:
  760.  
  761.       lpDIBSave = lpDIBDisplay;
  762.       hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  763.       SetScrollRange (hwndScroll, SB_CTL, 50, 150, TRUE);
  764.       SetScrollPos (hwndScroll, SB_CTL, 100, TRUE);
  765.       return (TRUE);
  766.  
  767.     case WM_HSCROLL:
  768.  
  769. #ifdef WIN32
  770.       iScrollCode = (int) LOWORD (wParam);
  771.       iNewPos = (int) HIWORD (wParam);
  772. #else
  773.       iScrollCode = (int) wParam;
  774.       iNewPos = (int) LOWORD (lParam);
  775. #endif
  776.       
  777.       hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  778.  
  779.       switch (iScrollCode)
  780.       {
  781.         case SB_ENDSCROLL:
  782.           iNewPos = GetScrollPos (hwndScroll, SB_CTL);
  783.           lpDIBNew = BrightenDIB (lpDIBSave, (short) iNewPos);
  784.  
  785.           if (lpDIBNew)
  786.           {
  787.             if (lpDIBDisplay != lpDIBSave)
  788.               DIBFree (lpDIBDisplay);
  789.  
  790.             lpDIBDisplay = lpDIBNew;
  791.             InvalidateRect (hwndMain, NULL, FALSE);
  792.             
  793.             /*
  794.              * WinG will not change the palette (as it uses a dithered palette
  795.              * which works with all colors.)  For that reason we force the
  796.              * slow standard GDI repaint.  This code will not have any side
  797.              * effects on non-WinG displays.
  798.              */
  799.             hbmpTemp = hbmpWinG;
  800.             hbmpWinG = NULL;
  801.             UpdateWindow (hwndMain);
  802.             hbmpWinG = hbmpTemp;
  803.           }
  804.           break;
  805.     
  806.         case SB_LINEDOWN:
  807.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) + 1;
  808.           break;
  809.  
  810.         case SB_LINEUP:
  811.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) - 1;
  812.           break;
  813.         case SB_PAGEDOWN:
  814.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) + 10;
  815.           break;
  816.  
  817.         case SB_PAGEUP:
  818.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) - 10;
  819.           break;
  820.       }
  821.  
  822.       if (iNewPos < 50)
  823.         iNewPos = 50;
  824.  
  825.       if (iNewPos > 150)
  826.         iNewPos = 150;
  827.  
  828.       wsprintf ((LPSTR)szMessage, (LPSTR)"%d %%", iNewPos);
  829.       hwndStatic = GetDlgItem (hDlg, IDC_BRIGHTNESS_PERCENTAGE);
  830.       SetWindowText (hwndStatic, szMessage);
  831.       SetScrollPos (hwndScroll, SB_CTL, iNewPos, TRUE);
  832.       return (TRUE);
  833.  
  834.     case WM_COMMAND:
  835.  
  836.       switch (CONTROL_ID (wParam))
  837.       {
  838.         case IDOK:
  839.           hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  840.           iNewPos = GetScrollPos (hwndScroll, SB_CTL);
  841.           
  842.           if (lpDIBDisplay != lpDIBSave)
  843.           {
  844.             DIBFree (lpDIBDisplay);
  845.             lpDIBDisplay = lpDIBSave;
  846.           }
  847.           EndDialog(hDlg, iNewPos);
  848.           return (TRUE);
  849.         case IDCANCEL:
  850.           
  851.           if (lpDIBDisplay != lpDIBSave)
  852.           {
  853.             DIBFree (lpDIBDisplay);
  854.             lpDIBDisplay = lpDIBSave;
  855.             InvalidateRect (hwndMain, NULL, FALSE);
  856.           }
  857.           EndDialog(hDlg, FALSE);
  858.           return (TRUE);
  859.       }
  860.       break;
  861.   }
  862.   return (FALSE);
  863. }
  864.  
  865. /****************************************************************************
  866.     FUNCTION: FileTypeProc(HWND, UINT, WPARAM, LPARAM)
  867.     PURPOSE:  Processes messages for the FileType dialog
  868. ****************************************************************************/
  869.  
  870. BOOL CALLBACK FileTypeProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  871. {
  872. static short      *pnFileType;
  873. int               iCtrl;
  874.  
  875.   switch (message)
  876.   {
  877.     case WM_INITDIALOG:
  878.  
  879.       pnFileType = (short *)lParam;
  880.  
  881.       switch (*pnFileType)
  882.       {
  883.         case FILETYPE_BMP:
  884.           iCtrl = IDC_IT_BMP;
  885.           break;
  886.         case FILETYPE_TIFF_DEFAULT:
  887.           iCtrl = IDC_IT_TIFF;
  888.           break;
  889.         case FILETYPE_TIFF_NO_COMPRESSION:
  890.           iCtrl = IDC_IT_TIFF_NOCOMP;
  891.           break;
  892.         case FILETYPE_TIFF_HUFFMAN:
  893.           iCtrl = IDC_IT_TIFF_HUFFMAN;
  894.           break;
  895.         case FILETYPE_TIFF_PACKBITS:
  896.           iCtrl = IDC_IT_TIFF_PACKBITS;
  897.           break;
  898.         case FILETYPE_TIFF_G3:
  899.           iCtrl = IDC_IT_TIFF_G3;
  900.           break;
  901.         case FILETYPE_TIFF_G4:
  902.           iCtrl = IDC_IT_TIFF_G4;
  903.           break;
  904.         default:
  905.           iCtrl = IDC_IT_BMP;
  906.           break;
  907.       }
  908.       CheckRadioButton (hDlg, IDC_IT_BMP, IDC_IT_TIFF_G4, iCtrl);
  909.       return (TRUE);
  910.  
  911.     case WM_COMMAND:
  912.  
  913.       if (CONTROL_ID (wParam) == IDOK)
  914.       {
  915.         if (IsDlgButtonChecked (hDlg, IDC_IT_BMP))
  916.           *pnFileType = FILETYPE_BMP;
  917.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF))
  918.           *pnFileType = FILETYPE_TIFF_DEFAULT;
  919.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_NOCOMP))
  920.           *pnFileType = FILETYPE_TIFF_NO_COMPRESSION;
  921.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_HUFFMAN))
  922.           *pnFileType = FILETYPE_TIFF_HUFFMAN;
  923.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_PACKBITS))
  924.           *pnFileType = FILETYPE_TIFF_PACKBITS;
  925.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_G3))
  926.           *pnFileType = FILETYPE_TIFF_G3;
  927.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_G4))
  928.           *pnFileType = FILETYPE_TIFF_G4;
  929.         EndDialog(hDlg, TRUE);
  930.         return (TRUE);
  931.       }
  932.       else if (CONTROL_ID (wParam) == IDCANCEL)
  933.       {
  934.         EndDialog(hDlg, FALSE);
  935.         return (TRUE);
  936.       }
  937.       break;
  938.   }
  939.   return (FALSE);
  940. }
  941.  
  942. /****************************************************************************
  943.     FUNCTION: PrintProc(HWND, UINT, WPARAM, LPARAM)
  944.     PURPOSE:  Processes messages for the Print dialog
  945. ****************************************************************************/
  946.  
  947. BOOL CALLBACK PrintProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  948. {
  949. static LPBITMAPINFOHEADER pBmi;
  950. HWND              hwndCtl;
  951. LPDEVNAMES        pDevNames, pDevNamesNew;
  952. LPDEVMODE         pDevMode, pDevModeNew;
  953. char              szBuffer[256];
  954. static PRINTDLG   PrintDlgStruct;
  955. unsigned int      uCopyCount;
  956. BOOL              bConvertOK;
  957. HANDLE            hDevModeNew, hDevNamesNew;
  958.  
  959.   switch (message)
  960.   {
  961.     case WM_INITDIALOG:
  962.  
  963.       PrintDlgStruct = *pPrintDlgStruct;
  964.       SetDlgItemInt (hDlg, IDC_COPY_COUNT, uPrintCopies, FALSE);
  965.       pBmi = (LPBITMAPINFOHEADER) lParam;
  966.       pDevNames = (LPDEVNAMES)GlobalLock (pPrintDlgStruct->hDevNames);
  967.       pDevMode = (LPDEVMODE)GlobalLock (pPrintDlgStruct->hDevMode);
  968.  
  969.       /*
  970.        * Make copies of the DEVNAMES and DEVMODE structures
  971.        */
  972.       hDevNamesNew = GlobalAlloc (GMEM_MOVEABLE, GlobalSize (pPrintDlgStruct->hDevNames));
  973.       pDevNamesNew = (LPDEVNAMES) GlobalLock (hDevNamesNew);
  974.       hDevModeNew = GlobalAlloc (GMEM_MOVEABLE, GlobalSize (pPrintDlgStruct->hDevMode));
  975.       pDevModeNew = (LPDEVMODE) GlobalLock (hDevModeNew);
  976.       copymem (pDevModeNew, pDevMode, GlobalSize (hDevModeNew));
  977.       copymem (pDevNamesNew, pDevNames, GlobalSize (hDevNamesNew));
  978.       GlobalUnlock (pPrintDlgStruct->hDevNames);
  979.       GlobalUnlock (pPrintDlgStruct->hDevMode);
  980.       PrintDlgStruct.hDevMode = hDevModeNew;
  981.       PrintDlgStruct.hDevNames = hDevNamesNew;
  982.  
  983.       if (pBmi->biPlanes * pBmi->biBitCount == 1 || pDevModeNew->dmColor == DMCOLOR_COLOR)   // monochrome bitmap or color printer
  984.       {
  985.         hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  986.         EnableWindow (hwndCtl, FALSE);
  987.         hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  988.         EnableWindow (hwndCtl, FALSE);
  989.         hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  990.         EnableWindow (hwndCtl, FALSE);
  991.       }
  992.       else
  993.       {
  994.         if (bHalftoneImgLib)
  995.           CheckRadioButton (hDlg, IDC_METHOD_GDI, IDC_METHOD_IMGLIB, IDC_METHOD_IMGLIB);
  996.         else
  997.           CheckRadioButton (hDlg, IDC_METHOD_GDI, IDC_METHOD_IMGLIB, IDC_METHOD_GDI);
  998.       }
  999.       if (bFillPage)
  1000.         CheckDlgButton (hDlg, IDC_FILL_PAGE, TRUE);
  1001.  
  1002.       wsprintf ((LPSTR)szBuffer, (LPSTR)"%s on %s", (LPSTR)pDevNamesNew + pDevNamesNew->wDeviceOffset, (LPSTR)pDevNamesNew + pDevNamesNew->wOutputOffset);
  1003.       SetDlgItemText (hDlg, IDC_PRINTERNAME, szBuffer);
  1004.       GlobalUnlock (hDevNamesNew);
  1005.       GlobalUnlock (hDevModeNew);
  1006.       return (TRUE);
  1007.  
  1008.     case WM_COMMAND:
  1009.  
  1010.       switch (CONTROL_ID (wParam))
  1011.       {
  1012.         case IDC_SETUP_PRINTER:
  1013.  
  1014.           PrintDlgStruct.hwndOwner = hDlg;
  1015.           PrintDlgStruct.Flags = PD_PRINTSETUP;
  1016.           if (PrintDlg (&PrintDlgStruct))
  1017.           {
  1018.             pDevModeNew = (LPDEVMODE) GlobalLock (PrintDlgStruct.hDevMode);
  1019.             if (pBmi->biPlanes * pBmi->biBitCount == 1 || pDevModeNew->dmColor == DMCOLOR_COLOR)   // monochrome bitmap or color printer
  1020.             {
  1021.               hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  1022.               EnableWindow (hwndCtl, FALSE);
  1023.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  1024.               EnableWindow (hwndCtl, FALSE);
  1025.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  1026.               EnableWindow (hwndCtl, FALSE);
  1027.             }
  1028.             else
  1029.             {
  1030.               hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  1031.               EnableWindow (hwndCtl, TRUE);
  1032.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  1033.               EnableWindow (hwndCtl, TRUE);
  1034.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  1035.               EnableWindow (hwndCtl, TRUE);
  1036.             }
  1037.             GlobalUnlock (PrintDlgStruct.hDevMode);
  1038.           }
  1039.           return (TRUE);
  1040.  
  1041.         case IDOK:
  1042.  
  1043.           uCopyCount = GetDlgItemInt (hDlg, IDC_COPY_COUNT, &bConvertOK, FALSE);
  1044.  
  1045.           if (!bConvertOK || uCopyCount < 1 || uCopyCount > 100)
  1046.           {
  1047.             MessageBox (hDlg, "Invalid value.  Please enter a number between 1 and 100", "Print", MB_ICONSTOP | MB_OK);
  1048.             SetFocus (GetDlgItem (hDlg, IDC_COPY_COUNT));
  1049.             return (TRUE);
  1050.           }
  1051.           uPrintCopies = uCopyCount;
  1052.           bFillPage = IsDlgButtonChecked (hDlg, IDC_FILL_PAGE);
  1053.           bHalftoneImgLib = IsDlgButtonChecked (hDlg, IDC_METHOD_IMGLIB);
  1054.           GlobalFree (pPrintDlgStruct->hDevNames);
  1055.           GlobalFree (pPrintDlgStruct->hDevMode);
  1056.           *pPrintDlgStruct = PrintDlgStruct;
  1057.           EndDialog (hDlg, TRUE);
  1058.           return (TRUE);
  1059.  
  1060.         case IDCANCEL:
  1061.  
  1062.           GlobalFree (PrintDlgStruct.hDevNames);
  1063.           GlobalFree (PrintDlgStruct.hDevMode);
  1064.           EndDialog (hDlg, FALSE);
  1065.           return (TRUE);
  1066.       }
  1067.       break;
  1068.   }
  1069.   return (FALSE);
  1070. }
  1071.  
  1072. /*************************************************************************
  1073.   Function:  GetOpenFile (LPSTR. WORD)
  1074.    Purpose:  Prompts user for a filename through the use of a Windows
  1075.              FileOpen common dialog box.
  1076.    Returns:  TRUE if a filename is selected.
  1077.              FALSE if no filename is selected.
  1078.   Comments:  Filename is put into the string passed to the routine.
  1079.              If a filename is not selected, NULL is returned.
  1080. *************************************************************************/
  1081.  
  1082. BOOL GetOpenFile (LPSTR szFileName)
  1083. {
  1084. OPENFILENAME   of;
  1085. DWORD          flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
  1086. static char    szTitle[30];         // Dialog Box title
  1087. static char    szTemplate[20];      // Dialog Box template
  1088. static char    szFile[256];         // File name
  1089. static char    szFileTitle[256];    // Title
  1090. static char    szDrive[5];          // Drive
  1091. static char    szDir[256];          // Directory
  1092. char szFilter[] =                   // Filter
  1093.   "Pictures\0*.bmp;*.jpg;*.tga;*.pcd;*.pcx;*.tif\0All Files\0*.*\0";
  1094. LPSTR          pFile;
  1095.  
  1096.    szFile[0] = '\0';
  1097.    of.lStructSize       = sizeof (OPENFILENAME);
  1098.    of.hwndOwner         = hwndMain;
  1099.    of.hInstance         = hInst;
  1100.    of.lpstrFilter       = szFilter;
  1101.    of.lpstrCustomFilter = NULL;
  1102.    of.nMaxCustFilter    = 0L;
  1103.    of.nFilterIndex      = 1L;
  1104.    of.lpstrFile         = szFile;
  1105.    of.nMaxFile          = sizeof (szFile);
  1106.    of.lpstrFileTitle    = szFileTitle;
  1107.    of.nMaxFileTitle     = sizeof (szFileTitle);
  1108.    of.lpstrInitialDir   = szDir;
  1109.    of.lpstrTitle        = "Open a new test bitmap file";
  1110.    of.Flags             = flags;
  1111.    of.nFileOffset       = 0;
  1112.    of.nFileExtension    = 0;
  1113.    of.lpstrDefExt       = NULL;
  1114.    of.lCustData         = 0;
  1115.    of.lpfnHook          = NULL;
  1116.    of.lpTemplateName    = NULL;
  1117.  
  1118.   if (GetOpenFileName (&of))
  1119.   {
  1120.     lstrcpy (szFileName, of.lpstrFile);
  1121.     lstrcpy (szDir, of.lpstrFile);
  1122.     pFile = strrchr (szDir, '\\');
  1123.  
  1124.     if (pFile)
  1125.       *pFile = 0;
  1126.  
  1127.     return TRUE;
  1128.   }
  1129.   else
  1130.     return FALSE;
  1131. }
  1132.  
  1133. /*************************************************************************
  1134.   Function:  GetSaveFile (LPSTR. WORD)
  1135.    Purpose:  Prompts user for a filename through the use of a Windows
  1136.              FileOpen common dialog box.
  1137.    Returns:  TRUE if a filename is selected.
  1138.              FALSE if no filename is selected.
  1139.   Comments:  Filename is put into the string passed to the routine.
  1140.              If a filename is not selected, NULL is returned.
  1141. *************************************************************************/
  1142.  
  1143. BOOL GetSaveFile (LPSTR szFileName)
  1144. {
  1145. OPENFILENAME   of;
  1146. DWORD          flags = OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
  1147. static char    szTitle[30];         // Dialog Box title
  1148. static char    szTemplate[20];      // Dialog Box template
  1149. static char    szFile[256];         // File name
  1150. static char    szFileTitle[256];    // Title
  1151. static char    szDrive[5];          // Drive
  1152. static char    szDir[256];          // Directory
  1153. char szFilter[] =                   // Filter
  1154.   "Windows Pictures\0*.bmp;*.tif\0All Files\0*.*\0";
  1155. LPSTR          pFile;
  1156.  
  1157.    szFile[0] = '\0';
  1158.    of.lStructSize       = sizeof (OPENFILENAME);
  1159.    of.hwndOwner         = GetFocus ();
  1160.    of.hInstance         = hInst;
  1161.    of.lpstrFilter       = szFilter;
  1162.    of.lpstrCustomFilter = NULL;
  1163.    of.nMaxCustFilter    = 0L;
  1164.    of.nFilterIndex      = 1L;
  1165.    of.lpstrFile         = szFile;
  1166.    of.nMaxFile          = sizeof (szFile);
  1167.    of.lpstrFileTitle    = szFileTitle;
  1168.    of.nMaxFileTitle     = sizeof (szFileTitle);
  1169.    of.lpstrInitialDir   = szDir;
  1170.    of.lpstrTitle        = "Save the image in a bitmap file";
  1171.    of.Flags             = flags;
  1172.    of.nFileOffset       = 0;
  1173.    of.nFileExtension    = 0;
  1174.    of.lpstrDefExt       = "*.bmp";
  1175.    of.lCustData         = 0;
  1176.    of.lpfnHook          = NULL;
  1177.    of.lpTemplateName    = NULL;
  1178.  
  1179.   if (GetSaveFileName (&of))
  1180.   {
  1181.     lstrcpy (szFileName, of.lpstrFile);
  1182.     lstrcpy (szDir, of.lpstrFile);
  1183.     pFile = strrchr (szDir, '\\');
  1184.  
  1185.     if (pFile)
  1186.       *pFile = 0;
  1187.  
  1188.     return TRUE;
  1189.   }
  1190.   else
  1191.     return FALSE;
  1192. }
  1193.  
  1194. /*************************************************************************
  1195.   Function:  CreateDisplayDIB()
  1196.    Purpose:  Creates a DIB suitable for the display based on user-selected options.
  1197.    Returns:  a new DIB pointer
  1198. *************************************************************************/
  1199.  
  1200. LPVOID CreateDisplayDIB (HWND hwnd, LPVOID *lpDIB, HPALETTE *phPal)
  1201. {
  1202. HMENU             hMenu;
  1203. LPBITMAPINFO      pBitmapInfo;
  1204. UINT              uState;
  1205. LPVOID            lpDIBDisplay;
  1206. long              lColors;
  1207. int               iPixelBits, iPlanes;
  1208. HDC               hDC;
  1209.  
  1210.   hDC = GetDC (hwnd);
  1211.   iPixelBits = GetDeviceCaps (hDC, BITSPIXEL);
  1212.   iPlanes = GetDeviceCaps (hDC, PLANES);
  1213.   ReleaseDC (hwnd, hDC);
  1214.  
  1215.   if (iPixelBits * iPlanes > 8)
  1216.   {
  1217.     /*
  1218.      * No color reduction on true color (or high color) displays
  1219.      */
  1220.     *phPal = NULL;
  1221.     return (*lpDIB);
  1222.   }
  1223.   pBitmapInfo = (LPBITMAPINFO) *lpDIB;
  1224.   hMenu = GetMenu (hwnd);
  1225.   uState = GetMenuState (hMenu, ID_OPTIONS_TC_DISPLAY_GDI, MF_BYCOMMAND);
  1226.  
  1227.   if (uState & MF_CHECKED || pBitmapInfo->bmiHeader.biClrUsed)
  1228.   {
  1229.     lpDIBDisplay = *lpDIB;
  1230.     
  1231.     if (pBitmapInfo->bmiHeader.biClrUsed > 2)
  1232.       *phPal = CreateDIBPalette (lpDIBDisplay);
  1233.     else
  1234.       *phPal = NULL;
  1235.   }
  1236.   else
  1237.   {
  1238.     uState = GetMenuState (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND);
  1239.  
  1240.     if (uState & MF_CHECKED && hWinGInst)
  1241.     {
  1242.       lpDIBDisplay = WinGHalftoneDIB (*lpDIB, phPal);
  1243.     }
  1244.     else
  1245.     {
  1246.       lColors = 1 << iPixelBits * iPlanes;
  1247.       lpDIBDisplay = ReduceDIB (*lpDIB, lColors, TRUE);
  1248.       *phPal = CreateDIBPalette (lpDIBDisplay);
  1249.     }
  1250.  
  1251.     if (lpDIBDisplay && lpDIBDisplay != *lpDIB)
  1252.     {
  1253.       if (!(GetMenuState (hMenu, ID_OPTIONS_RETAIN_TC, MF_BYCOMMAND) & MF_CHECKED))
  1254.       {
  1255.         DIBFree (*lpDIB);
  1256.         *lpDIB = lpDIBDisplay;
  1257.       }
  1258.     }
  1259.   }
  1260. #ifdef USE_WING
  1261.   /*
  1262.    * Use WinG for displaying if available
  1263.    */
  1264.  
  1265.   if (hWinGInst)
  1266.     UpdateWinGBitmap (lpDIBDisplay);
  1267. #endif
  1268.   return (lpDIBDisplay);
  1269. }
  1270.  
  1271. /*************************************************************************
  1272.   Function:  UpdateWindowTitle ()
  1273.    Purpose:  Updates the window title with the name of the file displayed.
  1274.    Returns:  none
  1275. *************************************************************************/
  1276.  
  1277. static void UpdateWindowTitle (LPSTR pszFilePath, BOOL bStripPath)
  1278. {
  1279. static char       szWindowName[260];
  1280. char              szFileName[260];
  1281. char              *pszFileName = NULL;
  1282.  
  1283.   if (pszFilePath && *pszFilePath)
  1284.   {
  1285.     /*
  1286.      * Make local copy because in 16-bit world strrchr can only operate on
  1287.      * near pointers.
  1288.      */
  1289.     lstrcpy (szFileName, pszFilePath);
  1290.  
  1291.     if (bStripPath)
  1292.       pszFileName = strrchr (szFileName, '\\');
  1293.  
  1294.     /*
  1295.      * If found the last path delimiter, skip over it.
  1296.      */
  1297.     if (pszFileName)
  1298.       pszFileName++;
  1299.     else
  1300.       pszFileName = szFileName;
  1301.  
  1302.     wsprintf ((LPSTR)szWindowName, (LPSTR)"%s -- %s", (LPSTR)WINDOW_NAME, (LPSTR)pszFileName);
  1303.   }
  1304.   else
  1305.     wsprintf ((LPSTR)szWindowName, (LPSTR)"%s", (LPSTR)WINDOW_NAME);
  1306.  
  1307.   SetWindowText (hwndMain, szWindowName);
  1308. }
  1309.  
  1310. /*************************************************************************
  1311.   Function:  ResizeWindowToDIB ()
  1312.    Purpose:  Updates the window size to fit the given device-independent DIB
  1313.    Returns:  none
  1314. *************************************************************************/
  1315.  
  1316. static void ResizeWindowToDIB (HWND hwnd, LPVOID pDIB)
  1317. {
  1318. int               iWidth, iHeight, iXOverhead, iYOverhead;
  1319. int               iScreenWidth, iScreenHeight, iXPos, iYPos;
  1320. int               iHScrollRange, iVScrollRange;
  1321. LPBITMAPINFOHEADER pBmi = (LPBITMAPINFOHEADER)pDIB;
  1322. HDC               hDC;
  1323. RECT              rect;
  1324. BOOL              bHScroll, bVScroll;
  1325. DWORD             dwStyle;
  1326.  
  1327.   bHScroll = bVScroll = FALSE;
  1328.   GetWindowRect (hwnd, &rect);
  1329.   iXPos = rect.left;
  1330.  
  1331.   if (iXPos < 0)
  1332.     iXPos = 0;
  1333.  
  1334.   iYPos = rect.top;
  1335.  
  1336.   if (iYPos < 0)
  1337.     iYPos = 0;
  1338.  
  1339.   hDC = GetDC (hwnd);
  1340.   iScreenWidth = GetDeviceCaps (hDC, HORZRES);
  1341.   iScreenHeight = GetDeviceCaps (hDC, VERTRES);
  1342.   ReleaseDC (hwnd, hDC);
  1343.   iWidth = (int)pBmi->biWidth;
  1344.   iHeight = (int)pBmi->biHeight;
  1345.   iXOverhead = GetSystemMetrics (SM_CXFRAME) * 2;
  1346.   iYOverhead = GetSystemMetrics (SM_CYFRAME) * 2 + GetSystemMetrics (SM_CYCAPTION) + GetSystemMetrics (SM_CYMENU);
  1347.  
  1348.   if (iWidth + iXOverhead + iXPos > iScreenWidth)
  1349.   {
  1350.     iXPos = iScreenWidth - iWidth - iXOverhead;
  1351.  
  1352.     if (iXPos < 0)
  1353.     {
  1354.       iHScrollRange = -iXPos;
  1355.       iXPos = 0;
  1356.       bHScroll = TRUE;
  1357.     }
  1358.   }
  1359.   if (iHeight + iYOverhead + iYPos > iScreenHeight)
  1360.   {
  1361.     iYPos = iScreenHeight - iHeight - iYOverhead;
  1362.  
  1363.     if (iYPos < 0)
  1364.     {
  1365.       iVScrollRange = -iYPos;
  1366.       iYPos = 0;
  1367.       bVScroll = TRUE;
  1368.     }
  1369.   }
  1370.   dwStyle = GetWindowLong (hwnd, GWL_STYLE);
  1371.  
  1372.   if (bHScroll)
  1373.   {
  1374.     ShowScrollBar (hwndMain, SB_HORZ, TRUE);
  1375.     /*
  1376.      * Having the vertical scrollbar will "steal" some more pixels
  1377.      * from the client area.  Check and adjust for it here.
  1378.      */
  1379.     if (bVScroll)
  1380.       iHScrollRange += GetSystemMetrics (SM_CXVSCROLL);
  1381.   }
  1382.   else
  1383.   {
  1384.     /*
  1385.      * Remove the scrollbar
  1386.      */
  1387.     if (dwStyle & WS_HSCROLL)
  1388.     {
  1389.       SetScrollPos (hwnd, SB_HORZ, 0, TRUE);
  1390.       ShowScrollBar (hwndMain, SB_HORZ, FALSE);
  1391.     }
  1392.   }
  1393.   if (bVScroll)
  1394.   {
  1395.     ShowScrollBar (hwndMain, SB_VERT, TRUE);
  1396.     /*
  1397.      * Having the horizontal scrollbar will "steal" some more pixels
  1398.      * from the client area.  Check and adjust for it here.
  1399.      */
  1400.     if (bHScroll)
  1401.       iVScrollRange += GetSystemMetrics (SM_CYHSCROLL);
  1402.   }
  1403.   else
  1404.   {
  1405.     /*
  1406.      * Remove the scrollbar
  1407.      */
  1408.     if (dwStyle & WS_VSCROLL)
  1409.     {
  1410.       SetScrollPos (hwnd, SB_VERT, 0, TRUE);
  1411.       ShowScrollBar (hwndMain, SB_VERT, FALSE);
  1412.     }
  1413.   }
  1414.   
  1415.   /*
  1416.    * Having done all this checking, the following call may still cause the
  1417.    * addition of scrollbars in rare circumstances like the menu bar becoming
  1418.    * 2-line.
  1419.    */
  1420.   SetWindowPos (hwnd, HWND_TOP, iXPos, iYPos, min (iXOverhead + iWidth, iScreenWidth),
  1421.                 min (iYOverhead + iHeight, iScreenHeight),
  1422.                 SWP_NOACTIVATE | SWP_NOZORDER);
  1423.   if (bHScroll)
  1424.     SetScrollRange (hwnd, SB_HORZ, 0, iHScrollRange, TRUE);
  1425.   if (bVScroll)
  1426.     SetScrollRange (hwnd, SB_VERT, 0, iVScrollRange, TRUE);
  1427.  
  1428.   InvalidateRect (hwnd, (LPRECT) (NULL), FALSE);
  1429. }
  1430.  
  1431. /*************************************************************************
  1432.   Function:  HandleVerticalScroll ()
  1433.    Purpose:  Process the vertical scrollbar operations.
  1434.    Returns:  none
  1435. *************************************************************************/
  1436.  
  1437. static void HandleVerticalScroll (WPARAM wParam, LPARAM lParam)
  1438. {
  1439. int               nScrollCode, iNewPos, iVScroll, iHScroll;
  1440. int               iCurrPos, iMinScroll, iMaxScroll, iClientHeight;
  1441. RECT              rect;
  1442.  
  1443.   UpdateWindow (hwndMain);
  1444.  
  1445. #ifdef WIN32
  1446.   nScrollCode = (int) LOWORD (wParam);
  1447.   iNewPos = (int) HIWORD (wParam);
  1448. #else
  1449.   nScrollCode = (int) wParam;
  1450.   iNewPos = (int) LOWORD (lParam);
  1451. #endif
  1452.  
  1453.   GetClientRect (hwndMain, &rect);
  1454.   iClientHeight = rect.bottom;
  1455.   iHScroll = iVScroll = 0;
  1456.   GetScrollRange (hwndMain, SB_VERT, &iMinScroll, &iMaxScroll);
  1457.   iCurrPos = GetScrollPos (hwndMain, SB_VERT);
  1458.  
  1459.   switch (nScrollCode)
  1460.   {
  1461.     case SB_BOTTOM:
  1462.       
  1463.       iVScroll = iMaxScroll - iCurrPos;
  1464.       break;
  1465.  
  1466.     case SB_PAGEDOWN:
  1467.  
  1468.       if (iCurrPos + iClientHeight <= iMaxScroll)
  1469.         iVScroll = -iClientHeight;
  1470.       else
  1471.         iVScroll = - (iMaxScroll - iCurrPos);
  1472.  
  1473.       break;
  1474.  
  1475.     case SB_PAGEUP:
  1476.  
  1477.       if (iCurrPos - iClientHeight >= 0)
  1478.         iVScroll = iClientHeight;
  1479.       else
  1480.         iVScroll = iCurrPos;
  1481.  
  1482.       break;
  1483.  
  1484.     case SB_THUMBTRACK:
  1485.     case SB_THUMBPOSITION:
  1486.       iVScroll = GetScrollPos (hwndMain, SB_VERT) - iNewPos;
  1487.       break;
  1488.   
  1489.     case SB_LINEDOWN:
  1490.  
  1491.       iVScroll = -1;
  1492.       break;
  1493.  
  1494.     case SB_LINEUP:
  1495.  
  1496.       iVScroll = 1;
  1497.       break;
  1498.  
  1499.     case SB_ENDSCROLL:
  1500.  
  1501.       return;
  1502.   }
  1503.   if (iCurrPos - iVScroll > iMaxScroll)
  1504.     iVScroll = iCurrPos - iMaxScroll;
  1505.  
  1506.   if (iCurrPos - iVScroll < iMinScroll)
  1507.     iVScroll = iCurrPos - iMinScroll;
  1508.  
  1509.   if (!iVScroll)
  1510.     return;
  1511.  
  1512.   ScrollWindow (hwndMain, iHScroll, iVScroll, NULL, &rect);
  1513.   SetScrollPos (hwndMain, SB_VERT, iCurrPos - iVScroll, TRUE);
  1514. }
  1515.  
  1516. /*************************************************************************
  1517.   Function:  HandleHorizontalScroll ()
  1518.    Purpose:  Process the horozontal scrollbar operations.
  1519.    Returns:  none
  1520. *************************************************************************/
  1521.  
  1522. static void HandleHorizontalScroll (WPARAM wParam, LPARAM lParam)
  1523. {
  1524. int               nScrollCode, iNewPos, iVScroll, iHScroll;
  1525. int               iCurrPos, iMinScroll, iMaxScroll, iClientWidth;
  1526. RECT              rect;
  1527.  
  1528.   UpdateWindow (hwndMain);
  1529.  
  1530. #ifdef WIN32
  1531.   nScrollCode = (int) LOWORD (wParam);
  1532.   iNewPos = (int) HIWORD (wParam);
  1533. #else
  1534.   nScrollCode = (int) wParam;
  1535.   iNewPos = (int) LOWORD (lParam);
  1536. #endif
  1537.  
  1538.   GetClientRect (hwndMain, &rect);
  1539.   iClientWidth = rect.right;
  1540.   iHScroll = iVScroll = 0;
  1541.   GetScrollRange (hwndMain, SB_HORZ, &iMinScroll, &iMaxScroll);
  1542.   iCurrPos = GetScrollPos (hwndMain, SB_HORZ);
  1543.  
  1544.   switch (nScrollCode)
  1545.   {
  1546.     case SB_BOTTOM:
  1547.       
  1548.       iHScroll = iMaxScroll - iCurrPos;
  1549.       break;
  1550.  
  1551.     case SB_PAGEDOWN:
  1552.  
  1553.       if (iCurrPos + iClientWidth <= iMaxScroll)
  1554.         iHScroll = -iClientWidth;
  1555.       else
  1556.         iHScroll = - (iMaxScroll - iCurrPos);
  1557.  
  1558.       break;
  1559.  
  1560.     case SB_PAGEUP:
  1561.  
  1562.       if (iCurrPos - iClientWidth >= 0)
  1563.         iHScroll = iClientWidth;
  1564.       else
  1565.         iHScroll = iCurrPos;
  1566.  
  1567.       break;
  1568.  
  1569.     case SB_THUMBTRACK:
  1570.     case SB_THUMBPOSITION:
  1571.       iHScroll = GetScrollPos (hwndMain, SB_HORZ) - iNewPos;
  1572.       break;
  1573.   
  1574.     case SB_LINEDOWN:
  1575.  
  1576.       iHScroll = -1;
  1577.       break;
  1578.  
  1579.     case SB_LINEUP:
  1580.  
  1581.       iHScroll = 1;
  1582.       break;
  1583.  
  1584.     case SB_ENDSCROLL:
  1585.  
  1586.       return;
  1587.   }
  1588.   if (iCurrPos - iHScroll > iMaxScroll)
  1589.     iHScroll = iCurrPos - iMaxScroll;
  1590.  
  1591.   if (iCurrPos - iHScroll < iMinScroll)
  1592.     iHScroll = iCurrPos - iMinScroll;
  1593.  
  1594.   if (!iHScroll)
  1595.     return;
  1596.  
  1597.   ScrollWindow (hwndMain, iHScroll, iVScroll, NULL, &rect);
  1598.   SetScrollPos (hwndMain, SB_HORZ, iCurrPos - iHScroll, TRUE);
  1599. }
  1600.  
  1601. /*************************************************************************
  1602.   Function:  HandleWindowSizing ()
  1603.    Purpose:  Process the WM_SIZE messages.
  1604.    Returns:  none
  1605. *************************************************************************/
  1606.  
  1607. static void HandleWindowSizing (LPVOID pDIB, WPARAM wParam, LPARAM lParam)
  1608. {
  1609. LPBITMAPINFOHEADER pBmi = (LPBITMAPINFOHEADER)pDIB;
  1610. BOOL              bHScroll, bVScroll;
  1611. DWORD             dwStyle;
  1612. int               iNewWidth, iNewHeight;
  1613. int               iHScrollRange, iVScrollRange;
  1614. int               iPos;
  1615. static BOOL       bSizing;
  1616.  
  1617.   /*
  1618.    * Prevent resizing from infinitely recursing.  This may be caused by having
  1619.    * to add or take away a scrollbar which in turn causes another WM_SIZE
  1620.    * message to be generated as the client area is affected by the scrollbars.
  1621.    */
  1622.   if (bSizing)
  1623.     return;
  1624.   if (!pBmi)
  1625.     return;
  1626.   if (wParam == SIZE_MINIMIZED || wParam == SIZE_MAXHIDE || wParam == SIZE_MAXSHOW)
  1627.     return;
  1628.  
  1629.   bSizing = TRUE;
  1630.   bHScroll = bVScroll = FALSE;
  1631.   iHScrollRange = iVScrollRange = 0;
  1632.   dwStyle = GetWindowLong (hwndMain, GWL_STYLE);
  1633.   iNewWidth = (int) LOWORD (lParam);
  1634.   iNewHeight = (int) HIWORD (lParam);
  1635.  
  1636.   if (dwStyle & WS_HSCROLL)
  1637.     iNewHeight += GetSystemMetrics (SM_CYHSCROLL);
  1638.  
  1639.   if (dwStyle & WS_VSCROLL)
  1640.     iNewWidth += GetSystemMetrics (SM_CXVSCROLL);
  1641.  
  1642.   /*
  1643.    * The following code determines if the scrollbars are required.
  1644.    * Adding a scrollbar "steals" pixels from client area, so the affected
  1645.    * dimension must be rechecked for a need of scrollbar.
  1646.    */
  1647.   if (pBmi->biWidth > iNewWidth)
  1648.   {
  1649.     bHScroll = TRUE;
  1650.     iHScrollRange = (int)pBmi->biWidth - iNewWidth;
  1651.     iNewHeight -= GetSystemMetrics (SM_CYHSCROLL);
  1652.   }
  1653.  
  1654.   if (pBmi->biHeight > iNewHeight)
  1655.   {
  1656.     bVScroll = TRUE;
  1657.     iVScrollRange = (int)pBmi->biHeight - iNewHeight;
  1658.     iNewWidth -= GetSystemMetrics (SM_CXVSCROLL);
  1659.  
  1660.     /*
  1661.      * Recheck the width to see if a horizontal scrollbar may be ncecessary.
  1662.      */
  1663.     if (pBmi->biWidth > iNewWidth && !bHScroll)
  1664.     {
  1665.       bHScroll = TRUE;
  1666.       iHScrollRange = (int)pBmi->biWidth - iNewWidth;
  1667.       iNewHeight -= GetSystemMetrics (SM_CYHSCROLL);
  1668.       iVScrollRange += GetSystemMetrics (SM_CYHSCROLL);
  1669.     }
  1670.   }
  1671.  
  1672.   if (!bHScroll && (dwStyle & WS_HSCROLL))
  1673.   {
  1674.     /*
  1675.      * Remove the scrollbar
  1676.      */
  1677.     SetScrollPos (hwndMain, SB_HORZ, 0, TRUE);
  1678.     ShowScrollBar (hwndMain, SB_HORZ, FALSE);
  1679.   }
  1680.   if (!bVScroll && (dwStyle & WS_VSCROLL))
  1681.   {
  1682.     /*
  1683.      * Remove the scrollbar
  1684.      */
  1685.     SetScrollPos (hwndMain, SB_VERT, 0, TRUE);
  1686.     ShowScrollBar (hwndMain, SB_VERT, FALSE);
  1687.   }
  1688.   /*
  1689.    * Update the scrollbar positions and ranges
  1690.    */
  1691.   if (bHScroll)
  1692.   {
  1693.     ShowScrollBar (hwndMain, SB_HORZ, TRUE);
  1694.     iPos = GetScrollPos (hwndMain, SB_HORZ);
  1695.  
  1696.     if (iPos > iHScrollRange)
  1697.     {
  1698.       InvalidateRect (hwndMain, NULL, FALSE);
  1699.       SetScrollPos (hwndMain, SB_HORZ, iHScrollRange, TRUE);
  1700.     }
  1701.     SetScrollRange (hwndMain, SB_HORZ, 0, iHScrollRange, TRUE);
  1702.   }
  1703.   if (bVScroll)
  1704.   {
  1705.     ShowScrollBar (hwndMain, SB_VERT, TRUE);
  1706.     iPos = GetScrollPos (hwndMain, SB_VERT);
  1707.  
  1708.     if (iPos > iVScrollRange)
  1709.     {
  1710.       InvalidateRect (hwndMain, NULL, FALSE);
  1711.       SetScrollPos (hwndMain, SB_VERT, iVScrollRange, TRUE);
  1712.     }
  1713.     SetScrollRange (hwndMain, SB_VERT, 0, iVScrollRange, TRUE);
  1714.   }
  1715.   bSizing = FALSE;
  1716. }
  1717.  
  1718. /*************************************************************************
  1719.   Function:  HandlePrinting ()
  1720.    Purpose:  Process the File/Print request.
  1721.    Returns:  none
  1722. *************************************************************************/
  1723.  
  1724. static void HandlePrinting (LPVOID lpDIB)
  1725. {
  1726. HDC               hDC;
  1727. LPDEVNAMES        pDevNames;
  1728. LPDEVMODE         pDevMode;
  1729. LPVOID            lpDIBPrint = NULL;
  1730. LPBITMAPINFOHEADER pBih;
  1731. LPBITMAPINFO      pBmi;
  1732. char              szTitle[128];
  1733. DOCINFO           DocInfo;
  1734. int               iXMargin, iYMargin, iWidth, iHeight;
  1735.  
  1736.   if (!pPrintDlgStruct)
  1737.   {
  1738.     InitializePrintStruct ();
  1739.  
  1740.     if (!pPrintDlgStruct)
  1741.       return;
  1742.   }
  1743.   if (!DialogBoxParam (hInst, "IDD_PRINT", hwndMain, PrintProc, (LPARAM)lpDIB))
  1744.     return;
  1745.  
  1746.   SetCursor (LoadCursor (NULL, IDC_WAIT));
  1747.   pDevNames = (LPDEVNAMES)GlobalLock (pPrintDlgStruct->hDevNames);
  1748.   pDevMode = (LPDEVMODE)GlobalLock (pPrintDlgStruct->hDevMode);
  1749.   pDevMode->dmCopies = uPrintCopies;
  1750.   hDC = CreateDC ((LPCSTR)pDevNames + pDevNames->wDriverOffset, (LPCSTR)pDevNames + pDevNames->wDeviceOffset,
  1751.                   (LPCSTR)pDevNames + pDevNames->wOutputOffset, pDevMode);
  1752.  
  1753.   if (bHalftoneImgLib)
  1754.   {
  1755.     lpDIBPrint = HalftoneDIB (lpDIB);
  1756.     pBih = (LPBITMAPINFOHEADER) lpDIBPrint;
  1757.   }
  1758.   else
  1759.   {
  1760.     pBih = (LPBITMAPINFOHEADER) lpDIB;
  1761.   }
  1762.   iXMargin = GetDeviceCaps (hDC, HORZRES) / 20;
  1763.   iYMargin = GetDeviceCaps (hDC, VERTRES) / 20;
  1764.  
  1765.   if (bFillPage)
  1766.   {
  1767.     iWidth = GetDeviceCaps (hDC, HORZRES) - iXMargin * 2;
  1768.     iHeight = GetDeviceCaps (hDC, VERTRES) - iYMargin * 2;
  1769.  
  1770.     if (iWidth / pBih->biWidth > iHeight / pBih->biHeight)
  1771.       iWidth = (int)pBih->biWidth * iHeight / (int)pBih->biHeight;
  1772.     else
  1773.       iHeight = (int)pBih->biHeight * iWidth / (int)pBih->biWidth;
  1774.   }
  1775.   else
  1776.   {
  1777.     iWidth = (int)pBih->biWidth;
  1778.     iHeight = (int)pBih->biHeight;
  1779.  
  1780.     /*
  1781.      * ImgLib halftonning increases the image size 4 times.  To make the
  1782.      * output look the same size, size the output the same for GDI.
  1783.      */
  1784.     if (!bHalftoneImgLib)
  1785.     {
  1786.       iWidth *= 4;
  1787.       iHeight *= 4;
  1788.     }
  1789.   }
  1790.   pBmi = (LPBITMAPINFO)pBih;
  1791.   GetWindowText (hwndMain, szTitle, sizeof (szTitle));
  1792.   DocInfo.cbSize = sizeof (DocInfo);
  1793.   DocInfo.lpszDocName = szTitle;
  1794.   DocInfo.lpszOutput = NULL;
  1795.   StartDoc (hDC, &DocInfo);
  1796.   StartPage (hDC);
  1797.   StretchDIBits (hDC, iXMargin, iYMargin, iWidth, iHeight, 0, 0, (int)pBih->biWidth,
  1798.                                  (int)pBih->biHeight, (HPSTR)&pBmi->bmiColors[pBih->biClrUsed], pBmi,
  1799.                                  DIB_RGB_COLORS, SRCCOPY);
  1800.   EndPage (hDC);
  1801.   EndDoc (hDC);
  1802.   DeleteDC (hDC);
  1803.  
  1804.   if (lpDIBPrint)
  1805.     DIBFree (lpDIBPrint);
  1806.  
  1807.   GlobalUnlock (pPrintDlgStruct->hDevNames);
  1808.   GlobalUnlock (pPrintDlgStruct->hDevMode);
  1809.   SetCursor (LoadCursor (NULL, IDC_ARROW));
  1810. }
  1811.  
  1812. /*************************************************************************
  1813.   Function:  InitializePrintStruct ()
  1814.    Purpose:  Initialize the printing structure with default printer information.
  1815.    Returns:  none
  1816. *************************************************************************/
  1817.  
  1818. static void InitializePrintStruct (void)
  1819. {
  1820.   if (pPrintDlgStruct)
  1821.     freemem (pPrintDlgStruct);
  1822.  
  1823.   pPrintDlgStruct = (LPPRINTDLG)allocmem (sizeof (PRINTDLG));
  1824.  
  1825.   if (pPrintDlgStruct)
  1826.   {
  1827. #ifdef WIN32
  1828.     memset (pPrintDlgStruct, 0, sizeof (PRINTDLG));
  1829. #else
  1830.     _fmemset (pPrintDlgStruct, 0, sizeof (PRINTDLG));
  1831. #endif
  1832.     pPrintDlgStruct->lStructSize = sizeof (PRINTDLG);
  1833.     pPrintDlgStruct->hwndOwner = hwndMain;
  1834.     pPrintDlgStruct->Flags = PD_PRINTSETUP | PD_RETURNDEFAULT;
  1835.  
  1836.     if (PrintDlg (pPrintDlgStruct) == FALSE)
  1837.     {
  1838.       freemem (pPrintDlgStruct);
  1839.       pPrintDlgStruct = NULL;
  1840.       MessageBox (hwndMain, "Error getting the default printer information", WINDOW_NAME, MB_OK | MB_ICONSTOP);
  1841.       return;
  1842.     }
  1843.   }
  1844. }
  1845.  
  1846. /*************************************************************************
  1847.   Function:  HandleMenuPopup ()
  1848.    Purpose:  Prepare a menu for display based on the current application state
  1849.    Returns:  none
  1850. *************************************************************************/
  1851.  
  1852. static void HandleMenuPopup (WPARAM wParam, LPARAM lParam)
  1853. {
  1854. HMENU             hMenuParent, hMenuPopup;
  1855. UINT              uIndex;
  1856. BOOL              bSystemMenu;
  1857. HDC               hDC;
  1858. LPBITMAPINFOHEADER pBmi;
  1859.  
  1860.   bSystemMenu = HIWORD (lParam);
  1861.  
  1862.   if (bSystemMenu)
  1863.     return;
  1864.  
  1865.   hMenuParent = GetMenu (hwndMain);
  1866.   hMenuPopup = (HMENU)wParam;
  1867.   uIndex = LOWORD (lParam);
  1868.  
  1869.   if (hMenuPopup == GetSubMenu (hMenuParent, 0))
  1870.   {
  1871.     if (lpDIBDisplay)
  1872.     {
  1873.       EnableMenuItem (hMenuPopup, ID_FILE_SAVE, MF_BYCOMMAND | MF_ENABLED);
  1874.       EnableMenuItem (hMenuPopup, ID_FILE_PRINT, MF_BYCOMMAND | MF_ENABLED);
  1875.     }
  1876.     else
  1877.     {
  1878.       EnableMenuItem (hMenuPopup, ID_FILE_SAVE, MF_BYCOMMAND | MF_GRAYED);
  1879.       EnableMenuItem (hMenuPopup, ID_FILE_PRINT, MF_BYCOMMAND | MF_GRAYED);
  1880.     }
  1881.   }
  1882.   else if (hMenuPopup == GetSubMenu (hMenuParent, 1))
  1883.   {
  1884.     if (lpDIB1 && lpDIB2)
  1885.       EnableMenuItem (hMenuPopup, ID_EDIT_UNDO, MF_BYCOMMAND | MF_ENABLED);
  1886.     else
  1887.       EnableMenuItem (hMenuPopup, ID_EDIT_UNDO, MF_BYCOMMAND | MF_GRAYED);
  1888.  
  1889.     if (lpDIB1)
  1890.       EnableMenuItem (hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_ENABLED);
  1891.     else
  1892.       EnableMenuItem (hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_GRAYED);
  1893.  
  1894.     if (IsClipboardFormatAvailable (CF_BITMAP) || IsClipboardFormatAvailable (CF_DIB))
  1895.       EnableMenuItem (hMenuPopup, ID_EDIT_PASTE, MF_BYCOMMAND | MF_ENABLED);
  1896.     else
  1897.       EnableMenuItem (hMenuPopup, ID_EDIT_PASTE, MF_BYCOMMAND | MF_GRAYED);
  1898.  
  1899.     if (bDrawSelection)
  1900.       EnableMenuItem (hMenuPopup, ID_EDIT_ZOOM, MF_BYCOMMAND | MF_ENABLED);
  1901.     else
  1902.       EnableMenuItem (hMenuPopup, ID_EDIT_ZOOM, MF_BYCOMMAND | MF_GRAYED);
  1903.   }
  1904.   else if (hMenuPopup == GetSubMenu (hMenuParent, 2))
  1905.   {
  1906.     if (lpDIB1)
  1907.     {
  1908.       pBmi = (LPBITMAPINFOHEADER) lpDIBDisplay;
  1909.       
  1910.       /*
  1911.        * Disallow controlling brightness of monochrome bitmaps
  1912.        */
  1913.       if (pBmi->biPlanes * pBmi->biBitCount > 1)
  1914.         EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_ENABLED);
  1915.       else
  1916.         EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_GRAYED);
  1917.  
  1918.       EnableMenuItem (hMenuPopup, ID_PROCESS_SMOOTH, MF_BYCOMMAND | MF_ENABLED);
  1919.       EnableMenuItem (hMenuPopup, ID_PROCESS_HALFTONE, MF_BYCOMMAND | MF_ENABLED);
  1920.       EnableMenuItem (hMenuPopup, ID_PROCESS_GRAY, MF_BYCOMMAND | MF_ENABLED);
  1921.  
  1922.       if (pBmi->biPlanes * pBmi->biBitCount <= 8)
  1923.         EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_ENABLED);
  1924.       else
  1925.         EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_GRAYED);
  1926.  
  1927.       EnableMenuItem (hMenuPopup, MENU_POSITION_ROTATE, MF_BYPOSITION | MF_ENABLED);
  1928.       EnableMenuItem (hMenuPopup, MENU_POSITION_MIRROR, MF_BYPOSITION | MF_ENABLED);
  1929.     }
  1930.     else
  1931.     {
  1932.       EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_GRAYED);
  1933.       EnableMenuItem (hMenuPopup, ID_PROCESS_SMOOTH, MF_BYCOMMAND | MF_GRAYED);
  1934.       EnableMenuItem (hMenuPopup, ID_PROCESS_HALFTONE, MF_BYCOMMAND | MF_GRAYED);
  1935.       EnableMenuItem (hMenuPopup, ID_PROCESS_GRAY, MF_BYCOMMAND | MF_GRAYED);
  1936.       EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_GRAYED);
  1937.       EnableMenuItem (hMenuPopup, MENU_POSITION_ROTATE, MF_BYPOSITION | MF_GRAYED);
  1938.       EnableMenuItem (hMenuPopup, MENU_POSITION_MIRROR, MF_BYPOSITION | MF_GRAYED);
  1939.     }
  1940.   }
  1941.   else if (hMenuPopup == GetSubMenu (hMenuParent, 3))
  1942.   {
  1943.     hDC = GetDC (NULL);
  1944.  
  1945.     if (GetDeviceCaps (hDC, BITSPIXEL) > 8)
  1946.       EnableMenuItem (hMenuPopup, MENU_POSITION_TC_OPT, MF_BYPOSITION | MF_GRAYED);
  1947.     else
  1948.       EnableMenuItem (hMenuPopup, MENU_POSITION_TC_OPT, MF_BYPOSITION | MF_ENABLED);
  1949.  
  1950.     ReleaseDC (NULL, hDC);
  1951.   }
  1952. }
  1953.  
  1954. /*************************************************************************
  1955.   Function:  HandleLButtonDown ()
  1956.    Purpose:  Process the WM_LBUTTONDOWN message
  1957.    Returns:  none
  1958. *************************************************************************/
  1959. static void HandleLButtonDown (WPARAM wParam, LPARAM lParam)
  1960. {
  1961.   SetCapture (hwndMain);
  1962.  
  1963.   if (!bPasting)
  1964.   {
  1965.     if (bDrawSelection)
  1966.       EraseSelectionBox ();
  1967.     else
  1968.       bDrawSelection = TRUE;
  1969.  
  1970.     ptAnchor.x = rcSelection.left = rcSelection.right = LOWORD (lParam);
  1971.     ptAnchor.y = rcSelection.top = rcSelection.bottom = HIWORD (lParam);
  1972.     DrawSelectionBox ();
  1973.   }
  1974. }
  1975.  
  1976. /*************************************************************************
  1977.   Function:  HandleLButtonUp ()
  1978.    Purpose:  Process the WM_LBUTTONUP message
  1979.    Returns:  none
  1980. *************************************************************************/
  1981. static void HandleLButtonUp (WPARAM wParam, LPARAM lParam)
  1982. {
  1983. HANDLE            hDIB;
  1984. LPBITMAPINFOHEADER pBih;
  1985. HBITMAP           hBitmap;
  1986. HPALETTE          hPalTemp;
  1987. LPVOID            lpDIBNew, lpDIBTemp;
  1988.  
  1989.   if (bPasting)
  1990.   {
  1991.     if (OpenClipboard (hwndMain))
  1992.     {
  1993.       SetCursor (LoadCursor (NULL, IDC_WAIT));
  1994.  
  1995.       if (IsClipboardFormatAvailable (CF_DIB))
  1996.       {
  1997.         hDIB = GetClipboardData (CF_DIB);
  1998.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  1999.         lpDIBNew = MergeDIB (lpDIB1, pBih, rcSelection.left, rcSelection.top);
  2000.         GlobalUnlock (hDIB);
  2001.       }
  2002.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  2003.       {
  2004.         hBitmap = GetClipboardData (CF_BITMAP);
  2005.         hPalTemp = GetClipboardData (CF_PALETTE);
  2006.         lpDIBTemp = DDBToDIB (hBitmap, hPalTemp);
  2007.  
  2008.         if (lpDIBTemp)
  2009.         {
  2010.           lpDIBNew = MergeDIB (lpDIB1, lpDIBTemp, rcSelection.left, rcSelection.top);
  2011.           DIBFree (lpDIBTemp);
  2012.         }
  2013.       }
  2014.       else
  2015.       {
  2016.         CloseClipboard ();
  2017.         return;
  2018.       }
  2019.       CloseClipboard ();
  2020.       EraseSelectionBox ();
  2021.       bDrawSelection = FALSE;
  2022.       ProcessNewDIB (lpDIBNew);
  2023.       SetCursor (LoadCursor (NULL, IDC_ARROW));
  2024.     }
  2025.     bPasting = FALSE;
  2026.   }
  2027.   else
  2028.   {
  2029.     if (rcSelection.right - rcSelection.left < 5 || rcSelection.bottom - rcSelection.top < 5)
  2030.     {
  2031.       EraseSelectionBox ();
  2032.       bDrawSelection = FALSE;
  2033.     }
  2034.   }
  2035.   ReleaseCapture ();
  2036. }
  2037.  
  2038. /*************************************************************************
  2039.   Function:  HandleRButtonDown ()
  2040.    Purpose:  Process the WM_RBUTTONDOWN message
  2041.    Returns:  none
  2042. *************************************************************************/
  2043. static void HandleRButtonDown (WPARAM wParam, LPARAM lParam)
  2044. {
  2045.   if (GetCapture () == hwndMain)
  2046.   {
  2047.     EraseSelectionBox ();
  2048.     bDrawSelection = FALSE;
  2049.     bPasting = FALSE;
  2050.     ReleaseCapture ();
  2051.   }
  2052. }
  2053.  
  2054. /*************************************************************************
  2055.   Function:  HandleMouseMove ()
  2056.    Purpose:  Process the WM_MOUSEMOVE message
  2057.    Returns:  none
  2058. *************************************************************************/
  2059. static void HandleMouseMove (WPARAM wParam, LPARAM lParam)
  2060. {
  2061. LONG              lX, lY, ldx, ldy;
  2062.  
  2063.   if (GetCapture () == hwndMain)
  2064.   {
  2065.     EraseSelectionBox ();
  2066.     lX = LOWORD (lParam);
  2067.     lY = HIWORD (lParam);
  2068.  
  2069.     if (lX < 0)
  2070.       lX = 0;
  2071.  
  2072.     if (lY < 0)
  2073.       lY = 0;
  2074.     
  2075.     if (bPasting)
  2076.     {
  2077.       ldx = lX - rcSelection.left;
  2078.       ldy = lY - rcSelection.top;
  2079.       OffsetRect (&rcSelection, (int)ldx, (int)ldy);
  2080.     }
  2081.     else
  2082.     {
  2083.       if (lX > ptAnchor.x)
  2084.       {
  2085.         rcSelection.right = (int)lX;
  2086.         rcSelection.left = ptAnchor.x;
  2087.       }
  2088.       else
  2089.       {
  2090.         rcSelection.left = (int)lX;
  2091.         rcSelection.right = ptAnchor.x;
  2092.       }
  2093.  
  2094.       if (lY > ptAnchor.y)
  2095.       {
  2096.         rcSelection.bottom = (int)lY;
  2097.         rcSelection.top = ptAnchor.y;
  2098.       }
  2099.       else
  2100.       {
  2101.         rcSelection.top = (int)lY;
  2102.         rcSelection.bottom = ptAnchor.y;
  2103.       }
  2104.     }
  2105.     DrawSelectionBox ();
  2106.   }
  2107. }
  2108.  
  2109. /*************************************************************************
  2110.   Function:  HandleCharacter ()
  2111.    Purpose:  Process the WM_CHAR message
  2112.    Returns:  none
  2113. *************************************************************************/
  2114. static void HandleCharacter (WPARAM wParam, LPARAM lParam)
  2115. {
  2116.   if (GetCapture () == hwndMain && wParam == VK_ESCAPE)
  2117.   {
  2118.     EraseSelectionBox ();
  2119.     bDrawSelection = FALSE;
  2120.     bPasting = FALSE;
  2121.     ReleaseCapture ();
  2122.   }
  2123. }
  2124.  
  2125. /*************************************************************************
  2126.   Function:  HandlePasting ()
  2127.    Purpose:  Process the clipdoard paste
  2128.    Returns:  none
  2129. *************************************************************************/
  2130. static void HandlePasting (WPARAM wParam, LPARAM lParam)
  2131. {
  2132. HANDLE            hDIB;
  2133. LPBITMAPINFOHEADER pBih;
  2134. long              lWidth, lHeight;
  2135. HBITMAP           hBitmap;
  2136. BITMAP            bm;
  2137. POINT             ptCursor;
  2138. LPVOID            lpDIBNew;
  2139. HPALETTE          hPalTemp;
  2140.  
  2141.   if (OpenClipboard (hwndMain))
  2142.   {
  2143.     if (lpDIB1)
  2144.     {
  2145.       if (IsClipboardFormatAvailable (CF_DIB))
  2146.       {
  2147.         hDIB = GetClipboardData (CF_DIB);
  2148.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  2149.         lWidth = pBih->biWidth;
  2150.         lHeight = pBih->biHeight;
  2151.         GlobalUnlock (hDIB);
  2152.       }
  2153.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  2154.       {
  2155.         hBitmap = GetClipboardData (CF_BITMAP);
  2156.         GetObject (hBitmap, sizeof (bm), &bm);
  2157.         lWidth = bm.bmWidth;
  2158.         lHeight = bm.bmHeight;
  2159.       }
  2160.       else
  2161.       {
  2162.         CloseClipboard ();
  2163.         return;
  2164.       }
  2165.       GetCursorPos (&ptCursor);
  2166.       ScreenToClient (hwndMain, &ptCursor);
  2167.       rcSelection.left = ptCursor.x;
  2168.       rcSelection.top = ptCursor.y;
  2169.       rcSelection.right = ptCursor.x + (int)lWidth;
  2170.       rcSelection.bottom = ptCursor.y + (int)lHeight;
  2171.       bDrawSelection = TRUE;
  2172.       bPasting = TRUE;
  2173.       DrawSelectionBox ();
  2174.       SetCapture (hwndMain);
  2175.     }
  2176.     else
  2177.     {
  2178.       if (IsClipboardFormatAvailable (CF_DIB))
  2179.       {
  2180.         hDIB = GetClipboardData (CF_DIB);
  2181.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  2182.         lpDIBNew = CopyDIB (pBih);
  2183.         GlobalUnlock (hDIB);
  2184.       }
  2185.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  2186.       {
  2187.         hBitmap = GetClipboardData (CF_BITMAP);
  2188.         hPalTemp = GetClipboardData (CF_PALETTE);
  2189.         lpDIBNew = DDBToDIB (hBitmap, hPalTemp);
  2190.       }
  2191.       else
  2192.       {
  2193.         CloseClipboard ();
  2194.         return;
  2195.       }
  2196.       ProcessNewDIB (lpDIBNew);
  2197.     }
  2198.     CloseClipboard ();
  2199.   }
  2200. }
  2201.  
  2202. /*************************************************************************
  2203.   Function:  HandleCopying ()
  2204.    Purpose:  Process the clipdoard copy
  2205.    Returns:  none
  2206. *************************************************************************/
  2207. static void HandleCopying (WPARAM wParam, LPARAM lParam)
  2208. {
  2209. LPVOID            lpDIBTemp, lpDIB;
  2210. DWORD             dwSize;
  2211. HANDLE            hDIB;
  2212.  
  2213.   if (lpDIB1)
  2214.   {
  2215.     if (OpenClipboard (hwndMain))
  2216.     {
  2217.       if (bDrawSelection)
  2218.       {
  2219.         EraseSelectionBox ();
  2220.         bDrawSelection = FALSE;
  2221.         lpDIBTemp = ClipDIB (lpDIB1, rcSelection.left, rcSelection.top, rcSelection.right - rcSelection.left + 1, rcSelection.bottom - rcSelection.top + 1);
  2222.       }
  2223.       else
  2224.         lpDIBTemp = lpDIB1;
  2225.  
  2226.       if (lpDIBTemp)
  2227.       {
  2228.         dwSize = GetDIBSize (lpDIBTemp);
  2229.         hDIB = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, dwSize);
  2230.         lpDIB = GlobalLock (hDIB);
  2231.  
  2232.         if (lpDIB)
  2233.         {
  2234.           copymem (lpDIB, lpDIBTemp, dwSize);
  2235.           GlobalUnlock (hDIB);
  2236.           EmptyClipboard ();
  2237.           SetClipboardData (CF_DIB, hDIB);
  2238.         }
  2239.         
  2240.         if (bDrawSelection)
  2241.           DIBFree (lpDIBTemp);
  2242.       }
  2243.       CloseClipboard ();
  2244.     }
  2245.   }
  2246. }
  2247.  
  2248. /*************************************************************************
  2249.   Function:  HandleZoomin ()
  2250.    Purpose:  Process the zoomin procedure
  2251.    Returns:  none
  2252. *************************************************************************/
  2253. static void HandleZoomin (WPARAM wParam, LPARAM lParam)
  2254. {
  2255. LPVOID            lpDIBTemp, lpDIBNew;
  2256.  
  2257.   if (lpDIB1 && bDrawSelection)
  2258.   {
  2259.     SetCursor (LoadCursor (NULL, IDC_WAIT));
  2260.     EraseSelectionBox ();
  2261.     bDrawSelection = FALSE;
  2262.     lpDIBTemp = ClipDIB (lpDIB1, rcSelection.left, rcSelection.top, rcSelection.right - rcSelection.left + 1, rcSelection.bottom - rcSelection.top + 1);
  2263.  
  2264.     if (lpDIBTemp)
  2265.     {
  2266.       lpDIBNew = ZoomDIB (lpDIBTemp, 500, 500);
  2267.       DIBFree (lpDIBTemp);
  2268.       
  2269.       if (lpDIBNew)
  2270.         ProcessNewDIB (lpDIBNew);
  2271.     }
  2272.     SetCursor (LoadCursor (NULL, IDC_ARROW));
  2273.   }
  2274. }
  2275.  
  2276. /*************************************************************************
  2277.   Function:  DrawSelectionBox ()
  2278.    Purpose:  Draw the selection
  2279.    Returns:  none
  2280. *************************************************************************/
  2281. static void DrawSelectionBox (void)
  2282. {
  2283. HDC               hDC;
  2284.   
  2285.   UpdateWindow (hwndMain);
  2286.   hDC = GetDC (hwndMain);
  2287.  
  2288.   if (hDC)
  2289.   {
  2290.     SetROP2 (hDC, R2_XORPEN);
  2291.     SelectObject (hDC, GetStockObject (WHITE_PEN));
  2292.     SelectObject (hDC, GetStockObject (HOLLOW_BRUSH));
  2293.     Rectangle (hDC, rcSelection.left, rcSelection.top, rcSelection.right, rcSelection.bottom);
  2294.     ReleaseDC (hwndMain, hDC);
  2295.   }
  2296. }
  2297.  
  2298. /*************************************************************************
  2299.   Function:  EraseSelectionBox ()
  2300.    Purpose:  Erase the selection
  2301.    Returns:  none
  2302. *************************************************************************/
  2303. static void EraseSelectionBox (void)
  2304. {
  2305.   if (bDrawSelection)
  2306.     DrawSelectionBox ();
  2307. }
  2308.  
  2309. /*************************************************************************
  2310.   Function:  ProcessNewDIB ()
  2311.    Purpose:  Set up to display a newly loaded/created DIB
  2312.    Returns:  none
  2313. *************************************************************************/
  2314. static void       ProcessNewDIB (LPVOID lpDIBNew)
  2315. {
  2316.   if (lpDIBNew && lpDIBNew != lpDIB1)
  2317.   {
  2318.     if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  2319.       DIBFree (lpDIBDisplay);
  2320.  
  2321.     if (lpDIB2)
  2322.       DIBFree (lpDIB2);
  2323.  
  2324.     lpDIB2 = lpDIB1;
  2325.     lpDIB1 = lpDIBNew;
  2326.  
  2327.     if (hPalette)
  2328.     {
  2329.       DeleteObject (hPalette);
  2330.       hPalette = NULL;
  2331.     }
  2332.     lpDIBDisplay = CreateDisplayDIB (hwndMain, &lpDIB1, &hPalette);
  2333.  
  2334.     if (lpDIBDisplay)
  2335.       ResizeWindowToDIB (hwndMain, lpDIBDisplay);
  2336.   }
  2337. }
  2338.  
  2339. /*************************************************************************
  2340.   Function:  HandlePaintingAndUpdates ()
  2341.    Purpose:  Process image painting and palette management
  2342.    Returns:  none
  2343. *************************************************************************/
  2344. static LRESULT HandlePaintingAndUpdates (UINT message, WPARAM wParam, LPARAM lParam)
  2345. {
  2346. RECT              rcClient;
  2347. HPALETTE          hPalOld;
  2348. HDC               hDC;
  2349. int               iCount, iXPos, iYPos, iYStart;
  2350. PAINTSTRUCT       PaintStruct;
  2351. HPSTR             hpBits;
  2352. LPBITMAPINFO      pBitmapInfo;
  2353.  
  2354.   switch (message)
  2355.   {
  2356.     case WM_QUERYNEWPALETTE:
  2357.  
  2358.     /*
  2359.      * If palette realization causes a palette change,
  2360.      * we need to do a full redraw.
  2361.      */
  2362.     if (hPalette && wParam != (UINT)hwndMain)
  2363.     {
  2364.       hDC = GetDC (hwndMain);
  2365.       hPalOld = SelectPalette (hDC, hPalette, FALSE);
  2366.       iCount = RealizePalette (hDC);
  2367.       InvalidateRect (hwndMain, (LPRECT) (NULL), FALSE);
  2368.       UpdateWindow (hwndMain);
  2369.       SelectPalette (hDC, hPalOld, 0);
  2370.       ReleaseDC (hwndMain, hDC);
  2371.       return TRUE;
  2372.     }
  2373.     break;
  2374.  
  2375.     case WM_PALETTECHANGED:
  2376.  
  2377.       if (hPalette && wParam != (UINT)hwndMain)
  2378.         InvalidateRect (hwndMain, (LPRECT) (NULL), FALSE);
  2379.  
  2380.       break;
  2381.  
  2382.     case WM_PAINT:
  2383.       
  2384.       hDC = BeginPaint (hwndMain, &PaintStruct);
  2385.  
  2386.       if (lpDIBDisplay)
  2387.       {
  2388.         if (hPalette)
  2389.         {
  2390.           hPalOld = SelectPalette (hDC, hPalette, FALSE);
  2391.           RealizePalette (hDC);
  2392.         }
  2393.  
  2394.         GetClientRect (hwndMain, &rcClient);
  2395.         iXPos = GetScrollPos (hwndMain, SB_HORZ);
  2396.         iYPos = GetScrollPos (hwndMain, SB_VERT);
  2397.         pBitmapInfo = (LPBITMAPINFO) lpDIBDisplay;
  2398. #ifdef USE_WING
  2399.         if (hWinGInst && hbmpWinG)
  2400.         {
  2401.           fpWinGStretchBlt (hDC, 0, 0, rcClient.right, rcClient.bottom, hdcWinG, iXPos, iYPos,
  2402.                             rcClient.right, rcClient.bottom);
  2403.         }
  2404.         else
  2405. #endif
  2406.         {
  2407.           iYStart = (int)pBitmapInfo->bmiHeader.biHeight - rcClient.bottom - iYPos;
  2408.           hpBits = (HPSTR)&pBitmapInfo->bmiColors[pBitmapInfo->bmiHeader.biClrUsed];
  2409.           StretchDIBits (hDC, 0, 0, rcClient.right, rcClient.bottom, iXPos, iYStart,
  2410.                          rcClient.right, rcClient.bottom, hpBits, pBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
  2411.         }
  2412.         if (hPalette)
  2413.           SelectPalette (hDC, hPalOld, FALSE);
  2414.       }
  2415.  
  2416.       if (bDrawSelection)
  2417.         DrawSelectionBox ();
  2418.  
  2419.       EndPaint (hwndMain, &PaintStruct);
  2420.       break;
  2421.   }
  2422.   return (0);
  2423. }
  2424.  
  2425. #ifdef USE_WING
  2426.  
  2427. /*************************************************************************
  2428.   Function:  InitializeWinG ()
  2429.    Purpose:  Initializes WinG
  2430.    Returns:  none
  2431. *************************************************************************/
  2432. static void InitializeWinG ()
  2433. {
  2434.   fpWinGCreateDC = (WINGCREATEDC) GetProcAddress (hWinGInst, "WinGCreateDC");
  2435.   fpWinGCreateBitmap = (WINGCREATEBITMAP) GetProcAddress (hWinGInst, "WinGCreateBitmap");
  2436.   fpWinGStretchBlt = (WINGSTRETCHBLT) GetProcAddress (hWinGInst, "WinGStretchBlt");
  2437.   hdcWinG = fpWinGCreateDC ();
  2438. }
  2439.  
  2440. /*************************************************************************
  2441.   Function:  UpdateWinGBitmap ()
  2442.    Purpose:  Updates WinG bitmap used to draw DIBs
  2443.    Returns:  none
  2444. *************************************************************************/
  2445. static void UpdateWinGBitmap (LPVOID lpDIB)
  2446. {
  2447. LPBITMAPINFO      pBiDIB = (LPBITMAPINFO) lpDIB;
  2448. HPALETTE          hpalTemp, hpalOld;
  2449. HPSTR             hpBits;
  2450.  
  2451.   if (hbmpWinG)
  2452.   {
  2453.     SelectObject (hdcWinG, hbmpWinGOld);
  2454.     DeleteObject (hbmpWinG);
  2455.   }
  2456.  
  2457.   /*
  2458.    * Create a new bitmap and put it in WinG DC for quick repaints.  WinG
  2459.    * deals with 8-bit-per-pixel bitmaps only.
  2460.    */
  2461.   hbmpWinG = fpWinGCreateBitmap (hdcWinG, pBiDIB, NULL);
  2462.   
  2463.   if (hbmpWinG)
  2464.   {
  2465.     hbmpWinGOld = SelectObject (hdcWinG, hbmpWinG);
  2466.     hpalTemp = CreateDIBPalette (lpDIB);
  2467.     hpalOld = SelectPalette (hdcWinG, hpalTemp, FALSE);
  2468.     RealizePalette (hdcWinG);
  2469.     hpBits = (HPSTR)&pBiDIB->bmiColors[pBiDIB->bmiHeader.biClrUsed];
  2470.     StretchDIBits (hdcWinG, 0, 0, (int)pBiDIB->bmiHeader.biWidth, (int)pBiDIB->bmiHeader.biHeight, 0, 0,
  2471.                    (int)pBiDIB->bmiHeader.biWidth, (int)pBiDIB->bmiHeader.biHeight, hpBits, pBiDIB, DIB_RGB_COLORS, SRCCOPY);
  2472.     SelectPalette (hdcWinG, hpalOld, FALSE);
  2473.     DeleteObject (hpalTemp);
  2474.   }
  2475. }
  2476.  
  2477. #endif
  2478.