sc/source/core/data/dpoutputgeometry.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 "dpoutputgeometry.hxx"
  21 #include "address.hxx"
  22
  23 #include <vector>
  24
  25 using ::std::vector;
  26
  27 ScDPOutputGeometry::ScDPOutputGeometry(const ScRange& rOutRange, bool bShowFilter) :
  28     maOutRange(rOutRange),
  29     mnRowFields(0),
  30     mnColumnFields(0),
  31     mnPageFields(0),
  32     mnDataFields(0),
  33     meDataLayoutType(None),
  34     mbShowFilter(bShowFilter)
  35 {
  36 }
  37
  38 ScDPOutputGeometry::~ScDPOutputGeometry()
  39 {
  40 }
  41
  42 void ScDPOutputGeometry::setRowFieldCount(sal_uInt32 nCount)
  43 {
  44     mnRowFields = nCount;
  45 }
  46
  47 void ScDPOutputGeometry::setColumnFieldCount(sal_uInt32 nCount)
  48 {
  49     mnColumnFields = nCount;
  50 }
  51
  52 void ScDPOutputGeometry::setPageFieldCount(sal_uInt32 nCount)
  53 {
  54     mnPageFields = nCount;
  55 }
  56
  57 void ScDPOutputGeometry::setDataFieldCount(sal_uInt32 nCount)
  58 {
  59     mnDataFields = nCount;
  60 }
  61
  62 void ScDPOutputGeometry::setDataLayoutType(FieldType eType)
  63 {
  64     meDataLayoutType = eType;
  65 }
  66
  67 void ScDPOutputGeometry::getColumnFieldPositions(vector<ScAddress>& rAddrs) const
  68 {
  69     sal_uInt32 nColumnFields, nRowFields;
  70     adjustFieldsForDataLayout(nColumnFields, nRowFields);
  71
  72     vector<ScAddress> aAddrs;
  73     if (!nColumnFields)
  74     {
  75         rAddrs.swap(aAddrs);
  76         return;
  77     }
  78
  79     SCROW nCurRow = maOutRange.aStart.Row();
  80
  81     if (mnPageFields)
  82     {
  83         SCROW nRowStart = maOutRange.aStart.Row() + int(mbShowFilter);
  84         SCROW nRowEnd   = nRowStart + static_cast<SCCOL>(mnPageFields-1);
  85         nCurRow = nRowEnd + 2;
  86     }
  87     else if (mbShowFilter)
  88         nCurRow += 2;
  89
  90     SCROW nRow = nCurRow;
  91     SCTAB nTab = maOutRange.aStart.Tab();
  92     SCCOL nColStart = static_cast<SCCOL>(maOutRange.aStart.Col() + nRowFields);
  93     SCCOL nColEnd = nColStart + static_cast<SCCOL>(nColumnFields-1);
  94
  95     for (SCCOL nCol = nColStart; nCol <= nColEnd; ++nCol)
  96         aAddrs.push_back(ScAddress(nCol, nRow, nTab));
  97     rAddrs.swap(aAddrs);
  98 }
  99
 100 void ScDPOutputGeometry::getRowFieldPositions(vector<ScAddress>& rAddrs) const
 101 {
 102     sal_uInt32 nColumnFields, nRowFields;
 103     adjustFieldsForDataLayout(nColumnFields, nRowFields);
 104
 105     vector<ScAddress> aAddrs;
 106     if (!nRowFields)
 107     {
 108         rAddrs.swap(aAddrs);
 109         return;
 110     }
 111
 112     SCROW nRow = getRowFieldHeaderRow();
 113     SCTAB nTab = maOutRange.aStart.Tab();
 114     SCCOL nColStart = maOutRange.aStart.Col();
 115     SCCOL nColEnd = nColStart + static_cast<SCCOL>(nRowFields-1);
 116
 117     for (SCCOL nCol = nColStart; nCol <= nColEnd; ++nCol)
 118         aAddrs.push_back(ScAddress(nCol, nRow, nTab));
 119     rAddrs.swap(aAddrs);
 120 }
 121
 122 void ScDPOutputGeometry::getPageFieldPositions(vector<ScAddress>& rAddrs) const
 123 {
 124     vector<ScAddress> aAddrs;
 125     if (!mnPageFields)
 126     {
 127         rAddrs.swap(aAddrs);
 128         return;
 129     }
 130
 131     SCTAB nTab = maOutRange.aStart.Tab();
 132     SCCOL nCol = maOutRange.aStart.Col();
 133
 134     SCROW nRowStart = maOutRange.aStart.Row() + int(mbShowFilter);
 135     SCROW nRowEnd   = nRowStart + static_cast<SCCOL>(mnPageFields-1);
 136
 137     for (SCROW nRow = nRowStart; nRow <= nRowEnd; ++nRow)
 138         aAddrs.push_back(ScAddress(nCol, nRow, nTab));
 139     rAddrs.swap(aAddrs);
 140 }
 141
 142 SCROW ScDPOutputGeometry::getRowFieldHeaderRow() const
 143 {
 144     SCROW nCurRow = maOutRange.aStart.Row();
 145     sal_uInt32 nColumnFields, nRowFields;
 146     adjustFieldsForDataLayout(nColumnFields, nRowFields);
 147
 148     if (mnPageFields)
 149     {
 150         SCROW nRowStart = maOutRange.aStart.Row() + int(mbShowFilter);
 151         SCROW nRowEnd   = nRowStart + static_cast<SCCOL>(mnPageFields-1);
 152         nCurRow = nRowEnd + 2;
 153     }
 154     else if (mbShowFilter)
 155         nCurRow += 2;
 156
 157     if (nColumnFields)
 158         nCurRow += static_cast<SCROW>(nColumnFields);
 159     else if (nRowFields)
 160         ++nCurRow;
 161
 162     return nCurRow;
 163 }
 164
 165 void ScDPOutputGeometry::adjustFieldsForDataLayout(sal_uInt32& rColumnFields, sal_uInt32& rRowFields) const
 166 {
 167     rRowFields = mnRowFields;
 168     rColumnFields = mnColumnFields;
 169
 170     if (mnDataFields < 2)
 171     {
 172         // Data layout field can be either row or column field, never page field.
 173         switch (meDataLayoutType)
 174         {
 175             case Column:
 176                 if (rColumnFields > 0)
 177                     rColumnFields -= 1;
 178             break;
 179             case Row:
 180                 if (rRowFields > 0)
 181                     rRowFields -= 1;
 182             default:
 183                 ;
 184         }
 185     }
 186 }
 187
 188 std::pair<ScDPOutputGeometry::FieldType, size_t>
 189 ScDPOutputGeometry::getFieldButtonType(const ScAddress& rPos) const
 190 {
 191     SCROW nCurRow = maOutRange.aStart.Row();
 192     sal_uInt32 nColumnFields, nRowFields;
 193     adjustFieldsForDataLayout(nColumnFields, nRowFields);
 194
 195     if (mnPageFields)
 196     {
 197         SCCOL nCol = maOutRange.aStart.Col();
 198         SCROW nRowStart = maOutRange.aStart.Row() + int(mbShowFilter);
 199         SCROW nRowEnd   = nRowStart + static_cast<SCCOL>(mnPageFields-1);
 200         if (rPos.Col() == nCol && nRowStart <= rPos.Row() && rPos.Row() <= nRowEnd)
 201         {
 202             size_t nPos = static_cast<size_t>(rPos.Row() - nRowStart);
 203             return std::pair<FieldType, size_t>(Page, nPos);
 204         }
 205
 206         nCurRow = nRowEnd + 2;
 207     }
 208     else if (mbShowFilter)
 209         nCurRow += 2;
 210
 211     if (nColumnFields)
 212     {
 213         SCROW nRow = nCurRow;
 214         SCCOL nColStart = static_cast<SCCOL>(maOutRange.aStart.Col() + nRowFields);
 215         SCCOL nColEnd = nColStart + static_cast<SCCOL>(nColumnFields-1);
 216         if (rPos.Row() == nRow && nColStart <= rPos.Col() && rPos.Col() <= nColEnd)
 217         {
 218             size_t nPos = static_cast<size_t>(rPos.Col() - nColStart);
 219             return std::pair<FieldType, size_t>(Column, nPos);
 220         }
 221
 222         nCurRow += static_cast<SCROW>(nColumnFields);
 223     }
 224     else
 225         ++nCurRow;
 226
 227     if (nRowFields)
 228     {
 229         SCCOL nColStart = maOutRange.aStart.Col();
 230         SCCOL nColEnd = nColStart + static_cast<SCCOL>(nRowFields-1);
 231         if (rPos.Row() == nCurRow && nColStart <= rPos.Col() && rPos.Col() <= nColEnd)
 232         {
 233             size_t nPos = static_cast<size_t>(rPos.Col() - nColStart);
 234             return std::pair<FieldType, size_t>(Row, nPos);
 235         }
 236     }
 237
 238     return std::pair<FieldType, size_t>(None, 0);
 239 }
 240
 241 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */