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 <config_wasm_strip.h>
  21
  22 #include <svl/itempool.hxx>
  23 #include <vcl/settings.hxx>
  24 #include <vcl/ptrstyle.hxx>
  25 #include <vcl/svapp.hxx>
  26
  27 #include <svx/graphctl.hxx>
  28 #include <svx/sdr/overlay/overlaymanager.hxx>
  29 #include <GraphCtlAccessibleContext.hxx>
  30 #include <svx/svxids.hrc>
  31 #include <svx/svdpage.hxx>
  32 #include <svx/sdrpaintwindow.hxx>
  33
  34 void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const tools::Rectangle& /*rOldBoundRect*/ )
  35 {
  36     switch( eType )
  37     {
  38         case SdrUserCallType::MoveOnly:
  39         case SdrUserCallType::Resize:
  40             rWin.SdrObjChanged( rObj );
  41         break;
  42
  43         case SdrUserCallType::Inserted:
  44             rWin.SdrObjCreated( rObj );
  45         break;
  46
  47         default:
  48         break;
  49     }
  50     rWin.QueueIdleUpdate();
  51 }
  52
  53 GraphCtrl::GraphCtrl(weld::Dialog* pDialog)
  54     : aUpdateIdle("svx GraphCtrl Update")
  55     , aMap100(MapUnit::Map100thMM)
  56     , eObjKind(SdrObjKind::NONE)
  57     , nPolyEdit(0)
  58     , bEditMode(false)
  59     , mbSdrMode(false)
  60     , mbInIdleUpdate(false)
  61     , mpDialog(pDialog)
  62 {
  63     pUserCall.reset(new GraphCtrlUserCall( *this ));
  64     aUpdateIdle.SetPriority( TaskPriority::LOWEST );
  65     aUpdateIdle.SetInvokeHandler( LINK( this, GraphCtrl, UpdateHdl ) );
  66     aUpdateIdle.Start();
  67 }
  68
  69 void GraphCtrl::SetDrawingArea(weld::DrawingArea* pDrawingArea)
  70 {
  71     weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
  72     EnableRTL(false);
  73 }
  74
  75 GraphCtrl::~GraphCtrl()
  76 {
  77     aUpdateIdle.Stop();
  78
  79 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
  80     if( mpAccContext.is() )
  81     {
  82         mpAccContext->disposing();
  83         mpAccContext.clear();
  84     }
  85 #endif
  86
  87     pView.reset();
  88     pModel.reset();
  89     pUserCall.reset();
  90 }
  91
  92 void GraphCtrl::SetSdrMode(bool bSdrMode)
  93 {
  94     mbSdrMode = bSdrMode;
  95
  96     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  97     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
  98     rDevice.SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
  99     xVD->SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
 100     rDevice.SetMapMode( aMap100 );
 101     xVD->SetMapMode( aMap100 );
 102
 103     pView.reset();
 104     pModel.reset();
 105
 106     if ( mbSdrMode )
 107         InitSdrModel();
 108
 109     QueueIdleUpdate();
 110 }
 111
 112 void GraphCtrl::InitSdrModel()
 113 {
 114     SolarMutexGuard aGuard;
 115
 116     rtl::Reference<SdrPage> pPage;
 117
 118     // destroy old junk
 119     pView.reset();
 120     pModel.reset();
 121
 122     // Creating a Model
 123     pModel.reset(new SdrModel(nullptr, nullptr, true));
 124     pModel->SetScaleUnit(aMap100.GetMapUnit());
 125     pModel->SetDefaultFontHeight( 500 );
 126
 127     pPage = new SdrPage( *pModel );
 128
 129     pPage->SetSize( aGraphSize );
 130     pPage->SetBorder( 0, 0, 0, 0 );
 131     pModel->InsertPage( pPage.get() );
 132     pModel->SetChanged( false );
 133
 134     // Creating a View
 135     pView.reset(new GraphCtrlView(*pModel, this));
 136     pView->SetWorkArea( tools::Rectangle( Point(), aGraphSize ) );
 137     pView->EnableExtendedMouseEventDispatcher( true );
 138     pView->ShowSdrPage(pView->GetModel().GetPage(0));
 139     pView->SetFrameDragSingles();
 140     pView->SetMarkedPointsSmooth( SdrPathSmoothKind::Symmetric );
 141     pView->SetEditMode();
 142
 143     // #i72889# set needed flags
 144     pView->SetPageDecorationAllowed(false);
 145     pView->SetMasterPageVisualizationAllowed(false);
 146     pView->SetBufferedOutputAllowed(true);
 147     pView->SetBufferedOverlayAllowed(true);
 148
 149 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 150     // Tell the accessibility object about the changes.
 151     if (mpAccContext.is())
 152         mpAccContext->setModelAndView (pModel.get(), pView.get());
 153 #endif
 154 }
 155
 156 void GraphCtrl::SetGraphic( const Graphic& rGraphic, bool bNewModel )
 157 {
 158     aGraphic = rGraphic;
 159     xVD->SetOutputSizePixel(Size(0, 0)); //force redraw
 160
 161     if ( aGraphic.GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel )
 162         aGraphSize = Application::GetDefaultDevice()->PixelToLogic( aGraphic.GetPrefSize(), aMap100 );
 163     else
 164         aGraphSize = OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 );
 165
 166     if ( mbSdrMode && bNewModel )
 167         InitSdrModel();
 168
 169     aGraphSizeLink.Call( this );
 170
 171     Resize();
 172
 173     Invalidate();
 174     QueueIdleUpdate();
 175 }
 176
 177 void GraphCtrl::GraphicToVD()
 178 {
 179     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 180     xVD->SetOutputSizePixel(GetOutputSizePixel());
 181     xVD->SetBackground(rDevice.GetBackground());
 182     xVD->Erase();
 183     const bool bGraphicValid(GraphicType::NONE != aGraphic.GetType());
 184     if (bGraphicValid)
 185         aGraphic.Draw(*xVD, Point(), aGraphSize);
 186 }
 187
 188 void GraphCtrl::Resize()
 189 {
 190     weld::CustomWidgetController::Resize();
 191
 192     if (aGraphSize.Width() && aGraphSize.Height())
 193     {
 194         MapMode         aDisplayMap( aMap100 );
 195         Point           aNewPos;
 196         Size            aNewSize;
 197         OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 198         const Size      aWinSize = rDevice.PixelToLogic( GetOutputSizePixel(), aDisplayMap );
 199         const tools::Long      nWidth = aWinSize.Width();
 200         const tools::Long      nHeight = aWinSize.Height();
 201         double          fGrfWH = static_cast<double>(aGraphSize.Width()) / aGraphSize.Height();
 202         double          fWinWH = static_cast<double>(nWidth) / nHeight;
 203
 204         // Adapt Bitmap to Thumb size
 205         if ( fGrfWH < fWinWH)
 206         {
 207             aNewSize.setWidth( static_cast<tools::Long>( static_cast<double>(nHeight) * fGrfWH ) );
 208             aNewSize.setHeight( nHeight );
 209         }
 210         else
 211         {
 212             aNewSize.setWidth( nWidth );
 213             aNewSize.setHeight( static_cast<tools::Long>( static_cast<double>(nWidth) / fGrfWH ) );
 214         }
 215
 216         aNewPos.setX( ( nWidth - aNewSize.Width() )  >> 1 );
 217         aNewPos.setY( ( nHeight - aNewSize.Height() ) >> 1 );
 218
 219         // Implementing MapMode for Engine
 220         aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) );
 221         aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) );
 222
 223         aDisplayMap.SetOrigin( OutputDevice::LogicToLogic( aNewPos, aMap100, aDisplayMap ) );
 224         rDevice.SetMapMode( aDisplayMap );
 225         xVD->SetMapMode( aDisplayMap );
 226     }
 227
 228     Invalidate();
 229 }
 230
 231 void GraphCtrl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
 232 {
 233     // #i72889# used split repaint to be able to paint an own background
 234     // even to the buffered view
 235     const bool bGraphicValid(GraphicType::NONE != aGraphic.GetType());
 236
 237     if (GetOutputSizePixel() != xVD->GetOutputSizePixel())
 238         GraphicToVD();
 239
 240     if (mbSdrMode)
 241     {
 242         SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(&rRenderContext);
 243         pPaintWindow->SetOutputToWindow(true);
 244
 245         if (bGraphicValid)
 246         {
 247             vcl::RenderContext& rTarget = pPaintWindow->GetTargetOutputDevice();
 248
 249             OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 250             rTarget.SetBackground(rDevice.GetBackground());
 251             rTarget.Erase();
 252
 253             rTarget.DrawOutDev(Point(), xVD->GetOutputSize(), Point(), xVD->GetOutputSize(), *xVD);
 254         }
 255
 256         const vcl::Region aRepaintRegion(rRect);
 257         pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion);
 258         pView->EndCompleteRedraw(*pPaintWindow, true);
 259     }
 260     else
 261     {
 262         // #i73381# in non-SdrMode, paint to local directly
 263         rRenderContext.DrawOutDev(rRect.TopLeft(), rRect.GetSize(),
 264                                   rRect.TopLeft(), rRect.GetSize(),
 265                                   *xVD);
 266     }
 267 }
 268
 269 void GraphCtrl::SdrObjChanged( const SdrObject&  )
 270 {
 271     QueueIdleUpdate();
 272 }
 273
 274 void GraphCtrl::SdrObjCreated( const SdrObject& )
 275 {
 276     QueueIdleUpdate();
 277 }
 278
 279 void GraphCtrl::MarkListHasChanged()
 280 {
 281     QueueIdleUpdate();
 282 }
 283
 284 bool GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 285 {
 286     vcl::KeyCode aCode( rKEvt.GetKeyCode() );
 287     bool    bProc = false;
 288
 289     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 290
 291     switch ( aCode.GetCode() )
 292     {
 293         case KEY_DELETE:
 294         case KEY_BACKSPACE:
 295         {
 296             if ( mbSdrMode )
 297             {
 298                 pView->DeleteMarked();
 299                 bProc = true;
 300             }
 301         }
 302         break;
 303
 304         case KEY_ESCAPE:
 305         {
 306             if ( mbSdrMode )
 307             {
 308                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 309                 if ( pView->IsAction() )
 310                 {
 311                     pView->BrkAction();
 312                     bProc = true;
 313                 }
 314                 else if ( rMarkList.GetMarkCount() != 0 )
 315                 {
 316                     pView->UnmarkAllObj();
 317                     bProc = true;
 318                 }
 319             }
 320         }
 321         break;
 322
 323         case KEY_F11:
 324         case KEY_TAB:
 325         {
 326             if( mbSdrMode )
 327             {
 328                 if( !aCode.IsMod1() && !aCode.IsMod2() )
 329                 {
 330                     bool bForward = !aCode.IsShift();
 331                     // select next object
 332                     if ( ! pView->MarkNextObj( bForward ))
 333                     {
 334                         // At first or last object.  Cycle to the other end
 335                         // of the list.
 336                         pView->UnmarkAllObj();
 337                         pView->MarkNextObj (bForward);
 338                     }
 339                     bProc = true;
 340                 }
 341                 else if(aCode.IsMod1())
 342                 {
 343                     // select next handle
 344                     const SdrHdlList& rHdlList = pView->GetHdlList();
 345                     bool bForward(!aCode.IsShift());
 346
 347                     const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl(bForward);
 348
 349                     bProc = true;
 350                 }
 351             }
 352         }
 353         break;
 354
 355         case KEY_END:
 356         {
 357
 358             if ( aCode.IsMod1() )
 359             {
 360                 // mark last object
 361                 pView->UnmarkAllObj();
 362                 pView->MarkNextObj();
 363
 364                 bProc = true;
 365             }
 366         }
 367         break;
 368
 369         case KEY_HOME:
 370         {
 371             if ( aCode.IsMod1() )
 372             {
 373                 pView->UnmarkAllObj();
 374                 pView->MarkNextObj(true);
 375
 376                 bProc = true;
 377             }
 378         }
 379         break;
 380
 381         case KEY_UP:
 382         case KEY_DOWN:
 383         case KEY_LEFT:
 384         case KEY_RIGHT:
 385         {
 386             tools::Long nX = 0;
 387             tools::Long nY = 0;
 388
 389             if (aCode.GetCode() == KEY_UP)
 390             {
 391                 // Scroll up
 392                 nX = 0;
 393                 nY =-1;
 394             }
 395             else if (aCode.GetCode() == KEY_DOWN)
 396             {
 397                 // Scroll down
 398                 nX = 0;
 399                 nY = 1;
 400             }
 401             else if (aCode.GetCode() == KEY_LEFT)
 402             {
 403                 // Scroll left
 404                 nX =-1;
 405                 nY = 0;
 406             }
 407             else if (aCode.GetCode() == KEY_RIGHT)
 408             {
 409                 // Scroll right
 410                 nX = 1;
 411                 nY = 0;
 412             }
 413
 414             const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 415             if (rMarkList.GetMarkCount() != 0 && !aCode.IsMod1() )
 416             {
 417                 if(aCode.IsMod2())
 418                 {
 419                     // move in 1 pixel distance
 420                     Size aLogicSizeOnePixel = rDevice.PixelToLogic(Size(1,1));
 421                     nX *= aLogicSizeOnePixel.Width();
 422                     nY *= aLogicSizeOnePixel.Height();
 423                 }
 424                 else
 425                 {
 426                     // old, fixed move distance
 427                     nX *= 100;
 428                     nY *= 100;
 429                 }
 430
 431                 // II
 432                 const SdrHdlList& rHdlList = pView->GetHdlList();
 433                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 434
 435                 if(nullptr == pHdl)
 436                 {
 437                     // restrict movement to WorkArea
 438                     const tools::Rectangle& rWorkArea = pView->GetWorkArea();
 439
 440                     if(!rWorkArea.IsEmpty())
 441                     {
 442                         tools::Rectangle aMarkRect(pView->GetMarkedObjRect());
 443                         aMarkRect.Move(nX, nY);
 444
 445                         if(!aMarkRect.Contains(rWorkArea))
 446                         {
 447                             if(aMarkRect.Left() < rWorkArea.Left())
 448                             {
 449                                 nX += rWorkArea.Left() - aMarkRect.Left();
 450                             }
 451
 452                             if(aMarkRect.Right() > rWorkArea.Right())
 453                             {
 454                                 nX -= aMarkRect.Right() - rWorkArea.Right();
 455                             }
 456
 457                             if(aMarkRect.Top() < rWorkArea.Top())
 458                             {
 459                                 nY += rWorkArea.Top() - aMarkRect.Top();
 460                             }
 461
 462                             if(aMarkRect.Bottom() > rWorkArea.Bottom())
 463                             {
 464                                 nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 465                             }
 466                         }
 467                     }
 468
 469                     // no handle selected
 470                     if(0 != nX || 0 != nY)
 471                     {
 472                         pView->MoveAllMarked(Size(nX, nY));
 473                     }
 474                 }
 475                 else
 476                 {
 477                     // move handle with index nHandleIndex
 478                     if (nX || nY)
 479                     {
 480                         // now move the Handle (nX, nY)
 481                         Point aStartPoint(pHdl->GetPos());
 482                         Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 483                         const SdrDragStat& rDragStat = pView->GetDragStat();
 484
 485                         // start dragging
 486                         pView->BegDragObj(aStartPoint, nullptr, pHdl, 0);
 487
 488                         if(pView->IsDragObj())
 489                         {
 490                             bool bWasNoSnap = rDragStat.IsNoSnap();
 491                             bool bWasSnapEnabled = pView->IsSnapEnabled();
 492
 493                             // switch snapping off
 494                             if(!bWasNoSnap)
 495                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap();
 496                             if(bWasSnapEnabled)
 497                                 pView->SetSnapEnabled(false);
 498
 499                             pView->MovAction(aEndPoint);
 500                             pView->EndDragObj();
 501
 502                             // restore snap
 503                             if(!bWasNoSnap)
 504                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap(bWasNoSnap);
 505                             if(bWasSnapEnabled)
 506                                 pView->SetSnapEnabled(bWasSnapEnabled);
 507                         }
 508                     }
 509                 }
 510
 511                 bProc = true;
 512             }
 513         }
 514         break;
 515
 516         case KEY_SPACE:
 517         {
 518             const SdrHdlList& rHdlList = pView->GetHdlList();
 519             SdrHdl* pHdl = rHdlList.GetFocusHdl();
 520
 521             if(pHdl)
 522             {
 523                 if(pHdl->GetKind() == SdrHdlKind::Poly)
 524                 {
 525                     // rescue ID of point with focus
 526                     sal_uInt32 nPol(pHdl->GetPolyNum());
 527                     sal_uInt32 nPnt(pHdl->GetPointNum());
 528
 529                     if(pView->IsPointMarked(*pHdl))
 530                     {
 531                         if(rKEvt.GetKeyCode().IsShift())
 532                         {
 533                             pView->UnmarkPoint(*pHdl);
 534                         }
 535                     }
 536                     else
 537                     {
 538                         if(!rKEvt.GetKeyCode().IsShift())
 539                         {
 540                             pView->UnmarkAllPoints();
 541                         }
 542
 543                         pView->MarkPoint(*pHdl);
 544                     }
 545
 546                     if(nullptr == rHdlList.GetFocusHdl())
 547                     {
 548                         // restore point with focus
 549                         SdrHdl* pNewOne = nullptr;
 550
 551                         for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
 552                         {
 553                             SdrHdl* pAct = rHdlList.GetHdl(a);
 554
 555                             if(pAct
 556                                 && pAct->GetKind() == SdrHdlKind::Poly
 557                                 && pAct->GetPolyNum() == nPol
 558                                 && pAct->GetPointNum() == nPnt)
 559                             {
 560                                 pNewOne = pAct;
 561                             }
 562                         }
 563
 564                         if(pNewOne)
 565                         {
 566                             const_cast<SdrHdlList&>(rHdlList).SetFocusHdl(pNewOne);
 567                         }
 568                     }
 569
 570                     bProc = true;
 571                 }
 572             }
 573         }
 574         break;
 575
 576         default:
 577         break;
 578     }
 579
 580     if (bProc)
 581         ReleaseMouse();
 582
 583     QueueIdleUpdate();
 584
 585     return bProc;
 586 }
 587
 588 bool GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
 589 {
 590     if ( mbSdrMode && ( rMEvt.GetClicks() < 2 ) )
 591     {
 592         OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 593
 594         const Point aLogPt( rDevice.PixelToLogic( rMEvt.GetPosPixel() ) );
 595
 596         if ( !tools::Rectangle( Point(), aGraphSize ).Contains( aLogPt ) && !pView->IsEditMode() )
 597             weld::CustomWidgetController::MouseButtonDown( rMEvt );
 598         else
 599         {
 600             // Get Focus for key inputs
 601             GrabFocus();
 602
 603             if ( nPolyEdit )
 604             {
 605                 SdrViewEvent    aVEvt;
 606                 SdrHitKind      eHit = pView->PickAnything( rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt );
 607
 608                 if ( nPolyEdit == SID_BEZIER_INSERT && eHit == SdrHitKind::MarkedObject )
 609                     pView->BegInsObjPoint( aLogPt, rMEvt.IsMod1());
 610                 else
 611                     pView->MouseButtonDown( rMEvt, &rDevice );
 612             }
 613             else
 614                 pView->MouseButtonDown( rMEvt, &rDevice );
 615         }
 616
 617         SdrObject* pCreateObj = pView->GetCreateObj();
 618
 619         // We want to realize the insert
 620         if ( pCreateObj && !pCreateObj->GetUserCall() )
 621             pCreateObj->SetUserCall( pUserCall.get() );
 622
 623         SetPointer( pView->GetPreferredPointer( aLogPt, &rDevice ) );
 624     }
 625     else
 626         weld::CustomWidgetController::MouseButtonDown( rMEvt );
 627
 628     QueueIdleUpdate();
 629
 630     return false;
 631 }
 632
 633 bool GraphCtrl::MouseMove(const MouseEvent& rMEvt)
 634 {
 635     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 636     const Point aLogPos( rDevice.PixelToLogic( rMEvt.GetPosPixel() ) );
 637
 638     if ( mbSdrMode )
 639     {
 640         pView->MouseMove( rMEvt, &rDevice );
 641
 642         if( ( SID_BEZIER_INSERT == nPolyEdit ) &&
 643             !pView->PickHandle( aLogPos ) &&
 644             !pView->IsInsObjPoint() )
 645         {
 646             SetPointer( PointerStyle::Cross );
 647         }
 648         else
 649             SetPointer( pView->GetPreferredPointer( aLogPos, &rDevice ) );
 650     }
 651     else
 652         weld::CustomWidgetController::MouseButtonUp( rMEvt );
 653
 654     if ( aMousePosLink.IsSet() )
 655     {
 656         if ( tools::Rectangle( Point(), aGraphSize ).Contains( aLogPos ) )
 657             aMousePos = aLogPos;
 658         else
 659             aMousePos = Point();
 660
 661         aMousePosLink.Call( this );
 662     }
 663
 664     QueueIdleUpdate();
 665
 666     return false;
 667 }
 668
 669 bool GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
 670 {
 671     if ( mbSdrMode )
 672     {
 673         OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 674
 675         if ( pView->IsInsObjPoint() )
 676             pView->EndInsObjPoint( SdrCreateCmd::ForceEnd );
 677         else
 678             pView->MouseButtonUp( rMEvt, &rDevice );
 679
 680         ReleaseMouse();
 681         SetPointer( pView->GetPreferredPointer( rDevice.PixelToLogic( rMEvt.GetPosPixel() ), &rDevice ) );
 682     }
 683     else
 684         weld::CustomWidgetController::MouseButtonUp( rMEvt );
 685
 686     QueueIdleUpdate();
 687
 688     return false;
 689 }
 690
 691 SdrObject* GraphCtrl::GetSelectedSdrObject() const
 692 {
 693     SdrObject* pSdrObj = nullptr;
 694
 695     if ( mbSdrMode )
 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 ( mbSdrMode )
 709     {
 710         bEditMode = _bEditMode;
 711         pView->SetEditMode( bEditMode );
 712         eObjKind = SdrObjKind::NONE;
 713         pView->SetCurrentObj(eObjKind);
 714     }
 715     else
 716         bEditMode = false;
 717
 718     QueueIdleUpdate();
 719 }
 720
 721 void GraphCtrl::SetPolyEditMode( const sal_uInt16 _nPolyEdit )
 722 {
 723     if ( mbSdrMode && ( _nPolyEdit != nPolyEdit ) )
 724     {
 725         nPolyEdit = _nPolyEdit;
 726         pView->SetFrameDragSingles( nPolyEdit == 0 );
 727     }
 728     else
 729         nPolyEdit = 0;
 730
 731     QueueIdleUpdate();
 732 }
 733
 734 void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
 735 {
 736     if ( mbSdrMode )
 737     {
 738         bEditMode = false;
 739         pView->SetEditMode( bEditMode );
 740         eObjKind = _eObjKind;
 741         pView->SetCurrentObj(eObjKind);
 742     }
 743     else
 744         eObjKind = SdrObjKind::NONE;
 745
 746     QueueIdleUpdate();
 747 }
 748
 749 IMPL_LINK_NOARG(GraphCtrl, UpdateHdl, Timer *, void)
 750 {
 751     mbInIdleUpdate = true;
 752     aUpdateLink.Call( this );
 753     mbInIdleUpdate = false;
 754 }
 755
 756 void GraphCtrl::QueueIdleUpdate()
 757 {
 758     if (!mbInIdleUpdate)
 759         aUpdateIdle.Start();
 760 }
 761
 762 namespace
 763 {
 764     class WeldOverlayManager final : public sdr::overlay::OverlayManager
 765     {
 766         weld::CustomWidgetController& m_rGraphCtrl;
 767
 768     public:
 769         WeldOverlayManager(weld::CustomWidgetController& rGraphCtrl, OutputDevice& rDevice)
 770             : OverlayManager(rDevice)
 771             , m_rGraphCtrl(rGraphCtrl)
 772         {
 773         }
 774
 775         // invalidate the given range at local OutputDevice
 776         virtual void invalidateRange(const basegfx::B2DRange& rRange) override
 777         {
 778             tools::Rectangle aInvalidateRectangle(RangeToInvalidateRectangle(rRange));
 779             m_rGraphCtrl.Invalidate(aInvalidateRectangle);
 780         }
 781     };
 782 }
 783
 784 rtl::Reference<sdr::overlay::OverlayManager> GraphCtrlView::CreateOverlayManager(OutputDevice& rDevice) const
 785 {
 786     assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device());
 787     if (rDevice.GetOutDevType() == OUTDEV_VIRDEV)
 788     {
 789         rtl::Reference<sdr::overlay::OverlayManager> xOverlayManager(new WeldOverlayManager(rGraphCtrl, rDevice));
 790         InitOverlayManager(xOverlayManager);
 791         return xOverlayManager;
 792     }
 793     return SdrView::CreateOverlayManager(rDevice);
 794 }
 795
 796 void GraphCtrlView::InvalidateOneWin(OutputDevice& rDevice)
 797 {
 798     assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device());
 799     if (rDevice.GetOutDevType() == OUTDEV_VIRDEV)
 800     {
 801         rGraphCtrl.Invalidate();
 802         return;
 803     }
 804     SdrView::InvalidateOneWin(rDevice);
 805 }
 806
 807 void GraphCtrlView::InvalidateOneWin(OutputDevice& rDevice, const tools::Rectangle& rArea)
 808 {
 809     assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device());
 810     if (rDevice.GetOutDevType() == OUTDEV_VIRDEV)
 811     {
 812         rGraphCtrl.Invalidate(rArea);
 813         return;
 814     }
 815     SdrView::InvalidateOneWin(rDevice, rArea);
 816 }
 817
 818 GraphCtrlView::~GraphCtrlView()
 819 {
 820     // turn SetOutputToWindow back off again before
 821     // turning back into our baseclass during dtoring
 822     const sal_uInt32 nWindowCount(PaintWindowCount());
 823     for (sal_uInt32 nWinNum(0); nWinNum < nWindowCount; nWinNum++)
 824     {
 825         SdrPaintWindow* pPaintWindow = GetPaintWindow(nWinNum);
 826         pPaintWindow->SetOutputToWindow(false);
 827     }
 828 }
 829
 830 Point GraphCtrl::GetPositionInDialog() const
 831 {
 832     int x, y, width, height;
 833     if (GetDrawingArea()->get_extents_relative_to(*mpDialog, x, y, width, height))
 834         return Point(x, y);
 835     return Point();
 836 }
 837
 838 css::uno::Reference< css::accessibility::XAccessible > GraphCtrl::CreateAccessible()
 839 {
 840 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 841     if(mpAccContext == nullptr )
 842     {
 843         // Disable accessibility if no model/view data available
 844         if (pView && pModel)
 845             mpAccContext = new SvxGraphCtrlAccessibleContext(*this);
 846     }
 847 #endif
 848     return mpAccContext;
 849 }
 850
 851 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */