LCOV - code coverage report
Current view: top level - lotuswordpro/source/filter - lwpcelllayout.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 159 341 46.6 %
Date: 2015-06-13 12:38:46 Functions: 20 43 46.5 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11