KiCad PCB EDA Suite
SCH_LINE_WIRE_BUS_TOOL Class Reference

Tool responsible for drawing/placing items (symbols, wires, buses, labels, etc.) More...

#include <sch_line_wire_bus_tool.h>

Inheritance diagram for SCH_LINE_WIRE_BUS_TOOL:
EE_TOOL_BASE< SCH_EDIT_FRAME > TOOL_INTERACTIVE TOOL_BASE

Public Types

enum  RESET_REASON { RUN, MODEL_RELOAD, GAL_SWITCH }
 Determine the reason of reset for a tool. More...
 

Public Member Functions

 SCH_LINE_WIRE_BUS_TOOL ()
 
 ~SCH_LINE_WIRE_BUS_TOOL ()
 
bool Init () override
 Init() is called once upon a registration of the tool. More...
 
int DrawSegments (const TOOL_EVENT &aEvent)
 
int UnfoldBus (const TOOL_EVENT &aEvent)
 
int AddJunctionsIfNeeded (const TOOL_EVENT &aEvent)
 Handle the addition of junctions to a selection of objects. More...
 
void Reset (RESET_REASON aReason) override
 Bring the tool to a known, initial state. More...
 
void Activate ()
 Run the tool. More...
 
TOOL_MENUGetToolMenu ()
 
void SetContextMenu (ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
 Assign a context menu and tells when it should be activated. More...
 
void RunMainStack (std::function< void()> aFunc)
 Call a function using the main stack. More...
 
template<class T >
void Go (int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
 Define which state (aStateFunc) to go when a certain event arrives (aConditions). More...
 
TOOL_EVENTWait (const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
 Suspend execution of the tool until an event specified in aEventList arrives. More...
 
TOOL_TYPE GetType () const
 Return the type of the tool. More...
 
TOOL_ID GetId () const
 Return the unique identifier of the tool. More...
 
const std::string & GetName () const
 Return the name of the tool. More...
 
TOOL_MANAGERGetManager () const
 Return the instance of TOOL_MANAGER that takes care of the tool. More...
 
bool IsToolActive () const
 

Static Public Member Functions

static bool IsDrawingLine (const SELECTION &aSelection)
 
static bool IsDrawingWire (const SELECTION &aSelection)
 
static bool IsDrawingBus (const SELECTION &aSelection)
 
static bool IsDrawingLineWireOrBus (const SELECTION &aSelection)
 

Protected Member Functions

void updateItem (EDA_ITEM *aItem, bool aUpdateRTree) const
 Similar to getView()->Update(), but handles items that are redrawn by their parents and updating the SCH_SCREEN's RTree. More...
 
void saveCopyInUndoList (EDA_ITEM *aItem, UNDO_REDO aType, bool aAppend=false)
 
void attachManager (TOOL_MANAGER *aManager)
 Set the TOOL_MANAGER the tool will belong to. More...
 
KIGFX::VIEWgetView () const
 Returns the instance of #VIEW object used in the application. More...
 
KIGFX::VIEW_CONTROLSgetViewControls () const
 Return the instance of VIEW_CONTROLS object used in the application. More...
 
template<typename T >
T * getEditFrame () const
 Return the application window object, casted to requested user type. More...
 
template<typename T >
T * getModel () const
 Return the model object if it matches the requested type. More...
 

Protected Attributes

SCH_EDIT_FRAMEm_frame
 
KIGFX::SCH_VIEWm_view
 
EE_SELECTION_TOOLm_selectionTool
 
bool m_isSymbolEditor
 
TOOL_MENU m_menu
 The functions below are not yet implemented - their interface may change. More...
 
TOOL_TYPE m_type
 Unique identifier for the tool, assigned by a TOOL_MANAGER instance. More...
 
TOOL_ID m_toolId
 Name of the tool. More...
 
std::string m_toolName
 
TOOL_MANAGERm_toolMgr
 

Private Member Functions

int doDrawSegments (const std::string &aTool, int aType, bool aQuitOnDraw)
 
SCH_LINEstartSegments (int aType, const VECTOR2D &aPos)
 
SCH_LINEdoUnfoldBus (const wxString &aNet, const wxPoint &aPos=wxDefaultPosition)
 
void finishSegments ()
 
void simplifyWireList ()
 Iterate over the wire list and removes the null segments and overlapping segments to create a simplified wire list. More...
 
void setTransitions () override
 This method is meant to be overridden in order to specify handlers for events. More...
 
const SCH_SHEET_PINgetSheetPin (const wxPoint &aPosition)
 Search for a sheet pin at a location. More...
 
void computeBreakPoint (const std::pair< SCH_LINE *, SCH_LINE * > &aSegments, wxPoint &aPosition)
 Compute the middle coordinate for 2 segments from the start point to aPosition with the segments kept in the horizontal or vertical axis only. More...
 

Private Attributes

BUS_UNFOLDING_T m_busUnfold
 Data related to bus unfolding tool. More...
 
std::vector< SCH_LINE * > m_wires
 Storage for the line segments while drawing. More...
 

Detailed Description

Tool responsible for drawing/placing items (symbols, wires, buses, labels, etc.)

Definition at line 73 of file sch_line_wire_bus_tool.h.

Member Enumeration Documentation

◆ RESET_REASON

enum TOOL_BASE::RESET_REASON
inherited

Determine the reason of reset for a tool.

Enumerator
RUN 

Tool is invoked after being inactive.

MODEL_RELOAD 

Model changes (required full reload)

GAL_SWITCH 

Rendering engine changes.

Definition at line 77 of file tool_base.h.

78  {
79  RUN,
80  MODEL_RELOAD,
81  GAL_SWITCH
82  };
Model changes (required full reload)
Definition: tool_base.h:80
Tool is invoked after being inactive.
Definition: tool_base.h:79
Rendering engine changes.
Definition: tool_base.h:81

Constructor & Destructor Documentation

◆ SCH_LINE_WIRE_BUS_TOOL()

SCH_LINE_WIRE_BUS_TOOL::SCH_LINE_WIRE_BUS_TOOL ( )

Definition at line 166 of file sch_line_wire_bus_tool.cpp.

166  :
167  EE_TOOL_BASE<SCH_EDIT_FRAME>( "eeschema.InteractiveDrawingLineWireBus" )
168 {
169  m_busUnfold = {};
170  m_wires.reserve( 16 );
171 }
std::vector< SCH_LINE * > m_wires
Storage for the line segments while drawing.
BUS_UNFOLDING_T m_busUnfold
Data related to bus unfolding tool.

References m_busUnfold, and m_wires.

◆ ~SCH_LINE_WIRE_BUS_TOOL()

SCH_LINE_WIRE_BUS_TOOL::~SCH_LINE_WIRE_BUS_TOOL ( )

Definition at line 174 of file sch_line_wire_bus_tool.cpp.

175 {
176 }

Member Function Documentation

◆ Activate()

void TOOL_INTERACTIVE::Activate ( )
inherited

Run the tool.

After activation, the tool starts receiving events until it is finished.

Definition at line 51 of file tool_interactive.cpp.

52 {
54 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209
bool InvokeTool(TOOL_ID aToolId)
Call a tool by sending a tool activation event to tool of given ID.

References TOOL_MANAGER::InvokeTool(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by AUTOPLACE_TOOL::autoplace(), EDIT_TOOL::copyToClipboard(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), PAD_TOOL::EnumeratePads(), PCB_CONTROL::GridSetOrigin(), SCH_EDITOR_CONTROL::HighlightNetCursor(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), PCB_PICKER_TOOL::Main(), PL_EDIT_TOOL::Main(), EE_POINT_EDITOR::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), LIB_TREE::onContextMenu(), PCB_POINT_EDITOR::OnSelectionChange(), GROUP_TOOL::PickNewMember(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), EDIT_TOOL::Remove(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), DRAWING_TOOL::SetAnchor(), DRC_TOOL::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), and UnfoldBus().

◆ AddJunctionsIfNeeded()

int SCH_LINE_WIRE_BUS_TOOL::AddJunctionsIfNeeded ( const TOOL_EVENT aEvent)

Handle the addition of junctions to a selection of objects.

Definition at line 976 of file sch_line_wire_bus_tool.cpp.

977 {
978  EE_SELECTION* aSelection = aEvent.Parameter<EE_SELECTION*>();
979 
980  std::vector<wxPoint> pts;
981  std::vector<wxPoint> connections = m_frame->GetSchematicConnections();
982 
983  for( unsigned ii = 0; ii < aSelection->GetSize(); ii++ )
984  {
985  SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( aSelection->GetItem( ii ) );
986 
987  if( !item || !item->IsConnectable() )
988  continue;
989 
990  std::vector<wxPoint> new_pts = item->GetConnectionPoints();
991  pts.insert( pts.end(), new_pts.begin(), new_pts.end() );
992 
993  // If the item is a line, we also add any connection points from the rest of the schematic
994  // that terminate on the line after it is moved.
995  if( item->Type() == SCH_LINE_T )
996  {
997  SCH_LINE* line = (SCH_LINE*) item;
998 
999  for( const wxPoint& pt : connections )
1000  {
1001  if( IsPointOnSegment( line->GetStartPoint(), line->GetEndPoint(), pt ) )
1002  pts.push_back( pt );
1003  }
1004  }
1005  else
1006  {
1007  // Clean up any wires that short non-wire connections in the list
1008  for( auto pt = new_pts.begin(); pt != new_pts.end(); pt++ )
1009  {
1010  for( auto secondPt = pt + 1; secondPt != new_pts.end(); secondPt++ )
1011  m_frame->TrimWire( *pt, *secondPt );
1012  }
1013  }
1014  }
1015 
1016  // We always have some overlapping connection points. Drop duplicates here
1017  std::sort( pts.begin(), pts.end(),
1018  []( const wxPoint& a, const wxPoint& b ) -> bool
1019  {
1020  return a.x < b.x || ( a.x == b.x && a.y < b.y );
1021  } );
1022 
1023  pts.erase( unique( pts.begin(), pts.end() ), pts.end() );
1024 
1025  for( const wxPoint& point : pts )
1026  {
1027  if( m_frame->GetScreen()->IsJunctionNeeded( point, true ) )
1028  m_frame->AddJunction( m_frame->GetScreen(), point, true, false );
1029  }
1030 
1031  return 0;
1032 }
virtual bool IsConnectable() const
Definition: sch_item.h:358
virtual std::vector< wxPoint > GetConnectionPoints() const
Add all the connection points for this item to aPoints.
Definition: sch_item.h:373
wxPoint GetStartPoint() const
Definition: sch_line.h:90
bool IsPointOnSegment(const wxPoint &aSegStart, const wxPoint &aSegEnd, const wxPoint &aTestPoint)
Test if aTestPoint is on line defined by aSegStart and aSegEnd.
Definition: trigo.cpp:42
SCH_JUNCTION * AddJunction(SCH_SCREEN *aScreen, const wxPoint &aPos, bool aAppendToUndo, bool aFinal=true)
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432
std::vector< wxPoint > GetSchematicConnections()
Collect a unique list of all possible connection points in the schematic.
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:87
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.cpp:52
bool IsJunctionNeeded(const wxPoint &aPosition, bool aNew=false) const
Test if a junction is required for the items at aPosition on the screen.
Definition: sch_screen.cpp:401
bool TrimWire(const wxPoint &aStart, const wxPoint &aEnd)
If any single wire passes through both points, remove the portion between the two points,...
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:193
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
wxPoint GetEndPoint() const
Definition: sch_line.h:93

References SCH_EDIT_FRAME::AddJunction(), SCH_ITEM::GetConnectionPoints(), SCH_LINE::GetEndPoint(), SELECTION::GetItem(), SCH_EDIT_FRAME::GetSchematicConnections(), SCH_EDIT_FRAME::GetScreen(), SELECTION::GetSize(), SCH_LINE::GetStartPoint(), SCH_ITEM::IsConnectable(), SCH_SCREEN::IsJunctionNeeded(), IsPointOnSegment(), EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_EVENT::Parameter(), SCH_LINE_T, SCH_EDIT_FRAME::TrimWire(), and EDA_ITEM::Type().

Referenced by setTransitions().

◆ attachManager()

void TOOL_BASE::attachManager ( TOOL_MANAGER aManager)
protectedinherited

Set the TOOL_MANAGER the tool will belong to.

Called by TOOL_MANAGER::RegisterTool()

Definition at line 60 of file tool_base.cpp.

61 {
62  m_toolMgr = aManager;
63 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_BASE::m_toolMgr.

Referenced by TOOL_MANAGER::RegisterTool().

◆ computeBreakPoint()

void SCH_LINE_WIRE_BUS_TOOL::computeBreakPoint ( const std::pair< SCH_LINE *, SCH_LINE * > &  aSegments,
wxPoint &  aPosition 
)
private

Compute the middle coordinate for 2 segments from the start point to aPosition with the segments kept in the horizontal or vertical axis only.

Parameters
aSegmentsA pair of pointers to a SCH_LINE objects containing the first line break point to compute.
aPositionA reference to a wxPoint object containing the coordinates of the position used to calculate the line break point.

Definition at line 411 of file sch_line_wire_bus_tool.cpp.

413 {
414  wxCHECK_RET( aSegments.first && aSegments.second,
415  wxT( "Cannot compute break point of NULL line segment." ) );
416 
417  SCH_LINE* segment = aSegments.first;
418  SCH_LINE* next_segment = aSegments.second;
419 
420  wxPoint midPoint;
421  int iDx = segment->GetEndPoint().x - segment->GetStartPoint().x;
422  int iDy = segment->GetEndPoint().y - segment->GetStartPoint().y;
423 
424  const SCH_SHEET_PIN* connectedPin = getSheetPin( segment->GetStartPoint() );
425  SHEET_SIDE force = connectedPin ? connectedPin->GetEdge() : SHEET_SIDE::UNDEFINED;
426 
427  if( force == SHEET_SIDE::LEFT || force == SHEET_SIDE::RIGHT )
428  {
429  if( aPosition.x == connectedPin->GetPosition().x ) // push outside sheet boundary
430  {
431  int direction = ( force == SHEET_SIDE::LEFT ) ? -1 : 1;
432  aPosition.x += KiROUND( getView()->GetGAL()->GetGridSize().x * direction );
433  }
434 
435  midPoint.x = aPosition.x;
436  midPoint.y = segment->GetStartPoint().y; // force horizontal
437  }
438  else if( iDy != 0 ) // keep the first segment orientation (vertical)
439  {
440  midPoint.x = segment->GetStartPoint().x;
441  midPoint.y = aPosition.y;
442  }
443  else if( iDx != 0 ) // keep the first segment orientation (horizontal)
444  {
445  midPoint.x = aPosition.x;
446  midPoint.y = segment->GetStartPoint().y;
447  }
448  else
449  {
450  if( std::abs( aPosition.x - segment->GetStartPoint().x ) <
451  std::abs( aPosition.y - segment->GetStartPoint().y ) )
452  {
453  midPoint.x = segment->GetStartPoint().x;
454  midPoint.y = aPosition.y;
455  }
456  else
457  {
458  midPoint.x = aPosition.x;
459  midPoint.y = segment->GetStartPoint().y;
460  }
461  }
462 
463  segment->SetEndPoint( midPoint );
464  next_segment->SetStartPoint( midPoint );
465  next_segment->SetEndPoint( aPosition );
466 }
wxPoint GetStartPoint() const
Definition: sch_line.h:90
SHEET_SIDE GetEdge() const
void SetEndPoint(const wxPoint &aPosition)
Definition: sch_line.h:94
const SCH_SHEET_PIN * getSheetPin(const wxPoint &aPosition)
Search for a sheet pin at a location.
void SetStartPoint(const wxPoint &aPosition)
Definition: sch_line.h:91
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet_pin.h:65
wxPoint GetPosition() const override
Definition: sch_text.h:239
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:73
SHEET_SIDE
Define the edge of the sheet that the sheet pin is positioned.
Definition: sch_sheet_pin.h:45
wxPoint GetEndPoint() const
Definition: sch_line.h:93

References SCH_SHEET_PIN::GetEdge(), SCH_LINE::GetEndPoint(), SCH_TEXT::GetPosition(), getSheetPin(), SCH_LINE::GetStartPoint(), TOOL_BASE::getView(), KiROUND(), LEFT, RIGHT, SCH_LINE::SetEndPoint(), SCH_LINE::SetStartPoint(), and UNDEFINED.

Referenced by doDrawSegments().

◆ doDrawSegments()

int SCH_LINE_WIRE_BUS_TOOL::doDrawSegments ( const std::string &  aTool,
int  aType,
bool  aQuitOnDraw 
)
private

Definition at line 469 of file sch_line_wire_bus_tool.cpp.

470 {
471  SCH_SCREEN* screen = m_frame->GetScreen();
472  SCH_LINE* segment = nullptr;
475 
476  auto setCursor =
477  [&]()
478  {
479  if( aType == LAYER_WIRE )
481  else if( aType == LAYER_BUS )
483  else if( aType == LAYER_NOTES )
485  else
487  };
488 
489  auto cleanup =
490  [&] ()
491  {
493 
494  for( SCH_LINE* wire : m_wires )
495  delete wire;
496 
497  m_wires.clear();
498  segment = nullptr;
499 
500  if( m_busUnfold.entry )
502 
505 
508 
509  delete m_busUnfold.entry;
510  delete m_busUnfold.label;
511  m_busUnfold = {};
512 
513  m_view->ClearPreview();
514  m_view->ShowPreview( false );
515  };
516 
517  Activate();
518  // Must be done after Activate() so that it gets set into the correct context
519  controls->ShowCursor( true );
520  // Set initial cursor
521  setCursor();
522 
523  // Add the new label to the selection so the rotate command operates on it
524  if( m_busUnfold.label )
526 
527  // Continue the existing wires if we've started (usually by immediate action preference)
528  if( !m_wires.empty() )
529  segment = m_wires.back();
530 
531  wxPoint contextMenuPos;
532 
533  // Main loop: keep receiving events
534  while( TOOL_EVENT* evt = Wait() )
535  {
536  setCursor();
537  grid.SetMask( GRID_HELPER::ALL );
538  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
539  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
540 
541  if( segment )
542  {
543  if( segment->GetStartPoint().x == segment->GetEndPoint().x )
544  grid.ClearMaskFlag( GRID_HELPER::VERTICAL );
545 
546  if( segment->GetStartPoint().y == segment->GetEndPoint().y )
547  grid.ClearMaskFlag( GRID_HELPER::HORIZONTAL );
548  }
549 
550  wxPoint cursorPos = static_cast<wxPoint>( evt->HasPosition() ?
551  evt->Position() :
552  controls->GetMousePosition() );
553 
554  cursorPos = (wxPoint) grid.BestSnapAnchor( cursorPos, LAYER_CONNECTABLE, segment );
555  controls->ForceCursorPosition( true, cursorPos );
556 
557  bool forceHV = m_frame->eeconfig()->m_Drawing.hv_lines_only;
558 
559  //------------------------------------------------------------------------
560  // Handle cancel:
561  //
562  if( evt->IsCancelInteractive() )
563  {
564  if( segment || m_busUnfold.in_progress )
565  {
566  cleanup();
567  }
568  else
569  {
570  m_frame->PopTool( aTool );
571  break;
572  }
573  }
574  else if( evt->IsActivate() )
575  {
576  if( segment || m_busUnfold.in_progress )
577  {
578  m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel drawing." ) );
579  evt->SetPassEvent( false );
580  continue;
581  }
582 
583  if( evt->IsMoveTool() )
584  {
585  // leave ourselves on the stack so we come back after the move
586  break;
587  }
588  else
589  {
590  m_frame->PopTool( aTool );
591  break;
592  }
593  }
594  //------------------------------------------------------------------------
595  // Handle finish:
596  //
597  else if( evt->IsAction( &EE_ACTIONS::finishLineWireOrBus )
598  || evt->IsAction( &EE_ACTIONS::finishWire )
599  || evt->IsAction( &EE_ACTIONS::finishBus )
600  || evt->IsAction( &EE_ACTIONS::finishLine ) )
601  {
602  if( segment || m_busUnfold.in_progress )
603  {
604  finishSegments();
605  segment = nullptr;
606 
607  if( aQuitOnDraw )
608  {
609  m_frame->PopTool( aTool );
610  break;
611  }
612  }
613  }
614  //------------------------------------------------------------------------
615  // Handle click:
616  //
617  else if( evt->IsClick( BUT_LEFT ) || ( segment && evt->IsDblClick( BUT_LEFT ) ) )
618  {
619  // First click when unfolding places the label and wire-to-bus entry
621  {
622  wxASSERT( aType == LAYER_WIRE );
623 
624  m_frame->AddToScreen( m_busUnfold.label, screen );
626  m_busUnfold.label_placed = true;
627  }
628 
629  if( !segment )
630  {
631  segment = startSegments( aType, VECTOR2D( cursorPos ) );
632  }
633  // Create a new segment if we're out of previously-created ones
634  else if( !segment->IsNull() || ( forceHV && !m_wires[ m_wires.size() - 2 ]->IsNull() ) )
635  {
636  // Terminate the command if the end point is on a pin, junction, label, or another
637  // wire or bus.
638  if( screen->IsTerminalPoint( cursorPos, segment->GetLayer() ) )
639  {
640  finishSegments();
641  segment = nullptr;
642 
643  if( aQuitOnDraw )
644  {
645  m_frame->PopTool( aTool );
646  break;
647  }
648  }
649  else
650  {
651  segment->SetEndPoint( cursorPos );
652 
653  // Create a new segment, and chain it after the current segment.
654  segment = new SCH_LINE( *segment );
655  segment->SetFlags( IS_NEW | IS_MOVING );
656  segment->SetStartPoint( cursorPos );
657  m_wires.push_back( segment );
658 
659  m_selectionTool->AddItemToSel( segment, true /*quiet mode*/ );
660  }
661  }
662 
663  if( evt->IsDblClick( BUT_LEFT ) && segment )
664  {
665  if( forceHV && m_wires.size() >= 2 )
666  computeBreakPoint( { m_wires[ m_wires.size() - 2 ], segment }, cursorPos );
667 
668  finishSegments();
669  segment = nullptr;
670 
671  if( aQuitOnDraw )
672  {
673  m_frame->PopTool( aTool );
674  break;
675  }
676  }
677  }
678  //------------------------------------------------------------------------
679  // Handle motion:
680  //
681  else if( evt->IsMotion() || evt->IsAction( &ACTIONS::refreshPreview ) )
682  {
683  m_view->ClearPreview();
684 
685  // Update the bus unfold posture based on the mouse movement
687  {
688  wxPoint cursor_delta = cursorPos - m_busUnfold.origin;
690 
691  bool flipX = ( cursor_delta.x < 0 );
692  bool flipY = ( cursor_delta.y < 0 );
693 
694  // Erase and redraw if necessary
695  if( flipX != m_busUnfold.flipX || flipY != m_busUnfold.flipY )
696  {
697  wxSize size = entry->GetSize();
698  int ySign = flipY ? -1 : 1;
699  int xSign = flipX ? -1 : 1;
700 
701  size.x = std::abs( size.x ) * xSign;
702  size.y = std::abs( size.y ) * ySign;
703  entry->SetSize( size );
704 
705  m_busUnfold.flipY = flipY;
706  m_busUnfold.flipX = flipX;
707 
708  m_frame->UpdateItem( entry );
709  m_wires.front()->SetStartPoint( entry->GetEnd() );
710  }
711 
712  // Update the label "ghost" position
713  m_busUnfold.label->SetPosition( cursorPos );
715 
716  // Ensure segment is non-null at the start of bus unfold
717  if( !segment )
718  segment = m_wires.back();
719  }
720 
721  if( segment )
722  {
723  // Coerce the line to vertical or horizontal if necessary
724  if( forceHV && m_wires.size() >= 2 )
725  computeBreakPoint( { m_wires[ m_wires.size() - 2 ], segment }, cursorPos );
726  else
727  segment->SetEndPoint( cursorPos );
728  }
729 
730  for( SCH_LINE* wire : m_wires )
731  {
732  if( !wire->IsNull() )
733  m_view->AddToPreview( wire->Clone() );
734  }
735  }
736  //------------------------------------------------------------------------
737  // Handle context menu:
738  //
739  else if( evt->IsClick( BUT_RIGHT ) )
740  {
741  // Warp after context menu only if dragging...
742  if( !segment )
744 
745  contextMenuPos = cursorPos;
747  }
748  else if( evt->Category() == TC_COMMAND && evt->Action() == TA_CHOICE_MENU_CHOICE )
749  {
750  if( evt->GetCommandId().get() >= ID_POPUP_SCH_UNFOLD_BUS
751  && evt->GetCommandId().get() <= ID_POPUP_SCH_UNFOLD_BUS_END )
752  {
753  wxASSERT_MSG( !segment, "Bus unfold event received when already drawing!" );
754 
755  aType = LAYER_WIRE;
756  wxString net = *evt->Parameter<wxString*>();
757  segment = doUnfoldBus( net, contextMenuPos );
758  }
759  }
760  else if( evt->IsAction( &EE_ACTIONS::rotateCW ) || evt->IsAction( &EE_ACTIONS::rotateCCW ) )
761  {
763  {
764  m_busUnfold.label->Rotate90( evt->IsAction( &EE_ACTIONS::rotateCW ) );
766  }
767  else
768  {
769  wxBell();
770  }
771  }
772  else if( evt->IsAction( &ACTIONS::doDelete ) && ( segment || m_busUnfold.in_progress ) )
773  {
774  cleanup();
775  }
776  else
777  {
778  evt->SetPassEvent();
779  }
780 
781  // Enable autopanning and cursor capture only when there is a segment to be placed
782  controls->SetAutoPan( segment != nullptr );
783  controls->CaptureCursor( segment != nullptr );
784  }
785 
786  controls->SetAutoPan( false );
787  controls->CaptureCursor( false );
789  controls->ForceCursorPosition( false );
790  return 0;
791 }
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
void UpdateItem(EDA_ITEM *aItem, bool isAddOrDelete=false)
Mark an item for refresh.
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
bool flipY
True if the bus entry should be flipped in the y-axis.
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Suspend execution of the tool until an event specified in aEventList arrives.
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Return the current mouse pointer position.
wxPoint GetStartPoint() const
Definition: sch_line.h:90
void SetSize(const wxSize &aSize)
Definition: sch_bus_entry.h:64
#define IS_NEW
New item, just created.
static TOOL_ACTION doDelete
Definition: actions.h:72
void AddToPreview(EDA_ITEM *aItem, bool aTakeOwnership=true)
Definition: view.cpp:1562
bool IsTerminalPoint(const wxPoint &aPosition, int aLayer) const
Test if aPosition is a connection point on aLayer.
Definition: sch_screen.cpp:484
std::vector< SCH_LINE * > m_wires
Storage for the line segments while drawing.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
SCH_LINE * startSegments(int aType, const VECTOR2D &aPos)
static TOOL_ACTION finishLineWireOrBus
Definition: ee_actions.h:90
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
void RemoveFromScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen)
Remove an item from the screen (and view) aScreen is the screen the item is located on,...
static TOOL_ACTION rotateCW
Definition: ee_actions.h:113
static TOOL_ACTION finishLine
Definition: ee_actions.h:93
void SetEndPoint(const wxPoint &aPosition)
Definition: sch_line.h:94
void ShowPreview(bool aShow=true)
Definition: view.cpp:1576
EE_SELECTION & GetSelection()
Return the set of currently selected items.
EESCHEMA_SETTINGS * eeconfig() const
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
void ShowInfoBarMsg(const wxString &aMsg, bool aShowCloseButton=false)
Show the WX_INFOBAR displayed on the top of the canvas with a message and an info icon on the left of...
static TOOL_ACTION rotateCCW
Definition: ee_actions.h:114
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
Definition: sch_text.cpp:844
#define IS_MOVING
Item being moved.
wxPoint origin
Origin (on the bus) of the unfold.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:622
virtual void PopTool(const std::string &actionName)
virtual void CaptureCursor(bool aEnabled)
Force the cursor to stay within the drawing panel area.
bool IsNull() const
Definition: sch_line.h:88
void SetStartPoint(const wxPoint &aPosition)
Definition: sch_line.h:91
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
Generic, UI-independent tool event.
Definition: tool_event.h:152
void ClearPreview()
Definition: view.cpp:1540
An interface for classes handling user events controlling the view behavior such as zooming,...
#define _(s)
EE_SELECTION_TOOL * m_selectionTool
Definition: ee_tool_base.h:177
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Place the cursor immediately at a given point.
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:53
void computeBreakPoint(const std::pair< SCH_LINE *, SCH_LINE * > &aSegments, wxPoint &aPosition)
Compute the middle coordinate for 2 segments from the start point to aPosition with the segments kept...
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
SCH_BUS_WIRE_ENTRY * entry
virtual void Rotate90(bool aClockwise)
Definition: sch_text.cpp:301
SCH_LAYER_ID GetLayer() const
Return the layer this item is on.
Definition: sch_item.h:268
int RemoveItemFromSel(const TOOL_EVENT &aEvent)
wxSize GetSize() const
Definition: sch_bus_entry.h:63
int AddItemToSel(const TOOL_EVENT &aEvent)
void AddToScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen)
Add an item to the screen (and view) aScreen is the screen the item is located on,...
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
void VetoContextMenuMouseWarp()
Disable mouse warping after the current context menu is closed.
Definition: tool_manager.h:422
Class for a wire to bus entry.
void Activate()
Run the tool.
bool label_placed
True if user has placed the net label.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
static TOOL_ACTION finishBus
Definition: ee_actions.h:92
void SetPosition(const wxPoint &aPosition) override
Definition: sch_text.h:240
bool flipX
True if the bus entry should be flipped in the x-axis.
void ShowContextMenu(SELECTION &aSelection)
Helper function to set and immediately show a CONDITIONAL_MENU in concert with the given SELECTION.
Definition: tool_menu.cpp:59
SCH_LINE * doUnfoldBus(const wxString &aNet, const wxPoint &aPos=wxDefaultPosition)
static TOOL_ACTION finishWire
Definition: ee_actions.h:91
BUS_UNFOLDING_T m_busUnfold
Data related to bus unfolding tool.
static TOOL_ACTION refreshPreview
Definition: actions.h:106
bool in_progress
True if bus unfold operation is running.
wxPoint GetEnd() const
wxPoint GetEndPoint() const
Definition: sch_line.h:93

References _, TOOL_INTERACTIVE::Activate(), EE_SELECTION_TOOL::AddItemToSel(), KIGFX::VIEW::AddToPreview(), SCH_BASE_FRAME::AddToScreen(), GRID_HELPER::ALL, ARROW, BUT_LEFT, BUT_RIGHT, KIGFX::VIEW_CONTROLS::CaptureCursor(), KIGFX::VIEW::ClearPreview(), EE_ACTIONS::clearSelection, SCH_LABEL::Clone(), computeBreakPoint(), ACTIONS::doDelete, doUnfoldBus(), SCH_BASE_FRAME::eeconfig(), BUS_UNFOLDING_T::entry, EE_ACTIONS::finishBus, EE_ACTIONS::finishLine, EE_ACTIONS::finishLineWireOrBus, finishSegments(), EE_ACTIONS::finishWire, BUS_UNFOLDING_T::flipX, BUS_UNFOLDING_T::flipY, KIGFX::VIEW_CONTROLS::ForceCursorPosition(), SCH_BASE_FRAME::GetCanvas(), SCH_BUS_ENTRY_BASE::GetEnd(), SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), KIGFX::VIEW_CONTROLS::GetMousePosition(), SCH_EDIT_FRAME::GetScreen(), EE_SELECTION_TOOL::GetSelection(), SCH_BUS_ENTRY_BASE::GetSize(), SCH_LINE::GetStartPoint(), TOOL_BASE::getView(), TOOL_BASE::getViewControls(), grid, GRID_HELPER::HORIZONTAL, EESCHEMA_SETTINGS::DRAWING::hv_lines_only, ID_POPUP_SCH_UNFOLD_BUS, ID_POPUP_SCH_UNFOLD_BUS_END, BUS_UNFOLDING_T::in_progress, IS_MOVING, IS_NEW, SCH_LINE::IsNull(), SCH_SCREEN::IsTerminalPoint(), BUS_UNFOLDING_T::label, BUS_UNFOLDING_T::label_placed, LAYER_BUS, LAYER_CONNECTABLE, LAYER_NOTES, LAYER_WIRE, LINE_BUS, LINE_GRAPHIC, LINE_WIRE, m_busUnfold, EESCHEMA_SETTINGS::m_Drawing, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_INTERACTIVE::m_menu, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, TOOL_BASE::m_toolMgr, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_view, m_wires, MD_SHIFT, BUS_UNFOLDING_T::origin, TOOLS_HOLDER::PopTool(), ACTIONS::refreshPreview, SCH_BASE_FRAME::RemoveFromScreen(), EE_SELECTION_TOOL::RemoveItemFromSel(), SCH_TEXT::Rotate90(), EE_ACTIONS::rotateCCW, EE_ACTIONS::rotateCW, TOOL_MANAGER::RunAction(), KIGFX::VIEW_CONTROLS::SetAutoPan(), EDA_DRAW_PANEL_GAL::SetCurrentCursor(), SCH_LINE::SetEndPoint(), EDA_ITEM::SetFlags(), SCH_TEXT::SetPosition(), SCH_BUS_ENTRY_BASE::SetSize(), SCH_LINE::SetStartPoint(), TOOL_MENU::ShowContextMenu(), KIGFX::VIEW_CONTROLS::ShowCursor(), EDA_BASE_FRAME::ShowInfoBarMsg(), KIGFX::VIEW::ShowPreview(), startSegments(), TA_CHOICE_MENU_CHOICE, TC_COMMAND, SCH_BASE_FRAME::UpdateItem(), GRID_HELPER::VERTICAL, TOOL_MANAGER::VetoContextMenuMouseWarp(), and TOOL_INTERACTIVE::Wait().

Referenced by DrawSegments(), and UnfoldBus().

◆ doUnfoldBus()

SCH_LINE * SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus ( const wxString &  aNet,
const wxPoint &  aPos = wxDefaultPosition 
)
private

Definition at line 361 of file sch_line_wire_bus_tool.cpp.

362 {
363  SCHEMATIC_SETTINGS& cfg = getModel<SCHEMATIC>()->Settings();
364 
365  wxPoint pos = aPos;
366 
367  if( aPos == wxDefaultPosition )
368  pos = static_cast<wxPoint>( getViewControls()->GetCursorPosition() );
369 
371 
372  m_busUnfold.entry = new SCH_BUS_WIRE_ENTRY( pos );
375 
381 
382  m_busUnfold.in_progress = true;
383  m_busUnfold.origin = pos;
384  m_busUnfold.net_name = aNet;
385 
387 
389 }
#define IS_NEW
New item, just created.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
SCH_LINE * startSegments(int aType, const VECTOR2D &aPos)
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:237
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:116
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
#define IS_MOVING
Item being moved.
wxPoint origin
Origin (on the bus) of the unfold.
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:53
virtual void SetCrossHairCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true)=0
Move the graphic crosshair cursor to the requested position expressed in world coordinates.
wxString net_name
Net label for the unfolding operation.
SCH_BUS_WIRE_ENTRY * entry
void AddToScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen)
Add an item to the screen (and view) aScreen is the screen the item is located on,...
These settings were stored in SCH_BASE_FRAME previously.
Class for a wire to bus entry.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
virtual void SetLabelSpinStyle(LABEL_SPIN_STYLE aSpinStyle)
Set a spin or rotation angle, along with specific horizontal and vertical justification styles with e...
Definition: sch_text.cpp:319
BUS_UNFOLDING_T m_busUnfold
Data related to bus unfolding tool.
bool in_progress
True if bus unfold operation is running.
wxPoint GetEnd() const

References SCH_BASE_FRAME::AddToScreen(), EE_ACTIONS::clearSelection, BUS_UNFOLDING_T::entry, SCH_BUS_ENTRY_BASE::GetEnd(), SCH_EDIT_FRAME::GetScreen(), TOOL_BASE::getViewControls(), BUS_UNFOLDING_T::in_progress, IS_MOVING, IS_NEW, BUS_UNFOLDING_T::label, LAYER_WIRE, m_busUnfold, SCHEMATIC_SETTINGS::m_DefaultTextSize, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_BASE::m_toolMgr, BUS_UNFOLDING_T::net_name, BUS_UNFOLDING_T::origin, LABEL_SPIN_STYLE::RIGHT, TOOL_MANAGER::RunAction(), KIGFX::VIEW_CONTROLS::SetCrossHairCursorPosition(), EDA_ITEM::SetFlags(), SCH_TEXT::SetLabelSpinStyle(), EDA_ITEM::SetParent(), EDA_TEXT::SetTextSize(), and startSegments().

Referenced by doDrawSegments(), and UnfoldBus().

◆ DrawSegments()

int SCH_LINE_WIRE_BUS_TOOL::DrawSegments ( const TOOL_EVENT aEvent)

Definition at line 279 of file sch_line_wire_bus_tool.cpp.

280 {
282 
283  std::string tool = aEvent.GetCommandStr().get();
284  m_frame->PushTool( tool );
286 
287  if( aEvent.HasPosition() )
288  {
290  grid.SetSnap( !aEvent.Modifier( MD_SHIFT ) );
291  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !aEvent.DisableGridSnapping() );
292 
293  VECTOR2D cursorPos = grid.BestSnapAnchor( aEvent.Position(), LAYER_CONNECTABLE, nullptr );
294  startSegments( params->layer, cursorPos );
295  }
296 
297  return doDrawSegments( tool, params->layer, params->quitOnDraw );
298 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
virtual void PushTool(const std::string &actionName)
NB: the definition of "tool" is different at the user level.
SCH_LINE * startSegments(int aType, const VECTOR2D &aPos)
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432
bool DisableGridSnapping() const
Definition: tool_event.h:341
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:53
int doDrawSegments(const std::string &aTool, int aType, bool aQuitOnDraw)
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
int Modifier(int aMask=MD_MODIFIER_MASK) const
Definition: tool_event.h:336
OPT< std::string > GetCommandStr() const
Definition: tool_event.h:460
bool HasPosition() const
Definition: tool_event.h:240
const VECTOR2D Position() const
Returns the point where dragging has started.
Definition: tool_event.h:263

References EE_ACTIONS::clearSelection, TOOL_EVENT::DisableGridSnapping(), doDrawSegments(), TOOL_EVENT::GetCommandStr(), TOOL_BASE::getView(), grid, TOOL_EVENT::HasPosition(), DRAW_SEGMENT_EVENT_PARAMS::layer, LAYER_CONNECTABLE, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_BASE::m_toolMgr, MD_SHIFT, TOOL_EVENT::Modifier(), TOOL_EVENT::Parameter(), TOOL_EVENT::Position(), TOOLS_HOLDER::PushTool(), DRAW_SEGMENT_EVENT_PARAMS::quitOnDraw, TOOL_MANAGER::RunAction(), and startSegments().

Referenced by setTransitions().

◆ finishSegments()

void SCH_LINE_WIRE_BUS_TOOL::finishSegments ( )
private

Definition at line 874 of file sch_line_wire_bus_tool.cpp.

875 {
876  // Clear selection when done so that a new wire can be started.
877  // NOTE: this must be done before simplifyWireList is called or we might end up with
878  // freed selected items.
880 
881  SCH_SCREEN* screen = m_frame->GetScreen();
882  PICKED_ITEMS_LIST itemList;
883 
884  // Remove segments backtracking over others
886 
887  // Collect the possible connection points for the new lines
888  std::vector< wxPoint > connections = m_frame->GetSchematicConnections();
889  std::vector< wxPoint > new_ends;
890 
891  // Check each new segment for possible junctions and add/split if needed
892  for( SCH_LINE* wire : m_wires )
893  {
894  if( wire->HasFlag( SKIP_STRUCT ) )
895  continue;
896 
897  std::vector<wxPoint> tmpends = wire->GetConnectionPoints();
898 
899  new_ends.insert( new_ends.end(), tmpends.begin(), tmpends.end() );
900 
901  for( const wxPoint& pt : connections )
902  {
903  if( IsPointOnSegment( wire->GetStartPoint(), wire->GetEndPoint(), pt ) )
904  new_ends.push_back( pt );
905  }
906  itemList.PushItem( ITEM_PICKER( screen, wire, UNDO_REDO::NEWITEM ) );
907  }
908 
910  {
911  wxASSERT( m_busUnfold.entry && m_busUnfold.label );
912 
913  itemList.PushItem( ITEM_PICKER( screen, m_busUnfold.entry, UNDO_REDO::NEWITEM ) );
914  itemList.PushItem( ITEM_PICKER( screen, m_busUnfold.label, UNDO_REDO::NEWITEM ) );
916  }
917 
918  // Get the last non-null wire (this is the last created segment).
919  if( !m_wires.empty() )
921 
922  // Add the new wires
923  for( SCH_LINE* wire : m_wires )
924  {
925  wire->ClearFlags( IS_NEW | IS_MOVING );
926  m_frame->AddToScreen( wire, screen );
927  }
928 
929  m_wires.clear();
930  m_view->ClearPreview();
931  m_view->ShowPreview( false );
932 
933  getViewControls()->CaptureCursor( false );
934  getViewControls()->SetAutoPan( false );
935 
936  m_frame->SaveCopyInUndoList( itemList, UNDO_REDO::NEWITEM, false );
937 
938  // Correct and remove segments that need to be merged.
940 
941  std::vector<SCH_ITEM*> symbols;
942 
943  for( SCH_ITEM* symbol : m_frame->GetScreen()->Items().OfType( SCH_SYMBOL_T ) )
944  symbols.push_back( symbol );
945 
946  for( SCH_ITEM* symbol : symbols )
947  {
948  std::vector<wxPoint> pts = symbol->GetConnectionPoints();
949 
950  if( pts.size() > 2 )
951  continue;
952 
953  for( auto pt = pts.begin(); pt != pts.end(); pt++ )
954  {
955  for( auto secondPt = pt + 1; secondPt != pts.end(); secondPt++ )
956  m_frame->TrimWire( *pt, *secondPt );
957  }
958  }
959 
960  for( const wxPoint& pt : new_ends )
961  {
962  if( m_frame->GetScreen()->IsJunctionNeeded( pt, true ) )
963  m_frame->AddJunction( m_frame->GetScreen(), pt, true, false );
964  }
965 
967  m_busUnfold = {};
968 
971 
972  m_frame->OnModify();
973 }
EE_TYPE OfType(KICAD_T aType) const
Definition: sch_rtree.h:216
bool SchematicCleanUp(SCH_SCREEN *aScreen=nullptr)
Perform routine schematic cleaning including breaking wire and buses and deleting identical objects s...
void simplifyWireList()
Iterate over the wire list and removes the null segments and overlapping segments to create a simplif...
#define IS_NEW
New item, just created.
std::vector< SCH_LINE * > m_wires
Storage for the line segments while drawing.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool IsPointOnSegment(const wxPoint &aSegStart, const wxPoint &aSegEnd, const wxPoint &aTestPoint)
Test if aTestPoint is on line defined by aSegStart and aSegEnd.
Definition: trigo.cpp:42
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
void PushItem(const ITEM_PICKER &aItem)
Push aItem to the top of the list.
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:204
SCH_JUNCTION * AddJunction(SCH_SCREEN *aScreen, const wxPoint &aPos, bool aAppendToUndo, bool aFinal=true)
void ShowPreview(bool aShow=true)
Definition: view.cpp:1576
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
#define IS_MOVING
Item being moved.
void TestDanglingEnds()
Test all of the connectable objects in the schematic for unused connection points.
virtual void CaptureCursor(bool aEnabled)
Force the cursor to stay within the drawing panel area.
void SaveCopyForRepeatItem(const SCH_ITEM *aItem)
Clone aItem and owns that clone in this container.
void ClearPreview()
Definition: view.cpp:1540
std::vector< wxPoint > GetSchematicConnections()
Collect a unique list of all possible connection points in the schematic.
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:53
A holder to handle information on schematic or board items.
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
SCH_BUS_WIRE_ENTRY * entry
#define SKIP_STRUCT
flag indicating that the structure should be ignored
void AddToScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen)
Add an item to the screen (and view) aScreen is the screen the item is located on,...
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
void SaveCopyInUndoList(SCH_SCREEN *aScreen, SCH_ITEM *aItemToCopy, UNDO_REDO aTypeCommand, bool aAppend)
Create a copy of the current schematic item, and put it in the undo list.
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:110
bool IsJunctionNeeded(const wxPoint &aPosition, bool aNew=false) const
Test if a junction is required for the items at aPosition on the screen.
Definition: sch_screen.cpp:401
bool TrimWire(const wxPoint &aStart, const wxPoint &aEnd)
If any single wire passes through both points, remove the portion between the two points,...
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag of the current screen and u...
bool label_placed
True if user has placed the net label.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
void ClearEditFlags()
Definition: eda_item.h:172
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:193
BUS_UNFOLDING_T m_busUnfold
Data related to bus unfolding tool.
bool in_progress
True if bus unfold operation is running.

References SCH_EDIT_FRAME::AddJunction(), SCH_BASE_FRAME::AddToScreen(), KIGFX::VIEW_CONTROLS::CaptureCursor(), EDA_ITEM::ClearEditFlags(), KIGFX::VIEW::ClearPreview(), EE_ACTIONS::clearSelection, BUS_UNFOLDING_T::entry, SCH_EDIT_FRAME::GetSchematicConnections(), SCH_EDIT_FRAME::GetScreen(), TOOL_BASE::getViewControls(), BUS_UNFOLDING_T::in_progress, IS_MOVING, IS_NEW, SCH_SCREEN::IsJunctionNeeded(), IsPointOnSegment(), SCH_SCREEN::Items(), BUS_UNFOLDING_T::label, BUS_UNFOLDING_T::label_placed, m_busUnfold, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_BASE::m_toolMgr, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_view, m_wires, NEWITEM, EE_RTREE::OfType(), SCH_EDIT_FRAME::OnModify(), TOOL_MANAGER::PostEvent(), PICKED_ITEMS_LIST::PushItem(), TOOL_MANAGER::RunAction(), SCH_EDIT_FRAME::SaveCopyForRepeatItem(), SCH_EDIT_FRAME::SaveCopyInUndoList(), SCH_SYMBOL_T, SCH_EDIT_FRAME::SchematicCleanUp(), EVENTS::SelectedItemsModified, KIGFX::VIEW_CONTROLS::SetAutoPan(), KIGFX::VIEW::ShowPreview(), simplifyWireList(), SKIP_STRUCT, SCH_EDIT_FRAME::TestDanglingEnds(), and SCH_EDIT_FRAME::TrimWire().

Referenced by doDrawSegments().

◆ getEditFrame()

template<typename T >
T* TOOL_BASE::getEditFrame ( ) const
inlineprotectedinherited

Return the application window object, casted to requested user type.

Definition at line 184 of file tool_base.h.

185  {
186 #if !defined( QA_TEST ) // Dynamic casts give the linker a seizure in the test framework
187  wxASSERT( dynamic_cast<T*>( getToolHolderInt() ) );
188 #endif
189  return static_cast<T*>( getToolHolderInt() );
190  }
TOOLS_HOLDER * getToolHolderInt() const
Definition: tool_base.cpp:48

References TOOL_BASE::getToolHolderInt().

Referenced by ZONE_CREATE_HELPER::createNewZone().

◆ GetId()

TOOL_ID TOOL_BASE::GetId ( ) const
inlineinherited

Return the unique identifier of the tool.

The identifier is set by an instance of TOOL_MANAGER.

Returns
Identifier of the tool.

Definition at line 120 of file tool_base.h.

121  {
122  return m_toolId;
123  }
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209

References TOOL_BASE::m_toolId.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::isActive(), TOOL_MANAGER::RegisterTool(), ACTION_MANAGER::RunHotKey(), TOOL_MANAGER::runTool(), TOOL_MANAGER::saveViewControls(), and TOOL_MANAGER::ShutdownTool().

◆ GetManager()

TOOL_MANAGER* TOOL_BASE::GetManager ( ) const
inlineinherited

Return the instance of TOOL_MANAGER that takes care of the tool.

Returns
Instance of the TOOL_MANAGER or NULL if there is no associated tool manager.

Definition at line 143 of file tool_base.h.

144  {
145  return m_toolMgr;
146  }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_BASE::m_toolMgr.

Referenced by BOARD_COMMIT::BOARD_COMMIT(), ZONE_CREATE_HELPER::commitZone(), ZONE_CREATE_HELPER::createNewZone(), PCB_TOOL_BASE::doInteractiveItemPlacement(), ACTION_MENU::getToolManager(), LIB_TREE::onContextMenu(), ZONE_CREATE_HELPER::OnFirstPoint(), ACTION_MENU::OnMenuEvent(), and ZONE_CREATE_HELPER::performZoneCutout().

◆ getModel()

template<typename T >
T* TOOL_BASE::getModel ( ) const
inlineprotectedinherited

Return the model object if it matches the requested type.

Store the type of the tool.

Definition at line 196 of file tool_base.h.

References TOOL_BASE::getModelInt().

Referenced by ZONE_CREATE_HELPER::commitZone(), and ZONE_CREATE_HELPER::createZoneFromExisting().

◆ GetName()

const std::string& TOOL_BASE::GetName ( void  ) const
inlineinherited

Return the name of the tool.

Tool names are expected to obey the format: application.ToolName (eg. pcbnew.InteractiveSelection).

Returns
The name of the tool.

Definition at line 133 of file tool_base.h.

134  {
135  return m_toolName;
136  }
std::string m_toolName
Definition: tool_base.h:213

References TOOL_BASE::m_toolName.

Referenced by TOOL_MANAGER::dispatchInternal(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::invokeTool(), TOOL_MANAGER::RegisterTool(), and TOOL_MANAGER::runTool().

◆ getSheetPin()

const SCH_SHEET_PIN * SCH_LINE_WIRE_BUS_TOOL::getSheetPin ( const wxPoint &  aPosition)
private

Search for a sheet pin at a location.

Parameters
aPositiongrid point to search for existing sheet pin
Returns
Pointer to sheet pin or nullptr on failure

Definition at line 392 of file sch_line_wire_bus_tool.cpp.

393 {
394  SCH_SCREEN* screen = m_frame->GetScreen();
395 
396  for( SCH_ITEM* item : screen->Items().Overlapping( SCH_SHEET_T, aPosition ) )
397  {
398  SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
399 
400  for( SCH_SHEET_PIN* pin : sheet->GetPins() )
401  {
402  if( pin->GetPosition() == aPosition )
403  return pin;
404  }
405  }
406 
407  return nullptr;
408 }
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet_pin.h:65
EE_TYPE Overlapping(const EDA_RECT &aRect) const
Definition: sch_rtree.h:221
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:54
std::vector< SCH_SHEET_PIN * > & GetPins()
Definition: sch_sheet.h:184
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:110
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:193

References SCH_SHEET::GetPins(), SCH_EDIT_FRAME::GetScreen(), SCH_SCREEN::Items(), EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, EE_RTREE::Overlapping(), pin, and SCH_SHEET_T.

Referenced by computeBreakPoint().

◆ GetToolMenu()

◆ GetType()

TOOL_TYPE TOOL_BASE::GetType ( ) const
inlineinherited

Return the type of the tool.

Returns
The type of the tool.

Definition at line 108 of file tool_base.h.

109  {
110  return m_type;
111  }
TOOL_TYPE m_type
Unique identifier for the tool, assigned by a TOOL_MANAGER instance.
Definition: tool_base.h:206

References TOOL_BASE::m_type.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InvokeTool(), TOOL_MANAGER::ResetTools(), TOOL_MANAGER::runTool(), and TOOL_MANAGER::ShutdownTool().

◆ getView()

KIGFX::VIEW * TOOL_BASE::getView ( ) const
protectedinherited

Returns the instance of #VIEW object used in the application.

It allows tools to draw.

Returns
The instance of VIEW.

Definition at line 36 of file tool_base.cpp.

37 {
38  return m_toolMgr->GetView();
39 }
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:283
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_MANAGER::GetView(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCornerCondition(), ALIGN_DISTRIBUTE_TOOL::AlignLeft(), ALIGN_DISTRIBUTE_TOOL::AlignRight(), COMMON_TOOLS::CenterContents(), SCH_EDIT_TOOL::ChangeTextType(), EE_INSPECTION_TOOL::CheckSymbol(), GERBVIEW_CONTROL::ClearAllLayers(), PL_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::CollectHits(), computeBreakPoint(), COMMON_TOOLS::CursorControl(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), GERBVIEW_SELECTION_TOOL::disambiguationMenu(), PL_EDIT_TOOL::DoDelete(), doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), PL_SELECTION_TOOL::doSelectionMenu(), EE_SELECTION_TOOL::doSelectionMenu(), PCB_SELECTION_TOOL::doSelectionMenu(), COMMON_TOOLS::doZoomFit(), COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), DrawSegments(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), SCH_EDITOR_CONTROL::FindSymbolAndItem(), EE_SELECTION_TOOL::GetNode(), ROUTER_TOOL::getStartLayer(), PCB_CONTROL::GridResetOrigin(), PCB_CONTROL::GridSetOrigin(), ROUTER_TOOL::handleCommonEvents(), PL_SELECTION_TOOL::highlight(), EE_SELECTION_TOOL::highlight(), PCB_SELECTION_TOOL::highlight(), GERBVIEW_CONTROL::HighlightControl(), PNS::TOOL_BASE::highlightNet(), BOARD_INSPECTION_TOOL::highlightNet(), PCB_SELECTION_TOOL::hitTestDistance(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineDrag(), PCB_PICKER_TOOL::Main(), EE_POINT_EDITOR::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), SCH_MOVE_TOOL::moveItem(), PL_EDIT_TOOL::moveItem(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), COMMON_TOOLS::PanControl(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), ROUTER_TOOL::performRouting(), PNS::TOOL_BASE::pickSingleItem(), BOARD_EDITOR_CONTROL::PlaceFootprint(), PL_DRAWING_TOOLS::PlaceItem(), BOARD_EDITOR_CONTROL::PlaceTarget(), ROUTER_TOOL::prepareInteractive(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), EDIT_TOOL::Remove(), BOARD_EDITOR_CONTROL::Reset(), PNS::TOOL_BASE::Reset(), PCB_CONTROL::Reset(), GERBVIEW_SELECTION_TOOL::Reset(), DRAWING_TOOL::Reset(), EE_SELECTION_TOOL::Reset(), PCB_SELECTION_TOOL::Reset(), EE_TOOL_BASE< SCH_BASE_FRAME >::Reset(), SCH_EDIT_TOOL::Rotate(), GERBVIEW_SELECTION_TOOL::select(), GERBVIEW_SELECTION_TOOL::selectable(), PCB_SELECTION_TOOL::Selectable(), PCB_SELECTION_TOOL::SelectAll(), EE_SELECTION_TOOL::SelectAll(), PL_SELECTION_TOOL::selectionContains(), EE_SELECTION_TOOL::selectionContains(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::SelectPoint(), ZOOM_TOOL::selectRegion(), GERBVIEW_SELECTION_TOOL::selectVisually(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_EDITOR_CONTROL::ToggleHiddenFields(), SCH_EDITOR_CONTROL::ToggleHiddenPins(), SCH_DRAWING_TOOLS::TwoClickPlace(), PL_SELECTION_TOOL::unhighlight(), EE_SELECTION_TOOL::unhighlight(), PCB_SELECTION_TOOL::unhighlight(), GERBVIEW_SELECTION_TOOL::unselect(), GERBVIEW_SELECTION_TOOL::unselectVisually(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), SCH_EDITOR_CONTROL::UpdateFind(), PL_POINT_EDITOR::updateItem(), PCB_POINT_EDITOR::updateItem(), EE_TOOL_BASE< SCH_BASE_FRAME >::updateItem(), SCH_EDITOR_CONTROL::UpdateNetHighlighting(), EE_POINT_EDITOR::updateParentItem(), EE_POINT_EDITOR::updatePoints(), PL_POINT_EDITOR::updatePoints(), PCB_POINT_EDITOR::updatePoints(), PCB_SELECTION_TOOL::updateSelection(), PNS::TOOL_BASE::updateStartItem(), PCB_VIEWER_TOOLS::view(), PCB_TOOL_BASE::view(), PCB_SELECTION_TOOL::zoomFitSelection(), EE_SELECTION_TOOL::~EE_SELECTION_TOOL(), GERBVIEW_SELECTION_TOOL::~GERBVIEW_SELECTION_TOOL(), and PCB_SELECTION_TOOL::~PCB_SELECTION_TOOL().

◆ getViewControls()

KIGFX::VIEW_CONTROLS * TOOL_BASE::getViewControls ( ) const
protectedinherited

Return the instance of VIEW_CONTROLS object used in the application.

It allows tools to read & modify user input and its settings (eg. show cursor, enable snapping to grid, etc.).

Returns
The instance of VIEW_CONTROLS.

Definition at line 42 of file tool_base.cpp.

43 {
44  return m_toolMgr->GetViewControls();
45 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
KIGFX::VIEW_CONTROLS * GetViewControls() const
Definition: tool_manager.h:285

References TOOL_MANAGER::GetViewControls(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCorner(), PCB_POINT_EDITOR::addCorner(), EE_POINT_EDITOR::addCornerCondition(), SCH_EDITOR_CONTROL::AssignNetclass(), SCH_EDIT_TOOL::BreakWire(), PCB_TOOL_BASE::controls(), EDIT_TOOL::copyToClipboard(), SCH_DRAWING_TOOLS::createSheetPin(), COMMON_TOOLS::CursorControl(), doDrawSegments(), EDIT_TOOL::doMoveSelection(), doUnfoldBus(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), finishSegments(), SCH_DRAWING_TOOLS::GetCanvasFreeAreaPixels(), BOARD_INSPECTION_TOOL::HighlightNet(), SCH_EDITOR_CONTROL::HighlightNet(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), PCB_PICKER_TOOL::Main(), EE_POINT_EDITOR::Main(), PL_EDIT_TOOL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), EE_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), ROUTER_TOOL::performDragging(), LENGTH_TUNER_TOOL::performTuning(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), EDIT_TOOL::Remove(), SCH_EDIT_TOOL::RepeatDrawItem(), PL_SELECTION_TOOL::RequestSelection(), EE_SELECTION_TOOL::RequestSelection(), PCB_POINT_EDITOR::Reset(), DRAWING_TOOL::Reset(), COMMON_TOOLS::ResetLocalCoords(), GERBVIEW_SELECTION_TOOL::selectCursor(), PCB_SELECTION_TOOL::selectCursor(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::SelectNode(), ZOOM_TOOL::selectRegion(), ALIGN_DISTRIBUTE_TOOL::selectTarget(), PCB_PICKER_TOOL::setControls(), PICKER_TOOL::setControls(), EE_POINT_EDITOR::setEditedPoint(), PL_POINT_EDITOR::setEditedPoint(), PCB_POINT_EDITOR::setEditedPoint(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateItem(), PL_EDIT_TOOL::updateModificationPoint(), and COMMON_TOOLS::ZoomCenter().

◆ Go()

template<class T >
void TOOL_INTERACTIVE::Go ( int(T::*)(const TOOL_EVENT &)  aStateFunc,
const TOOL_EVENT_LIST aConditions = TOOL_EVENTTC_ANYTA_ANY ) 
)
inherited

Define which state (aStateFunc) to go when a certain event arrives (aConditions).

No conditions means any event.

Definition at line 147 of file tool_interactive.h.

149 {
150  TOOL_STATE_FUNC sptr = std::bind( aStateFunc, static_cast<T*>( this ), std::placeholders::_1 );
151 
152  goInternal( sptr, aConditions );
153 }
std::function< int(const TOOL_EVENT &)> TOOL_STATE_FUNC
Definition: tool_base.h:58
void goInternal(TOOL_STATE_FUNC &aState, const TOOL_EVENT_LIST &aConditions)

References TOOL_INTERACTIVE::goInternal().

Referenced by AUTOPLACE_TOOL::setTransitions(), ZOOM_TOOL::setTransitions(), LENGTH_TUNER_TOOL::setTransitions(), BOARD_REANNOTATE_TOOL::setTransitions(), GERBVIEW_INSPECTION_TOOL::setTransitions(), ROUTER_TOOL::setTransitions(), PCB_PICKER_TOOL::setTransitions(), SCH_NAVIGATE_TOOL::setTransitions(), SYMBOL_EDITOR_PIN_TOOL::setTransitions(), SYMBOL_EDITOR_MOVE_TOOL::setTransitions(), PL_DRAWING_TOOLS::setTransitions(), EE_POINT_EDITOR::setTransitions(), PL_POINT_EDITOR::setTransitions(), SCRIPTING_TOOL::setTransitions(), COMMON_CONTROL::setTransitions(), KICAD_MANAGER_CONTROL::setTransitions(), CONVERT_TOOL::setTransitions(), SYMBOL_EDITOR_DRAWING_TOOLS::setTransitions(), ZONE_FILLER_TOOL::setTransitions(), PCB_VIEWER_TOOLS::setTransitions(), MICROWAVE_TOOL::setTransitions(), EE_INSPECTION_TOOL::setTransitions(), PAD_TOOL::setTransitions(), PCB_POINT_EDITOR::setTransitions(), GERBVIEW_CONTROL::setTransitions(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::setTransitions(), GLOBAL_EDIT_TOOL::setTransitions(), GROUP_TOOL::setTransitions(), PL_EDITOR_CONTROL::setTransitions(), SYMBOL_EDITOR_EDIT_TOOL::setTransitions(), SYMBOL_EDITOR_CONTROL::setTransitions(), SCH_MOVE_TOOL::setTransitions(), PL_EDIT_TOOL::setTransitions(), POSITION_RELATIVE_TOOL::setTransitions(), GERBVIEW_SELECTION_TOOL::setTransitions(), SCH_DRAWING_TOOLS::setTransitions(), FOOTPRINT_EDITOR_CONTROL::setTransitions(), SCH_EDIT_TOOL::setTransitions(), ALIGN_DISTRIBUTE_TOOL::setTransitions(), COMMON_TOOLS::setTransitions(), PCB_CONTROL::setTransitions(), EDA_3D_CONTROLLER::setTransitions(), DRC_TOOL::setTransitions(), CVPCB_CONTROL::setTransitions(), setTransitions(), CVPCB_ASSOCIATION_TOOL::setTransitions(), BOARD_INSPECTION_TOOL::setTransitions(), BOARD_EDITOR_CONTROL::setTransitions(), PICKER_TOOL::setTransitions(), EDIT_TOOL::setTransitions(), PCB_SELECTION_TOOL::setTransitions(), PL_SELECTION_TOOL::setTransitions(), SCH_EDITOR_CONTROL::setTransitions(), DRAWING_TOOL::setTransitions(), and EE_SELECTION_TOOL::setTransitions().

◆ Init()

bool SCH_LINE_WIRE_BUS_TOOL::Init ( )
overridevirtual

Init() is called once upon a registration of the tool.

Returns
True if the initialization went fine, false - otherwise.

Reimplemented from TOOL_BASE.

Definition at line 179 of file sch_line_wire_bus_tool.cpp.

180 {
182 
183  auto wireOrBusTool =
184  [this]( const SELECTION& aSel )
185  {
188  };
189 
190  auto lineTool =
191  [this]( const SELECTION& aSel )
192  {
194  };
195 
196  auto belowRootSheetCondition =
197  [&]( const SELECTION& aSel )
198  {
199  return m_frame->GetCurrentSheet().Last() != &m_frame->Schematic().Root();
200  };
201 
202  auto busSelection = EE_CONDITIONS::MoreThan( 0 )
204 
205  auto& ctxMenu = m_menu.GetMenu();
206 
207  // Build the tool menu
208  //
209  ctxMenu.AddItem( EE_ACTIONS::leaveSheet, belowRootSheetCondition, 2 );
210 
211  ctxMenu.AddSeparator( 10 );
212  ctxMenu.AddItem( EE_ACTIONS::drawWire, wireOrBusTool && EE_CONDITIONS::Idle, 10 );
213  ctxMenu.AddItem( EE_ACTIONS::drawBus, wireOrBusTool && EE_CONDITIONS::Idle, 10 );
214  ctxMenu.AddItem( EE_ACTIONS::drawLines, lineTool && EE_CONDITIONS::Idle, 10 );
215  ctxMenu.AddItem( EE_ACTIONS::finishWire, IsDrawingWire, 10 );
216  ctxMenu.AddItem( EE_ACTIONS::finishBus, IsDrawingBus, 10 );
217  ctxMenu.AddItem( EE_ACTIONS::finishLine, IsDrawingLine, 10 );
218 
219  std::shared_ptr<BUS_UNFOLD_MENU> busUnfoldMenu = std::make_shared<BUS_UNFOLD_MENU>();
220  busUnfoldMenu->SetTool( this );
221  m_menu.AddSubMenu( busUnfoldMenu );
222  ctxMenu.AddMenu( busUnfoldMenu.get(), EE_CONDITIONS::Idle, 10 );
223 
224  ctxMenu.AddSeparator( 100 );
225  ctxMenu.AddItem( EE_ACTIONS::placeJunction, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
226  ctxMenu.AddItem( EE_ACTIONS::placeLabel, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
227  ctxMenu.AddItem( EE_ACTIONS::placeGlobalLabel, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
228  ctxMenu.AddItem( EE_ACTIONS::placeHierLabel, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
229  ctxMenu.AddItem( EE_ACTIONS::breakWire, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
230  ctxMenu.AddItem( EE_ACTIONS::breakBus, wireOrBusTool && EE_CONDITIONS::Idle, 100 );
231 
232  ctxMenu.AddSeparator( 200 );
233  ctxMenu.AddItem( EE_ACTIONS::selectNode, wireOrBusTool && EE_CONDITIONS::Idle, 200 );
234  ctxMenu.AddItem( EE_ACTIONS::selectConnection, wireOrBusTool && EE_CONDITIONS::Idle, 200 );
235 
236  // Add bus unfolding to the selection tool
237  //
239 
240  std::shared_ptr<BUS_UNFOLD_MENU> selBusUnfoldMenu = std::make_shared<BUS_UNFOLD_MENU>();
241  selBusUnfoldMenu->SetTool( m_selectionTool );
242  m_selectionTool->GetToolMenu().AddSubMenu( selBusUnfoldMenu );
243  selToolMenu.AddMenu( selBusUnfoldMenu.get(), busSelection && EE_CONDITIONS::Idle, 100 );
244 
245  return true;
246 }
void AddMenu(ACTION_MENU *aMenu, const SELECTION_CONDITION &aCondition=SELECTION_CONDITIONS::ShowAlways, int aOrder=ANY_ORDER)
Add a submenu to the menu.
bool IsCurrentTool(const TOOL_ACTION &aAction) const
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
static bool IsDrawingWire(const SELECTION &aSelection)
static TOOL_ACTION breakBus
Definition: ee_actions.h:131
SCH_SHEET * Last() const
Return a pointer to the last SCH_SHEET of the list.
static SELECTION_CONDITION MoreThan(int aNumber)
Create a functor that tests if the number of selected items is greater than the value given as parame...
static bool Idle(const SELECTION &aSelection)
Test if there no items selected or being edited.
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:46
static TOOL_ACTION placeHierLabel
Definition: ee_actions.h:84
static TOOL_ACTION placeJunction
Definition: ee_actions.h:80
static TOOL_ACTION selectConnection
If current selection is a wire or bus, expand to entire connection.
Definition: ee_actions.h:50
TOOL_MENU & GetToolMenu()
static bool IsDrawingLine(const SELECTION &aSelection)
static TOOL_ACTION breakWire
Definition: ee_actions.h:130
static TOOL_ACTION finishLine
Definition: ee_actions.h:93
static TOOL_ACTION leaveSheet
Definition: ee_actions.h:181
bool Init() override
Init() is called once upon a registration of the tool.
Definition: ee_tool_base.h:66
static TOOL_ACTION drawWire
Definition: ee_actions.h:76
SCHEMATIC & Schematic() const
EE_SELECTION_TOOL * m_selectionTool
Definition: ee_tool_base.h:177
static bool IsDrawingBus(const SELECTION &aSelection)
static TOOL_ACTION drawBus
Definition: ee_actions.h:77
static TOOL_ACTION placeLabel
Definition: ee_actions.h:82
SCH_SHEET & Root() const
Definition: schematic.h:92
void AddSubMenu(std::shared_ptr< ACTION_MENU > aSubMenu)
Store a submenu of this menu model.
Definition: tool_menu.cpp:52
static SELECTION_CONDITION OnlyType(KICAD_T aType)
Create a functor that tests if the selected items are only of given type.
static TOOL_ACTION selectNode
Select the junction, wire or bus segment under the cursor.
Definition: ee_actions.h:46
SCH_SHEET_PATH & GetCurrentSheet() const
static TOOL_ACTION drawLines
Definition: ee_actions.h:88
static TOOL_ACTION placeGlobalLabel
Definition: ee_actions.h:83
static TOOL_ACTION finishBus
Definition: ee_actions.h:92
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 TOOL_ACTION finishWire
Definition: ee_actions.h:91

References CONDITIONAL_MENU::AddItem(), CONDITIONAL_MENU::AddMenu(), TOOL_MENU::AddSubMenu(), EE_ACTIONS::breakBus, EE_ACTIONS::breakWire, EE_ACTIONS::drawBus, EE_ACTIONS::drawLines, EE_ACTIONS::drawWire, EE_ACTIONS::finishBus, EE_ACTIONS::finishLine, EE_ACTIONS::finishWire, SCH_EDIT_FRAME::GetCurrentSheet(), TOOL_MENU::GetMenu(), TOOL_INTERACTIVE::GetToolMenu(), SELECTION_CONDITIONS::Idle(), EE_TOOL_BASE< T >::Init(), TOOLS_HOLDER::IsCurrentTool(), IsDrawingBus(), IsDrawingLine(), IsDrawingWire(), SCH_SHEET_PATH::Last(), EE_ACTIONS::leaveSheet, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_INTERACTIVE::m_menu, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, SELECTION_CONDITIONS::MoreThan(), SELECTION_CONDITIONS::OnlyType(), EE_ACTIONS::placeGlobalLabel, EE_ACTIONS::placeHierLabel, EE_ACTIONS::placeJunction, EE_ACTIONS::placeLabel, SCHEMATIC::Root(), SCH_LINE_LOCATE_BUS_T, SCH_EDIT_FRAME::Schematic(), EE_ACTIONS::selectConnection, and EE_ACTIONS::selectNode.

◆ IsDrawingBus()

bool SCH_LINE_WIRE_BUS_TOOL::IsDrawingBus ( const SELECTION aSelection)
static

Definition at line 263 of file sch_line_wire_bus_tool.cpp.

264 {
265  static KICAD_T busType[] = { SCH_LINE_LOCATE_BUS_T, EOT };
266  return IsDrawingLineWireOrBus( aSelection ) && aSelection.Front()->IsType( busType );
267 }
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
virtual bool IsType(const KICAD_T aScanTypes[]) const
Check whether the item is one of the listed types.
Definition: eda_item.h:183
static bool IsDrawingLineWireOrBus(const SELECTION &aSelection)
EDA_ITEM * Front() const
Definition: selection.h:144

References EOT, SELECTION::Front(), IsDrawingLineWireOrBus(), EDA_ITEM::IsType(), and SCH_LINE_LOCATE_BUS_T.

Referenced by EE_SELECTION_TOOL::Init(), and Init().

◆ IsDrawingLine()

bool SCH_LINE_WIRE_BUS_TOOL::IsDrawingLine ( const SELECTION aSelection)
static

Definition at line 249 of file sch_line_wire_bus_tool.cpp.

250 {
251  static KICAD_T graphicLineType[] = { SCH_LINE_LOCATE_GRAPHIC_LINE_T, EOT };
252  return IsDrawingLineWireOrBus( aSelection ) && aSelection.Front()->IsType( graphicLineType );
253 }
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
virtual bool IsType(const KICAD_T aScanTypes[]) const
Check whether the item is one of the listed types.
Definition: eda_item.h:183
static bool IsDrawingLineWireOrBus(const SELECTION &aSelection)
EDA_ITEM * Front() const
Definition: selection.h:144

References EOT, SELECTION::Front(), IsDrawingLineWireOrBus(), EDA_ITEM::IsType(), and SCH_LINE_LOCATE_GRAPHIC_LINE_T.

Referenced by Init().

◆ IsDrawingLineWireOrBus()

bool SCH_LINE_WIRE_BUS_TOOL::IsDrawingLineWireOrBus ( const SELECTION aSelection)
static

Definition at line 270 of file sch_line_wire_bus_tool.cpp.

271 {
272  // NOTE: for immediate hotkeys, it is NOT required that the line, wire or bus tool
273  // be selected
274  SCH_ITEM* item = (SCH_ITEM*) aSelection.Front();
275  return item && item->IsNew() && item->Type() == SCH_LINE_T;
276 }
bool IsNew() const
Definition: eda_item.h:119
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:193
EDA_ITEM * Front() const
Definition: selection.h:144
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References SELECTION::Front(), EDA_ITEM::IsNew(), SCH_LINE_T, and EDA_ITEM::Type().

Referenced by SCH_EDIT_TOOL::Init(), SCH_MOVE_TOOL::Init(), IsDrawingBus(), IsDrawingLine(), and IsDrawingWire().

◆ IsDrawingWire()

bool SCH_LINE_WIRE_BUS_TOOL::IsDrawingWire ( const SELECTION aSelection)
static

Definition at line 256 of file sch_line_wire_bus_tool.cpp.

257 {
258  static KICAD_T wireType[] = { SCH_LINE_LOCATE_WIRE_T, EOT };
259  return IsDrawingLineWireOrBus( aSelection ) && aSelection.Front()->IsType( wireType );
260 }
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
virtual bool IsType(const KICAD_T aScanTypes[]) const
Check whether the item is one of the listed types.
Definition: eda_item.h:183
static bool IsDrawingLineWireOrBus(const SELECTION &aSelection)
EDA_ITEM * Front() const
Definition: selection.h:144

References EOT, SELECTION::Front(), IsDrawingLineWireOrBus(), EDA_ITEM::IsType(), and SCH_LINE_LOCATE_WIRE_T.

Referenced by EE_SELECTION_TOOL::Init(), and Init().

◆ IsToolActive()

bool TOOL_BASE::IsToolActive ( ) const
inherited

Definition at line 31 of file tool_base.cpp.

32 {
33  return m_toolMgr->IsToolActive( m_toolId );
34 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209
bool IsToolActive(TOOL_ID aId) const
Return true if a tool with given id is active (executing)

References TOOL_MANAGER::IsToolActive(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by ROUTER_TOOL::handleLayerSwitch(), EDIT_TOOL::isRouterActive(), PCB_SELECTION_TOOL::Main(), BOARD_EDITOR_CONTROL::TrackWidthDec(), and BOARD_EDITOR_CONTROL::TrackWidthInc().

◆ Reset()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::Reset ( RESET_REASON  aReason)
inlineoverridevirtualinherited

Bring the tool to a known, initial state.

If the tool claimed anything from the model or the view, it must release it when its reset.

Parameters
aReasoncontains information about the reason of tool reset.

Implements TOOL_BASE.

Definition at line 86 of file ee_tool_base.h.

87  {
88  if( aReason == MODEL_RELOAD )
89  {
90  // Init variables used by every drawing tool
91  m_frame = getEditFrame<T>();
92  m_isSymbolEditor = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_frame ) != nullptr;
93  }
94 
95  m_view = static_cast<KIGFX::SCH_VIEW*>( getView() );
96  }
Model changes (required full reload)
Definition: tool_base.h:80
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36

◆ RunMainStack()

void TOOL_INTERACTIVE::RunMainStack ( std::function< void()>  aFunc)
inherited

Call a function using the main stack.

Parameters
aFuncis the function to be calls.

Definition at line 87 of file tool_interactive.cpp.

88 {
89  m_toolMgr->RunMainStack( this, std::move( aFunc ) );
90 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
void RunMainStack(TOOL_BASE *aTool, std::function< void()> aFunc)

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::RunMainStack().

Referenced by DRAWING_TOOL::PlaceText().

◆ saveCopyInUndoList()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList ( EDA_ITEM aItem,
UNDO_REDO  aType,
bool  aAppend = false 
)
inlineprotectedinherited

Definition at line 134 of file ee_tool_base.h.

135  {
136  KICAD_T itemType = aItem->Type();
137  bool selected = aItem->IsSelected();
138 
139  // IS_SELECTED flag should not be set on undo items which were added for
140  // a drag operation.
141  if( selected && aItem->HasFlag( TEMP_SELECTED ) )
142  aItem->ClearSelected();
143 
144  if( m_isSymbolEditor )
145  {
146  SYMBOL_EDIT_FRAME* editFrame = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_frame );
147  wxASSERT( editFrame );
148 
149  editFrame->SaveCopyInUndoList( static_cast<LIB_ITEM*>( aItem ), aType, aAppend );
150  }
151  else
152  {
153  SCH_EDIT_FRAME* editFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
154  wxASSERT( editFrame );
155 
156  if( itemType == SCH_PIN_T || itemType == SCH_FIELD_T || itemType == SCH_SHEET_PIN_T )
157  {
158  editFrame->SaveCopyInUndoList( editFrame->GetScreen(),
159  static_cast<SCH_ITEM*>( aItem->GetParent() ),
160  UNDO_REDO::CHANGED, aAppend );
161  }
162  else
163  {
164  editFrame->SaveCopyInUndoList( editFrame->GetScreen(),
165  static_cast<SCH_ITEM*>( aItem ),
166  aType, aAppend );
167  }
168  }
169 
170  if( selected && aItem->HasFlag( TEMP_SELECTED ) )
171  aItem->SetSelected();
172  }
bool IsSelected() const
Definition: eda_item.h:123
void ClearSelected()
Definition: eda_item.h:132
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition: eda_item.h:156
Schematic editor (Eeschema) main window.
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
void SetSelected()
Definition: eda_item.h:129
void SaveCopyInUndoList(EDA_ITEM *aItem, UNDO_REDO aUndoType=UNDO_REDO::LIBEDIT, bool aAppend=false)
Create a copy of the current symbol, and save it in the undo list.
EDA_ITEM * GetParent() const
Definition: eda_item.h:115
#define TEMP_SELECTED
flag indicating that the structure has already selected
void SaveCopyInUndoList(SCH_SCREEN *aScreen, SCH_ITEM *aItemToCopy, UNDO_REDO aTypeCommand, bool aAppend)
Create a copy of the current schematic item, and put it in the undo list.
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
The symbol library editor main window.

◆ SetContextMenu()

void TOOL_INTERACTIVE::SetContextMenu ( ACTION_MENU aMenu,
CONTEXT_MENU_TRIGGER  aTrigger = CMENU_BUTTON 
)
inherited

Assign a context menu and tells when it should be activated.

Parameters
aMenuis the menu to be assigned.
aTriggerdetermines conditions upon which the context menu is activated.

Definition at line 76 of file tool_interactive.cpp.

77 {
78  if( aMenu )
79  aMenu->SetTool( this );
80  else
81  aTrigger = CMENU_OFF;
82 
83  m_toolMgr->ScheduleContextMenu( this, aMenu, aTrigger );
84 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
void SetTool(TOOL_INTERACTIVE *aTool)
Set a tool that is the creator of the menu.
void ScheduleContextMenu(TOOL_BASE *aTool, ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger)
Set behavior of the tool's context popup menu.

References CMENU_OFF, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ScheduleContextMenu(), and ACTION_MENU::SetTool().

Referenced by GERBVIEW_SELECTION_TOOL::disambiguationMenu(), PL_SELECTION_TOOL::doSelectionMenu(), EE_SELECTION_TOOL::doSelectionMenu(), PCB_SELECTION_TOOL::doSelectionMenu(), TOOL_MENU::ShowContextMenu(), and UnfoldBus().

◆ setTransitions()

void SCH_LINE_WIRE_BUS_TOOL::setTransitions ( )
overrideprivatevirtual

This method is meant to be overridden in order to specify handlers for events.

It is called every time tool is reset or finished.

Implements TOOL_INTERACTIVE.

Definition at line 1035 of file sch_line_wire_bus_tool.cpp.

1036 {
1041 
1043 }
int AddJunctionsIfNeeded(const TOOL_EVENT &aEvent)
Handle the addition of junctions to a selection of objects.
static TOOL_ACTION unfoldBus
Definition: ee_actions.h:78
int UnfoldBus(const TOOL_EVENT &aEvent)
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Define which state (aStateFunc) to go when a certain event arrives (aConditions).
static TOOL_ACTION drawWire
Definition: ee_actions.h:76
static TOOL_ACTION addNeededJunctions
Definition: ee_actions.h:72
static TOOL_ACTION drawBus
Definition: ee_actions.h:77
static TOOL_ACTION drawLines
Definition: ee_actions.h:88
int DrawSegments(const TOOL_EVENT &aEvent)

References AddJunctionsIfNeeded(), EE_ACTIONS::addNeededJunctions, EE_ACTIONS::drawBus, EE_ACTIONS::drawLines, DrawSegments(), EE_ACTIONS::drawWire, TOOL_INTERACTIVE::Go(), EE_ACTIONS::unfoldBus, and UnfoldBus().

◆ simplifyWireList()

void SCH_LINE_WIRE_BUS_TOOL::simplifyWireList ( )
private

Iterate over the wire list and removes the null segments and overlapping segments to create a simplified wire list.

In a contiguous list of wires, remove wires that backtrack over the previous wire.

Set up handlers for various events.

Example:

Wire is added: -------------------------------------—>

A second wire backtracks over it: ----------------—<====================>

simplifyWireList is called: ----------------—>

Definition at line 840 of file sch_line_wire_bus_tool.cpp.

841 {
842  for( auto it = m_wires.begin(); it != m_wires.end(); )
843  {
844  SCH_LINE* line = *it;
845 
846  if( line->IsNull() )
847  {
848  delete line;
849  it = m_wires.erase( it );
850  continue;
851  }
852 
853  auto next_it = it;
854  ++next_it;
855 
856  if( next_it == m_wires.end() )
857  break;
858 
859  SCH_LINE* next_line = *next_it;
860 
861  if( SCH_LINE* merged = line->MergeOverlap( m_frame->GetScreen(), next_line, false ) )
862  {
863  delete line;
864  delete next_line;
865  it = m_wires.erase( it );
866  *it = merged;
867  }
868 
869  ++it;
870  }
871 }
SCH_LINE * MergeOverlap(SCH_SCREEN *aScreen, SCH_LINE *aLine, bool aCheckJunctions)
Check line against aLine to see if it overlaps and merge if it does.
Definition: sch_line.cpp:453
std::vector< SCH_LINE * > m_wires
Storage for the line segments while drawing.
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
bool IsNull() const
Definition: sch_line.h:88
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37

References SCH_EDIT_FRAME::GetScreen(), SCH_LINE::IsNull(), EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_wires, and SCH_LINE::MergeOverlap().

Referenced by finishSegments().

◆ startSegments()

SCH_LINE * SCH_LINE_WIRE_BUS_TOOL::startSegments ( int  aType,
const VECTOR2D aPos 
)
private

Definition at line 794 of file sch_line_wire_bus_tool.cpp.

795 {
796  SCH_LINE* segment = nullptr;
797 
798  switch ( aType )
799  {
800  default: segment = new SCH_LINE( aPos, LAYER_NOTES ); break;
801  case LAYER_WIRE: segment = new SCH_LINE( aPos, LAYER_WIRE ); break;
802  case LAYER_BUS: segment = new SCH_LINE( aPos, LAYER_BUS ); break;
803  }
804 
805  // Give segments a parent so they find the default line/wire/bus widths
806  segment->SetParent( &m_frame->Schematic() );
807  segment->SetFlags( IS_NEW | IS_MOVING );
808  m_wires.push_back( segment );
809 
810  m_selectionTool->AddItemToSel( segment, true /*quiet mode*/ );
811 
812  // We need 2 segments to go from a given start pin to an end point when the
813  // horizontal and vertical lines only switch is on.
815  {
816  segment = new SCH_LINE( *segment );
817  segment->SetFlags( IS_NEW | IS_MOVING );
818  m_wires.push_back( segment );
819 
820  m_selectionTool->AddItemToSel( segment, true /*quiet mode*/ );
821  }
822 
823  return segment;
824 }
#define IS_NEW
New item, just created.
std::vector< SCH_LINE * > m_wires
Storage for the line segments while drawing.
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:116
EESCHEMA_SETTINGS * eeconfig() const
#define IS_MOVING
Item being moved.
SCHEMATIC & Schematic() const
EE_SELECTION_TOOL * m_selectionTool
Definition: ee_tool_base.h:177
int AddItemToSel(const TOOL_EVENT &aEvent)
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37

References EE_SELECTION_TOOL::AddItemToSel(), SCH_BASE_FRAME::eeconfig(), EESCHEMA_SETTINGS::DRAWING::hv_lines_only, IS_MOVING, IS_NEW, LAYER_BUS, LAYER_NOTES, LAYER_WIRE, EESCHEMA_SETTINGS::m_Drawing, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, m_wires, SCH_EDIT_FRAME::Schematic(), EDA_ITEM::SetFlags(), and EDA_ITEM::SetParent().

Referenced by doDrawSegments(), doUnfoldBus(), and DrawSegments().

◆ UnfoldBus()

int SCH_LINE_WIRE_BUS_TOOL::UnfoldBus ( const TOOL_EVENT aEvent)

Definition at line 301 of file sch_line_wire_bus_tool.cpp.

302 {
303  wxString* netPtr = aEvent.Parameter<wxString*>();
304  wxString net;
305  SCH_LINE* segment = nullptr;
306 
307  std::string tool = aEvent.GetCommandStr().get();
308  m_frame->PushTool( tool );
309  Activate();
310 
311  if( netPtr )
312  {
313  net = *netPtr;
314  delete netPtr;
315  }
316  else
317  {
318  BUS_UNFOLD_MENU unfoldMenu;
319  unfoldMenu.SetTool( this );
320  unfoldMenu.SetShowTitle();
321 
322  SetContextMenu( &unfoldMenu, CMENU_NOW );
323 
324  while( TOOL_EVENT* evt = Wait() )
325  {
326  if( evt->Action() == TA_CHOICE_MENU_CHOICE )
327  {
328  OPT<int> id = evt->GetCommandId();
329 
330  if( id && ( *id > 0 ) )
331  net = *evt->Parameter<wxString*>();
332 
333  break;
334  }
335  else if( evt->Action() == TA_CHOICE_MENU_CLOSED )
336  {
337  break;
338  }
339  else
340  {
341  evt->SetPassEvent();
342  }
343  }
344  }
345 
346  // Break a wire for the given net out of the bus
347  if( !net.IsEmpty() )
348  segment = doUnfoldBus( net );
349 
350  // If we have an unfolded wire to draw, then draw it
351  if( segment )
352  return doDrawSegments( tool, LAYER_WIRE, false );
353  else
354  {
355  m_frame->PopTool( tool );
356  return 0;
357  }
358 }
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Suspend execution of the tool until an event specified in aEventList arrives.
virtual void PushTool(const std::string &actionName)
NB: the definition of "tool" is different at the user level.
void SetContextMenu(ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
Assign a context menu and tells when it should be activated.
void SetTool(TOOL_INTERACTIVE *aTool)
Set a tool that is the creator of the menu.
virtual void PopTool(const std::string &actionName)
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432
Generic, UI-independent tool event.
Definition: tool_event.h:152
int doDrawSegments(const std::string &aTool, int aType, bool aQuitOnDraw)
OPT< std::string > GetCommandStr() const
Definition: tool_event.h:460
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
boost::optional< T > OPT
Definition: optional.h:7
void Activate()
Run the tool.
SCH_LINE * doUnfoldBus(const wxString &aNet, const wxPoint &aPos=wxDefaultPosition)

References TOOL_INTERACTIVE::Activate(), CMENU_NOW, doDrawSegments(), doUnfoldBus(), TOOL_EVENT::GetCommandStr(), LAYER_WIRE, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_EVENT::Parameter(), TOOLS_HOLDER::PopTool(), TOOLS_HOLDER::PushTool(), TOOL_INTERACTIVE::SetContextMenu(), BUS_UNFOLD_MENU::SetShowTitle(), ACTION_MENU::SetTool(), TA_CHOICE_MENU_CHOICE, TA_CHOICE_MENU_CLOSED, and TOOL_INTERACTIVE::Wait().

Referenced by setTransitions().

◆ updateItem()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem ( EDA_ITEM aItem,
bool  aUpdateRTree 
) const
inlineprotectedinherited

Similar to getView()->Update(), but handles items that are redrawn by their parents and updating the SCH_SCREEN's RTree.

Similar to m_frame->SaveCopyInUndoList(), but handles items that are owned by their parents.

Definition at line 103 of file ee_tool_base.h.

◆ Wait()

TOOL_EVENT * TOOL_INTERACTIVE::Wait ( const TOOL_EVENT_LIST aEventList = TOOL_EVENTTC_ANYTA_ANY ))
inherited

Suspend execution of the tool until an event specified in aEventList arrives.

No parameters means waiting for any event.

Definition at line 57 of file tool_interactive.cpp.

58 {
59  return m_toolMgr->ScheduleWait( this, aEventList );
60 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
TOOL_EVENT * ScheduleWait(TOOL_BASE *aTool, const TOOL_EVENT_LIST &aConditions)
Pause execution of a given tool until one or more events matching aConditions arrives.

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::ScheduleWait().

Referenced by GERBVIEW_SELECTION_TOOL::disambiguationMenu(), doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), PL_SELECTION_TOOL::doSelectionMenu(), EE_SELECTION_TOOL::doSelectionMenu(), PCB_SELECTION_TOOL::doSelectionMenu(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), PAD_TOOL::EnumeratePads(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), ZOOM_TOOL::Main(), PCB_PICKER_TOOL::Main(), EE_POINT_EDITOR::Main(), PL_EDIT_TOOL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), CVPCB_CONTROL::Main(), PL_POINT_EDITOR::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), PL_SELECTION_TOOL::Main(), EDA_3D_CONTROLLER::Main(), GERBVIEW_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), PCB_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), PCB_POINT_EDITOR::OnSelectionChange(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), GROUP_TOOL::PickNewMember(), EDIT_TOOL::pickReferencePoint(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), GERBVIEW_SELECTION_TOOL::selectPoint(), PCB_SELECTION_TOOL::selectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), ZOOM_TOOL::selectRegion(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), and UnfoldBus().

Member Data Documentation

◆ m_busUnfold

BUS_UNFOLDING_T SCH_LINE_WIRE_BUS_TOOL::m_busUnfold
private

Data related to bus unfolding tool.

Definition at line 132 of file sch_line_wire_bus_tool.h.

Referenced by doDrawSegments(), doUnfoldBus(), finishSegments(), and SCH_LINE_WIRE_BUS_TOOL().

◆ m_frame

SCH_EDIT_FRAME * EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame
protectedinherited

Definition at line 175 of file ee_tool_base.h.

◆ m_isSymbolEditor

bool EE_TOOL_BASE< SCH_EDIT_FRAME >::m_isSymbolEditor
protectedinherited

Definition at line 178 of file ee_tool_base.h.

◆ m_menu

TOOL_MENU TOOL_INTERACTIVE::m_menu
protectedinherited

The functions below are not yet implemented - their interface may change.

Definition at line 125 of file tool_interactive.h.

Referenced by doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), PAD_TOOL::EnumeratePads(), TOOL_INTERACTIVE::GetToolMenu(), ROUTER_TOOL::Init(), LENGTH_TUNER_TOOL::Init(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Init(), PL_EDIT_TOOL::Init(), SCH_EDIT_TOOL::Init(), PAD_TOOL::Init(), PL_DRAWING_TOOLS::Init(), SYMBOL_EDITOR_DRAWING_TOOLS::Init(), SYMBOL_EDITOR_CONTROL::Init(), PCB_VIEWER_TOOLS::Init(), FOOTPRINT_EDITOR_CONTROL::Init(), PL_SELECTION_TOOL::Init(), SCH_DRAWING_TOOLS::Init(), BOARD_EDITOR_CONTROL::Init(), GERBVIEW_SELECTION_TOOL::Init(), EDA_3D_CONTROLLER::Init(), DRAWING_TOOL::Init(), EE_SELECTION_TOOL::Init(), EE_TOOL_BASE< SCH_BASE_FRAME >::Init(), PCB_SELECTION_TOOL::Init(), Init(), PCB_TOOL_BASE::Init(), PICKER_TOOL::Init(), DRAWING_TOOL::InteractivePlaceWithPreview(), PCB_PICKER_TOOL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), PL_EDIT_TOOL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), EDA_3D_CONTROLLER::Main(), PL_SELECTION_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), PCB_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), and SCH_DRAWING_TOOLS::TwoClickPlace().

◆ m_selectionTool

EE_SELECTION_TOOL* EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool
protectedinherited

Definition at line 177 of file ee_tool_base.h.

◆ m_toolId

TOOL_ID TOOL_BASE::m_toolId
protectedinherited

Name of the tool.

Names are expected to obey the format application.ToolName (eg. pcbnew.InteractiveSelection).

Definition at line 209 of file tool_base.h.

Referenced by TOOL_INTERACTIVE::Activate(), TOOL_BASE::GetId(), and TOOL_BASE::IsToolActive().

◆ m_toolMgr

TOOL_MANAGER* TOOL_BASE::m_toolMgr
protectedinherited

Definition at line 214 of file tool_base.h.

Referenced by TOOL_INTERACTIVE::Activate(), PL_SELECTION_TOOL::AddItemsToSel(), EE_SELECTION_TOOL::AddItemsToSel(), PL_SELECTION_TOOL::AddItemToSel(), PCB_SELECTION_TOOL::AddItemToSel(), EE_SELECTION_TOOL::AddItemToSel(), SCH_MOVE_TOOL::AlignElements(), SCH_EDITOR_CONTROL::AssignNetclass(), CVPCB_ASSOCIATION_TOOL::Associate(), TOOL_BASE::attachManager(), SCH_EDIT_TOOL::AutoplaceFields(), SCH_EDIT_TOOL::BreakWire(), BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), ROUTER_TOOL::CanInlineDrag(), SCH_EDIT_TOOL::ChangeTextType(), EDIT_TOOL::ChangeTrackWidth(), SCH_EDIT_TOOL::CleanupSheetPins(), GERBVIEW_CONTROL::ClearAllLayers(), BOARD_INSPECTION_TOOL::ClearHighlight(), SCH_EDITOR_CONTROL::ClearHighlight(), PL_SELECTION_TOOL::ClearSelection(), PCB_SELECTION_TOOL::ClearSelection(), GERBVIEW_SELECTION_TOOL::clearSelection(), EE_SELECTION_TOOL::ClearSelection(), SCH_EDIT_TOOL::ConvertDeMorgan(), PL_EDIT_TOOL::Copy(), SYMBOL_EDITOR_EDIT_TOOL::Copy(), PAD_TOOL::copyPadSettings(), EDIT_TOOL::copyToClipboard(), MICROWAVE_TOOL::createInductorBetween(), BOARD_INSPECTION_TOOL::CrossProbePcbToSch(), COMMON_TOOLS::CursorControl(), SCH_EDITOR_CONTROL::Cut(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), PL_SELECTION_TOOL::disambiguateCursor(), EE_SELECTION_TOOL::disambiguateCursor(), PCB_SELECTION_TOOL::disambiguateCursor(), SCH_EDITOR_CONTROL::doCopy(), SCH_EDITOR_CONTROL::doCrossProbeSchToPcb(), SYMBOL_EDITOR_EDIT_TOOL::DoDelete(), SCH_EDIT_TOOL::DoDelete(), doDrawSegments(), BOARD_INSPECTION_TOOL::doHideNet(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), doUnfoldBus(), COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawRectangle(), DRAWING_TOOL::drawSegment(), DrawSegments(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::EditField(), SCH_EDIT_TOOL::editFieldText(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), SYMBOL_EDITOR_EDIT_TOOL::editGraphicProperties(), PAD_TOOL::EditPad(), SYMBOL_EDITOR_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithSymbolEditor(), GROUP_TOOL::EnterGroup(), SCH_NAVIGATE_TOOL::EnterSheet(), SCH_EDITOR_CONTROL::EnterSheet(), PAD_TOOL::EnumeratePads(), EE_INSPECTION_TOOL::ExcludeMarker(), PCB_SELECTION_TOOL::expandConnection(), PAD_TOOL::explodePad(), PCB_SELECTION_TOOL::filterSelection(), PCB_SELECTION_TOOL::FindItem(), SCH_EDITOR_CONTROL::FindSymbolAndItem(), finishSegments(), EDIT_TOOL::Flip(), EDIT_TOOL::GetAndPlace(), TOOL_BASE::GetManager(), TOOL_BASE::getModelInt(), DRAWING_TOOL::getSourceZoneForAction(), TOOL_BASE::getToolHolderInt(), TOOL_BASE::getView(), TOOL_BASE::getViewControls(), TOOL_INTERACTIVE::goInternal(), COMMON_TOOLS::GridNext(), COMMON_TOOLS::GridPreset(), COMMON_TOOLS::GridPrev(), PCB_CONTROL::GridSetOrigin(), GROUP_TOOL::Group(), GERBVIEW_CONTROL::HighlightControl(), BOARD_INSPECTION_TOOL::HighlightItem(), BOARD_INSPECTION_TOOL::HighlightNet(), SCH_EDITOR_CONTROL::HighlightNet(), BOARD_INSPECTION_TOOL::highlightNet(), SCH_EDITOR_CONTROL::HighlightNetCursor(), PL_EDIT_TOOL::ImportDrawingSheetContent(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), BOARD_REANNOTATE_TOOL::Init(), SYMBOL_EDITOR_EDIT_TOOL::Init(), PL_EDIT_TOOL::Init(), SCH_EDIT_TOOL::Init(), GROUP_TOOL::Init(), PAD_TOOL::Init(), CONVERT_TOOL::Init(), PL_DRAWING_TOOLS::Init(), GLOBAL_EDIT_TOOL::Init(), SYMBOL_EDITOR_CONTROL::Init(), PL_POINT_EDITOR::Init(), BOARD_INSPECTION_TOOL::Init(), ALIGN_DISTRIBUTE_TOOL::Init(), PCB_POINT_EDITOR::Init(), BOARD_EDITOR_CONTROL::Init(), POSITION_RELATIVE_TOOL::Init(), EE_TOOL_BASE< SCH_BASE_FRAME >::Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), BOARD_INSPECTION_TOOL::InspectClearance(), BOARD_INSPECTION_TOOL::InspectConstraints(), DRAWING_TOOL::InteractivePlaceWithPreview(), EDIT_TOOL::invokeInlineRouter(), EDIT_TOOL::isInteractiveDragEnabled(), EDIT_TOOL::isRouterActive(), TOOL_BASE::IsToolActive(), GROUP_TOOL::LeaveGroup(), SCH_NAVIGATE_TOOL::LeaveSheet(), SCH_EDITOR_CONTROL::LeaveSheet(), COMMON_CONTROL::ListHotKeys(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), PCB_PICKER_TOOL::Main(), PL_EDIT_TOOL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), CVPCB_CONTROL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), PL_SELECTION_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), PCB_SELECTION_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), PCB_VIEWER_TOOLS::MeasureTool(), SYMBOL_EDITOR_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::Mirror(), BOARD_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::MoveExact(), SYMBOL_EDITOR_CONTROL::OnDeMorgan(), PL_SELECTION_TOOL::onDisambiguationExpire(), EE_SELECTION_TOOL::onDisambiguationExpire(), PCB_SELECTION_TOOL::onDisambiguationExpire(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), PL_EDIT_TOOL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), PAD_TOOL::pastePadProperties(), ROUTER_TOOL::performRouting(), GROUP_TOOL::PickNewMember(), EDIT_TOOL::pickReferencePoint(), SYMBOL_EDITOR_EDIT_TOOL::PinTable(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), PCB_CONTROL::Print(), GERBVIEW_CONTROL::Print(), SYMBOL_EDITOR_EDIT_TOOL::Properties(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), EE_SELECTION_TOOL::RebuildSelection(), SYMBOL_EDITOR_EDIT_TOOL::Redo(), SCH_EDITOR_CONTROL::Redo(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), EDIT_TOOL::Remove(), PCB_POINT_EDITOR::removeCorner(), GROUP_TOOL::RemoveFromGroup(), PL_SELECTION_TOOL::RemoveItemFromSel(), EE_SELECTION_TOOL::RemoveItemFromSel(), PCB_SELECTION_TOOL::RemoveItemFromSel(), PL_SELECTION_TOOL::RemoveItemsFromSel(), EE_SELECTION_TOOL::RemoveItemsFromSel(), SCH_EDIT_TOOL::RepeatDrawItem(), SYMBOL_EDITOR_DRAWING_TOOLS::RepeatDrawItem(), EE_SELECTION_TOOL::RequestSelection(), PCB_SELECTION_TOOL::RequestSelection(), COMMON_TOOLS::Reset(), PNS::TOOL_BASE::Reset(), EDA_3D_CONTROLLER::Reset(), COMMON_TOOLS::ResetLocalCoords(), TOOL_INTERACTIVE::resetTransitions(), SYMBOL_EDITOR_EDIT_TOOL::Rotate(), SCH_EDIT_TOOL::Rotate(), EDIT_TOOL::Rotate(), TOOL_INTERACTIVE::RunMainStack(), DRC_TOOL::RunTests(), EE_SELECTION_TOOL::Selectable(), EE_SELECTION_TOOL::SelectConnection(), PCB_TOOL_BASE::selection(), COMMON_TOOLS::SelectionTool(), GERBVIEW_SELECTION_TOOL::SelectItem(), GERBVIEW_SELECTION_TOOL::SelectItems(), PCB_SELECTION_TOOL::SelectItems(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectNet(), PL_SELECTION_TOOL::SelectPoint(), GERBVIEW_SELECTION_TOOL::selectPoint(), EE_SELECTION_TOOL::selectPoint(), PCB_SELECTION_TOOL::selectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), PCB_SELECTION_TOOL::selectSameSheet(), PCB_SELECTION_TOOL::selectSheetContents(), DRAWING_TOOL::SetAnchor(), TOOL_INTERACTIVE::SetContextMenu(), EDA_3D_CONTROLLER::SetMaterial(), DRC_TOOL::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), EDA_3D_CONTROLLER::ToggleVisibility(), BOARD_EDITOR_CONTROL::TrackWidthDec(), BOARD_EDITOR_CONTROL::TrackWidthInc(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_EDIT_TOOL::Undo(), SCH_EDITOR_CONTROL::Undo(), GROUP_TOOL::Ungroup(), GERBVIEW_SELECTION_TOOL::UnselectItem(), GERBVIEW_SELECTION_TOOL::UnselectItems(), PCB_SELECTION_TOOL::UnselectItems(), PNS::TOOL_BASE::updateEndItem(), EE_INSPECTION_TOOL::UpdateMessagePanel(), GERBVIEW_CONTROL::UpdateMessagePanel(), PL_EDITOR_CONTROL::UpdateMessagePanel(), PCB_CONTROL::UpdateMessagePanel(), EDIT_TOOL::updateModificationPoint(), BOARD_INSPECTION_TOOL::UpdateSelectionRatsnest(), PNS::TOOL_BASE::updateStartItem(), BOARD_EDITOR_CONTROL::ViaSizeDec(), BOARD_EDITOR_CONTROL::ViaSizeInc(), TOOL_INTERACTIVE::Wait(), BOARD_EDITOR_CONTROL::ZoneDuplicate(), and BOARD_EDITOR_CONTROL::ZoneMerge().

◆ m_toolName

std::string TOOL_BASE::m_toolName
protectedinherited

Definition at line 213 of file tool_base.h.

Referenced by TOOL_BASE::GetName().

◆ m_type

TOOL_TYPE TOOL_BASE::m_type
protectedinherited

Unique identifier for the tool, assigned by a TOOL_MANAGER instance.

Definition at line 206 of file tool_base.h.

Referenced by TOOL_BASE::GetType(), and BOARD_COMMIT::Push().

◆ m_view

KIGFX::SCH_VIEW* EE_TOOL_BASE< SCH_EDIT_FRAME >::m_view
protectedinherited

Definition at line 176 of file ee_tool_base.h.

◆ m_wires

std::vector<SCH_LINE*> SCH_LINE_WIRE_BUS_TOOL::m_wires
private

Storage for the line segments while drawing.

Definition at line 135 of file sch_line_wire_bus_tool.h.

Referenced by doDrawSegments(), finishSegments(), SCH_LINE_WIRE_BUS_TOOL(), simplifyWireList(), and startSegments().


The documentation for this class was generated from the following files: