svx/source/dialog/graphctl.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 <svl/itempool.hxx>
  21 #include <vcl/dialog.hxx>
  22 #include <vcl/wrkwin.hxx>
  23 #include <vcl/settings.hxx>
  24 #include <vcl/builderfactory.hxx>
  25 #include <unotools/syslocale.hxx>
  26 #include <rtl/math.hxx>
  27 #include <unotools/localedatawrapper.hxx>
  28 #include <comphelper/processfactory.hxx>
  29 #include <vcl/svapp.hxx>
  30 #include <osl/mutex.hxx>
  31
  32 #include <svx/graphctl.hxx>
  33 #include "GraphCtlAccessibleContext.hxx"
  34 #include "svx/xoutbmp.hxx"
  35 #include <svx/svxids.hrc>
  36 #include <svx/svdpage.hxx>
  37 #include "svx/sdrpaintwindow.hxx"
  38
  39 void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const Rectangle& /*rOldBoundRect*/ )
  40 {
  41     switch( eType )
  42     {
  43         case( SDRUSERCALL_MOVEONLY ):
  44         case( SDRUSERCALL_RESIZE ):
  45             rWin.SdrObjChanged( rObj );
  46         break;
  47
  48         case( SDRUSERCALL_INSERTED ):
  49             rWin.SdrObjCreated( rObj );
  50         break;
  51
  52         default:
  53         break;
  54     }
  55 }
  56
  57 GraphCtrl::GraphCtrl( vcl::Window* pParent, WinBits nStyle ) :
  58             Control         ( pParent, nStyle ),
  59             aMap100         ( MAP_100TH_MM ),
  60             nWinStyle       ( 0 ),
  61             eObjKind        ( OBJ_NONE ),
  62             nPolyEdit       ( 0 ),
  63             bEditMode       ( false ),
  64             bSdrMode        ( false ),
  65             bAnim           ( false ),
  66             mpAccContext    ( NULL ),
  67             pModel          ( NULL ),
  68             pView           ( NULL )
  69 {
  70     pUserCall = new GraphCtrlUserCall( *this );
  71     aUpdateIdle.SetPriority( SchedulerPriority::LOWEST );
  72     aUpdateIdle.SetIdleHdl( LINK( this, GraphCtrl, UpdateHdl ) );
  73     aUpdateIdle.Start();
  74     EnableRTL( false );
  75 }
  76
  77 VCL_BUILDER_DECL_FACTORY(GraphCtrl)
  78 {
  79     WinBits nWinStyle = 0;
  80     OString sBorder = VclBuilder::extractCustomProperty(rMap);
  81     if (!sBorder.isEmpty())
  82         nWinStyle |= WB_BORDER;
  83     rRet = VclPtr<GraphCtrl>::Create(pParent, nWinStyle);
  84 }
  85
  86 GraphCtrl::~GraphCtrl()
  87 {
  88     disposeOnce();
  89 }
  90
  91 void GraphCtrl::dispose()
  92 {
  93     if( mpAccContext )
  94     {
  95         mpAccContext->disposing();
  96         mpAccContext->release();
  97     }
  98     delete pView;
  99     delete pModel;
 100     delete pUserCall;
 101     Control::dispose();
 102 }
 103
 104 void GraphCtrl::SetWinStyle( WinBits nWinBits )
 105 {
 106     nWinStyle = nWinBits;
 107     bAnim = ( nWinStyle & WB_ANIMATION ) == WB_ANIMATION;
 108     bSdrMode = ( nWinStyle & WB_SDRMODE ) == WB_SDRMODE;
 109
 110     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 111     SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
 112     SetMapMode( aMap100 );
 113
 114     delete pView;
 115     pView = NULL;
 116
 117     delete pModel;
 118     pModel = NULL;
 119
 120     if ( bSdrMode )
 121         InitSdrModel();
 122 }
 123
 124 void GraphCtrl::InitSdrModel()
 125 {
 126     SolarMutexGuard aGuard;
 127
 128     SdrPage* pPage;
 129
 130     // destroy old junk
 131     delete pView;
 132     delete pModel;
 133
 134     // Creating a Model
 135     pModel = new SdrModel;
 136     pModel->GetItemPool().FreezeIdRanges();
 137     pModel->SetScaleUnit( aMap100.GetMapUnit() );
 138     pModel->SetScaleFraction( Fraction( 1, 1 ) );
 139     pModel->SetDefaultFontHeight( 500 );
 140
 141     pPage = new SdrPage( *pModel );
 142
 143     pPage->SetSize( aGraphSize );
 144     pPage->SetBorder( 0, 0, 0, 0 );
 145     pModel->InsertPage( pPage );
 146     pModel->SetChanged( false );
 147
 148     // Creating a View
 149     pView = new GraphCtrlView( pModel, this );
 150     pView->SetWorkArea( Rectangle( Point(), aGraphSize ) );
 151     pView->EnableExtendedMouseEventDispatcher( true );
 152     pView->ShowSdrPage(pView->GetModel()->GetPage(0));
 153     pView->SetFrameDragSingles( true );
 154     pView->SetMarkedPointsSmooth( SDRPATHSMOOTH_SYMMETRIC );
 155     pView->SetEditMode( true );
 156
 157     // #i72889# set neeeded flags
 158     pView->SetPagePaintingAllowed(false);
 159     pView->SetBufferedOutputAllowed(true);
 160     pView->SetBufferedOverlayAllowed(true);
 161
 162     // Tell the accessibility object about the changes.
 163     if (mpAccContext != NULL)
 164         mpAccContext->setModelAndView (pModel, pView);
 165 }
 166
 167 void GraphCtrl::SetGraphic( const Graphic& rGraphic, bool bNewModel )
 168 {
 169     // If possible we dither bitmaps for the display
 170     if ( !bAnim && ( rGraphic.GetType() == GRAPHIC_BITMAP )  )
 171     {
 172         if ( rGraphic.IsTransparent() )
 173         {
 174             Bitmap  aBmp( rGraphic.GetBitmap() );
 175
 176             DitherBitmap( aBmp );
 177             aGraphic = Graphic( BitmapEx( aBmp, rGraphic.GetBitmapEx().GetMask() ) );
 178         }
 179         else
 180         {
 181             Bitmap aBmp( rGraphic.GetBitmap() );
 182             DitherBitmap( aBmp );
 183             aGraphic = aBmp;
 184         }
 185     }
 186     else
 187         aGraphic = rGraphic;
 188
 189     if ( aGraphic.GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
 190         aGraphSize = Application::GetDefaultDevice()->PixelToLogic( aGraphic.GetPrefSize(), aMap100 );
 191     else
 192         aGraphSize = OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 );
 193
 194     if ( bSdrMode && bNewModel )
 195         InitSdrModel();
 196
 197     if ( aGraphSizeLink.IsSet() )
 198         aGraphSizeLink.Call( this );
 199
 200     Resize();
 201     Invalidate();
 202 }
 203
 204 void GraphCtrl::Resize()
 205 {
 206     Control::Resize();
 207
 208     if ( aGraphSize.Width() && aGraphSize.Height() )
 209     {
 210         MapMode         aDisplayMap( aMap100 );
 211         Point           aNewPos;
 212         Size            aNewSize;
 213         const Size      aWinSize = PixelToLogic( GetOutputSizePixel(), aDisplayMap );
 214         const long      nWidth = aWinSize.Width();
 215         const long      nHeight = aWinSize.Height();
 216         double          fGrfWH = (double) aGraphSize.Width() / aGraphSize.Height();
 217         double          fWinWH = (double) nWidth / nHeight;
 218
 219         // Adapt Bitmap to Thumb size
 220         if ( fGrfWH < fWinWH)
 221         {
 222             aNewSize.Width() = (long) ( (double) nHeight * fGrfWH );
 223             aNewSize.Height()= nHeight;
 224         }
 225         else
 226         {
 227             aNewSize.Width() = nWidth;
 228             aNewSize.Height()= (long) ( (double) nWidth / fGrfWH );
 229         }
 230
 231         aNewPos.X() = ( nWidth - aNewSize.Width() )  >> 1;
 232         aNewPos.Y() = ( nHeight - aNewSize.Height() ) >> 1;
 233
 234         // Implementing MapMode for Engine
 235         aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) );
 236         aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) );
 237
 238         aDisplayMap.SetOrigin( LogicToLogic( aNewPos, aMap100, aDisplayMap ) );
 239         SetMapMode( aDisplayMap );
 240     }
 241
 242     Invalidate();
 243 }
 244
 245 void GraphCtrl::Paint( vcl::RenderContext& rRenderContext, const Rectangle& rRect)
 246 {
 247     // #i72889# used splitted repaint to be able to paint an own background
 248     // even to the buffered view
 249     const bool bGraphicValid(GRAPHIC_NONE != aGraphic.GetType());
 250
 251     if (bSdrMode)
 252     {
 253         SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(&rRenderContext);
 254
 255         if (bGraphicValid)
 256         {
 257             vcl::RenderContext& rTarget = pPaintWindow->GetTargetOutputDevice();
 258
 259             rTarget.SetBackground(GetBackground());
 260             rTarget.Erase();
 261
 262             aGraphic.Draw(&rTarget, Point(), aGraphSize);
 263         }
 264
 265         const vcl::Region aRepaintRegion(rRect);
 266         pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion);
 267         pView->EndCompleteRedraw(*pPaintWindow, true);
 268     }
 269     else
 270     {
 271         // #i73381# in non-SdrMode, paint to local directly
 272         if(bGraphicValid)
 273         {
 274             aGraphic.Draw(&rRenderContext, Point(), aGraphSize);
 275         }
 276     }
 277 }
 278
 279 void GraphCtrl::SdrObjChanged( const SdrObject&  )
 280 {
 281 }
 282
 283 void GraphCtrl::SdrObjCreated( const SdrObject& )
 284 {
 285 }
 286
 287 void GraphCtrl::MarkListHasChanged()
 288 {
 289     if ( aMarkObjLink.IsSet() )
 290         aMarkObjLink.Call( this );
 291 }
 292
 293 void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 294 {
 295     vcl::KeyCode aCode( rKEvt.GetKeyCode() );
 296     bool    bProc = false;
 297
 298     Dialog* pDialog = GetParentDialog();
 299
 300     switch ( aCode.GetCode() )
 301     {
 302         case KEY_DELETE:
 303         case KEY_BACKSPACE:
 304         {
 305             if ( bSdrMode )
 306             {
 307                 pView->DeleteMarked();
 308                 bProc = true;
 309                 if (!pView->AreObjectsMarked() && pDialog)
 310                     pDialog->GrabFocusToFirstControl();
 311             }
 312         }
 313         break;
 314
 315         case KEY_ESCAPE:
 316         {
 317             if ( bSdrMode )
 318             {
 319                 bool bGrabFocusToFirstControl = true;
 320                 if ( pView->IsAction() )
 321                 {
 322                     pView->BrkAction();
 323                     bGrabFocusToFirstControl = false;
 324                 }
 325                 else if ( pView->AreObjectsMarked() )
 326                 {
 327                     const SdrHdlList& rHdlList = pView->GetHdlList();
 328                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 329
 330                     if(pHdl)
 331                     {
 332                         ((SdrHdlList&)rHdlList).ResetFocusHdl();
 333                         bGrabFocusToFirstControl = false;
 334                     }
 335                 }
 336                 if (bGrabFocusToFirstControl && pDialog)
 337                     pDialog->GrabFocusToFirstControl();
 338                 bProc = true;
 339             }
 340         }
 341         break;
 342
 343         case KEY_F11:
 344         case KEY_TAB:
 345         {
 346             if( bSdrMode )
 347             {
 348                 if( !aCode.IsMod1() && !aCode.IsMod2() )
 349                 {
 350                     bool bForward = !aCode.IsShift();
 351                     // select next object
 352                     if ( ! pView->MarkNextObj( bForward ))
 353                     {
 354                         // At first or last object.  Cycle to the other end
 355                         // of the list.
 356                         pView->UnmarkAllObj();
 357                         pView->MarkNextObj (bForward);
 358                     }
 359                     bProc = true;
 360                 }
 361                 else if(aCode.IsMod1())
 362                 {
 363                     // select next handle
 364                     const SdrHdlList& rHdlList = pView->GetHdlList();
 365                     bool bForward(!aCode.IsShift());
 366
 367                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
 368
 369                     bProc = true;
 370                 }
 371             }
 372         }
 373         break;
 374
 375         case KEY_END:
 376         {
 377
 378             if ( aCode.IsMod1() )
 379             {
 380                 // mark last object
 381                 pView->UnmarkAllObj();
 382                 pView->MarkNextObj(false);
 383
 384                 bProc = true;
 385             }
 386         }
 387         break;
 388
 389         case KEY_HOME:
 390         {
 391             if ( aCode.IsMod1() )
 392             {
 393                 pView->UnmarkAllObj();
 394                 pView->MarkNextObj(true);
 395
 396                 bProc = true;
 397             }
 398         }
 399         break;
 400
 401         case KEY_UP:
 402         case KEY_DOWN:
 403         case KEY_LEFT:
 404         case KEY_RIGHT:
 405         {
 406             long nX = 0;
 407             long nY = 0;
 408
 409             if (aCode.GetCode() == KEY_UP)
 410             {
 411                 // Scroll up
 412                 nX = 0;
 413                 nY =-1;
 414             }
 415             else if (aCode.GetCode() == KEY_DOWN)
 416             {
 417                 // Scroll down
 418                 nX = 0;
 419                 nY = 1;
 420             }
 421             else if (aCode.GetCode() == KEY_LEFT)
 422             {
 423                 // Scroll left
 424                 nX =-1;
 425                 nY = 0;
 426             }
 427             else if (aCode.GetCode() == KEY_RIGHT)
 428             {
 429                 // Scroll right
 430                 nX = 1;
 431                 nY = 0;
 432             }
 433
 434             if (pView->AreObjectsMarked() && !aCode.IsMod1() )
 435             {
 436                 if(aCode.IsMod2())
 437                 {
 438                     // move in 1 pixel distance
 439                     Size aLogicSizeOnePixel = PixelToLogic(Size(1,1));
 440                     nX *= aLogicSizeOnePixel.Width();
 441                     nY *= aLogicSizeOnePixel.Height();
 442                 }
 443                 else
 444                 {
 445                     // old, fixed move distance
 446                     nX *= 100;
 447                     nY *= 100;
 448                 }
 449
 450                 // II
 451                 const SdrHdlList& rHdlList = pView->GetHdlList();
 452                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 453
 454                 if(0L == pHdl)
 455                 {
 456                     // restrict movement to WorkArea
 457                     const Rectangle& rWorkArea = pView->GetWorkArea();
 458
 459                     if(!rWorkArea.IsEmpty())
 460                     {
 461                         Rectangle aMarkRect(pView->GetMarkedObjRect());
 462                         aMarkRect.Move(nX, nY);
 463
 464                         if(!aMarkRect.IsInside(rWorkArea))
 465                         {
 466                             if(aMarkRect.Left() < rWorkArea.Left())
 467                             {
 468                                 nX += rWorkArea.Left() - aMarkRect.Left();
 469                             }
 470
 471                             if(aMarkRect.Right() > rWorkArea.Right())
 472                             {
 473                                 nX -= aMarkRect.Right() - rWorkArea.Right();
 474                             }
 475
 476                             if(aMarkRect.Top() < rWorkArea.Top())
 477                             {
 478                                 nY += rWorkArea.Top() - aMarkRect.Top();
 479                             }
 480
 481                             if(aMarkRect.Bottom() > rWorkArea.Bottom())
 482                             {
 483                                 nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 484                             }
 485                         }
 486                     }
 487
 488                     // no handle selected
 489                     if(0 != nX || 0 != nY)
 490                     {
 491                         pView->MoveAllMarked(Size(nX, nY));
 492                     }
 493                 }
 494                 else
 495                 {
 496                     // move handle with index nHandleIndex
 497                     if(pHdl && (nX || nY))
 498                     {
 499                         // now move the Handle (nX, nY)
 500                         Point aStartPoint(pHdl->GetPos());
 501                         Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 502                         const SdrDragStat& rDragStat = pView->GetDragStat();
 503
 504                         // start dragging
 505                         pView->BegDragObj(aStartPoint, 0, pHdl, 0);
 506
 507                         if(pView->IsDragObj())
 508                         {
 509                             bool bWasNoSnap = rDragStat.IsNoSnap();
 510                             bool bWasSnapEnabled = pView->IsSnapEnabled();
 511
 512                             // switch snapping off
 513                             if(!bWasNoSnap)
 514                                 ((SdrDragStat&)rDragStat).SetNoSnap(true);
 515                             if(bWasSnapEnabled)
 516                                 pView->SetSnapEnabled(false);
 517
 518                             pView->MovAction(aEndPoint);
 519                             pView->EndDragObj();
 520
 521                             // restore snap
 522                             if(!bWasNoSnap)
 523                                 ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
 524                             if(bWasSnapEnabled)
 525                                 pView->SetSnapEnabled(bWasSnapEnabled);
 526                         }
 527                     }
 528                 }
 529
 530                 bProc = true;
 531             }
 532         }
 533         break;
 534
 535         case KEY_SPACE:
 536         {
 537             const SdrHdlList& rHdlList = pView->GetHdlList();
 538             SdrHdl* pHdl = rHdlList.GetFocusHdl();
 539
 540             if(pHdl)
 541             {
 542                 if(pHdl->GetKind() == HDL_POLY)
 543                 {
 544                     // rescue ID of point with focus
 545                     sal_uInt32 nPol(pHdl->GetPolyNum());
 546                     sal_uInt32 nPnt(pHdl->GetPointNum());
 547
 548                     if(pView->IsPointMarked(*pHdl))
 549                     {
 550                         if(rKEvt.GetKeyCode().IsShift())
 551                         {
 552                             pView->UnmarkPoint(*pHdl);
 553                         }
 554                     }
 555                     else
 556                     {
 557                         if(!rKEvt.GetKeyCode().IsShift())
 558                         {
 559                             pView->UnmarkAllPoints();
 560                         }
 561
 562                         pView->MarkPoint(*pHdl);
 563                     }
 564
 565                     if(0L == rHdlList.GetFocusHdl())
 566                     {
 567                         // restore point with focus
 568                         SdrHdl* pNewOne = 0L;
 569
 570                         for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
 571                         {
 572                             SdrHdl* pAct = rHdlList.GetHdl(a);
 573
 574                             if(pAct
 575                                 && pAct->GetKind() == HDL_POLY
 576                                 && pAct->GetPolyNum() == nPol
 577                                 && pAct->GetPointNum() == nPnt)
 578                             {
 579                                 pNewOne = pAct;
 580                             }
 581                         }
 582
 583                         if(pNewOne)
 584                         {
 585                             ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
 586                         }
 587                     }
 588
 589                     bProc = true;
 590                 }
 591             }
 592         }
 593         break;
 594
 595         default:
 596         break;
 597     }
 598
 599     if ( !bProc )
 600         Control::KeyInput( rKEvt );
 601     else
 602         ReleaseMouse();
 603 }
 604
 605 void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
 606 {
 607     if ( bSdrMode && ( rMEvt.GetClicks() < 2 ) )
 608     {
 609         const Point aLogPt( PixelToLogic( rMEvt.GetPosPixel() ) );
 610
 611         if ( !Rectangle( Point(), aGraphSize ).IsInside( aLogPt ) && !pView->IsEditMode() )
 612             Control::MouseButtonDown( rMEvt );
 613         else
 614         {
 615             // Get Focus for key inputs
 616             GrabFocus();
 617
 618             if ( nPolyEdit )
 619             {
 620                 SdrViewEvent    aVEvt;
 621                 SdrHitKind      eHit = pView->PickAnything( rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt );
 622
 623                 if ( nPolyEdit == SID_BEZIER_INSERT && eHit == SDRHIT_MARKEDOBJECT )
 624                     pView->BegInsObjPoint( aLogPt, rMEvt.IsMod1());
 625                 else
 626                     pView->MouseButtonDown( rMEvt, this );
 627             }
 628             else
 629                 pView->MouseButtonDown( rMEvt, this );
 630         }
 631
 632         SdrObject* pCreateObj = pView->GetCreateObj();
 633
 634         // We want to realize the insert
 635         if ( pCreateObj && !pCreateObj->GetUserCall() )
 636             pCreateObj->SetUserCall( pUserCall );
 637
 638         SetPointer( pView->GetPreferredPointer( aLogPt, this ) );
 639     }
 640     else
 641         Control::MouseButtonDown( rMEvt );
 642 }
 643
 644 void GraphCtrl::MouseMove(const MouseEvent& rMEvt)
 645 {
 646     const Point aLogPos( PixelToLogic( rMEvt.GetPosPixel() ) );
 647
 648     if ( bSdrMode )
 649     {
 650         pView->MouseMove( rMEvt, this );
 651
 652         if( ( SID_BEZIER_INSERT == nPolyEdit ) &&
 653             !pView->PickHandle( aLogPos ) &&
 654             !pView->IsInsObjPoint() )
 655         {
 656             SetPointer( PointerStyle::Cross );
 657         }
 658         else
 659             SetPointer( pView->GetPreferredPointer( aLogPos, this ) );
 660     }
 661     else
 662         Control::MouseButtonUp( rMEvt );
 663
 664     if ( aMousePosLink.IsSet() )
 665     {
 666         if ( Rectangle( Point(), aGraphSize ).IsInside( aLogPos ) )
 667             aMousePos = aLogPos;
 668         else
 669             aMousePos = Point();
 670
 671         aMousePosLink.Call( this );
 672     }
 673 }
 674
 675 void GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
 676 {
 677     if ( bSdrMode )
 678     {
 679         if ( pView->IsInsObjPoint() )
 680             pView->EndInsObjPoint( SDRCREATE_FORCEEND );
 681         else
 682             pView->MouseButtonUp( rMEvt, this );
 683
 684         ReleaseMouse();
 685         SetPointer( pView->GetPreferredPointer( PixelToLogic( rMEvt.GetPosPixel() ), this ) );
 686     }
 687     else
 688         Control::MouseButtonUp( rMEvt );
 689 }
 690
 691 SdrObject* GraphCtrl::GetSelectedSdrObject() const
 692 {
 693     SdrObject* pSdrObj = NULL;
 694
 695     if ( bSdrMode )
 696     {
 697         const SdrMarkList&  rMarkList = pView->GetMarkedObjectList();
 698
 699         if ( rMarkList.GetMarkCount() == 1 )
 700             pSdrObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 701     }
 702
 703     return pSdrObj;
 704 }
 705
 706 void GraphCtrl::SetEditMode( const bool _bEditMode )
 707 {
 708     if ( bSdrMode )
 709     {
 710         bEditMode = _bEditMode;
 711         pView->SetEditMode( bEditMode );
 712         eObjKind = OBJ_NONE;
 713         pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) );
 714     }
 715     else
 716         bEditMode = false;
 717 }
 718
 719 void GraphCtrl::SetPolyEditMode( const sal_uInt16 _nPolyEdit )
 720 {
 721     if ( bSdrMode && ( _nPolyEdit != nPolyEdit ) )
 722     {
 723         nPolyEdit = _nPolyEdit;
 724         pView->SetFrameDragSingles( nPolyEdit == 0 );
 725     }
 726     else
 727         nPolyEdit = 0;
 728 }
 729
 730 void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
 731 {
 732     if ( bSdrMode )
 733     {
 734         bEditMode = false;
 735         pView->SetEditMode( bEditMode );
 736         eObjKind = _eObjKind;
 737         pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) );
 738     }
 739     else
 740         eObjKind = OBJ_NONE;
 741 }
 742
 743 IMPL_LINK_TYPED( GraphCtrl, UpdateHdl, Idle*, pTimer, void )
 744 {
 745     if ( aUpdateLink.IsSet() )
 746         aUpdateLink.Call( this );
 747
 748     pTimer->Start();
 749 }
 750
 751
 752 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > GraphCtrl::CreateAccessible()
 753 {
 754     if( mpAccContext == NULL )
 755     {
 756         vcl::Window* pParent = GetParent();
 757
 758         DBG_ASSERT( pParent, "-GraphCtrl::CreateAccessible(): No Parent!" );
 759
 760         if( pParent )
 761         {
 762             ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAccParent( pParent->GetAccessible() );
 763
 764             // Disable accessibility if no model/view data available
 765             if( pView &&
 766                 pModel &&
 767                 xAccParent.is() )
 768             {
 769                 mpAccContext = new SvxGraphCtrlAccessibleContext( xAccParent, *this );
 770                 mpAccContext->acquire();
 771             }
 772         }
 773     }
 774
 775     return mpAccContext;
 776 }
 777
 778 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */