| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _HTMLTBL_HXX |
| #define _HTMLTBL_HXX |
| |
| |
| #include <vcl/timer.hxx> |
| #include <editeng/svxenum.hxx> |
| |
| #include "swtypes.hxx" |
| #include "node.hxx" // Fuer SwStartNode |
| |
| |
| class SwTableBox; |
| class SwTable; |
| class SwHTMLTableLayout; |
| class SwDoc; |
| class SwFrmFmt; |
| |
| #define HTMLTABLE_RESIZE_NOW (ULONG_MAX) |
| |
| class SwHTMLTableLayoutCnts |
| { |
| SwHTMLTableLayoutCnts *pNext; // der naechste Inhalt |
| |
| // von den beiden naechsten Pointern darf nur einer gesetzt sein! |
| SwTableBox *pBox; // ein Box |
| SwHTMLTableLayout *pTable; // eine "Tabelle in der Tabelle" |
| |
| // Beim ersten Durchlauf gibt es noch keine Boxen. Es wird dann |
| // pStartNode anstelle von pBox verwendet. |
| const SwStartNode *pStartNode; |
| |
| // Die folgenden Zahler geben an, wie oft ein Pass bereits fuer diesen |
| // Inhalt durchgefuehrt wurde. Dazu werden sie mit einer Soll-Vorgabe |
| // verglichen. Wird 255 erreicht laufen sie bei 0 weiter. So wird |
| // eine Reinitialisierung bei jedem Resize vermieden. |
| sal_uInt8 nPass1Done; // Wieoft wurde Pass 1 aufgerufen? |
| sal_uInt8 nWidthSet; // Wieoft wurde die Breite gesetzt? |
| |
| sal_Bool bNoBreakTag; // <NOBR>-Tag ueber gesamten Inhalt |
| |
| public: |
| |
| SwHTMLTableLayoutCnts( const SwStartNode* pSttNd, SwHTMLTableLayout* pTab, |
| sal_Bool bNoBreakTag, SwHTMLTableLayoutCnts* pNxt ); |
| |
| ~SwHTMLTableLayoutCnts(); |
| |
| void SetTableBox( SwTableBox *pBx ) { pBox = pBx; } |
| SwTableBox *GetTableBox() const { return pBox; } |
| |
| SwHTMLTableLayout *GetTable() const { return pTable; } |
| |
| const SwStartNode *GetStartNode() const; |
| |
| // Ermitteln des naechsten Knotens |
| SwHTMLTableLayoutCnts *GetNext() const { return pNext; } |
| |
| void SetWidthSet( sal_uInt8 nRef ) { nWidthSet = nRef; } |
| sal_Bool IsWidthSet( sal_uInt8 nRef ) const { return nRef==nWidthSet; } |
| |
| void SetPass1Done( sal_uInt8 nRef ) { nPass1Done = nRef; } |
| sal_Bool IsPass1Done( sal_uInt8 nRef ) const { return nRef==nPass1Done; } |
| |
| sal_Bool HasNoBreakTag() const { return bNoBreakTag; } |
| }; |
| |
| /* */ |
| |
| class SwHTMLTableLayoutCell |
| { |
| SwHTMLTableLayoutCnts *pContents; // der Inhalt der Zelle |
| |
| sal_uInt16 nRowSpan; // ROWSPAN der Zelle |
| sal_uInt16 nColSpan; // COLSPAN der Zelle |
| sal_uInt16 nWidthOption;// angegebene Breite der Zelle in Twip oder % |
| |
| sal_Bool bPrcWidthOption : 1;// nWidth ist %-Angabe |
| sal_Bool bNoWrapOption : 1; // NOWRAP-Option |
| |
| public: |
| |
| SwHTMLTableLayoutCell( SwHTMLTableLayoutCnts *pCnts, |
| sal_uInt16 nRSpan, sal_uInt16 nCSpan, |
| sal_uInt16 nWidthOpt, sal_Bool bPrcWdthOpt, |
| sal_Bool nNWrapOpt ); |
| |
| ~SwHTMLTableLayoutCell(); |
| |
| // Setzen/Ermitteln des Inhalts einer Zelle |
| void SetContents( SwHTMLTableLayoutCnts *pCnts ) { pContents = pCnts; } |
| SwHTMLTableLayoutCnts *GetContents() const { return pContents; } |
| |
| inline void SetProtected(); |
| |
| // ROWSPAN/COLSPAN der Zelle Setzen/Ermitteln |
| void SetRowSpan( sal_uInt16 nRSpan ) { nRowSpan = nRSpan; } |
| sal_uInt16 GetRowSpan() const { return nRowSpan; } |
| sal_uInt16 GetColSpan() const { return nColSpan; } |
| |
| sal_uInt16 GetWidthOption() const { return nWidthOption; } |
| sal_Bool IsPrcWidthOption() const { return bPrcWidthOption; } |
| |
| sal_Bool HasNoWrapOption() const { return bNoWrapOption; } |
| }; |
| |
| /* */ |
| |
| class SwHTMLTableLayoutColumn |
| { |
| // Zwischenwerte von AutoLayoutPass1 |
| sal_uLong nMinNoAlign, nMaxNoAlign, nAbsMinNoAlign; |
| |
| // Ergebnisse von AutoLayoutPass1 |
| sal_uLong nMin, nMax; |
| |
| // Ergibnisse von Pass 2 |
| sal_uInt16 nAbsColWidth; // in Twips |
| sal_uInt16 nRelColWidth; // in Twips bzw. relativ zu USHRT_MAX |
| |
| sal_uInt16 nWidthOption; // Optionen von <COL> oder <TD>/<TH> |
| |
| sal_Bool bRelWidthOption : 1; |
| sal_Bool bLeftBorder : 1; |
| |
| public: |
| |
| SwHTMLTableLayoutColumn( sal_uInt16 nColWidthOpt, sal_Bool bRelColWidthOpt, |
| sal_Bool bLBorder ); |
| |
| ~SwHTMLTableLayoutColumn() {} |
| |
| inline void MergeCellWidthOption( sal_uInt16 nWidth, sal_Bool bPrc ); |
| inline void SetWidthOption( sal_uInt16 nWidth, sal_Bool bRelWidth, sal_Bool bTest ); |
| |
| sal_uInt16 GetWidthOption() const { return nWidthOption; } |
| sal_Bool IsRelWidthOption() const { return bRelWidthOption; } |
| |
| inline void MergeMinMaxNoAlign( sal_uLong nMin, sal_uLong nMax, sal_uLong nAbsMin ); |
| sal_uLong GetMinNoAlign() const { return nMinNoAlign; } |
| sal_uLong GetMaxNoAlign() const { return nMaxNoAlign; } |
| sal_uLong GetAbsMinNoAlign() const { return nAbsMinNoAlign; } |
| inline void ClearPass1Info( sal_Bool bWidthOpt ); |
| |
| inline void SetMinMax( sal_uLong nMin, sal_uLong nMax ); |
| void SetMax( sal_uLong nVal ) { nMax = nVal; } |
| void AddToMin( sal_uLong nVal ) { nMin += nVal; } |
| void AddToMax( sal_uLong nVal ) { nMax += nVal; } |
| sal_uLong GetMin() const { return nMin; } |
| sal_uLong GetMax() const { return nMax; } |
| |
| void SetAbsColWidth( sal_uInt16 nWidth ) { nAbsColWidth = nWidth; } |
| sal_uInt16 GetAbsColWidth() const { return nAbsColWidth; } |
| |
| void SetRelColWidth( sal_uInt16 nWidth ) { nRelColWidth = nWidth; } |
| sal_uInt16 GetRelColWidth() const { return nRelColWidth; } |
| |
| sal_Bool HasLeftBorder() const { return bLeftBorder; } |
| }; |
| |
| /* */ |
| |
| class SwHTMLTableLayout |
| { |
| Timer aResizeTimer; // Timer fuer DelayedResize |
| |
| SwHTMLTableLayoutColumn **aColumns; |
| SwHTMLTableLayoutCell **aCells; |
| |
| const SwTable *pSwTable; // die SwTable (nur Top-Table) |
| SwTableBox *pLeftFillerBox; // linke Filler-Zelle (nur Tab in Tab) |
| SwTableBox *pRightFillerBox; // rechte Filler-Zelle (nur Tab-in Tab) |
| |
| sal_uLong nMin; // minimale Breite der Tabelle (Twips) |
| sal_uLong nMax; // maximale Breite der Tabelle (Twips) |
| |
| sal_uInt16 nRows; // Anzahl Zeilen |
| sal_uInt16 nCols; // Anzahl Spalten |
| |
| sal_uInt16 nLeftMargin; // Abstand zum linken Rand (aus Absatz) |
| sal_uInt16 nRightMargin; // Abstand zum rechten Rand (aus Absatz) |
| |
| sal_uInt16 nInhAbsLeftSpace; // von umgebender Zelle geerbter Abstand, |
| sal_uInt16 nInhAbsRightSpace; // der Zellen zugeschlagen wurde |
| |
| sal_uInt16 nRelLeftFill; // relative Breiten der Zellen zur |
| sal_uInt16 nRelRightFill; // Ausrichtung von Tabellen in Tabellen |
| |
| sal_uInt16 nRelTabWidth; // Die relative Breite der Tabelle |
| |
| sal_uInt16 nWidthOption; // die Breite der Tabelle (in Twip oder %) |
| sal_uInt16 nCellPadding; // Abstand zum Inhalt (in Twip) |
| sal_uInt16 nCellSpacing; // Absatnd zwischen Zellen (in Twip) |
| sal_uInt16 nBorder; // Dicke der ausseren Umrandung bzw. |
| // Platz, den Netscape hierfuer einrechnet. |
| |
| sal_uInt16 nLeftBorderWidth; |
| sal_uInt16 nRightBorderWidth; |
| sal_uInt16 nInhLeftBorderWidth; |
| sal_uInt16 nInhRightBorderWidth; |
| sal_uInt16 nBorderWidth; |
| |
| sal_uInt16 nDelayedResizeAbsAvail; // Param fuer's verzoegerte Resize |
| sal_uInt16 nLastResizeAbsAvail; |
| |
| sal_uInt8 nPass1Done; // Vorgabe-Werte fuer die einzelen |
| sal_uInt8 nWidthSet; // Schleifen-Durchlauefe |
| |
| SvxAdjust eTableAdjust; // Die Ausrichtung der Tabelle |
| |
| sal_Bool bColsOption : 1; // Tabelle besitzt eine COLS-Option |
| sal_Bool bColTags : 1; // Tabelle besitzt COL/COLGRP-Tags |
| sal_Bool bPrcWidthOption : 1; // Breite ist eine %-Angabe |
| sal_Bool bUseRelWidth : 1; // SwTable bekommt relative Breite |
| |
| sal_Bool bMustResize : 1; // Tabelle muss in der Breite ang. werden |
| sal_Bool bExportable : 1; // Layout kann zum Export genutzt werden |
| sal_Bool bBordersChanged : 1; // Umrandung wurde geaendert |
| sal_Bool bMayBeInFlyFrame : 1; // Die Tabelle koennte im Rahmen sein |
| |
| sal_Bool bDelayedResizeRecalc : 1; // Param fuer's verzoegerte Resize |
| sal_Bool bMustNotResize : 1; // Die Tabelle darf nicht reseized werden |
| sal_Bool bMustNotRecalc : 1; // Tabelle darf nicht an Inhalt angepasst |
| // werden |
| |
| // sal_uInt16 GetLeftBorderWidth( sal_uInt16 nCol ) const; |
| // sal_uInt16 GetRightBorderWidth( sal_uInt16 nCol, sal_uInt16 nColSpan ) const; |
| |
| void AddBorderWidth( sal_uLong &rMin, sal_uLong &rMax, sal_uLong& rAbsMin, |
| sal_uInt16 nCol, sal_uInt16 nColSpan, |
| sal_Bool bSwBorders=sal_True ) const; |
| void SetBoxWidth( SwTableBox *pBox, sal_uInt16 nCol, sal_uInt16 nColSpan ) const; |
| |
| const SwStartNode *GetAnyBoxStartNode() const; |
| SwFrmFmt *FindFlyFrmFmt() const; |
| const SwDoc *GetDoc() const { return GetAnyBoxStartNode()->GetDoc(); } |
| |
| void ClearPass1Info() { nMin = nMax = 0; } |
| |
| void _Resize( sal_uInt16 nAbsAvail, sal_Bool bRecalc=sal_False ); |
| |
| DECL_STATIC_LINK( SwHTMLTableLayout, DelayedResize_Impl, void* ); |
| |
| static sal_uInt16 GetBrowseWidthByVisArea( const SwDoc& rDoc ); |
| public: |
| |
| SwHTMLTableLayout( const SwTable *pSwTbl, |
| sal_uInt16 nRows, sal_uInt16 nCols, sal_Bool bColsOpt, sal_Bool ColTgs, |
| sal_uInt16 nWidth, sal_Bool bPrcWidth, sal_uInt16 nBorderOpt, |
| sal_uInt16 nCellPad, sal_uInt16 nCellSp, SvxAdjust eAdjust, |
| sal_uInt16 nLMargin, sal_uInt16 nRMargin, sal_uInt16 nBWidth, |
| sal_uInt16 nLeftBWidth, sal_uInt16 nRightBWidth, |
| sal_uInt16 nInhLeftBWidth, sal_uInt16 nInhRightBWidth ); |
| |
| ~SwHTMLTableLayout(); |
| |
| sal_uInt16 GetLeftCellSpace( sal_uInt16 nCol, sal_uInt16 nColSpan, |
| sal_Bool bSwBorders=sal_True ) const; |
| sal_uInt16 GetRightCellSpace( sal_uInt16 nCol, sal_uInt16 nColSpan, |
| sal_Bool bSwBorders=sal_True ) const; |
| inline sal_uInt16 GetInhCellSpace( sal_uInt16 nCol, sal_uInt16 nColSpan ) const; |
| |
| inline void SetInhBorderWidths( sal_uInt16 nLeft, sal_uInt16 nRight ); |
| |
| |
| void GetAvail( sal_uInt16 nCol, sal_uInt16 nColSpan, sal_uInt16& rAbsAvail, |
| sal_uInt16& rRelAvail ) const; |
| |
| void AutoLayoutPass1(); |
| void AutoLayoutPass2( sal_uInt16 nAbsAvail, sal_uInt16 nRelAvail, |
| sal_uInt16 nAbsLeftSpace, sal_uInt16 nAbsRightSpace, |
| sal_uInt16 nParentInhSpace ); |
| void SetWidths( sal_Bool bCallPass2=sal_False, sal_uInt16 nAbsAvail=0, |
| sal_uInt16 nRelAvail=0, sal_uInt16 nAbsLeftSpace=0, |
| sal_uInt16 nAbsRightSpace=0, |
| sal_uInt16 nParentInhSpace=0 ); |
| |
| inline SwHTMLTableLayoutColumn *GetColumn( sal_uInt16 nCol ) const; |
| inline void SetColumn( SwHTMLTableLayoutColumn *pCol, sal_uInt16 nCol ); |
| |
| inline SwHTMLTableLayoutCell *GetCell( sal_uInt16 nRow, sal_uInt16 nCol ) const; |
| inline void SetCell( SwHTMLTableLayoutCell *pCell, sal_uInt16 nRow, sal_uInt16 nCol ); |
| |
| void SetLeftFillerBox( SwTableBox *pBox ) { pLeftFillerBox = pBox; } |
| void SetRightFillerBox( SwTableBox *pBox ) { pRightFillerBox = pBox; } |
| |
| sal_uLong GetMin() const { return nMin; } |
| sal_uLong GetMax() const { return nMax; } |
| sal_uInt16 GetRelLeftFill() const { return nRelLeftFill; } |
| sal_uInt16 GetRelRightFill() const { return nRelRightFill; } |
| |
| inline long GetBrowseWidthMin() const; |
| |
| sal_Bool HasColsOption() const { return bColsOption; } |
| sal_Bool HasColTags() const { return bColTags; } |
| |
| sal_Bool IsTopTable() const { return pSwTable != 0; } |
| |
| void SetMustResize( sal_Bool bSet ) { bMustResize = bSet; } |
| void SetMustNotResize( sal_Bool bSet ) { bMustNotResize = bSet; } |
| void SetMustNotRecalc( sal_Bool bSet ) { bMustNotRecalc = bSet; } |
| |
| // Neueberechnung der Tabellenbreiten fuer die uebergebene verfuegbare |
| // Breite. |
| // - Wenn bRecalc gesetzt ist, werden auch der Inhalt der Boxen |
| // zur Berechnung herangezogen. |
| // neu berechnet. |
| // - Wenn bForce gesetzt ist, wird die Tabelle auch neu berechnet, wenn |
| // dies mit SetMustNotResize unterdrueckt werden soll. |
| // - Wenn nDelay>0 wird die Berechnung entsprechend verzoegert. |
| // Innerhalb der Verzeoegerung auftretende Resize-Aufrufe werden |
| // ignoriert, die Verzeogerung wird aber ggf. uebernommen. |
| // - Wenn nDelay==HTMLTABLE_RESIZE_NOW ist, wird sofort Resized und |
| // eventuell noch asstehende Resize-Aufrufe werden nicht mehr |
| // ausgefuehrt. |
| // - Der Rueckgabewert gibt an, ob sich die Tabelle geaendert hat. |
| sal_Bool Resize( sal_uInt16 nAbsAvail, sal_Bool bRecalc=sal_False, sal_Bool bForce=sal_False, |
| sal_uLong nDelay=0 ); |
| |
| void BordersChanged( sal_uInt16 nAbsAvail, sal_Bool bRecalc=sal_False ); |
| |
| // Ermitteln der verfuegbaren Breite. Das geht nur, wenn ein Layout |
| // oder eine ViewShell vorhanden ist. Sonst wird 0 zurueckgegeben. |
| // (Wird vom HTML-Filter benoetigt, da der nicht an das Layout kommt.) |
| static sal_uInt16 GetBrowseWidth( const SwDoc& rDoc ); |
| |
| // Ermitteln der verfuegbaren Breite uber den Tabellen-Frame |
| sal_uInt16 GetBrowseWidthByTabFrm( const SwTabFrm& rTabFrm ) const; |
| |
| // Ermitteln der verfuegbaren Breite uber den Tabellen-Frame oder |
| // das statische GetBrowseWidth, wenn kein Layout existiert. |
| sal_uInt16 GetBrowseWidthByTable( const SwDoc& rDoc ) const; |
| |
| // Fuer Export |
| sal_uInt16 GetWidthOption() const { return nWidthOption; } |
| sal_Bool HasPrcWidthOption() const { return bPrcWidthOption; } |
| |
| sal_uInt16 GetCellPadding() const { return nCellPadding; } |
| sal_uInt16 GetCellSpacing() const { return nCellSpacing; } |
| sal_uInt16 GetBorder() const { return nBorder; } |
| |
| sal_uInt16 GetRowCount() const { return nRows; } |
| sal_uInt16 GetColCount() const { return nCols; } |
| |
| void SetExportable( sal_Bool bSet ) { bExportable = bSet; } |
| sal_Bool IsExportable() const { return bExportable; } |
| |
| sal_Bool HaveBordersChanged() const { return bBordersChanged; } |
| |
| void SetMayBeInFlyFrame( sal_Bool bSet ) { bMayBeInFlyFrame = bSet; } |
| sal_Bool MayBeInFlyFrame() const { return bMayBeInFlyFrame; } |
| }; |
| |
| /* */ |
| |
| inline void SwHTMLTableLayoutCell::SetProtected() |
| { |
| nRowSpan = 1; |
| nColSpan = 1; |
| |
| pContents = 0; |
| } |
| |
| /* */ |
| |
| inline void SwHTMLTableLayoutColumn::MergeMinMaxNoAlign( sal_uLong nCMin, |
| sal_uLong nCMax, sal_uLong nAbsMin ) |
| { |
| if( nCMin > nMinNoAlign ) |
| nMinNoAlign = nCMin; |
| if( nCMax > nMaxNoAlign ) |
| nMaxNoAlign = nCMax; |
| if( nAbsMin > nAbsMinNoAlign ) |
| nAbsMinNoAlign = nAbsMin; |
| } |
| |
| inline void SwHTMLTableLayoutColumn::ClearPass1Info( sal_Bool bWidthOpt ) |
| { |
| nMinNoAlign = nMaxNoAlign = nAbsMinNoAlign = MINLAY; |
| nMin = nMax = 0; |
| if( bWidthOpt ) |
| { |
| nWidthOption = 0; |
| bRelWidthOption = sal_False; |
| } |
| } |
| |
| inline void SwHTMLTableLayoutColumn::MergeCellWidthOption( |
| sal_uInt16 nWidth, sal_Bool bRel ) |
| { |
| if( !nWidthOption || |
| (bRel==bRelWidthOption && nWidthOption < nWidth) ) |
| { |
| nWidthOption = nWidth; |
| bRelWidthOption = bRel; |
| } |
| } |
| |
| inline void SwHTMLTableLayoutColumn::SetMinMax( sal_uLong nMn, sal_uLong nMx ) |
| { |
| nMin = nMn; |
| nMax = nMx; |
| } |
| |
| /* */ |
| |
| inline sal_uInt16 SwHTMLTableLayout::GetInhCellSpace( sal_uInt16 nCol, |
| sal_uInt16 nColSpan ) const |
| { |
| sal_uInt16 nSpace = 0; |
| if( nCol==0 ) |
| nSpace = nSpace + sal::static_int_cast< sal_uInt16 >(nInhAbsLeftSpace); |
| if( nCol+nColSpan==nCols ) |
| nSpace = nSpace + sal::static_int_cast< sal_uInt16 >(nInhAbsRightSpace); |
| |
| return nSpace; |
| } |
| |
| inline SwHTMLTableLayoutColumn *SwHTMLTableLayout::GetColumn( sal_uInt16 nCol ) const |
| { |
| return aColumns[nCol]; |
| } |
| |
| inline void SwHTMLTableLayoutColumn::SetWidthOption( |
| sal_uInt16 nWidth, sal_Bool bRelWidth, sal_Bool bTest ) |
| { |
| if( bTest && bRelWidthOption==bRelWidth ) |
| { |
| if( nWidth > nWidthOption ) |
| nWidthOption = nWidth; |
| } |
| else |
| nWidthOption = nWidth; |
| bRelWidthOption = bRelWidth; |
| } |
| |
| inline void SwHTMLTableLayout::SetColumn( SwHTMLTableLayoutColumn *pCol, sal_uInt16 nCol ) |
| { |
| aColumns[nCol] = pCol; |
| } |
| |
| inline SwHTMLTableLayoutCell *SwHTMLTableLayout::GetCell( sal_uInt16 nRow, sal_uInt16 nCol ) const |
| { |
| return aCells[nRow*nCols+nCol]; |
| } |
| |
| inline void SwHTMLTableLayout::SetCell( SwHTMLTableLayoutCell *pCell, |
| sal_uInt16 nRow, sal_uInt16 nCol ) |
| { |
| aCells[nRow*nCols+nCol] = pCell; |
| } |
| |
| inline long SwHTMLTableLayout::GetBrowseWidthMin() const |
| { |
| return (long)( (!nWidthOption || bPrcWidthOption) ? nMin : nRelTabWidth ); |
| } |
| |
| void SwHTMLTableLayout::SetInhBorderWidths( sal_uInt16 nLeft, sal_uInt16 nRight ) |
| { |
| nInhLeftBorderWidth = nLeft; |
| nInhRightBorderWidth = nRight; |
| } |
| |
| |
| #endif |
