| /************************************************************** |
| * |
| * 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 <tools/list.hxx> |
| |
| #include <hintids.hxx> |
| #include "uitool.hxx" |
| #include <sfx2/app.hxx> |
| #include <svx/rulritem.hxx> |
| #include <editeng/tstpitem.hxx> |
| #include <sfx2/request.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <svl/eitem.hxx> |
| #include <svl/whiter.hxx> |
| #include <svx/ruler.hxx> |
| #include <editeng/protitem.hxx> |
| #include <svl/rectitem.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <fmtfsize.hxx> |
| #include <fmthdft.hxx> |
| #include <fmtclds.hxx> |
| #include <fmtornt.hxx> |
| #include <frmatr.hxx> |
| #include <edtwin.hxx> |
| #include "view.hxx" |
| #include "wrtsh.hxx" |
| #include "basesh.hxx" |
| #include "cmdid.h" |
| #include "viewopt.hxx" |
| #include "tabcol.hxx" |
| #include "frmfmt.hxx" // FrameFormat |
| #include "pagedesc.hxx" // Aktuelles Seitenformat |
| #include "wview.hxx" |
| #include "fmtcol.hxx" |
| #include "section.hxx" |
| |
| // -> #i23726# |
| #include "ndtxt.hxx" |
| #include "pam.hxx" |
| // <- #i23726# |
| |
| #include <IDocumentSettingAccess.hxx> |
| |
| using namespace ::com::sun::star; |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Debug-Methode |
| --------------------------------------------------------------------*/ |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Columns eintueten |
| --------------------------------------------------------------------*/ |
| |
| |
| void lcl_FillSvxColumn(const SwFmtCol& rCol, |
| sal_uInt16 nTotalWidth, |
| SvxColumnItem& rColItem, |
| long nDistance) |
| { |
| const SwColumns& rCols = rCol.GetColumns(); |
| sal_uInt16 nWidth = 0; |
| |
| sal_Bool bOrtho = rCol.IsOrtho() && rCols.Count(); |
| long nInnerWidth = 0; |
| if( bOrtho ) |
| { |
| nInnerWidth = nTotalWidth; |
| for ( sal_uInt16 i = 0; i < rCols.Count(); ++i ) |
| { |
| SwColumn* pCol = rCols[i]; |
| nInnerWidth -= pCol->GetLeft() + pCol->GetRight(); |
| } |
| if( nInnerWidth < 0 ) |
| nInnerWidth = 0; |
| else |
| nInnerWidth /= rCols.Count(); |
| } |
| for ( sal_uInt16 i = 0; i < rCols.Count(); ++i ) |
| { |
| SwColumn* pCol = rCols[i]; |
| const sal_uInt16 nStart = sal_uInt16(pCol->GetLeft() + nWidth + nDistance); |
| if( bOrtho ) |
| nWidth = static_cast< sal_uInt16 >(nWidth + nInnerWidth + pCol->GetLeft() + pCol->GetRight()); |
| else |
| nWidth = static_cast< sal_uInt16 >(nWidth + rCol.CalcColWidth(i, nTotalWidth)); |
| const sal_uInt16 nEnd = sal_uInt16(nWidth - pCol->GetRight() + nDistance); |
| |
| SvxColumnDescription aColDesc(nStart, nEnd, sal_True); |
| rColItem.Append(aColDesc); |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: ColumnItem in ColumnInfo ueberfuehren |
| --------------------------------------------------------------------*/ |
| |
| |
| void lcl_ConvertToCols(const SvxColumnItem& rColItem, |
| sal_uInt16 nTotalWidth, |
| SwFmtCol& rCols) |
| { |
| ASSERT( rCols.GetNumCols() == rColItem.Count(), "Column count mismatch" ); |
| // #126939# ruler executes that change the columns shortly after the selection has changed |
| // can result in a crash |
| if(rCols.GetNumCols() != rColItem.Count()) |
| return; |
| |
| sal_uInt16 nLeft = 0; |
| SwTwips nSumAll= 0; // Summiere alle Spalten und Raender auf |
| |
| SwColumns& rArr = rCols.GetColumns(); |
| |
| // Tabcols der Reihe nach |
| for( sal_uInt16 i=0; i < rColItem.Count()-1; ++i ) |
| { |
| DBG_ASSERT(rColItem[i+1].nStart >= rColItem[i].nEnd,"\201berlappende Spalten" ); |
| sal_uInt16 nStart = static_cast< sal_uInt16 >(rColItem[i+1].nStart); |
| sal_uInt16 nEnd = static_cast< sal_uInt16 >(rColItem[i].nEnd); |
| if(nStart < nEnd) |
| nStart = nEnd; |
| const sal_uInt16 nDiff = nStart - nEnd; |
| const sal_uInt16 nRight = nDiff / 2; |
| |
| sal_uInt16 nWidth = static_cast< sal_uInt16 >(rColItem[i].nEnd - rColItem[i].nStart); |
| nWidth += nLeft + nRight; |
| |
| SwColumn* pCol = rArr[i]; |
| pCol->SetWishWidth( sal_uInt16(long(rCols.GetWishWidth()) * long(nWidth) / |
| long(nTotalWidth) )); |
| pCol->SetLeft( nLeft ); |
| pCol->SetRight( nRight ); |
| nSumAll += pCol->GetWishWidth(); |
| |
| nLeft = nRight; |
| } |
| rArr[rColItem.Count()-1]->SetLeft( nLeft ); |
| |
| //Die Differenz aus der Gesamtwunschbreite und der Summe der bisher berechneten |
| // Spalten und Raender sollte die Breite der letzten Spalte ergeben. |
| rArr[rColItem.Count()-1]->SetWishWidth( rCols.GetWishWidth() - (sal_uInt16)nSumAll ); |
| |
| rCols.SetOrtho(sal_False, 0, 0 ); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Tabs loeschen |
| --------------------------------------------------------------------*/ |
| |
| |
| void lcl_EraseDefTabs(SvxTabStopItem& rTabStops) |
| { |
| // Def Tabs loeschen |
| for ( sal_uInt16 i = 0; i < rTabStops.Count(); ) |
| { |
| // Hier auch den DefTab auf Null rausschmeissen |
| if ( SVX_TAB_ADJUST_DEFAULT == rTabStops[i].GetAdjustment() || |
| rTabStops[i].GetTabPos() == 0 ) |
| { |
| rTabStops.Remove(i); |
| continue; |
| } |
| ++i; |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Seitenrand umdrehen |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwView::SwapPageMargin(const SwPageDesc& rDesc, SvxLRSpaceItem& rLRSpace) |
| { |
| sal_uInt16 nPhyPage, nVirPage; |
| GetWrtShell().GetPageNum( nPhyPage, nVirPage ); |
| |
| if ( rDesc.GetUseOn() == nsUseOnPage::PD_MIRROR && (nPhyPage % 2) == 0 ) |
| { |
| long nTmp = rLRSpace.GetRight(); |
| rLRSpace.SetRight( rLRSpace.GetLeft() ); |
| rLRSpace.SetLeft( nTmp ); |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Wenn der Rahmenrand verschoben wird, sollen die |
| Spaltentrenner an der gleichen absoluten Position bleiben |
| --------------------------------------------------------------------*/ |
| |
| |
| void lcl_Scale(long& nVal, long nScale) |
| { |
| nVal *= nScale; |
| nVal >>= 8; |
| } |
| |
| void ResizeFrameCols(SwFmtCol& rCol, |
| long nOldWidth, |
| long nNewWidth, |
| long nLeftDelta ) |
| { |
| SwColumns& rArr = rCol.GetColumns(); |
| long nWishSum = (long)rCol.GetWishWidth(); |
| long nWishDiff = (nWishSum * 100/nOldWidth * nNewWidth) / 100 - nWishSum; |
| long nNewWishWidth = nWishSum + nWishDiff; |
| if(nNewWishWidth > 0xffffl) |
| { |
| // wenn die Wunschbreite zu gross wird, dann muessen alle Werte passend skaliert werden |
| long nScale = (0xffffl << 8)/ nNewWishWidth; |
| for(sal_uInt16 i = 0; i < rArr.Count(); i++) |
| { |
| SwColumn* pCol = rArr.GetObject(i); |
| long nVal = pCol->GetWishWidth(); |
| lcl_Scale(nVal, nScale); |
| pCol->SetWishWidth((sal_uInt16) nVal); |
| nVal = pCol->GetLeft(); |
| lcl_Scale(nVal, nScale); |
| pCol->SetLeft((sal_uInt16) nVal); |
| nVal = pCol->GetRight(); |
| lcl_Scale(nVal, nScale); |
| pCol->SetRight((sal_uInt16) nVal); |
| } |
| lcl_Scale(nNewWishWidth, nScale); |
| lcl_Scale(nWishDiff, nScale); |
| } |
| rCol.SetWishWidth( (sal_uInt16) (nNewWishWidth) ); |
| |
| if( nLeftDelta >= 2 || nLeftDelta <= -2) |
| rArr[0]->SetWishWidth(rArr[0]->GetWishWidth() + (sal_uInt16)nWishDiff); |
| else |
| rArr[rArr.Count()-1]->SetWishWidth(rArr[rArr.Count()-1]->GetWishWidth() + (sal_uInt16)nWishDiff); |
| //reset auto width |
| rCol.SetOrtho(sal_False, 0, 0 ); |
| } |
| /*-------------------------------------------------------------------- |
| Beschreibung: Hier werden alle Aenderungen der Tableiste |
| wieder in das Modell geschossen |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwView::ExecTabWin( SfxRequest& rReq ) |
| { |
| SwWrtShell &rSh = GetWrtShell(); |
| const sal_uInt16 nFrmType = rSh.IsObjSelected() ? |
| FRMTYPE_DRAWOBJ : |
| rSh.GetFrmType(0,sal_True); |
| const sal_Bool bFrmSelection = rSh.IsFrmSelected(); |
| const sal_Bool bBrowse = rSh.GetViewOptions()->getBrowseMode(); |
| |
| const sal_uInt16 nSlot = rReq.GetSlot(); |
| const SfxItemSet* pReqArgs = rReq.GetArgs(); |
| const sal_uInt16 nDescId = rSh.GetCurPageDesc(); |
| const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId ); |
| |
| const sal_Bool bVerticalWriting = rSh.IsInVerticalText(); |
| const SwFmtHeader& rHeaderFmt = rDesc.GetMaster().GetHeader(); |
| SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt(); |
| |
| const SwFmtFooter& rFooterFmt = rDesc.GetMaster().GetFooter(); |
| SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt(); |
| |
| const SwFmtFrmSize &rFrmSize = rDesc.GetMaster().GetFrmSize(); |
| |
| const SwRect& rPageRect = rSh.GetAnyCurRect(RECT_PAGE); |
| const long nPageWidth = bBrowse ? rPageRect.Width() : rFrmSize.GetWidth(); |
| const long nPageHeight = bBrowse ? rPageRect.Height() : rFrmSize.GetHeight(); |
| |
| sal_Bool bUnlockView = sal_False; |
| rSh.StartAllAction(); |
| sal_Bool bSect = 0 != (nFrmType & FRMTYPE_COLSECT); |
| |
| switch( nSlot ) |
| { |
| case SID_ATTR_LONG_LRSPACE: |
| if ( pReqArgs ) |
| { |
| SvxLongLRSpaceItem aLongLR( (const SvxLongLRSpaceItem&)pReqArgs-> |
| Get( SID_ATTR_LONG_LRSPACE ) ); |
| SvxLRSpaceItem aLR(RES_LR_SPACE); |
| if ( !bSect && (bFrmSelection || nFrmType & FRMTYPE_FLY_ANY) ) |
| { |
| SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt()); |
| const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED); |
| |
| sal_Bool bVerticalFrame(sal_False); |
| { |
| sal_Bool bRTL; |
| sal_Bool bVertL2R; |
| bVerticalFrame = ( bFrmSelection && |
| rSh.IsFrmVertical(sal_True, bRTL, bVertL2R) ) || |
| ( !bFrmSelection && bVerticalWriting); |
| } |
| long nDeltaX = bVerticalFrame ? |
| rRect.Right() - rPageRect.Right() + aLongLR.GetRight() : |
| rPageRect.Left() + aLongLR.GetLeft() - rRect.Left(); |
| |
| SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE, |
| RES_VERT_ORIENT, RES_HORI_ORIENT, |
| RES_COL, RES_COL, 0 ); |
| |
| if(bVerticalFrame) |
| { |
| SwFmtVertOrient aVertOrient(pFmt->GetVertOrient()); |
| aVertOrient.SetVertOrient(text::VertOrientation::NONE); |
| aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaX ); |
| aSet.Put( aVertOrient ); |
| } |
| else |
| { |
| SwFmtHoriOrient aHoriOrient( pFmt->GetHoriOrient() ); |
| aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE ); |
| aHoriOrient.SetPos( aHoriOrient.GetPos() + nDeltaX ); |
| aSet.Put( aHoriOrient ); |
| } |
| |
| SwFmtFrmSize aSize( pFmt->GetFrmSize() ); |
| long nOldWidth = (long) aSize.GetWidth(); |
| |
| if(aSize.GetWidthPercent()) |
| { |
| SwRect aRect; |
| rSh.CalcBoundRect(aRect, FLY_AS_CHAR); |
| long nPrtWidth = aRect.Width(); |
| aSize.SetWidthPercent(sal_uInt8((nPageWidth - aLongLR.GetLeft() - aLongLR.GetRight()) * 100 /nPrtWidth)); |
| } |
| else |
| aSize.SetWidth( nPageWidth - |
| (aLongLR.GetLeft() + aLongLR.GetRight())); |
| |
| if( nFrmType & FRMTYPE_COLUMN ) |
| { |
| SwFmtCol aCol(pFmt->GetCol()); |
| |
| ::ResizeFrameCols(aCol, nOldWidth, (long)aSize.GetWidth(), nDeltaX ); |
| aSet.Put(aCol); |
| } |
| |
| aSet.Put( aSize ); |
| |
| rSh.StartAction(); |
| rSh.Push(); |
| rSh.SetFlyFrmAttr( aSet ); |
| //die Rahmenselektion wieder aufheben |
| if(!bFrmSelection && rSh.IsFrmSelected()) |
| { |
| rSh.UnSelectFrm(); |
| rSh.LeaveSelFrmMode(); |
| } |
| rSh.Pop(); |
| rSh.EndAction(); |
| } |
| else if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER )) |
| { |
| // Seitenraender rausrechnen |
| long nOld = rDesc.GetMaster().GetLRSpace().GetLeft(); |
| aLongLR.SetLeft( nOld > aLongLR.GetLeft() ? 0 : aLongLR.GetLeft() - nOld ); |
| |
| nOld = rDesc.GetMaster().GetLRSpace().GetRight(); |
| aLongLR.SetRight( nOld > (sal_uInt16)aLongLR.GetRight() ? 0 : aLongLR.GetRight() - nOld ); |
| aLR.SetLeft((sal_uInt16)aLongLR.GetLeft()); |
| aLR.SetRight((sal_uInt16)aLongLR.GetRight()); |
| |
| if ( nFrmType & FRMTYPE_HEADER && pHeaderFmt ) |
| pHeaderFmt->SetFmtAttr( aLR ); |
| else if( nFrmType & FRMTYPE_FOOTER && pFooterFmt ) |
| pFooterFmt->SetFmtAttr( aLR ); |
| } |
| else if( nFrmType == FRMTYPE_DRAWOBJ) |
| { |
| SwRect aRect( rSh.GetObjRect() ); |
| aRect.Left( aLongLR.GetLeft() + rPageRect.Left() ); |
| aRect.Right( rPageRect.Right() - aLongLR.GetRight()); |
| rSh.SetObjRect( aRect ); |
| } |
| else if(bSect || rSh.IsDirectlyInSection()) |
| { |
| //change the section indents and the columns if available |
| //at first determine the changes |
| SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0); |
| const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0); |
| aSectRect.Pos() += aTmpRect.Pos(); |
| long nLeftDiff = aLongLR.GetLeft() - (long)(aSectRect.Left() - rPageRect.Left() ); |
| long nRightDiff = aLongLR.GetRight() - (long)( rPageRect.Right() - aSectRect.Right()); |
| //change the LRSpaceItem of the section accordingly |
| const SwSection* pCurrSect = rSh.GetCurrSection(); |
| const SwSectionFmt* pSectFmt = pCurrSect->GetFmt(); |
| SvxLRSpaceItem aLRTmp = pSectFmt->GetLRSpace(); |
| aLRTmp.SetLeft(aLRTmp.GetLeft() + nLeftDiff); |
| aLRTmp.SetRight(aLRTmp.GetRight() + nRightDiff); |
| SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L); |
| aSet.Put(aLRTmp); |
| //change the first/last column |
| if(bSect) |
| { |
| SwFmtCol aCols( pSectFmt->GetCol() ); |
| long nDiffWidth = nLeftDiff + nRightDiff; |
| ::ResizeFrameCols(aCols, aSectRect.Width(), aSectRect.Width() - nDiffWidth, nLeftDiff ); |
| aSet.Put( aCols ); |
| } |
| SwSectionData aData(*pCurrSect); |
| rSh.UpdateSection(rSh.GetSectionFmtPos(*pSectFmt), aData, &aSet); |
| } |
| else |
| { // Seitenraender einstellen |
| aLR.SetLeft((sal_uInt16)aLongLR.GetLeft()); |
| aLR.SetRight((sal_uInt16)aLongLR.GetRight()); |
| SwapPageMargin( rDesc, aLR ); |
| SwPageDesc aDesc( rDesc ); |
| aDesc.GetMaster().SetFmtAttr( aLR ); |
| rSh.ChgPageDesc( nDescId, aDesc ); |
| } |
| } |
| break; |
| |
| // apply new left and right margins to current page style |
| case SID_ATTR_PAGE_LRSPACE: |
| if ( pReqArgs ) |
| { |
| const SvxLongLRSpaceItem aLongLR( static_cast<const SvxLongLRSpaceItem&>(pReqArgs->Get( SID_ATTR_PAGE_LRSPACE )) ); |
| |
| SwPageDesc aDesc( rDesc ); |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetLeft((sal_uInt16)aLongLR.GetLeft()); |
| aLR.SetRight((sal_uInt16)aLongLR.GetRight()); |
| SwapPageMargin( rDesc, aLR ); |
| aDesc.GetMaster().SetFmtAttr( aLR ); |
| } |
| rSh.ChgPageDesc( nDescId, aDesc ); |
| } |
| break; |
| |
| case SID_ATTR_LONG_ULSPACE: |
| if ( pReqArgs ) |
| { |
| SvxLongULSpaceItem aLongULSpace( (const SvxLongULSpaceItem&)pReqArgs-> |
| Get( SID_ATTR_LONG_ULSPACE )); |
| |
| if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY ) |
| { |
| SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt()); |
| const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED); |
| const long nDeltaY = rPageRect.Top() + aLongULSpace.GetUpper() - rRect.Top(); |
| const long nHeight = nPageHeight - (aLongULSpace.GetUpper() + aLongULSpace.GetLower()); |
| |
| SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE, |
| RES_VERT_ORIENT, RES_HORI_ORIENT, 0 ); |
| //which of the orientation attributes is to be put depends on the frame's environment |
| sal_Bool bRTL; |
| sal_Bool bVertL2R; |
| if ( ( bFrmSelection && |
| rSh.IsFrmVertical(sal_True, bRTL, bVertL2R ) ) || |
| ( !bFrmSelection && bVerticalWriting ) ) |
| { |
| SwFmtHoriOrient aHoriOrient(pFmt->GetHoriOrient()); |
| aHoriOrient.SetHoriOrient(text::HoriOrientation::NONE); |
| aHoriOrient.SetPos(aHoriOrient.GetPos() + nDeltaY ); |
| aSet.Put( aHoriOrient ); |
| } |
| else |
| { |
| SwFmtVertOrient aVertOrient(pFmt->GetVertOrient()); |
| aVertOrient.SetVertOrient(text::VertOrientation::NONE); |
| aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY ); |
| aSet.Put( aVertOrient ); |
| } |
| SwFmtFrmSize aSize(pFmt->GetFrmSize()); |
| if(aSize.GetHeightPercent()) |
| { |
| SwRect aRect; |
| rSh.CalcBoundRect(aRect, FLY_AS_CHAR); |
| long nPrtHeight = aRect.Height(); |
| aSize.SetHeightPercent(sal_uInt8(nHeight * 100 /nPrtHeight)); |
| } |
| else |
| aSize.SetHeight(nHeight ); |
| |
| aSet.Put( aSize ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| else if( nFrmType == FRMTYPE_DRAWOBJ ) |
| { |
| SwRect aRect( rSh.GetObjRect() ); |
| aRect.Top( aLongULSpace.GetUpper() + rPageRect.Top() ); |
| aRect.Bottom( rPageRect.Bottom() - aLongULSpace.GetLower() ); |
| rSh.SetObjRect( aRect ) ; |
| } |
| else if(bVerticalWriting && (bSect || rSh.IsDirectlyInSection())) |
| { |
| //change the section indents and the columns if available |
| //at first determine the changes |
| SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0); |
| const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0); |
| aSectRect.Pos() += aTmpRect.Pos(); |
| const long nLeftDiff = aLongULSpace.GetUpper() - (long)(aSectRect.Top() - rPageRect.Top()); |
| const long nRightDiff = aLongULSpace.GetLower() - (long)(nPageHeight - aSectRect.Bottom() + rPageRect.Top()); |
| //change the LRSpaceItem of the section accordingly |
| const SwSection* pCurrSect = rSh.GetCurrSection(); |
| const SwSectionFmt* pSectFmt = pCurrSect->GetFmt(); |
| SvxLRSpaceItem aLR = pSectFmt->GetLRSpace(); |
| aLR.SetLeft(aLR.GetLeft() + nLeftDiff); |
| aLR.SetRight(aLR.GetRight() + nRightDiff); |
| SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L); |
| aSet.Put(aLR); |
| //change the first/last column |
| if(bSect) |
| { |
| SwFmtCol aCols( pSectFmt->GetCol() ); |
| long nDiffWidth = nLeftDiff + nRightDiff; |
| ::ResizeFrameCols(aCols, aSectRect.Height(), aSectRect.Height() - nDiffWidth, nLeftDiff ); |
| aSet.Put( aCols ); |
| } |
| SwSectionData aData(*pCurrSect); |
| rSh.UpdateSection(rSh.GetSectionFmtPos(*pSectFmt), aData, &aSet); |
| } |
| else |
| { SwPageDesc aDesc( rDesc ); |
| |
| if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER )) |
| { |
| |
| const sal_Bool bHead = nFrmType & FRMTYPE_HEADER ? sal_True : sal_False; |
| SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() ); |
| if ( bHead ) |
| aUL.SetUpper( (sal_uInt16)aLongULSpace.GetUpper() ); |
| else |
| aUL.SetLower( (sal_uInt16)aLongULSpace.GetLower() ); |
| aDesc.GetMaster().SetFmtAttr( aUL ); |
| |
| if( (bHead && pHeaderFmt) || (!bHead && pFooterFmt) ) |
| { |
| SwFmtFrmSize aSz( bHead ? pHeaderFmt->GetFrmSize() : |
| pFooterFmt->GetFrmSize() ); |
| aSz.SetHeightSizeType( ATT_FIX_SIZE ); |
| aSz.SetHeight(nPageHeight - aLongULSpace.GetLower() - |
| aLongULSpace.GetUpper() ); |
| if ( bHead ) |
| pHeaderFmt->SetFmtAttr( aSz ); |
| else |
| pFooterFmt->SetFmtAttr( aSz ); |
| } |
| } |
| else |
| { |
| SvxULSpaceItem aUL(RES_UL_SPACE); |
| aUL.SetUpper((sal_uInt16)aLongULSpace.GetUpper()); |
| aUL.SetLower((sal_uInt16)aLongULSpace.GetLower()); |
| aDesc.GetMaster().SetFmtAttr(aUL); |
| } |
| |
| rSh.ChgPageDesc( nDescId, aDesc ); |
| } |
| } |
| break; |
| |
| // apply new top and bottom margins to current page style |
| case SID_ATTR_PAGE_ULSPACE: |
| if ( pReqArgs ) |
| { |
| SvxLongULSpaceItem aLongULSpace( |
| static_cast<const SvxLongULSpaceItem&>(pReqArgs->Get( SID_ATTR_PAGE_ULSPACE ) ) ); |
| |
| SwPageDesc aDesc( rDesc ); |
| { |
| SvxULSpaceItem aUL(RES_UL_SPACE); |
| aUL.SetUpper((sal_uInt16)aLongULSpace.GetUpper()); |
| aUL.SetLower((sal_uInt16)aLongULSpace.GetLower()); |
| aDesc.GetMaster().SetFmtAttr(aUL); |
| } |
| rSh.ChgPageDesc( nDescId, aDesc ); |
| } |
| break; |
| |
| case SID_ATTR_PAGE_COLUMN: |
| if ( pReqArgs ) |
| { |
| const SfxInt16Item aColumnItem( (const SfxInt16Item&)pReqArgs->Get(nSlot) ); |
| const sal_uInt16 nPageColumnType = aColumnItem.GetValue(); |
| |
| // nPageColumnType = |
| // 1 - single-columned page |
| // 2 - two-columned page |
| // 3 - three-columned page |
| // 4 - two-columned page with left column width of 2/3 of page width |
| // 5 - two-columned page with right column width of 2/3 of page width |
| |
| sal_uInt16 nCount = 2; |
| if ( nPageColumnType == 1 ) |
| { |
| nCount = 0; |
| } |
| else if ( nPageColumnType == 3 ) |
| { |
| nCount = 3; |
| } |
| |
| const sal_uInt16 nGutterWidth = 0; |
| |
| const SvxLRSpaceItem aLR( rDesc.GetMaster().GetLRSpace() ); |
| const long nLeft = aLR.GetLeft(); |
| const long nRight = aLR.GetRight(); |
| const long nWidth = nPageWidth - nLeft - nRight; |
| |
| SwFmtCol aCols( rDesc.GetMaster().GetCol() ); |
| aCols.Init( nCount, nGutterWidth, nWidth ); |
| aCols.SetWishWidth( nWidth ); |
| aCols.SetGutterWidth( nGutterWidth, nWidth ); |
| aCols.SetOrtho( sal_False, nGutterWidth, nWidth ); |
| |
| long nColumnLeft = 0; |
| long nColumnRight = 0; |
| if ( nPageColumnType == 4 ) |
| { |
| nColumnRight = (long)(nWidth/3); |
| nColumnLeft = nWidth - nColumnRight; |
| aCols.GetColumns()[0]->SetWishWidth( nColumnLeft ); |
| aCols.GetColumns()[1]->SetWishWidth( nColumnRight ); |
| } |
| else if ( nPageColumnType == 5 ) |
| { |
| nColumnLeft = (long)(nWidth/3); |
| nColumnRight = nWidth - nColumnLeft; |
| aCols.GetColumns()[0]->SetWishWidth( nColumnLeft ); |
| aCols.GetColumns()[1]->SetWishWidth( nColumnRight ); |
| } |
| |
| SwPageDesc aDesc( rDesc ); |
| aDesc.GetMaster().SetFmtAttr( aCols ); |
| rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc ); |
| } |
| break; |
| |
| case SID_ATTR_TABSTOP_VERTICAL: |
| case SID_ATTR_TABSTOP: |
| if ( pReqArgs ) |
| { |
| sal_uInt16 nWhich = GetPool().GetWhich(nSlot); |
| SvxTabStopItem aTabStops( (const SvxTabStopItem&)pReqArgs-> |
| Get( nWhich )); |
| aTabStops.SetWhich(RES_PARATR_TABSTOP); |
| const SvxTabStopItem& rDefTabs = |
| (const SvxTabStopItem&)rSh.GetDefault(RES_PARATR_TABSTOP); |
| |
| // Default-Tab an Pos 0 |
| SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE ); |
| rSh.GetCurAttr( aSet ); |
| const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)aSet.Get(RES_LR_SPACE); |
| |
| if ( rLR.GetTxtFirstLineOfst() < 0 ) |
| { |
| SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT ); |
| aTabStops.Insert( aSwTabStop ); |
| } |
| |
| // auffuellen mit Default-Tabs |
| sal_uInt16 nDef = ::GetTabDist( rDefTabs ); |
| ::MakeDefTabs( nDef, aTabStops ); |
| |
| SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl(); |
| if( pColl && pColl->IsAutoUpdateFmt() ) |
| { |
| SfxItemSet aTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP); |
| aTmp.Put(aTabStops); |
| rSh.AutoUpdatePara( pColl, aTmp ); |
| } |
| else |
| rSh.SetAttrItem( aTabStops ); |
| break; |
| } |
| |
| case SID_ATTR_PARA_LRSPACE_VERTICAL: |
| case SID_ATTR_PARA_LRSPACE: |
| if ( pReqArgs ) |
| { |
| SvxLRSpaceItem aParaMargin((const SvxLRSpaceItem&)pReqArgs->Get(nSlot)); |
| if(nFrmType & FRMTYPE_FLY_ANY) |
| { |
| sal_Bool bFirstColumn = sal_True; |
| sal_Bool bLastColumn = sal_True; |
| if(nFrmType & FRMTYPE_COLUMN) |
| { |
| sal_uInt16 nCurFrameCol = rSh.GetCurColNum() - 1; |
| bFirstColumn = !nCurFrameCol; |
| const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt(); |
| const SwFmtCol* pCols = &pFmt->GetCol(); |
| const SwColumns& rCols = pCols->GetColumns(); |
| sal_uInt16 nColumnCount = rCols.Count(); |
| bLastColumn = nColumnCount == nCurFrameCol + 1; |
| } |
| } |
| aParaMargin.SetRight( aParaMargin.GetRight() - nRightBorderDistance ); |
| aParaMargin.SetTxtLeft(aParaMargin.GetTxtLeft() - nLeftBorderDistance ); |
| |
| aParaMargin.SetWhich( RES_LR_SPACE ); |
| SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl(); |
| |
| // #i23726# |
| if (pNumRuleNodeFromDoc) |
| { |
| // --> FME 2005-02-22 #i42922# Mouse move of numbering label |
| // has to consider the left indent of the paragraph |
| SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE ); |
| rSh.GetCurAttr( aSet ); |
| const SvxLRSpaceItem& rLR = |
| static_cast<const SvxLRSpaceItem&>(aSet.Get(RES_LR_SPACE)); |
| // <-- |
| |
| SwPosition aPos(*pNumRuleNodeFromDoc); |
| // --> OD 2008-06-09 #i90078# |
| rSh.SetIndent( static_cast< short >(aParaMargin.GetTxtLeft() - rLR.GetTxtLeft()), aPos); |
| // <-- |
| // --> OD 2005-02-18 #i42921# - invalidate state of indent in order |
| // to get a ruler update. |
| aParaMargin.SetWhich( nSlot ); |
| GetViewFrame()->GetBindings().SetState( aParaMargin ); |
| // <-- |
| } |
| else if( pColl && pColl->IsAutoUpdateFmt() ) |
| { |
| SfxItemSet aSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE); |
| aSet.Put(aParaMargin); |
| rSh.AutoUpdatePara( pColl, aSet); |
| } |
| else |
| rSh.SetAttrItem( aParaMargin ); |
| |
| if ( aParaMargin.GetTxtFirstLineOfst() < 0 ) |
| { |
| SfxItemSet aSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP ); |
| |
| rSh.GetCurAttr( aSet ); |
| const SvxTabStopItem& rTabStops = (const SvxTabStopItem&)aSet.Get(RES_PARATR_TABSTOP); |
| |
| // Haben wir einen Tab an Stelle Null |
| sal_uInt16 i; |
| |
| for ( i = 0; i < rTabStops.Count(); ++i ) |
| if ( rTabStops[i].GetTabPos() == 0 ) |
| break; |
| |
| if ( i >= rTabStops.Count() ) |
| { |
| // Kein DefTab |
| SvxTabStopItem aTabStops( RES_PARATR_TABSTOP ); |
| aTabStops = rTabStops; |
| |
| ::lcl_EraseDefTabs(aTabStops); |
| |
| SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT ); |
| aTabStops.Insert(aSwTabStop); |
| |
| const SvxTabStopItem& rDefTabs = |
| (const SvxTabStopItem&)rSh.GetDefault(RES_PARATR_TABSTOP); |
| sal_uInt16 nDef = ::GetTabDist(rDefTabs); |
| ::MakeDefTabs( nDef, aTabStops ); |
| |
| if( pColl && pColl->IsAutoUpdateFmt()) |
| { |
| SfxItemSet aSetTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP); |
| aSetTmp.Put(aTabStops); |
| rSh.AutoUpdatePara( pColl, aSetTmp ); |
| } |
| else |
| rSh.SetAttrItem( aTabStops ); |
| } |
| } |
| } |
| break; |
| |
| case SID_ATTR_PARA_ULSPACE: |
| if ( pReqArgs ) |
| { |
| SvxULSpaceItem aParaMargin((const SvxULSpaceItem&)pReqArgs->Get(nSlot)); |
| |
| long nUDist = 0; |
| long nLDist = 0; |
| aParaMargin.SetUpper( aParaMargin.GetUpper() - nUDist ); |
| aParaMargin.SetLower(aParaMargin.GetLower() - nLDist); |
| |
| aParaMargin.SetWhich( RES_UL_SPACE ); |
| SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl(); |
| if( pColl && pColl->IsAutoUpdateFmt() ) |
| { |
| SfxItemSet aSet(GetPool(), RES_UL_SPACE, RES_UL_SPACE); |
| aSet.Put(aParaMargin); |
| rSh.AutoUpdatePara( pColl, aSet); |
| } |
| else |
| rSh.SetAttrItem( aParaMargin ); |
| } |
| break; |
| |
| case SID_RULER_BORDERS_VERTICAL: |
| case SID_RULER_BORDERS: |
| if ( pReqArgs ) |
| { |
| SvxColumnItem aColItem((const SvxColumnItem&)pReqArgs->Get(nSlot)); |
| |
| if( bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) ) |
| { |
| ASSERT(aColItem.Count(), "ColDesc ist leer!!"); |
| |
| const sal_Bool bSingleLine = ((const SfxBoolItem&)rReq. |
| GetArgs()->Get(SID_RULER_ACT_LINE_ONLY)).GetValue(); |
| |
| SwTabCols aTabCols; |
| if ( bSetTabColFromDoc ) |
| rSh.GetMouseTabCols( aTabCols, aTabColFromDocPos ); |
| else |
| rSh.GetTabCols(aTabCols); |
| |
| // linker Tabellenrand |
| long nBorder = (long)(aColItem.GetLeft() - aTabCols.GetLeftMin()); |
| aTabCols.SetLeft( nBorder ); |
| |
| nBorder = (bVerticalWriting ? nPageHeight : nPageWidth) - aTabCols.GetLeftMin() - aColItem.GetRight(); |
| |
| #ifdef DEBUG |
| long nTmp1 = nPageWidth; |
| long nTmp2 = aTabCols.GetLeftMin() + nBorder; |
| (void)nTmp1; |
| (void)nTmp2; |
| #endif |
| |
| if ( aColItem.GetRight() > 0 ) |
| aTabCols.SetRight( nBorder ); |
| |
| // Tabcols der Reihe nach |
| // Die letzte Col wird durch den Rand definiert |
| //columns in right-to-left tables need to be mirrored |
| sal_Bool bIsTableRTL = |
| IsTabColFromDoc() ? |
| rSh.IsMouseTableRightToLeft(aTabColFromDocPos) |
| : rSh.IsTableRightToLeft(); |
| if(bIsTableRTL) |
| { |
| sal_uInt16 nColCount = aColItem.Count() - 1; |
| for ( sal_uInt16 i = 0; i < nColCount; ++i ) |
| { |
| const SvxColumnDescription& rCol = aColItem[nColCount - i]; |
| aTabCols[i] = aTabCols.GetRight() - rCol.nStart; |
| aTabCols.SetHidden( i, !rCol.bVisible ); |
| } |
| } |
| else |
| { |
| for ( sal_uInt16 i = 0; i < aColItem.Count()-1; ++i ) |
| { |
| const SvxColumnDescription& rCol = aColItem[i]; |
| aTabCols[i] = rCol.nEnd + aTabCols.GetLeft(); |
| aTabCols.SetHidden( i, !rCol.bVisible ); |
| } |
| } |
| |
| if ( bSetTabColFromDoc ) |
| { |
| if( !rSh.IsViewLocked() ) |
| { |
| bUnlockView = sal_True; |
| rSh.LockView( sal_True ); |
| } |
| rSh.SetMouseTabCols( aTabCols, bSingleLine, |
| aTabColFromDocPos ); |
| } |
| else |
| rSh.SetTabCols(aTabCols, bSingleLine); |
| |
| } |
| else |
| { |
| if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY || bSect) |
| { |
| SwSectionFmt *pSectFmt = 0; |
| SfxItemSet aSet( GetPool(), RES_COL, RES_COL ); |
| if(bSect) |
| { |
| const SwSection *pSect = rSh.GetAnySection(); |
| ASSERT( pSect, "Welcher Bereich?"); |
| pSectFmt = pSect->GetFmt(); |
| } |
| else |
| { |
| rSh.GetFlyFrmAttr( aSet ); |
| } |
| SwFmtCol aCols( |
| bSect ? |
| pSectFmt->GetCol() : |
| (const SwFmtCol&)aSet.Get( RES_COL, sal_False )); |
| SwRect aCurRect = rSh.GetAnyCurRect(bSect ? RECT_SECTION_PRT : RECT_FLY_PRT_EMBEDDED); |
| const long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width(); |
| ::lcl_ConvertToCols( aColItem, sal_uInt16(lWidth), aCols ); |
| aSet.Put( aCols ); |
| if(bSect) |
| rSh.SetSectionAttr( aSet, pSectFmt ); |
| else |
| { |
| rSh.StartAction(); |
| rSh.Push(); |
| rSh.SetFlyFrmAttr( aSet ); |
| //die Rahmenselektion wieder aufheben |
| if(!bFrmSelection && rSh.IsFrmSelected()) |
| { |
| rSh.UnSelectFrm(); |
| rSh.LeaveSelFrmMode(); |
| } |
| rSh.Pop(); |
| rSh.EndAction(); |
| } |
| } |
| else |
| { |
| SwFmtCol aCols( rDesc.GetMaster().GetCol() ); |
| const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT); |
| ::lcl_ConvertToCols( aColItem, |
| sal_uInt16(bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width()), |
| aCols ); |
| SwPageDesc aDesc( rDesc ); |
| aDesc.GetMaster().SetFmtAttr( aCols ); |
| rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc ); |
| } |
| } |
| } |
| break; |
| |
| case SID_RULER_ROWS : |
| case SID_RULER_ROWS_VERTICAL: |
| if ( pReqArgs ) |
| { |
| SvxColumnItem aColItem((const SvxColumnItem&)pReqArgs->Get(nSlot)); |
| |
| if( bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) ) |
| { |
| ASSERT(aColItem.Count(), "ColDesc ist leer!!"); |
| |
| SwTabCols aTabCols; |
| if ( bSetTabRowFromDoc ) |
| rSh.GetMouseTabRows( aTabCols, aTabColFromDocPos ); |
| else |
| rSh.GetTabRows(aTabCols); |
| |
| if ( bVerticalWriting ) |
| { |
| aTabCols.SetRight(nPageWidth - aColItem.GetRight() - aColItem.GetLeft()); |
| aTabCols.SetLeftMin(aColItem.GetLeft()); |
| } |
| else |
| { |
| long nBorder = nPageHeight - aTabCols.GetLeftMin() - aColItem.GetRight(); |
| aTabCols.SetRight( nBorder ); |
| } |
| |
| if(bVerticalWriting) |
| { |
| for ( sal_uInt16 i = aColItem.Count() - 1; i; --i ) |
| { |
| const SvxColumnDescription& rCol = aColItem[i - 1]; |
| long nColumnPos = aTabCols.GetRight() - rCol.nEnd ; |
| aTabCols[i - 1] = nColumnPos; |
| aTabCols.SetHidden( i - 1, !rCol.bVisible ); |
| } |
| } |
| else |
| { |
| for ( sal_uInt16 i = 0; i < aColItem.Count()-1; ++i ) |
| { |
| const SvxColumnDescription& rCol = aColItem[i]; |
| aTabCols[i] = rCol.nEnd + aTabCols.GetLeft(); |
| aTabCols.SetHidden( i, !rCol.bVisible ); |
| } |
| } |
| sal_Bool bSingleLine = sal_False; |
| const SfxPoolItem* pSingleLine; |
| if( SFX_ITEM_SET == pReqArgs->GetItemState(SID_RULER_ACT_LINE_ONLY, sal_False, &pSingleLine)) |
| bSingleLine = ((const SfxBoolItem*)pSingleLine)->GetValue(); |
| if ( bSetTabRowFromDoc ) |
| { |
| if( !rSh.IsViewLocked() ) |
| { |
| bUnlockView = sal_True; |
| rSh.LockView( sal_True ); |
| } |
| rSh.SetMouseTabRows( aTabCols, bSingleLine, aTabColFromDocPos ); |
| } |
| else |
| rSh.SetTabRows(aTabCols, bSingleLine); |
| } |
| } |
| break; |
| |
| default: |
| ASSERT( !this, "Falsche SlotId"); |
| } |
| rSh.EndAllAction(); |
| |
| if( bUnlockView ) |
| rSh.LockView( sal_False ); |
| |
| bSetTabColFromDoc = bSetTabRowFromDoc = bTabColFromDoc = bTabRowFromDoc = sal_False; |
| SetNumRuleNodeFromDoc(NULL); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Hier wird der Status der Tableiste ermittelt |
| sprich alle relevanten Attribute an der CursorPos |
| werden der Tableiste uebermittelt |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwView::StateTabWin(SfxItemSet& rSet) |
| { |
| SwWrtShell &rSh = GetWrtShell(); |
| |
| const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &aTabColFromDocPos : 0; |
| const sal_uInt16 nFrmType = rSh.IsObjSelected() |
| ? FRMTYPE_DRAWOBJ |
| : rSh.GetFrmType( pPt, sal_True ); |
| |
| const sal_Bool bFrmSelection = rSh.IsFrmSelected(); |
| const sal_Bool bBrowse = rSh.GetViewOptions()->getBrowseMode(); |
| // PageOffset/Begrenzer |
| const SwRect& rPageRect = rSh.GetAnyCurRect( RECT_PAGE, pPt ); |
| const SwRect& rPagePrtRect = rSh.GetAnyCurRect( RECT_PAGE_PRT, pPt ); |
| const long nPageWidth = rPageRect.Width(); |
| const long nPageHeight = rPageRect.Height(); |
| |
| const SwPageDesc& rDesc = rSh.GetPageDesc( |
| IsTabColFromDoc() || bTabRowFromDoc ? |
| rSh.GetMousePageDesc(aTabColFromDocPos) : rSh.GetCurPageDesc() ); |
| |
| const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrmDir(); |
| const sal_Bool bVerticalWriting = rSh.IsInVerticalText(); |
| |
| //enable tab stop display on the rulers depending on the writing direction |
| WinBits nRulerStyle = pHRuler->GetStyle() & ~WB_EXTRAFIELD; |
| pHRuler->SetStyle(bVerticalWriting||bBrowse ? nRulerStyle : nRulerStyle|WB_EXTRAFIELD); |
| nRulerStyle = pVRuler->GetStyle() & ~WB_EXTRAFIELD; |
| pVRuler->SetStyle(bVerticalWriting ? nRulerStyle|WB_EXTRAFIELD : nRulerStyle); |
| |
| //#i24363# tab stops relative to indent |
| bool bRelative = rSh.getIDocumentSettingAccess()->get(IDocumentSettingAccess::TABS_RELATIVE_TO_INDENT); |
| pHRuler->SetTabsRelativeToIndent( bRelative ); |
| pVRuler->SetTabsRelativeToIndent( bRelative ); |
| |
| SvxLRSpaceItem aPageLRSpace( rDesc.GetMaster().GetLRSpace() ); |
| SwapPageMargin( rDesc, aPageLRSpace ); |
| |
| SfxItemSet aCoreSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP, |
| RES_LR_SPACE, RES_UL_SPACE, 0 ); |
| // get also the list level indent values merged as LR-SPACE item, if needed. |
| rSh.GetCurAttr( aCoreSet, true ); |
| const SelectionType nSelType = rSh.GetSelectionType(); |
| |
| SfxWhichIter aIter( rSet ); |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| sal_Bool bPutContentProtection = sal_False; |
| |
| while ( nWhich ) |
| { |
| switch ( nWhich ) |
| { |
| case SID_ATTR_PAGE_COLUMN: |
| { |
| sal_uInt16 nColumnType = 0; |
| |
| const SwFrmFmt& rMaster = rDesc.GetMaster(); |
| SwFmtCol aCol(rMaster.GetCol()); |
| const sal_uInt16 nCols = aCol.GetNumCols(); |
| if ( nCols == 0 ) |
| { |
| nColumnType = 1; |
| } |
| else if ( nCols == 2 ) |
| { |
| const sal_uInt16 nColLeft = aCol.CalcPrtColWidth(0, aCol.GetWishWidth()); |
| const sal_uInt16 nColRight = aCol.CalcPrtColWidth(1, aCol.GetWishWidth()); |
| |
| if ( abs(nColLeft - nColRight) <= 10 ) |
| { |
| nColumnType = 2; |
| } |
| else if( abs(nColLeft - nColRight*2) < 20 ) |
| { |
| nColumnType = 4; |
| } |
| else if( abs(nColLeft*2 - nColRight) < 20 ) |
| { |
| nColumnType = 5; |
| } |
| } |
| else if( nCols == 3 ) |
| { |
| nColumnType = 3; |
| } |
| |
| rSet.Put( SfxInt16Item( SID_ATTR_PAGE_COLUMN, nColumnType ) ); |
| } |
| break; |
| |
| case SID_ATTR_LONG_LRSPACE: |
| { |
| SvxLongLRSpaceItem aLongLR( (long)aPageLRSpace.GetLeft(), |
| (long)aPageLRSpace.GetRight(), |
| SID_ATTR_LONG_LRSPACE); |
| if(bBrowse) |
| { |
| aLongLR.SetLeft(rPagePrtRect.Left()); |
| aLongLR.SetRight(nPageWidth - rPagePrtRect.Right()); |
| } |
| if ( ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER ) && |
| !(nFrmType & FRMTYPE_COLSECT) ) |
| { |
| SwFrmFmt *pFmt = (SwFrmFmt*) (nFrmType & FRMTYPE_HEADER ? |
| rDesc.GetMaster().GetHeader().GetHeaderFmt() : |
| rDesc.GetMaster().GetFooter().GetFooterFmt()); |
| if( pFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash |
| { |
| SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt)); |
| aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos(); |
| const SvxLRSpaceItem& aLR = pFmt->GetLRSpace(); |
| aLongLR.SetLeft ( (long)aLR.GetLeft() + (long)aRect.Left() ); |
| aLongLR.SetRight( (nPageWidth - |
| (long)aRect.Right() + (long)aLR.GetRight())); |
| } |
| } |
| else |
| { |
| SwRect aRect; |
| if( !bFrmSelection && ((nFrmType & FRMTYPE_COLSECT) || rSh.IsDirectlyInSection()) ) |
| { |
| aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt); |
| const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt); |
| aRect.Pos() += aTmpRect.Pos(); |
| } |
| |
| else if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY ) |
| aRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt); |
| else if( nFrmType & FRMTYPE_DRAWOBJ) |
| aRect = rSh.GetObjRect(); |
| |
| if( aRect.Width() ) |
| { |
| // PAGES01 |
| // make relative to page position: |
| aLongLR.SetLeft ((long)( aRect.Left() - rPageRect.Left() )); |
| aLongLR.SetRight((long)( rPageRect.Right() - aRect.Right())); |
| } |
| } |
| if( nWhich == SID_ATTR_LONG_LRSPACE ) |
| rSet.Put( aLongLR ); |
| else |
| { |
| SvxLRSpaceItem aLR( aLongLR.GetLeft(), |
| aLongLR.GetRight(), |
| 0, 0, |
| nWhich); |
| rSet.Put(aLR); |
| } |
| break; |
| } |
| |
| // provide left and right margins of current page style |
| case SID_ATTR_PAGE_LRSPACE: |
| { |
| const SvxLRSpaceItem aTmpPageLRSpace( rDesc.GetMaster().GetLRSpace() ); |
| const SvxLongLRSpaceItem aLongLR( |
| (long)aTmpPageLRSpace.GetLeft(), |
| (long)aTmpPageLRSpace.GetRight(), |
| SID_ATTR_PAGE_LRSPACE ); |
| rSet.Put( aLongLR ); |
| } |
| break; |
| |
| case SID_ATTR_LONG_ULSPACE: |
| { |
| // Rand Seite Oben Unten |
| SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() ); |
| SvxLongULSpaceItem aLongUL( (long)aUL.GetUpper(), |
| (long)aUL.GetLower(), |
| SID_ATTR_LONG_ULSPACE); |
| |
| if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY ) |
| { |
| // Dokumentkoordinaten Frame auf Seitenkoordinaten umbrechen |
| const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt); |
| aLongUL.SetUpper((sal_uInt16)(rRect.Top() - rPageRect.Top() )); |
| aLongUL.SetLower((sal_uInt16)(rPageRect.Bottom() - rRect.Bottom() )); |
| } |
| else if ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER ) |
| { |
| SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt)); |
| aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos(); |
| aLongUL.SetUpper( (sal_uInt16)aRect.Top() ); |
| aLongUL.SetLower( (sal_uInt16)(nPageHeight - aRect.Bottom()) ); |
| } |
| else if( nFrmType & FRMTYPE_DRAWOBJ) |
| { |
| const SwRect &rRect = rSh.GetObjRect(); |
| aLongUL.SetUpper((rRect.Top() - rPageRect.Top())); |
| aLongUL.SetLower((rPageRect.Bottom() - rRect.Bottom())); |
| } |
| else if(bBrowse) |
| { |
| aLongUL.SetUpper(rPagePrtRect.Top()); |
| aLongUL.SetLower(nPageHeight - rPagePrtRect.Bottom()); |
| } |
| if( nWhich == SID_ATTR_LONG_ULSPACE ) |
| rSet.Put( aLongUL ); |
| else |
| { |
| SvxULSpaceItem aULTmp((sal_uInt16)aLongUL.GetUpper(), |
| (sal_uInt16)aLongUL.GetLower(), |
| nWhich); |
| rSet.Put(aULTmp); |
| } |
| break; |
| } |
| |
| // provide top and bottom margins of current page style |
| case SID_ATTR_PAGE_ULSPACE: |
| { |
| const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() ); |
| SvxLongULSpaceItem aLongUL( |
| (long)aUL.GetUpper(), |
| (long)aUL.GetLower(), |
| SID_ATTR_PAGE_ULSPACE ); |
| |
| rSet.Put( aLongUL ); |
| } |
| break; |
| |
| case SID_ATTR_TABSTOP_VERTICAL : |
| case RES_PARATR_TABSTOP: |
| { |
| if ( ISA( SwWebView ) || |
| IsTabColFromDoc() || |
| IsTabRowFromDoc() || |
| ( nSelType & nsSelectionType::SEL_GRF) || |
| (nSelType & nsSelectionType::SEL_FRM) || |
| (nSelType & nsSelectionType::SEL_OLE) || |
| SFX_ITEM_AVAILABLE > aCoreSet.GetItemState(RES_LR_SPACE)|| |
| (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich))|| |
| (bVerticalWriting && (RES_PARATR_TABSTOP == nWhich)) |
| ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| SvxTabStopItem aTabStops((const SvxTabStopItem&) |
| aCoreSet.Get( RES_PARATR_TABSTOP )); |
| |
| const SvxTabStopItem& rDefTabs = (const SvxTabStopItem&) |
| rSh.GetDefault(RES_PARATR_TABSTOP); |
| |
| DBG_ASSERT(pHRuler, "warum ist das Lineal nicht da?"); |
| long nDefTabDist = ::GetTabDist(rDefTabs); |
| pHRuler->SetDefTabDist( nDefTabDist ); |
| pVRuler->SetDefTabDist( nDefTabDist ); |
| ::lcl_EraseDefTabs(aTabStops); |
| rSet.Put(aTabStops, nWhich); |
| } |
| break; |
| } |
| |
| case SID_ATTR_PARA_LRSPACE_VERTICAL: |
| case SID_ATTR_PARA_LRSPACE: |
| { |
| if ( nSelType & nsSelectionType::SEL_GRF || |
| nSelType & nsSelectionType::SEL_FRM || |
| nSelType & nsSelectionType::SEL_OLE || |
| nFrmType == FRMTYPE_DRAWOBJ || |
| (!bVerticalWriting && (SID_ATTR_PARA_LRSPACE_VERTICAL == nWhich))|| |
| (bVerticalWriting && (SID_ATTR_PARA_LRSPACE == nWhich)) |
| ) |
| { |
| rSet.DisableItem(nWhich); |
| } |
| else |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| if ( !IsTabColFromDoc() ) |
| { |
| aLR = (const SvxLRSpaceItem&)aCoreSet.Get(RES_LR_SPACE); |
| |
| // #i23726# |
| if (pNumRuleNodeFromDoc) |
| { |
| short nOffset = static_cast< short >(aLR.GetTxtLeft() + |
| // --> FME 2005-02-22 #i42922# Mouse move of numbering label |
| // has to consider the left indent of the paragraph |
| pNumRuleNodeFromDoc->GetLeftMarginWithNum( sal_True ) ); |
| // <-- |
| |
| short nFLOffset; |
| pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset ); |
| |
| aLR.SetLeft( nOffset + nFLOffset ); |
| } |
| } |
| aLR.SetWhich(nWhich); |
| rSet.Put(aLR); |
| } |
| break; |
| } |
| |
| case SID_ATTR_PARA_ULSPACE: |
| { |
| SvxULSpaceItem aUL = (const SvxULSpaceItem&)aCoreSet.Get(RES_UL_SPACE); |
| aUL.SetWhich(nWhich); |
| |
| SfxItemState e = aCoreSet.GetItemState(RES_UL_SPACE); |
| if( e >= SFX_ITEM_AVAILABLE ) |
| rSet.Put( aUL ); |
| else |
| rSet.InvalidateItem(nWhich); |
| } |
| break; |
| |
| case SID_RULER_BORDER_DISTANCE: |
| { |
| nLeftBorderDistance = 0; |
| nRightBorderDistance = 0; |
| if ( nSelType & nsSelectionType::SEL_GRF || |
| nSelType & nsSelectionType::SEL_FRM || |
| nSelType & nsSelectionType::SEL_OLE || |
| nFrmType == FRMTYPE_DRAWOBJ ) |
| rSet.DisableItem(SID_RULER_BORDER_DISTANCE); |
| else |
| { |
| SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE); |
| if(nFrmType & FRMTYPE_FLY_ANY) |
| { |
| if( IsTabColFromDoc() ) |
| { |
| const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, pPt ); |
| aDistLR.SetLeft(rFlyPrtRect.Left()); |
| aDistLR.SetRight(rFlyPrtRect.Left()); |
| } |
| else |
| { |
| SfxItemSet aCoreSet2( GetPool(), |
| RES_BOX, RES_BOX, |
| SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 ); |
| SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER ); |
| aCoreSet.Put( aBoxInfo ); |
| rSh.GetFlyFrmAttr( aCoreSet ); |
| const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet.Get(RES_BOX); |
| aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT)); |
| |
| //add the paragraph border distance |
| SfxItemSet aCoreSet1( GetPool(), |
| RES_BOX, RES_BOX, |
| 0 ); |
| rSh.GetCurAttr( aCoreSet1 ); |
| const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX); |
| aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT)); |
| } |
| rSet.Put(aDistLR); |
| nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft()); |
| nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight()); |
| } |
| else if ( IsTabColFromDoc() || |
| ( rSh.GetTableFmt() && !bFrmSelection && |
| !(nFrmType & FRMTYPE_COLSECT ) ) ) |
| { |
| SfxItemSet aCoreSet2( GetPool(), |
| RES_BOX, RES_BOX, |
| SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 ); |
| SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER ); |
| aBoxInfo.SetTable(sal_False); |
| aBoxInfo.SetDist((sal_Bool) sal_True); |
| aCoreSet2.Put(aBoxInfo); |
| rSh.GetTabBorders( aCoreSet2 ); |
| const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet2.Get(RES_BOX); |
| aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT)); |
| |
| //add the border distance of the paragraph |
| SfxItemSet aCoreSet1( GetPool(), |
| RES_BOX, RES_BOX, |
| 0 ); |
| rSh.GetCurAttr( aCoreSet1 ); |
| const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX); |
| aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT)); |
| rSet.Put(aDistLR); |
| nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft()); |
| nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight()); |
| } |
| else if ( !rSh.IsDirectlyInSection() ) |
| { |
| //get the page/header/footer border distance |
| const SwFrmFmt& rMaster = rDesc.GetMaster(); |
| const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetAttrSet().Get(RES_BOX); |
| aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT)); |
| |
| const SvxBoxItem* pBox = 0; |
| if(nFrmType & FRMTYPE_HEADER) |
| { |
| rMaster.GetHeader(); |
| const SwFmtHeader& rHeaderFmt = rMaster.GetHeader(); |
| SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt(); |
| if( pHeaderFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash |
| pBox = & (const SvxBoxItem&)pHeaderFmt->GetBox(); |
| } |
| else if(nFrmType & FRMTYPE_FOOTER ) |
| { |
| const SwFmtFooter& rFooterFmt = rMaster.GetFooter(); |
| SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt(); |
| if( pFooterFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash |
| pBox = & (const SvxBoxItem&)pFooterFmt->GetBox(); |
| } |
| if(pBox) |
| { |
| aDistLR.SetLeft((sal_uInt16)pBox->GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight((sal_uInt16)pBox->GetDistance(BOX_LINE_RIGHT)); |
| } |
| |
| //add the border distance of the paragraph |
| SfxItemSet aCoreSetTmp( GetPool(), |
| RES_BOX, RES_BOX, |
| SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 ); |
| rSh.GetCurAttr( aCoreSetTmp ); |
| const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSetTmp.Get(RES_BOX); |
| aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT )); |
| aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT)); |
| rSet.Put(aDistLR); |
| nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft()); |
| nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight()); |
| } |
| } |
| } |
| break; |
| |
| case SID_RULER_TEXT_RIGHT_TO_LEFT: |
| { |
| if ( nSelType & nsSelectionType::SEL_GRF || |
| nSelType & nsSelectionType::SEL_FRM || |
| nSelType & nsSelectionType::SEL_OLE || |
| nFrmType == FRMTYPE_DRAWOBJ) |
| rSet.DisableItem(nWhich); |
| else |
| { |
| sal_Bool bFlag = rSh.IsInRightToLeftText(); |
| rSet.Put(SfxBoolItem(nWhich, bFlag)); |
| } |
| } |
| break; |
| |
| case SID_RULER_BORDERS_VERTICAL: |
| case SID_RULER_BORDERS: |
| { |
| sal_Bool bFrameHasVerticalColumns(sal_False); |
| { |
| sal_Bool bFrameRTL; |
| sal_Bool bFrameVertL2R; |
| bFrameHasVerticalColumns = rSh.IsFrmVertical(sal_False, bFrameRTL, bFrameVertL2R) && |
| bFrmSelection; |
| } |
| sal_Bool bHasTable = ( IsTabColFromDoc() || |
| ( rSh.GetTableFmt() && !bFrmSelection && |
| !(nFrmType & FRMTYPE_COLSECT ) ) ); |
| |
| sal_Bool bTableVertical = bHasTable && rSh.IsTableVertical(); |
| |
| if( ( (SID_RULER_BORDERS_VERTICAL == nWhich) && |
| ((bHasTable && !bTableVertical)|| |
| (!bVerticalWriting && !bFrmSelection && !bHasTable ) || (bFrmSelection && !bFrameHasVerticalColumns)) ) || |
| ((SID_RULER_BORDERS == nWhich) && |
| ((bHasTable && bTableVertical)|| |
| (bVerticalWriting && !bFrmSelection&& !bHasTable) || bFrameHasVerticalColumns))) |
| rSet.DisableItem(nWhich); |
| else if ( bHasTable ) |
| { |
| SwTabCols aTabCols; |
| sal_uInt16 nNum; |
| if ( 0 != ( bSetTabColFromDoc = IsTabColFromDoc() ) ) |
| { |
| rSh.GetMouseTabCols( aTabCols, aTabColFromDocPos ); |
| nNum = rSh.GetCurMouseTabColNum( aTabColFromDocPos ); |
| } |
| else |
| { |
| rSh.GetTabCols( aTabCols ); |
| nNum = rSh.GetCurTabColNum(); |
| if(rSh.IsTableRightToLeft()) |
| nNum = aTabCols.Count() - nNum; |
| } |
| |
| ASSERT(nNum <= aTabCols.Count(), "TabCol not found"); |
| const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft(); |
| const int nRgt = (sal_uInt16)(bTableVertical ? nPageHeight : nPageWidth) - |
| (aTabCols.GetLeftMin() + |
| aTabCols.GetRight()); |
| |
| const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0); |
| const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0); |
| |
| SvxColumnItem aColItem(nNum, nL, nR); |
| |
| sal_uInt16 nStart = 0, |
| nEnd; |
| |
| //columns in right-to-left tables need to be mirrored |
| sal_Bool bIsTableRTL = |
| IsTabColFromDoc() ? |
| rSh.IsMouseTableRightToLeft(aTabColFromDocPos) |
| : rSh.IsTableRightToLeft(); |
| if(bIsTableRTL) |
| { |
| for ( sal_uInt16 i = aTabCols.Count(); i ; --i ) |
| { |
| const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 ); |
| nEnd = (sal_uInt16)aTabCols.GetRight(); |
| nEnd = nEnd - (sal_uInt16)rEntry.nPos; |
| SvxColumnDescription aColDesc( nStart, nEnd, |
| (sal_uInt16(aTabCols.GetRight() - rEntry.nMax)), |
| (sal_uInt16(aTabCols.GetRight() - rEntry.nMin)), |
| !aTabCols.IsHidden(i - 1) ); |
| aColItem.Append(aColDesc); |
| nStart = nEnd; |
| } |
| SvxColumnDescription aColDesc(nStart, |
| aTabCols.GetRight() - aTabCols.GetLeft(), sal_True); |
| aColItem.Append(aColDesc); |
| } |
| else |
| { |
| for ( sal_uInt16 i = 0; i < aTabCols.Count(); ++i ) |
| { |
| const SwTabColsEntry& rEntry = aTabCols.GetEntry( i ); |
| nEnd = static_cast< sal_uInt16 >(rEntry.nPos - aTabCols.GetLeft()); |
| SvxColumnDescription aColDesc( nStart, nEnd, |
| rEntry.nMin - aTabCols.GetLeft(), rEntry.nMax - aTabCols.GetLeft(), |
| !aTabCols.IsHidden(i) ); |
| aColItem.Append(aColDesc); |
| nStart = nEnd; |
| } |
| SvxColumnDescription aColDesc(nStart, aTabCols.GetRight() - aTabCols.GetLeft(), |
| 0, 0, |
| sal_True); |
| aColItem.Append(aColDesc); |
| } |
| rSet.Put(aColItem, nWhich); |
| } |
| else if ( bFrmSelection || nFrmType & ( FRMTYPE_COLUMN | FRMTYPE_COLSECT ) ) |
| { |
| // Aus Rahmen oder Seite ? |
| sal_uInt16 nNum = 0; |
| if(bFrmSelection) |
| { |
| const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt(); |
| if(pFmt) |
| nNum = pFmt->GetCol().GetNumCols(); |
| } |
| else |
| nNum = rSh.GetCurColNum(); |
| |
| if( |
| //eigentlich sollte FRMTYPE_COLSECT nicht enthalten sein, wenn der Rahmen selektiert ist! |
| !bFrmSelection && |
| nFrmType & FRMTYPE_COLSECT ) |
| { |
| const SwSection *pSect = rSh.GetAnySection(sal_False, pPt); |
| ASSERT( pSect, "Welcher Bereich?"); |
| if( pSect ) |
| { |
| SwSectionFmt *pFmt = pSect->GetFmt(); |
| const SwFmtCol& rCol = pFmt->GetCol(); |
| if(rSh.IsInRightToLeftText()) |
| nNum = rCol.GetColumns().Count() - nNum; |
| else |
| --nNum; |
| SvxColumnItem aColItem(nNum); |
| SwRect aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt); |
| const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt); |
| |
| ::lcl_FillSvxColumn(rCol, sal_uInt16(bVerticalWriting ? aRect.Height() : aRect.Width()), aColItem, 0); |
| |
| if(bVerticalWriting) |
| { |
| aRect.Pos() += Point(aTmpRect.Left(), aTmpRect.Top()); |
| aRect.Pos().Y() -= rPageRect.Top(); |
| aColItem.SetLeft ((sal_uInt16)(aRect.Top())); |
| aColItem.SetRight((sal_uInt16)(nPageHeight - aRect.Bottom() )); |
| } |
| else |
| { |
| aRect.Pos() += aTmpRect.Pos(); |
| |
| // PAGES01 |
| // make relative to page position: |
| aColItem.SetLeft ((sal_uInt16)( aRect.Left() - rPageRect.Left() )); |
| aColItem.SetRight((sal_uInt16)( rPageRect.Right() - aRect.Right())); |
| } |
| aColItem.SetOrtho(aColItem.CalcOrtho()); |
| |
| rSet.Put(aColItem, nWhich); |
| } |
| } |
| else if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY ) |
| { |
| // Spalten in Rahmen |
| if ( nNum ) |
| { |
| const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt() ; |
| |
| const SwFmtCol& rCol = pFmt->GetCol(); |
| if(rSh.IsInRightToLeftText()) |
| nNum = rCol.GetColumns().Count() - nNum; |
| else |
| nNum--; |
| SvxColumnItem aColItem(nNum); |
| const SwRect &rSizeRect = rSh.GetAnyCurRect(RECT_FLY_PRT_EMBEDDED, pPt); |
| |
| sal_Bool bUseVertical = bFrameHasVerticalColumns || (!bFrmSelection && bVerticalWriting); |
| const long lWidth = bUseVertical ? rSizeRect.Height() : rSizeRect.Width(); |
| const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt); |
| long nDist2 = ((bUseVertical ? rRect.Height() : rRect.Width()) - lWidth) /2; |
| ::lcl_FillSvxColumn(rCol, sal_uInt16(lWidth), aColItem, nDist2); |
| |
| SfxItemSet aFrameSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE); |
| rSh.GetFlyFrmAttr( aFrameSet ); |
| |
| if(bUseVertical) |
| { |
| aColItem.SetLeft ((sal_uInt16)(rRect.Top()- rPageRect.Top())); |
| aColItem.SetRight((sal_uInt16)(nPageHeight + rPageRect.Top() - rRect.Bottom() )); |
| } |
| else |
| { |
| aColItem.SetLeft ((sal_uInt16)(rRect.Left() - rPageRect.Left() )); |
| aColItem.SetRight((sal_uInt16)(rPageRect.Right() - rRect.Right() )); |
| } |
| |
| aColItem.SetOrtho(aColItem.CalcOrtho()); |
| |
| rSet.Put(aColItem, nWhich); |
| } |
| else |
| rSet.DisableItem(nWhich); |
| } |
| else |
| { // Spalten auf der Seite |
| const SwFrmFmt& rMaster = rDesc.GetMaster(); |
| SwFmtCol aCol(rMaster.GetCol()); |
| if(rFrameDir.GetValue() == FRMDIR_HORI_RIGHT_TOP) |
| nNum = aCol.GetColumns().Count() - nNum; |
| else |
| nNum--; |
| |
| SvxColumnItem aColItem(nNum); |
| const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT, pPt); |
| const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetFmtAttr(RES_BOX); |
| long nDist = rBox.GetDistance(); |
| ::lcl_FillSvxColumn(aCol, |
| sal_uInt16(bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width() ), |
| aColItem, nDist); |
| |
| if(bBrowse) |
| { |
| aColItem.SetLeft((sal_uInt16)rPagePrtRect.Left()); |
| aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right())); |
| } |
| else |
| { |
| aColItem.SetLeft (aPageLRSpace.GetLeft()); |
| aColItem.SetRight(aPageLRSpace.GetRight()); |
| } |
| aColItem.SetOrtho(aColItem.CalcOrtho()); |
| |
| rSet.Put(aColItem, nWhich); |
| } |
| } |
| else |
| rSet.DisableItem(nWhich); |
| break; |
| } |
| |
| case SID_RULER_ROWS : |
| case SID_RULER_ROWS_VERTICAL: |
| { |
| sal_Bool bFrameHasVerticalColumns(sal_False); |
| { |
| sal_Bool bFrameRTL; |
| sal_Bool bFrameVertL2R; |
| bFrameHasVerticalColumns = rSh.IsFrmVertical(sal_False, bFrameRTL, bFrameVertL2R) && |
| bFrmSelection; |
| } |
| |
| if( ( (SID_RULER_ROWS == nWhich) && |
| ((!bVerticalWriting && !bFrmSelection) || (bFrmSelection && !bFrameHasVerticalColumns)) ) || |
| ((SID_RULER_ROWS_VERTICAL == nWhich) && |
| ((bVerticalWriting && !bFrmSelection) || bFrameHasVerticalColumns))) |
| rSet.DisableItem(nWhich); |
| else if ( IsTabRowFromDoc() || |
| ( rSh.GetTableFmt() && !bFrmSelection && |
| !(nFrmType & FRMTYPE_COLSECT ) ) ) |
| { |
| SwTabCols aTabCols; |
| //no current value necessary |
| sal_uInt16 nNum = 0; |
| if ( 0 != ( bSetTabRowFromDoc = IsTabRowFromDoc() ) ) |
| { |
| rSh.GetMouseTabRows( aTabCols, aTabColFromDocPos ); |
| } |
| else |
| { |
| rSh.GetTabRows( aTabCols ); |
| } |
| |
| // ASSERT(nNum <= aTabCols.Count(), "TabCol not found"); |
| const int nLft = aTabCols.GetLeftMin(); |
| const int nRgt = (sal_uInt16)(bVerticalWriting ? nPageWidth : nPageHeight) - |
| (aTabCols.GetLeftMin() + |
| aTabCols.GetRight()); |
| |
| const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0); |
| const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0); |
| |
| SvxColumnItem aColItem(nNum, nL, nR); |
| |
| sal_uInt16 nStart = 0, |
| nEnd; |
| |
| for ( sal_uInt16 i = 0; i < aTabCols.Count(); ++i ) |
| { |
| const SwTabColsEntry& rEntry = aTabCols.GetEntry( i ); |
| if(bVerticalWriting) |
| { |
| nEnd = sal_uInt16(aTabCols.GetRight() - rEntry.nPos); |
| SvxColumnDescription aColDesc( nStart, nEnd, |
| aTabCols.GetRight() - rEntry.nMax, aTabCols.GetRight() - rEntry.nMin, |
| !aTabCols.IsHidden(i) ); |
| aColItem.Append(aColDesc); |
| } |
| else |
| { |
| nEnd = sal_uInt16(rEntry.nPos - aTabCols.GetLeft()); |
| SvxColumnDescription aColDesc( nStart, nEnd, |
| sal_uInt16(rEntry.nMin - aTabCols.GetLeft()), sal_uInt16(rEntry.nMax - aTabCols.GetLeft()), |
| !aTabCols.IsHidden(i) ); |
| aColItem.Append(aColDesc); |
| } |
| nStart = nEnd; |
| } |
| if(bVerticalWriting) |
| nEnd = static_cast< sal_uInt16 >(aTabCols.GetRight()); |
| else |
| nEnd = static_cast< sal_uInt16 >(aTabCols.GetLeft()); |
| // put a position protection when the last row cannot be moved |
| // due to a page break inside of a row |
| if(!aTabCols.IsLastRowAllowedToChange()) |
| bPutContentProtection = sal_True; |
| |
| SvxColumnDescription aColDesc( nStart, nEnd, |
| aTabCols.GetRight(), aTabCols.GetRight(), |
| sal_False ); |
| aColItem.Append(aColDesc); |
| |
| rSet.Put(aColItem, nWhich); |
| } |
| else |
| rSet.DisableItem(nWhich); |
| } |
| break; |
| |
| case SID_RULER_PAGE_POS: |
| { |
| // PAGES01 |
| SvxPagePosSizeItem aPagePosSize( |
| Point( rPageRect.Left(), rPageRect.Top()) , nPageWidth, nPageHeight); |
| |
| rSet.Put(aPagePosSize); |
| break; |
| } |
| |
| case SID_RULER_LR_MIN_MAX: |
| { |
| Rectangle aRectangle; |
| if( ( nFrmType & FRMTYPE_COLSECT ) && !IsTabColFromDoc() && |
| ( nFrmType & ( FRMTYPE_TABLE|FRMTYPE_COLUMN ) ) ) |
| { |
| if( nFrmType & FRMTYPE_TABLE ) |
| { |
| const sal_uInt16 nNum = rSh.GetCurTabColNum(); |
| SwTabCols aTabCols; |
| rSh.GetTabCols( aTabCols ); |
| |
| const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft(); |
| const int nRgt = (sal_uInt16)nPageWidth -(aTabCols.GetLeftMin() + aTabCols.GetRight()); |
| |
| const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0); |
| const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0); |
| |
| aRectangle.Left() = nL; |
| if(nNum > 1) |
| aRectangle.Left() += aTabCols[nNum - 2]; |
| if(nNum) |
| aRectangle.Left() += MINLAY; |
| if(aTabCols.Count() <= nNum + 1 ) |
| aRectangle.Right() = nR; |
| else |
| aRectangle.Right() = nPageWidth - (nL + aTabCols[nNum + 1]); |
| |
| if(nNum < aTabCols.Count()) |
| aRectangle.Right() += MINLAY; |
| } |
| else |
| { |
| const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt(); |
| const SwFmtCol* pCols = pFmt ? &pFmt->GetCol(): |
| &rDesc.GetMaster().GetCol(); |
| const SwColumns& rCols = pCols->GetColumns(); |
| sal_uInt16 nNum = rSh.GetCurOutColNum(); |
| sal_uInt16 nCount = Min(sal_uInt16(nNum + 1), rCols.Count()); |
| const SwRect aRect( rSh.GetAnyCurRect( pFmt |
| ? RECT_FLY_PRT_EMBEDDED |
| : RECT_PAGE_PRT, pPt )); |
| const SwRect aAbsRect( rSh.GetAnyCurRect( pFmt |
| ? RECT_FLY_EMBEDDED |
| : RECT_PAGE, pPt )); |
| |
| //die Breite im Rahmen bzw. innerhalbe der Seitenraender |
| const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width(); |
| //die gesamte Rahmenbreite - die Differenz ist der doppelte Abstand zum Rand |
| const sal_uInt16 nOuterWidth = (sal_uInt16)aAbsRect.Width(); |
| int nWidth = 0, |
| nStart = 0, |
| nEnd = 0; |
| aRectangle.Left() = 0; |
| for ( sal_uInt16 i = 0; i < nCount; ++i ) |
| { |
| SwColumn* pCol = rCols[i]; |
| nStart = pCol->GetLeft() + nWidth; |
| if(i == nNum - 2) |
| aRectangle.Left() = nStart; |
| nWidth += pCols->CalcColWidth( i, nTotalWidth ); |
| nEnd = nWidth - pCol->GetRight(); |
| } |
| aRectangle.Right() = rPageRect.Right() - nEnd; |
| aRectangle.Left() -= rPageRect.Left(); |
| |
| if(nNum > 1) |
| { |
| aRectangle.Left() += MINLAY; |
| aRectangle.Left() += aRect.Left(); |
| } |
| if(pFmt) //Bereich in Rahmen - hier darf man bis zum Rand |
| aRectangle.Left() = aRectangle.Right() = 0; |
| else |
| { |
| // das Rechteck an die richtige absolute Position verschieben |
| aRectangle.Left() += aAbsRect.Left(); |
| aRectangle.Right() -= aAbsRect.Left(); |
| // Abstand zur Umrandung mit einbeziehen |
| aRectangle.Right() -= (nOuterWidth - nTotalWidth) / 2; |
| } |
| |
| if(nNum < rCols.Count()) |
| { |
| aRectangle.Right() += MINLAY; |
| } |
| else |
| // rechts ist jetzt nur noch der Seitenrand |
| aRectangle.Right() = 0; |
| |
| |
| } |
| } |
| else if ( ((nFrmType & FRMTYPE_TABLE) || IsTabColFromDoc()) && |
| !bFrmSelection ) |
| { |
| sal_Bool bColumn; |
| if ( IsTabColFromDoc() ) |
| bColumn = rSh.GetCurMouseColNum( aTabColFromDocPos ) != 0; |
| else |
| bColumn = (nFrmType & (FRMTYPE_COLUMN|FRMTYPE_FLY_ANY|FRMTYPE_COLSECTOUTTAB)) |
| ? sal_True |
| : sal_False; |
| if ( !bColumn ) |
| { |
| if( nFrmType & FRMTYPE_FLY_ANY && IsTabColFromDoc() ) |
| { |
| SwRect aRect( rSh.GetAnyCurRect( |
| RECT_FLY_PRT_EMBEDDED, pPt ) ); |
| aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED, |
| pPt ).Pos(); |
| |
| aRectangle.Left() = aRect.Left() - rPageRect.Left(); |
| aRectangle.Right() = rPageRect.Right() - aRect.Right(); |
| } |
| else if( bBrowse ) |
| { |
| aRectangle.Left() = rPagePrtRect.Left(); |
| aRectangle.Right() = nPageWidth - rPagePrtRect.Right(); |
| } |
| else |
| { |
| aRectangle.Left() = aPageLRSpace.GetLeft(); |
| aRectangle.Right() = aPageLRSpace.GetRight(); |
| } |
| } |
| else |
| { //hier nur fuer Tabelle in mehrspaltigen Seiten und Rahmen |
| sal_Bool bSectOutTbl = (nFrmType & FRMTYPE_TABLE) ? sal_True : sal_False; |
| sal_Bool bFrame = (nFrmType & FRMTYPE_FLY_ANY) ? sal_True : sal_False; |
| sal_Bool bColSct = (nFrmType & ( bSectOutTbl |
| ? FRMTYPE_COLSECTOUTTAB |
| : FRMTYPE_COLSECT ) |
| ) ? sal_True : sal_False; |
| //Damit man auch mit der Mouse ziehen kann, |
| //ohne in der Tabelle zu stehen |
| CurRectType eRecType = RECT_PAGE_PRT; |
| sal_uInt16 nNum = IsTabColFromDoc() ? |
| rSh.GetCurMouseColNum( aTabColFromDocPos ): |
| rSh.GetCurOutColNum(); |
| const SwFrmFmt* pFmt = NULL; |
| if( bColSct ) |
| { |
| eRecType = bSectOutTbl ? RECT_OUTTABSECTION |
| : RECT_SECTION; |
| const SwSection *pSect = rSh.GetAnySection( bSectOutTbl, pPt ); |
| ASSERT( pSect, "Welcher Bereich?"); |
| pFmt = pSect->GetFmt(); |
| } |
| else if( bFrame ) |
| { |
| pFmt = rSh.GetFlyFrmFmt(); |
| eRecType = RECT_FLY_PRT_EMBEDDED; |
| } |
| |
| const SwFmtCol* pCols = pFmt ? &pFmt->GetCol(): |
| &rDesc.GetMaster().GetCol(); |
| const SwColumns& rCols = pCols->GetColumns(); |
| const sal_uInt16 nBorder = pFmt ? pFmt->GetBox().GetDistance() : |
| rDesc.GetMaster().GetBox().GetDistance(); |
| |
| /* RECT_FLY_PRT_EMBEDDED returns the relative position to |
| RECT_FLY_EMBEDDED |
| the absolute position must be added here |
| */ |
| SwRect aRect( rSh.GetAnyCurRect( eRecType, pPt ) ); |
| if(RECT_FLY_PRT_EMBEDDED == eRecType) |
| aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED, |
| pPt ).Pos(); |
| |
| const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width(); |
| //nStart und nEnd initialisieren fuer nNum == 0 |
| int nWidth = 0, |
| nStart = 0, |
| nEnd = nTotalWidth; |
| |
| if( nNum > rCols.Count() ) |
| { |
| ASSERT( !this, "es wird auf dem falschen FmtCol gearbeitet!" ); |
| nNum = rCols.Count(); |
| } |
| |
| for( sal_uInt16 i = 0; i < nNum; ++i ) |
| { |
| SwColumn* pCol = rCols[i]; |
| nStart = pCol->GetLeft() + nWidth; |
| nWidth += pCols->CalcColWidth( i, nTotalWidth ); |
| nEnd = nWidth - pCol->GetRight(); |
| } |
| if( bFrame | bColSct ) |
| { |
| aRectangle.Left() = aRect.Left() - rPageRect.Left() + nStart; |
| aRectangle.Right() = nPageWidth - aRectangle.Left() - nEnd + nStart; |
| } |
| else if(!bBrowse) |
| { |
| aRectangle.Left() = aPageLRSpace.GetLeft() + nStart; |
| aRectangle.Right() = nPageWidth - nEnd - aPageLRSpace.GetLeft(); |
| } |
| else |
| { |
| long nLeft = rPagePrtRect.Left(); |
| aRectangle.Left() = nStart + nLeft; |
| aRectangle.Right() = nPageWidth - nEnd - nLeft; |
| } |
| if(!bFrame) |
| { |
| aRectangle.Left() += nBorder; |
| aRectangle.Right() -= nBorder; |
| } |
| } |
| } |
| else if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER )) |
| { |
| aRectangle.Left() = aPageLRSpace.GetLeft(); |
| aRectangle.Right() = aPageLRSpace.GetRight(); |
| } |
| else |
| aRectangle.Left() = aRectangle.Right() = 0; |
| |
| SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle); |
| rSet.Put(aLR); |
| } |
| break; |
| |
| case SID_RULER_PROTECT: |
| { |
| if(bFrmSelection) |
| { |
| sal_uInt8 nProtect = pWrtShell->IsSelObjProtected( FLYPROTECT_SIZE|FLYPROTECT_POS|FLYPROTECT_CONTENT ); |
| |
| SvxProtectItem aProt(SID_RULER_PROTECT); |
| aProt.SetCntntProtect((nProtect & FLYPROTECT_CONTENT) != 0); |
| aProt.SetSizeProtect ((nProtect & FLYPROTECT_SIZE) != 0); |
| aProt.SetPosProtect ((nProtect & FLYPROTECT_POS) != 0); |
| rSet.Put(aProt); |
| } |
| else |
| { |
| SvxProtectItem aProtect(SID_RULER_PROTECT); |
| if(bBrowse && !(nFrmType & (FRMTYPE_DRAWOBJ|FRMTYPE_COLUMN)) && !rSh.GetTableFmt()) |
| { |
| aProtect.SetSizeProtect(sal_True); |
| aProtect.SetPosProtect(sal_True); |
| } |
| rSet.Put(aProtect); |
| } |
| } |
| break; |
| } |
| nWhich = aIter.NextWhich(); |
| } |
| if(bPutContentProtection) |
| { |
| SvxProtectItem aProtect(SID_RULER_PROTECT); |
| aProtect.SetCntntProtect(sal_True); |
| rSet.Put(aProtect); |
| } |
| } |
| |
| |
