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