422 lines
13 KiB
C++
422 lines
13 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 <vcl/commandevent.hxx>
|
|
#include <vcl/window.hxx>
|
|
#include <vcl/seleng.hxx>
|
|
#include <comphelper/lok.hxx>
|
|
#include <sal/log.hxx>
|
|
|
|
FunctionSet::~FunctionSet()
|
|
{
|
|
}
|
|
|
|
inline bool SelectionEngine::ShouldDeselect( bool bModifierKey1 ) const
|
|
{
|
|
return eSelMode != SelectionMode::Multiple || !bModifierKey1;
|
|
}
|
|
|
|
// TODO: throw out FunctionSet::SelectAtPoint
|
|
|
|
SelectionEngine::SelectionEngine( vcl::Window* pWindow, FunctionSet* pFuncSet ) :
|
|
pWin( pWindow ),
|
|
aWTimer( "vcl::SelectionEngine aWTimer" ),
|
|
nUpdateInterval( SELENG_AUTOREPEAT_INTERVAL )
|
|
{
|
|
eSelMode = SelectionMode::Single;
|
|
pFunctionSet = pFuncSet;
|
|
nFlags = SelectionEngineFlags::EXPANDONMOVE;
|
|
nLockedMods = 0;
|
|
|
|
aWTimer.SetInvokeHandler( LINK( this, SelectionEngine, ImpWatchDog ) );
|
|
aWTimer.SetTimeout( nUpdateInterval );
|
|
}
|
|
|
|
SelectionEngine::~SelectionEngine()
|
|
{
|
|
aWTimer.Stop();
|
|
}
|
|
|
|
IMPL_LINK_NOARG(SelectionEngine, ImpWatchDog, Timer *, void)
|
|
{
|
|
if ( !aArea.Contains( aLastMove.GetPosPixel() ) )
|
|
SelMouseMove( aLastMove );
|
|
}
|
|
|
|
void SelectionEngine::SetSelectionMode( SelectionMode eMode )
|
|
{
|
|
eSelMode = eMode;
|
|
}
|
|
|
|
void SelectionEngine::CursorPosChanging( bool bShift, bool bMod1 )
|
|
{
|
|
if ( !pFunctionSet )
|
|
return;
|
|
|
|
if ( bShift && eSelMode != SelectionMode::Single )
|
|
{
|
|
if ( IsAddMode() )
|
|
{
|
|
if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
|
|
{
|
|
pFunctionSet->CreateAnchor();
|
|
nFlags |= SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
|
|
{
|
|
if( ShouldDeselect( bMod1 ) )
|
|
pFunctionSet->DeselectAll();
|
|
pFunctionSet->CreateAnchor();
|
|
nFlags |= SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( IsAddMode() )
|
|
{
|
|
if ( nFlags & SelectionEngineFlags::HAS_ANCH )
|
|
{
|
|
// pFunctionSet->CreateCursor();
|
|
pFunctionSet->DestroyAnchor();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( ShouldDeselect( bMod1 ) )
|
|
pFunctionSet->DeselectAll();
|
|
else
|
|
pFunctionSet->DestroyAnchor();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SelectionEngine::SelMouseButtonDown( const MouseEvent& rMEvt )
|
|
{
|
|
nFlags &= ~SelectionEngineFlags::CMDEVT;
|
|
if ( !pFunctionSet || rMEvt.GetClicks() > 1 )
|
|
return false;
|
|
|
|
sal_uInt16 nModifier = rMEvt.GetModifier() | nLockedMods;
|
|
bool nSwap = comphelper::LibreOfficeKit::isActive() && (nModifier & KEY_MOD1) && (nModifier & KEY_MOD2);
|
|
|
|
if ( !nSwap && (nModifier & KEY_MOD2) )
|
|
return false;
|
|
// in SingleSelection: filter Control-Key,
|
|
// so that a D&D can be also started with a Ctrl-Click
|
|
if ( nModifier == KEY_MOD1 && eSelMode == SelectionMode::Single )
|
|
nModifier = 0;
|
|
|
|
Point aPos = rMEvt.GetPosPixel();
|
|
aLastMove = rMEvt;
|
|
|
|
if( !rMEvt.IsRight() )
|
|
{
|
|
CaptureMouse();
|
|
nFlags |= SelectionEngineFlags::IN_SEL;
|
|
}
|
|
else
|
|
{
|
|
nModifier = 0;
|
|
}
|
|
|
|
if (nSwap)
|
|
{
|
|
pFunctionSet->CreateAnchor();
|
|
pFunctionSet->SetCursorAtPoint( aPos );
|
|
return true;
|
|
}
|
|
|
|
switch ( nModifier )
|
|
{
|
|
case 0: // KEY_NO_KEY
|
|
{
|
|
bool bSelAtPoint = pFunctionSet->IsSelectionAtPoint( aPos );
|
|
nFlags &= ~SelectionEngineFlags::IN_ADD;
|
|
if ( (nFlags & SelectionEngineFlags::DRG_ENAB) && bSelAtPoint )
|
|
{
|
|
nFlags |= SelectionEngineFlags::WAIT_UPEVT;
|
|
nFlags &= ~SelectionEngineFlags::IN_SEL;
|
|
ReleaseMouse();
|
|
return true; // wait for STARTDRAG-Command-Event
|
|
}
|
|
if ( eSelMode != SelectionMode::Single )
|
|
{
|
|
if( !IsAddMode() )
|
|
pFunctionSet->DeselectAll();
|
|
else
|
|
pFunctionSet->DestroyAnchor();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH; // bHasAnchor = false;
|
|
}
|
|
pFunctionSet->SetCursorAtPoint( aPos );
|
|
// special case Single-Selection, to enable simple Select+Drag
|
|
if (eSelMode == SelectionMode::Single && (nFlags & SelectionEngineFlags::DRG_ENAB))
|
|
nFlags |= SelectionEngineFlags::WAIT_UPEVT;
|
|
return true;
|
|
}
|
|
|
|
case KEY_SHIFT:
|
|
if ( eSelMode == SelectionMode::Single )
|
|
{
|
|
ReleaseMouse();
|
|
nFlags &= ~SelectionEngineFlags::IN_SEL;
|
|
pFunctionSet->SetCursorAtPoint(aPos);
|
|
return false;
|
|
}
|
|
if ( nFlags & SelectionEngineFlags::ADD_ALW )
|
|
nFlags |= SelectionEngineFlags::IN_ADD;
|
|
else
|
|
nFlags &= ~SelectionEngineFlags::IN_ADD;
|
|
|
|
if( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
|
|
{
|
|
if ( !(nFlags & SelectionEngineFlags::IN_ADD) )
|
|
pFunctionSet->DeselectAll();
|
|
pFunctionSet->CreateAnchor();
|
|
nFlags |= SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
pFunctionSet->SetCursorAtPoint( aPos );
|
|
return true;
|
|
|
|
case KEY_MOD1:
|
|
// allow Control only for Multi-Select
|
|
if ( eSelMode != SelectionMode::Multiple )
|
|
{
|
|
nFlags &= ~SelectionEngineFlags::IN_SEL;
|
|
ReleaseMouse();
|
|
return true; // skip Mouse-Click
|
|
}
|
|
if ( nFlags & SelectionEngineFlags::HAS_ANCH )
|
|
{
|
|
// pFunctionSet->CreateCursor();
|
|
pFunctionSet->DestroyAnchor();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
if ( pFunctionSet->IsSelectionAtPoint( aPos ) )
|
|
{
|
|
pFunctionSet->DeselectAtPoint( aPos );
|
|
pFunctionSet->SetCursorAtPoint( aPos, true );
|
|
}
|
|
else
|
|
{
|
|
pFunctionSet->SetCursorAtPoint( aPos );
|
|
}
|
|
return true;
|
|
|
|
case KEY_SHIFT + KEY_MOD1:
|
|
if ( eSelMode != SelectionMode::Multiple )
|
|
{
|
|
ReleaseMouse();
|
|
nFlags &= ~SelectionEngineFlags::IN_SEL;
|
|
return false;
|
|
}
|
|
nFlags |= SelectionEngineFlags::IN_ADD; //bIsInAddMode = true;
|
|
if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
|
|
{
|
|
pFunctionSet->CreateAnchor();
|
|
nFlags |= SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
pFunctionSet->SetCursorAtPoint( aPos );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SelectionEngine::SelMouseButtonUp( const MouseEvent& rMEvt )
|
|
{
|
|
aWTimer.Stop();
|
|
if (!pFunctionSet)
|
|
{
|
|
const SelectionEngineFlags nMask = SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT | SelectionEngineFlags::IN_SEL;
|
|
nFlags &= ~nMask;
|
|
return false;
|
|
}
|
|
|
|
if (!rMEvt.IsRight())
|
|
ReleaseMouse();
|
|
|
|
#if defined IOS || defined ANDROID
|
|
const bool bDoMessWithSelection = !rMEvt.IsRight();
|
|
#else
|
|
constexpr bool bDoMessWithSelection = true;
|
|
#endif
|
|
|
|
if( (nFlags & SelectionEngineFlags::WAIT_UPEVT) && !(nFlags & SelectionEngineFlags::CMDEVT) &&
|
|
eSelMode != SelectionMode::Single)
|
|
{
|
|
// MouseButtonDown in Sel but no CommandEvent yet
|
|
// ==> deselect
|
|
sal_uInt16 nModifier = aLastMove.GetModifier() | nLockedMods;
|
|
if( nModifier == KEY_MOD1 || IsAlwaysAdding() )
|
|
{
|
|
if( !(nModifier & KEY_SHIFT) )
|
|
{
|
|
pFunctionSet->DestroyAnchor();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH; // uncheck anchor
|
|
}
|
|
pFunctionSet->DeselectAtPoint( aLastMove.GetPosPixel() );
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH; // uncheck anchor
|
|
if (bDoMessWithSelection)
|
|
pFunctionSet->SetCursorAtPoint( aLastMove.GetPosPixel(), true );
|
|
}
|
|
else
|
|
{
|
|
if (bDoMessWithSelection)
|
|
pFunctionSet->DeselectAll();
|
|
nFlags &= ~SelectionEngineFlags::HAS_ANCH; // uncheck anchor
|
|
if (bDoMessWithSelection)
|
|
pFunctionSet->SetCursorAtPoint( aLastMove.GetPosPixel() );
|
|
}
|
|
}
|
|
|
|
const SelectionEngineFlags nMask = SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT | SelectionEngineFlags::IN_SEL;
|
|
nFlags &= ~nMask;
|
|
return true;
|
|
}
|
|
|
|
void SelectionEngine::ReleaseMouse()
|
|
{
|
|
if (!pWin || !pWin->IsMouseCaptured())
|
|
return;
|
|
pWin->ReleaseMouse();
|
|
}
|
|
|
|
void SelectionEngine::CaptureMouse()
|
|
{
|
|
if (!pWin || pWin->IsMouseCaptured())
|
|
return;
|
|
pWin->CaptureMouse();
|
|
}
|
|
|
|
bool SelectionEngine::SelMouseMove( const MouseEvent& rMEvt )
|
|
{
|
|
|
|
if ( !pFunctionSet || !(nFlags & SelectionEngineFlags::IN_SEL) ||
|
|
(nFlags & (SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT)) )
|
|
return false;
|
|
|
|
if( !(nFlags & SelectionEngineFlags::EXPANDONMOVE) )
|
|
return false; // wait for DragEvent!
|
|
|
|
aLastMove = rMEvt;
|
|
// if the mouse is outside the area, the frequency of
|
|
// SetCursorAtPoint() is only set by the Timer
|
|
if( aWTimer.IsActive() && !aArea.Contains( rMEvt.GetPosPixel() ))
|
|
return true;
|
|
|
|
aWTimer.SetTimeout( nUpdateInterval );
|
|
if (!comphelper::LibreOfficeKit::isActive())
|
|
// Generating fake mouse moves does not work with LOK.
|
|
aWTimer.Start();
|
|
if ( eSelMode != SelectionMode::Single )
|
|
{
|
|
if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
|
|
{
|
|
pFunctionSet->CreateAnchor();
|
|
nFlags |= SelectionEngineFlags::HAS_ANCH;
|
|
}
|
|
}
|
|
|
|
pFunctionSet->SetCursorAtPoint( rMEvt.GetPosPixel() );
|
|
|
|
return true;
|
|
}
|
|
|
|
void SelectionEngine::SetWindow( vcl::Window* pNewWin )
|
|
{
|
|
if( pNewWin != pWin )
|
|
{
|
|
if (nFlags & SelectionEngineFlags::IN_SEL)
|
|
ReleaseMouse();
|
|
pWin = pNewWin;
|
|
if (nFlags & SelectionEngineFlags::IN_SEL)
|
|
CaptureMouse();
|
|
}
|
|
}
|
|
|
|
void SelectionEngine::Reset()
|
|
{
|
|
aWTimer.Stop();
|
|
if (nFlags & SelectionEngineFlags::IN_SEL)
|
|
ReleaseMouse();
|
|
nFlags &= ~SelectionEngineFlags(SelectionEngineFlags::HAS_ANCH | SelectionEngineFlags::IN_SEL);
|
|
nLockedMods = 0;
|
|
}
|
|
|
|
bool SelectionEngine::Command( const CommandEvent& rCEvt )
|
|
{
|
|
// Timer aWTimer is active during enlarging a selection
|
|
if ( !pFunctionSet || aWTimer.IsActive() )
|
|
return false;
|
|
aWTimer.Stop();
|
|
if ( rCEvt.GetCommand() != CommandEventId::StartDrag )
|
|
return false;
|
|
|
|
nFlags |= SelectionEngineFlags::CMDEVT;
|
|
if ( nFlags & SelectionEngineFlags::DRG_ENAB )
|
|
{
|
|
SAL_WARN_IF( !rCEvt.IsMouseEvent(), "vcl", "STARTDRAG: Not a MouseEvent" );
|
|
if ( pFunctionSet->IsSelectionAtPoint( rCEvt.GetMousePosPixel() ) )
|
|
{
|
|
aLastMove = MouseEvent( rCEvt.GetMousePosPixel(),
|
|
aLastMove.GetClicks(), aLastMove.GetMode(),
|
|
aLastMove.GetButtons(), aLastMove.GetModifier() );
|
|
pFunctionSet->BeginDrag();
|
|
const SelectionEngineFlags nMask = SelectionEngineFlags::CMDEVT|SelectionEngineFlags::WAIT_UPEVT|SelectionEngineFlags::IN_SEL;
|
|
nFlags &= ~nMask;
|
|
}
|
|
else
|
|
nFlags &= ~SelectionEngineFlags::CMDEVT;
|
|
}
|
|
else
|
|
nFlags &= ~SelectionEngineFlags::CMDEVT;
|
|
return true;
|
|
}
|
|
|
|
void SelectionEngine::SetUpdateInterval( sal_uInt64 nInterval )
|
|
{
|
|
if (nInterval < SELENG_AUTOREPEAT_INTERVAL_MIN)
|
|
// Set a lower threshold. On Windows, setting this value too low
|
|
// would cause selection to get updated indefinitely.
|
|
nInterval = SELENG_AUTOREPEAT_INTERVAL_MIN;
|
|
|
|
if (nUpdateInterval == nInterval)
|
|
// no update needed.
|
|
return;
|
|
|
|
if (aWTimer.IsActive())
|
|
{
|
|
// reset the timer right away on interval change.
|
|
aWTimer.Stop();
|
|
aWTimer.SetTimeout(nInterval);
|
|
aWTimer.Start();
|
|
}
|
|
else
|
|
aWTimer.SetTimeout(nInterval);
|
|
|
|
nUpdateInterval = nInterval;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|