home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / QPROC.ZIP / QPAPI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-18  |  21.8 KB  |  808 lines
  1. /*****************************************************************/ 
  2. /**             Microsoft LAN Manager            **/ 
  3. /**           Copyright(c) Microsoft Corp., 1985-1990        **/ 
  4. /*****************************************************************/ 
  5. /****************************** Module Header ******************************\
  6.  
  7. Module Name: QPAPI.C
  8.  
  9. This module contains the default PM Print Queue Processor dynlink entry
  10. points.
  11.  
  12. ENTRY POINTS:   SplQpOpen, SplQpPrint, SplQpClose, SplQpControl,
  13.                 SplQpQueryDt, SplQpInstall
  14.  
  15. History:
  16.  21-Aug-88 [stevewo]  Created.
  17.  14-Feb-90 [thomaspa] DBCS fixes.
  18.  
  19. \***************************************************************************/
  20.  
  21. #define INCL_DEV
  22. #define INCL_GPIMETAFILES
  23. #define INCL_GPICONTROL
  24. #define INCL_DOSFILEMGR
  25. #define INCL_SHLERRORS
  26. #define INCL_WINDIALOGS
  27. #define INCL_GPIP
  28. #define INCL_DEVP
  29. #include "pmprint.h"
  30. #include <netlib.h>
  31. #include <strapi.h>
  32. #include <makenear.h>
  33.  
  34.  
  35.  
  36. /***************************** Public  Function ****************************\
  37. *
  38. *
  39. * SplQpQueryDt - return list of data types supported by this queue processor
  40. *
  41. *
  42. \***************************************************************************/
  43.  
  44. BOOL SPLENTRY SplQpQueryDt( pcDataType, rgpszDataType )
  45. PLONG pcDataType;
  46. PSZ FAR *rgpszDataType;
  47.  
  48. /* Description: ************************************************************\
  49.  
  50. History:
  51.  21-Aug-88 [stevewo]  Created
  52. \***************************************************************************/
  53. {
  54.     USHORT c;
  55.  
  56.     if (!pcDataType) {
  57.         SplLogError(PMERR_INVALID_PARM);
  58.     } else {
  59.         if (*pcDataType > QP_TYPE_NUM)
  60.            *pcDataType = QP_TYPE_NUM;
  61.  
  62.         c = (USHORT)*pcDataType;
  63.         *pcDataType = QP_TYPE_NUM;
  64.  
  65.         if (!c)
  66.             return( TRUE );
  67.  
  68.         if (c != (USHORT)*pcDataType) {
  69.             SplLogError(PMERR_SPL_INV_LENGTH_OR_COUNT);
  70.         } else if (!rgpszDataType || !rgpszDataType[0] || !rgpszDataType[1]) {
  71.             SplLogError(PMERR_INVALID_PARM);
  72.         } else {
  73.             SafeStrcpy( rgpszDataType[QP_TYPE_STD], DT_STD );
  74.             SafeStrcpy( rgpszDataType[QP_TYPE_RAW], DT_RAW );
  75.  
  76.             return( TRUE );
  77.         }
  78.     }
  79.     return( FALSE );
  80. }
  81.  
  82.  
  83. /***************************** Public  Function ****************************\
  84. *
  85. *
  86. * SplQpOpen - Open Queue Process to begin printing
  87. *
  88. *
  89. \***************************************************************************/
  90.  
  91. HPROC SPLENTRY SplQpOpen( cData, pQPDataIn )
  92. LONG cData;
  93. PQPOPENDATA pQPDataIn;
  94.  
  95. /* Description: ************************************************************\
  96.  
  97.  
  98. History:
  99.  21-Aug-88 [stevewo]  Created
  100. \***************************************************************************/
  101. {
  102.     register PQPROCINST pQProc;
  103.     DEVOPENSTRUC OpenData;
  104.     PSQPOPENDATA pSQPData = (PSQPOPENDATA) pQPDataIn;
  105.  
  106.     pQProc = NULL;
  107.  
  108.     if (cData < QPDAT_PROC_PARAMS - 1) {
  109.         SplLogError(PMERR_SPL_INV_LENGTH_OR_COUNT);
  110.         return NULL;
  111.     }
  112.  
  113.     OpenData.pszLogAddress = pQPDataIn[ QPDAT_ADDRESS ];
  114.     OpenData.pszDriverName = pQPDataIn[ QPDAT_DRIVER_NAME ];
  115.     OpenData.pdriv         = (PDRIVDATA)pQPDataIn[ QPDAT_DRIVER_DATA ];
  116.     OpenData.pszComment    = pQPDataIn[ QPDAT_COMMENT ];
  117.  
  118.     if (!(OpenData.pszDataType = pQPDataIn[ QPDAT_DATA_TYPE ] ))
  119.         OpenData.pszDataType = DT_STD;
  120.  
  121.     if (!(OpenData.pszQueueProcParams = pQPDataIn[ QPDAT_PROC_PARAMS ]))
  122.         OpenData.pszQueueProcParams = szNull;
  123.  
  124.     pQProc = CreateQProcInst(&OpenData, ((PSQPOPENDATA)pQPDataIn)->idJobId,
  125.                              ((PSQPOPENDATA)pQPDataIn)->pszQueueName);
  126.  
  127.     return( pQProc ? (HPROC)(USHORT)pQProc : (HPROC)NULL );
  128. }
  129.  
  130.  
  131. /***************************** Public  Function ****************************\
  132. *
  133. *
  134. * SplQpPrint - print a file
  135. *
  136. *
  137. \***************************************************************************/
  138.  
  139. BOOL SPLENTRY SplQpPrint( hQProc, pszFileName )
  140. HPROC hQProc;
  141. PSZ pszFileName;
  142.  
  143. /* Description: ************************************************************\
  144.  
  145.  
  146. History:
  147.  21-Aug-88 [stevewo]  Created
  148. \***************************************************************************/
  149. {
  150.     register PQPROCINST pQProc;
  151.     BOOL result;
  152.  
  153.   EnterSplSem();
  154.     pQProc = ValidateQProcInst( hQProc );
  155.   LeaveSplSem();
  156.  
  157.     result = FALSE;
  158.     DosError( FALSE );
  159.  
  160.     if (pQProc && pszFileName)
  161.         while (pQProc->qparms.cCopies &&
  162.               (result = (BOOL)(*pQProc->pfnPrintFile)( pQProc, pszFileName )))
  163.             pQProc->qparms.cCopies--;
  164.  
  165.     DosError( TRUE );
  166.  
  167.     return( result );
  168. }
  169.  
  170.  
  171.  
  172. /***************************** Public  Function ****************************\
  173. *
  174. *
  175. * SplQpClose - close a queue processor
  176. *
  177. *
  178. \***************************************************************************/
  179.  
  180. BOOL SPLENTRY SplQpClose( hQProc )
  181. HPROC hQProc;
  182.  
  183. /* Description: ************************************************************\
  184.  
  185.  
  186. History:
  187.  21-Aug-88 [stevewo]  Created
  188. \***************************************************************************/
  189. {
  190.     register PQPROCINST pQProc;
  191.     BOOL result = TRUE;
  192.  
  193.   EnterSplSem();
  194.  
  195.     if (pQProc = ValidateQProcInst( hQProc ))
  196.         DestroyQProcInst( pQProc );
  197.     else
  198.         result = FALSE;
  199.  
  200.   LeaveSplSem();
  201.  
  202.     return( result );
  203. }
  204.  
  205.  
  206. /***************************** Public  Function ****************************\
  207. *
  208. *
  209. * SplQpControl - abort, pause or continue the current printing operation
  210. *
  211. *
  212. \***************************************************************************/
  213.  
  214. BOOL SPLENTRY SplQpControl( hQProc, ulControlCode )
  215. HPROC hQProc;
  216. LONG ulControlCode;
  217.  
  218. /* Description: ************************************************************\
  219.  
  220.  
  221. History:
  222.  21-Aug-88 [stevewo]  Created
  223. \***************************************************************************/
  224. {
  225.     register PQPROCINST pQProc;
  226.     BOOL result;
  227.     USHORT  usStopMetaFile=SDW_OFF;
  228.  
  229.   EnterSplSem();
  230.     if (pQProc = ValidateQProcInst( hQProc )) {
  231.         result = TRUE;
  232.         switch( (USHORT)ulControlCode ) {
  233.             case SPLC_PAUSE:
  234.                 if (pQProc->uType == QP_TYPE_STD)
  235.                    while(!GpiSuspendPlay( pQProc->hps ))
  236.                        ; /* The Hursley spooler does this - so we will */
  237.  
  238.                 DosSemSet(&pQProc->semPaused);
  239.                 pQProc->fsStatus |= QP_PAUSED;
  240.                 break;
  241.  
  242.             case SPLC_ABORT:
  243.                 pQProc->fsStatus |= QP_ABORTED;
  244.  
  245.                 if (pQProc->uType == QP_TYPE_STD) {
  246.                     if (pQProc->hps) 
  247.                         GpiSetStopDraw( pQProc->hps, SDW_ON );
  248.                 }
  249.  
  250.                 if (pQProc->hdc) {
  251.                    DevEscape(pQProc->hdc, DEVESC_ABORTDOC, 0L, NULL, 0L, NULL);
  252.                 }
  253.  
  254.                 /* fall through to release job is paused */
  255.  
  256.             case SPLC_CONTINUE:
  257.                 if (pQProc->fsStatus & QP_PAUSED) {
  258.  
  259.                     if (pQProc->uType == QP_TYPE_STD)
  260.                         GpiResumePlay( pQProc->hps );
  261.  
  262.                     DosSemClear(&pQProc->semPaused);
  263.                     pQProc->fsStatus &= ~QP_PAUSED;
  264.                 }
  265.                 break;
  266.  
  267.             default:
  268.                 SplLogError(PMERR_INVALID_PARM);
  269.                 result = FALSE;
  270.                 break;
  271.             }
  272.         }
  273.     else
  274.         result = FALSE;
  275.   LeaveSplSem();
  276.  
  277.     return( result );
  278. }
  279.  
  280.  
  281. /***************************** Public  Function ****************************\
  282. *
  283. *
  284. * SplQpInstall - display installation message
  285. *
  286. *
  287. \***************************************************************************/
  288.  
  289. BOOL EXPENTRY _loadds SplQpInstall( hwnd )
  290. HWND hwnd;
  291. {
  292.     register USHORT us;
  293.  
  294.     us = WinMessageBox(HWND_DESKTOP, hwnd, INSTALL_MSG, INSTALL_CAPTION,
  295.                        0, MB_OK | MB_INFORMATION | MB_MOVEABLE);
  296.     return us && us != MBID_ERROR;
  297. }
  298.  
  299.  
  300.  
  301. PQPROCINST CreateQProcInst(PDEVOPENSTRUC pQProcData,
  302.                            USHORT uJobId, PSZ pszQName)
  303. {
  304.     register PQPROCINST pQProc;
  305.     PSZ psz;
  306.     NPSZ pStr;
  307.     PDRIVDATA   pDriverData;
  308.     USHORT      cb;
  309.     USHORT      cbDriverData;
  310.     USHORT      cbDataType;
  311.     USHORT      cbComment;
  312.     USHORT      cbPortName;
  313.     USHORT      cbDriverName;
  314.     USHORT      cbQName;
  315.     USHORT      uDataType;
  316.     QPPARMS     qp_parms;
  317.     PSZ         pszComment;
  318.  
  319.  
  320.     SplOutSem();
  321.  
  322.     if (pDriverData = pQProcData->pdriv)
  323.         cbDriverData = (USHORT)pDriverData->cb;
  324.     else
  325.         cbDriverData = 0;
  326.  
  327.     cbDataType = 1 + SafeStrlen( psz = pQProcData->pszDataType );
  328.     if (!strcmpf( psz, DT_STD ))
  329.         uDataType = QP_TYPE_STD;
  330.     else
  331.     if (!strcmpf( psz, DT_RAW ))
  332.         uDataType = QP_TYPE_RAW;
  333.     else {
  334.         SplQpMessage(pQProcData->pszLogAddress, SPL_ID_QP_DATATYPE_ERROR,
  335.                      PMERR_SPL_INV_DATATYPE);
  336.         return( NULL );
  337.     }
  338.     cbComment = 1+SafeStrlen(pszComment = pQProcData->pszComment ?
  339.                                        pQProcData->pszComment : (PSZ)szNull);
  340.     cbDriverName = 1+SafeStrlen( pQProcData->pszDriverName );
  341.     cbQName = 1+SafeStrlen(pszQName);
  342.     cbPortName = 1+SafeStrlen( pQProcData->pszLogAddress );
  343.  
  344.     if (!ParseQProcParms( pQProcData->pszQueueProcParams, &qp_parms )) {
  345.         if (SplQpMessage(pQProcData->pszLogAddress, SPL_ID_QP_INVALID_PARAMETER,
  346.                          PMERR_INVALID_PARM) == MBID_CANCEL)
  347.             return NULL;
  348.     }
  349.  
  350.     cb = sizeof( QPROCINST ) + cbDataType + cbComment + cbQName +
  351.                                cbDriverName + cbPortName + cbDriverData;
  352.  
  353.   EnterSplSem();
  354.     if (!(pQProc = (PQPROCINST)AllocSplMem( cb ))) {
  355.       LeaveSplSem();
  356.         SplQpMessage(pQProcData->pszLogAddress, SPL_ID_QP_MEM_ERROR,
  357.                      PMERR_SPL_NO_MEMORY);
  358.         return( NULL );
  359.     }
  360.     memsetf(pQProc, 0, sizeof(QPROCINST));
  361.     pStr = (NPSZ)(pQProc + 1);
  362.  
  363.     pQProc->pNext         = pQProcInstances;
  364.     pQProcInstances       = pQProc;
  365.     pQProc->cb            = cb;
  366.     pQProc->signature     = QP_SIGNATURE;
  367.     pQProc->uPid      = pLocalInfo->pidCurrent;
  368.     pQProc->uJobId      = uJobId;
  369.  
  370.     DosSemClear(&pQProc->semPaused);
  371.  
  372.     pQProc->uType         = uDataType;
  373.     pQProc->hFile         = NULL_HFILE;
  374.     pQProc->pszDataType   = pStr;
  375.     pQProc->pszDocument   = NULL;
  376.     pStr = 1 + (NPSZ)MAKENEAR(EndStrcpy( pStr, pQProcData->pszDataType ));
  377.     pQProc->pszQName      = pStr;
  378.     pStr = 1 + (NPSZ)MAKENEAR(EndStrcpy( pStr, pszQName));
  379.     pQProc->pszComment    = pStr;
  380.     pStr = 1 + (NPSZ)MAKENEAR(EndStrcpy( pStr, pszComment));
  381.     pQProc->pszDriverName = pStr;
  382.     pStr = 1 + (NPSZ)MAKENEAR(EndStrcpy( pStr, pQProcData->pszDriverName ));
  383.     pQProc->pszPortName   = pStr;
  384.     pStr = 1 + (NPSZ)MAKENEAR(EndStrcpy( pStr, pQProcData->pszLogAddress ));
  385.  
  386.     if (cbDriverData) {
  387.         pQProc->pDriverData = (PDRIVDATA)(PSZ)pStr;
  388.         memcpyf( pQProc->pDriverData, pDriverData, cbDriverData );
  389.     } else
  390.         pQProc->pDriverData = (PDRIVDATA)0l;
  391.  
  392.     pQProc->qparms = qp_parms;
  393.  
  394.     switch( pQProc->uType ) {
  395.         case QP_TYPE_STD: pQProc->pfnPrintFile = SplQpStdPrintFile; break;
  396.         case QP_TYPE_RAW: pQProc->pfnPrintFile = SplQpRawPrintFile; break;
  397.     }
  398.   LeaveSplSem();
  399.  
  400.     return( pQProc );
  401. }
  402.  
  403.  
  404. PQPROCINST FARENTRY DestroyQProcInst( pQProc )
  405. register PQPROCINST pQProc;
  406. {
  407.     register PQPROCINST pQProc1 = pQProcInstances;
  408.  
  409.     if (!pQProc || pQProc->signature != QP_SIGNATURE)
  410.         return( NULL );
  411.  
  412.     if (pQProc == pQProc1)
  413.         pQProcInstances = pQProc->pNext;
  414.     else
  415.         while (pQProc1)
  416.             if (pQProc1->pNext == pQProc) {
  417.                 pQProc1->pNext = pQProc->pNext;
  418.                 break;
  419.                 }
  420.             else
  421.                 pQProc1 = pQProc1->pNext;
  422.  
  423.     if (!pQProc1)
  424.         SplPanic( "DestroyQProcInst pQProc=%0x not in list", pQProc, 0 );
  425.     pQProc1 = pQProc->pNext;
  426.  
  427.     pQProc->signature = 0;
  428.  
  429.     /* Release any allocated resources */
  430.  
  431.     if (pQProc->hmf) GpiDeleteMetaFile( pQProc->hmf );
  432.     if (pQProc->hps) GpiAssociate( pQProc->hps, (HDC)0 );
  433.     if (pQProc->hdc) DevCloseDC( pQProc->hdc );
  434.     if (pQProc->hps) GpiDestroyPS( pQProc->hps );
  435.     if (pQProc->hFile != NULL_HFILE) DosClose( pQProc->hFile );
  436.  
  437.     FreeSplStr( pQProc->pszFileName );
  438.     FreeSplStr( pQProc->pszDocument );
  439.  
  440.     if (pQProc->selBuf)
  441.         DosFreeSeg( pQProc->selBuf );
  442.  
  443.     FreeSplMem( (NPBYTE)pQProc, pQProc->cb );
  444.  
  445.     return( pQProc1 );
  446. }
  447.  
  448.  
  449. PQPROCINST ValidateQProcInst( hQProc )
  450. HPROC hQProc;
  451. {
  452.     register PQPROCINST pQProc = hQProcTopQProc( hQProc );
  453.  
  454.     if (pQProc && ChkMem(pQProc, sizeof(QPROCINST), CHK_WRITE) &&
  455.         pQProc->signature == QP_SIGNATURE)
  456.         return( pQProc );
  457.     else {
  458.         SplPanic( "Invalid hQProc parameter = %0p", hQProc, 0 );
  459.         SplLogError(PMERR_SPL_INV_HSPL);
  460.         return( NULL );
  461.     }
  462. }
  463.  
  464.  
  465. /* ParseQProcParms -- parses queue processor parameter string
  466.  *
  467.  * in:  pszParms - -> parameter string
  468.  *      pqp - -> buffer
  469.  * out: string contains only valid parameters?
  470.  *      *pqp - specified parameter
  471.  */
  472. BOOL ParseQProcParms( pszParms, pqp )
  473. PSZ pszParms;
  474. PQPPARMS pqp;
  475. {
  476.     register PKEYDATA pQPParms=0;
  477.     register NPSZ pParm;
  478.     USHORT i;
  479.     BOOL result = TRUE;
  480.  
  481.     memsetf(pqp, 0, sizeof(QPPARMS));
  482.     pqp->cCopies = 1;
  483.     pqp->fTransform = TRUE;
  484.  
  485.     if (!pszParms || !(i = SafeStrlen( pszParms )))
  486.         return( TRUE );
  487.  
  488.   EnterSplSem();
  489.     if (pQPParms = ParseKeyData( pszParms, ' ', i+1 ))
  490.         for (i=0; i<pQPParms->cTokens; i++)
  491.             if (pParm = pQPParms->pTokens[ i ])
  492.                 result &= ParseQProcParm(pParm, pqp);
  493.  
  494.     if (pQPParms)
  495.         FreeSplMem(pQPParms, pQPParms->cb);
  496.   LeaveSplSem();
  497.  
  498.     if (!result)
  499.         SplWarning( "Invalid queue processor parms: %0s", pszParms, 0 );
  500.  
  501.     return( result );
  502. }
  503.  
  504.  
  505. BOOL ParseQProcParm( pszParm, pqp )
  506. register NPSZ pszParm;
  507. PQPPARMS pqp;
  508. {
  509.     register NPSZ pszVal = pszParm+3;
  510.     USHORT us;
  511.  
  512.     if (SafeStrlen( pszParm ) < 5)
  513.         return( FALSE );
  514.  
  515.     if (*pszVal != '=')
  516.         return( FALSE );
  517.     *pszVal++ = '\0';
  518.  
  519.     if (!strcmpf( pszParm, "COP" )) {
  520.         if (!(us = AsciiToInt( pszVal )))
  521.             return( FALSE );
  522.         else
  523.             pqp->cCopies = us;
  524.  
  525.         while ((UCHAR)(*pszVal-'0') < 10)
  526.             pszVal++;
  527.         }
  528.     else
  529.     if (!strcmpf( pszParm, "CDP" )) {      /* Code Page Support */
  530.     pqp->uCodePage = AsciiToInt( pszVal );
  531.  
  532.         while ((UCHAR)(*pszVal-'0') < 10)
  533.         pszVal++;
  534.  
  535.     if(*pszVal != '\0') {
  536.         pqp->uCodePage = 0;
  537.         return( FALSE );
  538.         };
  539.         }
  540.     else
  541.     if (!strcmpf( pszParm, "XFM" )) {
  542.         if (*pszVal == '0')
  543.             pqp->fTransform = FALSE;
  544.         else
  545.         if (*pszVal == '1')
  546.             pqp->fTransform = TRUE;
  547.         else
  548.             return( FALSE );
  549.  
  550.         pszVal++;
  551.         }
  552.     else
  553.     if (!strcmpf( pszParm, "ORI" )) {
  554.         if (*pszVal == 'P')
  555.             pqp->fLandscape = FALSE;
  556.         else
  557.         if (*pszVal == 'L')
  558.             pqp->fLandscape = TRUE;
  559.         else
  560.             return( FALSE );
  561.  
  562.         pszVal++;
  563.         }
  564.     else
  565.     if (!strcmpf( pszParm, "COL" )) {
  566.         if (*pszVal == 'M')
  567.             pqp->fColor = FALSE;
  568.         else
  569.         if (*pszVal == 'C')
  570.             pqp->fColor = TRUE;
  571.         else
  572.             return( FALSE );
  573.  
  574.         pszVal++;
  575.         }
  576.     else
  577.     if (!strcmpf( pszParm, "MAP" )) {
  578.         if (*pszVal == 'N')
  579.             pqp->fMapColors = FALSE;
  580.         else
  581.         if (*pszVal == 'A')
  582.             pqp->fMapColors = TRUE;
  583.         else
  584.             return( FALSE );
  585.  
  586.         pszVal++;
  587.         }
  588.     else
  589.     if (!strcmpf( pszParm, "ARE" )) {
  590.         if (*pszVal == 'C') {
  591.             pqp->fArea = FALSE;
  592.             pszVal++;
  593.             }
  594.         else
  595.         if (pszVal = ParseQProcPercentList( pszVal, (PBYTE)&pqp->ptAreaSize, 4 ))
  596.             pqp->fArea = TRUE;
  597.         else
  598.             return( FALSE );
  599.         }
  600.     else
  601.     if (!strcmpf( pszParm, "FIT" )) {
  602.         if (*pszVal == 'S') {
  603.             pqp->fFit = FALSE;
  604.             pszVal++;
  605.             }
  606.         else
  607.         if (pszVal = ParseQProcPercentList( pszVal, (PBYTE)&pqp->ptFit, 2 ))
  608.             pqp->fFit = TRUE;
  609.         else
  610.             return( FALSE );
  611.         }
  612.     else
  613.         return( FALSE );
  614.  
  615.     return( *pszVal == '\0' );
  616. }
  617.  
  618.  
  619. NPSZ ParseQProcPercentList( pszList, pResult, cListElem )
  620. register NPSZ pszList;
  621. PBYTE pResult;
  622. USHORT cListElem;
  623. {
  624.     register NPSZ p = pszList;
  625.     USHORT n;
  626.  
  627.     while (*pszList && cListElem)
  628.         if (!*p || *p == ',') {
  629.             if (!cListElem--)
  630.                 return( NULL );
  631.  
  632.             if (*p == ',')
  633.                 *p++ = '\0';
  634.  
  635.             if ((n = AsciiToInt( pszList )) > 100)
  636.                 return( NULL );
  637.  
  638.             *pResult++ = (BYTE)n;
  639.             pszList = p;
  640.             }
  641.         else
  642.             p++;
  643.  
  644.     if (cListElem)
  645.         return( NULL );
  646.     else
  647.         return( p );
  648. }
  649.  
  650.  
  651. BOOL OpenQPInputFile(register PQPROCINST pQProc, PSZ pszFileName, BOOL fOpen)
  652. {
  653.     USHORT actionTaken,rc;
  654.     FILESTATUS inFileStatus;
  655.     USHORT  NoFileHandles=30;
  656.  
  657.     SplOutSem();
  658.     if (pszFileName) {
  659.       EnterSplSem();
  660.         FreeSplStr( pQProc->pszFileName );
  661.         pQProc->pszFileName = AllocSplStr(pszFileName);
  662.       LeaveSplSem();
  663.         }
  664.  
  665.     if (pQProc->pszFileName) {
  666.         if (pQProc->hFile == NULL_HFILE)
  667.             while (((rc=DosOpen( (PSZ)pQProc->pszFileName,
  668.                             (PHFILE)&pQProc->hFile,
  669.                             (PUSHORT)&actionTaken,
  670.                             (ULONG)0, (USHORT)0,
  671.                             OS_OF_EXIST,         /* open only if exists */
  672.                             OM_PRIVATE | OM_SHARED | OM_READ,
  673.                             (ULONG)0 )) == ERROR_TOO_MANY_OPEN_FILES) &&
  674.                 ((rc=DosSetMaxFH(NoFileHandles++)) != ERROR_NOT_ENOUGH_MEMORY))
  675.                 ;
  676.         else
  677.             rc=TRUE;
  678.         if (rc) {
  679.             SplPanic("QP: DosOpen failed for %0s", (PSZ)pQProc->pszFileName, 0);
  680.             SplQpMessage(pQProc->pszPortName, SPL_ID_QP_FILE_NOT_FOUND,
  681.                          PMERR_SPL_FILE_NOT_FOUND);
  682.         } else if (pQProc->hFile != NULL_HFILE) {
  683.             if (!DosQFileInfo( pQProc->hFile, 1,
  684.                               (PBYTE)&inFileStatus,
  685.                               sizeof( inFileStatus ) ) )
  686.                 pQProc->cbFile = inFileStatus.cbFile;
  687.  
  688.             if (!fOpen) {
  689.                 DosClose( pQProc->hFile );
  690.                 pQProc->hFile = NULL_HFILE;
  691.             }
  692.             return( TRUE );
  693.         }
  694.     }
  695.     return( FALSE );
  696. }
  697.  
  698.  
  699. BOOL CloseQPInputFile( pQProc )
  700. register PQPROCINST pQProc;
  701. {
  702.     if (pQProc->hFile != NULL_HFILE) {
  703.         DosClose( pQProc->hFile );
  704.         pQProc->hFile = NULL_HFILE;
  705.     }
  706.  
  707.     return( TRUE );
  708. }
  709.  
  710.  
  711.  
  712. BOOL OpenQPOutputDC(register PQPROCINST pQProc, USHORT fFlag)
  713. {
  714.     DEVOPENSTRUC openData;
  715.     NPSZ pszDocument;
  716.     ESCSETMODE ModeData;
  717. #ifdef LMPRINT
  718.     DEVICESPL dev;
  719. #endif
  720.  
  721.     SplOutSem();
  722.  
  723.     openData.pszLogAddress = (PSZ)pQProc->pszPortName;
  724.     openData.pszDriverName = (PSZ)pQProc->pszDriverName;
  725.     openData.pdriv         = pQProc->pDriverData;
  726.     openData.pszDataType   = pQProc->pszDataType;
  727.     openData.pszComment    = pQProc->pszComment;
  728.  
  729.     pQProc->hdc = DevOpenDC( HABX, OD_DIRECT, "*",
  730.                              (LONG)DATA_TYPE+1,
  731.                              (PDEVOPENDATA)&openData,
  732.                              (HDC)NULL );
  733.  
  734.     if (!pQProc->hdc) {
  735.         SplPanic( "QP: DevOpenDC failed for %0s on %4s",
  736.                   openData.pszLogAddress, openData.pszDriverName );
  737.         SplQpMessage(pQProc->pszPortName, SPL_ID_QP_OPENDC_ERROR, 0);
  738.     } else {
  739.  
  740.       if (fFlag == ASSOCIATE) {
  741.           GpiAssociate (pQProc->hps, pQProc->hdc); 
  742.       }
  743.  
  744. #ifdef LMPRINT
  745.         if (GetSepInfo(pQProc, &dev) == OKSIG) {
  746.             if (DevEscape(pQProc->hdc, DEVESC_STARTDOC, 0L, NULL,
  747.                           NULL, NULL) != DEVESC_ERROR) {
  748.                 if(!strcmpf(pQProc->pszDataType, DT_RAW)) {
  749.                     ModeData.mode = 0;
  750.                     ModeData.codepage = usCodePage;
  751.  
  752.                     DevEscape(pQProc->hdc, DEVESC_SETMODE,
  753.                               (ULONG)sizeof(ModeData),
  754.                               (PBYTE)&ModeData,
  755.                               0L,
  756.                               NULL);
  757.                 }
  758.                 PrintSep(&dev);
  759.                 DevEscape(pQProc->hdc, DEVESC_ENDDOC, 0L, NULL, NULL, NULL);
  760.             }
  761.         }
  762. #endif /* LMPRINT */
  763.  
  764.         if (DevEscape(pQProc->hdc, DEVESC_STARTDOC,
  765.                       (pszDocument = pQProc->pszDocument) ?
  766.                                     (ULONG)(SafeStrlen(pszDocument) + 1) : 0L,
  767.               pszDocument, NULL, NULL) != DEVESC_ERROR) {
  768.         /* Code Page support */
  769.         if((!strcmpf(pQProc->pszDataType, DT_RAW))&&(pQProc->qparms.uCodePage))
  770.         {
  771.                 ModeData.mode = 0;
  772.                 ModeData.codepage = pQProc->qparms.uCodePage;
  773.  
  774.         DevEscape(pQProc->hdc, DEVESC_SETMODE,
  775.                           (ULONG)sizeof(ModeData),
  776.               (char far *)&ModeData,
  777.               0L,
  778.               NULL);
  779.         };
  780.  
  781.         return( TRUE );
  782.     };
  783.     }
  784.  
  785.     return( FALSE );
  786. }
  787.  
  788.  
  789. BOOL CloseQPOutputDC(register PQPROCINST pQProc, BOOL fEndDoc)
  790. {
  791.     BOOL result = TRUE;
  792.  
  793.     SplOutSem();
  794.     if (pQProc->hdc) {
  795.         if (fEndDoc &&
  796.             !(pQProc->fsStatus & QP_ABORTED) &&
  797.             !DevEscape( pQProc->hdc, DEVESC_ENDDOC, 0L,
  798.                         (PBYTE)NULL, (PLONG)NULL, (PBYTE)NULL
  799.                       ) != DEVESC_ERROR)
  800.             result = FALSE;
  801.  
  802.         DevCloseDC( pQProc->hdc );
  803.         pQProc->hdc = NULL;
  804.     }
  805.  
  806.     return( result );
  807. }
  808.