writerfilter/source/dmapper/TableManager.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 <memory>
  23 #include <stack>
  24
  25 #include "PropertyMap.hxx"
  26 #include "TableData.hxx"
  27
  28 #include <dmapper/resourcemodel.hxx>
  29
  30 namespace writerfilter::dmapper
  31 {
  32
  33 class DomainMapperTableHandler;
  34
  35 /**
  36    The table manager.
  37
  38    This class gets forwarded events from the tokenizer. It gathers the
  39    table data and after ending the table generates events for the
  40    table structure. The events have to be handles by a TableDataHandler.
  41
  42  */
  43 class TableManager : public virtual SvRefBase
  44 {
  45     class TableManagerState final
  46     {
  47         /**
  48          properties of the current cell
  49          */
  50         TablePropertyMapPtr mpCellProps;
  51
  52         /**
  53          properties of the current row
  54          */
  55         TablePropertyMapPtr mpRowProps;
  56
  57         /**
  58          table exception properties of the current row
  59          */
  60         TablePropertyMapPtr mpTableExceptionProps;
  61
  62         /**
  63          properties of the current table
  64          */
  65         std::stack<TablePropertyMapPtr> mTableProps;
  66
  67         /**
  68          true if at the end of a row
  69          */
  70         bool mbRowEnd;
  71
  72         /**
  73          true when in a cell
  74          */
  75         bool mbInCell;
  76
  77         /**
  78          true when at the end of a cell
  79          */
  80         bool mbCellEnd;
  81
  82     public:
  83         /**
  84          Constructor
  85          */
  86         TableManagerState()
  87         : mbRowEnd(false), mbInCell(false), mbCellEnd(false)
  88         {
  89         }
  90
  91         void startLevel()
  92         {
  93             TablePropertyMapPtr pProps;
  94             mTableProps.push(pProps);
  95         }
  96
  97         void endLevel()
  98         {
  99             mTableProps.pop();
 100         }
 101
 102         /**
 103          Reset to initial state at beginning of row.
 104          */
 105         void resetCellSpecifics()
 106         {
 107             mbRowEnd = false;
 108             mbInCell = false;
 109             mbCellEnd = false;
 110         }
 111
 112         void resetCellProps()
 113         {
 114             // copy tblPrEx table exception properties, if they exist
 115             if (getTableExceptionProps().is())
 116             {
 117                 mpCellProps = new TablePropertyMap;
 118                 mpCellProps->InsertProps(getTableExceptionProps().get());
 119             }
 120             else
 121                 mpCellProps.clear();
 122         }
 123
 124         void setCellProps(const TablePropertyMapPtr& pProps)
 125         {
 126             mpCellProps = pProps;
 127         }
 128
 129         const TablePropertyMapPtr& getCellProps() const
 130         {
 131             return mpCellProps;
 132         }
 133
 134         void resetRowProps()
 135         {
 136             // reset also table exception and
 137             // its copy set by the previous resetCellProps()
 138             mpTableExceptionProps.clear();
 139             resetCellProps();
 140             mpRowProps.clear();
 141         }
 142
 143         void setRowProps(TablePropertyMapPtr pProps)
 144         {
 145             mpRowProps = pProps;
 146         }
 147
 148         const TablePropertyMapPtr& getRowProps() const
 149         {
 150             return mpRowProps;
 151         }
 152
 153         void setTableExceptionProps(const TablePropertyMapPtr& pProps)
 154         {
 155             mpTableExceptionProps = pProps;
 156             // set table exception properties of the first cell
 157             resetCellProps();
 158         }
 159
 160         const TablePropertyMapPtr& getTableExceptionProps() const
 161         {
 162             return mpTableExceptionProps;
 163         }
 164
 165         void resetTableProps()
 166         {
 167             if (mTableProps.size() > 0)
 168                 mTableProps.top().clear();
 169         }
 170
 171         void setTableProps(TablePropertyMapPtr pProps)
 172         {
 173             if (mTableProps.size() > 0)
 174                 mTableProps.top() = pProps;
 175         }
 176
 177         TablePropertyMapPtr getTableProps()
 178         {
 179             TablePropertyMapPtr pResult;
 180
 181             if (mTableProps.size() > 0)
 182                 pResult = mTableProps.top();
 183
 184             return pResult;
 185         }
 186
 187         void setInCell(bool bInCell)
 188         {
 189             mbInCell = bInCell;
 190         }
 191
 192         bool isInCell() const
 193         {
 194             return mbInCell;
 195         }
 196
 197         void setCellEnd(bool bCellEnd)
 198         {
 199             mbCellEnd = bCellEnd;
 200         }
 201
 202         bool isCellEnd() const
 203         {
 204             return mbCellEnd;
 205         }
 206
 207         void setRowEnd(bool bRowEnd)
 208         {
 209             mbRowEnd = bRowEnd;
 210         }
 211
 212         bool isRowEnd() const
 213         {
 214             return mbRowEnd;
 215         }
 216     };
 217
 218     /**
 219      handle for the current position in document
 220      */
 221     css::uno::Reference<css::text::XTextRange> mCurHandle;
 222
 223     TableManagerState mState;
 224
 225 protected:
 226     TablePropertyMapPtr const & getCellProps() const
 227     {
 228         return mState.getCellProps();
 229     }
 230
 231 public:
 232     TablePropertyMapPtr const & getRowProps() const
 233     {
 234         return mState.getRowProps();
 235     }
 236
 237     TablePropertyMapPtr const & getTableExceptionProps() const
 238     {
 239         return mState.getTableExceptionProps();
 240     }
 241
 242 protected:
 243     void setInCell(bool bInCell)
 244     {
 245         mState.setInCell(bInCell);
 246     }
 247
 248     bool isInCell() const
 249     {
 250         return mState.isInCell();
 251     }
 252
 253     void setCellEnd(bool bCellEnd)
 254     {
 255         mState.setCellEnd(bCellEnd);
 256     }
 257
 258     void setRowEnd(bool bRowEnd)
 259     {
 260         mState.setRowEnd(bRowEnd);
 261     }
 262
 263     bool isRowEnd() const
 264     {
 265         return mState.isRowEnd();
 266     }
 267
 268     TablePropertyMapPtr getTableProps()
 269     {
 270         return mState.getTableProps();
 271     }
 272
 273     const css::uno::Reference<css::text::XTextRange>& getHandle() const
 274     {
 275         return mCurHandle;
 276     }
 277
 278     void setHandle(const css::uno::Reference<css::text::XTextRange>& rHandle)
 279     {
 280         mCurHandle = rHandle;
 281     }
 282
 283 private:
 284     typedef tools::SvRef< css::uno::Reference<css::text::XTextRange> > T_p;
 285
 286     /**
 287        depth of the current cell
 288     */
 289     sal_uInt32 mnTableDepthNew;
 290
 291     /**
 292         depth of the previous cell
 293     */
 294     sal_uInt32 mnTableDepth;
 295
 296     /**
 297        stack of table data
 298
 299        for each level of nested tables there is one frame in the stack
 300      */
 301     std::vector<TableData::Pointer_t> mTableDataStack;
 302     RowData::Pointer_t mpUnfinishedRow;
 303     bool mbKeepUnfinishedRow;
 304
 305     bool m_bCellLastParaAfterAutospacing;
 306
 307     /**
 308        handler for resolveCurrentTable
 309      */
 310     tools::SvRef<DomainMapperTableHandler> mpTableDataHandler;
 311
 312     /**
 313        Set flag which indicates the current handle is in a cell.
 314      */
 315     void inCell();
 316
 317     /**
 318        Set flag which indicate the current handle is at the end of a cell.
 319     */
 320     void endCell();
 321
 322     /**
 323        Set the table depth of the current cell.
 324
 325        @param nDepth     the cell depth
 326      */
 327     void cellDepth(sal_uInt32 nDepth);
 328
 329     /**
 330        Set flag indication the current handle is at the end of a row.
 331     */
 332     void endRow();
 333
 334     /**
 335        Resolve the current table to the TableDataHandler.
 336      */
 337     void resolveCurrentTable();
 338
 339     /**
 340      Open a cell at current level.
 341      */
 342
 343     void openCell(const css::uno::Reference<css::text::XTextRange>& rHandle, const TablePropertyMapPtr& pProps);
 344
 345     /**
 346      Close a cell at current level.
 347      */
 348     void closeCell(const css::uno::Reference<css::text::XTextRange>& rHandle);
 349
 350     /**
 351      Ensure a cell is open at the current level.
 352     */
 353     void ensureOpenCell(const TablePropertyMapPtr& pProps);
 354
 355 protected:
 356     /**
 357        Return the current table difference, i.e. 1 if we are in the first cell of a new table, etc.
 358      */
 359     sal_Int32 getTableDepthDifference() const { return mnTableDepthNew - mnTableDepth; }
 360
 361     sal_uInt32 getTableDepth() const { return mnTableDepthNew; }
 362
 363     /**
 364        Action to be carried out at the end of the last paragraph of a
 365        cell.
 366      */
 367     virtual void endOfCellAction();
 368
 369     /**
 370        Action to be carried out at the end of the "table row"
 371        paragraph.
 372      */
 373     virtual void endOfRowAction();
 374     /** let the derived class clear their table related data
 375      */
 376     virtual void clearData();
 377
 378     /** Should we keep the unfinished row in endLevel to initialize the table
 379         data in the following startLevel.
 380       */
 381     void setKeepUnfinishedRow(bool bKeep)
 382     {
 383         mbKeepUnfinishedRow = bKeep;
 384     }
 385
 386
 387 public:
 388     TableManager();
 389     ~TableManager();
 390
 391     /**
 392        Set handler for resolveCurrentTable.
 393
 394        @param pTableDataHandler     the handler
 395      */
 396     void setHandler(const tools::SvRef<DomainMapperTableHandler>& pTableDataHandler);
 397
 398     /**
 399        Set the current handle.
 400
 401        @param rHandle     the handle
 402      */
 403     void handle(const css::uno::Reference<css::text::XTextRange>& rHandle);
 404
 405     /**
 406        Start a new table level.
 407
 408        A new context is pushed onto the table data stack,
 409      */
 410     virtual void startLevel();
 411
 412     /**
 413        End a table level.
 414
 415        The current table is resolved and the context is popped from
 416        the stack.
 417      */
 418     virtual void endLevel();
 419
 420     /**
 421      * Signal that the next paragraph definitely won't be part of any table.
 422      */
 423     void endTable()
 424     {
 425         setRowEnd(false);
 426     }
 427
 428     /**
 429        Tells whether a table has been started or not
 430       */
 431     bool isInTable();
 432
 433     /**
 434        Handle the start of a paragraph group.
 435      */
 436     void startParagraphGroup();
 437
 438     /**
 439        Handle the end of a paragraph group.
 440     */
 441     void endParagraphGroup();
 442
 443     /**
 444        Handle an SPRM at current handle.
 445
 446        @param rSprm   the SPRM
 447      */
 448     virtual bool sprm(Sprm & rSprm);
 449
 450     /**
 451        Handle occurrence of character 0x7.
 452      */
 453     void handle0x7();
 454
 455     /**
 456        Handle 8 bit text at current handle.
 457
 458        @param data    array of characters
 459        @param len     number of characters to handle
 460      */
 461     void text(const sal_uInt8 * data, size_t len);
 462
 463     /**
 464        Handle 16 bit text at current handle.
 465
 466        @param data    array of characters
 467        @param len     number of characters to handle
 468      */
 469     void utext(const sal_Unicode * data, size_t len);
 470
 471     /**
 472        Handle properties of the current cell.
 473
 474        @param pProps   the properties
 475      */
 476     virtual void cellProps(const TablePropertyMapPtr& pProps);
 477
 478     /**
 479        Handle properties of the current row.
 480
 481        @param pProps   the properties
 482      */
 483     virtual void insertRowProps(const TablePropertyMapPtr& pProps);
 484
 485     /**
 486        Handle table exception properties of the current row.
 487
 488        @param pProps   the properties
 489      */
 490     virtual void tableExceptionProps(const TablePropertyMapPtr& pProps);
 491
 492     /**
 493        Handle properties of the current table.
 494
 495        @param pProps   the properties
 496      */
 497     virtual void insertTableProps(const TablePropertyMapPtr& pProps);
 498
 499     /**
 500        Return if table manager has detected paragraph to ignore.
 501
 502        If this function returns true the current paragraph contains
 503        only control information, e.g. end of row.
 504      */
 505     bool isIgnore() const;
 506
 507     sal_uInt32 getGridBefore(sal_uInt32 nRow);
 508     sal_uInt32 getCurrentGridBefore();
 509     void setCurrentGridBefore( sal_uInt32 nSkipGrids );
 510     sal_uInt32 getGridAfter(sal_uInt32 nRow);
 511     void setCurrentGridAfter( sal_uInt32 nSkipGrids );
 512     std::vector<sal_uInt32> getCurrentGridSpans();
 513     void setCurrentGridSpan( sal_uInt32 nGridSpan, bool bFirstCell = false );
 514     /// Given a zero-based row/cell, return the zero-based grid it belongs to, or SAL_MAX_UINT16 for invalid.
 515     sal_uInt32 findColumn( const sal_uInt32 nRow, const sal_uInt32 nCell );
 516     /// Given a zero-based row/col, return the zero-based cell describing that grid, or SAL_MAX_UINT16 for invalid.
 517     sal_uInt32 findColumnCell( const sal_uInt32 nRow, const sal_uInt32 nCol );
 518
 519     void setCellLastParaAfterAutospacing(bool bIsAfterAutospacing);
 520     bool isCellLastParaAfterAutospacing() const {return m_bCellLastParaAfterAutospacing;}
 521 };
 522
 523 }
 524
 525
 526
 527 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */