sd/source/ui/slidesorter/model/SlsPageDescriptor.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 "model/SlsPageDescriptor.hxx"
  21
  22 #include "sdpage.hxx"
  23 #include "drawdoc.hxx"
  24
  25 #include <svx/svdopage.hxx>
  26 #include <svx/svdpagv.hxx>
  27 #include <svx/sdr/contact/viewcontact.hxx>
  28 #include <svx/sdr/contact/viewobjectcontact.hxx>
  29
  30 using namespace ::com::sun::star::uno;
  31 using namespace ::com::sun::star;
  32
  33 namespace sd {  namespace slidesorter { namespace model {
  34
  35 PageDescriptor::PageDescriptor (
  36     const Reference<drawing::XDrawPage>& rxPage,
  37     SdPage* pPage,
  38     const sal_Int32 nIndex)
  39     : mpPage(pPage),
  40       mxPage(rxPage),
  41       mpMasterPage(NULL),
  42       mnIndex(nIndex),
  43       maBoundingBox(),
  44       maVisualState(nIndex),
  45       mbIsSelected(false),
  46       mbWasSelected(false),
  47       mbIsVisible(false),
  48       mbIsFocused(false),
  49       mbIsCurrent(false),
  50       mbIsMouseOver(false),
  51       mbHasTransition(false)
  52 {
  53     OSL_ASSERT(mpPage);
  54     OSL_ASSERT(mpPage == SdPage::getImplementation(rxPage));
  55     if (mpPage != NULL)
  56     {
  57         if (mpPage->TRG_HasMasterPage())
  58             mpMasterPage = &mpPage->TRG_GetMasterPage();
  59         if (mpPage->getTransitionType() > 0)
  60             mbHasTransition = true;
  61     }
  62 }
  63
  64 PageDescriptor::~PageDescriptor()
  65 {
  66 }
  67
  68 void PageDescriptor::SetPageIndex (const sal_Int32 nNewIndex)
  69 {
  70     mnIndex = nNewIndex;
  71     maVisualState.mnPageId = nNewIndex;
  72 }
  73
  74 bool PageDescriptor::UpdateMasterPage()
  75 {
  76     const SdrPage* pMaster = NULL;
  77     if (mpPage!=NULL && mpPage->TRG_HasMasterPage())
  78         pMaster = &mpPage->TRG_GetMasterPage();
  79     if (mpMasterPage != pMaster)
  80     {
  81         mpMasterPage = pMaster;
  82         return true;
  83     }
  84     else
  85         return false;
  86 }
  87
  88 bool PageDescriptor::UpdateTransitionFlag()
  89 {
  90     bool bHasSlideTransition (false);
  91     if (mpPage != NULL)
  92         bHasSlideTransition = mpPage->getTransitionType() > 0;
  93     if (bHasSlideTransition != mbHasTransition)
  94     {
  95         mbHasTransition = bHasSlideTransition;
  96         return true;
  97     }
  98     else
  99         return false;
 100 }
 101
 102 bool PageDescriptor::HasState (const State eState) const
 103 {
 104     switch (eState)
 105     {
 106         case ST_Visible:
 107             return mbIsVisible;
 108
 109         case ST_Selected:
 110             return mbIsSelected;
 111
 112         case ST_WasSelected:
 113             return mbWasSelected;
 114
 115         case ST_Focused:
 116             return mbIsFocused;
 117
 118         case ST_MouseOver:
 119             return mbIsMouseOver;
 120
 121         case ST_Current:
 122             return mbIsCurrent;
 123
 124         case ST_Excluded:
 125             return mpPage!=NULL && mpPage->IsExcluded();
 126
 127         default:
 128             OSL_ASSERT(false);
 129             return false;
 130     }
 131 }
 132
 133 bool PageDescriptor::SetState (const State eState, const bool bNewStateValue)
 134 {
 135     bool bModified (false);
 136     switch (eState)
 137     {
 138         case ST_Visible:
 139             bModified = (bNewStateValue!=mbIsVisible);
 140             if (bModified)
 141                 mbIsVisible = bNewStateValue;
 142             break;
 143
 144         case ST_Selected:
 145             bModified = (bNewStateValue!=mbIsSelected);
 146             if (bModified)
 147                 mbIsSelected = bNewStateValue;
 148             break;
 149
 150         case ST_WasSelected:
 151             bModified = (bNewStateValue!=mbWasSelected);
 152             if (bModified)
 153                 mbWasSelected = bNewStateValue;
 154             break;
 155
 156         case ST_Focused:
 157             bModified = (bNewStateValue!=mbIsFocused);
 158             if (bModified)
 159                 mbIsFocused = bNewStateValue;
 160             break;
 161
 162         case ST_MouseOver:
 163             bModified = (bNewStateValue!=mbIsMouseOver);
 164             if (bModified)
 165                 mbIsMouseOver = bNewStateValue;
 166             break;
 167
 168         case ST_Current:
 169             bModified = (bNewStateValue!=mbIsCurrent);
 170             if (bModified)
 171                 mbIsCurrent = bNewStateValue;
 172             break;
 173
 174         case ST_Excluded:
 175             // This is a state of the page and has to be handled differently
 176             // from the view-only states.
 177             if (mpPage != NULL)
 178                 if (bNewStateValue != mpPage->IsExcluded())
 179                 {
 180                     mpPage->SetExcluded(bNewStateValue);
 181                     bModified = true;
 182                 }
 183             break;
 184     }
 185
 186     if (bModified)
 187         maVisualState.UpdateVisualState(*this);
 188     return bModified;
 189 }
 190
 191 bool PageDescriptor::GetCoreSelection()
 192 {
 193     if (mpPage!=NULL && mpPage->IsSelected() != mbIsSelected)
 194         return SetState(ST_Selected, !mbIsSelected);
 195     else
 196         return false;
 197 }
 198
 199 void PageDescriptor::SetCoreSelection()
 200 {
 201     if (mpPage != NULL)
 202         if (HasState(ST_Selected))
 203             mpPage->SetSelected(true);
 204         else
 205             mpPage->SetSelected(false);
 206     else
 207     {
 208         OSL_ASSERT(mpPage!=NULL);
 209     }
 210 }
 211
 212 Rectangle PageDescriptor::GetBoundingBox() const
 213 {
 214     Rectangle aBox (maBoundingBox);
 215     const Point aOffset (maVisualState.GetLocationOffset());
 216     aBox.Move(aOffset.X(), aOffset.Y());
 217     return aBox;
 218 }
 219
 220 Point PageDescriptor::GetLocation (const bool bIgnoreOffset) const
 221 {
 222     if (bIgnoreOffset)
 223         return maBoundingBox.TopLeft();
 224     else
 225         return maBoundingBox.TopLeft() + maVisualState.GetLocationOffset();
 226 }
 227
 228 void PageDescriptor::SetBoundingBox (const Rectangle& rBoundingBox)
 229 {
 230     maBoundingBox = rBoundingBox;
 231 }
 232
 233 } } } // end of namespace ::sd::slidesorter::model
 234
 235 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */