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 |* 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 if(rKEvt.GetKeyCode().IsShift()) // #i121236# Support for shift key in calc
 465                     {
 466                         nX *= 1000;
 467                         nY *= 1000;
 468                     }
 469                     else
 470                     {
 471                         // old, fixed move distance
 472                         nX *= 100;
 473                         nY *= 100;
 474                     }
 475
 476                     // is there a movement to do?
 477                     if(0 != nX || 0 != nY)
 478                     {
 479                         // II
 480                         const SdrHdlList& rHdlList = pView->GetHdlList();
 481                         SdrHdl* pHdl = rHdlList.GetFocusHdl();
 482
 483                         if(0L == pHdl)
 484                         {
 485                             // only take action when move is allowed
 486                             if(pView->IsMoveAllowed())
 487                             {
 488                                 // restrict movement to WorkArea
 489                                 const Rectangle& rWorkArea = pView->GetWorkArea();
 490
 491                                 if(!rWorkArea.IsEmpty())
 492                                 {
 493                                     Rectangle aMarkRect(pView->GetMarkedObjRect());
 494                                     aMarkRect.Move(nX, nY);
 495
 496                                     if(!aMarkRect.IsInside(rWorkArea))
 497                                     {
 498                                         if(aMarkRect.Left() < rWorkArea.Left())
 499                                         {
 500                                             nX += rWorkArea.Left() - aMarkRect.Left();
 501                                         }
 502
 503                                         if(aMarkRect.Right() > rWorkArea.Right())
 504                                         {
 505                                             nX -= aMarkRect.Right() - rWorkArea.Right();
 506                                         }
 507
 508                                         if(aMarkRect.Top() < rWorkArea.Top())
 509                                         {
 510                                             nY += rWorkArea.Top() - aMarkRect.Top();
 511                                         }
 512
 513                                         if(aMarkRect.Bottom() > rWorkArea.Bottom())
 514                                         {
 515                                             nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 516                                         }
 517                                     }
 518                                 }
 519
 520                                 // now move the selected draw objects
 521                                 pView->MoveAllMarked(Size(nX, nY));
 522
 523                                 // II
 524                                 pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
 525
 526                                 bReturn = sal_True;
 527                             }
 528                         }
 529                         else
 530                         {
 531                             // move handle with index nHandleIndex
 532                             if(pHdl && (nX || nY))
 533                             {
 534                                 // now move the Handle (nX, nY)
 535                                 Point aStartPoint(pHdl->GetPos());
 536                                 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 537                                 const SdrDragStat& rDragStat = pView->GetDragStat();
 538
 539                                 // start dragging
 540                                 pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 541
 542                                 if(pView->IsDragObj())
 543                                 {
 544                                     bool bWasNoSnap = rDragStat.IsNoSnap();
 545                                     sal_Bool bWasSnapEnabled = pView->IsSnapEnabled();
 546
 547                                     // switch snapping off
 548                                     if(!bWasNoSnap)
 549                                         ((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
 550                                     if(bWasSnapEnabled)
 551                                         pView->SetSnapEnabled(false);
 552
 553                                     pView->MovAction(aEndPoint);
 554                                     pView->EndDragObj();
 555
 556                                     // restore snap
 557                                     if(!bWasNoSnap)
 558                                         ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 559                                     if(bWasSnapEnabled)
 560                                         pView->SetSnapEnabled(bWasSnapEnabled);
 561                                 }
 562
 563                                 // make moved handle visible
 564                                 Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
 565                                 pView->MakeVisible(aVisRect, *pWindow);
 566
 567                                 bReturn = sal_True;
 568                             }
 569                         }
 570                     }
 571                 }
 572             }
 573         }
 574         break;
 575
 576         // #97016#
 577         case KEY_SPACE:
 578         {
 579             // in calc do only something when draw objects are selected
 580             if(pView->AreObjectsMarked())
 581             {
 582                 const SdrHdlList& rHdlList = pView->GetHdlList();
 583                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 584
 585                 if(pHdl)
 586                 {
 587                     if(pHdl->GetKind() == HDL_POLY)
 588                     {
 589                         // rescue ID of point with focus
 590                         sal_uInt32 nPol(pHdl->GetPolyNum());
 591                         sal_uInt32 nPnt(pHdl->GetPointNum());
 592
 593                         if(pView->IsPointMarked(*pHdl))
 594                         {
 595                             if(rKEvt.GetKeyCode().IsShift())
 596                             {
 597                                 pView->UnmarkPoint(*pHdl);
 598                             }
 599                         }
 600                         else
 601                         {
 602                             if(!rKEvt.GetKeyCode().IsShift())
 603                             {
 604                                 pView->UnmarkAllPoints();
 605                             }
 606
 607                             pView->MarkPoint(*pHdl);
 608                         }
 609
 610                         if(0L == rHdlList.GetFocusHdl())
 611                         {
 612                             // restore point with focus
 613                             SdrHdl* pNewOne = 0L;
 614
 615                             for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
 616                             {
 617                                 SdrHdl* pAct = rHdlList.GetHdl(a);
 618
 619                                 if(pAct
 620                                     && pAct->GetKind() == HDL_POLY
 621                                     && pAct->GetPolyNum() == nPol
 622                                     && pAct->GetPointNum() == nPnt)
 623                                 {
 624                                     pNewOne = pAct;
 625                                 }
 626                             }
 627
 628                             if(pNewOne)
 629                             {
 630                                 ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 631                             }
 632                         }
 633
 634                         bReturn = sal_True;
 635                     }
 636                 }
 637             }
 638         }
 639         break;
 640     }
 641
 642     if (!bReturn)
 643     {
 644         bReturn = FuPoor::KeyInput(rKEvt);
 645     }
 646
 647     if (!bReturn)
 648     {
 649         // allow direct typing into a selected text object
 650
 651         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 652         if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() && EditEngine::IsSimpleCharInput(rKEvt) )
 653         {
 654             SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 655
 656             // start text edit for suitable object, pass key event to OutlinerView
 657             if ( lcl_KeyEditMode( pObj, pViewShell, &rKEvt ) )
 658                 bReturn = sal_True;
 659         }
 660     }
 661
 662     return (bReturn);
 663 }
 664
 665 // II
 666 void FuDraw::SelectionHasChanged()
 667 {
 668     const SdrHdlList& rHdlList = pView->GetHdlList();
 669     ((SdrHdlList&)rHdlList).ResetFocusHdl();
 670 }
 671
 672 /*************************************************************************
 673 |*
 674 |* Function aktivieren
 675 |*
 676 \************************************************************************/
 677
 678 void FuDraw::Activate()
 679 {
 680     FuPoor::Activate();
 681 }
 682
 683 /*************************************************************************
 684 |*
 685 |* Function deaktivieren
 686 |*
 687 \************************************************************************/
 688
 689 void FuDraw::Deactivate()
 690 {
 691     FuPoor::Deactivate();
 692 }
 693
 694 /*************************************************************************
 695 |*
 696 |* Maus-Pointer umschalten
 697 |*
 698 \************************************************************************/
 699
 700 static sal_Bool lcl_UrlHit( SdrView* pView, const Point& rPosPixel, Window* pWindow )
 701 {
 702     SdrViewEvent aVEvt;
 703     MouseEvent aMEvt( rPosPixel, 1, 0, MOUSE_LEFT );
 704     SdrHitKind eHit = pView->PickAnything( aMEvt, SDRMOUSEBUTTONDOWN, aVEvt );
 705
 706     if ( eHit != SDRHIT_NONE && aVEvt.pObj != NULL )
 707     {
 708         if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) && ScDrawLayer::GetHitIMapObject(
 709                                 aVEvt.pObj, pWindow->PixelToLogic(rPosPixel), *pWindow ) )
 710             return sal_True;
 711
 712         if ( aVEvt.eEvent == SDREVENT_EXECUTEURL )
 713             return sal_True;
 714     }
 715
 716     return false;
 717 }
 718
 719 void FuDraw::ForcePointer(const MouseEvent* pMEvt)
 720 {
 721     if ( !pView->IsAction() )
 722     {
 723         Point aPosPixel = pWindow->GetPointerPosPixel();
 724         sal_Bool bAlt       = pMEvt && pMEvt->IsMod2();
 725         Point aPnt      = pWindow->PixelToLogic( aPosPixel );
 726         SdrHdl* pHdl    = pView->PickHandle(aPnt);
 727         SdrObject* pObj;
 728         SdrPageView* pPV;
 729
 730         ScMacroInfo* pInfo = 0;
 731         if ( pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER) )
 732         {
 733             if ( pObj->IsGroupObject() )
 734             {
 735                 SdrObject* pHit = 0;
 736                 if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SDRSEARCH_DEEP ) )
 737                     pObj = pHit;
 738             }
 739             pInfo = ScDrawLayer::GetMacroInfo( pObj );
 740         }
 741
 742         if ( pView->IsTextEdit() )
 743         {
 744             pViewShell->SetActivePointer(Pointer(POINTER_TEXT));        // kann nicht sein ?
 745         }
 746         else if ( pHdl )
 747         {
 748             pViewShell->SetActivePointer(
 749                 pView->GetPreferedPointer( aPnt, pWindow ) );
 750         }
 751         else if ( pView->IsMarkedHit(aPnt) )
 752         {
 753             pViewShell->SetActivePointer( Pointer(POINTER_MOVE) );
 754         }
 755         else if ( !bAlt && ( !pMEvt || !pMEvt->GetButtons() )
 756                         && lcl_UrlHit( pView, aPosPixel, pWindow ) )
 757         {
 758             //  kann mit ALT unterdrueckt werden
 759             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );          // Text-URL / ImageMap
 760         }
 761         else if ( !bAlt && pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO) )
 762         {
 763             //  kann mit ALT unterdrueckt werden
 764             SdrObjMacroHitRec aHitRec;  //! muss da noch irgendwas gesetzt werden ????
 765             pViewShell->SetActivePointer( pObj->GetMacroPointer(aHitRec) );
 766         }
 767         else if ( !bAlt && pInfo && (!pInfo->GetMacro().isEmpty() || !pInfo->GetHlink().isEmpty()) )
 768             pWindow->SetPointer( Pointer( POINTER_REFHAND ) );
 769         else if ( IsDetectiveHit( aPnt ) )
 770             pViewShell->SetActivePointer( Pointer( POINTER_DETECTIVE ) );
 771         else
 772             pViewShell->SetActivePointer( aNewPointer );            //! in Gridwin?
 773     }
 774 }
 775
 776 sal_Bool FuDraw::IsEditingANote() const
 777 {
 778     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 779     sal_Int32 backval=rMarkList.GetMarkCount();
 780     for (sal_Int32 nlv1=0;nlv1<backval;nlv1++)
 781     {
 782         SdrObject* pObj = rMarkList.GetMark( nlv1 )->GetMarkedSdrObj();
 783         if ( ScDrawLayer::IsNoteCaption( pObj ) )
 784         {
 785             return true;
 786         }
 787     }
 788     return false;
 789 }
 790
 791 sal_Bool FuDraw::IsSizingOrMovingNote( const MouseEvent& rMEvt ) const
 792 {
 793     sal_Bool bIsSizingOrMoving = false;
 794     if ( rMEvt.IsLeft() )
 795     {
 796         const SdrMarkList& rNoteMarkList = pView->GetMarkedObjectList();
 797         if(rNoteMarkList.GetMarkCount() == 1)
 798         {
 799             SdrObject* pObj = rNoteMarkList.GetMark( 0 )->GetMarkedSdrObj();
 800             if ( ScDrawLayer::IsNoteCaption( pObj ) )
 801             {
 802                 Point aMPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 803                 bIsSizingOrMoving =
 804                     pView->PickHandle( aMPos ) ||      // handles to resize the note
 805                     pView->IsTextEditFrameHit( aMPos );         // frame for moving the note
 806             }
 807         }
 808     }
 809     return bIsSizingOrMoving;
 810 }
 811
 812 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */