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 #ifndef INCLUDED_WRITERFILTER_SOURCE_DMAPPER_TABLEDATA_HXX
  21 #define INCLUDED_WRITERFILTER_SOURCE_DMAPPER_TABLEDATA_HXX
  22
  23 #include <dmapper/resourcemodel.hxx>
  24
  25 #include <vector>
  26 #include <memory>
  27
  28 namespace writerfilter
  29 {
  30 namespace dmapper
  31 {
  32
  33 /**
  34    Class containing the data to describe a table cell.
  35  */
  36 class CellData final : public virtual SvRefBase
  37 {
  38     /**
  39        Handle to start of cell.
  40     */
  41     css::uno::Reference<css::text::XTextRange> mStart;
  42
  43     /**
  44        Handle to end of cell.
  45     */
  46     css::uno::Reference<css::text::XTextRange> mEnd;
  47
  48     /**
  49        Pointer to properties of cell.
  50     */
  51     TablePropertyMapPtr mpProps;
  52
  53     bool mbOpen;
  54
  55 public:
  56     typedef tools::SvRef<CellData> Pointer_t;
  57
  58     CellData(css::uno::Reference<css::text::XTextRange> const & start, TablePropertyMapPtr pProps)
  59     : mStart(start), mEnd(start), mpProps(pProps), mbOpen(true)
  60     {
  61     }
  62
  63     /**
  64        Set the end handle of a cell.
  65
  66        @param end     the end handle of the cell
  67     */
  68     void setEnd(css::uno::Reference<css::text::XTextRange> const & end) { mEnd = end; mbOpen = false; }
  69
  70     /**
  71        Adds properties to the cell.
  72
  73        @param pProps      the properties to add
  74      */
  75     void insertProperties(TablePropertyMapPtr pProps)
  76     {
  77         if( mpProps.get() )
  78             mpProps->InsertProps(pProps.get());
  79         else
  80             mpProps = pProps;
  81     }
  82
  83     /**
  84        Return start handle of the cell.
  85      */
  86     const css::uno::Reference<css::text::XTextRange>& getStart() { return mStart; }
  87
  88     /**
  89        Return end handle of the cell.
  90     */
  91     const css::uno::Reference<css::text::XTextRange>& getEnd() { return mEnd; }
  92
  93     /**
  94        Return properties of the cell.
  95      */
  96     const TablePropertyMapPtr& getProperties() { return mpProps; }
  97
  98     bool isOpen() const { return mbOpen; }
  99 };
 100
 101 /**
 102    Class to handle data of a table row.
 103  */
 104 class RowData final : public virtual SvRefBase
 105 {
 106     typedef ::std::vector<CellData::Pointer_t> Cells;
 107
 108     /**
 109        the cell data of the row
 110      */
 111     Cells mCells;
 112
 113     /**
 114        the properties of the row
 115     */
 116     mutable TablePropertyMapPtr mpProperties;
 117
 118 public:
 119     typedef tools::SvRef<RowData> Pointer_t;
 120
 121     RowData() {}
 122
 123     RowData(const RowData& rRowData)
 124     : SvRefBase(), mCells(rRowData.mCells), mpProperties(rRowData.mpProperties)
 125     {
 126     }
 127
 128     /**
 129        Add a cell to the row.
 130
 131        @param start     the start handle of the cell
 132        @param end       the end handle of the cell
 133        @param pProps    the properties of the cell
 134      */
 135     void addCell(const css::uno::Reference<css::text::XTextRange>& start, TablePropertyMapPtr pProps)
 136     {
 137         CellData::Pointer_t pCellData(new CellData(start, pProps));
 138         mCells.push_back(pCellData);
 139     }
 140
 141     void endCell(const css::uno::Reference<css::text::XTextRange>& end)
 142     {
 143         if (mCells.size() > 0)
 144             mCells.back()->setEnd(end);
 145     }
 146
 147     bool isCellOpen() const
 148     {
 149         return mCells.size() > 0 && mCells.back()->isOpen();
 150     }
 151
 152     /**
 153        Add properties to the row.
 154
 155        @param pProperties   the properties to set
 156      */
 157     void insertProperties(TablePropertyMapPtr pProperties)
 158     {
 159         if( pProperties.get() )
 160         {
 161             if( !mpProperties.get() )
 162                 mpProperties = pProperties;
 163             else
 164                 mpProperties->InsertProps(pProperties.get());
 165         }
 166     }
 167
 168     /**
 169         Add properties to the last cell of the row.
 170      */
 171     void insertCellProperties(TablePropertyMapPtr pProps)
 172     {
 173         if (!mCells.empty())
 174             mCells.back()->insertProperties(pProps);
 175     }
 176
 177     /**
 178        Return number of cells in the row.
 179     */
 180     unsigned int getCellCount()
 181     {
 182         return mCells.size();
 183     }
 184
 185     /**
 186        Return start handle of a cell in the row.
 187
 188        @param i      index of the cell
 189      */
 190     const css::uno::Reference<css::text::XTextRange>& getCellStart(unsigned int i) const
 191     {
 192         return mCells[i]->getStart();
 193     }
 194
 195     /**
 196         Return end handle of a cell in the row.
 197
 198         @param i     index of the cell
 199     */
 200     const css::uno::Reference<css::text::XTextRange>& getCellEnd(unsigned int i) const
 201     {
 202         return mCells[i]->getEnd();
 203     }
 204
 205     /**
 206        Return the properties of a cell in the row.
 207
 208        @param i      index of the cell
 209      */
 210     TablePropertyMapPtr const & getCellProperties(unsigned int i) const
 211     {
 212         return mCells[i]->getProperties();
 213     }
 214
 215     /**
 216        Return properties of the row.
 217      */
 218     const TablePropertyMapPtr& getProperties()
 219     {
 220         return mpProperties;
 221     }
 222 };
 223
 224 /**
 225    Class that holds the data of a table.
 226  */
 227 class TableData : public virtual SvRefBase
 228 {
 229     typedef RowData::Pointer_t RowPointer_t;
 230     typedef ::std::vector<RowPointer_t> Rows;
 231
 232     /**
 233        the data of the rows of the table
 234     */
 235     Rows mRows;
 236
 237     /**
 238         pointer to the data of the current row (while building up the table data).
 239     */
 240     RowPointer_t mpRow;
 241
 242     /**
 243        depth of the current table in a hierarchy of tables
 244      */
 245     unsigned int const mnDepth;
 246
 247     /**
 248        initialize mpRow
 249      */
 250     void newRow() { mpRow = RowPointer_t(new RowData()); }
 251
 252 public:
 253     typedef tools::SvRef<TableData> Pointer_t;
 254
 255     explicit TableData(unsigned int nDepth) : mnDepth(nDepth) { newRow(); }
 256
 257     /**
 258        End the current row.
 259
 260        Sets properties of the current row and pushes the row to the
 261        back of the rows currently contained in the table.
 262
 263        @param pProperties    properties of the row to be ended
 264      */
 265     void endRow(TablePropertyMapPtr pProperties)
 266     {
 267         mpRow->insertProperties(pProperties);
 268         mRows.push_back(mpRow);
 269         newRow();
 270     }
 271
 272     /**
 273        Add a cell to the current row.
 274
 275        @param start   start handle of the cell
 276        @param end     end handle of the cell
 277        @param pProps  properties of the cell
 278      */
 279     void addCell(const css::uno::Reference<css::text::XTextRange>& start, TablePropertyMapPtr pProps)
 280     {
 281         mpRow->addCell(start, pProps);
 282     }
 283
 284     /**
 285         End the current cell of the current row.
 286
 287         @parm end    end handle of the cell
 288      */
 289     void endCell(const css::uno::Reference<css::text::XTextRange>& end)
 290     {
 291         mpRow->endCell(end);
 292     }
 293
 294     /**
 295         Return if the current cell of the current row is open.
 296      */
 297     bool isCellOpen() const
 298     {
 299         return mpRow->isCellOpen();
 300     }
 301
 302     /**
 303         Insert properties to the current cell of the current row.
 304
 305         @param pProps   the properties to add
 306      */
 307     void insertCellProperties(TablePropertyMapPtr pProps)
 308     {
 309         mpRow->insertCellProperties(pProps);
 310     }
 311
 312     /**
 313        Return number of rows in the table.
 314      */
 315     unsigned int getRowCount()
 316     {
 317         return mRows.size();
 318     }
 319
 320     /**
 321        Return depth of table in surrounding table hierarchy.
 322     */
 323     unsigned int getDepth()
 324     {
 325         return mnDepth;
 326     }
 327
 328     /**
 329        Return row data of a certain row.
 330
 331        @param i     index of the row
 332     */
 333     RowPointer_t const & getRow(unsigned int i) const
 334     {
 335         return mRows[i];
 336     }
 337
 338     const RowPointer_t& getCurrentRow() const
 339     {
 340         return mpRow;
 341     }
 342 };
 343
 344 }
 345 }
 346
 347 #endif // INCLUDED_WRITERFILTER_SOURCE_DMAPPER_RESOURCEMODEL_TABLEDATA_HXX
 348
 349 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */