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(const 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 ::std::vector<RowData::Pointer_t> Rows;
 293
 294     /**
 295        the data of the rows of the table
 296     */
 297     Rows mRows;
 298
 299     /**
 300         pointer to the data of the current row (while building up the table data).
 301     */
 302     RowData::Pointer_t mpRow;
 303
 304     /**
 305        depth of the current table in a hierarchy of tables
 306      */
 307     unsigned int mnDepth;
 308
 309     /**
 310        initialize mpRow
 311      */
 312     void newRow() { mpRow = RowData::Pointer_t(new RowData()); }
 313
 314 public:
 315     typedef tools::SvRef<TableData> Pointer_t;
 316
 317     explicit TableData(unsigned int nDepth) : mnDepth(nDepth) { newRow(); }
 318
 319     /**
 320        End the current row.
 321
 322        Sets properties of the current row and pushes the row to the
 323        back of the rows currently contained in the table.
 324
 325        @param pProperties    properties of the row to be ended
 326      */
 327     void endRow(TablePropertyMapPtr pProperties)
 328     {
 329         mpRow->insertProperties(pProperties);
 330         mRows.push_back(mpRow);
 331         newRow();
 332     }
 333
 334     /**
 335        Add a cell to the current row.
 336
 337        @param start   start handle of the cell
 338        @param end     end handle of the cell
 339        @param pProps  properties of the cell
 340      */
 341     void addCell(const css::uno::Reference<css::text::XTextRange>& start, TablePropertyMapPtr pProps)
 342     {
 343         mpRow->addCell(start, pProps);
 344     }
 345
 346     /**
 347         End the current cell of the current row.
 348
 349         @parm end    end handle of the cell
 350      */
 351     void endCell(const css::uno::Reference<css::text::XTextRange>& end)
 352     {
 353         mpRow->endCell(end);
 354     }
 355
 356     /**
 357         Return if the current cell of the current row is open.
 358      */
 359     bool isCellOpen() const
 360     {
 361         return mpRow->isCellOpen();
 362     }
 363
 364     void SetCellStart(const css::uno::Reference<css::text::XTextRange>& xStart)
 365     {
 366         mpRow->SetCellStart(xStart);
 367     }
 368
 369     bool IsCellValid() const
 370     {
 371         return mpRow->IsCellValid();
 372     }
 373
 374     /**
 375         Insert properties to the current cell of the current row.
 376
 377         @param pProps   the properties to add
 378      */
 379     void insertCellProperties(const TablePropertyMapPtr& pProps)
 380     {
 381         mpRow->insertCellProperties(pProps);
 382     }
 383
 384     /**
 385        Return number of rows in the table.
 386      */
 387     unsigned int getRowCount() const
 388     {
 389         return mRows.size();
 390     }
 391
 392     /**
 393        Return depth of table in surrounding table hierarchy.
 394     */
 395     unsigned int getDepth() const
 396     {
 397         return mnDepth;
 398     }
 399
 400     /**
 401        Return row data of a certain row.
 402
 403        @param i     index of the row
 404     */
 405     RowData::Pointer_t const & getRow(unsigned int i) const
 406     {
 407         return mRows[i];
 408     }
 409
 410     const RowData::Pointer_t& getCurrentRow() const
 411     {
 412         return mpRow;
 413     }
 414 };
 415
 416 }
 417
 418
 419 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */