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 <sfx2/sidebar/FocusManager.hxx>
  21 #include <sfx2/sidebar/Panel.hxx>
  22 #include <sidebar/DeckTitleBar.hxx>
  23 #include <sidebar/PanelTitleBar.hxx>
  24 #include <sidebar/TitleBar.hxx>
  25 #include <vcl/event.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <toolkit/helper/vclunohelper.hxx>
  28
  29 namespace sfx2::sidebar {
  30
  31 FocusManager::FocusLocation::FocusLocation (const PanelComponent eComponent, const sal_Int32 nIndex)
  32     : meComponent(eComponent),
  33       mnIndex(nIndex)
  34 {
  35 }
  36
  37 FocusManager::FocusManager(const std::function<void(const Panel&)>& rShowPanelFunctor)
  38     : mpDeckTitleBar(),
  39       maPanels(),
  40       maButtons(),
  41       maShowPanelFunctor(rShowPanelFunctor)
  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     SetDeckTitle(nullptr);
  63     ClearPanels();
  64     ClearButtons();
  65 }
  66
  67 void FocusManager::ClearPanels()
  68 {
  69     std::vector<VclPtr<Panel> > 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         panel->RemoveChildEventListener(LINK(this, FocusManager, ChildEventListener));
  80     }
  81 }
  82
  83 void FocusManager::ClearButtons()
  84 {
  85     std::vector<weld::Widget*> aButtons;
  86     aButtons.swap(maButtons);
  87     for (auto const& button : aButtons)
  88     {
  89         UnregisterWindow(*button);
  90     }
  91 }
  92
  93 void FocusManager::SetDeckTitle (DeckTitleBar* pDeckTitleBar)
  94 {
  95     if (mpDeckTitleBar != nullptr)
  96         UnregisterWindow(mpDeckTitleBar->GetToolBox());
  97     mpDeckTitleBar = pDeckTitleBar;
  98
  99     if (mpDeckTitleBar != nullptr)
 100         RegisterWindow(mpDeckTitleBar->GetToolBox());
 101 }
 102
 103 void FocusManager::SetPanels (const SharedPanelContainer& rPanels)
 104 {
 105     ClearPanels();
 106     for (auto const& panel : rPanels)
 107     {
 108         if (panel->GetTitleBar())
 109         {
 110             RegisterWindow(panel->GetTitleBar()->GetToolBox());
 111             RegisterWindow(panel->GetTitleBar()->GetExpander());
 112         }
 113
 114         // Register also as child event listener at the panel.
 115         panel->AddChildEventListener(LINK(this, FocusManager, ChildEventListener));
 116
 117         maPanels.emplace_back(panel.get());
 118     }
 119 }
 120
 121 void FocusManager::SetButtons(const std::vector<weld::Widget*>& rButtons)
 122 {
 123     ClearButtons();
 124     for (auto const& button : rButtons)
 125     {
 126         RegisterWindow(*button);
 127         maButtons.emplace_back(button);
 128     }
 129 }
 130
 131 void FocusManager::RegisterWindow(weld::Widget& rWidget)
 132 {
 133     UnregisterWindow(rWidget); // explicitly unset key press handler so we can reconnect without warnings
 134     rWidget.connect_key_press(LINK(this, FocusManager, KeyInputHdl));
 135 }
 136
 137 void FocusManager::UnregisterWindow(weld::Widget& rWidget)
 138 {
 139     rWidget.connect_key_press(Link<const KeyEvent&, bool>());
 140 }
 141
 142 FocusManager::FocusLocation FocusManager::GetFocusLocation (const vcl::Window& rWindow) const
 143 {
 144     // Search the panels.
 145     for (size_t nIndex = 0; nIndex < maPanels.size(); ++nIndex)
 146     {
 147         if (maPanels[nIndex] == &rWindow)
 148             return FocusLocation(PC_PanelContent, nIndex);
 149         VclPtr<TitleBar> pTitleBar = maPanels[nIndex]->GetTitleBar();
 150         if (pTitleBar == &rWindow)
 151             return FocusLocation(PC_PanelTitle, nIndex);
 152     }
 153
 154     return FocusLocation(PC_None, -1);
 155 }
 156
 157 FocusManager::FocusLocation FocusManager::GetFocusLocation() const
 158 {
 159     // Check the deck title.
 160     if (mpDeckTitleBar && mpDeckTitleBar->GetToolBox().has_focus())
 161         return FocusLocation(PC_DeckToolBox, -1);
 162
 163     // Search the panels.
 164     for (size_t nIndex = 0; nIndex < maPanels.size(); ++nIndex)
 165     {
 166         VclPtr<PanelTitleBar> pTitleBar = maPanels[nIndex]->GetTitleBar();
 167         if (!pTitleBar)
 168             continue;
 169         if (pTitleBar->GetExpander().has_focus())
 170             return FocusLocation(PC_PanelTitle, nIndex);
 171         if (pTitleBar->GetToolBox().has_focus())
 172             return FocusLocation(PC_PanelToolBox, nIndex);
 173     }
 174
 175     // Search the buttons.
 176     for (size_t nIndex=0; nIndex < maButtons.size(); ++nIndex)
 177     {
 178         if (maButtons[nIndex]->has_focus())
 179             return FocusLocation(PC_TabBar, nIndex);
 180     }
 181     return FocusLocation(PC_None, -1);
 182 }
 183
 184 void FocusManager::FocusDeckTitle()
 185 {
 186     if (mpDeckTitleBar != nullptr)
 187     {
 188         if (mpDeckTitleBar->GetToolBox().get_n_items() > 0)
 189         {
 190             weld::Toolbar& rToolBox = mpDeckTitleBar->GetToolBox();
 191             rToolBox.grab_focus();
 192         }
 193         else
 194             FocusPanel(0, false);
 195     }
 196     else
 197         FocusPanel(0, false);
 198 }
 199
 200 bool FocusManager::IsDeckTitleVisible() const
 201 {
 202     return mpDeckTitleBar != nullptr && mpDeckTitleBar->IsVisible();
 203 }
 204
 205 bool FocusManager::IsPanelTitleVisible (const sal_Int32 nPanelIndex) const
 206 {
 207     if (nPanelIndex<0 || nPanelIndex>=static_cast<sal_Int32>(maPanels.size()))
 208         return false;
 209
 210     VclPtr<TitleBar> pTitleBar = maPanels[nPanelIndex]->GetTitleBar();
 211     if (!pTitleBar)
 212         return false;
 213     return pTitleBar->IsVisible();
 214 }
 215
 216 void FocusManager::FocusPanel (
 217     const sal_Int32 nPanelIndex,
 218     const bool bFallbackToDeckTitle)
 219 {
 220     if (nPanelIndex<0 || nPanelIndex>=static_cast<sal_Int32>(maPanels.size()))
 221     {
 222         if (bFallbackToDeckTitle)
 223             FocusDeckTitle();
 224         return;
 225     }
 226
 227     Panel& rPanel (*maPanels[nPanelIndex]);
 228     VclPtr<PanelTitleBar> pTitleBar = rPanel.GetTitleBar();
 229     if (pTitleBar && pTitleBar->IsVisible())
 230     {
 231         rPanel.SetExpanded(true);
 232         pTitleBar->GetExpander().grab_focus();
 233     }
 234     else if (bFallbackToDeckTitle)
 235     {
 236         // The panel title is not visible, fall back to the deck
 237         // title.
 238         // Make sure that the desk title is visible here to prevent a
 239         // loop when both the title of panel 0 and the deck title are
 240         // not present.
 241         if (IsDeckTitleVisible())
 242             FocusDeckTitle();
 243         else
 244             FocusPanelContent(nPanelIndex);
 245     }
 246     else
 247         FocusPanelContent(nPanelIndex);
 248
 249     if (maShowPanelFunctor)
 250         maShowPanelFunctor(rPanel);
 251 }
 252
 253 void FocusManager::FocusPanelContent (const sal_Int32 nPanelIndex)
 254 {
 255     if (!maPanels[nPanelIndex]->IsExpanded())
 256         maPanels[nPanelIndex]->SetExpanded(true);
 257
 258     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(maPanels[nPanelIndex]->GetElementWindow());
 259     if (pWindow)
 260         pWindow->GrabFocus();
 261 }
 262
 263 void FocusManager::FocusButton (const sal_Int32 nButtonIndex)
 264 {
 265     maButtons[nButtonIndex]->grab_focus();
 266 }
 267
 268 void FocusManager::RemoveWindow (vcl::Window& rWindow)
 269 {
 270     auto iPanel (::std::find(maPanels.begin(), maPanels.end(), &rWindow));
 271     if (iPanel != maPanels.end())
 272     {
 273         if ((*iPanel)->GetTitleBar() != nullptr)
 274         {
 275             UnregisterWindow((*iPanel)->GetTitleBar()->GetToolBox());
 276             UnregisterWindow((*iPanel)->GetTitleBar()->GetExpander());
 277         }
 278         maPanels.erase(iPanel);
 279         return;
 280     }
 281 }
 282
 283 void FocusManager::MoveFocusInsidePanel (
 284     const FocusLocation& rFocusLocation,
 285     const sal_Int32 nDirection)
 286 {
 287     const bool bHasToolBoxItem (
 288         maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().get_n_items() > 0);
 289     switch (rFocusLocation.meComponent)
 290     {
 291         case  PC_PanelTitle:
 292             if (nDirection > 0 && bHasToolBoxItem)
 293                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().grab_focus();
 294             else
 295                 FocusPanelContent(rFocusLocation.mnIndex);
 296             break;
 297
 298         case PC_PanelToolBox:
 299             if (nDirection < 0 && bHasToolBoxItem)
 300                 maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetExpander().grab_focus();
 301             else
 302                 FocusPanelContent(rFocusLocation.mnIndex);
 303             break;
 304
 305         default: break;
 306     }
 307 }
 308
 309 void FocusManager::MoveFocusInsideDeckTitle (
 310     const FocusLocation& rFocusLocation,
 311     const sal_Int32 nDirection)
 312 {
 313     // Note that when the title bar of the first (and only) panel is
 314     // not visible then the deck title takes its place and the focus
 315     // is moved between a) deck closer and b) content of panel 0.
 316     switch (rFocusLocation.meComponent)
 317     {
 318         case PC_DeckToolBox:
 319             if (nDirection>0 && ! IsPanelTitleVisible(0))
 320                 FocusPanelContent(0);
 321             break;
 322
 323         default: break;
 324     }
 325 }
 326
 327 bool FocusManager::HandleKeyEvent(
 328     const vcl::KeyCode& rKeyCode,
 329     const FocusLocation& aLocation)
 330 {
 331     bool bConsumed = false;
 332
 333     switch (rKeyCode.GetCode())
 334     {
 335         case KEY_ESCAPE:
 336             switch (aLocation.meComponent)
 337             {
 338                 case PC_TabBar:
 339                 case PC_DeckToolBox:
 340                 case PC_PanelTitle:
 341                 case PC_PanelToolBox:
 342                 {
 343                     vcl::Window* pFocusWin = Application::GetFocusWindow();
 344                     if (pFocusWin)
 345                     {
 346                         pFocusWin->GrabFocusToDocument();
 347                         bConsumed = true;
 348                     }
 349                     break;
 350                 }
 351
 352                 default:
 353                     break;
 354             }
 355             return bConsumed;
 356
 357         case KEY_RETURN:
 358             switch (aLocation.meComponent)
 359             {
 360                 case PC_DeckToolBox:
 361                     FocusButton(0);
 362                     bConsumed = true;
 363                     break;
 364
 365                 case PC_PanelTitle:
 366                     // Enter the panel.
 367                     FocusPanelContent(aLocation.mnIndex);
 368                     bConsumed = true;
 369                     break;
 370
 371                 default:
 372                     break;
 373             }
 374             return bConsumed;
 375
 376         case KEY_TAB:
 377         {
 378             const sal_Int32 nDirection (
 379                 rKeyCode.IsShift()
 380                     ? -1
 381                     : +1);
 382             switch (aLocation.meComponent)
 383             {
 384                 case PC_PanelTitle:
 385                 case PC_PanelToolBox:
 386                 case PC_PanelContent:
 387                     MoveFocusInsidePanel(aLocation, nDirection);
 388                     bConsumed = true;
 389                     break;
 390
 391                 case PC_DeckToolBox:
 392                     MoveFocusInsideDeckTitle(aLocation, nDirection);
 393                     bConsumed = true;
 394                     break;
 395
 396                 default:
 397                     break;
 398             }
 399             break;
 400         }
 401
 402         case KEY_LEFT:
 403         case KEY_UP:
 404             switch (aLocation.meComponent)
 405             {
 406                 case PC_PanelTitle:
 407                 case PC_PanelToolBox:
 408                 case PC_PanelContent:
 409                     // Go to previous panel or the deck title.
 410                     if (aLocation.mnIndex > 0)
 411                         FocusPanel(aLocation.mnIndex-1, true);
 412                     else if (IsDeckTitleVisible())
 413                         FocusDeckTitle();
 414                     else
 415                     {
 416                         // Focus the last button.
 417                         sal_Int32 nIndex(maButtons.size()-1);
 418                         while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 419                         FocusButton(nIndex);
 420                     }
 421                     bConsumed = true;
 422                     break;
 423
 424                 case PC_DeckToolBox:
 425                 {
 426                     // Focus the last button.
 427                     sal_Int32 nIndex(maButtons.size()-1);
 428                     while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 429                     FocusButton(nIndex);
 430                     bConsumed = true;
 431                     break;
 432                 }
 433
 434                 case PC_TabBar:
 435                     // Go to previous tab bar item.
 436                     if (aLocation.mnIndex == 0)
 437                         FocusPanel(maPanels.size()-1, true);
 438                     else
 439                     {
 440                         sal_Int32 nIndex((aLocation.mnIndex + maButtons.size() - 1) % maButtons.size());
 441                         while(!maButtons[nIndex]->get_visible() && --nIndex > 0);
 442                         FocusButton(nIndex);
 443                     }
 444                     bConsumed = true;
 445                     break;
 446
 447                 default:
 448                     break;
 449             }
 450             break;
 451
 452         case KEY_RIGHT:
 453         case KEY_DOWN:
 454             switch(aLocation.meComponent)
 455             {
 456                 case PC_PanelTitle:
 457                 case PC_PanelToolBox:
 458                 case PC_PanelContent:
 459                     // Go to next panel.
 460                     if (aLocation.mnIndex < static_cast<sal_Int32>(maPanels.size())-1)
 461                         FocusPanel(aLocation.mnIndex+1, false);
 462                     else
 463                         FocusButton(0);
 464                     bConsumed = true;
 465                     break;
 466
 467                 case PC_DeckToolBox:
 468                     // Focus the first panel.
 469                     if (IsPanelTitleVisible(0))
 470                         FocusPanel(0, false);
 471                     else
 472                         FocusButton(0);
 473                     bConsumed = true;
 474                     break;
 475
 476                 case PC_TabBar:
 477                     // Go to next tab bar item.
 478                     if (aLocation.mnIndex < static_cast<sal_Int32>(maButtons.size())-1)
 479                     {
 480                         sal_Int32 nIndex(aLocation.mnIndex + 1);
 481                         while(!maButtons[nIndex]->get_visible() && ++nIndex < static_cast<sal_Int32>(maButtons.size()));
 482                         if (nIndex < static_cast<sal_Int32>(maButtons.size()))
 483                         {
 484                             FocusButton(nIndex);
 485                             bConsumed = true;
 486                             break;
 487                         }
 488                     }
 489                     if (IsDeckTitleVisible())
 490                         FocusDeckTitle();
 491                     else
 492                         FocusPanel(0, true);
 493                     bConsumed = true;
 494                     break;
 495
 496                 default:
 497                     break;
 498             }
 499             break;
 500     }
 501     return bConsumed;
 502 }
 503
 504 IMPL_LINK(FocusManager, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 505 {
 506     return HandleKeyEvent(rKeyEvent.GetKeyCode(), GetFocusLocation());
 507 }
 508
 509 IMPL_LINK(FocusManager, ChildEventListener, VclWindowEvent&, rEvent, void)
 510 {
 511     vcl::Window* pSource = rEvent.GetWindow();
 512     if (pSource == nullptr)
 513         return;
 514
 515     switch (rEvent.GetId())
 516     {
 517         case VclEventId::WindowKeyInput:
 518         {
 519             KeyEvent* pKeyEvent = static_cast<KeyEvent*>(rEvent.GetData());
 520
 521             // Go up the window hierarchy to find out whether the
 522             // parent of the event source is known to us.
 523             vcl::Window* pWindow = pSource;
 524             FocusLocation aLocation (PC_None, -1);
 525             while (true)
 526             {
 527                 if (pWindow == nullptr)
 528                     break;
 529                 aLocation = GetFocusLocation(*pWindow);
 530                 if (aLocation.meComponent != PC_None)
 531                     break;
 532                 pWindow = pWindow->GetParent();
 533             }
 534
 535             if (aLocation.meComponent != PC_None)
 536             {
 537                 switch (pKeyEvent->GetKeyCode().GetCode())
 538                 {
 539                     case KEY_ESCAPE:
 540                         // Return focus to tab bar sidebar settings button or panel title.
 541                         if (!IsDeckTitleVisible() && maPanels.size() == 1)
 542                             FocusButton(0);
 543                         else
 544                             FocusPanel(aLocation.mnIndex, true);
 545                         break;
 546
 547                     default:
 548                         break;
 549                 }
 550             }
 551             return;
 552         }
 553
 554         default:
 555             break;
 556     }
 557 }
 558
 559 } // end of namespace sfx2::sidebar
 560
 561 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */