| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sfx2.hxx" |
| |
| #include <com/sun/star/document/XDocumentProperties.hpp> |
| #include "com/sun/star/view/XRenderable.hpp" |
| |
| #include <svl/itempool.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svtools/prnsetup.hxx> |
| #include <svl/flagitem.hxx> |
| #include <svl/stritem.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/eitem.hxx> |
| #include <sfx2/app.hxx> |
| #include <unotools/useroptions.hxx> |
| #include <unotools/printwarningoptions.hxx> |
| #include <tools/datetime.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/objface.hxx> |
| #include <sfx2/viewsh.hxx> |
| #include "viewimp.hxx" |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/prnmon.hxx> |
| #include "sfx2/sfxresid.hxx" |
| #include <sfx2/request.hxx> |
| #include <sfx2/objsh.hxx> |
| #include "sfxtypes.hxx" |
| #include <sfx2/event.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <sfx2/docfilt.hxx> |
| |
| #include "toolkit/awt/vclxdevice.hxx" |
| |
| #include "view.hrc" |
| #include "helpid.hrc" |
| |
| using namespace com::sun::star; |
| using namespace com::sun::star::uno; |
| |
| TYPEINIT1(SfxPrintingHint, SfxViewEventHint); |
| |
| // ----------------------------------------------------------------------- |
| class SfxPrinterController : public vcl::PrinterController, public SfxListener |
| { |
| Any maCompleteSelection; |
| Any maSelection; |
| Reference< view::XRenderable > mxRenderable; |
| mutable Printer* mpLastPrinter; |
| mutable Reference<awt::XDevice> mxDevice; |
| SfxViewShell* mpViewShell; |
| SfxObjectShell* mpObjectShell; |
| sal_Bool m_bOrigStatus; |
| sal_Bool m_bNeedsChange; |
| sal_Bool m_bApi; |
| sal_Bool m_bTempPrinter; |
| util::DateTime m_aLastPrinted; |
| ::rtl::OUString m_aLastPrintedBy; |
| |
| Sequence< beans::PropertyValue > getMergedOptions() const; |
| const Any& getSelectionObject() const; |
| public: |
| SfxPrinterController( const boost::shared_ptr<Printer>& i_rPrinter, |
| const Any& i_rComplete, |
| const Any& i_rSelection, |
| const Any& i_rViewProp, |
| const Reference< view::XRenderable >& i_xRender, |
| sal_Bool i_bApi, sal_Bool i_bDirect, |
| SfxViewShell* pView, |
| const uno::Sequence< beans::PropertyValue >& rProps |
| ); |
| |
| virtual ~SfxPrinterController(); |
| virtual void Notify( SfxBroadcaster&, const SfxHint& ); |
| |
| virtual int getPageCount() const; |
| virtual Sequence< beans::PropertyValue > getPageParameters( int i_nPage ) const; |
| virtual void printPage( int i_nPage ) const; |
| virtual void jobStarted(); |
| virtual void jobFinished( com::sun::star::view::PrintableState ); |
| }; |
| |
| SfxPrinterController::SfxPrinterController( const boost::shared_ptr<Printer>& i_rPrinter, |
| const Any& i_rComplete, |
| const Any& i_rSelection, |
| const Any& i_rViewProp, |
| const Reference< view::XRenderable >& i_xRender, |
| sal_Bool i_bApi, sal_Bool i_bDirect, |
| SfxViewShell* pView, |
| const uno::Sequence< beans::PropertyValue >& rProps |
| ) |
| : PrinterController( i_rPrinter) |
| , maCompleteSelection( i_rComplete ) |
| , maSelection( i_rSelection ) |
| , mxRenderable( i_xRender ) |
| , mpLastPrinter( NULL ) |
| , mpViewShell( pView ) |
| , mpObjectShell(0) |
| , m_bOrigStatus( sal_False ) |
| , m_bNeedsChange( sal_False ) |
| , m_bApi(i_bApi) |
| , m_bTempPrinter( i_rPrinter.get() != NULL ) |
| { |
| if ( mpViewShell ) |
| { |
| StartListening( *mpViewShell ); |
| mpObjectShell = mpViewShell->GetObjectShell(); |
| StartListening( *mpObjectShell ); |
| } |
| |
| // initialize extra ui options |
| if( mxRenderable.is() ) |
| { |
| for (sal_Int32 nProp=0; nProp<rProps.getLength(); nProp++) |
| setValue( rProps[nProp].Name, rProps[nProp].Value ); |
| |
| Sequence< beans::PropertyValue > aRenderOptions( 3 ); |
| aRenderOptions[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ExtraPrintUIOptions" ) ); |
| aRenderOptions[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "View" ) ); |
| aRenderOptions[1].Value = i_rViewProp; |
| aRenderOptions[2].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrinter" ) ); |
| aRenderOptions[2].Value <<= sal_True; |
| try |
| { |
| Sequence< beans::PropertyValue > aRenderParms( mxRenderable->getRenderer( 0 , getSelectionObject(), aRenderOptions ) ); |
| int nProps = aRenderParms.getLength(); |
| for( int i = 0; i < nProps; i++ ) |
| { |
| if( aRenderParms[i].Name.equalsAscii( "ExtraPrintUIOptions" ) ) |
| { |
| Sequence< beans::PropertyValue > aUIProps; |
| aRenderParms[i].Value >>= aUIProps; |
| setUIOptions( aUIProps ); |
| } |
| else if( aRenderParms[i].Name.compareToAscii( "NUp", 3 ) == 0 ) |
| { |
| setValue( aRenderParms[i].Name, aRenderParms[i].Value ); |
| } |
| } |
| } |
| catch( lang::IllegalArgumentException& ) |
| { |
| // the first renderer should always be available for the UI options, |
| // but catch the exception to be safe |
| } |
| } |
| |
| // set some job parameters |
| setValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsApi" ) ), makeAny( i_bApi ) ); |
| setValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsDirect" ) ), makeAny( i_bDirect ) ); |
| setValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrinter" ) ), makeAny( sal_True ) ); |
| setValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "View" ) ), i_rViewProp ); |
| } |
| |
| void SfxPrinterController::Notify( SfxBroadcaster& , const SfxHint& rHint ) |
| { |
| if ( rHint.IsA(TYPE(SfxSimpleHint)) ) |
| { |
| if ( ((SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) |
| { |
| EndListening(*mpViewShell); |
| EndListening(*mpObjectShell); |
| mpViewShell = 0; |
| mpObjectShell = 0; |
| } |
| } |
| } |
| |
| SfxPrinterController::~SfxPrinterController() |
| { |
| } |
| |
| const Any& SfxPrinterController::getSelectionObject() const |
| { |
| const beans::PropertyValue* pVal = getValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintSelectionOnly" ) ) ); |
| if( pVal ) |
| { |
| sal_Bool bSel = sal_False; |
| pVal->Value >>= bSel; |
| return bSel ? maSelection : maCompleteSelection; |
| } |
| |
| sal_Int32 nChoice = 0; |
| pVal = getValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintContent" ) ) ); |
| if( pVal ) |
| pVal->Value >>= nChoice; |
| return (nChoice > 1) ? maSelection : maCompleteSelection; |
| } |
| |
| Sequence< beans::PropertyValue > SfxPrinterController::getMergedOptions() const |
| { |
| boost::shared_ptr<Printer> pPrinter( getPrinter() ); |
| if( pPrinter.get() != mpLastPrinter ) |
| { |
| mpLastPrinter = pPrinter.get(); |
| VCLXDevice* pXDevice = new VCLXDevice(); |
| pXDevice->SetOutputDevice( mpLastPrinter ); |
| mxDevice = Reference< awt::XDevice >( pXDevice ); |
| } |
| |
| Sequence< beans::PropertyValue > aRenderOptions( 1 ); |
| aRenderOptions[ 0 ].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RenderDevice" ) ); |
| aRenderOptions[ 0 ].Value <<= mxDevice; |
| |
| aRenderOptions = getJobProperties( aRenderOptions ); |
| return aRenderOptions; |
| } |
| |
| int SfxPrinterController::getPageCount() const |
| { |
| int nPages = 0; |
| boost::shared_ptr<Printer> pPrinter( getPrinter() ); |
| if( mxRenderable.is() && pPrinter ) |
| { |
| Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() ); |
| nPages = mxRenderable->getRendererCount( getSelectionObject(), aJobOptions ); |
| } |
| return nPages; |
| } |
| |
| Sequence< beans::PropertyValue > SfxPrinterController::getPageParameters( int i_nPage ) const |
| { |
| boost::shared_ptr<Printer> pPrinter( getPrinter() ); |
| Sequence< beans::PropertyValue > aResult; |
| |
| if( mxRenderable.is() && pPrinter ) |
| { |
| Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() ); |
| try |
| { |
| aResult = mxRenderable->getRenderer( i_nPage, getSelectionObject(), aJobOptions ); |
| } |
| catch( lang::IllegalArgumentException& ) |
| { |
| } |
| } |
| return aResult; |
| } |
| |
| void SfxPrinterController::printPage( int i_nPage ) const |
| { |
| boost::shared_ptr<Printer> pPrinter( getPrinter() ); |
| if( mxRenderable.is() && pPrinter ) |
| { |
| Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() ); |
| try |
| { |
| mxRenderable->render( i_nPage, getSelectionObject(), aJobOptions ); |
| } |
| catch( lang::IllegalArgumentException& ) |
| { |
| // don't care enough about nonexistant page here |
| // to provoke a crash |
| } |
| } |
| } |
| |
| void SfxPrinterController::jobStarted() |
| { |
| if ( mpObjectShell ) |
| { |
| m_bOrigStatus = mpObjectShell->IsEnableSetModified(); |
| |
| // check configuration: shall update of printing information in DocInfo set the document to "modified"? |
| if ( m_bOrigStatus && !SvtPrintWarningOptions().IsModifyDocumentOnPrintingAllowed() ) |
| { |
| mpObjectShell->EnableSetModified( sal_False ); |
| m_bNeedsChange = sal_True; |
| } |
| |
| // refresh document info |
| uno::Reference<document::XDocumentProperties> xDocProps(mpObjectShell->getDocProperties()); |
| m_aLastPrintedBy = xDocProps->getPrintedBy(); |
| m_aLastPrinted = xDocProps->getPrintDate(); |
| |
| xDocProps->setPrintedBy( mpObjectShell->IsUseUserData() |
| ? ::rtl::OUString( SvtUserOptions().GetFullName() ) |
| : ::rtl::OUString() ); |
| ::DateTime now; |
| |
| xDocProps->setPrintDate( util::DateTime( |
| now.Get100Sec(), now.GetSec(), now.GetMin(), now.GetHour(), |
| now.GetDay(), now.GetMonth(), now.GetYear() ) ); |
| |
| uno::Sequence < beans::PropertyValue > aOpts; |
| aOpts = getJobProperties( aOpts ); |
| |
| uno::Reference< frame::XController2 > xController; |
| if ( mpViewShell ) |
| xController.set( mpViewShell->GetController(), uno::UNO_QUERY ); |
| |
| mpObjectShell->Broadcast( SfxPrintingHint( |
| view::PrintableState_JOB_STARTED, aOpts, mpObjectShell, xController ) ); |
| } |
| } |
| |
| void SfxPrinterController::jobFinished( com::sun::star::view::PrintableState nState ) |
| { |
| if ( mpObjectShell ) |
| { |
| bool bCopyJobSetup = false; |
| mpObjectShell->Broadcast( SfxPrintingHint( nState ) ); |
| switch ( nState ) |
| { |
| case view::PrintableState_JOB_FAILED : |
| { |
| // "real" problem (not simply printing cancelled by user) |
| String aMsg( SfxResId( STR_NOSTARTPRINTER ) ); |
| if ( !m_bApi ) |
| ErrorBox( mpViewShell->GetWindow(), WB_OK | WB_DEF_OK, aMsg ).Execute(); |
| // intentionally no break |
| } |
| case view::PrintableState_JOB_ABORTED : |
| { |
| // printing not succesful, reset DocInfo |
| uno::Reference<document::XDocumentProperties> xDocProps(mpObjectShell->getDocProperties()); |
| xDocProps->setPrintedBy(m_aLastPrintedBy); |
| xDocProps->setPrintDate(m_aLastPrinted); |
| break; |
| } |
| |
| case view::PrintableState_JOB_SPOOLED : |
| case view::PrintableState_JOB_COMPLETED : |
| { |
| SfxBindings& rBind = mpViewShell->GetViewFrame()->GetBindings(); |
| rBind.Invalidate( SID_PRINTDOC ); |
| rBind.Invalidate( SID_PRINTDOCDIRECT ); |
| rBind.Invalidate( SID_SETUPPRINTER ); |
| bCopyJobSetup = ! m_bTempPrinter; |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| if( bCopyJobSetup && mpViewShell ) |
| { |
| // #i114306# |
| // Note: this possibly creates a printer that gets immediately replaced |
| // by a new one. The reason for this is that otherwise we would not get |
| // the printer's SfxItemSet here to copy. Awkward, but at the moment there is no |
| // other way here to get the item set. |
| SfxPrinter* pDocPrt = mpViewShell->GetPrinter(sal_True); |
| if( pDocPrt ) |
| { |
| if( pDocPrt->GetName() == getPrinter()->GetName() ) |
| pDocPrt->SetJobSetup( getPrinter()->GetJobSetup() ); |
| else |
| { |
| SfxPrinter* pNewPrt = new SfxPrinter( pDocPrt->GetOptions().Clone(), getPrinter()->GetName() ); |
| pNewPrt->SetJobSetup( getPrinter()->GetJobSetup() ); |
| mpViewShell->SetPrinter( pNewPrt, SFX_PRINTER_PRINTER | SFX_PRINTER_JOBSETUP ); |
| } |
| } |
| } |
| |
| if ( m_bNeedsChange ) |
| mpObjectShell->EnableSetModified( m_bOrigStatus ); |
| |
| if ( mpViewShell ) |
| { |
| mpViewShell->pImp->m_pPrinterController.reset(); |
| } |
| } |
| } |
| |
| //==================================================================== |
| |
| class SfxDialogExecutor_Impl |
| |
| /* [Beschreibung] |
| |
| Eine Instanz dieser Klasse wird f"ur die Laufzeit des Printer-Dialogs |
| erzeugt, um im dessen Click-Handler f"ur die Zus"atze den per |
| virtueller Methode von der abgeleiteten SfxViewShell erzeugten |
| Print-Options-Dialog zu erzeugen und die dort eingestellten Optionen |
| als SfxItemSet zu zwischenzuspeichern. |
| */ |
| |
| { |
| private: |
| SfxViewShell* _pViewSh; |
| PrinterSetupDialog* _pSetupParent; |
| SfxItemSet* _pOptions; |
| sal_Bool _bModified; |
| sal_Bool _bHelpDisabled; |
| |
| DECL_LINK( Execute, void * ); |
| |
| public: |
| SfxDialogExecutor_Impl( SfxViewShell* pViewSh, PrinterSetupDialog* pParent ); |
| ~SfxDialogExecutor_Impl() { delete _pOptions; } |
| |
| Link GetLink() const { return LINK( this, SfxDialogExecutor_Impl, Execute); } |
| const SfxItemSet* GetOptions() const { return _pOptions; } |
| void DisableHelp() { _bHelpDisabled = sal_True; } |
| }; |
| |
| //-------------------------------------------------------------------- |
| |
| SfxDialogExecutor_Impl::SfxDialogExecutor_Impl( SfxViewShell* pViewSh, PrinterSetupDialog* pParent ) : |
| |
| _pViewSh ( pViewSh ), |
| _pSetupParent ( pParent ), |
| _pOptions ( NULL ), |
| _bModified ( sal_False ), |
| _bHelpDisabled ( sal_False ) |
| |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| IMPL_LINK( SfxDialogExecutor_Impl, Execute, void *, EMPTYARG ) |
| { |
| // Options lokal merken |
| if ( !_pOptions ) |
| { |
| DBG_ASSERT( _pSetupParent, "no dialog parent" ); |
| if( _pSetupParent ) |
| _pOptions = ( (SfxPrinter*)_pSetupParent->GetPrinter() )->GetOptions().Clone(); |
| } |
| |
| // Dialog ausf"uhren |
| SfxPrintOptionsDialog* pDlg = new SfxPrintOptionsDialog( static_cast<Window*>(_pSetupParent), |
| _pViewSh, _pOptions ); |
| if ( _bHelpDisabled ) |
| pDlg->DisableHelp(); |
| if ( pDlg->Execute() == RET_OK ) |
| { |
| delete _pOptions; |
| _pOptions = pDlg->GetOptions().Clone(); |
| |
| } |
| delete pDlg; |
| |
| return 0; |
| } |
| |
| //------------------------------------------------------------------------- |
| |
| sal_Bool UseStandardPrinter_Impl( Window* /*pParent*/, SfxPrinter* pDocPrinter ) |
| { |
| // Optionen abfragen, ob gewarnt werden soll (Doc uebersteuert App) |
| sal_Bool bWarn = sal_False; |
| const SfxItemSet *pDocOptions = &pDocPrinter->GetOptions(); |
| if ( pDocOptions ) |
| { |
| sal_uInt16 nWhich = pDocOptions->GetPool()->GetWhich(SID_PRINTER_NOTFOUND_WARN); |
| const SfxBoolItem* pBoolItem = NULL; |
| pDocPrinter->GetOptions().GetItemState( nWhich, sal_False, (const SfxPoolItem**) &pBoolItem ); |
| if ( pBoolItem ) |
| bWarn = pBoolItem->GetValue(); |
| } |
| /* |
| // ggf. den User fragen |
| if ( bWarn ) |
| { |
| // Geht nicht mehr ohne OrigJobSetup! |
| String aTmp( SfxResId( STR_PRINTER_NOTAVAIL ) ); |
| QueryBox aBox( pParent, WB_OK_CANCEL | WB_DEF_OK, aTmp ); |
| return RET_OK == aBox.Execute(); |
| } |
| */ |
| // nicht gewarnt => einfach so den StandardDrucker nehmen |
| return sal_True; |
| } |
| //------------------------------------------------------------------------- |
| |
| SfxPrinter* SfxViewShell::SetPrinter_Impl( SfxPrinter *pNewPrinter ) |
| |
| /* Interne Methode zum Setzen der Unterschiede von 'pNewPrinter' zum |
| aktuellen Printer. pNewPrinter wird entweder "ubernommen oder gel"oscht. |
| */ |
| |
| { |
| // aktuellen Printer holen |
| SfxPrinter *pDocPrinter = GetPrinter(); |
| |
| // Printer-Options auswerten |
| bool bOriToDoc = false; |
| bool bSizeToDoc = false; |
| if ( &pDocPrinter->GetOptions() ) |
| { |
| sal_uInt16 nWhich = GetPool().GetWhich(SID_PRINTER_CHANGESTODOC); |
| const SfxFlagItem *pFlagItem = 0; |
| pDocPrinter->GetOptions().GetItemState( nWhich, sal_False, (const SfxPoolItem**) &pFlagItem ); |
| bOriToDoc = pFlagItem ? (pFlagItem->GetValue() & SFX_PRINTER_CHG_ORIENTATION) : sal_False; |
| bSizeToDoc = pFlagItem ? (pFlagItem->GetValue() & SFX_PRINTER_CHG_SIZE) : sal_False; |
| } |
| |
| // vorheriges Format und Size feststellen |
| Orientation eOldOri = pDocPrinter->GetOrientation(); |
| Size aOldPgSz = pDocPrinter->GetPaperSizePixel(); |
| |
| // neues Format und Size feststellen |
| Orientation eNewOri = pNewPrinter->GetOrientation(); |
| Size aNewPgSz = pNewPrinter->GetPaperSizePixel(); |
| |
| // "Anderungen am Seitenformat feststellen |
| sal_Bool bOriChg = (eOldOri != eNewOri) && bOriToDoc; |
| sal_Bool bPgSzChg = ( aOldPgSz.Height() != |
| ( bOriChg ? aNewPgSz.Width() : aNewPgSz.Height() ) || |
| aOldPgSz.Width() != |
| ( bOriChg ? aNewPgSz.Height() : aNewPgSz.Width() ) ) && |
| bSizeToDoc; |
| |
| // Message und Flags f"ur Seitenformat-"Anderung zusammenstellen |
| String aMsg; |
| sal_uInt16 nNewOpt=0; |
| if( bOriChg && bPgSzChg ) |
| { |
| aMsg = String(SfxResId(STR_PRINT_NEWORISIZE)); |
| nNewOpt = SFX_PRINTER_CHG_ORIENTATION | SFX_PRINTER_CHG_SIZE; |
| } |
| else if (bOriChg ) |
| { |
| aMsg = String(SfxResId(STR_PRINT_NEWORI)); |
| nNewOpt = SFX_PRINTER_CHG_ORIENTATION; |
| } |
| else if (bPgSzChg) |
| { |
| aMsg = String(SfxResId(STR_PRINT_NEWSIZE)); |
| nNewOpt = SFX_PRINTER_CHG_SIZE; |
| } |
| |
| // in dieser Variable sammeln, was sich so ge"aendert hat |
| sal_uInt16 nChangedFlags = 0; |
| |
| // ggf. Nachfrage, ob Seitenformat vom Drucker "ubernommen werden soll |
| if ( ( bOriChg || bPgSzChg ) && |
| RET_YES == QueryBox(0, WB_YES_NO | WB_DEF_OK, aMsg).Execute() ) |
| // Flags mit "Anderungen f"ur <SetPrinter(SfxPrinter*)> mitpflegen |
| nChangedFlags |= nNewOpt; |
| |
| // fuer den MAC sein "temporary of class String" im naechsten if() |
| String aTempPrtName = pNewPrinter->GetName(); |
| String aDocPrtName = pDocPrinter->GetName(); |
| |
| // Wurde der Drucker gewechselt oder von Default auf Specific |
| // oder umgekehrt geaendert? |
| if ( (aTempPrtName != aDocPrtName) || (pDocPrinter->IsDefPrinter() != pNewPrinter->IsDefPrinter()) ) |
| { |
| // neuen Printer "ubernehmen |
| // pNewPrinter->SetOrigJobSetup( pNewPrinter->GetJobSetup() ); |
| nChangedFlags |= SFX_PRINTER_PRINTER|SFX_PRINTER_JOBSETUP; |
| pDocPrinter = pNewPrinter; |
| } |
| else |
| { |
| // Extra-Optionen vergleichen |
| if ( ! (pNewPrinter->GetOptions() == pDocPrinter->GetOptions()) ) |
| { |
| // Options haben sich geaendert |
| pDocPrinter->SetOptions( pNewPrinter->GetOptions() ); |
| nChangedFlags |= SFX_PRINTER_OPTIONS; |
| } |
| |
| // JobSetups vergleichen |
| JobSetup aNewJobSetup = pNewPrinter->GetJobSetup(); |
| JobSetup aOldJobSetup = pDocPrinter->GetJobSetup(); |
| if ( aNewJobSetup != aOldJobSetup ) |
| { |
| // JobSetup hat sich geaendert (=> App mu\s neu formatieren) |
| // pDocPrinter->SetOrigJobSetup( aNewJobSetup ); |
| nChangedFlags |= SFX_PRINTER_JOBSETUP; |
| } |
| |
| // alten, ver"anderten Printer behalten |
| pDocPrinter->SetPrinterProps( pNewPrinter ); |
| delete pNewPrinter; |
| } |
| |
| if ( 0 != nChangedFlags ) |
| // SetPrinter will delete the old printer if it changes |
| SetPrinter( pDocPrinter, nChangedFlags ); |
| return pDocPrinter; |
| } |
| |
| //------------------------------------------------------------------------- |
| // Unter WIN32 tritt leider das Problem auf, dass nichts gedruckt |
| // wird, wenn SID_PRINTDOCDIRECT auflaueft; bisher bekannte, |
| // einzige Abhilfe ist in diesem Fall das Abschalten der Optimierungen |
| // (KA 17.12.95) |
| #ifdef _MSC_VER |
| #pragma optimize ( "", off ) |
| #endif |
| |
| void SfxViewShell::ExecPrint( const uno::Sequence < beans::PropertyValue >& rProps, sal_Bool bIsAPI, sal_Bool bIsDirect ) |
| { |
| // get the current selection; our controller should know it |
| Reference< frame::XController > xController( GetController() ); |
| Reference< view::XSelectionSupplier > xSupplier( xController, UNO_QUERY ); |
| |
| Any aSelection; |
| if( xSupplier.is() ) |
| aSelection = xSupplier->getSelection(); |
| else |
| aSelection <<= GetObjectShell()->GetModel(); |
| Any aComplete( makeAny( GetObjectShell()->GetModel() ) ); |
| Any aViewProp( makeAny( xController ) ); |
| boost::shared_ptr<Printer> aPrt; |
| |
| const beans::PropertyValue* pVal = rProps.getConstArray(); |
| for( sal_Int32 i = 0; i < rProps.getLength(); i++ ) |
| { |
| if( pVal[i].Name.equalsAscii( "PrinterName" ) ) |
| { |
| rtl::OUString aPrinterName; |
| pVal[i].Value >>= aPrinterName; |
| aPrt.reset( new Printer( aPrinterName ) ); |
| break; |
| } |
| } |
| |
| boost::shared_ptr<vcl::PrinterController> pController( new SfxPrinterController( |
| aPrt, |
| aComplete, |
| aSelection, |
| aViewProp, |
| GetRenderable(), |
| bIsAPI, |
| bIsDirect, |
| this, |
| rProps |
| ) ); |
| pImp->m_pPrinterController = pController; |
| |
| SfxObjectShell *pObjShell = GetObjectShell(); |
| pController->setValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "JobName" ) ), |
| makeAny( rtl::OUString( pObjShell->GetTitle(0) ) ) ); |
| |
| // FIXME: job setup |
| SfxPrinter* pDocPrt = GetPrinter(sal_False); |
| JobSetup aJobSetup = pDocPrt ? pDocPrt->GetJobSetup() : GetJobSetup(); |
| if( bIsDirect ) |
| aJobSetup.SetValue( String( RTL_CONSTASCII_USTRINGPARAM( "IsQuickJob" ) ), |
| String( RTL_CONSTASCII_USTRINGPARAM( "true" ) ) ); |
| |
| Printer::PrintJob( pController, aJobSetup ); |
| } |
| |
| Printer* SfxViewShell::GetActivePrinter() const |
| { |
| return (pImp->m_pPrinterController) |
| ? pImp->m_pPrinterController->getPrinter().get() : 0; |
| } |
| |
| void SfxViewShell::ExecPrint_Impl( SfxRequest &rReq ) |
| { |
| // sal_uInt16 nCopies=1; |
| sal_uInt16 nDialogRet = RET_CANCEL; |
| // sal_Bool bCollate=sal_False; |
| SfxPrinter* pPrinter = 0; |
| SfxDialogExecutor_Impl* pExecutor = 0; |
| bool bSilent = false; |
| sal_Bool bIsAPI = rReq.GetArgs() && rReq.GetArgs()->Count(); |
| if ( bIsAPI ) |
| { |
| SFX_REQUEST_ARG(rReq, pSilentItem, SfxBoolItem, SID_SILENT, sal_False); |
| bSilent = pSilentItem && pSilentItem->GetValue(); |
| } |
| |
| //FIXME: how to transport "bPrintOnHelp"? |
| |
| // no help button in dialogs if called from the help window |
| // (pressing help button would exchange the current page inside the help document that is going to be printed!) |
| String aHelpFilterName( DEFINE_CONST_UNICODE("writer_web_HTML_help") ); |
| SfxMedium* pMedium = GetViewFrame()->GetObjectShell()->GetMedium(); |
| const SfxFilter* pFilter = pMedium ? pMedium->GetFilter() : NULL; |
| sal_Bool bPrintOnHelp = ( pFilter && pFilter->GetFilterName() == aHelpFilterName ); |
| |
| const sal_uInt16 nId = rReq.GetSlot(); |
| switch( nId ) |
| { |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| case SID_PRINTDOC: |
| case SID_PRINTDOCDIRECT: |
| { |
| SfxObjectShell* pDoc = GetObjectShell(); |
| |
| // derived class may decide to abort this |
| if( !pDoc->QuerySlotExecutable( nId ) ) |
| { |
| rReq.SetReturnValue( SfxBoolItem( 0, sal_False ) ); |
| return; |
| } |
| |
| bool bDetectHidden = ( !bSilent && pDoc ); |
| if ( bDetectHidden && pDoc->QueryHiddenInformation( WhenPrinting, NULL ) != RET_YES ) |
| break; |
| |
| SFX_REQUEST_ARG(rReq, pSelectItem, SfxBoolItem, SID_SELECTION, sal_False); |
| sal_Bool bSelection = pSelectItem && pSelectItem->GetValue(); |
| if( pSelectItem && rReq.GetArgs()->Count() == 1 ) |
| bIsAPI = sal_False; |
| |
| uno::Sequence < beans::PropertyValue > aProps; |
| if ( bIsAPI ) |
| { |
| // supported properties: |
| // String PrinterName |
| // String FileName |
| // Int16 From |
| // Int16 To |
| // In16 Copies |
| // String RangeText |
| // bool Selection |
| // bool Asynchron |
| // bool Collate |
| // bool Silent |
| TransformItems( nId, *rReq.GetArgs(), aProps, GetInterface()->GetSlot(nId) ); |
| for ( sal_Int32 nProp=0; nProp<aProps.getLength(); nProp++ ) |
| { |
| if ( aProps[nProp].Name.equalsAscii("Copies") ) |
| aProps[nProp]. Name = rtl::OUString::createFromAscii("CopyCount"); |
| else if ( aProps[nProp].Name.equalsAscii("RangeText") ) |
| aProps[nProp]. Name = rtl::OUString::createFromAscii("Pages"); |
| if ( aProps[nProp].Name.equalsAscii("Asynchron") ) |
| { |
| aProps[nProp]. Name = rtl::OUString::createFromAscii("Wait"); |
| sal_Bool bAsynchron = sal_False; |
| aProps[nProp].Value >>= bAsynchron; |
| aProps[nProp].Value <<= (sal_Bool) (!bAsynchron); |
| } |
| if ( aProps[nProp].Name.equalsAscii("Silent") ) |
| { |
| aProps[nProp]. Name = rtl::OUString::createFromAscii("MonitorVisible"); |
| sal_Bool bPrintSilent = sal_False; |
| aProps[nProp].Value >>= bPrintSilent; |
| aProps[nProp].Value <<= (sal_Bool) (!bPrintSilent); |
| } |
| } |
| } |
| // HACK: writer sets the SID_SELECTION item when printing directly and expects |
| // to get only the selection document in that case (see getSelectionObject) |
| // however it also reacts to the PrintContent property. We need this distinction here, too, |
| // else one of the combinations print / print direct and selection / all will not work. |
| // it would be better if writer handled this internally |
| if( nId == SID_PRINTDOCDIRECT ) |
| { |
| sal_Int32 nLen = aProps.getLength(); |
| aProps.realloc( nLen + 1 ); |
| aProps[nLen].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintSelectionOnly" ) ); |
| aProps[nLen].Value = makeAny( bSelection ); |
| } |
| |
| ExecPrint( aProps, bIsAPI, (nId == SID_PRINTDOCDIRECT) ); |
| |
| // FIXME: Recording |
| rReq.Done(); |
| break; |
| } |
| |
| case SID_SETUPPRINTER : |
| case SID_PRINTER_NAME : // only for recorded macros |
| { |
| // get printer and printer settings from the document |
| SfxPrinter *pDocPrinter = GetPrinter(sal_True); |
| |
| // look for printer in parameters |
| SFX_REQUEST_ARG( rReq, pPrinterItem, SfxStringItem, SID_PRINTER_NAME, sal_False ); |
| if ( pPrinterItem ) |
| { |
| // use PrinterName parameter to create a printer |
| pPrinter = new SfxPrinter( pDocPrinter->GetOptions().Clone(), ((const SfxStringItem*) pPrinterItem)->GetValue() ); |
| |
| // if printer is unknown, it can't be used - now printer from document will be used |
| if ( !pPrinter->IsOriginal() ) |
| DELETEZ(pPrinter); |
| } |
| |
| if ( SID_PRINTER_NAME == nId ) |
| { |
| // just set a recorded printer name |
| if ( pPrinter ) |
| SetPrinter( pPrinter, SFX_PRINTER_PRINTER ); |
| break; |
| } |
| |
| // no PrinterName parameter in ItemSet or the PrinterName points to an unknown printer |
| if ( !pPrinter ) |
| // use default printer from document |
| pPrinter = pDocPrinter; |
| |
| if( !pPrinter || !pPrinter->IsValid() ) |
| { |
| // no valid printer either in ItemSet or at the document |
| if ( bSilent ) |
| { |
| rReq.SetReturnValue(SfxBoolItem(0,sal_False)); |
| break; |
| } |
| else |
| ErrorBox( NULL, WB_OK | WB_DEF_OK, String( SfxResId( STR_NODEFPRINTER ) ) ).Execute(); |
| } |
| |
| if ( !pPrinter->IsOriginal() && rReq.GetArgs() && !UseStandardPrinter_Impl( NULL, pPrinter ) ) |
| { |
| // printer is not available, but standard printer should not be used |
| rReq.SetReturnValue(SfxBoolItem(0,sal_False)); |
| break; |
| } |
| |
| // FIXME: printer isn't used for printing anymore! |
| if( pPrinter->IsPrinting() ) |
| { |
| // if printer is busy, abort printing |
| if ( !bSilent ) |
| InfoBox( NULL, String( SfxResId( STR_ERROR_PRINTER_BUSY ) ) ).Execute(); |
| rReq.SetReturnValue(SfxBoolItem(0,sal_False)); |
| break; |
| } |
| |
| // if no arguments are given, retrieve them from a dialog |
| if ( !bIsAPI ) |
| { |
| // PrinterDialog needs a temporary printer |
| SfxPrinter* pDlgPrinter = pPrinter->Clone(); |
| nDialogRet = 0; |
| |
| // execute PrinterSetupDialog |
| PrinterSetupDialog* pPrintSetupDlg = new PrinterSetupDialog( GetWindow() ); |
| |
| if (pImp->m_bHasPrintOptions) |
| { |
| // additional controls for dialog |
| pExecutor = new SfxDialogExecutor_Impl( this, pPrintSetupDlg ); |
| if ( bPrintOnHelp ) |
| pExecutor->DisableHelp(); |
| pPrintSetupDlg->SetOptionsHdl( pExecutor->GetLink() ); |
| } |
| |
| pPrintSetupDlg->SetPrinter( pDlgPrinter ); |
| nDialogRet = pPrintSetupDlg->Execute(); |
| |
| if ( pExecutor && pExecutor->GetOptions() ) |
| { |
| if ( nDialogRet == RET_OK ) |
| // remark: have to be recorded if possible! |
| pDlgPrinter->SetOptions( *pExecutor->GetOptions() ); |
| else |
| { |
| pPrinter->SetOptions( *pExecutor->GetOptions() ); |
| SetPrinter( pPrinter, SFX_PRINTER_OPTIONS ); |
| } |
| } |
| |
| DELETEZ( pPrintSetupDlg ); |
| |
| // no recording of PrinterSetup except printer name (is printer dependent) |
| rReq.Ignore(); |
| |
| if ( nDialogRet == RET_OK ) |
| { |
| if ( pPrinter->GetName() != pDlgPrinter->GetName() ) |
| { |
| // user has changed the printer -> macro recording |
| SfxRequest aReq( GetViewFrame(), SID_PRINTER_NAME ); |
| aReq.AppendItem( SfxStringItem( SID_PRINTER_NAME, pDlgPrinter->GetName() ) ); |
| aReq.Done(); |
| } |
| |
| // take the changes made in the dialog |
| pPrinter = SetPrinter_Impl( pDlgPrinter ); |
| |
| // forget new printer, it was taken over (as pPrinter) or deleted |
| pDlgPrinter = NULL; |
| |
| } |
| else |
| { |
| // PrinterDialog is used to transfer information on printing, |
| // so it will only be deleted here if dialog was cancelled |
| DELETEZ( pDlgPrinter ); |
| rReq.Ignore(); |
| if ( SID_PRINTDOC == nId ) |
| rReq.SetReturnValue(SfxBoolItem(0,sal_False)); |
| } |
| } |
| } |
| |
| break; |
| } |
| } |
| |
| // Optimierungen wieder einschalten |
| #ifdef _MSC_VER |
| #pragma optimize ( "", on ) |
| #endif |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Bool SfxViewShell::IsPrinterLocked() const |
| { |
| return pImp->m_nPrinterLocks > 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| void SfxViewShell::LockPrinter( sal_Bool bLock) |
| { |
| sal_Bool bChanged = sal_False; |
| if ( bLock ) |
| { |
| bChanged = 1 == ++pImp->m_nPrinterLocks; |
| } |
| else |
| { |
| bChanged = 0 == --pImp->m_nPrinterLocks; |
| } |
| |
| if ( bChanged ) |
| { |
| Invalidate( SID_PRINTDOC ); |
| Invalidate( SID_PRINTDOCDIRECT ); |
| Invalidate( SID_SETUPPRINTER ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| SfxPrinter* SfxViewShell::GetPrinter( sal_Bool /*bCreate*/ ) |
| { |
| return 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_uInt16 SfxViewShell::SetPrinter( SfxPrinter* /*pNewPrinter*/, sal_uInt16 /*nDiffFlags*/, bool ) |
| { |
| return 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| SfxTabPage* SfxViewShell::CreatePrintOptionsPage |
| ( |
| Window* /*pParent*/, |
| const SfxItemSet& /*rOptions*/ |
| ) |
| { |
| return 0; |
| } |
| |
| JobSetup SfxViewShell::GetJobSetup() const |
| { |
| return JobSetup(); |
| } |
| |
