sd/source/core/PageListWatcher.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PageListWatcher.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "PageListWatcher.hxx"
  35
  36 #include "sdpage.hxx"
  37 #include <tools/debug.hxx>
  38 #include <svx/svdmodel.hxx>
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41 // #109538#
  42
  43 void ImpPageListWatcher::ImpRecreateSortedPageListOnDemand()
  44 {
  45     // clear vectors
  46     maPageVectorStandard.clear();
  47     maPageVectorNotes.clear();
  48     mpHandoutPage = 0L;
  49
  50     // build up vectors again
  51     const sal_uInt32 nPageCount(ImpGetPageCount());
  52
  53     for(sal_uInt32 a(0L); a < nPageCount; a++)
  54     {
  55         SdPage* pCandidate = ImpGetPage(a);
  56         DBG_ASSERT(pCandidate, "ImpPageListWatcher::ImpRecreateSortedPageListOnDemand: Invalid PageList in Model (!)");
  57
  58         switch(pCandidate->GetPageKind())
  59         {
  60             case PK_STANDARD:
  61             {
  62                 maPageVectorStandard.push_back(pCandidate);
  63                 break;
  64             }
  65             case PK_NOTES:
  66             {
  67                 maPageVectorNotes.push_back(pCandidate);
  68                 break;
  69             }
  70             case PK_HANDOUT:
  71             {
  72                 DBG_ASSERT(!mpHandoutPage, "ImpPageListWatcher::ImpRecreateSortedPageListOnDemand: Two Handout pages in PageList of Model (!)");
  73                 mpHandoutPage = pCandidate;
  74                 break;
  75             }
  76         }
  77     }
  78
  79     // set to valid
  80     mbPageListValid = sal_True;
  81 }
  82
  83 ImpPageListWatcher::ImpPageListWatcher(const SdrModel& rModel)
  84 :   mrModel(rModel),
  85     mpHandoutPage(0L),
  86     mbPageListValid(sal_False)
  87 {
  88 }
  89
  90 ImpPageListWatcher::~ImpPageListWatcher()
  91 {
  92 }
  93
  94 SdPage* ImpPageListWatcher::GetSdPage(PageKind ePgKind, sal_uInt32 nPgNum)
  95 {
  96     SdPage* pRetval(0L);
  97
  98     if(!mbPageListValid)
  99     {
 100         ImpRecreateSortedPageListOnDemand();
 101     }
 102
 103     switch(ePgKind)
 104     {
 105         case PK_STANDARD:
 106         {
 107             if( nPgNum < (sal_uInt32)maPageVectorStandard.size() )
 108                 pRetval = maPageVectorStandard[nPgNum];
 109             else
 110             {
 111                 DBG_ASSERT(nPgNum <= maPageVectorStandard.size(),
 112                     "ImpPageListWatcher::GetSdPage(PK_STANDARD): access out of range");
 113                 DBG_WARNING2 ("    %d  > %d",
 114                     nPgNum, nPgNum<maPageVectorStandard.size());
 115             }
 116             break;
 117         }
 118         case PK_NOTES:
 119         {
 120             if( nPgNum < (sal_uInt32)maPageVectorNotes.size() )
 121                 pRetval = maPageVectorNotes[nPgNum];
 122             else
 123             {
 124                 DBG_ASSERT(nPgNum <= maPageVectorNotes.size(),
 125                     "ImpPageListWatcher::GetSdPage(PK_NOTES): access out of range");
 126                 DBG_WARNING2("    %d > %d",
 127                     nPgNum, nPgNum<maPageVectorNotes.size());
 128             }
 129             break;
 130         }
 131         case PK_HANDOUT:
 132         {
 133 //                      #11420# for models used to transfer drawing shapes via clipboard its
 134 //                      ok to not have a handout page
 135 //                      DBG_ASSERT(mpHandoutPage, "ImpPageListWatcher::GetSdPage: access to non existing handout page (!)");
 136             DBG_ASSERT(nPgNum == 0L, "ImpPageListWatcher::GetSdPage: access to non existing handout page (!)");
 137             if (nPgNum == 0)
 138                 pRetval = mpHandoutPage;
 139             else
 140             {
 141                 DBG_ASSERT(nPgNum == 0L,
 142                     "ImpPageListWatcher::GetSdPage: access to non existing handout page (!)");
 143             }
 144             break;
 145         }
 146     }
 147
 148     return pRetval;
 149 }
 150
 151 sal_uInt32 ImpPageListWatcher::GetSdPageCount(PageKind ePgKind)
 152 {
 153     sal_uInt32 nRetval(0L);
 154
 155     if(!mbPageListValid)
 156     {
 157         ImpRecreateSortedPageListOnDemand();
 158     }
 159
 160     switch(ePgKind)
 161     {
 162         case PK_STANDARD:
 163         {
 164             nRetval = maPageVectorStandard.size();
 165             break;
 166         }
 167         case PK_NOTES:
 168         {
 169             nRetval = maPageVectorNotes.size();
 170             break;
 171         }
 172         case PK_HANDOUT:
 173         {
 174             if(mpHandoutPage)
 175             {
 176                 nRetval = 1L;
 177             }
 178
 179             break;
 180         }
 181     }
 182
 183     return nRetval;
 184 }
 185
 186 //////////////////////////////////////////////////////////////////////////////
 187
 188 sal_uInt32 ImpDrawPageListWatcher::ImpGetPageCount() const
 189 {
 190     return (sal_uInt32)mrModel.GetPageCount();
 191 }
 192
 193 SdPage* ImpDrawPageListWatcher::ImpGetPage(sal_uInt32 nIndex) const
 194 {
 195     return (SdPage*)mrModel.GetPage((sal_uInt16)nIndex);
 196 }
 197
 198 ImpDrawPageListWatcher::ImpDrawPageListWatcher(const SdrModel& rModel)
 199 :   ImpPageListWatcher(rModel)
 200 {
 201 }
 202
 203 ImpDrawPageListWatcher::~ImpDrawPageListWatcher()
 204 {
 205 }
 206
 207 //////////////////////////////////////////////////////////////////////////////
 208
 209 sal_uInt32 ImpMasterPageListWatcher::ImpGetPageCount() const
 210 {
 211     return (sal_uInt32)mrModel.GetMasterPageCount();
 212 }
 213
 214 SdPage* ImpMasterPageListWatcher::ImpGetPage(sal_uInt32 nIndex) const
 215 {
 216     return (SdPage*)mrModel.GetMasterPage((sal_uInt16)nIndex);
 217 }
 218
 219 ImpMasterPageListWatcher::ImpMasterPageListWatcher(const SdrModel& rModel)
 220 :   ImpPageListWatcher(rModel)
 221 {
 222 }
 223
 224 ImpMasterPageListWatcher::~ImpMasterPageListWatcher()
 225 {
 226 }