/*
 * FichaWindow.java
 *
 * Created on 29 de Marco de 2004, 11:50
 */

package siprp.ficha;

import java.awt.FileDialog;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FilenameFilter;
import java.text.DateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Vector;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.XMLOutputter;

import siprp.FichaDataProvider;
import siprp.data.EmpresaData;
import siprp.data.EstabelecimentoData;
import siprp.data.ExameData;
import siprp.data.MedicoData;
import siprp.data.TrabalhadorData;
import siprp.importer.Importer;
import siprp.medicina.MarcacoesMedicinaHandler;

import com.evolute.utils.Singleton;
import com.evolute.utils.data.IDObject;
import com.evolute.utils.jdo.JDOProvider;
import com.evolute.utils.strings.StringPlainer;
import com.evolute.utils.ui.DialogException;
import com.evolute.utils.ui.dialog.ListAction;
import com.evolute.utils.ui.dialog.ListActionDialog;
import com.evolute.utils.ui.search.SearchDialog;
import com.evolute.utils.ui.window.ActionHandler;
import com.evolute.utils.ui.window.ProgressDialog;
import com.evolute.utils.ui.window.TabbedWindow;

/**
 *
 * @author  fpalma
 */
public class FichaWindow extends TabbedWindow
	implements ListAction, FichaAptidaoConstants
{	
	private JDOProvider JDO;
	
	private UpperPanel upperPanel;
	private EmpresaPanel empresaPanel;
	private TrabalhadorPanel trabalhadorPanel;
	private ObservacoesPanel observacoesPanel;
	private ExamePanel examePanel;

	private FichaDataProvider fdpProvider;
	private MarcacoesMedicinaHandler marcacoesHandler;
	private Integer empresaID;
	private Integer estabelecimentoID;
	private Integer trabalhadorID;
	
	private final ExamePDF ePDF = new ExamePDF();
	
	private static int permissions[][] = 
		new int[][]{ { NEW_INDEX, CANCEL_INDEX, SAVE_INDEX } };
	
	private static FichaWindow window = null;
	
	private Integer imposedTrabalhadorID = null;
	private SaveExameListener exameListener = null;
	
	private boolean useFO = false;
	
	/** Creates a new instance of FichaWindow */
	private FichaWindow()
		throws Exception
	{
		super( new UpperPanel(), new String[]{ "Empresa/Trabalhador", "Exame" }, 
				createPermissions( permissions ) );
		setEditorManagerFactory( FichaAptidaoEditorManager.getEditorManagerFactory() );
		upperPanel = (UpperPanel) getUpperPanel();
		upperPanel.owner = this;
		fdpProvider = ( FichaDataProvider ) FichaDataProvider.getProvider();
		JDO = ( JDOProvider ) Singleton.getInstance( Singleton.DEFAULT_JDO_PROVIDER );
		marcacoesHandler = new MarcacoesMedicinaHandler();
		setupComponents();
	}
	
	public static FichaWindow getWindow()
		throws Exception
	{
		if( window == null )
		{
			window = new FichaWindow();
		}
		return window;
	}
	
	private void setupComponents()
		throws Exception
	{
		setSize( 700, 640 );
		setResizable( false );
		setTitle( "Ficha de Aptid\u00e3o" );
		
		JPanel empresaTrabalhadorPanel = getTab( 0 );
		JPanel exameRecomendacoesPanel = getTab( 1 );
		
		GridBagLayout gridbag = new GridBagLayout();
		empresaTrabalhadorPanel.setLayout( gridbag );
		GridBagConstraints constraints = new GridBagConstraints();
		constraints.insets = new Insets( 0, 1, 0, 1 );
		constraints.fill = GridBagConstraints.BOTH;
		constraints.weightx = 1;
		constraints.gridwidth = GridBagConstraints.REMAINDER;
		constraints.gridheight = 1;
		constraints.weighty = 0;
		
		empresaPanel = new EmpresaPanel();
		empresaPanel.setEnabled( false );
		gridbag.setConstraints( empresaPanel, constraints );
		empresaTrabalhadorPanel.add( empresaPanel );
		
		constraints.weighty = 0;
		trabalhadorPanel = new TrabalhadorPanel();
		gridbag.setConstraints( trabalhadorPanel, constraints );
		empresaTrabalhadorPanel.add( trabalhadorPanel );
		
		constraints.weighty = 1;
		observacoesPanel = new ObservacoesPanel();
		gridbag.setConstraints( observacoesPanel, constraints );
		empresaTrabalhadorPanel.add( observacoesPanel );
		
		
		gridbag = new GridBagLayout();
		exameRecomendacoesPanel.setLayout( gridbag );
		constraints = new GridBagConstraints();
		constraints.insets = new Insets( 0, 1, 0, 1 );
		constraints.fill = GridBagConstraints.BOTH;
		constraints.weightx = 1;
		constraints.gridwidth = GridBagConstraints.REMAINDER;
		constraints.gridheight = 1;
		constraints.weighty = 0;
				
		constraints.weighty = 1;
		examePanel = new ExamePanel();
		gridbag.setConstraints( examePanel, constraints );
		exameRecomendacoesPanel.add( examePanel );
		
		registerAction( new ActionHandler(){
							public void execute()
							{
								print();
							}
							
							public boolean activate( boolean newAction, boolean editAction, 
														boolean cancelAction, boolean saveAction,
														boolean deleteAction, boolean selectAction )
							{
								return saveAction || editAction;
							}
						}, "Imprimir", 
						"Imprimir Ficha", "print",
						0, true );
		
		registerAction( new ActionHandler(){
							public void execute()
							{
								printOld();
							}
							
							public boolean activate( boolean newAction, boolean editAction, 
														boolean cancelAction, boolean saveAction,
														boolean deleteAction, boolean selectAction )
							{
								return saveAction || editAction;
							}
						}, "Imprimir Fichas Anteriores", 
						"Imprimir Fichas Anteriores", null,
						0, false );
		
		registerAction( new ActionHandler(){
							public void execute()
							{
								printOldFO();
							}
							
							public boolean activate( boolean newAction, boolean editAction, 
														boolean cancelAction, boolean saveAction,
														boolean deleteAction, boolean selectAction )
							{
								return saveAction || editAction;
							}
						}, "Imprimir Fichas Anteriores (novo)", 
						"Imprimir Fichas Anteriores (novo)", null,
						0, false );
						
		registerAction( new ActionHandler(){
							public void execute()
							{
								deleteOld();
							}
							
							public boolean activate( boolean newAction, boolean editAction, 
														boolean cancelAction, boolean saveAction,
														boolean deleteAction, boolean selectAction )
							{
								return saveAction || editAction;
							}
						}, "Apagar Fichas Anteriores", 
						"Apagar Fichas Anteriores", null,
						0, false );
						
//		registerAction( new ActionHandler(){
//							public void execute()
//							{
//								excel();
//							}
//							
//							public boolean activate( boolean newAction, boolean editAction, 
//														boolean cancelAction, boolean saveAction,
//														boolean deleteAction, boolean selectAction )
//							{
//								return saveAction;
//							}
//						}, "Importar", 
//						"Importar de Excel", "excel",
//						0, true );
	}
	
	public boolean save( int index )
	{
		new ProgressDialog( this, "A gravar...", 
							new Runnable(){
								public void run()
								{
									
								}
							});
		StringBuilder msg = new StringBuilder();
		MedicoData medico;
		try
		{
			medico = (MedicoData)upperPanel.save();
		}
		catch( ValuesException vex )
		{
			msg.append( vex.getMessage() );
			medico = null;
		}
		EstabelecimentoData estabelecimento;
		try
		{
			estabelecimento = (EstabelecimentoData)empresaPanel.save();
		}
		catch( ValuesException vex )
		{
			msg.append( vex.getMessage() );
			estabelecimento = null;
		}
		TrabalhadorData trabalhador;
		try
		{
			trabalhador = (TrabalhadorData)trabalhadorPanel.save();
		}
		catch( ValuesException vex )
		{
			msg.append( vex.getMessage() );
			trabalhador = null;
		}
		ExameData exame;
		try
		{
			exame = (ExameData)examePanel.save();
		}
		catch( ValuesException vex )
		{
			msg.append( vex.getMessage() );
			exame = null;
		}
		if( estabelecimento == null || trabalhador == null || exame == null || medico == null )
		{
			JOptionPane.showMessageDialog( this, msg.toString(), "Erro...", JOptionPane.ERROR_MESSAGE );
			return false;
		}
		String observacoes = ( String ) observacoesPanel.save();
		
		
		estabelecimento.set( EstabelecimentoData.NOME_PLAIN, 
									com.evolute.utils.strings.StringPlainer.convertString( ( String ) 
										estabelecimento.get( EstabelecimentoData.NOME ) ) );
		
//		trabalhador.setProperty( FichaDataProvider.R_TRABALHADOR_ESTABELECIMENTO, estabelecimento );
//		trabalhador.setProperty( FichaDataProvider.OBSERVACOES, observacoesPanel.save() );
		trabalhador.set( TrabalhadorData.ESTABELECIMENTO, estabelecimento );
		trabalhador.set( TrabalhadorData.OBSERVACOES, observacoes );
		trabalhador.set( TrabalhadorData.NOME_PLAIN, 
									com.evolute.utils.strings.StringPlainer.convertString( ( String ) 
										trabalhador.get( TrabalhadorData.NOME ) ) );
		

//		exame.setProperty( FichaDataProvider.R_EXAME_MEDICO, medico );
//		exame.setProperty( FichaDataProvider.R_EXAME_TRABALHADOR, trabalhador );
		exame.set( ExameData.MEDICO, medico );
		exame.set( ExameData.TRABALHADOR, trabalhador );
		
		byte fo[] = null;
		try
		{
			fo = createFO( exame );
		}
		catch( Exception ex )
		{
			DialogException.showExceptionMessage( ex, "Erro a criar nova vers\u00e3o de ficha", true );
		}
		
		try
		{
			// lflores - disable FO for now
			
			
//	System.out.println( "FO sz: " + fo.length );
			exame.set( ExameData.FO, fo );
			exame.set( ExameData.PDF, createPDF( exame ) );
			
//			empresa.save();
//			estabelecimento.save();
		
			exame.save();
			trabalhador.save();
			try
			{
				if( medico != null )
				{
					fdpProvider.setMedicoForEstabelecimento( ( Integer ) estabelecimento.get( EstabelecimentoData.ID ),
																( Integer ) medico.get( MedicoData.ID ) );
				}
			}
			catch( Exception mex )
			{
			}
//			fdpProvider.savePDF( exame );
			
//			DBKey key = trabalhador.getPrimaryKeyValue();
//			DBField fields[] = FichaDataProvider.TRABALHADORES.getPrimaryKey();
//			trabalhadorID = new Integer( ((Number)key.getFieldValue( fields[ 0 ] )).intValue() );
			trabalhadorID = ( Integer ) trabalhador.get( TrabalhadorData.ID );
			try
			{
				//Marcacao.saveMarcacaoConsultaForTrabalhadorID( trabalhadorID, (Date)exame.get( ExameData.PROXIMO_EXAME ) );
				marcacoesHandler.ajustarMarcacoes( 
						trabalhadorID, (Integer)exame.get( ExameData.TIPO ), 
						(Date)exame.get( ExameData.DATA ), 
						examePanel.getMotivoProximoExame(), (Date)exame.get( ExameData.PROXIMO_EXAME ) );
			}
			catch( Exception iex )
			{
				iex.printStackTrace();
			}
//			createPDF( exame );
//			print();
		}
		catch( Exception ex )
		{
			DialogException.showExceptionMessage( ex, "Erro a guardar", true );
			return false;
		}
		if( exameListener != null )
		{
			exameListener.exameSaved( trabalhadorID, ( Integer )exame.get( ExameData.ID ) );
			exameListener = null;
		}
		return true;
	}
	
	public boolean newItem( int index )
	{
		exameListener = null;
		if( imposedTrabalhadorID == null )
		{
			fdpProvider.setSearch( FichaDataProvider.SEARCH_EMPRESAS );
			SearchDialog search;
			Integer oldID = empresaID;

			search = new SearchDialog( fdpProvider, null, false, null, true );
			empresaID = (  Integer )search.getSelected();
		
			if( empresaID == null )
			{
				if( search.getIsNew() )
				{
					estabelecimentoID = null;
					trabalhadorID = null;
					clear( 0 );
					return true;
				}
				else
				{
					return false;
				}
			}

			fdpProvider.setSearch( FichaDataProvider.SEARCH_ESTABELECIMENTOS );
			fdpProvider.setSearchID( FichaDataProvider.SEARCH_EMPRESAS, empresaID.intValue() );

			search = new SearchDialog( fdpProvider, null, false, null, true );
			estabelecimentoID = ( Integer )search.getSelected();

			if( estabelecimentoID == null )
			{
				if( search.getIsNew() )
				{
					trabalhadorID = null;
					reload(0);
					return true;
				}
				else
				{
					return false;
				}
			}

			fdpProvider.setSearch( FichaDataProvider.SEARCH_TRABALHADORES );
			fdpProvider.setSearchID( FichaDataProvider.SEARCH_ESTABELECIMENTOS, estabelecimentoID.intValue() );
			search = new SearchDialog( fdpProvider, null, false, null, true );
			trabalhadorID = ( Integer )search.getSelected();
			if( trabalhadorID == null && search.getIsNew() )
			{
				reload(0);
				return true;
			}
		}
		else
		{
			trabalhadorID = imposedTrabalhadorID;
			imposedTrabalhadorID = null;
			try
			{
				estabelecimentoID = fdpProvider.getEstabelecimentoIDForTrabalhador( trabalhadorID );
				empresaID = fdpProvider.getEmpresaIDForEstabelecimento( estabelecimentoID );
			}
			catch( Exception ex )
			{
				DialogException.showExceptionMessage( ex, "Erro a carregar dados.", true );
				return false;
			}
		}
		if( trabalhadorID == null )
		{
			return false;
		}
		reload(0);
		return true;
	}
	
	public boolean delete( int index )
	{
		return true;
	}
	
	public void deleteOld()
	{
		if( trabalhadorID == null )
		{
			return;
		}
		Vector linhas;
		try
		{
			IDObject fichas[] = fdpProvider.getAllFichasForTrabalhador( trabalhadorID );
			linhas = new Vector( Arrays.asList( fichas ) );
		}
		catch( Exception ex )
		{
			DialogException.showExceptionMessage( ex, "Erro a criar lista de Fichas anteriores", true );
			return;
		}
		ListActionDialog dialog = 
			new ListActionDialog( this, "Apagar Fichas Anteriores", new String[]{ "Data" }, linhas, 
							new ListAction(){
								public String getListActionName()
								{
									return "Apagar";
								}
								
								public boolean executeListAction( int line, Object value )
								{
									if( value == null )
									{
										return true;
									}
									try
									{
										delete( ( ( IDObject )value ).getID() );
									}
									catch( Exception ex )
									{
										DialogException.showExceptionMessage( ex, "Erro a Apagar Ficha", true );
										return false;
									}
									return true;
								}	
							} );
		dialog.setSize( 250, 200 );
		dialog.setVisible( true );
	}
	
	public void reload( int index )
	{
		Integer upperData[] = new Integer[]{ empresaID, estabelecimentoID, trabalhadorID };
		upperPanel.fill( upperData );
		Object empresaData[] = new Object[]{ empresaID, estabelecimentoID };
		empresaPanel.fill( empresaData );
		trabalhadorPanel.fill( trabalhadorID );
		observacoesPanel.fill( trabalhadorID );
		examePanel.fill( trabalhadorID );
	}
	
	public void enableComponents( int index, boolean enable )
	{
		upperPanel.setEnabled( enable );
		empresaPanel.setEnabled( enable );
		trabalhadorPanel.setEnabled( enable );
		observacoesPanel.setEnabled( enable );
		examePanel.setEnabled( enable );
	}
	
	public void clear( int index )
	{
		upperPanel.clear();
		empresaPanel.clear();
		trabalhadorPanel.clear();
		observacoesPanel.clear();
		examePanel.clear();
	}
	
	public void print()
	{
		try
		{
			if( trabalhadorID == null )
			{
				System.out.println( "no trab" );
				return;
			}

			Integer id = fdpProvider.getLastExameIDForTrabalhador( trabalhadorID );
			if( id == null )
			{
				System.out.println( "no id" );
				return;
			}
			print( id );
		}
		catch( Exception ex )
		{
			DialogException.showExceptionMessage( ex, "N\u00e3o foi poss\u00edvel imprimir", true );
		}
	}
		
	private void print( Integer exameID )
		throws Exception
	{
//		MetaObject exame = fdpProvider.load( fdpProvider.EXAMES, new DBKey( exameID ) );		
		ExameData exame = (ExameData) JDO.load( ExameData.class, exameID );
		if( exame == null )
		{
			throw new Exception( "N\u00e3o existe exame" );
		}
		
		// lflores - ignore FO (for now)
		byte fo[] = null; //(byte []) exame.get( ExameData.FO );
		byte pdf[] = (byte []) exame.get( ExameData.PDF );
		
		if( fo != null )
		{
			FichaAptidaoCreator.getCreator().print( fo );
		}
		else
		{
			TrabalhadorData trabalhadorExame = ( TrabalhadorData ) exame.get( ExameData.TRABALHADOR );
			String nomeFicheiro = StringPlainer.convertString( ( String ) trabalhadorExame.get( TrabalhadorData.NOME ) );
			nomeFicheiro = nomeFicheiro.replaceAll( " ", "_" );
			ePDF.print( pdf, nomeFicheiro );
		}		
	}
	
	private void printFO( Integer exameID )
		throws Exception
	{
	//	MetaObject exame = fdpProvider.load( fdpProvider.EXAMES, new DBKey( exameID ) );		
		ExameData exame = (ExameData) JDO.load( ExameData.class, exameID );
		if( exame == null )
		{
			throw new Exception( "N\u00e3o existe exame" );
		}
		
		// lflores - ignore FO (for now)
		byte fo[] = (byte []) exame.get( ExameData.FO );
		
		if( fo != null )
		{
			byte pdf[] = FichaAptidaoCreator.getCreator().createPDF( fo );
			new PDFFilePrinter( pdf, true );
		}
	}
		
	public byte[] createFO( ExameData exame )
		throws Exception
	{
		byte xml[] = createXmlFromExame( exame ); 
//		HashMap<String, String> ht = createMapFromExame(exame);
//		ExamePDF ePDF = new ExamePDF();
//		return ePDF.createPDF( ht );
		
		return FichaAptidaoCreator.getCreator().createFO( xml );
	}

	public byte[] createPDF( ExameData exame )
		throws Exception
	{
		// byte fo[] = exame.get( ExameData.FO, fo );
		HashMap<String, String> ht = createMapFromExame( exame );
		return ePDF.createPDF( ht );
//		return FichaAptidaoCreator.getCreator().createPDF( fo );
	}
	
	private HashMap<String, String> createMapFromExame(final ExameData exame)
	{
		MedicoData medico = (MedicoData)exame.get( ExameData.MEDICO );
		TrabalhadorData trabalhador = (TrabalhadorData) exame.get( ExameData.TRABALHADOR );
		EstabelecimentoData estabelecimento = (EstabelecimentoData) trabalhador.get( TrabalhadorData.ESTABELECIMENTO );
		EmpresaData empresa = (EmpresaData) estabelecimento.get( EstabelecimentoData.EMPRESA );
//		empresa.load( empresa.getPrimaryKeyValue() );
		HashMap<String,String> ht = new HashMap<String,String>();
		ht.put( DESIGNACAO_SOCIAL, ( String )empresa.get( EmpresaData.DESIGNACAO_SOCIAL ) );
		ht.put( ESTABELECIMENTOS_NOME, ( String )estabelecimento.get( EstabelecimentoData.NOME ) );
		String aux = (String)estabelecimento.get( EstabelecimentoData.LOCALIDADE );
		ht.put( ESTABELECIMENTOS_LOCALIDADE, aux != null ? aux : "" );
		Integer tipo = (Integer)empresa.get( EmpresaData.SERVICO_SAUDE_TIPO );
		ht.put( SERVICO_SAUDE_TIPO_INTERNO, SQUARE );
		ht.put( SERVICO_SAUDE_TIPO_INTEREMPRESAS, SQUARE );
		ht.put( SERVICO_SAUDE_TIPO_EXTERNO, SQUARE );
		ht.put( SERVICO_SAUDE_TIPO_SNS, SQUARE );
		switch( tipo.intValue() )
		{
			case 1:
				ht.put( SERVICO_SAUDE_TIPO_INTERNO, CHECKED );
				break;
			case 2:
				ht.put( SERVICO_SAUDE_TIPO_INTEREMPRESAS, CHECKED );
				break;
			case 3:
				ht.put( SERVICO_SAUDE_TIPO_EXTERNO, CHECKED );
				break;
			case 4:
				ht.put( SERVICO_SAUDE_TIPO_SNS, CHECKED );
				break;
		}
		ht.put( SERVICO_SAUDE_DESIGNACAO, ( String )empresa.get( EmpresaData.SERVICO_SAUDE_DESIGNACAO ) );
		tipo = (Integer)empresa.get( EmpresaData.SERVICO_HIGIENE_TIPO );
		ht.put( SERVICO_HIGIENE_TIPO_INTERNO, SQUARE );
		ht.put( SERVICO_HIGIENE_TIPO_INTEREMPRESAS, SQUARE );
		ht.put( SERVICO_HIGIENE_TIPO_EXTERNO, SQUARE );
		ht.put( SERVICO_HIGIENE_TIPO_OUTRO, SQUARE );
		switch( tipo.intValue() )
		{
			case 1:
				ht.put( SERVICO_HIGIENE_TIPO_INTERNO, CHECKED );
				break;
			case 2:
				ht.put( SERVICO_HIGIENE_TIPO_INTEREMPRESAS, CHECKED );
				break;
			case 3:
				ht.put( SERVICO_HIGIENE_TIPO_EXTERNO, CHECKED );
				break;
			case 4:
				ht.put( SERVICO_HIGIENE_TIPO_OUTRO, CHECKED );
				break;
		}
		ht.put( SERVICO_HIGIENE_DESIGNACAO, ( String )empresa.get( EmpresaData.SERVICO_HIGIENE_DESIGNACAO ) );
		ht.put( TRABALHADORES_NOME, ( String )trabalhador.get( TrabalhadorData.NOME ) );
		aux = (String)trabalhador.get( TrabalhadorData.SEXO );
		switch( aux.charAt( 0 ) )
		{
			case 'm':
				ht.put( SEXO, "Masculino" );
				break;
			case 'f':
				ht.put( SEXO, "Feminino" );
				break;
		}
		DateFormat df = DateFormat.getDateInstance( DateFormat.SHORT );
		Date data = ( Date )trabalhador.get( TrabalhadorData.DATA_NASCIMENTO );
		ht.put( DATA_NASCIMENTO, data != null ? df.format( data ) : "" );
		aux = (String)trabalhador.get( TrabalhadorData.NACIONALIDADE );
		ht.put( NACIONALIDADE, aux != null ? aux : "" );
		aux = (String)trabalhador.get( TrabalhadorData.NUMERO_MECANOGRAFICO );
		ht.put( NUMERO_MECANOGRAFICO, aux != null ? aux : "" );
		data = ( Date )trabalhador.get( TrabalhadorData.DATA_ADMISSAO );
		ht.put( DATA_ADMISSAO, data != null ? df.format( data ) : "" );
		aux = (String)trabalhador.get( TrabalhadorData.CATEGORIA );
		ht.put( CATEGORIA, aux != null ? aux : "" );
		aux = (String)trabalhador.get( TrabalhadorData.LOCAL_TRABALHO );
		ht.put( LOCAL_TRABALHO, aux != null ? aux : "" );
		aux = (String)trabalhador.get( TrabalhadorData.FUNCAO_PROPOSTA );
		ht.put( FUNCAO_PROPOSTA, aux != null ? aux : "" );
		data = ( Date )trabalhador.get( TrabalhadorData.DATA_ADMISSAO_FUNCAO );
		ht.put( DATA_ADMISSAO_FUNCAO, data != null ? df.format( data ) : "" );
		aux = (String)trabalhador.get( TrabalhadorData.OBSERVACOES );
		ht.put( OBSERVACOES, aux != null ? aux : "" );
		data = ( Date )exame.get( ExameData.DATA );
		ht.put( EXAMES_DATA, data != null ? df.format( data ) : "" );
		tipo = (Integer)exame.get( ExameData.TIPO );
		ht.put( TIPO_ADMISSAO, SQUARE );
		ht.put( TIPO_PERIODICO, SQUARE );
		ht.put( TIPO_OCASIONAL, SQUARE );
		
		ht.put( TIPO_APOS_DOENCA, SQUARE );
		ht.put( TIPO_APOS_ACIDENTE, SQUARE );
		ht.put( TIPO_PEDIDO_TRABALHADOR, SQUARE );
		ht.put( TIPO_PEDIDO_EMPRESA, SQUARE );
		ht.put( TIPO_MUDANCA_FUNCAO, SQUARE );
		ht.put( TIPO_TRABALHO, SQUARE );
		ht.put( TIPO_OUTRO, SQUARE );
		
		switch( tipo.intValue() )
		{
			case 1:
				ht.put( TIPO_ADMISSAO, CHECKED );
				break;
			case 2:
				ht.put( TIPO_PERIODICO, CHECKED );
				break;
			case 3:
				ht.put( TIPO_OCASIONAL, CHECKED );
				tipo = (Integer)exame.get( ExameData.OCASIONAL );
				
				switch( tipo.intValue() )
				{
					case 1:
						ht.put( TIPO_APOS_DOENCA, CHECKED );
						break;
					case 2:
						ht.put( TIPO_APOS_ACIDENTE, CHECKED );
						break;
					case 3:
						ht.put( TIPO_PEDIDO_TRABALHADOR, CHECKED );
						break;
					case 4:
						ht.put( TIPO_PEDIDO_EMPRESA, CHECKED );
						break;
					case 5:
						ht.put( TIPO_MUDANCA_FUNCAO, CHECKED );
						break;
					case 6:
						ht.put( TIPO_TRABALHO, CHECKED );
						break;
					case 10:
						ht.put( TIPO_OUTRO, CHECKED );
						break;
				}
				break;
//			case 4:
//				aux = (String)exame.get( ExameData.OUTRO_TIPO );
//				ht.put( "tipo_outro", aux != null ? aux : "" );
//				break;
		}
		aux = (String)exame.get( ExameData.OUTRO_TIPO );
		ht.put( TIPO_OUTRO_TEXTO, aux != null ? aux : "" );
		tipo = (Integer)exame.get( ExameData.RESULTADO );
		ht.put( RESULTADO_APTO, SQUARE );
		ht.put( RESULTADO_APTO_CONDICIONALMENTE, SQUARE );
		ht.put( RESULTADO_INAPTO_TEMP, SQUARE );
		ht.put( RESULTADO_INAPTO_DEF, SQUARE );
		switch( tipo.intValue() )
		{
			case 1:
				ht.put( RESULTADO_APTO, CHECKED );
				break;
			case 2:
				ht.put( RESULTADO_APTO_CONDICIONALMENTE, CHECKED );
				break;
			case 3:
				ht.put( RESULTADO_INAPTO_TEMP, CHECKED );
				break;
			case 4:
				ht.put( RESULTADO_INAPTO_DEF, CHECKED );
				break;
		}
		aux = (String)exame.get( ExameData.OUTRA_FUNCAO_1 );
		ht.put( OUTRA_FUNCAO_1, aux != null ? aux : "" );
		aux = (String)exame.get( ExameData.OUTRA_FUNCAO_2 );
		ht.put( OUTRA_FUNCAO_2, aux != null ? aux : "" );
		aux = (String)exame.get( ExameData.OUTRA_FUNCAO_3 );
		ht.put( OUTRA_FUNCAO_3, aux != null ? aux : "" );
		aux = (String)exame.get( ExameData.OUTRA_FUNCAO_4 );
		ht.put( OUTRA_FUNCAO_4, aux != null ? aux : "" );
		aux = (String)exame.get( ExameData.OUTRAS_RECOMENDACOES );
		ht.put( OUTRAS_RECOMENDACOES, aux != null ? aux : "" );
		data = ( Date )exame.get( ExameData.PROXIMO_EXAME );
		ht.put( PROXIMO_EXAME, data != null ? df.format( data ) : "n/d" );
		aux = (String)medico.get( MedicoData.NOME );
		ht.put( MEDICOS_NOME, aux != null ? aux : "" );
		aux = (String)medico.get( MedicoData.NUMERO_CEDULA );
		ht.put( NUMERO_CEDULA, aux != null ? aux : "" );
		return ht;
	}
	
	private byte[] createXmlFromExame(final ExameData exame)
		throws Exception
	{
		MedicoData medico = (MedicoData)exame.get( ExameData.MEDICO );
		TrabalhadorData trabalhador = (TrabalhadorData) exame.get( ExameData.TRABALHADOR );
		EstabelecimentoData estabelecimento = (EstabelecimentoData) trabalhador.get( TrabalhadorData.ESTABELECIMENTO );
		EmpresaData empresa = (EmpresaData) estabelecimento.get( EstabelecimentoData.EMPRESA );
		
		Element rootElement = new Element( "FichaAptidao" );
		Element portariaElement = new Element( "portaria" );
		portariaElement.setText( "Portaria n. 299/2007, de 16 de Mar\u00e7o" );
		rootElement.addContent( portariaElement );
		
		Element empresaElement = new Element( "empresa" );
		Element designacaoSocialEmpresaElement = new Element( "designacao-social" );
		designacaoSocialEmpresaElement.setText( ( String )empresa.get( EmpresaData.DESIGNACAO_SOCIAL ) );
		empresaElement.addContent( designacaoSocialEmpresaElement );
		rootElement.addContent( empresaElement );
		
		Integer tipoServicoSaude = (Integer)empresa.get( EmpresaData.SERVICO_SAUDE_TIPO );
		Integer tipoServicoHigieneSeguranca = (Integer)empresa.get( EmpresaData.SERVICO_HIGIENE_TIPO );
		Element estabelecimentoElement = new Element( "estabelecimento" );
		Element nomeEstabelecimentoElement = new Element( "nome" );
		nomeEstabelecimentoElement.setText( ( String )estabelecimento.get( EstabelecimentoData.NOME ) );
		estabelecimentoElement.addContent( nomeEstabelecimentoElement );
		Element localidadeEstabelecimentoElement = new Element( "localidade" );
		localidadeEstabelecimentoElement.setText( ( String )estabelecimento.get( EstabelecimentoData.LOCALIDADE ) );
		estabelecimentoElement.addContent( localidadeEstabelecimentoElement );
		Element servicoSaudeEstabelecimentoElement = new Element( "servico-saude" );
		Element tipoServicoSaudeEstabelecimentoElement = new Element( "tipo" );
		Element internoTipoServicoSaudeEstabelecimentoElement = new Element( "interno" );
		internoTipoServicoSaudeEstabelecimentoElement.setText( tipoServicoSaude.intValue() == 1 ? "y" : "n" );
		tipoServicoSaudeEstabelecimentoElement.addContent( internoTipoServicoSaudeEstabelecimentoElement );
		Element interempresasTipoServicoSaudeEstabelecimentoElement = new Element( "interempresas" );
		interempresasTipoServicoSaudeEstabelecimentoElement.setText( tipoServicoSaude.intValue() == 2 ? "y" : "n" );
		tipoServicoSaudeEstabelecimentoElement.addContent( interempresasTipoServicoSaudeEstabelecimentoElement );
		Element externoTipoServicoSaudeEstabelecimentoElement = new Element( "externo" );
		externoTipoServicoSaudeEstabelecimentoElement.setText( tipoServicoSaude.intValue() == 3 ? "y" : "n" );
		tipoServicoSaudeEstabelecimentoElement.addContent( externoTipoServicoSaudeEstabelecimentoElement );
		Element snsTipoServicoSaudeEstabelecimentoElement = new Element( "sns" );
		snsTipoServicoSaudeEstabelecimentoElement.setText( tipoServicoSaude.intValue() == 4 ? "y" : "n" );
		tipoServicoSaudeEstabelecimentoElement.addContent( snsTipoServicoSaudeEstabelecimentoElement );
		servicoSaudeEstabelecimentoElement.addContent( tipoServicoSaudeEstabelecimentoElement );
		Element designacaoServicoSaudeEstabelecimentoElement = new Element( "designacao" );
		designacaoServicoSaudeEstabelecimentoElement.setText( ( String )empresa.get( EmpresaData.SERVICO_SAUDE_DESIGNACAO ) );
		servicoSaudeEstabelecimentoElement.addContent( designacaoServicoSaudeEstabelecimentoElement );
		estabelecimentoElement.addContent( servicoSaudeEstabelecimentoElement );
		Element servicoHigieneSegurancaEstabelecimentoElement = new Element( "servico-higiene-seguranca" );
		Element tipoServicoHigieneSegurancaEstabelecimentoElement = new Element( "tipo" );
		Element internoTipoServicoHigieneSegurancaEstabelecimentoElement = new Element( "interno" );
		internoTipoServicoHigieneSegurancaEstabelecimentoElement.setText( tipoServicoHigieneSeguranca.intValue() == 1 ? "y" : "n" );
		tipoServicoHigieneSegurancaEstabelecimentoElement.addContent( internoTipoServicoHigieneSegurancaEstabelecimentoElement );
		Element interempresasTipoServicoHigieneSegurancaEstabelecimentoElement = new Element( "interempresas" );
		interempresasTipoServicoHigieneSegurancaEstabelecimentoElement.setText( tipoServicoHigieneSeguranca.intValue() == 2 ? "y" : "n" );
		tipoServicoHigieneSegurancaEstabelecimentoElement.addContent( interempresasTipoServicoHigieneSegurancaEstabelecimentoElement );
		Element externoTipoServicoHigieneSegurancaEstabelecimentoElement = new Element( "externo" );
		externoTipoServicoHigieneSegurancaEstabelecimentoElement.setText( tipoServicoHigieneSeguranca.intValue() == 3 ? "y" : "n" );
		tipoServicoHigieneSegurancaEstabelecimentoElement.addContent( externoTipoServicoHigieneSegurancaEstabelecimentoElement );
		Element outroTipoServicoHigieneSegurancaEstabelecimentoElement = new Element( "outro" );
		outroTipoServicoHigieneSegurancaEstabelecimentoElement.setText( tipoServicoHigieneSeguranca.intValue() == 4 ? "y" : "n" );
		tipoServicoHigieneSegurancaEstabelecimentoElement.addContent( outroTipoServicoHigieneSegurancaEstabelecimentoElement );
		servicoHigieneSegurancaEstabelecimentoElement.addContent( tipoServicoHigieneSegurancaEstabelecimentoElement );
		Element designacaoServicoHigieneSegurancaEstabelecimentoElement = new Element( "designacao" );
		designacaoServicoHigieneSegurancaEstabelecimentoElement.setText( ( String )empresa.get( EmpresaData.SERVICO_HIGIENE_DESIGNACAO ) );
		servicoHigieneSegurancaEstabelecimentoElement.addContent( designacaoServicoHigieneSegurancaEstabelecimentoElement );
		estabelecimentoElement.addContent( servicoHigieneSegurancaEstabelecimentoElement );
		rootElement.addContent( estabelecimentoElement );
		
		char sexo = ( (String)trabalhador.get( TrabalhadorData.SEXO ) ).charAt( 0 );
		DateFormat df = DateFormat.getDateInstance( DateFormat.SHORT );
		Date dataNascimento = ( Date )trabalhador.get( TrabalhadorData.DATA_NASCIMENTO );
		Date dataAdmissao = ( Date )trabalhador.get( TrabalhadorData.DATA_ADMISSAO );
		Date dataAdmissaoFuncao = ( Date )trabalhador.get( TrabalhadorData.DATA_ADMISSAO_FUNCAO );
		Element trabalhadorElement = new Element( "trabalhador" );
		Element nomeTrabalhadorElement = new Element( "nome" );
		nomeTrabalhadorElement.setText( ( String )trabalhador.get( TrabalhadorData.NOME ) );
		Element sexoTrabalhadorElement = new Element( "sexo" );
		sexoTrabalhadorElement.setText( sexo == 'm' ? "Masculino" : "Feminino" );
		trabalhadorElement.addContent( sexoTrabalhadorElement );
		Element dataNascimentoTrabalhadorElement = new Element( "data-nascimento" );
		dataNascimentoTrabalhadorElement.setText( dataNascimento != null ? df.format( dataNascimento ) : "" );
		trabalhadorElement.addContent( dataNascimentoTrabalhadorElement );
		Element nacionalidadeTrabalhadorElement = new Element( "nacionalidade" );
		nacionalidadeTrabalhadorElement.setText( (String)trabalhador.get( TrabalhadorData.NACIONALIDADE ) );
		trabalhadorElement.addContent( nacionalidadeTrabalhadorElement );
		trabalhadorElement.addContent( nomeTrabalhadorElement );
		Element numeroMecanograficoTrabalhadorElement = new Element( "numero-mecanografico" );
		numeroMecanograficoTrabalhadorElement.setText( (String)trabalhador.get( TrabalhadorData.NUMERO_MECANOGRAFICO ) );
		trabalhadorElement.addContent( numeroMecanograficoTrabalhadorElement );
		Element dataAdmissaoTrabalhadorElement = new Element( "data-admissao" );
		dataAdmissaoTrabalhadorElement.setText( dataAdmissao != null ? df.format( dataAdmissao ) : "" );
		trabalhadorElement.addContent( dataAdmissaoTrabalhadorElement );
		Element categoriaProfissionalTrabalhadorElement = new Element( "categoria-profissional" );
		categoriaProfissionalTrabalhadorElement.setText( (String)trabalhador.get( TrabalhadorData.CATEGORIA ) );
		trabalhadorElement.addContent( categoriaProfissionalTrabalhadorElement );
		Element localTrabalhoTrabalhadorElement = new Element( "local-trabalho" );
		localTrabalhoTrabalhadorElement.setText( (String)trabalhador.get( TrabalhadorData.LOCAL_TRABALHO ) );
		trabalhadorElement.addContent( localTrabalhoTrabalhadorElement );
		Element funcaoPropostaTrabalhadorElement = new Element( "funcao-proposta" );
		funcaoPropostaTrabalhadorElement.setText( (String)trabalhador.get( TrabalhadorData.FUNCAO_PROPOSTA ) );
		Element dataAdmissaoFuncaoTrabalhadorElement = new Element( "data-admissao-funcao" );
		dataAdmissaoFuncaoTrabalhadorElement.setText( dataAdmissaoFuncao != null ? df.format( dataAdmissaoFuncao ) : "" );
		trabalhadorElement.addContent( dataAdmissaoFuncaoTrabalhadorElement );
		trabalhadorElement.addContent( funcaoPropostaTrabalhadorElement );
		rootElement.addContent( trabalhadorElement );
		
		Element observacoesElement = new Element( "observacoes" );
		observacoesElement.setText( (String)trabalhador.get( TrabalhadorData.OBSERVACOES ) );
		rootElement.addContent( observacoesElement );
		
		Date dataExameMedico = ( Date )exame.get( ExameData.DATA );
		Integer tipoExameMedico = (Integer)exame.get( ExameData.TIPO );
		Integer tipoOcasionalExameMedico = (Integer)exame.get( ExameData.OCASIONAL );
		Integer resultadoExameMedico = (Integer)exame.get( ExameData.RESULTADO );
		Element exameMedicoElement = new Element( "exame-medico" );
		Element dataExameMedicoElement = new Element( "data" );
		dataExameMedicoElement.setText( dataExameMedico != null ? df.format( dataExameMedico ) : "" );
		exameMedicoElement.addContent( dataExameMedicoElement );
		Element tipoExameMedicoElement = new Element( "tipo" );
		Element admissaoTipoExameMedicoElement = new Element( "admissao" );
		admissaoTipoExameMedicoElement.setText( tipoExameMedico.intValue() == 1 ? "y" : "n" );
		tipoExameMedicoElement.addContent( admissaoTipoExameMedicoElement );
		Element periodicoTipoExameMedicoElement = new Element( "periodico" );
		periodicoTipoExameMedicoElement.setText( tipoExameMedico.intValue() == 2 ? "y" : "n" );
		tipoExameMedicoElement.addContent( periodicoTipoExameMedicoElement );
		Element ocasionalTipoExameMedicoElement = new Element( "ocasional" );
		ocasionalTipoExameMedicoElement.setText( tipoExameMedico.intValue() == 3 ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalTipoExameMedicoElement );
		Element ocasionalDoencaTipoExameMedicoElement = new Element( "ocasional-doenca" );
		ocasionalDoencaTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 1 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalDoencaTipoExameMedicoElement );
		Element ocasionalAcidenteTipoExameMedicoElement = new Element( "ocasional-acidente" );
		ocasionalAcidenteTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 2 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalAcidenteTipoExameMedicoElement );
		Element ocasionalPedidoTrabalhadorTipoExameMedicoElement = new Element( "ocasional-pedido-trabalhador" );
		ocasionalPedidoTrabalhadorTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 3 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalPedidoTrabalhadorTipoExameMedicoElement );
		Element ocasionalPedidoServicoTipoExameMedicoElement = new Element( "ocasional-pedido-servico" );
		ocasionalPedidoServicoTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 4 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalPedidoServicoTipoExameMedicoElement );
		Element ocasionalMudancaoFuncaoTipoExameMedicoElement = new Element( "ocasional-mudanca-funcao" );
		ocasionalMudancaoFuncaoTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 5 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalMudancaoFuncaoTipoExameMedicoElement );
		Element ocasionalAlteracaoCondicoesTrabalhoTipoExameMedicoElement = new Element( "ocasional-alteracao-condicoes-trabalho" );
		ocasionalAlteracaoCondicoesTrabalhoTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 6 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalAlteracaoCondicoesTrabalhoTipoExameMedicoElement );
		Element ocasionalOutroTipoExameMedicoElement = new Element( "ocasional-outro" );
		ocasionalOutroTipoExameMedicoElement.setText( 
				( tipoExameMedico.intValue() == 3 && tipoOcasionalExameMedico != null && tipoOcasionalExameMedico.intValue() == 10 ) ? "y" : "n" );
		tipoExameMedicoElement.addContent( ocasionalOutroTipoExameMedicoElement );
		Element ocasionalOutroDescricaoTipoExameMedicoElement = new Element( "ocasional-outro-descricao" );
		ocasionalOutroDescricaoTipoExameMedicoElement.setText( (String)exame.get( ExameData.OUTRO_TIPO ) );
		tipoExameMedicoElement.addContent( ocasionalOutroDescricaoTipoExameMedicoElement );
		exameMedicoElement.addContent( tipoExameMedicoElement );
		Element resultadoExameMedicoElement = new Element( "resultado" );
		Element aptoResultadoExameMedicoElement = new Element( "apto" );
		aptoResultadoExameMedicoElement.setText( resultadoExameMedico.intValue() == 1 ? "y" : "n" );
		resultadoExameMedicoElement.addContent( aptoResultadoExameMedicoElement );
		Element aptoCondicionalmenteResultadoExameMedicoElement = new Element( "apto-condicionalmente" );
		aptoCondicionalmenteResultadoExameMedicoElement.setText( resultadoExameMedico.intValue() == 2 ? "y" : "n" );
		resultadoExameMedicoElement.addContent( aptoCondicionalmenteResultadoExameMedicoElement );
		Element inaptoTemporariamenteResultadoExameMedicoElement = new Element( "inapto-temporariamente" );
		inaptoTemporariamenteResultadoExameMedicoElement.setText( resultadoExameMedico.intValue() == 3 ? "y" : "n" );
		resultadoExameMedicoElement.addContent( inaptoTemporariamenteResultadoExameMedicoElement );
		Element inaptoDefinitivamenteResultadoExameMedicoElement = new Element( "inapto-definitivamente" );
		inaptoDefinitivamenteResultadoExameMedicoElement.setText( resultadoExameMedico.intValue() == 4 ? "y" : "n" );
		resultadoExameMedicoElement.addContent( inaptoDefinitivamenteResultadoExameMedicoElement );
		Element outrasFuncoes1ResultadoExameMedicoElement = new Element( "outras-funcoes-1" );
		outrasFuncoes1ResultadoExameMedicoElement.setText( (String)exame.get( ExameData.OUTRA_FUNCAO_1 ) );
		resultadoExameMedicoElement.addContent( outrasFuncoes1ResultadoExameMedicoElement );
		Element outrasFuncoes2ResultadoExameMedicoElement = new Element( "outras-funcoes-2" );
		outrasFuncoes2ResultadoExameMedicoElement.setText( (String)exame.get( ExameData.OUTRA_FUNCAO_2 ) );
		resultadoExameMedicoElement.addContent( outrasFuncoes2ResultadoExameMedicoElement );
		Element outrasFuncoes3ResultadoExameMedicoElement = new Element( "outras-funcoes-3" );
		outrasFuncoes3ResultadoExameMedicoElement.setText( (String)exame.get( ExameData.OUTRA_FUNCAO_3 ) );
		resultadoExameMedicoElement.addContent( outrasFuncoes3ResultadoExameMedicoElement );
		Element outrasFuncoes4ResultadoExameMedicoElement = new Element( "outras-funcoes-4" );
		outrasFuncoes4ResultadoExameMedicoElement.setText( (String)exame.get( ExameData.OUTRA_FUNCAO_4 ) );
		resultadoExameMedicoElement.addContent( outrasFuncoes4ResultadoExameMedicoElement );
		exameMedicoElement.addContent( resultadoExameMedicoElement );
		rootElement.addContent( exameMedicoElement );
		
		Date dataProximoExame = ( Date )exame.get( ExameData.PROXIMO_EXAME );
		Element proximoExameElement = new Element( "proximo-element" );
		proximoExameElement.setText( dataProximoExame != null ? df.format( dataProximoExame ) : "" );
		rootElement.addContent( proximoExameElement );
		
		Element outrasRecomendacoesElement = new Element( "outras-recomendacoes" );
		outrasRecomendacoesElement.setText( (String)exame.get( ExameData.OUTRAS_RECOMENDACOES ) );
		rootElement.addContent( outrasRecomendacoesElement );
		
		Element medicoElement = new Element( "medico" );
		Element nomeMedicoElement = new Element( "nome" );
		nomeMedicoElement.setText( (String)medico.get( MedicoData.NOME ) );
		medicoElement.addContent( nomeMedicoElement );
		Element cedulaMedicoElement = new Element( "cedula" );
		cedulaMedicoElement.setText( (String)medico.get( MedicoData.NUMERO_CEDULA ) );
		medicoElement.addContent( cedulaMedicoElement );
		rootElement.addContent( medicoElement );
		
		Document doc = new Document( rootElement );
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		new XMLOutputter().output( doc, baos );
		return baos.toByteArray();
	}
	
	private void excel()
	{
		FileDialog fd = new FileDialog( this, "Escolha um ficheiro Excel:", FileDialog.LOAD );
		fd.setDirectory( System.getProperty( "user.home" ) );
		fd.setFilenameFilter( new FilenameFilter() {
				public boolean accept( File dir, String name )
				{
					return (name!=null) && (name.indexOf( ".xls" ) != -1);
				}
			} );
		fd.setVisible( true );
		//String filename = "c:\\test.xls";
		String filename = fd.getFile();
		if( filename != null )
		{
			filename = fd.getDirectory() + File.separator + filename;
			try
			{
				Importer importer = new Importer( this, filename, false, Importer.TYPE_ADMISSAO );
				Hashtable hash = importer.getData();
				if( hash != null )
				{
					trabalhadorPanel.setData( hash );
				}
			}
			catch( Exception ex )
			{
				ex.printStackTrace();
				JOptionPane.showMessageDialog( this, "Erro a importar", "Erro...", JOptionPane.ERROR_MESSAGE );
			}
		}
		
	}
	
	private void printOld()
	{
		if( trabalhadorID != null )
		{
			Vector linhas;
			try
			{
				IDObject fichas[] = fdpProvider.getAllFichasForTrabalhador( trabalhadorID );
				linhas = new Vector( Arrays.asList( fichas ) );
			}
			catch( Exception ex )
			{
				DialogException.showExceptionMessage( ex, "Erro a criar lista de Fichas anteriores", true );
				return;
			}
			ListActionDialog dialog = new ListActionDialog( this, "Imprimir Fichas Anteriores", new String[]{ "Data" },
													linhas, this );
			dialog.setSize( 250, 200 );
			useFO = false;
			dialog.setVisible( true );
		}
	}
	
	private void printOldFO()
	{
		if( trabalhadorID != null )
		{
			Vector linhas;
			try
			{
				IDObject fichas[] = fdpProvider.getAllFichasForTrabalhador( trabalhadorID );
				linhas = new Vector( Arrays.asList( fichas ) );
			}
			catch( Exception ex )
			{
				DialogException.showExceptionMessage( ex, "Erro a criar lista de Fichas anteriores", true );
				return;
			}
			ListActionDialog dialog = new ListActionDialog( this, "Imprimir Fichas Anteriores", new String[]{ "Data" },
													linhas, this );
			dialog.setSize( 250, 200 );
			useFO = true;
			dialog.setVisible( true );
		}
	}
	
	public boolean executeListAction( int line, Object value )
	{
		if( value != null )
		{
			try
			{
				if( useFO )
				{
					printFO( ( ( IDObject )value ).getID() );
				}
				else
				{
					print( ( ( IDObject )value ).getID() );
				}
			}
			catch( Exception ex )
			{
				DialogException.showExceptionMessage( ex, "Erro a imprimir Ficha", true );
				return false;
			}
		}
		return true;
	}	
	
	public String getListActionName()
	{
		return "Imprimir";
	}
	
	private void delete( Integer exameID )
		throws Exception
	{
//		MetaObject exame = fdpProvider.load( fdpProvider.EXAMES, new DBKey( exameID ) );
		ExameData exame = (ExameData) JDO.load( ExameData.class, exameID );
		if( exame == null )
		{
			throw new Exception( "N\u00e3o existe exame" );
		}
		if( JOptionPane.showConfirmDialog( this, 
			"Tem a certeza que quer apagar o exame de " + exame.get( ExameData.DATA ) + "?",
			"...", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE, null ) == 0 )
		{
//			exame.set( ExameData.INACTIVO, "y" );
//			exame.save();
			exame.delete();
		}
	}
	
	public void editTrabalhador( Integer trabalhadorID, SaveExameListener listener )
	{
System.out.println( "edit trabalhador: " + trabalhadorID );
		
		if( isVisible() )
		{
			toFront();
		}
		else
		{
			setVisible( true );
		}
		imposedTrabalhadorID = trabalhadorID;
		executeAction( NEW_INDEX );
		exameListener = listener;
	}
}
