static double calcMaxArea( GENERAL_COLLECTOR& aCollector, KICAD_T aType ) { double best = 0.0; for( int i = 0; i < aCollector.GetCount(); i++ ) { BOARD_ITEM* item = aCollector[i]; if( item->Type() == aType ) best = std::max( best, calcArea( item ) ); } return best; }
void BOARD::ConvertBrdLayerToPolygonalContours( PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aOutlines ) { // convert tracks and vias: for( TRACK* track = m_Track; track != NULL; track = track->Next() ) { if( !track->IsOnLayer( aLayer ) ) continue; track->TransformShapeWithClearanceToPolygon( aOutlines, 0 ); } // convert pads for( MODULE* module = m_Modules; module != NULL; module = module->Next() ) { module->TransformPadsShapesWithClearanceToPolygon( aLayer, aOutlines, 0 ); // Micro-wave modules may have items on copper layers module->TransformGraphicShapesWithClearanceToPolygonSet( aLayer, aOutlines, 0 ); } // convert copper zones for( int ii = 0; ii < GetAreaCount(); ii++ ) { ZONE_CONTAINER* zone = GetArea( ii ); PCB_LAYER_ID zonelayer = zone->GetLayer(); if( zonelayer == aLayer ) zone->TransformSolidAreasShapesToPolygonSet( aOutlines ); } // convert graphic items on copper layers (texts) for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { if( !item->IsOnLayer( aLayer ) ) continue; switch( item->Type() ) { case PCB_LINE_T: ( (DRAWSEGMENT*) item )->TransformShapeWithClearanceToPolygon( aOutlines, 0 ); break; case PCB_TEXT_T: ( (TEXTE_PCB*) item )->TransformShapeWithClearanceToPolygonSet( aOutlines, 0 ); break; default: break; } } }
void PCB_DRAW_PANEL_GAL::DisplayBoard( const BOARD* aBoard ) { m_view->Clear(); // Load zones for( int i = 0; i < aBoard->GetAreaCount(); ++i ) m_view->Add( (KIGFX::VIEW_ITEM*) ( aBoard->GetArea( i ) ) ); // Load drawings for( BOARD_ITEM* drawing = aBoard->m_Drawings; drawing; drawing = drawing->Next() ) m_view->Add( drawing ); // Load tracks for( TRACK* track = aBoard->m_Track; track; track = track->Next() ) m_view->Add( track ); // Load modules and its additional elements for( MODULE* module = aBoard->m_Modules; module; module = module->Next() ) { module->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, m_view, _1 ) ); m_view->Add( module ); } // Segzones (equivalent of ZONE_CONTAINER for legacy boards) for( SEGZONE* zone = aBoard->m_Zone; zone; zone = zone->Next() ) m_view->Add( zone ); // Ratsnest if( m_ratsnest ) { m_view->Remove( m_ratsnest ); delete m_ratsnest; } m_ratsnest = new KIGFX::RATSNEST_VIEWITEM( aBoard->GetRatsnest() ); m_view->Add( m_ratsnest ); UseColorScheme( aBoard->GetColorsSettings() ); // We are expecting here the parent frame is a EDA_DRAW_FRAME or a derived class // (usually a BASE_PCB_FRAME, PCB_EDIT_FRAME ...) EDA_DRAW_FRAME* frame = dynamic_cast <EDA_DRAW_FRAME*> ( GetParent() ); if( frame ) { DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*) frame->GetDisplayOptions(); static_cast<KIGFX::PCB_RENDER_SETTINGS*>( m_view->GetPainter()->GetSettings() )->LoadDisplayOptions( displ_opts ); } m_view->RecacheAllItems( true ); }
/* Copy marked items, at new position = old position + offset */ void CopyMarkedItems( MODULE* module, wxPoint offset ) { if( module == NULL ) return; for( D_PAD* pad = module->Pads(); pad; pad = pad->Next() ) { if( !pad->IsSelected() ) continue; pad->ClearFlags( SELECTED ); D_PAD* NewPad = new D_PAD( *pad ); NewPad->SetParent( module ); NewPad->SetFlags( SELECTED ); module->Pads().PushFront( NewPad ); } BOARD_ITEM* newItem; for( BOARD_ITEM* item = module->GraphicalItems(); item; item = item->Next() ) { if( !item->IsSelected() ) continue; item->ClearFlags( SELECTED ); newItem = (BOARD_ITEM*)item->Clone(); newItem->SetParent( module ); newItem->SetFlags( SELECTED ); module->GraphicalItems().PushFront( newItem ); } MoveMarkedItems( module, offset ); }
int PCB_EDITOR_CONTROL::CrossProbeSchToPcb( const TOOL_EVENT& aEvent ) { BOARD_ITEM* item = aEvent.Parameter<BOARD_ITEM*>(); if( item ) { m_probingSchToPcb = true; getView()->SetCenter( VECTOR2D( item->GetPosition() ) ); m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); m_toolMgr->RunAction( COMMON_ACTIONS::selectItem, true, item ); } return 0; }
void FOOTPRINT_VIEWER_FRAME::UpdateMsgPanel() { BOARD_ITEM* footprint = GetBoard()->m_Modules; if( footprint ) { MSG_PANEL_ITEMS items; footprint->GetMsgPanelInfo( m_UserUnits, items ); SetMsgPanel( items ); } else ClearMsgPanel(); }
bool PCB_EDIT_FRAME::OnHotkeyFlipItem( int aIdCommand ) { BOARD_ITEM* item = GetCurItem(); bool itemCurrentlyEdited = item && item->GetFlags(); int evt_type = 0; // Used to post a wxCommandEvent on demand wxASSERT( aIdCommand == HK_FLIP_ITEM ); if( GetScreen()->m_BlockLocate.GetState() != STATE_NO_BLOCK ) { evt_type = ID_POPUP_FLIP_BLOCK; } else { if( !itemCurrentlyEdited ) item = PcbGeneralLocateAndDisplay(); if( item == NULL ) return false; SetCurItem( item ); switch( item->Type() ) { case PCB_MODULE_T: evt_type = ID_POPUP_PCB_CHANGE_SIDE_MODULE; break; case PCB_TEXT_T: evt_type = ID_POPUP_PCB_FLIP_TEXTEPCB; break; default: break; } } if( evt_type != 0 ) { wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED ); evt.SetEventObject( this ); evt.SetId( evt_type ); GetEventHandler()->ProcessEvent( evt ); return true; } else { return false; } }
// Plot footprints graphic items (outlines) void BRDITEMS_PLOTTER::Plot_Edges_Modules() { for( MODULE* module = m_board->m_Modules; module; module = module->Next() ) { for( BOARD_ITEM* item = module->GraphicalItems().GetFirst(); item; item = item->Next() ) { EDGE_MODULE* edge = dyn_cast<EDGE_MODULE*>( item ); if( !edge || !m_layerMask[edge->GetLayer()] ) continue; Plot_1_EdgeModule( edge ); } } }
int EDIT_TOOL::Rotate( const TOOL_EVENT& aEvent ) { const SELECTION& selection = m_selectionTool->GetSelection(); PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>(); // Shall the selection be cleared at the end? bool unselect = selection.Empty(); if( !hoverSelection( selection ) ) return 0; wxPoint rotatePoint = getModificationPoint( selection ); // If it is being dragged, then it is already saved with UR_CHANGED flag if( !isUndoInhibited() ) { editFrame->OnModify(); editFrame->SaveCopyInUndoList( selection.items, UR_ROTATED, rotatePoint ); } for( unsigned int i = 0; i < selection.items.GetCount(); ++i ) { BOARD_ITEM* item = selection.Item<BOARD_ITEM>( i ); item->Rotate( rotatePoint, editFrame->GetRotationAngle() ); if( !m_dragging ) item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); } updateRatsnest( m_dragging ); // Update dragging offset (distance between cursor and the first dragged item) m_offset = static_cast<BOARD_ITEM*>( selection.items.GetPickedItem( 0 ) )->GetPosition() - rotatePoint; if( m_dragging ) selection.group->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); else getModel<BOARD>()->GetRatsnest()->Recalculate(); if( unselect ) m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); m_toolMgr->RunAction( COMMON_ACTIONS::pointEditorUpdate, true ); return 0; }
void MODULE::DrawEdgesOnly( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset, GR_DRAWMODE draw_mode ) { for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_EDGE_T: item->Draw( panel, DC, draw_mode, offset ); break; default: break; } } }
static double calcMinArea( GENERAL_COLLECTOR& aCollector, KICAD_T aType ) { double best = std::numeric_limits<double>::max(); if( !aCollector.GetCount() ) return 0.0; for( int i = 0; i < aCollector.GetCount(); i++ ) { BOARD_ITEM* item = aCollector[i]; if( item->Type() == aType ) best = std::min( best, calcArea( item ) ); } return best; }
int EDIT_TOOL::Properties( const TOOL_EVENT& aEvent ) { const SELECTION& selection = m_selectionTool->GetSelection(); PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>(); // Shall the selection be cleared at the end? bool unselect = selection.Empty(); if( !hoverSelection( false ) ) return 0; // Tracks & vias are treated in a special way: if( ( SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::Tracks ) )( selection ) ) { DIALOG_TRACK_VIA_PROPERTIES dlg( editFrame, selection ); if( dlg.ShowModal() ) { dlg.Apply( *m_commit ); m_commit->Push( _( "Edit track/via properties" ) ); } } else if( selection.Size() == 1 ) // Properties are displayed when there is only one item selected { // Display properties dialog BOARD_ITEM* item = selection.Item<BOARD_ITEM>( 0 ); // Some of properties dialogs alter pointers, so we should deselect them m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); // Store flags, so they can be restored later STATUS_FLAGS flags = item->GetFlags(); item->ClearFlags(); // Do not handle undo buffer, it is done by the properties dialogs @todo LEGACY // Display properties dialog provided by the legacy canvas frame editFrame->OnEditItemRequest( NULL, item ); m_toolMgr->RunAction( COMMON_ACTIONS::editModifiedSelection, true ); item->SetFlags( flags ); } if( unselect ) m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); return 0; }
EDA_ITEM* SELECTION::GetTopLeftItem( bool onlyModules ) const { BOARD_ITEM* topLeftItem = nullptr; BOARD_ITEM* currentItem; wxPoint pnt; // find the leftmost (smallest x coord) and highest (smallest y with the smallest x) item in the selection for( auto item : m_items ) { currentItem = static_cast<BOARD_ITEM*>( item ); pnt = currentItem->GetPosition(); if( ( currentItem->Type() != PCB_MODULE_T ) && onlyModules ) { continue; } else { if( topLeftItem == nullptr ) { topLeftItem = currentItem; } else if( ( pnt.x < topLeftItem->GetPosition().x ) || ( ( topLeftItem->GetPosition().x == pnt.x ) && ( pnt.y < topLeftItem->GetPosition().y ) ) ) { topLeftItem = currentItem; } } } return static_cast<EDA_ITEM*>( topLeftItem ); }
int EDIT_TOOL::MoveExact( const TOOL_EVENT& aEvent ) { const SELECTION& selection = m_selectionTool->GetSelection(); // Shall the selection be cleared at the end? bool unselect = selection.Empty(); if( !hoverSelection() || m_selectionTool->CheckLock() == SELECTION_LOCKED ) return 0; wxPoint translation; double rotation = 0; PCB_BASE_FRAME* editFrame = getEditFrame<PCB_BASE_FRAME>(); DIALOG_MOVE_EXACT dialog( editFrame, translation, rotation ); int ret = dialog.ShowModal(); if( ret == wxID_OK ) { VECTOR2I rp = selection.GetCenter(); wxPoint rotPoint( rp.x, rp.y ); for( unsigned int i = 0; i < selection.items.GetCount(); ++i ) { BOARD_ITEM* item = selection.Item<BOARD_ITEM>( i ); m_commit->Modify( item ); item->Move( translation ); item->Rotate( rotPoint, rotation ); if( !m_dragging ) item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); } m_commit->Push( _( "Move exact" ) ); if( unselect ) m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); m_toolMgr->RunAction( COMMON_ACTIONS::editModifiedSelection, true ); } return 0; }
int EDIT_TOOL::Properties( const TOOL_EVENT& aEvent ) { const SELECTION& selection = m_selectionTool->GetSelection(); PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>(); if( !hoverSelection( selection, false ) ) return 0; // Properties are displayed when there is only one item selected if( selection.Size() == 1 ) { // Display properties dialog BOARD_ITEM* item = selection.Item<BOARD_ITEM>( 0 ); std::vector<PICKED_ITEMS_LIST*>& undoList = editFrame->GetScreen()->m_UndoList.m_CommandsList; // Some of properties dialogs alter pointers, so we should deselect them m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true ); STATUS_FLAGS flags = item->GetFlags(); item->ClearFlags(); // It is necessary to determine if anything has changed PICKED_ITEMS_LIST* lastChange = undoList.empty() ? NULL : undoList.back(); // Display properties dialog editFrame->OnEditItemRequest( NULL, item ); PICKED_ITEMS_LIST* currentChange = undoList.empty() ? NULL : undoList.back(); if( lastChange != currentChange ) // Something has changed { processChanges( currentChange ); updateRatsnest( true ); getModel<BOARD>()->GetRatsnest()->Recalculate(); item->ViewUpdate(); m_toolMgr->RunAction( COMMON_ACTIONS::pointEditorUpdate, true ); } item->SetFlags( flags ); } return 0; }
SELECTION_LOCK_FLAGS SELECTION_TOOL::CheckLock() { if( !m_locked || m_editModules ) return SELECTION_UNLOCKED; bool containsLocked = false; // Check if the selection contains locked items for( int i = 0; i < m_selection.Size(); ++i ) { BOARD_ITEM* item = m_selection.Item<BOARD_ITEM>( i ); switch( item->Type() ) { case PCB_MODULE_T: if( static_cast<MODULE*>( item )->IsLocked() ) containsLocked = true; break; case PCB_MODULE_EDGE_T: case PCB_MODULE_TEXT_T: if( static_cast<MODULE*>( item->GetParent() )->IsLocked() ) containsLocked = true; break; default: // suppress warnings break; } } if( containsLocked ) { if ( IsOK( m_frame, _( "Selection contains locked items. Do you want to continue?" ) ) ) { m_locked = false; return SELECTION_LOCK_OVERRIDE; } else return SELECTION_LOCKED; } m_locked = false; return SELECTION_UNLOCKED; }
std::set<BOARD_ITEM*> GRID_HELPER::queryVisible( const BOX2I& aArea ) const { std::set<BOARD_ITEM*> items; std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems; std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR>::iterator it, it_end; m_frame->GetGalCanvas()->GetView()->Query( aArea, selectedItems ); // Get the list of selected items for( it = selectedItems.begin(), it_end = selectedItems.end(); it != it_end; ++it ) { BOARD_ITEM* item = static_cast<BOARD_ITEM*>( it->first ); if( item->ViewIsVisible() ) items.insert ( item ); } return items; }
void MODULE::RunOnChildren( std::function<void (BOARD_ITEM*)> aFunction ) { try { for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) aFunction( static_cast<BOARD_ITEM*>( pad ) ); for( BOARD_ITEM* drawing = m_Drawings; drawing; drawing = drawing->Next() ) aFunction( drawing ); aFunction( static_cast<BOARD_ITEM*>( m_Reference ) ); aFunction( static_cast<BOARD_ITEM*>( m_Value ) ); } catch( std::bad_function_call& e ) { DisplayError( NULL, wxT( "Error running MODULE::RunOnChildren" ) ); } }
bool SELECTION_TOOL::selectionContains( const VECTOR2I& aPoint ) const { const unsigned GRIP_MARGIN = 20; VECTOR2D margin = getView()->ToWorld( VECTOR2D( GRIP_MARGIN, GRIP_MARGIN ), false ); // Check if the point is located within any of the currently selected items bounding boxes for( unsigned int i = 0; i < m_selection.items.GetCount(); ++i ) { BOARD_ITEM* item = m_selection.Item<BOARD_ITEM>( i ); BOX2I itemBox = item->ViewBBox(); itemBox.Inflate( margin.x, margin.y ); // Give some margin for gripping an item if( itemBox.Contains( aPoint ) ) return true; } return false; }
void EDIT_TOOL::processChanges( const PICKED_ITEMS_LIST* aList ) { KIGFX::VIEW* view = getView(); RN_DATA* ratsnest = getModel<BOARD>()->GetRatsnest(); for( unsigned int i = 0; i < aList->GetCount(); ++i ) { UNDO_REDO_T operation = aList->GetPickedItemStatus( i ); BOARD_ITEM* updItem = static_cast<BOARD_ITEM*>( aList->GetPickedItem( i ) ); switch( operation ) { case UR_CHANGED: ratsnest->Update( updItem ); // fall through case UR_MODEDIT: updItem->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); break; case UR_DELETED: if( updItem->Type() == PCB_MODULE_T ) static_cast<MODULE*>( updItem )->RunOnChildren( boost::bind( &KIGFX::VIEW::Remove, view, _1 ) ); view->Remove( updItem ); //ratsnest->Remove( updItem ); // this is done in BOARD::Remove break; case UR_NEW: if( updItem->Type() == PCB_MODULE_T ) static_cast<MODULE*>( updItem )->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, view, _1 ) ); view->Add( updItem ); //ratsnest->Add( updItem ); // this is done in BOARD::Add break; default: assert( false ); // Not handled break; } } }
void PCB_BASE_FRAME::ProcessItemSelection( wxCommandEvent& aEvent ) { int id = aEvent.GetId(); // index into the collector list: int itemNdx = id - ID_POPUP_PCB_ITEM_SELECTION_START; if( id >= ID_POPUP_PCB_ITEM_SELECTION_START && id <= ID_POPUP_PCB_ITEM_SELECTION_END ) { BOARD_ITEM* item = (*m_Collector)[itemNdx]; m_canvas->SetAbortRequest( false ); #if 0 && defined (DEBUG) item->Show( 0, std::cout ); #endif SetCurItem( item ); } }
void SELECTION_TOOL::clearSelection() { if( m_selection.Empty() ) return; KIGFX::VIEW_GROUP::const_iter it, it_end; // Restore the initial properties for( it = m_selection.group->Begin(), it_end = m_selection.group->End(); it != it_end; ++it ) { BOARD_ITEM* item = static_cast<BOARD_ITEM*>( *it ); item->ViewSetVisible( true ); item->ClearSelected(); } m_selection.clear(); getEditFrame<PCB_EDIT_FRAME>()->SetCurItem( NULL ); }
void PCB_BASE_FRAME::UpdateMsgPanel() { BOARD_ITEM* item = GetScreen()->GetCurItem(); MSG_PANEL_ITEMS items; if( item ) { item->GetMsgPanelInfo( items ); } else // show general information about the board { if( IsGalCanvasActive() ) GetGalCanvas()->GetMsgPanelInfo( items ); else m_Pcb->GetMsgPanelInfo( items ); } SetMsgPanel( items ); }
void FOOTPRINT_EDIT_FRAME::UpdateMsgPanel() { // If a item is currently selected, displays the item info. // If nothing selected, display the current footprint info BOARD_ITEM* item = GetScreen()->GetCurItem(); if( !item ) item = GetBoard()->m_Modules; MSG_PANEL_ITEMS items; if( item ) { item->GetMsgPanelInfo( m_UserUnits, items ); SetMsgPanel( items ); } else ClearMsgPanel(); }
void PCB_DRAW_PANEL_GAL::DisplayBoard( const BOARD* aBoard ) { m_view->Clear(); // Load zones for( int i = 0; i < aBoard->GetAreaCount(); ++i ) m_view->Add( (KIGFX::VIEW_ITEM*) ( aBoard->GetArea( i ) ) ); // Load drawings for( BOARD_ITEM* drawing = aBoard->m_Drawings; drawing; drawing = drawing->Next() ) m_view->Add( drawing ); // Load tracks for( TRACK* track = aBoard->m_Track; track; track = track->Next() ) m_view->Add( track ); // Load modules and its additional elements for( MODULE* module = aBoard->m_Modules; module; module = module->Next() ) { module->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, m_view, _1 ) ); m_view->Add( module ); } // Segzones (equivalent of ZONE_CONTAINER for legacy boards) for( SEGZONE* zone = aBoard->m_Zone; zone; zone = zone->Next() ) m_view->Add( zone ); // Ratsnest if( m_ratsnest ) { m_view->Remove( m_ratsnest ); delete m_ratsnest; } m_ratsnest = new KIGFX::RATSNEST_VIEWITEM( aBoard->GetRatsnest() ); m_view->Add( m_ratsnest ); UseColorScheme( aBoard->GetColorsSettings() ); static_cast<KIGFX::PCB_RENDER_SETTINGS*>( m_view->GetPainter()->GetSettings() )->LoadDisplayOptions( DisplayOpt ); m_view->RecacheAllItems( true ); }
void MODULE::SetOrientation( double newangle ) { double angleChange = newangle - m_Orient; // change in rotation wxPoint pt; NORMALIZE_ANGLE_POS( newangle ); m_Orient = newangle; for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { pt = pad->GetPos0(); pad->SetOrientation( pad->GetOrientation() + angleChange ); RotatePoint( &pt, m_Orient ); pad->SetPosition( GetPosition() + pt ); } // Update of the reference and value. m_Reference->SetDrawCoord(); m_Value->SetDrawCoord(); // Displace contours and text of the footprint. for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { if( item->Type() == PCB_MODULE_EDGE_T ) { EDGE_MODULE* edge = (EDGE_MODULE*) item; edge->SetDrawCoord(); } else if( item->Type() == PCB_MODULE_TEXT_T ) { TEXTE_MODULE* text = (TEXTE_MODULE*) item; text->SetDrawCoord(); } } CalculateBoundingBox(); }
void MODULE::ViewUpdate( int aUpdateFlags ) { if( !m_view ) return; // Update pads for( D_PAD* pad = m_Pads.GetFirst(); pad; pad = pad->Next() ) m_view->InvalidateItem( pad, aUpdateFlags ); // Update module's drawing (mostly silkscreen) for( BOARD_ITEM* drawing = m_Drawings.GetFirst(); drawing; drawing = drawing->Next() ) m_view->InvalidateItem( drawing, aUpdateFlags ); // Update module's texts m_view->InvalidateItem( m_Reference, aUpdateFlags ); m_view->InvalidateItem( m_Value, aUpdateFlags ); // Update the module itself m_view->InvalidateItem( this, aUpdateFlags ); }
void MODULE::ViewUpdate( int aUpdateFlags ) { if( !m_view ) return; // Update the module itself VIEW_ITEM::ViewUpdate( aUpdateFlags ); // Update pads for( D_PAD* pad = m_Pads.GetFirst(); pad; pad = pad->Next() ) pad->ViewUpdate( aUpdateFlags ); // Update module's drawing (mostly silkscreen) for( BOARD_ITEM* drawing = m_Drawings.GetFirst(); drawing; drawing = drawing->Next() ) drawing->ViewUpdate( aUpdateFlags ); // Update module's texts m_Reference->ViewUpdate( aUpdateFlags ); m_Value->ViewUpdate( aUpdateFlags ); }
static bool TestForExistingItem( BOARD* aPcb, BOARD_ITEM* aItem ) { static std::list<BOARD_ITEM*> itemsList; if( aItem == NULL ) // Build list { // Count items to store in itemsList: BOARD_ITEM* item; itemsList.clear(); // Store items in list: // Append tracks: for( item = aPcb->m_Track; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Append modules: for( item = aPcb->m_Modules; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Append drawings for( auto ditem : aPcb->Drawings() ) itemsList.push_back( ditem ); // Append zones outlines for( int ii = 0; ii < aPcb->GetAreaCount(); ii++ ) itemsList.push_back( aPcb->GetArea( ii ) ); NETINFO_LIST& netInfo = aPcb->GetNetInfo(); for( NETINFO_LIST::iterator i = netInfo.begin(); i != netInfo.end(); ++i ) itemsList.push_back( *i ); // Sort list itemsList.sort(); return false; } // search in list: return std::binary_search( itemsList.begin(), itemsList.end(), aItem ); }
bool FOOTPRINT_EDIT_FRAME::OnHotkeyRotateItem( int aIdCommand ) { BOARD_ITEM* item = GetCurItem(); bool itemCurrentlyEdited = item && item->GetFlags(); int evt_type = 0; // Used to post a wxCommandEvent on demand bool blockActive = GetScreen()->m_BlockLocate.GetCommand() != BLOCK_IDLE; if( blockActive ) return false; if( !itemCurrentlyEdited ) item = ModeditLocateAndDisplay(); if( item == NULL ) return false; SetCurItem( item ); switch( item->Type() ) { case PCB_MODULE_TEXT_T: if( aIdCommand == HK_ROTATE_ITEM ) // Rotation evt_type = ID_POPUP_PCB_ROTATE_TEXTMODULE; break; default: break; } if( evt_type != 0 ) { wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED ); evt.SetEventObject( this ); evt.SetId( evt_type ); wxPostEvent( this, evt ); return true; } return false; }