toolkit/source/awt/vclxprinter.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 <com/sun/star/uno/XComponentContext.hpp>
  21 #include <awt/vclxprinter.hxx>
  22 #include <cppuhelper/supportsservice.hxx>
  23 #include <comphelper/string.hxx>
  24
  25 #include <vcl/print.hxx>
  26 #include <vcl/jobset.hxx>
  27 #include <vcl/oldprintadaptor.hxx>
  28 #include <vcl/svapp.hxx>
  29
  30 #include <tools/debug.hxx>
  31 #include <tools/stream.hxx>
  32 #include <o3tl/string_view.hxx>
  33
  34 #include <toolkit/awt/vclxdevice.hxx>
  35
  36
  37 #define BINARYSETUPMARKER       0x23864691
  38
  39 #define PROPERTY_Orientation    0
  40 #define PROPERTY_Horizontal     1
  41
  42 //    ----------------------------------------------------
  43 //    class VCLXPrinterPropertySet
  44 //    ----------------------------------------------------
  45
  46 IMPLEMENT_FORWARD_XINTERFACE2( VCLXPrinterPropertySet, VCLXPrinterPropertySet_Base, OPropertySetHelper )
  47 IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXPrinterPropertySet, VCLXPrinterPropertySet_Base, ::cppu::OPropertySetHelper )
  48
  49 VCLXPrinterPropertySet::VCLXPrinterPropertySet( const OUString& rPrinterName )
  50     : OPropertySetHelper( m_aBHelper )
  51     , mxPrinter(VclPtrInstance< Printer >(rPrinterName))
  52 {
  53     SolarMutexGuard aSolarGuard;
  54
  55     mnOrientation = 0;
  56     mbHorizontal = false;
  57 }
  58
  59 VCLXPrinterPropertySet::~VCLXPrinterPropertySet()
  60 {
  61     SolarMutexGuard aSolarGuard;
  62     mxPrinter.reset();
  63 }
  64
  65 css::uno::Reference< css::awt::XDevice > const &  VCLXPrinterPropertySet::GetDevice()
  66 {
  67     if ( !mxPrnDevice.is() )
  68     {
  69         rtl::Reference<VCLXDevice> pDev = new VCLXDevice;
  70         pDev->SetOutputDevice( GetPrinter() );
  71         mxPrnDevice = pDev;
  72     }
  73     return mxPrnDevice;
  74 }
  75
  76 css::uno::Reference< css::beans::XPropertySetInfo > VCLXPrinterPropertySet::getPropertySetInfo(  )
  77 {
  78     static css::uno::Reference< css::beans::XPropertySetInfo >  xInfo( createPropertySetInfo( getInfoHelper() ) );
  79     return xInfo;
  80 }
  81
  82 ::cppu::IPropertyArrayHelper& VCLXPrinterPropertySet::getInfoHelper()
  83 {
  84     static ::cppu::OPropertyArrayHelper s_PropertyArrayHelper(
  85             css::uno::Sequence<css::beans::Property>{
  86                     css::beans::Property( "Orientation", PROPERTY_Orientation, cppu::UnoType<sal_Int16>::get(), 0 ),
  87                     css::beans::Property( "Horizontal", PROPERTY_Horizontal, cppu::UnoType<bool>::get(), 0 )},
  88             false);
  89
  90     return s_PropertyArrayHelper;
  91 }
  92
  93 sal_Bool VCLXPrinterPropertySet::convertFastPropertyValue( css::uno::Any & rConvertedValue, css::uno::Any & rOldValue, sal_Int32 nHandle, const css::uno::Any& rValue )
  94 {
  95     ::osl::MutexGuard aGuard( m_aMutex );
  96
  97     bool bDifferent = false;
  98     switch ( nHandle )
  99     {
 100         case PROPERTY_Orientation:
 101         {
 102             sal_Int16 n;
 103             if( ( rValue >>= n ) && ( n != mnOrientation ) )
 104             {
 105                 rConvertedValue <<= n;
 106                 rOldValue <<= mnOrientation;
 107                 bDifferent = true;
 108             }
 109         }
 110         break;
 111         case PROPERTY_Horizontal:
 112         {
 113             bool b;
 114             if( ( rValue >>= b ) && ( b != mbHorizontal ) )
 115             {
 116                 rConvertedValue <<= b;
 117                 rOldValue <<= mbHorizontal;
 118                 bDifferent = true;
 119             }
 120         }
 121         break;
 122         default:
 123         {
 124             OSL_FAIL( "VCLXPrinterPropertySet_Impl::convertFastPropertyValue - invalid Handle" );
 125         }
 126     }
 127     return bDifferent;
 128 }
 129
 130 void VCLXPrinterPropertySet::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue )
 131 {
 132     ::osl::MutexGuard aGuard( m_aMutex );
 133
 134     switch( nHandle )
 135     {
 136         case PROPERTY_Orientation:
 137         {
 138             rValue >>= mnOrientation;
 139         }
 140         break;
 141         case PROPERTY_Horizontal:
 142         {
 143             rValue >>= mbHorizontal;
 144         }
 145         break;
 146         default:
 147         {
 148             OSL_FAIL( "VCLXPrinterPropertySet_Impl::convertFastPropertyValue - invalid Handle" );
 149         }
 150     }
 151 }
 152
 153 void VCLXPrinterPropertySet::getFastPropertyValue( css::uno::Any& rValue, sal_Int32 nHandle ) const
 154 {
 155     ::osl::MutexGuard aGuard( const_cast<VCLXPrinterPropertySet*>(this)->m_aMutex );
 156
 157     switch( nHandle )
 158     {
 159         case PROPERTY_Orientation:
 160             rValue <<= mnOrientation;
 161         break;
 162         case PROPERTY_Horizontal:
 163             rValue <<= mbHorizontal;
 164         break;
 165         default:
 166         {
 167             OSL_FAIL( "VCLXPrinterPropertySet_Impl::convertFastPropertyValue - invalid Handle" );
 168         }
 169     }
 170 }
 171
 172 // css::awt::XPrinterPropertySet
 173 void VCLXPrinterPropertySet::setHorizontal( sal_Bool bHorizontal )
 174 {
 175     ::osl::MutexGuard aGuard( m_aMutex );
 176
 177     css::uno::Any aValue;
 178     aValue <<= bHorizontal;
 179     setFastPropertyValue( PROPERTY_Horizontal, aValue );
 180 }
 181
 182 css::uno::Sequence< OUString > VCLXPrinterPropertySet::getFormDescriptions(  )
 183 {
 184     ::osl::MutexGuard aGuard( m_aMutex );
 185
 186     const sal_uInt16 nPaperBinCount = GetPrinter()->GetPaperBinCount();
 187     css::uno::Sequence< OUString > aDescriptions( nPaperBinCount );
 188     for ( sal_uInt16 n = 0; n < nPaperBinCount; n++ )
 189     {
 190         // Format: <DisplayFormName;FormNameId;DisplayPaperBinName;PaperBinNameId;DisplayPaperName;PaperNameId>
 191         OUString aDescr =  "*;*;" + GetPrinter()->GetPaperBinName( n ) + ";" +
 192             OUString::number(n) + ";*;*";
 193
 194         aDescriptions.getArray()[n] = aDescr;
 195     }
 196     return aDescriptions;
 197 }
 198
 199 void VCLXPrinterPropertySet::selectForm( const OUString& rFormDescription )
 200 {
 201     ::osl::MutexGuard aGuard( m_aMutex );
 202
 203     sal_uInt16 nPaperBin = sal::static_int_cast< sal_uInt16 >(
 204         o3tl::toInt32(o3tl::getToken(rFormDescription, 3, ';' )));
 205     GetPrinter()->SetPaperBin( nPaperBin );
 206 }
 207
 208 css::uno::Sequence< sal_Int8 > VCLXPrinterPropertySet::getBinarySetup(  )
 209 {
 210     ::osl::MutexGuard aGuard( m_aMutex );
 211
 212     SvMemoryStream aMem;
 213     aMem.WriteUInt32( BINARYSETUPMARKER );
 214     WriteJobSetup( aMem, GetPrinter()->GetJobSetup() );
 215     return css::uno::Sequence<sal_Int8>( static_cast<sal_Int8 const *>(aMem.GetData()), aMem.Tell() );
 216 }
 217
 218 void VCLXPrinterPropertySet::setBinarySetup( const css::uno::Sequence< sal_Int8 >& data )
 219 {
 220     ::osl::MutexGuard aGuard( m_aMutex );
 221
 222     SvMemoryStream aMem( const_cast<signed char*>(data.getConstArray()), data.getLength(), StreamMode::READ );
 223     sal_uInt32 nMarker;
 224     aMem.ReadUInt32( nMarker );
 225     DBG_ASSERT( nMarker == BINARYSETUPMARKER, "setBinarySetup - invalid!" );
 226     if ( nMarker == BINARYSETUPMARKER )
 227     {
 228         JobSetup aSetup;
 229         ReadJobSetup( aMem, aSetup );
 230         GetPrinter()->SetJobSetup( aSetup );
 231     }
 232 }
 233
 234
 235 //    ----------------------------------------------------
 236 //    class VCLXPrinter
 237 //    ----------------------------------------------------
 238 VCLXPrinter::VCLXPrinter( const OUString& rPrinterName )
 239     : VCLXPrinter_Base( rPrinterName )
 240 {
 241 }
 242
 243 VCLXPrinter::~VCLXPrinter()
 244 {
 245 }
 246
 247 sal_Bool VCLXPrinter::start( const OUString& /*rJobName*/, sal_Int16 /*nCopies*/, sal_Bool /*bCollate*/ )
 248 {
 249     ::osl::MutexGuard aGuard( m_aMutex );
 250
 251     if (mxPrinter)
 252     {
 253         maInitJobSetup = mxPrinter->GetJobSetup();
 254         mxListener = std::make_shared<vcl::OldStylePrintAdaptor>(mxPrinter, nullptr);
 255     }
 256
 257     return true;
 258 }
 259
 260 void VCLXPrinter::end(  )
 261 {
 262     ::osl::MutexGuard aGuard( m_aMutex );
 263
 264     if (mxListener)
 265     {
 266         Printer::PrintJob(mxListener, maInitJobSetup);
 267         mxListener.reset();
 268     }
 269 }
 270
 271 void VCLXPrinter::terminate(  )
 272 {
 273     ::osl::MutexGuard aGuard( m_aMutex );
 274
 275     mxListener.reset();
 276 }
 277
 278 css::uno::Reference< css::awt::XDevice > VCLXPrinter::startPage(  )
 279 {
 280     ::osl::MutexGuard aGuard( m_aMutex );
 281
 282     if (mxListener)
 283     {
 284         mxListener->StartPage();
 285     }
 286     return GetDevice();
 287 }
 288
 289 void VCLXPrinter::endPage(  )
 290 {
 291     ::osl::MutexGuard aGuard( m_aMutex );
 292
 293     if (mxListener)
 294     {
 295         mxListener->EndPage();
 296     }
 297 }
 298
 299
 300 //    ----------------------------------------------------
 301 //    class VCLXInfoPrinter
 302 //    ----------------------------------------------------
 303
 304 VCLXInfoPrinter::VCLXInfoPrinter( const OUString& rPrinterName )
 305     : VCLXInfoPrinter_Base( rPrinterName )
 306 {
 307 }
 308
 309 VCLXInfoPrinter::~VCLXInfoPrinter()
 310 {
 311 }
 312
 313 // css::awt::XInfoPrinter
 314 css::uno::Reference< css::awt::XDevice > VCLXInfoPrinter::createDevice(  )
 315 {
 316     ::osl::MutexGuard aGuard( m_aMutex );
 317
 318     return GetDevice();
 319 }
 320
 321 //    ----------------------------------------------------
 322 //    class VCLXPrinterServer
 323 //    ----------------------------------------------------
 324
 325 // css::awt::XPrinterServer2
 326 css::uno::Sequence< OUString > VCLXPrinterServer::getPrinterNames(  )
 327 {
 328     const std::vector<OUString>& rQueues = Printer::GetPrinterQueues();
 329     sal_uInt32 nPrinters = rQueues.size();
 330
 331     css::uno::Sequence< OUString > aNames( nPrinters );
 332     for ( sal_uInt32 n = 0; n < nPrinters; n++ )
 333         aNames.getArray()[n] = rQueues[n];
 334
 335     return aNames;
 336 }
 337
 338 OUString VCLXPrinterServer::getDefaultPrinterName()
 339 {
 340     return Printer::GetDefaultPrinterName();
 341 }
 342
 343 css::uno::Reference< css::awt::XPrinter > VCLXPrinterServer::createPrinter( const OUString& rPrinterName )
 344 {
 345     css::uno::Reference< css::awt::XPrinter > xP = new VCLXPrinter( rPrinterName );
 346     return xP;
 347 }
 348
 349 css::uno::Reference< css::awt::XInfoPrinter > VCLXPrinterServer::createInfoPrinter( const OUString& rPrinterName )
 350 {
 351     css::uno::Reference< css::awt::XInfoPrinter > xP = new VCLXInfoPrinter( rPrinterName );
 352     return xP;
 353 }
 354
 355 OUString VCLXPrinterServer::getImplementationName()
 356 {
 357     return "stardiv.Toolkit.VCLXPrinterServer";
 358 }
 359
 360 sal_Bool VCLXPrinterServer::supportsService(OUString const & ServiceName)
 361 {
 362     return cppu::supportsService(this, ServiceName);
 363 }
 364
 365 css::uno::Sequence<OUString> VCLXPrinterServer::getSupportedServiceNames()
 366 {
 367     return css::uno::Sequence<OUString>{
 368         "com.sun.star.awt.PrinterServer", "stardiv.vcl.PrinterServer"};
 369 }
 370
 371 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 372 stardiv_Toolkit_VCLXPrinterServer_get_implementation(
 373     css::uno::XComponentContext *,
 374     css::uno::Sequence<css::uno::Any> const &)
 375 {
 376     return cppu::acquire(new VCLXPrinterServer);
 377 }
 378
 379 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */