home *** CD-ROM | disk | FTP | other *** search
/ swCHIP 1991 January / swCHIP_95-1.bin / utility / gsview13 / src / gvpm.c < prev    next >
C/C++ Source or Header  |  1995-12-09  |  59KB  |  1,967 lines
  1. /* Copyright (C) 1993, 1994, 1995, Russell Lang.  All rights reserved.
  2.   
  3.   This file is part of GSview.
  4.   
  5.   This program is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the GSview Free Public Licence 
  9.   (the "Licence") for full details.
  10.   
  11.   Every copy of GSview must include a copy of the Licence, normally in a 
  12.   plain ASCII text file named LICENCE.  The Licence grants you the right 
  13.   to copy, modify and redistribute GSview, but only under certain conditions 
  14.   described in the Licence.  Among other things, the Licence requires that 
  15.   the copyright notice and this notice be preserved on all copies.
  16. */
  17.  
  18. /* gvpm.c */
  19. /* Main routines for PM GSview */
  20. #define INCL_WINSTDDRAG
  21. #include "gvpm.h"
  22. #ifdef __EMX__
  23. #include "sys/ioctl.h"
  24. #endif
  25. #include "gvphelp.h"   /* generated by doc2ipf.c */
  26.  
  27.  
  28. char szAppName[MAXSTR] = "PM GSview";
  29. char szHelpTopic[MAXSTR];
  30. char szWait[MAXSTR];
  31. char szExePath[MAXSTR];
  32. char szHelpFile[MAXSTR];
  33. char szFindText[MAXSTR];
  34. char szIniFile[MAXSTR];
  35. char szMMini[MAXSTR];
  36. char previous_filename[MAXSTR];
  37. const char szScratch[] = "gv";    /* temporary filename prefix */
  38. HAB hab;        /* Anchor Block */
  39. HELPINIT hi_help;
  40. ULONG os_version;
  41. HWND hwnd_frame;
  42. HWND hwnd_bmp;
  43. HWND hwnd_status;
  44. HWND hwnd_button;
  45. HWND hwnd_help;
  46. HWND hwnd_modeless;    /* any modeless dialog box */
  47. HWND hptr_crosshair;
  48. HACCEL haccel;
  49. POINTL buttonbar;
  50. POINTL statusbar;
  51. POINTL info_file;
  52. POINTL info_page;
  53. POINTL scroll_pos;
  54. RECTL info_coord;
  55. BOOL waiting;
  56. TID queue_tid;
  57. TID term_tid;
  58. #define SB_TOP 20
  59. #define SB_BOTTOM 21
  60. GVIEW gsview;        /* GSview structure */
  61. PSFILE psfile;        /* Postscript file structure */
  62. BMAP bitmap;        /* Bitmap structure */
  63. PROG gsprog;        /* Ghostscript program structure */
  64. PROG pdfconv;        /* Ghostscript running PDF converter */
  65. OPTIONS option;        /* GSview options (saved in INI file) */
  66. DISPLAY display;    /* Display parameters */
  67. PRINTER printer;    /* Printer GS parameters */
  68. PSDOC *doc;
  69.  
  70. int page_extra;            /* extra pages to skip */
  71. int page_skip = 5;        /* number of pages to skip in IDM_NEXTSKIP or IDM_PREVSKIP */
  72. BOOL changed_version = FALSE;    /* to warn user to update Ghostscript Command */
  73. BOOL zoom = FALSE;        /* true if display zoomed */
  74. BOOL debug = FALSE;        /* /D command line option used */
  75. struct page_list_s page_list;
  76. struct sound_s sound[NUMSOUND] = {
  77.     {"SoundOutputPage", IDS_SNDPAGE, ""},
  78.     {"SoundNoPage", IDS_SNDNOPAGE, BEEP},
  79.     {"SoundNoNumbering", IDS_SNDNONUMBER, ""},
  80.     {"SoundNotOpen", IDS_SNDNOTOPEN, ""},
  81.     {"SoundError", IDS_SNDERROR, BEEP},
  82.     {"SoundTimeout", IDS_SNDTIMEOUT, ""},
  83.     {"SoundStart", IDS_SNDSTART, ""},
  84.     {"SoundExit", IDS_SNDEXIT, ""},
  85. };
  86. PFN_MciPlayFile pfnMciPlayFile;
  87.  
  88. /* button bar */
  89. struct button *buttonhead, *buttontail;
  90. BOOL button_down;
  91. struct button *button_current;
  92. struct button *button_info;
  93. POINTL button_shift;
  94. POINTL button_size;
  95.  
  96. MRESULT EXPENTRY ClientWndProc(HWND, ULONG, MPARAM, MPARAM);
  97. MRESULT EXPENTRY FrameWndProc(HWND, ULONG, MPARAM, MPARAM);
  98. MRESULT EXPENTRY StatusWndProc(HWND, ULONG, MPARAM, MPARAM);
  99. MRESULT EXPENTRY ButtonWndProc(HWND, ULONG, MPARAM, MPARAM);
  100. PFNWP OldFrameWndProc;
  101.  
  102. BOOL scan_bitmap(BMAP *pbm);
  103. HBITMAP make_bitmap(BMAP *, ULONG, ULONG, ULONG, ULONG, ULONG);
  104. void cursorpos_paint(HPS hps);
  105. void map_pt_to_pixel(float *x, float *y);
  106. MRESULT DragOver(PDRAGINFO);
  107. MRESULT Drop(PDRAGINFO);
  108.  
  109. void
  110. update_scroll_bars(void)
  111. {
  112.     /* Cause update of scroll bars etc. */
  113.     SWP swp;
  114.     WinQueryWindowPos(hwnd_bmp, &swp);
  115.     WinSendMsg(hwnd_bmp, WM_SIZE, MPFROM2SHORT(swp.cx, swp.cy), MPFROM2SHORT(swp.cx, swp.cy));
  116. }
  117.  
  118. /* temporary until status line created */
  119. void
  120. update_title(void)
  121. {
  122. char buf[256];
  123. char *state;
  124. char page[256];
  125. char *progname = "PM GSview";
  126.     if (display.page)
  127.         state = "PAGE";
  128.     else if (display.sync)
  129.         state = "SYNC";
  130.     else
  131.         state = "OTHER";
  132.  
  133.     if (psfile.name[0]) {
  134.         if (doc != (PSDOC *)NULL) {
  135.         int n = map_page(psfile.pagenum - 1);
  136.         if (doc->pages)
  137.             sprintf(page, "'%s' %d of %d", doc->pages[n].label ? doc->pages[n].label : " ",psfile.pagenum,  doc->numpages);
  138.         else
  139.             sprintf(page, "'' %d of %d", psfile.pagenum, doc->numpages);
  140.     
  141.             sprintf(buf, "%s - %s - %s - %s", progname,
  142.             psfile.name, page, state);
  143.         }
  144.         else {
  145.         sprintf(buf, "%s - %s - %d -%s", progname,
  146.             psfile.name, psfile.pagenum, state);
  147.         }
  148.     }
  149.     else {
  150.         sprintf(buf, "%s - No File", progname);
  151.     }
  152.     WinSetWindowText(hwnd_frame, buf);
  153. }
  154.  
  155. /* display thread */
  156. /* abort if display.abort TRUE */
  157. void 
  158. display_thread(void *arg)
  159. {
  160.     do_output();
  161. /* avoid bug in gs 2.9.4 */
  162. {int i;
  163. for (i=0; i<80; i++)
  164.     fputs("\r\n",gsprog.input);
  165. } 
  166.     fflush(gsprog.input);
  167.     dfclose();
  168.     display.busy = FALSE;
  169.     display.abort = FALSE;
  170.     display.do_endfile = FALSE;
  171.     display.do_resize = FALSE;
  172.     display.do_display = FALSE;
  173.     if (!gsprog.valid) {
  174. /*        WinPostMsg(hwnd_bmp, WM_GSCLOSE, MPFROMLONG(0), MPFROMLONG(0)); */
  175.         gs_close();
  176.     }
  177.     DosPostEventSem(display.done);
  178. }
  179.  
  180. #ifdef NOTUSED
  181. /* not used */
  182. /* copy psfile.file to GS */
  183. /* abort copy if display.abort TRUE */
  184. void 
  185. copy_thread(void *arg)
  186. {
  187. #define COPY_BUF_SIZE 4096
  188. char *buffer;
  189. int count;
  190.     if ((buffer = malloc(COPY_BUF_SIZE)) != (char *)NULL) {
  191.         while ( !display.abort &&
  192.         (count = fread(buffer, 1, COPY_BUF_SIZE, psfile.file)) != 0 )
  193.             fwrite(buffer, 1, count, gsprog.input);
  194.         free(buffer);
  195.     }
  196.     fclose(psfile.file);
  197. /*    fputs("quit\n", gsprog.input); */
  198.     fflush(gsprog.input);
  199.     display.busy = FALSE;
  200.     display.abort = FALSE;
  201.     DosPostEventSem(display.done);
  202. }
  203. #endif
  204.  
  205.  
  206. /* Queue thread */
  207. /* This thread waits for queue messages from gsos2.exe */
  208. /* This thread must NOT call C library functions */
  209. VOID APIENTRY queue_thread(ULONG unused)
  210. {
  211.     REQUESTDATA Request;
  212.     ULONG DataLength;
  213.     PVOID DataAddress;
  214.     BYTE ElemPriority;
  215.     unused = unused;    /* to shut up warning */
  216.     while ( !DosReadQueue(gsview.queue, &Request, &DataLength, &DataAddress, 
  217.             0, DCWW_WAIT, &ElemPriority, (HEV)NULL) ) {
  218.         switch(Request.ulData) {
  219.         case GS_UPDATING:
  220.                 WinPostMsg(hwnd_bmp, WM_GSUPDATING, MPFROMLONG(0), MPFROMLONG(0));
  221.             break;
  222.         case GS_SYNC:
  223.                 WinPostMsg(hwnd_bmp, WM_GSSYNC, MPFROMLONG(0), MPFROMLONG(0));
  224.             break;
  225.         case GS_PAGE:
  226.                 WinPostMsg(hwnd_bmp, WM_GSPAGE, MPFROMLONG(0), MPFROMLONG(0));
  227.             break;
  228.         case GS_CLOSE:
  229.                 WinPostMsg(hwnd_bmp, WM_GSCLOSE, MPFROMLONG(0), MPFROMLONG(0));
  230.             break;
  231.         case GS_ERROR:
  232.                 WinPostMsg(hwnd_bmp, WM_GSERROR, MPFROMLONG(0), MPFROMLONG(0));
  233.             break;
  234.         case GS_PALCHANGE:
  235.                 WinPostMsg(hwnd_bmp, WM_GSPALCHANGE, MPFROMLONG(0), MPFROMLONG(0));
  236.             break;
  237.         case GS_BEGIN:
  238.                 WinPostMsg(hwnd_bmp, WM_GSBEGIN, MPFROMLONG(0), MPFROMLONG(0));
  239.             break;
  240.         case GS_END:
  241.                 WinPostMsg(hwnd_bmp, WM_GSEND, MPFROMLONG(0), MPFROMLONG(0));
  242.             break;
  243.         }
  244.     }
  245. }
  246.  
  247. /* termination queue thread */
  248. /* This thread waits for termination messages */
  249. /* This thread must NOT call C library functions */
  250. VOID APIENTRY term_thread(ULONG unused)
  251. {
  252.     REQUESTDATA Request;
  253.     ULONG DataLength;
  254.     PVOID DataAddress;
  255.     BYTE ElemPriority;
  256.     WORD *pword;
  257.     unused = unused;    /* to shut up warning */
  258.     while ( !DosReadQueue(gsview.term_queue, &Request, &DataLength, &DataAddress, 
  259.             0, DCWW_WAIT, &ElemPriority, (HEV)NULL) ) {
  260.         pword = DataAddress;
  261.         /* should really build a list of programs and search the list */
  262.         if (*pword == gsprog.session_id) {
  263.             WinPostMsg(hwnd_bmp, WM_GSCLOSE, MPFROMLONG(0), MPFROMSHORT(pword[1]));
  264.         }
  265.         else if (*pword == printer.prog.session_id) {
  266.         WinPostMsg(hwnd_bmp, WM_GSPRNEXIT, MPFROMP(&printer), MPFROMSHORT(pword[1]));
  267.         }
  268.         DosFreeMem(DataAddress);
  269.     }
  270.     term_tid = 0;
  271. }
  272.  
  273. void
  274. exit_func(void)
  275. {
  276.     DosCloseEventSem(gsview.next_event);
  277.     DosCloseMutexSem(gsview.bmp_mutex);
  278.     DosCloseQueue(gsview.queue);
  279.     if (bitmap.pbmi)
  280.         DosFreeMem((PVOID)bitmap.pbmi);
  281.     if (gsprog.valid) {
  282.         stop_pgm(&gsprog);
  283.     }
  284.     if (printer.prog.valid) {
  285.         /* clean up after printer */
  286.         stop_pgm(&printer.prog);
  287.         if ((printer.cfname[0] != '\0') && !debug)
  288.             unlink(printer.cfname);
  289.         printer.cfname[0] = '\0';
  290.         if ((printer.fname[0] != '\0') && !debug)
  291.             unlink(printer.fname);
  292.         printer.fname[0] = '\0';
  293.     }
  294.     if (psfile.ispdf && psfile.name[0] && psfile.pdftemp[0])
  295.         unlink(psfile.pdftemp);  /* remove temporary DSC file */
  296.     if (option.settings)
  297.         write_profile();
  298.     DosCloseQueue(gsview.term_queue);
  299. }
  300.  
  301. int
  302. main(int argc, char *argv[])
  303. {
  304.   HMQ hand_mq;        /* message queue */
  305.   QMSG q_mess;        /* queue message */
  306.   ULONG flFlags;    /* Window frame definition */
  307.   APIRET rc = 0;
  308.   SWP swp;
  309.  
  310.   hab = WinInitialize(0);    /* Get the Anchor Block */
  311.  
  312.   hand_mq = WinCreateMsgQueue(hab, 0); /* start a queue */
  313.  
  314.   if (argc > 4) {
  315.     rc = 1;
  316.     error_message("Usage: gvpm [/D] [/F] [/P] [/S[port]] [filename]");
  317.   }
  318.  
  319.   rc = gsview_init(argc, argv);
  320.  
  321.   atexit(exit_func);
  322.  
  323.   if (!rc) {
  324.         WinShowWindow(hwnd_frame, TRUE);
  325.     haccel = WinQueryAccelTable(hab, hwnd_frame);
  326.     /* create help window */
  327.     hi_help.cb = sizeof(HELPINIT);
  328.     hi_help.ulReturnCode = 0;
  329.     hi_help.pszTutorialName = NULL;
  330.     hi_help.phtHelpTable = NULL;
  331.     hi_help.hmodAccelActionBarModule = 0;
  332.     hi_help.idAccelTable = 0;
  333.     hi_help.idActionBar = 0;
  334.     hi_help.pszHelpWindowTitle=(PSZ)"PM GSview Help";
  335.     hi_help.hmodHelpTableModule = 0;
  336.     hi_help.fShowPanelId = 0;
  337.     hi_help.pszHelpLibraryName = (PSZ)szHelpFile;
  338.     hwnd_help = WinCreateHelpInstance(hab, &hi_help);
  339.     if (!hwnd_help)
  340.         message_box("main: help not available", 0);
  341.     else
  342.         if (hi_help.ulReturnCode)
  343.         message_box("main: help terminated due to error", 0);
  344.     if (hwnd_help)
  345.         WinAssociateHelpInstance(hwnd_help, hwnd_frame);
  346.   }
  347.  
  348.   play_sound(SOUND_START);
  349.   /* message loop */
  350.   while (!rc && WinGetMsg(hab, &q_mess, 0L, 0, 0))
  351.       WinDispatchMsg(hab, &q_mess);
  352.  
  353.   play_sound(SOUND_EXIT);
  354.   /* Shut down the application window and queue */
  355.   DosKillThread(queue_tid);
  356.   DosKillThread(term_tid);
  357.   term_tid = 0;
  358.   if (hwnd_help)
  359.       WinDestroyHelpInstance(hwnd_help);
  360.   WinDestroyWindow(hwnd_frame);
  361.   WinDestroyMsgQueue(hand_mq);
  362.   WinTerminate(hab);
  363.   return rc;
  364. }
  365.  
  366. #define MAX_PAL_SIZE 256
  367. void
  368. make_palette(BMAP *pbm)
  369. {
  370. ULONG tbl[MAX_PAL_SIZE];
  371. PRGB2 palptr = (PRGB2) ((PBYTE)(pbm->pbmi) + pbm->pbmi->cbFix);
  372. RGB *old_palptr = (RGB *)palptr;
  373. int palcount = pbm->palimportant;
  374. int i;
  375. BOOL old_bmp = (pbm->pbmi->cbFix == sizeof(BITMAPINFOHEADER));
  376.     if (old_bmp) {
  377.     for (i=0; i<palcount; i++) {
  378.         tbl[i] = (old_palptr->bRed<<16) + (old_palptr->bGreen<<8) + (old_palptr->bBlue);
  379.         palptr++;
  380.     }
  381.     }
  382.     else {
  383.     for (i=0; i<palcount; i++) {
  384.         tbl[i] = (palptr->bRed<<16) + (palptr->bGreen<<8) + (palptr->bBlue);
  385.         palptr++;
  386.     }
  387.     }
  388.     if (display.hpal_exists)
  389.     GpiDeletePalette(display.hpal);
  390.     display.hpal = GpiCreatePalette(hab, 0L, LCOLF_CONSECRGB, palcount, tbl);
  391.     display.hpal_exists = TRUE;
  392. }
  393.  
  394.  
  395. /* scan bitmap */
  396. /* update bitmap structure */
  397. /* return value is TRUE if bitmap dimension has changed */
  398. BOOL
  399. scan_bitmap(BMAP *pbm)
  400. {
  401. PBITMAPINFO2 pbmi = pbm->pbmi;
  402. PBITMAPINFO old_pbmi = (PBITMAPINFO)pbmi;
  403. BOOL old_bmp = (pbmi->cbFix == sizeof(BITMAPINFOHEADER));
  404.  
  405.    if (old_bmp) {
  406.       /* it is a BITMAPINFO */
  407.       switch(old_pbmi->cBitCount) {
  408.         case 24:
  409.           pbm->palsize = 0;
  410.           break;
  411.         case 8:
  412.           pbm->palsize = 256;
  413.           break;
  414.         case 4:
  415.           pbm->palsize = 16;
  416.           break;
  417.         case 1:
  418.           pbm->palsize = 2;
  419.           break;
  420.         default:
  421.         pbm->valid = FALSE;
  422.           error_message("scan_bitmap: wrong number of bits"); /* panic */
  423.           return FALSE;
  424.     }
  425.     pbm->palimportant = pbm->palsize;
  426.     pbm->palsize = pbm->palsize * sizeof(RGB);
  427.         pbm->bits   = (PBYTE)old_pbmi + old_pbmi->cbFix + pbm->palsize;
  428.     pbm->width  = old_pbmi->cx;
  429.     pbm->height = old_pbmi->cy;
  430.     pbm->planes = old_pbmi->cPlanes;
  431.     pbm->depth  = old_pbmi->cBitCount;
  432.     }
  433.     else {
  434.      /* it is a BITMAPINFO2 */
  435.       switch(pbmi->cBitCount) {
  436.         case 24:
  437.           pbm->palsize = 0;
  438.           break;
  439.         case 8:
  440.           pbm->palsize = 256;
  441.           break;
  442.         case 4:
  443.           pbm->palsize = 16;
  444.           break;
  445.         case 1:
  446.           pbm->palsize = 2;
  447.           break;
  448.         default:
  449.         pbm->valid = FALSE;
  450.           error_message("scan_bitmap: wrong number of bits"); /* panic */
  451.           return FALSE;
  452.     }
  453.     if ( (pbmi->cbFix > (&(pbmi->cclrUsed) - &(pbmi->cbFix)))
  454.         && (pbmi->cclrUsed != 0) && (pbmi->cBitCount != 24) )
  455.         pbm->palsize = pbmi->cclrUsed;
  456.     pbm->palimportant = pbm->palsize;
  457.     if ( (pbmi->cbFix > (&(pbmi->cclrImportant) - &(pbmi->cbFix)))
  458.         && (pbmi->cclrImportant != 0) && (pbmi->cBitCount != 24) )
  459.         pbm->palimportant = pbmi->cclrImportant;
  460.     pbm->palsize = pbm->palsize * sizeof(RGB2);
  461.         pbm->bits   = (PBYTE)pbmi + pbmi->cbFix + pbm->palsize;
  462.     pbm->width  = pbmi->cx;
  463.     pbm->height = pbmi->cy;
  464.     pbm->planes = pbmi->cPlanes;
  465.     pbm->depth  = pbmi->cBitCount;
  466.     }
  467.  
  468.     if ((pbm->palsize != pbm->old_palsize) || (pbm->palimportant != pbm->old_palimportant)) {
  469.     if ( (pbm->depth == 8) && display.hasPalMan )
  470.         make_palette(pbm);
  471.     pbm->old_palimportant = pbm->palimportant;
  472.     }
  473.  
  474.     if ( (pbm->width   == pbm->old_width) && 
  475.          (pbm->height  == pbm->old_height) &&
  476.      (pbm->planes  == pbm->old_planes) && 
  477.      (pbm->depth   == pbm->old_depth) &&
  478.      (pbm->palsize == pbm->old_palsize) &&
  479.      (pbm->old_bmp == old_bmp) )
  480.     return FALSE;
  481.  
  482.     /* bitmap has changed */
  483.     pbm->old_width   = pbm->width;
  484.     pbm->old_height  = pbm->height;
  485.     pbm->old_planes  = pbm->planes;
  486.     pbm->old_depth   = pbm->depth;
  487.     pbm->old_palsize = pbm->palsize;
  488.     pbm->old_bmp     = old_bmp;
  489.     return TRUE;
  490. }
  491.  
  492. /* copy bitmap to the clipboard */
  493. void
  494. copy_clipboard(void)
  495. {
  496. HBITMAP hbmp;
  497.     if (!bitmap.valid) {
  498.     gserror(0, "Cannot copy to clipboard:\nNo Bitmap displayed", MB_ICONEXCLAMATION, SOUND_ERROR);
  499.     return;
  500.     }
  501.     if (WinOpenClipbrd(hab)) {
  502.     /* get bmp mutex to stop gs.exe changing bitmap while we copy it */
  503.     if (DosRequestMutexSem(gsview.bmp_mutex, 10000) == ERROR_TIMEOUT)
  504.         message_box("copy_clipboard: mutex timeout", 0);
  505.     if (scan_bitmap(&bitmap)) {
  506.         /* bitmap has changed */
  507.         update_scroll_bars();
  508.     }
  509.     hbmp = make_bitmap(&bitmap, 0, 0, bitmap.width, bitmap.height, bitmap.depth);
  510.     if (hbmp) {
  511.         WinEmptyClipbrd(hab);
  512.         WinSetClipbrdData(hab, (ULONG)hbmp, CF_BITMAP, CFI_HANDLE);
  513.     }
  514.     
  515.     DosReleaseMutexSem(gsview.bmp_mutex);
  516.     WinCloseClipbrd(hab);
  517.     }
  518. }
  519.  
  520. HBITMAP
  521. make_bitmap(BMAP *pbm, ULONG left, ULONG bottom, ULONG right, ULONG top, ULONG depth)
  522. {
  523. HDC hdcMem = DEV_ERROR;
  524. HPS hps = GPI_ERROR;
  525. HBITMAP hbmp = GPI_ERROR, hbmr = HBM_ERROR;
  526. SIZEL sizePS;
  527. BITMAPINFOHEADER2 bmih;
  528.  
  529.     if ( (left == right) || (bottom == top) )
  530.         return (HBITMAP)NULL;
  531.  
  532.     if (right > pbm->width)
  533.         right = pbm->width;
  534.     if (left > pbm->width)
  535.         left = 0;
  536.     if (top > pbm->height)
  537.         top = pbm->height;
  538.     if (bottom > pbm->height)
  539.         bottom = 0;
  540.         
  541.     memset(&bmih, 0, sizeof(bmih));
  542.     bmih.cbFix = sizeof(BITMAPINFOHEADER2);
  543.     bmih.cx = right - left;
  544.     bmih.cy = top - bottom;
  545.     bmih.cPlanes = 1;
  546.     bmih.cBitCount = depth;
  547.  
  548.     /* create memory DC compatible with screen */
  549.     hdcMem = DevOpenDC(hab, OD_MEMORY, "*", 0L, NULL, NULLHANDLE);
  550.  
  551.     sizePS.cx = right - left;
  552.     sizePS.cy = top - bottom;
  553.     if (hdcMem != DEV_ERROR)
  554.         hps = GpiCreatePS(hab, hdcMem, &sizePS, 
  555.         PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC );
  556.  
  557.     if (hps != GPI_ERROR)
  558.         hbmp = GpiCreateBitmap(hps, &bmih, 0L, NULL, NULL);
  559.  
  560.     if (hbmp != GPI_ERROR)
  561.         hbmr = GpiSetBitmap(hps, hbmp);
  562.  
  563.  
  564.     if (hbmr != HBM_ERROR) {
  565.         LONG rc;
  566.         ERRORID eid;
  567.               POINTL apts[4];
  568.         /* target is inclusive */
  569.         apts[0].x = 0;
  570.         apts[0].y = 0;
  571.         apts[1].x = right - left - 1;
  572.         apts[1].y = top - bottom - 1;
  573.         /* source is not inclusive of top & right borders */
  574.         apts[2].x = left;
  575.         apts[2].y = bottom;
  576.         apts[3].x = right;
  577.         apts[3].y = top;
  578.  
  579.         rc = 0;
  580.         eid = WinGetLastError(hab);
  581.             rc = GpiDrawBits(hps, pbm->bits, pbm->pbmi, 4, apts, 
  582.             (bitmap.depth != 1) ? ROP_SRCCOPY : ROP_NOTSRCCOPY, 0);
  583.         if (rc==0) {
  584.             char buf[256];
  585.             eid = WinGetLastError(hab);
  586.             sprintf(buf,"make_bitmap: GpiDrawBits rc = %08x, eid = %08x",rc, eid);
  587.             message_box(buf, 0);
  588.         }
  589.     }
  590.     
  591.     if (hbmr != HBM_ERROR)
  592.         GpiSetBitmap(hps, (ULONG)0);
  593.     if (hps != GPI_ERROR)
  594.         GpiDestroyPS(hps);
  595.     if (hdcMem != DEV_ERROR)
  596.         DevCloseDC(hdcMem);
  597.  
  598.     if ( (hbmr == HBM_ERROR) || (hdcMem == DEV_ERROR) ||
  599.         (hbmp == GPI_ERROR) || (hps == GPI_ERROR) ) {
  600.         if (hbmp != GPI_ERROR)
  601.             GpiDeleteBitmap(hbmp);
  602.         return 0;
  603.     }
  604.     return hbmp;
  605. }
  606.  
  607. MRESULT
  608. paint_bitmap(HPS ps, PRECTL prect, int scrollx, int scrolly)
  609. {
  610.     POINTL apts[4];
  611.     RECTL rect;
  612.     int wx, wy;
  613.     int ewx = 0;    /* empty area at right */
  614.     int ewy = 0;    /* empty area at top */
  615.     if (WinIsRectEmpty(hab, prect))
  616.     return 0;
  617.     /* source is not inclusive of top & right borders */
  618.     wx = prect->xRight - prect->xLeft;   /* update width */
  619.     wy = prect->yTop -   prect->yBottom; /* update height */
  620.     if (prect->xLeft < display.offset.x)
  621.     apts[2].x = 0;
  622.     else
  623.     apts[2].x = (prect->xLeft-display.offset.x)   + scrollx;
  624.     if (prect->yBottom < display.offset.y)
  625.         apts[2].y = 0;
  626.     else
  627.     apts[2].y = (prect->yBottom-display.offset.y) + scrolly;
  628.     if (apts[2].x > bitmap.width)
  629.         apts[2].x = bitmap.width;
  630.     if (apts[2].x + wx > bitmap.width) {
  631.         wx = bitmap.width - apts[2].x;
  632.     }
  633.     apts[3].x = apts[2].x + wx;
  634.     if (apts[2].y > bitmap.height)
  635.         apts[2].y = bitmap.height;
  636.     if (apts[2].y + wy > bitmap.height) {
  637.         wy = bitmap.height - apts[2].y;
  638.     }
  639.     apts[3].y = apts[2].y + wy;
  640.     /* target is inclusive */
  641. #ifdef NOTUSED
  642.     apts[0].x = prect->xLeft;
  643.     apts[0].y = prect->yBottom;
  644.     apts[1].x = prect->xLeft + wx - 1;
  645.     apts[1].y = prect->yBottom + wy - 1;
  646. #else
  647.     if (prect->xLeft < display.offset.x)
  648.     apts[0].x = display.offset.x;
  649.     else 
  650.     apts[0].x = prect->xLeft;
  651.     if (prect->yBottom < display.offset.y)
  652.      apts[0].y = display.offset.y;
  653.     else
  654.     apts[0].y = prect->yBottom;
  655.     apts[1].x = apts[0].x + wx - 1;
  656.     apts[1].y = apts[0].y + wy - 1;
  657. #endif
  658.  
  659. #ifdef NOTUSED
  660.     if ( (display.bitcount == 4)  /* standard VGA is buggy */
  661.     || ( (os_version==201100) && (display.bitcount==8) && (bitmap.depth==1)) /* S3 and ATI GU are buggy */
  662.          ) {
  663.     /* slow code to dodge OS/2 bugs */
  664.     /* this code double buffers the bitmap and works on a standard VGA
  665.      * but didn't work on an ATI Ultra Graphics Pro in 8514 emulation
  666.      */
  667.     /* This won't work for version 2.11, S3 or ATI GU, 8bit/pixel display, 8bit/pixel bitmap */
  668.     HBITMAP hbmp;
  669.     /* create a bitmap */
  670.     hbmp = make_bitmap(&bitmap, apts[2].x, apts[2].y, apts[3].x, apts[3].y, bitmap.depth);
  671.     /* Draw it to the display */
  672.     if (hbmp) {
  673.         WinDrawBitmap(ps, hbmp, NULL, &apts[0], CLR_BLACK, CLR_WHITE, DBM_NORMAL);
  674.         GpiDeleteBitmap(hbmp);
  675.     }
  676.     }
  677.     else {
  678. #endif
  679.     /* fast code which doesn't always work */
  680.     /* This code works on the Trident SVGA and 8514 in 256 color mode,
  681.       * but GpiDrawBits fails with a SYS3175 on the standard VGA.
  682.      */
  683.     /* This won't work for version 2.11, S3 or ATI GU, 8bit/pixel display, 1bit/pixel bitmap */
  684.     GpiDrawBits(ps, bitmap.bits, bitmap.pbmi, 4, apts, 
  685.         (bitmap.depth != 1) ? ROP_SRCCOPY : ROP_NOTSRCCOPY, 0);
  686. #ifdef NOTUSED
  687.     }
  688. #endif
  689.     /* Fill areas around page */
  690.     if (prect->yBottom < display.offset.y) {    /* bottom centre */
  691.     rect.yBottom = prect->yBottom;
  692.     rect.yTop = display.offset.y;
  693.     rect.xLeft = apts[0].x;
  694.     rect.xRight = rect.xLeft + wx;
  695.     WinFillRect(ps, &rect, SYSCLR_BUTTONMIDDLE);
  696.     }
  697.     if (prect->yTop > bitmap.height + display.offset.y) { /* bottom centre */
  698.     rect.yBottom = bitmap.height + display.offset.y;
  699.     rect.yTop = prect->yTop;
  700.     rect.xLeft = apts[0].x;
  701.     rect.xRight = rect.xLeft + wx;
  702.     WinFillRect(ps, &rect, SYSCLR_BUTTONMIDDLE);
  703.     }
  704.     if (prect->xLeft < display.offset.x) { /* left */
  705.     rect.yBottom = prect->yBottom;
  706.     rect.yTop = prect->yTop;
  707.     rect.xLeft = prect->xLeft;
  708.     rect.xRight = display.offset.x;
  709.     WinFillRect(ps, &rect, SYSCLR_BUTTONMIDDLE);
  710.     }
  711.     if (prect->xRight > bitmap.width + display.offset.x) { /* right */
  712.     rect.yBottom = prect->yBottom;
  713.     rect.yTop = prect->yTop;
  714.     rect.xLeft = bitmap.width + display.offset.x;
  715.     rect.xRight = prect->xRight;
  716.     WinFillRect(ps, &rect, SYSCLR_BUTTONMIDDLE);
  717.     }
  718.  
  719.     /* draw bounding box */
  720.     if ((doc != (PSDOC *)NULL) && option.show_bbox) {
  721.         POINTL pt;
  722.     float x, y;
  723.     /* map bounding box to device coordinates */
  724.     x = doc->boundingbox[LLX];
  725.     y = doc->boundingbox[LLY];
  726.     map_pt_to_pixel(&x, &y);
  727.     rect.xLeft   = (int)x;
  728.     rect.yBottom = (int)y;
  729.     x = doc->boundingbox[URX];
  730.     y = doc->boundingbox[URY];
  731.     map_pt_to_pixel(&x, &y);
  732.     rect.xRight  = (int)x;
  733.     rect.yTop    = (int)y;
  734.  
  735.     /* draw it inverted */
  736.     GpiSetColor(ps, CLR_TRUE);
  737.     GpiSetLineType(ps, LINETYPE_SHORTDASH);
  738.     GpiSetMix(ps, FM_XOR);
  739.     pt.x = rect.xLeft; pt.y = rect.yBottom;
  740.     GpiMove(ps, &pt);
  741.     pt.x = rect.xRight; /* might be better to use GpiPolyLine */
  742.     GpiLine(ps, &pt);
  743.     pt.y = rect.yTop;
  744.     GpiLine(ps, &pt);
  745.     pt.x = rect.xLeft;
  746.     GpiLine(ps, &pt);
  747.     pt.y = rect.yBottom;
  748.     GpiLine(ps, &pt);
  749.     GpiSetLineType(ps, LINETYPE_DEFAULT);
  750.     GpiSetMix(ps, FM_DEFAULT);
  751.     GpiSetColor(ps, CLR_TRUE);
  752.     }
  753.  
  754.     return 0;
  755. }
  756.  
  757. /* enable or disable a menu item */
  758. void
  759. enable_menu_item(int menuid, int itemid, BOOL enabled)
  760. {
  761. HWND hwndMenu;
  762. MENUITEM mi;
  763.     hwndMenu = WinWindowFromID(hwnd_frame, FID_MENU);
  764.     WinSendMsg(hwndMenu, MM_QUERYITEM, 
  765.         MPFROM2SHORT(menuid, TRUE), MPFROMP(&mi));
  766.     WinSendMsg(mi.hwndSubMenu, MM_SETITEMATTR, MPFROMLONG(itemid),
  767.         MPFROM2SHORT(MIA_DISABLED, enabled ? 0 : MIA_DISABLED));
  768. }
  769.  
  770.  
  771. /* This is the window function */
  772. MRESULT EXPENTRY ClientWndProc(HWND hwnd, ULONG mess, 
  773.             MPARAM mp1, MPARAM mp2)
  774. {
  775.   char buf[256];
  776.  
  777.   static int cxClient, cyClient;
  778.   static int cxAdjust, cyAdjust;
  779.   static int nHscrollMax, nHscrollPos;
  780.   static int nVscrollMax, nVscrollPos;
  781.   int nHscrollInc;
  782.   int nVscrollInc;
  783.   HWND hwndScroll;
  784.   HPS hps;
  785.   RECTL rect;
  786.   ULONG ulclr;
  787.  
  788.     switch(mess) {
  789.     case WM_CREATE:
  790.         break;
  791.     case WM_ERASEBACKGROUND:
  792.         /* by returning TRUE, the Presentation Manager automatically clears
  793.          * the window each time the window is resized or moved.
  794.          */
  795.         if (!bitmap.valid)
  796.             return (MRESULT)TRUE;
  797.         break;
  798.     case WM_GSUPDATING:
  799.         /* this used to do the same as WM_GSBEGIN */
  800.         /* if we don't know the bitmap pointer, get it now */
  801.         if (!bitmap.valid) {
  802.             APIRET rc;
  803.             char name[256];
  804.             memset(&bitmap, 0, sizeof(bitmap));
  805.             sprintf(name, SHARED_NAME, gsview.id);
  806.               rc = DosGetNamedSharedMem((PVOID *)&bitmap.pbmi, name, PAG_READ);
  807.               if (rc) {
  808.             sprintf(buf, "Failed to open: bmp shared memory \"%s\" rc = %d", name, rc);
  809.             error_message(buf);
  810.             }
  811.             else
  812.                 bitmap.valid = TRUE;
  813.         }
  814.         return 0;
  815.     case WM_GSBEGIN:
  816.         display.page = FALSE;
  817.         display.sync = FALSE;
  818.         display.end = FALSE;
  819.         load_string(IDS_WAITDRAW, szWait, sizeof(szWait));
  820.         info_wait(TRUE);
  821.         if (!gsprog.valid) {
  822.             /* someone has killed GS */
  823.                 WinSendMsg(hwnd_bmp, WM_GSCLOSE, MPFROMLONG(0), MPFROMLONG(0));
  824.             return 0;
  825.         }
  826.         /* if we don't know the bitmap pointer, get it now */
  827.         if (!bitmap.valid) {
  828.             APIRET rc;
  829.             char name[256];
  830.             memset(&bitmap, 0, sizeof(bitmap));
  831.             sprintf(name, SHARED_NAME, gsview.id);
  832.               rc = DosGetNamedSharedMem((PVOID *)&bitmap.pbmi, name, PAG_READ);
  833.               if (rc) {
  834.             sprintf(buf, "Failed to open: bmp shared memory \"%s\" rc = %d", name, rc);
  835.             error_message(buf);
  836.             }
  837.             else
  838.                 bitmap.valid = TRUE;
  839.         }
  840.         /* should set update timer here */
  841.         return 0;
  842.     case WM_GSSYNC:
  843.         display.page = FALSE;
  844.         display.sync = TRUE;
  845. /* don't clear display.end since this stops us noticing end of non DSC document
  846.         display.end = FALSE;
  847. */
  848.         if (!WinInvalidateRect(hwnd_bmp, (PRECTL)NULL, TRUE))
  849.             error_message("error invalidating rect");
  850.           if (!WinUpdateWindow(hwnd_bmp))
  851.             error_message("error updating window");
  852. /*
  853.         if (!display.busy)
  854.             info_wait(FALSE);
  855. */
  856.         return 0;
  857.     case WM_GSPAGE:
  858.         play_sound(SOUND_PAGE);
  859.         display.page = TRUE;
  860.         display.sync = FALSE;
  861.         display.end = FALSE;
  862.         if (!WinInvalidateRect(hwnd_bmp, (PRECTL)NULL, TRUE))
  863.             error_message("error invalidating rect");
  864.           if (!WinUpdateWindow(hwnd_bmp))
  865.             error_message("error updating window");
  866.         info_wait(FALSE);
  867.         return 0;
  868.     case WM_GSCLOSE:
  869.         display.page = FALSE;
  870.         display.sync = FALSE;
  871.         bitmap.valid = FALSE;
  872.         /* mark bitmap as unused */
  873.         if (DosRequestMutexSem(gsview.bmp_mutex, 10000) == ERROR_TIMEOUT)
  874.                 message_box("ClientWndProc: WM_CLOSE: mutex timeout", 0);
  875.         DosEnterCritSec();
  876.         if (bitmap.pbmi)
  877.             DosFreeMem((PVOID)bitmap.pbmi);
  878.         memset(&bitmap, 0, sizeof(bitmap));
  879.         DosExitCritSec();
  880.         DosReleaseMutexSem(gsview.bmp_mutex);
  881.         update_scroll_bars();
  882.         if (display.busy)  {
  883.             int i, n;
  884.             char buf[2048];
  885.             gsprog.valid = FALSE; /* don't kill gsprog.input while display thread using it */
  886.             display.abort = TRUE;
  887. #ifdef __EMX__
  888.             /* flush pipe - not working */
  889.             n = -1;
  890.             while ( display.busy  && n ) {
  891.             i = ioctl(0, FIONREAD, &n);
  892.             if (n)
  893.                 read(0, buf, n > sizeof(buf) ? sizeof(buf) : n);
  894.             if (gsprog.input)
  895.                 fflush(gsprog.input);
  896.             DosSleep(0);    /* switch to next thread */
  897.             }
  898. #endif
  899.         }
  900.         else
  901.             cleanup_pgm(&gsprog);
  902.         info_wait(FALSE);
  903.         return 0;
  904.     case WM_GSERROR:
  905.         display.page = FALSE;
  906.         display.sync = FALSE;
  907.         display.end = FALSE;
  908.         if (display.busy)
  909.             display.abort = TRUE;
  910.         info_wait(FALSE);
  911.         message_box("Ghostscript Error\rSee Ghostscript window for more details", 0);
  912.             DosPostEventSem(gsview.next_event);
  913.         if (!display.busy)
  914.             cleanup_pgm(&gsprog);
  915.         return 0;
  916.     case WM_GSPALCHANGE:
  917.         /* do nothing yet */
  918.         return 0;
  919.     case WM_GSEND:
  920.         display.page = FALSE;
  921.         display.sync = FALSE;
  922.         display.end = TRUE;
  923.         if (!WinInvalidateRect(hwnd_bmp, (PRECTL)NULL, TRUE))
  924.             error_message("error invalidating rect");
  925.           if (!WinUpdateWindow(hwnd_bmp))
  926.             error_message("error updating window");
  927.         if (!display.busy)
  928.             info_wait(FALSE);
  929.         return 0;
  930.     case WM_GSPRNEXIT:
  931.         {   PRINTER *prn = (PRINTER *)mp1;
  932.             cleanup_pgm(&prn->prog);
  933.             if ((prn->cfname[0] != '\0') && !debug)
  934.                     unlink(prn->cfname);
  935.             prn->cfname[0] = '\0';
  936.             if ((prn->fname[0] != '\0') && !debug)
  937.                 unlink(prn->fname);
  938.             prn->fname[0] = '\0';
  939.         }
  940.         return 0;
  941.     case WM_INITMENU:
  942.         enable_menu_item(IDM_EDITMENU, IDM_COPYCLIP, bitmap.valid);
  943.         enable_menu_item(IDM_EDITMENU, IDM_PASTETO, bitmap.valid);
  944.         enable_menu_item(IDM_EDITMENU, IDM_ADDEPSMENU, bitmap.valid 
  945.                 && (doc != (PSDOC *)NULL) && doc->epsf);
  946.         enable_menu_item(IDM_EDITMENU, IDM_EXTEPSMENU, 
  947.             (psfile.preview == IDS_EPST) || (psfile.preview == IDS_EPSW));
  948.         WinSetAccelTable(hab, NULLHANDLE, hwnd_frame);    /* disable keyboard accelerators */
  949.         break;
  950.     case WM_MENUEND:
  951.         WinSetAccelTable(hab, haccel, hwnd_frame);    /* reenable keyboard accelerators */
  952.         break;
  953.     case WM_COMMAND:
  954.         if (LONGFROMMP(mp1) == IDM_DROP) {
  955.             char *cmd = (char *)mp2;
  956.             if ((cmd[0] == '-') || (cmd[0] == '/')) {
  957.             switch (toupper(cmd[1])) {
  958.                 case 'P':
  959.                       gsview_selectfile(cmd+2);
  960.                       gsview_print(FALSE);
  961.                   break;
  962.                 case 'F':
  963.                       gsview_selectfile(cmd+2);
  964.                       gsview_print(TRUE);
  965.                   break;
  966.                 case 'S':
  967.                   if (cmd[2] != ' ') {
  968.                 char *fname;
  969.                 /* skip over port name */
  970.                 for (fname=cmd+2; *fname && *fname!=' '; fname++)
  971.                   /* nothing */ ;
  972.                     /* skip blanks until file name */
  973.                     if (*fname) {
  974.                       *fname++ = '\0'; /* place null after port name */
  975.                       for (; *fname==' '; fname++)
  976.                         /* nothing */ ;
  977.                     }
  978.                     if (*fname) {
  979.                         /* found both filename and port */
  980.                         gsview_spool(fname, cmd+2);
  981.                         break;
  982.                     }
  983.                   }
  984.                       gsview_spool(cmd+2, (char *)NULL);
  985.                   break;
  986.                 default:
  987.                   gserror(IDS_BADCLI, cmd, MB_ICONEXCLAMATION, SOUND_ERROR);
  988.             }
  989.             }
  990.             else {
  991.             FILE *f;
  992.             /* only display file if it exists */
  993.             /* because starting GSview from Desktop menu sets cmd to d:\Desktop */
  994.             if ( (f=fopen(cmd,"rb")) != (FILE *)NULL ) {
  995.                 fclose(f);
  996.                     gsview_displayfile(cmd);
  997.             }
  998.             }
  999.             free(cmd);
  1000.         }
  1001.         else {
  1002.             if (waiting) {
  1003.             switch(LONGFROMMP(mp1)) {
  1004.                     case IDM_INFO:
  1005.                     case IDM_SAVEDIR:
  1006.                     case IDM_SETTINGS:
  1007.                     case IDM_SAVESETTINGS:
  1008.                     case IDM_SOUNDS:
  1009.                     case IDM_HELPCONTENT:
  1010.                     case IDM_HELPSEARCH:
  1011.                     case IDM_ABOUT:
  1012.                 case IDM_EXIT:
  1013.                     /* these are safe to use when busy */
  1014.                 break;
  1015.                 default:
  1016.                     play_sound(SOUND_ERROR);
  1017.                     return 0;    /* Command not permitted now */
  1018.             }
  1019.             }
  1020.             if (LONGFROMMP(mp1) == IDM_PSTOEPS) {
  1021.             if (psfile.name[0] == '\0')    /* need open file */
  1022.                 WinSendMsg(hwnd, WM_COMMAND, MPFROMSHORT(IDM_OPEN), MPFROM2SHORT(CMDSRC_OTHER,FALSE));
  1023.             }
  1024.             gsview_command(LONGFROMMP(mp1));
  1025.         }
  1026.  
  1027.         if (display.do_endfile || display.do_resize || display.do_display) {
  1028.             if (display.busy && (display.do_display || display.do_resize)) {
  1029.             play_sound(SOUND_ERROR);
  1030.             break;
  1031.             }
  1032.             load_string(IDS_WAIT, szWait, sizeof(szWait));
  1033.             info_wait(TRUE);
  1034.             if (!gs_open()) {
  1035.                 info_wait(FALSE);
  1036.                 return FALSE;
  1037.             }
  1038.             if (display.busy) {
  1039.             play_sound(SOUND_ERROR);
  1040.             if (!gsprog.valid) {
  1041.                 message_box("Problem with gs.  Exit and restart PM GSview", 0);
  1042.                     info_wait(FALSE);
  1043.             }
  1044.             }
  1045.             else {
  1046.                 ULONG count;
  1047.                 dfreopen();
  1048.                 display.busy = TRUE;
  1049.                 DosResetEventSem(display.done, &count);
  1050. #ifdef NOTHREAD
  1051.             /* for debugging run it in thread 1 */
  1052.             display_thread(NULL);
  1053. #else
  1054. #ifdef __BORLANDC__
  1055.                 display.id = _beginthread(display_thread, 16384, NULL);
  1056. #else
  1057.                 display.id = _beginthread(display_thread, NULL, 16384, NULL);
  1058. #endif
  1059.                 if (display.id == -1) {
  1060.                   info_wait(FALSE);
  1061.               message_box("_beginthread() output thread failed", 0);
  1062.               display.busy = FALSE;
  1063.               display.abort = FALSE;
  1064.               display.do_endfile = FALSE;
  1065.               display.do_resize = FALSE;
  1066.               display.do_display = FALSE;
  1067.               play_sound(SOUND_ERROR);
  1068.                 }
  1069. #endif
  1070.             }
  1071.         }
  1072.         else
  1073.             info_wait(FALSE);
  1074.         break;
  1075.     case WM_REALIZEPALETTE:
  1076.         if ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) {
  1077.         hps = WinGetPS(hwnd);
  1078.         GpiSelectPalette(hps, display.hpal);
  1079.             if (WinRealizePalette(hwnd, hps, &ulclr) > 0)
  1080.             WinInvalidateRect(hwnd, NULL, FALSE);
  1081.         GpiSelectPalette(hps, (HPAL)NULL);
  1082.         WinReleasePS(hps);
  1083.             return 0;
  1084.         }
  1085.         break;    /* use default processing */
  1086.     case WM_PAINT:
  1087.         if (!bitmap.valid) {
  1088.             hps = WinBeginPaint(hwnd, (ULONG)0, &rect);
  1089.         WinFillRect(hps, &rect, CLR_BACKGROUND);
  1090.         WinEndPaint(hwnd);
  1091.         return 0;
  1092.         }
  1093.  
  1094.         /* Refresh the window each time the WM_PAINT message is received */
  1095.  
  1096.         /* get bmp mutex to stop gs.exe changing bitmap while we paint */
  1097.         if (DosRequestMutexSem(gsview.bmp_mutex, 10000) == ERROR_TIMEOUT)
  1098.             message_box("ClientWndProc: WM_PAINT: mutex timeout", 0);
  1099.         if (scan_bitmap(&bitmap))
  1100.         update_scroll_bars(); /* bitmap has changed */
  1101.  
  1102.         if (!bitmap.valid) {
  1103.             DosReleaseMutexSem(gsview.bmp_mutex);
  1104.             hps = WinBeginPaint(hwnd, (ULONG)0, &rect);
  1105.         WinFillRect(hps, &rect, CLR_BACKGROUND);
  1106.         WinEndPaint(hwnd);
  1107.         return 0;
  1108.         }
  1109.  
  1110.         hps = WinBeginPaint(hwnd, (HPS)NULL, &rect);
  1111.         if ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) {
  1112.             GpiSelectPalette(hps, display.hpal);
  1113.                 WinRealizePalette(hwnd, hps, &ulclr);
  1114.             paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1115.             GpiSelectPalette(hps, (HPAL)NULL);
  1116.         }
  1117.         else
  1118.             paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1119.         WinEndPaint(hwnd);
  1120.  
  1121.         DosReleaseMutexSem(gsview.bmp_mutex);
  1122.         return 0;
  1123.     case WM_MOVE:
  1124.         /* don't interrogate the window location immediately since */
  1125.         /* it causes the Diamond Stealth VL24 with IBM S3 drivers */
  1126.         /* to corrupt the display */
  1127.         DosSleep(50);
  1128.         if (hwnd_frame) {
  1129.         SWP swp;
  1130.         WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
  1131.         if (!(swp.fl & SWP_MINIMIZE)) {
  1132.             if (!(swp.fl & SWP_MAXIMIZE)) {
  1133.                 option.img_origin.x = swp.x;
  1134.                 option.img_origin.y = swp.y;
  1135.             }
  1136.             option.img_max = ((swp.fl & SWP_MAXIMIZE) != 0);
  1137.         }
  1138.         }
  1139.         break;
  1140.     case WM_SIZE:
  1141.         cyClient = SHORT2FROMMP(mp2);
  1142.         cxClient = SHORT1FROMMP(mp2);
  1143.  
  1144.         cyAdjust = min(bitmap.height, cyClient) - cyClient;
  1145.         cyClient += cyAdjust;
  1146.  
  1147.         nVscrollMax = max(0, bitmap.height - cyClient);
  1148.         nVscrollPos = min(nVscrollPos, nVscrollMax);
  1149.         scroll_pos.y = nVscrollMax - nVscrollPos;
  1150.  
  1151.         if (!bitmap.valid)
  1152.             cyClient = cyAdjust = nVscrollMax = nVscrollPos;
  1153.  
  1154.         hwndScroll = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_VERTSCROLL);
  1155.         WinSendMsg(hwndScroll, SBM_SETSCROLLBAR, MPFROMLONG(nVscrollPos), 
  1156.             MPFROM2SHORT(0, nVscrollMax));
  1157.         if (bitmap.valid)
  1158.             WinSendMsg(hwndScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cyClient, bitmap.height),
  1159.             MPFROMLONG(0));
  1160.         else
  1161.             WinSendMsg(hwndScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(1, 1),
  1162.             MPFROMLONG(0));
  1163.  
  1164.         cxAdjust = min(bitmap.width,  cxClient) - cxClient;
  1165.         cxClient += cxAdjust;
  1166.  
  1167.         nHscrollMax = max(0, bitmap.width - cxClient);
  1168.         nHscrollPos = min(nHscrollPos, nHscrollMax);
  1169.         scroll_pos.x = nHscrollPos;
  1170.  
  1171.         if (!bitmap.valid)
  1172.             cxClient = cxAdjust = nHscrollMax = nHscrollPos;
  1173.  
  1174.         hwndScroll = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_HORZSCROLL);
  1175.         WinSendMsg(hwndScroll, SBM_SETSCROLLBAR, MPFROMLONG(nHscrollPos), 
  1176.             MPFROM2SHORT(0, nHscrollMax));
  1177.         if (bitmap.valid)
  1178.             WinSendMsg(hwndScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cxClient, bitmap.width),
  1179.             MPFROMLONG(0));
  1180.         else
  1181.             WinSendMsg(hwndScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(1, 1),
  1182.             MPFROMLONG(0));
  1183.  
  1184.         if ( option.fit_page && (cxAdjust!=0 || cyAdjust!=0) ) {
  1185.                 SWP swp;
  1186.             /* don't interrogate the window location immediately since */
  1187.             /* it causes the Diamond Stealth VL24 with IBM S3 drivers */
  1188.             /* to corrupt the display */
  1189.             DosSleep(50);
  1190.                 WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
  1191.                 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), 0, 
  1192.                 swp.x, swp.y - cyAdjust,
  1193.                 swp.cx + cxAdjust, swp.cy + cyAdjust, SWP_SIZE | SWP_MOVE);
  1194.                 cxAdjust = cyAdjust = 0;
  1195.         }
  1196.         display.offset.x = -cxAdjust/2;
  1197.         display.offset.y = -cyAdjust/2;
  1198.             if (hwnd_frame) {
  1199.             SWP swp;
  1200.             WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
  1201.             if (!(swp.fl & SWP_MINIMIZE)) {
  1202.             if (!(swp.fl & SWP_MAXIMIZE)) {
  1203.                     option.img_size.x = swp.cx;
  1204.                     option.img_size.y = swp.cy;
  1205.             }
  1206.                 option.img_max = ((swp.fl & SWP_MAXIMIZE) != 0);
  1207.             }
  1208.         }
  1209.         break;
  1210.     case WM_VSCROLL:
  1211.         switch(SHORT2FROMMP(mp2)) {
  1212.         case SB_LINEUP:
  1213.             nVscrollInc = -cyClient/16;
  1214.             break;
  1215.         case SB_LINEDOWN:
  1216.             nVscrollInc = cyClient/16;
  1217.             break;
  1218.         case SB_PAGEUP:
  1219.             nVscrollInc = min(-1,-cyClient);
  1220.             break;
  1221.         case SB_PAGEDOWN:
  1222.             nVscrollInc = max(1,cyClient);
  1223.             break;
  1224. #ifdef NOTUSED
  1225.         case SB_SLIDERTRACK:
  1226.             /* only do this for fast redraw modes */
  1227.             /* these are 8bit/pixel and 1bit/pixel */
  1228.                 if ( (bitmap.depth == 1) ||
  1229.                ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) ) {
  1230.             nVscrollInc = SHORT1FROMMP(mp2) - nVscrollPos;
  1231.             }
  1232.             else
  1233.             nVscrollInc = 0;
  1234. #endif
  1235.         case SB_SLIDERPOSITION:
  1236.             nVscrollInc = SHORT1FROMMP(mp2) - nVscrollPos;
  1237.             break;
  1238.         case SB_TOP:
  1239.             nVscrollInc = -nVscrollPos;
  1240.             break;
  1241.         case SB_BOTTOM:
  1242.             nVscrollInc = nVscrollMax - nVscrollPos;
  1243.             break;
  1244.         default:
  1245.             nVscrollInc = 0;
  1246.         }
  1247.         if ((nVscrollInc = max(-nVscrollPos, 
  1248.         min(nVscrollInc, nVscrollMax - nVscrollPos)))!=0) {
  1249.         LONG lComplexity;
  1250.         hwndScroll = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_VERTSCROLL);
  1251.         nVscrollPos += nVscrollInc;
  1252.         scroll_pos.y = nVscrollMax - nVscrollPos;
  1253.         lComplexity = WinScrollWindow(hwnd, 0, nVscrollInc, (PRECTL)NULL, (PRECTL)NULL, 
  1254.             (HRGN)NULLHANDLE, (PRECTL)&rect, 0);
  1255.         WinSendMsg(hwndScroll, SBM_SETPOS, MPFROMLONG(nVscrollPos), 0);
  1256.         if (lComplexity != RGN_RECT) {
  1257.             WinInvalidateRect(hwnd, (PRECTL)NULL, FALSE);
  1258.             WinUpdateWindow(hwnd);
  1259.         }
  1260.         else {
  1261.             /* redraw exposed area */
  1262.             hps = WinGetPS(hwnd);
  1263.                 if ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) {
  1264.                     GpiSelectPalette(hps, display.hpal);
  1265.                         WinRealizePalette(hwnd, hps, &ulclr);
  1266.                 paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1267.                     GpiSelectPalette(hps, (HPAL)NULL);
  1268.                 }
  1269.             else
  1270.                 paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1271.             WinReleasePS(hps);
  1272.         }
  1273.         }
  1274.         break;
  1275.     case WM_HSCROLL:
  1276.         switch(SHORT2FROMMP(mp2)) {
  1277.         case SB_LINELEFT:
  1278.             nHscrollInc = -cxClient/16;
  1279.             break;
  1280.         case SB_LINERIGHT:
  1281.             nHscrollInc = cyClient/16;
  1282.             break;
  1283.         case SB_PAGELEFT:
  1284.             nHscrollInc = min(-1,-cxClient);
  1285.             break;
  1286.         case SB_PAGERIGHT:
  1287.             nHscrollInc = max(1,cxClient);
  1288.             break;
  1289. #ifdef NOTUSED
  1290.         case SB_SLIDERTRACK:
  1291.             /* only do this for fast redraw modes */
  1292.             /* these are 8bit/pixel and 1bit/pixel */
  1293.                 if ( (bitmap.depth == 1) ||
  1294.                ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) ) {
  1295.             nHscrollInc = SHORT1FROMMP(mp2) - nHscrollPos;
  1296.             }
  1297.             else
  1298.             nHscrollInc = 0;
  1299. #endif
  1300.         case SB_SLIDERPOSITION:
  1301.             nHscrollInc = SHORT1FROMMP(mp2) - nHscrollPos;
  1302.             break;
  1303.         default:
  1304.             nHscrollInc = 0;
  1305.         }
  1306.         if ((nHscrollInc = max(-nHscrollPos, 
  1307.         min(nHscrollInc, nHscrollMax - nHscrollPos)))!=0) {
  1308.         LONG lComplexity;
  1309.         hwndScroll = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_HORZSCROLL);
  1310.         nHscrollPos += nHscrollInc;
  1311.         scroll_pos.x = nHscrollPos;
  1312.         lComplexity = WinScrollWindow(hwnd, -nHscrollInc, 0, (PRECTL)NULL, (PRECTL)NULL, 
  1313.             (HRGN)NULLHANDLE, (PRECTL)&rect, 0);
  1314.         /* need to send next message BEFORE redrawing, otherwise S3 driver screws up */
  1315.         WinSendMsg(hwndScroll, SBM_SETPOS, MPFROMLONG(nHscrollPos), 0);
  1316.         if (lComplexity != RGN_RECT) {
  1317.             WinInvalidateRect(hwnd, (PRECTL)NULL, FALSE);
  1318.             WinUpdateWindow(hwnd);
  1319.         }
  1320.         else {
  1321.             /* redraw exposed area */
  1322.             hps = WinGetPS(hwnd);
  1323.                 if ((bitmap.depth == 8) && display.hasPalMan && display.hpal_exists) {
  1324.                     GpiSelectPalette(hps, display.hpal);
  1325.                         WinRealizePalette(hwnd, hps, &ulclr);
  1326.                 paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1327.                     GpiSelectPalette(hps, (HPAL)NULL);
  1328.                 }
  1329.             else
  1330.                 paint_bitmap(hps, &rect, nHscrollPos, nVscrollMax - nVscrollPos);
  1331.             WinReleasePS(hps);
  1332.         }
  1333.         }
  1334.         break;
  1335.     case WM_CHAR:    /* process keystrokes here */
  1336.         /* Process only key presses, not key releases */
  1337.         if (SHORT1FROMMP(mp1) & KC_KEYUP)
  1338.             break;
  1339.         if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
  1340.         USHORT vkey = SHORT2FROMMP(mp2);
  1341.         switch(vkey) {
  1342.             case VK_HOME:
  1343.                 WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_TOP));
  1344.                 break;
  1345.             case VK_END:
  1346.                 WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_BOTTOM));
  1347.                 break;
  1348.             case VK_UP:
  1349.                 WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_LINEUP));
  1350.                 break;
  1351.             case VK_DOWN:
  1352.                 WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_LINEDOWN));
  1353.                 break;
  1354.             case VK_PAGEUP:
  1355.                 if (SHORT1FROMMP(mp1) & KC_CTRL)
  1356.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGELEFT));
  1357.              else
  1358.                     WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGEUP));
  1359.                 break;
  1360.             case VK_PAGEDOWN:
  1361.                 if (SHORT1FROMMP(mp1) & KC_CTRL)
  1362.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGERIGHT));
  1363.              else
  1364.                     WinSendMsg(hwnd, WM_VSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGEDOWN));
  1365.                 break;
  1366.             case VK_LEFT:
  1367.                 if (SHORT1FROMMP(mp1) & KC_CTRL)
  1368.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGELEFT));
  1369.               else
  1370.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_LINELEFT));
  1371.                 break;
  1372.             case VK_RIGHT:
  1373.                 if (SHORT1FROMMP(mp1) & KC_CTRL)
  1374.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_PAGERIGHT));
  1375.                 else
  1376.                     WinSendMsg(hwnd, WM_HSCROLL, MPFROMLONG(0), MPFROM2SHORT(0, SB_LINERIGHT));
  1377.                 break;
  1378.         }
  1379.         }
  1380.         case WM_BUTTON1DOWN:
  1381.         if (hwnd_modeless) 
  1382.             WinPostMsg(hwnd_modeless, WM_COMMAND, MPFROMSHORT(BB_CLICK), MPFROMLONG(0));
  1383.         break;
  1384.         case WM_BUTTON2DOWN:
  1385.         { float x, y;
  1386.             if (get_cursorpos(&x, &y)) {
  1387.                 zoom = !zoom;
  1388.                 display.zoom_xoffset = x;
  1389.                 display.zoom_yoffset = y;
  1390.             x = (scroll_pos.x+cxClient/2)*72.0/option.xdpi;
  1391.             y = (scroll_pos.y+cyClient/2)*72.0/option.ydpi;
  1392.             transform_point(&x, &y);
  1393.             x *= option.xdpi/72.0;
  1394.             y *= option.ydpi/72.0;
  1395.             display.zoom_xoffset -= (int)(x*72.0/option.zoom_xdpi);
  1396.             display.zoom_yoffset -= (int)(y*72.0/option.zoom_ydpi);
  1397.             }
  1398.             else {
  1399.                 zoom = FALSE;
  1400.             }
  1401.             WinPostMsg(hwnd_bmp, WM_COMMAND, (MPARAM)IDM_ZOOM, MPFROMLONG(0));
  1402.         }
  1403.         break;
  1404.         case WM_MOUSEMOVE:
  1405.         /* track cursor and display coordinates */
  1406.         hps = WinGetPS(hwnd_status);
  1407.         WinFillRect(hps, &info_coord, SYSCLR_BUTTONMIDDLE);
  1408.         cursorpos_paint(hps);
  1409.         WinReleasePS(hps);
  1410.         if (waiting)
  1411.                 WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE));
  1412.         else {
  1413.             if (!bitmap.valid)
  1414.                 break;
  1415.                 WinSetPointer(HWND_DESKTOP, hptr_crosshair);
  1416.         }
  1417.         return (MRESULT)TRUE;    /* cursor has been changed */
  1418.         case WM_CLOSE:
  1419.         if (printer.prog.valid) {
  1420.             load_string(IDS_PRINTBUSY, buf, sizeof(buf));
  1421.                 if (message_box(buf, MB_YESNO | MB_ICONQUESTION) != IDYES)
  1422.                 return (MRESULT)0;
  1423.         }
  1424.         break;
  1425.         case DM_DRAGOVER:
  1426.         return DragOver((PDRAGINFO)mp1);
  1427.         case DM_DROP:
  1428.         return Drop((PDRAGINFO)mp1);
  1429.   }
  1430.   /* All messages not handled by the ClientWndProc must be passed */
  1431.   /* along to the Presentation Manager for default processing */
  1432.   return WinDefWindowProc(hwnd, mess, mp1, mp2);
  1433. }
  1434.  
  1435. /* map from a coordinate in points, to a coordinate in pixels */
  1436. /* This is the opposite of the transform part of get_cursorpos */
  1437. /* Used when showing bbox */
  1438. void
  1439. map_pt_to_pixel(float *x, float *y)
  1440. {
  1441.     if (zoom) {
  1442.         /* WARNING - this doesn't cope with EPS Clip */
  1443.         *x = (*x - display.zoom_xoffset) * option.zoom_xdpi / 72.0;
  1444.         *y = (*y - display.zoom_yoffset) * option.zoom_ydpi / 72.0;
  1445.         *x = (*x * 72.0 / option.xdpi);
  1446.         *y = (*y * 72.0 / option.ydpi);
  1447.         itransform_point(x, y);
  1448.         *x = (*x * option.xdpi / 72.0) - scroll_pos.x + display.offset.x;
  1449.         *y = (*y * option.ydpi / 72.0) - scroll_pos.y + display.offset.y;
  1450.     }
  1451.     else {
  1452.         *x = *x - (display.epsf_clipped ? doc->boundingbox[LLX] : 0);
  1453.         *y = *y - (display.epsf_clipped ? doc->boundingbox[LLY] : 0);
  1454.         itransform_point(x, y);
  1455.         *x = *x * option.xdpi/72.0
  1456.           - scroll_pos.x + display.offset.x;
  1457.         *y = *y * option.ydpi/72.0
  1458.           - scroll_pos.y + display.offset.y;
  1459.     }
  1460. }
  1461.  
  1462.  
  1463. /* return coordinates in pts from origin of page */
  1464. /* For Portrait, this is the bottom left */
  1465. /* For rotated pages, this is NOT the bottom left */
  1466. BOOL
  1467. get_cursorpos(float *x, float *y)
  1468. {
  1469. RECTL rect;
  1470. POINTL pt;
  1471.     if (!bitmap.valid)
  1472.         return FALSE;
  1473.     if (!WinQueryPointerPos(HWND_DESKTOP, &pt))
  1474.         return FALSE;
  1475.     WinMapWindowPoints(HWND_DESKTOP, hwnd_bmp, &pt, 1);
  1476.     WinQueryWindowRect(hwnd_bmp, &rect);
  1477.     if (!WinPtInRect(hab, &rect, &pt))
  1478.         return FALSE;
  1479.     *x = scroll_pos.x+pt.x-display.offset.x;
  1480.     *y = scroll_pos.y+pt.y-display.offset.y;
  1481.     transform_cursorpos(x, y);
  1482.     return TRUE;
  1483. }
  1484.  
  1485. void
  1486. cursorpos_paint(HPS hps)
  1487. {
  1488. float x, y;
  1489. POINTL pt;
  1490. char buf[64];
  1491.        if (get_cursorpos(&x, &y)) {
  1492.         switch(option.unit) {
  1493.            case IDM_UNITPT:   
  1494.               sprintf(buf,"%.0f, %.0fpt", x, y);
  1495.           break;
  1496.            case IDM_UNITMM:   
  1497.               sprintf(buf,"%.0f, %.0fmm", x/72*25.4, y/72*25.4);
  1498.           break;
  1499.            case IDM_UNITINCH:   
  1500.               sprintf(buf,"%.1f, %.1fin", x/72, y/72);
  1501.           break;
  1502.         }
  1503.         GpiSetTextAlignment(hps, TA_RIGHT, TA_NORMAL_VERT);
  1504.         pt.x = info_coord.xRight - 1;
  1505.         pt.y = info_page.y;
  1506.             GpiCharStringAt(hps, &pt, strlen(buf), buf);
  1507.       }
  1508. }
  1509.  
  1510. void
  1511. info_paint(HWND hwnd)
  1512. {
  1513. HPS ps;
  1514. RECTL rect;
  1515. POINTL pt;
  1516. int i;
  1517. char *p;
  1518. char buf[MAXSTR];
  1519. char fmt[MAXSTR];
  1520.         ps = WinBeginPaint(hwnd, (ULONG)0, &rect);
  1521.     /* draw background */
  1522.     WinFillRect(ps, &rect, SYSCLR_BUTTONMIDDLE);
  1523.     GpiSetColor(ps, SYSCLR_BUTTONDARK);
  1524.     pt.x = 0; pt.y = 0;
  1525.     GpiMove(ps, &pt);
  1526.     pt.x = statusbar.x - 1;
  1527.     GpiLine(ps, &pt);
  1528.     pt.y = statusbar.y - 1;
  1529.     GpiLine(ps, &pt);
  1530.     GpiSetColor(ps, SYSCLR_BUTTONLIGHT);
  1531.     pt.x = 0;
  1532.     GpiLine(ps, &pt);
  1533.     pt.y = 0;
  1534.     GpiLine(ps, &pt);
  1535.     GpiSetColor(ps, SYSCLR_BUTTONDEFAULT);
  1536.  
  1537.     /* write file information */
  1538.     if (psfile.name[0] != '\0') {
  1539.         i = load_string(IDS_FILE, buf, sizeof(buf));
  1540.         if ( (p = strrchr(psfile.name, '\\')) == (char *)NULL )
  1541.         p = psfile.name;
  1542.         else
  1543.         p++;
  1544.         strcat(buf, p);
  1545.         GpiCharStringAt(ps, &info_file, strlen(buf), buf);
  1546.         if (waiting) {
  1547. /*
  1548.         i = load_string(IDS_WAIT, buf, sizeof(buf));
  1549.             GpiCharStringAt(ps, &info_page, strlen(buf), buf);
  1550. */
  1551.             GpiCharStringAt(ps, &info_page, strlen(szWait), szWait);
  1552.         }
  1553.         else {
  1554.           if (doc!=(PSDOC *)NULL) {
  1555.         int n = map_page(psfile.pagenum - 1);
  1556.         i = load_string(IDS_PAGEINFO, fmt, sizeof(fmt));
  1557.         if (doc->pages)
  1558.             sprintf(buf, fmt, doc->pages[n].label ? doc->pages[n].label : " ",psfile.pagenum,  doc->numpages);
  1559.         else
  1560.             sprintf(buf, fmt, " " ,psfile.pagenum,  doc->numpages);
  1561.         if (zoom)
  1562.             strcat(buf, "  Zoomed");
  1563.             GpiCharStringAt(ps, &info_page, strlen(buf), buf);
  1564.           }
  1565.           else {
  1566.         if (is_pipe_done())
  1567.             i = load_string(IDS_NOMORE, buf, sizeof(buf));
  1568.         else {
  1569.             i = load_string(IDS_PAGE, buf, sizeof(buf));
  1570.             sprintf(buf+i, "%d", psfile.pagenum);
  1571.         }
  1572.             GpiCharStringAt(ps, &info_page, strlen(buf), buf);
  1573.           }
  1574.           /* show coordinate */
  1575.           cursorpos_paint(ps);
  1576.         }
  1577.     }
  1578.     else {
  1579.         i = load_string(IDS_NOFILE, buf, sizeof(buf));
  1580.         GpiCharStringAt(ps, &info_file, strlen(buf), buf);
  1581.         if (waiting) {
  1582. /*
  1583.         i = load_string(IDS_WAIT, buf, sizeof(buf));
  1584.             GpiCharStringAt(ps, &info_page, strlen(buf), buf);
  1585. */
  1586.             GpiCharStringAt(ps, &info_page, strlen(szWait), szWait);
  1587.         }
  1588.     }
  1589.     WinEndPaint(hwnd);
  1590. }
  1591.  
  1592.  
  1593. /* Status Bar Window Proc */
  1594. MRESULT EXPENTRY StatusWndProc(HWND hwnd, ULONG mess, 
  1595.             MPARAM mp1, MPARAM mp2)
  1596. {
  1597.   HPS ps;
  1598.   RECTL rect;
  1599.   POINTL pt;
  1600.   switch (mess) {
  1601.     case WM_CREATE:
  1602.     {
  1603.     FONTMETRICS fm;
  1604.     POINTL char_size;
  1605.     ps = WinGetPS(hwnd);
  1606.     GpiQueryFontMetrics(ps, sizeof(FONTMETRICS), &fm);
  1607.     char_size.y = fm.lMaxAscender + fm.lMaxDescender + fm.lExternalLeading + 2;
  1608.     char_size.x = fm.lAveCharWidth;
  1609.     statusbar.y = char_size.y + 2;
  1610.     info_file.x = 2;
  1611.     info_file.y = fm.lMaxDescender + 3;
  1612.     info_coord.xLeft = 23 * char_size.x;
  1613.     info_coord.xRight = 38 * char_size.x;
  1614.     info_coord.yTop = char_size.y - 1;
  1615.     info_coord.yBottom = 1;
  1616.     info_page.x = 40 * char_size.x + 2;
  1617.     info_page.y = fm.lMaxDescender + 3;
  1618. /*
  1619.     WinFillRect(ps, SYSCLR_BUTTONMIDDLE);
  1620. */
  1621.     WinReleasePS(ps);
  1622.     }
  1623.     break;
  1624.     case WM_PAINT:
  1625.     info_paint(hwnd);
  1626.     return 0;
  1627.   }
  1628.   return WinDefWindowProc(hwnd, mess, mp1, mp2);
  1629. }
  1630.  
  1631.  
  1632. void
  1633. shade_button(HPS hps, struct button *bp, BOOL down)
  1634. {
  1635. POINTL pt;
  1636.     /* draw button shading */
  1637.     if (down)
  1638.         GpiSetColor(hps, SYSCLR_BUTTONLIGHT);
  1639.     else
  1640.         GpiSetColor(hps, SYSCLR_BUTTONDARK);
  1641.     pt.x = bp->rect.xLeft; 
  1642.     pt.y = bp->rect.yBottom;
  1643.     GpiMove(hps, &pt);
  1644.     pt.x = bp->rect.xRight - 1;
  1645.     GpiLine(hps, &pt);
  1646.     pt.y = bp->rect.yTop - 1;
  1647.     GpiLine(hps, &pt);
  1648.     if (down)
  1649.         GpiSetColor(hps, SYSCLR_BUTTONDARK);
  1650.     else
  1651.         GpiSetColor(hps, SYSCLR_BUTTONLIGHT);
  1652.     pt.x = bp->rect.xLeft;
  1653.     GpiLine(hps, &pt);
  1654.     pt.y = bp->rect.yBottom;
  1655.     GpiLine(hps, &pt);
  1656.     GpiSetColor(hps, SYSCLR_BUTTONDEFAULT);
  1657. }
  1658.  
  1659. void
  1660. size_buttons(PPOINTL ppt)
  1661. {
  1662.   struct button *bp;
  1663.   int i = 0;
  1664.   if (option.button_show) {
  1665.     for (bp = buttonhead; bp != (struct button *)NULL; bp = bp->next) {
  1666.     bp->rect.xLeft = i * button_shift.x;
  1667.     bp->rect.yBottom = ppt->y - button_size.y - i * button_shift.y;
  1668.     bp->rect.xRight = bp->rect.xLeft + button_size.x;
  1669.     bp->rect.yTop = bp->rect.yBottom + button_size.y;
  1670.         i++;
  1671.     }
  1672.   }
  1673. }
  1674.  
  1675. /* Button Bar Window Proc */
  1676. MRESULT EXPENTRY ButtonWndProc(HWND hwnd, ULONG mess, 
  1677.             MPARAM mp1, MPARAM mp2)
  1678. {
  1679.   HPS hps;
  1680.   RECTL rect;
  1681.   POINTL pt;
  1682.   struct button *bp;
  1683.   switch (mess) {
  1684.     case WM_SIZE:
  1685.     /* reposition buttons */
  1686.     pt.x = SHORT1FROMMP(mp2);
  1687.     pt.y = SHORT2FROMMP(mp2);
  1688.         size_buttons(&pt);
  1689.     WinInvalidateRect(hwnd, (PRECTL)NULL, FALSE);
  1690.     break;
  1691.     case WM_BUTTON1DOWN:
  1692.     pt.x = SHORT1FROMMP(mp1);
  1693.     pt.y = SHORT2FROMMP(mp1);
  1694.     for (bp = buttonhead; bp != (struct button *)NULL; bp = bp->next) {
  1695.         if (WinPtInRect(hab, &(bp->rect), &pt)) {
  1696.         button_current = bp;
  1697.         button_down = TRUE;
  1698.         hps = WinGetPS(hwnd);
  1699.         shade_button(hps, bp, TRUE);
  1700.         WinReleasePS(hps);
  1701.             WinSetCapture(HWND_DESKTOP, hwnd);
  1702.         break;
  1703.         }
  1704.     }
  1705.     break;
  1706.     case WM_BUTTON1UP:
  1707.     pt.x = SHORT1FROMMP(mp1);
  1708.     pt.y = SHORT2FROMMP(mp1);
  1709.     bp = button_current;
  1710.     if (bp != (struct button *)NULL) {
  1711.         hps = WinGetPS(hwnd);
  1712.         shade_button(hps, bp, FALSE);
  1713.         WinReleasePS(hps);
  1714.         if (WinPtInRect(hab, &(bp->rect), &pt)) {
  1715.             WinPostMsg(hwnd_bmp, WM_COMMAND, MPFROMSHORT(bp->id), MPFROMLONG(0));
  1716.         }
  1717.     }
  1718.     WinSetCapture(HWND_DESKTOP, NULLHANDLE);
  1719.     WinInvalidateRect(hwnd_status, NULL, FALSE);
  1720.     WinUpdateWindow(hwnd_status);
  1721.     button_info = NULL;
  1722.     button_current = NULL;
  1723.     button_down = FALSE;
  1724.     break;
  1725.     case WM_MOUSEMOVE:
  1726.     pt.x = SHORT1FROMMP(mp1);
  1727.     pt.y = SHORT2FROMMP(mp1);
  1728.     bp = button_current;
  1729.     if (bp != (struct button *)NULL) {
  1730.         if (button_down && !WinPtInRect(hab, &(bp->rect), &pt)) {
  1731.         button_down = FALSE;
  1732.         hps = WinGetPS(hwnd);
  1733.         shade_button(hps, bp, FALSE);
  1734.         WinReleasePS(hps);
  1735.         }
  1736.         else if (!button_down && WinPtInRect(hab, &(bp->rect), &pt)) {
  1737.         button_down = TRUE;
  1738.         hps = WinGetPS(hwnd);
  1739.         shade_button(hps, bp, TRUE);
  1740.         WinReleasePS(hps);
  1741.         }
  1742.     }
  1743.     else {
  1744.         /* track cursor and display button function */
  1745.         char buf[64];
  1746.         /* find button */
  1747.         for (bp = buttonhead; bp != (struct button *)NULL; bp = bp->next) {
  1748.           if (WinPtInRect(hab, &(bp->rect), &pt)) {
  1749.         break;
  1750.           }
  1751.         }
  1752.         if (bp != button_info) {
  1753.           button_info = bp;
  1754.           if (bp != (struct button *)NULL) {
  1755.         if (WinQueryCapture(HWND_DESKTOP) != hwnd)
  1756.                 WinSetCapture(HWND_DESKTOP, hwnd); /* track all mouse movements */
  1757.             /* erase page area of status bar */
  1758.             hps = WinGetPS(hwnd_status);
  1759.             rect.xLeft = info_file.x;
  1760.             rect.xRight = statusbar.x - 1;
  1761.             rect.yBottom = info_coord.yBottom;
  1762.             rect.yTop = info_coord.yTop;
  1763.             WinFillRect(hps, &rect, SYSCLR_BUTTONMIDDLE);
  1764.         load_string(bp->id, buf, sizeof(buf));
  1765.                 GpiCharStringAt(hps, &info_file, strlen(buf), buf);
  1766.             WinReleasePS(hps);
  1767.           }
  1768.           else {
  1769.             WinSetCapture(HWND_DESKTOP, NULLHANDLE);  /* release capture */
  1770.         /* put statusbar back to normal */
  1771.             WinInvalidateRect(hwnd_status, NULL, FALSE);
  1772.           WinUpdateWindow(hwnd_status);
  1773.           }
  1774.         }
  1775.     }
  1776.     break;
  1777.     case WM_PAINT:
  1778.     hps = WinBeginPaint(hwnd, (ULONG)0, &rect);
  1779.     /* draw background */
  1780.     WinFillRect(hps, &rect, SYSCLR_BUTTONMIDDLE);
  1781.     GpiSetColor(hps, SYSCLR_BUTTONDARK);
  1782.     pt.x = buttonbar.x - 1; pt.y = 0;
  1783.     GpiMove(hps, &pt);
  1784.     pt.y = buttonbar.y - 1;
  1785.     GpiLine(hps, &pt);
  1786.     GpiSetColor(hps, SYSCLR_BUTTONLIGHT);
  1787.     pt.x = 0;
  1788.     GpiLine(hps, &pt);
  1789.     pt.y = 0;
  1790.     GpiLine(hps, &pt);
  1791.     GpiSetColor(hps, SYSCLR_BUTTONDEFAULT);
  1792.     for (bp = buttonhead; bp != (struct button *)NULL; bp = bp->next) {
  1793.         if (bp->hbitmap) {
  1794.         /* draw bitmap */
  1795.         pt.x = bp->rect.xLeft;
  1796.         pt.y = bp->rect.yBottom;
  1797.         WinDrawBitmap(hps, bp->hbitmap, NULL, &pt, 0, 0, DBM_NORMAL);
  1798.         }
  1799.         else {
  1800.         /* draw button text */
  1801.         pt.x = (bp->rect.xLeft + bp->rect.xRight)/2;
  1802.         pt.y = (bp->rect.yBottom + bp->rect.yTop)/2;
  1803.             GpiSetTextAlignment(hps, TA_CENTER, TA_HALF);
  1804.                 GpiCharStringAt(hps, &pt, strlen(bp->str), bp->str);
  1805.         }
  1806.         shade_button(hps, bp, FALSE);
  1807.     }
  1808.     WinEndPaint(hwnd);
  1809.     return 0;
  1810.   }
  1811.   return WinDefWindowProc(hwnd, mess, mp1, mp2);
  1812. }
  1813.  
  1814. /* subclassed Frame Window Procedure */
  1815. MRESULT EXPENTRY FrameWndProc(HWND hwnd, ULONG mess, 
  1816.             MPARAM mp1, MPARAM mp2)
  1817. {
  1818. MRESULT mr;
  1819. int sCount;
  1820. PSWP pswpNew, pswpClient, pswp;
  1821.  
  1822.   switch(mess) {
  1823.     case WM_HELP:
  1824.     /* HM_DISPLAY_HELP is unreliable for HM_PANELNAME so we lookup */
  1825.     /* the id ourselves and use HM_RESOURCEID */
  1826.     {
  1827.     HELPIDX *hidx;
  1828.       for (hidx = helpidx; hidx->id != 0; hidx++) {
  1829.         if (strcmp(hidx->name, szHelpTopic)==0) {
  1830.         WinSendMsg(hwnd_help, HM_DISPLAY_HELP, MPFROMSHORT(hidx->id), MPFROMSHORT(HM_RESOURCEID));
  1831.         continue;
  1832.         }
  1833.       }
  1834.     }
  1835.     return 0;
  1836.     case WM_CALCFRAMERECT:
  1837.     mr =  (*OldFrameWndProc)(hwnd, mess, mp1, mp2);
  1838.     /* calculate position of client rectangle */
  1839.     if (mr && mp2) {
  1840.         ((PRECTL)mp1)->yTop -= statusbar.y;
  1841.         if (option.button_show)
  1842.             ((PRECTL)mp1)->xLeft += buttonbar.x;
  1843.     }
  1844.     return mr;
  1845.     case WM_FORMATFRAME:
  1846.     /* reformat frame to make room for status bar */
  1847.     mr =  (*OldFrameWndProc)(hwnd, mess, mp1, mp2);
  1848.     sCount = (int)mr;
  1849.     pswp = (PSWP)mp1;
  1850.     pswpClient = (PSWP)mp1 + sCount - 1;
  1851.     pswpNew = pswpClient + 1;
  1852.     *pswpNew = *pswpClient;
  1853.     pswpNew->hwnd = WinWindowFromID(hwnd, ID_STATUSBAR);
  1854.     pswpNew->cy = statusbar.y;
  1855.     pswpClient->cy -= pswpNew->cy;
  1856.     pswpNew->y = pswpClient->y + pswpClient->cy;
  1857.     pswp[FID_VERTSCROLL - FID_SYSMENU].cy -= pswpNew->cy;
  1858.     pswpNew->x = pswp[FID_MENU - FID_SYSMENU].x;
  1859.     pswpNew->cx = pswp[FID_MENU - FID_SYSMENU].cx;
  1860.     statusbar.x = pswpNew->cx;
  1861.     sCount++;
  1862.     /* reformat frame to make room for button bar */
  1863.     pswpNew++;
  1864.     *pswpNew = *pswpClient;
  1865.     pswpNew->hwnd = WinWindowFromID(hwnd, ID_BUTTONBAR);
  1866.     pswpNew->x = pswpClient->x;
  1867.         pswpNew->cx = buttonbar.x;
  1868.     pswpNew->y = pswpClient->y;
  1869.     pswpNew->cy = pswpClient->cy;
  1870.     buttonbar.y = pswpNew->cy;
  1871.     pswpNew->fl &= ~(SWP_SHOW | SWP_HIDE);
  1872.     sCount++;
  1873.     if (option.button_show) {
  1874.         pswpClient->x += buttonbar.x;
  1875.         pswpClient->cx -= buttonbar.x;
  1876.         pswpNew->fl |= SWP_SHOW;
  1877.         /* following is a kludge because ButtonWndProc is receiving WM_SIZE
  1878.            messages in reverse order to WM_FORMATFRAME here! */
  1879.         WinPostMsg(hwnd_button, WM_SIZE, 
  1880.         MPFROM2SHORT(pswpNew->cx, pswpNew->cy), 
  1881.         MPFROM2SHORT(pswpNew->cx, pswpNew->cy));
  1882.     }
  1883.     else {
  1884.         pswpNew->fl |= SWP_HIDE;
  1885.     }
  1886.     return (MRESULT)sCount;
  1887.     case WM_QUERYFRAMECTLCOUNT:
  1888.     mr =  (*OldFrameWndProc)(hwnd, mess, mp1, mp2);
  1889.         sCount = (int)mr;
  1890.         sCount+=2;
  1891.     return (MRESULT)sCount;
  1892.   }
  1893.   return (*OldFrameWndProc)(hwnd, mess, mp1, mp2);
  1894. }
  1895.  
  1896. MRESULT
  1897. DragOver(PDRAGINFO pDragInfo)
  1898. {
  1899. int cItems, i;
  1900. PDRAGITEM pditem;
  1901. USHORT usDrop, usDefaultOp;
  1902. char dtype[256];
  1903. char drmf[256];
  1904.     if (!DrgAccessDraginfo(pDragInfo))
  1905.         return MRFROM2SHORT(DOR_NODROPOP, 0);
  1906.     switch(pDragInfo->usOperation) {
  1907.         case DO_DEFAULT:
  1908.         case DO_COPY:
  1909.         usDrop = DOR_DROP;
  1910.         usDefaultOp = DO_COPY;
  1911.         break;
  1912.         default:
  1913.         case DO_UNKNOWN:
  1914.         case DO_MOVE:
  1915.         DrgFreeDraginfo(pDragInfo);
  1916.         return MRFROM2SHORT(DOR_NODROPOP, 0);
  1917.     }
  1918.     
  1919.     cItems = DrgQueryDragitemCount(pDragInfo);
  1920.     for (i=0; i<cItems; i++) {
  1921.         pditem = DrgQueryDragitemPtr(pDragInfo, i);
  1922.         DrgQueryStrName(pditem->hstrType, sizeof(dtype)-1, dtype);
  1923.         DrgQueryStrName(pditem->hstrRMF, sizeof(drmf)-1, drmf);
  1924.         if (pditem->fsSupportedOps & DO_COPYABLE)  {
  1925.             if ( DrgVerifyRMF(pditem, "DRM_OS2FILE", "DRF_TEXT") )
  1926.                 usDrop = DOR_DROP;
  1927.         else
  1928.                 usDrop = DOR_NEVERDROP;
  1929.         }
  1930.         else {
  1931.         usDrop = DOR_NODROPOP;
  1932.         }
  1933.     }
  1934.     DrgFreeDraginfo(pDragInfo);
  1935.     return MRFROM2SHORT(usDrop, usDefaultOp);
  1936. }
  1937.  
  1938. MRESULT
  1939. Drop(PDRAGINFO pDragInfo)
  1940. {
  1941. int cItems, i;
  1942. DRAGITEM dragitem;
  1943. USHORT usDrop, usDefaultOp;
  1944. char dirname[MAXSTR];
  1945. char filename[MAXSTR];
  1946. char *dragname;
  1947. int length;
  1948. HPS hps;
  1949. POINTL pt;
  1950.     if (!DrgAccessDraginfo(pDragInfo))
  1951.         return MRFROM2SHORT(DOR_NODROPOP, 0);
  1952.     cItems = DrgQueryDragitemCount(pDragInfo);
  1953.     for (i=0; i<cItems; i++) {
  1954.         DrgQueryDragitem(pDragInfo, sizeof(dragitem), &dragitem, i);
  1955.         length = DrgQueryStrName(dragitem.hstrContainerName, sizeof(dirname), dirname);
  1956.         length += DrgQueryStrName(dragitem.hstrSourceName, sizeof(filename), filename);
  1957.         dragname = malloc(length+1);
  1958.         strcpy(dragname, dirname);
  1959.         strcat(dragname, filename);
  1960.         WinPostMsg(hwnd_bmp, WM_COMMAND, (MPARAM)IDM_DROP, MPFROMP(dragname));    /* mp2 is not strictly correct */
  1961.     }
  1962.     DrgDeleteDraginfoStrHandles(pDragInfo);
  1963.     DrgFreeDraginfo(pDragInfo);
  1964.     return (MRESULT)0;
  1965. }
  1966.  
  1967.