LCOV - app.info - layout/printing/nsPagePrintTimer.cpp

LCOV - code coverage report
| Current view: | directory - layout/printing - nsPagePrintTimer.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 58 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 11 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "nsPagePrintTimer.h"
          39                 : #include "nsIContentViewer.h"
          40                 : #include "nsIServiceManager.h"
          41                 : #include "nsPrintEngine.h"
          42                 :
          43               0 : NS_IMPL_ISUPPORTS1(nsPagePrintTimer, nsITimerCallback)
          44                 :
          45               0 : nsPagePrintTimer::nsPagePrintTimer() :
          46                 :   mPrintEngine(nsnull),
          47                 :   mDelay(0),
          48                 :   mFiringCount(0),
          49               0 :   mPrintObj(nsnull)
          50                 : {
          51               0 : }
          52                 :
          53               0 : nsPagePrintTimer::~nsPagePrintTimer()
          54                 : {
          55                 :   // "Destroy" the document viewer; this normally doesn't actually
          56                 :   // destroy it because of the IncrementDestroyRefCount call below
          57                 :   // XXX This is messy; the document viewer should use a single approach
          58                 :   // to keep itself alive during printing
          59               0 :   nsCOMPtr<nsIContentViewer> cv(do_QueryInterface(mDocViewerPrint));
          60               0 :   if (cv) {
          61               0 :     cv->Destroy();
          62                 :   }
          63               0 : }
          64                 :
          65                 : nsresult
          66               0 : nsPagePrintTimer::StartTimer(bool aUseDelay)
          67                 : {
          68                 :   nsresult result;
          69               0 :   mTimer = do_CreateInstance("@mozilla.org/timer;1", &result);
          70               0 :   if (NS_FAILED(result)) {
          71               0 :     NS_WARNING("unable to start the timer");
          72                 :   } else {
          73               0 :     PRUint32 delay = 0;
          74               0 :     if (aUseDelay) {
          75               0 :       if (mFiringCount < 10) {
          76                 :         // Longer delay for the few first pages.
          77               0 :         delay = mDelay + ((10 - mFiringCount) * 100);
          78                 :       } else {
          79               0 :         delay = mDelay;
          80                 :       }
          81                 :     }
          82               0 :     mTimer->InitWithCallback(this, delay, nsITimer::TYPE_ONE_SHOT);
          83                 :   }
          84               0 :   return result;
          85                 : }
          86                 :
          87                 :
          88                 :
          89                 : // nsITimerCallback
          90                 : NS_IMETHODIMP
          91               0 : nsPagePrintTimer::Notify(nsITimer *timer)
          92                 : {
          93               0 :   if (mDocViewerPrint) {
          94               0 :     bool initNewTimer = true;
          95                 :     // Check to see if we are done
          96                 :     // inRange will be true if a page is actually printed
          97                 :     bool inRange;
          98                 :     // donePrinting will be true if it completed successfully or
          99                 :     // if the printing was cancelled
         100               0 :     bool donePrinting = mPrintEngine->PrintPage(mPrintObj, inRange);
         101               0 :     if (donePrinting) {
         102                 :       // now clean up print or print the next webshell
         103               0 :       if (mPrintEngine->DonePrintingPages(mPrintObj, NS_OK)) {
         104               0 :         initNewTimer = false;
         105                 :       }
         106                 :     }
         107                 :
         108                 :     // Note that the Stop() destroys this after the print job finishes
         109                 :     // (The PrintEngine stops holding a reference when DonePrintingPages
         110                 :     // returns true.)
         111               0 :     Stop();
         112               0 :     if (initNewTimer) {
         113               0 :       ++mFiringCount;
         114               0 :       nsresult result = StartTimer(inRange);
         115               0 :       if (NS_FAILED(result)) {
         116               0 :         donePrinting = true;     // had a failure.. we are finished..
         117               0 :         mPrintEngine->SetIsPrinting(false);
         118                 :       }
         119                 :     }
         120                 :   }
         121               0 :   return NS_OK;
         122                 : }
         123                 :
         124                 : void
         125               0 : nsPagePrintTimer::Init(nsPrintEngine*          aPrintEngine,
         126                 :                        nsIDocumentViewerPrint* aDocViewerPrint,
         127                 :                        PRUint32                aDelay)
         128                 : {
         129               0 :   mPrintEngine     = aPrintEngine;
         130               0 :   mDocViewerPrint  = aDocViewerPrint;
         131               0 :   mDelay           = aDelay;
         132                 :
         133               0 :   mDocViewerPrint->IncrementDestroyRefCount();
         134               0 : }
         135                 :
         136                 : nsresult
         137               0 : nsPagePrintTimer::Start(nsPrintObject* aPO)
         138                 : {
         139               0 :   mPrintObj = aPO;
         140               0 :   return StartTimer(false);
         141                 : }
         142                 :
         143                 :
         144                 : void
         145               0 : nsPagePrintTimer::Stop()
         146                 : {
         147               0 :   if (mTimer) {
         148               0 :     mTimer->Cancel();
         149               0 :     mTimer = nsnull;
         150                 :   }
         151               0 : }
         152                 :
         153               0 : nsresult NS_NewPagePrintTimer(nsPagePrintTimer **aResult)
         154                 : {
         155                 :
         156               0 :   NS_PRECONDITION(aResult, "null param");
         157                 :
         158               0 :   nsPagePrintTimer* result = new nsPagePrintTimer;
         159                 :
         160               0 :   if (!result) {
         161               0 :     *aResult = nsnull;
         162               0 :     return NS_ERROR_OUT_OF_MEMORY;
         163                 :   }
         164                 :
         165               0 :   NS_ADDREF(result);
         166               0 :   *aResult = result;
         167                 :
         168               0 :   return NS_OK;
         169                 : }
         170                 :

Generated by: LCOV version 1.7