writerfilter/source/dmapper/TableData.hxx

   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 #pragma once
  21
  22 #include <com/sun/star/text/XTextRange.hpp>
  23
  24 #include "PropertyMap.hxx"
  25
  26 #include <utility>
  27 #include <vector>
  28
  29 namespace writerfilter::dmapper
  30 {
  31
  32 /**
  33    Class containing the data to describe a table cell.
  34  */
  35 class CellData final : public virtual SvRefBase
  36 {
  37     /**
  38        Handle to start of cell.
  39     */
  40     css::uno::Reference<css::text::XTextRange> mStart;
  41
  42     /**
  43        Handle to end of cell.
  44     */
  45     css::uno::Reference<css::text::XTextRange> mEnd;
  46
  47     /**
  48        Pointer to properties of cell.
  49     */
  50     TablePropertyMapPtr mpProps;
  51
  52     bool mbOpen;
  53
  54     sal_uInt32 m_nGridSpan; ///< number of grid columns in the parent table's table grid which this cell defines
  55
  56 public:
  57     typedef tools::SvRef<CellData> Pointer_t;
  58
  59     CellData(css::uno::Reference<css::text::XTextRange> const & start, TablePropertyMapPtr pProps)
  60     : mStart(start), mEnd(start), mpProps(std::move(pProps)), mbOpen(true)
  61         , m_nGridSpan(1)
  62     {
  63     }
  64
  65     /**
  66        Set the end handle of a cell.
  67
  68        @param end     the end handle of the cell
  69     */
  70     void setEnd(css::uno::Reference<css::text::XTextRange> const & end) { mEnd = end; mbOpen = false; }
  71
  72     /**
  73        Adds properties to the cell.
  74
  75        @param pProps      the properties to add
  76      */
  77     void insertProperties(TablePropertyMapPtr pProps)
  78     {
  79         if( mpProps )
  80             mpProps->InsertProps(pProps.get());
  81         else
  82             mpProps = pProps;
  83     }
  84
  85     /**
  86        Return start handle of the cell.
  87      */
  88     const css::uno::Reference<css::text::XTextRange>& getStart() const { return mStart; }
  89
  90     /**
  91        Return end handle of the cell.
  92     */
  93     const css::uno::Reference<css::text::XTextRange>& getEnd() const { return mEnd; }
  94
  95     /**
  96        Return properties of the cell.
  97      */
  98     const TablePropertyMapPtr& getProperties() const { return mpProps; }
  99
 100     bool isOpen() const { return mbOpen; }
 101
 102     sal_uInt32 getGridSpan() const { return m_nGridSpan; }
 103     void setGridSpan( sal_uInt32 nSpan ) { m_nGridSpan = nSpan; }
 104
 105     void SetStart(const css::uno::Reference<css::text::XTextRange>& xStart) { mStart = xStart; }
 106
 107     bool IsValid() const;
 108 };
 109
 110 /**
 111    Class to handle data of a table row.
 112  */
 113 class RowData final : public virtual SvRefBase
 114 {
 115     typedef ::std::vector<CellData::Pointer_t> Cells;
 116
 117     /**
 118        the cell data of the row
 119      */
 120     Cells mCells;
 121
 122     /**
 123        the properties of the row
 124     */
 125     mutable TablePropertyMapPtr mpProperties;
 126
 127     sal_uInt32 m_nGridBefore; ///< number of grid columns in the parent table's table grid which must be skipped before the contents of this table row are added to the parent table
 128     sal_uInt32 m_nGridAfter; ///< number of grid columns in the parent table's table grid which shall be left after the last cell in the table row
 129
 130 public:
 131     typedef tools::SvRef<RowData> Pointer_t;
 132
 133     RowData()
 134         : m_nGridBefore(0)
 135         , m_nGridAfter(0)
 136     {
 137     }
 138
 139     RowData(const RowData& rRowData)
 140     : SvRefBase(), mCells(rRowData.mCells), mpProperties(rRowData.mpProperties)
 141         , m_nGridBefore(rRowData.m_nGridBefore)
 142         , m_nGridAfter(rRowData.m_nGridAfter)
 143     {
 144     }
 145
 146     /**
 147        Add a cell to the row.
 148
 149        @param start     the start handle of the cell
 150        @param end       the end handle of the cell
 151        @param pProps    the properties of the cell
 152        @param bAddBefore true: add an empty cell at beginning of the row for gridBefore
 153      */
 154     void addCell(const css::uno::Reference<css::text::XTextRange>& start, TablePropertyMapPtr pProps, bool bAddBefore = false)
 155     {
 156         CellData::Pointer_t pCellData(new CellData(start, pProps));
 157         if (bAddBefore)
 158         {
 159             mCells.insert(mCells.begin(), pCellData);
 160             mCells[0]->setEnd(start);
 161         }
 162         else
 163             mCells.push_back(pCellData);
 164     }
 165
 166     void endCell(const css::uno::Reference<css::text::XTextRange>& end)
 167     {
 168         if (mCells.size() > 0)
 169             mCells.back()->setEnd(end);
 170     }
 171
 172     bool isCellOpen() const
 173     {
 174         return mCells.size() > 0 && mCells.back()->isOpen();
 175     }
 176
 177     void SetCellStart(const css::uno::Reference<css::text::XTextRange>& xStart)
 178     {
 179         if (mCells.empty())
 180         {
 181             return;
 182         }
 183
 184         mCells.back()->SetStart(xStart);
 185     }
 186
 187     bool IsCellValid() const
 188     {
 189         return !mCells.empty() && mCells.back()->IsValid();
 190     }
 191
 192     /**
 193        Add properties to the row.
 194
 195        @param pProperties   the properties to set
 196      */
 197     void insertProperties(TablePropertyMapPtr pProperties)
 198     {
 199         if( pProperties )
 200         {
 201             if( !mpProperties )
 202                 mpProperties = pProperties;
 203             else
 204                 mpProperties->InsertProps(pProperties.get());
 205         }
 206     }
 207
 208     /**
 209         Add properties to the last cell of the row.
 210      */
 211     void insertCellProperties(TablePropertyMapPtr pProps)
 212     {
 213         if (!mCells.empty())
 214             mCells.back()->insertProperties(pProps);
 215     }
 216
 217     /**
 218        Return number of cells in the row.
 219     */
 220     unsigned int getCellCount() const
 221     {
 222         return mCells.size();
 223     }
 224
 225     /**
 226        Return start handle of a cell in the row.
 227
 228        @param i      index of the cell
 229      */
 230     const css::uno::Reference<css::text::XTextRange>& getCellStart(unsigned int i) const
 231     {
 232         return mCells[i]->getStart();
 233     }
 234
 235     /**
 236         Return end handle of a cell in the row.
 237
 238         @param i     index of the cell
 239     */
 240     const css::uno::Reference<css::text::XTextRange>& getCellEnd(unsigned int i) const
 241     {
 242         return mCells[i]->getEnd();
 243     }
 244
 245     /**
 246        Return the properties of a cell in the row.
 247
 248        @param i      index of the cell
 249      */
 250     TablePropertyMapPtr const & getCellProperties(unsigned int i) const
 251     {
 252         return mCells[i]->getProperties();
 253     }
 254
 255     /**
 256        Return properties of the row.
 257      */
 258     const TablePropertyMapPtr& getProperties() const
 259     {
 260         return mpProperties;
 261     }
 262
 263     sal_uInt32 getGridBefore() const { return m_nGridBefore; }
 264     void setGridBefore(sal_uInt32 nSkipGrids) { m_nGridBefore = nSkipGrids; }
 265     sal_uInt32 getGridAfter() const { return m_nGridAfter; }
 266     void setGridAfter(sal_uInt32 nSkipGrids) { m_nGridAfter = nSkipGrids; }
 267     sal_uInt32 getGridSpan(sal_uInt32 i) { return mCells[i]->getGridSpan(); }
 268     std::vector< sal_uInt32 > getGridSpans()
 269     {
 270         std::vector< sal_uInt32 > nRet;
 271         for (auto const& aCell: mCells)
 272             nRet.push_back(aCell->getGridSpan());
 273         return nRet;
 274     }
 275     void setCurrentGridSpan(sal_uInt32 nSpan, bool bFirstCell = false)
 276     {
 277         if ( mCells.size() )
 278         {
 279             if ( bFirstCell )
 280                 mCells.front()->setGridSpan(nSpan);
 281             else
 282                 mCells.back()->setGridSpan(nSpan);
 283         }
 284     }
 285 };
 286
 287 /**
 288    Class that holds the data of a table.
 289  */
 290 class TableData : public virtual SvRefBase
 291 {
 292     typedef RowData::Pointer_t RowPointer_t;
 293     typedef ::std::vector<RowPointer_t> Rows;
 294
 295     /**
 296        the data of the rows of the table
 297     */
 298     Rows mRows;
 299
 300     /**
 301         pointer to the data of the current row (while building up the table data).
 302     */
 303     RowPointer_t mpRow;
 304
 305     /**
 306        depth of the current table in a hierarchy of tables
 307      */
 308     unsigned int mnDepth;
 309
 310     /**
 311        initialize mpRow
 312      */
 313     void newRow() { mpRow = RowPointer_t(new RowData()); }
 314
 315 public:
 316     typedef tools::SvRef<TableData> Pointer_t;
 317
 318     explicit TableData(unsigned int nDepth) : mnDepth(nDepth) { newRow(); }
 319
 320     /**
 321        End the current row.
 322
 323        Sets properties of the current row and pushes the row to the
 324        back of the rows currently contained in the table.
 325
 326        @param pProperties    properties of the row to be ended
 327      */
 328     void endRow(TablePropertyMapPtr pProperties)
 329     {
 330         mpRow->insertProperties(pProperties);
 331         mRows.push_back(mpRow);
 332         newRow();
 333     }
 334
 335     /**
 336        Add a cell to the current row.
 337
 338        @param start   start handle of the cell
 339        @param end     end handle of the cell
 340        @param pProps  properties of the cell
 341      */
 342     void addCell(const css::uno::Reference<css::text::XTextRange>& start, TablePropertyMapPtr pProps)
 343     {
 344         mpRow->addCell(start, pProps);
 345     }
 346
 347     /**
 348         End the current cell of the current row.
 349
 350         @parm end    end handle of the cell
 351      */
 352     void endCell(const css::uno::Reference<css::text::XTextRange>& end)
 353     {
 354         mpRow->endCell(end);
 355     }
 356
 357     /**
 358         Return if the current cell of the current row is open.
 359      */
 360     bool isCellOpen() const
 361     {
 362         return mpRow->isCellOpen();
 363     }
 364
 365     void SetCellStart(const css::uno::Reference<css::text::XTextRange>& xStart)
 366     {
 367         mpRow->SetCellStart(xStart);
 368     }
 369
 370     bool IsCellValid() const
 371     {
 372         return mpRow->IsCellValid();
 373     }
 374
 375     /**
 376         Insert properties to the current cell of the current row.
 377
 378         @param pProps   the properties to add
 379      */
 380     void insertCellProperties(TablePropertyMapPtr pProps)
 381     {
 382         mpRow->insertCellProperties(pProps);
 383     }
 384
 385     /**
 386        Return number of rows in the table.
 387      */
 388     unsigned int getRowCount() const
 389     {
 390         return mRows.size();
 391     }
 392
 393     /**
 394        Return depth of table in surrounding table hierarchy.
 395     */
 396     unsigned int getDepth() const
 397     {
 398         return mnDepth;
 399     }
 400
 401     /**
 402        Return row data of a certain row.
 403
 404        @param i     index of the row
 405     */
 406     RowPointer_t const & getRow(unsigned int i) const
 407     {
 408         return mRows[i];
 409     }
 410
 411     const RowPointer_t& getCurrentRow() const
 412     {
 413         return mpRow;
 414     }
 415 };
 416
 417 }
 418
 419
 420 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */