mirror of https://gitlab.com/kicad/code/kicad.git
413 lines
14 KiB
C
413 lines
14 KiB
C
/***************************************/
|
|
/* prototypage des fonctions de PCBNEW */
|
|
/***************************************/
|
|
|
|
#ifndef PROTO_H
|
|
#define PROTO_H
|
|
|
|
/***************/
|
|
/* CONNECT.CPP */
|
|
/***************/
|
|
LISTE_PAD* CreateSortedPadListByXCoord(BOARD * pcb);
|
|
/* 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 );
|
|
|
|
/***************/
|
|
/* TRACEPCB.CPP */
|
|
/***************/
|
|
void Trace_MirePcb(WinEDA_DrawPanel * panel, wxDC * DC, MIREPCB * MirePcb, int mode_color);
|
|
|
|
/***************/
|
|
/* TRPISTE.CPP */
|
|
/***************/
|
|
|
|
void Trace_Pistes(WinEDA_DrawPanel * panel, BOARD * Pcb, wxDC * DC, int drawmode);
|
|
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
|
|
*/
|
|
|
|
void Trace_DrawSegmentPcb(WinEDA_DrawPanel * panel, wxDC * DC, DRAWSEGMENT * PtDrawSegment,int mode_color);
|
|
|
|
|
|
/****************/
|
|
/* 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 : */
|
|
/****************/
|
|
|
|
MODULE * ReturnModule(BOARD * Pcb, const wxString & name);
|
|
/* Recherche d'une empreinte par son nom */
|
|
|
|
D_PAD * ReturnPad(MODULE * Module, const wxString & name);
|
|
/* Recherche d'un pad par son nom, pour le module Module */
|
|
|
|
TRACK * Locate_Via(BOARD * Pcb, const wxPoint & pos, int layer = -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
|
|
*/
|
|
|
|
TEXTE_MODULE * LocateTexteModule(BOARD * Pcb, MODULE ** Module, int typeloc);
|
|
/* localisation du texte pointe par la souris (texte sur empreinte)
|
|
si Module == NULL; recherche sur tous les modules
|
|
sinon sur le module pointe par Module
|
|
retourne
|
|
- pointeur sur le texte localise ( ou NULL )
|
|
- pointeur sur module Module ( non modifie sinon ) */
|
|
|
|
|
|
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
|
|
*/
|
|
|
|
EDGE_MODULE * Locate_Edge_Module(MODULE * Module, int typeloc);
|
|
/* Localisation de segments de contour du type edge MODULE
|
|
Les contours sont de differents type:
|
|
simple, Arcs de cercles, box.
|
|
Retourne:
|
|
Pointeur sur DEBUT du segment localise
|
|
NULL si rien trouve
|
|
*/
|
|
|
|
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) ;
|
|
|
|
TEXTE_PCB * Locate_Texte_Pcb(EDA_BaseStruct * PtStruct, int LayerSearch , int typeloc);
|
|
/* localisation des inscriptions sur le Pcb:
|
|
la recherche se fait a partir de l'adresse pr_texte */
|
|
|
|
|
|
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
|
|
*/
|
|
|
|
COTATION* Locate_Cotation(BOARD * Pcb, int LayerSearch, int typeloc);
|
|
/* Localise un element de cotation, en priorite sur la couche active,
|
|
et a defaut sur les autres couches
|
|
retourne un pointeur sur l'element (TRACK ou TEXTE_PCB) localise
|
|
sinon retiurne NULL */
|
|
|
|
|
|
/*************/
|
|
/* 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 : */
|
|
/****************/
|
|
|
|
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 */
|
|
|
|
/*****************/
|
|
/* EDITEDGE.CPP : */
|
|
/*****************/
|
|
void Trace_1_Edge(WinEDA_DrawPanel * panel, wxDC * DC, TRACK * start_edge, int nbpoint, int mode_color);
|
|
|
|
/************/
|
|
/* 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) */
|
|
|
|
/***************/
|
|
/* PLOT_RTN.CPP */
|
|
/***************/
|
|
|
|
void Affiche_erreur(int nb_err) ;
|
|
|
|
|
|
/*****************************************************************/
|
|
/* 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 );
|
|
|
|
/*************/
|
|
/* STRUCT.CPP */
|
|
/*************/
|
|
void DeleteStructure(EDA_BaseStruct * Struct);
|
|
void DeleteStructList( EDA_BaseStruct * Struct);
|
|
|
|
|
|
/***************/
|
|
/* AUTOPLACE.CPP */
|
|
/***************/
|
|
int Calcule_Encadrement_EdgeBoard(void);
|
|
|
|
/***************/
|
|
/* 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 ) */
|
|
|
|
/***************/
|
|
/* LAY2PLOT.CPP */
|
|
/***************/
|
|
|
|
/*****************/
|
|
/* SEL_COLOR.CPP */
|
|
/*****************/
|
|
void DisplayColorSetupFrame(WinEDA_DrawFrame * parent,
|
|
const wxPoint & framepos);
|
|
|
|
|
|
#endif /* #define PROTO_H */
|