sfx2/source/sidebar/SidebarController.cxx

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