sd/source/ui/slidesorter/model/SlsPageEnumeration.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: SlsPageEnumeration.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 #include "precompiled_sd.hxx"
  32
  33 #include "model/SlideSorterModel.hxx"
  34 #include "model/SlsPageDescriptor.hxx"
  35
  36 using namespace ::sd::slidesorter;
  37 using namespace ::sd::slidesorter::model;
  38
  39 namespace {
  40
  41 class PageEnumerationImpl
  42     : public Enumeration<SharedPageDescriptor>
  43 {
  44 public:
  45     inline PageEnumerationImpl (
  46         const SlideSorterModel& rModel,
  47         const PageEnumeration::PagePredicate& rPredicate);
  48     virtual ~PageEnumerationImpl (void);
  49     /** Create a copy of the called enumeration object.
  50     */
  51     virtual inline ::std::auto_ptr<Enumeration<SharedPageDescriptor> > Clone (void);
  52
  53     virtual inline bool HasMoreElements (void) const;
  54     virtual inline SharedPageDescriptor GetNextElement (void);
  55     virtual inline void Rewind (void);
  56
  57 private:
  58     const SlideSorterModel& mrModel;
  59     const PageEnumeration::PagePredicate maPredicate;
  60     int mnIndex;
  61
  62     /** This constructor sets the internal page index to the given value.
  63         It does not call AdvanceToNextValidElement() to skip elements that
  64         do not fullfill Predicate.
  65     */
  66     inline PageEnumerationImpl (
  67         const SlideSorterModel& rModel,
  68         const PageEnumeration::PagePredicate& rPredicate,
  69         int nIndex);
  70
  71     /** Skip all elements that do not fullfill Predicate starting with the
  72         one pointed to by mnIndex.
  73     */
  74     inline void AdvanceToNextValidElement (void);
  75
  76     // Default constructor not implemented.
  77     PageEnumerationImpl (void);
  78     // Assignment operator not implemented.
  79     PageEnumerationImpl& operator= (const PageEnumerationImpl&);
  80 };
  81
  82 } // end of anonymouse namespace
  83
  84
  85
  86
  87 namespace sd { namespace slidesorter { namespace model {
  88
  89
  90 PageEnumeration PageEnumeration::Create (
  91     const SlideSorterModel& rModel,
  92     const PagePredicate& rPredicate)
  93 {
  94     return PageEnumeration(::std::auto_ptr<Enumeration<SharedPageDescriptor> >(
  95         new PageEnumerationImpl(rModel, rPredicate)));
  96 }
  97
  98
  99
 100
 101 PageEnumeration::PageEnumeration (
 102     ::std::auto_ptr<Enumeration<SharedPageDescriptor> > pImpl)
 103     : mpImpl(pImpl)
 104 {
 105 }
 106
 107
 108
 109
 110 PageEnumeration::PageEnumeration (
 111     PageEnumeration& rEnumeration,
 112     bool bCloneImpl)
 113 {
 114
 115     if( bCloneImpl )
 116     {
 117         mpImpl = rEnumeration.mpImpl->Clone();
 118     }
 119     else
 120     {
 121         mpImpl = rEnumeration.mpImpl;
 122     }
 123 }
 124
 125
 126
 127
 128 PageEnumeration::PageEnumeration (const PageEnumeration& rEnumeration )
 129 : sd::slidesorter::model::Enumeration<sd::slidesorter::model::SharedPageDescriptor>()
 130 {
 131     mpImpl = rEnumeration.mpImpl->Clone();
 132 }
 133
 134
 135
 136
 137 PageEnumeration::~PageEnumeration (void)
 138 {
 139 }
 140
 141
 142
 143
 144 PageEnumeration& PageEnumeration::operator= (
 145     const PageEnumeration& rEnumeration)
 146 {
 147     mpImpl = rEnumeration.mpImpl->Clone();
 148     return *this;
 149 }
 150
 151
 152
 153
 154 ::std::auto_ptr<Enumeration<SharedPageDescriptor> > PageEnumeration::Clone (void)
 155 {
 156     return ::std::auto_ptr<Enumeration<SharedPageDescriptor> >(
 157         new PageEnumeration (*this, true));
 158 }
 159
 160
 161
 162
 163 bool PageEnumeration::HasMoreElements (void) const
 164 {
 165     return mpImpl->HasMoreElements();
 166 }
 167
 168
 169
 170 SharedPageDescriptor PageEnumeration::GetNextElement (void)
 171 {
 172     return mpImpl->GetNextElement();
 173 }
 174
 175
 176
 177
 178 void PageEnumeration::Rewind (void)
 179 {
 180     return mpImpl->Rewind();
 181 }
 182
 183 } } } // end of namespace ::sd::slidesorter::model
 184
 185
 186
 187
 188 namespace {
 189
 190 PageEnumerationImpl::PageEnumerationImpl (
 191     const SlideSorterModel& rModel,
 192     const PageEnumeration::PagePredicate& rPredicate)
 193     : mrModel(rModel),
 194       maPredicate(rPredicate),
 195       mnIndex(0)
 196 {
 197     Rewind();
 198 }
 199
 200
 201
 202
 203 PageEnumerationImpl::PageEnumerationImpl (
 204     const SlideSorterModel& rModel,
 205     const PageEnumeration::PagePredicate& rPredicate,
 206     int nIndex)
 207     : mrModel(rModel),
 208       maPredicate(rPredicate),
 209       mnIndex(nIndex)
 210 {
 211 }
 212
 213
 214
 215
 216 PageEnumerationImpl::~PageEnumerationImpl (void)
 217 {
 218 }
 219
 220
 221
 222
 223 ::std::auto_ptr<Enumeration<SharedPageDescriptor> >
 224     PageEnumerationImpl::Clone (void)
 225 {
 226     return ::std::auto_ptr<Enumeration<SharedPageDescriptor> >(
 227         new PageEnumerationImpl(mrModel,maPredicate,mnIndex));
 228 }
 229
 230
 231
 232
 233 bool PageEnumerationImpl::HasMoreElements (void) const
 234 {
 235     return (mnIndex < mrModel.GetPageCount());
 236 }
 237
 238
 239
 240
 241 SharedPageDescriptor PageEnumerationImpl::GetNextElement (void)
 242 {
 243     SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(mnIndex));
 244
 245     // Go to the following valid element.
 246     mnIndex += 1;
 247     AdvanceToNextValidElement();
 248
 249     return pDescriptor;
 250 }
 251
 252
 253
 254
 255 void PageEnumerationImpl::Rewind (void)
 256 {
 257     // Go to first valid element.
 258     mnIndex = 0;
 259     AdvanceToNextValidElement();
 260 }
 261
 262
 263
 264
 265
 266 void PageEnumerationImpl::AdvanceToNextValidElement (void)
 267 {
 268     while (mnIndex < mrModel.GetPageCount())
 269     {
 270         SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(mnIndex));
 271
 272         // Test for the predicate being fullfilled.
 273         if (pDescriptor.get()!=NULL && maPredicate(pDescriptor))
 274         {
 275             // This predicate is valid.
 276             break;
 277         }
 278         else
 279         {
 280             // Advance to next predicate.
 281             mnIndex += 1;
 282         }
 283     }
 284 }
 285
 286 } // end of anonymous namespace
 287