sfx2/source/view/viewprn.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/document/XDocumentProperties.hpp>
  21 #include <com/sun/star/view/XRenderable.hpp>
  22
  23 #include <svl/itempool.hxx>
  24 #include <vcl/layout.hxx>
  25 #include <svtools/prnsetup.hxx>
  26 #include <svl/flagitem.hxx>
  27 #include <svl/stritem.hxx>
  28 #include <svl/intitem.hxx>
  29 #include <svl/eitem.hxx>
  30 #include <sfx2/app.hxx>
  31 #include <unotools/useroptions.hxx>
  32 #include <unotools/printwarningoptions.hxx>
  33 #include <tools/datetime.hxx>
  34 #include <sfx2/bindings.hxx>
  35 #include <sfx2/objface.hxx>
  36 #include <sfx2/viewsh.hxx>
  37 #include "viewimp.hxx"
  38 #include <sfx2/viewfrm.hxx>
  39 #include <sfx2/prnmon.hxx>
  40 #include <sfx2/sfxresid.hxx>
  41 #include <sfx2/request.hxx>
  42 #include <sfx2/objsh.hxx>
  43 #include "sfxtypes.hxx"
  44 #include <sfx2/event.hxx>
  45 #include <sfx2/docfile.hxx>
  46 #include <sfx2/docfilt.hxx>
  47
  48 #include <toolkit/awt/vclxdevice.hxx>
  49 #include <boost/scoped_ptr.hpp>
  50
  51 #include "view.hrc"
  52 #include "helpid.hrc"
  53
  54 using namespace com::sun::star;
  55 using namespace com::sun::star::uno;
  56
  57 class SfxPrinterController : public vcl::PrinterController, public SfxListener
  58 {
  59     Any                                     maCompleteSelection;
  60     Any                                     maSelection;
  61     Reference< view::XRenderable >          mxRenderable;
  62     mutable VclPtr<Printer>                 mpLastPrinter;
  63     mutable Reference<awt::XDevice>         mxDevice;
  64     SfxViewShell*                           mpViewShell;
  65     SfxObjectShell*                         mpObjectShell;
  66     bool        m_bOrigStatus;
  67     bool        m_bNeedsChange;
  68     bool        m_bApi;
  69     bool        m_bTempPrinter;
  70     util::DateTime  m_aLastPrinted;
  71     OUString m_aLastPrintedBy;
  72
  73     Sequence< beans::PropertyValue > getMergedOptions() const;
  74     const Any& getSelectionObject() const;
  75
  76 public:
  77     SfxPrinterController( const VclPtr<Printer>& i_rPrinter,
  78                           const Any& i_rComplete,
  79                           const Any& i_rSelection,
  80                           const Any& i_rViewProp,
  81                           const Reference< view::XRenderable >& i_xRender,
  82                           bool i_bApi, bool i_bDirect,
  83                           SfxViewShell* pView,
  84                           const uno::Sequence< beans::PropertyValue >& rProps
  85                         );
  86
  87     virtual ~SfxPrinterController();
  88     virtual void Notify( SfxBroadcaster&, const SfxHint& ) SAL_OVERRIDE;
  89
  90     virtual int  getPageCount() const SAL_OVERRIDE;
  91     virtual Sequence< beans::PropertyValue > getPageParameters( int i_nPage ) const SAL_OVERRIDE;
  92     virtual void printPage( int i_nPage ) const SAL_OVERRIDE;
  93     virtual void jobStarted() SAL_OVERRIDE;
  94     virtual void jobFinished( com::sun::star::view::PrintableState ) SAL_OVERRIDE;
  95 };
  96
  97 SfxPrinterController::SfxPrinterController( const VclPtr<Printer>& i_rPrinter,
  98                                             const Any& i_rComplete,
  99                                             const Any& i_rSelection,
 100                                             const Any& i_rViewProp,
 101                                             const Reference< view::XRenderable >& i_xRender,
 102                                             bool i_bApi, bool i_bDirect,
 103                                             SfxViewShell* pView,
 104                                             const uno::Sequence< beans::PropertyValue >& rProps
 105                                           )
 106     : PrinterController( i_rPrinter)
 107     , maCompleteSelection( i_rComplete )
 108     , maSelection( i_rSelection )
 109     , mxRenderable( i_xRender )
 110     , mpLastPrinter( NULL )
 111     , mpViewShell( pView )
 112     , mpObjectShell(0)
 113     , m_bOrigStatus( false )
 114     , m_bNeedsChange( false )
 115     , m_bApi(i_bApi)
 116     , m_bTempPrinter( i_rPrinter.get() != NULL )
 117 {
 118     if ( mpViewShell )
 119     {
 120         StartListening( *mpViewShell );
 121         mpObjectShell = mpViewShell->GetObjectShell();
 122         StartListening( *mpObjectShell );
 123     }
 124
 125     // initialize extra ui options
 126     if( mxRenderable.is() )
 127     {
 128         for (sal_Int32 nProp=0; nProp < rProps.getLength(); ++nProp)
 129             setValue( rProps[nProp].Name, rProps[nProp].Value );
 130
 131         Sequence< beans::PropertyValue > aRenderOptions( 3 );
 132         aRenderOptions[0].Name = "ExtraPrintUIOptions";
 133         aRenderOptions[1].Name = "View" ;
 134         aRenderOptions[1].Value = i_rViewProp;
 135         aRenderOptions[2].Name = "IsPrinter";
 136         aRenderOptions[2].Value <<= sal_True;
 137         try
 138         {
 139             Sequence< beans::PropertyValue > aRenderParms( mxRenderable->getRenderer( 0 , getSelectionObject(), aRenderOptions ) );
 140             int nProps = aRenderParms.getLength();
 141             for( int i = 0; i < nProps; i++ )
 142             {
 143                 if ( aRenderParms[i].Name == "ExtraPrintUIOptions" )
 144                 {
 145                     Sequence< beans::PropertyValue > aUIProps;
 146                     aRenderParms[i].Value >>= aUIProps;
 147                     setUIOptions( aUIProps );
 148                 }
 149                 else if( aRenderParms[i].Name == "NUp" )
 150                 {
 151                     setValue( aRenderParms[i].Name, aRenderParms[i].Value );
 152                 }
 153             }
 154         }
 155         catch( lang::IllegalArgumentException& )
 156         {
 157             // the first renderer should always be available for the UI options,
 158             // but catch the exception to be safe
 159         }
 160     }
 161
 162     // set some job parameters
 163     setValue( OUString( "IsApi"  ), makeAny( i_bApi ) );
 164     setValue( OUString( "IsDirect"  ), makeAny( i_bDirect ) );
 165     setValue( OUString( "IsPrinter"  ), makeAny( sal_True ) );
 166     setValue( OUString( "View"  ), i_rViewProp );
 167 }
 168
 169 void SfxPrinterController::Notify( SfxBroadcaster& , const SfxHint& rHint )
 170 {
 171     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
 172     if ( pSimpleHint )
 173     {
 174         if ( pSimpleHint->GetId() == SFX_HINT_DYING )
 175         {
 176             EndListening(*mpViewShell);
 177             EndListening(*mpObjectShell);
 178             mpViewShell = 0;
 179             mpObjectShell = 0;
 180         }
 181     }
 182 }
 183
 184 SfxPrinterController::~SfxPrinterController()
 185 {
 186 }
 187
 188 const Any& SfxPrinterController::getSelectionObject() const
 189 {
 190     const beans::PropertyValue* pVal = getValue( OUString( "PrintSelectionOnly"  ) );
 191     if( pVal )
 192     {
 193         bool bSel = false;
 194         pVal->Value >>= bSel;
 195         return bSel ? maSelection : maCompleteSelection;
 196     }
 197
 198     sal_Int32 nChoice = 0;
 199     pVal = getValue( OUString( "PrintContent"  ) );
 200     if( pVal )
 201         pVal->Value >>= nChoice;
 202     return (nChoice > 1) ? maSelection : maCompleteSelection;
 203 }
 204
 205 Sequence< beans::PropertyValue > SfxPrinterController::getMergedOptions() const
 206 {
 207     VclPtr<Printer> xPrinter( getPrinter() );
 208     if( xPrinter.get() != mpLastPrinter )
 209     {
 210         mpLastPrinter = xPrinter.get();
 211         VCLXDevice* pXDevice = new VCLXDevice();
 212         pXDevice->SetOutputDevice( mpLastPrinter );
 213         mxDevice = Reference< awt::XDevice >( pXDevice );
 214     }
 215
 216     Sequence< beans::PropertyValue > aRenderOptions( 1 );
 217     aRenderOptions[ 0 ].Name = "RenderDevice";
 218     aRenderOptions[ 0 ].Value <<= mxDevice;
 219
 220     aRenderOptions = getJobProperties( aRenderOptions );
 221     return aRenderOptions;
 222 }
 223
 224 int SfxPrinterController::getPageCount() const
 225 {
 226     int nPages = 0;
 227     VclPtr<Printer> xPrinter( getPrinter() );
 228     if( mxRenderable.is() && xPrinter )
 229     {
 230         Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() );
 231         try
 232         {
 233             nPages = mxRenderable->getRendererCount( getSelectionObject(), aJobOptions );
 234         }
 235         catch (lang::DisposedException &)
 236         {
 237             OSL_TRACE("SfxPrinterController: document disposed while printing");
 238             const_cast<SfxPrinterController*>(this)->setJobState(
 239                     view::PrintableState_JOB_ABORTED);
 240         }
 241     }
 242     return nPages;
 243 }
 244
 245 Sequence< beans::PropertyValue > SfxPrinterController::getPageParameters( int i_nPage ) const
 246 {
 247     VclPtr<Printer> xPrinter( getPrinter() );
 248     Sequence< beans::PropertyValue > aResult;
 249
 250     if (mxRenderable.is() && xPrinter)
 251     {
 252         Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() );
 253         try
 254         {
 255             aResult = mxRenderable->getRenderer( i_nPage, getSelectionObject(), aJobOptions );
 256         }
 257         catch( lang::IllegalArgumentException& )
 258         {
 259         }
 260         catch (lang::DisposedException &)
 261         {
 262             OSL_TRACE("SfxPrinterController: document disposed while printing");
 263             const_cast<SfxPrinterController*>(this)->setJobState(
 264                     view::PrintableState_JOB_ABORTED);
 265         }
 266     }
 267     return aResult;
 268 }
 269
 270 void SfxPrinterController::printPage( int i_nPage ) const
 271 {
 272     VclPtr<Printer> xPrinter( getPrinter() );
 273     if( mxRenderable.is() && xPrinter )
 274     {
 275         Sequence< beans::PropertyValue > aJobOptions( getMergedOptions() );
 276         try
 277         {
 278             mxRenderable->render( i_nPage, getSelectionObject(), aJobOptions );
 279         }
 280         catch( lang::IllegalArgumentException& )
 281         {
 282             // don't care enough about nonexistant page here
 283             // to provoke a crash
 284         }
 285         catch (lang::DisposedException &)
 286         {
 287             OSL_TRACE("SfxPrinterController: document disposed while printing");
 288             const_cast<SfxPrinterController*>(this)->setJobState(
 289                     view::PrintableState_JOB_ABORTED);
 290         }
 291     }
 292 }
 293
 294 void SfxPrinterController::jobStarted()
 295 {
 296     if ( mpObjectShell )
 297     {
 298         m_bOrigStatus = mpObjectShell->IsEnableSetModified();
 299
 300         // check configuration: shall update of printing information in DocInfo set the document to "modified"?
 301         if ( m_bOrigStatus && !SvtPrintWarningOptions().IsModifyDocumentOnPrintingAllowed() )
 302         {
 303             mpObjectShell->EnableSetModified( false );
 304             m_bNeedsChange = true;
 305         }
 306
 307         // refresh document info
 308         uno::Reference<document::XDocumentProperties> xDocProps(mpObjectShell->getDocProperties());
 309         m_aLastPrintedBy = xDocProps->getPrintedBy();
 310         m_aLastPrinted = xDocProps->getPrintDate();
 311
 312         xDocProps->setPrintedBy( mpObjectShell->IsUseUserData()
 313             ? OUString( SvtUserOptions().GetFullName() )
 314             : OUString() );
 315         ::DateTime now( ::DateTime::SYSTEM );
 316
 317         xDocProps->setPrintDate( now.GetUNODateTime() );
 318
 319         SfxGetpApp()->NotifyEvent( SfxEventHint(SFX_EVENT_PRINTDOC, GlobalEventConfig::GetEventName( GlobalEventId::PRINTDOC ), mpObjectShell ) );
 320         uno::Sequence < beans::PropertyValue > aOpts;
 321         aOpts = getJobProperties( aOpts );
 322
 323         uno::Reference< frame::XController2 > xController;
 324         if ( mpViewShell )
 325             xController.set( mpViewShell->GetController(), uno::UNO_QUERY );
 326
 327         mpObjectShell->Broadcast( SfxPrintingHint(
 328             view::PrintableState_JOB_STARTED, aOpts, mpObjectShell, xController ) );
 329     }
 330 }
 331
 332 void SfxPrinterController::jobFinished( com::sun::star::view::PrintableState nState )
 333 {
 334     if ( mpObjectShell )
 335     {
 336         bool bCopyJobSetup = false;
 337         mpObjectShell->Broadcast( SfxPrintingHint( nState ) );
 338         switch ( nState )
 339         {
 340             case view::PrintableState_JOB_SPOOLING_FAILED :
 341             case view::PrintableState_JOB_FAILED :
 342             {
 343                 // "real" problem (not simply printing cancelled by user)
 344                 OUString aMsg( SfxResId(STR_NOSTARTPRINTER).toString() );
 345                 if ( !m_bApi )
 346                     ScopedVclPtrInstance<MessageDialog>::Create(mpViewShell->GetWindow(), aMsg)->Execute();
 347                 // intentionally no break
 348             }
 349             case view::PrintableState_JOB_ABORTED :
 350             {
 351                 // printing not successful, reset DocInfo
 352                 uno::Reference<document::XDocumentProperties> xDocProps(mpObjectShell->getDocProperties());
 353                 xDocProps->setPrintedBy(m_aLastPrintedBy);
 354                 xDocProps->setPrintDate(m_aLastPrinted);
 355                 break;
 356             }
 357
 358             case view::PrintableState_JOB_SPOOLED :
 359             case view::PrintableState_JOB_COMPLETED :
 360             {
 361                 SfxBindings& rBind = mpViewShell->GetViewFrame()->GetBindings();
 362                 rBind.Invalidate( SID_PRINTDOC );
 363                 rBind.Invalidate( SID_PRINTDOCDIRECT );
 364                 rBind.Invalidate( SID_SETUPPRINTER );
 365                 bCopyJobSetup = ! m_bTempPrinter;
 366                 break;
 367             }
 368
 369             default:
 370                 break;
 371         }
 372
 373         if( bCopyJobSetup && mpViewShell )
 374         {
 375             // #i114306#
 376             // Note: this possibly creates a printer that gets immediately replaced
 377             // by a new one. The reason for this is that otherwise we would not get
 378             // the printer's SfxItemSet here to copy. Awkward, but at the moment there is no
 379             // other way here to get the item set.
 380             SfxPrinter* pDocPrt = mpViewShell->GetPrinter(true);
 381             if( pDocPrt )
 382             {
 383                 if( pDocPrt->GetName() == getPrinter()->GetName() )
 384                     pDocPrt->SetJobSetup( getPrinter()->GetJobSetup() );
 385                 else
 386                 {
 387                     VclPtr<SfxPrinter> pNewPrt = VclPtr<SfxPrinter>::Create( pDocPrt->GetOptions().Clone(), getPrinter()->GetName() );
 388                     pNewPrt->SetJobSetup( getPrinter()->GetJobSetup() );
 389                     mpViewShell->SetPrinter( pNewPrt, SfxPrinterChangeFlags::PRINTER | SfxPrinterChangeFlags::JOBSETUP );
 390                 }
 391             }
 392         }
 393
 394         if ( m_bNeedsChange )
 395             mpObjectShell->EnableSetModified( m_bOrigStatus );
 396
 397         if ( mpViewShell )
 398         {
 399             mpViewShell->pImp->m_xPrinterController.reset();
 400         }
 401     }
 402 }
 403
 404 /**
 405     An instance of this class is created for the life span of the
 406     printer dialogue, to create in its click handler for the additions by the
 407     virtual method of the derived SfxViewShell generated print options dialogue
 408     and to cache the options set there as SfxItemSet.
 409 */
 410 class SfxDialogExecutor_Impl
 411 {
 412 private:
 413     SfxViewShell*           _pViewSh;
 414     VclPtr<PrinterSetupDialog>  _pSetupParent;
 415     SfxItemSet*             _pOptions;
 416     bool                    _bHelpDisabled;
 417
 418     DECL_LINK( Execute, void * );
 419
 420 public:
 421             SfxDialogExecutor_Impl( SfxViewShell* pViewSh, PrinterSetupDialog* pParent );
 422             ~SfxDialogExecutor_Impl() { delete _pOptions; }
 423
 424     Link<>              GetLink() const { return LINK(const_cast<SfxDialogExecutor_Impl*>(this), SfxDialogExecutor_Impl, Execute); }
 425     const SfxItemSet*   GetOptions() const { return _pOptions; }
 426     void                DisableHelp() { _bHelpDisabled = true; }
 427 };
 428
 429 SfxDialogExecutor_Impl::SfxDialogExecutor_Impl( SfxViewShell* pViewSh, PrinterSetupDialog* pParent ) :
 430
 431     _pViewSh        ( pViewSh ),
 432     _pSetupParent   ( pParent ),
 433     _pOptions       ( NULL ),
 434     _bHelpDisabled  ( false )
 435
 436 {
 437 }
 438
 439 IMPL_LINK_NOARG(SfxDialogExecutor_Impl, Execute)
 440 {
 441     // Options noted locally
 442     if ( !_pOptions )
 443     {
 444         DBG_ASSERT( _pSetupParent, "no dialog parent" );
 445         if( _pSetupParent )
 446             _pOptions = static_cast<SfxPrinter*>( _pSetupParent->GetPrinter() )->GetOptions().Clone();
 447     }
 448
 449     assert(_pOptions);
 450     if (!_pOptions)
 451         return 0;
 452
 453     // Create Dialog
 454     VclPtrInstance<SfxPrintOptionsDialog> pDlg( static_cast<vcl::Window*>(_pSetupParent),
 455                                                 _pViewSh, _pOptions );
 456     if ( _bHelpDisabled )
 457         pDlg->DisableHelp();
 458     if ( pDlg->Execute() == RET_OK )
 459     {
 460         delete _pOptions;
 461         _pOptions = pDlg->GetOptions().Clone();
 462
 463     }
 464
 465     return 0;
 466 }
 467
 468 /**
 469    Internal method for setting the differences between 'pNewPrinter' to the
 470    current printer. pNewPrinter is either taken over or deleted.
 471 */
 472 SfxPrinter* SfxViewShell::SetPrinter_Impl( VclPtr<SfxPrinter>& pNewPrinter )
 473 {
 474     // get current Printer
 475     SfxPrinter *pDocPrinter = GetPrinter();
 476
 477     // Evaluate Printer Options
 478     sal_uInt16 nWhich = GetPool().GetWhich(SID_PRINTER_CHANGESTODOC);
 479     const SfxFlagItem *pFlagItem = 0;
 480     pDocPrinter->GetOptions().GetItemState( nWhich, false, reinterpret_cast<const SfxPoolItem**>(&pFlagItem) );
 481     bool bOriToDoc = pFlagItem && (static_cast<SfxPrinterChangeFlags>(pFlagItem->GetValue()) & SfxPrinterChangeFlags::CHG_ORIENTATION);
 482     bool bSizeToDoc = pFlagItem && (static_cast<SfxPrinterChangeFlags>(pFlagItem->GetValue()) & SfxPrinterChangeFlags::CHG_SIZE);
 483
 484     // Determine the previous format and size
 485     Orientation eOldOri = pDocPrinter->GetOrientation();
 486     Size aOldPgSz = pDocPrinter->GetPaperSizePixel();
 487
 488     // Determine the new format and size
 489     Orientation eNewOri = pNewPrinter->GetOrientation();
 490     Size aNewPgSz = pNewPrinter->GetPaperSizePixel();
 491
 492     // Determine the changes in page format
 493     bool bOriChg = (eOldOri != eNewOri) && bOriToDoc;
 494     bool bPgSzChg = ( aOldPgSz.Height() !=
 495             ( bOriChg ? aNewPgSz.Width() : aNewPgSz.Height() ) ||
 496             aOldPgSz.Width() !=
 497             ( bOriChg ? aNewPgSz.Height() : aNewPgSz.Width() ) ) &&
 498             bSizeToDoc;
 499
 500     // Message and Flags for page format, summaries changes
 501     OUString aMsg;
 502     SfxPrinterChangeFlags nNewOpt = SfxPrinterChangeFlags::NONE;
 503     if( bOriChg && bPgSzChg )
 504     {
 505         aMsg = SfxResId(STR_PRINT_NEWORISIZE).toString();
 506         nNewOpt = SfxPrinterChangeFlags::CHG_ORIENTATION | SfxPrinterChangeFlags::CHG_SIZE;
 507     }
 508     else if (bOriChg )
 509     {
 510         aMsg = SfxResId(STR_PRINT_NEWORI).toString();
 511         nNewOpt = SfxPrinterChangeFlags::CHG_ORIENTATION;
 512     }
 513     else if (bPgSzChg)
 514     {
 515         aMsg = SfxResId(STR_PRINT_NEWSIZE).toString();
 516         nNewOpt = SfxPrinterChangeFlags::CHG_SIZE;
 517     }
 518
 519     // Summaries in this variable what has been changed.
 520     SfxPrinterChangeFlags nChangedFlags = SfxPrinterChangeFlags::NONE;
 521
 522     // Ask if possible, if page format should be taken over from printer.
 523     if ( ( bOriChg  || bPgSzChg ) &&
 524         RET_YES == ScopedVclPtrInstance<MessageDialog>::Create(nullptr, aMsg, VCL_MESSAGE_QUESTION, VCL_BUTTONS_YES_NO)->Execute() )
 525     {
 526         // Flags with changes for  <SetPrinter(SfxPrinter*)> are maintained
 527         nChangedFlags |= nNewOpt;
 528     }
 529
 530     // For the MAC to have its "temporary of class String" in next if()
 531     OUString aTempPrtName = pNewPrinter->GetName();
 532     OUString aDocPrtName = pDocPrinter->GetName();
 533
 534     // Was the printer selection changed from Default to Specific
 535     // or the other way around?
 536     if ( (aTempPrtName != aDocPrtName) || (pDocPrinter->IsDefPrinter() != pNewPrinter->IsDefPrinter()) )
 537     {
 538         nChangedFlags |= SfxPrinterChangeFlags::PRINTER|SfxPrinterChangeFlags::JOBSETUP;
 539         pDocPrinter = pNewPrinter;
 540     }
 541     else
 542     {
 543         // Compare extra options
 544         if ( ! (pNewPrinter->GetOptions() == pDocPrinter->GetOptions()) )
 545         {
 546             // Option have changed
 547             pDocPrinter->SetOptions( pNewPrinter->GetOptions() );
 548             nChangedFlags |= SfxPrinterChangeFlags::OPTIONS;
 549         }
 550
 551         // Compare JobSetups
 552         JobSetup aNewJobSetup = pNewPrinter->GetJobSetup();
 553         JobSetup aOldJobSetup = pDocPrinter->GetJobSetup();
 554         if ( aNewJobSetup != aOldJobSetup )
 555         {
 556             nChangedFlags |= SfxPrinterChangeFlags::JOBSETUP;
 557         }
 558
 559         // Keep old changed Printer.
 560         pDocPrinter->SetPrinterProps( pNewPrinter );
 561         pNewPrinter.disposeAndClear();
 562     }
 563
 564     if ( SfxPrinterChangeFlags::NONE != nChangedFlags )
 565         // SetPrinter will delete the old printer if it changes
 566         SetPrinter( pDocPrinter, nChangedFlags );
 567     return pDocPrinter;
 568 }
 569
 570 void SfxViewShell::StartPrint( const uno::Sequence < beans::PropertyValue >& rProps, bool bIsAPI, bool bIsDirect )
 571 {
 572     assert( pImp->m_xPrinterController.get() == NULL );
 573
 574     // get the current selection; our controller should know it
 575     Reference< frame::XController > xController( GetController() );
 576     Reference< view::XSelectionSupplier > xSupplier( xController, UNO_QUERY );
 577
 578     Any aSelection;
 579     if( xSupplier.is() )
 580         aSelection = xSupplier->getSelection();
 581     else
 582         aSelection <<= GetObjectShell()->GetModel();
 583     Any aComplete( makeAny( GetObjectShell()->GetModel() ) );
 584     Any aViewProp( makeAny( xController ) );
 585     VclPtr<Printer> aPrt;
 586
 587     const beans::PropertyValue* pVal = rProps.getConstArray();
 588     for( sal_Int32 i = 0; i < rProps.getLength(); i++ )
 589     {
 590         if ( pVal[i].Name == "PrinterName" )
 591         {
 592             OUString aPrinterName;
 593             pVal[i].Value >>= aPrinterName;
 594             aPrt.reset( VclPtr<Printer>::Create( aPrinterName ) );
 595             break;
 596         }
 597     }
 598
 599     std::shared_ptr<vcl::PrinterController> xNewController(std::make_shared<SfxPrinterController>(
 600                                                                                aPrt,
 601                                                                                aComplete,
 602                                                                                aSelection,
 603                                                                                aViewProp,
 604                                                                                GetRenderable(),
 605                                                                                bIsAPI,
 606                                                                                bIsDirect,
 607                                                                                this,
 608                                                                                rProps
 609                                                                                ));
 610     pImp->m_xPrinterController = xNewController;
 611
 612     SfxObjectShell *pObjShell = GetObjectShell();
 613     xNewController->setValue( OUString( "JobName"  ),
 614                         makeAny( OUString( pObjShell->GetTitle(0) ) ) );
 615     xNewController->setPrinterModified( mbPrinterSettingsModified );
 616 }
 617
 618 void SfxViewShell::ExecPrint( const uno::Sequence < beans::PropertyValue >& rProps, bool bIsAPI, bool bIsDirect )
 619 {
 620     StartPrint( rProps, bIsAPI, bIsDirect );
 621     // FIXME: job setup
 622     SfxPrinter* pDocPrt = GetPrinter(false);
 623     JobSetup aJobSetup = pDocPrt ? pDocPrt->GetJobSetup() : GetJobSetup();
 624     Printer::PrintJob( GetPrinterController(), aJobSetup );
 625 }
 626
 627 std::shared_ptr< vcl::PrinterController > SfxViewShell::GetPrinterController() const
 628 {
 629     return pImp->m_xPrinterController;
 630 }
 631
 632 Printer* SfxViewShell::GetActivePrinter() const
 633 {
 634     return (pImp->m_xPrinterController)
 635         ?  pImp->m_xPrinterController->getPrinter().get() : 0;
 636 }
 637
 638 void SfxViewShell::ExecPrint_Impl( SfxRequest &rReq )
 639 {
 640     sal_uInt16              nDialogRet = RET_CANCEL;
 641     VclPtr<SfxPrinter>      pPrinter;
 642     bool                    bSilent = false;
 643
 644     // does the function have been called by the user interface or by an API call
 645     bool bIsAPI = rReq.GetArgs() && rReq.GetArgs()->Count();
 646     if ( bIsAPI )
 647     {
 648         // the function have been called by the API
 649
 650         // Should it be visible on the user interface,
 651         // should it launch popup dialogue ?
 652         SFX_REQUEST_ARG(rReq, pSilentItem, SfxBoolItem, SID_SILENT, false);
 653         bSilent = pSilentItem && pSilentItem->GetValue();
 654     }
 655
 656     // no help button in dialogs if called from the help window
 657     // (pressing help button would exchange the current page inside the help
 658     // document that is going to be printed!)
 659     OUString aHelpFilterName( "writer_web_HTML_help" );
 660     SfxMedium* pMedium = GetViewFrame()->GetObjectShell()->GetMedium();
 661     const SfxFilter* pFilter = pMedium ? pMedium->GetFilter() : NULL;
 662     bool bPrintOnHelp = ( pFilter && pFilter->GetFilterName() == aHelpFilterName );
 663
 664     const sal_uInt16 nId = rReq.GetSlot();
 665     switch( nId )
 666     {
 667         case SID_PRINTDOC: // display the printer selection and properties dialogue : File > Print...
 668         case SID_PRINTDOCDIRECT: // Print the document directly, without displaying the dialogue
 669         {
 670             SfxObjectShell* pDoc = GetObjectShell();
 671
 672             // derived class may decide to abort this
 673             if( pDoc == NULL || !pDoc->QuerySlotExecutable( nId ) )
 674             {
 675                 rReq.SetReturnValue( SfxBoolItem( 0, false ) );
 676                 return;
 677             }
 678
 679             if ( !bSilent && pDoc->QueryHiddenInformation( HiddenWarningFact::WhenPrinting, NULL ) != RET_YES )
 680                 return;
 681
 682             // should we print only the selection or the whole document
 683             SFX_REQUEST_ARG(rReq, pSelectItem, SfxBoolItem, SID_SELECTION, false);
 684             bool bSelection = ( pSelectItem != NULL && pSelectItem->GetValue() );
 685             // detect non api call from writer ( that adds SID_SELECTION ) and reset bIsAPI
 686             if ( pSelectItem && rReq.GetArgs()->Count() == 1 )
 687                 bIsAPI = false;
 688
 689             uno::Sequence < beans::PropertyValue > aProps;
 690             if ( bIsAPI )
 691             {
 692                 // supported properties:
 693                 // String PrinterName
 694                 // String FileName
 695                 // Int16 From
 696                 // Int16 To
 697                 // In16 Copies
 698                 // String RangeText
 699                 // bool Selection
 700                 // bool Asynchron
 701                 // bool Collate
 702                 // bool Silent
 703
 704                 // the TransformItems function overwrite aProps
 705                 TransformItems( nId, *rReq.GetArgs(), aProps, GetInterface()->GetSlot(nId) );
 706
 707                 for ( sal_Int32 nProp=0; nProp < aProps.getLength(); ++nProp )
 708                 {
 709                     if ( aProps[nProp].Name == "Copies" )
 710                     {
 711                         aProps[nProp]. Name = "CopyCount";
 712                     }
 713                     else if ( aProps[nProp].Name == "RangeText" )
 714                     {
 715                         aProps[nProp]. Name = "Pages";
 716                     }
 717                     else if ( aProps[nProp].Name == "Asynchron" )
 718                     {
 719                         aProps[nProp]. Name = "Wait";
 720                         bool bAsynchron = false;
 721                         aProps[nProp].Value >>= bAsynchron;
 722                         aProps[nProp].Value <<= (!bAsynchron);
 723                     }
 724                     else if ( aProps[nProp].Name == "Silent" )
 725                     {
 726                         aProps[nProp]. Name = "MonitorVisible";
 727                         bool bPrintSilent = false;
 728                         aProps[nProp].Value >>= bPrintSilent;
 729                         aProps[nProp].Value <<= (!bPrintSilent);
 730                     }
 731                 }
 732             }
 733
 734             // we will add the "PrintSelectionOnly" or "HideHelpButton" properties
 735             // we have to increase the capacity of aProps
 736             sal_Int32 nLen = aProps.getLength();
 737             aProps.realloc( nLen + 1 );
 738
 739             // HACK: writer sets the SID_SELECTION item when printing directly and expects
 740             // to get only the selection document in that case (see getSelectionObject)
 741             // however it also reacts to the PrintContent property. We need this distinction here, too,
 742             // else one of the combinations print / print direct and selection / all will not work.
 743             // it would be better if writer handled this internally
 744             if( nId == SID_PRINTDOCDIRECT )
 745             {
 746                 aProps[nLen].Name = "PrintSelectionOnly";
 747                 aProps[nLen].Value = makeAny( bSelection );
 748             }
 749             else // if nId == SID_PRINTDOC ; nothing to do with the previous HACK
 750             {
 751                 // should the printer selection and properties dialogue display an help button
 752                 aProps[nLen].Name = "HideHelpButton";
 753                 aProps[nLen].Value = makeAny( bPrintOnHelp );
 754             }
 755
 756             ExecPrint( aProps, bIsAPI, (nId == SID_PRINTDOCDIRECT) );
 757
 758             // FIXME: Recording
 759             rReq.Done();
 760             break;
 761         }
 762
 763         case SID_SETUPPRINTER : // display the printer settings dialogue : File > Printer Settings...
 764         case SID_PRINTER_NAME : // only for recorded macros
 765         {
 766             // get printer and printer settings from the document
 767             SfxPrinter *pDocPrinter = GetPrinter(true);
 768
 769             // look for printer in parameters
 770             SFX_REQUEST_ARG( rReq, pPrinterItem, SfxStringItem, SID_PRINTER_NAME, false );
 771             if ( pPrinterItem )
 772             {
 773                 // use PrinterName parameter to create a printer
 774                 pPrinter = VclPtr<SfxPrinter>::Create( pDocPrinter->GetOptions().Clone(), pPrinterItem->GetValue() );
 775
 776                 // if printer is unknown, it can't be used - now printer from document will be used
 777                 if ( !pPrinter->IsKnown() )
 778                     pPrinter.disposeAndClear();
 779             }
 780
 781             if ( SID_PRINTER_NAME == nId )
 782             {
 783                 // just set a recorded printer name
 784                 if ( pPrinter )
 785                     SetPrinter( pPrinter, SfxPrinterChangeFlags::PRINTER  );
 786                 return;
 787             }
 788
 789             // no PrinterName parameter in ItemSet or the PrinterName points to an unknown printer
 790             if ( !pPrinter )
 791                 // use default printer from document
 792                 pPrinter = pDocPrinter;
 793
 794             if( !pPrinter || !pPrinter->IsValid() )
 795             {
 796                 // no valid printer either in ItemSet or at the document
 797                 if ( !bSilent )
 798                     ScopedVclPtrInstance<MessageDialog>::Create(nullptr, SfxResId(STR_NODEFPRINTER))->Execute();
 799
 800                 rReq.SetReturnValue(SfxBoolItem(0,false));
 801
 802                 break;
 803             }
 804
 805             // FIXME: printer isn't used for printing anymore!
 806             if( pPrinter->IsPrinting() )
 807             {
 808                 // if printer is busy, abort configuration
 809                 if ( !bSilent )
 810                     ScopedVclPtrInstance<MessageDialog>::Create(nullptr, SfxResId(STR_ERROR_PRINTER_BUSY), VCL_MESSAGE_INFO)->Execute();
 811                 rReq.SetReturnValue(SfxBoolItem(0,false));
 812
 813                 return;
 814             }
 815
 816             // if no arguments are given, retrieve them from a dialog
 817             if ( !bIsAPI )
 818             {
 819                 // PrinterDialog needs a temporary printer
 820                 VclPtr<SfxPrinter> pDlgPrinter = pPrinter->Clone();
 821                 nDialogRet = 0;
 822
 823                 // execute PrinterSetupDialog
 824                 VclPtrInstance<PrinterSetupDialog> pPrintSetupDlg( GetWindow() );
 825                 SfxDialogExecutor_Impl* pExecutor = 0;
 826
 827                 if (pImp->m_bHasPrintOptions && HasPrintOptionsPage())
 828                 {
 829                     // additional controls for dialog
 830                     pExecutor = new SfxDialogExecutor_Impl( this, pPrintSetupDlg );
 831                     if ( bPrintOnHelp )
 832                         pExecutor->DisableHelp();
 833                     pPrintSetupDlg->SetOptionsHdl( pExecutor->GetLink() );
 834                 }
 835
 836                 pPrintSetupDlg->SetPrinter( pDlgPrinter );
 837                 nDialogRet = pPrintSetupDlg->Execute();
 838
 839                 if ( pExecutor && pExecutor->GetOptions() )
 840                 {
 841                     if ( nDialogRet == RET_OK )
 842                         // remark: have to be recorded if possible!
 843                         pDlgPrinter->SetOptions( *pExecutor->GetOptions() );
 844                     else
 845                     {
 846                         pPrinter->SetOptions( *pExecutor->GetOptions() );
 847                         SetPrinter( pPrinter, SfxPrinterChangeFlags::OPTIONS );
 848                     }
 849                 }
 850
 851                 pPrintSetupDlg.disposeAndClear();
 852                 delete pExecutor;
 853
 854                 // no recording of PrinterSetup except printer name (is printer dependent)
 855                 rReq.Ignore();
 856
 857                 if ( nDialogRet == RET_OK )
 858                 {
 859                     if ( pPrinter->GetName() != pDlgPrinter->GetName() )
 860                     {
 861                         // user has changed the printer -> macro recording
 862                         SfxRequest aReq( GetViewFrame(), SID_PRINTER_NAME );
 863                         aReq.AppendItem( SfxStringItem( SID_PRINTER_NAME, pDlgPrinter->GetName() ) );
 864                         aReq.Done();
 865                     }
 866
 867                     // take the changes made in the dialog
 868                     SetPrinter_Impl( pDlgPrinter );
 869
 870                     // forget new printer, it was taken over (as pPrinter) or deleted
 871                     pDlgPrinter = NULL;
 872                     mbPrinterSettingsModified = true;
 873                 }
 874                 else
 875                 {
 876                     // PrinterDialog is used to transfer information on printing,
 877                     // so it will only be deleted here if dialog was cancelled
 878                     pDlgPrinter.disposeAndClear();
 879                     rReq.Ignore();
 880                 }
 881             }
 882         }
 883     }
 884 }
 885
 886 SfxPrinter* SfxViewShell::GetPrinter( bool /*bCreate*/ )
 887 {
 888     return 0;
 889 }
 890
 891 sal_uInt16 SfxViewShell::SetPrinter( SfxPrinter* /*pNewPrinter*/, SfxPrinterChangeFlags /*nDiffFlags*/, bool )
 892 {
 893     return 0;
 894 }
 895
 896 VclPtr<SfxTabPage> SfxViewShell::CreatePrintOptionsPage
 897 (
 898     vcl::Window*             /*pParent*/,
 899     const SfxItemSet&   /*rOptions*/
 900 )
 901 {
 902     return VclPtr<SfxTabPage>();
 903 }
 904
 905 bool SfxViewShell::HasPrintOptionsPage() const
 906 {
 907     return false;
 908 }
 909
 910 JobSetup SfxViewShell::GetJobSetup()
 911 {
 912     return JobSetup();
 913 }
 914
 915 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */