Skip to content

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

mouse synchronization from PCBNEW to EESCHEMA

parent b0b3a6d5
Hide whitespace changes
Inline Side-by-side
Showing with 1436 additions and 1250 deletions
common/eda_dde.cpp
View file @ 51fc26e1
/////////////////////// ///////////////////////
// Name: eda_dde.cpp // // Name: eda_dde.cpp //
/////////////////////// ///////////////////////
// For compilers that support precompilation, includes "wx/wx.h". // For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h> #include <wx/wxprec.h>
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
// for all others, include the necessary headers // for all others, include the necessary headers
...@@ -23,186 +23,193 @@ ...@@ -23,186 +23,193 @@
#include "common.h" #include "common.h"
#include "macros.h" #include "macros.h"
#define ID_CONN "CAO_COM" wxString HOSTNAME( wxT( "localhost" ) );
wxString HOSTNAME(wxT("localhost"));
/* variables locales */ /* variables locales */
// buffers for read and write data in socket connections // buffers for read and write data in socket connections
#define IPC_BUF_SIZE 4096 #define IPC_BUF_SIZE 4096
char client_ipc_buffer[IPC_BUF_SIZE]; char client_ipc_buffer[IPC_BUF_SIZE];
char server_ipc_buffer[IPC_BUF_SIZE]; char server_ipc_buffer[IPC_BUF_SIZE];
wxServer * server; wxServer* server;
void (* RemoteFct)(char * cmd); void (*RemoteFct)(const char* cmd);
char buffcar[1024]; char buffcar[1024];
void SetupServerFunction(void (* remotefct)(char * remotecmd) ) void SetupServerFunction( void (*remotefct)(const char* remotecmd) )
{ {
RemoteFct = remotefct; RemoteFct = remotefct;
} }
/*****************************/ /*****************************/
/* Routines liees au SERVEUR */ /* Routines liees au SERVEUR */
/*****************************/ /*****************************/
/* Fonction d'initialisation d'un serveur socket /* Fonction d'initialisation d'un serveur socket
*/ */
WinEDA_Server * CreateServer(wxWindow * window, int service) WinEDA_Server* CreateServer( wxWindow* window, int service )
{ {
wxIPV4address addr; wxIPV4address addr;
// Create a new server // Create a new server
addr.Service(service); addr.Service( service );
server = new wxServer(addr); server = new wxServer( addr );
if(server) if( server )
{ {
server->SetNotify(wxSOCKET_CONNECTION_FLAG); server->SetNotify( wxSOCKET_CONNECTION_FLAG );
server->SetEventHandler(*window, ID_EDA_SOCKET_EVENT_SERV); server->SetEventHandler( *window, ID_EDA_SOCKET_EVENT_SERV );
server->Notify(TRUE); server->Notify( TRUE );
} }
return server; return server;
} }
/********************************************************/ /********************************************************/
void WinEDA_DrawFrame::OnSockRequest(wxSocketEvent& evt) void WinEDA_DrawFrame::OnSockRequest( wxSocketEvent& evt )
/********************************************************/ /********************************************************/
/* Fonction appelee a chaque demande d'un client /* Fonction appelee a chaque demande d'un client
*/ */
{ {
size_t len; size_t len;
wxSocketBase *sock = evt.GetSocket(); wxSocketBase* sock = evt.GetSocket();
switch (evt.GetSocketEvent()) switch( evt.GetSocketEvent() )
{ {
case wxSOCKET_INPUT: case wxSOCKET_INPUT:
sock->Read(server_ipc_buffer,1); sock->Read( server_ipc_buffer, 1 );
if( sock->LastCount() == 0 ) break; // No data: Occurs on open connection if( sock->LastCount() == 0 )
sock->Read(server_ipc_buffer+1,IPC_BUF_SIZE-2); break; // No data: Occurs on open connection
len = 1 + sock->LastCount();
server_ipc_buffer[len] = 0; sock->Read( server_ipc_buffer + 1, IPC_BUF_SIZE - 2 );
if(RemoteFct ) RemoteFct(server_ipc_buffer); len = 1 + sock->LastCount();
break; server_ipc_buffer[len] = 0;
if( RemoteFct )
case wxSOCKET_LOST: RemoteFct( server_ipc_buffer );
return; break;
break;
case wxSOCKET_LOST:
default: return;
wxPrintf( wxT("WinEDA_DrawFrame::OnSockRequest() error: Invalid event !")); break;
break;
} default:
wxPrintf( wxT( "WinEDA_DrawFrame::OnSockRequest() error: Invalid event !" ) );
break;
}
} }
/**************************************************************/ /**************************************************************/
void WinEDA_DrawFrame::OnSockRequestServer(wxSocketEvent& evt) void WinEDA_DrawFrame::OnSockRequestServer( wxSocketEvent& evt )
/**************************************************************/ /**************************************************************/
/* fonction appele lors d'une demande de connexion d'un client /* fonction appele lors d'une demande de connexion d'un client
*/ */
{ {
wxSocketBase *sock2; wxSocketBase* sock2;
wxSocketServer *server = (wxSocketServer *) evt.GetSocket(); wxSocketServer* server = (wxSocketServer*) evt.GetSocket();
sock2 = server->Accept(); sock2 = server->Accept();
if (sock2 == NULL) return; if( sock2 == NULL )
return;
sock2->Notify(TRUE); sock2->Notify( TRUE );
sock2->SetEventHandler(*this, ID_EDA_SOCKET_EVENT); sock2->SetEventHandler( *this, ID_EDA_SOCKET_EVENT );
sock2->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG); sock2->SetNotify( wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG );
} }
/****************************/ /****************************/
/* Routines liees au CLIENT */ /* Routines liees au CLIENT */
/*****************************/ /*****************************/
/********************************************/ /**************************************************/
bool SendCommand( int service, char * cmdline) bool SendCommand( int service, const char* cmdline )
/********************************************/ /**************************************************/
/* Used by a client to sent (by a socket connection) a data to a server.
- Open a Socket Client connection
- Send the buffer cmdline
- Close the socket connection
service is the service number for the TC/IP connection /* Used by a client to sent (by a socket connection) a data to a server.
*/ * - Open a Socket Client connection
* - Send the buffer cmdline
* - Close the socket connection
*
* service is the service number for the TC/IP connection
*/
{ {
wxSocketClient * sock_client; wxSocketClient* sock_client;
bool success = FALSE; bool success = FALSE;
wxIPV4address addr; wxIPV4address addr;
// Create a connexion // Create a connexion
addr.Hostname(HOSTNAME); addr.Hostname( HOSTNAME );
addr.Service(service); addr.Service( service );
// Mini-tutorial for Connect() :-) (JP CHARRAS Note: see wxWidgets: sockets/client.cpp sample) // Mini-tutorial for Connect() :-) (JP CHARRAS Note: see wxWidgets: sockets/client.cpp sample)
// --------------------------- // ---------------------------
// //
// There are two ways to use Connect(): blocking and non-blocking, // There are two ways to use Connect(): blocking and non-blocking,
// depending on the value passed as the 'wait' (2nd) parameter. // depending on the value passed as the 'wait' (2nd) parameter.
// //
// Connect(addr, true) will wait until the connection completes, // Connect(addr, true) will wait until the connection completes,
// returning true on success and false on failure. This call blocks // returning true on success and false on failure. This call blocks
// the GUI (this might be changed in future releases to honour the // the GUI (this might be changed in future releases to honour the
// wxSOCKET_BLOCK flag). // wxSOCKET_BLOCK flag).
// //
// Connect(addr, false) will issue a nonblocking connection request // Connect(addr, false) will issue a nonblocking connection request
// and return immediately. If the return value is true, then the // and return immediately. If the return value is true, then the
// connection has been already successfully established. If it is // connection has been already successfully established. If it is
// false, you must wait for the request to complete, either with // false, you must wait for the request to complete, either with
// WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
// events (please read the documentation). // events (please read the documentation).
// //
// WaitOnConnect() itself never blocks the GUI (this might change // WaitOnConnect() itself never blocks the GUI (this might change
// in the future to honour the wxSOCKET_BLOCK flag). This call will // in the future to honour the wxSOCKET_BLOCK flag). This call will
// return false on timeout, or true if the connection request // return false on timeout, or true if the connection request
// completes, which in turn might mean: // completes, which in turn might mean:
// //
// a) That the connection was successfully established // a) That the connection was successfully established
// b) That the connection request failed (for example, because // b) That the connection request failed (for example, because
// it was refused by the peer. // it was refused by the peer.
// //
// Use IsConnected() to distinguish between these two. // Use IsConnected() to distinguish between these two.
// //
// So, in a brief, you should do one of the following things: // So, in a brief, you should do one of the following things:
// //
// For blocking Connect: // For blocking Connect:
// //
// bool success = client->Connect(addr, true); // bool success = client->Connect(addr, true);
// //
// For nonblocking Connect: // For nonblocking Connect:
// //
// client->Connect(addr, false); // client->Connect(addr, false);
// //
// bool waitmore = true; // bool waitmore = true;
// while (! client->WaitOnConnect(seconds, millis) && waitmore ) // while (! client->WaitOnConnect(seconds, millis) && waitmore )
// { // {
// // possibly give some feedback to the user, // // possibly give some feedback to the user,
// // update waitmore if needed. // // update waitmore if needed.
// } // }
// bool success = client->IsConnected(); // bool success = client->IsConnected();
// //
// And that's all :-) // And that's all :-)
sock_client = new wxSocketClient();
sock_client->SetTimeout(2); // Time out in Seconds sock_client = new wxSocketClient();
sock_client->Connect(addr, FALSE); sock_client->SetTimeout( 2 ); // Time out in Seconds
sock_client->WaitOnConnect(0, 100); sock_client->Connect( addr, FALSE );
sock_client->WaitOnConnect( 0, 100 );
if (sock_client->Ok() && sock_client->IsConnected())
{ if( sock_client->Ok() && sock_client->IsConnected() )
success = TRUE; {
sock_client->SetFlags(wxSOCKET_NOWAIT /*wxSOCKET_WAITALL*/); success = TRUE;
sock_client->Write(cmdline, strlen(cmdline)); sock_client->SetFlags( wxSOCKET_NOWAIT /*wxSOCKET_WAITALL*/ );
} sock_client->Write( cmdline, strlen( cmdline ) );
}
sock_client->Close();
sock_client->Destroy(); sock_client->Close();
return success; sock_client->Destroy();
return success;
} }
eeschema/controle.cpp
View file @ 51fc26e1
/****************/ /****************/
/* controle.cpp */ /* controle.cpp */
/****************/ /****************/
#include "fctsys.h" #include "fctsys.h"
...@@ -21,345 +21,384 @@ ...@@ -21,345 +21,384 @@
/* variables externes */ /* variables externes */
#define MSG_TO_PCB KICAD_PCB_PORT_SERVICE_NUMBER
/**********************************/
void RemoteCommand( const char* cmdline )
/**********************************/
/* Read a remote command sent from pcbnew, so when user selects a module
* or pin in pcbnew, eeschema shows that same component or pin.
*/
{
char line[1024];
char* idcmd;
char* text;
strncpy( line, cmdline, sizeof(line) - 1 );
idcmd = strtok( line, " \n\r" );
text = strtok( NULL, " \n\r" );
if( (idcmd == NULL) || (text == NULL) )
return;
if( strcmp( idcmd, "$PART:" ) == 0 )
{
WinEDA_SchematicFrame* frame = EDA_Appl->SchematicFrame;
wxString msg = CONV_FROM_UTF8( text );
frame->FindSchematicItem( msg, 1, false );
}
}
/**************************************************************/ /**************************************************************/
EDA_BaseStruct * WinEDA_SchematicFrame:: EDA_BaseStruct* WinEDA_SchematicFrame::
SchematicGeneralLocateAndDisplay(bool IncludePin) SchematicGeneralLocateAndDisplay( bool IncludePin )
/**************************************************************/ /**************************************************************/
/* Routine de localisation et d'affichage des caract (si utile ) /* Routine de localisation et d'affichage des caract (si utile )
de l'element pointe par la souris ou par le curseur pcb * de l'element pointe par la souris ou par le curseur pcb
- marqueur * - marqueur
- noconnect * - noconnect
- jonction * - jonction
- wire/bus/entry * - wire/bus/entry
- label * - label
- composant * - composant
- pin * - pin
retourne * retourne
un pointeur sur le composant * un pointeur sur le composant
Null sinon * Null sinon
*/ */
{ {
EDA_BaseStruct *DrawStruct; EDA_BaseStruct* DrawStruct;
wxString msg; wxString msg;
wxPoint mouse_position = GetScreen()->m_MousePosition; wxPoint mouse_position = GetScreen()->m_MousePosition;
LibDrawPin * Pin = NULL; LibDrawPin* Pin = NULL;
EDA_SchComponentStruct * LibItem = NULL; EDA_SchComponentStruct* LibItem = NULL;
char Line[1024]; char Line[1024];
DrawStruct = SchematicGeneralLocateAndDisplay(mouse_position, IncludePin); DrawStruct = SchematicGeneralLocateAndDisplay( mouse_position, IncludePin );
if(! DrawStruct && ( mouse_position != GetScreen()->m_Curseur) ) if( !DrawStruct && ( mouse_position != GetScreen()->m_Curseur) )
{ {
DrawStruct = SchematicGeneralLocateAndDisplay(GetScreen()->m_Curseur, IncludePin); DrawStruct = SchematicGeneralLocateAndDisplay( GetScreen()->m_Curseur, IncludePin );
} }
if ( ! DrawStruct ) return NULL; if( !DrawStruct )
return NULL;
/* Cross probing to pcbnew if a pin or a component is found */
switch (DrawStruct->m_StructType ) /* Cross probing to pcbnew if a pin or a component is found */
{ switch( DrawStruct->m_StructType )
case COMPONENT_FIELD_DRAW_TYPE: {
{ case COMPONENT_FIELD_DRAW_TYPE:
PartTextStruct * Field = (PartTextStruct *) DrawStruct; {
LibItem = (EDA_SchComponentStruct * )Field->m_Parent; PartTextStruct* Field = (PartTextStruct*) DrawStruct;
sprintf(Line,"$PART: %s", CONV_TO_UTF8(LibItem->m_Field[REFERENCE].m_Text)); LibItem = (EDA_SchComponentStruct*) Field->m_Parent;
SendCommand(MSG_TO_PCB, Line); sprintf( Line, "$PART: %s", CONV_TO_UTF8( LibItem->m_Field[REFERENCE].m_Text ) );
} SendCommand( MSG_TO_PCB, Line );
break; }
break;
case DRAW_LIB_ITEM_STRUCT_TYPE:
Pin = LocateAnyPin(m_CurrentScreen->EEDrawList, GetScreen()->m_Curseur, &LibItem); case DRAW_LIB_ITEM_STRUCT_TYPE:
if ( Pin ) break; // Priority is probing a pin first Pin = LocateAnyPin( m_CurrentScreen->EEDrawList, GetScreen()->m_Curseur, &LibItem );
LibItem = (EDA_SchComponentStruct *) DrawStruct; if( Pin )
sprintf(Line,"$PART: %s", CONV_TO_UTF8(LibItem->m_Field[REFERENCE].m_Text) ); break; // Priority is probing a pin first
SendCommand(MSG_TO_PCB, Line); LibItem = (EDA_SchComponentStruct*) DrawStruct;
break; sprintf( Line, "$PART: %s", CONV_TO_UTF8( LibItem->m_Field[REFERENCE].m_Text ) );
SendCommand( MSG_TO_PCB, Line );
default: break;
Pin = LocateAnyPin(m_CurrentScreen->EEDrawList, GetScreen()->m_Curseur, &LibItem);
break; default:
Pin = LocateAnyPin( m_CurrentScreen->EEDrawList, GetScreen()->m_Curseur, &LibItem );
case COMPONENT_PIN_DRAW_TYPE: break;
Pin = (LibDrawPin*) DrawStruct;
break; case COMPONENT_PIN_DRAW_TYPE:
} Pin = (LibDrawPin*) DrawStruct;
break;
if ( Pin ) }
{
/* Force display pin infos (the previous display could be a component info) */ if( Pin )
Pin->Display_Infos(this); {
if ( LibItem ) /* Force display pin infos (the previous display could be a component info) */
Affiche_1_Parametre( this, 1, Pin->Display_Infos( this );
LibItem->m_Field[REFERENCE].m_Text, if( LibItem )
LibItem->m_Field[VALUE].m_Text, Affiche_1_Parametre( this, 1,
CYAN); LibItem->m_Field[REFERENCE].m_Text,
LibItem->m_Field[VALUE].m_Text,
// Cross probing:2 - pin found, and send a locate pin command to pcbnew (hightlight net) CYAN );
if(Pin->m_PinNum)
{ // Cross probing:2 - pin found, and send a locate pin command to pcbnew (hightlight net)
wxString pinnum; if( Pin->m_PinNum )
Pin->ReturnPinStringNum(pinnum); {
sprintf(Line,"$PIN: %s $PART: %s", CONV_TO_UTF8(pinnum), wxString pinnum;
CONV_TO_UTF8(LibItem->m_Field[REFERENCE].m_Text)); Pin->ReturnPinStringNum( pinnum );
SendCommand(MSG_TO_PCB, Line); sprintf( Line, "$PIN: %s $PART: %s", CONV_TO_UTF8( pinnum ),
} CONV_TO_UTF8( LibItem->m_Field[REFERENCE].m_Text ) );
} SendCommand( MSG_TO_PCB, Line );
return DrawStruct; }
}
return DrawStruct;
} }
/************************************************************************************/ /************************************************************************************/
EDA_BaseStruct * WinEDA_SchematicFrame:: EDA_BaseStruct* WinEDA_SchematicFrame::
SchematicGeneralLocateAndDisplay(const wxPoint & refpoint, bool IncludePin) SchematicGeneralLocateAndDisplay( const wxPoint& refpoint, bool IncludePin )
/************************************************************************************/ /************************************************************************************/
/* Find the schematic item at position "refpoint" /* Find the schematic item at position "refpoint"
the priority order is: * the priority order is:
- marker * - marker
- noconnect * - noconnect
- junction * - junction
- wire/bus/entry * - wire/bus/entry
- label * - label
- pin * - pin
- component * - component
return: * return:
an EDA_BaseStruct pointer on the item * an EDA_BaseStruct pointer on the item
a Null pointer if no item found * a Null pointer if no item found
*
For some items, caracteristics are displayed on the screen. * For some items, caracteristics are displayed on the screen.
*/ */
{ {
EDA_BaseStruct *DrawStruct; EDA_BaseStruct* DrawStruct;
LibDrawPin * Pin; LibDrawPin* Pin;
EDA_SchComponentStruct * LibItem; EDA_SchComponentStruct* LibItem;
wxString Text; wxString Text;
wxString msg; wxString msg;
int ii; int ii;
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList, MARKERITEM); DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList, MARKERITEM );
if( DrawStruct ) if( DrawStruct )
{ {
DrawMarkerStruct * Marker = (DrawMarkerStruct *) DrawStruct; DrawMarkerStruct* Marker = (DrawMarkerStruct*) DrawStruct;
ii = Marker->m_Type; ii = Marker->m_Type;
Text = Marker->GetComment(); Text = Marker->GetComment();
if(Text.IsEmpty() ) Text = wxT("NoComment"); if( Text.IsEmpty() )
msg = NameMarqueurType[ii]; msg << wxT(" << ") << Text; Text = wxT( "NoComment" );
Affiche_Message(msg); msg = NameMarqueurType[ii]; msg << wxT( " << " ) << Text;
return(DrawStruct); Affiche_Message( msg );
} return DrawStruct;
}
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList,
NOCONNECTITEM); DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList,
if( DrawStruct ) NOCONNECTITEM );
{ if( DrawStruct )
MsgPanel->EraseMsgBox(); {
return(DrawStruct); MsgPanel->EraseMsgBox();
} return DrawStruct;
}
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList,
JUNCTIONITEM); DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList,
if( DrawStruct ) JUNCTIONITEM );
{ if( DrawStruct )
MsgPanel->EraseMsgBox(); {
return(DrawStruct); MsgPanel->EraseMsgBox();
} return DrawStruct;
}
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList,
WIREITEM|BUSITEM|RACCORDITEM); DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList,
if( DrawStruct ) // Search for a pin WIREITEM | BUSITEM | RACCORDITEM );
{ if( DrawStruct ) // Search for a pin
Pin = LocateAnyPin(m_CurrentScreen->EEDrawList,refpoint, &LibItem); {
if( Pin ) Pin = LocateAnyPin( m_CurrentScreen->EEDrawList, refpoint, &LibItem );
{ if( Pin )
Pin->Display_Infos(this); {
if ( LibItem ) Pin->Display_Infos( this );
Affiche_1_Parametre( this, 1, if( LibItem )
LibItem->m_Field[REFERENCE].m_Text, Affiche_1_Parametre( this, 1,
LibItem->m_Field[VALUE].m_Text, LibItem->m_Field[REFERENCE].m_Text,
CYAN); LibItem->m_Field[VALUE].m_Text,
CYAN );
} }
else MsgPanel->EraseMsgBox(); else
return(DrawStruct); MsgPanel->EraseMsgBox();
} return DrawStruct;
}
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList, FIELDCMPITEM);
if( DrawStruct ) DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList, FIELDCMPITEM );
{ if( DrawStruct )
PartTextStruct * Field = (PartTextStruct *) DrawStruct; {
LibItem = (EDA_SchComponentStruct * )Field->m_Parent; PartTextStruct* Field = (PartTextStruct*) DrawStruct;
LibItem->Display_Infos(this); LibItem = (EDA_SchComponentStruct*) Field->m_Parent;
LibItem->Display_Infos( this );
return(DrawStruct);
} return DrawStruct;
}
/* search for a pin */
Pin = LocateAnyPin(m_CurrentScreen->EEDrawList, refpoint, &LibItem); /* search for a pin */
if( Pin ) Pin = LocateAnyPin( m_CurrentScreen->EEDrawList, refpoint, &LibItem );
{ if( Pin )
Pin->Display_Infos(this); {
if ( LibItem ) Pin->Display_Infos( this );
Affiche_1_Parametre( this, 1, if( LibItem )
LibItem->m_Field[REFERENCE].m_Text, Affiche_1_Parametre( this, 1,
LibItem->m_Field[VALUE].m_Text, LibItem->m_Field[REFERENCE].m_Text,
CYAN); LibItem->m_Field[VALUE].m_Text,
if ( IncludePin == TRUE ) return(LibItem); CYAN );
} if( IncludePin == TRUE )
return LibItem;
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList, LIBITEM); }
if( DrawStruct )
{ DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList, LIBITEM );
DrawStruct = LocateSmallestComponent( GetScreen() ); if( DrawStruct )
LibItem = (EDA_SchComponentStruct *) DrawStruct; {
LibItem->Display_Infos(this); DrawStruct = LocateSmallestComponent( GetScreen() );
return(DrawStruct); LibItem = (EDA_SchComponentStruct*) DrawStruct;
} LibItem->Display_Infos( this );
return DrawStruct;
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList, }
SHEETITEM);
if( DrawStruct ) DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList,
{ SHEETITEM );
((DrawSheetStruct*) DrawStruct)->Display_Infos(this); if( DrawStruct )
return(DrawStruct); {
} ( (DrawSheetStruct*) DrawStruct )->Display_Infos( this );
return DrawStruct;
// Recherche des autres elements }
DrawStruct = PickStruct(refpoint, GetScreen()->EEDrawList,
SEARCHALL); // Recherche des autres elements
if( DrawStruct ) DrawStruct = PickStruct( refpoint, GetScreen()->EEDrawList,
{ SEARCHALL );
return(DrawStruct); if( DrawStruct )
} {
return DrawStruct;
MsgPanel->EraseMsgBox(); }
return(NULL);
MsgPanel->EraseMsgBox();
return NULL;
} }
/***********************************************************************/ /***********************************************************************/
void WinEDA_DrawFrame::GeneralControle(wxDC *DC, wxPoint MousePositionInPixels) void WinEDA_DrawFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixels )
/***********************************************************************/ /***********************************************************************/
{ {
wxSize delta; wxSize delta;
int zoom = m_CurrentScreen->GetZoom(); int zoom = m_CurrentScreen->GetZoom();
wxPoint curpos, oldpos; wxPoint curpos, oldpos;
int hotkey = 0; int hotkey = 0;
ActiveScreen = (SCH_SCREEN *) m_CurrentScreen; ActiveScreen = (SCH_SCREEN*) m_CurrentScreen;
curpos = m_CurrentScreen->m_MousePosition; curpos = m_CurrentScreen->m_MousePosition;
oldpos = m_CurrentScreen->m_Curseur; oldpos = m_CurrentScreen->m_Curseur;
delta.x = m_CurrentScreen->GetGrid().x / zoom; delta.x = m_CurrentScreen->GetGrid().x / zoom;
delta.y = m_CurrentScreen->GetGrid().y / zoom; delta.y = m_CurrentScreen->GetGrid().y / zoom;
if( delta.x <= 0 ) delta.x = 1; if( delta.x <= 0 )
if( delta.y <= 0 ) delta.y = 1; delta.x = 1;
if( delta.y <= 0 )
switch( g_KeyPressed ) delta.y = 1;
{
case EDA_PANNING_UP_KEY : switch( g_KeyPressed )
OnZoom(ID_ZOOM_PANNING_UP); {
curpos = m_CurrentScreen->m_Curseur; case EDA_PANNING_UP_KEY:
break; OnZoom( ID_ZOOM_PANNING_UP );
case EDA_PANNING_DOWN_KEY : curpos = m_CurrentScreen->m_Curseur;
OnZoom(ID_ZOOM_PANNING_DOWN); break;
curpos = m_CurrentScreen->m_Curseur;
break; case EDA_PANNING_DOWN_KEY:
case EDA_PANNING_LEFT_KEY : OnZoom( ID_ZOOM_PANNING_DOWN );
OnZoom(ID_ZOOM_PANNING_LEFT); curpos = m_CurrentScreen->m_Curseur;
curpos = m_CurrentScreen->m_Curseur; break;
break;
case EDA_PANNING_RIGHT_KEY : case EDA_PANNING_LEFT_KEY:
OnZoom(ID_ZOOM_PANNING_RIGHT); OnZoom( ID_ZOOM_PANNING_LEFT );
curpos = m_CurrentScreen->m_Curseur; curpos = m_CurrentScreen->m_Curseur;
break; break;
case WXK_F1 :
OnZoom(ID_ZOOM_PLUS_KEY); case EDA_PANNING_RIGHT_KEY:
curpos = m_CurrentScreen->m_Curseur; OnZoom( ID_ZOOM_PANNING_RIGHT );
break; curpos = m_CurrentScreen->m_Curseur;
case WXK_F2 : break;
OnZoom(ID_ZOOM_MOINS_KEY);
curpos = m_CurrentScreen->m_Curseur; case WXK_F1:
break; OnZoom( ID_ZOOM_PLUS_KEY );
case WXK_F3 : curpos = m_CurrentScreen->m_Curseur;
OnZoom(ID_ZOOM_REDRAW_KEY); break;
break;
case WXK_F4 : case WXK_F2:
OnZoom(ID_ZOOM_CENTER_KEY); OnZoom( ID_ZOOM_MOINS_KEY );
curpos = m_CurrentScreen->m_Curseur; curpos = m_CurrentScreen->m_Curseur;
break; break;
case ' ': // Remise a zero coord relatives case WXK_F3:
m_CurrentScreen->m_O_Curseur = m_CurrentScreen->m_Curseur; OnZoom( ID_ZOOM_REDRAW_KEY );
break; break;
case WXK_NUMPAD8 : /* Deplacement curseur vers le haut */ case WXK_F4:
case WXK_UP : OnZoom( ID_ZOOM_CENTER_KEY );
MousePositionInPixels.y -= delta.y; curpos = m_CurrentScreen->m_Curseur;
DrawPanel->MouseTo(MousePositionInPixels); break;
break ;
case ' ': // Remise a zero coord relatives
case WXK_NUMPAD2: /* Deplacement curseur vers le bas */ m_CurrentScreen->m_O_Curseur = m_CurrentScreen->m_Curseur;
case WXK_DOWN: break;
MousePositionInPixels.y += delta.y;
DrawPanel->MouseTo(MousePositionInPixels); case WXK_NUMPAD8: /* Deplacement curseur vers le haut */
break ; case WXK_UP:
MousePositionInPixels.y -= delta.y;
case WXK_NUMPAD4: /* Deplacement curseur vers la gauche */ DrawPanel->MouseTo( MousePositionInPixels );
case WXK_LEFT : break;
MousePositionInPixels.x -= delta.x;
DrawPanel->MouseTo(MousePositionInPixels); case WXK_NUMPAD2: /* Deplacement curseur vers le bas */
break ; case WXK_DOWN:
MousePositionInPixels.y += delta.y;
case WXK_NUMPAD6: /* Deplacement curseur vers la droite */ DrawPanel->MouseTo( MousePositionInPixels );
case WXK_RIGHT: break;
MousePositionInPixels.x += delta.x;
DrawPanel->MouseTo(MousePositionInPixels); case WXK_NUMPAD4: /* Deplacement curseur vers la gauche */
break; case WXK_LEFT:
MousePositionInPixels.x -= delta.x;
default: hotkey = g_KeyPressed; DrawPanel->MouseTo( MousePositionInPixels );
break; break;
} case WXK_NUMPAD6: /* Deplacement curseur vers la droite */
case WXK_RIGHT:
/* Recalcul de la position du curseur schema */ MousePositionInPixels.x += delta.x;
m_CurrentScreen->m_Curseur = curpos; DrawPanel->MouseTo( MousePositionInPixels );
/* Placement sur la grille generale */ break;
PutOnGrid( & m_CurrentScreen->m_Curseur);
default:
if( m_CurrentScreen->IsRefreshReq() ) hotkey = g_KeyPressed;
{ break;
RedrawActiveWindow(DC, TRUE); }
}
/* Recalcul de la position du curseur schema */
if ( oldpos != m_CurrentScreen->m_Curseur ) m_CurrentScreen->m_Curseur = curpos;
{
curpos = m_CurrentScreen->m_Curseur; /* Placement sur la grille generale */
m_CurrentScreen->m_Curseur = oldpos; PutOnGrid( &m_CurrentScreen->m_Curseur );
DrawPanel->CursorOff(DC);
m_CurrentScreen->m_Curseur = curpos; if( m_CurrentScreen->IsRefreshReq() )
DrawPanel->CursorOn(DC); {
RedrawActiveWindow( DC, TRUE );
if(DrawPanel->ManageCurseur) }
{
DrawPanel->ManageCurseur(DrawPanel, DC, TRUE); if( oldpos != m_CurrentScreen->m_Curseur )
} {
} curpos = m_CurrentScreen->m_Curseur;
m_CurrentScreen->m_Curseur = oldpos;
Affiche_Status_Box(); /* Affichage des coord curseur */ DrawPanel->CursorOff( DC );
m_CurrentScreen->m_Curseur = curpos;
if ( hotkey ) DrawPanel->CursorOn( DC );
{
if( m_CurrentScreen->m_CurrentItem && if( DrawPanel->ManageCurseur )
m_CurrentScreen->m_CurrentItem->m_Flags ) {
OnHotKey(DC, hotkey, m_CurrentScreen->m_CurrentItem); DrawPanel->ManageCurseur( DrawPanel, DC, TRUE );
else OnHotKey(DC, hotkey, NULL); }
} }
Affiche_Status_Box(); /* Affichage des coord curseur */
if( hotkey )
{
if( m_CurrentScreen->m_CurrentItem
&& m_CurrentScreen->m_CurrentItem->m_Flags )
OnHotKey( DC, hotkey, m_CurrentScreen->m_CurrentItem );
else
OnHotKey( DC, hotkey, NULL );
}
} }
eeschema/eeschema.cpp
View file @ 51fc26e1
...@@ -20,10 +20,10 @@ ...@@ -20,10 +20,10 @@
#include "netlist.h" #include "netlist.h"
#include "worksheet.h" #include "worksheet.h"
#include "trigo.h" #include "trigo.h"
#include "protos.h" #include "protos.h"
#include "bitmaps.h" #include "bitmaps.h"
#include "eda_dde.h"
/* Routines locales */ /* Routines locales */
static void CreateScreens(void); static void CreateScreens(void);
...@@ -72,6 +72,13 @@ wxString FFileName; ...@@ -72,6 +72,13 @@ wxString FFileName;
SetTopWindow(SchematicFrame); SetTopWindow(SchematicFrame);
SchematicFrame->Show(TRUE); SchematicFrame->Show(TRUE);
if( CreateServer( SchematicFrame, KICAD_SCH_PORT_SERVICE_NUMBER ) )
{
// RemoteCommand is in controle.cpp and is called when PCBNEW
// sends EESCHEMA a command
SetupServerFunction( RemoteCommand );
}
SchematicFrame->Zoom_Automatique(TRUE); SchematicFrame->Zoom_Automatique(TRUE);
/* Load file specified in the command line. */ /* Load file specified in the command line. */
......
eeschema/find.cpp
View file @ 51fc26e1
/****************************************************************/ /****************************************************************/
/* EESchema: find.cpp (functions for seraching a schematic item */ /* EESchema: find.cpp (functions for seraching a schematic item */
/****************************************************************/ /****************************************************************/
/* /*
Search a text (text, value, reference) withing e composent or * Search a text (text, value, reference) withing e composent or
search a composant in libraries, a marker ..., * search a composant in libraries, a marker ...,
in current sheet or whole the project * in current sheet or whole the project
*/ */
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -15,7 +16,7 @@ ...@@ -15,7 +16,7 @@
#include "general.h" #include "general.h"
/* Variables Locales */ /* Variables Locales */
static int s_ItemsCount, s_MarkerCount; static int s_ItemsCount, s_MarkerCount;
static wxString s_OldStringFound; static wxString s_OldStringFound;
#include "dialog_find.cpp" #include "dialog_find.cpp"
...@@ -24,470 +25,534 @@ static wxString s_OldStringFound; ...@@ -24,470 +25,534 @@ static wxString s_OldStringFound;
#include "protos.h" #include "protos.h"
/**************************************************************/ /**************************************************************/
void InstallFindFrame(WinEDA_SchematicFrame *parent, wxPoint & pos) void InstallFindFrame( WinEDA_SchematicFrame* parent, wxPoint& pos )
/**************************************************************/ /**************************************************************/
{ {
parent->DrawPanel->m_IgnoreMouseEvents = TRUE; parent->DrawPanel->m_IgnoreMouseEvents = TRUE;
WinEDA_FindFrame * frame = new WinEDA_FindFrame(parent); WinEDA_FindFrame* frame = new WinEDA_FindFrame( parent );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
parent->DrawPanel->m_IgnoreMouseEvents = FALSE; parent->DrawPanel->m_IgnoreMouseEvents = FALSE;
} }
/**************************************************************/ /**************************************************************/
void WinEDA_FindFrame::FindMarker(wxCommandEvent& event) void WinEDA_FindFrame::FindMarker( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
/* Search de markers in whole the hierarchy. /* Search de markers in whole the hierarchy.
Mouse cursor is put on the marker * Mouse cursor is put on the marker
search the first marker, or next marker * search the first marker, or next marker
*/ */
{ {
int id = event.GetId(); int id = event.GetId();
if( id != FIND_NEXT_MARKER ) m_Parent->FindMarker(0);
else m_Parent->FindMarker(1); if( id != FIND_NEXT_MARKER )
m_Parent->FindMarker( 0 );
else
m_Parent->FindMarker( 1 );
Close(); Close();
} }
/*****************************************************************/ /*****************************************************************/
EDA_BaseStruct * WinEDA_SchematicFrame::FindMarker(int SearchType) EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
/*****************************************************************/ /*****************************************************************/
/* Search markers in whole the hierarchy. /* Search markers in whole the hierarchy.
Mouse cursor is put on the marker * Mouse cursor is put on the marker
SearchType = 0: search the first marker, else search next marker * SearchType = 0: search the first marker, else search next marker
*/ */
{ {
SCH_SCREEN * Screen, * FirstScreen = NULL; SCH_SCREEN* Screen, * FirstScreen = NULL;
EDA_BaseStruct *DrawList, *FirstStruct = NULL, *Struct = NULL; EDA_BaseStruct* DrawList, * FirstStruct = NULL, * Struct = NULL;
DrawMarkerStruct * Marker = NULL; DrawMarkerStruct* Marker = NULL;
int StartCount; int StartCount;
bool NotFound; bool NotFound;
wxPoint firstpos, pos; wxPoint firstpos, pos;
wxSize size = DrawPanel->GetClientSize(); wxSize size = DrawPanel->GetClientSize();
wxPoint curpos, old_cursor_position; wxPoint curpos, old_cursor_position;
bool force_recadre = FALSE; bool force_recadre = FALSE;
wxString msg, WildText; wxString msg, WildText;
g_LastSearchIsMarker = TRUE; g_LastSearchIsMarker = TRUE;
/* Set s_MarkerCount to 0 if we are look for the first marker */ /* Set s_MarkerCount to 0 if we are look for the first marker */
if( SearchType == 0 ) s_MarkerCount = 0; if( SearchType == 0 )
s_MarkerCount = 0;
EDA_ScreenList ScreenList(NULL);
NotFound = TRUE; StartCount = 0; EDA_ScreenList ScreenList( NULL );
/* Search for s_MarkerCount markers */
for ( Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() ) NotFound = TRUE; StartCount = 0;
{ /* Search for s_MarkerCount markers */
DrawList = Screen->EEDrawList; for( Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() )
while ( DrawList && NotFound ) {
{ DrawList = Screen->EEDrawList;
if(DrawList->m_StructType == DRAW_MARKER_STRUCT_TYPE ) while( DrawList && NotFound )
{ {
Marker = (DrawMarkerStruct *) DrawList; if( DrawList->m_StructType == DRAW_MARKER_STRUCT_TYPE )
NotFound = FALSE; {
pos = Marker->m_Pos; Marker = (DrawMarkerStruct*) DrawList;
if ( FirstScreen == NULL ) /* First item found */ NotFound = FALSE;
{ pos = Marker->m_Pos;
FirstScreen = Screen; firstpos = pos; if( FirstScreen == NULL ) /* First item found */
FirstStruct = DrawList; {
} FirstScreen = Screen; firstpos = pos;
FirstStruct = DrawList;
StartCount++; }
if( s_MarkerCount >= StartCount )
{ StartCount++;
NotFound = TRUE; /* Search for other markers */ if( s_MarkerCount >= StartCount )
} {
else /* We have found s_MarkerCount markers -> Ok */ NotFound = TRUE; /* Search for other markers */
{ }
Struct = DrawList; s_MarkerCount++; break ; else /* We have found s_MarkerCount markers -> Ok */
} {
} Struct = DrawList; s_MarkerCount++; break;
DrawList = DrawList->Pnext; }
} }
if( NotFound == FALSE ) break; DrawList = DrawList->Pnext;
} }
if( NotFound && FirstScreen ) // markers are found, but we have reach the last marker */ if( NotFound == FALSE )
{ // After the last marker, the first marker is used */ break;
NotFound = FALSE; Screen = FirstScreen; }
Struct = FirstStruct;
pos = firstpos; s_MarkerCount = 1; if( NotFound && FirstScreen ) // markers are found, but we have reach the last marker */
} { // After the last marker, the first marker is used */
NotFound = FALSE; Screen = FirstScreen;
if( NotFound == FALSE) Struct = FirstStruct;
{ pos = firstpos; s_MarkerCount = 1;
if ( Screen != GetScreen() ) }
{
Screen->SetZoom(GetScreen()->GetZoom() ); if( NotFound == FALSE )
m_CurrentScreen = ActiveScreen = Screen; {
force_recadre = TRUE; if( Screen != GetScreen() )
} {
Screen->SetZoom( GetScreen()->GetZoom() );
old_cursor_position = Screen->m_Curseur; m_CurrentScreen = ActiveScreen = Screen;
Screen->m_Curseur = pos; force_recadre = TRUE;
curpos = DrawPanel->CursorScreenPosition(); }
// calcul des coord curseur avec origine = screen
DrawPanel->GetViewStart(&m_CurrentScreen->m_StartVisu.x, old_cursor_position = Screen->m_Curseur;
&m_CurrentScreen->m_StartVisu.y); Screen->m_Curseur = pos;
curpos.x -= m_CurrentScreen->m_StartVisu.x; curpos = DrawPanel->CursorScreenPosition();
curpos.y -= m_CurrentScreen->m_StartVisu.y;
// calcul des coord curseur avec origine = screen
/* Il y a peut-etre necessite de recadrer le dessin: */ DrawPanel->GetViewStart( &m_CurrentScreen->m_StartVisu.x,
if( (curpos.x <= 0) || (curpos.x >= size.x-1) || &m_CurrentScreen->m_StartVisu.y );
(curpos.y <= 0) || (curpos.y >= size.y) || force_recadre ) curpos.x -= m_CurrentScreen->m_StartVisu.x;
{ curpos.y -= m_CurrentScreen->m_StartVisu.y;
Recadre_Trace(TRUE);
} /* Il y a peut-etre necessite de recadrer le dessin: */
else if( (curpos.x <= 0) || (curpos.x >= size.x - 1)
{ || (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre )
wxClientDC dc(DrawPanel); {
DrawPanel->PrepareGraphicContext(&dc); Recadre_Trace( TRUE );
EXCHG(old_cursor_position, Screen->m_Curseur); }
DrawPanel->CursorOff(&dc); else
GRMouseWarp(DrawPanel, curpos ); {
EXCHG(old_cursor_position, Screen->m_Curseur); wxClientDC dc( DrawPanel );
DrawPanel->CursorOn(&dc);
} DrawPanel->PrepareGraphicContext( &dc );
EXCHG( old_cursor_position, Screen->m_Curseur );
msg.Printf( _("Marker %d found in %s"), s_MarkerCount, Screen->m_FileName.GetData()); DrawPanel->CursorOff( &dc );
Affiche_Message(msg); GRMouseWarp( DrawPanel, curpos );
} EXCHG( old_cursor_position, Screen->m_Curseur );
DrawPanel->CursorOn( &dc );
else }
{
Affiche_Message(wxEmptyString); msg.Printf( _( "Marker %d found in %s" ), s_MarkerCount, Screen->m_FileName.GetData() );
msg = _("Marker Not Found"); Affiche_Message( msg );
DisplayError(this,msg, 10); }
} else
{
return Marker; Affiche_Message( wxEmptyString );
msg = _( "Marker Not Found" );
DisplayError( this, msg, 10 );
}
return Marker;
} }
/**************************************************************/ /**************************************************************/
void WinEDA_FindFrame::FindSchematicItem(wxCommandEvent& event) void WinEDA_FindFrame::FindSchematicItem( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
/* Find a string in schematic. /* Find a string in schematic.
Call to WinEDA_SchematicFrame::FindSchematicItem() * Call to WinEDA_SchematicFrame::FindSchematicItem()
*/ */
{ {
int id = event.GetId(); int id = event.GetId();
if( id == FIND_SHEET ) if( id == FIND_SHEET )
m_Parent->FindSchematicItem(m_NewTextCtrl->GetValue(), 0); m_Parent->FindSchematicItem( m_NewTextCtrl->GetValue(), 0 );
else if( id == FIND_HIERARCHY ) else if( id == FIND_HIERARCHY )
m_Parent->FindSchematicItem(m_NewTextCtrl->GetValue(), 1); m_Parent->FindSchematicItem( m_NewTextCtrl->GetValue(), 1 );
else if( id == FIND_NEXT ) else if( id == FIND_NEXT )
m_Parent->FindSchematicItem(wxEmptyString, 2); m_Parent->FindSchematicItem( wxEmptyString, 2 );
Close(); Close();
} }
/************************************************************************/ /************************************************************************/
EDA_BaseStruct * WinEDA_SchematicFrame::FindSchematicItem( EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
const wxString & pattern, int SearchType) const wxString& pattern, int SearchType, bool mouseWarp )
/************************************************************************/ /************************************************************************/
/* Find a string in schematic.
Search is made in current sheet (SearchType = 0), /**
or the whole hierarchy (SearchType = 1), * Function FindSchematicItem
or for the next item (SearchType = 2). * finds a string in the schematic.
Mouse cursor is put on item * @param pattern The text to search for, either in value, reference or elsewhere.
*/ * @param SearchType: 0 => Search is made in current sheet
* 1 => the whole hierarchy
* 2 => or for the next item
* @param mouseWarp If true, then move the mouse cursor to the item.
*/
{ {
SCH_SCREEN * Screen, * FirstScreen = NULL; SCH_SCREEN* Screen, * FirstScreen = NULL;
EDA_BaseStruct *DrawList = NULL, *FirstStruct = NULL, *Struct = NULL; EDA_BaseStruct* DrawList = NULL, * FirstStruct = NULL, * Struct = NULL;
int StartCount, ii, jj; int StartCount, ii, jj;
bool NotFound; bool NotFound;
wxPoint firstpos, pos, old_cursor_position; wxPoint firstpos, pos, old_cursor_position;
static int Find_in_hierarchy; static int Find_in_hierarchy;
wxSize size = DrawPanel->GetClientSize(); wxSize size = DrawPanel->GetClientSize();
wxPoint curpos; wxPoint curpos;
bool force_recadre = FALSE; bool force_recadre = FALSE;
wxString msg, WildText; wxString msg, WildText;
g_LastSearchIsMarker = FALSE; g_LastSearchIsMarker = FALSE;
if( SearchType == 0 ) if( SearchType == 0 )
{ {
s_OldStringFound = pattern; s_OldStringFound = pattern;
Find_in_hierarchy = FALSE; Find_in_hierarchy = FALSE;
} }
if( SearchType == 1 ) if( SearchType == 1 )
{ {
s_OldStringFound = pattern; s_OldStringFound = pattern;
Find_in_hierarchy = TRUE; Find_in_hierarchy = TRUE;
} }
if( SearchType != 2 ) s_ItemsCount = 0; if( SearchType != 2 )
s_ItemsCount = 0;
WildText = s_OldStringFound;
NotFound = TRUE; StartCount = 0; WildText = s_OldStringFound;
NotFound = TRUE;
EDA_ScreenList ScreenList(NULL); StartCount = 0;
Screen = ScreenList.GetFirst();
if ( ! Find_in_hierarchy ) Screen = (SCH_SCREEN*) m_CurrentScreen; EDA_ScreenList ScreenList( NULL );
for ( ; Screen != NULL; Screen = ScreenList.GetNext() ) Screen = ScreenList.GetFirst();
{ if( !Find_in_hierarchy )
DrawList = Screen->EEDrawList; Screen = (SCH_SCREEN*) m_CurrentScreen;
while ( DrawList )
{ for( ; Screen != NULL; Screen = ScreenList.GetNext() )
switch (DrawList->m_StructType) {
{ DrawList = Screen->EEDrawList;
case DRAW_LIB_ITEM_STRUCT_TYPE : while( DrawList )
#undef STRUCT {
#define STRUCT ((EDA_SchComponentStruct*)DrawList) switch( DrawList->m_StructType )
if( WildCompareString( WildText, STRUCT->m_Field[REFERENCE].m_Text, FALSE ) ) {
{ case DRAW_LIB_ITEM_STRUCT_TYPE:
NotFound = FALSE; EDA_SchComponentStruct* pSch;
pos = STRUCT->m_Field[REFERENCE].m_Pos; pSch = (EDA_SchComponentStruct*) DrawList;
break; if( WildCompareString( WildText, pSch->m_Field[REFERENCE].m_Text, FALSE ) )
} {
if( WildCompareString( WildText, STRUCT->m_Field[VALUE].m_Text, FALSE ) ) NotFound = FALSE;
{ pos = pSch->m_Field[REFERENCE].m_Pos;
NotFound = FALSE; break;
pos = STRUCT->m_Field[VALUE].m_Pos; }
} if( WildCompareString( WildText, pSch->m_Field[VALUE].m_Text, FALSE ) )
break; {
NotFound = FALSE;
case DRAW_LABEL_STRUCT_TYPE : pos = pSch->m_Field[VALUE].m_Pos;
case DRAW_GLOBAL_LABEL_STRUCT_TYPE : }
case DRAW_TEXT_STRUCT_TYPE : break;
#undef STRUCT
#define STRUCT ((DrawTextStruct*)DrawList) case DRAW_LABEL_STRUCT_TYPE:
if( WildCompareString( WildText, STRUCT->m_Text, FALSE ) ) case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
{ case DRAW_TEXT_STRUCT_TYPE:
NotFound = FALSE; DrawTextStruct* pDraw;
pos = STRUCT->m_Pos; pDraw = (DrawTextStruct*) DrawList;
} if( WildCompareString( WildText, pDraw->m_Text, FALSE ) )
break; {
NotFound = FALSE;
default: pos = pDraw->m_Pos;
break; }
} break;
if(NotFound == FALSE) /* Element trouve */ default:
{ break;
if ( FirstScreen == NULL ) /* 1er element trouve */ }
{
FirstScreen = Screen; firstpos = pos; if( NotFound == FALSE ) /* Element trouve */
FirstStruct = DrawList; {
} if( FirstScreen == NULL ) /* 1er element trouve */
{
StartCount++; FirstScreen = Screen;
if( s_ItemsCount >= StartCount ) firstpos = pos;
{ FirstStruct = DrawList;
NotFound = TRUE; /* Continue recherche de l'element suivant */ }
}
else StartCount++;
{ if( s_ItemsCount >= StartCount )
Struct = DrawList; s_ItemsCount++; break ; {
} NotFound = TRUE; /* Continue recherche de l'element suivant */
} }
if( NotFound == FALSE ) break; else
DrawList = DrawList->Pnext; {
} Struct = DrawList;
if( NotFound == FALSE ) break; s_ItemsCount++;
if( Find_in_hierarchy == FALSE ) break; break;
} }
}
if( NotFound && FirstScreen ) if( NotFound == FALSE )
{ break;
NotFound = FALSE; Screen = FirstScreen; Struct = FirstStruct; DrawList = DrawList->Pnext;
pos = firstpos; s_ItemsCount = 1; }
}
if( NotFound == FALSE )
if( NotFound == FALSE) break;
{
if ( Screen != GetScreen() ) if( Find_in_hierarchy == FALSE )
{ break;
Screen->SetZoom(GetScreen()->GetZoom() ); }
m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE; if( NotFound && FirstScreen )
} {
NotFound = FALSE;
/* Si la struct localisee est du type DRAW_LIB_ITEM_STRUCT_TYPE, Screen = FirstScreen;
Les coordonnes sont a recalculer en fonction de la matrice Struct = FirstStruct;
d'orientation */ pos = firstpos;
if( Struct->m_StructType == DRAW_LIB_ITEM_STRUCT_TYPE ) s_ItemsCount = 1;
{ }
#undef STRUCT
#define STRUCT ((EDA_SchComponentStruct*)Struct) if( NotFound == FALSE )
pos.x -= STRUCT->m_Pos.x; pos.y -= STRUCT->m_Pos.y; {
ii = STRUCT->m_Transform[0][0] * pos.x + STRUCT->m_Transform[0][1] * pos.y; if( Screen != GetScreen() )
jj = STRUCT->m_Transform[1][0] * pos.x + STRUCT->m_Transform[1][1] * pos.y; {
pos.x = ii + STRUCT->m_Pos.x; pos.y = jj + STRUCT->m_Pos.y; Screen->SetZoom( GetScreen()->GetZoom() );
} m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE;
old_cursor_position = Screen->m_Curseur; }
Screen->m_Curseur = pos;
curpos = DrawPanel->CursorScreenPosition(); /* Si la struct localisee est du type DRAW_LIB_ITEM_STRUCT_TYPE,
DrawPanel->GetViewStart(&m_CurrentScreen->m_StartVisu.x, * Les coordonnes sont a recalculer en fonction de la matrice
&m_CurrentScreen->m_StartVisu.y); * d'orientation */
if( Struct->m_StructType == DRAW_LIB_ITEM_STRUCT_TYPE )
// calcul des coord curseur avec origine = screen {
curpos.x -= m_CurrentScreen->m_StartVisu.x; EDA_SchComponentStruct* pSch = (EDA_SchComponentStruct*) Struct;
curpos.y -= m_CurrentScreen->m_StartVisu.y;
pos.x -= pSch->m_Pos.x;
/* Il y a peut-etre necessite de recadrer le dessin: */ pos.y -= pSch->m_Pos.y;
if( (curpos.x <= 0) || (curpos.x >= size.x-1) ||
(curpos.y <= 0) || (curpos.y >= size.y) || force_recadre ) ii = pSch->m_Transform[0][0] * pos.x + pSch->m_Transform[0][1] * pos.y;
{ jj = pSch->m_Transform[1][0] * pos.x + pSch->m_Transform[1][1] * pos.y;
Recadre_Trace(TRUE);
} pos.x = ii + pSch->m_Pos.x;
else pos.y = jj + pSch->m_Pos.y;
{ }
wxClientDC dc(DrawPanel);
DrawPanel->PrepareGraphicContext(&dc); old_cursor_position = Screen->m_Curseur;
EXCHG(old_cursor_position, Screen->m_Curseur); Screen->m_Curseur = pos;
DrawPanel->CursorOff(&dc);
GRMouseWarp(DrawPanel, curpos ); curpos = DrawPanel->CursorScreenPosition();
EXCHG(old_cursor_position, Screen->m_Curseur);
DrawPanel->CursorOn(&dc); DrawPanel->GetViewStart(
} &m_CurrentScreen->m_StartVisu.x,
&m_CurrentScreen->m_StartVisu.y );
msg = WildText + _(" Found in ") + Screen->m_FileName;
Affiche_Message(msg); // calcul des coord curseur avec origine = screen
} curpos.x -= m_CurrentScreen->m_StartVisu.x;
curpos.y -= m_CurrentScreen->m_StartVisu.y;
else
{ /* Il y a peut-etre necessite de recadrer le dessin: */
Affiche_Message(wxEmptyString); if( (curpos.x <= 0) || (curpos.x >= size.x - 1)
msg = WildText + _(" Not Found"); || (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre )
DisplayError(this,msg, 10); {
} Recadre_Trace( mouseWarp );
}
return DrawList; else
{
wxClientDC dc( DrawPanel );
DrawPanel->PrepareGraphicContext( &dc );
EXCHG( old_cursor_position, Screen->m_Curseur );
DrawPanel->CursorOff( &dc );
if( mouseWarp )
GRMouseWarp( DrawPanel, curpos );
EXCHG( old_cursor_position, Screen->m_Curseur );
DrawPanel->CursorOn( &dc );
}
msg = WildText + _( " Found in " ) + Screen->m_FileName;
Affiche_Message( msg );
}
else
{
Affiche_Message( wxEmptyString );
if( !mouseWarp )
{
// if called from RemoteCommand() don't popup the dialog which
// needs to be dismissed, user is in PCBNEW, and does'nt want to
// bother with dismissing the dialog in EESCHEMA.
msg = WildText + _( " Not Found" );
DisplayError( this, msg, 10 );
}
}
return DrawList;
} }
/*************************************************************/ /*************************************************************/
void WinEDA_FindFrame::LocatePartInLibs(wxCommandEvent& event) void WinEDA_FindFrame::LocatePartInLibs( wxCommandEvent& event )
/*************************************************************/ /*************************************************************/
/* Recherche exhaustive d'un composant en librairies, meme non chargees /* Recherche exhaustive d'un composant en librairies, meme non chargees
*/ */
{ {
wxString Text, FindList; wxString Text, FindList;
const wxChar ** ListNames; const wxChar** ListNames;
LibraryStruct *Lib = NULL; LibraryStruct* Lib = NULL;
EDA_LibComponentStruct * LibEntry; EDA_LibComponentStruct* LibEntry;
bool FoundInLib = FALSE; // True si reference trouvee ailleurs qu'en cache bool FoundInLib = FALSE; // True si reference trouvee ailleurs qu'en cache
Text = m_NewTextCtrl->GetValue(); Text = m_NewTextCtrl->GetValue();
if ( Text.IsEmpty() ) if( Text.IsEmpty() )
{ {
Close(); return; Close(); return;
} }
s_OldStringFound = Text; s_OldStringFound = Text;
int ii, nbitems, NumOfLibs = NumOfLibraries(); int ii, nbitems, NumOfLibs = NumOfLibraries();
if (NumOfLibs == 0) if( NumOfLibs == 0 )
{ {
DisplayError(this, _("No libraries are loaded")); DisplayError( this, _( "No libraries are loaded" ) );
Close(); return; Close(); return;
} }
ListNames = GetLibNames(); ListNames = GetLibNames();
nbitems = 0; nbitems = 0;
for (ii = 0; ii < NumOfLibs; ii++ ) /* Recherche de la librairie */ for( ii = 0; ii < NumOfLibs; ii++ ) /* Recherche de la librairie */
{ {
bool IsLibCache; bool IsLibCache;
Lib = FindLibrary(ListNames[ii]); Lib = FindLibrary( ListNames[ii] );
if ( Lib == NULL ) break; if( Lib == NULL )
if ( Lib->m_Name.Contains( wxT(".cache")) ) IsLibCache = TRUE; break;
else IsLibCache = FALSE; if( Lib->m_Name.Contains( wxT( ".cache" ) ) )
LibEntry = (EDA_LibComponentStruct *) PQFirst(&Lib->m_Entries, FALSE); IsLibCache = TRUE;
while( LibEntry ) else
{ IsLibCache = FALSE;
if( WildCompareString(Text, LibEntry->m_Name.m_Text, FALSE) ) LibEntry = (EDA_LibComponentStruct*) PQFirst( &Lib->m_Entries, FALSE );
{ while( LibEntry )
nbitems ++; {
if ( ! IsLibCache ) FoundInLib = TRUE; if( WildCompareString( Text, LibEntry->m_Name.m_Text, FALSE ) )
if ( ! FindList.IsEmpty() ) FindList += wxT("\n"); {
FindList << _("Found ") nbitems++;
+ LibEntry->m_Name.m_Text if( !IsLibCache )
+ _(" in lib ") + Lib->m_Name; FoundInLib = TRUE;
} if( !FindList.IsEmpty() )
LibEntry = (EDA_LibComponentStruct *) PQNext(Lib->m_Entries, LibEntry, NULL); FindList += wxT( "\n" );
} FindList << _( "Found " )
} + LibEntry->m_Name.m_Text
+ _( " in lib " ) + Lib->m_Name;
free (ListNames); }
LibEntry = (EDA_LibComponentStruct*) PQNext( Lib->m_Entries, LibEntry, NULL );
if ( ! FoundInLib ) }
{ }
if ( nbitems ) FindList = wxT("\n") + Text + _(" found only in cache");
else FindList = Text + _(" not found"); free( ListNames );
FindList += _("\nExplore All Libraries?");
if ( IsOK(this, FindList) ) if( !FoundInLib )
{ {
FindList.Empty(); if( nbitems )
ExploreAllLibraries(Text, FindList); FindList = wxT( "\n" ) + Text + _( " found only in cache" );
if ( FindList.IsEmpty() ) DisplayInfo(this, _("Nothing found") ); else
else DisplayInfo(this, FindList); FindList = Text + _( " not found" );
} FindList += _( "\nExplore All Libraries?" );
} if( IsOK( this, FindList ) )
else DisplayInfo(this, FindList); {
FindList.Empty();
Close(); ExploreAllLibraries( Text, FindList );
if( FindList.IsEmpty() )
DisplayInfo( this, _( "Nothing found" ) );
else
DisplayInfo( this, FindList );
}
}
else
DisplayInfo( this, FindList );
Close();
} }
/***************************************************************************************/ /***************************************************************************************/
int WinEDA_FindFrame::ExploreAllLibraries(const wxString & wildmask, wxString & FindList) int WinEDA_FindFrame::ExploreAllLibraries( const wxString& wildmask, wxString& FindList )
/***************************************************************************************/ /***************************************************************************************/
{ {
wxString FullFileName; wxString FullFileName;
FILE * file; FILE* file;
int nbitems = 0, LineNum = 0; int nbitems = 0, LineNum = 0;
char Line[2048], *name; char Line[2048], * name;
FullFileName = MakeFileName(g_RealLibDirBuffer, wxT("*"), g_LibExtBuffer); FullFileName = MakeFileName( g_RealLibDirBuffer, wxT( "*" ), g_LibExtBuffer );
FullFileName = wxFindFirstFile(FullFileName); FullFileName = wxFindFirstFile( FullFileName );
while ( ! FullFileName.IsEmpty() ) while( !FullFileName.IsEmpty() )
{ {
file = wxFopen(FullFileName, wxT("rt")); file = wxFopen( FullFileName, wxT( "rt" ) );
if (file == NULL) continue; if( file == NULL )
continue;
while (GetLine(file, Line, &LineNum, sizeof(Line)) )
{ while( GetLine( file, Line, &LineNum, sizeof(Line) ) )
if (strnicmp(Line, "DEF", 3) == 0) {
{ /* Read one DEF part from library: DEF 74LS00 U 0 30 Y Y 4 0 N */ if( strnicmp( Line, "DEF", 3 ) == 0 )
strtok(Line, " \t\r\n"); { /* Read one DEF part from library: DEF 74LS00 U 0 30 Y Y 4 0 N */
name = strtok(NULL, " \t\r\n"); strtok( Line, " \t\r\n" );
wxString st_name = CONV_FROM_UTF8(name); name = strtok( NULL, " \t\r\n" );
if( WildCompareString(wildmask, st_name, FALSE) ) wxString st_name = CONV_FROM_UTF8( name );
{ if( WildCompareString( wildmask, st_name, FALSE ) )
nbitems ++; {
if ( ! FindList.IsEmpty() ) FindList += wxT("\n"); nbitems++;
FindList << _("Found ") << CONV_FROM_UTF8(name) if( !FindList.IsEmpty() )
<< _(" in lib ") << FullFileName; FindList += wxT( "\n" );
} FindList << _( "Found " ) << CONV_FROM_UTF8( name )
} << _( " in lib " ) << FullFileName;
else if (strnicmp(Line, "ALIAS", 5) == 0) }
{ /* Read one ALIAS part from library: ALIAS 74HC00 74HCT00 7400 74LS37 */ }
strtok(Line, " \t\r\n"); else if( strnicmp( Line, "ALIAS", 5 ) == 0 )
while ( (name = strtok(NULL, " \t\r\n")) != NULL ) { /* Read one ALIAS part from library: ALIAS 74HC00 74HCT00 7400 74LS37 */
{ strtok( Line, " \t\r\n" );
wxString st_name = CONV_FROM_UTF8(name); while( ( name = strtok( NULL, " \t\r\n" ) ) != NULL )
if( WildCompareString( wildmask, st_name, FALSE) ) {
{ wxString st_name = CONV_FROM_UTF8( name );
nbitems ++; if( WildCompareString( wildmask, st_name, FALSE ) )
if ( ! FindList.IsEmpty() ) FindList += wxT("\n"); {
FindList << _("Found ") << CONV_FROM_UTF8(name) nbitems++;
<< _(" in lib ") << FullFileName; if( !FindList.IsEmpty() )
} FindList += wxT( "\n" );
} FindList << _( "Found " ) << CONV_FROM_UTF8( name )
} << _( " in lib " ) << FullFileName;
} }
fclose(file); }
FullFileName = wxFindNextFile(); }
} }
return nbitems; fclose( file );
FullFileName = wxFindNextFile();
}
return nbitems;
} }
eeschema/protos.h
View file @ 51fc26e1
...@@ -456,4 +456,8 @@ void InstallFindFrame(WinEDA_SchematicFrame *parent, wxPoint &pos); ...@@ -456,4 +456,8 @@ void InstallFindFrame(WinEDA_SchematicFrame *parent, wxPoint &pos);
/***************/ /***************/
void DisplayOptionFrame(WinEDA_DrawFrame * parent, const wxPoint & framepos); void DisplayOptionFrame(WinEDA_DrawFrame * parent, const wxPoint & framepos);
/****************/
/* CONTROLE.CPP */
/****************/
void RemoteCommand( const char* cmdline );
eeschema/schframe.cpp
View file @ 51fc26e1
...@@ -26,6 +26,9 @@ ...@@ -26,6 +26,9 @@
BEGIN_EVENT_TABLE(WinEDA_SchematicFrame, wxFrame) BEGIN_EVENT_TABLE(WinEDA_SchematicFrame, wxFrame)
COMMON_EVENTS_DRAWFRAME COMMON_EVENTS_DRAWFRAME
EVT_SOCKET(ID_EDA_SOCKET_EVENT_SERV, WinEDA_DrawFrame::OnSockRequestServer)
EVT_SOCKET(ID_EDA_SOCKET_EVENT, WinEDA_DrawFrame::OnSockRequest)
EVT_CLOSE(WinEDA_SchematicFrame::OnCloseWindow) EVT_CLOSE(WinEDA_SchematicFrame::OnCloseWindow)
EVT_SIZE(WinEDA_SchematicFrame::OnSize) EVT_SIZE(WinEDA_SchematicFrame::OnSize)
......
include/appl_wxstruct.h
View file @ 51fc26e1
/************************************************************/ /************************************************************/
/* appl_wxstruct.h: */ /* appl_wxstruct.h: */
/* descriptions des principales classes derivees utilisees: */ /* descriptions des principales classes derivees utilisees: */
/* Class "EDA_Appl: classe de l'application generale */ /* Class "EDA_Appl: classe de l'application generale */
/************************************************************/ /************************************************************/
/* Ce fichier doit etre inclus dans "wxstruct.h" /* Ce fichier doit etre inclus dans "wxstruct.h"
*/ */
#ifndef APPL_WXSTRUCT_H #ifndef APPL_WXSTRUCT_H
#define APPL_WXSTRUCT_H #define APPL_WXSTRUCT_H
...@@ -15,79 +15,77 @@ ...@@ -15,79 +15,77 @@
#endif #endif
/**********************************************/ /**********************************************/
/* Class representing the entire Application */ /* Class representing the entire Application */
/**********************************************/ /**********************************************/
eda_global WinEDA_App * EDA_Appl; /* application representant le programme */ eda_global WinEDA_App* EDA_Appl; /* application representant le programme */
class WinEDA_App: public wxApp class WinEDA_App : public wxApp
{ {
public: public:
wxString m_Project; wxString m_Project;
wxSingleInstanceChecker * m_Checker; wxSingleInstanceChecker* m_Checker;
WinEDA_MainFrame * m_MainFrame; WinEDA_MainFrame* m_MainFrame;
WinEDA_PcbFrame * m_PcbFrame; WinEDA_PcbFrame* m_PcbFrame;
WinEDA_ModuleEditFrame * m_ModuleEditFrame; WinEDA_ModuleEditFrame* m_ModuleEditFrame;
WinEDA_GerberFrame * m_GerberFrame; WinEDA_GerberFrame* m_GerberFrame;
WinEDA_SchematicFrame * SchematicFrame; // Edition des Schemas WinEDA_SchematicFrame* SchematicFrame; // Edition des Schemas
WinEDA_LibeditFrame * LibeditFrame; // Edition des composants WinEDA_LibeditFrame* LibeditFrame; // Edition des composants
WinEDA_ViewlibFrame * ViewlibFrame; // Visualisation des composants WinEDA_ViewlibFrame* ViewlibFrame; // Visualisation des composants
WinEDA_CvpcbFrame * m_CvpcbFrame; WinEDA_CvpcbFrame* m_CvpcbFrame;
wxPoint m_HelpPos; wxPoint m_HelpPos;
wxSize m_HelpSize; wxSize m_HelpSize;
wxHtmlHelpController * m_HtmlCtrl; wxHtmlHelpController* m_HtmlCtrl;
wxConfig * m_EDA_Config; // Config courante (tailles et positions fenetres ...*/ wxConfig* m_EDA_Config; // Config courante (tailles et positions fenetres ...*/
wxConfig * m_EDA_CommonConfig; // common setup (language ...) */ wxConfig* m_EDA_CommonConfig; // common setup (language ...) */
wxString m_HelpFileName; wxString m_HelpFileName;
wxString m_CurrentOptionFile; // dernier fichier .cnf utilis wxString m_CurrentOptionFile; // dernier fichier .cnf utilis
wxString m_CurrentOptionFileDateAndTime; wxString m_CurrentOptionFileDateAndTime;
wxString m_BinDir; /* Chemin ou reside l'executable wxString m_BinDir; /* Chemin ou reside l'executable
(utilis si KICAD non dfini)*/ * (utilis si KICAD non dfini)*/
wxArrayString m_LastProject; /* liste des derniers projets chargs */ wxArrayString m_LastProject; /* liste des derniers projets chargs */
unsigned int m_LastProjectMaxCount; /* Max histhory file length */ unsigned int m_LastProjectMaxCount; /* Max histhory file length */
wxString m_KicadEnv; /* Chemin de kicad dfini dans la variable wxString m_KicadEnv;/* Chemin de kicad dfini dans la variable
d'environnement KICAD, * d'environnement KICAD,
typiquement /usr/local/kicad ou c:\kicad */ * typiquement /usr/local/kicad ou c:\kicad */
bool m_Env_Defined; // TRUE si variable d'environnement KICAD definie bool m_Env_Defined; // TRUE si variable d'environnement KICAD definie
wxLocale * m_Locale; // Gestion de la localisation wxLocale* m_Locale; // Gestion de la localisation
int m_LanguageId; // indicateur de choix du langage ( 0 = defaut) int m_LanguageId; // indicateur de choix du langage ( 0 = defaut)
wxMenu * m_Language_Menu; // List menu for languages wxMenu* m_Language_Menu; // List menu for languages
wxString m_PdfBrowser; // Name of the selected browser, for browsing pdf datasheets wxString m_PdfBrowser; // Name of the selected browser, for browsing pdf datasheets
bool m_PdfBrowserIsDefault; // True if the pdf browser is the default (m_PdfBrowser not used) bool m_PdfBrowserIsDefault; // True if the pdf browser is the default (m_PdfBrowser not used)
public: public:
WinEDA_App(void); WinEDA_App( void );
~WinEDA_App(void); ~WinEDA_App( void );
bool OnInit(void); bool OnInit( void );
int OnRun(void); int OnRun( void );
bool SetBinDir(void); bool SetBinDir( void );
void InitEDA_Appl(const wxString & name); void InitEDA_Appl( const wxString& name );
bool SetLanguage(bool first_time = FALSE); bool SetLanguage( bool first_time = FALSE );
wxMenu * SetLanguageList(wxMenu * MasterMenu); wxMenu* SetLanguageList( wxMenu* MasterMenu );
void SetLanguageIdentifier(int menu_id); void SetLanguageIdentifier( int menu_id );
void InitOnLineHelp(void); void InitOnLineHelp( void );
// Sauvegarde de configurations et options: // Sauvegarde de configurations et options:
void GetSettings(void); void GetSettings( void );
void SaveSettings(void); void SaveSettings( void );
void SetLastProject(const wxString & FullFileName); void SetLastProject( const wxString& FullFileName );
void WriteProjectConfig(const wxString & local_config_filename, void WriteProjectConfig( const wxString& local_config_filename,
const wxString & GroupName, PARAM_CFG_BASE ** List); const wxString& GroupName, PARAM_CFG_BASE** List );
bool ReadProjectConfig(const wxString & local_config_filename, bool ReadProjectConfig( const wxString& local_config_filename,
const wxString & GroupName, PARAM_CFG_BASE ** List, const wxString& GroupName, PARAM_CFG_BASE** List,
bool Load_Only_if_New); bool Load_Only_if_New );
void ReadPdfBrowserInfos(void); void ReadPdfBrowserInfos( void );
void WritePdfBrowserInfos(void); void WritePdfBrowserInfos( void );
}; };
#endif /* APPL_WXSTRUCT_H */ #endif /* APPL_WXSTRUCT_H */
include/common.h
View file @ 51fc26e1
/****************************/ /****************************/
/* common.h */ /* common.h */
/****************************/ /****************************/
#ifndef COMMON_H #ifndef COMMON_H
#define COMMON_H #define COMMON_H
...@@ -12,27 +12,24 @@ ...@@ -12,27 +12,24 @@
#define COMMON_GLOBL extern #define COMMON_GLOBL extern
#endif #endif
/* Numero de ports TCP/IP utilis�s par KICAD */
#define KICAD_PCB_PORT_SERVICE_NUMBER 4242
/* Etat des touches speciales du clavier */ /* Etat des touches speciales du clavier */
#define GR_KB_RIGHTSHIFT 0x10000000 /* Keybd states: right shift key depressed */ #define GR_KB_RIGHTSHIFT 0x10000000 /* Keybd states: right shift key depressed */
#define GR_KB_LEFTSHIFT 0x20000000 /* left shift key depressed */ #define GR_KB_LEFTSHIFT 0x20000000 /* left shift key depressed */
#define GR_KB_CTRL 0x40000000 /* CTRL depressed */ #define GR_KB_CTRL 0x40000000 /* CTRL depressed */
#define GR_KB_ALT 0x80000000 /* ALT depressed */ #define GR_KB_ALT 0x80000000 /* ALT depressed */
#define GR_KB_SHIFT (GR_KB_LEFTSHIFT | GR_KB_RIGHTSHIFT) #define GR_KB_SHIFT (GR_KB_LEFTSHIFT | GR_KB_RIGHTSHIFT)
#define GR_KB_SHIFTCTRL (GR_KB_SHIFT | GR_KB_CTRL) #define GR_KB_SHIFTCTRL (GR_KB_SHIFT | GR_KB_CTRL)
#define MOUSE_MIDDLE 0x10000 /* flag indiquant bouton central souris */ #define MOUSE_MIDDLE 0x10000 /* flag indiquant bouton central souris */
/* Pseudo key codes for commands liske panning */ /* Pseudo key codes for commands liske panning */
enum pseudokeys { enum pseudokeys {
EDA_PANNING_UP_KEY = 2000, EDA_PANNING_UP_KEY = 2000,
EDA_PANNING_DOWN_KEY, EDA_PANNING_DOWN_KEY,
EDA_PANNING_LEFT_KEY, EDA_PANNING_LEFT_KEY,
EDA_PANNING_RIGHT_KEY EDA_PANNING_RIGHT_KEY
}; };
#define ESC 27 #define ESC 27
...@@ -65,8 +62,8 @@ enum pseudokeys { ...@@ -65,8 +62,8 @@ enum pseudokeys {
#define TEXT_ORIENT_VERT 900 #define TEXT_ORIENT_VERT 900
/* Affichage ou Effacement d'Item */ /* Affichage ou Effacement d'Item */
#define ON 1 /* Affichage */ #define ON 1 /* Affichage */
#define OFF 0 /* Effacement */ #define OFF 0 /* Effacement */
/* unites d'affichage sur ecran et autres */ /* unites d'affichage sur ecran et autres */
#define INCHES 0 #define INCHES 0
...@@ -77,15 +74,15 @@ enum pseudokeys { ...@@ -77,15 +74,15 @@ enum pseudokeys {
class LibNameList; class LibNameList;
/* definifition des types de parametre des files de configuration */ /* definifition des types de parametre des files de configuration */
enum paramcfg_id /* type du parametre dans la structure ParamConfig */ enum paramcfg_id /* type du parametre dans la structure ParamConfig */
{ {
PARAM_INT, PARAM_INT,
PARAM_SETCOLOR, PARAM_SETCOLOR,
PARAM_DOUBLE, PARAM_DOUBLE,
PARAM_BOOL, PARAM_BOOL,
PARAM_LIBNAME_LIST, PARAM_LIBNAME_LIST,
PARAM_WXSTRING, PARAM_WXSTRING,
PARAM_COMMAND_ERASE PARAM_COMMAND_ERASE
}; };
#define MAX_COLOR 0x8001F #define MAX_COLOR 0x8001F
...@@ -95,112 +92,112 @@ enum paramcfg_id /* type du parametre dans la structure ParamConfig */ ...@@ -95,112 +92,112 @@ enum paramcfg_id /* type du parametre dans la structure ParamConfig */
class PARAM_CFG_BASE class PARAM_CFG_BASE
{ {
public: public:
const wxChar * m_Ident; /* Abreviation de reperage des debuts de lignes */ const wxChar * m_Ident; /* Abreviation de reperage des debuts de lignes */
paramcfg_id m_Type; /* flag type des parametres */ paramcfg_id m_Type; /* flag type des parametres */
const wxChar * m_Group; /* Nom du groupe (rubrique) de classement */ const wxChar * m_Group; /* Nom du groupe (rubrique) de classement */
bool m_Setup; /* TRUE -> inscription en setup (registration base)*/ bool m_Setup; /* TRUE -> inscription en setup (registration base)*/
public: public:
PARAM_CFG_BASE(const wxChar * ident, const paramcfg_id type, const wxChar * group = NULL); PARAM_CFG_BASE(const wxChar * ident, const paramcfg_id type, const wxChar * group = NULL);
~PARAM_CFG_BASE() {}; ~PARAM_CFG_BASE() {};
}; };
class PARAM_CFG_INT : public PARAM_CFG_BASE class PARAM_CFG_INT : public PARAM_CFG_BASE
{ {
public: public:
int * m_Pt_param; /* pointeur sur le parametre a configurer */ int * m_Pt_param; /* pointeur sur le parametre a configurer */
int m_Min, m_Max; /* valeurs extremes du parametre */ int m_Min, m_Max; /* valeurs extremes du parametre */
int m_Default; /* valeur par defaut */ int m_Default; /* valeur par defaut */
public: public:
PARAM_CFG_INT(const wxChar * ident, int * ptparam, PARAM_CFG_INT(const wxChar * ident, int * ptparam,
int default_val = 0, int min = INT_MINVAL, int max = INT_MAXVAL, int default_val = 0, int min = INT_MINVAL, int max = INT_MAXVAL,
const wxChar * group = NULL); const wxChar * group = NULL);
PARAM_CFG_INT(bool Insetup, const wxChar * ident, int * ptparam, PARAM_CFG_INT(bool Insetup, const wxChar * ident, int * ptparam,
int default_val = 0, int min = INT_MINVAL, int max = INT_MAXVAL, int default_val = 0, int min = INT_MINVAL, int max = INT_MAXVAL,
const wxChar * group = NULL); const wxChar * group = NULL);
}; };
class PARAM_CFG_SETCOLOR : public PARAM_CFG_BASE class PARAM_CFG_SETCOLOR : public PARAM_CFG_BASE
{ {
public: public:
int * m_Pt_param; /* pointeur sur le parametre a configurer */ int * m_Pt_param; /* pointeur sur le parametre a configurer */
int m_Default; /* valeur par defaut */ int m_Default; /* valeur par defaut */
public: public:
PARAM_CFG_SETCOLOR(const wxChar * ident, int * ptparam, PARAM_CFG_SETCOLOR(const wxChar * ident, int * ptparam,
int default_val, const wxChar * group = NULL); int default_val, const wxChar * group = NULL);
PARAM_CFG_SETCOLOR(bool Insetup, const wxChar * ident, int * ptparam, PARAM_CFG_SETCOLOR(bool Insetup, const wxChar * ident, int * ptparam,
int default_val, const wxChar * group = NULL); int default_val, const wxChar * group = NULL);
}; };
class PARAM_CFG_DOUBLE : public PARAM_CFG_BASE class PARAM_CFG_DOUBLE : public PARAM_CFG_BASE
{ {
public: public:
double * m_Pt_param; /* pointeur sur le parametre a configurer */ double * m_Pt_param; /* pointeur sur le parametre a configurer */
double m_Default; /* valeur par defaut */ double m_Default; /* valeur par defaut */
double m_Min, m_Max; /* valeurs extremes du parametre */ double m_Min, m_Max; /* valeurs extremes du parametre */
public: public:
PARAM_CFG_DOUBLE(const wxChar * ident, double * ptparam, PARAM_CFG_DOUBLE(const wxChar * ident, double * ptparam,
double default_val = 0.0, double min = 0.0, double max = 10000.0, double default_val = 0.0, double min = 0.0, double max = 10000.0,
const wxChar * group = NULL); const wxChar * group = NULL);
PARAM_CFG_DOUBLE(bool Insetup, const wxChar * ident, double * ptparam, PARAM_CFG_DOUBLE(bool Insetup, const wxChar * ident, double * ptparam,
double default_val = 0.0, double min = 0.0, double max = 10000.0, double default_val = 0.0, double min = 0.0, double max = 10000.0,
const wxChar * group = NULL); const wxChar * group = NULL);
}; };
class PARAM_CFG_BOOL : public PARAM_CFG_BASE class PARAM_CFG_BOOL : public PARAM_CFG_BASE
{ {
public: public:
bool * m_Pt_param; /* pointeur sur le parametre a configurer */ bool * m_Pt_param; /* pointeur sur le parametre a configurer */
int m_Default; /* valeur par defaut */ int m_Default; /* valeur par defaut */
public: public:
PARAM_CFG_BOOL(const wxChar * ident, bool * ptparam, PARAM_CFG_BOOL(const wxChar * ident, bool * ptparam,
int default_val = FALSE,const wxChar * group = NULL); int default_val = FALSE,const wxChar * group = NULL);
PARAM_CFG_BOOL(bool Insetup, const wxChar * ident, bool * ptparam, PARAM_CFG_BOOL(bool Insetup, const wxChar * ident, bool * ptparam,
int default_val = FALSE,const wxChar * group = NULL); int default_val = FALSE,const wxChar * group = NULL);
}; };
class PARAM_CFG_WXSTRING : public PARAM_CFG_BASE class PARAM_CFG_WXSTRING : public PARAM_CFG_BASE
{ {
public: public:
wxString * m_Pt_param; /* pointeur sur le parametre a configurer */ wxString * m_Pt_param; /* pointeur sur le parametre a configurer */
public: public:
PARAM_CFG_WXSTRING(const wxChar * ident, wxString * ptparam, const wxChar * group = NULL); PARAM_CFG_WXSTRING(const wxChar * ident, wxString * ptparam, const wxChar * group = NULL);
PARAM_CFG_WXSTRING(bool Insetup, const wxChar * ident, wxString * ptparam, const wxChar * group = NULL); PARAM_CFG_WXSTRING(bool Insetup, const wxChar * ident, wxString * ptparam, const wxChar * group = NULL);
}; };
class PARAM_CFG_LIBNAME_LIST : public PARAM_CFG_BASE class PARAM_CFG_LIBNAME_LIST : public PARAM_CFG_BASE
{ {
public: public:
wxArrayString * m_Pt_param; /* pointeur sur le parametre a configurer */ wxArrayString * m_Pt_param; /* pointeur sur le parametre a configurer */
public: public:
PARAM_CFG_LIBNAME_LIST(const wxChar * ident, wxArrayString * ptparam, const wxChar * group = NULL); PARAM_CFG_LIBNAME_LIST(const wxChar * ident, wxArrayString * ptparam, const wxChar * group = NULL);
}; };
/***********************************/ /***********************************/
/* Classe pour affichage de textes */ /* Classe pour affichage de textes */
/***********************************/ /***********************************/
class WinEDA_TextFrame: public wxDialog class WinEDA_TextFrame: public wxDialog
{ {
private: private:
wxWindow * m_Parent; wxWindow * m_Parent;
wxListBox * m_List; wxListBox * m_List;
public: public:
WinEDA_TextFrame(wxWindow * parent, const wxString & title); WinEDA_TextFrame(wxWindow * parent, const wxString & title);
void Append( const wxString & text); void Append( const wxString & text);
private: private:
void D_ClickOnList(wxCommandEvent& event); void D_ClickOnList(wxCommandEvent& event);
void OnClose(wxCloseEvent& event); void OnClose(wxCloseEvent& event);
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };
...@@ -210,16 +207,16 @@ class Ki_PageDescr ...@@ -210,16 +207,16 @@ class Ki_PageDescr
{ {
// All sizes are in 1/1000 inch // All sizes are in 1/1000 inch
public: public:
wxSize m_Size ; /* page size in 1/1000 inch */ wxSize m_Size ; /* page size in 1/1000 inch */
wxPoint m_Offset; /* plot offset in 1/1000 inch */ wxPoint m_Offset; /* plot offset in 1/1000 inch */
wxString m_Name; wxString m_Name;
int m_LeftMargin; int m_LeftMargin;
int m_RightMargin; int m_RightMargin;
int m_TopMargin; int m_TopMargin;
int m_BottomMargin; int m_BottomMargin;
public: public:
Ki_PageDescr(const wxSize & size, const wxPoint & offset, const wxString & name); Ki_PageDescr(const wxSize & size, const wxPoint & offset, const wxString & name);
}; };
...@@ -253,7 +250,7 @@ extern Ki_PageDescr g_Sheet_user ; ...@@ -253,7 +250,7 @@ extern Ki_PageDescr g_Sheet_user ;
#endif #endif
COMMON_GLOBL int g_LastKey; /* code de la derniere touche actionn�� */ COMMON_GLOBL int g_LastKey; /* code de la derniere touche actionn�� */
COMMON_GLOBL wxString g_ProductName COMMON_GLOBL wxString g_ProductName
#ifdef EDA_BASE #ifdef EDA_BASE
= wxT("KiCad E.D.A. ") = wxT("KiCad E.D.A. ")
...@@ -261,33 +258,33 @@ COMMON_GLOBL wxString g_ProductName ...@@ -261,33 +258,33 @@ COMMON_GLOBL wxString g_ProductName
; ;
/* Gestion des librairies */ /* Gestion des librairies */
COMMON_GLOBL wxString g_RealLibDirBuffer; // Chemin reel des librairies de module COMMON_GLOBL wxString g_RealLibDirBuffer; // Chemin reel des librairies de module
// = UserLibDirBuffer si non vide // = UserLibDirBuffer si non vide
// = chemin par defaut sinon // = chemin par defaut sinon
COMMON_GLOBL wxString g_UserLibDirBuffer; // Chemin des librairies de module donne par COMMON_GLOBL wxString g_UserLibDirBuffer; // Chemin des librairies de module donne par
// le file de config // le file de config
/* variables globales generales */ /* variables globales generales */
COMMON_GLOBL int g_DebugLevel; // 0= Pas de debug */ COMMON_GLOBL int g_DebugLevel; // 0= Pas de debug */
COMMON_GLOBL int g_MouseOldButtons; COMMON_GLOBL int g_MouseOldButtons;
COMMON_GLOBL int g_KeyPressed; COMMON_GLOBL int g_KeyPressed;
// Font used by kicad. // Font used by kicad.
// these font have a size which do not depend on default size system font // these font have a size which do not depend on default size system font
COMMON_GLOBL wxFont * g_StdFont; /* Standard font used for status display ,in message panel */ COMMON_GLOBL wxFont * g_StdFont; /* Standard font used for status display ,in message panel */
COMMON_GLOBL wxFont * g_DialogFont; /* Normal font used in dialog box */ COMMON_GLOBL wxFont * g_DialogFont; /* Normal font used in dialog box */
COMMON_GLOBL wxFont * g_ItalicFont; /* Italic font used in dialog box */ COMMON_GLOBL wxFont * g_ItalicFont; /* Italic font used in dialog box */
COMMON_GLOBL wxFont * g_MsgFont; /* Italic font used in msg panel (lower window) */ COMMON_GLOBL wxFont * g_MsgFont; /* Italic font used in msg panel (lower window) */
COMMON_GLOBL wxFont * g_FixedFont; /* Affichage de Texte en fenetres de dialogue, COMMON_GLOBL wxFont * g_FixedFont; /* Affichage de Texte en fenetres de dialogue,
fonte a pas fixe)*/ fonte a pas fixe)*/
COMMON_GLOBL int g_StdFontPointSize; /* taille de la fonte */ COMMON_GLOBL int g_StdFontPointSize; /* taille de la fonte */
COMMON_GLOBL int g_DialogFontPointSize; /* taille de la fonte */ COMMON_GLOBL int g_DialogFontPointSize; /* taille de la fonte */
COMMON_GLOBL int g_FixedFontPointSize; /* taille de la fonte */ COMMON_GLOBL int g_FixedFontPointSize; /* taille de la fonte */
COMMON_GLOBL int g_MsgFontPointSize; /* taille de la fonte */ COMMON_GLOBL int g_MsgFontPointSize; /* taille de la fonte */
COMMON_GLOBL int g_FontMinPointSize; /* taille minimum des fontes */ COMMON_GLOBL int g_FontMinPointSize; /* taille minimum des fontes */
COMMON_GLOBL bool g_IsPrinting; // TRUE si impression au lieu de trace a l'ecran COMMON_GLOBL bool g_IsPrinting; // TRUE si impression au lieu de trace a l'ecran
COMMON_GLOBL bool g_ShowPageLimits // TRUE to display the page limits COMMON_GLOBL bool g_ShowPageLimits // TRUE to display the page limits
#ifdef EDA_BASE #ifdef EDA_BASE
= TRUE = TRUE
#endif #endif
...@@ -299,9 +296,9 @@ COMMON_GLOBL wxString g_Prj_Config_Filename_ext ...@@ -299,9 +296,9 @@ COMMON_GLOBL wxString g_Prj_Config_Filename_ext
= wxT(".pro" ) = wxT(".pro" )
#endif #endif
; ;
COMMON_GLOBL wxFileConfig * g_Prj_Config; // Configuration locale, propre au projet COMMON_GLOBL wxFileConfig * g_Prj_Config; // Configuration locale, propre au projet
COMMON_GLOBL wxString g_Prj_Default_Config_FullFilename; // Nom (full file name) du file Configuration par defaut (kicad.pro) COMMON_GLOBL wxString g_Prj_Default_Config_FullFilename; // Nom (full file name) du file Configuration par defaut (kicad.pro)
COMMON_GLOBL wxString g_Prj_Config_LocalFilename; // Nom du file Configuration local (<curr projet>.pro) COMMON_GLOBL wxString g_Prj_Config_LocalFilename; // Nom du file Configuration local (<curr projet>.pro)
// Handle the preferd editor for browsing report files: // Handle the preferd editor for browsing report files:
COMMON_GLOBL wxString g_EditorName; COMMON_GLOBL wxString g_EditorName;
...@@ -316,7 +313,7 @@ extern wxRealPoint g_UserGrid; ...@@ -316,7 +313,7 @@ extern wxRealPoint g_UserGrid;
extern int g_UserGrid_Unit; extern int g_UserGrid_Unit;
#endif #endif
COMMON_GLOBL int g_UnitMetric; // display units mm = 1, inches = 0, cm = 2 COMMON_GLOBL int g_UnitMetric; // display units mm = 1, inches = 0, cm = 2
// shape selector for cursor screen // shape selector for cursor screen
...@@ -328,7 +325,7 @@ COMMON_GLOBL int g_GhostColor; ...@@ -328,7 +325,7 @@ COMMON_GLOBL int g_GhostColor;
/* Draw color for grid: */ /* Draw color for grid: */
COMMON_GLOBL int g_GridColor COMMON_GLOBL int g_GridColor
#ifdef EDA_BASE #ifdef EDA_BASE
= DARKGRAY = DARKGRAY
#endif #endif
; ;
...@@ -349,8 +346,8 @@ class WinEDA_DrawPanel; ...@@ -349,8 +346,8 @@ class WinEDA_DrawPanel;
/* COMMON.CPP */ /* COMMON.CPP */
wxString ReturnPcbLayerName(int layer_number, bool is_filename = FALSE, bool is_gui = FALSE); wxString ReturnPcbLayerName(int layer_number, bool is_filename = FALSE, bool is_gui = FALSE);
/* Return the name of the layer number "layer_number". /* Return the name of the layer number "layer_number".
if "is_filename" == TRUE, the name can be used for a file name if "is_filename" == TRUE, the name can be used for a file name
(not internatinalized, no space)*/ (not internatinalized, no space)*/
/*********************/ /*********************/
...@@ -361,109 +358,109 @@ wxString ReturnPcbLayerName(int layer_number, bool is_filename = FALSE, bool is ...@@ -361,109 +358,109 @@ wxString ReturnPcbLayerName(int layer_number, bool is_filename = FALSE, bool is
/* DRAWTXT.CPP */ /* DRAWTXT.CPP */
/**************/ /**************/
void DrawGraphicText(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & pos, void DrawGraphicText(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & pos,
int mode_color, const wxString & Text, int mode_color, const wxString & Text,
int orient , const wxSize & char_size, int orient , const wxSize & char_size,
int h_justify, int v_justify, int width = 0); int h_justify, int v_justify, int width = 0);
void PlotGraphicText(int format_plot, const wxPoint & Pos, int gcolor, void PlotGraphicText(int format_plot, const wxPoint & Pos, int gcolor,
const wxString & Text, const wxString & Text,
int orient, const wxSize & Size, int h_justify, int v_justify); int orient, const wxSize & Size, int h_justify, int v_justify);
/***************/ /***************/
/* CONFIRM.CPP */ /* CONFIRM.CPP */
/***************/ /***************/
void DisplayError(wxWindow * parent, const wxString & msg, int displaytime = 0); void DisplayError(wxWindow * parent, const wxString & msg, int displaytime = 0);
void DisplayInfo(wxWindow * parent, const wxString & msg, int displaytime = 0); void DisplayInfo(wxWindow * parent, const wxString & msg, int displaytime = 0);
/* Routines d'affichage messages ( disparait au bout de displaytime 0.1 secondes) */ /* Routines d'affichage messages ( disparait au bout de displaytime 0.1 secondes) */
bool IsOK(wxWindow * parent, const wxString & msg) ; bool IsOK(wxWindow * parent, const wxString & msg) ;
/* Routine affichant la fenetre "CONFIRMATION" /* Routine affichant la fenetre "CONFIRMATION"
Retourne 1 ou 0 selon reponse Yes / No */ Retourne 1 ou 0 selon reponse Yes / No */
int Get_Message(const wxString & titre, wxString & buffer, wxWindow * frame) ; int Get_Message(const wxString & titre, wxString & buffer, wxWindow * frame) ;
/* Fonction d'installation du menu de Dialogue /* Fonction d'installation du menu de Dialogue
entree: titre = titre a afficher entree: titre = titre a afficher
entree/sortie :buffer : contient la reponse entree/sortie :buffer : contient la reponse
si a l'appel buffer n'est pas vide, son contenu est aussi si a l'appel buffer n'est pas vide, son contenu est aussi
affiche, mais disparait a la 1ere correction */ affiche, mais disparait a la 1ere correction */
/************************/ /************************/
/* file GESTFICH.CPP */ /* file GESTFICH.CPP */
/************************/ /************************/
wxString GetEditorName(void); // Return the prefered editor name wxString GetEditorName(void); // Return the prefered editor name
void OpenPDF( const wxString & file ); void OpenPDF( const wxString & file );
void OpenFile( const wxString & file ); void OpenFile( const wxString & file );
bool EDA_DirectorySelector(const wxString & Title, /* Titre de la fenetre */ bool EDA_DirectorySelector(const wxString & Title, /* Titre de la fenetre */
wxString & Path, /* Chemin par defaut */ wxString & Path, /* Chemin par defaut */
int flag, /* reserve */ int flag, /* reserve */
wxWindow * Frame, /* parent frame */ wxWindow * Frame, /* parent frame */
const wxPoint & Pos); const wxPoint & Pos);
wxString EDA_FileSelector(const wxString & Title, /* Window title */ wxString EDA_FileSelector(const wxString & Title, /* Window title */
const wxString & Path, /* default path */ const wxString & Path, /* default path */
const wxString & FileName, /* default filename */ const wxString & FileName, /* default filename */
const wxString & Ext, /* default extension */ const wxString & Ext, /* default extension */
const wxString & Mask, /* Display filename mask */ const wxString & Mask, /* Display filename mask */
wxWindow * Frame, /* parent frame */ wxWindow * Frame, /* parent frame */
int flag, /* wxSAVE, wxOPEN ..*/ int flag, /* wxSAVE, wxOPEN ..*/
const bool keep_working_directory, /* true = do not change the C.W.D. */ const bool keep_working_directory, /* true = do not change the C.W.D. */
const wxPoint & Pos = wxPoint(-1, -1) const wxPoint & Pos = wxPoint(-1, -1)
); );
wxString MakeFileName( const wxString & dir, wxString MakeFileName( const wxString & dir,
const wxString & shortname, const wxString & ext); const wxString & shortname, const wxString & ext);
/* Calcule le nom complet d'un file d'apres les chaines /* Calcule le nom complet d'un file d'apres les chaines
dir = prefixe (chemin) dir = prefixe (chemin)
shortname = nom avec ou sans chemin ou extension shortname = nom avec ou sans chemin ou extension
ext = extension ext = extension
si la chaine name possede deja un chemin ou une extension, elles si la chaine name possede deja un chemin ou une extension, elles
ne seront pas modifiees ne seront pas modifiees
retourne la chaine calculee */ retourne la chaine calculee */
wxString MakeReducedFileName( const wxString & fullfilename, wxString MakeReducedFileName( const wxString & fullfilename,
const wxString & default_path, const wxString & default_path,
const wxString & default_ext); const wxString & default_ext);
/* Calcule le nom "reduit" d'un file d'apres les chaines /* Calcule le nom "reduit" d'un file d'apres les chaines
fullfilename = nom complet fullfilename = nom complet
default_path = prefixe (chemin) par defaut default_path = prefixe (chemin) par defaut
default_ext = extension par defaut default_ext = extension par defaut
retourne le nom reduit, c'est a dire: retourne le nom reduit, c'est a dire:
sans le chemin si le chemin est default_path sans le chemin si le chemin est default_path
avec ./ si si le chemin est le chemin courant avec ./ si si le chemin est le chemin courant
sans l'extension si l'extension est default_ext sans l'extension si l'extension est default_ext
Renvoie un chemin en notation unix ('/' en separateur de repertoire) Renvoie un chemin en notation unix ('/' en separateur de repertoire)
*/ */
WinEDAListBox * GetFileNames(char *Directory, char *Mask); WinEDAListBox * GetFileNames(char *Directory, char *Mask);
void ChangeFileNameExt( wxString & FullFileName, const wxString & NewExt ); void ChangeFileNameExt( wxString & FullFileName, const wxString & NewExt );
/* Change l'extension du "filename FullFileName" en NewExt. /* Change l'extension du "filename FullFileName" en NewExt.
Retourne FullFileName */ Retourne FullFileName */
int ExecuteFile(wxWindow * frame, const wxString & ExecFile, int ExecuteFile(wxWindow * frame, const wxString & ExecFile,
const wxString & param = wxEmptyString); const wxString & param = wxEmptyString);
void AddDelimiterString( wxString & string ); void AddDelimiterString( wxString & string );
void SetRealLibraryPath(const wxString & shortlibname); /* met a jour void SetRealLibraryPath(const wxString & shortlibname); /* met a jour
le chemin des librairies RealLibDirBuffer (global) le chemin des librairies RealLibDirBuffer (global)
a partir de UserLibDirBuffer (global): a partir de UserLibDirBuffer (global):
Si UserLibDirBuffer non vide RealLibDirBuffer = UserLibDirBuffer. Si UserLibDirBuffer non vide RealLibDirBuffer = UserLibDirBuffer.
Sinon si variable d'environnement KICAD definie (KICAD = chemin pour kicad), Sinon si variable d'environnement KICAD definie (KICAD = chemin pour kicad),
UserLibDirBuffer = <KICAD>/shortlibname; UserLibDirBuffer = <KICAD>/shortlibname;
Sinon UserLibDirBuffer = <Chemin des binaires>../shortlibname/ Sinon UserLibDirBuffer = <Chemin des binaires>../shortlibname/
*/ */
wxString FindKicadHelpPath(void); wxString FindKicadHelpPath(void);
/* Find absolute path for kicad/help (or kicad/help/<language>) */ /* Find absolute path for kicad/help (or kicad/help/<language>) */
wxString ReturnKicadDatasPath(void); wxString ReturnKicadDatasPath(void);
/* Retourne le chemin des donnees communes de kicad. */ /* Retourne le chemin des donnees communes de kicad. */
wxString FindKicadFile(const wxString & shortname); wxString FindKicadFile(const wxString & shortname);
/* Search the executable file shortname in kicad binary path and return /* Search the executable file shortname in kicad binary path and return
...@@ -476,53 +473,53 @@ full file name if found or shortname */ ...@@ -476,53 +473,53 @@ full file name if found or shortname */
char * strupper(char * Text); char * strupper(char * Text);
int ReadDelimitedText(char * dest, char * source, int NbMaxChar ); int ReadDelimitedText(char * dest, char * source, int NbMaxChar );
/* lit et place dans dest la chaine de caractere trouvee dans source, /* lit et place dans dest la chaine de caractere trouvee dans source,
delimitee par " . delimitee par " .
transfere NbMaxChar max transfere NbMaxChar max
retourne le nombre de codes lus dans source retourne le nombre de codes lus dans source
dest est termine par NULL */ dest est termine par NULL */
char * GetLine(FILE *File, char *Line, int *LineNum = NULL, int SizeLine = 255); char * GetLine(FILE *File, char *Line, int *LineNum = NULL, int SizeLine = 255);
/* Routine de lecture de 1 ligne utile /* Routine de lecture de 1 ligne utile
retourne la 1ere ligne utile lue. retourne la 1ere ligne utile lue.
elimine lignes vides et commentaires */ elimine lignes vides et commentaires */
char * StrPurge(char * text); char * StrPurge(char * text);
/* Supprime les caracteres Space en debut de la ligne text /* Supprime les caracteres Space en debut de la ligne text
retourne un pointeur sur le 1er caractere non Space de text */ retourne un pointeur sur le 1er caractere non Space de text */
char * DateAndTime(char * line); char * DateAndTime(char * line);
wxString DateAndTime(void); wxString DateAndTime(void);
/* Retourne la chaine de caractere donnant date+heure */ /* Retourne la chaine de caractere donnant date+heure */
int StrLenNumCmp(const wxChar *str1,const wxChar *str2, int NbMax); int StrLenNumCmp(const wxChar *str1,const wxChar *str2, int NbMax);
/* /*
routine (compatible qsort() ) de comparaision pour classement alphab�tique routine (compatible qsort() ) de comparaision pour classement alphab�tique
Analogue a strncmp() mais les nombres sont compar�s selon leur valeur num�rique Analogue a strncmp() mais les nombres sont compar�s selon leur valeur num�rique
et non pas par leur code ascii */ et non pas par leur code ascii */
int StrNumICmp(const wxChar *str1,const wxChar *str2); int StrNumICmp(const wxChar *str1,const wxChar *str2);
/* routine (compatible qsort() ) de comparaison pour classement alphab�tique, /* routine (compatible qsort() ) de comparaison pour classement alphab�tique,
avec lower case == upper case. avec lower case == upper case.
Analogue a stricmp() mais les nombres sont compar�s selon leur valeur num�rique Analogue a stricmp() mais les nombres sont compar�s selon leur valeur num�rique
et non pas par leur code ascii */ et non pas par leur code ascii */
int StrLenNumICmp(const wxChar *str1,const wxChar *str2, int NbMax); int StrLenNumICmp(const wxChar *str1,const wxChar *str2, int NbMax);
/* routine (compatible qsort() ) de comparaison pour classement alphab�tique, /* routine (compatible qsort() ) de comparaison pour classement alphab�tique,
avec lower case == upper case. avec lower case == upper case.
Analogue a stricmp() mais les nombres sont compar�s selon leur valeur num�rique Analogue a stricmp() mais les nombres sont compar�s selon leur valeur num�rique
et non pas par leur code ascii */ et non pas par leur code ascii */
bool WildCompareString(const wxString & pattern, const wxString & string_to_tst, bool WildCompareString(const wxString & pattern, const wxString & string_to_tst,
bool case_sensitive = TRUE); bool case_sensitive = TRUE);
/* compare 2 noms de composants, selon regles usuelles /* compare 2 noms de composants, selon regles usuelles
( Jokers * , ? , autoris�s). ( Jokers * , ? , autoris�s).
la chaine de reference est "pattern" la chaine de reference est "pattern"
si case_sensitive == TRUE (default), comparaison exacte si case_sensitive == TRUE (default), comparaison exacte
retourne TRUE si match FALSE si differences */ retourne TRUE si match FALSE si differences */
char * to_point(char * Text); char * to_point(char * Text);
/* convertit les , en . dans une chaine. utilis� pour compenser la fct printf /* convertit les , en . dans une chaine. utilis� pour compenser la fct printf
qui genere les flottants avec une virgule au lieu du point en mode international */ qui genere les flottants avec une virgule au lieu du point en mode international */
/****************/ /****************/
/* infospgm.cpp */ /* infospgm.cpp */
...@@ -532,51 +529,51 @@ void Print_Kicad_Infos(wxWindow * frame); ...@@ -532,51 +529,51 @@ void Print_Kicad_Infos(wxWindow * frame);
/**************/ /**************/
/* common.cpp */ /* common.cpp */
/**************/ /**************/
wxString GetBuildVersion(void); /* Return the build date */ wxString GetBuildVersion(void); /* Return the build date */
void Affiche_1_Parametre(WinEDA_DrawFrame * frame , void Affiche_1_Parametre(WinEDA_DrawFrame * frame ,
int pos_X,const wxString& texte_H,const wxString& texte_L,int color); int pos_X,const wxString& texte_H,const wxString& texte_L,int color);
/* /*
Routine d'affichage d'un parametre. Routine d'affichage d'un parametre.
pos_X = cadrage horizontal pos_X = cadrage horizontal
si pos_X < 0 : la position horizontale est la derniere si pos_X < 0 : la position horizontale est la derniere
valeur demandee >= 0 valeur demandee >= 0
texte_H = texte a afficher en ligne superieure. texte_H = texte a afficher en ligne superieure.
si "", par d'affichage sur cette ligne si "", par d'affichage sur cette ligne
texte_L = texte a afficher en ligne inferieure. texte_L = texte a afficher en ligne inferieure.
si "", par d'affichage sur cette ligne si "", par d'affichage sur cette ligne
color = couleur d'affichage color = couleur d'affichage
*/ */
void AfficheDoc(WinEDA_DrawFrame * frame, const wxString & Doc, const wxString & KeyW); void AfficheDoc(WinEDA_DrawFrame * frame, const wxString & Doc, const wxString & KeyW);
/* Routine d'affichage de la documentation associee a un composant */ /* Routine d'affichage de la documentation associee a un composant */
int GetTimeStamp(void); int GetTimeStamp(void);
/* Retoure une identification temporelle (Time stamp) differente a chaque appel */ /* Retoure une identification temporelle (Time stamp) differente a chaque appel */
int DisplayColorFrame(wxWindow * parent); int DisplayColorFrame(wxWindow * parent);
int GetCommandOptions(const int argc, const char **argv, const char * stringtst, int GetCommandOptions(const int argc, const char **argv, const char * stringtst,
const char ** optarg, int * optind); const char ** optarg, int * optind);
void valeur_param(int valeur,wxString & buf_texte); void valeur_param(int valeur,wxString & buf_texte);
/* Retourne pour affichage la valeur d'un parametre, selon type d'unites choisies /* Retourne pour affichage la valeur d'un parametre, selon type d'unites choisies
entree : valeur en mils , buffer de texte entree : valeur en mils , buffer de texte
retourne en buffer : texte : valeur exprimee en pouces ou millimetres retourne en buffer : texte : valeur exprimee en pouces ou millimetres
suivie de " ou mm suivie de " ou mm
*/ */
wxString ReturnUnitSymbol(int Units = g_UnitMetric); wxString ReturnUnitSymbol(int Units = g_UnitMetric);
int ReturnValueFromString(int Units, const wxString & TextValue, int Internal_Unit); int ReturnValueFromString(int Units, const wxString & TextValue, int Internal_Unit);
wxString ReturnStringFromValue(int Units, int Value, int Internal_Unit); wxString ReturnStringFromValue(int Units, int Value, int Internal_Unit);
void AddUnitSymbol(wxStaticText & Stext, int Units = g_UnitMetric); void AddUnitSymbol(wxStaticText & Stext, int Units = g_UnitMetric);
/* Add string " (mm):" or " ("):" to the static text Stext. /* Add string " (mm):" or " ("):" to the static text Stext.
Used in dialog boxes for entering values depending on selected units */ Used in dialog boxes for entering values depending on selected units */
void PutValueInLocalUnits(wxTextCtrl & TextCtr, int Value, int Internal_Unit); void PutValueInLocalUnits(wxTextCtrl & TextCtr, int Value, int Internal_Unit);
/* Convert the number Value in a string according to the internal units /* Convert the number Value in a string according to the internal units
and the selected unit (g_UnitMetric) and put it in the wxTextCtrl TextCtrl */ and the selected unit (g_UnitMetric) and put it in the wxTextCtrl TextCtrl */
int ReturnValueFromTextCtrl(const wxTextCtrl & TextCtr, int Internal_Unit); int ReturnValueFromTextCtrl(const wxTextCtrl & TextCtr, int Internal_Unit);
/* Convert the Value in the wxTextCtrl TextCtrl in an integer, /* Convert the Value in the wxTextCtrl TextCtrl in an integer,
according to the internal units and the selected unit (g_UnitMetric) */ according to the internal units and the selected unit (g_UnitMetric) */
double To_User_Unit(bool is_metric, int val,int internal_unit_value); double To_User_Unit(bool is_metric, int val,int internal_unit_value);
int From_User_Unit(bool is_metric, double val,int internal_unit_value); int From_User_Unit(bool is_metric, double val,int internal_unit_value);
...@@ -591,42 +588,42 @@ void * MyMalloc (size_t nb_octets); ...@@ -591,42 +588,42 @@ void * MyMalloc (size_t nb_octets);
/****************/ /****************/
int KeyWordOk(const wxString & KeyList, const wxString & Database ); int KeyWordOk(const wxString & KeyList, const wxString & Database );
/* Recherche si dans le texte Database on retrouve tous les mots /* Recherche si dans le texte Database on retrouve tous les mots
cles donnes dans KeyList ( KeyList = suite de mots cles cles donnes dans KeyList ( KeyList = suite de mots cles
separes par des espaces separes par des espaces
Retourne: Retourne:
0 si aucun mot cle trouv� 0 si aucun mot cle trouv�
1 si mot cle trouv� 1 si mot cle trouv�
*/ */
bool GetAssociatedDocument(wxFrame * frame, const wxString & LibPath, bool GetAssociatedDocument(wxFrame * frame, const wxString & LibPath,
const wxString & DocName); const wxString & DocName);
/****************************/ /****************************/
/* get_component_dialog.cpp */ /* get_component_dialog.cpp */
/****************************/ /****************************/
wxString GetComponentName(WinEDA_DrawFrame * frame, wxString GetComponentName(WinEDA_DrawFrame * frame,
wxArrayString & HistoryList, const wxString & Title, wxArrayString & HistoryList, const wxString & Title,
wxString(*AuxTool)(WinEDA_DrawFrame *parent) ); wxString(*AuxTool)(WinEDA_DrawFrame *parent) );
/* Dialog frame to choose a component name */ /* Dialog frame to choose a component name */
void AddHistoryComponentName(wxArrayString & HistoryList, const wxString & Name); void AddHistoryComponentName(wxArrayString & HistoryList, const wxString & Name);
/* Add the string "Name" to the history list */ /* Add the string "Name" to the history list */
/**********************/ /**********************/
/* block_commande.cpp */ /* block_commande.cpp */
/**********************/ /**********************/
void AbortBlockCurrentCommand(WinEDA_DrawPanel * Panel, wxDC * DC); void AbortBlockCurrentCommand(WinEDA_DrawPanel * Panel, wxDC * DC);
/* Cancel Current block operation. */ /* Cancel Current block operation. */
void InitBlockLocateDatas( WinEDA_DrawPanel * Panel,const wxPoint & startpos ); void InitBlockLocateDatas( WinEDA_DrawPanel * Panel,const wxPoint & startpos );
/* Init the initial values of a BlockLocate, before starting a block command */ /* Init the initial values of a BlockLocate, before starting a block command */
void DrawAndSizingBlockOutlines(WinEDA_DrawPanel * panel, wxDC * DC, bool erase ); void DrawAndSizingBlockOutlines(WinEDA_DrawPanel * panel, wxDC * DC, bool erase );
/* Redraw the outlines of the block which shows the search area for block commands /* Redraw the outlines of the block which shows the search area for block commands
The first point of the rectangle showing the area is initialised The first point of the rectangle showing the area is initialised
by InitBlockLocateDatas(). by InitBlockLocateDatas().
The other point of the rectangle is the mouse cursor */ The other point of the rectangle is the mouse cursor */
#endif // COMMON_H #endif // COMMON_H
include/eda_dde.h
View file @ 51fc26e1
...@@ -11,17 +11,20 @@ ...@@ -11,17 +11,20 @@
#define WinEDA_Server wxSocketServer #define WinEDA_Server wxSocketServer
/********************/ // TCP/IP ports used by PCBNEW and EESCHEMA respectively.
/* autres fonctions */ #define KICAD_PCB_PORT_SERVICE_NUMBER 4242 ///< PCBNEW listens on this port for commands from EESCHEMA
/********************/ #define KICAD_SCH_PORT_SERVICE_NUMBER 4243 ///< EESCHEMA listens on this port for commands from PCBNEW
WinEDA_Server * CreateServer(wxWindow * window, int service);
bool SendCommand( int service, char * cmdline);
void SetupServerFunction(void (* remotefct)(char * remotecmd) );
#define MSG_TO_PCB KICAD_PCB_PORT_SERVICE_NUMBER
#define MSG_TO_SCH KICAD_SCH_PORT_SERVICE_NUMBER
/********************/
/* autres fonctions */
/********************/
WinEDA_Server * CreateServer( wxWindow * window, int port );
bool SendCommand( int port, const char* cmdline );
void SetupServerFunction( void (*remotefct) (const char* remotecmd) );
include/wxstruct.h
View file @ 51fc26e1
...@@ -700,6 +700,14 @@ public: ...@@ -700,6 +700,14 @@ public:
// divers // divers
void InstallFindFrame( const wxPoint& pos, wxDC* DC ); void InstallFindFrame( const wxPoint& pos, wxDC* DC );
/**
* Function SendMessageToEESCHEMA
* sends a message to the schematic editor so that it may move its cursor
* to a part with the same reference as the objectToSync
* @param objectToSync The object whose reference is used to syncronize eeschema.
*/
void SendMessageToEESCHEMA( EDA_BaseStruct* objectToSync );
/* Special micro_ondes */ /* Special micro_ondes */
void Edit_Gap( wxDC* DC, MODULE* Module ); void Edit_Gap( wxDC* DC, MODULE* Module );
MODULE* Create_MuWaveBasicShape( wxDC* DC, const wxString& name, int pad_count ); MODULE* Create_MuWaveBasicShape( wxDC* DC, const wxString& name, int pad_count );
...@@ -974,7 +982,17 @@ public: ...@@ -974,7 +982,17 @@ public:
bool LoadOneSheet( SCH_SCREEN* screen, const wxString& FullFileName ); bool LoadOneSheet( SCH_SCREEN* screen, const wxString& FullFileName );
// General search: // General search:
EDA_BaseStruct* FindSchematicItem( const wxString& pattern, int SearchType ); /**
* Function FindSchematicItem
* finds a string in the schematic.
* @param pattern The text to search for, either in value, reference or elsewhere.
* @param SearchType: 0 => Search is made in current sheet
* 1 => the whole hierarchy
* 2 => or for the next item
* @param mouseWarp If true, then move the mouse cursor to the item.
*/
EDA_BaseStruct* FindSchematicItem( const wxString& pattern, int SearchType, bool mouseWarp=true );
EDA_BaseStruct* FindMarker( int SearchType ); EDA_BaseStruct* FindMarker( int SearchType );
private: private:
......
pcbnew/class_text_mod.h
View file @ 51fc26e1
...@@ -2,6 +2,11 @@ ...@@ -2,6 +2,11 @@
/* class_text_module.h : texts module description */ /* class_text_module.h : texts module description */
/***************************************************/ /***************************************************/
#ifndef TEXT_MODULE_H
#define TEXT_MODULE_H
/* 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
...@@ -80,3 +85,6 @@ public: ...@@ -80,3 +85,6 @@ public:
virtual void Show( int nestLevel, std::ostream& os ); virtual void Show( int nestLevel, std::ostream& os );
#endif #endif
}; };
#endif // TEXT_MODULE_H
pcbnew/controle.cpp
View file @ 51fc26e1
...@@ -22,53 +22,57 @@ ...@@ -22,53 +22,57 @@
/* Variables Locales */ /* Variables Locales */
/**********************************/ /**********************************/
void RemoteCommand( char* cmdline ) void RemoteCommand( const char* cmdline )
/**********************************/ /**********************************/
/* Read a remote command send by eeschema via a socket, /* Read a remote command send by eeschema via a socket,
* port KICAD_PCB_PORT_SERVICE_NUMBER (currently 4242) * port KICAD_PCB_PORT_SERVICE_NUMBER (currently 4242)
*/ */
{ {
char Line[1024]; char line[1024];
wxString msg; wxString msg;
char* idcmd, * text; char* idcmd, * text;
WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame; WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
strncpy( Line, cmdline, sizeof(Line) - 1 ); strncpy( line, cmdline, sizeof(line) - 1 );
msg = CONV_FROM_UTF8( Line ); msg = CONV_FROM_UTF8( line );
idcmd = strtok( Line, " \n\r" ); idcmd = strtok( line, " \n\r" );
text = strtok( NULL, " \n\r" ); text = strtok( NULL, " \n\r" );
if( (idcmd == NULL) || (text == NULL) ) if( (idcmd == NULL) || (text == NULL) )
return; return;
if( strcmp( idcmd, "$PART:" ) == 0 ) if( strcmp( idcmd, "$PART:" ) == 0 )
{ {
MODULE* Module;
msg = CONV_FROM_UTF8( text ); msg = CONV_FROM_UTF8( text );
Module = ReturnModule( frame->m_Pcb, msg );
MODULE* module = ReturnModule( frame->m_Pcb, msg );
msg.Printf( _( "Locate module %s %s" ), msg.GetData(), msg.Printf( _( "Locate module %s %s" ), msg.GetData(),
Module ? wxT( "Ok" ) : wxT( "not found" ) ); module ? wxT( "Ok" ) : wxT( "not found" ) );
frame->Affiche_Message( msg ); frame->Affiche_Message( msg );
if( Module ) if( module )
{ {
wxClientDC dc( frame->DrawPanel ); wxClientDC dc( frame->DrawPanel );
frame->DrawPanel->PrepareGraphicContext( &dc ); frame->DrawPanel->PrepareGraphicContext( &dc );
frame->DrawPanel->CursorOff( &dc ); frame->DrawPanel->CursorOff( &dc );
frame->GetScreen()->m_Curseur = Module->m_Pos; frame->GetScreen()->m_Curseur = module->m_Pos;
frame->DrawPanel->CursorOn( &dc ); frame->DrawPanel->CursorOn( &dc );
} }
} }
if( idcmd && strcmp( idcmd, "$PIN:" ) == 0 ) if( idcmd && strcmp( idcmd, "$PIN:" ) == 0 )
{ {
wxString PinName, ModName; wxString pinName, modName;
MODULE* Module; MODULE* module;
D_PAD* Pad = NULL; D_PAD* pad = NULL;
int netcode = -1; int netcode = -1;
PinName = CONV_FROM_UTF8( text );
text = strtok( NULL, " \n\r" ); pinName = CONV_FROM_UTF8( text );
text = strtok( NULL, " \n\r" );
if( text && strcmp( text, "$PART:" ) == 0 ) if( text && strcmp( text, "$PART:" ) == 0 )
text = strtok( NULL, "\n\r" ); text = strtok( NULL, "\n\r" );
...@@ -76,30 +80,34 @@ void RemoteCommand( char* cmdline ) ...@@ -76,30 +80,34 @@ void RemoteCommand( char* cmdline )
frame->DrawPanel->PrepareGraphicContext( &dc ); frame->DrawPanel->PrepareGraphicContext( &dc );
ModName = CONV_FROM_UTF8( text ); modName = CONV_FROM_UTF8( text );
Module = ReturnModule( frame->m_Pcb, ModName ); module = ReturnModule( frame->m_Pcb, modName );
if( Module ) if( module )
Pad = ReturnPad( Module, PinName ); pad = ReturnPad( module, pinName );
if( Pad )
netcode = Pad->m_NetCode; if( pad )
netcode = pad->m_NetCode;
if( netcode > 0 ) if( netcode > 0 )
{ {
/* effacement surbrillance ancienne */ /* effacement surbrillance ancienne */
if( g_HightLigt_Status ) if( g_HightLigt_Status )
frame->Hight_Light( &dc ); frame->Hight_Light( &dc );
g_HightLigth_NetCode = netcode; g_HightLigth_NetCode = netcode;
frame->Hight_Light( &dc ); frame->Hight_Light( &dc );
frame->DrawPanel->CursorOff( &dc ); frame->DrawPanel->CursorOff( &dc );
frame->GetScreen()->m_Curseur = Pad->m_Pos; frame->GetScreen()->m_Curseur = pad->m_Pos;
frame->DrawPanel->CursorOn( &dc ); frame->DrawPanel->CursorOn( &dc );
} }
if( Module == NULL ) if( module == NULL )
msg.Printf( _( "module %s not found" ), text ); msg.Printf( _( "module %s not found" ), text );
else if( Pad == NULL ) else if( pad == NULL )
msg.Printf( _( "Pin %s (module %s) not found" ), PinName.GetData(), ModName.GetData() ); msg.Printf( _( "Pin %s (module %s) not found" ), pinName.GetData(), modName.GetData() );
else else
msg.Printf( _( "Locate Pin %s (module %s)" ), PinName.GetData(), ModName.GetData() ); msg.Printf( _( "Locate Pin %s (module %s)" ), pinName.GetData(), modName.GetData() );
frame->Affiche_Message( msg ); frame->Affiche_Message( msg );
} }
} }
......
pcbnew/edit.cpp
View file @ 51fc26e1
...@@ -11,8 +11,9 @@ ...@@ -11,8 +11,9 @@
#include "autorout.h" #include "autorout.h"
#include "id.h" #include "id.h"
#include "protos.h" #include "protos.h"
#include "eda_dde.h"
#define CURRENT_ITEM (GetScreen()->m_CurrentItem) #define CURRENT_ITEM (GetScreen()->m_CurrentItem)
...@@ -94,6 +95,8 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos ) ...@@ -94,6 +95,8 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
else else
{ {
DrawStruct = PcbGeneralLocateAndDisplay(); DrawStruct = PcbGeneralLocateAndDisplay();
if( DrawStruct )
SendMessageToEESCHEMA( DrawStruct );
} }
} }
...@@ -128,6 +131,9 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos ) ...@@ -128,6 +131,9 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
DrawStruct = m_Pcb->FindPadOrModule( GetScreen()->RefPos(true), DrawStruct = m_Pcb->FindPadOrModule( GetScreen()->RefPos(true),
GetScreen()->m_Active_Layer ); GetScreen()->m_Active_Layer );
Show_1_Ratsnest( DrawStruct, DC ); Show_1_Ratsnest( DrawStruct, DC );
if( DrawStruct )
SendMessageToEESCHEMA( DrawStruct );
break; break;
case ID_PCB_MIRE_BUTT: case ID_PCB_MIRE_BUTT:
...@@ -311,6 +317,27 @@ out: ...@@ -311,6 +317,27 @@ out:
} }
// see wxstruct.h
void WinEDA_PcbFrame::SendMessageToEESCHEMA( EDA_BaseStruct* objectToSync )
{
char cmd[1024];
MODULE* module = NULL;
if( objectToSync->m_StructType == TYPEMODULE )
module = (MODULE*) objectToSync;
else if( objectToSync->m_StructType == TYPEPAD )
module = (MODULE*)((D_PAD*)objectToSync)->m_Parent;
// ask only for the reference for now, maybe pins later.
if( module )
{
sprintf( cmd, "$PART: %s", CONV_TO_UTF8(module->m_Reference->m_Text) );
SendCommand( MSG_TO_SCH, cmd );
}
}
/*********************************************************************/ /*********************************************************************/
void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event ) void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
/*********************************************************************/ /*********************************************************************/
......
pcbnew/files.cpp
View file @ 51fc26e1
...@@ -235,7 +235,9 @@ int WinEDA_PcbFrame::LoadOnePcbFile( const wxString& FullFileName, wxDC* DC, boo ...@@ -235,7 +235,9 @@ int WinEDA_PcbFrame::LoadOnePcbFile( const wxString& FullFileName, wxDC* DC, boo
g_SaveTime = time( NULL ); g_SaveTime = time( NULL );
#if defined(DEBUG) #if 0 && defined(DEBUG)
// note this seems to freeze up pcbnew when run under the kicad project
// manager. runs fine from command prompt.
// output the board object tree to stdout: // output the board object tree to stdout:
m_Pcb->Show( 0, std::cout ); m_Pcb->Show( 0, std::cout );
#endif #endif
......
pcbnew/protos.h
View file @ 51fc26e1
...@@ -394,7 +394,7 @@ TRACK * CreateLockPoint(int *pX, int *pY, TRACK * ptsegm, TRACK * refsegm); ...@@ -394,7 +394,7 @@ TRACK * CreateLockPoint(int *pX, int *pY, TRACK * ptsegm, TRACK * refsegm);
/****************/ /****************/
/* CONTROLE.CPP */ /* CONTROLE.CPP */
/****************/ /****************/
void RemoteCommand(char * cmdline); void RemoteCommand( const char* cmdline );
/*************/ /*************/
/* STRUCT.CPP */ /* STRUCT.CPP */
......
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