| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <hintids.hxx> |
| #include <tools/solar.h> |
| #include <editeng/paperinf.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/adjitem.hxx> |
| #include <editeng/spltitem.hxx> |
| #include <editeng/keepitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/shaditem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/lspcitem.hxx> |
| #include <editeng/tstpitem.hxx> |
| #include <fmtclds.hxx> |
| #include <fmtfsize.hxx> |
| #include <pam.hxx> |
| #include <ndtxt.hxx> |
| #include <charatr.hxx> |
| #include <frmatr.hxx> |
| #include <doc.hxx> |
| #include <errhdl.hxx> |
| #include <fltini.hxx> |
| #include <docufld.hxx> |
| #include <pagedesc.hxx> |
| #include <flddat.hxx> |
| #include <reffld.hxx> |
| #include <expfld.hxx> |
| #include <w1par.hxx> |
| #include <mdiexp.hxx> |
| #include <swerror.h> |
| #include <statstr.hrc> |
| |
| using namespace ::com::sun::star; |
| |
| /////////////////////////////////////////////////////////////// Ww1Sprm |
| void Ww1Sprm::Stop( Ww1Shell& rOut, Ww1Manager& rMan) |
| { |
| if(IsUsed()) |
| // for(sal_uInt16 i=0;i<Count();i++) |
| for(short i=Count()-1;i>=0;i--){ // rueckwaerts |
| sal_uInt8 nId; |
| sal_uInt16 nSize; |
| sal_uInt8* pSprm; |
| Fill(i, nId, nSize, pSprm); |
| GetTab(nId).Stop(rOut, nId, pSprm, nSize, rMan); |
| } |
| } |
| |
| void Ww1Sprm::Start( |
| Ww1Shell& rOut, Ww1Manager& rMan, sal_uInt16 i) |
| { |
| sal_uInt8 nId; |
| sal_uInt16 nSize; |
| sal_uInt8* pSprm; |
| Fill(i, nId, nSize, pSprm); |
| GetTab(nId).Start(rOut, nId, pSprm, nSize, rMan); |
| } |
| |
| void Ww1Sprm::Start( |
| Ww1Shell& rOut, Ww1Manager& rMan) |
| { |
| if(IsUsed()) |
| for(sal_uInt16 i=0;i<Count();i++) |
| Start(rOut, rMan, i); |
| } |
| |
| //////////////////////////////////////////////////////////// SingleSprm |
| void Ww1SingleSprm::Start( |
| Ww1Shell&, sal_uInt8 /*nId*/, sal_uInt8*, sal_uInt16, Ww1Manager&) |
| { |
| } |
| |
| void Ww1SingleSprm::Stop( |
| Ww1Shell&, sal_uInt8, sal_uInt8*, sal_uInt16, Ww1Manager&) |
| { |
| // ASSERT(sal_False, "Unknown Sprm"); |
| } |
| |
| ////////////////////////////////////////////////////////////////// STOP |
| // |
| // folgende defines werden genutzt zur implementierung der |
| // Stop()-Member der SingleSprm-klassen, da diese im normalfalle |
| // lediglich EndItem(s) in die shell stellen. |
| // |
| #define STOP1(Class, Code) \ |
| void Class::Stop( \ |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8*, sal_uInt16, Ww1Manager&) { \ |
| rOut.EndItem(Code); } |
| #define STOP2(Class, Code1, Code2) \ |
| void Class::Stop( \ |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8*, sal_uInt16, Ww1Manager&) { \ |
| rOut.EndItem(Code1).EndItem(Code2); } |
| |
| /////////////////////////////////////////////////////// SingleSprmXxxxx |
| // |
| // hier beginnt die auswertung der eigentlichen sprms. jeder sprmtyp |
| // hat eine eigene klasse, die die virtualen methoden start und stop |
| // implementiert. die klassen stehen in der sprm-tab, die statischer |
| // member von Ww1Sprm ist. taucht ein sprm im dokument auf, werden die |
| // virtualen methoden bei beginn und ende der formatierung gerufen. |
| // |
| void Ww1SingleSprmPDxaLeft::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| SvxLRSpaceItem aLR((SvxLRSpaceItem&)rOut.GetAttr(RES_LR_SPACE)); |
| short nPara = SVBT16ToShort(pSprm); |
| if(nPara < 0) |
| nPara = 0; |
| if(aLR.GetTxtFirstLineOfst() < -nPara) |
| aLR.SetTxtFirstLineOfst(-nPara); // sonst weigert sich SetTxtLeft() |
| aLR.SetTxtLeft(nPara); |
| rOut << aLR; |
| } |
| |
| void Ww1SingleSprmPDxaRight::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| SvxLRSpaceItem aLR((SvxLRSpaceItem&)rOut.GetAttr(RES_LR_SPACE)); |
| short nPara = SVBT16ToShort(pSprm); |
| if(nPara < 0) |
| nPara = 0; |
| aLR.SetRight(nPara); |
| rOut << aLR; |
| } |
| |
| void Ww1SingleSprmPDxaLeft1::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| SvxLRSpaceItem aLR((SvxLRSpaceItem&)rOut.GetAttr(RES_LR_SPACE)); |
| short nPara = SVBT16ToShort(pSprm); |
| if(-nPara >(short)aLR.GetTxtLeft()) |
| nPara = -(short)aLR.GetTxtLeft(); |
| aLR.SetTxtFirstLineOfst(nPara); |
| rOut << aLR; |
| } |
| |
| STOP1(Ww1SingleSprmPDxa, RES_LR_SPACE) |
| |
| void Ww1SingleSprmPJc::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| static SvxAdjust __READONLY_DATA aAdj[] = { |
| SVX_ADJUST_LEFT, |
| SVX_ADJUST_CENTER, |
| SVX_ADJUST_RIGHT, |
| SVX_ADJUST_BLOCK }; |
| sal_uInt8 nPara = SVBT8ToByte(pSprm); |
| nPara %=(sizeof(aAdj)/sizeof(*aAdj)); |
| rOut << SvxAdjustItem(aAdj[nPara], RES_PARATR_ADJUST); |
| } |
| |
| STOP1(Ww1SingleSprmPJc, RES_PARATR_ADJUST) |
| |
| void Ww1SingleSprmPFKeep::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| rOut << SvxFmtSplitItem((SVBT8ToByte(pSprm) & 1) == 0, RES_PARATR_SPLIT); |
| } |
| |
| STOP1(Ww1SingleSprmPFKeep, RES_PARATR_SPLIT) |
| |
| void Ww1SingleSprmPFKeepFollow::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| rOut << SvxFmtKeepItem((SVBT8ToByte(pSprm) & 1) != 0, RES_KEEP); |
| } |
| |
| STOP1(Ww1SingleSprmPFKeepFollow, RES_KEEP) |
| |
| void Ww1SingleSprmPPageBreakBefore::Start( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8* pSprm, sal_uInt16, Ww1Manager&) |
| { |
| rOut << SvxFmtBreakItem(SVBT8ToByte(pSprm) & 1? |
| SVX_BREAK_PAGE_BEFORE:SVX_BREAK_NONE, RES_BREAK ); |
| } |
| |
| STOP1(Ww1SingleSprmPPageBreakBefore, RES_BREAK) |
| |
| SvxBorderLine* Ww1SingleSprmPBrc::SetBorder(SvxBorderLine* pLine, W1_BRC10* pBrc) |
| { |
| sal_uInt16 nCode; |
| if(pBrc->dxpLine2WidthGet() == 0) |
| { |
| switch(pBrc->dxpLine1WidthGet()) |
| { |
| default: ASSERT(sal_False, "unknown linewidth"); |
| case 0: return 0; // keine Linie |
| case 1: nCode = DEF_LINE_WIDTH_0; break; |
| case 2: nCode = DEF_LINE_WIDTH_1; break; |
| case 3: nCode = DEF_LINE_WIDTH_2; break; |
| case 4: nCode = DEF_LINE_WIDTH_3; break; |
| case 5: nCode = DEF_LINE_WIDTH_4; break; |
| } |
| pLine->SetOutWidth(nCode); |
| pLine->SetInWidth(0); |
| } |
| else |
| { |
| switch(pBrc->dxpLine1WidthGet()) |
| { |
| default: ASSERT(sal_False, "unknown linewidth"); |
| case 1: nCode = DEF_DOUBLE_LINE0_IN; break; |
| } |
| pLine->SetOutWidth(nCode); |
| switch(pBrc->dxpLine2WidthGet()) |
| { |
| default: ASSERT(sal_False, "unknown linewidth"); |
| case 1: nCode = DEF_DOUBLE_LINE0_OUT; break; |
| } |
| pLine->SetInWidth(nCode); |
| } |
| switch(pBrc->dxpLine1WidthGet()) |
| { |
| default: ASSERT(sal_False, "unknown space"); |
| case 0: nCode = DEF_DOUBLE_LINE0_DIST; break; |
| case 1: nCode = DEF_DOUBLE_LINE1_DIST; break; |
| case 2: nCode = DEF_DOUBLE_LINE2_DIST; break; |
| case 3: nCode = DEF_DOUBLE_LINE3_DIST; break; |
| } |
| pLine->SetDistance(nCode); |
| return pLine; |
| } |
| |
| void Ww1SingleSprmPBrc::Start( |
| Ww1Shell& rOut, sal_uInt8, |
| W1_BRC10* pBrc, |
| sal_uInt16 |
| #ifdef DBG_UTIL |
| nSize |
| #endif |
| , |
| Ww1Manager& /*rMan*/, |
| SvxBoxItem& aBox) |
| { |
| ASSERT(sizeof(W1_BRC10) == nSize, "sizemissmatch"); |
| if(pBrc->dxpSpaceGet()) |
| aBox.SetDistance(10 + 20 * pBrc->dxpSpaceGet()); |
| //??? Warum 10+... ???? |
| |
| if( rOut.IsInFly() ) |
| rOut.SetFlyFrmAttr( aBox ); |
| else |
| rOut << aBox; |
| |
| if(pBrc->fShadowGet()) |
| { |
| Color aBlack(COL_BLACK); // schwarzer... |
| SvxShadowItem aS(RES_SHADOW,(const Color*)&aBlack, 32, |
| SVX_SHADOW_BOTTOMRIGHT); // 1.6 tw breit |
| if( rOut.IsInFly() ) |
| rOut.SetFlyFrmAttr( aS ); |
| else |
| rOut << aS; |
| } |
| } |
| |
| STOP2(Ww1SingleSprmPBrc, RES_BOX, RES_SHADOW) |
| |
| static sal_uInt16 __READONLY_DATA nBrcTrans[BRC_ANZ] = |
| { BOX_LINE_TOP, BOX_LINE_LEFT, BOX_LINE_BOTTOM, BOX_LINE_RIGHT }; |
| |
| void Ww1SingleSprmPBrc10::Start( |
| Ww1Shell& rOut, sal_uInt8 nId, sal_uInt8* pSprm, sal_uInt16 nSize, Ww1Manager& rMan) |
| { |
| |
| W1_BRC10* pBrc =(W1_BRC10*)pSprm; |
| const SfxPoolItem &rItem = ( ( rOut.IsInFly() ) ? |
| rOut.GetFlyFrmAttr(RES_BOX) :rOut.GetAttr(RES_BOX)); |
| const SvxBoxItem &rBoxItem = (const SvxBoxItem&)rItem; |
| SvxBoxItem aBox( rBoxItem ); |
| // rOut >> aBox; |
| SvxBorderLine aLine; |
| aBox.SetLine(SetBorder(&aLine, pBrc), nBrcTrans[nLine] ); |
| Ww1SingleSprmPBrc::Start(rOut, nId, pBrc, nSize, rMan, aBox); |
| } |
| |
| STOP1(Ww1SingleSprmParaSpace, RES_UL_SPACE) |
| |
| void Ww1SingleSprmPDyaBefore::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nPara = SVBT16ToShort(pSprm); |
| if(nPara < 0) |
| nPara = -nPara; |
| SvxULSpaceItem aUL((SvxULSpaceItem&)rOut.GetAttr(RES_UL_SPACE)); |
| aUL.SetUpper(nPara); |
| rOut << aUL; |
| } |
| |
| void Ww1SingleSprmPDyaAfter::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nPara = SVBT16ToShort(pSprm); |
| if(nPara < 0) |
| nPara = -nPara; |
| SvxULSpaceItem aUL((SvxULSpaceItem&)rOut.GetAttr(RES_UL_SPACE)); |
| aUL.SetLower(nPara); |
| rOut << aUL; |
| } |
| |
| STOP1(Ww1SingleSprmPDyaLine, RES_PARATR_LINESPACING) |
| |
| void Ww1SingleSprmPDyaLine::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nSpace = SVBT16ToShort(pSprm); |
| if(nSpace < 0) |
| nSpace = -nSpace; |
| SvxLineSpacingItem aLSpc( LINE_SPACE_DEFAULT_HEIGHT, RES_PARATR_LINESPACING ); |
| if(sal_True) |
| {// MultilineSpace(proportional) |
| long n = nSpace * 100 / 240; // W1: 240 = 100%, SW: 100 = 100% |
| if(n>200) |
| n = 200; // SW_UI-Maximum |
| aLSpc.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO; |
| aLSpc.SetPropLineSpace((sal_uInt8)n); |
| } |
| else |
| {// Fixed / Minimum |
| aLSpc.SetLineHeight((sal_uInt16)nSpace); |
| aLSpc.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF; |
| } |
| rOut << aLSpc; |
| } |
| |
| void Ww1SingleSprmPChgTabsPapx::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| // rOut << 'T'; |
| #endif |
| short nLeftPMgn = 0; // Koordinaten etwa gleich ?? |
| // ( pAktColl ) ? pCollA[nAktColl].nLeftParaMgn |
| // : nLeftParaMgn; // Absatz L-Space |
| |
| short i; |
| sal_uInt8 nDel = pSprm[1]; |
| sal_uInt8* pDel = pSprm + 2; // Del - Array |
| sal_uInt8 nIns = pSprm[nDel*2+2]; |
| sal_uInt8* pIns = pSprm + 2*nDel + 3; // Ins - Array |
| W1_TBD* pTyp = (W1_TBD*)(pSprm + 2*nDel + 2*nIns + 3);// Typ - Array |
| |
| SvxTabStopItem aAttr( (SvxTabStopItem&)rOut.GetNodeOrStyAttr( RES_PARATR_TABSTOP )); |
| |
| SvxTabStop aTabStop; |
| |
| for( i=0; i<nDel; i++ ){ |
| sal_uInt16 nPos = aAttr.GetPos( SVBT16ToShort( pDel + i*2 ) - nLeftPMgn ); |
| if( nPos != SVX_TAB_NOTFOUND ) |
| aAttr.Remove( nPos, 1 ); |
| } |
| |
| for( i=0; i<nIns; i++ ){ |
| short nPos = SVBT16ToShort( pIns + i*2 ) - nLeftPMgn; |
| if( nPos < 0 ) |
| continue; |
| aTabStop.GetTabPos() = nPos; |
| switch( pTyp[i].jcGet() ){ |
| case 0: aTabStop.GetAdjustment() = SVX_TAB_ADJUST_LEFT; break; |
| case 1: aTabStop.GetAdjustment() = SVX_TAB_ADJUST_CENTER; break; |
| case 2: aTabStop.GetAdjustment() = SVX_TAB_ADJUST_RIGHT; break; |
| case 3: aTabStop.GetAdjustment() = SVX_TAB_ADJUST_DECIMAL; break; |
| case 4: continue; // ignoriere Bar |
| } |
| |
| switch( pTyp[i].tlcGet() ){ |
| case 0: aTabStop.GetFill() = ' '; break; |
| case 1: aTabStop.GetFill() = '.'; break; |
| case 2: aTabStop.GetFill() = '-'; break; |
| case 3: |
| case 4: aTabStop.GetFill() = '_'; break; |
| } |
| |
| sal_uInt16 nPos2 = aAttr.GetPos( nPos ); |
| if( nPos2 != SVX_TAB_NOTFOUND ) |
| aAttr.Remove( nPos2, 1 ); // sonst weigert sich das Insert() |
| |
| aAttr.Insert( aTabStop ); |
| } |
| rOut << aAttr; |
| } |
| |
| STOP1(Ww1SingleSprmPChgTabsPapx, RES_PARATR_TABSTOP) |
| |
| void Ww1SingleSprmSGprfIhdt::Start( |
| Ww1Shell& /*rOut*/, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& rMan) |
| { |
| rMan.GetSep().SetGrpfIhdt(SVBT8ToByte(pSprm)); |
| } |
| |
| void Ww1SingleSprmSColumns::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nColSpace = 708; // default 1,25 cm |
| short nNettoWidth = -1; //~ mdt: dxaLeft/Right missing... |
| short nCols = SVBT16ToShort(pSprm); |
| nCols++; |
| if (nCols < 2) |
| return; |
| SwFmtCol aCol; |
| aCol.Init(nCols, nColSpace, nNettoWidth); |
| rOut.GetPageDesc().GetMaster().SetFmtAttr(aCol); |
| } |
| |
| void Ww1SingleSprmPTtp::Start( |
| Ww1Shell& /*rOut*/, sal_uInt8, sal_uInt8*, sal_uInt16, Ww1Manager& rMan) |
| { |
| rMan.SetInTtp( sal_True ); // Besonderheit: wird bei InTable::Stop und |
| // nicht bei InTtp::Stop zurueckgesetzt, |
| // da Auswertung in InTable |
| } |
| |
| void Ww1SingleSprmPTtp::Stop( |
| Ww1Shell& rOut, sal_uInt8, sal_uInt8*, sal_uInt16, Ww1Manager& rMan) |
| { |
| if (rOut.IsInTable() && rMan.HasInTable()) |
| rOut.NextTableRow(); |
| } |
| |
| void Ww1SingleSprmPFInTable::Start( |
| Ww1Shell& /*rOut*/, sal_uInt8, sal_uInt8*, sal_uInt16, |
| Ww1Manager& /*rMan*/) |
| { |
| } |
| |
| void Ww1SingleSprmPFInTable::Stop( |
| Ww1Shell& |
| #ifdef DBG_UTIL |
| rOut |
| #endif |
| , |
| sal_uInt8, sal_uInt8*, sal_uInt16, |
| Ww1Manager& rMan) |
| { |
| ASSERT(rOut.IsInTable(), ""); |
| rMan.SetInTtp( sal_False ); |
| } |
| |
| void Ww1SingleSprmTDxaGapHalf::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nSpace = SVBT16ToShort(pSprm); |
| rOut.SetCellSpace(nSpace); |
| } |
| |
| void Ww1SingleSprmTDefTable10::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 nSize, Ww1Manager& /*rMan*/) |
| { |
| sal_uInt16 i; |
| sal_uInt8 *p = pSprm + 2; // LaengenWord ueberlesen |
| sal_uInt8 nCount = *p; |
| p++; |
| nSize -= 3; |
| // Es fehlt noch: |
| // - GapHalf |
| // - eventuelle Ausduennung der Zellenumrandungen |
| |
| if( nCount < 1 || nCount > 32 || nSize < ( nCount + 1 ) * 2 ) |
| return; |
| |
| // Erstmal die Zellenpositionen einlesen |
| short nPos = SVBT16ToShort( p ); // signed, kann auch neg. sein !!! |
| |
| // if( !rOut.IsTableWidthSet() ){ // Muss Tabellenbreite und -Ausrichtung |
| // noch gesetzt werden ? |
| { |
| short nWholeWidth = SVBT16ToShort( p + 2 * nCount ) - nPos; |
| rOut.SetTableWidth( (sal_uInt16)nWholeWidth ); // Tabellenbreite setzen |
| |
| // Pos der Tabelle setzen |
| long nMidTab = nPos + nWholeWidth / 2; // TabellenMitte |
| const SwFrmFmt &rFmt = rOut.GetPageDesc().GetMaster(); |
| const SvxLRSpaceItem& rLR = rFmt.GetLRSpace(); |
| long nRight = rFmt.GetFrmSize().GetWidth() |
| - rLR.GetLeft() - rLR.GetRight(); |
| |
| sal_Int16 eOri = text::HoriOrientation::LEFT; |
| if( nPos > MINLAY ){ // per Zuppeln positioniert |
| if ( nMidTab <= nRight / 3 ) // 1/3 der Seite |
| eOri = text::HoriOrientation::LEFT; |
| else if ( nMidTab <= 2 * nRight / 3 ) // 2/3 der Seite |
| eOri = text::HoriOrientation::CENTER; |
| else |
| eOri = text::HoriOrientation::RIGHT; |
| } |
| rOut.SetTableOrient( eOri ); |
| } |
| |
| sal_uInt8* pEndPos = p+2; |
| sal_uInt8* pTc0 = ( nSize >= nCount * 10 ) ? pEndPos + 2 * nCount : 0; |
| sal_uInt16 nCellsDeleted = 0; // fuer gemergte Zellen |
| |
| for( i = 0; i < nCount; i++ ){ |
| // Info sammeln |
| W1_TC* pTc = (W1_TC*)pTc0; |
| sal_Bool bMerged = (pTc) ? pTc->fMergedGet() : sal_False; |
| |
| // Zellenbreiten setzen |
| sal_uInt16 nPos1 = SVBT16ToShort( pEndPos ); |
| if( !bMerged ) |
| rOut.SetCellWidth( nPos1 - nPos, i - nCellsDeleted ); |
| // Zellenbreite setzen |
| // Wechselwirkung mit GapHalf fehlt noch |
| // ( GapHalf wird noch ignoriert ) |
| pEndPos+=2; |
| nPos = nPos1; |
| |
| if( pTc0 ){ // gibts TCs ueberhaupt ? |
| W1_TC* pTc2 = (W1_TC*)pTc0; |
| sal_Bool bMerged2 = pTc2->fMergedGet(); |
| // ASSERT( !bMerged2, "Gemergte Tabellenzellen noch nicht vollstaendig implementiert" ); |
| if( !bMerged2 ){ |
| // und nun die Umrandungen |
| SvxBoxItem aBox( (SvxBoxItem&)rOut.GetCellAttr( RES_BOX )); |
| SvxBorderLine aLine; |
| W1_BRC10* pBrc = pTc2->rgbrcGet(); |
| for( sal_uInt16 j=0; j<4; j++ ){ |
| aBox.SetLine(Ww1SingleSprmPBrc::SetBorder(&aLine, pBrc), |
| nBrcTrans[j]); |
| pBrc++; |
| } |
| rOut.SetCellBorder( aBox, i - nCellsDeleted ); |
| }else{ |
| // gemergte Zellen entfernen |
| rOut.DeleteCell( i - nCellsDeleted ); |
| nCellsDeleted++; |
| } |
| pTc0+=sizeof(W1_TC); // 10 |
| } |
| } |
| } |
| |
| |
| void Ww1SingleSprmTDyaRowHeight::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nSpace = SVBT16ToShort(pSprm); |
| rOut.SetCellHeight(nSpace); |
| } |
| |
| // Fastsave-Attribute brauche ich als Dymmys nicht |
| |
| void Ww1SingleSprmPpc::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& rMan) |
| { |
| sal_uInt8 nPpc = SVBT8ToByte(pSprm); |
| |
| if (rOut.IsInTable()) // Flys in Tabellen kann PMW |
| return; // nicht |
| |
| RndStdIds eAnchor; // Bindung |
| sal_Int16 eHRel; // Seite oder Seitenrand |
| sal_Int16 eVRel; // Seite oder Seitenrand |
| |
| switch ( ( nPpc & 0x30 ) >> 4 ){ // Y - Bindung bestimmt Sw-Bindung |
| case 0: eAnchor = FLY_AT_PARA; // Vert Margin |
| eVRel = text::RelOrientation::PRINT_AREA; |
| // if( nYPos < 0 ) |
| // nYPos = 0; // koennen wir nicht |
| break; |
| /* case 1:*/ // Vert. Seite |
| default:eAnchor = FLY_AT_PAGE; // Vert Page oder unknown |
| eVRel = text::RelOrientation::FRAME; |
| break; // 2=Vert. Paragraph, 3=Use Default |
| } |
| |
| switch ( ( nPpc & 0xc0 ) >> 6 ){ // X - Bindung -> Koordinatentransformation |
| case 0: // Hor. Spalte |
| case 1: // Hor. Absatz |
| eHRel = text::RelOrientation::PRINT_AREA; |
| // nXPos += nPgLeft; // in Seiten-Koordinaten umrechnen |
| break; |
| /* case 2:*/ // Hor. Seite |
| default: |
| eHRel = text::RelOrientation::FRAME; |
| break; |
| } |
| |
| if( !rOut.IsInFly() && rMan.IsInStyle() ){ |
| rOut.BeginFly( eAnchor ); // Starte StyleFly |
| }else{ |
| rOut.SetFlyAnchor( eAnchor ); // Setze Anker |
| } |
| } |
| |
| void Ww1SingleSprmPDxaAbs::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& rMan) |
| { |
| short nXPos = SVBT16ToShort(pSprm); |
| |
| if( rMan.IsInStyle() && !rOut.IsInFly() ){ |
| rOut.BeginFly(); // Fly ohne PPc-Attribut |
| } |
| |
| sal_Int16 eHRel = text::RelOrientation::FRAME; |
| sal_Int16 eHAlign = text::HoriOrientation::NONE; |
| |
| switch( nXPos ){ // besondere X-Positionen ? |
| case 0: |
| case -12: eHAlign = text::HoriOrientation::NONE; nXPos = 0; break; // Mogel: innen -> links |
| // eigentich text::HoriOrientation::LEFT, aber dann verrueckt |
| // ein Abstand nach aussen den Fly |
| case -4: eHAlign = text::HoriOrientation::CENTER; nXPos = 0; break; // zentriert |
| case -8: // rechts |
| case -16: eHAlign = text::HoriOrientation::RIGHT; nXPos = 0; break; // Mogel: aussen -> rechts |
| // default: nXPos += (short)nIniFlyDx; break; // Korrekturen per Ini-Datei |
| } |
| rOut.SetFlyXPos( nXPos, eHRel, eHAlign ); |
| } |
| |
| void Ww1SingleSprmPDyaAbs::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nYPos = SVBT16ToShort(pSprm); |
| sal_Int16 eVRel = text::RelOrientation::FRAME; |
| sal_Int16 eVAlign = text::VertOrientation::NONE; |
| |
| switch( nYPos ){ // besondere Y-Positionen ? |
| case -4: eVAlign = text::VertOrientation::TOP; nYPos = 0; break; // oben |
| case -8: eVAlign = text::VertOrientation::CENTER; nYPos = 0; break; // zentriert |
| case -12: eVAlign = text::VertOrientation::BOTTOM; nYPos = 0; break; // unten |
| // default: nYPos += (short)nIniFlyDy; break; // Korrekturen per Ini-Datei |
| } |
| rOut.SetFlyYPos( nYPos, eVRel, eVAlign ); |
| } |
| |
| void Ww1SingleSprmPDxaWidth::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| short nDxaWidth = SVBT16ToShort(pSprm); |
| rOut.SetFlyFrmAttr( SwFmtFrmSize( ATT_VAR_SIZE, nDxaWidth, MINFLY ) ); |
| } |
| |
| void Ww1SingleSprmPFromText::Start( |
| Ww1Shell& rOut, sal_uInt8 /*nId*/, sal_uInt8* pSprm, sal_uInt16 /*nSize*/, Ww1Manager& /*rMan*/) |
| { |
| if( rOut.IsInFly() ){ // Kommt auch ausserhalb eines Flys vor, hat |
| // dann aber offensichtlich nichts zu bedeuten. |
| // Einen impliziten Fly-Anfang bedeutet es |
| // definitiv nicht |
| short nFromText = SVBT16ToShort(pSprm); |
| |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtLeft( nFromText ); |
| aLR.SetRight( nFromText ); |
| rOut.SetFlyFrmAttr( aLR ); |
| |
| rOut.SetFlyFrmAttr( SvxULSpaceItem( nFromText, nFromText, RES_UL_SPACE ) ); |
| } |
| } |
| |
| #undef STOP1 |
| #undef STOP2 |
| |
| |