home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / os2cl016.zip / pmwin.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-05  |  15.2 KB  |  621 lines
  1. /* 
  2.  
  3.  
  4.     pmwin.cpp (emx+gcc) 
  5.  
  6.     1995 Giovanni Iachello
  7.     This is freeware software. You can use or modify it as you wish,
  8.     provided that the part of code that I wrote remains freeware.
  9.     Freeware means that the source code must be available on request 
  10.     to anyone.
  11.     You must also include this notice in all files derived from this
  12.     file.
  13.  
  14.  
  15. */
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <stdarg.h>
  20.  
  21. #include "pmwin.h"
  22. #include "pmgpi.h"
  23. #include "pmdlg.h"
  24. #include "pmhelp.h"
  25. #include "pmstdres.h"
  26.  
  27.  
  28. MRESULT PMWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  29. {
  30.     PMWin* win=NULL;
  31.     
  32.     if (msg==WM_CREATE) {
  33.         WinSetWindowPtr(hwnd,0,mp1);  // mp1=this pointer from WinCreateWindow, line 125
  34.         ((PMWin*)mp1)->hwnd=hwnd;     // PMWin::hwnd is set to hwnd
  35.     }
  36.  
  37.     win = (PMWin*)WinQueryWindowPtr(hwnd, 0);
  38.  
  39.     if (win) { // is there a C++ window object to process messages?
  40.         PMEvent event(msg,mp1,mp2,CHARMSG(&msg),MOUSEMSG(&msg)); // yes
  41.         MRESULT ret=win->msgProc(event);
  42.         if (msg==WM_DESTROY) delete win; // automatically destroy the C++ object il the window is destroyed
  43.         return ret;
  44.     }
  45.     return WinDefWindowProc(hwnd,msg,mp1,mp2); // no
  46. }
  47.  
  48.  
  49. /////////////////////////////////////////////////////////////////////////////
  50. // PMWin class
  51. // the constructors follow. Note that the constructors only fill in the
  52. // createArgs structure. The window is actually created by the createWin 
  53. // function
  54.  
  55. PMWin::PMWin(HAB iab)
  56. {
  57.     ab.PMAnchorBlock(iab);
  58.     createArgs=NULL;
  59.     hwnd=(HWND)0;
  60.     hwndFrame=(HWND)0;
  61.     oldproc=WinDefWindowProc; // for safety
  62. }
  63.  
  64. PMWin::PMWin(PCSZ classname,HAB iab)
  65. {
  66.     ab.PMAnchorBlock(iab);
  67.     createArgs=new WINCREATEARGS;
  68.     hwnd=(HWND)0;
  69.     hwndFrame=(HWND)0;
  70.     oldproc=WinDefWindowProc; 
  71.     
  72.     createArgs->hwndParent=HWND_DESKTOP;
  73.     createArgs->flStyle= WS_VISIBLE;
  74.     createArgs->flCreateFlags=(FCF_TITLEBAR | FCF_SYSMENU |
  75.                   FCF_SIZEBORDER | FCF_MINMAX |
  76.                   FCF_SHELLPOSITION | FCF_TASKLIST);
  77.     createArgs->pszClientClass=classname;
  78.     createArgs->pszTitle=NULL;
  79.     createArgs->styleClient=0L;
  80.     createArgs->hmod=(HMODULE)0;
  81.     createArgs->idResources=0;
  82.     createArgs->phwndClient=&hwnd;
  83.  
  84.     createArgs->hab=iab;
  85.     createArgs->pszClassName=classname;
  86.     createArgs->pfnWndProc=PMWndProc;
  87.     createArgs->flClassStyle=CS_SIZEREDRAW;
  88.     createArgs->cbWindowData=sizeof(this);
  89. }
  90.  
  91. PMWin::~PMWin()
  92. {
  93.     delete createArgs;
  94. }
  95.  
  96. // I'm using the two-phase method of window creation (frame and client)
  97. // beacuse I want to intercept the WM_CREATE message of the client window.
  98. // (see the PMWndProc functions at the beginning of this file)
  99.  
  100. BOOL PMWin::createWin()
  101. {
  102.     HWND newhwnd;
  103.     FRAMECDATA fcdata;
  104.  
  105.     CLASSINFO temp;
  106.     if (!WinQueryClassInfo(ab,createArgs->pszClassName,&temp)) {
  107.         BOOL ret=WinRegisterClass (createArgs->hab, createArgs->pszClassName, 
  108.             createArgs->pfnWndProc,createArgs->flClassStyle, createArgs->cbWindowData);
  109.         assert(ret);
  110.     }
  111.     
  112.     oldproc=WinDefWindowProc;
  113.  
  114.     fcdata.cb = sizeof(FRAMECDATA); // fill in the frame control data structure
  115.     fcdata.flCreateFlags = createArgs->flCreateFlags;
  116.     fcdata.hmodResources = createArgs->hmod;
  117.     fcdata.idResources   = createArgs->idResources;
  118.     
  119.     newhwnd = WinCreateWindow(createArgs->hwndParent,WC_FRAME,
  120.                             createArgs->pszTitle,0,
  121.                             0,0,0,0,    /* coordinates */ 0, // no owner 
  122.                             HWND_TOP,createArgs->idResources,&fcdata,NULL);
  123.     
  124.     assert(newhwnd);
  125.     hwndFrame=newhwnd;
  126.     newhwnd = WinCreateWindow(hwndFrame,createArgs->pszClassName,
  127.                             NULL,0,
  128.                             0,0,0,0,    /* coordinates */ 
  129.                             hwndFrame,
  130.                             HWND_TOP,FID_CLIENT,this,NULL);
  131.  
  132.     assert(newhwnd);
  133. //    hwnd=newhwnd; // not necessary, this->hwnd is set by PMWndProc
  134.     WinShowWindow(hwndFrame, TRUE);
  135.  
  136. //    BOOL ret=WinSetWindowPtr(hwnd, 0, this); // set the window user pointer to the pointer to this class. see PMWndProc
  137. //    assert(ret);
  138.     return hwnd;
  139. }
  140. //    newhwnd = WinCreateStdWindow (createArgs->hwndParent,createArgs->flStyle,
  141. //                &createArgs->flCreateFlags,createArgs->pszClientClass,
  142. //                createArgs->pszTitle,createArgs->styleClient,createArgs->hmod,
  143. //                createArgs->idResources,createArgs->phwndClient);
  144.  
  145. // a BOOL TRUE from dispachEvent means that we processed the message.
  146. MRESULT PMWin::msgProc(PMEvent &event)
  147. {
  148.     event.ret=MRFROMSHORT(FALSE);
  149.     // if we handle the message return the ret code, otherwise call the default message handler
  150.     return dispachEvent(event) ? event.ret : (*oldproc)(hwnd,event.msg,event.mp1,event.mp2);
  151. }
  152.  
  153. // dispach messages among the predefinde functions
  154. BOOL PMWin::dispachEvent(PMEvent & event)
  155. {
  156.     if ((event.msg>=WM_MOUSEFIRST && event.msg<=WM_MOUSELAST) ||
  157.             (event.msg>=WM_EXTMOUSEFIRST && event.msg<=WM_EXTMOUSELAST) ) {
  158.         return mouse(event);
  159.     } else if (event.msg>=HM_MSG_BASE && event.msg<=HM_CONTROL) {
  160.         return helpmsg(event);
  161.     } else
  162.         switch (event.msg) {
  163.         case WM_CREATE:
  164.             return create(event);
  165.         case WM_DESTROY:
  166.             return destroy();
  167.         case WM_SAVEAPPLICATION:
  168.             saveApplication();
  169.             return FALSE;
  170.         case WM_CHAR: 
  171.             return kbd(event);
  172.         case WM_COMMAND:
  173.             return command(SHORT1FROMMP (event.mp1),SHORT2FROMMP (event.mp2));
  174.         case WM_PAINT:
  175.             return paint();
  176.         case WM_ENABLE:
  177.             return enable();
  178.         case WM_SHOW:
  179.             return show();
  180.         case WM_MOVE:
  181.             return move();
  182.         case WM_SIZE:
  183.             return size(SHORT1FROMMP (event.mp2),SHORT2FROMMP (event.mp2));
  184.         case WM_ACTIVATE:
  185.             return activate();
  186.         case WM_SETFOCUS:
  187.             return setfocus();
  188.         case WM_HELP:
  189.             return help(event);
  190.         case WM_TIMER:
  191.             return timer();
  192.         case WM_CLOSE:
  193.             return closed();
  194.         case WM_PRESPARAMCHANGED:
  195.             invalidate(TRUE);
  196.             return TRUE;
  197.         case WM_INITMENU:
  198.             PMMenu* menu=new PMMenu(HWNDFROMMP(event.mp2));
  199.             return initmenu(SHORT1FROMMP(event.mp1),menu);
  200.             delete menu;
  201.         }               
  202.     return other(event);
  203. }
  204.  
  205. // predefinde message classes
  206. BOOL PMWin::create(PMEvent &)
  207. {
  208.     return FALSE;
  209. }
  210.  
  211. BOOL PMWin::destroy()
  212. {
  213.     return FALSE;
  214. }
  215.  
  216. // exception to the BOOL return value rool: PM requires that the default procedure always be called
  217. void PMWin::saveApplication()
  218. {
  219. }
  220.  
  221. BOOL PMWin::command(USHORT /*id*/,USHORT /*cmddev*/)  // nothandled
  222. {
  223.     return FALSE;
  224. }
  225.  
  226. BOOL PMWin::paint()
  227. {
  228.     return FALSE;
  229. }
  230.  
  231. BOOL PMWin::kbd(PMEvent &)
  232. {
  233.     return FALSE;
  234. }
  235.  
  236. BOOL PMWin::mouse(PMEvent &)
  237. {
  238.     return FALSE;
  239. }
  240.  
  241. BOOL PMWin::enable()
  242. {
  243.     return FALSE;
  244. }
  245. BOOL PMWin::show()    
  246. {
  247.     return FALSE;
  248. }
  249. BOOL PMWin::move()
  250. {
  251.     return FALSE;
  252. }
  253. BOOL PMWin::size(SHORT,SHORT)
  254. {
  255.     return FALSE;
  256. }
  257. BOOL PMWin::activate()
  258. {
  259.     return FALSE;
  260. }
  261. BOOL PMWin::setfocus()
  262. {
  263.     return FALSE;
  264. }
  265. BOOL PMWin::help(PMEvent &)
  266. {
  267.     return FALSE;
  268. }
  269. BOOL PMWin::helpmsg(PMEvent &)
  270. {
  271.     return FALSE;
  272. }
  273.  
  274. BOOL PMWin::timer()
  275. {
  276.     return FALSE;
  277. }
  278. BOOL PMWin::closed()
  279. {
  280.     return FALSE;
  281. }
  282.  
  283. BOOL PMWin::other(PMEvent &)
  284. {
  285.     return FALSE;
  286. }
  287.  
  288. MRESULT PMWin::close() 
  289. { 
  290.     return sendMsg(WM_CLOSE); 
  291. }
  292.  
  293. BOOL PMWin::destroyWin()
  294. {
  295.     return WinDestroyWindow(hwndFrame);
  296. }
  297.  
  298. BOOL PMWin::initmenu(SHORT /*id*/,PMMenu* /*menu*/)
  299. {
  300.     return FALSE;
  301. }
  302.  
  303.  
  304. /////////////////////////////////////////////////////////////////////////////
  305. // additional function
  306.  
  307. BOOL PMWin::ptInClient(PMPoint& pt)
  308. {
  309.     PMRect rcl;
  310.     rcl=this;
  311.     return WinPtInRect (ab, &rcl, &pt);
  312. }
  313.  
  314. /////////////////////////////////////////////////////////////////////////////
  315. // PMMain Window.
  316. // Adds automatic support to file handling, title bar text and menus and help
  317.  
  318. PMMainWin::PMMainWin(PCSZ classname,HAB ab,PMHelpWin *ihelpWin) : PMWin(classname,ab) 
  319. { 
  320.     helpWin=ihelpWin;
  321.     caption=NULL;
  322.     modified=FALSE;
  323.     filename[0]='\0';
  324.     fileFlags=PMMWFF_NOTHING;
  325.     fileNone="(none)"; fileUntitled="(untitled)";
  326.     flCaption=fsCaption=fnFilter=NULL;
  327. }
  328.  
  329.  
  330. // inline help support (this create uses the standard create function
  331. // and adds the automatic association to the help instance)
  332.  
  333. // supporto per help inline (usa tutto create della classe base, e aggiunge
  334. // l'associazione automatica alla finestra di help!)
  335.  
  336. BOOL PMMainWin::createWin()
  337. {
  338.     BOOL ret;
  339.     ret=PMWin::createWin();
  340.     if (helpWin) ret&=associateHelpInstance(helpWin->getHwnd());
  341.     return ret;
  342. }
  343.  
  344. BOOL PMMainWin::destroyWin()
  345. {
  346.     BOOL ret;
  347.     if (helpWin) {
  348.         ret=associateHelpInstance(NULLHANDLE);
  349.         ret&=PMWin::destroyWin();
  350.     } else ret=PMWin::destroyWin();
  351.     return ret;
  352. }
  353.  
  354. // automatically create a WindowPresSpace (WinBeginPaint) and pass it to 
  355. // the official paint function
  356. BOOL PMMainWin::paint() 
  357. {
  358.     PMWindowPresSpace ps(this);
  359.     return paint(ps);
  360. }
  361.  
  362. // the window wants to be closed. Ask to the user if it is possible (queryEnd)
  363. // and do it.
  364. BOOL PMMainWin::closed()
  365. {
  366.     if (queryEnd()) postMsg(WM_QUIT);
  367.     return TRUE;
  368. }
  369.  
  370. // used by queryEnd to ask the user if it is possible to close the file
  371. BOOL PMMainWin::fileKillConfirm()
  372. {
  373.     if (!modified) return TRUE;
  374.     char buf[160];
  375.     strcpy(buf,"Save Changes");
  376.     if (fileFlags==PMMWFF_FILE) {
  377.         strcat(buf," to ");
  378.         strcat(buf,filename);
  379.     }
  380.     strcat(buf,"?");
  381.     int ret=WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,(PCSZ)buf,(PCSZ)caption,0,MB_YESNOCANCEL|MB_ICONHAND|MB_APPLMODAL);
  382.     if (ret==MBID_YES) command(PMIDM_FILESAVE,0);
  383.     if (ret==MBID_CANCEL) return FALSE;
  384.     return TRUE;        
  385. }
  386.  
  387. // automatic title text setter. (automagically adds an * for modified files)
  388. void PMMainWin::setTitleCaption()
  389. {
  390.     char temp[256];
  391.     if (caption==NULL) temp[0]='\0';
  392.     else {
  393.         switch (fileFlags) {
  394.         case PMMWFF_NOTHING:
  395.             sprintf(temp,"%s",caption);
  396.             break;
  397.         case PMMWFF_NONE:
  398.             if (modified)
  399.                 sprintf(temp,"%s - *%s",caption,fileNone);
  400.             else
  401.                 sprintf(temp,"%s - %s",caption,fileNone);
  402.             break;
  403.         case PMMWFF_UNTITLED:
  404.             if (modified)
  405.                 sprintf(temp,"%s - *%s",caption,fileUntitled);
  406.             else
  407.                 sprintf(temp,"%s - %s",caption,fileUntitled);
  408.             break;
  409.         case PMMWFF_FILE:
  410.             if (modified)
  411.                 sprintf(temp,"%s - *%s",caption,filename);
  412.             else
  413.                 sprintf(temp,"%s - %s",caption,filename);
  414.             break;
  415.         }
  416.     }
  417.     setFrameWindowText(temp);
  418. }
  419.  
  420. // handle automatically menu selections.
  421. BOOL PMMainWin::command(USHORT id,USHORT /*cmddev*/)
  422. {
  423.     switch(id) {
  424.     case PMIDM_FILENEW:
  425.         if (fileKillConfirm()) {
  426.             if (fileNew()) { fileFlags=PMMWFF_UNTITLED; setModified(FALSE);    }
  427.         }
  428.         return TRUE;
  429.     case PMIDM_FILEOPEN: {
  430.         if (fileKillConfirm()) {
  431.             PMFileDialog fd(HWND_DESKTOP, hwnd, fnFilter, flCaption, "Open", FDS_OPEN_DIALOG);
  432.             int ret=fd.createWin();
  433.             if (ret==1) {
  434.                 FILEDLG fi=fd;
  435.                 if (fileOpen(fi.szFullFile)) { // if load clompleted successfully, change the caption
  436.                         strcpy(filename,fi.szFullFile);
  437.                     fileFlags=PMMWFF_FILE;
  438.                 }
  439.                 setModified(FALSE);
  440.             }
  441.         }
  442.         return TRUE;
  443.         }    
  444.     case PMIDM_FILESAVE: 
  445.         if (filename[0]) { // if there's already a filename, save the file
  446.             fileSave(filename);
  447.             setModified(FALSE);
  448.             return TRUE;
  449.         } // otherwise fallback to SAVEAS
  450.     case PMIDM_FILESAVEAS: {
  451.         PMFileDialog fd(HWND_DESKTOP, hwnd, fnFilter, fsCaption, "Save", FDS_SAVEAS_DIALOG);
  452.         int ret=fd.createWin();
  453.         if (ret==1) {
  454.             FILEDLG fi=fd;
  455.             if (fileSave(fi.szFullFile)) { // if correctly saved, change caption
  456.                 strcpy(filename,fi.szFullFile);
  457.                 fileFlags=PMMWFF_FILE;
  458.             }
  459.             setModified(FALSE);
  460.         }
  461.         return TRUE;
  462.         }    
  463.     case PMIDM_FILEPRINT :
  464.         filePrint();
  465.         return TRUE;
  466.     case PMIDM_FILEEXIT :
  467.         close();
  468.         return TRUE;
  469.  
  470.     case PMIDM_EDITUNDO :
  471.         editUndo();
  472.         return TRUE;
  473.     case PMIDM_EDITREDO :
  474.         editRedo();
  475.         return TRUE;
  476.     case PMIDM_EDITCUT :
  477.         editCut();
  478.         return TRUE;
  479.     case PMIDM_EDITCOPY :
  480.         editCopy();
  481.         return TRUE;
  482.     case PMIDM_EDITPASTE:
  483.         editPaste();
  484.         return TRUE;
  485.     case PMIDM_EDITCLEAR:
  486.         editClear();
  487.         return TRUE;
  488.     case PMIDM_EDITDUPLICATE :
  489.     case PMIDM_EDITSELECTALL :
  490.         return FALSE;
  491.  
  492.     case PMIDM_HELPINDEX :
  493.         helpWin->sendMsg(HM_HELP_INDEX);
  494.         return TRUE;
  495.     case PMIDM_HELPGENERAL :
  496.         helpWin->sendMsg(HM_EXT_HELP);
  497.         return TRUE;
  498.     case PMIDM_HELPUSING :
  499.         helpWin->sendMsg(HM_DISPLAY_HELP);
  500.         return TRUE;
  501.     case PMIDM_HELPKEYS :
  502.         helpWin->sendMsg(HM_KEYS_HELP);
  503.         return TRUE;
  504.  
  505.     case PMIDM_HELPABOUT :
  506.         WinDlgBox(HWND_DESKTOP,hwnd,(PFNWP)PMDlgProc,NULLHANDLE,PMDLG_ABOUT,NULL);
  507.         return TRUE;
  508.  
  509.     }
  510.     return FALSE;
  511. }
  512.  
  513.  
  514. /////////////////////////////////////////////////////////////////////////////
  515.  
  516. //static MRESULT PMSubclassWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  517. //{
  518. //    PMWin* win=NULL;
  519. //
  520. //    win = (PMWin*)WinQueryWindowPtr(hwnd, 0);
  521. //
  522. //    if (win) {
  523. //        PMEvent event(msg,mp1,mp2,CHARMSG(&msg),MOUSEMSG(&msg));
  524. //        MRESULT ret=win->msgProc(event);
  525. //        if (msg==WM_DESTROY) delete win; 
  526. //        return ret;
  527. //    }
  528. //    return WinDefWindowProc(hwnd,msg,mp1,mp2);
  529. //}
  530.  
  531. PMSubclassWin::PMSubclassWin(HWND hwndParent, PCSZ pszClass, PCSZ pszName,
  532.     ULONG flStyle, LONG x, LONG y, LONG cx, LONG cy, HWND hwndOwner,
  533.        HWND hwndInsertBehind, ULONG id, PVOID pCtlData, PVOID pPresParams) : PMWin(NULLHANDLE)
  534. {
  535.     createArgs=new WINCREATEARGS;
  536.     
  537.     createArgs->hwndParent=hwndParent;
  538.     createArgs->pszClientClass=pszClass;
  539.     createArgs->pszTitle=pszName;
  540.     createArgs->flStyle=flStyle;
  541.     createArgs->x=x;
  542.     createArgs->y=y;
  543.     createArgs->cx=cx;
  544.     createArgs->cy=cy;
  545.     createArgs->hwndOwner=hwndOwner;
  546.     createArgs->hwndInsertBehind=hwndInsertBehind;
  547.     createArgs->id=id;
  548.     createArgs->pCtlData=pCtlData;
  549.     createArgs->pPresParams=pPresParams;
  550.     
  551. }
  552.  
  553. PMSubclassWin::~PMSubclassWin()
  554. {
  555.     delete createArgs;
  556. }
  557.  
  558. BOOL PMSubclassWin::createWin()
  559. {
  560.     hwnd=WinCreateWindow(createArgs->hwndParent,
  561.                         createArgs->pszClientClass,
  562.                         createArgs->pszTitle,
  563.                         createArgs->flStyle,
  564.                         createArgs->x, createArgs->y,
  565.                         createArgs->cx, createArgs->cy,
  566.                         createArgs->hwndParent,
  567.                         createArgs->hwndInsertBehind,
  568.                         createArgs->id,
  569.                         createArgs->pCtlData,
  570.                         createArgs->pPresParams);
  571.     BOOL ret=WinSetWindowPtr(hwnd, 0, this);    // the first few messages (WM_CREATE...) are not sent to the massage handling routine
  572.     assert(ret);
  573.     ab.PMAnchorBlock( WinQueryAnchorBlock(hwnd) );
  574.     oldproc=WinSubclassWindow(hwnd,PMWndProc);            // PMWndProc gets active only at this point
  575.     return hwnd;
  576. }
  577.  
  578.  
  579. /////////////////////////////////////////////////////////////////////////////
  580. // Support functions:
  581. // DoAssert executes the assert macro code, displaying the offending condition, linenumber and source file
  582. // ErrBox shows a critical error box
  583. // MsgBox shows a message box (with optional sprintf-like parameter list)
  584.  
  585. void DoAssert(PCSZ msg,PCSZ file,unsigned line)
  586. {
  587.     char buf[160];
  588.     sprintf(buf,"at line %u in file %s: \"%s\"\nOK to continue, Cancel to close application.\n",line,file,msg);
  589.     if (WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,buf,"ASSERTION FAILURE",PMHLP_DLG_ASSERTFAIL,MB_OKCANCEL|MB_ICONHAND|MB_APPLMODAL|MB_HELP)!=MBID_OK) exit(-1);
  590. }
  591.  
  592. void ErrBox(PCSZ msg,...)
  593. {
  594.     char buf[256];
  595.  
  596.     va_list arg_ptr;
  597.     va_start(arg_ptr,msg);
  598.     vsprintf(buf,msg,arg_ptr);
  599.     va_end(arg_ptr);
  600.  
  601.     WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,buf,"Error!",PMHLP_DLG_ERRMSG,MB_CUACRITICAL|MB_APPLMODAL|MB_HELP);
  602. }
  603.  
  604. ULONG PMWin::msgBox(PCSZ title,PCSZ msg,...)
  605. {
  606.     char buf[256];
  607.  
  608.     va_list arg_ptr;
  609.     va_start(arg_ptr,msg);
  610.     vsprintf(buf,msg,arg_ptr);
  611.     va_end(arg_ptr);
  612.     
  613.     return WinMessageBox(HWND_DESKTOP,hwnd,buf,title,PMHLP_DLG_MSGWIN,MB_OK|MB_HELP);
  614. }
  615.  
  616. /*
  617.  * Local variables:
  618.  * compile-command: "dmake pmwin.o"
  619.  * end:
  620.  */
  621.