?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sw / source / core / frmedt / feshview.cxx
blob72f9ff07965dec6731e181c0bafca944b78bcd24
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 NEEDED_BY_FESHVIEW
38 #define _FESHVIEW_ONLY_INLINE_NEEDED
39 #endif
40
41 #include <svx/svdobj.hxx>
42 #include <svx/svdouno.hxx>
43 #include <svx/svdoole2.hxx>
44 #include <svx/svdogrp.hxx>
45 #include <svx/svdocirc.hxx>
46 #include <svx/svdopath.hxx>
47 #include <svx/sxciaitm.hxx>
48 #include <svx/xfillit.hxx>
49 #include <svx/svdocapt.hxx>
50 #include <sfx2/app.hxx>
51 #include <svx/boxitem.hxx>
52 #include <svx/opaqitem.hxx>
53 #include <svx/protitem.hxx>
54 #include <svx/svdpage.hxx>
55 #include <svx/svdpagv.hxx>
56
57 #ifndef _POOLFMT_HRC
58 #include <poolfmt.hrc> // fuer InitFldTypes
59 #endif
60 #include <frmfmt.hxx>
61 #include <frmatr.hxx>
62 #include <fmtfsize.hxx>
63 #include <fmtanchr.hxx>
64 #include <fmtornt.hxx>
65 #include <fmtsrnd.hxx>
66 #include <fmtcntnt.hxx>
67 #include <fmtflcnt.hxx>
68 #include <fmtcnct.hxx>
69 #include <docary.hxx>
70 #include <tblsel.hxx>
71 #include <swtable.hxx>
72 #include <flyfrms.hxx>
73 #include "fesh.hxx"
74 #include "rootfrm.hxx"
75 #include "pagefrm.hxx"
76 #include "sectfrm.hxx"
77 #include "doc.hxx"
78 #include "dview.hxx"
79 #include "dflyobj.hxx"
80 #include "dcontact.hxx"
81 #include "viewimp.hxx"
82 #include "flyfrm.hxx"
83 #include "pam.hxx"
84 #include "ndole.hxx"
85 #include "ndgrf.hxx"
86 #include "ndtxt.hxx"
87 #include "viewopt.hxx" // fuer GetHTMLMode
88 #include "swundo.hxx"
89 #include "notxtfrm.hxx"
90 #include "txtfrm.hxx"
91 #include "txatbase.hxx"
92 #include "mdiexp.hxx" // fuer Update der Statuszeile bei drag
93 // OD 2004-05-24 #i28701#
94 #include <sortedobjs.hxx>
95 // --> OD 2006-03-06 #125892#
96 #include <HandleAnchorNodeChg.hxx>
97 // <--
98 #include <basegfx/polygon/b2dpolygon.hxx>
99
100 #define SCROLLVAL 75
101
102 using namespace com::sun::star;
103
104 //Tattergrenze fuer Drawing-SS
105 #define MINMOVE ((USHORT)GetOut()->PixelToLogic(Size(Imp()->GetDrawView()->GetMarkHdlSizePixel()/2,0)).Width())
106
107 SwFlyFrm *GetFlyFromMarked( const SdrMarkList *pLst, ViewShell *pSh )
108 {
109 if ( !pLst )
110 pLst = pSh->HasDrawView() ? &pSh->Imp()->GetDrawView()->GetMarkedObjectList():0;
111
112 if ( pLst && pLst->GetMarkCount() == 1 )
113 {
114 SdrObject *pO = pLst->GetMark( 0 )->GetMarkedSdrObj();
115 if ( pO->ISA(SwVirtFlyDrawObj) )
116 return ((SwVirtFlyDrawObj*)pO)->GetFlyFrm();
117 }
118 return 0;
119 }
120
121 void lcl_GrabCursor( SwFEShell* pSh, SwFlyFrm* pOldSelFly)
122 {
123 const SwFrmFmt *pFlyFmt = pSh->SelFlyGrabCrsr();
124 if( pFlyFmt && !pSh->ActionPend() &&
125 (!pOldSelFly || pOldSelFly->GetFmt() != pFlyFmt) )
126 {
127 // dann das evt. gesetzte Macro rufen
128 pSh->GetFlyMacroLnk().Call( (void*)pFlyFmt );
129 extern BOOL bNoInterrupt; // in swapp.cxx
130 // wir in dem Makro ein Dialog gestartet, dann kommt das
131 // MouseButtonUp zu diesem und nicht zu uns. Dadurch ist
132 // Flag bei uns immer gesetzt und schaltet nie die auf die
133 // entsp. Shell um !!!!!!!
134 bNoInterrupt = FALSE;
135 }
136 else if( !pFlyFmt || RES_DRAWFRMFMT == pFlyFmt->Which() )
137 {
138 // --> OD 2007-07-25 #136039#
139 // assure consistent cursor
140 pSh->KillPams();
141 pSh->ClearMark();
142 // <--
143 pSh->SetCrsr( pSh->Imp()->GetDrawView()->GetAllMarkedRect().TopLeft(), TRUE);
144 }
145 }
146
147 /*************************************************************************
148 |*
149 |* SwFEShell::SelectObj()
150 |*
151 |* Ersterstellung MA 16. Nov. 92
152 |* Letzte Aenderung MA 22. Oct. 96
153 |*
154 *************************************************************************/
155
156 BOOL SwFEShell::SelectObj( const Point& rPt, BYTE nFlag, SdrObject *pObj )
157 {
158 SwDrawView *pDView = Imp()->GetDrawView();
159 if(!pDView)
160 return sal_False;
161 SET_CURR_SHELL( this );
162 StartAction(); //Aktion ist Notwendig, damit nicht mehrere
163 //AttrChgdNotify (etwa durch Unmark->MarkListHasChgd)
164 //durchkommen
165
166 const SdrMarkList &rMrkList = pDView->GetMarkedObjectList();
167 const BOOL bHadSelection = rMrkList.GetMarkCount() ? TRUE : FALSE;
168 const BOOL bAddSelect = 0 != (SW_ADD_SELECT & nFlag);
169 const BOOL bEnterGroup = 0 != (SW_ENTER_GROUP & nFlag);
170 SwFlyFrm* pOldSelFly = 0;
171 const Point aOldPos( pDView->GetAllMarkedRect().TopLeft() );
172
173 if( bHadSelection )
174 {
175 //Unmark rufen wenn !bAddSelect oder wenn ein Fly selektiert ist.
176 BOOL bUnmark = !bAddSelect;
177
178 if ( rMrkList.GetMarkCount() == 1 )
179 {
180 //Wenn ein Fly selektiert ist, so muss er erst deselektiert werden.
181 pOldSelFly = ::GetFlyFromMarked( &rMrkList, this );
182 if ( pOldSelFly )
183 {
184 const USHORT nType = GetCntType();
185 if( nType != CNT_TXT || (SW_LEAVE_FRAME & nFlag) ||
186 ( pOldSelFly->GetFmt()->GetProtect().IsCntntProtected()
187 && !IsReadOnlyAvailable() ))
188 {
189 //Wenn ein Fly deselektiert wird, der Grafik, Ole o.ae.
190 //enthaelt, so muss der Crsr aus diesem entfernt werden.
191 //Desgleichen wenn ein Fly mit geschuetztem Inhalt deselektiert
192 //wird. Der Einfachheit halber wire der Crsr 'grad so neben die
193 //linke obere Ecke gesetzt.
194 Point aPt( pOldSelFly->Frm().Pos() );
195 aPt.X() -= 1;
196 BOOL bUnLockView = !IsViewLocked();
197 LockView( TRUE );
198 SetCrsr( aPt, TRUE );
199 if( bUnLockView )
200 LockView( FALSE );
201 }
202 if ( nType & CNT_GRF &&
203 ((SwNoTxtFrm*)pOldSelFly->Lower())->HasAnimation() )
204 {
205 GetWin()->Invalidate( pOldSelFly->Frm().SVRect() );
206 }
207 bUnmark = TRUE;
208 }
209 }
210 if ( bUnmark )
211 pDView->UnmarkAll();
212 }
213 else
214 {
215 KillPams();
216 ClearMark();
217 }
218
219 if ( pObj )
220 {
221 ASSERT( !bEnterGroup, "SW_ENTER_GROUP is not supported" );
222 pDView->MarkObj( pObj, Imp()->GetPageView() );
223 }
224 else
225 {
226 pDView->MarkObj( rPt, MINMOVE, bAddSelect, bEnterGroup );
227 }
228
229 const BOOL bRet = 0 != rMrkList.GetMarkCount();
230
231 if ( rMrkList.GetMarkCount() > 1 )
232 {
233 //Ganz dumm ist es, wenn Zeichenobjekte Selektiert waren und
234 //nun ein Fly hinzuselektiert wird.
235 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
236 {
237 SdrObject *pTmpObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
238 BOOL bForget = pTmpObj->ISA(SwVirtFlyDrawObj);
239 if( bForget )
240 {
241 pDView->UnmarkAll();
242 if ( pTmpObj )
243 pDView->MarkObj( pTmpObj, Imp()->GetPageView(), bAddSelect, bEnterGroup );
244 else
245 pDView->MarkObj( rPt, MINMOVE );
246 break;
247 }
248 }
249 }
250
251 if ( bRet )
252 {
253 ::lcl_GrabCursor(this, pOldSelFly);
254 if ( GetCntType() & CNT_GRF )
255 {
256 const SwFlyFrm *pTmp = GetFlyFromMarked( &rMrkList, this );
257 ASSERT( pTmp, "Graphic without Fly" );
258 if ( ((SwNoTxtFrm*)pTmp->Lower())->HasAnimation() )
259 ((SwNoTxtFrm*)pTmp->Lower())->StopAnimation( GetOut() );
260 }
261 }
262 else if ( !pOldSelFly && bHadSelection )
263 SetCrsr( aOldPos, TRUE);
264
265 if( bRet || !bHadSelection )
266 CallChgLnk();
267
268 // update der Statuszeile
269 ::FrameNotify( this, bRet ? FLY_DRAG_START : FLY_DRAG_END );
270
271 EndAction();
272 return bRet;
273 }
274
275 /*************************************************************************
276 |*
277 |* sal_Bool SwFEShell::MoveAnchor( USHORT nDir )
278 |*
279 |* Created AMA 05/28/2002
280 |* Last modify AMA 05/30/2002
281 |*
282 |* Description: MoveAnchor( nDir ) looked for an another Anchor for
283 |* the selected drawing object (or fly frame) in the given direction.
284 |* An object "as character" doesn't moves anyway.
285 |* A page bounded object could move to the previous/next page with up/down,
286 |* an object bounded "at paragraph" moves to the previous/next paragraph, too.
287 |* An object bounded "at character" moves to the previous/next paragraph
288 |* with up/down and to the previous/next character with left/right.
289 |* If the anchor for at paragraph/character bounded objects has vertical or
290 |* right_to_left text direction, the directions for up/down/left/right will
291 |* interpreted accordingly.
292 |* An object bounded "at fly" takes the center of the actual anchor and looks
293 |* for the nearest fly frame in the given direction.
294 |*
295 *************************************************************************/
296
297 #define LESS_X( aPt1, aPt2, bOld ) ( aPt1.X() < aPt2.X() || \
298 ( aPt1.X() == aPt2.X() && ( aPt1.Y() < aPt2.Y() || \
299 ( aPt1.Y() == aPt2.Y() && bOld ) ) ) )
300 #define LESS_Y( aPt1, aPt2, bOld ) ( aPt1.Y() < aPt2.Y() || \
301 ( aPt1.Y() == aPt2.Y() && ( aPt1.X() < aPt2.X() || \
302 ( aPt1.X() == aPt2.X() && bOld ) ) ) )
303
304 sal_Bool SwFEShell::MoveAnchor( USHORT nDir )
305 {
306 const SdrMarkList* pMrkList;
307 if( !Imp()->GetDrawView() ||
308 0 == (pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList()) ||
309 1 != pMrkList->GetMarkCount())
310 return sal_False;
311 SwFrm* pOld;
312 SwFlyFrm* pFly = NULL;
313 SdrObject *pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
314 if( pObj->ISA(SwVirtFlyDrawObj) )
315 {
316 pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
317 pOld = pFly->AnchorFrm();
318 }
319 else
320 pOld = ((SwDrawContact*)GetUserCall(pObj))->GetAnchorFrm( pObj );
321 sal_Bool bRet = sal_False;
322 if( pOld )
323 {
324 SwFrm* pNew = pOld;
325 // --> OD 2004-07-16 #i28701#
326 SwAnchoredObject* pAnchoredObj = ::GetUserCall( pObj )->GetAnchoredObj( pObj );
327 SwFrmFmt& rFmt = pAnchoredObj->GetFrmFmt();
328 SwFmtAnchor aAnch( rFmt.GetAnchor() );
329 RndStdIds nAnchorId = aAnch.GetAnchorId();
330 if ( FLY_IN_CNTNT == nAnchorId )
331 return sal_False;
332 if( pOld->IsVertical() )
333 {
334 if( pOld->IsTxtFrm() )
335 {
336 switch( nDir ) {
337 case SW_MOVE_UP: nDir = SW_MOVE_LEFT; break;
338 case SW_MOVE_DOWN: nDir = SW_MOVE_RIGHT; break;
339 case SW_MOVE_LEFT: nDir = SW_MOVE_DOWN; break;
340 case SW_MOVE_RIGHT: nDir = SW_MOVE_UP; break;
341 }
342 if( pOld->IsRightToLeft() )
343 {
344 if( nDir == SW_MOVE_LEFT )
345 nDir = SW_MOVE_RIGHT;
346 else if( nDir == SW_MOVE_RIGHT )
347 nDir = SW_MOVE_LEFT;
348 }
349 }
350 }
351 switch ( nAnchorId ) {
352 case FLY_PAGE:
353 {
354 ASSERT( pOld->IsPageFrm(), "Wrong anchor, page exspected." );
355 if( SW_MOVE_UP == nDir )
356 pNew = pOld->GetPrev();
357 else if( SW_MOVE_DOWN == nDir )
358 pNew = pOld->GetNext();
359 if( pNew && pNew != pOld )
360 {
361 aAnch.SetPageNum( ((SwPageFrm*)pNew)->GetPhyPageNum() );
362 bRet = sal_True;
363 }
364 break;
365 }
366 case FLY_AUTO_CNTNT:
367 {
368 ASSERT( pOld->IsCntntFrm(), "Wrong anchor, page exspected." );
369 if( SW_MOVE_LEFT == nDir || SW_MOVE_RIGHT == nDir )
370 {
371 SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
372 SwTxtNode* pTxtNd = ((SwTxtFrm*)pOld)->GetTxtNode();
373 xub_StrLen nAct = pPos->nContent.GetIndex();
374 if( SW_MOVE_LEFT == nDir )
375 {
376 bRet = sal_True;
377 if( nAct )
378 {
379 --nAct;
380 pPos->nContent.Assign( pTxtNd, nAct );
381 }
382 else
383 nDir = SW_MOVE_UP;
384 }
385 else
386 {
387 xub_StrLen nMax =
388 ((SwTxtFrm*)pOld)->GetTxtNode()->GetTxt().Len();
389 if( nAct < nMax )
390 {
391 ++nAct;
392 bRet = sal_True;
393 pPos->nContent.Assign( pTxtNd, nAct );
394 }
395 else
396 nDir = SW_MOVE_DOWN;
397 }
398 }
399 } // no break!
400 case FLY_AT_CNTNT:
401 {
402 ASSERT( pOld->IsCntntFrm(), "Wrong anchor, page exspected." );
403 if( SW_MOVE_UP == nDir )
404 pNew = pOld->FindPrev();
405 else if( SW_MOVE_DOWN == nDir )
406 pNew = pOld->FindNext();
407 if( pNew && pNew != pOld && pNew->IsCntntFrm() )
408 {
409 SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
410 SwTxtNode* pTxtNd = ((SwTxtFrm*)pNew)->GetTxtNode();
411 pPos->nNode = *pTxtNd;
412 xub_StrLen nTmp = 0;
413 if( bRet )
414 {
415 nTmp = ((SwTxtFrm*)pNew)->GetTxtNode()->GetTxt().Len();
416 if( nTmp )
417 --nTmp;
418 }
419 pPos->nContent.Assign( pTxtNd, nTmp );
420 bRet = sal_True;
421 }
422 else if( SW_MOVE_UP == nDir || SW_MOVE_DOWN == nDir )
423 bRet = sal_False;
424 break;
425 }
426 case FLY_AT_FLY:
427 {
428 ASSERT( pOld->IsFlyFrm(), "Wrong anchor, fly frame exspected.");
429 SwPageFrm* pPage = pOld->FindPageFrm();
430 ASSERT( pPage, "Where's my page?" );
431 SwFlyFrm* pNewFly = NULL;
432 if( pPage->GetSortedObjs() )
433 {
434 int i;
435 sal_Bool bOld = sal_False;
436 Point aCenter( pOld->Frm().Left() + pOld->Frm().Width()/2,
437 pOld->Frm().Top() + pOld->Frm().Height()/2 );
438 Point aBest;
439 for( i = 0; (USHORT)i<pPage->GetSortedObjs()->Count(); ++i )
440 {
441 SwAnchoredObject* pAnchObj =
442 (*pPage->GetSortedObjs())[i];
443 if( pAnchObj->ISA(SwFlyFrm) )
444 {
445 SwFlyFrm* pTmp = static_cast<SwFlyFrm*>(pAnchObj);
446 if( pTmp == pOld )
447 bOld = sal_True;
448 else
449 {
450 const SwFlyFrm* pCheck = pFly ? pTmp : 0;
451 while( pCheck )
452 {
453 if( pCheck == pFly )
454 break;
455 const SwFrm *pNxt = pCheck->GetAnchorFrm();
456 pCheck = pNxt ? pNxt->FindFlyFrm() : NULL;
457 }
458 if( pCheck || pTmp->IsProtected() )
459 continue;
460 Point aNew( pTmp->Frm().Left() +
461 pTmp->Frm().Width()/2,
462 pTmp->Frm().Top() +
463 pTmp->Frm().Height()/2 );
464 sal_Bool bAccept = sal_False;
465 switch( nDir ) {
466 case SW_MOVE_RIGHT:
467 {
468 bAccept = LESS_X( aCenter, aNew, bOld )
469 && ( !pNewFly ||
470 LESS_X( aNew, aBest, sal_False ) );
471 break;
472 }
473 case SW_MOVE_LEFT:
474 {
475 bAccept = LESS_X( aNew, aCenter, !bOld )
476 && ( !pNewFly ||
477 LESS_X( aBest, aNew, sal_True ) );
478 break;
479 }
480 case SW_MOVE_UP:
481 {
482 bAccept = LESS_Y( aNew, aCenter, !bOld )
483 && ( !pNewFly ||
484 LESS_Y( aBest, aNew, sal_True ) );
485 break;
486 }
487 case SW_MOVE_DOWN:
488 {
489 bAccept = LESS_Y( aCenter, aNew, bOld )
490 && ( !pNewFly ||
491 LESS_Y( aNew, aBest, sal_False ) );
492 break;
493 }
494 }
495 if( bAccept )
496 {
497 pNewFly = pTmp;
498 aBest = aNew;
499 }
500 }
501 }
502 }
503 }
504
505 if( pNewFly )
506 {
507 SwPosition aPos( *pNewFly->GetFmt()->
508 GetCntnt().GetCntntIdx());
509 aAnch.SetAnchor( &aPos );
510 bRet = sal_True;
511 }
512 break;
513 }
514 default: break;
515 }
516 if( bRet )
517 {
518 StartAllAction();
519 // --> OD 2006-02-28 #125892#
520 // handle change of anchor node:
521 // if count of the anchor frame also change, the fly frames have to be
522 // re-created. Thus, delete all fly frames except the <this> before the
523 // anchor attribute is change and re-create them afterwards.
524 {
525 SwHandleAnchorNodeChg* pHandleAnchorNodeChg( 0L );
526 SwFlyFrmFmt* pFlyFrmFmt( dynamic_cast<SwFlyFrmFmt*>(&rFmt) );
527 if ( pFlyFrmFmt )
528 {
529 pHandleAnchorNodeChg =
530 new SwHandleAnchorNodeChg( *pFlyFrmFmt, aAnch );
531 }
532 rFmt.GetDoc()->SetAttr( aAnch, rFmt );
533 delete pHandleAnchorNodeChg;
534 }
535 // <--
536 // --> OD 2004-06-24 #i28701# - no call of method
537 // <CheckCharRectAndTopOfLine()> for to-character anchored
538 // Writer fly frame needed. This method call can cause a
539 // format of the anchor frame, which is no longer intended.
540 // Instead clear the anchor character rectangle and
541 // the top of line values for all to-character anchored objects.
542 pAnchoredObj->ClearCharRectAndTopOfLine();
543 EndAllAction();
544 }
545 }
546 return bRet;
547 }
548
549 /*************************************************************************
550 |*
551 |* SwFEShell::GetSelFrmType()
552 |*
553 |* Ersterstellung MA 12. Jan. 93
554 |* Letzte Aenderung JP 19.03.96
555 |*
556 *************************************************************************/
557
558 const SdrMarkList* SwFEShell::_GetMarkList() const
559 {
560 const SdrMarkList* pMarkList = NULL;
561 if( Imp()->GetDrawView() != NULL )
562 pMarkList = &Imp()->GetDrawView()->GetMarkedObjectList();
563 return pMarkList;
564 }
565
566 USHORT SwFEShell::GetSelFrmType() const
567 {
568 USHORT eType;
569
570 // get marked frame list, and check if anything is selected
571 const SdrMarkList* pMarkList = _GetMarkList();
572 if( pMarkList == NULL || pMarkList->GetMarkCount() == 0 )
573 eType = FRMTYPE_NONE;
574 else
575 {
576 // obtain marked item as fly frame; if no fly frame, it must
577 // be a draw object
578 const SwFlyFrm* pFly = ::GetFlyFromMarked(pMarkList, (ViewShell*)this);
579 if ( pFly != NULL )
580 {
581 if( pFly->IsFlyLayFrm() )
582 eType = FRMTYPE_FLY_FREE;
583 else if( pFly->IsFlyAtCntFrm() )
584 eType = FRMTYPE_FLY_ATCNT;
585 else
586 {
587 ASSERT( pFly->IsFlyInCntFrm(), "Neuer Rahmentyp?" );
588 eType = FRMTYPE_FLY_INCNT;
589 }
590 }
591 else
592 eType = FRMTYPE_DRAWOBJ;
593 }
594
595 return eType;
596 }
597
598 // #108784# does the draw selection contain a control?
599 bool SwFEShell::IsSelContainsControl() const
600 {
601 bool bRet = false;
602
603 // basically, copy the mechanism from GetSelFrmType(), but call
604 // CheckControl... if you get a drawing object
605 const SdrMarkList* pMarkList = _GetMarkList();
606 if( pMarkList != NULL && pMarkList->GetMarkCount() == 1 )
607 {
608 // if we have one marked object, get the SdrObject and check
609 // whether it contains a control
610 const SdrObject* pSdrObject = pMarkList->GetMark( 0 )->GetMarkedSdrObj();
611 bRet = CheckControlLayer( pSdrObject );
612 }
613 return bRet;
614 }
615
616 /*************************************************************************
617 |*
618 |* SwFEShell::Scroll()
619 |*
620 |* Ersterstellung MA 20. Dec. 94
621 |* Letzte Aenderung MA 27. Jul. 95
622 |*
623 *************************************************************************/
624
625 void SwFEShell::ScrollTo( const Point &rPt )
626 {
627 const SwRect aRect( rPt, rPt );
628 if ( IsScrollMDI( this, aRect ) &&
629 (!Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() ||
630 Imp()->IsDragPossible( rPt )) )
631 {
632 //SwSaveHdl aSave( Imp() );
633 ScrollMDI( this, aRect, SCROLLVAL, SCROLLVAL );
634 }
635 }
636
637 /*************************************************************************
638 |*
639 |* SwFEShell::SetDragMode()
640 |*
641 |* Ersterstellung MA 30. Jan. 95
642 |* Letzte Aenderung MA 30. Jan. 95
643 |*
644 *************************************************************************/
645
646 void SwFEShell::SetDragMode( UINT16 eDragMode )
647 {
648 if ( Imp()->HasDrawView() )
649 Imp()->GetDrawView()->SetDragMode( (SdrDragMode)eDragMode );
650 }
651
652 /*************************************************************************
653 |*
654 |* SwFEShell::BeginDrag()
655 |*
656 |* Ersterstellung MS 10.06.92
657 |* Letzte Aenderung MA 13. Mar. 96
658 |*
659 *************************************************************************/
660
661 long SwFEShell::BeginDrag( const Point* pPt, BOOL )
662 {
663 SdrView *pView = Imp()->GetDrawView();
664 if ( pView && pView->AreObjectsMarked() )
665 {
666 delete pChainFrom; delete pChainTo; pChainFrom = pChainTo = 0;
667 SdrHdl* pHdl = pView->PickHandle( *pPt );
668 pView->BegDragObj( *pPt, 0 /*GetWin()*/, pHdl );
669 ::FrameNotify( this, FLY_DRAG );
670 return 1;
671 }
672 return 0;
673 }
674 /*************************************************************************
675 |*
676 |* SwFEShell::Drag()
677 |*
678 |* Ersterstellung MS 10.06.92
679 |* Letzte Aenderung MA 13. Mar. 96
680 |*
681 *************************************************************************/
682
683 long SwFEShell::Drag( const Point *pPt, BOOL )
684 {
685 ASSERT( Imp()->HasDrawView(), "Drag without DrawView?" );
686 if ( Imp()->GetDrawView()->IsDragObj() )
687 {
688 ScrollTo( *pPt );
689 Imp()->GetDrawView()->MovDragObj( *pPt );
690 Imp()->GetDrawView()->ShowDragAnchor();
691 ::FrameNotify( this, FLY_DRAG );
692 return 1;
693 }
694 return 0;
695 }
696
697 /*************************************************************************
698 |*
699 |* SwFEShell::EndDrag()
700 |*
701 |* Ersterstellung MS 10.06.92
702 |* Letzte Aenderung MA 13. Mar. 96
703 |*
704 *************************************************************************/
705
706 long SwFEShell::EndDrag( const Point *, BOOL )
707 {
708 ASSERT( Imp()->HasDrawView(), "EndDrag without DrawView?" );
709 SdrView *pView = Imp()->GetDrawView();
710 if ( pView->IsDragObj() )
711 {
712 //Start-/EndActions nur an der ViewShell aufsetzen
713 ViewShell *pSh = this;
714 do {
715 pSh->StartAction();
716 } while ( this != (pSh = (ViewShell*)pSh->GetNext()) );
717
718 StartUndo( UNDO_START );
719
720 //#50778# Bug im Draging: Im StartAction wird ein HideShowXor gerufen.
721 //Im EndDragObj() wird dies unsinniger und faelschlicherweise wieder
722 //Rueckgaengig gemacht. Um Konsistenz herzustellen muessen wir das
723 //Xor also wieder zur Anzeige bringen.
724
725 // Reanimation from the hack #50778 to fix bug #97057
726 // May be not the best solution, but the one with lowest risc at the moment.
727 //pView->ShowShownXor( GetOut() );
728
729 pView->EndDragObj();
730 // JP 18.08.95: DrawUndo-Action auf FlyFrames werden nicht gespeichert
731 // Die Fly aendern das Flag
732 GetDoc()->SetNoDrawUndoObj( FALSE );
733 ChgAnchor( 0, TRUE );
734
735 EndUndo( UNDO_END );
736
737 do {
738 pSh->EndAction();
739 if( pSh->IsA( TYPE( SwCrsrShell ) ) )
740 ((SwCrsrShell*)pSh)->CallChgLnk();
741 } while ( this != (pSh = (ViewShell*)pSh->GetNext()) );
742
743 GetDoc()->SetModified();
744 ::FrameNotify( this, FLY_DRAG );
745 return 1;
746 }
747 return 0;
748 }
749
750 /*************************************************************************
751 |*
752 |* SwFEShell::BreakDrag()
753 |*
754 |* Ersterstellung OM 02. Okt. 95
755 |* Letzte Aenderung OM 02. Okt. 95
756 |*
757 *************************************************************************/
758
759 void SwFEShell::BreakDrag()
760 {
761 ASSERT( Imp()->HasDrawView(), "BreakDrag without DrawView?" );
762 if ( Imp()->GetDrawView()->IsDragObj() )
763 Imp()->GetDrawView()->BrkDragObj();
764 SetChainMarker();
765 }
766
767 /*************************************************************************
768 |*
769 |* SwFEShell::SelFlyGrabCrsr()
770 |*
771 |* Beschreibung Wenn ein Fly selektiert ist, zieht er den Crsr in
772 |* den ersten CntntFrm
773 |* Ersterstellung MA 11. Dec. 92
774 |* Letzte Aenderung MA 07. Oct. 96
775 |*
776 *************************************************************************/
777
778 const SwFrmFmt* SwFEShell::SelFlyGrabCrsr()
779 {
780 if ( Imp()->HasDrawView() )
781 {
782 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
783 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
784
785 if( pFly )
786 {
787 // --> OD 2004-06-11 #i28701# - no format here
788 // pFly->GetAnchorFrm()->Calc();
789 SwCntntFrm *pCFrm = pFly->ContainsCntnt();
790 if ( pCFrm )
791 {
792 SwCntntNode *pCNode = pCFrm->GetNode();
793 // --> OD 2007-07-25 #126039#
794 // assure, that the cursor is consistent.
795 KillPams();
796 ClearMark();
797 // <--
798 SwPaM *pCrsr = GetCrsr();
799
800 pCrsr->GetPoint()->nNode = *pCNode;
801 pCrsr->GetPoint()->nContent.Assign( pCNode, 0 );
802
803 SwRect& rChrRect = (SwRect&)GetCharRect();
804 rChrRect = pFly->Prt();
805 rChrRect.Pos() += pFly->Frm().Pos();
806 GetCrsrDocPos() = rChrRect.Pos();
807 }
808 return pFly->GetFmt();
809 }
810 }
811 return 0;
812 }
813
814
815 /*************************************************************************
816 |*
817 |* SwFEShell::SelectionToTop(), SelectionToBottom()
818 |*
819 |* Beschreibung Selektion nach oben/unten (Z-Order)
820 |*
821 |* Ersterstellung MA 05. Nov. 92
822 |* Letzte Aenderung MA 03. Jun. 96
823 |*
824 *************************************************************************/
825
826 void lcl_NotifyNeighbours( const SdrMarkList *pLst )
827 {
828 //Die Regeln fuer die Ausweichmanoever haben sich veraendert.
829 //1. Die Umgebung des Fly und aller innenliegenden muss benachrichtigt
830 // werden.
831 //2. Der Inhalt des Rahmen selbst muss benachrichtigt werden.
832 //3. Rahmen die dem Rahmen ausweichen bzw. wichen muessen benachrichtigt werden.
833 //4. Auch Zeichenobjekte koennen Rahmen verdraengen
834
835 for( USHORT j = 0; j < pLst->GetMarkCount(); ++j )
836 {
837 SwPageFrm *pPage;
838 BOOL bCheckNeighbours = FALSE;
839 sal_Int16 aHori = text::HoriOrientation::NONE;
840 SwRect aRect;
841 SdrObject *pO = pLst->GetMark( 0 )->GetMarkedSdrObj();
842 if ( pO->ISA(SwVirtFlyDrawObj) )
843 {
844 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pO)->GetFlyFrm();
845
846 const SwFmtHoriOrient &rHori = pFly->GetFmt()->GetHoriOrient();
847 aHori = rHori.GetHoriOrient();
848 if( text::HoriOrientation::NONE != aHori && text::HoriOrientation::CENTER != aHori &&
849 pFly->IsFlyAtCntFrm() )
850 {
851 bCheckNeighbours = TRUE;
852 pFly->InvalidatePos();
853 pFly->Frm().Pos().Y() += 1;
854 }
855
856 pPage = pFly->FindPageFrm();
857 aRect = pFly->Frm();
858 }
859 else
860 {
861 SwFrm* pAnch = ( (SwDrawContact*)GetUserCall(pO) )->GetAnchorFrm( pO );
862 if( !pAnch )
863 continue;
864 pPage = pAnch->FindPageFrm();
865 // --> OD 2006-08-15 #i68520# - naming changed
866 aRect = GetBoundRectOfAnchoredObj( pO );
867 // <--
868 }
869
870 sal_uInt32 nCount = pPage->GetSortedObjs() ? pPage->GetSortedObjs()->Count() : 0;
871 for ( sal_uInt32 i = 0; i < nCount; ++i )
872 {
873 SwAnchoredObject* pAnchoredObj = (*pPage->GetSortedObjs())[i];
874 if ( !pAnchoredObj->ISA(SwFlyFrm) )
875 continue;
876
877 SwFlyFrm* pAct = static_cast<SwFlyFrm*>(pAnchoredObj);
878 SwRect aTmpCalcPnt( pAct->Prt() );
879 aTmpCalcPnt += pAct->Frm().Pos();
880 if ( aRect.IsOver( aTmpCalcPnt ) )
881 {
882 SwCntntFrm *pCnt = pAct->ContainsCntnt();
883 while ( pCnt )
884 {
885 aTmpCalcPnt = pCnt->Prt();
886 aTmpCalcPnt += pCnt->Frm().Pos();
887 if ( aRect.IsOver( aTmpCalcPnt ) )
888 ((SwFrm*)pCnt)->Prepare( PREP_FLY_ATTR_CHG );
889 pCnt = pCnt->GetNextCntntFrm();
890 }
891 }
892 if ( bCheckNeighbours && pAct->IsFlyAtCntFrm() )
893 {
894 const SwFmtHoriOrient &rH = pAct->GetFmt()->GetHoriOrient();
895 if ( rH.GetHoriOrient() == aHori &&
896 pAct->Frm().Top() <= aRect.Bottom() &&
897 pAct->Frm().Bottom() >= aRect.Top() )
898 {
899 pAct->InvalidatePos();
900 pAct->Frm().Pos().Y() += 1;
901 }
902 }
903 }
904 }
905 }
906
907 void SwFEShell::SelectionToTop( BOOL bTop )
908 {
909 ASSERT( Imp()->HasDrawView(), "SelectionToTop without DrawView?" );
910 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
911 ASSERT( rMrkList.GetMarkCount(), "Kein Object Selektiert." );
912
913 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
914 if ( pFly && pFly->IsFlyInCntFrm() )
915 return;
916
917 StartAllAction();
918 if ( bTop )
919 Imp()->GetDrawView()->PutMarkedToTop();
920 else
921 Imp()->GetDrawView()->MovMarkedToTop();
922 ::lcl_NotifyNeighbours( &rMrkList );
923 GetDoc()->SetModified();
924 EndAllAction();
925 }
926
927 void SwFEShell::SelectionToBottom( BOOL bBottom )
928 {
929 ASSERT( Imp()->HasDrawView(), "SelectionToBottom without DrawView?" );
930 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
931 ASSERT( rMrkList.GetMarkCount(), "Kein Object Selektiert." );
932
933 SwFlyFrm *pFly = ::GetFlyFromMarked( &rMrkList, this );
934 if ( pFly && pFly->IsFlyInCntFrm() )
935 return;
936
937 StartAllAction();
938 if ( bBottom )
939 Imp()->GetDrawView()->PutMarkedToBtm();
940 else
941 Imp()->GetDrawView()->MovMarkedToBtm();
942 ::lcl_NotifyNeighbours( &rMrkList );
943 GetDoc()->SetModified();
944 EndAllAction();
945 }
946
947 /*************************************************************************
948 |*
949 |* SwFEShell::GetLayerId()
950 |*
951 |* Beschreibung Objekt ueber/unter dem Dokument?
952 |* 2 Controls, 1 Heaven, 0 Hell, -1 Uneindeutig
953 |* Ersterstellung MA 20. Dec. 94
954 |* Letzte Aenderung MA 20. Dec. 94
955 |*
956 *************************************************************************/
957
958 short SwFEShell::GetLayerId() const
959 {
960 short nRet = SHRT_MAX;
961 if ( Imp()->HasDrawView() )
962 {
963 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
964 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
965 {
966 const SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
967 if ( nRet == SHRT_MAX )
968 nRet = pObj->GetLayer();
969 else if ( nRet != pObj->GetLayer() )
970 {
971 nRet = -1;
972 break;
973 }
974 }
975 }
976 if ( nRet == SHRT_MAX )
977 nRet = -1;
978 return nRet;
979 }
980
981 /*************************************************************************
982 |*
983 |* SwFEShell::SelectionToHeaven(), SelectionToHell()
984 |*
985 |* Beschreibung Objekt ueber/unter dem Dokument
986 |* Ersterstellung MA 20. Dec. 94
987 |* Letzte Aenderung AMA 04. Jun. 98
988 |*
989 *************************************************************************/
990 // OD 25.06.2003 #108784#
991 // Note: only visible objects can be marked. Thus, objects with invisible
992 // layer IDs have not to be considered.
993 // If <SwFEShell> exists, layout exists!!
994 void SwFEShell::ChangeOpaque( SdrLayerID nLayerId )
995 {
996 if ( Imp()->HasDrawView() )
997 {
998 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
999 const IDocumentDrawModelAccess* pIDDMA = getIDocumentDrawModelAccess();
1000 // OD 25.06.2003 #108784# - correct type of <nControls>
1001 for ( USHORT i = 0; i < rMrkList.GetMarkCount(); ++i )
1002 {
1003 SdrObject* pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
1004 // OD 21.08.2003 #i18447# - no change of layer for controls
1005 // or group objects containing controls.
1006 const bool bControlObj = ::CheckControlLayer( pObj );
1007 //if ( pObj->GetLayer() != nLayerId && pObj->GetLayer() != nControls )
1008 if ( !bControlObj && pObj->GetLayer() != nLayerId )
1009 {
1010 pObj->SetLayer( nLayerId );
1011 InvalidateWindows( SwRect( pObj->GetCurrentBoundRect() ) );
1012 if ( pObj->ISA(SwVirtFlyDrawObj) )
1013 {
1014 SwFmt *pFmt = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->GetFmt();
1015 SvxOpaqueItem aOpa( pFmt->GetOpaque() );
1016 aOpa.SetValue( nLayerId == pIDDMA->GetHellId() );
1017 pFmt->SetFmtAttr( aOpa );
1018 }
1019 }
1020 }
1021 GetDoc()->SetModified();
1022 }
1023 }
1024
1025 void SwFEShell::SelectionToHeaven()
1026 {
1027 ChangeOpaque( getIDocumentDrawModelAccess()->GetHeavenId() );
1028 }
1029
1030 void SwFEShell::SelectionToHell()
1031 {
1032 ChangeOpaque( getIDocumentDrawModelAccess()->GetHellId() );
1033 }
1034
1035 /*************************************************************************
1036 |*
1037 |* SwFEShell::IsObjSelected(), IsFrmSelected()
1038 |*
1039 |* Ersterstellung MA 16. Nov. 92
1040 |* Letzte Aenderung MA 17. Jan. 95
1041 |*
1042 *************************************************************************/
1043
1044 USHORT SwFEShell::IsObjSelected() const
1045 {
1046 if ( IsFrmSelected() || !Imp()->HasDrawView() )
1047 return 0;
1048 else
1049 return USHORT( Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() );
1050 }
1051
1052 BOOL SwFEShell::IsFrmSelected() const
1053 {
1054 if ( !Imp()->HasDrawView() )
1055 return FALSE;
1056 else
1057 return 0 != ::GetFlyFromMarked( &Imp()->GetDrawView()->GetMarkedObjectList(),
1058 (ViewShell*)this );
1059 }
1060
1061 sal_Bool SwFEShell::IsObjSelected( const SdrObject& rObj ) const
1062 {
1063 if ( IsFrmSelected() || !Imp()->HasDrawView() )
1064 return sal_False;
1065 else
1066 return Imp()->GetDrawView()
1067 ->IsObjMarked( const_cast< SdrObject * >( &rObj ) );
1068 }
1069
1070 /*************************************************************************
1071 |*
1072 |* SwFEShell::EndTextEdit()
1073 |*
1074 |* Ersterstellung MA 19. Feb. 96
1075 |* Letzte Aenderung MA 19. Feb. 96
1076 |*
1077 *************************************************************************/
1078
1079 void SwFEShell::EndTextEdit()
1080 {
1081 //Beenden des TextEditModus. Wenn gewuenscht (default wenn das Objekt
1082 //keinen Text mehr enthaelt und keine Attribute traegt) wird das
1083 //Objekt gel�scht. Alle anderen markierten Objekte bleiben erhalten.
1084
1085 ASSERT( Imp()->HasDrawView() && Imp()->GetDrawView()->IsTextEdit(),
1086 "EndTextEdit an no Object" );
1087
1088 StartAllAction();
1089 SdrView *pView = Imp()->GetDrawView();
1090 SdrObject *pObj = pView->GetTextEditObject();
1091 SdrObjUserCall* pUserCall;
1092 if( 0 != ( pUserCall = GetUserCall(pObj) ) )
1093 {
1094 SdrObject *pTmp = ((SwContact*)pUserCall)->GetMaster();
1095 if( !pTmp )
1096 pTmp = pObj;
1097 pUserCall->Changed( *pTmp, SDRUSERCALL_RESIZE, pTmp->GetLastBoundRect() );
1098 }
1099 if ( !pObj->GetUpGroup() )
1100 {
1101 if ( SDRENDTEXTEDIT_SHOULDBEDELETED == pView->SdrEndTextEdit(sal_True) )
1102 {
1103 if ( pView->GetMarkedObjectList().GetMarkCount() > 1 )
1104 {
1105 {
1106 SdrMarkList aSave( pView->GetMarkedObjectList() );
1107 aSave.DeleteMark( aSave.FindObject( pObj ) );
1108 if ( aSave.GetMarkCount() )
1109 {
1110 pView->UnmarkAll();
1111 pView->MarkObj( pObj, Imp()->GetPageView() );
1112 }
1113 DelSelectedObj();
1114 if ( aSave.GetMarkCount() )
1115 {
1116 for ( USHORT i = 0; i < aSave.GetMarkCount(); ++i )
1117 pView->MarkObj( aSave.GetMark( i )->GetMarkedSdrObj(),
1118 Imp()->GetPageView() );
1119 }
1120 }
1121 }
1122 else
1123 DelSelectedObj();
1124 }
1125 }
1126 else
1127 pView->SdrEndTextEdit();
1128 EndAllAction();
1129 }
1130
1131 /*************************************************************************
1132 |*
1133 |* SwFEShell::IsInsideSelectedObj()
1134 |*
1135 |* Ersterstellung MA 16. Nov. 92
1136 |* Letzte Aenderung MA 08. Nov. 96
1137 |*
1138 *************************************************************************/
1139
1140 int SwFEShell::IsInsideSelectedObj( const Point &rPt )
1141 {
1142 if( Imp()->HasDrawView() )
1143 {
1144 SwDrawView *pDView = Imp()->GetDrawView();
1145
1146 if( pDView->GetMarkedObjectList().GetMarkCount() &&
1147 pDView->IsMarkedObjHit( rPt ) )
1148 {
1149 return SDRHIT_OBJECT;
1150 }
1151 }
1152 return SDRHIT_NONE;
1153 }
1154
1155 /*************************************************************************
1156 |*
1157 |* SwFEShell::IsObjSelectable()
1158 |*
1159 |* Ersterstellung MA 16. Nov. 92
1160 |* Letzte Aenderung MA 02. Feb. 95
1161 |*
1162 *************************************************************************/
1163
1164 bool SwFEShell::IsObjSelectable( const Point& rPt )
1165 {
1166 SET_CURR_SHELL(this);
1167 #ifdef OLD
1168 if( Imp()->HasDrawView() )
1169 return Imp()->GetDrawView()->PickSomething( rPt, MINMOVE );
1170 return 0;
1171 #else
1172 SwDrawView *pDView = Imp()->GetDrawView();
1173 bool bRet = false;
1174 if( pDView )
1175 {
1176 SdrObject* pObj;
1177 SdrPageView* pPV;
1178 USHORT nOld = pDView->GetHitTolerancePixel();
1179 pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
1180
1181 bRet = 0 != pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMARKABLE );
1182 pDView->SetHitTolerancePixel( nOld );
1183 }
1184 return bRet;
1185 #endif
1186 }
1187
1188 // #107513#
1189 // Test if there is a draw object at that position and if it should be selected.
1190 // The 'should' is aimed at Writer text fly frames which may be in front of
1191 // the draw object.
1192 sal_Bool SwFEShell::ShouldObjectBeSelected(const Point& rPt)
1193 {
1194 SET_CURR_SHELL(this);
1195 SwDrawView *pDrawView = Imp()->GetDrawView();
1196 sal_Bool bRet(sal_False);
1197
1198 if(pDrawView)
1199 {
1200 SdrObject* pObj;
1201 SdrPageView* pPV;
1202 sal_uInt16 nOld(pDrawView->GetHitTolerancePixel());
1203
1204 pDrawView->SetHitTolerancePixel(pDrawView->GetMarkHdlSizePixel()/2);
1205 bRet = pDrawView->PickObj(rPt, pDrawView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMARKABLE);
1206 pDrawView->SetHitTolerancePixel(nOld);
1207
1208 if(bRet && pObj)
1209 {
1210 const IDocumentDrawModelAccess* pIDDMA = getIDocumentDrawModelAccess();
1211 if( pObj->GetLayer() == pIDDMA->GetHellId() )
1212 {
1213 const SwFrm *pPageFrm = GetLayout()->Lower();
1214 while( pPageFrm && !pPageFrm->Frm().IsInside( rPt ) )
1215 {
1216 if ( rPt.Y() < pPageFrm->Frm().Top() )
1217 pPageFrm = 0;
1218 else
1219 pPageFrm = pPageFrm->GetNext();
1220 }
1221 if( pPageFrm )
1222 {
1223 SwRect aTmp( pPageFrm->Prt() );
1224 aTmp += pPageFrm->Frm().Pos();
1225 if( aTmp.IsInside( rPt ) )
1226 return sal_False;
1227 }
1228 }
1229
1230 const SdrPage* pPage = pIDDMA->GetDrawModel()->GetPage(0);
1231 // --> FME 2005-04-18 #i20965# Use GetOrdNum() instead of GetOrdNumDirect()
1232 // because ordnums might be wrong
1233 for(sal_uInt32 a(pObj->GetOrdNum() + 1); bRet && a < pPage->GetObjCount(); a++)
1234 {
1235 // <--
1236 SdrObject *pCandidate = pPage->GetObj(a);
1237
1238 if(pCandidate->ISA(SwVirtFlyDrawObj) && ((SwVirtFlyDrawObj*)pCandidate)->GetCurrentBoundRect().IsInside(rPt))
1239 {
1240 bRet = sal_False;
1241 }
1242 }
1243 }
1244 }
1245
1246 return bRet;
1247 }
1248
1249 /*************************************************************************
1250 |*
1251 |* SwFEShell::GotoObj()
1252 |*
1253 |* Beschreibung Wenn ein Obj selektiert ist, gehen wir von dessen
1254 |* TopLeft aus, andernfalls von der Mitte des aktuellen CharRects.
1255 |* Ersterstellung MA 01. Jun. 95
1256 |* Letzte Aenderung MA 30. Apr. 96
1257 |*
1258 *************************************************************************/
1259 /* -----------------23.09.98 10:29-------------------
1260 * Beinhaltet das Objekt ein Control oder Gruppen,
1261 * die nur aus Controls bestehen
1262 * --------------------------------------------------*/
1263 BOOL lcl_IsControlGroup( const SdrObject *pObj )
1264 {
1265 BOOL bRet = FALSE;
1266 if(pObj->ISA(SdrUnoObj))
1267 bRet = TRUE;
1268 else if( pObj->ISA( SdrObjGroup ) )
1269 {
1270 bRet = TRUE;
1271 const SdrObjList *pLst = ((SdrObjGroup*)pObj)->GetSubList();
1272 for ( USHORT i = 0; i < pLst->GetObjCount(); ++i )
1273 if( !::lcl_IsControlGroup( pLst->GetObj( i ) ) )
1274 return FALSE;
1275 }
1276 return bRet;
1277 }
1278
1279 BOOL SwFEShell::GotoObj( BOOL bNext, USHORT /*GOTOOBJ_...*/ eType )
1280 {
1281 if( !Imp()->HasDrawView() )
1282 return FALSE;
1283 else
1284 {
1285 const SdrObject *pBest = 0,
1286 *pTop = 0;
1287
1288 const long nTmp = bNext ? LONG_MAX : 0;
1289 Point aBestPos( nTmp, nTmp );
1290 Point aTopPos( nTmp, nTmp );
1291 Point aCurPos;
1292 Point aPos;
1293 BOOL bRet = FALSE;
1294 BOOL bNoDraw = 0 == (GOTOOBJ_DRAW_ANY & eType);
1295 BOOL bNoFly = 0 == (GOTOOBJ_FLY_ANY & eType);
1296
1297 if( !bNoFly && bNoDraw )
1298 {
1299 SwFlyFrm *pFly = GetCurrFrm( FALSE )->FindFlyFrm();
1300 if( pFly )
1301 pBest = pFly->GetVirtDrawObj();
1302 }
1303 const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
1304 SdrPageView* pPV = Imp()->GetDrawView()->GetSdrPageView();
1305
1306 if( !pBest || rMrkList.GetMarkCount() == 1 )
1307 {
1308 // Ausgangspunkt bestimmen.
1309 SdrObjList* pList = NULL;
1310 if ( rMrkList.GetMarkCount() )
1311 {
1312 const SdrObject* pStartObj = rMrkList.GetMark(0)->GetMarkedSdrObj();
1313 if( pStartObj->ISA(SwVirtFlyDrawObj) )
1314 aPos = ((SwVirtFlyDrawObj*)pStartObj)->GetFlyFrm()->Frm().Pos();
1315 else
1316 aPos = pStartObj->GetSnapRect().TopLeft();
1317
1318 // If an object inside a group is selected, we want to
1319 // iterate over the group members.
1320 if ( ! pStartObj->GetUserCall() )
1321 pList = pStartObj->GetObjList();
1322 }
1323 else
1324 {
1325 // If no object is selected, we check if we just entered a group.
1326 // In this case we want to iterate over the group members.
1327 aPos = GetCharRect().Center();
1328 const SdrObject* pStartObj = pPV ? pPV->GetAktGroup() : 0;
1329 if ( pStartObj && pStartObj->ISA( SdrObjGroup ) )
1330 pList = pStartObj->GetSubList();
1331 }
1332
1333 if ( ! pList )
1334 {
1335 // Here we are if
1336 // A No object has been selected and no group has been entered or
1337 // B An object has been selected and it is not inside a group
1338 pList = getIDocumentDrawModelAccess()->GetDrawModel()->GetPage( 0 );
1339 }
1340
1341
1342 ASSERT( pList, "No object list to iterate" )
1343
1344 const ULONG nObjs = pList->GetObjCount();
1345 for( ULONG nObj = 0; nObj < nObjs; ++nObj )
1346 {
1347 SdrObject* pObj = pList->GetObj( nObj );
1348 BOOL bFlyFrm = pObj->ISA(SwVirtFlyDrawObj);
1349 if( ( bNoFly && bFlyFrm ) ||
1350 ( bNoDraw && !bFlyFrm ) ||
1351 ( eType == GOTOOBJ_DRAW_SIMPLE && lcl_IsControlGroup( pObj ) ) ||
1352 ( eType == GOTOOBJ_DRAW_CONTROL && !lcl_IsControlGroup( pObj ) ) ||
1353 ( pPV && ! pPV->GetView().IsObjMarkable( pObj, pPV ) ) )
1354 continue;
1355 if( bFlyFrm )
1356 {
1357 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pObj;
1358 SwFlyFrm *pFly = pO->GetFlyFrm();
1359 if( GOTOOBJ_FLY_ANY != ( GOTOOBJ_FLY_ANY & eType ) )
1360 {
1361 switch ( eType )
1362 {
1363 case GOTOOBJ_FLY_FRM:
1364 if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
1365 continue;
1366 break;
1367 case GOTOOBJ_FLY_GRF:
1368 if ( pFly->Lower() &&
1369 (pFly->Lower()->IsLayoutFrm() ||
1370 !((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode()))
1371 continue;
1372 break;
1373 case GOTOOBJ_FLY_OLE:
1374 if ( pFly->Lower() &&
1375 (pFly->Lower()->IsLayoutFrm() ||
1376 !((SwCntntFrm*)pFly->Lower())->GetNode()->GetOLENode()))
1377 continue;
1378 break;
1379 }
1380 }
1381 aCurPos = pFly->Frm().Pos();
1382 }
1383 else
1384 aCurPos = pObj->GetCurrentBoundRect().TopLeft();
1385
1386 // Sonderfall wenn ein anderes Obj auf selber Y steht.
1387 if( aCurPos != aPos && // nur wenn ich es nicht selber bin
1388 aCurPos.Y() == aPos.Y() && // ist die Y Position gleich
1389 (bNext? (aCurPos.X() > aPos.X()) : // liegt neben mir
1390 (aCurPos.X() < aPos.X())) ) // " reverse
1391 {
1392 aBestPos = Point( nTmp, nTmp );
1393 for( ULONG i = 0; i < nObjs; ++i )
1394 {
1395 SdrObject *pTmpObj = pList->GetObj( i );
1396 bFlyFrm = pTmpObj->ISA(SwVirtFlyDrawObj);
1397 if( ( bNoFly && bFlyFrm ) || ( bNoDraw && !bFlyFrm ) )
1398 continue;
1399 if( bFlyFrm )
1400 {
1401 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pTmpObj;
1402 aCurPos = pO->GetFlyFrm()->Frm().Pos();
1403 }
1404 else
1405 aCurPos = pTmpObj->GetCurrentBoundRect().TopLeft();
1406
1407 if( aCurPos != aPos && aCurPos.Y() == aPos.Y() &&
1408 (bNext? (aCurPos.X() > aPos.X()) : // liegt neben mir
1409 (aCurPos.X() < aPos.X())) && // " reverse
1410 (bNext? (aCurPos.X() < aBestPos.X()) : // besser als Beste
1411 (aCurPos.X() > aBestPos.X())) ) // " reverse
1412 {
1413 aBestPos = aCurPos;
1414 pBest = pTmpObj;
1415 }
1416 }
1417 break;
1418 }
1419
1420 if( (bNext? (aPos.Y() < aCurPos.Y()) : // nur unter mir
1421 (aPos.Y() > aCurPos.Y())) && // " reverse
1422 (bNext? (aBestPos.Y() > aCurPos.Y()) : // naeher drunter
1423 (aBestPos.Y() < aCurPos.Y())) || // " reverse
1424 (aBestPos.Y() == aCurPos.Y() &&
1425 (bNext? (aBestPos.X() > aCurPos.X()) : // weiter links
1426 (aBestPos.X() < aCurPos.X())))) // " reverse
1427
1428 {
1429 aBestPos = aCurPos;
1430 pBest = pObj;
1431 }
1432
1433 if( (bNext? (aTopPos.Y() > aCurPos.Y()) : // hoeher als Beste
1434 (aTopPos.Y() < aCurPos.Y())) || // " reverse
1435 (aTopPos.Y() == aCurPos.Y() &&
1436 (bNext? (aTopPos.X() > aCurPos.X()) : // weiter links
1437 (aTopPos.X() < aCurPos.X())))) // " reverse
1438 {
1439 aTopPos = aCurPos;
1440 pTop = pObj;
1441 }
1442 }
1443 // leider nichts gefunden
1444 if( (bNext? (aBestPos.X() == LONG_MAX) : (aBestPos.X() == 0)) )
1445 pBest = pTop;
1446 }
1447
1448 if( pBest )
1449 {
1450 BOOL bFlyFrm = pBest->ISA(SwVirtFlyDrawObj);
1451 if( bFlyFrm )
1452 {
1453 SwVirtFlyDrawObj *pO = (SwVirtFlyDrawObj*)pBest;
1454 const SwRect& rFrm = pO->GetFlyFrm()->Frm();
1455 SelectObj( rFrm.Pos(), 0, (SdrObject*)pBest );
1456 if( !ActionPend() )
1457 MakeVisible( rFrm );
1458 }
1459 else
1460 {
1461 SelectObj( Point(), 0, (SdrObject*)pBest );
1462 if( !ActionPend() )
1463 MakeVisible( pBest->GetCurrentBoundRect() );
1464 }
1465 CallChgLnk();
1466 bRet = TRUE;
1467 }
1468 return bRet;
1469 }
1470 }
1471
1472 /*************************************************************************
1473 |*
1474 |* SwFEShell::BeginCreate()
1475 |*
1476 |* Ersterstellung MA 20. Dec. 94
1477 |* Letzte Aenderung MA 21. Mar. 95
1478 |*
1479 *************************************************************************/
1480
1481 BOOL SwFEShell::BeginCreate( UINT16 /*SdrObjKind ?*/ eSdrObjectKind, const Point &rPos )
1482 {
1483 BOOL bRet = FALSE;
1484
1485 if ( !Imp()->HasDrawView() )
1486 Imp()->MakeDrawView();
1487
1488 if ( GetPageNumber( rPos ) )
1489 {
1490 Imp()->GetDrawView()->SetCurrentObj( eSdrObjectKind );
1491 if ( eSdrObjectKind == OBJ_CAPTION )
1492 bRet = Imp()->GetDrawView()->BegCreateCaptionObj(
1493 rPos, Size( lMinBorder - MINFLY, lMinBorder - MINFLY ),
1494 GetOut() );
1495 else
1496 bRet = Imp()->GetDrawView()->BegCreateObj( rPos, GetOut() );
1497 }
1498 if ( bRet )
1499 {
1500 ::FrameNotify( this, FLY_DRAG_START );
1501 }
1502 return bRet;
1503 }
1504
1505 BOOL SwFEShell::BeginCreate( UINT16 /*SdrObjKind ?*/ eSdrObjectKind, UINT32 eObjInventor,
1506 const Point &rPos )
1507 {
1508 BOOL bRet = FALSE;
1509
1510 if ( !Imp()->HasDrawView() )
1511 Imp()->MakeDrawView();
1512
1513 if ( GetPageNumber( rPos ) )
1514 {
1515 Imp()->GetDrawView()->SetCurrentObj( eSdrObjectKind, eObjInventor );
1516 bRet = Imp()->GetDrawView()->BegCreateObj( rPos, GetOut() );
1517 }
1518 if ( bRet )
1519 ::FrameNotify( this, FLY_DRAG_START );
1520 return bRet;
1521 }
1522
1523 /*************************************************************************
1524 |*
1525 |* SwFEShell::MoveCreate()
1526 |*
1527 |* Ersterstellung MA 20. Dec. 94
1528 |* Letzte Aenderung MA 24. Jan. 95
1529 |*
1530 *************************************************************************/
1531
1532 void SwFEShell::MoveCreate( const Point &rPos )
1533 {
1534 ASSERT( Imp()->HasDrawView(), "MoveCreate without DrawView?" );
1535 if ( GetPageNumber( rPos ) )
1536 {
1537 ScrollTo( rPos );
1538 Imp()->GetDrawView()->MovCreateObj( rPos );
1539 ::FrameNotify( this, FLY_DRAG );
1540 }
1541 }
1542
1543 /*************************************************************************
1544 |*
1545 |* SwFEShell::EndCreate(), ImpEndCreate()
1546 |*
1547 |* Ersterstellung MA 20. Dec. 94
1548 |* Letzte Aenderung MA 14. Oct. 96
1549 |*
1550 *************************************************************************/
1551
1552 BOOL SwFEShell::EndCreate( UINT16 eSdrCreateCmd )
1553 {
1554 // JP 18.08.95: Damit das Undo-Object aus der DrawEngine nicht bei uns
1555 // gespeichert wird, (wir erzeugen ein eigenes Undo-Object!) hier kurz
1556 // das Undo abschalten
1557 ASSERT( Imp()->HasDrawView(), "EndCreate without DrawView?" );
1558 if( !Imp()->GetDrawView()->IsGroupEntered() )
1559 GetDoc()->SetNoDrawUndoObj( TRUE );
1560 BOOL bCreate = Imp()->GetDrawView()->EndCreateObj(
1561 SdrCreateCmd( eSdrCreateCmd ) );
1562 GetDoc()->SetNoDrawUndoObj( FALSE );
1563
1564 if ( !bCreate )
1565 {
1566 ::FrameNotify( this, FLY_DRAG_END );
1567 return FALSE;
1568 }
1569
1570 if ( (SdrCreateCmd)eSdrCreateCmd == SDRCREATE_NEXTPOINT )
1571 {
1572 ::FrameNotify( this, FLY_DRAG );
1573 return TRUE;
1574 }
1575 return ImpEndCreate();
1576 }
1577
1578
1579 BOOL SwFEShell::ImpEndCreate()
1580 {
1581 ASSERT( Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1,
1582 "Neues Object nicht selektiert." );
1583
1584 SdrObject& rSdrObj = *Imp()->GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
1585
1586 if( rSdrObj.GetSnapRect().IsEmpty() )
1587 {
1588 //JP 10.04.95: das Object vergessen wir lieber, fuerht nur
1589 // zu Problemen
1590 Imp()->GetDrawView()->DeleteMarked();
1591 Imp()->GetDrawView()->UnmarkAll();
1592 ::FrameNotify( this, FLY_DRAG_END );
1593 return FALSE;
1594 }
1595
1596 if( rSdrObj.GetUpGroup() )
1597 {
1598 Point aTmpPos( rSdrObj.GetSnapRect().TopLeft() );
1599 Point aNewAnchor( rSdrObj.GetUpGroup()->GetAnchorPos() );
1600 // OD 2004-04-05 #i26791# - direct object positioning for group members
1601 rSdrObj.NbcSetRelativePos( aTmpPos - aNewAnchor );
1602 rSdrObj.NbcSetAnchorPos( aNewAnchor );
1603 ::FrameNotify( this, FLY_DRAG );
1604 return TRUE;
1605 }
1606
1607 LockPaint();
1608 StartAllAction();
1609
1610 Imp()->GetDrawView()->UnmarkAll();
1611
1612 const Rectangle &rBound = rSdrObj.GetSnapRect();
1613 Point aPt( rBound.TopRight() );
1614
1615 //Fremde Identifier sollen in den Default laufen.
1616 //Ueberschneidungen sind moeglich!!
1617 UINT16 nIdent = SdrInventor == rSdrObj.GetObjInventor()
1618 ? rSdrObj.GetObjIdentifier()
1619 : 0xFFFF;
1620
1621 //Default fuer Controls ist Zeichengebunden, Absatzgebunden sonst.
1622 SwFmtAnchor aAnch;
1623 const SwFrm *pAnch = 0;
1624 BOOL bCharBound = FALSE;
1625 if( rSdrObj.ISA( SdrUnoObj ) )
1626 {
1627 SwPosition aPos( GetDoc()->GetNodes() );
1628 SwCrsrMoveState aState( MV_SETONLYTEXT );
1629 Point aPoint( aPt.X(), aPt.Y() + rBound.GetHeight()/2 );
1630 getIDocumentLayoutAccess()->GetRootFrm()->GetCrsrOfst( &aPos, aPoint, &aState );
1631
1632 //JP 22.01.99: Zeichenbindung ist im ReadnOnly-Inhalt nicht erlaubt
1633 if( !aPos.nNode.GetNode().IsProtect() )
1634 {
1635 pAnch = aPos.nNode.GetNode().GetCntntNode()->GetFrm( &aPoint, &aPos );
1636 SwRect aTmp;
1637 pAnch->GetCharRect( aTmp, aPos );
1638
1639 //Der Crsr darf nicht zu weit entfernt sein.
1640 bCharBound = TRUE;
1641 Rectangle aRect( aTmp.SVRect() );
1642 aRect.Left() -= MM50*2;
1643 aRect.Top() -= MM50*2;
1644 aRect.Right() += MM50*2;
1645 aRect.Bottom()+= MM50*2;
1646
1647 if( !aRect.IsOver( rBound ) && !::GetHtmlMode( GetDoc()->GetDocShell() ))
1648 bCharBound = FALSE;
1649
1650 //Bindung in Kopf-/Fusszeilen ist ebenfalls nicht erlaubt.
1651 if( bCharBound )
1652 bCharBound = !GetDoc()->IsInHeaderFooter( aPos.nNode );
1653
1654 if( bCharBound )
1655 {
1656 aAnch.SetType( FLY_IN_CNTNT );
1657 aAnch.SetAnchor( &aPos );
1658 }
1659 }
1660 }
1661
1662 if( !bCharBound )
1663 {
1664 // OD 16.05.2003 #108784# - allow native drawing objects in header/footer.
1665 // Thus, set <bBodyOnly> to <false> for these objects using value
1666 // of <nIdent> - value <0xFFFF> indicates control objects, which aren't
1667 // allowed in header/footer.
1668 //bool bBodyOnly = OBJ_NONE != nIdent;
1669 bool bBodyOnly = 0xFFFF == nIdent;
1670 bool bAtPage = false;
1671 const SwFrm* pPage = 0;
1672 SwCrsrMoveState aState( MV_SETONLYTEXT );
1673 Point aPoint( aPt );
1674 SwPosition aPos( GetDoc()->GetNodes() );
1675 GetLayout()->GetCrsrOfst( &aPos, aPoint, &aState );
1676
1677 //JP 22.01.99: nicht in ReadnOnly-Inhalt setzen
1678 if( aPos.nNode.GetNode().IsProtect() )
1679 // dann darf er nur seitengebunden sein. Oder sollte man
1680 // die naechste nicht READONLY Position suchen?
1681 bAtPage = true;
1682
1683 pAnch = aPos.nNode.GetNode().GetCntntNode()->GetFrm( &aPoint, 0, FALSE );
1684
1685 if( !bAtPage )
1686 {
1687 const SwFlyFrm *pTmp = pAnch->FindFlyFrm();
1688 if( pTmp )
1689 {
1690 const SwFrm* pTmpFrm = pAnch;
1691 SwRect aBound( rBound );
1692 while( pTmp )
1693 {
1694 if( pTmp->Frm().IsInside( aBound ) )
1695 {
1696 if( !bBodyOnly || !pTmp->FindFooterOrHeader() )
1697 pPage = pTmpFrm;
1698 break;
1699 }
1700 pTmp = pTmp->GetAnchorFrm()
1701 ? pTmp->GetAnchorFrm()->FindFlyFrm()
1702 : 0;
1703 pTmpFrm = pTmp;
1704 }
1705 }
1706
1707 if( !pPage )
1708 pPage = pAnch->FindPageFrm();
1709
1710 // immer ueber FindAnchor gehen, damit der Frame immer an den
1711 // davorgehen gebunden wird. Beim GetCrsOfst kann man auch zum
1712 // nachfolgenden kommen. DAS IST FALSCH
1713 pAnch = ::FindAnchor( pPage, aPt, bBodyOnly );
1714 aPos.nNode = *((SwCntntFrm*)pAnch)->GetNode();
1715
1716 //JP 22.01.99: nicht in ReadnOnly-Inhalt setzen
1717 if( aPos.nNode.GetNode().IsProtect() )
1718 // dann darf er nur seitengebunden sein. Oder sollte man
1719 // die naechste nicht READONLY Position suchen?
1720 bAtPage = true;
1721 else
1722 {
1723 aAnch.SetType( FLY_AT_CNTNT );
1724 aAnch.SetAnchor( &aPos );
1725 }
1726 }
1727
1728 if( bAtPage )
1729 {
1730 pPage = pAnch->FindPageFrm();
1731
1732 aAnch.SetType( FLY_PAGE );
1733 aAnch.SetPageNum( pPage->GetPhyPageNum() );
1734 pAnch = pPage; // die Page wird jetzt zum Anker
1735 }
1736 }
1737
1738 SfxItemSet aSet( GetDoc()->GetAttrPool(), RES_FRM_SIZE, RES_FRM_SIZE,
1739 RES_SURROUND, RES_ANCHOR, 0 );
1740 aSet.Put( aAnch );
1741
1742 // OD 2004-03-30 #i26791# - determine relative object position
1743 SwTwips nXOffset;
1744 SwTwips nYOffset = rBound.Top() - pAnch->Frm().Top();
1745 {
1746 if( pAnch->IsVertical() )
1747 {
1748 nXOffset = nYOffset;
1749 nYOffset = pAnch->Frm().Left()+pAnch->Frm().Width()-rBound.Right();
1750 }
1751 else if( pAnch->IsRightToLeft() )
1752 nXOffset = pAnch->Frm().Left()+pAnch->Frm().Width()-rBound.Right();
1753 else
1754 nXOffset = rBound.Left() - pAnch->Frm().Left();
1755 if( pAnch->IsTxtFrm() && ((SwTxtFrm*)pAnch)->IsFollow() )
1756 {
1757 SwTxtFrm* pTmp = (SwTxtFrm*)pAnch;
1758 do {
1759 pTmp = pTmp->FindMaster();
1760 ASSERT( pTmp, "Where's my Master?" );
1761 // OD 2004-03-30 #i26791# - correction: add frame area height
1762 // of master frames.
1763 nYOffset += pTmp->IsVertical() ?
1764 pTmp->Frm().Width() : pTmp->Frm().Height();
1765 } while ( pTmp->IsFollow() );
1766 }
1767 }
1768
1769 if( OBJ_NONE == nIdent )
1770 {
1771 //Bei OBJ_NONE wird ein Fly eingefuegt.
1772 const long nWidth = rBound.Right() - rBound.Left();
1773 const long nHeight= rBound.Bottom() - rBound.Top();
1774 aSet.Put( SwFmtFrmSize( ATT_MIN_SIZE, Max( nWidth, long(MINFLY) ),
1775 Max( nHeight, long(MINFLY) )));
1776
1777 SwFmtHoriOrient aHori( nXOffset, text::HoriOrientation::NONE, text::RelOrientation::FRAME );
1778 SwFmtVertOrient aVert( nYOffset, text::VertOrientation::NONE, text::RelOrientation::FRAME );
1779 aSet.Put( SwFmtSurround( SURROUND_PARALLEL ) );
1780 aSet.Put( aHori );
1781 aSet.Put( aVert );
1782
1783 //Schnell noch das Rechteck merken
1784 const SwRect aFlyRect( rBound );
1785
1786 //Erzeugtes Object wegwerfen, so kann der Fly am elegentesten
1787 //ueber vorhandene SS erzeugt werden.
1788 GetDoc()->SetNoDrawUndoObj( TRUE ); // siehe oben
1789 // --> OD 2005-08-08 #i52858# - method name changed
1790 SdrPage *pPg = getIDocumentDrawModelAccess()->GetOrCreateDrawModel()->GetPage( 0 );
1791 // <--
1792 if( !pPg )
1793 {
1794 SdrModel* pTmpSdrModel = getIDocumentDrawModelAccess()->GetDrawModel();
1795 pPg = pTmpSdrModel->AllocPage( FALSE );
1796 pTmpSdrModel->InsertPage( pPg );
1797 }
1798 pPg->RecalcObjOrdNums();
1799 SdrObject* pRemovedObject = pPg->RemoveObject( rSdrObj.GetOrdNumDirect() );
1800 SdrObject::Free( pRemovedObject );
1801 GetDoc()->SetNoDrawUndoObj( FALSE );
1802
1803 SwFlyFrm* pFlyFrm;
1804 if( NewFlyFrm( aSet, TRUE ) &&
1805 ::GetHtmlMode( GetDoc()->GetDocShell() ) &&
1806 0 != ( pFlyFrm = FindFlyFrm() ))
1807 {
1808 SfxItemSet aHtmlSet( GetDoc()->GetAttrPool(), RES_VERT_ORIENT, RES_HORI_ORIENT );
1809 //Horizontale Ausrichtung:
1810 const BOOL bLeftFrm = aFlyRect.Left() <
1811 pAnch->Frm().Left() + pAnch->Prt().Left(),
1812 bLeftPrt = aFlyRect.Left() + aFlyRect.Width() <
1813 pAnch->Frm().Left() + pAnch->Prt().Width()/2;
1814 if( bLeftFrm || bLeftPrt )
1815 {
1816 aHori.SetHoriOrient( text::HoriOrientation::LEFT );
1817 aHori.SetRelationOrient( bLeftFrm ? text::RelOrientation::FRAME : text::RelOrientation::PRINT_AREA );
1818 }
1819 else
1820 {
1821 const BOOL bRightFrm = aFlyRect.Left() >
1822 pAnch->Frm().Left() + pAnch->Prt().Width();
1823 aHori.SetHoriOrient( text::HoriOrientation::RIGHT );
1824 aHori.SetRelationOrient( bRightFrm ? text::RelOrientation::FRAME : text::RelOrientation::PRINT_AREA );
1825 }
1826 aHtmlSet.Put( aHori );
1827 aVert.SetVertOrient( text::VertOrientation::TOP );
1828 aVert.SetRelationOrient( text::RelOrientation::PRINT_AREA );
1829 aHtmlSet.Put( aVert );
1830
1831 GetDoc()->SetAttr( aHtmlSet, *pFlyFrm->GetFmt() );
1832 }
1833 }
1834 else
1835 {
1836 Point aRelNullPt;
1837 if( OBJ_CAPTION == nIdent )
1838 aRelNullPt = ((SdrCaptionObj&)rSdrObj).GetTailPos();
1839 else
1840 aRelNullPt = rBound.TopLeft();
1841
1842 aSet.Put( aAnch );
1843 aSet.Put( SwFmtSurround( SURROUND_THROUGHT ) );
1844 // OD 2004-03-30 #i26791# - set horizontal position
1845 SwFmtHoriOrient aHori( nXOffset, text::HoriOrientation::NONE, text::RelOrientation::FRAME );
1846 aSet.Put( aHori );
1847 // OD 2004-03-30 #i26791# - set vertical position
1848 if( pAnch->IsTxtFrm() && ((SwTxtFrm*)pAnch)->IsFollow() )
1849 {
1850 SwTxtFrm* pTmp = (SwTxtFrm*)pAnch;
1851 do {
1852 pTmp = pTmp->FindMaster();
1853 ASSERT( pTmp, "Where's my Master?" );
1854 nYOffset += pTmp->IsVertical() ?
1855 pTmp->Prt().Width() : pTmp->Prt().Height();
1856 } while ( pTmp->IsFollow() );
1857 }
1858 SwFmtVertOrient aVert( nYOffset, text::VertOrientation::NONE, text::RelOrientation::FRAME );
1859 aSet.Put( aVert );
1860 SwDrawFrmFmt* pFmt = (SwDrawFrmFmt*)getIDocumentLayoutAccess()->MakeLayoutFmt( RND_DRAW_OBJECT, &aSet );
1861 // --> OD 2004-10-25 #i36010# - set layout direction of the position
1862 pFmt->SetPositionLayoutDir(
1863 text::PositionLayoutDir::PositionInLayoutDirOfAnchor );
1864 // <--
1865 // --> OD 2005-03-11 #i44344#, #i44681# - positioning attributes already set
1866 pFmt->PosAttrSet();
1867 // <--
1868
1869 SwDrawContact *pContact = new SwDrawContact( pFmt, &rSdrObj );
1870 // --> OD 2004-11-22 #i35635#
1871 pContact->MoveObjToVisibleLayer( &rSdrObj );
1872 // <--
1873 if( bCharBound )
1874 {
1875 ASSERT( aAnch.GetAnchorId() == FLY_IN_CNTNT, "wrong AnchorType" );
1876 SwTxtNode *pNd = aAnch.GetCntntAnchor()->nNode.GetNode().GetTxtNode();
1877 pNd->InsertItem( SwFmtFlyCnt( pFmt ),
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