Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <svl/itemiter.hxx>
22 : #include <svtools/imapobj.hxx>
23 : #include <svtools/soerr.hxx>
24 : #include <editeng/protitem.hxx>
25 : #include <svx/svdogrp.hxx>
26 : #include <svx/svdouno.hxx>
27 : #include <svx/fmglob.hxx>
28 : #include <com/sun/star/form/FormButtonType.hpp>
29 : #include <com/sun/star/beans/XPropertySet.hpp>
30 : #include <fmtanchr.hxx>
31 : #include <txtflcnt.hxx>
32 : #include <fmtcntnt.hxx>
33 : #include <fmtornt.hxx>
34 : #include <fmtflcnt.hxx>
35 : #include <fmturl.hxx>
36 : #include <fmtclds.hxx>
37 : #include <fmtfsize.hxx>
38 : #include <docary.hxx>
39 : #include <fesh.hxx>
40 : #include <rootfrm.hxx>
41 : #include <pagefrm.hxx>
42 : #include <cntfrm.hxx>
43 : #include <txtfrm.hxx>
44 : #include <viewimp.hxx>
45 : #include <viscrs.hxx>
46 : #include <doc.hxx>
47 : #include <IDocumentUndoRedo.hxx>
48 : #include <dview.hxx>
49 : #include <dflyobj.hxx>
50 : #include <dcontact.hxx>
51 : #include <frmfmt.hxx>
52 : #include <flyfrm.hxx>
53 : #include <ndtxt.hxx>
54 : #include <edimp.hxx>
55 : #include <swtable.hxx>
56 : #include <mvsave.hxx>
57 : #include <ndgrf.hxx>
58 : #include <flyfrms.hxx>
59 : #include <flypos.hxx>
60 : #include <fldbas.hxx>
61 : #include <fmtfld.hxx>
62 : #include <swundo.hxx>
63 : #include <frame.hxx>
64 : #include <notxtfrm.hxx>
65 : #include <HandleAnchorNodeChg.hxx>
66 : #include <frmatr.hxx>
67 : #include <fmtsrnd.hxx>
68 : #include <ndole.hxx>
69 : #include <editeng/opaqitem.hxx>
70 :
71 : using namespace ::com::sun::star;
72 :
73 : // To register Flys in Flys in ...
74 : // as defined in layout/frmtool.cxx
75 : void RegistFlys( SwPageFrm*, const SwLayoutFrm* );
76 :
77 : /***********************************************************************
78 : #* Class : SwDoc
79 : #* Methode : UseSpzLayoutFmt
80 : #* Description : based on the request, changes to the specific layouts
81 : #* will be made, to fit to the format
82 : #***********************************************************************/
83 :
84 0 : static bool lcl_SetNewFlyPos( const SwNode& rNode, SwFmtAnchor& rAnchor,
85 : const Point& rPt )
86 : {
87 0 : bool bRet = false;
88 0 : const SwStartNode* pStNode = rNode.FindFlyStartNode();
89 0 : if( pStNode )
90 : {
91 0 : SwPosition aPos( *pStNode );
92 0 : rAnchor.SetAnchor( &aPos );
93 0 : bRet = true;
94 : }
95 : else
96 : {
97 0 : const SwCntntNode *pCntNd = rNode.GetCntntNode();
98 0 : const SwCntntFrm* pCFrm = pCntNd ? pCntNd->getLayoutFrm( pCntNd->GetDoc()->GetCurrentLayout(), &rPt, 0, false ) : 0;
99 0 : const SwPageFrm *pPg = pCFrm ? pCFrm->FindPageFrm() : 0;
100 :
101 0 : rAnchor.SetPageNum( pPg ? pPg->GetPhyPageNum() : 1 );
102 0 : rAnchor.SetType( FLY_AT_PAGE );
103 : }
104 0 : return bRet;
105 : }
106 :
107 0 : static sal_Bool lcl_FindAnchorPos(
108 : SwEditShell& rEditShell,
109 : SwDoc& rDoc,
110 : const Point& rPt,
111 : const SwFrm& rFrm,
112 : SfxItemSet& rSet )
113 : {
114 0 : sal_Bool bRet = sal_True;
115 0 : SwFmtAnchor aNewAnch( (SwFmtAnchor&)rSet.Get( RES_ANCHOR ) );
116 0 : RndStdIds nNew = aNewAnch.GetAnchorId();
117 : const SwFrm *pNewAnch;
118 :
119 : //determine new anchor
120 0 : Point aTmpPnt( rPt );
121 0 : switch( nNew )
122 : {
123 : case FLY_AS_CHAR: // also include this?
124 : case FLY_AT_PARA:
125 : case FLY_AT_CHAR: // LAYER_IMPL
126 : {
127 : // starting from the upper-left corner of the Fly,
128 : // search nearest CntntFrm
129 0 : const SwFrm* pFrm = rFrm.IsFlyFrm() ? ((SwFlyFrm&)rFrm).GetAnchorFrm()
130 0 : : &rFrm;
131 0 : pNewAnch = ::FindAnchor( pFrm, aTmpPnt );
132 0 : if( pNewAnch->IsProtected() )
133 : {
134 0 : bRet = sal_False;
135 0 : break;
136 : }
137 :
138 0 : SwPosition aPos( *((SwCntntFrm*)pNewAnch)->GetNode() );
139 0 : if ((FLY_AT_CHAR == nNew) || (FLY_AS_CHAR == nNew))
140 : {
141 : // textnode should be found, as only in those
142 : // a content bound frame can be anchored
143 0 : SwCrsrMoveState aState( MV_SETONLYTEXT );
144 0 : aTmpPnt.setX(aTmpPnt.getX() - 1); // do not land in the fly!
145 0 : if( !pNewAnch->GetCrsrOfst( &aPos, aTmpPnt, &aState ) )
146 : {
147 0 : SwCntntNode* pCNd = ((SwCntntFrm*)pNewAnch)->GetNode();
148 0 : if( pNewAnch->Frm().Bottom() < aTmpPnt.Y() )
149 0 : pCNd->MakeStartIndex( &aPos.nContent );
150 : else
151 0 : pCNd->MakeEndIndex( &aPos.nContent );
152 : }
153 : else
154 : {
155 0 : if ( rEditShell.PosInsideInputFld( aPos ) )
156 : {
157 0 : aPos.nContent = rEditShell.StartOfInputFldAtPos( aPos );
158 : }
159 : }
160 : }
161 0 : aNewAnch.SetAnchor( &aPos );
162 : }
163 0 : break;
164 :
165 : case FLY_AT_FLY: // LAYER_IMPL
166 : {
167 : // starting from the upper-left corner of the Fly
168 : // search nearest SwFlyFrm
169 0 : SwCrsrMoveState aState( MV_SETONLYTEXT );
170 0 : SwPosition aPos( rDoc.GetNodes() );
171 0 : aTmpPnt.setX(aTmpPnt.getX() - 1); // do not land in the fly!
172 0 : rDoc.GetCurrentLayout()->GetCrsrOfst( &aPos, aTmpPnt, &aState );
173 : pNewAnch = ::FindAnchor(
174 0 : aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( rFrm.getRootFrm(), 0, 0, false ),
175 0 : aTmpPnt )->FindFlyFrm();
176 :
177 0 : if( pNewAnch && &rFrm != pNewAnch && !pNewAnch->IsProtected() )
178 : {
179 0 : aPos.nNode = *((SwFlyFrm*)pNewAnch)->GetFmt()->GetCntnt().
180 0 : GetCntntIdx();
181 0 : aNewAnch.SetAnchor( &aPos );
182 0 : break;
183 0 : }
184 : }
185 :
186 0 : aNewAnch.SetType( nNew = FLY_AT_PAGE );
187 : // no break
188 :
189 : case FLY_AT_PAGE:
190 0 : pNewAnch = rFrm.FindPageFrm();
191 0 : aNewAnch.SetPageNum( pNewAnch->GetPhyPageNum() );
192 0 : break;
193 :
194 : default:
195 : OSL_ENSURE( !&rDoc, "Falsche ID fuer neuen Anker." );
196 : }
197 :
198 0 : rSet.Put( aNewAnch );
199 0 : return bRet;
200 : }
201 :
202 : //! also used in unoframe.cxx
203 :
204 0 : sal_Bool sw_ChkAndSetNewAnchor(
205 : SwEditShell& rEditShell,
206 : const SwFlyFrm& rFly,
207 : SfxItemSet& rSet )
208 : {
209 0 : const SwFrmFmt& rFmt = *rFly.GetFmt();
210 0 : const SwFmtAnchor &rOldAnch = rFmt.GetAnchor();
211 0 : const RndStdIds nOld = rOldAnch.GetAnchorId();
212 :
213 0 : RndStdIds nNew = ((SwFmtAnchor&)rSet.Get( RES_ANCHOR )).GetAnchorId();
214 :
215 0 : if( nOld == nNew )
216 0 : return sal_False;
217 :
218 0 : SwDoc* pDoc = (SwDoc*)rFmt.GetDoc();
219 :
220 : #if OSL_DEBUG_LEVEL > 0
221 : OSL_ENSURE( !(nNew == FLY_AT_PAGE &&
222 : (FLY_AT_PARA==nOld || FLY_AT_CHAR==nOld || FLY_AS_CHAR==nOld ) &&
223 : pDoc->IsInHeaderFooter( rOldAnch.GetCntntAnchor()->nNode )),
224 : "forbidden anchor change in Head/Foot." );
225 : #endif
226 :
227 0 : return ::lcl_FindAnchorPos( rEditShell, *pDoc, rFly.Frm().Pos(), rFly, rSet );
228 : }
229 :
230 0 : void SwFEShell::SelectFlyFrm( SwFlyFrm& rFrm, sal_Bool bNew )
231 : {
232 0 : SET_CURR_SHELL( this );
233 :
234 : // The frame is new, thus select it.
235 : // !! Always select the frame, if it's not selected.
236 : // - it could be a new "old" one because the anchor was changed
237 : // - "old" frames have had to be selected previously otherwise they could
238 : // not have been changed
239 : // The frames should not be selected by the document position, because
240 : // it should have been selected!
241 0 : SwViewImp *pImpl = Imp();
242 0 : if( GetWin() && (bNew || !pImpl->GetDrawView()->AreObjectsMarked()) )
243 : {
244 : OSL_ENSURE( rFrm.IsFlyFrm(), "SelectFlyFrm will einen Fly" );
245 :
246 : // nothing to be done if the Fly already was selected
247 0 : if ( FindFlyFrm() == &rFrm )
248 0 : return;
249 :
250 : // assure the anchor is drawn
251 0 : if( rFrm.IsFlyInCntFrm() && rFrm.GetAnchorFrm() )
252 0 : rFrm.GetAnchorFrm()->SetCompletePaint();
253 :
254 0 : if( pImpl->GetDrawView()->AreObjectsMarked() )
255 0 : pImpl->GetDrawView()->UnmarkAll();
256 :
257 0 : pImpl->GetDrawView()->MarkObj( rFrm.GetVirtDrawObj(),
258 0 : pImpl->GetPageView(), false, false );
259 0 : KillPams();
260 0 : ClearMark();
261 0 : SelFlyGrabCrsr();
262 0 : }
263 : }
264 :
265 : /*************************************************************************
266 : |*
267 : |* SwFEShell::FindFlyFrm()
268 : |*
269 : |* Description returns a Fly if one is selected
270 : |*
271 : *************************************************************************/
272 :
273 0 : SwFlyFrm *SwFEShell::FindFlyFrm() const
274 : {
275 0 : if ( Imp()->HasDrawView() )
276 : {
277 : // A Fly is only accessible if it is selected
278 0 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
279 0 : if( rMrkList.GetMarkCount() != 1 )
280 0 : return 0;
281 :
282 0 : SdrObject *pO = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
283 0 : return ( pO && pO->ISA(SwVirtFlyDrawObj) ) ? ((SwVirtFlyDrawObj*)pO)->GetFlyFrm() : 0;
284 : }
285 0 : return 0;
286 : }
287 :
288 : /*************************************************************************
289 : |*
290 : |* SwFEShell::IsFlyInFly()
291 : |*
292 : |* Description Returns sal_True, if the current Fly could be anchored
293 : |* to another one (so it is inside)
294 : |*
295 : *************************************************************************/
296 :
297 0 : const SwFrmFmt* SwFEShell::IsFlyInFly()
298 : {
299 0 : SET_CURR_SHELL( this );
300 :
301 0 : if ( !Imp()->HasDrawView() )
302 0 : return NULL;
303 :
304 0 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
305 0 : if ( !rMrkList.GetMarkCount() )
306 : {
307 0 : SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
308 0 : if( !pCntnt )
309 0 : return NULL;
310 0 : SwFlyFrm *pFly = pCntnt->FindFlyFrm();
311 0 : if ( !pFly )
312 0 : return NULL;
313 0 : return pFly->GetFmt();
314 : }
315 0 : else if ( rMrkList.GetMarkCount() != 1 ||
316 0 : !GetUserCall(rMrkList.GetMark( 0 )->GetMarkedSdrObj()) )
317 0 : return NULL;
318 :
319 0 : SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
320 :
321 0 : SwFrmFmt *pFmt = FindFrmFmt( pObj );
322 0 : if( pFmt && FLY_AT_FLY == pFmt->GetAnchor().GetAnchorId() )
323 : {
324 0 : const SwFrm* pFly = pObj->ISA(SwVirtFlyDrawObj) ?
325 0 : ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->GetAnchorFrm() :
326 0 : ((SwDrawContact*)GetUserCall(pObj))->GetAnchorFrm( pObj );
327 : OSL_ENSURE( pFly, "IsFlyInFly: Where's my anchor?" );
328 : OSL_ENSURE( pFly->IsFlyFrm(), "IsFlyInFly: Funny anchor!" );
329 0 : return ((SwFlyFrm*)pFly)->GetFmt();
330 : }
331 :
332 0 : Point aTmpPos = pObj->GetCurrentBoundRect().TopLeft();
333 :
334 : SwFrm *pTxtFrm;
335 : {
336 0 : SwCrsrMoveState aState( MV_SETONLYTEXT );
337 0 : SwNodeIndex aSwNodeIndex( GetDoc()->GetNodes() );
338 0 : SwPosition aPos( aSwNodeIndex );
339 0 : Point aPoint( aTmpPos );
340 0 : aPoint.setX(aPoint.getX() - 1); //do not land in the fly!!
341 0 : GetLayout()->GetCrsrOfst( &aPos, aPoint, &aState );
342 : // determine text frame by left-top-corner of object
343 0 : pTxtFrm = aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(), &aTmpPos, 0, false );
344 : }
345 0 : const SwFrm *pTmp = ::FindAnchor( pTxtFrm, aTmpPos );
346 0 : const SwFlyFrm *pFly = pTmp->FindFlyFrm();
347 0 : if( pFly )
348 0 : return pFly->GetFmt();
349 0 : return NULL;
350 : }
351 :
352 : /*************************************************************************
353 : |*
354 : |* SwFEShell::SetFlyPos
355 : |*
356 : *************************************************************************/
357 :
358 0 : void SwFEShell::SetFlyPos( const Point& rAbsPos )
359 : {
360 0 : SET_CURR_SHELL( this );
361 :
362 : // Determine reference point in document coordinates
363 0 : SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
364 0 : if( !pCntnt )
365 0 : return;
366 0 : SwFlyFrm *pFly = pCntnt->FindFlyFrm();
367 0 : if ( !pFly )
368 0 : return;
369 :
370 : //SwSaveHdl aSaveX( Imp() );
371 :
372 : // Set an anchor starting from the absolute position for paragraph bound Flys
373 : // Anchor and new RelPos will be calculated and set by the Fly
374 0 : if ( pFly->IsFlyAtCntFrm() )
375 0 : ((SwFlyAtCntFrm*)pFly)->SetAbsPos( rAbsPos );
376 : else
377 : {
378 0 : const SwFrm *pAnch = pFly->GetAnchorFrm();
379 0 : Point aOrient( pAnch->Frm().Pos() );
380 :
381 0 : if ( pFly->IsFlyInCntFrm() )
382 0 : aOrient.setX(rAbsPos.getX());
383 :
384 : // calculate RelPos.
385 0 : aOrient.setX(rAbsPos.getX() - aOrient.getX());
386 0 : aOrient.setY(rAbsPos.getY() - aOrient.getY());
387 0 : pFly->ChgRelPos( aOrient );
388 : }
389 0 : CallChgLnk(); // call the AttrChangeNotify on the UI-side.
390 : }
391 :
392 : /*************************************************************************
393 : |*
394 : |* SwFEShell::FindAnchorPos
395 : |*
396 : *************************************************************************/
397 :
398 0 : Point SwFEShell::FindAnchorPos( const Point& rAbsPos, sal_Bool bMoveIt )
399 : {
400 0 : Point aRet;
401 :
402 0 : SET_CURR_SHELL( this );
403 :
404 0 : if ( !Imp()->HasDrawView() )
405 0 : return aRet;
406 :
407 0 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
408 0 : if ( rMrkList.GetMarkCount() != 1 ||
409 0 : !GetUserCall(rMrkList.GetMark( 0 )->GetMarkedSdrObj()) )
410 0 : return aRet;
411 :
412 0 : SdrObject* pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
413 : // #i28701#
414 0 : SwAnchoredObject* pAnchoredObj = ::GetUserCall( pObj )->GetAnchoredObj( pObj );
415 0 : SwFrmFmt& rFmt = pAnchoredObj->GetFrmFmt();
416 0 : const RndStdIds nAnchorId = rFmt.GetAnchor().GetAnchorId();
417 :
418 0 : if ( FLY_AS_CHAR == nAnchorId )
419 0 : return aRet;
420 :
421 0 : sal_Bool bFlyFrame = pObj->ISA(SwVirtFlyDrawObj);
422 :
423 0 : SwFlyFrm* pFly = 0L;
424 : const SwFrm* pOldAnch;
425 0 : const SwFrm* pFooterOrHeader = NULL;
426 :
427 0 : if( bFlyFrame )
428 : {
429 : // Calculate reference point in document coordinates
430 0 : SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
431 0 : if( !pCntnt )
432 0 : return aRet;
433 0 : pFly = pCntnt->FindFlyFrm();
434 0 : if ( !pFly )
435 0 : return aRet;
436 0 : pOldAnch = pFly->GetAnchorFrm();
437 0 : if( !pOldAnch )
438 0 : return aRet;
439 0 : if ( FLY_AT_PAGE != nAnchorId )
440 : {
441 0 : pFooterOrHeader = pCntnt->FindFooterOrHeader();
442 : }
443 : }
444 : // set <pFooterOrHeader> also for drawing
445 : // objects, but not for control objects.
446 : // Necessary for moving 'anchor symbol' at the user interface inside header/footer.
447 0 : else if ( !::CheckControlLayer( pObj ) )
448 : {
449 0 : SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
450 0 : if( !pCntnt )
451 0 : return aRet;
452 0 : pFooterOrHeader = pCntnt->FindFooterOrHeader();
453 : }
454 :
455 : // Search nearest SwFlyFrm starting from the upper-left corner
456 : // of the fly
457 0 : SwCntntFrm *pTxtFrm = NULL;
458 : {
459 0 : SwCrsrMoveState aState( MV_SETONLYTEXT );
460 0 : SwPosition aPos( GetDoc()->GetNodes().GetEndOfExtras() );
461 0 : Point aTmpPnt( rAbsPos );
462 0 : GetLayout()->GetCrsrOfst( &aPos, aTmpPnt, &aState );
463 0 : if ( nAnchorId != FLY_AT_CHAR
464 0 : || !PosInsideInputFld( aPos ) )
465 : {
466 0 : pTxtFrm = aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(), 0, &aPos, false );
467 0 : }
468 : }
469 0 : const SwFrm *pNewAnch = NULL;
470 0 : if( pTxtFrm != NULL )
471 : {
472 0 : if ( FLY_AT_PAGE == nAnchorId )
473 : {
474 0 : pNewAnch = pTxtFrm->FindPageFrm();
475 : }
476 : else
477 : {
478 0 : pNewAnch = ::FindAnchor( pTxtFrm, rAbsPos );
479 :
480 0 : if( FLY_AT_FLY == nAnchorId ) // LAYER_IMPL
481 : {
482 0 : pNewAnch = pNewAnch->FindFlyFrm();
483 : }
484 : }
485 : }
486 :
487 0 : if( pNewAnch && !pNewAnch->IsProtected() )
488 : {
489 0 : const SwFlyFrm* pCheck = bFlyFrame ? pNewAnch->FindFlyFrm() : 0;
490 : // If we land inside the frame, make sure
491 : // that the frame does not land inside its own content
492 0 : while( pCheck )
493 : {
494 0 : if( pCheck == pFly )
495 0 : break;
496 0 : const SwFrm *pTmp = pCheck->GetAnchorFrm();
497 0 : pCheck = pTmp ? pTmp->FindFlyFrm() : NULL;
498 : }
499 :
500 : // Do not switch from header/footer to another area,
501 : // do not switch to a header/footer
502 0 : if( !pCheck &&
503 0 : pFooterOrHeader == pNewAnch->FindFooterOrHeader() )
504 : {
505 0 : aRet = pNewAnch->GetFrmAnchorPos( ::HasWrap( pObj ) );
506 :
507 0 : if ( bMoveIt || (nAnchorId == FLY_AT_CHAR) )
508 : {
509 0 : SwFmtAnchor aAnch( rFmt.GetAnchor() );
510 0 : switch ( nAnchorId )
511 : {
512 : case FLY_AT_PARA:
513 : {
514 0 : SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
515 0 : pPos->nNode = *pTxtFrm->GetNode();
516 0 : pPos->nContent.Assign(0,0);
517 0 : break;
518 : }
519 : case FLY_AT_PAGE:
520 : {
521 : aAnch.SetPageNum( ((const SwPageFrm*)pNewAnch)->
522 0 : GetPhyPageNum() );
523 0 : break;
524 : }
525 :
526 : case FLY_AT_FLY:
527 : {
528 0 : SwPosition aPos( *((SwFlyFrm*)pNewAnch)->GetFmt()->
529 0 : GetCntnt().GetCntntIdx() );
530 0 : aAnch.SetAnchor( &aPos );
531 0 : break;
532 : }
533 :
534 : case FLY_AT_CHAR:
535 : {
536 0 : SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
537 0 : Point aTmpPnt( rAbsPos );
538 0 : if( pTxtFrm->GetCrsrOfst( pPos, aTmpPnt, NULL ) )
539 : {
540 0 : SwRect aTmpRect;
541 0 : pTxtFrm->GetCharRect( aTmpRect, *pPos );
542 0 : aRet = aTmpRect.Pos();
543 : }
544 : else
545 : {
546 0 : pPos->nNode = *pTxtFrm->GetNode();
547 0 : pPos->nContent.Assign(0,0);
548 : }
549 0 : break;
550 : }
551 : default:
552 0 : break;
553 :
554 : }
555 :
556 0 : if( bMoveIt )
557 : {
558 0 : StartAllAction();
559 : // --> handle change of anchor node:
560 : // if count of the anchor frame also change, the fly frames have to be
561 : // re-created. Thus, delete all fly frames except the <this> before the
562 : // anchor attribute is change and re-create them afterwards.
563 : {
564 0 : SwHandleAnchorNodeChg* pHandleAnchorNodeChg( 0L );
565 0 : SwFlyFrmFmt* pFlyFrmFmt( dynamic_cast<SwFlyFrmFmt*>(&rFmt) );
566 0 : if ( pFlyFrmFmt )
567 : {
568 : pHandleAnchorNodeChg =
569 0 : new SwHandleAnchorNodeChg( *pFlyFrmFmt, aAnch );
570 : }
571 0 : rFmt.GetDoc()->SetAttr( aAnch, rFmt );
572 0 : delete pHandleAnchorNodeChg;
573 : }
574 : // #i28701# - no call of method
575 : // <CheckCharRectAndTopOfLine()> for to-character anchored
576 : // Writer fly frame needed. This method call can cause a
577 : // format of the anchor frame, which is no longer intended.
578 : // Instead clear the anchor character rectangle and
579 : // the top of line values for all to-character anchored objects.
580 0 : pAnchoredObj->ClearCharRectAndTopOfLine();
581 0 : EndAllAction();
582 0 : }
583 : }
584 :
585 0 : SwRect aTmpRect( aRet, rAbsPos );
586 0 : if( aTmpRect.HasArea() )
587 0 : MakeVisible( aTmpRect );
588 : #if OSL_DEBUG_LEVEL > 0
589 : //TODO: That doesn't seem to be intended
590 : if( Color(COL_TRANSPARENT) != GetOut()->GetLineColor() )
591 : {
592 : OSL_FAIL( "Hey, Joe: Where's my Null Pen?" );
593 : GetOut()->SetLineColor( Color(COL_TRANSPARENT) );
594 : }
595 : #endif
596 : }
597 : }
598 :
599 0 : return aRet;
600 : }
601 :
602 : /***********************************************************************
603 : #* Class : SwFEShell
604 : #* Methode : NewFlyFrm
605 : #* Description :
606 : #***********************************************************************/
607 :
608 0 : const SwFrmFmt *SwFEShell::NewFlyFrm( const SfxItemSet& rSet, sal_Bool bAnchValid,
609 : SwFrmFmt *pParent )
610 : {
611 0 : SET_CURR_SHELL( this );
612 0 : StartAllAction();
613 :
614 0 : SwPaM* pCrsr = GetCrsr();
615 0 : const Point aPt( GetCrsrDocPos() );
616 :
617 0 : SwSelBoxes aBoxes;
618 0 : sal_Bool bMoveCntnt = sal_True;
619 0 : if( IsTableMode() )
620 : {
621 0 : GetTblSel( *this, aBoxes );
622 0 : if( !aBoxes.empty() )
623 : {
624 : // Crsr should be removed from the removal area.
625 : // Always put it after/on the table; via the
626 : // document position they will be set to the old
627 : // position
628 0 : ParkCrsr( SwNodeIndex( *aBoxes[0]->GetSttNd() ));
629 :
630 : // #i127787# pCurCrsr will be deleted in ParkCrsr,
631 : // we better get the current pCurCrsr instead of working with the
632 : // deleted one:
633 0 : pCrsr = GetCrsr();
634 : }
635 : else
636 0 : bMoveCntnt = sal_False;
637 : }
638 0 : else if( !pCrsr->HasMark() && pCrsr->GetNext() == pCrsr )
639 0 : bMoveCntnt = sal_False;
640 :
641 0 : const SwPosition& rPos = *pCrsr->Start();
642 :
643 0 : SwFmtAnchor& rAnch = (SwFmtAnchor&)rSet.Get( RES_ANCHOR );
644 0 : RndStdIds eRndId = rAnch.GetAnchorId();
645 0 : switch( eRndId )
646 : {
647 : case FLY_AT_PAGE:
648 0 : if( !rAnch.GetPageNum() ) //HotFix: Bug in UpdateByExample
649 0 : rAnch.SetPageNum( 1 );
650 0 : break;
651 :
652 : case FLY_AT_FLY:
653 : case FLY_AT_PARA:
654 : case FLY_AT_CHAR:
655 : case FLY_AS_CHAR:
656 0 : if( !bAnchValid )
657 : {
658 0 : if( FLY_AT_FLY != eRndId )
659 : {
660 0 : rAnch.SetAnchor( &rPos );
661 : }
662 0 : else if( lcl_SetNewFlyPos( rPos.nNode.GetNode(), rAnch, aPt ) )
663 : {
664 0 : eRndId = FLY_AT_PAGE;
665 : }
666 : }
667 0 : break;
668 :
669 : default:
670 : OSL_ENSURE( !this, "What is the purpose of this Fly?" );
671 0 : break;
672 : }
673 :
674 : SwFlyFrmFmt *pRet;
675 0 : if( bMoveCntnt )
676 : {
677 0 : GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_INSLAYFMT, NULL );
678 0 : SwFmtAnchor* pOldAnchor = 0;
679 0 : bool bHOriChgd = false, bVOriChgd = false;
680 0 : SwFmtVertOrient aOldV;
681 0 : SwFmtHoriOrient aOldH;
682 :
683 0 : if ( FLY_AT_PAGE != eRndId )
684 : {
685 : // First as with page link. Paragraph/character link on if
686 : // everything was shifted. Then the position is valid!
687 : // JP 13.05.98: if necessary also convert the horizontal/vertical
688 : // orientation, to prevent correction during re-anchoring
689 0 : pOldAnchor = new SwFmtAnchor( rAnch );
690 0 : const_cast<SfxItemSet&>(rSet).Put( SwFmtAnchor( FLY_AT_PAGE, 1 ) );
691 :
692 : const SfxPoolItem* pItem;
693 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_HORI_ORIENT, false, &pItem )
694 0 : && text::HoriOrientation::NONE == ((SwFmtHoriOrient*)pItem)->GetHoriOrient() )
695 : {
696 0 : bHOriChgd = true;
697 0 : aOldH = *((SwFmtHoriOrient*)pItem);
698 0 : ((SfxItemSet&)rSet).Put( SwFmtHoriOrient( 0, text::HoriOrientation::LEFT ) );
699 : }
700 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_VERT_ORIENT, false, &pItem )
701 0 : && text::VertOrientation::NONE == ((SwFmtVertOrient*)pItem)->GetVertOrient() )
702 : {
703 0 : bVOriChgd = true;
704 0 : aOldV = *((SwFmtVertOrient*)pItem);
705 0 : ((SfxItemSet&)rSet).Put( SwFmtVertOrient( 0, text::VertOrientation::TOP ) );
706 : }
707 : }
708 :
709 0 : pRet = GetDoc()->MakeFlyAndMove( *pCrsr, rSet, &aBoxes, pParent );
710 :
711 0 : KillPams();
712 :
713 0 : if( pOldAnchor )
714 : {
715 0 : if( pRet )
716 : {
717 : // calculate new position
718 : // JP 24.03.97: also go via page links
719 : // chaos::anchor should not lie in the shifted area
720 0 : pRet->DelFrms();
721 :
722 0 : const SwFrm* pAnch = ::FindAnchor( GetLayout(), aPt, sal_False );
723 0 : SwPosition aPos( *((SwCntntFrm*)pAnch)->GetNode() );
724 0 : if ( FLY_AS_CHAR == eRndId )
725 : {
726 0 : aPos.nContent.Assign( ((SwCntntFrm*)pAnch)->GetNode(), 0 );
727 : }
728 0 : pOldAnchor->SetAnchor( &aPos );
729 :
730 : // shifting of table selection is not Undo-capable. therefore
731 : // changing the anchors should not be recorded
732 : bool const bDoesUndo =
733 0 : GetDoc()->GetIDocumentUndoRedo().DoesUndo();
734 0 : SwUndoId nLastUndoId(UNDO_EMPTY);
735 0 : if (bDoesUndo &&
736 0 : GetDoc()->GetIDocumentUndoRedo().GetLastUndoInfo(0,
737 0 : & nLastUndoId))
738 : {
739 0 : if (UNDO_INSLAYFMT == nLastUndoId)
740 : {
741 0 : GetDoc()->GetIDocumentUndoRedo().DoUndo(false);
742 : }
743 : }
744 :
745 0 : ((SfxItemSet&)rSet).Put( *pOldAnchor );
746 :
747 0 : if( bHOriChgd )
748 0 : ((SfxItemSet&)rSet).Put( aOldH );
749 0 : if( bVOriChgd )
750 0 : ((SfxItemSet&)rSet).Put( aOldV );
751 :
752 0 : GetDoc()->SetFlyFrmAttr( *pRet, (SfxItemSet&)rSet );
753 0 : GetDoc()->GetIDocumentUndoRedo().DoUndo(bDoesUndo);
754 : }
755 0 : delete pOldAnchor;
756 : }
757 0 : GetDoc()->GetIDocumentUndoRedo().EndUndo( UNDO_INSLAYFMT, NULL );
758 : }
759 : else
760 : /* If called from a shell try to propagate an
761 : existing adjust item from rPos to the content node of the
762 : new frame. */
763 0 : pRet = GetDoc()->MakeFlySection( eRndId, &rPos, &rSet, pParent, true );
764 :
765 0 : if( pRet )
766 : {
767 0 : SwFlyFrm* pFrm = pRet->GetFrm( &aPt );
768 0 : if( pFrm )
769 0 : SelectFlyFrm( *pFrm, sal_True );
770 : else
771 : {
772 0 : GetLayout()->SetAssertFlyPages();
773 0 : pRet = 0;
774 : }
775 : }
776 0 : EndAllActionAndCall();
777 :
778 0 : return pRet;
779 : }
780 :
781 : /***********************************************************************
782 : #* Class : SwFEShell
783 : #* Methode : Insert
784 : #***********************************************************************/
785 :
786 0 : void SwFEShell::Insert( const OUString& rGrfName, const OUString& rFltName,
787 : const Graphic* pGraphic,
788 : const SfxItemSet* pFlyAttrSet,
789 : const SfxItemSet* pGrfAttrSet,
790 : SwFrmFmt* pFrmFmt )
791 : {
792 0 : SwFlyFrmFmt* pFmt = 0;
793 0 : SET_CURR_SHELL( this );
794 0 : StartAllAction();
795 0 : SwShellCrsr *pStartCursor = dynamic_cast<SwShellCrsr*>(this->GetSwCrsr());
796 0 : SwShellCrsr *pCursor = pStartCursor;
797 0 : do
798 : {
799 0 : if (!pCursor)
800 0 : break;
801 :
802 : // Has the anchor not been set or been set incompletely?
803 0 : if( pFlyAttrSet )
804 : {
805 : const SfxPoolItem* pItem;
806 0 : if( SFX_ITEM_SET == pFlyAttrSet->GetItemState( RES_ANCHOR, false,
807 0 : &pItem ) )
808 : {
809 0 : SwFmtAnchor* pAnchor = (SwFmtAnchor*)pItem;
810 0 : switch( pAnchor->GetAnchorId())
811 : {
812 : case FLY_AT_PARA:
813 : case FLY_AT_CHAR: // LAYER_IMPL
814 : case FLY_AS_CHAR:
815 0 : if( !pAnchor->GetCntntAnchor() )
816 : {
817 0 : pAnchor->SetAnchor( pCursor->GetPoint() );
818 : }
819 0 : break;
820 : case FLY_AT_FLY:
821 0 : if( !pAnchor->GetCntntAnchor() )
822 : {
823 0 : lcl_SetNewFlyPos( *pCursor->GetNode(),
824 0 : *pAnchor, GetCrsrDocPos() );
825 : }
826 0 : break;
827 : case FLY_AT_PAGE:
828 0 : if( !pAnchor->GetPageNum() )
829 : {
830 : pAnchor->SetPageNum( pCursor->GetPageNum(
831 0 : true, &pCursor->GetPtPos() ) );
832 : }
833 0 : break;
834 : default :
835 0 : break;
836 : }
837 : }
838 : }
839 0 : pFmt = GetDoc()->Insert(*pCursor, rGrfName,
840 : rFltName, pGraphic,
841 : pFlyAttrSet,
842 0 : pGrfAttrSet, pFrmFmt );
843 : OSL_ENSURE( pFmt, "Doc->Insert(notxt) failed." );
844 :
845 0 : pCursor = dynamic_cast<SwShellCrsr*>(pCursor->GetNext());
846 : } while( pCursor != pStartCursor );
847 :
848 0 : EndAllAction();
849 :
850 0 : if( pFmt )
851 : {
852 0 : const Point aPt( GetCrsrDocPos() );
853 0 : SwFlyFrm* pFrm = pFmt->GetFrm( &aPt );
854 :
855 0 : if( pFrm )
856 : {
857 : // fdo#36681: Invalidate the content and layout to refresh
858 : // the picture anchoring properly
859 0 : SwPageFrm* pPageFrm = pFrm->FindPageFrmOfAnchor();
860 0 : pPageFrm->InvalidateFlyLayout();
861 0 : pPageFrm->InvalidateCntnt();
862 :
863 0 : SelectFlyFrm( *pFrm, sal_True );
864 : }
865 : else
866 0 : GetLayout()->SetAssertFlyPages();
867 0 : }
868 0 : }
869 :
870 0 : SwFlyFrmFmt* SwFEShell::InsertObject( const svt::EmbeddedObjectRef& xObj,
871 : const SfxItemSet* pFlyAttrSet,
872 : const SfxItemSet* pGrfAttrSet,
873 : SwFrmFmt* pFrmFmt )
874 : {
875 0 : SwFlyFrmFmt* pFmt = 0;
876 0 : SET_CURR_SHELL( this );
877 0 : StartAllAction();
878 0 : FOREACHPAM_START(GetCrsr())
879 0 : pFmt = GetDoc()->Insert(*PCURCRSR, xObj,
880 0 : pFlyAttrSet, pGrfAttrSet, pFrmFmt );
881 : OSL_ENSURE( pFmt, "Doc->Insert(notxt) failed." );
882 :
883 0 : FOREACHPAM_END()
884 0 : EndAllAction();
885 :
886 0 : if( pFmt )
887 : {
888 0 : const Point aPt( GetCrsrDocPos() );
889 0 : SwFlyFrm* pFrm = pFmt->GetFrm( &aPt );
890 :
891 0 : if( pFrm )
892 0 : SelectFlyFrm( *pFrm, sal_True );
893 : else
894 0 : GetLayout()->SetAssertFlyPages();
895 : }
896 :
897 0 : return pFmt;
898 : }
899 :
900 0 : void SwFEShell::InsertDrawObj( SdrObject& rDrawObj,
901 : const Point& rInsertPosition )
902 : {
903 0 : SET_CURR_SHELL( this );
904 :
905 0 : SfxItemSet rFlyAttrSet( GetDoc()->GetAttrPool(), aFrmFmtSetRange );
906 0 : rFlyAttrSet.Put( SwFmtAnchor( FLY_AT_PARA ));
907 : // #i89920#
908 0 : rFlyAttrSet.Put( SwFmtSurround( SURROUND_THROUGHT ) );
909 0 : rDrawObj.SetLayer( getIDocumentDrawModelAccess()->GetHeavenId() );
910 :
911 : // find anchor position
912 0 : SwPaM aPam( mpDoc->GetNodes() );
913 : {
914 0 : SwCrsrMoveState aState( MV_SETONLYTEXT );
915 0 : Point aTmpPt( rInsertPosition );
916 0 : GetLayout()->GetCrsrOfst( aPam.GetPoint(), aTmpPt, &aState );
917 0 : const SwFrm* pFrm = aPam.GetCntntNode()->getLayoutFrm( GetLayout(), 0, 0, false );
918 0 : const Point aRelPos( rInsertPosition.X() - pFrm->Frm().Left(),
919 0 : rInsertPosition.Y() - pFrm->Frm().Top() );
920 0 : rDrawObj.SetRelativePos( aRelPos );
921 0 : ::lcl_FindAnchorPos( *this, *GetDoc(), rInsertPosition, *pFrm, rFlyAttrSet );
922 : }
923 : // insert drawing object into the document creating a new <SwDrawFrmFmt> instance
924 0 : SwDrawFrmFmt* pFmt = GetDoc()->InsertDrawObj( aPam, rDrawObj, rFlyAttrSet );
925 :
926 : // move object to visible layer
927 0 : SwContact* pContact = static_cast<SwContact*>(rDrawObj.GetUserCall());
928 0 : if ( pContact )
929 : {
930 0 : pContact->MoveObjToVisibleLayer( &rDrawObj );
931 : }
932 :
933 0 : if ( pFmt )
934 : {
935 : // select drawing object
936 0 : Imp()->GetDrawView()->MarkObj( &rDrawObj, Imp()->GetPageView(),
937 0 : false, false );
938 : }
939 : else
940 : {
941 0 : GetLayout()->SetAssertFlyPages();
942 0 : }
943 0 : }
944 :
945 : /***********************************************************************
946 : #* Class : SwFEShell
947 : #* Methode : GetPageObjs
948 : #***********************************************************************/
949 :
950 0 : void SwFEShell::GetPageObjs( std::vector<SwFrmFmt*>& rFillArr )
951 : {
952 0 : rFillArr.clear();
953 :
954 0 : for( sal_uInt16 n = 0; n < mpDoc->GetSpzFrmFmts()->size(); ++n )
955 : {
956 0 : SwFrmFmt* pFmt = (*mpDoc->GetSpzFrmFmts())[n];
957 0 : if (FLY_AT_PAGE == pFmt->GetAnchor().GetAnchorId())
958 : {
959 0 : rFillArr.push_back( pFmt );
960 : }
961 : }
962 0 : }
963 :
964 : /***********************************************************************
965 : #* Class : SwFEShell
966 : #* Methode : SetPageFlysNewPage
967 : #***********************************************************************/
968 :
969 0 : void SwFEShell::SetPageObjsNewPage( std::vector<SwFrmFmt*>& rFillArr, int nOffset )
970 : {
971 0 : if( rFillArr.empty() || !nOffset )
972 0 : return;
973 :
974 0 : StartAllAction();
975 0 : StartUndo();
976 :
977 : long nNewPage;
978 0 : SwRootFrm* pTmpRootFrm = GetLayout();
979 0 : sal_uInt16 nMaxPage = pTmpRootFrm->GetPageNum();
980 0 : bool bTmpAssert = false;
981 0 : for( sal_uInt16 n = 0; n < rFillArr.size(); ++n )
982 : {
983 0 : SwFrmFmt* pFmt = rFillArr[n];
984 0 : if( mpDoc->GetSpzFrmFmts()->Contains( pFmt ))
985 : {
986 : // FlyFmt is still valid, therefore process
987 :
988 0 : SwFmtAnchor aNewAnchor( pFmt->GetAnchor() );
989 0 : if ((FLY_AT_PAGE != aNewAnchor.GetAnchorId()) ||
990 0 : 0 >= ( nNewPage = aNewAnchor.GetPageNum() + nOffset ) )
991 : // chaos::Anchor has been changed or invalid page number,
992 : // therefore: do not change!
993 0 : continue;
994 :
995 0 : if( sal_uInt16(nNewPage) > nMaxPage )
996 : {
997 0 : if ( RES_DRAWFRMFMT == pFmt->Which() )
998 : {
999 0 : SwContact *pCon = pFmt->FindContactObj();
1000 0 : if( pCon )
1001 0 : ((SwDrawContact*)pCon)->DisconnectFromLayout();
1002 : }
1003 : else
1004 0 : pFmt->DelFrms();
1005 0 : bTmpAssert = true;
1006 : }
1007 0 : aNewAnchor.SetPageNum( sal_uInt16(nNewPage) );
1008 0 : mpDoc->SetAttr( aNewAnchor, *pFmt );
1009 : }
1010 : }
1011 :
1012 0 : if( bTmpAssert )
1013 0 : pTmpRootFrm->SetAssertFlyPages();
1014 :
1015 0 : EndUndo();
1016 0 : EndAllAction();
1017 : }
1018 :
1019 : /***********************************************************************
1020 : #* Class : SwFEShell
1021 : #* Methode : GetFlyFrmAttr
1022 : #* Description : all attributes in the "baskets" will be filled
1023 : #* with the attributes of the current FlyFrms.
1024 : #* Attributes which cannot be filled due to being at the wrong place
1025 : #* or which are ambiguous (multiple selections) will be removed.
1026 : #*
1027 : #***********************************************************************/
1028 :
1029 0 : sal_Bool SwFEShell::GetFlyFrmAttr( SfxItemSet &rSet ) const
1030 : {
1031 0 : SwFlyFrm *pFly = FindFlyFrm();
1032 0 : if ( !pFly )
1033 : {
1034 0 : SwFrm* pCurrFrm( GetCurrFrm() );
1035 0 : if ( !pCurrFrm )
1036 : {
1037 : OSL_FAIL( "<SwFEShell::GetFlyFrmAttr(..)> - missing current frame. This is a serious defect, please inform OD." );
1038 0 : return sal_False;
1039 : }
1040 0 : pFly = GetCurrFrm()->FindFlyFrm();
1041 0 : if ( !pFly )
1042 : {
1043 : OSL_ENSURE( !this, "GetFlyFrmAttr, no Fly selected." );
1044 0 : return sal_False;
1045 : }
1046 : }
1047 :
1048 0 : SET_CURR_SHELL( (SwViewShell*)this );
1049 :
1050 0 : if( !rSet.Set( pFly->GetFmt()->GetAttrSet(), true ) )
1051 0 : return sal_False;
1052 :
1053 : // now examine all attributes. Remove forbidden attributes, then
1054 : // get all remaining attributes and enter them
1055 : const SfxPoolItem* pItem;
1056 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, false, &pItem ) )
1057 : {
1058 0 : SwFmtAnchor* pAnchor = (SwFmtAnchor*)pItem;
1059 0 : RndStdIds eType = pAnchor->GetAnchorId();
1060 :
1061 0 : if ( FLY_AT_PAGE != eType )
1062 : {
1063 : // OD 12.11.2003 #i22341# - content anchor of anchor item is needed.
1064 : // Thus, don't overwrite anchor item by default contructed anchor item.
1065 0 : if ( FLY_AS_CHAR == eType )
1066 : {
1067 0 : rSet.ClearItem( RES_OPAQUE );
1068 0 : rSet.ClearItem( RES_SURROUND );
1069 : }
1070 : }
1071 : }
1072 0 : rSet.SetParent( pFly->GetFmt()->GetAttrSet().GetParent() );
1073 : // attributes must be removed
1074 0 : rSet.ClearItem( RES_FILL_ORDER );
1075 0 : rSet.ClearItem( RES_CNTNT );
1076 : //MA: remove first (Template by example etc.)
1077 0 : rSet.ClearItem( RES_CHAIN );
1078 0 : return sal_True;
1079 : }
1080 : /***********************************************************************
1081 : #* Class : SwFEShell
1082 : #* Methode : SetFlyFrmAttr
1083 : #* Description : Attributes of the current fly will change.
1084 : #***********************************************************************/
1085 :
1086 0 : bool SwFEShell::SetFlyFrmAttr( SfxItemSet& rSet )
1087 : {
1088 0 : SET_CURR_SHELL( this );
1089 0 : bool bRet = false;
1090 :
1091 0 : if( rSet.Count() )
1092 : {
1093 0 : SwFlyFrm *pFly = FindFlyFrm();
1094 0 : if( !pFly )
1095 : {
1096 : OSL_ENSURE( GetCurrFrm(), "Crsr in parking zone" );
1097 0 : pFly = GetCurrFrm()->FindFlyFrm();
1098 : OSL_ENSURE( pFly, "SetFlyFrmAttr, no Fly selected." );
1099 : }
1100 0 : if( pFly )
1101 : {
1102 0 : StartAllAction();
1103 0 : const Point aPt( pFly->Frm().Pos() );
1104 :
1105 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, false ))
1106 0 : sw_ChkAndSetNewAnchor( *this, *pFly, rSet );
1107 0 : SwFlyFrmFmt* pFlyFmt = (SwFlyFrmFmt*)pFly->GetFmt();
1108 :
1109 0 : if( GetDoc()->SetFlyFrmAttr( *pFlyFmt, rSet ))
1110 : {
1111 0 : bRet = true;
1112 0 : SwFlyFrm* pFrm = pFlyFmt->GetFrm( &aPt );
1113 0 : if( pFrm )
1114 0 : SelectFlyFrm( *pFrm, sal_True );
1115 : else
1116 0 : GetLayout()->SetAssertFlyPages();
1117 : }
1118 :
1119 0 : EndAllActionAndCall();
1120 : }
1121 : }
1122 0 : return bRet;
1123 : }
1124 :
1125 0 : sal_Bool SwFEShell::SetDrawingAttr( SfxItemSet& rSet )
1126 : {
1127 0 : sal_Bool bRet = sal_False;
1128 0 : SET_CURR_SHELL( this );
1129 0 : if ( !rSet.Count() ||
1130 0 : !Imp()->HasDrawView() )
1131 0 : return bRet;
1132 :
1133 0 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
1134 0 : if ( rMrkList.GetMarkCount() != 1 )
1135 0 : return bRet;
1136 :
1137 0 : StartUndo();
1138 0 : SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
1139 0 : SwFrmFmt *pFmt = FindFrmFmt( pObj );
1140 0 : StartAllAction();
1141 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, false ))
1142 : {
1143 0 : RndStdIds nNew = ((SwFmtAnchor&)rSet.Get( RES_ANCHOR )).GetAnchorId();
1144 0 : if ( nNew != pFmt->GetAnchor().GetAnchorId() )
1145 : {
1146 0 : ChgAnchor( nNew );
1147 : // #i26791# - clear anchor attribute in item set,
1148 : // because method <ChgAnchor(..)> takes care of it.
1149 0 : rSet.ClearItem( RES_ANCHOR );
1150 : }
1151 : }
1152 :
1153 0 : if( GetDoc()->SetFlyFrmAttr( *pFmt, rSet ))
1154 : {
1155 0 : bRet = sal_True;
1156 0 : Point aTmp;
1157 0 : SelectObj( aTmp, 0, pObj );
1158 : }
1159 0 : EndAllActionAndCall();
1160 0 : EndUndo();
1161 0 : return bRet;
1162 : }
1163 :
1164 : /***********************************************************************
1165 : #* Class : SwFEShell
1166 : #* Methode : ResetFlyFrmAttr
1167 : #* Description : Reset requested attributes or the ones contained in
1168 : #* the set.
1169 : #***********************************************************************/
1170 :
1171 0 : sal_Bool SwFEShell::ResetFlyFrmAttr( sal_uInt16 nWhich, const SfxItemSet* pSet )
1172 : {
1173 0 : sal_Bool bRet = sal_False;
1174 :
1175 0 : if( RES_ANCHOR != nWhich && RES_CHAIN != nWhich && RES_CNTNT != nWhich )
1176 : {
1177 0 : SET_CURR_SHELL( this );
1178 :
1179 0 : SwFlyFrm *pFly = FindFlyFrm();
1180 0 : if( !pFly )
1181 : {
1182 : OSL_ENSURE( GetCurrFrm(), "Crsr in parking zone" );
1183 0 : pFly = GetCurrFrm()->FindFlyFrm();
1184 : OSL_ENSURE( pFly, "SetFlyFrmAttr, no Fly selected." );
1185 : }
1186 :
1187 0 : if( pFly )
1188 : {
1189 0 : StartAllAction();
1190 :
1191 0 : if( pSet )
1192 : {
1193 0 : SfxItemIter aIter( *pSet );
1194 0 : const SfxPoolItem* pItem = aIter.FirstItem();
1195 0 : while( pItem )
1196 : {
1197 0 : if( !IsInvalidItem( pItem ) &&
1198 0 : RES_ANCHOR != ( nWhich = pItem->Which() ) &&
1199 0 : RES_CHAIN != nWhich && RES_CNTNT != nWhich )
1200 0 : pFly->GetFmt()->ResetFmtAttr( nWhich );
1201 0 : pItem = aIter.NextItem();
1202 0 : }
1203 : }
1204 : else
1205 0 : pFly->GetFmt()->ResetFmtAttr( nWhich );
1206 :
1207 0 : bRet = sal_True;
1208 0 : EndAllActionAndCall();
1209 0 : GetDoc()->SetModified();
1210 0 : }
1211 : }
1212 0 : return bRet;
1213 : }
1214 :
1215 : /***********************************************************************
1216 : #* Class : SwFEShell
1217 : #* Methode : GetCurFrmFmt
1218 : #* Description : Returns frame-format if frame, otherwise 0
1219 : #***********************************************************************/
1220 :
1221 0 : SwFrmFmt* SwFEShell::GetCurFrmFmt() const
1222 : {
1223 0 : SwFrmFmt* pRet = 0;
1224 0 : SwLayoutFrm *pFly = FindFlyFrm();
1225 0 : if( pFly && ( pRet = (SwFrmFmt*)pFly->GetFmt()->DerivedFrom() ) ==
1226 0 : GetDoc()->GetDfltFrmFmt() )
1227 0 : pRet = 0;
1228 0 : return pRet;
1229 : }
1230 :
1231 : /******************************************************************************
1232 : * Methode : void SwFEShell::SetFrmFmt(SwFrmFmt *pNewFmt)
1233 : * Description :
1234 : ******************************************************************************/
1235 :
1236 0 : void SwFEShell::SetFrmFmt( SwFrmFmt *pNewFmt, bool bKeepOrient, Point* pDocPos )
1237 : {
1238 0 : SwFlyFrm *pFly = 0;
1239 0 : if(pDocPos)
1240 : {
1241 0 : const SwFrmFmt* pFmt = GetFmtFromObj( *pDocPos );
1242 :
1243 0 : if(PTR_CAST(SwFlyFrmFmt, pFmt))
1244 0 : pFly = ((SwFlyFrmFmt*)pFmt)->GetFrm();
1245 : }
1246 : else
1247 0 : pFly = FindFlyFrm();
1248 : OSL_ENSURE( pFly, "SetFrmFmt: no frame" );
1249 0 : if( pFly )
1250 : {
1251 0 : StartAllAction();
1252 0 : SET_CURR_SHELL( this );
1253 :
1254 0 : SwFlyFrmFmt* pFlyFmt = (SwFlyFrmFmt*)pFly->GetFmt();
1255 0 : const Point aPt( pFly->Frm().Pos() );
1256 :
1257 0 : SfxItemSet* pSet = 0;
1258 : const SfxPoolItem* pItem;
1259 0 : if( SFX_ITEM_SET == pNewFmt->GetItemState( RES_ANCHOR, sal_False, &pItem ))
1260 : {
1261 0 : pSet = new SfxItemSet( GetDoc()->GetAttrPool(), aFrmFmtSetRange );
1262 0 : pSet->Put( *pItem );
1263 0 : if( !sw_ChkAndSetNewAnchor( *this, *pFly, *pSet ))
1264 0 : delete pSet, pSet = 0;
1265 : }
1266 :
1267 0 : if( GetDoc()->SetFrmFmtToFly( *pFlyFmt, *pNewFmt, pSet, bKeepOrient ))
1268 : {
1269 0 : SwFlyFrm* pFrm = pFlyFmt->GetFrm( &aPt );
1270 0 : if( pFrm )
1271 0 : SelectFlyFrm( *pFrm, sal_True );
1272 : else
1273 0 : GetLayout()->SetAssertFlyPages();
1274 : }
1275 0 : delete pSet;
1276 :
1277 0 : EndAllActionAndCall();
1278 : }
1279 0 : }
1280 :
1281 : /*************************************************************************
1282 : |*
1283 : |* SwFEShell::GetFlyFrmFmt()
1284 : |*
1285 : *************************************************************************/
1286 :
1287 0 : const SwFrmFmt* SwFEShell::GetFlyFrmFmt() const
1288 : {
1289 0 : const SwFlyFrm* pFly = FindFlyFrm();
1290 0 : if ( !pFly )
1291 : {
1292 0 : SwFrm* pCurrFrm = GetCurrFrm();
1293 0 : pFly = pCurrFrm ? pCurrFrm->FindFlyFrm() : 0;
1294 : }
1295 0 : if( pFly )
1296 0 : return pFly->GetFmt();
1297 0 : return 0;
1298 : }
1299 :
1300 0 : SwFrmFmt* SwFEShell::GetFlyFrmFmt()
1301 : {
1302 0 : SwFlyFrm* pFly = FindFlyFrm();
1303 0 : if ( !pFly )
1304 : {
1305 0 : SwFrm* pCurrFrm = GetCurrFrm();
1306 0 : pFly = pCurrFrm ? pCurrFrm->FindFlyFrm() : 0;
1307 : }
1308 0 : if( pFly )
1309 0 : return pFly->GetFmt();
1310 0 : return 0;
1311 : }
1312 :
1313 : /*************************************************************************
1314 : |*
1315 : |* SwFEShell::GetFlyRect()
1316 : |*
1317 : *************************************************************************/
1318 :
1319 0 : SwRect SwFEShell::GetFlyRect() const
1320 : {
1321 0 : SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
1322 0 : SwFlyFrm *pFly = pCntnt ? pCntnt->FindFlyFrm() : 0;
1323 0 : if ( !pFly )
1324 : {
1325 0 : SwRect aRect;
1326 0 : return aRect;
1327 : }
1328 : else
1329 0 : return pFly->Frm();
1330 : }
1331 :
1332 : /*************************************************************************
1333 : |*
1334 : |* SwFEShell::GetObjRect()
1335 : |*
1336 : *************************************************************************/
1337 :
1338 0 : SwRect SwFEShell::GetObjRect() const
1339 : {
1340 0 : if( Imp()->HasDrawView() )
1341 0 : return Imp()->GetDrawView()->GetAllMarkedRect();
1342 : else
1343 : {
1344 0 : SwRect aRect;
1345 0 : return aRect;
1346 : }
1347 : }
1348 :
1349 0 : void SwFEShell::SetObjRect( const SwRect& rRect )
1350 : {
1351 0 : if ( Imp()->HasDrawView() )
1352 : {
1353 0 : Imp()->GetDrawView()->SetAllMarkedRect( rRect.SVRect() );
1354 0 : CallChgLnk(); // call AttrChangeNotify on the UI-side.
1355 : }
1356 0 : }
1357 :
1358 : /***********************************************************************
1359 : #* Class : SwFEShell
1360 : #* Methode : RequestObjectResize()
1361 : #***********************************************************************/
1362 :
1363 0 : Size SwFEShell::RequestObjectResize( const SwRect &rRect, const uno::Reference < embed::XEmbeddedObject >& xObj )
1364 : {
1365 0 : Size aResult;
1366 :
1367 0 : SwFlyFrm *pFly = FindFlyFrm( xObj );
1368 0 : if ( !pFly )
1369 : {
1370 0 : aResult = rRect.SSize();
1371 0 : return aResult;
1372 : }
1373 :
1374 0 : aResult = pFly->Prt().SSize();
1375 :
1376 0 : sal_Bool bPosProt = pFly->GetFmt()->GetProtect().IsPosProtected();
1377 0 : sal_Bool bSizeProt = pFly->GetFmt()->GetProtect().IsSizeProtected();
1378 :
1379 0 : StartAllAction();
1380 :
1381 : // MA we do not allow to clip the Fly, as the OLE server can
1382 : // request various wishes. Clipping is done via the formatting.
1383 : // Correct display is done by scaling.
1384 : // Scaling is done by SwNoTxtFrm::Format by calling
1385 : // SwWrtShell::CalcAndSetScale()
1386 0 : if ( rRect.SSize() != pFly->Prt().SSize() && !bSizeProt )
1387 : {
1388 0 : Size aSz( rRect.SSize() );
1389 :
1390 : //JP 28.02.2001: Task 74707 - ask for fly in fly with automatic size
1391 :
1392 : const SwFrm* pAnchor;
1393 : const SwTxtNode* pTNd;
1394 : const SwpHints* pHts;
1395 0 : const SwFmtFrmSize& rFrmSz = pFly->GetFmt()->GetFrmSize();
1396 0 : if( bCheckForOLEInCaption &&
1397 0 : 0 != rFrmSz.GetWidthPercent() &&
1398 0 : 0 != (pAnchor = pFly->GetAnchorFrm()) &&
1399 0 : pAnchor->IsTxtFrm() &&
1400 0 : !pAnchor->GetNext() && !pAnchor->GetPrev() &&
1401 0 : pAnchor->GetUpper()->IsFlyFrm() &&
1402 0 : 0 != ( pTNd = ((SwTxtFrm*)pAnchor)->GetNode()->GetTxtNode()) &&
1403 : 0 != ( pHts = pTNd->GetpSwpHints() ))
1404 : {
1405 : // search for a sequence field:
1406 : const SfxPoolItem* pItem;
1407 0 : for( sal_uInt16 n = 0, nEnd = pHts->Count(); n < nEnd; ++n )
1408 0 : if( RES_TXTATR_FIELD == ( pItem = &(*pHts)[ n ]->GetAttr())->Which()
1409 0 : && TYP_SEQFLD == ((SwFmtFld*)pItem)->GetField()->GetTypeId() )
1410 : {
1411 : // sequence field found
1412 0 : SwFlyFrm* pChgFly = (SwFlyFrm*)pAnchor->GetUpper();
1413 : // calculate the changed size:
1414 : // width must change, height can change
1415 0 : Size aNewSz( aSz.Width() + pChgFly->Frm().Width() -
1416 0 : pFly->Prt().Width(), aSz.Height() );
1417 :
1418 0 : SwFrmFmt *pFmt = pChgFly->GetFmt();
1419 0 : SwFmtFrmSize aFrmSz( pFmt->GetFrmSize() );
1420 0 : aFrmSz.SetWidth( aNewSz.Width() );
1421 0 : if( ATT_MIN_SIZE != aFrmSz.GetHeightSizeType() )
1422 : {
1423 0 : aNewSz.Height() += pChgFly->Frm().Height() -
1424 0 : pFly->Prt().Height();
1425 0 : if( std::abs( aNewSz.Height() - pChgFly->Frm().Height()) > 1 )
1426 0 : aFrmSz.SetHeight( aNewSz.Height() );
1427 : }
1428 : // via Doc for the Undo!
1429 0 : pFmt->GetDoc()->SetAttr( aFrmSz, *pFmt );
1430 0 : break;
1431 : }
1432 : }
1433 :
1434 : // set the new Size at the fly themself
1435 0 : if ( pFly->Prt().Height() > 0 && pFly->Prt().Width() > 0 )
1436 : {
1437 0 : aSz.Width() += pFly->Frm().Width() - pFly->Prt().Width();
1438 0 : aSz.Height()+= pFly->Frm().Height()- pFly->Prt().Height();
1439 : }
1440 0 : aResult = pFly->ChgSize( aSz );
1441 :
1442 : // if the object changes, the contour is outside the object
1443 : OSL_ENSURE( pFly->Lower()->IsNoTxtFrm(), "Request without NoTxt" );
1444 0 : SwNoTxtNode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetNoTxtNode();
1445 : OSL_ENSURE( pNd, "Request without Node" );
1446 0 : pNd->SetContour( 0 );
1447 0 : ClrContourCache();
1448 : }
1449 :
1450 : // if only the size is to be adjusted, a position is transported with
1451 : // allocated values
1452 0 : Point aPt( pFly->Prt().Pos() );
1453 0 : aPt += pFly->Frm().Pos();
1454 0 : if ( rRect.Top() != LONG_MIN && rRect.Pos() != aPt && !bPosProt )
1455 : {
1456 0 : aPt = rRect.Pos();
1457 0 : aPt.setX(aPt.getX() - pFly->Prt().Left());
1458 0 : aPt.setY(aPt.getY() - pFly->Prt().Top());
1459 :
1460 : // in case of paragraph-bound Flys, starting from the new position,
1461 : // a new anchor is to be set. The anchor and the new RelPos are
1462 : // calculated by the Fly and set
1463 0 : if( pFly->IsFlyAtCntFrm() )
1464 0 : ((SwFlyAtCntFrm*)pFly)->SetAbsPos( aPt );
1465 : else
1466 : {
1467 0 : const SwFrmFmt *pFmt = pFly->GetFmt();
1468 0 : const SwFmtVertOrient &rVert = pFmt->GetVertOrient();
1469 0 : const SwFmtHoriOrient &rHori = pFmt->GetHoriOrient();
1470 0 : const long lXDiff = aPt.getX() - pFly->Frm().Left();
1471 0 : const long lYDiff = aPt.getY() - pFly->Frm().Top();
1472 0 : const Point aTmp( rHori.GetPos() + lXDiff,
1473 0 : rVert.GetPos() + lYDiff );
1474 0 : pFly->ChgRelPos( aTmp );
1475 : }
1476 : }
1477 :
1478 0 : SwFlyFrmFmt *pFlyFrmFmt = pFly->GetFmt();
1479 : OSL_ENSURE( pFlyFrmFmt, "fly frame format missing!" );
1480 0 : if ( pFlyFrmFmt )
1481 0 : pFlyFrmFmt->SetLastFlyFrmPrtRectPos( pFly->Prt().Pos() ); //stores the value of last Prt rect
1482 :
1483 0 : EndAllAction();
1484 :
1485 0 : return aResult;
1486 : }
1487 :
1488 : /***********************************************************************
1489 : #* Class : SwFEShell
1490 : #* Methode : WizzardFindCurFrmFmt
1491 : #***********************************************************************/
1492 :
1493 0 : SwFrmFmt* SwFEShell::WizzardGetFly()
1494 : {
1495 : // do not search the Fly via the layout. Now we can delete a frame
1496 : // without a valid layout. ( e.g. for the wizards )
1497 0 : SwFrmFmts& rSpzArr = *mpDoc->GetSpzFrmFmts();
1498 0 : sal_uInt16 nCnt = rSpzArr.size();
1499 0 : if( nCnt )
1500 : {
1501 0 : SwNodeIndex& rCrsrNd = GetCrsr()->GetPoint()->nNode;
1502 0 : if( rCrsrNd.GetIndex() > mpDoc->GetNodes().GetEndOfExtras().GetIndex() )
1503 : // Cursor is in the body area!
1504 0 : return 0;
1505 :
1506 0 : for( sal_uInt16 n = 0; n < nCnt; ++n )
1507 : {
1508 0 : SwFrmFmt* pFmt = rSpzArr[ n ];
1509 0 : const SwNodeIndex* pIdx = pFmt->GetCntnt( sal_False ).GetCntntIdx();
1510 : SwStartNode* pSttNd;
1511 0 : if( pIdx &&
1512 0 : 0 != ( pSttNd = pIdx->GetNode().GetStartNode() ) &&
1513 0 : pSttNd->GetIndex() < rCrsrNd.GetIndex() &&
1514 0 : rCrsrNd.GetIndex() < pSttNd->EndOfSectionIndex() )
1515 : {
1516 : // found: return immediately
1517 0 : return pFmt;
1518 : }
1519 : }
1520 : }
1521 0 : return 0;
1522 : }
1523 :
1524 0 : void SwFEShell::SetFlyName( const OUString& rName )
1525 : {
1526 0 : SwLayoutFrm *pFly = FindFlyFrm();
1527 0 : if( pFly )
1528 0 : GetDoc()->SetFlyName( *(SwFlyFrmFmt*)pFly->GetFmt(), rName );
1529 : else {
1530 : OSL_ENSURE( !this, "no FlyFrame selected" );
1531 : }
1532 0 : }
1533 :
1534 0 : OUString SwFEShell::GetFlyName() const
1535 : {
1536 0 : SwLayoutFrm *pFly = FindFlyFrm();
1537 0 : if( pFly )
1538 0 : return pFly->GetFmt()->GetName();
1539 :
1540 : OSL_ENSURE( !this, "no FlyFrame selected" );
1541 0 : return OUString();
1542 : }
1543 :
1544 0 : const uno::Reference < embed::XEmbeddedObject > SwFEShell::GetOleRef() const
1545 : {
1546 0 : uno::Reference < embed::XEmbeddedObject > xObj;
1547 0 : SwFlyFrm * pFly = FindFlyFrm();
1548 0 : if (pFly && pFly->Lower() && pFly->Lower()->IsNoTxtFrm())
1549 : {
1550 0 : SwOLENode *pNd = ((SwNoTxtFrm*)pFly->Lower())->GetNode()->GetOLENode();
1551 0 : if (pNd)
1552 0 : xObj = pNd->GetOLEObj().GetOleRef();
1553 : }
1554 0 : return xObj;
1555 : }
1556 :
1557 0 : OUString SwFEShell::GetUniqueGrfName() const
1558 : {
1559 0 : return GetDoc()->GetUniqueGrfName();
1560 : }
1561 :
1562 0 : const SwFrmFmt* SwFEShell::IsURLGrfAtPos( const Point& rPt, OUString* pURL,
1563 : OUString *pTargetFrameName,
1564 : OUString *pDescription ) const
1565 : {
1566 0 : if( !Imp()->HasDrawView() )
1567 0 : return 0;
1568 :
1569 : SdrObject* pObj;
1570 : SdrPageView* pPV;
1571 0 : const SwFrmFmt* pRet = 0;
1572 0 : SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
1573 :
1574 0 : sal_uInt16 nOld = pDView->GetHitTolerancePixel();
1575 0 : pDView->SetHitTolerancePixel( 2 );
1576 :
1577 0 : if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV,SDRSEARCH_PICKMACRO ) &&
1578 0 : pObj->ISA(SwVirtFlyDrawObj) )
1579 : {
1580 0 : SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
1581 0 : const SwFmtURL &rURL = pFly->GetFmt()->GetURL();
1582 0 : if( !rURL.GetURL().isEmpty() || rURL.GetMap() )
1583 : {
1584 0 : bool bSetTargetFrameName = pTargetFrameName != 0;
1585 0 : bool bSetDescription = pDescription != 0;
1586 0 : if ( rURL.GetMap() )
1587 : {
1588 0 : IMapObject *pObject = pFly->GetFmt()->GetIMapObject( rPt, pFly );
1589 0 : if ( pObject && !pObject->GetURL().isEmpty() )
1590 : {
1591 0 : if( pURL )
1592 0 : *pURL = pObject->GetURL();
1593 0 : if ( bSetTargetFrameName && !pObject->GetTarget().isEmpty() )
1594 : {
1595 0 : bSetTargetFrameName = false;
1596 0 : *pTargetFrameName = pObject->GetTarget();
1597 : }
1598 0 : if ( bSetDescription )
1599 : {
1600 0 : bSetDescription = false;
1601 0 : *pDescription = pObject->GetAltText();
1602 : }
1603 0 : pRet = pFly->GetFmt();
1604 : }
1605 : }
1606 : else
1607 : {
1608 0 : if( pURL )
1609 : {
1610 0 : *pURL = rURL.GetURL();
1611 0 : if( rURL.IsServerMap() )
1612 : {
1613 : // append the relative pixel position !!
1614 0 : Point aPt( rPt );
1615 0 : aPt -= pFly->Frm().Pos();
1616 : // without MapMode-Offset, without Offset, o ... !!!!!
1617 : aPt = GetOut()->LogicToPixel(
1618 0 : aPt, MapMode( MAP_TWIP ) );
1619 0 : ((( *pURL += "?" ) += OUString::number( aPt.getX() ))
1620 0 : += "," ) += OUString::number(aPt.getY() );
1621 : }
1622 : }
1623 0 : pRet = pFly->GetFmt();
1624 : }
1625 0 : if ( bSetTargetFrameName )
1626 0 : *pTargetFrameName = rURL.GetTargetFrameName();
1627 0 : if ( bSetDescription )
1628 0 : *pDescription = pFly->GetFmt()->GetName();
1629 : }
1630 : }
1631 0 : pDView->SetHitTolerancePixel( nOld );
1632 0 : return pRet;
1633 : }
1634 :
1635 0 : const Graphic *SwFEShell::GetGrfAtPos( const Point &rPt,
1636 : OUString &rName, sal_Bool &rbLink ) const
1637 : {
1638 0 : if( !Imp()->HasDrawView() )
1639 0 : return 0;
1640 :
1641 : SdrObject* pObj;
1642 : SdrPageView* pPV;
1643 0 : SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
1644 :
1645 0 : if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV ) && pObj->ISA(SwVirtFlyDrawObj) )
1646 : {
1647 0 : SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
1648 0 : if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
1649 : {
1650 0 : SwGrfNode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode();
1651 0 : if ( pNd )
1652 : {
1653 0 : if ( pNd->IsGrfLink() )
1654 : {
1655 : // halfway ready graphic?
1656 0 : ::sfx2::SvLinkSource* pLnkObj = pNd->GetLink()->GetObj();
1657 0 : if( pLnkObj && pLnkObj->IsPending() )
1658 0 : return 0;
1659 0 : rbLink = sal_True;
1660 : }
1661 :
1662 0 : pNd->GetFileFilterNms( &rName, 0 );
1663 0 : if ( rName.isEmpty() )
1664 0 : rName = pFly->GetFmt()->GetName();
1665 0 : pNd->SwapIn( true );
1666 0 : return &pNd->GetGrf();
1667 : }
1668 : }
1669 : }
1670 0 : return 0;
1671 : }
1672 :
1673 0 : const SwFrmFmt* SwFEShell::GetFmtFromObj( const Point& rPt, SwRect** pRectToFill ) const
1674 : {
1675 0 : SwFrmFmt* pRet = 0;
1676 :
1677 0 : if( Imp()->HasDrawView() )
1678 : {
1679 : SdrObject* pObj;
1680 : SdrPageView* pPView;
1681 :
1682 0 : SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
1683 :
1684 0 : sal_uInt16 nOld = pDView->GetHitTolerancePixel();
1685 : // tolerance for Drawing-SS
1686 0 : pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
1687 :
1688 0 : if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE ) )
1689 : {
1690 : // first check it:
1691 0 : if ( pObj->ISA(SwVirtFlyDrawObj) )
1692 0 : pRet = ((SwVirtFlyDrawObj*)pObj)->GetFmt();
1693 0 : else if ( pObj->GetUserCall() ) //not for group objects
1694 0 : pRet = ((SwDrawContact*)pObj->GetUserCall())->GetFmt();
1695 0 : if(pRet && pRectToFill)
1696 0 : **pRectToFill = pObj->GetCurrentBoundRect();
1697 : }
1698 0 : pDView->SetHitTolerancePixel( nOld );
1699 : }
1700 0 : return pRet;
1701 : }
1702 :
1703 : // returns a format too, if the point is over the text of any fly
1704 0 : const SwFrmFmt* SwFEShell::GetFmtFromAnyObj( const Point& rPt ) const
1705 : {
1706 0 : const SwFrmFmt* pRet = GetFmtFromObj( rPt );
1707 0 : if( !pRet || RES_FLYFRMFMT == pRet->Which() )
1708 : {
1709 0 : SwPosition aPos( *GetCrsr()->GetPoint() );
1710 0 : Point aPt( rPt );
1711 0 : GetLayout()->GetCrsrOfst( &aPos, aPt );
1712 0 : SwCntntNode *pNd = aPos.nNode.GetNode().GetCntntNode();
1713 0 : SwFrm* pFrm = pNd->getLayoutFrm( GetLayout(), &rPt, 0, false )->FindFlyFrm();
1714 0 : pRet = pFrm ? ((SwLayoutFrm*)pFrm)->GetFmt() : 0;
1715 : }
1716 0 : return pRet;
1717 : }
1718 :
1719 0 : ObjCntType SwFEShell::GetObjCntType( const SdrObject& rObj ) const
1720 : {
1721 0 : ObjCntType eType = OBJCNT_NONE;
1722 :
1723 : // investigate 'master' drawing object, if method
1724 : // is called for a 'virtual' drawing object.
1725 : const SdrObject* pInvestigatedObj;
1726 0 : if ( rObj.ISA(SwDrawVirtObj) )
1727 : {
1728 0 : const SwDrawVirtObj* pDrawVirtObj = static_cast<const SwDrawVirtObj*>(&rObj);
1729 0 : pInvestigatedObj = &(pDrawVirtObj->GetReferencedObj());
1730 : }
1731 : else
1732 : {
1733 0 : pInvestigatedObj = &rObj;
1734 : }
1735 :
1736 0 : if( FmFormInventor == pInvestigatedObj->GetObjInventor() )
1737 : {
1738 0 : eType = OBJCNT_CONTROL;
1739 : uno::Reference< awt::XControlModel > xModel =
1740 0 : ((SdrUnoObj&)(*pInvestigatedObj)).GetUnoControlModel();
1741 0 : if( xModel.is() )
1742 : {
1743 0 : uno::Any aVal;
1744 0 : OUString sName("ButtonType");
1745 0 : uno::Reference< beans::XPropertySet > xSet(xModel, uno::UNO_QUERY);
1746 :
1747 0 : uno::Reference< beans::XPropertySetInfo > xInfo = xSet->getPropertySetInfo();
1748 0 : if(xInfo->hasPropertyByName( sName ))
1749 : {
1750 0 : beans::Property xProperty = xInfo->getPropertyByName( sName );
1751 0 : aVal = xSet->getPropertyValue( sName );
1752 0 : if( aVal.getValue() && form::FormButtonType_URL == *((form::FormButtonType*)aVal.getValue()) )
1753 0 : eType = OBJCNT_URLBUTTON;
1754 0 : }
1755 0 : }
1756 : }
1757 0 : else if( pInvestigatedObj->ISA(SwVirtFlyDrawObj) )
1758 : {
1759 0 : SwFlyFrm *pFly = ((SwVirtFlyDrawObj&)(*pInvestigatedObj)).GetFlyFrm();
1760 0 : if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
1761 : {
1762 0 : if ( ((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode() )
1763 0 : eType = OBJCNT_GRF;
1764 : else
1765 0 : eType = OBJCNT_OLE;
1766 : }
1767 : else
1768 0 : eType = OBJCNT_FLY;
1769 : }
1770 0 : else if ( pInvestigatedObj->ISA( SdrObjGroup ) )
1771 : {
1772 0 : SwDrawContact* pDrawContact( dynamic_cast<SwDrawContact*>(GetUserCall( pInvestigatedObj ) ) );
1773 0 : if ( !pDrawContact )
1774 : {
1775 : OSL_FAIL( "<SwFEShell::GetObjCntType(..)> - missing draw contact object" );
1776 0 : eType = OBJCNT_NONE;
1777 : }
1778 : else
1779 : {
1780 0 : SwFrmFmt* pFrmFmt( pDrawContact->GetFmt() );
1781 0 : if ( !pFrmFmt )
1782 : {
1783 : OSL_FAIL( "<SwFEShell::GetObjCntType(..)> - missing frame format" );
1784 0 : eType = OBJCNT_NONE;
1785 : }
1786 0 : else if ( FLY_AS_CHAR != pFrmFmt->GetAnchor().GetAnchorId() )
1787 : {
1788 0 : eType = OBJCNT_GROUPOBJ;
1789 : }
1790 : }
1791 : }
1792 : else
1793 0 : eType = OBJCNT_SIMPLE;
1794 0 : return eType;
1795 : }
1796 :
1797 0 : ObjCntType SwFEShell::GetObjCntType( const Point &rPt, SdrObject *&rpObj ) const
1798 : {
1799 0 : ObjCntType eType = OBJCNT_NONE;
1800 :
1801 0 : if( Imp()->HasDrawView() )
1802 : {
1803 : SdrObject* pObj;
1804 : SdrPageView* pPView;
1805 :
1806 0 : SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
1807 :
1808 0 : sal_uInt16 nOld = pDView->GetHitTolerancePixel();
1809 : // tolerance for Drawing-SS
1810 0 : pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
1811 :
1812 0 : if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE ) )
1813 0 : eType = GetObjCntType( *(rpObj = pObj) );
1814 :
1815 0 : pDView->SetHitTolerancePixel( nOld );
1816 : }
1817 0 : return eType;
1818 : }
1819 :
1820 0 : ObjCntType SwFEShell::GetObjCntTypeOfSelection( SdrObject** ppObj ) const
1821 : {
1822 0 : ObjCntType eType = OBJCNT_NONE;
1823 :
1824 0 : if( Imp()->HasDrawView() )
1825 : {
1826 0 : const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
1827 0 : for( sal_uInt32 i = 0, nE = rMrkList.GetMarkCount(); i < nE; ++i )
1828 : {
1829 0 : SdrObject* pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
1830 0 : if( !pObj )
1831 0 : continue;
1832 0 : ObjCntType eTmp = GetObjCntType( *pObj );
1833 0 : if( !i )
1834 : {
1835 0 : eType = eTmp;
1836 0 : if( ppObj ) *ppObj = pObj;
1837 : }
1838 0 : else if( eTmp != eType )
1839 : {
1840 0 : eType = OBJCNT_DONTCARE;
1841 : // once DontCare, always DontCare!
1842 0 : break;
1843 : }
1844 : }
1845 : }
1846 0 : return eType;
1847 : }
1848 :
1849 0 : sal_Bool SwFEShell::ReplaceSdrObj( const OUString& rGrfName, const OUString& rFltName,
1850 : const Graphic* pGrf )
1851 : {
1852 0 : SET_CURR_SHELL( this );
1853 :
1854 0 : sal_Bool bRet = sal_False;
1855 : const SdrMarkList *pMrkList;
1856 0 : if( Imp()->HasDrawView() && 1 ==
1857 0 : ( pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList())->GetMarkCount() )
1858 : {
1859 0 : SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
1860 0 : SwFrmFmt *pFmt = FindFrmFmt( pObj );
1861 :
1862 : // store attributes, then set the graphic
1863 0 : SfxItemSet aFrmSet( mpDoc->GetAttrPool(),
1864 0 : pFmt->GetAttrSet().GetRanges() );
1865 0 : aFrmSet.Set( pFmt->GetAttrSet() );
1866 :
1867 : // set size and position?
1868 0 : if( !pObj->ISA(SwVirtFlyDrawObj) )
1869 : {
1870 : // then let's do it:
1871 0 : const Rectangle &rBound = pObj->GetSnapRect();
1872 0 : Point aRelPos( pObj->GetRelativePos() );
1873 :
1874 0 : const long nWidth = rBound.Right() - rBound.Left();
1875 0 : const long nHeight= rBound.Bottom() - rBound.Top();
1876 : aFrmSet.Put( SwFmtFrmSize( ATT_MIN_SIZE,
1877 0 : std::max( nWidth, long(MINFLY) ),
1878 0 : std::max( nHeight, long(MINFLY) )));
1879 :
1880 0 : if( SFX_ITEM_SET != aFrmSet.GetItemState( RES_HORI_ORIENT ))
1881 0 : aFrmSet.Put( SwFmtHoriOrient( aRelPos.getX(), text::HoriOrientation::NONE, text::RelOrientation::FRAME ));
1882 :
1883 0 : if( SFX_ITEM_SET != aFrmSet.GetItemState( RES_VERT_ORIENT ))
1884 0 : aFrmSet.Put( SwFmtVertOrient( aRelPos.getY(), text::VertOrientation::NONE, text::RelOrientation::FRAME ));
1885 :
1886 : }
1887 :
1888 0 : pObj->GetOrdNum();
1889 :
1890 0 : StartAllAction();
1891 0 : StartUndo();
1892 :
1893 : // delete "Sdr-Object", insert the graphic instead
1894 0 : DelSelectedObj();
1895 :
1896 0 : GetDoc()->Insert( *GetCrsr(), rGrfName, rFltName, pGrf, &aFrmSet, NULL, NULL );
1897 :
1898 0 : EndUndo();
1899 0 : EndAllAction();
1900 0 : bRet = sal_True;
1901 : }
1902 0 : return bRet;
1903 : }
1904 :
1905 0 : static sal_uInt16 SwFmtGetPageNum(const SwFlyFrmFmt * pFmt)
1906 : {
1907 : OSL_ENSURE(pFmt != NULL, "invalid argument");
1908 :
1909 0 : SwFlyFrm * pFrm = pFmt->GetFrm();
1910 :
1911 : sal_uInt16 aResult;
1912 :
1913 0 : if (pFrm != NULL)
1914 0 : aResult = pFrm->GetPhyPageNum();
1915 : else
1916 0 : aResult = pFmt->GetAnchor().GetPageNum();
1917 :
1918 0 : return aResult;
1919 : }
1920 :
1921 : #include <fmtcnct.hxx>
1922 :
1923 0 : void SwFEShell::GetConnectableFrmFmts(SwFrmFmt & rFmt,
1924 : const OUString & rReference,
1925 : sal_Bool bSuccessors,
1926 : ::std::vector< OUString > & aPrevPageVec,
1927 : ::std::vector< OUString > & aThisPageVec,
1928 : ::std::vector< OUString > & aNextPageVec,
1929 : ::std::vector< OUString > & aRestVec)
1930 : {
1931 0 : StartAction();
1932 :
1933 0 : SwFmtChain rChain = rFmt.GetChain();
1934 0 : SwFrmFmt * pOldChainNext = (SwFrmFmt *) rChain.GetNext();
1935 0 : SwFrmFmt * pOldChainPrev = (SwFrmFmt *) rChain.GetPrev();
1936 :
1937 0 : if (pOldChainNext)
1938 0 : mpDoc->Unchain(rFmt);
1939 :
1940 0 : if (pOldChainPrev)
1941 0 : mpDoc->Unchain(*pOldChainPrev);
1942 :
1943 0 : sal_uInt16 nCnt = mpDoc->GetFlyCount(FLYCNTTYPE_FRM);
1944 :
1945 : /* potential successors resp. predecessors */
1946 0 : ::std::vector< const SwFrmFmt * > aTmpSpzArray;
1947 :
1948 0 : mpDoc->FindFlyByName(rReference);
1949 :
1950 0 : for (sal_uInt16 n = 0; n < nCnt; n++)
1951 : {
1952 0 : const SwFrmFmt & rFmt1 = *(mpDoc->GetFlyNum(n, FLYCNTTYPE_FRM));
1953 :
1954 : /*
1955 : pFmt is a potential successor of rFmt if it is chainable after
1956 : rFmt.
1957 :
1958 : pFmt is a potential predecessor of rFmt if rFmt is chainable
1959 : after pFmt.
1960 : */
1961 :
1962 : int nChainState;
1963 :
1964 0 : if (bSuccessors)
1965 0 : nChainState = mpDoc->Chainable(rFmt, rFmt1);
1966 : else
1967 0 : nChainState = mpDoc->Chainable(rFmt1, rFmt);
1968 :
1969 0 : if (nChainState == SW_CHAIN_OK)
1970 : {
1971 0 : aTmpSpzArray.push_back(&rFmt1);
1972 :
1973 : }
1974 :
1975 : }
1976 :
1977 0 : if (aTmpSpzArray.size() > 0)
1978 : {
1979 0 : aPrevPageVec.clear();
1980 0 : aThisPageVec.clear();
1981 0 : aNextPageVec.clear();
1982 0 : aRestVec.clear();
1983 :
1984 : /* number of page rFmt resides on */
1985 0 : sal_uInt16 nPageNum = SwFmtGetPageNum((SwFlyFrmFmt *) &rFmt);
1986 :
1987 0 : ::std::vector< const SwFrmFmt * >::const_iterator aIt;
1988 :
1989 0 : for (aIt = aTmpSpzArray.begin(); aIt != aTmpSpzArray.end(); ++aIt)
1990 : {
1991 0 : const OUString aString = (*aIt)->GetName();
1992 :
1993 : /* rFmt is not a vaild successor or predecessor of
1994 : itself */
1995 0 : if (aString != rReference && aString != rFmt.GetName())
1996 : {
1997 : sal_uInt16 nNum1 =
1998 0 : SwFmtGetPageNum((SwFlyFrmFmt *) *aIt);
1999 :
2000 0 : if (nNum1 == nPageNum -1)
2001 0 : aPrevPageVec.push_back(aString);
2002 0 : else if (nNum1 == nPageNum)
2003 0 : aThisPageVec.push_back(aString);
2004 0 : else if (nNum1 == nPageNum + 1)
2005 0 : aNextPageVec.push_back(aString);
2006 : else
2007 0 : aRestVec.push_back(aString);
2008 : }
2009 0 : }
2010 :
2011 : }
2012 :
2013 0 : if (pOldChainNext)
2014 0 : mpDoc->Chain(rFmt, *pOldChainNext);
2015 :
2016 0 : if (pOldChainPrev)
2017 0 : mpDoc->Chain(*pOldChainPrev, rFmt);
2018 :
2019 0 : EndAction();
2020 0 : }
2021 :
2022 : // #i73249#
2023 0 : OUString SwFEShell::GetObjTitle() const
2024 : {
2025 0 : if ( Imp()->HasDrawView() )
2026 : {
2027 0 : const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
2028 0 : if ( pMrkList->GetMarkCount() == 1 )
2029 : {
2030 0 : const SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
2031 0 : const SwFrmFmt* pFmt = FindFrmFmt( pObj );
2032 0 : if ( pFmt->Which() == RES_FLYFRMFMT )
2033 : {
2034 0 : return dynamic_cast<const SwFlyFrmFmt*>(pFmt)->GetObjTitle();
2035 : }
2036 0 : return pObj->GetTitle();
2037 : }
2038 : }
2039 :
2040 0 : return OUString();
2041 : }
2042 :
2043 0 : void SwFEShell::SetObjTitle( const OUString& rTitle )
2044 : {
2045 0 : if ( Imp()->HasDrawView() )
2046 : {
2047 0 : const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
2048 0 : if ( pMrkList->GetMarkCount() == 1 )
2049 : {
2050 0 : SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
2051 0 : SwFrmFmt* pFmt = FindFrmFmt( pObj );
2052 0 : if ( pFmt->Which() == RES_FLYFRMFMT )
2053 : {
2054 : GetDoc()->SetFlyFrmTitle( *(dynamic_cast<SwFlyFrmFmt*>(pFmt)),
2055 0 : rTitle );
2056 : }
2057 : else
2058 : {
2059 0 : pObj->SetTitle( rTitle );
2060 : }
2061 : }
2062 : }
2063 0 : }
2064 :
2065 0 : OUString SwFEShell::GetObjDescription() const
2066 : {
2067 0 : if ( Imp()->HasDrawView() )
2068 : {
2069 0 : const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
2070 0 : if ( pMrkList->GetMarkCount() == 1 )
2071 : {
2072 0 : const SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
2073 0 : const SwFrmFmt* pFmt = FindFrmFmt( pObj );
2074 0 : if ( pFmt->Which() == RES_FLYFRMFMT )
2075 : {
2076 0 : return dynamic_cast<const SwFlyFrmFmt*>(pFmt)->GetObjDescription();
2077 : }
2078 0 : return pObj->GetDescription();
2079 : }
2080 : }
2081 :
2082 0 : return OUString();
2083 : }
2084 :
2085 0 : void SwFEShell::SetObjDescription( const OUString& rDescription )
2086 : {
2087 0 : if ( Imp()->HasDrawView() )
2088 : {
2089 0 : const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
2090 0 : if ( pMrkList->GetMarkCount() == 1 )
2091 : {
2092 0 : SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
2093 0 : SwFrmFmt* pFmt = FindFrmFmt( pObj );
2094 0 : if ( pFmt->Which() == RES_FLYFRMFMT )
2095 : {
2096 0 : GetDoc()->SetFlyFrmDescription(dynamic_cast<SwFlyFrmFmt&>(*pFmt),
2097 0 : rDescription);
2098 : }
2099 : else
2100 : {
2101 0 : pObj->SetDescription( rDescription );
2102 : }
2103 : }
2104 : }
2105 0 : }
2106 :
2107 0 : void SwFEShell::AlignFormulaToBaseline( const uno::Reference < embed::XEmbeddedObject >& xObj, SwFlyFrm * pFly )
2108 : {
2109 : #if OSL_DEBUG_LEVEL > 0
2110 : SvGlobalName aCLSID( xObj->getClassID() );
2111 : const bool bStarMath = ( SotExchange::IsMath( aCLSID ) != 0 );
2112 : OSL_ENSURE( bStarMath, "AlignFormulaToBaseline should only be called for Math objects" );
2113 :
2114 : if ( !bStarMath )
2115 : return;
2116 : #endif
2117 :
2118 0 : if (!pFly)
2119 0 : pFly = FindFlyFrm( xObj );
2120 : OSL_ENSURE( pFly , "No fly frame!" );
2121 0 : SwFrmFmt * pFrmFmt = pFly ? pFly->GetFmt() : 0;
2122 :
2123 : // baseline to baseline alignment should only be applied to formulas anchored as char
2124 0 : if ( pFly && pFrmFmt && FLY_AS_CHAR == pFrmFmt->GetAnchor().GetAnchorId() )
2125 : {
2126 : // get baseline from Math object
2127 0 : uno::Any aBaseline;
2128 0 : if( svt::EmbeddedObjectRef::TryRunningState( xObj ) )
2129 : {
2130 0 : uno::Reference < beans::XPropertySet > xSet( xObj->getComponent(), uno::UNO_QUERY );
2131 0 : if ( xSet.is() )
2132 : {
2133 : try
2134 : {
2135 0 : aBaseline = xSet->getPropertyValue("BaseLine");
2136 : }
2137 0 : catch ( uno::Exception& )
2138 : {
2139 : OSL_FAIL( "Baseline could not be retrieved from Starmath!" );
2140 : }
2141 0 : }
2142 : }
2143 :
2144 0 : sal_Int32 nBaseline = ::comphelper::getINT32(aBaseline);
2145 0 : const MapMode aSourceMapMode( MAP_100TH_MM );
2146 0 : const MapMode aTargetMapMode( MAP_TWIP );
2147 0 : nBaseline = OutputDevice::LogicToLogic( nBaseline, aSourceMapMode.GetMapUnit(), aTargetMapMode.GetMapUnit() );
2148 :
2149 : OSL_ENSURE( nBaseline > 0, "Wrong value of Baseline while retrieving from Starmath!" );
2150 : //nBaseline must be moved by aPrt position
2151 0 : const SwFlyFrmFmt *pFlyFrmFmt = pFly->GetFmt();
2152 : OSL_ENSURE( pFlyFrmFmt, "fly frame format missing!" );
2153 0 : if ( pFlyFrmFmt )
2154 0 : nBaseline += pFlyFrmFmt->GetLastFlyFrmPrtRectPos().Y();
2155 :
2156 0 : const SwFmtVertOrient &rVert = pFrmFmt->GetVertOrient();
2157 0 : SwFmtVertOrient aVert( rVert );
2158 0 : aVert.SetPos( -nBaseline );
2159 0 : aVert.SetVertOrient( com::sun::star::text::VertOrientation::NONE );
2160 :
2161 0 : pFrmFmt->LockModify();
2162 0 : pFrmFmt->SetFmtAttr( aVert );
2163 0 : pFrmFmt->UnlockModify();
2164 0 : pFly->InvalidatePos();
2165 : }
2166 0 : }
2167 :
2168 0 : void SwFEShell::AlignAllFormulasToBaseline()
2169 : {
2170 0 : StartAllAction();
2171 :
2172 : SwStartNode *pStNd;
2173 0 : SwNodeIndex aIdx( *GetNodes().GetEndOfAutotext().StartOfSectionNode(), 1 );
2174 0 : while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) )
2175 : {
2176 0 : ++aIdx;
2177 0 : SwOLENode *pOleNode = dynamic_cast< SwOLENode * >( &aIdx.GetNode() );
2178 0 : if ( pOleNode )
2179 : {
2180 0 : const uno::Reference < embed::XEmbeddedObject > & xObj( pOleNode->GetOLEObj().GetOleRef() );
2181 0 : if (xObj.is())
2182 : {
2183 0 : SvGlobalName aCLSID( xObj->getClassID() );
2184 0 : if ( SotExchange::IsMath( aCLSID ) )
2185 0 : AlignFormulaToBaseline( xObj );
2186 0 : }
2187 : }
2188 :
2189 0 : aIdx.Assign( *pStNd->EndOfSectionNode(), + 1 );
2190 : }
2191 :
2192 0 : EndAllAction();
2193 0 : }
2194 :
2195 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
