794 lines
22 KiB
C++
794 lines
22 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <svl/itempool.hxx>
|
|
#include <vcl/dialog.hxx>
|
|
#include <vcl/wrkwin.hxx>
|
|
#include <vcl/settings.hxx>
|
|
#include <vcl/builderfactory.hxx>
|
|
#include <unotools/syslocale.hxx>
|
|
#include <rtl/math.hxx>
|
|
#include <unotools/localedatawrapper.hxx>
|
|
#include <comphelper/processfactory.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
|
|
#include <svx/graphctl.hxx>
|
|
#include <GraphCtlAccessibleContext.hxx>
|
|
#include <svx/xoutbmp.hxx>
|
|
#include <svx/svxids.hrc>
|
|
#include <svx/svdpage.hxx>
|
|
#include <svx/sdrpaintwindow.hxx>
|
|
|
|
void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const tools::Rectangle& /*rOldBoundRect*/ )
|
|
{
|
|
switch( eType )
|
|
{
|
|
case SdrUserCallType::MoveOnly:
|
|
case SdrUserCallType::Resize:
|
|
rWin.SdrObjChanged( rObj );
|
|
break;
|
|
|
|
case SdrUserCallType::Inserted:
|
|
rWin.SdrObjCreated( rObj );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
rWin.QueueIdleUpdate();
|
|
}
|
|
|
|
GraphCtrl::GraphCtrl( vcl::Window* pParent, WinBits nStyle ) :
|
|
Control ( pParent, nStyle ),
|
|
aUpdateIdle ( "svx GraphCtrl Update" ),
|
|
aMap100 ( MapUnit::Map100thMM ),
|
|
eObjKind ( OBJ_NONE ),
|
|
nPolyEdit ( 0 ),
|
|
bEditMode ( false ),
|
|
mbSdrMode ( false ),
|
|
mbInIdleUpdate ( false ),
|
|
pModel ( nullptr ),
|
|
pView ( nullptr )
|
|
{
|
|
pUserCall = new GraphCtrlUserCall( *this );
|
|
aUpdateIdle.SetPriority( TaskPriority::LOWEST );
|
|
aUpdateIdle.SetInvokeHandler( LINK( this, GraphCtrl, UpdateHdl ) );
|
|
aUpdateIdle.Start();
|
|
EnableRTL( false );
|
|
}
|
|
|
|
VCL_BUILDER_FACTORY_CONSTRUCTOR(GraphCtrl, 0)
|
|
|
|
GraphCtrl::~GraphCtrl()
|
|
{
|
|
disposeOnce();
|
|
}
|
|
|
|
void GraphCtrl::dispose()
|
|
{
|
|
aUpdateIdle.Stop();
|
|
|
|
if( mpAccContext.is() )
|
|
{
|
|
mpAccContext->disposing();
|
|
mpAccContext.clear();
|
|
}
|
|
delete pView;
|
|
pView = nullptr;
|
|
delete pModel;
|
|
pModel = nullptr;
|
|
delete pUserCall;
|
|
pUserCall = nullptr;
|
|
Control::dispose();
|
|
}
|
|
|
|
void GraphCtrl::SetSdrMode(bool bSdrMode)
|
|
{
|
|
mbSdrMode = bSdrMode;
|
|
|
|
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
|
|
SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
|
|
SetMapMode( aMap100 );
|
|
|
|
delete pView;
|
|
pView = nullptr;
|
|
|
|
delete pModel;
|
|
pModel = nullptr;
|
|
|
|
if ( mbSdrMode )
|
|
InitSdrModel();
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::InitSdrModel()
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
SdrPage* pPage;
|
|
|
|
// destroy old junk
|
|
delete pView;
|
|
delete pModel;
|
|
|
|
// Creating a Model
|
|
pModel = new SdrModel;
|
|
pModel->GetItemPool().FreezeIdRanges();
|
|
pModel->SetScaleUnit( aMap100.GetMapUnit() );
|
|
pModel->SetScaleFraction( Fraction( 1, 1 ) );
|
|
pModel->SetDefaultFontHeight( 500 );
|
|
|
|
pPage = new SdrPage( *pModel );
|
|
|
|
pPage->SetSize( aGraphSize );
|
|
pPage->SetBorder( 0, 0, 0, 0 );
|
|
pModel->InsertPage( pPage );
|
|
pModel->SetChanged( false );
|
|
|
|
// Creating a View
|
|
pView = new GraphCtrlView( pModel, this );
|
|
pView->SetWorkArea( tools::Rectangle( Point(), aGraphSize ) );
|
|
pView->EnableExtendedMouseEventDispatcher( true );
|
|
pView->ShowSdrPage(pView->GetModel()->GetPage(0));
|
|
pView->SetFrameDragSingles();
|
|
pView->SetMarkedPointsSmooth( SdrPathSmoothKind::Symmetric );
|
|
pView->SetEditMode();
|
|
|
|
// #i72889# set needed flags
|
|
pView->SetPagePaintingAllowed(false);
|
|
pView->SetBufferedOutputAllowed(true);
|
|
pView->SetBufferedOverlayAllowed(true);
|
|
|
|
// Tell the accessibility object about the changes.
|
|
if (mpAccContext.is())
|
|
mpAccContext->setModelAndView (pModel, pView);
|
|
}
|
|
|
|
void GraphCtrl::SetGraphic( const Graphic& rGraphic, bool bNewModel )
|
|
{
|
|
// If possible we dither bitmaps for the display
|
|
if ( rGraphic.GetType() == GraphicType::Bitmap )
|
|
{
|
|
if ( rGraphic.IsTransparent() )
|
|
{
|
|
Bitmap aBmp( rGraphic.GetBitmap() );
|
|
|
|
DitherBitmap( aBmp );
|
|
aGraphic = Graphic( BitmapEx( aBmp, rGraphic.GetBitmapEx().GetMask() ) );
|
|
}
|
|
else
|
|
{
|
|
Bitmap aBmp( rGraphic.GetBitmap() );
|
|
DitherBitmap( aBmp );
|
|
aGraphic = aBmp;
|
|
}
|
|
}
|
|
else
|
|
aGraphic = rGraphic;
|
|
|
|
if ( aGraphic.GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel )
|
|
aGraphSize = Application::GetDefaultDevice()->PixelToLogic( aGraphic.GetPrefSize(), aMap100 );
|
|
else
|
|
aGraphSize = OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 );
|
|
|
|
if ( mbSdrMode && bNewModel )
|
|
InitSdrModel();
|
|
|
|
aGraphSizeLink.Call( this );
|
|
|
|
Resize();
|
|
Invalidate();
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::Resize()
|
|
{
|
|
Control::Resize();
|
|
|
|
if ( aGraphSize.Width() && aGraphSize.Height() )
|
|
{
|
|
MapMode aDisplayMap( aMap100 );
|
|
Point aNewPos;
|
|
Size aNewSize;
|
|
const Size aWinSize = PixelToLogic( GetOutputSizePixel(), aDisplayMap );
|
|
const long nWidth = aWinSize.Width();
|
|
const long nHeight = aWinSize.Height();
|
|
double fGrfWH = (double) aGraphSize.Width() / aGraphSize.Height();
|
|
double fWinWH = (double) nWidth / nHeight;
|
|
|
|
// Adapt Bitmap to Thumb size
|
|
if ( fGrfWH < fWinWH)
|
|
{
|
|
aNewSize.Width() = (long) ( (double) nHeight * fGrfWH );
|
|
aNewSize.Height()= nHeight;
|
|
}
|
|
else
|
|
{
|
|
aNewSize.Width() = nWidth;
|
|
aNewSize.Height()= (long) ( (double) nWidth / fGrfWH );
|
|
}
|
|
|
|
aNewPos.X() = ( nWidth - aNewSize.Width() ) >> 1;
|
|
aNewPos.Y() = ( nHeight - aNewSize.Height() ) >> 1;
|
|
|
|
// Implementing MapMode for Engine
|
|
aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) );
|
|
aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) );
|
|
|
|
aDisplayMap.SetOrigin( LogicToLogic( aNewPos, aMap100, aDisplayMap ) );
|
|
SetMapMode( aDisplayMap );
|
|
}
|
|
|
|
Invalidate();
|
|
}
|
|
|
|
void GraphCtrl::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
|
|
{
|
|
// #i72889# used splitted repaint to be able to paint an own background
|
|
// even to the buffered view
|
|
const bool bGraphicValid(GraphicType::NONE != aGraphic.GetType());
|
|
|
|
if (mbSdrMode)
|
|
{
|
|
SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(&rRenderContext);
|
|
|
|
if (bGraphicValid)
|
|
{
|
|
vcl::RenderContext& rTarget = pPaintWindow->GetTargetOutputDevice();
|
|
|
|
rTarget.SetBackground(GetBackground());
|
|
rTarget.Erase();
|
|
|
|
aGraphic.Draw(&rTarget, Point(), aGraphSize);
|
|
}
|
|
|
|
const vcl::Region aRepaintRegion(rRect);
|
|
pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion);
|
|
pView->EndCompleteRedraw(*pPaintWindow, true);
|
|
}
|
|
else
|
|
{
|
|
// #i73381# in non-SdrMode, paint to local directly
|
|
if(bGraphicValid)
|
|
{
|
|
aGraphic.Draw(&rRenderContext, Point(), aGraphSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GraphCtrl::SdrObjChanged( const SdrObject& )
|
|
{
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::SdrObjCreated( const SdrObject& )
|
|
{
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::MarkListHasChanged()
|
|
{
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
|
|
{
|
|
vcl::KeyCode aCode( rKEvt.GetKeyCode() );
|
|
bool bProc = false;
|
|
|
|
Dialog* pDialog = GetParentDialog();
|
|
|
|
switch ( aCode.GetCode() )
|
|
{
|
|
case KEY_DELETE:
|
|
case KEY_BACKSPACE:
|
|
{
|
|
if ( mbSdrMode )
|
|
{
|
|
pView->DeleteMarked();
|
|
bProc = true;
|
|
if (!pView->AreObjectsMarked() && pDialog)
|
|
pDialog->GrabFocusToFirstControl();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_ESCAPE:
|
|
{
|
|
if ( mbSdrMode )
|
|
{
|
|
bool bGrabFocusToFirstControl = true;
|
|
if ( pView->IsAction() )
|
|
{
|
|
pView->BrkAction();
|
|
bGrabFocusToFirstControl = false;
|
|
}
|
|
else if ( pView->AreObjectsMarked() )
|
|
{
|
|
const SdrHdlList& rHdlList = pView->GetHdlList();
|
|
SdrHdl* pHdl = rHdlList.GetFocusHdl();
|
|
|
|
if(pHdl)
|
|
{
|
|
const_cast<SdrHdlList&>(rHdlList).ResetFocusHdl();
|
|
bGrabFocusToFirstControl = false;
|
|
}
|
|
}
|
|
if (bGrabFocusToFirstControl && pDialog)
|
|
pDialog->GrabFocusToFirstControl();
|
|
bProc = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_F11:
|
|
case KEY_TAB:
|
|
{
|
|
if( mbSdrMode )
|
|
{
|
|
if( !aCode.IsMod1() && !aCode.IsMod2() )
|
|
{
|
|
bool bForward = !aCode.IsShift();
|
|
// select next object
|
|
if ( ! pView->MarkNextObj( bForward ))
|
|
{
|
|
// At first or last object. Cycle to the other end
|
|
// of the list.
|
|
pView->UnmarkAllObj();
|
|
pView->MarkNextObj (bForward);
|
|
}
|
|
bProc = true;
|
|
}
|
|
else if(aCode.IsMod1())
|
|
{
|
|
// select next handle
|
|
const SdrHdlList& rHdlList = pView->GetHdlList();
|
|
bool bForward(!aCode.IsShift());
|
|
|
|
const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl(bForward);
|
|
|
|
bProc = true;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_END:
|
|
{
|
|
|
|
if ( aCode.IsMod1() )
|
|
{
|
|
// mark last object
|
|
pView->UnmarkAllObj();
|
|
pView->MarkNextObj();
|
|
|
|
bProc = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_HOME:
|
|
{
|
|
if ( aCode.IsMod1() )
|
|
{
|
|
pView->UnmarkAllObj();
|
|
pView->MarkNextObj(true);
|
|
|
|
bProc = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_UP:
|
|
case KEY_DOWN:
|
|
case KEY_LEFT:
|
|
case KEY_RIGHT:
|
|
{
|
|
long nX = 0;
|
|
long nY = 0;
|
|
|
|
if (aCode.GetCode() == KEY_UP)
|
|
{
|
|
// Scroll up
|
|
nX = 0;
|
|
nY =-1;
|
|
}
|
|
else if (aCode.GetCode() == KEY_DOWN)
|
|
{
|
|
// Scroll down
|
|
nX = 0;
|
|
nY = 1;
|
|
}
|
|
else if (aCode.GetCode() == KEY_LEFT)
|
|
{
|
|
// Scroll left
|
|
nX =-1;
|
|
nY = 0;
|
|
}
|
|
else if (aCode.GetCode() == KEY_RIGHT)
|
|
{
|
|
// Scroll right
|
|
nX = 1;
|
|
nY = 0;
|
|
}
|
|
|
|
if (pView->AreObjectsMarked() && !aCode.IsMod1() )
|
|
{
|
|
if(aCode.IsMod2())
|
|
{
|
|
// move in 1 pixel distance
|
|
Size aLogicSizeOnePixel = PixelToLogic(Size(1,1));
|
|
nX *= aLogicSizeOnePixel.Width();
|
|
nY *= aLogicSizeOnePixel.Height();
|
|
}
|
|
else
|
|
{
|
|
// old, fixed move distance
|
|
nX *= 100;
|
|
nY *= 100;
|
|
}
|
|
|
|
// II
|
|
const SdrHdlList& rHdlList = pView->GetHdlList();
|
|
SdrHdl* pHdl = rHdlList.GetFocusHdl();
|
|
|
|
if(nullptr == pHdl)
|
|
{
|
|
// restrict movement to WorkArea
|
|
const tools::Rectangle& rWorkArea = pView->GetWorkArea();
|
|
|
|
if(!rWorkArea.IsEmpty())
|
|
{
|
|
tools::Rectangle aMarkRect(pView->GetMarkedObjRect());
|
|
aMarkRect.Move(nX, nY);
|
|
|
|
if(!aMarkRect.IsInside(rWorkArea))
|
|
{
|
|
if(aMarkRect.Left() < rWorkArea.Left())
|
|
{
|
|
nX += rWorkArea.Left() - aMarkRect.Left();
|
|
}
|
|
|
|
if(aMarkRect.Right() > rWorkArea.Right())
|
|
{
|
|
nX -= aMarkRect.Right() - rWorkArea.Right();
|
|
}
|
|
|
|
if(aMarkRect.Top() < rWorkArea.Top())
|
|
{
|
|
nY += rWorkArea.Top() - aMarkRect.Top();
|
|
}
|
|
|
|
if(aMarkRect.Bottom() > rWorkArea.Bottom())
|
|
{
|
|
nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
|
|
}
|
|
}
|
|
}
|
|
|
|
// no handle selected
|
|
if(0 != nX || 0 != nY)
|
|
{
|
|
pView->MoveAllMarked(Size(nX, nY));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// move handle with index nHandleIndex
|
|
if(pHdl && (nX || nY))
|
|
{
|
|
// now move the Handle (nX, nY)
|
|
Point aStartPoint(pHdl->GetPos());
|
|
Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
|
|
const SdrDragStat& rDragStat = pView->GetDragStat();
|
|
|
|
// start dragging
|
|
pView->BegDragObj(aStartPoint, nullptr, pHdl, 0);
|
|
|
|
if(pView->IsDragObj())
|
|
{
|
|
bool bWasNoSnap = rDragStat.IsNoSnap();
|
|
bool bWasSnapEnabled = pView->IsSnapEnabled();
|
|
|
|
// switch snapping off
|
|
if(!bWasNoSnap)
|
|
const_cast<SdrDragStat&>(rDragStat).SetNoSnap();
|
|
if(bWasSnapEnabled)
|
|
pView->SetSnapEnabled(false);
|
|
|
|
pView->MovAction(aEndPoint);
|
|
pView->EndDragObj();
|
|
|
|
// restore snap
|
|
if(!bWasNoSnap)
|
|
const_cast<SdrDragStat&>(rDragStat).SetNoSnap(bWasNoSnap);
|
|
if(bWasSnapEnabled)
|
|
pView->SetSnapEnabled(bWasSnapEnabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
bProc = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_SPACE:
|
|
{
|
|
const SdrHdlList& rHdlList = pView->GetHdlList();
|
|
SdrHdl* pHdl = rHdlList.GetFocusHdl();
|
|
|
|
if(pHdl)
|
|
{
|
|
if(pHdl->GetKind() == SdrHdlKind::Poly)
|
|
{
|
|
// rescue ID of point with focus
|
|
sal_uInt32 nPol(pHdl->GetPolyNum());
|
|
sal_uInt32 nPnt(pHdl->GetPointNum());
|
|
|
|
if(pView->IsPointMarked(*pHdl))
|
|
{
|
|
if(rKEvt.GetKeyCode().IsShift())
|
|
{
|
|
pView->UnmarkPoint(*pHdl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!rKEvt.GetKeyCode().IsShift())
|
|
{
|
|
pView->UnmarkAllPoints();
|
|
}
|
|
|
|
pView->MarkPoint(*pHdl);
|
|
}
|
|
|
|
if(nullptr == rHdlList.GetFocusHdl())
|
|
{
|
|
// restore point with focus
|
|
SdrHdl* pNewOne = nullptr;
|
|
|
|
for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
|
|
{
|
|
SdrHdl* pAct = rHdlList.GetHdl(a);
|
|
|
|
if(pAct
|
|
&& pAct->GetKind() == SdrHdlKind::Poly
|
|
&& pAct->GetPolyNum() == nPol
|
|
&& pAct->GetPointNum() == nPnt)
|
|
{
|
|
pNewOne = pAct;
|
|
}
|
|
}
|
|
|
|
if(pNewOne)
|
|
{
|
|
const_cast<SdrHdlList&>(rHdlList).SetFocusHdl(pNewOne);
|
|
}
|
|
}
|
|
|
|
bProc = true;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if ( !bProc )
|
|
Control::KeyInput( rKEvt );
|
|
else
|
|
ReleaseMouse();
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
|
|
{
|
|
if ( mbSdrMode && ( rMEvt.GetClicks() < 2 ) )
|
|
{
|
|
const Point aLogPt( PixelToLogic( rMEvt.GetPosPixel() ) );
|
|
|
|
if ( !tools::Rectangle( Point(), aGraphSize ).IsInside( aLogPt ) && !pView->IsEditMode() )
|
|
Control::MouseButtonDown( rMEvt );
|
|
else
|
|
{
|
|
// Get Focus for key inputs
|
|
GrabFocus();
|
|
|
|
if ( nPolyEdit )
|
|
{
|
|
SdrViewEvent aVEvt;
|
|
SdrHitKind eHit = pView->PickAnything( rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt );
|
|
|
|
if ( nPolyEdit == SID_BEZIER_INSERT && eHit == SdrHitKind::MarkedObject )
|
|
pView->BegInsObjPoint( aLogPt, rMEvt.IsMod1());
|
|
else
|
|
pView->MouseButtonDown( rMEvt, this );
|
|
}
|
|
else
|
|
pView->MouseButtonDown( rMEvt, this );
|
|
}
|
|
|
|
SdrObject* pCreateObj = pView->GetCreateObj();
|
|
|
|
// We want to realize the insert
|
|
if ( pCreateObj && !pCreateObj->GetUserCall() )
|
|
pCreateObj->SetUserCall( pUserCall );
|
|
|
|
SetPointer( pView->GetPreferredPointer( aLogPt, this ) );
|
|
}
|
|
else
|
|
Control::MouseButtonDown( rMEvt );
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::MouseMove(const MouseEvent& rMEvt)
|
|
{
|
|
const Point aLogPos( PixelToLogic( rMEvt.GetPosPixel() ) );
|
|
|
|
if ( mbSdrMode )
|
|
{
|
|
pView->MouseMove( rMEvt, this );
|
|
|
|
if( ( SID_BEZIER_INSERT == nPolyEdit ) &&
|
|
!pView->PickHandle( aLogPos ) &&
|
|
!pView->IsInsObjPoint() )
|
|
{
|
|
SetPointer( PointerStyle::Cross );
|
|
}
|
|
else
|
|
SetPointer( pView->GetPreferredPointer( aLogPos, this ) );
|
|
}
|
|
else
|
|
Control::MouseButtonUp( rMEvt );
|
|
|
|
if ( aMousePosLink.IsSet() )
|
|
{
|
|
if ( tools::Rectangle( Point(), aGraphSize ).IsInside( aLogPos ) )
|
|
aMousePos = aLogPos;
|
|
else
|
|
aMousePos = Point();
|
|
|
|
aMousePosLink.Call( this );
|
|
}
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
|
|
{
|
|
if ( mbSdrMode )
|
|
{
|
|
if ( pView->IsInsObjPoint() )
|
|
pView->EndInsObjPoint( SdrCreateCmd::ForceEnd );
|
|
else
|
|
pView->MouseButtonUp( rMEvt, this );
|
|
|
|
ReleaseMouse();
|
|
SetPointer( pView->GetPreferredPointer( PixelToLogic( rMEvt.GetPosPixel() ), this ) );
|
|
}
|
|
else
|
|
Control::MouseButtonUp( rMEvt );
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
SdrObject* GraphCtrl::GetSelectedSdrObject() const
|
|
{
|
|
SdrObject* pSdrObj = nullptr;
|
|
|
|
if ( mbSdrMode )
|
|
{
|
|
const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
|
|
|
|
if ( rMarkList.GetMarkCount() == 1 )
|
|
pSdrObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
|
|
}
|
|
|
|
return pSdrObj;
|
|
}
|
|
|
|
void GraphCtrl::SetEditMode( const bool _bEditMode )
|
|
{
|
|
if ( mbSdrMode )
|
|
{
|
|
bEditMode = _bEditMode;
|
|
pView->SetEditMode( bEditMode );
|
|
eObjKind = OBJ_NONE;
|
|
pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) );
|
|
}
|
|
else
|
|
bEditMode = false;
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::SetPolyEditMode( const sal_uInt16 _nPolyEdit )
|
|
{
|
|
if ( mbSdrMode && ( _nPolyEdit != nPolyEdit ) )
|
|
{
|
|
nPolyEdit = _nPolyEdit;
|
|
pView->SetFrameDragSingles( nPolyEdit == 0 );
|
|
}
|
|
else
|
|
nPolyEdit = 0;
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
|
|
{
|
|
if ( mbSdrMode )
|
|
{
|
|
bEditMode = false;
|
|
pView->SetEditMode( bEditMode );
|
|
eObjKind = _eObjKind;
|
|
pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) );
|
|
}
|
|
else
|
|
eObjKind = OBJ_NONE;
|
|
|
|
QueueIdleUpdate();
|
|
}
|
|
|
|
IMPL_LINK( GraphCtrl, UpdateHdl, Timer *, , void )
|
|
{
|
|
mbInIdleUpdate = true;
|
|
aUpdateLink.Call( this );
|
|
mbInIdleUpdate = false;
|
|
}
|
|
|
|
void GraphCtrl::QueueIdleUpdate()
|
|
{
|
|
if (!mbInIdleUpdate)
|
|
aUpdateIdle.Start();
|
|
}
|
|
|
|
css::uno::Reference< css::accessibility::XAccessible > GraphCtrl::CreateAccessible()
|
|
{
|
|
if( mpAccContext == nullptr )
|
|
{
|
|
vcl::Window* pParent = GetParent();
|
|
|
|
DBG_ASSERT( pParent, "-GraphCtrl::CreateAccessible(): No Parent!" );
|
|
|
|
if( pParent )
|
|
{
|
|
css::uno::Reference< css::accessibility::XAccessible > xAccParent( pParent->GetAccessible() );
|
|
|
|
// Disable accessibility if no model/view data available
|
|
if( pView &&
|
|
pModel &&
|
|
xAccParent.is() )
|
|
{
|
|
mpAccContext = new SvxGraphCtrlAccessibleContext( xAccParent, *this );
|
|
}
|
|
}
|
|
}
|
|
|
|
return mpAccContext.get();
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|