int WinEDA_FindFrame::ExploreAllLibraries(const wxString & wildmask, wxString & FindList)
/****************************************************************************************/
{
wxString FullFileName;
FILE * file;
int nbitems = 0, LineNum = 0;
char Line[2048], *name;
FullFileName = MakeFileName(g_RealLibDirBuffer, wxT("*"), g_LibExtBuffer);
FullFileName = wxFindFirstFile(FullFileName);
while ( ! FullFileName.IsEmpty() )
{
file = wxFopen(FullFileName, wxT("rt"));
if (file == NULL) continue;
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 */
strtok(Line, " \t\r\n");
name = strtok(NULL, " \t\r\n");
wxString st_name = CONV_FROM_UTF8(name);
if( WildCompareString(wildmask, st_name, FALSE) )
{
nbitems ++;
if ( ! FindList.IsEmpty() ) 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");
while ( (name = strtok(NULL, " \t\r\n")) != NULL )
{
wxString st_name = CONV_FROM_UTF8(name);
if( WildCompareString( wildmask, st_name, FALSE) )
{
nbitems ++;
if ( ! FindList.IsEmpty() ) FindList += wxT("\n");
FindList << _("Found ") << CONV_FROM_UTF8(name)
<< _(" in lib ") << FullFileName;
}
}
}
}
fclose(file);
FullFileName = wxFindNextFile();
}
return nbitems;
}
void CMP_LIBRARY::SearchEntryNames( std::vector<wxArrayString>& aNames,
const wxString& aNameSearch,
const wxString& aKeySearch,
bool aSort )
{
LIB_ALIAS_MAP::iterator it;
for( it = aliases.begin(); it!=aliases.end(); it++ )
{
if( !aKeySearch.IsEmpty() && KeyWordOk( aKeySearch, (*it).second->GetKeyWords() ) )
{
wxArrayString item;
item.Add( (*it).first );
item.Add( GetLogicalName() );
aNames.push_back( item );
}
if( !aNameSearch.IsEmpty() && WildCompareString( aNameSearch,
(*it).second->GetName(), false ) )
{
wxArrayString item;
item.Add( (*it).first );
item.Add( GetLogicalName() );
aNames.push_back( item );
}
}
if( aSort )
std::sort( aNames.begin(), aNames.end(), sortFunction );
}
void CMP_LIBRARY::SearchEntryNames( wxArrayString& aNames,
const wxString& aNameSearch,
const wxString& aKeySearch,
bool aSort )
{
LIB_ALIAS_MAP::iterator it;
for( it=aliases.begin(); it!=aliases.end(); it++ )
{
if( !aKeySearch.IsEmpty() && KeyWordOk( aKeySearch, (*it).second->GetKeyWords() ) )
aNames.Add( (*it).first );
if( !aNameSearch.IsEmpty() && WildCompareString( aNameSearch,
(*it).second->GetName(), false ) )
aNames.Add( (*it).first );
}
if( aSort )
aNames.Sort();
}
/* Set or reset (true or false) Lock attribute of aModule or all modules if aModule == NULL
*/
void PCB_EDIT_FRAME::LockModule( MODULE* aModule, bool aLocked )
{
if( aModule )
{
aModule->SetLocked( aLocked );
SetMsgPanel( aModule );
OnModify();
}
else
{
aModule = GetBoard()->m_Modules;
for( ; aModule != NULL; aModule = aModule->Next() )
{
if( WildCompareString( ModulesMaskSelection, aModule->GetReference() ) )
{
aModule->SetLocked( aLocked );
OnModify();
}
}
}
}
bool PCB_EDIT_FRAME::ReOrientModules( const wxString& ModuleMask,
int Orient, bool include_fixe )
/*******************************************************************/
/**
* Function ReOrientModules
* Set the orientation of footprints
* @param ModuleMask = mask (wildcard allowed) selection
* @param Orient = new orientation
* @param include_fixe = true to orient locked footprints
* @return true if some footprints modified, false if no change
*/
{
wxString line;
bool modified = false;
line.Printf( _( "Ok to set footprints orientation to %.1f degrees ?" ), (double)Orient / 10 );
if( !IsOK( this, line ) )
return false;
for( MODULE* module = GetBoard()->m_Modules; module; module = module->Next() )
{
if( module->IsLocked() && !include_fixe )
continue;
if( WildCompareString( ModuleMask, module->m_Reference->m_Text, false ) )
{
modified = true;
Rotate_Module( NULL, module, Orient, false );
}
}
if ( modified )
OnModify();
return modified;
}
void PCB_BASE_FRAME::ResetModuleTextSizes( const wxString & aFilter, bool aRef,
bool aValue, bool aOthers )
{
BOARD_COMMIT commit( this );
int modTextWidth = GetDesignSettings().m_ModuleTextWidth;
const wxSize& modTextSize = GetDesignSettings().m_ModuleTextSize;
bool modified = false;
// Change fields of footprints with fpid matching the filter
for( MODULE* module = GetBoard()->m_Modules; module; module = module->Next() )
{
if( !aFilter.IsEmpty() )
{
if( ! WildCompareString( aFilter, FROM_UTF8( module->GetFPID().Format().c_str() ),
false ) )
continue;
}
if( aRef )
{
TEXTE_MODULE* item = &module->Reference();
if( item->GetTextSize() != GetDesignSettings().m_ModuleTextSize ||
item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
commit.Modify( item );
item->SetThickness( modTextWidth );
item->SetTextSize( modTextSize );
modified = true;
}
}
if( aValue )
{
TEXTE_MODULE* item = &module->Value();
if( item->GetTextSize() != GetDesignSettings().m_ModuleTextSize ||
item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
commit.Modify( item );
item->SetThickness( modTextWidth );
item->SetTextSize( modTextSize );
modified = true;
}
}
if( aOthers )
{
// Go through all other module text fields
for( BOARD_ITEM* boardItem = module->GraphicalItemsList(); boardItem; boardItem = boardItem->Next() )
{
if( boardItem->Type() == PCB_MODULE_TEXT_T )
{
TEXTE_MODULE* item = static_cast<TEXTE_MODULE*>( boardItem );
if( item->GetTextSize() != GetDesignSettings().m_ModuleTextSize
|| item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
commit.Modify( item );
item->SetThickness( modTextWidth );
item->SetTextSize( modTextSize );
modified = true;
}
}
}
}
}
if( modified )
{
commit.Push( "Reset module text size" );
GetCanvas()->Refresh();
}
}
void WinEDA_PcbFindFrame::FindItem(wxCommandEvent& event)
/********************************************************/
{
PCB_SCREEN * screen = m_Parent->GetScreen();
wxPoint locate_pos;
wxString msg;
bool succes = FALSE;
bool FindMarker = FALSE;
MODULE * Module;
int StartCount;
switch ( event.GetId() )
{
case ID_FIND_ITEM:
s_ItemCount = 0;
break;
case ID_FIND_MARKER: s_MarkerCount = 0;
case ID_FIND_NEXT_MARKER:
FindMarker = TRUE;
break;
}
s_OldStringFound = m_NewText->GetValue();
m_Parent->DrawPanel->GetViewStart(&screen->m_StartVisu.x, &screen->m_StartVisu.y);
StartCount = 0;
if( FindMarker )
{
MARQUEUR * Marker = (MARQUEUR *) m_Parent->m_Pcb->m_Drawings;
for( ; Marker != NULL; Marker = (MARQUEUR *)Marker->Pnext)
{
if( Marker->m_StructType != TYPEMARQUEUR ) continue;
StartCount++;
if ( StartCount > s_MarkerCount )
{
succes = TRUE;
locate_pos = Marker->m_Pos;
s_MarkerCount++;
break;
}
}
}
else for ( Module = m_Parent->m_Pcb->m_Modules; Module != NULL; Module = (MODULE*)Module->Pnext)
{
if( WildCompareString( s_OldStringFound, Module->m_Reference->m_Text.GetData(), FALSE ) )
{
StartCount++;
if ( StartCount > s_ItemCount )
{
succes = TRUE;
locate_pos = Module->m_Pos;
s_ItemCount++;
break;
}
}
if( WildCompareString( s_OldStringFound, Module->m_Value->m_Text.GetData(), FALSE ) )
{
StartCount++;
if ( StartCount > s_ItemCount )
{
succes = TRUE;
locate_pos = Module->m_Pos;
s_ItemCount++;
break;
}
}
}
if ( succes )
{ /* Il y a peut-etre necessite de recadrer le dessin: */
if( ! m_Parent->DrawPanel->IsPointOnDisplay(locate_pos) )
{
screen->m_Curseur = locate_pos;
m_Parent->Recadre_Trace(TRUE);
}
else
{ // Positionnement du curseur sur l'item
screen->Trace_Curseur(m_Parent->DrawPanel, m_DC);
screen->m_Curseur = locate_pos;
GRMouseWarp(m_Parent->DrawPanel, screen->m_Curseur );
m_Parent->DrawPanel->MouseToCursorSchema();
screen->Trace_Curseur(m_Parent->DrawPanel, m_DC);
}
if( FindMarker ) msg = _("Marker found");
else msg.Printf( _("<%s> Found"), s_OldStringFound.GetData() );
m_Parent->Affiche_Message(msg);
EndModal(1);
}
else
{
m_Parent->Affiche_Message(wxEmptyString);
if( FindMarker ) msg = _("Marker not found");
else msg.Printf( _("<%s> Not Found"), s_OldStringFound.GetData());
DisplayError(this,msg, 10);
}
EndModal(0);
}
wxString PCB_BASE_FRAME::SelectFootprint( EDA_DRAW_FRAME* aWindow,
const wxString& aLibraryName,
const wxString& aMask,
const wxString& aKeyWord,
FP_LIB_TABLE* aTable )
{
static wxString oldName; // Save the name of the last module loaded.
wxString fpname;
wxString msg;
wxArrayString libraries;
std::vector< wxArrayString > rows;
wxASSERT( aTable != NULL );
MList.ReadFootprintFiles( aTable, !aLibraryName ? NULL : &aLibraryName );
if( MList.GetErrorCount() )
{
MList.DisplayErrors( this );
return wxEmptyString;
}
if( MList.GetCount() == 0 )
{
wxString tmp;
for( unsigned i = 0; i < libraries.GetCount(); i++ )
{
tmp += libraries[i] + wxT( "\n" );
}
msg.Printf( _( "No footprints could be read from library file(s):\n\n%s\nin any of "
"the library search paths. Verify your system is configured properly "
"so the footprint libraries can be found." ), GetChars( tmp ) );
DisplayError( aWindow, msg );
return wxEmptyString;
}
if( !aKeyWord.IsEmpty() ) // Create a list of modules found by keyword.
{
for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
{
if( KeyWordOk( aKeyWord, MList.GetItem( ii ).GetKeywords() ) )
{
wxArrayString cols;
cols.Add( MList.GetItem( ii ).GetFootprintName() );
cols.Add( MList.GetItem( ii ).GetNickname() );
rows.push_back( cols );
}
}
}
else if( !aMask.IsEmpty() ) // Create a list of modules found by pattern
{
for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
{
const wxString& candidate = MList.GetItem( ii ).GetFootprintName();
if( WildCompareString( aMask, candidate, false ) )
{
wxArrayString cols;
cols.Add( MList.GetItem( ii ).GetFootprintName() );
cols.Add( MList.GetItem( ii ).GetNickname() );
rows.push_back( cols );
}
}
}
else // Create the full list of modules
{
for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
{
wxArrayString cols;
cols.Add( MList.GetItem( ii ).GetFootprintName() );
cols.Add( MList.GetItem( ii ).GetNickname() );
rows.push_back( cols );
}
}
if( !rows.empty() )
{
wxArrayString headers;
headers.Add( _( "Module" ) );
headers.Add( _( "Library" ) );
msg.Printf( _( "Modules [%d items]" ), (int) rows.size() );
EDA_LIST_DIALOG dlg( aWindow, msg, headers, rows, oldName, DisplayCmpDoc );
if( dlg.ShowModal() == wxID_OK )
{
fpname = dlg.GetTextSelection();
fpname = dlg.GetTextSelection( 1 ) + wxT( ":" ) + fpname;
SkipNextLeftButtonReleaseEvent();
}
else
fpname.Empty();
}
else
{
DisplayError( aWindow, _( "No footprint found." ) );
fpname.Empty();
}
if( fpname != wxEmptyString )
oldName = fpname;
wxLogDebug( wxT( "Footprint '%s' was selected." ), GetChars( fpname ) );
return fpname;
}
wxString WinEDA_BasePcbFrame::Select_1_Module_From_List(
wxWindow * active_window,
const wxString & Library,
const wxString & Mask, const wxString & KeyWord)
/***************************************************************/
/*
Affiche la liste des modules des librairies
Recherche dans la librairie Library ou generale si Library == NULL
Mask = Filtre d'affichage( Mask = wxEmptyString pour listage non filtré )
KeyWord = Liste de mots cles, Recherche limitee aux composants
ayant ces mots cles ( KeyWord = wxEmptyString pour listage de tous les modules )
retourne wxEmptyString si abort ou probleme
ou le nom du module
*/
{
int LineNum;
unsigned ii, NbModules;
char Line[1024];
wxString FullLibName;
static wxString OldName; /* Memorise le nom du dernier composant charge */
wxString CmpName;
FILE * lib_module;
wxString msg;
WinEDAListBox * ListBox = new WinEDAListBox(active_window, wxEmptyString,
NULL, OldName, DisplayCmpDoc, wxColour(200, 200, 255) );
wxBeginBusyCursor();
/* Recherche des composants en librairies */
NbModules = 0;
for( ii = 0; ii < g_LibName_List.GetCount(); ii++)
{
/* Calcul du nom complet de la librairie */
if( Library.IsEmpty() )
{
FullLibName = MakeFileName(g_RealLibDirBuffer,
g_LibName_List[ii], LibExtBuffer);
}
else
FullLibName = MakeFileName(g_RealLibDirBuffer,Library,LibExtBuffer);
ReadDocLib(FullLibName );
if( ! KeyWord.IsEmpty()) /* Inutile de lire la librairie si selection
par mots cles, deja lus */
{
if( ! Library.IsEmpty() ) break;
continue ;
}
if ((lib_module = wxFopen(FullLibName, wxT("rt"))) == NULL )
{
if( ! Library.IsEmpty() ) break;
continue ;
}
msg = _("Library: "); msg << FullLibName;
Affiche_Message(msg);
/* lecture entete */
LineNum = 0;
GetLine(lib_module, Line, &LineNum, sizeof(Line) -1);
if(strnicmp( Line,ENTETE_LIBRAIRIE, L_ENTETE_LIB) != 0)
{
DisplayError(this, wxT("This file is not an Eeschema libray file"), 20); continue;
}
/* Lecture de la librairie */
while( GetLine(lib_module,Line, &LineNum, sizeof(Line) -1) )
{
if( Line[0] != '$' ) continue;
if( strnicmp( Line, "$MODULE",6) == 0 ) break;
if( strnicmp( Line,"$INDEX",6) == 0 )
{
while( GetLine(lib_module,Line, &LineNum) )
{
if( strnicmp( Line,"$EndINDEX",9) == 0 ) break;
strupper(Line);
msg = CONV_FROM_UTF8(StrPurge(Line));
if ( Mask.IsEmpty() )
{
ListBox->Append( msg );
NbModules++;
}
else if ( WildCompareString(Mask, msg, FALSE) )
{
ListBox->Append( msg );
NbModules++;
}
}
} /* Fin Lecture INDEX */
} /* Fin lecture 1 Librairie */
fclose(lib_module) ; lib_module = NULL;
if( ! Library.IsEmpty() ) break;
}
/* creation de la liste des modules si recherche par mots-cles */
if( ! KeyWord.IsEmpty() )
{
ModList * ItemMod = MList;
while( ItemMod != NULL )
{
if( KeyWordOk(KeyWord, ItemMod->m_KeyWord) )
{
NbModules++;
ListBox->Append( ItemMod->m_Name );
}
ItemMod = ItemMod->Next;
}
}
wxEndBusyCursor();
msg.Printf( _("Modules (%d items)"), NbModules);
ListBox->SetTitle(msg);
ListBox->SortList();
ii = ListBox->ShowModal();
if ( ii >= 0 ) CmpName = ListBox->GetTextSelection();
else CmpName.Empty();
ListBox->Destroy();
/* liberation mem de la liste des textes doc module */
while( MList != NULL )
{
ModList * NewMod = MList->Next;
delete MList;
MList = NewMod;
}
if( CmpName != wxEmptyString ) OldName = CmpName;
return(CmpName);
}
void PCB_BASE_FRAME::ResetModuleTextSizes( const wxString & aFilter, bool aRef,
bool aValue, bool aOthers )
{
MODULE* module;
BOARD_ITEM* boardItem;
ITEM_PICKER itemWrapper( NULL, UR_CHANGED );
PICKED_ITEMS_LIST undoItemList;
unsigned int ii;
// Prepare undo list
for( module = GetBoard()->m_Modules; module; module = module->Next() )
{
itemWrapper.SetItem( module );
if( ! aFilter.IsEmpty() )
{
if( ! WildCompareString( aFilter, FROM_UTF8( module->GetFPID().Format().c_str() ),
false ) )
continue;
}
if( aRef )
{
TEXTE_MODULE *item = &module->Reference();
if( item->GetSize() != GetDesignSettings().m_ModuleTextSize ||
item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
undoItemList.PushItem( itemWrapper );
}
}
if( aValue )
{
TEXTE_MODULE *item = &module->Value();
if( item->GetSize() != GetDesignSettings().m_ModuleTextSize ||
item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
undoItemList.PushItem( itemWrapper );
}
}
if( aOthers )
{
// Go through all other module text fields
for( boardItem = module->GraphicalItems(); boardItem; boardItem = boardItem->Next() )
{
if( boardItem->Type() == PCB_MODULE_TEXT_T )
{
TEXTE_MODULE *item = static_cast<TEXTE_MODULE*>( boardItem );
if( item->GetSize() != GetDesignSettings().m_ModuleTextSize
|| item->GetThickness() != GetDesignSettings().m_ModuleTextWidth )
{
undoItemList.PushItem( itemWrapper );
}
}
}
}
}
// Exit if there's nothing to do
if( !undoItemList.GetCount() )
return;
SaveCopyInUndoList( undoItemList, UR_CHANGED );
// Apply changes to modules in the undo list
for( ii = 0; ii < undoItemList.GetCount(); ii++ )
{
module = (MODULE*) undoItemList.GetPickedItem( ii );
if( aRef )
{
module->Reference().SetThickness( GetDesignSettings().m_ModuleTextWidth );
module->Reference().SetSize( GetDesignSettings().m_ModuleTextSize );
}
if( aValue )
{
module->Value().SetThickness( GetDesignSettings().m_ModuleTextWidth );
module->Value().SetSize( GetDesignSettings().m_ModuleTextSize );
}
if( aOthers )
{
for( boardItem = module->GraphicalItems(); boardItem; boardItem = boardItem->Next() )
{
if( boardItem->Type() == PCB_MODULE_TEXT_T )
{
TEXTE_MODULE *item = static_cast<TEXTE_MODULE*>( boardItem );
item->SetThickness( GetDesignSettings().m_ModuleTextWidth );
item->SetSize( GetDesignSettings().m_ModuleTextSize );
}
}
}
}
OnModify();
}
void PCB_EDIT_FRAME::ListNetsAndSelect( wxCommandEvent& event )
{
NETINFO_ITEM* net;
wxString netFilter;
wxArrayString list;
netFilter = wxT( "*" );
wxTextEntryDialog dlg( this, _( "Filter Net Names" ), _( "Net Filter" ), netFilter );
if( dlg.ShowModal() != wxID_OK )
return; // cancelled by user
netFilter = dlg.GetValue( );
if( netFilter.IsEmpty() )
return;
wxString Line;
for( unsigned ii = 0; ii < GetBoard()->GetNetCount(); ii++ )
{
net = GetBoard()->m_NetInfo.GetNetItem( ii );
if( !WildCompareString( netFilter, net->GetNetname(), false ) )
continue;
Line.Printf( wxT( "net %3.3d: %s" ), net->GetNet(),
GetChars( net->GetNetname() ) );
list.Add( Line );
}
wxSingleChoiceDialog choiceDlg( this, wxEmptyString, _( "Select Net" ), list );
if( (choiceDlg.ShowModal() == wxID_CANCEL) || (choiceDlg.GetSelection() == wxNOT_FOUND) )
return;
bool found = false;
unsigned netcode = (unsigned) choiceDlg.GetSelection();
// Search for the net selected.
for( unsigned ii = 0; ii < GetBoard()->GetNetCount(); ii++ )
{
net = GetBoard()->FindNet( ii );
if( !WildCompareString( netFilter, net->GetNetname(), false ) )
continue;
if( ii == netcode )
{
netcode = net->GetNet();
found = true;
break;
}
}
if( found )
{
INSTALL_UNBUFFERED_DC( dc, m_canvas );
if( GetBoard()->IsHighLightNetON() )
HighLight( &dc );
GetBoard()->SetHighLightNet( netcode );
HighLight( &dc );
}
}
void WinEDA_FindFrame::LocatePartInLibs(wxCommandEvent& event)
/*************************************************************/
/* Recherche exhaustive d'un composant en librairies, meme non chargees
*/
{
wxString Text, FindList;
const wxChar ** ListNames;
LibraryStruct *Lib = NULL;
EDA_LibComponentStruct * LibEntry;
bool FoundInLib = FALSE; // True si reference trouvee ailleurs qu'en cache
Text = m_NewTextCtrl->GetData();
if ( Text.IsEmpty() )
{
Close(); return;
}
s_OldStringFound = Text;
int ii, nbitems, NumOfLibs = NumOfLibraries();
if (NumOfLibs == 0)
{
DisplayError(this, _("No libraries are loaded"));
Close(); return;
}
ListNames = GetLibNames();
nbitems = 0;
for (ii = 0; ii < NumOfLibs; ii++ ) /* Recherche de la librairie */
{
bool IsLibCache;
Lib = FindLibrary(ListNames[ii]);
if ( Lib == NULL ) break;
if ( Lib->m_Name.Contains( wxT(".cache")) ) IsLibCache = TRUE;
else IsLibCache = FALSE;
LibEntry = (EDA_LibComponentStruct *) PQFirst(&Lib->m_Entries, FALSE);
while( LibEntry )
{
if( WildCompareString(Text, LibEntry->m_Name.m_Text, FALSE) )
{
nbitems ++;
if ( ! IsLibCache ) FoundInLib = TRUE;
if ( ! FindList.IsEmpty() ) FindList += wxT("\n");
FindList << _("Found ")
+ LibEntry->m_Name.m_Text
+ _(" in lib ") + Lib->m_Name;
}
LibEntry = (EDA_LibComponentStruct *) PQNext(Lib->m_Entries, LibEntry, NULL);
}
}
free (ListNames);
if ( ! FoundInLib )
{
if ( nbitems ) FindList = wxT("\n") + Text + _(" found only in cache");
else FindList = Text + _(" not found");
FindList += _("\nExplore All Libraries?");
if ( IsOK(this, FindList) )
{
FindList.Empty();
ExploreAllLibraries(Text, FindList);
if ( FindList.IsEmpty() ) DisplayInfo(this, _("Nothing found") );
else DisplayInfo(this, FindList);
}
}
else DisplayInfo(this, FindList);
Close();
}
EDA_BaseStruct * WinEDA_SchematicFrame::FindSchematicItem(
const wxString & pattern, int SearchType)
/************************************************************************/
/* Find a string in schematic.
Search is made in current sheet (SearchType = 0),
or the whole hierarchy (SearchType = 1),
or for the next item (SearchType = 2).
Mouse cursor is put on item
*/
{
SCH_SCREEN * Screen, * FirstScreen = NULL;
EDA_BaseStruct *DrawList = NULL, *FirstStruct = NULL, *Struct = NULL;
int NotFound, StartCount, ii, jj;
wxPoint firstpos, pos;
static int FindAll;
wxSize size = DrawPanel->GetClientSize();
wxPoint curpos;
bool force_recadre = FALSE;
wxString msg, WildText;
g_LastSearchIsMarker = FALSE;
Screen = ScreenSch;
if( SearchType == 0 )
{
s_OldStringFound = pattern;
Screen = (SCH_SCREEN*) m_CurrentScreen; FindAll = FALSE;
}
if( SearchType == 1 )
{
s_OldStringFound = pattern;
FindAll = TRUE;
}
if( SearchType != 2 ) ItemsCount = 0;
WildText = s_OldStringFound;
NotFound = 1; StartCount = 0;
for ( ; Screen != NULL; Screen = Screen->Next() )
{
DrawList = Screen->EEDrawList;
while ( DrawList )
{
switch (DrawList->m_StructType)
{
case DRAW_LIB_ITEM_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((EDA_SchComponentStruct*)DrawList)
if( WildCompareString( WildText, STRUCT->m_Field[REFERENCE].m_Text, FALSE ) )
{
NotFound = 0;
pos = STRUCT->m_Field[REFERENCE].m_Pos;
break;
}
if( WildCompareString( WildText, STRUCT->m_Field[VALUE].m_Text, FALSE ) )
{
NotFound = 0;
pos = STRUCT->m_Field[VALUE].m_Pos;
}
break;
case DRAW_LABEL_STRUCT_TYPE :
case DRAW_GLOBAL_LABEL_STRUCT_TYPE :
case DRAW_TEXT_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawTextStruct*)DrawList)
if( WildCompareString( WildText, STRUCT->m_Text, FALSE ) )
{
NotFound = 0;
pos = STRUCT->m_Pos;
}
break;
default:
break;
}
if(NotFound == 0) /* Element trouve */
{
if ( FirstScreen == NULL ) /* 1er element trouve */
{
FirstScreen = Screen; firstpos = pos;
FirstStruct = DrawList;
}
StartCount++;
if( ItemsCount >= StartCount )
{
NotFound = 1; /* Continue recherche de l'element suivant */
}
else
{
Struct = DrawList; ItemsCount++; break ;
}
}
if( NotFound == 0 ) break;
DrawList = DrawList->Pnext;
}
if( NotFound == 0 ) break;
if( FindAll == FALSE ) break;
}
if( NotFound && FirstScreen )
{
NotFound = 0; Screen = FirstScreen; Struct = FirstStruct;
pos = firstpos; ItemsCount = 1;
}
if( NotFound == 0)
{
if ( Screen != GetScreen() )
{
Screen->SetZoom(GetScreen()->GetZoom() );
m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE;
}
/* Si la struct localisee est du type DRAW_LIB_ITEM_STRUCT_TYPE,
Les coordonnes sont a recalculer en fonction de la matrice
d'orientation */
if( Struct->m_StructType == DRAW_LIB_ITEM_STRUCT_TYPE )
{
#undef STRUCT
#define STRUCT ((EDA_SchComponentStruct*)Struct)
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;
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->m_Curseur = pos;
curpos = DrawPanel->CursorScreenPosition();
DrawPanel->GetViewStart(&m_CurrentScreen->m_StartVisu.x,
&m_CurrentScreen->m_StartVisu.y);
// calcul des coord curseur avec origine = screen
curpos.x -= m_CurrentScreen->m_StartVisu.x;
curpos.y -= m_CurrentScreen->m_StartVisu.y;
/* Il y a peut-etre necessite de recadrer le dessin: */
if( (curpos.x <= 0) || (curpos.x >= size.x-1) ||
(curpos.y <= 0) || (curpos.y >= size.y) || force_recadre )
{
Recadre_Trace(TRUE);
}
else
{
GRMouseWarp(DrawPanel, curpos );
}
msg = WildText + _(" Found in ") + Screen->m_FileName;
Affiche_Message(msg);
}
else
{
Affiche_Message(wxEmptyString);
msg = WildText + _(" Not Found");
DisplayError(this,msg, 10);
}
return DrawList;
}
void WinEDA_PcbFindFrame::FindItem( wxCommandEvent& event )
{
PCB_SCREEN* screen = (PCB_SCREEN*) ( m_Parent->GetScreen() );
wxPoint locate_pos;
wxString msg;
bool FindMarker = false;
BOARD_ITEM* foundItem = 0;
switch( event.GetId() )
{
case ID_FIND_ITEM:
s_ItemCount = 0;
break;
case ID_FIND_MARKER:
s_MarkerCount = 0;
// fall thru
case ID_FIND_NEXT_MARKER:
FindMarker = true;
break;
}
s_OldStringFound = m_NewText->GetValue();
m_Parent->GetCanvas()->GetViewStart( &screen->m_StartVisu.x, &screen->m_StartVisu.y );
if( FindMarker )
{
MARKER_PCB* marker = m_Parent->GetBoard()->GetMARKER( s_MarkerCount++ );
if( marker )
{
foundItem = marker;
locate_pos = marker->GetPosition();
}
}
else
{
int StartCount = 0;
for( MODULE* module = m_Parent->GetBoard()->m_Modules; module; module = module->Next() )
{
if( WildCompareString( s_OldStringFound, module->GetReference().GetData(), false ) )
{
StartCount++;
if( StartCount > s_ItemCount )
{
foundItem = module;
locate_pos = module->GetPosition();
s_ItemCount++;
break;
}
}
if( WildCompareString( s_OldStringFound, module->m_Value->m_Text.GetData(), false ) )
{
StartCount++;
if( StartCount > s_ItemCount )
{
foundItem = module;
locate_pos = module->m_Pos;
s_ItemCount++;
break;
}
}
}
}
if( foundItem )
{
m_Parent->SetCurItem( foundItem );
if( FindMarker )
msg = _( "Marker found" );
else
msg.Printf( _( "<%s> Found" ), GetChars( s_OldStringFound ) );
m_Parent->SetStatusText( msg );
m_Parent->CursorGoto( locate_pos );
EndModal( 1 );
}
else
{
m_Parent->SetStatusText( wxEmptyString );
if( FindMarker )
msg = _( "Marker not found" );
else
msg.Printf( _( "<%s> Not Found" ), GetChars( s_OldStringFound ) );
DisplayError( this, msg, 10 );
EndModal( 0 );
}
}
