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>  // EditEngine::IsSimpleCharInput
  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 |* Basisklasse fuer alle Drawmodul-spezifischen Funktionen
  47 |*
  48 \************************************************************************/
  49
  50 FuDraw::FuDraw(ScTabViewShell* pViewSh, Window* pWin, ScDrawView* pViewP,
  51                SdrModel* pDoc, SfxRequest& rReq) :
  52     FuPoor      (pViewSh, pWin, pViewP, pDoc, rReq),
  53     aNewPointer ( POINTER_ARROW ),
  54     aOldPointer ( POINTER_ARROW )
  55 {
  56 }
  57
  58 /*************************************************************************
  59 |*
  60 |* Destruktor
  61 |*
  62 \************************************************************************/
  63
  64 FuDraw::~FuDraw()
  65 {
  66 }
  67
  68 /*************************************************************************
  69 |*
  70 |* Modifier-Tasten auswerten
  71 |*
  72 \************************************************************************/
  73
  74 void FuDraw::DoModifiers(const MouseEvent& rMEvt)
  75 {
  76     //  Shift   = Ortho und AngleSnap
  77     //  Control = Snap (Toggle)
  78     //  Alt     = zentrisch
  79
  80     sal_Bool bShift = rMEvt.IsShift();
  81     sal_Bool bAlt   = rMEvt.IsMod2();
  82
  83     bool bOrtho     = bShift;
  84     sal_Bool bAngleSnap = bShift;
  85     sal_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     ScViewData* pViewData = pViewShell->GetViewData();
 108     const ScViewOptions& rOpt = pViewData->GetOptions();
 109     const ScGridOptions& rGrid = rOpt.GetGridOptions();
 110     sal_Bool bGridOpt = rGrid.GetUseGridSnap();
 111
 112     if (pView->IsOrtho())
 113         pView->SetOrtho(false);
 114     if (pView->IsAngleSnapEnabled())
 115         pView->SetAngleSnapEnabled(false);
 116
 117     if (pView->IsGridSnap() != bGridOpt)
 118         pView->SetGridSnap(bGridOpt);
 119     if (pView->IsSnapEnabled() != bGridOpt)
 120         pView->SetSnapEnabled(bGridOpt);
 121
 122     if (pView->IsCreate1stPointAsCenter())
 123         pView->SetCreate1stPointAsCenter(false);
 124     if (pView->IsResizeAtCenter())
 125         pView->SetResizeAtCenter(false);
 126 }
 127
 128 /*************************************************************************
 129 |*
 130 |* MouseButtonDown-event
 131 |*
 132 \************************************************************************/
 133
 134 sal_Bool FuDraw::MouseButtonDown(const MouseEvent& rMEvt)
 135 {
 136     // remember button state for creation of own MouseEvents
 137     SetMouseButtonCode(rMEvt.GetButtons());
 138
 139     DoModifiers( rMEvt );
 140     return false;
 141 }
 142
 143 /*************************************************************************
 144 |*
 145 |* MouseMove-event
 146 |*
 147 \************************************************************************/
 148
 149 sal_Bool FuDraw::MouseMove(const MouseEvent& rMEvt)
 150 {
 151     //  evaluate modifiers only if in a drawing layer action
 152     //  (don't interfere with keyboard shortcut handling)
 153     if (pView->IsAction())
 154         DoModifiers( rMEvt );
 155
 156     return false;
 157 }
 158
 159 /*************************************************************************
 160 |*
 161 |* MouseButtonUp-event
 162 |*
 163 \************************************************************************/
 164
 165 sal_Bool FuDraw::MouseButtonUp(const MouseEvent& rMEvt)
 166 {
 167     // remember button state for creation of own MouseEvents
 168     SetMouseButtonCode(rMEvt.GetButtons());
 169
 170     ResetModifiers();
 171     return false;
 172 }
 173
 174 /*************************************************************************
 175 |*
 176 |* Tastaturereignisse bearbeiten
 177 |*
 178 |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
 179 |* FALSE.
 180 |*
 181 \************************************************************************/
 182
 183 static sal_Bool lcl_KeyEditMode( SdrObject* pObj, ScTabViewShell* pViewShell, const KeyEvent* pInitialKey )
 184 {
 185     sal_Bool bReturn = false;
 186     if ( pObj && pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) )
 187     {
 188         // start text edit - like FuSelection::MouseButtonUp,
 189         // but with bCursorToEnd instead of mouse position
 190
 191         OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
 192         sal_Bool bVertical = ( pOPO && pOPO->IsVertical() );
 193         sal_uInt16 nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
 194
 195         // don't switch shells if text shell is already active
 196         FuPoor* pPoor = pViewShell->GetViewData()->GetView()->GetDrawFuncPtr();
 197         if ( !pPoor || pPoor->GetSlotID() != nTextSlotId )
 198         {
 199             pViewShell->GetViewData()->GetDispatcher().
 200                 Execute(nTextSlotId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
 201         }
 202
 203         // get the resulting FuText and set in edit mode
 204         pPoor = pViewShell->GetViewData()->GetView()->GetDrawFuncPtr();
 205         if ( pPoor && pPoor->GetSlotID() == nTextSlotId )    // no RTTI
 206         {
 207             FuText* pText = (FuText*)pPoor;
 208             pText->SetInEditMode( pObj, NULL, sal_True, pInitialKey );
 209             //! set cursor to end of text
 210         }
 211         bReturn = sal_True;
 212     }
 213     return bReturn;
 214 }
 215
 216 sal_Bool FuDraw::KeyInput(const KeyEvent& rKEvt)
 217 {
 218     sal_Bool bReturn = false;
 219     ScViewData& rViewData = *pViewShell->GetViewData();
 220
 221     switch ( rKEvt.GetKeyCode().GetCode() )
 222     {
 223         case KEY_ESCAPE:
 224             if ( pViewShell->IsDrawTextShell() || aSfxRequest.GetSlot() == SID_DRAW_NOTEEDIT )
 225             {
 226                 // in normale Draw-Shell, wenn Objekt selektiert, sonst Zeichnen aus
 227                 rViewData.GetDispatcher().Execute(aSfxRequest.GetSlot(), SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 228                 bReturn = sal_True;
 229             }
 230             else if ( pViewShell->IsDrawSelMode() )
 231             {
 232                 pView->UnmarkAll();
 233                 rViewData.GetDispatcher().Execute(SID_OBJECT_SELECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 234                 bReturn = sal_True;
 235             }
 236             else if ( pView->AreObjectsMarked() )
 237             {
 238                 // III
 239                 SdrHdlList& rHdlList = const_cast< SdrHdlList& >( pView->GetHdlList() );
 240                 if( rHdlList.GetFocusHdl() )
 241                     rHdlList.ResetFocusHdl();
 242                 else
 243                     pView->UnmarkAll();
 244
 245                 //  Beim Bezier-Editieren ist jetzt wieder das Objekt selektiert
 246                 if (!pView->AreObjectsMarked())
 247                     pViewShell->SetDrawShell( false );
 248
 249                 bReturn = sal_True;
 250             }
 251             break;
 252
 253         case KEY_DELETE:                    //! ueber Accelerator
 254             pView->DeleteMarked();
 255             bReturn = sal_True;
 256         break;
 257
 258         case KEY_RETURN:
 259         {
 260             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 261             {
 262                 // activate OLE object on RETURN for selected object
 263                 // put selected text object in edit mode
 264                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 265                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 266                 {
 267                     sal_Bool bOle = pViewShell->GetViewFrame()->GetFrame().IsInPlace();
 268                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 269                     if( pObj && pObj->ISA( SdrOle2Obj ) && !bOle )
 270                     {
 271                         pViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
 272
 273                         // consumed
 274                         bReturn = sal_True;
 275                     }
 276                     else if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )       // start text edit for suitable object
 277                         bReturn = sal_True;
 278                 }
 279             }
 280         }
 281         break;
 282
 283         case KEY_F2:
 284         {
 285             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 286             {
 287                 // put selected text object in edit mode
 288                 // (this is not SID_SETINPUTMODE, but F2 hardcoded, like in Writer)
 289                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 290                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 291                 {
 292                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 293                     if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )            // start text edit for suitable object
 294                         bReturn = sal_True;
 295                 }
 296             }
 297         }
 298         break;
 299
 300         // #97016#
 301         case KEY_TAB:
 302         {
 303             // in calc do NOT start draw object selection using TAB/SHIFT-TAB when
 304             // there is not yet a object selected
 305             if(pView->AreObjectsMarked())
 306             {
 307                 KeyCode aCode = rKEvt.GetKeyCode();
 308
 309                 if ( !aCode.IsMod1() && !aCode.IsMod2() )
 310                 {
 311                     // changeover to the next object
 312                     if(!pView->MarkNextObj( !aCode.IsShift() ))
 313                     {
 314                         // No next object: go over open end and
 315                         // get first from the other side
 316                         pView->UnmarkAllObj();
 317                         pView->MarkNextObj(!aCode.IsShift());
 318                     }
 319
 320                     // II
 321                     if(pView->AreObjectsMarked())
 322                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 323
 324                     bReturn = sal_True;
 325                 }
 326
 327                 // handle Mod1 and Mod2 to get travelling running on different systems
 328                 if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
 329                 {
 330                     // II do something with a selected handle?
 331                     const SdrHdlList& rHdlList = pView->GetHdlList();
 332                     sal_Bool bForward(!rKEvt.GetKeyCode().IsShift());
 333
 334                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
 335
 336                     // guarantee visibility of focused handle
 337                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 338
 339                     if(pHdl)
 340                     {
 341                         Point aHdlPosition(pHdl->GetPos());
 342                         Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
 343                         pView->MakeVisible(aVisRect, *pWindow);
 344                     }
 345
 346                     // consumed
 347                     bReturn = sal_True;
 348                 }
 349             }
 350         }
 351         break;
 352
 353         // #97016#
 354         case KEY_END:
 355         {
 356             // in calc do NOT select the last draw object when
 357             // there is not yet a object selected
 358             if(pView->AreObjectsMarked())
 359             {
 360                 KeyCode aCode = rKEvt.GetKeyCode();
 361
 362                 if ( aCode.IsMod1() )
 363                 {
 364                     // mark last object
 365                     pView->UnmarkAllObj();
 366                     pView->MarkNextObj(false);
 367
 368                     // II
 369                     if(pView->AreObjectsMarked())
 370                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 371
 372                     bReturn = sal_True;
 373                 }
 374             }
 375         }
 376         break;
 377
 378         // #97016#
 379         case KEY_HOME:
 380         {
 381             // in calc do NOT select the first draw object when
 382             // there is not yet a object selected
 383             if(pView->AreObjectsMarked())
 384             {
 385                 KeyCode aCode = rKEvt.GetKeyCode();
 386
 387                 if ( aCode.IsMod1() )
 388                 {
 389                     // mark first object
 390                     pView->UnmarkAllObj();
 391                     pView->MarkNextObj(sal_True);
 392
 393                     // II
 394                     if(pView->AreObjectsMarked())
 395                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 396
 397                     bReturn = sal_True;
 398                 }
 399             }
 400         }
 401         break;
 402
 403         // #97016#
 404         case KEY_UP:
 405         case KEY_DOWN:
 406         case KEY_LEFT:
 407         case KEY_RIGHT:
 408         {
 409             // in calc do cursor travelling of draw objects only when
 410             // there is a object selected yet
 411             if(pView->AreObjectsMarked())
 412             {
 413
 414                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 415                 if(rMarkList.GetMarkCount() == 1)
 416                 {
 417                     // disable cursor travelling on note objects as the tail connector position
 418                     // must not move.
 419                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 420                     if( ScDrawLayer::IsNoteCaption( pObj ) )
 421                         break;
 422                 }
 423
 424                 long nX = 0;
 425                 long nY = 0;
 426                 sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
 427
 428                 if (nCode == KEY_UP)
 429                 {
 430                     // Scroll nach oben
 431                     nX = 0;
 432                     nY =-1;
 433                 }
 434                 else if (nCode == KEY_DOWN)
 435                 {
 436                     // Scroll nach unten
 437                     nX = 0;
 438                     nY = 1;
 439                 }
 440                 else if (nCode == KEY_LEFT)
 441                 {
 442                     // Scroll nach links
 443                     nX =-1;
 444                     nY = 0;
 445                 }
 446                 else if (nCode == KEY_RIGHT)
 447                 {
 448                     // Scroll nach rechts
 449                     nX = 1;
 450                     nY = 0;
 451                 }
 452
 453                 sal_Bool bReadOnly = rViewData.GetDocShell()->IsReadOnly();
 454
 455                 if(!rKEvt.GetKeyCode().IsMod1() && !bReadOnly)
 456                 {
 457                     if(rKEvt.GetKeyCode().IsMod2())
 458                     {
 459                         // move in 1 pixel distance
 460                         Size aLogicSizeOnePixel = (pWindow) ? pWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
 461                         nX *= aLogicSizeOnePixel.Width();
 462                         nY *= aLogicSizeOnePixel.Height();
 463                     }
 464                     else
 465                     {
 466                         // old, fixed move distance
 467                         nX *= 100;
 468                         nY *= 100;
 469                     }
 470
 471                     // is there a movement to do?
 472                     if(0 != nX || 0 != nY)
 473                     {
 474                         // II
 475                         const SdrHdlList& rHdlList = pView->GetHdlList();
 476                         SdrHdl* pHdl = rHdlList.GetFocusHdl();
 477
 478                         if(0L == pHdl)
 479                         {
 480                             // only take action when move is allowed
 481                             if(pView->IsMoveAllowed())
 482                             {
 483                                 // restrict movement to WorkArea
 484                                 const Rectangle& rWorkArea = pView->GetWorkArea();
 485
 486                                 if(!rWorkArea.IsEmpty())
 487                                 {
 488                                     Rectangle aMarkRect(pView->GetMarkedObjRect());
 489                                     aMarkRect.Move(nX, nY);
 490
 491                                     if(!aMarkRect.IsInside(rWorkArea))
 492                                     {
 493                                         if(aMarkRect.Left() < rWorkArea.Left())
 494                                         {
 495                                             nX += rWorkArea.Left() - aMarkRect.Left();
 496                                         }
 497
 498                                         if(aMarkRect.Right() > rWorkArea.Right())
 499                                         {
 500                                             nX -= aMarkRect.Right() - rWorkArea.Right();
 501                                         }
 502
 503                                         if(aMarkRect.Top() < rWorkArea.Top())
 504                                         {
 505                                             nY += rWorkArea.Top() - aMarkRect.Top();
 506                                         }
 507
 508                                         if(aMarkRect.Bottom() > rWorkArea.Bottom())
 509                                         {
 510                                             nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 511                                         }
 512                                     }
 513                                 }
 514
 515                                 // now move the selected draw objects
 516                                 pView->MoveAllMarked(Size(nX, nY));
 517
 518                                 // II
 519                                 pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 520
 521                                 bReturn = sal_True;
 522                             }
 523                         }
 524                         else
 525                         {
 526                             // move handle with index nHandleIndex
 527                             if(pHdl && (nX || nY))
 528                             {
 529                                 // now move the Handle (nX, nY)
 530                                 Point aStartPoint(pHdl->GetPos());
 531                                 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 532                                 const SdrDragStat& rDragStat = pView->GetDragStat();
 533
 534                                 // start dragging
 535                                 pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 536
 537                                 if(pView->IsDragObj())
 538                                 {
 539                                     bool bWasNoSnap = rDragStat.IsNoSnap();
 540                                     sal_Bool bWasSnapEnabled = pView->IsSnapEnabled();
 541
 542                                     // switch snapping off
 543                                     if(!bWasNoSnap)
 544                                         ((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
 545                                     if(bWasSnapEnabled)
 546                                         pView->SetSnapEnabled(false);
 547
 548                                     pView->MovAction(aEndPoint);
 549                                     pView->EndDragObj();
 550
 551                                     // restore snap
 552                                     if(!bWasNoSnap)
 553                                         ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 554                                     if(bWasSnapEnabled)
 555                                         pView->SetSnapEnabled(bWasSnapEnabled);
 556                                 }
 557
 558                                 // make moved handle visible
 559                                 Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
 560                                 pView->MakeVisible(aVisRect, *pWindow);
 561
 562                                 bReturn = sal_True;
 563                             }
 564                         }
 565                     }
 566                 }
 567             }
 568         }
 569         break;
 570
 571         // #97016#
 572         case KEY_SPACE:
 573         {
 574             // in calc do only something when draw objects are selected
 575             if(pView->AreObjectsMarked())
 576             {
 577                 const SdrHdlList& rHdlList = pView->GetHdlList();
 578                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 579
 580                 if(pHdl)
 581                 {
 582                     if(pHdl->GetKind() == HDL_POLY)
 583                     {
 584                         // rescue ID of point with focus
 585                         sal_uInt32 nPol(pHdl->GetPolyNum());
 586                         sal_uInt32 nPnt(pHdl->GetPointNum());
 587
 588                         if(pView->IsPointMarked(*pHdl))
 589                         {
 590                             if(rKEvt.GetKeyCode().IsShift())
 591                             {
 592                                 pView->UnmarkPoint(*pHdl);
 593                             }
 594                         }
 595                         else
 596                         {
 597                             if(!rKEvt.GetKeyCode().IsShift())
 598                             {
 599                                 pView->UnmarkAllPoints();
 600                             }
 601
 602                             pView->MarkPoint(*pHdl);
 603                         }
 604
 605                         if(0L == rHdlList.GetFocusHdl())
 606                         {
 607                             // restore point with focus
 608                             SdrHdl* pNewOne = 0L;
 609
 610                             for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
 611                             {
 612                                 SdrHdl* pAct = rHdlList.GetHdl(a);
 613
 614                                 if(pAct
 615                                     && pAct->GetKind() == HDL_POLY
 616                                     && pAct->GetPolyNum() == nPol
 617                                     && pAct->GetPointNum() == nPnt)
 618                                 {
 619                                     pNewOne = pAct;
 620                                 }
 621                             }
 622
 623                             if(pNewOne)
 624                             {
 625                                 ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 626                             }
 627                         }
 628
 629                         bReturn = sal_True;
 630                     }
 631                 }
 632             }
 633         }
 634         break;
 635     }
 636
 637     if (!bReturn)
 638     {
 639         bReturn = FuPoor::KeyInput(rKEvt);
 640     }
 641
 642     if (!bReturn)
 643     {
 644         // allow direct typing into a selected text object
 645
 646         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 647         if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() && EditEngine::IsSimpleCharInput(rKEvt) )
 648         {
 649             SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 650
 651             // start text edit for suitable object, pass key event to OutlinerView
 652             if ( lcl_KeyEditMode( pObj, pViewShell, &rKEvt ) )
 653                 bReturn = sal_True;
 654         }
 655     }
 656
 657     return (bReturn);
 658 }
 659
 660 // II
 661 void FuDraw::SelectionHasChanged()
 662 {
 663     const SdrHdlList& rHdlList = pView->GetHdlList();
 664     ((SdrHdlList&)rHdlList).ResetFocusHdl();
 665 }
 666
 667 /*************************************************************************
 668 |*
 669 |* Function aktivieren
 670 |*
 671 \************************************************************************/
 672
 673 void FuDraw::Activate()
 674 {
 675     FuPoor::Activate();
 676 }
 677
 678 /*************************************************************************
 679 |*
 680 |* Function deaktivieren
 681 |*
 682 \************************************************************************/
 683
 684 void FuDraw::Deactivate()
 685 {
 686     FuPoor::Deactivate();
 687 }
 688
 689 /*************************************************************************
 690 |*
 691 |* Maus-Pointer umschalten
 692 |*
 693 \************************************************************************/
 694
 695 static sal_Bool lcl_UrlHit( SdrView* pView, const Point& rPosPixel, Window* pWindow )
 696 {
 697     SdrViewEvent aVEvt;
 698     MouseEvent aMEvt( rPosPixel, 1, 0, MOUSE_LEFT );
 699     SdrHitKind eHit = pView->PickAnything( aMEvt, SDRMOUSEBUTTONDOWN, aVEvt );
 700
 701     if ( eHit != SDRHIT_NONE && aVEvt.pObj != NULL )
 702     {
 703         if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) && ScDrawLayer::GetHitIMapObject(
 704                                 aVEvt.pObj, pWindow->PixelToLogic(rPosPixel), *pWindow ) )
 705             return sal_True;
 706
 707         if ( aVEvt.eEvent == SDREVENT_EXECUTEURL )
 708             return sal_True;
 709     }
 710
 711     return false;
 712 }
 713
 714 void FuDraw::ForcePointer(const MouseEvent* pMEvt)
 715 {
 716     if ( !pView->IsAction() )
 717     {
 718         Point aPosPixel = pWindow->GetPointerPosPixel();
 719         sal_Bool bAlt       = pMEvt && pMEvt->IsMod2();
 720         Point aPnt      = pWindow->PixelToLogic( aPosPixel );
 721         SdrHdl* pHdl    = pView->PickHandle(aPnt);
 722         SdrObject* pObj;
 723         SdrPageView* pPV;
 724
 725         ScMacroInfo* pInfo = 0;
 726         if ( pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER) )
 727         {
 728             if ( pObj->IsGroupObject() )
 729             {
 730                 SdrObject* pHit = 0;
 731                 if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SDRSEARCH_DEEP ) )
 732                     pObj = pHit;
 733             }
 734             pInfo = ScDrawLayer::GetMacroInfo( pObj );
 735         }
 736
 737         if ( pView->IsTextEdit() )
 738         {
 739             pViewShell->SetActivePointer(Pointer(POINTER_TEXT));        // kann nicht sein ?
 740         }
 741         else if ( pHdl )
 742         {
 743             pViewShell->SetActivePointer(
 744                 pView->GetPreferedPointer( aPnt, pWindow ) );
 745         }
 746         else if ( pView->IsMarkedHit(aPnt) )
 747         {
 748             pViewShell->SetActivePointer( Pointer(POINTER_MOVE) );
 749         }
 750         else if ( !bAlt && ( !pMEvt || !pMEvt->GetButtons() )
 751                         && lcl_UrlHit( pView, aPosPixel, pWindow ) )
 752         {
 753             //  kann mit ALT unterdrueckt werden
 754             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );          // Text-URL / ImageMap
 755         }
 756         else if ( !bAlt && pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO) )
 757         {
 758             //  kann mit ALT unterdrueckt werden
 759             SdrObjMacroHitRec aHitRec;  //! muss da noch irgendwas gesetzt werden ????
 760             pViewShell->SetActivePointer( pObj->GetMacroPointer(aHitRec) );
 761         }
 762         else if ( !bAlt && pInfo && (!pInfo->GetMacro().isEmpty() || !pInfo->GetHlink().isEmpty()) )
 763             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );
 764         else if ( IsDetectiveHit( aPnt ) )
 765             pViewShell->SetActivePointer( Pointer( POINTER_DETECTIVE ) );
 766         else
 767             pViewShell->SetActivePointer( aNewPointer );            //! in Gridwin?
 768     }
 769 }
 770
 771 sal_Bool FuDraw::IsEditingANote() const
 772 {
 773     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 774     sal_Int32 backval=rMarkList.GetMarkCount();
 775     for (sal_Int32 nlv1=0;nlv1<backval;nlv1++)
 776     {
 777         SdrObject* pObj = rMarkList.GetMark( nlv1 )->GetMarkedSdrObj();
 778         if ( ScDrawLayer::IsNoteCaption( pObj ) )
 779         {
 780             return true;
 781         }
 782     }
 783     return false;
 784 }
 785
 786 sal_Bool FuDraw::IsSizingOrMovingNote( const MouseEvent& rMEvt ) const
 787 {
 788     sal_Bool bIsSizingOrMoving = false;
 789     if ( rMEvt.IsLeft() )
 790     {
 791         const SdrMarkList& rNoteMarkList = pView->GetMarkedObjectList();
 792         if(rNoteMarkList.GetMarkCount() == 1)
 793         {
 794             SdrObject* pObj = rNoteMarkList.GetMark( 0 )->GetMarkedSdrObj();
 795             if ( ScDrawLayer::IsNoteCaption( pObj ) )
 796             {
 797                 Point aMPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 798                 bIsSizingOrMoving =
 799                     pView->PickHandle( aMPos ) ||      // handles to resize the note
 800                     pView->IsTextEditFrameHit( aMPos );         // frame for moving the note
 801             }
 802         }
 803     }
 804     return bIsSizingOrMoving;
 805 }
 806
 807 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */