| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // use this define to disable the DJP support |
| // #define NO_DJP |
| |
| #define INCL_DOSMODULEMGR |
| #define INCL_DEV |
| #define INCL_SPL |
| #define INCL_SPLERRORS |
| #define INCL_SPLDOSPRINT |
| #define INCL_DEVDJP |
| |
| #define INCL_GPI |
| #define INCL_DOSSEMAPHORES |
| #define INCL_PM |
| #include <svpm.h> |
| #include <pmdjp.h> |
| |
| #include <string.h> |
| |
| #include <osl/module.h> |
| |
| #include <tools/urlobj.hxx> |
| #include <tools/svwin.h> |
| #ifdef __MINGW32__ |
| #include <excpt.h> |
| #endif |
| |
| #include <os2/saldata.hxx> |
| #include <os2/salinst.h> |
| #include <os2/salgdi.h> |
| #include <os2/salframe.h> |
| #include <os2/salprn.h> |
| |
| #include <salptype.hxx> |
| #include <print.h> |
| #include <jobset.h> |
| |
| #include <malloc.h> |
| |
| #ifndef __H_FT2LIB |
| #include <os2/wingdi.h> |
| #include <ft2lib.h> |
| #endif |
| |
| // ======================================================================= |
| |
| // ----------------------- |
| // - struct ImplFormInfo - |
| // ----------------------- |
| |
| struct ImplFormInfo |
| { |
| long mnPaperWidth; |
| long mnPaperHeight; |
| #ifndef NO_DJP |
| DJPT_PAPERSIZE mnId; |
| #endif |
| }; |
| |
| // ======================================================================= |
| |
| // ----------------------- |
| // - struct ImplTrayInfo - |
| // ----------------------- |
| |
| struct ImplTrayInfo |
| { |
| CHAR maName[32]; |
| CHAR maDisplayName[64]; |
| DJPT_TRAYTYPE mnId; |
| |
| ImplTrayInfo( const char* pTrayName, |
| const char* pTrayDisplayName ) |
| { |
| strcpy( maName, pTrayName); |
| strcpy( maDisplayName, pTrayDisplayName); |
| } |
| }; |
| |
| // ======================================================================= |
| |
| struct ImplQueueSalSysData |
| { |
| ByteString maPrinterName; // pszPrinters |
| ByteString maName; // pszName bzw. LogAddress |
| ByteString maOrgDriverName; // pszDriverName (maDriverName.maDeviceName) |
| ByteString maDriverName; // pszDriverName bis . |
| ByteString maDeviceName; // pszDriverName nach . |
| PDRIVDATA mpDrivData; |
| |
| ImplQueueSalSysData( const ByteString& rPrinterName, |
| const ByteString& rName, |
| const ByteString& rDriverName, |
| const ByteString& rDeviceName, |
| const ByteString& rOrgDriverName, |
| PDRIVDATA pDrivData ); |
| ~ImplQueueSalSysData(); |
| }; |
| |
| // ----------------------------------------------------------------------- |
| |
| ImplQueueSalSysData::ImplQueueSalSysData( const ByteString& rPrinterName, |
| const ByteString& rName, |
| const ByteString& rOrgDriverName, |
| const ByteString& rDriverName, |
| const ByteString& rDeviceName, |
| PDRIVDATA pDrivData ) : |
| maPrinterName( rPrinterName ), |
| maName( rName ), |
| maOrgDriverName( rName ), |
| maDriverName( rDriverName ), |
| maDeviceName( rDeviceName ) |
| { |
| if ( pDrivData ) |
| { |
| mpDrivData = (PDRIVDATA)new PM_BYTE[pDrivData->cb]; |
| memcpy( mpDrivData, pDrivData, pDrivData->cb ); |
| } |
| else |
| mpDrivData = NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ImplQueueSalSysData::~ImplQueueSalSysData() |
| { |
| delete mpDrivData; |
| } |
| |
| // ======================================================================= |
| |
| static ULONG ImplPMQueueStatusToSal( USHORT nPMStatus ) |
| { |
| ULONG nStatus = 0; |
| if ( nPMStatus & PRQ3_PAUSED ) |
| nStatus |= QUEUE_STATUS_PAUSED; |
| if ( nPMStatus & PRQ3_PENDING ) |
| nStatus |= QUEUE_STATUS_PENDING_DELETION; |
| if ( !nStatus ) |
| nStatus |= QUEUE_STATUS_READY; |
| return nStatus; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList ) |
| { |
| APIRET rc; |
| ULONG nNeeded; |
| ULONG nReturned; |
| ULONG nTotal; |
| |
| // query needed size of the buffer for the QueueInfo |
| rc = SplEnumQueue( (PSZ)NULL, 3, NULL, 0, &nReturned, &nTotal, &nNeeded, NULL ); |
| if( nNeeded == 0 ) |
| return; |
| |
| // create the buffer for the QueueInfo |
| PCHAR pQueueData = new CHAR[nNeeded]; |
| |
| // query QueueInfos |
| rc = SplEnumQueue( (PSZ)NULL, 3, pQueueData, nNeeded, &nReturned, &nTotal, &nNeeded, NULL ); |
| |
| PPRQINFO3 pPrqInfo = (PPRQINFO3)pQueueData; |
| for ( int i = 0; i < nReturned; i++ ) |
| { |
| // create entry for the QueueInfo array |
| SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo; |
| |
| ByteString aOrgDriverName( pPrqInfo->pszDriverName); |
| ByteString aName( pPrqInfo->pszName); |
| #if OSL_DEBUG_LEVEL>0 |
| printf("GetPrinterQueueInfo pszDriverName %s\n", pPrqInfo->pszDriverName); |
| printf("GetPrinterQueueInfo pszName %s\n", pPrqInfo->pszDriverName); |
| #endif |
| pInfo->maDriver = ::rtl::OStringToOUString (aOrgDriverName, gsl_getSystemTextEncoding()); |
| pInfo->maPrinterName = ::rtl::OStringToOUString (pPrqInfo->pszComment, gsl_getSystemTextEncoding()); |
| pInfo->maLocation = ::rtl::OStringToOUString (aName, gsl_getSystemTextEncoding()); |
| pInfo->mnStatus = ImplPMQueueStatusToSal( pPrqInfo->fsStatus ); |
| pInfo->mnJobs = pPrqInfo->cJobs; |
| // pInfo->maComment = !!! |
| |
| // Feststellen, ob Name doppelt |
| PPRQINFO3 pTempPrqInfo = (PPRQINFO3)pQueueData; |
| for ( int j = 0; j < nReturned; j++ ) |
| { |
| // Wenn Name doppelt, erweitern wir diesen um die Location |
| if ( (j != i) && |
| (strcmp( pPrqInfo->pszComment, pTempPrqInfo->pszComment ) == 0) ) |
| { |
| pInfo->maPrinterName += ';'; |
| pInfo->maPrinterName += pInfo->maLocation; |
| } |
| pTempPrqInfo++; |
| } |
| |
| // pszDriver in DriverName (bis .) und DeviceName (nach .) aufsplitten |
| PSZ pDriverName; |
| PSZ pDeviceName; |
| if ( (pDriverName = strchr( pPrqInfo->pszDriverName, '.' )) != 0 ) |
| { |
| *pDriverName = 0; |
| pDeviceName = pDriverName + 1; |
| } |
| else |
| pDeviceName = NULL; |
| |
| // Alle Bytes hinter dem DeviceNamen auf 0 initialisieren, damit |
| // ein memcmp vom JobSetup auch funktioniert |
| if ( pPrqInfo->pDriverData && |
| (pPrqInfo->pDriverData->cb >= sizeof( pPrqInfo->pDriverData )) ) |
| { |
| int nDeviceNameLen = strlen( pPrqInfo->pDriverData->szDeviceName ); |
| memset( pPrqInfo->pDriverData->szDeviceName+nDeviceNameLen, |
| 0, |
| sizeof( pPrqInfo->pDriverData->szDeviceName )-nDeviceNameLen ); |
| } |
| |
| // save driver data and driver names |
| ByteString aPrinterName( pPrqInfo->pszPrinters); |
| ByteString aDriverName( pPrqInfo->pszDriverName); |
| ByteString aDeviceName; |
| if ( pDeviceName ) |
| aDeviceName = pDeviceName; |
| pInfo->mpSysData = new ImplQueueSalSysData( aPrinterName, aName, |
| aOrgDriverName, |
| aDriverName, aDeviceName, |
| pPrqInfo->pDriverData ); |
| |
| // add queue to the list |
| pList->Add( pInfo ); |
| |
| // increment to next element of the QueueInfo array |
| pPrqInfo++; |
| } |
| |
| delete [] pQueueData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInstance::GetPrinterQueueState( SalPrinterQueueInfo* pInfo ) |
| { |
| APIRET rc; |
| ULONG nNeeded; |
| ULONG nReturned; |
| ULONG nTotal; |
| |
| // query needed size of the buffer for the QueueInfo |
| rc = SplEnumQueue( (PSZ)NULL, 3, NULL, 0, &nReturned, &nTotal, &nNeeded, NULL ); |
| if( nNeeded == 0 ) |
| return; |
| |
| // create the buffer for the QueueInfo |
| PCHAR pQueueData = new CHAR[nNeeded]; |
| |
| // query QueueInfos |
| rc = SplEnumQueue( (PSZ)NULL, 3, pQueueData, nNeeded, &nReturned, &nTotal, &nNeeded, NULL ); |
| |
| PPRQINFO3 pPrqInfo = (PPRQINFO3)pQueueData; |
| for ( int i = 0; i < nReturned; i++ ) |
| { |
| ImplQueueSalSysData* pSysData = (ImplQueueSalSysData*)(pInfo->mpSysData); |
| if ( pSysData->maPrinterName.Equals( pPrqInfo->pszPrinters ) && |
| pSysData->maName.Equals( pPrqInfo->pszName ) && |
| pSysData->maOrgDriverName.Equals( pPrqInfo->pszDriverName ) ) |
| { |
| pInfo->mnStatus = ImplPMQueueStatusToSal( pPrqInfo->fsStatus ); |
| pInfo->mnJobs = pPrqInfo->cJobs; |
| break; |
| } |
| |
| // increment to next element of the QueueInfo array |
| pPrqInfo++; |
| } |
| |
| delete [] pQueueData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo ) |
| { |
| delete ((ImplQueueSalSysData*)(pInfo->mpSysData)); |
| delete pInfo; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| XubString Os2SalInstance::GetDefaultPrinter() |
| { |
| APIRET rc; |
| ULONG nNeeded; |
| ULONG nReturned; |
| ULONG nTotal; |
| char szQueueName[255]; |
| XubString aDefaultName; |
| |
| // query default queue |
| if ( !PrfQueryProfileString( HINI_PROFILE, SPL_INI_SPOOLER, "QUEUE", 0, szQueueName, sizeof( szQueueName ) ) ) |
| return aDefaultName; |
| |
| // extract first queue name |
| PSZ pStr; |
| if ( (pStr = strchr( szQueueName, ';' )) != 0 ) |
| *pStr = 0; |
| |
| // query needed size of the buffer for the QueueInfo |
| rc = SplEnumQueue( (PSZ)NULL, 3, NULL, 0, &nReturned, &nTotal, &nNeeded, NULL ); |
| if ( nNeeded == 0 ) |
| return aDefaultName; |
| |
| // create the buffer for the QueueInfo |
| PCHAR pQueueData = new CHAR[ nNeeded ]; |
| |
| // query QueueInfos |
| rc = SplEnumQueue ((PSZ)NULL, 3, pQueueData, nNeeded, &nReturned, &nTotal, &nNeeded, NULL ); |
| |
| // find printer name for default queue |
| PPRQINFO3 pPrqInfo = (PPRQINFO3) pQueueData; |
| for ( int i = 0; i < nReturned; i++ ) |
| { |
| if ( strcmp( pPrqInfo->pszName, szQueueName ) == 0 ) |
| { |
| aDefaultName = ::rtl::OStringToOUString (pPrqInfo->pszComment, gsl_getSystemTextEncoding()); |
| |
| // Feststellen, ob Name doppelt |
| PPRQINFO3 pTempPrqInfo = (PPRQINFO3)pQueueData; |
| for ( int j = 0; j < nReturned; j++ ) |
| { |
| // Wenn Name doppelt, erweitern wir diesen um die Location |
| if ( (j != i) && |
| (strcmp( pPrqInfo->pszComment, pTempPrqInfo->pszComment ) == 0) ) |
| { |
| String pszName( ::rtl::OStringToOUString (pPrqInfo->pszName, gsl_getSystemTextEncoding())); |
| aDefaultName += ';'; |
| aDefaultName += pszName; |
| } |
| pTempPrqInfo++; |
| } |
| break; |
| } |
| |
| // increment to next element of the QueueInfo array |
| pPrqInfo++; |
| } |
| |
| delete [] pQueueData; |
| |
| return aDefaultName; |
| } |
| |
| // ======================================================================= |
| |
| static void* ImplAllocPrnMemory( size_t n ) |
| { |
| return calloc( n, 1); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| inline void ImplFreePrnMemory( void* p ) |
| { |
| free( p ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static PDRIVDATA ImplPrnDrivData( const ImplJobSetup* pSetupData ) |
| { |
| // Diese Funktion wird eingesetzt, damit Druckertreiber nicht auf |
| // unseren Daten arbeiten, da es durch Konfigurationsprobleme |
| // sein kann, das der Druckertreiber bei uns Daten ueberschreibt. |
| // Durch diese vorgehensweise werden einige Abstuerze vermieden, bzw. |
| // sind dadurch leichter zu finden |
| |
| if ( !pSetupData->mpDriverData ) |
| return NULL; |
| |
| DBG_ASSERT( ((PDRIVDATA)(pSetupData->mpDriverData))->cb == pSetupData->mnDriverDataLen, |
| "ImplPrnDrivData() - SetupDataLen != DriverDataLen" ); |
| |
| PDRIVDATA pDrivData = (PDRIVDATA)ImplAllocPrnMemory( pSetupData->mnDriverDataLen ); |
| memcpy( pDrivData, pSetupData->mpDriverData, pSetupData->mnDriverDataLen ); |
| return pDrivData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplUpdateSetupData( const PDRIVDATA pDrivData, ImplJobSetup* pSetupData ) |
| { |
| // Diese Funktion wird eingesetzt, damit Druckertreiber nicht auf |
| // unseren Daten arbeiten, da es durch Konfigurationsprobleme |
| // sein kann, das der Druckertreiber bei uns Daten ueberschreibt. |
| // Durch diese vorgehensweise werden einige Abstuerze vermieden, bzw. |
| // sind dadurch leichter zu finden |
| |
| if ( !pDrivData || !pDrivData->cb ) |
| { |
| if ( pSetupData->mpDriverData ) |
| rtl_freeMemory( pSetupData->mpDriverData ); |
| pSetupData->mpDriverData = NULL; |
| pSetupData->mnDriverDataLen = 0; |
| } |
| else |
| { |
| // Alle Bytes hinter dem DeviceNamen auf 0 initialisieren, damit |
| // ein memcmp vom JobSetup auch funktioniert |
| if ( pDrivData->cb >= sizeof( pDrivData ) ) |
| { |
| int nDeviceNameLen = strlen( pDrivData->szDeviceName ); |
| memset( pDrivData->szDeviceName+nDeviceNameLen, |
| 0, |
| sizeof( pDrivData->szDeviceName )-nDeviceNameLen ); |
| } |
| |
| if ( pSetupData->mpDriverData ) |
| { |
| if ( pSetupData->mnDriverDataLen != pDrivData->cb ) |
| rtl_freeMemory( pSetupData->mpDriverData ); |
| pSetupData->mpDriverData = (sal_uInt8*)rtl_allocateMemory( pDrivData->cb); |
| } |
| else |
| pSetupData->mpDriverData = (sal_uInt8*)rtl_allocateMemory( pDrivData->cb); |
| pSetupData->mnDriverDataLen = pDrivData->cb; |
| memcpy( pSetupData->mpDriverData, pDrivData, pDrivData->cb ); |
| } |
| |
| if ( pDrivData ) |
| ImplFreePrnMemory( pDrivData ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplPaperSizeEqual( long nPaperWidth1, long nPaperHeight1, |
| long nPaperWidth2, long nPaperHeight2 ) |
| { |
| return (((nPaperWidth1 >= nPaperWidth2-1) && (nPaperWidth1 <= nPaperWidth2+1)) && |
| ((nPaperHeight1 >= nPaperHeight2-1) && (nPaperHeight1 <= nPaperHeight2+1))); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplIsDriverDJPEnabled( HDC hDC ) |
| { |
| #ifdef NO_DJP |
| return FALSE; |
| #else |
| // Ueber OS2-Ini kann DJP disablte werden |
| if ( !PrfQueryProfileInt( HINI_PROFILE, SAL_PROFILE_APPNAME, SAL_PROFILE_USEDJP, 1 ) ) |
| return FALSE; |
| |
| // Testen, ob DJP-Interface am Drucker vorhanden |
| LONG lQuery; |
| APIRET rc; |
| |
| lQuery = DEVESC_QUERYSIZE; |
| rc = DevEscape( hDC, |
| DEVESC_QUERYESCSUPPORT, |
| sizeof( lQuery ), |
| (PBYTE)&lQuery, |
| 0, |
| (PBYTE)NULL ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| lQuery = DEVESC_QUERYJOBPROPERTIES; |
| rc = DevEscape( hDC, |
| DEVESC_QUERYESCSUPPORT, |
| sizeof( lQuery ), |
| (PBYTE)&lQuery, |
| 0, |
| (PBYTE)NULL ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| lQuery = DEVESC_SETJOBPROPERTIES; |
| rc = DevEscape( hDC, |
| DEVESC_QUERYESCSUPPORT, |
| sizeof( lQuery ), |
| (PBYTE)&lQuery, |
| 0, |
| (PBYTE)NULL ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| return TRUE; |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplFormatInputList( PDJP_ITEM pDJP, PQUERYTUPLE pTuple ) |
| { |
| // Loop through the query elements |
| sal_Bool fContinue = TRUE; |
| do |
| { |
| pDJP->cb = sizeof (DJP_ITEM); |
| pDJP->ulProperty = pTuple->ulProperty; |
| pDJP->lType = pTuple->lType; |
| pDJP->ulNumReturned = 0; |
| pDJP->ulValue = DJP_NONE; |
| |
| // at EOL? |
| fContinue = DJP_NONE != pTuple->ulProperty; |
| |
| // Move to next item structure and tuplet |
| pDJP++; |
| pTuple++; |
| } |
| while ( fContinue ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplFreeFormAndTrayList( Os2SalInfoPrinter* pOs2SalInfoPrinter ) |
| { |
| if ( pOs2SalInfoPrinter->mnFormCount ) |
| { |
| for ( USHORT i = 0; i < pOs2SalInfoPrinter->mnFormCount; i++ ) |
| delete pOs2SalInfoPrinter->mpFormArray[i]; |
| delete [] pOs2SalInfoPrinter->mpFormArray; |
| pOs2SalInfoPrinter->mnFormCount = 0; |
| } |
| |
| if ( pOs2SalInfoPrinter->mnTrayCount ) |
| { |
| for ( USHORT i = 0; i < pOs2SalInfoPrinter->mnTrayCount; i++ ) |
| delete pOs2SalInfoPrinter->mpTrayArray[i]; |
| delete [] pOs2SalInfoPrinter->mpTrayArray; |
| pOs2SalInfoPrinter->mnTrayCount = 0; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplGetFormAndTrayList( Os2SalInfoPrinter* pOs2SalInfoPrinter, const ImplJobSetup* pSetupData ) |
| { |
| // if not defined, suppose default orientation is portrait |
| Orientation orientation = ORIENTATION_PORTRAIT; |
| |
| ImplFreeFormAndTrayList( pOs2SalInfoPrinter ); |
| |
| LONG alQuery[] = |
| { |
| 0, 0, // First two members of QUERYSIZE |
| DJP_SJ_ORIENTATION, DJP_CURRENT, |
| DJP_CJ_FORM, DJP_ALL, |
| DJP_CJ_TRAYNAME, DJP_ALL, |
| DJP_NONE, DJP_NONE // EOL marker |
| }; |
| |
| APIRET rc; |
| PQUERYSIZE pQuerySize = (PQUERYSIZE)alQuery; |
| PBYTE pBuffer = NULL; |
| LONG nAlloc = 0; |
| PDRIVDATA pCopyDrivData = ImplPrnDrivData( pSetupData ); |
| LONG nDrivDataSize = pCopyDrivData->cb; |
| PBYTE pDrivData = (PBYTE)pCopyDrivData; |
| |
| // find out how many bytes to allocate |
| pQuerySize->cb = sizeof( alQuery ); |
| rc = DevEscape( pOs2SalInfoPrinter->mhDC, |
| DEVESC_QUERYSIZE, |
| sizeof( alQuery ), |
| (PBYTE)pQuerySize, |
| &nDrivDataSize, |
| pDrivData ); |
| if ( DEV_OK != rc ) |
| { |
| ImplFreePrnMemory( pCopyDrivData ); |
| return; |
| } |
| |
| // allocate the memory |
| nAlloc = pQuerySize->ulSizeNeeded; |
| pBuffer = (PBYTE)new PM_BYTE[nAlloc]; |
| |
| // set up the input |
| PDJP_ITEM pDJP = (PDJP_ITEM)pBuffer; |
| ImplFormatInputList( pDJP, pQuerySize->aTuples ); |
| |
| // do it! |
| rc = DevEscape( pOs2SalInfoPrinter->mhDC, |
| DEVESC_QUERYJOBPROPERTIES, |
| nAlloc, |
| pBuffer, |
| &nDrivDataSize, |
| pDrivData ); |
| ImplFreePrnMemory( pCopyDrivData ); |
| |
| if ( (DEV_OK == rc) || (DEV_WARNING == rc) ) |
| { |
| // Loop through the query elements |
| PQUERYTUPLE pTuple = pQuerySize->aTuples; |
| while ( DJP_NONE != pTuple->ulProperty ) |
| { |
| if ( pDJP->ulProperty == DJP_SJ_ORIENTATION ) |
| { |
| if ( pDJP->ulNumReturned ) |
| { |
| PDJPT_ORIENTATION pElm = DJP_ELEMENTP( *pDJP, DJPT_ORIENTATION ); |
| if ( (DJP_ORI_PORTRAIT == *pElm) || (DJP_ORI_REV_PORTRAIT == *pElm) ) |
| orientation = ORIENTATION_PORTRAIT; |
| else |
| orientation = ORIENTATION_LANDSCAPE; |
| } |
| } |
| else if ( pDJP->ulProperty == DJP_CJ_FORM ) |
| { |
| if ( pDJP->ulNumReturned ) |
| { |
| PDJPT_FORM pElm = DJP_ELEMENTP( *pDJP, DJPT_FORM ); |
| |
| pOs2SalInfoPrinter->mnFormCount = pDJP->ulNumReturned; |
| pOs2SalInfoPrinter->mpFormArray = new PIMPLFORMINFO[pOs2SalInfoPrinter->mnFormCount]; |
| for( int i = 0; i < pDJP->ulNumReturned; i++, pElm++ ) |
| { |
| ImplFormInfo* pInfo = new ImplFormInfo; |
| // AOO expects form size always in portrait mode |
| if (orientation == ORIENTATION_PORTRAIT) |
| { |
| pInfo->mnPaperWidth = pElm->hcInfo.cx; |
| pInfo->mnPaperHeight = pElm->hcInfo.cy; |
| } |
| else |
| { |
| pInfo->mnPaperWidth = pElm->hcInfo.cy; |
| pInfo->mnPaperHeight = pElm->hcInfo.cx; |
| } |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf("ImplGetFormAndTrayList #%d: %d x %d", |
| i, pInfo->mnPaperWidth, pInfo->mnPaperHeight); |
| #endif |
| pInfo->mnId = pElm->djppsFormID; |
| pOs2SalInfoPrinter->mpFormArray[i] = pInfo; |
| } |
| } |
| } |
| else if ( pDJP->ulProperty == DJP_CJ_TRAYNAME ) |
| { |
| if ( pDJP->ulNumReturned ) |
| { |
| PDJPT_TRAYNAME pElm = DJP_ELEMENTP( *pDJP, DJPT_TRAYNAME ); |
| |
| pOs2SalInfoPrinter->mnTrayCount = pDJP->ulNumReturned; |
| pOs2SalInfoPrinter->mpTrayArray = new PIMPLTRAYINFO[pOs2SalInfoPrinter->mnTrayCount]; |
| for( int i = 0; i < pDJP->ulNumReturned; i++, pElm++ ) |
| { |
| ImplTrayInfo* pInfo = new ImplTrayInfo( pElm->szTrayname, pElm->szDisplayTrayname ); |
| pInfo->mnId = pElm->djpttTrayID; |
| pOs2SalInfoPrinter->mpTrayArray[i] = pInfo; |
| } |
| } |
| } |
| |
| pDJP = DJP_NEXT_STRUCTP( pDJP ); |
| pTuple++; |
| } |
| } |
| |
| delete [] pBuffer; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplGetCurrentSettings( Os2SalInfoPrinter* pOs2SalInfoPrinter, ImplJobSetup* pSetupData ) |
| { |
| // Um den aktuellen Tray zu ermitteln, brauchen wir auch die Listen dazu |
| if ( !pOs2SalInfoPrinter->mnFormCount ) |
| ImplGetFormAndTrayList( pOs2SalInfoPrinter, pSetupData ); |
| |
| LONG alQuery[] = |
| { |
| 0, 0, // First two members of QUERYSIZE |
| DJP_SJ_ORIENTATION, DJP_CURRENT, |
| DJP_CJ_FORM, DJP_CURRENT, |
| DJP_NONE, DJP_NONE // EOL marker |
| }; |
| |
| APIRET rc; |
| PQUERYSIZE pQuerySize = (PQUERYSIZE)alQuery; |
| PBYTE pBuffer = NULL; |
| LONG nAlloc = 0; |
| PDRIVDATA pCopyDrivData = ImplPrnDrivData( pSetupData ); |
| LONG nDrivDataSize = pCopyDrivData->cb; |
| PBYTE pDrivData = (PBYTE)pCopyDrivData; |
| sal_Bool bResult; |
| |
| // find out how many bytes to allocate |
| pQuerySize->cb = sizeof( alQuery ); |
| rc = DevEscape( pOs2SalInfoPrinter->mhDC, |
| DEVESC_QUERYSIZE, |
| sizeof( alQuery ), |
| (PBYTE)pQuerySize, |
| &nDrivDataSize, |
| pDrivData ); |
| if ( DEV_OK != rc ) |
| { |
| ImplFreePrnMemory( pCopyDrivData ); |
| return FALSE; |
| } |
| |
| // allocate the memory |
| nAlloc = pQuerySize->ulSizeNeeded; |
| pBuffer = (PBYTE)new PM_BYTE[nAlloc]; |
| |
| // set up the input |
| PDJP_ITEM pDJP = (PDJP_ITEM)pBuffer; |
| ImplFormatInputList( pDJP, pQuerySize->aTuples ); |
| |
| rc = DevEscape( pOs2SalInfoPrinter->mhDC, |
| DEVESC_QUERYJOBPROPERTIES, |
| nAlloc, |
| pBuffer, |
| &nDrivDataSize, |
| pDrivData ); |
| if ( (DEV_OK == rc) || (DEV_WARNING == rc) ) |
| { |
| // aktuelle Setup-Daten uebernehmen |
| ImplUpdateSetupData( pCopyDrivData, pSetupData ); |
| |
| // Loop through the query elements |
| PQUERYTUPLE pTuple = pQuerySize->aTuples; |
| while ( DJP_NONE != pTuple->ulProperty ) |
| { |
| if ( pDJP->ulProperty == DJP_SJ_ORIENTATION ) |
| { |
| if ( pDJP->ulNumReturned ) |
| { |
| PDJPT_ORIENTATION pElm = DJP_ELEMENTP( *pDJP, DJPT_ORIENTATION ); |
| if ( (DJP_ORI_PORTRAIT == *pElm) || (DJP_ORI_REV_PORTRAIT == *pElm) ) |
| pSetupData->meOrientation = ORIENTATION_PORTRAIT; |
| else |
| pSetupData->meOrientation = ORIENTATION_LANDSCAPE; |
| } |
| } |
| else if ( pDJP->ulProperty == DJP_CJ_FORM ) |
| { |
| if ( pDJP->ulNumReturned ) |
| { |
| PDJPT_FORM pElm = DJP_ELEMENTP( *pDJP, DJPT_FORM ); |
| |
| pSetupData->mnPaperWidth = pElm->hcInfo.cx*100; |
| pSetupData->mnPaperHeight = pElm->hcInfo.cy*100; |
| switch( pElm->djppsFormID ) |
| { |
| case DJP_PSI_A3: |
| pSetupData->mePaperFormat = PAPER_A3; |
| break; |
| |
| case DJP_PSI_A4: |
| pSetupData->mePaperFormat = PAPER_A4; |
| break; |
| |
| case DJP_PSI_A5: |
| pSetupData->mePaperFormat = PAPER_A5; |
| break; |
| |
| case DJP_PSI_B4: |
| pSetupData->mePaperFormat = PAPER_B4_JIS; |
| break; |
| |
| case DJP_PSI_B5: |
| pSetupData->mePaperFormat = PAPER_B5_JIS; |
| break; |
| |
| case DJP_PSI_LETTER: |
| pSetupData->mePaperFormat = PAPER_LETTER; |
| break; |
| |
| case DJP_PSI_LEGAL: |
| pSetupData->mePaperFormat = PAPER_LEGAL; |
| break; |
| |
| case DJP_PSI_TABLOID: |
| pSetupData->mePaperFormat = PAPER_TABLOID; |
| break; |
| |
| default: |
| pSetupData->mePaperFormat = PAPER_USER; |
| break; |
| } |
| |
| // Wir suchen zuerst ueber den Namen/Id und dann ueber die Id |
| sal_Bool bTrayFound = FALSE; |
| USHORT j; |
| for ( j = 0; j < pOs2SalInfoPrinter->mnTrayCount; j++ ) |
| { |
| if ( (pOs2SalInfoPrinter->mpTrayArray[j]->mnId == pElm->djpttTrayID) && |
| (pOs2SalInfoPrinter->mpTrayArray[j]->maName == pElm->szTrayname) ) |
| { |
| pSetupData->mnPaperBin = j; |
| bTrayFound = TRUE; |
| break; |
| } |
| } |
| if ( !bTrayFound ) |
| { |
| for ( j = 0; j < pOs2SalInfoPrinter->mnTrayCount; j++ ) |
| { |
| if ( pOs2SalInfoPrinter->mpTrayArray[j]->mnId == pElm->djpttTrayID ) |
| { |
| pSetupData->mnPaperBin = j; |
| bTrayFound = TRUE; |
| break; |
| } |
| } |
| } |
| // Wenn wir Ihn immer noch nicht gefunden haben, setzen |
| // wir ihn auf DontKnow |
| if ( !bTrayFound ) |
| pSetupData->mnPaperBin = 0xFFFF; |
| } |
| } |
| |
| pDJP = DJP_NEXT_STRUCTP( pDJP ); |
| pTuple++; |
| } |
| |
| bResult = TRUE; |
| } |
| else |
| { |
| ImplFreePrnMemory( pCopyDrivData ); |
| bResult = FALSE; |
| } |
| |
| delete [] pBuffer; |
| |
| return bResult; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplSetOrientation( HDC hPrinterDC, PDRIVDATA pDriverData, |
| Orientation eOrientation ) |
| { |
| LONG alQuery[] = |
| { |
| 0, 0, // First two members of QUERYSIZE |
| DJP_SJ_ORIENTATION, DJP_CURRENT, |
| DJP_NONE, DJP_NONE // EOL marker |
| }; |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "ImplSetOrientation mhDC %x, %d", hPrinterDC, eOrientation); |
| #endif |
| |
| APIRET rc; |
| PQUERYSIZE pQuerySize = (PQUERYSIZE)alQuery; |
| PBYTE pBuffer = NULL; |
| LONG nAlloc = 0; |
| LONG nDrivDataSize = pDriverData->cb; |
| |
| // find out how many bytes to allocate |
| pQuerySize->cb = sizeof( alQuery ); |
| rc = DevEscape( hPrinterDC, |
| DEVESC_QUERYSIZE, |
| sizeof( alQuery ), |
| (PBYTE)pQuerySize, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| // allocate the memory |
| nAlloc = pQuerySize->ulSizeNeeded; |
| pBuffer = (PBYTE)new PM_BYTE[nAlloc]; |
| |
| // set up the input |
| PDJP_ITEM pDJP = (PDJP_ITEM)pBuffer; |
| ImplFormatInputList( pDJP, pQuerySize->aTuples ); |
| |
| pDJP->cb = sizeof( DJP_ITEM ); |
| pDJP->ulProperty = DJP_SJ_ORIENTATION; |
| pDJP->lType = DJP_CURRENT; |
| pDJP->ulValue = (eOrientation == ORIENTATION_PORTRAIT) |
| ? DJP_ORI_PORTRAIT |
| : DJP_ORI_LANDSCAPE; |
| |
| // do it! |
| rc = DevEscape( hPrinterDC, |
| DEVESC_SETJOBPROPERTIES, |
| nAlloc, |
| pBuffer, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| |
| delete [] pBuffer; |
| |
| return ((DEV_OK == rc) || (DEV_WARNING == rc)); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplSetPaperSize( HDC hPrinterDC, PDRIVDATA pDriverData, |
| DJPT_PAPERSIZE nOS2PaperFormat ) |
| { |
| LONG alQuery[] = |
| { |
| 0, 0, // First two members of QUERYSIZE |
| DJP_SJ_PAPERSIZE, DJP_CURRENT, |
| DJP_NONE, DJP_NONE // EOL marker |
| }; |
| |
| APIRET rc; |
| PQUERYSIZE pQuerySize = (PQUERYSIZE)alQuery; |
| PBYTE pBuffer = NULL; |
| LONG nAlloc = 0; |
| LONG nDrivDataSize = pDriverData->cb; |
| |
| // find out how many bytes to allocate |
| pQuerySize->cb = sizeof( alQuery ); |
| rc = DevEscape( hPrinterDC, |
| DEVESC_QUERYSIZE, |
| sizeof( alQuery ), |
| (PBYTE)pQuerySize, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| // allocate the memory |
| nAlloc = pQuerySize->ulSizeNeeded; |
| pBuffer = (PBYTE)new PM_BYTE[nAlloc]; |
| |
| // set up the input |
| PDJP_ITEM pDJP = (PDJP_ITEM)pBuffer; |
| PDJP_ITEM pStartDJP = pDJP; |
| ImplFormatInputList( pDJP, pQuerySize->aTuples ); |
| |
| // Neue Daten zuweisen |
| pDJP->cb = sizeof( DJP_ITEM ); |
| pDJP->ulProperty = DJP_SJ_PAPERSIZE; |
| pDJP->lType = DJP_CURRENT; |
| pDJP->ulValue = nOS2PaperFormat; |
| |
| // und setzen |
| rc = DevEscape( hPrinterDC, |
| DEVESC_SETJOBPROPERTIES, |
| nAlloc, |
| pBuffer, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| |
| delete [] pBuffer; |
| |
| return ((DEV_OK == rc) || (DEV_WARNING == rc)); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplSetPaperBin( HDC hPrinterDC, PDRIVDATA pDriverData, |
| ImplTrayInfo* pTrayInfo ) |
| { |
| LONG alQuery[] = |
| { |
| 0, 0, // First two members of QUERYSIZE |
| DJP_SJ_TRAYTYPE, DJP_CURRENT, |
| DJP_NONE, DJP_NONE // EOL marker |
| }; |
| |
| APIRET rc; |
| PQUERYSIZE pQuerySize = (PQUERYSIZE)alQuery; |
| PBYTE pBuffer = NULL; |
| LONG nAlloc = 0; |
| LONG nDrivDataSize = pDriverData->cb; |
| |
| // find out how many bytes to allocate |
| pQuerySize->cb = sizeof( alQuery ); |
| rc = DevEscape( hPrinterDC, |
| DEVESC_QUERYSIZE, |
| sizeof( alQuery ), |
| (PBYTE)pQuerySize, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| // allocate the memory |
| nAlloc = pQuerySize->ulSizeNeeded; |
| pBuffer = (PBYTE)new PM_BYTE[nAlloc]; |
| |
| // set up the input |
| PDJP_ITEM pDJP = (PDJP_ITEM)pBuffer; |
| ImplFormatInputList( pDJP, pQuerySize->aTuples ); |
| |
| // Neue Daten zuweisen |
| pDJP->cb = sizeof( DJP_ITEM ); |
| pDJP->ulProperty = DJP_SJ_TRAYTYPE; |
| pDJP->lType = DJP_CURRENT; |
| pDJP->ulValue = pTrayInfo->mnId; |
| |
| // und setzen |
| rc = DevEscape( hPrinterDC, |
| DEVESC_SETJOBPROPERTIES, |
| nAlloc, |
| pBuffer, |
| &nDrivDataSize, |
| (PBYTE)pDriverData ); |
| |
| delete [] pBuffer; |
| |
| return ((DEV_OK == rc) || (DEV_WARNING == rc)); |
| } |
| |
| // ======================================================================= |
| |
| static sal_Bool ImplSalCreateInfoPrn( Os2SalInfoPrinter* pPrinter, PDRIVDATA pDriverData, |
| HDC& rDC, HPS& rPS ) |
| { |
| SalData* pSalData = GetSalData(); |
| |
| // create info context |
| DEVOPENSTRUC devOpenStruc; |
| memset( &devOpenStruc, 0, sizeof( devOpenStruc ) ); |
| devOpenStruc.pszLogAddress = (char*)pPrinter->maName.GetBuffer(); |
| devOpenStruc.pszDriverName = (char*)pPrinter->maDriverName.GetBuffer(); |
| devOpenStruc.pdriv = pDriverData; |
| devOpenStruc.pszDataType = "PM_Q_STD"; |
| |
| HDC hDC = DevOpenDC( pSalData->mhAB, OD_INFO, "*", |
| 4, (PDEVOPENDATA)&devOpenStruc, (HDC)NULL); |
| if ( !hDC ) |
| return FALSE; |
| |
| // create presentation space |
| SIZEL sizel; |
| sizel.cx = 0; |
| sizel.cy = 0; |
| HPS hPS = Ft2CreatePS( pSalData->mhAB, hDC, &sizel, GPIA_ASSOC | GPIT_MICRO | PU_PELS ); |
| if ( !hPS ) |
| { |
| DevCloseDC( hDC ); |
| return FALSE; |
| } |
| |
| rDC = hDC; |
| rPS = hPS; |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplSalDestroyInfoPrn( Os2SalInfoPrinter* pPrinter ) |
| { |
| ImplSalDeInitGraphics( pPrinter->mpGraphics); |
| Ft2Associate( pPrinter->mhPS, 0 ); |
| Ft2DestroyPS( pPrinter->mhPS ); |
| DevCloseDC( pPrinter->mhDC ); |
| } |
| |
| // ======================================================================= |
| |
| SalInfoPrinter* Os2SalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo, |
| ImplJobSetup* pSetupData ) |
| { |
| ImplQueueSalSysData* pSysQueueData = (ImplQueueSalSysData*)(pQueueInfo->mpSysData); |
| Os2SalInfoPrinter* pPrinter = new Os2SalInfoPrinter; |
| pPrinter->maPrinterName = pSysQueueData->maPrinterName; |
| pPrinter->maName = pSysQueueData->maName; |
| pPrinter->maDriverName = pSysQueueData->maDriverName; |
| pPrinter->maDeviceName = pSysQueueData->maDeviceName; |
| |
| // Nur Setup-Daten uebernehmen, wenn Treiber und Laenge der Treiberdaten |
| // uebereinstimmt |
| PDRIVDATA pDriverData; |
| sal_Bool bUpdateDriverData; |
| if ( pSetupData->mpDriverData && pSysQueueData->mpDrivData && |
| (pSetupData->mnSystem == JOBSETUP_SYSTEM_OS2) && |
| (pSetupData->mnDriverDataLen == pSysQueueData->mpDrivData->cb) && |
| (strcmp( ((PDRIVDATA)pSetupData->mpDriverData)->szDeviceName, |
| pSysQueueData->mpDrivData->szDeviceName ) == 0) ) |
| { |
| pDriverData = PDRIVDATA( pSetupData->mpDriverData ); |
| bUpdateDriverData = FALSE; |
| } |
| else |
| { |
| pDriverData = pSysQueueData->mpDrivData; |
| bUpdateDriverData = TRUE; |
| } |
| if ( pDriverData ) |
| pPrinter->maJobSetupDeviceName = pDriverData->szDeviceName; |
| |
| if ( !ImplSalCreateInfoPrn( pPrinter, pDriverData, |
| pPrinter->mhDC, |
| pPrinter->mhPS ) ) |
| { |
| delete pPrinter; |
| return NULL; |
| } |
| |
| // create graphics object for output |
| Os2SalGraphics* pGraphics = new Os2SalGraphics; |
| pGraphics->mhDC = pPrinter->mhDC; |
| pGraphics->mhPS = pPrinter->mhPS; |
| pGraphics->mhWnd = 0; |
| pGraphics->mbPrinter = TRUE; |
| pGraphics->mbVirDev = FALSE; |
| pGraphics->mbWindow = FALSE; |
| pGraphics->mbScreen = FALSE; |
| |
| ImplSalInitGraphics( pGraphics ); |
| pPrinter->mpGraphics = pGraphics; |
| |
| // check printer driver for DJP support |
| pPrinter->mbDJPSupported = ImplIsDriverDJPEnabled( pPrinter->mhDC ); |
| |
| if ( bUpdateDriverData ) |
| { |
| if ( pSetupData->mpDriverData ) |
| rtl_freeMemory( pSetupData->mpDriverData); |
| pSetupData->mpDriverData = (sal_uInt8*)rtl_allocateMemory( pDriverData->cb); |
| memcpy( pSetupData->mpDriverData, pDriverData, pDriverData->cb ); |
| pSetupData->mnDriverDataLen = pDriverData->cb; |
| } |
| |
| // retrieve current settings from printer driver and store them to system independend data! |
| if ( pPrinter->mbDJPSupported ) |
| ImplGetCurrentSettings( pPrinter, pSetupData ); |
| pSetupData->mnSystem = JOBSETUP_SYSTEM_OS2; |
| |
| return pPrinter; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter ) |
| { |
| delete pPrinter; |
| } |
| |
| // ======================================================================= |
| |
| Os2SalInfoPrinter::Os2SalInfoPrinter() |
| { |
| mhDC = 0; |
| mhPS = 0; |
| mpGraphics = NULL; |
| mbGraphics = FALSE; |
| mbDJPSupported = FALSE; |
| mnFormCount = 0; |
| mpFormArray = NULL; |
| mnTrayCount = 0; |
| mpTrayArray = NULL; |
| m_bPapersInit = FALSE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Os2SalInfoPrinter::~Os2SalInfoPrinter() |
| { |
| if ( mpGraphics ) |
| { |
| ImplSalDestroyInfoPrn( this ); |
| delete mpGraphics; |
| } |
| |
| ImplFreeFormAndTrayList( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInfoPrinter::InitPaperFormats( const ImplJobSetup* pSetupData ) |
| { |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalInfoPrinter::InitPaperFormats pSetupData %x", |
| pSetupData); |
| #endif |
| |
| m_aPaperFormats.clear(); |
| m_bPapersInit = true; |
| |
| // init paperbinlist if empty |
| if ( !mnTrayCount ) |
| ImplGetFormAndTrayList( this, pSetupData ); |
| |
| for( int i = 0; i < mnFormCount; i++) |
| { |
| PaperInfo aInfo( mpFormArray[i]->mnPaperWidth * 100, |
| mpFormArray[i]->mnPaperHeight * 100); |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalInfoPrinter::InitPaperFormats #%d: %d x %d", |
| i, mpFormArray[i]->mnPaperWidth * 100, |
| mpFormArray[i]->mnPaperHeight * 100); |
| #endif |
| m_aPaperFormats.push_back( aInfo ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int Os2SalInfoPrinter::GetLandscapeAngle( const ImplJobSetup* pSetupData ) |
| { |
| return 900; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SalGraphics* Os2SalInfoPrinter::GetGraphics() |
| { |
| if ( mbGraphics ) |
| return NULL; |
| |
| if ( mpGraphics ) |
| mbGraphics = TRUE; |
| |
| return mpGraphics; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInfoPrinter::ReleaseGraphics( SalGraphics* ) |
| { |
| mbGraphics = FALSE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalInfoPrinter::Setup( SalFrame* pFrame, ImplJobSetup* pSetupData ) |
| { |
| PDRIVDATA pDrivData = ImplPrnDrivData( pSetupData ); |
| if ( !pDrivData ) |
| return FALSE; |
| |
| APIRET rc = DevPostDeviceModes( GetSalData()->mhAB, pDrivData, |
| maDriverName.GetBuffer(), |
| maDeviceName.GetBuffer(), |
| maPrinterName.GetBuffer(), |
| DPDM_POSTJOBPROP ); |
| if ( rc == DEV_OK ) |
| { |
| ImplUpdateSetupData( pDrivData, pSetupData ); |
| |
| // update DC and PS |
| HDC hDC; |
| HPS hPS; |
| if ( !ImplSalCreateInfoPrn( this, (PDRIVDATA)(pSetupData->mpDriverData), hDC, hPS ) ) |
| return FALSE; |
| |
| // Alten Printer DC/PS zerstoeren |
| ImplSalDestroyInfoPrn( this ); |
| |
| // Neue Daten setzen und initialisieren |
| mhDC = hDC; |
| mhPS = hPS; |
| mpGraphics->mhDC = mhDC; |
| mpGraphics->mhPS = mhPS; |
| ImplSalInitGraphics( mpGraphics ); |
| |
| // retrieve current settings from printer driver and store them to system independend data! |
| ImplFreeFormAndTrayList( this ); |
| if ( mbDJPSupported ) |
| ImplGetCurrentSettings( this, pSetupData ); |
| |
| return TRUE; |
| } |
| else |
| { |
| ImplFreePrnMemory( pDrivData ); |
| return FALSE; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalInfoPrinter::SetPrinterData( ImplJobSetup* pSetupData ) |
| { |
| // Wir koennen nur Treiberdaten von OS2 setzen |
| if ( pSetupData->mnSystem != JOBSETUP_SYSTEM_OS2 ) |
| return FALSE; |
| |
| PDRIVDATA pNewDrivData = (PDRIVDATA)(pSetupData->mpDriverData); |
| if ( !pNewDrivData ) |
| return FALSE; |
| |
| // Testen, ob Printerdaten fuer den gleichen Printer uebergeben werden, |
| // da einige Treiber zu Abstuerzen neigen, wenn Daten von einem anderen |
| // Printer gesetzt werden |
| if ( !maJobSetupDeviceName.Equals( pNewDrivData->szDeviceName )) |
| return FALSE; |
| |
| // update DC and PS |
| HDC hDC; |
| HPS hPS; |
| if ( !ImplSalCreateInfoPrn( this, pNewDrivData, hDC, hPS ) ) |
| return FALSE; |
| |
| // Alten Printer DC/PS zerstoeren |
| ImplSalDestroyInfoPrn( this ); |
| |
| // Neue Daten setzen und initialisieren |
| mhDC = hDC; |
| mhPS = hPS; |
| mpGraphics->mhDC = mhDC; |
| mpGraphics->mhPS = mhPS; |
| ImplSalInitGraphics( mpGraphics ); |
| |
| // retrieve current settings from printer driver and store them to system independend data! |
| ImplFreeFormAndTrayList( this ); |
| if ( mbDJPSupported ) |
| ImplGetCurrentSettings( this, pSetupData ); |
| |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalInfoPrinter::SetData( ULONG nFlags, ImplJobSetup* pSetupData ) |
| { |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalInfoPrinter::SetData nFlags %x, pSetupData %x", |
| nFlags, pSetupData); |
| #endif |
| |
| // needs DJP support |
| if ( !mbDJPSupported ) |
| return FALSE; |
| |
| PDRIVDATA pDrivData = ImplPrnDrivData( pSetupData ); |
| |
| if ( !pDrivData ) |
| return FALSE; |
| |
| sal_Bool bOK = FALSE; |
| |
| // set orientation |
| if ( nFlags & SAL_JOBSET_ORIENTATION ) |
| { |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalInfoPrinter::SetData meOrientation %d", pSetupData->meOrientation); |
| #endif |
| if ( ImplSetOrientation( mhDC, pDrivData, pSetupData->meOrientation ) ) |
| bOK = TRUE; |
| } |
| |
| // set paper size |
| if ( nFlags & SAL_JOBSET_PAPERSIZE ) |
| { |
| // Papierformat ermitteln |
| DJPT_PAPERSIZE nOS2PaperFormat; |
| switch ( pSetupData->mePaperFormat ) |
| { |
| case PAPER_A3: |
| nOS2PaperFormat = DJP_PSI_A3; |
| break; |
| |
| case PAPER_A4: |
| nOS2PaperFormat = DJP_PSI_A4; |
| break; |
| |
| case PAPER_A5: |
| nOS2PaperFormat = DJP_PSI_A5; |
| break; |
| |
| case PAPER_B4_JIS: |
| nOS2PaperFormat = DJP_PSI_B4; |
| break; |
| |
| case PAPER_B5_JIS: |
| nOS2PaperFormat = DJP_PSI_B5; |
| break; |
| |
| case PAPER_LETTER: |
| nOS2PaperFormat = DJP_PSI_LETTER; |
| break; |
| |
| case PAPER_LEGAL: |
| nOS2PaperFormat = DJP_PSI_LEGAL; |
| break; |
| |
| case PAPER_TABLOID: |
| nOS2PaperFormat = DJP_PSI_TABLOID; |
| break; |
| |
| default: |
| { |
| nOS2PaperFormat = DJP_PSI_NONE; |
| // OS2 rechnet in Millimetern |
| long nPaperWidth = pSetupData->mnPaperWidth / 100; |
| long nPaperHeight = pSetupData->mnPaperHeight / 100; |
| // Ansonsten ueber die Papiergroesse suchen |
| for( int i = 0; i < mnFormCount; i++ ) |
| { |
| ImplFormInfo* pFormInfo = mpFormArray[i]; |
| if ( ImplPaperSizeEqual( nPaperWidth, nPaperHeight, |
| pFormInfo->mnPaperWidth, pFormInfo->mnPaperHeight ) ) |
| { |
| nOS2PaperFormat = pFormInfo->mnId; |
| break; |
| } |
| } |
| } |
| break; |
| } |
| |
| if ( nOS2PaperFormat != DJP_PSI_NONE ) |
| { |
| if ( ImplSetPaperSize( mhDC, pDrivData, nOS2PaperFormat ) ) |
| bOK = TRUE; |
| } |
| } |
| |
| // set paper tray |
| if ( (nFlags & SAL_JOBSET_PAPERBIN) && (pSetupData->mnPaperBin < mnTrayCount) ) |
| { |
| if ( ImplSetPaperBin( mhDC, pDrivData, |
| mpTrayArray[pSetupData->mnPaperBin] ) ) |
| bOK = TRUE; |
| } |
| |
| if ( bOK ) |
| { |
| ImplUpdateSetupData( pDrivData, pSetupData ); |
| |
| // query current driver settings |
| ImplFreeFormAndTrayList( this ); |
| if ( ImplGetCurrentSettings( this, pSetupData ) ) |
| { |
| // update DC and PS |
| HDC hDC; |
| HPS hPS; |
| if ( ImplSalCreateInfoPrn( this, (PDRIVDATA)(pSetupData->mpDriverData), hDC, hPS ) ) |
| { |
| // Alten Printer DC/PS zerstoeren |
| ImplSalDestroyInfoPrn( this ); |
| |
| // Neue Daten setzen und initialisieren |
| mhDC = hDC; |
| mhPS = hPS; |
| mpGraphics->mhDC = mhDC; |
| mpGraphics->mhPS = mhPS; |
| ImplSalInitGraphics( mpGraphics ); |
| } |
| else |
| bOK = FALSE; |
| } |
| else |
| bOK = FALSE; |
| } |
| |
| return bOK; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ULONG Os2SalInfoPrinter::GetPaperBinCount( const ImplJobSetup* pJobSetup ) |
| { |
| if ( !mbDJPSupported ) |
| return 1; |
| |
| // init paperbinlist if empty |
| if ( !mnTrayCount ) |
| ImplGetFormAndTrayList( this, pJobSetup ); |
| |
| // Wir haben immer einen PaperTray und wenn, das eben einen ohne |
| // Namen |
| if ( !mnTrayCount ) |
| return 1; |
| else |
| return mnTrayCount; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| XubString Os2SalInfoPrinter::GetPaperBinName( const ImplJobSetup* pJobSetup, |
| ULONG nPaperBin ) |
| { |
| XubString aPaperBinName; |
| |
| if ( mbDJPSupported ) |
| { |
| // init paperbinlist if empty |
| if ( !mnTrayCount ) |
| ImplGetFormAndTrayList( this, pJobSetup ); |
| |
| if ( nPaperBin < mnTrayCount ) |
| aPaperBinName = ::rtl::OStringToOUString (mpTrayArray[nPaperBin]->maDisplayName, gsl_getSystemTextEncoding()); |
| } |
| |
| return aPaperBinName; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ULONG Os2SalInfoPrinter::GetCapabilities( const ImplJobSetup*, USHORT nType ) |
| { |
| switch ( nType ) |
| { |
| case PRINTER_CAPABILITIES_SUPPORTDIALOG: |
| return TRUE; |
| case PRINTER_CAPABILITIES_COPIES: |
| return 0xFFFF; |
| case PRINTER_CAPABILITIES_COLLATECOPIES: |
| return 0; |
| case PRINTER_CAPABILITIES_SETORIENTATION: |
| case PRINTER_CAPABILITIES_SETPAPERBIN: |
| case PRINTER_CAPABILITIES_SETPAPERSIZE: |
| case PRINTER_CAPABILITIES_SETPAPER: |
| return mbDJPSupported; |
| } |
| |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInfoPrinter::GetPageInfo( const ImplJobSetup*, |
| long& rOutWidth, long& rOutHeight, |
| long& rPageOffX, long& rPageOffY, |
| long& rPageWidth, long& rPageHeight ) |
| { |
| HDC hDC = mhDC; |
| |
| // search current form |
| HCINFO aInfo; |
| int nForms = DevQueryHardcopyCaps( hDC, 0, 0, &aInfo ); |
| for( int i = 0; i < nForms; i++ ) |
| { |
| if ( DevQueryHardcopyCaps( hDC, i, 1, &aInfo ) >= 0 ) |
| { |
| if ( aInfo.flAttributes & HCAPS_CURRENT ) |
| { |
| // query resolution |
| long nXResolution; |
| long nYResolution; |
| DevQueryCaps( hDC, CAPS_HORIZONTAL_RESOLUTION, 1, &nXResolution ); |
| DevQueryCaps( hDC, CAPS_VERTICAL_RESOLUTION, 1, &nYResolution ); |
| rPageOffX = aInfo.xLeftClip * nXResolution / 1000; |
| rPageOffY = (aInfo.cy-aInfo.yTopClip) * nYResolution / 1000; |
| rPageWidth = aInfo.cx * nXResolution / 1000; |
| rPageHeight = aInfo.cy * nYResolution / 1000; |
| rOutWidth = aInfo.xPels; |
| rOutHeight = aInfo.yPels; |
| return; |
| } |
| } |
| } |
| |
| // use device caps if no form selected/found |
| long lCapsWidth = 0; |
| long lCapsHeight = 0; |
| DevQueryCaps( hDC, CAPS_WIDTH, 1L, &lCapsWidth ); |
| DevQueryCaps( hDC, CAPS_HEIGHT, 1L, &lCapsHeight ); |
| rPageOffX = 0; |
| rPageOffY = 0; |
| rOutWidth = lCapsWidth; |
| rOutHeight = lCapsHeight; |
| rPageWidth = rOutWidth; |
| rPageHeight = rOutHeight; |
| } |
| |
| // ======================================================================= |
| |
| static sal_Bool ImplIsDriverPrintDJPEnabled( HDC hDC ) |
| { |
| #ifdef NO_DJP |
| return FALSE; |
| #else |
| // Ueber OS2-Ini kann DJP disablte werden |
| if ( !PrfQueryProfileInt( HINI_PROFILE, SAL_PROFILE_APPNAME, SAL_PROFILE_PRINTDJP, 1 ) ) |
| return FALSE; |
| |
| // Testen, ob DJP-Interface am Drucker vorhanden |
| LONG lQuery; |
| APIRET rc; |
| |
| lQuery = DEVESC_QUERYSIZE; |
| rc = DevEscape( hDC, |
| DEVESC_QUERYESCSUPPORT, |
| sizeof( lQuery ), |
| (PBYTE)&lQuery, |
| 0, |
| (PBYTE)NULL ); |
| if ( DEV_OK != rc ) |
| return FALSE; |
| |
| return TRUE; |
| #endif |
| } |
| |
| // ======================================================================= |
| |
| SalPrinter* Os2SalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter ) |
| { |
| Os2SalPrinter* pPrinter = new Os2SalPrinter; |
| pPrinter->mpInfoPrinter = static_cast<Os2SalInfoPrinter*>(pInfoPrinter); |
| return pPrinter; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Os2SalInstance::DestroyPrinter( SalPrinter* pPrinter ) |
| { |
| delete pPrinter; |
| } |
| |
| // ======================================================================= |
| |
| Os2SalPrinter::Os2SalPrinter() |
| { |
| mhDC = 0; |
| mhPS = 0; |
| mpGraphics = NULL; |
| mbAbort = FALSE; |
| mbPrintDJPSupported = FALSE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Os2SalPrinter::~Os2SalPrinter() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalPrinter::StartJob( const XubString* pFileName, |
| const XubString& rJobName, |
| const XubString& rAppName, |
| ULONG nCopies, |
| bool bCollate, |
| bool bDirect, |
| ImplJobSetup* pSetupData ) |
| { |
| DEVOPENSTRUC aDevOpenStruc; |
| LONG lType; |
| APIRET rc; |
| |
| // prepare queue information |
| memset( &aDevOpenStruc, 0, sizeof( aDevOpenStruc ) ); |
| aDevOpenStruc.pszDriverName = (PSZ)(mpInfoPrinter->maDriverName.GetBuffer()); |
| |
| // print into file? |
| if ( pFileName ) |
| { |
| aDevOpenStruc.pszLogAddress = (PSZ)pFileName->GetBuffer(); |
| aDevOpenStruc.pszDataType = "PM_Q_RAW"; |
| lType = OD_DIRECT; |
| } |
| else |
| { |
| aDevOpenStruc.pszLogAddress = (PSZ)(mpInfoPrinter->maName.GetBuffer()); |
| if ( PrfQueryProfileInt( HINI_PROFILE, SAL_PROFILE_APPNAME, SAL_PROFILE_PRINTRAW, 0 ) ) |
| aDevOpenStruc.pszDataType = "PM_Q_RAW"; |
| else |
| aDevOpenStruc.pszDataType = "PM_Q_STD"; |
| lType = OD_QUEUED; |
| } |
| |
| #if 0 // YD FIXME |
| // Set comment (AppName nur bis zum 1. Space-Zeichen nehmen) |
| const xub_Unicode* pComment = rAppName; |
| USHORT nCommentLen = 0; |
| memset( maCommentBuf, 0, sizeof( maCommentBuf ) ); |
| while ( (nCommentLen < 32) && |
| (((*pComment >= 'a') && (*pComment <= 'z')) || |
| ((*pComment >= 'A') && (*pComment <= 'Z')) || |
| ((*pComment >= '0') && (*pComment <= '9')) || |
| (*pComment == '-'))) |
| { |
| maCommentBuf[nCommentLen] = (char)(*pComment); |
| nCommentLen++; |
| pComment++; |
| } |
| aDevOpenStruc.pszComment = (PSZ)maCommentBuf; |
| #endif |
| ByteString jobName( rJobName, gsl_getSystemTextEncoding()); |
| aDevOpenStruc.pszComment = (PSZ)jobName.GetBuffer(); |
| |
| // Kopien |
| if ( nCopies > 1 ) |
| { |
| // OS2 kann maximal 999 Kopien |
| if ( nCopies > 999 ) |
| nCopies = 999; |
| sprintf( maCopyBuf, "COP=%d", nCopies); |
| aDevOpenStruc.pszQueueProcParams = (PSZ)maCopyBuf; |
| } |
| |
| // open device context |
| SalData* pSalData = GetSalData(); |
| HAB hAB = pSalData->mhAB; |
| aDevOpenStruc.pdriv = (PDRIVDATA)pSetupData->mpDriverData; |
| mhDC = DevOpenDC( hAB, |
| lType, |
| "*", |
| 7, |
| (PDEVOPENDATA)&aDevOpenStruc, |
| 0 ); |
| if ( mhDC == 0 ) |
| { |
| ERRORID nLastError = WinGetLastError( hAB ); |
| if ( (nLastError & 0xFFFF) == PMERR_SPL_PRINT_ABORT ) |
| mnError = SAL_PRINTER_ERROR_ABORT; |
| else |
| mnError = SAL_PRINTER_ERROR_GENERALERROR; |
| return FALSE; |
| } |
| |
| // open presentation space |
| SIZEL sizel; |
| sizel.cx = 0; |
| sizel.cy = 0; |
| mhPS = Ft2CreatePS( hAB, mhDC, &sizel, GPIA_ASSOC | GPIT_MICRO | PU_PELS ); |
| if ( !mhPS ) |
| { |
| DevCloseDC( mhDC ); |
| mnError = SAL_PRINTER_ERROR_GENERALERROR; |
| return NULL; |
| } |
| |
| // Can we print with DJP |
| mbPrintDJPSupported = ImplIsDriverPrintDJPEnabled( mhDC ); |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "mbPrintDJPSupported %d", mbPrintDJPSupported); |
| #endif |
| |
| // JobName ermitteln und Job starten |
| PSZ pszJobName = NULL; |
| int nJobNameLen = 0; |
| if ( jobName.Len() > 0 ) |
| { |
| pszJobName = (PSZ)jobName.GetBuffer(); |
| nJobNameLen = jobName.Len(); |
| } |
| rc = DevEscape( mhDC, |
| mbPrintDJPSupported ? DEVESC_STARTDOC_WPROP : DEVESC_STARTDOC, |
| nJobNameLen, (PBYTE)pszJobName, |
| &((PDRIVDATA)(pSetupData->mpDriverData))->cb, |
| (PBYTE)(pSetupData->mpDriverData)); |
| |
| if ( rc != DEV_OK ) |
| { |
| ERRORID nLastError = WinGetLastError( hAB ); |
| if ( (nLastError & 0xFFFF) == PMERR_SPL_PRINT_ABORT ) |
| mnError = SAL_PRINTER_ERROR_ABORT; |
| else |
| mnError = SAL_PRINTER_ERROR_GENERALERROR; |
| Ft2Associate( mhPS, NULL ); |
| Ft2DestroyPS( mhPS ); |
| DevCloseDC( mhDC ); |
| return FALSE; |
| } |
| |
| // init for first page |
| mbFirstPage = TRUE; |
| mnError = 0; |
| |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalPrinter::EndJob() |
| { |
| APIRET rc; |
| rc = DevEscape( mhDC, |
| DEVESC_ENDDOC, |
| 0, NULL, |
| 0, NULL); |
| |
| // destroy presentation space and device context |
| Ft2Associate( mhPS, NULL ); |
| Ft2DestroyPS( mhPS ); |
| DevCloseDC( mhDC ); |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalPrinter::AbortJob() |
| { |
| APIRET rc; |
| |
| rc = DevEscape( mhDC, |
| DEVESC_ABORTDOC, |
| 0, NULL, |
| 0, NULL ); |
| |
| // destroy SalGraphics |
| if ( mpGraphics ) |
| { |
| ImplSalDeInitGraphics( mpGraphics ); |
| delete mpGraphics; |
| mpGraphics = NULL; |
| } |
| |
| // destroy presentation space and device context |
| Ft2Associate( mhPS, NULL ); |
| Ft2DestroyPS( mhPS ); |
| DevCloseDC( mhDC ); |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SalGraphics* Os2SalPrinter::StartPage( ImplJobSetup* pSetupData, sal_Bool bNewJobSetup ) |
| { |
| APIRET rc; |
| |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalPrinter::StartPage mhDC %x, mbFirstPage %d, bNewJobSetup %d", |
| mhDC, mbFirstPage, bNewJobSetup); |
| debug_printf( "Os2SalPrinter::StartPage pSetupData %x", |
| pSetupData); |
| #endif |
| |
| if ( mbFirstPage ) |
| mbFirstPage = FALSE; |
| else |
| { |
| PBYTE pJobData; |
| LONG nJobDataSize; |
| LONG nEscape; |
| if ( mbPrintDJPSupported && bNewJobSetup ) |
| { |
| nEscape = DEVESC_NEWFRAME_WPROP; |
| nJobDataSize = ((PDRIVDATA)(pSetupData->mpDriverData))->cb; |
| pJobData = (PBYTE)(pSetupData->mpDriverData); |
| } |
| else |
| { |
| nEscape = DEVESC_NEWFRAME; |
| nJobDataSize = 0; |
| pJobData = NULL; |
| } |
| rc = DevEscape( mhDC, |
| nEscape, |
| 0, NULL, |
| &nJobDataSize, pJobData ); |
| |
| if ( rc != DEV_OK ) |
| { |
| DevEscape( mhDC, DEVESC_ENDDOC, 0, NULL, 0, NULL); |
| Ft2Associate( mhPS, NULL ); |
| Ft2DestroyPS( mhPS ); |
| DevCloseDC( mhDC ); |
| mnError = SAL_PRINTER_ERROR_GENERALERROR; |
| return NULL; |
| } |
| } |
| |
| // create SalGraphics with copy of hPS |
| Os2SalGraphics* pGraphics = new Os2SalGraphics; |
| pGraphics->mhDC = mhDC; |
| pGraphics->mhPS = mhPS; |
| pGraphics->mhWnd = 0; |
| pGraphics->mbPrinter = TRUE; |
| pGraphics->mbVirDev = FALSE; |
| pGraphics->mbWindow = FALSE; |
| pGraphics->mbScreen = FALSE; |
| pGraphics->mnHeight = 0; |
| // search current form for actual page height |
| HCINFO aInfo; |
| int nForms = DevQueryHardcopyCaps( mhDC, 0, 0, &aInfo ); |
| for( int i = 0; i < nForms; i++ ) |
| { |
| if ( DevQueryHardcopyCaps( mhDC, i, 1, &aInfo ) >= 0 ) |
| { |
| if ( aInfo.flAttributes & HCAPS_CURRENT ) |
| pGraphics->mnHeight = aInfo.yPels; |
| } |
| } |
| // use device caps if no form selected/found |
| if ( !pGraphics->mnHeight ) |
| DevQueryCaps( mhDC, CAPS_HEIGHT, 1L, &pGraphics->mnHeight ); |
| |
| ImplSalInitGraphics( pGraphics ); |
| mpGraphics = pGraphics; |
| |
| return pGraphics; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Os2SalPrinter::EndPage() |
| { |
| #if OSL_DEBUG_LEVEL>0 |
| debug_printf( "Os2SalPrinter::EndPage mhDC %x", mhDC); |
| #endif |
| |
| if ( mpGraphics ) |
| { |
| // destroy SalGraphics |
| ImplSalDeInitGraphics( mpGraphics ); |
| delete mpGraphics; |
| mpGraphics = NULL; |
| } |
| |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ULONG Os2SalPrinter::GetErrorCode() |
| { |
| return mnError; |
| } |