Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <editeng/eeitem.hxx>
21 :
22 : #include "svx/svdstr.hrc"
23 : #include "svdglob.hxx"
24 : #include <svx/svdpagv.hxx>
25 : #include <svx/svdmrkv.hxx>
26 : #include <svx/svdedxv.hxx>
27 : #include <svx/svdobj.hxx>
28 : #include <svx/svdopath.hxx>
29 : #include <svx/svdograf.hxx>
30 : #include <svx/svdomedia.hxx>
31 : #include <svx/svdetc.hxx>
32 :
33 : #ifdef DBG_UTIL
34 : #include <svdibrow.hxx>
35 : #endif
36 :
37 : #include "svx/svdoutl.hxx"
38 : #include "svx/svdview.hxx"
39 : #include "editeng/editview.hxx"
40 : #include "editeng/flditem.hxx"
41 : #include "svx/obj3d.hxx"
42 : #include "svx/svddrgmt.hxx"
43 : #include "svx/svdotable.hxx"
44 : #include <tools/tenccvt.hxx>
45 : #include <svx/sdr/overlay/overlaypolypolygon.hxx>
46 : #include <svx/sdr/overlay/overlaymanager.hxx>
47 : #include <svx/sdrpaintwindow.hxx>
48 : #include <svx/sdrpagewindow.hxx>
49 : #include <svx/sdrhittesthelper.hxx>
50 : #include <svx/sdr/contact/viewcontact.hxx>
51 : #include <drawinglayer/processor2d/contourextractor2d.hxx>
52 :
53 :
54 :
55 700 : SdrViewEvent::SdrViewEvent()
56 : : pHdl(NULL),
57 : pObj(NULL),
58 : pRootObj(NULL),
59 : pPV(NULL),
60 : pURLField(NULL),
61 : eHit(SDRHIT_NONE),
62 : eEvent(SDREVENT_NONE),
63 : eHdlKind(HDL_MOVE),
64 : eEndCreateCmd(SDRCREATE_NEXTPOINT),
65 : nMouseClicks(0),
66 : nMouseMode(MouseEventModifiers::NONE),
67 : nMouseCode(0),
68 : nHlplIdx(0),
69 : nGlueId(0),
70 : bMouseDown(false),
71 : bMouseUp(false),
72 : bDoubleHdlSize(false),
73 : bIsAction(false),
74 : bIsTextEdit(false),
75 : bTextEditHit(false),
76 : bAddMark(false),
77 : bUnmark(false),
78 : bPrevNextMark(false),
79 : bMarkPrev(false),
80 : bInsPointNewObj(false),
81 : bDragWithCopy(false),
82 : bCaptureMouse(false),
83 700 : bReleaseMouse(false)
84 : {
85 700 : }
86 :
87 700 : SdrViewEvent::~SdrViewEvent()
88 : {
89 700 : }
90 :
91 :
92 : // helper class for all D&D overlays
93 :
94 0 : void SdrDropMarkerOverlay::ImplCreateOverlays(
95 : const SdrView& rView,
96 : const basegfx::B2DPolyPolygon& rLinePolyPolygon)
97 : {
98 0 : for(sal_uInt32 a(0L); a < rView.PaintWindowCount(); a++)
99 : {
100 0 : SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
101 0 : rtl::Reference< sdr::overlay::OverlayManager > xTargetOverlay = pCandidate->GetOverlayManager();
102 :
103 0 : if (xTargetOverlay.is())
104 : {
105 : sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new sdr::overlay::OverlayPolyPolygonStripedAndFilled(
106 0 : rLinePolyPolygon);
107 :
108 0 : xTargetOverlay->add(*pNew);
109 0 : maObjects.append(*pNew);
110 : }
111 0 : }
112 0 : }
113 :
114 0 : SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const SdrObject& rObject)
115 : {
116 : ImplCreateOverlays(
117 : rView,
118 0 : rObject.TakeXorPoly());
119 0 : }
120 :
121 0 : SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Rectangle& rRectangle)
122 : {
123 0 : basegfx::B2DPolygon aB2DPolygon;
124 :
125 0 : aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Top()));
126 0 : aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Top()));
127 0 : aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Bottom()));
128 0 : aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Bottom()));
129 0 : aB2DPolygon.setClosed(true);
130 :
131 : ImplCreateOverlays(
132 : rView,
133 0 : basegfx::B2DPolyPolygon(aB2DPolygon));
134 0 : }
135 :
136 0 : SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Point& rStart, const Point& rEnd)
137 : {
138 0 : basegfx::B2DPolygon aB2DPolygon;
139 :
140 0 : aB2DPolygon.append(basegfx::B2DPoint(rStart.X(), rStart.Y()));
141 0 : aB2DPolygon.append(basegfx::B2DPoint(rEnd.X(), rEnd.Y()));
142 0 : aB2DPolygon.setClosed(true);
143 :
144 : ImplCreateOverlays(
145 : rView,
146 0 : basegfx::B2DPolyPolygon(aB2DPolygon));
147 0 : }
148 :
149 0 : SdrDropMarkerOverlay::~SdrDropMarkerOverlay()
150 : {
151 : // The OverlayObjects are cleared using the destructor of OverlayObjectList.
152 : // That destructor calls clear() at the list which removes all objects from the
153 : // OverlayManager and deletes them.
154 0 : }
155 :
156 :
157 1488353 : TYPEINIT1(SdrView,SdrCreateView);
158 :
159 9504 : SdrView::SdrView(SdrModel* pModel1, OutputDevice* pOut)
160 : : SdrCreateView(pModel1,pOut),
161 : bNoExtendedMouseDispatcher(false),
162 : bNoExtendedKeyDispatcher(false),
163 : bNoExtendedCommandDispatcher(false),
164 9504 : mbMasterPagePaintCaching(false)
165 : {
166 9504 : bTextEditOnObjectsWithoutTextIfTextTool=false;
167 :
168 9504 : maAccessibilityOptions.AddListener(this);
169 :
170 9504 : onAccessibilityOptionsChanged();
171 9504 : }
172 :
173 24029 : SdrView::~SdrView()
174 : {
175 9438 : maAccessibilityOptions.RemoveListener(this);
176 14591 : }
177 :
178 2 : bool SdrView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin)
179 : {
180 2 : SetActualWin(pWin);
181 2 : bool bRet = SdrCreateView::KeyInput(rKEvt,pWin);
182 2 : if (!bRet && !IsExtendedKeyInputDispatcherEnabled()) {
183 0 : bRet = true;
184 0 : switch (rKEvt.GetKeyCode().GetFullFunction()) {
185 0 : case KeyFuncType::CUT : Cut(); break;
186 0 : case KeyFuncType::COPY : Yank(); break;
187 0 : case KeyFuncType::PASTE : Paste(pWin); break;
188 0 : case KeyFuncType::DELETE: DeleteMarked(); break;
189 0 : case KeyFuncType::UNDO: pMod->Undo(); break;
190 0 : case KeyFuncType::REDO: pMod->Redo(); break;
191 0 : case KeyFuncType::REPEAT: pMod->Repeat(*this); break;
192 : default: {
193 0 : switch (rKEvt.GetKeyCode().GetFullCode()) {
194 : case KEY_ESCAPE: {
195 0 : if (IsTextEdit()) SdrEndTextEdit();
196 0 : if (IsAction()) BrkAction();
197 0 : if (pWin!=NULL) pWin->ReleaseMouse();
198 0 : } break;
199 0 : case KEY_DELETE: DeleteMarked(); break;
200 0 : case KEY_CUT: case KEY_DELETE+KEY_SHIFT: Cut(); break;
201 0 : case KEY_COPY: case KEY_INSERT+KEY_MOD1: Yank(); break;
202 0 : case KEY_PASTE: case KEY_INSERT+KEY_SHIFT: Paste(pWin); break;
203 0 : case KEY_UNDO: case KEY_BACKSPACE+KEY_MOD2: pMod->Undo(); break;
204 0 : case KEY_BACKSPACE+KEY_MOD2+KEY_SHIFT: pMod->Redo(); break;
205 0 : case KEY_REPEAT: case KEY_BACKSPACE+KEY_MOD2+KEY_MOD1: pMod->Repeat(*this); break;
206 0 : case KEY_MOD1+KEY_A: MarkAll(); break;
207 0 : default: bRet=false;
208 : } // switch
209 : }
210 : } // switch
211 0 : if (bRet && pWin!=NULL) {
212 : pWin->SetPointer(GetPreferredPointer(
213 0 : pWin->PixelToLogic(pWin->ScreenToOutputPixel( pWin->GetPointerPosPixel() ) ),
214 : pWin,
215 0 : rKEvt.GetKeyCode().GetModifier()));
216 : }
217 : }
218 2 : return bRet;
219 : }
220 :
221 3 : bool SdrView::MouseButtonDown(const MouseEvent& rMEvt, vcl::Window* pWin)
222 : {
223 3 : SetActualWin(pWin);
224 3 : if (rMEvt.IsLeft()) aDragStat.SetMouseDown(true);
225 3 : bool bRet = SdrCreateView::MouseButtonDown(rMEvt,pWin);
226 3 : if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) {
227 0 : SdrViewEvent aVEvt;
228 0 : PickAnything(rMEvt,SdrMouseEventKind::BUTTONDOWN,aVEvt);
229 0 : bRet = DoMouseEvent(aVEvt);
230 : }
231 3 : return bRet;
232 : }
233 :
234 3 : bool SdrView::MouseButtonUp(const MouseEvent& rMEvt, vcl::Window* pWin)
235 : {
236 3 : SetActualWin(pWin);
237 3 : if (rMEvt.IsLeft()) aDragStat.SetMouseDown(false);
238 3 : bool bAction = IsAction();
239 3 : bool bRet = !bAction && SdrCreateView::MouseButtonUp(rMEvt,pWin);
240 3 : if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) {
241 0 : SdrViewEvent aVEvt;
242 0 : PickAnything(rMEvt,SdrMouseEventKind::BUTTONUP,aVEvt);
243 0 : bRet = DoMouseEvent(aVEvt);
244 : }
245 3 : return bRet;
246 : }
247 :
248 4 : bool SdrView::MouseMove(const MouseEvent& rMEvt, vcl::Window* pWin)
249 : {
250 4 : SetActualWin(pWin);
251 4 : aDragStat.SetMouseDown(rMEvt.IsLeft());
252 4 : bool bRet = SdrCreateView::MouseMove(rMEvt,pWin);
253 4 : if (!IsExtendedMouseEventDispatcherEnabled() && !IsTextEditInSelectionMode()) {
254 0 : SdrViewEvent aVEvt;
255 0 : PickAnything(rMEvt,SdrMouseEventKind::MOVE,aVEvt);
256 0 : if (DoMouseEvent(aVEvt)) bRet=true;
257 : }
258 :
259 4 : return bRet;
260 : }
261 :
262 0 : bool SdrView::Command(const CommandEvent& rCEvt, vcl::Window* pWin)
263 : {
264 0 : SetActualWin(pWin);
265 0 : bool bRet = SdrCreateView::Command(rCEvt,pWin);
266 0 : return bRet;
267 : }
268 :
269 583 : bool SdrView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
270 : {
271 583 : return SdrCreateView::GetAttributes(rTargetSet, bOnlyHardAttr);
272 : }
273 :
274 0 : SfxStyleSheet* SdrView::GetStyleSheet() const
275 : {
276 0 : return SdrCreateView::GetStyleSheet();
277 : }
278 :
279 15 : SdrHitKind SdrView::PickAnything(const MouseEvent& rMEvt, SdrMouseEventKind nEventKind, SdrViewEvent& rVEvt) const
280 : {
281 15 : rVEvt.bMouseDown=nEventKind==SdrMouseEventKind::BUTTONDOWN;
282 15 : rVEvt.bMouseUp=nEventKind==SdrMouseEventKind::BUTTONUP;
283 15 : rVEvt.nMouseClicks=rMEvt.GetClicks();
284 15 : rVEvt.nMouseMode=rMEvt.GetMode();
285 15 : rVEvt.nMouseCode=rMEvt.GetButtons() | rMEvt.GetModifier();
286 15 : const OutputDevice* pOut=pActualOutDev;
287 15 : if (pOut==NULL)
288 : {
289 0 : pOut = GetFirstOutputDevice();
290 : }
291 15 : Point aPnt(rMEvt.GetPosPixel());
292 15 : if (pOut!=NULL) aPnt=pOut->PixelToLogic(aPnt);
293 15 : rVEvt.aLogicPos=aPnt;
294 15 : return PickAnything(aPnt,rVEvt);
295 : }
296 :
297 : // Dragging with the Mouse (Move)
298 : // Example when creating a rectangle: MouseDown has to happen without a ModKey,
299 : // else we usually force a selection (see below).
300 : // When pressing Shift, Ctrl and Alt at the same time while doing a MouseMove,
301 : // a centered, not snapped square is created.
302 : // The dual allocation of Ortho and Shift won't usually create a problem, as the
303 : // two functions are in most cases mutually exclusive. Only shearing (the kind
304 : // that happens when contorting, not when rotating) can use both functions at
305 : // the same time. To get around this, the user can use e. g. help lines.
306 : #define MODKEY_NoSnap bCtrl /* temporarily disable snapping */
307 : #define MODKEY_Ortho bShift /* ortho */
308 : #define MODKEY_Center bAlt /* create/resize centeredly */
309 : #define MODKEY_AngleSnap bShift
310 : #define MODKEY_CopyDrag bCtrl /* drag and copy */
311 :
312 : // click somewhere (MouseDown)
313 : #define MODKEY_PolyPoly bAlt /* new Poly at InsPt and at Create */
314 : #define MODKEY_MultiMark bShift /* MarkObj without doing UnmarkAll first */
315 : #define MODKEY_Unmark bAlt /* deselect with a dragged frame */
316 : #define MODKEY_ForceMark bCtrl /* force dragging a frame, even if there's an object at cursor position */
317 : #define MODKEY_DeepMark bAlt /* MarkNextObj */
318 : #define MODKEY_DeepBackw bShift /* MarkNextObj but backwards */
319 :
320 360 : SdrHitKind SdrView::PickAnything(const Point& rLogicPos, SdrViewEvent& rVEvt) const
321 : {
322 360 : const OutputDevice* pOut=pActualOutDev;
323 360 : if (pOut==NULL)
324 : {
325 0 : pOut = GetFirstOutputDevice();
326 : }
327 :
328 : // #i73628# Use a non-changeable copy of he logic position
329 360 : const Point aLocalLogicPosition(rLogicPos);
330 :
331 360 : bool bEditMode=IsEditMode();
332 360 : bool bPointMode=bEditMode && HasMarkablePoints();
333 360 : bool bGluePointMode=IsGluePointEditMode();
334 360 : bool bInsPolyPt=bPointMode && IsInsObjPointMode() && IsInsObjPointPossible();
335 360 : bool bInsGluePt=bGluePointMode && IsInsGluePointMode() && IsInsGluePointPossible();
336 360 : bool bIsTextEdit=IsTextEdit();
337 360 : bool bTextEditHit=IsTextEditHit(aLocalLogicPosition,0/*nHitTolLog*/);
338 360 : bool bTextEditSel=IsTextEditInSelectionMode();
339 360 : bool bShift=(rVEvt.nMouseCode & KEY_SHIFT) !=0;
340 360 : bool bCtrl=(rVEvt.nMouseCode & KEY_MOD1) !=0;
341 360 : bool bAlt=(rVEvt.nMouseCode & KEY_MOD2) !=0;
342 360 : SdrHitKind eHit=SDRHIT_NONE;
343 360 : SdrHdl* pHdl=pOut!=NULL && !bTextEditSel ? PickHandle(aLocalLogicPosition) : NULL;
344 360 : SdrPageView* pPV=NULL;
345 360 : SdrObject* pObj=NULL;
346 360 : SdrObject* pHitObj=NULL;
347 360 : bool bHitPassDirect=true;
348 360 : sal_uInt16 nHlplIdx=0;
349 360 : sal_uInt16 nGlueId=0;
350 360 : if (bTextEditHit || bTextEditSel)
351 : {
352 3 : eHit=SDRHIT_TEXTEDIT;
353 3 : bTextEditHit=true;
354 : }
355 357 : else if (pHdl!=NULL)
356 : {
357 8 : eHit=SDRHIT_HANDLE; // handle is hit: highest priority
358 : }
359 349 : else if (bEditMode && IsHlplVisible() && IsHlplFront() && pOut!=NULL && PickHelpLine(aLocalLogicPosition,nHitTolLog,*pOut,nHlplIdx,pPV))
360 : {
361 0 : eHit=SDRHIT_HELPLINE; // help line in the foreground hit: can be moved now
362 : }
363 349 : else if (bGluePointMode && PickGluePoint(aLocalLogicPosition,pObj,nGlueId,pPV))
364 : {
365 0 : eHit=SDRHIT_GLUEPOINT; // deselected glue point hit
366 : }
367 349 : else if (PickObj(aLocalLogicPosition,nHitTolLog,pHitObj,pPV,SdrSearchOptions::DEEP|SdrSearchOptions::MARKED,&pObj,&bHitPassDirect))
368 : {
369 0 : eHit=SDRHIT_MARKEDOBJECT;
370 0 : sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pObj );
371 0 : if( pTableObj )
372 : {
373 0 : sal_Int32 nX = 0, nY = 0;
374 0 : switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY, 0 ) )
375 : {
376 : case sdr::table::SDRTABLEHIT_CELL:
377 0 : eHit = SDRHIT_CELL;
378 0 : break;
379 : case sdr::table::SDRTABLEHIT_CELLTEXTAREA:
380 0 : eHit = SDRHIT_TEXTEDITOBJ;
381 0 : break;
382 : default:
383 0 : break;
384 : }
385 : }
386 : }
387 349 : else if (PickObj(aLocalLogicPosition,nHitTolLog,pHitObj,pPV,SdrSearchOptions::DEEP|SdrSearchOptions::ALSOONMASTER|SdrSearchOptions::WHOLEPAGE,&pObj,&bHitPassDirect))
388 : {
389 : // MasterPages and WholePage for Macro and URL
390 4 : eHit=SDRHIT_UNMARKEDOBJECT;
391 4 : sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pObj );
392 4 : if( pTableObj )
393 : {
394 0 : sal_Int32 nX = 0, nY = 0;
395 0 : switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY, 0 ) )
396 : {
397 : case sdr::table::SDRTABLEHIT_CELL:
398 0 : eHit = SDRHIT_CELL;
399 0 : break;
400 : case sdr::table::SDRTABLEHIT_CELLTEXTAREA:
401 0 : eHit = SDRHIT_TEXTEDITOBJ;
402 0 : break;
403 : default:
404 0 : break;
405 : }
406 : }
407 : }
408 345 : else if (bEditMode && IsHlplVisible() && !IsHlplFront() && pOut!=NULL && PickHelpLine(aLocalLogicPosition,nHitTolLog,*pOut,nHlplIdx,pPV))
409 : {
410 0 : eHit=SDRHIT_HELPLINE; // help line in foreground hit: can be moved now
411 : }
412 360 : if (IsMacroMode() && eHit==SDRHIT_UNMARKEDOBJECT)
413 : {
414 4 : bool bRoot=pObj->HasMacro();
415 4 : bool bDeep=pObj!=pHitObj && pHitObj->HasMacro();
416 4 : bool bMid=false; // Have we hit upon a grouped group with a macro?
417 4 : SdrObject* pMidObj=NULL;
418 4 : if (pObj!=pHitObj)
419 : {
420 0 : SdrObject* pObjTmp=NULL;
421 0 : pObjTmp=pHitObj->GetUpGroup();
422 0 : if (pObjTmp==pObj) pObjTmp=NULL;
423 0 : while (pObjTmp!=NULL)
424 : {
425 0 : if (pObjTmp->HasMacro())
426 : {
427 0 : bMid=true;
428 0 : pMidObj=pObjTmp;
429 : }
430 0 : pObjTmp=pObjTmp->GetUpGroup();
431 0 : if (pObjTmp==pObj) pObjTmp=NULL;
432 : }
433 : }
434 :
435 4 : if (bDeep || bMid || bRoot)
436 : {
437 0 : SdrObjMacroHitRec aHitRec;
438 0 : aHitRec.aPos=aLocalLogicPosition;
439 0 : aHitRec.aDownPos=aLocalLogicPosition;
440 0 : aHitRec.nTol=nHitTolLog;
441 0 : aHitRec.pVisiLayer=&pPV->GetVisibleLayers();
442 0 : aHitRec.pPageView=pPV;
443 0 : if (bDeep) bDeep=pHitObj->IsMacroHit(aHitRec);
444 0 : if (bMid ) bMid =pMidObj->IsMacroHit(aHitRec);
445 0 : if (bRoot) bRoot=pObj->IsMacroHit(aHitRec);
446 0 : if (bRoot || bMid || bDeep)
447 : {
448 : // Priorities: 1. Root, 2. Mid, 3. Deep
449 0 : rVEvt.pRootObj=pObj;
450 0 : if (!bRoot) pObj=pMidObj;
451 0 : if (!bRoot && !bMid) pObj=pHitObj;
452 0 : eHit=SDRHIT_MACRO;
453 0 : }
454 : }
455 : }
456 : // check for URL field
457 360 : if (IsMacroMode() && eHit==SDRHIT_UNMARKEDOBJECT)
458 : {
459 4 : SdrTextObj* pTextObj=PTR_CAST(SdrTextObj,pHitObj);
460 4 : if (pTextObj!=NULL && pTextObj->HasText())
461 : {
462 0 : bool bTEHit(pPV &&
463 0 : SdrObjectPrimitiveHit(*pTextObj, aLocalLogicPosition, 0, *pPV, &pPV->GetVisibleLayers(), true));
464 :
465 0 : if (bTEHit)
466 : {
467 0 : Rectangle aTextRect;
468 0 : Rectangle aAnchor;
469 0 : SdrOutliner* pOutliner = &pTextObj->ImpGetDrawOutliner();
470 0 : if( pTextObj->GetModel() )
471 0 : pOutliner = &pTextObj->GetModel()->GetHitTestOutliner();
472 :
473 0 : pTextObj->TakeTextRect( *pOutliner, aTextRect, false, &aAnchor, false );
474 :
475 : // #i73628# Use a text-relative position for hit test in hit test outliner
476 0 : Point aTemporaryTextRelativePosition(aLocalLogicPosition - aTextRect.TopLeft());
477 :
478 : // account for FitToSize
479 0 : bool bFitToSize(pTextObj->IsFitToSize());
480 0 : if (bFitToSize) {
481 0 : Fraction aX(aTextRect.GetWidth()-1,aAnchor.GetWidth()-1);
482 0 : Fraction aY(aTextRect.GetHeight()-1,aAnchor.GetHeight()-1);
483 0 : ResizePoint(aTemporaryTextRelativePosition,Point(),aX,aY);
484 : }
485 : // account for rotation
486 0 : const GeoStat& rGeo=pTextObj->GetGeoStat();
487 0 : if (rGeo.nRotationAngle!=0) RotatePoint(aTemporaryTextRelativePosition,Point(),-rGeo.nSin,rGeo.nCos); // -sin for Unrotate
488 : // we currently don't account for ticker text
489 0 : if(pActualOutDev && pActualOutDev->GetOutDevType() == OUTDEV_WINDOW)
490 : {
491 0 : OutlinerView aOLV(pOutliner, const_cast<vcl::Window*>(static_cast<const vcl::Window*>(pActualOutDev.get())));
492 0 : const EditView& aEV=aOLV.GetEditView();
493 0 : const SvxFieldItem* pItem=aEV.GetField(aTemporaryTextRelativePosition);
494 0 : if (pItem!=NULL) {
495 0 : const SvxFieldData* pFld=pItem->GetField();
496 0 : const SvxURLField* pURL=PTR_CAST(SvxURLField,pFld);
497 0 : if (pURL!=NULL) {
498 0 : eHit=SDRHIT_URLFIELD;
499 0 : rVEvt.pURLField=pURL;
500 : }
501 0 : }
502 : }
503 : }
504 : }
505 : }
506 :
507 386 : if (bHitPassDirect &&
508 30 : (eHit==SDRHIT_MARKEDOBJECT || eHit==SDRHIT_UNMARKEDOBJECT) &&
509 368 : (IsTextTool() || (IsEditMode() && IsQuickTextEditMode())) && pHitObj->HasTextEdit())
510 : {
511 : // Around the TextEditArea there's a border to select without going into text edit mode.
512 4 : Rectangle aBoundRect(pHitObj->GetCurrentBoundRect());
513 :
514 : // Force to SnapRect when Fontwork
515 4 : if(pHitObj->ISA(SdrTextObj) && static_cast<SdrTextObj*>(pHitObj)->IsFontwork())
516 : {
517 0 : aBoundRect = pHitObj->GetSnapRect();
518 : }
519 :
520 4 : sal_Int32 nTolerance(nHitTolLog);
521 4 : bool bBoundRectHit(false);
522 :
523 4 : if(pOut)
524 : {
525 4 : nTolerance = pOut->PixelToLogic(Size(2, 0)).Width();
526 : }
527 :
528 12 : if( (aLocalLogicPosition.X() >= aBoundRect.Left() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Left() + nTolerance)
529 4 : || (aLocalLogicPosition.X() >= aBoundRect.Right() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Right() + nTolerance)
530 4 : || (aLocalLogicPosition.Y() >= aBoundRect.Top() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Top() + nTolerance)
531 8 : || (aLocalLogicPosition.Y() >= aBoundRect.Bottom() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Bottom() + nTolerance))
532 : {
533 3 : bBoundRectHit = true;
534 : }
535 :
536 4 : if(!bBoundRectHit)
537 : {
538 2 : bool bTEHit(pPV &&
539 2 : SdrObjectPrimitiveHit(*pHitObj, aLocalLogicPosition, 0, *pPV, &pPV->GetVisibleLayers(), true));
540 :
541 : // TextEdit attached to an object in a locked layer
542 1 : if (pPV->GetLockedLayers().IsSet(pHitObj->GetLayer()))
543 : {
544 0 : bTEHit=false;
545 : }
546 :
547 1 : if (bTEHit)
548 : {
549 0 : rVEvt.pRootObj=pObj;
550 0 : pObj=pHitObj;
551 0 : eHit=SDRHIT_TEXTEDITOBJ;
552 : }
553 : }
554 : }
555 360 : if (!bHitPassDirect && eHit==SDRHIT_UNMARKEDOBJECT) {
556 0 : eHit=SDRHIT_NONE;
557 0 : pObj=NULL;
558 0 : pPV=NULL;
559 : }
560 360 : bool bMouseLeft=(rVEvt.nMouseCode&MOUSE_LEFT)!=0;
561 360 : bool bMouseRight=(rVEvt.nMouseCode&MOUSE_RIGHT)!=0;
562 360 : bool bMouseDown=rVEvt.bMouseDown;
563 360 : bool bMouseUp=rVEvt.bMouseUp;
564 360 : SdrEventKind eEvent=SDREVENT_NONE;
565 360 : bool bIsAction=IsAction();
566 :
567 360 : if (bIsAction)
568 : {
569 0 : if (bMouseDown)
570 : {
571 0 : if (bMouseRight) eEvent=SDREVENT_BCKACTION;
572 : }
573 0 : else if (bMouseUp)
574 : {
575 0 : if (bMouseLeft)
576 : {
577 0 : eEvent=SDREVENT_ENDACTION;
578 0 : if (IsDragObj())
579 : {
580 0 : eEvent=SDREVENT_ENDDRAG;
581 0 : rVEvt.bDragWithCopy=MODKEY_CopyDrag;
582 : }
583 0 : else if (IsCreateObj() || IsInsObjPoint())
584 : {
585 0 : eEvent=IsCreateObj() ? SDREVENT_ENDCREATE : SDREVENT_ENDINSOBJPOINT;
586 0 : rVEvt.eEndCreateCmd=SDRCREATE_NEXTPOINT;
587 0 : if (MODKEY_PolyPoly) rVEvt.eEndCreateCmd=SDRCREATE_NEXTOBJECT;
588 0 : if (rVEvt.nMouseClicks>1) rVEvt.eEndCreateCmd=SDRCREATE_FORCEEND;
589 : }
590 0 : else if (IsMarking())
591 : {
592 0 : eEvent=SDREVENT_ENDMARK;
593 0 : if (!aDragStat.IsMinMoved())
594 : {
595 0 : eEvent=SDREVENT_BRKMARK;
596 0 : rVEvt.bAddMark=MODKEY_MultiMark;
597 : }
598 : }
599 : }
600 : }
601 : else
602 : {
603 0 : eEvent=SDREVENT_MOVACTION;
604 : }
605 : }
606 360 : else if (eHit==SDRHIT_TEXTEDIT)
607 : {
608 3 : eEvent=SDREVENT_TEXTEDIT;
609 : }
610 357 : else if (bMouseDown && bMouseLeft)
611 : {
612 345 : if (rVEvt.nMouseClicks==2 && rVEvt.nMouseCode==MOUSE_LEFT && pObj!=NULL && pHitObj!=NULL && pHitObj->HasTextEdit() && eHit==SDRHIT_MARKEDOBJECT)
613 : {
614 0 : rVEvt.pRootObj=pObj;
615 0 : pObj=pHitObj;
616 0 : eEvent=SDREVENT_BEGTEXTEDIT;
617 : }
618 345 : else if (MODKEY_ForceMark && eHit!=SDRHIT_URLFIELD)
619 : {
620 0 : eEvent=SDREVENT_BEGMARK; // AddMark,Unmark */
621 : }
622 345 : else if (eHit==SDRHIT_HELPLINE)
623 : {
624 0 : eEvent=SDREVENT_BEGDRAGHELPLINE; // nothing, actually
625 : }
626 345 : else if (eHit==SDRHIT_GLUEPOINT)
627 : {
628 0 : eEvent=SDREVENT_MARKGLUEPOINT; // AddMark+Drag
629 0 : rVEvt.bAddMark=MODKEY_MultiMark || MODKEY_DeepMark; // if not hit with Deep
630 : }
631 345 : else if (eHit==SDRHIT_HANDLE)
632 : {
633 3 : eEvent=SDREVENT_BEGDRAGOBJ; // Mark+Drag,AddMark+Drag,DeepMark+Drag,Unmark
634 3 : bool bGlue=pHdl->GetKind()==HDL_GLUE;
635 3 : bool bPoly=!bGlue && IsPointMarkable(*pHdl);
636 3 : bool bMarked=bGlue || (bPoly && pHdl->IsSelected());
637 3 : if (bGlue || bPoly)
638 : {
639 0 : eEvent=bGlue ? SDREVENT_MARKGLUEPOINT : SDREVENT_MARKPOINT;
640 0 : if (MODKEY_DeepMark)
641 : {
642 0 : rVEvt.bAddMark=true;
643 0 : rVEvt.bPrevNextMark=true;
644 0 : rVEvt.bMarkPrev=MODKEY_DeepBackw;
645 : }
646 0 : else if (MODKEY_MultiMark)
647 : {
648 0 : rVEvt.bAddMark=true;
649 0 : rVEvt.bUnmark=bMarked; // Toggle
650 0 : if (bGlue)
651 : {
652 0 : pObj=pHdl->GetObj();
653 0 : nGlueId=(sal_uInt16)pHdl->GetObjHdlNum();
654 : }
655 : }
656 0 : else if (bMarked)
657 : {
658 0 : eEvent=SDREVENT_BEGDRAGOBJ; // don't change MarkState, only change Drag
659 : }
660 : }
661 : }
662 342 : else if (bInsPolyPt && (MODKEY_PolyPoly || (!MODKEY_MultiMark && !MODKEY_DeepMark)))
663 : {
664 0 : eEvent=SDREVENT_BEGINSOBJPOINT;
665 0 : rVEvt.bInsPointNewObj=MODKEY_PolyPoly;
666 : }
667 342 : else if (bInsGluePt && !MODKEY_MultiMark && !MODKEY_DeepMark)
668 : {
669 0 : eEvent=SDREVENT_BEGINSGLUEPOINT;
670 : }
671 342 : else if (eHit==SDRHIT_TEXTEDITOBJ)
672 : {
673 0 : eEvent=SDREVENT_BEGTEXTEDIT; // AddMark+Drag,DeepMark+Drag,Unmark
674 0 : if (MODKEY_MultiMark || MODKEY_DeepMark)
675 : { // if not hit with Deep
676 0 : eEvent=SDREVENT_MARKOBJ;
677 : }
678 : }
679 342 : else if (eHit==SDRHIT_MACRO)
680 : {
681 0 : eEvent=SDREVENT_BEGMACROOBJ; // AddMark+Drag
682 0 : if (MODKEY_MultiMark || MODKEY_DeepMark)
683 : { // if not hit with Deep
684 0 : eEvent=SDREVENT_MARKOBJ;
685 : }
686 : }
687 342 : else if (eHit==SDRHIT_URLFIELD)
688 : {
689 0 : eEvent=SDREVENT_EXECUTEURL; // AddMark+Drag
690 0 : if (MODKEY_MultiMark || MODKEY_DeepMark)
691 : { // if not hit with Deep
692 0 : eEvent=SDREVENT_MARKOBJ;
693 : }
694 : }
695 342 : else if (eHit==SDRHIT_MARKEDOBJECT)
696 : {
697 0 : eEvent=SDREVENT_BEGDRAGOBJ; // DeepMark+Drag,Unmark
698 :
699 0 : if (MODKEY_MultiMark || MODKEY_DeepMark)
700 : { // if not hit with Deep
701 0 : eEvent=SDREVENT_MARKOBJ;
702 : }
703 : }
704 342 : else if (IsCreateMode())
705 : {
706 3 : eEvent=SDREVENT_BEGCREATEOBJ; // nothing, actually
707 : }
708 339 : else if (eHit==SDRHIT_UNMARKEDOBJECT)
709 : {
710 2 : eEvent=SDREVENT_MARKOBJ; // AddMark+Drag
711 : }
712 : else
713 : {
714 337 : eEvent=SDREVENT_BEGMARK;
715 : }
716 :
717 345 : if (eEvent==SDREVENT_MARKOBJ)
718 : {
719 2 : rVEvt.bAddMark=MODKEY_MultiMark || MODKEY_DeepMark; // if not hit with Deep
720 2 : rVEvt.bPrevNextMark=MODKEY_DeepMark;
721 2 : rVEvt.bMarkPrev=MODKEY_DeepMark && MODKEY_DeepBackw;
722 : }
723 345 : if (eEvent==SDREVENT_BEGMARK)
724 : {
725 337 : rVEvt.bAddMark=MODKEY_MultiMark;
726 337 : rVEvt.bUnmark=MODKEY_Unmark;
727 : }
728 : }
729 360 : rVEvt.bIsAction=bIsAction;
730 360 : rVEvt.bIsTextEdit=bIsTextEdit;
731 360 : rVEvt.bTextEditHit=bTextEditHit;
732 360 : rVEvt.aLogicPos=aLocalLogicPosition;
733 360 : rVEvt.pHdl=pHdl;
734 360 : rVEvt.pObj=pObj;
735 360 : if(rVEvt.pRootObj==NULL)
736 360 : rVEvt.pRootObj=pObj;
737 360 : rVEvt.pPV=pPV;
738 360 : rVEvt.nHlplIdx=nHlplIdx;
739 360 : rVEvt.nGlueId=nGlueId;
740 360 : rVEvt.eHit=eHit;
741 360 : rVEvt.eEvent=eEvent;
742 360 : rVEvt.bCaptureMouse=bMouseLeft && bMouseDown && eEvent!=SDREVENT_NONE;
743 360 : rVEvt.bReleaseMouse=bMouseLeft && bMouseUp;
744 : #ifdef DGB_UTIL
745 : if (rVEvt.pRootObj!=NULL) {
746 : if (rVEvt.pRootObj->GetObjList()!=rVEvt.pPV->GetObjList()) {
747 : OSL_FAIL("SdrView::PickAnything(): pRootObj->GetObjList()!=pPV->GetObjList() !");
748 : }
749 : }
750 : #endif
751 360 : return eHit;
752 : }
753 :
754 0 : bool SdrView::DoMouseEvent(const SdrViewEvent& rVEvt)
755 : {
756 0 : bool bRet=false;
757 0 : SdrHitKind eHit=rVEvt.eHit;
758 0 : Point aLogicPos(rVEvt.aLogicPos);
759 :
760 0 : bool bShift=(rVEvt.nMouseCode & KEY_SHIFT) !=0;
761 0 : bool bCtrl=(rVEvt.nMouseCode & KEY_MOD1) !=0;
762 0 : bool bAlt=(rVEvt.nMouseCode & KEY_MOD2) !=0;
763 0 : bool bMouseLeft=(rVEvt.nMouseCode&MOUSE_LEFT)!=0;
764 0 : bool bMouseDown=rVEvt.bMouseDown;
765 0 : bool bMouseUp=rVEvt.bMouseUp;
766 0 : if (bMouseDown) {
767 0 : if (bMouseLeft) aDragStat.SetMouseDown(true);
768 0 : } else if (bMouseUp) {
769 0 : if (bMouseLeft) aDragStat.SetMouseDown(false);
770 : } else { // else, MouseMove
771 0 : aDragStat.SetMouseDown(bMouseLeft);
772 : }
773 :
774 : #ifdef MODKEY_NoSnap
775 0 : SetSnapEnabled(!MODKEY_NoSnap);
776 : #endif
777 : #ifdef MODKEY_Ortho
778 0 : SetOrtho(MODKEY_Ortho!=IsOrthoDesired());
779 : #endif
780 : #ifdef MODKEY_AngleSnap
781 0 : SetAngleSnapEnabled(MODKEY_AngleSnap);
782 : #endif
783 : #ifdef MODKEY_CopyDrag
784 0 : SetDragWithCopy(MODKEY_CopyDrag);
785 : #endif
786 : #ifdef MODKEY_Center
787 0 : SetCreate1stPointAsCenter(MODKEY_Center);
788 0 : SetResizeAtCenter(MODKEY_Center);
789 0 : SetCrookAtCenter(MODKEY_Center);
790 : #endif
791 0 : if (bMouseLeft && bMouseDown && rVEvt.bIsTextEdit && (eHit==SDRHIT_UNMARKEDOBJECT || eHit==SDRHIT_NONE)) {
792 0 : SdrEndTextEdit(); // User has clicked beneath object, exit edit mode.
793 : // pHdl is invalid, then, that shouldn't matter, though, as we expect
794 : // pHdl==NULL (because of eHit).
795 : }
796 0 : switch (rVEvt.eEvent) {
797 0 : case SDREVENT_NONE: bRet=false; break;
798 0 : case SDREVENT_TEXTEDIT: bRet=false; break; // Events handled by the OutlinerView are not taken into account here.
799 0 : case SDREVENT_MOVACTION: MovAction(aLogicPos); bRet=true; break;
800 0 : case SDREVENT_ENDACTION: EndAction(); bRet=true; break;
801 0 : case SDREVENT_BCKACTION: BckAction(); bRet=true; break;
802 0 : case SDREVENT_BRKACTION: BrkAction(); bRet=true; break;
803 0 : case SDREVENT_ENDMARK : EndAction(); bRet=true; break;
804 : case SDREVENT_BRKMARK : {
805 0 : BrkAction();
806 0 : if (!MarkObj(aLogicPos,nHitTolLog,rVEvt.bAddMark)) {
807 : // No object hit. Do the following:
808 : // 1. deselect any selected glue points
809 : // 2. deselect any selected polygon points
810 : // 3. deselect any selected objects
811 0 : if (!rVEvt.bAddMark) UnmarkAll();
812 : }
813 0 : bRet=true;
814 0 : } break;
815 : case SDREVENT_ENDCREATE: { // if necessary, MarkObj
816 0 : SdrCreateCmd eCmd=SDRCREATE_NEXTPOINT;
817 0 : if (MODKEY_PolyPoly) eCmd=SDRCREATE_NEXTOBJECT;
818 0 : if (rVEvt.nMouseClicks>1) eCmd=SDRCREATE_FORCEEND;
819 0 : if (!EndCreateObj(eCmd)) { // Don't evaluate event for Create? -> Select
820 0 : if (eHit==SDRHIT_UNMARKEDOBJECT || eHit==SDRHIT_TEXTEDIT) {
821 0 : MarkObj(rVEvt.pRootObj,rVEvt.pPV);
822 0 : if (eHit==SDRHIT_TEXTEDIT)
823 : {
824 0 : bool bRet2(pActualOutDev && OUTDEV_WINDOW == pActualOutDev->GetOutDevType() &&
825 0 : SdrBeginTextEdit(rVEvt.pObj, rVEvt.pPV, const_cast<vcl::Window*>(static_cast<const vcl::Window*>(pActualOutDev.get())), false, nullptr));
826 :
827 0 : if(bRet2)
828 : {
829 0 : MouseEvent aMEvt(pActualOutDev->LogicToPixel(aLogicPos),
830 0 : 1,rVEvt.nMouseMode,rVEvt.nMouseCode,rVEvt.nMouseCode);
831 :
832 0 : OutlinerView* pOLV=GetTextEditOutlinerView();
833 0 : if (pOLV!=NULL) {
834 0 : pOLV->MouseButtonDown(aMEvt); // event for the Outliner, but without double-click
835 0 : pOLV->MouseButtonUp(aMEvt); // event for the Outliner, but without double-click
836 : }
837 : }
838 : }
839 0 : bRet=true; // object is selected and (if necessary) TextEdit is started
840 0 : } else bRet=false; // canceled Create, nothing else
841 0 : } else bRet=true; // return true for EndCreate
842 0 : } break;
843 : case SDREVENT_ENDDRAG: {
844 0 : bRet=EndDragObj(IsDragWithCopy());
845 0 : ForceMarkedObjToAnotherPage(); // TODO: Undo+bracing missing!
846 0 : } break;
847 : case SDREVENT_MARKOBJ: { // + (if applicable) BegDrag
848 0 : if (!rVEvt.bAddMark) UnmarkAllObj();
849 0 : bool bUnmark=rVEvt.bUnmark;
850 0 : if (rVEvt.bPrevNextMark) {
851 0 : bRet=MarkNextObj(aLogicPos,nHitTolLog,rVEvt.bMarkPrev);
852 : } else {
853 0 : SortMarkedObjects();
854 0 : const size_t nCount0=GetMarkedObjectCount();
855 0 : bRet=MarkObj(aLogicPos,nHitTolLog,rVEvt.bAddMark);
856 0 : SortMarkedObjects();
857 0 : const size_t nCount1=GetMarkedObjectCount();
858 0 : bUnmark=nCount1<nCount0;
859 : }
860 0 : if (!bUnmark) {
861 0 : BegDragObj(aLogicPos,NULL,nullptr,nMinMovLog);
862 0 : bRet=true;
863 : }
864 0 : } break;
865 : case SDREVENT_MARKPOINT: { // + (if applicable) BegDrag
866 0 : if (!rVEvt.bAddMark) UnmarkAllPoints();
867 0 : if (rVEvt.bPrevNextMark) {
868 0 : bRet=MarkNextPoint(aLogicPos,rVEvt.bMarkPrev);
869 : } else {
870 0 : bRet=MarkPoint(*rVEvt.pHdl,rVEvt.bUnmark);
871 : }
872 0 : if (!rVEvt.bUnmark && !rVEvt.bPrevNextMark) {
873 0 : BegDragObj(aLogicPos,NULL,rVEvt.pHdl,nMinMovLog);
874 0 : bRet=true;
875 : }
876 0 : } break;
877 : case SDREVENT_MARKGLUEPOINT: { // + (if applicable) BegDrag
878 0 : if (!rVEvt.bAddMark) UnmarkAllGluePoints();
879 0 : if (rVEvt.bPrevNextMark) {
880 0 : bRet=MarkNextGluePoint(aLogicPos,rVEvt.bMarkPrev);
881 : } else {
882 0 : bRet=MarkGluePoint(rVEvt.pObj,rVEvt.nGlueId,rVEvt.pPV,rVEvt.bUnmark);
883 : }
884 0 : if (!rVEvt.bUnmark && !rVEvt.bPrevNextMark) {
885 0 : SdrHdl* pHdl=GetGluePointHdl(rVEvt.pObj,rVEvt.nGlueId);
886 0 : BegDragObj(aLogicPos,NULL,pHdl,nMinMovLog);
887 0 : bRet=true;
888 : }
889 0 : } break;
890 0 : case SDREVENT_BEGMARK: bRet=BegMark(aLogicPos,rVEvt.bAddMark,rVEvt.bUnmark); break;
891 0 : case SDREVENT_BEGINSOBJPOINT: bRet = BegInsObjPoint(aLogicPos, MODKEY_PolyPoly); break;
892 : case SDREVENT_ENDINSOBJPOINT: {
893 0 : SdrCreateCmd eCmd=SDRCREATE_NEXTPOINT;
894 0 : if (MODKEY_PolyPoly) eCmd=SDRCREATE_NEXTOBJECT;
895 0 : if (rVEvt.nMouseClicks>1) eCmd=SDRCREATE_FORCEEND;
896 0 : EndInsObjPoint(eCmd);
897 0 : bRet=true;
898 0 : } break;
899 0 : case SDREVENT_BEGINSGLUEPOINT: bRet=BegInsGluePoint(aLogicPos); break;
900 0 : case SDREVENT_BEGDRAGHELPLINE: bRet=BegDragHelpLine(rVEvt.nHlplIdx,rVEvt.pPV); break;
901 0 : case SDREVENT_BEGDRAGOBJ: bRet=BegDragObj(aLogicPos,NULL,rVEvt.pHdl,nMinMovLog); break;
902 : case SDREVENT_BEGCREATEOBJ: {
903 0 : if (nAktInvent==SdrInventor && nAktIdent==OBJ_CAPTION) {
904 0 : long nHgt=SdrEngineDefaults::GetFontHeight();
905 0 : bRet=BegCreateCaptionObj(aLogicPos,Size(5*nHgt,2*nHgt));
906 0 : } else bRet=BegCreateObj(aLogicPos);
907 0 : } break;
908 : case SDREVENT_BEGMACROOBJ: {
909 0 : bRet=BegMacroObj(aLogicPos,nHitTolLog,rVEvt.pObj,rVEvt.pPV,const_cast<vcl::Window*>(static_cast<const vcl::Window*>(pActualOutDev.get())));
910 0 : } break;
911 : case SDREVENT_BEGTEXTEDIT: {
912 0 : if (!IsObjMarked(rVEvt.pObj)) {
913 0 : UnmarkAllObj();
914 0 : MarkObj(rVEvt.pRootObj,rVEvt.pPV);
915 : }
916 :
917 0 : bRet = pActualOutDev && OUTDEV_WINDOW == pActualOutDev->GetOutDevType()&&
918 0 : SdrBeginTextEdit(rVEvt.pObj, rVEvt.pPV, const_cast<vcl::Window*>(static_cast<const vcl::Window*>(pActualOutDev.get())), false, nullptr);
919 :
920 0 : if(bRet)
921 : {
922 0 : MouseEvent aMEvt(pActualOutDev->LogicToPixel(aLogicPos),
923 0 : 1,rVEvt.nMouseMode,rVEvt.nMouseCode,rVEvt.nMouseCode);
924 0 : OutlinerView* pOLV=GetTextEditOutlinerView();
925 0 : if (pOLV!=NULL) pOLV->MouseButtonDown(aMEvt); // event for the Outliner, but without double-click
926 : }
927 0 : } break;
928 0 : default: break;
929 : } // switch
930 0 : if (bRet && pActualOutDev && pActualOutDev->GetOutDevType()==OUTDEV_WINDOW) {
931 0 : vcl::Window* pWin=const_cast<vcl::Window*>(static_cast<const vcl::Window*>(pActualOutDev.get()));
932 : // left mouse button pressed?
933 0 : bool bLeftDown=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && rVEvt.bMouseDown;
934 : // left mouse button released?
935 0 : bool bLeftUp=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && rVEvt.bMouseUp;
936 : // left mouse button pressed or held?
937 0 : bool bLeftDown1=(rVEvt.nMouseCode&MOUSE_LEFT)!=0 && !rVEvt.bMouseUp;
938 : pWin->SetPointer(GetPreferredPointer(rVEvt.aLogicPos,pWin,
939 0 : rVEvt.nMouseCode & (KEY_SHIFT|KEY_MOD1|KEY_MOD2),bLeftDown1));
940 0 : bool bAction=IsAction();
941 0 : if (bLeftDown && bAction)
942 0 : pWin->CaptureMouse();
943 0 : else if (bLeftUp || (rVEvt.bIsAction && !bAction))
944 0 : pWin->ReleaseMouse();
945 : }
946 0 : return bRet;
947 : }
948 : #include <editeng/outlobj.hxx>
949 :
950 351 : Pointer SdrView::GetPreferredPointer(const Point& rMousePos, const OutputDevice* pOut, sal_uInt16 nModifier, bool bLeftDown) const
951 : {
952 : // Actions
953 351 : if (IsCreateObj())
954 : {
955 0 : return pAktCreate->GetCreatePointer();
956 : }
957 351 : if (mpCurrentSdrDragMethod)
958 : {
959 5 : if ((IsDraggingPoints() || IsDraggingGluePoints()) && IsMouseHideWhileDraggingPoints())
960 0 : return Pointer(PointerStyle::Null);
961 :
962 5 : return mpCurrentSdrDragMethod->GetSdrDragPointer();
963 : }
964 346 : if (IsMarkObj() || IsMarkPoints() || IsMarkGluePoints() || IsSetPageOrg()) return Pointer(PointerStyle::Arrow);
965 346 : if (IsDragHelpLine()) return GetDraggedHelpLinePointer();
966 346 : if (IsMacroObj()) {
967 0 : SdrObjMacroHitRec aHitRec;
968 0 : aHitRec.aPos=pOut->LogicToPixel(rMousePos);
969 0 : aHitRec.aDownPos=aMacroDownPos;
970 0 : aHitRec.nTol=nMacroTol;
971 0 : aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers();
972 0 : aHitRec.pPageView=pMacroPV;
973 0 : aHitRec.pOut=pMacroWin.get();
974 0 : aHitRec.bDown=bMacroDown;
975 0 : return pMacroObj->GetMacroPointer(aHitRec);
976 : }
977 :
978 : // TextEdit, ObjEdit, Macro
979 346 : if (IsTextEdit() && (IsTextEditInSelectionMode() || IsTextEditHit(rMousePos,0/*nTol*/)))
980 : {
981 1 : if(!pOut || IsTextEditInSelectionMode())
982 : {
983 0 : if(pTextEditOutliner->IsVertical())
984 0 : return Pointer(PointerStyle::TextVertical);
985 : else
986 0 : return Pointer(PointerStyle::Text);
987 : }
988 : // Outliner should return something here...
989 1 : Point aPos(pOut->LogicToPixel(rMousePos));
990 1 : Pointer aPointer(pTextEditOutlinerView->GetPointer(aPos));
991 1 : if (aPointer==PointerStyle::Arrow)
992 : {
993 0 : if(pTextEditOutliner->IsVertical())
994 0 : aPointer = PointerStyle::TextVertical;
995 : else
996 0 : aPointer = PointerStyle::Text;
997 : }
998 1 : return aPointer;
999 : }
1000 :
1001 345 : SdrViewEvent aVEvt;
1002 345 : aVEvt.nMouseCode=(nModifier&(KEY_SHIFT|KEY_MOD1|KEY_MOD2))|MOUSE_LEFT; // to see what would happen on MouseLeftDown
1003 345 : aVEvt.bMouseDown=!bLeftDown; // What if ..?
1004 345 : aVEvt.bMouseUp=bLeftDown; // What if ..?
1005 345 : if (pOut!=NULL)
1006 345 : const_cast<SdrView*>(this)->SetActualWin(pOut);
1007 345 : SdrHitKind eHit=PickAnything(rMousePos,aVEvt);
1008 345 : SdrEventKind eEvent=aVEvt.eEvent;
1009 345 : switch (eEvent)
1010 : {
1011 : case SDREVENT_BEGCREATEOBJ:
1012 3 : return aAktCreatePointer;
1013 : case SDREVENT_MARKOBJ:
1014 1 : return Pointer(PointerStyle::Move);
1015 : case SDREVENT_BEGMARK:
1016 336 : return Pointer(PointerStyle::Arrow);
1017 : case SDREVENT_MARKPOINT:
1018 : case SDREVENT_MARKGLUEPOINT:
1019 0 : return Pointer(PointerStyle::MovePoint);
1020 : case SDREVENT_BEGINSOBJPOINT:
1021 : case SDREVENT_BEGINSGLUEPOINT:
1022 0 : return Pointer(PointerStyle::Cross);
1023 : case SDREVENT_EXECUTEURL:
1024 0 : return Pointer(PointerStyle::RefHand);
1025 : case SDREVENT_BEGMACROOBJ:
1026 : {
1027 0 : SdrObjMacroHitRec aHitRec;
1028 0 : aHitRec.aPos=aVEvt.aLogicPos;
1029 0 : aHitRec.aDownPos=aHitRec.aPos;
1030 0 : aHitRec.nTol=nHitTolLog;
1031 0 : aHitRec.pVisiLayer=&aVEvt.pPV->GetVisibleLayers();
1032 0 : aHitRec.pPageView=aVEvt.pPV;
1033 0 : aHitRec.pOut=const_cast<OutputDevice*>(pOut);
1034 0 : return aVEvt.pObj->GetMacroPointer(aHitRec);
1035 : }
1036 5 : default: break;
1037 : } // switch
1038 :
1039 5 : switch(eHit)
1040 : {
1041 : case SDRHIT_CELL:
1042 0 : return Pointer(PointerStyle::Arrow);
1043 : case SDRHIT_HELPLINE :
1044 0 : return aVEvt.pPV->GetHelpLines()[aVEvt.nHlplIdx].GetPointer();
1045 : case SDRHIT_GLUEPOINT:
1046 0 : return Pointer(PointerStyle::MovePoint);
1047 : case SDRHIT_TEXTEDIT :
1048 : case SDRHIT_TEXTEDITOBJ:
1049 : {
1050 0 : SdrTextObj* pText = dynamic_cast< SdrTextObj* >( aVEvt.pObj );
1051 0 : if(pText && pText->HasText())
1052 : {
1053 0 : OutlinerParaObject* pParaObj = pText->GetOutlinerParaObject();
1054 0 : if(pParaObj && pParaObj->IsVertical())
1055 0 : return Pointer(PointerStyle::TextVertical);
1056 : }
1057 0 : return Pointer(PointerStyle::Text);
1058 : }
1059 5 : default: break;
1060 : }
1061 :
1062 5 : bool bMarkHit=eHit==SDRHIT_MARKEDOBJECT;
1063 5 : SdrHdl* pHdl=aVEvt.pHdl;
1064 : // now check the pointers for dragging
1065 5 : if (pHdl!=NULL || bMarkHit) {
1066 4 : SdrHdlKind eHdl= pHdl!=NULL ? pHdl->GetKind() : HDL_MOVE;
1067 4 : bool bCorner=pHdl!=NULL && pHdl->IsCornerHdl();
1068 4 : bool bVertex=pHdl!=NULL && pHdl->IsVertexHdl();
1069 4 : bool bMov=eHdl==HDL_MOVE;
1070 4 : if (bMov && (eDragMode==SDRDRAG_MOVE || eDragMode==SDRDRAG_RESIZE || mbMarkedHitMovesAlways)) {
1071 0 : if (!IsMoveAllowed()) return Pointer(PointerStyle::Arrow); // because double click or drag & drop is possible
1072 0 : return Pointer(PointerStyle::Move);
1073 : }
1074 4 : switch (eDragMode) {
1075 : case SDRDRAG_ROTATE: {
1076 0 : if ((bCorner || bMov) && !IsRotateAllowed(true))
1077 0 : return Pointer(PointerStyle::NotAllowed);
1078 :
1079 : // are 3D objects selected?
1080 0 : bool b3DObjSelected = false;
1081 0 : for (size_t a=0; !b3DObjSelected && a<GetMarkedObjectCount(); ++a) {
1082 0 : SdrObject* pObj = GetMarkedObjectByIndex(a);
1083 0 : if(pObj && pObj->ISA(E3dObject))
1084 0 : b3DObjSelected = true;
1085 : }
1086 : // If we have a 3D object, go on despite !IsShearAllowed,
1087 : // because then we have a rotation instead of a shear.
1088 0 : if (bVertex && !IsShearAllowed() && !b3DObjSelected)
1089 0 : return Pointer(PointerStyle::NotAllowed);
1090 0 : if (bMov)
1091 0 : return Pointer(PointerStyle::Rotate);
1092 0 : } break;
1093 : case SDRDRAG_SHEAR: case SDRDRAG_DISTORT: {
1094 0 : if (bCorner) {
1095 0 : if (!IsDistortAllowed(true) && !IsDistortAllowed(false)) return Pointer(PointerStyle::NotAllowed);
1096 0 : else return Pointer(PointerStyle::RefHand);
1097 : }
1098 0 : if (bVertex && !IsShearAllowed()) return Pointer(PointerStyle::NotAllowed);
1099 0 : if (bMov) {
1100 0 : if (!IsMoveAllowed()) return Pointer(PointerStyle::Arrow); // because double click or drag & drop is possible
1101 0 : return Pointer(PointerStyle::Move);
1102 : }
1103 0 : } break;
1104 : case SDRDRAG_MIRROR: {
1105 0 : if (bCorner || bVertex || bMov) {
1106 0 : SdrHdl* pH1=maHdlList.GetHdl(HDL_REF1);
1107 0 : SdrHdl* pH2=maHdlList.GetHdl(HDL_REF2);
1108 0 : bool b90=false;
1109 0 : bool b45=false;
1110 0 : Point aDif;
1111 0 : if (pH1!=NULL && pH2!=NULL) {
1112 0 : aDif=pH2->GetPos()-pH1->GetPos();
1113 0 : b90=(aDif.X()==0) || aDif.Y()==0;
1114 0 : b45=b90 || (std::abs(aDif.X())==std::abs(aDif.Y()));
1115 : }
1116 0 : bool bNo=false;
1117 0 : if (!IsMirrorAllowed(true,true)) bNo=true; // any mirroring is forbidden
1118 0 : if (!IsMirrorAllowed(false,false) && !b45) bNo=true; // mirroring freely is forbidden
1119 0 : if (!IsMirrorAllowed(true,false) && !b90) bNo=true; // mirroring horizontally/vertically is allowed
1120 0 : if (bNo) return Pointer(PointerStyle::NotAllowed);
1121 0 : if (b90) {
1122 0 : return Pointer(PointerStyle::Mirror);
1123 : }
1124 0 : return Pointer(PointerStyle::Mirror);
1125 : }
1126 0 : } break;
1127 :
1128 : case SDRDRAG_TRANSPARENCE:
1129 : {
1130 0 : if(!IsTransparenceAllowed())
1131 0 : return Pointer(PointerStyle::NotAllowed);
1132 :
1133 0 : return Pointer(PointerStyle::RefHand);
1134 : }
1135 :
1136 : case SDRDRAG_GRADIENT:
1137 : {
1138 0 : if(!IsGradientAllowed())
1139 0 : return Pointer(PointerStyle::NotAllowed);
1140 :
1141 0 : return Pointer(PointerStyle::RefHand);
1142 : }
1143 :
1144 : case SDRDRAG_CROOK: {
1145 0 : if (bCorner || bVertex || bMov) {
1146 0 : if (!IsCrookAllowed(true) && !IsCrookAllowed(false)) return Pointer(PointerStyle::NotAllowed);
1147 0 : return Pointer(PointerStyle::Crook);
1148 : }
1149 : }
1150 :
1151 : case SDRDRAG_CROP:
1152 : {
1153 0 : return Pointer(PointerStyle::Crop);
1154 : }
1155 :
1156 : default: {
1157 4 : if ((bCorner || bVertex) && !IsResizeAllowed(true)) return Pointer(PointerStyle::NotAllowed);
1158 : }
1159 : }
1160 4 : if (pHdl!=NULL) return pHdl->GetPointer();
1161 0 : if (bMov) {
1162 0 : if (!IsMoveAllowed()) return Pointer(PointerStyle::Arrow); // because double click or drag & drop is possible
1163 0 : return Pointer(PointerStyle::Move);
1164 : }
1165 : }
1166 1 : if (eEditMode==SDREDITMODE_CREATE) return aAktCreatePointer;
1167 1 : return Pointer(PointerStyle::Arrow);
1168 : }
1169 :
1170 : #define STR_NOTHING "nothing"
1171 126 : OUString SdrView::GetStatusText()
1172 : {
1173 126 : OUString aStr;
1174 252 : OUString aName;
1175 :
1176 126 : aStr += STR_NOTHING;
1177 :
1178 126 : if (pAktCreate!=NULL)
1179 : {
1180 0 : aStr=pAktCreate->getSpecialDragComment(aDragStat);
1181 :
1182 0 : if(aStr.isEmpty())
1183 : {
1184 0 : aName = pAktCreate->TakeObjNameSingul();
1185 0 : aStr = ImpGetResStr(STR_ViewCreateObj);
1186 : }
1187 : }
1188 126 : else if (mpCurrentSdrDragMethod)
1189 : {
1190 2 : if (bInsPolyPoint || IsInsertGluePoint())
1191 : {
1192 0 : aStr=maInsPointUndoStr;
1193 : }
1194 : else
1195 : {
1196 2 : if (aDragStat.IsMinMoved())
1197 : {
1198 : SAL_INFO(
1199 : "svx.svdraw",
1200 : "(" << this << ") " << mpCurrentSdrDragMethod);
1201 1 : mpCurrentSdrDragMethod->TakeSdrDragComment(aStr);
1202 : }
1203 : }
1204 : }
1205 124 : else if(IsMarkObj())
1206 : {
1207 0 : if(AreObjectsMarked())
1208 : {
1209 0 : aStr = ImpGetResStr(STR_ViewMarkMoreObjs);
1210 : }
1211 : else
1212 : {
1213 0 : aStr = ImpGetResStr(STR_ViewMarkObjs);
1214 : }
1215 : }
1216 124 : else if(IsMarkPoints())
1217 : {
1218 0 : if(HasMarkedPoints())
1219 : {
1220 0 : aStr = ImpGetResStr(STR_ViewMarkMorePoints);
1221 : }
1222 : else
1223 : {
1224 0 : aStr = ImpGetResStr(STR_ViewMarkPoints);
1225 : }
1226 124 : } else if (IsMarkGluePoints())
1227 : {
1228 0 : if(HasMarkedGluePoints())
1229 : {
1230 0 : aStr = ImpGetResStr(STR_ViewMarkMoreGluePoints);
1231 : }
1232 : else
1233 : {
1234 0 : aStr = ImpGetResStr(STR_ViewMarkGluePoints);
1235 : }
1236 : }
1237 124 : else if (IsTextEdit() && pTextEditOutlinerView!=NULL) {
1238 0 : aStr=ImpGetResStr(STR_ViewTextEdit); // "TextEdit - Row y, Column x";
1239 0 : ESelection aSel(pTextEditOutlinerView->GetSelection());
1240 0 : long nPar=aSel.nEndPara,nLin=0,nCol=aSel.nEndPos;
1241 0 : if (aSel.nEndPara>0) {
1242 0 : for (sal_Int32 nParaNum=0; nParaNum<aSel.nEndPara; nParaNum++) {
1243 0 : nLin+=pTextEditOutliner->GetLineCount(nParaNum);
1244 : }
1245 : }
1246 : // A little imperfection:
1247 : // At the end of a line of any multi-line paragraph, we display the
1248 : // position of the next line of the same paragraph, if there is one.
1249 0 : sal_uInt16 nParaLine = 0;
1250 0 : sal_uIntPtr nParaLineCount = pTextEditOutliner->GetLineCount(aSel.nEndPara);
1251 0 : bool bBrk = false;
1252 0 : while (!bBrk)
1253 : {
1254 0 : sal_uInt16 nLen = pTextEditOutliner->GetLineLen(aSel.nEndPara, nParaLine);
1255 0 : bool bLastLine = (nParaLine == nParaLineCount - 1);
1256 0 : if (nCol>nLen || (!bLastLine && nCol == nLen))
1257 : {
1258 0 : nCol -= nLen;
1259 0 : nLin++;
1260 0 : nParaLine++;
1261 : }
1262 : else
1263 0 : bBrk = true;
1264 :
1265 0 : if (nLen == 0)
1266 0 : bBrk = true; // to be sure
1267 : }
1268 :
1269 0 : aStr = aStr.replaceFirst("%1", OUString::number(nPar + 1));
1270 0 : aStr = aStr.replaceFirst("%2", OUString::number(nLin + 1));
1271 0 : aStr = aStr.replaceFirst("%3", OUString::number(nCol + 1));
1272 :
1273 : #ifdef DBG_UTIL
1274 : aStr += ", Level " ;
1275 : aStr += OUString::number( pTextEditOutliner->GetDepth( aSel.nEndPara ) );
1276 : #endif
1277 : }
1278 :
1279 126 : if(aStr == STR_NOTHING)
1280 : {
1281 125 : if (AreObjectsMarked()) {
1282 1 : ImpTakeDescriptionStr(STR_ViewMarked,aStr);
1283 1 : if (IsGluePointEditMode()) {
1284 0 : if (HasMarkedGluePoints()) {
1285 0 : ImpTakeDescriptionStr(STR_ViewMarked,aStr,0,ImpTakeDescriptionOptions::GLUEPOINTS);
1286 : }
1287 : } else {
1288 1 : if (HasMarkedPoints()) {
1289 0 : ImpTakeDescriptionStr(STR_ViewMarked,aStr,0,ImpTakeDescriptionOptions::POINTS);
1290 : }
1291 : }
1292 : } else {
1293 124 : aStr.clear();
1294 : }
1295 : }
1296 1 : else if(!aName.isEmpty())
1297 : {
1298 0 : aStr = aStr.replaceFirst("%1", aName);
1299 : }
1300 :
1301 126 : if(!aStr.isEmpty())
1302 : {
1303 : // capitalize first letter
1304 2 : aStr = aStr.replaceAt(0, 1, OUString(aStr[0]).toAsciiUpperCase());
1305 : }
1306 252 : return aStr;
1307 : }
1308 :
1309 1067 : SdrViewContext SdrView::GetContext() const
1310 : {
1311 1067 : if( IsGluePointEditMode() )
1312 0 : return SDRCONTEXT_GLUEPOINTEDIT;
1313 :
1314 1067 : const size_t nMarkCount = GetMarkedObjectCount();
1315 :
1316 1067 : if( HasMarkablePoints() && !IsFrameHandles() )
1317 : {
1318 0 : bool bPath=true;
1319 0 : for( size_t nMarkNum = 0; nMarkNum < nMarkCount && bPath; ++nMarkNum )
1320 0 : if (!GetMarkedObjectByIndex(nMarkNum)->ISA(SdrPathObj))
1321 0 : bPath=false;
1322 :
1323 0 : if( bPath )
1324 0 : return SDRCONTEXT_POINTEDIT;
1325 : }
1326 :
1327 1067 : if( GetMarkedObjectCount() )
1328 : {
1329 11 : bool bGraf = true, bMedia = true, bTable = true;
1330 :
1331 22 : for( size_t nMarkNum = 0; nMarkNum < nMarkCount && ( bGraf || bMedia ); ++nMarkNum )
1332 : {
1333 11 : const SdrObject* pMarkObj = GetMarkedObjectByIndex( nMarkNum );
1334 : DBG_ASSERT( pMarkObj, "SdrView::GetContext(), null pointer in mark list!" );
1335 :
1336 11 : if( !pMarkObj )
1337 0 : continue;
1338 :
1339 11 : if( !pMarkObj->ISA( SdrGrafObj ) )
1340 11 : bGraf = false;
1341 :
1342 11 : if( !pMarkObj->ISA( SdrMediaObj ) )
1343 11 : bMedia = false;
1344 :
1345 11 : if( !pMarkObj->ISA( sdr::table::SdrTableObj ) )
1346 11 : bTable = false;
1347 : }
1348 :
1349 11 : if( bGraf )
1350 0 : return SDRCONTEXT_GRAPHIC;
1351 11 : else if( bMedia )
1352 0 : return SDRCONTEXT_MEDIA;
1353 11 : else if( bTable )
1354 0 : return SDRCONTEXT_TABLE;
1355 : }
1356 :
1357 1067 : return SDRCONTEXT_STANDARD;
1358 : }
1359 :
1360 0 : void SdrView::MarkAll()
1361 : {
1362 0 : if (IsTextEdit()) {
1363 0 : GetTextEditOutlinerView()->SetSelection(ESelection(0,0,EE_PARA_ALL,EE_TEXTPOS_ALL));
1364 : #ifdef DBG_UTIL
1365 : if (pItemBrowser!=nullptr) pItemBrowser->SetDirty();
1366 : #endif
1367 0 : } else if (IsGluePointEditMode()) MarkAllGluePoints();
1368 0 : else if (HasMarkablePoints()) MarkAllPoints();
1369 0 : else MarkAllObj();
1370 0 : }
1371 :
1372 3056 : void SdrView::UnmarkAll()
1373 : {
1374 3056 : if (IsTextEdit()) {
1375 1 : ESelection eSel=GetTextEditOutlinerView()->GetSelection();
1376 1 : eSel.nStartPara=eSel.nEndPara;
1377 1 : eSel.nStartPos=eSel.nEndPos;
1378 1 : GetTextEditOutlinerView()->SetSelection(eSel);
1379 : #ifdef DBG_UTIL
1380 : if (pItemBrowser!=nullptr) pItemBrowser->SetDirty();
1381 : #endif
1382 3055 : } else if (HasMarkedGluePoints()) UnmarkAllGluePoints();
1383 3055 : else if (HasMarkedPoints()) UnmarkAllPoints(); // Marked, not Markable!
1384 3055 : else UnmarkAllObj();
1385 3056 : }
1386 :
1387 0 : const Rectangle& SdrView::GetMarkedRect() const
1388 : {
1389 0 : if (IsGluePointEditMode() && HasMarkedGluePoints()) {
1390 0 : return GetMarkedGluePointsRect();
1391 : }
1392 0 : if (HasMarkedPoints()) {
1393 0 : return GetMarkedPointsRect();
1394 : }
1395 0 : return GetMarkedObjRect();
1396 : }
1397 :
1398 1 : void SdrView::DeleteMarked()
1399 : {
1400 1 : if (IsTextEdit())
1401 : {
1402 0 : SdrObjEditView::KeyInput(KeyEvent(0,vcl::KeyCode(KeyFuncType::DELETE)),pTextEditWin);
1403 : }
1404 : else
1405 : {
1406 1 : if( mxSelectionController.is() && mxSelectionController->DeleteMarked() )
1407 : {
1408 : // action already performed by current selection controller, do nothing
1409 : }
1410 1 : else if (IsGluePointEditMode() && HasMarkedGluePoints())
1411 : {
1412 0 : DeleteMarkedGluePoints();
1413 : }
1414 1 : else if (GetContext()==SDRCONTEXT_POINTEDIT && HasMarkedPoints())
1415 : {
1416 0 : DeleteMarkedPoints();
1417 : }
1418 : else
1419 : {
1420 1 : DeleteMarkedObj();
1421 : }
1422 : }
1423 1 : }
1424 :
1425 0 : bool SdrView::BegMark(const Point& rPnt, bool bAddMark, bool bUnmark)
1426 : {
1427 0 : if (bUnmark) bAddMark=true;
1428 0 : if (IsGluePointEditMode()) {
1429 0 : if (!bAddMark) UnmarkAllGluePoints();
1430 0 : return BegMarkGluePoints(rPnt,bUnmark);
1431 0 : } else if (HasMarkablePoints()) {
1432 0 : if (!bAddMark) UnmarkAllPoints();
1433 0 : return BegMarkPoints(rPnt,bUnmark);
1434 : } else {
1435 0 : if (!bAddMark) UnmarkAllObj();
1436 0 : return BegMarkObj(rPnt,bUnmark);
1437 : }
1438 : }
1439 :
1440 165 : void SdrView::ConfigurationChanged( ::utl::ConfigurationBroadcaster*p, sal_uInt32 nHint)
1441 : {
1442 165 : onAccessibilityOptionsChanged();
1443 165 : SdrCreateView::ConfigurationChanged(p, nHint);
1444 165 : }
1445 :
1446 :
1447 : /** method is called whenever the global SvtAccessibilityOptions is changed */
1448 9665 : void SdrView::onAccessibilityOptionsChanged()
1449 : {
1450 9665 : }
1451 :
1452 367 : void SdrView::SetMasterPagePaintCaching(bool bOn)
1453 : {
1454 367 : if(mbMasterPagePaintCaching != bOn)
1455 : {
1456 367 : mbMasterPagePaintCaching = bOn;
1457 :
1458 : // reset at all SdrPageWindows
1459 367 : SdrPageView* pPageView = GetSdrPageView();
1460 :
1461 367 : if(pPageView)
1462 : {
1463 0 : for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1464 : {
1465 0 : SdrPageWindow* pPageWindow = pPageView->GetPageWindow(b);
1466 : assert(pPageWindow && "SdrView::SetMasterPagePaintCaching: Corrupt SdrPageWindow list (!)");
1467 :
1468 : // force deletion of ObjectContact, so at re-display all VOCs
1469 : // will be re-created with updated flag setting
1470 0 : pPageWindow->ResetObjectContact();
1471 : }
1472 :
1473 : // force redraw of this view
1474 0 : pPageView->InvalidateAllWin();
1475 : }
1476 : }
1477 802 : }
1478 :
1479 :
1480 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
