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 SwFmtCol& 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 : SwFmtCol& 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 195 : static void lcl_EraseDefTabs(SvxTabStopItem& rTabStops)
145 : {
146 : // Delete DefTabs
147 585 : for ( sal_uInt16 i = 0; i < rTabStops.Count(); )
148 : {
149 : // Here also throw out the DefTab to zero
150 195 : if ( SVX_TAB_ADJUST_DEFAULT == rTabStops[i].GetAdjustment() ||
151 0 : rTabStops[i].GetTabPos() == 0 )
152 : {
153 195 : rTabStops.Remove(i);
154 195 : continue;
155 : }
156 0 : ++i;
157 : }
158 195 : }
159 :
160 : // Flip page margin
161 1687 : void SwView::SwapPageMargin(const SwPageDesc& rDesc, SvxLRSpaceItem& rLRSpace)
162 : {
163 : sal_uInt16 nPhyPage, nVirPage;
164 1687 : GetWrtShell().GetPageNum( nPhyPage, nVirPage );
165 :
166 1687 : 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 1687 : }
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(SwFmtCol& 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 sal_uInt16 nFrmType = rSh.IsObjSelected() ?
227 : FRMTYPE_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 sal_uInt16 nDescId = rSh.GetCurPageDesc();
235 0 : const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId );
236 :
237 0 : const bool bVerticalWriting = rSh.IsInVerticalText();
238 0 : const SwFmtHeader& rHeaderFmt = rDesc.GetMaster().GetHeader();
239 0 : SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt();
240 :
241 0 : const SwFmtFooter& rFooterFmt = rDesc.GetMaster().GetFooter();
242 0 : SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt();
243 :
244 0 : const SwFmtFrmSize &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 = 0 != (nFrmType & FRMTYPE_COLSECT);
253 :
254 0 : switch (nSlot)
255 : {
256 : case SID_ATTR_LONG_LRSPACE:
257 0 : if ( pReqArgs )
258 : {
259 : SvxLongLRSpaceItem aLongLR( (const SvxLongLRSpaceItem&)pReqArgs->
260 0 : Get( SID_ATTR_LONG_LRSPACE ) );
261 0 : SvxLRSpaceItem aLR(RES_LR_SPACE);
262 0 : if ( !bSect && (bFrmSelection || nFrmType & FRMTYPE_FLY_ANY) )
263 : {
264 0 : SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt());
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 : SwFmtVertOrient aVertOrient(pFmt->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 : SwFmtHoriOrient aHoriOrient( pFmt->GetHoriOrient() );
293 0 : aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
294 0 : aHoriOrient.SetPos( aHoriOrient.GetPos() + nDeltaX );
295 0 : aSet.Put( aHoriOrient );
296 : }
297 :
298 0 : SwFmtFrmSize aSize( pFmt->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 & FRMTYPE_COLUMN )
313 : {
314 0 : SwFmtCol aCol(pFmt->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 & ( FRMTYPE_HEADER | FRMTYPE_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 & FRMTYPE_HEADER && pHeaderFmt )
346 0 : pHeaderFmt->SetFmtAttr( aLR );
347 0 : else if( nFrmType & FRMTYPE_FOOTER && pFooterFmt )
348 0 : pFooterFmt->SetFmtAttr( aLR );
349 : }
350 0 : else if( nFrmType == FRMTYPE_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 SwSectionFmt* pSectFmt = pCurrSect->GetFmt();
369 0 : SvxLRSpaceItem aLRTmp = pSectFmt->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 : SwFmtCol aCols( pSectFmt->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.GetSectionFmtPos(*pSectFmt), 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().SetFmtAttr( 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().SetFmtAttr( 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( (const SvxLongULSpaceItem&)pReqArgs->
419 0 : Get( SID_ATTR_LONG_ULSPACE ));
420 :
421 0 : if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
422 : {
423 0 : SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt());
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 : SwFmtHoriOrient aHoriOrient(pFmt->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 : SwFmtVertOrient aVertOrient(pFmt->GetVertOrient());
445 0 : aVertOrient.SetVertOrient(text::VertOrientation::NONE);
446 0 : aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY );
447 0 : aSet.Put( aVertOrient );
448 : }
449 0 : SwFmtFrmSize aSize(pFmt->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 == FRMTYPE_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 SwSectionFmt* pSectFmt = pCurrSect->GetFmt();
482 0 : SvxLRSpaceItem aLR = pSectFmt->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 : SwFmtCol aCols( pSectFmt->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.GetSectionFmtPos(*pSectFmt), aData, &aSet);
497 : }
498 : else
499 0 : { SwPageDesc aDesc( rDesc );
500 :
501 0 : if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER ))
502 : {
503 :
504 0 : const bool bHead = nFrmType & FRMTYPE_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().SetFmtAttr( aUL );
511 :
512 0 : if( (bHead && pHeaderFmt) || (!bHead && pFooterFmt) )
513 : {
514 0 : SwFmtFrmSize aSz( bHead ? pHeaderFmt->GetFrmSize() :
515 0 : pFooterFmt->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 : pHeaderFmt->SetFmtAttr( aSz );
521 : else
522 0 : pFooterFmt->SetFmtAttr( 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().SetFmtAttr(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().SetFmtAttr(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( (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 : SwFmtCol 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().SetFmtAttr( 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( (const SvxTabStopItem&)pReqArgs->
621 0 : Get( nWhich ));
622 0 : aTabStops.SetWhich(RES_PARATR_TABSTOP);
623 : const SvxTabStopItem& rDefTabs =
624 0 : (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 = (const SvxLRSpaceItem&)aSet.Get(RES_LR_SPACE);
630 :
631 0 : if ( rLR.GetTxtFirstLineOfst() < 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 : SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
641 0 : if( pColl && pColl->IsAutoUpdateFmt() )
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((const SvxLRSpaceItem&)pReqArgs->Get(nSlot));
657 :
658 0 : aParaMargin.SetRight( aParaMargin.GetRight() - m_nRightBorderDistance );
659 0 : aParaMargin.SetTxtLeft(aParaMargin.GetTxtLeft() - m_nLeftBorderDistance );
660 :
661 0 : aParaMargin.SetWhich( RES_LR_SPACE );
662 0 : SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
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.GetTxtLeft() - rLR.GetTxtLeft()), 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->IsAutoUpdateFmt() )
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.GetTxtFirstLineOfst() < 0 )
691 : {
692 0 : SfxItemSet aSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP );
693 :
694 0 : rSh.GetCurAttr( aSet );
695 0 : const SvxTabStopItem& rTabStops = (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 : (const SvxTabStopItem&)rSh.GetDefault(RES_PARATR_TABSTOP);
717 0 : ::MakeDefTabs( ::GetTabDist(rDefTabs), aTabStops );
718 :
719 0 : if( pColl && pColl->IsAutoUpdateFmt())
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((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 : SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
744 0 : if( pColl && pColl->IsAutoUpdateFmt() )
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 :
755 : case SID_RULER_BORDERS_VERTICAL:
756 : case SID_RULER_BORDERS:
757 0 : if ( pReqArgs )
758 : {
759 0 : SvxColumnItem aColItem((const SvxColumnItem&)pReqArgs->Get(nSlot));
760 :
761 0 : if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) )
762 : {
763 : OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
764 :
765 : const bool bSingleLine = ((const SfxBoolItem&)rReq.
766 0 : GetArgs()->Get(SID_RULER_ACT_LINE_ONLY)).GetValue();
767 :
768 0 : SwTabCols aTabCols;
769 0 : if ( m_bSetTabColFromDoc )
770 0 : rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
771 : else
772 0 : rSh.GetTabCols(aTabCols);
773 :
774 : // left table border
775 0 : long nBorder = (long)(aColItem.GetLeft() - aTabCols.GetLeftMin());
776 0 : aTabCols.SetLeft( nBorder );
777 :
778 0 : nBorder = (bVerticalWriting ? nPageHeight : nPageWidth) - aTabCols.GetLeftMin() - aColItem.GetRight();
779 :
780 0 : if ( aColItem.GetRight() > 0 )
781 0 : aTabCols.SetRight( nBorder );
782 :
783 : // Tabcols sequentially
784 : // The last column is defined by the edge.
785 : // Columns in right-to-left tables need to be mirrored
786 : bool bIsTableRTL =
787 0 : IsTabColFromDoc() ?
788 0 : rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
789 0 : : rSh.IsTableRightToLeft();
790 0 : const size_t nColCount = aColItem.Count() - 1;
791 0 : if(bIsTableRTL)
792 : {
793 0 : for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
794 : {
795 0 : const SvxColumnDescription& rCol = aColItem[nColCount - i];
796 0 : aTabCols[i] = aTabCols.GetRight() - rCol.nStart;
797 0 : aTabCols.SetHidden( i, !rCol.bVisible );
798 : }
799 : }
800 : else
801 : {
802 0 : for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
803 : {
804 0 : const SvxColumnDescription& rCol = aColItem[i];
805 0 : aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
806 0 : aTabCols.SetHidden( i, !rCol.bVisible );
807 : }
808 : }
809 :
810 0 : if ( m_bSetTabColFromDoc )
811 : {
812 0 : if( !rSh.IsViewLocked() )
813 : {
814 0 : bUnlockView = true;
815 0 : rSh.LockView( true );
816 : }
817 : rSh.SetMouseTabCols( aTabCols, bSingleLine,
818 0 : m_aTabColFromDocPos );
819 : }
820 : else
821 0 : rSh.SetTabCols(aTabCols, bSingleLine);
822 :
823 : }
824 : else
825 : {
826 0 : if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY || bSect)
827 : {
828 0 : SwSectionFmt *pSectFmt = 0;
829 0 : SfxItemSet aSet( GetPool(), RES_COL, RES_COL );
830 0 : if(bSect)
831 : {
832 0 : const SwSection *pSect = rSh.GetAnySection();
833 : OSL_ENSURE( pSect, "Which section?");
834 0 : pSectFmt = pSect->GetFmt();
835 : }
836 : else
837 : {
838 0 : rSh.GetFlyFrmAttr( aSet );
839 : }
840 : SwFmtCol aCols(
841 : bSect ?
842 0 : pSectFmt->GetCol() :
843 0 : (const SwFmtCol&)aSet.Get( RES_COL, false ));
844 0 : SwRect aCurRect = rSh.GetAnyCurRect(bSect ? RECT_SECTION_PRT : RECT_FLY_PRT_EMBEDDED);
845 0 : const long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width();
846 0 : ::lcl_ConvertToCols( aColItem, lWidth, aCols );
847 0 : aSet.Put( aCols );
848 0 : if(bSect)
849 0 : rSh.SetSectionAttr( aSet, pSectFmt );
850 : else
851 : {
852 0 : rSh.StartAction();
853 0 : rSh.Push();
854 0 : rSh.SetFlyFrmAttr( aSet );
855 : // Cancel the frame selection again
856 0 : if(!bFrmSelection && rSh.IsFrmSelected())
857 : {
858 0 : rSh.UnSelectFrm();
859 0 : rSh.LeaveSelFrmMode();
860 : }
861 0 : rSh.Pop();
862 0 : rSh.EndAction();
863 0 : }
864 : }
865 : else
866 : {
867 0 : SwFmtCol aCols( rDesc.GetMaster().GetCol() );
868 0 : const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT);
869 : ::lcl_ConvertToCols( aColItem,
870 : bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
871 0 : aCols );
872 0 : SwPageDesc aDesc( rDesc );
873 0 : aDesc.GetMaster().SetFmtAttr( aCols );
874 0 : rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
875 : }
876 0 : }
877 : }
878 0 : break;
879 :
880 : case SID_RULER_ROWS :
881 : case SID_RULER_ROWS_VERTICAL:
882 0 : if (pReqArgs)
883 : {
884 0 : SvxColumnItem aColItem((const SvxColumnItem&)pReqArgs->Get(nSlot));
885 :
886 0 : if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) )
887 : {
888 : OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
889 :
890 0 : SwTabCols aTabCols;
891 0 : if ( m_bSetTabRowFromDoc )
892 0 : rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
893 : else
894 0 : rSh.GetTabRows(aTabCols);
895 :
896 0 : if ( bVerticalWriting )
897 : {
898 0 : aTabCols.SetRight(nPageWidth - aColItem.GetRight() - aColItem.GetLeft());
899 0 : aTabCols.SetLeftMin(aColItem.GetLeft());
900 : }
901 : else
902 : {
903 0 : long nBorder = nPageHeight - aTabCols.GetLeftMin() - aColItem.GetRight();
904 0 : aTabCols.SetRight( nBorder );
905 : }
906 :
907 0 : const size_t nColItems = aColItem.Count() - 1;
908 0 : if(bVerticalWriting)
909 : {
910 0 : for ( size_t i = nColItems; i; --i )
911 : {
912 0 : const SvxColumnDescription& rCol = aColItem[i - 1];
913 0 : long nColumnPos = aTabCols.GetRight() - rCol.nEnd ;
914 0 : aTabCols[i - 1] = nColumnPos;
915 0 : aTabCols.SetHidden( i - 1, !rCol.bVisible );
916 : }
917 : }
918 : else
919 : {
920 0 : for ( size_t i = 0; i < nColItems; ++i )
921 : {
922 0 : const SvxColumnDescription& rCol = aColItem[i];
923 0 : aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
924 0 : aTabCols.SetHidden( i, !rCol.bVisible );
925 : }
926 : }
927 0 : bool bSingleLine = false;
928 : const SfxPoolItem* pSingleLine;
929 0 : if( SfxItemState::SET == rReq.GetArgs()->GetItemState(SID_RULER_ACT_LINE_ONLY, false, &pSingleLine))
930 0 : bSingleLine = ((const SfxBoolItem*)pSingleLine)->GetValue();
931 0 : if ( m_bSetTabRowFromDoc )
932 : {
933 0 : if( !rSh.IsViewLocked() )
934 : {
935 0 : bUnlockView = true;
936 0 : rSh.LockView( true );
937 : }
938 0 : rSh.SetMouseTabRows( aTabCols, bSingleLine, m_aTabColFromDocPos );
939 : }
940 : else
941 0 : rSh.SetTabRows(aTabCols, bSingleLine);
942 0 : }
943 : }
944 0 : break;
945 :
946 : default:
947 : OSL_ENSURE( false, "wrong SlotId");
948 : }
949 0 : rSh.EndAllAction();
950 :
951 0 : if( bUnlockView )
952 0 : rSh.LockView( false );
953 :
954 0 : m_bSetTabColFromDoc = m_bSetTabRowFromDoc = m_bTabColFromDoc = m_bTabRowFromDoc = false;
955 0 : SetNumRuleNodeFromDoc(NULL);
956 0 : }
957 :
958 : // Here the status of the tab bar will be determined.
959 : // This means that all relevant attributes at the CursorPos
960 : // will be submittet to the tab bar.
961 1687 : void SwView::StateTabWin(SfxItemSet& rSet)
962 : {
963 1687 : SwWrtShell &rSh = GetWrtShell();
964 :
965 1687 : const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &m_aTabColFromDocPos : 0;
966 1687 : const sal_uInt16 nFrmType = rSh.IsObjSelected()
967 : ? FRMTYPE_DRAWOBJ
968 1687 : : rSh.GetFrmType( pPt, true );
969 :
970 1687 : const bool bFrmSelection = rSh.IsFrmSelected();
971 1687 : const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
972 : // PageOffset/limiter
973 1687 : const SwRect& rPageRect = rSh.GetAnyCurRect( RECT_PAGE, pPt );
974 1687 : const SwRect& rPagePrtRect = rSh.GetAnyCurRect( RECT_PAGE_PRT, pPt );
975 1687 : const long nPageWidth = rPageRect.Width();
976 1687 : const long nPageHeight = rPageRect.Height();
977 :
978 : const SwPageDesc& rDesc = rSh.GetPageDesc(
979 3374 : IsTabColFromDoc() || m_bTabRowFromDoc ?
980 1687 : rSh.GetMousePageDesc(m_aTabColFromDocPos) : rSh.GetCurPageDesc() );
981 :
982 1687 : const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrmDir();
983 1687 : const bool bVerticalWriting = rSh.IsInVerticalText();
984 :
985 : //enable tab stop display on the rulers depending on the writing direction
986 1687 : WinBits nRulerStyle = m_pHRuler->GetStyle() & ~WB_EXTRAFIELD;
987 1687 : m_pHRuler->SetStyle(bVerticalWriting||bBrowse ? nRulerStyle : nRulerStyle|WB_EXTRAFIELD);
988 1687 : nRulerStyle = m_pVRuler->GetStyle() & ~WB_EXTRAFIELD;
989 1687 : m_pVRuler->SetStyle(bVerticalWriting ? nRulerStyle|WB_EXTRAFIELD : nRulerStyle);
990 :
991 : //#i24363# tab stops relative to indent
992 1687 : bool bRelative = rSh.getIDocumentSettingAccess()->get(IDocumentSettingAccess::TABS_RELATIVE_TO_INDENT);
993 1687 : m_pHRuler->SetTabsRelativeToIndent( bRelative );
994 1687 : m_pVRuler->SetTabsRelativeToIndent( bRelative );
995 :
996 1687 : SvxLRSpaceItem aPageLRSpace( rDesc.GetMaster().GetLRSpace() );
997 1687 : SwapPageMargin( rDesc, aPageLRSpace );
998 :
999 1687 : SfxItemSet aCoreSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP,
1000 3374 : RES_LR_SPACE, RES_UL_SPACE, 0 );
1001 : // get also the list level indent values merged as LR-SPACE item, if needed.
1002 1687 : rSh.GetCurAttr( aCoreSet, true );
1003 1687 : const SelectionType nSelType = rSh.GetSelectionType();
1004 :
1005 3374 : SfxWhichIter aIter( rSet );
1006 1687 : sal_uInt16 nWhich = aIter.FirstWhich();
1007 1687 : bool bPutContentProtection = false;
1008 :
1009 8436 : while ( nWhich )
1010 : {
1011 5062 : switch ( nWhich )
1012 : {
1013 :
1014 : case SID_ATTR_PAGE_COLUMN:
1015 : {
1016 194 : sal_uInt16 nColumnType = 0;
1017 :
1018 194 : const SwFrmFmt& rMaster = rDesc.GetMaster();
1019 194 : SwFmtCol aCol(rMaster.GetCol());
1020 194 : const sal_uInt16 nCols = aCol.GetNumCols();
1021 194 : if ( nCols == 0 )
1022 : {
1023 194 : nColumnType = 1;
1024 : }
1025 0 : else if ( nCols == 2 )
1026 : {
1027 0 : const sal_uInt16 nColLeft = aCol.CalcPrtColWidth(0, aCol.GetWishWidth());
1028 0 : const sal_uInt16 nColRight = aCol.CalcPrtColWidth(1, aCol.GetWishWidth());
1029 :
1030 0 : if ( abs(nColLeft - nColRight) <= 10 )
1031 : {
1032 0 : nColumnType = 2;
1033 : }
1034 0 : else if( abs(nColLeft - nColRight*2) < 20 )
1035 : {
1036 0 : nColumnType = 4;
1037 : }
1038 0 : else if( abs(nColLeft*2 - nColRight) < 20 )
1039 : {
1040 0 : nColumnType = 5;
1041 : }
1042 : }
1043 0 : else if( nCols == 3 )
1044 : {
1045 0 : nColumnType = 3;
1046 : }
1047 :
1048 194 : rSet.Put( SfxInt16Item( SID_ATTR_PAGE_COLUMN, nColumnType ) );
1049 : }
1050 194 : break;
1051 :
1052 : case SID_ATTR_LONG_LRSPACE:
1053 : {
1054 : SvxLongLRSpaceItem aLongLR( (long)aPageLRSpace.GetLeft(),
1055 : (long)aPageLRSpace.GetRight(),
1056 201 : SID_ATTR_LONG_LRSPACE);
1057 201 : if(bBrowse)
1058 : {
1059 0 : aLongLR.SetLeft(rPagePrtRect.Left());
1060 0 : aLongLR.SetRight(nPageWidth - rPagePrtRect.Right());
1061 : }
1062 201 : if ( ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER ) &&
1063 0 : !(nFrmType & FRMTYPE_COLSECT) )
1064 : {
1065 0 : SwFrmFmt *pFmt = (SwFrmFmt*) (nFrmType & FRMTYPE_HEADER ?
1066 0 : rDesc.GetMaster().GetHeader().GetHeaderFmt() :
1067 0 : rDesc.GetMaster().GetFooter().GetFooterFmt());
1068 0 : if( pFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
1069 : {
1070 0 : SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
1071 0 : aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
1072 0 : const SvxLRSpaceItem& aLR = pFmt->GetLRSpace();
1073 0 : aLongLR.SetLeft ( (long)aLR.GetLeft() + (long)aRect.Left() );
1074 0 : aLongLR.SetRight( (nPageWidth -
1075 0 : (long)aRect.Right() + (long)aLR.GetRight()));
1076 0 : }
1077 : }
1078 : else
1079 : {
1080 201 : SwRect aRect;
1081 201 : if( !bFrmSelection && ((nFrmType & FRMTYPE_COLSECT) || rSh.IsDirectlyInSection()) )
1082 : {
1083 0 : aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
1084 0 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);
1085 0 : aRect.Pos() += aTmpRect.Pos();
1086 : }
1087 :
1088 201 : else if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
1089 0 : aRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1090 201 : else if( nFrmType & FRMTYPE_DRAWOBJ)
1091 0 : aRect = rSh.GetObjRect();
1092 :
1093 201 : if( aRect.Width() )
1094 : {
1095 : // make relative to page position:
1096 0 : aLongLR.SetLeft(aRect.Left() - rPageRect.Left());
1097 0 : aLongLR.SetRight(rPageRect.Right() - aRect.Right());
1098 : }
1099 : }
1100 201 : if( nWhich == SID_ATTR_LONG_LRSPACE )
1101 201 : rSet.Put( aLongLR );
1102 : else
1103 : {
1104 : SvxLRSpaceItem aLR( aLongLR.GetLeft(),
1105 : aLongLR.GetRight(),
1106 : 0, 0,
1107 0 : nWhich);
1108 0 : rSet.Put(aLR);
1109 : }
1110 201 : break;
1111 : }
1112 :
1113 : // provide left and right margins of current page style
1114 : case SID_ATTR_PAGE_LRSPACE:
1115 : {
1116 936 : const SvxLRSpaceItem aTmpPageLRSpace( rDesc.GetMaster().GetLRSpace() );
1117 : const SvxLongLRSpaceItem aLongLR(
1118 : (long)aTmpPageLRSpace.GetLeft(),
1119 : (long)aTmpPageLRSpace.GetRight(),
1120 1872 : SID_ATTR_PAGE_LRSPACE );
1121 1872 : rSet.Put( aLongLR );
1122 : }
1123 936 : break;
1124 :
1125 : case SID_ATTR_LONG_ULSPACE:
1126 : {
1127 : // Page margin top bottom
1128 201 : SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1129 201 : SvxLongULSpaceItem aLongUL( (long)aUL.GetUpper(),
1130 201 : (long)aUL.GetLower(),
1131 603 : SID_ATTR_LONG_ULSPACE);
1132 :
1133 201 : if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
1134 : {
1135 : // Convert document coordinates into page coordinates.
1136 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1137 0 : aLongUL.SetUpper(rRect.Top() - rPageRect.Top());
1138 0 : aLongUL.SetLower(rPageRect.Bottom() - rRect.Bottom());
1139 : }
1140 201 : else if ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER )
1141 : {
1142 0 : SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
1143 0 : aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
1144 0 : aLongUL.SetUpper( aRect.Top() );
1145 0 : aLongUL.SetLower( nPageHeight - aRect.Bottom() );
1146 : }
1147 201 : else if( nFrmType & FRMTYPE_DRAWOBJ)
1148 : {
1149 0 : const SwRect &rRect = rSh.GetObjRect();
1150 0 : aLongUL.SetUpper((rRect.Top() - rPageRect.Top()));
1151 0 : aLongUL.SetLower((rPageRect.Bottom() - rRect.Bottom()));
1152 : }
1153 201 : else if(bBrowse)
1154 : {
1155 0 : aLongUL.SetUpper(rPagePrtRect.Top());
1156 0 : aLongUL.SetLower(nPageHeight - rPagePrtRect.Bottom());
1157 : }
1158 201 : if( nWhich == SID_ATTR_LONG_ULSPACE )
1159 201 : rSet.Put( aLongUL );
1160 : else
1161 : {
1162 0 : SvxULSpaceItem aULTmp((sal_uInt16)aLongUL.GetUpper(),
1163 0 : (sal_uInt16)aLongUL.GetLower(),
1164 0 : nWhich);
1165 0 : rSet.Put(aULTmp);
1166 : }
1167 402 : break;
1168 : }
1169 :
1170 : // provide top and bottom margins of current page style
1171 : case SID_ATTR_PAGE_ULSPACE:
1172 : {
1173 936 : const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1174 : SvxLongULSpaceItem aLongUL(
1175 936 : (long)aUL.GetUpper(),
1176 936 : (long)aUL.GetLower(),
1177 2808 : SID_ATTR_PAGE_ULSPACE );
1178 :
1179 1872 : rSet.Put( aLongUL );
1180 : }
1181 936 : break;
1182 :
1183 : case SID_ATTR_TABSTOP_VERTICAL :
1184 : case RES_PARATR_TABSTOP:
1185 : {
1186 1170 : if ( ISA( SwWebView ) ||
1187 780 : IsTabColFromDoc() ||
1188 780 : IsTabRowFromDoc() ||
1189 780 : ( nSelType & nsSelectionType::SEL_GRF ) ||
1190 780 : ( nSelType & nsSelectionType::SEL_FRM ) ||
1191 780 : ( nSelType & nsSelectionType::SEL_OLE ) ||
1192 780 : ( SfxItemState::DEFAULT > aCoreSet.GetItemState(RES_LR_SPACE) ) ||
1193 1365 : (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich) ) ||
1194 0 : ( bVerticalWriting && (RES_PARATR_TABSTOP == nWhich))
1195 : )
1196 195 : rSet.DisableItem( nWhich );
1197 : else
1198 : {
1199 : SvxTabStopItem aTabStops((const SvxTabStopItem&)
1200 195 : aCoreSet.Get( RES_PARATR_TABSTOP ));
1201 :
1202 : const SvxTabStopItem& rDefTabs = (const SvxTabStopItem&)
1203 195 : rSh.GetDefault(RES_PARATR_TABSTOP);
1204 :
1205 : OSL_ENSURE(m_pHRuler, "why is there no ruler?");
1206 195 : const long nDefTabDist = ::GetTabDist(rDefTabs);
1207 195 : m_pHRuler->SetDefTabDist( nDefTabDist );
1208 195 : m_pVRuler->SetDefTabDist( nDefTabDist );
1209 195 : ::lcl_EraseDefTabs(aTabStops);
1210 195 : rSet.Put(aTabStops, nWhich);
1211 : }
1212 390 : break;
1213 : }
1214 :
1215 : case SID_ATTR_PARA_LRSPACE_VERTICAL:
1216 : case SID_ATTR_PARA_LRSPACE:
1217 : {
1218 402 : if ( nSelType & nsSelectionType::SEL_GRF ||
1219 402 : nSelType & nsSelectionType::SEL_FRM ||
1220 402 : nSelType & nsSelectionType::SEL_OLE ||
1221 201 : nFrmType == FRMTYPE_DRAWOBJ ||
1222 402 : (!bVerticalWriting && (SID_ATTR_PARA_LRSPACE_VERTICAL == nWhich)) ||
1223 0 : ( bVerticalWriting && (SID_ATTR_PARA_LRSPACE == nWhich))
1224 : )
1225 : {
1226 201 : rSet.DisableItem(nWhich);
1227 : }
1228 : else
1229 : {
1230 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1231 0 : if ( !IsTabColFromDoc() )
1232 : {
1233 0 : aLR = (const SvxLRSpaceItem&)aCoreSet.Get(RES_LR_SPACE);
1234 :
1235 : // #i23726#
1236 0 : if (m_pNumRuleNodeFromDoc)
1237 : {
1238 0 : short nOffset = static_cast< short >(aLR.GetTxtLeft() +
1239 : // #i42922# Mouse move of numbering label
1240 : // has to consider the left indent of the paragraph
1241 0 : m_pNumRuleNodeFromDoc->GetLeftMarginWithNum( true ) );
1242 :
1243 : short nFLOffset;
1244 0 : m_pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset );
1245 :
1246 0 : aLR.SetLeft( nOffset + nFLOffset );
1247 : }
1248 : }
1249 0 : aLR.SetWhich(nWhich);
1250 0 : rSet.Put(aLR);
1251 : }
1252 201 : break;
1253 : }
1254 :
1255 : case SID_ATTR_PARA_ULSPACE:
1256 : {
1257 194 : SvxULSpaceItem aUL = (const SvxULSpaceItem&)aCoreSet.Get(RES_UL_SPACE);
1258 194 : aUL.SetWhich(nWhich);
1259 :
1260 194 : SfxItemState e = aCoreSet.GetItemState(RES_UL_SPACE);
1261 194 : if( e >= SfxItemState::DEFAULT )
1262 194 : rSet.Put( aUL );
1263 : else
1264 0 : rSet.InvalidateItem(nWhich);
1265 : }
1266 194 : break;
1267 :
1268 : case SID_RULER_BORDER_DISTANCE:
1269 : {
1270 201 : m_nLeftBorderDistance = 0;
1271 201 : m_nRightBorderDistance = 0;
1272 402 : if ( nSelType & nsSelectionType::SEL_GRF ||
1273 402 : nSelType & nsSelectionType::SEL_FRM ||
1274 402 : nSelType & nsSelectionType::SEL_OLE ||
1275 : nFrmType == FRMTYPE_DRAWOBJ )
1276 0 : rSet.DisableItem(SID_RULER_BORDER_DISTANCE);
1277 : else
1278 : {
1279 201 : SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE);
1280 201 : if(nFrmType & FRMTYPE_FLY_ANY)
1281 : {
1282 0 : if( IsTabColFromDoc() )
1283 : {
1284 0 : const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, pPt );
1285 0 : aDistLR.SetLeft(rFlyPrtRect.Left());
1286 0 : aDistLR.SetRight(rFlyPrtRect.Left());
1287 : }
1288 : else
1289 : {
1290 0 : SfxItemSet aCoreSet2( GetPool(),
1291 : RES_BOX, RES_BOX,
1292 0 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1293 0 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1294 0 : aCoreSet.Put( aBoxInfo );
1295 0 : rSh.GetFlyFrmAttr( aCoreSet );
1296 0 : const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet.Get(RES_BOX);
1297 0 : aDistLR.SetLeft(rBox.GetDistance(BOX_LINE_LEFT));
1298 0 : aDistLR.SetRight(rBox.GetDistance(BOX_LINE_RIGHT));
1299 :
1300 : //add the paragraph border distance
1301 0 : SfxItemSet aCoreSet1( GetPool(),
1302 : RES_BOX, RES_BOX,
1303 0 : 0 );
1304 0 : rSh.GetCurAttr( aCoreSet1 );
1305 0 : const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX);
1306 0 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(BOX_LINE_LEFT));
1307 0 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(BOX_LINE_RIGHT));
1308 : }
1309 0 : rSet.Put(aDistLR);
1310 0 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1311 0 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1312 : }
1313 406 : else if ( IsTabColFromDoc() ||
1314 209 : ( rSh.GetTableFmt() && !bFrmSelection &&
1315 4 : !(nFrmType & FRMTYPE_COLSECT ) ) )
1316 : {
1317 4 : SfxItemSet aCoreSet2( GetPool(),
1318 : RES_BOX, RES_BOX,
1319 4 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1320 8 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1321 4 : aBoxInfo.SetTable(false);
1322 4 : aBoxInfo.SetDist(true);
1323 4 : aCoreSet2.Put(aBoxInfo);
1324 4 : rSh.GetTabBorders( aCoreSet2 );
1325 4 : const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet2.Get(RES_BOX);
1326 4 : aDistLR.SetLeft(rBox.GetDistance(BOX_LINE_LEFT));
1327 4 : aDistLR.SetRight(rBox.GetDistance(BOX_LINE_RIGHT));
1328 :
1329 : //add the border distance of the paragraph
1330 8 : SfxItemSet aCoreSet1( GetPool(), RES_BOX, RES_BOX );
1331 4 : rSh.GetCurAttr( aCoreSet1 );
1332 4 : const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX);
1333 4 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(BOX_LINE_LEFT));
1334 4 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(BOX_LINE_RIGHT));
1335 4 : rSet.Put(aDistLR);
1336 4 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1337 8 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1338 : }
1339 197 : else if ( !rSh.IsDirectlyInSection() )
1340 : {
1341 : //get the page/header/footer border distance
1342 197 : const SwFrmFmt& rMaster = rDesc.GetMaster();
1343 197 : const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetAttrSet().Get(RES_BOX);
1344 197 : aDistLR.SetLeft(rBox.GetDistance(BOX_LINE_LEFT));
1345 197 : aDistLR.SetRight(rBox.GetDistance(BOX_LINE_RIGHT));
1346 :
1347 197 : const SvxBoxItem* pBox = 0;
1348 197 : if(nFrmType & FRMTYPE_HEADER)
1349 : {
1350 0 : rMaster.GetHeader();
1351 0 : const SwFmtHeader& rHeaderFmt = rMaster.GetHeader();
1352 0 : SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt();
1353 0 : if( pHeaderFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
1354 0 : pBox = & (const SvxBoxItem&)pHeaderFmt->GetBox();
1355 : }
1356 197 : else if(nFrmType & FRMTYPE_FOOTER )
1357 : {
1358 0 : const SwFmtFooter& rFooterFmt = rMaster.GetFooter();
1359 0 : SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt();
1360 0 : if( pFooterFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
1361 0 : pBox = & (const SvxBoxItem&)pFooterFmt->GetBox();
1362 : }
1363 197 : if(pBox)
1364 : {
1365 0 : aDistLR.SetLeft(pBox->GetDistance(BOX_LINE_LEFT));
1366 0 : aDistLR.SetRight(pBox->GetDistance(BOX_LINE_RIGHT));
1367 : }
1368 :
1369 : //add the border distance of the paragraph
1370 197 : SfxItemSet aCoreSetTmp( GetPool(),
1371 : RES_BOX, RES_BOX,
1372 197 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
1373 197 : rSh.GetCurAttr( aCoreSetTmp );
1374 197 : const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSetTmp.Get(RES_BOX);
1375 197 : aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(BOX_LINE_LEFT));
1376 197 : aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(BOX_LINE_RIGHT));
1377 197 : rSet.Put(aDistLR);
1378 197 : m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
1379 197 : m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
1380 201 : }
1381 : }
1382 : }
1383 201 : break;
1384 :
1385 : case SID_RULER_TEXT_RIGHT_TO_LEFT:
1386 : {
1387 402 : if ( nSelType & nsSelectionType::SEL_GRF ||
1388 402 : nSelType & nsSelectionType::SEL_FRM ||
1389 402 : nSelType & nsSelectionType::SEL_OLE ||
1390 : nFrmType == FRMTYPE_DRAWOBJ)
1391 0 : rSet.DisableItem(nWhich);
1392 : else
1393 : {
1394 201 : bool bFlag = rSh.IsInRightToLeftText();
1395 201 : rSet.Put(SfxBoolItem(nWhich, bFlag));
1396 : }
1397 : }
1398 201 : break;
1399 :
1400 : case SID_RULER_BORDERS_VERTICAL:
1401 : case SID_RULER_BORDERS:
1402 : {
1403 402 : bool bFrameHasVerticalColumns(false);
1404 : {
1405 : bool bFrameRTL;
1406 : bool bFrameVertL2R;
1407 402 : bFrameHasVerticalColumns = rSh.IsFrmVertical(false, bFrameRTL, bFrameVertL2R) &&
1408 402 : bFrmSelection;
1409 : }
1410 812 : bool bHasTable = ( IsTabColFromDoc() ||
1411 418 : ( rSh.GetTableFmt() && !bFrmSelection &&
1412 410 : !(nFrmType & FRMTYPE_COLSECT ) ) );
1413 :
1414 402 : bool bTableVertical = bHasTable && rSh.IsTableVertical();
1415 :
1416 402 : if(((SID_RULER_BORDERS_VERTICAL == nWhich) &&
1417 201 : ((bHasTable && !bTableVertical) ||
1418 394 : (!bVerticalWriting && !bFrmSelection && !bHasTable ) ||
1419 0 : ( bFrmSelection && !bFrameHasVerticalColumns))) ||
1420 201 : ((SID_RULER_BORDERS == nWhich) &&
1421 4 : ((bHasTable && bTableVertical) ||
1422 0 : (bVerticalWriting && !bFrmSelection&& !bHasTable) || bFrameHasVerticalColumns)))
1423 201 : rSet.DisableItem(nWhich);
1424 201 : else if ( bHasTable )
1425 : {
1426 4 : SwTabCols aTabCols;
1427 4 : size_t nNum = 0;
1428 4 : if ( ( m_bSetTabColFromDoc = IsTabColFromDoc() ) )
1429 : {
1430 0 : rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
1431 0 : nNum = rSh.GetCurMouseTabColNum( m_aTabColFromDocPos );
1432 : }
1433 : else
1434 : {
1435 4 : rSh.GetTabCols( aTabCols );
1436 4 : nNum = rSh.GetCurTabColNum();
1437 4 : if(rSh.IsTableRightToLeft())
1438 0 : nNum = aTabCols.Count() - nNum;
1439 : }
1440 :
1441 : OSL_ENSURE(nNum <= aTabCols.Count(), "TabCol not found");
1442 4 : const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
1443 : const int nRgt = (bTableVertical ? nPageHeight : nPageWidth) -
1444 4 : (aTabCols.GetLeftMin() + aTabCols.GetRight());
1445 :
1446 4 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1447 4 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1448 :
1449 8 : SvxColumnItem aColItem(nNum, nL, nR);
1450 :
1451 4 : long nStart = 0;
1452 4 : long nEnd = 0;
1453 :
1454 : //columns in right-to-left tables need to be mirrored
1455 : bool bIsTableRTL =
1456 4 : IsTabColFromDoc() ?
1457 0 : rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
1458 4 : : rSh.IsTableRightToLeft();
1459 4 : if(bIsTableRTL)
1460 : {
1461 0 : for ( size_t i = aTabCols.Count(); i; --i )
1462 : {
1463 0 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 );
1464 0 : nEnd = aTabCols.GetRight() - rEntry.nPos;
1465 : SvxColumnDescription aColDesc( nStart, nEnd,
1466 0 : aTabCols.GetRight() - rEntry.nMax,
1467 0 : aTabCols.GetRight() - rEntry.nMin,
1468 0 : !aTabCols.IsHidden(i - 1) );
1469 0 : aColItem.Append(aColDesc);
1470 0 : nStart = nEnd;
1471 : }
1472 : SvxColumnDescription aColDesc(nStart,
1473 0 : aTabCols.GetRight() - aTabCols.GetLeft(), true);
1474 0 : aColItem.Append(aColDesc);
1475 : }
1476 : else
1477 : {
1478 8 : for ( size_t i = 0; i < aTabCols.Count(); ++i )
1479 : {
1480 4 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
1481 4 : nEnd = rEntry.nPos - aTabCols.GetLeft();
1482 : SvxColumnDescription aColDesc( nStart, nEnd,
1483 8 : rEntry.nMin - aTabCols.GetLeft(), rEntry.nMax - aTabCols.GetLeft(),
1484 12 : !aTabCols.IsHidden(i) );
1485 4 : aColItem.Append(aColDesc);
1486 4 : nStart = nEnd;
1487 : }
1488 4 : SvxColumnDescription aColDesc(nStart, aTabCols.GetRight() - aTabCols.GetLeft(),
1489 4 : 0, 0, true);
1490 4 : aColItem.Append(aColDesc);
1491 : }
1492 8 : rSet.Put(aColItem, nWhich);
1493 : }
1494 197 : else if ( bFrmSelection || nFrmType & ( FRMTYPE_COLUMN | FRMTYPE_COLSECT ) )
1495 : {
1496 : // Out of frame or page?
1497 0 : sal_uInt16 nNum = 0;
1498 0 : if(bFrmSelection)
1499 : {
1500 0 : const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt();
1501 0 : if(pFmt)
1502 0 : nNum = pFmt->GetCol().GetNumCols();
1503 : }
1504 : else
1505 0 : nNum = rSh.GetCurColNum();
1506 :
1507 0 : if(
1508 : // For that matter FRMTYPE_COLSECT should not be included
1509 : // if the border is selected!
1510 0 : !bFrmSelection &&
1511 0 : nFrmType & FRMTYPE_COLSECT )
1512 : {
1513 0 : const SwSection *pSect = rSh.GetAnySection(false, pPt);
1514 : OSL_ENSURE( pSect, "Which section?");
1515 0 : if( pSect )
1516 : {
1517 0 : SwSectionFmt *pFmt = pSect->GetFmt();
1518 0 : const SwFmtCol& rCol = pFmt->GetCol();
1519 0 : if(rSh.IsInRightToLeftText())
1520 0 : nNum = rCol.GetColumns().size() - nNum;
1521 : else
1522 0 : --nNum;
1523 0 : SvxColumnItem aColItem(nNum);
1524 0 : SwRect aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
1525 0 : const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);
1526 :
1527 0 : ::lcl_FillSvxColumn(rCol, bVerticalWriting ? aRect.Height() : aRect.Width(), aColItem, 0);
1528 :
1529 0 : if(bVerticalWriting)
1530 : {
1531 0 : aRect.Pos() += Point(aTmpRect.Left(), aTmpRect.Top());
1532 0 : aRect.Pos().Y() -= rPageRect.Top();
1533 0 : aColItem.SetLeft(aRect.Top());
1534 0 : aColItem.SetRight(nPageHeight - aRect.Bottom());
1535 : }
1536 : else
1537 : {
1538 0 : aRect.Pos() += aTmpRect.Pos();
1539 :
1540 : // make relative to page position:
1541 0 : aColItem.SetLeft ((sal_uInt16)( aRect.Left() - rPageRect.Left() ));
1542 0 : aColItem.SetRight((sal_uInt16)( rPageRect.Right() - aRect.Right()));
1543 : }
1544 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1545 :
1546 0 : rSet.Put(aColItem, nWhich);
1547 0 : }
1548 : }
1549 0 : else if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
1550 : {
1551 : // Columns in frame
1552 0 : if ( nNum )
1553 : {
1554 0 : const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt() ;
1555 :
1556 0 : const SwFmtCol& rCol = pFmt->GetCol();
1557 0 : if(rSh.IsInRightToLeftText())
1558 0 : nNum = rCol.GetColumns().size() - nNum;
1559 : else
1560 0 : nNum--;
1561 0 : SvxColumnItem aColItem(nNum);
1562 0 : const SwRect &rSizeRect = rSh.GetAnyCurRect(RECT_FLY_PRT_EMBEDDED, pPt);
1563 :
1564 0 : bool bUseVertical = bFrameHasVerticalColumns || (!bFrmSelection && bVerticalWriting);
1565 0 : const long lWidth = bUseVertical ? rSizeRect.Height() : rSizeRect.Width();
1566 0 : const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
1567 0 : long nDist2 = ((bUseVertical ? rRect.Height() : rRect.Width()) - lWidth) /2;
1568 0 : ::lcl_FillSvxColumn(rCol, lWidth, aColItem, nDist2);
1569 :
1570 0 : SfxItemSet aFrameSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE);
1571 0 : rSh.GetFlyFrmAttr( aFrameSet );
1572 :
1573 0 : if(bUseVertical)
1574 : {
1575 0 : aColItem.SetLeft(rRect.Top()- rPageRect.Top());
1576 0 : aColItem.SetRight(nPageHeight + rPageRect.Top() - rRect.Bottom());
1577 : }
1578 : else
1579 : {
1580 0 : aColItem.SetLeft(rRect.Left() - rPageRect.Left());
1581 0 : aColItem.SetRight(rPageRect.Right() - rRect.Right());
1582 : }
1583 :
1584 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1585 :
1586 0 : rSet.Put(aColItem, nWhich);
1587 : }
1588 : else
1589 0 : rSet.DisableItem(nWhich);
1590 : }
1591 : else
1592 : { // Columns on the page
1593 0 : const SwFrmFmt& rMaster = rDesc.GetMaster();
1594 0 : SwFmtCol aCol(rMaster.GetCol());
1595 0 : if(rFrameDir.GetValue() == FRMDIR_HORI_RIGHT_TOP)
1596 0 : nNum = aCol.GetColumns().size() - nNum;
1597 : else
1598 0 : nNum--;
1599 :
1600 0 : SvxColumnItem aColItem(nNum);
1601 0 : const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT, pPt);
1602 0 : const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetFmtAttr(RES_BOX);
1603 0 : long nDist = rBox.GetDistance();
1604 :
1605 : lcl_FillSvxColumn(
1606 : aCol,
1607 : bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
1608 0 : aColItem, nDist);
1609 :
1610 0 : if(bBrowse)
1611 : {
1612 0 : if (bVerticalWriting)
1613 : {
1614 0 : aColItem.SetLeft((sal_uInt16)rPagePrtRect.Top());
1615 0 : aColItem.SetRight(sal_uInt16(nPageHeight - rPagePrtRect.Bottom()));
1616 : }
1617 : else
1618 : {
1619 0 : aColItem.SetLeft((sal_uInt16)rPagePrtRect.Left());
1620 0 : aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right()));
1621 : }
1622 : }
1623 : else
1624 : {
1625 0 : if (bVerticalWriting)
1626 : {
1627 0 : SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
1628 0 : aColItem.SetLeft (aUL.GetUpper());
1629 0 : aColItem.SetRight(aUL.GetLower());
1630 : }
1631 : else
1632 : {
1633 0 : aColItem.SetLeft (aPageLRSpace.GetLeft());
1634 0 : aColItem.SetRight(aPageLRSpace.GetRight());
1635 : }
1636 : }
1637 0 : aColItem.SetOrtho(aColItem.CalcOrtho());
1638 :
1639 0 : rSet.Put(aColItem, nWhich);
1640 0 : }
1641 : }
1642 : else
1643 197 : rSet.DisableItem(nWhich);
1644 402 : break;
1645 : }
1646 :
1647 : case SID_RULER_ROWS :
1648 : case SID_RULER_ROWS_VERTICAL:
1649 : {
1650 402 : bool bFrameHasVerticalColumns(false);
1651 : {
1652 : bool bFrameRTL;
1653 : bool bFrameVertL2R;
1654 402 : bFrameHasVerticalColumns = rSh.IsFrmVertical(false, bFrameRTL, bFrameVertL2R) &&
1655 402 : bFrmSelection;
1656 : }
1657 :
1658 603 : if(((SID_RULER_ROWS == nWhich) &&
1659 402 : ((!bVerticalWriting && !bFrmSelection) || (bFrmSelection && !bFrameHasVerticalColumns))) ||
1660 201 : ((SID_RULER_ROWS_VERTICAL == nWhich) &&
1661 0 : ((bVerticalWriting && !bFrmSelection) || bFrameHasVerticalColumns)))
1662 201 : rSet.DisableItem(nWhich);
1663 406 : else if ( IsTabRowFromDoc() ||
1664 209 : ( rSh.GetTableFmt() && !bFrmSelection &&
1665 4 : !(nFrmType & FRMTYPE_COLSECT ) ) )
1666 : {
1667 4 : SwTabCols aTabCols;
1668 4 : if ( ( m_bSetTabRowFromDoc = IsTabRowFromDoc() ) )
1669 : {
1670 0 : rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
1671 : }
1672 : else
1673 : {
1674 4 : rSh.GetTabRows( aTabCols );
1675 : }
1676 :
1677 4 : const int nLft = aTabCols.GetLeftMin();
1678 : const int nRgt = (bVerticalWriting ? nPageWidth : nPageHeight) -
1679 4 : (aTabCols.GetLeftMin() + aTabCols.GetRight());
1680 :
1681 4 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1682 4 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1683 :
1684 8 : SvxColumnItem aColItem(0, nL, nR);
1685 :
1686 4 : long nStart = 0;
1687 4 : long nEnd = 0;
1688 :
1689 8 : for ( size_t i = 0; i < aTabCols.Count(); ++i )
1690 : {
1691 4 : const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
1692 4 : if(bVerticalWriting)
1693 : {
1694 0 : nEnd = aTabCols.GetRight() - rEntry.nPos;
1695 : SvxColumnDescription aColDesc( nStart, nEnd,
1696 0 : aTabCols.GetRight() - rEntry.nMax,
1697 0 : aTabCols.GetRight() - rEntry.nMin,
1698 0 : !aTabCols.IsHidden(i) );
1699 0 : aColItem.Append(aColDesc);
1700 : }
1701 : else
1702 : {
1703 4 : nEnd = rEntry.nPos - aTabCols.GetLeft();
1704 : SvxColumnDescription aColDesc( nStart, nEnd,
1705 4 : rEntry.nMin - aTabCols.GetLeft(),
1706 4 : rEntry.nMax - aTabCols.GetLeft(),
1707 12 : !aTabCols.IsHidden(i) );
1708 4 : aColItem.Append(aColDesc);
1709 : }
1710 4 : nStart = nEnd;
1711 : }
1712 4 : if(bVerticalWriting)
1713 0 : nEnd = aTabCols.GetRight();
1714 : else
1715 4 : nEnd = aTabCols.GetLeft();
1716 : // put a position protection when the last row cannot be moved
1717 : // due to a page break inside of a row
1718 4 : if(!aTabCols.IsLastRowAllowedToChange())
1719 0 : bPutContentProtection = true;
1720 :
1721 : SvxColumnDescription aColDesc( nStart, nEnd,
1722 : aTabCols.GetRight(),
1723 : aTabCols.GetRight(),
1724 4 : false );
1725 4 : aColItem.Append(aColDesc);
1726 :
1727 8 : rSet.Put(aColItem, nWhich);
1728 : }
1729 : else
1730 197 : rSet.DisableItem(nWhich);
1731 : }
1732 402 : break;
1733 :
1734 : case SID_RULER_PAGE_POS:
1735 : {
1736 : SvxPagePosSizeItem aPagePosSize(
1737 203 : Point( rPageRect.Left(), rPageRect.Top()) , nPageWidth, nPageHeight);
1738 :
1739 203 : rSet.Put(aPagePosSize);
1740 203 : break;
1741 : }
1742 :
1743 : case SID_RULER_LR_MIN_MAX:
1744 : {
1745 203 : Rectangle aRectangle;
1746 203 : if( ( nFrmType & FRMTYPE_COLSECT ) && !IsTabColFromDoc() &&
1747 0 : ( nFrmType & ( FRMTYPE_TABLE|FRMTYPE_COLUMN ) ) )
1748 : {
1749 0 : if( nFrmType & FRMTYPE_TABLE )
1750 : {
1751 0 : const size_t nNum = rSh.GetCurTabColNum();
1752 0 : SwTabCols aTabCols;
1753 0 : rSh.GetTabCols( aTabCols );
1754 :
1755 0 : const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
1756 0 : const int nRgt = nPageWidth -(aTabCols.GetLeftMin() + aTabCols.GetRight());
1757 :
1758 0 : const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
1759 0 : const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);
1760 :
1761 0 : aRectangle.Left() = nL;
1762 0 : if(nNum > 1)
1763 0 : aRectangle.Left() += aTabCols[nNum - 2];
1764 0 : if(nNum)
1765 0 : aRectangle.Left() += MINLAY;
1766 0 : if(aTabCols.Count() <= nNum + 1 )
1767 0 : aRectangle.Right() = nR;
1768 : else
1769 0 : aRectangle.Right() = nPageWidth - (nL + aTabCols[nNum + 1]);
1770 :
1771 0 : if(nNum < aTabCols.Count())
1772 0 : aRectangle.Right() += MINLAY;
1773 : }
1774 : else
1775 : {
1776 0 : const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt();
1777 0 : const SwFmtCol* pCols = pFmt ? &pFmt->GetCol():
1778 0 : &rDesc.GetMaster().GetCol();
1779 0 : const SwColumns& rCols = pCols->GetColumns();
1780 0 : sal_uInt16 nNum = rSh.GetCurOutColNum();
1781 0 : const sal_uInt16 nCount = std::min(sal_uInt16(nNum + 1), sal_uInt16(rCols.size()));
1782 : const SwRect aRect( rSh.GetAnyCurRect( pFmt
1783 : ? RECT_FLY_PRT_EMBEDDED
1784 0 : : RECT_PAGE_PRT, pPt ));
1785 : const SwRect aAbsRect( rSh.GetAnyCurRect( pFmt
1786 : ? RECT_FLY_EMBEDDED
1787 0 : : RECT_PAGE, pPt ));
1788 :
1789 : // The width of the frame or within the page margins.
1790 0 : const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
1791 : // The entire frame width - The difference is twice the distance to the edge.
1792 0 : const sal_uInt16 nOuterWidth = (sal_uInt16)aAbsRect.Width();
1793 0 : int nWidth = 0,
1794 0 : nStart = 0,
1795 0 : nEnd = 0;
1796 0 : aRectangle.Left() = 0;
1797 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
1798 : {
1799 0 : const SwColumn* pCol = &rCols[i];
1800 0 : nStart = pCol->GetLeft() + nWidth;
1801 0 : if(i == nNum - 2)
1802 0 : aRectangle.Left() = nStart;
1803 0 : nWidth += pCols->CalcColWidth( i, nTotalWidth );
1804 0 : nEnd = nWidth - pCol->GetRight();
1805 : }
1806 0 : aRectangle.Right() = rPageRect.Right() - nEnd;
1807 0 : aRectangle.Left() -= rPageRect.Left();
1808 :
1809 0 : if(nNum > 1)
1810 : {
1811 0 : aRectangle.Left() += MINLAY;
1812 0 : aRectangle.Left() += aRect.Left();
1813 : }
1814 0 : if(pFmt) // Range in frame - here you may up to the edge
1815 0 : aRectangle.Left() = aRectangle.Right() = 0;
1816 : else
1817 : {
1818 : // Move the rectangle to the correct absolute position.
1819 0 : aRectangle.Left() += aAbsRect.Left();
1820 0 : aRectangle.Right() -= aAbsRect.Left();
1821 : // Include distance to the border.
1822 0 : aRectangle.Right() -= (nOuterWidth - nTotalWidth) / 2;
1823 : }
1824 :
1825 0 : if(nNum < rCols.size())
1826 : {
1827 0 : aRectangle.Right() += MINLAY;
1828 : }
1829 : else
1830 : // Right is only the margin now.
1831 0 : aRectangle.Right() = 0;
1832 :
1833 : }
1834 : }
1835 207 : else if ( ((nFrmType & FRMTYPE_TABLE) || IsTabColFromDoc()) &&
1836 4 : !bFrmSelection )
1837 : {
1838 : bool bColumn;
1839 4 : if ( IsTabColFromDoc() )
1840 0 : bColumn = rSh.GetCurMouseColNum( m_aTabColFromDocPos ) != 0;
1841 : else
1842 4 : bColumn = (nFrmType & (FRMTYPE_COLUMN|FRMTYPE_FLY_ANY|FRMTYPE_COLSECTOUTTAB))
1843 : ? sal_True
1844 4 : : sal_False;
1845 :
1846 4 : if ( !bColumn )
1847 : {
1848 4 : if( nFrmType & FRMTYPE_FLY_ANY && IsTabColFromDoc() )
1849 : {
1850 : SwRect aRect( rSh.GetAnyCurRect(
1851 0 : RECT_FLY_PRT_EMBEDDED, pPt ) );
1852 0 : aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
1853 0 : pPt ).Pos();
1854 :
1855 0 : aRectangle.Left() = aRect.Left() - rPageRect.Left();
1856 0 : aRectangle.Right() = rPageRect.Right() - aRect.Right();
1857 : }
1858 4 : else if( bBrowse )
1859 : {
1860 0 : aRectangle.Left() = rPagePrtRect.Left();
1861 0 : aRectangle.Right() = nPageWidth - rPagePrtRect.Right();
1862 : }
1863 : else
1864 : {
1865 4 : aRectangle.Left() = aPageLRSpace.GetLeft();
1866 4 : aRectangle.Right() = aPageLRSpace.GetRight();
1867 : }
1868 : }
1869 : else
1870 : { // Here only for table in multi-column pages and borders.
1871 0 : bool bSectOutTbl = (nFrmType & FRMTYPE_TABLE) ? sal_True : sal_False;
1872 0 : bool bFrame = (nFrmType & FRMTYPE_FLY_ANY);
1873 0 : bool bColSct = (nFrmType & ( bSectOutTbl
1874 : ? FRMTYPE_COLSECTOUTTAB
1875 : : FRMTYPE_COLSECT )
1876 0 : );
1877 : //So you can also drag with the mouse, without being in the table.
1878 0 : CurRectType eRecType = RECT_PAGE_PRT;
1879 0 : size_t nNum = IsTabColFromDoc() ?
1880 0 : rSh.GetCurMouseColNum( m_aTabColFromDocPos ):
1881 0 : rSh.GetCurOutColNum();
1882 0 : const SwFrmFmt* pFmt = NULL;
1883 0 : if( bColSct )
1884 : {
1885 : eRecType = bSectOutTbl ? RECT_OUTTABSECTION
1886 0 : : RECT_SECTION;
1887 0 : const SwSection *pSect = rSh.GetAnySection( bSectOutTbl, pPt );
1888 : OSL_ENSURE( pSect, "Which section?");
1889 0 : pFmt = pSect->GetFmt();
1890 : }
1891 0 : else if( bFrame )
1892 : {
1893 0 : pFmt = rSh.GetFlyFrmFmt();
1894 0 : eRecType = RECT_FLY_PRT_EMBEDDED;
1895 : }
1896 :
1897 0 : const SwFmtCol* pCols = pFmt ? &pFmt->GetCol():
1898 0 : &rDesc.GetMaster().GetCol();
1899 0 : const SwColumns& rCols = pCols->GetColumns();
1900 0 : const sal_uInt16 nBorder = pFmt ? pFmt->GetBox().GetDistance() :
1901 0 : rDesc.GetMaster().GetBox().GetDistance();
1902 :
1903 : // RECT_FLY_PRT_EMBEDDED returns the relative position to RECT_FLY_EMBEDDED
1904 : // the absolute position must be added here
1905 :
1906 0 : SwRect aRect( rSh.GetAnyCurRect( eRecType, pPt ) );
1907 0 : if(RECT_FLY_PRT_EMBEDDED == eRecType)
1908 0 : aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
1909 0 : pPt ).Pos();
1910 :
1911 0 : const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
1912 : // Initialize nStart and nEnd initialisieren for nNum == 0
1913 0 : int nWidth = 0,
1914 0 : nStart = 0,
1915 0 : nEnd = nTotalWidth;
1916 :
1917 0 : if( nNum > rCols.size() )
1918 : {
1919 : OSL_ENSURE( false, "wrong FmtCol is being edited!" );
1920 0 : nNum = rCols.size();
1921 : }
1922 :
1923 0 : for( size_t i = 0; i < nNum; ++i )
1924 : {
1925 0 : const SwColumn* pCol = &rCols[i];
1926 0 : nStart = pCol->GetLeft() + nWidth;
1927 0 : nWidth += pCols->CalcColWidth( static_cast<sal_uInt16>(i), nTotalWidth );
1928 0 : nEnd = nWidth - pCol->GetRight();
1929 : }
1930 0 : if( bFrame || bColSct )
1931 : {
1932 0 : aRectangle.Left() = aRect.Left() - rPageRect.Left() + nStart;
1933 0 : aRectangle.Right() = nPageWidth - aRectangle.Left() - nEnd + nStart;
1934 : }
1935 0 : else if(!bBrowse)
1936 : {
1937 0 : aRectangle.Left() = aPageLRSpace.GetLeft() + nStart;
1938 0 : aRectangle.Right() = nPageWidth - nEnd - aPageLRSpace.GetLeft();
1939 : }
1940 : else
1941 : {
1942 0 : long nLeft = rPagePrtRect.Left();
1943 0 : aRectangle.Left() = nStart + nLeft;
1944 0 : aRectangle.Right() = nPageWidth - nEnd - nLeft;
1945 : }
1946 0 : if(!bFrame)
1947 : {
1948 0 : aRectangle.Left() += nBorder;
1949 0 : aRectangle.Right() -= nBorder;
1950 : }
1951 : }
1952 : }
1953 199 : else if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER ))
1954 : {
1955 0 : aRectangle.Left() = aPageLRSpace.GetLeft();
1956 0 : aRectangle.Right() = aPageLRSpace.GetRight();
1957 : }
1958 : else
1959 199 : aRectangle.Left() = aRectangle.Right() = 0;
1960 :
1961 203 : SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle);
1962 203 : rSet.Put(aLR);
1963 : }
1964 203 : break;
1965 :
1966 : case SID_RULER_PROTECT:
1967 : {
1968 197 : if(bFrmSelection)
1969 : {
1970 0 : sal_uInt8 nProtect = m_pWrtShell->IsSelObjProtected( FLYPROTECT_SIZE|FLYPROTECT_POS|FLYPROTECT_CONTENT );
1971 :
1972 0 : SvxProtectItem aProt(SID_RULER_PROTECT);
1973 0 : aProt.SetCntntProtect((nProtect & FLYPROTECT_CONTENT) != 0);
1974 0 : aProt.SetSizeProtect ((nProtect & FLYPROTECT_SIZE) != 0);
1975 0 : aProt.SetPosProtect ((nProtect & FLYPROTECT_POS) != 0);
1976 0 : rSet.Put(aProt);
1977 : }
1978 : else
1979 : {
1980 197 : SvxProtectItem aProtect(SID_RULER_PROTECT);
1981 197 : if(bBrowse && !(nFrmType & (FRMTYPE_DRAWOBJ|FRMTYPE_COLUMN)) && !rSh.GetTableFmt())
1982 : {
1983 0 : aProtect.SetSizeProtect(true);
1984 0 : aProtect.SetPosProtect(true);
1985 : }
1986 197 : rSet.Put(aProtect);
1987 : }
1988 : }
1989 197 : break;
1990 : }
1991 5062 : nWhich = aIter.NextWhich();
1992 : }
1993 1687 : if(bPutContentProtection)
1994 : {
1995 0 : SvxProtectItem aProtect(SID_RULER_PROTECT);
1996 0 : aProtect.SetCntntProtect(true);
1997 0 : rSet.Put(aProtect);
1998 1687 : }
1999 1957 : }
2000 :
2001 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
