1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_svx.hxx" 24 25 #include <editeng/eeitem.hxx> 26 #include "svx/svdstr.hrc" 27 #include "svx/svdglob.hxx" 28 #include <svx/svdpagv.hxx> 29 #include <svx/svdmrkv.hxx> 30 #include <svx/svdedxv.hxx> 31 #include <svx/svdobj.hxx> 32 #include <svx/svdopath.hxx> 33 #include <svx/svdograf.hxx> 34 #include <svx/svdomedia.hxx> 35 #include <svx/svdetc.hxx> 36 37 #ifdef DBG_UTIL 38 #include <svdibrow.hxx> 39 #endif 40 41 #include "svx/svdoutl.hxx" 42 #include "svx/svdview.hxx" 43 #include "editeng/editview.hxx" 44 #include "editeng/flditem.hxx" 45 #include "svx/obj3d.hxx" 46 #include "svx/svddrgmt.hxx" 47 #include "svx/svdoutl.hxx" 48 #include "svx/svdotable.hxx" 49 #include <tools/tenccvt.hxx> 50 #include <svx/sdr/overlay/overlaypolypolygon.hxx> 51 #include <svx/sdr/overlay/overlaymanager.hxx> 52 #include <svx/sdrpaintwindow.hxx> 53 #include <svx/sdrpagewindow.hxx> 54 #include <svx/sdrhittesthelper.hxx> 55 #include <svx/sdr/contact/viewcontact.hxx> 56 #include <drawinglayer/processor2d/contourextractor2d.hxx> 57 58 //////////////////////////////////////////////////////////////////////////////////////////////////// 59 60 SdrViewEvent::SdrViewEvent() 61 : pHdl(NULL), 62 pObj(NULL), 63 pRootObj(NULL), 64 pPV(NULL), 65 pURLField(NULL), 66 eHit(SDRHIT_NONE), 67 eEvent(SDREVENT_NONE), 68 eHdlKind(HDL_MOVE), 69 eEndCreateCmd(SDRCREATE_NEXTPOINT), 70 nMouseClicks(0), 71 nMouseMode(0), 72 nMouseCode(0), 73 nHlplIdx(0), 74 nGlueId(0), 75 bMouseDown(sal_False), 76 bMouseUp(sal_False), 77 bDoubleHdlSize(sal_False), 78 bIsAction(sal_False), 79 bIsTextEdit(sal_False), 80 bTextEditHit(sal_False), 81 bAddMark(sal_False), 82 bUnmark(sal_False), 83 bPrevNextMark(sal_False), 84 bMarkPrev(sal_False), 85 bInsPointNewObj(sal_False), 86 bDragWithCopy(sal_False), 87 bCaptureMouse(sal_False), 88 bReleaseMouse(sal_False) 89 { 90 } 91 92 SdrViewEvent::~SdrViewEvent() 93 { 94 } 95 96 //////////////////////////////////////////////////////////////////////////////////////////////////// 97 // helper class for all D&D overlays 98 99 void SdrDropMarkerOverlay::ImplCreateOverlays( 100 const SdrView& rView, 101 const basegfx::B2DPolyPolygon& rLinePolyPolygon) 102 { 103 for(sal_uInt32 a(0L); a < rView.PaintWindowCount(); a++) 104 { 105 SdrPaintWindow* pCandidate = rView.GetPaintWindow(a); 106 ::sdr::overlay::OverlayManager* pTargetOverlay = pCandidate->GetOverlayManager(); 107 108 if(pTargetOverlay) 109 { 110 ::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled( 111 rLinePolyPolygon); 112 113 pTargetOverlay->add(*pNew); 114 maObjects.append(*pNew); 115 } 116 } 117 } 118 119 SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const SdrObject& rObject) 120 { 121 ImplCreateOverlays( 122 rView, 123 rObject.TakeXorPoly()); 124 } 125 126 SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Rectangle& rRectangle) 127 { 128 basegfx::B2DPolygon aB2DPolygon; 129 130 aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Top())); 131 aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Top())); 132 aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Bottom())); 133 aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Bottom())); 134 aB2DPolygon.setClosed(true); 135 136 ImplCreateOverlays( 137 rView, 138 basegfx::B2DPolyPolygon(aB2DPolygon)); 139 } 140 141 SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Point& rStart, const Point& rEnd) 142 { 143 basegfx::B2DPolygon aB2DPolygon; 144 145 aB2DPolygon.append(basegfx::B2DPoint(rStart.X(), rStart.Y())); 146 aB2DPolygon.append(basegfx::B2DPoint(rEnd.X(), rEnd.Y())); 147 aB2DPolygon.setClosed(true); 148 149 ImplCreateOverlays( 150 rView, 151 basegfx::B2DPolyPolygon(aB2DPolygon)); 152 } 153 154 SdrDropMarkerOverlay::~SdrDropMarkerOverlay() 155 { 156 // The OverlayObjects are cleared using the destructor of OverlayObjectList. 157 // That destructor calls clear() at the list which removes all objects from the 158 // OverlayManager and deletes them. 159 } 160 161 //////////////////////////////////////////////////////////////////////////////////////////////////// 162 //////////////////////////////////////////////////////////////////////////////////////////////////// 163 // 164 // @@ @@ @@ @@@@@ @@ @@ 165 // @@ @@ @@ @@ @@ @@ 166 // @@ @@ @@ @@ @@ @ @@ 167 // @@@@@ @@ @@@@ @@@@@@@ 168 // @@@ @@ @@ @@@@@@@ 169 // @@@ @@ @@ @@@ @@@ 170 // @ @@ @@@@@ @@ @@ 171 // 172 //////////////////////////////////////////////////////////////////////////////////////////////////// 173 //////////////////////////////////////////////////////////////////////////////////////////////////// 174 175 TYPEINIT1(SdrView,SdrCreateView); 176 177 SdrView::SdrView(SdrModel* pModel1, OutputDevice* pOut) 178 : SdrCreateView(pModel1,pOut), 179 bNoExtendedMouseDispatcher(sal_False), 180 bNoExtendedKeyDispatcher(sal_False), 181 bNoExtendedCommandDispatcher(sal_False), 182 mbMasterPagePaintCaching(sal_False) 183 { 184 bTextEditOnObjectsWithoutTextIfTextTool=sal_False; 185 186 maAccessibilityOptions.AddListener(this); 187 188 onAccessibilityOptionsChanged(); 189 } 190 191 SdrView::~SdrView() 192 { 193 maAccessibilityOptions.RemoveListener(this); 194 } 195 196 sal_Bool SdrView::KeyInput(const KeyEvent& rKEvt, Window* pWin) 197 { 198 SetActualWin(pWin); 199 sal_Bool bRet=SdrCreateView::KeyInput(rKEvt,pWin); 200 if (!bRet && !IsExtendedKeyInputDispatcherEnabled()) { 201 bRet=sal_True; 202 switch (rKEvt.GetKeyCode().GetFullFunction()) { 203 case KEYFUNC_CUT : Cut(); break; 204 case KEYFUNC_COPY : Yank(); break; 205 case KEYFUNC_PASTE : Paste(pWin); break; 206 case KEYFUNC_DELETE: DeleteMarked(); break; 207 case KEYFUNC_UNDO: pMod->Undo(); break; 208 case KEYFUNC_REDO: pMod->Redo(); break; 209 case KEYFUNC_REPEAT: pMod->Repeat(*this); break; 210 default: { 211 switch (rKEvt.GetKeyCode().GetFullCode()) { 212 case KEY_ESCAPE: { 213 if (IsTextEdit()) SdrEndTextEdit(); 214 if (IsAction()) BrkAction(); 215 if (pWin!=NULL) pWin->ReleaseMouse(); 216 } break; 217 case KEY_DELETE: DeleteMarked(); break; 218 case KEY_CUT: case KEY_DELETE+KEY_SHIFT: Cut(); break; 219 case KEY_COPY: case KEY_INSERT+KEY_MOD1: Yank(); break; 220 case KEY_PASTE: case KEY_INSERT+KEY_SHIFT: Paste(pWin); break; 221 case KEY_UNDO: case KEY_BACKSPACE+KEY_MOD2: pMod->Undo(); break; 222 case KEY_BACKSPACE+KEY_MOD2+KEY_SHIFT: pMod->Redo(); break; 223 case KEY_REPEAT: case KEY_BACKSPACE+KEY_MOD2+KEY_MOD1: pMod->Repeat(*this); break; 224 case KEY_MOD1+KEY_A: MarkAll(); break; 225 default: bRet=sal_False; 226 } // switch 227 } 228 } // switch 229 if (bRet && pWin!=NULL) { 230 pWin->SetPointer(GetPreferedPointer( 231 pWin->PixelToLogic(pWin->ScreenToOutputPixel( pWin->GetPointerPosPixel() ) ), 232 pWin, 233 rKEvt.GetKeyCode().GetModifier())); 234 } 235 } 236 return bRet; 237 } 238 239 sal_Bool SdrView::MouseButtonDown(const MouseEvent& rMEvt, Window* pWin) 240 { 241 SetActualWin(pWin); 242 if (rMEvt.IsLeft()) aDragStat.SetMouseDown(sal_True); 243 sal_Bool bRet=SdrCreateView::MouseButtonDown(rMEvt,pWin); 244 if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) { 245 SdrViewEvent aVEvt; 246 PickAnything(rMEvt,SDRMOUSEBUTTONDOWN,aVEvt); 247 bRet=DoMouseEvent(aVEvt); 248 } 249 return bRet; 250 } 251 252 sal_Bool SdrView::MouseButtonUp(const MouseEvent& rMEvt, Window* pWin) 253 { 254 SetActualWin(pWin); 255 if (rMEvt.IsLeft()) aDragStat.SetMouseDown(sal_False); 256 sal_Bool bAction=IsAction(); 257 sal_Bool bRet=!bAction && SdrCreateView::MouseButtonUp(rMEvt,pWin); 258 if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) { 259 SdrViewEvent aVEvt; 260 PickAnything(rMEvt,SDRMOUSEBUTTONUP,aVEvt); 261 bRet=DoMouseEvent(aVEvt); 262 } 263 return bRet; 264 } 265 266 sal_Bool SdrView::MouseMove(const MouseEvent& rMEvt, Window* pWin) 267 { 268 SetActualWin(pWin); 269 aDragStat.SetMouseDown(rMEvt.IsLeft()); 270 sal_Bool bRet=SdrCreateView::MouseMove(rMEvt,pWin); 271 if (!IsExtendedMouseEventDispatcherEnabled() && !IsTextEditInSelectionMode()) { 272 SdrViewEvent aVEvt; 273 PickAnything(rMEvt,SDRMOUSEMOVE,aVEvt); 274 if (DoMouseEvent(aVEvt)) bRet=sal_True; 275 } 276 277 // #87792# Removed code which did let the mouse snap on object 278 // points 279 280 return bRet; 281 } 282 283 sal_Bool SdrView::Command(const CommandEvent& rCEvt, Window* pWin) 284 { 285 SetActualWin(pWin); 286 sal_Bool bRet=SdrCreateView::Command(rCEvt,pWin); 287 return bRet; 288 } 289 290 /* new interface src537 */ 291 sal_Bool SdrView::GetAttributes(SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr) const 292 { 293 return SdrCreateView::GetAttributes(rTargetSet, bOnlyHardAttr); 294 } 295 296 SfxStyleSheet* SdrView::GetStyleSheet() const 297 { 298 //sal_Bool bOk=sal_False; 299 return SdrCreateView::GetStyleSheet(); //bOk); 300 } 301 302 SdrHitKind SdrView::PickAnything(const MouseEvent& rMEvt, sal_uInt16 nEventKind, SdrViewEvent& rVEvt) const 303 { 304 rVEvt.bMouseDown=nEventKind==SDRMOUSEBUTTONDOWN; 305 rVEvt.bMouseUp=nEventKind==SDRMOUSEBUTTONUP; 306 rVEvt.nMouseClicks=rMEvt.GetClicks(); 307 rVEvt.nMouseMode=rMEvt.GetMode(); 308 rVEvt.nMouseCode=rMEvt.GetButtons() | rMEvt.GetModifier(); 309 const OutputDevice* pOut=pActualOutDev; 310 if (pOut==NULL) 311 { 312 pOut = GetFirstOutputDevice(); 313 //pOut=GetWin(0); 314 } 315 Point aPnt(rMEvt.GetPosPixel()); 316 if (pOut!=NULL) aPnt=pOut->PixelToLogic(aPnt); 317 rVEvt.aLogicPos=aPnt; 318 return PickAnything(aPnt,rVEvt); 319 } 320 321 // Mit der Maus draggen (Move) 322 // Beispiel beim erzeugen eines Rechtecks. MouseDown muss ohne 323 // ModKey erfolgen, weil sonst i.d.R. Markieren forciert wird (s.u.) 324 // Drueckt man dann beim MouseMove gleichzeitig Shift, Ctrl, und Alt, 325 // so erzeugt man ein zentrisches Quadrat ohne Fang. 326 // Die Doppelbelegung von Ortho und Shift stellt i.d.R. kein Problem dar, 327 // da sich beides meisst gegenseitig ausschliesst. Einzig Shear (das beim 328 // Verzerren, nicht dass beim Drehen) beruecksichtigt beides gleichzeitig. 329 // Dass muss der Anwender erstmal noch umschiffen (z.B. mit einer Hilfslinie). 330 #define MODKEY_NoSnap bCtrl /* Fang temporaer aus */ 331 #define MODKEY_Ortho bShift /* na eben ortho */ 332 #define MODKEY_Center bAlt /* Zentrisch erzeugen/resizen */ 333 #define MODKEY_AngleSnap bShift 334 #define MODKEY_CopyDrag bCtrl /* Draggen mit kopieren */ 335 336 // irgendwo hinklicken (MouseDown) 337 #define MODKEY_PolyPoly bAlt /* Neues Poly bei InsPt und bei Create */ 338 #define MODKEY_MultiMark bShift /* MarkObj ohne vorher UnmarkAll */ 339 #define MODKEY_Unmark bAlt /* Unmark durch Rahmenaufziehen */ 340 #define MODKEY_ForceMark bCtrl /* Rahmenaufziehen erzwingen, auch wenn Obj an MausPos */ 341 #define MODKEY_DeepMark bAlt /* MarkNextObj */ 342 #define MODKEY_DeepBackw bShift /* MarkNextObj rueckwaerts */ 343 344 SdrHitKind SdrView::PickAnything(const Point& rLogicPos, SdrViewEvent& rVEvt) const 345 { 346 const OutputDevice* pOut=pActualOutDev; 347 if (pOut==NULL) 348 { 349 pOut = GetFirstOutputDevice(); 350 //pOut=GetWin(0); 351 } 352 353 // #i73628# Use a non-changeable copy of he logic pos 354 const Point aLocalLogicPosition(rLogicPos); 355 356 sal_Bool bEditMode=IsEditMode(); 357 sal_Bool bPointMode=bEditMode && HasMarkablePoints(); 358 sal_Bool bGluePointMode=IsGluePointEditMode(); 359 sal_Bool bInsPolyPt=bPointMode && IsInsObjPointMode() && IsInsObjPointPossible(); 360 sal_Bool bInsGluePt=bGluePointMode && IsInsGluePointMode() && IsInsGluePointPossible(); 361 sal_Bool bIsTextEdit=IsTextEdit(); 362 sal_Bool bTextEditHit=IsTextEditHit(aLocalLogicPosition,0/*nHitTolLog*/); 363 sal_Bool bTextEditSel=IsTextEditInSelectionMode(); 364 sal_Bool bShift=(rVEvt.nMouseCode & KEY_SHIFT) !=0; 365 sal_Bool bCtrl=(rVEvt.nMouseCode & KEY_MOD1) !=0; 366 sal_Bool bAlt=(rVEvt.nMouseCode & KEY_MOD2) !=0; 367 SdrHitKind eHit=SDRHIT_NONE; 368 SdrHdl* pHdl=pOut!=NULL && !bTextEditSel ? PickHandle(aLocalLogicPosition) : NULL; 369 SdrPageView* pPV=NULL; 370 SdrObject* pObj=NULL; 371 SdrObject* pHitObj=NULL; 372 sal_uInt16 nHitPassNum=0; 373 sal_uInt16 nHlplIdx=0; 374 sal_uInt16 nGlueId=0; 375 sal_Bool bUnmarkedObjHit=sal_False; 376 if (bTextEditHit || bTextEditSel) 377 { 378 eHit=SDRHIT_TEXTEDIT; 379 bTextEditHit=sal_True; 380 } 381 else if (pHdl!=NULL) 382 { 383 eHit=SDRHIT_HANDLE; // Handle getroffen hat hoechste Prioritaet 384 } 385 else if (bEditMode && IsHlplVisible() && IsHlplFront() && pOut!=NULL && PickHelpLine(aLocalLogicPosition,nHitTolLog,*pOut,nHlplIdx,pPV)) 386 { 387 eHit=SDRHIT_HELPLINE; // Hilfslinie im Vordergrund getroffen zum verschieben 388 } 389 else if (bGluePointMode && PickGluePoint(aLocalLogicPosition,pObj,nGlueId,pPV)) 390 { 391 eHit=SDRHIT_GLUEPOINT; // nichtmarkierter Klebepunkt getroffen 392 } 393 else if (PickObj(aLocalLogicPosition,nHitTolLog,pHitObj,pPV,SDRSEARCH_DEEP|SDRSEARCH_MARKED,&pObj,NULL,&nHitPassNum)) 394 { 395 eHit=SDRHIT_MARKEDOBJECT; 396 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( pObj ); 397 if( pTableObj ) 398 { 399 sal_Int32 nX = 0, nY = 0; 400 switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY, 0 ) ) 401 { 402 case sdr::table::SDRTABLEHIT_CELL: 403 eHit = SDRHIT_CELL; 404 break; 405 case sdr::table::SDRTABLEHIT_CELLTEXTAREA: 406 eHit = SDRHIT_TEXTEDITOBJ; 407 break; 408 default: 409 break; 410 } 411 } 412 } 413 else if (PickObj(aLocalLogicPosition,nHitTolLog,pHitObj,pPV,SDRSEARCH_DEEP|/*SDRSEARCH_TESTMARKABLE|*/SDRSEARCH_ALSOONMASTER|SDRSEARCH_WHOLEPAGE,&pObj,NULL,&nHitPassNum)) 414 { 415 // MasterPages und WholePage fuer Macro und URL 416 eHit=SDRHIT_UNMARKEDOBJECT; 417 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( pObj ); 418 if( pTableObj ) 419 { 420 sal_Int32 nX = 0, nY = 0; 421 switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY, 0 ) ) 422 { 423 case sdr::table::SDRTABLEHIT_CELL: 424 eHit = SDRHIT_CELL; 425 break; 426 case sdr::table::SDRTABLEHIT_CELLTEXTAREA: 427 eHit = SDRHIT_TEXTEDITOBJ; 428 break; 429 default: 430 break; 431 } 432 } 433 bUnmarkedObjHit=sal_True; 434 } 435 else if (bEditMode && IsHlplVisible() && !IsHlplFront() && pOut!=NULL && PickHelpLine(aLocalLogicPosition,nHitTolLog,*pOut,nHlplIdx,pPV)) 436 { 437 eHit=SDRHIT_HELPLINE; // Hilfslinie im Vordergrund getroffen zum verschieben 438 } 439 if (IsMacroMode() && eHit==SDRHIT_UNMARKEDOBJECT) 440 { 441 bool bRoot=pObj->HasMacro(); 442 sal_Bool bDeep=pObj!=pHitObj && pHitObj->HasMacro(); 443 sal_Bool bMid=sal_False; // Gruppierte Gruppe mit Macro getroffen? 444 SdrObject* pMidObj=NULL; 445 if (pObj!=pHitObj) 446 { 447 SdrObject* pObjTmp=NULL; 448 pObjTmp=pHitObj->GetUpGroup(); 449 if (pObjTmp==pObj) pObjTmp=NULL; 450 while (pObjTmp!=NULL) 451 { 452 if (pObjTmp->HasMacro()) 453 { 454 bMid=sal_True; 455 pMidObj=pObjTmp; 456 } 457 pObjTmp=pObjTmp->GetUpGroup(); 458 if (pObjTmp==pObj) pObjTmp=NULL; 459 } 460 } 461 462 if (bDeep || bMid || bRoot) 463 { 464 SdrObjMacroHitRec aHitRec; 465 aHitRec.aPos=aLocalLogicPosition; 466 aHitRec.aDownPos=aLocalLogicPosition; 467 aHitRec.nTol=nHitTolLog; 468 aHitRec.pVisiLayer=&pPV->GetVisibleLayers(); 469 aHitRec.pPageView=pPV; 470 if (bDeep) bDeep=pHitObj->IsMacroHit(aHitRec); 471 if (bMid ) bMid =pMidObj->IsMacroHit(aHitRec); 472 if (bRoot) bRoot=pObj->IsMacroHit(aHitRec); 473 if (bRoot || bMid || bDeep) 474 { 475 // Prio: 1.Root, 2.Mid, 3.Deep 476 rVEvt.pRootObj=pObj; 477 if (!bRoot) pObj=pMidObj; 478 if (!bRoot && !bMid) pObj=pHitObj; 479 eHit=SDRHIT_MACRO; 480 } 481 } 482 } 483 // auf URL-Field checken 484 if (IsMacroMode() && eHit==SDRHIT_UNMARKEDOBJECT) 485 { 486 SdrTextObj* pTextObj=PTR_CAST(SdrTextObj,pHitObj); 487 if (pTextObj!=NULL && pTextObj->HasText()) 488 { 489 bool bTEHit(pPV && 490 SdrObjectPrimitiveHit(*pTextObj, aLocalLogicPosition, 0, *pPV, &pPV->GetVisibleLayers(), true)); 491 492 if (bTEHit) 493 { 494 Rectangle aTextRect; 495 Rectangle aAnchor; 496 SdrOutliner* pOutliner = &pTextObj->ImpGetDrawOutliner(); 497 if( pTextObj->GetModel() ) 498 pOutliner = &pTextObj->GetModel()->GetHitTestOutliner(); 499 500 pTextObj->TakeTextRect( *pOutliner, aTextRect, sal_False, &aAnchor, sal_False ); 501 502 // #i73628# Use a text-relative position for hit test in hit test outliner 503 Point aTemporaryTextRelativePosition(aLocalLogicPosition - aTextRect.TopLeft()); 504 505 // FitToSize berueksichtigen 506 SdrFitToSizeType eFit=pTextObj->GetFitToSize(); 507 sal_Bool bFitToSize=(eFit==SDRTEXTFIT_PROPORTIONAL || eFit==SDRTEXTFIT_ALLLINES); 508 if (bFitToSize) { 509 Fraction aX(aTextRect.GetWidth()-1,aAnchor.GetWidth()-1); 510 Fraction aY(aTextRect.GetHeight()-1,aAnchor.GetHeight()-1); 511 ResizePoint(aTemporaryTextRelativePosition,Point(),aX,aY); 512 } 513 // Drehung berueksichtigen 514 const GeoStat& rGeo=pTextObj->GetGeoStat(); 515 if (rGeo.nDrehWink!=0) RotatePoint(aTemporaryTextRelativePosition,Point(),-rGeo.nSin,rGeo.nCos); // -sin fuer Unrotate 516 // Laufschrift berueksichtigen fehlt noch ... 517 if(pActualOutDev && pActualOutDev->GetOutDevType() == OUTDEV_WINDOW) 518 { 519 OutlinerView aOLV(pOutliner, (Window*)pActualOutDev); 520 const EditView& aEV=aOLV.GetEditView(); 521 const SvxFieldItem* pItem=aEV.GetField(aTemporaryTextRelativePosition); 522 if (pItem!=NULL) { 523 const SvxFieldData* pFld=pItem->GetField(); 524 const SvxURLField* pURL=PTR_CAST(SvxURLField,pFld); 525 if (pURL!=NULL) { 526 eHit=SDRHIT_URLFIELD; 527 rVEvt.pURLField=pURL; 528 } 529 } 530 } 531 } 532 } 533 } 534 535 if (nHitPassNum==SDRSEARCHPASS_DIRECT && 536 (eHit==SDRHIT_MARKEDOBJECT || eHit==SDRHIT_UNMARKEDOBJECT) && 537 (IsTextTool() || (IsEditMode() && IsQuickTextEditMode())) && pHitObj->HasTextEdit()) 538 { 539 // Ringsum die TextEditArea ein Rand zum Selektieren ohne Textedit 540 Rectangle aBoundRect(pHitObj->GetCurrentBoundRect()); 541 542 // #105130# Force to SnapRect when Fontwork 543 if(pHitObj->ISA(SdrTextObj) && ((SdrTextObj*)pHitObj)->IsFontwork()) 544 { 545 aBoundRect = pHitObj->GetSnapRect(); 546 } 547 548 // #105130# Old test for hit on BoundRect is completely wrong 549 // and never worked, doing it new here. 550 sal_Int32 nTolerance(nHitTolLog); 551 sal_Bool bBoundRectHit(sal_False); 552 553 if(pOut) 554 { 555 nTolerance = pOut->PixelToLogic(Size(2, 0)).Width(); 556 } 557 558 if( (aLocalLogicPosition.X() >= aBoundRect.Left() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Left() + nTolerance) 559 || (aLocalLogicPosition.X() >= aBoundRect.Right() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Right() + nTolerance) 560 || (aLocalLogicPosition.Y() >= aBoundRect.Top() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Top() + nTolerance) 561 || (aLocalLogicPosition.Y() >= aBoundRect.Bottom() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Bottom() + nTolerance)) 562 { 563 bBoundRectHit = sal_True; 564 } 565 566 if(!bBoundRectHit) 567 { 568 bool bTEHit(pPV && 569 SdrObjectPrimitiveHit(*pHitObj, aLocalLogicPosition, 0, *pPV, &pPV->GetVisibleLayers(), true)); 570 571 // TextEdit an Objekten im gesperrten Layer 572 if (pPV->GetLockedLayers().IsSet(pHitObj->GetLayer())) 573 { 574 bTEHit=sal_False; 575 } 576 577 if (bTEHit) 578 { 579 rVEvt.pRootObj=pObj; 580 pObj=pHitObj; 581 eHit=SDRHIT_TEXTEDITOBJ; 582 } 583 } 584 } 585 if (nHitPassNum!=SDRSEARCHPASS_DIRECT && eHit==SDRHIT_UNMARKEDOBJECT) { 586 eHit=SDRHIT_NONE; 587 pObj=NULL; 588 pPV=NULL; 589 } 590 sal_Bool bMouseLeft=(rVEvt.nMouseCode&MOUSE_LEFT)!=0; 591 sal_Bool bMouseRight=(rVEvt.nMouseCode&MOUSE_RIGHT)!=0; 592 sal_Bool bMouseDown=rVEvt.bMouseDown; 593 sal_Bool bMouseUp=rVEvt.bMouseUp; 594 SdrEventKind eEvent=SDREVENT_NONE; 595 sal_Bool bIsAction=IsAction(); 596 597 if (bIsAction) 598 { 599 if (bMouseDown) 600 { 601 if (bMouseRight) eEvent=SDREVENT_BCKACTION; 602 } 603 else if (bMouseUp) 604 { 605 if (bMouseLeft) 606 { 607 eEvent=SDREVENT_ENDACTION; 608 if (IsDragObj()) 609 { 610 eEvent=SDREVENT_ENDDRAG; 611 rVEvt.bDragWithCopy=MODKEY_CopyDrag; 612 } 613 else if (IsCreateObj() || IsInsObjPoint()) 614 { 615 eEvent=IsCreateObj() ? SDREVENT_ENDCREATE : SDREVENT_ENDINSOBJPOINT; 616 rVEvt.eEndCreateCmd=SDRCREATE_NEXTPOINT; 617 if (MODKEY_PolyPoly) rVEvt.eEndCreateCmd=SDRCREATE_NEXTOBJECT; 618 if (rVEvt.nMouseClicks>1) rVEvt.eEndCreateCmd=SDRCREATE_FORCEEND; 619 } 620 else if (IsMarking()) 621 { 622 eEvent=SDREVENT_ENDMARK; 623 if (!aDragStat.IsMinMoved()) 624 { 625 eEvent=SDREVENT_BRKMARK; 626 rVEvt.bAddMark=MODKEY_MultiMark; 627 } 628 } 629 } 630 } 631 else 632 { 633 eEvent=SDREVENT_MOVACTION; 634 } 635 } 636 else if (eHit==SDRHIT_TEXTEDIT) 637 { 638 eEvent=SDREVENT_TEXTEDIT; 639 } 640 else if (bMouseDown && bMouseLeft) 641 { 642 if (rVEvt.nMouseClicks==2 && rVEvt.nMouseCode==MOUSE_LEFT && pObj!=NULL && pHitObj!=NULL && pHitObj->HasTextEdit() && eHit==SDRHIT_MARKEDOBJECT) 643 { 644 rVEvt.pRootObj=pObj; 645 pObj=pHitObj; 646 eEvent=SDREVENT_BEGTEXTEDIT; 647 } 648 else if (MODKEY_ForceMark && eHit!=SDRHIT_URLFIELD) 649 { 650 eEvent=SDREVENT_BEGMARK; // AddMark,Unmark */ 651 } 652 else if (eHit==SDRHIT_HELPLINE) 653 { 654 eEvent=SDREVENT_BEGDRAGHELPLINE; // nix weiter 655 } 656 else if (eHit==SDRHIT_GLUEPOINT) 657 { 658 eEvent=SDREVENT_MARKGLUEPOINT; // AddMark+Drag 659 rVEvt.bAddMark=MODKEY_MultiMark || MODKEY_DeepMark; // falls bei Deep nicht getroffen 660 } 661 else if (eHit==SDRHIT_HANDLE) 662 { 663 eEvent=SDREVENT_BEGDRAGOBJ; // Mark+Drag,AddMark+Drag,DeepMark+Drag,Unmark 664 sal_Bool bGlue=pHdl->GetKind()==HDL_GLUE; 665 sal_Bool bPoly=!bGlue && IsPointMarkable(*pHdl); 666 sal_Bool bMarked=bGlue || bPoly && pHdl->IsSelected(); 667 if (bGlue || bPoly) 668 { 669 eEvent=bGlue ? SDREVENT_MARKGLUEPOINT : SDREVENT_MARKPOINT; 670 if (MODKEY_DeepMark) 671 { 672 rVEvt.bAddMark=sal_True; 673 rVEvt.bPrevNextMark=sal_True; 674 rVEvt.bMarkPrev=MODKEY_DeepBackw; 675 } 676 else if (MODKEY_MultiMark) 677 { 678 rVEvt.bAddMark=sal_True; 679 rVEvt.bUnmark=bMarked; // Toggle 680 if (bGlue) 681 { 682 pObj=pHdl->GetObj(); 683 nGlueId=(sal_uInt16)pHdl->GetObjHdlNum(); 684 } 685 } 686 else if (bMarked) 687 { 688 eEvent=SDREVENT_BEGDRAGOBJ; // MarkState nicht aendern, nur Drag 689 } 690 } 691 } 692 else if (bInsPolyPt && (MODKEY_PolyPoly || (!MODKEY_MultiMark && !MODKEY_DeepMark))) 693 { 694 eEvent=SDREVENT_BEGINSOBJPOINT; 695 rVEvt.bInsPointNewObj=MODKEY_PolyPoly; 696 } 697 else if (bInsGluePt && !MODKEY_MultiMark && !MODKEY_DeepMark) 698 { 699 eEvent=SDREVENT_BEGINSGLUEPOINT; 700 } 701 else if (eHit==SDRHIT_TEXTEDITOBJ) 702 { 703 eEvent=SDREVENT_BEGTEXTEDIT; // AddMark+Drag,DeepMark+Drag,Unmark 704 if (MODKEY_MultiMark || MODKEY_DeepMark) 705 { // falls bei Deep nicht getroffen 706 eEvent=SDREVENT_MARKOBJ; 707 } 708 } 709 else if (eHit==SDRHIT_MACRO) 710 { 711 eEvent=SDREVENT_BEGMACROOBJ; // AddMark+Drag 712 if (MODKEY_MultiMark || MODKEY_DeepMark) 713 { // falls bei Deep nicht getroffen 714 eEvent=SDREVENT_MARKOBJ; 715 } 716 } 717 else if (eHit==SDRHIT_URLFIELD) 718 { 719 eEvent=SDREVENT_EXECUTEURL; // AddMark+Drag 720 if (MODKEY_MultiMark || MODKEY_DeepMark) 721 { // falls bei Deep nicht getroffen 722 eEvent=SDREVENT_MARKOBJ; 723 } 724 } 725 else if (eHit==SDRHIT_MARKEDOBJECT) 726 { 727 eEvent=SDREVENT_BEGDRAGOBJ; // DeepMark+Drag,Unmark 728 729 if (MODKEY_MultiMark || MODKEY_DeepMark) 730 { // falls bei Deep nicht getroffen 731 eEvent=SDREVENT_MARKOBJ; 732 } 733 } 734 else if (IsCreateMode()) 735 { 736 eEvent=SDREVENT_BEGCREATEOBJ; // Nix weiter 737 } 738 else if (eHit==SDRHIT_UNMARKEDOBJECT) 739 { 740 eEvent=SDREVENT_MARKOBJ; // AddMark+Drag 741 } 742 else 743 { 744 eEvent=SDREVENT_BEGMARK; 745 } 746 747 if (eEvent==SDREVENT_MARKOBJ) 748 { 749 rVEvt.bAddMark=MODKEY_MultiMark || MODKEY_DeepMark; // falls bei Deep nicht getroffen 750 rVEvt.bPrevNextMark=MODKEY_DeepMark; 751 rVEvt.bMarkPrev=MODKEY_DeepMark && MODKEY_DeepBackw; 752 } 753 if (eEvent==SDREVENT_BEGMARK) 754 { 755 rVEvt.bAddMark=MODKEY_MultiMark; 756 rVEvt.bUnmark=MODKEY_Unmark; 757 } 758 } 759 rVEvt.bIsAction=bIsAction; 760 rVEvt.bIsTextEdit=bIsTextEdit; 761 rVEvt.bTextEditHit=bTextEditHit; 762 rVEvt.aLogicPos=aLocalLogicPosition; 763 rVEvt.pHdl=pHdl; 764 rVEvt.pObj=pObj; 765 if(rVEvt.pRootObj==NULL) 766 rVEvt.pRootObj=pObj; 767 rVEvt.pPV=pPV; 768 rVEvt.nHlplIdx=nHlplIdx; 769 rVEvt.nGlueId=nGlueId; 770 rVEvt.eHit=eHit; 771 rVEvt.eEvent=eEvent; 772 rVEvt.bCaptureMouse=bMouseLeft && bMouseDown && eEvent!=SDREVENT_NONE; 773 rVEvt.bReleaseMouse=bMouseLeft && bMouseUp; 774 #ifdef DGB_UTIL 775 if (rVEvt.pRootObj!=NULL) { 776 if (rVEvt.pRootObj->GetObjList()!=rVEvt.pPV->GetObjList()) { 777 DBG_ERROR("SdrView::PickAnything(): pRootObj->GetObjList()!=pPV->GetObjList() !"); 778 } 779 } 780 #endif 781 return eHit; 782 } 783 784 sal_Bool SdrView::DoMouseEvent(const SdrViewEvent& rVEvt) 785 { 786 sal_Bool bRet=sal_False; 787 SdrHitKind eHit=rVEvt.eHit; 788 Point aLogicPos(rVEvt.aLogicPos); 789 790 sal_Bool bShift=(rVEvt.nMouseCode & KEY_SHIFT) !=0; 791 sal_Bool bCtrl=(rVEvt.nMouseCode & KEY_MOD1) !=0; 792 sal_Bool bAlt=(rVEvt.nMouseCode & KEY_MOD2) !=0; 793 sal_Bool bMouseLeft=(rVEvt.nMouseCode&MOUSE_LEFT)!=0; 794 //sal_Bool bMouseRight=(rVEvt.nMouseCode&MOUSE_RIGHT)!=0; 795 sal_Bool bMouseDown=rVEvt.bMouseDown; 796 sal_Bool bMouseUp=rVEvt.bMouseUp; 797 if (bMouseDown) { 798 if (bMouseLeft) aDragStat.SetMouseDown(sal_True); 799 } else if (bMouseUp) { 800 if (bMouseLeft) aDragStat.SetMouseDown(sal_False); 801 } else { // ansonsten MoueMove 802 aDragStat.SetMouseDown(bMouseLeft); 803 } 804 805 #ifdef MODKEY_NoSnap 806 SetSnapEnabled(!MODKEY_NoSnap); 807 #endif 808 #ifdef MODKEY_Ortho 809 SetOrtho(MODKEY_Ortho!=IsOrthoDesired()); 810 #endif 811 #ifdef MODKEY_BigOrtho 812 SetBigOrtho(MODKEY_BigOrtho); 813 #endif 814 #ifdef MODKEY_AngleSnap 815 SetAngleSnapEnabled(MODKEY_AngleSnap); 816 #endif 817 #ifdef MODKEY_CopyDrag 818 SetDragWithCopy(MODKEY_CopyDrag); 819 #endif 820 #ifdef MODKEY_Center 821 SetCreate1stPointAsCenter(MODKEY_Center); 822 SetResizeAtCenter(MODKEY_Center); 823 SetCrookAtCenter(MODKEY_Center); 824 #endif 825 if (bMouseLeft && bMouseDown && rVEvt.bIsTextEdit && (eHit==SDRHIT_UNMARKEDOBJECT || eHit==SDRHIT_NONE)) { 826 SdrEndTextEdit(); // Danebengeklickt, Ende mit Edit 827 // pHdl ist dann ungueltig. Sollte aber egal sein, wein pHdl==NULL 828 // sein muesste (wg. eHit). 829 } 830 switch (rVEvt.eEvent) { 831 case SDREVENT_NONE: bRet=sal_False; break; 832 case SDREVENT_TEXTEDIT: bRet=sal_False; break; // Events an die OutlinerView werden hier nicht beruecksichtigt 833 case SDREVENT_MOVACTION: MovAction(aLogicPos); bRet=sal_True; break; 834 case SDREVENT_ENDACTION: EndAction(); bRet=sal_True; break; 835 case SDREVENT_BCKACTION: BckAction(); bRet=sal_True; break; 836 case SDREVENT_BRKACTION: BrkAction(); bRet=sal_True; break; 837 case SDREVENT_ENDMARK : EndAction(); bRet=sal_True; break; 838 case SDREVENT_BRKMARK : { 839 BrkAction(); 840 if (!MarkObj(aLogicPos,nHitTolLog,rVEvt.bAddMark)) { 841 // Kein Obj getroffen. Dann werden zuerst 842 // - Markierte Klebepunkte deselektiert 843 // - dann ggf. selektierte Polygonpunkte 844 // - und ansonsten Objekte 845 if (!rVEvt.bAddMark) UnmarkAll(); 846 } 847 bRet=sal_True; 848 } break; 849 case SDREVENT_ENDCREATE: { // ggf. MarkObj 850 SdrCreateCmd eCmd=SDRCREATE_NEXTPOINT; 851 if (MODKEY_PolyPoly) eCmd=SDRCREATE_NEXTOBJECT; 852 if (rVEvt.nMouseClicks>1) eCmd=SDRCREATE_FORCEEND; 853 if (!EndCreateObj(eCmd)) { // Event fuer Create nicht ausgewerten? -> Markieren 854 if (eHit==SDRHIT_UNMARKEDOBJECT || eHit==SDRHIT_TEXTEDIT) { 855 MarkObj(rVEvt.pRootObj,rVEvt.pPV); 856 if (eHit==SDRHIT_TEXTEDIT) 857 { 858 sal_Bool bRet2(pActualOutDev && OUTDEV_WINDOW == pActualOutDev->GetOutDevType() && 859 SdrBeginTextEdit(rVEvt.pObj, rVEvt.pPV, (Window*)pActualOutDev, sal_False, (SdrOutliner*)0L)); 860 861 if(bRet2) 862 { 863 MouseEvent aMEvt(pActualOutDev->LogicToPixel(aLogicPos), 864 1,rVEvt.nMouseMode,rVEvt.nMouseCode,rVEvt.nMouseCode); 865 866 OutlinerView* pOLV=GetTextEditOutlinerView(); 867 if (pOLV!=NULL) { 868 pOLV->MouseButtonDown(aMEvt); // Event an den Outliner, aber ohne Doppelklick 869 pOLV->MouseButtonUp(aMEvt); // Event an den Outliner, aber ohne Doppelklick 870 } 871 } 872 } 873 bRet=sal_True; // Obj markiert und ggf. TextEdit gestartet 874 } else bRet=sal_False; // Create abgebrochen, sonst nix weiter. 875 } else bRet=sal_True; // EndCreate mit sal_True returniert 876 } break; 877 case SDREVENT_ENDDRAG: { 878 bRet=EndDragObj(IsDragWithCopy()); 879 ForceMarkedObjToAnotherPage(); // Undo+Klammerung fehlt noch !!! 880 } break; 881 case SDREVENT_MARKOBJ: { // + ggf. BegDrag 882 if (!rVEvt.bAddMark) UnmarkAllObj(); 883 sal_Bool bUnmark=rVEvt.bUnmark; 884 if (rVEvt.bPrevNextMark) { 885 bRet=MarkNextObj(aLogicPos,nHitTolLog,rVEvt.bMarkPrev); 886 } else { 887 SortMarkedObjects(); 888 sal_uIntPtr nAnz0=GetMarkedObjectCount(); 889 bRet=MarkObj(aLogicPos,nHitTolLog,rVEvt.bAddMark); 890 SortMarkedObjects(); 891 sal_uIntPtr nAnz1=GetMarkedObjectCount(); 892 bUnmark=nAnz1<nAnz0; 893 } 894 if (!bUnmark) { 895 BegDragObj(aLogicPos,NULL,(SdrHdl*)NULL,nMinMovLog); 896 bRet=sal_True; 897 } 898 } break; 899 case SDREVENT_MARKPOINT: { // + ggf. BegDrag 900 if (!rVEvt.bAddMark) UnmarkAllPoints(); 901 if (rVEvt.bPrevNextMark) { 902 bRet=MarkNextPoint(aLogicPos,rVEvt.bMarkPrev); 903 } else { 904 bRet=MarkPoint(*rVEvt.pHdl,rVEvt.bUnmark); 905 } 906 if (!rVEvt.bUnmark && !rVEvt.bPrevNextMark) { 907 BegDragObj(aLogicPos,NULL,rVEvt.pHdl,nMinMovLog); 908 bRet=sal_True; 909 } 910 } break; 911 case SDREVENT_MARKGLUEPOINT: { // + ggf. BegDrag 912 if (!rVEvt.bAddMark) UnmarkAllGluePoints(); 913 if (rVEvt.bPrevNextMark) { 914 bRet=MarkNextGluePoint(aLogicPos,rVEvt.bMarkPrev); 915 } else { 916 bRet=MarkGluePoint(rVEvt.pObj,rVEvt.nGlueId,rVEvt.pPV,rVEvt.bUnmark); 917 } 918 if (!rVEvt.bUnmark && !rVEvt.bPrevNextMark) { 919 SdrHdl* pHdl=GetGluePointHdl(rVEvt.pObj,rVEvt.nGlueId); 920 BegDragObj(aLogicPos,NULL,pHdl,nMinMovLog); 921 bRet=sal_True; 922 } 923 } break; 924 case SDREVENT_BEGMARK: bRet=BegMark(aLogicPos,rVEvt.bAddMark,rVEvt.bUnmark); break; 925 case SDREVENT_BEGINSOBJPOINT: bRet = BegInsObjPoint(aLogicPos, MODKEY_PolyPoly); break; 926 case SDREVENT_ENDINSOBJPOINT: { 927 SdrCreateCmd eCmd=SDRCREATE_NEXTPOINT; 928 if (MODKEY_PolyPoly) eCmd=SDRCREATE_NEXTOBJECT; 929 if (rVEvt.nMouseClicks>1) eCmd=SDRCREATE_FORCEEND; 930 EndInsObjPoint(eCmd); 931 bRet=sal_True; 932 } break; 933 case SDREVENT_BEGINSGLUEPOINT: bRet=BegInsGluePoint(aLogicPos); break; 934 case SDREVENT_BEGDRAGHELPLINE: bRet=BegDragHelpLine(rVEvt.nHlplIdx,rVEvt.pPV); break; 935 case SDREVENT_BEGDRAGOBJ: bRet=BegDragObj(aLogicPos,NULL,rVEvt.pHdl,nMinMovLog); break; 936 case SDREVENT_BEGCREATEOBJ: { 937 if (nAktInvent==SdrInventor && nAktIdent==OBJ_CAPTION) { 938 long nHgt=SdrEngineDefaults::GetFontHeight(); 939 bRet=BegCreateCaptionObj(aLogicPos,Size(5*nHgt,2*nHgt)); 940 } else bRet=BegCreateObj(aLogicPos); 941 } break; 942 case SDREVENT_BEGMACROOBJ: bRet=BegMacroObj(aLogicPos,nHitTolLog,rVEvt.pObj,rVEvt.pPV,(Window*)pActualOutDev); break; 943 case SDREVENT_BEGTEXTEDIT: { 944 if (!IsObjMarked(rVEvt.pObj)) { 945 UnmarkAllObj(); 946 MarkObj(rVEvt.pRootObj,rVEvt.pPV); 947 } 948 949 bRet = pActualOutDev && OUTDEV_WINDOW == pActualOutDev->GetOutDevType()&& 950 SdrBeginTextEdit(rVEvt.pObj, rVEvt.pPV, (Window*)pActualOutDev, sal_False, (SdrOutliner*)0L); 951 952 if(bRet) 953 { 954 MouseEvent aMEvt(pActualOutDev->LogicToPixel(aLogicPos), 955 1,rVEvt.nMouseMode,rVEvt.nMouseCode,rVEvt.nMouseCode); 956 OutlinerView* pOLV=GetTextEditOutlinerView(); 957 if (pOLV!=NULL) pOLV->MouseButtonDown(aMEvt); // Event an den Outliner, aber ohne Doppelklick 958 } 959 } break; 960 default: break; 961 } // switch 962 if (bRet && pActualOutDev!=NULL && pActualOutDev->GetOutDevType()==OUTDEV_WINDOW) { 963 Window* pWin=(Window*)pActualOutDev; 964 // Maus links gedrueckt? 965 sal_Bool bLeftDown=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && rVEvt.bMouseDown; 966 // Maus links losgelassen? 967 sal_Bool bLeftUp=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && rVEvt.bMouseUp; 968 // Maus links gedrueckt oder gehalten? 969 sal_Bool bLeftDown1=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && !rVEvt.bMouseUp; 970 pWin->SetPointer(GetPreferedPointer(rVEvt.aLogicPos,pWin, 971 rVEvt.nMouseCode & (KEY_SHIFT|KEY_MOD1|KEY_MOD2),bLeftDown1)); 972 sal_Bool bAction=IsAction(); 973 if (bLeftDown && bAction) pWin->CaptureMouse(); 974 else if (bLeftUp || (rVEvt.bIsAction && !bAction)) pWin->ReleaseMouse(); 975 } 976 return bRet; 977 } 978 #include <editeng/outlobj.hxx> 979 980 Pointer SdrView::GetPreferedPointer(const Point& rMousePos, const OutputDevice* pOut, sal_uInt16 nModifier, sal_Bool bLeftDown) const 981 { 982 // Actions 983 if (IsCreateObj()) 984 { 985 return pAktCreate->GetCreatePointer(); 986 } 987 if (mpCurrentSdrDragMethod) 988 { 989 if ((IsDraggingPoints() || IsDraggingGluePoints()) && IsMouseHideWhileDraggingPoints()) 990 return Pointer(POINTER_NULL); 991 992 return mpCurrentSdrDragMethod->GetSdrDragPointer(); 993 } 994 if (IsMarkObj() || IsMarkPoints() || IsMarkGluePoints() || IsEncirclement() || IsSetPageOrg()) return Pointer(POINTER_ARROW); 995 if (IsDragHelpLine()) return GetDraggedHelpLinePointer(); 996 if (IsMacroObj()) { 997 SdrObjMacroHitRec aHitRec; 998 aHitRec.aPos=pOut->LogicToPixel(rMousePos); 999 aHitRec.aDownPos=aMacroDownPos; 1000 aHitRec.nTol=nMacroTol; 1001 aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); 1002 aHitRec.pPageView=pMacroPV; 1003 aHitRec.pOut=pMacroWin; 1004 aHitRec.bDown=bMacroDown; 1005 return pMacroObj->GetMacroPointer(aHitRec); 1006 } 1007 //sal_uInt16 nTol=nHitTolLog; 1008 // TextEdit, ObjEdit, Macro 1009 if (IsTextEdit() && (IsTextEditInSelectionMode() || IsTextEditHit(rMousePos,0/*nTol*/))) 1010 { 1011 if(!pOut || IsTextEditInSelectionMode()) 1012 { 1013 if(pTextEditOutliner->IsVertical()) 1014 return Pointer(POINTER_TEXT_VERTICAL); 1015 else 1016 return Pointer(POINTER_TEXT); 1017 } 1018 // hier muss besser der Outliner was liefern: 1019 Point aPos(pOut->LogicToPixel(rMousePos)); 1020 Pointer aPointer(pTextEditOutlinerView->GetPointer(aPos)); 1021 if (aPointer==POINTER_ARROW) 1022 { 1023 if(pTextEditOutliner->IsVertical()) 1024 aPointer = POINTER_TEXT_VERTICAL; 1025 else 1026 aPointer = POINTER_TEXT; 1027 } 1028 return aPointer; 1029 } 1030 1031 SdrViewEvent aVEvt; 1032 aVEvt.nMouseCode=(nModifier&(KEY_SHIFT|KEY_MOD1|KEY_MOD2))|MOUSE_LEFT; // um zu sehen, was bei MouseLeftDown passieren wuerde 1033 aVEvt.bMouseDown=!bLeftDown; // Was waere wenn ... 1034 aVEvt.bMouseUp=bLeftDown; // Was waere wenn ... 1035 if (pOut!=NULL) 1036 ((SdrView*)this)->SetActualWin(pOut); 1037 SdrHitKind eHit=PickAnything(rMousePos,aVEvt); 1038 SdrEventKind eEvent=aVEvt.eEvent; 1039 switch (eEvent) 1040 { 1041 case SDREVENT_BEGCREATEOBJ: 1042 return aAktCreatePointer; 1043 case SDREVENT_MARKOBJ: 1044 case SDREVENT_BEGMARK: 1045 return Pointer(POINTER_ARROW); 1046 case SDREVENT_MARKPOINT: 1047 case SDREVENT_MARKGLUEPOINT: 1048 return Pointer(POINTER_MOVEPOINT); 1049 case SDREVENT_BEGINSOBJPOINT: 1050 case SDREVENT_BEGINSGLUEPOINT: 1051 return Pointer(POINTER_CROSS); 1052 case SDREVENT_EXECUTEURL: 1053 return Pointer(POINTER_REFHAND); 1054 case SDREVENT_BEGMACROOBJ: 1055 { 1056 SdrObjMacroHitRec aHitRec; 1057 aHitRec.aPos=aVEvt.aLogicPos; 1058 aHitRec.aDownPos=aHitRec.aPos; 1059 aHitRec.nTol=nHitTolLog; 1060 aHitRec.pVisiLayer=&aVEvt.pPV->GetVisibleLayers(); 1061 aHitRec.pPageView=aVEvt.pPV; 1062 aHitRec.pOut=(OutputDevice*)pOut; 1063 return aVEvt.pObj->GetMacroPointer(aHitRec); 1064 } 1065 default: break; 1066 } // switch 1067 1068 switch(eHit) 1069 { 1070 case SDRHIT_CELL: 1071 return Pointer(POINTER_ARROW); 1072 case SDRHIT_HELPLINE : 1073 return aVEvt.pPV->GetHelpLines()[aVEvt.nHlplIdx].GetPointer(); 1074 case SDRHIT_GLUEPOINT: 1075 return Pointer(POINTER_MOVEPOINT); 1076 case SDRHIT_TEXTEDIT : 1077 case SDRHIT_TEXTEDITOBJ: 1078 { 1079 SdrTextObj* pText = dynamic_cast< SdrTextObj* >( aVEvt.pObj ); 1080 if(pText && pText->HasText()) 1081 { 1082 OutlinerParaObject* pParaObj = pText->GetOutlinerParaObject(); 1083 if(pParaObj && pParaObj->IsVertical()) 1084 return Pointer(POINTER_TEXT_VERTICAL); 1085 } 1086 return Pointer(POINTER_TEXT); 1087 } 1088 default: break; 1089 } 1090 1091 sal_Bool bMarkHit=eHit==SDRHIT_MARKEDOBJECT; 1092 SdrHdl* pHdl=aVEvt.pHdl; 1093 // Nun die Pointer fuer Dragging checken 1094 if (pHdl!=NULL || bMarkHit) { 1095 SdrHdlKind eHdl= pHdl!=NULL ? pHdl->GetKind() : HDL_MOVE; 1096 sal_Bool bCorner=pHdl!=NULL && pHdl->IsCornerHdl(); 1097 sal_Bool bVertex=pHdl!=NULL && pHdl->IsVertexHdl(); 1098 sal_Bool bMov=eHdl==HDL_MOVE; 1099 if (bMov && (eDragMode==SDRDRAG_MOVE || eDragMode==SDRDRAG_RESIZE || bMarkedHitMovesAlways)) { 1100 if (!IsMoveAllowed()) return Pointer(POINTER_ARROW); // weil Doppelklick oder Drag&Drop moeglich 1101 return Pointer(POINTER_MOVE); 1102 } 1103 switch (eDragMode) { 1104 case SDRDRAG_ROTATE: { 1105 if ((bCorner || bMov) && !IsRotateAllowed(sal_True)) 1106 return Pointer(POINTER_NOTALLOWED); 1107 1108 // Sind 3D-Objekte selektiert? 1109 sal_Bool b3DObjSelected = sal_False; 1110 #ifndef SVX_LIGHT 1111 for (sal_uInt32 a=0; !b3DObjSelected && a<GetMarkedObjectCount(); a++) { 1112 SdrObject* pObj = GetMarkedObjectByIndex(a); 1113 if(pObj && pObj->ISA(E3dObject)) 1114 b3DObjSelected = sal_True; 1115 } 1116 #endif 1117 // Falls es um ein 3D-Objekt geht, muss trotz !IsShearAllowed 1118 // weitergemacht werden, da es sich um eine Rotation statt um 1119 // einen Shear handelt 1120 if (bVertex && !IsShearAllowed() && !b3DObjSelected) 1121 return Pointer(POINTER_NOTALLOWED); 1122 if (bMov) 1123 return Pointer(POINTER_ROTATE); 1124 } break; 1125 case SDRDRAG_SHEAR: case SDRDRAG_DISTORT: { 1126 if (bCorner) { 1127 if (!IsDistortAllowed(sal_True) && !IsDistortAllowed(sal_False)) return Pointer(POINTER_NOTALLOWED); 1128 else return Pointer(POINTER_REFHAND); 1129 } 1130 if (bVertex && !IsShearAllowed()) return Pointer(POINTER_NOTALLOWED); 1131 if (bMov) { 1132 if (!IsMoveAllowed()) return Pointer(POINTER_ARROW); // weil Doppelklick oder Drag&Drop moeglich 1133 return Pointer(POINTER_MOVE); 1134 } 1135 } break; 1136 case SDRDRAG_MIRROR: { 1137 if (bCorner || bVertex || bMov) { 1138 SdrHdl* pH1=aHdl.GetHdl(HDL_REF1); 1139 SdrHdl* pH2=aHdl.GetHdl(HDL_REF2); 1140 sal_Bool b90=sal_False; 1141 sal_Bool b45=sal_False; 1142 Point aDif; 1143 if (pH1!=NULL && pH2!=NULL) { 1144 aDif=pH2->GetPos()-pH1->GetPos(); 1145 b90=(aDif.X()==0) || aDif.Y()==0; 1146 b45=b90 || (Abs(aDif.X())==Abs(aDif.Y())); 1147 } 1148 sal_Bool bNo=sal_False; 1149 if (!IsMirrorAllowed(sal_True,sal_True)) bNo=sal_True; // Spiegeln ueberhaupt nicht erlaubt 1150 if (!IsMirrorAllowed(sal_False,sal_False) && !b45) bNo=sal_True; // freies Spiegeln nicht erlaubt 1151 if (!IsMirrorAllowed(sal_True,sal_False) && !b90) bNo=sal_True; // Spiegeln hor/ver erlaubt 1152 if (bNo) return Pointer(POINTER_NOTALLOWED); 1153 if (b90) { 1154 return Pointer(POINTER_MIRROR); 1155 } 1156 return Pointer(POINTER_MIRROR); 1157 } 1158 } break; 1159 1160 case SDRDRAG_TRANSPARENCE: 1161 { 1162 if(!IsTransparenceAllowed()) 1163 return Pointer(POINTER_NOTALLOWED); 1164 1165 return Pointer(POINTER_REFHAND); 1166 } 1167 1168 case SDRDRAG_GRADIENT: 1169 { 1170 if(!IsGradientAllowed()) 1171 return Pointer(POINTER_NOTALLOWED); 1172 1173 return Pointer(POINTER_REFHAND); 1174 } 1175 1176 case SDRDRAG_CROOK: { 1177 if (bCorner || bVertex || bMov) { 1178 if (!IsCrookAllowed(sal_True) && !IsCrookAllowed(sal_False)) return Pointer(POINTER_NOTALLOWED); 1179 return Pointer(POINTER_CROOK); 1180 } 1181 } 1182 1183 case SDRDRAG_CROP: 1184 { 1185 return Pointer(POINTER_CROP); 1186 } 1187 1188 default: { 1189 if ((bCorner || bVertex) && !IsResizeAllowed(sal_True)) return Pointer(POINTER_NOTALLOWED); 1190 } 1191 } 1192 if (pHdl!=NULL) return pHdl->GetPointer(); 1193 if (bMov) { 1194 if (!IsMoveAllowed()) return Pointer(POINTER_ARROW); // weil Doppelklick oder Drag&Drop moeglich 1195 return Pointer(POINTER_MOVE); 1196 } 1197 } 1198 if (eEditMode==SDREDITMODE_CREATE) return aAktCreatePointer; 1199 return Pointer(POINTER_ARROW); 1200 } 1201 1202 XubString SdrView::GetStatusText() 1203 { 1204 XubString aStr; 1205 XubString aName; 1206 1207 aStr.AppendAscii("nix"); 1208 1209 if (pAktCreate!=NULL) 1210 { 1211 aStr=pAktCreate->getSpecialDragComment(aDragStat); 1212 1213 if(!aStr.Len()) 1214 { 1215 pAktCreate->TakeObjNameSingul(aName); 1216 aStr = ImpGetResStr(STR_ViewCreateObj); 1217 } 1218 } 1219 else if (mpCurrentSdrDragMethod) 1220 { 1221 if (bInsPolyPoint || IsInsertGluePoint()) 1222 { 1223 aStr=aInsPointUndoStr; 1224 } 1225 else 1226 { 1227 if (aDragStat.IsMinMoved()) 1228 { 1229 OSL_TRACE("SdrView::GetStatusText(%lx) %lx\n", this, mpCurrentSdrDragMethod); 1230 mpCurrentSdrDragMethod->TakeSdrDragComment(aStr); 1231 } 1232 } 1233 } 1234 else if(IsMarkObj()) 1235 { 1236 if(AreObjectsMarked()) 1237 { 1238 aStr = ImpGetResStr(STR_ViewMarkMoreObjs); 1239 } 1240 else 1241 { 1242 aStr = ImpGetResStr(STR_ViewMarkObjs); 1243 } 1244 } 1245 else if(IsMarkPoints()) 1246 { 1247 if(HasMarkedPoints()) 1248 { 1249 aStr = ImpGetResStr(STR_ViewMarkMorePoints); 1250 } 1251 else 1252 { 1253 aStr = ImpGetResStr(STR_ViewMarkPoints); 1254 } 1255 } else if (IsMarkGluePoints()) 1256 { 1257 if(HasMarkedGluePoints()) 1258 { 1259 aStr = ImpGetResStr(STR_ViewMarkMoreGluePoints); 1260 } 1261 else 1262 { 1263 aStr = ImpGetResStr(STR_ViewMarkGluePoints); 1264 } 1265 } 1266 else if (IsTextEdit() && pTextEditOutlinerView!=NULL) { 1267 aStr=ImpGetResStr(STR_ViewTextEdit); // "TextEdit - Zeile y Spalte x"; 1268 ESelection aSel(pTextEditOutlinerView->GetSelection()); 1269 long nPar=aSel.nEndPara,nLin=0,nCol=aSel.nEndPos; 1270 if (aSel.nEndPara>0) { 1271 for (sal_uInt16 nParaNum=0; nParaNum<aSel.nEndPara; nParaNum++) { 1272 nLin+=pTextEditOutliner->GetLineCount(nParaNum); 1273 } 1274 } 1275 // Noch 'ne kleine Unschoenheit: 1276 // Am Ende einer Zeile eines mehrzeiligen Absatzes wird die Position 1277 // der naechsten Zeile des selben Absatzes angezeigt, so es eine solche 1278 // gibt. 1279 sal_uInt16 nParaLine=0; 1280 sal_uIntPtr nParaLineAnz=pTextEditOutliner->GetLineCount(aSel.nEndPara); 1281 sal_Bool bBrk=sal_False; 1282 while (!bBrk) { 1283 sal_uInt16 nLen=pTextEditOutliner->GetLineLen(aSel.nEndPara,nParaLine); 1284 sal_Bool bLastLine=(nParaLine==nParaLineAnz-1); 1285 if (nCol>nLen || (!bLastLine && nCol==nLen)) { 1286 nCol-=nLen; 1287 nLin++; 1288 nParaLine++; 1289 } else bBrk=sal_True; 1290 if (nLen==0) bBrk=sal_True; // Sicherheitshalber 1291 } 1292 1293 aStr.SearchAndReplaceAscii("%1", UniString::CreateFromInt32(nPar + 1)); 1294 aStr.SearchAndReplaceAscii("%2", UniString::CreateFromInt32(nLin + 1)); 1295 aStr.SearchAndReplaceAscii("%3", UniString::CreateFromInt32(nCol + 1)); 1296 1297 #ifdef DBG_UTIL 1298 aStr += UniString( RTL_CONSTASCII_USTRINGPARAM( ", Level " ) ); 1299 aStr += UniString::CreateFromInt32( pTextEditOutliner->GetDepth( aSel.nEndPara ) ); 1300 #endif 1301 } 1302 1303 if(aStr.EqualsAscii("nix")) 1304 { 1305 if (AreObjectsMarked()) { 1306 ImpTakeDescriptionStr(STR_ViewMarked,aStr); 1307 if (IsGluePointEditMode()) { 1308 if (HasMarkedGluePoints()) { 1309 ImpTakeDescriptionStr(STR_ViewMarked,aStr,0,IMPSDR_GLUEPOINTSDESCRIPTION); 1310 } 1311 } else { 1312 if (HasMarkedPoints()) { 1313 ImpTakeDescriptionStr(STR_ViewMarked,aStr,0,IMPSDR_POINTSDESCRIPTION); 1314 } 1315 } 1316 } else { 1317 aStr.Erase(); 1318 } 1319 } 1320 else if(aName.Len()) 1321 { 1322 aStr.SearchAndReplaceAscii("%1", aName); 1323 } 1324 1325 if(aStr.Len()) 1326 { 1327 // ersten Buchstaben gross schreiben 1328 String aTmpStr(aStr.Copy(0, 1)); 1329 aTmpStr.ToUpperAscii(); 1330 aStr.Replace(0, 1, aTmpStr); 1331 } 1332 return aStr; 1333 } 1334 1335 SdrViewContext SdrView::GetContext() const 1336 { 1337 if( IsGluePointEditMode() ) 1338 return SDRCONTEXT_GLUEPOINTEDIT; 1339 1340 const sal_uIntPtr nMarkAnz = GetMarkedObjectCount(); 1341 1342 if( HasMarkablePoints() && !IsFrameHandles() ) 1343 { 1344 sal_Bool bPath=sal_True; 1345 for( sal_uIntPtr nMarkNum = 0; nMarkNum < nMarkAnz && bPath; nMarkNum++ ) 1346 if (!GetMarkedObjectByIndex(nMarkNum)->ISA(SdrPathObj)) 1347 bPath=sal_False; 1348 1349 if( bPath ) 1350 return SDRCONTEXT_POINTEDIT; 1351 } 1352 1353 if( GetMarkedObjectCount() ) 1354 { 1355 sal_Bool bGraf = sal_True, bMedia = sal_True, bTable = sal_True; 1356 1357 for( sal_uIntPtr nMarkNum = 0; nMarkNum < nMarkAnz && ( bGraf || bMedia ); nMarkNum++ ) 1358 { 1359 const SdrObject* pMarkObj = GetMarkedObjectByIndex( nMarkNum ); 1360 DBG_ASSERT( pMarkObj, "SdrView::GetContext(), null pointer in mark list!" ); 1361 1362 if( !pMarkObj ) 1363 continue; 1364 1365 if( !pMarkObj->ISA( SdrGrafObj ) ) 1366 bGraf = sal_False; 1367 1368 if( !pMarkObj->ISA( SdrMediaObj ) ) 1369 bMedia = sal_False; 1370 1371 if( !pMarkObj->ISA( ::sdr::table::SdrTableObj ) ) 1372 bTable = sal_False; 1373 } 1374 1375 if( bGraf ) 1376 return SDRCONTEXT_GRAPHIC; 1377 else if( bMedia ) 1378 return SDRCONTEXT_MEDIA; 1379 else if( bTable ) 1380 return SDRCONTEXT_TABLE; 1381 } 1382 1383 return SDRCONTEXT_STANDARD; 1384 } 1385 1386 void SdrView::MarkAll() 1387 { 1388 if (IsTextEdit()) { 1389 GetTextEditOutlinerView()->SetSelection(ESelection(0,0,0xFFFF,0xFFFF)); 1390 #ifdef DBG_UTIL 1391 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1392 #endif 1393 } else if (IsGluePointEditMode()) MarkAllGluePoints(); 1394 else if (HasMarkablePoints()) MarkAllPoints(); 1395 else MarkAllObj(); 1396 } 1397 1398 void SdrView::UnmarkAll() 1399 { 1400 if (IsTextEdit()) { 1401 ESelection eSel=GetTextEditOutlinerView()->GetSelection(); 1402 eSel.nStartPara=eSel.nEndPara; 1403 eSel.nStartPos=eSel.nEndPos; 1404 GetTextEditOutlinerView()->SetSelection(eSel); 1405 #ifdef DBG_UTIL 1406 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1407 #endif 1408 } else if (HasMarkedGluePoints()) UnmarkAllGluePoints(); 1409 else if (HasMarkedPoints()) UnmarkAllPoints(); // ! Marked statt Markable ! 1410 else UnmarkAllObj(); 1411 } 1412 1413 sal_Bool SdrView::IsAllMarked() const 1414 { 1415 if (IsTextEdit()) { 1416 return ImpIsTextEditAllSelected(); 1417 } 1418 if (IsGluePointEditMode()) { 1419 sal_uIntPtr nAnz=GetMarkableGluePointCount(); 1420 return nAnz!=0 && nAnz==GetMarkedGluePointCount(); 1421 } 1422 if (HasMarkedPoints()) { 1423 sal_uIntPtr nAnz=GetMarkablePointCount(); 1424 return nAnz!=0 && nAnz==GetMarkedPointCount(); 1425 } 1426 sal_uIntPtr nAnz=GetMarkableObjCount(); 1427 return nAnz!=0 && nAnz == GetMarkedObjectCount(); 1428 } 1429 1430 sal_Bool SdrView::IsMarkPossible() const 1431 { 1432 if(IsTextEdit()) 1433 { 1434 return SdrTextObj::HasTextImpl( pTextEditOutliner ); 1435 } 1436 1437 if(IsGluePointEditMode()) 1438 { 1439 return HasMarkableGluePoints(); 1440 } 1441 1442 if(HasMarkedPoints()) 1443 { 1444 return HasMarkablePoints(); 1445 } 1446 1447 return HasMarkableObj(); 1448 } 1449 1450 sal_Bool SdrView::IsAllMarkPrevNextPossible() const 1451 { 1452 if (IsTextEdit()) { 1453 return sal_False; 1454 } 1455 if (IsGluePointEditMode()) { 1456 return HasMarkableGluePoints(); 1457 } 1458 if (HasMarkedPoints()) { 1459 return HasMarkablePoints(); 1460 } 1461 return HasMarkableObj(); 1462 } 1463 1464 sal_Bool SdrView::MarkNext(sal_Bool bPrev) 1465 { 1466 if (IsTextEdit()) { 1467 return sal_False; 1468 } 1469 if (IsGluePointEditMode() && HasMarkedGluePoints()) { 1470 return MarkNextGluePoint(bPrev); 1471 } 1472 if (HasMarkedPoints()) { 1473 return MarkNextPoint(bPrev); 1474 } 1475 return MarkNextObj(bPrev); 1476 } 1477 1478 sal_Bool SdrView::MarkNext(const Point& rPnt, sal_Bool bPrev) 1479 { 1480 if (IsTextEdit()) { 1481 return sal_False; 1482 } 1483 if (IsGluePointEditMode() && HasMarkedGluePoints()) { 1484 //return MarkNextGluePoint(rPnt,bPrev); fehlende Implementation !!! 1485 } 1486 if (HasMarkedPoints()) { 1487 //return MarkNextPoint(rPnt,bPrev); fehlende Implementation !!! 1488 } 1489 return MarkNextObj(rPnt,-2,bPrev); 1490 } 1491 1492 const Rectangle& SdrView::GetMarkedRect() const 1493 { 1494 if (IsGluePointEditMode() && HasMarkedGluePoints()) { 1495 return GetMarkedGluePointsRect(); 1496 } 1497 if (HasMarkedPoints()) { 1498 return GetMarkedPointsRect(); 1499 } 1500 return GetMarkedObjRect(); 1501 } 1502 1503 void SdrView::SetMarkedRect(const Rectangle& rRect) 1504 { 1505 if (IsGluePointEditMode() && HasMarkedGluePoints()) { 1506 //SetMarkedGluePointsRect(rRect); fehlende Implementation !!! 1507 } else if (HasMarkedPoints()) { 1508 //SetMarkedPointsRect(rRect); fehlende Implementation !!! 1509 } else SetMarkedObjRect(rRect); 1510 } 1511 1512 void SdrView::DeleteMarked() 1513 { 1514 if (IsTextEdit()) 1515 { 1516 SdrObjEditView::KeyInput(KeyEvent(0,KeyCode(KEYFUNC_DELETE)),pTextEditWin); 1517 } 1518 else 1519 { 1520 if( mxSelectionController.is() && mxSelectionController->DeleteMarked() ) 1521 { 1522 // action already performed by current selection controller, do nothing 1523 } 1524 else if (IsGluePointEditMode() && HasMarkedGluePoints()) 1525 { 1526 DeleteMarkedGluePoints(); 1527 } 1528 else if (GetContext()==SDRCONTEXT_POINTEDIT && HasMarkedPoints()) 1529 { 1530 DeleteMarkedPoints(); 1531 } 1532 else 1533 { 1534 DeleteMarkedObj(); 1535 } 1536 } 1537 } 1538 1539 sal_Bool SdrView::BegMark(const Point& rPnt, sal_Bool bAddMark, sal_Bool bUnmark) 1540 { 1541 if (bUnmark) bAddMark=sal_True; 1542 if (IsGluePointEditMode()) { 1543 if (!bAddMark) UnmarkAllGluePoints(); 1544 return BegMarkGluePoints(rPnt,bUnmark); 1545 } else if (HasMarkablePoints()) { 1546 if (!bAddMark) UnmarkAllPoints(); 1547 return BegMarkPoints(rPnt,bUnmark); 1548 } else { 1549 if (!bAddMark) UnmarkAllObj(); 1550 return BegMarkObj(rPnt,bUnmark); 1551 } 1552 } 1553 1554 sal_Bool SdrView::IsDeleteMarkedPossible() const 1555 { 1556 if (IsReadOnly()) return sal_False; 1557 if (IsTextEdit()) return sal_True; 1558 if (IsGluePointEditMode() && HasMarkedGluePoints()) return sal_True; 1559 if (HasMarkedPoints()) return sal_True; 1560 return IsDeleteMarkedObjPossible(); 1561 } 1562 1563 void SdrView::ConfigurationChanged( ::utl::ConfigurationBroadcaster*p, sal_uInt32 nHint) 1564 { 1565 onAccessibilityOptionsChanged(); 1566 SdrCreateView::ConfigurationChanged(p, nHint); 1567 } 1568 1569 SvtAccessibilityOptions& SdrView::getAccessibilityOptions() 1570 { 1571 return maAccessibilityOptions; 1572 } 1573 1574 /** method is called whenever the global SvtAccessibilityOptions is changed */ 1575 void SdrView::onAccessibilityOptionsChanged() 1576 { 1577 } 1578 1579 void SdrView::SetMasterPagePaintCaching(sal_Bool bOn) 1580 { 1581 if(mbMasterPagePaintCaching != bOn) 1582 { 1583 mbMasterPagePaintCaching = bOn; 1584 1585 // reset at all SdrPageWindow's 1586 SdrPageView* pPageView = GetSdrPageView(); 1587 1588 if(pPageView) 1589 { 1590 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++) 1591 { 1592 SdrPageWindow* pPageWindow = pPageView->GetPageWindow(b); 1593 DBG_ASSERT(pPageWindow, "SdrView::SetMasterPagePaintCaching: Corrupt SdrPageWindow list (!)"); 1594 1595 // force deletion of ObjectContact, so at re-display all VOCs 1596 // will be re-created with updated flag setting 1597 pPageWindow->ResetObjectContact(); 1598 } 1599 1600 // force redraw of this view 1601 pPageView->InvalidateAllWin(); 1602 } 1603 } 1604 } 1605 // eof 1606