sd/source/ui/toolpanel/TaskPaneFocusManager.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: TaskPaneFocusManager.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 "TaskPaneFocusManager.hxx"
  35
  36 #include <vcl/window.hxx>
  37 #include <vos/mutex.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/event.hxx>
  40 #include <hash_map>
  41
  42 namespace {
  43
  44 class WindowHash
  45 {
  46 public:
  47     size_t operator()(const ::Window* argument) const
  48     { return reinterpret_cast<unsigned long>(argument); }
  49 };
  50
  51 class EventDescriptor
  52 {
  53 public:
  54     EventDescriptor (const KeyCode& rKey, ::Window* pWindow)
  55         : maKeyCode(rKey), mpTargetWindow(pWindow) {}
  56     KeyCode maKeyCode;
  57     ::Window* mpTargetWindow;
  58 };
  59
  60 } // end of anonymous namespace
  61
  62
  63
  64
  65 namespace sd { namespace toolpanel {
  66
  67
  68
  69 class FocusManager::LinkMap
  70     : public ::std::hash_multimap< ::Window*, EventDescriptor, WindowHash>
  71 {
  72 };
  73
  74
  75
  76 FocusManager* FocusManager::spInstance = NULL;
  77
  78
  79 FocusManager& FocusManager::Instance (void)
  80 {
  81     if (spInstance == NULL)
  82     {
  83         ::vos::OGuard aGuard (::Application::GetSolarMutex());
  84         if (spInstance == NULL)
  85             spInstance = new FocusManager ();
  86     }
  87     return *spInstance;
  88 }
  89
  90
  91
  92
  93 FocusManager::FocusManager (void)
  94     : mpLinks(new LinkMap())
  95 {
  96 }
  97
  98
  99
 100
 101 FocusManager::~FocusManager (void)
 102 {
 103     Clear();
 104 }
 105
 106
 107
 108
 109 void FocusManager::Clear (void)
 110 {
 111     if (mpLinks.get() != NULL)
 112     {
 113         while ( ! mpLinks->empty())
 114         {
 115             ::Window* pWindow = mpLinks->begin()->first;
 116             if (pWindow == NULL)
 117             {
 118                 mpLinks->erase(mpLinks->begin());
 119             }
 120             else
 121             {
 122                 RemoveLinks(pWindow);
 123             }
 124         }
 125     }
 126 }
 127
 128
 129
 130
 131 void FocusManager::RegisterUpLink (::Window* pSource, ::Window* pTarget)
 132 {
 133     RegisterLink(pSource, pTarget, KEY_ESCAPE);
 134 }
 135
 136
 137
 138
 139 void FocusManager::RegisterDownLink (::Window* pSource, ::Window* pTarget)
 140 {
 141     RegisterLink(pSource, pTarget, KEY_RETURN);
 142 }
 143
 144
 145
 146
 147 void FocusManager::RegisterLink (
 148     ::Window* pSource,
 149     ::Window* pTarget,
 150     const KeyCode& rKey)
 151 {
 152     OSL_ASSERT(pSource!=NULL);
 153     OSL_ASSERT(pTarget!=NULL);
 154
 155     if (pSource==NULL || pTarget==NULL)
 156         return;
 157
 158     // Register this focus manager as event listener at the source window.
 159     if (mpLinks->equal_range(pSource).first == mpLinks->end())
 160         pSource->AddEventListener (LINK (this, FocusManager, WindowEventListener));
 161     mpLinks->insert(LinkMap::value_type(pSource, EventDescriptor(rKey,pTarget)));
 162 }
 163
 164
 165
 166
 167 void FocusManager::RemoveLinks (
 168     ::Window* pSourceWindow,
 169     ::Window* pTargetWindow)
 170 {
 171     OSL_ASSERT(pSourceWindow!=NULL);
 172     OSL_ASSERT(pTargetWindow!=NULL);
 173
 174     if (pSourceWindow==NULL || pTargetWindow==NULL)
 175     {
 176         // This method was called with invalid arguments.  To avoid
 177         // referencing windows that will soon be deleted we clear *all*
 178         // links as an emergency fallback.
 179         Clear();
 180         return;
 181     }
 182
 183     ::std::pair<LinkMap::iterator,LinkMap::iterator> aCandidates;
 184     LinkMap::iterator iCandidate;
 185     bool bLoop (mpLinks->size() > 0);
 186     while (bLoop)
 187     {
 188         aCandidates = mpLinks->equal_range(pSourceWindow);
 189         if (aCandidates.first == mpLinks->end())
 190         {
 191             // No links for the source window found -> nothing more to do.
 192             bLoop = false;
 193         }
 194         else
 195         {
 196             // Set the loop control to false so that when no candidate for
 197             // deletion is found the loop is left.
 198             bLoop = false;
 199             for (iCandidate=aCandidates.first; iCandidate!=aCandidates.second; ++iCandidate)
 200                 if (iCandidate->second.mpTargetWindow == pTargetWindow)
 201                 {
 202                     mpLinks->erase(iCandidate);
 203                     // One link erased.  The iterators have become invalid so
 204                     // start the search for links to delete anew.
 205                     bLoop = true;
 206                     break;
 207                 }
 208         }
 209     }
 210
 211     RemoveUnusedEventListener(pSourceWindow);
 212 }
 213
 214
 215
 216
 217 void FocusManager::RemoveLinks (::Window* pWindow)
 218 {
 219     OSL_ASSERT(pWindow!=NULL);
 220
 221     if (pWindow == NULL)
 222     {
 223         // This method was called with invalid arguments.  To avoid
 224         // referencing windows that will soon be deleted we clear *all*
 225         // links as an emergency fallback.
 226         Clear();
 227         return;
 228     }
 229
 230     // Make sure that we are not called back for the window.
 231     pWindow->RemoveEventListener (LINK (this, FocusManager, WindowEventListener));
 232
 233     // Remove the links from the given window.
 234     ::std::pair<LinkMap::iterator,LinkMap::iterator> aCandidates(mpLinks->equal_range(pWindow));
 235     mpLinks->erase(aCandidates.first, aCandidates.second);
 236
 237     // Remove links to the given window.
 238     bool bLinkRemoved;
 239     do
 240     {
 241         bLinkRemoved = false;
 242         LinkMap::iterator iLink;
 243         for (iLink=mpLinks->begin(); iLink!=mpLinks->end(); ++iLink)
 244         {
 245             if (iLink->second.mpTargetWindow == pWindow)
 246             {
 247                 RemoveUnusedEventListener(iLink->first);
 248                 mpLinks->erase(iLink);
 249                 bLinkRemoved = true;
 250                 break;
 251             }
 252         }
 253     }
 254     while (bLinkRemoved);
 255 }
 256
 257
 258
 259
 260 void FocusManager::RemoveUnusedEventListener (::Window* pWindow)
 261 {
 262     OSL_ASSERT(pWindow!=NULL);
 263
 264     if (pWindow == NULL)
 265         return;
 266
 267     // When there are no more links from the window to another window
 268     // then remove the event listener from the window.
 269     if (mpLinks->find(pWindow) == mpLinks->end())
 270         pWindow->RemoveEventListener (LINK (this, FocusManager, WindowEventListener));
 271 }
 272
 273
 274
 275
 276 bool FocusManager::TransferFocus (
 277     ::Window* pSourceWindow,
 278     const KeyCode& rKeyCode)
 279 {
 280     bool bSuccess (false);
 281
 282     OSL_ASSERT(pSourceWindow!=NULL);
 283     if (pSourceWindow == NULL)
 284         return bSuccess;
 285
 286     ::std::pair<LinkMap::iterator,LinkMap::iterator> aCandidates (
 287         mpLinks->equal_range(pSourceWindow));
 288     LinkMap::const_iterator iCandidate;
 289     for (iCandidate=aCandidates.first; iCandidate!=aCandidates.second; ++iCandidate)
 290         if (iCandidate->second.maKeyCode == rKeyCode)
 291         {
 292             OSL_ASSERT(iCandidate->second.mpTargetWindow != NULL);
 293             iCandidate->second.mpTargetWindow->GrabFocus();
 294             bSuccess = true;
 295             break;
 296         }
 297
 298     return bSuccess;
 299 }
 300
 301
 302
 303
 304 IMPL_LINK(FocusManager, WindowEventListener, VclSimpleEvent*, pEvent)
 305 {
 306     if (pEvent!=NULL && pEvent->ISA(VclWindowEvent))
 307     {
 308         VclWindowEvent* pWindowEvent = static_cast<VclWindowEvent*>(pEvent);
 309         switch (pWindowEvent->GetId())
 310         {
 311             case VCLEVENT_WINDOW_KEYINPUT:
 312             {
 313                 ::Window* pSource = pWindowEvent->GetWindow();
 314                 KeyEvent* pKeyEvent = static_cast<KeyEvent*>(pWindowEvent->GetData());
 315                 TransferFocus(pSource, pKeyEvent->GetKeyCode());
 316             }
 317             break;
 318
 319             case VCLEVENT_OBJECT_DYING:
 320                 RemoveLinks(pWindowEvent->GetWindow());
 321                 break;
 322         }
 323     }
 324     return 1;
 325 }
 326
 327
 328 } } // end of namespace ::sd::toolpanel