Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
K
kicad-source-mirror
Project
Project
Details
Activity
Releases
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Commits
Open sidebar
Elphel
kicad-source-mirror
Commits
2e4c17a8
Commit
2e4c17a8
authored
Aug 04, 2007
by
dickelbeck
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
beautification, commenting, and renaming
parent
caa42eaf
Changes
9
Hide whitespace changes
Inline
Side-by-side
Showing
9 changed files
with
1241 additions
and
1100 deletions
+1241
-1100
change_log.txt
change_log.txt
+9
-1
base_struct.cpp
common/base_struct.cpp
+560
-518
trigo.cpp
common/trigo.cpp
+173
-142
base_struct.h
include/base_struct.h
+8
-2
class_board.cpp
pcbnew/class_board.cpp
+207
-196
class_text_mod.cpp
pcbnew/class_text_mod.cpp
+210
-181
class_text_mod.h
pcbnew/class_text_mod.h
+53
-48
hotkeys.cpp
pcbnew/hotkeys.cpp
+16
-7
locate.cpp
pcbnew/locate.cpp
+5
-5
No files found.
change_log.txt
View file @
2e4c17a8
...
@@ -6,10 +6,18 @@ email address.
...
@@ -6,10 +6,18 @@ email address.
2007-Aug-05 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+ pcbnew & common
Changed the function name of Locate( const wxPoint& ref_pos ) to bool HitTest(..)
in both class_text_mod and base_struct.
More beautification and commenting.
2007-Aug-04 UPDATE Dick Hollenbeck <dick@softplc.com>
2007-Aug-04 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
================================================================================
+ pcbnew
+ pcbnew
Read-ability formatting, I am playing with a C++ beautifier called
uncrustify
.
Read-ability formatting, I am playing with a C++ beautifier called
"uncrustify"
.
I had to patch it and spent 2 days getting it configured. Patch not
I had to patch it and spent 2 days getting it configured. Patch not
sent upstream yet.
sent upstream yet.
Fixed a bug in "display local ratsnest pad or module": if you had a small
Fixed a bug in "display local ratsnest pad or module": if you had a small
...
...
common/base_struct.cpp
View file @
2e4c17a8
/********************************************************/
/********************************************************/
/* methodes pour les structures de base: */
/* methodes pour les structures de base: */
/* EDA_BaseStruct (classe non utilisable seule) */
/* EDA_BaseStruct (classe non utilisable seule) */
/* EDA_TextStruct (classe non utilisable seule) */
/* EDA_TextStruct (classe non utilisable seule) */
/********************************************************/
/********************************************************/
/* Fichier base_struct.cpp */
/* Fichier base_struct.cpp */
#include "fctsys.h"
#include "fctsys.h"
#include "gr_basic.h"
#include "gr_basic.h"
...
@@ -18,664 +18,706 @@
...
@@ -18,664 +18,706 @@
// DrawStructureType names for error messages only:
// DrawStructureType names for error messages only:
static
wxString
DrawStructureTypeName
[
MAX_STRUCT_TYPE_ID
+
1
]
static
wxString
DrawStructureTypeName
[
MAX_STRUCT_TYPE_ID
+
1
]
=
{
=
{
wxT
(
"Not init"
),
wxT
(
"Not init"
),
wxT
(
"Pcb"
),
wxT
(
"Pcb"
),
wxT
(
"Equipot"
),
wxT
(
"Equipot"
),
wxT
(
"Module"
),
wxT
(
"Module"
),
wxT
(
"Pad"
),
wxT
(
"Pad"
),
wxT
(
"DrawSegment"
),
wxT
(
"DrawSegment"
),
wxT
(
"Text (pcb)"
),
wxT
(
"Text (pcb)"
),
wxT
(
"Text module"
),
wxT
(
"Text module"
),
wxT
(
"edge module"
),
wxT
(
"edge module"
),
wxT
(
"track"
),
wxT
(
"track"
),
wxT
(
"zone"
),
wxT
(
"zone"
),
wxT
(
"via"
),
wxT
(
"via"
),
wxT
(
"marker"
),
wxT
(
"marker"
),
wxT
(
"cotation"
),
wxT
(
"cotation"
),
wxT
(
"mire"
),
wxT
(
"mire"
),
wxT
(
"screen"
),
wxT
(
"screen"
),
wxT
(
"block"
),
wxT
(
"block"
),
wxT
(
"edge zone"
),
wxT
(
"edge zone"
),
wxT
(
"Polyline"
),
wxT
(
"Polyline"
),
wxT
(
"Junction"
),
wxT
(
"Junction"
),
wxT
(
"Text"
),
wxT
(
"Text"
),
wxT
(
"Label"
),
wxT
(
"Label"
),
wxT
(
"Glob label"
),
wxT
(
"Glob label"
),
wxT
(
"Lib item"
),
wxT
(
"Lib item"
),
wxT
(
"Pick struct"
),
wxT
(
"Pick struct"
),
wxT
(
"Segment"
),
wxT
(
"Segment"
),
wxT
(
"Raccord"
),
wxT
(
"Raccord"
),
wxT
(
"Sheet"
),
wxT
(
"Sheet"
),
wxT
(
"Sheet label"
),
wxT
(
"Sheet label"
),
wxT
(
"Marker"
),
wxT
(
"Marker"
),
wxT
(
"No connect"
),
wxT
(
"No connect"
),
wxT
(
"Text (lib item)"
),
wxT
(
"Text (lib item)"
),
wxT
(
"Screen"
),
wxT
(
"Screen"
),
wxT
(
"Block locate"
),
wxT
(
"Block locate"
),
wxT
(
"Library component"
),
wxT
(
"Library component"
),
wxT
(
"lib cmp draw circle"
),
wxT
(
"lib cmp draw circle"
),
wxT
(
"lib cmp draw graphic text"
),
wxT
(
"lib cmp draw graphic text"
),
wxT
(
"lib cmp draw rect"
),
wxT
(
"lib cmp draw rect"
),
wxT
(
"lib cmp draw poly line"
),
wxT
(
"lib cmp draw poly line"
),
wxT
(
"lib cmp draw line"
),
wxT
(
"lib cmp draw line"
),
wxT
(
"lib cmp pin"
),
wxT
(
"lib cmp pin"
),
wxT
(
"lib cmp field"
),
wxT
(
"lib cmp field"
),
wxT
(
"unknown"
),
wxT
(
"unknown"
),
wxT
(
"unknown"
)
wxT
(
"unknown"
)
};
};
enum
textbox
{
enum
textbox
{
ID_TEXTBOX_LIST
=
8010
ID_TEXTBOX_LIST
=
8010
};
};
/******************************************************************************/
/******************************************************************************/
EDA_BaseStruct
::
EDA_BaseStruct
(
EDA_BaseStruct
*
parent
,
int
idType
)
EDA_BaseStruct
::
EDA_BaseStruct
(
EDA_BaseStruct
*
parent
,
int
idType
)
/******************************************************************************/
/******************************************************************************/
{
{
InitVars
();
InitVars
();
m_StructType
=
idType
;
m_StructType
=
idType
;
m_Parent
=
parent
;
/* Chainage hierarchique sur struct racine */
m_Parent
=
parent
;
/* Chainage hierarchique sur struct racine */
}
}
/********************************************/
/********************************************/
EDA_BaseStruct
::
EDA_BaseStruct
(
int
idType
)
EDA_BaseStruct
::
EDA_BaseStruct
(
int
idType
)
/********************************************/
/********************************************/
{
{
InitVars
();
InitVars
();
m_StructType
=
idType
;
m_StructType
=
idType
;
}
}
/********************************************/
/********************************************/
void
EDA_BaseStruct
::
InitVars
(
void
)
void
EDA_BaseStruct
::
InitVars
(
void
)
/********************************************/
/********************************************/
{
{
m_StructType
=
TYPE_NOT_INIT
;
m_StructType
=
TYPE_NOT_INIT
;
Pnext
=
NULL
;
/* Linked list: Link (next struct) */
Pnext
=
NULL
;
/* Linked list: Link (next struct) */
Pback
=
NULL
;
/* Linked list: Link (previous struct) */
Pback
=
NULL
;
/* Linked list: Link (previous struct) */
m_Parent
=
NULL
;
/* Linked list: Link (parent struct) */
m_Parent
=
NULL
;
/* Linked list: Link (parent struct) */
m_Son
=
NULL
;
/* Linked list: Link (son struct) */
m_Son
=
NULL
;
/* Linked list: Link (son struct) */
m_Image
=
NULL
;
/* Link to an image copy for undelete or abort command */
m_Image
=
NULL
;
/* Link to an image copy for undelete or abort command */
m_Flags
=
0
;
/* flags for editions and other */
m_Flags
=
0
;
/* flags for editions and other */
m_TimeStamp
=
0
;
// Time stamp used for logical links
m_TimeStamp
=
0
;
// Time stamp used for logical links
m_Status
=
0
;
m_Status
=
0
;
m_Selected
=
0
;
/* Used by block commands, and selective editing */
m_Selected
=
0
;
/* Used by block commands, and selective editing */
}
}
/* Gestion de l'etat (status) de la structure (active, deleted..) */
/* Gestion de l'etat (status) de la structure (active, deleted..) */
int
EDA_BaseStruct
::
GetState
(
int
type
)
int
EDA_BaseStruct
::
GetState
(
int
type
)
{
{
return
(
m_Status
&
type
)
;
return
m_Status
&
type
;
}
}
void
EDA_BaseStruct
::
SetState
(
int
type
,
int
state
)
void
EDA_BaseStruct
::
SetState
(
int
type
,
int
state
)
{
{
if
(
state
)
m_Status
|=
type
;
/* state = ON ou OFF */
if
(
state
)
else
m_Status
&=
~
type
;
m_Status
|=
type
;
/* state = ON ou OFF */
else
m_Status
&=
~
type
;
}
}
/*********************************************************/
/*********************************************************/
void
EDA_BaseStruct
::
AddToChain
(
EDA_BaseStruct
*
laststruct
)
void
EDA_BaseStruct
::
AddToChain
(
EDA_BaseStruct
*
laststruct
)
/*********************************************************/
/*********************************************************/
/*
/*
addition d'une nouvelle struct a la liste chaine
, apres la structure laststruct
* addition d'une nouvelle struct a la liste chain�
, apres la structure laststruct
*/
*/
{
{
Pnext
=
laststruct
->
Pnext
;
Pnext
=
laststruct
->
Pnext
;
Pback
=
laststruct
;
Pback
=
laststruct
;
laststruct
->
Pnext
=
this
;
laststruct
->
Pnext
=
this
;
}
}
/**************************************************************************************/
/**************************************************************************************/
void
EDA_BaseStruct
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
const
wxPoint
&
offset
,
void
EDA_BaseStruct
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
const
wxPoint
&
offset
,
int
draw_mode
,
int
Color
)
int
draw_mode
,
int
Color
)
/**************************************************************************************/
/**************************************************************************************/
/* Virtual
/* Virtual
*/
*/
{
{
wxString
msg
,
name
;
wxString
msg
,
name
;
msg
.
Printf
(
wxT
(
"EDA_BaseStruct::Draw() error. Method for struct type %d used but not implemented ("
),
m_StructType
);
msg
.
Printf
(
wxT
(
msg
+=
ReturnClassName
()
+
wxT
(
")
\n
"
);
"EDA_BaseStruct::Draw() error. Method for struct type %d used but not implemented ("
),
printf
(
CONV_TO_UTF8
(
msg
));
m_StructType
);
msg
+=
ReturnClassName
()
+
wxT
(
")
\n
"
);
printf
(
CONV_TO_UTF8
(
msg
)
);
}
}
#if 0
#if 0
/**************************************************************/
/**************************************************************/
void EDA_BaseStruct::Place(
WinEDA_DrawFrame * frame, wxDC * DC
)
void EDA_BaseStruct::Place(
WinEDA_DrawFrame* frame, wxDC* DC
)
/**************************************************************/
/**************************************************************/
/* fonction virtuelle de placement: non utilisee en pcbnew (utilisee eeschema)
/* fonction virtuelle de placement: non utilisee en pcbnew (utilisee eeschema)
---- A mieux utiliser (TODO...)
*
---- A mieux utiliser (TODO...)
*/
*/
{
{
}
}
#endif
#endif
/*********************************************/
/*********************************************/
wxString
EDA_BaseStruct
::
ReturnClassName
(
void
)
wxString
EDA_BaseStruct
::
ReturnClassName
(
void
)
/*********************************************/
/*********************************************/
/* Used at run time for diags: return the class name of the item,
/* Used at run time for diags: return the class name of the item,
from its .m_StructType value.
*
from its .m_StructType value.
*/
*/
{
{
int
ii
=
m_StructType
;
int
ii
=
m_StructType
;
wxString
classname
;
wxString
classname
;
if
(
(
ii
<
0
)
||
(
ii
>
MAX_STRUCT_TYPE_ID
)
)
ii
=
MAX_STRUCT_TYPE_ID
;
if
(
(
ii
<
0
)
||
(
ii
>
MAX_STRUCT_TYPE_ID
)
)
classname
=
DrawStructureTypeName
[
ii
];
ii
=
MAX_STRUCT_TYPE_ID
;
classname
=
DrawStructureTypeName
[
ii
];
return
classname
;
return
classname
;
}
}
/**********************************************************************************************/
/**********************************************************************************************/
EDA_BaseLineStruct
::
EDA_BaseLineStruct
(
EDA_BaseStruct
*
StructFather
,
DrawStructureType
idtype
)
:
EDA_BaseLineStruct
::
EDA_BaseLineStruct
(
EDA_BaseStruct
*
StructFather
,
DrawStructureType
idtype
)
:
EDA_BaseStruct
(
StructFather
,
idtype
)
EDA_BaseStruct
(
StructFather
,
idtype
)
/**********************************************************************************************/
/**********************************************************************************************/
{
{
m_Layer
=
0
;
m_Layer
=
0
;
m_Width
=
0
;
// 0 = line, > 0 = tracks, bus ...
m_Width
=
0
;
// 0 = line, > 0 = tracks, bus ...
};
};
/*********************************************************/
/*********************************************************/
/* EDA_TextStruct (classe de base, non utilis
e
seule */
/* EDA_TextStruct (classe de base, non utilis
�
seule */
/*********************************************************/
/*********************************************************/
EDA_TextStruct
::
EDA_TextStruct
(
const
wxString
&
text
)
EDA_TextStruct
::
EDA_TextStruct
(
const
wxString
&
text
)
{
{
m_Layer
=
0
;
m_Layer
=
0
;
m_Size
.
x
=
m_Size
.
y
=
DEFAULT_SIZE_TEXT
;
/* XY size of font */
m_Size
.
x
=
m_Size
.
y
=
DEFAULT_SIZE_TEXT
;
/* XY size of font */
m_Orient
=
0
;
/* Orient in 0.1 degrees */
m_Orient
=
0
;
/* Orient in 0.1 degrees */
m_Attributs
=
0
;
m_Attributs
=
0
;
m_Miroir
=
0
;
// vue normale / miroir
m_Miroir
=
0
;
// vue normale / miroir
m_HJustify
=
GR_TEXT_HJUSTIFY_CENTER
;
m_HJustify
=
GR_TEXT_HJUSTIFY_CENTER
;
m_VJustify
=
GR_TEXT_VJUSTIFY_CENTER
;
/* Justifications Horiz et Vert du texte */
m_VJustify
=
GR_TEXT_VJUSTIFY_CENTER
;
/* Justifications Horiz et Vert du texte */
m_Width
=
0
;
/* epaisseur du trait */
m_Width
=
0
;
/* epaisseur du trait */
m_CharType
=
0
;
/* normal, bold, italic ... */
m_CharType
=
0
;
/* normal, bold, italic ... */
m_Text
=
text
;
m_Text
=
text
;
m_ZoomLevelDrawable
=
0
;
/* Niveau de zoom acceptable pour affichage normal */
m_ZoomLevelDrawable
=
0
;
/* Niveau de zoom acceptable pour affichage normal */
m_TextDrawings
=
NULL
;
/* Pointeur sur le dessin du caractere */
m_TextDrawings
=
NULL
;
/* Pointeur sur le dessin du caractere */
m_TextDrawingsSize
=
0
;
/* taille du tableau point
*/
m_TextDrawingsSize
=
0
;
/* taille du tableau point�
*/
}
}
EDA_TextStruct
::~
EDA_TextStruct
(
void
)
EDA_TextStruct
::~
EDA_TextStruct
(
void
)
{
{
if
(
m_TextDrawings
)
/* pointeur sur la liste des segments de dessin */
if
(
m_TextDrawings
)
/* pointeur sur la liste des segments de dessin */
{
{
free
(
m_TextDrawings
);
m_TextDrawings
=
NULL
;
free
(
m_TextDrawings
);
m_TextDrawings
=
NULL
;
}
}
m_TextDrawingsSize
=
0
;
/* nombre de sommets a dessiner */
m_TextDrawingsSize
=
0
;
/* nombre de sommets a dessiner */
}
}
/********************************/
/********************************/
int
EDA_TextStruct
::
Len_Size
(
void
)
int
EDA_TextStruct
::
Len_Size
(
void
)
/********************************/
/********************************/
// Return the text lenght in internal units
// Return the text lenght in internal units
{
{
int
nbchar
=
m_Text
.
Len
();
int
nbchar
=
m_Text
.
Len
();
int
len
;
int
len
;
if
(
nbchar
==
0
)
return
0
;
if
(
nbchar
==
0
)
return
0
;
len
=
((
10
*
m_Size
.
x
)
/
9
)
*
nbchar
;
len
=
(
(
10
*
m_Size
.
x
)
/
9
)
*
nbchar
;
return
len
;
return
len
;
}
}
/*************************************************/
/*************************************************/
int
EDA_TextStruct
::
Locate
(
const
wxPoint
&
posref
)
bool
EDA_TextStruct
::
HitTest
(
const
wxPoint
&
posref
)
/*************************************************/
/*************************************************/
/* locate function
/* locate function
return:
*
return:
1
if posref is inside the text area.
* true
if posref is inside the text area.
0
else.
* false
else.
*/
*/
{
{
int
dx
,
dy
;
int
dx
,
dy
;
int
spot_cX
,
spot_cY
;
int
spot_cX
,
spot_cY
;
dx
=
(
Pitch
()
*
GetLength
())
/
2
;
dx
=
(
Pitch
()
*
GetLength
()
)
/
2
;
dy
=
m_Size
.
y
/
2
;
dy
=
m_Size
.
y
/
2
;
/* Is the ref point inside the text area ? */
/* Is the ref point inside the text area ? */
spot_cX
=
posref
.
x
-
m_Pos
.
x
;
spot_cY
=
posref
.
y
-
m_Pos
.
y
;
spot_cX
=
posref
.
x
-
m_Pos
.
x
;
RotatePoint
(
&
spot_cX
,
&
spot_cY
,
-
m_Orient
);
spot_cY
=
posref
.
y
-
m_Pos
.
y
;
if
(
(
abs
(
spot_cX
)
<=
abs
(
dx
)
)
&&
(
abs
(
spot_cY
)
<=
abs
(
dy
)
)
)
return
1
;
return
0
;
RotatePoint
(
&
spot_cX
,
&
spot_cY
,
-
m_Orient
);
if
(
(
abs
(
spot_cX
)
<=
abs
(
dx
)
)
&&
(
abs
(
spot_cY
)
<=
abs
(
dy
)
)
)
return
true
;
return
false
;
}
}
/*******************************/
/*******************************/
int
EDA_TextStruct
::
Pitch
(
void
)
int
EDA_TextStruct
::
Pitch
(
void
)
/*******************************/
/*******************************/
/* retourne le pas entre 2 caracteres
/* retourne le pas entre 2 caracteres
*/
*/
{
{
return
((
10
*
m_Size
.
x
)
/
9
)
+
m_Width
;
return
(
(
10
*
m_Size
.
x
)
/
9
)
+
m_Width
;
}
}
/***************************************************************/
/***************************************************************/
void
EDA_TextStruct
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
void
EDA_TextStruct
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
const
wxPoint
&
offset
,
int
color
,
int
draw_mode
,
const
wxPoint
&
offset
,
int
color
,
int
draw_mode
,
int
display_mode
,
int
anchor_color
)
int
display_mode
,
int
anchor_color
)
/***************************************************************/
/***************************************************************/
/*
/*
Trace de 1 texte type EDA_TextStruct.
*
Trace de 1 texte type EDA_TextStruct.
offset = Offset de trace (usuellement (0,0)
*
offset = Offset de trace (usuellement (0,0)
color = couleur du texte
*
color = couleur du texte
draw_mode = GR_OR, GR_XOR.., -1 si mode courant.
*
draw_mode = GR_OR, GR_XOR.., -1 si mode courant.
display_mose = FILAIRE, FILLED ou SKETCH
*
display_mose = FILAIRE, FILLED ou SKETCH
anchor_color = couleur de l'ancre ( -1 si pas d'ancre ).
*
anchor_color = couleur de l'ancre ( -1 si pas d'ancre ).
*/
*/
{
{
int
zoom
;
int
zoom
;
int
coord
[
104
];
int
coord
[
104
];
int
ii
,
jj
,
kk
,
ll
,
nbpoints
;
int
ii
,
jj
,
kk
,
ll
,
nbpoints
;
int
width
;
int
width
;
if
(
m_TextDrawings
==
NULL
)
/* pointeur sur la liste des segments de dessin */
if
(
m_TextDrawings
==
NULL
)
/* pointeur sur la liste des segments de dessin */
CreateDrawData
();
CreateDrawData
();
if
(
m_TextDrawings
==
NULL
)
return
;
if
(
m_TextDrawings
==
NULL
)
return
;
zoom
=
panel
->
GetZoom
();
width
=
m_Width
/
zoom
;
zoom
=
panel
->
GetZoom
();
if
(
display_mode
==
FILAIRE
)
width
=
0
;
width
=
m_Width
/
zoom
;
/* choix de la couleur du texte : */
if
(
display_mode
==
FILAIRE
)
if
(
draw_mode
!=
-
1
)
GRSetDrawMode
(
DC
,
draw_mode
);
width
=
0
;
/* choix de la couleur du texte : */
/* trace du texte */
if
(
draw_mode
!=
-
1
)
if
(
zoom
>
m_ZoomLevelDrawable
)
GRSetDrawMode
(
DC
,
draw_mode
);
{
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
/* trace du texte */
m_TextDrawings
[
1
]
+
offset
.
x
+
m_Pos
.
x
,
if
(
zoom
>
m_ZoomLevelDrawable
)
m_TextDrawings
[
2
]
+
offset
.
y
+
m_Pos
.
y
,
{
m_TextDrawings
[
3
]
+
offset
.
x
+
m_Pos
.
x
,
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
m_TextDrawings
[
4
]
+
offset
.
y
+
m_Pos
.
y
,
m_TextDrawings
[
1
]
+
offset
.
x
+
m_Pos
.
x
,
width
,
color
);
m_TextDrawings
[
2
]
+
offset
.
y
+
m_Pos
.
y
,
}
m_TextDrawings
[
3
]
+
offset
.
x
+
m_Pos
.
x
,
m_TextDrawings
[
4
]
+
offset
.
y
+
m_Pos
.
y
,
else
width
,
color
);
{
}
/* trace ancre du texte ? */
else
if
(
anchor_color
!=
-
1
)
{
{
/* trace ancre du texte ? */
int
anchor_size
=
2
*
zoom
;
if
(
anchor_color
!=
-
1
)
anchor_color
&=
MASKCOLOR
;
{
/* calcul de la position du texte */
int
anchor_size
=
2
*
zoom
;
int
cX
=
m_Pos
.
x
-
offset
.
x
;
anchor_color
&=
MASKCOLOR
;
int
cY
=
m_Pos
.
y
-
offset
.
y
;
/* calcul de la position du texte */
/* trace ancre du texte */
int
cX
=
m_Pos
.
x
-
offset
.
x
;
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
cX
-
anchor_size
,
cY
,
int
cY
=
m_Pos
.
y
-
offset
.
y
;
cX
+
anchor_size
,
cY
,
0
,
anchor_color
);
/* trace ancre du texte */
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
cX
,
cY
-
anchor_size
,
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
cX
-
anchor_size
,
cY
,
cX
,
cY
+
anchor_size
,
0
,
anchor_color
);
cX
+
anchor_size
,
cY
,
0
,
anchor_color
);
}
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
cX
,
cY
-
anchor_size
,
jj
=
5
;
ii
=
jj
+
1
;
cX
,
cY
+
anchor_size
,
0
,
anchor_color
);
while
(
ii
<
m_TextDrawingsSize
)
}
{
jj
=
5
;
ii
=
jj
+
1
;
nbpoints
=
m_TextDrawings
[
jj
];
while
(
ii
<
m_TextDrawingsSize
)
if
(
nbpoints
>
50
)
nbpoints
=
50
;
{
for
(
kk
=
0
,
ll
=
0
;
(
kk
<
nbpoints
)
&&
(
ii
<
m_TextDrawingsSize
)
;
kk
++
)
nbpoints
=
m_TextDrawings
[
jj
];
{
if
(
nbpoints
>
50
)
coord
[
ll
]
=
m_TextDrawings
[
ii
]
+
offset
.
x
+
m_Pos
.
x
;
nbpoints
=
50
;
ll
++
;
ii
++
;
for
(
kk
=
0
,
ll
=
0
;
(
kk
<
nbpoints
)
&&
(
ii
<
m_TextDrawingsSize
);
kk
++
)
coord
[
ll
]
=
m_TextDrawings
[
ii
]
+
offset
.
y
+
m_Pos
.
y
;
{
ll
++
;
ii
++
;
coord
[
ll
]
=
m_TextDrawings
[
ii
]
+
offset
.
x
+
m_Pos
.
x
;
}
ll
++
;
ii
++
;
jj
=
ii
;
ii
++
;
coord
[
ll
]
=
m_TextDrawings
[
ii
]
+
offset
.
y
+
m_Pos
.
y
;
ll
++
;
ii
++
;
if
(
width
>
2
)
}
{
for
(
kk
=
0
,
ll
=
0
;
kk
<
(
nbpoints
-
1
);
kk
++
,
ll
+=
2
)
jj
=
ii
;
ii
++
;
{
if
(
display_mode
==
SKETCH
)
if
(
width
>
2
)
GRCSegm
(
&
panel
->
m_ClipBox
,
DC
,
{
coord
[
ll
],
coord
[
ll
+
1
],
for
(
kk
=
0
,
ll
=
0
;
kk
<
(
nbpoints
-
1
);
kk
++
,
ll
+=
2
)
coord
[
ll
+
2
],
coord
[
ll
+
3
],
{
m_Width
,
color
)
;
if
(
display_mode
==
SKETCH
)
GRCSegm
(
&
panel
->
m_ClipBox
,
DC
,
else
GRFillCSegm
(
&
panel
->
m_ClipBox
,
DC
,
coord
[
ll
],
coord
[
ll
+
1
],
coord
[
ll
],
coord
[
ll
+
1
],
coord
[
ll
+
2
],
coord
[
ll
+
3
],
coord
[
ll
+
2
],
coord
[
ll
+
3
],
m_Width
,
color
);
m_Width
,
color
)
;
}
else
}
GRFillCSegm
(
&
panel
->
m_ClipBox
,
DC
,
else
coord
[
ll
],
coord
[
ll
+
1
],
GRPoly
(
&
panel
->
m_ClipBox
,
DC
,
nbpoints
,
coord
,
0
,
0
,
color
,
color
);
coord
[
ll
+
2
],
coord
[
ll
+
3
],
m_Width
,
color
);
}
}
}
}
else
GRPoly
(
&
panel
->
m_ClipBox
,
DC
,
nbpoints
,
coord
,
0
,
0
,
color
,
color
);
}
}
}
}
/****************************************/
/****************************************/
void
EDA_TextStruct
::
CreateDrawData
(
void
)
void
EDA_TextStruct
::
CreateDrawData
(
void
)
/****************************************/
/****************************************/
/* Cree le tableau de donnes ncessaire au trace d'un texte (pcb, module..)
Met a jour:
/* Cree le tableau de donn�s n�essaire au trace d'un texte (pcb, module..)
m_ZoomLevelDrawable Niveau de zoom acceptable pour affichage normal
* Met a jour:
m_TextDrawings Pointeur sur le tableau de donnes
* m_ZoomLevelDrawable Niveau de zoom acceptable pour affichage normal
m_TextDrawingsSize taille (en int) du tableau
* m_TextDrawings Pointeur sur le tableau de donn�s
Codage dans le tableau:
* m_TextDrawingsSize taille (en int) du tableau
Suite des coord des sommets des polygones a tracer prcd du nombre de sommets
* Codage dans le tableau:
nn xx1 yy1 xx2 yy2 .. xxn yyn mm xx1 yy1 xx2 yy2 .. xxm yym
* Suite des coord des sommets des polygones a tracer pr���du nombre de sommets
les 2 premiers sommets sont le segment symbolisant le texte pour les
* nn xx1 yy1 xx2 yy2 .. xxn yyn mm xx1 yy1 xx2 yy2 .. xxm yym
affichages a trop petite echelle
* les 2 premiers sommets sont le segment symbolisant le texte pour les
*/
* affichages a trop petite echelle
*/
{
{
int
ii
,
jj
,
kk
,
nbchar
,
nbpoints
,
AsciiCode
,
endcar
;
int
ii
,
jj
,
kk
,
nbchar
,
nbpoints
,
AsciiCode
,
endcar
;
int
k1
,
k2
,
x0
,
y0
;
int
k1
,
k2
,
x0
,
y0
;
int
size_h
,
size_v
,
espacement
;
int
size_h
,
size_v
,
espacement
;
char
f_cod
,
plume
=
'U'
;
char
f_cod
,
plume
=
'U'
;
const
wxChar
*
ptr
;
const
wxChar
*
ptr
;
const
SH_CODE
*
ptcar
;
const
SH_CODE
*
ptcar
;
int
ux0
,
uy0
,
dx
,
dy
;
// Coord de trace des segments de texte & variables de calcul */
int
ux0
,
uy0
,
dx
,
dy
;
// Coord de trace des segments de texte & variables de calcul */
int
cX
,
cY
;
// Centre du texte
int
cX
,
cY
;
// Centre du texte
int
ox
,
oy
;
// coord de trace du caractere courant
int
ox
,
oy
;
// coord de trace du caractere courant
int
*
coord
;
// liste des coord des segments a tracer
int
*
coord
;
// liste des coord des segments a tracer
int
coord_count_max
=
1000
;
int
coord_count_max
=
1000
;
if
(
m_TextDrawings
)
/* pointeur sur la liste des segments de dessin */
if
(
m_TextDrawings
)
/* pointeur sur la liste des segments de dessin */
{
{
free
(
m_TextDrawings
);
m_TextDrawings
=
0
;
free
(
m_TextDrawings
);
m_TextDrawings
=
0
;
}
}
m_TextDrawingsSize
=
0
;
/* nombre de segments a dessiner */
m_TextDrawingsSize
=
0
;
/* nombre de segments a dessiner */
nbchar
=
m_Text
.
Length
();
nbchar
=
m_Text
.
Length
();
if
(
nbchar
==
0
)
return
;
if
(
nbchar
==
0
)
return
;
size_h
=
m_Size
.
x
;
size_v
=
m_Size
.
y
;
size_h
=
m_Size
.
x
;
espacement
=
Pitch
();
size_v
=
m_Size
.
y
;
if
(
m_Miroir
==
0
)
espacement
=
Pitch
();
{
if
(
m_Miroir
==
0
)
size_h
=
-
size_h
;
espacement
=
-
espacement
;
{
}
size_h
=
-
size_h
;
espacement
=
-
espacement
;
}
kk
=
0
;
ptr
=
m_Text
.
GetData
()
;
/* ptr pointe 1er caractere du texte */
kk
=
0
;
ptr
=
m_Text
.
GetData
();
/* ptr pointe 1er caractere du texte */
/* calcul de la position du debut des textes: ox et oy */
ox
=
cX
=
0
;
oy
=
cY
=
0
;
/* calcul de la position du debut des textes: ox et oy */
ox
=
cX
=
0
;
oy
=
cY
=
0
;
/* Calcul du cadrage du texte */
dx
=
(
espacement
*
nbchar
)
/
2
;
/* Calcul du cadrage du texte */
dy
=
size_v
/
2
;
/* Decalage du debut du texte / centre */
dx
=
(
espacement
*
nbchar
)
/
2
;
dy
=
size_v
/
2
;
/* Decalage du debut du texte / centre */
ux0
=
uy0
=
0
;
/* Decalage du centre du texte / ccord de ref */
ux0
=
uy0
=
0
;
/* Decalage du centre du texte / ccord de ref */
if
(
(
m_Orient
==
0
)
||
(
m_Orient
==
1800
)
)
/* Texte Horizontal */
{
if
(
(
m_Orient
==
0
)
||
(
m_Orient
==
1800
)
)
/* Texte Horizontal */
switch
(
m_HJustify
)
{
{
switch
(
m_HJustify
)
case
GR_TEXT_HJUSTIFY_CENTER
:
{
break
;
case
GR_TEXT_HJUSTIFY_CENTER
:
break
;
case
GR_TEXT_HJUSTIFY_RIGHT
:
ux0
=
-
dx
;
case
GR_TEXT_HJUSTIFY_RIGHT
:
break
;
ux0
=
-
dx
;
break
;
case
GR_TEXT_HJUSTIFY_LEFT
:
ux0
=
dx
;
case
GR_TEXT_HJUSTIFY_LEFT
:
break
;
ux0
=
dx
;
}
break
;
}
switch
(
m_VJustify
)
{
switch
(
m_VJustify
)
case
GR_TEXT_VJUSTIFY_CENTER
:
{
break
;
case
GR_TEXT_VJUSTIFY_CENTER
:
break
;
case
GR_TEXT_VJUSTIFY_TOP
:
uy0
=
dy
;
case
GR_TEXT_VJUSTIFY_TOP
:
break
;
uy0
=
dy
;
break
;
case
GR_TEXT_VJUSTIFY_BOTTOM
:
uy0
=
-
dy
;
case
GR_TEXT_VJUSTIFY_BOTTOM
:
break
;
uy0
=
-
dy
;
}
break
;
}
}
}
else
/* Texte Vertical */
else
/* Texte Vertical */
{
{
switch
(
m_HJustify
)
switch
(
m_HJustify
)
{
{
case
GR_TEXT_HJUSTIFY_CENTER
:
case
GR_TEXT_HJUSTIFY_CENTER
:
break
;
break
;
case
GR_TEXT_HJUSTIFY_RIGHT
:
case
GR_TEXT_HJUSTIFY_RIGHT
:
ux0
=
-
dy
;
ux0
=
-
dy
;
break
;
break
;
case
GR_TEXT_HJUSTIFY_LEFT
:
case
GR_TEXT_HJUSTIFY_LEFT
:
ux0
=
dy
;
ux0
=
dy
;
break
;
break
;
}
}
switch
(
m_VJustify
)
switch
(
m_VJustify
)
{
{
case
GR_TEXT_VJUSTIFY_CENTER
:
case
GR_TEXT_VJUSTIFY_CENTER
:
break
;
break
;
case
GR_TEXT_VJUSTIFY_TOP
:
case
GR_TEXT_VJUSTIFY_TOP
:
uy0
=
dx
;
uy0
=
dx
;
break
;
break
;
case
GR_TEXT_VJUSTIFY_BOTTOM
:
case
GR_TEXT_VJUSTIFY_BOTTOM
:
uy0
=
-
dx
;
uy0
=
-
dx
;
break
;
break
;
}
}
}
}
cX
+=
ux0
;
cY
+=
uy0
;
cX
+=
ux0
;
cY
+=
uy0
;
ox
=
cX
-
dx
;
;
oy
=
cY
+
dy
;
ox
=
cX
-
dx
;;
oy
=
cY
+
dy
;
/* lorsque les chars sont trop petits pour etre dessines,
/* lorsque les chars sont trop petits pour etre dessines,
le texte est symbolise par une barre */
* le texte est symbolise par une barre */
m_ZoomLevelDrawable
=
m_Size
.
x
/
3
;
m_ZoomLevelDrawable
=
m_Size
.
x
/
3
;
dx
=
(
espacement
*
nbchar
)
/
2
;
dx
=
(
espacement
*
nbchar
)
/
2
;
dy
=
size_v
/
2
;
/* Decalage du debut du texte / centre */
dy
=
size_v
/
2
;
/* Decalage du debut du texte / centre */
ux0
=
cX
-
dx
;
uy0
=
cY
;
ux0
=
cX
-
dx
;
uy0
=
cY
;
dx
+=
cX
;
dy
=
cY
;
dx
+=
cX
;
dy
=
cY
;
RotatePoint
(
&
ux0
,
&
uy0
,
cX
,
cY
,
m_Orient
);
RotatePoint
(
&
ux0
,
&
uy0
,
cX
,
cY
,
m_Orient
);
RotatePoint
(
&
dx
,
&
dy
,
cX
,
cY
,
m_Orient
);
RotatePoint
(
&
dx
,
&
dy
,
cX
,
cY
,
m_Orient
);
coord
=
(
int
*
)
MyMalloc
(
(
coord_count_max
+
2
)
*
sizeof
(
int
));
coord
=
(
int
*
)
MyMalloc
(
(
coord_count_max
+
2
)
*
sizeof
(
int
)
);
coord
[
0
]
=
2
;
coord
[
0
]
=
2
;
coord
[
1
]
=
ux0
;
coord
[
2
]
=
uy0
;
coord
[
1
]
=
ux0
;
coord
[
2
]
=
uy0
;
coord
[
3
]
=
dx
;
coord
[
4
]
=
dy
;
coord
[
3
]
=
dx
;
coord
[
4
]
=
dy
;
jj
=
5
;
ii
=
jj
+
1
;
nbpoints
=
0
;
jj
=
5
;
ii
=
jj
+
1
;
nbpoints
=
0
;
while
(
kk
++
<
nbchar
)
while
(
kk
++
<
nbchar
)
{
{
x0
=
0
;
y0
=
0
;
x0
=
0
;
y0
=
0
;
AsciiCode
=
(
*
ptr
)
&
255
;
AsciiCode
=
(
*
ptr
)
&
255
;
ptcar
=
graphic_fonte_shape
[
AsciiCode
]
;
/* ptcar pointe la description
ptcar
=
graphic_fonte_shape
[
AsciiCode
];
/* ptcar pointe la description
du caractere a dessiner */
* du caractere a dessiner */
for
(
endcar
=
FALSE
;
!
endcar
;
ptcar
++
)
for
(
endcar
=
FALSE
;
!
endcar
;
ptcar
++
)
{
{
f_cod
=
*
ptcar
;
/* get code n de la forme selectionnee */
f_cod
=
*
ptcar
;
switch
(
f_cod
)
{
/* get code n de la forme selectionnee */
case
'X'
:
switch
(
f_cod
)
endcar
=
TRUE
;
/* fin du caractere */
{
break
;
case
'X'
:
endcar
=
TRUE
;
/* fin du caractere */
case
'U'
:
break
;
if
(
nbpoints
&&
(
plume
==
'D'
)
)
{
case
'U'
:
if
(
jj
>=
coord_count_max
)
if
(
nbpoints
&&
(
plume
==
'D'
)
)
{
{
coord_count_max
*=
2
;
if
(
jj
>=
coord_count_max
)
coord
=
(
int
*
)
realloc
(
coord
,
coord_count_max
*
sizeof
(
int
)
);
{
}
coord_count_max
*=
2
;
coord
[
jj
]
=
nbpoints
;
coord
=
(
int
*
)
realloc
(
coord
,
coord_count_max
*
sizeof
(
int
)
);
jj
=
ii
;
ii
++
;
}
}
coord
[
jj
]
=
nbpoints
;
plume
=
f_cod
;
nbpoints
=
0
;
jj
=
ii
;
ii
++
;
break
;
}
plume
=
f_cod
;
nbpoints
=
0
;
case
'D'
:
break
;
plume
=
f_cod
;
nbpoints
=
1
;
/* 1 point va suivre (origine du trac) */
case
'D'
:
break
;
plume
=
f_cod
;
nbpoints
=
1
;
/* 1 point va suivre (origine du trac� */
default
:
break
;
{
k1
=
f_cod
;
/* trace sur axe V */
default
:
k1
=
-
((
k1
*
size_v
)
/
9
)
;
{
ptcar
++
;
k1
=
f_cod
;
/* trace sur axe V */
f_cod
=
*
ptcar
;
k1
=
-
(
(
k1
*
size_v
)
/
9
);
k2
=
f_cod
;
/* trace sur axe H */
ptcar
++
;
k2
=
(
k2
*
size_h
)
/
9
;
f_cod
=
*
ptcar
;
dx
=
k2
+
ox
;
dy
=
k1
+
oy
;
k2
=
f_cod
;
/* trace sur axe H */
RotatePoint
(
&
dx
,
&
dy
,
cX
,
cY
,
m_Orient
);
k2
=
(
k2
*
size_h
)
/
9
;
if
(
ii
>=
coord_count_max
)
dx
=
k2
+
ox
;
dy
=
k1
+
oy
;
{
RotatePoint
(
&
dx
,
&
dy
,
cX
,
cY
,
m_Orient
);
coord_count_max
*=
2
;
if
(
ii
>=
coord_count_max
)
coord
=
(
int
*
)
realloc
(
coord
,
coord_count_max
*
sizeof
(
int
)
);
{
}
coord_count_max
*=
2
;
coord
[
ii
]
=
dx
;
ii
++
;
coord
[
ii
]
=
dy
;
ii
++
;
coord
=
(
int
*
)
realloc
(
coord
,
coord_count_max
*
sizeof
(
int
)
);
nbpoints
++
;
}
break
;
coord
[
ii
]
=
dx
;
ii
++
;
coord
[
ii
]
=
dy
;
ii
++
;
}
nbpoints
++
;
}
/* end switch */
break
;
}
/* end boucle for = end trace de 1 caractere */
}
}
ptr
++
;
ox
+=
espacement
;
}
/* end trace du texte */
/* end switch */
}
m_TextDrawings
=
(
int
*
)
realloc
(
coord
,
ii
*
sizeof
(
int
)
);
m_TextDrawingsSize
=
ii
;
//taille (en int) du tableau
/* end boucle for = end trace de 1 caractere */
ptr
++
;
ox
+=
espacement
;
}
/* end trace du texte */
m_TextDrawings
=
(
int
*
)
realloc
(
coord
,
ii
*
sizeof
(
int
)
);
m_TextDrawingsSize
=
ii
;
//taille (en int) du tableau
}
}
/******************************/
/******************************/
void
EDA_Rect
::
Normalize
(
void
)
void
EDA_Rect
::
Normalize
(
void
)
/******************************/
/******************************/
// Ensure the height ant width are >= 0
// Ensure the height ant width are >= 0
{
{
if
(
m_Size
.
y
<
0
)
if
(
m_Size
.
y
<
0
)
{
{
m_Size
.
y
=
-
m_Size
.
y
;
m_Size
.
y
=
-
m_Size
.
y
;
m_Pos
.
y
-=
m_Size
.
y
;
m_Pos
.
y
-=
m_Size
.
y
;
}
}
if
(
m_Size
.
x
<
0
)
if
(
m_Size
.
x
<
0
)
{
{
m_Size
.
x
=
-
m_Size
.
x
;
m_Size
.
x
=
-
m_Size
.
x
;
m_Pos
.
x
-=
m_Size
.
x
;
m_Pos
.
x
-=
m_Size
.
x
;
}
}
}
}
/*******************************************/
/*******************************************/
bool
EDA_Rect
::
Inside
(
const
wxPoint
&
point
)
bool
EDA_Rect
::
Inside
(
const
wxPoint
&
point
)
/*******************************************/
/*******************************************/
/* Return TRUE if point is in Rect
/* Return TRUE if point is in Rect
Accept rect size < 0
*
Accept rect size < 0
*/
*/
{
{
int
rel_posx
=
point
.
x
-
m_Pos
.
x
;
int
rel_posx
=
point
.
x
-
m_Pos
.
x
;
int
rel_posy
=
point
.
y
-
m_Pos
.
y
;
int
rel_posy
=
point
.
y
-
m_Pos
.
y
;
wxSize
size
=
m_Size
;
wxSize
size
=
m_Size
;
if
(
size
.
x
<
0
)
if
(
size
.
x
<
0
)
{
{
size
.
x
=
-
size
.
x
;
rel_posx
+=
size
.
x
;
size
.
x
=
-
size
.
x
;
rel_posx
+=
size
.
x
;
}
}
if
(
size
.
y
<
0
)
if
(
size
.
y
<
0
)
{
{
size
.
y
=
-
size
.
y
;
rel_posy
+=
size
.
y
;
size
.
y
=
-
size
.
y
;
rel_posy
+=
size
.
y
;
}
}
return
(
(
rel_posx
>=
0
)
&&
(
rel_posy
>=
0
)
return
(
rel_posx
>=
0
)
&&
(
rel_posy
>=
0
)
&&
(
rel_posy
<=
size
.
y
)
&&
(
rel_posy
<=
size
.
y
)
&&
(
rel_posx
<=
size
.
x
)
&&
(
rel_posx
<=
size
.
x
)
)
;
;
}
}
/**************************************************/
/**************************************************/
EDA_Rect
&
EDA_Rect
::
Inflate
(
wxCoord
dx
,
wxCoord
dy
)
EDA_Rect
&
EDA_Rect
::
Inflate
(
wxCoord
dx
,
wxCoord
dy
)
/**************************************************/
/**************************************************/
{
{
if
(
-
2
*
dx
>
m_Size
.
x
)
if
(
-
2
*
dx
>
m_Size
.
x
)
{
{
// Don't allow deflate to eat more width than we have,
// Don't allow deflate to eat more width than we have,
// a well-defined rectangle cannot have negative width.
// a well-defined rectangle cannot have negative width.
m_Pos
.
x
+=
m_Size
.
x
/
2
;
m_Pos
.
x
+=
m_Size
.
x
/
2
;
m_Size
.
x
=
0
;
m_Size
.
x
=
0
;
}
}
else
else
{
{
// The inflate is valid.
// The inflate is valid.
m_Pos
.
x
-=
dx
;
m_Pos
.
x
-=
dx
;
m_Size
.
x
+=
2
*
dx
;
m_Size
.
x
+=
2
*
dx
;
}
}
if
(
-
2
*
dy
>
m_Size
.
y
)
if
(
-
2
*
dy
>
m_Size
.
y
)
{
{
// Don't allow deflate to eat more height than we have,
// Don't allow deflate to eat more height than we have,
// a well-defined rectangle cannot have negative height.
// a well-defined rectangle cannot have negative height.
m_Pos
.
y
+=
m_Size
.
y
/
2
;
m_Pos
.
y
+=
m_Size
.
y
/
2
;
m_Size
.
y
=
0
;
m_Size
.
y
=
0
;
}
}
else
else
{
{
// The inflate is valid.
// The inflate is valid.
m_Pos
.
y
-=
dy
;
m_Pos
.
y
-=
dy
;
m_Size
.
y
+=
2
*
dy
;
m_Size
.
y
+=
2
*
dy
;
}
}
return
*
this
;
return
*
this
;
}
}
/**************************/
/**************************/
/* class DrawPickedStruct */
/* class DrawPickedStruct */
/**************************/
/**************************/
/* This class has only one useful member: .m_PickedStruct, used as a link.
/* This class has only one useful member: .m_PickedStruct, used as a link.
It does not describe really an item.
*
It does not describe really an item.
It is used to create a linked list of selected items (in block selection).
*
It is used to create a linked list of selected items (in block selection).
Each DrawPickedStruct item has is member: .m_PickedStruct pointing the
*
Each DrawPickedStruct item has is member: .m_PickedStruct pointing the
real selected item
*
real selected item
*/
*/
/*******************************************************************/
/*******************************************************************/
DrawPickedStruct
::
DrawPickedStruct
(
EDA_BaseStruct
*
pickedstruct
)
:
DrawPickedStruct
::
DrawPickedStruct
(
EDA_BaseStruct
*
pickedstruct
)
:
EDA_BaseStruct
(
DRAW_PICK_ITEM_STRUCT_TYPE
)
EDA_BaseStruct
(
DRAW_PICK_ITEM_STRUCT_TYPE
)
/*******************************************************************/
/*******************************************************************/
{
{
m_PickedStruct
=
pickedstruct
;
m_PickedStruct
=
pickedstruct
;
}
}
DrawPickedStruct
::~
DrawPickedStruct
(
void
)
DrawPickedStruct
::~
DrawPickedStruct
(
void
)
{
{
}
}
/*********************************************/
/*********************************************/
void
DrawPickedStruct
::
DeleteWrapperList
(
void
)
void
DrawPickedStruct
::
DeleteWrapperList
(
void
)
/*********************************************/
/*********************************************/
/* Delete this item all the items of the linked list
/* Delete this item all the items of the linked list
Free the wrapper, but DOES NOT delete the picked items linked by .m_PickedStruct
*
Free the wrapper, but DOES NOT delete the picked items linked by .m_PickedStruct
*/
*/
{
{
DrawPickedStruct
*
wrapp_struct
,
*
next_struct
;
DrawPickedStruct
*
wrapp_struct
,
*
next_struct
;
for
(
wrapp_struct
=
Next
();
wrapp_struct
!=
NULL
;
wrapp_struct
=
next_struct
)
for
(
wrapp_struct
=
Next
();
wrapp_struct
!=
NULL
;
wrapp_struct
=
next_struct
)
{
{
next_struct
=
wrapp_struct
->
Next
();
next_struct
=
wrapp_struct
->
Next
();
delete
wrapp_struct
;
delete
wrapp_struct
;
}
}
}
}
common/trigo.cpp
View file @
2e4c17a8
/************************/
/************************/
/* Routines de rotation */
/* Routines de rotation */
/************************/
/************************/
/* Fichier TRIGO.CPP */
/* Fichier TRIGO.CPP */
#include "fctsys.h"
#include "fctsys.h"
#define global extern
#define global extern
...
@@ -10,179 +10,210 @@
...
@@ -10,179 +10,210 @@
/***********************************/
/***********************************/
int
ArcTangente
(
int
dy
,
int
dx
)
int
ArcTangente
(
int
dy
,
int
dx
)
/***********************************/
/***********************************/
/* Retourne l'arc tangente en 0.1 degres du vecteur de coord dx, dy
/* Retourne l'arc tangente en 0.1 degres du vecteur de coord dx, dy
entre -1800 et 1800
*
entre -1800 et 1800
Analogue a atan2 ( mais plus rapide pour les calculs si
*
Analogue a atan2 ( mais plus rapide pour les calculs si
l'angle est souvent 0, -1800, ou +- 900
*
l'angle est souvent 0, -1800, ou +- 900
*/
*/
{
{
double
fangle
;
double
fangle
;
if
(
dy
==
0
)
if
(
dy
==
0
)
{
{
if
(
dx
>=
0
)
return
(
0
);
if
(
dx
>=
0
)
else
return
(
-
1800
);
return
0
;
}
else
return
-
1800
;
if
(
dx
==
0
)
}
{
if
(
dy
>=
0
)
return
(
900
);
if
(
dx
==
0
)
else
return
(
-
900
);
{
}
if
(
dy
>=
0
)
return
900
;
if
(
dx
==
dy
)
else
{
return
-
900
;
if
(
dx
>=
0
)
return
(
450
);
}
else
return
(
-
1800
+
450
);
}
if
(
dx
==
dy
)
{
if
(
dx
==
-
dy
)
if
(
dx
>=
0
)
{
return
450
;
if
(
dx
>=
0
)
return
(
-
450
);
else
else
return
(
1800
-
450
);
return
-
1800
+
450
;
}
}
fangle
=
atan2
(
(
double
)
dy
,
(
double
)
dx
)
/
M_PI
*
1800
;
if
(
dx
==
-
dy
)
return
(
(
int
)
round
(
fangle
)
);
{
if
(
dx
>=
0
)
return
-
450
;
else
return
1800
-
450
;
}
fangle
=
atan2
(
(
double
)
dy
,
(
double
)
dx
)
/
M_PI
*
1800
;
return
(
int
)
round
(
fangle
);
}
}
/*********************************************/
/*********************************************/
void
RotatePoint
(
int
*
pX
,
int
*
pY
,
int
angle
)
void
RotatePoint
(
int
*
pX
,
int
*
pY
,
int
angle
)
/*********************************************/
/*********************************************/
/*
/*
Fonction surchargee!
*
Fonction surchargee!
calcule les nouvelles coord du point de coord pX, pY,
*
calcule les nouvelles coord du point de coord pX, pY,
pour une rotation de centre 0, 0, et d'angle angle ( en 1/10 degre)
*
pour une rotation de centre 0, 0, et d'angle angle ( en 1/10 degre)
*/
*/
{
{
float
fpx
,
fpy
;
float
fpx
,
fpy
;
int
tmp
;
int
tmp
;
while
(
angle
<
0
)
angle
+=
3600
;
while
(
angle
<
0
)
while
(
angle
>=
3600
)
angle
-=
3600
;
angle
+=
3600
;
if
(
angle
==
0
)
return
;
while
(
angle
>=
3600
)
angle
-=
3600
;
/* Calcul des coord :
coord: xrot = y*sin + x*cos
if
(
angle
==
0
)
yrot = y*cos - x*sin
return
;
*/
if
(
angle
==
900
)
/* sin = 1, cos = 0 */
/* Calcul des coord :
{
* coord: xrot = y*sin + x*cos
tmp
=
*
pX
;
* yrot = y*cos - x*sin
*
pX
=
*
pY
;
*/
*
pY
=
-
tmp
;
if
(
angle
==
900
)
/* sin = 1, cos = 0 */
}
{
tmp
=
*
pX
;
else
if
(
angle
==
1800
)
/* sin = 0, cos = -1 */
*
pX
=
*
pY
;
{
*
pY
=
-
tmp
;
*
pX
=
-
*
pX
;
}
*
pY
=
-
*
pY
;
else
if
(
angle
==
1800
)
/* sin = 0, cos = -1 */
}
{
*
pX
=
-*
pX
;
else
if
(
angle
==
2700
)
/* sin = -1, cos = 0 */
*
pY
=
-*
pY
;
{
}
tmp
=
*
pX
;
else
if
(
angle
==
2700
)
/* sin = -1, cos = 0 */
*
pX
=
-
*
pY
;
{
*
pY
=
tmp
;
tmp
=
*
pX
;
}
*
pX
=
-*
pY
;
*
pY
=
tmp
;
else
}
{
else
fpx
=
(
*
pY
*
fsinus
[
angle
])
+
(
*
pX
*
fcosinus
[
angle
]);
{
fpy
=
(
*
pY
*
fcosinus
[
angle
])
-
(
*
pX
*
fsinus
[
angle
]);
fpx
=
(
*
pY
*
fsinus
[
angle
])
+
(
*
pX
*
fcosinus
[
angle
]);
*
pX
=
(
int
)
round
(
fpx
);
*
pY
=
(
int
)
round
(
fpy
);
fpy
=
(
*
pY
*
fcosinus
[
angle
])
-
(
*
pX
*
fsinus
[
angle
]);
}
*
pX
=
(
int
)
round
(
fpx
);
*
pY
=
(
int
)
round
(
fpy
);
}
}
}
/************************************************************/
/************************************************************/
void
RotatePoint
(
int
*
pX
,
int
*
pY
,
int
cx
,
int
cy
,
int
angle
)
void
RotatePoint
(
int
*
pX
,
int
*
pY
,
int
cx
,
int
cy
,
int
angle
)
/*************************************************************/
/*************************************************************/
/*
/*
Fonction surchargee!
*
Fonction surchargee!
calcule les nouvelles coord du point de coord pX, pY,
*
calcule les nouvelles coord du point de coord pX, pY,
pour une rotation de centre cx, cy, et d'angle angle ( en 1/10 degre)
*
pour une rotation de centre cx, cy, et d'angle angle ( en 1/10 degre)
*/
*/
{
{
int
ox
,
oy
;
int
ox
,
oy
;
ox
=
*
pX
-
cx
;
oy
=
*
pY
-
cy
;
ox
=
*
pX
-
cx
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
oy
=
*
pY
-
cy
;
*
pX
=
ox
+
cx
;
*
pY
=
oy
+
cy
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
*
pX
=
ox
+
cx
;
*
pY
=
oy
+
cy
;
}
}
/*****************************************************************/
/*****************************************************************/
void
RotatePoint
(
wxPoint
*
point
,
const
wxPoint
&
centre
,
int
angle
)
void
RotatePoint
(
wxPoint
*
point
,
const
wxPoint
&
centre
,
int
angle
)
/*****************************************************************/
/*****************************************************************/
/*
/*
Fonction surchargee!
*
Fonction surchargee!
calcule les nouvelles coord du point point,
*
calcule les nouvelles coord du point point,
pour une rotation de centre centre, et d'angle angle ( en 1/10 degre)
*
pour une rotation de centre centre, et d'angle angle ( en 1/10 degre)
*/
*/
{
{
int
ox
,
oy
;
int
ox
,
oy
;
ox
=
point
->
x
-
centre
.
x
;
oy
=
point
->
y
-
centre
.
y
;
ox
=
point
->
x
-
centre
.
x
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
oy
=
point
->
y
-
centre
.
y
;
point
->
x
=
ox
+
centre
.
x
;
point
->
y
=
oy
+
centre
.
y
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
point
->
x
=
ox
+
centre
.
x
;
point
->
y
=
oy
+
centre
.
y
;
}
}
/*************************************************************************/
/*************************************************************************/
void
RotatePoint
(
double
*
pX
,
double
*
pY
,
double
cx
,
double
cy
,
int
angle
)
void
RotatePoint
(
double
*
pX
,
double
*
pY
,
double
cx
,
double
cy
,
int
angle
)
/*************************************************************************/
/*************************************************************************/
{
{
double
ox
,
oy
;
double
ox
,
oy
;
ox
=
*
pX
-
cx
;
oy
=
*
pY
-
cy
;
ox
=
*
pX
-
cx
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
oy
=
*
pY
-
cy
;
*
pX
=
ox
+
cx
;
*
pY
=
oy
+
cy
;
RotatePoint
(
&
ox
,
&
oy
,
angle
);
*
pX
=
ox
+
cx
;
*
pY
=
oy
+
cy
;
}
}
/*************************************************/
/*************************************************/
void
RotatePoint
(
double
*
pX
,
double
*
pY
,
int
angle
)
void
RotatePoint
(
double
*
pX
,
double
*
pY
,
int
angle
)
/*************************************************/
/*************************************************/
/* Calcul des coord :
/* Calcul des coord :
coord: xrot = y*sin + x*cos
*
coord: xrot = y*sin + x*cos
yrot = y*cos - x*sin
*
yrot = y*cos - x*sin
*/
*/
{
{
double
tmp
;
double
tmp
;
while
(
angle
<
0
)
angle
+=
3600
;
while
(
angle
>=
3600
)
angle
-=
3600
;
while
(
angle
<
0
)
if
(
angle
==
0
)
return
;
angle
+=
3600
;
if
(
angle
==
900
)
/* sin = 1, cos = 0 */
{
while
(
angle
>=
3600
)
tmp
=
*
pX
;
angle
-=
3600
;
*
pX
=
*
pY
;
*
pY
=
-
tmp
;
if
(
angle
==
0
)
}
return
;
else
if
(
angle
==
1800
)
/* sin = 0, cos = -1 */
if
(
angle
==
900
)
/* sin = 1, cos = 0 */
{
{
*
pX
=
-
*
pX
;
tmp
=
*
pX
;
*
pY
=
-
*
pY
;
*
pX
=
*
pY
;
}
*
pY
=
-
tmp
;
}
else
if
(
angle
==
2700
)
/* sin = -1, cos = 0 */
else
if
(
angle
==
1800
)
/* sin = 0, cos = -1 */
{
{
tmp
=
*
pX
;
*
pX
=
-*
pX
;
*
pX
=
-
*
pY
;
*
pY
=
-*
pY
;
*
pY
=
tmp
;
}
}
else
if
(
angle
==
2700
)
/* sin = -1, cos = 0 */
{
else
tmp
=
*
pX
;
{
*
pX
=
-*
pY
;
double
fpx
=
(
*
pY
*
fsinus
[
angle
])
+
(
*
pX
*
fcosinus
[
angle
]);
*
pY
=
tmp
;
double
fpy
=
(
*
pY
*
fcosinus
[
angle
])
-
(
*
pX
*
fsinus
[
angle
]);
}
*
pX
=
fpx
;
*
pY
=
fpy
;
else
}
{
double
fpx
=
(
*
pY
*
fsinus
[
angle
])
+
(
*
pX
*
fcosinus
[
angle
]);
double
fpy
=
(
*
pY
*
fcosinus
[
angle
])
-
(
*
pX
*
fsinus
[
angle
]);
*
pX
=
fpx
;
*
pY
=
fpy
;
}
}
}
include/base_struct.h
View file @
2e4c17a8
...
@@ -179,8 +179,14 @@ public:
...
@@ -179,8 +179,14 @@ public:
const
wxPoint
&
offset
,
int
color
,
const
wxPoint
&
offset
,
int
color
,
int
draw_mode
,
int
display_mode
=
FILAIRE
,
int
anchor_color
=
-
1
);
int
draw_mode
,
int
display_mode
=
FILAIRE
,
int
anchor_color
=
-
1
);
/* locate functions */
/**
int
Locate
(
const
wxPoint
&
posref
);
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param posref A wxPoint to test
* @return bool - true if a hit, else false
*/
bool
HitTest
(
const
wxPoint
&
posref
);
int
Len_Size
(
void
);
// Return the text lenght in internal units
int
Len_Size
(
void
);
// Return the text lenght in internal units
};
};
...
...
pcbnew/class_board.cpp
View file @
2e4c17a8
/*******************************************/
/*******************************************/
/* class_board.cpp - BOARD class functions */
/* class_board.cpp - BOARD class functions */
/*******************************************/
/*******************************************/
#include "fctsys.h"
#include "fctsys.h"
#include "common.h"
#include "common.h"
...
@@ -9,237 +9,248 @@
...
@@ -9,237 +9,248 @@
#include "bitmaps.h"
#include "bitmaps.h"
/*****************/
/*****************/
/* Class BOARD: */
/* Class BOARD: */
/*****************/
/*****************/
/* Constructor */
/* Constructor */
BOARD
::
BOARD
(
EDA_BaseStruct
*
parent
,
WinEDA_BasePcbFrame
*
frame
)
:
BOARD
::
BOARD
(
EDA_BaseStruct
*
parent
,
WinEDA_BasePcbFrame
*
frame
)
:
EDA_BaseStruct
(
parent
,
TYPEPCB
)
EDA_BaseStruct
(
parent
,
TYPEPCB
)
{
{
m_PcbFrame
=
frame
;
m_PcbFrame
=
frame
;
m_Status_Pcb
=
0
;
// Mot d'etat: Bit 1 = Chevelu calcule
m_Status_Pcb
=
0
;
// Mot d'etat: Bit 1 = Chevelu calcule
m_NbNets
=
0
;
// Nombre de nets (equipotentielles)
m_NbNets
=
0
;
// Nombre de nets (equipotentielles)
m_BoardSettings
=
&
g_DesignSettings
;
m_BoardSettings
=
&
g_DesignSettings
;
m_NbPads
=
0
;
// nombre total de pads
m_NbPads
=
0
;
// nombre total de pads
m_NbNodes
=
0
;
// nombre de pads connectes
m_NbNodes
=
0
;
// nombre de pads connectes
m_NbLinks
=
0
;
// nombre de chevelus (donc aussi nombre
m_NbLinks
=
0
;
// nombre de chevelus (donc aussi nombre
// minimal de pistes a tracer
// minimal de pistes a tracer
m_NbSegmTrack
=
0
;
// nombre d'elements de type segments de piste
m_NbSegmTrack
=
0
;
// nombre d'elements de type segments de piste
m_NbSegmZone
=
0
;
// nombre d'elements de type segments de zone
m_NbSegmZone
=
0
;
// nombre d'elements de type segments de zone
m_NbNoconnect
=
0
;
// nombre de chevelus actifs
m_NbNoconnect
=
0
;
// nombre de chevelus actifs
m_NbLoclinks
=
0
;
// nb ratsnest local
m_NbLoclinks
=
0
;
// nb ratsnest local
m_Drawings
=
NULL
;
// pointeur sur liste drawings
m_Drawings
=
NULL
;
// pointeur sur liste drawings
m_Modules
=
NULL
;
// pointeur sur liste zone modules
m_Modules
=
NULL
;
// pointeur sur liste zone modules
m_Equipots
=
NULL
;
// pointeur liste zone equipot
m_Equipots
=
NULL
;
// pointeur liste zone equipot
m_Track
=
NULL
;
// pointeur relatif zone piste
m_Track
=
NULL
;
// pointeur relatif zone piste
m_Zone
=
NULL
;
// pointeur tableau zone zones de cuivre
m_Zone
=
NULL
;
// pointeur tableau zone zones de cuivre
m_Pads
=
NULL
;
// pointeur liste d'acces aux pads
m_Pads
=
NULL
;
// pointeur liste d'acces aux pads
m_Ratsnest
=
NULL
;
// pointeur liste rats
m_Ratsnest
=
NULL
;
// pointeur liste rats
m_LocalRatsnest
=
NULL
;
// pointeur liste rats local
m_LocalRatsnest
=
NULL
;
// pointeur liste rats local
m_CurrentLimitZone
=
NULL
;
// pointeur liste des EDEGE_ZONES
m_CurrentLimitZone
=
NULL
;
// pointeur liste des EDEGE_ZONES
// de determination des contours de zone
// de determination des contours de zone
}
}
/***************/
/* Destructeur */
/***************/
/***************/
/* Destructeur */
BOARD
::~
BOARD
(
void
)
/***************/
BOARD
::~
BOARD
(
void
)
{
{
}
}
void
BOARD
::
UnLink
(
void
)
void
BOARD
::
UnLink
(
void
)
{
{
/* Modification du chainage arriere */
/* Modification du chainage arriere */
if
(
Pback
)
if
(
Pback
)
{
{
if
(
Pback
->
m_StructType
==
TYPEPCB
)
if
(
Pback
->
m_StructType
==
TYPEPCB
)
{
{
Pback
->
Pnext
=
Pnext
;
Pback
->
Pnext
=
Pnext
;
}
}
else
/* Le chainage arriere pointe sur la structure "Pere" */
else
/* Le chainage arriere pointe sur la structure "Pere" */
{
{
// Pback-> = Pnext;
// Pback-> = Pnext;
}
}
}
}
/* Modification du chainage avant */
/* Modification du chainage avant */
if
(
Pnext
)
Pnext
->
Pback
=
Pback
;
if
(
Pnext
)
Pnext
->
Pback
=
Pback
;
Pnext
=
Pback
=
NULL
;
Pnext
=
Pback
=
NULL
;
}
}
/* Routines de calcul des nombres de segments pistes et zones */
/* Routines de calcul des nombres de segments pistes et zones */
int
BOARD
::
GetNumSegmTrack
(
void
)
int
BOARD
::
GetNumSegmTrack
(
void
)
{
{
TRACK
*
CurTrack
=
m_Track
;
TRACK
*
CurTrack
=
m_Track
;
int
ii
=
0
;
int
ii
=
0
;
for
(
;
CurTrack
!=
NULL
;
CurTrack
=
(
TRACK
*
)
CurTrack
->
Pnext
)
ii
++
;
for
(
;
CurTrack
!=
NULL
;
CurTrack
=
(
TRACK
*
)
CurTrack
->
Pnext
)
m_NbSegmTrack
=
ii
;
ii
++
;
return
(
ii
);
m_NbSegmTrack
=
ii
;
return
ii
;
}
}
int
BOARD
::
GetNumSegmZone
(
void
)
int
BOARD
::
GetNumSegmZone
(
void
)
{
{
TRACK
*
CurTrack
=
m_Zone
;
TRACK
*
CurTrack
=
m_Zone
;
int
ii
=
0
;
int
ii
=
0
;
for
(
;
CurTrack
!=
NULL
;
CurTrack
=
(
TRACK
*
)
CurTrack
->
Pnext
)
ii
++
;
for
(
;
CurTrack
!=
NULL
;
CurTrack
=
(
TRACK
*
)
CurTrack
->
Pnext
)
ii
++
;
m_NbSegmZone
=
ii
;
m_NbSegmZone
=
ii
;
return
ii
;
return
(
ii
);
}
}
// retourne le nombre de connexions manquantes
// retourne le nombre de connexions manquantes
int
BOARD
::
GetNumNoconnect
(
void
)
int
BOARD
::
GetNumNoconnect
(
void
)
{
{
return
(
m_NbNoconnect
)
;
return
m_NbNoconnect
;
}
}
// retourne le nombre de chevelus
int
BOARD
::
GetNumRatsnests
(
void
)
// retourne le nombre de chevelus
int
BOARD
::
GetNumRatsnests
(
void
)
{
{
return
(
m_NbLinks
)
;
return
m_NbLinks
;
}
}
// retourne le nombre de pads a netcode > 0
int
BOARD
::
GetNumNodes
(
void
)
// retourne le nombre de pads a netcode > 0
int
BOARD
::
GetNumNodes
(
void
)
{
{
return
(
m_NbNodes
)
;
return
m_NbNodes
;
}
}
/***********************************/
/***********************************/
bool
BOARD
::
ComputeBoundaryBox
(
void
)
bool
BOARD
::
ComputeBoundaryBox
(
void
)
/***********************************/
/***********************************/
/* Determine le rectangle d'encadrement du pcb
/* Determine le rectangle d'encadrement du pcb
Ce rectangle englobe les contours pcb, pads , vias et piste
*
Ce rectangle englobe les contours pcb, pads , vias et piste
Sortie:
*
Sortie:
m_PcbBox
*
m_PcbBox
*
retourne:
*
retourne:
0 si aucun element utile
*
0 si aucun element utile
1 sinon
*
1 sinon
*/
*/
{
{
int
rayon
,
cx
,
cy
,
d
,
xmin
,
ymin
,
xmax
,
ymax
;
int
rayon
,
cx
,
cy
,
d
,
xmin
,
ymin
,
xmax
,
ymax
;
bool
Has_Items
=
FALSE
;
bool
Has_Items
=
FALSE
;
EDA_BaseStruct
*
PtStruct
;
EDA_BaseStruct
*
PtStruct
;
DRAWSEGMENT
*
ptr
;
DRAWSEGMENT
*
ptr
;
TRACK
*
Track
;
TRACK
*
Track
;
xmin
=
ymin
=
0x7FFFFFFFl
;
xmin
=
ymin
=
0x7FFFFFFFl
;
xmax
=
ymax
=
-
0x7FFFFFFFl
;
xmax
=
ymax
=
-
0x7FFFFFFFl
;
/* Analyse des Contours PCB */
/* Analyse des Contours PCB */
PtStruct
=
m_Drawings
;
PtStruct
=
m_Drawings
;
for
(
;
PtStruct
!=
NULL
;
PtStruct
=
PtStruct
->
Pnext
)
for
(
;
PtStruct
!=
NULL
;
PtStruct
=
PtStruct
->
Pnext
)
{
{
if
(
PtStruct
->
m_StructType
!=
TYPEDRAWSEGMENT
)
continue
;
if
(
PtStruct
->
m_StructType
!=
TYPEDRAWSEGMENT
)
ptr
=
(
DRAWSEGMENT
*
)
PtStruct
;
continue
;
d
=
(
ptr
->
m_Width
/
2
)
+
1
;
if
(
ptr
->
m_Shape
==
S_CIRCLE
)
ptr
=
(
DRAWSEGMENT
*
)
PtStruct
;
{
d
=
(
ptr
->
m_Width
/
2
)
+
1
;
cx
=
ptr
->
m_Start
.
x
;
cy
=
ptr
->
m_Start
.
y
;
rayon
=
(
int
)
hypot
((
double
)(
ptr
->
m_End
.
x
-
cx
),(
double
)(
ptr
->
m_End
.
y
-
cy
)
);
if
(
ptr
->
m_Shape
==
S_CIRCLE
)
rayon
+=
d
;
{
xmin
=
min
(
xmin
,
cx
-
rayon
);
cx
=
ptr
->
m_Start
.
x
;
cy
=
ptr
->
m_Start
.
y
;
ymin
=
min
(
ymin
,
cy
-
rayon
);
rayon
=
(
int
)
hypot
(
(
double
)
(
ptr
->
m_End
.
x
-
cx
),
(
double
)
(
ptr
->
m_End
.
y
-
cy
)
);
xmax
=
max
(
xmax
,
cx
+
rayon
);
rayon
+=
d
;
ymax
=
max
(
ymax
,
cy
+
rayon
);
xmin
=
min
(
xmin
,
cx
-
rayon
);
Has_Items
=
TRUE
;
ymin
=
min
(
ymin
,
cy
-
rayon
);
}
xmax
=
max
(
xmax
,
cx
+
rayon
);
else
ymax
=
max
(
ymax
,
cy
+
rayon
);
{
Has_Items
=
TRUE
;
cx
=
min
(
ptr
->
m_Start
.
x
,
ptr
->
m_End
.
x
);
}
cy
=
min
(
ptr
->
m_Start
.
y
,
ptr
->
m_End
.
y
);
else
xmin
=
min
(
xmin
,
cx
-
d
);
{
ymin
=
min
(
ymin
,
cy
-
d
);
cx
=
min
(
ptr
->
m_Start
.
x
,
ptr
->
m_End
.
x
);
cx
=
max
(
ptr
->
m_Start
.
x
,
ptr
->
m_End
.
x
);
cy
=
min
(
ptr
->
m_Start
.
y
,
ptr
->
m_End
.
y
);
cy
=
max
(
ptr
->
m_Start
.
y
,
ptr
->
m_End
.
y
);
xmin
=
min
(
xmin
,
cx
-
d
);
xmax
=
max
(
xmax
,
cx
+
d
);
ymin
=
min
(
ymin
,
cy
-
d
);
ymax
=
max
(
ymax
,
cy
+
d
);
cx
=
max
(
ptr
->
m_Start
.
x
,
ptr
->
m_End
.
x
);
Has_Items
=
TRUE
;
cy
=
max
(
ptr
->
m_Start
.
y
,
ptr
->
m_End
.
y
);
}
xmax
=
max
(
xmax
,
cx
+
d
);
}
ymax
=
max
(
ymax
,
cy
+
d
);
Has_Items
=
TRUE
;
/* Analyse des Modules */
}
MODULE
*
module
=
m_Modules
;
}
for
(
;
module
!=
NULL
;
module
=
(
MODULE
*
)
module
->
Pnext
)
{
/* Analyse des Modules */
Has_Items
=
TRUE
;
MODULE
*
module
=
m_Modules
;
xmin
=
min
(
xmin
,(
module
->
m_Pos
.
x
+
module
->
m_BoundaryBox
.
GetX
()));
for
(
;
module
!=
NULL
;
module
=
(
MODULE
*
)
module
->
Pnext
)
ymin
=
min
(
ymin
,(
module
->
m_Pos
.
y
+
module
->
m_BoundaryBox
.
GetY
()));
{
xmax
=
max
(
xmax
,
module
->
m_Pos
.
x
+
module
->
m_BoundaryBox
.
GetRight
());
Has_Items
=
TRUE
;
ymax
=
max
(
ymax
,
module
->
m_Pos
.
y
+
module
->
m_BoundaryBox
.
GetBottom
());
xmin
=
min
(
xmin
,
(
module
->
m_Pos
.
x
+
module
->
m_BoundaryBox
.
GetX
()
)
);
ymin
=
min
(
ymin
,
(
module
->
m_Pos
.
y
+
module
->
m_BoundaryBox
.
GetY
()
)
);
D_PAD
*
pt_pad
=
module
->
m_Pads
;
xmax
=
max
(
xmax
,
module
->
m_Pos
.
x
+
module
->
m_BoundaryBox
.
GetRight
()
);
for
(
;
pt_pad
!=
NULL
;
pt_pad
=
(
D_PAD
*
)
pt_pad
->
Pnext
)
ymax
=
max
(
ymax
,
module
->
m_Pos
.
y
+
module
->
m_BoundaryBox
.
GetBottom
()
);
{
d
=
pt_pad
->
m_Rayon
;
D_PAD
*
pt_pad
=
module
->
m_Pads
;
xmin
=
min
(
xmin
,
pt_pad
->
m_Pos
.
x
-
d
);
for
(
;
pt_pad
!=
NULL
;
pt_pad
=
(
D_PAD
*
)
pt_pad
->
Pnext
)
ymin
=
min
(
ymin
,
pt_pad
->
m_Pos
.
y
-
d
);
{
xmax
=
max
(
xmax
,
pt_pad
->
m_Pos
.
x
+
d
);
d
=
pt_pad
->
m_Rayon
;
ymax
=
max
(
ymax
,
pt_pad
->
m_Pos
.
y
+
d
);
xmin
=
min
(
xmin
,
pt_pad
->
m_Pos
.
x
-
d
);
}
ymin
=
min
(
ymin
,
pt_pad
->
m_Pos
.
y
-
d
);
}
xmax
=
max
(
xmax
,
pt_pad
->
m_Pos
.
x
+
d
);
ymax
=
max
(
ymax
,
pt_pad
->
m_Pos
.
y
+
d
);
/* Analyse des segments de piste et zone*/
}
for
(
Track
=
m_Track
;
Track
!=
NULL
;
Track
=
(
TRACK
*
)
Track
->
Pnext
)
}
{
d
=
(
Track
->
m_Width
/
2
)
+
1
;
/* Analyse des segments de piste et zone*/
cx
=
min
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
for
(
Track
=
m_Track
;
Track
!=
NULL
;
Track
=
(
TRACK
*
)
Track
->
Pnext
)
cy
=
min
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
{
xmin
=
min
(
xmin
,
cx
-
d
);
d
=
(
Track
->
m_Width
/
2
)
+
1
;
ymin
=
min
(
ymin
,
cy
-
d
);
cx
=
min
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
cx
=
max
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
cy
=
min
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
cy
=
max
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
xmin
=
min
(
xmin
,
cx
-
d
);
xmax
=
max
(
xmax
,
cx
+
d
);
ymin
=
min
(
ymin
,
cy
-
d
);
ymax
=
max
(
ymax
,
cy
+
d
);
cx
=
max
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
Has_Items
=
TRUE
;
cy
=
max
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
}
xmax
=
max
(
xmax
,
cx
+
d
);
ymax
=
max
(
ymax
,
cy
+
d
);
for
(
Track
=
m_Zone
;
Track
!=
NULL
;
Track
=
(
TRACK
*
)
Track
->
Pnext
)
Has_Items
=
TRUE
;
{
}
d
=
(
Track
->
m_Width
/
2
)
+
1
;
cx
=
min
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
for
(
Track
=
m_Zone
;
Track
!=
NULL
;
Track
=
(
TRACK
*
)
Track
->
Pnext
)
cy
=
min
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
{
xmin
=
min
(
xmin
,
cx
-
d
);
d
=
(
Track
->
m_Width
/
2
)
+
1
;
ymin
=
min
(
ymin
,
cy
-
d
);
cx
=
min
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
cx
=
max
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
cy
=
min
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
cy
=
max
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
xmin
=
min
(
xmin
,
cx
-
d
);
xmax
=
max
(
xmax
,
cx
+
d
);
ymin
=
min
(
ymin
,
cy
-
d
);
ymax
=
max
(
ymax
,
cy
+
d
);
cx
=
max
(
Track
->
m_Start
.
x
,
Track
->
m_End
.
x
);
Has_Items
=
TRUE
;
cy
=
max
(
Track
->
m_Start
.
y
,
Track
->
m_End
.
y
);
}
xmax
=
max
(
xmax
,
cx
+
d
);
ymax
=
max
(
ymax
,
cy
+
d
);
if
(
!
Has_Items
&&
m_PcbFrame
)
Has_Items
=
TRUE
;
{
}
if
(
m_PcbFrame
->
m_Draw_Sheet_Ref
)
{
if
(
!
Has_Items
&&
m_PcbFrame
)
xmin
=
ymin
=
0
;
{
xmax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
;
if
(
m_PcbFrame
->
m_Draw_Sheet_Ref
)
ymax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
;
{
}
xmin
=
ymin
=
0
;
else
xmax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
;
{
ymax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
;
xmin
=
-
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
/
2
;
}
ymin
=
-
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
/
2
;
else
xmax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
/
2
;
{
ymax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
/
2
;
xmin
=
-
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
/
2
;
}
ymin
=
-
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
/
2
;
}
xmax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
x
/
2
;
ymax
=
m_PcbFrame
->
m_CurrentScreen
->
ReturnPageSize
().
y
/
2
;
m_BoundaryBox
.
SetX
(
xmin
);
}
m_BoundaryBox
.
SetY
(
ymin
);
}
m_BoundaryBox
.
SetWidth
(
xmax
-
xmin
);
m_BoundaryBox
.
SetHeight
(
ymax
-
ymin
);
m_BoundaryBox
.
SetX
(
xmin
);
m_BoundaryBox
.
SetY
(
ymin
);
return
(
Has_Items
);
m_BoundaryBox
.
SetWidth
(
xmax
-
xmin
);
m_BoundaryBox
.
SetHeight
(
ymax
-
ymin
);
return
Has_Items
;
}
}
pcbnew/class_text_mod.cpp
View file @
2e4c17a8
/****************************************************/
/****************************************************/
/* class_module.cpp : fonctions de la classe MODULE */
/* class_module.cpp : fonctions de la classe MODULE */
/****************************************************/
/****************************************************/
#include "fctsys.h"
#include "fctsys.h"
#include "gr_basic.h"
#include "gr_basic.h"
...
@@ -22,246 +22,275 @@
...
@@ -22,246 +22,275 @@
#include "protos.h"
#include "protos.h"
/************************************************************************/
/************************************************************************/
/* Class TEXTE_MODULE classe de base des elements type Texte sur module */
/* Class TEXTE_MODULE classe de base des elements type Texte sur module */
/************************************************************************/
/************************************************************************/
/* Constructeur de TEXTE_MODULE */
/* Constructeur de TEXTE_MODULE */
TEXTE_MODULE
::
TEXTE_MODULE
(
MODULE
*
parent
,
int
text_type
)
:
TEXTE_MODULE
::
TEXTE_MODULE
(
MODULE
*
parent
,
int
text_type
)
:
EDA_BaseStruct
(
parent
,
TYPETEXTEMODULE
)
EDA_BaseStruct
(
parent
,
TYPETEXTEMODULE
)
{
{
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
m_NoShow
=
0
;
/* visible */
m_NoShow
=
0
;
/* visible */
m_Type
=
text_type
;
/* Reference */
m_Type
=
text_type
;
/* Reference */
if
(
(
m_Type
!=
TEXT_is_REFERENCE
)
&&
(
m_Type
!=
TEXT_is_VALUE
)
)
if
(
(
m_Type
!=
TEXT_is_REFERENCE
)
&&
(
m_Type
!=
TEXT_is_VALUE
)
)
m_Type
=
TEXT_is_DIVERS
;
m_Type
=
TEXT_is_DIVERS
;
m_Size
.
x
=
m_Size
.
y
=
400
;
m_Width
=
120
;
/* dimensions raisonnables par defaut */
m_Size
.
x
=
m_Size
.
y
=
400
;
m_Width
=
120
;
/* dimensions raisonnables par defaut */
m_Orient
=
0
;
/* en 1/10 degre */
m_Orient
=
0
;
/* en 1/10 degre */
m_Miroir
=
1
;
// Mode normal (pas de miroir)
m_Miroir
=
1
;
// Mode normal (pas de miroir)
m_Unused
=
0
;
m_Unused
=
0
;
m_Layer
=
SILKSCREEN_N_CMP
;
m_Layer
=
SILKSCREEN_N_CMP
;
if
(
Module
&&
(
Module
->
m_StructType
==
TYPEMODULE
)
)
if
(
Module
&&
(
Module
->
m_StructType
==
TYPEMODULE
)
)
{
{
m_Pos
=
Module
->
m_Pos
;
m_Pos
=
Module
->
m_Pos
;
m_Layer
=
Module
->
m_Layer
;
m_Layer
=
Module
->
m_Layer
;
if
(
Module
->
m_Layer
==
CUIVRE_N
)
m_Layer
=
SILKSCREEN_N_CU
;
if
(
Module
->
m_Layer
==
CUIVRE_N
)
if
(
Module
->
m_Layer
==
CMP_N
)
m_Layer
=
SILKSCREEN_N_CMP
;
m_Layer
=
SILKSCREEN_N_CU
;
if
((
Module
->
m_Layer
==
SILKSCREEN_N_CU
)
||
if
(
Module
->
m_Layer
==
CMP_N
)
(
Module
->
m_Layer
==
ADHESIVE_N_CU
)
||
(
Module
->
m_Layer
==
CUIVRE_N
))
m_Layer
=
SILKSCREEN_N_CMP
;
m_Miroir
=
0
;
if
(
(
Module
->
m_Layer
==
SILKSCREEN_N_CU
)
}
||
(
Module
->
m_Layer
==
ADHESIVE_N_CU
)
||
(
Module
->
m_Layer
==
CUIVRE_N
)
)
m_Miroir
=
0
;
}
}
}
TEXTE_MODULE
::
~
TEXTE_MODULE
(
void
)
TEXTE_MODULE
::~
TEXTE_MODULE
(
void
)
{
{
}
}
void
TEXTE_MODULE
::
Copy
(
TEXTE_MODULE
*
source
)
// copy structure
void
TEXTE_MODULE
::
Copy
(
TEXTE_MODULE
*
source
)
// copy structure
{
{
if
(
source
==
NULL
)
return
;
if
(
source
==
NULL
)
return
;
m_Pos
=
source
->
m_Pos
;
m_Pos
=
source
->
m_Pos
;
m_Layer
=
source
->
m_Layer
;
m_Layer
=
source
->
m_Layer
;
m_Miroir
=
source
->
m_Miroir
;
// vue normale / miroir
m_Miroir
=
source
->
m_Miroir
;
// vue normale / miroir
m_NoShow
=
source
->
m_NoShow
;
// 0: visible 1: invisible
m_NoShow
=
source
->
m_NoShow
;
// 0: visible 1: invisible
m_Type
=
source
->
m_Type
;
// 0: ref,1: val, autre = 2..255
m_Type
=
source
->
m_Type
;
// 0: ref,1: val, autre = 2..255
m_Orient
=
source
->
m_Orient
;
// orientation en 1/10 degre
m_Orient
=
source
->
m_Orient
;
// orientation en 1/10 degre
m_Pos0
=
source
->
m_Pos0
;
// coord du debut du texte /ancre, orient 0
m_Pos0
=
source
->
m_Pos0
;
// coord du debut du texte /ancre, orient 0
m_Size
=
source
->
m_Size
;
m_Size
=
source
->
m_Size
;
m_Width
=
source
->
m_Width
;
m_Width
=
source
->
m_Width
;
m_Text
=
source
->
m_Text
;
m_Text
=
source
->
m_Text
;
}
}
/* supprime du chainage la structure Struct
/* supprime du chainage la structure Struct
les structures arrieres et avant sont chainees directement
*
les structures arrieres et avant sont chainees directement
*/
*/
void
TEXTE_MODULE
::
UnLink
(
void
)
void
TEXTE_MODULE
::
UnLink
(
void
)
{
{
/* Modification du chainage arriere */
/* Modification du chainage arriere */
if
(
Pback
)
if
(
Pback
)
{
{
if
(
Pback
->
m_StructType
!=
TYPEMODULE
)
if
(
Pback
->
m_StructType
!=
TYPEMODULE
)
{
{
Pback
->
Pnext
=
Pnext
;
Pback
->
Pnext
=
Pnext
;
}
}
else
/* Le chainage arriere pointe sur la structure "Pere" */
else
/* Le chainage arriere pointe sur la structure "Pere" */
{
{
(
(
MODULE
*
)
Pback
)
->
m_Drawings
=
Pnext
;
((
MODULE
*
)
Pback
)
->
m_Drawings
=
Pnext
;
}
}
}
}
/* Modification du chainage avant */
/* Modification du chainage avant */
if
(
Pnext
)
if
(
Pnext
)
Pnext
->
Pback
=
Pback
;
Pnext
->
Pback
=
Pback
;
Pnext
=
Pback
=
NULL
;
Pnext
=
Pback
=
NULL
;
}
}
/******************************************/
/******************************************/
int
TEXTE_MODULE
::
GetLength
(
void
)
int
TEXTE_MODULE
::
GetLength
(
void
)
/******************************************/
/******************************************/
{
{
return
m_Text
.
Len
();
return
m_Text
.
Len
();
}
}
/******************************************/
/******************************************/
void
TEXTE_MODULE
::
SetWidth
(
int
new_width
)
void
TEXTE_MODULE
::
SetWidth
(
int
new_width
)
/******************************************/
/******************************************/
{
{
m_Width
=
new_width
;
m_Width
=
new_width
;
}
}
// mise a jour des coordonnes absolues pour affichage
void
TEXTE_MODULE
::
SetDrawCoord
(
void
)
// mise a jour des coordonn�s absolues pour affichage
void
TEXTE_MODULE
::
SetDrawCoord
(
void
)
{
{
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
m_Pos
=
m_Pos0
;
m_Pos
=
m_Pos0
;
if
(
Module
==
NULL
)
return
;
if
(
Module
==
NULL
)
return
;
int
angle
=
Module
->
m_Orient
;
int
angle
=
Module
->
m_Orient
;
NORMALIZE_ANGLE_POS
(
angle
);
NORMALIZE_ANGLE_POS
(
angle
);
RotatePoint
(
&
m_Pos
.
x
,
&
m_Pos
.
y
,
angle
);
RotatePoint
(
&
m_Pos
.
x
,
&
m_Pos
.
y
,
angle
);
m_Pos
.
x
+=
Module
->
m_Pos
.
x
;
m_Pos
.
x
+=
Module
->
m_Pos
.
x
;
m_Pos
.
y
+=
Module
->
m_Pos
.
y
;
m_Pos
.
y
+=
Module
->
m_Pos
.
y
;
}
}
// mise a jour des coordonnes relatives au module
void
TEXTE_MODULE
::
SetLocalCoord
(
void
)
// mise a jour des coordonn�s relatives au module
void
TEXTE_MODULE
::
SetLocalCoord
(
void
)
{
{
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
if
(
Module
==
NULL
)
return
;
if
(
Module
==
NULL
)
return
;
m_Pos0
.
x
=
m_Pos
.
x
-
Module
->
m_Pos
.
x
;
m_Pos0
.
x
=
m_Pos
.
x
-
Module
->
m_Pos
.
x
;
m_Pos0
.
y
=
m_Pos
.
y
-
Module
->
m_Pos
.
y
;
m_Pos0
.
y
=
m_Pos
.
y
-
Module
->
m_Pos
.
y
;
int
angle
=
Module
->
m_Orient
;
int
angle
=
Module
->
m_Orient
;
NORMALIZE_ANGLE_POS
(
angle
);
NORMALIZE_ANGLE_POS
(
angle
);
RotatePoint
(
&
m_Pos0
.
x
,
&
m_Pos0
.
y
,
-
angle
);
RotatePoint
(
&
m_Pos0
.
x
,
&
m_Pos0
.
y
,
-
angle
);
}
}
/* locate functions */
int
TEXTE_MODULE
::
Locate
(
const
wxPoint
&
posref
)
/* locate functions */
bool
TEXTE_MODULE
::
HitTest
(
const
wxPoint
&
posref
)
{
{
int
mX
,
mY
,
dx
,
dy
;
int
mX
,
mY
,
dx
,
dy
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
int
angle
=
m_Orient
;
int
angle
=
m_Orient
;
if
(
Module
)
angle
+=
Module
->
m_Orient
;
if
(
Module
)
angle
+=
Module
->
m_Orient
;
dx
=
(
m_Size
.
x
*
GetLength
())
/
2
;
dy
=
m_Size
.
y
/
2
;
dx
=
(
m_Size
.
x
*
GetLength
()
)
/
2
;
dx
=
((
dx
*
10
)
/
9
)
+
m_Width
;
/* Facteur de forme des lettres : 10/9 */
dy
=
m_Size
.
y
/
2
;
dx
=
(
(
dx
*
10
)
/
9
)
+
m_Width
;
/* Facteur de forme des lettres : 10/9 */
/* le point de reference est tourn de - angle
pour se ramener a un rectangle de reference horizontal */
/* le point de reference est tourn�de - angle
mX
=
posref
.
x
-
m_Pos
.
x
;
mY
=
posref
.
y
-
m_Pos
.
y
;
* pour se ramener a un rectangle de reference horizontal */
RotatePoint
(
&
mX
,
&
mY
,
-
angle
);
mX
=
posref
.
x
-
m_Pos
.
x
;
/* le point de reference est-il dans ce rectangle */
mY
=
posref
.
y
-
m_Pos
.
y
;
if
(
(
abs
(
mX
)
<=
abs
(
dx
)
)
&&
(
abs
(
mY
)
<=
abs
(
dy
))
)
{
RotatePoint
(
&
mX
,
&
mY
,
-
angle
);
return
1
;
}
/* le point de reference est-il dans ce rectangle */
return
0
;
if
(
(
abs
(
mX
)
<=
abs
(
dx
)
)
&&
(
abs
(
mY
)
<=
abs
(
dy
)
)
)
{
return
true
;
}
return
false
;
}
}
/******************************************************************************************/
/******************************************************************************************/
void
TEXTE_MODULE
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
wxPoint
offset
,
int
draw_mode
)
void
TEXTE_MODULE
::
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
wxPoint
offset
,
int
draw_mode
)
/******************************************************************************************/
/******************************************************************************************/
/* trace 1 texte de module
/* trace 1 texte de module
Utilise la police definie dans grfonte.h
*
Utilise la police definie dans grfonte.h
(Se reporter a ce fichier pour les explications complementaires)
*
(Se reporter a ce fichier pour les explications complementaires)
offset = offset de trace ( reference au centre du texte)
*
offset = offset de trace ( reference au centre du texte)
draw_mode = GR_OR, GR_XOR..
*
draw_mode = GR_OR, GR_XOR..
*/
*/
{
{
int
zoom
;
int
zoom
;
int
width
,
color
,
orient
,
miroir
;
int
width
,
color
,
orient
,
miroir
;
wxSize
size
;
wxSize
size
;
wxPoint
pos
;
// Centre du texte
wxPoint
pos
;
// Centre du texte
PCB_SCREEN
*
screen
;
PCB_SCREEN
*
screen
;
WinEDA_BasePcbFrame
*
frame
;
WinEDA_BasePcbFrame
*
frame
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
if
(
panel
==
NULL
)
return
;
if
(
panel
==
NULL
)
return
;
screen
=
(
PCB_SCREEN
*
)
panel
->
GetScreen
();
frame
=
(
WinEDA_BasePcbFrame
*
)
panel
->
m_Parent
;
screen
=
(
PCB_SCREEN
*
)
panel
->
GetScreen
();
zoom
=
screen
->
GetZoom
();
frame
=
(
WinEDA_BasePcbFrame
*
)
panel
->
m_Parent
;
zoom
=
screen
->
GetZoom
();
pos
.
x
=
m_Pos
.
x
-
offset
.
x
;
pos
.
y
=
m_Pos
.
y
-
offset
.
y
;
pos
.
x
=
m_Pos
.
x
-
offset
.
x
;
pos
.
y
=
m_Pos
.
y
-
offset
.
y
;
size
=
m_Size
;
orient
=
GetDrawRotation
();
size
=
m_Size
;
miroir
=
m_Miroir
&
1
;
// = 0 si vu en miroir
orient
=
GetDrawRotation
();
width
=
m_Width
;
miroir
=
m_Miroir
&
1
;
// = 0 si vu en miroir
if
(
(
frame
->
m_DisplayModText
==
FILAIRE
)
||
(
(
width
/
zoom
)
<
L_MIN_DESSIN
)
)
width
=
m_Width
;
width
=
0
;
if
(
(
frame
->
m_DisplayModText
==
FILAIRE
)
||
(
(
width
/
zoom
)
<
L_MIN_DESSIN
)
)
else
if
(
frame
->
m_DisplayModText
==
SKETCH
)
width
=
-
width
;
width
=
0
;
else
if
(
frame
->
m_DisplayModText
==
SKETCH
)
GRSetDrawMode
(
DC
,
draw_mode
);
width
=
-
width
;
/* trace du centre du texte */
GRSetDrawMode
(
DC
,
draw_mode
);
if
((
g_AnchorColor
&
ITEM_NOT_SHOW
)
==
0
)
{
/* trace du centre du texte */
int
anchor_size
=
2
*
zoom
;
if
(
(
g_AnchorColor
&
ITEM_NOT_SHOW
)
==
0
)
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
{
pos
.
x
-
anchor_size
,
pos
.
y
,
int
anchor_size
=
2
*
zoom
;
pos
.
x
+
anchor_size
,
pos
.
y
,
0
,
g_AnchorColor
);
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
pos
.
x
-
anchor_size
,
pos
.
y
,
pos
.
x
,
pos
.
y
-
anchor_size
,
pos
.
x
+
anchor_size
,
pos
.
y
,
0
,
g_AnchorColor
);
pos
.
x
,
pos
.
y
+
anchor_size
,
0
,
g_AnchorColor
);
GRLine
(
&
panel
->
m_ClipBox
,
DC
,
}
pos
.
x
,
pos
.
y
-
anchor_size
,
pos
.
x
,
pos
.
y
+
anchor_size
,
0
,
g_AnchorColor
);
color
=
g_DesignSettings
.
m_LayerColor
[
Module
->
m_Layer
];
}
if
(
Module
&&
Module
->
m_Layer
==
CUIVRE_N
)
color
=
g_ModuleTextCUColor
;
color
=
g_DesignSettings
.
m_LayerColor
[
Module
->
m_Layer
];
if
(
Module
&&
Module
->
m_Layer
==
CMP_N
)
color
=
g_ModuleTextCMPColor
;
if
(
Module
&&
Module
->
m_Layer
==
CUIVRE_N
)
if
(
(
color
&
ITEM_NOT_SHOW
)
!=
0
)
return
;
color
=
g_ModuleTextCUColor
;
if
(
Module
&&
Module
->
m_Layer
==
CMP_N
)
if
(
m_NoShow
)
color
=
g_ModuleTextNOVColor
;
color
=
g_ModuleTextCMPColor
;
if
(
(
color
&
ITEM_NOT_SHOW
)
!=
0
)
return
;
if
(
(
color
&
ITEM_NOT_SHOW
)
!=
0
)
/* Si le texte doit etre mis en miroir: modif des parametres */
return
;
if
(
miroir
==
0
)
size
.
x
=
-
size
.
x
;
if
(
m_NoShow
)
/* Trace du texte */
color
=
g_ModuleTextNOVColor
;
DrawGraphicText
(
panel
,
DC
,
pos
,
color
,
m_Text
,
if
(
(
color
&
ITEM_NOT_SHOW
)
!=
0
)
orient
,
size
,
GR_TEXT_HJUSTIFY_CENTER
,
GR_TEXT_VJUSTIFY_CENTER
,
width
);
return
;
/* Si le texte doit etre mis en miroir: modif des parametres */
if
(
miroir
==
0
)
size
.
x
=
-
size
.
x
;
/* Trace du texte */
DrawGraphicText
(
panel
,
DC
,
pos
,
color
,
m_Text
,
orient
,
size
,
GR_TEXT_HJUSTIFY_CENTER
,
GR_TEXT_VJUSTIFY_CENTER
,
width
);
}
}
/******************************************/
/******************************************/
int
TEXTE_MODULE
::
GetDrawRotation
(
void
)
int
TEXTE_MODULE
::
GetDrawRotation
(
void
)
/******************************************/
/******************************************/
/* Return text rotation for drawings and plotting
/* Return text rotation for drawings and plotting
*/
*/
{
{
int
rotation
;
int
rotation
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
MODULE
*
Module
=
(
MODULE
*
)
m_Parent
;
rotation
=
m_Orient
;
if
(
Module
)
rotation
+=
Module
->
m_Orient
;
NORMALIZE_ANGLE_POS
(
rotation
);
rotation
=
m_Orient
;
if
(
Module
)
rotation
+=
Module
->
m_Orient
;
NORMALIZE_ANGLE_POS
(
rotation
);
// if( (rotation > 900 ) && (rotation < 2700 ) ) rotation -= 1800; // For angle = 0 .. 180 deg
// if( (rotation > 900 ) && (rotation < 2700 ) ) rotation -= 1800; // For angle = 0 .. 180 deg
while
(
rotation
>
900
)
rotation
-=
1800
;
// For angle = -90 .. 90 deg
while
(
rotation
>
900
)
rotation
-=
1800
;
return
rotation
;
}
// For angle = -90 .. 90 deg
return
rotation
;
}
pcbnew/class_text_mod.h
View file @
2e4c17a8
/***************************************************/
/***************************************************/
/* class_text_module.h : texts module description */
/* class_text_module.h : texts module description */
/***************************************************/
/***************************************************/
/* Description des Textes sur Modules : */
/* Description des Textes sur Modules : */
#define TEXT_is_REFERENCE 0
#define TEXT_is_REFERENCE 0
#define TEXT_is_VALUE 1
#define TEXT_is_VALUE
1
#define TEXT_is_DIVERS 2
#define TEXT_is_DIVERS
2
class
TEXTE_MODULE
:
public
EDA_BaseStruct
class
TEXTE_MODULE
:
public
EDA_BaseStruct
{
{
public
:
public
:
int
m_Layer
;
// layer number
int
m_Layer
;
// layer number
int
m_Width
;
int
m_Width
;
wxPoint
m_Pos
;
// Real coord
wxPoint
m_Pos
;
// Real coord
wxPoint
m_Pos0
;
// coord du debut du texte /ancre, orient 0
wxPoint
m_Pos0
;
// coord du debut du texte /ancre, orient 0
char
m_Unused
;
// unused (reserved for future extensions)
char
m_Unused
;
// unused (reserved for future extensions)
char
m_Miroir
;
// vue normale / miroir
char
m_Miroir
;
// vue normale / miroir
char
m_NoShow
;
// 0: visible 1: invisible (bool)
char
m_NoShow
;
// 0: visible 1: invisible (bool)
char
m_Type
;
// 0: ref,1: val, autre = 2..255
char
m_Type
;
// 0: ref,1: val, autre = 2..255
int
m_Orient
;
// orientation en 1/10 degre
int
m_Orient
;
// orientation en 1/10 degre
wxSize
m_Size
;
// dimensions (en X et Y) du texte
wxSize
m_Size
;
// dimensions (en X et Y) du texte
wxString
m_Text
;
wxString
m_Text
;
public
:
public
:
TEXTE_MODULE
(
MODULE
*
parent
,
int
text_type
=
TEXT_is_DIVERS
);
TEXTE_MODULE
(
MODULE
*
parent
,
int
text_type
=
TEXT_is_DIVERS
);
~
TEXTE_MODULE
(
void
);
~
TEXTE_MODULE
(
void
);
/* supprime du chainage la structure Struct */
/* supprime du chainage la structure Struct */
void
UnLink
(
void
);
void
UnLink
(
void
);
void
Copy
(
TEXTE_MODULE
*
source
);
// copy structure
void
Copy
(
TEXTE_MODULE
*
source
);
// copy structure
/* Gestion du texte */
/* Gestion du texte */
void
SetWidth
(
int
new_width
);
void
SetWidth
(
int
new_width
);
int
GetLength
(
void
);
/* text length */
int
GetLength
(
void
);
/* text length */
int
Pitch
(
void
);
/* retourne le pas entre 2 caracteres */
int
Pitch
(
void
);
/* retourne le pas entre 2 caracteres */
int
GetDrawRotation
(
void
);
// Return text rotation for drawings and plotting
int
GetDrawRotation
(
void
);
// Return text rotation for drawings and plotting
void
SetDrawCoord
(
void
);
// mise a jour des coordonnées absolues de tracé
// a partir des coord relatives
void
SetLocalCoord
(
void
);
// mise a jour des coordonnées relatives
// a partir des coord absolues de tracé
/* Reading and writing data on files */
int
WriteDescr
(
FILE
*
File
);
int
ReadDescr
(
FILE
*
File
,
int
*
LineNum
=
NULL
);
/* drawing functions */
void
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
wxPoint
offset
,
int
draw_mode
);
/* locate functions */
int
Locate
(
const
wxPoint
&
posref
);
};
void
SetDrawCoord
(
void
);
// mise a jour des coordonn�s absolues de trac�
// a partir des coord relatives
void
SetLocalCoord
(
void
);
// mise a jour des coordonn�s relatives
// a partir des coord absolues de trac�
/* Reading and writing data on files */
int
WriteDescr
(
FILE
*
File
);
int
ReadDescr
(
FILE
*
File
,
int
*
LineNum
=
NULL
);
/* drawing functions */
void
Draw
(
WinEDA_DrawPanel
*
panel
,
wxDC
*
DC
,
wxPoint
offset
,
int
draw_mode
);
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param posref A wxPoint to test
* @return bool - true if a hit, else false
*/
bool
HitTest
(
const
wxPoint
&
posref
);
};
pcbnew/hotkeys.cpp
View file @
2e4c17a8
...
@@ -34,6 +34,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -34,6 +34,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
{
{
bool
PopupOn
=
GetScreen
()
->
m_CurrentItem
bool
PopupOn
=
GetScreen
()
->
m_CurrentItem
&&
GetScreen
()
->
m_CurrentItem
->
m_Flags
;
&&
GetScreen
()
->
m_CurrentItem
->
m_Flags
;
bool
ItemFree
=
(
GetScreen
()
->
m_CurrentItem
==
0
)
bool
ItemFree
=
(
GetScreen
()
->
m_CurrentItem
==
0
)
||
(
GetScreen
()
->
m_CurrentItem
->
m_Flags
==
0
);
||
(
GetScreen
()
->
m_CurrentItem
->
m_Flags
==
0
);
...
@@ -63,10 +64,10 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -63,10 +64,10 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
||
(
GetScreen
()
->
m_CurrentItem
->
m_Flags
==
0
);
||
(
GetScreen
()
->
m_CurrentItem
->
m_Flags
==
0
);
if
(
ItemFree
)
if
(
ItemFree
)
{
{
//no track is currently being edited - select a segment and remove it.
//
no track is currently being edited - select a segment and remove it.
DrawStruct
=
PcbGeneralLocateAndDisplay
();
DrawStruct
=
PcbGeneralLocateAndDisplay
();
//don't let backspace delete modules!!
//
don't let backspace delete modules!!
if
(
DrawStruct
&&
(
DrawStruct
->
m_StructType
==
TYPETRACK
if
(
DrawStruct
&&
(
DrawStruct
->
m_StructType
==
TYPETRACK
||
DrawStruct
->
m_StructType
==
TYPEVIA
)
)
||
DrawStruct
->
m_StructType
==
TYPEVIA
)
)
Delete_Segment
(
DC
,
(
TRACK
*
)
DrawStruct
);
Delete_Segment
(
DC
,
(
TRACK
*
)
DrawStruct
);
...
@@ -74,7 +75,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -74,7 +75,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
}
}
else
if
(
GetScreen
()
->
m_CurrentItem
->
m_StructType
==
TYPETRACK
)
else
if
(
GetScreen
()
->
m_CurrentItem
->
m_StructType
==
TYPETRACK
)
{
{
//then an element is being edited - remove the last segment.
//
then an element is being edited - remove the last segment.
GetScreen
()
->
m_CurrentItem
=
GetScreen
()
->
m_CurrentItem
=
Delete_Segment
(
DC
,
(
TRACK
*
)
GetScreen
()
->
m_CurrentItem
);
Delete_Segment
(
DC
,
(
TRACK
*
)
GetScreen
()
->
m_CurrentItem
);
GetScreen
()
->
SetModify
();
GetScreen
()
->
SetModify
();
...
@@ -97,7 +98,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -97,7 +98,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
case
'O'
+
GR_KB_CTRL
:
case
'O'
+
GR_KB_CTRL
:
{
{
//try not to duplicate save, load code etc.
//
try not to duplicate save, load code etc.
wxCommandEvent
evt
;
wxCommandEvent
evt
;
evt
.
SetId
(
ID_LOAD_FILE
);
evt
.
SetId
(
ID_LOAD_FILE
);
Files_io
(
evt
);
Files_io
(
evt
);
...
@@ -106,7 +107,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -106,7 +107,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
case
'S'
+
GR_KB_CTRL
:
case
'S'
+
GR_KB_CTRL
:
{
{
//try not to duplicate save, load code etc.
//
try not to duplicate save, load code etc.
wxCommandEvent
evt
;
wxCommandEvent
evt
;
evt
.
SetId
(
ID_SAVE_BOARD
);
evt
.
SetId
(
ID_SAVE_BOARD
);
Files_io
(
evt
);
Files_io
(
evt
);
...
@@ -163,10 +164,18 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
...
@@ -163,10 +164,18 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
if
(
module
==
NULL
)
// no footprint found
if
(
module
==
NULL
)
// no footprint found
{
{
module
=
Locate_Prefered_Module
(
m_Pcb
,
CURSEUR_OFF_GRILLE
);
module
=
Locate_Prefered_Module
(
m_Pcb
,
CURSEUR_OFF_GRILLE
);
if
(
module
)
// a footprint is found, but locked or on an other layer
if
(
module
)
{
{
// a footprint is found, but locked or on an other layer
if
(
module
->
IsLocked
()
)
if
(
module
->
IsLocked
()
)
DisplayInfo
(
this
,
_
(
"Footprint found, but locked"
)
);
{
wxString
msg
;
msg
.
Printf
(
_
(
"Footprint %s found, but locked"
),
module
->
m_Reference
->
m_Text
.
GetData
()
);
DisplayInfo
(
this
,
msg
);
}
module
=
NULL
;
module
=
NULL
;
}
}
}
}
...
...
pcbnew/locate.cpp
View file @
2e4c17a8
...
@@ -426,7 +426,7 @@ EDA_BaseStruct* Locate_Cotation( BOARD* Pcb, int LayerSearch, int typeloc )
...
@@ -426,7 +426,7 @@ EDA_BaseStruct* Locate_Cotation( BOARD* Pcb, int LayerSearch, int typeloc )
pt_txt
=
Cotation
->
m_Text
;
pt_txt
=
Cotation
->
m_Text
;
if
(
pt_txt
)
if
(
pt_txt
)
{
{
if
(
pt_txt
->
Locate
(
ref_pos
)
)
if
(
pt_txt
->
HitTest
(
ref_pos
)
)
return
PtStruct
;
return
PtStruct
;
}
}
...
@@ -857,7 +857,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
...
@@ -857,7 +857,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
// hit-test the reference text
// hit-test the reference text
pt_txt_mod
=
module
->
m_Reference
;
pt_txt_mod
=
module
->
m_Reference
;
if
(
pt_txt_mod
->
Locate
(
ref_pos
)
)
if
(
pt_txt_mod
->
HitTest
(
ref_pos
)
)
{
{
if
(
PtModule
)
if
(
PtModule
)
*
PtModule
=
module
;
*
PtModule
=
module
;
...
@@ -866,7 +866,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
...
@@ -866,7 +866,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
// hit-test the value text
// hit-test the value text
pt_txt_mod
=
module
->
m_Value
;
pt_txt_mod
=
module
->
m_Value
;
if
(
pt_txt_mod
->
Locate
(
ref_pos
)
)
if
(
pt_txt_mod
->
HitTest
(
ref_pos
)
)
{
{
if
(
PtModule
)
if
(
PtModule
)
*
PtModule
=
module
;
*
PtModule
=
module
;
...
@@ -881,7 +881,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
...
@@ -881,7 +881,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
continue
;
continue
;
pt_txt_mod
=
(
TEXTE_MODULE
*
)
PtStruct
;
pt_txt_mod
=
(
TEXTE_MODULE
*
)
PtStruct
;
if
(
pt_txt_mod
->
Locate
(
ref_pos
)
)
if
(
pt_txt_mod
->
HitTest
(
ref_pos
)
)
{
{
if
(
PtModule
)
if
(
PtModule
)
*
PtModule
=
module
;
*
PtModule
=
module
;
...
@@ -1151,7 +1151,7 @@ TEXTE_PCB* Locate_Texte_Pcb( EDA_BaseStruct* PtStruct, int LayerSearch, int type
...
@@ -1151,7 +1151,7 @@ TEXTE_PCB* Locate_Texte_Pcb( EDA_BaseStruct* PtStruct, int LayerSearch, int type
if
(
PtStruct
->
m_StructType
!=
TYPETEXTE
)
if
(
PtStruct
->
m_StructType
!=
TYPETEXTE
)
continue
;
continue
;
TEXTE_PCB
*
pt_txt_pcb
=
(
TEXTE_PCB
*
)
PtStruct
;
TEXTE_PCB
*
pt_txt_pcb
=
(
TEXTE_PCB
*
)
PtStruct
;
if
(
pt_txt_pcb
->
Locate
(
ref
)
)
if
(
pt_txt_pcb
->
HitTest
(
ref
)
)
{
{
if
(
pt_txt_pcb
->
m_Layer
==
LayerSearch
)
if
(
pt_txt_pcb
->
m_Layer
==
LayerSearch
)
return
pt_txt_pcb
;
return
pt_txt_pcb
;
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment