Skip to content

K
kicad-source-mirror
Commit f601dff4 authored by dickelbeck's avatar dickelbeck
Browse files
Options

Hot key operations for a single module such as Move 'M', Rotate 'R', Swap... 

Hot key operations for a single module such as Move 'M', Rotate 'R', Swap Layer 'S', now operate only on unlocked modules 
and only on modules in the current layer.
parent ad61cdaa
Hide whitespace changes
Inline Side-by-side
Showing with 1311 additions and 1217 deletions
pcbnew/class_module.h
View file @ f601dff4
/*******************************************************/
/* class_module.h : module description (excepted pads) */
/*******************************************************/
/*******************************************************/
/* class_module.h : module description (excepted pads) */
/*******************************************************/
class Pcb3D_GLCanvas;
class Struct3D_Master;
/************************************/
/* Modules (footprints) description */
/* pad are in class_pad.xx */
/************************************/
/************************************/
/* Modules (footprints) description */
/* pad are in class_pad.xx */
/************************************/
/* Format des modules:
Description generale
Description segments contour
Description textes
Description pastilles
Description generale
Description segments contour
Description textes
Description pastilles
*/
/* Flags :*/
enum Mod_Attribut /* Attributs d'un module */
{
MOD_DEFAULT = 0, /* Type default */
MOD_CMS = 1, /* Pour module apparaissant dans les
fichiers de placement automatique (principalement modules CMS */
MOD_VIRTUAL = 2 /* Module virtuel constitue par un dessin sur circuit
(connecteur, trou de percage..) */
};
enum Mod_Attribut /* Attributs d'un module */
{
MOD_DEFAULT = 0, /* Type default */
MOD_CMS = 1, /* Pour module apparaissant dans les
fichiers de placement automatique (principalement modules CMS */
MOD_VIRTUAL = 2 /* Module virtuel constitue par un dessin sur circuit
(connecteur, trou de percage..) */
};
/* flags for autoplace and autoroute (.m_ModuleStatus member) */
#define MODULE_is_LOCKED 0x01 /* module LOCKED: no autoplace allowed */
#define MODULE_is_PLACED 0x02 /* In autoplace: module automatically placed */
#define MODULE_to_PLACE 0x04 /* In autoplace: module waiting for autoplace */
#define MODULE_is_LOCKED 0x01 /* module LOCKED: no autoplace allowed */
#define MODULE_is_PLACED 0x02 /* In autoplace: module automatically placed */
#define MODULE_to_PLACE 0x04 /* In autoplace: module waiting for autoplace */
class MODULE: public EDA_BaseStruct
{
public:
int m_Layer; // layer number
wxPoint m_Pos; // Real coord on board
D_PAD * m_Pads; /* Pad list (linked list) */
EDA_BaseStruct * m_Drawings; /* Graphic items list (linked list) */
Struct3D_Master * m_3D_Drawings; /* Pointeur sur la liste des elements de trace 3D*/
TEXTE_MODULE * m_Reference; // texte reference du composant (U34, R18..)
TEXTE_MODULE * m_Value; // texte valeur du composant (74LS00, 22K..)
wxString m_LibRef; /* nom du module en librairie */
int m_Attributs; /* Flags bits a bit ( voir enum Mod_Attribut ) */
int m_Orient ; /* orientation en 1/10 degres */
int flag ; /* flag utilise en trace rastnest et routage auto */
int m_ModuleStatus; /* For autoplace: flags (LOCKED, AUTOPLACED) */
EDA_Rect m_BoundaryBox ; /* position/taille du cadre de reperage (coord locales)*/
EDA_Rect m_RealBoundaryBox ; /* position/taille du module (coord relles) */
int m_PadNum; // Nombre total de pads
int m_AltPadNum; // en placement auto Nombre de pads actifs pour
// les calculs
int m_CntRot90; // Placement auto: cout ( 0..10 ) de la rotation 90 degre
int m_CntRot180; // Placement auto: cout ( 0..10 ) de la rotation 180 degre
wxSize m_Ext; // marges de "garde": utilise en placement auto.
float m_Surface; // surface du rectangle d'encadrement
long m_Link; // variable temporaire ( pour editions, ...)
long m_LastEdit_Time; // Date de la derniere modification du module (gestion de librairies)
wxString m_Doc; // Texte de description du module
wxString m_KeyWord; // Liste des mots cles relatifs au module
int m_Layer; // layer number
wxPoint m_Pos; // Real coord on board
D_PAD * m_Pads; /* Pad list (linked list) */
EDA_BaseStruct * m_Drawings; /* Graphic items list (linked list) */
Struct3D_Master * m_3D_Drawings; /* Pointeur sur la liste des elements de trace 3D*/
TEXTE_MODULE * m_Reference; // texte reference du composant (U34, R18..)
TEXTE_MODULE * m_Value; // texte valeur du composant (74LS00, 22K..)
wxString m_LibRef; /* nom du module en librairie */
int m_Attributs; /* Flags bits a bit ( voir enum Mod_Attribut ) */
int m_Orient ; /* orientation en 1/10 degres */
int flag ; /* flag utilise en trace rastnest et routage auto */
int m_ModuleStatus; /* For autoplace: flags (LOCKED, AUTOPLACED) */
EDA_Rect m_BoundaryBox; /* position/taille du cadre de reperage (coord locales)*/
EDA_Rect m_RealBoundaryBox ; /* position/taille du module (coord relles) */
int m_PadNum; // Nombre total de pads
int m_AltPadNum; // en placement auto Nombre de pads actifs pour
// les calculs
int m_CntRot90; // Placement auto: cout ( 0..10 ) de la rotation 90 degre
int m_CntRot180; // Placement auto: cout ( 0..10 ) de la rotation 180 degre
wxSize m_Ext; // marges de "garde": utilise en placement auto.
float m_Surface; // surface du rectangle d'encadrement
long m_Link; // variable temporaire ( pour editions, ...)
long m_LastEdit_Time; // Date de la derniere modification du module (gestion de librairies)
wxString m_Doc; // Texte de description du module
wxString m_KeyWord; // Liste des mots cles relatifs au module
public:
MODULE(BOARD * parent);
MODULE(MODULE * module);
~MODULE(void);
void Copy(MODULE * Module); // Copy structure
MODULE * Next(void) { return (MODULE *) Pnext; }
void Set_Rectangle_Encadrement(void); /* mise a jour du rect d'encadrement
en coord locales (orient 0 et origine = pos module) */
void SetRectangleExinscrit(void); /* mise a jour du rect d'encadrement
et de la surface en coord reelles */
// deplacements
void SetPosition(const wxPoint & newpos);
void SetOrientation(int newangle);
/* supprime du chainage la structure Struct */
void UnLink( void );
/* Readind and writing data on files */
int WriteDescr( FILE * File );
int Write_3D_Descr( FILE * File );
int ReadDescr( FILE * File, int * LineNum = NULL);
int Read_3D_Descr( FILE * File, int * LineNum = NULL);
/* drawing functions */
void Draw(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int draw_mode);
void Draw3D(Pcb3D_GLCanvas * glcanvas);
void DrawEdgesOnly(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset,int draw_mode);
void DrawAncre(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int dim_ancre, int draw_mode);
/* miscellaneous */
void Display_Infos(WinEDA_BasePcbFrame * frame);
MODULE(BOARD * parent);
MODULE(MODULE * module);
~MODULE(void);
void Copy(MODULE * Module); // Copy structure
MODULE * Next(void) { return (MODULE *) Pnext; }
void Set_Rectangle_Encadrement(void); /* mise a jour du rect d'encadrement
en coord locales (orient 0 et origine = pos module) */
void SetRectangleExinscrit(void); /* mise a jour du rect d'encadrement
et de la surface en coord reelles */
// deplacements
void SetPosition(const wxPoint & newpos);
void SetOrientation(int newangle);
/* supprime du chainage la structure Struct */
void UnLink( void );
/**
* Function IsLocked
* @returns bool - true if the MODULE is locked, else false
*/
bool IsLocked()
{
return (m_ModuleStatus & MODULE_is_LOCKED) != 0;
}
/**
* Function SetLocked
* sets the MODULE_is_LOCKED bit in the m_ModuleStatus
* @param setLocked When true means turn on locked status, else unlock
*/
void SetLocked( bool setLocked )
{
if( setLocked )
m_ModuleStatus |= MODULE_is_LOCKED;
else
m_ModuleStatus &= ~MODULE_is_LOCKED;
}
/* Readind and writing data on files */
int WriteDescr( FILE * File );
int Write_3D_Descr( FILE * File );
int ReadDescr( FILE * File, int * LineNum = NULL);
int Read_3D_Descr( FILE * File, int * LineNum = NULL);
/* drawing functions */
void Draw(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int draw_mode);
void Draw3D(Pcb3D_GLCanvas * glcanvas);
void DrawEdgesOnly(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset,int draw_mode);
void DrawAncre(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int dim_ancre, int draw_mode);
/* miscellaneous */
void Display_Infos(WinEDA_BasePcbFrame * frame);
};
pcbnew/hotkeys.cpp
View file @ f601dff4
/***************/
/* hotkeys.cpp */
/***************/
/***************/
/* hotkeys.cpp */
/***************/
#include "fctsys.h"
......@@ -18,129 +18,161 @@
/***********************************************************/
void WinEDA_PcbFrame::OnHotKey(wxDC * DC, int hotkey,
EDA_BaseStruct * DrawStruct)
EDA_BaseStruct * DrawStruct)
/***********************************************************/
/* Gestion des commandes rapides (Raccourcis claviers) concernant l'element
sous le courseur souris
Les majuscules/minuscules sont indifferenciees
touche DELETE: Effacement (Module ou piste selon commande en cours)
touche V: Place via en cours de trace de piste
touche R: Rotation module
touche S: Change couche module (Composant <-> Cuivre)
touche M: Start Move module
touche G: Start Drag module
touche DELETE: Effacement (Module ou piste selon commande en cours)
touche V: Place via en cours de trace de piste
touche R: Rotation module
touche S: Change couche module (Composant <-> Cuivre)
touche M: Start Move module
touche G: Start Drag module
*/
{
bool PopupOn = GetScreen()->m_CurrentItem &&
GetScreen()->m_CurrentItem->m_Flags;
bool ItemFree = (GetScreen()->m_CurrentItem == 0 ) ||
(GetScreen()->m_CurrentItem->m_Flags == 0);
if ( hotkey == 0 ) return;
MODULE* module = NULL;
switch (hotkey)
{
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
OnHotkeyDeleteItem(DC, DrawStruct);
break;
case WXK_BACK:{
if( m_ID_current_state == ID_TRACK_BUTT &&
GetScreen()->m_Active_Layer <= CMP_N ){
bool ItemFree = (GetScreen()->m_CurrentItem == NULL ) ||
(GetScreen()->m_CurrentItem->m_Flags == 0);
if ( ItemFree ){
//no track is currently being edited - select a segment and remove it.
DrawStruct = PcbGeneralLocateAndDisplay();
//don't let backspace delete modules!!
if ( DrawStruct && (DrawStruct->m_StructType == TYPETRACK
|| DrawStruct->m_StructType == TYPEVIA))
Delete_Segment(DC, (TRACK*)DrawStruct);
GetScreen()->SetModify();
}
else if ( GetScreen()->m_CurrentItem->m_StructType == TYPETRACK )
{
//then an element is being edited - remove the last segment.
GetScreen()->m_CurrentItem =
Delete_Segment(DC, (TRACK*)GetScreen()->m_CurrentItem);
GetScreen()->SetModify();
}
}
break;
}
case WXK_END:
DrawPanel->MouseToCursorSchema();
End_Route( (TRACK *) (GetScreen()->m_CurrentItem), DC);
break;
case 'v': // Switch to alternate layer and Place a via if a track is in progress
case 'V':
if ( m_ID_current_state != ID_TRACK_BUTT ) return;
if ( ItemFree )
{
Other_Layer_Route( NULL, DC);
break;
}
if ( GetScreen()->m_CurrentItem->m_StructType != TYPETRACK )
return;
if ( (GetScreen()->m_CurrentItem->m_Flags & IS_NEW) == 0 )
return;
Other_Layer_Route( (TRACK *) GetScreen()->m_CurrentItem, DC);
if ( DisplayOpt.ContrastModeDisplay )
GetScreen()->SetRefreshReq();
break;
case 'r': // Rotation
case 'R':
if ( ItemFree )
module = Locate_Prefered_Module(m_Pcb, CURSEUR_ON_GRILLE);
else if (GetScreen()->m_CurrentItem->m_StructType == TYPEMODULE)
module = (MODULE*)GetScreen()->m_CurrentItem;
if ( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
Rotate_Module(DC, module, 900, TRUE);
}
break;
case 's': // move to other side
case 'S':
if ( ItemFree )
module = Locate_Prefered_Module(m_Pcb, CURSEUR_ON_GRILLE);
else if (GetScreen()->m_CurrentItem->m_StructType == TYPEMODULE)
module = (MODULE*)GetScreen()->m_CurrentItem;
if ( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
Change_Side_Module(module, DC);
}
break;
case 'g':
case 'G': // Start move (and drag) module
g_Drag_Pistes_On = TRUE;
case 'm':
case 'M': // Start move module
if ( PopupOn ) break;
if ( (module = Locate_Prefered_Module(m_Pcb, CURSEUR_ON_GRILLE)) != NULL)
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
StartMove_Module( module, DC);
}
break;
}
}
bool PopupOn = GetScreen()->m_CurrentItem &&
GetScreen()->m_CurrentItem->m_Flags;
bool ItemFree = (GetScreen()->m_CurrentItem == 0 ) ||
(GetScreen()->m_CurrentItem->m_Flags == 0);
if ( hotkey == 0 ) return;
MODULE* module = NULL;
switch (hotkey)
{
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
OnHotkeyDeleteItem(DC, DrawStruct);
break;
case WXK_BACK:
{
if( m_ID_current_state == ID_TRACK_BUTT &&
GetScreen()->m_Active_Layer <= CMP_N )
{
bool ItemFree = (GetScreen()->m_CurrentItem == NULL ) ||
(GetScreen()->m_CurrentItem->m_Flags == 0);
if ( ItemFree )
{
//no track is currently being edited - select a segment and remove it.
DrawStruct = PcbGeneralLocateAndDisplay();
//don't let backspace delete modules!!
if ( DrawStruct && (DrawStruct->m_StructType == TYPETRACK
|| DrawStruct->m_StructType == TYPEVIA))
Delete_Segment(DC, (TRACK*)DrawStruct);
GetScreen()->SetModify();
}
else if ( GetScreen()->m_CurrentItem->m_StructType == TYPETRACK )
{
//then an element is being edited - remove the last segment.
GetScreen()->m_CurrentItem =
Delete_Segment(DC, (TRACK*)GetScreen()->m_CurrentItem);
GetScreen()->SetModify();
}
}
break;
}
case WXK_END:
DrawPanel->MouseToCursorSchema();
End_Route( (TRACK *) (GetScreen()->m_CurrentItem), DC);
break;
case 'v': // Switch to alternate layer and Place a via if a track is in progress
case 'V':
if ( m_ID_current_state != ID_TRACK_BUTT ) return;
if ( ItemFree )
{
Other_Layer_Route( NULL, DC);
break;
}
if ( GetScreen()->m_CurrentItem->m_StructType != TYPETRACK )
return;
if ( (GetScreen()->m_CurrentItem->m_Flags & IS_NEW) == 0 )
return;
Other_Layer_Route( (TRACK *) GetScreen()->m_CurrentItem, DC);
if ( DisplayOpt.ContrastModeDisplay )
GetScreen()->SetRefreshReq();
break;
case 'r': // Rotation
case 'R':
if ( ItemFree )
module = Locate_Prefered_Module(m_Pcb,
CURSEUR_ON_GRILLE | IGNORE_LOCKED | MATCH_LAYER );
else if (GetScreen()->m_CurrentItem->m_StructType == TYPEMODULE)
{
module = (MODULE*)GetScreen()->m_CurrentItem;
// @todo: might need to add a layer check in if() below
if( module->IsLocked() )
module = 0; // do not move it.
}
if ( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
Rotate_Module(DC, module, 900, TRUE);
}
break;
case 's': // move to other side
case 'S':
if ( ItemFree )
module = Locate_Prefered_Module(m_Pcb,
CURSEUR_ON_GRILLE | IGNORE_LOCKED | MATCH_LAYER );
else if (GetScreen()->m_CurrentItem->m_StructType == TYPEMODULE)
{
module = (MODULE*)GetScreen()->m_CurrentItem;
// @todo: might need to add a layer check in if() below
if( module->IsLocked() )
module = 0; // do not move it.
}
if ( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
Change_Side_Module(module, DC);
}
break;
case 'L': // toggle module "MODULE_is_LOCKED" status:
case 'l':
// get any module, locked or not locked and toggle its locked status
module = Locate_Prefered_Module( m_Pcb, CURSEUR_ON_GRILLE | MATCH_LAYER );
if( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
module->SetLocked( !module->IsLocked() );
}
break;
case 'g':
case 'G': // Start move (and drag) module
g_Drag_Pistes_On = TRUE;
// fall through
case 'm':
case 'M': // Start move module
if ( PopupOn ) break;
module = Locate_Prefered_Module( m_Pcb,
CURSEUR_ON_GRILLE | IGNORE_LOCKED | MATCH_LAYER );
if( module )
{
GetScreen()->m_CurrentItem = module;
module->Display_Infos(this);
StartMove_Module( module, DC);
}
break;
}
}
/***********************************************************/
void WinEDA_ModuleEditFrame::OnHotKey(wxDC * DC, int hotkey,
EDA_BaseStruct * DrawStruct)
EDA_BaseStruct * DrawStruct)
/***********************************************************/
/* Gestion des commandes rapides (Raccourcis claviers) concernant l'element
sous le courseur souris
......@@ -148,88 +180,88 @@ sous le courseur souris
*/
{
bool PopupOn = GetScreen()->m_CurrentItem &&
GetScreen()->m_CurrentItem->m_Flags;
if ( hotkey == 0 ) return;
switch (hotkey)
{
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
if ( PopupOn ) break;
break;
case 'r': // Rotation
case 'R':
break;
case 'y': // Mirror Y (drawlibpart)
case 'Y':
break;
case 'x': // Mirror X (drawlibpart)
case 'X':
break;
case 'n':
case 'N': // Orient 0, no mirror (drawlibpart)
break;
case 'm':
case 'M': // Start move drawlibpart
if ( PopupOn ) break;
break;
}
GetScreen()->m_CurrentItem->m_Flags;
if ( hotkey == 0 ) return;
switch (hotkey)
{
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
if ( PopupOn ) break;
break;
case 'r': // Rotation
case 'R':
break;
case 'y': // Mirror Y (drawlibpart)
case 'Y':
break;
case 'x': // Mirror X (drawlibpart)
case 'X':
break;
case 'n':
case 'N': // Orient 0, no mirror (drawlibpart)
break;
case 'm':
case 'M': // Start move drawlibpart
if ( PopupOn ) break;
break;
}
}
/******************************************************************************/
bool WinEDA_PcbFrame::OnHotkeyDeleteItem(wxDC * DC, EDA_BaseStruct * DrawStruct)
/******************************************************************************/
/* Efface l'item pointe par la souris, en reponse a la touche "Del"
Effet dependant de l'outil selectionne:
Outil trace de pistes
Efface le segment en cours ou la piste si pas d'element
Outil module:
Efface le module.
Effet dependant de l'outil selectionne:
Outil trace de pistes
Efface le segment en cours ou la piste si pas d'element
Outil module:
Efface le module.
*/
{
bool ItemFree = (GetScreen()->m_CurrentItem == NULL ) ||
(GetScreen()->m_CurrentItem->m_Flags == 0);
switch ( m_ID_current_state )
{
case ID_TRACK_BUTT:
if ( GetScreen()->m_Active_Layer > CMP_N ) return FALSE;
if ( ItemFree )
{
DrawStruct = PcbGeneralLocateAndDisplay();
if ( DrawStruct && DrawStruct->m_StructType != TYPETRACK ) return FALSE;
Delete_Track(DC, (TRACK*)DrawStruct);
}
else if ( GetScreen()->m_CurrentItem->m_StructType == TYPETRACK )
{
GetScreen()->m_CurrentItem =
Delete_Segment(DC, (TRACK*)GetScreen()->m_CurrentItem);
GetScreen()->SetModify();
return TRUE;
}
break;
case ID_COMPONENT_BUTT:
if ( ItemFree )
{
MODULE * module = Locate_Prefered_Module(m_Pcb, CURSEUR_ON_GRILLE);
if ( module == NULL ) return FALSE;
if( ! IsOK(this, _("Delete module?")) ) return FALSE;
RemoveStruct(module, DC);
}
else return FALSE;
break;
default:
return FALSE;
}
GetScreen()->SetModify();
GetScreen()->m_CurrentItem = NULL;
return TRUE;
(GetScreen()->m_CurrentItem->m_Flags == 0);
switch ( m_ID_current_state )
{
case ID_TRACK_BUTT:
if ( GetScreen()->m_Active_Layer > CMP_N ) return FALSE;
if ( ItemFree )
{
DrawStruct = PcbGeneralLocateAndDisplay();
if ( DrawStruct && DrawStruct->m_StructType != TYPETRACK ) return FALSE;
Delete_Track(DC, (TRACK*)DrawStruct);
}
else if ( GetScreen()->m_CurrentItem->m_StructType == TYPETRACK )
{
GetScreen()->m_CurrentItem =
Delete_Segment(DC, (TRACK*)GetScreen()->m_CurrentItem);
GetScreen()->SetModify();
return TRUE;
}
break;
case ID_COMPONENT_BUTT:
if ( ItemFree )
{
MODULE * module = Locate_Prefered_Module(m_Pcb, CURSEUR_ON_GRILLE);
if ( module == NULL ) return FALSE;
if( ! IsOK(this, _("Delete module?")) ) return FALSE;
RemoveStruct(module, DC);
}
else return FALSE;
break;
default:
return FALSE;
}
GetScreen()->SetModify();
GetScreen()->m_CurrentItem = NULL;
return TRUE;
}
pcbnew/locate.cpp
View file @ f601dff4
/*****************************/
/* Localisation des elements */
/*****************************/
/*****************************/
/* Localisation des elements */
/*****************************/
#include "fctsys.h"
#include "gr_basic.h"
......@@ -14,8 +14,8 @@
/* variables locales */
int ux0 , uy0 ,dx, dy, spot_cX, spot_cY; /* Variables utilisees pour
la localisation des segments */
int ux0 , uy0 ,dx, dy, spot_cX, spot_cY; /* Variables utilisees pour
la localisation des segments */
/* fonctions locales */
EDA_BaseStruct * Locate_MirePcb( EDA_BaseStruct * PtStruct, int LayerSearch, int typeloc);
/**/
......@@ -24,29 +24,48 @@ EDA_BaseStruct * Locate_MirePcb( EDA_BaseStruct * PtStruct, int LayerSearch, int
(ON/OFF grille) choisi
*/
#define SET_REF_POS(ref_pos) if(typeloc == CURSEUR_ON_GRILLE) \
{ ref_pos = ActiveScreen->m_Curseur;} \
else { ref_pos = ActiveScreen->m_MousePosition; }
{ ref_pos = ActiveScreen->m_Curseur;} \
else { ref_pos = ActiveScreen->m_MousePosition; }
/**
* Function IsModuleLayerVisible
* expects either of the two layers on which a module can reside, and returns
* whether that layer is visible.
* @param layer One of the two allowed layers for modules: CMP_N or CUIVRE_N
* @return bool - true if the layer is visible, else false.
*/
bool inline IsModuleLayerVisible( int layer )
{
if( layer==CMP_N )
return DisplayOpt.Show_Modules_Cmp;
else if( layer==CUIVRE_N )
return DisplayOpt.Show_Modules_Cu;
else
return true;
}
/*************************************************************/
MODULE * ReturnModule(BOARD * pcb, const wxString & reference)
/*************************************************************/
/*
Recherche d'un module par sa reference
Retourne:
un pointeur sur le module
Null si pas localis
Retourne:
un pointeur sur le module
Null si pas localis
*/
{
MODULE * Module = pcb->m_Modules;
for( ; Module != NULL ; Module = (MODULE *) Module->Pnext )
{
if( reference.CmpNoCase(Module->m_Reference->m_Text) == 0 )
return Module;
}
return NULL;
for( ; Module != NULL ; Module = (MODULE *) Module->Pnext )
{
if( reference.CmpNoCase(Module->m_Reference->m_Text) == 0 )
return Module;
}
return NULL;
}
......@@ -59,17 +78,17 @@ D_PAD * ReturnPad(MODULE * module, const wxString & name)
D_PAD * pt_pad ;
wxString buf;
if( module == NULL ) return NULL;
if( module == NULL ) return NULL;
pt_pad = module->m_Pads;
pt_pad = module->m_Pads;
for ( ; pt_pad != NULL; pt_pad = (D_PAD*)pt_pad->Pnext )
{
pt_pad->ReturnStringPadName(buf);
if( buf.CmpNoCase(name) == 0 )
return pt_pad;
}
return(NULL);
for ( ; pt_pad != NULL; pt_pad = (D_PAD*)pt_pad->Pnext )
{
pt_pad->ReturnStringPadName(buf);
if( buf.CmpNoCase(name) == 0 )
return pt_pad;
}
return(NULL);
}
......@@ -79,8 +98,8 @@ wxString buf;
EDA_BaseStruct * WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
/*******************************************************************************/
/* General locate function
Display infos relatives to the item found
return a pointer to this item ( or NULL )
Display infos relatives to the item found
return a pointer to this item ( or NULL )
*/
{
TEXTE_PCB * pt_texte_pcb;
......@@ -91,96 +110,96 @@ D_PAD* pt_pad;
int masque_layer;
EDA_BaseStruct * item;
pt_texte_pcb = Locate_Texte_Pcb(m_Pcb->m_Drawings, LayerSearch, typeloc);
if(pt_texte_pcb ) // a PCB text is found
{
Affiche_Infos_PCB_Texte(this, pt_texte_pcb);
return pt_texte_pcb;
}
if ( (DrawSegm = Locate_Segment_Pcb(m_Pcb, LayerSearch, typeloc)) != NULL)
{
Affiche_Infos_DrawSegment(this, DrawSegm);
return DrawSegm;
}
if ( (item = Locate_Cotation(m_Pcb, LayerSearch, typeloc)) != NULL) return item;
if ( (item = Locate_MirePcb(m_Pcb->m_Drawings, LayerSearch, typeloc)) != NULL) return item;
/* Search for tracks and vias, with via priority */
if ( LayerSearch == -1 ) masque_layer = ALL_LAYERS;
else masque_layer = g_TabOneLayerMask[LayerSearch];
Track = Locate_Pistes( m_Pcb->m_Track, masque_layer,typeloc );
if ( Track != NULL )
{
TrackLocate = Track ; /* a track or a via is found*/
/* Search for a via */
while((TrackLocate = Locate_Pistes(TrackLocate,
masque_layer,typeloc)) != NULL )
{
Track = TrackLocate;
if(TrackLocate->m_StructType == TYPEVIA) break ;
TrackLocate = (TRACK*) TrackLocate->Pnext;
}
Affiche_Infos_Piste(this, Track) ;
return Track;
}
/* Search for Pads */
if( (pt_pad = Locate_Any_Pad(m_Pcb, typeloc)) != NULL )
{
pt_pad->Display_Infos(this); return pt_pad;
}
/* Search for a footprint text */
// First search: locate texts for footprints on copper or component layer
// Priority to the active layer (component or copper.
// this is useful for small smd components when 2 texts overlap but are not on the same layer
if ( (LayerSearch == LAYER_CUIVRE_N) || (LayerSearch == CMP_N ))
{
for (module = m_Pcb->m_Modules; module != NULL; module = (MODULE*)module->Pnext)
{
TEXTE_MODULE * pt_texte;
if ( module->m_Layer != LayerSearch) continue;
pt_texte = LocateTexteModule(m_Pcb, &module, typeloc);
if( pt_texte != NULL )
{
Affiche_Infos_E_Texte(this, module, pt_texte);
return pt_texte;
}
}
}
// Now Search footprint texts on all layers
module = NULL;
{
TEXTE_MODULE * pt_texte;
pt_texte = LocateTexteModule(m_Pcb, &module, typeloc);
if( pt_texte != NULL )
{
Affiche_Infos_E_Texte(this, module, pt_texte);
return pt_texte;
}
}
/* Search for a footprint */
if ( (module = Locate_Prefered_Module(m_Pcb, typeloc)) != NULL)
{
module->Display_Infos(this);
return module;
}
/* Search for zones */
if( (TrackLocate = Locate_Zone((TRACK*)m_Pcb->m_Zone,
GetScreen()->m_Active_Layer,typeloc)) != NULL )
{
Affiche_Infos_Piste(this, TrackLocate) ; return TrackLocate;
}
MsgPanel->EraseMsgBox();
return NULL;
pt_texte_pcb = Locate_Texte_Pcb(m_Pcb->m_Drawings, LayerSearch, typeloc);
if(pt_texte_pcb ) // a PCB text is found
{
Affiche_Infos_PCB_Texte(this, pt_texte_pcb);
return pt_texte_pcb;
}
if ( (DrawSegm = Locate_Segment_Pcb(m_Pcb, LayerSearch, typeloc)) != NULL)
{
Affiche_Infos_DrawSegment(this, DrawSegm);
return DrawSegm;
}
if ( (item = Locate_Cotation(m_Pcb, LayerSearch, typeloc)) != NULL) return item;
if ( (item = Locate_MirePcb(m_Pcb->m_Drawings, LayerSearch, typeloc)) != NULL) return item;
/* Search for tracks and vias, with via priority */
if ( LayerSearch == -1 ) masque_layer = ALL_LAYERS;
else masque_layer = g_TabOneLayerMask[LayerSearch];
Track = Locate_Pistes( m_Pcb->m_Track, masque_layer,typeloc );
if ( Track != NULL )
{
TrackLocate = Track ; /* a track or a via is found*/
/* Search for a via */
while((TrackLocate = Locate_Pistes(TrackLocate,
masque_layer,typeloc)) != NULL )
{
Track = TrackLocate;
if(TrackLocate->m_StructType == TYPEVIA) break ;
TrackLocate = (TRACK*) TrackLocate->Pnext;
}
Affiche_Infos_Piste(this, Track) ;
return Track;
}
/* Search for Pads */
if( (pt_pad = Locate_Any_Pad(m_Pcb, typeloc)) != NULL )
{
pt_pad->Display_Infos(this); return pt_pad;
}
/* Search for a footprint text */
// First search: locate texts for footprints on copper or component layer
// Priority to the active layer (component or copper.
// this is useful for small smd components when 2 texts overlap but are not on the same layer
if ( (LayerSearch == LAYER_CUIVRE_N) || (LayerSearch == CMP_N ))
{
for (module = m_Pcb->m_Modules; module != NULL; module = (MODULE*)module->Pnext)
{
TEXTE_MODULE * pt_texte;
if ( module->m_Layer != LayerSearch) continue;
pt_texte = LocateTexteModule(m_Pcb, &module, typeloc);
if( pt_texte != NULL )
{
Affiche_Infos_E_Texte(this, module, pt_texte);
return pt_texte;
}
}
}
// Now Search footprint texts on all layers
module = NULL;
{
TEXTE_MODULE * pt_texte;
pt_texte = LocateTexteModule(m_Pcb, &module, typeloc);
if( pt_texte != NULL )
{
Affiche_Infos_E_Texte(this, module, pt_texte);
return pt_texte;
}
}
/* Search for a footprint */
if ( (module = Locate_Prefered_Module(m_Pcb, typeloc)) != NULL)
{
module->Display_Infos(this);
return module;
}
/* Search for zones */
if( (TrackLocate = Locate_Zone((TRACK*)m_Pcb->m_Zone,
GetScreen()->m_Active_Layer,typeloc)) != NULL )
{
Affiche_Infos_Piste(this, TrackLocate) ; return TrackLocate;
}
MsgPanel->EraseMsgBox();
return NULL;
}
......@@ -189,28 +208,28 @@ TRACK * Locate_Via(BOARD * Pcb, const wxPoint & pos, int layer)
/*******************************************************************/
/* Localise une via au point pX,pY
Si layer < 0 la via sera localisee quelle que soit la couche
Si layer = 0 .. 15 la via sera localisee selon son type:
- traversante : toutes couches
- aveugle = entre couches utiles
- borgnes idem
Entree : coord du point de reference, couche
Sortie: NULL si pas de via
(TRACK*) adresse de la via
Si layer < 0 la via sera localisee quelle que soit la couche
Si layer = 0 .. 15 la via sera localisee selon son type:
- traversante : toutes couches
- aveugle = entre couches utiles
- borgnes idem
Entree : coord du point de reference, couche
Sortie: NULL si pas de via
(TRACK*) adresse de la via
*/
{
TRACK * Track;
for(Track = Pcb->m_Track; Track != NULL; Track = Track->Next())
{
if( Track->m_StructType != TYPEVIA) continue;
if( Track->m_Start != pos) continue;
if( Track->GetState(BUSY|DELETED) ) continue;
if(layer < 0 ) return(Track);
if ( ((SEGVIA *)Track)->IsViaOnLayer(layer) )
return(Track);
}
return(NULL);
for(Track = Pcb->m_Track; Track != NULL; Track = Track->Next())
{
if( Track->m_StructType != TYPEVIA) continue;
if( Track->m_Start != pos) continue;
if( Track->GetState(BUSY|DELETED) ) continue;
if(layer < 0 ) return(Track);
if ( ((SEGVIA *)Track)->IsViaOnLayer(layer) )
return(Track);
}
return(NULL);
}
......@@ -218,12 +237,12 @@ TRACK * Track;
D_PAD * Locate_Pad_Connecte(BOARD * Pcb, TRACK * ptr_piste, int extr)
/********************************************************************/
/* localisation de la pastille connectee au point de piste a tester
entree : ptr_piste: pointeur sur le segment de piste
extr = flag = START -> debut du segment a tester
= END -> fin du segment a tester
retourne:
un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
entree : ptr_piste: pointeur sur le segment de piste
extr = flag = START -> debut du segment a tester
= END -> fin du segment a tester
retourne:
un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
*/
{
D_PAD * ptr_pad = NULL;
......@@ -231,22 +250,22 @@ int masque_layer;
MODULE * module;
wxPoint ref_pos;
masque_layer = g_TabOneLayerMask[ptr_piste->m_Layer];
if( extr == START)
{
ref_pos = ptr_piste->m_Start;
}
else
{
ref_pos = ptr_piste->m_End;
}
module = Pcb->m_Modules;
for(; module != NULL; module = (MODULE*) module->Pnext)
{
ptr_pad = Locate_Pads(module, ref_pos, masque_layer) ;
if ( ptr_pad != NULL ) break ;
}
return(ptr_pad);
masque_layer = g_TabOneLayerMask[ptr_piste->m_Layer];
if( extr == START)
{
ref_pos = ptr_piste->m_Start;
}
else
{
ref_pos = ptr_piste->m_End;
}
module = Pcb->m_Modules;
for(; module != NULL; module = (MODULE*) module->Pnext)
{
ptr_pad = Locate_Pads(module, ref_pos, masque_layer) ;
if ( ptr_pad != NULL ) break ;
}
return(ptr_pad);
}
......@@ -255,78 +274,78 @@ wxPoint ref_pos;
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 : succession de droites
Arcs de cercles : on a alors debut arc, fin arc , centre
si debut arc = fin arc : cercle complet
Retourne:
Pointeur sur le segment localise
NULL si rien trouve
Les contours sont de differents type:
simple : succession de droites
Arcs de cercles : on a alors debut arc, fin arc , centre
si debut arc = fin arc : cercle complet
Retourne:
Pointeur sur le segment localise
NULL si rien trouve
*/
{
EDGE_MODULE * edge_mod;
EDA_BaseStruct * PtStruct;
int uxf, uyf, type_trace;
int rayon, dist;
wxPoint ref_pos; /* coord du point de localisation */
wxPoint ref_pos; /* coord du point de localisation */
int StAngle, EndAngle, MouseAngle; /* pour localisation d'arcs,
angle du point de debut, de fin et du point
de reference */
if ( ! module ) return NULL;
SET_REF_POS(ref_pos);
PtStruct = module->m_Drawings;
for ( ;PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEEDGEMODULE ) continue;
edge_mod = (EDGE_MODULE *) PtStruct;
type_trace = edge_mod->m_Shape ;
ux0 = edge_mod->m_Start.x; uy0 = edge_mod->m_Start.y;
uxf = edge_mod->m_End.x; uyf = edge_mod->m_End.y;
switch(type_trace)
{
case S_SEGMENT :
/* recalcul des coordonnees avec ux0,uy0 = origine des coord. */
spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
dx = uxf - ux0 ; dy = uyf - uy0 ;
/* detection : */
if( distance(edge_mod->m_Width/2) ) return( edge_mod) ;
break;
case S_CIRCLE:
rayon = (int)hypot((double)(uxf-ux0),(double)(uyf-uy0) );
dist = (int)hypot((double)(ref_pos.x - ux0),(double)(ref_pos.y - uy0) );
if(abs(rayon-dist) <= edge_mod->m_Width) return(edge_mod);
break;
case S_ARC:
rayon = (int)hypot((double)(uxf-ux0),(double)(uyf-uy0) );
dist = (int)hypot((double)(ref_pos.x - ux0),(double)(ref_pos.y - uy0) );
if(abs(rayon-dist) > edge_mod->m_Width) break;
/* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente(ref_pos.y - uy0, ref_pos.x - ux0);
StAngle = (int) ArcTangente(uyf - uy0, uxf - ux0);
EndAngle = StAngle + edge_mod->m_Angle;
if( EndAngle > 3600 )
{
StAngle -= 3600; EndAngle -= 3600;
}
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
return(edge_mod);
break;
}
}
return(NULL) ;
angle du point de debut, de fin et du point
de reference */
if ( ! module ) return NULL;
SET_REF_POS(ref_pos);
PtStruct = module->m_Drawings;
for ( ;PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEEDGEMODULE ) continue;
edge_mod = (EDGE_MODULE *) PtStruct;
type_trace = edge_mod->m_Shape ;
ux0 = edge_mod->m_Start.x; uy0 = edge_mod->m_Start.y;
uxf = edge_mod->m_End.x; uyf = edge_mod->m_End.y;
switch(type_trace)
{
case S_SEGMENT :
/* recalcul des coordonnees avec ux0,uy0 = origine des coord. */
spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
dx = uxf - ux0 ; dy = uyf - uy0 ;
/* detection : */
if( distance(edge_mod->m_Width/2) ) return( edge_mod) ;
break;
case S_CIRCLE:
rayon = (int)hypot((double)(uxf-ux0),(double)(uyf-uy0) );
dist = (int)hypot((double)(ref_pos.x - ux0),(double)(ref_pos.y - uy0) );
if(abs(rayon-dist) <= edge_mod->m_Width) return(edge_mod);
break;
case S_ARC:
rayon = (int)hypot((double)(uxf-ux0),(double)(uyf-uy0) );
dist = (int)hypot((double)(ref_pos.x - ux0),(double)(ref_pos.y - uy0) );
if(abs(rayon-dist) > edge_mod->m_Width) break;
/* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente(ref_pos.y - uy0, ref_pos.x - ux0);
StAngle = (int) ArcTangente(uyf - uy0, uxf - ux0);
EndAngle = StAngle + edge_mod->m_Angle;
if( EndAngle > 3600 )
{
StAngle -= 3600; EndAngle -= 3600;
}
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
return(edge_mod);
break;
}
}
return(NULL) ;
}
......@@ -334,8 +353,8 @@ int StAngle, EndAngle, MouseAngle; /* pour localisation d'arcs,
EDA_BaseStruct * Locate_Cotation(BOARD * Pcb, int LayerSearch, int typeloc)
/*************************************************************************/
/* Serach for a cotation item , on LayerSearch,
(if LayerSearch == -1 , no yaere restriction )
return a pointer to the located item, or NULL
(if LayerSearch == -1 , no yaere restriction )
return a pointer to the located item, or NULL
*/
{
EDA_BaseStruct * PtStruct;
......@@ -344,184 +363,184 @@ TEXTE_PCB* pt_txt;
wxPoint ref_pos;
int ux0, uy0;
SET_REF_POS(ref_pos);
PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPECOTATION ) continue;
Cotation = (COTATION*) PtStruct;
if( (Cotation->m_Layer != LayerSearch) && (LayerSearch != -1) )
continue;
/* Localisation du texte ? */
pt_txt = Cotation->m_Text;
if( pt_txt )
{
if( pt_txt->Locate(ref_pos) ) return(PtStruct);
}
/* Localisation des SEGMENTS ?) */
ux0 = Cotation->Barre_ox ; uy0 = Cotation->Barre_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx =Cotation->Barre_fx - ux0 ; dy = Cotation->Barre_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->TraitG_ox ; uy0 = Cotation->TraitG_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->TraitG_fx - ux0 ; dy = Cotation->TraitG_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->TraitD_ox ; uy0 = Cotation->TraitD_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->TraitD_fx - ux0 ; dy = Cotation->TraitD_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheD1_ox ; uy0 = Cotation->FlecheD1_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheD1_fx - ux0 ; dy = Cotation->FlecheD1_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheD2_ox ; uy0 = Cotation->FlecheD2_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheD2_fx - ux0 ; dy = Cotation->FlecheD2_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheG1_ox ; uy0 = Cotation->FlecheG1_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheG1_fx - ux0 ; dy = Cotation->FlecheG1_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheG2_ox ; uy0 = Cotation->FlecheG2_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheG2_fx - ux0 ; dy = Cotation->FlecheG2_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
}
return(NULL);
SET_REF_POS(ref_pos);
PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPECOTATION ) continue;
Cotation = (COTATION*) PtStruct;
if( (Cotation->m_Layer != LayerSearch) && (LayerSearch != -1) )
continue;
/* Localisation du texte ? */
pt_txt = Cotation->m_Text;
if( pt_txt )
{
if( pt_txt->Locate(ref_pos) ) return(PtStruct);
}
/* Localisation des SEGMENTS ?) */
ux0 = Cotation->Barre_ox ; uy0 = Cotation->Barre_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx =Cotation->Barre_fx - ux0 ; dy = Cotation->Barre_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->TraitG_ox ; uy0 = Cotation->TraitG_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->TraitG_fx - ux0 ; dy = Cotation->TraitG_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->TraitD_ox ; uy0 = Cotation->TraitD_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->TraitD_fx - ux0 ; dy = Cotation->TraitD_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheD1_ox ; uy0 = Cotation->FlecheD1_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheD1_fx - ux0 ; dy = Cotation->FlecheD1_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheD2_ox ; uy0 = Cotation->FlecheD2_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheD2_fx - ux0 ; dy = Cotation->FlecheD2_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheG1_ox ; uy0 = Cotation->FlecheG1_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheG1_fx - ux0 ; dy = Cotation->FlecheG1_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
ux0 = Cotation->FlecheG2_ox ; uy0 = Cotation->FlecheG2_oy;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = Cotation->FlecheG2_fx - ux0 ; dy = Cotation->FlecheG2_fy - uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( distance( Cotation->m_Width/2 )) return( PtStruct );
}
return(NULL);
}
/*************************************************************************/
DRAWSEGMENT * Locate_Segment_Pcb(BOARD * Pcb, int LayerSearch, int typeloc)
/*************************************************************************/
/* Localisation de segments de contour du type drawing
Retourne:
Pointeur sur DEBUT du segment localise
NULL si rien trouve
Le segment sur la couche active est dtect en priorite
Retourne:
Pointeur sur DEBUT du segment localise
NULL si rien trouve
Le segment sur la couche active est dtect en priorite
*/
{
EDA_BaseStruct * PtStruct;
DRAWSEGMENT * pts, *locate_segm = NULL;
wxPoint ref_pos;
PCB_SCREEN *screen = (PCB_SCREEN *)ActiveScreen;
SET_REF_POS(ref_pos);
PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue;
pts = ( DRAWSEGMENT * ) PtStruct;
if ( (pts->m_Layer != LayerSearch) && (LayerSearch != -1) )
continue;
ux0 = pts->m_Start.x ; uy0 = pts->m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = pts->m_End.x - ux0 ; dy = pts->m_End.y - uy0 ;
spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
{
int rayon, dist, StAngle, EndAngle, MouseAngle;
rayon = (int) hypot((double)(dx),(double)(dy) );
dist = (int) hypot((double)(spot_cX),(double)(spot_cY) );
if( abs(rayon-dist) <= (pts->m_Width/2) )
{
if(pts->m_Shape == S_CIRCLE)
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
/* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente(spot_cY, spot_cX);
StAngle = (int) ArcTangente(dy, dx);
EndAngle = StAngle + pts->m_Angle;
if( EndAngle > 3600 )
{
StAngle -= 3600; EndAngle -= 3600;
}
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
}
}
else
{
if( distance( pts->m_Width /2 ) )
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
}
}
return(locate_segm) ;
SET_REF_POS(ref_pos);
PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue;
pts = ( DRAWSEGMENT * ) PtStruct;
if ( (pts->m_Layer != LayerSearch) && (LayerSearch != -1) )
continue;
ux0 = pts->m_Start.x ; uy0 = pts->m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = pts->m_End.x - ux0 ; dy = pts->m_End.y - uy0 ;
spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0 ;
/* detection : */
if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
{
int rayon, dist, StAngle, EndAngle, MouseAngle;
rayon = (int) hypot((double)(dx),(double)(dy) );
dist = (int) hypot((double)(spot_cX),(double)(spot_cY) );
if( abs(rayon-dist) <= (pts->m_Width/2) )
{
if(pts->m_Shape == S_CIRCLE)
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
/* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente(spot_cY, spot_cX);
StAngle = (int) ArcTangente(dy, dx);
EndAngle = StAngle + pts->m_Angle;
if( EndAngle > 3600 )
{
StAngle -= 3600; EndAngle -= 3600;
}
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
}
}
else
{
if( distance( pts->m_Width /2 ) )
{
if(pts->m_Layer == screen->m_Active_Layer)
return( pts ) ;
else if ( ! locate_segm ) locate_segm = pts;
}
}
}
return(locate_segm) ;
}
/*************************************************/
/* D_PAD * Locate_Any_Pad(int typeloc, bool OnlyCurrentLayer) */
/* D_PAD* Locate_Any_Pad(int ref_pos, bool OnlyCurrentLayer) */
/*************************************************/
/*************************************************/
/* D_PAD * Locate_Any_Pad(int typeloc, bool OnlyCurrentLayer) */
/* D_PAD* Locate_Any_Pad(int ref_pos, bool OnlyCurrentLayer) */
/*************************************************/
/*
localisation de la pastille pointee par la coordonnee ref_pos.x,,ref_pos.y, ou
par la souris, recherche faite sur toutes les empreintes.
entree :
- coord souris
ou ref_pos
retourne:
pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
num_empr = numero d'empreinte du pad
la priorit est donne a la couche active
entree :
- coord souris
ou ref_pos
retourne:
pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
num_empr = numero d'empreinte du pad
la priorit est donne a la couche active
*/
D_PAD * Locate_Any_Pad(BOARD * Pcb, int typeloc, bool OnlyCurrentLayer)
{
wxPoint ref_pos;
SET_REF_POS(ref_pos);
return(Locate_Any_Pad(Pcb, ref_pos, OnlyCurrentLayer)) ;
SET_REF_POS(ref_pos);
return(Locate_Any_Pad(Pcb, ref_pos, OnlyCurrentLayer)) ;
}
D_PAD * Locate_Any_Pad(BOARD * Pcb, const wxPoint & ref_pos, bool OnlyCurrentLayer)
......@@ -529,45 +548,45 @@ D_PAD * Locate_Any_Pad(BOARD * Pcb, const wxPoint & ref_pos, bool OnlyCurrentLay
D_PAD * pt_pad ;
MODULE * module;
int layer_mask = g_TabOneLayerMask[ ((PCB_SCREEN*)ActiveScreen)->m_Active_Layer];
module = Pcb->m_Modules;
for( ; module != NULL ; module = (MODULE *) module->Pnext )
{
/* First: Search a pad on the active layer: */
if ( (pt_pad = Locate_Pads(module, ref_pos,layer_mask) ) != NULL )
return(pt_pad) ;
/* If not found, search on other layers: */
if ( ! OnlyCurrentLayer )
{
if ( (pt_pad = Locate_Pads(module, ref_pos,ALL_LAYERS) ) != NULL )
return(pt_pad) ;
}
}
return(NULL) ;
module = Pcb->m_Modules;
for( ; module != NULL ; module = (MODULE *) module->Pnext )
{
/* First: Search a pad on the active layer: */
if ( (pt_pad = Locate_Pads(module, ref_pos,layer_mask) ) != NULL )
return(pt_pad) ;
/* If not found, search on other layers: */
if ( ! OnlyCurrentLayer )
{
if ( (pt_pad = Locate_Pads(module, ref_pos,ALL_LAYERS) ) != NULL )
return(pt_pad) ;
}
}
return(NULL) ;
}
/******************************************************************************/
/* D_PAD* Locate_Pads(MODULE * module, int masque_layer,int typeloc) */
/* D_PAD* Locate_Pads(MODULE * module, int masque_layer,int typeloc) */
/* D_PAD* Locate_Pads(MODULE * module, const wxPoint & ref_pos,int masque_layer) */
/******************************************************************************/
/* localisation de la pastille pointee par la coordonnee ref_pos.x,,ref_pos.y, ou
par la souris, concernant l'empreinte en cours.
entree :
- parametres generaux de l'empreinte mise a jour par caract()
- masque_layer = couche(s) (bit_masque)sur laquelle doit etre la pastille
retourne:
un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
entree :
- parametres generaux de l'empreinte mise a jour par caract()
- masque_layer = couche(s) (bit_masque)sur laquelle doit etre la pastille
retourne:
un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee
*/
D_PAD * Locate_Pads(MODULE * module, int masque_layer,int typeloc)
{
wxPoint ref_pos;
SET_REF_POS(ref_pos);
return(Locate_Pads(module, ref_pos, masque_layer) );
SET_REF_POS(ref_pos);
return(Locate_Pads(module, ref_pos, masque_layer) );
}
......@@ -577,45 +596,45 @@ D_PAD * pt_pad ;
int deltaX, deltaY;
wxPoint shape_pos;
double dist;
pt_pad = module->m_Pads;
for ( ; pt_pad != NULL; pt_pad = (D_PAD*)pt_pad->Pnext )
{
pt_pad = module->m_Pads;
for ( ; pt_pad != NULL; pt_pad = (D_PAD*)pt_pad->Pnext )
{
shape_pos = pt_pad->ReturnShapePos();
ux0 = shape_pos.x; uy0 = shape_pos.y; /* pos x,y du centre du pad */
deltaX = ref_pos.x - ux0; deltaY = ref_pos.y - uy0;
/* Test rapide: le point a tester doit etre a l'interieur du cercle
exinscrit ... */
if ( (abs(deltaX) > pt_pad->m_Rayon ) ||
(abs(deltaY) > pt_pad->m_Rayon) )
continue;
/* ... et sur la bonne couche */
if( (pt_pad->m_Masque_Layer & masque_layer) == 0) continue ;
/* calcul des demi dim dx et dy */
dx = pt_pad->m_Size.x >> 1; // dx also is the radius for rounded pads
dy = pt_pad->m_Size.y >> 1;
/* localisation ? */
switch (pt_pad->m_PadShape & 0x7F)
{
case CIRCLE :
dist = hypot(deltaX, deltaY);
if ( (int)(round(dist)) <= dx ) return(pt_pad) ;
break;
default:
/* calcul des coord du point test dans le repere du Pad */
RotatePoint(&deltaX, &deltaY, - pt_pad->m_Orient);
if ( (abs(deltaX) <= dx ) && (abs(deltaY) <= dy) )
return(pt_pad) ;
break;
}
}
return(NULL);
ux0 = shape_pos.x; uy0 = shape_pos.y; /* pos x,y du centre du pad */
deltaX = ref_pos.x - ux0; deltaY = ref_pos.y - uy0;
/* Test rapide: le point a tester doit etre a l'interieur du cercle
exinscrit ... */
if ( (abs(deltaX) > pt_pad->m_Rayon ) ||
(abs(deltaY) > pt_pad->m_Rayon) )
continue;
/* ... et sur la bonne couche */
if( (pt_pad->m_Masque_Layer & masque_layer) == 0) continue ;
/* calcul des demi dim dx et dy */
dx = pt_pad->m_Size.x >> 1; // dx also is the radius for rounded pads
dy = pt_pad->m_Size.y >> 1;
/* localisation ? */
switch (pt_pad->m_PadShape & 0x7F)
{
case CIRCLE :
dist = hypot(deltaX, deltaY);
if ( (int)(round(dist)) <= dx ) return(pt_pad) ;
break;
default:
/* calcul des coord du point test dans le repere du Pad */
RotatePoint(&deltaX, &deltaY, - pt_pad->m_Orient);
if ( (abs(deltaX) <= dx ) && (abs(deltaY) <= dy) )
return(pt_pad) ;
break;
}
}
return(NULL);
}
......@@ -624,88 +643,101 @@ MODULE * Locate_Prefered_Module(BOARD * Pcb, int typeloc)
/********************************************************/
/*
localisation d'une empreinte par son rectangle d'encadrement
Si plusieurs empreintes sont possibles, la priorite est:
- sur la couche active
- la plus petite
Si plusieurs empreintes sont possibles, la priorite est:
- sur la couche active
- la plus petite
*/
{
MODULE * pt_module;
int lx , ly; /* dimensions du rectangle d'encadrement du module */
MODULE * module = NULL, /* module localise sur la couche active */
* Altmodule = NULL; /* module localise sur les couches non actives */
int min_dim = 0x7FFFFFFF, /* dim mini du module localise sur la couche active */
alt_min_dim = 0x7FFFFFFF; /* dim mini du module localise sur les couches non actives */
int layer; /* pour calcul de couches prioritaires */
wxPoint ref_pos; /* coord du point de reference pour la localisation */
SET_REF_POS(ref_pos);
pt_module = Pcb->m_Modules;
for( ; pt_module != NULL ; pt_module = (MODULE *) pt_module->Pnext )
{
/* calcul des dimensions du cadre :*/
lx = pt_module->m_BoundaryBox.GetWidth();
ly = pt_module->m_BoundaryBox.GetHeight();
/* Calcul des coord souris dans le repere module */
spot_cX = ref_pos.x - pt_module->m_Pos.x;
spot_cY = ref_pos.y - pt_module->m_Pos.y;
RotatePoint(&spot_cX, &spot_cY, - pt_module->m_Orient);
/* la souris est-elle dans ce rectangle : */
if( ! pt_module->m_BoundaryBox.Inside(spot_cX, spot_cY) )
continue;
/* Localisation: test des dimensions minimales, choix du meilleur candidat */
/* calcul de priorite: la priorite est donnee a la couche
d'appartenance du module et a la couche cuivre si le module
est sur couche serigr,adhesive cuivre, a la couche cmp si le module
est sur couche serigr,adhesive composant */
layer = pt_module->m_Layer;
if( (layer == ADHESIVE_N_CU) || (layer == SILKSCREEN_N_CU) )
layer = CUIVRE_N;
if( (layer == ADHESIVE_N_CMP) || (layer == SILKSCREEN_N_CMP) )
layer = CMP_N;
if( ((PCB_SCREEN*)ActiveScreen)->m_Active_Layer == layer )
{
if( min(lx,ly) <= min_dim )
{ /* meilleure empreinte localisee sur couche active */
module = pt_module ; min_dim = min(lx,ly) ;
}
}
else
{
if( min(lx,ly) <= alt_min_dim )
{ /* meilleure empreinte localisee sur autres couches */
Altmodule = pt_module ; alt_min_dim = min(lx,ly) ;
}
}
} /* fin boucle d'examen des modules */
if(module)
{
return(module);
}
if(Altmodule)
{
return(Altmodule);
}
return(NULL);
MODULE* pt_module;
int lx, ly; /* dimensions du rectangle d'encadrement du module */
MODULE* module = NULL; /* module localise sur la couche active */
MODULE* Altmodule = NULL; /* module localise sur les couches non actives */
int min_dim = 0x7FFFFFFF; /* dim mini du module localise sur la couche active */
int alt_min_dim = 0x7FFFFFFF; /* dim mini du module localise sur les couches non actives */
int layer; /* pour calcul de couches prioritaires */
wxPoint ref_pos; /* coord du point de reference pour la localisation */
SET_REF_POS(ref_pos);
pt_module = Pcb->m_Modules;
for( ; pt_module; pt_module = (MODULE*) pt_module->Pnext )
{
/* calcul des dimensions du cadre :*/
lx = pt_module->m_BoundaryBox.GetWidth();
ly = pt_module->m_BoundaryBox.GetHeight();
/* Calcul des coord souris dans le repere module */
spot_cX = ref_pos.x - pt_module->m_Pos.x;
spot_cY = ref_pos.y - pt_module->m_Pos.y;
RotatePoint(&spot_cX, &spot_cY, - pt_module->m_Orient);
/* la souris est-elle dans ce rectangle : */
if( ! pt_module->m_BoundaryBox.Inside(spot_cX, spot_cY) )
continue;
// if caller wants to ignore locked modules, and this one is locked, skip it.
if( (typeloc & IGNORE_LOCKED) && pt_module->IsLocked() )
continue;
/* Localisation: test des dimensions minimales, choix du meilleur candidat */
/* calcul de priorite: la priorite est donnee a la couche
d'appartenance du module et a la couche cuivre si le module
est sur couche serigr,adhesive cuivre, a la couche cmp si le module
est sur couche serigr,adhesive composant */
layer = pt_module->m_Layer;
if( layer==ADHESIVE_N_CU || layer==SILKSCREEN_N_CU )
layer = CUIVRE_N;
else if( layer==ADHESIVE_N_CMP || layer==SILKSCREEN_N_CMP )
layer = CMP_N;
if( ((PCB_SCREEN*)ActiveScreen)->m_Active_Layer == layer )
{
if( min(lx,ly) <= min_dim )
{
/* meilleure empreinte localisee sur couche active */
module = pt_module ; min_dim = min(lx,ly) ;
}
}
else if( !(typeloc & MATCH_LAYER)
&& ( !(typeloc & VISIBLE_ONLY) || IsModuleLayerVisible( layer )) )
{
if( min(lx,ly) <= alt_min_dim )
{
/* meilleure empreinte localisee sur autres couches */
Altmodule = pt_module;
alt_min_dim = min(lx,ly);
}
}
}
if( module )
{
return module;
}
if( Altmodule )
{
return Altmodule;
}
return NULL;
}
/*****************************************************************************/
TEXTE_MODULE * LocateTexteModule(BOARD * Pcb, MODULE ** PtModule, int typeloc)
/*****************************************************************************/
/* localisation du texte pointe par la souris (texte sur empreinte)
si * PtModule == NULL; recherche sur tous les modules
sinon sur le module pointe par module
si * PtModule == NULL; recherche sur tous les modules
sinon sur le module pointe par module
retourne
- pointeur sur le texte localise ( ou NULL )
- si Ptmodule != NULL: pointeur sur module module ( non modifie sinon )
retourne
- pointeur sur le texte localise ( ou NULL )
- si Ptmodule != NULL: pointeur sur module module ( non modifie sinon )
*/
{
EDA_BaseStruct * PtStruct;
......@@ -713,65 +745,65 @@ TEXTE_MODULE * pt_txt_mod ;
MODULE * module;
wxPoint ref_pos;
SET_REF_POS(ref_pos);
module = * PtModule;
if( module == NULL )
{
module = Pcb->m_Modules;
}
for( ; module != NULL; module = (MODULE*)module->Pnext )
{
pt_txt_mod = module->m_Reference;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
pt_txt_mod = module->m_Value;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
PtStruct = module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPETEXTEMODULE ) continue;
pt_txt_mod = (TEXTE_MODULE*) PtStruct;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
}
if( *PtModule != NULL ) break; /* Recherche limitee a 1 seul module */
}
return(NULL) ;
SET_REF_POS(ref_pos);
module = * PtModule;
if( module == NULL )
{
module = Pcb->m_Modules;
}
for( ; module != NULL; module = (MODULE*)module->Pnext )
{
pt_txt_mod = module->m_Reference;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
pt_txt_mod = module->m_Value;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
PtStruct = module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPETEXTEMODULE ) continue;
pt_txt_mod = (TEXTE_MODULE*) PtStruct;
/* la souris est-elle dans le rectangle autour du texte*/
if( pt_txt_mod->Locate(ref_pos) )
{
if( PtModule) *PtModule = module;
return(pt_txt_mod);
}
}
if( *PtModule != NULL ) break; /* Recherche limitee a 1 seul module */
}
return(NULL) ;
}
/**************************************************************/
TRACK * Locate_Piste_Connectee( TRACK * PtRefSegm, TRACK * pt_base,
TRACK * pt_lim, int extr)
TRACK * pt_lim, int extr)
/**************************************************************/
/* recherche le segment connecte au segment pointe par
PtRefSegm:
si int extr = START, le point de debut du segment est utilise
si int extr = END, le point de fin du segment est utilise
La recherche ne se fait que sur les EXTREMITES des segments
La recherche se fait de l'adresse :
pt_base a pt_lim (borne finale comprise)
si pt_lim = NULL, la recherche se fait jusqu'a la fin de la liste
Afin d'accelerer la recherche, une 1ere passe est faite, avec une recherche
realisee sur un ensemble de +/- 100 points autour du point courant.
Si echec: recherche generale
PtRefSegm:
si int extr = START, le point de debut du segment est utilise
si int extr = END, le point de fin du segment est utilise
La recherche ne se fait que sur les EXTREMITES des segments
La recherche se fait de l'adresse :
pt_base a pt_lim (borne finale comprise)
si pt_lim = NULL, la recherche se fait jusqu'a la fin de la liste
Afin d'accelerer la recherche, une 1ere passe est faite, avec une recherche
realisee sur un ensemble de +/- 100 points autour du point courant.
Si echec: recherche generale
*/
{
TRACK * PtSegmB, * PtSegmN;
......@@ -779,191 +811,191 @@ int Reflayer;
wxPoint pos_ref;
int ii;
if ( extr == START) pos_ref = PtRefSegm->m_Start;
else pos_ref = PtRefSegm->m_End;
Reflayer = PtRefSegm->ReturnMaskLayer();
/* 1ere passe */
PtSegmB = PtSegmN = PtRefSegm;
for ( ii = 0; ii < 50; ii++ )
{
if( (PtSegmN == NULL) && (PtSegmB == NULL) ) break;
if( PtSegmN )
{
if( PtSegmN->GetState(BUSY|DELETED) ) goto suite;
if (PtSegmN == PtRefSegm) goto suite;
if( pos_ref == PtSegmN->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if( pos_ref == PtSegmN->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
suite:
if( PtSegmN == pt_lim ) PtSegmN = NULL;
else PtSegmN = (TRACK*)PtSegmN->Pnext;
}
if( PtSegmB )
{
if(PtSegmB->GetState(BUSY|DELETED) ) goto suite1;
if (PtSegmB == PtRefSegm) goto suite1;
if( pos_ref == PtSegmB->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmB->ReturnMaskLayer() )return(PtSegmB);
}
if( pos_ref == PtSegmB->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmB->ReturnMaskLayer() )return(PtSegmB);
}
suite1:
if( PtSegmB == pt_base ) PtSegmB = NULL;
else if( PtSegmB->m_StructType != TYPEPCB) PtSegmB = (TRACK*)PtSegmB->Pback;
else PtSegmB = NULL;
}
}
/* Recherche generale */
for ( PtSegmN = pt_base; PtSegmN != NULL; PtSegmN = (TRACK*) PtSegmN->Pnext )
{
if(PtSegmN->GetState(DELETED|BUSY))
{
if (PtSegmN == pt_lim ) break;
continue;
}
if (PtSegmN == PtRefSegm)
{
if (PtSegmN == pt_lim ) break;
continue;
}
if( pos_ref == PtSegmN->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if( pos_ref == PtSegmN->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if (PtSegmN == pt_lim ) break;
}
return (NULL);
if ( extr == START) pos_ref = PtRefSegm->m_Start;
else pos_ref = PtRefSegm->m_End;
Reflayer = PtRefSegm->ReturnMaskLayer();
/* 1ere passe */
PtSegmB = PtSegmN = PtRefSegm;
for ( ii = 0; ii < 50; ii++ )
{
if( (PtSegmN == NULL) && (PtSegmB == NULL) ) break;
if( PtSegmN )
{
if( PtSegmN->GetState(BUSY|DELETED) ) goto suite;
if (PtSegmN == PtRefSegm) goto suite;
if( pos_ref == PtSegmN->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if( pos_ref == PtSegmN->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
suite:
if( PtSegmN == pt_lim ) PtSegmN = NULL;
else PtSegmN = (TRACK*)PtSegmN->Pnext;
}
if( PtSegmB )
{
if(PtSegmB->GetState(BUSY|DELETED) ) goto suite1;
if (PtSegmB == PtRefSegm) goto suite1;
if( pos_ref == PtSegmB->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmB->ReturnMaskLayer() )return(PtSegmB);
}
if( pos_ref == PtSegmB->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmB->ReturnMaskLayer() )return(PtSegmB);
}
suite1:
if( PtSegmB == pt_base ) PtSegmB = NULL;
else if( PtSegmB->m_StructType != TYPEPCB) PtSegmB = (TRACK*)PtSegmB->Pback;
else PtSegmB = NULL;
}
}
/* Recherche generale */
for ( PtSegmN = pt_base; PtSegmN != NULL; PtSegmN = (TRACK*) PtSegmN->Pnext )
{
if(PtSegmN->GetState(DELETED|BUSY))
{
if (PtSegmN == pt_lim ) break;
continue;
}
if (PtSegmN == PtRefSegm)
{
if (PtSegmN == pt_lim ) break;
continue;
}
if( pos_ref == PtSegmN->m_Start )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if( pos_ref == PtSegmN->m_End )
{ /* Test des couches */
if(Reflayer & PtSegmN->ReturnMaskLayer() )return(PtSegmN);
}
if (PtSegmN == pt_lim ) break;
}
return (NULL);
}
/****************************************************************************/
/* TRACK *Locate_Pistes(TRACK * start_adresse, int MasqueLayer,int typeloc) */
/* TRACK *Locate_Pistes(TRACK * start_adresse, int MasqueLayer,int typeloc) */
/* TRACK *Locate_Pistes(TRACK * start_adresse, int ref_pos.x, int ref_pos.y,*/
/* int MasqueLayer) */
/* int MasqueLayer) */
/****************************************************************************/
/*
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_pos.x , ref_pos.y.r
ref_pos.x , ref_pos.y.r
La recherche commence a l'adresse start_adresse
La recherche commence a l'adresse start_adresse
*/
TRACK * Locate_Pistes(TRACK * start_adresse,int MasqueLayer, int typeloc )
{
wxPoint ref_pos;
SET_REF_POS(ref_pos);
SET_REF_POS(ref_pos);
return( Locate_Pistes(start_adresse, ref_pos,MasqueLayer) );
return( Locate_Pistes(start_adresse, ref_pos,MasqueLayer) );
}
TRACK * Locate_Pistes(TRACK * start_adresse, const wxPoint & ref_pos,int MasqueLayer)
{
TRACK * Track; /* pointeur sur les pistes */
int l_piste ; /* demi-largeur de la piste */
for( Track = start_adresse; Track != NULL; Track = (TRACK*) Track->Pnext)
{
if( Track->GetState(BUSY|DELETED) ) continue;
if ( (g_DesignSettings.m_LayerColor[Track->m_Layer] & ITEM_NOT_SHOW) )
continue;
/* calcul des coordonnees du segment teste */
l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Track->m_Start.x ; uy0 = Track->m_Start.y ; /* coord de depart */
dx = Track->m_End.x ; dy = Track->m_End.y ; /* coord d'arrivee */
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0 ; dy -= uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
if ( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
{
if ((abs(spot_cX) <= l_piste ) && (abs(spot_cY) <=l_piste))
{
return(Track) ;
}
continue ;
}
if(MasqueLayer != -1)
if( (g_TabOneLayerMask[Track->m_Layer] & MasqueLayer) == 0)
continue; /* Segments sur couches differentes */
if( distance(l_piste) ) return(Track) ;
}
return(NULL) ;
TRACK * Track; /* pointeur sur les pistes */
int l_piste ; /* demi-largeur de la piste */
for( Track = start_adresse; Track != NULL; Track = (TRACK*) Track->Pnext)
{
if( Track->GetState(BUSY|DELETED) ) continue;
if ( (g_DesignSettings.m_LayerColor[Track->m_Layer] & ITEM_NOT_SHOW) )
continue;
/* calcul des coordonnees du segment teste */
l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Track->m_Start.x ; uy0 = Track->m_Start.y ; /* coord de depart */
dx = Track->m_End.x ; dy = Track->m_End.y ; /* coord d'arrivee */
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0 ; dy -= uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
if ( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
{
if ((abs(spot_cX) <= l_piste ) && (abs(spot_cY) <=l_piste))
{
return(Track) ;
}
continue ;
}
if(MasqueLayer != -1)
if( (g_TabOneLayerMask[Track->m_Layer] & MasqueLayer) == 0)
continue; /* Segments sur couches differentes */
if( distance(l_piste) ) return(Track) ;
}
return(NULL) ;
}
/****************************************************************/
/* TRACK * Locate_Zone(TRACK * start_adresse, int layer, */
/* int typeloc) */
/* TRACK * Locate_Zone(TRACK * start_adresse, */
/* const wxPoint & ref_pos, */
/* int layer) */
/****************************************************************/
/****************************************************************/
/* 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_pos.x , ref_pos.y.r
ref_pos.x , ref_pos.y.r
Si layer == -1 , le tst de la couche n'est pas fait
Si layer == -1 , le tst de la couche n'est pas fait
La recherche commence a l'adresse start_adresse
La recherche commence a l'adresse start_adresse
*/
TRACK * Locate_Zone(TRACK * start_adresse,int layer, int typeloc )
{
wxPoint ref_pos;
SET_REF_POS(ref_pos);
SET_REF_POS(ref_pos);
return( Locate_Zone(start_adresse, ref_pos, layer) );
return( Locate_Zone(start_adresse, ref_pos, layer) );
}
TRACK * Locate_Zone(TRACK * start_adresse, const wxPoint & ref_pos, int layer)
{
TRACK * Zone; /* pointeur sur les pistes */
int l_segm ; /* demi-largeur de la piste */
for( Zone = start_adresse; Zone != NULL; Zone = (TRACK *) Zone->Pnext)
{
/* calcul des coordonnees du segment teste */
l_segm = Zone->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Zone->m_Start.x ; uy0 = Zone->m_Start.y ; /* coord de depart */
dx = Zone->m_End.x ; dy = Zone->m_End.y ; /* coord d'arrivee */
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0 ; dy -= uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
if((layer != -1) && (Zone->m_Layer != layer)) continue;
if( distance(l_segm) ) return(Zone) ;
}
return(NULL) ;
TRACK * Zone; /* pointeur sur les pistes */
int l_segm ; /* demi-largeur de la piste */
for( Zone = start_adresse; Zone != NULL; Zone = (TRACK *) Zone->Pnext)
{
/* calcul des coordonnees du segment teste */
l_segm = Zone->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Zone->m_Start.x ; uy0 = Zone->m_Start.y ; /* coord de depart */
dx = Zone->m_End.x ; dy = Zone->m_End.y ; /* coord d'arrivee */
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0 ; dy -= uy0 ;
spot_cX = ref_pos.x - ux0 ; spot_cY = ref_pos.y - uy0 ;
if((layer != -1) && (Zone->m_Layer != layer)) continue;
if( distance(l_segm) ) return(Zone) ;
}
return(NULL) ;
}
......@@ -972,24 +1004,24 @@ int l_segm ; /* demi-largeur de la piste */
TEXTE_PCB * Locate_Texte_Pcb(EDA_BaseStruct * PtStruct, int LayerSearch, int typeloc)
/************************************************************************************/
/* localisation des inscriptions sur le Pcb:
entree : EDA_BaseStruct pointeur sur le debut de la zone de recherche
retour : pointeur sur la description du texte localise
entree : EDA_BaseStruct pointeur sur le debut de la zone de recherche
retour : pointeur sur la description du texte localise
*/
{
wxPoint ref;
SET_REF_POS(ref);
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPETEXTE ) continue;
TEXTE_PCB * pt_txt_pcb = (TEXTE_PCB *) PtStruct;
if( pt_txt_pcb->Locate(ref) )
{
if ( pt_txt_pcb->m_Layer == LayerSearch )
return pt_txt_pcb;
}
}
return(NULL) ;
SET_REF_POS(ref);
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPETEXTE ) continue;
TEXTE_PCB * pt_txt_pcb = (TEXTE_PCB *) PtStruct;
if( pt_txt_pcb->Locate(ref) )
{
if ( pt_txt_pcb->m_Layer == LayerSearch )
return pt_txt_pcb;
}
}
return(NULL) ;
}
......@@ -1001,270 +1033,270 @@ int distance(int seuil)
/*
Calcul de la distance du curseur souris a un segment de droite :
( piste, edge, contour module ..
retourne:
0 si distance > seuil
1 si distance <= seuil
Variables utilisees ( doivent etre initialisees avant appel , et
sont ramenees au repere centre sur l'origine du segment)
dx, dy = coord de l'extremite segment.
spot_cX,spot_cY = coord du curseur souris
la recherche se fait selon 4 cas:
segment horizontal
segment vertical
segment 45
segment quelconque
retourne:
0 si distance > seuil
1 si distance <= seuil
Variables utilisees ( doivent etre initialisees avant appel , et
sont ramenees au repere centre sur l'origine du segment)
dx, dy = coord de l'extremite segment.
spot_cX,spot_cY = coord du curseur souris
la recherche se fait selon 4 cas:
segment horizontal
segment vertical
segment 45
segment quelconque
*/
{
int cXrot, cYrot , /* coord du point (souris) dans le repere tourne */
segX, segY; /* coord extremite segment tj >= 0 */
int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
segX et segY sont >=0 */
segX = dx ; segY = dy; pointX = spot_cX ; pointY = spot_cY ;
/*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
if (segX < 0) /* mise en >0 par symetrie par rapport a l'axe Y */
{
segX = -segX ; pointX = - pointX ;
}
if (segY < 0) /* mise en > 0 par symetrie par rapport a l'axe X */
{
segY = -segY ; pointY = -pointY ;
}
if ( segY == 0 ) /* piste Horizontale */
{
if(abs(pointY) <= seuil )
{
if((pointX >= 0) && (pointX <= segX) ) return(1);
/* Etude des extremites : cercle de rayon seuil */
if( (pointX < 0) && (pointX >= -seuil) )
{
if( ((pointX * pointX) + (pointY*pointY)) <= (seuil*seuil) )
return(1);
}
if( (pointX > segX) && (pointX <= (segX+seuil)) )
{
if( (((pointX-segX) * (pointX-segX)) + (pointY*pointY)) <= (seuil*seuil) )
return(1);
}
}
}
else if ( segX == 0 ) /* piste verticale */
{
if( abs(pointX) <= seuil)
{
if((pointY >= 0 ) && (pointY <= segY) ) return(1);
if( (pointY < 0) && (pointY >= -seuil) )
{
if( ((pointY * pointY) + (pointX*pointX)) <= (seuil*seuil) )
return(1);
}
if( (pointY > segY) && (pointY <= (segY+seuil)) )
{
if( ( ((pointY-segY) * (pointY-segY)) + (pointX*pointX)) <= (seuil*seuil) )
return(1);
}
}
}
else if ( segX == segY ) /* piste a 45 degre */
{
/* on fait tourner les axes de 45 degre. la souris a alors les
coord : x1 = x*cos45 + y*sin45
y1 = y*cos45 - x*sin45
et le segment de piste est alors horizontal.
recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
remarque : sin ou cos45 = .707, et lors du recalcul des coord
dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
trop grands. (c.a.d trop petits)
spot_cX,Y doit etre * par .707 * .707 = 0.5 */
cXrot = (pointX + pointY) >> 1 ;
cYrot = (pointY - pointX) >> 1 ;
/* recalcul des coord de l'extremite du segment , qui sera vertical
suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
et est en fait 1,414 plus grand , et dy45 = 0 */
// seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
seuil *= 7 ; seuil /= 10 ;
if ( abs(cYrot) <= seuil) /* ok sur axe vertical) */
{
if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
{
if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
{
if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
}
}
else /* orientation quelconque */
{
/* On fait un changement d'axe (rotation) de facon a ce que le segment
de piste soit horizontal dans le nouveau repere */
int angle;
angle = (int)( atan2((float)segY, (float)segX) * 1800 / M_PI) ;
cXrot = pointX; cYrot = pointY;
RotatePoint(&cXrot, &cYrot, angle); /* Rotation du point a tester */
RotatePoint(&segX, &segY, angle) ; /* Rotation du segment */
/*la piste est Horizontale , par suite des modifs de coordonnes
et d'axe, donc segX = longueur du segment */
if ( abs(cYrot) <= seuil ) /* ok sur axe vertical) */
{
if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
{
if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
{
if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
}
}
return(0) ;
int cXrot, cYrot , /* coord du point (souris) dans le repere tourne */
segX, segY; /* coord extremite segment tj >= 0 */
int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
segX et segY sont >=0 */
segX = dx ; segY = dy; pointX = spot_cX ; pointY = spot_cY ;
/*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
if (segX < 0) /* mise en >0 par symetrie par rapport a l'axe Y */
{
segX = -segX ; pointX = - pointX ;
}
if (segY < 0) /* mise en > 0 par symetrie par rapport a l'axe X */
{
segY = -segY ; pointY = -pointY ;
}
if ( segY == 0 ) /* piste Horizontale */
{
if(abs(pointY) <= seuil )
{
if((pointX >= 0) && (pointX <= segX) ) return(1);
/* Etude des extremites : cercle de rayon seuil */
if( (pointX < 0) && (pointX >= -seuil) )
{
if( ((pointX * pointX) + (pointY*pointY)) <= (seuil*seuil) )
return(1);
}
if( (pointX > segX) && (pointX <= (segX+seuil)) )
{
if( (((pointX-segX) * (pointX-segX)) + (pointY*pointY)) <= (seuil*seuil) )
return(1);
}
}
}
else if ( segX == 0 ) /* piste verticale */
{
if( abs(pointX) <= seuil)
{
if((pointY >= 0 ) && (pointY <= segY) ) return(1);
if( (pointY < 0) && (pointY >= -seuil) )
{
if( ((pointY * pointY) + (pointX*pointX)) <= (seuil*seuil) )
return(1);
}
if( (pointY > segY) && (pointY <= (segY+seuil)) )
{
if( ( ((pointY-segY) * (pointY-segY)) + (pointX*pointX)) <= (seuil*seuil) )
return(1);
}
}
}
else if ( segX == segY ) /* piste a 45 degre */
{
/* on fait tourner les axes de 45 degre. la souris a alors les
coord : x1 = x*cos45 + y*sin45
y1 = y*cos45 - x*sin45
et le segment de piste est alors horizontal.
recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
remarque : sin ou cos45 = .707, et lors du recalcul des coord
dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
trop grands. (c.a.d trop petits)
spot_cX,Y doit etre * par .707 * .707 = 0.5 */
cXrot = (pointX + pointY) >> 1 ;
cYrot = (pointY - pointX) >> 1 ;
/* recalcul des coord de l'extremite du segment , qui sera vertical
suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
et est en fait 1,414 plus grand , et dy45 = 0 */
// seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
seuil *= 7 ; seuil /= 10 ;
if ( abs(cYrot) <= seuil) /* ok sur axe vertical) */
{
if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
{
if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
{
if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
}
}
else /* orientation quelconque */
{
/* On fait un changement d'axe (rotation) de facon a ce que le segment
de piste soit horizontal dans le nouveau repere */
int angle;
angle = (int)( atan2((float)segY, (float)segX) * 1800 / M_PI) ;
cXrot = pointX; cYrot = pointY;
RotatePoint(&cXrot, &cYrot, angle); /* Rotation du point a tester */
RotatePoint(&segX, &segY, angle) ; /* Rotation du segment */
/*la piste est Horizontale , par suite des modifs de coordonnes
et d'axe, donc segX = longueur du segment */
if ( abs(cYrot) <= seuil ) /* ok sur axe vertical) */
{
if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
{
if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
{
if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
return(1);
}
}
}
return(0) ;
}
/*******************************************************************************/
D_PAD * Fast_Locate_Pad_Connecte(BOARD * Pcb, const wxPoint & ref_pos, int masque_layer)
/*******************************************************************************/
/* Routine cherchant le pad de centre px,py,
sur la couche indiquee par masque_layer (bit a bit)
( extremite de piste )
La liste des pads doit deja exister.
retourne :
NULL si pas de pad localise.
pointeur sur la structure descr_pad correspondante si pad trouve
(bonne position ET bonne couche).
sur la couche indiquee par masque_layer (bit a bit)
( extremite de piste )
La liste des pads doit deja exister.
retourne :
NULL si pas de pad localise.
pointeur sur la structure descr_pad correspondante si pad trouve
(bonne position ET bonne couche).
*/
{
D_PAD * pad;
LISTE_PAD * ptr_pad , * lim;
lim = (LISTE_PAD*)Pcb->m_Pads + Pcb->m_NbPads;
for (ptr_pad = (LISTE_PAD*)Pcb->m_Pads; ptr_pad < lim ; ptr_pad++)
{
pad = * ptr_pad;
if( pad->m_Pos != ref_pos ) continue ;
lim = (LISTE_PAD*)Pcb->m_Pads + Pcb->m_NbPads;
for (ptr_pad = (LISTE_PAD*)Pcb->m_Pads; ptr_pad < lim ; ptr_pad++)
{
pad = * ptr_pad;
if( pad->m_Pos != ref_pos ) continue ;
/* Pad peut-etre trouve ici : il doit etre sur la bonne couche */
if (pad->m_Masque_Layer & masque_layer) return(pad) ;
/* Pad peut-etre trouve ici : il doit etre sur la bonne couche */
if (pad->m_Masque_Layer & masque_layer) return(pad) ;
}
return(NULL);
}
return(NULL);
}
/***********************************************************************************/
TRACK * Fast_Locate_Piste(TRACK *start_adr, TRACK* end_adr,
const wxPoint & ref_pos, int MaskLayer)
const wxPoint & ref_pos, int MaskLayer)
/***********************************************************************************/
/* Localiste le segment dont une extremite coincide avec le point x,y
sur les couches donnees par masklayer
la recherche se fait de l'adresse start_adr a end_adr
si end_adr = NULL, recherche jusqu'a la fin de la liste
Les segments de piste marques avec le flag DELETED ne sont pas
pris en compte
sur les couches donnees par masklayer
la recherche se fait de l'adresse start_adr a end_adr
si end_adr = NULL, recherche jusqu'a la fin de la liste
Les segments de piste marques avec le flag DELETED ne sont pas
pris en compte
*/
{
TRACK * PtSegm;
if( start_adr == NULL ) return(NULL);
for ( PtSegm = start_adr; PtSegm != NULL; PtSegm = (TRACK*) PtSegm->Pnext )
{
if( PtSegm->GetState(DELETED|BUSY) == 0)
{
if( ref_pos == PtSegm->m_Start )
{ /* Test des couches */
if(MaskLayer & PtSegm->ReturnMaskLayer() ) return(PtSegm);
}
if( ref_pos == PtSegm->m_End )
{ /* Test des couches */
if(MaskLayer & PtSegm->ReturnMaskLayer() ) return(PtSegm);
}
}
if( PtSegm == end_adr) break;
}
return (NULL);
if( start_adr == NULL ) return(NULL);
for ( PtSegm = start_adr; PtSegm != NULL; PtSegm = (TRACK*) PtSegm->Pnext )
{
if( PtSegm->GetState(DELETED|BUSY) == 0)
{
if( ref_pos == PtSegm->m_Start )
{ /* Test des couches */
if(MaskLayer & PtSegm->ReturnMaskLayer() ) return(PtSegm);
}
if( ref_pos == PtSegm->m_End )
{ /* Test des couches */
if(MaskLayer & PtSegm->ReturnMaskLayer() ) return(PtSegm);
}
}
if( PtSegm == end_adr) break;
}
return (NULL);
}
/*******************************************************************/
TRACK * Fast_Locate_Via(TRACK *start_adr, TRACK* end_adr,
const wxPoint & pos, int MaskLayer)
const wxPoint & pos, int MaskLayer)
/*******************************************************************/
/* Localise la via de centre le point x,y , sur les couches donnees
par masklayer
la recherche se fait de l'adresse start_adr a end_adr.
si end_adr = NULL, recherche jusqu'a la fin de la liste
les vias dont le parametre State a le bit DELETED ou BUSY = 1 sont ignorees
par masklayer
la recherche se fait de l'adresse start_adr a end_adr.
si end_adr = NULL, recherche jusqu'a la fin de la liste
les vias dont le parametre State a le bit DELETED ou BUSY = 1 sont ignorees
*/
{
TRACK * PtSegm;
for ( PtSegm = start_adr; PtSegm != NULL; PtSegm = (TRACK*)PtSegm->Pnext )
{
if(PtSegm->m_StructType == TYPEVIA)
{
if( pos == PtSegm->m_Start )
{
if( PtSegm->GetState(BUSY|DELETED) == 0)
{/* Test des couches */
if( MaskLayer & PtSegm->ReturnMaskLayer() )return(PtSegm);
}
}
}
if( PtSegm == end_adr ) break;
}
return (NULL);
for ( PtSegm = start_adr; PtSegm != NULL; PtSegm = (TRACK*)PtSegm->Pnext )
{
if(PtSegm->m_StructType == TYPEVIA)
{
if( pos == PtSegm->m_Start )
{
if( PtSegm->GetState(BUSY|DELETED) == 0)
{/* Test des couches */
if( MaskLayer & PtSegm->ReturnMaskLayer() )return(PtSegm);
}
}
}
if( PtSegm == end_adr ) break;
}
return (NULL);
}
/***********************************************************************/
EDA_BaseStruct * Locate_MirePcb( EDA_BaseStruct * PtStruct, int LayerSearch,
int typeloc)
int typeloc)
/***********************************************************************/
/* Serach for a photo target
*/
{
wxPoint ref_pos; /* coord du point de localisation */
wxPoint ref_pos; /* coord du point de localisation */
int dX, dY, rayon;
if(PtStruct == NULL ) return(NULL);
SET_REF_POS(ref_pos);
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext)
{
MIREPCB* item;
if( PtStruct->m_StructType != TYPEMIRE ) continue;
item = (MIREPCB*) PtStruct;
if( LayerSearch != -1 && item->m_Layer != LayerSearch ) continue;
dX = ref_pos.x - item->m_Pos.x;
dY = ref_pos.y - item->m_Pos.y;
rayon = item->m_Size / 2;
if( (abs(dX) <= rayon ) && ( abs(dY) <= rayon ) )
break; /* Mire Localisee */
}
return(PtStruct);
if(PtStruct == NULL ) return(NULL);
SET_REF_POS(ref_pos);
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext)
{
MIREPCB* item;
if( PtStruct->m_StructType != TYPEMIRE ) continue;
item = (MIREPCB*) PtStruct;
if( LayerSearch != -1 && item->m_Layer != LayerSearch ) continue;
dX = ref_pos.x - item->m_Pos.x;
dY = ref_pos.y - item->m_Pos.y;
rayon = item->m_Size / 2;
if( (abs(dX) <= rayon ) && ( abs(dY) <= rayon ) )
break; /* Mire Localisee */
}
return(PtStruct);
}
pcbnew/pcbnew.h
View file @ f601dff4
......@@ -15,8 +15,12 @@
/* valeur de flag indicant si le pointeur de reference pour une localisation
est le curseur sur grille ou le curseur a deplacement fin hors grille */
#define CURSEUR_ON_GRILLE 0
#define CURSEUR_OFF_GRILLE 1
#define CURSEUR_ON_GRILLE (0<<0)
#define CURSEUR_OFF_GRILLE (1<<1)
#define IGNORE_LOCKED (1<<2) ///< if module is locked, do not select for single module operation
#define MATCH_LAYER (1<<3) ///< if module not on current layer, do not select
#define VISIBLE_ONLY (1<<4) ///< if module not on a visible layer, do not select
#define START 0 /* ctes parametre dans les routines de localisation */
#define END 1
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment