sw/source/filter/inc/wrtswtbl.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: wrtswtbl.hxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef  _WRTSWTBL_HXX
  31 #define  _WRTSWTBL_HXX
  32
  33 #include <tools/solar.h>
  34 #include <tools/color.hxx>
  35 #include <svtools/svarray.hxx>
  36
  37 #include <swdllapi.h>
  38
  39 class Color;
  40 class SwTableBox;
  41 class SwTableLine;
  42 class SwTableLines;
  43 class SwTable;
  44 class SwHTMLTableLayout;
  45 class SvxBrushItem;
  46 class SvxBorderLine;
  47
  48 //---------------------------------------------------------------------------
  49 //               Code aus dem HTML-Filter fuers schreiben von Tabellen
  50 //---------------------------------------------------------------------------
  51
  52 #define COLFUZZY 20
  53 #define ROWFUZZY 20
  54 #define COL_DFLT_WIDTH ((2*COLFUZZY)+1)
  55 #define ROW_DFLT_HEIGHT (2*ROWFUZZY)+1
  56
  57
  58 //-----------------------------------------------------------------------
  59
  60 class SwWriteTableCell
  61 {
  62     const SwTableBox *pBox;             // SwTableBox der Zelle
  63     const SvxBrushItem *pBackground;    // geerbter Hintergrund einer Zeile
  64
  65     long nHeight;                               // fixe/Mindest-Hoehe der Zeile
  66
  67     USHORT nWidthOpt;                   // Breite aus Option;
  68
  69     USHORT nRow;                                // Start-Zeile
  70     USHORT nCol;                                // Start-Spalte
  71
  72     USHORT nRowSpan;                    // ueberspannte Zeilen
  73     USHORT nColSpan;                    // ueberspannte Spalten
  74
  75
  76     BOOL bPrcWidthOpt;
  77
  78 public:
  79
  80     SwWriteTableCell(const SwTableBox *pB, USHORT nR, USHORT nC, USHORT nRSpan,
  81         USHORT nCSpan, long nHght, const SvxBrushItem *pBGround)
  82     : pBox( pB ), pBackground( pBGround ), nHeight( nHght ), nWidthOpt( 0 ),
  83     nRow( nR ), nCol( nC ), nRowSpan( nRSpan ), nColSpan( nCSpan ),
  84     bPrcWidthOpt( FALSE )
  85     {}
  86
  87     const SwTableBox *GetBox() const { return pBox; }
  88
  89     USHORT GetRow() const { return nRow; }
  90     USHORT GetCol() const { return nCol; }
  91
  92     USHORT GetRowSpan() const { return nRowSpan; }
  93     USHORT GetColSpan() const { return nColSpan; }
  94
  95     long GetHeight() const { return nHeight; }
  96     sal_Int16 GetVertOri() const;
  97
  98     const SvxBrushItem *GetBackground() const { return pBackground; }
  99
 100     void SetWidthOpt( USHORT nWidth, BOOL bPrc )
 101     {
 102         nWidthOpt = nWidth; bPrcWidthOpt = bPrc;
 103     }
 104
 105     USHORT GetWidthOpt() const { return nWidthOpt; }
 106     BOOL HasPrcWidthOpt() const { return bPrcWidthOpt; }
 107 };
 108
 109 typedef SwWriteTableCell *SwWriteTableCellPtr;
 110 SV_DECL_PTRARR_DEL( SwWriteTableCells, SwWriteTableCellPtr, 5, 5 )
 111
 112
 113 //-----------------------------------------------------------------------
 114
 115 class SwWriteTableRow
 116 {
 117     SwWriteTableCells aCells;           // Alle Zellen der Rows
 118     const SvxBrushItem *pBackground;// Hintergrund
 119
 120     long nPos;                                  // End-Position (twips) der Zeile
 121     BOOL mbUseLayoutHeights;
 122
 123     // Forbidden and not implemented.
 124     SwWriteTableRow();
 125
 126     SwWriteTableRow & operator= (const SwWriteTableRow &);
 127
 128 protected:
 129     // GCC >= 3.4 needs accessible T (const T&) to pass T as const T& argument.
 130     SwWriteTableRow( const SwWriteTableRow & );
 131
 132 public:
 133
 134     USHORT nTopBorder;                          // Dicke der oberen/unteren Umrandugen
 135     USHORT nBottomBorder;
 136
 137     BOOL bTopBorder : 1;                        // Welche Umrandungen sind da?
 138     BOOL bBottomBorder : 1;
 139
 140     SwWriteTableRow( long nPos, BOOL bUseLayoutHeights );
 141
 142     SwWriteTableCell *AddCell( const SwTableBox *pBox,
 143                                  USHORT nRow, USHORT nCol,
 144                                  USHORT nRowSpan, USHORT nColSpan,
 145                                  long nHeight,
 146                                  const SvxBrushItem *pBackground );
 147
 148     void SetBackground( const SvxBrushItem *pBGround )
 149     {
 150         pBackground = pBGround;
 151     }
 152     const SvxBrushItem *GetBackground() const { return pBackground; }
 153
 154     BOOL HasTopBorder() const                                   { return bTopBorder; }
 155     BOOL HasBottomBorder() const                                { return bBottomBorder; }
 156
 157     long GetPos() const                                                 { return nPos; }
 158     const SwWriteTableCells& GetCells() const   { return aCells; }
 159
 160     inline int operator==( const SwWriteTableRow& rRow ) const;
 161     inline int operator<( const SwWriteTableRow& rRow2 ) const;
 162 };
 163
 164 inline int SwWriteTableRow::operator==( const SwWriteTableRow& rRow ) const
 165 {
 166     // etwas Unschaerfe zulassen
 167     return (nPos >= rRow.nPos ?  nPos - rRow.nPos : rRow.nPos - nPos ) <=
 168         (mbUseLayoutHeights ? 0 : ROWFUZZY);
 169 }
 170
 171 inline int SwWriteTableRow::operator<( const SwWriteTableRow& rRow ) const
 172 {
 173     // Da wir hier nur die Wahrheits-Grade 0 und 1 kennen, lassen wir lieber
 174     // auch nicht zu, dass x==y und x<y gleichzeitig gilt ;-)
 175     return nPos < rRow.nPos - (mbUseLayoutHeights ? 0 : ROWFUZZY);
 176 }
 177
 178 typedef SwWriteTableRow *SwWriteTableRowPtr;
 179 SV_DECL_PTRARR_SORT_DEL( SwWriteTableRows, SwWriteTableRowPtr, 5, 5 )
 180
 181
 182 //-----------------------------------------------------------------------
 183
 184 class SwWriteTableCol
 185 {
 186     USHORT nPos;                                                // End Position der Spalte
 187
 188     USHORT nWidthOpt;
 189
 190     BOOL bRelWidthOpt : 1;
 191     BOOL bOutWidth : 1;                                 // Spaltenbreite ausgeben?
 192
 193 public:
 194     BOOL bLeftBorder : 1;                               // Welche Umrandungen sind da?
 195     BOOL bRightBorder : 1;
 196
 197     SwWriteTableCol( USHORT nPosition );
 198
 199     USHORT GetPos() const                                               { return nPos; }
 200
 201     void SetLeftBorder( BOOL bBorder )                  { bLeftBorder = bBorder; }
 202     BOOL HasLeftBorder() const                                  { return bLeftBorder; }
 203
 204     void SetRightBorder( BOOL bBorder )                 { bRightBorder = bBorder; }
 205     BOOL HasRightBorder() const                                 { return bRightBorder; }
 206
 207     void SetOutWidth( BOOL bSet )                               { bOutWidth = bSet; }
 208     BOOL GetOutWidth() const                                    { return bOutWidth; }
 209
 210     inline int operator==( const SwWriteTableCol& rCol ) const;
 211     inline int operator<( const SwWriteTableCol& rCol ) const;
 212
 213     void SetWidthOpt( USHORT nWidth, BOOL bRel )
 214     {
 215         nWidthOpt = nWidth; bRelWidthOpt = bRel;
 216     }
 217     USHORT GetWidthOpt() const                                  { return nWidthOpt; }
 218     BOOL HasRelWidthOpt() const                                 { return bRelWidthOpt; }
 219 };
 220
 221 inline int SwWriteTableCol::operator==( const SwWriteTableCol& rCol ) const
 222 {
 223     // etwas Unschaerfe zulassen
 224     return (nPos >= rCol.nPos ? nPos - rCol.nPos
 225                                      : rCol.nPos - nPos ) <= COLFUZZY;
 226 }
 227
 228 inline int SwWriteTableCol::operator<( const SwWriteTableCol& rCol ) const
 229 {
 230     // Da wir hier nur die Wahrheits-Grade 0 und 1 kennen, lassen wir lieber
 231     // auch nicht zu, dass x==y und x<y gleichzeitig gilt ;-)
 232     return nPos < rCol.nPos - COLFUZZY;
 233 }
 234
 235
 236 typedef SwWriteTableCol *SwWriteTableColPtr;
 237 SV_DECL_PTRARR_SORT_DEL( SwWriteTableCols, SwWriteTableColPtr, 5, 5 )
 238
 239 //-----------------------------------------------------------------------
 240
 241 class SW_DLLPUBLIC SwWriteTable
 242 {
 243 protected:
 244     SwWriteTableCols aCols;     // alle Spalten
 245     SwWriteTableRows aRows;     // alle Zellen
 246
 247     UINT32 nBorderColor;                // Umrandungsfarbe
 248
 249     USHORT nCellSpacing;                // Dicke der inneren Umrandung
 250     USHORT nCellPadding;                // Absatnd Umrandung-Inhalt
 251
 252     USHORT nBorder;                             // Dicke der ausseren Umrandung
 253     USHORT nInnerBorder;                // Dicke der inneren Umrandung
 254     USHORT nBaseWidth;                  // Bezugsgroesse fur Breiten SwFmtFrmSize
 255
 256     USHORT nHeadEndRow;                 // letzte Zeile des Tabellen-Kopfes
 257
 258     USHORT nLeftSub;
 259     USHORT nRightSub;
 260
 261     long nTabWidth;                             // Absolute/Relative Breite der Tabelle
 262
 263     BOOL bRelWidths : 1;                // Breiten relativ ausgeben?
 264     BOOL bUseLayoutHeights : 1; // Layout zur Hoehenbestimmung nehmen?
 265 #ifndef PRODUCT
 266     BOOL bGetLineHeightCalled : 1;
 267 #endif
 268
 269     BOOL bColsOption : 1;
 270     BOOL bColTags : 1;
 271     BOOL bLayoutExport : 1;
 272     BOOL bCollectBorderWidth : 1;
 273
 274     virtual BOOL ShouldExpandSub( const SwTableBox *pBox,
 275                                 BOOL bExpandedBefore, USHORT nDepth ) const;
 276
 277     void CollectTableRowsCols( long nStartRPos, USHORT nStartCPos,
 278                                long nParentLineHeight,
 279                                USHORT nParentLineWidth,
 280                                const SwTableLines& rLines,
 281                                USHORT nDepth );
 282
 283     void FillTableRowsCols( long nStartRPos, USHORT nStartRow,
 284                             USHORT nStartCPos, USHORT nStartCol,
 285                             long nParentLineHeight,
 286                             USHORT nParentLineWidth,
 287                             const SwTableLines& rLines,
 288                             const SvxBrushItem* pLineBrush,
 289                             USHORT nDepth,
 290                             sal_uInt16 nNumOfHeaderRows );
 291
 292     void MergeBorders( const SvxBorderLine* pBorderLine, BOOL bTable );
 293
 294     USHORT MergeBoxBorders( const SwTableBox *pBox, USHORT nRow, USHORT nCol,
 295                             USHORT nRowSpan, USHORT nColSpan,
 296                             USHORT &rTopBorder, USHORT &rBottomBorder );
 297
 298     USHORT GetBaseWidth() const { return nBaseWidth; }
 299
 300     BOOL HasRelWidths() const { return bRelWidths; }
 301
 302 public:
 303     static long GetBoxWidth( const SwTableBox *pBox );
 304
 305     USHORT GetRawWidth( USHORT nCol, USHORT nColSpan ) const;
 306     USHORT GetAbsWidth( USHORT nCol, USHORT nColSpan ) const;
 307     USHORT GetRelWidth( USHORT nCol, USHORT nColSpan ) const;
 308     USHORT GetPrcWidth( USHORT nCol, USHORT nColSpan ) const;
 309
 310     long GetAbsHeight( long nRawWidth, USHORT nRow, USHORT nRowSpan ) const;
 311 protected:
 312
 313     long GetLineHeight( const SwTableLine *pLine );
 314     long GetLineHeight( const SwTableBox *pBox ) const;
 315     const SvxBrushItem *GetLineBrush( const SwTableBox *pBox,
 316                                       SwWriteTableRow *pRow );
 317
 318     USHORT GetLeftSpace( USHORT nCol ) const;
 319     USHORT GetRightSpace( USHORT nCol, USHORT nColSpan ) const;
 320
 321
 322 public:
 323     SwWriteTable( const SwTableLines& rLines, long nWidth, USHORT nBWidth,
 324                     BOOL bRel, USHORT nMaxDepth = USHRT_MAX,
 325                     USHORT nLeftSub=0, USHORT nRightSub=0, sal_uInt32 nNumOfRowsToRepeat=0 );
 326     SwWriteTable( const SwHTMLTableLayout *pLayoutInfo );
 327     virtual ~SwWriteTable();
 328
 329     const SwWriteTableCols& GetCols() const { return aCols; }
 330     const SwWriteTableRows& GetRows() const { return aRows; }
 331 };
 332
 333
 334
 335
 336 #endif
 337