lotuswordpro/source/filter/lwptablelayout.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 /**
  57  * @file
  58  *  For LWP filter architecture prototype - table layouts
  59  */
  60
  61 #include <lwpglobalmgr.hxx>
  62 #include "lwptablelayout.hxx"
  63 #include <lwpfoundry.hxx>
  64 #include "lwpholder.hxx"
  65 #include "lwptable.hxx"
  66 #include "lwptblcell.hxx"
  67 #include "lwprowlayout.hxx"
  68 #include <lwpfilehdr.hxx>
  69
  70 #include <xfilter/xfstylemanager.hxx>
  71 #include <xfilter/xftablestyle.hxx>
  72 #include <xfilter/xfrow.hxx>
  73 #include <xfilter/xfrowstyle.hxx>
  74 #include <xfilter/xfcell.hxx>
  75 #include <xfilter/xfcolstyle.hxx>
  76 #include <xfilter/xfframestyle.hxx>
  77 #include <xfilter/xfframe.hxx>
  78 #include <xfilter/xffloatframe.hxx>
  79 #include "lwpframelayout.hxx"
  80 #include <xfilter/xfnumberstyle.hxx>
  81 #include <xfilter/xfparastyle.hxx>
  82 #include <o3tl/sorted_vector.hxx>
  83 #include <sal/log.hxx>
  84 #include <comphelper/configuration.hxx>
  85
  86 #include <algorithm>
  87 #include <memory>
  88
  89 LwpSuperTableLayout::LwpSuperTableLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
  90     : LwpPlacableLayout(objHdr, pStrm)
  91 {
  92     m_pFrame.reset(new LwpFrame(this) );
  93 }
  94
  95 LwpSuperTableLayout::~LwpSuperTableLayout()
  96 {
  97 }
  98 /**
  99  * @short    Read super table layout record
 100  */
 101 void LwpSuperTableLayout::Read()
 102 {
 103     LwpPlacableLayout::Read();
 104     m_pObjStrm->SkipExtra();
 105
 106 }
 107 /**
 108  * @short   Get child table layout
 109  * @return pointer to table layout
 110  */
 111 LwpTableLayout* LwpSuperTableLayout::GetTableLayout()
 112 {
 113     LwpObjectID *pID = &GetChildTail();
 114
 115     o3tl::sorted_vector<LwpObjectID*> aSeen;
 116     while (pID && !pID->IsNull())
 117     {
 118         bool bAlreadySeen = !aSeen.insert(pID).second;
 119         if (bAlreadySeen)
 120             throw std::runtime_error("loop in conversion");
 121
 122         LwpLayout* pLayout = dynamic_cast<LwpLayout*>(pID->obj().get());
 123         if (!pLayout)
 124             break;
 125         if (pLayout->GetLayoutType() == LWP_TABLE_LAYOUT)
 126             return dynamic_cast<LwpTableLayout *>(pLayout);
 127         pID = &pLayout->GetPrevious();
 128     }
 129
 130     return nullptr;
 131 }
 132
 133 /**
 134  * @short   Get effective heading table layout, the one just before table layout is the only one which is effective
 135  * @return LwpTableHeadingLayout* - pointer to table heading layout
 136  */
 137 LwpTableHeadingLayout* LwpSuperTableLayout::GetTableHeadingLayout()
 138 {
 139     LwpObjectID *pID = &GetChildTail();
 140
 141     o3tl::sorted_vector<LwpObjectID*> aSeen;
 142     while (pID && !pID->IsNull())
 143     {
 144         bool bAlreadySeen = !aSeen.insert(pID).second;
 145         if (bAlreadySeen)
 146             throw std::runtime_error("loop in conversion");
 147
 148         LwpLayout * pLayout = dynamic_cast<LwpLayout *>(pID->obj().get());
 149         if (!pLayout)
 150             break;
 151         if (pLayout->GetLayoutType() == LWP_TABLE_HEADING_LAYOUT)
 152             return dynamic_cast<LwpTableHeadingLayout *>(pLayout);
 153         pID = &pLayout->GetPrevious();
 154     }
 155
 156     return nullptr;
 157 }
 158
 159 /**
 160  * @short   Register super table layout style
 161  */
 162 void LwpSuperTableLayout::RegisterNewStyle()
 163 {
 164     // if this layout is style of real table entry
 165     LwpTableLayout* pTableLayout = GetTableLayout();
 166     if (pTableLayout != nullptr)
 167     {
 168         pTableLayout->SetFoundry(m_pFoundry);
 169         pTableLayout->RegisterStyle();
 170     }
 171 }
 172 /**
 173  * @short   Judge whether table size is according to content, borrowed from Word Pro code
 174  * @param
 175  * @return sal_Bool
 176  */
 177 bool LwpSuperTableLayout::IsSizeRightToContent()
 178 {
 179     /* Only "with paragraph above" tables can size right to content. */
 180     if (GetRelativeType() == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE)
 181         return LwpPlacableLayout::IsSizeRightToContent();
 182
 183     return false;
 184 }
 185 /**
 186  * @short   Judge whether table is justifiable, borrowed from Word Pro code
 187  * @param
 188  * @return sal_Bool
 189  */
 190 bool LwpSuperTableLayout::IsJustifiable()
 191 {
 192     return (GetRelativeType() != LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE || IsSizeRightToContent());
 193 }
 194 /**
 195  * @short   Get width of frame outside table
 196  * @param pTableStyle - pointer of XFTableStyle
 197  * @return double - table width
 198  */
 199 double LwpSuperTableLayout::GetWidth()
 200 {
 201     double dWidth = GetTableWidth();
 202     double dLeft    = GetMarginsValue(MARGIN_LEFT);
 203     double dRight   = GetMarginsValue(MARGIN_RIGHT);
 204
 205     return (dWidth + dLeft + dRight);
 206 }
 207 /**
 208  * @short   Get width of table
 209  * @param pTableStyle - pointer of XFTableStyle
 210  * @return double - table width
 211  */
 212 double LwpSuperTableLayout::GetTableWidth()
 213 {
 214     sal_Int32 nWidth = 0;
 215     if(!IsJustifiable() || ((nWidth = LwpMiddleLayout::GetMinimumWidth()) <= 0))
 216     {
 217         LwpTableLayout* pTableLayout = GetTableLayout();
 218         if(!pTableLayout)
 219         {
 220             SAL_WARN("lwp", "missing table layout, early return");
 221             return 0;
 222         }
 223         LwpTable *pTable = pTableLayout->GetTable();
 224         if(!pTable)
 225         {
 226             SAL_WARN("lwp", "missing table, early return");
 227             return 0;
 228         }
 229         double dDefaultWidth = pTable->GetWidth();
 230         sal_uInt16 nCol = pTable->GetColumn();
 231
 232         double dWidth = 0;
 233
 234         for(sal_uInt16 i =0; i< nCol; i++)
 235         {
 236             LwpObjectID *pColumnID = &pTableLayout->GetColumnLayoutHead();
 237             LwpColumnLayout * pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColumnID->obj().get());
 238             double dColumnWidth = dDefaultWidth;
 239             o3tl::sorted_vector<LwpColumnLayout*> aSeen;
 240             while (pColumnLayout)
 241             {
 242                 bool bAlreadySeen = !aSeen.insert(pColumnLayout).second;
 243                 if (bAlreadySeen)
 244                     throw std::runtime_error("loop in conversion");
 245                 if(pColumnLayout->GetColumnID() == i)
 246                 {
 247                     dColumnWidth = pColumnLayout->GetWidth();
 248                     break;
 249                 }
 250                 pColumnID = &pColumnLayout->GetNext();
 251                 pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColumnID->obj().get());
 252             }
 253             dWidth += dColumnWidth;
 254         }
 255
 256         return dWidth;
 257     }
 258
 259     double dLeft    = GetMarginsValue(MARGIN_LEFT);
 260     double dRight   = GetMarginsValue(MARGIN_RIGHT);
 261     return LwpTools::ConvertFromUnits(nWidth) - dLeft - dRight;
 262
 263 }
 264 /**
 265  * @short   Apply shadow to table
 266  * @param pTableStyle - pointer of XFTableStyle
 267  * @return
 268  */
 269 void LwpSuperTableLayout::ApplyShadow(XFTableStyle *pTableStyle)
 270 {
 271     // use shadow property of supertable
 272     std::unique_ptr<XFShadow> pXFShadow(GetXFShadow());
 273     if(pXFShadow)
 274     {
 275         pTableStyle->SetShadow(pXFShadow->GetPosition(), pXFShadow->GetOffset(), pXFShadow->GetColor());
 276     }
 277 }
 278 /**
 279  * @short   Apply pattern fill to table style
 280  * @param pTableStyle - pointer of XFTableStyle
 281  * @return
 282  */
 283 void LwpSuperTableLayout::ApplyPatternFill(XFTableStyle* pTableStyle)
 284 {
 285     std::unique_ptr<XFBGImage> xXFBGImage(GetFillPattern());
 286     if (xXFBGImage)
 287     {
 288         pTableStyle->SetBackImage(xXFBGImage);
 289     }
 290 }
 291
 292 /**
 293  * @short   Apply background to table style
 294  * @param pTableStyle - pointer of XFTableStyle
 295  * @return
 296  */
 297 void LwpSuperTableLayout::ApplyBackGround(XFTableStyle* pTableStyle)
 298 {
 299     if (IsPatternFill())
 300     {
 301         ApplyPatternFill(pTableStyle);
 302     }
 303     else
 304     {
 305         ApplyBackColor(pTableStyle);
 306     }
 307 }
 308 /**
 309  * @short   Apply back color to table
 310  * @param pTableStyle - pointer of XFTableStyle
 311  * @return
 312  */
 313 void LwpSuperTableLayout::ApplyBackColor(XFTableStyle *pTableStyle)
 314 {
 315     LwpColor* pColor = GetBackColor();
 316     if(pColor && pColor->IsValidColor())
 317     {
 318         XFColor aColor(pColor->To24Color());
 319         pTableStyle->SetBackColor(aColor);
 320     }
 321 }
 322 /**
 323  * @short   Apply watermark to  table
 324  * @param pTableStyle - pointer of XFTableStyle
 325  * @return
 326  */
 327 void LwpSuperTableLayout::ApplyWatermark(XFTableStyle *pTableStyle)
 328 {
 329     std::unique_ptr<XFBGImage> xBGImage(GetXFBGImage());
 330     if (xBGImage)
 331     {
 332         pTableStyle->SetBackImage(xBGImage);
 333     }
 334 }
 335 /**
 336  * @short   Apply alignment  to table
 337  * @param pTableStyle - pointer of XFTableStyle
 338  * @return
 339  */
 340 void LwpSuperTableLayout::ApplyAlignment(XFTableStyle * pTableStyle)
 341 {
 342     LwpPoint aPoint;
 343     if (LwpLayoutGeometry* pGeometry = GetGeometry())
 344         aPoint = pGeometry->GetOrigin();
 345     double dXOffset = LwpTools::ConvertFromUnits(aPoint.GetX());
 346
 347     // add left padding to alignment distance
 348     double dLeft = GetMarginsValue(MARGIN_LEFT);
 349
 350     pTableStyle->SetAlign(enumXFAlignStart, dXOffset+ dLeft);
 351 }
 352 /**
 353  * @short   Add table to container
 354  * @param pCont - pointer of container
 355  * @return pCont
 356  */
 357 void  LwpSuperTableLayout::XFConvert(XFContentContainer* pCont)
 358 {
 359     if ( LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE == GetRelativeType()
 360             && (!GetContainerLayout().is() || !GetContainerLayout()->IsCell()) )
 361     {
 362         LwpTableLayout * pTableLayout = GetTableLayout();
 363         if (pTableLayout)
 364         {
 365             pTableLayout->XFConvert(pCont);
 366         }
 367     }
 368     else if(IsRelativeAnchored())
 369     {
 370         //anchor to paragraph except "with paragraph above"
 371         XFConvertFrame(pCont);
 372     }
 373     else if(m_pFrame)
 374     {
 375         //anchor to page, frame, cell
 376         m_pFrame->XFConvert(pCont);
 377     }
 378 }
 379 /**
 380  * @short   convert frame which anchor to page
 381  * @param
 382  * @return
 383  */
 384 void  LwpSuperTableLayout::XFConvertFrame(XFContentContainer* pCont, sal_Int32 nStart, sal_Int32 nEnd, bool bAll)
 385 {
 386     if(!m_pFrame)
 387         return;
 388
 389     rtl::Reference<XFFrame> xXFFrame;
 390     if(nEnd < nStart)
 391     {
 392         xXFFrame.set(new XFFrame);
 393     }
 394     else
 395     {
 396         xXFFrame.set(new XFFloatFrame(nStart, nEnd, bAll));
 397     }
 398
 399     m_pFrame->Parse(xXFFrame.get(), static_cast<sal_uInt16>(nStart));
 400     //parse table, and add table to frame
 401     LwpTableLayout * pTableLayout = GetTableLayout();
 402     if (pTableLayout)
 403     {
 404         pTableLayout->XFConvert(xXFFrame.get());
 405     }
 406     //add frame to the container
 407     pCont->Add(xXFFrame.get());
 408
 409 }
 410 /**
 411  * @short  register frame style
 412  * @param
 413  * @return
 414  */
 415 void  LwpSuperTableLayout::RegisterFrameStyle()
 416 {
 417     std::unique_ptr<XFFrameStyle> xFrameStyle(new XFFrameStyle);
 418     m_pFrame->RegisterStyle(xFrameStyle);
 419 }
 420
 421 LwpTableLayout::LwpTableLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
 422     : LwpLayout(objHdr, pStrm)
 423     , m_nRows(0)
 424     , m_nCols(0)
 425     , m_pDefaultCellLayout(nullptr)
 426     , m_bConverted(false)
 427 {
 428 }
 429
 430 /**
 431  * @short   Get neighbour cell by specifying ROW+COL
 432  * @param   nRow
 433  * @param   nCol
 434  * @return   LwpCellLayout *
 435  */
 436 LwpCellLayout * LwpTableLayout::GetCellByRowCol(sal_uInt16 nRow, sal_uInt16 nCol)
 437 {
 438     if (nRow >= m_nRows || nCol >= m_nCols)
 439         return nullptr;
 440
 441     return m_WordProCellsMap[static_cast<size_t>(nRow)*m_nCols + nCol];
 442 }
 443
 444 /**
 445  * @short   traverse all table cells
 446  * @param
 447  * @param
 448  * @param
 449  */
 450 void LwpTableLayout::TraverseTable()
 451 {
 452     sal_uInt32 nCount = m_nRows*m_nCols;
 453
 454     // new cell map nRow*nCOl and initialize
 455     m_WordProCellsMap.insert(m_WordProCellsMap.end(), nCount, m_pDefaultCellLayout);
 456
 457     // set value
 458     LwpObjectID* pRowID = &GetChildHead();
 459     LwpRowLayout * pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
 460     o3tl::sorted_vector<LwpRowLayout*> aSeen;
 461     while (pRowLayout)
 462     {
 463         bool bAlreadySeen = !aSeen.insert(pRowLayout).second;
 464         if (bAlreadySeen)
 465             throw std::runtime_error("loop in conversion");
 466
 467         pRowLayout->SetRowMap();
 468
 469         // for 's analysis job
 470         m_RowsMap[pRowLayout->GetRowID()] = pRowLayout;
 471         pRowLayout->CollectMergeInfo();
 472         // end for 's analysis
 473
 474         pRowID = &pRowLayout->GetNext();
 475         pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
 476     }
 477 }
 478
 479 /**
 480  * @short   search the cell map
 481  * @param   nRow - row id (0 based)
 482  * @param   nRow - row id (0 based)
 483  * @return   LwpObjectID * - pointer to cell story object ID
 484  */
 485 LwpObjectID * LwpTableLayout::SearchCellStoryMap(sal_uInt16 nRow, sal_uInt16 nCol)
 486 {
 487     if (nRow >= m_nRows || nCol >= m_nCols )
 488     {
 489         return nullptr;
 490     }
 491
 492     LwpCellLayout * pCell = GetCellByRowCol(nRow, nCol);
 493     if (pCell)
 494     {
 495         // maybe connected cell layout
 496         // maybe default cell layout
 497         if (nRow != pCell->GetRowID() || nCol != pCell->GetColID())
 498         {
 499             return nullptr;
 500         }
 501         return &pCell->GetContent();
 502     }
 503
 504     return nullptr;
 505 }
 506
 507 /**
 508  * @short   Get parent super table layout of table layout
 509  * @return  LwpSuperTableLayout * - pointer of parent super table layout
 510  */
 511 LwpSuperTableLayout * LwpTableLayout::GetSuperTableLayout()
 512 {
 513     return dynamic_cast<LwpSuperTableLayout *>(GetParent().obj().get());
 514 }
 515 /**
 516  * @short    Get table pointer
 517  * @return   LwpTable * - content table pointer
 518  */
 519 LwpTable *  LwpTableLayout::GetTable()
 520 {
 521     return dynamic_cast<LwpTable *>(m_Content.obj().get());
 522 }
 523 /**
 524  * @short   Get column style name by column ID
 525  * @param   sal_uInt16 -- col id(0 based)
 526  * @return OUString - name of column style
 527  */
 528 OUString LwpTableLayout::GetColumnWidth(sal_uInt16 nCol)
 529 {
 530     if (nCol >= m_nCols)
 531     {
 532         assert(false);
 533         return m_DefaultColumnStyleName;
 534     }
 535
 536     LwpColumnLayout * pCol = m_aColumns[nCol];
 537     if (pCol)
 538     {
 539         return pCol->GetStyleName();
 540     }
 541
 542     return m_DefaultColumnStyleName;
 543 }
 544 /**
 545  * @short   analyze all columns to get whole table width and width of all columns
 546  * @short   and register all column styles
 547  * @param   none
 548  */
 549 void LwpTableLayout::RegisterColumns()
 550 {
 551     LwpTable* pTable = GetTable();
 552     if (!pTable)
 553         throw std::range_error("corrupt LwpTableLayout");
 554
 555     LwpSuperTableLayout* pSuper = GetSuperTableLayout();
 556     if (!pSuper)
 557         throw std::range_error("corrupt LwpTableLayout");
 558
 559     sal_uInt16 nCols = m_nCols;
 560
 561     m_aColumns.resize(nCols);
 562     std::unique_ptr<bool[]> pWidthCalculated( new bool[nCols] );
 563     for(sal_uInt16 i=0;i<nCols; i++)
 564     {
 565         pWidthCalculated[i] = false;
 566         m_aColumns[i] = nullptr;
 567     }
 568
 569     double dDefaultColumn = pTable->GetWidth();
 570     sal_uInt16 nJustifiableColumn = nCols;
 571
 572     double dTableWidth = pSuper->GetTableWidth();
 573
 574     // Get total width of justifiable columns
 575     // NOTICE: all default columns are regarded as justifiable columns
 576     LwpObjectID* pColumnID = &GetColumnLayoutHead();
 577     LwpColumnLayout * pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColumnID->obj().get());
 578     o3tl::sorted_vector<LwpColumnLayout*> aSeen;
 579     while (pColumnLayout)
 580     {
 581         bool bAlreadySeen = !aSeen.insert(pColumnLayout).second;
 582         if (bAlreadySeen)
 583             throw std::runtime_error("loop in conversion");
 584
 585         auto nColId = pColumnLayout->GetColumnID();
 586         if (nColId >= nCols)
 587         {
 588             throw std::range_error("corrupt LwpTableLayout");
 589         }
 590         m_aColumns[nColId] = pColumnLayout;
 591         if (!pColumnLayout->IsJustifiable())
 592         {
 593             pWidthCalculated[nColId] = true;
 594             dTableWidth -= pColumnLayout->GetWidth();
 595             nJustifiableColumn --;
 596         }
 597
 598         pColumnID = &pColumnLayout->GetNext();
 599         pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColumnID->obj().get());
 600     }
 601
 602     // if all columns are not justifiable, the rightmost column will be changed to justifiable
 603     if (nJustifiableColumn == 0 && nCols != 0)
 604     {
 605         nJustifiableColumn ++;
 606         if (m_aColumns[nCols - 1])
 607         {
 608             pWidthCalculated[nCols-1] = false;
 609             dTableWidth += m_aColumns[nCols-1]->GetWidth();
 610         }
 611         else
 612         {
 613             // this can't happen
 614             dTableWidth = dDefaultColumn;
 615             assert(false);
 616         }
 617     }
 618
 619     // justifiable columns will share the remain width averagely
 620     dDefaultColumn = nJustifiableColumn ? dTableWidth/nJustifiableColumn : 0;
 621
 622     // register default column style
 623     std::unique_ptr<XFColStyle> xColStyle(new XFColStyle);
 624     xColStyle->SetWidth(static_cast<float>(dDefaultColumn));
 625
 626     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 627     m_DefaultColumnStyleName =  pXFStyleManager->AddStyle(std::move(xColStyle)).m_pStyle->GetStyleName();
 628
 629     // register existed column style
 630     sal_uInt16 i=0;
 631     for( i=0;i<nCols; i++)
 632     {
 633         if (m_aColumns[i])
 634         {
 635             m_aColumns[i]->SetFoundry(m_pFoundry);
 636             if(!pWidthCalculated[i])
 637             {
 638                 // justifiable ----register style with calculated value
 639                 m_aColumns[i]->SetStyleName(m_DefaultColumnStyleName);
 640             }
 641             else
 642             {
 643                 // not justifiable ---- register style with original value
 644                 m_aColumns[i]->RegisterStyle(m_aColumns[i]->GetWidth());
 645             }
 646         }
 647     }
 648 }
 649 /**
 650  * @short    register all row styles
 651  * @param   none
 652  */
 653 void LwpTableLayout::RegisterRows()
 654 {
 655     LwpTable * pTable = GetTable();
 656     if (pTable == nullptr)
 657     {
 658         assert(false);
 659         return;
 660     }
 661
 662     // register default row style
 663     std::unique_ptr<XFRowStyle> xRowStyle(new XFRowStyle);
 664     if (m_nDirection & 0x0030)
 665     {
 666         xRowStyle->SetMinRowHeight(static_cast<float>(pTable->GetHeight()));
 667     }
 668     else
 669     {
 670         xRowStyle->SetRowHeight(static_cast<float>(pTable->GetHeight()));
 671     }
 672     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 673     m_DefaultRowStyleName =  pXFStyleManager->AddStyle(std::move(xRowStyle)).m_pStyle->GetStyleName();
 674
 675     // register style of rows
 676     LwpObjectID * pRowID = &GetChildHead();
 677     LwpRowLayout * pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
 678     while (pRowLayout)
 679     {
 680         pRowLayout->SetFoundry(m_pFoundry);
 681         pRowLayout->RegisterStyle();
 682
 683         pRowID = &pRowLayout->GetNext();
 684         pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
 685     }
 686 }
 687 /**
 688  * @short   register table style, if needed, including frame style
 689  * @param   none
 690  */
 691 void LwpTableLayout::RegisterStyle()
 692 {
 693     // get super table layout
 694     LwpSuperTableLayout * pSuper = GetSuperTableLayout();
 695     if (!pSuper)
 696         return;
 697
 698     // get table
 699     LwpTable * pTable = GetTable();
 700     if (pTable == nullptr)
 701     {
 702         SAL_WARN("lwp", "missing table, early return");
 703         return;
 704     }
 705
 706     // get row/column number of this table
 707     m_nRows = pTable->GetRow();
 708     m_nCols = pTable->GetColumn();
 709     //http://www.danielsays.com/ss-gallery-win1x2x3x-lotus-word-pro-96.html
 710     //tables with up to 255 rows and 8192 columns
 711     //the row limit tallies with the casting of m_nCols to an unsigned char
 712     //elsewhere
 713     if (m_nRows > MAX_NUM_ROWS)
 714         throw std::runtime_error("max legal row exceeded");
 715     if (m_nCols > MAX_NUM_COLS)
 716         throw std::runtime_error("max legal column exceeded");
 717
 718     // get default cell layout of current table
 719     LwpObjectID& rID= pTable->GetDefaultCellStyle();
 720     m_pDefaultCellLayout = dynamic_cast<LwpCellLayout *>(rID.obj().get());
 721
 722     // register columns styles
 723     RegisterColumns();
 724
 725     // register style of whole table
 726     std::unique_ptr<XFTableStyle> xTableStyle(new XFTableStyle);
 727
 728     sal_uInt8 nType = pSuper->GetRelativeType();
 729     // If the table is not "with paragraph above" placement, create an frame style
 730     // by supertable layout
 731     if ( LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE == nType
 732         && (!pSuper->GetContainerLayout().is() || !pSuper->GetContainerLayout()->IsCell()) )
 733     {
 734         //with para above
 735         pSuper->ApplyBackGround(xTableStyle.get());
 736         pSuper->ApplyWatermark(xTableStyle.get());
 737         pSuper->ApplyShadow(xTableStyle.get());
 738         pSuper->ApplyAlignment(xTableStyle.get());
 739         xTableStyle->SetWidth(pSuper->GetTableWidth());
 740     }
 741     else
 742     {
 743         pSuper->RegisterFrameStyle();
 744         xTableStyle->SetAlign(enumXFAlignCenter);
 745         xTableStyle->SetWidth(pSuper->GetTableWidth());
 746     }
 747     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 748     m_StyleName = pXFStyleManager->AddStyle(std::move(xTableStyle)).m_pStyle->GetStyleName();
 749
 750     //convert to OO table now and register row style traverse
 751     TraverseTable();
 752
 753     SplitConflictCells();
 754
 755     // Register rows layouts, it must be after SplitConflictCells
 756     RegisterRows();
 757
 758     // Parse table
 759     ParseTable();
 760
 761     // the old code doesn't check if the LwpFoundry pointer is NULL,
 762     // so the NULL pointer cause sodc freeze. Add code to check the pointer.
 763     if (GetFoundry())
 764         PutCellVals(GetFoundry(), pTable->GetObjectID());
 765 }
 766 /**
 767  * @short   read table layout
 768  * @param   none
 769  */
 770 void LwpTableLayout::ParseTable()
 771 {
 772     // get super table layout
 773     LwpSuperTableLayout* pSuper = GetSuperTableLayout();
 774     if (!pSuper)
 775     {
 776         throw std::runtime_error("missing super table");
 777     }
 778
 779     if (m_pXFTable)
 780     {
 781         throw std::runtime_error("this table is already parsed");
 782     }
 783
 784     // set name of object
 785     m_pXFTable.set(new XFTable);
 786
 787     m_pXFTable->SetTableName(pSuper->GetName().str());
 788     // set table style
 789     m_pXFTable->SetStyleName(m_StyleName);
 790
 791     sal_uInt16 nRow = m_nRows;
 792     sal_uInt8 nCol = static_cast<sal_uInt8>(m_nCols);
 793
 794     sal_uInt16 nContentRow = 0;
 795
 796     //process header rows
 797     LwpTableHeadingLayout* pTableHeading;
 798     pTableHeading = pSuper->GetTableHeadingLayout();
 799     if (pTableHeading)
 800     {
 801         sal_uInt16 nStartHeadRow;
 802         sal_uInt16 nEndHeadRow;
 803         pTableHeading->GetStartEndRow(nStartHeadRow,nEndHeadRow);
 804         if (nStartHeadRow == 0)
 805         {
 806             if (comphelper::IsFuzzing() && nEndHeadRow - nStartHeadRow > 128)
 807             {
 808                 SAL_WARN("lwp", "truncating HeadingRow for fuzzing performance");
 809                 nEndHeadRow = nStartHeadRow + 128;
 810             }
 811             nContentRow = ConvertHeadingRow(m_pXFTable,nStartHeadRow,nEndHeadRow+1);
 812         }
 813     }
 814
 815     ConvertTable(m_pXFTable, nContentRow, nRow, 0, nCol);
 816 }
 817
 818 /**
 819  * @short   read table layout
 820  * @param   none
 821  */
 822 void LwpTableLayout::Read()
 823 {
 824     LwpLayout::Read();
 825
 826     // before layout hierarchy rework!
 827     if(LwpFileHeader::m_nFileRevision < 0x000b)
 828     {
 829         assert(false);
 830     }
 831     m_ColumnLayout.ReadIndexed(m_pObjStrm.get());
 832
 833     m_pObjStrm->SkipExtra();
 834 }
 835
 836 /**
 837  * @short    Convert table
 838  * @param
 839  * @return   pCont - container which will contain table
 840  */
 841 void LwpTableLayout::XFConvert(XFContentContainer* pCont)
 842 {
 843     if (!m_pXFTable)
 844         return;
 845     if (m_bConverted)
 846         throw std::runtime_error("already added to a container");
 847     pCont->Add(m_pXFTable.get());
 848     m_bConverted = true;
 849 }
 850
 851 /**
 852  * @short   convert heading row
 853  * @param  pXFTable - pointer of table
 854  * @param  nStartRow - start heading row ID
 855  * @param  nEndRow - end heading row ID
 856  */
 857 sal_uInt16 LwpTableLayout::ConvertHeadingRow(
 858         rtl::Reference<XFTable> const & pXFTable, sal_uInt16 nStartHeadRow, sal_uInt16 nEndHeadRow)
 859 {
 860     sal_uInt16 nContentRow;
 861     LwpTable* pTable = GetTable();
 862     assert(pTable);
 863     sal_uInt8 nCol = static_cast<sal_uInt8>(pTable->GetColumn());
 864     rtl::Reference<XFTable> pTmpTable( new XFTable );
 865
 866     ConvertTable(pTmpTable,nStartHeadRow,nEndHeadRow,0,nCol);
 867
 868     sal_uInt16 nRowNum = pTmpTable->GetRowCount();
 869     std::vector<sal_uInt8> CellMark(nRowNum);
 870
 871     if (nRowNum == 1)
 872     {
 873         XFRow* pXFRow = pTmpTable->GetRow(1);
 874         pXFTable->AddHeaderRow(pXFRow);
 875         pTmpTable->RemoveRow(1);
 876         nContentRow = nEndHeadRow;
 877     }
 878     else
 879     {
 880         sal_uInt8 nFirstColSpann = 1;
 881         const bool bFindFlag = FindSplitColMark(pTmpTable.get(), CellMark, nFirstColSpann);
 882
 883         if (bFindFlag)//split to 2 cells
 884         {
 885             SplitRowToCells(pTmpTable.get(), pXFTable, nFirstColSpann, CellMark.data());
 886             nContentRow = nEndHeadRow;
 887         }
 888         else//can not split,the first row will be the heading row,the rest will be content row
 889         {
 890             XFRow* pXFRow = pTmpTable->GetRow(1);
 891             pXFTable->AddHeaderRow(pXFRow);
 892             pTmpTable->RemoveRow(1);
 893             auto iter = m_RowsMap.find(0);
 894             if (iter == m_RowsMap.end())
 895             {
 896                 SAL_WARN("lwp", "row 0 is unknown");
 897                 nContentRow = 0;
 898             }
 899             else
 900                 nContentRow = iter->second->GetCurMaxSpannedRows(0,nCol);
 901         }
 902     }
 903     return nContentRow;
 904 }
 905
 906 void LwpTableLayout::SplitRowToCells(XFTable* pTmpTable, rtl::Reference<XFTable> const & pXFTable,
 907         sal_uInt8 nFirstColSpann,const sal_uInt8* pCellMark)
 908 {
 909     sal_uInt16 i;
 910     sal_uInt16 nRowNum = pTmpTable->GetRowCount();
 911     LwpTable* pTable = GetTable();
 912     assert(pTable);
 913     sal_uInt8 nCol = static_cast<sal_uInt8>(pTable->GetColumn());
 914
 915     rtl::Reference<XFRow> xXFRow(new XFRow);
 916
 917     //register style for heading row
 918     double fHeight = 0;
 919     std::unique_ptr<XFRowStyle> xRowStyle(new XFRowStyle);
 920     XFRow* pRow = pTmpTable->GetRow(1);
 921     if (!pRow)
 922         throw std::runtime_error("missing row");
 923     OUString styleName = pRow->GetStyleName();
 924
 925     // get settings of the row and assign them to new row style
 926     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 927     XFRowStyle *pTempRowStyle = static_cast<XFRowStyle*>(pXFStyleManager->FindStyle(styleName));
 928     if (pTempRowStyle)
 929         *xRowStyle = *pTempRowStyle;
 930
 931     for (i=1;i<=nRowNum;i++)
 932     {
 933         styleName = pTmpTable->GetRow(i)->GetStyleName();
 934         if (XFRowStyle* pRowStyle = static_cast<XFRowStyle*>(pXFStyleManager->FindStyle(styleName)))
 935             fHeight+=pRowStyle->GetRowHeight();
 936     }
 937     if (m_nDirection & 0x0030)
 938     {
 939         xRowStyle->SetMinRowHeight(static_cast<float>(fHeight));
 940     }
 941     else
 942     {
 943         xRowStyle->SetRowHeight(static_cast<float>(fHeight));
 944     }
 945     xXFRow->SetStyleName(pXFStyleManager->AddStyle(std::move(xRowStyle)).m_pStyle->GetStyleName());
 946
 947     //construct heading row
 948     rtl::Reference<XFCell> xXFCell1(new XFCell);
 949     rtl::Reference<XFCell> xXFCell2(new XFCell);
 950     rtl::Reference<XFTable> xSubTable1(new XFTable);
 951     rtl::Reference<XFTable> xSubTable2(new XFTable);
 952     rtl::Reference<XFCell> xNewCell;
 953
 954     for (i=1;i<=nRowNum;i++)
 955     {
 956         XFRow* pOldRow = pTmpTable->GetRow(i);
 957         rtl::Reference<XFRow> xNewRow(new XFRow);
 958         xNewRow->SetStyleName(pOldRow->GetStyleName());
 959         for (sal_uInt8 j=1;j<=pCellMark[i];j++)
 960         {
 961             xNewCell = pOldRow->GetCell(j);
 962             xNewRow->AddCell(xNewCell);
 963         }
 964         xSubTable1->AddRow(xNewRow);
 965     }
 966     ConvertColumn(xSubTable1, 0, nFirstColSpann);//add column info
 967
 968     xXFCell1->Add(xSubTable1.get());
 969     xXFCell1->SetColumnSpaned(nFirstColSpann);
 970     xXFRow->AddCell(xXFCell1);
 971
 972     for (i=1;i<=nRowNum;i++)
 973     {
 974         XFRow* pOldRow = pTmpTable->GetRow(i);
 975         rtl::Reference<XFRow> xNewRow(new XFRow);
 976         xNewRow->SetStyleName(pOldRow->GetStyleName());
 977         for(sal_Int32 j=pCellMark[i]+1;j<=pOldRow->GetCellCount();j++)
 978         {
 979             xNewCell = pOldRow->GetCell(j);
 980             xNewRow->AddCell(xNewCell);
 981         }
 982         xSubTable2->AddRow(xNewRow);
 983
 984     }
 985     ConvertColumn(xSubTable2, nFirstColSpann, nCol);//add column info
 986     xXFCell2->Add(xSubTable2.get());
 987     xXFCell2->SetColumnSpaned(nCol-nFirstColSpann);
 988     xXFRow->AddCell(xXFCell2);
 989
 990     pXFTable->AddHeaderRow(xXFRow.get());
 991
 992     //remove tmp table
 993     for (i=1;i<=nRowNum;i++)
 994     {
 995         pTmpTable->RemoveRow(i);
 996     }
 997 }
 998
 999 /**
1000  * @short   find if the heading rows can be split to 2 cells
1001  * @param  pXFTable - pointer of tmp XFtable
1002  * @param  CellMark - pointer of cell mark array
1003  */
1004 bool  LwpTableLayout::FindSplitColMark(XFTable* pXFTable, std::vector<sal_uInt8>& rCellMark,
1005             sal_uInt8& nMaxColSpan)
1006 {
1007     sal_uInt16 nRowNum = pXFTable->GetRowCount();
1008     sal_uInt8 nColNum = static_cast<sal_uInt8>(pXFTable->GetColumnCount());
1009     sal_uInt8 nCount;
1010     sal_uInt8 nColSpan;
1011     bool bFindFlag = false;
1012     XFRow* pTmpRow;
1013
1014     for(sal_uInt8 i=1;i<=nColNum;i++)
1015     {
1016         sal_uInt16 nRowLoop;
1017
1018         //find current max column span
1019         nMaxColSpan = 1;
1020         for (nRowLoop=1;nRowLoop<=nRowNum;nRowLoop++)
1021         {
1022             nColSpan = 0;
1023             for(sal_uInt8 nCellLoop=1; nCellLoop<i+1; nCellLoop++)
1024             {
1025                 pTmpRow = pXFTable->GetRow(nRowLoop);
1026                 XFCell* pCell = pTmpRow->GetCell(nCellLoop);
1027                 if (pCell)
1028                     nColSpan += static_cast<sal_uInt8>(pCell->GetColSpaned());
1029                 else
1030                     return false;
1031             }
1032             if (nColSpan > nMaxColSpan)
1033                 nMaxColSpan = nColSpan;
1034             rCellMark.at(nRowLoop) = 0;//reset all cell mark to zero
1035         }
1036
1037         //find if other row has the same column
1038         for (nRowLoop=1;nRowLoop<=nRowNum;nRowLoop++)
1039         {
1040             pTmpRow = pXFTable->GetRow(nRowLoop);
1041             nCount = 0;
1042             sal_Int32 nCellMark = 0;
1043             for (sal_Int32 nCellLoop=1; nCellLoop<=pTmpRow->GetCellCount(); nCellLoop++)
1044             {
1045                 if (nCount>nMaxColSpan)
1046                     break;
1047                 nCount+= static_cast<sal_uInt8>(pTmpRow->GetCell(nCellLoop)->GetColSpaned());
1048                 if (nCount == nMaxColSpan)
1049                 {
1050                     nCellMark = nCellLoop;
1051                     break;
1052                 }
1053             }
1054             if (nCellMark == 0)
1055                 break;
1056             else
1057                 rCellMark.at(nRowLoop) = nCellMark;
1058         }
1059         for(nRowLoop=1;nRowLoop<=nRowNum;nRowLoop++)//check if all ==0,break
1060         {
1061             if (rCellMark.at(nRowLoop) == 0)
1062                 break;
1063         }
1064         if (nRowLoop == nRowNum+1)
1065         {
1066             bFindFlag = true;
1067             return bFindFlag;
1068         }
1069
1070     }
1071     return bFindFlag;
1072 }
1073
1074 static bool operator==(const TableConvertAttempt& a, const TableConvertAttempt& b)
1075 {
1076     return a.mnStartRow == b.mnStartRow &&
1077            a.mnEndRow == b.mnEndRow &&
1078            a.mnStartCol== b.mnStartCol &&
1079            a.mnEndCol == b.mnEndCol;
1080 }
1081
1082 /**
1083  * @short   convert word pro table to SODC table
1084  * @param  pXFTable - pointer of table
1085  * @param  nStartRow - start row ID
1086  * @param  nEndRow - end row ID
1087  * @param  nStartCol - start column ID
1088  * @param  nEndCol - end column ID
1089  */
1090 void LwpTableLayout::ConvertTable(rtl::Reference<XFTable> const & pXFTable, sal_uInt16 nStartRow,
1091                 sal_uInt16 nEndRow,sal_uInt8 nStartCol,sal_uInt8 nEndCol)
1092 {
1093     TableConvertAttempt aConversionAttempt(nStartRow, nEndRow, nStartCol, nEndCol);
1094     auto itr = std::find(m_aConvertingStack.begin(), m_aConvertingStack.end(), aConversionAttempt);
1095     if (itr != m_aConvertingStack.end())
1096     {
1097         SAL_WARN("lwp", "already trying to convert this range");
1098         return;
1099     }
1100
1101     m_aConvertingStack.push_back(aConversionAttempt);
1102
1103     //out put column info TO BE CHANGED
1104     ConvertColumn(pXFTable,nStartCol,nEndCol);
1105
1106     std::map<sal_uInt16,LwpRowLayout*>::iterator iter;
1107
1108     for (sal_uInt16 i=nStartRow; i<nEndRow;)
1109     {
1110         iter = m_RowsMap.find(i);
1111         if (iter == m_RowsMap.end())
1112         {
1113             ConvertDefaultRow(pXFTable,nStartCol,nEndCol,i);
1114             i++;
1115         }
1116         else
1117         {
1118             LwpRowLayout* pRow = iter->second;
1119             if (pRow->GetCurMaxSpannedRows(nStartCol,nEndCol) == 1)
1120             {
1121                 pRow->ConvertCommonRow(pXFTable,nStartCol,nEndCol);
1122                 i++;
1123             }
1124             else
1125             {
1126                 pRow->ConvertRow(pXFTable,nStartCol,nEndCol);
1127                 i += pRow->GetCurMaxSpannedRows(nStartCol,nEndCol);
1128             }
1129         }
1130     }
1131
1132     m_aConvertingStack.pop_back();
1133 }
1134
1135 /**
1136  * @short   apply numeric value and formula to cell
1137  * @param  pFoundry - pointer of foundry
1138  * @param  aTableID - table ID
1139  */
1140 void LwpTableLayout::PutCellVals(LwpFoundry* pFoundry, LwpObjectID aTableID)
1141 {
1142
1143     // The old code doesn't check if the LwpFoundry pointer is NULL, so the NULL
1144     // pointer cause sodc frozen. Add code to check the pointer.
1145     if( !pFoundry ) return;
1146
1147     try{
1148
1149         LwpDLVListHeadHolder* pHolder = dynamic_cast<LwpDLVListHeadHolder*>(pFoundry->GetNumberManager().GetTableRangeID().obj().get());
1150
1151         LwpTableRange* pTableRange = pHolder ? dynamic_cast<LwpTableRange*>(pHolder->GetHeadID().obj().get()) : nullptr;
1152
1153         //Look up the table
1154         o3tl::sorted_vector<LwpTableRange*> aTableSeen;
1155         while (pTableRange)
1156         {
1157             bool bAlreadySeenTable = !aTableSeen.insert(pTableRange).second;
1158             if (bAlreadySeenTable)
1159                 throw std::runtime_error("loop in conversion");
1160             LwpObjectID aID = pTableRange->GetTableID();
1161             if (aID == aTableID)
1162             {
1163                 break;
1164             }
1165             pTableRange = pTableRange->GetNext();
1166         }
1167
1168         if (!pTableRange)
1169             return;
1170
1171         LwpCellRange* pRange = dynamic_cast<LwpCellRange*>(pTableRange->GetCellRangeID().obj().get());
1172         if (!pRange)
1173             return;
1174
1175         LwpFolder* pFolder = dynamic_cast<LwpFolder*>(pRange->GetFolderID().obj().get());
1176         if (!pFolder)
1177             return;
1178
1179         LwpObjectID aRowListID = pFolder->GetChildHeadID();
1180         LwpRowList* pRowList = dynamic_cast<LwpRowList*>(aRowListID.obj().get());
1181
1182         //loop the rowlist
1183         o3tl::sorted_vector<LwpRowList*> aOuterSeen;
1184         while (pRowList)
1185         {
1186             bool bAlreadySeenOuter = !aOuterSeen.insert(pRowList).second;
1187             if (bAlreadySeenOuter)
1188                 throw std::runtime_error("loop in conversion");
1189             sal_uInt16 nRowID =  pRowList->GetRowID();
1190             {
1191                 LwpCellList* pCellList = dynamic_cast<LwpCellList*>(pRowList->GetChildHeadID().obj().get());
1192                 //loop the cellList
1193                 o3tl::sorted_vector<LwpCellList*> aSeen;
1194                 while (pCellList)
1195                 {
1196                     bool bAlreadySeen = !aSeen.insert(pCellList).second;
1197                     if (bAlreadySeen)
1198                         throw std::runtime_error("loop in conversion");
1199
1200                     {//put cell
1201                         sal_uInt16 nColID = pCellList->GetColumnID();
1202
1203                         XFCell* pCell = GetCellsMap(nRowID,static_cast<sal_uInt8>(nColID));
1204                         if (!pCell)
1205                         {
1206                             throw std::runtime_error("Hidden cell would not be in cellsmap");
1207                         }
1208
1209                         pCellList->Convert(pCell, this);
1210
1211                         //process paragraph
1212                         PostProcessParagraph(pCell, nRowID, nColID);
1213
1214                     }
1215                     pCellList = dynamic_cast<LwpCellList*>(pCellList->GetNextID().obj().get());
1216                 }
1217             }
1218             pRowList = dynamic_cast<LwpRowList*>(pRowList->GetNextID().obj().get());
1219         }
1220
1221     }catch (...) {
1222         SAL_WARN("lwp", "bad PutCellVals");
1223     }
1224 }
1225
1226 /**
1227  * @short   1. set number right alignment to right if number 2. remove tab added before if number
1228  * @param  pCell - cell which to be process
1229  * @param  nRowID - row number in Word Pro file
1230  * @param  nColID - column number in Word Pro file
1231  */
1232 void LwpTableLayout::PostProcessParagraph(XFCell *pCell, sal_uInt16 nRowID, sal_uInt16 nColID)
1233 {
1234     // if number right, set alignment to right
1235     LwpCellLayout * pCellLayout = GetCellByRowCol(nRowID, nColID);
1236     if(!pCellLayout)
1237         return;
1238
1239     rtl::Reference<XFContent> first(
1240         pCell->FindFirstContent(enumXFContentPara));
1241     XFParagraph * pXFPara = static_cast<XFParagraph*>(first.get());
1242     if (!pXFPara)
1243         return;
1244     XFColor aNullColor;
1245
1246     OUString sNumfmt = pCellLayout->GetNumfmtName();
1247     bool bColorMod = false;
1248     XFNumberStyle* pNumStyle = nullptr;
1249     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1250     if (!sNumfmt.isEmpty())
1251     {
1252         pNumStyle = static_cast<XFNumberStyle*>(pXFStyleManager->FindStyle(sNumfmt));
1253         XFColor aColor = pNumStyle->GetColor();
1254         if ( aColor != aNullColor )
1255             bColorMod = true;//end
1256     }
1257
1258     XFParaStyle * pStyle = pXFStyleManager->FindParaStyle(pXFPara->GetStyleName());
1259     if (!((pStyle && pStyle->GetNumberRight()) || bColorMod))
1260         return;
1261
1262     std::unique_ptr<XFParaStyle> xOverStyle(new XFParaStyle);
1263
1264     if (pStyle)
1265     {
1266         *xOverStyle = *pStyle;
1267
1268         if (pStyle->GetNumberRight())
1269             xOverStyle->SetAlignType(enumXFAlignEnd);
1270     }
1271
1272     if (bColorMod)
1273     {
1274         rtl::Reference<XFFont> xFont = xOverStyle->GetFont();
1275         if (xFont.is())
1276         {
1277             XFColor aColor = xFont->GetColor();
1278             if (aColor == aNullColor)
1279             {
1280                 rtl::Reference<XFFont> pNewFont(new XFFont);
1281                 aColor = pNumStyle->GetColor();
1282                 pNewFont->SetColor(aColor);
1283                 xOverStyle->SetFont(pNewFont);
1284             }
1285         }
1286     }
1287
1288     xOverStyle->SetStyleName(u""_ustr);
1289     OUString StyleName
1290         = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
1291
1292     pXFPara->SetStyleName(StyleName);
1293 }
1294
1295 /**
1296  * @short   Parse all cols of table
1297  * @param  pXFTable - pointer to created XFTable
1298  */
1299 void LwpTableLayout::ConvertColumn(rtl::Reference<XFTable> const & pXFTable, sal_uInt8 nStartCol, sal_uInt8 nEndCol)
1300 {
1301     LwpTable * pTable = GetTable();
1302     if (!pTable)
1303     {
1304         assert(false);
1305         return;
1306     }
1307
1308     for (sal_uInt32 iLoop = 0; iLoop < static_cast<sal_uInt32>(nEndCol)-nStartCol; ++iLoop)
1309     {
1310         // add row to table
1311         LwpObjectID *pColID = &GetColumnLayoutHead();
1312         LwpColumnLayout * pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColID->obj().get());
1313         while (pColumnLayout)
1314         {
1315             if (pColumnLayout->GetColumnID() == (iLoop+nStartCol))
1316             {
1317                 pXFTable->SetColumnStyle(iLoop+1,  pColumnLayout->GetStyleName());
1318                 break;
1319             }
1320             pColID = &pColumnLayout->GetNext();
1321             pColumnLayout = dynamic_cast<LwpColumnLayout *>(pColID->obj().get());
1322         }
1323         if (!pColumnLayout)
1324         {
1325             pXFTable->SetColumnStyle(iLoop+1, m_DefaultColumnStyleName);
1326         }
1327     }
1328 }
1329 /**
1330  * @short   split conflict merged cells
1331  */
1332 void LwpTableLayout::SplitConflictCells()
1333 {
1334     LwpTable * pTable = GetTable();
1335     if (!pTable)
1336         return;
1337     sal_uInt16 nCol = pTable->GetColumn();
1338     sal_uInt16 nRow = pTable->GetRow();
1339
1340     sal_uInt16 nEffectRows;
1341     std::map<sal_uInt16,LwpRowLayout*>::iterator iter1;
1342     std::map<sal_uInt16,LwpRowLayout*>::iterator iter2;
1343     LwpRowLayout* pRowLayout;
1344     LwpRowLayout* pEffectRow;
1345
1346     for (sal_uInt16 i=0; i<nRow; )
1347     {
1348         iter1 = m_RowsMap.find(i);
1349         if (iter1 == m_RowsMap.end())//default rows
1350         {
1351             i++;
1352             continue;
1353         }
1354         pRowLayout= iter1->second;
1355         if (!pRowLayout->GetMergeCellFlag())
1356         {
1357             i++;
1358             continue;
1359         }
1360         else
1361         {
1362             nEffectRows = i + pRowLayout->GetCurMaxSpannedRows(0,static_cast<sal_uInt8>(nCol));
1363
1364             for (sal_uInt16 j = i+1; j<nEffectRows; j++)
1365             {
1366                 iter2 = m_RowsMap.find(j);
1367                 if (iter2 == m_RowsMap.end())
1368                         continue;
1369                 pEffectRow = iter2->second;
1370                 if (!pEffectRow->GetMergeCellFlag())
1371                     continue;
1372                 else
1373                     pEffectRow->SetCellSplit(nEffectRows);
1374             }
1375             i = nEffectRows;
1376         }
1377     }//end for
1378
1379 }
1380 /**
1381  * @short   add default row which are missing in the file
1382  * @param   pXFTable - pointer to new created table
1383  * @param   nStartCol - starting column
1384  * @param   nEndCol  - end column
1385  * @return   pXFTable
1386  */
1387 void LwpTableLayout::ConvertDefaultRow(rtl::Reference<XFTable> const & pXFTable, sal_uInt8 nStartCol,
1388          sal_uInt8 nEndCol, sal_uInt16 nRowID)
1389 {
1390     // current row doesn't exist in the file
1391     rtl::Reference<XFRow> xRow(new XFRow);
1392     xRow->SetStyleName(m_DefaultRowStyleName);
1393
1394     for (sal_uInt16 j =0;j < nEndCol-nStartCol; j++)
1395     {
1396         // if table has default cell layout, use it to ConvertCell
1397         // otherwise use blank cell
1398         rtl::Reference<XFCell> xCell;
1399         if (m_pDefaultCellLayout)
1400         {
1401             LwpTable* pTable = GetTable();
1402             assert(pTable);
1403             xCell = m_pDefaultCellLayout->DoConvertCell(
1404                 pTable->GetObjectID(),nRowID,j+nStartCol);
1405         }
1406         else
1407         {
1408             xCell.set(new XFCell);
1409         }
1410         xRow->AddCell(xCell);
1411     }
1412
1413     pXFTable->AddRow(xRow);
1414 }
1415
1416 /**
1417  * @short   set cell map info
1418  * @param   pXFCell - pointer to xfcell
1419  * @param   nRow - row id
1420  * @param   nCol - column id
1421  */
1422 void LwpTableLayout::SetCellsMap(sal_uInt16 nRow1, sal_uInt8 nCol1,
1423                                  sal_uInt16 nRow2, sal_uInt8 nCol2, XFCell* pXFCell)
1424 {
1425     m_CellsMap.insert({{nRow1, nCol1}, {nRow2, nCol2}}, pXFCell);
1426 }
1427
1428 /**
1429  * @short   get cell map info
1430  * @param   nRow - row id
1431  * @param   nCol  - column id
1432  * @return  pXFCell
1433  */
1434 XFCell* LwpTableLayout::GetCellsMap(sal_uInt16 nRow, sal_uInt8 nCol)
1435 {
1436     auto results = m_CellsMap.search({{nRow, nCol}, {nRow, nCol}}, rt_type::search_type::overlap);
1437     if (results.begin() == results.end())
1438        return nullptr;
1439     // return the last thing inserted for this position
1440     return std::prev(results.end())->GetCell();
1441 }
1442 /**
1443  * @descr   Get row layout by row id
1444  * @param   nRow - row id
1445  */
1446 LwpRowLayout* LwpTableLayout::GetRowLayout(sal_uInt16 nRow)
1447 {
1448     LwpObjectID *pRowID = &GetChildHead();
1449     LwpRowLayout * pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
1450     while (pRowLayout)
1451     {
1452         if(pRowLayout->GetRowID() == nRow)
1453             return pRowLayout;
1454
1455         pRowID = &pRowLayout->GetNext();
1456         pRowLayout = dynamic_cast<LwpRowLayout *>(pRowID->obj().get());
1457     }
1458     return nullptr;
1459 }
1460
1461 //add end by
1462 LwpColumnLayout::LwpColumnLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
1463     : LwpVirtualLayout(objHdr, pStrm)
1464     , ccolid(0)
1465     , cwidth(0)
1466 {}
1467
1468 LwpColumnLayout::~LwpColumnLayout()
1469 {}
1470 void LwpColumnLayout::Read()
1471 {
1472     LwpObjectStream* pStrm = m_pObjStrm.get();
1473
1474     LwpVirtualLayout::Read();
1475
1476     sal_uInt16 colid;
1477
1478     colid = pStrm->QuickReaduInt16();   // forced to lushort
1479     ccolid = static_cast<sal_uInt8>(colid);
1480     cwidth = pStrm->QuickReadInt32();
1481
1482     pStrm->SkipExtra();
1483 }
1484
1485 void LwpColumnLayout::RegisterStyle(double dCalculatedWidth)
1486 {
1487     std::unique_ptr<XFColStyle> xColStyle(new XFColStyle);
1488     xColStyle->SetWidth(static_cast<float>(dCalculatedWidth));
1489     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1490     m_StyleName = pXFStyleManager->AddStyle(std::move(xColStyle)).m_pStyle->GetStyleName();
1491 }
1492
1493 LwpTableHeadingLayout::LwpTableHeadingLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
1494     : LwpTableLayout(objHdr, pStrm)
1495     , cStartRow(0)
1496     , cEndRow(0)
1497 {}
1498
1499 LwpTableHeadingLayout::~LwpTableHeadingLayout()
1500 {}
1501 /**
1502  * @short   read table heading layout
1503  * @param
1504  * @return
1505  */
1506 void LwpTableHeadingLayout::Read()
1507 {
1508     LwpTableLayout::Read();
1509
1510     cStartRow = m_pObjStrm->QuickReaduInt16();
1511     cEndRow = m_pObjStrm->QuickReaduInt16();
1512
1513     m_pObjStrm->SkipExtra();
1514
1515 }
1516 /**
1517  * @short   get start and end row number of table heading
1518  * @param
1519  * @return *pStartRow - starting row number
1520  * @return *pEndRow -   end row number
1521  */
1522 void LwpTableHeadingLayout::GetStartEndRow(sal_uInt16& nStartRow, sal_uInt16& nEndRow)
1523 {
1524     nStartRow = cStartRow;
1525     nEndRow = cEndRow;
1526 }
1527
1528 LwpSuperParallelColumnLayout::LwpSuperParallelColumnLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm):LwpSuperTableLayout(objHdr, pStrm)
1529 {
1530 }
1531 LwpSuperParallelColumnLayout::~LwpSuperParallelColumnLayout()
1532 {}
1533
1534 void LwpSuperParallelColumnLayout::Read()
1535 {
1536     LwpSuperTableLayout::Read();
1537     m_pObjStrm->SkipExtra();
1538
1539 }
1540
1541 LwpSuperGlossaryLayout::LwpSuperGlossaryLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm):LwpSuperTableLayout(objHdr, pStrm)
1542 {
1543 }
1544
1545 LwpSuperGlossaryLayout::~LwpSuperGlossaryLayout()
1546 {
1547 }
1548
1549 void LwpSuperGlossaryLayout::Read()
1550 {
1551     LwpSuperTableLayout::Read();
1552     m_pObjStrm->SkipExtra();
1553 }
1554
1555 LwpParallelColumnsLayout::LwpParallelColumnsLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm):LwpTableLayout(objHdr, pStrm)
1556 {
1557 }
1558
1559 LwpParallelColumnsLayout::~LwpParallelColumnsLayout()
1560 {
1561 }
1562
1563 void LwpParallelColumnsLayout::Read()
1564 {
1565     LwpTableLayout::Read();
1566     m_pObjStrm->SkipExtra();
1567 }
1568
1569 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */