sfx2/source/notebookbar/SfxNotebookBar.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
  10 #include <sfx2/bindings.hxx>
  11 #include <sfx2/viewsh.hxx>
  12 #include <sfx2/dispatch.hxx>
  13 #include <sfx2/notebookbar/SfxNotebookBar.hxx>
  14 #include <vcl/syswin.hxx>
  15 #include <sfx2/viewfrm.hxx>
  16 #include <sfx2/sfxsids.hrc>
  17 #include <sfx2/weldutils.hxx>
  18 #include <comphelper/processfactory.hxx>
  19 #include <comphelper/lok.hxx>
  20 #include <com/sun/star/frame/UnknownModuleException.hpp>
  21 #include <com/sun/star/frame/XLayoutManager.hpp>
  22 #include <officecfg/Office/UI/ToolbarMode.hxx>
  23 #include <com/sun/star/frame/XModuleManager.hpp>
  24 #include <com/sun/star/frame/ModuleManager.hpp>
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26 #include <unotools/confignode.hxx>
  27 #include <comphelper/types.hxx>
  28 #include <framework/addonsoptions.hxx>
  29 #include <vcl/notebookbar/NotebookBarAddonsMerger.hxx>
  30 #include <vector>
  31 #include <unordered_map>
  32 #include <vcl/WeldedTabbedNotebookbar.hxx>
  33
  34 using namespace sfx2;
  35 using namespace css::uno;
  36 using namespace css::ui;
  37 using namespace css;
  38
  39 constexpr OUString MENUBAR_STR = u"private:resource/menubar/menubar"_ustr;
  40
  41 const char MERGE_NOTEBOOKBAR_URL[] = "URL";
  42
  43 bool SfxNotebookBar::m_bLock = false;
  44 bool SfxNotebookBar::m_bHide = false;
  45
  46 namespace
  47 {
  48
  49 /** View specific notebook bar data */
  50 struct NotebookBarViewData
  51 {
  52     std::unique_ptr<WeldedTabbedNotebookbar> m_pWeldedWrapper;
  53     VclPtr<NotebookBar> m_pNotebookBar;
  54     std::unique_ptr<ToolbarUnoDispatcher> m_pToolbarUnoDispatcher;
  55
  56     ~NotebookBarViewData()
  57     {
  58         if (m_pNotebookBar)
  59             m_pNotebookBar.disposeAndClear();
  60     }
  61 };
  62
  63 /** Notebookbar instance manager is a singleton that is used for track the
  64  *  per-view instances of view specific data contained in NotebookBarViewData
  65  *  class.
  66  **/
  67 class NotebookBarViewManager final
  68 {
  69 private:
  70     // map contains a view data instance for a view (SfxViewShell pointer)
  71     std::unordered_map<const SfxViewShell*, std::unique_ptr<NotebookBarViewData>> m_pViewDataList;
  72
  73     // private constructor to prevent any other instantiation outside of get() method
  74     NotebookBarViewManager() = default;
  75
  76     // prevent class copying
  77     NotebookBarViewManager(const NotebookBarViewManager&) = delete;
  78     NotebookBarViewManager& operator=(const NotebookBarViewManager&) = delete;
  79
  80 public:
  81     // Singleton get method - creates an instance on first get() call
  82     static NotebookBarViewManager& get()
  83     {
  84         static NotebookBarViewManager gNotebookBarManager;
  85         return gNotebookBarManager;
  86     }
  87
  88     NotebookBarViewData& getViewData(const SfxViewShell* pViewShell)
  89     {
  90         auto aFound = m_pViewDataList.find(pViewShell);
  91         if (aFound != m_pViewDataList.end()) // found
  92             return *aFound->second;
  93
  94         // Create new view data instance
  95         NotebookBarViewData* pViewData = new NotebookBarViewData;
  96         m_pViewDataList.emplace(pViewShell, std::unique_ptr<NotebookBarViewData>(pViewData));
  97         return *pViewData;
  98     }
  99
 100     void removeViewData(const SfxViewShell* pViewShell)
 101     {
 102         m_pViewDataList.erase(pViewShell);
 103     }
 104 };
 105
 106 } // end anonymous namespace
 107
 108 static void NotebookbarAddonValues(
 109     std::vector<Image>& aImageValues,
 110     std::vector<css::uno::Sequence<css::uno::Sequence<css::beans::PropertyValue>>>&
 111         aExtensionValues)
 112 {
 113     if (comphelper::LibreOfficeKit::isActive())
 114         return;
 115
 116     framework::AddonsOptions aAddonsItems;
 117
 118     for (int nIdx = 0; nIdx < aAddonsItems.GetAddonsNotebookBarCount(); nIdx++)
 119     {
 120         const css::uno::Sequence<css::uno::Sequence<css::beans::PropertyValue>> aExtension
 121             = aAddonsItems.GetAddonsNotebookBarPart(nIdx);
 122         for (const css::uno::Sequence<css::beans::PropertyValue>& rExtensionVal : aExtension)
 123         {
 124             Image aImage;
 125             bool isBigImage = true;
 126             for (const auto& rProp : rExtensionVal)
 127             {
 128                 if (rProp.Name == MERGE_NOTEBOOKBAR_URL)
 129                 {
 130                     OUString sImage;
 131                     rProp.Value >>= sImage;
 132                     aImage = Image(aAddonsItems.GetImageFromURL(sImage, isBigImage));
 133                 }
 134             }
 135             aImageValues.push_back(aImage);
 136         }
 137         aExtensionValues.push_back(aExtension);
 138     }
 139 }
 140
 141 static Reference<frame::XLayoutManager> lcl_getLayoutManager( const Reference<frame::XFrame>& xFrame )
 142 {
 143     css::uno::Reference<css::frame::XLayoutManager> xLayoutManager;
 144
 145     if (xFrame.is())
 146     {
 147         Reference<css::beans::XPropertySet> xPropSet(xFrame, UNO_QUERY);
 148
 149         if (xPropSet.is())
 150         {
 151             Any aValue = xPropSet->getPropertyValue("LayoutManager");
 152             aValue >>= xLayoutManager;
 153         }
 154     }
 155
 156     return xLayoutManager;
 157 }
 158
 159 static OUString lcl_getAppName( vcl::EnumContext::Application eApp )
 160 {
 161     switch ( eApp )
 162     {
 163         case vcl::EnumContext::Application::Writer:
 164             return "Writer";
 165         case vcl::EnumContext::Application::Calc:
 166             return "Calc";
 167         case vcl::EnumContext::Application::Impress:
 168             return "Impress";
 169         case vcl::EnumContext::Application::Draw:
 170             return "Draw";
 171         case vcl::EnumContext::Application::Formula:
 172             return "Formula";
 173         default:
 174             return OUString();
 175     }
 176 }
 177
 178 static void lcl_setNotebookbarFileName( vcl::EnumContext::Application eApp, const OUString& sFileName )
 179 {
 180     std::shared_ptr<comphelper::ConfigurationChanges> aBatch(
 181                 comphelper::ConfigurationChanges::create() );
 182     switch ( eApp )
 183     {
 184         case vcl::EnumContext::Application::Writer:
 185             officecfg::Office::UI::ToolbarMode::ActiveWriter::set( sFileName, aBatch );
 186             break;
 187         case vcl::EnumContext::Application::Calc:
 188             officecfg::Office::UI::ToolbarMode::ActiveCalc::set( sFileName, aBatch );
 189             break;
 190         case vcl::EnumContext::Application::Impress:
 191             officecfg::Office::UI::ToolbarMode::ActiveImpress::set( sFileName, aBatch );
 192             break;
 193         case vcl::EnumContext::Application::Draw:
 194             officecfg::Office::UI::ToolbarMode::ActiveDraw::set( sFileName, aBatch );
 195             break;
 196         default:
 197             break;
 198     }
 199     aBatch->commit();
 200 }
 201
 202 static OUString lcl_getNotebookbarFileName( vcl::EnumContext::Application eApp )
 203 {
 204     switch ( eApp )
 205     {
 206         case vcl::EnumContext::Application::Writer:
 207             return officecfg::Office::UI::ToolbarMode::ActiveWriter::get();
 208         case vcl::EnumContext::Application::Calc:
 209             return officecfg::Office::UI::ToolbarMode::ActiveCalc::get();
 210         case vcl::EnumContext::Application::Impress:
 211             return officecfg::Office::UI::ToolbarMode::ActiveImpress::get();
 212         case vcl::EnumContext::Application::Draw:
 213             return officecfg::Office::UI::ToolbarMode::ActiveDraw::get();
 214
 215         default:
 216             break;
 217     }
 218     return OUString();
 219 }
 220
 221 static utl::OConfigurationTreeRoot lcl_getCurrentImplConfigRoot()
 222 {
 223     return utl::OConfigurationTreeRoot(::comphelper::getProcessComponentContext(),
 224                                        "org.openoffice.Office.UI.ToolbarMode/",
 225                                        true);
 226 }
 227
 228 static utl::OConfigurationNode lcl_getCurrentImplConfigNode(const Reference<css::frame::XFrame>& xFrame,
 229                                                                   utl::OConfigurationTreeRoot const & rNotebookbarNode )
 230 {
 231     if (!rNotebookbarNode.isValid())
 232         return utl::OConfigurationNode();
 233
 234     const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( ::comphelper::getProcessComponentContext() );
 235
 236     vcl::EnumContext::Application eApp = vcl::EnumContext::GetApplicationEnum( xModuleManager->identify( xFrame ) );
 237     OUString aActive = lcl_getNotebookbarFileName( eApp );
 238
 239     const utl::OConfigurationNode aImplsNode = rNotebookbarNode.openNode("Applications/" + lcl_getAppName( eApp) + "/Modes");
 240     const Sequence<OUString> aModeNodeNames( aImplsNode.getNodeNames() );
 241
 242     for ( const auto& rModeNodeName : aModeNodeNames )
 243     {
 244         const utl::OConfigurationNode aImplNode( aImplsNode.openNode( rModeNodeName ) );
 245         if ( !aImplNode.isValid() )
 246             continue;
 247
 248         OUString aCommandArg = comphelper::getString( aImplNode.getNodeValue( "CommandArg" ) );
 249
 250         if ( aCommandArg == aActive )
 251         {
 252             return aImplNode;
 253         }
 254     }
 255
 256     return utl::OConfigurationNode();
 257 }
 258
 259 void SfxNotebookBar::RemoveCurrentLOKWrapper()
 260 {
 261     const SfxViewShell* pViewShell = SfxViewShell::Current();
 262     auto& rViewData = NotebookBarViewManager::get().getViewData(pViewShell);
 263
 264     if (rViewData.m_pNotebookBar)
 265     {
 266         // Calls STATIC_LINK SfxNotebookBar -> VclDisposeHdl
 267         // which clears the whole InstanceManager
 268         rViewData.m_pNotebookBar.disposeAndClear();
 269     }
 270 }
 271
 272 void SfxNotebookBar::CloseMethod(SfxBindings& rBindings)
 273 {
 274     SfxFrame& rFrame = rBindings.GetDispatcher_Impl()->GetFrame()->GetFrame();
 275     CloseMethod(rFrame.GetSystemWindow());
 276 }
 277
 278 void SfxNotebookBar::CloseMethod(SystemWindow* pSysWindow)
 279 {
 280     if (comphelper::LibreOfficeKit::isActive())
 281     {
 282         RemoveCurrentLOKWrapper();
 283         return;
 284     }
 285
 286     if (pSysWindow)
 287     {
 288         if(pSysWindow->GetNotebookBar())
 289             pSysWindow->CloseNotebookBar();
 290         if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 291             SfxNotebookBar::ShowMenubar(pViewFrm, true);
 292     }
 293 }
 294
 295 void SfxNotebookBar::LockNotebookBar()
 296 {
 297     m_bHide = true;
 298     m_bLock = true;
 299 }
 300
 301 void SfxNotebookBar::UnlockNotebookBar()
 302 {
 303     m_bHide = false;
 304     m_bLock = false;
 305 }
 306
 307 bool SfxNotebookBar::IsActive(bool bConsiderSingleToolbar)
 308 {
 309     if (m_bHide)
 310         return false;
 311
 312     vcl::EnumContext::Application eApp = vcl::EnumContext::Application::Any;
 313
 314     if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 315     {
 316         const Reference<frame::XFrame>& xFrame = pViewFrm->GetFrame().GetFrameInterface();
 317         if (!xFrame.is())
 318             return false;
 319
 320         const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( ::comphelper::getProcessComponentContext() );
 321         try
 322         {
 323             eApp = vcl::EnumContext::GetApplicationEnum(xModuleManager->identify(xFrame));
 324         }
 325         catch (css::frame::UnknownModuleException& e)
 326         {
 327             SAL_WARN("sfx.appl", "SfxNotebookBar::IsActive(): " + e.Message);
 328             return false;
 329         }
 330     }
 331     else
 332         return false;
 333
 334     OUString appName(lcl_getAppName( eApp ));
 335
 336     if (appName.isEmpty())
 337         return false;
 338
 339
 340     OUString aPath = "org.openoffice.Office.UI.ToolbarMode/Applications/" + appName;
 341
 342     const utl::OConfigurationTreeRoot aAppNode(
 343                                         ::comphelper::getProcessComponentContext(),
 344                                         aPath,
 345                                         false);
 346     if ( !aAppNode.isValid() )
 347         return false;
 348
 349     OUString aActive = comphelper::getString( aAppNode.getNodeValue( "Active" ) );
 350
 351     if (bConsiderSingleToolbar && aActive == "Single")
 352         return true;
 353
 354     if (comphelper::LibreOfficeKit::isActive() && aActive == "notebookbar_online.ui")
 355         return true;
 356
 357     const utl::OConfigurationNode aModesNode = aAppNode.openNode("Modes");
 358     const Sequence<OUString> aModeNodeNames( aModesNode.getNodeNames() );
 359
 360     for ( const auto& rModeNodeName : aModeNodeNames )
 361     {
 362         const utl::OConfigurationNode aModeNode( aModesNode.openNode( rModeNodeName ) );
 363         if ( !aModeNode.isValid() )
 364             continue;
 365
 366         OUString aCommandArg = comphelper::getString( aModeNode.getNodeValue( "CommandArg" ) );
 367
 368         if ( aCommandArg == aActive )
 369         {
 370             return comphelper::getBOOL( aModeNode.getNodeValue( "HasNotebookbar" ) );
 371         }
 372     }
 373     return false;
 374 }
 375
 376 void SfxNotebookBar::ResetActiveToolbarModeToDefault(vcl::EnumContext::Application eApp)
 377 {
 378     const OUString appName( lcl_getAppName( eApp ) );
 379
 380     if ( appName.isEmpty() )
 381         return;
 382
 383     const OUString aPath = "org.openoffice.Office.UI.ToolbarMode/Applications/" + appName;
 384
 385     utl::OConfigurationTreeRoot aAppNode(
 386                                         ::comphelper::getProcessComponentContext(),
 387                                         aPath,
 388                                         true);
 389     if ( !aAppNode.isValid() )
 390         return;
 391
 392     aAppNode.setNodeValue( "Active", Any( OUString( "Default" ) ) );
 393     aAppNode.commit();
 394 }
 395
 396 void SfxNotebookBar::ExecMethod(SfxBindings& rBindings, const OUString& rUIName)
 397 {
 398     // Save active UI file name
 399     if (!rUIName.isEmpty())
 400     {
 401         if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 402         {
 403             const Reference<frame::XFrame>& xFrame = pViewFrm->GetFrame().GetFrameInterface();
 404             if (xFrame.is())
 405             {
 406                 const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( ::comphelper::getProcessComponentContext() );
 407                 vcl::EnumContext::Application eApp = vcl::EnumContext::GetApplicationEnum(xModuleManager->identify(xFrame));
 408                 lcl_setNotebookbarFileName( eApp, rUIName );
 409             }
 410         }
 411     }
 412
 413     // trigger the StateMethod
 414     rBindings.Invalidate(SID_NOTEBOOKBAR);
 415     rBindings.Update();
 416 }
 417
 418 bool SfxNotebookBar::StateMethod(SfxBindings& rBindings, std::u16string_view rUIFile,
 419                                  bool bReloadNotebookbar)
 420 {
 421     SfxFrame& rFrame = rBindings.GetDispatcher_Impl()->GetFrame()->GetFrame();
 422     return StateMethod(rFrame.GetSystemWindow(), rFrame.GetFrameInterface(), rUIFile,
 423                        bReloadNotebookbar);
 424 }
 425
 426 bool SfxNotebookBar::StateMethod(SystemWindow* pSysWindow,
 427                                  const Reference<css::frame::XFrame>& xFrame,
 428                                  std::u16string_view rUIFile, bool bReloadNotebookbar)
 429 {
 430     if (!pSysWindow)
 431     {
 432         SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 433         if (pViewFrm && pViewFrm->GetWindow().GetSystemWindow())
 434             pSysWindow = pViewFrm->GetWindow().GetSystemWindow();
 435         else
 436             return false;
 437     }
 438
 439     const SfxViewShell* pViewShell = SfxViewShell::Current();
 440     auto& rViewData = NotebookBarViewManager::get().getViewData(pViewShell);
 441     bool hasWeldedWrapper = bool(rViewData.m_pWeldedWrapper);
 442
 443     if (IsActive())
 444     {
 445         css::uno::Reference<css::uno::XComponentContext> xContext = comphelper::getProcessComponentContext();
 446         const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( xContext );
 447         OUString aModuleName = xModuleManager->identify( xFrame );
 448         vcl::EnumContext::Application eApp = vcl::EnumContext::GetApplicationEnum( aModuleName );
 449         bool bIsLOK = comphelper::LibreOfficeKit::isActive();
 450
 451         OUString sFile;
 452         if (bIsLOK)
 453             sFile = "notebookbar_online.ui";
 454         else
 455             sFile = lcl_getNotebookbarFileName( eApp );
 456
 457         OUString sNewFile = rUIFile + sFile;
 458         OUString sCurrentFile;
 459         VclPtr<NotebookBar> pNotebookBar = pSysWindow->GetNotebookBar();
 460         if ( pNotebookBar )
 461             sCurrentFile = pNotebookBar->GetUIFilePath();
 462
 463         bool bChangedFile = sNewFile != sCurrentFile;
 464
 465         if ((!bIsLOK && (
 466                 (!sFile.isEmpty() && bChangedFile) ||
 467                 (!pNotebookBar || !pNotebookBar->IsVisible()) ||
 468                 bReloadNotebookbar)
 469             ) || (bIsLOK && !hasWeldedWrapper))
 470         {
 471             OUString aBuf = rUIFile + sFile;
 472
 473             //Addons For Notebookbar
 474             std::vector<Image> aImageValues;
 475             std::vector<css::uno::Sequence< css::uno::Sequence< css::beans::PropertyValue > > > aExtensionValues;
 476             NotebookBarAddonsItem aNotebookBarAddonsItem;
 477             NotebookbarAddonValues(aImageValues , aExtensionValues);
 478             aNotebookBarAddonsItem.aAddonValues = aExtensionValues;
 479             aNotebookBarAddonsItem.aImageValues = aImageValues;
 480
 481             if (bIsLOK)
 482             {
 483                 if (!pViewShell)
 484                     return false;
 485
 486                 // Notebookbar was loaded too early what caused:
 487                 //   * in LOK: Paste Special feature was incorrectly initialized
 488                 // Skip first request so Notebookbar will be initialized after document was loaded
 489                 static std::map<const void*, bool> bSkippedFirstInit;
 490                 if (eApp == vcl::EnumContext::Application::Writer
 491                     && bSkippedFirstInit.find(pViewShell) == bSkippedFirstInit.end())
 492                 {
 493                     bSkippedFirstInit[pViewShell] = true;
 494                     ResetActiveToolbarModeToDefault(eApp);
 495                     return false;
 496                 }
 497
 498                 // update the current LOK language and locale for the dialog tunneling
 499                 comphelper::LibreOfficeKit::setLanguageTag(pViewShell->GetLOKLanguageTag());
 500                 comphelper::LibreOfficeKit::setLocale(pViewShell->GetLOKLocale());
 501
 502                 pNotebookBar = VclPtr<NotebookBar>::Create(pSysWindow, "NotebookBar", aBuf, xFrame, aNotebookBarAddonsItem);
 503                 rViewData.m_pNotebookBar = pNotebookBar;
 504                 assert(pNotebookBar->IsWelded());
 505
 506                 sal_uInt64 nWindowId = reinterpret_cast<sal_uInt64>(pViewShell);
 507                 rViewData.m_pWeldedWrapper.reset(
 508                         new WeldedTabbedNotebookbar(pNotebookBar->GetMainContainer(),
 509                                                     pNotebookBar->GetUIFilePath(),
 510                                                     xFrame, nWindowId));
 511                 pNotebookBar->SetDisposeCallback(LINK(nullptr, SfxNotebookBar, VclDisposeHdl), pViewShell);
 512
 513                 rViewData.m_pToolbarUnoDispatcher.reset(
 514                     new ToolbarUnoDispatcher(rViewData.m_pWeldedWrapper->getWeldedToolbar(),
 515                                              rViewData.m_pWeldedWrapper->getBuilder(), xFrame));
 516
 517                 return true;
 518             }
 519
 520             RemoveListeners(pSysWindow);
 521
 522             pSysWindow->SetNotebookBar(aBuf, xFrame, aNotebookBarAddonsItem , bReloadNotebookbar);
 523             pNotebookBar = pSysWindow->GetNotebookBar();
 524             pNotebookBar->Show();
 525
 526             pNotebookBar->GetParent()->Resize();
 527
 528             utl::OConfigurationTreeRoot aRoot(lcl_getCurrentImplConfigRoot());
 529             const utl::OConfigurationNode aModeNode(lcl_getCurrentImplConfigNode(xFrame, aRoot));
 530             SfxNotebookBar::ShowMenubar( comphelper::getBOOL( aModeNode.getNodeValue( "HasMenubar" ) ) );
 531
 532             SfxViewFrame* pView = SfxViewFrame::Current();
 533
 534             if(pView)
 535             {
 536                 pNotebookBar->SetupListener(true);
 537             }
 538         }
 539
 540         return true;
 541     }
 542     else if (comphelper::LibreOfficeKit::isActive())
 543     {
 544         // don't do anything to not close notebookbar of other session
 545         return hasWeldedWrapper;
 546     }
 547     else if (auto pNotebookBar = pSysWindow->GetNotebookBar())
 548     {
 549         vcl::Window* pParent = pNotebookBar->GetParent();
 550         pSysWindow->CloseNotebookBar();
 551         pParent->Resize();
 552         SfxNotebookBar::ShowMenubar(true);
 553     }
 554
 555     return false;
 556 }
 557
 558 void SfxNotebookBar::RemoveListeners(SystemWindow const * pSysWindow)
 559 {
 560     if (auto pNotebookBar = pSysWindow->GetNotebookBar())
 561     {
 562         pNotebookBar->SetupListener(false);
 563     }
 564 }
 565
 566 void SfxNotebookBar::ShowMenubar(bool bShow)
 567 {
 568     if (m_bLock)
 569         return;
 570
 571     m_bLock = true;
 572
 573     Reference<frame::XFrame> xFrame;
 574     vcl::EnumContext::Application eCurrentApp = vcl::EnumContext::Application::NONE;
 575     uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
 576     const Reference<frame::XModuleManager> xModuleManager = frame::ModuleManager::create( xContext );
 577
 578     if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 579     {
 580         xFrame = pViewFrm->GetFrame().GetFrameInterface();
 581         eCurrentApp = vcl::EnumContext::GetApplicationEnum( xModuleManager->identify( xFrame ) );
 582     }
 583
 584     SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst();
 585     while( pViewFrame )
 586     {
 587         xFrame = pViewFrame->GetFrame().GetFrameInterface();
 588         if ( xFrame.is() )
 589         {
 590             vcl::EnumContext::Application eApp =
 591                     vcl::EnumContext::GetApplicationEnum( xModuleManager->identify( xFrame ) );
 592
 593             if ( eApp == eCurrentApp )
 594             {
 595                 const Reference<frame::XLayoutManager>& xLayoutManager =
 596                                                         lcl_getLayoutManager( xFrame );
 597
 598                 if (xLayoutManager.is())
 599                 {
 600                     if (xLayoutManager->getElement(MENUBAR_STR).is())
 601                     {
 602                         if (xLayoutManager->isElementVisible(MENUBAR_STR) && !bShow)
 603                             xLayoutManager->hideElement(MENUBAR_STR);
 604                         else if(!xLayoutManager->isElementVisible(MENUBAR_STR) && bShow)
 605                             xLayoutManager->showElement(MENUBAR_STR);
 606                     }
 607                 }
 608             }
 609         }
 610
 611         pViewFrame = SfxViewFrame::GetNext( *pViewFrame );
 612     }
 613     m_bLock = false;
 614 }
 615
 616 void SfxNotebookBar::ShowMenubar(SfxViewFrame const * pViewFrame, bool bShow)
 617 {
 618     if (m_bLock)
 619         return;
 620
 621     m_bLock = true;
 622
 623     Reference<frame::XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface();
 624     if (xFrame.is())
 625     {
 626         const Reference<frame::XLayoutManager>& xLayoutManager = lcl_getLayoutManager(xFrame);
 627         if (xLayoutManager.is())
 628         {
 629             if (xLayoutManager->getElement(MENUBAR_STR).is())
 630             {
 631                 if (xLayoutManager->isElementVisible(MENUBAR_STR) && !bShow)
 632                     xLayoutManager->hideElement(MENUBAR_STR);
 633                 else if (!xLayoutManager->isElementVisible(MENUBAR_STR) && bShow)
 634                     xLayoutManager->showElement(MENUBAR_STR);
 635             }
 636         }
 637     }
 638     m_bLock = false;
 639 }
 640
 641 void SfxNotebookBar::ToggleMenubar()
 642 {
 643     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 644     if (!pViewFrm)
 645         return;
 646
 647     const Reference<frame::XFrame>& xFrame = pViewFrm->GetFrame().GetFrameInterface();
 648     if (!xFrame.is())
 649         return;
 650
 651     const Reference<frame::XLayoutManager>& xLayoutManager =
 652                                             lcl_getLayoutManager(xFrame);
 653
 654     bool bShow = true;
 655     if (xLayoutManager.is() && xLayoutManager->getElement(MENUBAR_STR).is())
 656     {
 657         if (xLayoutManager->isElementVisible(MENUBAR_STR))
 658         {
 659             SfxNotebookBar::ShowMenubar(false);
 660             bShow = false;
 661         }
 662         else
 663             SfxNotebookBar::ShowMenubar(true);
 664     }
 665
 666     // Save menubar settings
 667     if (IsActive())
 668     {
 669         utl::OConfigurationTreeRoot aRoot(lcl_getCurrentImplConfigRoot());
 670         utl::OConfigurationNode aModeNode(lcl_getCurrentImplConfigNode(xFrame, aRoot));
 671         aModeNode.setNodeValue( "HasMenubar", toAny<bool>( bShow ) );
 672         aRoot.commit();
 673     }
 674 }
 675
 676 void SfxNotebookBar::ReloadNotebookBar(std::u16string_view sUIPath)
 677 {
 678     if (!SfxNotebookBar::IsActive())
 679         return;
 680     SfxViewShell* pViewShell = SfxViewShell::Current();
 681     if (!pViewShell)
 682         return;
 683     sfx2::SfxNotebookBar::StateMethod(pViewShell->GetViewFrame().GetBindings(), sUIPath, true);
 684 }
 685
 686 IMPL_STATIC_LINK(SfxNotebookBar, VclDisposeHdl, const SfxViewShell*, pViewShell, void)
 687 {
 688     NotebookBarViewManager::get().removeViewData(pViewShell);
 689 }
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */