import java.applet.*;
import java.awt.*;
import sansmodels.*;
import graph.*;
import graph.SpecialFunction;

public class SANSSimulator extends Applet {
    TextField[] parameters, structParams;
    Label[] paramLabels, structLabels;
    TextField qminField, qmaxField, qpointsField;
    TextPopup outputText;
    TextField[] instrument;
    Label[] instrumentLabels;
    Checkbox smearedBox;
    Button showData;
    SANSResolution resolution = new SANSResolution();
    Panel structPanel;
     
    Choice modelChoice, axisChoice, structureChoice;
    G2Dint graph;
    DataSet modelData, smearedData;
    Axis xaxis, yaxis;
    SANSModel model; 
    StructureFactor structure;

    public void init() {
        Font font = new Font("TimesRoman",Font.PLAIN,12);
        graph = new G2Dint();
        graph.drawzero = false;
        graph.drawgrid = true;
        graph.borderTop = 20;                                                   
        graph.borderRight = 50;
        graph.setDataBackground(Color.white);
        graph.setBackground(Color.white);

        setLayout( new BorderLayout() );
        setBackground(Color.white);
        Label title = new Label("SANS data simulator", Label.CENTER);
        Panel panel = new Panel();

        title.setFont(new Font("TimesRoman",Font.PLAIN,20));

        add("North", title);
        add("Center", panel);

        GridBagLayout gridbag = new GridBagLayout();
        GridBagConstraints c = new GridBagConstraints();
        panel.setLayout(gridbag);
        c.ipadx = 5;
        c.weightx = 1.0;
        c.weighty = 1.0;
        c.gridwidth = GridBagConstraints.REMAINDER;
        c.fill = GridBagConstraints.BOTH;
        
        gridbag.setConstraints(graph,c);
        panel.add(graph);

        showData = new Button("Show Data");
        showData.setFont(font);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.weightx=0.0;
        c.weighty=0.0;
        c.gridheight=1;
        c.anchor = GridBagConstraints.CENTER;
        gridbag.setConstraints(showData,c);
        panel.add(showData);

        c.fill = GridBagConstraints.NONE;
        c.weightx=0.0;
        c.weighty=0.0;
        c.gridheight=1;
        c.gridwidth=1;
        c.anchor = GridBagConstraints.CENTER;
  
        modelChoice = new Choice();
        modelChoice.addItem("Sphere");
        modelChoice.addItem("PolyHardSphere");
        modelChoice.addItem("PolyRectSphere");
        modelChoice.addItem("CoreShell");
        modelChoice.addItem("PolyCoreShell");
        modelChoice.addItem("PolyCoreShellRatio");
        modelChoice.addItem("Cylinder");
        modelChoice.addItem("HollowCylinder");
        modelChoice.addItem("CoreShellCylinder");
        modelChoice.addItem("Ellipsoid");
        modelChoice.addItem("OblateCoreShell");
        modelChoice.addItem("ProlateCoreShell");
        modelChoice.addItem("TwoHomopolymerRPA");
        modelChoice.addItem("DAB");
        modelChoice.addItem("TeubnerStrey");
        modelChoice.addItem("Lorentz");
        modelChoice.addItem("PeakLorentz");
        modelChoice.addItem("PeakGauss");
        modelChoice.addItem("PowerLaw");
        modelChoice.addItem("BE_RPA");
        modelChoice.addItem("Flat");
        modelChoice.addItem("CoreShellCylinderLam");
        modelChoice.setFont(font);
        gridbag.setConstraints(modelChoice,c);
        panel.add(modelChoice);

        structureChoice = new Choice();
        structureChoice.addItem("Flat");
        structureChoice.addItem("HardSphere");
        structureChoice.addItem("SquareWell");
        structureChoice.addItem("HardDisk");
        //structureChoice.addItem("MSA");
        structureChoice.setFont(font);
        gridbag.setConstraints(structureChoice,c);
        panel.add(structureChoice);

        axisChoice = new Choice();
        axisChoice.addItem("Lin-Lin");
        axisChoice.addItem("Lin-Log");
        axisChoice.addItem("Log-Lin");
        axisChoice.addItem("Log-Log");
        axisChoice.setFont(font);
        gridbag.setConstraints(axisChoice,c);
        panel.add(axisChoice);
       
        c.gridwidth = GridBagConstraints.REMAINDER;
        
        smearedBox = new Checkbox();
        smearedBox.setLabel("Smear data?");
        smearedBox.setFont(font);
        gridbag.setConstraints(smearedBox,c);
        panel.add(smearedBox);
        
        c.fill = GridBagConstraints.HORIZONTAL;
        c.anchor = GridBagConstraints.NORTH;

        Panel paramPanel = new Panel();
        GridBagLayout paramGridbag = new GridBagLayout();
        GridBagConstraints paramc = new GridBagConstraints();
        paramPanel.setLayout(paramGridbag);
        paramc.fill = GridBagConstraints.HORIZONTAL;
        paramc.weightx=0.0;
        paramc.weighty=0.0;
        paramc.gridheight=1;
        paramc.gridwidth=1;

        //initialize the values in the model fields
        model = new Sphere();
        double[] paramValues = model.getParameters();
        String[] paramText = model.getParametersText();
        int numParams = model.getNumberOfParameters();

        parameters = new TextField[11];
        paramLabels = new Label[11];
        for(int i=0;i<11;i++) {
            if (i<numParams) {
                paramLabels[i] = new Label(paramText[i], Label.RIGHT);
            } else {
                paramLabels[i] = new Label("Parameter "+i, Label.RIGHT);
            } 
            paramLabels[i].setFont(font);
            paramc.gridwidth=1;
            paramc.anchor = GridBagConstraints.NORTHEAST;
            paramGridbag.setConstraints(paramLabels[i],paramc);
            paramPanel.add(paramLabels[i]);
            if (i<numParams) {
                parameters[i] = new TextField(String.valueOf(paramValues[i]),8);
            } else {
                parameters[i] = new TextField(8);
            }
            parameters[i].setFont(font);
            paramc.gridwidth = GridBagConstraints.REMAINDER;
            paramc.anchor = GridBagConstraints.NORTH;
            paramGridbag.setConstraints(parameters[i],paramc);
            paramPanel.add(parameters[i]);
        }
        for(int i=0;i<numParams;i++) {
            parameters[i].show(true);
            paramLabels[i].show(true);
        }
        if(numParams < 11) {
            for(int i=numParams;i<11;i++) {
                parameters[i].show(false);
                paramLabels[i].show(false);
                parameters[i].setText(" ");
                paramLabels[i].setText(" ");
            }
        }

        structPanel = new Panel();
        GridBagLayout structGridbag = new GridBagLayout();
        structPanel.setLayout(structGridbag);
        paramc.fill = GridBagConstraints.HORIZONTAL;
        paramc.weightx=0.0;
        paramc.weighty=0.0;
        paramc.gridheight=1;
        paramc.gridwidth=1;

        //initialize the values in the structure fields
        structure = new FlatStruct();
        double[] structValues = structure.getParameters();
        String[] structText = structure.getParametersText();
        int numStructParams = structure.getNumberOfParameters();

        structParams = new TextField[4];
        structLabels = new Label[4];
        for(int i=0;i<4;i++) {
            if (i<numStructParams) {
                structLabels[i] = new Label(structText[i], Label.RIGHT);
            } else {
                structLabels[i] = new Label("Parameter "+i, Label.RIGHT);
            } 
            structLabels[i].setFont(font);
            paramc.gridwidth=1;
            paramc.anchor = GridBagConstraints.NORTHEAST;
            structGridbag.setConstraints(structLabels[i],paramc);
            structPanel.add(structLabels[i]);
            if (i<numStructParams) {
                structParams[i] = 
                    new TextField(String.valueOf(structValues[i]),6);
            } else {
                structParams[i] = new TextField(6);
            }
            structParams[i].setFont(font);
            paramc.gridwidth = GridBagConstraints.REMAINDER;
            paramc.anchor = GridBagConstraints.NORTH;
            structGridbag.setConstraints(structParams[i],paramc);
            structPanel.add(structParams[i]);
        }
        for(int i=0;i<numStructParams;i++) {
            structParams[i].show(true);
            structLabels[i].show(true);
        }
        if(numStructParams < 4) {
            for(int i=numStructParams;i<4;i++) {
                structParams[i].show(false);
                structLabels[i].show(false);
                structParams[i].setText(" ");
                structLabels[i].setText(" ");
            }
        }

        Label qmin = new Label("Qmin: ", Label.RIGHT);
        Label qmax = new Label("Qmax: ", Label.RIGHT);
        Label qpoints = new Label("# Points: ", Label.RIGHT);

        qmin.setFont(font);
        qmax.setFont(font);
        qpoints.setFont(font);
        qminField = new TextField("0.001",6);
        qmaxField = new TextField("0.2",6);
        qpointsField = new TextField("128",6);
        qminField.setFont(font);
        qmaxField.setFont(font);
        qpointsField.setFont(font);
        
        Panel qPanel = new Panel();
        GridBagLayout qGridbag = new GridBagLayout();
        qPanel.setLayout(qGridbag);
        paramc.fill = GridBagConstraints.HORIZONTAL;
        paramc.weightx=0.0;
        paramc.weighty=0.0;
        paramc.gridheight=1;
        paramc.gridwidth=1;

        paramc.anchor = GridBagConstraints.NORTHEAST;
        structGridbag.setConstraints(qmin,paramc);
        qPanel.add(qmin);
        paramc.gridwidth = GridBagConstraints.REMAINDER;
        paramc.anchor = GridBagConstraints.NORTH;
        qGridbag.setConstraints(qminField,paramc);
        qPanel.add(qminField);
        paramc.gridwidth=1;
        paramc.anchor = GridBagConstraints.NORTHEAST;
        qGridbag.setConstraints(qmax,paramc);
        qPanel.add(qmax);
        paramc.gridwidth = GridBagConstraints.REMAINDER;
        paramc.anchor = GridBagConstraints.NORTH;
        qGridbag.setConstraints(qmaxField,paramc);
        qPanel.add(qmaxField);
        paramc.gridwidth=1;
        paramc.anchor = GridBagConstraints.NORTHEAST;
        qGridbag.setConstraints(qpoints,paramc);
        qPanel.add(qpoints);
        paramc.gridwidth = GridBagConstraints.REMAINDER;
        paramc.anchor = GridBagConstraints.NORTH;
        qGridbag.setConstraints(qpointsField,paramc);
        qPanel.add(qpointsField);
        
        instrument = new TextField[9];
        instrumentLabels = new Label[9];
        instrumentLabels[0] = new Label("Lambda (A): ", Label.RIGHT);
        instrumentLabels[1] = new Label("dLambda (FWHM): ", Label.RIGHT);
        instrumentLabels[2] = new Label("Source-Sample (m): ", Label.RIGHT);
        instrumentLabels[3] = new Label("Sample-Det (m): ", Label.RIGHT);
        instrumentLabels[4] = new Label("Source Ap (mm): ", Label.RIGHT);
        instrumentLabels[5] = new Label("Sample Ap (mm): ", Label.RIGHT);
        instrumentLabels[6] = new Label("Bmstp Diam (mm): ", Label.RIGHT);
        instrumentLabels[7] = new Label("Det res (FWHM cm): ", Label.RIGHT);
        instrumentLabels[8] = new Label("SamAp-Sam (cm): ", Label.RIGHT);
        
        double[] resValues = resolution.getParameters();

        for(int i=0;i<9;i++) {
           instrument[i] = new TextField(String.valueOf(resValues[i]),6);
           instrument[i].setFont(font);
           instrumentLabels[i].setFont(font);
           instrument[i].show(false);
           instrumentLabels[i].show(false);
        }

        Panel instPanel = new Panel();
        GridBagLayout instGridbag = new GridBagLayout();
        instPanel.setLayout(instGridbag);
        paramc.fill = GridBagConstraints.HORIZONTAL;
        paramc.weightx=0.0;
        paramc.weighty=0.0;
        paramc.gridheight=1;
        paramc.gridwidth=1;
        for(int i=0;i<9;i++) {
            paramc.gridwidth=1;
            paramc.anchor = GridBagConstraints.NORTHEAST;
            instGridbag.setConstraints(instrumentLabels[i],paramc);
            instPanel.add(instrumentLabels[i]);
            paramc.gridwidth = GridBagConstraints.REMAINDER;
            paramc.anchor = GridBagConstraints.NORTH;
            instGridbag.setConstraints(instrument[i],paramc);
            instPanel.add(instrument[i]);
        }

        c.gridwidth = 1;
        c.anchor = GridBagConstraints.NORTH;
        c.fill = GridBagConstraints.HORIZONTAL;
        gridbag.setConstraints(paramPanel,c);
        panel.add(paramPanel);

        gridbag.setConstraints(structPanel,c);
        panel.add(structPanel);
        
        gridbag.setConstraints(qPanel,c);
        panel.add(qPanel);

        c.gridwidth = GridBagConstraints.REMAINDER;
        gridbag.setConstraints(instPanel,c);
        panel.add(instPanel);

        xaxis = graph.createXAxis();
        xaxis.setTitleText("Q (A^{-1})");
        xaxis.setTitleFont(new Font("TimesRoman",Font.PLAIN,15));
        xaxis.setLabelFont(new Font("Helvetica",Font.PLAIN,12));

        yaxis = graph.createYAxis();
        yaxis.setTitleText("dSigma/dOmega (cm^{-1})");
        yaxis.setTitleFont(new Font("TimesRoman",Font.PLAIN,15));
        yaxis.setLabelFont(new Font("Helvetica",Font.PLAIN,12));

        modelData = new DataSet();
        modelData.linecolor = Color.black;
        smearedData = new DataSet();
        smearedData.linecolor = Color.red;
 
        xaxis.attachDataSet(modelData);
        xaxis.attachDataSet(smearedData);
        yaxis.attachDataSet(modelData);
        yaxis.attachDataSet(smearedData);
        graph.attachDataSet(modelData);
        graph.attachDataSet(smearedData);

        outputText = new TextPopup();
        updatePlot();
    }

    public void updatePlot() {
        int i, qpoints;
        int count = 0;
        double qmin, qmax, qinc, qtemp, x;
        boolean error = false;
        boolean xlog = false;
        boolean ylog = false;

        int numParams = model.getNumberOfParameters();
        int numStructParams = structure.getNumberOfParameters();
        double paramValues[] = new double[numParams];
        double structValues[] = new double[numStructParams];
        
        boolean state = smearedBox.getState();

        String modelName = modelChoice.getSelectedItem();
        String StructureName = structureChoice.getSelectedItem();

        int axisType = axisChoice.getSelectedIndex();
        
        switch(axisType) {
            case 0 :
                xlog = false;
                xaxis.setTitleText("Q (A^{-1})");
                ylog = false;
                yaxis.setTitleText("dSigma/dOmega (cm^{-1})");
                break;
            case 1 :
                xlog = false;
                xaxis.setTitleText("Q (A^{-1})");
                ylog = true;
                yaxis.setTitleText("log[dSigma/dOmega (cm^{-1})]");
                break;
            case 2 :
                xlog = true;
                xaxis.setTitleText("log[Q (A^{-1})]");
                ylog = false;
                yaxis.setTitleText("dSigma/dOmega (cm^{-1})");
                break;
            case 3 :
                xlog = true;
                xaxis.setTitleText("log[Q (A^{-1})]");
                ylog = true;
                yaxis.setTitleText("log[dSigma/dOmega (cm^{-1})]");
                break;
        }

        try {
            qmin = Double.valueOf(qminField.getText()).doubleValue();
        } catch(Exception e) {
            this.showStatus("Error with qmin!");
            System.out.println("qmin error "+e.getMessage());
            return;
        }
        if(qmin <= 0) qmin = 0.0001;

        try {
            qmax = Double.valueOf(qmaxField.getText()).doubleValue();
        } catch(Exception e) {
            this.showStatus("Error with qmax!");
            System.out.println("qmax error "+e.getMessage());
            return;
        }
        if (qmax <= 0) qmax = 0.2;

        try {
            qpoints = Integer.parseInt(qpointsField.getText());
        } catch(Exception e) {
            this.showStatus("Error with number of points!");
            System.out.println("Number of points error "+e.getMessage());
            return;
        }

        if (qmax < qmin) {
            qtemp = qmin;
            qmin = qmax;
            qmax = qtemp;
            qminField.setText(String.valueOf(qmin));
            qmaxField.setText(String.valueOf(qmax));
        }
        if (Math.abs(qmax-qmin) <= 0.001) {
            qmin = 0.001;
            qmax = 0.2;
            qminField.setText(String.valueOf(qmin));
            qmaxField.setText(String.valueOf(qmax));
        }
        if (qpoints <= 0) {
            qpoints = 128;
            qpointsField.setText(String.valueOf(qpoints));
        }
        qinc = (qmax-qmin)/(double)qpoints;
        
        for(i=0;i<numParams;i++) {
            try {
                paramValues[i] = 
                    Double.valueOf(parameters[i].getText()).doubleValue();
            } catch(Exception e) {
                this.showStatus("Error with parameter "+i+"!");
                System.out.println("Parameter error "+e.getMessage());
                return;
            }
        }
        model.setParameters(paramValues);
        for(i=0;i<numStructParams;i++) {
            try {
                structValues[i] = 
                    Double.valueOf(structParams[i].getText()).doubleValue();
            } catch(Exception e) {
                this.showStatus("Error with structure parameter "+i+"!");
                System.out.println("Structure parameter error "+e.getMessage());
                return;
            }
        }
        structure.setParameters(structValues);
        model.setStructureFactor(structure);
        
        double d[] = new double[2*qpoints];
        double d2[] = new double[2*qpoints];
 
        this.showStatus("Calculating points!");
 
        double resValues[] = new double[3];
        for(i=0;i<qpoints;i++) {
            x = qmin + (double)i*qinc;
            d[count] = x;
            if(xlog) d[count] = SpecialFunction.log10(x);
            try {
                if(state) {
                    d2[count] = x;
                    if(xlog) d2[count] = SpecialFunction.log10(x);
                    resValues = resolution.getResolution(x);
                    d2[count+1] = model.getSmearedFormFactor(
                                    resValues[0],
                                    resValues[1],
                                    resValues[2]);
                    if(ylog) d2[count+1] = SpecialFunction.log10(d2[count+1]);
                }
                d[count+1] = model.getFormFactor(x);
                //System.out.println(structure.calculate(x));
                if(ylog) d[count+1] = SpecialFunction.log10(d[count+1]);
                count += 2;
            } catch(Exception e) {error = true;}
        }

        if(count <= 2) {
            this.showStatus("Error NO POINTS to PLOT!");
            System.out.println("Error NO POINTS to PLOT!");
            return;
        } else
        if( error ) {
            this.showStatus("Error while Calculating points!");
            System.out.println("Error while calculating points!");
        }
        
        modelData.deleteData();
        smearedData.deleteData();

        try {
              modelData.append(d,count/2);
              smearedData.append(d2,count/2);
              //Make the text for showing on theOutputText window.
              String outputData="";
              int point = 0;
              for(i=0;i<count/2;i++) {
                  point = 2*i;
                  if(state) {
                      outputData+=(new Format("%10.5f").format(d[point]))
                          +" "
                          +(new Format("%10.5G").format(d[point+1]))
                          +" "
                          +(new Format("%10.5G").format(d2[point+1]))
                          +"\n";
                  } else {
                      outputData+=(new Format("%10.5f").format(d[point]))
                          +" "
                          +(new Format("%10.5G").format(d[point+1]))
                          +"\n";
                  }
              }
              outputText.setText(outputData);
        } catch(Exception e) {
            this.showStatus("Error while appending data!");
            System.out.println("Error while appending data!");
            return;
        }

        graph.repaint();
        
    }


