vcl/headless/svpprn.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "vcl/svapp.hxx"
  22 #include "vcl/timer.hxx"
  23 #include "vcl/printerinfomanager.hxx"
  24
  25 #include "jobset.h"
  26 #include "print.h"
  27 #include "salptype.hxx"
  28 #include "saldatabasic.hxx"
  29
  30 #include "generic/genpspgraphics.h"
  31
  32 #include "headless/svpprn.hxx"
  33 #include "headless/svpinst.hxx"
  34
  35 using namespace psp;
  36
  37 /*
  38  *  static helpers
  39  */
  40
  41 static OUString getPdfDir( const PrinterInfo& rInfo )
  42 {
  43     OUString aDir;
  44     sal_Int32 nIndex = 0;
  45     while( nIndex != -1 )
  46     {
  47         OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
  48         if( aToken.startsWith( "pdf=" ) )
  49         {
  50             sal_Int32 nPos = 0;
  51             aDir = aToken.getToken( 1, '=', nPos );
  52             if( aDir.isEmpty() )
  53                 aDir = OStringToOUString( OString( getenv( "HOME" ) ), osl_getThreadTextEncoding() );
  54             break;
  55         }
  56     }
  57     return aDir;
  58 }
  59
  60 inline int PtTo10Mu( int nPoints ) { return (int)((((double)nPoints)*35.27777778)+0.5); }
  61
  62 inline int TenMuToPt( int nUnits ) { return (int)((((double)nUnits)/35.27777778)+0.5); }
  63
  64 static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, JobData& rData )
  65 {
  66     pJobSetup->meOrientation    = (Orientation)(rData.m_eOrientation == orientation::Landscape ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
  67
  68     // copy page size
  69     OUString aPaper;
  70     int width, height;
  71
  72     rData.m_aContext.getPageSize( aPaper, width, height );
  73     pJobSetup->mePaperFormat    = PaperInfo::fromPSName(OUStringToOString( aPaper, RTL_TEXTENCODING_ISO_8859_1 ));
  74     pJobSetup->mnPaperWidth     = 0;
  75     pJobSetup->mnPaperHeight    = 0;
  76     if( pJobSetup->mePaperFormat == PAPER_USER )
  77     {
  78         // transform to 100dth mm
  79         width               = PtTo10Mu( width );
  80         height              = PtTo10Mu( height );
  81
  82         if( rData.m_eOrientation == psp::orientation::Portrait )
  83         {
  84             pJobSetup->mnPaperWidth = width;
  85             pJobSetup->mnPaperHeight= height;
  86         }
  87         else
  88         {
  89             pJobSetup->mnPaperWidth = height;
  90             pJobSetup->mnPaperHeight= width;
  91         }
  92     }
  93
  94     // copy input slot
  95     const PPDKey* pKey = NULL;
  96     const PPDValue* pValue = NULL;
  97
  98     pJobSetup->mnPaperBin = 0xffff;
  99     if( rData.m_pParser )
 100         pKey                    = rData.m_pParser->getKey( OUString( "InputSlot"  ) );
 101     if( pKey )
 102         pValue                  = rData.m_aContext.getValue( pKey );
 103     if( pKey && pValue )
 104     {
 105         for( pJobSetup->mnPaperBin = 0;
 106              pValue != pKey->getValue( pJobSetup->mnPaperBin ) &&
 107                  pJobSetup->mnPaperBin < pKey->countValues();
 108              pJobSetup->mnPaperBin++ )
 109             ;
 110         if( pJobSetup->mnPaperBin >= pKey->countValues() || pValue == pKey->getDefaultValue() )
 111             pJobSetup->mnPaperBin = 0xffff;
 112     }
 113
 114     // copy duplex
 115     pKey = NULL;
 116     pValue = NULL;
 117
 118     pJobSetup->meDuplexMode = DUPLEX_UNKNOWN;
 119     if( rData.m_pParser )
 120         pKey = rData.m_pParser->getKey( OUString( "Duplex"  ) );
 121     if( pKey )
 122         pValue = rData.m_aContext.getValue( pKey );
 123     if( pKey && pValue )
 124     {
 125         if( pValue->m_aOption.equalsIgnoreAsciiCase( "None" ) ||
 126             pValue->m_aOption.startsWithIgnoreAsciiCase( "Simplex" )
 127            )
 128         {
 129             pJobSetup->meDuplexMode = DUPLEX_OFF;
 130         }
 131         else if( pValue->m_aOption.equalsIgnoreAsciiCase( "DuplexNoTumble" ) )
 132         {
 133             pJobSetup->meDuplexMode = DUPLEX_LONGEDGE;
 134         }
 135         else if( pValue->m_aOption.equalsIgnoreAsciiCase( "DuplexTumble" ) )
 136         {
 137             pJobSetup->meDuplexMode = DUPLEX_SHORTEDGE;
 138         }
 139     }
 140
 141     // copy the whole context
 142     if( pJobSetup->mpDriverData )
 143         rtl_freeMemory( pJobSetup->mpDriverData );
 144
 145     int nBytes;
 146     void* pBuffer = NULL;
 147     if( rData.getStreamBuffer( pBuffer, nBytes ) )
 148     {
 149         pJobSetup->mnDriverDataLen = nBytes;
 150         pJobSetup->mpDriverData = (sal_uInt8*)pBuffer;
 151     }
 152     else
 153     {
 154         pJobSetup->mnDriverDataLen = 0;
 155         pJobSetup->mpDriverData = NULL;
 156     }
 157 }
 158
 159 /*
 160  *  SalInstance
 161  */
 162
 163 SalInfoPrinter* SvpSalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo,
 164                                                    ImplJobSetup*            pJobSetup )
 165 {
 166     // create and initialize SalInfoPrinter
 167     SvpSalInfoPrinter* pPrinter = new SvpSalInfoPrinter();
 168
 169     if( pJobSetup )
 170     {
 171         PrinterInfoManager& rManager( PrinterInfoManager::get() );
 172         PrinterInfo aInfo( rManager.getPrinterInfo( pQueueInfo->maPrinterName ) );
 173         pPrinter->m_aJobData = aInfo;
 174         pPrinter->m_aPrinterGfx.Init( pPrinter->m_aJobData );
 175
 176         if( pJobSetup->mpDriverData )
 177             JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aInfo );
 178
 179         pJobSetup->mnSystem         = JOBSETUP_SYSTEM_UNIX;
 180         pJobSetup->maPrinterName    = pQueueInfo->maPrinterName;
 181         pJobSetup->maDriver         = aInfo.m_aDriverName;
 182         copyJobDataToJobSetup( pJobSetup, aInfo );
 183     }
 184
 185
 186     return pPrinter;
 187 }
 188
 189 void SvpSalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter )
 190 {
 191     delete pPrinter;
 192 }
 193
 194 SalPrinter* SvpSalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter )
 195 {
 196     // create and initialize SalPrinter
 197     SvpSalPrinter* pPrinter = new SvpSalPrinter( pInfoPrinter );
 198     pPrinter->m_aJobData = static_cast<SvpSalInfoPrinter*>(pInfoPrinter)->m_aJobData;
 199
 200     return pPrinter;
 201 }
 202
 203 void SvpSalInstance::DestroyPrinter( SalPrinter* pPrinter )
 204 {
 205     delete pPrinter;
 206 }
 207
 208 void SvpSalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList )
 209 {
 210     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 211     static const char* pNoSyncDetection = getenv( "SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION" );
 212     if( ! pNoSyncDetection || ! *pNoSyncDetection )
 213     {
 214         // #i62663# synchronize possible asynchronouse printer detection now
 215         rManager.checkPrintersChanged( true );
 216     }
 217     ::std::list< OUString > aPrinters;
 218     rManager.listPrinters( aPrinters );
 219
 220     for( ::std::list< OUString >::iterator it = aPrinters.begin(); it != aPrinters.end(); ++it )
 221     {
 222         const PrinterInfo& rInfo( rManager.getPrinterInfo( *it ) );
 223         // Neuen Eintrag anlegen
 224         SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo;
 225         pInfo->maPrinterName    = *it;
 226         pInfo->maDriver         = rInfo.m_aDriverName;
 227         pInfo->maLocation       = rInfo.m_aLocation;
 228         pInfo->maComment        = rInfo.m_aComment;
 229         pInfo->mpSysData        = NULL;
 230
 231         sal_Int32 nIndex = 0;
 232         while( nIndex != -1 )
 233         {
 234             OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
 235             if( aToken.startsWith( "pdf=" ) )
 236             {
 237                 pInfo->maLocation = getPdfDir( rInfo );
 238                 break;
 239             }
 240         }
 241
 242         pList->Add( pInfo );
 243     }
 244 }
 245
 246 void SvpSalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo )
 247 {
 248     delete pInfo;
 249 }
 250
 251 void SvpSalInstance::GetPrinterQueueState( SalPrinterQueueInfo* )
 252 {
 253 }
 254
 255 OUString SvpSalInstance::GetDefaultPrinter()
 256 {
 257     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 258     return rManager.getDefaultPrinter();
 259 }
 260
 261 void SvpSalInstance::PostPrintersChanged()
 262 {
 263     const std::list< SalFrame* >& rList = SvpSalInstance::s_pDefaultInstance->getFrames();
 264     for( std::list< SalFrame* >::const_iterator it = rList.begin();
 265          it != rList.end(); ++it )
 266         SvpSalInstance::s_pDefaultInstance->PostEvent( *it, NULL, SALEVENT_PRINTERCHANGED );
 267 }
 268
 269 GenPspGraphics *SvpSalInstance::CreatePrintGraphics()
 270 {
 271     return new GenPspGraphics();
 272 }
 273
 274 sal_Bool SvpSalInfoPrinter::Setup( SalFrame*, ImplJobSetup* )
 275 {
 276     return sal_False;
 277 }
 278
 279 SvpSalPrinter::SvpSalPrinter( SalInfoPrinter* pInfoPrinter )
 280     : PspSalPrinter( pInfoPrinter )
 281 {
 282 }
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */