widget/os2/nsPrintOS2.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "nsPrintOS2.h"
   6
   7 #include "nsOS2Uni.h"
   8
   9 #include <stdlib.h>
  10
  11 //---------------------------------------------------------------------------
  12 // OS/2 Printing   - was in libprint.cpp
  13 //---------------------------------------------------------------------------
  14 static HMODULE hmodRes;
  15
  16 #define SHIFT_PTR(ptr,offset) ( *((LONG*)&ptr) += offset )
  17
  18
  19 class PRTQUEUE
  20 {
  21 public:
  22    PRTQUEUE (const PRQINFO3* pPQI3)  { InitWithPQI3 (pPQI3); }
  23    PRTQUEUE (const PRTQUEUE& PQInfo);
  24   ~PRTQUEUE (void) { free (mpPQI3); }
  25
  26    PRQINFO3& PQI3 () const { return *mpPQI3; }
  27    const char* DriverName () const { return mDriverName; }
  28    const char* DeviceName () const { return mDeviceName; }
  29    const char* PrinterName() const { return mPrinterName; }
  30    const char* QueueName  () const { return mpPQI3->pszComment; }
  31
  32 private:
  33    PRTQUEUE& operator = (const PRTQUEUE& z);        // prevent copying
  34    void InitWithPQI3 (const PRQINFO3* pInfo);
  35
  36    PRQINFO3* mpPQI3;
  37    unsigned  mPQI3BufSize;
  38    char mDriverName  [DRIV_NAME_SIZE + 1];          // Driver name
  39    char mDeviceName  [DRIV_DEVICENAME_SIZE + 1];    // Device name
  40    char mPrinterName [PRINTERNAME_SIZE + 1];        // Printer name
  41 };
  42
  43
  44 PRTQUEUE::PRTQUEUE (const PRTQUEUE& PQInfo)
  45 {
  46    mPQI3BufSize = PQInfo.mPQI3BufSize;
  47    mpPQI3 = (PRQINFO3*)malloc (mPQI3BufSize);
  48    memcpy (mpPQI3, PQInfo.mpPQI3, mPQI3BufSize);    // Copy entire buffer
  49
  50    long Diff = (long)mpPQI3 - (long)PQInfo.mpPQI3;  // Calculate the difference between addresses
  51    SHIFT_PTR (mpPQI3->pszName,       Diff);         // Modify internal pointers accordingly
  52    SHIFT_PTR (mpPQI3->pszSepFile,    Diff);
  53    SHIFT_PTR (mpPQI3->pszPrProc,     Diff);
  54    SHIFT_PTR (mpPQI3->pszParms,      Diff);
  55    SHIFT_PTR (mpPQI3->pszComment,    Diff);
  56    SHIFT_PTR (mpPQI3->pszPrinters,   Diff);
  57    SHIFT_PTR (mpPQI3->pszDriverName, Diff);
  58    SHIFT_PTR (mpPQI3->pDriverData,   Diff);
  59
  60    strcpy (mDriverName, PQInfo.mDriverName);
  61    strcpy (mDeviceName, PQInfo.mDeviceName);
  62    strcpy (mPrinterName, PQInfo.mPrinterName);
  63 }
  64
  65 void PRTQUEUE::InitWithPQI3(const PRQINFO3* pInfo)
  66 {
  67    // Make local copy of PPRQINFO3 object
  68    ULONG SizeNeeded;
  69    ::SplQueryQueue (nullptr, pInfo->pszName, 3, nullptr, 0, &SizeNeeded);
  70    mpPQI3 = (PRQINFO3*)malloc (SizeNeeded);
  71    ::SplQueryQueue (nullptr, pInfo->pszName, 3, mpPQI3, SizeNeeded, &SizeNeeded);
  72
  73    mPQI3BufSize = SizeNeeded;
  74
  75    PCHAR sep = strchr (pInfo->pszDriverName, '.');
  76
  77    if (sep)
  78    {
  79       *sep = '\0';
  80       strcpy (mDriverName, pInfo->pszDriverName);
  81       strcpy (mDeviceName, sep + 1);
  82       *sep = '.';
  83    } else
  84    {
  85       strcpy (mDriverName, pInfo->pszDriverName);
  86       mDeviceName [0] = '\0';
  87    }
  88
  89
  90    sep = strchr (pInfo->pszPrinters, ',');
  91
  92    if (sep)
  93    {
  94       *sep = '\0';
  95       strcpy (mPrinterName, pInfo->pszPrinters);
  96       *sep = '.';
  97    } else
  98    {
  99       strcpy (mPrinterName, pInfo->pszPrinters);
 100    }
 101 }
 102
 103
 104 //===========================================================================
 105
 106 PRINTDLG::PRINTDLG()
 107 {
 108   mQueueCount = 0;
 109
 110   ULONG TotalQueues = 0;
 111   ULONG MemNeeded = 0;
 112   SPLERR rc;
 113
 114   rc = ::SplEnumQueue(nullptr, 3, nullptr, 0, &mQueueCount,
 115                       &TotalQueues, &MemNeeded, nullptr);
 116   PRQINFO3* pPQI3Buf = (PRQINFO3*) malloc (MemNeeded);
 117   rc = ::SplEnumQueue(nullptr, 3, pPQI3Buf, MemNeeded, &mQueueCount,
 118                       &TotalQueues, &MemNeeded, nullptr);
 119
 120   if (mQueueCount > MAX_PRINT_QUEUES)
 121     mQueueCount = MAX_PRINT_QUEUES;
 122
 123   ULONG defaultQueue = 0;
 124   for (ULONG cnt = 0; cnt < mQueueCount; cnt++) {
 125     if (pPQI3Buf[cnt].fsType & PRQ3_TYPE_APPDEFAULT)
 126       defaultQueue = cnt;
 127     mPQBuf[cnt] = new PRTQUEUE(&pPQI3Buf[cnt]);
 128   }
 129
 130   // move the entry for the default printer to index 0 (if necessary)
 131   if (defaultQueue > 0) {
 132     PRTQUEUE* temp = mPQBuf[0];
 133     mPQBuf[0] = mPQBuf[defaultQueue];
 134     mPQBuf[defaultQueue] = temp;
 135   }
 136
 137   free(pPQI3Buf);
 138 }
 139
 140 PRINTDLG::~PRINTDLG()
 141 {
 142   for (ULONG index = 0; index < mQueueCount; index++)
 143     delete mPQBuf[index];
 144 }
 145
 146 void PRINTDLG::RefreshPrintQueue()
 147 {
 148   ULONG newQueueCount = 0;
 149   ULONG TotalQueues = 0;
 150   ULONG MemNeeded = 0;
 151   SPLERR rc;
 152
 153   rc = ::SplEnumQueue(nullptr, 3, nullptr, 0, &newQueueCount,
 154                       &TotalQueues, &MemNeeded, nullptr);
 155   PRQINFO3* pPQI3Buf = (PRQINFO3*)malloc(MemNeeded);
 156   rc = ::SplEnumQueue(nullptr, 3, pPQI3Buf, MemNeeded, &newQueueCount,
 157                       &TotalQueues, &MemNeeded, nullptr);
 158
 159   if (newQueueCount > MAX_PRINT_QUEUES)
 160     newQueueCount = MAX_PRINT_QUEUES;
 161
 162   PRTQUEUE* tmpBuf[MAX_PRINT_QUEUES];
 163
 164   ULONG defaultQueue = 0;
 165   for (ULONG cnt = 0; cnt < newQueueCount; cnt++) {
 166     if (pPQI3Buf[cnt].fsType & PRQ3_TYPE_APPDEFAULT)
 167       defaultQueue = cnt;
 168
 169     BOOL found = FALSE;
 170     for (ULONG index = 0; index < mQueueCount && !found; index++) {
 171        //Compare printer from requeried list with what's already in Mozilla's printer list(mPQBuf)
 172        //If printer is already there, use current properties; otherwise create a new printer in list
 173        if (mPQBuf[index] != 0) {
 174          if ((strcmp(pPQI3Buf[cnt].pszPrinters, mPQBuf[index]->PrinterName()) == 0) &&
 175              (strcmp(pPQI3Buf[cnt].pszDriverName, mPQBuf[index]->PQI3().pszDriverName) == 0)) {
 176            found = TRUE;
 177            tmpBuf[cnt] = mPQBuf[index];
 178            mPQBuf[index] = 0;
 179          }
 180        }
 181     }
 182     if (!found)
 183        tmpBuf[cnt] = new PRTQUEUE(&pPQI3Buf[cnt]);
 184   }
 185
 186   for (ULONG index = 0; index < newQueueCount; index++) {
 187     if (mPQBuf[index] != 0)
 188       delete(mPQBuf[index]);
 189     mPQBuf[index] = tmpBuf[index];
 190   }
 191
 192   if (mQueueCount > newQueueCount)
 193     for (ULONG index = newQueueCount; index < mQueueCount; index++)
 194        if (mPQBuf[index] != 0)
 195          delete(mPQBuf[index]);
 196
 197   mQueueCount = newQueueCount;
 198
 199   // move the entry for the default printer to index 0 (if necessary)
 200   if (defaultQueue > 0) {
 201     PRTQUEUE* temp = mPQBuf[0];
 202     mPQBuf[0] = mPQBuf[defaultQueue];
 203     mPQBuf[defaultQueue] = temp;
 204   }
 205
 206   free(pPQI3Buf);
 207 }
 208
 209 ULONG PRINTDLG::GetNumPrinters()
 210 {
 211    return mQueueCount;
 212 }
 213
 214 void PRINTDLG::GetPrinter(ULONG printerNdx, char** printerName)
 215 {
 216    if (printerNdx >= mQueueCount)
 217       return;
 218
 219    nsAutoCString pName(mPQBuf[printerNdx]->QueueName());
 220
 221    pName.ReplaceChar('\r', ' ');
 222    pName.StripChars("\n");
 223    *printerName = ToNewCString(pName);
 224 }
 225
 226 PRTQUEUE* PRINTDLG::SetPrinterQueue(ULONG printerNdx)
 227 {
 228    PRTQUEUE *pPQ = nullptr;
 229
 230    if (printerNdx >= mQueueCount)
 231       return nullptr;
 232
 233    pPQ = mPQBuf[printerNdx];
 234
 235    return new PRTQUEUE(*pPQ);
 236 }
 237
 238 LONG PRINTDLG::GetPrintDriverSize(ULONG printerNdx)
 239 {
 240    return mPQBuf[printerNdx]->PQI3().pDriverData->cb;
 241 }
 242
 243 PDRIVDATA PRINTDLG::GetPrintDriver(ULONG printerNdx)
 244 {
 245    if (printerNdx >= mQueueCount)
 246       return nullptr;
 247
 248    return mPQBuf[printerNdx]->PQI3().pDriverData;
 249 }
 250
 251 HDC PRINTDLG::GetDCHandle(ULONG printerNdx)
 252 {
 253     HDC hdc = 0;
 254     DEVOPENSTRUC dop;
 255
 256     dop.pszLogAddress      = 0;
 257     dop.pszDriverName      = (char *)mPQBuf[printerNdx]->DriverName();
 258     dop.pdriv              = mPQBuf[printerNdx]->PQI3().pDriverData;
 259     dop.pszDataType        = 0;
 260     dop.pszComment         = 0;
 261     dop.pszQueueProcName   = 0;
 262     dop.pszQueueProcParams = 0;
 263     dop.pszSpoolerParams   = 0;
 264     dop.pszNetworkParams   = 0;
 265
 266     hdc = ::DevOpenDC(0, OD_INFO, "*", 9, (PDEVOPENDATA) &dop, NULLHANDLE);
 267     return hdc;
 268 }
 269
 270 char* PRINTDLG::GetDriverType(ULONG printerNdx)
 271 {
 272   return (char *)mPQBuf[printerNdx]->DriverName ();
 273 }
 274
 275 BOOL PRINTDLG::ShowProperties(ULONG printerNdx)
 276 {
 277     BOOL          rc = FALSE;
 278     LONG          devrc = FALSE;
 279     PDRIVDATA     pOldDrivData;
 280     PDRIVDATA     pNewDrivData = nullptr;
 281     LONG          buflen;
 282
 283 /* check size of buffer required for job properties */
 284     buflen = DevPostDeviceModes( 0 /*hab*/,
 285                                  nullptr,
 286                                  mPQBuf[printerNdx]->DriverName (),
 287                                  mPQBuf[printerNdx]->DeviceName (),
 288                                  mPQBuf[printerNdx]->PrinterName (),
 289                                  DPDM_POSTJOBPROP);
 290
 291 /* return error to caller */
 292     if (buflen <= 0)
 293         return(buflen);
 294
 295 /* allocate some memory for larger job properties and */
 296 /* return error to caller */
 297
 298     if (buflen != mPQBuf[printerNdx]->PQI3().pDriverData->cb)
 299     {
 300         if (DosAllocMem((PPVOID)&pNewDrivData,buflen,fALLOC))
 301             return(FALSE); // DPDM_ERROR
 302
 303 /* copy over old data so driver can use old job */
 304 /* properties as base for job properties dialog */
 305         pOldDrivData = mPQBuf[printerNdx]->PQI3().pDriverData;
 306         mPQBuf[printerNdx]->PQI3().pDriverData = pNewDrivData;
 307         memcpy( (PSZ)pNewDrivData, (PSZ)pOldDrivData, pOldDrivData->cb );
 308     }
 309
 310 /* display job properties dialog and get updated */
 311 /* job properties from driver */
 312
 313     devrc = DevPostDeviceModes( 0 /*hab*/,
 314                                 mPQBuf[printerNdx]->PQI3().pDriverData,
 315                                 mPQBuf[printerNdx]->DriverName (),
 316                                 mPQBuf[printerNdx]->DeviceName (),
 317                                 mPQBuf[printerNdx]->PrinterName (),
 318                                 DPDM_POSTJOBPROP);
 319     rc = (devrc != DPDM_ERROR);
 320     return rc;
 321 }
 322
 323 /****************************************************************************/
 324 /*  Job management                                                          */
 325 /****************************************************************************/
 326
 327 HDC PrnOpenDC( PRTQUEUE *pInfo, PCSZ pszApplicationName, int copies, int destination, char *file )
 328 {
 329    HDC hdc = 0;
 330    PCSZ pszLogAddress;
 331    PCSZ pszDataType;
 332    LONG dcType;
 333    DEVOPENSTRUC dop;
 334
 335    if (!pInfo || !pszApplicationName)
 336       return hdc;
 337
 338    if ( destination ) {
 339       pszLogAddress = pInfo->PQI3 ().pszName;
 340       pszDataType = "PM_Q_STD";
 341       if ( destination == 2 )
 342          dcType = OD_METAFILE;
 343       else
 344          dcType = OD_QUEUED;
 345    } else {
 346       if (file && *file)
 347          pszLogAddress = (PSZ) file;
 348       else
 349          pszLogAddress = "FILE";
 350       pszDataType = "PM_Q_RAW";
 351       dcType = OD_DIRECT;
 352    }
 353
 354    dop.pszLogAddress      = const_cast<PSZ>(pszLogAddress);
 355    dop.pszDriverName      = (char*)pInfo->DriverName ();
 356    dop.pdriv              = pInfo->PQI3 ().pDriverData;
 357    dop.pszDataType        = const_cast<PSZ>(pszDataType);
 358    dop.pszComment         = const_cast<PSZ>(pszApplicationName);
 359    dop.pszQueueProcName   = pInfo->PQI3 ().pszPrProc;
 360    dop.pszQueueProcParams = 0;
 361    dop.pszSpoolerParams   = 0;
 362    dop.pszNetworkParams   = 0;
 363
 364    hdc = ::DevOpenDC( 0, dcType, "*", 9, (PDEVOPENDATA) &dop, NULLHANDLE);
 365
 366 #ifdef DEBUG
 367    if (hdc == 0)
 368    {
 369       ULONG ErrorCode = ERRORIDERROR (::WinGetLastError (0));
 370       printf ("!ERROR! - Can't open DC for printer %04lX\a\n", ErrorCode);
 371    }
 372 #endif
 373
 374    return hdc;
 375 }
 376
 377 /* find the selected form */
 378 BOOL PrnQueryHardcopyCaps( HDC hdc, PHCINFO pHCInfo)
 379 {
 380    BOOL rc = FALSE;
 381
 382    if( hdc && pHCInfo)
 383    {
 384       PHCINFO pBuffer;
 385       long    lAvail, i;
 386
 387       /* query how many forms are available */
 388       lAvail = ::DevQueryHardcopyCaps( hdc, 0, 0, nullptr);
 389
 390       pBuffer = (PHCINFO) malloc( lAvail * sizeof(HCINFO));
 391
 392       ::DevQueryHardcopyCaps( hdc, 0, lAvail, pBuffer);
 393
 394       for( i = 0; i < lAvail; i++)
 395          if( pBuffer[ i].flAttributes & HCAPS_CURRENT)
 396          {
 397             memcpy( pHCInfo, pBuffer + i, sizeof(HCINFO));
 398             rc = TRUE;
 399             break;
 400          }
 401
 402       free( pBuffer);
 403    }
 404
 405    return rc;
 406 }
 407
 408
 409 /****************************************************************************/
 410 /*  Library-level data and functions    -Printing                           */
 411 /****************************************************************************/
 412
 413 BOOL PrnInitialize( HMODULE hmodResources)
 414 {
 415    hmodRes = hmodResources;
 416    return TRUE;
 417 }
 418
 419 BOOL PrnTerminate()
 420 {
 421    /* nop for now, may do something eventually */
 422    return TRUE;
 423 }
 424
 425 BOOL PrnClosePrinter( PRTQUEUE *pPrintQueue)
 426 {
 427    BOOL rc = FALSE;
 428
 429    if (pPrintQueue)
 430    {
 431       delete pPrintQueue;
 432       rc = TRUE;
 433    }
 434
 435    return rc;
 436 }
 437