svx/source/dialog/graphctl.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: graphctl.cxx,v $
  10  * $Revision: 1.32 $
  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_svx.hxx"
  33 #include <svtools/itempool.hxx>
  34 #include <vcl/dialog.hxx>
  35 #include <vcl/wrkwin.hxx>
  36 #include <svtools/syslocale.hxx>
  37 #include <rtl/math.hxx>
  38 #include <unotools/localedatawrapper.hxx>
  39 #ifndef _UNOTOOLS_PROCESSFACTORY_HXX
  40 #include <comphelper/processfactory.hxx>
  41 #endif
  42 #include <vcl/svapp.hxx>
  43 #include <osl/mutex.hxx>
  44
  45 #include <svx/graphctl.hxx>
  46 #include "GraphCtlAccessibleContext.hxx"
  47 #include "xoutbmp.hxx"
  48 #include <svx/svxids.hrc>
  49 #include <svx/svdpage.hxx>
  50
  51 // #i72889#
  52 #include "sdrpaintwindow.hxx"
  53
  54 /*************************************************************************
  55 |*
  56 |*
  57 |*
  58 \************************************************************************/
  59
  60 void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const Rectangle& /*rOldBoundRect*/ )
  61 {
  62     switch( eType )
  63     {
  64         case( SDRUSERCALL_MOVEONLY ):
  65         case( SDRUSERCALL_RESIZE ):
  66             rWin.SdrObjChanged( rObj );
  67         break;
  68
  69         case( SDRUSERCALL_INSERTED ):
  70             rWin.SdrObjCreated( rObj );
  71         break;
  72
  73         default:
  74         break;
  75     }
  76 }
  77
  78
  79 /*************************************************************************
  80 |*
  81 |*
  82 |*
  83 \************************************************************************/
  84
  85 GraphCtrl::GraphCtrl( Window* pParent, const WinBits nWinBits ) :
  86             Control                     ( pParent, nWinBits ),
  87             aMap100                     ( MAP_100TH_MM ),
  88             eObjKind        ( OBJ_NONE ),
  89             nPolyEdit           ( 0 ),
  90             bEditMode           ( FALSE ),
  91             bSdrMode            ( FALSE ),
  92             mpAccContext    ( NULL ),
  93             pModel          ( NULL ),
  94             pView           ( NULL )
  95 {
  96     pUserCall = new GraphCtrlUserCall( *this );
  97     aUpdateTimer.SetTimeout( 200 );
  98     aUpdateTimer.SetTimeoutHdl( LINK( this, GraphCtrl, UpdateHdl ) );
  99     aUpdateTimer.Start();
 100
 101     SetWinStyle( nWinBits );
 102
 103     EnableRTL( FALSE );
 104 }
 105
 106
 107 /*************************************************************************
 108 |*
 109 |*
 110 |*
 111 \************************************************************************/
 112
 113 GraphCtrl::GraphCtrl( Window* pParent, const ResId& rResId ) :
 114             Control                     ( pParent, rResId ),
 115             aMap100                     ( MAP_100TH_MM ),
 116             nWinStyle       ( 0 ),
 117             eObjKind        ( OBJ_NONE ),
 118             nPolyEdit           ( 0 ),
 119             bEditMode       ( FALSE ),
 120             bSdrMode        ( FALSE ),
 121             bAnim           ( FALSE ),
 122             mpAccContext    ( NULL ),
 123             pModel          ( NULL ),
 124             pView           ( NULL )
 125 {
 126     pUserCall = new GraphCtrlUserCall( *this );
 127     aUpdateTimer.SetTimeout( 500 );
 128     aUpdateTimer.SetTimeoutHdl( LINK( this, GraphCtrl, UpdateHdl ) );
 129     aUpdateTimer.Start();
 130     EnableRTL( FALSE );
 131 }
 132
 133
 134 /*************************************************************************
 135 |*
 136 |*
 137 |*
 138 \************************************************************************/
 139
 140 GraphCtrl::~GraphCtrl()
 141 {
 142     if( mpAccContext )
 143     {
 144         mpAccContext->disposing();
 145         mpAccContext->release();
 146     }
 147     delete pView;
 148     delete pModel;
 149     delete pUserCall;
 150 }
 151
 152
 153 /*************************************************************************
 154 |*
 155 |*
 156 |*
 157 \************************************************************************/
 158
 159 void GraphCtrl::SetWinStyle( WinBits nWinBits )
 160 {
 161     nWinStyle = nWinBits;
 162     bAnim = ( nWinStyle & WB_ANIMATION ) == WB_ANIMATION;
 163     bSdrMode = ( nWinStyle & WB_SDRMODE ) == WB_SDRMODE;
 164
 165     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 166     SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
 167     SetMapMode( aMap100 );
 168
 169     delete pView;
 170     pView = NULL;
 171
 172     delete pModel;
 173     pModel = NULL;
 174
 175     if ( bSdrMode )
 176         InitSdrModel();
 177 }
 178
 179
 180 /*************************************************************************
 181 |*
 182 |*
 183 |*
 184 \************************************************************************/
 185
 186 void GraphCtrl::InitSdrModel()
 187 {
 188     ::vos::OGuard aGuard (Application::GetSolarMutex());
 189
 190     SdrPage* pPage;
 191
 192     // alten Kram zerstoeren
 193     delete pView;
 194     delete pModel;
 195
 196     // Model anlegen
 197     pModel = new SdrModel;
 198     pModel->GetItemPool().FreezeIdRanges();
 199     pModel->SetScaleUnit( aMap100.GetMapUnit() );
 200     pModel->SetScaleFraction( Fraction( 1, 1 ) );
 201     pModel->SetDefaultFontHeight( 500 );
 202
 203     pPage = new SdrPage( *pModel );
 204
 205     pPage->SetSize( aGraphSize );
 206     pPage->SetBorder( 0, 0, 0, 0 );
 207     pModel->InsertPage( pPage );
 208     pModel->SetChanged( sal_False );
 209
 210     // View anlegen
 211     pView = new GraphCtrlView( pModel, this );
 212     pView->SetWorkArea( Rectangle( Point(), aGraphSize ) );
 213     pView->EnableExtendedMouseEventDispatcher( TRUE );
 214     pView->ShowSdrPage(pView->GetModel()->GetPage(0));
 215 //      pView->ShowSdrPage(pView->GetModel()->GetPage(0));
 216     pView->SetFrameDragSingles( TRUE );
 217     pView->SetMarkedPointsSmooth( SDRPATHSMOOTH_SYMMETRIC );
 218     pView->SetEditMode( TRUE );
 219
 220     // #i72889# set neeeded flags
 221     pView->SetPagePaintingAllowed(false);
 222     pView->SetBufferedOutputAllowed(true);
 223     pView->SetBufferedOverlayAllowed(true);
 224
 225     // Tell the accessibility object about the changes.
 226     if (mpAccContext != NULL)
 227         mpAccContext->setModelAndView (pModel, pView);
 228 }
 229
 230
 231 /*************************************************************************
 232 |*
 233 |*
 234 |*
 235 \************************************************************************/
 236
 237 void GraphCtrl::SetGraphic( const Graphic& rGraphic, BOOL bNewModel )
 238 {
 239     // Bitmaps dithern wir ggf. fuer die Anzeige
 240     if ( !bAnim && ( rGraphic.GetType() == GRAPHIC_BITMAP )  )
 241     {
 242         if ( rGraphic.IsTransparent() )
 243         {
 244             Bitmap      aBmp( rGraphic.GetBitmap() );
 245
 246             DitherBitmap( aBmp );
 247             aGraphic = Graphic( BitmapEx( aBmp, rGraphic.GetBitmapEx().GetMask() ) );
 248         }
 249         else
 250         {
 251             Bitmap aBmp( rGraphic.GetBitmap() );
 252             DitherBitmap( aBmp );
 253             aGraphic = aBmp;
 254         }
 255     }
 256     else
 257         aGraphic = rGraphic;
 258
 259     if ( aGraphic.GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
 260         aGraphSize = Application::GetDefaultDevice()->PixelToLogic( aGraphic.GetPrefSize(), aMap100 );
 261     else
 262         aGraphSize = OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 );
 263
 264     if ( bSdrMode && bNewModel )
 265         InitSdrModel();
 266
 267     if ( aGraphSizeLink.IsSet() )
 268         aGraphSizeLink.Call( this );
 269
 270     Resize();
 271     Invalidate();
 272 }
 273
 274
 275 /*************************************************************************
 276 |*
 277 |*
 278 |*
 279 \************************************************************************/
 280
 281 void GraphCtrl::Resize()
 282 {
 283     Control::Resize();
 284
 285     if ( aGraphSize.Width() && aGraphSize.Height() )
 286     {
 287         MapMode                 aDisplayMap( aMap100 );
 288         Point           aNewPos;
 289         Size                    aNewSize;
 290         const Size              aWinSize = PixelToLogic( GetOutputSizePixel(), aDisplayMap );
 291         const long              nWidth = aWinSize.Width();
 292         const long              nHeight = aWinSize.Height();
 293         double          fGrfWH = (double) aGraphSize.Width() / aGraphSize.Height();
 294         double          fWinWH = (double) nWidth / nHeight;
 295
 296         // Bitmap an Thumbgroesse anpassen
 297         if ( fGrfWH < fWinWH)
 298         {
 299             aNewSize.Width() = (long) ( (double) nHeight * fGrfWH );
 300             aNewSize.Height()= nHeight;
 301         }
 302         else
 303         {
 304             aNewSize.Width() = nWidth;
 305             aNewSize.Height()= (long) ( (double) nWidth / fGrfWH );
 306         }
 307
 308         aNewPos.X() = ( nWidth - aNewSize.Width() )  >> 1;
 309         aNewPos.Y() = ( nHeight - aNewSize.Height() ) >> 1;
 310
 311         // MapMode fuer Engine umsetzen
 312         aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) );
 313         aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) );
 314
 315         aDisplayMap.SetOrigin( LogicToLogic( aNewPos, aMap100, aDisplayMap ) );
 316         SetMapMode( aDisplayMap );
 317     }
 318
 319     Invalidate();
 320 }
 321
 322
 323 /*************************************************************************
 324 |*
 325 |*
 326 |*
 327 \************************************************************************/
 328
 329 void GraphCtrl::Paint( const Rectangle& rRect )
 330 {
 331     // #i72889# used splitted repaint to be able to paint an own background
 332     // even to the buffered view
 333     const bool bGraphicValid(GRAPHIC_NONE != aGraphic.GetType());
 334
 335     if(bSdrMode)
 336     {
 337         SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(this);
 338
 339         if(bGraphicValid)
 340         {
 341             OutputDevice& rTarget = pPaintWindow->GetTargetOutputDevice();
 342
 343             rTarget.SetBackground(GetBackground());
 344             rTarget.Erase();
 345
 346             aGraphic.Draw(&rTarget, Point(), aGraphSize);
 347         }
 348
 349         const Region aRepaintRegion(rRect);
 350         pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion);
 351         pView->EndCompleteRedraw(*pPaintWindow, true);
 352     }
 353     else
 354     {
 355         // #i73381# in non-SdrMode, paint to local directly
 356         if(bGraphicValid)
 357         {
 358             aGraphic.Draw(this, Point(), aGraphSize);
 359         }
 360     }
 361 }
 362
 363
 364 /*************************************************************************
 365 |*
 366 |*
 367 |*
 368 \************************************************************************/
 369
 370 void GraphCtrl::SdrObjChanged( const SdrObject&  )
 371 {
 372 }
 373
 374
 375 /*************************************************************************
 376 |*
 377 |*
 378 |*
 379 \************************************************************************/
 380
 381 void GraphCtrl::SdrObjCreated( const SdrObject& )
 382 {
 383 }
 384
 385
 386 /*************************************************************************
 387 |*
 388 |*
 389 |*
 390 \************************************************************************/
 391
 392 void GraphCtrl::MarkListHasChanged()
 393 {
 394     if ( aMarkObjLink.IsSet() )
 395         aMarkObjLink.Call( this );
 396 }
 397
 398
 399 /*************************************************************************
 400 |*
 401 |*
 402 |*
 403 \************************************************************************/
 404
 405 void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 406 {
 407     KeyCode aCode( rKEvt.GetKeyCode() );
 408     BOOL        bProc = FALSE;
 409
 410     switch ( aCode.GetCode() )
 411     {
 412         case KEY_DELETE:
 413         case KEY_BACKSPACE:
 414         {
 415             if ( bSdrMode )
 416             {
 417                 pView->DeleteMarked();
 418                 bProc = TRUE;
 419                 if( !pView->AreObjectsMarked() )
 420                     ((Dialog*)GetParent())->GrabFocusToFirstControl();
 421             }
 422         }
 423         break;
 424
 425         case KEY_ESCAPE:
 426         {
 427             if ( bSdrMode )
 428             {
 429                 if ( pView->IsAction() )
 430                 {
 431                     pView->BrkAction();
 432                 }
 433                 else if ( pView->AreObjectsMarked() )
 434                 {
 435                     const SdrHdlList& rHdlList = pView->GetHdlList();
 436                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 437
 438                     if(pHdl)
 439                     {
 440                         ((SdrHdlList&)rHdlList).ResetFocusHdl();
 441                     }
 442                     else
 443                     {
 444                         ((Dialog*)GetParent())->GrabFocusToFirstControl();
 445                     }
 446                 }
 447                 else
 448                 {
 449                     ((Dialog*)GetParent())->GrabFocusToFirstControl();
 450                 }
 451                 bProc = TRUE;
 452             }
 453         }
 454         break;
 455
 456         case KEY_F11:
 457         case KEY_TAB:
 458         {
 459             if( bSdrMode )
 460             {
 461                 if( !aCode.IsMod1() && !aCode.IsMod2() )
 462                 {
 463                     bool bForward = !aCode.IsShift();
 464                     // select next object
 465                     if ( ! pView->MarkNextObj( bForward ))
 466                     {
 467                         // At first or last object.  Cycle to the other end
 468                         // of the list.
 469                         pView->UnmarkAllObj();
 470                         pView->MarkNextObj (bForward);
 471                     }
 472                     bProc = TRUE;
 473                 }
 474                 else if(aCode.IsMod1())
 475                 {
 476                     // select next handle
 477                     const SdrHdlList& rHdlList = pView->GetHdlList();
 478                     sal_Bool bForward(!aCode.IsShift());
 479
 480                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
 481
 482                     bProc = true;
 483                 }
 484             }
 485         }
 486         break;
 487
 488         case KEY_END:
 489         {
 490
 491             if ( aCode.IsMod1() )
 492             {
 493                 // #97016# mark last object
 494                 pView->UnmarkAllObj();
 495                 pView->MarkNextObj(FALSE);
 496
 497                 bProc = true;
 498             }
 499         }
 500         break;
 501
 502         case KEY_HOME:
 503         {
 504             if ( aCode.IsMod1() )
 505             {
 506                 pView->UnmarkAllObj();
 507                 pView->MarkNextObj(TRUE);
 508
 509                 bProc = true;
 510             }
 511         }
 512         break;
 513
 514         case KEY_UP:
 515         case KEY_DOWN:
 516         case KEY_LEFT:
 517         case KEY_RIGHT:
 518         {
 519             long nX = 0;
 520             long nY = 0;
 521
 522             if (aCode.GetCode() == KEY_UP)
 523             {
 524                 // Scroll nach oben
 525                 nX = 0;
 526                 nY =-1;
 527             }
 528             else if (aCode.GetCode() == KEY_DOWN)
 529             {
 530                 // Scroll nach unten
 531                 nX = 0;
 532                 nY = 1;
 533             }
 534             else if (aCode.GetCode() == KEY_LEFT)
 535             {
 536                 // Scroll nach links
 537                 nX =-1;
 538                 nY = 0;
 539             }
 540             else if (aCode.GetCode() == KEY_RIGHT)
 541             {
 542                 // Scroll nach rechts
 543                 nX = 1;
 544                 nY = 0;
 545             }
 546
 547             if (pView->AreObjectsMarked() && !aCode.IsMod1() )
 548             {
 549                 if(aCode.IsMod2())
 550                 {
 551                     // #97016# move in 1 pixel distance
 552                     Size aLogicSizeOnePixel = PixelToLogic(Size(1,1));
 553                     nX *= aLogicSizeOnePixel.Width();
 554                     nY *= aLogicSizeOnePixel.Height();
 555                 }
 556                 else
 557                 {
 558                     // old, fixed move distance
 559                     nX *= 100;
 560                     nY *= 100;
 561                 }
 562
 563                 // #97016# II
 564                 const SdrHdlList& rHdlList = pView->GetHdlList();
 565                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 566
 567                 if(0L == pHdl)
 568                 {
 569                     // #90129# restrict movement to WorkArea
 570                     const Rectangle& rWorkArea = pView->GetWorkArea();
 571
 572                     if(!rWorkArea.IsEmpty())
 573                     {
 574                         Rectangle aMarkRect(pView->GetMarkedObjRect());
 575                         aMarkRect.Move(nX, nY);
 576
 577                         if(!aMarkRect.IsInside(rWorkArea))
 578                         {
 579                             if(aMarkRect.Left() < rWorkArea.Left())
 580                             {
 581                                 nX += rWorkArea.Left() - aMarkRect.Left();
 582                             }
 583
 584                             if(aMarkRect.Right() > rWorkArea.Right())
 585                             {
 586                                 nX -= aMarkRect.Right() - rWorkArea.Right();
 587                             }
 588
 589                             if(aMarkRect.Top() < rWorkArea.Top())
 590                             {
 591                                 nY += rWorkArea.Top() - aMarkRect.Top();
 592                             }
 593
 594                             if(aMarkRect.Bottom() > rWorkArea.Bottom())
 595                             {
 596                                 nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 597                             }
 598                         }
 599                     }
 600
 601                     // no handle selected
 602                     if(0 != nX || 0 != nY)
 603                     {
 604                         pView->MoveAllMarked(Size(nX, nY));
 605                     }
 606                 }
 607                 else
 608                 {
 609                     // move handle with index nHandleIndex
 610                     if(pHdl && (nX || nY))
 611                     {
 612                         // now move the Handle (nX, nY)
 613                         Point aStartPoint(pHdl->GetPos());
 614                         Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 615                         const SdrDragStat& rDragStat = pView->GetDragStat();
 616
 617                         // start dragging
 618                         pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 619
 620                         if(pView->IsDragObj())
 621                         {
 622                             FASTBOOL bWasNoSnap = rDragStat.IsNoSnap();
 623                             BOOL bWasSnapEnabled = pView->IsSnapEnabled();
 624
 625                             // switch snapping off
 626                             if(!bWasNoSnap)
 627                                 ((SdrDragStat&)rDragStat).SetNoSnap(TRUE);
 628                             if(bWasSnapEnabled)
 629                                 pView->SetSnapEnabled(FALSE);
 630
 631                             pView->MovAction(aEndPoint);
 632                             pView->EndDragObj();
 633
 634                             // restore snap
 635                             if(!bWasNoSnap)
 636                                 ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 637                             if(bWasSnapEnabled)
 638                                 pView->SetSnapEnabled(bWasSnapEnabled);
 639                         }
 640                     }
 641                 }
 642
 643                 bProc = true;
 644             }
 645         }
 646         break;
 647
 648         case KEY_SPACE:
 649         {
 650             const SdrHdlList& rHdlList = pView->GetHdlList();
 651             SdrHdl* pHdl = rHdlList.GetFocusHdl();
 652
 653             if(pHdl)
 654             {
 655                 if(pHdl->GetKind() == HDL_POLY)
 656                 {
 657                     // rescue ID of point with focus
 658                     sal_uInt32 nPol(pHdl->GetPolyNum());
 659                     sal_uInt32 nPnt(pHdl->GetPointNum());
 660
 661                     if(pView->IsPointMarked(*pHdl))
 662                     {
 663                         if(rKEvt.GetKeyCode().IsShift())
 664                         {
 665                             pView->UnmarkPoint(*pHdl);
 666                         }
 667                     }
 668                     else
 669                     {
 670                         if(!rKEvt.GetKeyCode().IsShift())
 671                         {
 672                             pView->UnmarkAllPoints();
 673                         }
 674
 675                         pView->MarkPoint(*pHdl);
 676                     }
 677
 678                     if(0L == rHdlList.GetFocusHdl())
 679                     {
 680                         // restore point with focus
 681                         SdrHdl* pNewOne = 0L;
 682
 683                         for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
 684                         {
 685                             SdrHdl* pAct = rHdlList.GetHdl(a);
 686
 687                             if(pAct
 688                                 && pAct->GetKind() == HDL_POLY
 689                                 && pAct->GetPolyNum() == nPol
 690                                 && pAct->GetPointNum() == nPnt)
 691                             {
 692                                 pNewOne = pAct;
 693                             }
 694                         }
 695
 696                         if(pNewOne)
 697                         {
 698                             ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 699                         }
 700                     }
 701
 702                     bProc = TRUE;
 703                 }
 704             }
 705         }
 706         break;
 707
 708         default:
 709         break;
 710     }
 711
 712     if ( !bProc )
 713         Control::KeyInput( rKEvt );
 714     else
 715         ReleaseMouse();
 716 }
 717
 718
 719 /*************************************************************************
 720 |*
 721 |*
 722 |*
 723 \************************************************************************/
 724
 725 void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
 726 {
 727     if ( bSdrMode && ( rMEvt.GetClicks() < 2 ) )
 728     {
 729         const Point aLogPt( PixelToLogic( rMEvt.GetPosPixel() ) );
 730
 731         if ( !Rectangle( Point(), aGraphSize ).IsInside( aLogPt ) && !pView->IsEditMode() )
 732             Control::MouseButtonDown( rMEvt );
 733         else
 734         {
 735             // Focus anziehen fuer Key-Inputs
 736             GrabFocus();
 737
 738             if ( nPolyEdit )
 739             {
 740                 SdrViewEvent    aVEvt;
 741                 SdrHitKind              eHit = pView->PickAnything( rMEvt, SDRMOUSEBUTTONDOWN, aVEvt );
 742
 743                 if ( nPolyEdit == SID_BEZIER_INSERT && eHit == SDRHIT_MARKEDOBJECT )
 744                     pView->BegInsObjPoint( aLogPt, rMEvt.IsMod1());
 745                 else
 746                     pView->MouseButtonDown( rMEvt, this );
 747             }
 748             else
 749                 pView->MouseButtonDown( rMEvt, this );
 750         }
 751
 752         SdrObject* pCreateObj = pView->GetCreateObj();
 753
 754         // Wir wollen das Inserten mitbekommen
 755         if ( pCreateObj && !pCreateObj->GetUserCall() )
 756             pCreateObj->SetUserCall( pUserCall );
 757
 758         SetPointer( pView->GetPreferedPointer( aLogPt, this ) );
 759     }
 760     else
 761         Control::MouseButtonDown( rMEvt );
 762 }
 763
 764
 765 /*************************************************************************
 766 |*
 767 |*
 768 |*
 769 \************************************************************************/
 770
 771 void GraphCtrl::MouseMove(const MouseEvent& rMEvt)
 772 {
 773     const Point aLogPos( PixelToLogic( rMEvt.GetPosPixel() ) );
 774
 775     if ( bSdrMode )
 776     {
 777         pView->MouseMove( rMEvt, this );
 778
 779         if( ( SID_BEZIER_INSERT == nPolyEdit ) &&
 780             !pView->PickHandle( aLogPos ) &&
 781             !pView->IsInsObjPoint() )
 782         {
 783             SetPointer( POINTER_CROSS );
 784         }
 785         else
 786             SetPointer( pView->GetPreferedPointer( aLogPos, this ) );
 787     }
 788     else
 789         Control::MouseButtonUp( rMEvt );
 790
 791     if ( aMousePosLink.IsSet() )
 792     {
 793         if ( Rectangle( Point(), aGraphSize ).IsInside( aLogPos ) )
 794             aMousePos = aLogPos;
 795         else
 796             aMousePos = Point();
 797
 798         aMousePosLink.Call( this );
 799     }
 800 }
 801
 802
 803 /*************************************************************************
 804 |*
 805 |*
 806 |*
 807 \************************************************************************/
 808
 809 void GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
 810 {
 811     if ( bSdrMode )
 812     {
 813         if ( pView->IsInsObjPoint() )
 814             pView->EndInsObjPoint( SDRCREATE_FORCEEND );
 815         else
 816             pView->MouseButtonUp( rMEvt, this );
 817
 818         ReleaseMouse();
 819         SetPointer( pView->GetPreferedPointer( PixelToLogic( rMEvt.GetPosPixel() ), this ) );
 820     }
 821     else
 822         Control::MouseButtonUp( rMEvt );
 823 }
 824
 825
 826 /*************************************************************************
 827 |*
 828 |*
 829 |*
 830 \************************************************************************/
 831
 832 SdrObject* GraphCtrl::GetSelectedSdrObject() const
 833 {
 834     SdrObject* pSdrObj = NULL;
 835
 836     if ( bSdrMode )
 837     {
 838         const SdrMarkList&      rMarkList = pView->GetMarkedObjectList();
 839
 840         if ( rMarkList.GetMarkCount() == 1 )
 841             pSdrObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 842     }
 843
 844     return pSdrObj;
 845 }
 846
 847
 848 /*************************************************************************
 849 |*
 850 |*
 851 |*
 852 \************************************************************************/
 853
 854 void GraphCtrl::SetEditMode( const BOOL _bEditMode )
 855 {
 856     if ( bSdrMode )
 857     {
 858         bEditMode = _bEditMode;
 859         pView->SetEditMode( bEditMode );
 860         eObjKind = OBJ_NONE;
 861         pView->SetCurrentObj( sal::static_int_cast< UINT16 >( eObjKind ) );
 862     }
 863     else
 864         bEditMode = FALSE;
 865 }
 866
 867
 868 /*************************************************************************
 869 |*
 870 |*
 871 |*
 872 \************************************************************************/
 873
 874 void GraphCtrl::SetPolyEditMode( const USHORT _nPolyEdit )
 875 {
 876     if ( bSdrMode && ( _nPolyEdit != nPolyEdit ) )
 877     {
 878         nPolyEdit = _nPolyEdit;
 879         pView->SetFrameDragSingles( nPolyEdit == 0 );
 880     }
 881     else
 882         nPolyEdit = 0;
 883 }
 884
 885
 886 /*************************************************************************
 887 |*
 888 |*
 889 |*
 890 \************************************************************************/
 891
 892 void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
 893 {
 894     if ( bSdrMode )
 895     {
 896         bEditMode = FALSE;
 897         pView->SetEditMode( bEditMode );
 898         eObjKind = _eObjKind;
 899         pView->SetCurrentObj( sal::static_int_cast< UINT16 >( eObjKind ) );
 900     }
 901     else
 902         eObjKind = OBJ_NONE;
 903 }
 904
 905
 906 /*************************************************************************
 907 |*
 908 |*
 909 |*
 910 \************************************************************************/
 911
 912 String GraphCtrl::GetStringFromDouble( const double& rDouble )
 913 {
 914     sal_Unicode cSep =
 915         SvtSysLocale().GetLocaleData().getNumDecimalSep().GetChar(0);
 916     String aStr( ::rtl::math::doubleToUString( rDouble,
 917                 rtl_math_StringFormat_F, 2, cSep ));
 918     return aStr;
 919 }
 920
 921
 922 /*************************************************************************
 923 www|*
 924 |*
 925 |*
 926 \************************************************************************/
 927
 928 IMPL_LINK( GraphCtrl, UpdateHdl, Timer*, pTimer )
 929 {
 930     if ( aUpdateLink.IsSet() )
 931         aUpdateLink.Call( this );
 932
 933     pTimer->Start();
 934
 935     return 0L;
 936 }
 937
 938
 939 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > GraphCtrl::CreateAccessible()
 940 {
 941     if( mpAccContext == NULL )
 942     {
 943         Window* pParent = GetParent();
 944
 945         DBG_ASSERT( pParent, "-GraphCtrl::CreateAccessible(): No Parent!" );
 946
 947         if( pParent )
 948         {
 949             ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAccParent( pParent->GetAccessible() );
 950
 951             // #103856# Disable accessibility if no model/view data available
 952             if( pView &&
 953                 pModel &&
 954                 xAccParent.is() )
 955             {
 956                 mpAccContext = new SvxGraphCtrlAccessibleContext( xAccParent, *this );
 957                 mpAccContext->acquire();
 958             }
 959         }
 960     }
 961
 962     return mpAccContext;
 963 }