sfx2/source/sidebar/SidebarController.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 #include <sfx2/sidebar/SidebarController.hxx>
  20
  21 #include <boost/property_tree/json_parser.hpp>
  22
  23 #include <sfx2/sidebar/Deck.hxx>
  24 #include <sidebar/DeckDescriptor.hxx>
  25 #include <sidebar/DeckTitleBar.hxx>
  26 #include <sfx2/sidebar/Panel.hxx>
  27 #include <sidebar/PanelDescriptor.hxx>
  28 #include <sidebar/PanelTitleBar.hxx>
  29 #include <sfx2/sidebar/TabBar.hxx>
  30 #include <sfx2/sidebar/Theme.hxx>
  31 #include <sfx2/sidebar/SidebarChildWindow.hxx>
  32 #include <sidebar/Tools.hxx>
  33 #include <sfx2/sidebar/SidebarDockingWindow.hxx>
  34 #include <com/sun/star/ui/XSidebarProvider.hpp>
  35 #include <com/sun/star/frame/XController2.hpp>
  36 #include <sfx2/sidebar/Context.hxx>
  37 #include <sfx2/viewsh.hxx>
  38
  39
  40 #include <framework/ContextChangeEventMultiplexerTunnel.hxx>
  41 #include <vcl/EnumContext.hxx>
  42 #include <vcl/uitest/logger.hxx>
  43 #include <vcl/uitest/eventdescription.hxx>
  44 #include <vcl/svapp.hxx>
  45 #include <splitwin.hxx>
  46 #include <comphelper/diagnose_ex.hxx>
  47 #include <tools/json_writer.hxx>
  48 #include <tools/link.hxx>
  49 #include <toolkit/helper/vclunohelper.hxx>
  50 #include <comphelper/processfactory.hxx>
  51 #include <comphelper/namedvaluecollection.hxx>
  52 #include <comphelper/lok.hxx>
  53 #include <sal/log.hxx>
  54 #include <officecfg/Office/UI/Sidebar.hxx>
  55 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  56 #include <o3tl/string_view.hxx>
  57
  58 #include <com/sun/star/awt/XWindowPeer.hpp>
  59 #include <com/sun/star/frame/XDispatch.hpp>
  60 #include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp>
  61 #include <com/sun/star/ui/ContextChangeEventObject.hpp>
  62 #include <com/sun/star/ui/theUIElementFactoryManager.hpp>
  63 #include <com/sun/star/util/URL.hpp>
  64 #include <com/sun/star/rendering/XSpriteCanvas.hpp>
  65
  66 #include <bitmaps.hlst>
  67
  68 using namespace css;
  69 using namespace css::uno;
  70
  71 namespace
  72 {
  73     constexpr OUString gsReadOnlyCommandName = u".uno:EditDoc"_ustr;
  74     const sal_Int32 gnWidthCloseThreshold (70);
  75     const sal_Int32 gnWidthOpenThreshold (40);
  76
  77     std::string UnoNameFromDeckId(std::u16string_view rsDeckId, const sfx2::sidebar::Context& context)
  78     {
  79         if (rsDeckId == u"SdCustomAnimationDeck")
  80             return ".uno:CustomAnimation";
  81
  82         if (rsDeckId == u"PropertyDeck")
  83             return vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(context.msApplication) ? ".uno:ModifyPage" : ".uno:Sidebar";
  84
  85         if (rsDeckId == u"SdLayoutsDeck")
  86             return ".uno:ModifyPage";
  87
  88         if (rsDeckId == u"SdSlideTransitionDeck")
  89             return ".uno:SlideChangeWindow";
  90
  91         if (rsDeckId == u"SdAllMasterPagesDeck")
  92             return ".uno:MasterSlidesPanel";
  93
  94         if (rsDeckId == u"SdMasterPagesDeck")
  95             return ".uno:MasterSlidesPanel";
  96
  97         if (rsDeckId == u"GalleryDeck")
  98             return ".uno:Gallery";
  99
 100         OString sUno = ".uno:SidebarDeck." + OUStringToOString(rsDeckId, RTL_TEXTENCODING_ASCII_US);
 101         return std::string(sUno);
 102     }
 103 }
 104
 105 namespace sfx2::sidebar {
 106
 107 namespace {
 108
 109     /** When in doubt, show this deck.
 110     */
 111     constexpr OUString gsDefaultDeckId(u"PropertyDeck"_ustr);
 112 }
 113
 114 SidebarController::SidebarController (
 115     SidebarDockingWindow* pParentWindow,
 116     const SfxViewFrame* pViewFrame)
 117     : mpParentWindow(pParentWindow),
 118       mpViewFrame(pViewFrame),
 119       mxFrame(pViewFrame->GetFrame().GetFrameInterface()),
 120       mpTabBar(VclPtr<TabBar>::Create(
 121               mpParentWindow,
 122               mxFrame,
 123               [this](const OUString& rsDeckId) { return this->OpenThenToggleDeck(rsDeckId); },
 124               [this](weld::Menu& rMainMenu, weld::Menu& rSubMenu) { return this->ConnectMenuActivateHandlers(rMainMenu, rSubMenu); },
 125               *this)),
 126       maCurrentContext(OUString(), OUString()),
 127       maRequestedContext(OUString(), OUString()),
 128       mnRequestedForceFlags(SwitchFlag_NoForce),
 129       mbMinimumSidebarWidth(officecfg::Office::UI::Sidebar::General::MinimumWidth::get()),
 130       msCurrentDeckId(gsDefaultDeckId),
 131       maPropertyChangeForwarder(mpViewFrame, [this](){ return this->BroadcastPropertyChange(); }),
 132       maContextChangeUpdate(mpViewFrame, [this](){ return this->UpdateConfigurations(); }),
 133       mbFloatingDeckClosed(!pParentWindow->IsFloatingMode()),
 134       mnSavedSidebarWidth(pParentWindow->GetSizePixel().Width()),
 135       maFocusManager([this](const Panel& rPanel){ return this->ShowPanel(rPanel); }),
 136       mbIsDocumentReadOnly(false),
 137       mpSplitWindow(nullptr),
 138       mnWidthOnSplitterButtonDown(0)
 139 {
 140     mnMaximumSidebarWidth = officecfg::Office::UI::Sidebar::General::MaximumWidth::get() * mpTabBar->GetDPIScaleFactor();
 141     // Decks and panel collections for this sidebar
 142     mpResourceManager = std::make_unique<ResourceManager>();
 143 }
 144
 145 rtl::Reference<SidebarController> SidebarController::create(SidebarDockingWindow* pParentWindow,
 146                                                             const SfxViewFrame* pViewFrame)
 147 {
 148     rtl::Reference<SidebarController> instance(new SidebarController(pParentWindow, pViewFrame));
 149
 150     const css::uno::Reference<css::frame::XFrame>& rxFrame = pViewFrame->GetFrame().GetFrameInterface();
 151     instance->registerSidebarForFrame(rxFrame->getController());
 152     rxFrame->addFrameActionListener(instance);
 153     // Listen for window events.
 154     instance->mpParentWindow->AddEventListener(LINK(instance.get(), SidebarController, WindowEventHandler));
 155
 156     // Listen for theme property changes.
 157     instance->mxThemePropertySet = Theme::GetPropertySet();
 158     instance->mxThemePropertySet->addPropertyChangeListener(
 159         u""_ustr,
 160         static_cast<css::beans::XPropertyChangeListener*>(instance.get()));
 161
 162     // Get the dispatch object as preparation to listen for changes of
 163     // the read-only state.
 164     const util::URL aURL (Tools::GetURL(gsReadOnlyCommandName));
 165     instance->mxReadOnlyModeDispatch = Tools::GetDispatch(rxFrame, aURL);
 166     if (instance->mxReadOnlyModeDispatch.is())
 167         instance->mxReadOnlyModeDispatch->addStatusListener(instance, aURL);
 168
 169     //first UpdateConfigurations call will SwitchToDeck
 170
 171     return instance;
 172 }
 173
 174 SidebarController::~SidebarController()
 175 {
 176 }
 177
 178 SidebarController* SidebarController::GetSidebarControllerForFrame (
 179     const css::uno::Reference<css::frame::XFrame>& rxFrame)
 180 {
 181     uno::Reference<frame::XController> const xController(rxFrame->getController());
 182     if (!xController.is()) // this may happen during dispose of Draw controller but perhaps it's a bug
 183     {
 184         SAL_WARN("sfx.sidebar", "GetSidebarControllerForFrame: frame has no XController");
 185         return nullptr;
 186     }
 187     uno::Reference<ui::XContextChangeEventListener> const xListener(
 188         framework::GetFirstListenerWith(
 189             ::comphelper::getProcessComponentContext(),
 190             xController,
 191             [] (uno::Reference<uno::XInterface> const& xRef)
 192             { return nullptr != dynamic_cast<SidebarController*>(xRef.get()); }
 193         ));
 194
 195     return dynamic_cast<SidebarController*>(xListener.get());
 196 }
 197
 198 void SidebarController::registerSidebarForFrame(const css::uno::Reference<css::frame::XController>& xController)
 199 {
 200     // Listen for context change events.
 201     css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
 202         css::ui::ContextChangeEventMultiplexer::get(
 203             ::comphelper::getProcessComponentContext()));
 204     xMultiplexer->addContextChangeEventListener(
 205         static_cast<css::ui::XContextChangeEventListener*>(this),
 206         xController);
 207 }
 208
 209 void SidebarController::unregisterSidebarForFrame(const css::uno::Reference<css::frame::XController>& xController)
 210 {
 211     saveDeckState();
 212     disposeDecks();
 213
 214     css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
 215         css::ui::ContextChangeEventMultiplexer::get(
 216             ::comphelper::getProcessComponentContext()));
 217     xMultiplexer->removeContextChangeEventListener(
 218         static_cast<css::ui::XContextChangeEventListener*>(this),
 219         xController);
 220 }
 221
 222 void SidebarController::disposeDecks()
 223 {
 224     SolarMutexGuard aSolarMutexGuard;
 225
 226     if (comphelper::LibreOfficeKit::isActive())
 227     {
 228         if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
 229         {
 230             const std::string hide = UnoNameFromDeckId(msCurrentDeckId, GetCurrentContext());
 231             if (!hide.empty())
 232             {
 233                 // Be consistent with SwitchToDeck(), so both places emit JSON.
 234                 boost::property_tree::ptree aTree;
 235                 aTree.put("commandName", hide);
 236                 aTree.put("state", "false");
 237                 std::stringstream aStream;
 238                 boost::property_tree::write_json(aStream, aTree);
 239                 pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
 240                                                        OString(aStream.str()));
 241             }
 242         }
 243
 244         if (mpParentWindow)
 245             mpParentWindow->ReleaseLOKNotifier();
 246     }
 247
 248     mpCurrentDeck.clear();
 249     maFocusManager.Clear();
 250     mpResourceManager->disposeDecks();
 251 }
 252
 253 namespace
 254 {
 255     class CloseIndicator final : public InterimItemWindow
 256     {
 257     public:
 258         CloseIndicator(vcl::Window* pParent)
 259             : InterimItemWindow(pParent, u"svt/ui/fixedimagecontrol.ui"_ustr, u"FixedImageControl"_ustr)
 260             , m_xWidget(m_xBuilder->weld_image(u"image"_ustr))
 261         {
 262             InitControlBase(m_xWidget.get());
 263
 264             m_xWidget->set_from_icon_name(SIDEBAR_CLOSE_INDICATOR);
 265
 266             SetSizePixel(get_preferred_size());
 267
 268             SetBackground(Theme::GetColor(Theme::Color_DeckBackground));
 269         }
 270
 271         virtual ~CloseIndicator() override
 272         {
 273             disposeOnce();
 274         }
 275
 276         virtual void dispose() override
 277         {
 278             m_xWidget.reset();
 279             InterimItemWindow::dispose();
 280         }
 281
 282     private:
 283         std::unique_ptr<weld::Image> m_xWidget;
 284     };
 285 }
 286
 287 void SidebarController::disposing(std::unique_lock<std::mutex>&)
 288 {
 289     SolarMutexGuard aSolarMutexGuard;
 290
 291     mpCloseIndicator.disposeAndClear();
 292
 293     maFocusManager.Clear();
 294     mpTabBar.disposeAndClear();
 295
 296     saveDeckState();
 297
 298     // clear decks
 299     ResourceManager::DeckContextDescriptorContainer aDecks;
 300
 301     mpResourceManager->GetMatchingDecks (
 302             aDecks,
 303             GetCurrentContext(),
 304             IsDocumentReadOnly(),
 305             mxFrame->getController());
 306
 307     for (const auto& rDeck : aDecks)
 308     {
 309         std::shared_ptr<DeckDescriptor> deckDesc = mpResourceManager->GetDeckDescriptor(rDeck.msId);
 310
 311         VclPtr<Deck> aDeck = deckDesc->mpDeck;
 312         if (aDeck)
 313             aDeck.disposeAndClear();
 314     }
 315
 316     maContextChangeUpdate.CancelRequest();
 317
 318     if (mxReadOnlyModeDispatch.is())
 319         mxReadOnlyModeDispatch->removeStatusListener(this, Tools::GetURL(gsReadOnlyCommandName));
 320
 321     if (mxThemePropertySet.is())
 322         mxThemePropertySet->removePropertyChangeListener(
 323             u""_ustr,
 324             static_cast<css::beans::XPropertyChangeListener*>(this));
 325
 326     if (mpParentWindow != nullptr)
 327     {
 328         mpParentWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
 329         mpParentWindow = nullptr;
 330     }
 331
 332     if (mpSplitWindow != nullptr)
 333     {
 334         mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
 335         mpSplitWindow = nullptr;
 336     }
 337
 338     mxFrame->removeFrameActionListener(this);
 339
 340     uno::Reference<css::frame::XController> xController = mxFrame->getController();
 341     if (!xController.is())
 342         xController = mxCurrentController;
 343
 344     unregisterSidebarForFrame(xController);
 345 }
 346
 347 void SAL_CALL SidebarController::notifyContextChangeEvent (const css::ui::ContextChangeEventObject& rEvent)
 348 {
 349     SolarMutexGuard aSolarMutexGuard;
 350
 351     // Update to the requested new context asynchronously to avoid
 352     // subtle errors caused by SFX2 which in rare cases can not
 353     // properly handle a synchronous update.
 354
 355     maRequestedContext = Context(
 356         rEvent.ApplicationName,
 357         rEvent.ContextName);
 358
 359     if (maRequestedContext != maCurrentContext)
 360     {
 361         mxCurrentController.set(rEvent.Source, css::uno::UNO_QUERY);
 362         maContextChangeUpdate.RequestCall(); // async call, not a prob
 363                                              // calling with held
 364                                              // solarmutex
 365         // TODO: this call is redundant but mandatory for unit test to update context on document loading
 366         if (!comphelper::LibreOfficeKit::isActive())
 367             UpdateConfigurations();
 368     }
 369 }
 370
 371 void SAL_CALL SidebarController::disposing (const css::lang::EventObject& )
 372 {
 373     dispose();
 374 }
 375
 376 void SAL_CALL SidebarController::propertyChange (const css::beans::PropertyChangeEvent& )
 377 {
 378     SolarMutexGuard aSolarMutexGuard;
 379
 380     maPropertyChangeForwarder.RequestCall(); // async call, not a prob
 381                                              // to call with held
 382                                              // solarmutex
 383 }
 384
 385 void SAL_CALL SidebarController::statusChanged (const css::frame::FeatureStateEvent& rEvent)
 386 {
 387     SolarMutexGuard aSolarMutexGuard;
 388
 389     bool bIsReadWrite (true);
 390     if (rEvent.IsEnabled)
 391         rEvent.State >>= bIsReadWrite;
 392
 393     if (mbIsDocumentReadOnly != !bIsReadWrite)
 394     {
 395         mbIsDocumentReadOnly = !bIsReadWrite;
 396
 397         // Force the current deck to update its panel list.
 398         if ( ! mbIsDocumentReadOnly)
 399             SwitchToDefaultDeck();
 400
 401         mnRequestedForceFlags |= SwitchFlag_ForceSwitch;
 402         maContextChangeUpdate.RequestCall(); // async call, ok to call
 403                                              // with held solarmutex
 404     }
 405 }
 406
 407 void SAL_CALL SidebarController::requestLayout()
 408 {
 409     SolarMutexGuard aSolarMutexGuard;
 410
 411     sal_Int32 nMinimalWidth = 0;
 412     if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
 413     {
 414         mpCurrentDeck->RequestLayout();
 415         nMinimalWidth = mbMinimumSidebarWidth ? mpCurrentDeck->GetMinimalWidth() : 0;
 416     }
 417     RestrictWidth(nMinimalWidth);
 418 }
 419
 420 void SidebarController::BroadcastPropertyChange()
 421 {
 422     mpParentWindow->Invalidate(InvalidateFlags::Children);
 423 }
 424
 425 void SidebarController::NotifyResize()
 426 {
 427     if (!mpTabBar)
 428     {
 429         OSL_ASSERT(mpTabBar!=nullptr);
 430         return;
 431     }
 432
 433     const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth();
 434
 435     const sal_Int32 nWidth(mpParentWindow->GetSizePixel().Width());
 436     const sal_Int32 nHeight(mpParentWindow->GetSizePixel().Height());
 437
 438     mbIsDeckOpen = (nWidth > nTabBarDefaultWidth);
 439
 440     if (mnSavedSidebarWidth <= 0)
 441         mnSavedSidebarWidth = nWidth;
 442
 443     bool bIsDeckVisible;
 444     const bool bIsOpening (nWidth > mnWidthOnSplitterButtonDown);
 445     if (bIsOpening)
 446         bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthOpenThreshold;
 447     else
 448         bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthCloseThreshold;
 449     mbIsDeckRequestedOpen = bIsDeckVisible;
 450     UpdateCloseIndicator(!bIsDeckVisible);
 451
 452     if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
 453     {
 454         SfxSplitWindow* pSplitWindow = GetSplitWindow();
 455         WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right;
 456         tools::Long nDeckX, nTabX;
 457         if (eAlign == WindowAlign::Left)     // attach the Sidebar towards the left-side of screen
 458         {
 459             nDeckX = nTabBarDefaultWidth;
 460             nTabX = 0;
 461         }
 462         else   // attach the Sidebar towards the right-side of screen
 463         {
 464             nDeckX = 0;
 465             nTabX = nWidth - nTabBarDefaultWidth;
 466         }
 467
 468         // Place the deck first.
 469         if (bIsDeckVisible)
 470         {
 471             if (comphelper::LibreOfficeKit::isActive())
 472             {
 473                 // We want to let the layouter use up as much of the
 474                 // height as necessary to make sure no scrollbar is
 475                 // visible. This only works when there are no greedy
 476                 // panes that fill up all available area. So we only
 477                 // use this for the PropertyDeck, which has no such
 478                 // panes, while most other do. This is fine, since
 479                 // it's the PropertyDeck that really has many panes
 480                 // that can collapse or expand. For others, limit
 481                 // the height to something sensible.
 482                 const sal_Int32 nExtHeight = (msCurrentDeckId == "PropertyDeck" ? 2000 : 600);
 483                 // No TabBar in LOK (use nWidth in full).
 484                 mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth, nExtHeight);
 485             }
 486             else
 487                 mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth - nTabBarDefaultWidth, nHeight);
 488             mpCurrentDeck->Show();
 489             mpCurrentDeck->RequestLayout();
 490             mpTabBar->HighlightDeck(mpCurrentDeck->GetId());
 491         }
 492         else
 493             mpCurrentDeck->Hide();
 494
 495         // Now place the tab bar.
 496         mpTabBar->setPosSizePixel(nTabX, 0, nTabBarDefaultWidth, nHeight);
 497         if (!comphelper::LibreOfficeKit::isActive())
 498             mpTabBar->Show(); // Don't show TabBar in LOK.
 499     }
 500
 501     // Determine if the closer of the deck can be shown.
 502     sal_Int32 nMinimalWidth = 0;
 503     if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
 504     {
 505         DeckTitleBar* pTitleBar = mpCurrentDeck->GetTitleBar();
 506         if (pTitleBar && pTitleBar->GetVisible())
 507             pTitleBar->SetCloserVisible(CanModifyChildWindowWidth());
 508         nMinimalWidth = mbMinimumSidebarWidth ? mpCurrentDeck->GetMinimalWidth() : 0;
 509     }
 510
 511     RestrictWidth(nMinimalWidth);
 512 }
 513
 514 void SidebarController::ProcessNewWidth (const sal_Int32 nNewWidth)
 515 {
 516     if ( ! mbIsDeckRequestedOpen.has_value())
 517         return;
 518
 519     if (*mbIsDeckRequestedOpen)
 520     {
 521         // Deck became large enough to be shown.  Show it.
 522         mnSavedSidebarWidth = nNewWidth;
 523         // Store nNewWidth to mnWidthOnSplitterButtonDown when dragging sidebar Splitter
 524         mnWidthOnSplitterButtonDown = nNewWidth;
 525         if (!*mbIsDeckOpen)
 526             RequestOpenDeck();
 527     }
 528     else
 529     {
 530         // Deck became too small.  Close it completely.
 531         // If window is wider than the tab bar then mark the deck as being visible, even when it is not.
 532         // This is to trigger an adjustment of the width to the width of the tab bar.
 533         mbIsDeckOpen = true;
 534         RequestCloseDeck();
 535
 536         if (mnWidthOnSplitterButtonDown > TabBar::GetDefaultWidth())
 537             mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
 538     }
 539 }
 540
 541 void SidebarController::SyncUpdate()
 542 {
 543     maPropertyChangeForwarder.Sync();
 544     maContextChangeUpdate.Sync();
 545 }
 546
 547 void SidebarController::UpdateConfigurations()
 548 {
 549     if (maCurrentContext == maRequestedContext
 550         && mnRequestedForceFlags == SwitchFlag_NoForce)
 551         return;
 552
 553     if ((maCurrentContext.msApplication != "none") &&
 554             !maCurrentContext.msApplication.isEmpty())
 555     {
 556         mpResourceManager->SaveDecksSettings(maCurrentContext);
 557         mpResourceManager->SetLastActiveDeck(maCurrentContext, msCurrentDeckId);
 558     }
 559
 560     // get last active deck for this application on first update
 561     if (!maRequestedContext.msApplication.isEmpty() &&
 562             (maCurrentContext.msApplication != maRequestedContext.msApplication))
 563     {
 564         OUString sLastActiveDeck = mpResourceManager->GetLastActiveDeck( maRequestedContext );
 565         if (!sLastActiveDeck.isEmpty())
 566             msCurrentDeckId = sLastActiveDeck;
 567     }
 568
 569     maCurrentContext = maRequestedContext;
 570
 571     mpResourceManager->InitDeckContext(GetCurrentContext());
 572
 573     // Find the set of decks that could be displayed for the new context.
 574     ResourceManager::DeckContextDescriptorContainer aDecks;
 575
 576     css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();
 577
 578     mpResourceManager->GetMatchingDecks (
 579         aDecks,
 580         maCurrentContext,
 581         mbIsDocumentReadOnly,
 582         xController);
 583
 584     maFocusManager.Clear();
 585
 586     // Notify the tab bar about the updated set of decks.
 587     mpTabBar->SetDecks(aDecks);
 588
 589     // Find the new deck.  By default that is the same as the old
 590     // one.  If that is not set or not enabled, then choose the
 591     // first enabled deck (which is PropertyDeck).
 592     OUString sNewDeckId;
 593     for (const auto& rDeck : aDecks)
 594     {
 595         if (rDeck.mbIsEnabled)
 596         {
 597             if (rDeck.msId == msCurrentDeckId)
 598             {
 599                 sNewDeckId = msCurrentDeckId;
 600                 break;
 601             }
 602             else if (sNewDeckId.getLength() == 0)
 603                 sNewDeckId = rDeck.msId;
 604         }
 605     }
 606
 607     if (sNewDeckId.getLength() == 0)
 608     {
 609         // We did not find a valid deck.
 610         RequestCloseDeck();
 611         return;
 612     }
 613
 614     std::shared_ptr<DeckDescriptor> xDescriptor = mpResourceManager->GetDeckDescriptor(sNewDeckId);
 615
 616     if (xDescriptor)
 617     {
 618         SwitchToDeck(*xDescriptor, maCurrentContext);
 619     }
 620 }
 621
 622 namespace {
 623
 624 void collectUIInformation(const OUString& rDeckId)
 625 {
 626     EventDescription aDescription;
 627     aDescription.aAction = "SIDEBAR";
 628     aDescription.aParent = "MainWindow";
 629     aDescription.aParameters = {{"PANEL", rDeckId}};
 630     aDescription.aKeyWord = "CurrentApp";
 631
 632     UITestLogger::getInstance().logEvent(aDescription);
 633 }
 634
 635 }
 636
 637 bool SidebarController::IsDocked() const { return !mpParentWindow->IsFloatingMode(); }
 638
 639 void SidebarController::OpenThenToggleDeck (
 640     const OUString& rsDeckId)
 641 {
 642     SfxSplitWindow* pSplitWindow = GetSplitWindow();
 643     if ( pSplitWindow && !pSplitWindow->IsFadeIn() )
 644         // tdf#83546 Collapsed sidebar should expand first
 645         pSplitWindow->FadeIn();
 646     else if ( IsDeckVisible( rsDeckId ) )
 647     {
 648         if( !WasFloatingDeckClosed() )
 649         {
 650             // tdf#88241 Summoning an undocked sidebar a second time should close sidebar
 651             mpParentWindow->Close();
 652             return;
 653         }
 654         else
 655         {
 656             // tdf#67627 Clicking a second time on a Deck icon will close the Deck
 657             RequestCloseDeck();
 658             return;
 659         }
 660     }
 661     RequestOpenDeck();
 662     // before SwitchToDeck which may cause the rsDeckId string to be released
 663     collectUIInformation(rsDeckId);
 664     SwitchToDeck(rsDeckId);
 665
 666     // Make sure the sidebar is wide enough to fit the requested content
 667     if (mpCurrentDeck && mpTabBar)
 668     {
 669         sal_Int32 nRequestedWidth = mpCurrentDeck->GetMinimalWidth() + TabBar::GetDefaultWidth();
 670         // if sidebar was dragged
 671         if(mnWidthOnSplitterButtonDown > 0 && mnWidthOnSplitterButtonDown > nRequestedWidth){
 672             SetChildWindowWidth(mnWidthOnSplitterButtonDown);
 673         }else{
 674             // tdf#150639 The mnWidthOnSplitterButtonDown is initialized to 0 at program start.
 675             // This makes every call to take the else case until the user manually changes the
 676             // width, but some decks such as Master Slides have the mnMinimalWidth too low which
 677             // makes them too narrow for the content they should display to the user.
 678             SetChildWindowWidth(nRequestedWidth > mnSavedSidebarWidth ? nRequestedWidth
 679                                                                       : mnSavedSidebarWidth);
 680         }
 681     }
 682 }
 683
 684 void SidebarController::OpenThenSwitchToDeck (
 685     std::u16string_view rsDeckId)
 686 {
 687     RequestOpenDeck();
 688     SwitchToDeck(rsDeckId);
 689
 690 }
 691
 692 void SidebarController::SwitchToDefaultDeck()
 693 {
 694     SwitchToDeck(gsDefaultDeckId);
 695 }
 696
 697 void SidebarController::SwitchToDeck (
 698     std::u16string_view rsDeckId)
 699 {
 700     if (  msCurrentDeckId != rsDeckId
 701         || ! mbIsDeckOpen.has_value()
 702         || mnRequestedForceFlags!=SwitchFlag_NoForce)
 703     {
 704         std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rsDeckId);
 705
 706         if (xDeckDescriptor)
 707         {
 708             SwitchToDeck(*xDeckDescriptor, maCurrentContext);
 709             Deck::LOKSendSidebarFullUpdate();
 710         }
 711     }
 712 }
 713
 714 void SidebarController::CreateDeck(std::u16string_view rDeckId) {
 715     CreateDeck(rDeckId, maCurrentContext);
 716 }
 717
 718 void SidebarController::CreateDeck(std::u16string_view rDeckId, const Context& rContext, bool bForceCreate)
 719 {
 720     std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId);
 721
 722     if (!xDeckDescriptor)
 723         return;
 724
 725     VclPtr<Deck> aDeck = xDeckDescriptor->mpDeck;
 726     if (!aDeck || bForceCreate)
 727     {
 728         if (aDeck)
 729             aDeck.disposeAndClear();
 730
 731         aDeck = VclPtr<Deck>::Create(
 732                         *xDeckDescriptor,
 733                         mpParentWindow,
 734                         [this]() { return this->RequestCloseDeck(); });
 735     }
 736     xDeckDescriptor->mpDeck = std::move(aDeck);
 737     CreatePanels(rDeckId, rContext);
 738 }
 739
 740 void SidebarController::CreatePanels(std::u16string_view rDeckId, const Context& rContext)
 741 {
 742     std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId);
 743
 744     // init panels bounded to that deck, do not wait them being displayed as may be accessed through API
 745
 746     VclPtr<Deck> pDeck = xDeckDescriptor->mpDeck;
 747
 748     ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors;
 749
 750     css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();
 751
 752     mpResourceManager->GetMatchingPanels(
 753                                         aPanelContextDescriptors,
 754                                         rContext,
 755                                         rDeckId,
 756                                         xController);
 757
 758     // Update the panel list.
 759     const sal_Int32 nNewPanelCount (aPanelContextDescriptors.size());
 760     SharedPanelContainer aNewPanels;
 761     sal_Int32 nWriteIndex (0);
 762
 763     aNewPanels.resize(nNewPanelCount);
 764
 765     for (sal_Int32 nReadIndex=0; nReadIndex<nNewPanelCount; ++nReadIndex)
 766     {
 767         const ResourceManager::PanelContextDescriptor& rPanelContexDescriptor (
 768             aPanelContextDescriptors[nReadIndex]);
 769
 770         // Determine if the panel can be displayed.
 771         const bool bIsPanelVisible (!mbIsDocumentReadOnly || rPanelContexDescriptor.mbShowForReadOnlyDocuments);
 772         if ( ! bIsPanelVisible)
 773             continue;
 774
 775         auto xOldPanel(pDeck->GetPanel(rPanelContexDescriptor.msId));
 776         if (xOldPanel)
 777         {
 778             xOldPanel->SetLurkMode(false);
 779             aNewPanels[nWriteIndex] = xOldPanel;
 780             xOldPanel->SetExpanded(rPanelContexDescriptor.mbIsInitiallyVisible);
 781             ++nWriteIndex;
 782         }
 783         else
 784         {
 785             auto aPanel = CreatePanel(rPanelContexDescriptor.msId,
 786                                       pDeck->GetPanelParentWindow(),
 787                                       rPanelContexDescriptor.mbIsInitiallyVisible,
 788                                       rContext,
 789                                       pDeck);
 790             if (aPanel)
 791             {
 792                 aNewPanels[nWriteIndex] = std::move(aPanel);
 793
 794                 // Depending on the context we have to change the command
 795                 // for the "more options" dialog.
 796                 PanelTitleBar* pTitleBar = aNewPanels[nWriteIndex]->GetTitleBar();
 797                 if (pTitleBar)
 798                 {
 799                     pTitleBar->SetMoreOptionsCommand(
 800                         rPanelContexDescriptor.msMenuCommand,
 801                         mxFrame, xController);
 802                 }
 803                 ++nWriteIndex;
 804             }
 805         }
 806     }
 807
 808     // mpCurrentPanels - may miss stuff (?)
 809     aNewPanels.resize(nWriteIndex);
 810     pDeck->ResetPanels(std::move(aNewPanels));
 811 }
 812
 813 void SidebarController::SwitchToDeck (
 814     const DeckDescriptor& rDeckDescriptor,
 815     const Context& rContext)
 816 {
 817     if (comphelper::LibreOfficeKit::isActive())
 818     {
 819         if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
 820         {
 821             std::vector<std::pair<std::string, std::string>> aStateChanges;
 822             if (msCurrentDeckId != rDeckDescriptor.msId)
 823             {
 824                 const std::string hide = UnoNameFromDeckId(msCurrentDeckId, GetCurrentContext());
 825                 if (!hide.empty())
 826                 {
 827                     aStateChanges.push_back({hide, std::string("false")});
 828                 }
 829             }
 830
 831             const std::string show = UnoNameFromDeckId(rDeckDescriptor.msId, GetCurrentContext());
 832             if (!show.empty())
 833             {
 834                 aStateChanges.push_back({show, std::string("true")});
 835             }
 836
 837             for (const auto& rStateChange : aStateChanges)
 838             {
 839                 boost::property_tree::ptree aTree;
 840                 aTree.put("locale", comphelper::LibreOfficeKit::getLocale().getBcp47());
 841                 aTree.put("commandName", rStateChange.first);
 842                 aTree.put("state", rStateChange.second);
 843                 std::stringstream aStream;
 844                 boost::property_tree::write_json(aStream, aTree);
 845                 pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
 846                                                        OString(aStream.str()));
 847             }
 848         }
 849     }
 850
 851     maFocusManager.Clear();
 852
 853     const bool bForceNewDeck ((mnRequestedForceFlags&SwitchFlag_ForceNewDeck)!=0);
 854     const bool bForceNewPanels ((mnRequestedForceFlags&SwitchFlag_ForceNewPanels)!=0);
 855     mnRequestedForceFlags = SwitchFlag_NoForce;
 856
 857     if (   msCurrentDeckId != rDeckDescriptor.msId
 858         || bForceNewDeck)
 859     {
 860         if (mpCurrentDeck)
 861             mpCurrentDeck->Hide();
 862
 863         msCurrentDeckId = rDeckDescriptor.msId;
 864     }
 865
 866     // Determine the panels to display in the deck.
 867     ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors;
 868
 869     css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();
 870
 871     mpResourceManager->GetMatchingPanels(
 872         aPanelContextDescriptors,
 873         rContext,
 874         rDeckDescriptor.msId,
 875         xController);
 876
 877     if (aPanelContextDescriptors.empty())
 878     {
 879         // There are no panels to be displayed in the current context.
 880         if (vcl::EnumContext::GetContextEnum(rContext.msContext) != vcl::EnumContext::Context::Empty)
 881         {
 882             // Switch to the "empty" context and try again.
 883             SwitchToDeck(
 884                 rDeckDescriptor,
 885                 Context(
 886                     rContext.msApplication,
 887                     vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Empty)));
 888             return;
 889         }
 890         else
 891         {
 892             // This is already the "empty" context. Looks like we have
 893             // to live with an empty deck.
 894         }
 895     }
 896
 897     // Provide a configuration and Deck object.
 898
 899     CreateDeck(rDeckDescriptor.msId, rContext, bForceNewDeck);
 900
 901     if (bForceNewPanels && !bForceNewDeck) // already forced if bForceNewDeck
 902         CreatePanels(rDeckDescriptor.msId, rContext);
 903
 904     if (mpCurrentDeck && mpCurrentDeck != rDeckDescriptor.mpDeck)
 905         mpCurrentDeck->Hide();
 906     mpCurrentDeck.reset(rDeckDescriptor.mpDeck);
 907
 908     if ( ! mpCurrentDeck)
 909         return;
 910
 911 #if OSL_DEBUG_LEVEL >= 2
 912     // Show the context name in the deck title bar.
 913     DeckTitleBar* pDebugTitleBar = mpCurrentDeck->GetTitleBar();
 914     if (pDebugTitleBar)
 915         pDebugTitleBar->SetTitle(rDeckDescriptor.msTitle + " (" + maCurrentContext.msContext + ")");
 916 #endif
 917
 918     SfxSplitWindow* pSplitWindow = GetSplitWindow();
 919     sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth();
 920     WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right;
 921     tools::Long nDeckX;
 922     if (eAlign == WindowAlign::Left)     // attach the Sidebar towards the left-side of screen
 923     {
 924         nDeckX = nTabBarDefaultWidth;
 925     }
 926     else   // attach the Sidebar towards the right-side of screen
 927     {
 928         nDeckX = 0;
 929     }
 930
 931     // Activate the deck and the new set of panels.
 932     mpCurrentDeck->setPosSizePixel(
 933         nDeckX,
 934         0,
 935         mpParentWindow->GetSizePixel().Width() - nTabBarDefaultWidth,
 936         mpParentWindow->GetSizePixel().Height());
 937
 938     mpCurrentDeck->Show();
 939
 940     mpParentWindow->SetText(rDeckDescriptor.msTitle);
 941
 942     NotifyResize();
 943
 944     // Tell the focus manager about the new panels and tab bar
 945     // buttons.
 946     maFocusManager.SetDeck(mpCurrentDeck);
 947     maFocusManager.SetPanels(mpCurrentDeck->GetPanels());
 948
 949     mpTabBar->UpdateFocusManager(maFocusManager);
 950     UpdateTitleBarIcons();
 951 }
 952
 953 void SidebarController::notifyDeckTitle(std::u16string_view targetDeckId)
 954 {
 955     if (msCurrentDeckId == targetDeckId)
 956     {
 957         maFocusManager.SetDeck(mpCurrentDeck);
 958         mpTabBar->UpdateFocusManager(maFocusManager);
 959         UpdateTitleBarIcons();
 960     }
 961 }
 962
 963 std::shared_ptr<Panel> SidebarController::CreatePanel (
 964     std::u16string_view rsPanelId,
 965     weld::Widget* pParentWindow,
 966     const bool bIsInitiallyExpanded,
 967     const Context& rContext,
 968     const VclPtr<Deck>& pDeck)
 969 {
 970     std::shared_ptr<PanelDescriptor> xPanelDescriptor = mpResourceManager->GetPanelDescriptor(rsPanelId);
 971
 972     if (!xPanelDescriptor)
 973         return nullptr;
 974
 975     // Create the panel which is the parent window of the UIElement.
 976     auto xPanel = std::make_shared<Panel>(
 977         *xPanelDescriptor,
 978         pParentWindow,
 979         bIsInitiallyExpanded,
 980         pDeck,
 981         [this]() { return this->GetCurrentContext(); },
 982         mxFrame);
 983
 984     // Create the XUIElement.
 985     Reference<ui::XUIElement> xUIElement (CreateUIElement(
 986             xPanel->GetElementParentWindow(),
 987             xPanelDescriptor->msImplementationURL,
 988             xPanelDescriptor->mbWantsCanvas,
 989             rContext));
 990     if (xUIElement.is())
 991     {
 992         // Initialize the panel and add it to the active deck.
 993         xPanel->SetUIElement(xUIElement);
 994     }
 995     else
 996     {
 997         xPanel.reset();
 998     }
 999
1000     return xPanel;
1001 }
1002
1003 Reference<ui::XUIElement> SidebarController::CreateUIElement (
1004     const Reference<awt::XWindow>& rxWindow,
1005     const OUString& rsImplementationURL,
1006     const bool bWantsCanvas,
1007     const Context& rContext)
1008 {
1009     try
1010     {
1011         const Reference<XComponentContext>& xComponentContext (::comphelper::getProcessComponentContext() );
1012         const Reference<ui::XUIElementFactory> xUIElementFactory =
1013                ui::theUIElementFactoryManager::get( xComponentContext );
1014
1015        // Create the XUIElement.
1016         ::comphelper::NamedValueCollection aCreationArguments;
1017         aCreationArguments.put(u"Frame"_ustr, Any(mxFrame));
1018         aCreationArguments.put(u"ParentWindow"_ustr, Any(rxWindow));
1019         SidebarDockingWindow* pSfxDockingWindow = mpParentWindow.get();
1020         if (pSfxDockingWindow != nullptr)
1021             aCreationArguments.put(u"SfxBindings"_ustr, Any(reinterpret_cast<sal_uInt64>(&pSfxDockingWindow->GetBindings())));
1022         aCreationArguments.put(u"Theme"_ustr, Theme::GetPropertySet());
1023         aCreationArguments.put(u"Sidebar"_ustr, Any(Reference<ui::XSidebar>(static_cast<ui::XSidebar*>(this))));
1024         if (bWantsCanvas)
1025         {
1026             Reference<rendering::XSpriteCanvas> xCanvas (VCLUnoHelper::GetWindow(rxWindow)->GetOutDev()->GetSpriteCanvas());
1027             aCreationArguments.put(u"Canvas"_ustr, Any(xCanvas));
1028         }
1029
1030         if (mxCurrentController.is())
1031         {
1032             OUString aModule = Tools::GetModuleName(mxCurrentController);
1033             if (!aModule.isEmpty())
1034             {
1035                 aCreationArguments.put(u"Module"_ustr, Any(aModule));
1036             }
1037             aCreationArguments.put(u"Controller"_ustr, Any(mxCurrentController));
1038         }
1039
1040         aCreationArguments.put(u"ApplicationName"_ustr, Any(rContext.msApplication));
1041         aCreationArguments.put(u"ContextName"_ustr, Any(rContext.msContext));
1042
1043         Reference<ui::XUIElement> xUIElement(
1044             xUIElementFactory->createUIElement(
1045                 rsImplementationURL,
1046                 aCreationArguments.getPropertyValues()),
1047             UNO_SET_THROW);
1048
1049         return xUIElement;
1050     }
1051     catch(const Exception&)
1052     {
1053         TOOLS_WARN_EXCEPTION("sfx.sidebar", "Cannot create panel " << rsImplementationURL);
1054         return nullptr;
1055     }
1056 }
1057
1058 IMPL_LINK(SidebarController, WindowEventHandler, VclWindowEvent&, rEvent, void)
1059 {
1060     if (rEvent.GetWindow() == mpParentWindow)
1061     {
1062         switch (rEvent.GetId())
1063         {
1064             case VclEventId::WindowShow:
1065             case VclEventId::WindowResize:
1066                 NotifyResize();
1067                 break;
1068
1069             case VclEventId::WindowDataChanged:
1070                 // Force an update of deck and tab bar to reflect
1071                 // changes in theme (high contrast mode).
1072                 Theme::HandleDataChange();
1073                 UpdateTitleBarIcons();
1074                 mpParentWindow->Invalidate();
1075                 mnRequestedForceFlags |= SwitchFlag_ForceNewDeck | SwitchFlag_ForceNewPanels;
1076                 maContextChangeUpdate.RequestCall();
1077                 break;
1078
1079             case VclEventId::WindowToggleFloating:
1080                 // make sure the appropriate "Dock" or "Undock" menu entry is shown
1081                 mpTabBar->UpdateMenus();
1082                 break;
1083
1084             case VclEventId::ObjectDying:
1085                 dispose();
1086                 break;
1087
1088             case VclEventId::WindowPaint:
1089                 SAL_INFO("sfx.sidebar", "Paint");
1090                 break;
1091
1092             default:
1093                 break;
1094         }
1095     }
1096     else if (rEvent.GetWindow()==mpSplitWindow && mpSplitWindow!=nullptr)
1097     {
1098         switch (rEvent.GetId())
1099         {
1100             case VclEventId::WindowMouseButtonDown:
1101                 mnWidthOnSplitterButtonDown = mpParentWindow->GetSizePixel().Width();
1102                 break;
1103
1104             case VclEventId::WindowMouseButtonUp:
1105             {
1106                 ProcessNewWidth(mpParentWindow->GetSizePixel().Width());
1107                 break;
1108             }
1109
1110             case VclEventId::ObjectDying:
1111                 dispose();
1112                 break;
1113
1114             default: break;
1115          }
1116     }
1117 }
1118
1119 void SidebarController::ConnectMenuActivateHandlers(weld::Menu& rMainMenu, weld::Menu& rSubMenu) const
1120 {
1121     rMainMenu.connect_activate(LINK(const_cast<SidebarController*>(this), SidebarController, OnMenuItemSelected));
1122     rSubMenu.connect_activate(LINK(const_cast<SidebarController*>(this), SidebarController, OnSubMenuItemSelected));
1123 }
1124
1125 IMPL_LINK(SidebarController, OnMenuItemSelected, const OUString&, rCurItemId, void)
1126 {
1127     if (rCurItemId == "unlocktaskpanel")
1128     {
1129         mpParentWindow->SetFloatingMode(true);
1130         if (mpParentWindow->IsFloatingMode())
1131             mpParentWindow->ToTop(ToTopFlags::GrabFocusOnly);
1132     }
1133     else if (rCurItemId == "locktaskpanel")
1134     {
1135         mpParentWindow->SetFloatingMode(false);
1136     }
1137     else if (rCurItemId == "hidesidebar")
1138     {
1139         if (!comphelper::LibreOfficeKit::isActive())
1140         {
1141             const util::URL aURL(Tools::GetURL(u".uno:Sidebar"_ustr));
1142             Reference<frame::XDispatch> xDispatch(Tools::GetDispatch(mxFrame, aURL));
1143             if (xDispatch.is())
1144                 xDispatch->dispatch(aURL, Sequence<beans::PropertyValue>());
1145         }
1146         else
1147         {
1148             // In LOK we don't really destroy the sidebar when "closing";
1149             // we simply hide it. This is because recreating it is problematic
1150             // See notes in SidebarDockingWindow::NotifyResize().
1151             RequestCloseDeck();
1152         }
1153     }
1154     else
1155     {
1156         try
1157         {
1158             std::u16string_view sNumber;
1159             if (rCurItemId.startsWith("select", &sNumber))
1160             {
1161                 RequestOpenDeck();
1162                 SwitchToDeck(mpTabBar->GetDeckIdForIndex(o3tl::toInt32(sNumber)));
1163             }
1164             mpParentWindow->GrabFocusToDocument();
1165         }
1166         catch (RuntimeException&)
1167         {
1168         }
1169     }
1170 }
1171
1172 IMPL_LINK(SidebarController, OnSubMenuItemSelected, const OUString&, rCurItemId, void)
1173 {
1174         try
1175         {
1176             std::u16string_view sNumber;
1177             if (rCurItemId.startsWith("customize", &sNumber))
1178             {
1179                 mpTabBar->ToggleHideFlag(o3tl::toInt32(sNumber));
1180
1181                 // Find the set of decks that could be displayed for the new context.
1182                 ResourceManager::DeckContextDescriptorContainer aDecks;
1183                 mpResourceManager->GetMatchingDecks (
1184                                             aDecks,
1185                                             GetCurrentContext(),
1186                                             IsDocumentReadOnly(),
1187                                             mxFrame->getController());
1188                 // Notify the tab bar about the updated set of decks.
1189                 maFocusManager.Clear();
1190                 mpTabBar->SetDecks(aDecks);
1191                 mpTabBar->HighlightDeck(mpCurrentDeck->GetId());
1192                 mpTabBar->UpdateFocusManager(maFocusManager);
1193             }
1194             mpParentWindow->GrabFocusToDocument();
1195         }
1196         catch (RuntimeException&)
1197         {
1198         }
1199 }
1200
1201
1202 void SidebarController::RequestCloseDeck()
1203 {
1204     if (comphelper::LibreOfficeKit::isActive() && mpCurrentDeck)
1205     {
1206         const SfxViewShell* pViewShell = SfxViewShell::Current();
1207         if (pViewShell && pViewShell->isLOKMobilePhone())
1208         {
1209             // Mobile phone - TODO: unify with desktop
1210             tools::JsonWriter aJsonWriter;
1211             aJsonWriter.put("id", mpParentWindow->get_id());
1212             aJsonWriter.put("type", "dockingwindow");
1213             aJsonWriter.put("text", mpParentWindow->GetText());
1214             aJsonWriter.put("enabled", false);
1215             pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_JSDIALOG, aJsonWriter.finishAndGetAsOString());
1216         }
1217         else if (pViewShell)
1218         {
1219             tools::JsonWriter aJsonWriter;
1220             aJsonWriter.put("id", mpParentWindow->get_id());
1221             aJsonWriter.put("action", "close");
1222             aJsonWriter.put("jsontype", "sidebar");
1223             pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_JSDIALOG, aJsonWriter.finishAndGetAsOString());
1224         }
1225     }
1226
1227     mbIsDeckRequestedOpen = false;
1228     UpdateDeckOpenState();
1229
1230     mpTabBar->RemoveDeckHighlight();
1231 }
1232
1233 void SidebarController::RequestOpenDeck()
1234 {
1235     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1236     if ( pSplitWindow && !pSplitWindow->IsFadeIn() )
1237         // tdf#83546 Collapsed sidebar should expand first
1238         pSplitWindow->FadeIn();
1239
1240     mbIsDeckRequestedOpen = true;
1241     UpdateDeckOpenState();
1242 }
1243
1244 bool SidebarController::IsDeckOpen(const sal_Int32 nIndex)
1245 {
1246     if (nIndex >= 0)
1247     {
1248         OUString asDeckId(mpTabBar->GetDeckIdForIndex(nIndex));
1249         return IsDeckVisible(asDeckId);
1250     }
1251     return mbIsDeckOpen.has_value() && *mbIsDeckOpen;
1252 }
1253
1254 bool SidebarController::IsDeckVisible(std::u16string_view rsDeckId)
1255 {
1256     return mbIsDeckOpen.has_value() && *mbIsDeckOpen && msCurrentDeckId == rsDeckId;
1257 }
1258
1259 void SidebarController::UpdateDeckOpenState()
1260 {
1261     if ( ! mbIsDeckRequestedOpen.has_value() )
1262         // No state requested.
1263         return;
1264
1265     const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth();
1266
1267     // Update (change) the open state when it either has not yet been initialized
1268     // or when its value differs from the requested state.
1269     if ( mbIsDeckOpen.has_value() && *mbIsDeckOpen == *mbIsDeckRequestedOpen )
1270         return;
1271
1272     if (*mbIsDeckRequestedOpen)
1273     {
1274         if (!mpParentWindow->IsFloatingMode())
1275         {
1276             if (mnSavedSidebarWidth <= nTabBarDefaultWidth)
1277                 SetChildWindowWidth(SidebarChildWindow::GetDefaultWidth(mpParentWindow));
1278             else
1279                 SetChildWindowWidth(mnSavedSidebarWidth);
1280         }
1281         else
1282         {
1283             // Show the Deck by resizing back to the original size (before hiding).
1284             Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel());
1285             Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel());
1286
1287             aNewPos.setX(aNewPos.X() - mnSavedSidebarWidth + nTabBarDefaultWidth);
1288             aNewSize.setWidth(mnSavedSidebarWidth);
1289
1290             mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize);
1291
1292             if (comphelper::LibreOfficeKit::isActive())
1293             {
1294                 // Sidebar wide enough to render the menu; enable it.
1295                 mpTabBar->EnableMenuButton(true);
1296
1297                 if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
1298                 {
1299                     const std::string uno = UnoNameFromDeckId(msCurrentDeckId, GetCurrentContext());
1300                     if (!uno.empty())
1301                         pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
1302                                                                 OString(uno + "=true"));
1303                 }
1304             }
1305         }
1306     }
1307     else
1308     {
1309         if ( ! mpParentWindow->IsFloatingMode())
1310             mnSavedSidebarWidth = SetChildWindowWidth(nTabBarDefaultWidth);
1311         else
1312         {
1313             // Hide the Deck by resizing to the width of the TabBar.
1314             Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel());
1315             Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel());
1316             mnSavedSidebarWidth = aNewSize.Width(); // Save the current width to restore.
1317
1318             aNewPos.setX(aNewPos.X() + mnSavedSidebarWidth - nTabBarDefaultWidth);
1319             if (comphelper::LibreOfficeKit::isActive())
1320             {
1321                 // Hide by collapsing, otherwise with 0x0 the client might expect
1322                 // to get valid dimensions on rendering and not collapse the sidebar.
1323                 aNewSize.setWidth(1);
1324             }
1325             else
1326                 aNewSize.setWidth(nTabBarDefaultWidth);
1327
1328             mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize);
1329
1330             if (comphelper::LibreOfficeKit::isActive())
1331             {
1332                 // Sidebar too narrow to render the menu; disable it.
1333                 mpTabBar->EnableMenuButton(false);
1334
1335                 if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
1336                 {
1337                     const std::string uno = UnoNameFromDeckId(msCurrentDeckId, GetCurrentContext());
1338                     if (!uno.empty())
1339                         pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
1340                                                                 OString(uno + "=false"));
1341                 }
1342             }
1343         }
1344
1345         if (mnWidthOnSplitterButtonDown > nTabBarDefaultWidth)
1346             mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
1347         mpParentWindow->SetStyle(mpParentWindow->GetStyle() & ~WB_SIZEABLE);
1348     }
1349
1350     NotifyResize();
1351 }
1352
1353 bool SidebarController::CanModifyChildWindowWidth()
1354 {
1355     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1356     if (pSplitWindow == nullptr)
1357         return false;
1358
1359     sal_uInt16 nRow (0xffff);
1360     sal_uInt16 nColumn (0xffff);
1361     if (pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow))
1362     {
1363         sal_uInt16 nRowCount (pSplitWindow->GetWindowCount(nColumn));
1364         return nRowCount==1;
1365     }
1366     else
1367         return false;
1368 }
1369
1370 sal_Int32 SidebarController::SetChildWindowWidth (const sal_Int32 nNewWidth)
1371 {
1372     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1373     if (pSplitWindow == nullptr)
1374         return 0;
1375
1376     sal_uInt16 nRow (0xffff);
1377     sal_uInt16 nColumn (0xffff);
1378     pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow);
1379     const tools::Long nColumnWidth (pSplitWindow->GetLineSize(nColumn));
1380
1381     vcl::Window* pWindow = mpParentWindow;
1382     const Size aWindowSize (pWindow->GetSizePixel());
1383
1384     pSplitWindow->MoveWindow(
1385         mpParentWindow,
1386         Size(nNewWidth, aWindowSize.Height()),
1387         nColumn,
1388         nRow,
1389         false);
1390     static_cast<SplitWindow*>(pSplitWindow)->Split();
1391
1392     return static_cast<sal_Int32>(nColumnWidth);
1393 }
1394
1395 void SidebarController::RestrictWidth (sal_Int32 nWidth)
1396 {
1397     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1398     if (pSplitWindow != nullptr)
1399     {
1400         const sal_uInt16 nId (pSplitWindow->GetItemId(mpParentWindow.get()));
1401         const sal_uInt16 nSetId (pSplitWindow->GetSet(nId));
1402         const sal_Int32 nRequestedWidth = TabBar::GetDefaultWidth() + nWidth;
1403
1404         pSplitWindow->SetItemSizeRange(
1405             nSetId,
1406             Range(nRequestedWidth, std::max(nRequestedWidth, getMaximumWidth())));
1407     }
1408 }
1409
1410 SfxSplitWindow* SidebarController::GetSplitWindow()
1411 {
1412     if (mpParentWindow != nullptr)
1413     {
1414         SfxSplitWindow* pSplitWindow = dynamic_cast<SfxSplitWindow*>(mpParentWindow->GetParent());
1415         if (pSplitWindow != mpSplitWindow)
1416         {
1417             if (mpSplitWindow != nullptr)
1418                 mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
1419
1420             mpSplitWindow = pSplitWindow;
1421
1422             if (mpSplitWindow != nullptr)
1423                 mpSplitWindow->AddEventListener(LINK(this, SidebarController, WindowEventHandler));
1424         }
1425         return mpSplitWindow;
1426     }
1427     else
1428         return nullptr;
1429 }
1430
1431 void SidebarController::UpdateCloseIndicator (const bool bCloseAfterDrag)
1432 {
1433     if (mpParentWindow == nullptr)
1434         return;
1435
1436     if (bCloseAfterDrag)
1437     {
1438         // Make sure that the indicator exists.
1439         if (!mpCloseIndicator)
1440             mpCloseIndicator.reset(VclPtr<CloseIndicator>::Create(mpParentWindow));
1441
1442         // Place and show the indicator.
1443         const Size aWindowSize (mpParentWindow->GetSizePixel());
1444         const Size aImageSize (mpCloseIndicator->GetSizePixel());
1445         mpCloseIndicator->SetPosPixel(
1446             Point(
1447                 aWindowSize.Width() - TabBar::GetDefaultWidth() - aImageSize.Width(),
1448                 (aWindowSize.Height() - aImageSize.Height())/2));
1449         mpCloseIndicator->Show();
1450     }
1451     else
1452     {
1453         // Hide but don't delete the indicator.
1454         if (mpCloseIndicator)
1455             mpCloseIndicator->Hide();
1456     }
1457 }
1458
1459 void SidebarController::UpdateTitleBarIcons()
1460 {
1461     if ( ! mpCurrentDeck)
1462         return;
1463
1464     const bool bIsHighContrastModeActive (Theme::IsHighContrastMode());
1465
1466     const ResourceManager& rResourceManager = *mpResourceManager;
1467
1468     // Update the deck icon.
1469     std::shared_ptr<DeckDescriptor> xDeckDescriptor = rResourceManager.GetDeckDescriptor(mpCurrentDeck->GetId());
1470     if (xDeckDescriptor && mpCurrentDeck->GetTitleBar())
1471     {
1472         const OUString sIconURL(
1473             bIsHighContrastModeActive
1474                 ? xDeckDescriptor->msHighContrastTitleBarIconURL
1475                 : xDeckDescriptor->msTitleBarIconURL);
1476         mpCurrentDeck->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
1477     }
1478
1479     // Update the panel icons.
1480     const SharedPanelContainer& rPanels (mpCurrentDeck->GetPanels());
1481     for (const auto& rxPanel : rPanels)
1482     {
1483         if ( ! rxPanel)
1484             continue;
1485         if (!rxPanel->GetTitleBar())
1486             continue;
1487         std::shared_ptr<PanelDescriptor> xPanelDescriptor = rResourceManager.GetPanelDescriptor(rxPanel->GetId());
1488         if (!xPanelDescriptor)
1489             continue;
1490         const OUString sIconURL (
1491             bIsHighContrastModeActive
1492                ? xPanelDescriptor->msHighContrastTitleBarIconURL
1493                : xPanelDescriptor->msTitleBarIconURL);
1494         rxPanel->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
1495     }
1496 }
1497
1498 void SidebarController::ShowPanel (const Panel& rPanel)
1499 {
1500     if (mpCurrentDeck)
1501     {
1502         if (!IsDeckOpen())
1503             RequestOpenDeck();
1504         mpCurrentDeck->ShowPanel(rPanel);
1505     }
1506 }
1507
1508 ResourceManager::DeckContextDescriptorContainer SidebarController::GetMatchingDecks()
1509 {
1510     ResourceManager::DeckContextDescriptorContainer aDecks;
1511     mpResourceManager->GetMatchingDecks (aDecks,
1512                                         GetCurrentContext(),
1513                                         IsDocumentReadOnly(),
1514                                         mxFrame->getController());
1515     return aDecks;
1516 }
1517
1518 ResourceManager::PanelContextDescriptorContainer SidebarController::GetMatchingPanels(std::u16string_view rDeckId)
1519 {
1520     ResourceManager::PanelContextDescriptorContainer aPanels;
1521
1522     mpResourceManager->GetMatchingPanels(aPanels,
1523                                         GetCurrentContext(),
1524                                         rDeckId,
1525                                         mxFrame->getController());
1526     return aPanels;
1527 }
1528
1529 void SidebarController::updateModel(const css::uno::Reference<css::frame::XModel>& xModel)
1530 {
1531     mpResourceManager->UpdateModel(xModel);
1532 }
1533
1534 void SidebarController::FadeOut()
1535 {
1536     if (mpSplitWindow)
1537         mpSplitWindow->FadeOut();
1538 }
1539
1540 void SidebarController::FadeIn()
1541 {
1542     if (mpSplitWindow)
1543         mpSplitWindow->FadeIn();
1544 }
1545
1546 tools::Rectangle SidebarController::GetDeckDragArea() const
1547 {
1548     tools::Rectangle aRect;
1549     if (mpCurrentDeck)
1550     {
1551         if (DeckTitleBar* pTitleBar = mpCurrentDeck->GetTitleBar())
1552         {
1553             aRect = pTitleBar->GetDragArea();
1554         }
1555     }
1556     return aRect;
1557 }
1558
1559 void SidebarController::frameAction(const css::frame::FrameActionEvent& rEvent)
1560 {
1561     if (rEvent.Frame == mxFrame)
1562     {
1563         if (rEvent.Action == css::frame::FrameAction_COMPONENT_DETACHING)
1564             unregisterSidebarForFrame(mxFrame->getController());
1565         else if (rEvent.Action == css::frame::FrameAction_COMPONENT_REATTACHED)
1566             registerSidebarForFrame(mxFrame->getController());
1567     }
1568 }
1569
1570 void SidebarController::saveDeckState()
1571 {
1572     // Impress shutdown : context (frame) is disposed before sidebar disposing
1573     // calc writer : context (frame) is disposed after sidebar disposing
1574     // so need to test if GetCurrentContext is still valid regarding msApplication
1575     if (GetCurrentContext().msApplication != "none")
1576     {
1577         mpResourceManager->SaveDecksSettings(GetCurrentContext());
1578         mpResourceManager->SaveLastActiveDeck(GetCurrentContext(), msCurrentDeckId);
1579     }
1580 }
1581
1582 static bool isChartOrMathContext(const Context& context)
1583 {
1584     return context.msApplication == "com.sun.star.chart2.ChartDocument"
1585            || context.msApplication == "com.sun.star.formula.FormulaProperties";
1586 }
1587
1588 bool SidebarController::hasChartOrMathContextCurrently() const
1589 {
1590     if ((maRequestedContext != maCurrentContext) && isChartOrMathContext(maRequestedContext))
1591         return true; // We are not yet changed, but in the process
1592
1593     return isChartOrMathContext(maCurrentContext);
1594 }
1595
1596 sfx2::sidebar::SidebarController* SidebarController::GetSidebarControllerForView(const SfxViewShell* pViewShell)
1597 {
1598     if (!pViewShell)
1599         return nullptr;
1600
1601     Reference<css::frame::XController2> xController(pViewShell->GetController(), UNO_QUERY);
1602     if (!xController.is())
1603         return nullptr;
1604
1605     // Make sure there is a model behind the controller, otherwise getSidebar() can crash.
1606     if (!xController->getModel().is())
1607         return nullptr;
1608
1609     Reference<css::ui::XSidebarProvider> xSidebarProvider = xController->getSidebar();
1610     if (!xSidebarProvider.is())
1611         return nullptr;
1612
1613     Reference<css::ui::XSidebar> xSidebar = xSidebarProvider->getSidebar();
1614     if (!xSidebar.is())
1615         return nullptr;
1616
1617     return dynamic_cast<sfx2::sidebar::SidebarController*>(xSidebar.get());
1618 }
1619
1620 } // end of namespace sfx2::sidebar
1621
1622 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */