sc/source/filter/oox/sheetdatacontext.cxx

   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 #include <sheetdatacontext.hxx>
  21
  22 #include <oox/core/xmlfilterbase.hxx>
  23 #include <oox/helper/attributelist.hxx>
  24 #include <oox/helper/binaryinputstream.hxx>
  25 #include <oox/token/namespaces.hxx>
  26 #include <oox/token/tokens.hxx>
  27 #include <addressconverter.hxx>
  28 #include <biffhelper.hxx>
  29 #include <formulaparser.hxx>
  30 #include <richstringcontext.hxx>
  31 #include <sal/log.hxx>
  32 #include <o3tl/string_view.hxx>
  33
  34 namespace oox::xls {
  35
  36 using ::oox::core::ContextHandlerRef;
  37
  38 namespace {
  39
  40 // record constants -----------------------------------------------------------
  41
  42 const sal_uInt32 BIFF12_CELL_SHOWPHONETIC   = 0x01000000;
  43
  44 const sal_uInt8 BIFF12_DATATABLE_ROW        = 0x01;
  45 const sal_uInt8 BIFF12_DATATABLE_2D         = 0x02;
  46 const sal_uInt8 BIFF12_DATATABLE_REF1DEL    = 0x04;
  47 const sal_uInt8 BIFF12_DATATABLE_REF2DEL    = 0x08;
  48
  49 const sal_uInt16 BIFF12_ROW_THICKTOP        = 0x0001;
  50 const sal_uInt16 BIFF12_ROW_THICKBOTTOM     = 0x0002;
  51 const sal_uInt16 BIFF12_ROW_COLLAPSED       = 0x0800;
  52 const sal_uInt16 BIFF12_ROW_HIDDEN          = 0x1000;
  53 const sal_uInt16 BIFF12_ROW_CUSTOMHEIGHT    = 0x2000;
  54 const sal_uInt16 BIFF12_ROW_CUSTOMFORMAT    = 0x4000;
  55 const sal_uInt8 BIFF12_ROW_SHOWPHONETIC     = 0x01;
  56
  57 } // namespace
  58
  59 SheetDataContext::SheetDataContext( WorksheetFragmentBase& rFragment ) :
  60     WorksheetContextBase( rFragment ),
  61     mrAddressConv( rFragment.getAddressConverter() ),
  62     mrSheetData( rFragment.getSheetData() ),
  63     mnSheet( rFragment.getSheetIndex() ),
  64     mbHasFormula( false ),
  65     mbValidRange( false ),
  66     mnRow( -1 ),
  67     mnCol( -1 )
  68 {
  69     SAL_INFO( "sc.filter",  "start safe sheet data context - unlock" );
  70     mxFormulaParser.reset(rFragment.createFormulaParser());
  71 }
  72
  73 SheetDataContext::~SheetDataContext()
  74 {
  75     SAL_INFO( "sc.filter",  "end safe sheet data context - relock" );
  76 }
  77
  78 ContextHandlerRef SheetDataContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
  79 {
  80     switch( getCurrentElement() )
  81     {
  82         case XLS_TOKEN( sheetData ):
  83             if( nElement == XLS_TOKEN( row ) ) { importRow( rAttribs ); return this; }
  84         break;
  85
  86         case XLS_TOKEN( row ):
  87             // do not process cell elements with invalid (out-of-range) address
  88             if( nElement == XLS_TOKEN( c ) && importCell( rAttribs ) )
  89                 return this;
  90         break;
  91
  92         case XLS_TOKEN( c ):
  93             switch( nElement )
  94             {
  95                 case XLS_TOKEN( is ):
  96                     mxInlineStr = std::make_shared<RichString>();
  97                     return new RichStringContext( *this, mxInlineStr );
  98                 case XLS_TOKEN( v ):
  99                     return this;    // characters contain cell value
 100                 case XLS_TOKEN( f ):
 101                     importFormula( rAttribs );
 102                     return this;    // characters contain formula string
 103             }
 104         break;
 105     }
 106     return nullptr;
 107 }
 108
 109 void SheetDataContext::onCharacters( const OUString& rChars )
 110 {
 111     switch( getCurrentElement() )
 112     {
 113         case XLS_TOKEN( v ):
 114             maCellValue = rChars;
 115         break;
 116         case XLS_TOKEN( f ):
 117             if( maFmlaData.mnFormulaType != XML_TOKEN_INVALID )
 118             {
 119                 maFormulaStr = rChars;
 120             }
 121         break;
 122     }
 123 }
 124
 125 void SheetDataContext::onEndElement()
 126 {
 127     if( getCurrentElement() != XLS_TOKEN( c ) )
 128         return;
 129
 130     // try to create a formula cell
 131     if( mbHasFormula ) switch( maFmlaData.mnFormulaType )
 132     {
 133         // will buffer formulas but need to
 134         // a) need to set format first
 135         // :/
 136         case XML_normal:
 137             setCellFormula( maCellData.maCellAddr, maFormulaStr );
 138             mrSheetData.setCellFormat( maCellData );
 139
 140             // If a number cell has some preloaded value, stick it into the buffer
 141             // but do this only for real cell formulas (not array, shared etc.)
 142             if (!maCellValue.isEmpty())
 143                 setCellFormulaValue(maCellData.maCellAddr, maCellValue, maCellData.mnCellType);
 144             break;
 145
 146         case XML_shared:
 147             if( maFmlaData.mnSharedId >= 0 )
 148             {
 149                 if( mbValidRange && maFmlaData.isValidSharedRef( maCellData.maCellAddr ) )
 150                     createSharedFormulaMapEntry(maCellData.maCellAddr, maFmlaData.mnSharedId, maFormulaStr);
 151
 152                 setCellFormula(maCellData.maCellAddr, maFmlaData.mnSharedId, maCellValue, maCellData.mnCellType);
 153                 mrSheetData.setCellFormat( maCellData );
 154             }
 155             else
 156                 // no success, set plain cell value and formatting below
 157                 mbHasFormula = false;
 158         break;
 159         case XML_array:
 160             if( mbValidRange && maFmlaData.isValidArrayRef( maCellData.maCellAddr ) )
 161             {
 162                 setCellArrayFormula( maFmlaData.maFormulaRef, maCellData.maCellAddr, maFormulaStr );
 163             }
 164             // set cell formatting, but do not set result as cell value
 165             mrSheetData.setBlankCell( maCellData );
 166         break;
 167         case XML_dataTable:
 168             if( mbValidRange )
 169                 mrSheetData.createTableOperation( maFmlaData.maFormulaRef, maTableData );
 170             // set cell formatting, but do not set result as cell value
 171             mrSheetData.setBlankCell( maCellData );
 172         break;
 173         default:
 174             OSL_ENSURE( maFmlaData.mnFormulaType == XML_TOKEN_INVALID, "SheetDataContext::onEndElement - unknown formula type" );
 175             mbHasFormula = false;
 176     }
 177
 178     if( mbHasFormula )
 179         return;
 180
 181     // no formula created: try to set the cell value
 182     if( !maCellValue.isEmpty() ) switch( maCellData.mnCellType )
 183     {
 184         case XML_n:
 185             mrSheetData.setValueCell( maCellData, maCellValue.toDouble() );
 186         break;
 187         case XML_b:
 188             mrSheetData.setBooleanCell( maCellData, maCellValue.toDouble() != 0.0 );
 189         break;
 190         case XML_e:
 191             mrSheetData.setErrorCell( maCellData, maCellValue );
 192         break;
 193         case XML_str:
 194             mrSheetData.setStringCell( maCellData, maCellValue );
 195         break;
 196         case XML_s:
 197             mrSheetData.setStringCell( maCellData, maCellValue.toInt32() );
 198         break;
 199         case XML_d:
 200             mrSheetData.setDateCell( maCellData, maCellValue );
 201         break;
 202     }
 203     else if( (maCellData.mnCellType == XML_inlineStr) && mxInlineStr )
 204     {
 205         mxInlineStr->finalizeImport(*this);
 206         mrSheetData.setStringCell( maCellData, mxInlineStr );
 207     }
 208     else
 209     {
 210         // empty cell, update cell type
 211         maCellData.mnCellType = XML_TOKEN_INVALID;
 212         mrSheetData.setBlankCell( maCellData );
 213     }
 214 }
 215
 216 ContextHandlerRef SheetDataContext::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
 217 {
 218     switch( getCurrentElement() )
 219     {
 220         case BIFF12_ID_SHEETDATA:
 221             if( nRecId == BIFF12_ID_ROW ) { importRow( rStrm ); return this; }
 222         break;
 223
 224         case BIFF12_ID_ROW:
 225             switch( nRecId )
 226             {
 227                 case BIFF12_ID_ARRAY:           importArray( rStrm );                           break;
 228                 case BIFF12_ID_CELL_BOOL:       importCellBool( rStrm, CELLTYPE_VALUE );        break;
 229                 case BIFF12_ID_CELL_BLANK:      importCellBlank( rStrm, CELLTYPE_VALUE );       break;
 230                 case BIFF12_ID_CELL_DOUBLE:     importCellDouble( rStrm, CELLTYPE_VALUE );      break;
 231                 case BIFF12_ID_CELL_ERROR:      importCellError( rStrm, CELLTYPE_VALUE );       break;
 232                 case BIFF12_ID_CELL_RK:         importCellRk( rStrm, CELLTYPE_VALUE );          break;
 233                 case BIFF12_ID_CELL_RSTRING:    importCellRString( rStrm, CELLTYPE_VALUE );     break;
 234                 case BIFF12_ID_CELL_SI:         importCellSi( rStrm, CELLTYPE_VALUE );          break;
 235                 case BIFF12_ID_CELL_STRING:     importCellString( rStrm, CELLTYPE_VALUE );      break;
 236                 case BIFF12_ID_DATATABLE:       importDataTable( rStrm );                       break;
 237                 case BIFF12_ID_FORMULA_BOOL:    importCellBool( rStrm, CELLTYPE_FORMULA );      break;
 238                 case BIFF12_ID_FORMULA_DOUBLE:  importCellDouble( rStrm, CELLTYPE_FORMULA );    break;
 239                 case BIFF12_ID_FORMULA_ERROR:   importCellError( rStrm, CELLTYPE_FORMULA );     break;
 240                 case BIFF12_ID_FORMULA_STRING:  importCellString( rStrm, CELLTYPE_FORMULA );    break;
 241                 case BIFF12_ID_MULTCELL_BOOL:   importCellBool( rStrm, CELLTYPE_MULTI );        break;
 242                 case BIFF12_ID_MULTCELL_BLANK:  importCellBlank( rStrm, CELLTYPE_MULTI );       break;
 243                 case BIFF12_ID_MULTCELL_DOUBLE: importCellDouble( rStrm, CELLTYPE_MULTI );      break;
 244                 case BIFF12_ID_MULTCELL_ERROR:  importCellError( rStrm, CELLTYPE_MULTI );       break;
 245                 case BIFF12_ID_MULTCELL_RK:     importCellRk( rStrm, CELLTYPE_MULTI );          break;
 246                 case BIFF12_ID_MULTCELL_RSTRING:importCellRString( rStrm, CELLTYPE_MULTI );     break;
 247                 case BIFF12_ID_MULTCELL_SI:     importCellSi( rStrm, CELLTYPE_MULTI );          break;
 248                 case BIFF12_ID_MULTCELL_STRING: importCellString( rStrm, CELLTYPE_MULTI );      break;
 249                 case BIFF12_ID_SHAREDFMLA:      importSharedFmla( rStrm );                      break;
 250             }
 251         break;
 252     }
 253     return nullptr;
 254 }
 255
 256 // private --------------------------------------------------------------------
 257
 258 void SheetDataContext::importRow( const AttributeList& rAttribs )
 259 {
 260     RowModel aModel;
 261     sal_Int32 nRow = rAttribs.getInteger( XML_r, -1 ); // 1-based row index
 262     if(nRow != -1)
 263     {
 264         aModel.mnRow = nRow;
 265         mnRow = nRow-1; // to 0-based row index.
 266     }
 267     else
 268         aModel.mnRow = (++mnRow + 1);   // increment 0-based row index, to 1-based model row
 269     mrAddressConv.checkRow( mnRow, true);
 270     mnCol = -1;
 271
 272     aModel.mfHeight       = rAttribs.getDouble( XML_ht, -1.0 );
 273     aModel.mnXfId         = rAttribs.getInteger( XML_s, -1 );
 274     aModel.mnLevel        = rAttribs.getInteger( XML_outlineLevel, 0 );
 275     aModel.mbCustomHeight = rAttribs.getBool( XML_customHeight, false );
 276     aModel.mbCustomFormat = rAttribs.getBool( XML_customFormat, false );
 277     aModel.mbShowPhonetic = rAttribs.getBool( XML_ph, false );
 278     aModel.mbHidden       = rAttribs.getBool( XML_hidden, false );
 279     aModel.mbCollapsed    = rAttribs.getBool( XML_collapsed, false );
 280     aModel.mbThickTop     = rAttribs.getBool( XML_thickTop, false );
 281     aModel.mbThickBottom  = rAttribs.getBool( XML_thickBot, false );
 282
 283     if (aModel.mfHeight > 0 && getFilter().isMSODocument())
 284     {
 285         aModel.mfHeight -= fmod(aModel.mfHeight, 0.75);  //round down to 0.75pt
 286     }
 287
 288     // decode the column spans (space-separated list of colon-separated integer pairs)
 289     OUString aColSpansText = rAttribs.getString( XML_spans, OUString() );
 290     sal_Int32 nIndex = 0;
 291     while( nIndex >= 0 )
 292     {
 293         std::u16string_view aColSpanToken = o3tl::getToken(aColSpansText, 0, ' ', nIndex );
 294         size_t nSepPos = aColSpanToken.find( ':' );
 295         if( (0 < nSepPos) && (nSepPos + 1 < aColSpanToken.size()) )
 296         {
 297             // OOXML uses 1-based integer column indexes, row model expects 0-based colspans
 298             const sal_Int32 nCol1 = o3tl::toInt32(aColSpanToken.substr( 0, nSepPos )) - 1;
 299             const bool bValid1 = mrAddressConv.checkCol( nCol1, true);
 300             if (bValid1)
 301             {
 302                 const sal_Int32 nCol2 = o3tl::toInt32(aColSpanToken.substr( nSepPos + 1 )) - 1;
 303                 mrAddressConv.checkCol( nCol2, true);
 304             }
 305         }
 306     }
 307
 308     // set row properties in the current sheet
 309     setRowModel( aModel );
 310 }
 311
 312 bool SheetDataContext::importCell( const AttributeList& rAttribs )
 313 {
 314     bool bValid = true;
 315     std::string_view p = rAttribs.getView(XML_r);
 316
 317     if (p.empty())
 318     {
 319         ++mnCol;
 320         ScAddress aAddress( mnCol, mnRow, mnSheet );
 321         bValid = mrAddressConv.checkCellAddress( aAddress, true );
 322         maCellData.maCellAddr = aAddress;
 323     }
 324     else
 325     {
 326         bValid = mrAddressConv.convertToCellAddress(maCellData.maCellAddr, p, mnSheet, true);
 327         mnCol = maCellData.maCellAddr.Col();
 328     }
 329
 330     if( bValid )
 331     {
 332         maCellData.mnCellType     = rAttribs.getToken( XML_t, XML_n );
 333         maCellData.mnXfId         = rAttribs.getInteger( XML_s, -1 );
 334         maCellData.mbShowPhonetic = rAttribs.getBool( XML_ph, false );
 335
 336         // reset cell value, formula settings, and inline string
 337         maCellValue.clear();
 338         mxInlineStr.reset();
 339         mbHasFormula = false;
 340
 341         // update used area of the sheet
 342         extendUsedArea( maCellData.maCellAddr );
 343     }
 344     return bValid;
 345 }
 346
 347 void SheetDataContext::importFormula( const AttributeList& rAttribs )
 348 {
 349     mbHasFormula = true;
 350     mbValidRange = mrAddressConv.convertToCellRange( maFmlaData.maFormulaRef, rAttribs.getString( XML_ref, OUString() ), mnSheet, true, true );
 351
 352     maFmlaData.mnFormulaType = rAttribs.getToken( XML_t, XML_normal );
 353     maFmlaData.mnSharedId    = rAttribs.getInteger( XML_si, -1 );
 354
 355     if( maFmlaData.mnFormulaType == XML_dataTable )
 356     {
 357         maTableData.maRef1        = rAttribs.getString( XML_r1, OUString() );
 358         maTableData.maRef2        = rAttribs.getString( XML_r2, OUString() );
 359         maTableData.mb2dTable     = rAttribs.getBool( XML_dt2D, false );
 360         maTableData.mbRowTable    = rAttribs.getBool( XML_dtr, false );
 361         maTableData.mbRef1Deleted = rAttribs.getBool( XML_del1, false );
 362         maTableData.mbRef2Deleted = rAttribs.getBool( XML_del2, false );
 363     }
 364
 365     maFormulaStr.clear();
 366 }
 367
 368 void SheetDataContext::importRow( SequenceInputStream& rStrm )
 369 {
 370     RowModel aModel;
 371     sal_Int32 nSpanCount;
 372     sal_uInt16 nHeight, nFlags1;
 373     sal_uInt8 nFlags2;
 374     maCurrPos.mnRow = rStrm.readInt32();
 375     aModel.mnXfId = rStrm.readInt32();
 376     nHeight = rStrm.readuInt16();
 377     nFlags1 = rStrm.readuInt16();
 378     nFlags2 = rStrm.readuChar();
 379     nSpanCount = rStrm.readInt32();
 380     maCurrPos.mnCol = 0;
 381
 382     mrAddressConv.checkRow( maCurrPos.mnRow, true);
 383     // row index is 0-based in BIFF12, but RowModel expects 1-based
 384     aModel.mnRow          = maCurrPos.mnRow + 1;
 385     // row height is in twips in BIFF12, convert to points
 386     aModel.mfHeight       = nHeight / 20.0;
 387     aModel.mnLevel        = extractValue< sal_Int32 >( nFlags1, 8, 3 );
 388     aModel.mbCustomHeight = getFlag( nFlags1, BIFF12_ROW_CUSTOMHEIGHT );
 389     aModel.mbCustomFormat = getFlag( nFlags1, BIFF12_ROW_CUSTOMFORMAT );
 390     aModel.mbShowPhonetic = getFlag( nFlags2, BIFF12_ROW_SHOWPHONETIC );
 391     aModel.mbHidden       = getFlag( nFlags1, BIFF12_ROW_HIDDEN );
 392     aModel.mbCollapsed    = getFlag( nFlags1, BIFF12_ROW_COLLAPSED );
 393     aModel.mbThickTop     = getFlag( nFlags1, BIFF12_ROW_THICKTOP );
 394     aModel.mbThickBottom  = getFlag( nFlags1, BIFF12_ROW_THICKBOTTOM );
 395
 396     // read the column spans
 397     for( sal_Int32 nSpanIdx = 0; (nSpanIdx < nSpanCount) && !rStrm.isEof(); ++nSpanIdx )
 398     {
 399         sal_Int32 nFirstCol, nLastCol;
 400         nFirstCol = rStrm.readInt32();
 401         mrAddressConv.checkCol( nFirstCol, true);
 402         nLastCol = rStrm.readInt32();
 403         mrAddressConv.checkCol( nLastCol, true);
 404     }
 405
 406     // set row properties in the current sheet
 407     setRowModel( aModel );
 408 }
 409
 410 bool SheetDataContext::readCellHeader( SequenceInputStream& rStrm, CellType eCellType )
 411 {
 412     switch( eCellType )
 413     {
 414         case CELLTYPE_VALUE:
 415         case CELLTYPE_FORMULA:  maCurrPos.mnCol = rStrm.readInt32();   break;
 416         case CELLTYPE_MULTI:    ++maCurrPos.mnCol;          break;
 417     }
 418
 419     sal_uInt32 nXfId = rStrm.readuInt32();
 420
 421     bool bValidAddr = mrAddressConv.convertToCellAddress( maCellData.maCellAddr, maCurrPos, mnSheet, true );
 422     maCellData.mnXfId = extractValue< sal_Int32 >( nXfId, 0, 24 );
 423     maCellData.mbShowPhonetic = getFlag( nXfId, BIFF12_CELL_SHOWPHONETIC );
 424
 425     // update used area of the sheet
 426     if( bValidAddr )
 427         extendUsedArea( maCellData.maCellAddr );
 428     return bValidAddr;
 429 }
 430
 431 ApiTokenSequence SheetDataContext::readCellFormula( SequenceInputStream& rStrm )
 432 {
 433     rStrm.skip( 2 );
 434     return mxFormulaParser->importFormula( maCellData.maCellAddr, FormulaType::Cell, rStrm );
 435 }
 436
 437 bool SheetDataContext::readFormulaRef( SequenceInputStream& rStrm )
 438 {
 439     BinRange aRange;
 440     rStrm >> aRange;
 441     return mrAddressConv.convertToCellRange( maFmlaData.maFormulaRef, aRange, mnSheet, true, true );
 442 }
 443
 444 void SheetDataContext::importCellBool( SequenceInputStream& rStrm, CellType eCellType )
 445 {
 446     if( readCellHeader( rStrm, eCellType ) )
 447     {
 448         maCellData.mnCellType = XML_b;
 449         bool bValue = rStrm.readuInt8() != 0;
 450         if( eCellType == CELLTYPE_FORMULA )
 451             mrSheetData.setFormulaCell( maCellData, readCellFormula( rStrm ) );
 452         else
 453             mrSheetData.setBooleanCell( maCellData, bValue );
 454     }
 455 }
 456
 457 void SheetDataContext::importCellBlank( SequenceInputStream& rStrm, CellType eCellType )
 458 {
 459     OSL_ENSURE( eCellType != CELLTYPE_FORMULA, "SheetDataContext::importCellBlank - no formula cells supported" );
 460     if( readCellHeader( rStrm, eCellType ) )
 461         mrSheetData.setBlankCell( maCellData );
 462 }
 463
 464 void SheetDataContext::importCellDouble( SequenceInputStream& rStrm, CellType eCellType )
 465 {
 466     if( readCellHeader( rStrm, eCellType ) )
 467     {
 468         maCellData.mnCellType = XML_n;
 469         double fValue = rStrm.readDouble();
 470         if( eCellType == CELLTYPE_FORMULA )
 471             mrSheetData.setFormulaCell( maCellData, readCellFormula( rStrm ) );
 472         else
 473             mrSheetData.setValueCell( maCellData, fValue );
 474     }
 475 }
 476
 477 void SheetDataContext::importCellError( SequenceInputStream& rStrm, CellType eCellType )
 478 {
 479     if( readCellHeader( rStrm, eCellType ) )
 480     {
 481         maCellData.mnCellType = XML_e;
 482         sal_uInt8 nErrorCode = rStrm.readuInt8();
 483         if( eCellType == CELLTYPE_FORMULA )
 484             mrSheetData.setFormulaCell( maCellData, readCellFormula( rStrm ) );
 485         else
 486             mrSheetData.setErrorCell( maCellData, nErrorCode );
 487     }
 488 }
 489
 490 void SheetDataContext::importCellRk( SequenceInputStream& rStrm, CellType eCellType )
 491 {
 492     OSL_ENSURE( eCellType != CELLTYPE_FORMULA, "SheetDataContext::importCellRk - no formula cells supported" );
 493     if( readCellHeader( rStrm, eCellType ) )
 494     {
 495         maCellData.mnCellType = XML_n;
 496         mrSheetData.setValueCell( maCellData, BiffHelper::calcDoubleFromRk( rStrm.readInt32() ) );
 497     }
 498 }
 499
 500 void SheetDataContext::importCellRString( SequenceInputStream& rStrm, CellType eCellType )
 501 {
 502     OSL_ENSURE( eCellType != CELLTYPE_FORMULA, "SheetDataContext::importCellRString - no formula cells supported" );
 503     if( readCellHeader( rStrm, eCellType ) )
 504     {
 505         maCellData.mnCellType = XML_inlineStr;
 506         RichStringRef xString = std::make_shared<RichString>();
 507         xString->importString( rStrm, true, *this );
 508         xString->finalizeImport( *this );
 509         mrSheetData.setStringCell( maCellData, xString );
 510     }
 511 }
 512
 513 void SheetDataContext::importCellSi( SequenceInputStream& rStrm, CellType eCellType )
 514 {
 515     OSL_ENSURE( eCellType != CELLTYPE_FORMULA, "SheetDataContext::importCellSi - no formula cells supported" );
 516     if( readCellHeader( rStrm, eCellType ) )
 517     {
 518         maCellData.mnCellType = XML_s;
 519         mrSheetData.setStringCell( maCellData, rStrm.readInt32() );
 520     }
 521 }
 522
 523 void SheetDataContext::importCellString( SequenceInputStream& rStrm, CellType eCellType )
 524 {
 525     if( readCellHeader( rStrm, eCellType ) )
 526     {
 527         maCellData.mnCellType = XML_inlineStr;
 528         // always import the string, stream will point to formula afterwards, if existing
 529         RichStringRef xString = std::make_shared<RichString>();
 530         xString->importString( rStrm, false, *this );
 531         xString->finalizeImport( *this );
 532         if( eCellType == CELLTYPE_FORMULA )
 533             mrSheetData.setFormulaCell( maCellData, readCellFormula( rStrm ) );
 534         else
 535             mrSheetData.setStringCell( maCellData, xString );
 536     }
 537 }
 538
 539 void SheetDataContext::importArray( SequenceInputStream& rStrm )
 540 {
 541     if( readFormulaRef( rStrm ) && maFmlaData.isValidArrayRef( maCellData.maCellAddr ) )
 542     {
 543         rStrm.skip( 1 );
 544         ApiTokenSequence aTokens = mxFormulaParser->importFormula( maCellData.maCellAddr, FormulaType::Array, rStrm );
 545         mrSheetData.createArrayFormula( maFmlaData.maFormulaRef, aTokens );
 546     }
 547 }
 548
 549 void SheetDataContext::importDataTable( SequenceInputStream& rStrm )
 550 {
 551     if( !readFormulaRef( rStrm ) )
 552         return;
 553
 554     BinAddress aRef1, aRef2;
 555     sal_uInt8 nFlags;
 556     rStrm >> aRef1 >> aRef2;
 557     nFlags = rStrm.readuChar();
 558     maTableData.maRef1        = FormulaProcessorBase::generateAddress2dString( aRef1, false );
 559     maTableData.maRef2        = FormulaProcessorBase::generateAddress2dString( aRef2, false );
 560     maTableData.mbRowTable    = getFlag( nFlags, BIFF12_DATATABLE_ROW );
 561     maTableData.mb2dTable     = getFlag( nFlags, BIFF12_DATATABLE_2D );
 562     maTableData.mbRef1Deleted = getFlag( nFlags, BIFF12_DATATABLE_REF1DEL );
 563     maTableData.mbRef2Deleted = getFlag( nFlags, BIFF12_DATATABLE_REF2DEL );
 564     mrSheetData.createTableOperation( maFmlaData.maFormulaRef, maTableData );
 565 }
 566
 567 void SheetDataContext::importSharedFmla( SequenceInputStream& rStrm )
 568 {
 569     if( readFormulaRef( rStrm ) && maFmlaData.isValidSharedRef( maCellData.maCellAddr ) )
 570     {
 571         ApiTokenSequence aTokens = mxFormulaParser->importFormula( maCellData.maCellAddr, FormulaType::SharedFormula, rStrm );
 572         mrSheetData.createSharedFormula( maCellData.maCellAddr, aTokens );
 573     }
 574 }
 575
 576 } // namespace oox
 577
 578 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */