?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sw / source / core / frmedt / feshview.cxx
blobe8c849cee09767d5bba9d692b3848b77d5299411
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: feshview.cxx,v $
10 * $Revision: 1.61.136.2 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33 #include <com/sun/star/embed/EmbedMisc.hpp>
34 #include "hintids.hxx"
35
36 #ifdef WIN
37 #define _FESHVIEW_ONLY_INLINE_NEEDED
38 #endif
39
40 #include <svx/svdobj.hxx>
41 #include <svx/svdouno.hxx>
42 #include <svx/svdoole2.hxx>
43 #include <svx/svdogrp.hxx>
44 #include <svx/svdocirc.hxx>
45 #include <svx/svdopath.hxx>
46 #include <svx/sxciaitm.hxx>
47 #include <svx/xfillit.hxx>
48 #include <svx/svdocapt.hxx>
49 #include <sfx2/app.hxx>
50 #include <svx/boxitem.hxx>
51 #include <svx/opaqitem.hxx>
52 #include <svx/protitem.hxx>
53 #include <svx/svdpage.hxx>
54 #include <svx/svdpagv.hxx>
55
56 #ifndef _POOLFMT_HRC
57 #include <poolfmt.hrc> // fuer InitFldTypes
58 #endif
59 #include <frmfmt.hxx>
60 #include <frmatr.hxx>
61 #include <fmtfsize.hxx>
62 #include <fmtanchr.hxx>
63 #include <fmtornt.hxx>
64 #include <fmtsrnd.hxx>
65 #include <fmtcntnt.hxx>
66 #include <fmtflcnt.hxx>
67 #include <fmtcnct.hxx>
68 #include <docary.hxx>
69 #include <tblsel.hxx>
70 #include <swtable.hxx>
71 #include <flyfrms.hxx>
72 #include "fesh.hxx"
73 #include "rootfrm.hxx"
74 #include "pagefrm.hxx"
75 #include "sectfrm.hxx"
76 #include "doc.hxx"
77 #include "dview.hxx"
78 #include "dflyobj.hxx"
79 #include "dcontact.hxx"
80 #include "viewimp.hxx"
81 #include "flyfrm.hxx"
82 #include "pam.hxx"
83 #include "ndole.hxx"
84 #include "ndgrf.hxx"
85 #include "ndtxt.hxx"
86 #include "viewopt.hxx" // fuer GetHTMLMode
87 #include "swundo.hxx"
88 #include "notxtfrm.hxx"
89 #include "txtfrm.hxx"
90 #include "txatbase.hxx"
91 #include "mdiexp.hxx" // fuer Update der Statuszeile bei drag
92 // OD 2004-05-24 #i28701#
93 #include <sortedobjs.hxx>
94 // --> OD 2006-03-06 #125892#
95 #include <HandleAnchorNodeChg.hxx>
96 // <--
97 #include <basegfx/polygon/b2dpolygon.hxx>
98
99 #define SCROLLVAL 75
100
101 using namespace com::sun::star;
102
103 //Tattergrenze fuer Drawing-SS
104 #define MINMOVE ((USHORT)GetOut()->PixelToLogic(Size(Imp()->GetDrawView()->GetMarkHdlSizePixel()/2,0)).Width())
105
106 SwFlyFrm *GetFlyFromMarked( const SdrMarkList *pLst, ViewShell *pSh )
107 {
108 if ( !pLst )
109 pLst = pSh->HasDrawView() ? &pSh->Imp()->GetDrawView()->GetMarkedObjectList():0;
110
111 if ( pLst && pLst->GetMarkCount() == 1 )
112 {
113 SdrObject *pO = pLst->GetMark( 0 )->GetMarkedSdrObj();
114 if ( pO->ISA(SwVirtFlyDrawObj) )
115 return ((SwVirtFlyDrawObj*)pO)->GetFlyFrm();
116 }
117 return 0;
118 }
119
120 void lcl_GrabCursor( SwFEShell* pSh, SwFlyFrm* pOldSelFly)
121 {
122 const SwFrmFmt *pFlyFmt = pSh->SelFlyGrabCrsr();
123 if( pFlyFmt && !pSh->ActionPend() &&
124 (!pOldSelFly || pOldSelFly->GetFmt() != pFlyFmt) )
125 {
126 // dann das evt. gesetzte Macro rufen
127 pSh->GetFlyMacroLnk().Call( (void*)pFlyFmt );
128 extern BOOL bNoInterrupt; // in swapp.cxx
129 // wir in dem Makro ein Dialog gestartet, dann kommt das
130 // MouseButtonUp zu diesem und nicht zu uns. Dadurch ist
131 // Flag bei uns immer gesetzt und schaltet nie die auf die
132 // entsp. Shell um !!!!!!!
133 bNoInterrupt = FALSE;
134 }
135 else if( !pFlyFmt || RES_DRAWFRMFMT == pFlyFmt->Which() )
136 {
137 // --> OD 2007-07-25 #136039#
138 // assure consistent cursor
139 pSh->KillPams();
140 pSh->ClearMark();
141 // <--
142 pSh->SetCrsr( pSh->Imp()->GetDrawView()->GetAllMarkedRect().TopLeft(), TRUE);
143 }
144 }
145
146 /*************************************************************************
147 |*
148 |* SwFEShell::SelectObj()
149 |*
150 |* Ersterstellung MA 16. Nov. 92
151 |* Letzte Aenderung MA 22. Oct. 96
152 |*
153 *************************************************************************/
154
155 BOOL SwFEShell::SelectObj( const Point& rPt, BYTE nFlag, SdrObject *pObj )
156 {
157 SwDrawView *pDView = Imp()->GetDrawView();
158 if(!pDView)
159 return sal_False;
160 SET_CURR_SHELL( this );
161 StartAction(); //Aktion ist Notwendig, damit nicht mehrere
162 //AttrChgdNotify (etwa durch Unmark->MarkListHasChgd)
163 //durchkommen
164
165 const SdrMarkList &rMrkList = pDView->GetMarkedObjectList();
166 const BOOL bHadSelection = rMrkList.GetMarkCount() ? TRUE : FALSE;
167 const BOOL bAddSelect = 0 != (SW_ADD_SELECT & nFlag);
168 const BOOL bEnterGroup = 0 != (SW_ENTER_GROUP & nFlag);
169 SwFlyFrm* pOldSelFly = 0;
170 const Point aOldPos( pDView->GetAllMarkedRect().TopLeft() );
171
172 if( bHadSelection )
173 {
174 //Unmark rufen wenn !bAddSelect oder wenn ein Fly selektiert ist.
175 BOOL bUnmark = !bAddSelect;
176
177 if ( rMrkList.GetMarkCount() == 1 )
178 {
179 //Wenn ein Fly selektiert ist, so muss er erst deselektiert werden.
180 pOldSelFly = ::GetFlyFromMarked( &rMrkList, this );
181 if ( pOldSelFly )
182 {
183 const USHORT nType = GetCntType();
184 if( nType != CNT_TXT || (SW_LEAVE_FRAME & nFlag) ||
185 ( pOldSelFly->GetFmt()->GetProtect().IsCntntProtected()
186 && !IsReadOnlyAvailable() ))
187 {
188 //Wenn ein Fly deselektiert wird, der Grafik, Ole o.ae.
189 //enthaelt, so muss der Crsr aus diesem entfernt werden.
190 //Desgleichen wenn ein Fly mit geschuetztem Inhalt deselektiert
191 //wird. Der Einfachheit halber wire der Crsr 'grad so neben die
192 //linke obere Ecke gesetzt.
193 Point aPt( pOldSelFly->Frm().Pos() );
194 aPt.X() -= 1;
195 BOOL bUnLockView = !IsViewLocked();
196 LockView( TRUE );
197 SetCrsr( aPt, TRUE );
198 if( bUnLockView )
199 LockView( FALSE );
200 }
201 if ( nType & CNT_GRF &&
202 ((SwNoTxtFrm*)pOldSelFly->Lower())->HasAnimation() )
203 {
204 GetWin()->Invalidate( pOldSelFly->Frm().SVRect() );
205 }
206 bUnmark = TRUE;
207 }
208 }
209 if ( bUnmark )
210 pDView->UnmarkAll();
211 }
212 else
213 {
214 KillPams();
215 ClearMark();
216 }
217
218 if ( pObj )
219 {
220 ASSERT( !bEnterGroup, "SW_ENTER_GROUP is not supported" );
221 pDView->MarkObj( pObj, Imp()->GetPageView() );
222 }
223 else
224 {
225 pDView->MarkObj( rPt, MINMOVE, bAddSelect, bEnterGroup );
226 }
227
228 const BOOL bRet = 0 != rMrkList.GetMarkCount();
229
230 if ( rMrkList.GetMarkCount() > 1 )
231 {
232 //Ganz dumm ist es, wenn Zeichenobjekte Selektiert waren und
233 //nun ein Fly hinzuselektiert wird.
234 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
235 {
236 SdrObject *pTmpObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
237 BOOL bForget = pTmpObj->ISA(SwVirtFlyDrawObj);
238 if( bForget )
239 {
240 pDView->UnmarkAll();
241 if ( pTmpObj )
242 pDView->MarkObj( pTmpObj, Imp()->GetPageView(), bAddSelect, bEnterGroup );
243 else
244 pDView->MarkObj( rPt, MINMOVE );
245 break;
246 }
247 }
248 }
249
250 if ( bRet )
251 {
252 ::lcl_GrabCursor(this, pOldSelFly);
253 if ( GetCntType() & CNT_GRF )
254 {
255 const SwFlyFrm *pTmp = GetFlyFromMarked( &rMrkList, this );
256 ASSERT( pTmp, "Graphic without Fly" );
257 if ( ((SwNoTxtFrm*)pTmp->Lower())->HasAnimation() )
258 ((SwNoTxtFrm*)pTmp->Lower())->StopAnimation( GetOut() );
259 }
260 }
261 else if ( !pOldSelFly && bHadSelection )
262 SetCrsr( aOldPos, TRUE);
263
264 if( bRet || !bHadSelection )
265 CallChgLnk();
266
267 // update der Statuszeile
268 ::FrameNotify( this, bRet ? FLY_DRAG_START : FLY_DRAG_END );
269
270 EndAction();
271 return bRet;
272 }
273
274 /*************************************************************************
275 |*
276 |* sal_Bool SwFEShell::MoveAnchor( USHORT nDir )
277 |*
278 |* Created AMA 05/28/2002
279 |* Last modify AMA 05/30/2002
280 |*
281 |* Description: MoveAnchor( nDir ) looked for an another Anchor for
282 |* the selected drawing object (or fly frame) in the given direction.
283 |* An object "as character" doesn't moves anyway.
284 |* A page bounded object could move to the previous/next page with up/down,
285 |* an object bounded "at paragraph" moves to the previous/next paragraph, too.
286 |* An object bounded "at character" moves to the previous/next paragraph
287 |* with up/down and to the previous/next character with left/right.
288 |* If the anchor for at paragraph/character bounded objects has vertical or
289 |* right_to_left text direction, the directions for up/down/left/right will
290 |* interpreted accordingly.
291 |* An object bounded "at fly" takes the center of the actual anchor and looks
292 |* for the nearest fly frame in the given direction.
293 |*
294 *************************************************************************/
295
296 #define LESS_X( aPt1, aPt2, bOld ) ( aPt1.X() < aPt2.X() || \
297 ( aPt1.X() == aPt2.X() && ( aPt1.Y() < aPt2.Y() || \
298 ( aPt1.Y() == aPt2.Y() && bOld ) ) ) )
299 #define LESS_Y( aPt1, aPt2, bOld ) ( aPt1.Y() < aPt2.Y() || \
300 ( aPt1.Y() == aPt2.Y() && ( aPt1.X() < aPt2.X() || \
301 ( aPt1.X() == aPt2.X() && bOld ) ) ) )
302
303 sal_Bool SwFEShell::MoveAnchor( USHORT nDir )
304 {
305 const SdrMarkList* pMrkList;
306 if( !Imp()->GetDrawView() ||
307 0 == (pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList()) ||
308 1 != pMrkList->GetMarkCount())
309 return sal_False;
310 SwFrm* pOld;
311 SwFlyFrm* pFly = NULL;
312 SdrObject *pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
313 if( pObj->ISA(SwVirtFlyDrawObj) )
314 {
315 pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
316 pOld = pFly->AnchorFrm();
317 }
318 else
319 pOld = ((SwDrawContact*)GetUserCall(pObj))->GetAnchorFrm( pObj );
320 sal_Bool bRet = sal_False;
321 if( pOld )
322 {
323 SwFrm* pNew = pOld;
324 // --> OD 2004-07-16 #i28701#
325 SwAnchoredObject* pAnchoredObj = ::GetUserCall( pObj )->GetAnchoredObj( pObj );
326 SwFrmFmt& rFmt = pAnchoredObj->GetFrmFmt();
327 SwFmtAnchor aAnch( rFmt.GetAnchor() );
328 RndStdIds nAnchorId = aAnch.GetAnchorId();
329 if ( FLY_IN_CNTNT == nAnchorId )
330 return sal_False;
331 if( pOld->IsVertical() )
332 {
333 if( pOld->IsTxtFrm() )
334 {
335 switch( nDir ) {
336 case SW_MOVE_UP: nDir = SW_MOVE_LEFT; break;
337 case SW_MOVE_DOWN: nDir = SW_MOVE_RIGHT; break;
338 case SW_MOVE_LEFT: nDir = SW_MOVE_DOWN; break;
339 case SW_MOVE_RIGHT: nDir = SW_MOVE_UP; break;
340 }
341 if( pOld->IsRightToLeft() )
342 {
343 if( nDir == SW_MOVE_LEFT )
344 nDir = SW_MOVE_RIGHT;
345 else if( nDir == SW_MOVE_RIGHT )
346 nDir = SW_MOVE_LEFT;
347 }
348 }
349 }
350 switch ( nAnchorId ) {
351 case FLY_PAGE:
352 {
353 ASSERT( pOld->IsPageFrm(), "Wrong anchor, page exspected." );
354 if( SW_MOVE_UP == nDir )
355 pNew = pOld->GetPrev();
356 else if( SW_MOVE_DOWN == nDir )
357 pNew = pOld->GetNext();
358 if( pNew && pNew != pOld )
359 {
360 aAnch.SetPageNum( ((SwPageFrm*)pNew)->GetPhyPageNum() );
361 bRet = sal_True;
362 }
363 break;
364 }
365 case FLY_AUTO_CNTNT:
366 {
367 ASSERT( pOld->IsCntntFrm(), "Wrong anchor, page exspected." );
368 if( SW_MOVE_LEFT == nDir || SW_MOVE_RIGHT == nDir )
369 {
370 SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
371 SwTxtNode* pTxtNd = ((SwTxtFrm*)pOld)->GetTxtNode();
372 xub_StrLen nAct = pPos->nContent.GetIndex();
373 if( SW_MOVE_LEFT == nDir )
374 {
375 bRet = sal_True;
376 if( nAct )
377 {
378 --nAct;
379 pPos->nContent.Assign( pTxtNd, nAct );
380 }
381 else
382 nDir = SW_MOVE_UP;
383 }
384 else
385 {
386 xub_StrLen nMax =
387 ((SwTxtFrm*)pOld)->GetTxtNode()->GetTxt().Len();
388 if( nAct < nMax )
389 {
390 ++nAct;
391 bRet = sal_True;
392 pPos->nContent.Assign( pTxtNd, nAct );
393 }
394 else
395 nDir = SW_MOVE_DOWN;
396 }
397 }
398 } // no break!
399 case FLY_AT_CNTNT:
400 {
401 ASSERT( pOld->IsCntntFrm(), "Wrong anchor, page exspected." );
402 if( SW_MOVE_UP == nDir )
403 pNew = pOld->FindPrev();
404 else if( SW_MOVE_DOWN == nDir )
405 pNew = pOld->FindNext();
406 if( pNew && pNew != pOld && pNew->IsCntntFrm() )
407 {
408 SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
409 SwTxtNode* pTxtNd = ((SwTxtFrm*)pNew)->GetTxtNode();
410 pPos->nNode = *pTxtNd;
411 xub_StrLen nTmp = 0;
412 if( bRet )
413 {
414 nTmp = ((SwTxtFrm*)pNew)->GetTxtNode()->GetTxt().Len();
415 if( nTmp )
416 --nTmp;
417 }
418 pPos->nContent.Assign( pTxtNd, nTmp );
419 bRet = sal_True;
420 }
421 else if( SW_MOVE_UP == nDir || SW_MOVE_DOWN == nDir )
422 bRet = sal_False;
423 break;
424 }
425 case FLY_AT_FLY:
426 {
427 ASSERT( pOld->IsFlyFrm(), "Wrong anchor, fly frame exspected.");
428 SwPageFrm* pPage = pOld->FindPageFrm();
429 ASSERT( pPage, "Where's my page?" );
430 SwFlyFrm* pNewFly = NULL;
431 if( pPage->GetSortedObjs() )
432 {
433 int i;
434 sal_Bool bOld = sal_False;
435 Point aCenter( pOld->Frm().Left() + pOld->Frm().Width()/2,
436 pOld->Frm().Top() + pOld->Frm().Height()/2 );
437 Point aBest;
438 for( i = 0; (USHORT)i<pPage->GetSortedObjs()->Count(); ++i )
439 {
440 SwAnchoredObject* pAnchObj =
441 (*pPage->GetSortedObjs())[i];
442 if( pAnchObj->ISA(SwFlyFrm) )
443 {
444 SwFlyFrm* pTmp = static_cast<SwFlyFrm*>(pAnchObj);
445 if( pTmp == pOld )
446 bOld = sal_True;
447 else
448 {
449 const SwFlyFrm* pCheck = pFly ? pTmp : 0;
450 while( pCheck )
451 {
452 if( pCheck == pFly )
453 break;
454 const SwFrm *pNxt = pCheck->GetAnchorFrm();
455 pCheck = pNxt ? pNxt->FindFlyFrm() : NULL;
456 }
457 if( pCheck || pTmp->IsProtected() )
458 continue;
459 Point aNew( pTmp->Frm().Left() +
460 pTmp->Frm().Width()/2,
461 pTmp->Frm().Top() +
462 pTmp->Frm().Height()/2 );
463 sal_Bool bAccept = sal_False;
464 switch( nDir ) {
465 case SW_MOVE_RIGHT:
466 {
467 bAccept = LESS_X( aCenter, aNew, bOld )
468 && ( !pNewFly ||
469 LESS_X( aNew, aBest, sal_False ) );
470 break;
471 }
472 case SW_MOVE_LEFT:
473 {
474 bAccept = LESS_X( aNew, aCenter, !bOld )
475 && ( !pNewFly ||
476 LESS_X( aBest, aNew, sal_True ) );
477 break;
478 }
479 case SW_MOVE_UP:
480 {
481 bAccept = LESS_Y( aNew, aCenter, !bOld )
482 && ( !pNewFly ||
483 LESS_Y( aBest, aNew, sal_True ) );
484 break;
485 }
486 case SW_MOVE_DOWN:
487 {
488 bAccept = LESS_Y( aCenter, aNew, bOld )
489 && ( !pNewFly ||
490 LESS_Y( aNew, aBest, sal_False ) );
491 break;
492 }
493 }
494 if( bAccept )
495 {
496 pNewFly = pTmp;
497 aBest = aNew;
498 }
499 }
500 }
501 }
502 }
503
504 if( pNewFly )
505 {
506 SwPosition aPos( *pNewFly->GetFmt()->
507 GetCntnt().GetCntntIdx());
508 aAnch.SetAnchor( &aPos );
509 bRet = sal_True;
510 }
511 break;
512 }
513 default: break;
514 }
515 if( bRet )
516 {
517 StartAllAction();
518 // --> OD 2006-02-28 #125892#
519 // handle change of anchor node:
520 // if count of the anchor frame also change, the fly frames have to be
521 // re-created. Thus, delete all fly frames except the <this> before the
522 // anchor attribute is change and re-create them afterwards.
523 {
524 SwHandleAnchorNodeChg* pHandleAnchorNodeChg( 0L );
525 SwFlyFrmFmt* pFlyFrmFmt( dynamic_cast<SwFlyFrmFmt*>(&rFmt) );
526 if ( pFlyFrmFmt )
527 {
528 pHandleAnchorNodeChg =
529 new SwHandleAnchorNodeChg( *pFlyFrmFmt, aAnch );
530 }
531 rFmt.GetDoc()->SetAttr( aAnch, rFmt );
532 delete pHandleAnchorNodeChg;
533 }
534 // <--
535 // --> OD 2004-06-24 #i28701# - no call of method
536 // <CheckCharRectAndTopOfLine()> for to-character anchored
537 // Writer fly frame needed. This method call can cause a
538 // format of the anchor frame, which is no longer intended.
539 // Instead clear the anchor character rectangle and
540 // the top of line values for all to-character anchored objects.
541 pAnchoredObj->ClearCharRectAndTopOfLine();
542 EndAllAction();
543 }
544 }
545 return bRet;
546 }
547
548 /*************************************************************************
549 |*
550 |* SwFEShell::GetSelFrmType()
551 |*
552 |* Ersterstellung MA 12. Jan. 93
553 |* Letzte Aenderung JP 19.03.96
554 |*
555 *************************************************************************/
556
557 const SdrMarkList* SwFEShell::_GetMarkList() const
558 {
559 const SdrMarkList* pMarkList = NULL;
560 if( Imp()->GetDrawView() != NULL )
561 pMarkList = &Imp()->GetDrawView()->GetMarkedObjectList();
562 return pMarkList;
563 }
564
565 USHORT SwFEShell::GetSelFrmType() const
566 {
567 USHORT eType;
568
569 // get marked frame list, and check if anything is selected
570 const SdrMarkList* pMarkList = _GetMarkList();
571 if( pMarkList == NULL || pMarkList->GetMarkCount() == 0 )
572 eType = FRMTYPE_NONE;
573 else
574 {
575 // obtain marked item as fly frame; if no fly frame, it must
576 // be a draw object
577 const SwFlyFrm* pFly = ::GetFlyFromMarked(pMarkList, (ViewShell*)this);
578 if ( pFly != NULL )
579 {
580 if( pFly->IsFlyLayFrm() )
581 eType = FRMTYPE_FLY_FREE;
582 else if( pFly->IsFlyAtCntFrm() )
583 eType = FRMTYPE_FLY_ATCNT;
584 else
585 {
586 ASSERT( pFly->IsFlyInCntFrm(), "Neuer Rahmentyp?" );
587 eType = FRMTYPE_FLY_INCNT;
588 }
589 }
590 else
591 eType = FRMTYPE_DRAWOBJ;
592 }
593
594 return eType;
595 }
596
597 // #108784# does the draw selection contain a control?
598 bool SwFEShell::IsSelContainsControl() const
599 {
600 bool bRet = false;
601
602 // basically, copy the mechanism from GetSelFrmType(), but call
603 // CheckControl... if you get a drawing object
604 const SdrMarkList* pMarkList = _GetMarkList();
605 if( pMarkList != NULL && pMarkList->GetMarkCount() == 1 )
606 {
607 // if we have one marked object, get the SdrObject and check
608 // whether it contains a control
609 const SdrObject* pSdrObject = pMarkList->GetMark( 0 )->GetMarkedSdrObj();
610 bRet = CheckControlLayer( pSdrObject );
611 }
612 return bRet;
613 }
614
615 /*************************************************************************
616 |*
617 |* SwFEShell::Scroll()
618 |*
619 |* Ersterstellung MA 20. Dec. 94
620 |* Letzte Aenderung MA 27. Jul. 95
621 |*
622 *************************************************************************/
623
624 void SwFEShell::ScrollTo( const Point &rPt )
625 {
626 const SwRect aRect( rPt, rPt );
627 if ( IsScrollMDI( this, aRect ) &&
628 (!Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() ||
629 Imp()->IsDragPossible( rPt )) )
630 {
631 //SwSaveHdl aSave( Imp() );
632 ScrollMDI( this, aRect, SCROLLVAL, SCROLLVAL );
633 }
634 }
635
636 /*************************************************************************
637 |*
638 |* SwFEShell::SetDragMode()
639 |*
640 |* Ersterstellung MA 30. Jan. 95
641 |* Letzte Aenderung MA 30. Jan. 95
642 |*
643 *************************************************************************/
644
645 void SwFEShell::SetDragMode( UINT16 eDragMode )
646 {
647 if ( Imp()->HasDrawView() )
648 Imp()->GetDrawView()->SetDragMode( (SdrDragMode)eDragMode );
649 }
650
651 /*************************************************************************
652 |*
653 |* SwFEShell::BeginDrag()
654 |*
655 |* Ersterstellung MS 10.06.92
656 |* Letzte Aenderung MA 13. Mar. 96
657 |*
658 *************************************************************************/
659
660 long SwFEShell::BeginDrag( const Point* pPt, BOOL )
661 {
662 SdrView *pView = Imp()->GetDrawView();
663 if ( pView && pView->AreObjectsMarked() )
664 {
665 delete pChainFrom; delete pChainTo; pChainFrom = pChainTo = 0;
666 SdrHdl* pHdl = pView->PickHandle( *pPt );
667 pView->BegDragObj( *pPt, 0 /*GetWin()*/, pHdl );
668 ::FrameNotify( this, FLY_DRAG );
669 return 1;
670 }
671 return 0;
672 }
673 /*************************************************************************
674 |*
675 |* SwFEShell::Drag()
676 |*
677 |* Ersterstellung MS 10.06.92
678 |* Letzte Aenderung MA 13. Mar. 96
679 |*
680 *************************************************************************/
681
682 long SwFEShell::Drag( const Point *pPt, BOOL )
683 {
684 ASSERT( Imp()->HasDrawView(), "Drag without DrawView?" );
685 if ( Imp()->GetDrawView()->IsDragObj() )
686 {
687 ScrollTo( *pPt );
688 Imp()->GetDrawView()->MovDragObj( *pPt );
689 Imp()->GetDrawView()->ShowDragAnchor();
690 ::FrameNotify( this, FLY_DRAG );
691 return 1;
692 }
693 return 0;
694 }
695
696 /*************************************************************************
697 |*
698 |* SwFEShell::EndDrag()
699 |*
700 |* Ersterstellung MS 10.06.92
701 |* Letzte Aenderung MA 13. Mar. 96
702 |*
703 *************************************************************************/
704
705 long SwFEShell::EndDrag( const Point *, BOOL )
706 {
707 ASSERT( Imp()->HasDrawView(), "EndDrag without DrawView?" );
708 SdrView *pView = Imp()->GetDrawView();
709 if ( pView->IsDragObj() )
710 {
711 //Start-/EndActions nur an der ViewShell aufsetzen
712 ViewShell *pSh = this;
713 do {
714 pSh->StartAction();
715 } while ( this != (pSh = (ViewShell*)pSh->GetNext()) );
716
717 StartUndo( UNDO_START );
718
719 //#50778# Bug im Draging: Im StartAction wird ein HideShowXor gerufen.
720 //Im EndDragObj() wird dies unsinniger und faelschlicherweise wieder
721 //Rueckgaengig gemacht. Um Konsistenz herzustellen muessen wir das
722 //Xor also wieder zur Anzeige bringen.
723
724 // Reanimation from the hack #50778 to fix bug #97057
725 // May be not the best solution, but the one with lowest risc at the moment.
726 //pView->ShowShownXor( GetOut() );
727
728 pView->EndDragObj();
729 // JP 18.08.95: DrawUndo-Action auf FlyFrames werden nicht gespeichert
730 // Die Fly aendern das Flag
731 GetDoc()->SetNoDrawUndoObj( FALSE );
732 ChgAnchor( 0, TRUE );
733
734 EndUndo( UNDO_END );
735
736 do {
737 pSh->EndAction();
738 if( pSh->IsA( TYPE( SwCrsrShell ) ) )
739 ((SwCrsrShell*)pSh)->CallChgLnk();
740 } while ( this != (pSh = (ViewShell*)pSh->GetNext()) );
741
742 GetDoc()->SetModified();
743 ::FrameNotify( this, FLY_DRAG );
744 return 1;
745 }
746 return 0;
747 }
748
749 /*************************************************************************
750 |*
751 |* SwFEShell::BreakDrag()
752 |*
753 |* Ersterstellung OM 02. Okt. 95
754 |* Letzte Aenderung OM 02. Okt. 95
755 |*
756 *************************************************************************/
757
758 void SwFEShell::BreakDrag()
759 {
760 ASSERT( Imp()->HasDrawView(), "BreakDrag without DrawView?" );
761 if ( Imp()->GetDrawView()->IsDragObj() )
762 Imp()->GetDrawView()->BrkDragObj();
763 SetChainMarker();
764 }
765
766 /*************************************************************************
767 |*
768 |* SwFEShell::SelFlyGrabCrsr()
769 |*
770 |* Beschreibung Wenn ein Fly selektiert ist, zieht er den Crsr in
771 |* den ersten CntntFrm
772 |* Ersterstellung MA 11. Dec. 92
773 |* Letzte Aenderung MA 07. Oct. 96
774 |*
775 *************************************************************************/
776
777 const SwFrmFmt* SwFEShell::SelFlyGrabCrsr()
778 {
779 if ( Imp()->HasDrawView() )
780 {
781 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
782 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
783
784 if( pFly )
785 {
786 // --> OD 2004-06-11 #i28701# - no format here
787 // pFly->GetAnchorFrm()->Calc();
788 SwCntntFrm *pCFrm = pFly->ContainsCntnt();
789 if ( pCFrm )
790 {
791 SwCntntNode *pCNode = pCFrm->GetNode();
792 // --> OD 2007-07-25 #126039#
793 // assure, that the cursor is consistent.
794 KillPams();
795 ClearMark();
796 // <--
797 SwPaM *pCrsr = GetCrsr();
798
799 pCrsr->GetPoint()->nNode = *pCNode;
800 pCrsr->GetPoint()->nContent.Assign( pCNode, 0 );
801
802 SwRect& rChrRect = (SwRect&)GetCharRect();
803 rChrRect = pFly->Prt();
804 rChrRect.Pos() += pFly->Frm().Pos();
805 GetCrsrDocPos() = rChrRect.Pos();
806 }
807 return pFly->GetFmt();
808 }
809 }
810 return 0;
811 }
812
813
814 /*************************************************************************
815 |*
816 |* SwFEShell::SelectionToTop(), SelectionToBottom()
817 |*
818 |* Beschreibung Selektion nach oben/unten (Z-Order)
819 |*
820 |* Ersterstellung MA 05. Nov. 92
821 |* Letzte Aenderung MA 03. Jun. 96
822 |*
823 *************************************************************************/
824
825 void lcl_NotifyNeighbours( const SdrMarkList *pLst )
826 {
827 //Die Regeln fuer die Ausweichmanoever haben sich veraendert.
828 //1. Die Umgebung des Fly und aller innenliegenden muss benachrichtigt
829 // werden.
830 //2. Der Inhalt des Rahmen selbst muss benachrichtigt werden.
831 //3. Rahmen die dem Rahmen ausweichen bzw. wichen muessen benachrichtigt werden.
832 //4. Auch Zeichenobjekte koennen Rahmen verdraengen
833
834 for( USHORT j = 0; j < pLst->GetMarkCount(); ++j )
835 {
836 SwPageFrm *pPage;
837 BOOL bCheckNeighbours = FALSE;
838 sal_Int16 aHori = text::HoriOrientation::NONE;
839 SwRect aRect;
840 SdrObject *pO = pLst->GetMark( 0 )->GetMarkedSdrObj();
841 if ( pO->ISA(SwVirtFlyDrawObj) )
842 {
843 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pO)->GetFlyFrm();
844
845 const SwFmtHoriOrient &rHori = pFly->GetFmt()->GetHoriOrient();
846 aHori = rHori.GetHoriOrient();
847 if( text::HoriOrientation::NONE != aHori && text::HoriOrientation::CENTER != aHori &&
848 pFly->IsFlyAtCntFrm() )
849 {
850 bCheckNeighbours = TRUE;
851 pFly->InvalidatePos();
852 pFly->Frm().Pos().Y() += 1;
853 }
854
855 pPage = pFly->FindPageFrm();
856 aRect = pFly->Frm();
857 }
858 else
859 {
860 SwFrm* pAnch = ( (SwDrawContact*)GetUserCall(pO) )->GetAnchorFrm( pO );
861 if( !pAnch )
862 continue;
863 pPage = pAnch->FindPageFrm();
864 // --> OD 2006-08-15 #i68520# - naming changed
865 aRect = GetBoundRectOfAnchoredObj( pO );
866 // <--
867 }
868
869 sal_uInt32 nCount = pPage->GetSortedObjs() ? pPage->GetSortedObjs()->Count() : 0;
870 for ( sal_uInt32 i = 0; i < nCount; ++i )
871 {
872 SwAnchoredObject* pAnchoredObj = (*pPage->GetSortedObjs())[i];
873 if ( !pAnchoredObj->ISA(SwFlyFrm) )
874 continue;
875
876 SwFlyFrm* pAct = static_cast<SwFlyFrm*>(pAnchoredObj);
877 SwRect aTmpCalcPnt( pAct->Prt() );
878 aTmpCalcPnt += pAct->Frm().Pos();
879 if ( aRect.IsOver( aTmpCalcPnt ) )
880 {
881 SwCntntFrm *pCnt = pAct->ContainsCntnt();
882 while ( pCnt )
883 {
884 aTmpCalcPnt = pCnt->Prt();
885 aTmpCalcPnt += pCnt->Frm().Pos();
886 if ( aRect.IsOver( aTmpCalcPnt ) )
887 ((SwFrm*)pCnt)->Prepare( PREP_FLY_ATTR_CHG );
888 pCnt = pCnt->GetNextCntntFrm();
889 }
890 }
891 if ( bCheckNeighbours && pAct->IsFlyAtCntFrm() )
892 {
893 const SwFmtHoriOrient &rH = pAct->GetFmt()->GetHoriOrient();
894 if ( rH.GetHoriOrient() == aHori &&
895 pAct->Frm().Top() <= aRect.Bottom() &&
896 pAct->Frm().Bottom() >= aRect.Top() )
897 {
898 pAct->InvalidatePos();
899 pAct->Frm().Pos().Y() += 1;
900 }
901 }
902 }
903 }
904 }
905
906 void SwFEShell::SelectionToTop( BOOL bTop )
907 {
908 ASSERT( Imp()->HasDrawView(), "SelectionToTop without DrawView?" );
909 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
910 ASSERT( rMrkList.GetMarkCount(), "Kein Object Selektiert." );
911
912 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
913 if ( pFly && pFly->IsFlyInCntFrm() )
914 return;
915
916 StartAllAction();
917 if ( bTop )
918 Imp()->GetDrawView()->PutMarkedToTop();
919 else
920 Imp()->GetDrawView()->MovMarkedToTop();
921 ::lcl_NotifyNeighbours( &rMrkList );
922 GetDoc()->SetModified();
923 EndAllAction();
924 }
925
926 void SwFEShell::SelectionToBottom( BOOL bBottom )
927 {
928 ASSERT( Imp()->HasDrawView(), "SelectionToBottom without DrawView?" );
929 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
930 ASSERT( rMrkList.GetMarkCount(), "Kein Object Selektiert." );
931
932 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
933 if ( pFly && pFly->IsFlyInCntFrm() )
934 return;
935
936 StartAllAction();
937 if ( bBottom )
938 Imp()->GetDrawView()->PutMarkedToBtm();
939 else
940 Imp()->GetDrawView()->MovMarkedToBtm();
941 ::lcl_NotifyNeighbours( &rMrkList );
942 GetDoc()->SetModified();
943 EndAllAction();
944 }
945
946 /*************************************************************************
947 |*
948 |* SwFEShell::GetLayerId()
949 |*
950 |* Beschreibung Objekt ueber/unter dem Dokument?
951 |* 2 Controls, 1 Heaven, 0 Hell, -1 Uneindeutig
952 |* Ersterstellung MA 20. Dec. 94
953 |* Letzte Aenderung MA 20. Dec. 94
954 |*
955 *************************************************************************/
956
957 short SwFEShell::GetLayerId() const
958 {
959 short nRet = SHRT_MAX;
960 if ( Imp()->HasDrawView() )
961 {
962 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
963 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
964 {
965 const SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
966 if ( nRet == SHRT_MAX )
967 nRet = pObj->GetLayer();
968 else if ( nRet != pObj->GetLayer() )
969 {
970 nRet = -1;
971 break;
972 }
973 }
974 }
975 if ( nRet == SHRT_MAX )
976 nRet = -1;
977 return nRet;
978 }
979
980 /*************************************************************************
981 |*
982 |* SwFEShell::SelectionToHeaven(), SelectionToHell()
983 |*
984 |* Beschreibung Objekt ueber/unter dem Dokument
985 |* Ersterstellung MA 20. Dec. 94
986 |* Letzte Aenderung AMA 04. Jun. 98
987 |*
988 *************************************************************************/
989 // OD 25.06.2003 #108784#
990 // Note: only visible objects can be marked. Thus, objects with invisible
991 // layer IDs have not to be considered.
992 // If <SwFEShell> exists, layout exists!!
993 void SwFEShell::ChangeOpaque( SdrLayerID nLayerId )
994 {
995 if ( Imp()->HasDrawView() )
996 {
997 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
998 const IDocumentDrawModelAccess* pIDDMA = getIDocumentDrawModelAccess();
999 // OD 25.06.2003 #108784# - correct type of <nControls>
1000 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
1001 {
1002 SdrObject* pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
1003 // OD 21.08.2003 #i18447# - no change of layer for controls
1004 // or group objects containing controls.
1005 const bool bControlObj = ::CheckControlLayer( pObj );
1006 //if ( pObj->GetLayer() != nLayerId && pObj->GetLayer() != nControls )
1007 if ( !bControlObj && pObj->GetLayer() != nLayerId )
1008 {
1009 pObj->SetLayer( nLayerId );
1010 InvalidateWindows( SwRect( pObj->GetCurrentBoundRect() ) );
1011 if ( pObj->ISA(SwVirtFlyDrawObj) )
1012 {
1013 SwFmt *pFmt = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->GetFmt();
1014 SvxOpaqueItem aOpa( pFmt->GetOpaque() );
1015 aOpa.SetValue( nLayerId == pIDDMA->GetHellId() );
1016 pFmt->SetFmtAttr( aOpa );
1017 }
1018 }
1019 }
1020 GetDoc()->SetModified();
1021 }
1022 }
1023
1024 void SwFEShell::SelectionToHeaven()
1025 {
1026 ChangeOpaque( getIDocumentDrawModelAccess()->GetHeavenId() );
1027 }
1028
1029 void SwFEShell::SelectionToHell()
1030 {
1031 ChangeOpaque( getIDocumentDrawModelAccess()->GetHellId() );
1032 }
1033
1034 /*************************************************************************
1035 |*
1036 |* SwFEShell::IsObjSelected(), IsFrmSelected()
1037 |*
1038 |* Ersterstellung MA 16. Nov. 92
1039 |* Letzte Aenderung MA 17. Jan. 95
1040 |*
1041 *************************************************************************/
1042
1043 USHORT SwFEShell::IsObjSelected() const
1044 {
1045 if ( IsFrmSelected() || !Imp()->HasDrawView() )
1046 return 0;
1047 else
1048 return USHORT( Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() );
1049 }
1050
1051 BOOL SwFEShell::IsFrmSelected() const
1052 {
1053 if ( !Imp()->HasDrawView() )
1054 return FALSE;
1055 else
1056 return 0 != ::GetFlyFromMarked( &Imp()->GetDrawView()->GetMarkedObjectList(),
1057 (ViewShell*)this );
1058 }
1059
1060 sal_Bool SwFEShell::IsObjSelected( const SdrObject& rObj ) const
1061 {
1062 if ( IsFrmSelected() || !Imp()->HasDrawView() )
1063 return sal_False;
1064 else
1065 return Imp()->GetDrawView()
1066 ->IsObjMarked( const_cast< SdrObject * >( &rObj ) );
1067 }
1068
1069 /*************************************************************************
1070 |*
1071 |* SwFEShell::EndTextEdit()
1072 |*
1073 |* Ersterstellung MA 19. Feb. 96
1074 |* Letzte Aenderung MA 19. Feb. 96
1075 |*
1076 *************************************************************************/
1077
1078 void SwFEShell::EndTextEdit()
1079 {
1080 //Beenden des TextEditModus. Wenn gewuenscht (default wenn das Objekt
1081 //keinen Text mehr enthaelt und keine Attribute traegt) wird das
1082 //Objekt gel�scht. Alle anderen markierten Objekte bleiben erhalten.
1083
1084 ASSERT( Imp()->HasDrawView() && Imp()->GetDrawView()->IsTextEdit(),
1085 "EndTextEdit an no Object" );
1086
1087 StartAllAction();
1088 SdrView *pView = Imp()->GetDrawView();
1089 SdrObject *pObj = pView->GetTextEditObject();
1090 SdrObjUserCall* pUserCall;
1091 if( 0 != ( pUserCall = GetUserCall(pObj) ) )
1092 {
1093 SdrObject *pTmp = ((SwContact*)pUserCall)->GetMaster();
1094 if( !pTmp )
1095 pTmp = pObj;
1096 pUserCall->Changed( *pTmp, SDRUSERCALL_RESIZE, pTmp->GetLastBoundRect() );
1097 }
1098 if ( !pObj->GetUpGroup() )
1099 {
1100 if ( SDRENDTEXTEDIT_SHOULDBEDELETED == pView->SdrEndTextEdit(sal_True) )
1101 {
1102 if ( pView->GetMarkedObjectList().GetMarkCount() > 1 )
1103 {
1104 {
1105 SdrMarkList aSave( pView->GetMarkedObjectList() );
1106 aSave.DeleteMark( aSave.FindObject( pObj ) );
1107 if ( aSave.GetMarkCount() )
1108 {
1109 pView->UnmarkAll();
1110 pView->MarkObj( pObj, Imp()->GetPageView() );
1111 }
1112 DelSelectedObj();
1113 if ( aSave.GetMarkCount() )
1114 {
1115 for ( USHORT i = 0; i < aSave.GetMarkCount(); ++i )
1116 pView->MarkObj( aSave.GetMark( i )->GetMarkedSdrObj(),
1117 Imp()->GetPageView() );
1118 }
1119 }
1120 }
1121 else
1122 DelSelectedObj();
1123 }
1124 }
1125 else
1126 pView->SdrEndTextEdit();
1127 EndAllAction();
1128 }
1129
1130 /*************************************************************************
1131 |*
1132 |* SwFEShell::IsInsideSelectedObj()
1133 |*
1134 |* Ersterstellung MA 16. Nov. 92
1135 |* Letzte Aenderung MA 08. Nov. 96
1136 |*
1137 *************************************************************************/
1138
1139 int SwFEShell::IsInsideSelectedObj( const Point &rPt )
1140 {
1141 if( Imp()->HasDrawView() )
1142 {
1143 SwDrawView *pDView = Imp()->GetDrawView();
1144
1145 if( pDView->GetMarkedObjectList().GetMarkCount() &&
1146 pDView->IsMarkedObjHit( rPt ) )
1147 {
1148 return SDRHIT_OBJECT;
1149 }
1150 }
1151 return SDRHIT_NONE;
1152 }
1153
1154 /*************************************************************************
1155 |*
1156 |* SwFEShell::IsObjSelectable()
1157 |*
1158 |* Ersterstellung MA 16. Nov. 92
1159 |* Letzte Aenderung MA 02. Feb. 95
1160 |*
1161 *************************************************************************/
1162
1163 bool SwFEShell::IsObjSelectable( const Point& rPt )
1164 {
1165 SET_CURR_SHELL(this);
1166 #ifdef OLD
1167 if( Imp()->HasDrawView() )
1168 return Imp()->GetDrawView()->PickSomething( rPt, MINMOVE );
1169 return 0;
1170 #else
1171 SwDrawView *pDView = Imp()->GetDrawView();
1172 bool bRet = false;
1173 if( pDView )
1174 {
1175 SdrObject* pObj;
1176 SdrPageView* pPV;
1177 USHORT nOld = pDView->GetHitTolerancePixel();
1178 pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
1179
1180 bRet = 0 != pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMARKABLE );
1181 pDView->SetHitTolerancePixel( nOld );
1182 }
1183 return bRet;
1184 #endif
1185 }
1186
1187 // #107513#
1188 // Test if there is a draw object at that position and if it should be selected.
1189 // The 'should' is aimed at Writer text fly frames which may be in front of
1190 // the draw object.
1191 sal_Bool SwFEShell::ShouldObjectBeSelected(const Point& rPt)
1192 {
1193 SET_CURR_SHELL(this);
1194 SwDrawView *pDrawView = Imp()->GetDrawView();
1195 sal_Bool bRet(sal_False);
1196
1197 if(pDrawView)
1198 {
1199 SdrObject* pObj;
1200 SdrPageView* pPV;
1201 sal_uInt16 nOld(pDrawView->GetHitTolerancePixel());
1202
1203 pDrawView->SetHitTolerancePixel(pDrawView->GetMarkHdlSizePixel()/2);
1204 bRet = pDrawView->PickObj(rPt, pDrawView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMARKABLE);
1205 pDrawView->SetHitTolerancePixel(nOld);
1206
1207 if(bRet && pObj)
1208 {
1209 const IDocumentDrawModelAccess* pIDDMA = getIDocumentDrawModelAccess();
1210 if( pObj->GetLayer() == pIDDMA->GetHellId() )
1211 {
1212 const SwFrm *pPageFrm = GetLayout()->Lower();
1213 while( pPageFrm && !pPageFrm->Frm().IsInside( rPt ) )
1214 {
1215 if ( rPt.Y() < pPageFrm->Frm().Top() )
1216 pPageFrm = 0;
1217 else
1218 pPageFrm = pPageFrm->GetNext();
1219 }
1220 if( pPageFrm )
1221 {
1222 SwRect aTmp( pPageFrm->Prt() );
1223 aTmp += pPageFrm->Frm().Pos();
1224 if( aTmp.IsInside( rPt ) )
1225 return sal_False;
1226 }
1227 }
1228
1229 const SdrPage* pPage = pIDDMA->GetDrawModel()->GetPage(0);
1230 // --> FME 2005-04-18 #i20965# Use GetOrdNum() instead of GetOrdNumDirect()
1231 // because ordnums might be wrong
1232 for(sal_uInt32 a(pObj->GetOrdNum() + 1); bRet && a < pPage->GetObjCount(); a++)
1233 {
1234 // <--
1235 SdrObject *pCandidate = pPage->GetObj(a);
1236
1237 if(pCandidate->ISA(SwVirtFlyDrawObj) && ((SwVirtFlyDrawObj*)pCandidate)->GetCurrentBoundRect().IsInside(rPt))
1238 {
1239 bRet = sal_False;
1240 }
1241 }
1242 }
1243 }
1244
1245 return bRet;
1246 }
1247
1248 /*************************************************************************
1249 |*
1250 |* SwFEShell::GotoObj()
1251 |*
1252 |* Beschreibung Wenn ein Obj selektiert ist, gehen wir von dessen
1253 |* TopLeft aus, andernfalls von der Mitte des aktuellen CharRects.
1254 |* Ersterstellung MA 01. Jun. 95
1255 |* Letzte Aenderung MA 30. Apr. 96
1256 |*
1257 *************************************************************************/
1258 /* -----------------23.09.98 10:29-------------------
1259 * Beinhaltet das Objekt ein Control oder Gruppen,
1260 * die nur aus Controls bestehen
1261 * --------------------------------------------------*/
1262 BOOL lcl_IsControlGroup( const SdrObject *pObj )
1263 {
1264 BOOL bRet = FALSE;
1265 if(pObj->ISA(SdrUnoObj))
1266 bRet = TRUE;
1267 else if( pObj->ISA( SdrObjGroup ) )
1268 {
1269 bRet = TRUE;
1270 const SdrObjList *pLst = ((SdrObjGroup*)pObj)->GetSubList();
1271 for ( USHORT i = 0; i < pLst->GetObjCount(); ++i )
1272 if( !::lcl_IsControlGroup( pLst->GetObj( i ) ) )
1273 return FALSE;
1274 }
1275 return bRet;
1276 }
1277
1278 BOOL SwFEShell::GotoObj( BOOL bNext, USHORT /*GOTOOBJ_...*/ eType )
1279 {
1280 if( !Imp()->HasDrawView() )
1281 return FALSE;
1282 else
1283 {
1284 const SdrObject *pBest = 0,
1285 *pTop = 0;
1286
1287 const long nTmp = bNext ? LONG_MAX : 0;
1288 Point aBestPos( nTmp, nTmp );
1289 Point aTopPos( nTmp, nTmp );
1290 Point aCurPos;
1291 Point aPos;
1292 BOOL bRet = FALSE;
1293 BOOL bNoDraw = 0 == (GOTOOBJ_DRAW_ANY & eType);
1294 BOOL bNoFly = 0 == (GOTOOBJ_FLY_ANY & eType);
1295
1296 if( !bNoFly && bNoDraw )
1297 {
1298 SwFlyFrm *pFly = GetCurrFrm( FALSE )->FindFlyFrm();
1299 if( pFly )
1300 pBest = pFly->GetVirtDrawObj();
1301 }
1302 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
1303 SdrPageView* pPV = Imp()->GetDrawView()->GetSdrPageView();
1304
1305 if( !pBest || rMrkList.GetMarkCount() == 1 )
1306 {
1307 // Ausgangspunkt bestimmen.
1308 SdrObjList* pList = NULL;
1309 if ( rMrkList.GetMarkCount() )
1310 {
1311 const SdrObject* pStartObj = rMrkList.GetMark(0)->GetMarkedSdrObj();
1312 if( pStartObj->ISA(SwVirtFlyDrawObj) )
1313 aPos = ((SwVirtFlyDrawObj*)pStartObj)->GetFlyFrm()->Frm().Pos();
1314 else
1315 aPos = pStartObj->GetSnapRect().TopLeft();
1316
1317 // If an object inside a group is selected, we want to
1318 // iterate over the group members.
1319 if ( ! pStartObj->GetUserCall() )
1320 pList = pStartObj->GetObjList();
1321 }
1322 else
1323 {
1324 // If no object is selected, we check if we just entered a group.
1325 // In this case we want to iterate over the group members.
1326 aPos = GetCharRect().Center();
1327 const SdrObject* pStartObj = pPV ? pPV->GetAktGroup() : 0;
1328 if ( pStartObj && pStartObj->ISA( SdrObjGroup ) )
1329 pList = pStartObj->GetSubList();
1330 }
1331
1332 if ( ! pList )
1333 {
1334 // Here we are if
1335 // A No object has been selected and no group has been entered or
1336 // B An object has been selected and it is not inside a group
1337 pList = getIDocumentDrawModelAccess()->GetDrawModel()->GetPage( 0 );
1338 }
1339
1340
1341 ASSERT( pList, "No object list to iterate" )
1342
1343 const ULONG nObjs = pList->GetObjCount();
1344 for( ULONG nObj = 0; nObj < nObjs; ++nObj )
1345 {
1346 SdrObject* pObj = pList->GetObj( nObj );
1347 BOOL bFlyFrm = pObj->ISA(SwVirtFlyDrawObj);
1348 if( ( bNoFly && bFlyFrm ) ||
1349 ( bNoDraw && !bFlyFrm ) ||
1350 ( eType == GOTOOBJ_DRAW_SIMPLE && lcl_IsControlGroup( pObj ) ) ||
1351 ( eType == GOTOOBJ_DRAW_CONTROL && !lcl_IsControlGroup( pObj ) ) ||
1352 ( pPV && ! pPV->GetView().IsObjMarkable( pObj, pPV ) ) )
1353 continue;
1354 if( bFlyFrm )
1355 {
1356 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pObj;
1357 SwFlyFrm *pFly = pO->GetFlyFrm();
1358 if( GOTOOBJ_FLY_ANY != ( GOTOOBJ_FLY_ANY & eType ) )
1359 {
1360 switch ( eType )
1361 {
1362 case GOTOOBJ_FLY_FRM:
1363 if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
1364 continue;
1365 break;
1366 case GOTOOBJ_FLY_GRF:
1367 if ( pFly->Lower() &&
1368 (pFly->Lower()->IsLayoutFrm() ||
1369 !((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode()))
1370 continue;
1371 break;
1372 case GOTOOBJ_FLY_OLE:
1373 if ( pFly->Lower() &&
1374 (pFly->Lower()->IsLayoutFrm() ||
1375 !((SwCntntFrm*)pFly->Lower())->GetNode()->GetOLENode()))
1376 continue;
1377 break;
1378 }
1379 }
1380 aCurPos = pFly->Frm().Pos();
1381 }
1382 else
1383 aCurPos = pObj->GetCurrentBoundRect().TopLeft();
1384
1385 // Sonderfall wenn ein anderes Obj auf selber Y steht.
1386 if( aCurPos != aPos && // nur wenn ich es nicht selber bin
1387 aCurPos.Y() == aPos.Y() && // ist die Y Position gleich
1388 (bNext? (aCurPos.X() > aPos.X()) : // liegt neben mir
1389 (aCurPos.X() < aPos.X())) ) // " reverse
1390 {
1391 aBestPos = Point( nTmp, nTmp );
1392 for( ULONG i = 0; i < nObjs; ++i )
1393 {
1394 SdrObject *pTmpObj = pList->GetObj( i );
1395 bFlyFrm = pTmpObj->ISA(SwVirtFlyDrawObj);
1396 if( ( bNoFly && bFlyFrm ) || ( bNoDraw && !bFlyFrm ) )
1397 continue;
1398 if( bFlyFrm )
1399 {
1400 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pTmpObj;
1401 aCurPos = pO->GetFlyFrm()->Frm().Pos();
1402 }
1403 else
1404 aCurPos = pTmpObj->GetCurrentBoundRect().TopLeft();
1405
1406 if( aCurPos != aPos && aCurPos.Y() == aPos.Y() &&
1407 (bNext? (aCurPos.X() > aPos.X()) : // liegt neben mir
1408 (aCurPos.X() < aPos.X())) && // " reverse
1409 (bNext? (aCurPos.X() < aBestPos.X()) : // besser als Beste
1410 (aCurPos.X() > aBestPos.X())) ) // " reverse
1411 {
1412 aBestPos = aCurPos;
1413 pBest = pTmpObj;
1414 }
1415 }
1416 break;
1417 }
1418
1419 if( (bNext? (aPos.Y() < aCurPos.Y()) : // nur unter mir
1420 (aPos.Y() > aCurPos.Y())) && // " reverse
1421 (bNext? (aBestPos.Y() > aCurPos.Y()) : // naeher drunter
1422 (aBestPos.Y() < aCurPos.Y())) || // " reverse
1423 (aBestPos.Y() == aCurPos.Y() &&
1424 (bNext? (aBestPos.X() > aCurPos.X()) : // weiter links
1425 (aBestPos.X() < aCurPos.X())))) // " reverse
1426
1427 {
1428 aBestPos = aCurPos;
1429 pBest = pObj;
1430 }
1431
1432 if( (bNext? (aTopPos.Y() > aCurPos.Y()) : // hoeher als Beste
1433 (aTopPos.Y() < aCurPos.Y())) || // " reverse
1434 (aTopPos.Y() == aCurPos.Y() &&
1435 (bNext? (aTopPos.X() > aCurPos.X()) : // weiter links
1436 (aTopPos.X() < aCurPos.X())))) // " reverse
1437 {
1438 aTopPos = aCurPos;
1439 pTop = pObj;
1440 }
1441 }
1442 // leider nichts gefunden
1443 if( (bNext? (aBestPos.X() == LONG_MAX) : (aBestPos.X() == 0)) )
1444 pBest = pTop;
1445 }
1446
1447 if( pBest )
1448 {
1449 BOOL bFlyFrm = pBest->ISA(SwVirtFlyDrawObj);
1450 if( bFlyFrm )
1451 {
1452 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pBest;
1453 const SwRect& rFrm = pO->GetFlyFrm()->Frm();
1454 SelectObj( rFrm.Pos(), 0, (SdrObject*)pBest );
1455 if( !ActionPend() )
1456 MakeVisible( rFrm );
1457 }
1458 else
1459 {
1460 SelectObj( Point(), 0, (SdrObject*)pBest );
1461 if( !ActionPend() )
1462 MakeVisible( pBest->GetCurrentBoundRect() );
1463 }
1464 CallChgLnk();
1465 bRet = TRUE;
1466 }
1467 return bRet;
1468 }
1469 }
1470
1471 /*************************************************************************
1472 |*
1473 |* SwFEShell::BeginCreate()
1474 |*
1475 |* Ersterstellung MA 20. Dec. 94
1476 |* Letzte Aenderung MA 21. Mar. 95
1477 |*
1478 *************************************************************************/
1479
1480 BOOL SwFEShell::BeginCreate( UINT16 /*SdrObjKind ?*/ eSdrObjectKind, const Point &rPos )
1481 {
1482 BOOL bRet = FALSE;
1483
1484 if ( !Imp()->HasDrawView() )
1485 Imp()->MakeDrawView();
1486
1487 if ( GetPageNumber( rPos ) )
1488 {
1489 Imp()->GetDrawView()->SetCurrentObj( eSdrObjectKind );
1490 if ( eSdrObjectKind == OBJ_CAPTION )
1491 bRet = Imp()->GetDrawView()->BegCreateCaptionObj(
1492 rPos, Size( lMinBorder - MINFLY, lMinBorder - MINFLY ),
1493 GetOut() );
1494 else
1495 bRet = Imp()->GetDrawView()->BegCreateObj( rPos, GetOut() );
1496 }
1497 if ( bRet )
1498 {
1499 ::FrameNotify( this, FLY_DRAG_START );
1500 }
1501 return bRet;
1502 }
1503
1504 BOOL SwFEShell::BeginCreate( UINT16 /*SdrObjKind ?*/ eSdrObjectKind, UINT32 eObjInventor,
1505 const Point &rPos )
1506 {
1507 BOOL bRet = FALSE;
1508
1509 if ( !Imp()->HasDrawView() )
1510 Imp()->MakeDrawView();
1511
1512 if ( GetPageNumber( rPos ) )
1513 {
1514 Imp()->GetDrawView()->SetCurrentObj( eSdrObjectKind, eObjInventor );
1515 bRet = Imp()->GetDrawView()->BegCreateObj( rPos, GetOut() );
1516 }
1517 if ( bRet )
1518 ::FrameNotify( this, FLY_DRAG_START );
1519 return bRet;
1520 }
1521
1522 /*************************************************************************
1523 |*
1524 |* SwFEShell::MoveCreate()
1525 |*
1526 |* Ersterstellung MA 20. Dec. 94
1527 |* Letzte Aenderung MA 24. Jan. 95
1528 |*
1529 *************************************************************************/
1530
1531 void SwFEShell::MoveCreate( const Point &rPos )
1532 {
1533 ASSERT( Imp()->HasDrawView(), "MoveCreate without DrawView?" );
1534 if ( GetPageNumber( rPos ) )
1535 {
1536 ScrollTo( rPos );
1537 Imp()->GetDrawView()->MovCreateObj( rPos );
1538 ::FrameNotify( this, FLY_DRAG );
1539 }
1540 }
1541
1542 /*************************************************************************
1543 |*
1544 |* SwFEShell::EndCreate(), ImpEndCreate()
1545 |*
1546 |* Ersterstellung MA 20. Dec. 94
1547 |* Letzte Aenderung MA 14. Oct. 96
1548 |*
1549 *************************************************************************/
1550
1551 BOOL SwFEShell::EndCreate( UINT16 eSdrCreateCmd )
1552 {
1553 // JP 18.08.95: Damit das Undo-Object aus der DrawEngine nicht bei uns
1554 // gespeichert wird, (wir erzeugen ein eigenes Undo-Object!) hier kurz
1555 // das Undo abschalten
1556 ASSERT( Imp()->HasDrawView(), "EndCreate without DrawView?" );
1557 if( !Imp()->GetDrawView()->IsGroupEntered() )
1558 GetDoc()->SetNoDrawUndoObj( TRUE );
1559 BOOL bCreate = Imp()->GetDrawView()->EndCreateObj(
1560 SdrCreateCmd( eSdrCreateCmd ) );
1561 GetDoc()->SetNoDrawUndoObj( FALSE );
1562
1563 if ( !bCreate )
1564 {
1565 ::FrameNotify( this, FLY_DRAG_END );
1566 return FALSE;
1567 }
1568
1569 if ( (SdrCreateCmd)eSdrCreateCmd == SDRCREATE_NEXTPOINT )
1570 {
1571 ::FrameNotify( this, FLY_DRAG );
1572 return TRUE;
1573 }
1574 return ImpEndCreate();
1575 }
1576
1577
1578 BOOL SwFEShell::ImpEndCreate()
1579 {
1580 ASSERT( Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1,
1581 "Neues Object nicht selektiert." );
1582
1583 SdrObject& rSdrObj = *Imp()->GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
1584
1585 if( rSdrObj.GetSnapRect().IsEmpty() )
1586 {
1587 //JP 10.04.95: das Object vergessen wir lieber, fuerht nur
1588 // zu Problemen
1589 Imp()->GetDrawView()->DeleteMarked();
1590 Imp()->GetDrawView()->UnmarkAll();
1591 ::FrameNotify( this, FLY_DRAG_END );
1592 return FALSE;
1593 }
1594
1595 if( rSdrObj.GetUpGroup() )
1596 {
1597 Point aTmpPos( rSdrObj.GetSnapRect().TopLeft() );
1598 Point aNewAnchor( rSdrObj.GetUpGroup()->GetAnchorPos() );
1599 // OD 2004-04-05 #i26791# - direct object positioning for group members
1600 rSdrObj.NbcSetRelativePos( aTmpPos - aNewAnchor );
1601 rSdrObj.NbcSetAnchorPos( aNewAnchor );
1602 ::FrameNotify( this, FLY_DRAG );
1603 return TRUE;
1604 }
1605
1606 LockPaint();
1607 StartAllAction();
1608
1609 Imp()->GetDrawView()->UnmarkAll();
1610
1611 const Rectangle &rBound = rSdrObj.GetSnapRect();
1612 Point aPt( rBound.TopRight() );
1613
1614 //Fremde Identifier sollen in den Default laufen.
1615 //Ueberschneidungen sind moeglich!!
1616 UINT16 nIdent = SdrInventor == rSdrObj.GetObjInventor()
1617 ? rSdrObj.GetObjIdentifier()
1618 : 0xFFFF;
1619
1620 //Default fuer Controls ist Zeichengebunden, Absatzgebunden sonst.
1621 SwFmtAnchor aAnch;
1622 const SwFrm *pAnch = 0;
1623 BOOL bCharBound = FALSE;
1624 if( rSdrObj.ISA( SdrUnoObj ) )
1625 {
1626 SwPosition aPos( GetDoc()->GetNodes() );
1627 SwCrsrMoveState aState( MV_SETONLYTEXT );
1628 Point aPoint( aPt.X(), aPt.Y() + rBound.GetHeight()/2 );
1629 getIDocumentLayoutAccess()->GetRootFrm()->GetCrsrOfst( &aPos, aPoint, &aState );
1630
1631 //JP 22.01.99: Zeichenbindung ist im ReadnOnly-Inhalt nicht erlaubt
1632 if( !aPos.nNode.GetNode().IsProtect() )
1633 {
1634 pAnch = aPos.nNode.GetNode().GetCntntNode()->GetFrm( &aPoint, &aPos );
1635 SwRect aTmp;
1636 pAnch->GetCharRect( aTmp, aPos );
1637
1638 //Der Crsr darf nicht zu weit entfernt sein.
1639 bCharBound = TRUE;
1640 Rectangle aRect( aTmp.SVRect() );
1641 aRect.Left() -= MM50*2;
1642 aRect.Top() -= MM50*2;
1643 aRect.Right() += MM50*2;
1644 aRect.Bottom()+= MM50*2;
1645
1646 if( !aRect.IsOver( rBound ) && !::GetHtmlMode( GetDoc()->GetDocShell() ))
1647 bCharBound = FALSE;
1648
1649 //Bindung in Kopf-/Fusszeilen ist ebenfalls nicht erlaubt.
1650 if( bCharBound )
1651 bCharBound = !GetDoc()->IsInHeaderFooter( aPos.nNode );
1652
1653 if( bCharBound )
1654 {
1655 aAnch.SetType( FLY_IN_CNTNT );
1656 aAnch.SetAnchor( &aPos );
1657 }
1658 }
1659 }
1660
1661 if( !bCharBound )
1662 {
1663 // OD 16.05.2003 #108784# - allow native drawing objects in header/footer.
1664 // Thus, set <bBodyOnly> to <false> for these objects using value
1665 // of <nIdent> - value <0xFFFF> indicates control objects, which aren't
1666 // allowed in header/footer.
1667 //bool bBodyOnly = OBJ_NONE != nIdent;
1668 bool bBodyOnly = 0xFFFF == nIdent;
1669 bool bAtPage = false;
1670 const SwFrm* pPage = 0;
1671 SwCrsrMoveState aState( MV_SETONLYTEXT );
1672 Point aPoint( aPt );
1673 SwPosition aPos( GetDoc()->GetNodes() );
1674 GetLayout()->GetCrsrOfst( &aPos, aPoint, &aState );
1675
1676 //JP 22.01.99: nicht in ReadnOnly-Inhalt setzen
1677 if( aPos.nNode.GetNode().IsProtect() )
1678 // dann darf er nur seitengebunden sein. Oder sollte man
1679 // die naechste nicht READONLY Position suchen?
1680 bAtPage = true;
1681
1682 pAnch = aPos.nNode.GetNode().GetCntntNode()->GetFrm( &aPoint, 0, FALSE );
1683
1684 if( !bAtPage )
1685 {
1686 const SwFlyFrm *pTmp = pAnch->FindFlyFrm();
1687 if( pTmp )
1688 {
1689 const SwFrm* pTmpFrm = pAnch;
1690 SwRect aBound( rBound );
1691 while( pTmp )
1692 {
1693 if( pTmp->Frm().IsInside( aBound ) )
1694 {
1695 if( !bBodyOnly || !pTmp->FindFooterOrHeader() )
1696 pPage = pTmpFrm;
1697 break;
1698 }
1699 pTmp = pTmp->GetAnchorFrm()
1700 ? pTmp->GetAnchorFrm()->FindFlyFrm()
1701 : 0;
1702 pTmpFrm = pTmp;
1703 }
1704 }
1705
1706 if( !pPage )
1707 pPage = pAnch->FindPageFrm();
1708
1709 // immer ueber FindAnchor gehen, damit der Frame immer an den
1710 // davorgehen gebunden wird. Beim GetCrsOfst kann man auch zum
1711 // nachfolgenden kommen. DAS IST FALSCH
1712 pAnch = ::FindAnchor( pPage, aPt, bBodyOnly );
1713 aPos.nNode = *((SwCntntFrm*)pAnch)->GetNode();
1714
1715 //JP 22.01.99: nicht in ReadnOnly-Inhalt setzen
1716 if( aPos.nNode.GetNode().IsProtect() )
1717 // dann darf er nur seitengebunden sein. Oder sollte man
1718 // die naechste nicht READONLY Position suchen?
1719 bAtPage = true;
1720 else
1721 {
1722 aAnch.SetType( FLY_AT_CNTNT );
1723 aAnch.SetAnchor( &aPos );
1724 }
1725 }
1726
1727 if( bAtPage )
1728 {
1729 pPage = pAnch->FindPageFrm();
1730
1731 aAnch.SetType( FLY_PAGE );
1732 aAnch.SetPageNum( pPage->GetPhyPageNum() );
1733 pAnch = pPage; // die Page wird jetzt zum Anker
1734 }
1735 }
1736
1737 SfxItemSet aSet( GetDoc()->GetAttrPool(), RES_FRM_SIZE, RES_FRM_SIZE,
1738 RES_SURROUND, RES_ANCHOR, 0 );
1739 aSet.Put( aAnch );
1740
1741 // OD 2004-03-30 #i26791# - determine relative object position
1742 SwTwips nXOffset;
1743 SwTwips nYOffset = rBound.Top() - pAnch->Frm().Top();
1744 {
1745 if( pAnch->IsVertical() )
1746 {
1747 nXOffset = nYOffset;
1748 nYOffset = pAnch->Frm().Left()+pAnch->Frm().Width()-rBound.Right();
1749 }
1750 else if( pAnch->IsRightToLeft() )
1751 nXOffset = pAnch->Frm().Left()+pAnch->Frm().Width()-rBound.Right();
1752 else
1753 nXOffset = rBound.Left() - pAnch->Frm().Left();
1754 if( pAnch->IsTxtFrm() && ((SwTxtFrm*)pAnch)->IsFollow() )
1755 {
1756 SwTxtFrm* pTmp = (SwTxtFrm*)pAnch;
1757 do {
1758 pTmp = pTmp->FindMaster();
1759 ASSERT( pTmp, "Where's my Master?" );
1760 // OD 2004-03-30 #i26791# - correction: add frame area height
1761 // of master frames.
1762 nYOffset += pTmp->IsVertical() ?
1763 pTmp->Frm().Width() : pTmp->Frm().Height();
1764 } while ( pTmp->IsFollow() );
1765 }
1766 }
1767
1768 if( OBJ_NONE == nIdent )
1769 {
1770 //Bei OBJ_NONE wird ein Fly eingefuegt.
1771 const long nWidth = rBound.Right() - rBound.Left();
1772 const long nHeight= rBound.Bottom() - rBound.Top();
1773 aSet.Put( SwFmtFrmSize( ATT_MIN_SIZE, Max( nWidth, long(MINFLY) ),
1774 Max( nHeight, long(MINFLY) )));
1775
1776 SwFmtHoriOrient aHori( nXOffset, text::HoriOrientation::NONE, text::RelOrientation::FRAME );
1777 SwFmtVertOrient aVert( nYOffset, text::VertOrientation::NONE, text::RelOrientation::FRAME );
1778 aSet.Put( SwFmtSurround( SURROUND_PARALLEL ) );
1779 aSet.Put( aHori );
1780 aSet.Put( aVert );
1781
1782 //Schnell noch das Rechteck merken
1783 const SwRect aFlyRect( rBound );
1784
1785 //Erzeugtes Object wegwerfen, so kann der Fly am elegentesten
1786 //ueber vorhandene SS erzeugt werden.
1787 GetDoc()->SetNoDrawUndoObj( TRUE ); // siehe oben
1788 // --> OD 2005-08-08 #i52858# - method name changed
1789 SdrPage *pPg = getIDocumentDrawModelAccess()->GetOrCreateDrawModel()->GetPage( 0 );
1790 // <--
1791 if( !pPg )
1792 {
1793 SdrModel* pTmpSdrModel = getIDocumentDrawModelAccess()->GetDrawModel();
1794 pPg = pTmpSdrModel->AllocPage( FALSE );
1795 pTmpSdrModel->InsertPage( pPg );
1796 }
1797 pPg->RecalcObjOrdNums();
1798 SdrObject* pRemovedObject = pPg->RemoveObject( rSdrObj.GetOrdNumDirect() );
1799 SdrObject::Free( pRemovedObject );
1800 GetDoc()->SetNoDrawUndoObj( FALSE );
1801
1802 SwFlyFrm* pFlyFrm;
1803 if( NewFlyFrm( aSet, TRUE ) &&
1804 ::GetHtmlMode( GetDoc()->GetDocShell() ) &&
1805 0 != ( pFlyFrm = FindFlyFrm() ))
1806 {
1807 SfxItemSet aHtmlSet( GetDoc()->GetAttrPool(), RES_VERT_ORIENT, RES_HORI_ORIENT );
1808 //Horizontale Ausrichtung:
1809 const BOOL bLeftFrm = aFlyRect.Left() <
1810 pAnch->Frm().Left() + pAnch->Prt().Left(),
1811 bLeftPrt = aFlyRect.Left() + aFlyRect.Width() <
1812 pAnch->Frm().Left() + pAnch->Prt().Width()/2;
1813 if( bLeftFrm || bLeftPrt )
1814 {
1815 aHori.SetHoriOrient( text::HoriOrientation::LEFT );
1816 aHori.SetRelationOrient( bLeftFrm ? text::RelOrientation::FRAME : text::RelOrientation::PRINT_AREA );
1817 }
1818 else
1819 {
1820 const BOOL bRightFrm = aFlyRect.Left() >
1821 pAnch->Frm().Left() + pAnch->Prt().Width();
1822 aHori.SetHoriOrient( text::HoriOrientation::RIGHT );
1823 aHori.SetRelationOrient( bRightFrm ? text::RelOrientation::FRAME : text::RelOrientation::PRINT_AREA );
1824 }
1825 aHtmlSet.Put( aHori );
1826 aVert.SetVertOrient( text::VertOrientation::TOP );
1827 aVert.SetRelationOrient( text::RelOrientation::PRINT_AREA );
1828 aHtmlSet.Put( aVert );
1829
1830 GetDoc()->SetAttr( aHtmlSet, *pFlyFrm->GetFmt() );
1831 }
1832 }
1833 else
1834 {
1835 Point aRelNullPt;
1836 if( OBJ_CAPTION == nIdent )
1837 aRelNullPt = ((SdrCaptionObj&)rSdrObj).GetTailPos();
1838 else
1839 aRelNullPt = rBound.TopLeft();
1840
1841 aSet.Put( aAnch );
1842 aSet.Put( SwFmtSurround( SURROUND_THROUGHT ) );
1843 // OD 2004-03-30 #i26791# - set horizontal position
1844 SwFmtHoriOrient aHori( nXOffset, text::HoriOrientation::NONE, text::RelOrientation::FRAME );
1845 aSet.Put( aHori );
1846 // OD 2004-03-30 #i26791# - set vertical position
1847 if( pAnch->IsTxtFrm() && ((SwTxtFrm*)pAnch)->IsFollow() )
1848 {
1849 SwTxtFrm* pTmp = (SwTxtFrm*)pAnch;
1850 do {
1851 pTmp = pTmp->FindMaster();
1852 ASSERT( pTmp, "Where's my Master?" );
1853 nYOffset += pTmp->IsVertical() ?
1854 pTmp->Prt().Width() : pTmp->Prt().Height();
1855 } while ( pTmp->IsFollow() );
1856 }
1857 SwFmtVertOrient aVert( nYOffset, text::VertOrientation::NONE, text::RelOrientation::FRAME );
1858 aSet.Put( aVert );
1859 SwDrawFrmFmt* pFmt = (SwDrawFrmFmt*)getIDocumentLayoutAccess()->MakeLayoutFmt( RND_DRAW_OBJECT, &aSet );
1860 // --> OD 2004-10-25 #i36010# - set layout direction of the position
1861 pFmt->SetPositionLayoutDir(
1862 text::PositionLayoutDir::PositionInLayoutDirOfAnchor );
1863 // <--
1864 // --> OD 2005-03-11 #i44344#, #i44681# - positioning attributes already set
1865 pFmt->PosAttrSet();
1866 // <--
1867
1868 SwDrawContact *pContact = new SwDrawContact( pFmt, &rSdrObj );
1869 // --> OD 2004-11-22 #i35635#
1870 pContact->MoveObjToVisibleLayer( &rSdrObj );
1871 // <--
1872 if( bCharBound )
1873 {
1874 ASSERT( aAnch.GetAnchorId() == FLY_IN_CNTNT, "wrong AnchorType" );
1875 SwTxtNode *pNd = aAnch.GetCntntAnchor()->nNode.GetNode().GetTxtNode();
1876 SwFmtFlyCnt aFmt( pFmt );
1877 pNd->InsertItem(aFmt,
1878 aAnch.GetCntntAnchor()->nContent.GetIndex(), 0 );
1879 SwFmtVertOrient aVertical( pFmt->GetVertOrient() );
1880 aVertical.SetVertOrient( text::VertOrientation::LINE_CENTER );
1881 pFmt->SetFmtAttr( aVertical );
1882 }
1883 if( pAnch->IsTxtFrm() && ((SwTxtFrm*)pAnch)->IsFollow() )
1884 {
1885 SwTxtFrm* pTmp = (SwTxtFrm*)pAnch;
1886 do {
1887 pTmp = pTmp->FindMaster();
1888 ASSERT( pTmp, "Where's my Master?" );
1889 } while( pTmp->IsFollow() );
1890 pAnch = pTmp;
1891 }
1892
1893 pContact->ConnectToLayout();
1894
1895 // OD 25.06.2003 #108784# - mark object at frame the object is inserted at.
1896 {
1897 SdrObject* pMarkObj = pContact->GetDrawObjectByAnchorFrm( *pAnch );
1898 if ( pMarkObj )
1899 {
1900 Imp()->GetDrawView()->MarkObj( pMarkObj, Imp()->GetPageView(),
1901 FALSE, FALSE );
1902 }
1903 else
1904 {
1905 Imp()->GetDrawView()->MarkObj( &rSdrObj, Imp()->GetPageView(),
1906 FALSE, FALSE );
1907 }
1908 }
1909 }
1910
1911 GetDoc()->SetModified();
1912
1913 KillPams();
1914 EndAllActionAndCall();
1915 UnlockPaint();
1916 return TRUE;
1917 }
1918
1919
1920 /*************************************************************************
1921 |*
1922 |* SwFEShell::BreakCreate()
1923 |*
1924 |* Ersterstellung MA 20. Dec. 94
1925 |* Letzte Aenderung MA 09. Jan. 95
1926 |*
1927 *************************************************************************/
1928
1929 void SwFEShell::BreakCreate()
1930 {
1931 ASSERT( Imp()->HasDrawView(), "BreakCreate without DrawView?" );
1932 Imp()->GetDrawView()->BrkCreateObj();
1933 ::FrameNotify( this, FLY_DRAG_END );
1934 }
1935
1936 /*************************************************************************
1937 |*
1938 |* SwFEShell::IsDrawCreate()
1939 |*
1940 |* Ersterstellung OM 16. Mar. 95
1941 |* Letzte Aenderung OM 16. Mar. 95
1942 |*
1943 *************************************************************************/
1944
1945 BOOL SwFEShell::IsDrawCreate() const
1946 {
1947 return Imp()->HasDrawView() ? Imp()->GetDrawView()->IsCreateObj() : FALSE;
1948 }
1949
1950 /*************************************************************************
1951 |*
1952 |* SwFEShell::BeginMark()
1953 |*
1954 |* Ersterstellung OM 07. Feb. 95
1955 |* Letzte Aenderung OM 07. Feb. 95
1956 |*
1957 *************************************************************************/
1958
1959 BOOL SwFEShell::BeginMark( const Point &rPos )
1960 {
1961 if ( !Imp()->HasDrawView() )
1962 Imp()->MakeDrawView();
1963
1964 if ( GetPageNumber( rPos ) )
1965 {
1966 SwDrawView* pDView = Imp()->GetDrawView();
1967
1968 if (pDView->HasMarkablePoints())
1969 return pDView->BegMarkPoints( rPos );
1970 else
1971 return pDView->BegMarkObj( rPos );
1972 }
1973 else
1974 return FALSE;
1975 }
1976
1977 /*************************************************************************
1978 |*
1979 |* SwFEShell::MoveMark()
1980 |*
1981 |* Ersterstellung OM 07. Feb. 95
1982 |* Letzte Aenderung OM 07. Feb. 95
1983 |*
1984 *************************************************************************/
1985
1986 void SwFEShell::MoveMark( const Point &rPos )
1987 {
1988 ASSERT( Imp()->HasDrawView(), "MoveMark without DrawView?" );
1989
1990 if ( GetPageNumber( rPos ) )
1991 {
1992 ScrollTo( rPos );
1993 SwDrawView* pDView = Imp()->GetDrawView();
1994 // Imp()->GetDrawView()->MovMarkObj( rPos );
1995
1996 if (pDView->IsInsObjPoint())
1997 pDView->MovInsObjPoint( rPos );
1998 else if (pDView->IsMarkPoints())
1999 pDView->MovMarkPoints( rPos );
2000 else
2001 pDView->MovAction( rPos );
2002 }
2003 }
2004
2005 /*************************************************************************
2006 |*
2007 |* SwFEShell::EndMark()
2008 |*
2009 |* Ersterstellung OM 07. Feb. 95
2010 |* Letzte Aenderung MA 08. Feb. 95
2011 |*
2012 *************************************************************************/
2013
2014 BOOL SwFEShell::EndMark()
2015 {
2016 BOOL bRet = FALSE;
2017 ASSERT( Imp()->HasDrawView(), "EndMark without DrawView?" );
2018
2019 if (Imp()->GetDrawView()->IsMarkObj())
2020 {
2021 bRet = Imp()->GetDrawView()->EndMarkObj();
2022
2023 if ( bRet )
2024 {
2025 BOOL bShowHdl = FALSE;
2026 SwDrawView* pDView = Imp()->GetDrawView();
2027 //Rahmen werden auf diese Art nicht Selektiert, es sein denn es
2028 //ist nur ein Rahmen.
2029 SdrMarkList &rMrkList = (SdrMarkList&)pDView->GetMarkedObjectList();
2030 SwFlyFrm* pOldSelFly = ::GetFlyFromMarked( &rMrkList, this );
2031
2032 if ( rMrkList.GetMarkCount() > 1 )
2033 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2034 {
2035 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2036 if( pObj->ISA(SwVirtFlyDrawObj) )
2037 {
2038 if ( !bShowHdl )
2039 {
2040 //HMHpDView->HideMarkHdl();
2041 bShowHdl = TRUE;
2042 }
2043 rMrkList.DeleteMark( i );
2044 --i; //keinen auslassen.
2045 }
2046 }
2047
2048 if( bShowHdl )
2049 {
2050 pDView->MarkListHasChanged();
2051 pDView->AdjustMarkHdl();
2052 //HMHpDView->ShowMarkHdl();
2053 }
2054
2055 if ( rMrkList.GetMarkCount() )
2056 ::lcl_GrabCursor(this, pOldSelFly);
2057 else
2058 bRet = FALSE;
2059 }
2060 if ( bRet )
2061 ::FrameNotify( this, FLY_DRAG_START );
2062 }
2063 else
2064 {
2065 if (Imp()->GetDrawView()->IsMarkPoints())
2066 bRet = Imp()->GetDrawView()->EndMarkPoints();
2067 }
2068
2069 SetChainMarker();
2070 return bRet;
2071 }
2072
2073 /*************************************************************************
2074 |*
2075 |* SwFEShell::BreakSelect()
2076 |*
2077 |* Ersterstellung OM 07. Feb. 95
2078 |* Letzte Aenderung OM 07. Feb. 95
2079 |*
2080 *************************************************************************/
2081
2082 void SwFEShell::BreakMark()
2083 {
2084 ASSERT( Imp()->HasDrawView(), "BreakMark without DrawView?" );
2085 Imp()->GetDrawView()->BrkMarkObj();
2086 }
2087
2088 /*************************************************************************
2089 |*
2090 |* SwFEShell::GetAnchorId()
2091 |*
2092 |* Ersterstellung MA 30. Jan. 95
2093 |* Letzte Aenderung MA 30. Jan. 95
2094 |*
2095 *************************************************************************/
2096
2097 short SwFEShell::GetAnchorId() const
2098 {
2099 short nRet = SHRT_MAX;
2100 if ( Imp()->HasDrawView() )
2101 {
2102 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2103 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2104 {
2105 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2106 if ( pObj->ISA(SwVirtFlyDrawObj) )
2107 {
2108 nRet = -1;
2109 break;
2110 }
2111 SwDrawContact *pContact = (SwDrawContact*)GetUserCall(pObj);
2112 short nId = static_cast<short>(pContact->GetFmt()->GetAnchor().GetAnchorId());
2113 if ( nRet == SHRT_MAX )
2114 nRet = nId;
2115 else if ( nRet != nId )
2116 {
2117 nRet = -1;
2118 break;
2119 }
2120 }
2121 }
2122 if ( nRet == SHRT_MAX )
2123 nRet = -1;
2124 return nRet;
2125 }
2126
2127 /*************************************************************************
2128 |*
2129 |* SwFEShell::ChgAnchor()
2130 |*
2131 |* Ersterstellung MA 10. Jan. 95
2132 |* Letzte Aenderung MA 30. May. 96
2133 |*
2134 *************************************************************************/
2135
2136 void SwFEShell::ChgAnchor( int eAnchorId, BOOL bSameOnly, BOOL bPosCorr )
2137 {
2138 ASSERT( Imp()->HasDrawView(), "ChgAnchor without DrawView?" );
2139 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2140 if( rMrkList.GetMarkCount() &&
2141 !rMrkList.GetMark( 0 )->GetMarkedSdrObj()->GetUpGroup() )
2142 {
2143 StartAllAction();
2144
2145 if( GetDoc()->ChgAnchor( rMrkList, (RndStdIds)eAnchorId, bSameOnly, bPosCorr ))
2146 Imp()->GetDrawView()->UnmarkAll();
2147
2148 EndAllAction();
2149
2150 ::FrameNotify( this, FLY_DRAG );
2151 }
2152 }
2153
2154 /*************************************************************************
2155 |*
2156 |* SwFEShell::DelSelectedObj()
2157 |*
2158 |* Ersterstellung MA 03. Nov. 92
2159 |* Letzte Aenderung MA 14. Nov. 95
2160 |*
2161 *************************************************************************/
2162
2163 void SwFEShell::DelSelectedObj()
2164 {
2165 ASSERT( Imp()->HasDrawView(), "DelSelectedObj(), no DrawView available" );
2166 if ( Imp()->HasDrawView() )
2167 {
2168 StartAllAction();
2169 Imp()->GetDrawView()->DeleteMarked();
2170 EndAllAction();
2171 ::FrameNotify( this, FLY_DRAG_END );
2172 }
2173 }
2174
2175 /*************************************************************************
2176 |*
2177 |* SwFEShell::GetObjSize(), GetAnchorObjDiff()
2178 |*
2179 |* Beschreibung Fuer die Statuszeile zum Erfragen der aktuellen
2180 |* Verhaeltnisse
2181 |* Ersterstellung MA 25. Apr. 95
2182 |* Letzte Aenderung MA 25. Apr. 95
2183 |*
2184 *************************************************************************/
2185
2186 Size SwFEShell::GetObjSize() const
2187 {
2188 Rectangle aRect;
2189 if ( Imp()->HasDrawView() )
2190 {
2191 if ( Imp()->GetDrawView()->IsAction() )
2192 Imp()->GetDrawView()->TakeActionRect( aRect );
2193 else
2194 aRect = Imp()->GetDrawView()->GetAllMarkedRect();
2195 }
2196 return aRect.GetSize();
2197 }
2198
2199 Point SwFEShell::GetAnchorObjDiff() const
2200 {
2201 const SdrView *pView = Imp()->GetDrawView();
2202 ASSERT( pView, "GetAnchorObjDiff without DrawView?" );
2203
2204 Rectangle aRect;
2205 if ( Imp()->GetDrawView()->IsAction() )
2206 Imp()->GetDrawView()->TakeActionRect( aRect );
2207 else
2208 aRect = Imp()->GetDrawView()->GetAllMarkedRect();
2209
2210 Point aRet( aRect.TopLeft() );
2211
2212 if ( IsFrmSelected() )
2213 {
2214 SwFlyFrm *pFly = FindFlyFrm();
2215 aRet -= pFly->GetAnchorFrm()->Frm().Pos();
2216 }
2217 else
2218 {
2219 const SdrObject *pObj = pView->GetMarkedObjectList().GetMarkCount() == 1 ?
2220 pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj() : 0;
2221 if ( pObj )
2222 aRet -= pObj->GetAnchorPos();
2223 }
2224
2225 return aRet;
2226 }
2227
2228 Point SwFEShell::GetObjAbsPos() const
2229 {
2230 ASSERT( Imp()->GetDrawView(), "GetObjAbsPos() without DrawView?" );
2231 return Imp()->GetDrawView()->GetDragStat().GetActionRect().TopLeft();
2232 }
2233
2234
2235
2236 /*************************************************************************
2237 |*
2238 |* SwFEShell::IsGroupSelected()
2239 |*
2240 |* Ersterstellung MA 30. Jan. 95
2241 |* Letzte Aenderung MA 30. May. 96
2242 |*
2243 *************************************************************************/
2244
2245 BOOL SwFEShell::IsGroupSelected()
2246 {
2247 if ( IsObjSelected() )
2248 {
2249 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2250 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2251 {
2252 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2253 // OD 30.06.2003 #108784# - consider 'virtual' drawing objects.
2254 // Thus, use corresponding method instead of checking type.
2255 if ( pObj->IsGroupObject() &&
2256 // --> FME 2004-12-08 #i38505# No ungroup allowed for 3d objects
2257 !pObj->Is3DObj() &&
2258 // <--
2259 FLY_IN_CNTNT != ((SwDrawContact*)GetUserCall(pObj))->
2260 GetFmt()->GetAnchor().GetAnchorId() )
2261 {
2262 return TRUE;
2263 }
2264 }
2265 }
2266 return FALSE;
2267 }
2268
2269 // OD 27.06.2003 #108784# - change return type.
2270 // OD 27.06.2003 #108784# - adjustments for drawing objects in header/footer:
2271 // allow group, only if all selected objects are in the same header/footer
2272 // or not in header/footer.
2273 bool SwFEShell::IsGroupAllowed() const
2274 {
2275 bool bIsGroupAllowed = false;
2276 if ( IsObjSelected() > 1 )
2277 {
2278 bIsGroupAllowed = true;
2279 const SdrObject* pUpGroup = 0L;
2280 const SwFrm* pHeaderFooterFrm = 0L;
2281 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2282 for ( USHORT i = 0; bIsGroupAllowed && i < rMrkList.GetMarkCount(); ++i )
2283 {
2284 const SdrObject* pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2285 if ( i )
2286 bIsGroupAllowed = pObj->GetUpGroup() == pUpGroup;
2287 else
2288 pUpGroup = pObj->GetUpGroup();
2289
2290 // --> OD 2006-11-06 #130889# - make code robust
2291 // if ( bIsGroupAllowed &&
2292 // FLY_IN_CNTNT == ::FindFrmFmt( (SdrObject*)pObj )->GetAnchor().GetAnchorId() )
2293 // {
2294 // bIsGroupAllowed = false;
2295 // }
2296 if ( bIsGroupAllowed )
2297 {
2298 SwFrmFmt* pFrmFmt( ::FindFrmFmt( const_cast<SdrObject*>(pObj) ) );
2299 if ( !pFrmFmt )
2300 {
2301 ASSERT( false,
2302 "<SwFEShell::IsGroupAllowed()> - missing frame format" );
2303 bIsGroupAllowed = false;
2304 }
2305 else if ( FLY_IN_CNTNT == pFrmFmt->GetAnchor().GetAnchorId() )
2306 {
2307 bIsGroupAllowed = false;
2308 }
2309 }
2310 // <--
2311
2312 // OD 27.06.2003 #108784# - check, if all selected objects are in the
2313 // same header/footer or not in header/footer.
2314 if ( bIsGroupAllowed )
2315 {
2316 const SwFrm* pAnchorFrm = 0L;
2317 if ( pObj->ISA(SwVirtFlyDrawObj) )
2318 {
2319 const SwFlyFrm* pFlyFrm =
2320 static_cast<const SwVirtFlyDrawObj*>(pObj)->GetFlyFrm();
2321 if ( pFlyFrm )
2322 {
2323 pAnchorFrm = pFlyFrm->GetAnchorFrm();
2324 }
2325 }
2326 else
2327 {
2328 SwDrawContact* pDrawContact = static_cast<SwDrawContact*>(GetUserCall( pObj ));
2329 if ( pDrawContact )
2330 {
2331 pAnchorFrm = pDrawContact->GetAnchorFrm( pObj );
2332 }
2333 }
2334 if ( pAnchorFrm )
2335 {
2336 if ( i )
2337 {
2338 bIsGroupAllowed =
2339 ( pAnchorFrm->FindFooterOrHeader() == pHeaderFooterFrm );
2340 }
2341 else
2342 {
2343 pHeaderFooterFrm = pAnchorFrm->FindFooterOrHeader();
2344 }
2345 }
2346 }
2347
2348 }
2349 }
2350
2351 return bIsGroupAllowed;
2352 }
2353
2354 /*************************************************************************
2355 |*
2356 |* SwFEShell::GroupSelection()
2357 |*
2358 |* Beschreibung Die Gruppe bekommt den Anker und das Contactobjekt
2359 |* des ersten in der Selektion
2360 |* Ersterstellung MA 30. Jan. 95
2361 |* Letzte Aenderung MA 23. Apr. 95
2362 |*
2363 *************************************************************************/
2364
2365 void SwFEShell::GroupSelection()
2366 {
2367 if ( IsGroupAllowed() )
2368 {
2369 StartAllAction();
2370 StartUndo( UNDO_START );
2371
2372 GetDoc()->GroupSelection( *Imp()->GetDrawView() );
2373
2374 EndUndo( UNDO_END );
2375 EndAllAction();
2376 }
2377 }
2378
2379 /*************************************************************************
2380 |*
2381 |* SwFEShell::UnGroupSelection()
2382 |*
2383 |* Beschreibung Die Einzelobjekte bekommen eine Kopie vom Anker und
2384 |* Contactobjekt der Gruppe.
2385 |* Ersterstellung MA 30. Jan. 95
2386 |* Letzte Aenderung MA 01. Feb. 95
2387 |*
2388 *************************************************************************/
2389
2390 void SwFEShell::UnGroupSelection()
2391 {
2392 if ( IsGroupSelected() )
2393 {
2394 StartAllAction();
2395 StartUndo( UNDO_START );
2396
2397 GetDoc()->UnGroupSelection( *Imp()->GetDrawView() );
2398
2399 EndUndo( UNDO_END );
2400 EndAllAction();
2401 }
2402 }
2403
2404 /*************************************************************************
2405 |*
2406 |* SwFEShell::MirrorSelection()
2407 |*
2408 |* Ersterstellung MA 06. Aug. 95
2409 |* Letzte Aenderung MA 06. Aug. 95
2410 |*
2411 *************************************************************************/
2412
2413 void SwFEShell::MirrorSelection( BOOL bHorizontal )
2414 {
2415 SdrView *pView = Imp()->GetDrawView();
2416 if ( IsObjSelected() && pView->IsMirrorAllowed() )
2417 {
2418 if ( bHorizontal )
2419 pView->MirrorAllMarkedHorizontal();
2420 else
2421 pView->MirrorAllMarkedVertical();
2422 }
2423 }
2424
2425 // springe zum benannten Rahmen (Grafik/OLE)
2426
2427 BOOL SwFEShell::GotoFly( const String& rName, FlyCntType eType, BOOL bSelFrm )
2428 {
2429 BOOL bRet = FALSE;
2430 static BYTE __READONLY_DATA aChkArr[ 4 ] = {
2431 /* FLYCNTTYPE_ALL */ 0,
2432 /* FLYCNTTYPE_FRM */ ND_TEXTNODE,
2433 /* FLYCNTTYPE_GRF */ ND_GRFNODE,
2434 /* FLYCNTTYPE_OLE */ ND_OLENODE
2435 };
2436
2437 const SwFlyFrmFmt* pFlyFmt = pDoc->FindFlyByName( rName, aChkArr[ eType]);
2438 if( pFlyFmt )
2439 {
2440 SET_CURR_SHELL( this );
2441
2442 SwClientIter aIter( *(SwModify*)pFlyFmt );
2443 SwFlyFrm* pFrm = (SwFlyFrm*)aIter.First( TYPE( SwFlyFrm ));
2444 if( pFrm )
2445 {
2446 ASSERT( pFrm->IsFlyFrm(), "Wrong FrmType" );
2447 if( bSelFrm )
2448 {
2449 SelectObj( pFrm->Frm().Pos(), 0, ((SwFlyFrm*)pFrm)->GetVirtDrawObj() );
2450 if( !ActionPend() )
2451 MakeVisible( pFrm->Frm() );
2452 }
2453 else
2454 {
2455 // --> OD 2004-06-11 #i28701# - no format here
2456 // pFrm->GetAnchorFrm()->Calc();
2457 SwCntntFrm *pCFrm = pFrm->ContainsCntnt();
2458 if ( pCFrm )
2459 {
2460 SwCntntNode *pCNode = pCFrm->GetNode();
2461 ClearMark();
2462 SwPaM* pCrsr = GetCrsr();
2463
2464 pCrsr->GetPoint()->nNode = *pCNode;
2465 pCrsr->GetPoint()->nContent.Assign( pCNode, 0 );
2466
2467 SwRect& rChrRect = (SwRect&)GetCharRect();
2468 rChrRect = pFrm->Prt();
2469 rChrRect.Pos() += pFrm->Frm().Pos();
2470 GetCrsrDocPos() = rChrRect.Pos();
2471 }
2472 }
2473 bRet = TRUE;
2474 }
2475 }
2476 return bRet;
2477 }
2478
2479 USHORT SwFEShell::GetFlyCount( FlyCntType eType ) const
2480 {
2481 return GetDoc()->GetFlyCount(eType);
2482 }
2483
2484
2485 const SwFrmFmt* SwFEShell::GetFlyNum(USHORT nIdx, FlyCntType eType ) const
2486 {
2487 return GetDoc()->GetFlyNum(nIdx, eType );
2488 }
2489
2490 // zeige das akt. selektierte "Object" an
2491 void SwFEShell::MakeSelVisible()
2492 {
2493 if( Imp()->HasDrawView() &&
2494 Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() )
2495 {
2496 MakeVisible( Imp()->GetDrawView()->GetAllMarkedRect() );
2497 }
2498 else
2499 SwCrsrShell::MakeSelVisible();
2500 }
2501
2502
2503 //Welcher Schutz ist am selektierten Objekt gesetzt?
2504 BYTE SwFEShell::IsSelObjProtected( USHORT eType ) const
2505 {
2506 int nChk = 0;
2507 const bool bParent = (eType & FLYPROTECT_PARENT);
2508 if( Imp()->HasDrawView() )
2509 {
2510 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2511 for( ULONG i = rMrkList.GetMarkCount(); i; )
2512 {
2513 SdrObject *pObj = rMrkList.GetMark( --i )->GetMarkedSdrObj();
2514 if( !bParent )
2515 {
2516 nChk |= ( pObj->IsMoveProtect() ? FLYPROTECT_POS : 0 ) |
2517 ( pObj->IsResizeProtect()? FLYPROTECT_SIZE : 0 );
2518
2519 if( FLYPROTECT_CONTENT & eType && pObj->ISA(SwVirtFlyDrawObj) )
2520 {
2521 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
2522 if ( pFly->GetFmt()->GetProtect().IsCntntProtected() )
2523 nChk |= FLYPROTECT_CONTENT;
2524
2525 if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
2526 {
2527 SwOLENode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetOLENode();
2528 if ( pNd )
2529 {
2530 uno::Reference < embed::XEmbeddedObject > xObj = pNd->GetOLEObj().GetOleRef();
2531
2532 // TODO/LATER: use correct aspect
2533 if ( xObj.is() &&
2534 embed::EmbedMisc::EMBED_NEVERRESIZE & xObj->getStatus( embed::Aspects::MSOLE_CONTENT ) )
2535 {
2536 nChk |= FLYPROTECT_SIZE;
2537 nChk |= FLYPROTECT_FIXED;
2538 }
2539 }
2540 }
2541 }
2542 nChk &= eType;
2543 if( nChk == eType )
2544 return static_cast<BYTE>(eType);
2545 }
2546 const SwFrm* pAnch;
2547 if( pObj->ISA(SwVirtFlyDrawObj) )
2548 pAnch = ( (SwVirtFlyDrawObj*)pObj )->GetFlyFrm()->GetAnchorFrm();
2549 else
2550 {
2551 SwDrawContact* pTmp = (SwDrawContact*)GetUserCall(pObj);
2552 pAnch = pTmp ? pTmp->GetAnchorFrm( pObj ) : NULL;
2553 }
2554 if( pAnch && pAnch->IsProtected() )
2555 return static_cast<BYTE>(eType);
2556 }
2557 }
2558 return static_cast<BYTE>(nChk);
2559 }
2560
2561 BOOL SwFEShell::GetObjAttr( SfxItemSet &rSet ) const
2562 {
2563 if ( !IsObjSelected() )
2564 return FALSE;
2565
2566 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2567 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2568 {
2569 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2570 SwDrawContact *pContact = (SwDrawContact*)GetUserCall(pObj);
2571 // --> OD 2007-07-24 #143008# - make code robust
2572 ASSERT( pContact, "<SwFEShell::GetObjAttr(..)> - missing <pContact> - please inform OD." );
2573 if ( pContact )
2574 {
2575 if ( i )
2576 rSet.MergeValues( pContact->GetFmt()->GetAttrSet() );
2577 else
2578 rSet.Put( pContact->GetFmt()->GetAttrSet() );
2579 }
2580 // <--
2581 }
2582 return TRUE;
2583 }
2584
2585 BOOL SwFEShell::SetObjAttr( const SfxItemSet& rSet )
2586 {
2587 SET_CURR_SHELL( this );
2588
2589 if ( !rSet.Count() )
2590 { ASSERT( !this, "SetObjAttr, empty set." );
2591 return FALSE;
2592 }
2593
2594 StartAllAction();
2595 StartUndo( UNDO_INSATTR );
2596
2597 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2598 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2599 {
2600 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2601 SwDrawContact *pContact = (SwDrawContact*)GetUserCall(pObj);
2602 GetDoc()->SetAttr( rSet, *pContact->GetFmt() );
2603 }
2604
2605 EndUndo( UNDO_INSATTR );
2606 EndAllActionAndCall();
2607 GetDoc()->SetModified();
2608 return TRUE;
2609 }
2610
2611 BOOL SwFEShell::IsAlignPossible() const
2612 {
2613 USHORT nCnt;
2614 if ( 0 < (nCnt = IsObjSelected()) )
2615 {
2616 BOOL bRet = TRUE;
2617 if ( nCnt == 1 )
2618 {
2619 SdrObject *pO = Imp()->GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
2620 SwDrawContact *pC = (SwDrawContact*)GetUserCall(pO);
2621 //only as character bound drawings can be aligned
2622 bRet = pC->GetFmt()->GetAnchor().GetAnchorId() == FLY_IN_CNTNT;
2623 }
2624 if ( bRet )
2625 return Imp()->GetDrawView()->IsAlignPossible();
2626 }
2627 return FALSE;
2628 }
2629
2630
2631 //Temporaerer Fix bis SS von JOE da ist
2632 void SwFEShell::CheckUnboundObjects()
2633 {
2634 SET_CURR_SHELL( this );
2635
2636 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
2637 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
2638 {
2639 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
2640 if ( !GetUserCall(pObj) )
2641 {
2642 const Rectangle &rBound = pObj->GetSnapRect();
2643 const Point aPt( rBound.TopLeft() );
2644 const SwFrm *pPage = GetLayout()->Lower();
2645 const SwFrm *pLast = pPage;
2646 while ( pPage && !pPage->Frm().IsInside( aPt ) )
2647 {
2648 if ( aPt.Y() > pPage->Frm().Bottom() )
2649 pLast = pPage;
2650 pPage = pPage->GetNext();
2651 }
2652 if ( !pPage )
2653 pPage = pLast;
2654 ASSERT( pPage, "Page not found." );
2655
2656 //Fremde Identifier sollen in den Default laufen.
2657 //Ueberschneidungen sind moeglich!!
2658 UINT16 nIdent =
2659 Imp()->GetDrawView()->GetCurrentObjInventor() == SdrInventor ?
2660 Imp()->GetDrawView()->GetCurrentObjIdentifier() : 0xFFFF;
2661
2662 SwFmtAnchor aAnch;
2663 const SwFrm *pAnch = 0;
2664 {
2665 pAnch = ::FindAnchor( pPage, aPt, TRUE );
2666 SwPosition aPos( *((SwCntntFrm*)pAnch)->GetNode() );
2667 aAnch.SetType( FLY_AT_CNTNT );
2668 aAnch.SetAnchor( &aPos );
2669 ((SwRect&)GetCharRect()).Pos() = aPt;
2670 }
2671
2672 //Erst hier die Action, damit das GetCharRect aktuelle Werte liefert.
2673 StartAllAction();
2674
2675 SfxItemSet aSet( GetAttrPool(), RES_FRM_SIZE, RES_FRM_SIZE,
2676 RES_SURROUND, RES_ANCHOR, 0 );
2677 aSet.Put( aAnch );
2678
2679 Point aRelNullPt;
2680
2681 if( OBJ_CAPTION == nIdent )
2682 aRelNullPt = ((SdrCaptionObj*)pObj)->GetTailPos();
2683 else
2684 aRelNullPt = rBound.TopLeft();
2685
2686 aSet.Put( aAnch );
2687 aSet.Put( SwFmtSurround( SURROUND_THROUGHT ) );
2688 SwFrmFmt* pFmt = getIDocumentLayoutAccess()->MakeLayoutFmt( RND_DRAW_OBJECT, &aSet );
2689
2690 SwDrawContact *pContact = new SwDrawContact(
2691 (SwDrawFrmFmt*)pFmt, pObj );
2692
2693 // --> OD 2004-11-22 #i35635#
2694 pContact->MoveObjToVisibleLayer( pObj );
2695 // <--
2696 pContact->ConnectToLayout();
2697
2698 EndAllAction();
2699 }
2700 }
2701 }
2702
2703 void SwFEShell::SetCalcFieldValueHdl(Outliner* pOutliner)
2704 {
2705 GetDoc()->SetCalcFieldValueHdl(pOutliner);
2706 }
2707
2708
2709
2710 int SwFEShell::Chainable( SwRect &rRect, const SwFrmFmt &rSource,
2711 const Point &rPt ) const
2712 {
2713 rRect.Clear();
2714
2715 //Die Source darf noch keinen Follow haben.
2716 const SwFmtChain &rChain = rSource.GetChain();
2717 if ( rChain.GetNext() )
2718 return SW_CHAIN_SOURCE_CHAINED;
2719
2720 if( Imp()->HasDrawView() )
2721 {
2722 SdrObject* pObj;
2723 SdrPageView* pPView;
2724 SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
2725 const USHORT nOld = pDView->GetHitTolerancePixel();
2726 pDView->SetHitTolerancePixel( 0 );
2727 if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE ) &&
2728 pObj->ISA(SwVirtFlyDrawObj) )
2729 {
2730 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
2731 rRect = pFly->Frm();
2732
2733 //Ziel darf natuerlich nicht gleich Source sein und es
2734 //darf keine geschlossene Kette entstehen.
2735 SwFrmFmt *pFmt = pFly->GetFmt();
2736 return GetDoc()->Chainable(rSource, *pFmt);
2737 }
2738 pDView->SetHitTolerancePixel( nOld );
2739 }
2740 return SW_CHAIN_NOT_FOUND;
2741 }
2742 /* -----------------------------09.08.2002 07:40------------------------------
2743
2744 ---------------------------------------------------------------------------*/
2745 int SwFEShell::Chain( SwFrmFmt &rSource, const SwFrmFmt &rDest )
2746 {
2747 return GetDoc()->Chain(rSource, rDest);
2748 }
2749
2750 int SwFEShell::Chain( SwFrmFmt &rSource, const Point &rPt )
2751 {
2752 SwRect aDummy;
2753 int nErr = Chainable( aDummy, rSource, rPt );
2754 if ( !nErr )
2755 {
2756 StartAllAction();
2757 SdrObject* pObj;
2758 SdrPageView* pPView;
2759 SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
2760 const USHORT nOld = pDView->GetHitTolerancePixel();
2761 pDView->SetHitTolerancePixel( 0 );
2762 pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE );
2763 pDView->SetHitTolerancePixel( nOld );
2764 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
2765
2766 SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)pFly->GetFmt();
2767 GetDoc()->Chain(rSource, *pFmt);
2768 EndAllAction();
2769 SetChainMarker();
2770 }
2771 return nErr;
2772 }
2773
2774 void SwFEShell::Unchain( SwFrmFmt &rFmt )
2775 {
2776 StartAllAction();
2777 GetDoc()->Unchain(rFmt);
2778 EndAllAction();
2779 }
2780
2781
2782 void SwFEShell::HideChainMarker()
2783 {
2784 if ( pChainFrom )
2785 {
2786 delete pChainFrom;
2787 pChainFrom = 0L;
2788 }
2789 if ( pChainTo )
2790 {
2791 delete pChainTo;
2792 pChainTo = 0L;
2793 }
2794 }
2795
2796 void SwFEShell::SetChainMarker()
2797 {
2798 BOOL bDelFrom = TRUE,
2799 bDelTo = TRUE;
2800 if ( IsFrmSelected() )
2801 {
2802 SwFlyFrm *pFly = FindFlyFrm();
2803
2804 if ( pFly->GetPrevLink() )
2805 {
2806 bDelFrom = FALSE;
2807 const SwFrm *pPre = pFly->GetPrevLink();
2808
2809 Point aStart( pPre->Frm().Right(), pPre->Frm().Bottom());
2810 Point aEnd(pFly->Frm().Pos());
2811
2812 if ( !pChainFrom )
2813 {
2814 pChainFrom = new SdrDropMarkerOverlay( *GetDrawView(), aStart, aEnd );
2815 }
2816 }
2817 if ( pFly->GetNextLink() )
2818 {
2819 bDelTo = FALSE;
2820 const SwFlyFrm *pNxt = pFly->GetNextLink();
2821
2822 Point aStart( pFly->Frm().Right(), pFly->Frm().Bottom());
2823 Point aEnd(pNxt->Frm().Pos());
2824
2825 if ( !pChainTo )
2826 {
2827 pChainTo = new SdrDropMarkerOverlay( *GetDrawView(), aStart, aEnd );
2828 }
2829 }
2830 }
2831
2832 if ( bDelFrom )
2833 {
2834 delete pChainFrom, pChainFrom = 0;
2835 }
2836
2837 if ( bDelTo )
2838 {
2839 delete pChainTo, pChainTo = 0;
2840 }
2841 }
2842
2843 long SwFEShell::GetSectionWidth( SwFmt& rFmt ) const
2844 {
2845 SwFrm *pFrm = GetCurrFrm();
2846 // Steht der Cursor z.Z. in einem SectionFrm?
2847 if( pFrm && pFrm->IsInSct() )
2848 {
2849 SwSectionFrm* pSect = pFrm->FindSctFrm();
2850 do
2851 {
2852 // Ist es der Gewuenschte?
2853 if( pSect->GetRegisteredIn() == &rFmt )
2854 return pSect->Frm().Width();
2855 // fuer geschachtelte Bereiche
2856 pSect = pSect->GetUpper()->FindSctFrm();
2857 }
2858 while( pSect );
2859 }
2860 SwClientIter aIter( rFmt );
2861 SwClient *pLast = aIter.GoStart();
2862 while ( pLast )
2863 {
2864 if ( pLast->IsA( TYPE(SwFrm) ) )
2865 {
2866 SwSectionFrm* pSct = (SwSectionFrm*)pLast;
2867 if( !pSct->IsFollow() )
2868 return pSct->Frm().Width();
2869 }
2870 pLast = aIter++;
2871 }
2872 return 0;
2873 }
2874 /* -----------------------------2002/06/24 15:07------------------------------
2875
2876 ---------------------------------------------------------------------------*/
2877 void SwFEShell::CreateDefaultShape( UINT16 /*SdrObjKind ?*/ eSdrObjectKind, const Rectangle& rRect,
2878 USHORT nSlotId)
2879 {
2880 SdrView* pDrawView = GetDrawView();
2881 SdrModel* pDrawModel = pDrawView->GetModel();
2882 SdrObject* pObj = SdrObjFactory::MakeNewObject(
2883 SdrInventor, eSdrObjectKind,
2884 0L, pDrawModel);
2885
2886 if(pObj)
2887 {
2888 Rectangle aRect(rRect);
2889 if(OBJ_CARC == eSdrObjectKind || OBJ_CCUT == eSdrObjectKind)
2890 {
2891 // force quadratic
2892 if(aRect.GetWidth() > aRect.GetHeight())
2893 {
2894 aRect = Rectangle(
2895 Point(aRect.Left() + ((aRect.GetWidth() - aRect.GetHeight()) / 2), aRect.Top()),
2896 Size(aRect.GetHeight(), aRect.GetHeight()));
2897 }
2898 else
2899 {
2900 aRect = Rectangle(
2901 Point(aRect.Left(), aRect.Top() + ((aRect.GetHeight() - aRect.GetWidth()) / 2)),
2902 Size(aRect.GetWidth(), aRect.GetWidth()));
2903 }
2904 }
2905 pObj->SetLogicRect(aRect);
2906
2907 if(pObj->ISA(SdrCircObj))
2908 {
2909 SfxItemSet aAttr(pDrawModel->GetItemPool());
2910 aAttr.Put(SdrCircStartAngleItem(9000));
2911 aAttr.Put(SdrCircEndAngleItem(0));
2912 pObj->SetMergedItemSet(aAttr);
2913 }
2914 else if(pObj->ISA(SdrPathObj))
2915 {
2916 basegfx::B2DPolyPolygon aPoly;
2917
2918 switch(eSdrObjectKind)
2919 {
2920 case OBJ_PATHLINE:
2921 {
2922 basegfx::B2DPolygon aInnerPoly;
2923
2924 aInnerPoly.append(basegfx::B2DPoint(aRect.Left(), aRect.Bottom()));
2925
2926 const basegfx::B2DPoint aCenterBottom(aRect.Center().X(), aRect.Bottom());
2927 aInnerPoly.appendBezierSegment(
2928 aCenterBottom,
2929 aCenterBottom,
2930 basegfx::B2DPoint(aRect.Center().X(), aRect.Center().Y()));
2931
2932 const basegfx::B2DPoint aCenterTop(aRect.Center().X(), aRect.Top());
2933 aInnerPoly.appendBezierSegment(
2934 aCenterTop,
2935 aCenterTop,
2936 basegfx::B2DPoint(aRect.Right(), aRect.Top()));
2937
2938 aInnerPoly.setClosed(true);
2939 aPoly.append(aInnerPoly);
2940 }
2941 break;
2942 case OBJ_FREELINE:
2943 {
2944 basegfx::B2DPolygon aInnerPoly;
2945
2946 aInnerPoly.append(basegfx::B2DPoint(aRect.Left(), aRect.Bottom()));
2947
2948 aInnerPoly.appendBezierSegment(
2949 basegfx::B2DPoint(aRect.Left(), aRect.Top()),
2950 basegfx::B2DPoint(aRect.Center().X(), aRect.Top()),
2951 basegfx::B2DPoint(aRect.Center().X(), aRect.Center().Y()));
2952
2953 aInnerPoly.appendBezierSegment(
2954 basegfx::B2DPoint(aRect.Center().X(), aRect.Bottom()),
2955 basegfx::B2DPoint(aRect.Right(), aRect.Bottom()),
2956 basegfx::B2DPoint(aRect.Right(), aRect.Top()));
2957
2958 aInnerPoly.append(basegfx::B2DPoint(aRect.Right(), aRect.Bottom()));
2959 aInnerPoly.setClosed(true);
2960 aPoly.append(aInnerPoly);
2961 }
2962 break;
2963 case OBJ_POLY:
2964 case OBJ_PLIN:
2965 {
2966 basegfx::B2DPolygon aInnerPoly;
2967 sal_Int32 nWdt(aRect.GetWidth());
2968 sal_Int32 nHgt(aRect.GetHeight());
2969
2970 aInnerPoly.append(basegfx::B2DPoint(aRect.Left(), aRect.Bottom()));
2971 aInnerPoly.append(basegfx::B2DPoint(aRect.Left() + (nWdt * 30) / 100, aRect.Top() + (nHgt * 70) / 100));
2972 aInnerPoly.append(basegfx::B2DPoint(aRect.Left(), aRect.Top() + (nHgt * 15) / 100));
2973 aInnerPoly.append(basegfx::B2DPoint(aRect.Left() + (nWdt * 65) / 100, aRect.Top()));
2974 aInnerPoly.append(basegfx::B2DPoint(aRect.Left() + nWdt, aRect.Top() + (nHgt * 30) / 100));
2975 aInnerPoly.append(basegfx::B2DPoint(aRect.Left() + (nWdt * 80) / 100, aRect.Top() + (nHgt * 50) / 100));
2976 aInnerPoly.append(basegfx::B2DPoint(aRect.Left() + (nWdt * 80) / 100, aRect.Top() + (nHgt * 75) / 100));
2977 aInnerPoly.append(basegfx::B2DPoint(aRect.Bottom(), aRect.Right()));
2978
2979 if(OBJ_PLIN == eSdrObjectKind)
2980 {
2981 aInnerPoly.append(basegfx::B2DPoint(aRect.Center().X(), aRect.Bottom()));
2982 }
2983 else
2984 {
2985 aInnerPoly.setClosed(true);
2986 }
2987
2988 aPoly.append(aInnerPoly);
2989 }
2990 break;
2991 case OBJ_LINE :
2992 {
2993 sal_Int32 nYMiddle((aRect.Top() + aRect.Bottom()) / 2);
2994 basegfx::B2DPolygon aTempPoly;
2995 aTempPoly.append(basegfx::B2DPoint(aRect.TopLeft().X(), nYMiddle));
2996 aTempPoly.append(basegfx::B2DPoint(aRect.BottomRight().X(), nYMiddle));
2997 aPoly.append(aTempPoly);
2998 }
2999 break;
3000 }
3001
3002 ((SdrPathObj*)pObj)->SetPathPoly(aPoly);
3003 }
3004 else if(pObj->ISA(SdrCaptionObj))
3005 {
3006 BOOL bVerticalText = ( SID_DRAW_TEXT_VERTICAL == nSlotId ||
3007 SID_DRAW_CAPTION_VERTICAL == nSlotId );
3008 ((SdrTextObj*)pObj)->SetVerticalWriting(bVerticalText);
3009 if(bVerticalText)
3010 {
3011 SfxItemSet aSet(pObj->GetMergedItemSet());
3012 aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER));
3013 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
3014 pObj->SetMergedItemSet(aSet);
3015 }
3016
3017 ((SdrCaptionObj*)pObj)->SetLogicRect(aRect);
3018 ((SdrCaptionObj*)pObj)->SetTailPos(
3019 aRect.TopLeft() - Point(aRect.GetWidth() / 2, aRect.GetHeight() / 2));
3020 }
3021 else if(pObj->ISA(SdrTextObj))
3022 {
3023 SdrTextObj* pText = (SdrTextObj*)pObj;
3024 pText->SetLogicRect(aRect);
3025
3026 sal_Bool bVertical = (SID_DRAW_TEXT_VERTICAL == nSlotId);
3027 sal_Bool bMarquee = (SID_DRAW_TEXT_MARQUEE == nSlotId);
3028
3029 pText->SetVerticalWriting(bVertical);
3030
3031 if(bVertical)
3032 {
3033 SfxItemSet aSet(pDrawModel->GetItemPool());
3034 aSet.Put(SdrTextAutoGrowWidthItem(TRUE));
3035 aSet.Put(SdrTextAutoGrowHeightItem(FALSE));
3036 aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP));
3037 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
3038 pText->SetMergedItemSet(aSet);
3039 }
3040
3041 if(bMarquee)
3042 {
3043 SfxItemSet aSet(pDrawModel->GetItemPool(), SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST);
3044 aSet.Put( SdrTextAutoGrowWidthItem( FALSE ) );
3045 aSet.Put( SdrTextAutoGrowHeightItem( FALSE ) );
3046 aSet.Put( SdrTextAniKindItem( SDRTEXTANI_SLIDE ) );
3047 aSet.Put( SdrTextAniDirectionItem( SDRTEXTANI_LEFT ) );
3048 aSet.Put( SdrTextAniCountItem( 1 ) );
3049 aSet.Put( SdrTextAniAmountItem( (INT16)GetWin()->PixelToLogic(Size(2,1)).Width()) );
3050 pObj->SetMergedItemSetAndBroadcast(aSet);
3051 }
3052 }
3053 SdrPageView* pPageView = pDrawView->GetSdrPageView();
3054 pDrawView->InsertObjectAtView(pObj, *pPageView);
3055 }
3056 ImpEndCreate();
3057 }
3058
3059 /** SwFEShell::GetShapeBackgrd
3060
3061 OD 02.09.2002 for #102450#:
3062 method determines background color of the page the selected drawing
3063 object is on and returns this color.
3064 If no color is found, because no drawing object is selected or ...,
3065 color COL_BLACK (default color on constructing object of class Color)
3066 is returned.
3067
3068 @author OD
3069
3070 @returns an object of class Color
3071 */
3072 const Color SwFEShell::GetShapeBackgrd() const
3073 {
3074 Color aRetColor;
3075
3076 // check, if a draw view exists
3077 ASSERT( Imp()->GetDrawView(), "wrong usage of SwFEShell::GetShapeBackgrd - no draw view!");
3078 if( Imp()->GetDrawView() )
3079 {
3080 // determine list of selected objects
3081 const SdrMarkList* pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
3082 // check, if exactly one object is selected.
3083 ASSERT( pMrkList->GetMarkCount() == 1, "wrong usage of SwFEShell::GetShapeBackgrd - no selected object!");
3084 if ( pMrkList->GetMarkCount() == 1)
3085 {
3086 // get selected object
3087 const SdrObject *pSdrObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
3088 // check, if selected object is a shape (drawing object)
3089 ASSERT( !pSdrObj->ISA(SwVirtFlyDrawObj), "wrong usage of SwFEShell::GetShapeBackgrd - selected object is not a drawing object!");
3090 if ( !pSdrObj->ISA(SwVirtFlyDrawObj) )
3091 {
3092 // determine page frame of the frame the shape is anchored.
3093 const SwFrm* pAnchorFrm =
3094 static_cast<SwDrawContact*>(GetUserCall(pSdrObj))->GetAnchorFrm( pSdrObj );
3095 ASSERT( pAnchorFrm, "inconsistent modell - no anchor at shape!");
3096 if ( pAnchorFrm )
3097 {
3098 const SwPageFrm* pPageFrm = pAnchorFrm->FindPageFrm();
3099 ASSERT( pPageFrm, "inconsistent modell - no page!");
3100 if ( pPageFrm )
3101 {
3102 aRetColor = pPageFrm->GetDrawBackgrdColor();
3103 }
3104 }
3105 }
3106 }
3107 }
3108
3109 return aRetColor;
3110 }
3111
3112 /** Is default horizontal text direction for selected drawing object right-to-left
3113
3114 OD 09.12.2002 #103045#
3115 Because drawing objects only painted for each page only, the default
3116 horizontal text direction of a drawing object is given by the corresponding
3117 page property.
3118
3119 @author OD
3120
3121 @returns boolean, indicating, if the horizontal text direction of the
3122 page, the selected drawing object is on, is right-to-left.
3123 */
3124 bool SwFEShell::IsShapeDefaultHoriTextDirR2L() const
3125 {
3126 bool bRet = false;
3127
3128 // check, if a draw view exists
3129 ASSERT( Imp()->GetDrawView(), "wrong usage of SwFEShell::GetShapeBackgrd - no draw view!");
3130 if( Imp()->GetDrawView() )
3131 {
3132 // determine list of selected objects
3133 const SdrMarkList* pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
3134 // check, if exactly one object is selected.
3135 ASSERT( pMrkList->GetMarkCount() == 1, "wrong usage of SwFEShell::GetShapeBackgrd - no selected object!");
3136 if ( pMrkList->GetMarkCount() == 1)
3137 {
3138 // get selected object
3139 const SdrObject *pSdrObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
3140 // check, if selected object is a shape (drawing object)
3141 ASSERT( !pSdrObj->ISA(SwVirtFlyDrawObj), "wrong usage of SwFEShell::GetShapeBackgrd - selected object is not a drawing object!");
3142 if ( !pSdrObj->ISA(SwVirtFlyDrawObj) )
3143 {
3144 // determine page frame of the frame the shape is anchored.
3145 const SwFrm* pAnchorFrm =
3146 static_cast<SwDrawContact*>(GetUserCall(pSdrObj))->GetAnchorFrm( pSdrObj );
3147 ASSERT( pAnchorFrm, "inconsistent modell - no anchor at shape!");
3148 if ( pAnchorFrm )
3149 {
3150 const SwPageFrm* pPageFrm = pAnchorFrm->FindPageFrm();
3151 ASSERT( pPageFrm, "inconsistent modell - no page!");
3152 if ( pPageFrm )
3153 {
3154 bRet = pPageFrm->IsRightToLeft() ? true : false;
3155 }
3156 }
3157 }
3158 }
3159 }
3160
3161 return bRet;
3162 }
3163 /* -----------------20.03.2003 14:35-----------------
3164
3165 --------------------------------------------------*/
3166 Point SwFEShell::GetRelativePagePosition(const Point& rDocPos)
3167 {
3168 Point aRet(-1, -1);
3169 const SwFrm *pPage = GetLayout()->Lower();
3170 while ( pPage && !pPage->Frm().IsInside( rDocPos ) )
3171 {
3172 pPage = pPage->GetNext();
3173 }
3174 if(pPage)
3175 {
3176 aRet = rDocPos - pPage->Frm().TopLeft();
3177 }
3178 return aRet;
3179 }
3180
vba interoperability for OOo