vcl/source/window/seleng.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 <vcl/window.hxx>
  21 #include <vcl/seleng.hxx>
  22 #include <tools/debug.hxx>
  23 #include <comphelper/lok.hxx>
  24
  25 FunctionSet::~FunctionSet()
  26 {
  27 }
  28
  29 inline bool SelectionEngine::ShouldDeselect( bool bModifierKey1 ) const
  30 {
  31     return eSelMode != SelectionMode::Multiple || !bModifierKey1;
  32 }
  33
  34 // TODO: throw out FunctionSet::SelectAtPoint
  35
  36 SelectionEngine::SelectionEngine( vcl::Window* pWindow, FunctionSet* pFuncSet ) :
  37     pWin( pWindow ),
  38     nUpdateInterval( SELENG_AUTOREPEAT_INTERVAL )
  39 {
  40     eSelMode = SelectionMode::Single;
  41     pFunctionSet = pFuncSet;
  42     nFlags = SelectionEngineFlags::EXPANDONMOVE;
  43     nLockedMods = 0;
  44
  45     aWTimer.SetTimeoutHdl( LINK( this, SelectionEngine, ImpWatchDog ) );
  46     aWTimer.SetTimeout( nUpdateInterval );
  47     aWTimer.SetDebugName( "vcl::SelectionEngine aWTimer" );
  48 }
  49
  50 SelectionEngine::~SelectionEngine()
  51 {
  52     aWTimer.Stop();
  53 }
  54
  55 IMPL_LINK_NOARG(SelectionEngine, ImpWatchDog, Timer *, void)
  56 {
  57     if ( !aArea.IsInside( aLastMove.GetPosPixel() ) )
  58         SelMouseMove( aLastMove );
  59 }
  60
  61 void SelectionEngine::SetSelectionMode( SelectionMode eMode )
  62 {
  63     eSelMode = eMode;
  64 }
  65
  66 void SelectionEngine::CursorPosChanging( bool bShift, bool bMod1 )
  67 {
  68     if ( !pFunctionSet )
  69         return;
  70
  71     if ( bShift && eSelMode != SelectionMode::Single )
  72     {
  73         if ( IsAddMode() )
  74         {
  75             if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
  76             {
  77                 pFunctionSet->CreateAnchor();
  78                 nFlags |= SelectionEngineFlags::HAS_ANCH;
  79             }
  80         }
  81         else
  82         {
  83             if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
  84             {
  85                 if( ShouldDeselect( bMod1 ) )
  86                     pFunctionSet->DeselectAll();
  87                 pFunctionSet->CreateAnchor();
  88                 nFlags |= SelectionEngineFlags::HAS_ANCH;
  89             }
  90         }
  91     }
  92     else
  93     {
  94         if ( IsAddMode() )
  95         {
  96             if ( nFlags & SelectionEngineFlags::HAS_ANCH )
  97             {
  98                 // pFunctionSet->CreateCursor();
  99                 pFunctionSet->DestroyAnchor();
 100                 nFlags &= (~SelectionEngineFlags::HAS_ANCH);
 101             }
 102         }
 103         else
 104         {
 105             if( ShouldDeselect( bMod1 ) )
 106                 pFunctionSet->DeselectAll();
 107             else
 108                 pFunctionSet->DestroyAnchor();
 109             nFlags &= (~SelectionEngineFlags::HAS_ANCH);
 110         }
 111     }
 112 }
 113
 114 bool SelectionEngine::SelMouseButtonDown( const MouseEvent& rMEvt )
 115 {
 116     nFlags &= (~SelectionEngineFlags::CMDEVT);
 117     if ( !pFunctionSet || !pWin || rMEvt.GetClicks() > 1 || rMEvt.IsRight() )
 118         return false;
 119
 120     sal_uInt16 nModifier = rMEvt.GetModifier() | nLockedMods;
 121     if ( nModifier & KEY_MOD2 )
 122         return false;
 123     // in SingleSelection: filter Control-Key,
 124     // so that a D&D can be also started with a Ctrl-Click
 125     if ( nModifier == KEY_MOD1 && eSelMode == SelectionMode::Single )
 126         nModifier = 0;
 127
 128     Point aPos = rMEvt.GetPosPixel();
 129     aLastMove = rMEvt;
 130
 131     if( !rMEvt.IsRight() )
 132     {
 133         pWin->CaptureMouse();
 134         nFlags |= SelectionEngineFlags::IN_SEL;
 135     }
 136     else
 137     {
 138         nModifier = 0;
 139     }
 140
 141     switch ( nModifier )
 142     {
 143         case 0:     // KEY_NO_KEY
 144         {
 145             bool bSelAtPoint = pFunctionSet->IsSelectionAtPoint( aPos );
 146             nFlags &= (~SelectionEngineFlags::IN_ADD);
 147             if ( (nFlags & SelectionEngineFlags::DRG_ENAB) && bSelAtPoint )
 148             {
 149                 nFlags |= SelectionEngineFlags::WAIT_UPEVT;
 150                 nFlags &= ~(SelectionEngineFlags::IN_SEL);
 151                 pWin->ReleaseMouse();
 152                 return true;  // wait for STARTDRAG-Command-Event
 153             }
 154             if ( eSelMode != SelectionMode::Single )
 155             {
 156                 if( !IsAddMode() )
 157                     pFunctionSet->DeselectAll();
 158                 else
 159                     pFunctionSet->DestroyAnchor();
 160                    nFlags &= (~SelectionEngineFlags::HAS_ANCH); // bHasAnchor = false;
 161             }
 162             pFunctionSet->SetCursorAtPoint( aPos );
 163             // special case Single-Selection, to enable simple Select+Drag
 164             if (eSelMode == SelectionMode::Single && (nFlags & SelectionEngineFlags::DRG_ENAB))
 165                 nFlags |= SelectionEngineFlags::WAIT_UPEVT;
 166             return true;
 167         }
 168
 169         case KEY_SHIFT:
 170             if ( eSelMode == SelectionMode::Single )
 171             {
 172                 pWin->ReleaseMouse();
 173                 nFlags &= (~SelectionEngineFlags::IN_SEL);
 174                 return false;
 175             }
 176             if ( nFlags & SelectionEngineFlags::ADD_ALW )
 177                 nFlags |= SelectionEngineFlags::IN_ADD;
 178             else
 179                 nFlags &= (~SelectionEngineFlags::IN_ADD);
 180
 181             if( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
 182             {
 183                 if ( !(nFlags & SelectionEngineFlags::IN_ADD) )
 184                     pFunctionSet->DeselectAll();
 185                 pFunctionSet->CreateAnchor();
 186                 nFlags |= SelectionEngineFlags::HAS_ANCH;
 187             }
 188             pFunctionSet->SetCursorAtPoint( aPos );
 189             return true;
 190
 191         case KEY_MOD1:
 192             // allow Control only for Multi-Select
 193             if ( eSelMode != SelectionMode::Multiple )
 194             {
 195                 nFlags &= (~SelectionEngineFlags::IN_SEL);
 196                 pWin->ReleaseMouse();
 197                 return true;  // skip Mouse-Click
 198             }
 199             if ( nFlags & SelectionEngineFlags::HAS_ANCH )
 200             {
 201                 // pFunctionSet->CreateCursor();
 202                 pFunctionSet->DestroyAnchor();
 203                 nFlags &= (~SelectionEngineFlags::HAS_ANCH);
 204             }
 205             if ( pFunctionSet->IsSelectionAtPoint( aPos ) )
 206             {
 207                 pFunctionSet->DeselectAtPoint( aPos );
 208                 pFunctionSet->SetCursorAtPoint( aPos, true );
 209             }
 210             else
 211             {
 212                 pFunctionSet->SetCursorAtPoint( aPos );
 213             }
 214             return true;
 215
 216         case KEY_SHIFT + KEY_MOD1:
 217             if ( eSelMode != SelectionMode::Multiple )
 218             {
 219                 pWin->ReleaseMouse();
 220                 nFlags &= (~SelectionEngineFlags::IN_SEL);
 221                 return false;
 222             }
 223             nFlags |= SelectionEngineFlags::IN_ADD; //bIsInAddMode = true;
 224             if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
 225             {
 226                 pFunctionSet->CreateAnchor();
 227                 nFlags |= SelectionEngineFlags::HAS_ANCH;
 228             }
 229             pFunctionSet->SetCursorAtPoint( aPos );
 230             return true;
 231     }
 232
 233     return false;
 234 }
 235
 236 bool SelectionEngine::SelMouseButtonUp( const MouseEvent& rMEvt )
 237 {
 238     aWTimer.Stop();
 239     if( !pFunctionSet || !pWin )
 240     {
 241         const SelectionEngineFlags nMask = (SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT | SelectionEngineFlags::IN_SEL);
 242         nFlags &= ~nMask;
 243         return false;
 244     }
 245
 246     if( !rMEvt.IsRight() )
 247     {
 248        ReleaseMouse();
 249     }
 250
 251     if( (nFlags & SelectionEngineFlags::WAIT_UPEVT) && !(nFlags & SelectionEngineFlags::CMDEVT) &&
 252         eSelMode != SelectionMode::Single)
 253     {
 254         // MouseButtonDown in Sel but no CommandEvent yet
 255         // ==> deselektieren
 256         sal_uInt16 nModifier = aLastMove.GetModifier() | nLockedMods;
 257         if( nModifier == KEY_MOD1 || IsAlwaysAdding() )
 258         {
 259             if( !(nModifier & KEY_SHIFT) )
 260             {
 261                 pFunctionSet->DestroyAnchor();
 262                 nFlags &= (~SelectionEngineFlags::HAS_ANCH); // uncheck anchor
 263             }
 264             pFunctionSet->DeselectAtPoint( aLastMove.GetPosPixel() );
 265             nFlags &= (~SelectionEngineFlags::HAS_ANCH); // uncheck anchor
 266             pFunctionSet->SetCursorAtPoint( aLastMove.GetPosPixel(), true );
 267         }
 268         else
 269         {
 270             pFunctionSet->DeselectAll();
 271             nFlags &= (~SelectionEngineFlags::HAS_ANCH); // uncheck anchor
 272             pFunctionSet->SetCursorAtPoint( aLastMove.GetPosPixel() );
 273         }
 274     }
 275
 276     const SelectionEngineFlags nMask = (SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT | SelectionEngineFlags::IN_SEL);
 277     nFlags &= ~nMask;
 278     return true;
 279 }
 280
 281 void SelectionEngine::ReleaseMouse()
 282 {
 283     if (!pWin || !pWin->IsMouseCaptured())
 284         return;
 285     pWin->ReleaseMouse();
 286 }
 287
 288 bool SelectionEngine::SelMouseMove( const MouseEvent& rMEvt )
 289 {
 290
 291     if ( !pFunctionSet || !(nFlags & SelectionEngineFlags::IN_SEL) ||
 292          (nFlags & (SelectionEngineFlags::CMDEVT | SelectionEngineFlags::WAIT_UPEVT)) )
 293         return false;
 294
 295     if( !(nFlags & SelectionEngineFlags::EXPANDONMOVE) )
 296         return false; // wait for DragEvent!
 297
 298     aLastMove = rMEvt;
 299     // if the mouse is outside the area, the frequency of
 300     // SetCursorAtPoint() is only set by the Timer
 301     if( aWTimer.IsActive() && !aArea.IsInside( rMEvt.GetPosPixel() ))
 302         return true;
 303
 304     aWTimer.SetTimeout( nUpdateInterval );
 305     if (!comphelper::LibreOfficeKit::isActive())
 306         // Generating fake mouse moves does not work with LOK.
 307         aWTimer.Start();
 308     if ( eSelMode != SelectionMode::Single )
 309     {
 310         if ( !(nFlags & SelectionEngineFlags::HAS_ANCH) )
 311         {
 312             pFunctionSet->CreateAnchor();
 313             nFlags |= SelectionEngineFlags::HAS_ANCH;
 314         }
 315     }
 316
 317     pFunctionSet->SetCursorAtPoint( rMEvt.GetPosPixel() );
 318
 319     return true;
 320 }
 321
 322 void SelectionEngine::SetWindow( vcl::Window* pNewWin )
 323 {
 324     if( pNewWin != pWin )
 325     {
 326         if ( pWin && (nFlags & SelectionEngineFlags::IN_SEL) )
 327             pWin->ReleaseMouse();
 328         pWin = pNewWin;
 329         if ( pWin && ( nFlags & SelectionEngineFlags::IN_SEL ) )
 330             pWin->CaptureMouse();
 331     }
 332 }
 333
 334 void SelectionEngine::Reset()
 335 {
 336     aWTimer.Stop();
 337     if ( nFlags & SelectionEngineFlags::IN_SEL )
 338         pWin->ReleaseMouse();
 339     SelectionEngineFlags nMask = (SelectionEngineFlags::HAS_ANCH | SelectionEngineFlags::IN_SEL);
 340     nFlags &= ~nMask;
 341     nLockedMods = 0;
 342 }
 343
 344 void SelectionEngine::Command( const CommandEvent& rCEvt )
 345 {
 346     // Timer aWTimer is active during enlarging a selection
 347     if ( !pFunctionSet || !pWin || aWTimer.IsActive() )
 348         return;
 349     aWTimer.Stop();
 350     nFlags |= SelectionEngineFlags::CMDEVT;
 351     if ( rCEvt.GetCommand() == CommandEventId::StartDrag )
 352     {
 353         if ( nFlags & SelectionEngineFlags::DRG_ENAB )
 354         {
 355             SAL_WARN_IF( !rCEvt.IsMouseEvent(), "vcl", "STARTDRAG: Not a MouseEvent" );
 356             if ( pFunctionSet->IsSelectionAtPoint( rCEvt.GetMousePosPixel() ) )
 357             {
 358                 aLastMove = MouseEvent( rCEvt.GetMousePosPixel(),
 359                                aLastMove.GetClicks(), aLastMove.GetMode(),
 360                                aLastMove.GetButtons(), aLastMove.GetModifier() );
 361                 pFunctionSet->BeginDrag();
 362                 const SelectionEngineFlags nMask = (SelectionEngineFlags::CMDEVT|SelectionEngineFlags::WAIT_UPEVT|SelectionEngineFlags::IN_SEL);
 363                 nFlags &= ~nMask;
 364             }
 365             else
 366                 nFlags &= ~SelectionEngineFlags::CMDEVT;
 367         }
 368         else
 369             nFlags &= ~SelectionEngineFlags::CMDEVT;
 370     }
 371 }
 372
 373 void SelectionEngine::SetUpdateInterval( sal_uLong nInterval )
 374 {
 375     if (nInterval < SELENG_AUTOREPEAT_INTERVAL_MIN)
 376         // Set a lower threshold.  On Windows, setting this value too low
 377         // would cause selection to get updated indefinitely.
 378         nInterval = SELENG_AUTOREPEAT_INTERVAL_MIN;
 379
 380     if (nUpdateInterval == nInterval)
 381         // no update needed.
 382         return;
 383
 384     if (aWTimer.IsActive())
 385     {
 386         // reset the timer right away on interval change.
 387         aWTimer.Stop();
 388         aWTimer.SetTimeout(nInterval);
 389         aWTimer.Start();
 390     }
 391     else
 392         aWTimer.SetTimeout(nInterval);
 393
 394     nUpdateInterval = nInterval;
 395 }
 396
 397 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */