lotuswordpro/source/filter/lwpcelllayout.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 - cell layouts
  59  */
  60
  61 #include <memory>
  62 #include "lwpcelllayout.hxx"
  63 #include "lwpnumericfmt.hxx"
  64 #include "lwptable.hxx"
  65 #include "lwprowlayout.hxx"
  66 #include <lwpfilehdr.hxx>
  67 #include <lwpglobalmgr.hxx>
  68
  69 #include <sal/log.hxx>
  70 #include <comphelper/configuration.hxx>
  71
  72 #include <xfilter/xfstylemanager.hxx>
  73 #include <xfilter/xfcell.hxx>
  74 #include <xfilter/xfcellstyle.hxx>
  75 #include <xfilter/xfcolstyle.hxx>
  76
  77 LwpCellLayout::LwpCellLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
  78     : LwpMiddleLayout(objHdr, pStrm)
  79     , m_bConvertCell(false)
  80     , crowid(0)
  81     , ccolid(0)
  82     , cType(LDT_NONE)
  83 {
  84 }
  85
  86 LwpCellLayout::~LwpCellLayout()
  87 {}
  88
  89 /**
  90  * @short   Get table layout pointer, if default cell layout, return NULL
  91  * @param LwpTableLayout *
  92  * @return
  93  */
  94 LwpTableLayout * LwpCellLayout::GetTableLayout()
  95 {
  96     LwpRowLayout * pRow = dynamic_cast<LwpRowLayout *>(GetParent().obj().get());
  97     if(!pRow)
  98     {
  99         return nullptr;
 100     }
 101     LwpTableLayout * pTableLayout = pRow->GetParentTableLayout();
 102     return pTableLayout;
 103 }
 104 /**
 105  * @short   Get table pointer, if default cell layout, return NULL
 106  * @param LwpTable *
 107  * @return
 108  */
 109 LwpTable * LwpCellLayout::GetTable()
 110 {
 111     LwpTableLayout * pTableLayout = GetTableLayout();
 112     if(!pTableLayout)
 113     {
 114         return nullptr;
 115     }
 116     LwpTable *pTable = pTableLayout->GetTable();
 117     return pTable;
 118 }
 119 /**
 120  * @short   Set current cell layout to cell layout map
 121  * @param
 122  * @return
 123  */
 124 void LwpCellLayout::SetCellMap()
 125 {
 126     LwpTableLayout * pTableLayout = GetTableLayout();
 127     if (pTableLayout)
 128         pTableLayout->SetWordProCellMap(crowid, ccolid, this);
 129 }
 130 /**
 131  * @short  Get actual width of this cell layout
 132  * @param
 133  * @return width (cm)
 134  */
 135 double LwpCellLayout::GetActualWidth()
 136 {
 137     //Get table layout
 138     LwpTableLayout * pTableLayout = GetTableLayout();
 139
 140     if (pTableLayout == nullptr)
 141     {
 142         return GetGeometryWidth();
 143     }
 144
 145     OUString strColStyle = pTableLayout->GetColumnWidth(ccolid);
 146
 147     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 148     XFColStyle *pStyle = static_cast<XFColStyle *>(pXFStyleManager->FindStyle(strColStyle));
 149     if(pStyle)
 150     {
 151         return pStyle->GetWidth();
 152     }
 153
 154     return GetGeometryWidth();
 155 }
 156
 157 /**
 158  * @short   Apply padding to cell style
 159  * @param pCellStyle - pointer of XFCellStyle
 160  * @return
 161  */
 162 void LwpCellLayout::ApplyPadding(XFCellStyle *pCellStyle)
 163 {
 164     double fLeft = GetMarginsValue(MARGIN_LEFT);
 165     double fRight = GetMarginsValue(MARGIN_RIGHT);
 166     double fTop = GetMarginsValue(MARGIN_TOP);
 167     double fBottom = GetMarginsValue(MARGIN_BOTTOM);
 168     pCellStyle->SetPadding(static_cast<float>(fLeft),static_cast<float>(fRight),static_cast<float>(fTop),static_cast<float>(fBottom));
 169 }
 170 /**
 171  * @short   Apply border to cell style according to cell position, default cell layout won't use this function
 172  * @param
 173  * @return pCellStyle - pointer of XFCellStyle
 174  */
 175 void LwpCellLayout::ApplyBorders(XFCellStyle *pCellStyle)
 176 {
 177     // judge cell border type
 178     LwpCellBorderType eType = GetCellBorderType(crowid, ccolid, GetTableLayout());
 179
 180     // get left cell and judge if neighbour border is different
 181     std::unique_ptr<XFBorders> xBorders(GetXFBorders());
 182     if (!xBorders)
 183     {
 184         return;
 185     }
 186
 187     switch (eType)
 188     {
 189     case enumNoBottomBorder:
 190         xBorders->SetWidth(enumXFBorderBottom, 0);
 191         break;
 192     case enumNoLeftBorder:
 193         xBorders->SetWidth(enumXFBorderLeft, 0);
 194         break;
 195     case enumNoLeftNoBottomBorder:
 196         xBorders->SetWidth(enumXFBorderBottom, 0);
 197         xBorders->SetWidth(enumXFBorderLeft, 0);
 198         break;
 199     case enumWholeBorder:
 200         break;
 201     default:
 202         assert(false);
 203     }
 204     pCellStyle->SetBorders(xBorders.release());
 205 }
 206 /**
 207  * @short   Apply watermark to cell style
 208  * @param pCellStyle - pointer of XFCellStyle
 209  * @return
 210  */
 211 void LwpCellLayout::ApplyWatermark(XFCellStyle *pCellStyle)
 212 {
 213     std::unique_ptr<XFBGImage> xBGImage(GetXFBGImage());
 214     if (xBGImage)
 215     {
 216         pCellStyle->SetBackImage(xBGImage);
 217     }
 218 }
 219
 220 /**
 221  * @short   Apply pattern fill to cell style
 222  * @param pCellStyle - pointer of XFCellStyle
 223  * @return
 224  */
 225 void LwpCellLayout::ApplyPatternFill(XFCellStyle* pCellStyle)
 226 {
 227     std::unique_ptr<XFBGImage> xXFBGImage(GetFillPattern());
 228     if (xXFBGImage)
 229     {
 230         pCellStyle->SetBackImage(xXFBGImage);
 231     }
 232 }
 233
 234 /**
 235  * @short   Apply background to cell style
 236  * @param pCellStyle - pointer of XFCellStyle
 237  * @return
 238  */
 239 void LwpCellLayout::ApplyBackGround(XFCellStyle* pCellStyle)
 240 {
 241     if (IsPatternFill())
 242     {
 243         ApplyPatternFill(pCellStyle);
 244     }
 245     else
 246     {
 247         ApplyBackColor(pCellStyle);
 248     }
 249 }
 250 /**
 251  * @short   Apply back color to cell style
 252  * @param pCellStyle - pointer of XFCellStyle
 253  * @return
 254  */
 255 void LwpCellLayout::ApplyBackColor(XFCellStyle *pCellStyle)
 256 {
 257     LwpColor* pColor = GetBackColor();
 258     if(pColor && pColor->IsValidColor())
 259     {
 260         XFColor aXFColor(pColor->To24Color());
 261         pCellStyle->SetBackColor(aXFColor);
 262     }
 263 }
 264 /**
 265  * @short   register style of cell layout
 266  * @param pCellStyle The style of the cell, which would be applied to the cell.
 267  * @return
 268  */
 269 void LwpCellLayout::ApplyFmtStyle(XFCellStyle *pCellStyle)
 270 {
 271     LwpLayoutNumerics* pLayoutNumerics = dynamic_cast<LwpLayoutNumerics*>(cLayNumerics.obj().get());
 272     if (!pLayoutNumerics)
 273     {
 274         // if current layout doesn't have format, go to based on layout
 275         LwpCellLayout* pCellLayout = dynamic_cast<LwpCellLayout*>(GetBasedOnStyle().get());
 276         if (pCellLayout)
 277         {
 278             pLayoutNumerics = dynamic_cast<LwpLayoutNumerics*>(pCellLayout->GetNumericsObject().obj().get());
 279         }
 280     }
 281
 282     // apply format style
 283     if (pLayoutNumerics)
 284     {
 285         XFStyle* pStyle = pLayoutNumerics->Convert();
 286         if (pStyle)
 287         {
 288             XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 289             m_NumfmtName = pXFStyleManager->AddStyle(std::unique_ptr<XFStyle>(pStyle)).m_pStyle->GetStyleName();
 290             pCellStyle->SetDataStyle(m_NumfmtName);
 291         }
 292     }
 293 }
 294 /**
 295  * @short   get style name according to cell position, only table default cells use this function
 296  * @param   nRow - default cell position row number
 297  * @param   nCol - default cell position col number
 298  * @return  OUString - registered cell style name
 299  */
 300 OUString const & LwpCellLayout::GetCellStyleName(sal_uInt16 nRow, sal_uInt16 nCol, LwpTableLayout * pTableLayout)
 301 {
 302     // judge cell border type
 303     LwpCellBorderType eType = GetCellBorderType(nRow, nCol, pTableLayout);
 304     return m_CellStyleNames[eType];
 305 }
 306 /**
 307 *   Make the XFCell
 308 *   @param  aTableID - ID of the table which this cell belongs to
 309 *   @param  bIsTopRow - whether current cell is top row
 310 *   @param  bIsRightCol - whether current cell is the rightest column
 311 *   @return XFCell*
 312 */
 313 rtl::Reference<XFCell> LwpCellLayout::ConvertCell(LwpObjectID aTableID, sal_uInt16 nRow, sal_uInt16 nCol)
 314 {
 315     // if cell layout is aTableID's default cell layout
 316     // it can't have any content, bypass these code
 317     LwpTable * pTable = dynamic_cast<LwpTable *>(aTableID.obj().get());
 318     if (!pTable)
 319     {
 320         assert(false);
 321         return nullptr;
 322     }
 323     rtl::Reference<XFCell> xXFCell(new XFCell);
 324     OUString aStyleName = m_StyleName;
 325
 326     // if cell layout is aTableID's default cell layout
 327     // we should adjust its style by current position
 328     if (pTable->GetDefaultCellStyle() == GetObjectID())
 329     {
 330         aStyleName = GetCellStyleName(nRow, nCol, pTable->GetTableLayout().get());
 331     }
 332
 333     // content of cell
 334     LwpStory* pStory = dynamic_cast<LwpStory*>(m_Content.obj().get());
 335     if (pStory)
 336     {
 337         pStory->XFConvert(xXFCell.get());
 338     }
 339
 340     ApplyProtect(xXFCell.get(), aTableID);
 341     xXFCell->SetStyleName(aStyleName);
 342     return xXFCell;
 343 }
 344
 345 LwpPara* LwpCellLayout::GetLastParaOfPreviousStory()
 346 {
 347     LwpObjectID* pPreStoryID = GetPreviousCellStory();
 348     if (pPreStoryID && !(pPreStoryID->IsNull()))
 349     {
 350         LwpStory* pPreStory = dynamic_cast<LwpStory*>(pPreStoryID->obj(VO_STORY).get());
 351         if (!pPreStory)
 352         {
 353             SAL_WARN("lwp", "unexpected null VO_STORY");
 354             return nullptr;
 355         }
 356         return dynamic_cast<LwpPara*>(pPreStory->GetLastPara().obj(VO_PARA).get());
 357     }
 358     else
 359     {
 360         return nullptr;
 361     }
 362 }
 363
 364 /**
 365  * @short    Get previous cell which used for bullet inside cell
 366  * @param
 367  * @return   LwpObjectID * - object ID of cell content story
 368  */
 369 LwpObjectID * LwpCellLayout::GetPreviousCellStory()
 370 {
 371     LwpTable *pTable = GetTable();
 372     if (!pTable)
 373     {
 374         assert(false);
 375         return nullptr;
 376     }
 377     sal_uInt16 nRow = crowid;
 378     sal_uInt16 nCol = ccolid;
 379
 380     // if table is reset paragraph in columns, get cell on the top side of current cell
 381     if (pTable->IsNumberDown())
 382     {
 383         if (nRow == 0)
 384         {
 385             return nullptr;
 386         }
 387         nRow -=1;
 388     }
 389     else
 390     {
 391         // if not, get cell on the left side of current cell
 392         if (nCol == 0)
 393         {
 394             if (nRow == 0)
 395             {
 396                 return nullptr;
 397             }
 398             else
 399             {
 400                 nRow--;
 401                 nCol = pTable->GetColumn() - 1;
 402             }
 403         }
 404         else
 405         {
 406             nCol -=1;
 407         }
 408     }
 409
 410     // get the object id pointer of previous cell story
 411     LwpTableLayout * pTableLayout = GetTableLayout();
 412     if (!pTableLayout)
 413     {
 414         assert(false);
 415         return nullptr;
 416     }
 417     return pTableLayout->SearchCellStoryMap(nRow, nCol);
 418 }
 419
 420 /**
 421  * @short   judge border type by cell neighbour
 422  * @param nRow
 423  * @param nCol
 424  * @param pTableLayout
 425  * @return   LwpCellBorderType
 426  */
 427 LwpCellBorderType LwpCellLayout::GetCellBorderType(sal_uInt16 nRow, sal_uInt16 nCol, LwpTableLayout * pTableLayout)
 428 {
 429     if (!pTableLayout)
 430         return enumWholeBorder;
 431
 432     // get left cell and judge if neighbour border is different
 433     std::unique_ptr<XFBorders> xBorders(GetXFBorders());
 434     if (!xBorders)
 435     {
 436         return enumWholeBorder;
 437     }
 438     XFBorder& rLeftBorder = xBorders->GetLeft();
 439     XFBorder& rBottomBorder = xBorders->GetBottom();
 440     bool bNoLeftBorder = false;
 441     bool bNoBottomBorder = false;
 442
 443     LwpCellLayout * pLeftNeighbour = GetCellByRowCol(nRow, GetLeftColID(nCol), pTableLayout);
 444     if (pLeftNeighbour)
 445     {
 446         std::unique_ptr<XFBorders> pNeighbourBorders = pLeftNeighbour->GetXFBorders();
 447         if (pNeighbourBorders)
 448         {
 449             XFBorder& rRightBorder = pNeighbourBorders->GetRight();
 450             if (rLeftBorder == rRightBorder)
 451             {
 452                 // for these 2 types cell, left border should be ignored for sake of avoiding duplication border
 453                 // but if left border is different with right border of left cell
 454                 // we should not ignored it
 455                 bNoLeftBorder = true;
 456             }
 457         }
 458
 459     }
 460
 461     LwpCellLayout * pBelowNeighbour = GetCellByRowCol(GetBelowRowID(nRow), nCol, pTableLayout);
 462     if (pBelowNeighbour) //&& (eType == enumRightNotLastCellBorder || eType ==  enumLeftNotLastCellBorder) )
 463     {
 464         std::unique_ptr<XFBorders> pBelowBorders = pBelowNeighbour->GetXFBorders();
 465         if (pBelowBorders)
 466         {
 467             XFBorder& rTopBorder = pBelowBorders->GetTop();
 468             if (rTopBorder == rBottomBorder)
 469             {
 470                 // for these 2 types cell, bottom border should be ignored for sake of avoiding duplication border
 471                 // but if bottom border is different with right border of left cell
 472                 // we should not ignored it
 473                 bNoBottomBorder = true;
 474             }
 475         }
 476     }
 477
 478     xBorders.reset();
 479
 480     if (bNoBottomBorder)
 481     {
 482         if (bNoLeftBorder)
 483         {
 484             return enumNoLeftNoBottomBorder;
 485         }
 486         return enumNoBottomBorder;
 487     }
 488     if (bNoLeftBorder)
 489     {
 490         return enumNoLeftBorder;
 491     }
 492     return enumWholeBorder;
 493 }
 494
 495 /**
 496  * @short   Get neighbour cell by specifying ROW+COL
 497  * @param   nRow
 498  * @param   nCol
 499  * @return   LwpCellLayout *
 500  */
 501 LwpCellLayout * LwpCellLayout::GetCellByRowCol(sal_uInt16 nRow, sal_uInt16 nCol, LwpTableLayout * pTableLayout)
 502 {
 503     return pTableLayout->GetCellByRowCol(nRow, nCol);
 504 }
 505 /**
 506  * @short   Register table's default cell layout
 507  * @param
 508  * @return
 509  */
 510 void LwpCellLayout::RegisterDefaultCell()
 511 {
 512     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 513     for (sal_uInt16 eLoop = enumWholeBorder; eLoop < enumCellBorderTopLimit; eLoop++)
 514     {
 515         // register cell style
 516         std::unique_ptr<XFCellStyle> xCellStyle(new XFCellStyle());
 517
 518         ApplyPadding(xCellStyle.get());
 519         ApplyBackColor(xCellStyle.get());
 520         ApplyWatermark(xCellStyle.get());
 521         ApplyFmtStyle(xCellStyle.get());
 522         xCellStyle->SetAlignType(enumXFAlignNone, GetVerticalAlignmentType());
 523
 524         std::unique_ptr<XFBorders> xBorders(GetXFBorders());
 525         if (xBorders)
 526         {
 527             switch(eLoop)
 528             {
 529             case enumNoBottomBorder:
 530
 531                 //| |
 532
 533                 // remove bottom line
 534                 xBorders->SetWidth(enumXFBorderBottom, 0);
 535                 break;
 536             case enumNoLeftNoBottomBorder:
 537
 538                 //  |
 539
 540                 // remove left and bottom
 541                 xBorders->SetWidth(enumXFBorderLeft, 0);
 542                 xBorders->SetWidth(enumXFBorderBottom, 0);
 543                 break;
 544             case enumWholeBorder:
 545
 546                 //||
 547
 548                 // nothing to remove
 549                 break;
 550             case enumNoLeftBorder:
 551
 552                 //| |
 553
 554                 // remove left line
 555                 xBorders->SetWidth(enumXFBorderLeft, 0);
 556                 break;
 557             default:
 558                 assert(false);
 559             }
 560             xCellStyle->SetBorders(xBorders.release());
 561         }
 562         m_CellStyleNames[eLoop] = pXFStyleManager->AddStyle(std::move(xCellStyle)).m_pStyle->GetStyleName();
 563     }
 564 }
 565 /**
 566  * @short    Register 4 types of cell style and register content styles
 567  * @param
 568  * @param
 569  * @param
 570  * @return
 571  */
 572 void LwpCellLayout::RegisterStyle()
 573 {
 574     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout *>(GetParent().obj().get()));
 575     if (!xParent.is() || xParent->GetLayoutType() != LWP_ROW_LAYOUT)
 576     {
 577         // default cell layout, we must register 4 styles for it
 578         RegisterDefaultCell();
 579         return;
 580     }
 581
 582     // register cell style
 583     std::unique_ptr<XFCellStyle> xCellStyle(new XFCellStyle);
 584
 585     ApplyPadding(xCellStyle.get());
 586     ApplyBackGround(xCellStyle.get());
 587     ApplyWatermark(xCellStyle.get());
 588     ApplyFmtStyle(xCellStyle.get());
 589     ApplyBorders(xCellStyle.get());
 590
 591     xCellStyle->SetAlignType(enumXFAlignNone, GetVerticalAlignmentType());
 592
 593     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 594     m_StyleName = pXFStyleManager->AddStyle(std::move(xCellStyle)).m_pStyle->GetStyleName();
 595
 596     // content object register styles
 597     rtl::Reference<LwpObject> pObj = m_Content.obj();
 598     if (pObj.is())
 599     {
 600         pObj->SetFoundry(m_pFoundry);
 601         pObj->DoRegisterStyle();
 602     }
 603
 604     //register child layout style
 605     RegisterChildStyle();
 606 }
 607 /**
 608  * @short   Read cell layout
 609  * @param
 610  * @return
 611  */
 612 void LwpCellLayout::Read()
 613 {
 614     LwpObjectStream* pStrm = m_pObjStrm.get();
 615
 616     LwpMiddleLayout::Read();
 617
 618     // before the layout hierarchy rework
 619     if (LwpFileHeader::m_nFileRevision  < 0x000b)
 620     {
 621         assert(false);
 622     }
 623     else
 624     {
 625         crowid = pStrm->QuickReaduInt16();
 626         ccolid = static_cast<sal_uInt8>(pStrm->QuickReaduInt16());  // written as a lushort
 627
 628         sal_uInt16 type;
 629
 630         type = pStrm->QuickReaduInt16();
 631         pStrm->SkipExtra();
 632         cType = static_cast<LeaderDotType>(type);
 633
 634         cLayNumerics.ReadIndexed(pStrm);
 635         cLayDiagonalLine.ReadIndexed(pStrm);
 636
 637         pStrm->SkipExtra();
 638     }
 639 }
 640
 641 /**
 642 *   Apply protect attribute to cell of table
 643 *   @param  aTableID - ID of the table which the cell belongs to
 644 *   @param
 645 *   @return XFCell*
 646 */
 647 void LwpCellLayout::ApplyProtect(XFCell * pCell, LwpObjectID aTableID)
 648 {
 649     bool bProtected = false;
 650     // judge current cell
 651     if (GetIsProtected())
 652     {
 653         bProtected = true;
 654     }
 655     else
 656     {
 657         // judge base on
 658         LwpCellLayout * pBase = dynamic_cast<LwpCellLayout *>(GetBasedOnStyle().get());
 659         if (pBase && pBase->GetIsProtected())
 660         {
 661             bProtected = true;
 662         }
 663         else
 664         {
 665             // judge whole table
 666             LwpTable * pTable = dynamic_cast<LwpTable *>(aTableID.obj().get());
 667             rtl::Reference<LwpTableLayout> xTableLayout(pTable ? pTable->GetTableLayout() : nullptr);
 668             LwpSuperTableLayout * pSuper = xTableLayout.is() ? xTableLayout->GetSuperTableLayout() : nullptr;
 669             if (pSuper && pSuper->GetIsProtected())
 670             {
 671                 bProtected = true;
 672             }
 673         }
 674     }
 675
 676     pCell->SetProtect(bProtected);
 677 }
 678
 679 LwpConnectedCellLayout::LwpConnectedCellLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
 680     : LwpCellLayout(objHdr, pStrm)
 681     , cnumrows(0)
 682     , cnumcols(0)
 683     , m_nRealrowspan(0)
 684     , m_nRealcolspan(0)
 685 {
 686 }
 687
 688 LwpConnectedCellLayout::~LwpConnectedCellLayout()
 689 {}
 690 /**
 691  * @short   Set current connected cell layout to cell layout map
 692  * @param pCellLayoutMap - cell layout map reference
 693  * @return
 694  */
 695 void LwpConnectedCellLayout::SetCellMap()
 696 {
 697     LwpTableLayout * pTableLayout = GetTableLayout();
 698     if (!pTableLayout)
 699         return;
 700
 701     sal_uInt16 nRowSpan = m_nRealrowspan;
 702
 703     for (sal_uInt16 iLoop = 0; iLoop < nRowSpan; iLoop ++)
 704     {
 705         for (sal_uInt16 jLoop = 0; jLoop < cnumcols; jLoop ++)
 706             pTableLayout->SetWordProCellMap(iLoop + crowid, jLoop + ccolid, this);
 707     }
 708 }
 709
 710 /**
 711  * @short   judge border type by cell neighbour
 712  * @param nRow
 713  * @param nCol
 714  * @param pTableLayout
 715  * @return   LwpCellBorderType
 716  */
 717 LwpCellBorderType LwpConnectedCellLayout::GetCellBorderType(sal_uInt16 nRow, sal_uInt16 nCol, LwpTableLayout * pTableLayout)
 718 {
 719     if (!pTableLayout)
 720         throw std::runtime_error("missing table layout");
 721
 722     sal_uInt16 nRowSpan = m_nRealrowspan;
 723
 724     // get left cell and judge if neighbour border is different
 725     std::unique_ptr<XFBorders> xBorders(GetXFBorders());
 726     if( !xBorders)
 727     {
 728         return enumWholeBorder;
 729     }
 730     XFBorder& rLeftBorder = xBorders->GetLeft();
 731     XFBorder& rBottomBorder = xBorders->GetBottom();
 732     bool bNoLeftBorder = true;
 733     bool bNoBottomBorder = true;
 734
 735     if (nCol == 0)
 736     {
 737         bNoLeftBorder = false;
 738     }
 739     else
 740     {
 741         for (sal_uInt16 iLoop=0; iLoop < nRowSpan; iLoop++)
 742         {
 743             LwpCellLayout * pLeftNeighbour = GetCellByRowCol(nRow+iLoop, GetLeftColID(nCol), pTableLayout);
 744             if (pLeftNeighbour)
 745             {
 746                 std::unique_ptr<XFBorders> pNeighbourBorders(pLeftNeighbour->GetXFBorders());
 747                 if (pNeighbourBorders)
 748                 {
 749                     XFBorder& rRightBorder = pNeighbourBorders->GetRight();
 750                     if (rLeftBorder != rRightBorder)
 751                     {
 752                         // if left border is different with right border of left cell
 753                         // we should not ignored it
 754                         bNoLeftBorder = false;
 755                         break;
 756                     }
 757                 }
 758             }
 759         }
 760     }
 761
 762     LwpTable* pTable = pTableLayout->GetTable();
 763     if (!pTable)
 764         throw std::runtime_error("missing table");
 765
 766     if ( (nRow + nRowSpan) == pTable->GetRow())
 767     {
 768         bNoBottomBorder = false;
 769     }
 770     else
 771     {
 772         for (sal_uInt16 iLoop = 0; iLoop < cnumcols; iLoop ++)
 773         {
 774             LwpCellLayout * pBelowNeighbour = GetCellByRowCol(nRow + nRowSpan, nCol+iLoop, pTableLayout);
 775             if (pBelowNeighbour)
 776             {
 777                 std::unique_ptr<XFBorders> pBelowBorders(pBelowNeighbour->GetXFBorders());
 778                 if (pBelowBorders)
 779                 {
 780                     XFBorder& rTopBorder = pBelowBorders->GetTop();
 781                     if (rTopBorder != rBottomBorder)
 782                     {
 783                         // if bottom border is different with right border of left cell
 784                         // we should not ignored it
 785                         bNoBottomBorder = false;
 786                         break;
 787                     }
 788                 }
 789             }
 790         }
 791     }
 792
 793     xBorders.reset();
 794
 795     if (bNoBottomBorder)
 796     {
 797         if (bNoLeftBorder)
 798         {
 799             return enumNoLeftNoBottomBorder;
 800         }
 801         return enumNoBottomBorder;
 802     }
 803     if (bNoLeftBorder)
 804     {
 805         return enumNoLeftBorder;
 806     }
 807     return enumWholeBorder;
 808 }
 809 /**
 810  * @short   Read connected cell layout
 811  * @param
 812  * @return
 813  */
 814 void LwpConnectedCellLayout::Read()
 815 {
 816     LwpCellLayout::Read();
 817
 818     cnumrows = m_pObjStrm->QuickReaduInt16();
 819     sal_uInt16 numcols = m_pObjStrm->QuickReaduInt16();        // written as a lushort
 820     cnumcols = static_cast<sal_uInt8>(numcols);
 821
 822     m_nRealrowspan = cnumrows;
 823     if (comphelper::IsFuzzing())
 824         m_nRealrowspan = std::min<sal_uInt16>(m_nRealrowspan, 128);
 825     m_nRealcolspan = cnumcols;
 826
 827     m_pObjStrm->SkipExtra();
 828 }
 829
 830 rtl::Reference<XFCell> LwpConnectedCellLayout::ConvertCell(LwpObjectID aTableID, sal_uInt16 nRow, sal_uInt16 nCol)
 831 {
 832     rtl::Reference<XFCell> xXFCell = LwpCellLayout::ConvertCell(aTableID, nRow, nCol);
 833     xXFCell->SetColumnSpaned(cnumcols);
 834     return xXFCell;
 835 }
 836
 837 /**
 838  * @short   parse connected cell layout
 839  * @param pOutputStream - output stream
 840  * @return
 841  */
 842 void LwpConnectedCellLayout::Parse(IXFStream* /*pOutputStream*/)
 843 {
 844 }
 845
 846 LwpHiddenCellLayout::LwpHiddenCellLayout(LwpObjectHeader const &objHdr, LwpSvStream* pStrm)
 847     : LwpCellLayout(objHdr, pStrm)
 848 {}
 849
 850 LwpHiddenCellLayout::~LwpHiddenCellLayout()
 851 {}
 852 /**
 853  * @short   Set current hidden cell layout to cell layout map
 854  * @param
 855  * @return
 856  */
 857 void LwpHiddenCellLayout::SetCellMap()
 858 {
 859 }
 860 /**
 861  * @short   Read hidden cell layout
 862  * @param
 863  * @return
 864  */
 865 void LwpHiddenCellLayout::Read()
 866 {
 867     LwpCellLayout::Read();
 868
 869     cconnectedlayout.ReadIndexed(m_pObjStrm.get());
 870     m_pObjStrm->SkipExtra();
 871
 872 }
 873 /**
 874  * @short   Convert hidden cell layout
 875  * @param aTableID - Object ID of table
 876  * @return XFCell * - pointer to converted cell
 877  */
 878
 879 rtl::Reference<XFCell> LwpHiddenCellLayout::ConvertCell(LwpObjectID aTableID, sal_uInt16 nRow, sal_uInt16 nCol)
 880 {
 881     if (!cconnectedlayout.obj().is())
 882         return nullptr;
 883     LwpConnectedCellLayout* pConnCell = dynamic_cast<LwpConnectedCellLayout* >(cconnectedlayout.obj().get());
 884
 885     if (!pConnCell || nRow < (pConnCell->GetNumrows()+pConnCell->GetRowID()))
 886         return nullptr;
 887     // if the hidden cell should be displayed for limit of SODC
 888     // use the default cell layout
 889     rtl::Reference<XFCell> xXFCell;
 890     LwpTable *pTable = dynamic_cast<LwpTable *>(aTableID.obj().get());
 891     if (pTable)
 892     {
 893         LwpCellLayout *pDefault = dynamic_cast<LwpCellLayout *>(pTable->GetDefaultCellStyle().obj().get());
 894         if (pDefault)
 895         {
 896             xXFCell = pDefault->DoConvertCell(aTableID, nRow, nCol);
 897         }
 898         else
 899         {
 900             xXFCell = pConnCell->DoConvertCell(aTableID, nRow, nCol);
 901         }
 902         xXFCell->SetColumnSpaned(pConnCell->GetNumcols());
 903     }
 904     else
 905     {
 906         assert(false);
 907     }
 908     return xXFCell;
 909 }
 910 /**
 911  * @short   parse hidden cell layout
 912  * @param pOutputStream - output stream
 913  * @return
 914  */
 915  void  LwpHiddenCellLayout::Parse(IXFStream* /*pOutputStream*/)
 916 {
 917 }
 918
 919 LwpParallelColumnsBlock::LwpParallelColumnsBlock(LwpObjectHeader const &objHdr, LwpSvStream* pStrm):LwpCellLayout(objHdr, pStrm)
 920 {}
 921
 922 LwpParallelColumnsBlock::~LwpParallelColumnsBlock()
 923 {}
 924
 925 void LwpParallelColumnsBlock::Read()
 926 {
 927     LwpCellLayout::Read();
 928     m_pObjStrm->SkipExtra();
 929 }
 930
 931 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */