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