LibreOffice/core
1
0
Fork 0
mirror of https://github.com/LibreOffice/core.git synced 2025-08-11 23:24:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
d94d4efde4a57ec80ebbf8870901886aba7c132d
core/toolkit/source/hatchwindow/ipwin.cxx
Laurent Balland 2ae6a6b7e4 tdf#163816 Keep ratio of OLE object (chart...) 
When an OLE object (for instance a chart in Calc) is edited,
resizing should behave like in non-edited mode:
handles in corner resize proportionaly (Widht/Height ratio is preserved)
whereas handles on edges modify Width/Height ratio
Press Shift key to toggle behavior
When draging object with border,
press shift key to move object only horizontal/vertical/45°

Change-Id: I66df55d3170a094bbd63eff9f6b93915cc57e060
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/177588
Tested-by: Jenkins
Reviewed-by: Laurent Balland <laurent.balland@mailo.fr>
2025-05-04 10:48:43 +02:00

684 lines
24 KiB
C++
Raw Blame History

/* -*- 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 <com/sun/star/accessibility/AccessibleRole.hpp>
#include <osl/diagnose.h>
#include <vcl/event.hxx>
#include <vcl/settings.hxx>
#include <vcl/ptrstyle.hxx>
#include "ipwin.hxx"
#include "hatchwindow.hxx"
/************************************************************************/
/*************************************************************************
|* SvResizeHelper::SvResizeHelper()
|*
|* Description
*************************************************************************/
SvResizeHelper::SvResizeHelper()
: aBorder( 5, 5 )
, nGrab( -1 )
, mofStartingRatio( std::nullopt )
{
}
/*************************************************************************
|* SvResizeHelper::FillHandleRects()
|*
|* Description: the eight handles to magnify
*************************************************************************/
std::array<tools::Rectangle,8> SvResizeHelper::FillHandleRectsPixel() const
{
std::array<tools::Rectangle,8> aRects;
// only because of EMPTY_RECT
Point aBottomRight = aOuter.BottomRight();
// upper left
aRects[ 0 ] = tools::Rectangle( aOuter.TopLeft(), aBorder );
// upper middle
aRects[ 1 ] = tools::Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
aOuter.Top() ),
aBorder );
// upper right
aRects[ 2 ] = tools::Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
aOuter.Top() ),
aBorder );
// middle right
aRects[ 3 ] = tools::Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
aOuter.Center().Y() - aBorder.Height() / 2 ),
aBorder );
// lower right
aRects[ 4 ] = tools::Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
aBottomRight.Y() - aBorder.Height() +1 ),
aBorder );
// lower middle
aRects[ 5 ] = tools::Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
aBottomRight.Y() - aBorder.Height() +1),
aBorder );
// lower left
aRects[ 6 ] = tools::Rectangle( Point( aOuter.Left(),
aBottomRight.Y() - aBorder.Height() +1),
aBorder );
// middle left
aRects[ 7 ] = tools::Rectangle( Point( aOuter.Left(),
aOuter.Center().Y() - aBorder.Height() / 2 ),
aBorder );
return aRects;
}
/*************************************************************************
|* SvResizeHelper::FillMoveRectsPixel()
|*
|* Description: the four edges are calculated
*************************************************************************/
std::array<tools::Rectangle,4> SvResizeHelper::FillMoveRectsPixel() const
{
std::array<tools::Rectangle,4> aRects;
// upper
aRects[ 0 ] = aOuter;
aRects[ 0 ].SetBottom( aRects[ 0 ].Top() + aBorder.Height() -1 );
// right
aRects[ 1 ] = aOuter;
if (!aOuter.IsWidthEmpty())
aRects[ 1 ].SetLeft( aRects[ 1 ].Right() - aBorder.Width() -1 );
// lower
aRects[ 2 ] = aOuter;
if (!aOuter.IsHeightEmpty())
aRects[ 2 ].SetTop( aRects[ 2 ].Bottom() - aBorder.Height() -1 );
// left
aRects[ 3 ] = aOuter;
aRects[ 3 ].SetRight( aRects[ 3 ].Left() + aBorder.Width() -1 );
return aRects;
}
/*************************************************************************
|* SvResizeHelper::Draw()
|*
|* Description
*************************************************************************/
void SvResizeHelper::Draw(vcl::RenderContext& rRenderContext)
{
rRenderContext.Push();
rRenderContext.SetMapMode( MapMode() );
rRenderContext.SetFillColor( COL_LIGHTGRAY );
rRenderContext.SetLineColor();
std::array<tools::Rectangle,4> aMoveRects = FillMoveRectsPixel();
sal_uInt16 i;
for (i = 0; i < 4; i++)
rRenderContext.DrawRect(aMoveRects[i]);
// draw handles
rRenderContext.SetFillColor(Color()); // black
std::array<tools::Rectangle,8> aRects = FillHandleRectsPixel();
for (i = 0; i < 8; i++)
rRenderContext.DrawRect( aRects[ i ] );
rRenderContext.Pop();
}
/*************************************************************************
|* SvResizeHelper::InvalidateBorder()
|*
|* Description
*************************************************************************/
void SvResizeHelper::InvalidateBorder( vcl::Window * pWin )
{
std::array<tools::Rectangle,4> aMoveRects = FillMoveRectsPixel();
for(const auto & rMoveRect : aMoveRects)
pWin->Invalidate( rMoveRect );
}
/*************************************************************************
|* SvResizeHelper::SelectBegin()
|*
|* Description
*************************************************************************/
bool SvResizeHelper::SelectBegin( vcl::Window * pWin, const Point & rPos, const bool bShiftPressed )
{
if( -1 == nGrab && pWin )
{
nGrab = SelectMove( pWin, rPos, bShiftPressed );
if( -1 != nGrab )
{
aSelPos = rPos; // store start position
mofStartingRatio = std::nullopt;
const auto aWinSize = pWin->GetSizePixel();
if( aWinSize.Height() )
mofStartingRatio = aWinSize.Width() / static_cast<double>( aWinSize.Height() );
pWin->CaptureMouse();
return true;
}
}
return false;
}
/*************************************************************************
|* SvResizeHelper::SelectMove()
|*
|* Description
*************************************************************************/
short SvResizeHelper::SelectMove( vcl::Window * pWin, const Point & rPos, const bool bShiftPressed )
{
if( -1 == nGrab )
{
std::array<tools::Rectangle,8> aRects = FillHandleRectsPixel();
for( sal_uInt16 i = 0; i < 8; i++ )
if( aRects[ i ].Contains( rPos ) )
return i;
// Move-Rect overlaps Handles
std::array<tools::Rectangle,4> aMoveRects = FillMoveRectsPixel();
for(const auto & rMoveRect : aMoveRects)
if( rMoveRect.Contains( rPos ) )
return 8;
}
else
{
tools::Rectangle aRect = pWin->PixelToLogic(GetTrackRectPixel( rPos, bShiftPressed ));
pWin->ShowTracking( aRect );
}
return nGrab;
}
Point SvResizeHelper::GetTrackPosPixel( const tools::Rectangle & rRect ) const
{
// not important how the rectangle is returned, it is important
// which handle has been touched
Point aPos;
tools::Rectangle aRect( rRect );
aRect.Normalize();
// only because of EMPTY_RECT
Point aBR = aOuter.BottomRight();
Point aTR = aOuter.TopRight();
Point aBL = aOuter.BottomLeft();
bool bRTL = AllSettings::GetLayoutRTL();
switch( nGrab )
{
case 0:
// FIXME: disable it for RTL because it's wrong calculations
if( bRTL )
break;
aPos = aRect.TopLeft() - aOuter.TopLeft();
break;
case 1:
aPos.setY( aRect.Top() - aOuter.Top() );
break;
case 2:
// FIXME: disable it for RTL because it's wrong calculations
if( bRTL )
break;
aPos = aRect.TopRight() - aTR;
break;
case 3:
if( bRTL )
aPos.setX( aRect.Left() - aTR.X() );
else
aPos.setX( aRect.Right() - aTR.X() );
break;
case 4:
// FIXME: disable it for RTL because it's wrong calculations
if( bRTL )
break;
aPos = aRect.BottomRight() - aBR;
break;
case 5:
aPos.setY( aRect.Bottom() - aBR.Y() );
break;
case 6:
// FIXME: disable it for RTL because it's wrong calculations
if( bRTL )
break;
aPos = aRect.BottomLeft() - aBL;
break;
case 7:
if( bRTL )
aPos.setX( aRect.Right() + aOuter.Right() - aOuter.Right() );
else
aPos.setX( aRect.Left() - aOuter.Left() );
break;
case 8:
aPos = aRect.TopLeft() - aOuter.TopLeft();
break;
}
return aPos + aSelPos;
}
/*************************************************************************
|* SvResizeHelper::GetTrackRectPixel()
|*
|* Description
*************************************************************************/
tools::Rectangle SvResizeHelper::GetTrackRectPixel( const Point & rTrackPos, const bool bShiftPressed ) const
{
tools::Rectangle aTrackRect;
if( -1 == nGrab )
return aTrackRect;
Point aDiff = rTrackPos - aSelPos;
aTrackRect = aOuter;
Point aBR = aOuter.BottomRight();
bool bRTL = AllSettings::GetLayoutRTL();
switch( nGrab )
{
case 0:
aTrackRect.AdjustTop(aDiff.Y() );
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.SetRight( aBR.X() - aDiff.X() );
else
aTrackRect.AdjustLeft(aDiff.X() );
break;
case 1:
aTrackRect.AdjustTop(aDiff.Y() );
break;
case 2:
aTrackRect.AdjustTop(aDiff.Y() );
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.AdjustLeft( -(aDiff.X()) );
else
aTrackRect.SetRight( aBR.X() + aDiff.X() );
break;
case 3:
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.AdjustLeft( -(aDiff.X()) );
else
aTrackRect.SetRight( aBR.X() + aDiff.X() );
break;
case 4:
aTrackRect.SetBottom( aBR.Y() + aDiff.Y() );
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.AdjustLeft( -(aDiff.X()) );
else
aTrackRect.SetRight( aBR.X() + aDiff.X() );
break;
case 5:
aTrackRect.SetBottom( aBR.Y() + aDiff.Y() );
break;
case 6:
aTrackRect.SetBottom( aBR.Y() + aDiff.Y() );
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.SetRight( aBR.X() - aDiff.X() );
else
aTrackRect.AdjustLeft(aDiff.X() );
break;
case 7:
// ugly solution for resizing OLE objects in RTL
if( bRTL )
aTrackRect.SetRight( aBR.X() - aDiff.X() );
else
aTrackRect.AdjustLeft(aDiff.X() );
break;
case 8:
if( bRTL )
aDiff.setX( -aDiff.X() ); // workaround for move in RTL mode
if( bShiftPressed )
{
const Point aDiffAbs( std::abs( aDiff.X() ), std::abs( aDiff.Y() ) );
if( 2 * aDiffAbs.X() < aDiffAbs.Y() ) // vertical move
aDiff.setX( 0L );
else if( aDiffAbs.X() > 2 * aDiffAbs.Y() ) // horizontal move
aDiff.setY( 0L );
else if( aDiffAbs.X() != aDiffAbs.Y() ) // 45° move
{
if( aDiffAbs.X() > aDiffAbs.Y() )
aDiff.setY( aDiff.Y() / aDiffAbs.Y() * aDiffAbs.X() );
else
aDiff.setX( aDiff.X() / aDiffAbs.X() * aDiffAbs.Y() );
}
}
aTrackRect.SetPos( aTrackRect.TopLeft() + aDiff );
break;
}
// TODO: should use same code as other objects. See SdrTextObj::ImpDragCalcRect() and SdrObject::ImpDragCalcRect()
// uneven values are for edges
const bool bIsEdge = ( nGrab != (( nGrab / 2 ) * 2) );
// tdf#163816: Resizing OLE object in edited mode should behave like in not-edited mode
// Corner handles are proportional by default, whereas edge handles are not proportional
// pressed Shift toggles behavior
const bool bProportional = ( bIsEdge == bShiftPressed );
if( bProportional && nGrab != 8 && mofStartingRatio )
{
bool bChangeWidth = false;
if( nGrab == 1 || nGrab == 5 ) // top and bottom handles
{
bChangeWidth = true;
}
else if ( nGrab != 3 && nGrab != 7 )
{ // handles in corners: keep the largest size
bChangeWidth = aTrackRect.GetWidth() < aTrackRect.GetHeight() * mofStartingRatio.value();
}
if( bChangeWidth )
{
const tools::Long nNewWidth = aTrackRect.GetHeight() * mofStartingRatio.value();
if ( nGrab == 6 || nGrab == 0 ) // corners on left side
// move left with right as reference
aTrackRect.SetLeft( aTrackRect.Right() - nNewWidth );
else if ( nGrab == 1 || nGrab == 5 ) // top and bottom handles
// move left half of the change of width to keep the handle in the middle
aTrackRect.SetLeft( aTrackRect.Left() + ( aTrackRect.GetWidth() - nNewWidth ) / 2 );
// other handles use left as reference, then no change needed
aTrackRect.SetWidth( nNewWidth );
}
else
{
const tools::Long nNewHeight = aTrackRect.GetWidth() / mofStartingRatio.value();
if ( nGrab == 2 || nGrab == 0 ) // corners on top
// move top with bottom as reference
aTrackRect.SetTop( aTrackRect.Bottom() - nNewHeight );
else if ( nGrab == 3 || nGrab == 7 ) // right and left handles
// move top half of the change of height to keep the handle in the middle
aTrackRect.SetTop( aTrackRect.Top() + ( aTrackRect.GetHeight() - nNewHeight ) / 2 );
// other handles use top as reference, then no change needed
aTrackRect.SetHeight( nNewHeight );
}
}
return aTrackRect;
}
void SvResizeHelper::ValidateRect( tools::Rectangle & rValidate ) const
{
switch( nGrab )
{
case 0:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetTop( rValidate.Bottom() );
if( rValidate.Left() > rValidate.Right() )
rValidate.SetLeft( rValidate.Right() );
break;
case 1:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetTop( rValidate.Bottom() );
break;
case 2:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetTop( rValidate.Bottom() );
if( rValidate.Left() > rValidate.Right() )
rValidate.SetRight( rValidate.Left() );
break;
case 3:
if( rValidate.Left() > rValidate.Right() )
rValidate.SetRight( rValidate.Left() );
break;
case 4:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetBottom( rValidate.Top() );
if( rValidate.Left() > rValidate.Right() )
rValidate.SetRight( rValidate.Left() );
break;
case 5:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetBottom( rValidate.Top() );
break;
case 6:
if( rValidate.Top() > rValidate.Bottom() )
rValidate.SetBottom( rValidate.Top() );
if( rValidate.Left() > rValidate.Right() )
rValidate.SetLeft( rValidate.Right() );
break;
case 7:
if( rValidate.Left() > rValidate.Right() )
rValidate.SetLeft( rValidate.Right() );
break;
}
// Minimum size 5 x 5
if( rValidate.Left() + 5 > rValidate.Right() )
rValidate.SetRight( rValidate.Left() + 5 );
if( rValidate.Top() + 5 > rValidate.Bottom() )
rValidate.SetBottom( rValidate.Top() + 5 );
}
/*************************************************************************
|* SvResizeHelper::SelectRelease()
|*
|* Description
*************************************************************************/
bool SvResizeHelper::SelectRelease( vcl::Window * pWin, const Point & rPos,
tools::Rectangle & rOutPosSize, const bool bShiftPressed )
{
if( -1 != nGrab )
{
rOutPosSize = GetTrackRectPixel( rPos, bShiftPressed );
rOutPosSize.Normalize();
nGrab = -1;
pWin->ReleaseMouse();
pWin->HideTracking();
return true;
}
return false;
}
/*************************************************************************
|* SvResizeHelper::Release()
|*
|* Description
*************************************************************************/
void SvResizeHelper::Release( vcl::Window * pWin )
{
if( nGrab != -1 )
{
pWin->ReleaseMouse();
pWin->HideTracking();
nGrab = -1;
}
}
/*************************************************************************
|* SvResizeWindow::SvResizeWindow()
|*
|* Description
*************************************************************************/
SvResizeWindow::SvResizeWindow
(
vcl::Window * pParent,
VCLXHatchWindow* pWrapper
)
: Window( pParent, WB_CLIPCHILDREN )
, m_aOldPointer(PointerStyle::Arrow)
, m_nMoveGrab( -1 )
, m_bActive( false )
, m_pWrapper( pWrapper )
{
OSL_ENSURE( pParent != nullptr && pWrapper != nullptr, "Wrong initialization of hatch window!" );
SetBackground();
SetAccessibleRole( css::accessibility::AccessibleRole::EMBEDDED_OBJECT );
m_aResizer.SetOuterRectPixel( tools::Rectangle( Point(), GetOutputSizePixel() ) );
}
/*************************************************************************
|* SvResizeWindow::SetHatchBorderPixel()
|*
|* Description
*************************************************************************/
void SvResizeWindow::SetHatchBorderPixel( const Size & rSize )
{
m_aResizer.SetBorderPixel( rSize );
}
/*************************************************************************
|* SvResizeWindow::SelectMouse()
|*
|* Description
*************************************************************************/
void SvResizeWindow::SelectMouse( const Point & rPos, const bool bShiftPressed )
{
short nGrab = m_aResizer.SelectMove( this, rPos, bShiftPressed );
if( nGrab >= 4 )
nGrab -= 4;
if( m_nMoveGrab == nGrab )
return;
// Pointer did change
if( -1 == nGrab )
SetPointer( m_aOldPointer );
else
{
PointerStyle aStyle = PointerStyle::Move;
if( nGrab == 3 )
aStyle = PointerStyle::ESize;
else if( nGrab == 2 )
aStyle = PointerStyle::NESize;
else if( nGrab == 1 )
aStyle = PointerStyle::SSize;
else if( nGrab == 0 )
aStyle = PointerStyle::SESize;
if( m_nMoveGrab == -1 ) // the first time
{
m_aOldPointer = GetPointer();
SetPointer( aStyle );
}
else
SetPointer( aStyle );
}
m_nMoveGrab = nGrab;
}
/*************************************************************************
|* SvResizeWindow::MouseButtonDown()
|*
|* Description
*************************************************************************/
void SvResizeWindow::MouseButtonDown( const MouseEvent & rEvt )
{
if( m_aResizer.SelectBegin( this, rEvt.GetPosPixel(), rEvt.IsShift() ) )
SelectMouse( rEvt.GetPosPixel(), rEvt.IsShift() );
}
/*************************************************************************
|* SvResizeWindow::MouseMove()
|*
|* Description
*************************************************************************/
void SvResizeWindow::MouseMove( const MouseEvent & rEvt )
{
if( m_aResizer.GetGrab() == -1 )
SelectMouse( rEvt.GetPosPixel(), rEvt.IsShift() );
else
{
tools::Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel(), rEvt.IsShift() ) );
Point aDiff = GetPosPixel();
aRect.SetPos( aRect.TopLeft() + aDiff );
m_aResizer.ValidateRect( aRect );
m_pWrapper->QueryObjAreaPixel( aRect );
aRect.SetPos( aRect.TopLeft() - aDiff );
Point aPos = m_aResizer.GetTrackPosPixel( aRect );
SelectMouse( aPos, rEvt.IsShift() );
}
}
/*************************************************************************
|* SvResizeWindow::MouseButtonUp()
|*
|* Description
*************************************************************************/
void SvResizeWindow::MouseButtonUp( const MouseEvent & rEvt )
{
if( m_aResizer.GetGrab() == -1 )
return;
tools::Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel(), rEvt.IsShift() ) );
Point aDiff = GetPosPixel();
aRect.SetPos( aRect.TopLeft() + aDiff );
// aRect -= GetAllBorderPixel();
m_aResizer.ValidateRect( aRect );
m_pWrapper->QueryObjAreaPixel( aRect );
tools::Rectangle aOutRect;
if( m_aResizer.SelectRelease( this, rEvt.GetPosPixel(), aOutRect, rEvt.IsShift() ) )
{
m_nMoveGrab = -1;
SetPointer( m_aOldPointer );
m_pWrapper->RequestObjAreaPixel( aRect );
}
}
/*************************************************************************
|* SvResizeWindow::KeyEvent()
|*
|* Description
*************************************************************************/
void SvResizeWindow::KeyInput( const KeyEvent & rEvt )
{
if( rEvt.GetKeyCode().GetCode() == KEY_ESCAPE )
{
m_aResizer.Release( this );
m_pWrapper->InplaceDeactivate();
}
}
/*************************************************************************
|* SvResizeWindow::Resize()
|*
|* Description
*************************************************************************/
void SvResizeWindow::Resize()
{
m_aResizer.InvalidateBorder( this ); // old area
m_aResizer.SetOuterRectPixel( tools::Rectangle( Point(), GetOutputSizePixel() ) );
m_aResizer.InvalidateBorder( this ); // new area
}
/*************************************************************************
|* SvResizeWindow::Paint()
|*
|* Description
*************************************************************************/
void SvResizeWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle & /*rRect*/ )
{
m_aResizer.Draw(rRenderContext);
}
bool SvResizeWindow::PreNotify( NotifyEvent& rEvt )
{
if ( rEvt.GetType() == NotifyEventType::GETFOCUS && !m_bActive )
{
m_bActive = true;
m_pWrapper->Activated();
}
return Window::PreNotify(rEvt);
}
bool SvResizeWindow::EventNotify( NotifyEvent& rEvt )
{
if ( rEvt.GetType() == NotifyEventType::LOSEFOCUS && m_bActive )
{
bool bHasFocus = HasChildPathFocus(true);
if ( !bHasFocus )
{
m_bActive = false;
m_pWrapper->Deactivated();
}
}
return Window::EventNotify(rEvt);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in New Issue View Git Blame Copy Permalink