LCOV - code coverage report
Current view: top level - sd/source/core - PageListWatcher.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 74 74 100.0 %
Date: 2014-11-03 Functions: 18 19 94.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "PageListWatcher.hxx"
      21             : 
      22             : #include "sdpage.hxx"
      23             : #include <tools/debug.hxx>
      24             : #include <svx/svdmodel.hxx>
      25             : 
      26        2250 : void ImpPageListWatcher::ImpRecreateSortedPageListOnDemand()
      27             : {
      28             :     // clear vectors
      29        2250 :     maPageVectorStandard.clear();
      30        2250 :     maPageVectorNotes.clear();
      31        2250 :     mpHandoutPage = 0L;
      32             : 
      33             :     // build up vectors again
      34        2250 :     const sal_uInt32 nPageCount(ImpGetPageCount());
      35             : 
      36        7898 :     for(sal_uInt32 a(0L); a < nPageCount; a++)
      37             :     {
      38        5648 :         SdPage* pCandidate = ImpGetPage(a);
      39             :         DBG_ASSERT(pCandidate, "ImpPageListWatcher::ImpRecreateSortedPageListOnDemand: Invalid PageList in Model (!)");
      40             : 
      41        5648 :         switch(pCandidate->GetPageKind())
      42             :         {
      43             :             case PK_STANDARD:
      44             :             {
      45        2138 :                 maPageVectorStandard.push_back(pCandidate);
      46        2138 :                 break;
      47             :             }
      48             :             case PK_NOTES:
      49             :             {
      50        2062 :                 maPageVectorNotes.push_back(pCandidate);
      51        2062 :                 break;
      52             :             }
      53             :             case PK_HANDOUT:
      54             :             {
      55             :                 DBG_ASSERT(!mpHandoutPage, "ImpPageListWatcher::ImpRecreateSortedPageListOnDemand: Two Handout pages in PageList of Model (!)");
      56        1448 :                 mpHandoutPage = pCandidate;
      57        1448 :                 break;
      58             :             }
      59             :         }
      60             :     }
      61             : 
      62             :     // set to valid
      63        2250 :     mbPageListValid = true;
      64        2250 : }
      65             : 
      66         884 : ImpPageListWatcher::ImpPageListWatcher(const SdrModel& rModel)
      67             :     : mrModel(rModel)
      68             :     , mpHandoutPage(0L)
      69         884 :     , mbPageListValid(false)
      70             : {
      71         884 : }
      72             : 
      73         884 : ImpPageListWatcher::~ImpPageListWatcher()
      74             : {
      75         884 : }
      76             : 
      77       14424 : SdPage* ImpPageListWatcher::GetSdPage(PageKind ePgKind, sal_uInt32 nPgNum)
      78             : {
      79       14424 :     SdPage* pRetval(0L);
      80             : 
      81       14424 :     if(!mbPageListValid)
      82             :     {
      83         686 :         ImpRecreateSortedPageListOnDemand();
      84             :     }
      85             : 
      86       14424 :     switch(ePgKind)
      87             :     {
      88             :         case PK_STANDARD:
      89             :         {
      90       12470 :             if( nPgNum < (sal_uInt32)maPageVectorStandard.size() )
      91       10630 :                 pRetval = maPageVectorStandard[nPgNum];
      92             :             else
      93             :             {
      94             :                 SAL_WARN( "sd.core",
      95             :                           "ImpPageListWatcher::GetSdPage(PK_STANDARD): page number " << nPgNum << " >= " << maPageVectorStandard.size() );
      96             :             }
      97       12470 :             break;
      98             :         }
      99             :         case PK_NOTES:
     100             :         {
     101        1234 :             if( nPgNum < (sal_uInt32)maPageVectorNotes.size() )
     102        1234 :                 pRetval = maPageVectorNotes[nPgNum];
     103             :             else
     104             :             {
     105             :                 SAL_WARN( "sd.core",
     106             :                           "ImpPageListWatcher::GetSdPage(PK_NOTES): page number " << nPgNum << " >= " << maPageVectorNotes.size() );
     107             :             }
     108        1234 :             break;
     109             :         }
     110             :         case PK_HANDOUT:
     111             :         {
     112             : //          #11420# for models used to transfer drawing shapes via clipboard its ok to not have a handout page
     113             :             DBG_ASSERT(nPgNum == 0L, "ImpPageListWatcher::GetSdPage: access to non existing handout page (!)");
     114         720 :             if (nPgNum == 0)
     115         720 :                 pRetval = mpHandoutPage;
     116             :             else
     117             :             {
     118             :                 DBG_ASSERT(nPgNum == 0L,
     119             :                     "ImpPageListWatcher::GetSdPage: access to non existing handout page (!)");
     120             :             }
     121         720 :             break;
     122             :         }
     123             :     }
     124             : 
     125       14424 :     return pRetval;
     126             : }
     127             : 
     128       14810 : sal_uInt32 ImpPageListWatcher::GetSdPageCount(PageKind ePgKind)
     129             : {
     130       14810 :     sal_uInt32 nRetval(0L);
     131             : 
     132       14810 :     if(!mbPageListValid)
     133             :     {
     134        1564 :         ImpRecreateSortedPageListOnDemand();
     135             :     }
     136             : 
     137       14810 :     switch(ePgKind)
     138             :     {
     139             :         case PK_STANDARD:
     140             :         {
     141       14002 :             nRetval = maPageVectorStandard.size();
     142       14002 :             break;
     143             :         }
     144             :         case PK_NOTES:
     145             :         {
     146         752 :             nRetval = maPageVectorNotes.size();
     147         752 :             break;
     148             :         }
     149             :         case PK_HANDOUT:
     150             :         {
     151          56 :             if(mpHandoutPage)
     152             :             {
     153          56 :                 nRetval = 1L;
     154             :             }
     155             : 
     156          56 :             break;
     157             :         }
     158             :     }
     159             : 
     160       14810 :     return nRetval;
     161             : }
     162             : 
     163         209 : sal_uInt32 ImpPageListWatcher::GetVisibleSdPageCount()
     164             : {
     165         209 :     sal_uInt32 nVisiblePageCount = 0;
     166             : 
     167             :     // build up vectors again
     168         209 :     const sal_uInt32 nPageCount(ImpGetPageCount());
     169             : 
     170         846 :     for(sal_uInt32 a(0L); a < nPageCount; a++)
     171             :     {
     172         637 :         SdPage* pCandidate = ImpGetPage(a);
     173         637 :         if ((pCandidate->GetPageKind() == PK_STANDARD)&&(!pCandidate->IsExcluded())) nVisiblePageCount++;
     174             :     }
     175         209 :     return nVisiblePageCount;
     176             : }
     177             : 
     178        1547 : sal_uInt32 ImpDrawPageListWatcher::ImpGetPageCount() const
     179             : {
     180        1547 :     return (sal_uInt32)mrModel.GetPageCount();
     181             : }
     182             : 
     183        4849 : SdPage* ImpDrawPageListWatcher::ImpGetPage(sal_uInt32 nIndex) const
     184             : {
     185        4849 :     return (SdPage*)mrModel.GetPage((sal_uInt16)nIndex);
     186             : }
     187             : 
     188         442 : ImpDrawPageListWatcher::ImpDrawPageListWatcher(const SdrModel& rModel)
     189         442 : :   ImpPageListWatcher(rModel)
     190             : {
     191         442 : }
     192             : 
     193         884 : ImpDrawPageListWatcher::~ImpDrawPageListWatcher()
     194             : {
     195         884 : }
     196             : 
     197         912 : sal_uInt32 ImpMasterPageListWatcher::ImpGetPageCount() const
     198             : {
     199         912 :     return (sal_uInt32)mrModel.GetMasterPageCount();
     200             : }
     201             : 
     202        1436 : SdPage* ImpMasterPageListWatcher::ImpGetPage(sal_uInt32 nIndex) const
     203             : {
     204        1436 :     return (SdPage*)mrModel.GetMasterPage((sal_uInt16)nIndex);
     205             : }
     206             : 
     207         442 : ImpMasterPageListWatcher::ImpMasterPageListWatcher(const SdrModel& rModel)
     208         442 : :   ImpPageListWatcher(rModel)
     209             : {
     210         442 : }
     211             : 
     212         884 : ImpMasterPageListWatcher::~ImpMasterPageListWatcher()
     213             : {
     214         998 : }
     215             : 
     216             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10