home *** CD-ROM | disk | FTP | other *** search
/ The Developer Connection…ice Driver Kit for OS/2 3 / DEV3-D1.ISO / devtools / toolkt21 / c / samples / print / prtprint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-22  |  56.3 KB  |  1,681 lines
  1. /**************************************************************************
  2.  *  File name  :  prtprint.c
  3.  *
  4.  *  Description:  This module contains all the functions needed to display
  5.  *                a listbox with the valid printer queues and to select a
  6.  *                printer and the print properties.
  7.  *
  8.  *                This source file contains the following functions:
  9.  *
  10.  *                Print( hwnd, pmp )
  11.  *                PrintingDlgProc( hwnd, msg, mp1, mp2 )
  12.  *                PrintDlgProc( hwnd, msg, mp1, mp2 )
  13.  *                QueryPrintQueue( hwnd, pmp, fShowDialog)
  14.  *                QueryPrintDlgProc( hwnd, msg, mp1, mp2 )
  15.  *                QueryJobProperties( hab, pQueueInfo )
  16.  *                ProcessUserPrint( hwnd, pmp )
  17.  *                PrinterBitblt( hwnd, pmp )
  18.  *                PrinterPaginate( hwnd, pmp )
  19.  *                PrinterPlayMetaFile( hwnd, pmp )
  20.  *                FindQueue( pszQueueName, pQueueInfo, sCount )
  21.  *                SortQueues( pQueue1, pQueue2 )
  22.  *
  23.  *  Concepts   :  Listbox, printer queue display and printer property dislpay
  24.  *                and modification.
  25.  *
  26.  *  API's      :  DevCloseDC
  27.  *                DevEscape
  28.  *                DevOpenDC
  29.  *                DevPostDeviceModes
  30.  *                DevQueryCaps
  31.  *
  32.  *                GpiAssociate
  33.  *                GpiBitblt
  34.  *                GpiConvert
  35.  *                GpiCreateLogFont
  36.  *                GpiCreatePS
  37.  *                GpiDeleteBitmap
  38.  *                GpiDeleteSetId
  39.  *                GpiDestroyPS
  40.  *                GpiPlayMetaFile
  41.  *                GpiQueryPS
  42.  *                GpiSetBitmap
  43.  *                GpiSetCharSet
  44.  *
  45.  *                PrfQueryProfileString
  46.  *
  47.  *                SplEnumQueue
  48.  *
  49.  *                WinDefDlgProc
  50.  *                WinDismissDlg
  51.  *                WinDlgBox
  52.  *                WinEnableControl
  53.  *                WinLoadDlg
  54.  *                WinLoadString
  55.  *                WinMessageBox
  56.  *                WinPostMsg
  57.  *                WinQueryDlgItemShort
  58.  *                WinQueryDlgItemText
  59.  *                WinQueryWindowULong
  60.  *                WinSendMsg
  61.  *                WinSetDlgItemShort
  62.  *                WinSetDlgItemText
  63.  *                WinSetWindowULong
  64.  *                WinSendDlgItemMsg
  65.  *                WinShowWindow
  66.  *
  67.  *    Files    :  OS2.H, PRTSAMP.H, PRTSDLG.H, PRTSHLP.H, PMASSERT.H
  68.  *
  69.  *  Copyright (C) 1991-1993 IBM Corporation
  70.  *
  71.  *      DISCLAIMER OF WARRANTIES.  The following [enclosed] code is
  72.  *      sample code created by IBM Corporation. This sample code is not
  73.  *      part of any standard or IBM product and is provided to you solely
  74.  *      for  the purpose of assisting you in the development of your
  75.  *      applications.  The code is provided "AS IS", without
  76.  *      warranty of any kind.  IBM shall not be liable for any damages
  77.  *      arising out of your use of the sample code, even if they have been
  78.  *      advised of the possibility of such damages.                                                    *
  79.  *************************************************************************/
  80.  
  81. /* Include the required sections from the PM header file.  */
  82. #define INCL_DEV
  83. #define INCL_DOSMISC
  84. #define INCL_GPIBITMAPS
  85. #define INCL_GPICONTROL
  86. #define INCL_GPILCIDS
  87. #define INCL_GPIMETAFILES
  88. #define INCL_GPIPRIMITIVES
  89. #define INCL_GPITRANSFORMS
  90. #define INCL_SPL
  91. #define INCL_SPLDOSPRINT
  92. #define INCL_WINBUTTONS
  93. #define INCL_WINDIALOGS
  94. #define INCL_WINENTRYFIELDS
  95. #define INCL_WINERRORS
  96. #define INCL_WINHELP
  97. #define INCL_WININPUT
  98. #define INCL_WINLISTBOXES
  99. #define INCL_WINMENUS
  100. #define INCL_WINMESSAGEMGR
  101. #define INCL_WINSTDFILE
  102. #define INCL_WINSTDFONT
  103. #define INCL_WINWINDOWMGR
  104. #include <os2.h>
  105.  
  106. /* c language includes */
  107. #include <stdio.h>
  108. #include <stdlib.h>
  109. #include <string.h>
  110. #include <ctype.h>
  111. #include <stddef.h>
  112. #include <process.h>
  113. #include <memory.h>
  114. #include <sys\types.h>
  115. #include <sys\stat.h>
  116.  
  117. /* application includes */
  118. #include "prtsamp.h"
  119. #include "prtsdlg.h"
  120. #include "pmassert.h"
  121. #include "prtshlp.h"
  122.  
  123.  
  124. /* static function prototypes */
  125.  
  126. static int _Optlink SortQueues(const void *pQueue1, const void *pQueue2);
  127. MRESULT EXPENTRY PrintDlgProc(HWND, USHORT, MPARAM, MPARAM);
  128. MRESULT EXPENTRY PrintingDlgProc(HWND, USHORT, MPARAM, MPARAM);
  129. MRESULT EXPENTRY QueryPrintDlgProc(HWND, USHORT, MPARAM, MPARAM);
  130. BOOL QueryJobProperties(HAB hab, PPRQINFO3 pPrQ);
  131. LONG FindQueue(PSZ pszQueueName, PPRQINFO3 pQueueInfo, LONG lCount);
  132. VOID PrinterPaginate(HWND hwnd, PMAIN_PARM pmp);
  133. VOID PrinterBitblt(HWND hwnd, PMAIN_PARM pmp);
  134. VOID PrinterPlayMetaFile(HWND hwnd, PMAIN_PARM pmp);
  135. VOID ResetPrinterInfoDC( PMAIN_PARM pmp );
  136.  
  137. /*************************************************************************
  138.  *  Function   :  Print
  139.  *
  140.  *  Description:  This function displays the print dialog.
  141.  *
  142.  *  API's      :  WinDlgBox
  143.  *                WinSendMsg
  144.  *                WinLoadDlg
  145.  *
  146.  *  Parameters :  HWND         window handle of frame window
  147.  *                PMAIN_PARM   global application data
  148.  *
  149.  *  Return     :  TRUE if print successful, otherwise FALSE
  150.  *
  151.  *************************************************************************/
  152. BOOL Print(HWND hwnd, PMAIN_PARM pmp)
  153. {
  154.    SHORT      index;
  155.    PPRQINFO3  pQueueInfo;
  156.    ULONG      ul;
  157.    ULONG      cbNeeded;
  158.    BOOL       bOK;
  159.    CHAR       szWork[LEN_WORKSTRING],szTmp[LEN_WORKSTRING];
  160.  
  161.    /*
  162.     * Ensure that queue is correct, the user may have initiated a print
  163.     * without going thruogh any other of the dialogs
  164.     */
  165.    QueryPrintQueue( pmp, FALSE );
  166.  
  167.    /* Query to get latest forms data */
  168.    pmp->cForms = QueryPrinterForms( pmp, pmp->hcinfo, MAX_FORMS );
  169.    pmassert( pmp->hab, pmp->cForms );
  170.  
  171.    /*
  172.     * Check that the form selected by the user in page setup matches the
  173.     * form in job properties
  174.     */
  175.    index = FindForm( pmp->form.achFormName, pmp->hcinfo, pmp->cForms );
  176.    pmassert( pmp->hab, index != -1L);
  177.    if (! (pmp->hcinfo[index].flAttributes & HCAPS_CURRENT))
  178.    {
  179.       /* display warning message box */
  180.       bOK = WinLoadString( pmp->hab,
  181.                            (HMODULE)NULLHANDLE,
  182.                            ERRMSG_WRONG_FORM,
  183.                            LEN_WORKSTRING,
  184.                            szTmp );
  185.       pmassert( pmp->hab, bOK );
  186.       sprintf( szWork, szTmp, pmp->form.achFormName );
  187.       WinMessageBox( HWND_DESKTOP,
  188.                      pmp->hwndFrame,
  189.                      szWork,
  190.                      pmp->pszTitle,
  191.                      (USHORT)0,
  192.                      MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
  193.  
  194.       /* query queue information */
  195.       ul = SplQueryQueue( NULL, pmp->achQueueName, 3, NULL, 0L, &cbNeeded );
  196.       pmassert( pmp->hab, ul );
  197.       pQueueInfo = malloc( cbNeeded );
  198.       ul = SplQueryQueue( NULL, pmp->achQueueName, 3, pQueueInfo, cbNeeded,
  199.                           &cbNeeded );
  200.       pmassert( pmp->hab, ul == 0 );
  201.  
  202.      /*
  203.       * store current driver data info into SplEnumQueue info
  204.       * so that when user wants to change a print property
  205.       * but not necessarily a printer, his previous settings
  206.       * will be shown in the print properties dialog
  207.       */
  208.      if( pQueueInfo->pDriverData->cb == pmp->cbDriverDataLen )
  209.      {
  210.        memcpy( pQueueInfo->pDriverData, pmp->pDriverData, pmp->cbDriverDataLen );
  211.      }
  212.  
  213.      /* display job properties dialog */
  214.      QueryJobProperties( pmp->hab, pQueueInfo);
  215.  
  216.      /* destroy allocations for printer driver data */
  217.      if( pmp->pDriverData )
  218.      {
  219.          free( pmp->pDriverData );
  220.          pmp->pDriverData      = NULL;
  221.          pmp->cbDriverDataLen  = 0;
  222.      }
  223.  
  224.      /* store new driver data length in pmp  */
  225.      pmp->cbDriverDataLen  = pQueueInfo->pDriverData->cb;
  226.  
  227.      /* store new driver data in pmp  */
  228.      pmp->pDriverData = (PDRIVDATA) malloc( pmp->cbDriverDataLen );
  229.      pmassert( pmp->hab, pmp->pDriverData );
  230.      memcpy( pmp->pDriverData, pQueueInfo->pDriverData, pmp->cbDriverDataLen );
  231.  
  232.      /* destroy allocation for Queue information */
  233.      free( pQueueInfo );
  234.  
  235.      /*
  236.       * reset the printer info device context so the changed form
  237.       * will be found next time
  238.       */
  239.      ResetPrinterInfoDC( pmp );
  240.    }
  241.  
  242.    /*
  243.     * Query user print options. See the PrintDlgProc for details.
  244.     */
  245.    if (WinDlgBox( HWND_DESKTOP,
  246.                   hwnd,
  247.                   (PFNWP)PrintDlgProc,
  248.                   (HMODULE)NULLHANDLE,
  249.                   IDD_PRINT,
  250.                   (PVOID)pmp) )
  251.    {
  252.       /*
  253.        * User wants to print, so start print job and display text
  254.        * showing job printing status.
  255.        */
  256.       WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0L, (MPARAM)0L );
  257.  
  258.       pmp->hwndPrinting = WinLoadDlg( HWND_DESKTOP,
  259.                                       hwnd,
  260.                                       (PFNWP)PrintingDlgProc,
  261.                                       (HMODULE)NULLHANDLE,
  262.                                       IDD_PRINTING,
  263.                                       (PVOID)pmp);
  264.    }
  265.    return FALSE;
  266. }
  267.  
  268. /*************************************************************************
  269.  *  Function   : PrintingDlgProc
  270.  *
  271.  *  Description:  This function displays the print dialog.
  272.  *
  273.  *  API's      :  WinPostMsg
  274.  *                WinDismissDlg
  275.  *                WinEnableControl
  276.  *                WinSetDlgItemText
  277.  *                WinDefDlgProc
  278.  *
  279.  *  Parameters :  HWND         window handle of printer selection dialog
  280.  *                USHORT       message
  281.  *                MPARAM       message parameter 1
  282.  *                MPARAM       message parameter 2
  283.  *
  284.  *  Return     :  message result
  285.  *
  286.  *************************************************************************/
  287. MRESULT EXPENTRY PrintingDlgProc(HWND hwnd,
  288.                                  USHORT msg,
  289.                                  MPARAM mp1,
  290.                                  MPARAM mp2)
  291. {
  292.    static PMAIN_PARM   pmp;
  293.    PSZ                 psz;
  294.    CHAR                szWork[LEN_WORKSTRING], szPrintString[LEN_WORKSTRING];
  295.    BOOL                bOK;
  296.  
  297.    switch (msg)
  298.    {
  299.    case WM_INITDLG:
  300.       /* Get pointer to application specific data */
  301.       pmp = (PMAIN_PARM) PVOIDFROMMP(mp2);
  302.  
  303.       WinSetDlgItemText(hwnd, IDD_PRINTPRINTER, (PSZ)pmp->achQueueDesc);
  304.  
  305.       /* Show the document name */
  306.       psz = strrchr( pmp->szFilename, '\\' );
  307.       if (psz && *psz)
  308.       {
  309.           ++psz;
  310.       }
  311.       else
  312.       {
  313.           psz = pmp->szFilename;
  314.       }
  315.       WinSetDlgItemText(hwnd, IDD_PRINTDOCUMENT, psz);
  316.  
  317.       /* set focus to cancel pushbutton */
  318.       WinSetFocus (HWND_DESKTOP, WinWindowFromID (hwnd, (USHORT)DID_CANCEL));
  319.  
  320.       /*
  321.        * send WM_USER_PRINT message
  322.        * disable client -- object window enables client
  323.        *   when complete
  324.        */
  325.       pmp->fCancel = FALSE;
  326.       WinPostMsg(pmp->hwndObject, WM_USER_PRINT, (MPARAM)hwnd, (MPARAM)0L);
  327.       return 0L;
  328.  
  329.    case WM_USER_ACK:
  330.       /*
  331.        *  The job has either completed or aborted, so tell the client
  332.        *  window and get out.
  333.        */
  334.  
  335.       WinPostMsg(pmp->hwndClient, WM_USER_ACK, 0L, 0L);
  336.  
  337.       WinDismissDlg(hwnd, FALSE);
  338.       return 0L;
  339.  
  340.    case WM_USER_NEW_PAGE:
  341.       /*
  342.        * Increment the page counter on the print confirmation dialog
  343.        */
  344.       bOK = WinLoadString( pmp->hab,
  345.                            (HMODULE)NULLHANDLE,
  346.                            PRINT_PAGE_MSG,
  347.                            LEN_WORKSTRING,
  348.                            szPrintString );
  349.       pmassert( pmp->hab, bOK );
  350.       sprintf(szWork, szPrintString, (ULONG)mp1);
  351.       WinSetDlgItemText( hwnd, IDD_PRINTINGTEXT, szWork);
  352.  
  353.       /* set focus to cancel pushbutton */
  354.       WinSetFocus (HWND_DESKTOP, WinWindowFromID (hwnd, (USHORT)DID_CANCEL));
  355.       break;
  356.  
  357.    case WM_USER_SKIP_PAGE:
  358.       /*
  359.        * Skip the page counter on the print confirmation dialog
  360.        */
  361.       bOK = WinLoadString( pmp->hab,
  362.                            (HMODULE)NULLHANDLE,
  363.                            PRINT_SCAN_MSG,
  364.                            LEN_WORKSTRING,
  365.                            szPrintString );
  366.       pmassert( pmp->hab, bOK );
  367.       sprintf(szWork, szPrintString, (ULONG)mp1);
  368.       WinSetDlgItemText( hwnd, IDD_PRINTINGTEXT, szWork);
  369.  
  370.       /* set focus to cancel pushbutton */
  371.       WinSetFocus (HWND_DESKTOP, WinWindowFromID (hwnd, (USHORT)DID_CANCEL));
  372.       break;
  373.  
  374.    case WM_COMMAND:
  375.       switch(SHORT1FROMMP(mp1))
  376.       {
  377.       case DID_CANCEL:
  378.          pmp->fCancel = TRUE;
  379.          WinEnableControl( hwnd, DID_CANCEL, FALSE );
  380.          bOK = WinLoadString( pmp->hab,
  381.                               (HMODULE)NULLHANDLE,
  382.                               PRINT_ABORT_MSG,
  383.                               LEN_WORKSTRING,
  384.                               szWork );
  385.          pmassert( pmp->hab, bOK );
  386.          WinSetDlgItemText( hwnd, IDD_PRINTINGTEXT, szWork);
  387.          return 0;
  388.       }
  389.       break;
  390.    }
  391.    return( WinDefDlgProc( hwnd, msg, mp1, mp2 ) );
  392. }  /* End of PrintingDlgProc */
  393.  
  394. /*************************************************************************
  395.  *  Function   :  PrintDlgProc
  396.  *
  397.  *  Description:
  398.  *
  399.  *  API's      :  WinSetDlgItemText
  400.  *                WinSetDlgItemShort
  401.  *                WinShowWindow
  402.  *                WinSendMsg
  403.  *                WinQueryDlgItemShort
  404.  *                WinQueryDlgItemText
  405.  *                WinDismissDlg
  406.  *                WinDefDlgProc
  407.  *
  408.  *  Parameters :  HWND         window handle of printer selection dialog
  409.  *                USHORT       message
  410.  *                MPARAM       message parameter 1
  411.  *                MPARAM       message parameter 2
  412.  *
  413.  *  Return     :  MRESULT         message result
  414.  *
  415.  *************************************************************************/
  416. MRESULT EXPENTRY PrintDlgProc(HWND hwnd,
  417.                               USHORT msg,
  418.                               MPARAM mp1,
  419.                               MPARAM mp2)
  420. {
  421.    static PMAIN_PARM pmp;
  422.    PSZ         psz;
  423.    ULONG       ulPanel;
  424.    USHORT      usCopies, usFirstPage, usLastPage;
  425.    CHAR        szEntryField[4];            /* text contents of entry field */
  426.  
  427.    switch (msg)
  428.    {
  429.    case WM_INITDLG:
  430.       /* Get pointer to application specific data */
  431.       pmp = (PMAIN_PARM) PVOIDFROMMP(mp2);
  432.  
  433.       /* Show the printer name */
  434.       WinSetDlgItemText(hwnd, IDD_PRTPRINTER, (PSZ)pmp->achQueueDesc);
  435.  
  436.       /* Show the document name */
  437.       psz = strrchr( pmp->szFilename, '\\' );
  438.       if (psz && *psz)
  439.       {
  440.           ++psz;
  441.       }
  442.       else
  443.       {
  444.           psz = pmp->szFilename;
  445.       }
  446.       WinSetDlgItemText(hwnd, IDD_PRTDOCUMENT, psz);
  447.  
  448.       /* Make entry fields read only */
  449.       WinSendMsg( WinWindowFromID( hwnd, IDD_PRTPRINTER ),
  450.                   EM_SETREADONLY, (MPARAM)TRUE, (MPARAM)0L );
  451.       WinSendMsg( WinWindowFromID( hwnd, IDD_PRTDOCUMENT ),
  452.                   EM_SETREADONLY, (MPARAM)TRUE, (MPARAM)0L );
  453.  
  454.       /* Initialize the number of copies */
  455.       WinSetDlgItemShort(hwnd, IDD_PRTCOPIES, pmp->usCopies, FALSE);
  456.  
  457.       /*
  458.        * If the file is TEXT then set the page fields. Otherwise reset the
  459.        * fields and disable the all fields and pushbuttons
  460.        */
  461.       if (pmp->ulMode == MODE_TEXT)
  462.       {
  463.          WinSetDlgItemShort(hwnd, IDD_PRTFIRSTPAGE, pmp->usFirstPage, FALSE);
  464.          WinSetDlgItemShort(hwnd, IDD_PRTLASTPAGE, pmp->usLastPage, FALSE);
  465.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTFIRSTPAGE), TRUE);
  466.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTLASTPAGE), TRUE);
  467.       }
  468.       else
  469.       {
  470.          WinSetDlgItemShort(hwnd, IDD_PRTFIRSTPAGE, 1, FALSE);
  471.          WinSetDlgItemShort(hwnd, IDD_PRTLASTPAGE, 1, FALSE);
  472.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTALL), FALSE);
  473.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTSELECT), FALSE);
  474.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTFIRSTPAGE), FALSE);
  475.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTLASTPAGE), FALSE);
  476.       }
  477.  
  478.       /* Set the state of the page select pushbuttons */
  479.       if (pmp->fPrintAllPages)
  480.       {
  481.          WinCheckButton( hwnd, IDD_PRTALL, 1);
  482.          WinCheckButton( hwnd, IDD_PRTSELECT, 0);
  483.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTFIRSTPAGE), FALSE);
  484.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTLASTPAGE), FALSE);
  485.       }
  486.       else
  487.       {
  488.          WinCheckButton( hwnd, IDD_PRTALL, 0);
  489.          WinCheckButton( hwnd, IDD_PRTSELECT, 1);
  490.       }
  491.  
  492.       /*
  493.        * Hide the preview control.  The reason it is included in the
  494.        * print sample DLG file is for the benefit of programmers who
  495.        * want their dialogs to look exactly like those presented in
  496.        * the Programming Guide for printing (Chapter 18).
  497.        */
  498.       WinShowWindow(WinWindowFromID(hwnd, IDD_PRTPREVIEW), FALSE);
  499.  
  500.       return 0;
  501.  
  502.    case WM_HELP:
  503.       if( pmp->hwndHelp )
  504.       {
  505.          ulPanel = PANEL_PRINTDLG;
  506.          WinSendMsg( pmp->hwndHelp, HM_DISPLAY_HELP,
  507.                    (MPARAM)&ulPanel, (MPARAM)HM_RESOURCEID );
  508.          return (MRESULT)NULL;
  509.       }
  510.       break;
  511.  
  512.    case WM_CONTROL:
  513.       switch(SHORT1FROMMP(mp1))
  514.       {
  515.       case IDD_PRTDOCUMENT:
  516.       case IDD_PRTPRINTER:
  517.          /* these fields are read-only */
  518.          return 0;
  519.  
  520.       case IDD_PRTCOPIES:
  521.          if (SHORT2FROMMP(mp1) == EN_CHANGE)
  522.          {
  523.             /* Verify that a non-zero number was typed in the entry field. */
  524.             if (!WinQueryDlgItemShort( hwnd, IDD_PRTCOPIES,
  525.                                        (PSHORT)&usCopies, FALSE) ||
  526.                                        !usCopies )
  527.             {
  528.                /* If the field has length, clear the value and beep */
  529.                if (WinQueryDlgItemText( hwnd, IDD_PRTCOPIES,
  530.                                         sizeof(szEntryField), szEntryField ) )
  531.                {
  532.                   WinSetDlgItemText( hwnd, IDD_PRTCOPIES, "" );
  533.                   DosBeep(600, 5);
  534.                }
  535.             }
  536.          }
  537.          return 0;
  538.  
  539.       case IDD_PRTALL:
  540.          /* check buttons appropriately */
  541.          WinCheckButton( hwnd, IDD_PRTALL, 1);
  542.          WinCheckButton( hwnd, IDD_PRTSELECT, 0);
  543.          /* disable first and last page entry fields */
  544.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTFIRSTPAGE), FALSE);
  545.          WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTLASTPAGE), FALSE);
  546.          return 0;
  547.  
  548.       case IDD_PRTSELECT:
  549.          /* check buttons appropriately */
  550.          WinCheckButton( hwnd, IDD_PRTALL, 0);
  551.          WinCheckButton( hwnd, IDD_PRTSELECT, 1);
  552.          /*
  553.           * if the mode is TEXT and the page selection is active, enable the
  554.           * the first and last page controls otherwise disable them
  555.           */
  556.          if (pmp->ulMode == MODE_TEXT)
  557.          {
  558.             WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTFIRSTPAGE), TRUE);
  559.             WinEnableWindow(WinWindowFromID(hwnd, IDD_PRTLASTPAGE), TRUE);
  560.          }
  561.          return 0;
  562.  
  563.       case IDD_PRTFIRSTPAGE:
  564.          if (SHORT2FROMMP(mp1) == EN_CHANGE)
  565.          {
  566.             /* Verify that a non-zero number was typed in the entry field. */
  567.             if (!WinQueryDlgItemShort( hwnd, IDD_PRTFIRSTPAGE,
  568.                                        (PSHORT)&usFirstPage, FALSE) ||
  569.                                        !usFirstPage )
  570.                /* If the field has length, clear the value and beep */
  571.                if (WinQueryDlgItemText( hwnd, IDD_PRTFIRSTPAGE,
  572.                                         sizeof(szEntryField), szEntryField ) )
  573.                {
  574.                   WinSetDlgItemText( hwnd, IDD_PRTFIRSTPAGE, "" );
  575.                   DosBeep(600, 5);
  576.                }
  577.          }
  578.          return 0;
  579.  
  580.       case IDD_PRTLASTPAGE:
  581.          if (SHORT2FROMMP(mp1) == EN_CHANGE)
  582.          {
  583.             /* Verify that a non-zero number was typed in the entry field. */
  584.             if (!WinQueryDlgItemShort( hwnd, IDD_PRTLASTPAGE,
  585.                                        (PSHORT)&usLastPage, FALSE) ||
  586.                                        !usLastPage )
  587.             {
  588.                /* If the field has length, clear the value and beep */
  589.                if (WinQueryDlgItemText( hwnd, IDD_PRTLASTPAGE,
  590.                                         sizeof(szEntryField), szEntryField ) )
  591.                {
  592.                   WinSetDlgItemText( hwnd, IDD_PRTLASTPAGE, "" );
  593.                   DosBeep(600, 5);
  594.                }
  595.             }
  596.          }
  597.          return 0;
  598.  
  599.  
  600.       case IDD_PRTPREVIEW:
  601.          /* this field is not used in this sample program */
  602.          return 0;
  603.       }
  604.       break;
  605.  
  606.    case WM_COMMAND:
  607.       switch(SHORT1FROMMP(mp1))
  608.       {
  609.       case DID_OK:
  610.          /* get number of copies and store in global data structure */
  611.          WinQueryDlgItemShort( hwnd, IDD_PRTCOPIES,
  612.                                (PSHORT)&pmp->usCopies, FALSE);
  613.  
  614.          /* print all pages or selective pages */
  615.          pmp->fPrintAllPages =
  616.              (BOOL)WinSendDlgItemMsg( hwnd, IDD_PRTALL, BM_QUERYCHECK,
  617.                                       (MPARAM)TRUE, (MPARAM)0L );
  618.  
  619.          /*
  620.           * If mode is TEXT, get first and last page, even though
  621.           * page select may be greyed
  622.           */
  623.          if (pmp->ulMode == MODE_TEXT)
  624.          {
  625.             WinQueryDlgItemShort( hwnd, IDD_PRTFIRSTPAGE,
  626.                                   (PSHORT)&pmp->usFirstPage, FALSE);
  627.             WinQueryDlgItemShort( hwnd, IDD_PRTLASTPAGE,
  628.                                   (PSHORT)&pmp->usLastPage, FALSE);
  629.          }
  630.          if (pmp->usLastPage < pmp->usFirstPage)
  631.          {
  632.             pmp->fPrintAllPages = TRUE;
  633.             pmp->usFirstPage = 1;
  634.             pmp->usLastPage = 1;
  635.          }
  636.  
  637.          WinDismissDlg(hwnd, TRUE);
  638.          return 0;
  639.  
  640.       case DID_CANCEL:
  641.          WinDismissDlg(hwnd, FALSE);
  642.          return 0;
  643.  
  644.       case DID_HELP_BUTTON:
  645.          /* don't do anything yet */
  646.          return 0;
  647.       }
  648.       break;
  649.  
  650.    }
  651.    return(WinDefDlgProc(hwnd, msg, mp1, mp2));
  652.  
  653. } /* End of PrintDlgProc */
  654.  
  655. /*************************************************************************
  656.  *  Function   :  QueryPrintQueue
  657.  *
  658.  *  Description:  Query all printer queues, display them in a listbox
  659.  *                and do a selection.
  660.  *
  661.  *  Parameters:   PMAIN_PARM  pmp has global application data
  662.  *                fShowDialog     a flag:  should the dialog be displayed?
  663.  *
  664.  *  API's      :  SplEnumQueue
  665.  *                WinLoadString
  666.  *                WinMessageBox
  667.  *                DosQuerySysInfo
  668.  *                PrfQueryProfileString
  669.  *                WinDlgBox
  670.  *
  671.  *  Return     :  TRUE if printer changed, otherwise FALSE
  672.  *
  673.  *************************************************************************/
  674. BOOL QueryPrintQueue(PMAIN_PARM pmp, BOOL fShowDialog)
  675. {
  676.     ULONG           ul, cReturned, cTotal, cbNeeded;
  677.     PPRQINFO3       pQueueInfo, pqi;
  678.     LONG            i;
  679.     BOOL            fResult, bOK;
  680.     CHAR            szWork[LEN_WORKSTRING], *pch;
  681.     ULONG           aulVersion[2];
  682.  
  683.    /*
  684.     * Get count of total number of print queues and the size of the
  685.     * buffer needed (cbNeeded) to hold them.
  686.     */
  687.    ul = SplEnumQueue( NULL,          /* pszComputerName - local machine */
  688.                       3,             /* information level 3 requested   */
  689.                       NULL,          /* pBuf - NULL for first call      */
  690.                       0L,            /* cbBuf - 0 to get size needed    */
  691.                       &cReturned,    /* number of queues returned       */
  692.                       &cTotal,       /* total number of queues          */
  693.                       &cbNeeded,     /* number bytes needed to store    */
  694.                                      /* all requested information       */
  695.                       NULL );        /* reserved                        */
  696.  
  697.    /* If there are no print queues display Message Box */
  698.    if (cTotal == 0L)
  699.    {           /* this system has no printers defined */
  700.       bOK = WinLoadString( pmp->hab,
  701.                            (HMODULE)NULLHANDLE,
  702.                            ERRMSG_NO_QUEUES_DEFINED,
  703.                            LEN_WORKSTRING,
  704.                            szWork );
  705.       pmassert( pmp->hab, bOK );
  706.  
  707.       WinMessageBox( HWND_DESKTOP,
  708.                      pmp->hwndFrame,
  709.                      szWork,
  710.                      pmp->pszTitle,
  711.                      (USHORT)0,
  712.                      MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
  713.  
  714.       /* Grey Print menu item */
  715.       WinEnableMenuItem( pmp->hwndMenubar, IDM_PRINT, FALSE );
  716.  
  717.       /*
  718.        * There are no printers now. A previously defined printer may have
  719.        * have been deleted, so reset all the fields in the global data
  720.        */
  721.       pmp->hdcPrinter = (HDC)NULL;
  722.       pmp->hpsPrinter = (HPS)NULL;
  723.       pmp->hdcPrinterInfo = (HDC)NULL;
  724.       pmp->achQueueName[0] = '\0';
  725.       pmp->achQueueDesc[0] = '\0';
  726.       pmp->pDriverData = (PDRIVDATA)NULL;
  727.  
  728.       /*
  729.        * Return TRUE if a printer was previously defined and then reset
  730.        * this field so that some default forms can be returned for
  731.        * the Page Setup dialog
  732.        */
  733.       fResult = pmp->hpsPrinterInfo;
  734.       pmp->hpsPrinterInfo = (HPS)NULL;
  735.       return fResult;
  736.    }
  737.  
  738.    /*
  739.     * allocate memory to store the enumerated queue information
  740.     */
  741.    pQueueInfo = malloc( cbNeeded ) ;
  742.     pmassert( pmp->hab, pQueueInfo );
  743.  
  744.     /* Call again to get print queue data. */
  745.    ul = SplEnumQueue( NULL,             /* pszComputerName - local machine */
  746.                       3,                /* information level 3 requested   */
  747.                       pQueueInfo,       /* pBuf - gets enumerated queues   */
  748.                       cbNeeded,         /* cbBuf - size of pBuf            */
  749.                       &cReturned,       /* number of queues returned       */
  750.                       &cTotal,          /* total number of queues          */
  751.                       &cbNeeded,        /* number bytes needed to store    */
  752.                                         /*   all requested information     */
  753.                       NULL );           /* reserved                        */
  754.  
  755.     pmassert( pmp->hab, ul == 0 );
  756.  
  757.     /*
  758.      * Validate that the user-preferred queue exists and if not then
  759.      * set preferred queue to none. User's preference of queues is
  760.      * named by the variable pmp->achQueueName.
  761.      */
  762.  
  763.     if( *pmp->achQueueName != 0 )
  764.     {
  765.       i = FindQueue( pmp->achQueueName, pQueueInfo, cReturned );
  766.       if (i == -1)
  767.       {
  768.         *pmp->achQueueName = 0;
  769.       }
  770.     }
  771.  
  772.     /*
  773.      * Validate that the user-preferred queue has been initialized OK.
  774.      * If not, initialize it now.
  775.      */
  776.  
  777.     if ( *pmp->achQueueName == 0 )
  778.     {
  779.        /*
  780.         * There is no preferred queue name because there was none
  781.         * in the INI file (perhaps this is the first time the
  782.         * program has run on this system?) or the profile reading
  783.         * failed somehow. Give the user the application default
  784.         * queue.
  785.         */
  786.  
  787.        /* check OS/2 version number */
  788.        ul = DosQuerySysInfo( QSV_VERSION_MAJOR, QSV_VERSION_MINOR,
  789.                         aulVersion, 8 );
  790.        pmassert( pmp->hab, ul == 0 );
  791.  
  792.        if (aulVersion[0] == 20 && aulVersion[1] == 0 )
  793.        {
  794.          ul = PrfQueryProfileString( HINI_PROFILE,
  795.                                      "PM_SPOOLER",
  796.                                      "QUEUE",
  797.                                      NULL,
  798.                                      szWork,
  799.                                      LEN_WORKSTRING );
  800.  
  801.          if ( ul )
  802.          {
  803.             /* truncate queuename at terminating semicolon */
  804.             pch = strchr( szWork, ';' );
  805.             pmassert( pmp->hab, pch );
  806.             *pch = 0;
  807.             strcpy( pmp->achQueueName, szWork );
  808.          }
  809.        }
  810.        else
  811.        {
  812.          for (i = 0L; i < cTotal; ++i)
  813.          {
  814.             if ( pQueueInfo[i].fsType & PRQ3_TYPE_APPDEFAULT)
  815.             {
  816.                strcpy( pmp->achQueueName, pQueueInfo[i].pszName );
  817.                break;
  818.             }
  819.          }
  820.        }
  821.  
  822.        /*
  823.         * Still no application default queue? odd. Give him the first queue
  824.         * from the SplEnumQueue calls
  825.         */
  826.        if ( *pmp->achQueueName == 0 )
  827.        {
  828.           pmassert( pmp->hab, NULL == "Error?? No application default queue" );
  829.           strcpy( pmp->achQueueName, pQueueInfo->pszName );
  830.        }
  831.     }
  832.     pmassert( pmp->hab, 0 < strlen( pmp->achQueueName ));
  833.  
  834.     /* find queue and queue settings including the driver data info */
  835.     i = FindQueue( pmp->achQueueName, pQueueInfo, cReturned );
  836.     pmassert( pmp->hab, i != -1 );
  837.     pqi = &pQueueInfo[i];
  838.  
  839.     /*
  840.      * Store current driver data info into SplEnumQueue info
  841.      * so that when user wants to change a job property
  842.      * but not necessarily a printer, his previous settings
  843.      * will be shown in the print properties dialog. Otherwise use
  844.      * the defaults from the SplEnumQueue info.
  845.      *
  846.      * Note if the device name, driver data length or version does not match,
  847.      * the driver may not be able to understand or correctly use the
  848.      * driver data info
  849.      */
  850.     if (pmp->cbDriverDataLen)
  851.     {
  852.       if ( ! strcmp( pqi->pDriverData->szDeviceName,
  853.                      pmp->pDriverData->szDeviceName ) )
  854.       {
  855.         if ( (pqi->pDriverData->cb == pmp->cbDriverDataLen ) &&
  856.              (pqi->pDriverData->lVersion == pmp->pDriverData->lVersion ) )
  857.         {
  858.           memcpy( pqi->pDriverData, pmp->pDriverData, pmp->cbDriverDataLen );
  859.         }
  860.         else
  861.         {
  862.           bOK = WinLoadString( pmp->hab,
  863.                                (HMODULE)NULLHANDLE,
  864.                                ERRMSG_NEW_DRIVER_VERSION,
  865.                                LEN_WORKSTRING,
  866.                                szWork );
  867.           pmassert( pmp->hab, bOK );
  868.  
  869.           WinMessageBox( HWND_DESKTOP,
  870.                          pmp->hwndFrame,
  871.                          szWork,
  872.                          pmp->pszTitle,
  873.                          (USHORT)0,
  874.                          MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
  875.         }
  876.       }
  877.       else
  878.       {
  879.         bOK = WinLoadString( pmp->hab,
  880.                              (HMODULE)NULLHANDLE,
  881.                              ERRMSG_DEVICE_CHANGED,
  882.                              LEN_WORKSTRING,
  883.                              szWork );
  884.         pmassert( pmp->hab, bOK );
  885.  
  886.         WinMessageBox( HWND_DESKTOP,
  887.                        pmp->hwndFrame,
  888.                        szWork,
  889.                        pmp->pszTitle,
  890.                        (USHORT)0,
  891.                        MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
  892.       }
  893.     }
  894.  
  895.     /*
  896.      * Display dialog box to select a printer
  897.      */
  898.  
  899.  
  900.     if (fShowDialog)
  901.     {
  902.         /* sort the data returned from SplEnumQueue by queue name  */
  903.         qsort((void *)pQueueInfo,
  904.           (size_t)cReturned,
  905.           (size_t)sizeof(PRQINFO3),
  906.           SortQueues);
  907.  
  908.         /*
  909.          * Dialog procedure requires the data from SplEnumQueue.
  910.          * Use the pmp to pass this data to the dialog.
  911.          */
  912.         pmp->pQueueInfo  = pQueueInfo;
  913.         pmp->lQueueCount = cReturned;
  914.  
  915.         /* present the dialog  */
  916.         ul = WinDlgBox( HWND_DESKTOP,
  917.                         pmp->hwndFrame,
  918.                         (PFNWP)QueryPrintDlgProc,
  919.                         (HMODULE)0,
  920.                         IDD_QUERYPRINT,
  921.                         (PVOID)pmp);
  922.  
  923.         pmassert( pmp->hab, ul != DID_ERROR );
  924.  
  925.         /* done with these vars for now  */
  926.         pmp->pQueueInfo  = NULL;
  927.         pmp->lQueueCount = 0;
  928.  
  929.  
  930.         if( ul == DID_CANCEL )
  931.         {
  932.              /* free queueinfo buffer for SplEnumQueue   */
  933.              free( pQueueInfo );
  934.              /* indicate to caller that no change occurred  */
  935.              return FALSE;
  936.         }
  937.     }
  938.  
  939.  
  940.  
  941.  
  942.     /*
  943.      * At this point, something changed about the printer destination:
  944.      * form, printer, queue, resolution, something.
  945.      *
  946.      * Prepare a printer info DC and associate a printer info PS with it
  947.      * for the print queue named by pmp->achQueueName.
  948.      */
  949.  
  950.  
  951.  
  952.     /* set pqi to point to the PRQINFO3 structure for pmp->achQueueName  */
  953.  
  954.     i = FindQueue( pmp->achQueueName, pQueueInfo, cReturned );
  955.     pmassert( pmp->hab, i  != -1 );
  956.     pqi = &pQueueInfo[i];
  957.  
  958.     /* destroy previous printer driver data */
  959.     if( pmp->pDriverData )
  960.     {
  961.         free( pmp->pDriverData );
  962.         pmp->pDriverData      = NULL;
  963.         pmp->cbDriverDataLen  = 0;
  964.     }
  965.  
  966.     /* store new driver name in pmp  */
  967.     strcpy( pmp->achDriverName, pqi->pszDriverName );
  968.  
  969.     /* store new driver data length in pmp  */
  970.     pmp->cbDriverDataLen  = pqi->pDriverData->cb;
  971.  
  972.     /* store new driver data in pmp  */
  973.     pmp->pDriverData = (PDRIVDATA) malloc( pmp->cbDriverDataLen );
  974.     pmassert( pmp->hab, pmp->pDriverData );
  975.     memcpy( pmp->pDriverData, pqi->pDriverData, pmp->cbDriverDataLen );
  976.  
  977.     /* store new queue description in pmp  */
  978.     strncpy(pmp->achQueueDesc, pqi->pszComment, QUEUEDESC_LENGTH);
  979.     pmp->achQueueDesc[QUEUEDESC_LENGTH-1] = 0;
  980.  
  981.     /*
  982.      * reset the printer info device context so that any changes
  983.      * will be found next time
  984.      */
  985.     ResetPrinterInfoDC( pmp );
  986.  
  987.  
  988.     /* free the buffer allocated for SplEnumQueue call  */
  989.     free( pQueueInfo );
  990.  
  991.     /* enable the Print menu item */
  992.     WinEnableMenuItem( pmp->hwndMenubar, IDM_PRINT, TRUE );
  993.  
  994.     /* return indication that something changed  */
  995.     return TRUE;
  996. }   /*  end of QueryPrintQueue */
  997.  
  998. /*************************************************************************
  999.  *  Function   :  QueryPrintDlgProc
  1000.  *
  1001.  *  Description:  This function is the dialog window procedure for printer
  1002.  *                selection.
  1003.  *                This dialog presents to the user a list of printer
  1004.  *                destinations, or queues.  Typically, the user would
  1005.  *                hilight a queue, then press the Job Properties... button
  1006.  *                to set items like orientation, form, resolution, etc.
  1007.  *                The printer driver presents the job properties dialog
  1008.  *                when the application calls DevPostDeviceModes.
  1009.  *
  1010.  *                Today, there is no standard, uniform way to tell whether
  1011.  *                the user pressed OK or Cancel at the Job Properties dialog;
  1012.  *                therefore, the dialog processing assumes that
  1013.  *                job properties were changed no matter if the
  1014.  *                user pressed OK or cancel. See the use of the
  1015.  *                fVisitedJobProperties Boolean variable.
  1016.  *
  1017.  *                This function is associated with the dialog box that is
  1018.  *                included in the function name of the procedure. It
  1019.  *                provides the service routines for the events (messages)
  1020.  *                that occur because the end user operates one of the dialog
  1021.  *                box's buttons, entry fields, or controls.
  1022.  *
  1023.  *                The SWITCH statement in the function distributes the dialog
  1024.  *                box messages to the respective service routines, which are
  1025.  *                set apart by the CASE clauses. Like any other PM window,
  1026.  *                the Dialog Window procedures must provide an appropriate
  1027.  *                service routine for their end user initiated messages as
  1028.  *                well as for the general PM messages (like the WM_CLOSE
  1029.  *                message). If a message is sent to this procedure for which
  1030.  *                there is no programmed CASE condition (no service routine),
  1031.  *                the message is defaulted to the WinDefDlgProc function,
  1032.  *                where it is disposed of by PM.
  1033.  *
  1034.  *  Parameters :  HWND         window handle of printer selection dialog
  1035.  *                USHORT       message
  1036.  *                MPARAM       message parameter 1
  1037.  *                MPARAM       message parameter 2
  1038.  *
  1039.  *  API's      :  WinSetWindowULong
  1040.  *                WinSendDlgItemMsg
  1041.  *                WinEnableControl
  1042.  *                WinSendDlgItemMsg
  1043.  *                WinQueryWindowULong
  1044.  *                WinDismissDlg
  1045.  *                WinDefDlgProc
  1046.  *
  1047.  * Return      :  message result
  1048.  *
  1049.  *************************************************************************/
  1050. MRESULT EXPENTRY QueryPrintDlgProc( HWND hwnd,
  1051.                                     USHORT msg,
  1052.                                     MPARAM mp1,
  1053.                                     MPARAM mp2 )
  1054. {
  1055.    static BOOL         fVisitedJobProperties;
  1056.    PMAIN_PARM          pmp;
  1057.    INT                 i, index;
  1058.    PSZ                 psz;
  1059.    HWND                hwndListbox;
  1060.    ULONG               ulPanel;
  1061.  
  1062.    switch (msg)
  1063.    {
  1064.    case WM_BUTTON1DBLCLK:
  1065.       WinSendMsg( hwnd, WM_COMMAND, (MPARAM)DID_OK, (MPARAM)0L );
  1066.       break;
  1067.  
  1068.  
  1069.    case WM_INITDLG:
  1070.       /* Get pointer to application specific data */
  1071.       pmp = (PMAIN_PARM) mp2;
  1072.       WinSetWindowULong( hwnd, QWL_USER, (ULONG) mp2 );
  1073.  
  1074.  
  1075.       /*
  1076.        *  Assume user will not select job properties.
  1077.        *  This affects how to dismiss this dialog.
  1078.        */
  1079.       fVisitedJobProperties = FALSE;
  1080.  
  1081.       /* Fill listbox with print objects */
  1082.  
  1083.         hwndListbox = WinWindowFromID( hwnd, IDD_QPLISTBOX );
  1084.         pmassert( pmp->hab, hwndListbox );
  1085.  
  1086.       for (i = 0; i < pmp->lQueueCount; ++i)
  1087.       {
  1088.        /* use printer comment if possible, else use queue name for display */
  1089.          psz = *pmp->pQueueInfo[i].pszComment ?
  1090.                 pmp->pQueueInfo[i].pszComment :
  1091.                 pmp->pQueueInfo[i].pszName;
  1092.             /* pmwin.h macro for inserting list box items   */
  1093.             index = WinInsertLboxItem( hwndListbox, LIT_END, psz );
  1094.  
  1095.             /* pre-select this one?  */
  1096.             if( 0 == strcmp( pmp->pQueueInfo[i].pszName, pmp->achQueueName ))
  1097.             {
  1098.                WinSendMsg( hwndListbox, LM_SELECTITEM,
  1099.                                             (MPARAM)index, (MPARAM)TRUE );
  1100.             }
  1101.       }
  1102.  
  1103.         /* one must be selected */
  1104.         index = WinQueryLboxSelectedItem( hwndListbox );
  1105.         pmassert( pmp->hab, index != LIT_NONE );
  1106.  
  1107.       return FALSE;
  1108.  
  1109.    case WM_HELP:
  1110.       /* get pointer to structure from window words of this dialog */
  1111.       pmp = (PMAIN_PARM)WinQueryWindowULong( hwnd, QWL_USER );
  1112.  
  1113.       if( pmp->hwndHelp )
  1114.       {
  1115.          ulPanel = PANEL_QUERYPRINT;
  1116.          WinSendMsg( pmp->hwndHelp, HM_DISPLAY_HELP,
  1117.                    (MPARAM)&ulPanel, (MPARAM)HM_RESOURCEID );
  1118.          return (MRESULT)NULL;
  1119.       }
  1120.       break;
  1121.  
  1122.  
  1123.    case WM_COMMAND:
  1124.       pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
  1125.       switch(SHORT1FROMMP(mp1))
  1126.       {
  1127.       case IDD_QPJOBPROP:
  1128.           /*
  1129.            * Flag that we visited the job properties dialog. Since
  1130.            * DevPostDeviceModes (OS2_PM_DRV_DEVMODES) option
  1131.            * DPDM_POSTJOBPROP has no return code or standard way to
  1132.            * indicate user cancel, we have to assume something might
  1133.            * have changed.
  1134.            */
  1135.           fVisitedJobProperties = TRUE;
  1136.           hwndListbox = WinWindowFromID( hwnd, IDD_QPLISTBOX );
  1137.           pmassert( pmp->hab, hwndListbox );
  1138.           index = WinQueryLboxSelectedItem( hwndListbox );
  1139.           pmassert( pmp->hab, index != LIT_NONE );
  1140.           QueryJobProperties( pmp->hab, &pmp->pQueueInfo[ index ] );
  1141.           return 0;
  1142.  
  1143.       case DID_OK:
  1144.             hwndListbox = WinWindowFromID( hwnd, IDD_QPLISTBOX );
  1145.             pmassert( pmp->hab, hwndListbox );
  1146.             index = WinQueryLboxSelectedItem( hwndListbox );
  1147.             pmassert( pmp->hab, index != LIT_NONE );
  1148.  
  1149.          /* modify pmp->achQueueName; it is now the user's preferred queue */
  1150.             strcpy( pmp->achQueueName,  pmp->pQueueInfo[ index ].pszName );
  1151.             WinDismissDlg( hwnd, DID_OK );
  1152.             return 0;
  1153.  
  1154.  
  1155.       case DID_CANCEL:
  1156.          WinDismissDlg(hwnd, fVisitedJobProperties ? DID_OK : DID_CANCEL );
  1157.          return (MRESULT)NULL;
  1158.       }
  1159.       break;
  1160.  
  1161.    }
  1162.    return( WinDefDlgProc(hwnd, msg, mp1, mp2) );
  1163. } /* End of QueryPrintDlgProc */
  1164.  
  1165.  
  1166. /*************************************************************************
  1167.  *  Function   :  QueryJobProperties
  1168.  *
  1169.  *  Description:  Query job properties (print properties) of the printer
  1170.  *                driver.
  1171.  *
  1172.  *  Parameters :  HAB             anchor block handle of the process
  1173.  *                PPRQINFO3       pointer to queue information structure
  1174.  *
  1175.  *  API's      :  DevPostDeviceModes
  1176.  *
  1177.  *  Return     :  TRUE if ok, otherwise FALSE
  1178.  *
  1179.  *************************************************************************/
  1180. BOOL QueryJobProperties(HAB hab, PPRQINFO3 pQueueInfo)
  1181. {
  1182.    CHAR        achDriverName[DRIVERNAME_LENGTH];
  1183.    CHAR        achDeviceName[DEVICENAME_LENGTH];
  1184.    INT         i;
  1185.    LONG        l;
  1186.    PSZ         pszTemp;
  1187.  
  1188.    /*
  1189.     * The pszDriverName is of the form DRIVER.DEVICE (e.g.,
  1190.     * LASERJET.HP LaserJet IID) so we need to separate it
  1191.     * at the dot
  1192.     */
  1193.    i = strcspn(pQueueInfo->pszDriverName, ".");
  1194.    if (i)
  1195.    {
  1196.       strncpy(achDriverName, pQueueInfo->pszDriverName, i);
  1197.       achDriverName[i] = '\0';
  1198.       strcpy(achDeviceName, &pQueueInfo->pszDriverName[i + 1]);
  1199.    }
  1200.    else
  1201.    {
  1202.       strcpy(achDriverName, pQueueInfo->pszDriverName);
  1203.       *achDeviceName = '\0';
  1204.    }
  1205.  
  1206.    /*
  1207.     * There may be more than one printer assigned to this print queue
  1208.     * We will use the first in the comma separated list.  We would
  1209.     * need an expanded dialog for the user to be more specific.
  1210.     */
  1211.    pszTemp = strchr(pQueueInfo->pszPrinters, ',');
  1212.    if ( pszTemp )
  1213.    {
  1214.       /* Strip off comma and trailing printer names */
  1215.       *pszTemp = '\0' ;
  1216.    }
  1217.  
  1218.    /*
  1219.     * Post the job properties dialog for the printer to allow the
  1220.     * user to modify the options
  1221.     */
  1222.    l = DevPostDeviceModes( hab,
  1223.                            pQueueInfo->pDriverData,
  1224.                            achDriverName,
  1225.                            achDeviceName,
  1226.                            pQueueInfo->pszPrinters,
  1227.                            DPDM_POSTJOBPROP );
  1228.  
  1229.    return (l == DEV_OK);
  1230. }  /* End of QueryJobProperties */
  1231.  
  1232. /*************************************************************************
  1233.  *
  1234.  *  Name:         ProcessUserPrint
  1235.  *
  1236.  *  Description:  This routine handles the user print (WM_USER_PRINT)
  1237.  *                message. We're running thread 2 here because it can be
  1238.  *                a long operation. The device context and presentation
  1239.  *                space are created here, then one of three functions
  1240.  *                is called to print depending on whether we have a
  1241.  *                bitmap, metafile or text document.
  1242.  *
  1243.  *  Parameters :  HWND           window handle
  1244.  *                PMAIN_PARM     global application data
  1245.  *
  1246.  *  API's      :  DevOpenDC
  1247.  *                GpiCreatePS
  1248.  *                DevEscape
  1249.  *                GpiAssociate
  1250.  *                GpiDestroyPS
  1251.  *                DevCloseDC
  1252.  *
  1253.  *  Return     :  VOID
  1254.  *
  1255.  *
  1256.  *************************************************************************/
  1257.  
  1258. VOID ProcessUserPrint( HWND hwnd, PMAIN_PARM pmp)
  1259. {
  1260.    DEVOPENSTRUC    dos;
  1261.    VOID            (*pfnPrintDocument)(HWND, PMAIN_PARM);
  1262.    CHAR            achDriverName[DRIVERNAME_LENGTH];
  1263.    CHAR            achQueueProcParams[8];
  1264.    CHAR            achSpoolerParams[40];
  1265.    SIZEL           sizel;
  1266.    PSZ             psz;
  1267.  
  1268.    /* Build the device context data for DevOpenDC */
  1269.    memset((PVOID)&dos, 0, sizeof(dos));
  1270.  
  1271.    strcpy(achDriverName, pmp->achDriverName);
  1272.    achDriverName[strcspn(achDriverName, ".")] = '\0';
  1273.    sprintf(achQueueProcParams, "COP=%d", pmp->usCopies);
  1274.    sprintf(achSpoolerParams, "FORM=%s", pmp->form.achFormName);
  1275.  
  1276.    dos.pszLogAddress = pmp->achQueueName;
  1277.    dos.pszDriverName = (PSZ)achDriverName;
  1278.    dos.pdriv = pmp->pDriverData;
  1279.    dos.pszDataType = (PSZ)"PM_Q_STD";
  1280.    dos.pszComment = pmp->pszTitle;
  1281.    dos.pszQueueProcParams = (PSZ)achQueueProcParams;
  1282.    dos.pszSpoolerParams = (PSZ)achSpoolerParams;
  1283.  
  1284.    /*
  1285.     * Switch on whether we are writing text, a bitmap
  1286.     * or a metafile into the PS, and process
  1287.     */
  1288.    switch (pmp->ulMode)
  1289.    {
  1290.    case MODE_TEXT:
  1291.         /* Seek to beginning of user-specified file */
  1292.       fseek(pmp->f, 0, SEEK_SET);
  1293.       pfnPrintDocument = PrinterPaginate;
  1294.       break;
  1295.  
  1296.    case MODE_BITMAP:
  1297.       pfnPrintDocument = PrinterBitblt;
  1298.       break;
  1299.  
  1300.    case MODE_METAFILE:
  1301.       pfnPrintDocument = PrinterPlayMetaFile;
  1302.       break;
  1303.  
  1304.    default:
  1305.       pmassert(pmp->hab, FALSE);
  1306.       return;
  1307.    }
  1308.  
  1309.    /* Create DC for the printer */
  1310.    pmp->hdcPrinter = DevOpenDC( pmp->hab,
  1311.                                 OD_QUEUED,
  1312.                                 "*",
  1313.                                 9L,
  1314.                                 (PVOID)&dos,
  1315.                                 (HDC)NULLHANDLE );
  1316.  
  1317.    /* Create PS for the printer */
  1318.    pmp->hpsPrinter = GPI_ERROR;
  1319.    if (pmp->hdcPrinter != DEV_ERROR)
  1320.    {
  1321.       /*
  1322.        * Set page size to 0,0. A page size should not be defined for printing
  1323.        * because when the job is printed, the output will be scaled to fit
  1324.        * the page size specified on GpiCreatePS
  1325.        */
  1326.       sizel.cx = 0;
  1327.       sizel.cy = 0;
  1328.       pmp->hpsPrinter = GpiCreatePS( pmp->hab,
  1329.                                      pmp->hdcPrinter,
  1330.                                      &sizel,
  1331.                                      PU_TWIPS | GPIA_ASSOC );
  1332.       pmassert( pmp->hab, pmp->hpsPrinter != GPI_ERROR );
  1333.  
  1334.       if (pmp->hpsPrinter != GPI_ERROR)
  1335.       {
  1336.          /* parse full-qualified filename to just get filename and extension */
  1337.          psz = strrchr( pmp->szFilename, '\\' );
  1338.          if (psz && *psz)
  1339.          {
  1340.              ++psz;
  1341.          }
  1342.          else
  1343.          {
  1344.              psz = pmp->szFilename;
  1345.          }
  1346.  
  1347.          /* Issue STARTDOC to begin printing */
  1348.          DevEscape( pmp->hdcPrinter,
  1349.                     DEVESC_STARTDOC,
  1350.                     (LONG)strlen(psz),
  1351.                     (PBYTE)psz,
  1352.                     (PLONG)NULL, (PBYTE)NULL );
  1353.  
  1354.          /* Print the document */
  1355.          (*pfnPrintDocument)(hwnd, pmp);
  1356.  
  1357.          /*
  1358.           * Issue ABORTDOC if user cancelled print job, or ENDDOC
  1359.           * to for normal job termination.
  1360.           */
  1361.          DevEscape( pmp->hdcPrinter,
  1362.                     pmp->fCancel ? DEVESC_ABORTDOC : DEVESC_ENDDOC,
  1363.                     0L, (PBYTE)NULL, (PLONG)NULL, (PBYTE)NULL );
  1364.  
  1365.          /* Release and destroy the PS */
  1366.          GpiAssociate( pmp->hpsPrinter, (HDC)NULLHANDLE );
  1367.          GpiDestroyPS( pmp->hpsPrinter );
  1368.       }
  1369.    }
  1370.  
  1371.    /* Clean up the DC */
  1372.    if (pmp->hdcPrinter != DEV_ERROR)
  1373.    {
  1374.       DevCloseDC(pmp->hdcPrinter);
  1375.       pmp->hdcPrinter = DEV_ERROR;
  1376.    }
  1377.  
  1378.    return;
  1379. }
  1380.  
  1381. /*************************************************************************
  1382.  *
  1383.  *  Name       :  PrinterBitblt
  1384.  *
  1385.  *  Description:  Load a bitmap into a memory DC using the WM_USER_LOAD_BITMAP
  1386.  *                processing. Calculate what size to print the bitmap in order
  1387.  *                to preserve the bitmap aspect ratio and still have it fit on
  1388.  *                the page. Then bit blit into the printer PS, allowing the
  1389.  *                device presentation driver to do the stretch blit.
  1390.  *
  1391.  *  Parameters :  HWND           window handle
  1392.  *                PMAIN_PARM     global application data
  1393.  *
  1394.  *  API's      :  WinSendMsg
  1395.  *                GpiQueryPS
  1396.  *                GpiConvert
  1397.  *                GpiBitblt
  1398.  *                GpiSetBitmap
  1399.  *                GpiDeleteBitmap
  1400.  *                GpiAssociate
  1401.  *                GpiDestroyPS
  1402.  *                DevCloseDC
  1403.  *
  1404.  *  Return     :  VOID
  1405.  *
  1406.  *************************************************************************/
  1407.  
  1408. VOID PrinterBitblt(HWND hwnd, PMAIN_PARM pmp)
  1409. {
  1410.  
  1411.     /* Clear our variables to ensure USER_LOAD_BITMAP starts fresh */
  1412.     pmp->hdcMem4Printer = (HDC)NULLHANDLE;
  1413.     pmp->hpsMem4Printer = (HPS)NULLHANDLE;
  1414.     pmp->hbm4Printer = (HBITMAP)NULLHANDLE;
  1415.  
  1416.     /* update print confirmation dialog */
  1417.     WinSendMsg( pmp->hwndPrinting, WM_USER_NEW_PAGE, MPFROMLONG(1L), NULL);
  1418.  
  1419.     /* Send message to create a printer PS with our bitmap set into it */
  1420.     WinSendMsg(hwnd, WM_USER_LOAD_BITMAP, (MPARAM)hwnd,
  1421.                (MPARAM)FLAGS_PRINTER);
  1422.  
  1423.     /* draw bitmap into presentation space */
  1424.     PaintBitmap( pmp, FLAGS_PRINTER );
  1425.  
  1426.     /* Clean up bitmap, memory PS and memory DC */
  1427.     GpiDeleteBitmap( pmp->hbm4Printer );
  1428.     GpiAssociate( pmp->hpsMem4Printer, (HDC)NULLHANDLE );
  1429.     GpiDestroyPS( pmp->hpsMem4Printer );
  1430.     DevCloseDC( pmp->hdcMem4Printer );
  1431.  
  1432.     return;
  1433. }  /* End of PrinterBitblt */
  1434.  
  1435. /*************************************************************************
  1436.  *
  1437.  *  Name:      :  PrinterPaginate
  1438.  *
  1439.  *  Description:  This function uses WM_USER_PAGINATE processing to
  1440.  *                print text to printer There is a check of the fCancel
  1441.  *                Boolean in the main parameters after paginating each
  1442.  *                page. If this Boolean becomes true, then printing the
  1443.  *                text is aborted.
  1444.  *
  1445.  *  API's      :  GpiCreateLogFont
  1446.  *                GpiSetCharSet
  1447.  *                WinSendMsg
  1448.  *                DevEscape
  1449.  *                GpiSetCharSet
  1450.  *                GpiDeleteSetId
  1451.  *
  1452.  *  Return     :  VOID
  1453.  *
  1454.  *************************************************************************/
  1455. VOID PrinterPaginate(HWND hwnd, PMAIN_PARM pmp)
  1456. {
  1457.    ULONG   ul;
  1458.    BOOL    bOK;
  1459.    ULONG   cPage = 0;
  1460.    ULONG   cPagesPrinted = 0;
  1461.    CHAR    szWork[LEN_WORKSTRING];
  1462.  
  1463.    /*
  1464.     * Create a logical font for the printer and set it
  1465.     * into the PS
  1466.     */
  1467.    ul = (ULONG)GpiCreateLogFont( pmp->hpsPrinter,
  1468.                                  (PSTR8)NULL,
  1469.                                  1L,
  1470.                                  (PFATTRS)&pmp->fontdlg.fAttrs );
  1471.    pmassert(pmp->hab, ul != GPI_ERROR);
  1472.  
  1473.    bOK = GpiSetCharSet( pmp->hpsPrinter, 1L );
  1474.    pmassert( pmp->hab, bOK );
  1475.  
  1476.    if (!pmp->fPrintAllPages && pmp->usFirstPage != 1)
  1477.    {
  1478.       WinSendMsg( pmp->hwndPrinting, WM_USER_SKIP_PAGE,
  1479.                   MPFROMLONG(pmp->usFirstPage), NULL);
  1480.    }
  1481.  
  1482.    do
  1483.    {
  1484.       cPage++;
  1485.       /*
  1486.        * Print to info PS until correct page is reached
  1487.        */
  1488.       if (!pmp->fPrintAllPages && cPage < pmp->usFirstPage)
  1489.       {
  1490.          ul = (ULONG)WinSendMsg( hwnd, WM_USER_PAGINATE, (MPARAM)hwnd,
  1491.                                  (MPARAM)FLAGS_INFO );
  1492.       }
  1493.       else
  1494.       {
  1495.          WinSendMsg( pmp->hwndPrinting, WM_USER_NEW_PAGE,
  1496.                      MPFROMLONG(cPage), NULL);
  1497.          ul = (ULONG)WinSendMsg( hwnd, WM_USER_PAGINATE, (MPARAM)hwnd,
  1498.                                  (MPARAM)FLAGS_PRINTER );
  1499.          cPagesPrinted++;
  1500.       }
  1501.  
  1502.       /* break out of loop if no more pages to print */
  1503.       if (!pmp->fPrintAllPages && cPage + 1 > pmp->usLastPage)
  1504.       {
  1505.          break;
  1506.       }
  1507.  
  1508.       if ( ul == PAGINATE_NOT_EOF )
  1509.       {
  1510.          DevEscape( pmp->hdcPrinter,
  1511.                     DEVESC_NEWFRAME,
  1512.                     0L,
  1513.                     (PBYTE)NULL,
  1514.                     (PLONG)NULL,
  1515.                     (PBYTE)NULL );
  1516.       }
  1517.       else
  1518.       {
  1519.            /* End of file; Break out of this loop and return to do enddoc */
  1520.           break;
  1521.       }
  1522.     } while ( !pmp->fCancel );
  1523.  
  1524.     /* Report error if no pages actually printed */
  1525.     if (! cPagesPrinted)
  1526.     {
  1527.       bOK = WinLoadString( pmp->hab,
  1528.                            (HMODULE)NULLHANDLE,
  1529.                            ERRMSG_NOTHING_PRINTED,
  1530.                            LEN_WORKSTRING,
  1531.                            szWork );
  1532.       pmassert( pmp->hab, bOK );
  1533.       WinMessageBox( HWND_DESKTOP,
  1534.                      pmp->hwndFrame,
  1535.                      szWork,
  1536.                      pmp->pszTitle,
  1537.                      (USHORT)0,
  1538.                      MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
  1539.     }
  1540.  
  1541.     /* Clean up logical font id */
  1542.     GpiSetCharSet(pmp->hpsPrinter, 0L);
  1543.     GpiDeleteSetId(pmp->hpsPrinter, 1L);
  1544.  
  1545.    return;
  1546. }  /* End of PrinterPaginate */
  1547.  
  1548. /*************************************************************************
  1549.  *
  1550.  *  Name       :  PrinterPlayMetafile
  1551.  *
  1552.  *  Description:  Play metafile into printer PS without the reset and
  1553.  *                suppress options.
  1554.  *
  1555.  *  Parameters :  HWND           window handle
  1556.  *                PMAIN_PARM     global application data
  1557.  *
  1558.  *  Return     :  VOID
  1559.  *
  1560.  *************************************************************************/
  1561. VOID PrinterPlayMetaFile(HWND hwnd, PMAIN_PARM pmp)
  1562. {
  1563.     /* update print confirmation dialog */
  1564.     WinSendMsg( pmp->hwndPrinting, WM_USER_NEW_PAGE, MPFROMLONG(1L), NULL);
  1565.     /* print metafile */
  1566.     PaintMetaFile( pmp, FLAGS_PRINTER );
  1567.     return;
  1568. }  /* End of PrinterPlayMetafile */
  1569.  
  1570. /*************************************************************************
  1571.  *
  1572.  *   Function   :  FindQueue
  1573.  *
  1574.  *   Description:  Finds the queue name in the PRQINFO3 structure.
  1575.  *
  1576.  *   Parameters :  PSZ          pointer to the name of the queue
  1577.  *                 PPRQINFO3    pointer to queue selection structure 1
  1578.  *                 SHORT        number of queue names to compare
  1579.  *
  1580.  *   API's      :  [none]
  1581.  *
  1582.  *************************************************************************/
  1583. LONG FindQueue(PSZ pszQueueName, PPRQINFO3 pQueueInfo, LONG lCount)
  1584. {
  1585.    LONG i;
  1586.  
  1587.    for (i = 0L; i < lCount; ++i)
  1588.    {
  1589.       if ( !strcmp( pszQueueName, pQueueInfo[i].pszName ) )
  1590.          return i;
  1591.    }
  1592.  
  1593.    return -1L;                 /*  if not found  */
  1594. }  /* End of FindQueue */
  1595.  
  1596. /*************************************************************************
  1597.  *  Function   :  SortQueues
  1598.  *
  1599.  *  Description:  Compare routine for sorting the queue names table.
  1600.  *
  1601.  *  Parameters :  PPRQINFO3    pointer to queue selection structure 1
  1602.  *                PPRQINFO3    pointer to queue selection structure 2
  1603.  *
  1604.  *  API's      :  [none]
  1605.  *
  1606.  *  Return     :  result of comparison
  1607.  *
  1608.  *************************************************************************/
  1609. static int _Optlink SortQueues(const void *pQueue1, const void *pQueue2)
  1610. {
  1611. return(strcmp(((PPRQINFO3)pQueue1)->pszComment,
  1612.               ((PPRQINFO3)pQueue2)->pszComment));
  1613. } /* end of SortQueues() */
  1614.  
  1615.  
  1616. /*************************************************************************
  1617.  *  Function   :  ResetPrinterInfoDC
  1618.  *
  1619.  *  Description:  Close the info DC, PS and re-open another one
  1620.  *
  1621.  *  Parameters :  PMP          pointer to global data structure
  1622.  *
  1623.  *  API's      :  [none]
  1624.  *
  1625.  *  Return     :  [none]
  1626.  *
  1627.  *************************************************************************/
  1628. VOID ResetPrinterInfoDC( PMAIN_PARM pmp )
  1629. {
  1630.     CHAR            achDriverName[DRIVERNAME_LENGTH];
  1631.     SIZEL           sizel;
  1632.     DEVOPENSTRUC    dos;
  1633.  
  1634.     /* initialize local variables to zeros */
  1635.     memset( &dos,   0, sizeof(dos));
  1636.     memset( &sizel, 0, sizeof(sizel));
  1637.  
  1638.  
  1639.     /* destroy previous printer info PS's and DC's */
  1640.     if( pmp->hpsPrinterInfo )
  1641.     {
  1642.         GpiAssociate(pmp->hpsPrinterInfo, (HDC)NULL);
  1643.         GpiDestroyPS(pmp->hpsPrinterInfo);
  1644.         pmp->hpsPrinterInfo = (HPS)0;
  1645.     }
  1646.     if( pmp->hdcPrinterInfo )
  1647.     {
  1648.         DevCloseDC(pmp->hdcPrinterInfo);
  1649.         pmp->hdcPrinterInfo = (HDC)0;
  1650.     }
  1651.  
  1652.     /* build a devopenstruct for the call to DevOpenDC */
  1653.     dos.pszLogAddress = pmp->achQueueName;
  1654.     strcpy( achDriverName, pmp->achDriverName );
  1655.     achDriverName[strcspn(achDriverName, ".")] = '\0';
  1656.     dos.pszDriverName = (PSZ)achDriverName;
  1657.     dos.pdriv = pmp->pDriverData;
  1658.  
  1659.     /* Create an OD_INFO device context */
  1660.     pmp->hdcPrinterInfo = DevOpenDC(
  1661.                             pmp->hab,
  1662.                             OD_INFO,
  1663.                             "*",
  1664.                             3L,
  1665.                             (PVOID)&dos,
  1666.                             (HDC)NULL);
  1667.     pmassert(pmp->hab, pmp->hdcPrinterInfo != DEV_ERROR);
  1668.  
  1669.  
  1670.     /* create PS for printer info -- not a full-blown PS */
  1671.     pmp->hpsPrinterInfo = GpiCreatePS(
  1672.                         pmp->hab,
  1673.                         pmp->hdcPrinterInfo,
  1674.                         (PSIZEL)&sizel,
  1675.                         PU_TWIPS | GPIA_ASSOC);
  1676.     pmassert(pmp->hab, pmp->hpsPrinterInfo != GPI_ERROR);
  1677.  
  1678. } /* end of ResetPrinterInfoDC */
  1679.  
  1680. /***************************  End of prtprint.c ****************************/
  1681.