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 #include <vcl/svapp.hxx>
  21 #include <vcl/timer.hxx>
  22 #include "printerinfomanager.hxx"
  23
  24 #include "jobset.h"
  25 #include "print.h"
  26 #include "salptype.hxx"
  27 #include "saldatabasic.hxx"
  28
  29 #include "unx/genpspgraphics.h"
  30
  31 #include "headless/svpprn.hxx"
  32 #include "headless/svpinst.hxx"
  33
  34 using namespace psp;
  35
  36 /*
  37  *  static helpers
  38  */
  39
  40 static OUString getPdfDir( const PrinterInfo& rInfo )
  41 {
  42     OUString aDir;
  43     sal_Int32 nIndex = 0;
  44     while( nIndex != -1 )
  45     {
  46         OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
  47         if( aToken.startsWith( "pdf=" ) )
  48         {
  49             sal_Int32 nPos = 0;
  50             aDir = aToken.getToken( 1, '=', nPos );
  51             if( aDir.isEmpty() )
  52                 aDir = OStringToOUString( OString( getenv( "HOME" ) ), osl_getThreadTextEncoding() );
  53             break;
  54         }
  55     }
  56     return aDir;
  57 }
  58
  59 inline int PtTo10Mu( int nPoints ) { return (int)((((double)nPoints)*35.27777778)+0.5); }
  60
  61 static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, JobData& rData )
  62 {
  63     pJobSetup->SetOrientation( rData.m_eOrientation == orientation::Landscape ? Orientation::Landscape : Orientation::Portrait );
  64
  65     // copy page size
  66     OUString aPaper;
  67     int width, height;
  68
  69     rData.m_aContext.getPageSize( aPaper, width, height );
  70     pJobSetup->SetPaperFormat( PaperInfo::fromPSName(OUStringToOString( aPaper, RTL_TEXTENCODING_ISO_8859_1 )) );
  71     pJobSetup->SetPaperWidth( 0 );
  72     pJobSetup->SetPaperHeight( 0 );
  73     if( pJobSetup->GetPaperFormat() == PAPER_USER )
  74     {
  75         // transform to 100dth mm
  76         width               = PtTo10Mu( width );
  77         height              = PtTo10Mu( height );
  78
  79         if( rData.m_eOrientation == psp::orientation::Portrait )
  80         {
  81             pJobSetup->SetPaperWidth( width );
  82             pJobSetup->SetPaperHeight( height );
  83         }
  84         else
  85         {
  86             pJobSetup->SetPaperWidth( height );
  87             pJobSetup->SetPaperHeight( width );
  88         }
  89     }
  90
  91     // copy input slot
  92     const PPDKey* pKey = nullptr;
  93     const PPDValue* pValue = nullptr;
  94
  95     pJobSetup->SetPaperBin( 0xffff );
  96     if( rData.m_pParser )
  97         pKey                    = rData.m_pParser->getKey( OUString( "InputSlot"  ) );
  98     if( pKey )
  99         pValue                  = rData.m_aContext.getValue( pKey );
 100     if( pKey && pValue )
 101     {
 102         int nPaperBin;
 103         for( nPaperBin = 0;
 104              pValue != pKey->getValue( nPaperBin ) &&
 105                  nPaperBin < pKey->countValues();
 106              nPaperBin++ );
 107         pJobSetup->SetPaperBin(
 108             (nPaperBin == pKey->countValues()
 109              || pValue == pKey->getDefaultValue())
 110             ? 0xffff : nPaperBin);
 111     }
 112
 113     // copy duplex
 114     pKey = nullptr;
 115     pValue = nullptr;
 116
 117     pJobSetup->SetDuplexMode( DuplexMode::Unknown );
 118     if( rData.m_pParser )
 119         pKey = rData.m_pParser->getKey( OUString( "Duplex"  ) );
 120     if( pKey )
 121         pValue = rData.m_aContext.getValue( pKey );
 122     if( pKey && pValue )
 123     {
 124         if( pValue->m_aOption.equalsIgnoreAsciiCase( "None" ) ||
 125             pValue->m_aOption.startsWithIgnoreAsciiCase( "Simplex" )
 126            )
 127         {
 128             pJobSetup->SetDuplexMode( DuplexMode::Off );
 129         }
 130         else if( pValue->m_aOption.equalsIgnoreAsciiCase( "DuplexNoTumble" ) )
 131         {
 132             pJobSetup->SetDuplexMode( DuplexMode::LongEdge );
 133         }
 134         else if( pValue->m_aOption.equalsIgnoreAsciiCase( "DuplexTumble" ) )
 135         {
 136             pJobSetup->SetDuplexMode( DuplexMode::ShortEdge );
 137         }
 138     }
 139
 140     // copy the whole context
 141     if( pJobSetup->GetDriverData() )
 142         rtl_freeMemory( const_cast<sal_uInt8*>(pJobSetup->GetDriverData()) );
 143
 144     sal_uInt32 nBytes;
 145     void* pBuffer = nullptr;
 146     if( rData.getStreamBuffer( pBuffer, nBytes ) )
 147     {
 148         pJobSetup->SetDriverDataLen( nBytes );
 149         pJobSetup->SetDriverData( static_cast<sal_uInt8*>(pBuffer) );
 150     }
 151     else
 152     {
 153         pJobSetup->SetDriverDataLen( 0 );
 154         pJobSetup->SetDriverData( nullptr );
 155     }
 156 }
 157
 158 // SalInstance
 159
 160 SalInfoPrinter* SvpSalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo,
 161                                                    ImplJobSetup*        pJobSetup )
 162 {
 163     // create and initialize SalInfoPrinter
 164     SvpSalInfoPrinter* pPrinter = new SvpSalInfoPrinter;
 165
 166     if( pJobSetup )
 167     {
 168         PrinterInfoManager& rManager( PrinterInfoManager::get() );
 169         PrinterInfo aInfo( rManager.getPrinterInfo( pQueueInfo->maPrinterName ) );
 170         pPrinter->m_aJobData = aInfo;
 171         pPrinter->m_aPrinterGfx.Init( pPrinter->m_aJobData );
 172
 173         if( pJobSetup->GetDriverData() )
 174             JobData::constructFromStreamBuffer( pJobSetup->GetDriverData(),
 175                                                 pJobSetup->GetDriverDataLen(), aInfo );
 176
 177         pJobSetup->SetSystem( JOBSETUP_SYSTEM_UNIX );
 178         pJobSetup->SetPrinterName( pQueueInfo->maPrinterName );
 179         pJobSetup->SetDriver( aInfo.m_aDriverName );
 180         copyJobDataToJobSetup( pJobSetup, aInfo );
 181     }
 182
 183     return pPrinter;
 184 }
 185
 186 void SvpSalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter )
 187 {
 188     delete pPrinter;
 189 }
 190
 191 SalPrinter* SvpSalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter )
 192 {
 193     // create and initialize SalPrinter
 194     SvpSalPrinter* pPrinter = new SvpSalPrinter( pInfoPrinter );
 195     pPrinter->m_aJobData = static_cast<SvpSalInfoPrinter*>(pInfoPrinter)->m_aJobData;
 196
 197     return pPrinter;
 198 }
 199
 200 void SvpSalInstance::DestroyPrinter( SalPrinter* pPrinter )
 201 {
 202     delete pPrinter;
 203 }
 204
 205 void SvpSalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList )
 206 {
 207     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 208     static const char* pNoSyncDetection = getenv( "SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION" );
 209     if( ! pNoSyncDetection || ! *pNoSyncDetection )
 210     {
 211         // #i62663# synchronize possible asynchronouse printer detection now
 212         rManager.checkPrintersChanged( true );
 213     }
 214     ::std::list< OUString > aPrinters;
 215     rManager.listPrinters( aPrinters );
 216
 217     for( ::std::list< OUString >::iterator it = aPrinters.begin(); it != aPrinters.end(); ++it )
 218     {
 219         const PrinterInfo& rInfo( rManager.getPrinterInfo( *it ) );
 220         // Neuen Eintrag anlegen
 221         SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo;
 222         pInfo->maPrinterName    = *it;
 223         pInfo->maDriver         = rInfo.m_aDriverName;
 224         pInfo->maLocation       = rInfo.m_aLocation;
 225         pInfo->maComment        = rInfo.m_aComment;
 226         pInfo->mpSysData        = nullptr;
 227
 228         sal_Int32 nIndex = 0;
 229         while( nIndex != -1 )
 230         {
 231             OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
 232             if( aToken.startsWith( "pdf=" ) )
 233             {
 234                 pInfo->maLocation = getPdfDir( rInfo );
 235                 break;
 236             }
 237         }
 238
 239         pList->Add( pInfo );
 240     }
 241 }
 242
 243 void SvpSalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo )
 244 {
 245     delete pInfo;
 246 }
 247
 248 void SvpSalInstance::GetPrinterQueueState( SalPrinterQueueInfo* )
 249 {
 250 }
 251
 252 OUString SvpSalInstance::GetDefaultPrinter()
 253 {
 254     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 255     return rManager.getDefaultPrinter();
 256 }
 257
 258 void SvpSalInstance::PostPrintersChanged()
 259 {
 260     const std::list< SalFrame* >& rList = SvpSalInstance::s_pDefaultInstance->getFrames();
 261     for( std::list< SalFrame* >::const_iterator it = rList.begin();
 262          it != rList.end(); ++it )
 263         SvpSalInstance::s_pDefaultInstance->PostEvent( *it, nullptr, SalEvent::PrinterChanged );
 264 }
 265
 266 GenPspGraphics *SvpSalInstance::CreatePrintGraphics()
 267 {
 268     return new GenPspGraphics();
 269 }
 270
 271 bool SvpSalInfoPrinter::Setup( SalFrame*, ImplJobSetup* )
 272 {
 273     return false;
 274 }
 275
 276 SvpSalPrinter::SvpSalPrinter( SalInfoPrinter* pInfoPrinter )
 277     : PspSalPrinter( pInfoPrinter )
 278 {
 279 }
 280
 281 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */