/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 02-mar-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.modules.jvm;
  
  import java.util.List;
  
  import com.gridsystems.config.ConfiguratorModel;
  import com.gridsystems.config.app.UI;
  import com.gridsystems.config.tools.ErrorSupport;
  import com.gridsystems.config.tools.PortVerifier;
  import com.gridsystems.config.tools.console.AbstractConsoleView;
  import com.gridsystems.config.tools.console.GroupField;
  import com.gridsystems.config.tools.console.ValueField;
  
  /**
   * Console View for the JVM Configurator.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public class JVMConsoleView extends AbstractConsoleView {
    /**
     * Minimum heap size.
     */
    ValueField fldMinHeap;
  
    /**
     * Maximum heap size.
     */
    ValueField fldMaxHeap;
  
    /**
     * Thread stack size.
     */
    ValueField fldStackSize;
  
    /**
     * Proxy flag.
     */
    ValueField fldUseProxy;
  
    /**
     * Proxy host address.
     */
    ValueField fldProxyHost;
  
    /**
     * Proxy port.
     */
    ValueField fldProxyPort;
  
    /**
     * Remote debugging flag.
     */
    ValueField fldDebugEnabled;
  
    /**
     * Remote debugging port.
     */
    ValueField fldDebugPort;
  
    /**
     * "Suspend at start" flag for remote debugging.
     */
    ValueField fldDebugSuspend;
  
    /**
     * Creates a new instance bound to the specified configurator.
     *
     * @param config The configurator instance.
     */
    public JVMConsoleView(JVMConfigurator config) {
      super(config);
  
      fldMinHeap = createValueField("fldMinHeap", null);
      fldMaxHeap = createValueField("fldMaxHeap", null);
      fldStackSize = createValueField("fldStackSize", null);
      fldUseProxy = createBoolField("fldUseProxy");
     fldProxyHost = createValueField("fldProxyHost", null);
     fldProxyPort = createValueField("fldProxyPort", null);
     fldDebugEnabled = createBoolField("fldDebugEnabled");
     fldDebugPort = createValueField("fldDebugPort", null);
     fldDebugSuspend = createBoolField("fldDebugSuspend");
   }
 
   /**
    * {@inheritDoc}
    */
   public String getTitle() {
     return bundle.getString("config.name");
   }
 
   /**
    * {@inheritDoc}
    */
   public String getSubtitle() {
     return bundle.getString("config.description");
   }
 
   /**
    * {@inheritDoc}
    */
   public void getValues(ConfiguratorModel model) {
     JVMConfigModel data = (JVMConfigModel)model;
 
     fldMinHeap.setValue(data.getMinHeap());
     fldMaxHeap.setValue(data.getMaxHeap());
     fldStackSize.setValue(data.getStackSize());
 
     if (UI.isExpertMode()) {
       fldUseProxy.setValue(data.getUseProxy());
       fldProxyHost.setValue(data.getProxyHost());
       fldProxyPort.setValue(data.getProxyPort());
 
       fldDebugEnabled.setValue(data.getDebugEnabled());
       fldDebugPort.setValue(data.getDebugPort());
       fldDebugSuspend.setValue(data.getDebugSuspend());
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setValues(ConfiguratorModel model) {
     JVMConfigModel data = (JVMConfigModel)model;
 
     data.setValue("heap.min",   fldMinHeap.getValue());
     data.setValue("heap.max",   fldMaxHeap.getValue());
     data.setValue("stack.size", fldStackSize.getValue());
 
     if (UI.isExpertMode()) {
       data.setValue("proxy.use",  fldUseProxy.getValue());
       data.setValue("proxy.host", fldProxyHost.getValue());
       data.setValue("proxy.port", fldProxyPort.getValue());
 
       data.setValue("debug.enable", fldDebugEnabled.getValue());
       data.setValue("debug.port", fldDebugPort.getValue());
       data.setValue("debug.suspend", fldDebugSuspend.getValue());
     }
   }
 
   /**
    * {@inheritDoc}
    */
   protected void getContents(List<Object> contents) {
     // Sets the field verifiers
     ErrorSupport support = new ErrorSupport(this.getConfigurator());
     support.addError("badMemSize1", "MinHeap: " + getString("errors.badMemSize"));
     support.addError("badMemSize2", "MaxHeap: " + getString("errors.badMemSize"));
     support.addError("badMemSize3", "StackSize: " + getString("errors.badMemSize"));
     support.addError("badProxyPort", getString("errors.badProxyPort"));
     support.addError("badDebugPort", getString("errors.badDebugPort"));
 
     fldMinHeap.setVerifier(new MemSizeVerifier(support, "badMemSize1"));
     fldMaxHeap.setVerifier(new MemSizeVerifier(support, "badMemSize2"));
     fldStackSize.setVerifier(new MemSizeVerifier(support, "badMemSize3", true));
     fldProxyPort.setVerifier(new PortVerifier(support, "badProxyPort"));
     fldDebugPort.setVerifier(new PortVerifier(support, "badDebugPort"));
 
     // Groups fields into logical areas
     GroupField grpMemory = new GroupField(bundle, "pnlMemory.title");
     grpMemory.addField(fldMinHeap);
     grpMemory.addField(fldMaxHeap);
     grpMemory.addField(fldStackSize);
 
     // Sets the form contents
     contents.add(grpMemory);
 
     // Adds key mappings for fields edition
     addKeyMapping(grpMemory);
 
     if (UI.isExpertMode()) {
       GroupField grpProxy = new GroupField(bundle, "pnlProxy.title");
       grpProxy.addField(fldUseProxy);
       grpProxy.addField(fldProxyHost);
       grpProxy.addField(fldProxyPort);
 
       GroupField grpDebug = new GroupField(bundle, "pnlDebug.title");
       grpDebug.addField(fldDebugEnabled);
       grpDebug.addField(fldDebugPort);
       grpDebug.addField(fldDebugSuspend);
 
       contents.add("-");
       contents.add(grpProxy);
       contents.add("-");
       contents.add(grpDebug);
 
       addKeyMapping(grpProxy);
       addKeyMapping(grpDebug);
     }
   }
 }