sc/source/ui/drawfunc/fudraw.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <editeng/editeng.hxx>
  21 #include <editeng/outlobj.hxx>
  22 #include <svx/svdobj.hxx>
  23 #include <svx/svdoole2.hxx>
  24 #include <svx/svdouno.hxx>
  25 #include <svx/svdocapt.hxx>
  26 #include <svx/svdpage.hxx>
  27 #include <svx/svditer.hxx>
  28 #include <svx/svdundo.hxx>
  29 #include <sfx2/dispatch.hxx>
  30 #include <sfx2/viewfrm.hxx>
  31
  32 #include "sc.hrc"
  33 #include "fudraw.hxx"
  34 #include "futext.hxx"
  35 #include "tabvwsh.hxx"
  36 #include "drwlayer.hxx"
  37 #include "scresid.hxx"
  38 #include "userdat.hxx"
  39 #include "docsh.hxx"
  40 #include "postit.hxx"
  41 #include "globstr.hrc"
  42 #include "drawview.hxx"
  43
  44 /*************************************************************************
  45 |*
  46 |* base class for draw module specific functions
  47 |*
  48 \************************************************************************/
  49
  50 FuDraw::FuDraw(ScTabViewShell* pViewSh, vcl::Window* pWin, ScDrawView* pViewP,
  51                SdrModel* pDoc, SfxRequest& rReq) :
  52     FuPoor      (pViewSh, pWin, pViewP, pDoc, rReq),
  53     aNewPointer ( PointerStyle::Arrow ),
  54     aOldPointer ( PointerStyle::Arrow )
  55 {
  56 }
  57
  58 /*************************************************************************
  59 |*
  60 |* destructor
  61 |*
  62 \************************************************************************/
  63
  64 FuDraw::~FuDraw()
  65 {
  66 }
  67
  68 /*************************************************************************
  69 |*
  70 |* evaluate modifier keys
  71 |*
  72 \************************************************************************/
  73
  74 void FuDraw::DoModifiers(const MouseEvent& rMEvt)
  75 {
  76     //  Shift   = Ortho and AngleSnap
  77     //  Control = Snap (Toggle)
  78     //  Alt     = centric
  79
  80     bool bShift = rMEvt.IsShift();
  81     bool bAlt   = rMEvt.IsMod2();
  82
  83     bool bOrtho     = bShift;
  84     bool bAngleSnap = bShift;
  85     bool bCenter    = bAlt;
  86
  87     // #i33136#
  88     if(doConstructOrthogonal())
  89     {
  90         bOrtho = !bShift;
  91     }
  92
  93     if (pView->IsOrtho() != bOrtho)
  94         pView->SetOrtho(bOrtho);
  95     if (pView->IsAngleSnapEnabled() != bAngleSnap)
  96         pView->SetAngleSnapEnabled(bAngleSnap);
  97
  98     if (pView->IsCreate1stPointAsCenter() != bCenter)
  99         pView->SetCreate1stPointAsCenter(bCenter);
 100     if (pView->IsResizeAtCenter() != bCenter)
 101         pView->SetResizeAtCenter(bCenter);
 102
 103 }
 104
 105 void FuDraw::ResetModifiers()
 106 {
 107     if (!pView)
 108         return;
 109
 110     ScViewData& rViewData = pViewShell->GetViewData();
 111     const ScViewOptions& rOpt = rViewData.GetOptions();
 112     const ScGridOptions& rGrid = rOpt.GetGridOptions();
 113     bool bGridOpt = rGrid.GetUseGridSnap();
 114
 115     if (pView->IsOrtho())
 116         pView->SetOrtho(false);
 117     if (pView->IsAngleSnapEnabled())
 118         pView->SetAngleSnapEnabled(false);
 119
 120     if (pView->IsGridSnap() != bGridOpt)
 121         pView->SetGridSnap(bGridOpt);
 122     if (pView->IsSnapEnabled() != bGridOpt)
 123         pView->SetSnapEnabled(bGridOpt);
 124
 125     if (pView->IsCreate1stPointAsCenter())
 126         pView->SetCreate1stPointAsCenter(false);
 127     if (pView->IsResizeAtCenter())
 128         pView->SetResizeAtCenter(false);
 129 }
 130
 131 /*************************************************************************
 132 |*
 133 |* MouseButtonDown-event
 134 |*
 135 \************************************************************************/
 136
 137 bool FuDraw::MouseButtonDown(const MouseEvent& rMEvt)
 138 {
 139     // remember button state for creation of own MouseEvents
 140     SetMouseButtonCode(rMEvt.GetButtons());
 141
 142     DoModifiers( rMEvt );
 143     return false;
 144 }
 145
 146 /*************************************************************************
 147 |*
 148 |* MouseMove-event
 149 |*
 150 \************************************************************************/
 151
 152 bool FuDraw::MouseMove(const MouseEvent& rMEvt)
 153 {
 154     //  evaluate modifiers only if in a drawing layer action
 155     //  (don't interfere with keyboard shortcut handling)
 156     if (pView->IsAction())
 157         DoModifiers( rMEvt );
 158
 159     return false;
 160 }
 161
 162 /*************************************************************************
 163 |*
 164 |* MouseButtonUp-event
 165 |*
 166 \************************************************************************/
 167
 168 bool FuDraw::MouseButtonUp(const MouseEvent& rMEvt)
 169 {
 170     // remember button state for creation of own MouseEvents
 171     SetMouseButtonCode(rMEvt.GetButtons());
 172
 173     ResetModifiers();
 174     return false;
 175 }
 176
 177 /*************************************************************************
 178 |*
 179 |* process keyboard events
 180 |*
 181 |* if a keyevent is processed -> returns sal_True
 182 |*                            -> else  FALSE
 183 |*
 184 \************************************************************************/
 185
 186 static bool lcl_KeyEditMode( SdrObject* pObj, ScTabViewShell* pViewShell, const KeyEvent* pInitialKey )
 187 {
 188     bool bReturn = false;
 189     if ( pObj && pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) )
 190     {
 191         // start text edit - like FuSelection::MouseButtonUp,
 192         // but with bCursorToEnd instead of mouse position
 193
 194         OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
 195         bool bVertical = ( pOPO && pOPO->IsVertical() );
 196         sal_uInt16 nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
 197
 198         // don't switch shells if text shell is already active
 199         FuPoor* pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
 200         if ( !pPoor || pPoor->GetSlotID() != nTextSlotId )
 201         {
 202             pViewShell->GetViewData().GetDispatcher().
 203                 Execute(nTextSlotId, SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
 204         }
 205
 206         // get the resulting FuText and set in edit mode
 207         pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
 208         if ( pPoor && pPoor->GetSlotID() == nTextSlotId )    // no RTTI
 209         {
 210             FuText* pText = static_cast<FuText*>(pPoor);
 211             pText->SetInEditMode( pObj, NULL, true, pInitialKey );
 212             //! set cursor to end of text
 213         }
 214         bReturn = true;
 215     }
 216     return bReturn;
 217 }
 218
 219 bool FuDraw::KeyInput(const KeyEvent& rKEvt)
 220 {
 221     bool bReturn = false;
 222     ScViewData& rViewData = pViewShell->GetViewData();
 223
 224     switch ( rKEvt.GetKeyCode().GetCode() )
 225     {
 226         case KEY_ESCAPE:
 227             if ( pViewShell->IsDrawTextShell() || aSfxRequest.GetSlot() == SID_DRAW_NOTEEDIT )
 228             {
 229                 // if object selected -> normal draw-shell, else turn off drawing
 230                 rViewData.GetDispatcher().Execute(aSfxRequest.GetSlot(), SfxCallMode::SLOT | SfxCallMode::RECORD);
 231                 bReturn = true;
 232             }
 233             else if ( pViewShell->IsDrawSelMode() )
 234             {
 235                 pView->UnmarkAll();
 236                 rViewData.GetDispatcher().Execute(SID_OBJECT_SELECT, SfxCallMode::SLOT | SfxCallMode::RECORD);
 237                 bReturn = true;
 238             }
 239             else if ( pView->AreObjectsMarked() )
 240             {
 241                 // III
 242                 SdrHdlList& rHdlList = const_cast< SdrHdlList& >( pView->GetHdlList() );
 243                 if( rHdlList.GetFocusHdl() )
 244                     rHdlList.ResetFocusHdl();
 245                 else
 246                     pView->UnmarkAll();
 247
 248                 //  while bezier editing, object is selected
 249                 if (!pView->AreObjectsMarked())
 250                     pViewShell->SetDrawShell( false );
 251
 252                 bReturn = true;
 253             }
 254             break;
 255
 256         case KEY_DELETE:                    //! via accelerator
 257             pView->DeleteMarked();
 258             bReturn = true;
 259         break;
 260
 261         case KEY_RETURN:
 262         {
 263             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 264             {
 265                 // activate OLE object on RETURN for selected object
 266                 // put selected text object in edit mode
 267                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 268                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 269                 {
 270                     bool bOle = pViewShell->GetViewFrame()->GetFrame().IsInPlace();
 271                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 272                     if( pObj && pObj->ISA( SdrOle2Obj ) && !bOle )
 273                     {
 274                         pViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
 275
 276                         // consumed
 277                         bReturn = true;
 278                     }
 279                     else if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )       // start text edit for suitable object
 280                         bReturn = true;
 281                 }
 282             }
 283         }
 284         break;
 285
 286         case KEY_F2:
 287         {
 288             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 289             {
 290                 // put selected text object in edit mode
 291                 // (this is not SID_SETINPUTMODE, but F2 hardcoded, like in Writer)
 292                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 293                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 294                 {
 295                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 296                     if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )            // start text edit for suitable object
 297                         bReturn = true;
 298                 }
 299             }
 300         }
 301         break;
 302
 303         // #97016#
 304         case KEY_TAB:
 305         {
 306             // in calc do NOT start draw object selection using TAB/SHIFT-TAB when
 307             // there is not yet a object selected
 308             if(pView->AreObjectsMarked())
 309             {
 310                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
 311
 312                 if ( !aCode.IsMod1() && !aCode.IsMod2() )
 313                 {
 314                     // changeover to the next object
 315                     if(!pView->MarkNextObj( !aCode.IsShift() ))
 316                     {
 317                         //If there is only one object, don't do the UnmarkAlllObj() & MarkNextObj().
 318                         if ( pView->GetMarkableObjCount() > 1 && pView->HasMarkableObj() )
 319                         {
 320                             // No next object: go over open end and
 321                             // get first from the other side
 322                             pView->UnmarkAllObj();
 323                             pView->MarkNextObj(!aCode.IsShift());
 324                         }
 325                     }
 326
 327                     // II
 328                     if(pView->AreObjectsMarked())
 329                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 330
 331                     bReturn = true;
 332                 }
 333
 334                 // handle Mod1 and Mod2 to get travelling running on different systems
 335                 if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
 336                 {
 337                     // II do something with a selected handle?
 338                     const SdrHdlList& rHdlList = pView->GetHdlList();
 339                     bool bForward(!rKEvt.GetKeyCode().IsShift());
 340
 341                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
 342
 343                     // guarantee visibility of focused handle
 344                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 345
 346                     if(pHdl)
 347                     {
 348                         Point aHdlPosition(pHdl->GetPos());
 349                         Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
 350                         pView->MakeVisible(aVisRect, *pWindow);
 351                     }
 352
 353                     // consumed
 354                     bReturn = true;
 355                 }
 356             }
 357         }
 358         break;
 359
 360         // #97016#
 361         case KEY_END:
 362         {
 363             // in calc do NOT select the last draw object when
 364             // there is not yet a object selected
 365             if(pView->AreObjectsMarked())
 366             {
 367                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
 368
 369                 if ( aCode.IsMod1() )
 370                 {
 371                     // mark last object
 372                     pView->UnmarkAllObj();
 373                     pView->MarkNextObj(false);
 374
 375                     // II
 376                     if(pView->AreObjectsMarked())
 377                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 378
 379                     bReturn = true;
 380                 }
 381             }
 382         }
 383         break;
 384
 385         // #97016#
 386         case KEY_HOME:
 387         {
 388             // in calc do NOT select the first draw object when
 389             // there is not yet a object selected
 390             if(pView->AreObjectsMarked())
 391             {
 392                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
 393
 394                 if ( aCode.IsMod1() )
 395                 {
 396                     // mark first object
 397                     pView->UnmarkAllObj();
 398                     pView->MarkNextObj(true);
 399
 400                     // II
 401                     if(pView->AreObjectsMarked())
 402                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 403
 404                     bReturn = true;
 405                 }
 406             }
 407         }
 408         break;
 409
 410         // #97016#
 411         case KEY_UP:
 412         case KEY_DOWN:
 413         case KEY_LEFT:
 414         case KEY_RIGHT:
 415         {
 416             // in calc do cursor travelling of draw objects only when
 417             // there is a object selected yet
 418             if(pView->AreObjectsMarked())
 419             {
 420
 421                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 422                 if(rMarkList.GetMarkCount() == 1)
 423                 {
 424                     // disable cursor travelling on note objects as the tail connector position
 425                     // must not move.
 426                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 427                     if( ScDrawLayer::IsNoteCaption( pObj ) )
 428                         break;
 429                 }
 430
 431                 long nX = 0;
 432                 long nY = 0;
 433                 sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
 434
 435                 if (nCode == KEY_UP)
 436                 {
 437                     // scroll up
 438                     nX = 0;
 439                     nY =-1;
 440                 }
 441                 else if (nCode == KEY_DOWN)
 442                 {
 443                     // scroll down
 444                     nX = 0;
 445                     nY = 1;
 446                 }
 447                 else if (nCode == KEY_LEFT)
 448                 {
 449                     // scroll left
 450                     nX =-1;
 451                     nY = 0;
 452                 }
 453                 else if (nCode == KEY_RIGHT)
 454                 {
 455                     // scroll right
 456                     nX = 1;
 457                     nY = 0;
 458                 }
 459
 460                 bool bReadOnly = rViewData.GetDocShell()->IsReadOnly();
 461
 462                 if(!rKEvt.GetKeyCode().IsMod1() && !bReadOnly)
 463                 {
 464                     if(rKEvt.GetKeyCode().IsMod2())
 465                     {
 466                         // move in 1 pixel distance
 467                         Size aLogicSizeOnePixel = (pWindow) ? pWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
 468                         nX *= aLogicSizeOnePixel.Width();
 469                         nY *= aLogicSizeOnePixel.Height();
 470                     }
 471                     else if(rKEvt.GetKeyCode().IsShift()) // #i121236# Support for shift key in calc
 472                     {
 473                         nX *= 1000;
 474                         nY *= 1000;
 475                     }
 476                     else
 477                     {
 478                         // old, fixed move distance
 479                         nX *= 100;
 480                         nY *= 100;
 481                     }
 482
 483                     // is there a movement to do?
 484                     if(0 != nX || 0 != nY)
 485                     {
 486                         // II
 487                         const SdrHdlList& rHdlList = pView->GetHdlList();
 488                         SdrHdl* pHdl = rHdlList.GetFocusHdl();
 489
 490                         if(0L == pHdl)
 491                         {
 492                             // only take action when move is allowed
 493                             if(pView->IsMoveAllowed())
 494                             {
 495                                 // restrict movement to WorkArea
 496                                 const Rectangle& rWorkArea = pView->GetWorkArea();
 497
 498                                 if(!rWorkArea.IsEmpty())
 499                                 {
 500                                     Rectangle aMarkRect(pView->GetMarkedObjRect());
 501                                     aMarkRect.Move(nX, nY);
 502
 503                                     if(!aMarkRect.IsInside(rWorkArea))
 504                                     {
 505                                         if(aMarkRect.Left() < rWorkArea.Left())
 506                                         {
 507                                             nX += rWorkArea.Left() - aMarkRect.Left();
 508                                         }
 509
 510                                         if(aMarkRect.Right() > rWorkArea.Right())
 511                                         {
 512                                             nX -= aMarkRect.Right() - rWorkArea.Right();
 513                                         }
 514
 515                                         if(aMarkRect.Top() < rWorkArea.Top())
 516                                         {
 517                                             nY += rWorkArea.Top() - aMarkRect.Top();
 518                                         }
 519
 520                                         if(aMarkRect.Bottom() > rWorkArea.Bottom())
 521                                         {
 522                                             nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 523                                         }
 524                                     }
 525                                 }
 526
 527                                 // now move the selected draw objects
 528                                 pView->MoveAllMarked(Size(nX, nY));
 529
 530                                 // II
 531                                 pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 532
 533                                 bReturn = true;
 534                             }
 535                         }
 536                         else
 537                         {
 538                             // move handle with index nHandleIndex
 539                             if(pHdl && (nX || nY))
 540                             {
 541                                 // now move the Handle (nX, nY)
 542                                 Point aStartPoint(pHdl->GetPos());
 543                                 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 544                                 const SdrDragStat& rDragStat = pView->GetDragStat();
 545
 546                                 // start dragging
 547                                 pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 548
 549                                 if(pView->IsDragObj())
 550                                 {
 551                                     bool bWasNoSnap = rDragStat.IsNoSnap();
 552                                     bool bWasSnapEnabled = pView->IsSnapEnabled();
 553
 554                                     // switch snapping off
 555                                     if(!bWasNoSnap)
 556                                         ((SdrDragStat&)rDragStat).SetNoSnap(true);
 557                                     if(bWasSnapEnabled)
 558                                         pView->SetSnapEnabled(false);
 559
 560                                     pView->MovAction(aEndPoint);
 561                                     pView->EndDragObj();
 562
 563                                     // restore snap
 564                                     if(!bWasNoSnap)
 565                                         ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 566                                     if(bWasSnapEnabled)
 567                                         pView->SetSnapEnabled(bWasSnapEnabled);
 568                                 }
 569
 570                                 // make moved handle visible
 571                                 Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
 572                                 pView->MakeVisible(aVisRect, *pWindow);
 573
 574                                 bReturn = true;
 575                             }
 576                         }
 577                     }
 578                 }
 579             }
 580         }
 581         break;
 582
 583         // #97016#
 584         case KEY_SPACE:
 585         {
 586             // in calc do only something when draw objects are selected
 587             if(pView->AreObjectsMarked())
 588             {
 589                 const SdrHdlList& rHdlList = pView->GetHdlList();
 590                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 591
 592                 if(pHdl)
 593                 {
 594                     if(pHdl->GetKind() == HDL_POLY)
 595                     {
 596                         // rescue ID of point with focus
 597                         sal_uInt32 nPol(pHdl->GetPolyNum());
 598                         sal_uInt32 nPnt(pHdl->GetPointNum());
 599
 600                         if(pView->IsPointMarked(*pHdl))
 601                         {
 602                             if(rKEvt.GetKeyCode().IsShift())
 603                             {
 604                                 pView->UnmarkPoint(*pHdl);
 605                             }
 606                         }
 607                         else
 608                         {
 609                             if(!rKEvt.GetKeyCode().IsShift())
 610                             {
 611                                 pView->UnmarkAllPoints();
 612                             }
 613
 614                             pView->MarkPoint(*pHdl);
 615                         }
 616
 617                         if(0L == rHdlList.GetFocusHdl())
 618                         {
 619                             // restore point with focus
 620                             SdrHdl* pNewOne = 0L;
 621
 622                             for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
 623                             {
 624                                 SdrHdl* pAct = rHdlList.GetHdl(a);
 625
 626                                 if(pAct
 627                                     && pAct->GetKind() == HDL_POLY
 628                                     && pAct->GetPolyNum() == nPol
 629                                     && pAct->GetPointNum() == nPnt)
 630                                 {
 631                                     pNewOne = pAct;
 632                                 }
 633                             }
 634
 635                             if(pNewOne)
 636                             {
 637                                 ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 638                             }
 639                         }
 640
 641                         bReturn = true;
 642                     }
 643                 }
 644             }
 645         }
 646         break;
 647     }
 648
 649     if (!bReturn)
 650     {
 651         bReturn = FuPoor::KeyInput(rKEvt);
 652     }
 653
 654     if (!bReturn)
 655     {
 656         // allow direct typing into a selected text object
 657
 658         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 659         if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() && EditEngine::IsSimpleCharInput(rKEvt) )
 660         {
 661             SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 662
 663             // start text edit for suitable object, pass key event to OutlinerView
 664             if ( lcl_KeyEditMode( pObj, pViewShell, &rKEvt ) )
 665                 bReturn = true;
 666         }
 667     }
 668
 669     return bReturn;
 670 }
 671
 672 // II
 673 void FuDraw::SelectionHasChanged()
 674 {
 675     const SdrHdlList& rHdlList = pView->GetHdlList();
 676     ((SdrHdlList&)rHdlList).ResetFocusHdl();
 677 }
 678
 679 /*************************************************************************
 680 |*
 681 |* enable function
 682 |*
 683 \************************************************************************/
 684
 685 void FuDraw::Activate()
 686 {
 687     FuPoor::Activate();
 688 }
 689
 690 /*************************************************************************
 691 |*
 692 |* disable function
 693 |*
 694 \************************************************************************/
 695
 696 void FuDraw::Deactivate()
 697 {
 698     FuPoor::Deactivate();
 699 }
 700
 701 /*************************************************************************
 702 |*
 703 |* toggle mouse-pointer
 704 |*
 705 \************************************************************************/
 706
 707 static bool lcl_UrlHit( SdrView* pView, const Point& rPosPixel, vcl::Window* pWindow )
 708 {
 709     SdrViewEvent aVEvt;
 710     MouseEvent aMEvt( rPosPixel, 1, MouseEventModifiers::NONE, MOUSE_LEFT );
 711     SdrHitKind eHit = pView->PickAnything( aMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt );
 712
 713     if ( eHit != SDRHIT_NONE && aVEvt.pObj != NULL )
 714     {
 715         if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) && ScDrawLayer::GetHitIMapObject(
 716                                 aVEvt.pObj, pWindow->PixelToLogic(rPosPixel), *pWindow ) )
 717             return true;
 718
 719         if ( aVEvt.eEvent == SDREVENT_EXECUTEURL )
 720             return true;
 721     }
 722
 723     return false;
 724 }
 725
 726 void FuDraw::ForcePointer(const MouseEvent* pMEvt)
 727 {
 728     if ( !pView->IsAction() )
 729     {
 730         Point aPosPixel = pWindow->GetPointerPosPixel();
 731         bool bAlt       = pMEvt && pMEvt->IsMod2();
 732         Point aPnt      = pWindow->PixelToLogic( aPosPixel );
 733         SdrHdl* pHdl    = pView->PickHandle(aPnt);
 734         SdrObject* pObj;
 735         SdrPageView* pPV;
 736
 737         ScMacroInfo* pInfo = 0;
 738         if ( pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SdrSearchOptions::ALSOONMASTER) )
 739         {
 740             if ( pObj->IsGroupObject() )
 741             {
 742                 SdrObject* pHit = 0;
 743                 if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SdrSearchOptions::DEEP ) )
 744                     pObj = pHit;
 745             }
 746             pInfo = ScDrawLayer::GetMacroInfo( pObj );
 747         }
 748
 749         if ( pView->IsTextEdit() )
 750         {
 751             pViewShell->SetActivePointer(Pointer(PointerStyle::Text));        // can't be ?
 752         }
 753         else if ( pHdl )
 754         {
 755             pViewShell->SetActivePointer(
 756                 pView->GetPreferredPointer( aPnt, pWindow ) );
 757         }
 758         else if ( pView->IsMarkedHit(aPnt) )
 759         {
 760             pViewShell->SetActivePointer( Pointer(PointerStyle::Move) );
 761         }
 762         else if ( !bAlt && ( !pMEvt || !pMEvt->GetButtons() )
 763                         && lcl_UrlHit( pView, aPosPixel, pWindow ) )
 764         {
 765             //  could be suppressed with ALT
 766             pWindow->SetPointer( Pointer( PointerStyle::RefHand ) );          // Text-URL / ImageMap
 767         }
 768         else if ( !bAlt && pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SdrSearchOptions::PICKMACRO) )
 769         {
 770             //  could be suppressed with ALT
 771             SdrObjMacroHitRec aHitRec;  //! something missing ????
 772             pViewShell->SetActivePointer( pObj->GetMacroPointer(aHitRec) );
 773         }
 774         else if ( !bAlt && pInfo && (!pInfo->GetMacro().isEmpty() || !pInfo->GetHlink().isEmpty()) )
 775             pWindow->SetPointer( Pointer( PointerStyle::RefHand ) );
 776         else if ( IsDetectiveHit( aPnt ) )
 777             pViewShell->SetActivePointer( Pointer( PointerStyle::Detective ) );
 778         else
 779             pViewShell->SetActivePointer( aNewPointer );            //! in Gridwin?
 780     }
 781 }
 782
 783 bool FuDraw::IsEditingANote() const
 784 {
 785     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 786     const size_t backval=rMarkList.GetMarkCount();
 787     for (size_t nlv1=0; nlv1<backval; ++nlv1)
 788     {
 789         SdrObject* pObj = rMarkList.GetMark( nlv1 )->GetMarkedSdrObj();
 790         if ( ScDrawLayer::IsNoteCaption( pObj ) )
 791         {
 792             return true;
 793         }
 794     }
 795     return false;
 796 }
 797
 798 bool FuDraw::IsSizingOrMovingNote( const MouseEvent& rMEvt ) const
 799 {
 800     bool bIsSizingOrMoving = false;
 801     if ( rMEvt.IsLeft() )
 802     {
 803         const SdrMarkList& rNoteMarkList = pView->GetMarkedObjectList();
 804         if(rNoteMarkList.GetMarkCount() == 1)
 805         {
 806             SdrObject* pObj = rNoteMarkList.GetMark( 0 )->GetMarkedSdrObj();
 807             if ( ScDrawLayer::IsNoteCaption( pObj ) )
 808             {
 809                 Point aMPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 810                 bIsSizingOrMoving =
 811                     pView->PickHandle( aMPos ) ||      // handles to resize the note
 812                     pView->IsTextEditFrameHit( aMPos );         // frame for moving the note
 813             }
 814         }
 815     }
 816     return bIsSizingOrMoving;
 817 }
 818
 819 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */