writerfilter/inc/resourcemodel/TableData.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: TableData.hxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef INCLUDED_TABLE_DATA
  32 #define INCLUDED_TABLE_DATA
  33
  34 #ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX
  35 #include <resourcemodel/WW8ResourceModel.hxx>
  36 #endif
  37
  38 #include <vector>
  39 #include <boost/shared_ptr.hpp>
  40
  41 namespace writerfilter
  42 {
  43
  44 template <typename T, typename PropertiesPointer>
  45 /**
  46    Class containing the data to describe a table cell.
  47  */
  48 class WRITERFILTER_DLLPUBLIC CellData
  49 {
  50     /**
  51        Handle to start of cell.
  52     */
  53     T mStart;
  54
  55     /**
  56        Handle to end of cell.
  57     */
  58     T mEnd;
  59
  60     /**
  61        Pointer to properties of cell.
  62     */
  63     PropertiesPointer mpProps;
  64
  65     bool mbOpen;
  66
  67 public:
  68     typedef boost::shared_ptr<CellData> Pointer_t;
  69
  70     CellData(T start, PropertiesPointer pProps)
  71     : mStart(start), mEnd(start), mpProps(pProps), mbOpen(true)
  72     {
  73     }
  74
  75     virtual ~CellData() {}
  76
  77     /**
  78        Set the start handle of the cell.
  79
  80        @param start    the start handle of the cell
  81     */
  82     void setStart(T start) { mStart = start; }
  83
  84     /**
  85        Set the end handle of a cell.
  86
  87        @param end     the end handle of the cell
  88     */
  89     void setEnd(T end) { mEnd = end; mbOpen = false; }
  90
  91     /**
  92        Set the properties of the cell.
  93
  94        @param pProps      the properties of the cell
  95     */
  96     void setProperties(PropertiesPointer pProps) { mpProps = pProps; }
  97
  98     /**
  99        Adds properties to the cell.
 100
 101        @param pProps      the properties to add
 102      */
 103     void insertProperties(PropertiesPointer pProps)
 104     {
 105         if( mpProps.get() )
 106             mpProps->insert(pProps);
 107         else
 108             mpProps = pProps;
 109     }
 110
 111     /**
 112        Return start handle of the cell.
 113      */
 114     const T & getStart() { return mStart; }
 115
 116     /**
 117        Return end handle of the cell.
 118     */
 119     const T & getEnd() { return mEnd; }
 120
 121     /**
 122        Return properties of the cell.
 123      */
 124     PropertiesPointer getProperties() { return mpProps; }
 125
 126     bool isOpen() const { return mbOpen; }
 127 };
 128
 129 template <typename T, typename PropertiesPointer>
 130 /**
 131    Class to handle data of a table row.
 132  */
 133 class WRITERFILTER_DLLPUBLIC RowData
 134 {
 135     typedef typename CellData<T, PropertiesPointer>::Pointer_t
 136         CellDataPointer_t;
 137     typedef ::std::vector<CellDataPointer_t> Cells;
 138
 139     /**
 140        the cell data of the row
 141      */
 142     Cells mCells;
 143
 144     /**
 145        the properties of the row
 146     */
 147     mutable PropertiesPointer mpProperties;
 148
 149 public:
 150     typedef boost::shared_ptr<RowData <T, PropertiesPointer> > Pointer_t;
 151
 152     RowData() {}
 153
 154     RowData(const RowData<T, PropertiesPointer> & rRowData)
 155     : mCells(rRowData.mCells), mpProperties(rRowData.mpProperties)
 156     {
 157     }
 158
 159     virtual ~RowData() {}
 160
 161     /**
 162        Add a cell to the row.
 163
 164        @param start     the start handle of the cell
 165        @param end       the end handle of the cell
 166        @param pProps    the properties of the cell
 167      */
 168     void addCell(const T & start, PropertiesPointer pProps)
 169     {
 170         CellDataPointer_t pCellData
 171             (new CellData<T, PropertiesPointer>(start, pProps));
 172         mCells.push_back(pCellData);
 173     }
 174
 175     void endCell(const T & end)
 176     {
 177         if (mCells.size() > 0)
 178             mCells.back()->setEnd(end);
 179     }
 180
 181     bool isCellOpen() const
 182     {
 183         return mCells.size() > 0 && mCells.back()->isOpen();
 184     }
 185
 186     /**
 187        Add properties to the row.
 188
 189        @param pProperties   the properties to set
 190      */
 191     void insertProperties(PropertiesPointer pProperties)
 192     {
 193         if( pProperties.get() )
 194         {
 195             if( !mpProperties.get() )
 196                 mpProperties = pProperties;
 197             else
 198                 mpProperties->insert( pProperties );
 199         }
 200     }
 201
 202     /**
 203        Add properties to a cell of the row.
 204
 205        @param i          index of the cell
 206        @param pProps     the properties to add
 207      */
 208     void insertCellProperties(unsigned int i, PropertiesPointer pProps)
 209     {
 210         mCells[i]->insertProperties(pProps);
 211     }
 212
 213     /**
 214        Return number of cells in the row.
 215     */
 216     unsigned int getCellCount()
 217     {
 218         return mCells.size();
 219     }
 220
 221     /**
 222        Return start handle of a cell in the row.
 223
 224        @param i      index of the cell
 225      */
 226     const T & getCellStart(unsigned int i) const
 227     {
 228         return mCells[i]->getStart();
 229     }
 230
 231     /**
 232         Return end handle of a cell in the row.
 233
 234         @param i     index of the cell
 235     */
 236     const T & getCellEnd(unsigned int i) const
 237     {
 238         return mCells[i]->getEnd();
 239     }
 240
 241     /**
 242        Return the properties of a cell in the row.
 243
 244        @param i      index of the cell
 245      */
 246     PropertiesPointer getCellProperties(unsigned int i) const
 247     {
 248         return mCells[i]->getProperties();
 249     }
 250
 251     /**
 252        Return properties of the row.
 253      */
 254     PropertiesPointer getProperties()
 255     {
 256         return mpProperties;
 257     }
 258
 259     /**
 260        Clear the row data.
 261      */
 262     void clear()
 263     {
 264         mCells.clear();
 265         mpProperties.reset();
 266     }
 267 };
 268
 269 template <typename T, typename PropertiesPointer>
 270 /**
 271    Class that holds the data of a table.
 272  */
 273 class WRITERFILTER_DLLPUBLIC TableData
 274 {
 275     typedef typename RowData<T, PropertiesPointer>::Pointer_t RowPointer_t;
 276     typedef ::std::vector<RowPointer_t> Rows;
 277
 278     /**
 279        the table properties
 280      */
 281     PropertiesPointer mpTableProps;
 282
 283     /**
 284        the data of the rows of the table
 285     */
 286     Rows mRows;
 287
 288     /**
 289         pointer to the data of the current row (while building up the table data).
 290     */
 291     RowPointer_t mpRow;
 292
 293     /**
 294        depth of the current table in a hierarchy of tables
 295      */
 296     unsigned int mnDepth;
 297
 298     /**
 299        initialize mpRow
 300      */
 301     void newRow() { mpRow = RowPointer_t(new RowData<T, PropertiesPointer>()); }
 302
 303 public:
 304     typedef boost::shared_ptr<TableData <T, PropertiesPointer> > Pointer_t;
 305
 306     TableData(unsigned int nDepth) : mnDepth(nDepth) { newRow(); }
 307     ~TableData() {}
 308
 309     /**
 310        End the current row.
 311
 312        Sets properties of the current row and pushes the row to the
 313        back of the rows currently contained in the table.
 314
 315        @param pProperties    properties of the row to be ended
 316      */
 317     void endRow(PropertiesPointer pProperties)
 318     {
 319         mpRow->insertProperties(pProperties);
 320         mRows.push_back(mpRow);
 321         newRow();
 322     }
 323
 324     /**
 325        Add a cell to the current row.
 326
 327        @param start   start handle of the cell
 328        @param end     end handle of the cell
 329        @param pProps  properties of the cell
 330      */
 331     void addCell(const T & start, PropertiesPointer pProps)
 332     {
 333         mpRow->addCell(start, pProps);
 334     }
 335
 336     void endCell(const T & end)
 337     {
 338         mpRow->endCell(end);
 339     }
 340
 341     bool isCellOpen() const
 342     {
 343         return mpRow->isCellOpen();
 344     }
 345
 346     /**
 347        Add properties to a cell of the current row.
 348
 349        @param i       index of the cell
 350        @param pProps  properties to add
 351      */
 352     void insertCellProperties(unsigned int i, PropertiesPointer pProps)
 353     {
 354         mpRow->insertCellProperties(i, pProps);
 355     }
 356
 357     void insertTableProperties( PropertiesPointer pProps )
 358     {
 359         if ( mpTableProps.get( ) )
 360             mpTableProps->insert( pProps );
 361         else
 362             mpTableProps = pProps;
 363     }
 364
 365     /**
 366       Return the table properties.
 367      */
 368     PropertiesPointer getTableProperties( )
 369     {
 370         return mpTableProps;
 371     }
 372
 373     /**
 374        Return number of rows in the table.
 375      */
 376     unsigned int getRowCount()
 377     {
 378         return mRows.size();
 379     }
 380
 381     /**
 382        Return depth of table in surrounding table hierarchy.
 383     */
 384     unsigned int getDepth()
 385     {
 386         return mnDepth;
 387     }
 388
 389     /**
 390        Return row data of a certain row.
 391
 392        @param i     index of the row
 393     */
 394     const RowPointer_t getRow(unsigned int i) const
 395     {
 396         return mRows[i];
 397     }
 398 };
 399
 400 }
 401
 402 #endif // INCLUDED_TABLE_DATA