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