sc/source/ui/drawfunc/fudraw.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: fudraw.cxx,v $
  10  * $Revision: 1.25.128.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 //------------------------------------------------------------------------
  35
  36 #include <svx/editeng.hxx>      // EditEngine::IsSimpleCharInput
  37 #include <svx/outlobj.hxx>
  38 #include <svx/svdobj.hxx>
  39 #include <svx/svdoole2.hxx>
  40 #include <svx/svdouno.hxx>
  41 #include <svx/svdocapt.hxx>
  42 #include <svx/svdpage.hxx>
  43 #include <svx/svditer.hxx>
  44 #include <svx/svdundo.hxx>
  45 #include <sfx2/dispatch.hxx>
  46 #include <sfx2/viewfrm.hxx>
  47 #include <com/sun/star/embed/EmbedVerbs.hpp>
  48
  49 #include "sc.hrc"
  50 #include "fudraw.hxx"
  51 #include "futext.hxx"
  52 #include "tabvwsh.hxx"
  53 #include "drwlayer.hxx"
  54 #include "scresid.hxx"
  55 #include "userdat.hxx"
  56 #include "docsh.hxx"
  57 #include "postit.hxx"
  58 #include "globstr.hrc"
  59 #include "drawview.hxx"
  60
  61 using namespace ::com::sun::star;
  62
  63 /*************************************************************************
  64 |*
  65 |* Basisklasse fuer alle Drawmodul-spezifischen Funktionen
  66 |*
  67 \************************************************************************/
  68
  69 FuDraw::FuDraw(ScTabViewShell* pViewSh, Window* pWin, ScDrawView* pViewP,
  70                SdrModel* pDoc, SfxRequest& rReq) :
  71     FuPoor      (pViewSh, pWin, pViewP, pDoc, rReq),
  72     aNewPointer ( POINTER_ARROW ),
  73     aOldPointer ( POINTER_ARROW )
  74 {
  75 }
  76
  77 /*************************************************************************
  78 |*
  79 |* Destruktor
  80 |*
  81 \************************************************************************/
  82
  83 FuDraw::~FuDraw()
  84 {
  85 }
  86
  87 /*************************************************************************
  88 |*
  89 |* Modifier-Tasten auswerten
  90 |*
  91 \************************************************************************/
  92
  93 void FuDraw::DoModifiers(const MouseEvent& rMEvt)
  94 {
  95     //  Shift   = Ortho und AngleSnap
  96     //  Control = Snap (Toggle)
  97     //  Alt             = zentrisch
  98
  99     BOOL bShift = rMEvt.IsShift();
 100 //    BOOL bCtrl  = rMEvt.IsMod1();
 101     BOOL bAlt   = rMEvt.IsMod2();
 102
 103 //    ScViewData* pViewData = pViewShell->GetViewData();
 104 //    const ScViewOptions& rOpt = pViewData->GetOptions();
 105 //    const ScGridOptions& rGrid = rOpt.GetGridOptions();
 106 //    BOOL bGridOpt = rGrid.GetUseGridSnap();
 107
 108     BOOL bOrtho         = bShift;
 109     BOOL bAngleSnap     = bShift;
 110 //    BOOL bGridSnap  = ( bGridOpt != bCtrl );        // andere Snap's nicht unterstuetzt
 111     BOOL bCenter        = bAlt;
 112
 113     // #i33136#
 114     if(doConstructOrthogonal())
 115     {
 116         bOrtho = !bShift;
 117     }
 118
 119     if (pView->IsOrtho() != bOrtho)
 120         pView->SetOrtho(bOrtho);
 121     if (pView->IsAngleSnapEnabled() != bAngleSnap)
 122         pView->SetAngleSnapEnabled(bAngleSnap);
 123
 124 /*      Control fuer Snap beisst sich beim Verschieben mit "kopieren" !!!
 125
 126     if (pView->IsGridSnap() != bGridSnap)
 127         pView->SetGridSnap(bGridSnap);
 128     if (pView->IsSnapEnabled() != bGridSnap)
 129         pView->SetSnapEnabled(bGridSnap);
 130 */
 131     if (pView->IsCreate1stPointAsCenter() != bCenter)
 132         pView->SetCreate1stPointAsCenter(bCenter);
 133     if (pView->IsResizeAtCenter() != bCenter)
 134         pView->SetResizeAtCenter(bCenter);
 135
 136 }
 137
 138 void FuDraw::ResetModifiers()
 139 {
 140     ScViewData* pViewData = pViewShell->GetViewData();
 141     const ScViewOptions& rOpt = pViewData->GetOptions();
 142     const ScGridOptions& rGrid = rOpt.GetGridOptions();
 143     BOOL bGridOpt = rGrid.GetUseGridSnap();
 144
 145     if (pView->IsOrtho())
 146         pView->SetOrtho(FALSE);
 147     if (pView->IsAngleSnapEnabled())
 148         pView->SetAngleSnapEnabled(FALSE);
 149
 150     if (pView->IsGridSnap() != bGridOpt)
 151         pView->SetGridSnap(bGridOpt);
 152     if (pView->IsSnapEnabled() != bGridOpt)
 153         pView->SetSnapEnabled(bGridOpt);
 154
 155     if (pView->IsCreate1stPointAsCenter())
 156         pView->SetCreate1stPointAsCenter(FALSE);
 157     if (pView->IsResizeAtCenter())
 158         pView->SetResizeAtCenter(FALSE);
 159 }
 160
 161 /*************************************************************************
 162 |*
 163 |* MouseButtonDown-event
 164 |*
 165 \************************************************************************/
 166
 167 BOOL __EXPORT FuDraw::MouseButtonDown(const MouseEvent& rMEvt)
 168 {
 169     // #95491# remember button state for creation of own MouseEvents
 170     SetMouseButtonCode(rMEvt.GetButtons());
 171
 172     DoModifiers( rMEvt );
 173     return FALSE;
 174 }
 175
 176 /*************************************************************************
 177 |*
 178 |* MouseMove-event
 179 |*
 180 \************************************************************************/
 181
 182 BOOL __EXPORT FuDraw::MouseMove(const MouseEvent& rMEvt)
 183 {
 184     //  #106438# evaluate modifiers only if in a drawing layer action
 185     //  (don't interfere with keyboard shortcut handling)
 186     if (pView->IsAction())
 187         DoModifiers( rMEvt );
 188
 189     return FALSE;
 190 }
 191
 192 /*************************************************************************
 193 |*
 194 |* MouseButtonUp-event
 195 |*
 196 \************************************************************************/
 197
 198 BOOL __EXPORT FuDraw::MouseButtonUp(const MouseEvent& rMEvt)
 199 {
 200     // #95491# remember button state for creation of own MouseEvents
 201     SetMouseButtonCode(rMEvt.GetButtons());
 202
 203     ResetModifiers();
 204     return FALSE;
 205 }
 206
 207 /*************************************************************************
 208 |*
 209 |* Tastaturereignisse bearbeiten
 210 |*
 211 |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert TRUE, andernfalls
 212 |* FALSE.
 213 |*
 214 \************************************************************************/
 215
 216 BOOL lcl_KeyEditMode( SdrObject* pObj, ScTabViewShell* pViewShell, const KeyEvent* pInitialKey )
 217 {
 218     BOOL bReturn = FALSE;
 219     if ( pObj && pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) )
 220     {
 221         // start text edit - like FuSelection::MouseButtonUp,
 222         // but with bCursorToEnd instead of mouse position
 223
 224         OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
 225         BOOL bVertical = ( pOPO && pOPO->IsVertical() );
 226         USHORT nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
 227
 228         // don't switch shells if text shell is already active
 229         FuPoor* pPoor = pViewShell->GetViewData()->GetView()->GetDrawFuncPtr();
 230         if ( !pPoor || pPoor->GetSlotID() != nTextSlotId )
 231         {
 232             pViewShell->GetViewData()->GetDispatcher().
 233                 Execute(nTextSlotId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
 234         }
 235
 236         // get the resulting FuText and set in edit mode
 237         pPoor = pViewShell->GetViewData()->GetView()->GetDrawFuncPtr();
 238         if ( pPoor && pPoor->GetSlotID() == nTextSlotId )        //     no RTTI
 239         {
 240             FuText* pText = (FuText*)pPoor;
 241             pText->SetInEditMode( pObj, NULL, TRUE, pInitialKey );
 242             //! set cursor to end of text
 243         }
 244         bReturn = TRUE;
 245     }
 246     return bReturn;
 247 }
 248
 249 BOOL __EXPORT FuDraw::KeyInput(const KeyEvent& rKEvt)
 250 {
 251     BOOL bReturn = FALSE;
 252     ScViewData& rViewData = *pViewShell->GetViewData();
 253
 254     switch ( rKEvt.GetKeyCode().GetCode() )
 255     {
 256         case KEY_ESCAPE:
 257
 258     /* 18.12.95: TextShell beibehalten nicht mehr gewuenscht...
 259      *
 260      *                  if ( pView->IsAction() )
 261      *                  {
 262      *                          pView->BrkAction();
 263      *                          pWindow->ReleaseMouse();
 264      *                          bReturn = TRUE;
 265      *                  }
 266      *                  else if ( pView->IsTextEdit() )
 267      *                  {
 268      *                          pView->EndTextEdit();
 269      *                          pView->SetCreateMode();
 270      *                          pViewShell->GetScDrawView()->InvalidateDrawTextAttrs();
 271      *                          bReturn = TRUE;
 272      *                  }
 273      *                  else
 274      */
 275
 276             if ( pViewShell->IsDrawTextShell() || aSfxRequest.GetSlot() == SID_DRAW_NOTEEDIT )
 277             {
 278                 // in normale Draw-Shell, wenn Objekt selektiert, sonst Zeichnen aus
 279                 rViewData.GetDispatcher().Execute(aSfxRequest.GetSlot(), SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 280                 bReturn = TRUE;
 281             }
 282             else if ( pViewShell->IsDrawSelMode() )
 283             {
 284                 pView->UnmarkAll();
 285                 rViewData.GetDispatcher().Execute(SID_OBJECT_SELECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 286                 bReturn = TRUE;
 287             }
 288             else if ( pView->AreObjectsMarked() )
 289             {
 290                 // #97016# III
 291                 SdrHdlList& rHdlList = const_cast< SdrHdlList& >( pView->GetHdlList() );
 292                 if( rHdlList.GetFocusHdl() )
 293                     rHdlList.ResetFocusHdl();
 294                 else
 295                     pView->UnmarkAll();
 296
 297                 //      Beim Bezier-Editieren ist jetzt wieder das Objekt selektiert
 298                 if (!pView->AreObjectsMarked())
 299                     pViewShell->SetDrawShell( FALSE );
 300
 301                 bReturn = TRUE;
 302             }
 303             break;
 304
 305         case KEY_DELETE:                                        //! ueber Accelerator
 306             pView->DeleteMarked();
 307             bReturn = TRUE;
 308         break;
 309
 310         case KEY_RETURN:
 311         {
 312             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 313             {
 314                 // #98256# activate OLE object on RETURN for selected object
 315                 // #98198# put selected text object in edit mode
 316                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 317                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 318                 {
 319                     BOOL bOle = pViewShell->GetViewFrame()->GetFrame()->IsInPlace();
 320                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 321                     if( pObj && pObj->ISA( SdrOle2Obj ) && !bOle )
 322                     {
 323                         //HMHpView->HideMarkHdl();
 324                         if(rKEvt.GetKeyCode().IsShift())
 325                             pViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ),
 326                                                         embed::EmbedVerbs::MS_OLEVERB_OPEN );
 327                         else
 328                             pViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ),
 329                                                         embed::EmbedVerbs::MS_OLEVERB_PRIMARY );
 330
 331                         // consumed
 332                         bReturn = TRUE;
 333                     }
 334                     else if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )               // start text edit for suitable object
 335                         bReturn = TRUE;
 336                 }
 337             }
 338         }
 339         break;
 340
 341         case KEY_F2:
 342         {
 343             if( rKEvt.GetKeyCode().GetModifier() == 0 )
 344             {
 345                 // #98198# put selected text object in edit mode
 346                 // (this is not SID_SETINPUTMODE, but F2 hardcoded, like in Writer)
 347                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 348                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 349                 {
 350                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 351                     if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )                    // start text edit for suitable object
 352                         bReturn = TRUE;
 353                 }
 354             }
 355         }
 356         break;
 357
 358         // #97016#
 359         case KEY_TAB:
 360         {
 361             // in calc do NOT start draw object selection using TAB/SHIFT-TAB when
 362             // there is not yet a object selected
 363             if(pView->AreObjectsMarked())
 364             {
 365                 KeyCode aCode = rKEvt.GetKeyCode();
 366
 367                 if ( !aCode.IsMod1() && !aCode.IsMod2() )
 368                 {
 369                     // changeover to the next object
 370                     if(!pView->MarkNextObj( !aCode.IsShift() ))
 371                     {
 372                         // #97016# No next object: go over open end and
 373                         // get first from the other side
 374                         pView->UnmarkAllObj();
 375                         pView->MarkNextObj(!aCode.IsShift());
 376                     }
 377
 378                     // #97016# II
 379                     if(pView->AreObjectsMarked())
 380                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 381
 382                     bReturn = TRUE;
 383                 }
 384
 385                 // #98994# handle Mod1 and Mod2 to get travelling running on different systems
 386                 if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
 387                 {
 388                     // #97016# II do something with a selected handle?
 389                     const SdrHdlList& rHdlList = pView->GetHdlList();
 390                     sal_Bool bForward(!rKEvt.GetKeyCode().IsShift());
 391
 392                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
 393
 394                     // guarantee visibility of focused handle
 395                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 396
 397                     if(pHdl)
 398                     {
 399                         Point aHdlPosition(pHdl->GetPos());
 400                         Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
 401                         pView->MakeVisible(aVisRect, *pWindow);
 402                     }
 403
 404                     // consumed
 405                     bReturn = TRUE;
 406                 }
 407             }
 408         }
 409         break;
 410
 411         // #97016#
 412         case KEY_END:
 413         {
 414             // in calc do NOT select the last draw object when
 415             // there is not yet a object selected
 416             if(pView->AreObjectsMarked())
 417             {
 418                 KeyCode aCode = rKEvt.GetKeyCode();
 419
 420                 if ( aCode.IsMod1() )
 421                 {
 422                     // #97016# mark last object
 423                     pView->UnmarkAllObj();
 424                     pView->MarkNextObj(FALSE);
 425
 426                     // #97016# II
 427                     if(pView->AreObjectsMarked())
 428                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 429
 430                     bReturn = TRUE;
 431                 }
 432             }
 433         }
 434         break;
 435
 436         // #97016#
 437         case KEY_HOME:
 438         {
 439             // in calc do NOT select the first draw object when
 440             // there is not yet a object selected
 441             if(pView->AreObjectsMarked())
 442             {
 443                 KeyCode aCode = rKEvt.GetKeyCode();
 444
 445                 if ( aCode.IsMod1() )
 446                 {
 447                     // #97016# mark first object
 448                     pView->UnmarkAllObj();
 449                     pView->MarkNextObj(TRUE);
 450
 451                     // #97016# II
 452                     if(pView->AreObjectsMarked())
 453                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 454
 455                     bReturn = TRUE;
 456                 }
 457             }
 458         }
 459         break;
 460
 461         // #97016#
 462         case KEY_UP:
 463         case KEY_DOWN:
 464         case KEY_LEFT:
 465         case KEY_RIGHT:
 466         {
 467             // in calc do cursor travelling of draw objects only when
 468             // there is a object selected yet
 469             if(pView->AreObjectsMarked())
 470             {
 471
 472                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 473                 if(rMarkList.GetMarkCount() == 1)
 474                 {
 475                     // disable cursor travelling on note objects as the tail connector position
 476                     // must not move.
 477                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 478                     if( ScDrawLayer::IsNoteCaption( pObj ) )
 479                         break;
 480                 }
 481
 482                 long nX = 0;
 483                 long nY = 0;
 484                 USHORT nCode = rKEvt.GetKeyCode().GetCode();
 485
 486                 if (nCode == KEY_UP)
 487                 {
 488                     // Scroll nach oben
 489                     nX = 0;
 490                     nY =-1;
 491                 }
 492                 else if (nCode == KEY_DOWN)
 493                 {
 494                     // Scroll nach unten
 495                     nX = 0;
 496                     nY = 1;
 497                 }
 498                 else if (nCode == KEY_LEFT)
 499                 {
 500                     // Scroll nach links
 501                     nX =-1;
 502                     nY = 0;
 503                 }
 504                 else if (nCode == KEY_RIGHT)
 505                 {
 506                     // Scroll nach rechts
 507                     nX = 1;
 508                     nY = 0;
 509                 }
 510
 511                 BOOL bReadOnly = rViewData.GetDocShell()->IsReadOnly();
 512
 513                 if(!rKEvt.GetKeyCode().IsMod1() && !bReadOnly)
 514                 {
 515                     if(rKEvt.GetKeyCode().IsMod2())
 516                     {
 517                         // #97016# move in 1 pixel distance
 518                         Size aLogicSizeOnePixel = (pWindow) ? pWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
 519                         nX *= aLogicSizeOnePixel.Width();
 520                         nY *= aLogicSizeOnePixel.Height();
 521                     }
 522                     else
 523                     {
 524                         // old, fixed move distance
 525                         nX *= 100;
 526                         nY *= 100;
 527                     }
 528
 529                     // is there a movement to do?
 530                     if(0 != nX || 0 != nY)
 531                     {
 532                         // #97016# II
 533                         const SdrHdlList& rHdlList = pView->GetHdlList();
 534                         SdrHdl* pHdl = rHdlList.GetFocusHdl();
 535
 536                         if(0L == pHdl)
 537                         {
 538                             // #107086# only take action when move is allowed
 539                             if(pView->IsMoveAllowed())
 540                             {
 541                                 // #90129# restrict movement to WorkArea
 542                                 const Rectangle& rWorkArea = pView->GetWorkArea();
 543
 544                                 if(!rWorkArea.IsEmpty())
 545                                 {
 546                                     Rectangle aMarkRect(pView->GetMarkedObjRect());
 547                                     aMarkRect.Move(nX, nY);
 548
 549                                     if(!aMarkRect.IsInside(rWorkArea))
 550                                     {
 551                                         if(aMarkRect.Left() < rWorkArea.Left())
 552                                         {
 553                                             nX += rWorkArea.Left() - aMarkRect.Left();
 554                                         }
 555
 556                                         if(aMarkRect.Right() > rWorkArea.Right())
 557                                         {
 558                                             nX -= aMarkRect.Right() - rWorkArea.Right();
 559                                         }
 560
 561                                         if(aMarkRect.Top() < rWorkArea.Top())
 562                                         {
 563                                             nY += rWorkArea.Top() - aMarkRect.Top();
 564                                         }
 565
 566                                         if(aMarkRect.Bottom() > rWorkArea.Bottom())
 567                                         {
 568                                             nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 569                                         }
 570                                     }
 571                                 }
 572
 573                                 // now move the selected draw objects
 574                                 pView->MoveAllMarked(Size(nX, nY));
 575
 576                                 // #97016# II
 577                                 pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 578
 579                                 bReturn = TRUE;
 580                             }
 581                         }
 582                         else
 583                         {
 584                             // move handle with index nHandleIndex
 585                             if(pHdl && (nX || nY))
 586                             {
 587                                 // now move the Handle (nX, nY)
 588                                 Point aStartPoint(pHdl->GetPos());
 589                                 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 590                                 const SdrDragStat& rDragStat = pView->GetDragStat();
 591
 592                                 // start dragging
 593                                 pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 594
 595                                 if(pView->IsDragObj())
 596                                 {
 597                                     FASTBOOL bWasNoSnap = rDragStat.IsNoSnap();
 598                                     BOOL bWasSnapEnabled = pView->IsSnapEnabled();
 599
 600                                     // switch snapping off
 601                                     if(!bWasNoSnap)
 602                                         ((SdrDragStat&)rDragStat).SetNoSnap(TRUE);
 603                                     if(bWasSnapEnabled)
 604                                         pView->SetSnapEnabled(FALSE);
 605
 606                                     pView->MovAction(aEndPoint);
 607                                     pView->EndDragObj();
 608
 609                                     // restore snap
 610                                     if(!bWasNoSnap)
 611                                         ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 612                                     if(bWasSnapEnabled)
 613                                         pView->SetSnapEnabled(bWasSnapEnabled);
 614                                 }
 615
 616                                 // make moved handle visible
 617                                 Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
 618                                 pView->MakeVisible(aVisRect, *pWindow);
 619
 620                                 bReturn = TRUE;
 621                             }
 622                         }
 623                     }
 624                 }
 625             }
 626         }
 627         break;
 628
 629         // #97016#
 630         case KEY_SPACE:
 631         {
 632             // in calc do only something when draw objects are selected
 633             if(pView->AreObjectsMarked())
 634             {
 635                 const SdrHdlList& rHdlList = pView->GetHdlList();
 636                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 637
 638                 if(pHdl)
 639                 {
 640                     if(pHdl->GetKind() == HDL_POLY)
 641                     {
 642                         // rescue ID of point with focus
 643                         sal_uInt32 nPol(pHdl->GetPolyNum());
 644                         sal_uInt32 nPnt(pHdl->GetPointNum());
 645
 646                         if(pView->IsPointMarked(*pHdl))
 647                         {
 648                             if(rKEvt.GetKeyCode().IsShift())
 649                             {
 650                                 pView->UnmarkPoint(*pHdl);
 651                             }
 652                         }
 653                         else
 654                         {
 655                             if(!rKEvt.GetKeyCode().IsShift())
 656                             {
 657                                 pView->UnmarkAllPoints();
 658                             }
 659
 660                             pView->MarkPoint(*pHdl);
 661                         }
 662
 663                         if(0L == rHdlList.GetFocusHdl())
 664                         {
 665                             // restore point with focus
 666                             SdrHdl* pNewOne = 0L;
 667
 668                             for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
 669                             {
 670                                 SdrHdl* pAct = rHdlList.GetHdl(a);
 671
 672                                 if(pAct
 673                                     && pAct->GetKind() == HDL_POLY
 674                                     && pAct->GetPolyNum() == nPol
 675                                     && pAct->GetPointNum() == nPnt)
 676                                 {
 677                                     pNewOne = pAct;
 678                                 }
 679                             }
 680
 681                             if(pNewOne)
 682                             {
 683                                 ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 684                             }
 685                         }
 686
 687                         bReturn = TRUE;
 688                     }
 689                 }
 690             }
 691         }
 692         break;
 693     }
 694
 695     if (!bReturn)
 696     {
 697         bReturn = FuPoor::KeyInput(rKEvt);
 698     }
 699
 700     if (!bReturn)
 701     {
 702         // #98198# allow direct typing into a selected text object
 703
 704         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 705         if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() && EditEngine::IsSimpleCharInput(rKEvt) )
 706         {
 707             SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 708
 709             // start text edit for suitable object, pass key event to OutlinerView
 710             if ( lcl_KeyEditMode( pObj, pViewShell, &rKEvt ) )
 711                 bReturn = TRUE;
 712         }
 713     }
 714
 715     return (bReturn);
 716 }
 717
 718 // #97016# II
 719 void FuDraw::SelectionHasChanged()
 720 {
 721     const SdrHdlList& rHdlList = pView->GetHdlList();
 722     ((SdrHdlList&)rHdlList).ResetFocusHdl();
 723 }
 724
 725 /*************************************************************************
 726 |*
 727 |* Vor dem Scrollen Selektionsdarstellung ausblenden
 728 |*
 729 \************************************************************************/
 730
 731 void FuDraw::ScrollStart()
 732 {
 733 //              HideShownXor in Gridwin
 734 }
 735
 736 /*************************************************************************
 737 |*
 738 |* Nach dem Scrollen Selektionsdarstellung wieder anzeigen
 739 |*
 740 \************************************************************************/
 741
 742 void FuDraw::ScrollEnd()
 743 {
 744 //              ShowShownXor in Gridwin
 745 }
 746
 747 /*************************************************************************
 748 |*
 749 |* Function aktivieren
 750 |*
 751 \************************************************************************/
 752
 753 void FuDraw::Activate()
 754 {
 755     FuPoor::Activate();
 756 }
 757
 758 /*************************************************************************
 759 |*
 760 |* Function deaktivieren
 761 |*
 762 \************************************************************************/
 763
 764 void FuDraw::Deactivate()
 765 {
 766     FuPoor::Deactivate();
 767 }
 768
 769 /*************************************************************************
 770 |*
 771 |* Maus-Pointer umschalten
 772 |*
 773 \************************************************************************/
 774
 775 BOOL lcl_UrlHit( SdrView* pView, const Point& rPosPixel, Window* pWindow )
 776 {
 777     SdrViewEvent aVEvt;
 778     MouseEvent aMEvt( rPosPixel, 1, 0, MOUSE_LEFT );
 779     SdrHitKind eHit = pView->PickAnything( aMEvt, SDRMOUSEBUTTONDOWN, aVEvt );
 780
 781     if ( eHit != SDRHIT_NONE && aVEvt.pObj != NULL )
 782     {
 783         if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) && ScDrawLayer::GetHitIMapObject(
 784                                 aVEvt.pObj, pWindow->PixelToLogic(rPosPixel), *pWindow ) )
 785             return TRUE;
 786
 787         if ( aVEvt.eEvent == SDREVENT_EXECUTEURL )
 788             return TRUE;
 789     }
 790
 791     return FALSE;
 792 }
 793
 794 void FuDraw::ForcePointer(const MouseEvent* pMEvt)
 795 {
 796     if ( !pView->IsAction() )
 797     {
 798         Point aPosPixel = pWindow->GetPointerPosPixel();
 799         BOOL bAlt               = pMEvt && pMEvt->IsMod2();
 800         Point aPnt              = pWindow->PixelToLogic( aPosPixel );
 801         SdrHdl* pHdl    = pView->PickHandle(aPnt);
 802         SdrObject* pObj;
 803         SdrPageView* pPV;
 804
 805         ScMacroInfo* pInfo = 0;
 806         if ( pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER) )
 807         {
 808             if ( pObj->IsGroupObject() )
 809             {
 810                 SdrObject* pHit = 0;
 811                 if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SDRSEARCH_DEEP ) )
 812                     pObj = pHit;
 813             }
 814             pInfo = ScDrawLayer::GetMacroInfo( pObj );
 815         }
 816
 817         if ( pView->IsTextEdit() )
 818         {
 819             pViewShell->SetActivePointer(Pointer(POINTER_TEXT));                // kann nicht sein ?
 820         }
 821         else if ( pHdl )
 822         {
 823             pViewShell->SetActivePointer(
 824                 pView->GetPreferedPointer( aPnt, pWindow ) );
 825         }
 826         else if ( pView->IsMarkedHit(aPnt) )
 827         {
 828             pViewShell->SetActivePointer( Pointer(POINTER_MOVE) );
 829         }
 830         else if ( !bAlt && ( !pMEvt || !pMEvt->GetButtons() )
 831                         && lcl_UrlHit( pView, aPosPixel, pWindow ) )
 832         {
 833             //  kann mit ALT unterdrueckt werden
 834             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );                  // Text-URL / ImageMap
 835         }
 836         else if ( !bAlt && pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO) )
 837         {
 838             //  kann mit ALT unterdrueckt werden
 839             SdrObjMacroHitRec aHitRec;  //! muss da noch irgendwas gesetzt werden ????
 840             pViewShell->SetActivePointer( pObj->GetMacroPointer(aHitRec) );
 841         }
 842         else if ( !bAlt && pInfo && ((pInfo->GetMacro().getLength() > 0) || (pInfo->GetHlink().getLength() > 0)) )
 843             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );
 844         else if ( IsDetectiveHit( aPnt ) )
 845             pViewShell->SetActivePointer( Pointer( POINTER_DETECTIVE ) );
 846         else
 847             pViewShell->SetActivePointer( aNewPointer );                        //! in Gridwin?
 848     }
 849 }
 850
 851 BOOL FuDraw::IsSizingOrMovingNote( const MouseEvent& rMEvt ) const
 852 {
 853     BOOL bIsSizingOrMoving = FALSE;
 854     if ( rMEvt.IsLeft() )
 855     {
 856         const SdrMarkList& rNoteMarkList = pView->GetMarkedObjectList();
 857         if(rNoteMarkList.GetMarkCount() == 1)
 858         {
 859             SdrObject* pObj = rNoteMarkList.GetMark( 0 )->GetMarkedSdrObj();
 860             if ( ScDrawLayer::IsNoteCaption( pObj ) )
 861             {
 862                 Point aMPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 863                 bIsSizingOrMoving =
 864                     pView->PickHandle( aMPos ) ||      // handles to resize the note
 865                     pView->IsTextEditFrameHit( aMPos );         // frame for moving the note
 866             }
 867         }
 868     }
 869     return bIsSizingOrMoving;
 870 }