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 "fusel.hxx"
21 : #include <basic/sbstar.hxx>
22 : #include <svx/svddrgmt.hxx>
23 : #include <svx/svdpagv.hxx>
24 : #include <svx/svdogrp.hxx>
25 : #include <svx/polysc3d.hxx>
26 : #include "drawview.hxx"
27 : #include <svtools/imapobj.hxx>
28 : #include <svl/urihelper.hxx>
29 : #include <unotools/localfilehelper.hxx>
30 : #include <svx/svxids.hrc>
31 : #include <svx/xfillit0.hxx>
32 : #include <sfx2/app.hxx>
33 : #include <sfx2/viewfrm.hxx>
34 : #include <svl/aeitem.hxx>
35 : #include <svl/stritem.hxx>
36 : #include <svl/intitem.hxx>
37 : #include <sfx2/dispatch.hxx>
38 : #include <tools/urlobj.hxx>
39 : #include <sfx2/docfile.hxx>
40 : #include <editeng/eeitem.hxx>
41 : #include <editeng/flditem.hxx>
42 :
43 : #include <svx/svdotable.hxx>
44 :
45 : #include "app.hrc"
46 : #include "strings.hrc"
47 : #include "res_bmp.hrc"
48 : #include "GraphicDocShell.hxx"
49 : #include "sdmod.hxx"
50 : #include "DrawDocShell.hxx"
51 : #include "stlpool.hxx"
52 : #include "anminfo.hxx"
53 : #include "fudraw.hxx"
54 : #include "ViewShell.hxx"
55 : #include "ViewShellBase.hxx"
56 : #include "FrameView.hxx"
57 : #include "View.hxx"
58 : #include "Window.hxx"
59 : #include "drawdoc.hxx"
60 : #include "sdpage.hxx"
61 : #include "DrawViewShell.hxx"
62 : #include "ToolBarManager.hxx"
63 : #include "pgjump.hxx"
64 : #include <svx/globl3d.hxx>
65 : #include "Client.hxx"
66 :
67 : #include "slideshow.hxx"
68 :
69 : #include <svx/svdundo.hxx>
70 : #include <avmedia/mediawindow.hxx>
71 :
72 : #include <svx/sdrhittesthelper.hxx>
73 :
74 : #include <LibreOfficeKit/LibreOfficeKitEnums.h>
75 :
76 : using namespace ::com::sun::star;
77 :
78 : namespace sd {
79 :
80 4 : TYPEINIT1( FuSelection, FuDraw );
81 :
82 135 : FuSelection::FuSelection (
83 : ViewShell* pViewSh,
84 : ::sd::Window* pWin,
85 : ::sd::View* pView,
86 : SdDrawDocument* pDoc,
87 : SfxRequest& rReq)
88 : : FuDraw(pViewSh, pWin, pView, pDoc, rReq),
89 : bTempRotation(false),
90 : bSelectionChanged(false),
91 : bHideAndAnimate(false),
92 : pHdl(NULL),
93 : bSuppressChangesOfSelection(false),
94 : bMirrorSide0(false),
95 : nEditMode(SID_BEZIER_MOVE),
96 : pWaterCanCandidate(NULL)
97 : //Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
98 : //and SHIFT+ENTER key to decide the position and draw the new insert point
99 : ,bBeginInsertPoint(false),
100 : oldPoint(0,0)
101 135 : ,bMovedToCenterPoint(false)
102 : {
103 135 : }
104 :
105 135 : rtl::Reference<FuPoor> FuSelection::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
106 : {
107 135 : rtl::Reference<FuPoor> xFunc( new FuSelection( pViewSh, pWin, pView, pDoc, rReq ) );
108 135 : xFunc->DoExecute(rReq);
109 135 : return xFunc;
110 : }
111 :
112 135 : void FuSelection::DoExecute( SfxRequest& rReq )
113 : {
114 135 : FuDraw::DoExecute( rReq );
115 :
116 : // Select object bar
117 135 : SelectionHasChanged();
118 135 : }
119 :
120 405 : FuSelection::~FuSelection()
121 : {
122 135 : mpView->UnmarkAllPoints();
123 135 : mpView->ResetCreationActive();
124 :
125 135 : if ( mpView->GetDragMode() != SDRDRAG_MOVE )
126 : {
127 0 : mpView->SetDragMode(SDRDRAG_MOVE);
128 : }
129 270 : }
130 :
131 1 : bool FuSelection::MouseButtonDown(const MouseEvent& rMEvt)
132 : {
133 : // Hack for #?????#
134 1 : bHideAndAnimate = false;
135 :
136 1 : pHdl = NULL;
137 1 : bool bReturn = FuDraw::MouseButtonDown(rMEvt);
138 1 : bool bWaterCan = SD_MOD()->GetWaterCan();
139 1 : const bool bReadOnly = mpDocSh->IsReadOnly();
140 : // When the right mouse button is pressed then only select objects
141 : // (and deselect others) as a preparation for showing the context
142 : // menu.
143 1 : const bool bSelectionOnly = rMEvt.IsRight();
144 :
145 1 : bMBDown = true;
146 1 : bSelectionChanged = false;
147 :
148 1 : if ( mpView->IsAction() )
149 : {
150 0 : if ( rMEvt.IsRight() )
151 0 : mpView->BckAction();
152 0 : return true;
153 : }
154 :
155 1 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
156 1 : sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
157 :
158 1 : if (mpDoc->isTiledRendering())
159 : {
160 : // When tiled rendering, we always work in logic units, use the non-pixel constants.
161 1 : nDrgLog = DRGLOG;
162 1 : nHitLog = HITLOG;
163 : }
164 :
165 : // The following code is executed for right clicks as well as for left
166 : // clicks in order to modify the selection for the right button as a
167 : // preparation for the context menu. The functions BegMarkObject() and
168 : // BegDragObject(), however, are not called for right clicks because a)
169 : // it makes no sense and b) to have IsAction() return sal_False when called
170 : // from Command() which is a prerequisite for the context menu.
171 2 : if ((rMEvt.IsLeft() || rMEvt.IsRight())
172 1 : && !mpView->IsAction()
173 2 : && (mpView->IsFrameDragSingles() || !mpView->HasMarkablePoints()))
174 : {
175 : /******************************************************************
176 : * NO BEZIER_EDITOR
177 : ******************************************************************/
178 1 : mpWindow->CaptureMouse();
179 1 : pHdl = mpView->PickHandle(aMDPos);
180 : SdrObject* pObj;
181 : SdrPageView* pPV;
182 :
183 1 : long nAngle0 = GetAngle(aMDPos - mpView->GetRef1());
184 1 : nAngle0 -= 27000;
185 1 : nAngle0 = NormAngle360(nAngle0);
186 1 : bMirrorSide0 = nAngle0 < 18000L;
187 :
188 1 : if (!pHdl && mpView->Is3DRotationCreationActive())
189 : {
190 : /******************************************************************
191 : * If 3D-rotation bodies are about to be created,
192 : * end creation now.
193 : ******************************************************************/
194 0 : bSuppressChangesOfSelection = true;
195 0 : mpWindow->EnterWait();
196 0 : mpView->End3DCreation();
197 0 : bSuppressChangesOfSelection = false;
198 0 : mpView->ResetCreationActive();
199 0 : mpWindow->LeaveWait();
200 : }
201 :
202 1 : bool bTextEdit = false;
203 1 : SdrViewEvent aVEvt;
204 1 : SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
205 :
206 1 : if ( eHit == SDRHIT_TEXTEDITOBJ && ( mpViewShell->GetFrameView()->IsQuickEdit() || dynamic_cast< sdr::table::SdrTableObj* >( aVEvt.pObj ) != NULL ) )
207 : {
208 0 : bTextEdit = true;
209 : }
210 :
211 2 : if(!bTextEdit
212 1 : && !mpDocSh->IsReadOnly()
213 1 : && ((mpView->IsMarkedHit(aMDPos, nHitLog) && !rMEvt.IsShift() && !rMEvt.IsMod2()) || pHdl != NULL)
214 1 : && (rMEvt.GetClicks() != 2)
215 : )
216 : {
217 0 : if (!pHdl && mpView->Is3DRotationCreationActive())
218 : {
219 : // Switch between 3D-rotation body -> selection
220 0 : mpView->ResetCreationActive();
221 : }
222 0 : else if (bWaterCan)
223 : {
224 : // Remember the selected object for proper handling in
225 : // MouseButtonUp().
226 0 : pWaterCanCandidate = pickObject (aMDPos);
227 : }
228 : else
229 : {
230 : // hit handle or marked object
231 0 : bFirstMouseMove = true;
232 0 : aDragTimer.Start();
233 : }
234 :
235 0 : if ( ! rMEvt.IsRight())
236 0 : if (mpView->BegDragObj(aMDPos, nullptr, pHdl, nDrgLog))
237 0 : mpView->GetDragMethod()->SetShiftPressed( rMEvt.IsShift() );
238 0 : bReturn = true;
239 : }
240 : else
241 : {
242 1 : if (!rMEvt.IsMod2() && mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SdrSearchOptions::PICKMACRO))
243 : {
244 0 : mpView->BegMacroObj(aMDPos, nHitLog, pObj, pPV, mpWindow);
245 0 : bReturn = true;
246 : }
247 1 : else if ( bTextEdit )
248 : {
249 0 : sal_uInt16 nSdrObjKind = aVEvt.pObj->GetObjIdentifier();
250 :
251 0 : if (aVEvt.pObj->GetObjInventor() == SdrInventor &&
252 0 : (nSdrObjKind == OBJ_TEXT ||
253 0 : nSdrObjKind == OBJ_TITLETEXT ||
254 0 : nSdrObjKind == OBJ_OUTLINETEXT ||
255 0 : !aVEvt.pObj->IsEmptyPresObj()))
256 : {
257 : // Seamless Editing: branch to text input
258 0 : if (!rMEvt.IsShift())
259 0 : mpView->UnmarkAll();
260 :
261 0 : SfxUInt16Item aItem(SID_TEXTEDIT, 1);
262 : mpViewShell->GetViewFrame()->GetDispatcher()->
263 : Execute(SID_TEXTEDIT, SfxCallMode::SYNCHRON |
264 0 : SfxCallMode::RECORD, &aItem, 0L);
265 0 : return bReturn; // CAUTION, due to the synchronous slot the object is deleted now
266 : }
267 : }
268 2 : else if ( !rMEvt.IsMod2() && rMEvt.GetClicks() == 1 &&
269 1 : aVEvt.eEvent == SDREVENT_EXECUTEURL )
270 : {
271 0 : mpWindow->ReleaseMouse();
272 0 : SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.pURLField->GetURL());
273 0 : SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
274 0 : SfxBoolItem aBrowseItem( SID_BROWSE, true );
275 0 : SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
276 0 : mpWindow->ReleaseMouse();
277 :
278 : // If tiled rendering, let client handles URL execution and early returns.
279 0 : if (mpDoc->isTiledRendering())
280 : {
281 : mpDoc->libreOfficeKitCallback(LOK_CALLBACK_HYPERLINK_CLICKED,
282 0 : aVEvt.pURLField->GetURL().toUtf8().getStr());
283 0 : return true;
284 : }
285 :
286 0 : if (rMEvt.IsMod1())
287 : {
288 : // Open in new frame
289 : pFrame->GetDispatcher()->Execute(SID_OPENDOC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
290 0 : &aStrItem, &aBrowseItem, &aReferer, 0L);
291 : }
292 : else
293 : {
294 : // Open in current frame
295 0 : SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
296 : pFrame->GetDispatcher()->Execute(SID_OPENDOC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
297 0 : &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
298 : }
299 :
300 0 : bReturn = true;
301 : }
302 2 : else if(!rMEvt.IsMod2()
303 1 : && mpViewShell->ISA(DrawViewShell)
304 : )
305 : {
306 1 : if(mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SdrSearchOptions::ALSOONMASTER))
307 : {
308 : // Animate object when not just selecting.
309 1 : if ( ! bSelectionOnly)
310 1 : bReturn = AnimateObj(pObj, aMDPos);
311 :
312 1 : if (!bReturn && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dPolyScene)))
313 : {
314 0 : if(rMEvt.GetClicks() == 1)
315 : {
316 : // Look into the group
317 0 : if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SdrSearchOptions::ALSOONMASTER | SdrSearchOptions::DEEP))
318 0 : bReturn = AnimateObj(pObj, aMDPos);
319 : }
320 0 : else if( !bReadOnly && rMEvt.GetClicks() == 2)
321 : {
322 : // New: double click on selected Group object
323 : // enter group
324 0 : if ( ! bSelectionOnly
325 0 : && pObj->GetPage() == pPV->GetPage())
326 0 : bReturn = pPV->EnterGroup(pObj);
327 : }
328 : }
329 : }
330 :
331 : // #i71727# replaced else here with two possibilities, once the original else (!pObj)
332 : // and also ignoring the found object when it's on a masterpage
333 1 : if(!pObj || (pObj->GetPage() && pObj->GetPage()->IsMasterPage()))
334 : {
335 0 : if(mpView->IsGroupEntered() && 2 == rMEvt.GetClicks())
336 : {
337 : // New: double click on empty space/on obj on MasterPage, leave group
338 0 : mpView->LeaveOneGroup();
339 0 : bReturn = true;
340 : }
341 : }
342 : }
343 :
344 1 : if (!bReturn)
345 : {
346 1 : if (bWaterCan)
347 : {
348 0 : if ( ! (rMEvt.IsShift() || rMEvt.IsMod2()))
349 : {
350 : // Find the object under the current mouse position
351 : // and store it for the MouseButtonUp() method to
352 : // evaluate.
353 0 : pWaterCanCandidate = pickObject (aMDPos);
354 : }
355 : }
356 : else
357 : {
358 1 : bReturn = true;
359 1 : bool bDeactivateOLE = false;
360 :
361 1 : if ( !rMEvt.IsShift() && !rMEvt.IsMod2() )
362 : {
363 : OSL_ASSERT (mpViewShell->GetViewShell()!=NULL);
364 : Client* pIPClient = static_cast<Client*>(
365 1 : mpViewShell->GetViewShell()->GetIPClient());
366 :
367 1 : if (pIPClient && pIPClient->IsObjectInPlaceActive())
368 : {
369 : // OLE-Objekt gets deactivated in subsequent UnmarkAll()
370 0 : bDeactivateOLE = true;
371 : }
372 :
373 1 : mpView->UnmarkAll();
374 : }
375 :
376 1 : bool bMarked = false;
377 :
378 1 : if ( !rMEvt.IsMod1() && !bDeactivateOLE)
379 : {
380 1 : if ( rMEvt.IsMod2() )
381 : {
382 0 : bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift() );
383 : }
384 : else
385 : {
386 1 : bool bToggle = false;
387 :
388 1 : if (rMEvt.IsShift() && mpView->GetMarkedObjectList().GetMarkCount() > 1)
389 : {
390 : // No Toggle on single selection
391 0 : bToggle = true;
392 : }
393 :
394 1 : bMarked = mpView->MarkObj(aMDPos, nHitLog, bToggle, false);
395 : }
396 : }
397 :
398 1 : if( !bDeactivateOLE )
399 : {
400 3 : if ( !bReadOnly &&
401 3 : bMarked &&
402 1 : (!rMEvt.IsShift() || mpView->IsMarkedHit(aMDPos, nHitLog)))
403 : {
404 : /**********************************************************
405 : * Move object
406 : **********************************************************/
407 1 : aDragTimer.Start();
408 :
409 1 : pHdl=mpView->PickHandle(aMDPos);
410 1 : if ( ! rMEvt.IsRight())
411 1 : mpView->BegDragObj(aMDPos, nullptr, pHdl, nDrgLog);
412 : }
413 : else
414 : {
415 : /**********************************************************
416 : * Select object
417 : **********************************************************/
418 0 : if ( ! rMEvt.IsRight())
419 0 : mpView->BegMarkObj(aMDPos);
420 : }
421 : }
422 :
423 1 : if( bMarked && bTempRotation && (nSlotId == SID_OBJECT_ROTATE) && !rMEvt.IsShift() && (rMEvt.GetClicks() != 2) )
424 : {
425 0 : nSlotId = SID_OBJECT_SELECT;
426 0 : Activate();
427 : }
428 : }
429 : }
430 1 : }
431 : }
432 0 : else if ( !bReadOnly
433 0 : && (rMEvt.IsLeft() || rMEvt.IsRight())
434 0 : && !mpView->IsAction())
435 : {
436 : /**********************************************************************
437 : * BEZIER-EDITOR
438 : **********************************************************************/
439 0 : mpWindow->CaptureMouse();
440 0 : SdrViewEvent aVEvt;
441 0 : SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
442 :
443 0 : if (eHit == SDRHIT_HANDLE && aVEvt.pHdl->GetKind() == HDL_BWGT)
444 : {
445 : /******************************************************************
446 : * Drag Handle
447 : ******************************************************************/
448 0 : if ( ! rMEvt.IsRight())
449 0 : mpView->BegDragObj(aMDPos, nullptr, aVEvt.pHdl, nDrgLog);
450 : }
451 0 : else if (eHit == SDRHIT_MARKEDOBJECT && nEditMode == SID_BEZIER_INSERT)
452 : {
453 : /******************************************************************
454 : * Insert glue point
455 : ******************************************************************/
456 0 : mpView->BegInsObjPoint(aMDPos, rMEvt.IsMod1());
457 : }
458 0 : else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
459 : {
460 : /******************************************************************
461 : * Select glue point
462 : ******************************************************************/
463 0 : if (!rMEvt.IsShift())
464 0 : mpView->UnmarkAllPoints();
465 :
466 0 : if ( ! rMEvt.IsRight())
467 0 : mpView->BegMarkPoints(aMDPos);
468 : }
469 0 : else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
470 : {
471 : /******************************************************************
472 : * Move object
473 : ******************************************************************/
474 0 : if ( ! rMEvt.IsRight())
475 0 : mpView->BegDragObj(aMDPos, nullptr, NULL, nDrgLog);
476 : }
477 0 : else if (eHit == SDRHIT_HANDLE)
478 : {
479 : /******************************************************************
480 : * Select glue point
481 : ******************************************************************/
482 0 : if (!mpView->IsPointMarked(*aVEvt.pHdl) || rMEvt.IsShift())
483 : {
484 0 : if (!rMEvt.IsShift())
485 : {
486 0 : mpView->UnmarkAllPoints();
487 0 : pHdl = mpView->PickHandle(aMDPos);
488 : }
489 : else
490 : {
491 0 : if (mpView->IsPointMarked(*aVEvt.pHdl))
492 : {
493 0 : mpView->UnmarkPoint(*aVEvt.pHdl);
494 0 : pHdl = NULL;
495 : }
496 : else
497 : {
498 0 : pHdl = mpView->PickHandle(aMDPos);
499 : }
500 : }
501 :
502 0 : if (pHdl)
503 : {
504 0 : mpView->MarkPoint(*pHdl);
505 0 : if ( ! rMEvt.IsRight())
506 0 : mpView->BegDragObj(aMDPos, nullptr, pHdl, nDrgLog);
507 :
508 : }
509 : }
510 : else
511 : {
512 : // Point IS marked and NO shift is pressed. Start
513 : // dragging of selected point(s)
514 0 : pHdl = mpView->PickHandle(aMDPos);
515 0 : if(pHdl)
516 0 : if ( ! rMEvt.IsRight())
517 0 : mpView->BegDragObj(aMDPos, nullptr, pHdl, nDrgLog);
518 : }
519 : }
520 : else
521 : {
522 : /******************************************************************
523 : * Select or drag object
524 : ******************************************************************/
525 0 : if (!rMEvt.IsShift() && !rMEvt.IsMod2() && eHit == SDRHIT_UNMARKEDOBJECT)
526 : {
527 0 : mpView->UnmarkAllObj();
528 : }
529 :
530 0 : bool bMarked = false;
531 :
532 0 : if (!rMEvt.IsMod1())
533 : {
534 0 : if (rMEvt.IsMod2())
535 : {
536 0 : bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift());
537 : }
538 : else
539 : {
540 0 : bMarked = mpView->MarkObj(aMDPos, nHitLog, rMEvt.IsShift(), false);
541 : }
542 : }
543 :
544 0 : if (bMarked &&
545 0 : (!rMEvt.IsShift() || eHit == SDRHIT_MARKEDOBJECT))
546 : {
547 : // Move object
548 0 : if ( ! rMEvt.IsRight())
549 0 : mpView->BegDragObj(aMDPos, nullptr, aVEvt.pHdl, nDrgLog);
550 : }
551 0 : else if (mpView->AreObjectsMarked())
552 : {
553 : /**************************************************************
554 : * Select glue point
555 : **************************************************************/
556 0 : if (!rMEvt.IsShift())
557 0 : mpView->UnmarkAllPoints();
558 :
559 0 : if ( ! rMEvt.IsRight())
560 0 : mpView->BegMarkPoints(aMDPos);
561 : }
562 : else
563 : {
564 : /**************************************************************
565 : * Select object
566 : **************************************************************/
567 0 : if ( ! rMEvt.IsRight())
568 0 : mpView->BegMarkObj(aMDPos);
569 : }
570 :
571 0 : ForcePointer(&rMEvt);
572 0 : }
573 : }
574 :
575 1 : if (!bIsInDragMode)
576 : {
577 1 : ForcePointer(&rMEvt);
578 : }
579 :
580 1 : return bReturn;
581 : }
582 :
583 2 : bool FuSelection::MouseMove(const MouseEvent& rMEvt)
584 : {
585 2 : bool bReturn = FuDraw::MouseMove(rMEvt);
586 :
587 2 : if (aDragTimer.IsActive())
588 : {
589 1 : if(bFirstMouseMove)
590 : {
591 0 : bFirstMouseMove = false;
592 : }
593 : else
594 : {
595 1 : aDragTimer.Stop();
596 : }
597 : }
598 :
599 2 : if (mpView->IsAction())
600 : {
601 2 : Point aPix(rMEvt.GetPosPixel());
602 2 : Point aPnt(mpWindow->PixelToLogic(aPix));
603 :
604 2 : ForceScroll(aPix);
605 :
606 2 : if (mpView->IsInsObjPoint())
607 : {
608 0 : mpView->MovInsObjPoint(aPnt);
609 : }
610 : else
611 : {
612 2 : mpView->MovAction(aPnt);
613 : }
614 : }
615 :
616 2 : ForcePointer(&rMEvt);
617 :
618 2 : return bReturn;
619 : }
620 :
621 1 : bool FuSelection::MouseButtonUp(const MouseEvent& rMEvt)
622 : {
623 1 : bool bReturn = false;
624 : // When the right mouse button is pressed then only select objects
625 : // (and deselect others) as a preparation for showing the context
626 : // menu.
627 1 : const bool bSelectionOnly = rMEvt.IsRight();
628 : SdrObject* pObj;
629 : SdrPageView* pPV;
630 :
631 1 : if (bHideAndAnimate)
632 : {
633 : // Animation is still running -> return immediately
634 0 : bHideAndAnimate = false;
635 0 : pHdl = NULL;
636 0 : mpWindow->ReleaseMouse();
637 0 : return true;
638 : }
639 :
640 1 : if (aDragTimer.IsActive() )
641 : {
642 0 : aDragTimer.Stop();
643 0 : bIsInDragMode = false;
644 : }
645 :
646 1 : if( !mpView )
647 0 : return false;
648 :
649 1 : Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
650 1 : sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
651 1 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
652 :
653 1 : if (mpView->IsFrameDragSingles() || !mpView->HasMarkablePoints())
654 : {
655 : /**********************************************************************
656 : * NO BEZIER_EDITOR
657 : **********************************************************************/
658 1 : if ( mpView->IsDragObj() )
659 : {
660 : /******************************************************************
661 : * Object was moved
662 : ******************************************************************/
663 1 : FrameView* pFrameView = mpViewShell->GetFrameView();
664 1 : bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
665 :
666 1 : if (bDragWithCopy)
667 : {
668 0 : bDragWithCopy = !mpView->IsPresObjSelected(false, true);
669 : }
670 :
671 1 : mpView->SetDragWithCopy(bDragWithCopy);
672 1 : mpView->EndDragObj( mpView->IsDragWithCopy() );
673 :
674 1 : mpView->ForceMarkedToAnotherPage();
675 :
676 4 : if (!rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() &&
677 1 : !bSelectionChanged &&
678 1 : std::abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
679 0 : std::abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
680 : {
681 : /*************************************************************
682 : * If a user wants to click on an object in front of a marked
683 : * one, he releases the mouse button immediately
684 : **************************************************************/
685 0 : if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SdrSearchOptions::ALSOONMASTER | SdrSearchOptions::BEFOREMARK))
686 : {
687 0 : mpView->UnmarkAllObj();
688 0 : mpView->MarkObj(pObj,pPV,false,false);
689 0 : return true;
690 : }
691 : /**************************************************************
692 : * Toggle between selection and rotation
693 : **************************************************************/
694 0 : SdrObject* pSingleObj = NULL;
695 :
696 0 : if (mpView->GetMarkedObjectList().GetMarkCount()==1)
697 : {
698 0 : pSingleObj = mpView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
699 : }
700 :
701 0 : if (nSlotId == SID_OBJECT_SELECT
702 0 : && mpView->IsRotateAllowed()
703 :
704 0 : && (rMEvt.GetClicks() != 2)
705 0 : && (mpViewShell->GetFrameView()->IsClickChangeRotation()
706 0 : || (pSingleObj
707 0 : && pSingleObj->GetObjInventor()==E3dInventor))
708 0 : && ! bSelectionOnly)
709 :
710 : {
711 0 : bTempRotation = true;
712 0 : nSlotId = SID_OBJECT_ROTATE;
713 0 : Activate();
714 : }
715 0 : else if (nSlotId == SID_OBJECT_ROTATE)
716 : {
717 0 : nSlotId = SID_OBJECT_SELECT;
718 0 : Activate();
719 : }
720 : }
721 1 : else if (nSlotId == SID_CONVERT_TO_3D_LATHE)
722 : {
723 0 : if (!pHdl)
724 : {
725 0 : bSuppressChangesOfSelection = true;
726 0 : mpView->Start3DCreation();
727 0 : bSuppressChangesOfSelection = false;
728 : }
729 0 : else if (pHdl->GetKind() != HDL_MIRX &&
730 0 : pHdl->GetKind() != HDL_REF1 &&
731 0 : pHdl->GetKind() != HDL_REF2 && mpView->Is3DRotationCreationActive())
732 : {
733 : /*********************************************************
734 : * If 3D-rotation bodies are about to be created,
735 : * end creation now
736 : **********************************************************/
737 0 : long nAngle1 = GetAngle(aPnt - mpView->GetRef1());
738 0 : nAngle1 -= 27000;
739 0 : nAngle1 = NormAngle360(nAngle1);
740 0 : bool bMirrorSide1 = nAngle1 < 18000L;
741 :
742 0 : if (bMirrorSide0 != bMirrorSide1)
743 : {
744 0 : bSuppressChangesOfSelection = true;
745 0 : mpWindow->EnterWait();
746 0 : mpView->End3DCreation();
747 0 : bSuppressChangesOfSelection = false;
748 0 : nSlotId = SID_OBJECT_SELECT;
749 0 : mpWindow->LeaveWait();
750 0 : Activate();
751 : }
752 : }
753 : }
754 : }
755 0 : else if (rMEvt.IsMod1()
756 0 : && !rMEvt.IsMod2()
757 0 : && std::abs(aPnt.X() - aMDPos.X()) < nDrgLog
758 0 : && std::abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
759 : {
760 : // Enter group
761 0 : mpView->MarkObj(aPnt, nHitLog, rMEvt.IsShift(), rMEvt.IsMod1());
762 : }
763 :
764 1 : if (mpView->IsAction() )
765 : {
766 0 : mpView->EndAction();
767 : }
768 :
769 1 : if( SD_MOD()->GetWaterCan() )
770 : {
771 0 : if( rMEvt.IsRight() )
772 : {
773 : // In watering-can mode, on press onto right mouse button, a undo is executed
774 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_UNDO, SfxCallMode::ASYNCHRON );
775 : }
776 0 : else if (pWaterCanCandidate != NULL)
777 : {
778 : // Is the candidate object still under the mouse?
779 0 : if (pickObject (aPnt) == pWaterCanCandidate)
780 : {
781 : SdStyleSheetPool* pPool = static_cast<SdStyleSheetPool*>(
782 0 : mpDocSh->GetStyleSheetPool());
783 0 : if (pPool != NULL)
784 : {
785 : SfxStyleSheet* pStyleSheet = static_cast<SfxStyleSheet*>(
786 0 : pPool->GetActualStyleSheet());
787 0 : if (pStyleSheet != NULL && mpView->IsUndoEnabled() )
788 : {
789 : // Added UNDOs for the WaterCan mode. This was never done in
790 : // the past, thus it was missing all the time.
791 0 : SdrUndoAction* pUndoAttr = mpDoc->GetSdrUndoFactory().CreateUndoAttrObject(*pWaterCanCandidate, true, true);
792 0 : mpView->BegUndo(pUndoAttr->GetComment());
793 0 : mpView->AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoGeoObject(*pWaterCanCandidate));
794 0 : mpView->AddUndo(pUndoAttr);
795 :
796 0 : pWaterCanCandidate->SetStyleSheet (pStyleSheet, false);
797 :
798 0 : mpView->EndUndo();
799 : }
800 : }
801 : }
802 : }
803 : // else when there has been no object under the mouse when the
804 : // button was pressed then nothing happens even when there is
805 : // one now.
806 : }
807 :
808 1 : sal_uInt16 nClicks = rMEvt.GetClicks();
809 :
810 1 : if (nClicks == 2 && rMEvt.IsLeft() && bMBDown &&
811 1 : !rMEvt.IsMod1() && !rMEvt.IsShift() )
812 : {
813 0 : DoubleClick(rMEvt);
814 : }
815 :
816 1 : bMBDown = false;
817 :
818 1 : ForcePointer(&rMEvt);
819 1 : pHdl = NULL;
820 1 : mpWindow->ReleaseMouse();
821 1 : SdrObject* pSingleObj = NULL;
822 1 : const size_t nMarkCount = mpView->GetMarkedObjectList().GetMarkCount();
823 :
824 1 : if (nMarkCount==1)
825 : {
826 1 : pSingleObj = mpView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
827 : }
828 :
829 3 : if ( (nSlotId != SID_OBJECT_SELECT && nMarkCount==0) ||
830 1 : ( mpView->GetDragMode() == SDRDRAG_CROOK &&
831 1 : !mpView->IsCrookAllowed( mpView->IsCrookNoContortion() ) ) ||
832 1 : ( mpView->GetDragMode() == SDRDRAG_SHEAR &&
833 2 : !mpView->IsShearAllowed() && !mpView->IsDistortAllowed() ) ||
834 1 : ( nSlotId==SID_CONVERT_TO_3D_LATHE && pSingleObj &&
835 0 : (pSingleObj->GetObjInventor() != SdrInventor ||
836 0 : pSingleObj->GetObjIdentifier() == OBJ_MEASURE) ) )
837 : {
838 0 : bReturn = true;
839 0 : ForcePointer(&rMEvt);
840 0 : pHdl = NULL;
841 0 : mpWindow->ReleaseMouse();
842 0 : FuDraw::MouseButtonUp(rMEvt);
843 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::SYNCHRON);
844 0 : return bReturn; // CAUTION, due to the synchronous slot, the object is deleted now.
845 : }
846 :
847 1 : FuDraw::MouseButtonUp(rMEvt);
848 : }
849 : else
850 : {
851 : /**********************************************************************
852 : * BEZIER_EDITOR
853 : **********************************************************************/
854 0 : if ( mpView->IsAction() )
855 : {
856 0 : if ( mpView->IsInsObjPoint() )
857 : {
858 0 : mpView->EndInsObjPoint(SDRCREATE_FORCEEND);
859 : }
860 0 : else if ( mpView->IsDragObj() )
861 : {
862 0 : FrameView* pFrameView = mpViewShell->GetFrameView();
863 0 : bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
864 :
865 0 : if (bDragWithCopy)
866 : {
867 0 : bDragWithCopy = !mpView->IsPresObjSelected(false, true);
868 : }
869 :
870 0 : mpView->SetDragWithCopy(bDragWithCopy);
871 0 : mpView->EndDragObj( mpView->IsDragWithCopy() );
872 : }
873 : else
874 : {
875 0 : mpView->EndAction();
876 :
877 0 : sal_uInt16 nDrgLog2 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
878 0 : Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
879 :
880 0 : if (std::abs(aMDPos.X() - aPos.X()) < nDrgLog2 &&
881 0 : std::abs(aMDPos.Y() - aPos.Y()) < nDrgLog2 &&
882 0 : !rMEvt.IsShift() && !rMEvt.IsMod2())
883 : {
884 0 : SdrViewEvent aVEvt;
885 0 : SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
886 :
887 0 : if (eHit == SDRHIT_NONE)
888 : {
889 : // Click on the same place - unselect
890 0 : mpView->UnmarkAllObj();
891 0 : }
892 : }
893 : }
894 : }
895 0 : else if (!rMEvt.IsShift() && rMEvt.IsMod1() && !rMEvt.IsMod2() &&
896 0 : std::abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
897 0 : std::abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
898 : {
899 : // Enter group
900 0 : mpView->MarkObj(aPnt, nHitLog, false, rMEvt.IsMod1());
901 : }
902 :
903 0 : ForcePointer(&rMEvt);
904 0 : pHdl = NULL;
905 0 : mpWindow->ReleaseMouse();
906 :
907 0 : FuDraw::MouseButtonUp(rMEvt);
908 : }
909 :
910 1 : return bReturn;
911 : }
912 :
913 : /**
914 : * Process keyboard input
915 : * @returns sal_True if a KeyEvent is being processed, sal_False otherwise
916 : */
917 0 : bool FuSelection::KeyInput(const KeyEvent& rKEvt)
918 : {
919 0 : bool bReturn = false;
920 :
921 0 : switch (rKEvt.GetKeyCode().GetCode())
922 : {
923 : case KEY_ESCAPE:
924 : {
925 0 : bReturn = FuSelection::cancel();
926 : }
927 0 : break;
928 : //add keyboard operation for insert points in drawing curve
929 : case KEY_UP:
930 : case KEY_DOWN:
931 : case KEY_LEFT:
932 : case KEY_RIGHT:
933 : {
934 0 : if(rKEvt.GetKeyCode().IsShift()&&(nEditMode == SID_BEZIER_INSERT)){
935 0 : long nX = 0;
936 0 : long nY = 0;
937 0 : sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
938 0 : if (nCode == KEY_UP)
939 : {
940 : // Scroll nach oben
941 0 : nX = 0;
942 0 : nY =-1;
943 : }
944 0 : else if (nCode == KEY_DOWN)
945 : {
946 : // Scroll nach unten
947 0 : nX = 0;
948 0 : nY = 1;
949 : }
950 0 : else if (nCode == KEY_LEFT)
951 : {
952 : // Scroll nach links
953 0 : nX =-1;
954 0 : nY = 0;
955 : }
956 0 : else if (nCode == KEY_RIGHT)
957 : {
958 : // Scroll nach rechts
959 0 : nX = 1;
960 0 : nY = 0;
961 : }
962 :
963 0 : Point centerPoint;
964 0 : Rectangle rect = mpView->GetMarkedObjRect();
965 0 : centerPoint = mpWindow->LogicToPixel(rect.Center());
966 0 : Point aPoint = bMovedToCenterPoint? oldPoint:centerPoint;
967 0 : Point ePoint = aPoint + Point(nX,nY);
968 0 : mpWindow->SetPointerPosPixel(ePoint);
969 : //simulate mouse move action
970 0 : MouseEvent eMevt(ePoint, 1, MouseEventModifiers::DRAGMOVE, MOUSE_LEFT, 0);
971 0 : MouseMove(eMevt);
972 0 : oldPoint = ePoint;
973 0 : bMovedToCenterPoint = true;
974 0 : bReturn = true;
975 : }
976 : }
977 0 : break;
978 : case KEY_RETURN:
979 0 : if(rKEvt.GetKeyCode().IsShift()&&(nEditMode == SID_BEZIER_INSERT))
980 : {
981 0 : if(!bBeginInsertPoint)
982 : {
983 : //simulate mouse button down action
984 : MouseEvent aMevt(oldPoint, 1,
985 0 : MouseEventModifiers::SIMPLEMOVE | MouseEventModifiers::DRAGMOVE,
986 0 : MOUSE_LEFT, KEY_SHIFT);
987 0 : MouseButtonDown(aMevt);
988 0 : mpWindow->CaptureMouse();
989 0 : bBeginInsertPoint = true;
990 : }
991 : else
992 : {
993 : //simulate mouse button up action
994 : MouseEvent rMEvt(oldPoint, 1,
995 0 : MouseEventModifiers::SIMPLEMOVE | MouseEventModifiers::ENTERWINDOW,
996 0 : MOUSE_LEFT, KEY_SHIFT);
997 0 : MouseButtonUp(rMEvt);
998 0 : bBeginInsertPoint = false;
999 : }
1000 0 : bReturn= true;
1001 : }
1002 0 : break;
1003 : }
1004 0 : if (!bReturn)
1005 : {
1006 0 : bReturn = FuDraw::KeyInput(rKEvt);
1007 :
1008 0 : if(mpView->GetMarkedObjectList().GetMarkCount() == 0)
1009 : {
1010 0 : mpView->ResetCreationActive();
1011 :
1012 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
1013 : }
1014 : }
1015 :
1016 0 : return bReturn;
1017 :
1018 : }
1019 :
1020 337 : void FuSelection::Activate()
1021 : {
1022 : SdrDragMode eMode;
1023 337 : mpView->ResetCreationActive();
1024 337 : mpView->SetEditMode(SDREDITMODE_EDIT);
1025 :
1026 337 : switch( nSlotId )
1027 : {
1028 : case SID_OBJECT_ROTATE:
1029 : {
1030 : // (mapped) Slot is explicitly set to rotate
1031 0 : if( mpViewShell->ISA(DrawViewShell) )
1032 : {
1033 : sal_uInt16* pSlotArray =
1034 0 : static_cast<DrawViewShell*>(mpViewShell)->GetSlotArray();
1035 0 : pSlotArray[ 1 ] = SID_OBJECT_ROTATE;
1036 : }
1037 :
1038 0 : eMode = SDRDRAG_ROTATE;
1039 :
1040 0 : if ( mpView->GetDragMode() != eMode )
1041 0 : mpView->SetDragMode(eMode);
1042 : }
1043 0 : break;
1044 :
1045 : case SID_OBJECT_MIRROR:
1046 : {
1047 0 : eMode = SDRDRAG_MIRROR;
1048 :
1049 0 : if ( mpView->GetDragMode() != eMode )
1050 0 : mpView->SetDragMode(eMode);
1051 : }
1052 0 : break;
1053 :
1054 : case SID_OBJECT_CROP:
1055 : {
1056 0 : eMode = SDRDRAG_CROP;
1057 :
1058 0 : if ( mpView->GetDragMode() != eMode )
1059 0 : mpView->SetDragMode(eMode);
1060 : }
1061 0 : break;
1062 :
1063 : case SID_OBJECT_TRANSPARENCE:
1064 : {
1065 0 : eMode = SDRDRAG_TRANSPARENCE;
1066 :
1067 0 : if ( mpView->GetDragMode() != eMode )
1068 0 : mpView->SetDragMode(eMode);
1069 : }
1070 0 : break;
1071 :
1072 : case SID_OBJECT_GRADIENT:
1073 : {
1074 0 : eMode = SDRDRAG_GRADIENT;
1075 :
1076 0 : if ( mpView->GetDragMode() != eMode )
1077 0 : mpView->SetDragMode(eMode);
1078 : }
1079 0 : break;
1080 :
1081 : case SID_OBJECT_SHEAR:
1082 : {
1083 0 : eMode = SDRDRAG_SHEAR;
1084 :
1085 0 : if ( mpView->GetDragMode() != eMode )
1086 0 : mpView->SetDragMode(eMode);
1087 : }
1088 0 : break;
1089 :
1090 : case SID_OBJECT_CROOK_ROTATE:
1091 : {
1092 0 : eMode = SDRDRAG_CROOK;
1093 :
1094 0 : if ( mpView->GetDragMode() != eMode )
1095 : {
1096 0 : mpView->SetDragMode(eMode);
1097 0 : mpView->SetCrookMode(SDRCROOK_ROTATE);
1098 : }
1099 : }
1100 0 : break;
1101 :
1102 : case SID_OBJECT_CROOK_SLANT:
1103 : {
1104 0 : eMode = SDRDRAG_CROOK;
1105 :
1106 0 : if ( mpView->GetDragMode() != eMode )
1107 : {
1108 0 : mpView->SetDragMode(eMode);
1109 0 : mpView->SetCrookMode(SDRCROOK_SLANT);
1110 : }
1111 : }
1112 0 : break;
1113 :
1114 : case SID_OBJECT_CROOK_STRETCH:
1115 : {
1116 0 : eMode = SDRDRAG_CROOK;
1117 :
1118 0 : if ( mpView->GetDragMode() != eMode )
1119 : {
1120 0 : mpView->SetDragMode(eMode);
1121 0 : mpView->SetCrookMode(SDRCROOK_STRETCH);
1122 : }
1123 : }
1124 0 : break;
1125 :
1126 : case SID_CONVERT_TO_3D_LATHE:
1127 : {
1128 0 : eMode = SDRDRAG_MIRROR;
1129 0 : bSuppressChangesOfSelection = true;
1130 :
1131 0 : if ( mpView->GetDragMode() != eMode )
1132 0 : mpView->SetDragMode(eMode);
1133 :
1134 0 : if (!mpView->Is3DRotationCreationActive())
1135 0 : mpView->Start3DCreation();
1136 :
1137 0 : bSuppressChangesOfSelection = false;
1138 : }
1139 0 : break;
1140 :
1141 : default:
1142 : {
1143 337 : eMode = SDRDRAG_MOVE;
1144 :
1145 337 : if ( mpView->GetDragMode() != eMode )
1146 0 : mpView->SetDragMode(eMode);
1147 : }
1148 337 : break;
1149 : }
1150 :
1151 337 : if (nSlotId != SID_OBJECT_ROTATE)
1152 : {
1153 337 : bTempRotation = false;
1154 : }
1155 :
1156 337 : FuDraw::Activate();
1157 337 : }
1158 :
1159 293 : void FuSelection::Deactivate()
1160 : {
1161 293 : FuDraw::Deactivate();
1162 293 : }
1163 :
1164 139 : void FuSelection::SelectionHasChanged()
1165 : {
1166 139 : bSelectionChanged = true;
1167 :
1168 139 : FuDraw::SelectionHasChanged();
1169 :
1170 139 : if ((mpView->Is3DRotationCreationActive() && !bSuppressChangesOfSelection))
1171 : {
1172 : // Switch rotation body -> selection
1173 0 : mpView->ResetCreationActive();
1174 0 : nSlotId = SID_OBJECT_SELECT;
1175 0 : Activate();
1176 : }
1177 :
1178 : // Activate the right tool bar for the current context of the view.
1179 139 : mpViewShell->GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*mpViewShell, *mpView);
1180 139 : }
1181 :
1182 : /**
1183 : * Set current bezier edit mode
1184 : */
1185 0 : void FuSelection::SetEditMode(sal_uInt16 nMode)
1186 : {
1187 0 : nEditMode = nMode;
1188 :
1189 0 : if (nEditMode == SID_BEZIER_INSERT)
1190 : {
1191 0 : mpView->SetInsObjPointMode(true);
1192 : }
1193 : else
1194 : {
1195 0 : mpView->SetInsObjPointMode(false);
1196 : }
1197 :
1198 0 : ForcePointer();
1199 :
1200 0 : SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings();
1201 0 : rBindings.Invalidate(SID_BEZIER_MOVE);
1202 0 : rBindings.Invalidate(SID_BEZIER_INSERT);
1203 0 : }
1204 :
1205 : /**
1206 : * Execute animation or interaction
1207 : */
1208 1 : bool FuSelection::AnimateObj(SdrObject* pObj, const Point& rPos)
1209 : {
1210 1 : bool bAnimated = false;
1211 1 : bool bClosed = pObj->IsClosedObj();
1212 1 : bool bFilled = false;
1213 :
1214 1 : if (bClosed)
1215 : {
1216 1 : SfxItemSet aSet(mpDoc->GetPool());
1217 :
1218 1 : aSet.Put(pObj->GetMergedItemSet());
1219 :
1220 1 : const XFillStyleItem& rFillStyle = static_cast<const XFillStyleItem&>( aSet.Get(XATTR_FILLSTYLE) );
1221 1 : bFilled = rFillStyle.GetValue() != drawing::FillStyle_NONE;
1222 : }
1223 :
1224 1 : const SetOfByte* pVisiLayer = &mpView->GetSdrPageView()->GetVisibleLayers();
1225 1 : sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
1226 1 : const long n2HitLog = nHitLog * 2;
1227 1 : Point aHitPosR(rPos);
1228 1 : Point aHitPosL(rPos);
1229 1 : Point aHitPosT(rPos);
1230 1 : Point aHitPosB(rPos);
1231 :
1232 1 : aHitPosR.X() += n2HitLog;
1233 1 : aHitPosL.X() -= n2HitLog;
1234 1 : aHitPosT.Y() += n2HitLog;
1235 1 : aHitPosB.Y() -= n2HitLog;
1236 :
1237 3 : if ( !bClosed ||
1238 2 : !bFilled ||
1239 2 : (SdrObjectPrimitiveHit(*pObj, aHitPosR, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
1240 2 : SdrObjectPrimitiveHit(*pObj, aHitPosL, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
1241 1 : SdrObjectPrimitiveHit(*pObj, aHitPosT, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
1242 0 : SdrObjectPrimitiveHit(*pObj, aHitPosB, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) ) )
1243 : {
1244 0 : if ( mpDoc->GetIMapInfo( pObj ) )
1245 : {
1246 0 : const IMapObject* pIMapObj = mpDoc->GetHitIMapObject( pObj, rPos, *mpWindow );
1247 :
1248 0 : if ( pIMapObj && !pIMapObj->GetURL().isEmpty() )
1249 : {
1250 : // Jump to Document
1251 0 : mpWindow->ReleaseMouse();
1252 0 : SfxStringItem aStrItem(SID_FILE_NAME, pIMapObj->GetURL());
1253 0 : SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
1254 0 : SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
1255 0 : SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
1256 0 : SfxBoolItem aBrowseItem( SID_BROWSE, true );
1257 0 : mpWindow->ReleaseMouse();
1258 : pFrame->GetDispatcher()->
1259 : Execute(SID_OPENDOC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
1260 0 : &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
1261 :
1262 0 : bAnimated = true;
1263 : }
1264 : }
1265 0 : else if (!mpDocSh->ISA(GraphicDocShell) &&
1266 0 : mpView->ISA(DrawView) &&
1267 0 : mpDoc->GetAnimationInfo(pObj))
1268 : {
1269 : /**********************************************************
1270 : * Animation-object hit in the middle -> interaction
1271 : **********************************************************/
1272 0 : SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
1273 0 : DrawViewShell* pDrViewSh = static_cast<DrawViewShell*>(mpViewShell);
1274 0 : mpWindow->ReleaseMouse();
1275 :
1276 0 : switch (pInfo->meClickAction)
1277 : {
1278 : case presentation::ClickAction_BOOKMARK:
1279 : {
1280 : // Jump to Bookmark (Page or Object)
1281 0 : SfxStringItem aItem(SID_NAVIGATOR_OBJECT, pInfo->GetBookmark());
1282 : mpViewShell->GetViewFrame()->GetDispatcher()->
1283 0 : Execute(SID_NAVIGATOR_OBJECT, SfxCallMode::SLOT | SfxCallMode::RECORD, &aItem, 0L);
1284 0 : bAnimated = true;
1285 : }
1286 0 : break;
1287 :
1288 : case presentation::ClickAction_DOCUMENT:
1289 : {
1290 0 : OUString sBookmark( pInfo->GetBookmark() );
1291 : // Jump to document
1292 0 : if (!sBookmark.isEmpty())
1293 : {
1294 0 : SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
1295 0 : SfxStringItem aStrItem(SID_FILE_NAME, sBookmark);
1296 0 : SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
1297 0 : SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
1298 0 : SfxBoolItem aBrowseItem( SID_BROWSE, true );
1299 : pFrame->GetDispatcher()->
1300 : Execute(SID_OPENDOC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
1301 0 : &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
1302 : }
1303 :
1304 0 : bAnimated = true;
1305 : }
1306 0 : break;
1307 :
1308 : case presentation::ClickAction_PREVPAGE:
1309 : {
1310 : // Jump to the previous page
1311 0 : SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_PREVIOUS);
1312 : mpViewShell->GetViewFrame()->GetDispatcher()->
1313 : Execute(SID_NAVIGATOR_PAGE, SfxCallMode::SLOT | SfxCallMode::RECORD,
1314 0 : &aItem, 0L);
1315 0 : bAnimated = true;
1316 : }
1317 0 : break;
1318 :
1319 : case presentation::ClickAction_NEXTPAGE:
1320 : {
1321 : // Jump to the next page
1322 0 : SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_NEXT);
1323 : mpViewShell->GetViewFrame()->GetDispatcher()->
1324 : Execute(SID_NAVIGATOR_PAGE, SfxCallMode::SLOT | SfxCallMode::RECORD,
1325 0 : &aItem, 0L);
1326 0 : bAnimated = true;
1327 : }
1328 0 : break;
1329 :
1330 : case presentation::ClickAction_FIRSTPAGE:
1331 : {
1332 : // Jump to the first page
1333 0 : SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_FIRST);
1334 : mpViewShell->GetViewFrame()->GetDispatcher()->
1335 : Execute(SID_NAVIGATOR_PAGE, SfxCallMode::SLOT | SfxCallMode::RECORD,
1336 0 : &aItem, 0L);
1337 0 : bAnimated = true;
1338 : }
1339 0 : break;
1340 :
1341 : case presentation::ClickAction_LASTPAGE:
1342 : {
1343 : // Jump to the last page
1344 0 : SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_LAST);
1345 : mpViewShell->GetViewFrame()->GetDispatcher()->
1346 : Execute(SID_NAVIGATOR_PAGE, SfxCallMode::SLOT | SfxCallMode::RECORD,
1347 0 : &aItem, 0L);
1348 0 : bAnimated = true;
1349 : }
1350 0 : break;
1351 :
1352 : case presentation::ClickAction_SOUND:
1353 : {
1354 : try
1355 : {
1356 0 : mxPlayer.set( avmedia::MediaWindow::createPlayer( pInfo->GetBookmark(), ""/*TODO?*/), uno::UNO_QUERY_THROW );
1357 0 : mxPlayer->start();
1358 : }
1359 0 : catch( uno::Exception& )
1360 : {
1361 : }
1362 0 : bAnimated = true;
1363 : }
1364 0 : break;
1365 :
1366 : case presentation::ClickAction_VERB:
1367 : {
1368 : // Assign verb
1369 0 : mpView->UnmarkAll();
1370 0 : mpView->MarkObj(pObj, mpView->GetSdrPageView(), false, false);
1371 0 : pDrViewSh->DoVerb((sal_Int16)pInfo->mnVerb);
1372 0 : bAnimated = true;
1373 : }
1374 0 : break;
1375 :
1376 : case presentation::ClickAction_PROGRAM:
1377 : {
1378 0 : OUString aBaseURL = GetDocSh()->GetMedium()->GetBaseURL();
1379 : INetURLObject aURL( ::URIHelper::SmartRel2Abs( INetURLObject(aBaseURL), pInfo->GetBookmark(),
1380 : URIHelper::GetMaybeFileHdl(), true, false,
1381 0 : INetURLObject::WAS_ENCODED, INetURLObject::DECODE_UNAMBIGUOUS ) );
1382 :
1383 0 : if( INetProtocol::File == aURL.GetProtocol() )
1384 : {
1385 0 : SfxStringItem aUrl( SID_FILE_NAME, aURL.GetMainURL( INetURLObject::NO_DECODE ) );
1386 0 : SfxBoolItem aBrowsing( SID_BROWSE, true );
1387 :
1388 0 : SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1389 0 : if (pViewFrm)
1390 : pViewFrm->GetDispatcher()->Execute( SID_OPENDOC,
1391 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
1392 : &aUrl,
1393 : &aBrowsing,
1394 0 : 0L );
1395 : }
1396 :
1397 0 : bAnimated = true;
1398 : }
1399 0 : break;
1400 :
1401 : case presentation::ClickAction_MACRO:
1402 : {
1403 : // Execute macro
1404 0 : OUString aMacro = pInfo->GetBookmark();
1405 :
1406 0 : if ( SfxApplication::IsXScriptURL( aMacro ) )
1407 : {
1408 0 : uno::Any aRet;
1409 0 : uno::Sequence< sal_Int16 > aOutArgsIndex;
1410 0 : uno::Sequence< uno::Any > aOutArgs;
1411 : uno::Sequence< uno::Any >* pInArgs =
1412 0 : new uno::Sequence< uno::Any >(0);
1413 :
1414 : ErrCode eErr = mpDocSh->CallXScript( aMacro,
1415 0 : *pInArgs, aRet, aOutArgsIndex, aOutArgs);
1416 :
1417 : // Check the return value from the script
1418 0 : bool bTmp = false;
1419 0 : if ( eErr == ERRCODE_NONE &&
1420 0 : aRet.getValueType() == cppu::UnoType<bool>::get() &&
1421 0 : ( aRet >>= bTmp ) &&
1422 : bTmp )
1423 : {
1424 0 : bAnimated = true;
1425 : }
1426 : else
1427 : {
1428 0 : bAnimated = false;
1429 0 : }
1430 : }
1431 : else
1432 : {
1433 : // aMacro has got following format:
1434 : // "Macroname.Modulname.Libname.Documentname" or
1435 : // "Macroname.Modulname.Libname.Applicationname"
1436 0 : OUString aMacroName = aMacro.getToken(0, '.');
1437 0 : OUString aModulName = aMacro.getToken(1, '.');
1438 :
1439 : // In this moment the Call-method only
1440 : // resolves modulename+macroname
1441 0 : OUString aExecMacro(aModulName + "." + aMacroName);
1442 0 : bAnimated = mpDocSh->GetBasic()->Call(aExecMacro);
1443 0 : }
1444 : }
1445 0 : break;
1446 :
1447 : default:
1448 : {
1449 0 : bAnimated = false;
1450 : }
1451 0 : break;
1452 : }
1453 : }
1454 :
1455 0 : if (!bAnimated &&
1456 0 : mpView->ISA(DrawView) &&
1457 0 : !mpDocSh->ISA(GraphicDocShell) &&
1458 0 : SlideShow::IsRunning( mpViewShell->GetViewShellBase() ) &&
1459 0 : mpDoc->GetAnimationInfo(pObj))
1460 : {
1461 : /**********************************************************
1462 : * Effect-Object hit in the middle -> Play effect
1463 : **********************************************************/
1464 0 : SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
1465 :
1466 0 : switch (pInfo->meClickAction)
1467 : {
1468 : case presentation::ClickAction_VANISH:
1469 : case presentation::ClickAction_INVISIBLE:
1470 0 : break;
1471 :
1472 : default:
1473 0 : bAnimated = false;
1474 0 : break;
1475 : }
1476 : }
1477 : }
1478 :
1479 1 : return bAnimated;
1480 : }
1481 :
1482 : /** is called when the current function should be aborted. <p>
1483 : This is used when a function gets a KEY_ESCAPE but can also
1484 : be called directly.
1485 :
1486 : @returns true if a active function was aborted
1487 : */
1488 0 : bool FuSelection::cancel()
1489 : {
1490 0 : if (mpView->Is3DRotationCreationActive())
1491 : {
1492 0 : mpView->ResetCreationActive();
1493 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
1494 0 : return true;
1495 : }
1496 : else
1497 : {
1498 0 : return false;
1499 : }
1500 : }
1501 :
1502 0 : SdrObject* FuSelection::pickObject (const Point& rTestPoint)
1503 : {
1504 0 : SdrObject* pObject = NULL;
1505 : SdrPageView* pPageView;
1506 0 : sal_uInt16 nHitLog = sal_uInt16 (mpWindow->PixelToLogic(Size(HITPIX,0)).Width());
1507 0 : mpView->PickObj (rTestPoint, nHitLog, pObject, pPageView, SdrSearchOptions::PICKMARKABLE);
1508 0 : return pObject;
1509 : }
1510 :
1511 345 : void FuSelection::ForcePointer(const MouseEvent* pMEvt)
1512 : {
1513 345 : if(bMovedToCenterPoint && !bBeginInsertPoint && pMEvt)
1514 : {
1515 0 : MouseEvent aMEvt(pMEvt->GetPosPixel(), pMEvt->GetClicks(),
1516 0 : pMEvt->GetMode(), pMEvt->GetButtons(), pMEvt->GetModifier() & ~KEY_SHIFT);
1517 0 : FuDraw::ForcePointer(&aMEvt);
1518 : }
1519 : else
1520 : {
1521 345 : FuDraw::ForcePointer(pMEvt);
1522 : }
1523 345 : }
1524 :
1525 66 : } // end of namespace sd
1526 :
1527 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
