home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / sharewar / win95nt / grafika / imglib / tstapp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-25  |  72.4 KB  |  2,466 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.  
  756.   switch (message)
  757.   {
  758.     case WM_INITDIALOG:
  759.  
  760.       lpDIBSave = lpDIBDisplay;
  761.       hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  762.       SetScrollRange (hwndScroll, SB_CTL, 50, 150, TRUE);
  763.       SetScrollPos (hwndScroll, SB_CTL, 100, TRUE);
  764.       return (TRUE);
  765.  
  766.     case WM_HSCROLL:
  767.  
  768. #ifdef WIN32
  769.       iScrollCode = (int) LOWORD (wParam);
  770.       iNewPos = (int) HIWORD (wParam);
  771. #else
  772.       iScrollCode = (int) wParam;
  773.       iNewPos = (int) LOWORD (lParam);
  774. #endif
  775.       
  776.       hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  777.  
  778.       switch (iScrollCode)
  779.       {
  780.         case SB_ENDSCROLL:
  781.           iNewPos = GetScrollPos (hwndScroll, SB_CTL);
  782.           lpDIBNew = BrightenDIB (lpDIBSave, (short) iNewPos);
  783.  
  784.           if (lpDIBNew)
  785.           {
  786.             if (lpDIBDisplay != lpDIBSave)
  787.               DIBFree (lpDIBDisplay);
  788.  
  789.             lpDIBDisplay = lpDIBNew;
  790.             InvalidateRect (hwndMain, NULL, FALSE);
  791.           }
  792.           break;
  793.     
  794.         case SB_LINEDOWN:
  795.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) + 1;
  796.           break;
  797.  
  798.         case SB_LINEUP:
  799.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) - 1;
  800.           break;
  801.         case SB_PAGEDOWN:
  802.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) + 10;
  803.           break;
  804.  
  805.         case SB_PAGEUP:
  806.           iNewPos = GetScrollPos (hwndScroll, SB_CTL) - 10;
  807.           break;
  808.       }
  809.  
  810.       if (iNewPos < 50)
  811.         iNewPos = 50;
  812.  
  813.       if (iNewPos > 150)
  814.         iNewPos = 150;
  815.  
  816.       wsprintf ((LPSTR)szMessage, (LPSTR)"%d %%", iNewPos);
  817.       hwndStatic = GetDlgItem (hDlg, IDC_BRIGHTNESS_PERCENTAGE);
  818.       SetWindowText (hwndStatic, szMessage);
  819.       SetScrollPos (hwndScroll, SB_CTL, iNewPos, TRUE);
  820.       return (TRUE);
  821.  
  822.     case WM_COMMAND:
  823.  
  824.       switch (CONTROL_ID (wParam))
  825.       {
  826.         case IDOK:
  827.           hwndScroll = GetDlgItem (hDlg, IDC_BRIGHTNESS_SCROLLBAR);
  828.           iNewPos = GetScrollPos (hwndScroll, SB_CTL);
  829.           
  830.           if (lpDIBDisplay != lpDIBSave)
  831.           {
  832.             DIBFree (lpDIBDisplay);
  833.             lpDIBDisplay = lpDIBSave;
  834.           }
  835.           EndDialog(hDlg, iNewPos);
  836.           return (TRUE);
  837.         case IDCANCEL:
  838.           
  839.           if (lpDIBDisplay != lpDIBSave)
  840.           {
  841.             DIBFree (lpDIBDisplay);
  842.             lpDIBDisplay = lpDIBSave;
  843.             InvalidateRect (hwndMain, NULL, FALSE);
  844.           }
  845.           EndDialog(hDlg, FALSE);
  846.           return (TRUE);
  847.       }
  848.       break;
  849.   }
  850.   return (FALSE);
  851. }
  852.  
  853. /****************************************************************************
  854.     FUNCTION: FileTypeProc(HWND, UINT, WPARAM, LPARAM)
  855.     PURPOSE:  Processes messages for the FileType dialog
  856. ****************************************************************************/
  857.  
  858. BOOL CALLBACK FileTypeProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  859. {
  860. static short      *pnFileType;
  861. int               iCtrl;
  862.  
  863.   switch (message)
  864.   {
  865.     case WM_INITDIALOG:
  866.  
  867.       pnFileType = (short *)lParam;
  868.  
  869.       switch (*pnFileType)
  870.       {
  871.         case FILETYPE_BMP:
  872.           iCtrl = IDC_IT_BMP;
  873.           break;
  874.         case FILETYPE_TIFF_DEFAULT:
  875.           iCtrl = IDC_IT_TIFF;
  876.           break;
  877.         case FILETYPE_TIFF_NO_COMPRESSION:
  878.           iCtrl = IDC_IT_TIFF_NOCOMP;
  879.           break;
  880.         case FILETYPE_TIFF_HUFFMAN:
  881.           iCtrl = IDC_IT_TIFF_HUFFMAN;
  882.           break;
  883.         case FILETYPE_TIFF_PACKBITS:
  884.           iCtrl = IDC_IT_TIFF_PACKBITS;
  885.           break;
  886.         case FILETYPE_TIFF_G3:
  887.           iCtrl = IDC_IT_TIFF_G3;
  888.           break;
  889.         case FILETYPE_TIFF_G4:
  890.           iCtrl = IDC_IT_TIFF_G4;
  891.           break;
  892.         default:
  893.           iCtrl = IDC_IT_BMP;
  894.           break;
  895.       }
  896.       CheckRadioButton (hDlg, IDC_IT_BMP, IDC_IT_TIFF_G4, iCtrl);
  897.       return (TRUE);
  898.  
  899.     case WM_COMMAND:
  900.  
  901.       if (CONTROL_ID (wParam) == IDOK)
  902.       {
  903.         if (IsDlgButtonChecked (hDlg, IDC_IT_BMP))
  904.           *pnFileType = FILETYPE_BMP;
  905.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF))
  906.           *pnFileType = FILETYPE_TIFF_DEFAULT;
  907.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_NOCOMP))
  908.           *pnFileType = FILETYPE_TIFF_NO_COMPRESSION;
  909.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_HUFFMAN))
  910.           *pnFileType = FILETYPE_TIFF_HUFFMAN;
  911.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_PACKBITS))
  912.           *pnFileType = FILETYPE_TIFF_PACKBITS;
  913.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_G3))
  914.           *pnFileType = FILETYPE_TIFF_G3;
  915.         else if (IsDlgButtonChecked (hDlg, IDC_IT_TIFF_G4))
  916.           *pnFileType = FILETYPE_TIFF_G4;
  917.         EndDialog(hDlg, TRUE);
  918.         return (TRUE);
  919.       }
  920.       else if (CONTROL_ID (wParam) == IDCANCEL)
  921.       {
  922.         EndDialog(hDlg, FALSE);
  923.         return (TRUE);
  924.       }
  925.       break;
  926.   }
  927.   return (FALSE);
  928. }
  929.  
  930. /****************************************************************************
  931.     FUNCTION: PrintProc(HWND, UINT, WPARAM, LPARAM)
  932.     PURPOSE:  Processes messages for the Print dialog
  933. ****************************************************************************/
  934.  
  935. BOOL CALLBACK PrintProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  936. {
  937. static LPBITMAPINFOHEADER pBmi;
  938. HWND              hwndCtl;
  939. LPDEVNAMES        pDevNames, pDevNamesNew;
  940. LPDEVMODE         pDevMode, pDevModeNew;
  941. char              szBuffer[256];
  942. static PRINTDLG   PrintDlgStruct;
  943. unsigned int      uCopyCount;
  944. BOOL              bConvertOK;
  945. HANDLE            hDevModeNew, hDevNamesNew;
  946.  
  947.   switch (message)
  948.   {
  949.     case WM_INITDIALOG:
  950.  
  951.       PrintDlgStruct = *pPrintDlgStruct;
  952.       SetDlgItemInt (hDlg, IDC_COPY_COUNT, uPrintCopies, FALSE);
  953.       pBmi = (LPBITMAPINFOHEADER) lParam;
  954.       pDevNames = (LPDEVNAMES)GlobalLock (pPrintDlgStruct->hDevNames);
  955.       pDevMode = (LPDEVMODE)GlobalLock (pPrintDlgStruct->hDevMode);
  956.  
  957.       /*
  958.        * Make copies of the DEVNAMES and DEVMODE structures
  959.        */
  960.       hDevNamesNew = GlobalAlloc (GMEM_MOVEABLE, GlobalSize (pPrintDlgStruct->hDevNames));
  961.       pDevNamesNew = (LPDEVNAMES) GlobalLock (hDevNamesNew);
  962.       hDevModeNew = GlobalAlloc (GMEM_MOVEABLE, GlobalSize (pPrintDlgStruct->hDevMode));
  963.       pDevModeNew = (LPDEVMODE) GlobalLock (hDevModeNew);
  964.       copymem (pDevModeNew, pDevMode, GlobalSize (hDevModeNew));
  965.       copymem (pDevNamesNew, pDevNames, GlobalSize (hDevNamesNew));
  966.       GlobalUnlock (pPrintDlgStruct->hDevNames);
  967.       GlobalUnlock (pPrintDlgStruct->hDevMode);
  968.       PrintDlgStruct.hDevMode = hDevModeNew;
  969.       PrintDlgStruct.hDevNames = hDevNamesNew;
  970.  
  971.       if (pBmi->biPlanes * pBmi->biBitCount == 1 || pDevModeNew->dmColor == DMCOLOR_COLOR)   // monochrome bitmap or color printer
  972.       {
  973.         hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  974.         EnableWindow (hwndCtl, FALSE);
  975.         hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  976.         EnableWindow (hwndCtl, FALSE);
  977.         hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  978.         EnableWindow (hwndCtl, FALSE);
  979.       }
  980.       else
  981.       {
  982.         if (bHalftoneImgLib)
  983.           CheckRadioButton (hDlg, IDC_METHOD_GDI, IDC_METHOD_IMGLIB, IDC_METHOD_IMGLIB);
  984.         else
  985.           CheckRadioButton (hDlg, IDC_METHOD_GDI, IDC_METHOD_IMGLIB, IDC_METHOD_GDI);
  986.       }
  987.       if (bFillPage)
  988.         CheckDlgButton (hDlg, IDC_FILL_PAGE, TRUE);
  989.  
  990.       wsprintf ((LPSTR)szBuffer, (LPSTR)"%s on %s", (LPSTR)pDevNamesNew + pDevNamesNew->wDeviceOffset, (LPSTR)pDevNamesNew + pDevNamesNew->wOutputOffset);
  991.       SetDlgItemText (hDlg, IDC_PRINTERNAME, szBuffer);
  992.       GlobalUnlock (hDevNamesNew);
  993.       GlobalUnlock (hDevModeNew);
  994.       return (TRUE);
  995.  
  996.     case WM_COMMAND:
  997.  
  998.       switch (CONTROL_ID (wParam))
  999.       {
  1000.         case IDC_SETUP_PRINTER:
  1001.  
  1002.           PrintDlgStruct.hwndOwner = hDlg;
  1003.           PrintDlgStruct.Flags = PD_PRINTSETUP;
  1004.           if (PrintDlg (&PrintDlgStruct))
  1005.           {
  1006.             pDevModeNew = (LPDEVMODE) GlobalLock (PrintDlgStruct.hDevMode);
  1007.             if (pBmi->biPlanes * pBmi->biBitCount == 1 || pDevModeNew->dmColor == DMCOLOR_COLOR)   // monochrome bitmap or color printer
  1008.             {
  1009.               hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  1010.               EnableWindow (hwndCtl, FALSE);
  1011.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  1012.               EnableWindow (hwndCtl, FALSE);
  1013.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  1014.               EnableWindow (hwndCtl, FALSE);
  1015.             }
  1016.             else
  1017.             {
  1018.               hwndCtl = GetDlgItem (hDlg, IDC_HALFTONE_GROUP);
  1019.               EnableWindow (hwndCtl, TRUE);
  1020.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_GDI);
  1021.               EnableWindow (hwndCtl, TRUE);
  1022.               hwndCtl = GetDlgItem (hDlg, IDC_METHOD_IMGLIB);
  1023.               EnableWindow (hwndCtl, TRUE);
  1024.             }
  1025.             GlobalUnlock (PrintDlgStruct.hDevMode);
  1026.           }
  1027.           return (TRUE);
  1028.  
  1029.         case IDOK:
  1030.  
  1031.           uCopyCount = GetDlgItemInt (hDlg, IDC_COPY_COUNT, &bConvertOK, FALSE);
  1032.  
  1033.           if (!bConvertOK || uCopyCount < 1 || uCopyCount > 100)
  1034.           {
  1035.             MessageBox (hDlg, "Invalid value.  Please enter a number between 1 and 100", "Print", MB_ICONSTOP | MB_OK);
  1036.             SetFocus (GetDlgItem (hDlg, IDC_COPY_COUNT));
  1037.             return (TRUE);
  1038.           }
  1039.           uPrintCopies = uCopyCount;
  1040.           bFillPage = IsDlgButtonChecked (hDlg, IDC_FILL_PAGE);
  1041.           bHalftoneImgLib = IsDlgButtonChecked (hDlg, IDC_METHOD_IMGLIB);
  1042.           GlobalFree (pPrintDlgStruct->hDevNames);
  1043.           GlobalFree (pPrintDlgStruct->hDevMode);
  1044.           *pPrintDlgStruct = PrintDlgStruct;
  1045.           EndDialog (hDlg, TRUE);
  1046.           return (TRUE);
  1047.  
  1048.         case IDCANCEL:
  1049.  
  1050.           GlobalFree (PrintDlgStruct.hDevNames);
  1051.           GlobalFree (PrintDlgStruct.hDevMode);
  1052.           EndDialog (hDlg, FALSE);
  1053.           return (TRUE);
  1054.       }
  1055.       break;
  1056.   }
  1057.   return (FALSE);
  1058. }
  1059.  
  1060. /*************************************************************************
  1061.   Function:  GetOpenFile (LPSTR. WORD)
  1062.    Purpose:  Prompts user for a filename through the use of a Windows
  1063.              FileOpen common dialog box.
  1064.    Returns:  TRUE if a filename is selected.
  1065.              FALSE if no filename is selected.
  1066.   Comments:  Filename is put into the string passed to the routine.
  1067.              If a filename is not selected, NULL is returned.
  1068. *************************************************************************/
  1069.  
  1070. BOOL GetOpenFile (LPSTR szFileName)
  1071. {
  1072. OPENFILENAME   of;
  1073. DWORD          flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
  1074. static char    szTitle[30];         // Dialog Box title
  1075. static char    szTemplate[20];      // Dialog Box template
  1076. static char    szFile[256];         // File name
  1077. static char    szFileTitle[256];    // Title
  1078. static char    szDrive[5];          // Drive
  1079. static char    szDir[256];          // Directory
  1080. char szFilter[] =                   // Filter
  1081.   "Pictures\0*.bmp;*.jpg;*.tga;*.pcd;*.pcx;*.tif\0All Files\0*.*\0";
  1082. LPSTR          pFile;
  1083.  
  1084.    szFile[0] = '\0';
  1085.    of.lStructSize       = sizeof (OPENFILENAME);
  1086.    of.hwndOwner         = hwndMain;
  1087.    of.hInstance         = hInst;
  1088.    of.lpstrFilter       = szFilter;
  1089.    of.lpstrCustomFilter = NULL;
  1090.    of.nMaxCustFilter    = 0L;
  1091.    of.nFilterIndex      = 1L;
  1092.    of.lpstrFile         = szFile;
  1093.    of.nMaxFile          = sizeof (szFile);
  1094.    of.lpstrFileTitle    = szFileTitle;
  1095.    of.nMaxFileTitle     = sizeof (szFileTitle);
  1096.    of.lpstrInitialDir   = szDir;
  1097.    of.lpstrTitle        = "Open a new test bitmap file";
  1098.    of.Flags             = flags;
  1099.    of.nFileOffset       = 0;
  1100.    of.nFileExtension    = 0;
  1101.    of.lpstrDefExt       = NULL;
  1102.    of.lCustData         = 0;
  1103.    of.lpfnHook          = NULL;
  1104.    of.lpTemplateName    = NULL;
  1105.  
  1106.   if (GetOpenFileName (&of))
  1107.   {
  1108.     lstrcpy (szFileName, of.lpstrFile);
  1109.     lstrcpy (szDir, of.lpstrFile);
  1110.     pFile = strrchr (szDir, '\\');
  1111.  
  1112.     if (pFile)
  1113.       *pFile = 0;
  1114.  
  1115.     return TRUE;
  1116.   }
  1117.   else
  1118.     return FALSE;
  1119. }
  1120.  
  1121. /*************************************************************************
  1122.   Function:  GetSaveFile (LPSTR. WORD)
  1123.    Purpose:  Prompts user for a filename through the use of a Windows
  1124.              FileOpen common dialog box.
  1125.    Returns:  TRUE if a filename is selected.
  1126.              FALSE if no filename is selected.
  1127.   Comments:  Filename is put into the string passed to the routine.
  1128.              If a filename is not selected, NULL is returned.
  1129. *************************************************************************/
  1130.  
  1131. BOOL GetSaveFile (LPSTR szFileName)
  1132. {
  1133. OPENFILENAME   of;
  1134. DWORD          flags = OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
  1135. static char    szTitle[30];         // Dialog Box title
  1136. static char    szTemplate[20];      // Dialog Box template
  1137. static char    szFile[256];         // File name
  1138. static char    szFileTitle[256];    // Title
  1139. static char    szDrive[5];          // Drive
  1140. static char    szDir[256];          // Directory
  1141. char szFilter[] =                   // Filter
  1142.   "Windows Pictures\0*.bmp;*.tif\0All Files\0*.*\0";
  1143. LPSTR          pFile;
  1144.  
  1145.    szFile[0] = '\0';
  1146.    of.lStructSize       = sizeof (OPENFILENAME);
  1147.    of.hwndOwner         = GetFocus ();
  1148.    of.hInstance         = hInst;
  1149.    of.lpstrFilter       = szFilter;
  1150.    of.lpstrCustomFilter = NULL;
  1151.    of.nMaxCustFilter    = 0L;
  1152.    of.nFilterIndex      = 1L;
  1153.    of.lpstrFile         = szFile;
  1154.    of.nMaxFile          = sizeof (szFile);
  1155.    of.lpstrFileTitle    = szFileTitle;
  1156.    of.nMaxFileTitle     = sizeof (szFileTitle);
  1157.    of.lpstrInitialDir   = szDir;
  1158.    of.lpstrTitle        = "Save the image in a bitmap file";
  1159.    of.Flags             = flags;
  1160.    of.nFileOffset       = 0;
  1161.    of.nFileExtension    = 0;
  1162.    of.lpstrDefExt       = "*.bmp";
  1163.    of.lCustData         = 0;
  1164.    of.lpfnHook          = NULL;
  1165.    of.lpTemplateName    = NULL;
  1166.  
  1167.   if (GetSaveFileName (&of))
  1168.   {
  1169.     lstrcpy (szFileName, of.lpstrFile);
  1170.     lstrcpy (szDir, of.lpstrFile);
  1171.     pFile = strrchr (szDir, '\\');
  1172.  
  1173.     if (pFile)
  1174.       *pFile = 0;
  1175.  
  1176.     return TRUE;
  1177.   }
  1178.   else
  1179.     return FALSE;
  1180. }
  1181.  
  1182. /*************************************************************************
  1183.   Function:  CreateDisplayDIB()
  1184.    Purpose:  Creates a DIB suitable for the display based on user-selected options.
  1185.    Returns:  a new DIB pointer
  1186. *************************************************************************/
  1187.  
  1188. LPVOID CreateDisplayDIB (HWND hwnd, LPVOID *lpDIB, HPALETTE *phPal)
  1189. {
  1190. HMENU             hMenu;
  1191. LPBITMAPINFO      pBitmapInfo;
  1192. UINT              uState;
  1193. LPVOID            lpDIBDisplay;
  1194. long              lColors;
  1195. int               iPixelBits, iPlanes;
  1196. HDC               hDC;
  1197.  
  1198.   hDC = GetDC (hwnd);
  1199.   iPixelBits = GetDeviceCaps (hDC, BITSPIXEL);
  1200.   iPlanes = GetDeviceCaps (hDC, PLANES);
  1201.   ReleaseDC (hwnd, hDC);
  1202.  
  1203.   if (iPixelBits * iPlanes > 8)
  1204.   {
  1205.     /*
  1206.      * No color reduction on true color (or high color) displays
  1207.      */
  1208.     *phPal = NULL;
  1209.     return (*lpDIB);
  1210.   }
  1211.   pBitmapInfo = (LPBITMAPINFO) *lpDIB;
  1212.   hMenu = GetMenu (hwnd);
  1213.   uState = GetMenuState (hMenu, ID_OPTIONS_TC_DISPLAY_GDI, MF_BYCOMMAND);
  1214.  
  1215.   if (uState & MF_CHECKED || pBitmapInfo->bmiHeader.biClrUsed)
  1216.   {
  1217.     lpDIBDisplay = *lpDIB;
  1218.     
  1219.     if (pBitmapInfo->bmiHeader.biClrUsed > 2)
  1220.       *phPal = CreateDIBPalette (lpDIBDisplay);
  1221.     else
  1222.       *phPal = NULL;
  1223.   }
  1224.   else
  1225.   {
  1226.     uState = GetMenuState (hMenu, ID_OPTIONS_TC_DISPLAY_WING, MF_BYCOMMAND);
  1227.  
  1228.     if (uState & MF_CHECKED && hWinGInst)
  1229.     {
  1230.       lpDIBDisplay = WinGHalftoneDIB (*lpDIB, phPal);
  1231.     }
  1232.     else
  1233.     {
  1234.       lColors = 1 << iPixelBits * iPlanes;
  1235.       lpDIBDisplay = ReduceDIB (*lpDIB, lColors, TRUE);
  1236.       *phPal = CreateDIBPalette (lpDIBDisplay);
  1237.     }
  1238.  
  1239.     if (lpDIBDisplay && lpDIBDisplay != *lpDIB)
  1240.     {
  1241.       if (!(GetMenuState (hMenu, ID_OPTIONS_RETAIN_TC, MF_BYCOMMAND) & MF_CHECKED))
  1242.       {
  1243.         DIBFree (*lpDIB);
  1244.         *lpDIB = lpDIBDisplay;
  1245.       }
  1246.     }
  1247.   }
  1248. #ifdef USE_WING
  1249.   /*
  1250.    * Use WinG for displaying if available
  1251.    */
  1252.  
  1253.   if (hWinGInst)
  1254.     UpdateWinGBitmap (lpDIBDisplay);
  1255. #endif
  1256.   return (lpDIBDisplay);
  1257. }
  1258.  
  1259. /*************************************************************************
  1260.   Function:  UpdateWindowTitle ()
  1261.    Purpose:  Updates the window title with the name of the file displayed.
  1262.    Returns:  none
  1263. *************************************************************************/
  1264.  
  1265. static void UpdateWindowTitle (LPSTR pszFilePath, BOOL bStripPath)
  1266. {
  1267. static char       szWindowName[260];
  1268. char              szFileName[260];
  1269. char              *pszFileName = NULL;
  1270.  
  1271.   if (pszFilePath && *pszFilePath)
  1272.   {
  1273.     /*
  1274.      * Make local copy because in 16-bit world strrchr can only operate on
  1275.      * near pointers.
  1276.      */
  1277.     lstrcpy (szFileName, pszFilePath);
  1278.  
  1279.     if (bStripPath)
  1280.       pszFileName = strrchr (szFileName, '\\');
  1281.  
  1282.     /*
  1283.      * If found the last path delimiter, skip over it.
  1284.      */
  1285.     if (pszFileName)
  1286.       pszFileName++;
  1287.     else
  1288.       pszFileName = szFileName;
  1289.  
  1290.     wsprintf ((LPSTR)szWindowName, (LPSTR)"%s -- %s", (LPSTR)WINDOW_NAME, (LPSTR)pszFileName);
  1291.   }
  1292.   else
  1293.     wsprintf ((LPSTR)szWindowName, (LPSTR)"%s", (LPSTR)WINDOW_NAME);
  1294.  
  1295.   SetWindowText (hwndMain, szWindowName);
  1296. }
  1297.  
  1298. /*************************************************************************
  1299.   Function:  ResizeWindowToDIB ()
  1300.    Purpose:  Updates the window size to fit the given device-independent DIB
  1301.    Returns:  none
  1302. *************************************************************************/
  1303.  
  1304. static void ResizeWindowToDIB (HWND hwnd, LPVOID pDIB)
  1305. {
  1306. int               iWidth, iHeight, iXOverhead, iYOverhead;
  1307. int               iScreenWidth, iScreenHeight, iXPos, iYPos;
  1308. int               iHScrollRange, iVScrollRange;
  1309. LPBITMAPINFOHEADER pBmi = (LPBITMAPINFOHEADER)pDIB;
  1310. HDC               hDC;
  1311. RECT              rect;
  1312. BOOL              bHScroll, bVScroll;
  1313. DWORD             dwStyle;
  1314.  
  1315.   bHScroll = bVScroll = FALSE;
  1316.   GetWindowRect (hwnd, &rect);
  1317.   iXPos = rect.left;
  1318.  
  1319.   if (iXPos < 0)
  1320.     iXPos = 0;
  1321.  
  1322.   iYPos = rect.top;
  1323.  
  1324.   if (iYPos < 0)
  1325.     iYPos = 0;
  1326.  
  1327.   hDC = GetDC (hwnd);
  1328.   iScreenWidth = GetDeviceCaps (hDC, HORZRES);
  1329.   iScreenHeight = GetDeviceCaps (hDC, VERTRES);
  1330.   ReleaseDC (hwnd, hDC);
  1331.   iWidth = (int)pBmi->biWidth;
  1332.   iHeight = (int)pBmi->biHeight;
  1333.   iXOverhead = GetSystemMetrics (SM_CXFRAME) * 2;
  1334.   iYOverhead = GetSystemMetrics (SM_CYFRAME) * 2 + GetSystemMetrics (SM_CYCAPTION) + GetSystemMetrics (SM_CYMENU);
  1335.  
  1336.   if (iWidth + iXOverhead + iXPos > iScreenWidth)
  1337.   {
  1338.     iXPos = iScreenWidth - iWidth - iXOverhead;
  1339.  
  1340.     if (iXPos < 0)
  1341.     {
  1342.       iHScrollRange = -iXPos;
  1343.       iXPos = 0;
  1344.       bHScroll = TRUE;
  1345.     }
  1346.   }
  1347.   if (iHeight + iYOverhead + iYPos > iScreenHeight)
  1348.   {
  1349.     iYPos = iScreenHeight - iHeight - iYOverhead;
  1350.  
  1351.     if (iYPos < 0)
  1352.     {
  1353.       iVScrollRange = -iYPos;
  1354.       iYPos = 0;
  1355.       bVScroll = TRUE;
  1356.     }
  1357.   }
  1358.   dwStyle = GetWindowLong (hwnd, GWL_STYLE);
  1359.  
  1360.   if (bHScroll)
  1361.   {
  1362.     ShowScrollBar (hwndMain, SB_HORZ, TRUE);
  1363.     /*
  1364.      * Having the vertical scrollbar will "steal" some more pixels
  1365.      * from the client area.  Check and adjust for it here.
  1366.      */
  1367.     if (bVScroll)
  1368.       iHScrollRange += GetSystemMetrics (SM_CXVSCROLL);
  1369.   }
  1370.   else
  1371.   {
  1372.     /*
  1373.      * Remove the scrollbar
  1374.      */
  1375.     if (dwStyle & WS_HSCROLL)
  1376.     {
  1377.       SetScrollPos (hwnd, SB_HORZ, 0, TRUE);
  1378.       ShowScrollBar (hwndMain, SB_HORZ, FALSE);
  1379.     }
  1380.   }
  1381.   if (bVScroll)
  1382.   {
  1383.     ShowScrollBar (hwndMain, SB_VERT, TRUE);
  1384.     /*
  1385.      * Having the horizontal scrollbar will "steal" some more pixels
  1386.      * from the client area.  Check and adjust for it here.
  1387.      */
  1388.     if (bHScroll)
  1389.       iVScrollRange += GetSystemMetrics (SM_CYHSCROLL);
  1390.   }
  1391.   else
  1392.   {
  1393.     /*
  1394.      * Remove the scrollbar
  1395.      */
  1396.     if (dwStyle & WS_VSCROLL)
  1397.     {
  1398.       SetScrollPos (hwnd, SB_VERT, 0, TRUE);
  1399.       ShowScrollBar (hwndMain, SB_VERT, FALSE);
  1400.     }
  1401.   }
  1402.   
  1403.   /*
  1404.    * Having done all this checking, the following call may still cause the
  1405.    * addition of scrollbars in rare circumstances like the menu bar becoming
  1406.    * 2-line.
  1407.    */
  1408.   SetWindowPos (hwnd, HWND_TOP, iXPos, iYPos, min (iXOverhead + iWidth, iScreenWidth),
  1409.                 min (iYOverhead + iHeight, iScreenHeight),
  1410.                 SWP_NOACTIVATE | SWP_NOZORDER);
  1411.   if (bHScroll)
  1412.     SetScrollRange (hwnd, SB_HORZ, 0, iHScrollRange, TRUE);
  1413.   if (bVScroll)
  1414.     SetScrollRange (hwnd, SB_VERT, 0, iVScrollRange, TRUE);
  1415.  
  1416.   InvalidateRect (hwnd, (LPRECT) (NULL), FALSE);
  1417. }
  1418.  
  1419. /*************************************************************************
  1420.   Function:  HandleVerticalScroll ()
  1421.    Purpose:  Process the vertical scrollbar operations.
  1422.    Returns:  none
  1423. *************************************************************************/
  1424.  
  1425. static void HandleVerticalScroll (WPARAM wParam, LPARAM lParam)
  1426. {
  1427. int               nScrollCode, iNewPos, iVScroll, iHScroll;
  1428. int               iCurrPos, iMinScroll, iMaxScroll, iClientHeight;
  1429. RECT              rect;
  1430.  
  1431.   UpdateWindow (hwndMain);
  1432.  
  1433. #ifdef WIN32
  1434.   nScrollCode = (int) LOWORD (wParam);
  1435.   iNewPos = (int) HIWORD (wParam);
  1436. #else
  1437.   nScrollCode = (int) wParam;
  1438.   iNewPos = (int) LOWORD (lParam);
  1439. #endif
  1440.  
  1441.   GetClientRect (hwndMain, &rect);
  1442.   iClientHeight = rect.bottom;
  1443.   iHScroll = iVScroll = 0;
  1444.   GetScrollRange (hwndMain, SB_VERT, &iMinScroll, &iMaxScroll);
  1445.   iCurrPos = GetScrollPos (hwndMain, SB_VERT);
  1446.  
  1447.   switch (nScrollCode)
  1448.   {
  1449.     case SB_BOTTOM:
  1450.       
  1451.       iVScroll = iMaxScroll - iCurrPos;
  1452.       break;
  1453.  
  1454.     case SB_PAGEDOWN:
  1455.  
  1456.       if (iCurrPos + iClientHeight <= iMaxScroll)
  1457.         iVScroll = -iClientHeight;
  1458.       else
  1459.         iVScroll = - (iMaxScroll - iCurrPos);
  1460.  
  1461.       break;
  1462.  
  1463.     case SB_PAGEUP:
  1464.  
  1465.       if (iCurrPos - iClientHeight >= 0)
  1466.         iVScroll = iClientHeight;
  1467.       else
  1468.         iVScroll = iCurrPos;
  1469.  
  1470.       break;
  1471.  
  1472.     case SB_THUMBTRACK:
  1473.     case SB_THUMBPOSITION:
  1474.       iVScroll = GetScrollPos (hwndMain, SB_VERT) - iNewPos;
  1475.       break;
  1476.   
  1477.     case SB_LINEDOWN:
  1478.  
  1479.       iVScroll = -1;
  1480.       break;
  1481.  
  1482.     case SB_LINEUP:
  1483.  
  1484.       iVScroll = 1;
  1485.       break;
  1486.  
  1487.     case SB_ENDSCROLL:
  1488.  
  1489.       return;
  1490.   }
  1491.   if (iCurrPos - iVScroll > iMaxScroll)
  1492.     iVScroll = iCurrPos - iMaxScroll;
  1493.  
  1494.   if (iCurrPos - iVScroll < iMinScroll)
  1495.     iVScroll = iCurrPos - iMinScroll;
  1496.  
  1497.   if (!iVScroll)
  1498.     return;
  1499.  
  1500.   ScrollWindow (hwndMain, iHScroll, iVScroll, NULL, &rect);
  1501.   SetScrollPos (hwndMain, SB_VERT, iCurrPos - iVScroll, TRUE);
  1502. }
  1503.  
  1504. /*************************************************************************
  1505.   Function:  HandleHorizontalScroll ()
  1506.    Purpose:  Process the horozontal scrollbar operations.
  1507.    Returns:  none
  1508. *************************************************************************/
  1509.  
  1510. static void HandleHorizontalScroll (WPARAM wParam, LPARAM lParam)
  1511. {
  1512. int               nScrollCode, iNewPos, iVScroll, iHScroll;
  1513. int               iCurrPos, iMinScroll, iMaxScroll, iClientWidth;
  1514. RECT              rect;
  1515.  
  1516.   UpdateWindow (hwndMain);
  1517.  
  1518. #ifdef WIN32
  1519.   nScrollCode = (int) LOWORD (wParam);
  1520.   iNewPos = (int) HIWORD (wParam);
  1521. #else
  1522.   nScrollCode = (int) wParam;
  1523.   iNewPos = (int) LOWORD (lParam);
  1524. #endif
  1525.  
  1526.   GetClientRect (hwndMain, &rect);
  1527.   iClientWidth = rect.right;
  1528.   iHScroll = iVScroll = 0;
  1529.   GetScrollRange (hwndMain, SB_HORZ, &iMinScroll, &iMaxScroll);
  1530.   iCurrPos = GetScrollPos (hwndMain, SB_HORZ);
  1531.  
  1532.   switch (nScrollCode)
  1533.   {
  1534.     case SB_BOTTOM:
  1535.       
  1536.       iHScroll = iMaxScroll - iCurrPos;
  1537.       break;
  1538.  
  1539.     case SB_PAGEDOWN:
  1540.  
  1541.       if (iCurrPos + iClientWidth <= iMaxScroll)
  1542.         iHScroll = -iClientWidth;
  1543.       else
  1544.         iHScroll = - (iMaxScroll - iCurrPos);
  1545.  
  1546.       break;
  1547.  
  1548.     case SB_PAGEUP:
  1549.  
  1550.       if (iCurrPos - iClientWidth >= 0)
  1551.         iHScroll = iClientWidth;
  1552.       else
  1553.         iHScroll = iCurrPos;
  1554.  
  1555.       break;
  1556.  
  1557.     case SB_THUMBTRACK:
  1558.     case SB_THUMBPOSITION:
  1559.       iHScroll = GetScrollPos (hwndMain, SB_HORZ) - iNewPos;
  1560.       break;
  1561.   
  1562.     case SB_LINEDOWN:
  1563.  
  1564.       iHScroll = -1;
  1565.       break;
  1566.  
  1567.     case SB_LINEUP:
  1568.  
  1569.       iHScroll = 1;
  1570.       break;
  1571.  
  1572.     case SB_ENDSCROLL:
  1573.  
  1574.       return;
  1575.   }
  1576.   if (iCurrPos - iHScroll > iMaxScroll)
  1577.     iHScroll = iCurrPos - iMaxScroll;
  1578.  
  1579.   if (iCurrPos - iHScroll < iMinScroll)
  1580.     iHScroll = iCurrPos - iMinScroll;
  1581.  
  1582.   if (!iHScroll)
  1583.     return;
  1584.  
  1585.   ScrollWindow (hwndMain, iHScroll, iVScroll, NULL, &rect);
  1586.   SetScrollPos (hwndMain, SB_HORZ, iCurrPos - iHScroll, TRUE);
  1587. }
  1588.  
  1589. /*************************************************************************
  1590.   Function:  HandleWindowSizing ()
  1591.    Purpose:  Process the WM_SIZE messages.
  1592.    Returns:  none
  1593. *************************************************************************/
  1594.  
  1595. static void HandleWindowSizing (LPVOID pDIB, WPARAM wParam, LPARAM lParam)
  1596. {
  1597. LPBITMAPINFOHEADER pBmi = (LPBITMAPINFOHEADER)pDIB;
  1598. BOOL              bHScroll, bVScroll;
  1599. DWORD             dwStyle;
  1600. int               iNewWidth, iNewHeight;
  1601. int               iHScrollRange, iVScrollRange;
  1602. int               iPos;
  1603. static BOOL       bSizing;
  1604.  
  1605.   /*
  1606.    * Prevent resizing from infinitely recursing.  This may be caused by having
  1607.    * to add or take away a scrollbar which in turn causes another WM_SIZE
  1608.    * message to be generated as the client area is affected by the scrollbars.
  1609.    */
  1610.   if (bSizing)
  1611.     return;
  1612.   if (!pBmi)
  1613.     return;
  1614.   if (wParam == SIZE_MINIMIZED || wParam == SIZE_MAXHIDE || wParam == SIZE_MAXSHOW)
  1615.     return;
  1616.  
  1617.   bSizing = TRUE;
  1618.   bHScroll = bVScroll = FALSE;
  1619.   iHScrollRange = iVScrollRange = 0;
  1620.   dwStyle = GetWindowLong (hwndMain, GWL_STYLE);
  1621.   iNewWidth = (int) LOWORD (lParam);
  1622.   iNewHeight = (int) HIWORD (lParam);
  1623.  
  1624.   if (dwStyle & WS_HSCROLL)
  1625.     iNewHeight += GetSystemMetrics (SM_CYHSCROLL);
  1626.  
  1627.   if (dwStyle & WS_VSCROLL)
  1628.     iNewWidth += GetSystemMetrics (SM_CXVSCROLL);
  1629.  
  1630.   /*
  1631.    * The following code determines if the scrollbars are required.
  1632.    * Adding a scrollbar "steals" pixels from client area, so the affected
  1633.    * dimension must be rechecked for a need of scrollbar.
  1634.    */
  1635.   if (pBmi->biWidth > iNewWidth)
  1636.   {
  1637.     bHScroll = TRUE;
  1638.     iHScrollRange = (int)pBmi->biWidth - iNewWidth;
  1639.     iNewHeight -= GetSystemMetrics (SM_CYHSCROLL);
  1640.   }
  1641.  
  1642.   if (pBmi->biHeight > iNewHeight)
  1643.   {
  1644.     bVScroll = TRUE;
  1645.     iVScrollRange = (int)pBmi->biHeight - iNewHeight;
  1646.     iNewWidth -= GetSystemMetrics (SM_CXVSCROLL);
  1647.  
  1648.     /*
  1649.      * Recheck the width to see if a horizontal scrollbar may be ncecessary.
  1650.      */
  1651.     if (pBmi->biWidth > iNewWidth && !bHScroll)
  1652.     {
  1653.       bHScroll = TRUE;
  1654.       iHScrollRange = (int)pBmi->biWidth - iNewWidth;
  1655.       iNewHeight -= GetSystemMetrics (SM_CYHSCROLL);
  1656.       iVScrollRange += GetSystemMetrics (SM_CYHSCROLL);
  1657.     }
  1658.   }
  1659.  
  1660.   if (!bHScroll && (dwStyle & WS_HSCROLL))
  1661.   {
  1662.     /*
  1663.      * Remove the scrollbar
  1664.      */
  1665.     SetScrollPos (hwndMain, SB_HORZ, 0, TRUE);
  1666.     ShowScrollBar (hwndMain, SB_HORZ, FALSE);
  1667.   }
  1668.   if (!bVScroll && (dwStyle & WS_VSCROLL))
  1669.   {
  1670.     /*
  1671.      * Remove the scrollbar
  1672.      */
  1673.     SetScrollPos (hwndMain, SB_VERT, 0, TRUE);
  1674.     ShowScrollBar (hwndMain, SB_VERT, FALSE);
  1675.   }
  1676.   /*
  1677.    * Update the scrollbar positions and ranges
  1678.    */
  1679.   if (bHScroll)
  1680.   {
  1681.     ShowScrollBar (hwndMain, SB_HORZ, TRUE);
  1682.     iPos = GetScrollPos (hwndMain, SB_HORZ);
  1683.  
  1684.     if (iPos > iHScrollRange)
  1685.     {
  1686.       InvalidateRect (hwndMain, NULL, FALSE);
  1687.       SetScrollPos (hwndMain, SB_HORZ, iHScrollRange, TRUE);
  1688.     }
  1689.     SetScrollRange (hwndMain, SB_HORZ, 0, iHScrollRange, TRUE);
  1690.   }
  1691.   if (bVScroll)
  1692.   {
  1693.     ShowScrollBar (hwndMain, SB_VERT, TRUE);
  1694.     iPos = GetScrollPos (hwndMain, SB_VERT);
  1695.  
  1696.     if (iPos > iVScrollRange)
  1697.     {
  1698.       InvalidateRect (hwndMain, NULL, FALSE);
  1699.       SetScrollPos (hwndMain, SB_VERT, iVScrollRange, TRUE);
  1700.     }
  1701.     SetScrollRange (hwndMain, SB_VERT, 0, iVScrollRange, TRUE);
  1702.   }
  1703.   bSizing = FALSE;
  1704. }
  1705.  
  1706. /*************************************************************************
  1707.   Function:  HandlePrinting ()
  1708.    Purpose:  Process the File/Print request.
  1709.    Returns:  none
  1710. *************************************************************************/
  1711.  
  1712. static void HandlePrinting (LPVOID lpDIB)
  1713. {
  1714. HDC               hDC;
  1715. LPDEVNAMES        pDevNames;
  1716. LPDEVMODE         pDevMode;
  1717. LPVOID            lpDIBPrint = NULL;
  1718. LPBITMAPINFOHEADER pBih;
  1719. LPBITMAPINFO      pBmi;
  1720. char              szTitle[128];
  1721. DOCINFO           DocInfo;
  1722. int               iXMargin, iYMargin, iWidth, iHeight;
  1723.  
  1724.   if (!pPrintDlgStruct)
  1725.   {
  1726.     InitializePrintStruct ();
  1727.  
  1728.     if (!pPrintDlgStruct)
  1729.       return;
  1730.   }
  1731.   if (!DialogBoxParam (hInst, "IDD_PRINT", hwndMain, PrintProc, (LPARAM)lpDIB))
  1732.     return;
  1733.  
  1734.   SetCursor (LoadCursor (NULL, IDC_WAIT));
  1735.   pDevNames = (LPDEVNAMES)GlobalLock (pPrintDlgStruct->hDevNames);
  1736.   pDevMode = (LPDEVMODE)GlobalLock (pPrintDlgStruct->hDevMode);
  1737.   pDevMode->dmCopies = uPrintCopies;
  1738.   hDC = CreateDC ((LPCSTR)pDevNames + pDevNames->wDriverOffset, (LPCSTR)pDevNames + pDevNames->wDeviceOffset,
  1739.                   (LPCSTR)pDevNames + pDevNames->wOutputOffset, pDevMode);
  1740.  
  1741.   if (bHalftoneImgLib)
  1742.   {
  1743.     lpDIBPrint = HalftoneDIB (lpDIB);
  1744.     pBih = (LPBITMAPINFOHEADER) lpDIBPrint;
  1745.   }
  1746.   else
  1747.   {
  1748.     pBih = (LPBITMAPINFOHEADER) lpDIB;
  1749.   }
  1750.   iXMargin = GetDeviceCaps (hDC, HORZRES) / 20;
  1751.   iYMargin = GetDeviceCaps (hDC, VERTRES) / 20;
  1752.  
  1753.   if (bFillPage)
  1754.   {
  1755.     iWidth = GetDeviceCaps (hDC, HORZRES) - iXMargin * 2;
  1756.     iHeight = GetDeviceCaps (hDC, VERTRES) - iYMargin * 2;
  1757.  
  1758.     if (iWidth / pBih->biWidth > iHeight / pBih->biHeight)
  1759.       iWidth = (int)pBih->biWidth * iHeight / (int)pBih->biHeight;
  1760.     else
  1761.       iHeight = (int)pBih->biHeight * iWidth / (int)pBih->biWidth;
  1762.   }
  1763.   else
  1764.   {
  1765.     iWidth = (int)pBih->biWidth;
  1766.     iHeight = (int)pBih->biHeight;
  1767.  
  1768.     /*
  1769.      * ImgLib halftonning increases the image size 4 times.  To make the
  1770.      * output look the same size, size the output the same for GDI.
  1771.      */
  1772.     if (!bHalftoneImgLib)
  1773.     {
  1774.       iWidth *= 4;
  1775.       iHeight *= 4;
  1776.     }
  1777.   }
  1778.   pBmi = (LPBITMAPINFO)pBih;
  1779.   GetWindowText (hwndMain, szTitle, sizeof (szTitle));
  1780.   DocInfo.cbSize = sizeof (DocInfo);
  1781.   DocInfo.lpszDocName = szTitle;
  1782.   DocInfo.lpszOutput = NULL;
  1783.   StartDoc (hDC, &DocInfo);
  1784.   StartPage (hDC);
  1785.   StretchDIBits (hDC, iXMargin, iYMargin, iWidth, iHeight, 0, 0, (int)pBih->biWidth,
  1786.                                  (int)pBih->biHeight, (HPSTR)&pBmi->bmiColors[pBih->biClrUsed], pBmi,
  1787.                                  DIB_RGB_COLORS, SRCCOPY);
  1788.   EndPage (hDC);
  1789.   EndDoc (hDC);
  1790.   DeleteDC (hDC);
  1791.  
  1792.   if (lpDIBPrint)
  1793.     DIBFree (lpDIBPrint);
  1794.  
  1795.   GlobalUnlock (pPrintDlgStruct->hDevNames);
  1796.   GlobalUnlock (pPrintDlgStruct->hDevMode);
  1797.   SetCursor (LoadCursor (NULL, IDC_ARROW));
  1798. }
  1799.  
  1800. /*************************************************************************
  1801.   Function:  InitializePrintStruct ()
  1802.    Purpose:  Initialize the printing structure with default printer information.
  1803.    Returns:  none
  1804. *************************************************************************/
  1805.  
  1806. static void InitializePrintStruct (void)
  1807. {
  1808.   if (pPrintDlgStruct)
  1809.     freemem (pPrintDlgStruct);
  1810.  
  1811.   pPrintDlgStruct = (LPPRINTDLG)allocmem (sizeof (PRINTDLG));
  1812.  
  1813.   if (pPrintDlgStruct)
  1814.   {
  1815. #ifdef WIN32
  1816.     memset (pPrintDlgStruct, 0, sizeof (PRINTDLG));
  1817. #else
  1818.     _fmemset (pPrintDlgStruct, 0, sizeof (PRINTDLG));
  1819. #endif
  1820.     pPrintDlgStruct->lStructSize = sizeof (PRINTDLG);
  1821.     pPrintDlgStruct->hwndOwner = hwndMain;
  1822.     pPrintDlgStruct->Flags = PD_PRINTSETUP | PD_RETURNDEFAULT;
  1823.  
  1824.     if (PrintDlg (pPrintDlgStruct) == FALSE)
  1825.     {
  1826.       freemem (pPrintDlgStruct);
  1827.       pPrintDlgStruct = NULL;
  1828.       MessageBox (hwndMain, "Error getting the default printer information", WINDOW_NAME, MB_OK | MB_ICONSTOP);
  1829.       return;
  1830.     }
  1831.   }
  1832. }
  1833.  
  1834. /*************************************************************************
  1835.   Function:  HandleMenuPopup ()
  1836.    Purpose:  Prepare a menu for display based on the current application state
  1837.    Returns:  none
  1838. *************************************************************************/
  1839.  
  1840. static void HandleMenuPopup (WPARAM wParam, LPARAM lParam)
  1841. {
  1842. HMENU             hMenuParent, hMenuPopup;
  1843. UINT              uIndex;
  1844. BOOL              bSystemMenu;
  1845. HDC               hDC;
  1846. LPBITMAPINFOHEADER pBmi;
  1847.  
  1848.   bSystemMenu = HIWORD (lParam);
  1849.  
  1850.   if (bSystemMenu)
  1851.     return;
  1852.  
  1853.   hMenuParent = GetMenu (hwndMain);
  1854.   hMenuPopup = (HMENU)wParam;
  1855.   uIndex = LOWORD (lParam);
  1856.  
  1857.   if (hMenuPopup == GetSubMenu (hMenuParent, 0))
  1858.   {
  1859.     if (lpDIBDisplay)
  1860.     {
  1861.       EnableMenuItem (hMenuPopup, ID_FILE_SAVE, MF_BYCOMMAND | MF_ENABLED);
  1862.       EnableMenuItem (hMenuPopup, ID_FILE_PRINT, MF_BYCOMMAND | MF_ENABLED);
  1863.     }
  1864.     else
  1865.     {
  1866.       EnableMenuItem (hMenuPopup, ID_FILE_SAVE, MF_BYCOMMAND | MF_GRAYED);
  1867.       EnableMenuItem (hMenuPopup, ID_FILE_PRINT, MF_BYCOMMAND | MF_GRAYED);
  1868.     }
  1869.   }
  1870.   else if (hMenuPopup == GetSubMenu (hMenuParent, 1))
  1871.   {
  1872.     if (lpDIB1 && lpDIB2)
  1873.       EnableMenuItem (hMenuPopup, ID_EDIT_UNDO, MF_BYCOMMAND | MF_ENABLED);
  1874.     else
  1875.       EnableMenuItem (hMenuPopup, ID_EDIT_UNDO, MF_BYCOMMAND | MF_GRAYED);
  1876.  
  1877.     if (lpDIB1)
  1878.       EnableMenuItem (hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_ENABLED);
  1879.     else
  1880.       EnableMenuItem (hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_GRAYED);
  1881.  
  1882.     if (IsClipboardFormatAvailable (CF_BITMAP) || IsClipboardFormatAvailable (CF_DIB))
  1883.       EnableMenuItem (hMenuPopup, ID_EDIT_PASTE, MF_BYCOMMAND | MF_ENABLED);
  1884.     else
  1885.       EnableMenuItem (hMenuPopup, ID_EDIT_PASTE, MF_BYCOMMAND | MF_GRAYED);
  1886.  
  1887.     if (bDrawSelection)
  1888.       EnableMenuItem (hMenuPopup, ID_EDIT_ZOOM, MF_BYCOMMAND | MF_ENABLED);
  1889.     else
  1890.       EnableMenuItem (hMenuPopup, ID_EDIT_ZOOM, MF_BYCOMMAND | MF_GRAYED);
  1891.   }
  1892.   else if (hMenuPopup == GetSubMenu (hMenuParent, 2))
  1893.   {
  1894.     if (lpDIB1)
  1895.     {
  1896.       pBmi = (LPBITMAPINFOHEADER) lpDIBDisplay;
  1897.       
  1898.       /*
  1899.        * Disallow controlling brightness of monochrome bitmaps
  1900.        */
  1901.       if (pBmi->biPlanes * pBmi->biBitCount > 1)
  1902.         EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_ENABLED);
  1903.       else
  1904.         EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_GRAYED);
  1905.  
  1906.       EnableMenuItem (hMenuPopup, ID_PROCESS_SMOOTH, MF_BYCOMMAND | MF_ENABLED);
  1907.       EnableMenuItem (hMenuPopup, ID_PROCESS_HALFTONE, MF_BYCOMMAND | MF_ENABLED);
  1908.       EnableMenuItem (hMenuPopup, ID_PROCESS_GRAY, MF_BYCOMMAND | MF_ENABLED);
  1909.  
  1910.       if (pBmi->biPlanes * pBmi->biBitCount <= 8)
  1911.         EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_ENABLED);
  1912.       else
  1913.         EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_GRAYED);
  1914.  
  1915.       EnableMenuItem (hMenuPopup, MENU_POSITION_ROTATE, MF_BYPOSITION | MF_ENABLED);
  1916.       EnableMenuItem (hMenuPopup, MENU_POSITION_MIRROR, MF_BYPOSITION | MF_ENABLED);
  1917.     }
  1918.     else
  1919.     {
  1920.       EnableMenuItem (hMenuPopup, ID_PROCESS_BRIGHTNESS, MF_BYCOMMAND | MF_GRAYED);
  1921.       EnableMenuItem (hMenuPopup, ID_PROCESS_SMOOTH, MF_BYCOMMAND | MF_GRAYED);
  1922.       EnableMenuItem (hMenuPopup, ID_PROCESS_HALFTONE, MF_BYCOMMAND | MF_GRAYED);
  1923.       EnableMenuItem (hMenuPopup, ID_PROCESS_GRAY, MF_BYCOMMAND | MF_GRAYED);
  1924.       EnableMenuItem (hMenuPopup, ID_PROCESS_EXPAND, MF_BYCOMMAND | MF_GRAYED);
  1925.       EnableMenuItem (hMenuPopup, MENU_POSITION_ROTATE, MF_BYPOSITION | MF_GRAYED);
  1926.       EnableMenuItem (hMenuPopup, MENU_POSITION_MIRROR, MF_BYPOSITION | MF_GRAYED);
  1927.     }
  1928.   }
  1929.   else if (hMenuPopup == GetSubMenu (hMenuParent, 3))
  1930.   {
  1931.     hDC = GetDC (NULL);
  1932.  
  1933.     if (GetDeviceCaps (hDC, BITSPIXEL) > 8)
  1934.       EnableMenuItem (hMenuPopup, MENU_POSITION_TC_OPT, MF_BYPOSITION | MF_GRAYED);
  1935.     else
  1936.       EnableMenuItem (hMenuPopup, MENU_POSITION_TC_OPT, MF_BYPOSITION | MF_ENABLED);
  1937.  
  1938.     ReleaseDC (NULL, hDC);
  1939.   }
  1940. }
  1941.  
  1942. /*************************************************************************
  1943.   Function:  HandleLButtonDown ()
  1944.    Purpose:  Process the WM_LBUTTONDOWN message
  1945.    Returns:  none
  1946. *************************************************************************/
  1947. static void HandleLButtonDown (WPARAM wParam, LPARAM lParam)
  1948. {
  1949.   SetCapture (hwndMain);
  1950.  
  1951.   if (!bPasting)
  1952.   {
  1953.     if (bDrawSelection)
  1954.       EraseSelectionBox ();
  1955.     else
  1956.       bDrawSelection = TRUE;
  1957.  
  1958.     ptAnchor.x = rcSelection.left = rcSelection.right = LOWORD (lParam);
  1959.     ptAnchor.y = rcSelection.top = rcSelection.bottom = HIWORD (lParam);
  1960.     DrawSelectionBox ();
  1961.   }
  1962. }
  1963.  
  1964. /*************************************************************************
  1965.   Function:  HandleLButtonUp ()
  1966.    Purpose:  Process the WM_LBUTTONUP message
  1967.    Returns:  none
  1968. *************************************************************************/
  1969. static void HandleLButtonUp (WPARAM wParam, LPARAM lParam)
  1970. {
  1971. HANDLE            hDIB;
  1972. LPBITMAPINFOHEADER pBih;
  1973. HBITMAP           hBitmap;
  1974. HPALETTE          hPalTemp;
  1975. LPVOID            lpDIBNew, lpDIBTemp;
  1976.  
  1977.   if (bPasting)
  1978.   {
  1979.     if (OpenClipboard (hwndMain))
  1980.     {
  1981.       SetCursor (LoadCursor (NULL, IDC_WAIT));
  1982.  
  1983.       if (IsClipboardFormatAvailable (CF_DIB))
  1984.       {
  1985.         hDIB = GetClipboardData (CF_DIB);
  1986.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  1987.         lpDIBNew = MergeDIB (lpDIB1, pBih, rcSelection.left, rcSelection.top);
  1988.         GlobalUnlock (hDIB);
  1989.       }
  1990.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  1991.       {
  1992.         hBitmap = GetClipboardData (CF_BITMAP);
  1993.         hPalTemp = GetClipboardData (CF_PALETTE);
  1994.         lpDIBTemp = DDBToDIB (hBitmap, hPalTemp);
  1995.  
  1996.         if (lpDIBTemp)
  1997.         {
  1998.           lpDIBNew = MergeDIB (lpDIB1, lpDIBTemp, rcSelection.left, rcSelection.top);
  1999.           DIBFree (lpDIBTemp);
  2000.         }
  2001.       }
  2002.       else
  2003.       {
  2004.         CloseClipboard ();
  2005.         return;
  2006.       }
  2007.       CloseClipboard ();
  2008.       EraseSelectionBox ();
  2009.       bDrawSelection = FALSE;
  2010.       ProcessNewDIB (lpDIBNew);
  2011.       SetCursor (LoadCursor (NULL, IDC_ARROW));
  2012.     }
  2013.     bPasting = FALSE;
  2014.   }
  2015.   else
  2016.   {
  2017.     if (rcSelection.right - rcSelection.left < 5 || rcSelection.bottom - rcSelection.top < 5)
  2018.     {
  2019.       EraseSelectionBox ();
  2020.       bDrawSelection = FALSE;
  2021.     }
  2022.   }
  2023.   ReleaseCapture ();
  2024. }
  2025.  
  2026. /*************************************************************************
  2027.   Function:  HandleRButtonDown ()
  2028.    Purpose:  Process the WM_RBUTTONDOWN message
  2029.    Returns:  none
  2030. *************************************************************************/
  2031. static void HandleRButtonDown (WPARAM wParam, LPARAM lParam)
  2032. {
  2033.   if (GetCapture () == hwndMain)
  2034.   {
  2035.     EraseSelectionBox ();
  2036.     bDrawSelection = FALSE;
  2037.     bPasting = FALSE;
  2038.     ReleaseCapture ();
  2039.   }
  2040. }
  2041.  
  2042. /*************************************************************************
  2043.   Function:  HandleMouseMove ()
  2044.    Purpose:  Process the WM_MOUSEMOVE message
  2045.    Returns:  none
  2046. *************************************************************************/
  2047. static void HandleMouseMove (WPARAM wParam, LPARAM lParam)
  2048. {
  2049. LONG              lX, lY, ldx, ldy;
  2050.  
  2051.   if (GetCapture () == hwndMain)
  2052.   {
  2053.     EraseSelectionBox ();
  2054.     lX = LOWORD (lParam);
  2055.     lY = HIWORD (lParam);
  2056.  
  2057.     if (lX < 0)
  2058.       lX = 0;
  2059.  
  2060.     if (lY < 0)
  2061.       lY = 0;
  2062.     
  2063.     if (bPasting)
  2064.     {
  2065.       ldx = lX - rcSelection.left;
  2066.       ldy = lY - rcSelection.top;
  2067.       OffsetRect (&rcSelection, (int)ldx, (int)ldy);
  2068.     }
  2069.     else
  2070.     {
  2071.       if (lX > ptAnchor.x)
  2072.       {
  2073.         rcSelection.right = (int)lX;
  2074.         rcSelection.left = ptAnchor.x;
  2075.       }
  2076.       else
  2077.       {
  2078.         rcSelection.left = (int)lX;
  2079.         rcSelection.right = ptAnchor.x;
  2080.       }
  2081.  
  2082.       if (lY > ptAnchor.y)
  2083.       {
  2084.         rcSelection.bottom = (int)lY;
  2085.         rcSelection.top = ptAnchor.y;
  2086.       }
  2087.       else
  2088.       {
  2089.         rcSelection.top = (int)lY;
  2090.         rcSelection.bottom = ptAnchor.y;
  2091.       }
  2092.     }
  2093.     DrawSelectionBox ();
  2094.   }
  2095. }
  2096.  
  2097. /*************************************************************************
  2098.   Function:  HandleCharacter ()
  2099.    Purpose:  Process the WM_CHAR message
  2100.    Returns:  none
  2101. *************************************************************************/
  2102. static void HandleCharacter (WPARAM wParam, LPARAM lParam)
  2103. {
  2104.   if (GetCapture () == hwndMain && wParam == VK_ESCAPE)
  2105.   {
  2106.     EraseSelectionBox ();
  2107.     bDrawSelection = FALSE;
  2108.     bPasting = FALSE;
  2109.     ReleaseCapture ();
  2110.   }
  2111. }
  2112.  
  2113. /*************************************************************************
  2114.   Function:  HandlePasting ()
  2115.    Purpose:  Process the clipdoard paste
  2116.    Returns:  none
  2117. *************************************************************************/
  2118. static void HandlePasting (WPARAM wParam, LPARAM lParam)
  2119. {
  2120. HANDLE            hDIB;
  2121. LPBITMAPINFOHEADER pBih;
  2122. long              lWidth, lHeight;
  2123. HBITMAP           hBitmap;
  2124. BITMAP            bm;
  2125. POINT             ptCursor;
  2126. LPVOID            lpDIBNew;
  2127. HPALETTE          hPalTemp;
  2128.  
  2129.   if (OpenClipboard (hwndMain))
  2130.   {
  2131.     if (lpDIB1)
  2132.     {
  2133.       if (IsClipboardFormatAvailable (CF_DIB))
  2134.       {
  2135.         hDIB = GetClipboardData (CF_DIB);
  2136.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  2137.         lWidth = pBih->biWidth;
  2138.         lHeight = pBih->biHeight;
  2139.         GlobalUnlock (hDIB);
  2140.       }
  2141.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  2142.       {
  2143.         hBitmap = GetClipboardData (CF_BITMAP);
  2144.         GetObject (hBitmap, sizeof (bm), &bm);
  2145.         lWidth = bm.bmWidth;
  2146.         lHeight = bm.bmHeight;
  2147.       }
  2148.       else
  2149.       {
  2150.         CloseClipboard ();
  2151.         return;
  2152.       }
  2153.       GetCursorPos (&ptCursor);
  2154.       ScreenToClient (hwndMain, &ptCursor);
  2155.       rcSelection.left = ptCursor.x;
  2156.       rcSelection.top = ptCursor.y;
  2157.       rcSelection.right = ptCursor.x + (int)lWidth;
  2158.       rcSelection.bottom = ptCursor.y + (int)lHeight;
  2159.       bDrawSelection = TRUE;
  2160.       bPasting = TRUE;
  2161.       DrawSelectionBox ();
  2162.       SetCapture (hwndMain);
  2163.     }
  2164.     else
  2165.     {
  2166.       if (IsClipboardFormatAvailable (CF_DIB))
  2167.       {
  2168.         hDIB = GetClipboardData (CF_DIB);
  2169.         pBih = (LPBITMAPINFOHEADER)GlobalLock (hDIB);
  2170.         lpDIBNew = CopyDIB (pBih);
  2171.         GlobalUnlock (hDIB);
  2172.       }
  2173.       else if (IsClipboardFormatAvailable (CF_BITMAP))
  2174.       {
  2175.         hBitmap = GetClipboardData (CF_BITMAP);
  2176.         hPalTemp = GetClipboardData (CF_PALETTE);
  2177.         lpDIBNew = DDBToDIB (hBitmap, hPalTemp);
  2178.       }
  2179.       else
  2180.       {
  2181.         CloseClipboard ();
  2182.         return;
  2183.       }
  2184.       ProcessNewDIB (lpDIBNew);
  2185.     }
  2186.     CloseClipboard ();
  2187.   }
  2188. }
  2189.  
  2190. /*************************************************************************
  2191.   Function:  HandleCopying ()
  2192.    Purpose:  Process the clipdoard copy
  2193.    Returns:  none
  2194. *************************************************************************/
  2195. static void HandleCopying (WPARAM wParam, LPARAM lParam)
  2196. {
  2197. LPVOID            lpDIBTemp, lpDIB;
  2198. DWORD             dwSize;
  2199. HANDLE            hDIB;
  2200.  
  2201.   if (lpDIB1)
  2202.   {
  2203.     if (OpenClipboard (hwndMain))
  2204.     {
  2205.       if (bDrawSelection)
  2206.       {
  2207.         EraseSelectionBox ();
  2208.         bDrawSelection = FALSE;
  2209.         lpDIBTemp = ClipDIB (lpDIB1, rcSelection.left, rcSelection.top, rcSelection.right - rcSelection.left + 1, rcSelection.bottom - rcSelection.top + 1);
  2210.       }
  2211.       else
  2212.         lpDIBTemp = lpDIB1;
  2213.  
  2214.       if (lpDIBTemp)
  2215.       {
  2216.         dwSize = GetDIBSize (lpDIBTemp);
  2217.         hDIB = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, dwSize);
  2218.         lpDIB = GlobalLock (hDIB);
  2219.  
  2220.         if (lpDIB)
  2221.         {
  2222.           copymem (lpDIB, lpDIBTemp, dwSize);
  2223.           GlobalUnlock (hDIB);
  2224.           EmptyClipboard ();
  2225.           SetClipboardData (CF_DIB, hDIB);
  2226.         }
  2227.         
  2228.         if (bDrawSelection)
  2229.           DIBFree (lpDIBTemp);
  2230.       }
  2231.       CloseClipboard ();
  2232.     }
  2233.   }
  2234. }
  2235.  
  2236. /*************************************************************************
  2237.   Function:  HandleZoomin ()
  2238.    Purpose:  Process the zoomin procedure
  2239.    Returns:  none
  2240. *************************************************************************/
  2241. static void HandleZoomin (WPARAM wParam, LPARAM lParam)
  2242. {
  2243. LPVOID            lpDIBTemp, lpDIBNew;
  2244.  
  2245.   if (lpDIB1 && bDrawSelection)
  2246.   {
  2247.     SetCursor (LoadCursor (NULL, IDC_WAIT));
  2248.     EraseSelectionBox ();
  2249.     bDrawSelection = FALSE;
  2250.     lpDIBTemp = ClipDIB (lpDIB1, rcSelection.left, rcSelection.top, rcSelection.right - rcSelection.left + 1, rcSelection.bottom - rcSelection.top + 1);
  2251.  
  2252.     if (lpDIBTemp)
  2253.     {
  2254.       lpDIBNew = ZoomDIB (lpDIBTemp, 500, 500);
  2255.       DIBFree (lpDIBTemp);
  2256.       
  2257.       if (lpDIBNew)
  2258.         ProcessNewDIB (lpDIBNew);
  2259.     }
  2260.     SetCursor (LoadCursor (NULL, IDC_ARROW));
  2261.   }
  2262. }
  2263.  
  2264. /*************************************************************************
  2265.   Function:  DrawSelectionBox ()
  2266.    Purpose:  Draw the selection
  2267.    Returns:  none
  2268. *************************************************************************/
  2269. static void DrawSelectionBox (void)
  2270. {
  2271. HDC               hDC;
  2272.   
  2273.   UpdateWindow (hwndMain);
  2274.   hDC = GetDC (hwndMain);
  2275.  
  2276.   if (hDC)
  2277.   {
  2278.     SetROP2 (hDC, R2_XORPEN);
  2279.     SelectObject (hDC, GetStockObject (WHITE_PEN));
  2280.     SelectObject (hDC, GetStockObject (HOLLOW_BRUSH));
  2281.     Rectangle (hDC, rcSelection.left, rcSelection.top, rcSelection.right, rcSelection.bottom);
  2282.     ReleaseDC (hwndMain, hDC);
  2283.   }
  2284. }
  2285.  
  2286. /*************************************************************************
  2287.   Function:  EraseSelectionBox ()
  2288.    Purpose:  Erase the selection
  2289.    Returns:  none
  2290. *************************************************************************/
  2291. static void EraseSelectionBox (void)
  2292. {
  2293.   if (bDrawSelection)
  2294.     DrawSelectionBox ();
  2295. }
  2296.  
  2297. /*************************************************************************
  2298.   Function:  ProcessNewDIB ()
  2299.    Purpose:  Set up to display a newly loaded/created DIB
  2300.    Returns:  none
  2301. *************************************************************************/
  2302. static void       ProcessNewDIB (LPVOID lpDIBNew)
  2303. {
  2304.   if (lpDIBNew && lpDIBNew != lpDIB1)
  2305.   {
  2306.     if (lpDIBDisplay && lpDIBDisplay != lpDIB1)
  2307.       DIBFree (lpDIBDisplay);
  2308.  
  2309.     if (lpDIB2)
  2310.       DIBFree (lpDIB2);
  2311.  
  2312.     lpDIB2 = lpDIB1;
  2313.     lpDIB1 = lpDIBNew;
  2314.  
  2315.     if (hPalette)
  2316.     {
  2317.       DeleteObject (hPalette);
  2318.       hPalette = NULL;
  2319.     }
  2320.     lpDIBDisplay = CreateDisplayDIB (hwndMain, &lpDIB1, &hPalette);
  2321.  
  2322.     if (lpDIBDisplay)
  2323.       ResizeWindowToDIB (hwndMain, lpDIBDisplay);
  2324.   }
  2325. }
  2326.  
  2327. /*************************************************************************
  2328.   Function:  HandlePaintingAndUpdates ()
  2329.    Purpose:  Process image painting and palette management
  2330.    Returns:  none
  2331. *************************************************************************/
  2332. static LRESULT HandlePaintingAndUpdates (UINT message, WPARAM wParam, LPARAM lParam)
  2333. {
  2334. RECT              rcClient;
  2335. HPALETTE          hPalOld;
  2336. HDC               hDC;
  2337. int               iCount, iXPos, iYPos, iYStart;
  2338. PAINTSTRUCT       PaintStruct;
  2339. HPSTR             hpBits;
  2340. LPBITMAPINFO      pBitmapInfo;
  2341.  
  2342.   switch (message)
  2343.   {
  2344.     case WM_QUERYNEWPALETTE:
  2345.  
  2346.     /*
  2347.      * If palette realization causes a palette change,
  2348.      * we need to do a full redraw.
  2349.      */
  2350.     if (hPalette && wParam != (UINT)hwndMain)
  2351.     {
  2352.       hDC = GetDC (hwndMain);
  2353.       hPalOld = SelectPalette (hDC, hPalette, FALSE);
  2354.       iCount = RealizePalette (hDC);
  2355.       InvalidateRect (hwndMain, (LPRECT) (NULL), FALSE);
  2356.       UpdateWindow (hwndMain);
  2357.       SelectPalette (hDC, hPalOld, 0);
  2358.       ReleaseDC (hwndMain, hDC);
  2359.       return TRUE;
  2360.     }
  2361.     break;
  2362.  
  2363.     case WM_PALETTECHANGED:
  2364.  
  2365.       if (hPalette && wParam != (UINT)hwndMain)
  2366.         InvalidateRect (hwndMain, (LPRECT) (NULL), FALSE);
  2367.  
  2368.       break;
  2369.  
  2370.     case WM_PAINT:
  2371.       
  2372.       hDC = BeginPaint (hwndMain, &PaintStruct);
  2373.  
  2374.       if (lpDIBDisplay)
  2375.       {
  2376.         if (hPalette)
  2377.         {
  2378.           hPalOld = SelectPalette (hDC, hPalette, FALSE);
  2379.           RealizePalette (hDC);
  2380.         }
  2381.  
  2382.         GetClientRect (hwndMain, &rcClient);
  2383.         iXPos = GetScrollPos (hwndMain, SB_HORZ);
  2384.         iYPos = GetScrollPos (hwndMain, SB_VERT);
  2385.         pBitmapInfo = (LPBITMAPINFO) lpDIBDisplay;
  2386. #ifdef USE_WING
  2387.         if (hWinGInst && hbmpWinG)
  2388.         {
  2389.           fpWinGStretchBlt (hDC, 0, 0, rcClient.right, rcClient.bottom, hdcWinG, iXPos, iYPos,
  2390.                             rcClient.right, rcClient.bottom);
  2391.         }
  2392.         else
  2393. #endif
  2394.         {
  2395.           iYStart = (int)pBitmapInfo->bmiHeader.biHeight - rcClient.bottom - iYPos;
  2396.           hpBits = (HPSTR)&pBitmapInfo->bmiColors[pBitmapInfo->bmiHeader.biClrUsed];
  2397.           StretchDIBits (hDC, 0, 0, rcClient.right, rcClient.bottom, iXPos, iYStart,
  2398.                          rcClient.right, rcClient.bottom, hpBits, pBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
  2399.         }
  2400.         if (hPalette)
  2401.           SelectPalette (hDC, hPalOld, FALSE);
  2402.       }
  2403.  
  2404.       if (bDrawSelection)
  2405.         DrawSelectionBox ();
  2406.  
  2407.       EndPaint (hwndMain, &PaintStruct);
  2408.       break;
  2409.   }
  2410.   return (0);
  2411. }
  2412.  
  2413. #ifdef USE_WING
  2414.  
  2415. /*************************************************************************
  2416.   Function:  InitializeWinG ()
  2417.    Purpose:  Initializes WinG
  2418.    Returns:  none
  2419. *************************************************************************/
  2420. static void InitializeWinG ()
  2421. {
  2422.   fpWinGCreateDC = (WINGCREATEDC) GetProcAddress (hWinGInst, "WinGCreateDC");
  2423.   fpWinGCreateBitmap = (WINGCREATEBITMAP) GetProcAddress (hWinGInst, "WinGCreateBitmap");
  2424.   fpWinGStretchBlt = (WINGSTRETCHBLT) GetProcAddress (hWinGInst, "WinGStretchBlt");
  2425.   hdcWinG = fpWinGCreateDC ();
  2426. }
  2427.  
  2428. /*************************************************************************
  2429.   Function:  UpdateWinGBitmap ()
  2430.    Purpose:  Updates WinG bitmap used to draw DIBs
  2431.    Returns:  none
  2432. *************************************************************************/
  2433. static void UpdateWinGBitmap (LPVOID lpDIB)
  2434. {
  2435. LPBITMAPINFO      pBiDIB = (LPBITMAPINFO) lpDIB;
  2436. HPALETTE          hpalTemp, hpalOld;
  2437. HPSTR             hpBits;
  2438.  
  2439.   if (hbmpWinG)
  2440.   {
  2441.     SelectObject (hdcWinG, hbmpWinGOld);
  2442.     DeleteObject (hbmpWinG);
  2443.   }
  2444.  
  2445.   /*
  2446.    * Create a new bitmap and put it in WinG DC for quick repaints.  WinG
  2447.    * deals with 8-bit-per-pixel bitmaps only.
  2448.    */
  2449.   hbmpWinG = fpWinGCreateBitmap (hdcWinG, pBiDIB, NULL);
  2450.   
  2451.   if (hbmpWinG)
  2452.   {
  2453.     hbmpWinGOld = SelectObject (hdcWinG, hbmpWinG);
  2454.     hpalTemp = CreateDIBPalette (lpDIB);
  2455.     hpalOld = SelectPalette (hdcWinG, hpalTemp, FALSE);
  2456.     RealizePalette (hdcWinG);
  2457.     hpBits = (HPSTR)&pBiDIB->bmiColors[pBiDIB->bmiHeader.biClrUsed];
  2458.     StretchDIBits (hdcWinG, 0, 0, (int)pBiDIB->bmiHeader.biWidth, (int)pBiDIB->bmiHeader.biHeight, 0, 0,
  2459.                    (int)pBiDIB->bmiHeader.biWidth, (int)pBiDIB->bmiHeader.biHeight, hpBits, pBiDIB, DIB_RGB_COLORS, SRCCOPY);
  2460.     SelectPalette (hdcWinG, hpalOld, FALSE);
  2461.     DeleteObject (hpalTemp);
  2462.   }
  2463. }
  2464.  
  2465. #endif
  2466.