/****************************************************************/
		/* Routines de deplacement automatique et rotation  des MODULES */
		/* routines et menu d'autoplacement								*/
		/****************************************************************/

		/* Fichier automove.cpp */

#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"
#include "autorout.h"
#include "cell.h"
#include "id.h"

#include "protos.h"


/* variables locales */

typedef enum {
	FIXE_MODULE,
	FREE_MODULE,
	FIXE_ALL_MODULES,
	FREE_ALL_MODULES
	} SelectFixeFct;


/* Fonctions locales */
static int tri_modules(MODULE ** pt_ref, MODULE ** pt_compare);

/* Variables locales */
wxString ModulesMaskSelection = wxT("*");
int ModulesNewOrient;


/******************************************************/
void WinEDA_PcbFrame::AutoPlace(wxCommandEvent& event)
/******************************************************/
/* Traite les selections d'outils et les commandes appelees du menu POPUP
*/
{
int id = event.GetId();
wxPoint pos;
wxClientDC dc(DrawPanel);
bool on_state;

	if ( m_HToolBar == NULL ) return;

	DrawPanel->PrepareGraphicContext(&dc);

	wxGetMousePosition(&pos.x, &pos.y);

	switch ( id )	// Arret eventuel de la commande de déplacement en cours
		{
		case ID_POPUP_CANCEL_CURRENT_COMMAND:
			if( DrawPanel->ManageCurseur &&
				DrawPanel->ForceCloseManageCurseur )
				{
				DrawPanel->ForceCloseManageCurseur(DrawPanel, &dc);
				}
			break;

		default:	// Arret de la commande de déplacement en cours
			if( DrawPanel->ManageCurseur &&
				DrawPanel->ForceCloseManageCurseur )
				{
				DrawPanel->ForceCloseManageCurseur(DrawPanel, &dc);
				}
			m_ID_current_state = 0;
			DisplayToolMsg(wxEmptyString);
			DrawPanel->SetCursor(wxCursor(wxCURSOR_ARROW) );
			break;
		}

	/* Erase rastnest if needed */
	if(g_Show_Ratsnest) DrawGeneralRatsnest(&dc);
	m_Pcb->m_Status_Pcb |= DO_NOT_SHOW_GENERAL_RASTNEST;

	switch ( id )	// Traitement des commandes
		{
		case ID_TOOLBARH_PCB_AUTOPLACE:
			on_state = m_HToolBar->GetToolState(ID_TOOLBARH_PCB_AUTOPLACE);
			if ( on_state )
				{
				m_HToolBar->ToggleTool(ID_TOOLBARH_PCB_AUTOROUTE, FALSE);
				m_HTOOL_current_state = ID_TOOLBARH_PCB_AUTOPLACE;
				}
			else m_HTOOL_current_state = 0;
			break;

		case ID_TOOLBARH_PCB_AUTOROUTE:
			on_state = m_HToolBar->GetToolState(ID_TOOLBARH_PCB_AUTOROUTE);
			if ( on_state )
				{
				m_HToolBar->ToggleTool(ID_TOOLBARH_PCB_AUTOPLACE, FALSE);
				m_HTOOL_current_state = ID_TOOLBARH_PCB_AUTOROUTE;
				}
			else m_HTOOL_current_state = 0;
			break;

		case ID_POPUP_PCB_AUTOPLACE_FIXE_MODULE:
			FixeModule((MODULE *) m_CurrentScreen->m_CurrentItem, TRUE);
			break;

		case ID_POPUP_PCB_AUTOPLACE_FREE_MODULE:
	        FixeModule((MODULE *) m_CurrentScreen->m_CurrentItem, FALSE);
			break;

		case ID_POPUP_PCB_AUTOPLACE_FREE_ALL_MODULES:
			FixeModule(NULL, FALSE);
			break;

		case ID_POPUP_PCB_AUTOPLACE_FIXE_ALL_MODULES:
			FixeModule(NULL, TRUE);
			break;

		case ID_POPUP_PCB_AUTOPLACE_CURRENT_MODULE:
			AutoPlaceModule((MODULE *) m_CurrentScreen->m_CurrentItem,
				PLACE_1_MODULE, &dc);
			break;

		case ID_POPUP_PCB_AUTOPLACE_ALL_MODULES:
			AutoPlaceModule(NULL, PLACE_ALL, &dc);
			break;

		case ID_POPUP_PCB_AUTOPLACE_NEW_MODULES:
			AutoPlaceModule(NULL, PLACE_OUT_OF_BOARD, &dc);
			break;

		case ID_POPUP_PCB_AUTOPLACE_NEXT_MODULE:
			AutoPlaceModule(NULL, PLACE_INCREMENTAL, &dc);
			break;

		case ID_POPUP_PCB_AUTOMOVE_ALL_MODULES:
			AutoMoveModulesOnPcb(&dc, FALSE);
			break;

		case ID_POPUP_PCB_AUTOMOVE_NEW_MODULES:
			AutoMoveModulesOnPcb(&dc, TRUE);
			break;

		case ID_POPUP_PCB_REORIENT_ALL_MODULES:
			ReOrientModules(ModulesMaskSelection, ModulesNewOrient, FALSE, &dc);
			break;

		case ID_POPUP_PCB_AUTOROUTE_ALL_MODULES:
			Autoroute(&dc, ROUTE_ALL);
			break;

		case ID_POPUP_PCB_AUTOROUTE_MODULE:
			Autoroute(&dc, ROUTE_MODULE);
			break;

		case ID_POPUP_PCB_AUTOROUTE_PAD:
			Autoroute(&dc, ROUTE_PAD);
			break;

		case ID_POPUP_PCB_AUTOROUTE_NET:
			Autoroute(&dc, ROUTE_NET);
			break;

		case ID_POPUP_PCB_AUTOROUTE_RESET_UNROUTED:
			Reset_Noroutable(&dc);
			break;

		case ID_POPUP_PCB_AUTOROUTE_SELECT_LAYERS:
			break;

		default:
			DisplayError(this, wxT("AutoPlace command error") );
			break;
		}
	m_Pcb->m_Status_Pcb &= ~DO_NOT_SHOW_GENERAL_RASTNEST;
	ReCompile_Ratsnest_After_Changes( &dc );
	SetToolbars();
}

/*****************************************************************************/
void WinEDA_PcbFrame::AutoMoveModulesOnPcb(wxDC * DC, bool PlaceModulesHorsPcb)
/*****************************************************************************/
/* Routine de repartition des composants dans un rectangle de format 4 / 3,
	partant du curseur souris
	Les composants ayant le status FIXE ne sont normalement pas bouges
	Selon les flags:
		Tous les modules (non fixes) seront repartis
		Seuls les modules Hors PCB seront repartis
*/
{
MODULE ** pt_Dmod, ** BaseListeModules;
MODULE * Module;
wxPoint start, current;
int Ymax_size, Xsize_allowed;
int pas_grille = m_CurrentScreen->GetGrid().x;
bool EdgeExists;
float surface;

	if( m_Pcb->m_Modules == NULL )
		{
		DisplayError(this, _("No Modules!"), 10);return;
		}

	/* Confirmation */
	if( ! IsOK(this, _("Move Modules ?") ) ) return;

	EdgeExists = SetBoardBoundaryBoxFromEdgesOnly();

	if( PlaceModulesHorsPcb && ! EdgeExists )
		{
		DisplayError(this,
			_("Autoplace modules: No boad edges detected, unable to place modules"), 20);
		return;
		}

	Module = m_Pcb->m_Modules;
	for( ; Module != NULL; Module = (MODULE*)Module->Pnext) // remise a jour du rect d'encadrement
       	{
		Module->Set_Rectangle_Encadrement();
		Module->SetRectangleExinscrit();
		}
	BaseListeModules = GenListeModules(m_Pcb, NULL);

	/* Si repartition de modules Hors PCB, le curseur est mis au dessous
		du PCB, pour eviter de placer des composants dans la zone PCB
	*/
	if( PlaceModulesHorsPcb && EdgeExists )
		{
		if( m_CurrentScreen->m_Curseur.y < (m_Pcb->m_BoundaryBox.GetBottom() + 2000) )
			m_CurrentScreen->m_Curseur.y = m_Pcb->m_BoundaryBox.GetBottom() + 2000;
		}

	/* calcul de la surface occupee par les circuits */
	surface = 0.0;
	for( pt_Dmod = BaseListeModules; *pt_Dmod != NULL; pt_Dmod++)
		{
		Module = *pt_Dmod;
		if( PlaceModulesHorsPcb && EdgeExists )
			{
			if( m_Pcb->m_BoundaryBox.Inside(Module->m_Pos) )
				continue;
			}
		surface += Module->m_Surface;
		}
	Xsize_allowed = (int)(sqrt(surface) * 4.0 /3.0);

	/* Placement des modules */
	start = current = m_CurrentScreen->m_Curseur;
	Ymax_size = 0;

	for( pt_Dmod = BaseListeModules; *pt_Dmod != NULL; pt_Dmod++)
		{
		Module = *pt_Dmod;
		if( Module->m_ModuleStatus & MODULE_is_LOCKED ) continue;

		if( PlaceModulesHorsPcb && EdgeExists )
			{
			if( m_Pcb->m_BoundaryBox.Inside(Module->m_Pos) )
				continue;
			}

		if( current.x > (Xsize_allowed + start.x)  )
			{
			current.x = start.x;
			current.y += Ymax_size + pas_grille;
			Ymax_size = 0;
			}

		m_CurrentScreen->m_Curseur.x =
			current.x + Module->m_Pos.x - Module->m_RealBoundaryBox.GetX();
		m_CurrentScreen->m_Curseur.y =
			current.y + Module->m_Pos.y - Module->m_RealBoundaryBox.GetY();
		Ymax_size = MAX(Ymax_size, Module->m_RealBoundaryBox.GetHeight());

		PutOnGrid(&m_CurrentScreen->m_Curseur);

		Module->Draw(DrawPanel, DC, wxPoint(0, 0), GR_XOR);
		Place_Module(Module, DC);	/* positionne Module et recalcule cadre */

		current.x += Module->m_RealBoundaryBox.GetWidth ()+ pas_grille;
		}

	MyFree( BaseListeModules);
	m_CurrentScreen->SetRefreshReq();
}


/***********************************************************/
void WinEDA_PcbFrame::FixeModule(MODULE * Module, bool Fixe)
/***********************************************************/
/* Met a jour (FALSE ou TRUE) l'attribut FIXE sur le module Module,
ou sur tous les modules si Modulle == NULL
*/
{
	if ( Module)	/* Traitement du module */
	{
		if ( Fixe ) Module->m_ModuleStatus |= MODULE_is_LOCKED;
		else Module->m_ModuleStatus &= ~MODULE_is_LOCKED;
		Module->Display_Infos(this);
		GetScreen()->SetModify();
	}

	else
	{
		Module = m_Pcb->m_Modules;
		for( ; Module != NULL; Module = (MODULE*)Module->Pnext)
		{
			if( WildCompareString(ModulesMaskSelection, Module->m_Reference->m_Text) )
			{
				if ( Fixe ) Module->m_ModuleStatus |= MODULE_is_LOCKED;
				else Module->m_ModuleStatus &= ~MODULE_is_LOCKED;
				GetScreen()->SetModify();
			}
		}
	}
}

/*******************************************************************/
void WinEDA_PcbFrame::ReOrientModules(const wxString & ModuleMask,
				int Orient,	bool include_fixe, wxDC * DC)
/*******************************************************************/
/*
	Reoriente tous les modules selon masque et attribut, avec la nouvelle
	orientation selectionnee
*/
{
MODULE * Module;
wxString line;

	line.Printf( _("Ok to set module orientation to %d degrees ?"), Orient/10);
	if( !IsOK(this, line ) )return;

	Module = m_Pcb->m_Modules;
	for( ; Module != NULL; Module = (MODULE*)Module->Pnext)
	{
		if( (Module->m_ModuleStatus & MODULE_is_LOCKED ) && ! include_fixe )
			continue;

		if( WildCompareString(ModuleMask, Module->m_Reference->m_Text, FALSE ) )
		{
			m_CurrentScreen->SetModify();
			Module->Draw(DrawPanel, DC, wxPoint(0,0), GR_XOR);
			Rotate_Module( NULL, Module, Orient, FALSE );
			Module->Draw(DrawPanel, DC, wxPoint(0,0), GR_OR);
		}
	}
}


/*********************************************************/
MODULE ** GenListeModules( BOARD * Pcb, int * NbModules )
/*********************************************************/
/* Cree par allocation memoire la liste ordonnee des structures D_MODULES
	decrivant les modules a deplacer
	la fin de la liste est signalee par NULL
	Retourne egalement le nombre de modules par *NbModules
	Penser a desallouer la memoire apres usage
*/
{
MODULE * Module;
MODULE ** ListeMod, ** PtList;
int NbMod;

	/* Reservation de la memoire pour description des modules que l'on
	peut deplacer */
	Module = Pcb->m_Modules;
	NbMod = 0;
	for( ; Module != NULL; Module = (MODULE*)Module->Pnext) NbMod++;

	ListeMod = (MODULE**) MyZMalloc( (NbMod+1) * sizeof(MODULE*) );
	if(ListeMod == NULL )
		{
		if( NbModules != NULL ) *NbModules = 0;
		return(NULL);
		}

	PtList = ListeMod;
	Module = Pcb->m_Modules;
	for( ; Module != NULL; Module = (MODULE*)Module->Pnext)
		{
		*PtList = Module; PtList++;
		Module->SetRectangleExinscrit();
		}

	/* Tri par surface decroissante des modules ( on place les plus gros en 1er) */
	qsort(ListeMod, NbMod, sizeof(MODULE**),
			(int(*)(const void *, const void * ))tri_modules);

	if( NbModules != NULL ) *NbModules = NbMod;
	return( ListeMod );
}

	/**************************************************/
	/* Routine de tri de modules, utilisee par qsort: */
	/**************************************************/

static int tri_modules(MODULE ** pt_ref, MODULE ** pt_compare)
{
float ff ;

	ff = (*pt_ref)->m_Surface - (*pt_compare)->m_Surface ;
	if( ff < 0 ) return(1) ;
	if( ff > 0 ) return(-1) ;
	return( 0 );
}