home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 19 Printer / 19-Printer.zip / LAPRINT.ZIP / LAPRINT.C < prev    next >
C/C++ Source or Header  |  1991-01-23  |  67KB  |  1,515 lines
  1.  
  2. /************************************************************************
  3. *                                                                       *
  4. *  (c) Cray Research, Inc., 1991.  All rights reserved.                 *
  5. *                                                                       *
  6. *     This program and/or module and all modifications made by Cray     *
  7. *  Research, Inc., are the sole property of Cray Research, Inc., and    *
  8. *  shall not be made available to or used by any person or persons      *
  9. *  without the prior written permission of Cray Research, Inc.          *
  10. *                                                                       *
  11. *     Programs and/or modules which are deemed in the public domain or  *
  12. *  whose copyright is held by another legal entity other than Cray      *
  13. *  Research, Inc., shall be deemed excluded from the above named        *
  14. *  restrictions and protections.                                        *
  15. *                                                                       *
  16. *     All changes made by Cray Research Inc which represent original    *
  17. *  work, modifications, descriptions or ideas to the above excluded     *
  18. *  programs and/or modules shall not be made available to or used by    *
  19. *  any person or persons without the prior written permission of        *
  20. *  Cray Research, Inc.                                                  *
  21. *                                                                       *
  22. ************************************************************************/
  23.  
  24. #define EXTERN
  25. #include "LAPRINT.h"
  26.  
  27. /***************************************************************************/
  28. /*                                                                         */
  29. /* Presentation Manager Program Main Body                                  */
  30. /*                                                                         */
  31. /* The following routine is the Presentation Manager program Main Body.    */
  32. /* The Main Body of a PM program is concerned with associating the         */
  33. /* application with the Presentation Manager system, creating its          */
  34. /* message queue, registering and displaying its main window, servicing    */
  35. /* its message queue during the time that the application is active,       */
  36. /* and disassociating the application from PM when the user is finished    */
  37. /* with the application. The remaining parts of this source module that    */
  38. /* are concerned with the Presentation Manager are the application's       */
  39. /* window procedures (main window procedure, child window procedures,      */
  40. /* and dialog window procedures) that process the messages associated      */
  41. /* with the application's various windows.                                 */
  42. /*                                                                         */
  43. /***************************************************************************/
  44.  
  45. SHORT cdecl main(argc, argv)
  46. int argc;
  47. char *argv[];
  48. {
  49.  
  50.  static CHAR szCRI_Copyright[]="(c) Cray Research, Inc., 1991.";
  51.  
  52.  QMSG qmsg;  /* MSG structure to store your messages                       */
  53.  PID  pid;   /* Process identifier for adding name to switch list          */
  54.  TID  tid;   /* Thread identifier                                          */
  55.  static CHAR szTitle[13];
  56.  
  57.  /* The WinInitialize routine initializes the Presentation Manager         */
  58.  /* facilities for use by this application and returns a handle to the     */
  59.  /* anchor block assigned to the application by PM.                        */
  60.  
  61.  if((hAB = WinInitialize(0)) == 0)
  62.     return(FALSE);
  63.   
  64.  /* The WinCreateMsgQueue call creates a message queue for this application*/
  65.  
  66.  if((hMQ = WinCreateMsgQueue(hAB, 0)) == 0)
  67.     return(FALSE);
  68.  
  69.  /* The following function registers the classes of all application windows*/
  70.  if(!cwRegisterClass())
  71.     return(FALSE);
  72.  
  73.  /* If the application's Initialization Panel is not already shown, display*/
  74.  /* it on the desktop window before any other application window is shown. */
  75.  if(!WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, (PFNWP)INITIALMsgProc, 0, 
  76.     IDLG_INITIAL, (PBYTE)HWND_DESKTOP))
  77.     DosExit(0, 1);
  78.  
  79.  /**************************************************************************/
  80.  /* IPF Initialization Structure                                           */
  81.  /**************************************************************************/
  82.  
  83.  hiLAPRINTHelp.cb = sizeof(HELPINIT);  /* size of init structure      */
  84.  hiLAPRINTHelp.ulReturnCode = 0;
  85.  hiLAPRINTHelp.pszTutorialName = 0; /* no tutorial                         */
  86.  hiLAPRINTHelp.phtHelpTable = (PVOID)(0xffff0000 | ID_LAPRINT);
  87.  hiLAPRINTHelp.hmodAccelActionBarModule = 0;
  88.  hiLAPRINTHelp.idAccelTable = 0;
  89.  hiLAPRINTHelp.idActionBar = 0;
  90.  hiLAPRINTHelp.pszHelpWindowTitle = "LAPRINT";
  91.  hiLAPRINTHelp.hmodHelpTableModule = 0;
  92.  hiLAPRINTHelp.usShowPanelId = 0;
  93.  hiLAPRINTHelp.pszHelpLibraryName = "LAPRINT.HLP";
  94.  
  95.  /**************************************************************************/
  96.  /* Create Instance of IPF                                                 */
  97.  /**************************************************************************/
  98.  
  99.  hWndLAPRINTHelp = WinCreateHelpInstance(hAB, &hiLAPRINTHelp);
  100.  if(!hWndLAPRINTHelp || hiLAPRINTHelp.ulReturnCode)
  101.    {
  102.     WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  103.                   (PSZ)"No help is available.",
  104.                   (PSZ) szAppName,
  105.                   1,
  106.                   MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  107.     WinDestroyHelpInstance(hWndLAPRINTHelp);
  108.    }
  109.  
  110.  /* The CreateWindow function creates a frame window for this application's*/
  111.  /* top window, and set the window's size and location as appropriate.     */
  112.  
  113.  WinLoadString(hAB, 0, IDS_TITLE, 13, szTitle);
  114.  hWndFrame = cwCreateWindow((HWND)HWND_DESKTOP,
  115.           FCF_TITLEBAR     |
  116.           FCF_SYSMENU      |
  117.           FCF_MINBUTTON    |
  118.           FCF_MAXBUTTON    |
  119.           FCF_SIZEBORDER   |
  120.           FCF_MENU         |
  121.           FCF_ICON         |
  122.           FCF_SHELLPOSITION,
  123.           szAppName,
  124.           szTitle,
  125.           ID_LAPRINT,
  126.           0, 0,
  127.           0, 0,
  128.           &hWndClient,
  129.           0L, SWP_SHOW);
  130.  
  131.  if(hWndFrame == 0)
  132.     return(FALSE);
  133.  
  134.  /**************************************************************************/
  135.  /* Associate Instance of IPF                                              */
  136.  /**************************************************************************/
  137.  if(hWndLAPRINTHelp)
  138.    WinAssociateHelpInstance(hWndLAPRINTHelp, hWndFrame);
  139.  /* The following inline routine fills out the application's switch control*/
  140.  /* structure with the appropriate information to add the application's    */
  141.  /* name to the OS/2 Task Manager List, a list of the jobs currently       */
  142.  /* running on the computer.                                               */
  143.  
  144.  WinQueryWindowProcess(hWndFrame, &pid, &tid);
  145.  Swctl.hwnd = hWndFrame;                         /* Frame window handle    */
  146.  Swctl.idProcess = pid;                          /* Process identifier     */
  147.  Swctl.uchVisibility = SWL_VISIBLE;              /* visibility             */
  148.  Swctl.fbJump = SWL_JUMPABLE;                    /* Jump indicator         */
  149.  strcpy(Swctl.szSwtitle, szTitle);               /* Frame window title     */
  150.  hSwitch = WinAddSwitchEntry(&Swctl);
  151.    
  152.  BgmConfigNeedsSaving = FALSE;
  153.  cwEnableMenuItem(hWndFrame,
  154.                  IDM_F_QUERYREMOTEPRINTER,
  155.                  FALSE);
  156.  
  157.  /* The following is the message loop for the application.                 */
  158.  
  159.  while(WinGetMsg(hAB, (PQMSG)&qmsg, 0, 0, 0))
  160.        WinDispatchMsg(hAB,(PQMSG)&qmsg);
  161.  
  162.  /* Perform clean up before exiting application.                           */
  163.  /**************************************************************************/
  164.  /* Destroy Instance of IPF                                                */
  165.  /**************************************************************************/
  166.  if(hWndLAPRINTHelp)
  167.     WinDestroyHelpInstance(hWndLAPRINTHelp);
  168.  /* The following routine destroys the application's frame window (which   */
  169.  /* also destroys its child windows), destroys its message queue, and      */
  170.  /* disassociates the application from the Presentation Manager system.    */
  171.  
  172.  WinDestroyWindow(hWndFrame); /* Destroy the frame window                  */
  173.  WinDestroyMsgQueue(hMQ);     /* Destroy this application's message queue  */
  174.  WinTerminate(hAB);           /* Terminate this application's use of the   */
  175.                               /* Presentation Manager resources            */
  176. } /* end of main */
  177.  
  178.  
  179. /* The following Dialog box calls are generated for the dialog boxes that  */
  180. /* have been selected as "Unlinked" dialog boxes.  To use these calls,     */
  181. /* simply copy them to the appropriate location in the application.        */
  182.  
  183. #if 0
  184.  
  185.    hWndQUERYPRT = WinLoadDlg(HWND_DESKTOP, hWnd, (PFNWP)QUERYPRTMsgProc,
  186.                           0, IDLG_QUERYPRT, (PBYTE)hWnd);
  187.  
  188. #endif
  189.  
  190. /***************************************************************************/
  191. /*                                                                         */   
  192. /* Main Window Procedure                                                   */
  193. /*                                                                         */
  194. /* This procedure provides service routines for the general PM events      */
  195. /* (messages) that PM sends to the window, as well as the user             */
  196. /* initiated events (messages) that are generated when the user selects    */
  197. /* the action bar and pulldown menu controls or the corresponding          */
  198. /* keyboard accelerators.                                                  */
  199. /*                                                                         */
  200. /* The SWITCH statement shown below distributes the window messages to     */
  201. /* the respective message service routines, which are set apart by the     */
  202. /* CASE statements. The window procedures must provide an appropriate      */
  203. /* service routine for its end user initiated messages, as well as the     */
  204. /* general PM messages (like the WM_CLOSE message). If a message is        */
  205. /* sent to this procedure for which there is no programmed CASE clause     */
  206. /* (i.e., no service routine), the message is defaulted to the             */
  207. /* WinDefWindowProc function, where it is disposed of by PM.               */
  208. /*                                                                         */
  209. /***************************************************************************/
  210.  
  211. MRESULT EXPENTRY WndProc(hWnd, message, mp1, mp2)
  212. HWND hWnd;
  213. USHORT message;
  214. MPARAM mp1;
  215. MPARAM mp2;
  216. {                        /* Beginning of message processor                 */
  217.    HPS hPS;              /* Handle for the Presentation Space              */
  218.    RECTL rClient;        /* Handle to rectangle formed by client area      */
  219.    USHORT rc;            /* common return code value                       */
  220.    INT i;
  221.  
  222.    switch(message)
  223.      {
  224.       case WM_COMMAND:
  225.         /* The PM messages for action bar and pulldown menu items are      */
  226.         /* processed in this routine.                                      */
  227.   
  228.            switch(SHORT1FROMMP(mp1))
  229.             {
  230.              case IDM_F_NEW:
  231.                   /* Place User Code to respond to the                     */
  232.                   /* Menu Item Named "~New" here.                          */
  233.  
  234.                   BgmNew(hWndClient,
  235.                          TRUE,      /* CFGOPENStruct  reset       */
  236.                          TRUE,      /* CFGSAVEStruct  reset       */
  237.                          TRUE,      /* FSELECTStruct  reset       */
  238.                          TRUE,      /* SELSERVStruct  reset       */
  239.                          TRUE,      /* PRTERADDStruct reset       */
  240.                          TRUE,      /* PRTERDELStruct reset       */
  241.                          TRUE,      /* PRTCHANGStruct reset       */
  242.                          TRUE,      /* SELPRTERStruct reset       */
  243.                          TRUE,      /* ADDSERVStruct  reset       */
  244.                          TRUE,      /* DELSERVStruct  reset       */
  245.                          TRUE,      /* CHNGSERVStruct reset       */
  246.                          TRUE);     /* QUERYPRTStruct reset       */
  247.  
  248.                   break;
  249.  
  250.              case IDM_F_OPEN:
  251.                   /* This makes a call to the dialog box named             */
  252.                   /* "CFGOPEN" rc will receive the return code             */
  253.                   /* sent when the dialog box is closed                    */
  254.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)CFGOPENMsgProc,
  255.                                  0, IDLG_CFGOPEN, (PBYTE)hWnd);
  256.                   break;
  257.  
  258.              case IDM_F_SAVE:
  259.                   /* Place User Code to respond to the                     */
  260.                   /* Menu Item Named "~Save" here.                         */
  261.                   {
  262.  
  263.                     CFGSAVEStruct  FAR *Cfgsave;
  264.  
  265.                     Cfgsave = (CFGSAVEStruct  FAR *)WinQueryWindowULong(hWndClient,
  266.                                                                         OFFSET_CFGSAVE);
  267.                     if(Cfgsave->szConfig_Directory[0] == NULL ||
  268.                        Cfgsave->szConfig_Filename[0] ==NULL)
  269.                     {
  270.                       WinPostMsg(hWnd,
  271.                                  WM_COMMAND,
  272.                                  MPFROMSHORT(IDM_F_SAVEAS),
  273.                                  0L);
  274.                       break;
  275.                     }
  276.  
  277.                     BgmWriteConfigFile(hWnd,
  278.                                        TRUE);
  279.  
  280.                   }
  281.                   break;
  282.  
  283.              case IDM_F_SAVEAS:
  284.                   /* This makes a call to the dialog box named             */
  285.                   /* "CFGSAVE" rc will receive the return code             */
  286.                   /* sent when the dialog box is closed                    */
  287.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)CFGSAVEMsgProc,
  288.                                  0, IDLG_CFGSAVE, (PBYTE)hWnd);
  289.                   break;
  290.  
  291.              case IDM_F_PRINT:
  292.  
  293.                   {
  294.  
  295.                     FSELECTStruct  FAR *Fselect;
  296.  
  297.                     Fselect  = (FSELECTStruct  FAR *)WinQueryWindowULong(hWndClient,
  298.                                                                          OFFSET_FSELECT);
  299.  
  300.                     /****************************************************
  301.                     *                                                   *
  302.                     *     This section insures we have a file to print. *
  303.                     *     If we don't then we need to query the user    *
  304.                     *     for one via the File section to print dialog. *
  305.                     *                                                   *
  306.                     ****************************************************/
  307.                     if(Fselect->szSelected_Filename[0] == NULL ||
  308.                        isspace((int)Fselect->szSelected_Filename[0]) != 0)
  309.                     {
  310.                       WinPostMsg(hWnd,
  311.                                  WM_COMMAND,
  312.                                  MPFROMSHORT(IDM_F_SELECTFILETOPRINT),
  313.                                  0L);
  314.                       break;
  315.                     }
  316.  
  317.                   }
  318.  
  319.                   if (!WinIsWindow(hAB, hWndFPRINTObject))
  320.                     {
  321.                      /* if the window is not a valid window, allocate memory */
  322.                      /* for the thread's stack                               */
  323.                      DosAllocSeg(4096, &FPRINTObjSel, SEG_NONSHARED);
  324.                      FPRINTObjStack = (CHAR *)MAKEP(FPRINTObjSel, 0);  
  325.                      _beginthread((void FAR *)FPRINTObjFunction, FPRINTObjStack, 4096, 0);
  326.                     }
  327.                   break;
  328.  
  329.              case IDM_F_SELECTFILETOPRINT:
  330.                   /* This makes a call to the dialog box named             */
  331.                   /* "FSELECT" rc will receive the return code             */
  332.                   /* sent when the dialog box is closed                    */
  333.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)FSELECTMsgProc,
  334.                                  0, IDLG_FSELECT, (PBYTE)hWnd);
  335.                   break;
  336.  
  337.              case IDM_F_QUERYREMOTEPRINTER:
  338.                   if (!WinIsWindow(hAB, hWndFQUERYREMOTEPRINTERObject))
  339.                     {
  340.                      /* if the window is not a valid window, allocate memory */
  341.                      /* for the thread's stack                               */
  342.                      DosAllocSeg(4096, &FQUERYREMOTEPRINTERObjSel, SEG_NONSHARED);
  343.                      FQUERYREMOTEPRINTERObjStack = (CHAR *)MAKEP(FQUERYREMOTEPRINTERObjSel, 0);  
  344.                      _beginthread((void FAR *)FQUERYREMOTEPRINTERObjFunction, FQUERYREMOTEPRINTERObjStack, 4096, 0);
  345.                     }
  346.                   break;
  347.  
  348.              case IDM_F_EXIT:
  349.                   /* Place User Code to respond to the                     */
  350.                   /* Menu Item Named "E~xit" here.                         */
  351.  
  352.                   WinPostMsg(hWnd,
  353.                              WM_CLOSE,
  354.                              0L,
  355.                              0L);
  356.  
  357.                   break;
  358.  
  359.              case IDM_O_SELECTPRINTER:
  360.                   /* This makes a call to the dialog box named             */
  361.                   /* "SELPRTER" rc will receive the return code            */
  362.                   /* sent when the dialog box is closed                    */
  363.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)SELPRTERMsgProc,
  364.                                  0, IDLG_SELPRTER, (PBYTE)hWnd);
  365.                   break;
  366.  
  367.              case IDM_P_ADDPRINTER:
  368.                   /* This makes a call to the dialog box named             */
  369.                   /* "PRTERADD" rc will receive the return code            */
  370.                   /* sent when the dialog box is closed                    */
  371.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)PRTERADDMsgProc,
  372.                                  0, IDLG_PRTERADD, (PBYTE)hWnd);
  373.                   break;
  374.  
  375.              case IDM_P_DELETEPRINTER:
  376.                   /* This makes a call to the dialog box named             */
  377.                   /* "PRTERDEL" rc will receive the return code            */
  378.                   /* sent when the dialog box is closed                    */
  379.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)PRTERDELMsgProc,
  380.                                  0, IDLG_PRTERDEL, (PBYTE)hWnd);
  381.                   break;
  382.  
  383.              case IDM_P_CHANGEPRINTER:
  384.                   /* This makes a call to the dialog box named             */
  385.                   /* "PRTCHANG" rc will receive the return code            */
  386.                   /* sent when the dialog box is closed                    */
  387.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)PRTCHANGMsgProc,
  388.                                  0, IDLG_PRTCHANG, (PBYTE)hWnd);
  389.                   break;
  390.  
  391.              case IDM_S_SELECTSERVER:
  392.                   /* This makes a call to the dialog box named             */
  393.                   /* "SELSERV" rc will receive the return code             */
  394.                   /* sent when the dialog box is closed                    */
  395.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)SELSERVMsgProc,
  396.                                  0, IDLG_SELSERV, (PBYTE)hWnd);
  397.                   break;
  398.  
  399.              case IDM_O_ADDSERVER:
  400.                   /* This makes a call to the dialog box named             */
  401.                   /* "ADDSERV" rc will receive the return code             */
  402.                   /* sent when the dialog box is closed                    */
  403.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)ADDSERVMsgProc,
  404.                                  0, IDLG_ADDSERV, (PBYTE)hWnd);
  405.                   break;
  406.  
  407.              case IDM_S_DELETESERVER:
  408.                   /* This makes a call to the dialog box named             */
  409.                   /* "DELSERV" rc will receive the return code             */
  410.                   /* sent when the dialog box is closed                    */
  411.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)DELSERVMsgProc,
  412.                                  0, IDLG_DELSERV, (PBYTE)hWnd);
  413.                   break;
  414.  
  415.              case IDM_S_CHANGESERVER:
  416.                   /* This makes a call to the dialog box named             */
  417.                   /* "CHNGSERV" rc will receive the return code            */
  418.                   /* sent when the dialog box is closed                    */
  419.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)CHNGSERVMsgProc,
  420.                                  0, IDLG_CHNGSERV, (PBYTE)hWnd);
  421.                   break;
  422.  
  423.              case IDM_O_NOLPRMESSAGES:
  424.                   /* Place User Code to respond to the                     */
  425.                   /* Menu Item Named "~No lpr messages" here.              */
  426.                   cwCheckPulldown(hWndFrame, IDM_O_NOLPRMESSAGES);
  427.                   break;
  428.  
  429.              case IDM_O_UNIXFORMAT:
  430.                   /* Place User Code to respond to the                     */
  431.                   /* Menu Item Named "~Unix format" here.                  */
  432.                   cwCheckPulldown(hWndFrame, IDM_O_UNIXFORMAT);
  433.                   break;
  434.  
  435.  
  436.             case IDM_H_HELPFORHELP:
  437.                  if(hWndLAPRINTHelp)
  438.                     WinSendMsg(hWndLAPRINTHelp, HM_DISPLAY_HELP, 0L, 0L);
  439.                  break;
  440.  
  441.              case IDM_H_ABOUT:
  442.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)BGMABOUTMsgProc,
  443.                                  0, IDLG_BGMABOUT, (PBYTE)hWnd);
  444.                   break;
  445.  
  446.              default:
  447.                   break; /* End of default case for switch(mp1) */
  448.             }
  449.            break; /* End of WM_COMMAND */
  450.  
  451.  
  452.       case HM_QUERY_KEYS_HELP:
  453.            /* If the user requests Keys Help from the help pulldown,       */
  454.            /* IPF sends the HM_QUERY_KEYS_HELP message to the application, */
  455.            /* which should return the panel id of the Keys Help panel      */
  456.            return((MRESULT)999);
  457.            break;
  458.  
  459.       case HM_ERROR:
  460.            /* If an IPF error occurs, an HM_ERROR message will be sent to  */
  461.            /* the application.                                             */
  462.            if(hWndLAPRINTHelp && ((ULONG)mp1) == HMERR_NO_MEMORY)
  463.              {
  464.               WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  465.                             (PSZ) "Help Terminated Due to Error",
  466.                             (PSZ) "Help Error",
  467.                             1,
  468.                             MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  469.               WinDestroyHelpInstance(hWndLAPRINTHelp);
  470.              }
  471.             else
  472.              {
  473.               WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  474.                             (PSZ) "Help Error Occurred",
  475.                             (PSZ) "Help Error",
  476.                             1,
  477.                             MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  478.              }
  479.            break;
  480.  
  481.       case WM_CREATE:
  482.            /* The WM_CREATE message is sent to a window when an application*/
  483.            /* requests that the window be created.  The window procedure   */
  484.            /* for the new window receives this message after the window is */
  485.            /* created, but before the window becomes visible.              */
  486.            /*                                                              */
  487.            cwSetInitDlgStatus(hWnd);
  488.            break; /* End of WM_CREATE */
  489.  
  490.       case WM_MOUSEMOVE:
  491.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  492.            break;
  493.  
  494.       case WM_SIZE:     /* code for sizing client area                     */
  495.            break;       /* End of WM_SIZE                                  */
  496.     
  497.       case WM_PAINT:    /* code for the window's client area               */
  498.            /* Obtain a handle to a cache presentation space                */
  499.            hPS = WinBeginPaint(hWnd, 0, 0);
  500.  
  501.            /* Determine the size of the client area                        */
  502.            WinQueryWindowRect(hWnd, &rClient);
  503.  
  504.            /* Fill the background with the default background color        */
  505.            WinFillRect(hPS, &rClient, CLR_BACKGROUND);
  506.  
  507.            /* return presentation space to state before WinBeginPaint      */
  508.            WinEndPaint(hPS);
  509.            break; /* End of WM_PAINT */
  510.  
  511.  
  512.       case WM_CLOSE:  /* close the window                                  */
  513.  
  514.            if(BgmConfigNeedsSaving != FALSE)
  515.            {
  516.  
  517.              i = WinMessageBox(HWND_DESKTOP,
  518.                                hWnd,
  519.                                (PSZ) "Current configuration not saved.  Do you wish to exit without saving? (No = Save and then exit)",
  520.                                (PSZ) szAppName,
  521.                                0,
  522.                                MB_YESNOCANCEL|MB_ICONEXCLAMATION);
  523.  
  524.              /***********************************************************
  525.              *                                                          *
  526.              *     This section processes an user Cancel on the above   *
  527.              *     message box by cancelling the close request.         *
  528.              *                                                          *
  529.              ***********************************************************/
  530.              if(i == MBID_CANCEL)
  531.              {
  532.                return(0L);
  533.              }
  534.  
  535.              /***********************************************************
  536.              *                                                          *
  537.              *     This section processes an user No on the above       *
  538.              *     message box by calling the Save configuration file   *
  539.              *     routine.                                             *
  540.              *                                                          *
  541.              *     We fall out of the BgmConfigNeedsSaving test when    *
  542.              *     the user's response is to say yes exit anyway.       *
  543.              *                                                          *
  544.              ***********************************************************/
  545.              if(i == MBID_NO)
  546.              {
  547.                WinPostMsg(hWnd,
  548.                           WM_COMMAND,
  549.                           MPFROMSHORT(IDM_F_SAVE),
  550.                           0L);
  551.                BgmConfigNeedsSaving = BGM_SAVE_THEN_EXIT;
  552.                return(0L);
  553.              }
  554.            }
  555.  
  556.            if(hWnd != hWndClient)
  557.              break;
  558.            cwFreeDlgMemory(hWnd);
  559.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  560.            break; /* End of WM_CLOSE */
  561.  
  562.       case WM_FREE_MEM: /* Free memory allocated for separate threads      */
  563.            DosFreeSeg((SEL)PVOIDFROMMP(mp1));
  564.            break;
  565.      
  566.       default:
  567.            /* For any message for which you don't specifically provide a   */
  568.            /* service routine, you should return the message to PM using   */
  569.            /* the WinDefWindowProc function.                               */
  570.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  571.            break;  /* End of default */
  572.      } 
  573.    return(0L);
  574. } /* End of WndProc */
  575.  
  576. /***************************************************************************/
  577. /*                                                                         */
  578. /* Dialog Window Procedure                                                 */
  579. /*                                                                         */
  580. /* This procedure is associated with the dialog box that is included in    */
  581. /* the function name of the procedure. It provides the service routines    */
  582. /* for the events (messages) that occur because the end user operates      */
  583. /* one of the dialog box's buttons, entry fields, or controls.             */
  584. /*                                                                         */
  585. /* The SWITCH statement in the function distributes the dialog box         */
  586. /* messages to the respective service routines, which are set apart by     */
  587. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  588. /* procedures must provide an appropriate service routine for their end    */
  589. /* user initiated messages as well as for the general PM messages (like    */
  590. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  591. /* which there is no programmed CASE condition (no service routine),       */
  592. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  593. /* disposed of by PM.                                                      */
  594. /*                                                                         */
  595. /***************************************************************************/
  596.  
  597. MRESULT EXPENTRY BGMABOUTMsgProc(hWndDlg, message, mp1, mp2)
  598. HWND hWndDlg;
  599. USHORT message;
  600. MPARAM mp1;
  601. MPARAM mp2;
  602. { 
  603.  static SHORT sfValidate = TRUE;
  604.  INT    i;
  605.  static HWND  hWndParent;
  606.           
  607.  switch(message)
  608.    {
  609.     case WM_INITDLG:
  610.          hWndParent = (HWND)mp2;
  611.          cwCenter(hWndDlg, (HWND)hWndParent);
  612.          break; /* End of WM_INITDLG */
  613.    
  614.     case WM_CONTROL:
  615.          switch(SHORT1FROMMP(mp1))
  616.            {
  617.            }
  618.          break; /* End of WM_CONTROL */
  619.    
  620.     case WM_COMMAND:
  621.          switch(SHORT1FROMMP(mp1))
  622.            {
  623.             case DID_OK: /* Button text: "Enter"                           */
  624.                  WinDismissDlg(hWndDlg, TRUE);
  625.                  break;
  626.  
  627.            }
  628.          break; /* End of WM_COMMAND */
  629.                                
  630.     case WM_CLOSE:
  631.          WinDismissDlg(hWndDlg, FALSE);
  632.          break; /* End of WM_CLOSE */
  633.            
  634.     case WM_FAILEDVALIDATE:
  635.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  636.          sfValidate = FALSE;
  637.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  638.          sfValidate = TRUE;
  639.          return((MRESULT)TRUE);
  640.          break; /* End of WM_FAILEDVALIDATE */
  641.  
  642.     default:
  643.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  644.          break;
  645.    }
  646.  return FALSE;
  647. } /* End of BGMABOUTMsgProc */
  648.  
  649.  
  650. /***************************************************************************/
  651. /*                                                                         */
  652. /* Dialog Window Procedure                                                 */
  653. /*                                                                         */
  654. /* This procedure is associated with the dialog box that is included in    */
  655. /* the function name of the procedure. It provides the service routines    */
  656. /* for the events (messages) that occur because the end user operates      */
  657. /* one of the dialog box's buttons, entry fields, or controls.             */
  658. /*                                                                         */
  659. /* The SWITCH statement in the function distributes the dialog box         */
  660. /* messages to the respective service routines, which are set apart by     */
  661. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  662. /* procedures must provide an appropriate service routine for their end    */
  663. /* user initiated messages as well as for the general PM messages (like    */
  664. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  665. /* which there is no programmed CASE condition (no service routine),       */
  666. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  667. /* disposed of by PM.                                                      */
  668. /*                                                                         */
  669. /***************************************************************************/
  670.  
  671. MRESULT EXPENTRY INITIALMsgProc(hWndDlg, message, mp1, mp2)
  672. HWND hWndDlg;
  673. USHORT message;
  674. MPARAM mp1;
  675. MPARAM mp2;
  676. { 
  677.  static SHORT sfValidate = TRUE;
  678.  INT    i;
  679.  static INT   iLogoTime;
  680.  static HWND  hWndParent;
  681.           
  682.  switch(message)
  683.    {
  684.     case WM_INITDLG:
  685.          hWndParent = (HWND)mp2;
  686.          cwCenter(hWndDlg, (HWND)hWndParent);
  687.          iLogoTime = WinQueryProfileInt(hAB, "PM_ControlPanel",
  688.                                              "LogoDisplayTime", -1);
  689.          if(iLogoTime == 0)
  690.            {
  691.             WinDismissDlg(hWndDlg, TRUE);
  692.             break;
  693.            }
  694.          if(iLogoTime == -1)
  695.            break;
  696.          WinStartTimer(hAB, hWndDlg, ID_LOGO_TIMER, iLogoTime);
  697.          break; /* End of WM_INITDLG */
  698.    
  699.     case WM_TIMER:
  700.          WinStopTimer(hAB, hWndDlg, ID_LOGO_TIMER);
  701.          WinDismissDlg(hWndDlg, TRUE);
  702.          break;
  703.  
  704.     case WM_CONTROL:
  705.          switch(SHORT1FROMMP(mp1))
  706.            {
  707.            }
  708.          break; /* End of WM_CONTROL */
  709.    
  710.     case WM_COMMAND:
  711.          switch(SHORT1FROMMP(mp1))
  712.            {
  713.             case DID_OK: /* Button text: "Enter"                           */
  714.                  WinDismissDlg(hWndDlg, TRUE);
  715.                  break;
  716.  
  717.            }
  718.          break; /* End of WM_COMMAND */
  719.                                
  720.     case WM_CLOSE:
  721.          WinDismissDlg(hWndDlg, FALSE);
  722.          break; /* End of WM_CLOSE */
  723.            
  724.     case WM_FAILEDVALIDATE:
  725.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  726.          sfValidate = FALSE;
  727.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  728.          sfValidate = TRUE;
  729.          return((MRESULT)TRUE);
  730.          break; /* End of WM_FAILEDVALIDATE */
  731.  
  732.     default:
  733.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  734.          break;
  735.    }
  736.  return FALSE;
  737. } /* End of INITIALMsgProc */
  738.  
  739.  
  740. MRESULT EXPENTRY FPRINTObjWndProc(hWnd, message, mp1, mp2)
  741. HWND hWnd;
  742. USHORT message;
  743. MPARAM mp1;
  744. MPARAM mp2;
  745. {                            
  746.  QMSG        qmsg; /* MSG structure to store your messages                 */
  747.  
  748.    switch(message)
  749.      {
  750.       case WM_USER_DEFINED_CODE:
  751.            /* Copy the following two lines of code throughout your         */
  752.            /* threaded user defined code to enable your application to     */
  753.            /* kill this thread when the user requests so.  Modifications   */
  754.            /* may wish to be made to enable clean up of thread operations. */
  755.            /*                                                              */
  756.            /* if(WinPeekMsg(hAB, (PQMSG)&qmsg, hWnd, WM_QUIT, WM_QUIT, PM_NOREMOVE)) */
  757.            /*    return(0L);                                               */
  758.            /*                                                              */
  759.  
  760.            BgmPrint(hWnd,
  761.                     TRUE);
  762.  
  763.            if(hWndFSELECT != 0)
  764.            {
  765.              WinEnableWindow((WinWindowFromID(hWndFSELECT,
  766.                                               DID_PRINT)),
  767.                              TRUE);
  768.            }
  769.           
  770.           /* After processing user defined code, post a WM_QUIT message    */
  771.           /* to terminate the thread                                       */
  772.            WinPostMsg(hWndFPRINTObject, WM_QUIT, 0L, 0L);
  773.            break;
  774.  
  775.       case WM_CREATE:
  776.            /* Post a message to start user defined code after startup      */
  777.            WinPostMsg(hWnd, WM_USER_DEFINED_CODE, 0L, 0L);
  778.            break; /* End of WM_CREATE */
  779.  
  780.       default:
  781.            /* For any message for which you don't specifically provide a   */
  782.            /* service routine, you should return the message to PM using   */
  783.            /* the WinDefWindowProc function.                               */
  784.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  785.            break;  /* End of default */
  786.      } 
  787.    return(0L);
  788. } /* End of FPRINTObjWndProc */
  789.  
  790.  
  791. MRESULT EXPENTRY FSELECTDID_PRINTObjWndProc(hWnd, message, mp1, mp2)
  792. HWND hWnd;
  793. USHORT message;
  794. MPARAM mp1;
  795. MPARAM mp2;
  796. {                            
  797.  QMSG        qmsg; /* MSG structure to store your messages                 */
  798.  
  799.    switch(message)
  800.      {
  801.       case WM_USER_DEFINED_CODE:
  802.            /* Copy the following two lines of code throughout your         */
  803.            /* threaded user defined code to enable your application to     */
  804.            /* kill this thread when the user requests so.  Modifications   */
  805.            /* may wish to be made to enable clean up of thread operations. */
  806.            /*                                                              */
  807.            /* if(WinPeekMsg(hAB, (PQMSG)&qmsg, hWnd, WM_QUIT, WM_QUIT, PM_NOREMOVE)) */
  808.            /*    return(0L);                                               */
  809.            /*                                                              */
  810.  
  811.            BgmPrint(hWndFSELECT,
  812.                     FALSE);
  813.           
  814.           /* After processing user defined code, post a WM_QUIT message    */
  815.           /* to terminate the thread                                       */
  816.            WinPostMsg(hWndFSELECTDID_PRINTObject, WM_QUIT, 0L, 0L);
  817.            break;
  818.  
  819.       case WM_CREATE:
  820.            /* Post a message to start user defined code after startup      */
  821.            WinPostMsg(hWnd, WM_USER_DEFINED_CODE, 0L, 0L);
  822.            break; /* End of WM_CREATE */
  823.  
  824.       default:
  825.            /* For any message for which you don't specifically provide a   */
  826.            /* service routine, you should return the message to PM using   */
  827.            /* the WinDefWindowProc function.                               */
  828.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  829.            break;  /* End of default */
  830.      } 
  831.    return(0L);
  832. } /* End of FSELECTDID_PRINTObjWndProc */
  833.  
  834.  
  835. MRESULT EXPENTRY FQUERYREMOTEPRINTERObjWndProc(hWnd, message, mp1, mp2)
  836. HWND hWnd;
  837. USHORT message;
  838. MPARAM mp1;
  839. MPARAM mp2;
  840. {                            
  841.  QMSG        qmsg; /* MSG structure to store your messages                 */
  842.  
  843.    switch(message)
  844.      {
  845.       case WM_USER_DEFINED_CODE:
  846.            /* Copy the following two lines of code throughout your         */
  847.            /* threaded user defined code to enable your application to     */
  848.            /* kill this thread when the user requests so.  Modifications   */
  849.            /* may wish to be made to enable clean up of thread operations. */
  850.            /*                                                              */
  851.            /* if(WinPeekMsg(hAB, (PQMSG)&qmsg, hWnd, WM_QUIT, WM_QUIT, PM_NOREMOVE)) */
  852.            /*    return(0L);                                               */
  853.            /*                                                              */
  854. /* Query remote printer pulldown - rexec server lpq -Pprinter command */
  855.           
  856.           /* After processing user defined code, post a WM_QUIT message    */
  857.           /* to terminate the thread                                       */
  858.            WinPostMsg(hWndFQUERYREMOTEPRINTERObject, WM_QUIT, 0L, 0L);
  859.            break;
  860.  
  861.       case WM_CREATE:
  862.            /* Post a message to start user defined code after startup      */
  863.            WinPostMsg(hWnd, WM_USER_DEFINED_CODE, 0L, 0L);
  864.            break; /* End of WM_CREATE */
  865.  
  866.       default:
  867.            /* For any message for which you don't specifically provide a   */
  868.            /* service routine, you should return the message to PM using   */
  869.            /* the WinDefWindowProc function.                               */
  870.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  871.            break;  /* End of default */
  872.      } 
  873.    return(0L);
  874. } /* End of FQUERYREMOTEPRINTERObjWndProc */
  875.  
  876.  
  877.  
  878.  
  879. /***************************************************************************/
  880. /*                                                                         */
  881. /* cwRegisterClass Function                                                */
  882. /*                                                                         */
  883. /* The following function registers all the classes of all the windows     */
  884. /* associated with this application. The function returns TRUE if it is    */
  885. /* successful, otherwise it returns FALSE.                                 */
  886. /*                                                                         */
  887. /***************************************************************************/
  888.  
  889. INT cwRegisterClass()
  890. {
  891.  CLASSINFO ci;
  892.  INT rc;
  893.  
  894.  strcpy(szAppName, "LAPRINT");
  895.  rc = WinRegisterClass(hAB,             /* Anchor block handle             */
  896.                       (PCH)szAppName,   /* Name of class being registered  */
  897.                       (PFNWP)WndProc,   /* Window procedure for class      */
  898.                       CS_SIZEREDRAW ,
  899.                       12*sizeof(char FAR *));
  900.  if (rc == FALSE)
  901.    return(FALSE);
  902.  
  903.  WinQueryClassInfo(hAB, WC_ENTRYFIELD, (PCLASSINFO)&ci);
  904.  pfnEditWndProc = ci.pfnWindowProc;
  905.  rc = WinRegisterClass(hAB, "UDAlpha", UDCharWndProc, CS_SIZEREDRAW, 
  906.                         ci.cbWindowData + sizeof(PVOID));
  907.  if (rc == FALSE)
  908.    return(FALSE);
  909.  
  910.  return(TRUE);
  911. } /* End of cwRegisterClass */
  912.  
  913.  
  914.  
  915. /***************************************************************************/
  916. /*                                                                         */
  917. /* cwCreateWindow Function                                                 */
  918. /*                                                                         */
  919. /* The following function is used to create a window (the main window,     */
  920. /* a child window, an icon window, etc.) and set it's initial size and     */
  921. /* position. It returns the handle to the frame window.                    */
  922. /*                                                                         */
  923. /***************************************************************************/
  924.  
  925. HWND cwCreateWindow(
  926.    HWND   hWndParent,  /* Handle to the parent of the window to be created */
  927.    ULONG  ctldata,     /* Frame control flags for the window               */
  928.    PCH    appname,     /* Class name of the window                         */
  929.    PCH    title,       /* Title of the window                              */
  930.    USHORT ResID,       /* Resource id value                                */
  931.    INT    x,           /* Initial horizontal and vertical location         */
  932.    INT    y,
  933.    INT    cx,          /* Initial width and height of the window           */
  934.    INT    cy, 
  935.    PHWND  hWndClient,  /* Handle to the client area of the window          */
  936.    ULONG  lfStyle,     /* Frame window style                               */
  937.    USHORT uSizeStyle)  /* User defined size and location flags             */
  938. {
  939.    USHORT rc;            /* accepts return codes from function calls       */
  940.    HWND   hWndFrame;     /* local handle to created window frame           */
  941.    USHORT SizeStyle;     /* local window positioning options               */
  942.    CHAR   MsgBuffer[80]; /* buffer for error messages                      */
  943.    HPS    hPS;           /* handle to a presentation space                 */
  944.    int    xmod, ymod;    /* modifiers for sizing                           */
  945.    #define DLGXMOD  4    /* Dialog units X modulo */
  946.    #define DLGYMOD  8    /* Dialog units Y modulo */
  947.    FONTMETRICS fm;       /* structure for determing modifiers              */
  948.    /* Create the frame window                                              */
  949.    hWndFrame = WinCreateStdWindow(hWndParent,  /* parent of window         */
  950.                                   lfStyle,     /* frame window style       */
  951.                                   &ctldata,    /* frame flags              */
  952.                                   appname,     /* class name               */
  953.                                   title,       /* window title             */
  954.                                   0L,          /* client window style      */
  955.                                   0,           /* module for resources     */
  956.                                   ResID,       /* resource id              */
  957.                                   (HWND FAR *)hWndClient); /* client handle*/
  958.  
  959.    /* if hWndFrame is NULL, an error occured when opening the window,      */
  960.    /*     notify the user and exit this function                           */
  961.    if(hWndFrame == 0)
  962.      {
  963.       WinLoadString(hAB, 0, IDS_ERR_WINDOW_CREATE, 80, MsgBuffer);
  964.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  965.                     0, 0, MB_OK|MB_ICONEXCLAMATION);
  966.       return((HWND)0);
  967.      }
  968.  
  969.    /* set up size options                                                  */
  970.    SizeStyle = SWP_ACTIVATE | SWP_ZORDER | uSizeStyle;
  971.  
  972.    /* if the height, width, intial x or initial y values are non-zero,     */
  973.    /*     then we will need to set up the modifiers for size and location  */
  974.    if((cx > 0) || (cy > 0) ||
  975.       (x > 0)  || (y > 0))
  976.      {
  977.       hPS = WinGetPS(HWND_DESKTOP);
  978.       GpiQueryFontMetrics(hPS, (LONG)sizeof(FONTMETRICS), &fm);
  979.       xmod = (INT)fm.lAveCharWidth;
  980.       ymod = (INT)fm.lMaxBaselineExt;
  981.       WinReleasePS(hPS);
  982.      }
  983.    /* if either the width or the height are non-zero, then the size of the */
  984.    /*     created window will be changed, set SizeStyle accordingly        */
  985.    if((cx > 0) || (cy > 0))
  986.      SizeStyle |= SWP_SIZE;
  987.    /* set the size and position of the window and activate it              */
  988.    rc = WinSetWindowPos(hWndFrame, HWND_TOP, 0, 0,
  989.                         (USHORT)(cx * xmod)/DLGXMOD,
  990.                         (USHORT)(cy * ymod)/DLGYMOD, SizeStyle);
  991.  
  992.    /* if the either the intial x or y position of the window is non-zero,  */
  993.    /*    set the window to its new position                                */
  994.    if((x > 0) || (y > 0))
  995.      rc = WinSetWindowPos(hWndFrame, HWND_TOP,
  996.                           (USHORT)(x * xmod)/DLGXMOD,
  997.                           (USHORT)(y * ymod)/DLGYMOD, 0, 0, SWP_MOVE);
  998.    
  999.    /* if rc is not set to TRUE then WinSetWindowPos failed, notify the user*/
  1000.    /*     and exit this function                                           */
  1001.    if(!rc)
  1002.      {
  1003.       WinLoadString(hAB, 0, IDS_ERR_WINDOW_POS, 80, MsgBuffer);
  1004.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  1005.                     0, 0, MB_OK|MB_ICONEXCLAMATION);
  1006.       return((HWND)0);
  1007.      }
  1008.  
  1009.    /* return the handle to the frame window                                */
  1010.    return(hWndFrame);
  1011. }  /* End of cwCreateWindow */
  1012.  
  1013.  
  1014. VOID FAR FPRINTObjFunction()
  1015. {
  1016.  QMSG lqmsg;  /* MSG structure to store your messages                      */
  1017.  HAB  lhAB;   /* Handle to the Anchor Block                                */
  1018.  HMQ  lhMQ;   /* Handle to the Message Queue                               */
  1019.  
  1020.  /* Initialize the Presentation Manager facilities for use by this         */
  1021.  /* application, return the handle to our anchor block                     */
  1022.  lhAB = WinInitialize(0);
  1023.  
  1024.  /* Create a message queue for this application                            */
  1025.  lhMQ = WinCreateMsgQueue(lhAB, 0);
  1026.  strcpy(szFPRINTObjAppName, "FPRINT");
  1027.  WinRegisterClass(hAB, (PCH)szFPRINTObjAppName,
  1028.                   (PFNWP)FPRINTObjWndProc,
  1029.                   0L, 0);
  1030.  
  1031.  hWndFPRINTObject = WinCreateWindow(HWND_OBJECT, szFPRINTObjAppName,
  1032.                                 0, 0L, 0, 0, 0, 0, 0,
  1033.                                 HWND_TOP, 0, 0, 0);
  1034.  
  1035.  cwEnableMenuItem(hWndFrame, IDM_F_PRINT, FALSE);
  1036.  
  1037.  while(WinGetMsg(lhAB, (PQMSG)&lqmsg, 0, 0, 0))
  1038.        WinDispatchMsg(lhAB,(PQMSG)&lqmsg);
  1039.  
  1040.  cwEnableMenuItem(hWndFrame, IDM_F_PRINT, TRUE);
  1041.  
  1042.  /* Perform clean up before exiting application                            */
  1043.  WinDestroyWindow(hWndFPRINTObject); /* Destroy the frame window */
  1044.  WinDestroyMsgQueue(lhMQ);      /* Destroy this application's message queue */
  1045.  DosEnterCritSec();
  1046.  WinPostMsg(hWndFrame, WM_FREE_MEM, MPFROMP(FPRINTObjSel), 0L);
  1047.  WinTerminate(lhAB);                 /* Terminate this thread's use of the */
  1048.                                      /* Presentation Manager resources     */
  1049.  _endthread();
  1050. }
  1051.  
  1052. VOID FAR FSELECTDID_PRINTObjFunction()
  1053. {
  1054.  QMSG lqmsg;  /* MSG structure to store your messages                      */
  1055.  HAB  lhAB;   /* Handle to the Anchor Block                                */
  1056.  HMQ  lhMQ;   /* Handle to the Message Queue                               */
  1057.  
  1058.  /* Initialize the Presentation Manager facilities for use by this         */
  1059.  /* application, return the handle to our anchor block                     */
  1060.  lhAB = WinInitialize(0);
  1061.  
  1062.  /* Create a message queue for this application                            */
  1063.  lhMQ = WinCreateMsgQueue(lhAB, 0);
  1064.  strcpy(szFSELECTDID_PRINTObjAppName, "FSELECTDID_PRINT");
  1065.  WinRegisterClass(hAB, (PCH)szFSELECTDID_PRINTObjAppName,
  1066.                   (PFNWP)FSELECTDID_PRINTObjWndProc,
  1067.                   0L, 0);
  1068.  
  1069.  hWndFSELECTDID_PRINTObject = WinCreateWindow(HWND_OBJECT, szFSELECTDID_PRINTObjAppName,
  1070.                                 0, 0L, 0, 0, 0, 0, 0,
  1071.                                 HWND_TOP, 0, 0, 0);
  1072.  
  1073.  cwEnableMenuItem(hWndFrame, IDM_F_PRINT, FALSE);
  1074.  
  1075.  while(WinGetMsg(lhAB, (PQMSG)&lqmsg, 0, 0, 0))
  1076.        WinDispatchMsg(lhAB,(PQMSG)&lqmsg);
  1077.  
  1078.  cwEnableMenuItem(hWndFrame, IDM_F_PRINT, TRUE);
  1079.  
  1080.  /* Perform clean up before exiting application                            */
  1081.  WinDestroyWindow(hWndFSELECTDID_PRINTObject); /* Destroy the frame window */
  1082.  WinDestroyMsgQueue(lhMQ);      /* Destroy this application's message queue */
  1083.  DosEnterCritSec();
  1084.  WinPostMsg(hWndFrame, WM_FREE_MEM, MPFROMP(FSELECTDID_PRINTObjSel), 0L);
  1085.  WinTerminate(lhAB);                 /* Terminate this thread's use of the */
  1086.                                      /* Presentation Manager resources     */
  1087.  _endthread();
  1088. }
  1089.  
  1090. VOID FAR FQUERYREMOTEPRINTERObjFunction()
  1091. {
  1092.  QMSG lqmsg;  /* MSG structure to store your messages                      */
  1093.  HAB  lhAB;   /* Handle to the Anchor Block                                */
  1094.  HMQ  lhMQ;   /* Handle to the Message Queue                               */
  1095.  
  1096.  /* Initialize the Presentation Manager facilities for use by this         */
  1097.  /* application, return the handle to our anchor block                     */
  1098.  lhAB = WinInitialize(0);
  1099.  
  1100.  /* Create a message queue for this application                            */
  1101.  lhMQ = WinCreateMsgQueue(lhAB, 0);
  1102.  strcpy(szFQUERYREMOTEPRINTERObjAppName, "FQUERYREMOTEPRINTER");
  1103.  WinRegisterClass(hAB, (PCH)szFQUERYREMOTEPRINTERObjAppName,
  1104.                   (PFNWP)FQUERYREMOTEPRINTERObjWndProc,
  1105.                   0L, 0);
  1106.  
  1107.  hWndFQUERYREMOTEPRINTERObject = WinCreateWindow(HWND_OBJECT, szFQUERYREMOTEPRINTERObjAppName,
  1108.                                 0, 0L, 0, 0, 0, 0, 0,
  1109.                                 HWND_TOP, 0, 0, 0);
  1110.  
  1111.  cwEnableMenuItem(hWndFrame, IDM_F_QUERYREMOTEPRINTER, FALSE);
  1112.  
  1113.  while(WinGetMsg(lhAB, (PQMSG)&lqmsg, 0, 0, 0))
  1114.        WinDispatchMsg(lhAB,(PQMSG)&lqmsg);
  1115.  
  1116.  cwEnableMenuItem(hWndFrame, IDM_F_QUERYREMOTEPRINTER, TRUE);
  1117.  
  1118.  /* Perform clean up before exiting application                            */
  1119.  WinDestroyWindow(hWndFQUERYREMOTEPRINTERObject); /* Destroy the frame window */
  1120.  WinDestroyMsgQueue(lhMQ);      /* Destroy this application's message queue */
  1121.  DosEnterCritSec();
  1122.  WinPostMsg(hWndFrame, WM_FREE_MEM, MPFROMP(FQUERYREMOTEPRINTERObjSel), 0L);
  1123.  WinTerminate(lhAB);                 /* Terminate this thread's use of the */
  1124.                                      /* Presentation Manager resources     */
  1125.  _endthread();
  1126. }
  1127.  
  1128.  
  1129. /* cwCheckPulldown accepts as input a handle to a frame window that a      */
  1130. /*    pulldown belongs to and the id value of this pulldown item.  It      */
  1131. /*    determines whether this item is checked or unchecked; if it is       */
  1132. /*    unchecked the pulldown item is checked and TRUE is returned, if it   */
  1133. /*    is checked the pulldown item is unchecked and FALSE is returned.     */
  1134.  
  1135. USHORT cwCheckPulldown(hWnd, item)
  1136. HWND   hWnd;     /* handle to the frame window                             */
  1137. USHORT item;     /* id value of the item to be checked/unchecked           */
  1138. {
  1139.    MENUITEM Menu;  /* structure to store attributes of menu item           */
  1140.  
  1141.    /* query the system for the attributes of this particular menu item     */
  1142.    WinSendMsg(WinWindowFromID(hWnd, FID_MENU),
  1143.               MM_QUERYITEM,
  1144.               MPFROM2SHORT(item, TRUE),
  1145.               MPFROMP((PMENUITEM)&Menu));
  1146.  
  1147.    /* if this menu item's MIA_CHECKED bit is on, uncheck the menu item,    */
  1148.    /*    else, check the menu item                                         */
  1149.    Menu.afAttribute = ~Menu.afAttribute;
  1150.    WinSendMsg(WinWindowFromID(hWnd, FID_MENU),
  1151.              MM_SETITEMATTR, MPFROM2SHORT(item, TRUE),
  1152.              MPFROM2SHORT(MIA_CHECKED, Menu.afAttribute));
  1153.    return(Menu.afAttribute & MIA_CHECKED);
  1154. } /* End of cwCheckPulldown function */
  1155.  
  1156. INT cwFillFileListBox(hWnd, szFileSpec, ListID)
  1157. HWND hWnd;
  1158. PSZ szFileSpec;
  1159. INT  ListID;
  1160. {
  1161.  FILEFINDBUF findbuf ;
  1162.  HDIR        hDir = 1 ;
  1163.  USHORT      usSearchCount = 1 ;
  1164.  
  1165.  WinSendDlgItemMsg(hWnd, ListID, LM_DELETEALL, 0, 0) ;
  1166.  DosFindFirst(szFileSpec, &hDir, 0x0007, &findbuf, sizeof(findbuf),
  1167.                               &usSearchCount, 0L) ;
  1168.  while(usSearchCount)
  1169.    {
  1170.     WinSendDlgItemMsg(hWnd, ListID, LM_INSERTITEM,
  1171.                       MPFROM2SHORT(LIT_SORTASCENDING, 0),
  1172.                       MPFROMP(findbuf.achName));
  1173.  
  1174.     DosFindNext(hDir, &findbuf, sizeof(findbuf), &usSearchCount) ;
  1175.    }
  1176.  return(1);
  1177. }
  1178.  
  1179.  
  1180. /***************************************************************************/
  1181. /*  cwAlphaValidate Function                                               */
  1182. /*                                                                         */
  1183. /*  Returns TRUE if the string is acceptable, otherwise returns FALSE      */
  1184. /*                                                                         */
  1185. /***************************************************************************/
  1186. INT cwAlphaValidate(string)
  1187. CHAR *string;
  1188. {
  1189.  int count;
  1190.  for(count = 0; count <= strlen(string)-1; count++)
  1191.     if(!isalnum((int)string[count]))
  1192.       if(!isspace((int)string[count]))
  1193.          return(FALSE);
  1194.  return(TRUE);
  1195. }
  1196.  
  1197. /***************************************************************************/
  1198. /*  UDCharWndProc                                                          */
  1199. /*                                                                         */
  1200. /*  Is used on subclassing edit fields for character validation            */
  1201. /*                                                                         */
  1202. /***************************************************************************/
  1203. MRESULT EXPENTRY UDCharWndProc(hWnd, message, mp1, mp2)
  1204. HWND hWnd;
  1205. USHORT message;
  1206. MPARAM mp1;
  1207. MPARAM mp2;
  1208. { 
  1209.  static CHAR key;
  1210.  switch(message)
  1211.    {
  1212.     case WM_CHAR:
  1213.          if(SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
  1214.          {
  1215.            key = ((CHAR)SHORT1FROMMP(mp2));
  1216.            if((int)key == 0x20)
  1217.            {
  1218.              WinAlarm(HWND_DESKTOP,
  1219.                       WA_ERROR);
  1220.              return((MRESULT)TRUE);
  1221.            }
  1222.            break;
  1223.          }
  1224.          if(SHORT1FROMMP(mp1) & KC_CHAR)
  1225.            {
  1226.             key = (CHAR)SHORT1FROMMP(mp2);
  1227.             if(isalnum((int)key))
  1228.               return(pfnEditWndProc(hWnd, message, mp1, mp2));
  1229.             else
  1230.              {
  1231.               WinAlarm(HWND_DESKTOP, WA_ERROR);
  1232.               return((MRESULT)TRUE);
  1233.              }
  1234.            }
  1235.          break;
  1236.  
  1237.     case WM_TRANSLATEACCEL:
  1238.          return((MRESULT)FALSE);
  1239.          break;
  1240.    } 
  1241.  return(pfnEditWndProc(hWnd, message, mp1, mp2));
  1242. } /* End of UDCharWndProc */
  1243.  
  1244. /***************************************************************************/
  1245. /*  cwCenter Function                                                      */
  1246. /*                                                                         */
  1247. /*  Centers a dialog box on the client area of the caller                  */
  1248. /*                                                                         */
  1249. /***************************************************************************/
  1250.  
  1251. INT cwCenter(hWnd, hWndParent)                                              
  1252. HWND hWnd;         /* handle of the window to be centered                  */
  1253. HWND hWndParent;   /* handle of the window to center on                    */
  1254. {
  1255.   ULONG  SrcX, SrcY;                /* Center of parent                    */
  1256.   INT    ix, iy;                    /* Destination points                  */
  1257.   SWP    DlgSwp, ParentSwp;         /* Set window position structures      */
  1258.   ULONG  ScreenWidth, ScreenHeight; /* Dimensions of the DESKTOP           */
  1259.   POINTL pt;                        /* Point                               */
  1260.  
  1261.   /* Determine the width and height of the DESKTOP so the dialog box       */
  1262.   /* will not be positioned to a point off of the screen.                  */
  1263.   ScreenWidth  = (ULONG)WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
  1264.   ScreenHeight = (ULONG)WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
  1265.  
  1266.   /* Query width and depth of dialog box                                   */
  1267.   WinQueryWindowPos(hWnd, (PSWP)&DlgSwp);
  1268.  
  1269.   /* Query width and depth of caller                                       */
  1270.   WinQueryWindowPos(hWndParent, (PSWP)&ParentSwp);
  1271.  
  1272.   /* Map the point parent points to the Desktop                            */
  1273.   pt.x = ParentSwp.x;
  1274.   pt.y = ParentSwp.y;
  1275.  
  1276.   /* Convert the point from having our window as the origin to having      */
  1277.   /* the DESKTOP as the origin                                             */
  1278.   WinMapWindowPoints(hWndParent, HWND_DESKTOP, &pt, 1);
  1279.  
  1280.   SrcX = pt.x + (ParentSwp.cx / 2);
  1281.   SrcY = pt.y + (ParentSwp.cy / 2);
  1282.  
  1283.   /* Determine the point to move the dialog box to                         */
  1284.   ix = (INT)(SrcX - (DlgSwp.cx / 2));
  1285.   iy = (INT)(SrcY - (DlgSwp.cy / 2));
  1286.  
  1287.   /* if either point is less than zero, then set that point to zero        */
  1288.   /* so the dialog box will not be positoned off of the window             */
  1289.   ix = (ix < 0) ? 0 : ix;
  1290.   iy = (iy < 0) ? 0 : iy;
  1291.  
  1292.   /* if either point plus the height or width of the dialog box is         */
  1293.   /* greater than the height or width of the screen adjust point           */
  1294.   if(((ULONG)ix + DlgSwp.cx) > ScreenWidth)
  1295.     ix = (INT)(ScreenWidth - DlgSwp.cx);
  1296.   if(((ULONG)iy + DlgSwp.cy) > ScreenHeight)
  1297.     iy = (INT)(ScreenHeight - DlgSwp.cy);
  1298.  
  1299.   /* move the dialog box                                                   */
  1300.   return(WinSetWindowPos(hWnd, HWND_TOP, ix, iy, 0, 0, SWP_MOVE));
  1301. }
  1302.  
  1303. INT cwEnableMenuItem(hWnd, idval, bool)
  1304. HWND hWnd;
  1305. INT  idval;
  1306. INT  bool;
  1307. {
  1308.  INT rc;
  1309.  
  1310.  rc = (INT)WinSendMsg(WinWindowFromID(hWnd, FID_MENU),
  1311.                       MM_SETITEMATTR, MPFROM2SHORT(idval, TRUE),
  1312.                       MPFROM2SHORT(MIA_DISABLED,
  1313.                       bool ? ~MIA_DISABLED : MIA_DISABLED));
  1314.  return(rc);
  1315. }
  1316.  
  1317. INT cwFillDirListBox(hWndDlg, id, targetid)
  1318. HWND hWndDlg;
  1319. USHORT id;
  1320. USHORT targetid;
  1321. {
  1322.  static CHAR buffer[10];
  1323.  FILEFINDBUF findbuf;
  1324.  HDIR        hDir = 1;
  1325.  SHORT       sDrive;
  1326.  USHORT      usDriveNum, usSearchCount = 1;
  1327.  ULONG       ulDriveMap;
  1328.  SHORT       rc;
  1329.  CHAR        szBuffer[128];
  1330.  USHORT      usPathLen;
  1331.  
  1332.  WinSendDlgItemMsg(hWndDlg, id, LM_DELETEALL, 0, 0) ;
  1333.  rc = DosFindFirst("*.*", &hDir, 0x0017, &findbuf,
  1334.                    sizeof(findbuf), &usSearchCount, 0L);
  1335.  if(rc!=0)
  1336.    return( -1 );
  1337.       
  1338.  while(usSearchCount)
  1339.     {
  1340.      if(findbuf.attrFile & 0x0010 &&
  1341.         (findbuf.achName [0] != '.' || findbuf.achName [1]))
  1342.                WinSendDlgItemMsg(hWndDlg, id, LM_INSERTITEM,
  1343.                                  MPFROM2SHORT(LIT_SORTASCENDING, 0),
  1344.                                  MPFROMP(findbuf.achName));
  1345.      DosFindNext(hDir, &findbuf, sizeof findbuf, &usSearchCount) ;
  1346.     }
  1347.  
  1348.  rc = DosQCurDisk(&usDriveNum, &ulDriveMap);
  1349.  for(sDrive = 0; sDrive < 26; sDrive++)
  1350.    if(ulDriveMap & 1L << sDrive)
  1351.      {
  1352.       sprintf(buffer,"[%c:]", (CHAR)sDrive + 'A');
  1353.       WinSendDlgItemMsg(hWndDlg, id, LM_INSERTITEM,
  1354.                         MPFROM2SHORT(LIT_END, 0),
  1355.                         MPFROMP(buffer)) ;
  1356.      }
  1357.  usPathLen = sizeof(szBuffer);
  1358.  DosQCurDir(usDriveNum, &szBuffer[3], &usPathLen);
  1359.  szBuffer[0] = '@' + usDriveNum;
  1360.  szBuffer[1] = ':';
  1361.  szBuffer[2] = '\\';
  1362.  WinSetDlgItemText(hWndDlg, targetid, szBuffer);
  1363. }
  1364.  
  1365.  
  1366.  
  1367. /* This function initializes the states of all dialog box radio buttons    */
  1368. /* and check boxes that have had their initial status set to true          */
  1369. INT cwSetInitDlgStatus(hWnd)
  1370. HWND hWnd;
  1371. {
  1372.   CFGOPENStruct FAR *Cfgopen;
  1373.   CFGSAVEStruct FAR *Cfgsave;
  1374.   FSELECTStruct FAR *Fselect;
  1375.   SELPRTERStruct FAR *Selprter;
  1376.   PRTERADDStruct FAR *Prteradd;
  1377.   PRTERDELStruct FAR *Prterdel;
  1378.   PRTCHANGStruct FAR *Prtchang;
  1379.   SELSERVStruct FAR *Selserv;
  1380.   ADDSERVStruct FAR *Addserv;
  1381.   DELSERVStruct FAR *Delserv;
  1382.   CHNGSERVStruct FAR *Chngserv;
  1383.   QUERYPRTStruct FAR *Queryprt;
  1384.  
  1385.   OFFSETOF(Cfgopen) = 0;
  1386.   DosAllocSeg(sizeof(CFGOPENStruct), (PSEL)&SELECTOROF(Cfgopen), 0);
  1387.   lmemset(Cfgopen, 0x00, sizeof(CFGOPENStruct));
  1388.   WinSetWindowULong(hWnd, OFFSET_CFGOPEN, (ULONG)Cfgopen);
  1389.  
  1390.   OFFSETOF(Cfgsave) = 0;
  1391.   DosAllocSeg(sizeof(CFGSAVEStruct), (PSEL)&SELECTOROF(Cfgsave), 0);
  1392.   lmemset(Cfgsave, 0x00, sizeof(CFGSAVEStruct));
  1393.   WinSetWindowULong(hWnd, OFFSET_CFGSAVE, (ULONG)Cfgsave);
  1394.  
  1395.   OFFSETOF(Fselect) = 0;
  1396.   DosAllocSeg(sizeof(FSELECTStruct), (PSEL)&SELECTOROF(Fselect), 0);
  1397.   lmemset(Fselect, 0x00, sizeof(FSELECTStruct));
  1398.   WinSetWindowULong(hWnd, OFFSET_FSELECT, (ULONG)Fselect);
  1399.  
  1400.   OFFSETOF(Selprter) = 0;
  1401.   DosAllocSeg(sizeof(SELPRTERStruct), (PSEL)&SELECTOROF(Selprter), 0);
  1402.   lmemset(Selprter, 0x00, sizeof(SELPRTERStruct));
  1403.   WinSetWindowULong(hWnd, OFFSET_SELPRTER, (ULONG)Selprter);
  1404.  
  1405.   OFFSETOF(Prteradd) = 0;
  1406.   DosAllocSeg(sizeof(PRTERADDStruct), (PSEL)&SELECTOROF(Prteradd), 0);
  1407.   lmemset(Prteradd, 0x00, sizeof(PRTERADDStruct));
  1408.   WinSetWindowULong(hWnd, OFFSET_PRTERADD, (ULONG)Prteradd);
  1409.  
  1410.   OFFSETOF(Prterdel) = 0;
  1411.   DosAllocSeg(sizeof(PRTERDELStruct), (PSEL)&SELECTOROF(Prterdel), 0);
  1412.   lmemset(Prterdel, 0x00, sizeof(PRTERDELStruct));
  1413.   WinSetWindowULong(hWnd, OFFSET_PRTERDEL, (ULONG)Prterdel);
  1414.  
  1415.   OFFSETOF(Prtchang) = 0;
  1416.   DosAllocSeg(sizeof(PRTCHANGStruct), (PSEL)&SELECTOROF(Prtchang), 0);
  1417.   lmemset(Prtchang, 0x00, sizeof(PRTCHANGStruct));
  1418.   WinSetWindowULong(hWnd, OFFSET_PRTCHANG, (ULONG)Prtchang);
  1419.  
  1420.   OFFSETOF(Selserv) = 0;
  1421.   DosAllocSeg(sizeof(SELSERVStruct), (PSEL)&SELECTOROF(Selserv), 0);
  1422.   lmemset(Selserv, 0x00, sizeof(SELSERVStruct));
  1423.   WinSetWindowULong(hWnd, OFFSET_SELSERV, (ULONG)Selserv);
  1424.   Selserv->ckSelected_UNIX_Format = FALSE;
  1425.  
  1426.   OFFSETOF(Addserv) = 0;
  1427.   DosAllocSeg(sizeof(ADDSERVStruct), (PSEL)&SELECTOROF(Addserv), 0);
  1428.   lmemset(Addserv, 0x00, sizeof(ADDSERVStruct));
  1429.   WinSetWindowULong(hWnd, OFFSET_ADDSERV, (ULONG)Addserv);
  1430.  
  1431.   OFFSETOF(Delserv) = 0;
  1432.   DosAllocSeg(sizeof(DELSERVStruct), (PSEL)&SELECTOROF(Delserv), 0);
  1433.   lmemset(Delserv, 0x00, sizeof(DELSERVStruct));
  1434.   WinSetWindowULong(hWnd, OFFSET_DELSERV, (ULONG)Delserv);
  1435.  
  1436.   OFFSETOF(Chngserv) = 0;
  1437.   DosAllocSeg(sizeof(CHNGSERVStruct), (PSEL)&SELECTOROF(Chngserv), 0);
  1438.   lmemset(Chngserv, 0x00, sizeof(CHNGSERVStruct));
  1439.   WinSetWindowULong(hWnd, OFFSET_CHNGSERV, (ULONG)Chngserv);
  1440.  
  1441.   OFFSETOF(Queryprt) = 0;
  1442.   DosAllocSeg(sizeof(QUERYPRTStruct), (PSEL)&SELECTOROF(Queryprt), 0);
  1443.   lmemset(Queryprt, 0x00, sizeof(QUERYPRTStruct));
  1444.   WinSetWindowULong(hWnd, OFFSET_QUERYPRT, (ULONG)Queryprt);
  1445.  
  1446. }
  1447.  
  1448. INT cwFreeDlgMemory(hWnd)
  1449. HWND hWnd;
  1450. {
  1451.   CFGOPENStruct FAR *Cfgopen;
  1452.   CFGSAVEStruct FAR *Cfgsave;
  1453.   FSELECTStruct FAR *Fselect;
  1454.   SELPRTERStruct FAR *Selprter;
  1455.   PRTERADDStruct FAR *Prteradd;
  1456.   PRTERDELStruct FAR *Prterdel;
  1457.   PRTCHANGStruct FAR *Prtchang;
  1458.   SELSERVStruct FAR *Selserv;
  1459.   ADDSERVStruct FAR *Addserv;
  1460.   DELSERVStruct FAR *Delserv;
  1461.   CHNGSERVStruct FAR *Chngserv;
  1462.   QUERYPRTStruct FAR *Queryprt;
  1463.  
  1464.   Cfgopen = (CFGOPENStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_CFGOPEN);
  1465.   DosFreeSeg(SELECTOROF(Cfgopen));
  1466.   Cfgsave = (CFGSAVEStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_CFGSAVE);
  1467.   DosFreeSeg(SELECTOROF(Cfgsave));
  1468.   Fselect = (FSELECTStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_FSELECT);
  1469.   DosFreeSeg(SELECTOROF(Fselect));
  1470.   Selprter = (SELPRTERStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_SELPRTER);
  1471.   DosFreeSeg(SELECTOROF(Selprter));
  1472.   Prteradd = (PRTERADDStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_PRTERADD);
  1473.   DosFreeSeg(SELECTOROF(Prteradd));
  1474.   Prterdel = (PRTERDELStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_PRTERDEL);
  1475.   DosFreeSeg(SELECTOROF(Prterdel));
  1476.   Prtchang = (PRTCHANGStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_PRTCHANG);
  1477.   DosFreeSeg(SELECTOROF(Prtchang));
  1478.   Selserv = (SELSERVStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_SELSERV);
  1479.   DosFreeSeg(SELECTOROF(Selserv));
  1480.   Addserv = (ADDSERVStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_ADDSERV);
  1481.   DosFreeSeg(SELECTOROF(Addserv));
  1482.   Delserv = (DELSERVStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_DELSERV);
  1483.   DosFreeSeg(SELECTOROF(Delserv));
  1484.   Chngserv = (CHNGSERVStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_CHNGSERV);
  1485.   DosFreeSeg(SELECTOROF(Chngserv));
  1486.   Queryprt = (QUERYPRTStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_QUERYPRT);
  1487.   DosFreeSeg(SELECTOROF(Queryprt));
  1488. }
  1489.  
  1490. void lmemset(memptr, value, size)
  1491. void FAR *memptr;
  1492. char     value;
  1493. int      size;
  1494. {
  1495.    char FAR *chrptr = memptr;
  1496.  
  1497.    while (size--)
  1498.       *chrptr++ = value;
  1499. }
  1500.  
  1501. /* LONGSTRCPY - is a functional equivalent to the C library routine        */
  1502. /*              strcpy, with the exception that it takes far pointers to   */
  1503. /*              to character strings as it's parameters.                   */
  1504. PSZ longstrcpy(target, source)
  1505. PSZ target;
  1506. PSZ source;
  1507. {
  1508.  PSZ z = target;
  1509.  while(*target++ = *source++);
  1510.  return(z);
  1511. }
  1512.  
  1513.  
  1514.  
  1515.