sfx2/source/sidebar/DeckLayouter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sidebar/DeckLayouter.hxx>
  21 #include <sidebar/DeckTitleBar.hxx>
  22 #include <sidebar/PanelTitleBar.hxx>
  23 #include <sfx2/sidebar/Deck.hxx>
  24 #include <sfx2/sidebar/Panel.hxx>
  25 #include <sfx2/sidebar/Theme.hxx>
  26 #include <sfx2/sidebar/SidebarDockingWindow.hxx>
  27 #include <sfx2/sidebar/SidebarController.hxx>
  28 #include <sfx2/viewsh.hxx>
  29 #include <comphelper/lok.hxx>
  30
  31 #include <comphelper/processfactory.hxx>
  32
  33 #include <com/sun/star/uno/Reference.hxx>
  34 #include <com/sun/star/frame/Desktop.hpp>
  35 #include <com/sun/star/frame/XDesktop2.hpp>
  36 #include <com/sun/star/frame/XFrame.hpp>
  37 #include <com/sun/star/ui/XSidebarPanel.hpp>
  38
  39 #include <vcl/jsdialog/executor.hxx>
  40
  41 using namespace css;
  42 using namespace css::uno;
  43
  44 namespace sfx2::sidebar {
  45
  46 namespace {
  47     const sal_Int32 MinimalPanelHeight (25);
  48
  49     enum LayoutMode
  50     {
  51         MinimumOrLarger,
  52         PreferredOrLarger,
  53         Preferred
  54     };
  55     class LayoutItem
  56     {
  57     public:
  58         std::shared_ptr<Panel> mpPanel;
  59         css::ui::LayoutSize maLayoutSize;
  60         sal_Int32 mnDistributedHeight;
  61         sal_Int32 mnWeight;
  62         bool mbShowTitleBar;
  63
  64         LayoutItem(const std::shared_ptr<Panel>& pPanel)
  65             : mpPanel(pPanel)
  66             , maLayoutSize(0, 0, 0)
  67             , mnDistributedHeight(0)
  68             , mnWeight(0)
  69             , mbShowTitleBar(true)
  70         {
  71         }
  72     };
  73     void LayoutPanels (
  74         const tools::Rectangle& rContentArea,
  75         sal_Int32& rMinimalWidth,
  76         sal_Int32& rMinimalHeight,
  77         ::std::vector<LayoutItem>& rLayoutItems,
  78         weld::ScrolledWindow& pVerticalScrollBar,
  79         const bool bShowVerticalScrollBar);
  80     void GetRequestedSizes (
  81         ::std::vector<LayoutItem>& rLayoutItem,
  82         sal_Int32& rAvailableHeight,
  83         sal_Int32& rMinimalWidth,
  84         const tools::Rectangle& rContentBox);
  85     void DistributeHeights (
  86         ::std::vector<LayoutItem>& rLayoutItems,
  87         const sal_Int32 nHeightToDistribute,
  88         const sal_Int32 nContainerHeight,
  89         const bool bMinimumHeightIsBase);
  90     sal_Int32 PlacePanels (
  91         ::std::vector<LayoutItem>& rLayoutItems,
  92         const LayoutMode eMode_);
  93     tools::Rectangle PlaceDeckTitle (
  94         const SidebarDockingWindow* pDockingWindow,
  95         DeckTitleBar& rTitleBar,
  96         const tools::Rectangle& rAvailableSpace);
  97     tools::Rectangle PlaceVerticalScrollBar (
  98         weld::ScrolledWindow& rVerticalScrollBar,
  99         const tools::Rectangle& rAvailableSpace,
 100         const bool bShowVerticalScrollBar);
 101     void SetupVerticalScrollBar(
 102         weld::ScrolledWindow& rVerticalScrollBar,
 103         const sal_Int32 nContentHeight,
 104         const sal_Int32 nVisibleHeight);
 105 }
 106
 107 void DeckLayouter::LayoutDeck (
 108     const SidebarDockingWindow* pDockingWindow,
 109     const tools::Rectangle& rContentArea,
 110     sal_Int32& rMinimalWidth,
 111     sal_Int32& rMinimalHeight,
 112     SharedPanelContainer& rPanels,
 113     DeckTitleBar& rDeckTitleBar,
 114     weld::ScrolledWindow& rVerticalScrollBar)
 115 {
 116     if (rContentArea.GetWidth()<=0 || rContentArea.GetHeight()<=0)
 117         return;
 118     tools::Rectangle aBox(PlaceDeckTitle(pDockingWindow, rDeckTitleBar, rContentArea));
 119
 120     if (  rPanels.empty())
 121         return;
 122
 123     // Prepare the layout item container.
 124     ::std::vector<LayoutItem> aLayoutItems;
 125     aLayoutItems.reserve(rPanels.size());
 126     for (auto& rPanel : rPanels)
 127         aLayoutItems.emplace_back(rPanel);
 128
 129     LayoutPanels(
 130         aBox,
 131         rMinimalWidth,
 132         rMinimalHeight,
 133         aLayoutItems,
 134         rVerticalScrollBar,
 135         false);
 136 }
 137
 138 namespace {
 139
 140 void LayoutPanels (
 141     const tools::Rectangle& rContentArea,
 142     sal_Int32& rMinimalWidth,
 143     sal_Int32& rMinimalHeight,
 144     ::std::vector<LayoutItem>& rLayoutItems,
 145     weld::ScrolledWindow& rVerticalScrollBar,
 146     const bool bShowVerticalScrollBar)
 147 {
 148     tools::Rectangle aBox (PlaceVerticalScrollBar(rVerticalScrollBar, rContentArea, bShowVerticalScrollBar));
 149
 150     // Get the requested heights of the panels and the available
 151     // height that is left when all panel titles and separators are
 152     // taken into account.
 153     sal_Int32 nAvailableHeight (aBox.GetHeight());
 154     GetRequestedSizes(rLayoutItems, nAvailableHeight, rMinimalWidth, aBox);
 155     const sal_Int32 nTotalDecorationHeight (aBox.GetHeight() - nAvailableHeight);
 156
 157     // Analyze the requested heights.
 158     // Determine the height that is available for panel content
 159     // and count the different layouts.
 160     sal_Int32 nTotalPreferredHeight (0);
 161     sal_Int32 nTotalMinimumHeight (0);
 162
 163     for (const auto& rItem : rLayoutItems)
 164     {
 165         nTotalMinimumHeight += rItem.maLayoutSize.Minimum;
 166         nTotalPreferredHeight += rItem.maLayoutSize.Preferred;
 167     }
 168
 169     if (nTotalMinimumHeight > nAvailableHeight && !bShowVerticalScrollBar
 170         && !comphelper::LibreOfficeKit::isActive())
 171     {
 172         // Not enough space, even when all panels are shrunk to their
 173         // minimum height.
 174         // Show a vertical scrollbar.
 175         LayoutPanels(
 176             rContentArea,
 177             rMinimalWidth,
 178             rMinimalHeight,
 179             rLayoutItems,
 180             rVerticalScrollBar,
 181             true);
 182         return;
 183     }
 184
 185     // We are now in one of three modes.
 186     // - The preferred height fits into the available size:
 187     //   Use the preferred size, distribute the remaining height by
 188     //   enlarging panels.
 189     // - The total minimum height fits into the available size:
 190     //   Use the minimum size, distribute the remaining height by
 191     //   enlarging panels.
 192     // - The total minimum height does not fit into the available
 193     //   size:
 194     //   Use the unmodified preferred height for all panels.
 195
 196     LayoutMode eMode(MinimumOrLarger);
 197     if (bShowVerticalScrollBar)
 198     {
 199         eMode = Preferred;
 200
 201         const sal_Int32 nContentHeight(nTotalPreferredHeight + nTotalDecorationHeight);
 202         SetupVerticalScrollBar(rVerticalScrollBar, nContentHeight, aBox.GetHeight());
 203     }
 204     else
 205     {
 206         if (nTotalPreferredHeight <= nAvailableHeight)
 207             eMode = PreferredOrLarger;
 208         else
 209             eMode = MinimumOrLarger;
 210
 211         const sal_Int32 nTotalHeight (eMode==MinimumOrLarger ? nTotalMinimumHeight : nTotalPreferredHeight);
 212
 213         DistributeHeights(
 214             rLayoutItems,
 215             nAvailableHeight-nTotalHeight,
 216             aBox.GetHeight(),
 217             eMode==MinimumOrLarger);
 218     }
 219
 220     const sal_Int32 nUsedHeight(PlacePanels(rLayoutItems, eMode));
 221     rMinimalHeight = nUsedHeight;
 222 }
 223
 224 sal_Int32 PlacePanels (
 225     ::std::vector<LayoutItem>& rLayoutItems,
 226     const LayoutMode eMode)
 227 {
 228     const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight));
 229     sal_Int32 nY (0);
 230
 231     // Assign heights and places.
 232     for(::std::vector<LayoutItem>::const_iterator iItem(rLayoutItems.begin()),
 233          iEnd(rLayoutItems.end());
 234         iItem!=iEnd;
 235         ++iItem)
 236     {
 237         if (!iItem->mpPanel)
 238             continue;
 239
 240         Panel& rPanel (*iItem->mpPanel);
 241
 242         rPanel.set_margin_top(nDeckSeparatorHeight);
 243         rPanel.set_margin_bottom(0);
 244
 245         // Separator above the panel title bar.
 246         if (!rPanel.IsLurking())
 247         {
 248             nY += nDeckSeparatorHeight;
 249         }
 250
 251         bool bShowTitlebar = iItem->mbShowTitleBar;
 252         PanelTitleBar* pTitleBar = rPanel.GetTitleBar();
 253         pTitleBar->Show(bShowTitlebar);
 254         rPanel.set_vexpand(!bShowTitlebar);
 255         weld::Container* pContents = rPanel.GetContents();
 256         pContents->set_vexpand(true);
 257
 258         bool bExpanded = rPanel.IsExpanded() && !rPanel.IsLurking();
 259         if (bShowTitlebar || bExpanded)
 260         {
 261             rPanel.Show(true);
 262
 263             sal_Int32 nPanelHeight(0);
 264             if (bExpanded)
 265             {
 266                 // Determine the height of the panel depending on layout
 267                 // mode and distributed heights.
 268                 switch(eMode)
 269                 {
 270                     case MinimumOrLarger:
 271                         nPanelHeight = iItem->maLayoutSize.Minimum + iItem->mnDistributedHeight;
 272                         break;
 273                     case PreferredOrLarger:
 274                         nPanelHeight = iItem->maLayoutSize.Preferred + iItem->mnDistributedHeight;
 275                         break;
 276                     case Preferred:
 277                         nPanelHeight = iItem->maLayoutSize.Preferred;
 278                         break;
 279                     default:
 280                         OSL_ASSERT(false);
 281                         break;
 282                 }
 283             }
 284             if (bShowTitlebar)
 285                 nPanelHeight += pTitleBar->get_preferred_size().Height();
 286
 287             rPanel.SetHeightPixel(nPanelHeight);
 288
 289             nY += nPanelHeight;
 290         }
 291         else
 292         {
 293             rPanel.Show(false);
 294         }
 295
 296         if (!bExpanded)
 297         {
 298             // Add a separator below the collapsed panel, if it is the
 299             // last panel in the deck.
 300             if (iItem == rLayoutItems.end()-1)
 301             {
 302                 // Separator below the panel title bar.
 303                 rPanel.set_margin_bottom(nDeckSeparatorHeight);
 304                 nY += nDeckSeparatorHeight;
 305             }
 306         }
 307     }
 308
 309     if (comphelper::LibreOfficeKit::isActive())
 310     {
 311         sal_uInt64 nShellId = reinterpret_cast<sal_uInt64>(SfxViewShell::Current());
 312         jsdialog::SendFullUpdate(std::to_string(nShellId) + "sidebar", "Panel");
 313     }
 314
 315     return nY;
 316 }
 317
 318 void GetRequestedSizes (
 319     ::std::vector<LayoutItem>& rLayoutItems,
 320     sal_Int32& rAvailableHeight,
 321     sal_Int32& rMinimalWidth,
 322     const tools::Rectangle& rContentBox)
 323 {
 324     rAvailableHeight = rContentBox.GetHeight();
 325
 326     const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight));
 327
 328     for (auto& rItem : rLayoutItems)
 329     {
 330         rItem.maLayoutSize = ui::LayoutSize(0,0,0);
 331
 332         if (rItem.mpPanel == nullptr)
 333             continue;
 334
 335         if (rItem.mpPanel->IsLurking())
 336         {
 337             rItem.mbShowTitleBar = false;
 338             continue;
 339         }
 340
 341         if (rLayoutItems.size() == 1
 342             && rItem.mpPanel->IsTitleBarOptional())
 343         {
 344             // There is only one panel and its title bar is
 345             // optional => hide it.
 346             rAvailableHeight -= nDeckSeparatorHeight;
 347             rItem.mbShowTitleBar = false;
 348         }
 349         else
 350         {
 351             // Show the title bar and a separator above and below
 352             // the title bar.
 353             PanelTitleBar* pTitleBar = rItem.mpPanel->GetTitleBar();
 354             const sal_Int32 nPanelTitleBarHeight = pTitleBar->get_preferred_size().Height();
 355
 356             rAvailableHeight -= nPanelTitleBarHeight;
 357             rAvailableHeight -= nDeckSeparatorHeight;
 358         }
 359
 360         if (rItem.mpPanel->IsExpanded() && rItem.mpPanel->GetPanelComponent().is())
 361         {
 362             Reference<ui::XSidebarPanel> xPanel (rItem.mpPanel->GetPanelComponent());
 363
 364             rItem.maLayoutSize = xPanel->getHeightForWidth(rContentBox.GetWidth());
 365             if (!(0 <= rItem.maLayoutSize.Minimum && rItem.maLayoutSize.Minimum <= rItem.maLayoutSize.Preferred
 366                   && rItem.maLayoutSize.Preferred <= rItem.maLayoutSize.Maximum))
 367             {
 368                 SAL_INFO("sfx.sidebar", "Please follow LayoutSize constraints: 0 ≤ "
 369                          "Minimum ≤ Preferred ≤ Maximum."
 370                          " Currently: Minimum: "
 371                          << rItem.maLayoutSize.Minimum
 372                          << " Preferred: " << rItem.maLayoutSize.Preferred
 373                          << " Maximum: " << rItem.maLayoutSize.Maximum);
 374             }
 375
 376             sal_Int32 nWidth = rMinimalWidth;
 377             try
 378             {
 379                 // The demo sidebar extension "Analog Clock" fails with
 380                 // java.lang.AbstractMethodError here
 381                 nWidth = xPanel->getMinimalWidth();
 382             }
 383             catch (...)
 384             {
 385             }
 386
 387             uno::Reference<frame::XDesktop2> xDesktop
 388                 = frame::Desktop::create(comphelper::getProcessComponentContext());
 389             uno::Reference<frame::XFrame> xFrame = xDesktop->getActiveFrame();
 390             if (xFrame.is())
 391             {
 392                 SidebarController* pController
 393                     = SidebarController::GetSidebarControllerForFrame(xFrame);
 394                 if (pController && pController->getMaximumWidth() < nWidth)
 395                 {
 396                     // Add 100 extra pixels to still have the sidebar resizable
 397                     // (See also documentation of XSidebarPanel::getMinimalWidth)
 398                     pController->setMaximumWidth(nWidth + 100);
 399                 }
 400             }
 401
 402             if (nWidth > rMinimalWidth)
 403                 rMinimalWidth = nWidth;
 404         }
 405         else
 406             rItem.maLayoutSize = ui::LayoutSize(MinimalPanelHeight, -1, 0);
 407     }
 408 }
 409
 410 void DistributeHeights (
 411     ::std::vector<LayoutItem>& rLayoutItems,
 412     const sal_Int32 nHeightToDistribute,
 413     const sal_Int32 nContainerHeight,
 414     const bool bMinimumHeightIsBase)
 415 {
 416     if (nHeightToDistribute <= 0)
 417         return;
 418
 419     sal_Int32 nRemainingHeightToDistribute (nHeightToDistribute);
 420
 421     // Compute the weights as difference between panel base height
 422     // (either its minimum or preferred height) and the container height.
 423     sal_Int32 nTotalWeight (0);
 424     sal_Int32 nNoMaximumCount (0);
 425
 426     for (auto& rItem : rLayoutItems)
 427     {
 428         if (rItem.maLayoutSize.Maximum == 0)
 429             continue;
 430         if (rItem.maLayoutSize.Maximum < 0)
 431             ++nNoMaximumCount;
 432
 433         const sal_Int32 nBaseHeight (
 434             bMinimumHeightIsBase
 435                 ? rItem.maLayoutSize.Minimum
 436                 : rItem.maLayoutSize.Preferred);
 437         if (nBaseHeight < nContainerHeight)
 438         {
 439             rItem.mnWeight = nContainerHeight - nBaseHeight;
 440             nTotalWeight += rItem.mnWeight;
 441         }
 442     }
 443
 444     if (nTotalWeight == 0)
 445         return;
 446
 447     // First pass of height distribution.
 448     for (auto& rItem : rLayoutItems)
 449     {
 450         const sal_Int32 nBaseHeight (
 451             bMinimumHeightIsBase
 452                 ? rItem.maLayoutSize.Minimum
 453                 : rItem.maLayoutSize.Preferred);
 454         sal_Int32 nDistributedHeight (rItem.mnWeight * nHeightToDistribute / nTotalWeight);
 455         if (nBaseHeight+nDistributedHeight > rItem.maLayoutSize.Maximum
 456             && rItem.maLayoutSize.Maximum >= 0)
 457         {
 458             nDistributedHeight = ::std::max<sal_Int32>(0, rItem.maLayoutSize.Maximum - nBaseHeight);
 459         }
 460         rItem.mnDistributedHeight = nDistributedHeight;
 461         nRemainingHeightToDistribute -= nDistributedHeight;
 462     }
 463
 464     if (nRemainingHeightToDistribute == 0)
 465         return;
 466     OSL_ASSERT(nRemainingHeightToDistribute > 0);
 467
 468     // It is possible that not all of the height could be distributed
 469     // because of Maximum heights being smaller than expected.
 470     // Distribute the remaining height between the panels that have no
 471     // Maximum (ie Maximum==-1).
 472     if (nNoMaximumCount == 0)
 473     {
 474         // There are no panels with unrestricted height.
 475         return;
 476     }
 477
 478     const sal_Int32 nAdditionalHeightPerPanel(nRemainingHeightToDistribute / nNoMaximumCount);
 479     // Handle rounding error.
 480     sal_Int32 nAdditionalHeightForFirstPanel (nRemainingHeightToDistribute
 481         - nNoMaximumCount*nAdditionalHeightPerPanel);
 482
 483     for (auto& rItem : rLayoutItems)
 484     {
 485         if (rItem.maLayoutSize.Maximum < 0)
 486         {
 487             rItem.mnDistributedHeight += nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel;
 488             nRemainingHeightToDistribute -= nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel;
 489         }
 490     }
 491
 492     OSL_ASSERT(nRemainingHeightToDistribute==0);
 493 }
 494
 495 tools::Rectangle PlaceDeckTitle(
 496     const SidebarDockingWindow* pDockingWindow,
 497     DeckTitleBar& rDeckTitleBar,
 498     const tools::Rectangle& rAvailableSpace)
 499 {
 500     if (pDockingWindow->IsFloatingMode())
 501     {
 502         // When the side bar is undocked then the outer system window displays the deck title.
 503         rDeckTitleBar.Show(false);
 504         return rAvailableSpace;
 505     }
 506     else
 507     {
 508         rDeckTitleBar.Show(true);
 509         const sal_Int32 nDeckTitleBarHeight(rDeckTitleBar.get_preferred_size().Height());
 510         return tools::Rectangle(
 511             rAvailableSpace.Left(),
 512             rAvailableSpace.Top() + nDeckTitleBarHeight,
 513             rAvailableSpace.Right(),
 514             rAvailableSpace.Bottom());
 515     }
 516 }
 517
 518 tools::Rectangle PlaceVerticalScrollBar (
 519     weld::ScrolledWindow& rVerticalScrollBar,
 520     const tools::Rectangle& rAvailableSpace,
 521     const bool bShowVerticalScrollBar)
 522 {
 523     if (bShowVerticalScrollBar)
 524     {
 525         const sal_Int32 nScrollBarWidth(rVerticalScrollBar.get_scroll_thickness());
 526         rVerticalScrollBar.set_vpolicy(VclPolicyType::ALWAYS);
 527         return tools::Rectangle(
 528             rAvailableSpace.Left(),
 529             rAvailableSpace.Top(),
 530             rAvailableSpace.Right() - nScrollBarWidth,
 531             rAvailableSpace.Bottom());
 532     }
 533     else
 534     {
 535         rVerticalScrollBar.set_vpolicy(VclPolicyType::NEVER);
 536         return rAvailableSpace;
 537     }
 538 }
 539
 540 void SetupVerticalScrollBar(
 541     weld::ScrolledWindow& rVerticalScrollBar,
 542     const sal_Int32 nContentHeight,
 543     const sal_Int32 nVisibleHeight)
 544 {
 545     OSL_ASSERT(nContentHeight > nVisibleHeight);
 546
 547     rVerticalScrollBar.vadjustment_set_upper(nContentHeight-1);
 548     rVerticalScrollBar.vadjustment_set_page_size(nVisibleHeight);
 549 }
 550
 551 }
 552
 553 } // end of namespace sfx2::sidebar
 554
 555 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */