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