sd/source/ui/slidesorter/controller/SlsFocusManager.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: SlsFocusManager.cxx,v $
  10  * $Revision: 1.14 $
  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 #include "controller/SlsFocusManager.hxx"
  33
  34 #include "SlideSorter.hxx"
  35 #include "PaneDockingWindow.hxx"
  36 #include "controller/SlideSorterController.hxx"
  37 #include "controller/SlsSelectionManager.hxx"
  38 #include "model/SlideSorterModel.hxx"
  39 #include "model/SlsPageDescriptor.hxx"
  40 #include "view/SlideSorterView.hxx"
  41 #include "view/SlsLayouter.hxx"
  42 #include <vcl/toolbox.hxx>
  43
  44 #include "Window.hxx"
  45 #include "sdpage.hxx"
  46
  47 namespace sd { namespace slidesorter { namespace controller {
  48
  49 FocusManager::FocusManager (SlideSorter& rSlideSorter)
  50     : mrSlideSorter(rSlideSorter),
  51       mnPageIndex(0),
  52       mbPageIsFocused(false)
  53 {
  54     if (mrSlideSorter.GetModel().GetPageCount() > 0)
  55         mnPageIndex = 0;
  56 }
  57
  58
  59
  60
  61 FocusManager::~FocusManager (void)
  62 {
  63 }
  64
  65
  66
  67
  68 void FocusManager::MoveFocus (FocusMoveDirection eDirection)
  69 {
  70     if (mnPageIndex >= 0 && mbPageIsFocused)
  71     {
  72         HideFocusIndicator (GetFocusedPageDescriptor());
  73
  74         int nColumnCount (mrSlideSorter.GetView().GetLayouter().GetColumnCount());
  75         switch (eDirection)
  76         {
  77             case FMD_NONE:
  78                 if (mnPageIndex >= mrSlideSorter.GetModel().GetPageCount())
  79                     mnPageIndex = mrSlideSorter.GetModel().GetPageCount() - 1;
  80                 break;
  81
  82             case FMD_LEFT:
  83                 mnPageIndex -= 1;
  84                 if (mnPageIndex < 0)
  85                 {
  86                     mnPageIndex = mrSlideSorter.GetModel().GetPageCount() - 1;
  87                     SetFocusToToolBox();
  88                 }
  89                 break;
  90
  91             case FMD_RIGHT:
  92                 mnPageIndex += 1;
  93                 if (mnPageIndex >= mrSlideSorter.GetModel().GetPageCount())
  94                 {
  95                     mnPageIndex = 0;
  96                     SetFocusToToolBox();
  97                 }
  98                 break;
  99
 100             case FMD_UP:
 101             {
 102                 int nColumn = mnPageIndex % nColumnCount;
 103                 mnPageIndex -= nColumnCount;
 104                 if (mnPageIndex < 0)
 105                 {
 106                     // Wrap arround to the bottom row or the one above and
 107                     // go to the correct column.
 108                     int nCandidate = mrSlideSorter.GetModel().GetPageCount()-1;
 109                     int nCandidateColumn = nCandidate % nColumnCount;
 110                     if (nCandidateColumn > nColumn)
 111                         mnPageIndex = nCandidate - (nCandidateColumn-nColumn);
 112                     else if (nCandidateColumn < nColumn)
 113                         mnPageIndex = nCandidate
 114                             - nColumnCount
 115                             + (nColumn - nCandidateColumn);
 116                     else
 117                         mnPageIndex = nCandidate;
 118                 }
 119             }
 120             break;
 121
 122             case FMD_DOWN:
 123             {
 124                 int nColumn = mnPageIndex % nColumnCount;
 125                 mnPageIndex += nColumnCount;
 126                 if (mnPageIndex >= mrSlideSorter.GetModel().GetPageCount())
 127                 {
 128                     // Wrap arround to the correct column.
 129                     mnPageIndex = nColumn;
 130                 }
 131             }
 132             break;
 133         }
 134
 135         if (mbPageIsFocused)
 136             ShowFocusIndicator(GetFocusedPageDescriptor());
 137     }
 138 }
 139
 140
 141
 142
 143 void FocusManager::ShowFocus (void)
 144 {
 145     mbPageIsFocused = true;
 146     ShowFocusIndicator(GetFocusedPageDescriptor());
 147 }
 148
 149
 150
 151
 152 void FocusManager::HideFocus (void)
 153 {
 154     mbPageIsFocused = false;
 155     HideFocusIndicator(GetFocusedPageDescriptor());
 156 }
 157
 158
 159
 160
 161 bool FocusManager::ToggleFocus (void)
 162 {
 163     if (mnPageIndex >= 0)
 164     {
 165         if (mbPageIsFocused)
 166             HideFocus ();
 167         else
 168             ShowFocus ();
 169     }
 170     return mbPageIsFocused;
 171 }
 172
 173
 174
 175
 176 bool FocusManager::HasFocus (void) const
 177 {
 178     return mrSlideSorter.GetView().GetWindow()->HasFocus();
 179 }
 180
 181
 182
 183
 184 model::SharedPageDescriptor FocusManager::GetFocusedPageDescriptor (void) const
 185 {
 186     return mrSlideSorter.GetModel().GetPageDescriptor(mnPageIndex);
 187 }
 188
 189
 190
 191
 192 sal_Int32 FocusManager::GetFocusedPageIndex (void) const
 193 {
 194     return mnPageIndex;
 195 }
 196
 197
 198
 199
 200 void FocusManager::FocusPage (sal_Int32 nPageIndex)
 201 {
 202     if (nPageIndex != mnPageIndex)
 203     {
 204         // Hide the focus while switching it to the specified page.
 205         FocusHider aHider (*this);
 206         mnPageIndex = nPageIndex;
 207     }
 208
 209     if (HasFocus() && !IsFocusShowing())
 210         ShowFocus();
 211 }
 212
 213
 214
 215
 216 void FocusManager::SetFocusedPage (const model::SharedPageDescriptor& rpDescriptor)
 217 {
 218     if (rpDescriptor.get() != NULL)
 219     {
 220         FocusHider aFocusHider (*this);
 221         mnPageIndex = (rpDescriptor->GetPage()->GetPageNum()-1)/2;
 222     }
 223 }
 224
 225
 226
 227
 228 void FocusManager::SetFocusedPage (sal_Int32 nPageIndex)
 229 {
 230     FocusHider aFocusHider (*this);
 231     mnPageIndex = nPageIndex;
 232 }
 233
 234
 235
 236
 237 bool FocusManager::IsFocusShowing (void) const
 238 {
 239     return HasFocus() && mbPageIsFocused;
 240 }
 241
 242
 243
 244
 245 void FocusManager::HideFocusIndicator (const model::SharedPageDescriptor& rpDescriptor)
 246 {
 247     if (rpDescriptor.get() != NULL)
 248     {
 249         rpDescriptor->RemoveFocus();
 250         mrSlideSorter.GetView().RequestRepaint(rpDescriptor);
 251     }
 252 }
 253
 254
 255
 256
 257 void FocusManager::ShowFocusIndicator (const model::SharedPageDescriptor& rpDescriptor)
 258 {
 259     if (rpDescriptor.get() != NULL)
 260     {
 261         rpDescriptor->SetFocus ();
 262
 263         // Scroll the focused page object into the visible area and repaint
 264         // it, so that the focus indicator becomes visible.
 265         view::SlideSorterView& rView (mrSlideSorter.GetView());
 266         mrSlideSorter.GetController().GetSelectionManager()->MakeRectangleVisible (
 267             rView.GetPageBoundingBox (
 268                 GetFocusedPageDescriptor(),
 269                 view::SlideSorterView::CS_MODEL,
 270                 view::SlideSorterView::BBT_INFO));
 271
 272         mrSlideSorter.GetView().RequestRepaint (rpDescriptor);
 273         NotifyFocusChangeListeners();
 274     }
 275 }
 276
 277
 278
 279
 280 void FocusManager::AddFocusChangeListener (const Link& rListener)
 281 {
 282     if (::std::find (maFocusChangeListeners.begin(), maFocusChangeListeners.end(), rListener)
 283         == maFocusChangeListeners.end())
 284     {
 285         maFocusChangeListeners.push_back (rListener);
 286     }
 287 }
 288
 289
 290
 291
 292 void FocusManager::RemoveFocusChangeListener (const Link& rListener)
 293 {
 294     maFocusChangeListeners.erase (
 295         ::std::find (maFocusChangeListeners.begin(), maFocusChangeListeners.end(), rListener));
 296 }
 297
 298
 299
 300
 301 void FocusManager::SetFocusToToolBox (void)
 302 {
 303     HideFocus();
 304
 305     if (mrSlideSorter.GetViewShell() != NULL)
 306     {
 307         ::Window* pParentWindow = mrSlideSorter.GetViewShell()->GetParentWindow();
 308         DockingWindow* pDockingWindow = NULL;
 309         while (pParentWindow!=NULL && pDockingWindow==NULL)
 310         {
 311             pDockingWindow = dynamic_cast<DockingWindow*>(pParentWindow);
 312             pParentWindow = pParentWindow->GetParent();
 313         }
 314         if (pDockingWindow)
 315         {
 316             PaneDockingWindow* pPaneDockingWindow = dynamic_cast<PaneDockingWindow*>(pDockingWindow);
 317             if (pPaneDockingWindow != NULL)
 318                 pPaneDockingWindow->GetTitleToolBox()->GrabFocus();
 319         }
 320     }
 321 }
 322
 323
 324
 325
 326 void FocusManager::NotifyFocusChangeListeners (void) const
 327 {
 328     // Create a copy of the listener list to be safe when that is modified.
 329     ::std::vector<Link> aListeners (maFocusChangeListeners);
 330
 331     // Tell the slection change listeners that the selection has changed.
 332     ::std::vector<Link>::iterator iListener (aListeners.begin());
 333     ::std::vector<Link>::iterator iEnd (aListeners.end());
 334     for (; iListener!=iEnd; ++iListener)
 335     {
 336         iListener->Call(NULL);
 337     }
 338 }
 339
 340
 341
 342
 343 FocusManager::FocusHider::FocusHider (FocusManager& rManager)
 344 : mbFocusVisible(rManager.IsFocusShowing())
 345 , mrManager(rManager)
 346 {
 347     mrManager.HideFocus();
 348 }
 349
 350
 351
 352
 353 FocusManager::FocusHider::~FocusHider (void)
 354 {
 355     if (mbFocusVisible)
 356         mrManager.ShowFocus();
 357 }
 358
 359 } } } // end of namespace ::sd::slidesorter::controller
 360