    public boolean action(Event e, Object a) {
        if (e.target instanceof Checkbox) {
            boolean state = ((Checkbox)e.target).getState();
            for(int i=0;i<9;i++) {
                instrumentLabels[i].show(state);
                instrument[i].show(state);
            }
            updatePlot();
            this.validate();
            return true;
        } 
        if(e.target instanceof Button) {
            if (outputText.isVisible()) {
               outputText.hide();
               showData.setLabel("Show Data");
            } else {
               outputText.show();
               showData.setLabel("Hide Data");
            }
        }
        if(e.target instanceof Choice) {
            int chosen = modelChoice.getSelectedIndex();
            int structChosen = structureChoice.getSelectedIndex();
            
            if(e.target.equals(modelChoice)) {
                switch (chosen) {
                    case 0 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new Sphere();
                        break;
                    case 1 : 
                        structureChoice.enable(false);
                        structPanel.enable(false);
                        model = new PolyHardSphere();
                        break;
                    case 2 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PolyRectSphere();
                        break;
                    case 3 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new CoreShell();
                        break;
                    case 4 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PolyCoreShell();
                        break;
                    case 5 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PolyCoreShellRatio();
                        break;
                    case 6 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new Cylinder();
                        break;
                    case 7 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new HollowCylinder();
                        break;
                    case 8 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new CoreShellCylinder();
                        break;
                    case 9 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new Ellipsoid();
                        break;
                    case 10 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new OblateCoreShell();
                        break;
                    case 11 : 
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new ProlateCoreShell();
                        break;
                    case 12 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new TwoHomopolymerRPA();
                        break;
                    case 13 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new DAB();
                        break;
                    case 14 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new TeubnerStrey();
                        break;
                    case 15 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new Lorentz();
                        break;
                    case 16 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PeakLorentz();
                        break;
                    case 17 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PeakGauss();
                        break;
                    case 18 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new PowerLaw();
                        break;
                    case 19 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new BE_RPA();
                        break;
                    case 20 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new Flat();
                        break;
                    case 21 :
                        structureChoice.enable(true);
                        structPanel.enable(true);
                        model = new CoreShellCylinderLam();
                        break;
                }
    
                double[] paramValues = model.getParameters();
                String[] paramText = model.getParametersText();
                int numParams = model.getNumberOfParameters();
                for(int i=0;i<numParams;i++) {
                    parameters[i].show(true);
                    paramLabels[i].show(true);
                    parameters[i].setText(String.valueOf(paramValues[i]));
                    paramLabels[i].setText(paramText[i]);
                }
                if(numParams < 11) {
                    for(int i=numParams;i<11;i++) {
                        parameters[i].show(false);
                        paramLabels[i].show(false);
                        parameters[i].setText(" ");
                        paramLabels[i].setText(" ");
                    }
                }
            } else if (e.target.equals(structureChoice)) {
                switch (structChosen) {
                    case 0: //Flat
                        structure = new FlatStruct();
                        break;
                    case 1: //Hard Sphere
                        structure = new HardSphereStruct();
                        break;
                    case 2: //Square Well
                        structure = new SquareWellStruct();
                        break;
                    case 3: //Hard Disk
                        structure = new HardDiskStruct();
                        break;
                }
                
                double[] structValues = structure.getParameters();
                String[] structText = structure.getParametersText();
                int numStructParams = structure.getNumberOfParameters();
                for(int i=0;i<numStructParams;i++) {
                    structParams[i].show(true);
                    structLabels[i].show(true);
                    structParams[i].setText(String.valueOf(structValues[i]));
                    structLabels[i].setText(structText[i]);
                }
                if(numStructParams < 4) {
                    for(int i=numStructParams;i<4;i++) {
                        structParams[i].show(false);
                        structLabels[i].show(false);
                        structParams[i].setText(" ");
                        structLabels[i].setText(" ");
                    }
                }
            }
            updatePlot();
            this.validate();
            return true;
        } 
        if (e.target instanceof TextField) {
            boolean state = smearedBox.getState();
            if(state) {
                double[] resValues = resolution.getParameters();
                for(int i=0;i<9;i++) {
                    try {
                        resValues[i] = 
                         Double.valueOf(instrument[i].getText()).doubleValue();
                    } catch(Exception exc) {
                       this.showStatus("Error with resolution par "+i+"!");
                       System.out.println("Resolution error "+exc.getMessage());
                       return true;
                    }
                }
                resolution.setParameters(resValues);
            }
            updatePlot();
            return true;
        }
        return false;
    }

}