LCOV - code coverage report
Current view: top level - sfx2/source/sidebar - DeckLayouter.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 162 181 89.5 %
Date: 2014-11-03 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "DeckLayouter.hxx"
      21             : #include <sfx2/sidebar/Theme.hxx>
      22             : #include "Panel.hxx"
      23             : #include "PanelTitleBar.hxx"
      24             : #include "Deck.hxx"
      25             : 
      26             : #include <vcl/window.hxx>
      27             : #include <vcl/scrbar.hxx>
      28             : 
      29             : using namespace css;
      30             : using namespace css::uno;
      31             : 
      32             : 
      33             : namespace sfx2 { namespace sidebar {
      34             : 
      35             : 
      36             : namespace {
      37             :     static const sal_Int32 MinimalPanelHeight (25);
      38             : }
      39             : 
      40             : #define IterateLayoutItems(iterator_name,container)                     \
      41             :     for(::std::vector<LayoutItem>::iterator                             \
      42             :                    iterator_name(container.begin()),                    \
      43             :                    iEnd(container.end());                               \
      44             :         iterator_name!=iEnd;                                            \
      45             :         ++iterator_name)
      46             : 
      47             : 
      48             : 
      49       25788 : void DeckLayouter::LayoutDeck (
      50             :     const Rectangle aContentArea,
      51             :     sal_Int32& rMinimalWidth,
      52             :     SharedPanelContainer& rPanels,
      53             :     vcl::Window& rDeckTitleBar,
      54             :     vcl::Window& rScrollClipWindow,
      55             :     vcl::Window& rScrollContainer,
      56             :     vcl::Window& rFiller,
      57             :     ScrollBar& rVerticalScrollBar)
      58             : {
      59       25788 :     if (aContentArea.GetWidth()<=0 || aContentArea.GetHeight()<=0)
      60       30488 :         return;
      61       21088 :     Rectangle aBox (PlaceDeckTitle(rDeckTitleBar, aContentArea));
      62             : 
      63       21088 :     if ( ! rPanels.empty())
      64             :     {
      65             :         // Prepare the layout item container.
      66       17024 :         ::std::vector<LayoutItem> aLayoutItems;
      67       17024 :         aLayoutItems.resize(rPanels.size());
      68       38306 :         for (sal_Int32 nIndex(0),nCount(rPanels.size()); nIndex<nCount; ++nIndex)
      69             :         {
      70       21282 :             aLayoutItems[nIndex].mpPanel = rPanels[nIndex];
      71       21282 :             aLayoutItems[nIndex].mnPanelIndex = nIndex;
      72             :         }
      73             :         aBox = LayoutPanels(
      74             :             aBox,
      75             :             rMinimalWidth,
      76             :             aLayoutItems,
      77             :             rScrollClipWindow,
      78             :             rScrollContainer,
      79             :             rVerticalScrollBar,
      80       17024 :             false);
      81             :     }
      82       21088 :     UpdateFiller(rFiller, aBox);
      83             : }
      84             : 
      85             : 
      86             : 
      87             : 
      88       17098 : Rectangle DeckLayouter::LayoutPanels (
      89             :     const Rectangle aContentArea,
      90             :     sal_Int32& rMinimalWidth,
      91             :     ::std::vector<LayoutItem>& rLayoutItems,
      92             :     vcl::Window& rScrollClipWindow,
      93             :     vcl::Window& rScrollContainer,
      94             :     ScrollBar& rVerticalScrollBar,
      95             :     const bool bShowVerticalScrollBar)
      96             : {
      97       17098 :     Rectangle aBox (PlaceVerticalScrollBar(rVerticalScrollBar, aContentArea, bShowVerticalScrollBar));
      98             : 
      99       17098 :     const sal_Int32 nWidth (aBox.GetWidth());
     100             : 
     101             :     // Get the requested heights of the panels and the available
     102             :     // height that is left when all panel titles and separators are
     103             :     // taken into account.
     104       17098 :     sal_Int32 nAvailableHeight (aBox.GetHeight());
     105       17098 :     GetRequestedSizes(rLayoutItems, nAvailableHeight, rMinimalWidth, aBox);
     106       17098 :     const sal_Int32 nTotalDecorationHeight (aBox.GetHeight() - nAvailableHeight);
     107             : 
     108             :     // Analyze the requested heights.
     109             :     // Determine the height that is available for panel content
     110             :     // and count the different layouts.
     111       17098 :     sal_Int32 nTotalPreferredHeight (0);
     112       17098 :     sal_Int32 nTotalMinimumHeight (0);
     113       38454 :     IterateLayoutItems(iItem,rLayoutItems)
     114             :     {
     115       21356 :         nTotalMinimumHeight += iItem->maLayoutSize.Minimum;
     116       21356 :         nTotalPreferredHeight += iItem->maLayoutSize.Preferred;
     117             :     }
     118             : 
     119       17098 :     if (nTotalMinimumHeight > nAvailableHeight
     120         148 :         && ! bShowVerticalScrollBar)
     121             :     {
     122             :         // Not enough space, even when all panels are shrunk to their
     123             :         // minimum height.
     124             :         // Show a vertical scrollbar.
     125             :         return LayoutPanels(
     126             :             aContentArea,
     127             :             rMinimalWidth,
     128             :             rLayoutItems,
     129             :             rScrollClipWindow,
     130             :             rScrollContainer,
     131             :             rVerticalScrollBar,
     132          74 :             true);
     133             :     }
     134             : 
     135             :     // We are now in one of three modes.
     136             :     // - The preferred height fits into the available size:
     137             :     //   Use the preferred size, distribute the remaining height bei
     138             :     //   enlarging panels.
     139             :     // - The total minimum height fits into the available size:
     140             :     //   Use the minimum size, distribute the remaining height bei
     141             :     //   enlarging panels.
     142             :     // - The total minimum height does not fit into the available
     143             :     //   size:
     144             :     //   Use the unmodified preferred height for all panels.
     145             : 
     146       17024 :     LayoutMode eMode (MinimumOrLarger);
     147       17024 :     if (bShowVerticalScrollBar)
     148          74 :         eMode = Preferred;
     149       16950 :     else if (nTotalPreferredHeight <= nAvailableHeight)
     150       16950 :         eMode = PreferredOrLarger;
     151             :     else
     152           0 :         eMode = MinimumOrLarger;
     153             : 
     154       17024 :     if (eMode != Preferred)
     155             :     {
     156       16950 :         const sal_Int32 nTotalHeight (eMode==MinimumOrLarger ? nTotalMinimumHeight : nTotalPreferredHeight);
     157             : 
     158             :         DistributeHeights(
     159             :             rLayoutItems,
     160             :             nAvailableHeight-nTotalHeight,
     161       16950 :             aBox.GetHeight(),
     162       33900 :             eMode==MinimumOrLarger);
     163             :     }
     164             : 
     165             :     // Set position and size of the mpScrollClipWindow to the available
     166             :     // size.  Its child, the mpScrollContainer, may have a bigger
     167             :     // height.
     168       17024 :     rScrollClipWindow.setPosSizePixel(aBox.Left(), aBox.Top(), aBox.GetWidth(), aBox.GetHeight());
     169             : 
     170             :     const sal_Int32 nContentHeight (
     171             :         eMode==Preferred
     172             :             ? nTotalPreferredHeight + nTotalDecorationHeight
     173       17024 :             : aBox.GetHeight());
     174       17024 :     sal_Int32 nY = rVerticalScrollBar.GetThumbPos();
     175       17024 :     if (nContentHeight-nY < aBox.GetHeight())
     176           0 :         nY = nContentHeight-aBox.GetHeight();
     177       17024 :     if (nY < 0)
     178           0 :         nY = 0;
     179             :     rScrollContainer.setPosSizePixel(
     180             :         0,
     181             :         -nY,
     182             :         nWidth,
     183       17024 :         nContentHeight);
     184             : 
     185       17024 :     if (bShowVerticalScrollBar)
     186          74 :         SetupVerticalScrollBar(rVerticalScrollBar, nContentHeight, aBox.GetHeight());
     187             : 
     188       17024 :     const sal_Int32 nUsedHeight (PlacePanels(rLayoutItems, nWidth, eMode, rScrollContainer));
     189       17024 :     aBox.Top() += nUsedHeight;
     190       17024 :     return aBox;
     191             : }
     192             : 
     193             : 
     194             : 
     195             : 
     196       17024 : sal_Int32 DeckLayouter::PlacePanels (
     197             :     ::std::vector<LayoutItem>& rLayoutItems,
     198             :     const sal_Int32 nWidth,
     199             :     const LayoutMode eMode,
     200             :     vcl::Window& rScrollContainer)
     201             : {
     202       17024 :     ::std::vector<sal_Int32> aSeparators;
     203       17024 :     const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight));
     204       17024 :     sal_Int32 nY (0);
     205             : 
     206             :     // Assign heights and places.
     207       38306 :     IterateLayoutItems(iItem,rLayoutItems)
     208             :     {
     209       21282 :         if (iItem->mpPanel == 0)
     210           0 :             continue;
     211             : 
     212       21282 :         Panel& rPanel (*iItem->mpPanel);
     213             : 
     214             :         // Separator above the panel title bar.
     215       21282 :         aSeparators.push_back(nY);
     216       21282 :         nY += nDeckSeparatorHeight;
     217             : 
     218             :         // Place the title bar.
     219       21282 :         PanelTitleBar* pTitleBar = rPanel.GetTitleBar();
     220       21282 :         if (pTitleBar != NULL)
     221             :         {
     222       21282 :             const sal_Int32 nPanelTitleBarHeight (Theme::GetInteger(Theme::Int_PanelTitleBarHeight) * rPanel.GetDPIScaleFactor());
     223             : 
     224       21282 :             if (iItem->mbShowTitleBar)
     225             :             {
     226        6469 :                 pTitleBar->setPosSizePixel(0, nY, nWidth, nPanelTitleBarHeight);
     227        6469 :                 pTitleBar->Show();
     228        6469 :                 nY += nPanelTitleBarHeight;
     229             :             }
     230             :             else
     231             :             {
     232       14813 :                 pTitleBar->Hide();
     233             :             }
     234             :         }
     235             : 
     236       21282 :         if (rPanel.IsExpanded())
     237             :         {
     238       19145 :             rPanel.Show();
     239             : 
     240             :             // Determine the height of the panel depending on layout
     241             :             // mode and distributed heights.
     242       19145 :             sal_Int32 nPanelHeight (0);
     243       19145 :             switch(eMode)
     244             :             {
     245             :                 case MinimumOrLarger:
     246           0 :                     nPanelHeight = iItem->maLayoutSize.Minimum + iItem->mnDistributedHeight;
     247           0 :                     break;
     248             :                 case PreferredOrLarger:
     249       19071 :                     nPanelHeight = iItem->maLayoutSize.Preferred + iItem->mnDistributedHeight;
     250       19071 :                     break;
     251             :                 case Preferred:
     252          74 :                     nPanelHeight = iItem->maLayoutSize.Preferred;
     253          74 :                     break;
     254             :                 default:
     255             :                     OSL_ASSERT(false);
     256           0 :                     break;
     257             :             }
     258             : 
     259             :             // Place the panel.
     260       19145 :             rPanel.setPosSizePixel(0, nY, nWidth, nPanelHeight);
     261       19145 :             rPanel.Invalidate();
     262             : 
     263       19145 :             nY += nPanelHeight;
     264             :         }
     265             :         else
     266             :         {
     267        2137 :             rPanel.Hide();
     268             : 
     269             :             // Add a separator below the collapsed panel, if it is the
     270             :             // last panel in the deck.
     271        2137 :             if (iItem == rLayoutItems.end()-1)
     272             :             {
     273             :                 // Separator below the panel title bar.
     274        2137 :                 aSeparators.push_back(nY);
     275        2137 :                 nY += nDeckSeparatorHeight;
     276             :             }
     277             :         }
     278             :     }
     279             : 
     280             :     Deck::ScrollContainerWindow* pScrollContainerWindow
     281       17024 :         = dynamic_cast<Deck::ScrollContainerWindow*>(&rScrollContainer);
     282       17024 :     if (pScrollContainerWindow != NULL)
     283       17024 :         pScrollContainerWindow->SetSeparators(aSeparators);
     284             : 
     285       17024 :     return nY;
     286             : }
     287             : 
     288             : 
     289             : 
     290             : 
     291       17098 : void DeckLayouter::GetRequestedSizes (
     292             :     ::std::vector<LayoutItem>& rLayoutItems,
     293             :     sal_Int32& rAvailableHeight,
     294             :     sal_Int32& rMinimalWidth,
     295             :     const Rectangle& rContentBox)
     296             : {
     297       17098 :     rAvailableHeight = rContentBox.GetHeight();
     298             : 
     299       17098 :     const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight));
     300             : 
     301       38454 :     IterateLayoutItems(iItem,rLayoutItems)
     302             :     {
     303       21356 :         ui::LayoutSize aLayoutSize (ui::LayoutSize(0,0,0));
     304       21356 :         if (iItem->mpPanel != 0)
     305             :         {
     306       42712 :             if (rLayoutItems.size() == 1
     307       21356 :                 && iItem->mpPanel->IsTitleBarOptional())
     308             :             {
     309             :                 // There is only one panel and its title bar is
     310             :                 // optional => hide it.
     311       14813 :                 rAvailableHeight -= nDeckSeparatorHeight;
     312       14813 :                 iItem->mbShowTitleBar = false;
     313             :             }
     314             :             else
     315             :             {
     316             :                 // Show the title bar and a separator above and below
     317             :                 // the title bar.
     318        6543 :                 const sal_Int32 nPanelTitleBarHeight (Theme::GetInteger(Theme::Int_PanelTitleBarHeight) * iItem->mpPanel->GetDPIScaleFactor());
     319             : 
     320        6543 :                 rAvailableHeight -= nPanelTitleBarHeight;
     321        6543 :                 rAvailableHeight -= nDeckSeparatorHeight;
     322             :             }
     323             : 
     324       21356 :             if (iItem->mpPanel->IsExpanded())
     325             :             {
     326       19219 :                 Reference<ui::XSidebarPanel> xPanel (iItem->mpPanel->GetPanelComponent());
     327       19219 :                 if (xPanel.is())
     328             :                 {
     329       19219 :                     aLayoutSize = xPanel->getHeightForWidth(rContentBox.GetWidth());
     330             : 
     331       19219 :                     sal_Int32 nWidth = xPanel->getMinimalWidth();
     332       19219 :                     if (nWidth > rMinimalWidth)
     333        4258 :                         rMinimalWidth = nWidth;
     334             :                 }
     335             :                 else
     336           0 :                     aLayoutSize = ui::LayoutSize(MinimalPanelHeight, -1, 0);
     337             :             }
     338             :         }
     339       21356 :         iItem->maLayoutSize = aLayoutSize;
     340             :     }
     341       17098 : }
     342             : 
     343             : 
     344             : 
     345             : 
     346       16950 : void DeckLayouter::DistributeHeights (
     347             :     ::std::vector<LayoutItem>& rLayoutItems,
     348             :     const sal_Int32 nHeightToDistribute,
     349             :     const sal_Int32 nContainerHeight,
     350             :     const bool bMinimumHeightIsBase)
     351             : {
     352       16950 :     if (nHeightToDistribute <= 0)
     353           0 :         return;
     354             : 
     355       16950 :     sal_Int32 nRemainingHeightToDistribute (nHeightToDistribute);
     356             : 
     357             :     // Compute the weights as difference between panel base height
     358             :     // (either its minimum or preferred height) and the container height.
     359       16950 :     sal_Int32 nTotalWeight (0);
     360       16950 :     sal_Int32 nNoMaximumCount (0);
     361       38158 :     IterateLayoutItems(iItem,rLayoutItems)
     362             :     {
     363       21208 :         if (iItem->maLayoutSize.Maximum == 0)
     364        2137 :             continue;
     365       19071 :         if (iItem->maLayoutSize.Maximum < 0)
     366       14813 :             ++nNoMaximumCount;
     367             : 
     368             :         const sal_Int32 nBaseHeight (
     369             :             bMinimumHeightIsBase
     370           0 :                 ? iItem->maLayoutSize.Minimum
     371       19071 :                 : iItem->maLayoutSize.Preferred);
     372       19071 :         if (nBaseHeight < nContainerHeight)
     373             :         {
     374       19071 :             iItem->mnWeight = nContainerHeight - nBaseHeight;
     375       19071 :             nTotalWeight += iItem->mnWeight;
     376             :         }
     377             :     }
     378             : 
     379       16950 :     if (nTotalWeight == 0)
     380           8 :         return;
     381             : 
     382             :     // First pass of height distribution.
     383       38142 :     IterateLayoutItems(iItem,rLayoutItems)
     384             :     {
     385             :         const sal_Int32 nBaseHeight (
     386             :             bMinimumHeightIsBase
     387           0 :                 ? iItem->maLayoutSize.Minimum
     388       21200 :                 : iItem->maLayoutSize.Preferred);
     389       21200 :         sal_Int32 nDistributedHeight (iItem->mnWeight * nHeightToDistribute / nTotalWeight);
     390       42400 :         if (nBaseHeight+nDistributedHeight > iItem->maLayoutSize.Maximum
     391       21200 :             && iItem->maLayoutSize.Maximum >= 0)
     392             :         {
     393        4258 :             nDistributedHeight = ::std::max<sal_Int32>(0,iItem->maLayoutSize.Maximum - nBaseHeight);
     394             :         }
     395       21200 :         iItem->mnDistributedHeight = nDistributedHeight;
     396       21200 :         nRemainingHeightToDistribute -= nDistributedHeight;
     397             :     }
     398             : 
     399       16942 :     if (nRemainingHeightToDistribute == 0)
     400       14813 :         return;
     401             :     OSL_ASSERT(nRemainingHeightToDistribute > 0);
     402             : 
     403             :     // It is possible that not all of the height could be distributed
     404             :     // because of Maximum heights being smaller than expected.
     405             :     // Distribute the remaining height between the panels that have no
     406             :     // Maximum (ie Maximum==-1).
     407        2129 :     if (nNoMaximumCount == 0)
     408             :     {
     409             :         // There are no panels with unrestricted height.
     410        2129 :         return;
     411             :     }
     412           0 :     const sal_Int32 nAdditionalHeightPerPanel (nRemainingHeightToDistribute / nNoMaximumCount);
     413             :     // Handle rounding error.
     414             :     sal_Int32 nAdditionalHeightForFirstPanel (nRemainingHeightToDistribute
     415           0 :         - nNoMaximumCount*nAdditionalHeightPerPanel);
     416           0 :     IterateLayoutItems(iItem,rLayoutItems)
     417             :     {
     418           0 :         if (iItem->maLayoutSize.Maximum < 0)
     419             :         {
     420           0 :             iItem->mnDistributedHeight += nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel;
     421           0 :             nRemainingHeightToDistribute -= nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel;
     422             :         }
     423             :     }
     424             : 
     425             :     OSL_ASSERT(nRemainingHeightToDistribute==0);
     426             : }
     427             : 
     428             : 
     429             : 
     430             : 
     431       21088 : Rectangle DeckLayouter::PlaceDeckTitle (
     432             :     vcl::Window& rDeckTitleBar,
     433             :     const Rectangle& rAvailableSpace)
     434             : {
     435       21088 :     if (static_cast<DockingWindow*>(rDeckTitleBar.GetParent()->GetParent())->IsFloatingMode())
     436             :     {
     437             :         // When the side bar is undocked then the outer system window displays the deck title.
     438           0 :         rDeckTitleBar.Hide();
     439           0 :         return rAvailableSpace;
     440             :     }
     441             :     else
     442             :     {
     443       21088 :         const sal_Int32 nDeckTitleBarHeight (Theme::GetInteger(Theme::Int_DeckTitleBarHeight) * rDeckTitleBar.GetDPIScaleFactor());
     444             :         rDeckTitleBar.setPosSizePixel(
     445             :             rAvailableSpace.Left(),
     446             :             rAvailableSpace.Top(),
     447             :             rAvailableSpace.GetWidth(),
     448       21088 :             nDeckTitleBarHeight);
     449       21088 :         rDeckTitleBar.Show();
     450             :         return Rectangle(
     451             :             rAvailableSpace.Left(),
     452       21088 :             rAvailableSpace.Top() + nDeckTitleBarHeight,
     453             :             rAvailableSpace.Right(),
     454       42176 :             rAvailableSpace.Bottom());
     455             :     }
     456             : }
     457             : 
     458             : 
     459             : 
     460             : 
     461       17098 : Rectangle DeckLayouter::PlaceVerticalScrollBar (
     462             :     ScrollBar& rVerticalScrollBar,
     463             :     const Rectangle& rAvailableSpace,
     464             :     const bool bShowVerticalScrollBar)
     465             : {
     466       17098 :     if (bShowVerticalScrollBar)
     467             :     {
     468          74 :         const sal_Int32 nScrollBarWidth (rVerticalScrollBar.GetSizePixel().Width());
     469             :         rVerticalScrollBar.setPosSizePixel(
     470          74 :             rAvailableSpace.Right() - nScrollBarWidth + 1,
     471             :             rAvailableSpace.Top(),
     472             :             nScrollBarWidth,
     473         148 :             rAvailableSpace.GetHeight());
     474          74 :         rVerticalScrollBar.Show();
     475             :         return Rectangle(
     476             :             rAvailableSpace.Left(),
     477             :             rAvailableSpace.Top(),
     478          74 :             rAvailableSpace.Right() - nScrollBarWidth,
     479         148 :             rAvailableSpace.Bottom());
     480             :     }
     481             :     else
     482             :     {
     483       17024 :         rVerticalScrollBar.Hide();
     484       17024 :         return rAvailableSpace;
     485             :     }
     486             : }
     487             : 
     488             : 
     489             : 
     490             : 
     491          74 : void DeckLayouter::SetupVerticalScrollBar(
     492             :     ScrollBar& rVerticalScrollBar,
     493             :     const sal_Int32 nContentHeight,
     494             :     const sal_Int32 nVisibleHeight)
     495             : {
     496             :     OSL_ASSERT(nContentHeight > nVisibleHeight);
     497             : 
     498          74 :     rVerticalScrollBar.SetRangeMin(0);
     499          74 :     rVerticalScrollBar.SetRangeMax(nContentHeight-1);
     500          74 :     rVerticalScrollBar.SetVisibleSize(nVisibleHeight);
     501          74 : }
     502             : 
     503             : 
     504             : 
     505             : 
     506       21088 : void DeckLayouter::UpdateFiller (
     507             :     vcl::Window& rFiller,
     508             :     const Rectangle& rBox)
     509             : {
     510       21088 :     if (rBox.GetHeight() > 0)
     511             :     {
     512             :         // Show the filler.
     513        6201 :         rFiller.SetBackground(Theme::GetPaint(Theme::Paint_PanelBackground).GetWallpaper());
     514        6201 :         rFiller.SetPosSizePixel(rBox.TopLeft(), rBox.GetSize());
     515        6201 :         rFiller.Show();
     516             :     }
     517             :     else
     518             :     {
     519             :         // Hide the filler.
     520       14887 :         rFiller.Hide();
     521             :     }
     522       21088 : }
     523             : 
     524             : 
     525             : 
     526         951 : } } // end of namespace sfx2::sidebar
     527             : 
     528             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10