Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <svx/svdobj.hxx>
21 : #include <init.hxx>
22 : #include <fesh.hxx>
23 : #include <pagefrm.hxx>
24 : #include <rootfrm.hxx>
25 : #include <cntfrm.hxx>
26 : #include <doc.hxx>
27 : #include <frmtool.hxx>
28 : #include <swtable.hxx>
29 : #include <viewimp.hxx>
30 : #include <dview.hxx>
31 : #include <flyfrm.hxx>
32 : #include <node.hxx>
33 : #include <pam.hxx>
34 : #include <sectfrm.hxx>
35 : #include <fmtpdsc.hxx>
36 : #include <fmtsrnd.hxx>
37 : #include <fmtcntnt.hxx>
38 : #include <fmtfsize.hxx>
39 : #include <tabfrm.hxx>
40 : #include <cellfrm.hxx>
41 : #include <flyfrms.hxx>
42 : #include <txtfrm.hxx>
43 : #include <mdiexp.hxx>
44 : #include <edimp.hxx>
45 : #include <pagedesc.hxx>
46 : #include <fmtanchr.hxx>
47 : #include <environmentofanchoredobject.hxx>
48 : #include <ndtxt.hxx>
49 : #include <dflyobj.hxx>
50 : #include <dcontact.hxx>
51 :
52 : using namespace com::sun::star;
53 :
54 338332411 : TYPEINIT1(SwFEShell,SwEditShell)
55 :
56 3 : void SwFEShell::EndAllActionAndCall()
57 : {
58 6 : for(SwViewShell& rCurrentShell : GetRingContainer())
59 : {
60 3 : if( rCurrentShell.IsA( TYPE(SwCrsrShell) ) )
61 : {
62 3 : static_cast<SwFEShell*>(&rCurrentShell)->EndAction();
63 3 : static_cast<SwFEShell*>(&rCurrentShell)->CallChgLnk();
64 : }
65 : else
66 0 : rCurrentShell.EndAction();
67 : }
68 3 : }
69 :
70 : // Determine the Content's nearest to the point
71 0 : Point SwFEShell::GetContentPos( const Point& rPoint, bool bNext ) const
72 : {
73 0 : SET_CURR_SHELL( const_cast<SwViewShell*>(static_cast<SwViewShell const *>(this)) );
74 0 : return GetLayout()->GetNextPrevContentPos( rPoint, bNext );
75 : }
76 :
77 7043 : const SwRect& SwFEShell::GetAnyCurRect( CurRectType eType, const Point* pPt,
78 : const uno::Reference < embed::XEmbeddedObject >& xObj ) const
79 : {
80 7043 : const SwFrm *pFrm = Imp()->HasDrawView()
81 7043 : ? ::GetFlyFromMarked( &Imp()->GetDrawView()->GetMarkedObjectList(),
82 7043 : const_cast<SwViewShell*>(static_cast<SwViewShell const *>(this)))
83 14086 : : 0;
84 :
85 7043 : if( !pFrm )
86 : {
87 7043 : if( pPt )
88 : {
89 0 : SwPosition aPos( *GetCrsr()->GetPoint() );
90 0 : Point aPt( *pPt );
91 0 : GetLayout()->GetCrsrOfst( &aPos, aPt );
92 0 : SwContentNode *pNd = aPos.nNode.GetNode().GetContentNode();
93 0 : pFrm = pNd->getLayoutFrm( GetLayout(), pPt );
94 : }
95 : else
96 : {
97 7043 : const bool bOldCallbackActionEnabled = GetLayout()->IsCallbackActionEnabled();
98 7043 : if( bOldCallbackActionEnabled )
99 7043 : GetLayout()->SetCallbackActionEnabled( false );
100 7043 : pFrm = GetCurrFrm();
101 7043 : if( bOldCallbackActionEnabled )
102 7043 : GetLayout()->SetCallbackActionEnabled( true );
103 : }
104 : }
105 :
106 7043 : if( !pFrm )
107 0 : return GetLayout()->Frm();
108 :
109 7043 : bool bFrm = true;
110 7043 : switch ( eType )
111 : {
112 2610 : case RECT_PAGE_PRT: bFrm = false; /* no break */
113 5225 : case RECT_PAGE : pFrm = pFrm->FindPageFrm();
114 5225 : break;
115 :
116 906 : case RECT_PAGE_CALC: pFrm->Calc();
117 906 : pFrm = pFrm->FindPageFrm();
118 906 : pFrm->Calc();
119 906 : break;
120 :
121 0 : case RECT_FLY_PRT_EMBEDDED: bFrm = false; /* no break */
122 0 : case RECT_FLY_EMBEDDED: pFrm = xObj.is() ? FindFlyFrm( xObj )
123 0 : : pFrm->IsFlyFrm()
124 : ? pFrm
125 0 : : pFrm->FindFlyFrm();
126 0 : break;
127 :
128 : case RECT_OUTTABSECTION_PRT:
129 0 : case RECT_OUTTABSECTION : if( pFrm->IsInTab() )
130 0 : pFrm = pFrm->FindTabFrm();
131 : else {
132 : OSL_FAIL( "Missing Table" );
133 : }
134 : /* no break */
135 : case RECT_SECTION_PRT:
136 6 : case RECT_SECTION: if( pFrm->IsInSct() )
137 6 : pFrm = pFrm->FindSctFrm();
138 : else {
139 : OSL_FAIL( "Missing section" );
140 : }
141 :
142 6 : if( RECT_OUTTABSECTION_PRT == eType ||
143 : RECT_SECTION_PRT == eType )
144 3 : bFrm = false;
145 6 : break;
146 :
147 0 : case RECT_HEADERFOOTER_PRT: bFrm = false; /* no break */
148 0 : case RECT_HEADERFOOTER: if( 0 == (pFrm = pFrm->FindFooterOrHeader()) )
149 0 : return GetLayout()->Frm();
150 0 : break;
151 :
152 906 : case RECT_PAGES_AREA: return GetLayout()->GetPagesArea();
153 :
154 0 : default: break;
155 : }
156 6137 : return bFrm ? pFrm->Frm() : pFrm->Prt();
157 : }
158 :
159 0 : sal_uInt16 SwFEShell::GetPageNumber( const Point &rPoint ) const
160 : {
161 0 : const SwFrm *pPage = GetLayout()->Lower();
162 0 : while ( pPage && !pPage->Frm().IsInside( rPoint ) )
163 0 : pPage = pPage->GetNext();
164 0 : if ( pPage )
165 0 : return static_cast<const SwPageFrm*>(pPage)->GetPhyPageNum();
166 : else
167 0 : return 0;
168 : }
169 :
170 870 : bool SwFEShell::GetPageNumber( long nYPos, bool bAtCrsrPos, sal_uInt16& rPhyNum, sal_uInt16& rVirtNum, OUString &rDisplay) const
171 : {
172 : const SwFrm *pPage;
173 :
174 870 : if ( bAtCrsrPos ) // get page of Crsr
175 : {
176 849 : pPage = GetCurrFrm( false );
177 849 : if ( pPage )
178 849 : pPage = pPage->FindPageFrm();
179 : }
180 21 : else if ( nYPos > -1 ) // determine page via the position
181 : {
182 0 : pPage = GetLayout()->Lower();
183 0 : while( pPage && (pPage->Frm().Bottom() < nYPos ||
184 0 : nYPos < pPage->Frm().Top() ) )
185 0 : pPage = pPage->GetNext();
186 : }
187 : else // first visible page
188 : {
189 21 : pPage = Imp()->GetFirstVisPage();
190 21 : if ( pPage && static_cast<const SwPageFrm*>(pPage)->IsEmptyPage() )
191 0 : pPage = pPage->GetNext();
192 : }
193 :
194 870 : if( pPage )
195 : {
196 870 : rPhyNum = static_cast<const SwPageFrm*>(pPage)->GetPhyPageNum();
197 870 : rVirtNum = static_cast<const SwPageFrm*>(pPage)->GetVirtPageNum();
198 870 : const SvxNumberType& rNum = static_cast<const SwPageFrm*>(pPage)->GetPageDesc()->GetNumType();
199 870 : rDisplay = rNum.GetNumStr( rVirtNum );
200 : }
201 :
202 870 : return 0 != pPage;
203 : }
204 :
205 1129 : bool SwFEShell::IsDirectlyInSection() const
206 : {
207 1129 : SwFrm* pFrm = GetCurrFrm( false );
208 1129 : return pFrm && pFrm->GetUpper() && pFrm->GetUpper()->IsSctFrm();
209 : }
210 :
211 6948 : FrmTypeFlags SwFEShell::GetFrmType( const Point *pPt, bool bStopAtFly ) const
212 : {
213 6948 : FrmTypeFlags nReturn = FrmTypeFlags::NONE;
214 : const SwFrm *pFrm;
215 6948 : if ( pPt )
216 : {
217 0 : SwPosition aPos( *GetCrsr()->GetPoint() );
218 0 : Point aPt( *pPt );
219 0 : GetLayout()->GetCrsrOfst( &aPos, aPt );
220 0 : SwContentNode *pNd = aPos.nNode.GetNode().GetContentNode();
221 0 : pFrm = pNd->getLayoutFrm( GetLayout(), pPt );
222 : }
223 : else
224 6948 : pFrm = GetCurrFrm( false );
225 41772 : while ( pFrm )
226 : {
227 27876 : switch ( pFrm->GetType() )
228 : {
229 1 : case FRM_COLUMN: if( pFrm->GetUpper()->IsSctFrm() )
230 : {
231 : // Check, if isn't not only a single column
232 : // from a section with footnotes at the end.
233 1 : if( pFrm->GetNext() || pFrm->GetPrev() )
234 : // Sectioncolumns
235 3 : nReturn |= ( nReturn & FrmTypeFlags::TABLE ) ?
236 2 : FrmTypeFlags::COLSECTOUTTAB : FrmTypeFlags::COLSECT;
237 : }
238 : else // only pages and frame columns
239 0 : nReturn |= FrmTypeFlags::COLUMN;
240 1 : break;
241 6948 : case FRM_PAGE: nReturn |= FrmTypeFlags::PAGE;
242 6948 : if( static_cast<const SwPageFrm*>(pFrm)->IsFootnotePage() )
243 0 : nReturn |= FrmTypeFlags::FTNPAGE;
244 6948 : break;
245 0 : case FRM_HEADER: nReturn |= FrmTypeFlags::HEADER; break;
246 0 : case FRM_FOOTER: nReturn |= FrmTypeFlags::FOOTER; break;
247 6949 : case FRM_BODY: if( pFrm->GetUpper()->IsPageFrm() ) // not for ColumnFrms
248 6948 : nReturn |= FrmTypeFlags::BODY;
249 6949 : break;
250 0 : case FRM_FTN: nReturn |= FrmTypeFlags::FOOTNOTE; break;
251 0 : case FRM_FLY: if( static_cast<const SwFlyFrm*>(pFrm)->IsFlyLayFrm() )
252 0 : nReturn |= FrmTypeFlags::FLY_FREE;
253 0 : else if ( static_cast<const SwFlyFrm*>(pFrm)->IsFlyAtCntFrm() )
254 0 : nReturn |= FrmTypeFlags::FLY_ATCNT;
255 : else
256 : {
257 : OSL_ENSURE( static_cast<const SwFlyFrm*>(pFrm)->IsFlyInCntFrm(),
258 : "New frametype?" );
259 0 : nReturn |= FrmTypeFlags::FLY_INCNT;
260 : }
261 0 : nReturn |= FrmTypeFlags::FLY_ANY;
262 0 : if( bStopAtFly )
263 0 : return nReturn;
264 0 : break;
265 : case FRM_TAB:
266 : case FRM_ROW:
267 75 : case FRM_CELL: nReturn |= FrmTypeFlags::TABLE; break;
268 13903 : default: /* do nothing */ break;
269 : }
270 27876 : if ( pFrm->IsFlyFrm() )
271 0 : pFrm = static_cast<const SwFlyFrm*>(pFrm)->GetAnchorFrm();
272 : else
273 27876 : pFrm = pFrm->GetUpper();
274 : }
275 6948 : return nReturn;
276 : }
277 :
278 2673 : void SwFEShell::ShGetFcs( bool bUpdate )
279 : {
280 2673 : ::SetShell( this );
281 2673 : SwCrsrShell::ShGetFcs( bUpdate );
282 :
283 2673 : if ( HasDrawView() )
284 : {
285 2673 : Imp()->GetDrawView()->showMarkHandles();
286 2673 : if ( Imp()->GetDrawView()->AreObjectsMarked() )
287 0 : FrameNotify( this, FLY_DRAG_START );
288 : }
289 2673 : }
290 :
291 2672 : void SwFEShell::ShLooseFcs()
292 : {
293 2672 : SwCrsrShell::ShLooseFcs();
294 :
295 2672 : if ( HasDrawView() && Imp()->GetDrawView()->AreObjectsMarked() )
296 : {
297 3 : Imp()->GetDrawView()->hideMarkHandles();
298 3 : FrameNotify( this, FLY_DRAG_END );
299 : }
300 2672 : }
301 :
302 5 : sal_uInt16 SwFEShell::GetPhyPageNum()
303 : {
304 5 : SwFrm *pFrm = GetCurrFrm();
305 5 : if ( pFrm )
306 5 : return pFrm->GetPhyPageNum();
307 0 : return 0;
308 : }
309 :
310 5 : sal_uInt16 SwFEShell::GetVirtPageNum( const bool bCalcFrm )
311 : {
312 5 : SwFrm *pFrm = GetCurrFrm( bCalcFrm );
313 5 : if ( pFrm )
314 5 : return pFrm->GetVirtPageNum();
315 0 : return 0;
316 : }
317 :
318 0 : static void lcl_SetAPageOffset( sal_uInt16 nOffset, SwPageFrm* pPage, SwFEShell* pThis )
319 : {
320 0 : pThis->StartAllAction();
321 : OSL_ENSURE( pPage->FindFirstBodyContent(),
322 : "SwFEShell _SetAPageOffset() without ContentFrm" );
323 :
324 0 : SwFormatPageDesc aDesc( pPage->GetPageDesc() );
325 0 : aDesc.SetNumOffset( nOffset );
326 :
327 0 : SwFrm *pFrm = pThis->GetCurrFrm( false );
328 0 : if ( pFrm->IsInTab() )
329 0 : pThis->GetDoc()->SetAttr( aDesc, *pFrm->FindTabFrm()->GetFormat() );
330 : else
331 : {
332 0 : pThis->GetDoc()->getIDocumentContentOperations().InsertPoolItem( *pThis->GetCrsr(), aDesc );
333 : }
334 :
335 0 : pThis->EndAllAction();
336 0 : }
337 :
338 0 : void SwFEShell::SetNewPageOffset( sal_uInt16 nOffset )
339 : {
340 0 : GetLayout()->SetVirtPageNum( true );
341 0 : const SwPageFrm *pPage = GetCurrFrm( false )->FindPageFrm();
342 0 : lcl_SetAPageOffset( nOffset, const_cast<SwPageFrm*>(pPage), this );
343 0 : }
344 :
345 0 : void SwFEShell::SetPageOffset( sal_uInt16 nOffset )
346 : {
347 0 : const SwPageFrm *pPage = GetCurrFrm( false )->FindPageFrm();
348 0 : const SwRootFrm* pDocLayout = GetLayout();
349 0 : while ( pPage )
350 : {
351 0 : const SwFrm *pFlow = pPage->FindFirstBodyContent();
352 0 : if ( pFlow )
353 : {
354 0 : if ( pFlow->IsInTab() )
355 0 : pFlow = pFlow->FindTabFrm();
356 0 : const SwFormatPageDesc& rPgDesc = pFlow->GetAttrSet()->GetPageDesc();
357 0 : if ( rPgDesc.GetNumOffset() )
358 : {
359 0 : pDocLayout->SetVirtPageNum( true );
360 0 : lcl_SetAPageOffset( nOffset, const_cast<SwPageFrm*>(pPage), this );
361 0 : break;
362 : }
363 : }
364 0 : pPage = static_cast<const SwPageFrm*>(pPage->GetPrev());
365 : }
366 0 : }
367 :
368 0 : sal_uInt16 SwFEShell::GetPageOffset() const
369 : {
370 0 : const SwPageFrm *pPage = GetCurrFrm()->FindPageFrm();
371 0 : while ( pPage )
372 : {
373 0 : const SwFrm *pFlow = pPage->FindFirstBodyContent();
374 0 : if ( pFlow )
375 : {
376 0 : if ( pFlow->IsInTab() )
377 0 : pFlow = pFlow->FindTabFrm();
378 0 : ::boost::optional<sal_uInt16> oNumOffset = pFlow->GetAttrSet()->GetPageDesc().GetNumOffset();
379 0 : if ( oNumOffset )
380 0 : return oNumOffset.get();
381 : }
382 0 : pPage = static_cast<const SwPageFrm*>(pPage->GetPrev());
383 : }
384 0 : return 0;
385 : }
386 :
387 0 : void SwFEShell::InsertLabel( const SwLabelType eType, const OUString &rText, const OUString& rSeparator,
388 : const OUString& rNumberSeparator,
389 : const bool bBefore, const sal_uInt16 nId,
390 : const OUString& rCharacterStyle,
391 : const bool bCpyBrd )
392 : {
393 : // get node index of cursor position, SwDoc can do everything else itself
394 0 : SwContentFrm *pCnt = LTYPE_DRAW==eType ? 0 : GetCurrFrm( false );
395 0 : if( LTYPE_DRAW==eType || pCnt )
396 : {
397 0 : StartAllAction();
398 :
399 0 : sal_uLong nIdx = 0;
400 0 : SwFlyFrameFormat* pFlyFormat = 0;
401 0 : switch( eType )
402 : {
403 : case LTYPE_OBJECT:
404 : case LTYPE_FLY:
405 0 : if( pCnt->IsInFly() )
406 : {
407 : // pass down index to the startnode for flys
408 0 : nIdx = pCnt->FindFlyFrm()->
409 0 : GetFormat()->GetContent().GetContentIdx()->GetIndex();
410 : }
411 0 : break;
412 : case LTYPE_TABLE:
413 0 : if( pCnt->IsInTab() )
414 : {
415 : // pass down index to the TableNode for tables
416 0 : const SwTable& rTable = *pCnt->FindTabFrm()->GetTable();
417 0 : nIdx = rTable.GetTabSortBoxes()[ 0 ]
418 0 : ->GetSttNd()->FindTableNode()->GetIndex();
419 : }
420 0 : break;
421 : case LTYPE_DRAW:
422 0 : if( Imp()->GetDrawView() )
423 : {
424 0 : SwDrawView *pDView = Imp()->GetDrawView();
425 0 : const SdrMarkList& rMrkList = pDView->GetMarkedObjectList();
426 0 : StartUndo();
427 :
428 : // copy marked drawing objects to
429 : // local list to perform the corresponding action for each object
430 0 : std::vector<SdrObject*> aDrawObjs;
431 : {
432 0 : for ( size_t i = 0; i < rMrkList.GetMarkCount(); ++i )
433 : {
434 0 : SdrObject* pDrawObj = rMrkList.GetMark(i)->GetMarkedSdrObj();
435 0 : if( pDrawObj )
436 0 : aDrawObjs.push_back( pDrawObj );
437 : }
438 : }
439 : // loop on marked drawing objects
440 0 : while ( !aDrawObjs.empty() )
441 : {
442 0 : SdrObject* pDrawObj = aDrawObjs.back();
443 0 : if ( !pDrawObj->ISA(SwVirtFlyDrawObj) &&
444 0 : !pDrawObj->ISA(SwFlyDrawObj) )
445 : {
446 : SwFlyFrameFormat *pFormat =
447 0 : GetDoc()->InsertDrawLabel( rText, rSeparator, rNumberSeparator, nId, rCharacterStyle, *pDrawObj );
448 0 : if( !pFlyFormat )
449 0 : pFlyFormat = pFormat;
450 : }
451 :
452 0 : aDrawObjs.pop_back();
453 : }
454 :
455 0 : EndUndo();
456 : }
457 0 : break;
458 : default:
459 : OSL_ENSURE( false, "Crsr neither in table nor in fly." );
460 : }
461 :
462 0 : if( nIdx )
463 : pFlyFormat = GetDoc()->InsertLabel( eType, rText, rSeparator, rNumberSeparator, bBefore, nId,
464 0 : nIdx, rCharacterStyle, bCpyBrd );
465 :
466 : SwFlyFrm* pFrm;
467 0 : const Point aPt( GetCrsrDocPos() );
468 0 : if( pFlyFormat && 0 != ( pFrm = pFlyFormat->GetFrm( &aPt )))
469 0 : SelectFlyFrm( *pFrm, true );
470 :
471 0 : EndAllActionAndCall();
472 : }
473 0 : }
474 :
475 0 : bool SwFEShell::Sort(const SwSortOptions& rOpt)
476 : {
477 0 : if( !HasSelection() )
478 0 : return false;
479 :
480 0 : SET_CURR_SHELL( this );
481 0 : bool bRet = false;
482 0 : StartAllAction();
483 0 : if(IsTableMode())
484 : {
485 : // Sort table
486 : // check if Point/Mark of current Crsr are in one table
487 0 : SwFrm *pFrm = GetCurrFrm( false );
488 : OSL_ENSURE( pFrm->FindTabFrm(), "Crsr not in table." );
489 :
490 : // search boxes via the layout
491 0 : SwSelBoxes aBoxes;
492 0 : GetTableSel(*this, aBoxes);
493 :
494 : // The Crsr should be removed from the deletion area.
495 : // Always put them behind/on the table; via the
496 : // document position they will always be set to the old position
497 0 : while( !pFrm->IsCellFrm() )
498 0 : pFrm = pFrm->GetUpper();
499 : {
500 : /* ParkCursor->ParkCursorTab */
501 0 : ParkCursorInTab();
502 : }
503 :
504 : // call sorting on document
505 0 : bRet = mpDoc->SortTable(aBoxes, rOpt);
506 : }
507 : else
508 : {
509 : // Sort text nothing else
510 0 : for(SwPaM& rPaM : GetCrsr()->GetRingContainer())
511 : {
512 0 : SwPaM* pPam = &rPaM;
513 :
514 0 : SwPosition* pStart = pPam->Start();
515 0 : SwPosition* pEnd = pPam->End();
516 :
517 0 : SwNodeIndex aPrevIdx( pStart->nNode, -1 );
518 0 : sal_uLong nOffset = pEnd->nNode.GetIndex() - pStart->nNode.GetIndex();
519 0 : const sal_Int32 nCntStt = pStart->nContent.GetIndex();
520 :
521 : // Sorting
522 0 : bRet = mpDoc->SortText(*pPam, rOpt);
523 :
524 : // put selection again
525 0 : pPam->DeleteMark();
526 0 : pPam->GetPoint()->nNode.Assign( aPrevIdx.GetNode(), +1 );
527 0 : SwContentNode* pCNd = pPam->GetContentNode();
528 0 : sal_Int32 nLen = pCNd->Len();
529 0 : if( nLen > nCntStt )
530 0 : nLen = nCntStt;
531 0 : pPam->GetPoint()->nContent.Assign(pCNd, nLen );
532 0 : pPam->SetMark();
533 :
534 0 : pPam->GetPoint()->nNode += nOffset;
535 0 : pCNd = pPam->GetContentNode();
536 0 : pPam->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
537 0 : }
538 : }
539 :
540 0 : EndAllAction();
541 0 : return bRet;
542 : }
543 :
544 0 : sal_uInt16 SwFEShell::_GetCurColNum( const SwFrm *pFrm,
545 : SwGetCurColNumPara* pPara ) const
546 : {
547 0 : sal_uInt16 nRet = 0;
548 0 : while ( pFrm )
549 : {
550 0 : pFrm = pFrm->GetUpper();
551 0 : if( pFrm && pFrm->IsColumnFrm() )
552 : {
553 0 : const SwFrm *pCurFrm = pFrm;
554 0 : do {
555 0 : ++nRet;
556 0 : pFrm = pFrm->GetPrev();
557 : } while ( pFrm );
558 :
559 0 : if( pPara )
560 : {
561 : // now search the format, determining the columness
562 0 : pFrm = pCurFrm->GetUpper();
563 0 : while( pFrm )
564 : {
565 0 : if( ( FRM_PAGE | FRM_FLY | FRM_SECTION ) & pFrm->GetType() )
566 : {
567 0 : pPara->pFrameFormat = static_cast<const SwLayoutFrm*>(pFrm)->GetFormat();
568 0 : pPara->pPrtRect = &pFrm->Prt();
569 0 : pPara->pFrmRect = &pFrm->Frm();
570 0 : break;
571 : }
572 0 : pFrm = pFrm->GetUpper();
573 : }
574 0 : if( !pFrm )
575 : {
576 0 : pPara->pFrameFormat = 0;
577 0 : pPara->pPrtRect = 0;
578 0 : pPara->pFrmRect = 0;
579 : }
580 : }
581 0 : break;
582 : }
583 : }
584 0 : return nRet;
585 : }
586 :
587 0 : sal_uInt16 SwFEShell::GetCurColNum( SwGetCurColNumPara* pPara ) const
588 : {
589 : OSL_ENSURE( GetCurrFrm(), "Crsr parked?" );
590 0 : return _GetCurColNum( GetCurrFrm(), pPara );
591 : }
592 :
593 0 : sal_uInt16 SwFEShell::GetCurOutColNum( SwGetCurColNumPara* pPara ) const
594 : {
595 0 : sal_uInt16 nRet = 0;
596 0 : SwFrm* pFrm = GetCurrFrm();
597 : OSL_ENSURE( pFrm, "Crsr parked?" );
598 0 : if( pFrm )
599 : {
600 0 : pFrm = pFrm->IsInTab() ? static_cast<SwFrm*>(pFrm->FindTabFrm())
601 0 : : static_cast<SwFrm*>(pFrm->FindSctFrm());
602 : OSL_ENSURE( pFrm, "No Tab, no Sect" );
603 0 : if( pFrm )
604 0 : nRet = _GetCurColNum( pFrm, pPara );
605 : }
606 0 : return nRet;
607 : }
608 :
609 2761 : SwFEShell::SwFEShell( SwDoc& rDoc, vcl::Window *pWindow, const SwViewOption *pOptions )
610 : : SwEditShell( rDoc, pWindow, pOptions )
611 2761 : , m_bCheckForOLEInCaption(false)
612 : {
613 2761 : }
614 :
615 0 : SwFEShell::SwFEShell( SwEditShell& rShell, vcl::Window *pWindow )
616 : : SwEditShell( rShell, pWindow )
617 0 : , m_bCheckForOLEInCaption(false)
618 : {
619 0 : }
620 :
621 2757 : SwFEShell::~SwFEShell()
622 : {
623 2757 : }
624 :
625 : // #i17567# - adjustments for allowing
626 : // negative vertical positions for fly frames anchored to paragraph/to character.
627 : // #i22305# - adjustments for option 'Follow text flow'
628 : // for to frame anchored objects.
629 : // #i22341# - adjustments for vertical alignment at top of line
630 : // for to character anchored objects.
631 0 : void SwFEShell::CalcBoundRect( SwRect& _orRect,
632 : const RndStdIds _nAnchorId,
633 : const sal_Int16 _eHoriRelOrient,
634 : const sal_Int16 _eVertRelOrient,
635 : const SwPosition* _pToCharContentPos,
636 : const bool _bFollowTextFlow,
637 : bool _bMirror,
638 : Point* _opRef,
639 : Size* _opPercent,
640 : const SwFormatFrmSize* pFormatFrmSize) const
641 : {
642 : const SwFrm* pFrm;
643 : const SwFlyFrm* pFly;
644 0 : if( _opRef )
645 : {
646 0 : pFrm = GetCurrFrm();
647 0 : if( 0 != ( pFly = pFrm->FindFlyFrm() ) )
648 0 : pFrm = pFly->GetAnchorFrm();
649 : }
650 : else
651 : {
652 0 : pFly = FindFlyFrm();
653 0 : pFrm = pFly ? pFly->GetAnchorFrm() : GetCurrFrm();
654 : }
655 :
656 0 : bool bWrapThrough = false;
657 0 : if ( pFly )
658 : {
659 0 : SwFlyFrameFormat* pFormat = const_cast<SwFlyFrameFormat*>(pFly->GetFormat());
660 0 : const SwFormatSurround& rSurround = pFormat->GetSurround();
661 0 : bWrapThrough = rSurround.GetSurround() == SURROUND_THROUGHT;
662 : }
663 :
664 0 : const SwPageFrm* pPage = pFrm->FindPageFrm();
665 0 : _bMirror = _bMirror && !pPage->OnRightPage();
666 :
667 0 : Point aPos;
668 0 : bool bVertic = false;
669 0 : bool bRTL = false;
670 0 : bool bVerticalL2R = false;
671 :
672 0 : if ((FLY_AT_PAGE == _nAnchorId) || (FLY_AT_FLY == _nAnchorId)) // LAYER_IMPL
673 : {
674 0 : const SwFrm* pTmp = pFrm;
675 : // #i22305#
676 0 : if ((FLY_AT_PAGE == _nAnchorId) ||
677 0 : ((FLY_AT_FLY == _nAnchorId) && !_bFollowTextFlow))
678 : {
679 0 : pFrm = pPage;
680 : }
681 : else
682 : {
683 0 : pFrm = pFrm->FindFlyFrm();
684 : }
685 0 : if ( !pFrm )
686 0 : pFrm = pTmp;
687 0 : _orRect = pFrm->Frm();
688 0 : SWRECTFN( pFrm )
689 0 : bRTL = pFrm->IsRightToLeft();
690 0 : if ( bRTL )
691 0 : aPos = pFrm->Frm().TopRight();
692 : else
693 0 : aPos = (pFrm->Frm().*fnRect->fnGetPos)();
694 :
695 0 : if( bVert || bVertL2R )
696 : {
697 0 : bVertic = bVert;
698 0 : bVerticalL2R = bVertL2R;
699 0 : _bMirror = false; // no mirroring in vertical environment
700 0 : switch ( _eHoriRelOrient )
701 : {
702 : case text::RelOrientation::PAGE_RIGHT:
703 0 : case text::RelOrientation::FRAME_RIGHT: aPos.Y() += pFrm->Prt().Height();
704 : // no break!
705 : case text::RelOrientation::PRINT_AREA:
706 0 : case text::RelOrientation::PAGE_PRINT_AREA: aPos.Y() += pFrm->Prt().Top(); break;
707 0 : default: break;
708 : }
709 : }
710 0 : else if ( _bMirror )
711 : {
712 0 : switch ( _eHoriRelOrient )
713 : {
714 : case text::RelOrientation::PRINT_AREA:
715 0 : case text::RelOrientation::PAGE_PRINT_AREA: aPos.X() += pFrm->Prt().Width();
716 : // no break
717 : case text::RelOrientation::PAGE_RIGHT:
718 0 : case text::RelOrientation::FRAME_RIGHT: aPos.X() += pFrm->Prt().Left(); break;
719 0 : default: aPos.X() += pFrm->Frm().Width();
720 : }
721 : }
722 0 : else if ( bRTL )
723 : {
724 0 : switch ( _eHoriRelOrient )
725 : {
726 : case text::RelOrientation::PRINT_AREA:
727 0 : case text::RelOrientation::PAGE_PRINT_AREA: aPos.X() += pFrm->Prt().Width();
728 : // no break!
729 : case text::RelOrientation::PAGE_LEFT:
730 0 : case text::RelOrientation::FRAME_LEFT: aPos.X() += pFrm->Prt().Left() -
731 0 : pFrm->Frm().Width(); break;
732 0 : default: break;
733 : }
734 : }
735 : else
736 : {
737 0 : switch ( _eHoriRelOrient )
738 : {
739 : case text::RelOrientation::PAGE_RIGHT:
740 0 : case text::RelOrientation::FRAME_RIGHT: aPos.X() += pFrm->Prt().Width();
741 : // no break!
742 : case text::RelOrientation::PRINT_AREA:
743 0 : case text::RelOrientation::PAGE_PRINT_AREA: aPos.X() += pFrm->Prt().Left(); break;
744 0 : default:break;
745 : }
746 : }
747 :
748 0 : if ( bVert && !bVertL2R )
749 : {
750 0 : switch ( _eVertRelOrient )
751 : {
752 : case text::RelOrientation::PRINT_AREA:
753 : case text::RelOrientation::PAGE_PRINT_AREA:
754 : {
755 0 : aPos.X() -= pFrm->GetRightMargin();
756 : }
757 0 : break;
758 : }
759 : }
760 0 : else if ( bVertL2R )
761 : {
762 0 : switch ( _eVertRelOrient )
763 : {
764 : case text::RelOrientation::PRINT_AREA:
765 : case text::RelOrientation::PAGE_PRINT_AREA:
766 : {
767 0 : aPos.X() += pFrm->GetLeftMargin();
768 : }
769 0 : break;
770 : }
771 : }
772 : else
773 : {
774 0 : switch ( _eVertRelOrient )
775 : {
776 : case text::RelOrientation::PRINT_AREA:
777 : case text::RelOrientation::PAGE_PRINT_AREA:
778 : {
779 0 : if ( pFrm->IsPageFrm() )
780 : {
781 0 : aPos.Y() =
782 0 : static_cast<const SwPageFrm*>(pFrm)->PrtWithoutHeaderAndFooter().Top();
783 : }
784 : else
785 : {
786 0 : aPos.Y() += pFrm->Prt().Top();
787 : }
788 : }
789 0 : break;
790 : }
791 : }
792 0 : if ( _opPercent )
793 0 : *_opPercent = pFrm->Prt().SSize();
794 : }
795 : else
796 : {
797 0 : const SwFrm* pUpper = ( pFrm->IsPageFrm() || pFrm->IsFlyFrm() ) ?
798 0 : pFrm : pFrm->GetUpper();
799 0 : SWRECTFN( pUpper );
800 0 : if ( _opPercent )
801 : {
802 : // If the size is relative from page, then full size should be counted from the page frame.
803 0 : if (pFormatFrmSize && pFormatFrmSize->GetWidthPercentRelation() == text::RelOrientation::PAGE_FRAME)
804 0 : _opPercent->setWidth(pPage->Frm().Width());
805 : else
806 0 : _opPercent->setWidth(pUpper->Prt().Width());
807 :
808 0 : if (pFormatFrmSize && pFormatFrmSize->GetHeightPercentRelation() == text::RelOrientation::PAGE_FRAME)
809 : // If the size is relative from page, then full size should be counted from the page frame.
810 0 : _opPercent->setHeight(pPage->Frm().Height());
811 : else
812 0 : _opPercent->setHeight(pUpper->Prt().Height());
813 : }
814 :
815 0 : bRTL = pFrm->IsRightToLeft();
816 0 : if ( bRTL )
817 0 : aPos = pFrm->Frm().TopRight();
818 : else
819 0 : aPos = (pFrm->Frm().*fnRect->fnGetPos)();
820 : // #i17567# - allow negative positions
821 : // for fly frames anchor to paragraph/to character.
822 0 : if ((_nAnchorId == FLY_AT_PARA) || (_nAnchorId == FLY_AT_CHAR))
823 : {
824 : // The rectangle, the fly frame can be positioned in, is determined
825 : // horizontally by the frame area of the horizontal environment
826 : // and vertically by the printing area of the vertical environment,
827 : // if the object follows the text flow, or by the frame area of the
828 : // vertical environment, if the object doesn't follow the text flow.
829 : // new class <SwEnvironmentOfAnchoredObject>
830 : objectpositioning::SwEnvironmentOfAnchoredObject aEnvOfObj(
831 0 : _bFollowTextFlow );
832 : const SwLayoutFrm& rHoriEnvironLayFrm =
833 0 : aEnvOfObj.GetHoriEnvironmentLayoutFrm( *pFrm );
834 : const SwLayoutFrm& rVertEnvironLayFrm =
835 0 : aEnvOfObj.GetVertEnvironmentLayoutFrm( *pFrm );
836 0 : SwRect aHoriEnvironRect( rHoriEnvironLayFrm.Frm() );
837 0 : SwRect aVertEnvironRect;
838 0 : if ( _bFollowTextFlow )
839 : {
840 0 : aVertEnvironRect = rVertEnvironLayFrm.Prt();
841 0 : aVertEnvironRect.Pos() += rVertEnvironLayFrm.Frm().Pos();
842 : // #i18732# - adjust vertical 'virtual' anchor position
843 : // (<aPos.Y()> respectively <aPos.X()>), if object is vertical aligned
844 : // to page areas.
845 0 : if ( _eVertRelOrient == text::RelOrientation::PAGE_FRAME || _eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA )
846 : {
847 0 : if ( bVert && !bVertL2R )
848 : {
849 0 : aPos.X() = aVertEnvironRect.Right();
850 : }
851 0 : else if ( bVertL2R )
852 : {
853 0 : aPos.X() = aVertEnvironRect.Left();
854 : }
855 : else
856 : {
857 0 : aPos.Y() = aVertEnvironRect.Top();
858 : }
859 : }
860 : }
861 : else
862 : {
863 : OSL_ENSURE( rVertEnvironLayFrm.IsPageFrm(),
864 : "<SwFEShell::CalcBoundRect(..)> - not following text flow, but vertical environment *not* page!" );
865 0 : aVertEnvironRect = rVertEnvironLayFrm.Frm();
866 : // #i18732# - adjustment vertical 'virtual' anchor position
867 : // (<aPos.Y()> respectively <aPos.X()>), if object is vertical aligned
868 : // to page areas.
869 0 : if ( _eVertRelOrient == text::RelOrientation::PAGE_FRAME || _eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA )
870 : {
871 0 : if ( bVert && !bVertL2R )
872 : {
873 0 : aPos.X() = aVertEnvironRect.Right();
874 0 : if ( _eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA )
875 : {
876 0 : aPos.setX(aPos.getX() - rVertEnvironLayFrm.GetRightMargin());
877 : }
878 : }
879 0 : else if ( bVertL2R )
880 : {
881 0 : aPos.X() = aVertEnvironRect.Left();
882 0 : if ( _eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA )
883 : {
884 0 : aPos.setX(aPos.getX() + rVertEnvironLayFrm.GetLeftMargin());
885 : }
886 : }
887 : else
888 : {
889 0 : aPos.Y() = aVertEnvironRect.Top();
890 0 : if ( _eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA )
891 : {
892 0 : aPos.setY(aPos.getY() + rVertEnvironLayFrm.GetTopMargin());
893 : // add height of page header
894 0 : const SwFrm* pTmpFrm = rVertEnvironLayFrm.Lower();
895 0 : if ( pTmpFrm->IsHeaderFrm() )
896 : {
897 0 : aPos.setY(aPos.getY() + pTmpFrm->Frm().Height());
898 : }
899 : }
900 : }
901 : }
902 : }
903 :
904 : // #i22341# - adjust vertical 'virtual' anchor position
905 : // (<aPos.Y()> respectively <aPos.X()>), if object is anchored to
906 : // character and vertical aligned at character or top of line
907 : // <pFrm>, which is the anchor frame or the proposed anchor frame,
908 : // doesn't have to be a text frame (e.g. edit a to-page anchored
909 : // fly frame). Thus, assure this.
910 0 : const SwTextFrm* pTextFrm( dynamic_cast<const SwTextFrm*>(pFrm) );
911 0 : if ( pTextFrm &&
912 0 : (_nAnchorId == FLY_AT_CHAR) &&
913 0 : ( _eVertRelOrient == text::RelOrientation::CHAR ||
914 : _eVertRelOrient == text::RelOrientation::TEXT_LINE ) )
915 : {
916 0 : SwTwips nTop = 0L;
917 0 : if ( _eVertRelOrient == text::RelOrientation::CHAR )
918 : {
919 0 : SwRect aChRect;
920 0 : if ( _pToCharContentPos )
921 : {
922 0 : pTextFrm->GetAutoPos( aChRect, *_pToCharContentPos );
923 : }
924 : else
925 : {
926 : // No content position provided. Thus, use a default one.
927 0 : SwPosition aDefaultContentPos( *(pTextFrm->GetTextNode()) );
928 0 : pTextFrm->GetAutoPos( aChRect, aDefaultContentPos );
929 : }
930 0 : nTop = (aChRect.*fnRect->fnGetBottom)();
931 : }
932 : else
933 : {
934 0 : if ( _pToCharContentPos )
935 : {
936 0 : pTextFrm->GetTopOfLine( nTop, *_pToCharContentPos );
937 : }
938 : else
939 : {
940 : // No content position provided. Thus, use a default one.
941 0 : SwPosition aDefaultContentPos( *(pTextFrm->GetTextNode()) );
942 0 : pTextFrm->GetTopOfLine( nTop, aDefaultContentPos );
943 : }
944 : }
945 0 : if ( bVert || bVertL2R )
946 : {
947 0 : aPos.setX(nTop);
948 : }
949 : else
950 : {
951 0 : aPos.setY(nTop);
952 : }
953 : }
954 :
955 : // #i26945# - adjust horizontal 'virtual' anchor
956 : // position (<aPos.X()> respectively <aPos.Y()>), if object is
957 : // anchored to character and horizontal aligned at character.
958 0 : if ( pTextFrm &&
959 0 : (_nAnchorId == FLY_AT_CHAR) &&
960 : _eHoriRelOrient == text::RelOrientation::CHAR )
961 : {
962 0 : SwTwips nLeft = 0L;
963 0 : SwRect aChRect;
964 0 : if ( _pToCharContentPos )
965 : {
966 0 : pTextFrm->GetAutoPos( aChRect, *_pToCharContentPos );
967 : }
968 : else
969 : {
970 : // No content position provided. Thus, use a default one.
971 0 : SwPosition aDefaultContentPos( *(pTextFrm->GetTextNode()) );
972 0 : pTextFrm->GetAutoPos( aChRect, aDefaultContentPos );
973 : }
974 0 : nLeft = (aChRect.*fnRect->fnGetLeft)();
975 0 : if ( bVert || bVertL2R )
976 : {
977 0 : aPos.setY(nLeft);
978 : }
979 : else
980 : {
981 0 : aPos.setX(nLeft);
982 : }
983 : }
984 0 : if ( bVert || bVertL2R )
985 : {
986 0 : _orRect = SwRect( aVertEnvironRect.Left(),
987 : aHoriEnvironRect.Top(),
988 : aVertEnvironRect.Width(),
989 0 : aHoriEnvironRect.Height() );
990 : }
991 : else
992 : {
993 0 : _orRect = SwRect( aHoriEnvironRect.Left(),
994 : aVertEnvironRect.Top(),
995 : aHoriEnvironRect.Width(),
996 0 : aVertEnvironRect.Height() );
997 0 : }
998 : }
999 : else
1000 : {
1001 0 : if( _opRef && pFly && pFly->IsFlyInCntFrm() )
1002 0 : *_opRef = static_cast<const SwFlyInCntFrm*>( pFly )->GetRefPoint();
1003 :
1004 0 : _orRect = pUpper->Frm();
1005 0 : if( !pUpper->IsBodyFrm() )
1006 : {
1007 0 : _orRect += pUpper->Prt().Pos();
1008 0 : _orRect.SSize( pUpper->Prt().SSize() );
1009 0 : if ( pUpper->IsCellFrm() )//MA_FLY_HEIGHT
1010 : {
1011 0 : const SwFrm* pTab = pUpper->FindTabFrm();
1012 0 : long nBottom = (pTab->GetUpper()->*fnRect->fnGetPrtBottom)();
1013 0 : (_orRect.*fnRect->fnSetBottom)( nBottom );
1014 : }
1015 : }
1016 : // only use 90% of height for character bound
1017 : {
1018 0 : if( bVert || bVertL2R )
1019 0 : _orRect.Width( (_orRect.Width()*9)/10 );
1020 : else
1021 0 : _orRect.Height( (_orRect.Height()*9)/10 );
1022 : }
1023 : }
1024 :
1025 0 : const SwTwips nBaseOfstForFly = ( pFrm->IsTextFrm() && pFly ) ?
1026 0 : static_cast<const SwTextFrm*>(pFrm)->GetBaseOfstForFly( !bWrapThrough ) :
1027 0 : 0;
1028 0 : if( bVert || bVertL2R )
1029 : {
1030 0 : bVertic = bVert;
1031 0 : bVerticalL2R = bVertL2R;
1032 0 : _bMirror = false;
1033 :
1034 0 : switch ( _eHoriRelOrient )
1035 : {
1036 : case text::RelOrientation::FRAME_RIGHT:
1037 : {
1038 0 : aPos.setY(aPos.getY() + pFrm->Prt().Height());
1039 0 : aPos += (pFrm->Prt().*fnRect->fnGetPos)();
1040 0 : break;
1041 : }
1042 : case text::RelOrientation::PRINT_AREA:
1043 : {
1044 0 : aPos += (pFrm->Prt().*fnRect->fnGetPos)();
1045 0 : aPos.setY(aPos.getY() + nBaseOfstForFly);
1046 0 : break;
1047 : }
1048 : case text::RelOrientation::PAGE_RIGHT:
1049 : {
1050 0 : aPos.setY(pPage->Frm().Top() + pPage->Prt().Bottom());
1051 0 : break;
1052 : }
1053 : case text::RelOrientation::PAGE_PRINT_AREA:
1054 : {
1055 0 : aPos.setY(pPage->Frm().Top() + pPage->Prt().Top());
1056 0 : break;
1057 : }
1058 : case text::RelOrientation::PAGE_LEFT:
1059 : case text::RelOrientation::PAGE_FRAME:
1060 : {
1061 0 : aPos.setY(pPage->Frm().Top());
1062 0 : break;
1063 : }
1064 : case text::RelOrientation::FRAME:
1065 : {
1066 0 : aPos.setY(aPos.getY() + nBaseOfstForFly);
1067 0 : break;
1068 : }
1069 0 : default: break;
1070 : }
1071 : }
1072 0 : else if( _bMirror )
1073 : {
1074 0 : switch ( _eHoriRelOrient )
1075 : {
1076 0 : case text::RelOrientation::FRAME_RIGHT: aPos.setX(aPos.getX() + pFrm->Prt().Left()); break;
1077 : case text::RelOrientation::FRAME:
1078 0 : case text::RelOrientation::FRAME_LEFT: aPos.setX(aPos.getX() + pFrm->Frm().Width()); break;
1079 0 : case text::RelOrientation::PRINT_AREA: aPos.setX(aPos.getX() + pFrm->Prt().Right()); break;
1080 : case text::RelOrientation::PAGE_LEFT:
1081 0 : case text::RelOrientation::PAGE_FRAME: aPos.setX(pPage->Frm().Right()); break;
1082 0 : case text::RelOrientation::PAGE_PRINT_AREA: aPos.setX(pPage->Frm().Left()
1083 0 : + pPage->Prt().Left()); break;
1084 0 : default: break;
1085 : }
1086 : }
1087 0 : else if ( bRTL )
1088 : {
1089 0 : switch ( _eHoriRelOrient )
1090 : {
1091 : case text::RelOrientation::FRAME_LEFT:
1092 0 : aPos.setX(pFrm->Frm().Left() +
1093 0 : pFrm->Prt().Left());
1094 0 : break;
1095 :
1096 : case text::RelOrientation::PRINT_AREA:
1097 0 : aPos.setX(pFrm->Frm().Left() + pFrm->Prt().Left() +
1098 0 : pFrm->Prt().Width());
1099 0 : aPos.setX(aPos.getX() + nBaseOfstForFly);
1100 0 : break;
1101 :
1102 : case text::RelOrientation::PAGE_LEFT:
1103 0 : aPos.setX(pPage->Frm().Left() + pPage->Prt().Left());
1104 0 : break;
1105 :
1106 : case text::RelOrientation::PAGE_PRINT_AREA:
1107 0 : aPos.setX(pPage->Frm().Left() + pPage->Prt().Left() +
1108 0 : pPage->Prt().Width());
1109 0 : break;
1110 :
1111 : case text::RelOrientation::PAGE_RIGHT:
1112 : case text::RelOrientation::PAGE_FRAME:
1113 0 : aPos.setX(pPage->Frm().Right());
1114 0 : break;
1115 :
1116 : case text::RelOrientation::FRAME:
1117 0 : aPos.setX(aPos.getX() + nBaseOfstForFly);
1118 0 : break;
1119 0 : default: break;
1120 : }
1121 : }
1122 : else
1123 : {
1124 0 : switch ( _eHoriRelOrient )
1125 : {
1126 : case text::RelOrientation::FRAME_RIGHT:
1127 0 : aPos.X() += pFrm->Prt().Width();
1128 0 : aPos += pFrm->Prt().Pos();
1129 0 : break;
1130 : case text::RelOrientation::PRINT_AREA:
1131 0 : aPos += pFrm->Prt().Pos();
1132 0 : aPos.setX(aPos.getX() + nBaseOfstForFly);
1133 0 : break;
1134 : case text::RelOrientation::PAGE_RIGHT:
1135 0 : aPos.setX(pPage->Frm().Left() + pPage->Prt().Right());
1136 0 : break;
1137 : case text::RelOrientation::PAGE_PRINT_AREA:
1138 0 : aPos.setX(pPage->Frm().Left() + pPage->Prt().Left());
1139 0 : break;
1140 : case text::RelOrientation::PAGE_LEFT:
1141 : case text::RelOrientation::PAGE_FRAME:
1142 0 : aPos.setX(pPage->Frm().Left());
1143 0 : break;
1144 : case text::RelOrientation::FRAME:
1145 0 : aPos.setX(aPos.getX() + nBaseOfstForFly);
1146 0 : break;
1147 0 : default: break;
1148 : }
1149 : }
1150 :
1151 : }
1152 0 : if( !_opRef )
1153 : {
1154 0 : if( bVertic && !bVerticalL2R )
1155 0 : _orRect.Pos( aPos.getX() - _orRect.Width() - _orRect.Left(), _orRect.Top() - aPos.getY() );
1156 0 : else if( bVerticalL2R )
1157 0 : _orRect.Pos( _orRect.Left() - aPos.getX(), _orRect.Top() - aPos.getY() );
1158 0 : else if ( bRTL )
1159 0 : _orRect.Pos( - ( _orRect.Right() - aPos.getX() ), _orRect.Top() - aPos.getY() );
1160 : else
1161 0 : _orRect.Pos( _orRect.Left() - aPos.getX(), _orRect.Top() - aPos.getY() );
1162 0 : if( _bMirror )
1163 0 : _orRect.Pos( -_orRect.Right(), _orRect.Top() );
1164 : }
1165 0 : }
1166 :
1167 0 : Size SwFEShell::GetGraphicDefaultSize() const
1168 : {
1169 0 : Size aRet;
1170 0 : SwFlyFrm *pFly = FindFlyFrm();
1171 0 : if ( pFly )
1172 : {
1173 : // #i32951# - due to issue #i28701# no format of a
1174 : // newly inserted Writer fly frame or its anchor frame is performed
1175 : // any more. Thus, it could be possible (e.g. on insert of a horizontal
1176 : // line) that the anchor frame isn't formatted and its printing area
1177 : // size is (0,0). If this is the case the printing area of the upper
1178 : // of the anchor frame is taken.
1179 0 : const SwFrm* pAnchorFrm = pFly->GetAnchorFrm();
1180 0 : aRet = pAnchorFrm->Prt().SSize();
1181 0 : if ( aRet.Width() == 0 && aRet.Height() == 0 &&
1182 0 : pAnchorFrm->GetUpper() )
1183 : {
1184 0 : aRet = pAnchorFrm->GetUpper()->Prt().SSize();
1185 : }
1186 :
1187 0 : SwRect aBound;
1188 0 : CalcBoundRect( aBound, pFly->GetFormat()->GetAnchor().GetAnchorId());
1189 0 : if ( pFly->GetAnchorFrm()->IsVertical() )
1190 0 : aRet.Width() = aBound.Width();
1191 : else
1192 0 : aRet.Height() = aBound.Height();
1193 : }
1194 0 : return aRet;
1195 : }
1196 :
1197 2262 : bool SwFEShell::IsFrmVertical(const bool bEnvironment, bool& bRTL, bool& bVertL2R) const
1198 : {
1199 2262 : bool bVert = false;
1200 2262 : bRTL = false;
1201 2262 : bVertL2R = false;
1202 :
1203 2262 : if ( Imp()->HasDrawView() )
1204 : {
1205 2262 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
1206 2262 : if( rMrkList.GetMarkCount() != 1 )
1207 2262 : return bVert;
1208 :
1209 0 : SdrObject* pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
1210 0 : if ( !pObj )
1211 : {
1212 : OSL_FAIL( "<SwFEShell::IsFrmVertical(..)> - missing SdrObject instance in marked object list -> This is a serious situation, please inform OD" );
1213 0 : return bVert;
1214 : }
1215 : // #i26791#
1216 0 : SwContact* pContact = static_cast<SwContact*>(GetUserCall( pObj ));
1217 0 : if ( !pContact )
1218 : {
1219 : OSL_FAIL( "<SwFEShell::IsFrmVertical(..)> - missing SwContact instance at marked object -> This is a serious situation, please inform OD" );
1220 0 : return bVert;
1221 : }
1222 0 : const SwFrm* pRef = pContact->GetAnchoredObj( pObj )->GetAnchorFrm();
1223 0 : if ( !pRef )
1224 : {
1225 : OSL_FAIL( "<SwFEShell::IsFrmVertical(..)> - missing anchor frame at marked object -> This is a serious situation, please inform OD" );
1226 0 : return bVert;
1227 : }
1228 :
1229 0 : if ( pObj->ISA(SwVirtFlyDrawObj) && !bEnvironment )
1230 0 : pRef = static_cast<const SwVirtFlyDrawObj*>(pObj)->GetFlyFrm();
1231 :
1232 0 : bVert = pRef->IsVertical();
1233 0 : bRTL = pRef->IsRightToLeft();
1234 0 : bVertL2R = pRef->IsVertLR();
1235 : }
1236 :
1237 0 : return bVert;
1238 : }
1239 :
1240 0 : void SwFEShell::MoveObjectIfActive( svt::EmbeddedObjectRef&, const Point& )
1241 : {
1242 : // does not do anything, only avoids crash if the method is used for wrong shell
1243 0 : }
1244 :
1245 0 : void SwFEShell::ToggleHeaderFooterEdit()
1246 : {
1247 : // Clear objects selection
1248 0 : if ( Imp()->GetDrawView()->AreObjectsMarked() )
1249 : {
1250 0 : Imp()->GetDrawView()->UnmarkAll();
1251 0 : ClearMark();
1252 : }
1253 :
1254 0 : SwCrsrShell::ToggleHeaderFooterEdit();
1255 177 : }
1256 :
1257 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
