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