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