KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_move_tool.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) 2019 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <cmath>
26#include <memory>
27#include <optional>
28#include <wx/log.h>
29#include <trigo.h>
31#include <tool/tool_manager.h>
36#include <tools/sch_move_tool.h>
37
38#include <sch_actions.h>
39#include <sch_commit.h>
40#include <eda_item.h>
41#include <sch_group.h>
42#include <sch_item.h>
43#include <sch_symbol.h>
44#include <sch_sheet.h>
45#include <sch_sheet_pin.h>
46#include <sch_line.h>
47#include <sch_connection.h>
48#include <sch_junction.h>
49#include <junction_helpers.h>
50#include <sch_edit_frame.h>
51#include <eeschema_id.h>
52#include <pgm_base.h>
53#include <view/view_controls.h>
55#include <math/box2.h>
56#include <base_units.h>
57#include <sch_screen.h>
58#include <trace_helpers.h>
59
60
61// For adding to or removing from selections
62#define QUIET_MODE true
63
64
65static bool isGraphicItemForDrop( const SCH_ITEM* aItem )
66{
67 switch( aItem->Type() )
68 {
69 case SCH_SHAPE_T:
70 case SCH_BITMAP_T:
71 case SCH_TEXT_T:
72 case SCH_TEXTBOX_T:
73 return true;
74 case SCH_LINE_T:
75 return static_cast<const SCH_LINE*>( aItem )->IsGraphicLine();
76 default:
77 return false;
78 }
79}
80
81
82static void cloneWireConnection( SCH_LINE* aNewLine, SCH_ITEM* aSource, SCH_EDIT_FRAME* aFrame )
83{
84 if( !aNewLine || !aSource || !aFrame )
85 return;
86
87 SCH_LINE* sourceLine = dynamic_cast<SCH_LINE*>( aSource );
88
89 if( !sourceLine )
90 return;
91
92 SCH_SHEET_PATH sheetPath = aFrame->GetCurrentSheet();
93 SCH_CONNECTION* sourceConnection = sourceLine->Connection( &sheetPath );
94
95 if( !sourceConnection )
96 return;
97
98 SCH_CONNECTION* newConnection = aNewLine->InitializeConnection( sheetPath, nullptr );
99
100 if( !newConnection )
101 return;
102
103 newConnection->Clone( *sourceConnection );
104}
105
106
108 SCH_TOOL_BASE<SCH_EDIT_FRAME>( "eeschema.InteractiveMove" ),
109 m_inMoveTool( false ),
110 m_moveInProgress( false ),
111 m_mode( MOVE ),
112 m_moveOffset( 0, 0 )
113{
114}
115
116
118{
120
121 auto moveCondition =
122 []( const SELECTION& aSel )
123 {
124 if( aSel.Empty() || SELECTION_CONDITIONS::OnlyTypes( { SCH_MARKER_T } )( aSel ) )
125 return false;
126
128 return false;
129
130 return true;
131 };
132
133 // Add move actions to the selection tool menu
134 //
135 CONDITIONAL_MENU& selToolMenu = m_selectionTool->GetToolMenu().GetMenu();
136
137 selToolMenu.AddItem( SCH_ACTIONS::move, moveCondition, 150 );
138 selToolMenu.AddItem( SCH_ACTIONS::drag, moveCondition, 150 );
139 selToolMenu.AddItem( SCH_ACTIONS::alignToGrid, moveCondition, 150 );
140
141 return true;
142}
143
144
146{
147 SCH_TOOL_BASE::Reset( aReason );
148
149 if( aReason == MODEL_RELOAD || aReason == SUPERMODEL_RELOAD )
150 {
151 // If we were in the middle of a move/drag operation and the model changes (e.g., sheet
152 // switch), we need to clean up our state to avoid blocking future move/drag operations
153 if( m_moveInProgress )
154 {
155 // Clear the move state
156 m_moveInProgress = false;
157 m_mode = MOVE;
158 m_moveOffset = VECTOR2I( 0, 0 );
159 m_anchorPos.reset();
160 m_breakPos.reset();
161
162 // Clear cached data that references items from the previous sheet
163 m_dragAdditions.clear();
164 m_lineConnectionCache.clear();
165 m_newDragLines.clear();
166 m_changedDragLines.clear();
167 m_specialCaseLabels.clear();
169 m_hiddenJunctions.clear();
170
171 // Clear any preview
172 if( m_view )
173 m_view->ClearPreview();
174 }
175 }
176}
177
178
179void SCH_MOVE_TOOL::orthoLineDrag( SCH_COMMIT* aCommit, SCH_LINE* line, const VECTOR2I& splitDelta,
180 int& xBendCount, int& yBendCount, const EE_GRID_HELPER& grid )
181{
182 // If the move is not the same angle as this move, then we need to do something special with
183 // the unselected end to maintain orthogonality. Either drag some connected line that is the
184 // same angle as the move or add two lines to make a 90 degree connection
185 if( !EDA_ANGLE( splitDelta ).IsParallelTo( line->Angle() ) || line->GetLength() == 0 )
186 {
187 VECTOR2I unselectedEnd = line->HasFlag( STARTPOINT ) ? line->GetEndPoint()
188 : line->GetStartPoint();
189 VECTOR2I selectedEnd = line->HasFlag( STARTPOINT ) ? line->GetStartPoint()
190 : line->GetEndPoint();
191
192 // Look for pre-existing lines we can drag with us instead of creating new ones
193 bool foundAttachment = false;
194 bool foundJunction = false;
195 bool foundPin = false;
196 SCH_LINE* foundLine = nullptr;
197
198 for( EDA_ITEM* cItem : m_lineConnectionCache[line] )
199 {
200 foundAttachment = true;
201
202 // If the move is the same angle as a connected line, we can shrink/extend that line
203 // endpoint
204 switch( cItem->Type() )
205 {
206 case SCH_LINE_T:
207 {
208 SCH_LINE* cLine = static_cast<SCH_LINE*>( cItem );
209
210 // A matching angle on a non-zero-length line means lengthen/shorten will work
211 if( EDA_ANGLE( splitDelta ).IsParallelTo( cLine->Angle() )
212 && cLine->GetLength() != 0 )
213 {
214 foundLine = cLine;
215 }
216
217 // Zero length lines are lines that this algorithm has shortened to 0 so they also
218 // work but we should prefer using a segment with length and angle matching when
219 // we can (otherwise the zero length line will draw overlapping segments on them)
220 if( !foundLine && cLine->GetLength() == 0 )
221 foundLine = cLine;
222
223 break;
224 }
225 case SCH_JUNCTION_T:
226 foundJunction = true;
227 break;
228
229 case SCH_PIN_T:
230 foundPin = true;
231 break;
232
233 case SCH_SHEET_T:
234 for( const auto& pair : m_specialCaseSheetPins )
235 {
236 if( pair.first->IsConnected( selectedEnd ) )
237 {
238 foundPin = true;
239 break;
240 }
241 }
242
243 break;
244
245 default:
246 break;
247 }
248 }
249
250 // Ok... what if our original line is length zero from moving in its direction, and the
251 // last added segment of the 90 bend we are connected to is zero from moving it in its
252 // direction after it was added?
253 //
254 // If we are moving in original direction, we should lengthen the original drag wire.
255 // Otherwise we should lengthen the new wire.
256 bool preferOriginalLine = false;
257
258 if( foundLine
259 && foundLine->GetLength() == 0
260 && line->GetLength() == 0
261 && EDA_ANGLE( splitDelta ).IsParallelTo( line->GetStoredAngle() ) )
262 {
263 preferOriginalLine = true;
264 }
265 // If we have found an attachment, but not a line, we want to check if it's a junction.
266 // These are special-cased and get a single line added instead of a 90-degree bend. Except
267 // when we're on a pin, because pins always need bends, and junctions are just added to
268 // pins for visual clarity.
269 else if( !foundLine && foundJunction && !foundPin )
270 {
271 // Create a new wire ending at the unselected end
272 foundLine = new SCH_LINE( unselectedEnd, line->GetLayer() );
273 foundLine->SetFlags( IS_NEW );
274 foundLine->SetLastResolvedState( line );
275 cloneWireConnection( foundLine, line, m_frame );
276 m_frame->AddToScreen( foundLine, m_frame->GetScreen() );
277 m_newDragLines.insert( foundLine );
278
279 // We just broke off of the existing items, so replace all of them with our new
280 // end connection.
282 m_lineConnectionCache[line].clear();
283 m_lineConnectionCache[line].emplace_back( foundLine );
284 }
285
286 // We want to drag our found line if it's in the same angle as the move or zero length,
287 // but if the original drag line is also zero and the same original angle we should extend
288 // that one first
289 if( foundLine && !preferOriginalLine )
290 {
291 // Move the connected line found oriented in the direction of our move.
292 //
293 // Make sure we grab the right endpoint, it's not always STARTPOINT since the user can
294 // draw a box of lines. We need to only move one though, and preferably the start point,
295 // in case we have a zero length line that we are extending (we want the foundLine
296 // start point to be attached to the unselected end of our drag line).
297 //
298 // Also, new lines are added already so they'll be in the undo list, skip adding them.
299
300 if( !foundLine->HasFlag( IS_CHANGED ) && !foundLine->HasFlag( IS_NEW ) )
301 {
302 aCommit->Modify( (SCH_ITEM*) foundLine, m_frame->GetScreen() );
303
304 if( !foundLine->IsSelected() )
305 m_changedDragLines.insert( foundLine );
306 }
307
308 if( foundLine->GetStartPoint() == unselectedEnd )
309 foundLine->MoveStart( splitDelta );
310 else if( foundLine->GetEndPoint() == unselectedEnd )
311 foundLine->MoveEnd( splitDelta );
312
313 updateItem( foundLine, true );
314
315 SCH_LINE* bendLine = nullptr;
316
317 if( m_lineConnectionCache.count( foundLine ) == 1
318 && m_lineConnectionCache[foundLine][0]->Type() == SCH_LINE_T )
319 {
320 bendLine = static_cast<SCH_LINE*>( m_lineConnectionCache[foundLine][0] );
321 }
322
323 // Remerge segments we've created if this is a segment that we've added whose only
324 // other connection is also an added segment
325 //
326 // bendLine is first added segment at the original attachment point, foundLine is the
327 // orthogonal line between bendLine and this line
328 if( foundLine->HasFlag( IS_NEW )
329 && foundLine->GetLength() == 0
330 && bendLine && bendLine->HasFlag( IS_NEW ) )
331 {
332 if( line->HasFlag( STARTPOINT ) )
333 line->SetEndPoint( bendLine->GetEndPoint() );
334 else
335 line->SetStartPoint( bendLine->GetEndPoint() );
336
337 // Update our cache of the connected items.
338
339 // Re-attach drag labels from lines being deleted to the surviving line.
340 // This prevents dangling pointers when bendLine/foundLine are deleted below.
341 for( auto& [label, info] : m_specialCaseLabels )
342 {
343 if( info.attachedLine == bendLine || info.attachedLine == foundLine )
344 info.attachedLine = line;
345 }
346
348 m_lineConnectionCache[bendLine].clear();
349 m_lineConnectionCache[foundLine].clear();
350
351 m_frame->RemoveFromScreen( bendLine, m_frame->GetScreen() );
352 m_frame->RemoveFromScreen( foundLine, m_frame->GetScreen() );
353
354 m_newDragLines.erase( bendLine );
355 m_newDragLines.erase( foundLine );
356
357 delete bendLine;
358 delete foundLine;
359 }
360 //Ok, move the unselected end of our item
361 else
362 {
363 if( line->HasFlag( STARTPOINT ) )
364 line->MoveEnd( splitDelta );
365 else
366 line->MoveStart( splitDelta );
367 }
368
369 updateItem( line, true );
370 }
371 else if( line->GetLength() == 0 )
372 {
373 // We didn't find another line to shorten/lengthen, (or we did but it's also zero)
374 // so now is a good time to use our existing zero-length original line
375 }
376 // Either no line was at the "right" angle, or this was a junction, pin, sheet, etc. We
377 // need to add segments to keep the soon-to-move unselected end connected to these items.
378 //
379 // To keep our drag selections all the same, we'll move our unselected end point and then
380 // put wires between it and its original endpoint.
381 else if( foundAttachment && line->IsOrthogonal() )
382 {
383 VECTOR2D lineGrid = grid.GetGridSize( grid.GetItemGrid( line ) );
384
385 // The bend counter handles a group of wires all needing their offset one grid movement
386 // further out from each other to not overlap. The absolute value stuff finds the
387 // direction of the line and hence the the bend increment on that axis
388 unsigned int xMoveBit = splitDelta.x != 0;
389 unsigned int yMoveBit = splitDelta.y != 0;
390 int xLength = abs( unselectedEnd.x - selectedEnd.x );
391 int yLength = abs( unselectedEnd.y - selectedEnd.y );
392 int xMove = ( xLength - ( xBendCount * lineGrid.x ) )
393 * sign( selectedEnd.x - unselectedEnd.x );
394 int yMove = ( yLength - ( yBendCount * lineGrid.y ) )
395 * sign( selectedEnd.y - unselectedEnd.y );
396
397 // Create a new wire ending at the unselected end, we'll move the new wire's start
398 // point to the unselected end
399 SCH_LINE* a = new SCH_LINE( unselectedEnd, line->GetLayer() );
400 a->MoveStart( VECTOR2I( xMove, yMove ) );
401 a->SetFlags( IS_NEW );
402 a->SetConnectivityDirty( true );
403 a->SetLastResolvedState( line );
404 cloneWireConnection( a, line, m_frame );
405 m_frame->AddToScreen( a, m_frame->GetScreen() );
406 m_newDragLines.insert( a );
407
408 SCH_LINE* b = new SCH_LINE( a->GetStartPoint(), line->GetLayer() );
409 b->MoveStart( VECTOR2I( splitDelta.x, splitDelta.y ) );
410 b->SetFlags( IS_NEW | STARTPOINT );
411 b->SetConnectivityDirty( true );
412 b->SetLastResolvedState( line );
413 cloneWireConnection( b, line, m_frame );
414 m_frame->AddToScreen( b, m_frame->GetScreen() );
415 m_newDragLines.insert( b );
416
417 xBendCount += yMoveBit;
418 yBendCount += xMoveBit;
419
420 // Ok move the unselected end of our item
421 if( line->HasFlag( STARTPOINT ) )
422 {
423 line->MoveEnd( VECTOR2I( splitDelta.x ? splitDelta.x : xMove,
424 splitDelta.y ? splitDelta.y : yMove ) );
425 }
426 else
427 {
428 line->MoveStart( VECTOR2I( splitDelta.x ? splitDelta.x : xMove,
429 splitDelta.y ? splitDelta.y : yMove ) );
430 }
431
432 // Update our cache of the connected items. First, attach our drag labels to the line
433 // left behind.
434 for( EDA_ITEM* candidate : m_lineConnectionCache[line] )
435 {
436 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( candidate );
437
438 if( label && m_specialCaseLabels.count( label ) )
439 m_specialCaseLabels[label].attachedLine = a;
440 }
441
442 // We just broke off of the existing items, so replace all of them with our new end
443 // connection.
445 m_lineConnectionCache[b].emplace_back( a );
446 m_lineConnectionCache[line].clear();
447 m_lineConnectionCache[line].emplace_back( b );
448 }
449 // Original line has no attachments, just move the unselected end
450 else if( !foundAttachment )
451 {
452 if( line->HasFlag( STARTPOINT ) )
453 line->MoveEnd( splitDelta );
454 else
455 line->MoveStart( splitDelta );
456 }
457 }
458}
459
460
461int SCH_MOVE_TOOL::Main( const TOOL_EVENT& aEvent )
462{
463 if( aEvent.IsAction( &SCH_ACTIONS::drag ) )
464 m_mode = DRAG;
465 else if( aEvent.IsAction( &SCH_ACTIONS::breakWire ) )
466 m_mode = BREAK;
467 else if( aEvent.IsAction( &SCH_ACTIONS::slice ) )
468 m_mode = SLICE;
469 else
470 m_mode = MOVE;
471
472 if( SCH_COMMIT* commit = dynamic_cast<SCH_COMMIT*>( aEvent.Commit() ) )
473 {
474 wxCHECK( aEvent.SynchronousState(), 0 );
475 aEvent.SynchronousState()->store( STS_RUNNING );
476
477 if( doMoveSelection( aEvent, commit ) )
478 aEvent.SynchronousState()->store( STS_FINISHED );
479 else
480 aEvent.SynchronousState()->store( STS_CANCELLED );
481 }
482 else
483 {
484 SCH_COMMIT localCommit( m_toolMgr );
485
486 if( doMoveSelection( aEvent, &localCommit ) )
487 {
488 switch( m_mode )
489 {
490 case MOVE: localCommit.Push( _( "Move" ) ); break;
491 case DRAG: localCommit.Push( _( "Drag" ) ); break;
492 case BREAK: localCommit.Push( _( "Break Wire" ) ); break;
493 case SLICE: localCommit.Push( _( "Slice Wire" ) ); break;
494 }
495 }
496 else
497 {
498 localCommit.Revert();
499 }
500 }
501
502 return 0;
503}
504
505
507{
508 if( m_mode != BREAK && m_mode != SLICE )
509 return;
510
511 if( !aCommit )
512 return;
513
515
516 if( !lwbTool )
517 return;
518
519 SCH_SELECTION& selection = m_selectionTool->GetSelection();
520
521 if( selection.Empty() )
522 return;
523
524 std::vector<SCH_LINE*> lines;
525
526 for( EDA_ITEM* item : selection )
527 {
528 if( item->Type() == SCH_LINE_T )
529 {
530 // This function gets called every time segments are broken, which can also be for subsequent
531 // breaks in a loop without leaving the current move tool.
532 // Skip already placed segments (segment keeps IS_BROKEN but will have IS_NEW cleared below)
533 // so that only the actively placed tail segment gets split again.
534 if( item->HasFlag( IS_BROKEN ) && !item->HasFlag( IS_NEW ) )
535 continue;
536
537 lines.push_back( static_cast<SCH_LINE*>( item ) );
538 }
539 }
540
541 if( lines.empty() )
542 return;
543
545 SCH_SCREEN* screen = m_frame->GetScreen();
546 VECTOR2I cursorPos = controls->GetCursorPosition( !aEvent.DisableGridSnapping() );
547
548 bool useCursorForSingleLine = false;
549
550 if( lines.size() == 1 )
551 useCursorForSingleLine = true;
552
553 m_selectionTool->ClearSelection();
554 m_breakPos.reset();
555
556 for( SCH_LINE* line : lines )
557 {
558 VECTOR2I breakPos = useCursorForSingleLine ? cursorPos : line->GetMidPoint();
559
560 if( m_mode == BREAK && !m_breakPos )
561 m_breakPos = breakPos;
562
563 SCH_LINE* newLine = nullptr;
564
565 lwbTool->BreakSegment( aCommit, line, breakPos, &newLine, screen );
566
567 if( !newLine )
568 continue;
569
570 // If this is a second+ round break, we need to get rid of the IS_NEW flag since the new segment
571 // is now an existing segment we are breaking from, this will be checked for in the line selection
572 // gathering above
573 line->ClearFlags( STARTPOINT | IS_NEW );
574 line->SetFlags( ENDPOINT );
575 m_selectionTool->AddItemToSel( line );
576
577 newLine->ClearFlags( ENDPOINT | STARTPOINT );
578
579 if( m_mode == BREAK )
580 {
581 m_selectionTool->AddItemToSel( newLine );
582 newLine->SetFlags( STARTPOINT );
583 }
584 }
585}
586
587
589{
592 bool currentModeIsDragLike = ( m_mode != MOVE );
593 bool wasDragging = m_moveInProgress && currentModeIsDragLike;
594 bool didAtLeastOneBreak = false;
595
596 m_anchorPos.reset();
597
598 // Check if already in progress and handle state transitions
599 if( checkMoveInProgress( aEvent, aCommit, currentModeIsDragLike, wasDragging ) )
600 return false;
601
602 if( m_inMoveTool ) // Must come after m_moveInProgress checks above...
603 return false;
604
606
607 preprocessBreakOrSliceSelection( aCommit, aEvent );
608
609 // Prepare selection (promote pins to symbols, request selection)
610 bool unselect = false;
611 SCH_SELECTION& selection = prepareSelection( unselect );
612
613 // Keep an original copy of the starting points for cleanup after the move
614 std::vector<DANGLING_END_ITEM> internalPoints;
615
616 // Track selection characteristics
617 bool selectionHasSheetPins = false;
618 bool selectionHasGraphicItems = false;
619 bool selectionHasNonGraphicItems = false;
620 bool selectionIsGraphicsOnly = false;
621
622 std::unique_ptr<SCH_DRAG_NET_COLLISION_MONITOR> netCollisionMonitor;
623
624 auto refreshTraits =
625 [&]()
626 {
627 refreshSelectionTraits( selection, selectionHasSheetPins, selectionHasGraphicItems,
628 selectionHasNonGraphicItems, selectionIsGraphicsOnly );
629 };
630
631 refreshTraits();
632
633 if( !selection.Empty() )
634
635 {
636 netCollisionMonitor = std::make_unique<SCH_DRAG_NET_COLLISION_MONITOR>( m_frame, m_view );
637 netCollisionMonitor->Initialize( selection );
638 }
639
640 bool lastCtrlDown = false;
641
642 Activate();
643
644 // Must be done after Activate() so that it gets set into the correct context
645 controls->ShowCursor( true );
646
647 m_frame->PushTool( aEvent );
648
649 if( selection.Empty() )
650 {
651 // Note that it's important to go through push/pop even when the selection is empty.
652 // This keeps other tools from having to special-case an empty move.
653 m_frame->PopTool( aEvent );
654 return false;
655 }
656
657 bool restore_state = false;
658 TOOL_EVENT copy = aEvent;
659 TOOL_EVENT* evt = &copy;
660 VECTOR2I prevPos = controls->GetCursorPosition();
662 SCH_SHEET* hoverSheet = nullptr;
663 KICURSOR currentCursor = KICURSOR::MOVING;
664 m_cursor = controls->GetCursorPosition();
665
666 // Axis locking for arrow key movement
667 enum class AXIS_LOCK { NONE, HORIZONTAL, VERTICAL };
668 AXIS_LOCK axisLock = AXIS_LOCK::NONE;
669 long lastArrowKeyAction = 0;
670
671 // Main loop: keep receiving events
672 do
673 {
674 wxLogTrace( traceSchMove, "doMoveSelection: event loop iteration, evt=%s, action=%s",
675 evt->Category() == TC_MOUSE ? "MOUSE" :
676 evt->Category() == TC_KEYBOARD ? "KEYBOARD" :
677 evt->Category() == TC_COMMAND ? "COMMAND" : "OTHER",
678 evt->Format().c_str() );
679
680 m_frame->GetCanvas()->SetCurrentCursor( currentCursor );
681 grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
682 grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
683
684 bool ctrlDown = evt->Modifier( MD_CTRL );
685 lastCtrlDown = ctrlDown;
686
688 || evt->IsAction( &SCH_ACTIONS::move )
689 || evt->IsAction( &SCH_ACTIONS::drag )
690 || evt->IsMotion()
691 || evt->IsDrag( BUT_LEFT )
693 {
694 refreshTraits();
695
696 if( !m_moveInProgress ) // Prepare to start moving/dragging
697 {
698 initializeMoveOperation( aEvent, selection, aCommit, internalPoints, snapLayer );
699 prevPos = m_cursor;
700 refreshTraits();
701 }
702
703 //------------------------------------------------------------------------
704 // Follow the mouse
705 //
706 m_view->ClearPreview();
707
708 // We need to bypass refreshPreview action here because it is triggered by the move, so we were
709 // getting double-key events that toggled the axis locking if you pressed them in a certain order.
711 {
712 VECTOR2I keyboardPos( controls->GetSettings().m_lastKeyboardCursorPosition );
713 long action = controls->GetSettings().m_lastKeyboardCursorCommand;
714
715 grid.SetSnap( false );
716 m_cursor = grid.Align( keyboardPos, snapLayer );
717
718 // Update axis lock based on arrow key press
719 if( action == ACTIONS::CURSOR_LEFT || action == ACTIONS::CURSOR_RIGHT )
720 {
721 if( axisLock == AXIS_LOCK::HORIZONTAL )
722 {
723 // Check if opposite horizontal key pressed to unlock
724 if( ( lastArrowKeyAction == ACTIONS::CURSOR_LEFT && action == ACTIONS::CURSOR_RIGHT ) ||
725 ( lastArrowKeyAction == ACTIONS::CURSOR_RIGHT && action == ACTIONS::CURSOR_LEFT ) )
726 {
727 axisLock = AXIS_LOCK::NONE;
728 }
729 // Same direction axis, keep locked
730 }
731 else
732 {
733 axisLock = AXIS_LOCK::HORIZONTAL;
734 }
735 }
736 else if( action == ACTIONS::CURSOR_UP || action == ACTIONS::CURSOR_DOWN )
737 {
738 if( axisLock == AXIS_LOCK::VERTICAL )
739 {
740 // Check if opposite vertical key pressed to unlock
741 if( ( lastArrowKeyAction == ACTIONS::CURSOR_UP && action == ACTIONS::CURSOR_DOWN ) ||
742 ( lastArrowKeyAction == ACTIONS::CURSOR_DOWN && action == ACTIONS::CURSOR_UP ) )
743 {
744 axisLock = AXIS_LOCK::NONE;
745 }
746 // Same direction axis, keep locked
747 }
748 else
749 {
750 axisLock = AXIS_LOCK::VERTICAL;
751 }
752 }
753
754 lastArrowKeyAction = action;
755 }
756 else
757 {
758 m_cursor = grid.BestSnapAnchor( controls->GetCursorPosition( false ), snapLayer, selection );
759 }
760
761 if( axisLock == AXIS_LOCK::HORIZONTAL )
762 m_cursor.y = prevPos.y;
763 else if( axisLock == AXIS_LOCK::VERTICAL )
764 m_cursor.x = prevPos.x;
765
766 // Find potential target sheet for dropping
767 SCH_SHEET* sheet = findTargetSheet( selection, m_cursor, selectionHasSheetPins,
768 selectionIsGraphicsOnly, ctrlDown );
769
770 if( sheet != hoverSheet )
771 {
772 hoverSheet = sheet;
773
774 if( hoverSheet )
775 {
776 hoverSheet->SetFlags( BRIGHTENED );
777 m_frame->UpdateItem( hoverSheet, false );
778 }
779 }
780
781 currentCursor = hoverSheet ? KICURSOR::PLACE : KICURSOR::MOVING;
782
783 if( netCollisionMonitor )
784 currentCursor = netCollisionMonitor->AdjustCursor( currentCursor );
785
786 VECTOR2I delta( m_cursor - prevPos );
788
789 // Used for tracking how far off a drag end should have its 90 degree elbow added
790 int xBendCount = 1;
791 int yBendCount = 1;
792
793 performItemMove( selection, delta, aCommit, xBendCount, yBendCount, grid );
794 prevPos = m_cursor;
795
796 std::vector<SCH_ITEM*> previewItems;
797
798 for( EDA_ITEM* it : selection )
799 previewItems.push_back( static_cast<SCH_ITEM*>( it ) );
800
801 for( SCH_LINE* line : m_newDragLines )
802 previewItems.push_back( line );
803
804 for( SCH_LINE* line : m_changedDragLines )
805 previewItems.push_back( line );
806
807 std::vector<SCH_JUNCTION*> previewJunctions =
808 JUNCTION_HELPERS::PreviewJunctions( m_frame->GetScreen(), previewItems );
809
810 if( netCollisionMonitor )
811 netCollisionMonitor->Update( previewJunctions, selection );
812
813 for( SCH_JUNCTION* jct : previewJunctions )
814 m_view->AddToPreview( jct, true );
815
817 }
818
819 //------------------------------------------------------------------------
820 // Handle cancel
821 //
822 else if( evt->IsCancelInteractive()
823 || evt->IsActivate()
824 || evt->IsAction( &ACTIONS::undo ) )
825 {
826 if( evt->IsCancelInteractive() )
827 {
828 m_frame->GetInfoBar()->Dismiss();
829
830 // When breaking, the user can cancel after multiple breaks to keep all but the last
831 // break, so exit normally if we have done at least one break
832 if( didAtLeastOneBreak && m_mode == BREAK )
833 break;
834 }
835
836 if( m_moveInProgress )
837 {
838 if( evt->IsActivate() )
839 {
840 // Allowing other tools to activate during a move runs the risk of race
841 // conditions in which we try to spool up both event loops at once.
842
843 switch( m_mode )
844 {
845 case MOVE: m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel move." ) ); break;
846 case DRAG: m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel drag." ) ); break;
847 case BREAK: m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel break." ) ); break;
848 case SLICE: m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel slice." ) ); break;
849 }
850
851 evt->SetPassEvent( false );
852 continue;
853 }
854
855 evt->SetPassEvent( false );
856 restore_state = true;
857 }
858
860
861 m_view->ClearPreview();
862
863 break;
864 }
865 //------------------------------------------------------------------------
866 // Handle TOOL_ACTION special cases
867 //
868 else if( !handleMoveToolActions( evt, aCommit, selection ) )
869 {
870 wxLogTrace( traceSchMove, "doMoveSelection: handleMoveToolActions returned false, exiting" );
871 break; // Exit if told to by handler
872 }
873 //------------------------------------------------------------------------
874 // Handle context menu
875 //
876 else if( evt->IsClick( BUT_RIGHT ) )
877 {
878 m_menu->ShowContextMenu( m_selectionTool->GetSelection() );
879 }
880 //------------------------------------------------------------------------
881 // Handle drop
882 //
883 else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) )
884 {
885 if( m_mode != BREAK )
886 break; // Finish
887 else
888 {
889 didAtLeastOneBreak = true;
890 preprocessBreakOrSliceSelection( aCommit, *evt );
891 selection = m_selectionTool->RequestSelection( SCH_COLLECTOR::MovableItems, true );
892
893 if( m_breakPos )
894 {
897 selection.SetReferencePoint( m_cursor );
898 m_moveOffset = VECTOR2I( 0, 0 );
899 m_breakPos.reset();
900
901 controls->SetCursorPosition( m_cursor, false );
902 prevPos = m_cursor;
903 }
904 }
905 }
906 else if( evt->IsDblClick( BUT_LEFT ) )
907 {
908 // Double click always finishes, even breaks
909 break;
910 }
911 // Don't call SetPassEvent() for events we've handled - let them be consumed
912 else if( evt->IsAction( &SCH_ACTIONS::rotateCW )
914 || evt->IsAction( &ACTIONS::increment )
919 || evt->IsAction( &SCH_ACTIONS::toText )
923 || evt->IsAction( &ACTIONS::duplicate )
925 || evt->IsAction( &ACTIONS::redo ) )
926 {
927 // Event was already handled by handleMoveToolActions, don't pass it on
928 wxLogTrace( traceSchMove, "doMoveSelection: event handled, not passing" );
929 }
930 else
931 {
932 evt->SetPassEvent();
933 }
934
935 controls->SetAutoPan( m_moveInProgress );
936
937 } while( ( evt = Wait() ) ); //Should be assignment not equality test
938
939 SCH_SHEET* targetSheet = hoverSheet;
940
941 if( selectionHasSheetPins || ( selectionIsGraphicsOnly && !lastCtrlDown ) )
942 targetSheet = nullptr;
943
944 if( hoverSheet )
945 {
946 hoverSheet->ClearFlags( BRIGHTENED );
947 m_frame->UpdateItem( hoverSheet, false );
948 }
949
950 if( restore_state )
951 {
952 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
953 }
954 else
955 {
956 // Only drop into a sheet when the move is committed, not when canceled.
957 if( targetSheet )
958 {
959 moveSelectionToSheet( selection, targetSheet, aCommit );
961 m_newDragLines.clear();
962 m_changedDragLines.clear();
963 }
964
965 finalizeMoveOperation( selection, aCommit, unselect, internalPoints );
966 }
967
968 m_dragAdditions.clear();
969 m_lineConnectionCache.clear();
970 m_moveInProgress = false;
971 m_breakPos.reset();
972
973 m_hiddenJunctions.clear();
974 m_view->ClearPreview();
975 m_frame->PopTool( aEvent );
976
977 return !restore_state;
978}
979
980
981bool SCH_MOVE_TOOL::checkMoveInProgress( const TOOL_EVENT& aEvent, SCH_COMMIT* aCommit, bool aCurrentModeIsDragLike,
982 bool aWasDragging )
983{
985
986 if( !m_moveInProgress )
987 return false;
988
989 if( aCurrentModeIsDragLike != aWasDragging )
990 {
991 EDA_ITEM* sel = m_selectionTool->GetSelection().Front();
992
993 if( sel && !sel->IsNew() )
994 {
995 // Reset the selected items so we can start again with the current drag mode state
996 aCommit->Revert();
997
998 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
1000 m_moveInProgress = false;
1001 controls->SetAutoPan( false );
1002
1003 // Give it a kick so it doesn't have to wait for the first mouse movement to refresh
1004 m_toolMgr->PostAction( SCH_ACTIONS::restartMove );
1005 }
1006 }
1007 else
1008 {
1009 // The tool hotkey is interpreted as a click when already dragging/moving
1010 m_toolMgr->PostAction( ACTIONS::cursorClick );
1011 }
1012
1013 return true;
1014}
1015
1016
1018{
1019 SCH_SELECTION& userSelection = m_selectionTool->GetSelection();
1020
1021 // If a single pin is selected, promote the move selection to its parent symbol
1022 if( userSelection.GetSize() == 1 )
1023 {
1024 EDA_ITEM* selItem = userSelection.Front();
1025
1026 if( selItem->Type() == SCH_PIN_T )
1027 {
1028 EDA_ITEM* parent = selItem->GetParent();
1029
1030 if( parent->Type() == SCH_SYMBOL_T )
1031 {
1032 m_selectionTool->ClearSelection();
1033 m_selectionTool->AddItemToSel( parent );
1034 }
1035 }
1036 }
1037
1038 // Be sure that there is at least one item that we can move. If there's no selection try
1039 // looking for the stuff under mouse cursor (i.e. KiCad old-style hover selection).
1040 SCH_SELECTION& selection = m_selectionTool->RequestSelection( SCH_COLLECTOR::MovableItems, true );
1041 aUnselect = selection.IsHover();
1042
1043 return selection;
1044}
1045
1046
1047void SCH_MOVE_TOOL::refreshSelectionTraits( const SCH_SELECTION& aSelection, bool& aHasSheetPins,
1048 bool& aHasGraphicItems, bool& aHasNonGraphicItems,
1049 bool& aIsGraphicsOnly )
1050{
1051 aHasSheetPins = false;
1052 aHasGraphicItems = false;
1053 aHasNonGraphicItems = false;
1054
1055 for( EDA_ITEM* edaItem : aSelection )
1056 {
1057 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( edaItem );
1058
1059 if( schItem->Type() == SCH_SHEET_PIN_T )
1060 aHasSheetPins = true;
1061
1062 if( isGraphicItemForDrop( schItem ) )
1063 aHasGraphicItems = true;
1064 else if( schItem->Type() != SCH_SHEET_T )
1065 aHasNonGraphicItems = true;
1066 }
1067
1068 aIsGraphicsOnly = aHasGraphicItems && !aHasNonGraphicItems;
1069}
1070
1071
1073{
1074 // Drag of split items start over top of their other segment, so we want to skip grabbing
1075 // the segments we split from
1076 if( m_mode != DRAG && m_mode != BREAK )
1077 return;
1078
1079 EDA_ITEMS connectedDragItems;
1080
1081 // Add connections to the selection for a drag.
1082 // Do all non-labels/entries first so we don't add junctions to drag when the line will
1083 // eventually be drag selected.
1084 std::vector<SCH_ITEM*> stageTwo;
1085
1086 for( EDA_ITEM* edaItem : aSelection )
1087 {
1088 SCH_ITEM* item = static_cast<SCH_ITEM*>( edaItem );
1089 std::vector<VECTOR2I> connections;
1090
1091 switch( item->Type() )
1092 {
1093 case SCH_LABEL_T:
1094 case SCH_HIER_LABEL_T:
1095 case SCH_GLOBAL_LABEL_T:
1097 stageTwo.emplace_back( item );
1098 break;
1099
1100 case SCH_LINE_T:
1101 static_cast<SCH_LINE*>( item )->GetSelectedPoints( connections );
1102 break;
1103
1104 default:
1105 connections = item->GetConnectionPoints();
1106 }
1107
1108 for( const VECTOR2I& point : connections )
1109 getConnectedDragItems( aCommit, item, point, connectedDragItems );
1110 }
1111
1112 // Go back and get all label connections now that we can test for drag-selected lines
1113 // the labels might be on
1114 for( SCH_ITEM* item : stageTwo )
1115 {
1116 for( const VECTOR2I& point : item->GetConnectionPoints() )
1117 getConnectedDragItems( aCommit, item, point, connectedDragItems );
1118 }
1119
1120 for( EDA_ITEM* item : connectedDragItems )
1121 {
1122 m_dragAdditions.push_back( item->m_Uuid );
1123 m_selectionTool->AddItemToSel( item, QUIET_MODE );
1124 }
1125
1126 // Pre-cache all connections of our selected objects so we can keep track of what they
1127 // were originally connected to as we drag them around
1128 for( EDA_ITEM* edaItem : aSelection )
1129 {
1130 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( edaItem );
1131
1132 if( schItem->Type() == SCH_LINE_T )
1133 {
1134 SCH_LINE* line = static_cast<SCH_LINE*>( schItem );
1135
1136 // Store the original angle of the line; needed later to decide which segment
1137 // to extend when they've become zero length
1138 line->StoreAngle();
1139
1140 for( const VECTOR2I& point : line->GetConnectionPoints() )
1141 getConnectedItems( line, point, m_lineConnectionCache[line] );
1142 }
1143 }
1144}
1145
1146
1147void SCH_MOVE_TOOL::setupItemsForMove( SCH_SELECTION& aSelection, std::vector<DANGLING_END_ITEM>& aInternalPoints )
1148{
1149 // Mark the edges of the block with dangling flags for a move
1150 for( EDA_ITEM* item : aSelection )
1151 static_cast<SCH_ITEM*>( item )->GetEndPoints( aInternalPoints );
1152
1153 std::vector<DANGLING_END_ITEM> endPointsByType = aInternalPoints;
1154 std::vector<DANGLING_END_ITEM> endPointsByPos = endPointsByType;
1155 DANGLING_END_ITEM_HELPER::sort_dangling_end_items( endPointsByType, endPointsByPos );
1156
1157 for( EDA_ITEM* item : aSelection )
1158 static_cast<SCH_ITEM*>( item )->UpdateDanglingState( endPointsByType, endPointsByPos );
1159}
1160
1161
1163 std::vector<DANGLING_END_ITEM>& aInternalPoints,
1164 GRID_HELPER_GRIDS& aSnapLayer )
1165{
1168 SCH_ITEM* sch_item = static_cast<SCH_ITEM*>( aSelection.Front() );
1169 bool placingNewItems = sch_item && sch_item->IsNew();
1170
1171 //------------------------------------------------------------------------
1172 // Setup a drag or a move
1173 //
1174 m_dragAdditions.clear();
1175 m_specialCaseLabels.clear();
1176 m_specialCaseSheetPins.clear();
1177 aInternalPoints.clear();
1179
1180 for( SCH_ITEM* it : m_frame->GetScreen()->Items() )
1181 {
1182 it->ClearFlags( SELECTED_BY_DRAG );
1183
1184 if( !it->IsSelected() )
1185 it->ClearFlags( STARTPOINT | ENDPOINT );
1186 }
1187
1188 setupItemsForDrag( aSelection, aCommit );
1189 setupItemsForMove( aSelection, aInternalPoints );
1190
1191 // Hide junctions connected to line endpoints that are not selected
1192 m_hiddenJunctions.clear();
1193
1194 for( EDA_ITEM* item : aSelection )
1195 item->SetFlags( STRUCT_DELETED );
1196
1197 for( EDA_ITEM* edaItem : aSelection )
1198 {
1199 if( edaItem->Type() != SCH_LINE_T )
1200 continue;
1201
1202 SCH_LINE* line = static_cast<SCH_LINE*>( edaItem );
1203
1204 for( const VECTOR2I& pt : line->GetConnectionPoints() )
1205 {
1206 SCH_JUNCTION* jct = static_cast<SCH_JUNCTION*>( m_frame->GetScreen()->GetItem( pt, 0, SCH_JUNCTION_T ) );
1207
1208 if( jct && !jct->IsSelected()
1209 && std::find( m_hiddenJunctions.begin(), m_hiddenJunctions.end(), jct ) == m_hiddenJunctions.end() )
1210 {
1212 pt, false );
1213
1214 if( !info.isJunction )
1215 {
1216 jct->SetFlags( STRUCT_DELETED );
1217 m_frame->RemoveFromScreen( jct, m_frame->GetScreen() );
1218 aCommit->Removed( jct, m_frame->GetScreen() );
1219 }
1220 }
1221 }
1222 }
1223
1224 for( EDA_ITEM* item : aSelection )
1225 item->ClearFlags( STRUCT_DELETED );
1226
1227 // Generic setup
1228 aSnapLayer = grid.GetSelectionGrid( aSelection );
1229
1230 for( EDA_ITEM* item : aSelection )
1231 {
1232 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
1233
1234 if( schItem->IsNew() )
1235 {
1236 // Item was added to commit in a previous command
1237
1238 // While SCH_COMMIT::Push() will add any new items to the entered group, we need
1239 // to do it earlier so that the previews while moving are correct.
1240 if( SCH_GROUP* enteredGroup = m_selectionTool->GetEnteredGroup() )
1241 {
1242 if( schItem->IsGroupableType() && !schItem->GetParentGroup() )
1243 {
1244 aCommit->Modify( enteredGroup, m_frame->GetScreen(), RECURSE_MODE::NO_RECURSE );
1245 enteredGroup->AddItem( schItem );
1246 }
1247 }
1248 }
1249 else if( schItem->GetParent() && schItem->GetParent()->IsSelected() )
1250 {
1251 // Item will be (or has been) added to commit by parent
1252 }
1253 else
1254 {
1255 aCommit->Modify( schItem, m_frame->GetScreen(), RECURSE_MODE::RECURSE );
1256 }
1257
1258 schItem->SetFlags( IS_MOVING );
1259
1260 if( SCH_SHAPE* shape = dynamic_cast<SCH_SHAPE*>( schItem ) )
1261 {
1262 shape->SetHatchingDirty();
1263 shape->UpdateHatching();
1264 }
1265
1266 schItem->RunOnChildren(
1267 [&]( SCH_ITEM* unused )
1268 {
1269 item->SetFlags( IS_MOVING );
1270 },
1272
1273 schItem->SetStoredPos( schItem->GetPosition() );
1274 }
1275
1276 // Set up the starting position and move/drag offset
1277 m_cursor = controls->GetCursorPosition();
1278
1279 if( m_mode == BREAK && m_breakPos )
1280 {
1283 aSelection.SetReferencePoint( m_cursor );
1284 m_moveOffset = VECTOR2I( 0, 0 );
1285 m_breakPos.reset();
1286 }
1287
1288 if( aEvent.IsAction( &SCH_ACTIONS::restartMove ) )
1289 {
1290 wxASSERT_MSG( m_anchorPos, "Should be already set from previous cmd" );
1291 }
1292 else if( placingNewItems )
1293 {
1294 m_anchorPos = aSelection.GetReferencePoint();
1295 }
1296
1297 if( m_anchorPos )
1298 {
1299 VECTOR2I delta = m_cursor - ( *m_anchorPos );
1300 bool isPasted = false;
1301
1302 // Drag items to the current cursor position
1303 for( EDA_ITEM* item : aSelection )
1304 {
1305 // Don't double move pins, fields, etc.
1306 if( item->GetParent() && item->GetParent()->IsSelected() )
1307 continue;
1308
1309 moveItem( item, delta );
1310 updateItem( item, false );
1311
1312 isPasted |= ( item->GetFlags() & IS_PASTED ) != 0;
1313 }
1314
1315 // The first time pasted items are moved we need to store the position of the cursor
1316 // so that rotate while moving works as expected (instead of around the original
1317 // anchor point)
1318 if( isPasted )
1319 aSelection.SetReferencePoint( m_cursor );
1320
1322 }
1323 // For some items, moving the cursor to anchor is not good (for instance large
1324 // hierarchical sheets or symbols can have the anchor outside the view)
1325 else if( aSelection.Size() == 1 && !sch_item->IsMovableFromAnchorPoint() )
1326 {
1329 }
1330 else
1331 {
1332 if( m_frame->GetMoveWarpsCursor() )
1333 {
1334 // User wants to warp the mouse
1335 m_cursor = grid.BestDragOrigin( m_cursor, aSnapLayer, aSelection );
1336 aSelection.SetReferencePoint( m_cursor );
1337 }
1338 else
1339 {
1340 // User does not want to warp the mouse
1342 }
1343 }
1344
1345 controls->SetCursorPosition( m_cursor, false );
1346 controls->SetAutoPan( true );
1347 m_moveInProgress = true;
1348}
1349
1350
1352 bool aHasSheetPins, bool aIsGraphicsOnly, bool aCtrlDown )
1353{
1354 // Determine potential target sheet
1355 SCH_SHEET* sheet = dynamic_cast<SCH_SHEET*>( m_frame->GetScreen()->GetItem( aCursorPos, 0, SCH_SHEET_T ) );
1356
1357 if( sheet && sheet->IsSelected() )
1358 sheet = nullptr; // Never target a selected sheet
1359
1360 if( !sheet )
1361 {
1362 // Build current selection bounding box in its (already moved) position
1363 BOX2I selBBox;
1364
1365 for( EDA_ITEM* it : aSelection )
1366 {
1367 if( SCH_ITEM* schIt = dynamic_cast<SCH_ITEM*>( it ) )
1368 selBBox.Merge( schIt->GetBoundingBox() );
1369 }
1370
1371 if( selBBox.GetWidth() > 0 && selBBox.GetHeight() > 0 )
1372 {
1373 VECTOR2I selCenter( selBBox.GetX() + selBBox.GetWidth() / 2,
1374 selBBox.GetY() + selBBox.GetHeight() / 2 );
1375
1376 // Find first non-selected sheet whose body fully contains the selection or at
1377 // least contains its center point
1378 for( SCH_ITEM* it : m_frame->GetScreen()->Items().OfType( SCH_SHEET_T ) )
1379 {
1380 SCH_SHEET* candidate = static_cast<SCH_SHEET*>( it );
1381
1382 if( candidate->IsSelected() || candidate->IsTopLevelSheet() )
1383 continue;
1384
1385 BOX2I body = candidate->GetBodyBoundingBox();
1386
1387 if( body.Contains( selBBox ) || body.Contains( selCenter ) )
1388 {
1389 sheet = candidate;
1390 break;
1391 }
1392 }
1393 }
1394 }
1395
1396 bool dropAllowedBySelection = !aHasSheetPins;
1397 bool dropAllowedByModifiers = !aIsGraphicsOnly || aCtrlDown;
1398
1399 if( sheet && !( dropAllowedBySelection && dropAllowedByModifiers ) )
1400 sheet = nullptr;
1401
1402 return sheet;
1403}
1404
1405
1407 SCH_COMMIT* aCommit, int& aXBendCount, int& aYBendCount,
1408 const EE_GRID_HELPER& aGrid )
1409{
1410 wxLogTrace( traceSchMove, "performItemMove: delta=(%d,%d), moveOffset=(%d,%d), selection size=%u",
1411 aDelta.x, aDelta.y, m_moveOffset.x, m_moveOffset.y, aSelection.GetSize() );
1412
1413 // We need to check if the movement will change the net offset direction on the X and Y
1414 // axes. This is because we remerge added bend lines in realtime, and we also account for
1415 // the direction of the move when adding bend lines. So, if the move direction changes,
1416 // we need to split it into a move that gets us back to zero, then the rest of the move.
1417 std::vector<VECTOR2I> splitMoves;
1418
1419 if( alg::signbit( m_moveOffset.x ) != alg::signbit( ( m_moveOffset + aDelta ).x ) )
1420 {
1421 splitMoves.emplace_back( VECTOR2I( -1 * m_moveOffset.x, 0 ) );
1422 splitMoves.emplace_back( VECTOR2I( aDelta.x + m_moveOffset.x, 0 ) );
1423 }
1424 else
1425 {
1426 splitMoves.emplace_back( VECTOR2I( aDelta.x, 0 ) );
1427 }
1428
1429 if( alg::signbit( m_moveOffset.y ) != alg::signbit( ( m_moveOffset + aDelta ).y ) )
1430 {
1431 splitMoves.emplace_back( VECTOR2I( 0, -1 * m_moveOffset.y ) );
1432 splitMoves.emplace_back( VECTOR2I( 0, aDelta.y + m_moveOffset.y ) );
1433 }
1434 else
1435 {
1436 splitMoves.emplace_back( VECTOR2I( 0, aDelta.y ) );
1437 }
1438
1439 m_moveOffset += aDelta;
1440
1441 // Split the move into X and Y moves so we can correctly drag orthogonal lines
1442 for( const VECTOR2I& splitDelta : splitMoves )
1443 {
1444 // Skip non-moves
1445 if( splitDelta == VECTOR2I( 0, 0 ) )
1446 continue;
1447
1448 for( EDA_ITEM* item : aSelection.GetItemsSortedByTypeAndXY( ( aDelta.x >= 0 ),
1449 ( aDelta.y >= 0 ) ) )
1450 {
1451 // Don't double move pins, fields, etc.
1452 if( item->GetParent() && item->GetParent()->IsSelected() )
1453 continue;
1454
1455 SCH_LINE* line = dynamic_cast<SCH_LINE*>( item );
1456 bool isLineModeConstrained = false;
1457
1458 if( EESCHEMA_SETTINGS* cfg = GetAppSettings<EESCHEMA_SETTINGS>( "eeschema" ) )
1459 isLineModeConstrained = cfg->m_Drawing.line_mode != LINE_MODE::LINE_MODE_FREE;
1460
1461 // Only partially selected drag lines in orthogonal line mode need special handling
1462 if( ( m_mode == DRAG ) && isLineModeConstrained && line
1463 && line->HasFlag( STARTPOINT ) != line->HasFlag( ENDPOINT ) )
1464 {
1465 orthoLineDrag( aCommit, line, splitDelta, aXBendCount, aYBendCount, aGrid );
1466 }
1467
1468 // Move all other items normally, including the selected end of partially selected
1469 // lines
1470 moveItem( item, splitDelta );
1471 updateItem( item, false );
1472
1473 // Update any lines connected to sheet pins to the sheet pin's location (which may
1474 // not exactly follow the splitDelta as the pins are constrained along the sheet
1475 // edges)
1476 for( const auto& [pin, lineEnd] : m_specialCaseSheetPins )
1477 {
1478 if( lineEnd.second && lineEnd.first->HasFlag( STARTPOINT ) )
1479 lineEnd.first->SetStartPoint( pin->GetPosition() );
1480 else if( !lineEnd.second && lineEnd.first->HasFlag( ENDPOINT ) )
1481 lineEnd.first->SetEndPoint( pin->GetPosition() );
1482 }
1483 }
1484 }
1485
1486 if( aSelection.HasReferencePoint() )
1487 aSelection.SetReferencePoint( aSelection.GetReferencePoint() + aDelta );
1488}
1489
1490
1492 const SCH_SELECTION& aSelection )
1493{
1494 wxLogTrace( traceSchMove, "handleMoveToolActions: received event, action=%s",
1495 aEvent->Format().c_str() );
1496
1497 if( aEvent->IsAction( &ACTIONS::doDelete ) )
1498 {
1499 wxLogTrace( traceSchMove, "handleMoveToolActions: doDelete, exiting move" );
1500 const_cast<TOOL_EVENT*>( aEvent )->SetPassEvent();
1501 return false; // Exit on delete; there will no longer be anything to drag
1502 }
1503 else if( aEvent->IsAction( &ACTIONS::duplicate )
1505 || aEvent->IsAction( &ACTIONS::redo ) )
1506 {
1507 wxBell();
1508 }
1509 else if( aEvent->IsAction( &SCH_ACTIONS::rotateCW ) )
1510 {
1511 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCW event received, selection size=%u",
1512 aSelection.GetSize() );
1513 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::rotateCW, aCommit );
1514 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCW RunSynchronousAction completed" );
1515 updateStoredPositions( aSelection );
1516 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCW updateStoredPositions completed" );
1517 // Note: SCH_EDIT_TOOL::Rotate already posts refreshPreview when moving
1518 }
1519 else if( aEvent->IsAction( &SCH_ACTIONS::rotateCCW ) )
1520 {
1521 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCCW event received, selection size=%u",
1522 aSelection.GetSize() );
1523 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::rotateCCW, aCommit );
1524 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCCW RunSynchronousAction completed" );
1525 updateStoredPositions( aSelection );
1526 wxLogTrace( traceSchMove, "handleMoveToolActions: rotateCCW updateStoredPositions completed" );
1527 // Note: SCH_EDIT_TOOL::Rotate already posts refreshPreview when moving
1528 }
1529 else if( aEvent->IsAction( &ACTIONS::increment ) )
1530 {
1531 if( aEvent->HasParameter() )
1532 m_toolMgr->RunSynchronousAction( ACTIONS::increment, aCommit, aEvent->Parameter<ACTIONS::INCREMENT>() );
1533 else
1534 m_toolMgr->RunSynchronousAction( ACTIONS::increment, aCommit, ACTIONS::INCREMENT{ 1, 0 } );
1535
1536 updateStoredPositions( aSelection );
1537 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1538 }
1539 else if( aEvent->IsAction( &SCH_ACTIONS::toDLabel ) )
1540 {
1541 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toDLabel, aCommit );
1542 updateStoredPositions( aSelection );
1543 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1544 }
1545 else if( aEvent->IsAction( &SCH_ACTIONS::toGLabel ) )
1546 {
1547 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toGLabel, aCommit );
1548 updateStoredPositions( aSelection );
1549 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1550 }
1551 else if( aEvent->IsAction( &SCH_ACTIONS::toHLabel ) )
1552 {
1553 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toHLabel, aCommit );
1554 updateStoredPositions( aSelection );
1555 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1556 }
1557 else if( aEvent->IsAction( &SCH_ACTIONS::toLabel ) )
1558 {
1559 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toLabel, aCommit );
1560 updateStoredPositions( aSelection );
1561 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1562 }
1563 else if( aEvent->IsAction( &SCH_ACTIONS::toText ) )
1564 {
1565 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toText, aCommit );
1566 updateStoredPositions( aSelection );
1567 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1568 }
1569 else if( aEvent->IsAction( &SCH_ACTIONS::toTextBox ) )
1570 {
1571 m_toolMgr->RunSynchronousAction( SCH_ACTIONS::toTextBox, aCommit );
1572 updateStoredPositions( aSelection );
1573 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1574 }
1575 else if( aEvent->Action() == TA_CHOICE_MENU_CHOICE )
1576 {
1577 if( *aEvent->GetCommandId() >= ID_POPUP_SCH_SELECT_UNIT
1579 {
1580 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( m_selectionTool->GetSelection().Front() );
1581 int unit = *aEvent->GetCommandId() - ID_POPUP_SCH_SELECT_UNIT;
1582
1583 if( symbol )
1584 {
1585 m_frame->SelectUnit( symbol, unit );
1586 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1587 }
1588 }
1589 else if( *aEvent->GetCommandId() >= ID_POPUP_SCH_SELECT_BODY_STYLE
1591 {
1592 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( m_selectionTool->GetSelection().Front() );
1593 int bodyStyle = ( *aEvent->GetCommandId() - ID_POPUP_SCH_SELECT_BODY_STYLE ) + 1;
1594
1595 if( symbol && symbol->GetBodyStyle() != bodyStyle )
1596 {
1597 m_frame->SelectBodyStyle( symbol, bodyStyle );
1598 m_toolMgr->PostAction( ACTIONS::refreshPreview );
1599 }
1600 }
1601 }
1602 else if( aEvent->IsAction( &SCH_ACTIONS::highlightNet )
1603 || aEvent->IsAction( &SCH_ACTIONS::selectOnPCB ) )
1604 {
1605 // These don't make any sense during a move. Eat them.
1606 }
1607 else
1608 {
1609 return true; // Continue processing
1610 }
1611
1612 return true; // Continue processing
1613}
1614
1615
1617{
1618 wxLogTrace( traceSchMove, "updateStoredPositions: start, selection size=%u",
1619 aSelection.GetSize() );
1620
1621 // After transformations like rotation during a move, we need to update the stored
1622 // positions that moveItem() uses, particularly for sheet pins which rely on them
1623 // for constraint calculations.
1624 int itemCount = 0;
1625
1626 for( EDA_ITEM* item : aSelection )
1627 {
1628 SCH_ITEM* schItem = dynamic_cast<SCH_ITEM*>( item );
1629
1630 if( !schItem )
1631 continue;
1632
1633 VECTOR2I oldPos = schItem->GetStoredPos();
1634 VECTOR2I newPos = schItem->GetPosition();
1635 schItem->SetStoredPos( newPos );
1636
1637 wxLogTrace( traceSchMove, " item[%d] type=%d: stored pos updated (%d,%d) -> (%d,%d)",
1638 itemCount++, (int) schItem->Type(), oldPos.x, oldPos.y, newPos.x, newPos.y );
1639
1640 // Also update stored positions for sheet pins
1641 if( schItem->Type() == SCH_SHEET_T )
1642 {
1643 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( schItem );
1644 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1645 {
1646 VECTOR2I pinOldPos = pin->GetStoredPos();
1647 VECTOR2I pinNewPos = pin->GetPosition();
1648 pin->SetStoredPos( pinNewPos );
1649 wxLogTrace( traceSchMove, " sheet pin: stored pos updated (%d,%d) -> (%d,%d)",
1650 pinOldPos.x, pinOldPos.y, pinNewPos.x, pinNewPos.y );
1651 }
1652 }
1653 }
1654
1655 wxLogTrace( traceSchMove, "updateStoredPositions: complete, updated %d items", itemCount );
1656}
1657
1658
1659void SCH_MOVE_TOOL::finalizeMoveOperation( SCH_SELECTION& aSelection, SCH_COMMIT* aCommit, bool aUnselect,
1660 const std::vector<DANGLING_END_ITEM>& aInternalPoints )
1661{
1663 const bool isSlice = ( m_mode == SLICE );
1664 const bool isDragLike = ( m_mode == DRAG || m_mode == BREAK );
1665
1666 // Save whatever new bend lines and changed lines survived the drag
1667 for( SCH_LINE* newLine : m_newDragLines )
1668 {
1669 newLine->ClearEditFlags();
1670 aCommit->Added( newLine, m_frame->GetScreen() );
1671 }
1672
1673 // These lines have been changed, but aren't selected. We need to manually clear these
1674 // edit flags or they'll stick around.
1675 for( SCH_LINE* oldLine : m_changedDragLines )
1676 oldLine->ClearEditFlags();
1677
1678 controls->ForceCursorPosition( false );
1679 controls->ShowCursor( false );
1680 controls->SetAutoPan( false );
1681
1682 m_moveOffset = { 0, 0 };
1683 m_anchorPos.reset();
1684
1685 // One last update after exiting loop (for slower stuff, such as updating SCREEN's RTree)
1686 for( EDA_ITEM* item : aSelection )
1687 {
1688 updateItem( item, true );
1689
1690 if( SCH_ITEM* sch_item = dynamic_cast<SCH_ITEM*>( item ) )
1691 sch_item->SetConnectivityDirty( true );
1692 }
1693
1694 if( aSelection.GetSize() == 1 && aSelection.Front()->IsNew() )
1695 m_frame->SaveCopyForRepeatItem( static_cast<SCH_ITEM*>( aSelection.Front() ) );
1696
1697 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
1698
1700
1701 // If we move items away from a junction, we _may_ want to add a junction there
1702 // to denote the state
1703 for( const DANGLING_END_ITEM& it : aInternalPoints )
1704 {
1705 if( m_frame->GetScreen()->IsExplicitJunctionNeeded( it.GetPosition() ) )
1706 lwbTool->AddJunction( aCommit, m_frame->GetScreen(), it.GetPosition() );
1707 }
1708
1709 // Create a selection of original selection, drag selected/changed items, and new bend
1710 // lines for later before we clear them in the aCommit. We'll need these to check for new
1711 // junctions needed, etc.
1712 SCH_SELECTION selectionCopy( aSelection );
1713
1714 for( SCH_LINE* line : m_newDragLines )
1715 selectionCopy.Add( line );
1716
1717 for( SCH_LINE* line : m_changedDragLines )
1718 selectionCopy.Add( line );
1719
1720 lwbTool->TrimOverLappingWires( aCommit, &selectionCopy );
1721 lwbTool->AddJunctionsIfNeeded( aCommit, &selectionCopy );
1722
1723 // This needs to run prior to `RecalculateConnections` because we need to identify the
1724 // lines that are newly dangling
1725 if( isDragLike && !isSlice )
1726 trimDanglingLines( aCommit );
1727
1728 // Auto-rotate any moved labels
1729 for( EDA_ITEM* item : aSelection )
1730 m_frame->AutoRotateItem( m_frame->GetScreen(), static_cast<SCH_ITEM*>( item ) );
1731
1732 m_frame->Schematic().CleanUp( aCommit );
1733
1734 for( EDA_ITEM* item : m_frame->GetScreen()->Items() )
1735 item->ClearEditFlags();
1736
1737 // Ensure any selected item not in screen main list (for instance symbol fields) has its
1738 // edit flags cleared
1739 for( EDA_ITEM* item : selectionCopy )
1740 item->ClearEditFlags();
1741
1742 m_newDragLines.clear();
1743 m_changedDragLines.clear();
1744
1745 if( aUnselect )
1746 m_toolMgr->RunAction( ACTIONS::selectionClear );
1747 else
1748 m_selectionTool->RebuildSelection(); // Schematic cleanup might have merged lines, etc.
1749}
1750
1751
1753 SCH_COMMIT* aCommit )
1754{
1755 SCH_SCREEN* destScreen = aTargetSheet->GetScreen();
1756 SCH_SCREEN* srcScreen = m_frame->GetScreen();
1757
1758 BOX2I bbox;
1759
1760 for( EDA_ITEM* item : aSelection )
1761 bbox.Merge( static_cast<SCH_ITEM*>( item )->GetBoundingBox() );
1762
1763 VECTOR2I offset = VECTOR2I( 0, 0 ) - bbox.GetPosition();
1764 int step = schIUScale.MilsToIU( 50 );
1765 bool overlap = false;
1766
1767 do
1768 {
1769 BOX2I moved = bbox;
1770 moved.Move( offset );
1771 overlap = false;
1772
1773 for( SCH_ITEM* existing : destScreen->Items() )
1774 {
1775 if( moved.Intersects( existing->GetBoundingBox() ) )
1776 {
1777 overlap = true;
1778 break;
1779 }
1780 }
1781
1782 if( overlap )
1783 offset += VECTOR2I( step, step );
1784 } while( overlap );
1785
1786 for( EDA_ITEM* item : aSelection )
1787 {
1788 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
1789
1790 // Remove from current screen and view manually
1791 m_frame->RemoveFromScreen( schItem, srcScreen );
1792
1793 // Move the item
1794 schItem->Move( offset );
1795
1796 // Add to destination screen manually (won't add to view since it's not current)
1797 destScreen->Append( schItem );
1798
1799 // Record in commit with CHT_DONE flag to bypass automatic screen/view operations
1800 aCommit->Stage( schItem, CHT_REMOVE | CHT_DONE, srcScreen );
1801 aCommit->Stage( schItem, CHT_ADD | CHT_DONE, destScreen );
1802 }
1803}
1804
1805
1807{
1808 // Need a local cleanup first to ensure we remove unneeded junctions
1809 m_frame->Schematic().CleanUp( aCommit, m_frame->GetScreen() );
1810
1811 std::set<SCH_ITEM*> danglers;
1812
1813 std::function<void( SCH_ITEM* )> changeHandler =
1814 [&]( SCH_ITEM* aChangedItem ) -> void
1815 {
1816 m_toolMgr->GetView()->Update( aChangedItem, KIGFX::REPAINT );
1817
1818 // Delete newly dangling lines:
1819 // Find split segments (one segment is new, the other is changed) that
1820 // we aren't dragging and don't have selected
1821 if( aChangedItem->HasFlag( IS_BROKEN) && aChangedItem->IsDangling()
1822 && !aChangedItem->IsSelected() )
1823 {
1824 danglers.insert( aChangedItem );
1825 }
1826 };
1827
1828 m_frame->GetScreen()->TestDanglingEnds( nullptr, &changeHandler );
1829
1830 for( SCH_ITEM* line : danglers )
1831 {
1832 line->SetFlags( STRUCT_DELETED );
1833 aCommit->Removed( line, m_frame->GetScreen() );
1834 updateItem( line, false ); // Update any cached visuals before commit processes
1835 m_frame->RemoveFromScreen( line, m_frame->GetScreen() );
1836 }
1837}
1838
1839
1840void SCH_MOVE_TOOL::getConnectedItems( SCH_ITEM* aOriginalItem, const VECTOR2I& aPoint, EDA_ITEMS& aList )
1841{
1842 EE_RTREE& items = m_frame->GetScreen()->Items();
1843 EE_RTREE::EE_TYPE itemsOverlapping = items.Overlapping( aOriginalItem->GetBoundingBox() );
1844 SCH_ITEM* foundJunction = nullptr;
1845 SCH_ITEM* foundSymbol = nullptr;
1846
1847 // If you're connected to a junction, you're only connected to the junction.
1848 //
1849 // But, if you're connected to a junction on a pin, you're only connected to the pin. This
1850 // is because junctions and pins have different logic for how bend lines are generated and
1851 // we need to prioritize the pin version in some cases.
1852 for( SCH_ITEM* item : itemsOverlapping )
1853 {
1854 if( item != aOriginalItem && item->IsConnected( aPoint ) )
1855 {
1856 if( item->Type() == SCH_JUNCTION_T )
1857 foundJunction = item;
1858 else if( item->Type() == SCH_SYMBOL_T )
1859 foundSymbol = item;
1860 }
1861 }
1862
1863 if( foundSymbol && foundJunction )
1864 {
1865 aList.push_back( foundSymbol );
1866 return;
1867 }
1868
1869 if( foundJunction )
1870 {
1871 aList.push_back( foundJunction );
1872 return;
1873 }
1874
1875
1876 for( SCH_ITEM* test : itemsOverlapping )
1877 {
1878 if( test == aOriginalItem || !test->CanConnect( aOriginalItem ) )
1879 continue;
1880
1881 switch( test->Type() )
1882 {
1883 case SCH_LINE_T:
1884 {
1885 SCH_LINE* line = static_cast<SCH_LINE*>( test );
1886
1887 // When getting lines for the connection cache, it's important that we only add
1888 // items at the unselected end, since that is the only end that is handled specially.
1889 // Fully selected lines, and the selected end of a partially selected line, are moved
1890 // around normally and don't care about their connections.
1891 if( ( line->HasFlag( STARTPOINT ) && aPoint == line->GetStartPoint() )
1892 || ( line->HasFlag( ENDPOINT ) && aPoint == line->GetEndPoint() ) )
1893 {
1894 continue;
1895 }
1896
1897 if( test->IsConnected( aPoint ) )
1898 aList.push_back( test );
1899
1900 // Labels can connect to a wire (or bus) anywhere along the length
1901 if( SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( aOriginalItem ) )
1902 {
1903 if( static_cast<SCH_LINE*>( test )->HitTest( label->GetPosition(), 1 ) )
1904 aList.push_back( test );
1905 }
1906
1907 break;
1908 }
1909
1910 case SCH_SHEET_T:
1911 if( aOriginalItem->Type() == SCH_LINE_T )
1912 {
1913 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
1914
1915 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( test )->GetPins() )
1916 {
1917 if( pin->IsConnected( aPoint ) )
1918 {
1919 if( pin->IsSelected() )
1920 m_specialCaseSheetPins[pin] = { line, line->GetStartPoint() == aPoint };
1921
1922 aList.push_back( pin );
1923 }
1924 }
1925 }
1926
1927 break;
1928
1929 case SCH_SYMBOL_T:
1930 case SCH_JUNCTION_T:
1931 case SCH_NO_CONNECT_T:
1932 if( test->IsConnected( aPoint ) )
1933 aList.push_back( test );
1934
1935 break;
1936
1937 case SCH_LABEL_T:
1938 case SCH_GLOBAL_LABEL_T:
1939 case SCH_HIER_LABEL_T:
1941 // Labels can connect to a wire (or bus) anywhere along the length
1942 if( aOriginalItem->Type() == SCH_LINE_T && test->CanConnect( aOriginalItem ) )
1943 {
1944 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( test );
1945 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
1946
1947 if( line->HitTest( label->GetPosition(), 1 ) )
1948 aList.push_back( label );
1949 }
1950
1951 break;
1952
1955 if( aOriginalItem->Type() == SCH_LINE_T && test->CanConnect( aOriginalItem ) )
1956 {
1957 SCH_TEXT* label = static_cast<SCH_TEXT*>( test );
1958 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
1959
1960 if( line->HitTest( aPoint, 1 ) )
1961 aList.push_back( label );
1962 }
1963
1964 break;
1965
1966 default:
1967 break;
1968 }
1969 }
1970}
1971
1972
1973void SCH_MOVE_TOOL::getConnectedDragItems( SCH_COMMIT* aCommit, SCH_ITEM* aSelectedItem, const VECTOR2I& aPoint,
1974 EDA_ITEMS& aList )
1975{
1976 EE_RTREE& items = m_frame->GetScreen()->Items();
1977 EE_RTREE::EE_TYPE itemsOverlappingRTree = items.Overlapping( aSelectedItem->GetBoundingBox() );
1978 std::vector<SCH_ITEM*> itemsConnectable;
1979 bool ptHasUnselectedJunction = false;
1980
1981 auto makeNewWire =
1982 [this]( SCH_COMMIT* commit, SCH_ITEM* fixed, SCH_ITEM* selected, const VECTOR2I& start,
1983 const VECTOR2I& end )
1984 {
1985 SCH_LINE* newWire;
1986
1987 // Add a new newWire between the fixed item and the selected item so the selected
1988 // item can be dragged.
1989 if( fixed->GetLayer() == LAYER_BUS_JUNCTION || fixed->GetLayer() == LAYER_BUS
1990 || selected->GetLayer() == LAYER_BUS )
1991 {
1992 newWire = new SCH_LINE( start, LAYER_BUS );
1993 }
1994 else
1995 {
1996 newWire = new SCH_LINE( start, LAYER_WIRE );
1997 }
1998
1999 newWire->SetFlags( IS_NEW );
2000 newWire->SetConnectivityDirty( true );
2001
2002 SCH_LINE* selectedLine = dynamic_cast<SCH_LINE*>( selected );
2003 SCH_LINE* fixedLine = dynamic_cast<SCH_LINE*>( fixed );
2004
2005 if( selectedLine )
2006 {
2007 newWire->SetLastResolvedState( selected );
2008 cloneWireConnection( newWire, selectedLine, m_frame );
2009 }
2010 else if( fixedLine )
2011 {
2012 newWire->SetLastResolvedState( fixed );
2013 cloneWireConnection( newWire, fixedLine, m_frame );
2014 }
2015
2016 newWire->SetEndPoint( end );
2017 m_frame->AddToScreen( newWire, m_frame->GetScreen() );
2018 commit->Added( newWire, m_frame->GetScreen() );
2019
2020 return newWire;
2021 };
2022
2023 auto makeNewJunction =
2024 [this]( SCH_COMMIT* commit, SCH_LINE* line, const VECTOR2I& pt )
2025 {
2026 SCH_JUNCTION* junction = new SCH_JUNCTION( pt );
2027 junction->SetFlags( IS_NEW );
2028 junction->SetConnectivityDirty( true );
2029 junction->SetLastResolvedState( line );
2030
2031 if( line->IsBus() )
2032 junction->SetLayer( LAYER_BUS_JUNCTION );
2033
2034 m_frame->AddToScreen( junction, m_frame->GetScreen() );
2035 commit->Added( junction, m_frame->GetScreen() );
2036
2037 return junction;
2038 };
2039
2040 for( SCH_ITEM* item : itemsOverlappingRTree )
2041 {
2042 if( item->Type() == SCH_SHEET_T )
2043 {
2044 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
2045
2046 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
2047 {
2048 if( !pin->IsSelected()
2049 && pin->GetPosition() == aPoint
2050 && pin->CanConnect( aSelectedItem ) )
2051 {
2052 itemsConnectable.push_back( pin );
2053 }
2054 }
2055
2056 continue;
2057 }
2058
2059 // Skip ourselves, skip already selected items (but not lines, they need both ends tested)
2060 // and skip unconnectable items
2061 if( item == aSelectedItem
2062 || ( item->Type() != SCH_LINE_T && item->IsSelected() )
2063 || !item->CanConnect( aSelectedItem ) )
2064 {
2065 continue;
2066 }
2067
2068 itemsConnectable.push_back( item );
2069 }
2070
2071 for( SCH_ITEM* item : itemsConnectable )
2072 {
2073 if( item->Type() == SCH_JUNCTION_T && item->IsConnected( aPoint ) && !item->IsSelected() )
2074 {
2075 ptHasUnselectedJunction = true;
2076 break;
2077 }
2078 }
2079
2080 SCH_LINE* newWire = nullptr;
2081
2082 for( SCH_ITEM* test : itemsConnectable )
2083 {
2084 KICAD_T testType = test->Type();
2085
2086 switch( testType )
2087 {
2088 case SCH_LINE_T:
2089 {
2090 // Select the connected end of wires/bus connections that don't have an unselected
2091 // junction isolating them from the drag
2092 if( ptHasUnselectedJunction )
2093 break;
2094
2095 SCH_LINE* line = static_cast<SCH_LINE*>( test );
2096
2097 if( line->GetStartPoint() == aPoint )
2098 {
2099 // It's possible to manually select one end of a line and get a drag
2100 // connected other end, so we set the flag and then early exit the loop
2101 // later if the other drag items like labels attached to the line have
2102 // already been grabbed during the partial selection process.
2103 line->SetFlags( STARTPOINT );
2104
2105 if( line->HasFlag( SELECTED ) || line->HasFlag( SELECTED_BY_DRAG ) )
2106 {
2107 continue;
2108 }
2109 else
2110 {
2111 line->SetFlags( SELECTED_BY_DRAG );
2112 aList.push_back( line );
2113 }
2114 }
2115 else if( line->GetEndPoint() == aPoint )
2116 {
2117 line->SetFlags( ENDPOINT );
2118
2119 if( line->HasFlag( SELECTED ) || line->HasFlag( SELECTED_BY_DRAG ) )
2120 {
2121 continue;
2122 }
2123 else
2124 {
2125 line->SetFlags( SELECTED_BY_DRAG );
2126 aList.push_back( line );
2127 }
2128 }
2129 else
2130 {
2131 switch( aSelectedItem->Type() )
2132 {
2133 // These items can connect anywhere along a line
2136 case SCH_LABEL_T:
2137 case SCH_HIER_LABEL_T:
2138 case SCH_GLOBAL_LABEL_T:
2140 // Only add a line if this line is unselected; if the label and line are both
2141 // selected they'll move together
2142 if( line->HitTest( aPoint, 1 ) && !line->HasFlag( SELECTED )
2143 && !line->HasFlag( SELECTED_BY_DRAG ) )
2144 {
2145 newWire = makeNewWire( aCommit, line, aSelectedItem, aPoint, aPoint );
2146 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
2147 newWire->StoreAngle( ( line->Angle() + ANGLE_90 ).Normalize() );
2148 aList.push_back( newWire );
2149
2150 if( aPoint != line->GetStartPoint() && aPoint != line->GetEndPoint() )
2151 {
2152 // Split line in half
2153 aCommit->Modify( line, m_frame->GetScreen() );
2154
2155 VECTOR2I oldEnd = line->GetEndPoint();
2156 line->SetEndPoint( aPoint );
2157
2158 makeNewWire( aCommit, line, line, aPoint, oldEnd );
2159 makeNewJunction( aCommit, line, aPoint );
2160 }
2161 else
2162 {
2163 m_lineConnectionCache[ newWire ] = { line };
2164 m_lineConnectionCache[ line ] = { newWire };
2165 }
2166 }
2167 break;
2168
2169 default:
2170 break;
2171 }
2172
2173 break;
2174 }
2175
2176 // Since only one end is going to move, the movement vector of any labels attached to
2177 // it is scaled by the proportion of the line length the label is from the moving end.
2178 for( SCH_ITEM* item : items.Overlapping( line->GetBoundingBox() ) )
2179 {
2180 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( item );
2181
2182 if( !label || label->IsSelected() )
2183 continue; // These will be moved on their own because they're selected
2184
2185 if( label->HasFlag( SELECTED_BY_DRAG ) )
2186 continue;
2187
2188 if( label->CanConnect( line ) && line->HitTest( label->GetPosition(), 1 ) )
2189 {
2190 label->SetFlags( SELECTED_BY_DRAG );
2191 aList.push_back( label );
2192
2194 info.attachedLine = line;
2195 info.originalLabelPos = label->GetPosition();
2196 m_specialCaseLabels[label] = info;
2197 }
2198 }
2199
2200 break;
2201 }
2202
2203 case SCH_SHEET_T:
2204 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( test )->GetPins() )
2205 {
2206 if( pin->IsConnected( aPoint ) )
2207 {
2208 if( pin->IsSelected() && aSelectedItem->Type() == SCH_LINE_T )
2209 {
2210 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
2211 m_specialCaseSheetPins[ pin ] = { line, line->GetStartPoint() == aPoint };
2212 }
2213 else if( !newWire )
2214 {
2215 // Add a new wire between the sheetpin and the selected item so the
2216 // selected item can be dragged.
2217 newWire = makeNewWire( aCommit, pin, aSelectedItem, aPoint, aPoint );
2218 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
2219 aList.push_back( newWire );
2220 }
2221 }
2222 }
2223
2224 break;
2225
2226 case SCH_SYMBOL_T:
2227 case SCH_JUNCTION_T:
2228 if( test->IsConnected( aPoint ) )
2229 {
2230 if( test->Type() == SCH_JUNCTION_T && test->GetPosition() == aPoint )
2231 {
2232 test->SetFlags( SELECTED_BY_DRAG );
2233 aList.push_back( test );
2234 }
2235 else if( !newWire )
2236 {
2237 // Add a new wire between the symbol or junction and the selected item so
2238 // the selected item can be dragged.
2239 newWire = makeNewWire( aCommit, test, aSelectedItem, aPoint, aPoint );
2240 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
2241 aList.push_back( newWire );
2242 }
2243 }
2244
2245 break;
2246
2247 case SCH_NO_CONNECT_T:
2248 // Select no-connects that are connected to items being moved.
2249 if( !test->HasFlag( SELECTED_BY_DRAG ) && test->IsConnected( aPoint ) )
2250 {
2251 aList.push_back( test );
2252 test->SetFlags( SELECTED_BY_DRAG );
2253 }
2254
2255 break;
2256
2257 case SCH_LABEL_T:
2258 case SCH_GLOBAL_LABEL_T:
2259 case SCH_HIER_LABEL_T:
2261 case SCH_SHEET_PIN_T:
2262 // Performance optimization:
2263 if( test->HasFlag( SELECTED_BY_DRAG ) )
2264 break;
2265
2266 // Select labels that are connected to a wire (or bus) being moved.
2267 if( aSelectedItem->Type() == SCH_LINE_T && test->CanConnect( aSelectedItem ) )
2268 {
2269 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( test );
2270 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
2271
2272 bool oneEndFixed = !line->HasFlag( STARTPOINT ) || !line->HasFlag( ENDPOINT );
2273
2274 if( line->HitTest( label->GetTextPos(), 1 ) )
2275 {
2276 if( ( !line->HasFlag( STARTPOINT ) && label->GetPosition() == line->GetStartPoint() )
2277 || ( !line->HasFlag( ENDPOINT ) && label->GetPosition() == line->GetEndPoint() ) )
2278 {
2279 //If we have a line selected at only one end, don't grab labels
2280 //connected directly to the unselected endpoint
2281 break;
2282 }
2283 else
2284 {
2285 label->SetFlags( SELECTED_BY_DRAG );
2286 aList.push_back( label );
2287
2288 if( oneEndFixed )
2289 {
2291 info.attachedLine = line;
2292 info.originalLabelPos = label->GetPosition();
2293 m_specialCaseLabels[label] = info;
2294 }
2295 }
2296 }
2297 }
2298 else if( test->IsConnected( aPoint ) && !newWire )
2299 {
2300 // Add a new wire between the label and the selected item so the selected item
2301 // can be dragged.
2302 newWire = makeNewWire( aCommit, test, aSelectedItem, aPoint, aPoint );
2303 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
2304 aList.push_back( newWire );
2305 }
2306
2307 break;
2308
2311 // Performance optimization:
2312 if( test->HasFlag( SELECTED_BY_DRAG ) )
2313 break;
2314
2315 // Select bus entries that are connected to a bus being moved.
2316 if( aSelectedItem->Type() == SCH_LINE_T && test->CanConnect( aSelectedItem ) )
2317 {
2318 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
2319
2320 if( ( !line->HasFlag( STARTPOINT ) && test->IsConnected( line->GetStartPoint() ) )
2321 || ( !line->HasFlag( ENDPOINT ) && test->IsConnected( line->GetEndPoint() ) ) )
2322 {
2323 // If we have a line selected at only one end, don't grab bus entries
2324 // connected directly to the unselected endpoint
2325 continue;
2326 }
2327
2328 for( VECTOR2I& point : test->GetConnectionPoints() )
2329 {
2330 if( line->HitTest( point, 1 ) )
2331 {
2332 test->SetFlags( SELECTED_BY_DRAG );
2333 aList.push_back( test );
2334
2335 // A bus entry needs its wire & label as well
2336 std::vector<VECTOR2I> ends = test->GetConnectionPoints();
2337 VECTOR2I otherEnd;
2338
2339 if( ends[0] == point )
2340 otherEnd = ends[1];
2341 else
2342 otherEnd = ends[0];
2343
2344 getConnectedDragItems( aCommit, test, otherEnd, aList );
2345
2346 // No need to test the other end of the bus entry
2347 break;
2348 }
2349 }
2350 }
2351
2352 break;
2353
2354 default:
2355 break;
2356 }
2357 }
2358}
2359
2360
2361void SCH_MOVE_TOOL::moveItem( EDA_ITEM* aItem, const VECTOR2I& aDelta )
2362{
2363 static int moveCallCount = 0;
2364 wxLogTrace( traceSchMove, "moveItem[%d]: type=%d, delta=(%d,%d)",
2365 ++moveCallCount, aItem->Type(), aDelta.x, aDelta.y );
2366
2367 switch( aItem->Type() )
2368 {
2369 case SCH_LINE_T:
2370 {
2371 SCH_LINE* line = static_cast<SCH_LINE*>( aItem );
2372
2373 if( aItem->HasFlag( STARTPOINT ) || ( m_mode == MOVE ) )
2374 line->MoveStart( aDelta );
2375
2376 if( aItem->HasFlag( ENDPOINT ) || ( m_mode == MOVE ) )
2377 line->MoveEnd( aDelta );
2378
2379 break;
2380 }
2381
2382 case SCH_PIN_T:
2383 case SCH_FIELD_T:
2384 {
2385 SCH_ITEM* parent = (SCH_ITEM*) aItem->GetParent();
2386 VECTOR2I delta( aDelta );
2387
2388 if( parent && parent->Type() == SCH_SYMBOL_T )
2389 {
2390 SCH_SYMBOL* symbol = (SCH_SYMBOL*) aItem->GetParent();
2391 TRANSFORM transform = symbol->GetTransform().InverseTransform();
2392
2393 delta = transform.TransformCoordinate( delta );
2394 }
2395
2396 static_cast<SCH_ITEM*>( aItem )->Move( delta );
2397
2398 // If we're moving a field with respect to its parent then it's no longer auto-placed
2399 if( aItem->Type() == SCH_FIELD_T && parent && !parent->IsSelected() )
2401
2402 break;
2403 }
2404
2405 case SCH_SHEET_PIN_T:
2406 {
2407 SCH_SHEET_PIN* pin = (SCH_SHEET_PIN*) aItem;
2408
2409 pin->SetStoredPos( pin->GetStoredPos() + aDelta );
2410 pin->ConstrainOnEdge( pin->GetStoredPos(), true );
2411 break;
2412 }
2413
2414 case SCH_LABEL_T:
2416 case SCH_GLOBAL_LABEL_T:
2417 case SCH_HIER_LABEL_T:
2418 {
2419 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( aItem );
2420
2421 if( m_specialCaseLabels.count( label ) )
2422 {
2424 SEG currentLine( info.attachedLine->GetStartPoint(), info.attachedLine->GetEndPoint() );
2425 label->SetPosition( currentLine.NearestPoint( info.originalLabelPos ) );
2426 }
2427 else
2428 {
2429 label->Move( aDelta );
2430 }
2431
2432 break;
2433 }
2434
2435 default:
2436 static_cast<SCH_ITEM*>( aItem )->Move( aDelta );
2437 break;
2438 }
2439
2440 aItem->SetFlags( IS_MOVING );
2441}
2442
2443
2445{
2447 SCH_SELECTION& selection = m_selectionTool->RequestSelection( SCH_COLLECTOR::MovableItems );
2448 GRID_HELPER_GRIDS selectionGrid = grid.GetSelectionGrid( selection );
2449 SCH_COMMIT commit( m_toolMgr );
2450
2451 auto doMoveItem =
2452 [&]( EDA_ITEM* item, const VECTOR2I& delta )
2453 {
2454 commit.Modify( item, m_frame->GetScreen(), RECURSE_MODE::RECURSE );
2455
2456 // Ensure only one end is moved when calling moveItem
2457 // i.e. we are in drag mode
2458 MOVE_MODE tmpMode = m_mode;
2459 m_mode = DRAG;
2460 moveItem( item, delta );
2461 m_mode = tmpMode;
2462
2463 item->ClearFlags( IS_MOVING );
2464 updateItem( item, true );
2465 };
2466
2467 for( SCH_ITEM* it : m_frame->GetScreen()->Items() )
2468 {
2469 if( !it->IsSelected() )
2470 it->ClearFlags( STARTPOINT | ENDPOINT );
2471
2472 if( !selection.IsHover() && it->IsSelected() )
2473 it->SetFlags( STARTPOINT | ENDPOINT );
2474
2475 it->SetStoredPos( it->GetPosition() );
2476
2477 if( it->Type() == SCH_SHEET_T )
2478 {
2479 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( it )->GetPins() )
2480 pin->SetStoredPos( pin->GetPosition() );
2481 }
2482 }
2483
2484 for( EDA_ITEM* item : selection )
2485 {
2486 if( item->Type() == SCH_LINE_T )
2487 {
2488 SCH_LINE* line = static_cast<SCH_LINE*>( item );
2489 std::vector<int> flags{ STARTPOINT, ENDPOINT };
2490 std::vector<VECTOR2I> pts{ line->GetStartPoint(), line->GetEndPoint() };
2491
2492 for( int ii = 0; ii < 2; ++ii )
2493 {
2494 EDA_ITEMS drag_items{ item };
2495 line->ClearFlags();
2496 line->SetFlags( SELECTED );
2497 line->SetFlags( flags[ii] );
2498 getConnectedDragItems( &commit, line, pts[ii], drag_items );
2499 std::set<EDA_ITEM*> unique_items( drag_items.begin(), drag_items.end() );
2500
2501 VECTOR2I delta = grid.AlignGrid( pts[ii], selectionGrid ) - pts[ii];
2502
2503 if( delta != VECTOR2I( 0, 0 ) )
2504 {
2505 for( EDA_ITEM* dragItem : unique_items )
2506 {
2507 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
2508 continue;
2509
2510 doMoveItem( dragItem, delta );
2511 }
2512 }
2513 }
2514 }
2515 else if( item->Type() == SCH_FIELD_T || item->Type() == SCH_TEXT_T )
2516 {
2517 VECTOR2I delta = grid.AlignGrid( item->GetPosition(), selectionGrid ) - item->GetPosition();
2518
2519 if( delta != VECTOR2I( 0, 0 ) )
2520 doMoveItem( item, delta );
2521 }
2522 else if( item->Type() == SCH_SHEET_T )
2523 {
2524 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
2525 VECTOR2I topLeft = sheet->GetPosition();
2526 VECTOR2I bottomRight = topLeft + sheet->GetSize();
2527 VECTOR2I tl_delta = grid.AlignGrid( topLeft, selectionGrid ) - topLeft;
2528 VECTOR2I br_delta = grid.AlignGrid( bottomRight, selectionGrid ) - bottomRight;
2529
2530 if( tl_delta != VECTOR2I( 0, 0 ) || br_delta != VECTOR2I( 0, 0 ) )
2531 {
2532 doMoveItem( sheet, tl_delta );
2533
2534 VECTOR2I newSize = (VECTOR2I) sheet->GetSize() - tl_delta + br_delta;
2535 sheet->SetSize( VECTOR2I( newSize.x, newSize.y ) );
2536 updateItem( sheet, true );
2537 }
2538
2539 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
2540 {
2541 VECTOR2I newPos;
2542
2543 if( pin->GetSide() == SHEET_SIDE::TOP || pin->GetSide() == SHEET_SIDE::LEFT )
2544 newPos = pin->GetPosition() + tl_delta;
2545 else
2546 newPos = pin->GetPosition() + br_delta;
2547
2548 VECTOR2I delta = grid.AlignGrid( newPos - pin->GetPosition(), selectionGrid );
2549
2550 if( delta != VECTOR2I( 0, 0 ) )
2551 {
2552 EDA_ITEMS drag_items;
2553 getConnectedDragItems( &commit, pin, pin->GetConnectionPoints()[0],
2554 drag_items );
2555
2556 doMoveItem( pin, delta );
2557
2558 for( EDA_ITEM* dragItem : drag_items )
2559 {
2560 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
2561 continue;
2562
2563 doMoveItem( dragItem, delta );
2564 }
2565 }
2566 }
2567 }
2568 else
2569 {
2570 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
2571 std::vector<VECTOR2I> connections = schItem->GetConnectionPoints();
2572 EDA_ITEMS drag_items;
2573
2574 for( const VECTOR2I& point : connections )
2575 getConnectedDragItems( &commit, schItem, point, drag_items );
2576
2577 std::map<VECTOR2I, int> shifts;
2578 VECTOR2I most_common( 0, 0 );
2579 int max_count = 0;
2580
2581 for( const VECTOR2I& conn : connections )
2582 {
2583 VECTOR2I gridpt = grid.AlignGrid( conn, selectionGrid ) - conn;
2584
2585 shifts[gridpt]++;
2586
2587 if( shifts[gridpt] > max_count )
2588 {
2589 most_common = gridpt;
2590 max_count = shifts[most_common];
2591 }
2592 }
2593
2594 if( most_common != VECTOR2I( 0, 0 ) )
2595 {
2596 doMoveItem( item, most_common );
2597
2598 for( EDA_ITEM* dragItem : drag_items )
2599 {
2600 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
2601 continue;
2602
2603 doMoveItem( dragItem, most_common );
2604 }
2605 }
2606 }
2607 }
2608
2610 lwbTool->TrimOverLappingWires( &commit, &selection );
2611 lwbTool->AddJunctionsIfNeeded( &commit, &selection );
2612
2614
2615 m_frame->Schematic().CleanUp( &commit );
2616 commit.Push( _( "Align Items to Grid" ) );
2617 return 0;
2618}
2619
2620
2622{
2623 // Remove new bend lines added during the drag
2624 for( SCH_LINE* newLine : m_newDragLines )
2625 {
2626 m_frame->RemoveFromScreen( newLine, m_frame->GetScreen() );
2627 delete newLine;
2628 }
2629
2630 m_newDragLines.clear();
2631}
2632
2633
constexpr EDA_IU_SCALE schIUScale
Definition base_units.h:114
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
@ CURSOR_RIGHT
Definition actions.h:311
@ CURSOR_LEFT
Definition actions.h:309
@ CURSOR_UP
Definition actions.h:305
@ CURSOR_DOWN
Definition actions.h:307
static TOOL_ACTION undo
Definition actions.h:75
static TOOL_ACTION duplicate
Definition actions.h:84
static TOOL_ACTION doDelete
Definition actions.h:85
static TOOL_ACTION cursorClick
Definition actions.h:180
static TOOL_ACTION redo
Definition actions.h:76
static TOOL_ACTION increment
Definition actions.h:94
static TOOL_ACTION selectionClear
Clear the current selection.
Definition actions.h:224
static TOOL_ACTION refreshPreview
Definition actions.h:159
constexpr const Vec & GetPosition() const
Definition box2.h:211
constexpr coord_type GetY() const
Definition box2.h:208
constexpr size_type GetWidth() const
Definition box2.h:214
constexpr coord_type GetX() const
Definition box2.h:207
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition box2.h:658
constexpr size_type GetHeight() const
Definition box2.h:215
constexpr bool Contains(const Vec &aPoint) const
Definition box2.h:168
COMMIT & Added(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Notify observers that aItem has been added.
Definition commit.h:84
COMMIT & Modify(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr, RECURSE_MODE aRecurse=RECURSE_MODE::NO_RECURSE)
Modify a given item in the model.
Definition commit.h:106
COMMIT & Removed(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Definition commit.h:96
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Add a menu entry to run a TOOL_ACTION on selected items.
static void sort_dangling_end_items(std::vector< DANGLING_END_ITEM > &aItemListByType, std::vector< DANGLING_END_ITEM > &aItemListByPos)
Both contain the same information.
Definition sch_item.cpp:953
Helper class used to store the state of schematic items that can be connected to other schematic item...
Definition sch_item.h:96
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
virtual VECTOR2I GetPosition() const
Definition eda_item.h:278
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
Definition eda_item.cpp:110
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition eda_item.h:148
virtual EDA_GROUP * GetParentGroup() const
Definition eda_item.h:116
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition eda_item.h:150
bool IsSelected() const
Definition eda_item.h:127
EDA_ITEM * GetParent() const
Definition eda_item.h:112
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:152
bool IsNew() const
Definition eda_item.h:124
const VECTOR2I & GetTextPos() const
Definition eda_text.h:273
Implement an R-tree for fast spatial and type indexing of schematic items.
Definition sch_rtree.h:40
EE_TYPE Overlapping(const BOX2I &aRect) const
Definition sch_rtree.h:246
static const TOOL_EVENT SelectedItemsMoved
Used to inform tools that the selection should temporarily be non-editable.
Definition actions.h:355
An interface for classes handling user events controlling the view behavior such as zooming,...
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Place the cursor immediately at a given point.
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
virtual void SetCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true, bool aTriggeredByArrows=false, long aArrowCommand=0)=0
Move cursor to the requested position expressed in world coordinates.
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
const VC_SETTINGS & GetSettings() const
Return the current VIEW_CONTROLS settings.
static TOOL_ACTION rotateCCW
static TOOL_ACTION breakWire
static TOOL_ACTION toText
static TOOL_ACTION restartMove
static TOOL_ACTION toHLabel
static TOOL_ACTION rotateCW
static TOOL_ACTION drag
static TOOL_ACTION toLabel
static TOOL_ACTION alignToGrid
static TOOL_ACTION toDLabel
static TOOL_ACTION slice
static TOOL_ACTION toTextBox
static TOOL_ACTION highlightNet
static TOOL_ACTION repeatDrawItem
static TOOL_ACTION toGLabel
static TOOL_ACTION selectOnPCB
static TOOL_ACTION move
static const std::vector< KICAD_T > MovableItems
COMMIT & Stage(EDA_ITEM *aItem, CHANGE_TYPE aChangeType, BASE_SCREEN *aScreen=nullptr, RECURSE_MODE aRecurse=RECURSE_MODE::NO_RECURSE) override
Add a change of the item aItem of type aChangeType to the change list.
virtual void Push(const wxString &aMessage=wxT("A commit"), int aCommitFlags=0) override
Execute the changes.
virtual void Revert() override
Revert the commit by restoring the modified items state.
Each graphical item can have a SCH_CONNECTION describing its logical connection (to a bus or net).
void Clone(const SCH_CONNECTION &aOther)
Copies connectivity information (but not parent) from another connection.
Schematic editor (Eeschema) main window.
SCH_SHEET_PATH & GetCurrentSheet() const
A set of SCH_ITEMs (i.e., without duplicates).
Definition sch_group.h:52
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition sch_item.h:167
void SetStoredPos(const VECTOR2I &aPos)
Definition sch_item.h:304
virtual bool CanConnect(const SCH_ITEM *aItem) const
Definition sch_item.h:521
virtual void RunOnChildren(const std::function< void(SCH_ITEM *)> &aFunction, RECURSE_MODE aMode)
Definition sch_item.h:630
int GetBodyStyle() const
Definition sch_item.h:247
SCH_CONNECTION * InitializeConnection(const SCH_SHEET_PATH &aPath, CONNECTION_GRAPH *aGraph)
Create a new connection object associated with this object.
Definition sch_item.cpp:554
virtual void Move(const VECTOR2I &aMoveVector)
Move the item by aMoveVector to a new position.
Definition sch_item.h:398
void SetLayer(SCH_LAYER_ID aLayer)
Definition sch_item.h:341
void SetConnectivityDirty(bool aDirty=true)
Definition sch_item.h:589
void SetFieldsAutoplaced(AUTOPLACE_ALGO aAlgo)
Definition sch_item.h:626
bool IsConnected(const VECTOR2I &aPoint) const
Test the item to see if it is connected to aPoint.
Definition sch_item.cpp:457
virtual bool IsMovableFromAnchorPoint() const
Check if object is movable from the anchor point.
Definition sch_item.h:301
SCH_CONNECTION * Connection(const SCH_SHEET_PATH *aSheet=nullptr) const
Retrieve the connection associated with this object in the given sheet.
Definition sch_item.cpp:466
VECTOR2I & GetStoredPos()
Definition sch_item.h:303
bool IsGroupableType() const
Definition sch_item.cpp:108
virtual std::vector< VECTOR2I > GetConnectionPoints() const
Add all the connection points for this item to aPoints.
Definition sch_item.h:541
void SetLastResolvedState(const SCH_ITEM *aItem) override
void Move(const VECTOR2I &aMoveVector) override
Move the item by aMoveVector to a new position.
void SetPosition(const VECTOR2I &aPosition) override
bool CanConnect(const SCH_ITEM *aItem) const override
Definition sch_label.h:148
Tool responsible for drawing/placing items (symbols, wires, buses, labels, etc.)
int AddJunctionsIfNeeded(SCH_COMMIT *aCommit, SCH_SELECTION *aSelection)
Handle the addition of junctions to a selection of objects.
SCH_JUNCTION * AddJunction(SCH_COMMIT *aCommit, SCH_SCREEN *aScreen, const VECTOR2I &aPos)
int TrimOverLappingWires(SCH_COMMIT *aCommit, SCH_SELECTION *aSelection)
Logic to remove wires when overlapping correct items.
static bool IsDrawingLineWireOrBus(const SELECTION &aSelection)
void BreakSegment(SCH_COMMIT *aCommit, SCH_LINE *aSegment, const VECTOR2I &aPoint, SCH_LINE **aNewSegment, SCH_SCREEN *aScreen)
Break a single segment into two at the specified point.
Segment description base class to describe items which have 2 end points (track, wire,...
Definition sch_line.h:42
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
Definition sch_line.cpp:816
void StoreAngle()
Save the current line angle.
Definition sch_line.h:115
std::vector< VECTOR2I > GetConnectionPoints() const override
Add all the connection points for this item to aPoints.
Definition sch_line.cpp:716
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition sch_line.cpp:233
EDA_ANGLE Angle() const
Get the angle between the start and end lines.
Definition sch_line.h:104
VECTOR2I GetEndPoint() const
Definition sch_line.h:148
VECTOR2I GetStartPoint() const
Definition sch_line.h:139
void MoveEnd(const VECTOR2I &aMoveVector)
Definition sch_line.cpp:178
void SetLastResolvedState(const SCH_ITEM *aItem) override
Definition sch_line.h:163
void MoveStart(const VECTOR2I &aMoveVector)
Definition sch_line.cpp:172
double GetLength() const
Definition sch_line.cpp:249
void SetEndPoint(const VECTOR2I &aPosition)
Definition sch_line.h:149
void moveSelectionToSheet(SCH_SELECTION &aSelection, SCH_SHEET *aTarget, SCH_COMMIT *aCommit)
Clears the new drag lines and removes them from the screen.
void refreshSelectionTraits(const SCH_SELECTION &aSelection, bool &aHasSheetPins, bool &aHasGraphicItems, bool &aHasNonGraphicItems, bool &aIsGraphicsOnly)
Initialize the move/drag operation, setting up flags and connections.
bool Init() override
Init() is called once upon a registration of the tool.
VECTOR2I m_cursor
void trimDanglingLines(SCH_COMMIT *aCommit)
Break or slice the current selection before initiating a move, if required.
void orthoLineDrag(SCH_COMMIT *aCommit, SCH_LINE *line, const VECTOR2I &splitDelta, int &xBendCount, int &yBendCount, const EE_GRID_HELPER &grid)
std::unordered_set< SCH_LINE * > m_newDragLines
Lines changed by drag algorithm that weren't selected.
SCH_SHEET * findTargetSheet(const SCH_SELECTION &aSelection, const VECTOR2I &aCursorPos, bool aHasSheetPins, bool aIsGraphicsOnly, bool aCtrlDown)
Perform the actual move of items by delta, handling split moves and orthogonal dragging.
bool handleMoveToolActions(const TOOL_EVENT *aEvent, SCH_COMMIT *aCommit, const SCH_SELECTION &aSelection)
Update stored positions after transformations (rotation, mirroring, etc.) during move.
bool checkMoveInProgress(const TOOL_EVENT &aEvent, SCH_COMMIT *aCommit, bool aCurrentModeIsDragLike, bool aWasDragging)
< Check if a move is already in progress and handle state transitions
void initializeMoveOperation(const TOOL_EVENT &aEvent, SCH_SELECTION &aSelection, SCH_COMMIT *aCommit, std::vector< DANGLING_END_ITEM > &aInternalPoints, GRID_HELPER_GRIDS &aSnapLayer)
Setup items for drag operation, collecting connected items.
OPT_VECTOR2I m_anchorPos
void performItemMove(SCH_SELECTION &aSelection, const VECTOR2I &aDelta, SCH_COMMIT *aCommit, int &aXBendCount, int &aYBendCount, const EE_GRID_HELPER &aGrid)
Handle tool action events during the move operation.
int Main(const TOOL_EVENT &aEvent)
Run an interactive move of the selected items, or the item under the cursor.
SCH_SELECTION & prepareSelection(bool &aUnselect)
Refresh selection traits (sheet pins, graphic items, etc.)
std::vector< SCH_JUNCTION * > m_hiddenJunctions
void setupItemsForMove(SCH_SELECTION &aSelection, std::vector< DANGLING_END_ITEM > &aInternalPoints)
Find the target sheet for dropping items (if any)
bool m_inMoveTool
< Re-entrancy guard
std::vector< KIID > m_dragAdditions
Cache of the line's original connections before dragging started.
void moveItem(EDA_ITEM *aItem, const VECTOR2I &aDelta)
Find additional items for a drag operation.
void setupItemsForDrag(SCH_SELECTION &aSelection, SCH_COMMIT *aCommit)
Setup items for move operation, marking dangling ends.
std::unordered_set< SCH_LINE * > m_changedDragLines
Junctions that were hidden during the move.
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
void finalizeMoveOperation(SCH_SELECTION &aSelection, SCH_COMMIT *aCommit, bool aUnselect, const std::vector< DANGLING_END_ITEM > &aInternalPoints)
void setTransitions() override
Cleanup dangling lines left after a drag.
void getConnectedItems(SCH_ITEM *aOriginalItem, const VECTOR2I &aPoint, EDA_ITEMS &aList)
std::map< SCH_LINE *, EDA_ITEMS > m_lineConnectionCache
Lines added at bend points dynamically during the move.
OPT_VECTOR2I m_breakPos
void updateStoredPositions(const SCH_SELECTION &aSelection)
Finalize the move operation, updating junctions and cleaning up.
bool doMoveSelection(const TOOL_EVENT &aEvent, SCH_COMMIT *aCommit)
void getConnectedDragItems(SCH_COMMIT *aCommit, SCH_ITEM *fixed, const VECTOR2I &selected, EDA_ITEMS &aList)
VECTOR2I m_moveOffset
Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point).
std::map< SCH_LABEL_BASE *, SPECIAL_CASE_LABEL_INFO > m_specialCaseLabels
int AlignToGrid(const TOOL_EVENT &aEvent)
Align selected elements to the grid.
void clearNewDragLines()
Set up handlers for various events.
MOVE_MODE m_mode
Items (such as wires) which were added to the selection for a drag.
void preprocessBreakOrSliceSelection(SCH_COMMIT *aCommit, const TOOL_EVENT &aEvent)
std::map< SCH_SHEET_PIN *, std::pair< SCH_LINE *, bool > > m_specialCaseSheetPins
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
EE_RTREE & Items()
Get the full RTree, usually for iterating.
Definition sch_screen.h:118
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition sch_sheet.h:48
void SetSize(const VECTOR2I &aSize)
Definition sch_sheet.h:148
bool IsTopLevelSheet() const
Check if this sheet is a top-level sheet.
VECTOR2I GetSize() const
Definition sch_sheet.h:147
SCH_SCREEN * GetScreen() const
Definition sch_sheet.h:145
VECTOR2I GetPosition() const override
Definition sch_sheet.h:496
const BOX2I GetBodyBoundingBox() const
Return a bounding box for the sheet body but not the fields.
std::vector< SCH_SHEET_PIN * > & GetPins()
Definition sch_sheet.h:233
Schematic symbol object.
Definition sch_symbol.h:76
VECTOR2I GetPosition() const override
Definition sch_text.h:147
void updateItem(EDA_ITEM *aItem, bool aUpdateRTree) const
bool Init() override
Init() is called once upon a registration of the tool.
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
SCH_TOOL_BASE(const std::string &aName)
SCH_SELECTION_TOOL * m_selectionTool
Definition seg.h:42
const VECTOR2I NearestPoint(const VECTOR2I &aP) const
Compute a point on the segment (this) that is closest to point aP.
Definition seg.cpp:633
static SELECTION_CONDITION OnlyTypes(std::vector< KICAD_T > aTypes)
Create a functor that tests if the selected items are only of given types.
virtual void Add(EDA_ITEM *aItem)
Definition selection.cpp:42
VECTOR2I GetReferencePoint() const
bool IsHover() const
Definition selection.h:89
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition selection.h:105
EDA_ITEM * Front() const
Definition selection.h:177
int Size() const
Returns the number of selected parts.
Definition selection.h:121
void SetReferencePoint(const VECTOR2I &aP)
bool Empty() const
Checks if there is anything selected.
Definition selection.h:115
std::vector< EDA_ITEM * > GetItemsSortedByTypeAndXY(bool leftBeforeRight=true, bool topBeforeBottom=true) const
Returns a copy of this selection of items sorted by their X then Y position.
bool HasReferencePoint() const
Definition selection.h:216
const TRANSFORM & GetTransform() const
Definition symbol.h:247
KIGFX::VIEW_CONTROLS * getViewControls() const
Definition tool_base.cpp:44
KIGFX::VIEW * getView() const
Definition tool_base.cpp:38
Generic, UI-independent tool event.
Definition tool_event.h:171
bool DisableGridSnapping() const
Definition tool_event.h:371
bool HasParameter() const
Definition tool_event.h:464
bool IsCancelInteractive() const
Indicate the event should restart/end an ongoing interactive tool's event loop (eg esc key,...
TOOL_ACTIONS Action() const
Returns more specific information about the type of an event.
Definition tool_event.h:250
bool IsActivate() const
Definition tool_event.h:345
COMMIT * Commit() const
Definition tool_event.h:283
bool IsClick(int aButtonMask=BUT_ANY) const
TOOL_EVENT_CATEGORY Category() const
Return the category (eg. mouse/keyboard/action) of an event.
Definition tool_event.h:247
bool IsDrag(int aButtonMask=BUT_ANY) const
Definition tool_event.h:315
int Modifier(int aMask=MD_MODIFIER_MASK) const
Return information about key modifiers state (Ctrl, Alt, etc.).
Definition tool_event.h:366
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
T Parameter() const
Return a parameter assigned to the event.
Definition tool_event.h:473
bool IsDblClick(int aButtonMask=BUT_ANY) const
std::atomic< SYNCRONOUS_TOOL_STATE > * SynchronousState() const
Definition tool_event.h:280
std::optional< int > GetCommandId() const
Definition tool_event.h:533
void SetPassEvent(bool aPass=true)
Definition tool_event.h:256
bool IsMouseUp(int aButtonMask=BUT_ANY) const
Definition tool_event.h:325
bool IsMotion() const
Definition tool_event.h:330
const std::string Format() const
Return information about event in form of a human-readable string.
void Go(int(SCH_EDIT_FRAME::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
std::unique_ptr< TOOL_MENU > m_menu
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
for transforming drawing coordinates for a wxDC device context.
Definition transform.h:46
TRANSFORM InverseTransform() const
Calculate the Inverse mirror/rotation transform.
Definition transform.cpp:59
VECTOR2I TransformCoordinate(const VECTOR2I &aPoint) const
Calculate a new coordinate according to the mirror/rotation transform.
Definition transform.cpp:44
@ CHT_REMOVE
Definition commit.h:43
@ CHT_DONE
Flag to indicate the change is already applied.
Definition commit.h:47
@ CHT_ADD
Definition commit.h:42
KICURSOR
Definition cursors.h:44
@ PLACE
Definition cursors.h:98
@ MOVING
Definition cursors.h:48
#define _(s)
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
@ RECURSE
Definition eda_item.h:51
@ NO_RECURSE
Definition eda_item.h:52
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition eda_item.h:575
#define IS_PASTED
Modifier on IS_NEW which indicates it came from clipboard.
#define IS_CHANGED
Item was edited, and modified.
#define BRIGHTENED
item is drawn with a bright contour
#define IS_NEW
New item, just created.
#define SELECTED
Item was manually selected by the user.
#define SELECTED_BY_DRAG
Item was algorithmically selected as a dragged item.
#define IS_BROKEN
Is a segment just broken by BreakSegment.
#define STRUCT_DELETED
flag indication structures to be erased
#define ENDPOINT
ends. (Used to support dragging.)
#define IS_MOVING
Item being moved.
#define STARTPOINT
When a line is selected, these flags indicate which.
@ NONE
Definition eda_shape.h:69
@ ID_POPUP_SCH_SELECT_UNIT
Definition eeschema_id.h:89
@ ID_POPUP_SCH_SELECT_BODY_STYLE
Definition eeschema_id.h:99
@ ID_POPUP_SCH_SELECT_BODY_STYLE_END
@ ID_POPUP_SCH_SELECT_UNIT_END
Definition eeschema_id.h:93
@ LINE_MODE_FREE
GRID_HELPER_GRIDS
Definition grid_helper.h:44
@ GRID_CURRENT
Definition grid_helper.h:46
const wxChar *const traceSchMove
Flag to watch how schematic move tool actions are handled.
@ LAYER_WIRE
Definition layer_ids.h:452
@ LAYER_BUS
Definition layer_ids.h:453
@ LAYER_BUS_JUNCTION
Definition layer_ids.h:498
std::vector< SCH_JUNCTION * > PreviewJunctions(const class SCH_SCREEN *aScreen, const std::vector< class SCH_ITEM * > &aItems)
Determine the points where explicit junctions would be required if the given temporary items were com...
POINT_INFO AnalyzePoint(const EE_RTREE &aItem, const VECTOR2I &aPosition, bool aBreakCrossings)
Check a tree of items for a confluence at a given point and work out what kind of junction it is,...
@ REPAINT
Item needs to be redrawn.
Definition view_item.h:58
bool signbit(T v)
Integral version of std::signbit that works all compilers.
Definition kicad_algo.h:176
see class PGM_BASE
Class to handle a set of SCH_ITEMs.
@ AUTOPLACE_NONE
Definition sch_item.h:69
#define QUIET_MODE
static bool isGraphicItemForDrop(const SCH_ITEM *aItem)
static void cloneWireConnection(SCH_LINE *aNewLine, SCH_ITEM *aSource, SCH_EDIT_FRAME *aFrame)
T * GetAppSettings(const char *aFilename)
The EE_TYPE struct provides a type-specific auto-range iterator to the RTree.
Definition sch_rtree.h:195
A selection of information about a point in the schematic that might be eligible for turning into a j...
VECTOR2D m_lastKeyboardCursorPosition
Position of the above event.
bool m_lastKeyboardCursorPositionValid
Is last cursor motion event coming from keyboard arrow cursor motion action.
long m_lastKeyboardCursorCommand
ACTIONS::CURSOR_UP, ACTIONS::CURSOR_DOWN, etc.
bool moved
KIBIS_PIN * pin
VECTOR2I end
int delta
@ TA_CHOICE_MENU_CHOICE
Context menu choice.
Definition tool_event.h:98
@ STS_CANCELLED
Definition tool_event.h:164
@ STS_FINISHED
Definition tool_event.h:163
@ STS_RUNNING
Definition tool_event.h:162
@ MD_CTRL
Definition tool_event.h:144
@ MD_SHIFT
Definition tool_event.h:143
@ TC_COMMAND
Definition tool_event.h:57
@ TC_MOUSE
Definition tool_event.h:55
@ TC_KEYBOARD
Definition tool_event.h:56
@ BUT_LEFT
Definition tool_event.h:132
@ BUT_RIGHT
Definition tool_event.h:133
wxLogTrace helper definitions.
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:78
@ SCH_LINE_T
Definition typeinfo.h:167
@ SCH_NO_CONNECT_T
Definition typeinfo.h:164
@ SCH_SYMBOL_T
Definition typeinfo.h:176
@ SCH_FIELD_T
Definition typeinfo.h:154
@ SCH_DIRECTIVE_LABEL_T
Definition typeinfo.h:175
@ SCH_LABEL_T
Definition typeinfo.h:171
@ SCH_SHEET_T
Definition typeinfo.h:179
@ SCH_SHAPE_T
Definition typeinfo.h:153
@ SCH_HIER_LABEL_T
Definition typeinfo.h:173
@ SCH_BUS_BUS_ENTRY_T
Definition typeinfo.h:166
@ SCH_SHEET_PIN_T
Definition typeinfo.h:178
@ SCH_TEXT_T
Definition typeinfo.h:155
@ SCH_BUS_WIRE_ENTRY_T
Definition typeinfo.h:165
@ SCH_BITMAP_T
Definition typeinfo.h:168
@ SCH_TEXTBOX_T
Definition typeinfo.h:156
@ SCH_GLOBAL_LABEL_T
Definition typeinfo.h:172
@ SCH_JUNCTION_T
Definition typeinfo.h:163
@ SCH_PIN_T
Definition typeinfo.h:157
constexpr int sign(T val)
Definition util.h:145
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695
VECTOR2< double > VECTOR2D
Definition vector2d.h:694