Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include "uitool.hxx"
22 : #include <sfx2/app.hxx>
23 : #include <svx/rulritem.hxx>
24 : #include <editeng/tstpitem.hxx>
25 : #include <sfx2/request.hxx>
26 : #include <editeng/lrspitem.hxx>
27 : #include <editeng/ulspitem.hxx>
28 : #include <editeng/boxitem.hxx>
29 : #include <editeng/frmdiritem.hxx>
30 : #include <svl/eitem.hxx>
31 : #include <svl/whiter.hxx>
32 : #include <svx/ruler.hxx>
33 : #include <editeng/protitem.hxx>
34 : #include <svl/rectitem.hxx>
35 : #include <sfx2/bindings.hxx>
36 : #include <fmtfsize.hxx>
37 : #include <fmthdft.hxx>
38 : #include <fmtclds.hxx>
39 : #include <fmtornt.hxx>
40 : #include <frmatr.hxx>
41 : #include <edtwin.hxx>
42 : #include "view.hxx"
43 : #include "wrtsh.hxx"
44 : #include "basesh.hxx"
45 : #include "cmdid.h"
46 : #include "viewopt.hxx"
47 : #include "tabcol.hxx"
48 : #include "frmfmt.hxx"
49 : #include "pagedesc.hxx"
50 : #include "wview.hxx"
51 : #include "fmtcol.hxx"
52 : #include "section.hxx"
53 :
54 : #include "ndtxt.hxx"
55 : #include "pam.hxx"
56 :
57 : #include <IDocumentSettingAccess.hxx>
58 :
59 : using namespace ::com::sun::star;
60 :
61 : // Pack columns
62 0 : static void lcl_FillSvxColumn(const SwFormatCol& rCol,
63 : long nTotalWidth,
64 : SvxColumnItem& rColItem,
65 : long nDistance)
66 : {
67 0 : const SwColumns& rCols = rCol.GetColumns();
68 :
69 0 : bool bOrtho = rCol.IsOrtho() && rCols.size();
70 0 : long nInnerWidth = 0;
71 0 : if( bOrtho )
72 : {
73 0 : nInnerWidth = nTotalWidth;
74 0 : for ( size_t i = 0; i < rCols.size(); ++i )
75 : {
76 0 : const SwColumn* pCol = &rCols[i];
77 0 : nInnerWidth -= pCol->GetLeft() + pCol->GetRight();
78 : }
79 0 : if( nInnerWidth < 0 )
80 0 : nInnerWidth = 0;
81 : else
82 0 : nInnerWidth /= rCols.size();
83 : }
84 :
85 0 : long nWidth = 0;
86 0 : for ( size_t i = 0; i < rCols.size(); ++i )
87 : {
88 0 : const SwColumn* pCol = &rCols[i];
89 0 : const long nStart = pCol->GetLeft() + nWidth + nDistance;
90 0 : if( bOrtho )
91 0 : nWidth += nInnerWidth + pCol->GetLeft() + pCol->GetRight();
92 : else
93 0 : nWidth += rCol.CalcColWidth(i, static_cast< sal_uInt16 >(nTotalWidth));
94 0 : const long nEnd = nWidth - pCol->GetRight() + nDistance;
95 :
96 0 : SvxColumnDescription aColDesc(nStart, nEnd, true);
97 0 : rColItem.Append(aColDesc);
98 : }
99 0 : }
100 :
101 : // Transfer ColumnItem in ColumnInfo
102 0 : static void lcl_ConvertToCols(const SvxColumnItem& rColItem,
103 : long nTotalWidth,
104 : SwFormatCol& rCols)
105 : {
106 : OSL_ENSURE( rCols.GetNumCols() == rColItem.Count(), "Column count mismatch" );
107 : // ruler executes that change the columns shortly after the selection has changed
108 : // can result in a crash
109 0 : if(rCols.GetNumCols() != rColItem.Count())
110 0 : return;
111 :
112 0 : sal_uInt16 nLeft = 0;
113 0 : SwTwips nSumAll= 0; // Sum up all columns and margins
114 :
115 0 : SwColumns& rArr = rCols.GetColumns();
116 :
117 : // Tabcols sequentially
118 0 : for( sal_uInt16 i=0; i < rColItem.Count()-1; ++i )
119 : {
120 : OSL_ENSURE(rColItem[i+1].nStart >= rColItem[i].nEnd,"overlapping columns" );
121 0 : const long nStart = std::max(rColItem[i+1].nStart, rColItem[i].nEnd);
122 0 : const sal_uInt16 nRight = static_cast<sal_uInt16>((nStart - rColItem[i].nEnd) / 2);
123 :
124 0 : const long nWidth = rColItem[i].nEnd - rColItem[i].nStart + nLeft + nRight;
125 :
126 0 : SwColumn* pCol = &rArr[i];
127 0 : pCol->SetWishWidth( sal_uInt16(long(rCols.GetWishWidth()) * nWidth / nTotalWidth ));
128 0 : pCol->SetLeft( nLeft );
129 0 : pCol->SetRight( nRight );
130 0 : nSumAll += pCol->GetWishWidth();
131 :
132 0 : nLeft = nRight;
133 : }
134 0 : rArr[rColItem.Count()-1].SetLeft( nLeft );
135 :
136 : // The difference between the total sum of the desired width and the so far
137 : // calculated columns and margins should result in the width of the last column.
138 0 : rArr[rColItem.Count()-1].SetWishWidth( rCols.GetWishWidth() - (sal_uInt16)nSumAll );
139 :
140 0 : rCols.SetOrtho(false, 0, 0 );
141 : }
142 :
143 : // Delete tabs
144 542 : static void lcl_EraseDefTabs(SvxTabStopItem& rTabStops)
145 : {
146 : // Delete DefTabs
147 1626 : for ( sal_uInt16 i = 0; i < rTabStops.Count(); )
148 : {
149 : // Here also throw out the DefTab to zero
150 542 : if ( SVX_TAB_ADJUST_DEFAULT == rTabStops[i].GetAdjustment() ||
151 0 : rTabStops[i].GetTabPos() == 0 )
152 : {
153 542 : rTabStops.Remove(i);
154 542 : continue;
155 : }
156 0 : ++i;
157 : }
158 542 : }
159 :
160 : // Flip page margin
161 2609 : void SwView::SwapPageMargin(const SwPageDesc& rDesc, SvxLRSpaceItem& rLRSpace)
162 : {
163 : sal_uInt16 nPhyPage, nVirPage;
164 2609 : GetWrtShell().GetPageNum( nPhyPage, nVirPage );
165 :
166 2609 : if ( rDesc.GetUseOn() == nsUseOnPage::PD_MIRROR && (nPhyPage % 2) == 0 )
167 : {
168 0 : long nTmp = rLRSpace.GetRight();
169 0 : rLRSpace.SetRight( rLRSpace.GetLeft() );
170 0 : rLRSpace.SetLeft( nTmp );
171 : }
172 2609 : }
173 :
174 : // If the frame border is moved, the column separator
175 : // should stay in the same absolute position.
176 0 : static void lcl_Scale(long& nVal, long nScale)
177 : {
178 0 : nVal *= nScale;
179 0 : nVal >>= 8;
180 0 : }
181 :
182 0 : void ResizeFrameCols(SwFormatCol& rCol,
183 : long nOldWidth,
184 : long nNewWidth,
185 : long nLeftDelta )
186 : {
187 0 : SwColumns& rArr = rCol.GetColumns();
188 0 : long nWishSum = (long)rCol.GetWishWidth();
189 0 : long nWishDiff = (nWishSum * 100/nOldWidth * nNewWidth) / 100 - nWishSum;
190 0 : long nNewWishWidth = nWishSum + nWishDiff;
191 0 : if(nNewWishWidth > 0xffffl)
192 : {
193 : // If the desired width is getting too large, then all values
194 : // must be scaled appropriately.
195 0 : long nScale = (0xffffl << 8)/ nNewWishWidth;
196 0 : for(size_t i = 0; i < rArr.size(); ++i)
197 : {
198 0 : SwColumn* pCol = &rArr[i];
199 0 : long nVal = pCol->GetWishWidth();
200 0 : lcl_Scale(nVal, nScale);
201 0 : pCol->SetWishWidth((sal_uInt16) nVal);
202 0 : nVal = pCol->GetLeft();
203 0 : lcl_Scale(nVal, nScale);
204 0 : pCol->SetLeft((sal_uInt16) nVal);
205 0 : nVal = pCol->GetRight();
206 0 : lcl_Scale(nVal, nScale);
207 0 : pCol->SetRight((sal_uInt16) nVal);
208 : }
209 0 : lcl_Scale(nNewWishWidth, nScale);
210 0 : lcl_Scale(nWishDiff, nScale);
211 : }
212 0 : rCol.SetWishWidth( (sal_uInt16) (nNewWishWidth) );
213 :
214 0 : if( nLeftDelta >= 2 || nLeftDelta <= -2)
215 0 : rArr.front().SetWishWidth(rArr.front().GetWishWidth() + (sal_uInt16)nWishDiff);
216 : else
217 0 : rArr.back().SetWishWidth(rArr.back().GetWishWidth() + (sal_uInt16)nWishDiff);
218 : // Reset auto width
219 0 : rCol.SetOrtho(false, 0, 0 );
220 0 : }
221 :
222 : // Here all changes to the tab bar will be shot again into the model.
223 0 : void SwView::ExecTabWin( SfxRequest& rReq )
224 : {
225 0 : SwWrtShell &rSh = GetWrtShell();
226 0 : const FrmTypeFlags nFrmType = rSh.IsObjSelected() ?
227 : FrmTypeFlags::DRAWOBJ :
228 0 : rSh.GetFrmType(0,true);
229 0 : const bool bFrmSelection = rSh.IsFrmSelected();
230 0 : const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
231 :
232 0 : const sal_uInt16 nSlot = rReq.GetSlot();
233 0 : const SfxItemSet* pReqArgs = rReq.GetArgs();
234 0 : const size_t nDescId = rSh.GetCurPageDesc();
235 0 : const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId );
236 :
237 0 : const bool bVerticalWriting = rSh.IsInVerticalText();
238 0 : const SwFormatHeader& rHeaderFormat = rDesc.GetMaster().GetHeader();
239 0 : SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());
240 :
241 0 : const SwFormatFooter& rFooterFormat = rDesc.GetMaster().GetFooter();
242 0 : SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());
243 :
244 0 : const SwFormatFrmSize &rFrmSize = rDesc.GetMaster().GetFrmSize();
245 :
246 0 : const SwRect& rPageRect = rSh.GetAnyCurRect(RECT_PAGE);
247 0 : const long nPageWidth = bBrowse ? rPageRect.Width() : rFrmSize.GetWidth();
248 0 : const long nPageHeight = bBrowse ? rPageRect.Height() : rFrmSize.GetHeight();
249 :
250 0 : bool bUnlockView = false;
251 0 : rSh.StartAllAction();
252 0 : bool bSect = bool(nFrmType & FrmTypeFlags::COLSECT);
253 :
254 0 : switch (nSlot)
255 : {
256 : case SID_ATTR_LONG_LRSPACE:
257 0 : if ( pReqArgs )
258 : {
259 : SvxLongLRSpaceItem aLongLR( static_cast<const SvxLongLRSpaceItem&>(pReqArgs->
260 0 : Get( SID_ATTR_LONG_LRSPACE )) );
261 0 : SvxLRSpaceItem aLR(RES_LR_SPACE);
262 0 : if ( !bSect && (bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY) )
263 : {
264 0 : SwFrameFormat* pFormat = static_cast<SwFrameFormat*>(rSh.GetFlyFrameFormat());
265 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED);
266 :
267 0 : bool bVerticalFrame(false);
268 : {
269 : bool bRTL;
270 : bool bVertL2R;
271 0 : bVerticalFrame = ( bFrmSelection &&
272 0 : rSh.IsFrmVertical(true, bRTL, bVertL2R) ) ||
273 0 : ( !bFrmSelection && bVerticalWriting);
274 : }
275 : long nDeltaX = bVerticalFrame ?
276 0 : rRect.Right() - rPageRect.Right() + aLongLR.GetRight() :
277 0 : rPageRect.Left() + aLongLR.GetLeft() - rRect.Left();
278 :
279 0 : SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE,
280 : RES_VERT_ORIENT, RES_HORI_ORIENT,
281 0 : RES_COL, RES_COL, 0 );
282 :
283 0 : if(bVerticalFrame)
284 : {
285 0 : SwFormatVertOrient aVertOrient(pFormat->GetVertOrient());
286 0 : aVertOrient.SetVertOrient(text::VertOrientation::NONE);
287 0 : aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaX );
288 0 : aSet.Put( aVertOrient );
289 : }
290 : else
291 : {
292 0 : SwFormatHoriOrient aHoriOrient( pFormat->GetHoriOrient() );
293 0 : aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
294 0 : aHoriOrient.SetPos( aHoriOrient.GetPos() + nDeltaX );
295 0 : aSet.Put( aHoriOrient );
296 : }
297 :
298 0 : SwFormatFrmSize aSize( pFormat->GetFrmSize() );
299 0 : long nOldWidth = (long) aSize.GetWidth();
300 :
301 0 : if(aSize.GetWidthPercent())
302 : {
303 0 : SwRect aRect;
304 0 : rSh.CalcBoundRect(aRect, FLY_AS_CHAR);
305 0 : long nPrtWidth = aRect.Width();
306 0 : aSize.SetWidthPercent(sal_uInt8((nPageWidth - aLongLR.GetLeft() - aLongLR.GetRight()) * 100 /nPrtWidth));
307 : }
308 : else
309 : aSize.SetWidth( nPageWidth -
310 0 : (aLongLR.GetLeft() + aLongLR.GetRight()));
311 :
312 0 : if( nFrmType & FrmTypeFlags::COLUMN )
313 : {
314 0 : SwFormatCol aCol(pFormat->GetCol());
315 :
316 0 : ::ResizeFrameCols(aCol, nOldWidth, (long)aSize.GetWidth(), nDeltaX );
317 0 : aSet.Put(aCol);
318 : }
319 :
320 0 : aSet.Put( aSize );
321 :
322 0 : rSh.StartAction();
323 0 : rSh.Push();
324 0 : rSh.SetFlyFrmAttr( aSet );
325 : // Cancel the frame selection
326 0 : if(!bFrmSelection && rSh.IsFrmSelected())
327 : {
328 0 : rSh.UnSelectFrm();
329 0 : rSh.LeaveSelFrmMode();
330 : }
331 0 : rSh.Pop();
332 0 : rSh.EndAction();
333 : }
334 0 : else if ( nFrmType & ( FrmTypeFlags::HEADER | FrmTypeFlags::FOOTER ))
335 : {
336 : // Subtract out page margins
337 0 : long nOld = rDesc.GetMaster().GetLRSpace().GetLeft();
338 0 : aLongLR.SetLeft( nOld > aLongLR.GetLeft() ? 0 : aLongLR.GetLeft() - nOld );
339 :
340 0 : nOld = rDesc.GetMaster().GetLRSpace().GetRight();
341 0 : aLongLR.SetRight( nOld > aLongLR.GetRight() ? 0 : aLongLR.GetRight() - nOld );
342 0 : aLR.SetLeft(aLongLR.GetLeft());
343 0 : aLR.SetRight(aLongLR.GetRight());
344 :
345 0 : if ( nFrmType & FrmTypeFlags::HEADER && pHeaderFormat )
346 0 : pHeaderFormat->SetFormatAttr( aLR );
347 0 : else if( nFrmType & FrmTypeFlags::FOOTER && pFooterFormat )
348 0 : pFooterFormat->SetFormatAttr( aLR );
349 : }
350 0 : else if( nFrmType == FrmTypeFlags::DRAWOBJ)
351 : {
352 0 : SwRect aRect( rSh.GetObjRect() );
353 0 : aRect.Left( aLongLR.GetLeft() + rPageRect.Left() );
354 0 : aRect.Right( rPageRect.Right() - aLongLR.GetRight());
355 0 : rSh.SetObjRect( aRect );
356 : }
357 0 : else if(bSect || rSh.IsDirectlyInSection())
358 : {
359 : //change the section indents and the columns if available
360 : //at first determine the changes
361 0 : SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0);
362 0 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0);
363 0 : aSectRect.Pos() += aTmpRect.Pos();
364 0 : long nLeftDiff = aLongLR.GetLeft() - (long)(aSectRect.Left() - rPageRect.Left() );
365 0 : long nRightDiff = aLongLR.GetRight() - (long)( rPageRect.Right() - aSectRect.Right());
366 : //change the LRSpaceItem of the section accordingly
367 0 : const SwSection* pCurrSect = rSh.GetCurrSection();
368 0 : const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
369 0 : SvxLRSpaceItem aLRTmp = pSectFormat->GetLRSpace();
370 0 : aLRTmp.SetLeft(aLRTmp.GetLeft() + nLeftDiff);
371 0 : aLRTmp.SetRight(aLRTmp.GetRight() + nRightDiff);
372 0 : SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L);
373 0 : aSet.Put(aLRTmp);
374 : //change the first/last column
375 0 : if(bSect)
376 : {
377 0 : SwFormatCol aCols( pSectFormat->GetCol() );
378 0 : long nDiffWidth = nLeftDiff + nRightDiff;
379 0 : ::ResizeFrameCols(aCols, aSectRect.Width(), aSectRect.Width() - nDiffWidth, nLeftDiff );
380 0 : aSet.Put( aCols );
381 : }
382 0 : SwSectionData aData(*pCurrSect);
383 0 : rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
384 : }
385 : else
386 : { // Adjust page margins
387 0 : aLR.SetLeft(aLongLR.GetLeft());
388 0 : aLR.SetRight(aLongLR.GetRight());
389 0 : SwapPageMargin( rDesc, aLR );
390 0 : SwPageDesc aDesc( rDesc );
391 0 : aDesc.GetMaster().SetFormatAttr( aLR );
392 0 : rSh.ChgPageDesc( nDescId, aDesc );
393 0 : }
394 : }
395 0 : break;
396 :
397 : // apply new left and right margins to current page style
398 : case SID_ATTR_PAGE_LRSPACE:
399 0 : if ( pReqArgs )
400 : {
401 0 : const SvxLongLRSpaceItem aLongLR( static_cast<const SvxLongLRSpaceItem&>(pReqArgs->Get( SID_ATTR_PAGE_LRSPACE )) );
402 :
403 0 : SwPageDesc aDesc( rDesc );
404 : {
405 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
406 0 : aLR.SetLeft(aLongLR.GetLeft());
407 0 : aLR.SetRight(aLongLR.GetRight());
408 0 : SwapPageMargin( rDesc, aLR );
409 0 : aDesc.GetMaster().SetFormatAttr( aLR );
410 : }
411 0 : rSh.ChgPageDesc( nDescId, aDesc );
412 : }
413 0 : break;
414 :
415 : case SID_ATTR_LONG_ULSPACE:
416 0 : if ( pReqArgs )
417 : {
418 : SvxLongULSpaceItem aLongULSpace( static_cast<const SvxLongULSpaceItem&>(pReqArgs->
419 0 : Get( SID_ATTR_LONG_ULSPACE )));
420 :
421 0 : if( bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY )
422 : {
423 0 : SwFrameFormat* pFormat = static_cast<SwFrameFormat*>(rSh.GetFlyFrameFormat());
424 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED);
425 0 : const long nDeltaY = rPageRect.Top() + aLongULSpace.GetUpper() - rRect.Top();
426 0 : const long nHeight = nPageHeight - (aLongULSpace.GetUpper() + aLongULSpace.GetLower());
427 :
428 0 : SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE,
429 0 : RES_VERT_ORIENT, RES_HORI_ORIENT, 0 );
430 : //which of the orientation attributes is to be put depends on the frame's environment
431 : bool bRTL;
432 : bool bVertL2R;
433 0 : if ( ( bFrmSelection &&
434 0 : rSh.IsFrmVertical(true, bRTL, bVertL2R ) ) ||
435 0 : ( !bFrmSelection && bVerticalWriting ) )
436 : {
437 0 : SwFormatHoriOrient aHoriOrient(pFormat->GetHoriOrient());
438 0 : aHoriOrient.SetHoriOrient(text::HoriOrientation::NONE);
439 0 : aHoriOrient.SetPos(aHoriOrient.GetPos() + nDeltaY );
440 0 : aSet.Put( aHoriOrient );
441 : }
442 : else
443 : {
444 0 : SwFormatVertOrient aVertOrient(pFormat->GetVertOrient());
445 0 : aVertOrient.SetVertOrient(text::VertOrientation::NONE);
446 0 : aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY );
447 0 : aSet.Put( aVertOrient );
448 : }
449 0 : SwFormatFrmSize aSize(pFormat->GetFrmSize());
450 0 : if(aSize.GetHeightPercent())
451 : {
452 0 : SwRect aRect;
453 0 : rSh.CalcBoundRect(aRect, FLY_AS_CHAR);
454 0 : long nPrtHeight = aRect.Height();
455 0 : aSize.SetHeightPercent(sal_uInt8(nHeight * 100 /nPrtHeight));
456 : }
457 : else
458 0 : aSize.SetHeight(nHeight );
459 :
460 0 : aSet.Put( aSize );
461 0 : rSh.SetFlyFrmAttr( aSet );
462 : }
463 0 : else if( nFrmType == FrmTypeFlags::DRAWOBJ )
464 : {
465 0 : SwRect aRect( rSh.GetObjRect() );
466 0 : aRect.Top( aLongULSpace.GetUpper() + rPageRect.Top() );
467 0 : aRect.Bottom( rPageRect.Bottom() - aLongULSpace.GetLower() );
468 0 : rSh.SetObjRect( aRect ) ;
469 : }
470 0 : else if(bVerticalWriting && (bSect || rSh.IsDirectlyInSection()))
471 : {
472 : //change the section indents and the columns if available
473 : //at first determine the changes
474 0 : SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0);
475 0 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0);
476 0 : aSectRect.Pos() += aTmpRect.Pos();
477 0 : const long nLeftDiff = aLongULSpace.GetUpper() - (long)(aSectRect.Top() - rPageRect.Top());
478 0 : const long nRightDiff = aLongULSpace.GetLower() - (long)(nPageHeight - aSectRect.Bottom() + rPageRect.Top());
479 : //change the LRSpaceItem of the section accordingly
480 0 : const SwSection* pCurrSect = rSh.GetCurrSection();
481 0 : const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
482 0 : SvxLRSpaceItem aLR = pSectFormat->GetLRSpace();
483 0 : aLR.SetLeft(aLR.GetLeft() + nLeftDiff);
484 0 : aLR.SetRight(aLR.GetRight() + nRightDiff);
485 0 : SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L);
486 0 : aSet.Put(aLR);
487 : //change the first/last column
488 0 : if(bSect)
489 : {
490 0 : SwFormatCol aCols( pSectFormat->GetCol() );
491 0 : long nDiffWidth = nLeftDiff + nRightDiff;
492 0 : ::ResizeFrameCols(aCols, aSectRect.Height(), aSectRect.Height() - nDiffWidth, nLeftDiff );
493 0 : aSet.Put( aCols );
494 : }
495 0 : SwSectionData aData(*pCurrSect);
496 0 : rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
497 : }
498 : else
499 0 : { SwPageDesc aDesc( rDesc );
500 :
501 0 : if ( nFrmType & ( FrmTypeFlags::HEADER | FrmTypeFlags::FOOTER ))
502 : {
503 :
504 0 : const bool bHead = bool(nFrmType & FrmTypeFlags::HEADER);
505 0 : SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
506 0 : if ( bHead )
507 0 : aUL.SetUpper( (sal_uInt16)aLongULSpace.GetUpper() );
508 : else
509 0 : aUL.SetLower( (sal_uInt16)aLongULSpace.GetLower() );
510 0 : aDesc.GetMaster().SetFormatAttr( aUL );
511 :
512 0 : if( (bHead && pHeaderFormat) || (!bHead && pFooterFormat) )
513 : {
514 0 : SwFormatFrmSize aSz( bHead ? pHeaderFormat->GetFrmSize() :
515 0 : pFooterFormat->GetFrmSize() );
516 0 : aSz.SetHeightSizeType( ATT_FIX_SIZE );
517 0 : aSz.SetHeight(nPageHeight - aLongULSpace.GetLower() -
518 0 : aLongULSpace.GetUpper() );
519 0 : if ( bHead )
520 0 : pHeaderFormat->SetFormatAttr( aSz );
521 : else
522 0 : pFooterFormat->SetFormatAttr( aSz );
523 0 : }
524 : }
525 : else
526 : {
527 0 : SvxULSpaceItem aUL(RES_UL_SPACE);
528 0 : aUL.SetUpper((sal_uInt16)aLongULSpace.GetUpper());
529 0 : aUL.SetLower((sal_uInt16)aLongULSpace.GetLower());
530 0 : aDesc.GetMaster().SetFormatAttr(aUL);
531 : }
532 :
533 0 : rSh.ChgPageDesc( nDescId, aDesc );
534 0 : }
535 : }
536 0 : break;
537 :
538 : // apply new top and bottom margins to current page style
539 : case SID_ATTR_PAGE_ULSPACE:
540 0 : if ( pReqArgs )
541 : {
542 : SvxLongULSpaceItem aLongULSpace(
543 0 : static_cast<const SvxLongULSpaceItem&>(pReqArgs->Get( SID_ATTR_PAGE_ULSPACE ) ) );
544 :
545 0 : SwPageDesc aDesc( rDesc );
546 : {
547 0 : SvxULSpaceItem aUL(RES_UL_SPACE);
548 0 : aUL.SetUpper((sal_uInt16)aLongULSpace.GetUpper());
549 0 : aUL.SetLower((sal_uInt16)aLongULSpace.GetLower());
550 0 : aDesc.GetMaster().SetFormatAttr(aUL);
551 : }
552 0 : rSh.ChgPageDesc( nDescId, aDesc );
553 : }
554 0 : break;
555 :
556 : case SID_ATTR_PAGE_COLUMN:
557 0 : if ( pReqArgs )
558 : {
559 0 : const SfxInt16Item aColumnItem( static_cast<const SfxInt16Item&>(pReqArgs->Get(nSlot)) );
560 0 : const sal_uInt16 nPageColumnType = aColumnItem.GetValue();
561 :
562 : // nPageColumnType =
563 : // 1 - single-columned page
564 : // 2 - two-columned page
565 : // 3 - three-columned page
566 : // 4 - two-columned page with left column width of 2/3 of page width
567 : // 5 - two-columned page with right column width of 2/3 of page width
568 :
569 0 : sal_uInt16 nCount = 2;
570 0 : if ( nPageColumnType == 1 )
571 : {
572 0 : nCount = 0;
573 : }
574 0 : else if ( nPageColumnType == 3 )
575 : {
576 0 : nCount = 3;
577 : }
578 :
579 0 : const sal_uInt16 nGutterWidth = 0;
580 :
581 0 : const SvxLRSpaceItem aLR( rDesc.GetMaster().GetLRSpace() );
582 0 : const long nLeft = aLR.GetLeft();
583 0 : const long nRight = aLR.GetRight();
584 0 : const long nWidth = nPageWidth - nLeft - nRight;
585 :
586 0 : SwFormatCol aCols( rDesc.GetMaster().GetCol() );
587 0 : aCols.Init( nCount, nGutterWidth, nWidth );
588 0 : aCols.SetWishWidth( nWidth );
589 0 : aCols.SetGutterWidth( nGutterWidth, nWidth );
590 0 : aCols.SetOrtho( false, nGutterWidth, nWidth );
591 :
592 0 : long nColumnLeft = 0;
593 0 : long nColumnRight = 0;
594 0 : if ( nPageColumnType == 4 )
595 : {
596 0 : nColumnRight = (long)(nWidth/3);
597 0 : nColumnLeft = nWidth - nColumnRight;
598 0 : aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
599 0 : aCols.GetColumns()[1].SetWishWidth( nColumnRight );
600 : }
601 0 : else if ( nPageColumnType == 5 )
602 : {
603 0 : nColumnLeft = (long)(nWidth/3);
604 0 : nColumnRight = nWidth - nColumnLeft;
605 0 : aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
606 0 : aCols.GetColumns()[1].SetWishWidth( nColumnRight );
607 : }
608 :
609 0 : SwPageDesc aDesc( rDesc );
610 0 : aDesc.GetMaster().SetFormatAttr( aCols );
611 0 : rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
612 : }
613 0 : break;
614 :
615 : case SID_ATTR_TABSTOP_VERTICAL:
616 : case SID_ATTR_TABSTOP:
617 0 : if (pReqArgs)
618 : {
619 0 : const sal_uInt16 nWhich = GetPool().GetWhich(nSlot);
620 : SvxTabStopItem aTabStops( static_cast<const SvxTabStopItem&>(pReqArgs->
621 0 : Get( nWhich )));
622 0 : aTabStops.SetWhich(RES_PARATR_TABSTOP);
623 : const SvxTabStopItem& rDefTabs =
624 0 : static_cast<const SvxTabStopItem&>(rSh.GetDefault(RES_PARATR_TABSTOP));
625 :
626 : // Default tab at pos 0
627 0 : SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE );
628 0 : rSh.GetCurAttr( aSet );
629 0 : const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>(aSet.Get(RES_LR_SPACE));
630 :
631 0 : if ( rLR.GetTextFirstLineOfst() < 0 )
632 : {
633 0 : SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT );
634 0 : aTabStops.Insert( aSwTabStop );
635 : }
636 :
637 : // Populate with default tabs.
638 0 : ::MakeDefTabs( ::GetTabDist( rDefTabs ), aTabStops );
639 :
640 0 : SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
641 0 : if( pColl && pColl->IsAutoUpdateFormat() )
642 : {
643 0 : SfxItemSet aTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP);
644 0 : aTmp.Put(aTabStops);
645 0 : rSh.AutoUpdatePara( pColl, aTmp );
646 : }
647 : else
648 0 : rSh.SetAttrItem( aTabStops );
649 : }
650 0 : break;
651 :
652 : case SID_ATTR_PARA_LRSPACE_VERTICAL:
653 : case SID_ATTR_PARA_LRSPACE:
654 0 : if ( pReqArgs )
655 : {
656 0 : SvxLRSpaceItem aParaMargin(static_cast<const SvxLRSpaceItem&>(pReqArgs->Get(nSlot)));
657 :
658 0 : aParaMargin.SetRight( aParaMargin.GetRight() - m_nRightBorderDistance );
659 0 : aParaMargin.SetTextLeft(aParaMargin.GetTextLeft() - m_nLeftBorderDistance );
660 :
661 0 : aParaMargin.SetWhich( RES_LR_SPACE );
662 0 : SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
663 :
664 : // #i23726#
665 0 : if (m_pNumRuleNodeFromDoc)
666 : {
667 : // --> #i42922# Mouse move of numbering label
668 : // has to consider the left indent of the paragraph
669 0 : SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE );
670 0 : rSh.GetCurAttr( aSet );
671 : const SvxLRSpaceItem& rLR =
672 0 : static_cast<const SvxLRSpaceItem&>(aSet.Get(RES_LR_SPACE));
673 :
674 0 : SwPosition aPos(*m_pNumRuleNodeFromDoc);
675 : // #i90078#
676 0 : rSh.SetIndent( static_cast< short >(aParaMargin.GetTextLeft() - rLR.GetTextLeft()), aPos);
677 : // #i42921# invalidate state of indent in order to get a ruler update.
678 0 : aParaMargin.SetWhich( nSlot );
679 0 : GetViewFrame()->GetBindings().SetState( aParaMargin );
680 : }
681 0 : else if( pColl && pColl->IsAutoUpdateFormat() )
682 : {
683 0 : SfxItemSet aSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE);
684 0 : aSet.Put(aParaMargin);
685 0 : rSh.AutoUpdatePara( pColl, aSet);
686 : }
687 : else
688 0 : rSh.SetAttrItem( aParaMargin );
689 :
690 0 : if ( aParaMargin.GetTextFirstLineOfst() < 0 )
691 : {
692 0 : SfxItemSet aSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP );
693 :
694 0 : rSh.GetCurAttr( aSet );
695 0 : const SvxTabStopItem& rTabStops = static_cast<const SvxTabStopItem&>(aSet.Get(RES_PARATR_TABSTOP));
696 :
697 : // Do we have a tab at position zero?
698 : sal_uInt16 i;
699 :
700 0 : for ( i = 0; i < rTabStops.Count(); ++i )
701 0 : if ( rTabStops[i].GetTabPos() == 0 )
702 0 : break;
703 :
704 0 : if ( i >= rTabStops.Count() )
705 : {
706 : // No DefTab
707 0 : SvxTabStopItem aTabStops( RES_PARATR_TABSTOP );
708 0 : aTabStops = rTabStops;
709 :
710 0 : ::lcl_EraseDefTabs(aTabStops);
711 :
712 0 : SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT );
713 0 : aTabStops.Insert(aSwTabStop);
714 :
715 : const SvxTabStopItem& rDefTabs =
716 0 : static_cast<const SvxTabStopItem&>(rSh.GetDefault(RES_PARATR_TABSTOP));
717 0 : ::MakeDefTabs( ::GetTabDist(rDefTabs), aTabStops );
718 :
719 0 : if( pColl && pColl->IsAutoUpdateFormat())
720 : {
721 0 : SfxItemSet aSetTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP);
722 0 : aSetTmp.Put(aTabStops);
723 0 : rSh.AutoUpdatePara( pColl, aSetTmp );
724 : }
725 : else
726 0 : rSh.SetAttrItem( aTabStops );
727 0 : }
728 0 : }
729 : }
730 0 : break;
731 :
732 : case SID_ATTR_PARA_ULSPACE:
733 0 : if ( pReqArgs )
734 : {
735 0 : SvxULSpaceItem aParaMargin(static_cast<const SvxULSpaceItem&>(pReqArgs->Get(nSlot)));
736 :
737 0 : long nUDist = 0;
738 0 : long nLDist = 0;
739 0 : aParaMargin.SetUpper( aParaMargin.GetUpper() - nUDist );
740 0 : aParaMargin.SetLower(aParaMargin.GetLower() - nLDist);
741 :
742 0 : aParaMargin.SetWhich( RES_UL_SPACE );
743 0 : SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
744 0 : if( pColl && pColl->IsAutoUpdateFormat() )
745 : {
746 0 : SfxItemSet aSet(GetPool(), RES_UL_SPACE, RES_UL_SPACE);
747 0 : aSet.Put(aParaMargin);
748 0 : rSh.AutoUpdatePara( pColl, aSet);
749 : }
750 : else
751 0 : rSh.SetAttrItem( aParaMargin );
752 : }
753 0 : break;
754 : case SID_PARASPACE_INCREASE:
755 : case SID_PARASPACE_DECREASE:
756 : {
757 0 : SfxItemSet aULSpaceSet( GetPool(), RES_UL_SPACE, RES_UL_SPACE );
758 0 : rSh.GetCurAttr( aULSpaceSet );
759 : SvxULSpaceItem aULSpace(
760 0 : static_cast< const SvxULSpaceItem& >( aULSpaceSet.Get( RES_UL_SPACE ) ) );
761 0 : sal_uInt16 nUpper = aULSpace.GetUpper();
762 0 : sal_uInt16 nLower = aULSpace.GetLower();
763 :
764 0 : if ( nSlot == SID_PARASPACE_INCREASE )
765 : {
766 0 : nUpper = std::min< sal_uInt16 >( nUpper + 57, 5670 );
767 0 : nLower = std::min< sal_uInt16 >( nLower + 57, 5670 );
768 : }
769 : else
770 : {
771 0 : nUpper = std::max< sal_Int16 >( nUpper - 57, 0 );
772 0 : nLower = std::max< sal_Int16 >( nLower - 57, 0 );
773 : }
774 :
775 0 : aULSpace.SetUpper( nUpper );
776 0 : aULSpace.SetLower( nLower );
777 :
778 0 : SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
779 0 : if( pColl && pColl->IsAutoUpdateFormat() )
780 : {
781 0 : aULSpaceSet.Put( aULSpace );
782 0 : rSh.AutoUpdatePara( pColl, aULSpaceSet );
783 : }
784 : else
785 0 : rSh.SetAttrItem( aULSpace );
786 : }
787 0 : break;
788 : case SID_RULER_BORDERS_VERTICAL:
789 : case SID_RULER_BORDERS:
790 0 : if ( pReqArgs )
791 : {
792 0 : SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));
793 :
794 0 : if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
795 : {
796 : OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
797 :
798 : const bool bSingleLine = static_cast<const SfxBoolItem&>(rReq.
799 0 : GetArgs()->Get(SID_RULER_ACT_LINE_ONLY)).GetValue();
800 :
801 0 : SwTabCols aTabCols;
802 0 : if ( m_bSetTabColFromDoc )
803 0 : rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
804 : else
805 0 : rSh.GetTabCols(aTabCols);
806 :
807 : // left table border
808 0 : long nBorder = (long)(aColItem.GetLeft() - aTabCols.GetLeftMin());
809 0 : aTabCols.SetLeft( nBorder );
810 :
811 0 : nBorder = (bVerticalWriting ? nPageHeight : nPageWidth) - aTabCols.GetLeftMin() - aColItem.GetRight();
812 :
813 0 : if ( aColItem.GetRight() > 0 )
814 0 : aTabCols.SetRight( nBorder );
815 :
816 : // Tabcols sequentially
817 : // The last column is defined by the edge.
818 : // Columns in right-to-left tables need to be mirrored
819 : bool bIsTableRTL =
820 0 : IsTabColFromDoc() ?
821 0 : rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
822 0 : : rSh.IsTableRightToLeft();
823 0 : const size_t nColCount = aColItem.Count() - 1;
824 0 : if(bIsTableRTL)
825 : {
826 0 : for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
827 : {
828 0 : const SvxColumnDescription& rCol = aColItem[nColCount - i];
829 0 : aTabCols[i] = aTabCols.GetRight() - rCol.nStart;
830 0 : aTabCols.SetHidden( i, !rCol.bVisible );
831 : }
832 : }
833 : else
834 : {
835 0 : for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
836 : {
837 0 : const SvxColumnDescription& rCol = aColItem[i];
838 0 : aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
839 0 : aTabCols.SetHidden( i, !rCol.bVisible );
840 : }
841 : }
842 :
843 0 : if ( m_bSetTabColFromDoc )
844 : {
845 0 : if( !rSh.IsViewLocked() )
846 : {
847 0 : bUnlockView = true;
848 0 : rSh.LockView( true );
849 : }
850 : rSh.SetMouseTabCols( aTabCols, bSingleLine,
851 0 : m_aTabColFromDocPos );
852 : }
853 : else
854 0 : rSh.SetTabCols(aTabCols, bSingleLine);
855 :
856 : }
857 : else
858 : {
859 0 : if ( bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY || bSect)
860 : {
861 0 : SwSectionFormat *pSectFormat = 0;
862 0 : SfxItemSet aSet( GetPool(), RES_COL, RES_COL );
863 0 : if(bSect)
864 : {
865 0 : SwSection *pSect = rSh.GetAnySection();
866 : OSL_ENSURE( pSect, "Which section?");
867 0 : pSectFormat = pSect->GetFormat();
868 : }
869 : else
870 : {
871 0 : rSh.GetFlyFrmAttr( aSet );
872 : }
873 : SwFormatCol aCols(
874 : bSect ?
875 0 : pSectFormat->GetCol() :
876 0 : static_cast<const SwFormatCol&>(aSet.Get( RES_COL, false )));
877 0 : SwRect aCurRect = rSh.GetAnyCurRect(bSect ? RECT_SECTION_PRT : RECT_FLY_PRT_EMBEDDED);
878 0 : const long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width();
879 0 : ::lcl_ConvertToCols( aColItem, lWidth, aCols );
880 0 : aSet.Put( aCols );
881 0 : if(bSect)
882 0 : rSh.SetSectionAttr( aSet, pSectFormat );
883 : else
884 : {
885 0 : rSh.StartAction();
886 0 : rSh.Push();
887 0 : rSh.SetFlyFrmAttr( aSet );
888 : // Cancel the frame selection again
889 0 : if(!bFrmSelection && rSh.IsFrmSelected())
890 : {
891 0 : rSh.UnSelectFrm();
892 0 : rSh.LeaveSelFrmMode();
893 : }
894 0 : rSh.Pop();
895 0 : rSh.EndAction();
896 0 : }
897 : }
898 : else
899 : {
900 0 : SwFormatCol aCols( rDesc.GetMaster().GetCol() );
901 0 : const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT);
902 : ::lcl_ConvertToCols( aColItem,
903 : bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
904 0 : aCols );
905 0 : SwPageDesc aDesc( rDesc );
906 0 : aDesc.GetMaster().SetFormatAttr( aCols );
907 0 : rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
908 : }
909 0 : }
910 : }
911 0 : break;
912 :
913 : case SID_RULER_ROWS :
914 : case SID_RULER_ROWS_VERTICAL:
915 0 : if (pReqArgs)
916 : {
917 0 : SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));
918 :
919 0 : if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
920 : {
921 : OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
922 :
923 0 : SwTabCols aTabCols;
924 0 : if ( m_bSetTabRowFromDoc )
925 0 : rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
926 : else
927 0 : rSh.GetTabRows(aTabCols);
928 :
929 0 : if ( bVerticalWriting )
930 : {
931 0 : aTabCols.SetRight(nPageWidth - aColItem.GetRight() - aColItem.GetLeft());
932 0 : aTabCols.SetLeftMin(aColItem.GetLeft());
933 : }
934 : else
935 : {
936 0 : long nBorder = nPageHeight - aTabCols.GetLeftMin() - aColItem.GetRight();
937 0 : aTabCols.SetRight( nBorder );
938 : }
939 :
940 0 : const size_t nColItems = aColItem.Count() - 1;
941 0 : if(bVerticalWriting)
942 : {
943 0 : for ( size_t i = nColItems; i; --i )
944 : {
945 0 : const SvxColumnDescription& rCol = aColItem[i - 1];
946 0 : long nColumnPos = aTabCols.GetRight() - rCol.nEnd ;
947 0 : aTabCols[i - 1] = nColumnPos;
948 0 : aTabCols.SetHidden( i - 1, !rCol.bVisible );
949 : }
950 : }
951 : else
952 : {
953 0 : for ( size_t i = 0; i < nColItems; ++i )
954 : {
955 0 : const SvxColumnDescription& rCol = aColItem[i];
956 0 : aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
957 0 : aTabCols.SetHidden( i, !rCol.bVisible );
958 : }
959 : }
960 0 : bool bSingleLine = false;
961 : const SfxPoolItem* pSingleLine;
962 0 : if( SfxItemState::SET == rReq.GetArgs()->GetItemState(SID_RULER_ACT_LINE_ONLY, false, &pSingleLine))
963 0 : bSingleLine = static_cast<const SfxBoolItem*>(pSingleLine)->GetValue();
964 0 : if ( m_bSetTabRowFromDoc )
965 : {
966 0 : if( !rSh.IsViewLocked() )
967 : {
968 0 : bUnlockView = true;
969 0 : rSh.LockView( true );
970 : }
971 0 : rSh.SetMouseTabRows( aTabCols, bSingleLine, m_aTabColFromDocPos );
972 : }
973 : else
974 0 : rSh.SetTabRows(aTabCols, bSingleLine);
975 0 : }
976 : }
977 0 : break;
978 :
979 : default:
980 : OSL_ENSURE( false, "wrong SlotId");
981 : }
982 0 : rSh.EndAllAction();
983 :
984 0 : if( bUnlockView )
985 0 : rSh.LockView( false );
986 :
987 0 : m_bSetTabColFromDoc = m_bSetTabRowFromDoc = m_bTabColFromDoc = m_bTabRowFromDoc = false;
988 0 : SetNumRuleNodeFromDoc(NULL);
989 0 : }
990 :
991 : // Here the status of the tab bar will be determined.
992 : // This means that all relevant attributes at the CursorPos
993 : // will be submittet to the tab bar.
994 2609 : void SwView::StateTabWin(SfxItemSet& rSet)
995 : {
996 2609 : SwWrtShell &rSh = GetWrtShell();
997 :
998 2609 : const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &m_aTabColFromDocPos : 0;
999 2609 : const FrmTypeFlags nFrmType = rSh.IsObjSelected()
1000 : ? FrmTypeFlags::DRAWOBJ
1001 2609 : : rSh.GetFrmType( pPt, true );
1002 :
1003 2609 : const bool bFrmSelection = rSh.IsFrmSelected();
1004 2609 : const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
1005 : // PageOffset/limiter
1006 2609 : const SwRect& rPageRect = rSh.GetAnyCurRect( RECT_PAGE, pPt );
1007 2609 : const SwRect& rPagePrtRect = rSh.GetAnyCurRect( RECT_PAGE_PRT, pPt );
1008 2609 : const long nPageWidth = rPageRect.Width();
1009 2609 : const long nPageHeight = rPageRect.Height();
1010 :
1011 : const SwPageDesc& rDesc = rSh.GetPageDesc(
1012 5218 : IsTabColFromDoc() || m_bTabRowFromDoc ?
1013 2609 : rSh.GetMousePageDesc(m_aTabColFromDocPos) : rSh.GetCurPageDesc() );
1014 :
1015 2609 : const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrmDir();
1016 2609 : const bool bVerticalWriting = rSh.IsInVerticalText();
1017 :
1018 : //enable tab stop display on the rulers depending on the writing direction
1019 2609 : WinBits nRulerStyle = m_pHRuler->GetStyle() & ~WB_EXTRAFIELD;
1020 2609 : m_pHRuler->SetStyle(bVerticalWriting||bBrowse ? nRulerStyle : nRulerStyle|WB_EXTRAFIELD);
1021 2609 : nRulerStyle = m_pVRuler->GetStyle() & ~WB_EXTRAFIELD;
1022 2609 : m_pVRuler->SetStyle(bVerticalWriting ? nRulerStyle|WB_EXTRAFIELD : nRulerStyle);
1023 :
1024 : //#i24363# tab stops relative to indent
1025 2609 : bool bRelative = rSh.getIDocumentSettingAccess()->get(DocumentSettingId::TABS_RELATIVE_TO_INDENT);
1026 2609 : m_pHRuler->SetTabsRelativeToIndent( bRelative );
1027 2609 : m_pVRuler->SetTabsRelativeToIndent( bRelative );
1028 :
1029 2609 : SvxLRSpaceItem aPageLRSpace( rDesc.GetMaster().GetLRSpace() );
1030 2609 : SwapPageMargin( rDesc, aPageLRSpace );
1031 :
1032 2609 : SfxItemSet aCoreSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP,
1033 5218 : RES_LR_SPACE, RES_UL_SPACE, 0 );
1034 : // get also the list level indent values merged as LR-SPACE item, if needed.
1035 2609 : rSh.GetCurAttr( aCoreSet, true );
1036 2609 : const SelectionType nSelType = rSh.GetSelectionType();
1037 :
1038 5218 : SfxWhichIter aIter( rSet );
1039 2609 : sal_uInt16 nWhich = aIter.FirstWhich();
1040 2609 : bool bPutContentProtection = false;
1041 :
1042 18312 : while ( nWhich )
1043 : {
1044 13094 : switch ( nWhich )
1045 : {
1046 :
1047 : case SID_ATTR_PAGE_COLUMN:
1048 : {
1049 510 : sal_uInt16 nColumnType = 0;
1050 :
1051 510 : const SwFrameFormat& rMaster = rDesc.GetMaster();
1052 510 : SwFormatCol aCol(rMaster.GetCol());
1053 510 : const sal_uInt16 nCols = aCol.GetNumCols();
1054 510 : if ( nCols == 0 )
1055 : {
1056 510 : nColumnType = 1;
1057 : }
1058 0 : else if ( nCols == 2 )
1059 : {
1060 0 : const sal_uInt16 nColLeft = aCol.CalcPrtColWidth(0, aCol.GetWishWidth());
1061 0 : const sal_uInt16 nColRight = aCol.CalcPrtColWidth(1, aCol.GetWishWidth());
1062 :
1063 0 : if ( abs(nColLeft - nColRight) <= 10 )
1064 : {
1065 0 : nColumnType = 2;
1066 : }
1067 0 : else if( abs(nColLeft - nColRight*2) < 20 )
1068 : {
1069 0 : nColumnType = 4;
1070 : }
1071 0 : else if( abs(nColLeft*2 - nColRight) < 20 )
1072 : {
1073 0 : nColumnType = 5;
1074 : }
1075 : }
1076 0 : else if( nCols == 3 )
1077 : {
1078 0 : nColumnType = 3;
1079 : }
1080 :
1081 510 : rSet.Put( SfxInt16Item( SID_ATTR_PAGE_COLUMN, nColumnType ) );
1082 : }
1083 510 : break;
1084 :
1085 : case SID_ATTR_LONG_LRSPACE:
1086 : {
1087 : SvxLongLRSpaceItem aLongLR( (long)aPageLRSpace.GetLeft(),
1088 : (long)aPageLRSpace.GetRight(),
1089 548 : SID_ATTR_LONG_LRSPACE);
1090 548 : if(bBrowse)
1091 : {
1092 1 : aLongLR.SetLeft(rPagePrtRect.Left());
1093 1 : aLongLR.SetRight(nPageWidth - rPagePrtRect.Right());
1094 : }
1095 1096 : if ( ( nFrmType & FrmTypeFlags::HEADER || nFrmType & FrmTypeFlags::FOOTER ) &&
1096 548 : !(nFrmType & FrmTypeFlags::COLSECT) )
1097 : {
1098 0 : SwFrameFormat *pFormat = const_cast<SwFrameFormat*>(nFrmType & FrmTypeFlags::HEADER ?
1099 0 : rDesc.GetMaster().GetHeader().GetHeaderFormat() :
1100 0 : rDesc.GetMaster().GetFooter().GetFooterFormat());
1101 0 : if( pFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
1102 : {
1103 0 : SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
1104 0 : aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
1105 0 : const SvxLRSpaceItem& aLR = pFormat->GetLRSpace();
1106 0 : aLongLR.SetLeft ( (long)aLR.GetLeft() + (long)aRect.Left() );
1107 0 : aLongLR.SetRight( (nPageWidth -
1108 0 : (long)aRect.Right() + (long)aLR.GetRight()));
1109 : }
1110 : }
1111 : else
1112 : {
1113 548 : SwRect aRect;
1114 548 : if( !bFrmSelection && ((nFrmType & FrmTypeFlags::COLSECT) || rSh.IsDirectlyInSection()) )
1115 : {
1116 3 : aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
1117 3 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);
1118 3 : aRect.Pos() += aTmpRect.Pos();
1119 : }
1120 :
1121 545 : else if ( bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY )
1122 0 : aRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1123 545 : else if( nFrmType & FrmTypeFlags::DRAWOBJ)
1124 0 : aRect = rSh.GetObjRect();
1125 :
1126 548 : if( aRect.Width() )
1127 : {
1128 : // make relative to page position:
1129 3 : aLongLR.SetLeft(aRect.Left() - rPageRect.Left());
1130 3 : aLongLR.SetRight(rPageRect.Right() - aRect.Right());
1131 : }
1132 : }
1133 548 : if( nWhich == SID_ATTR_LONG_LRSPACE )
1134 548 : rSet.Put( aLongLR );
1135 : else
1136 : {
1137 : SvxLRSpaceItem aLR( aLongLR.GetLeft(),
1138 : aLongLR.GetRight(),
1139 : 0, 0,
1140 0 : nWhich);
1141 0 : rSet.Put(aLR);
1142 : }
1143 548 : break;
1144 : }
1145 :
1146 : // provide left and right margins of current page style
1147 : case SID_ATTR_PAGE_LRSPACE:
1148 : {
1149 847 : const SvxLRSpaceItem aTmpPageLRSpace( rDesc.GetMaster().GetLRSpace() );
1150 : const SvxLongLRSpaceItem aLongLR(
1151 : (long)aTmpPageLRSpace.GetLeft(),
1152 : (long)aTmpPageLRSpace.GetRight(),
1153 1694 : SID_ATTR_PAGE_LRSPACE );
1154 1694 : rSet.Put( aLongLR );
1155 : }
1156 847 : break;
1157 :
1158 : case SID_ATTR_LONG_ULSPACE:
1159 : {
1160 : // Page margin top bottom
1161 583 : SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1162 583 : SvxLongULSpaceItem aLongUL( (long)aUL.GetUpper(),
1163 583 : (long)aUL.GetLower(),
1164 1749 : SID_ATTR_LONG_ULSPACE);
1165 :
1166 583 : if ( bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY )
1167 : {
1168 : // Convert document coordinates into page coordinates.
1169 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1170 0 : aLongUL.SetUpper(rRect.Top() - rPageRect.Top());
1171 0 : aLongUL.SetLower(rPageRect.Bottom() - rRect.Bottom());
1172 : }
1173 583 : else if ( nFrmType & FrmTypeFlags::HEADER || nFrmType & FrmTypeFlags::FOOTER )
1174 : {
1175 0 : SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
1176 0 : aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
1177 0 : aLongUL.SetUpper( aRect.Top() );
1178 0 : aLongUL.SetLower( nPageHeight - aRect.Bottom() );
1179 : }
1180 583 : else if( nFrmType & FrmTypeFlags::DRAWOBJ)
1181 : {
1182 0 : const SwRect &rRect = rSh.GetObjRect();
1183 0 : aLongUL.SetUpper((rRect.Top() - rPageRect.Top()));
1184 0 : aLongUL.SetLower((rPageRect.Bottom() - rRect.Bottom()));
1185 : }
1186 583 : else if(bBrowse)
1187 : {
1188 1 : aLongUL.SetUpper(rPagePrtRect.Top());
1189 1 : aLongUL.SetLower(nPageHeight - rPagePrtRect.Bottom());
1190 : }
1191 583 : if( nWhich == SID_ATTR_LONG_ULSPACE )
1192 583 : rSet.Put( aLongUL );
1193 : else
1194 : {
1195 0 : SvxULSpaceItem aULTmp((sal_uInt16)aLongUL.GetUpper(),
1196 0 : (sal_uInt16)aLongUL.GetLower(),
1197 0 : nWhich);
1198 0 : rSet.Put(aULTmp);
1199 : }
1200 1166 : break;
1201 : }
1202 :
1203 : // provide top and bottom margins of current page style
1204 : case SID_ATTR_PAGE_ULSPACE:
1205 : {
1206 847 : const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1207 : SvxLongULSpaceItem aLongUL(
1208 847 : (long)aUL.GetUpper(),
1209 847 : (long)aUL.GetLower(),
1210 2541 : SID_ATTR_PAGE_ULSPACE );
1211 :
1212 1694 : rSet.Put( aLongUL );
1213 : }
1214 847 : break;
1215 :
1216 : case SID_ATTR_TABSTOP_VERTICAL :
1217 : case RES_PARATR_TABSTOP:
1218 : {
1219 3357 : if ( ISA( SwWebView ) ||
1220 2238 : IsTabColFromDoc() ||
1221 2238 : IsTabRowFromDoc() ||
1222 2238 : ( nSelType & nsSelectionType::SEL_GRF ) ||
1223 2238 : ( nSelType & nsSelectionType::SEL_FRM ) ||
1224 2238 : ( nSelType & nsSelectionType::SEL_OLE ) ||
1225 2238 : ( SfxItemState::DEFAULT > aCoreSet.GetItemState(RES_LR_SPACE) ) ||
1226 3934 : (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich) ) ||
1227 0 : ( bVerticalWriting && (RES_PARATR_TABSTOP == nWhich))
1228 : )
1229 577 : rSet.DisableItem( nWhich );
1230 : else
1231 : {
1232 : SvxTabStopItem aTabStops(static_cast<const SvxTabStopItem&>(
1233 542 : aCoreSet.Get( RES_PARATR_TABSTOP )));
1234 :
1235 : const SvxTabStopItem& rDefTabs = static_cast<const SvxTabStopItem&>(
1236 542 : rSh.GetDefault(RES_PARATR_TABSTOP));
1237 :
1238 : OSL_ENSURE(m_pHRuler, "why is there no ruler?");
1239 542 : const long nDefTabDist = ::GetTabDist(rDefTabs);
1240 542 : m_pHRuler->SetDefTabDist( nDefTabDist );
1241 542 : m_pVRuler->SetDefTabDist( nDefTabDist );
1242 542 : ::lcl_EraseDefTabs(aTabStops);
1243 542 : rSet.Put(aTabStops, nWhich);
1244 : }
1245 1119 : break;
1246 : }
1247 :
1248 : case SID_ATTR_PARA_LRSPACE_VERTICAL:
1249 : case SID_ATTR_PARA_LRSPACE:
1250 : {
1251 1166 : if ( nSelType & nsSelectionType::SEL_GRF ||
1252 1166 : nSelType & nsSelectionType::SEL_FRM ||
1253 1166 : nSelType & nsSelectionType::SEL_OLE ||
1254 583 : nFrmType == FrmTypeFlags::DRAWOBJ ||
1255 1166 : (!bVerticalWriting && (SID_ATTR_PARA_LRSPACE_VERTICAL == nWhich)) ||
1256 0 : ( bVerticalWriting && (SID_ATTR_PARA_LRSPACE == nWhich))
1257 : )
1258 : {
1259 583 : rSet.DisableItem(nWhich);
1260 : }
1261 : else
1262 : {
1263 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1264 0 : if ( !IsTabColFromDoc() )
1265 : {
1266 0 : aLR = static_cast<const SvxLRSpaceItem&>(aCoreSet.Get(RES_LR_SPACE));
1267 :
1268 : // #i23726#
1269 0 : if (m_pNumRuleNodeFromDoc)
1270 : {
1271 0 : short nOffset = static_cast< short >(aLR.GetTextLeft() +
1272 : // #i42922# Mouse move of numbering label
1273 : // has to consider the left indent of the paragraph
1274 0 : m_pNumRuleNodeFromDoc->GetLeftMarginWithNum( true ) );
1275 :
1276 : short nFLOffset;
1277 0 : m_pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset );
1278 :
1279 0 : aLR.SetLeft( nOffset + nFLOffset );
1280 : }
1281 : }
1282 0 : aLR.SetWhich(nWhich);
1283 0 : rSet.Put(aLR);
1284 : }
1285 583 : break;
1286 : }
1287 :
1288 : case SID_ATTR_PARA_ULSPACE:
1289 : case SID_PARASPACE_INCREASE:
1290 : case SID_PARASPACE_DECREASE:
1291 : {
1292 2875 : SvxULSpaceItem aUL = static_cast<const SvxULSpaceItem&>(aCoreSet.Get(RES_UL_SPACE));
1293 2875 : SfxItemState e = aCoreSet.GetItemState(RES_UL_SPACE);
1294 2875 : if( e >= SfxItemState::DEFAULT )
1295 : {
1296 2875 : if ( !aUL.GetUpper() && !aUL.GetLower() )
1297 2853 : rSet.DisableItem( SID_PARASPACE_DECREASE );
1298 22 : else if ( aUL.GetUpper() >= 5670 && aUL.GetLower() >= 5670 )
1299 0 : rSet.DisableItem( SID_PARASPACE_INCREASE );
1300 2875 : if ( nWhich == SID_ATTR_PARA_ULSPACE )
1301 : {
1302 509 : aUL.SetWhich( SID_ATTR_PARA_ULSPACE );
1303 509 : rSet.Put( aUL );
1304 : }
1305 : }
1306 : else
1307 : {
1308 0 : rSet.DisableItem( SID_PARASPACE_INCREASE );
1309 0 : rSet.DisableItem( SID_PARASPACE_DECREASE );
1310 0 : rSet.InvalidateItem( SID_ATTR_PARA_ULSPACE );
1311 2875 : }
1312 : }
1313 2875 : break;
1314 :
1315 : case SID_RULER_BORDER_DISTANCE:
1316 : {
1317 584 : m_nLeftBorderDistance = 0;
1318 584 : m_nRightBorderDistance = 0;
1319 1168 : if ( nSelType & nsSelectionType::SEL_GRF ||
1320 1168 : nSelType & nsSelectionType::SEL_FRM ||
1321 1168 : nSelType & nsSelectionType::SEL_OLE ||
1322 : nFrmType == FrmTypeFlags::DRAWOBJ )
1323 0 : rSet.DisableItem(SID_RULER_BORDER_DISTANCE);
1324 : else
1325 : {
1326 584 : SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE);
1327 584 : if(nFrmType & FrmTypeFlags::FLY_ANY)
1328 : {
1329 0 : if( IsTabColFromDoc() )
1330 : {
1331 0 : const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, pPt );
1332 0 : aDistLR.SetLeft(rFlyPrtRect.Left());
1333 0 : aDistLR.SetRight(rFlyPrtRect.Left());
1334 : }
1335 : else
1336 : {
1337 0 : SfxItemSet aCoreSet2( GetPool(),
1338 : RES_BOX, RES_BOX,
1339 0 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1340 0 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1341 0 : aCoreSet.Put( aBoxInfo );
1342 0 : rSh.GetFlyFrmAttr( aCoreSet );
1343 0 : const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(aCoreSet.Get(RES_BOX));
1344 0 : aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
1345 0 : aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
1346 :
1347 : //add the paragraph border distance
1348 0 : SfxItemSet aCoreSet1( GetPool(),
1349 : RES_BOX, RES_BOX,
1350 0 : 0 );
1351 0 : rSh.GetCurAttr( aCoreSet1 );
1352 0 : const SvxBoxItem& rParaBox = static_cast<const SvxBoxItem&>(aCoreSet1.Get(RES_BOX));
1353 0 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
1354 0 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
1355 : }
1356 0 : rSet.Put(aDistLR);
1357 0 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1358 0 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1359 : }
1360 2336 : else if ( IsTabColFromDoc() ||
1361 593 : ( rSh.GetTableFormat() && !bFrmSelection &&
1362 593 : !(nFrmType & FrmTypeFlags::COLSECT ) ) )
1363 : {
1364 3 : SfxItemSet aCoreSet2( GetPool(),
1365 : RES_BOX, RES_BOX,
1366 3 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1367 6 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1368 3 : aBoxInfo.SetTable(false);
1369 3 : aBoxInfo.SetDist(true);
1370 3 : aCoreSet2.Put(aBoxInfo);
1371 3 : rSh.GetTabBorders( aCoreSet2 );
1372 3 : const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(aCoreSet2.Get(RES_BOX));
1373 3 : aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
1374 3 : aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
1375 :
1376 : //add the border distance of the paragraph
1377 6 : SfxItemSet aCoreSet1( GetPool(), RES_BOX, RES_BOX );
1378 3 : rSh.GetCurAttr( aCoreSet1 );
1379 3 : const SvxBoxItem& rParaBox = static_cast<const SvxBoxItem&>(aCoreSet1.Get(RES_BOX));
1380 3 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
1381 3 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
1382 3 : rSet.Put(aDistLR);
1383 3 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1384 6 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1385 : }
1386 581 : else if ( !rSh.IsDirectlyInSection() )
1387 : {
1388 : //get the page/header/footer border distance
1389 578 : const SwFrameFormat& rMaster = rDesc.GetMaster();
1390 578 : const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(rMaster.GetAttrSet().Get(RES_BOX));
1391 578 : aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
1392 578 : aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
1393 :
1394 578 : const SvxBoxItem* pBox = 0;
1395 578 : if(nFrmType & FrmTypeFlags::HEADER)
1396 : {
1397 0 : rMaster.GetHeader();
1398 0 : const SwFormatHeader& rHeaderFormat = rMaster.GetHeader();
1399 0 : SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());
1400 0 : if( pHeaderFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
1401 0 : pBox = & (const SvxBoxItem&)pHeaderFormat->GetBox();
1402 : }
1403 578 : else if(nFrmType & FrmTypeFlags::FOOTER )
1404 : {
1405 0 : const SwFormatFooter& rFooterFormat = rMaster.GetFooter();
1406 0 : SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());
1407 0 : if( pFooterFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
1408 0 : pBox = & (const SvxBoxItem&)pFooterFormat->GetBox();
1409 : }
1410 578 : if(pBox)
1411 : {
1412 0 : aDistLR.SetLeft(pBox->GetDistance(SvxBoxItemLine::LEFT));
1413 0 : aDistLR.SetRight(pBox->GetDistance(SvxBoxItemLine::RIGHT));
1414 : }
1415 :
1416 : //add the border distance of the paragraph
1417 578 : SfxItemSet aCoreSetTmp( GetPool(),
1418 : RES_BOX, RES_BOX,
1419 578 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1420 578 : rSh.GetCurAttr( aCoreSetTmp );
1421 578 : const SvxBoxItem& rParaBox = static_cast<const SvxBoxItem&>(aCoreSetTmp.Get(RES_BOX));
1422 578 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
1423 578 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
1424 578 : rSet.Put(aDistLR);
1425 578 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1426 578 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1427 584 : }
1428 : }
1429 : }
1430 584 : break;
1431 :
1432 : case SID_RULER_TEXT_RIGHT_TO_LEFT:
1433 : {
1434 1168 : if ( nSelType & nsSelectionType::SEL_GRF ||
1435 1168 : nSelType & nsSelectionType::SEL_FRM ||
1436 1168 : nSelType & nsSelectionType::SEL_OLE ||
1437 : nFrmType == FrmTypeFlags::DRAWOBJ)
1438 0 : rSet.DisableItem(nWhich);
1439 : else
1440 : {
1441 584 : bool bFlag = rSh.IsInRightToLeftText();
1442 584 : rSet.Put(SfxBoolItem(nWhich, bFlag));
1443 : }
1444 : }
1445 584 : break;
1446 :
1447 : case SID_RULER_BORDERS_VERTICAL:
1448 : case SID_RULER_BORDERS:
1449 : {
1450 1131 : bool bFrameHasVerticalColumns(false);
1451 : {
1452 : bool bFrameRTL;
1453 : bool bFrameVertL2R;
1454 1131 : bFrameHasVerticalColumns = rSh.IsFrmVertical(false, bFrameRTL, bFrameVertL2R) &&
1455 1131 : bFrmSelection;
1456 : }
1457 2268 : bool bHasTable = ( IsTabColFromDoc() ||
1458 1149 : ( rSh.GetTableFormat() && !bFrmSelection &&
1459 1143 : !(nFrmType & FrmTypeFlags::COLSECT ) ) );
1460 :
1461 1131 : bool bTableVertical = bHasTable && rSh.IsTableVertical();
1462 :
1463 1131 : if(((SID_RULER_BORDERS_VERTICAL == nWhich) &&
1464 583 : ((bHasTable && !bTableVertical) ||
1465 1160 : (!bVerticalWriting && !bFrmSelection && !bHasTable ) ||
1466 0 : ( bFrmSelection && !bFrameHasVerticalColumns))) ||
1467 548 : ((SID_RULER_BORDERS == nWhich) &&
1468 3 : ((bHasTable && bTableVertical) ||
1469 0 : (bVerticalWriting && !bFrmSelection&& !bHasTable) || bFrameHasVerticalColumns)))
1470 583 : rSet.DisableItem(nWhich);
1471 548 : else if ( bHasTable )
1472 : {
1473 3 : SwTabCols aTabCols;
1474 3 : size_t nNum = 0;
1475 3 : if ( ( m_bSetTabColFromDoc = IsTabColFromDoc() ) )
1476 : {
1477 0 : rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
1478 0 : nNum = rSh.GetCurMouseTabColNum( m_aTabColFromDocPos );
1479 : }
1480 : else
1481 : {
1482 3 : rSh.GetTabCols( aTabCols );
1483 3 : nNum = rSh.GetCurTabColNum();
1484 3 : if(rSh.IsTableRightToLeft())
1485 0 : nNum = aTabCols.Count() - nNum;
1486 : }
1487 :
1488 : OSL_ENSURE(nNum <= aTabCols.Count(), "TabCol not found");
1489 3 : const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
1490 : const int nRgt = (bTableVertical ? nPageHeight : nPageWidth) -
1491 3 : (aTabCols.GetLeftMin() + aTabCols.GetRight());
1492 :
1493 3 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1494 3 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1495 :
1496 6 : SvxColumnItem aColItem(nNum, nL, nR);
1497 :
1498 3 : long nStart = 0;
1499 3 : long nEnd = 0;
1500 :
1501 : //columns in right-to-left tables need to be mirrored
1502 : bool bIsTableRTL =
1503 3 : IsTabColFromDoc() ?
1504 0 : rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
1505 3 : : rSh.IsTableRightToLeft();
1506 3 : if(bIsTableRTL)
1507 : {
1508 0 : for ( size_t i = aTabCols.Count(); i; --i )
1509 : {
1510 0 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 );
1511 0 : nEnd = aTabCols.GetRight() - rEntry.nPos;
1512 : SvxColumnDescription aColDesc( nStart, nEnd,
1513 0 : aTabCols.GetRight() - rEntry.nMax,
1514 0 : aTabCols.GetRight() - rEntry.nMin,
1515 0 : !aTabCols.IsHidden(i - 1) );
1516 0 : aColItem.Append(aColDesc);
1517 0 : nStart = nEnd;
1518 : }
1519 : SvxColumnDescription aColDesc(nStart,
1520 0 : aTabCols.GetRight() - aTabCols.GetLeft(), true);
1521 0 : aColItem.Append(aColDesc);
1522 : }
1523 : else
1524 : {
1525 6 : for ( size_t i = 0; i < aTabCols.Count(); ++i )
1526 : {
1527 3 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
1528 3 : nEnd = rEntry.nPos - aTabCols.GetLeft();
1529 : SvxColumnDescription aColDesc( nStart, nEnd,
1530 6 : rEntry.nMin - aTabCols.GetLeft(), rEntry.nMax - aTabCols.GetLeft(),
1531 9 : !aTabCols.IsHidden(i) );
1532 3 : aColItem.Append(aColDesc);
1533 3 : nStart = nEnd;
1534 : }
1535 3 : SvxColumnDescription aColDesc(nStart, aTabCols.GetRight() - aTabCols.GetLeft(),
1536 3 : 0, 0, true);
1537 3 : aColItem.Append(aColDesc);
1538 : }
1539 6 : rSet.Put(aColItem, nWhich);
1540 : }
1541 545 : else if ( bFrmSelection || nFrmType & ( FrmTypeFlags::COLUMN | FrmTypeFlags::COLSECT ) )
1542 : {
1543 : // Out of frame or page?
1544 0 : sal_uInt16 nNum = 0;
1545 0 : if(bFrmSelection)
1546 : {
1547 0 : const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
1548 0 : if(pFormat)
1549 0 : nNum = pFormat->GetCol().GetNumCols();
1550 : }
1551 : else
1552 0 : nNum = rSh.GetCurColNum();
1553 :
1554 0 : if(
1555 : // For that matter FrmTypeFlags::COLSECT should not be included
1556 : // if the border is selected!
1557 0 : !bFrmSelection &&
1558 0 : nFrmType & FrmTypeFlags::COLSECT )
1559 : {
1560 0 : const SwSection *pSect = rSh.GetAnySection(false, pPt);
1561 : OSL_ENSURE( pSect, "Which section?");
1562 0 : if( pSect )
1563 : {
1564 0 : SwSectionFormat const *pFormat = pSect->GetFormat();
1565 0 : const SwFormatCol& rCol = pFormat->GetCol();
1566 0 : if(rSh.IsInRightToLeftText())
1567 0 : nNum = rCol.GetColumns().size() - nNum;
1568 : else
1569 0 : --nNum;
1570 0 : SvxColumnItem aColItem(nNum);
1571 0 : SwRect aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
1572 0 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);
1573 :
1574 0 : ::lcl_FillSvxColumn(rCol, bVerticalWriting ? aRect.Height() : aRect.Width(), aColItem, 0);
1575 :
1576 0 : if(bVerticalWriting)
1577 : {
1578 0 : aRect.Pos() += Point(aTmpRect.Left(), aTmpRect.Top());
1579 0 : aRect.Pos().Y() -= rPageRect.Top();
1580 0 : aColItem.SetLeft(aRect.Top());
1581 0 : aColItem.SetRight(nPageHeight - aRect.Bottom());
1582 : }
1583 : else
1584 : {
1585 0 : aRect.Pos() += aTmpRect.Pos();
1586 :
1587 : // make relative to page position:
1588 0 : aColItem.SetLeft ((sal_uInt16)( aRect.Left() - rPageRect.Left() ));
1589 0 : aColItem.SetRight((sal_uInt16)( rPageRect.Right() - aRect.Right()));
1590 : }
1591 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1592 :
1593 0 : rSet.Put(aColItem, nWhich);
1594 : }
1595 : }
1596 0 : else if( bFrmSelection || nFrmType & FrmTypeFlags::FLY_ANY )
1597 : {
1598 : // Columns in frame
1599 0 : if ( nNum )
1600 : {
1601 0 : const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat() ;
1602 :
1603 0 : const SwFormatCol& rCol = pFormat->GetCol();
1604 0 : if(rSh.IsInRightToLeftText())
1605 0 : nNum = rCol.GetColumns().size() - nNum;
1606 : else
1607 0 : nNum--;
1608 0 : SvxColumnItem aColItem(nNum);
1609 0 : const SwRect &rSizeRect = rSh.GetAnyCurRect(RECT_FLY_PRT_EMBEDDED, pPt);
1610 :
1611 0 : bool bUseVertical = bFrameHasVerticalColumns || (!bFrmSelection && bVerticalWriting);
1612 0 : const long lWidth = bUseVertical ? rSizeRect.Height() : rSizeRect.Width();
1613 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1614 0 : long nDist2 = ((bUseVertical ? rRect.Height() : rRect.Width()) - lWidth) /2;
1615 0 : ::lcl_FillSvxColumn(rCol, lWidth, aColItem, nDist2);
1616 :
1617 0 : SfxItemSet aFrameSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE);
1618 0 : rSh.GetFlyFrmAttr( aFrameSet );
1619 :
1620 0 : if(bUseVertical)
1621 : {
1622 0 : aColItem.SetLeft(rRect.Top()- rPageRect.Top());
1623 0 : aColItem.SetRight(nPageHeight + rPageRect.Top() - rRect.Bottom());
1624 : }
1625 : else
1626 : {
1627 0 : aColItem.SetLeft(rRect.Left() - rPageRect.Left());
1628 0 : aColItem.SetRight(rPageRect.Right() - rRect.Right());
1629 : }
1630 :
1631 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1632 :
1633 0 : rSet.Put(aColItem, nWhich);
1634 : }
1635 : else
1636 0 : rSet.DisableItem(nWhich);
1637 : }
1638 : else
1639 : { // Columns on the page
1640 0 : const SwFrameFormat& rMaster = rDesc.GetMaster();
1641 0 : SwFormatCol aCol(rMaster.GetCol());
1642 0 : if(rFrameDir.GetValue() == FRMDIR_HORI_RIGHT_TOP)
1643 0 : nNum = aCol.GetColumns().size() - nNum;
1644 : else
1645 0 : nNum--;
1646 :
1647 0 : SvxColumnItem aColItem(nNum);
1648 0 : const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT, pPt);
1649 0 : const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(rMaster.GetFormatAttr(RES_BOX));
1650 0 : long nDist = rBox.GetDistance();
1651 :
1652 : lcl_FillSvxColumn(
1653 : aCol,
1654 : bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
1655 0 : aColItem, nDist);
1656 :
1657 0 : if(bBrowse)
1658 : {
1659 0 : if (bVerticalWriting)
1660 : {
1661 0 : aColItem.SetLeft((sal_uInt16)rPagePrtRect.Top());
1662 0 : aColItem.SetRight(sal_uInt16(nPageHeight - rPagePrtRect.Bottom()));
1663 : }
1664 : else
1665 : {
1666 0 : aColItem.SetLeft((sal_uInt16)rPagePrtRect.Left());
1667 0 : aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right()));
1668 : }
1669 : }
1670 : else
1671 : {
1672 0 : if (bVerticalWriting)
1673 : {
1674 0 : SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1675 0 : aColItem.SetLeft (aUL.GetUpper());
1676 0 : aColItem.SetRight(aUL.GetLower());
1677 : }
1678 : else
1679 : {
1680 0 : aColItem.SetLeft (aPageLRSpace.GetLeft());
1681 0 : aColItem.SetRight(aPageLRSpace.GetRight());
1682 : }
1683 : }
1684 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1685 :
1686 0 : rSet.Put(aColItem, nWhich);
1687 : }
1688 : }
1689 : else
1690 545 : rSet.DisableItem(nWhich);
1691 1131 : break;
1692 : }
1693 :
1694 : case SID_RULER_ROWS :
1695 : case SID_RULER_ROWS_VERTICAL:
1696 : {
1697 1131 : bool bFrameHasVerticalColumns(false);
1698 : {
1699 : bool bFrameRTL;
1700 : bool bFrameVertL2R;
1701 1131 : bFrameHasVerticalColumns = rSh.IsFrmVertical(false, bFrameRTL, bFrameVertL2R) &&
1702 1131 : bFrmSelection;
1703 : }
1704 :
1705 1679 : if(((SID_RULER_ROWS == nWhich) &&
1706 1096 : ((!bVerticalWriting && !bFrmSelection) || (bFrmSelection && !bFrameHasVerticalColumns))) ||
1707 583 : ((SID_RULER_ROWS_VERTICAL == nWhich) &&
1708 0 : ((bVerticalWriting && !bFrmSelection) || bFrameHasVerticalColumns)))
1709 548 : rSet.DisableItem(nWhich);
1710 2332 : else if ( IsTabRowFromDoc() ||
1711 592 : ( rSh.GetTableFormat() && !bFrmSelection &&
1712 592 : !(nFrmType & FrmTypeFlags::COLSECT ) ) )
1713 : {
1714 3 : SwTabCols aTabCols;
1715 3 : if ( ( m_bSetTabRowFromDoc = IsTabRowFromDoc() ) )
1716 : {
1717 0 : rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
1718 : }
1719 : else
1720 : {
1721 3 : rSh.GetTabRows( aTabCols );
1722 : }
1723 :
1724 3 : const int nLft = aTabCols.GetLeftMin();
1725 : const int nRgt = (bVerticalWriting ? nPageWidth : nPageHeight) -
1726 3 : (aTabCols.GetLeftMin() + aTabCols.GetRight());
1727 :
1728 3 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1729 3 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1730 :
1731 6 : SvxColumnItem aColItem(0, nL, nR);
1732 :
1733 3 : long nStart = 0;
1734 3 : long nEnd = 0;
1735 :
1736 6 : for ( size_t i = 0; i < aTabCols.Count(); ++i )
1737 : {
1738 3 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
1739 3 : if(bVerticalWriting)
1740 : {
1741 0 : nEnd = aTabCols.GetRight() - rEntry.nPos;
1742 : SvxColumnDescription aColDesc( nStart, nEnd,
1743 0 : aTabCols.GetRight() - rEntry.nMax,
1744 0 : aTabCols.GetRight() - rEntry.nMin,
1745 0 : !aTabCols.IsHidden(i) );
1746 0 : aColItem.Append(aColDesc);
1747 : }
1748 : else
1749 : {
1750 3 : nEnd = rEntry.nPos - aTabCols.GetLeft();
1751 : SvxColumnDescription aColDesc( nStart, nEnd,
1752 3 : rEntry.nMin - aTabCols.GetLeft(),
1753 3 : rEntry.nMax - aTabCols.GetLeft(),
1754 9 : !aTabCols.IsHidden(i) );
1755 3 : aColItem.Append(aColDesc);
1756 : }
1757 3 : nStart = nEnd;
1758 : }
1759 3 : if(bVerticalWriting)
1760 0 : nEnd = aTabCols.GetRight();
1761 : else
1762 3 : nEnd = aTabCols.GetLeft();
1763 : // put a position protection when the last row cannot be moved
1764 : // due to a page break inside of a row
1765 3 : if(!aTabCols.IsLastRowAllowedToChange())
1766 0 : bPutContentProtection = true;
1767 :
1768 : SvxColumnDescription aColDesc( nStart, nEnd,
1769 : aTabCols.GetRight(),
1770 : aTabCols.GetRight(),
1771 3 : false );
1772 3 : aColItem.Append(aColDesc);
1773 :
1774 6 : rSet.Put(aColItem, nWhich);
1775 : }
1776 : else
1777 580 : rSet.DisableItem(nWhich);
1778 : }
1779 1131 : break;
1780 :
1781 : case SID_RULER_PAGE_POS:
1782 : {
1783 : SvxPagePosSizeItem aPagePosSize(
1784 586 : Point( rPageRect.Left(), rPageRect.Top()) , nPageWidth, nPageHeight);
1785 :
1786 586 : rSet.Put(aPagePosSize);
1787 586 : break;
1788 : }
1789 :
1790 : case SID_RULER_LR_MIN_MAX:
1791 : {
1792 586 : Rectangle aRectangle;
1793 1172 : if( ( nFrmType & FrmTypeFlags::COLSECT ) && !IsTabColFromDoc() &&
1794 586 : ( nFrmType & ( FrmTypeFlags::TABLE|FrmTypeFlags::COLUMN ) ) )
1795 : {
1796 0 : if( nFrmType & FrmTypeFlags::TABLE )
1797 : {
1798 0 : const size_t nNum = rSh.GetCurTabColNum();
1799 0 : SwTabCols aTabCols;
1800 0 : rSh.GetTabCols( aTabCols );
1801 :
1802 0 : const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
1803 0 : const int nRgt = nPageWidth -(aTabCols.GetLeftMin() + aTabCols.GetRight());
1804 :
1805 0 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1806 0 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1807 :
1808 0 : aRectangle.Left() = nL;
1809 0 : if(nNum > 1)
1810 0 : aRectangle.Left() += aTabCols[nNum - 2];
1811 0 : if(nNum)
1812 0 : aRectangle.Left() += MINLAY;
1813 0 : if(aTabCols.Count() <= nNum + 1 )
1814 0 : aRectangle.Right() = nR;
1815 : else
1816 0 : aRectangle.Right() = nPageWidth - (nL + aTabCols[nNum + 1]);
1817 :
1818 0 : if(nNum < aTabCols.Count())
1819 0 : aRectangle.Right() += MINLAY;
1820 : }
1821 : else
1822 : {
1823 0 : const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
1824 0 : const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
1825 0 : &rDesc.GetMaster().GetCol();
1826 0 : const SwColumns& rCols = pCols->GetColumns();
1827 0 : sal_uInt16 nNum = rSh.GetCurOutColNum();
1828 0 : const sal_uInt16 nCount = std::min(sal_uInt16(nNum + 1), sal_uInt16(rCols.size()));
1829 : const SwRect aRect( rSh.GetAnyCurRect( pFormat
1830 : ? RECT_FLY_PRT_EMBEDDED
1831 0 : : RECT_PAGE_PRT, pPt ));
1832 : const SwRect aAbsRect( rSh.GetAnyCurRect( pFormat
1833 : ? RECT_FLY_EMBEDDED
1834 0 : : RECT_PAGE, pPt ));
1835 :
1836 : // The width of the frame or within the page margins.
1837 0 : const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
1838 : // The entire frame width - The difference is twice the distance to the edge.
1839 0 : const sal_uInt16 nOuterWidth = (sal_uInt16)aAbsRect.Width();
1840 0 : int nWidth = 0,
1841 0 : nEnd = 0;
1842 0 : aRectangle.Left() = 0;
1843 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
1844 : {
1845 0 : const SwColumn* pCol = &rCols[i];
1846 0 : const int nStart = pCol->GetLeft() + nWidth;
1847 0 : if(i == nNum - 2)
1848 0 : aRectangle.Left() = nStart;
1849 0 : nWidth += pCols->CalcColWidth( i, nTotalWidth );
1850 0 : nEnd = nWidth - pCol->GetRight();
1851 : }
1852 0 : aRectangle.Right() = rPageRect.Right() - nEnd;
1853 0 : aRectangle.Left() -= rPageRect.Left();
1854 :
1855 0 : if(nNum > 1)
1856 : {
1857 0 : aRectangle.Left() += MINLAY;
1858 0 : aRectangle.Left() += aRect.Left();
1859 : }
1860 0 : if(pFormat) // Range in frame - here you may up to the edge
1861 0 : aRectangle.Left() = aRectangle.Right() = 0;
1862 : else
1863 : {
1864 : // Move the rectangle to the correct absolute position.
1865 0 : aRectangle.Left() += aAbsRect.Left();
1866 0 : aRectangle.Right() -= aAbsRect.Left();
1867 : // Include distance to the border.
1868 0 : aRectangle.Right() -= (nOuterWidth - nTotalWidth) / 2;
1869 : }
1870 :
1871 0 : if(nNum < rCols.size())
1872 : {
1873 0 : aRectangle.Right() += MINLAY;
1874 : }
1875 : else
1876 : // Right is only the margin now.
1877 0 : aRectangle.Right() = 0;
1878 :
1879 : }
1880 : }
1881 589 : else if ( ((nFrmType & FrmTypeFlags::TABLE) || IsTabColFromDoc()) &&
1882 3 : !bFrmSelection )
1883 : {
1884 : bool bColumn;
1885 3 : if ( IsTabColFromDoc() )
1886 0 : bColumn = rSh.GetCurMouseColNum( m_aTabColFromDocPos ) != 0;
1887 : else
1888 3 : bColumn = bool(nFrmType & (FrmTypeFlags::COLUMN|FrmTypeFlags::FLY_ANY|FrmTypeFlags::COLSECTOUTTAB));
1889 :
1890 3 : if ( !bColumn )
1891 : {
1892 3 : if( nFrmType & FrmTypeFlags::FLY_ANY && IsTabColFromDoc() )
1893 : {
1894 : SwRect aRect( rSh.GetAnyCurRect(
1895 0 : RECT_FLY_PRT_EMBEDDED, pPt ) );
1896 0 : aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
1897 0 : pPt ).Pos();
1898 :
1899 0 : aRectangle.Left() = aRect.Left() - rPageRect.Left();
1900 0 : aRectangle.Right() = rPageRect.Right() - aRect.Right();
1901 : }
1902 3 : else if( bBrowse )
1903 : {
1904 0 : aRectangle.Left() = rPagePrtRect.Left();
1905 0 : aRectangle.Right() = nPageWidth - rPagePrtRect.Right();
1906 : }
1907 : else
1908 : {
1909 3 : aRectangle.Left() = aPageLRSpace.GetLeft();
1910 3 : aRectangle.Right() = aPageLRSpace.GetRight();
1911 : }
1912 : }
1913 : else
1914 : { // Here only for table in multi-column pages and borders.
1915 0 : bool bSectOutTable = bool(nFrmType & FrmTypeFlags::TABLE);
1916 0 : bool bFrame = bool(nFrmType & FrmTypeFlags::FLY_ANY);
1917 0 : bool bColSct = bool(nFrmType & ( bSectOutTable
1918 : ? FrmTypeFlags::COLSECTOUTTAB
1919 0 : : FrmTypeFlags::COLSECT )
1920 0 : );
1921 : //So you can also drag with the mouse, without being in the table.
1922 0 : CurRectType eRecType = RECT_PAGE_PRT;
1923 0 : size_t nNum = IsTabColFromDoc() ?
1924 0 : rSh.GetCurMouseColNum( m_aTabColFromDocPos ):
1925 0 : rSh.GetCurOutColNum();
1926 0 : const SwFrameFormat* pFormat = NULL;
1927 0 : if( bColSct )
1928 : {
1929 : eRecType = bSectOutTable ? RECT_OUTTABSECTION
1930 0 : : RECT_SECTION;
1931 0 : const SwSection *pSect = rSh.GetAnySection( bSectOutTable, pPt );
1932 : OSL_ENSURE( pSect, "Which section?");
1933 0 : pFormat = pSect->GetFormat();
1934 : }
1935 0 : else if( bFrame )
1936 : {
1937 0 : pFormat = rSh.GetFlyFrameFormat();
1938 0 : eRecType = RECT_FLY_PRT_EMBEDDED;
1939 : }
1940 :
1941 0 : const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
1942 0 : &rDesc.GetMaster().GetCol();
1943 0 : const SwColumns& rCols = pCols->GetColumns();
1944 0 : const sal_uInt16 nBorder = pFormat ? pFormat->GetBox().GetDistance() :
1945 0 : rDesc.GetMaster().GetBox().GetDistance();
1946 :
1947 : // RECT_FLY_PRT_EMBEDDED returns the relative position to RECT_FLY_EMBEDDED
1948 : // the absolute position must be added here
1949 :
1950 0 : SwRect aRect( rSh.GetAnyCurRect( eRecType, pPt ) );
1951 0 : if(RECT_FLY_PRT_EMBEDDED == eRecType)
1952 0 : aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
1953 0 : pPt ).Pos();
1954 :
1955 0 : const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
1956 : // Initialize nStart and nEnd initialisieren for nNum == 0
1957 0 : int nWidth = 0,
1958 0 : nStart = 0,
1959 0 : nEnd = nTotalWidth;
1960 :
1961 0 : if( nNum > rCols.size() )
1962 : {
1963 : OSL_ENSURE( false, "wrong FormatCol is being edited!" );
1964 0 : nNum = rCols.size();
1965 : }
1966 :
1967 0 : for( size_t i = 0; i < nNum; ++i )
1968 : {
1969 0 : const SwColumn* pCol = &rCols[i];
1970 0 : nStart = pCol->GetLeft() + nWidth;
1971 0 : nWidth += pCols->CalcColWidth( static_cast<sal_uInt16>(i), nTotalWidth );
1972 0 : nEnd = nWidth - pCol->GetRight();
1973 : }
1974 0 : if( bFrame || bColSct )
1975 : {
1976 0 : aRectangle.Left() = aRect.Left() - rPageRect.Left() + nStart;
1977 0 : aRectangle.Right() = nPageWidth - aRectangle.Left() - nEnd + nStart;
1978 : }
1979 0 : else if(!bBrowse)
1980 : {
1981 0 : aRectangle.Left() = aPageLRSpace.GetLeft() + nStart;
1982 0 : aRectangle.Right() = nPageWidth - nEnd - aPageLRSpace.GetLeft();
1983 : }
1984 : else
1985 : {
1986 0 : long nLeft = rPagePrtRect.Left();
1987 0 : aRectangle.Left() = nStart + nLeft;
1988 0 : aRectangle.Right() = nPageWidth - nEnd - nLeft;
1989 : }
1990 0 : if(!bFrame)
1991 : {
1992 0 : aRectangle.Left() += nBorder;
1993 0 : aRectangle.Right() -= nBorder;
1994 : }
1995 : }
1996 : }
1997 583 : else if ( nFrmType & ( FrmTypeFlags::HEADER | FrmTypeFlags::FOOTER ))
1998 : {
1999 0 : aRectangle.Left() = aPageLRSpace.GetLeft();
2000 0 : aRectangle.Right() = aPageLRSpace.GetRight();
2001 : }
2002 : else
2003 583 : aRectangle.Left() = aRectangle.Right() = 0;
2004 :
2005 586 : SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle);
2006 586 : rSet.Put(aLR);
2007 : }
2008 586 : break;
2009 :
2010 : case SID_RULER_PROTECT:
2011 : {
2012 580 : if(bFrmSelection)
2013 : {
2014 0 : FlyProtectFlags nProtect = m_pWrtShell->IsSelObjProtected( FlyProtectFlags::Size|FlyProtectFlags::Pos|FlyProtectFlags::Content );
2015 :
2016 0 : SvxProtectItem aProt(SID_RULER_PROTECT);
2017 0 : aProt.SetContentProtect(bool(nProtect & FlyProtectFlags::Content));
2018 0 : aProt.SetSizeProtect (bool(nProtect & FlyProtectFlags::Size));
2019 0 : aProt.SetPosProtect (bool(nProtect & FlyProtectFlags::Pos));
2020 0 : rSet.Put(aProt);
2021 : }
2022 : else
2023 : {
2024 580 : SvxProtectItem aProtect(SID_RULER_PROTECT);
2025 580 : if(bBrowse && !(nFrmType & (FrmTypeFlags::DRAWOBJ|FrmTypeFlags::COLUMN)) && !rSh.GetTableFormat())
2026 : {
2027 1 : aProtect.SetSizeProtect(true);
2028 1 : aProtect.SetPosProtect(true);
2029 : }
2030 580 : rSet.Put(aProtect);
2031 : }
2032 : }
2033 580 : break;
2034 : }
2035 13094 : nWhich = aIter.NextWhich();
2036 : }
2037 2609 : if(bPutContentProtection)
2038 : {
2039 0 : SvxProtectItem aProtect(SID_RULER_PROTECT);
2040 0 : aProtect.SetContentProtect(true);
2041 0 : rSet.Put(aProtect);
2042 2609 : }
2043 2786 : }
2044 :
2045 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
