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 "fupoor.hxx"
21 :
22 : #include <svx/svxids.hrc>
23 : #include <svl/aeitem.hxx>
24 : #include <svx/svdpagv.hxx>
25 : #include <svx/svdoole2.hxx>
26 : #include <svx/svdograf.hxx>
27 : #include <vcl/seleng.hxx>
28 : #include <sfx2/app.hxx>
29 : #include <sfx2/dispatch.hxx>
30 : #include <sfx2/bindings.hxx>
31 : #include <sfx2/request.hxx>
32 : #include <vcl/dialog.hxx>
33 : #include <com/sun/star/beans/XPropertySet.hpp>
34 : #include <com/sun/star/drawing/XLayer.hpp>
35 : #include <com/sun/star/drawing/XLayerManager.hpp>
36 : #include <com/sun/star/container/XChild.hpp>
37 :
38 : #include "FrameView.hxx"
39 : #include "app.hrc"
40 : #include "fusel.hxx"
41 : #include "sdpage.hxx"
42 : #include "drawview.hxx"
43 : #include "DrawViewShell.hxx"
44 : #include "Window.hxx"
45 : #include "drawdoc.hxx"
46 : #include "DrawDocShell.hxx"
47 : #include "zoomlist.hxx"
48 : #include "Client.hxx"
49 : #include "slideshow.hxx"
50 : #include "LayerTabBar.hxx"
51 :
52 : #include <sfx2/viewfrm.hxx>
53 :
54 : #include <svx/svditer.hxx>
55 :
56 : #include <editeng/editeng.hxx>
57 :
58 : using namespace ::com::sun::star;
59 : using ::com::sun::star::uno::Reference;
60 :
61 : namespace sd {
62 :
63 0 : TYPEINIT0( FuPoor );
64 :
65 : /*************************************************************************
66 : |*
67 : |* Konstruktor
68 : |*
69 : \************************************************************************/
70 :
71 0 : FuPoor::FuPoor (
72 : ViewShell* pViewSh,
73 : ::sd::Window* pWin,
74 : ::sd::View* pView,
75 : SdDrawDocument* pDrDoc,
76 : SfxRequest& rReq)
77 : : mpView(pView),
78 : mpViewShell(pViewSh),
79 : mpWindow(pWin),
80 0 : mpDocSh( pDrDoc->GetDocSh() ),
81 : mpDoc(pDrDoc),
82 0 : nSlotId( rReq.GetSlot() ),
83 : nSlotValue(0),
84 : pDialog(NULL),
85 : bIsInDragMode(sal_False),
86 : bNoScrollUntilInside (sal_True),
87 : bScrollable (sal_False),
88 : bDelayActive (sal_False),
89 : bFirstMouseMove (sal_False),
90 : // remember MouseButton state
91 0 : mnCode(0)
92 : {
93 0 : ReceiveRequest(rReq);
94 :
95 0 : aScrollTimer.SetTimeoutHdl( LINK(this, FuPoor, ScrollHdl) );
96 0 : aScrollTimer.SetTimeout(SELENG_AUTOREPEAT_INTERVAL);
97 :
98 0 : aDragTimer.SetTimeoutHdl( LINK(this, FuPoor, DragHdl) );
99 0 : aDragTimer.SetTimeout(SELENG_DRAGDROP_TIMEOUT);
100 :
101 0 : aDelayToScrollTimer.SetTimeoutHdl( LINK(this, FuPoor, DelayHdl) );
102 0 : aDelayToScrollTimer.SetTimeout(2000);
103 0 : }
104 :
105 : /*************************************************************************
106 : |*
107 : |* Destruktor
108 : |*
109 : \************************************************************************/
110 :
111 0 : FuPoor::~FuPoor()
112 : {
113 0 : aDragTimer.Stop();
114 0 : aScrollTimer.Stop();
115 0 : aDelayToScrollTimer.Stop ();
116 :
117 0 : if (pDialog)
118 0 : delete pDialog;
119 0 : }
120 :
121 : /*************************************************************************
122 : |*
123 : |* Function aktivieren
124 : |*
125 : \************************************************************************/
126 :
127 0 : void FuPoor::Activate()
128 : {
129 0 : if (pDialog)
130 : {
131 0 : pDialog->Show();
132 : }
133 0 : }
134 :
135 : /*************************************************************************
136 : |*
137 : |* Function deaktivieren
138 : |*
139 : \************************************************************************/
140 :
141 0 : void FuPoor::Deactivate()
142 : {
143 0 : aDragTimer.Stop();
144 0 : aScrollTimer.Stop();
145 0 : aDelayToScrollTimer.Stop ();
146 : bScrollable =
147 0 : bDelayActive = sal_False;
148 :
149 0 : if (pDialog)
150 : {
151 0 : pDialog->Hide();
152 : }
153 :
154 0 : if (mpWindow) mpWindow->ReleaseMouse ();
155 0 : }
156 :
157 : /*************************************************************************
158 : |*
159 : |* Scrollen bei Erreichen des Fensterrandes; wird von
160 : |* MouseMove aufgerufen
161 : |*
162 : \************************************************************************/
163 :
164 0 : void FuPoor::ForceScroll(const Point& aPixPos)
165 : {
166 0 : aScrollTimer.Stop();
167 :
168 0 : if ( !mpView->IsDragHelpLine() && !mpView->IsSetPageOrg() &&
169 0 : !SlideShow::IsRunning( mpViewShell->GetViewShellBase() ) )
170 : {
171 0 : Point aPos = mpWindow->OutputToScreenPixel(aPixPos);
172 0 : const Rectangle& rRect = mpViewShell->GetAllWindowRect();
173 :
174 0 : if ( bNoScrollUntilInside )
175 : {
176 0 : if ( rRect.IsInside(aPos) )
177 0 : bNoScrollUntilInside = sal_False;
178 : }
179 : else
180 : {
181 0 : short dx = 0, dy = 0;
182 :
183 0 : if ( aPos.X() <= rRect.Left() ) dx = -1;
184 0 : if ( aPos.X() >= rRect.Right() ) dx = 1;
185 0 : if ( aPos.Y() <= rRect.Top() ) dy = -1;
186 0 : if ( aPos.Y() >= rRect.Bottom() ) dy = 1;
187 :
188 0 : if ( dx != 0 || dy != 0 )
189 : {
190 0 : if (bScrollable)
191 : {
192 : // Scrollaktion in abgeleiteter Klasse
193 0 : mpViewShell->ScrollLines(dx, dy);
194 0 : aScrollTimer.Start();
195 : }
196 0 : else if (! bDelayActive) StartDelayToScrollTimer ();
197 : }
198 : }
199 : }
200 0 : }
201 :
202 : /*************************************************************************
203 : |*
204 : |* Timer-Handler fuer Fensterscrolling
205 : |*
206 : \************************************************************************/
207 :
208 0 : IMPL_LINK_NOARG_INLINE_START(FuPoor, ScrollHdl)
209 : {
210 0 : Point aPnt(mpWindow->GetPointerPosPixel());
211 :
212 : // use remembered MouseButton state to create correct
213 : // MouseEvents for this artifical MouseMove.
214 0 : MouseMove(MouseEvent(aPnt, 1, 0, GetMouseButtonCode()));
215 :
216 0 : return 0;
217 : }
218 0 : IMPL_LINK_INLINE_END( FuPoor, ScrollHdl, Timer *, pTimer )
219 :
220 : /*************************************************************************
221 : |*
222 : |* Tastaturereignisse bearbeiten
223 : |*
224 : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
225 : |* sal_False.
226 : |*
227 : \************************************************************************/
228 :
229 0 : sal_Bool FuPoor::KeyInput(const KeyEvent& rKEvt)
230 : {
231 0 : sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
232 0 : sal_Bool bReturn = sal_False;
233 0 : sal_Bool bSlideShow = SlideShow::IsRunning( mpViewShell->GetViewShellBase() );
234 :
235 0 : switch (nCode)
236 : {
237 : case KEY_RETURN:
238 : {
239 0 : if(rKEvt.GetKeyCode().IsMod1())
240 : {
241 0 : if(mpViewShell && mpViewShell->ISA(DrawViewShell))
242 : {
243 : DrawViewShell* pDrawViewShell =
244 0 : static_cast<DrawViewShell*>(mpViewShell);
245 0 : SdPage* pActualPage = pDrawViewShell->GetActualPage();
246 0 : SdrTextObj* pCandidate = 0L;
247 :
248 0 : if(pActualPage)
249 : {
250 0 : SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS);
251 :
252 0 : while(aIter.IsMore() && !pCandidate)
253 : {
254 0 : SdrObject* pObj = aIter.Next();
255 :
256 0 : if(pObj && pObj->ISA(SdrTextObj))
257 : {
258 0 : sal_uInt32 nInv(pObj->GetObjInventor());
259 0 : sal_uInt16 nKnd(pObj->GetObjIdentifier());
260 :
261 0 : if(SdrInventor == nInv &&
262 : (OBJ_TITLETEXT == nKnd || OBJ_OUTLINETEXT == nKnd || OBJ_TEXT == nKnd))
263 : {
264 0 : pCandidate = (SdrTextObj*)pObj;
265 : }
266 : }
267 0 : }
268 : }
269 :
270 0 : if(pCandidate)
271 : {
272 0 : mpView->UnMarkAll();
273 0 : mpView->MarkObj(pCandidate, mpView->GetSdrPageView());
274 :
275 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
276 0 : SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON);
277 : }
278 : else
279 : {
280 : // insert a new page with the same page layout
281 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
282 0 : SID_INSERTPAGE_QUICK, SFX_CALLMODE_ASYNCHRON);
283 : }
284 :
285 : // consumed
286 0 : bReturn = sal_True;
287 : }
288 : }
289 : else
290 : {
291 : // activate OLE object on RETURN for selected object
292 : // activate text edit on RETURN for selected object
293 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
294 :
295 0 : if( !mpView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
296 : {
297 0 : SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
298 :
299 0 : if( pObj && pObj->ISA( SdrOle2Obj ) && !mpDocSh->IsUIActive() )
300 : {
301 : //HMHmpView->HideMarkHdl();
302 0 : mpViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
303 : }
304 0 : else if( pObj && pObj->IsEmptyPresObj() && pObj->ISA( SdrGrafObj ) )
305 : {
306 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_GRAPHIC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
307 : }
308 : else
309 : {
310 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
311 : }
312 :
313 : // consumed
314 0 : bReturn = sal_True;
315 : }
316 : }
317 : }
318 0 : break;
319 :
320 : case KEY_TAB:
321 : {
322 : // handle Mod1 and Mod2 to get travelling running on different systems
323 0 : if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
324 : {
325 : // do something with a selected handle?
326 0 : const SdrHdlList& rHdlList = mpView->GetHdlList();
327 0 : sal_Bool bForward(!rKEvt.GetKeyCode().IsShift());
328 :
329 0 : ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
330 :
331 : // guarantee visibility of focused handle
332 0 : SdrHdl* pHdl = rHdlList.GetFocusHdl();
333 :
334 0 : if(pHdl)
335 : {
336 0 : Point aHdlPosition(pHdl->GetPos());
337 0 : Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
338 0 : mpView->MakeVisible(aVisRect, *mpWindow);
339 : }
340 :
341 : // consumed
342 0 : bReturn = sal_True;
343 : }
344 : }
345 0 : break;
346 :
347 : case KEY_ESCAPE:
348 : {
349 0 : bReturn = FuPoor::cancel();
350 : }
351 0 : break;
352 :
353 : case KEY_ADD:
354 : {
355 0 : if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
356 : {
357 : // Zoom vergroessern
358 0 : mpViewShell->SetZoom(mpWindow->GetZoom() * 3 / 2);
359 :
360 0 : if (mpViewShell->ISA(DrawViewShell))
361 : static_cast<DrawViewShell*>(mpViewShell)
362 0 : ->SetZoomOnPage(sal_False);
363 :
364 0 : bReturn = sal_True;
365 : }
366 : }
367 0 : break;
368 :
369 : case KEY_SUBTRACT:
370 : {
371 0 : if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
372 : {
373 : // Zoom verringern
374 0 : mpViewShell->SetZoom(mpWindow->GetZoom() * 2 / 3);
375 :
376 0 : if (mpViewShell->ISA(DrawViewShell))
377 : static_cast<DrawViewShell*>(mpViewShell)
378 0 : ->SetZoomOnPage(sal_False);
379 :
380 0 : bReturn = sal_True;
381 : }
382 : }
383 0 : break;
384 :
385 : case KEY_MULTIPLY:
386 : {
387 0 : if (!mpView->IsTextEdit() && !bSlideShow)
388 : {
389 : // Zoom auf Seite
390 : mpViewShell->GetViewFrame()->GetDispatcher()->
391 0 : Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
392 0 : bReturn = sal_True;
393 : }
394 : }
395 0 : break;
396 :
397 : case KEY_DIVIDE:
398 : {
399 0 : if (!mpView->IsTextEdit() && !bSlideShow)
400 : {
401 : // Zoom auf selektierte Objekte
402 : mpViewShell->GetViewFrame()->GetDispatcher()->
403 0 : Execute(SID_SIZE_OPTIMAL, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
404 0 : bReturn = sal_True;
405 : }
406 : }
407 0 : break;
408 :
409 : case KEY_POINT:
410 : {
411 0 : ZoomList* pZoomList = mpViewShell->GetZoomList();
412 :
413 0 : if (!mpView->IsTextEdit() && pZoomList->IsNextPossible() && !bSlideShow && !mpDocSh->IsUIActive())
414 : {
415 : // Naechstes ZoomRect einstellen
416 0 : mpViewShell->SetZoomRect(pZoomList->GetNextZoomRect());
417 0 : bReturn = sal_True;
418 : }
419 : }
420 0 : break;
421 :
422 : case KEY_COMMA:
423 : {
424 0 : ZoomList* pZoomList = mpViewShell->GetZoomList();
425 :
426 0 : if (!mpView->IsTextEdit() && pZoomList->IsPreviousPossible() && !bSlideShow && !mpDocSh->IsUIActive())
427 : {
428 : // Vorheriges ZoomRect einstellen
429 0 : mpViewShell->SetZoomRect(pZoomList->GetPreviousZoomRect());
430 0 : bReturn = sal_True;
431 : }
432 : }
433 0 : break;
434 :
435 : case KEY_HOME:
436 : {
437 0 : if (!mpView->IsTextEdit()
438 0 : && mpViewShell->ISA(DrawViewShell)
439 : && !bSlideShow)
440 : {
441 : // Sprung zu erster Seite
442 0 : static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(0);
443 0 : bReturn = sal_True;
444 : }
445 : }
446 0 : break;
447 :
448 : case KEY_END:
449 : {
450 0 : if (!mpView->IsTextEdit()
451 0 : && mpViewShell->ISA(DrawViewShell)
452 : && !bSlideShow)
453 : {
454 : // Sprung zu letzter Seite
455 : SdPage* pPage =
456 0 : static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
457 : static_cast<DrawViewShell*>(mpViewShell)
458 : ->SwitchPage(mpDoc->GetSdPageCount(
459 0 : pPage->GetPageKind()) - 1);
460 0 : bReturn = sal_True;
461 : }
462 : }
463 0 : break;
464 :
465 : case KEY_PAGEUP:
466 : {
467 0 : if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
468 0 : break;
469 :
470 0 : if(mpViewShell->ISA(DrawViewShell) && !bSlideShow)
471 : {
472 : // The page-up key switches layers or pages depending on the
473 : // modifier key.
474 0 : if ( ! rKEvt.GetKeyCode().GetAllModifier())
475 : {
476 : // With no modifier pressed we move to the previous
477 : // slide.
478 0 : mpView->SdrEndTextEdit();
479 :
480 : // Previous page.
481 0 : bReturn = sal_True;
482 0 : SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
483 0 : sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;
484 :
485 0 : if (nSdPage > 0)
486 : {
487 : // Switch the page and send events regarding
488 : // deactivation the old page and activating the new
489 : // one.
490 : TabControl* pPageTabControl =
491 : static_cast<DrawViewShell*>(mpViewShell)
492 0 : ->GetPageTabControl();
493 0 : if (pPageTabControl->IsReallyShown())
494 0 : pPageTabControl->SendDeactivatePageEvent ();
495 0 : static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage - 1);
496 0 : if (pPageTabControl->IsReallyShown())
497 0 : pPageTabControl->SendActivatePageEvent ();
498 : }
499 : }
500 0 : else if (rKEvt.GetKeyCode().IsMod1())
501 : {
502 : // With the CONTROL modifier we switch layers.
503 0 : if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
504 : {
505 : // Moves to the previous layer.
506 0 : SwitchLayer (-1);
507 : }
508 : }
509 : }
510 : }
511 0 : break;
512 :
513 : case KEY_PAGEDOWN:
514 : {
515 0 : if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
516 0 : break;
517 0 : if(mpViewShell->ISA(DrawViewShell) && !bSlideShow)
518 : {
519 : // The page-down key switches layers or pages depending on the
520 : // modifier key.
521 0 : if ( ! rKEvt.GetKeyCode().GetAllModifier())
522 : {
523 : // With no modifier pressed we move to the next slide.
524 0 : mpView->SdrEndTextEdit();
525 :
526 : // Next page.
527 0 : bReturn = sal_True;
528 0 : SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
529 0 : sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;
530 :
531 0 : if (nSdPage < mpDoc->GetSdPageCount(pPage->GetPageKind()) - 1)
532 : {
533 : // Switch the page and send events regarding
534 : // deactivation the old page and activating the new
535 : // one.
536 : TabControl* pPageTabControl =
537 0 : static_cast<DrawViewShell*>(mpViewShell)->GetPageTabControl();
538 0 : if (pPageTabControl->IsReallyShown())
539 0 : pPageTabControl->SendDeactivatePageEvent ();
540 0 : static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage + 1);
541 0 : if (pPageTabControl->IsReallyShown())
542 0 : pPageTabControl->SendActivatePageEvent ();
543 : }
544 : }
545 0 : else if (rKEvt.GetKeyCode().IsMod1())
546 : {
547 : // With the CONTROL modifier we switch layers.
548 0 : if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
549 : {
550 : // With the layer mode active pressing page-down
551 : // moves to the next layer.
552 0 : SwitchLayer (+1);
553 : }
554 : }
555 : }
556 : }
557 0 : break;
558 :
559 : // change select state when focus is on poly point
560 : case KEY_SPACE:
561 : {
562 0 : const SdrHdlList& rHdlList = mpView->GetHdlList();
563 0 : SdrHdl* pHdl = rHdlList.GetFocusHdl();
564 :
565 0 : if(pHdl)
566 : {
567 0 : if(pHdl->GetKind() == HDL_POLY)
568 : {
569 : // rescue ID of point with focus
570 0 : sal_uInt32 nPol(pHdl->GetPolyNum());
571 0 : sal_uInt32 nPnt(pHdl->GetPointNum());
572 :
573 0 : if(mpView->IsPointMarked(*pHdl))
574 : {
575 0 : if(rKEvt.GetKeyCode().IsShift())
576 : {
577 0 : mpView->UnmarkPoint(*pHdl);
578 : }
579 : }
580 : else
581 : {
582 0 : if(!rKEvt.GetKeyCode().IsShift())
583 : {
584 0 : mpView->UnmarkAllPoints();
585 : }
586 :
587 0 : mpView->MarkPoint(*pHdl);
588 : }
589 :
590 0 : if(0L == rHdlList.GetFocusHdl())
591 : {
592 : // restore point with focus
593 0 : SdrHdl* pNewOne = 0L;
594 :
595 0 : for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
596 : {
597 0 : SdrHdl* pAct = rHdlList.GetHdl(a);
598 :
599 0 : if(pAct
600 0 : && pAct->GetKind() == HDL_POLY
601 0 : && pAct->GetPolyNum() == nPol
602 0 : && pAct->GetPointNum() == nPnt)
603 : {
604 0 : pNewOne = pAct;
605 : }
606 : }
607 :
608 0 : if(pNewOne)
609 : {
610 0 : ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
611 : }
612 : }
613 :
614 0 : bReturn = sal_True;
615 : }
616 : }
617 : }
618 0 : break;
619 :
620 : case KEY_UP:
621 : case KEY_DOWN:
622 : case KEY_LEFT:
623 : case KEY_RIGHT:
624 : {
625 0 : if (!mpView->IsTextEdit() && !bSlideShow)
626 : {
627 0 : long nX = 0;
628 0 : long nY = 0;
629 :
630 0 : if (nCode == KEY_UP)
631 : {
632 : // Scroll nach oben
633 0 : nX = 0;
634 0 : nY =-1;
635 : }
636 0 : else if (nCode == KEY_DOWN)
637 : {
638 : // Scroll nach unten
639 0 : nX = 0;
640 0 : nY = 1;
641 : }
642 0 : else if (nCode == KEY_LEFT)
643 : {
644 : // Scroll nach links
645 0 : nX =-1;
646 0 : nY = 0;
647 : }
648 0 : else if (nCode == KEY_RIGHT)
649 : {
650 : // Scroll nach rechts
651 0 : nX = 1;
652 0 : nY = 0;
653 : }
654 :
655 0 : if (mpView->AreObjectsMarked() && !rKEvt.GetKeyCode().IsMod1() &&
656 0 : !mpDocSh->IsReadOnly())
657 : {
658 0 : const SdrHdlList& rHdlList = mpView->GetHdlList();
659 0 : SdrHdl* pHdl = rHdlList.GetFocusHdl();
660 :
661 0 : sal_Bool bIsMoveOfConnectedHandle(sal_False);
662 0 : sal_Bool bOldSuppress = false;
663 0 : SdrEdgeObj* pEdgeObj = 0L;
664 :
665 0 : if(pHdl && pHdl->GetObj() && pHdl->GetObj()->ISA(SdrEdgeObj) && 0 == pHdl->GetPolyNum())
666 : {
667 0 : pEdgeObj = (SdrEdgeObj*)pHdl->GetObj();
668 :
669 0 : if(0L == pHdl->GetPointNum())
670 : {
671 0 : if(pEdgeObj->GetConnection(sal_True).GetObject())
672 : {
673 0 : bIsMoveOfConnectedHandle = sal_True;
674 : }
675 : }
676 0 : if(1L == pHdl->GetPointNum())
677 : {
678 0 : if(pEdgeObj->GetConnection(sal_False).GetObject())
679 : {
680 0 : bIsMoveOfConnectedHandle = sal_True;
681 : }
682 : }
683 : }
684 :
685 0 : if(pEdgeObj)
686 : {
687 : // Suppress default connects to inside object and object center
688 0 : bOldSuppress = pEdgeObj->GetSuppressDefaultConnect();
689 0 : pEdgeObj->SetSuppressDefaultConnect(sal_True);
690 : }
691 :
692 0 : if(bIsMoveOfConnectedHandle)
693 : {
694 0 : sal_uInt16 nMarkHdSiz(mpView->GetMarkHdlSizePixel());
695 0 : Size aHalfConSiz(nMarkHdSiz + 1, nMarkHdSiz + 1);
696 0 : aHalfConSiz = mpWindow->PixelToLogic(aHalfConSiz);
697 :
698 0 : if(100 < aHalfConSiz.Width())
699 0 : nX *= aHalfConSiz.Width();
700 : else
701 0 : nX *= 100;
702 :
703 0 : if(100 < aHalfConSiz.Height())
704 0 : nY *= aHalfConSiz.Height();
705 : else
706 0 : nY *= 100;
707 : }
708 0 : else if(rKEvt.GetKeyCode().IsMod2())
709 : {
710 : // move in 1 pixel distance
711 0 : Size aLogicSizeOnePixel = (mpWindow) ? mpWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
712 0 : nX *= aLogicSizeOnePixel.Width();
713 0 : nY *= aLogicSizeOnePixel.Height();
714 : }
715 0 : else if(rKEvt.GetKeyCode().IsShift())
716 : {
717 0 : nX *= 1000;
718 0 : nY *= 1000;
719 : }
720 : else
721 : {
722 : // old, fixed move distance
723 0 : nX *= 100;
724 0 : nY *= 100;
725 : }
726 :
727 0 : if(0L == pHdl)
728 : {
729 : // only take action when move is allowed
730 0 : if(mpView->IsMoveAllowed())
731 : {
732 : // restrict movement to WorkArea
733 0 : const Rectangle& rWorkArea = mpView->GetWorkArea();
734 :
735 0 : if(!rWorkArea.IsEmpty())
736 : {
737 0 : Rectangle aMarkRect(mpView->GetMarkedObjRect());
738 0 : aMarkRect.Move(nX, nY);
739 :
740 0 : if(!aMarkRect.IsInside(rWorkArea))
741 : {
742 0 : if(aMarkRect.Left() < rWorkArea.Left())
743 : {
744 0 : nX += rWorkArea.Left() - aMarkRect.Left();
745 : }
746 :
747 0 : if(aMarkRect.Right() > rWorkArea.Right())
748 : {
749 0 : nX -= aMarkRect.Right() - rWorkArea.Right();
750 : }
751 :
752 0 : if(aMarkRect.Top() < rWorkArea.Top())
753 : {
754 0 : nY += rWorkArea.Top() - aMarkRect.Top();
755 : }
756 :
757 0 : if(aMarkRect.Bottom() > rWorkArea.Bottom())
758 : {
759 0 : nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
760 : }
761 : }
762 : }
763 :
764 : // no handle selected
765 0 : if(0 != nX || 0 != nY)
766 : {
767 0 : mpView->MoveAllMarked(Size(nX, nY));
768 :
769 0 : mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
770 : }
771 : }
772 : }
773 : else
774 : {
775 : // move handle with index nHandleIndex
776 0 : if(pHdl && (nX || nY))
777 : {
778 : // now move the Handle (nX, nY)
779 0 : Point aStartPoint(pHdl->GetPos());
780 0 : Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
781 0 : const SdrDragStat& rDragStat = mpView->GetDragStat();
782 :
783 : // start dragging
784 0 : mpView->BegDragObj(aStartPoint, 0, pHdl, 0);
785 :
786 0 : if(mpView->IsDragObj())
787 : {
788 0 : bool bWasNoSnap = rDragStat.IsNoSnap();
789 0 : sal_Bool bWasSnapEnabled = mpView->IsSnapEnabled();
790 :
791 : // switch snapping off
792 0 : if(!bWasNoSnap)
793 0 : ((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
794 0 : if(bWasSnapEnabled)
795 0 : mpView->SetSnapEnabled(sal_False);
796 :
797 0 : mpView->MovAction(aEndPoint);
798 0 : mpView->EndDragObj();
799 :
800 : // restore snap
801 0 : if(!bWasNoSnap)
802 0 : ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
803 0 : if(bWasSnapEnabled)
804 0 : mpView->SetSnapEnabled(bWasSnapEnabled);
805 : }
806 :
807 : // make moved handle visible
808 0 : Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
809 0 : mpView->MakeVisible(aVisRect, *mpWindow);
810 : }
811 : }
812 :
813 0 : if(pEdgeObj)
814 : {
815 : // Restore original suppress value
816 0 : pEdgeObj->SetSuppressDefaultConnect(bOldSuppress);
817 : }
818 : }
819 : else
820 : {
821 : // Seite scrollen
822 0 : mpViewShell->ScrollLines(nX, nY);
823 : }
824 :
825 0 : bReturn = sal_True;
826 : }
827 : }
828 0 : break;
829 : }
830 :
831 0 : if (bReturn)
832 : {
833 0 : mpWindow->ReleaseMouse();
834 : }
835 :
836 : // when a text-editable object is selected and the
837 : // input character is printable, activate text edit on that object
838 : // and feed character to object
839 0 : if(!bReturn && !mpDocSh->IsReadOnly())
840 : {
841 0 : if(!mpView->IsTextEdit() && mpViewShell)
842 : {
843 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
844 :
845 0 : if(1 == rMarkList.GetMarkCount())
846 : {
847 0 : SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
848 :
849 : // #i118485# allow TextInput for OLEs, too
850 0 : if(pObj->ISA(SdrTextObj) && pObj->HasTextEdit())
851 : {
852 : // use common IsSimpleCharInput from the EditEngine.
853 0 : sal_Bool bPrintable(EditEngine::IsSimpleCharInput(rKEvt));
854 :
855 0 : if(bPrintable)
856 : {
857 : // try to activate textedit mode for the selected object
858 0 : SfxStringItem aInputString(SID_ATTR_CHAR, rtl::OUString(rKEvt.GetCharCode()));
859 :
860 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
861 : SID_ATTR_CHAR,
862 : SFX_CALLMODE_ASYNCHRON,
863 : &aInputString,
864 0 : 0L);
865 :
866 : // consumed
867 0 : bReturn = sal_True;
868 : }
869 : }
870 : }
871 : else
872 : {
873 : // test if there is a title object there. If yes, try to
874 : // set it to edit mode and start typing...
875 0 : if(mpViewShell->ISA(DrawViewShell)
876 0 : && EditEngine::IsSimpleCharInput(rKEvt))
877 : {
878 : DrawViewShell* pDrawViewShell =
879 0 : static_cast<DrawViewShell*>(mpViewShell);
880 0 : SdPage* pActualPage = pDrawViewShell->GetActualPage();
881 0 : SdrTextObj* pCandidate = 0L;
882 :
883 0 : if(pActualPage)
884 : {
885 0 : SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS);
886 :
887 0 : while(aIter.IsMore() && !pCandidate)
888 : {
889 0 : SdrObject* pObj = aIter.Next();
890 :
891 0 : if(pObj && pObj->ISA(SdrTextObj))
892 : {
893 0 : sal_uInt32 nInv(pObj->GetObjInventor());
894 0 : sal_uInt16 nKnd(pObj->GetObjIdentifier());
895 :
896 0 : if(SdrInventor == nInv && OBJ_TITLETEXT == nKnd)
897 : {
898 0 : pCandidate = (SdrTextObj*)pObj;
899 : }
900 : }
901 0 : }
902 : }
903 :
904 : // when candidate found and candidate is untouched, start editing text...
905 0 : if(pCandidate && pCandidate->IsEmptyPresObj())
906 : {
907 0 : mpView->UnMarkAll();
908 0 : mpView->MarkObj(pCandidate, mpView->GetSdrPageView());
909 0 : SfxStringItem aInputString(SID_ATTR_CHAR, rtl::OUString(rKEvt.GetCharCode()));
910 :
911 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
912 : SID_ATTR_CHAR,
913 : SFX_CALLMODE_ASYNCHRON,
914 : &aInputString,
915 0 : 0L);
916 :
917 : // consumed
918 0 : bReturn = sal_True;
919 : }
920 : }
921 : }
922 : }
923 : }
924 :
925 0 : return(bReturn);
926 : }
927 :
928 0 : sal_Bool FuPoor::MouseMove(const MouseEvent& )
929 : {
930 0 : return sal_False;
931 : }
932 :
933 0 : void FuPoor::SelectionHasChanged()
934 : {
935 0 : const SdrHdlList& rHdlList = mpView->GetHdlList();
936 0 : ((SdrHdlList&)rHdlList).ResetFocusHdl();
937 0 : }
938 :
939 : /*************************************************************************
940 : |*
941 : |* Cut object to clipboard
942 : |*
943 : \************************************************************************/
944 :
945 0 : void FuPoor::DoCut()
946 : {
947 0 : if (mpView)
948 : {
949 0 : mpView->DoCut(mpWindow);
950 : }
951 0 : }
952 :
953 : /*************************************************************************
954 : |*
955 : |* Copy object to clipboard
956 : |*
957 : \************************************************************************/
958 :
959 0 : void FuPoor::DoCopy()
960 : {
961 0 : if (mpView)
962 : {
963 0 : mpView->DoCopy(mpWindow);
964 : }
965 0 : }
966 :
967 : /*************************************************************************
968 : |*
969 : |* Paste object from clipboard
970 : |*
971 : \************************************************************************/
972 :
973 0 : void FuPoor::DoPaste()
974 : {
975 0 : if (mpView)
976 : {
977 0 : mpView->DoPaste(mpWindow);
978 : }
979 0 : }
980 :
981 : /*************************************************************************
982 : |*
983 : |* Timer-Handler fuer Drag&Drop
984 : |*
985 : \************************************************************************/
986 :
987 0 : IMPL_LINK_NOARG(FuPoor, DragHdl)
988 : {
989 0 : if( mpView )
990 : {
991 0 : sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
992 0 : SdrHdl* pHdl = mpView->PickHandle(aMDPos);
993 :
994 0 : if ( pHdl==NULL && mpView->IsMarkedHit(aMDPos, nHitLog)
995 0 : && !mpView->IsPresObjSelected(sal_False, sal_True) )
996 : {
997 0 : mpWindow->ReleaseMouse();
998 0 : bIsInDragMode = sal_True;
999 0 : mpView->StartDrag( aMDPos, mpWindow );
1000 : }
1001 : }
1002 0 : return 0;
1003 : }
1004 :
1005 : /*************************************************************************
1006 : |*
1007 : |* Command-event
1008 : |*
1009 : \************************************************************************/
1010 :
1011 0 : sal_Bool FuPoor::Command(const CommandEvent& rCEvt)
1012 : {
1013 0 : return( mpView->Command(rCEvt,mpWindow) );
1014 : }
1015 :
1016 : /*************************************************************************
1017 : |*
1018 : |* Timer-Handler fuer Fensterscrolling
1019 : |*
1020 : \************************************************************************/
1021 :
1022 0 : IMPL_LINK_NOARG_INLINE_START(FuPoor, DelayHdl)
1023 : {
1024 0 : aDelayToScrollTimer.Stop ();
1025 0 : bScrollable = sal_True;
1026 :
1027 0 : Point aPnt(mpWindow->GetPointerPosPixel());
1028 :
1029 : // use remembered MouseButton state to create correct
1030 : // MouseEvents for this artifical MouseMove.
1031 0 : MouseMove(MouseEvent(aPnt, 1, 0, GetMouseButtonCode()));
1032 :
1033 0 : return 0;
1034 : }
1035 0 : IMPL_LINK_INLINE_END( FuPoor, DelayHdl, Timer *, pTimer )
1036 :
1037 : /*************************************************************************
1038 : |*
1039 : |* Handler fuer Maustaste
1040 : |*
1041 : \************************************************************************/
1042 :
1043 0 : sal_Bool FuPoor::MouseButtonUp (const MouseEvent& rMEvt)
1044 : {
1045 : // remember button state for creation of own MouseEvents
1046 0 : SetMouseButtonCode(rMEvt.GetButtons());
1047 :
1048 0 : aDelayToScrollTimer.Stop ();
1049 : return bScrollable =
1050 0 : bDelayActive = sal_False;
1051 : }
1052 :
1053 0 : sal_Bool FuPoor::MouseButtonDown(const MouseEvent& rMEvt)
1054 : {
1055 : // remember button state for creation of own MouseEvents
1056 0 : SetMouseButtonCode(rMEvt.GetButtons());
1057 :
1058 0 : return sal_False;
1059 : }
1060 :
1061 : /*************************************************************************
1062 : |*
1063 : |* Handler fuer Maustaste
1064 : |*
1065 : \************************************************************************/
1066 :
1067 0 : void FuPoor::StartDelayToScrollTimer ()
1068 : {
1069 0 : bDelayActive = sal_True;
1070 0 : aDelayToScrollTimer.Start ();
1071 0 : }
1072 :
1073 : /*************************************************************************
1074 : |*
1075 : |* Help-event
1076 : |*
1077 : \************************************************************************/
1078 :
1079 0 : sal_Bool FuPoor::RequestHelp(const HelpEvent& rHEvt)
1080 : {
1081 0 : sal_Bool bReturn = sal_False;
1082 :
1083 0 : SdrPageView* pPV = mpView->GetSdrPageView();
1084 :
1085 0 : if (pPV)
1086 : {
1087 0 : SdPage* pPage = (SdPage*) pPV->GetPage();
1088 :
1089 0 : if (pPage)
1090 : {
1091 0 : bReturn = pPage->RequestHelp(mpWindow, mpView, rHEvt);
1092 : }
1093 : }
1094 :
1095 0 : return(bReturn);
1096 : }
1097 :
1098 0 : void FuPoor::Paint(const Rectangle&, ::sd::Window* )
1099 : {
1100 0 : }
1101 :
1102 : /*************************************************************************
1103 : |*
1104 : |* Request verarbeiten
1105 : |*
1106 : \************************************************************************/
1107 :
1108 0 : void FuPoor::ReceiveRequest(SfxRequest& rReq)
1109 : {
1110 0 : const SfxItemSet* pSet = rReq.GetArgs();
1111 :
1112 0 : if (pSet)
1113 : {
1114 0 : if( pSet->GetItemState( nSlotId ) == SFX_ITEM_SET )
1115 : {
1116 0 : const SfxPoolItem& rItem = pSet->Get( nSlotId );
1117 :
1118 0 : if( rItem.ISA( SfxAllEnumItem ) )
1119 : {
1120 0 : nSlotValue = ( ( const SfxAllEnumItem& ) rItem ).GetValue();
1121 : }
1122 : }
1123 : }
1124 0 : }
1125 :
1126 0 : SdrObject* FuPoor::CreateDefaultObject(const sal_uInt16, const Rectangle& )
1127 : {
1128 : // empty base implementation
1129 0 : return 0L;
1130 : }
1131 :
1132 0 : void FuPoor::ImpForceQuadratic(Rectangle& rRect)
1133 : {
1134 0 : if(rRect.GetWidth() > rRect.GetHeight())
1135 : {
1136 : rRect = Rectangle(
1137 0 : Point(rRect.Left() + ((rRect.GetWidth() - rRect.GetHeight()) / 2), rRect.Top()),
1138 0 : Size(rRect.GetHeight(), rRect.GetHeight()));
1139 : }
1140 : else
1141 : {
1142 : rRect = Rectangle(
1143 0 : Point(rRect.Left(), rRect.Top() + ((rRect.GetHeight() - rRect.GetWidth()) / 2)),
1144 0 : Size(rRect.GetWidth(), rRect.GetWidth()));
1145 : }
1146 0 : }
1147 :
1148 :
1149 :
1150 :
1151 0 : void FuPoor::SwitchLayer (sal_Int32 nOffset)
1152 : {
1153 0 : if(mpViewShell && mpViewShell->ISA(DrawViewShell))
1154 : {
1155 : DrawViewShell* pDrawViewShell =
1156 0 : static_cast<DrawViewShell*>(mpViewShell);
1157 :
1158 : // Calculate the new index.
1159 0 : sal_Int32 nIndex = pDrawViewShell->GetActiveTabLayerIndex() + nOffset;
1160 :
1161 : // Make sure the new index lies inside the range of valid indices.
1162 0 : if (nIndex < 0)
1163 0 : nIndex = 0;
1164 0 : else if (nIndex >= pDrawViewShell->GetTabLayerCount ())
1165 0 : nIndex = pDrawViewShell->GetTabLayerCount() - 1;
1166 :
1167 : // Set the new active layer.
1168 0 : if (nIndex != pDrawViewShell->GetActiveTabLayerIndex ())
1169 : {
1170 : LayerTabBar* pLayerTabControl =
1171 0 : static_cast<DrawViewShell*>(mpViewShell)->GetLayerTabControl();
1172 0 : if (pLayerTabControl != NULL)
1173 0 : pLayerTabControl->SendDeactivatePageEvent ();
1174 :
1175 0 : pDrawViewShell->SetActiveTabLayerIndex (nIndex);
1176 :
1177 0 : if (pLayerTabControl != NULL)
1178 0 : pLayerTabControl->SendActivatePageEvent ();
1179 : }
1180 : }
1181 0 : }
1182 :
1183 : /** is called when the currenct function should be aborted. <p>
1184 : This is used when a function gets a KEY_ESCAPE but can also
1185 : be called directly.
1186 :
1187 : @returns true if a active function was aborted
1188 : */
1189 0 : bool FuPoor::cancel()
1190 : {
1191 0 : if ( !this->ISA(FuSelection) )
1192 : {
1193 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON);
1194 0 : return true;
1195 : }
1196 :
1197 0 : return false;
1198 : }
1199 :
1200 : // #i33136#
1201 0 : bool FuPoor::doConstructOrthogonal() const
1202 : {
1203 : return (
1204 : SID_DRAW_XLINE == nSlotId ||
1205 : SID_DRAW_CIRCLEARC == nSlotId ||
1206 : SID_DRAW_SQUARE == nSlotId ||
1207 : SID_DRAW_SQUARE_NOFILL == nSlotId ||
1208 : SID_DRAW_SQUARE_ROUND == nSlotId ||
1209 : SID_DRAW_SQUARE_ROUND_NOFILL == nSlotId ||
1210 : SID_DRAW_CIRCLE == nSlotId ||
1211 : SID_DRAW_CIRCLE_NOFILL == nSlotId ||
1212 : SID_DRAW_CIRCLEPIE == nSlotId ||
1213 : SID_DRAW_CIRCLEPIE_NOFILL == nSlotId ||
1214 : SID_DRAW_CIRCLECUT == nSlotId ||
1215 : SID_DRAW_CIRCLECUT_NOFILL == nSlotId ||
1216 : SID_DRAW_XPOLYGON == nSlotId ||
1217 : SID_DRAW_XPOLYGON_NOFILL == nSlotId ||
1218 : SID_3D_CUBE == nSlotId ||
1219 : SID_3D_SPHERE == nSlotId ||
1220 : SID_3D_SHELL == nSlotId ||
1221 : SID_3D_HALF_SPHERE == nSlotId ||
1222 : SID_3D_TORUS == nSlotId ||
1223 : SID_3D_CYLINDER == nSlotId ||
1224 : SID_3D_CONE == nSlotId ||
1225 0 : SID_3D_PYRAMID == nSlotId);
1226 : }
1227 :
1228 0 : void FuPoor::DoExecute( SfxRequest& )
1229 : {
1230 0 : }
1231 :
1232 : } // end of namespace sd
1233 :
1234 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
