| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| #include "precompiled_sfx2.hxx" |
| #include "sfx2/sidebar/GridLayouter.hxx" |
| |
| #include <vcl/window.hxx> |
| |
| namespace sfx2 { namespace sidebar { |
| |
| typedef std::vector<CellDescriptor> CellData; |
| typedef std::vector<CellData> ColumnData; |
| |
| class GridLayouter::Implementation |
| { |
| public: |
| Implementation (Window& rParent); |
| ~Implementation (void); |
| |
| CellDescriptor& GetCell ( |
| const sal_Int32 nRow, |
| const sal_Int32 nColumn, |
| const sal_Int32 nVariant); |
| |
| void Layout (void); |
| void LayoutColumn( |
| ColumnData& rColumn, |
| const sal_Int32 nX, |
| const sal_Int32 nColumnIndex); |
| |
| void DistributeWidth (const sal_Int32 nTotalWidth); |
| sal_Int32 GetMinimumColumnWidth ( |
| ColumnData& rColumn, |
| const ColumnDescriptor& rDescriptor) const; |
| |
| void Paint (void); |
| |
| Window& mrParent; |
| ::std::vector<ColumnData> maColumns; |
| ::std::vector<ColumnDescriptor> maColumnDescriptors; |
| }; |
| |
| #define ForAllColumnDescriptors(I) \ |
| for (::std::vector<ColumnDescriptor>::iterator \ |
| I(maColumnDescriptors.begin()), \ |
| iEnd(maColumnDescriptors.end()); \ |
| I!=iEnd; \ |
| ++I) |
| |
| #define ForAllColumns(I,N) \ |
| sal_Int32 N (0); \ |
| for (::std::vector<ColumnData>::iterator \ |
| I(maColumns.begin()), \ |
| iEnd(maColumns.end()); \ |
| I!=iEnd; \ |
| ++I,++N) |
| |
| #define ForAllRows(ColumnData,I) \ |
| for (std::vector<CellData>::iterator \ |
| I((ColumnData).begin()), \ |
| iRowEnd((ColumnData).end()); \ |
| I!=iRowEnd; \ |
| ++I) |
| |
| #define ForAllCells(CellData,I) \ |
| for (::std::vector<CellDescriptor>::iterator \ |
| I((CellData).begin()), \ |
| iCellEnd((CellData).end()); \ |
| I!=iCellEnd; \ |
| ++I) |
| |
| |
| //===== GridLayouter ========================================================== |
| |
| GridLayouter::GridLayouter (Window& rParent) |
| : mpImplementation(new Implementation(rParent)) |
| { |
| } |
| |
| |
| |
| |
| GridLayouter::~GridLayouter (void) |
| { |
| } |
| |
| |
| |
| |
| CellDescriptor& GridLayouter::GetCell ( |
| const sal_Int32 nRow, |
| const sal_Int32 nColumn, |
| const sal_Int32 nVariant) |
| { |
| return mpImplementation->GetCell(nRow, nColumn, nVariant); |
| } |
| |
| |
| |
| |
| ColumnDescriptor& GridLayouter::GetColumn ( |
| const sal_Int32 nColumn) |
| { |
| // Make sure that the specified column exists. |
| mpImplementation->GetCell(0, nColumn, 0); |
| return mpImplementation->maColumnDescriptors[nColumn]; |
| } |
| |
| |
| |
| |
| void GridLayouter::Layout (void) |
| { |
| mpImplementation->Layout(); |
| } |
| |
| |
| |
| |
| void GridLayouter::Paint (const Rectangle& rBox) |
| { |
| (void)rBox; |
| |
| mpImplementation->Paint(); |
| } |
| |
| |
| |
| |
| //===== CellDescriptor ======================================================== |
| |
| CellDescriptor::CellDescriptor (void) |
| : mpControl(NULL), |
| mnGridWidth(1), |
| mnMinimumWidth(-1), |
| mnMaximumWidth(-1), |
| mnOffset(0) |
| { |
| } |
| |
| |
| |
| |
| CellDescriptor::~CellDescriptor (void) |
| { |
| } |
| |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetGridWidth (const sal_Int32 nColumnCount) |
| { |
| mnGridWidth = nColumnCount; |
| return *this; |
| } |
| |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetControl (Window& rControl) |
| { |
| mpControl = &rControl; |
| return *this; |
| } |
| |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetFixedWidth (const sal_Int32 nWidth) |
| { |
| mnMinimumWidth = nWidth; |
| mnMaximumWidth = nWidth; |
| return *this; |
| } |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetOffset (const sal_Int32 nOffset) |
| { |
| mnOffset = nOffset; |
| return *this; |
| } |
| |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetFixedWidth (void) |
| { |
| sal_Int32 nMaxControlWidth (0); |
| if (mpControl != NULL) |
| { |
| const sal_Int32 nControlWidth (mpControl->GetSizePixel().Width()); |
| if (nControlWidth > nMaxControlWidth) |
| nMaxControlWidth = nControlWidth; |
| } |
| mnMinimumWidth = nMaxControlWidth; |
| mnMaximumWidth = nMaxControlWidth; |
| |
| return *this; |
| } |
| |
| |
| |
| |
| CellDescriptor& CellDescriptor::SetMinimumWidth (const sal_Int32 nWidth) |
| { |
| mnMinimumWidth = nWidth; |
| return *this; |
| } |
| |
| |
| |
| sal_Int32 CellDescriptor::GetGridWidth (void) const |
| { |
| return mnGridWidth; |
| } |
| |
| |
| |
| |
| Window* CellDescriptor::GetControl (void) const |
| { |
| return mpControl; |
| } |
| |
| |
| |
| |
| sal_Int32 CellDescriptor::GetMinimumWidth (void) const |
| { |
| return mnMinimumWidth + mnOffset; |
| } |
| |
| |
| |
| |
| sal_Int32 CellDescriptor::GetMaximumWidth (void) const |
| { |
| return mnMaximumWidth; |
| } |
| |
| |
| |
| sal_Int32 CellDescriptor::GetOffset (void) const |
| { |
| return mnOffset; |
| } |
| |
| |
| |
| |
| //===== GridLayouter::Implementation ========================================== |
| |
| GridLayouter::Implementation::Implementation (Window& rParent) |
| : mrParent(rParent), |
| maColumns(), |
| maColumnDescriptors() |
| { |
| } |
| |
| |
| |
| |
| GridLayouter::Implementation::~Implementation (void) |
| { |
| } |
| |
| |
| |
| |
| CellDescriptor& GridLayouter::Implementation::GetCell ( |
| const sal_Int32 nRow, |
| const sal_Int32 nColumn, |
| const sal_Int32 nVariant) |
| { |
| if (nColumn<0 || nRow<0 || nVariant<0) |
| { |
| OSL_ASSERT(nColumn>=0); |
| OSL_ASSERT(nRow>=0); |
| OSL_ASSERT(nVariant>=0); |
| return GetCell(0,0,0); |
| } |
| |
| // Provide missing columns. |
| if (maColumns.size() <= static_cast<size_t>(nColumn)) |
| { |
| maColumns.resize(nColumn+1); |
| maColumnDescriptors.resize(nColumn+1); |
| } |
| |
| // Provide missing rows. |
| ColumnData& rColumn (maColumns[nColumn]); |
| if (rColumn.size() <= static_cast<size_t>(nRow)) |
| rColumn.resize(nRow+1); |
| |
| // Provide missing variants. |
| CellData& rCellData (rColumn[nRow]); |
| if (rCellData.size() <= static_cast<size_t>(nVariant)) |
| rCellData.resize(nVariant+1); |
| |
| return rCellData[nVariant]; |
| } |
| |
| |
| |
| |
| void GridLayouter::Implementation::Layout (void) |
| { |
| if (maColumns.empty()) |
| { |
| // There are no columns and therefore no controls => nothing |
| // to do. |
| return; |
| } |
| |
| const Size aParentSize (mrParent.GetSizePixel()); |
| |
| // Determine the total column weight. |
| sal_Int32 nTotalColumnWeight (0); |
| ForAllColumnDescriptors(iDescriptor) |
| nTotalColumnWeight += iDescriptor->GetWeight(); |
| if (nTotalColumnWeight <= 0) |
| { |
| OSL_ASSERT(nTotalColumnWeight>0); |
| return; |
| } |
| |
| // Distribute the width of the parent window to the columns. |
| DistributeWidth(aParentSize.Width()); |
| |
| // Set the new positions and widths. |
| sal_Int32 nX (0); |
| ForAllColumns(iColumn,nColumnIndex) |
| { |
| LayoutColumn( |
| *iColumn, |
| nX, |
| nColumnIndex); |
| |
| nX += maColumnDescriptors[nColumnIndex].GetWidth(); |
| } |
| } |
| |
| |
| |
| |
| void GridLayouter::Implementation::LayoutColumn( |
| ColumnData& rColumn, |
| const sal_Int32 nX, |
| const sal_Int32 nColumnIndex) |
| { |
| ColumnDescriptor& rDescriptor (maColumnDescriptors[nColumnIndex]); |
| const sal_Int32 nLeft (nX + rDescriptor.GetLeftPadding()); |
| const sal_Int32 nWidth (rDescriptor.GetWidth() - rDescriptor.GetLeftPadding() - rDescriptor.GetRightPadding()); |
| |
| sal_Int32 nRow (-1); |
| ForAllRows(rColumn, iCell) |
| { |
| ++nRow; |
| |
| ForAllCells(*iCell, iCellDescriptor) |
| { |
| Window* pControl = iCellDescriptor->GetControl(); |
| if (pControl==NULL || ! pControl->IsVisible()) |
| continue; |
| |
| sal_Int32 nCellWidth (nWidth); |
| const sal_Int32 nGridWidth (iCellDescriptor->GetGridWidth()); |
| if (nGridWidth < 0) |
| continue; |
| else if (nGridWidth > 1) |
| { |
| // Cell spans more than one column. Sum all their |
| // widths. |
| for (sal_Int32 nOffset=1; |
| nOffset<nGridWidth && static_cast<size_t>(nColumnIndex+nOffset)<maColumnDescriptors.size(); |
| ++nOffset) |
| { |
| nCellWidth += maColumnDescriptors[nColumnIndex+nOffset].GetWidth(); |
| } |
| nCellWidth -= maColumnDescriptors[nColumnIndex+nGridWidth-1].GetRightPadding(); |
| } |
| |
| // Check width against valid range of cell. |
| if (iCellDescriptor->GetMinimumWidth() > 0) |
| if (nCellWidth < iCellDescriptor->GetMinimumWidth()) |
| nCellWidth = iCellDescriptor->GetMinimumWidth(); |
| if (iCellDescriptor->GetMaximumWidth() > 0) |
| if (nCellWidth > iCellDescriptor->GetMaximumWidth()) |
| nCellWidth = iCellDescriptor->GetMaximumWidth(); |
| |
| pControl->SetPosSizePixel( |
| nLeft + iCellDescriptor->GetOffset(), |
| 0, |
| nCellWidth, |
| 0, |
| WINDOW_POSSIZE_X | WINDOW_POSSIZE_WIDTH); |
| } |
| } |
| } |
| |
| |
| |
| |
| void GridLayouter::Implementation::DistributeWidth (const sal_Int32 nTotalWidth) |
| { |
| // Prepare width distribution: |
| // a) Setup minimum widths for all columns. |
| // b) Sum up the width of columns that have zero weight. |
| // c) Sum up the non-zero weights. |
| sal_Int32 nZeroWeightWidth (0); |
| sal_Int32 nTotalColumnWeight (0); |
| for (sal_uInt32 nColumn=0; nColumn<maColumns.size(); ++nColumn) |
| { |
| ColumnDescriptor& rDescriptor (maColumnDescriptors[nColumn]); |
| ColumnData& rColumn (maColumns[nColumn]); |
| |
| const sal_Int32 nWidth (GetMinimumColumnWidth(rColumn, rDescriptor)); |
| |
| rDescriptor.SetWidth(nWidth); |
| |
| if (rDescriptor.GetWeight() <= 0) |
| nZeroWeightWidth += nWidth; |
| else |
| nTotalColumnWeight += rDescriptor.GetWeight(); |
| } |
| |
| sal_Int32 nRemainingWidth (nTotalWidth - nZeroWeightWidth); |
| if (nRemainingWidth < 0) |
| nRemainingWidth = 0; |
| |
| |
| // Distribute the remaining width between columns that have |
| // non-zero width. |
| const sal_Int32 nDistributableWidth (nRemainingWidth); |
| for (sal_uInt32 nColumn=0; nColumn<maColumns.size(); ++nColumn) |
| { |
| ColumnDescriptor& rDescriptor (maColumnDescriptors[nColumn]); |
| |
| if (rDescriptor.GetWeight() > 0) |
| { |
| sal_Int32 nWidth (nDistributableWidth * rDescriptor.GetWeight() / nTotalColumnWeight); |
| // Make sure the width lies inside the valid range of |
| // column widths. |
| if (nWidth < rDescriptor.GetWidth()) |
| nWidth = rDescriptor.GetWidth(); |
| if (rDescriptor.GetMaximumWidth()>0) |
| if (nWidth > rDescriptor.GetTotalMaximumWidth()) |
| nWidth = rDescriptor.GetTotalMaximumWidth(); |
| |
| rDescriptor.SetWidth(nWidth); |
| nRemainingWidth -= nWidth; |
| } |
| } |
| |
| // If there are some pixels left (due to rounding errors), then |
| // give them to the first column that has non-zero weight. |
| if (nRemainingWidth > 0) |
| for (sal_uInt32 nColumn=0; nColumn<maColumns.size(); ++nColumn) |
| { |
| ColumnDescriptor& rDescriptor (maColumnDescriptors[nColumn]); |
| if (rDescriptor.GetWeight() > 0) |
| { |
| rDescriptor.SetWidth(rDescriptor.GetWidth() + nRemainingWidth); |
| break; |
| } |
| } |
| } |
| |
| |
| |
| |
| sal_Int32 GridLayouter::Implementation::GetMinimumColumnWidth ( |
| ColumnData& rColumn, |
| const ColumnDescriptor& rDescriptor) const |
| { |
| // Start with the minimum width of the whole column. |
| sal_Int32 nMinimumWidth (rDescriptor.GetMinimumWidth()); |
| |
| // Take also into account the minimum widths of all cells in the column. |
| ForAllRows(rColumn, iCell) |
| ForAllCells(*iCell, iCellDescriptor) |
| { |
| if (iCellDescriptor->GetGridWidth() != 1) |
| continue; |
| const sal_Int32 nMinimumCellWidth (iCellDescriptor->GetMinimumWidth()); |
| if (nMinimumCellWidth > nMinimumWidth) |
| nMinimumWidth = nMinimumCellWidth; |
| } |
| |
| // Make sure that the minimum width does not become larger than |
| // the maximum width of the column. |
| if (nMinimumWidth > rDescriptor.GetMaximumWidth() && rDescriptor.GetMaximumWidth()>0) |
| nMinimumWidth = rDescriptor.GetMaximumWidth(); |
| |
| // Add the horizontal padding. |
| return nMinimumWidth |
| + rDescriptor.GetLeftPadding() |
| + rDescriptor.GetRightPadding(); |
| } |
| |
| |
| |
| |
| void GridLayouter::Implementation::Paint (void) |
| { |
| const Size aParentSize (mrParent.GetSizePixel()); |
| |
| static const Color aSeparatorColor (0x66cdaa); |
| static const Color aLeftPaddingColor (0x98fb98); |
| static const Color aRightPaddingColor (0xff69b4); |
| static const Color aControlOverlayColor (0xffff00); |
| |
| sal_Int32 nX (0); |
| mrParent.SetLineColor(); |
| mrParent.SetFillColor(aLeftPaddingColor); |
| ForAllColumnDescriptors(iColumn) |
| { |
| if (iColumn->GetLeftPadding() > 0) |
| { |
| mrParent.DrawRect(Rectangle( |
| nX,0, |
| nX+iColumn->GetLeftPadding(),aParentSize.Height())); |
| } |
| |
| nX += iColumn->GetWidth(); |
| } |
| |
| nX = 0; |
| mrParent.SetFillColor(aRightPaddingColor); |
| ForAllColumnDescriptors(iColumn) |
| { |
| if (iColumn->GetRightPadding() > 0) |
| { |
| const sal_Int32 nRight (nX + iColumn->GetWidth()); |
| const sal_Int32 nLeft (nRight - iColumn->GetRightPadding()); |
| mrParent.DrawRect(Rectangle( |
| nLeft,0, |
| nRight,aParentSize.Height())); |
| } |
| |
| nX += iColumn->GetWidth(); |
| } |
| |
| nX = 0; |
| mrParent.SetFillColor(); |
| mrParent.SetLineColor(aSeparatorColor); |
| ForAllColumnDescriptors(iColumn) |
| { |
| mrParent.DrawLine(Point(nX,0), Point(nX,aParentSize.Height())); |
| nX += iColumn->GetWidth(); |
| } |
| |
| mrParent.SetFillColor(); |
| mrParent.SetLineColor(aControlOverlayColor); |
| ForAllColumns(iColumn,nColumnIndex) |
| ForAllRows(*iColumn, iCell) |
| ForAllCells(*iCell, iCellDescriptor) |
| { |
| Window* pControl (iCellDescriptor->GetControl()); |
| if (pControl!=NULL && pControl->IsVisible()) |
| { |
| Rectangle aBox ( |
| pControl->GetPosPixel(), |
| pControl->GetSizePixel()); |
| --aBox.Left(); |
| --aBox.Top(); |
| ++aBox.Right(); |
| ++aBox.Bottom(); |
| mrParent.DrawRect(aBox); |
| } |
| } |
| } |
| |
| |
| |
| |
| //===== ColumnDescriptor ====================================================== |
| |
| ColumnDescriptor::ColumnDescriptor (void) |
| : mnWeight(1), |
| mnMinimumWidth(0), |
| mnMaximumWidth(-1), |
| mnLeftPadding(0), |
| mnRightPadding(0), |
| mnWidth(0) |
| { |
| } |
| |
| |
| |
| |
| ColumnDescriptor::~ColumnDescriptor (void) |
| { |
| } |
| |
| |
| |
| |
| ColumnDescriptor& ColumnDescriptor::SetWeight (const sal_Int32 nWeight) |
| { |
| mnWeight = nWeight; |
| |
| return *this; |
| } |
| |
| |
| |
| |
| ColumnDescriptor& ColumnDescriptor::SetMinimumWidth (const sal_Int32 nWidth) |
| { |
| mnMinimumWidth = nWidth; |
| |
| return *this; |
| } |
| |
| |
| |
| ColumnDescriptor& ColumnDescriptor::SetFixedWidth (const sal_Int32 nWidth) |
| { |
| mnMinimumWidth = nWidth; |
| mnMaximumWidth = nWidth; |
| |
| return *this; |
| } |
| |
| |
| |
| ColumnDescriptor& ColumnDescriptor::SetLeftPadding (const sal_Int32 nPadding) |
| { |
| mnLeftPadding = nPadding; |
| |
| return *this; |
| } |
| |
| |
| |
| |
| ColumnDescriptor& ColumnDescriptor::SetRightPadding (const sal_Int32 nPadding) |
| { |
| mnRightPadding = nPadding; |
| |
| return *this; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetWeight (void) const |
| { |
| return mnWeight; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetMinimumWidth (void) const |
| { |
| return mnMinimumWidth; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetMaximumWidth (void) const |
| { |
| return mnMaximumWidth; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetTotalMaximumWidth (void) const |
| { |
| return mnMaximumWidth + mnLeftPadding + mnRightPadding; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetLeftPadding (void) const |
| { |
| return mnLeftPadding; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetRightPadding (void) const |
| { |
| return mnRightPadding; |
| } |
| |
| |
| |
| |
| void ColumnDescriptor::SetWidth (const sal_Int32 nWidth) |
| { |
| mnWidth = nWidth; |
| } |
| |
| |
| |
| |
| sal_Int32 ColumnDescriptor::GetWidth (void) const |
| { |
| return mnWidth; |
| } |
| |
| } } // end of namespace sfx2::sidebar |
