summaryrefslogtreecommitdiffstats
path: root/sfx2/source/doc/printhelper.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--sfx2/source/doc/printhelper.cxx807
1 files changed, 807 insertions, 0 deletions
diff --git a/sfx2/source/doc/printhelper.cxx b/sfx2/source/doc/printhelper.cxx
new file mode 100644
index 000000000..7a1891037
--- /dev/null
+++ b/sfx2/source/doc/printhelper.cxx
@@ -0,0 +1,807 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+
+#include "printhelper.hxx"
+
+#include <com/sun/star/view/XPrintJob.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/view/PaperFormat.hpp>
+#include <com/sun/star/view/PaperOrientation.hpp>
+#include <com/sun/star/ucb/NameClash.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/view/DuplexMode.hpp>
+#include <comphelper/processfactory.hxx>
+#include <svl/itemset.hxx>
+#include <svl/lstner.hxx>
+#include <unotools/tempfile.hxx>
+#include <osl/file.hxx>
+#include <osl/thread.hxx>
+#include <tools/urlobj.hxx>
+#include <tools/diagnose_ex.h>
+#include <ucbhelper/content.hxx>
+#include <comphelper/interfacecontainer4.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/printer.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/event.hxx>
+
+#define SFX_PRINTABLESTATE_CANCELJOB css::view::PrintableState(-2)
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+struct IMPL_PrintListener_DataContainer : public SfxListener
+{
+ SfxObjectShellRef m_pObjectShell;
+ std::mutex m_aMutex;
+ comphelper::OInterfaceContainerHelper4<view::XPrintJobListener> m_aJobListeners;
+ uno::Reference< css::view::XPrintJob> m_xPrintJob;
+ css::uno::Sequence< css::beans::PropertyValue > m_aPrintOptions;
+
+ explicit IMPL_PrintListener_DataContainer()
+ {
+ }
+
+
+ void Notify( SfxBroadcaster& aBC ,
+ const SfxHint& aHint ) override ;
+};
+
+static awt::Size impl_Size_Object2Struct( const Size& aSize )
+{
+ awt::Size aReturnValue;
+ aReturnValue.Width = aSize.Width() ;
+ aReturnValue.Height = aSize.Height() ;
+ return aReturnValue ;
+}
+
+static Size impl_Size_Struct2Object( const awt::Size& aSize )
+{
+ Size aReturnValue;
+ aReturnValue.setWidth( aSize.Width ) ;
+ aReturnValue.setHeight( aSize.Height ) ;
+ return aReturnValue ;
+}
+
+namespace {
+
+class SfxPrintJob_Impl : public cppu::WeakImplHelper
+<
+ css::view::XPrintJob
+>
+{
+ IMPL_PrintListener_DataContainer* m_pData;
+
+public:
+ explicit SfxPrintJob_Impl( IMPL_PrintListener_DataContainer* pData );
+ virtual Sequence< css::beans::PropertyValue > SAL_CALL getPrintOptions( ) override;
+ virtual Sequence< css::beans::PropertyValue > SAL_CALL getPrinter( ) override;
+ virtual Reference< css::view::XPrintable > SAL_CALL getPrintable( ) override;
+ virtual void SAL_CALL cancelJob() override;
+};
+
+}
+
+SfxPrintJob_Impl::SfxPrintJob_Impl( IMPL_PrintListener_DataContainer* pData )
+ : m_pData( pData )
+{
+}
+
+Sequence< css::beans::PropertyValue > SAL_CALL SfxPrintJob_Impl::getPrintOptions()
+{
+ return m_pData->m_aPrintOptions;
+}
+
+Sequence< css::beans::PropertyValue > SAL_CALL SfxPrintJob_Impl::getPrinter()
+{
+ if( m_pData->m_pObjectShell.is() )
+ {
+ Reference < view::XPrintable > xPrintable( m_pData->m_pObjectShell->GetModel(), UNO_QUERY );
+ if ( xPrintable.is() )
+ return xPrintable->getPrinter();
+ }
+ return Sequence< css::beans::PropertyValue >();
+}
+
+Reference< css::view::XPrintable > SAL_CALL SfxPrintJob_Impl::getPrintable()
+{
+ Reference < view::XPrintable > xPrintable( m_pData->m_pObjectShell.is() ? m_pData->m_pObjectShell->GetModel() : nullptr, UNO_QUERY );
+ return xPrintable;
+}
+
+void SAL_CALL SfxPrintJob_Impl::cancelJob()
+{
+ // FIXME: how to cancel PrintJob via API?!
+ if( m_pData->m_pObjectShell.is() )
+ m_pData->m_pObjectShell->Broadcast( SfxPrintingHint( SFX_PRINTABLESTATE_CANCELJOB ) );
+}
+
+SfxPrintHelper::SfxPrintHelper()
+{
+ m_pData.reset(new IMPL_PrintListener_DataContainer());
+}
+
+void SAL_CALL SfxPrintHelper::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
+{
+ if ( !aArguments.hasElements() )
+ return;
+
+ css::uno::Reference < css::frame::XModel > xModel;
+ aArguments[0] >>= xModel;
+ m_pData->m_pObjectShell = SfxObjectShell::GetShellFromComponent(xModel);
+ if (m_pData->m_pObjectShell)
+ m_pData->StartListening(*m_pData->m_pObjectShell);
+}
+
+SfxPrintHelper::~SfxPrintHelper()
+{
+}
+
+namespace
+{
+ view::PaperFormat convertToPaperFormat(Paper eFormat)
+ {
+ view::PaperFormat eRet;
+ switch (eFormat)
+ {
+ case PAPER_A3:
+ eRet = view::PaperFormat_A3;
+ break;
+ case PAPER_A4:
+ eRet = view::PaperFormat_A4;
+ break;
+ case PAPER_A5:
+ eRet = view::PaperFormat_A5;
+ break;
+ case PAPER_B4_ISO:
+ eRet = view::PaperFormat_B4;
+ break;
+ case PAPER_B5_ISO:
+ eRet = view::PaperFormat_B5;
+ break;
+ case PAPER_LETTER:
+ eRet = view::PaperFormat_LETTER;
+ break;
+ case PAPER_LEGAL:
+ eRet = view::PaperFormat_LEGAL;
+ break;
+ case PAPER_TABLOID:
+ eRet = view::PaperFormat_TABLOID;
+ break;
+ case PAPER_USER:
+ default:
+ eRet = view::PaperFormat_USER;
+ break;
+ }
+ return eRet;
+ }
+
+ Paper convertToPaper(view::PaperFormat eFormat)
+ {
+ Paper eRet(PAPER_USER);
+ switch (eFormat)
+ {
+ case view::PaperFormat_A3:
+ eRet = PAPER_A3;
+ break;
+ case view::PaperFormat_A4:
+ eRet = PAPER_A4;
+ break;
+ case view::PaperFormat_A5:
+ eRet = PAPER_A5;
+ break;
+ case view::PaperFormat_B4:
+ eRet = PAPER_B4_ISO;
+ break;
+ case view::PaperFormat_B5:
+ eRet = PAPER_B5_ISO;
+ break;
+ case view::PaperFormat_LETTER:
+ eRet = PAPER_LETTER;
+ break;
+ case view::PaperFormat_LEGAL:
+ eRet = PAPER_LEGAL;
+ break;
+ case view::PaperFormat_TABLOID:
+ eRet = PAPER_TABLOID;
+ break;
+ case view::PaperFormat_USER:
+ eRet = PAPER_USER;
+ break;
+ case view::PaperFormat::PaperFormat_MAKE_FIXED_SIZE:
+ break;
+ //deliberate no default to force warn on a new papersize
+ }
+ return eRet;
+ }
+}
+
+
+// XPrintable
+
+
+uno::Sequence< beans::PropertyValue > SAL_CALL SfxPrintHelper::getPrinter()
+{
+ // object already disposed?
+ SolarMutexGuard aGuard;
+
+ // search for any view of this document that is currently printing
+ const Printer *pPrinter = nullptr;
+ SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ? SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr;
+ SfxViewFrame* pFirst = pViewFrm;
+ while ( pViewFrm && !pPrinter )
+ {
+ pPrinter = pViewFrm->GetViewShell()->GetActivePrinter();
+ pViewFrm = SfxViewFrame::GetNext( *pViewFrm, m_pData->m_pObjectShell.get(), false );
+ }
+
+ // if no view is printing currently, use the permanent SfxPrinter instance
+ if ( !pPrinter && pFirst )
+ pPrinter = pFirst->GetViewShell()->GetPrinter(true);
+
+ if ( !pPrinter )
+ return uno::Sequence< beans::PropertyValue >();
+
+ uno::Sequence< beans::PropertyValue > aPrinter(8);
+
+ aPrinter.getArray()[7].Name = "CanSetPaperSize";
+ aPrinter.getArray()[7].Value <<= pPrinter->HasSupport( PrinterSupport::SetPaperSize );
+
+ aPrinter.getArray()[6].Name = "CanSetPaperFormat";
+ aPrinter.getArray()[6].Value <<= pPrinter->HasSupport( PrinterSupport::SetPaper );
+
+ aPrinter.getArray()[5].Name = "CanSetPaperOrientation";
+ aPrinter.getArray()[5].Value <<= pPrinter->HasSupport( PrinterSupport::SetOrientation );
+
+ aPrinter.getArray()[4].Name = "IsBusy";
+ aPrinter.getArray()[4].Value <<= pPrinter->IsPrinting();
+
+ aPrinter.getArray()[3].Name = "PaperSize";
+ awt::Size aSize = impl_Size_Object2Struct(pPrinter->GetPaperSize() );
+ aPrinter.getArray()[3].Value <<= aSize;
+
+ aPrinter.getArray()[2].Name = "PaperFormat";
+ view::PaperFormat eFormat = convertToPaperFormat(pPrinter->GetPaper());
+ aPrinter.getArray()[2].Value <<= eFormat;
+
+ aPrinter.getArray()[1].Name = "PaperOrientation";
+ view::PaperOrientation eOrient = static_cast<view::PaperOrientation>(pPrinter->GetOrientation());
+ aPrinter.getArray()[1].Value <<= eOrient;
+
+ aPrinter.getArray()[0].Name = "Name";
+ OUString sStringTemp = pPrinter->GetName() ;
+ aPrinter.getArray()[0].Value <<= sStringTemp;
+
+ return aPrinter;
+}
+
+
+// XPrintable
+
+
+void SfxPrintHelper::impl_setPrinter(const uno::Sequence< beans::PropertyValue >& rPrinter,
+ VclPtr<SfxPrinter>& pPrinter,
+ SfxPrinterChangeFlags& nChangeFlags,
+ SfxViewShell*& pViewSh)
+
+{
+ // Get old Printer
+ SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ?
+ SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr;
+ if ( !pViewFrm )
+ return;
+
+ pViewSh = pViewFrm->GetViewShell();
+ pPrinter = pViewSh->GetPrinter(true);
+ if ( !pPrinter )
+ return;
+
+ // new Printer-Name available?
+ nChangeFlags = SfxPrinterChangeFlags::NONE;
+ sal_Int32 lDummy = 0;
+ auto pProp = std::find_if(rPrinter.begin(), rPrinter.end(),
+ [](const beans::PropertyValue &rProp) { return rProp.Name == "Name"; });
+ if (pProp != rPrinter.end())
+ {
+ OUString aPrinterName;
+ if ( ! ( pProp->Value >>= aPrinterName ) )
+ throw css::lang::IllegalArgumentException();
+
+ if ( aPrinterName != pPrinter->GetName() )
+ {
+ pPrinter = VclPtr<SfxPrinter>::Create( pPrinter->GetOptions().Clone(), aPrinterName );
+ nChangeFlags = SfxPrinterChangeFlags::PRINTER;
+ }
+ }
+
+ Size aSetPaperSize( 0, 0);
+ view::PaperFormat nPaperFormat = view::PaperFormat_USER;
+
+ // other properties
+ for ( const beans::PropertyValue &rProp : rPrinter )
+ {
+ // get Property-Value from printer description
+ // PaperOrientation-Property?
+ if ( rProp.Name == "PaperOrientation" )
+ {
+ view::PaperOrientation eOrient;
+ if ( !( rProp.Value >>= eOrient ) )
+ {
+ if ( !( rProp.Value >>= lDummy ) )
+ throw css::lang::IllegalArgumentException();
+ eOrient = static_cast<view::PaperOrientation>(lDummy);
+ }
+
+ if ( static_cast<Orientation>(eOrient) != pPrinter->GetOrientation() )
+ {
+ pPrinter->SetOrientation( static_cast<Orientation>(eOrient) );
+ nChangeFlags |= SfxPrinterChangeFlags::CHG_ORIENTATION;
+ }
+ }
+
+ // PaperFormat-Property?
+ else if ( rProp.Name == "PaperFormat" )
+ {
+ if ( !( rProp.Value >>= nPaperFormat ) )
+ {
+ if ( !( rProp.Value >>= lDummy ) )
+ throw css::lang::IllegalArgumentException();
+ nPaperFormat = static_cast<view::PaperFormat>(lDummy);
+ }
+
+ if ( convertToPaper(nPaperFormat) != pPrinter->GetPaper() )
+ {
+ pPrinter->SetPaper( convertToPaper(nPaperFormat) );
+ nChangeFlags |= SfxPrinterChangeFlags::CHG_SIZE;
+ }
+ }
+
+ // PaperSize-Property?
+ else if ( rProp.Name == "PaperSize" )
+ {
+ awt::Size aTempSize ;
+ if ( !( rProp.Value >>= aTempSize ) )
+ {
+ throw css::lang::IllegalArgumentException();
+ }
+ aSetPaperSize = impl_Size_Struct2Object(aTempSize);
+ }
+
+ // PrinterTray-Property
+ else if ( rProp.Name == "PrinterPaperTray" )
+ {
+ OUString aTmp;
+ if ( !( rProp.Value >>= aTmp ) )
+ throw css::lang::IllegalArgumentException();
+ const sal_uInt16 nCount = pPrinter->GetPaperBinCount();
+ for (sal_uInt16 nBin=0; nBin<nCount; nBin++)
+ {
+ OUString aName( pPrinter->GetPaperBinName(nBin) );
+ if ( aName == aTmp )
+ {
+ pPrinter->SetPaperBin(nBin);
+ break;
+ }
+ }
+ }
+ }
+
+ // The PaperSize may be set only when actually PAPER_USER
+ // applies, otherwise the driver could choose an invalid format.
+ if(nPaperFormat == view::PaperFormat_USER && aSetPaperSize.Width())
+ {
+ // Bug 56929 - MapMode of 100mm which recalculated when
+ // the device is set. Additionally only set if they were really changed.
+ aSetPaperSize = pPrinter->LogicToPixel(aSetPaperSize, MapMode(MapUnit::Map100thMM));
+ if( aSetPaperSize != pPrinter->GetPaperSizePixel() )
+ {
+ pPrinter->SetPaperSizeUser( pPrinter->PixelToLogic( aSetPaperSize ) );
+ nChangeFlags |= SfxPrinterChangeFlags::CHG_SIZE;
+ }
+ }
+
+ //wait until printing is done
+ SfxPrinter* pDocPrinter = pViewSh->GetPrinter();
+ while ( pDocPrinter->IsPrinting() && !Application::IsQuit())
+ Application::Yield();
+}
+
+void SAL_CALL SfxPrintHelper::setPrinter(const uno::Sequence< beans::PropertyValue >& rPrinter)
+{
+ // object already disposed?
+ SolarMutexGuard aGuard;
+
+ SfxViewShell* pViewSh = nullptr;
+ VclPtr<SfxPrinter> pPrinter;
+ SfxPrinterChangeFlags nChangeFlags = SfxPrinterChangeFlags::NONE;
+ impl_setPrinter(rPrinter,pPrinter,nChangeFlags,pViewSh);
+ // set new printer
+ if ( pViewSh && pPrinter )
+ pViewSh->SetPrinter( pPrinter, nChangeFlags );
+}
+
+
+// ImplPrintWatch thread for asynchronous printing with moving temp. file to ucb location
+
+namespace {
+
+/* This implements a thread which will be started to wait for asynchronous
+ print jobs to temp. locally files. If they finish we move the temp. files
+ to their right locations by using the ucb.
+ */
+class ImplUCBPrintWatcher : public ::osl::Thread
+{
+ private:
+ /// of course we must know the printer which execute the job
+ VclPtr<SfxPrinter> m_pPrinter;
+ /// this describes the target location for the printed temp file
+ OUString m_sTargetURL;
+ /// it holds the temp file alive, till the print job will finish and remove it from disk automatically if the object die
+ ::utl::TempFile* m_pTempFile;
+
+ public:
+ /* initialize this watcher but don't start it */
+ ImplUCBPrintWatcher( SfxPrinter* pPrinter, ::utl::TempFile* pTempFile, const OUString& sTargetURL )
+ : m_pPrinter ( pPrinter )
+ , m_sTargetURL( sTargetURL )
+ , m_pTempFile ( pTempFile )
+ {}
+
+ /* waits for finishing of the print job and moves the temp file afterwards
+ Note: Starting of the job is done outside this thread!
+ But we have to free some of the given resources on heap!
+ */
+ void SAL_CALL run() override
+ {
+ osl_setThreadName("ImplUCBPrintWatcher");
+
+ /* SAFE { */
+ {
+ SolarMutexGuard aGuard;
+ while( m_pPrinter->IsPrinting() && !Application::IsQuit())
+ Application::Yield();
+ m_pPrinter.clear(); // don't delete it! It's borrowed only :-)
+ }
+ /* } SAFE */
+
+ // lock for further using of our member isn't necessary - because
+ // we run alone by definition. Nobody join for us nor use us...
+ moveAndDeleteTemp(&m_pTempFile,m_sTargetURL);
+
+ // finishing of this run() method will call onTerminate() automatically
+ // kill this thread there!
+ }
+
+ /* nobody wait for this thread. We must kill ourself ...
+ */
+ void SAL_CALL onTerminated() override
+ {
+ delete this;
+ }
+
+ /* static helper to move the temp. file to the target location by using the ucb
+ It's static to be usable from outside too. So it's not really necessary to start
+ the thread, if finishing of the job was detected outside this thread.
+ But it must be called without using a corresponding thread for the given parameter!
+ */
+ static void moveAndDeleteTemp( ::utl::TempFile** ppTempFile, std::u16string_view sTargetURL )
+ {
+ // move the file
+ try
+ {
+ INetURLObject aSplitter(sTargetURL);
+ OUString sFileName = aSplitter.getName(
+ INetURLObject::LAST_SEGMENT,
+ true,
+ INetURLObject::DecodeMechanism::WithCharset);
+ if (aSplitter.removeSegment() && !sFileName.isEmpty())
+ {
+ ::ucbhelper::Content aSource(
+ (*ppTempFile)->GetURL(),
+ css::uno::Reference< css::ucb::XCommandEnvironment >(),
+ comphelper::getProcessComponentContext());
+
+ ::ucbhelper::Content aTarget(
+ aSplitter.GetMainURL(INetURLObject::DecodeMechanism::NONE),
+ css::uno::Reference< css::ucb::XCommandEnvironment >(),
+ comphelper::getProcessComponentContext());
+
+ aTarget.transferContent(
+ aSource,
+ ::ucbhelper::InsertOperation::Copy,
+ sFileName,
+ css::ucb::NameClash::OVERWRITE);
+ }
+ }
+ catch (const css::uno::Exception&)
+ {
+ TOOLS_WARN_EXCEPTION( "sfx.doc", "");
+ }
+
+ // kill the temp file!
+ delete *ppTempFile;
+ *ppTempFile = nullptr;
+ }
+};
+
+}
+
+// XPrintable
+
+void SAL_CALL SfxPrintHelper::print(const uno::Sequence< beans::PropertyValue >& rOptions)
+{
+ if( Application::GetSettings().GetMiscSettings().GetDisablePrinting() )
+ return;
+
+ // object already disposed?
+ // object already disposed?
+ SolarMutexGuard aGuard;
+
+ // get view for sfx printing capabilities
+ SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ?
+ SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr;
+ if ( !pViewFrm )
+ return;
+ SfxViewShell* pView = pViewFrm->GetViewShell();
+ if ( !pView )
+ return;
+ bool bMonitor = false;
+ // We need this information at the end of this method, if we start the vcl printer
+ // by executing the slot. Because if it is a ucb relevant URL we must wait for
+ // finishing the print job and move the temporary local file by using the ucb
+ // to the right location. But in case of no file name is given or it is already
+ // a local one we can suppress this special handling. Because then vcl makes all
+ // right for us.
+ OUString sUcbUrl;
+ ::utl::TempFile* pUCBPrintTempFile = nullptr;
+
+ uno::Sequence < beans::PropertyValue > aCheckedArgs( rOptions.getLength() );
+ auto pCheckedArgs = aCheckedArgs.getArray();
+ sal_Int32 nProps = 0;
+ bool bWaitUntilEnd = false;
+ sal_Int16 nDuplexMode = css::view::DuplexMode::UNKNOWN;
+ for ( const beans::PropertyValue &rProp : rOptions )
+ {
+ // get Property-Value from options
+ // FileName-Property?
+ if ( rProp.Name == "FileName" )
+ {
+ // unpack th URL and check for a valid and well known protocol
+ OUString sTemp;
+ if (
+ ( rProp.Value.getValueType()!=cppu::UnoType<OUString>::get()) ||
+ (!(rProp.Value>>=sTemp))
+ )
+ {
+ throw css::lang::IllegalArgumentException();
+ }
+
+ OUString sPath;
+ OUString sURL (sTemp);
+ INetURLObject aCheck(sURL );
+ if (aCheck.GetProtocol()==INetProtocol::NotValid)
+ {
+ // OK - it's not a valid URL. But may it's a simple
+ // system path directly. It will be supported for historical
+ // reasons. Otherwise we break too much external code...
+ // We try to convert it to a file URL. If it's possible
+ // we put the system path to the item set and let vcl work with it.
+ // No ucb or thread will be necessary then. In case it couldn't be
+ // converted it's not a URL nor a system path. Then we can't accept
+ // this parameter and have to throw an exception.
+ const OUString& sSystemPath(sTemp);
+ OUString sFileURL;
+ if (::osl::FileBase::getFileURLFromSystemPath(sSystemPath,sFileURL)!=::osl::FileBase::E_None)
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= sFileURL;
+ // and append the local filename
+ aCheckedArgs.realloc( aCheckedArgs.getLength()+1 );
+ pCheckedArgs = aCheckedArgs.getArray();
+ pCheckedArgs[nProps].Name = "LocalFileName";
+ pCheckedArgs[nProps++].Value <<= sTemp;
+ }
+ else
+ // It's a valid URL. but now we must know, if it is a local one or not.
+ // It's a question of using ucb or not!
+ if (osl::FileBase::getSystemPathFromFileURL(sURL, sPath) == osl::FileBase::E_None)
+ {
+ // it's a local file, we can use vcl without special handling
+ // And we have to use the system notation of the incoming URL.
+ // But it into the descriptor and let the slot be executed at
+ // the end of this method.
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= sTemp;
+ // and append the local filename
+ aCheckedArgs.realloc( aCheckedArgs.getLength()+1 );
+ pCheckedArgs = aCheckedArgs.getArray();
+ pCheckedArgs[nProps].Name = "LocalFileName";
+ pCheckedArgs[nProps++].Value <<= sPath;
+ }
+ else
+ {
+ // it's a ucb target. So we must use a temp. file for vcl
+ // and move it after printing by using the ucb.
+ // Create a temp file on the heap (because it must delete the
+ // real file on disk automatically if it die - bt we have to share it with
+ // some other sources ... e.g. the ImplUCBPrintWatcher).
+ // And we put the name of this temp file to the descriptor instead
+ // of the URL. The URL we save for later using separately.
+ // Execution of the print job will be done later by executing
+ // a slot ...
+ if(!pUCBPrintTempFile)
+ pUCBPrintTempFile = new ::utl::TempFile();
+ pUCBPrintTempFile->EnableKillingFile();
+
+ //FIXME: does it work?
+ pCheckedArgs[nProps].Name = "LocalFileName";
+ pCheckedArgs[nProps++].Value <<= pUCBPrintTempFile->GetFileName();
+ sUcbUrl = sURL;
+ }
+ }
+
+ // CopyCount-Property
+ else if ( rProp.Name == "CopyCount" )
+ {
+ sal_Int32 nCopies = 0;
+ if ( !( rProp.Value >>= nCopies ) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= nCopies;
+ }
+
+ // Collate-Property
+ // Sort-Property (deprecated)
+ else if ( rProp.Name == "Collate" || rProp.Name == "Sort" )
+ {
+ bool bTemp;
+ if ( !(rProp.Value >>= bTemp) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = "Collate";
+ pCheckedArgs[nProps++].Value <<= bTemp;
+ }
+
+ else if ( rProp.Name == "SinglePrintJobs" )
+ {
+ bool bTemp;
+ if ( !(rProp.Value >>= bTemp) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = "SinglePrintJobs";
+ pCheckedArgs[nProps++].Value <<= bTemp;
+ }
+
+ // Pages-Property
+ else if ( rProp.Name == "Pages" )
+ {
+ OUString sTemp;
+ if( !(rProp.Value >>= sTemp) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= sTemp;
+ }
+
+ // MonitorVisible
+ else if ( rProp.Name == "MonitorVisible" )
+ {
+ if( !(rProp.Value >>= bMonitor) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= bMonitor;
+ }
+
+ // Wait
+ else if ( rProp.Name == "Wait" )
+ {
+ if ( !(rProp.Value >>= bWaitUntilEnd) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= bWaitUntilEnd;
+ }
+
+ else if ( rProp.Name == "DuplexMode" )
+ {
+ if ( !(rProp.Value >>= nDuplexMode ) )
+ throw css::lang::IllegalArgumentException();
+ pCheckedArgs[nProps].Name = rProp.Name;
+ pCheckedArgs[nProps++].Value <<= nDuplexMode;
+ }
+ }
+
+ if ( nProps != aCheckedArgs.getLength() )
+ aCheckedArgs.realloc(nProps);
+
+ // Execute the print request every time.
+ // It doesn't matter if it is a real printer used or we print to a local file
+ // nor if we print to a temp file and move it afterwards by using the ucb.
+ // That will be handled later. see pUCBPrintFile below!
+ pView->ExecPrint( aCheckedArgs, true, false );
+
+ // Ok - may be execution before has finished (or started!) printing.
+ // And may it was a printing to a file.
+ // Now we have to check if we can move the file (if necessary) via UCB to its right location.
+ // Cases:
+ // a) printing finished => move the file directly and forget the watcher thread
+ // b) printing is asynchron and runs currently => start watcher thread and exit this method
+ // This thread make all necessary things by itself.
+ if (!pUCBPrintTempFile)
+ return;
+
+ // a)
+ SfxPrinter* pPrinter = pView->GetPrinter();
+ if ( ! pPrinter->IsPrinting() )
+ ImplUCBPrintWatcher::moveAndDeleteTemp(&pUCBPrintTempFile,sUcbUrl);
+ // b)
+ else
+ {
+ // Note: we create(d) some resource on the heap (thread and temp file).
+ // They will be deleted by the thread automatically if it finishes its run() method.
+ ImplUCBPrintWatcher* pWatcher = new ImplUCBPrintWatcher( pPrinter, pUCBPrintTempFile, sUcbUrl );
+ pWatcher->create();
+ }
+}
+
+void IMPL_PrintListener_DataContainer::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
+{
+ const SfxPrintingHint* pPrintHint = dynamic_cast<const SfxPrintingHint*>(&rHint);
+ if ( &rBC != m_pObjectShell.get()
+ || !pPrintHint
+ || pPrintHint->GetWhich() == SFX_PRINTABLESTATE_CANCELJOB )
+ return;
+
+ if ( pPrintHint->GetWhich() == css::view::PrintableState_JOB_STARTED )
+ {
+ if ( !m_xPrintJob.is() )
+ m_xPrintJob = new SfxPrintJob_Impl( this );
+ m_aPrintOptions = pPrintHint->GetOptions();
+ }
+
+ std::unique_lock aGuard(m_aMutex);
+ if (!m_aJobListeners.getLength(aGuard))
+ return;
+ view::PrintJobEvent aEvent;
+ aEvent.Source = m_xPrintJob;
+ aEvent.State = pPrintHint->GetWhich();
+
+ comphelper::OInterfaceIteratorHelper4 pIterator(aGuard, m_aJobListeners);
+ aGuard.unlock();
+ while (pIterator.hasMoreElements())
+ pIterator.next()->printJobEvent( aEvent );
+}
+
+void SAL_CALL SfxPrintHelper::addPrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener )
+{
+ std::unique_lock aGuard(m_pData->m_aMutex);
+ m_pData->m_aJobListeners.addInterface( aGuard, xListener );
+}
+
+void SAL_CALL SfxPrintHelper::removePrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener )
+{
+ std::unique_lock aGuard(m_pData->m_aMutex);
+ m_pData->m_aJobListeners.removeInterface( aGuard, xListener );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 12:31:55 +0000