419 lines
14 KiB
C++
419 lines
14 KiB
C++
/***************************************/
|
|
/* prototypage des fonctions de PCBNEW */
|
|
/***************************************/
|
|
|
|
#ifndef PROTO_H
|
|
#define PROTO_H
|
|
|
|
|
|
#include <vector>
|
|
|
|
|
|
class COMMAND;
|
|
|
|
|
|
/* install function for DialogNonCopperZonesEditor dialog frame :*/
|
|
bool InstallDialogNonCopperZonesEditor(WinEDA_PcbFrame* aParent, ZONE_CONTAINER* aZone);
|
|
|
|
/***************/
|
|
/* PAD_CONNECT.CPP */
|
|
/***************/
|
|
|
|
class D_PAD;
|
|
|
|
/**
|
|
* Function CreateSortedPadListByXCoord
|
|
* first empties then fills the vector with all pads and sorts them by
|
|
* increasing x coordinate. The vector only holds pointers to the pads and
|
|
* those pointers are only references to pads which are owned by the BOARD
|
|
* through other links.
|
|
* @param aBoard Which board to gather pads from.
|
|
* @param aVector Where to put the pad pointers.
|
|
*/
|
|
void CreateSortedPadListByXCoord( BOARD* aBoard, std::vector<D_PAD*>* aVector );
|
|
|
|
|
|
/* Create a sorted list of pointers to pads.
|
|
* This list is sorted by X ccordinate value.
|
|
* The list must be freed bu user
|
|
*/
|
|
|
|
/**************/
|
|
/* PCBCFG.CPP */
|
|
/**************/
|
|
bool Read_Config( const wxString& project_name );
|
|
bool Read_Hotkey_Config( WinEDA_DrawFrame* frame, bool verbose );
|
|
|
|
|
|
/***************/
|
|
/* TRPISTE.CPP */
|
|
/***************/
|
|
|
|
void Trace_Une_Piste( WinEDA_DrawPanel* panel,
|
|
wxDC* DC,
|
|
TRACK* pt_start_piste,
|
|
int nbsegment,
|
|
int mode_color );
|
|
|
|
/* routine de trace de n segments consecutifs en memoire.
|
|
* Utile pour monter une piste en cours de trace car les segments de cette
|
|
* piste sont alors contigus en memoire
|
|
* Parametres :
|
|
* pt_start_piste = adresse de depart de la liste des segments
|
|
* nbsegment = nombre de segments a tracer
|
|
* mode_color = mode ( GrXOR, GrOR..)
|
|
* ATTENTION:
|
|
* le point de depart d'une piste suivante DOIT exister: peut etre
|
|
* donc mis a 0 avant appel a la routine si la piste a tracer est la derniere
|
|
*/
|
|
|
|
|
|
/****************/
|
|
/* TRACEMOD.C : */
|
|
/****************/
|
|
void Trace_Pads_Only( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* Module, int ox, int oy,
|
|
int MasqueLayer, int mode_color );
|
|
|
|
/* Trace les pads d'un module en mode SKETCH.
|
|
* Utilisee pour afficher les pastilles d'un module lorsque celui ci n'est
|
|
* pas affiche par les options d'affichage des Modules
|
|
* Les pads affiches doivent apparaitre sur les couches donnees par
|
|
* MasqueLayer */
|
|
|
|
/****************/
|
|
/* LOCATE.CPP : */
|
|
/****************/
|
|
|
|
/* Recherche d'une empreinte par son nom */
|
|
|
|
/* Recherche d'un pad par son nom, pour le module Module */
|
|
|
|
TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 );
|
|
|
|
/**
|
|
* Function Locate_Via_Area
|
|
* finds the first SEGVIA which covers the given aPos with a matching layer.
|
|
* @param aStart The starting TRACK or SEGVIA in the BOARD's list.
|
|
* @param aPos The wxPoint to HitTest() against.
|
|
* @param aLayer The layer to match, pass -1 for a don't care.
|
|
* @return TRACK* - actually a SEGVIA* if found, else NULL.
|
|
*/
|
|
TRACK* Locate_Via_Area( TRACK* aStart, const wxPoint& aPos, int aLayer = -1 );
|
|
|
|
TRACK* Fast_Locate_Via( TRACK* start_adr, TRACK* end_adr,
|
|
const wxPoint& pos, int masquelayer );
|
|
|
|
/* Localise la via de centre le point x,y , sur les couches donnees
|
|
* par masquelayer.
|
|
* la recherche se fait de l'adresse start_adr a end_adr(non comprise)
|
|
*/
|
|
|
|
TRACK* Fast_Locate_Piste( TRACK* start_adr, TRACK* end_adr,
|
|
const wxPoint& ref_pos, int masquelayer );
|
|
|
|
/* Localiste le segment dont une extremite coincide avec le point x,y
|
|
* sur les couches donnees par masquelayer
|
|
* la recherche se fait de l'adresse start_adr a end_adr(non comprise)
|
|
*/
|
|
|
|
TRACK* Locate_Piste_Connectee( TRACK* ptr_piste, TRACK* pt_base,
|
|
TRACK* pt_lim, int extr );
|
|
|
|
/* recherche le segment connecte au segment pointe par
|
|
* ptr_piste:
|
|
* si int = START, le point de debut du segment est utilise
|
|
* si int = END, le point de fin du segment est utilise
|
|
* La recherche ne se fait que sur les EXTREMITES des segments
|
|
* La recherche est limitee a la zone [pt_base...]pt_lim.
|
|
*/
|
|
|
|
TRACK* Locate_Pistes( TRACK* start_adresse, int layer, int typeloc );
|
|
TRACK* Locate_Pistes( TRACK* start_adresse,
|
|
const wxPoint& ref_pos, int layer );
|
|
|
|
/*
|
|
* 1 - routine de localisation du segment de piste pointe par la souris.
|
|
* 2 - routine de localisation du segment de piste pointe par le point
|
|
* ref_pX , ref_pY.
|
|
*
|
|
* Si layer < 0 la couche n'est pas testee.
|
|
*
|
|
* La recherche commence a l'adresse start_adresse
|
|
*/
|
|
|
|
D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_segment, int extr );
|
|
|
|
/* localisation de la pastille connectee au debut ou fin du segment
|
|
* entree : pointeur sur le segment, et flag = START ou END
|
|
* retourne:
|
|
* un pointeur sur la description de la pastille si localisation
|
|
* pointeur NULL si pastille non trouvee */
|
|
|
|
D_PAD* Locate_Any_Pad( BOARD* Pcb, int typeloc, bool OnlyCurrentLayer = FALSE );
|
|
D_PAD* Locate_Any_Pad( BOARD* Pcb, const wxPoint& ref_pos, bool OnlyCurrentLayer = FALSE );
|
|
|
|
/*
|
|
* localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou
|
|
* par la souris, recherche faite sur toutes les empreintes.
|
|
* entree : (OVERHAEAD)
|
|
* - coord souris (Curseur_X et Curseur_Y)
|
|
* ou ref_pX, ref_pY
|
|
* retourne:
|
|
* pointeur sur la description de la pastille si localisation
|
|
* pointeur NULL si pastille non trouvee
|
|
*/
|
|
|
|
D_PAD* Locate_Pads( MODULE* Module, int layer, int typeloc );
|
|
D_PAD* Locate_Pads( MODULE* Module, const wxPoint& ref_pos, int layer );
|
|
|
|
/* localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou
|
|
* par la souris, concernant l'empreinte en cours.
|
|
* entree :
|
|
* - parametres generaux de l'empreinte mise a jous par caract()
|
|
* - layer = couche ou doit se trouver la pastille
|
|
* (si layer < 0 ) la couche est ignoree)
|
|
* retourne:
|
|
* un pointeur sur la description de la pastille si localisation
|
|
* pointeur NULL si pastille non trouvee
|
|
*/
|
|
|
|
MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc );
|
|
|
|
/* localisation d'une empreinte par son rectangle d'encadrement */
|
|
|
|
D_PAD* Locate_Pads( MODULE* Module, int typeloc );
|
|
|
|
/* localisation de la pastille pointee par la souris, concernant l'empreinte
|
|
* Module.
|
|
* entree :
|
|
* - parametres generaux de l'empreinte mise a jous par caract()
|
|
* retourne:
|
|
* un pointeur sur la description de la pastille si localisation
|
|
* pointeur NULL si pastille non trouvee
|
|
*/
|
|
|
|
TRACK* Locate_Pistes( TRACK* start_adresse, int typeloc );
|
|
|
|
/* routine de localisation du segment de piste pointe par la souris
|
|
* La recherche commence a l'adresse start_adresse */
|
|
|
|
DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc );
|
|
|
|
|
|
D_PAD* Fast_Locate_Pad_Connecte( BOARD* Pcb, const wxPoint& ref_pos, int layer );
|
|
|
|
/* Routine cherchant le pad contenant le point px,py, sur la couche layer
|
|
* ( extremite de piste )
|
|
* La liste des pads doit deja exister.
|
|
*
|
|
* retourne :
|
|
* NULL si pas de pad localise.
|
|
* pointeur sur le pad correspondante si pad trouve
|
|
* (bonne position ET bonne couche). */
|
|
|
|
|
|
TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc );
|
|
TRACK* Locate_Zone( TRACK* start_adresse, const wxPoint& ref_pos, int layer );
|
|
|
|
/*
|
|
* 1 - routine de localisation du segment de zone pointe par la souris.
|
|
* 2 - routine de localisation du segment de zone pointe par le point
|
|
* ref_pX , ref_pY.r
|
|
*
|
|
* Si layer == -1 , le tst de la couche n'est pas fait
|
|
*
|
|
* La recherche commence a l'adresse start_adresse
|
|
*/
|
|
|
|
|
|
/*************/
|
|
/* MODULES.C */
|
|
/*************/
|
|
int ChangeSideNumLayer( int oldlayer );
|
|
void DrawModuleOutlines( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* module );
|
|
void Montre_Position_Empreinte( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
|
|
|
|
|
|
/* LOADCMP.C : */
|
|
MODULE* Load_Module_From_Library( WinEDA_DrawFrame* frame, wxDC* DC );
|
|
|
|
/****************/
|
|
/* EDITRACK.C : */
|
|
/****************/
|
|
|
|
TRACK* LocateIntrusion( TRACK* start, int net, int width );
|
|
|
|
void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel,
|
|
wxDC* DC, bool erase );
|
|
|
|
void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy );
|
|
|
|
/* determine les coord fx et fy d'un segment
|
|
* pour avoir un segment oriente a 0, 90 ou 45 degres, selon position
|
|
* du point d'origine (ox,oy) et de la souris */
|
|
|
|
/*****************/
|
|
/* TRACK.CPP : */
|
|
/*****************/
|
|
TRACK* Marque_Une_Piste( WinEDA_BasePcbFrame* frame, wxDC* DC,
|
|
TRACK* pt_segm, int* nb_segm, int flagcolor );
|
|
|
|
/* Routine de Marquage de 1 piste, a partir du segment pointe par pt_segm.
|
|
* le segment pointe est marque puis les segments adjacents
|
|
* jusqu'a un pad ou un point de jonction de plus de 2 segments
|
|
* le marquage est la mise a 1 du bit BUSY du parametre .status
|
|
* Les segments sont ensuite reclasses pour etre contigus en memoire
|
|
* Retourne:
|
|
* adresse du 1er segment de la chaine creee
|
|
* nombre de segments */
|
|
|
|
int ReturnEndsTrack( TRACK* RefTrack, int NbSegm,
|
|
TRACK** StartTrack, TRACK** EndTrack );
|
|
|
|
/* Calcule les coordonnes des extremites d'une piste
|
|
* retourne 1 si OK, 0 si piste bouclee
|
|
* Les coord sont retournees en StartTrack->ox, oy
|
|
* et EndTrack->fx, fy si OK
|
|
* Les segments sont supposes chaines de facon consecutive */
|
|
|
|
void ListSetState( EDA_BaseStruct* Start, int Nbitem, int State, int onoff );
|
|
|
|
/* Met a jour le membre .state d'une chaine de structures */
|
|
|
|
|
|
/************/
|
|
/* DRC.CPP : */
|
|
/************/
|
|
int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
|
|
TRACK* pt_segment, TRACK* pt_start_buffer, int show_err );
|
|
|
|
/* Teste le segment pointe par pt_segment:
|
|
* debsegment = adresse du segment a tester
|
|
* pt_start_buffer = adresse de la zone piste
|
|
* show_err (flag) si 0 pas d'affichage d'erreur sur ecran
|
|
* retourne :
|
|
* BAD_DRC (1) si Violation DRC
|
|
* OK_DRC (0) si OK */
|
|
|
|
|
|
/*****************/
|
|
/* TR_MODIF.CPP : */
|
|
/*****************/
|
|
|
|
int EraseOldTrack( WinEDA_BasePcbFrame* frame, BOARD* Pcb, wxDC* DC,
|
|
TRACK* pt_new_track, int nbptnewpiste );
|
|
void Modif_Auto_Route( TRACK* pt_debut_new_piste );
|
|
|
|
|
|
/**************/
|
|
/* CLEAN.CPP : */
|
|
/**************/
|
|
|
|
int Netliste_Controle_piste( WinEDA_PcbFrame* frame, wxDC* DC, int affiche );
|
|
|
|
/* Supprime les segments mal connectes, cad interconnectant des segments
|
|
* de net_code differents */
|
|
|
|
|
|
/************/
|
|
/* BLOCK.CPP */
|
|
/************/
|
|
|
|
void Block_Affiche( int on_off ); /*
|
|
* routine de trace du cadre d'un Block en cours de delimitation
|
|
* Si on_off = 0 : effacement du cadre
|
|
* Si on_off = 1 : affichage du cadre */
|
|
|
|
void Trace_Block( WinEDA_DrawPanel* panel, wxDC* DC, int ox, int oy, int fx, int fy, int color );
|
|
|
|
/* Routine de trace d'un rectangle symbolisant un block
|
|
* (toujours en mode XOR) */
|
|
|
|
|
|
/*****************************************************************/
|
|
/* AFFICHE.CPP: (Fonctions d'affichage de messages, parametres... */
|
|
/*****************************************************************/
|
|
void Affiche_Infos_Equipot( int netcode, WinEDA_BasePcbFrame* frame );
|
|
|
|
/************/
|
|
/* ZONES.CPP */
|
|
/************/
|
|
int Propagation( WinEDA_PcbFrame* frame );
|
|
|
|
/***************/
|
|
/* ATTRIBUT.CPP */
|
|
/***************/
|
|
|
|
void MasqueAttributs( int* masque_set, int* masque_clr );
|
|
|
|
/* Calcule les attributs a remettre a 0 (masque_clr) et a mettre a 1
|
|
* (masque_set), en fonction des options d'attributs
|
|
*
|
|
* ces attributs sont normalement le membre .flags de la structure TRACK
|
|
* les pointeurs NULLs sont acceptes
|
|
*/
|
|
|
|
|
|
/***************/
|
|
/* DUPLTRAC.CPP */
|
|
/***************/
|
|
|
|
EDA_BaseStruct* LocateLockPoint( BOARD* Pcb, wxPoint pos, int LayerMask );
|
|
|
|
/* Routine trouvant le point " d'accrochage " d'une extremite de piste.
|
|
* Ce point peut etre un PAD ou un autre segment de piste
|
|
* Retourne:
|
|
* - pointeur sur ce PAD ou:
|
|
* - pointeur sur le segment ou:
|
|
* - NULL
|
|
* Parametres d'appel:
|
|
* coord pX, pY du point tst
|
|
* masque des couches a tester
|
|
*/
|
|
|
|
|
|
TRACK* CreateLockPoint( int* pX, int* pY, TRACK* ptsegm, TRACK* refsegm );
|
|
|
|
/* Routine de creation d'un point intermediaire sur un segment
|
|
* le segment ptsegm est casse en 2 segments se raccordant au point pX, pY
|
|
* retourne:
|
|
* NULL si pas de nouveau point ( c.a.d si pX, pY correspondait deja
|
|
* a une extremite ou:
|
|
* pointeur sur le segment cree
|
|
* si refsegm != NULL refsegm est pointeur sur le segment incident,
|
|
* et le point cree est l'ntersection des 2 axes des segments ptsegm et
|
|
* refsegm
|
|
* retourne la valeur exacte de pX et pY
|
|
*/
|
|
|
|
/****************/
|
|
/* CONTROLE.CPP */
|
|
/****************/
|
|
void RemoteCommand( const char* cmdline );
|
|
bool Project( wxPoint* res, wxPoint on_grid, const TRACK* track );
|
|
|
|
|
|
/***************/
|
|
/* AUTOROUT.CPP */
|
|
/***************/
|
|
void DisplayBoard( WinEDA_DrawPanel* panel, wxDC* DC ); /* routine de Debug */
|
|
|
|
|
|
/**************/
|
|
/* NETLIST.CPP */
|
|
/**************/
|
|
MODULE* ListAndSelectModuleName( COMMAND* Cmd );
|
|
|
|
/* liste les noms des modules du PCB
|
|
* Retourne un pointeur sur le module selectionne
|
|
* ( ou NULL si pas de selection ) */
|
|
|
|
/*****************/
|
|
/* SET_COLOR.CPP */
|
|
/*****************/
|
|
void DisplayColorSetupFrame( WinEDA_PcbFrame* parent,
|
|
const wxPoint& framepos );
|
|
|
|
|
|
#endif /* #define PROTO_H */
|