KiCad PCB EDA Suite
wx_view_controls.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
5  * Copyright (C) 2013-2015 CERN
6  * Copyright (C) 2012-2016 KiCad Developers, see AUTHORS.txt for contributors.
7  *
8  * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
9  * @author Maciej Suminski <maciej.suminski@cern.ch>
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, you may find one here:
23  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
24  * or you may search the http://www.gnu.org website for the version 2 license,
25  * or you may write to the Free Software Foundation, Inc.,
26  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
27  */
28 
29 #include <view/view.h>
30 #include <view/wx_view_controls.h>
31 #include <view/zoom_controller.h>
33 #include <tool/tool_dispatcher.h>
34 
35 using namespace KIGFX;
36 
37 const wxEventType WX_VIEW_CONTROLS::EVT_REFRESH_MOUSE = wxNewEventType();
38 
39 
40 static std::unique_ptr<ZOOM_CONTROLLER> GetZoomControllerForPlatform()
41 {
42 #ifdef __WXMAC__
43  // On Apple pointer devices, wheel events occur frequently and with
44  // smaller rotation values. For those devices, let's handle zoom
45  // based on the rotation amount rather than the time difference.
46  return std::make_unique<CONSTANT_ZOOM_CONTROLLER>( CONSTANT_ZOOM_CONTROLLER::MAC_SCALE );
47 #elif __WXGTK3__
48  // GTK3 is similar, but the scale constant is smaller
49  return std::make_unique<CONSTANT_ZOOM_CONTROLLER>( CONSTANT_ZOOM_CONTROLLER::GTK3_SCALE );
50 #else
51  return std::make_unique<ACCELERATING_ZOOM_CONTROLLER>();
52 #endif
53 }
54 
55 
56 WX_VIEW_CONTROLS::WX_VIEW_CONTROLS( VIEW* aView, wxScrolledCanvas* aParentPanel ) :
57  VIEW_CONTROLS( aView ), m_state( IDLE ), m_parentPanel( aParentPanel ),
58  m_scrollScale( 1.0, 1.0 ), m_lastTimestamp( 0 ), m_cursorPos( 0, 0 ), m_updateCursor( true )
59 {
60  m_parentPanel->Connect( wxEVT_MOTION,
61  wxMouseEventHandler( WX_VIEW_CONTROLS::onMotion ), NULL, this );
62 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
63  m_parentPanel->Connect( wxEVT_MAGNIFY,
64  wxMouseEventHandler( WX_VIEW_CONTROLS::onMagnify ), NULL, this );
65 #endif
66  m_parentPanel->Connect( wxEVT_MOUSEWHEEL,
67  wxMouseEventHandler( WX_VIEW_CONTROLS::onWheel ), NULL, this );
68  m_parentPanel->Connect( wxEVT_MIDDLE_UP,
69  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
70  m_parentPanel->Connect( wxEVT_MIDDLE_DOWN,
71  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
72  m_parentPanel->Connect( wxEVT_LEFT_UP,
73  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
74  m_parentPanel->Connect( wxEVT_LEFT_DOWN,
75  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
76  m_parentPanel->Connect( wxEVT_RIGHT_UP,
77  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
78  m_parentPanel->Connect( wxEVT_RIGHT_DOWN,
79  wxMouseEventHandler( WX_VIEW_CONTROLS::onButton ), NULL, this );
80 #if defined _WIN32 || defined _WIN64
81  m_parentPanel->Connect( wxEVT_ENTER_WINDOW,
82  wxMouseEventHandler( WX_VIEW_CONTROLS::onEnter ), NULL, this );
83 #endif
84  m_parentPanel->Connect( wxEVT_LEAVE_WINDOW,
85  wxMouseEventHandler( WX_VIEW_CONTROLS::onLeave ), NULL, this );
86  m_parentPanel->Connect( wxEVT_SCROLLWIN_THUMBTRACK,
87  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
88  m_parentPanel->Connect( wxEVT_SCROLLWIN_PAGEUP,
89  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
90  m_parentPanel->Connect( wxEVT_SCROLLWIN_PAGEDOWN,
91  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
92 
93  m_parentPanel->Connect( wxEVT_SCROLLWIN_BOTTOM,
94  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
95  m_parentPanel->Connect( wxEVT_SCROLLWIN_TOP,
96  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
97  m_parentPanel->Connect( wxEVT_SCROLLWIN_LINEUP,
98  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
99  m_parentPanel->Connect( wxEVT_SCROLLWIN_LINEDOWN,
100  wxScrollWinEventHandler( WX_VIEW_CONTROLS::onScroll ), NULL, this );
101 
103 
104  m_cursorWarped = false;
105 
106  m_panTimer.SetOwner( this );
107  this->Connect( wxEVT_TIMER,
108  wxTimerEventHandler( WX_VIEW_CONTROLS::onTimer ), NULL, this );
109 
111 }
112 
113 
115 {
116 }
117 
118 
119 void WX_VIEW_CONTROLS::onMotion( wxMouseEvent& aEvent )
120 {
121  bool isAutoPanning = false;
122  VECTOR2D mousePos( aEvent.GetX(), aEvent.GetY() );
123 
125  isAutoPanning = handleAutoPanning( aEvent );
126 
127  if( !isAutoPanning && aEvent.Dragging() )
128  {
129  if( m_state == DRAG_PANNING )
130  {
131  VECTOR2D d = m_dragStartPoint - mousePos;
132  VECTOR2D delta = m_view->ToWorld( d, false );
133 
135  aEvent.StopPropagation();
136  }
137  }
138 
139  if( m_updateCursor ) // do not update the cursor position if it was explicitly set
140  m_cursorPos = m_view->ToWorld( mousePos );
141  else
142  m_updateCursor = true;
143 
144  aEvent.Skip();
145 }
146 
147 
148 void WX_VIEW_CONTROLS::onWheel( wxMouseEvent& aEvent )
149 {
150 #ifdef __WXGTK3__
151  if( aEvent.GetTimestamp() == m_lastTimestamp )
152  {
153  aEvent.Skip( false );
154  return;
155  }
156 
157  m_lastTimestamp = aEvent.GetTimestamp();
158 #endif
159 
160  const double wheelPanSpeed = 0.001;
161  const int axis = aEvent.GetWheelAxis();
162 
163  // mousewheelpan disabled:
164  // wheel + ctrl -> horizontal scrolling;
165  // wheel + shift -> vertical scrolling;
166  // wheel -> zooming;
167  // mousewheelpan enabled:
168  // wheel -> pan;
169  // wheel + ctrl -> zooming;
170  // wheel + shift -> horizontal scrolling.
171 
172  if( ( !m_settings.m_enableMousewheelPan && ( aEvent.ControlDown() || aEvent.ShiftDown() ) ) ||
173  ( m_settings.m_enableMousewheelPan && !aEvent.ControlDown() ) )
174  {
175  // Scrolling
176  VECTOR2D scrollVec = m_view->ToWorld( m_view->GetScreenPixelSize(), false ) *
177  ( (double) aEvent.GetWheelRotation() * wheelPanSpeed );
178  double scrollX = 0.0;
179  double scrollY = 0.0;
180 
182  {
183  if ( axis == wxMOUSE_WHEEL_HORIZONTAL || aEvent.ShiftDown() )
184  scrollX = scrollVec.x;
185  else
186  scrollY = -scrollVec.y;
187  }
188  else
189  {
190  if( aEvent.ControlDown() )
191  scrollX = -scrollVec.x;
192  else
193  scrollY = -scrollVec.y;
194  }
195 
196  VECTOR2D delta( scrollX, scrollY );
197 
199  refreshMouse();
200  }
201  else
202  {
203  // Restrict zoom handling to the vertical axis, otherwise horizontal
204  // scrolling events (e.g. touchpads and some mice) end up interpreted
205  // as vertical scroll events and confuse the user.
206  if( axis == wxMOUSE_WHEEL_VERTICAL )
207  {
208  const int rotation = aEvent.GetWheelRotation();
209  const double zoomScale = m_zoomController->GetScaleForRotation( rotation );
210 
211  if( IsCursorWarpingEnabled() )
212  {
213  CenterOnCursor();
214  m_view->SetScale( m_view->GetScale() * zoomScale );
215  }
216  else
217  {
218  const VECTOR2D anchor = m_view->ToWorld( VECTOR2D( aEvent.GetX(), aEvent.GetY() ) );
219  m_view->SetScale( m_view->GetScale() * zoomScale, anchor );
220  }
221  }
222  }
223 
224  // Do not skip this event, otherwise wxWidgets will fire
225  // 3 wxEVT_SCROLLWIN_LINEUP or wxEVT_SCROLLWIN_LINEDOWN (normal wxWidgets behavior)
226  // and we do not want that.
227  m_parentPanel->Refresh();
228 }
229 
230 
231 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
232 void WX_VIEW_CONTROLS::onMagnify( wxMouseEvent& aEvent )
233 {
234  // Scale based on the magnification from our underlying magnification event.
235  VECTOR2D anchor = m_view->ToWorld( VECTOR2D( aEvent.GetX(), aEvent.GetY() ) );
236  m_view->SetScale( m_view->GetScale() * ( aEvent.GetMagnification() + 1.0f ), anchor );
237 
238  aEvent.Skip();
239 }
240 #endif
241 
242 
243 void WX_VIEW_CONTROLS::onButton( wxMouseEvent& aEvent )
244 {
245  switch( m_state )
246  {
247  case IDLE:
248  case AUTO_PANNING:
249  if( aEvent.MiddleDown() ||
250  ( aEvent.LeftDown() && m_settings.m_panWithLeftButton ) ||
251  ( aEvent.RightDown() && m_settings.m_panWithRightButton ) )
252  {
253  m_dragStartPoint = VECTOR2D( aEvent.GetX(), aEvent.GetY() );
256  }
257 
258  if( aEvent.LeftUp() )
259  m_state = IDLE; // Stop autopanning when user release left mouse button
260 
261  break;
262 
263  case DRAG_PANNING:
264  if( aEvent.MiddleUp() || aEvent.LeftUp() || aEvent.RightUp() )
265  m_state = IDLE;
266 
267  break;
268  }
269 
270  aEvent.Skip();
271 }
272 
273 
274 void WX_VIEW_CONTROLS::onEnter( wxMouseEvent& aEvent )
275 {
276  m_parentPanel->SetFocus();
277 }
278 
279 
280 void WX_VIEW_CONTROLS::onLeave( wxMouseEvent& aEvent )
281 {
283  {
284  bool warp = false;
285  int x = aEvent.GetX();
286  int y = aEvent.GetY();
287  wxSize parentSize = m_parentPanel->GetClientSize();
288 
289  if( x < 0 )
290  {
291  x = 0;
292  warp = true;
293  }
294  else if( x >= parentSize.x )
295  {
296  x = parentSize.x - 1;
297  warp = true;
298  }
299 
300  if( y < 0 )
301  {
302  y = 0;
303  warp = true;
304  }
305  else if( y >= parentSize.y )
306  {
307  y = parentSize.y - 1;
308  warp = true;
309  }
310 
311  if( warp )
312  m_parentPanel->WarpPointer( x, y );
313  }
314 }
315 
316 
317 void WX_VIEW_CONTROLS::onTimer( wxTimerEvent& aEvent )
318 {
319  switch( m_state )
320  {
321  case AUTO_PANNING:
322  {
324  {
325  m_state = IDLE;
326  return;
327  }
328 
329 #if wxCHECK_VERSION( 3, 0, 0 )
330  if( !m_parentPanel->HasFocus() )
331  break;
332 #endif
333 
334  double borderSize = std::min( m_settings.m_autoPanMargin * m_view->GetScreenPixelSize().x,
336 
337  VECTOR2D dir( m_panDirection );
338 
339  if( dir.EuclideanNorm() > borderSize )
340  dir = dir.Resize( borderSize );
341 
342  dir = m_view->ToWorld( dir, false );
344 
345  refreshMouse();
346  }
347  break;
348 
349  case IDLE: // Just remove unnecessary warnings
350  case DRAG_PANNING:
351  break;
352  }
353 }
354 
355 
356 void WX_VIEW_CONTROLS::onScroll( wxScrollWinEvent& aEvent )
357 {
358  const double linePanDelta = 0.05;
359  const double pagePanDelta = 0.5;
360 
361  int type = aEvent.GetEventType();
362  int dir = aEvent.GetOrientation();
363 
364  if( type == wxEVT_SCROLLWIN_THUMBTRACK )
365  {
366  auto center = m_view->GetCenter();
367  const auto& boundary = m_view->GetBoundary();
368 
369  // Flip scroll direction in flipped view
370  const double xstart = ( m_view->IsMirroredX() ?
371  boundary.GetRight() : boundary.GetLeft() );
372  const double xdelta = ( m_view->IsMirroredX() ? -1 : 1 );
373 
374  if( dir == wxHORIZONTAL )
375  center.x = xstart + xdelta * ( aEvent.GetPosition() / m_scrollScale.x );
376  else
377  center.y = boundary.GetTop() + aEvent.GetPosition() / m_scrollScale.y;
378 
379  m_view->SetCenter( center );
380  }
381  else
382  {
383  double dist = 0;
384 
385  if( type == wxEVT_SCROLLWIN_PAGEUP )
386  dist = pagePanDelta;
387  else if( type == wxEVT_SCROLLWIN_PAGEDOWN )
388  dist = -pagePanDelta;
389  else if( type == wxEVT_SCROLLWIN_LINEUP )
390  dist = linePanDelta;
391  else if( type == wxEVT_SCROLLWIN_LINEDOWN )
392  dist = -linePanDelta;
393  else
394  {
395  wxASSERT( "Unhandled event type" );
396  return;
397  }
398 
399  VECTOR2D scroll = m_view->ToWorld( m_view->GetScreenPixelSize(), false ) * dist;
400 
401  double scrollX = 0.0;
402  double scrollY = 0.0;
403 
404  if ( dir == wxHORIZONTAL )
405  scrollX = -scroll.x;
406  else
407  scrollY = -scroll.y;
408 
409  VECTOR2D delta( scrollX, scrollY );
410 
412  }
413 
414  m_parentPanel->Refresh();
415 }
416 
417 
418 void WX_VIEW_CONTROLS::SetGrabMouse( bool aEnabled )
419 {
420  if( aEnabled && !m_settings.m_grabMouse )
421  m_parentPanel->CaptureMouse();
422  else if( !aEnabled && m_settings.m_grabMouse )
423  m_parentPanel->ReleaseMouse();
424 
425  VIEW_CONTROLS::SetGrabMouse( aEnabled );
426 }
427 
428 
429 VECTOR2D WX_VIEW_CONTROLS::GetMousePosition( bool aWorldCoordinates ) const
430 {
431  wxPoint msp = getMouseScreenPosition();
432  VECTOR2D screenPos( msp.x, msp.y );
433 
434  return aWorldCoordinates ? m_view->ToWorld( screenPos ) : screenPos;
435 }
436 
437 
439 {
440  if( aEnableSnapping )
441  {
442  return m_view->GetGAL()->GetGridPoint( m_cursorPos );
443  }
444  else
445  {
446  return m_cursorPos;
447  }
448 }
449 
450 
451 VECTOR2D WX_VIEW_CONTROLS::GetCursorPosition( bool aEnableSnapping ) const
452 {
454  {
456  }
457  else
458  {
459  return GetRawCursorPosition( aEnableSnapping );
460  }
461 }
462 
463 
464 void WX_VIEW_CONTROLS::SetCursorPosition( const VECTOR2D& aPosition, bool aWarpView,
465  bool aTriggeredByArrows )
466 {
467  m_updateCursor = false;
468 
469  if( aTriggeredByArrows )
470  {
473  m_cursorWarped = false;
474  }
475  else
476  {
478  m_cursorWarped = true;
479  }
480 
481  WarpCursor( aPosition, true, aWarpView );
482  m_cursorPos = aPosition;
483 }
484 
485 
486 void WX_VIEW_CONTROLS::SetCrossHairCursorPosition( const VECTOR2D& aPosition, bool aWarpView = true )
487 {
488  m_updateCursor = false;
489 
490  const VECTOR2I& screenSize = m_view->GetGAL()->GetScreenPixelSize();
491  BOX2I screen( VECTOR2I( 0, 0 ), screenSize );
492  VECTOR2D screenPos = m_view->ToScreen( aPosition );
493 
494  if( aWarpView && !screen.Contains( screenPos ) )
495  m_view->SetCenter( aPosition );
496 
497  m_cursorPos = aPosition;
498 }
499 
500 
501 void WX_VIEW_CONTROLS::WarpCursor( const VECTOR2D& aPosition, bool aWorldCoordinates,
502  bool aWarpView )
503 {
504  if( aWorldCoordinates )
505  {
506  const VECTOR2I& screenSize = m_view->GetGAL()->GetScreenPixelSize();
507  BOX2I screen( VECTOR2I( 0, 0 ), screenSize );
508  VECTOR2D screenPos = m_view->ToScreen( aPosition );
509 
510  if( !screen.Contains( screenPos ) )
511  {
512  if( aWarpView )
513  {
514  m_view->SetCenter( aPosition );
515  m_parentPanel->WarpPointer( screenSize.x / 2, screenSize.y / 2 );
516  }
517  }
518  else
519  {
520  m_parentPanel->WarpPointer( screenPos.x, screenPos.y );
521  }
522  }
523  else
524  {
525  m_parentPanel->WarpPointer( aPosition.x, aPosition.y );
526  }
527 
528  refreshMouse();
529 }
530 
531 
533 {
534  const VECTOR2I& screenSize = m_view->GetGAL()->GetScreenPixelSize();
535  VECTOR2I screenCenter( screenSize / 2 );
536 
537  if( GetMousePosition( false ) != screenCenter )
538  {
540  m_parentPanel->WarpPointer( KiROUND( screenSize.x / 2 ), KiROUND( screenSize.y / 2 ) );
541  }
542 }
543 
544 
545 bool WX_VIEW_CONTROLS::handleAutoPanning( const wxMouseEvent& aEvent )
546 {
547  VECTOR2I p( aEvent.GetX(), aEvent.GetY() );
549 
551  {
552  // last cursor move event came from keyboard cursor control. If auto-panning is enabled and
553  // the next position is inside the autopan zone, check if it really came from a mouse event, otherwise
554  // disable autopan temporarily. Also temporaly disable autopan if the cursor is in the autopan zone
555  // because the application warped the cursor.
556 
557  m_cursorWarped = false;
558  return true;
559  }
560 
561  m_cursorWarped = false;
562 
563  // Compute areas where autopanning is active
566  int borderEndX = m_view->GetScreenPixelSize().x - borderStart;
567  int borderEndY = m_view->GetScreenPixelSize().y - borderStart;
568 
569  if( p.x < borderStart )
570  m_panDirection.x = -( borderStart - p.x );
571  else if( p.x > borderEndX )
572  m_panDirection.x = ( p.x - borderEndX );
573  else
574  m_panDirection.x = 0;
575 
576  if( p.y < borderStart )
577  m_panDirection.y = -( borderStart - p.y );
578  else if( p.y > borderEndY )
579  m_panDirection.y = ( p.y - borderEndY );
580  else
581  m_panDirection.y = 0;
582 
583  bool borderHit = ( m_panDirection.x != 0 || m_panDirection.y != 0 );
584 
585  switch( m_state )
586  {
587  case AUTO_PANNING:
588  if( !borderHit )
589  {
590  m_panTimer.Stop();
591  m_state = IDLE;
592 
593  return false;
594  }
595 
596  return true;
597  break;
598 
599  case IDLE:
600  if( borderHit )
601  {
603  m_panTimer.Start( (int) ( 250.0 / 60.0 ) );
604 
605  return true;
606  }
607 
608  return false;
609  break;
610 
611  case DRAG_PANNING:
612  return false;
613  }
614 
615  wxASSERT_MSG( false, wxT( "This line should never be reached" ) );
616  return false; // Should not be reached, just avoid the compiler warnings..
617 }
618 
619 
621 {
622  // Notify tools that the cursor position has changed in the world coordinates
623  wxMouseEvent moveEvent( EVT_REFRESH_MOUSE );
624  wxPoint msp = getMouseScreenPosition();
625  moveEvent.SetX( msp.x );
626  moveEvent.SetY( msp.y );
627 
628  // Set the modifiers state
629 #if wxCHECK_VERSION( 3, 0, 0 )
630  moveEvent.SetControlDown( wxGetKeyState( WXK_CONTROL ) );
631  moveEvent.SetShiftDown( wxGetKeyState( WXK_SHIFT ) );
632  moveEvent.SetAltDown( wxGetKeyState( WXK_ALT ) );
633 #else
634  // wx <3.0 do not have accessors, but the fields are exposed
635  moveEvent.m_controlDown = wxGetKeyState( WXK_CONTROL );
636  moveEvent.m_shiftDown = wxGetKeyState( WXK_SHIFT );
637  moveEvent.m_altDown = wxGetKeyState( WXK_ALT );
638 #endif
639 
640  m_cursorPos = m_view->ToWorld( VECTOR2D( msp.x, msp.y ) );
641  wxPostEvent( m_parentPanel, moveEvent );
642 }
643 
644 
646 {
647  wxPoint msp = wxGetMousePosition();
648  m_parentPanel->ScreenToClient( &msp.x, &msp.y );
649  return msp;
650 }
651 
652 
654 {
655  const BOX2D viewport = m_view->GetViewport();
656  const BOX2D& boundary = m_view->GetBoundary();
657 
658  m_scrollScale.x = 2e3 / viewport.GetWidth(); // TODO it does not have to be updated so often
659  m_scrollScale.y = 2e3 / viewport.GetHeight();
660  VECTOR2I newScroll( ( viewport.Centre().x - boundary.GetLeft() ) * m_scrollScale.x,
661  ( viewport.Centre().y - boundary.GetTop() ) * m_scrollScale.y );
662 
663  // Flip scroll direction in flipped view
664  if( m_view->IsMirroredX() )
665  newScroll.x = ( boundary.GetRight() - viewport.Centre().x ) * m_scrollScale.x;
666 
667  // Adjust scrollbars only if it is needed. Otherwise there are cases when canvas is continuosly
668  // refreshed (Windows)
669  if( m_scrollPos != newScroll )
670  {
671  // Another example of wxWidgets being broken by design: scroll position is determined by the
672  // left (or top, if vertical) edge of the slider. Fortunately, slider size seems to be constant
673  // (at least for wxGTK and wxMSW), so we have to add its size to allow user to scroll the workspace
674  // till the end.
675 
676  m_parentPanel->SetScrollbars( 1, 1,
677 #if defined(__LINUX__)
678  m_scrollScale.x * boundary.GetWidth() + 1623, m_scrollScale.y * boundary.GetHeight() + 1623,
679 #elif defined(__WIN32__) || defined(__WIN64__)
680  m_scrollScale.x * boundary.GetWidth() + 1377, m_scrollScale.y * boundary.GetHeight() + 741,
681 #else
682  m_scrollScale.x * boundary.GetWidth(), m_scrollScale.y * boundary.GetHeight(),
683 #endif
684  newScroll.x, newScroll.y, false );
685 
686  m_scrollPos = newScroll;
687  }
688 }
689 
690 void WX_VIEW_CONTROLS::ForceCursorPosition( bool aEnabled, const VECTOR2D& aPosition )
691 {
693  m_settings.m_forcedPosition = aPosition;
694 }
bool m_enableMousewheelPan
Mousewheel (2-finger touchpad) panning
Definition: view_controls.h:88
VECTOR2D m_lookStartPoint
Stores information about the center of viewport when dragging has started.
BOX2D GetViewport() const
Function GetViewport() Returns the current viewport visible area rectangle.
Definition: view.cpp:538
float m_autoPanSpeed
How fast is panning when in auto mode
Definition: view_controls.h:82
static const int dist[10][10]
Definition: ar_matrix.cpp:320
Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
Definition: class_module.h:57
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:118
const BOX2D & GetBoundary() const
Function GetBoundary()
Definition: view.h:298
static std::unique_ptr< ZOOM_CONTROLLER > GetZoomControllerForPlatform()
static const wxEventType EVT_REFRESH_MOUSE
Event that forces mouse move event in the dispatcher (eg.
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates.
Definition: view.cpp:475
coord_type GetTop() const
Definition: box2.h:202
const VECTOR2D & GetCenter() const
Function GetCenter() Returns the center point of this VIEW (in world space coordinates)
Definition: view.h:339
wxPoint getMouseScreenPosition() const
Gets the cursor position in the screen coordinates.
bool m_grabMouse
Flag for grabbing the mouse cursor
Definition: view_controls.h:70
VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const override
Function GetMousePosition() Returns the current mouse pointer position.
std::unique_ptr< ZOOM_CONTROLLER > m_zoomController
a ZOOM_CONTROLLER that determines zoom steps. This is platform-specific.
void onButton(wxMouseEvent &aEvent)
long int m_lastTimestamp
Last event timestamp to remove duplicates.
VC_SETTINGS m_settings
Current VIEW_CONTROLS settings
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates)
Definition: view_controls.h:58
coord_type GetRight() const
Definition: box2.h:197
GAL * GetGAL() const
Function GetGAL() Returns the GAL this view is using to draw graphical primitives.
Definition: view.h:180
bool m_panWithRightButton
Allow panning with the right button in addition to middle
Definition: view_controls.h:91
VIEW * m_view
Pointer to controlled VIEW.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
void SetScale(double aScale)
Function SetScale() Sets the scaling factor.
Definition: view.h:250
VECTOR2D m_scrollScale
Ratio used for scaling world coordinates to scrollbar position.
static const int delta[8][2]
Definition: solve.cpp:112
WX_VIEW_CONTROLS class definition.
static constexpr double GTK3_SCALE
A suitable (magic) scale factor for GTK3 systems.
void UpdateScrollbars()
Adjusts the scrollbars position to match the current viewport.
VECTOR2D GetGridPoint(const VECTOR2D &aPoint) const
Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world...
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
VECTOR2D m_lastKeyboardCursorPosition
Position of the above event
VECTOR2D GetRawCursorPosition(bool aSnappingEnabled=true) const override
Returns the current cursor position in world coordinates - ingoring the cursorUp position force mode.
bool m_autoPanSettingEnabled
Flag for turning on autopanning
Definition: view_controls.h:76
void onWheel(wxMouseEvent &aEvent)
Handler functions.
void SetCenter(const VECTOR2D &aCenter)
Function SetCenter() Sets the center point of the VIEW (i.e.
Definition: view.cpp:601
Panning with mouse button pressed.
bool m_forceCursorPosition
Is the forced cursor position enabled
Definition: view_controls.h:61
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
coord_type GetWidth() const
Definition: box2.h:195
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:149
void SetCrossHairCursorPosition(const VECTOR2D &aPosition, bool aWarpView) override
Moves the graphic crosshair cursor to the requested position expressed in world coordinates.
const VECTOR2I & GetScreenPixelSize() const
Function GetScreenPixelSize() Returns the size of the our rendering area, in pixels.
Definition: view.cpp:1176
bool IsCursorWarpingEnabled() const
Function IsCursorWarpingEnabled()
Class VIEW_CONTROLS is an interface for classes handling user events controlling the view behaviour (...
static constexpr double MAC_SCALE
A suitable (magic) scale factor for Mac systems.
float m_autoPanMargin
Distance from cursor to VIEW edge when panning is active
Definition: view_controls.h:79
void SetGrabMouse(bool aEnabled) override
Function SetGrabMouse() Enables/disables mouse cursor grabbing (limits the movement field only to the...
bool m_cursorWarped
Application warped the cursor, not the user (keyboard)
void refreshMouse()
Sends an event to refresh mouse position.
VECTOR2D ToScreen(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToScreen() Converts a world space point/vector to a point/vector in screen space coordinates...
Definition: view.cpp:494
bool m_autoPanEnabled
Flag for turning on autopanning
Definition: view_controls.h:73
void onMotion(wxMouseEvent &aEvent)
void WarpCursor(const VECTOR2D &aPosition, bool aWorldCoordinates=false, bool aWarpView=false) override
bool IsMirroredX() const
Function IsMirroredX() Returns true if view is flipped across the X axis.
Definition: view.h:230
void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0)) override
Function ForceCursorPosition() Places the cursor immediately at a given point.
wxScrolledCanvas * m_parentPanel
Panel that is affected by VIEW_CONTROLS.
void onTimer(wxTimerEvent &WXUNUSED(aEvent))
Vec Centre() const
Definition: box2.h:77
VECTOR2D m_panDirection
Current direction of panning (only autopanning mode)
bool m_updateCursor
Flag deciding whether the cursor position should be calculated using the mouse position.
bool m_lastKeyboardCursorPositionValid
Is last cursor motion event coming from keyboard arrow cursor motion action
Definition: view_controls.h:97
virtual void SetGrabMouse(bool aEnabled)
Function SetGrabMouse Turns on/off mouse grabbing.
VECTOR2I m_scrollPos
Current scrollbar position.
coord_type GetHeight() const
Definition: box2.h:196
WX_VIEW_CONTROLS(VIEW *aView, wxScrolledCanvas *aParentPanel)
bool handleAutoPanning(const wxMouseEvent &aEvent)
Function handleAutoPanning() Computes new viewport settings while in autopanning mode.
void onEnter(wxMouseEvent &WXUNUSED(aEvent))
VECTOR2D m_dragStartPoint
Stores information about point where dragging has started.
STATE m_state
Current state of VIEW_CONTROLS.
coord_type GetLeft() const
Definition: box2.h:201
Class VIEW.
Definition: view.h:61
double GetScale() const
Function GetScale()
Definition: view.h:268
void CenterOnCursor() const override
Function CenterOnCursor() Sets the viewport center to the current cursor position and warps the curso...
bool m_cursorCaptured
Should the cursor be locked within the parent window area
Definition: view_controls.h:64
void onScroll(wxScrollWinEvent &aEvent)
void SetCursorPosition(const VECTOR2D &aPosition, bool warpView, bool aTriggeredByArrows) override
Moves cursor to the requested position expressed in world coordinates.
VECTOR2D GetCursorPosition() const
Returns the current cursor position in world coordinates.
#define min(a, b)
Definition: auxiliary.h:85
void onLeave(wxMouseEvent &WXUNUSED(aEvent))
VECTOR2D m_cursorPos
Current cursor position (world coordinates)
wxTimer m_panTimer
Timer repsonsible for handling autopanning.
bool m_panWithLeftButton
Allow panning with the left button in addition to middle
Definition: view_controls.h:94