lotuswordpro/source/filter/lwprowlayout.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 - row layouts
  59  */
  60 /*************************************************************************
  61  * Change History
  62  April 2005         Created
  63  ************************************************************************/
  64 #include "lwprowlayout.hxx"
  65 #include "lwptable.hxx"
  66 #include "lwpglobalmgr.hxx"
  67 #include "xfilter/xfstylemanager.hxx"
  68 #include "xfilter/xfrow.hxx"
  69 #include "xfilter/xfrowstyle.hxx"
  70 #include "xfilter/xftablestyle.hxx"
  71 #include "xfilter/xftable.hxx"
  72 #include "xfilter/xfcell.hxx"
  73 #include "xfilter/xfcellstyle.hxx"
  74
  75 LwpRowLayout::LwpRowLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
  76     : LwpVirtualLayout(objHdr, pStrm)
  77     , crowid(0)
  78     , cheight(0)
  79     , cLeaderDotCount(0)
  80     , cLeaderDotY(0)
  81     , cRowFlags(0)
  82 {
  83     m_ConnCellList.clear();
  84 }
  85
  86 LwpRowLayout::~LwpRowLayout()
  87 {}
  88
  89 /**
  90  * @short   register row style
  91  * @param
  92  * @param
  93  * @param
  94  * @return
  95  */
  96 void LwpRowLayout::SetRowMap()
  97 {
  98     LwpObjectID& rCellID= GetChildHead();
  99     LwpCellLayout * pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 100
 101     while(pCellLayout)
 102     {
 103         pCellLayout->SetCellMap();
 104
 105         rCellID = pCellLayout->GetNext();
 106         pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 107     }
 108 }
 109 /**
 110  * @short   register row style
 111  * @param
 112  * @param
 113  * @param
 114  * @return
 115  */
 116 void LwpRowLayout::RegisterStyle()
 117 {
 118     // register row style
 119     XFRowStyle *pRowStyle = new XFRowStyle();
 120
 121     if (m_nDirection & 0x0030)
 122     {
 123         pRowStyle->SetMinRowHeight((float)LwpTools::ConvertFromUnitsToMetric(cheight));
 124     }
 125     else
 126     {
 127         pRowStyle->SetRowHeight((float)LwpTools::ConvertFromUnitsToMetric(cheight));
 128     }
 129     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 130     m_StyleName = pXFStyleManager->AddStyle(pRowStyle).m_pStyle->GetStyleName();
 131
 132     LwpTableLayout* pTableLayout = GetParentTableLayout();
 133     if (pTableLayout)
 134     {
 135         pTableLayout->GetTable();
 136     }
 137     // register cells' style
 138     LwpObjectID& rCellID= GetChildHead();
 139     LwpCellLayout * pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 140
 141     while(pCellLayout)
 142     {
 143         pCellLayout->SetFoundry(m_pFoundry);
 144         pCellLayout->RegisterStyle();
 145         rCellID = pCellLayout->GetNext();
 146         pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 147     }
 148
 149 }
 150 /**
 151  * @short   register row style
 152  * @param
 153  * @param
 154  * @param
 155  * @return
 156  */
 157 void LwpRowLayout::Read()
 158 {
 159     #define MAXUNIT (0x7fffffffL)               // Highest positive UNIT value
 160     LwpObjectStream* pStrm = m_pObjStrm;
 161
 162     LwpVirtualLayout::Read();
 163
 164     //skip CLiteLayout data;
 165     LwpAtomHolder ContentClass;
 166     ContentClass.Read(pStrm);
 167     pStrm->SkipExtra();
 168
 169     // Row layout content
 170     crowid = pStrm->QuickReaduInt16();
 171     cheight = pStrm->QuickReadInt32();
 172     cLeaderDotCount = (sal_uInt8)pStrm->QuickReaduInt16();  // was written as lushort.
 173     cLeaderDotY = MAXUNIT;  // Sentinel meaning "not calculated yet"
 174     cRowFlags = (sal_uInt8)pStrm->QuickReaduInt16();    // was written as lushort.
 175
 176     pStrm->SkipExtra();
 177 }
 178
 179 /**
 180  * @short   Parse rows with connect cell
 181  * @param  pXFTable - pointer to created XFTable
 182  */
 183 void LwpRowLayout::ConvertRow(XFTable* pXFTable,sal_uInt8 nStartCol,sal_uInt8 nEndCol)
 184 {
 185     LwpTableLayout* pTableLayout = GetParentTableLayout();
 186     LwpTable* pTable = pTableLayout->GetTable();
 187
 188     //calculate the connected cell position
 189     sal_Int32 nMarkConnCell = FindMarkConnCell(nStartCol,nEndCol);
 190
 191     //if there is no connected cell
 192     if (nMarkConnCell == -1)
 193     {
 194         ConvertCommonRow(pXFTable,nStartCol,nEndCol);
 195         return;
 196     }
 197
 198     //register connect row style
 199     sal_uInt16 nRowMark = crowid + GetCurMaxSpannedRows(nStartCol,nEndCol);
 200     XFRow* pXFRow = new XFRow;
 201     RegisterCurRowStyle(pXFRow,nRowMark);
 202
 203     //if there is connected cell
 204     for (sal_uInt8 i=nStartCol; i<nEndCol; )
 205     {
 206         XFCell* pXFCell;
 207         sal_uInt8 nColMark;
 208
 209         if (nMarkConnCell == -1)
 210             nColMark = nEndCol;
 211         else
 212             nColMark = m_ConnCellList[nMarkConnCell]->GetColID();
 213
 214         if (nColMark > i)//create subtable
 215         {
 216             pXFCell = new XFCell;
 217             pXFCell->SetColumnSpaned(nColMark-i);
 218             XFTable* pSubTable = new XFTable;
 219             pTableLayout->ConvertTable(pSubTable,crowid,nRowMark,i,nColMark);
 220             pXFCell->Add(pSubTable);
 221             i = nColMark;
 222         }
 223         else
 224         {
 225             sal_uInt8 nColID = m_ConnCellList[nMarkConnCell]->GetColID()
 226                     +m_ConnCellList[nMarkConnCell]->GetNumcols()-1;
 227             pXFCell = m_ConnCellList[nMarkConnCell]->ConvertCell(
 228                 pTable->GetObjectID(),
 229                 crowid+m_ConnCellList[nMarkConnCell]->GetNumrows()-1,
 230                 m_ConnCellList[nMarkConnCell]->GetColID());
 231
 232             //set all cell in this merge cell to cellsmap
 233             for (sal_uInt16 nRowLoop = crowid;nRowLoop<nRowMark ;nRowLoop++)
 234                 for (sal_uInt8 nColLoop = i;nColLoop<nColID+1;nColLoop++)
 235                     pTableLayout->SetCellsMap(nRowLoop,nColLoop,pXFCell);
 236
 237             i += m_ConnCellList[nMarkConnCell]->GetNumcols();
 238             nMarkConnCell = FindNextMarkConnCell(static_cast<sal_uInt16>(nMarkConnCell),nEndCol);
 239         }
 240
 241         if (pXFCell)
 242             pXFRow->AddCell(pXFCell);
 243     }
 244     pXFTable->AddRow(pXFRow);
 245 }
 246
 247 /**
 248  * @short   register row style in SODC table
 249  * @param   pXFRow - pointer of row
 250  * @param   nRowMark - spanned row number
 251  */
 252 void LwpRowLayout::RegisterCurRowStyle(XFRow* pXFRow,sal_uInt16 nRowMark)
 253 {
 254     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 255     XFRowStyle* pRowStyle = static_cast<XFRowStyle*>(pXFStyleManager->FindStyle(m_StyleName));
 256     if (!pRowStyle)
 257         return;
 258     double fHeight = pRowStyle->GetRowHeight();
 259
 260     XFRowStyle* pNewStyle = new XFRowStyle;
 261     *pNewStyle = *pRowStyle;
 262     LwpTableLayout* pTableLayout = GetParentTableLayout();
 263     if (!pTableLayout)
 264     {
 265         delete pNewStyle;
 266         return;
 267     }
 268     std::map<sal_uInt16,LwpRowLayout*> RowsMap = pTableLayout->GetRowsMap();
 269
 270     for (sal_uInt16 i=crowid+1; i<nRowMark;i++)
 271     {
 272         std::map<sal_uInt16,LwpRowLayout*>::iterator iter = RowsMap.find(i);
 273         if (iter == RowsMap.end())
 274         {
 275             pRowStyle = static_cast<XFRowStyle*>(
 276                 pXFStyleManager->FindStyle(pTableLayout->GetDefaultRowStyleName()));
 277             fHeight += pRowStyle->GetRowHeight();
 278         }
 279         else
 280         {
 281             pRowStyle = static_cast<XFRowStyle*>(
 282                 pXFStyleManager->FindStyle(iter->second->GetStyleName()));
 283             fHeight+=pRowStyle->GetRowHeight();
 284         }
 285     }
 286
 287     if (m_nDirection & 0x0030)
 288     {
 289         pNewStyle->SetMinRowHeight((float)fHeight);
 290     }
 291     else
 292     {
 293         pNewStyle->SetRowHeight((float)fHeight);
 294     }
 295
 296     pXFRow->SetStyleName(pXFStyleManager->AddStyle(pNewStyle).m_pStyle->GetStyleName());
 297 }
 298
 299 /**
 300  * @short   find max merge cell in a given column range
 301  * @param   nStartCol - start column ID
 302  * @param   nEndCol - end column ID
 303  */
 304 sal_Int32 LwpRowLayout::FindMarkConnCell(sal_uInt8 nStartCol,sal_uInt8 nEndCol)
 305 {
 306     if (m_ConnCellList.empty())
 307         return -1;
 308
 309     sal_uInt16 nSpannRows = 1;
 310     sal_Int32 nMarkConnCell = -1;
 311
 312     for (sal_uInt16 i=0;i<m_ConnCellList.size();i++)
 313     {
 314         if (m_ConnCellList[i]->GetColID()>=nEndCol)
 315             break;
 316         if (m_ConnCellList[i]->GetColID()>=nStartCol)
 317         {
 318             if (m_ConnCellList[i]->GetNumrows()>nSpannRows)
 319             {
 320                 nSpannRows = m_ConnCellList[i]->GetNumrows();
 321                 nMarkConnCell = i;
 322             }
 323         }
 324     }
 325     return nMarkConnCell;
 326 }
 327
 328 /**
 329  * @short   find next merge cell with the same spanned row number with current merge cell
 330  * @param   nStartCol - start column ID
 331  * @param   nEndCol - end column ID
 332  */
 333 sal_Int32 LwpRowLayout::FindNextMarkConnCell(sal_uInt16 nMarkConnCell,sal_uInt8 nEndCol)
 334 {
 335     sal_uInt16 nMaxRows = m_ConnCellList[nMarkConnCell]->GetNumrows();
 336
 337     for (sal_uInt16 i=nMarkConnCell+1;i<m_ConnCellList.size();i++)
 338     {
 339         if (m_ConnCellList[i]->GetColID()>=nEndCol)
 340             break;
 341         if (m_ConnCellList[i]->GetNumrows() == nMaxRows)
 342         {
 343             return i;
 344         }
 345     }
 346     return -1;
 347 }
 348 /**
 349  * @short   get max spanned row numbers in a given column range
 350  * @param   nStartCol - start column ID
 351  * @param   nEndCol - end column ID
 352  */
 353 sal_uInt16 LwpRowLayout::GetCurMaxSpannedRows(sal_uInt8 nStartCol,sal_uInt8 nEndCol)
 354 {
 355     sal_Int32 nMarkConnCell = FindMarkConnCell(nStartCol,nEndCol);
 356     if (nMarkConnCell == -1)
 357         return 1;
 358     else
 359         return m_ConnCellList[nMarkConnCell]->GetNumrows();
 360 }
 361 /**
 362  * @short   convert row with rowlayout,but no merge cells
 363  * @param   pXFTable - pointer of table
 364  * @param   nStartCol - start column ID
 365  * @param   nEndCol - end column ID
 366  */
 367 void LwpRowLayout::ConvertCommonRow(XFTable* pXFTable,sal_uInt8 nStartCol,sal_uInt8 nEndCol)
 368 {
 369     XFRow* pRow = new XFRow;
 370     pRow->SetStyleName(m_StyleName);
 371
 372     XFCell * pCell = NULL;
 373     LwpTableLayout* pTableLayout = GetParentTableLayout();
 374     LwpTable* pTable = pTableLayout->GetTable();
 375     sal_uInt8 nCellStartCol,nCellEndCol;
 376
 377     for (sal_uInt8 i = nStartCol; i < nEndCol ; i++)
 378     {
 379         // add row to table
 380         LwpObjectID& rCellID= GetChildHead();
 381         LwpCellLayout * pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 382         nCellStartCol = i;//mark the begin position of cell
 383         nCellEndCol = i;//mark the end position of cell
 384         while(pCellLayout)
 385         {
 386             if (pCellLayout->GetColID() == i)
 387             {
 388                 if (pCellLayout->GetLayoutType() == LWP_CONNECTED_CELL_LAYOUT)
 389                 {
 390                     LwpConnectedCellLayout* pConnCell = static_cast<LwpConnectedCellLayout*>(pCellLayout);
 391                     nCellEndCol = i+pConnCell->GetNumcols()-1;
 392                     i = nCellEndCol;
 393                 }
 394                 pCell = pCellLayout->ConvertCell(pTable->GetObjectID(),crowid,i);
 395                 break;
 396             }
 397             rCellID = pCellLayout->GetNext();
 398             pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 399         }
 400         if (!pCellLayout)
 401         {
 402             // if table has default cell layout, use it to ConvertCell
 403             // otherwise use blank cell
 404             LwpCellLayout * pDefaultCell = pTableLayout->GetDefaultCellLayout();
 405             if (pDefaultCell)
 406             {
 407                 pCell = pDefaultCell->ConvertCell(
 408                     pTable->GetObjectID(),crowid, i);
 409             }
 410             else
 411             {
 412                 pCell = new XFCell;
 413             }
 414         }
 415         pRow->AddCell(pCell);
 416
 417         for (sal_uInt8 j=nCellStartCol;j<=nCellEndCol;j++)
 418             pTableLayout->SetCellsMap(crowid,j,pCell);//set to cellsmap
 419     }
 420
 421     pXFTable->AddRow(pRow);
 422 }
 423 /**
 424  * @short   collect merge cell info when register row styles
 425  */
 426 void LwpRowLayout::CollectMergeInfo()
 427 {
 428     LwpObjectID& rCellID= GetChildHead();
 429     LwpCellLayout * pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 430
 431     while(pCellLayout)
 432     {
 433         if (pCellLayout->GetLayoutType() == LWP_CONNECTED_CELL_LAYOUT)
 434         {
 435             LwpConnectedCellLayout* pConnCell = static_cast<LwpConnectedCellLayout*>(pCellLayout);
 436             m_ConnCellList.push_back(pConnCell);
 437         }
 438         rCellID = pCellLayout->GetNext();
 439         pCellLayout = dynamic_cast<LwpCellLayout *>(rCellID.obj().get());
 440     }
 441 }
 442 /**
 443  * @short   split merge cells in this row
 444  * @param   nEffectRows - max spanned number of prevoius row
 445  */
 446 void LwpRowLayout::SetCellSplit(sal_uInt16 nEffectRows)
 447 {
 448     LwpConnectedCellLayout* pConnCell;
 449     for (sal_uInt32 i=0; i<m_ConnCellList.size(); i++)
 450     {
 451         pConnCell = m_ConnCellList[i];
 452         sal_uInt16 nRowSpan = pConnCell->GetRowID()+pConnCell->GetNumrows();
 453         if ( nRowSpan > nEffectRows )
 454         {
 455             pConnCell->SetNumrows(nEffectRows - pConnCell->GetRowID());
 456         }
 457     }
 458 }
 459 /**
 460  * @short   check if the row has merge cell
 461  */
 462 bool LwpRowLayout::GetMergeCellFlag()
 463 {
 464     if (m_ConnCellList.empty())
 465         return false;
 466     else
 467         return true;
 468 }
 469
 470 LwpRowHeadingLayout::LwpRowHeadingLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
 471     : LwpRowLayout(objHdr, pStrm)
 472 {}
 473
 474 LwpRowHeadingLayout::~LwpRowHeadingLayout()
 475 {}
 476 void LwpRowHeadingLayout::Read()
 477 {
 478     LwpRowLayout::Read();
 479
 480     cRowLayout.ReadIndexed(m_pObjStrm);
 481     m_pObjStrm->SkipExtra();
 482 }
 483
 484 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */