sfx2/source/sidebar/FocusManager.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 <o3tl/safeint.hxx>
  21 #include <sfx2/sidebar/FocusManager.hxx>
  22 #include <sfx2/sidebar/Deck.hxx>
  23 #include <sfx2/sidebar/Panel.hxx>
  24 #include <sidebar/DeckTitleBar.hxx>
  25 #include <sidebar/PanelTitleBar.hxx>
  26 #include <sidebar/TitleBar.hxx>
  27 #include <utility>
  28 #include <vcl/event.hxx>
  29 #include <vcl/weld.hxx>
  30
  31 namespace sfx2::sidebar {
  32
  33 FocusManager::FocusLocation::FocusLocation (const PanelComponent eComponent, const sal_Int32 nIndex)
  34     : meComponent(eComponent),
  35       mnIndex(nIndex)
  36 {
  37 }
  38
  39 FocusManager::FocusManager(std::function<void(const Panel&)> aShowPanelFunctor)
  40     : mpDeckTitleBar(nullptr),
  41       maShowPanelFunctor(std::move(aShowPanelFunctor))
  42 {
  43 }
  44
  45 FocusManager::~FocusManager()
  46 {
  47     Clear();
  48 }
  49
  50 void FocusManager::GrabFocus()
  51 {
  52     FocusDeckTitle();
  53 }
  54
  55 void FocusManager::GrabFocusPanel()
  56 {
  57     FocusPanel(0, false);
  58 }
  59
  60 void FocusManager::Clear()
  61 {
  62     SetDeck(nullptr);
  63     ClearPanels();
  64     ClearButtons();
  65 }
  66
  67 void FocusManager::ClearPanels()
  68 {
  69     SharedPanelContainer aPanels;
  70     aPanels.swap(maPanels);
  71     for (auto const& panel : aPanels)
  72     {
  73         if (panel->GetTitleBar())
  74         {
  75             UnregisterWindow(panel->GetTitleBar()->GetToolBox());
  76             UnregisterWindow(panel->GetTitleBar()->GetExpander());
  77         }
  78
  79         weld::Container* pContents = panel->GetContents();
  80         UnregisterWindow(*pContents);
  81     }
  82 }
  83
  84 void FocusManager::ClearButtons()
  85 {
  86     std::vector<weld::Widget*> aButtons;
  87     aButtons.swap(maButtons);
  88     for (auto const& button : aButtons)
  89     {
  90         UnregisterWindow(*button);
  91     }
  92 }
  93
  94 void FocusManager::SetDeck(Deck* pDeck)
  95 {
  96     DeckTitleBar* pDeckTitleBar = pDeck ? pDeck->GetTitleBar() : nullptr;
  97     if (mpDeckTitleBar != nullptr)
  98         UnregisterWindow(mpDeckTitleBar->GetToolBox());
  99     mxDeck = pDeck;
 100     mpDeckTitleBar = pDeckTitleBar;
 101     if (mpDeckTitleBar != nullptr)
 102         RegisterWindow(mpDeckTitleBar->GetToolBox());
 103 }
 104
 105 void FocusManager::SetPanels (const SharedPanelContainer& rPanels)
 106 {
 107     ClearPanels();
 108     for (auto const& panel : rPanels)
 109     {
 110         if (panel->GetTitleBar())
 111         {
 112             RegisterWindow(panel->GetTitleBar()->GetToolBox());
 113             RegisterWindow(panel->GetTitleBar()->GetExpander());
 114         }
 115
 116         // Register also as key event listener at the panel.
 117         weld::Container* pContents = panel->GetContents();
 118         RegisterWindow(*pContents);
 119
 120         maPanels.emplace_back(panel);
 121     }
 122 }
 123
 124 void FocusManager::SetButtons(const std::vector<weld::Widget*>& rButtons)
 125 {
 126     ClearButtons();
 127     for (auto const& button : rButtons)
 128     {
 129         RegisterWindow(*button);
 130         maButtons.emplace_back(button);
 131     }
 132 }
 133
 134 void FocusManager::RegisterWindow(weld::Widget& rWidget)
 135 {
 136     UnregisterWindow(rWidget); // explicitly unset key press handler so we can reconnect without warnings
 137     rWidget.connect_key_press(LINK(this, FocusManager, KeyInputHdl));
 138 }
 139
 140 void FocusManager::UnregisterWindow(weld::Widget& rWidget)
 141 {
 142     rWidget.connect_key_press(Link<const KeyEvent&, bool>());
 143 }
 144
 145 FocusManager::FocusLocation FocusManager::GetFocusLocation() const
 146 {
 147     // Check the deck title.
 148     if (mpDeckTitleBar && mpDeckTitleBar->GetToolBox().has_focus())
 149         return FocusLocation(PC_DeckToolBox, -1);
 150
 151     // Search the panels.
 152     for (size_t nIndex = 0; nIndex < maPanels.size(); ++nIndex)
 153     {
 154         PanelTitleBar* pTitleBar = maPanels[nIndex]->GetTitleBar();
 155         if (!pTitleBar)
 156             continue;
 157         if (pTitleBar->GetExpander().has_focus())
 158             return FocusLocation(PC_PanelTitle, nIndex);
 159         if (pTitleBar->GetToolBox().has_focus())
 160             return FocusLocation(PC_PanelToolBox, nIndex);
 161         weld::Container* pContents = maPanels[nIndex]->GetContents();
 162         if (pContents->has_child_focus())
 163             return FocusLocation(PC_PanelContent, nIndex);
 164     }
 165
 166     // Search the buttons.
 167     for (size_t nIndex=0; nIndex < maButtons.size(); ++nIndex)
 168     {
 169         if (maButtons[nIndex]->has_focus())
 170             return FocusLocation(PC_TabBar, nIndex);
 171     }
 172     return FocusLocation(PC_None, -1);
 173 }
 174
 175 void FocusManager::FocusDeckTitle()
 176 {
 177     if (mpDeckTitleBar != nullptr)
 178     {
 179         if (mpDeckTitleBar->GetToolBox().get_n_items() > 0)
 180         {
 181             weld::Toolbar& rToolBox = mpDeckTitleBar->GetToolBox();
 182             rToolBox.grab_focus();
 183         }
 184         else
 185             FocusPanel(0, false);
 186     }
 187     else
 188         FocusPanel(0, false);
 189 }
 190
 191 bool FocusManager::IsDeckTitleVisible() const
 192 {
 193     return mpDeckTitleBar != nullptr && mpDeckTitleBar->GetVisible();
 194 }
 195
 196 void FocusManager::FocusPanel (
 197     const sal_Int32 nPanelIndex,
 198     const bool bFallbackToDeckTitle)
 199 {
 200     if (nPanelIndex<0 || o3tl::make_unsigned(nPanelIndex)>=maPanels.size())
 201     {
 202         if (bFallbackToDeckTitle)
 203             FocusDeckTitle();
 204         return;
 205     }
 206
 207     Panel& rPanel (*maPanels[nPanelIndex]);
 208     PanelTitleBar* pTitleBar = rPanel.GetTitleBar();
 209     if (pTitleBar && pTitleBar->GetVisible())
 210     {
 211         rPanel.SetExpanded(true);
 212         pTitleBar->GetExpander().grab_focus();
 213     }
 214     // Fallback to deck title should only be applicable when there is more than one panel,
 215     // or else it will never be possible to enter the panel contents when there's a single panel
 216     // without a titlebar and expander
 217     else if (bFallbackToDeckTitle && maPanels.size() > 1)
 218     {
 219         // The panel title is not visible, fall back to the deck
 220         // title.
 221         // Make sure that the desk title is visible here to prevent a
 222         // loop when both the title of panel 0 and the deck title are
 223         // not present.
 224         if (IsDeckTitleVisible())
 225             FocusDeckTitle();
 226         else
 227             FocusPanelContent(nPanelIndex);
 228     }
 229     else
 230         FocusPanelContent(nPanelIndex);
 231
 232     if (maShowPanelFunctor)
 233         maShowPanelFunctor(rPanel);
 234 }
 235
 236 void FocusManager::FocusPanelContent(const sal_Int32 nPanelIndex)
 237 {
 238     if (!maPanels[nPanelIndex]->IsExpanded())
 239         maPanels[nPanelIndex]->SetExpanded(true);
 240
 241     weld::Container* pContents = maPanels[nPanelIndex]->GetContents();
 242     pContents->child_grab_focus();
 243 }
 244
 245 void FocusManager::FocusButton (const sal_Int32 nButtonIndex)
 246 {
 247     maButtons[nButtonIndex]->grab_focus();
 248 }
 249
 250 void FocusManager::MoveFocusInsidePanel (
 251     const FocusLocation& rFocusLocation,
 252     const sal_Int32 nDirection)
 253 {
 254     const bool bHasToolBoxItem (
 255         maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().get_n_items() > 0);
 256     switch (rFocusLocation.meComponent)
 257     {
 258         case  PC_PanelTitle:
 259             if (nDirection > 0 && bHasToolBoxItem)
 260                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().grab_focus();
 261             else
 262                 FocusPanelContent(rFocusLocation.mnIndex);
 263             break;
 264
 265         case PC_PanelToolBox:
 266             if (nDirection < 0 && bHasToolBoxItem)
 267                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetExpander().grab_focus();
 268             else
 269                 FocusPanelContent(rFocusLocation.mnIndex);
 270             break;
 271
 272         default: break;
 273     }
 274 }
 275
 276 bool FocusManager::HandleKeyEvent(
 277     const vcl::KeyCode& rKeyCode,
 278     const FocusLocation& aLocation)
 279 {
 280     bool bConsumed = false;
 281
 282     switch (rKeyCode.GetCode())
 283     {
 284         case KEY_ESCAPE:
 285             switch (aLocation.meComponent)
 286             {
 287                 case PC_TabBar:
 288                 case PC_DeckToolBox:
 289                 case PC_PanelTitle:
 290                 case PC_PanelToolBox:
 291                 {
 292                     if (mxDeck)
 293                     {
 294                         mxDeck->GrabFocusToDocument();
 295                         bConsumed = true;
 296                     }
 297                     break;
 298                 }
 299                 case PC_PanelContent:
 300                     // Return focus to tab bar sidebar settings button or panel title.
 301                     if ((!IsDeckTitleVisible() && maPanels.size() == 1) ||
 302                         (!maPanels[aLocation.mnIndex]->GetTitleBar()->GetVisible()))
 303                         FocusButton(0);
 304                     else
 305                         FocusPanel(aLocation.mnIndex, true);
 306
 307                     bConsumed = true;
 308                     break;
 309                 default:
 310                     break;
 311             }
 312             return bConsumed;
 313
 314         case KEY_RETURN:
 315             switch (aLocation.meComponent)
 316             {
 317                 case PC_PanelTitle:
 318                     // Enter the panel.
 319                     FocusPanelContent(aLocation.mnIndex);
 320                     bConsumed = true;
 321                     break;
 322
 323                 default:
 324                     break;
 325             }
 326             return bConsumed;
 327
 328         case KEY_TAB:
 329         {
 330             const sal_Int32 nDirection (
 331                 rKeyCode.IsShift()
 332                     ? -1
 333                     : +1);
 334             switch (aLocation.meComponent)
 335             {
 336                 case PC_PanelTitle:
 337                 case PC_PanelToolBox:
 338                     if (rKeyCode.IsShift())
 339                         break;
 340                     MoveFocusInsidePanel(aLocation, nDirection);
 341                     bConsumed = true;
 342                     break;
 343
 344                 case PC_DeckToolBox:
 345                     {
 346                         // Moves to the first deck activation button that is visible and sensitive
 347                         sal_Int32 nIndex(0);
 348                         sal_Int32 nButtons(maButtons.size());
 349                         if (nButtons > 1)
 350                         {
 351                             nIndex = 1;
 352                             // Finds the next visible button that is sensitive
 353                             while((!maButtons[nIndex]->get_visible() ||
 354                                    !maButtons[nIndex]->get_sensitive()) && ++nIndex < nButtons);
 355                             // Wrap to the menu button when going past the last button
 356                             if (nIndex >= nButtons)
 357                                 nIndex = 0;
 358                         }
 359                         FocusButton(nIndex);
 360                         bConsumed = true;
 361                     }
 362                     break;
 363
 364                 case PC_TabBar:
 365                     if (rKeyCode.IsShift())
 366                     {
 367                         if (IsDeckTitleVisible())
 368                             FocusDeckTitle();
 369                         else
 370                             FocusPanel(0, true);
 371                     }
 372                     else
 373                         FocusPanel(0, true);
 374                     bConsumed = true;
 375                     break;
 376
 377                 default:
 378                     break;
 379             }
 380             break;
 381         }
 382
 383         case KEY_LEFT:
 384         case KEY_UP:
 385             switch (aLocation.meComponent)
 386             {
 387                 case PC_PanelTitle:
 388                 case PC_PanelToolBox:
 389                     // Go to previous panel or the deck title.
 390                     if (aLocation.mnIndex > 0)
 391                         FocusPanel(aLocation.mnIndex-1, true);
 392                     else if (IsDeckTitleVisible())
 393                         FocusDeckTitle();
 394                     else
 395                     {
 396                         // Set focus to the last visible sensitive button.
 397                         sal_Int32 nIndex(maButtons.size()-1);
 398                         while((!maButtons[nIndex]->get_visible() ||
 399                                !maButtons[nIndex]->get_sensitive()) && --nIndex > 0);
 400                         FocusButton(nIndex);
 401                     }
 402                     bConsumed = true;
 403                     break;
 404
 405                 case PC_TabBar:
 406                     {
 407                         if (rKeyCode.GetCode() == KEY_LEFT)
 408                             break;
 409
 410                         sal_Int32 nIndex;
 411                         if (aLocation.mnIndex <= 0)
 412                             nIndex = maButtons.size() - 1;
 413                         else
 414                             nIndex = aLocation.mnIndex - 1;
 415
 416                         // Finds the previous visible sensitive button
 417                         while((!maButtons[nIndex]->get_visible() ||
 418                                !maButtons[nIndex]->get_sensitive()) && --nIndex > 0);
 419                         FocusButton(nIndex);
 420                         bConsumed = true;
 421                     }
 422                     break;
 423
 424                 default:
 425                     break;
 426             }
 427             break;
 428
 429         case KEY_RIGHT:
 430         case KEY_DOWN:
 431             switch(aLocation.meComponent)
 432             {
 433                 case PC_PanelTitle:
 434                 case PC_PanelToolBox:
 435                     // Go to next panel.
 436                     if (aLocation.mnIndex < static_cast<sal_Int32>(maPanels.size())-1)
 437                         FocusPanel(aLocation.mnIndex+1, false);
 438                     else
 439                         FocusButton(0);
 440                     bConsumed = true;
 441                     break;
 442
 443                 case PC_TabBar:
 444                     {
 445                         if (rKeyCode.GetCode() == KEY_RIGHT)
 446                             break;
 447
 448                         sal_Int32 nButtons(maButtons.size());
 449
 450                         sal_Int32 nIndex = aLocation.mnIndex + 1;
 451                         if (nIndex >= nButtons)
 452                             nIndex = 0;
 453
 454                         // Finds the next visible sensitive button
 455                         while((!maButtons[nIndex]->get_visible() ||
 456                                !maButtons[nIndex]->get_sensitive()) && ++nIndex < nButtons);
 457                         // Wrap to the menu button when going past the last button
 458                         if (nIndex >= nButtons)
 459                             nIndex = 0;
 460                         FocusButton(nIndex);
 461                         bConsumed = true;
 462                     }
 463                     break;
 464
 465                 default:
 466                     break;
 467             }
 468             break;
 469     }
 470     return bConsumed;
 471 }
 472
 473 IMPL_LINK(FocusManager, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 474 {
 475     return HandleKeyEvent(rKeyEvent.GetKeyCode(), GetFocusLocation());
 476 }
 477
 478 } // end of namespace sfx2::sidebar
 479
 480 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */