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 bool FocusManager::IsPanelTitleVisible (const sal_Int32 nPanelIndex) const
 197 {
 198     if (nPanelIndex<0 || o3tl::make_unsigned(nPanelIndex)>=maPanels.size())
 199         return false;
 200
 201     TitleBar* pTitleBar = maPanels[nPanelIndex]->GetTitleBar();
 202     if (!pTitleBar)
 203         return false;
 204     return pTitleBar->GetVisible();
 205 }
 206
 207 void FocusManager::FocusPanel (
 208     const sal_Int32 nPanelIndex,
 209     const bool bFallbackToDeckTitle)
 210 {
 211     if (nPanelIndex<0 || o3tl::make_unsigned(nPanelIndex)>=maPanels.size())
 212     {
 213         if (bFallbackToDeckTitle)
 214             FocusDeckTitle();
 215         return;
 216     }
 217
 218     Panel& rPanel (*maPanels[nPanelIndex]);
 219     PanelTitleBar* pTitleBar = rPanel.GetTitleBar();
 220     if (pTitleBar && pTitleBar->GetVisible())
 221     {
 222         rPanel.SetExpanded(true);
 223         pTitleBar->GetExpander().grab_focus();
 224     }
 225     else if (bFallbackToDeckTitle)
 226     {
 227         // The panel title is not visible, fall back to the deck
 228         // title.
 229         // Make sure that the desk title is visible here to prevent a
 230         // loop when both the title of panel 0 and the deck title are
 231         // not present.
 232         if (IsDeckTitleVisible())
 233             FocusDeckTitle();
 234         else
 235             FocusPanelContent(nPanelIndex);
 236     }
 237     else
 238         FocusPanelContent(nPanelIndex);
 239
 240     if (maShowPanelFunctor)
 241         maShowPanelFunctor(rPanel);
 242 }
 243
 244 void FocusManager::FocusPanelContent(const sal_Int32 nPanelIndex)
 245 {
 246     if (!maPanels[nPanelIndex]->IsExpanded())
 247         maPanels[nPanelIndex]->SetExpanded(true);
 248
 249     weld::Container* pContents = maPanels[nPanelIndex]->GetContents();
 250     pContents->child_grab_focus();
 251 }
 252
 253 void FocusManager::FocusButton (const sal_Int32 nButtonIndex)
 254 {
 255     maButtons[nButtonIndex]->grab_focus();
 256 }
 257
 258 void FocusManager::MoveFocusInsidePanel (
 259     const FocusLocation& rFocusLocation,
 260     const sal_Int32 nDirection)
 261 {
 262     const bool bHasToolBoxItem (
 263         maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().get_n_items() > 0);
 264     switch (rFocusLocation.meComponent)
 265     {
 266         case  PC_PanelTitle:
 267             if (nDirection > 0 && bHasToolBoxItem)
 268                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().grab_focus();
 269             else
 270                 FocusPanelContent(rFocusLocation.mnIndex);
 271             break;
 272
 273         case PC_PanelToolBox:
 274             if (nDirection < 0 && bHasToolBoxItem)
 275                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetExpander().grab_focus();
 276             else
 277                 FocusPanelContent(rFocusLocation.mnIndex);
 278             break;
 279
 280         default: break;
 281     }
 282 }
 283
 284 bool FocusManager::MoveFocusInsideDeckTitle (
 285     const FocusLocation& rFocusLocation,
 286     const sal_Int32 nDirection)
 287 {
 288     bool bConsumed = false;
 289     // Note that when the title bar of the first (and only) panel is
 290     // not visible then the deck title takes its place and the focus
 291     // is moved between a) deck closer and b) content of panel 0.
 292     switch (rFocusLocation.meComponent)
 293     {
 294         case PC_DeckToolBox:
 295             if (nDirection>0 && ! IsPanelTitleVisible(0))
 296             {
 297                 FocusPanelContent(0);
 298                 bConsumed = true;
 299             }
 300             else if (nDirection < 0)
 301             {
 302                 FocusButton(0);
 303                 bConsumed = true;
 304             }
 305             break;
 306
 307         default: break;
 308     }
 309     return bConsumed;
 310 }
 311
 312 bool FocusManager::HandleKeyEvent(
 313     const vcl::KeyCode& rKeyCode,
 314     const FocusLocation& aLocation)
 315 {
 316     bool bConsumed = false;
 317
 318     switch (rKeyCode.GetCode())
 319     {
 320         case KEY_ESCAPE:
 321             switch (aLocation.meComponent)
 322             {
 323                 case PC_TabBar:
 324                 case PC_DeckToolBox:
 325                 case PC_PanelTitle:
 326                 case PC_PanelToolBox:
 327                 {
 328                     if (mxDeck)
 329                     {
 330                         mxDeck->GrabFocusToDocument();
 331                         bConsumed = true;
 332                     }
 333                     break;
 334                 }
 335                 case PC_PanelContent:
 336                     // Return focus to tab bar sidebar settings button or panel title.
 337                     if (!IsDeckTitleVisible() && maPanels.size() == 1)
 338                         FocusButton(0);
 339                     else
 340                         FocusPanel(aLocation.mnIndex, true);
 341                     bConsumed = true;
 342                     break;
 343                 default:
 344                     break;
 345             }
 346             return bConsumed;
 347
 348         case KEY_RETURN:
 349             switch (aLocation.meComponent)
 350             {
 351                 case PC_DeckToolBox:
 352                     FocusButton(0);
 353                     bConsumed = true;
 354                     break;
 355
 356                 case PC_PanelTitle:
 357                     // Enter the panel.
 358                     FocusPanelContent(aLocation.mnIndex);
 359                     bConsumed = true;
 360                     break;
 361
 362                 default:
 363                     break;
 364             }
 365             return bConsumed;
 366
 367         case KEY_TAB:
 368         {
 369             const sal_Int32 nDirection (
 370                 rKeyCode.IsShift()
 371                     ? -1
 372                     : +1);
 373             switch (aLocation.meComponent)
 374             {
 375                 case PC_PanelTitle:
 376                 case PC_PanelToolBox:
 377                     if (rKeyCode.IsShift())
 378                         break;
 379                     MoveFocusInsidePanel(aLocation, nDirection);
 380                     bConsumed = true;
 381                     break;
 382
 383                 case PC_DeckToolBox:
 384                     bConsumed = MoveFocusInsideDeckTitle(aLocation, nDirection);
 385                     break;
 386
 387                 case PC_TabBar:
 388                     if (rKeyCode.IsShift())
 389                         FocusPanel(maPanels.size()-1, true);
 390                     else
 391                     {
 392                         if (IsDeckTitleVisible())
 393                             FocusDeckTitle();
 394                         else
 395                             FocusPanel(0, true);
 396                     }
 397                     bConsumed = true;
 398                     break;
 399
 400                 default:
 401                     break;
 402             }
 403             break;
 404         }
 405
 406         case KEY_LEFT:
 407         case KEY_UP:
 408             switch (aLocation.meComponent)
 409             {
 410                 case PC_PanelTitle:
 411                 case PC_PanelToolBox:
 412                     // Go to previous panel or the deck title.
 413                     if (aLocation.mnIndex > 0)
 414                         FocusPanel(aLocation.mnIndex-1, true);
 415                     else if (IsDeckTitleVisible())
 416                         FocusDeckTitle();
 417                     else
 418                     {
 419                         // Focus the last button.
 420                         sal_Int32 nIndex(maButtons.size()-1);
 421                         while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 422                         FocusButton(nIndex);
 423                     }
 424                     bConsumed = true;
 425                     break;
 426
 427                 case PC_DeckToolBox:
 428                 {
 429                     // Focus the last button.
 430                     sal_Int32 nIndex(maButtons.size()-1);
 431                     while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 432                     FocusButton(nIndex);
 433                     bConsumed = true;
 434                     break;
 435                 }
 436
 437                 case PC_TabBar:
 438                     // Go to previous tab bar item.
 439                     if (aLocation.mnIndex == 0)
 440                         FocusPanel(maPanels.size()-1, true);
 441                     else
 442                     {
 443                         sal_Int32 nIndex((aLocation.mnIndex + maButtons.size() - 1) % maButtons.size());
 444                         while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 445                         FocusButton(nIndex);
 446                     }
 447                     bConsumed = true;
 448                     break;
 449
 450                 default:
 451                     break;
 452             }
 453             break;
 454
 455         case KEY_RIGHT:
 456         case KEY_DOWN:
 457             switch(aLocation.meComponent)
 458             {
 459                 case PC_PanelTitle:
 460                 case PC_PanelToolBox:
 461                     // Go to next panel.
 462                     if (aLocation.mnIndex < static_cast<sal_Int32>(maPanels.size())-1)
 463                         FocusPanel(aLocation.mnIndex+1, false);
 464                     else
 465                         FocusButton(0);
 466                     bConsumed = true;
 467                     break;
 468
 469                 case PC_DeckToolBox:
 470                     // Focus the first panel.
 471                     if (IsPanelTitleVisible(0))
 472                         FocusPanel(0, false);
 473                     else
 474                         FocusButton(0);
 475                     bConsumed = true;
 476                     break;
 477
 478                 case PC_TabBar:
 479                     // Go to next tab bar item.
 480                     if (aLocation.mnIndex < static_cast<sal_Int32>(maButtons.size())-1)
 481                     {
 482                         sal_Int32 nIndex(aLocation.mnIndex + 1);
 483                         while(!maButtons[nIndex]->get_visible() && ++nIndex < static_cast<sal_Int32>(maButtons.size()));
 484                         if (nIndex < static_cast<sal_Int32>(maButtons.size()))
 485                         {
 486                             FocusButton(nIndex);
 487                             bConsumed = true;
 488                             break;
 489                         }
 490                     }
 491                     if (IsDeckTitleVisible())
 492                         FocusDeckTitle();
 493                     else
 494                         FocusPanel(0, true);
 495                     bConsumed = true;
 496                     break;
 497
 498                 default:
 499                     break;
 500             }
 501             break;
 502     }
 503     return bConsumed;
 504 }
 505
 506 IMPL_LINK(FocusManager, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 507 {
 508     return HandleKeyEvent(rKeyEvent.GetKeyCode(), GetFocusLocation());
 509 }
 510
 511 } // end of namespace sfx2::sidebar
 512
 513 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */