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 "SidebarController.hxx"
  20 #include "Deck.hxx"
  21 #include "DeckTitleBar.hxx"
  22 #include "Panel.hxx"
  23 #include "PanelTitleBar.hxx"
  24 #include "SidebarResource.hxx"
  25 #include "TabBar.hxx"
  26 #include <sfx2/sidebar/Theme.hxx>
  27 #include <sfx2/sidebar/SidebarChildWindow.hxx>
  28 #include <sfx2/sidebar/Tools.hxx>
  29 #include "SidebarDockingWindow.hxx"
  30 #include "Context.hxx"
  31
  32 #include <sfx2/sfxresid.hxx>
  33 #include <sfx2/sfxsids.hrc>
  34 #include <sfx2/titledockwin.hxx>
  35 #include "sfxlocal.hrc"
  36 #include <vcl/floatwin.hxx>
  37 #include <vcl/fixed.hxx>
  38 #include "splitwin.hxx"
  39 #include <svl/smplhint.hxx>
  40 #include <tools/link.hxx>
  41 #include <toolkit/helper/vclunohelper.hxx>
  42 #include <comphelper/processfactory.hxx>
  43 #include <comphelper/namedvaluecollection.hxx>
  44
  45 #include <com/sun/star/frame/XDispatchProvider.hpp>
  46 #include <com/sun/star/lang/XInitialization.hpp>
  47 #include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp>
  48 #include <com/sun/star/ui/ContextChangeEventObject.hpp>
  49 #include <com/sun/star/ui/theUIElementFactoryManager.hpp>
  50 #include <com/sun/star/util/XURLTransformer.hpp>
  51 #include <com/sun/star/util/URL.hpp>
  52 #include <com/sun/star/rendering/XSpriteCanvas.hpp>
  53
  54 #include <boost/bind.hpp>
  55 #include <boost/function.hpp>
  56 #include <boost/scoped_array.hpp>
  57
  58 using namespace css;
  59 using namespace css::uno;
  60 using ::rtl::OUString;
  61
  62 namespace
  63 {
  64     const static char gsReadOnlyCommandName[] = ".uno:EditDoc";
  65     const static char gsHideSidebarCommandName[] = ".uno:Sidebar";
  66     const static sal_Int32 gnMaximumSidebarWidth (400);
  67     const static sal_Int32 gnWidthCloseThreshold (70);
  68     const static sal_Int32 gnWidthOpenThreshold (40);
  69 }
  70
  71 namespace sfx2 { namespace sidebar {
  72
  73 SidebarController::SidebarControllerContainer SidebarController::maSidebarControllerContainer;
  74
  75 namespace {
  76     enum MenuId
  77     {
  78         MID_UNLOCK_TASK_PANEL = 1,
  79         MID_LOCK_TASK_PANEL,
  80         MID_HIDE_SIDEBAR,
  81         MID_CUSTOMIZATION,
  82         MID_RESTORE_DEFAULT,
  83         MID_FIRST_PANEL,
  84         MID_FIRST_HIDE = 1000
  85     };
  86
  87     /** When in doubt, show this deck.
  88     */
  89     static const char gsDefaultDeckId[] = "PropertyDeck";
  90 }
  91
  92 SidebarController::SidebarController (
  93     SidebarDockingWindow* pParentWindow,
  94     const css::uno::Reference<css::frame::XFrame>& rxFrame)
  95     : SidebarControllerInterfaceBase(m_aMutex),
  96       mpCurrentDeck(),
  97       mpParentWindow(pParentWindow),
  98       mpTabBar(VclPtr<TabBar>::Create(
  99               mpParentWindow,
 100               rxFrame,
 101               ::boost::bind(&SidebarController::OpenThenSwitchToDeck, this, _1),
 102               ::boost::bind(&SidebarController::ShowPopupMenu, this, _1,_2))),
 103       mxFrame(rxFrame),
 104       maCurrentContext(OUString(), OUString()),
 105       maRequestedContext(),
 106       mnRequestedForceFlags(SwitchFlag_NoForce),
 107       msCurrentDeckId(gsDefaultDeckId),
 108       msCurrentDeckTitle(),
 109       maPropertyChangeForwarder(::boost::bind(&SidebarController::BroadcastPropertyChange, this)),
 110       maContextChangeUpdate(::boost::bind(&SidebarController::UpdateConfigurations, this)),
 111       maAsynchronousDeckSwitch(),
 112       mbIsDeckRequestedOpen(),
 113       mbIsDeckOpen(),
 114       mbCanDeckBeOpened(true),
 115       mnSavedSidebarWidth(pParentWindow->GetSizePixel().Width()),
 116       maFocusManager(::boost::bind(&SidebarController::ShowPanel, this, _1)),
 117       mxReadOnlyModeDispatch(),
 118       mbIsDocumentReadOnly(false),
 119       mpSplitWindow(NULL),
 120       mnWidthOnSplitterButtonDown(0)
 121 {
 122     // Listen for context change events.
 123     css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
 124         css::ui::ContextChangeEventMultiplexer::get(
 125             ::comphelper::getProcessComponentContext()));
 126     if (xMultiplexer.is())
 127         xMultiplexer->addContextChangeEventListener(
 128             static_cast<css::ui::XContextChangeEventListener*>(this),
 129             mxFrame->getController());
 130
 131     // Listen for window events.
 132     mpParentWindow->AddEventListener(LINK(this, SidebarController, WindowEventHandler));
 133
 134     // Listen for theme property changes.
 135     Theme::GetPropertySet()->addPropertyChangeListener(
 136         OUString(""),
 137         static_cast<css::beans::XPropertyChangeListener*>(this));
 138
 139     // Get the dispatch object as preparation to listen for changes of
 140     // the read-only state.
 141     const util::URL aURL (Tools::GetURL(gsReadOnlyCommandName));
 142     mxReadOnlyModeDispatch = Tools::GetDispatch(mxFrame, aURL);
 143     if (mxReadOnlyModeDispatch.is())
 144         mxReadOnlyModeDispatch->addStatusListener(this, aURL);
 145
 146     SwitchToDeck(gsDefaultDeckId);
 147
 148     WeakReference<SidebarController> xWeakController (this);
 149     maSidebarControllerContainer.insert(
 150         SidebarControllerContainer::value_type(
 151             rxFrame,
 152             xWeakController));
 153 }
 154
 155 SidebarController::~SidebarController()
 156 {
 157 }
 158
 159 SidebarController* SidebarController::GetSidebarControllerForFrame (
 160     const css::uno::Reference<css::frame::XFrame>& rxFrame)
 161 {
 162     SidebarControllerContainer::iterator iEntry (maSidebarControllerContainer.find(rxFrame));
 163     if (iEntry == maSidebarControllerContainer.end())
 164         return NULL;
 165
 166     css::uno::Reference<XInterface> xController (iEntry->second.get());
 167     if ( ! xController.is())
 168         return NULL;
 169
 170     return dynamic_cast<SidebarController*>(xController.get());
 171 }
 172
 173 void SAL_CALL SidebarController::disposing()
 174 {
 175     mpCloseIndicator.disposeAndClear();
 176
 177     SidebarControllerContainer::iterator iEntry (maSidebarControllerContainer.find(mxFrame));
 178     if (iEntry != maSidebarControllerContainer.end())
 179         maSidebarControllerContainer.erase(iEntry);
 180
 181     maFocusManager.Clear();
 182
 183     css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
 184         css::ui::ContextChangeEventMultiplexer::get(
 185             ::comphelper::getProcessComponentContext()));
 186     if (xMultiplexer.is())
 187         xMultiplexer->removeAllContextChangeEventListeners(
 188             static_cast<css::ui::XContextChangeEventListener*>(this));
 189
 190     if (mxReadOnlyModeDispatch.is())
 191         mxReadOnlyModeDispatch->removeStatusListener(this, Tools::GetURL(gsReadOnlyCommandName));
 192     if (mpSplitWindow != nullptr)
 193     {
 194         mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
 195         mpSplitWindow = NULL;
 196     }
 197
 198     if (mpParentWindow != nullptr)
 199     {
 200         mpParentWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
 201         mpParentWindow = NULL;
 202     }
 203
 204     if (mpCurrentDeck)
 205     {
 206         mpCurrentDeck.disposeAndClear();
 207     }
 208
 209     mpTabBar.disposeAndClear();
 210
 211     Theme::GetPropertySet()->removePropertyChangeListener(
 212         OUString(""),
 213         static_cast<css::beans::XPropertyChangeListener*>(this));
 214
 215     maContextChangeUpdate.CancelRequest();
 216     maAsynchronousDeckSwitch.CancelRequest();
 217 }
 218
 219 void SAL_CALL SidebarController::notifyContextChangeEvent (const css::ui::ContextChangeEventObject& rEvent)
 220     throw(css::uno::RuntimeException, std::exception)
 221 {
 222     // Update to the requested new context asynchronously to avoid
 223     // subtle errors caused by SFX2 which in rare cases can not
 224     // properly handle a synchronous update.
 225     maRequestedContext = Context(
 226         rEvent.ApplicationName,
 227         rEvent.ContextName);
 228     if (maRequestedContext != maCurrentContext)
 229     {
 230         maAsynchronousDeckSwitch.CancelRequest();
 231         maContextChangeUpdate.RequestCall();
 232     }
 233 }
 234
 235 void SAL_CALL SidebarController::disposing (const css::lang::EventObject& rEventObject)
 236     throw(css::uno::RuntimeException, std::exception)
 237 {
 238     (void)rEventObject;
 239
 240     dispose();
 241 }
 242
 243 void SAL_CALL SidebarController::propertyChange (const css::beans::PropertyChangeEvent& rEvent)
 244     throw(css::uno::RuntimeException, std::exception)
 245 {
 246     (void)rEvent;
 247
 248     maPropertyChangeForwarder.RequestCall();
 249 }
 250
 251 void SAL_CALL SidebarController::statusChanged (const css::frame::FeatureStateEvent& rEvent)
 252     throw(css::uno::RuntimeException, std::exception)
 253 {
 254     bool bIsReadWrite (true);
 255     if (rEvent.IsEnabled)
 256         rEvent.State >>= bIsReadWrite;
 257
 258     if (mbIsDocumentReadOnly != !bIsReadWrite)
 259     {
 260         mbIsDocumentReadOnly = !bIsReadWrite;
 261
 262         // Force the current deck to update its panel list.
 263         if ( ! mbIsDocumentReadOnly)
 264             msCurrentDeckId = gsDefaultDeckId;
 265         mnRequestedForceFlags |= SwitchFlag_ForceSwitch;
 266         maAsynchronousDeckSwitch.CancelRequest();
 267         maContextChangeUpdate.RequestCall();
 268     }
 269 }
 270
 271 void SAL_CALL SidebarController::requestLayout()
 272     throw(css::uno::RuntimeException, std::exception)
 273 {
 274     sal_Int32 nMinimalWidth = 0;
 275     if (mpCurrentDeck)
 276     {
 277         mpCurrentDeck->RequestLayout();
 278         nMinimalWidth = mpCurrentDeck->GetMinimalWidth();
 279     }
 280     RestrictWidth(nMinimalWidth);
 281 }
 282
 283 void SidebarController::BroadcastPropertyChange()
 284 {
 285     DataChangedEvent aEvent (DataChangedEventType::USER);
 286     mpParentWindow->NotifyAllChildren(aEvent);
 287     mpParentWindow->Invalidate(INVALIDATE_CHILDREN);
 288 }
 289
 290 void SidebarController::NotifyResize()
 291 {
 292     if (!mpTabBar)
 293     {
 294         OSL_ASSERT(mpTabBar!=nullptr);
 295         return;
 296     }
 297
 298     vcl::Window* pParentWindow = mpTabBar->GetParent();
 299     sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();
 300
 301     const sal_Int32 nWidth (pParentWindow->GetSizePixel().Width());
 302     const sal_Int32 nHeight (pParentWindow->GetSizePixel().Height());
 303
 304     mbIsDeckOpen = (nWidth > nTabBarDefaultWidth);
 305
 306     if (mnSavedSidebarWidth <= 0)
 307         mnSavedSidebarWidth = nWidth;
 308
 309     bool bIsDeckVisible;
 310     if (mbCanDeckBeOpened)
 311     {
 312         const bool bIsOpening (nWidth > mnWidthOnSplitterButtonDown);
 313         if (bIsOpening)
 314             bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthOpenThreshold;
 315         else
 316             bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthCloseThreshold;
 317         mbIsDeckRequestedOpen = bIsDeckVisible;
 318         UpdateCloseIndicator(!bIsDeckVisible);
 319     }
 320     else
 321         bIsDeckVisible = false;
 322
 323     if (mpCurrentDeck)
 324     {
 325         SfxSplitWindow* pSplitWindow = GetSplitWindow();
 326         WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WINDOWALIGN_RIGHT;
 327         long nDeckX, nTabX;
 328         if (eAlign == WINDOWALIGN_LEFT)     // attach the Sidebar towards the left-side of screen
 329         {
 330             nDeckX = nTabBarDefaultWidth;
 331             nTabX = 0;
 332         }
 333         else   // attach the Sidebar towards the right-side of screen
 334         {
 335             nDeckX = 0;
 336             nTabX = nWidth-nTabBarDefaultWidth;
 337         }
 338
 339         // Place the deck first.
 340         if (bIsDeckVisible)
 341         {
 342             mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth - nTabBarDefaultWidth, nHeight);
 343             mpCurrentDeck->Show();
 344             mpCurrentDeck->RequestLayout();
 345         }
 346         else
 347             mpCurrentDeck->Hide();
 348
 349         // Now place the tab bar.
 350         mpTabBar->setPosSizePixel(nTabX, 0, nTabBarDefaultWidth, nHeight);
 351         mpTabBar->Show();
 352
 353     }
 354
 355     // Determine if the closer of the deck can be shown.
 356     sal_Int32 nMinimalWidth = 0;
 357     if (mpCurrentDeck)
 358     {
 359         DeckTitleBar* pTitleBar = mpCurrentDeck->GetTitleBar();
 360         if (pTitleBar != NULL && pTitleBar->IsVisible())
 361             pTitleBar->SetCloserVisible(CanModifyChildWindowWidth());
 362         nMinimalWidth = mpCurrentDeck->GetMinimalWidth();
 363     }
 364
 365     RestrictWidth(nMinimalWidth);
 366 }
 367
 368 void SidebarController::ProcessNewWidth (const sal_Int32 nNewWidth)
 369 {
 370     if ( ! mbIsDeckRequestedOpen)
 371         return;
 372
 373     if (mbIsDeckRequestedOpen.get())
 374      {
 375         // Deck became large enough to be shown.  Show it.
 376         mnSavedSidebarWidth = nNewWidth;
 377         RequestOpenDeck();
 378     }
 379     else
 380     {
 381         // Deck became too small.  Close it completely.
 382         // If window is wider than the tab bar then mark the deck as being visible, even when it its not.
 383         // This is to trigger an adjustment of the width to the width of the tab bar.
 384         mbIsDeckOpen = true;
 385         RequestCloseDeck();
 386
 387         if (mnWidthOnSplitterButtonDown > TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor())
 388             mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
 389     }
 390 }
 391
 392 void SidebarController::UpdateConfigurations()
 393 {
 394     if (maCurrentContext != maRequestedContext
 395         || mnRequestedForceFlags!=SwitchFlag_NoForce)
 396     {
 397         maCurrentContext = maRequestedContext;
 398
 399         // Find the set of decks that could be displayed for the new context.
 400         ResourceManager::DeckContextDescriptorContainer aDecks;
 401         ResourceManager::Instance().GetMatchingDecks (
 402             aDecks,
 403             maCurrentContext,
 404             mbIsDocumentReadOnly,
 405             mxFrame);
 406
 407         // Notify the tab bar about the updated set of decks.
 408         mpTabBar->SetDecks(aDecks);
 409
 410         // Find the new deck.  By default that is the same as the old
 411         // one.  If that is not set or not enabled, then choose the
 412         // first enabled deck (which is PropertyDeck).
 413         OUString sNewDeckId;
 414         for (ResourceManager::DeckContextDescriptorContainer::const_iterator
 415                  iDeck(aDecks.begin()),
 416                  iEnd(aDecks.end());
 417              iDeck!=iEnd;
 418              ++iDeck)
 419         {
 420             if (iDeck->mbIsEnabled)
 421             {
 422                 if (iDeck->msId.equals(msCurrentDeckId))
 423                 {
 424                     sNewDeckId = msCurrentDeckId;
 425                     break;
 426                 }
 427                 else if (sNewDeckId.getLength() == 0)
 428                     sNewDeckId = iDeck->msId;
 429             }
 430         }
 431
 432         if (sNewDeckId.getLength() == 0)
 433         {
 434             // We did not find a valid deck.
 435             RequestCloseDeck();
 436             return;
 437         }
 438
 439         // Tell the tab bar to highlight the button associated
 440         // with the deck.
 441         mpTabBar->HighlightDeck(sNewDeckId);
 442
 443         const DeckDescriptor* pDescriptor =
 444             ResourceManager::Instance().GetDeckDescriptor(sNewDeckId);
 445
 446         if (pDescriptor)
 447         {
 448             SwitchToDeck(
 449                 *pDescriptor,
 450                 maCurrentContext);
 451         }
 452     }
 453 }
 454
 455 void SidebarController::OpenThenSwitchToDeck (
 456     const ::rtl::OUString& rsDeckId)
 457 {
 458     SfxSplitWindow* pSplitWindow = GetSplitWindow();
 459     if ( pSplitWindow && !pSplitWindow->IsFadeIn() )
 460         // tdf#83546 Collapsed sidebar should expand first
 461         pSplitWindow->FadeIn();
 462     else if ( IsDeckVisible( rsDeckId ) )
 463     {
 464         if ( pSplitWindow )
 465             // tdf#67627 Clicking a second time on a Deck icon will close the Deck
 466             RequestCloseDeck();
 467         else
 468             // tdf#88241 Summoning an undocked sidebar a second time should close sidebar
 469             mpParentWindow->Close();
 470         return;
 471     }
 472     RequestOpenDeck();
 473     SwitchToDeck(rsDeckId);
 474     mpTabBar->Invalidate();
 475     mpTabBar->HighlightDeck(rsDeckId);
 476 }
 477
 478 void SidebarController::SwitchToDeck (
 479     const ::rtl::OUString& rsDeckId)
 480 {
 481     if ( ! msCurrentDeckId.equals(rsDeckId)
 482         || ! mbIsDeckOpen
 483         || mnRequestedForceFlags!=SwitchFlag_NoForce)
 484     {
 485         const DeckDescriptor* pDeckDescriptor = ResourceManager::Instance().GetDeckDescriptor(rsDeckId);
 486         if (pDeckDescriptor != NULL)
 487             SwitchToDeck(*pDeckDescriptor, maCurrentContext);
 488     }
 489 }
 490
 491 void SidebarController::SwitchToDeck (
 492     const DeckDescriptor& rDeckDescriptor,
 493     const Context& rContext)
 494 {
 495     maFocusManager.Clear();
 496
 497     const bool bForceNewDeck ((mnRequestedForceFlags&SwitchFlag_ForceNewDeck)!=0);
 498     const bool bForceNewPanels ((mnRequestedForceFlags&SwitchFlag_ForceNewPanels)!=0);
 499
 500     if ( ! msCurrentDeckId.equals(rDeckDescriptor.msId)
 501         || bForceNewDeck)
 502     {
 503         // When the deck changes then destroy the deck and all panels
 504         // and create everything new.
 505         mpCurrentDeck.disposeAndClear();
 506
 507         msCurrentDeckId = rDeckDescriptor.msId;
 508     }
 509     mpTabBar->HighlightDeck(msCurrentDeckId);
 510
 511     // Determine the panels to display in the deck.
 512     ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors;
 513     ResourceManager::Instance().GetMatchingPanels(
 514         aPanelContextDescriptors,
 515         rContext,
 516         rDeckDescriptor.msId,
 517         mxFrame);
 518
 519     if (aPanelContextDescriptors.empty())
 520     {
 521         // There are no panels to be displayed in the current context.
 522         if (EnumContext::GetContextEnum(rContext.msContext) != EnumContext::Context_Empty)
 523         {
 524             // Switch to the "empty" context and try again.
 525             SwitchToDeck(
 526                 rDeckDescriptor,
 527                 Context(
 528                     rContext.msApplication,
 529                     EnumContext::GetContextName(EnumContext::Context_Empty)));
 530             return;
 531         }
 532         else
 533         {
 534             // This is already the "empty" context. Looks like we have
 535             // to live with an empty deck.
 536         }
 537     }
 538
 539     // Provide a configuration and Deck object.
 540     if ( ! mpCurrentDeck)
 541     {
 542         mpCurrentDeck.reset(
 543             VclPtr<Deck>::Create(
 544                 rDeckDescriptor,
 545                 mpParentWindow,
 546                 ::boost::bind(&SidebarController::RequestCloseDeck, this)));
 547         msCurrentDeckTitle = rDeckDescriptor.msTitle;
 548
 549     }
 550     if ( ! mpCurrentDeck)
 551         return;
 552
 553 #ifdef DEBUG
 554     // Show the context name in the deck title bar.
 555     DeckTitleBar* pDebugTitleBar = mpCurrentDeck->GetTitleBar();
 556     if (pDebugTitleBar != NULL)
 557         pDebugTitleBar->SetTitle(rDeckDescriptor.msTitle + " (" + maCurrentContext.msContext + ")");
 558 #endif
 559
 560     // Update the panel list.
 561     const sal_Int32 nNewPanelCount (aPanelContextDescriptors.size());
 562     SharedPanelContainer aNewPanels;
 563     const SharedPanelContainer& rCurrentPanels (mpCurrentDeck->GetPanels());
 564
 565     aNewPanels.resize(nNewPanelCount);
 566     sal_Int32 nWriteIndex (0);
 567     bool bHasPanelSetChanged (false);
 568     for (sal_Int32 nReadIndex=0; nReadIndex<nNewPanelCount; ++nReadIndex)
 569     {
 570         const ResourceManager::PanelContextDescriptor& rPanelContexDescriptor (
 571             aPanelContextDescriptors[nReadIndex]);
 572
 573         // Determine if the panel can be displayed.
 574         const bool bIsPanelVisible (!mbIsDocumentReadOnly || rPanelContexDescriptor.mbShowForReadOnlyDocuments);
 575         if ( ! bIsPanelVisible)
 576             continue;
 577
 578         // Find the corresponding panel among the currently active
 579         // panels.
 580         SharedPanelContainer::const_iterator iPanel = rCurrentPanels.end();
 581
 582         if (!bForceNewPanels)
 583         {
 584             iPanel = rCurrentPanels.end();
 585             for (auto a = rCurrentPanels.begin(); a != rCurrentPanels.end(); ++a)
 586             {
 587                 if ((*a)->HasIdPredicate(rPanelContexDescriptor.msId))
 588                 {
 589                     iPanel = a;
 590                     break;
 591                 }
 592             }
 593         }
 594         if (iPanel != rCurrentPanels.end())
 595         {
 596             // Panel already exists in current deck.  Reuse it.
 597             aNewPanels[nWriteIndex] = *iPanel;
 598             aNewPanels[nWriteIndex]->SetExpanded(rPanelContexDescriptor.mbIsInitiallyVisible);
 599         }
 600         else
 601         {
 602             // Panel does not yet exist or creation of new panels is forced.
 603             // Create it.
 604             aNewPanels[nWriteIndex] = CreatePanel(
 605                 rPanelContexDescriptor.msId,
 606                 mpCurrentDeck->GetPanelParentWindow(),
 607                 rPanelContexDescriptor.mbIsInitiallyVisible,
 608                 rContext);
 609             bHasPanelSetChanged = true;
 610         }
 611         if (aNewPanels[nWriteIndex] != nullptr)
 612         {
 613             // Depending on the context we have to change the command
 614             // for the "more options" dialog.
 615             PanelTitleBar* pTitleBar = aNewPanels[nWriteIndex]->GetTitleBar();
 616             if (pTitleBar != NULL)
 617             {
 618                 pTitleBar->SetMoreOptionsCommand(
 619                     rPanelContexDescriptor.msMenuCommand,
 620                     mxFrame);
 621             }
 622
 623             ++nWriteIndex;
 624         }
 625
 626     }
 627     // mpCurrentPanels - may miss stuff (?)
 628     aNewPanels.resize(nWriteIndex);
 629
 630     SfxSplitWindow* pSplitWindow = GetSplitWindow();
 631     sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();
 632     WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WINDOWALIGN_RIGHT;
 633     long nDeckX;
 634     if (eAlign == WINDOWALIGN_LEFT)     // attach the Sidebar towards the left-side of screen
 635     {
 636         nDeckX = nTabBarDefaultWidth;
 637     }
 638     else   // attach the Sidebar towards the right-side of screen
 639     {
 640         nDeckX = 0;
 641     }
 642
 643     // Activate the deck and the new set of panels.
 644     mpCurrentDeck->setPosSizePixel(
 645         nDeckX,
 646         0,
 647         mpParentWindow->GetSizePixel().Width() - nTabBarDefaultWidth,
 648         mpParentWindow->GetSizePixel().Height());
 649
 650     mpCurrentDeck->ResetPanels(aNewPanels);
 651     mpCurrentDeck->Show();
 652
 653     mpParentWindow->SetText(rDeckDescriptor.msTitle);
 654
 655     if (bHasPanelSetChanged)
 656         NotifyResize();
 657
 658     // Tell the focus manager about the new panels and tab bar
 659     // buttons.
 660     maFocusManager.SetDeckTitle(mpCurrentDeck->GetTitleBar());
 661     maFocusManager.SetPanels(aNewPanels);
 662     mpTabBar->UpdateFocusManager(maFocusManager);
 663     UpdateTitleBarIcons();
 664 }
 665
 666 VclPtr<Panel> SidebarController::CreatePanel (
 667     const OUString& rsPanelId,
 668     vcl::Window* pParentWindow,
 669     const bool bIsInitiallyExpanded,
 670     const Context& rContext)
 671 {
 672     const PanelDescriptor* pPanelDescriptor = ResourceManager::Instance().GetPanelDescriptor(rsPanelId);
 673     if (pPanelDescriptor == NULL)
 674         return NULL;
 675
 676     // Create the panel which is the parent window of the UIElement.
 677     VclPtr<Panel> pPanel = VclPtr<Panel>::Create(
 678         *pPanelDescriptor,
 679         pParentWindow,
 680         bIsInitiallyExpanded,
 681         ::boost::bind(&Deck::RequestLayout, mpCurrentDeck.get()),
 682         ::boost::bind(&SidebarController::GetCurrentContext, this));
 683
 684     // Create the XUIElement.
 685     Reference<ui::XUIElement> xUIElement (CreateUIElement(
 686             pPanel->GetComponentInterface(),
 687             pPanelDescriptor->msImplementationURL,
 688             pPanelDescriptor->mbWantsCanvas,
 689             rContext));
 690     if (xUIElement.is())
 691     {
 692         // Initialize the panel and add it to the active deck.
 693         pPanel->SetUIElement(xUIElement);
 694     }
 695     else
 696     {
 697         pPanel.disposeAndClear();
 698     }
 699
 700     return pPanel;
 701 }
 702
 703 Reference<ui::XUIElement> SidebarController::CreateUIElement (
 704     const Reference<awt::XWindowPeer>& rxWindow,
 705     const ::rtl::OUString& rsImplementationURL,
 706     const bool bWantsCanvas,
 707     const Context& rContext)
 708 {
 709     try
 710     {
 711         const Reference<XComponentContext> xComponentContext (::comphelper::getProcessComponentContext() );
 712         const Reference<ui::XUIElementFactory> xUIElementFactory =
 713                ui::theUIElementFactoryManager::get( xComponentContext );
 714
 715        // Create the XUIElement.
 716         ::comphelper::NamedValueCollection aCreationArguments;
 717         aCreationArguments.put("Frame", makeAny(mxFrame));
 718         aCreationArguments.put("ParentWindow", makeAny(rxWindow));
 719         SfxDockingWindow* pSfxDockingWindow = dynamic_cast<SfxDockingWindow*>(mpParentWindow.get());
 720         if (pSfxDockingWindow != NULL)
 721             aCreationArguments.put("SfxBindings", makeAny(sal_uInt64(&pSfxDockingWindow->GetBindings())));
 722         aCreationArguments.put("Theme", Theme::GetPropertySet());
 723         aCreationArguments.put("Sidebar", makeAny(Reference<ui::XSidebar>(static_cast<ui::XSidebar*>(this))));
 724         if (bWantsCanvas)
 725         {
 726             Reference<rendering::XSpriteCanvas> xCanvas (VCLUnoHelper::GetWindow(rxWindow)->GetSpriteCanvas());
 727             aCreationArguments.put("Canvas", makeAny(xCanvas));
 728         }
 729         aCreationArguments.put("ApplicationName", makeAny(rContext.msApplication));
 730         aCreationArguments.put("ContextName", makeAny(rContext.msContext));
 731
 732         Reference<ui::XUIElement> xUIElement(
 733             xUIElementFactory->createUIElement(
 734                 rsImplementationURL,
 735                 Sequence<beans::PropertyValue>(aCreationArguments.getPropertyValues())),
 736             UNO_QUERY_THROW);
 737
 738         return xUIElement;
 739     }
 740     catch(const Exception& rException)
 741     {
 742         SAL_WARN("sfx.sidebar", "Cannot create panel: " << rException.Message);
 743         return NULL;
 744     }
 745 }
 746
 747 IMPL_LINK(SidebarController, WindowEventHandler, VclWindowEvent*, pEvent)
 748 {
 749     if (pEvent==NULL)
 750         return sal_IntPtr(false);
 751
 752     if (pEvent->GetWindow() == mpParentWindow)
 753     {
 754         switch (pEvent->GetId())
 755         {
 756             case VCLEVENT_WINDOW_SHOW:
 757             case VCLEVENT_WINDOW_RESIZE:
 758                 NotifyResize();
 759                 break;
 760
 761             case VCLEVENT_WINDOW_DATACHANGED:
 762                 // Force an update of deck and tab bar to reflect
 763                 // changes in theme (high contrast mode).
 764                 Theme::HandleDataChange();
 765                 UpdateTitleBarIcons();
 766                 mpParentWindow->Invalidate();
 767                 mnRequestedForceFlags |= SwitchFlag_ForceNewDeck | SwitchFlag_ForceNewPanels;
 768                 maAsynchronousDeckSwitch.CancelRequest();
 769                 maContextChangeUpdate.RequestCall();
 770                 break;
 771
 772             case SFX_HINT_DYING:
 773                 dispose();
 774                 break;
 775
 776             case VCLEVENT_WINDOW_PAINT:
 777                 OSL_TRACE("Paint");
 778                 break;
 779
 780             default:
 781                 break;
 782         }
 783     }
 784     else if (pEvent->GetWindow()==mpSplitWindow && mpSplitWindow!=nullptr)
 785     {
 786         switch (pEvent->GetId())
 787         {
 788             case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
 789                 mnWidthOnSplitterButtonDown = mpParentWindow->GetSizePixel().Width();
 790                 break;
 791
 792             case VCLEVENT_WINDOW_MOUSEBUTTONUP:
 793             {
 794                 ProcessNewWidth(mpParentWindow->GetSizePixel().Width());
 795                 mnWidthOnSplitterButtonDown = 0;
 796                 break;
 797             }
 798
 799             case SFX_HINT_DYING:
 800                 dispose();
 801                 break;
 802          }
 803     }
 804
 805     return sal_IntPtr(true);
 806 }
 807
 808 void SidebarController::ShowPopupMenu (
 809     const Rectangle& rButtonBox,
 810     const ::std::vector<TabBar::DeckMenuData>& rMenuData) const
 811 {
 812     ::boost::shared_ptr<PopupMenu> pMenu = CreatePopupMenu(rMenuData);
 813     pMenu->SetSelectHdl(LINK(const_cast<SidebarController*>(this), SidebarController, OnMenuItemSelected));
 814
 815     // pass toolbox button rect so the menu can stay open on button up
 816     Rectangle aBox (rButtonBox);
 817     aBox.Move(mpTabBar->GetPosPixel().X(), 0);
 818     pMenu->Execute(mpParentWindow, aBox, PopupMenuFlags::ExecuteDown);
 819 }
 820
 821 ::boost::shared_ptr<PopupMenu> SidebarController::CreatePopupMenu (
 822     const ::std::vector<TabBar::DeckMenuData>& rMenuData) const
 823 {
 824     // Create the top level popup menu.
 825     ::boost::shared_ptr<PopupMenu> pMenu (new PopupMenu());
 826     FloatingWindow* pMenuWindow = dynamic_cast<FloatingWindow*>(pMenu->GetWindow());
 827     if (pMenuWindow != NULL)
 828     {
 829         pMenuWindow->SetPopupModeFlags(pMenuWindow->GetPopupModeFlags() | FloatWinPopupFlags::NoMouseUpClose);
 830     }
 831
 832     // Create sub menu for customization (hiding of deck tabs.)
 833     PopupMenu* pCustomizationMenu = new PopupMenu();
 834
 835     SidebarResource aLocalResource;
 836
 837     // Add one entry for every tool panel element to individually make
 838     // them visible or hide them.
 839     sal_Int32 nIndex (0);
 840     for(::std::vector<TabBar::DeckMenuData>::const_iterator
 841             iItem(rMenuData.begin()),
 842             iEnd(rMenuData.end());
 843         iItem!=iEnd;
 844         ++iItem,++nIndex)
 845     {
 846         const sal_Int32 nMenuIndex (nIndex+MID_FIRST_PANEL);
 847         pMenu->InsertItem(nMenuIndex, iItem->msDisplayName, MenuItemBits::RADIOCHECK);
 848         pMenu->CheckItem(nMenuIndex, iItem->mbIsCurrentDeck);
 849         pMenu->EnableItem(nMenuIndex, iItem->mbIsEnabled&&iItem->mbIsActive);
 850
 851         const sal_Int32 nSubMenuIndex (nIndex+MID_FIRST_HIDE);
 852         if (iItem->mbIsCurrentDeck)
 853         {
 854             // Don't allow the currently visible deck to be disabled.
 855             pCustomizationMenu->InsertItem(nSubMenuIndex, iItem->msDisplayName, MenuItemBits::RADIOCHECK);
 856             pCustomizationMenu->CheckItem(nSubMenuIndex, true);
 857         }
 858         else
 859         {
 860             pCustomizationMenu->InsertItem(nSubMenuIndex, iItem->msDisplayName, MenuItemBits::CHECKABLE);
 861             pCustomizationMenu->CheckItem(nSubMenuIndex, iItem->mbIsActive);
 862         }
 863     }
 864
 865     pMenu->InsertSeparator();
 866
 867     // Add entry for docking or un-docking the tool panel.
 868     if (mpParentWindow->IsFloatingMode())
 869         pMenu->InsertItem(MID_LOCK_TASK_PANEL, SFX2_RESSTR(STR_SFX_DOCK));
 870     else
 871         pMenu->InsertItem(MID_UNLOCK_TASK_PANEL, SFX2_RESSTR(STR_SFX_UNDOCK));
 872
 873     pMenu->InsertItem(MID_HIDE_SIDEBAR, SFX2_RESSTR(STRING_HIDE_SIDEBAR));
 874     pCustomizationMenu->InsertSeparator();
 875     pCustomizationMenu->InsertItem(MID_RESTORE_DEFAULT, SFX2_RESSTR(STRING_RESTORE));
 876
 877     pMenu->InsertItem(MID_CUSTOMIZATION, SFX2_RESSTR(STRING_CUSTOMIZATION));
 878     pMenu->SetPopupMenu(MID_CUSTOMIZATION, pCustomizationMenu);
 879
 880     pMenu->RemoveDisabledEntries(false, false);
 881
 882     return pMenu;
 883 }
 884
 885 IMPL_LINK(SidebarController, OnMenuItemSelected, Menu*, pMenu)
 886 {
 887     if (pMenu == NULL)
 888     {
 889         OSL_ENSURE(pMenu!=NULL, "sfx2::sidebar::SidebarController::OnMenuItemSelected: illegal menu!");
 890         return 0;
 891     }
 892
 893     pMenu->Deactivate();
 894     const sal_Int32 nIndex (pMenu->GetCurItemId());
 895     switch (nIndex)
 896     {
 897         case MID_UNLOCK_TASK_PANEL:
 898             mpParentWindow->SetFloatingMode(true);
 899             break;
 900
 901         case MID_LOCK_TASK_PANEL:
 902             mpParentWindow->SetFloatingMode(false);
 903             break;
 904
 905         case MID_RESTORE_DEFAULT:
 906             mpTabBar->RestoreHideFlags();
 907             break;
 908
 909         case MID_HIDE_SIDEBAR:
 910         {
 911             const util::URL aURL (Tools::GetURL(gsHideSidebarCommandName));
 912             Reference<frame::XDispatch> mxDispatch (Tools::GetDispatch(mxFrame, aURL));
 913             if (mxDispatch.is())
 914                     mxDispatch->dispatch(aURL, Sequence<beans::PropertyValue>());
 915             break;
 916         }
 917         default:
 918         {
 919             try
 920             {
 921                 if (nIndex >= MID_FIRST_PANEL && nIndex<MID_FIRST_HIDE)
 922                 {
 923                     RequestOpenDeck();
 924                     SwitchToDeck(mpTabBar->GetDeckIdForIndex(nIndex - MID_FIRST_PANEL));
 925                 }
 926                 else if (nIndex >=MID_FIRST_HIDE)
 927                     if (pMenu->GetItemBits(nIndex) == MenuItemBits::CHECKABLE)
 928                         mpTabBar->ToggleHideFlag(nIndex-MID_FIRST_HIDE);
 929             }
 930             catch (RuntimeException&)
 931             {
 932             }
 933         }
 934         break;
 935     }
 936
 937     return 1;
 938 }
 939
 940 void SidebarController::RequestCloseDeck()
 941 {
 942     mbIsDeckRequestedOpen = false;
 943     UpdateDeckOpenState();
 944
 945     // remove highlight from TabBar, because Deck will be closed
 946     mpTabBar->RemoveDeckHighlight();
 947 }
 948
 949 void SidebarController::RequestOpenDeck()
 950 {
 951     mbIsDeckRequestedOpen = true;
 952     UpdateDeckOpenState();
 953 }
 954
 955 bool SidebarController::IsDeckVisible(const OUString& rsDeckId)
 956 {
 957     return mbIsDeckOpen && mbIsDeckOpen.get() && msCurrentDeckId == rsDeckId;
 958 }
 959
 960 void SidebarController::UpdateDeckOpenState()
 961 {
 962     if ( ! mbIsDeckRequestedOpen)
 963         // No state requested.
 964         return;
 965
 966     sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();
 967
 968     // Update (change) the open state when it either has not yet been initialized
 969     // or when its value differs from the requested state.
 970     if ( ! mbIsDeckOpen
 971         || mbIsDeckOpen.get() != mbIsDeckRequestedOpen.get())
 972     {
 973         if (mbIsDeckRequestedOpen.get())
 974         {
 975             if (mnSavedSidebarWidth <= nTabBarDefaultWidth)
 976                 SetChildWindowWidth(SidebarChildWindow::GetDefaultWidth(mpParentWindow));
 977             else
 978                 SetChildWindowWidth(mnSavedSidebarWidth);
 979         }
 980         else
 981         {
 982             if ( ! mpParentWindow->IsFloatingMode())
 983                 mnSavedSidebarWidth = SetChildWindowWidth(nTabBarDefaultWidth);
 984             if (mnWidthOnSplitterButtonDown > nTabBarDefaultWidth)
 985                 mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
 986             mpParentWindow->SetStyle(mpParentWindow->GetStyle() & ~WB_SIZEABLE);
 987         }
 988
 989         mbIsDeckOpen = mbIsDeckRequestedOpen.get();
 990         if (mbIsDeckOpen.get() && mpCurrentDeck)
 991             mpCurrentDeck->Show(mbIsDeckOpen.get());
 992         NotifyResize();
 993     }
 994 }
 995
 996 bool SidebarController::CanModifyChildWindowWidth()
 997 {
 998     SfxSplitWindow* pSplitWindow = GetSplitWindow();
 999     if (pSplitWindow == NULL)
1000         return false;
1001
1002     sal_uInt16 nRow (0xffff);
1003     sal_uInt16 nColumn (0xffff);
1004     if (pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow))
1005     {
1006         sal_uInt16 nRowCount (pSplitWindow->GetWindowCount(nColumn));
1007         return nRowCount==1;
1008     }
1009     else
1010         return false;
1011 }
1012
1013 sal_Int32 SidebarController::SetChildWindowWidth (const sal_Int32 nNewWidth)
1014 {
1015     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1016     if (pSplitWindow == NULL)
1017         return 0;
1018
1019     sal_uInt16 nRow (0xffff);
1020     sal_uInt16 nColumn (0xffff);
1021     pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow);
1022     const long nColumnWidth (pSplitWindow->GetLineSize(nColumn));
1023
1024     vcl::Window* pWindow = mpParentWindow;
1025     const Size aWindowSize (pWindow->GetSizePixel());
1026
1027     pSplitWindow->MoveWindow(
1028         mpParentWindow,
1029         Size(nNewWidth, aWindowSize.Height()),
1030         nColumn,
1031         nRow);
1032     static_cast<SplitWindow*>(pSplitWindow)->Split();
1033
1034     return static_cast<sal_Int32>(nColumnWidth);
1035 }
1036
1037 void SidebarController::RestrictWidth (sal_Int32 nWidth)
1038 {
1039     SfxSplitWindow* pSplitWindow = GetSplitWindow();
1040     if (pSplitWindow != NULL)
1041     {
1042         const sal_uInt16 nId (pSplitWindow->GetItemId(mpParentWindow.get()));
1043         const sal_uInt16 nSetId (pSplitWindow->GetSet(nId));
1044         pSplitWindow->SetItemSizeRange(
1045             nSetId,
1046             Range(TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor() + nWidth,
1047                   gnMaximumSidebarWidth * mpTabBar->GetDPIScaleFactor()));
1048     }
1049 }
1050
1051 SfxSplitWindow* SidebarController::GetSplitWindow()
1052 {
1053     if (mpParentWindow != nullptr)
1054     {
1055         SfxSplitWindow* pSplitWindow = dynamic_cast<SfxSplitWindow*>(mpParentWindow->GetParent());
1056         if (pSplitWindow != mpSplitWindow)
1057         {
1058             if (mpSplitWindow != nullptr)
1059                 mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler));
1060
1061             mpSplitWindow = pSplitWindow;
1062
1063             if (mpSplitWindow != nullptr)
1064                 mpSplitWindow->AddEventListener(LINK(this, SidebarController, WindowEventHandler));
1065         }
1066         return mpSplitWindow;
1067     }
1068     else
1069         return NULL;
1070 }
1071
1072 void SidebarController::UpdateCloseIndicator (const bool bCloseAfterDrag)
1073 {
1074     if (mpParentWindow == nullptr)
1075         return;
1076
1077     if (bCloseAfterDrag)
1078     {
1079         // Make sure that the indicator exists.
1080         if ( ! mpCloseIndicator)
1081         {
1082             mpCloseIndicator.reset(VclPtr<FixedImage>::Create(mpParentWindow));
1083             FixedImage* pFixedImage = static_cast<FixedImage*>(mpCloseIndicator.get());
1084             const Image aImage (Theme::GetImage(Theme::Image_CloseIndicator));
1085             pFixedImage->SetImage(aImage);
1086             pFixedImage->SetSizePixel(aImage.GetSizePixel());
1087             pFixedImage->SetBackground(Theme::GetWallpaper(Theme::Paint_DeckBackground));
1088         }
1089
1090         // Place and show the indicator.
1091         const Size aWindowSize (mpParentWindow->GetSizePixel());
1092         const Size aImageSize (mpCloseIndicator->GetSizePixel());
1093         mpCloseIndicator->SetPosPixel(
1094             Point(
1095                 aWindowSize.Width() - TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor() - aImageSize.Width(),
1096                 (aWindowSize.Height() - aImageSize.Height())/2));
1097         mpCloseIndicator->Show();
1098     }
1099     else
1100     {
1101         // Hide but don't delete the indicator.
1102         if (mpCloseIndicator)
1103             mpCloseIndicator->Hide();
1104     }
1105 }
1106
1107 void SidebarController::UpdateTitleBarIcons()
1108 {
1109     if ( ! mpCurrentDeck)
1110         return;
1111
1112     const bool bIsHighContrastModeActive (Theme::IsHighContrastMode());
1113     const ResourceManager& rResourceManager (ResourceManager::Instance());
1114
1115     // Update the deck icon.
1116     const DeckDescriptor* pDeckDescriptor = rResourceManager.GetDeckDescriptor(mpCurrentDeck->GetId());
1117     if (pDeckDescriptor != NULL && mpCurrentDeck->GetTitleBar())
1118     {
1119         const OUString sIconURL(
1120             bIsHighContrastModeActive
1121                 ? pDeckDescriptor->msHighContrastTitleBarIconURL
1122                 : pDeckDescriptor->msTitleBarIconURL);
1123         mpCurrentDeck->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
1124     }
1125
1126     // Update the panel icons.
1127     const SharedPanelContainer& rPanels (mpCurrentDeck->GetPanels());
1128     for (SharedPanelContainer::const_iterator
1129              iPanel(rPanels.begin()), iEnd(rPanels.end());
1130              iPanel!=iEnd;
1131              ++iPanel)
1132     {
1133         if ( ! *iPanel)
1134             continue;
1135         if ((*iPanel)->GetTitleBar() == NULL)
1136             continue;
1137         const PanelDescriptor* pPanelDescriptor = rResourceManager.GetPanelDescriptor((*iPanel)->GetId());
1138         if (pPanelDescriptor == NULL)
1139             continue;
1140         const OUString sIconURL (
1141             bIsHighContrastModeActive
1142                ? pPanelDescriptor->msHighContrastTitleBarIconURL
1143                : pPanelDescriptor->msTitleBarIconURL);
1144         (*iPanel)->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
1145     }
1146 }
1147
1148 void SidebarController::ShowPanel (const Panel& rPanel)
1149 {
1150     if (mpCurrentDeck)
1151         mpCurrentDeck->ShowPanel(rPanel);
1152 }
1153
1154 } } // end of namespace sfx2::sidebar
1155
1156 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */