//
   // $Id: DefaultUploadPolicy.java 289 2007-06-19 10:04:46 +0000 (mar., 19 juin
   // 2007) etienne_sf $
   //
   // jupload - A file upload juploadContext.
   // Copyright 2007 The JUpload Team
   //
   // Created: 2006-05-04
   // Creator: etienne_sf
  // Last modified: $Date: 2015-03-14 15:13:43 +0100 (sam., 14 mars 2015) $
  //
  // This program is free software; you can redistribute it and/or modify it under
  // the terms of the GNU General Public License as published by the Free Software
  // Foundation; either version 2 of the License, or (at your option) any later
  // version. 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.,
  // 675 Mass Ave, Cambridge, MA 02139, USA.
  
  package wjhk.jupload2.policies;
  
  import java.awt.BorderLayout;
  import java.awt.Cursor;
  import java.awt.GridLayout;
  import java.awt.SystemColor;
  import java.awt.dnd.DropTargetDropEvent;
  import java.io.BufferedReader;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.PrintStream;
  import java.io.UnsupportedEncodingException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLEncoder;
  import java.nio.charset.Charset;
  import java.nio.charset.UnsupportedCharsetException;
  import java.util.IllegalFormatException;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.ResourceBundle;
  import java.util.Vector;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  
  import javax.swing.BorderFactory;
  import javax.swing.BoxLayout;
  import javax.swing.Icon;
  import javax.swing.JButton;
  import javax.swing.JLabel;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.JProgressBar;
  import javax.swing.UIManager;
  import javax.swing.UnsupportedLookAndFeelException;
  import javax.swing.border.BevelBorder;
  
  import wjhk.jupload2.context.JUploadContext;
  import wjhk.jupload2.exception.JUploadException;
  import wjhk.jupload2.exception.JUploadExceptionStopAddingFiles;
  import wjhk.jupload2.exception.JUploadExceptionUploadFailed;
  import wjhk.jupload2.exception.JUploadExceptionUploadFailedSuccessNotFound;
  import wjhk.jupload2.exception.JUploadIOException;
  import wjhk.jupload2.filedata.DefaultFileData;
  import wjhk.jupload2.filedata.FileData;
  import wjhk.jupload2.gui.JUploadFileChooser;
  import wjhk.jupload2.gui.JUploadFileFilter;
  import wjhk.jupload2.gui.JUploadPanel;
  import wjhk.jupload2.gui.filepanel.FilePanel.FileListViewMode;
  import wjhk.jupload2.upload.helper.ByteArrayEncoder;
  import wjhk.jupload2.upload.helper.ByteArrayEncoderHTTP;
  import wjhk.jupload2.upload.helper.HTTPConnectionHelper;
  import wjhk.jupload2.upload.helper.HttpProtocolFinderThread;
  import wjhk.jupload2.upload.helper.InteractiveTrustManager;
  
  /**
   * This class implements all {@link wjhk.jupload2.policies.UploadPolicy} methods. Its way of working is he same as the
   * JUpload version 1. <BR>
   * The simplest way to use this policy is given in the presentation of {@link UploadPolicy}. The DefaultUploadPolicy is
   * used when no <I>uploadPolicy</I> parameter is given to the juploadContext, or this parameter has
   * 'DefaultUploadPolicy' as a value. <BR>
   * <P>
   * The <U>default behavior</U> is representated below. It can be overridden by adding parameters to the juploadContext.
   * All available parameters are shown in the presentation of {@link UploadPolicy}.
   * </P>
   * <UL>
   * <LI>Default implementation for all {@link wjhk.jupload2.policies.UploadPolicy} methods.
   * <LI>Files are uploaded all in one HTTP request.
   * <LI>No handling for particular kind of files: files are transmitted without any transformation.
   * <LI>The file are transmitted to the server with the navigator cookies, userAgent and Protocol (see also the
   * readCookieFromNavigator and serverProtocol juploadContext parameter). This make upload occurs within the current user
   * session on the server. So, it allows right management and context during the management of uploaded files, on the
   * server.
  * </UL>
  * 
  * @author etienne_sf
  * @version $Revision: 1718 $
  */
 
 public class DefaultUploadPolicy implements UploadPolicy {
 
     /**
      * Maximum number of characters allowed for a message that is displayed in a DialogBox
      */
     public final static int DIALOG_MESSAGE_MAX_LINE_LENGTH = 80;
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// APPLET PARAMETERS
     // ///////////////////////////////////////////////////
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
      * juploadContext contains the reference of the Applet. It's useful to interact with it. <BR>
      * It also allows access to the navigator properties, if the html tag MAYSCRIPT is put in the APPLET tag. This
      * allows this class to get the cookie, userAgent and protocol, to upload files in the current user session on the
      * server. <BR>
      * Default : no default value
      */
     JUploadContext juploadContext = null;
 
     /**
      * Contains the applet parameter of the same name. If a valid URL is given here, the navigator will get redirected
      * to this page, after a successful upload.
      */
     private String afterUploadURL = UploadPolicy.DEFAULT_AFTER_UPLOAD_URL;
 
     /**
      * Contains the allowedFileExtensions applet parameter.
      */
     private boolean allowHttpPersistent = UploadPolicy.DEFAULT_ALLOW_HTTP_PERSISTENT;
 
     /**
      * Contains the allowedFileExtensions applet parameter.
      */
     private String allowedFileExtensions = UploadPolicy.DEFAULT_ALLOWED_FILE_EXTENSIONS;
 
     /**
      * Indicate whether the log window is shown or not to the user. In all cases it remains in memory, and stores all
      * debug information. This allows a log information, in case of an error occurs.
      * 
      * @see #urlToSendErrorTo
      */
     private String showLogWindow = UploadPolicy.DEFAULT_SHOW_LOGWINDOW;
 
     private boolean showStatusbar = UploadPolicy.DEFAULT_SHOW_STATUSBAR;
 
     private String specificHeaders = null;
 
     /** Indicates the directory in which the file chooser is to be opened */
     private File currentBrowsingDirectory = null;
 
     /**
      * This parameter controls whether the applet generates a debug file or not. If true, this file contains the full
      * debug output, whatever the current debugLevel is.
      */
     private boolean debugGenerateFile = true;
 
     /**
      * The current debug level. This control the details of information that is written in the log part of the applet.
      */
     private int debugLevel = UploadPolicy.DEFAULT_DEBUG_LEVEL;
 
     /**
      * Stored value for the fileChooserIconFromFileContent applet property.
      * 
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT
      */
     private int fileChooserIconFromFileContent = UploadPolicy.DEFAULT_FILE_CHOOSER_ICON_FROM_FILE_CONTENT;
 
     /**
      * Stored value for the fileChooserIconSize applet property.
      * 
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_SIZE
      */
     private int fileChooserIconSize = UploadPolicy.DEFAULT_FILE_CHOOSER_ICON_SIZE;
 
     /** Stored value for the {@link UploadPolicy#PROP_FILE_FILTER_NAME} */
     private String fileFilterName = UploadPolicy.DEFAULT_FILE_FILTER_NAME;
 
     /** Stored value for the {@link UploadPolicy#PROP_FILE_LIST_VIEW_MODE} */
     private FileListViewMode fileListViewMode = UploadPolicy.DEFAULT_FILE_LIST_VIEW_MODE;
 
     /**
      * This String contains the filenameEncoding parameter. All details about the available applet parameters are
      * displayed in the <a href="UploadPolicy.html@parameters">Upload Policy javadoc page</a>.
      */
     private String filenameEncoding = UploadPolicy.DEFAULT_FILENAME_ENCODING;
 
     /**
      * Default value for the ftpCreateDirectoryStructure applet parameter
      */
     private boolean ftpCreateDirectoryStructure = UploadPolicy.DEFAULT_FTP_CREATE_DIRECTORY_STRUCTURE;
 
     /**
      * Default value for the ftpCreateDirectoryStructure applet parameter
      */
     private boolean ftpTransfertBinary = UploadPolicy.DEFAULT_FTP_TRANSFERT_BINARY;
 
     /**
      * Default value for the ftpCreateDirectoryStructure applet parameter
      */
     private boolean ftpTransfertPassive = UploadPolicy.DEFAULT_FTP_TRANSFERT_PASSIVE;
 
     /** Default value for the httpUploadParameterName applet parameter */
     protected String httpUploadParameterName = UploadPolicy.DEFAULT_HTTP_UPLOAD_PARAMETER_NAME;
 
     /** Default value for the httpUploadParameterType applet parameter */
     protected String httpUploadParameterType = UploadPolicy.DEFAULT_HTTP_UPLOAD_PARAMETER_TYPE;
 
     /**
      * The lang parameter, given to the applet.
      */
     private String lang = UploadPolicy.DEFAULT_LANG;
 
     /**
      * The current Locale. If the lang parameter is given and value, this supersede the default locale.
      */
     private Locale locale = Locale.getDefault();
 
     /**
      * Contains the last exception that occurs in the applet.
      * 
      * @see #displayErr(String, Exception)
      */
     private JUploadException lastException = null;
 
     /**
      * The look and feel is used as a parameter of the UIManager.setLookAndFeel(String) method. See the parameters list
      * on the {@link UploadPolicy} page.
      */
     private String lookAndFeel = UploadPolicy.DEFAULT_LOOK_AND_FEEL;
 
     /**
      * The applet will do as may HTTP requests to upload all files, with the number as a maximum number of files for
      * each HTTP request. <BR>
      * Default : -1
      */
     private int nbFilesPerRequest = UploadPolicy.DEFAULT_NB_FILES_PER_REQUEST;
 
     /**
      * Current value (or default value) of the maxChunkSize applet parameter. <BR>
      * Default : Long.MAX_VALUE
      */
     private long maxChunkSize = UploadPolicy.DEFAULT_MAX_CHUNK_SIZE;
 
     /**
      * Current value (or default value) of the maxFileSize applet parameter. <BR>
      * Default : Long.MAX_VALUE
      */
     private long maxFileSize = UploadPolicy.DEFAULT_MAX_FILE_SIZE;
 
     /**
      * The URL where files should be posted. <BR>
      * Default : no default value. (mandatory)
      */
     private String postURL = UploadPolicy.DEFAULT_POST_URL;
 
     /** @see UploadPolicy#getReadCookieFromNavigator() */
     private boolean readCookieFromNavigator = UploadPolicy.DEFAULT_READ_COOKIE_FROM_NAVIGATOR;
 
     /** @see UploadPolicy#getReadUserAgentFromNavigator() */
     private boolean readUserAgentFromNavigator = UploadPolicy.DEFAULT_READ_USER_AGENT_FROM_NAVIGATOR;
 
     /** @see UploadPolicy#getRetryMaxNumberOf() */
     private int retryMaxNumberOf = UploadPolicy.DEFAULT_RETRY_MAX_NUMBER_OF;
 
     /** @see UploadPolicy#getRetryNbSecondsBetween() */
     private int retryNbSecondsBetween = UploadPolicy.DEFAULT_RETRY_NB_SECONDS_BETWEEN;
 
     /** @see UploadPolicy#getSendMD5Sum() */
     private boolean sendMD5Sum = UploadPolicy.DEFAULT_SEND_MD5_SUM;
 
     /** @see UploadPolicy#getServerProtocol() */
     private String serverProtocol = UploadPolicy.DEFAULT_SERVER_PROTOCOL;
 
     /**
      * @see UploadPolicy#getStringUploadError()
      */
     private String stringUploadError = UploadPolicy.DEFAULT_STRING_UPLOAD_ERROR;
 
     /**
      * @see UploadPolicy#getStringUploadSuccess()
      */
     private String stringUploadSuccess = UploadPolicy.DEFAULT_STRING_UPLOAD_SUCCESS;
 
     /**
      * @see UploadPolicy#getStringUploadWarning()
      */
     private String stringUploadWarning = UploadPolicy.DEFAULT_STRING_UPLOAD_WARNING;
 
     /**
      * If an error occurs during upload, and this attribute is not null, the applet asks the user if wants to send the
      * debug ouput to the administrator. If yes, the full debug information is POSTed to this URL. It's a little
      * development on the server side to send a mail to the webmaster, or just log this error into a log file.
      * 
      * @see UploadPolicy#sendDebugInformation(String, Exception)
      */
     private String urlToSendErrorTo = UploadPolicy.DEFAULT_URL_TO_SEND_ERROR_TO;
 
     /**
      * Optional name of a form (in the same document like the applet) which is used to populate POST parameters.
      */
     private String formData = UploadPolicy.DEFAULT_FORMDATA;
 
     private String afterUploadTarget = UploadPolicy.DEFAULT_AFTER_UPLOAD_TARGET;
 
     private String lastResponseBody = null;
 
     protected String lastResponseMessage = null;
 
     private int sslVerifyCert = InteractiveTrustManager.NONE;
 
     private final String CRLF = System.getProperty("line.separator");
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// INTERNAL ATTRIBUTE
     // ///////////////////////////////////////////////////
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
      * This Vector contains headers that will be added for each upload. It may contains specific cookies, for instance.
      * 
      * @see #onAppendHeader(ByteArrayEncoder)
      */
     private Vector<String> headers = new Vector<String>();
 
     /**
      * The resourceBundle contains all localized String (and others ??)
      */
     private ResourceBundle resourceBundle = null;
 
     /**
      * This stream is used to store all information that could be useful, in case a problem occurs. Is content can then
      * be sent to the webmaster.
      */
     protected PrintStream debugOut = null;
 
     /**
      * The actual file, used for the debug log.
      * 
      * @see #debugGenerateFile
      */
     protected File debugFile = null;
 
     /**
      * This flag prevents endless repeats of opening the debug log, if that failed for some reason.
      */
     protected boolean debugOk = true;
 
     /**
      * Same as {@link #patternSuccess}, but for the error message. If found, then the upload was accepted by the remote
      * HTTP server, but rejected by the remote application. This pattern should also find the error message in the first
      * matching string.
      */
     protected Pattern patternError = Pattern.compile(UploadPolicy.DEFAULT_STRING_UPLOAD_ERROR);
 
     /**
      * The regexp pattern that is used to find the success string in the HTTP response. If found, the upload is
      * considered to be a success: it has been accepted by the remote server and the remote application.
      */
     protected Pattern patternSuccess = Pattern.compile(UploadPolicy.DEFAULT_STRING_UPLOAD_SUCCESS);
 
     /**
      * Same as {@link #patternSuccess}, but for the warning message. Each time it is found, a message is displayed to
      * the user.
      */
     protected Pattern patternWarning = Pattern.compile(UploadPolicy.DEFAULT_STRING_UPLOAD_WARNING);
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// CONSTRUCTORS
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
      * The main constructor : use default values, and the given postURL.
      * 
      * @param juploadContext The current juploadContext. As the reference to the current upload policy exists almost
      *            everywhere, this parameter allows any access to anyone on the juploadContext... including reading the
      *            applet parameters.
      * @throws JUploadException If an applet parameter is invalid
      */
     public DefaultUploadPolicy(JUploadContext juploadContext) throws JUploadException {
         // Call default constructor for all default initialization;.
         this.juploadContext = juploadContext;
         displayInfo("JUpload juploadContext started, with " + this.getClass().getName() + " upload policy");
 
         // get the debug level. This control the level of debug messages that
         // are written in the log window (see displayDebugMessage). In all
         // cases, the full output is written in the debugBufferString (see also
         // urlToSendErrorTo)
         setDebugLevel(juploadContext.getParameter(PROP_DEBUG_LEVEL, DEFAULT_DEBUG_LEVEL), false);
 
         // Get resource file. This must be the very first parameter to be set,
         // because during initialization, translations may be needed.
         setLang(juploadContext.getParameter(PROP_LANG, DEFAULT_LANG));
 
         // Force the look and feel of the current system. This must be the
         // second
         // first parameter to be set, because during initialization, dialogs can
         // appear.
         setLookAndFeel(juploadContext.getParameter(PROP_LOOK_AND_FEEL, DEFAULT_LOOK_AND_FEEL));
 
         // This must be set before any URL's because these might trigger an
         // connection attempt.
         setSslVerifyCert(juploadContext.getParameter(PROP_SSL_VERIFY_CERT, DEFAULT_SSL_VERIFY_CERT));
 
         // get the afterUploadURL juploadContext parameter.
         setAfterUploadURL(juploadContext.getParameter(PROP_AFTER_UPLOAD_URL, DEFAULT_AFTER_UPLOAD_URL));
 
         // FTP: whether or not to create subfolders on the server side.
         setFtpCreateDirectoryStructure(juploadContext.getParameter(PROP_FTP_CREATE_DIRECTORY_STRUCTURE,
                 DEFAULT_FTP_CREATE_DIRECTORY_STRUCTURE));
         // FTP transfert mode
         setFtpTransfertBinary(juploadContext.getParameter(PROP_FTP_TRANSFERT_BINARY, DEFAULT_FTP_TRANSFERT_BINARY));
         // FTP connection mode
         setFtpTransfertPassive(juploadContext.getParameter(PROP_FTP_TRANSFERT_PASSIVE, DEFAULT_FTP_TRANSFERT_PASSIVE));
 
         // get the fileChooser parameters
         setAllowedFileExtensions(juploadContext.getParameter(PROP_ALLOWED_FILE_EXTENSIONS,
                 DEFAULT_ALLOWED_FILE_EXTENSIONS));
         setFileFilterName(juploadContext.getParameter(PROP_FILE_FILTER_NAME, DEFAULT_FILE_FILTER_NAME));
         setFileListViewMode(juploadContext.getParameter(PROP_FILE_LIST_VIEW_MODE, DEFAULT_FILE_LIST_VIEW_MODE));
 
         setAllowHttpPersistent(juploadContext.getParameter(PROP_ALLOW_HTTP_PERSISTENT, DEFAULT_ALLOW_HTTP_PERSISTENT));
 
         setShowStatusbar(juploadContext.getParameter(PROP_SHOW_STATUSBAR, DEFAULT_SHOW_STATUSBAR));
 
         setShowLogWindow(juploadContext.getParameter(PROP_SHOW_LOGWINDOW, DEFAULT_SHOW_LOGWINDOW));
 
         // set the fileChooser relative stuff.
         setFileChooserIconFromFileContent(juploadContext.getParameter(PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT,
                 DEFAULT_FILE_CHOOSER_ICON_FROM_FILE_CONTENT));
         setFileChooserIconSize(juploadContext.getParameter(PROP_FILE_CHOOSER_ICON_SIZE, DEFAULT_FILE_CHOOSER_ICON_SIZE));
         setCurrentBrowsingDirectory(juploadContext.getParameter(PROP_BROWSING_DIRECTORY, DEFAULT_BROWSING_DIRECTORY));
         // get the filenameEncoding. If not null, it should be a valid argument for the URLEncoder.encode method.
         // DEPRECATED.
         setFilenameEncoding(juploadContext.getParameter(PROP_FILENAME_ENCODING, DEFAULT_FILENAME_ENCODING));
 
         // Read parameters about the HTTP upload request.
         setNbFilesPerRequest(juploadContext.getParameter(PROP_NB_FILES_PER_REQUEST, DEFAULT_NB_FILES_PER_REQUEST));
         setHttpUploadParameterName(juploadContext.getParameter(PROP_HTTP_UPLOAD_PARAMETER_NAME,
                 DEFAULT_HTTP_UPLOAD_PARAMETER_NAME));
         setHttpUploadParameterType(juploadContext.getParameter(PROP_HTTP_UPLOAD_PARAMETER_TYPE,
                 DEFAULT_HTTP_UPLOAD_PARAMETER_TYPE));
         // get the maximum size of a file on one HTTP request (indicates if the
         // file must be splitted before upload, see UploadPolicy comment).
         setMaxChunkSize(juploadContext.getParameter(PROP_MAX_CHUNK_SIZE, DEFAULT_MAX_CHUNK_SIZE));
         // get the maximum size of an uploaded file.
         setMaxFileSize(juploadContext.getParameter(PROP_MAX_FILE_SIZE, DEFAULT_MAX_FILE_SIZE));
         // retry management
         setRetryMaxNumberOf(juploadContext.getParameter(PROP_RETRY_MAX_NUMBER_OF, DEFAULT_RETRY_MAX_NUMBER_OF));
         setRetryNbSecondsBetween(juploadContext.getParameter(PROP_RETRY_NB_SECONDS_BETWEEN,
                 DEFAULT_RETRY_NB_SECONDS_BETWEEN));
 
         // get the URL where files must be posted.
         setPostURL(juploadContext.getParameter(PROP_POST_URL, DEFAULT_POST_URL));
 
         // get any additional headers.
         setReadCookieFromNavigator(juploadContext.getParameter(PROP_READ_COOKIE_FROM_NAVIGATOR,
                 DEFAULT_READ_COOKIE_FROM_NAVIGATOR));
         setReadUserAgentFromNavigator(juploadContext.getParameter(PROP_READ_USER_AGENT_FROM_NAVIGATOR,
                 DEFAULT_READ_USER_AGENT_FROM_NAVIGATOR));
         setSendMD5Sum(juploadContext.getParameter(PROP_SEND_MD5_SUM, DEFAULT_SEND_MD5_SUM));
         setSpecificHeaders(juploadContext.getParameter(PROP_SPECIFIC_HEADERS, DEFAULT_SPECIFIC_HEADERS));
         setStringUploadError(juploadContext.getParameter(PROP_STRING_UPLOAD_ERROR, DEFAULT_STRING_UPLOAD_ERROR));
         setStringUploadSuccess(juploadContext.getParameter(PROP_STRING_UPLOAD_SUCCESS, DEFAULT_STRING_UPLOAD_SUCCESS));
         setStringUploadWarning(juploadContext.getParameter(PROP_STRING_UPLOAD_WARNING, DEFAULT_STRING_UPLOAD_WARNING));
 
         // get the URL where the full debug output can be sent when an error
         // occurs.
         setUrlToSendErrorTo(juploadContext.getParameter(PROP_URL_TO_SEND_ERROR_TO, DEFAULT_URL_TO_SEND_ERROR_TO));
         this.formData = juploadContext.getParameter(PROP_FORMDATA, DEFAULT_FORMDATA);
         this.afterUploadTarget = juploadContext.getParameter(PROP_AFTER_UPLOAD_TARGET, DEFAULT_AFTER_UPLOAD_TARGET);
 
         // We let the UploadPolicyFactory call the displayParameterStatus
         // method, so that the initialization is finished, including for classes
         // which inherit from DefaultUploadPolicy.
         displayDebug("[DefaultUploadPolicy] end of constructor (serverProtocol has not been set)", 30);
     }
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// UploadPolicy methods
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /** @see UploadPolicy#start() */
     public void start() {
         // The current context may add any specific headers.
         if (getReadCookieFromNavigator()) {
             this.juploadContext.readCookieFromNavigator(this.headers);
         }
         if (getReadUserAgentFromNavigator()) {
             this.juploadContext.readUserAgentFromNavigator(this.headers);
         }
 
         // Let's touch the server, to test that everything is Ok. Take care,
         // this is the only place where we override the default value, by null:
         // the default value will be used by the HttpConnect.getProtocol()
         // method.
         // Also, in FTP mode, there can be no default value.
         //
         // Must be done AFTER reading the cookie and the userAgent.
         //
         HttpProtocolFinderThread.computeServerProtocol(this,
                 juploadContext.getParameter(PROP_SERVER_PROTOCOL, (String) null));
     }
 
     // getters and setters are sorted below
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#addHeader(java.lang.String)
      */
     public void addHeader(String header) {
         this.headers.add(header);
     }
 
     /**
      * The default behavior (see {@link DefaultUploadPolicy}) is to check that the stringUploadSuccess applet parameter
      * is present in the response from the server. The return is tested, in the order below: <DIR> <LI>False, if the
      * stringUploadError is found. An error message is then displayed. <LI>True, if the stringUploadSuccess is null or
      * empty (no test at all). <LI>True, if the stringUploadSuccess string is present in the serverOutputBody. <LI>True,
      * If previous condition is not filled, but the HTTP header "HTTP(.*)200OK$" is present: the test is currently non
      * blocking, because I can not test all possible HTTP configurations.<BR> <LI>False if the previous conditions are
      * not fullfilled. </DIR> <BR>
      * This method also looks for the stringUploadWarning regular expression. Each time it is matched, the found message
      * is displayed to the user.
      * 
      * @param status The HTTP response code
      * @param msg The status message from the first line of the response (e.g. "200 OK").
      * @param body The body of the HTTP answer.
      * @return True or False, indicating if the upload is a success or not.
      * @see UploadPolicy#checkUploadSuccess(int, String, String)
      */
     public boolean checkUploadSuccess(int status, String msg, String body) throws JUploadException {
         boolean bReturn = false;
 
         if (getDebugLevel() > 100) {
             // Let's have a little time to check the upload messages written on
             // the progress bar.
             try {
                 Thread.sleep(300);
             } catch (InterruptedException e) {
             }
         }
 
         this.lastResponseBody = body;
         this.lastResponseMessage = msg;
         displayDebug("HTTP status: " + msg, 30);
         // HTTP-100 correction, thanks to Marc Reidy
         if ((status != 200) && (status != 100))
             throw new JUploadExceptionUploadFailed("Received HTTP status " + msg);
 
         // HTTP-100 "continue", in case we're uploading
         // to an ASP.NET development server. We should
         // continue sending...
         if (status == 100)
             return true;
 
         // Let's analyze the body returned, line by line. The end of line
         // character may be CR, LF, or CRLF. We navigate through the body, and
         // replace any end of line character by a uniform CRLF.
         Matcher matcherError, matcherWarning;
         String line;
         Pattern p = Pattern.compile("[\\r\\n]", Pattern.MULTILINE);
         String[] lines = p.split(body);
         StringBuffer sbBodyWithUniformCRLF = new StringBuffer(body.length());
         for (int i = 0; i < lines.length; i += 1) {
             line = lines[i];
             sbBodyWithUniformCRLF.append(line).append("\r\n");
 
             // FIXME some empty lines are given by the server
             // Let's remove the empty line: with the p pattern, a multiline is
             // generated each time a \r\n is received, that is: for each line.
             if (line == null || line.equals("")) {
                 // An empty line. Let's go the next line.
                 continue;
             }
 
             // Check if this is a success
             // The success string should be in the http body
             if (getStringUploadSuccess() != null && !getStringUploadSuccess().equals("")) {
                 if (this.patternSuccess.matcher(line).matches()) {
                     // We go on. There may be some WARNING message, hereafter.
                     bReturn = true;
                 }
             }
 
             // Check if this is an error
             if (getStringUploadError() != null && !getStringUploadError().equals("")) {
                 matcherError = this.patternError.matcher(line);
                 if (matcherError.matches()) {
                     String errmsg = "An error occurs during upload (but the applet couldn't find the error message)";
                     if (matcherError.groupCount() > 0) {
                         if (!matcherError.group(1).equals("")) {
                             // Let's do a (very simple) formatting: one line to
                             // 100 characters
                             errmsg = formatMessage(matcherError.group(1));
                         }
                     }
                     this.lastResponseMessage = errmsg;
                     throw new JUploadExceptionUploadFailed(errmsg);
                 }
             }// getStringUploadError
 
             // Check if this is an warning
             if (getStringUploadWarning() != null && !getStringUploadWarning().equals("")) {
                 matcherWarning = this.patternWarning.matcher(line);
                 if (matcherWarning.matches()) {
                     String warnmsg = "A warning occurs during upload (but the applet couldn't find the warning message)";
                     if (matcherWarning.groupCount() > 0) {
                         if (!matcherWarning.group(1).equals("")) {
                             warnmsg = formatMessage(matcherWarning.group(1));
                         }
                     }
                     this.lastResponseMessage = warnmsg;
                     displayWarn(warnmsg);
                     alertStr(warnmsg);
                 }
             }// getStringUploadWarning
 
         }// while(st.hasMoreTokens())
 
         if (bReturn) {
             return true;
         }
 
         // We found no stringUploadSuccess nor stringUploadError
         if (getStringUploadSuccess() == null || getStringUploadSuccess().equals("")) {
             // No chance to check the correctness of this upload. -> Assume Ok
             return true;
         }
 
         // stringUploadSuccess was defined but we did not find it.
         // This is most certainly an error as http-status 200 does *not* refer
         // to the correctness of the content. It merely means that the protocol
         // handling was ok. -> throw an exception
         throw new JUploadExceptionUploadFailedSuccessNotFound(getClass().getName()
                 + ".checkUploadSuccess(): The regexp string \"" + getStringUploadSuccess()
                 + "\" was not found in the response body");
     } // checkUploadSuccess
 
     /**
      * Generation of a formatted error message, so that it can be displayed in a DialogBox. That is: each line that
      * contains more than {@link #DIALOG_MESSAGE_MAX_LINE_LENGTH} is truncated to DIALOG_MESSAGE_MAX_LINE_LENGTH.
      * 
      * @param msg
      * @return
      */
     protected String formatMessage(String msg) {
         StringBuffer sbMsg = new StringBuffer();
         String[] lines = msg.split("\\\\n");
         for (int i = 0; i < lines.length; i += 1) {
             // For each line, we truncate it, if it's too long.
             String line = lines[i];
             for (int j = 0, remaining = line.length(); remaining > 0; remaining -= DIALOG_MESSAGE_MAX_LINE_LENGTH, j += 1) {
                 if (remaining <= DIALOG_MESSAGE_MAX_LINE_LENGTH) {
                     // It's the last loop.
                     sbMsg.append(line.substring(j * DIALOG_MESSAGE_MAX_LINE_LENGTH));
                 } else {
                     sbMsg.append(line.substring(j * DIALOG_MESSAGE_MAX_LINE_LENGTH, (j + 1)
                             * DIALOG_MESSAGE_MAX_LINE_LENGTH));
                     sbMsg.append("\n");
                 }
             }
             // End we add the EOL characters, for all lines, but the last one.
             if (i < lines.length - 1) {
                 sbMsg.append("\n");
             }
         }
 
         return sbMsg.toString();
     }
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#afterUpload(Exception, String)
      */
     public void afterUpload(Exception e, String serverOutput) throws JUploadException {
         // If there was no error, and afterUploadURL is defined, let's try to go
         // to this URL.
         String url = getAfterUploadURL();
         if (url != null) {
             this.juploadContext.displayURL(url, e == null);
         }
     }
 
     /** @see UploadPolicy#alertStr(String) */
     public void alertStr(String str) {
         String str2 = str.replaceAll("\\\\n", "\n");
         JOptionPane.showMessageDialog(null, str2, "Alert", JOptionPane.WARNING_MESSAGE);
     }
 
     /** @see UploadPolicy#confirmDialogStr(String, int) */
     public int confirmDialogStr(String str, int optionTypes) {
         String str2 = str.replaceAll("\\\\n", "\n");
         return JOptionPane.showConfirmDialog(getContext().getUploadPanel().getJComponent().getParent(), str2, "Alert",
                 optionTypes);
     }
 
     /** @see UploadPolicy#alert(String) */
     public void alert(String key) {
         alertStr(getLocalizedString(key));
     }
 
     /**
      * The DefaultUpload accepts all file types: we just return an instance of FileData, without any test.
      * 
      * @exception JUploadExceptionStopAddingFiles If the users choosed to stop adding. This occurs when the
      *                {@link #fileFilterAccept(File)} method returns false, and the user then choose to stop adding
      *                files.
      * @see UploadPolicy#createFileData(File, File)
      */
     public FileData createFileData(File file) throws JUploadExceptionStopAddingFiles {
         if (!fileFilterAccept(file)) {
             String msg = file.getName() + " : " + getLocalizedString("errForbiddenExtension");
             displayWarn(msg);
             if (confirmDialogStr(msg, JOptionPane.OK_CANCEL_OPTION) == JOptionPane.CANCEL_OPTION) {
                 // The user want to stop to add files to the list. For instance,
                 // when he/she added a whole directory, and it contains a lot of
                 // files that don't match the allowed file extension.
                 throw new JUploadExceptionStopAddingFiles("Stopped by the user");
             }
             return null;
         } else if (!file.canRead()) {
             displayInfo("Can't read file " + file.getName() + ". No DefaultFileData creation.");
             return null;
         } else {
             return new DefaultFileData(file, this);
         }
     }
 
     /**
      * Default implementation of
      * {@link wjhk.jupload2.policies.UploadPolicy#createTopPanel(JButton, JButton, JButton, JUploadPanel)} . IT creates
      * a JPanel, containing the three given JButton. It creates the same panel as the original JUpload.
      * 
      * @see wjhk.jupload2.policies.UploadPolicy#createTopPanel(JButton, JButton, JButton, JUploadPanel)
      */
     public JPanel createTopPanel(JButton browse, JButton remove, JButton removeAll, JUploadPanel jUploadPanel) {
         JPanel jPanel = new JPanel();
 
         jPanel.setLayout(new GridLayout(1, 3, 10, 5));
         jPanel.setBorder(BorderFactory.createEmptyBorder(5, 10, 5, 10));
         jPanel.add(browse);
         jPanel.add(removeAll);
         jPanel.add(remove);
 
         jUploadPanel.getJComponent().setBorder(BorderFactory.createLineBorder(SystemColor.controlDkShadow));
 
         return jPanel;
     }
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#createProgressPanel(JProgressBar, JProgressBar, JButton, JButton,
      *      JUploadPanel)
      */
     public JPanel createProgressPanel(JProgressBar preparationProgressBar, JProgressBar uploadProgressBar,
             JButton uploadButton, JButton stopButton, JUploadPanel mainPanel) {
 
         // There may be two progress bar: one for preparation progress of files
         // (preparation before upload) and one to follow the actual upload.
         JPanel jProgressBarPanel = new JPanel();
         jProgressBarPanel.setLayout(new BorderLayout(10, 1));
         jProgressBarPanel.add(preparationProgressBar, BorderLayout.NORTH);
         jProgressBarPanel.add(uploadProgressBar, BorderLayout.SOUTH);
 
         JPanel jProgressPanel = new JPanel();
         jProgressPanel.setLayout(new BorderLayout(10, 0));
         jProgressPanel.setBorder(BorderFactory.createEmptyBorder(5, 10, 5, 10));
         jProgressPanel.add(uploadButton, BorderLayout.LINE_START);
         jProgressPanel.add(jProgressBarPanel, BorderLayout.CENTER);
         jProgressPanel.add(stopButton, BorderLayout.LINE_END);
         return jProgressPanel;
     }
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#createStatusBar(javax.swing.JLabel, JUploadPanel)
      */
     public JPanel createStatusBar(JLabel content, JUploadPanel mainPanel) {
         if (this.showStatusbar) {
             JPanel pstatus = new JPanel();
             pstatus.setLayout(new BorderLayout());
             pstatus.add(content, BorderLayout.CENTER);
             pstatus.setBorder(new BevelBorder(BevelBorder.LOWERED));
             return pstatus;
         }
         return null;
     }
 
     /**
      * This methods allow the upload policy to override the default disposition of the components on the applet.
      * 
      * @see UploadPolicy#addComponentsToJUploadPanel(JUploadPanel)
      */
     public void addComponentsToJUploadPanel(JUploadPanel jUploadPanel) {
         // Set the global layout of the panel.
         jUploadPanel.getJComponent().setLayout(new BoxLayout(jUploadPanel.getJComponent(), BoxLayout.Y_AXIS));
 
         // The top panel is the upper part of the applet: above the file
         // list.
         // JPanel topPanel = new JPanel();
         JPanel topPanel = createTopPanel(jUploadPanel.getBrowseButton(), jUploadPanel.getRemoveButton(),
                 jUploadPanel.getRemoveAllButton(), jUploadPanel);
         if (topPanel != null) {
             jUploadPanel.getJComponent().add(topPanel);
             topPanel.addMouseListener(jUploadPanel.getMouseListener());
         }
 
         // Then, we add the file list.
         jUploadPanel.getJComponent().add(jUploadPanel.getFilePanel().getDropComponent());
 
         // The progress panel contains the progress bar, and the upload and stop
         // buttons.
         JPanel progressPanel = createProgressPanel(jUploadPanel.getPreparationProgressBar(),
                 jUploadPanel.getUploadProgressBar(), jUploadPanel.getUploadButton(), jUploadPanel.getStopButton(),
                 jUploadPanel);
         jUploadPanel.getJComponent().add(progressPanel);
         jUploadPanel.getJComponent().addMouseListener(jUploadPanel.getMouseListener());
 
         // Now, we add the log window.
         jUploadPanel.showOrHideLogWindow();
         jUploadPanel.getJComponent().add(jUploadPanel.getJLogWindowPane());
 
         // And, to finish with: the status bar.
         JPanel p = createStatusBar(jUploadPanel.getStatusLabel(), jUploadPanel);
         if (null != p) {
             jUploadPanel.getJComponent().add(p);
             p.addMouseListener(jUploadPanel.getMouseListener());
         }
     }
 
     /** {@inheritDoc} */
     public void updateButtonState(int executionStatus) {
         // First step: check the parameter.
         if (executionStatus != UploadPolicy.EXEC_STATUS_READY && executionStatus != UploadPolicy.EXEC_STATUS_UPLOADING) {
             throw new java.lang.IllegalArgumentException("Unknow value for executionStatus: " + executionStatus);
         }
 
         // Then ... nothing to do! This class has no specific GUI item.
     }
 
     /** @see UploadPolicy#displayErr(Exception) */
     public void displayErr(Exception e) {
         displayErr(e.getMessage(), e);
     }
 
     /** @see UploadPolicy#displayErr(String) */
     public void displayErr(String err) {
         displayErr(err, null);
     }
 
     /**
      * Logs a stack trace for the given exception.
      * 
      * @param throwable
      */
     private void displayStackTrace(Throwable throwable) {
         if (throwable != null) {
             ByteArrayOutputStream bs = new ByteArrayOutputStream();
             PrintStream ps = new PrintStream(bs);
             throwable.printStackTrace(ps);
             ps.close();
             displayMsg("", bs.toString());
 
             // If there is a cause, let's be sure its stack trace is displayed.
             if (throwable.getCause() != null) {
                 displayMsg("", "Caused by:");
                 displayStackTrace(throwable.getCause());
             }
         }
     }
 
     /**
      * This method just logs an error.
      * 
      * @param errorText
      * @param exception
      */
     private void logErr(String errorText, Exception exception) {
         if (exception == null) {
             setLastException(new JUploadException("errorText"));
         } else if (exception instanceof JUploadException) {
             setLastException((JUploadException) exception);
         } else {
             setLastException(new JUploadException(exception));
         }
 
         // Default behavior: if debugLevel is 0, and an error occurs, we force
         // the debug level to 1: this makes the log window become visible, if it
         // was hidden.
         if (getDebugLevel() == 0)
             setDebugLevel(1);
 
         String exceptionMsg = null;
         String exceptionClassName = null;
         String logMsg = errorText;
 
         // First, we construct the exception class name.
         if (exception == null) {
             exceptionClassName = "";
         } else if (exception instanceof JUploadException) {
             exceptionClassName = "[" + ((JUploadException) exception).getClassNameAndClause() + "] ";
         } else {
             exceptionClassName = "[" + exception.getClass().getName() + "] ";
         }
 
         // Then, the message body can be completed by the exception message.
         if (exception != null) {
             // Ok, we have an exception.
             if (exception.getCause() != null) {
                 exceptionMsg = exception.getCause().getMessage();
             } else {
                 exceptionMsg = exception.getMessage();
             }
             logMsg = exceptionMsg + " (" + errorText + ")";
         }
 
         // Add the message to the log window
         displayMsg("[ERROR]", exceptionClassName + logMsg);
         // Let's display the stack trace, if relevant.
         displayStackTrace(exception);
 
         // Then we copy the debug output to the clipboard, and say it to the
         // current user.
         if (this.juploadContext.getUploadPanel() != null && getDebugLevel() >= 99) {
             // Ok, the applet has been fully built.
             this.juploadContext.getUploadPanel().copyLogWindow();
             alert("messageLogWindowCopiedToClipboard");
         }
 
     }
 
     /**
      * If debug is off, the log window may not be visible. We switch the debug to on, to be sure that some information
      * will be displayed to the user. <BR>
      * If debug is -1, the log window remains hidden.
      * 
      * @see wjhk.jupload2.policies.UploadPolicy#displayErr(java.lang.String, java.lang.Exception, int)
      */
     public int displayErr(String errorText, Exception exception, int optionTypes) {
         // Then, we display it to the user.
         String alertMsg = errorText;
         // Then, the message body can be completed by the exception message.
         if (exception != null && (errorText == null || errorText.equals(""))) {
             // Ok, we have an exception.
             if (exception.getCause() != null) {
                 alertMsg = exception.getCause().getMessage();
             } else {
                 alertMsg = exception.getMessage();
             }
         }
 
         // The message displayed depend on the debug level:
         if (getDebugLevel() >= 30 && exception != null) {
             alertMsg = exception.getClass().getName() + ": " + alertMsg;
         }
 
         // Display the message to the user. The kind of alert box depends on the
         // given options:
         int buttonClicked = 0;
         switch (optionTypes) {
             case -1:
                 // Standard message box.
                 alertStr(alertMsg);
                 buttonClicked = JOptionPane.OK_OPTION;
                 break;
             case JOptionPane.OK_CANCEL_OPTION:
             case JOptionPane.YES_NO_CANCEL_OPTION:
             case JOptionPane.YES_NO_OPTION:
                 buttonClicked = confirmDialogStr(alertMsg, optionTypes);
                 break;
             default:
                 // This is a problem. Let's display it to the user as a standard
                 // alert box.
                 alertStr(alertMsg);
                 buttonClicked = JOptionPane.OK_OPTION;
                 // Then, we log this new problem.
                 String msg = "Unknown optionType in displayErr(String, Exception, int)";
                 alertStr(msg);
                 logErr(msg, null);
         }
 
         // First, we log the error.
         logErr(errorText, exception);
 
         return buttonClicked;
     }
 
     /**
      * If debug is off, the log window may not be visible. We switch the debug to on, to be sure that some information
      * will be displayed to the user. <BR>
      * If debug is -1, the log window remains hidden.
      * 
      * @see wjhk.jupload2.policies.UploadPolicy#displayErr(java.lang.String, java.lang.Exception)
      */
     public void displayErr(String errorText, Exception exception) {
         displayErr(errorText, exception, -1);
     }
 
     /**
      * @see UploadPolicy#displayInfo(String)
      */
     public void displayInfo(String info) {
         displayMsg("[INFO]", info);
     }
 
     /**
      * @see UploadPolicy#displayWarn(String)
      */
     public void displayWarn(String warn) {
         displayMsg("[WARN]", warn);
     }
 
     /**
      * @see UploadPolicy#displayDebug(String, int)
      */
     public void displayDebug(String debug, int minDebugLevel) {
         final String tag = "[DEBUG]";
         if (this.debugLevel >= minDebugLevel) {
             // displayMsg will add the message to the debugStrignBuffer.
             displayMsg(tag, debug);
         } else if (this.debugGenerateFile) {
             // We have to write the message to the debug file, whatever the
             // debugLevel is.
             addMsgToDebugLog(tag + debug);
         }
     }
 
     /** @see UploadPolicy#getLocalizedString(String, Object...) */
     public String getLocalizedString(String key, Object... args) {
         String ret = this.resourceBundle.getString(key);
         try {
             // We have to recreate the correct call to String.format
             switch (args.length) {
                 case 0:
                     return String.format(ret);
                 case 1:
                     return String.format(ret, args[0]);
                 case 2:
                     return String.format(ret, args[0], args[1]);
                 case 3:
                     return String.format(ret, args[0], args[1], args[2]);
                 case 4:
                     return String.format(ret, args[0], args[1], args[2], args[3]);
                 case 5:
                     return String.format(ret, args[0], args[1], args[2], args[3], args[4]);
                 case 6:
                     return String.format(ret, args[0], args[1], args[2], args[3], args[4], args[5]);
                 case 7:
                     return String.format(ret, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
                 default:
                     throw new IllegalArgumentException(
                             "DefaultUploadPolicy.getLocalizedString accepts up to 7 variable parameters ("
                                     + args.length + " values were given for the 'args' argument");
             }
         } catch (IllegalFormatException ife) {
             displayErr(ife.getClass().getName() + " (" + ife.getMessage() + ")when managing this string: " + ret);
             throw ife;
         }
     }
 
     /**
      * @see UploadPolicy#getUploadFilename(FileData, int)
      */
     public String getUploadFilename(FileData fileData, int index) throws JUploadException {
         return getEncodedFilename(fileData.getFileName());
     }
 
     /**
      * returns the filename and encodes it, if necessary
      * 
      * @param filename the original filename
      * @return filename (encoded, if necessary)
      * @throws JUploadException
      */
     protected final String getEncodedFilename(String filename) throws JUploadException {
         if (this.filenameEncoding == null || this.filenameEncoding.equals("")) {
             return filename;
         }
         try {
             return URLEncoder.encode(filename, this.filenameEncoding);
         } catch (UnsupportedEncodingException e) {
             throw new JUploadException(e);
         }
     }
 
     /** @see UploadPolicy#getUploadName(FileData, int) */
     public String getUploadName(FileData fileData, int index) throws JUploadException {
         if (this.httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ARRAY)) {
             return this.httpUploadParameterName + "[]";
         } else if (this.httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ITERATION)) {
             return this.httpUploadParameterName + index;
         } else if (this.httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ONE_FILE)) {
             // Only valid if nbFilesPerRequest is 1. Let's check it.
             if (getNbFilesPerRequest() == 1) {
                 return this.httpUploadParameterName;
             } else {
                 throw new JUploadException(UploadPolicy.PROP_HTTP_UPLOAD_PARAMETER_TYPE + " value '"
                         + this.httpUploadParameterType + "' is only valid when '"
                         + UploadPolicy.PROP_NB_FILES_PER_REQUEST + " is 1.");
             }
         } else {
             throw new JUploadException(UploadPolicy.PROP_HTTP_UPLOAD_PARAMETER_TYPE + " '"
                     + this.httpUploadParameterType + "' is not implemented.");
         }
     }
 
     /** @see UploadPolicy#getHttpUploadParameterName() */
     public String getHttpUploadParameterName() {
         return this.httpUploadParameterName;
     }
 
     /**
      * Setter for the {@link #httpUploadParameterName}. This value is used by the {@link #getUploadName(FileData, int)}
      * method, to generate the name of the upload parameter that will contain the uploaded file.<BR>
      * The name must begin by a letter, then contain letter or numbers
      * 
      * @throws JUploadException When the given value is invalid (null, empty string, or contains other characters than
      *             letters and/or numbers)
      */
     protected void setHttpUploadParameterName(String httpUploadParameterName) throws JUploadException {
         // Some useful checks.
         if (httpUploadParameterName == null || httpUploadParameterName.equals("")) {
             throw new JUploadException("httpUploadParameterName may not be null");
         }
         // Control the parameter name content.
         if (!httpUploadParameterName.matches("^[a-zA-Z0-9][a-zA-Z0-9_]*$")) {
             throw new JUploadException(
                     "httpUploadParameterName may only contain letters (lowercase or uppercase) and numbers.");
         }
 
         // Ok, we're happy with the given value. Let's store it.
         this.httpUploadParameterName = httpUploadParameterName;
     }
 
     /** @see UploadPolicy#getHttpUploadParameterType() */
     public String getHttpUploadParameterType() {
         return this.httpUploadParameterType;
     }
 
     /**
      * Setter for the {@link #httpUploadParameterType}. This value is used by the {@link #getUploadName(FileData, int)}
      * method, to generate the name of the upload parameter that will contain the uploaded file. Depending on this
      * value, the parameter will be an iteration or an array.
      * 
      * @throws JUploadException
      */
     protected void setHttpUploadParameterType(String httpUploadParameterType) throws JUploadException {
         // Some useful checks.
         if (httpUploadParameterType == null) {
             throw new JUploadException("httpUploadParameterType may not be null");
         }
 
         // Check against the list of allowed values
         if (!httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ARRAY)
                 && !httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ITERATION)
                 && !httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ONE_FILE)) {
             throw new JUploadException("'" + httpUploadParameterType
                     + "' is not an allowed value for httpUploadParameterType.");
         }
 
         // OneFile is only valid ... when we upload file per file !
         if (httpUploadParameterType.equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ONE_FILE)) {
             if (getNbFilesPerRequest() != 1) {
                 throw new JUploadException("'" + httpUploadParameterType
                         + "' is only valid when nbFilesPerRequest is 1.");
             }
         }
 
         // Ok, we're happy. Let's store the value !
         this.httpUploadParameterType = httpUploadParameterType;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#beforeUpload() */
     public boolean beforeUpload() {
         // Default : nothing to do before upload, so we're ready.
         return true;
     }
 
     /** @see UploadPolicy#onAppendHeader(ByteArrayEncoder) */
     public ByteArrayEncoder onAppendHeader(ByteArrayEncoder bae) throws JUploadIOException {
         Iterator<String> it = this.headers.iterator();
         String header;
         displayDebug("[onAppendHeader] Start", 80);
         while (it.hasNext()) {
             header = it.next();
             if (header == null || header.equals("")) {
                 displayWarn("[onAppendHeader] Found one empty header. Ignoring it.");
             } else {
                 bae.append(header).append("\r\n");
                 displayDebug("[onAppendHeader] Header appended; " + header, 80);
             }
         }
         displayDebug("[onAppendHeader] End", 80);
         return bae;
     }// appendHeader
 
     /**
      * Default implementation of the
      * {@link wjhk.jupload2.policies.UploadPolicy#onFileSelected(wjhk.jupload2.filedata.FileData)} . Nothing's done.
      */
     public void onFileSelected(FileData fileData) {
         // Default implementation : no action
     }
 
     /**
      * Default implementation of the {@link wjhk.jupload2.policies.UploadPolicy#onFileDoubleClicked(FileData)} .
      * Nothing's done.
      */
     public void onFileDoubleClicked(FileData fileData) {
         // Default implementation : no action
     }
 
     /** @see UploadPolicy#sendDebugInformation(String, Exception) */
     public void sendDebugInformation(String description, Exception exception) {
         try {
             if (null == getUrlToSendErrorTo()) {
                 displayInfo("getUrlToSendErrorTo is null. No debug information is sent.");
                 if (exception == null) {
                     displayInfo("  No exception was stored!");
                 } else {
                     displayInfo("  The exception was: " + exception.getClass().getName() + exception.getMessage());
                 }
             } else {
                 displayInfo("Sending debug information to " + getUrlToSendErrorTo());
                 if (JOptionPane.showConfirmDialog(null, getLocalizedString("questionSendMailOnError"),
                         getLocalizedString("Confirm"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION) {
                     displayDebug("[sendDebugInformation] Within response == true", 30);
 
                     String action = null;
                     String line;
                     HTTPConnectionHelper connectionHelper = null;
                     boolean localDebugOk = this.debugOk;
 
                     try {
                         URL url = new URL(this.urlToSendErrorTo);
                         connectionHelper = new HTTPConnectionHelper(this);
                         connectionHelper.initRequest(url, "POST", false, true);
 
                         ByteArrayEncoder baeContent = new ByteArrayEncoderHTTP(this, connectionHelper
                                 .getByteArrayEncoder().getBoundary(), connectionHelper.getByteArrayEncoder()
                                 .getEncoding());
                         // The message is written in English, as it is not sure
                         // that
                         // the webmaster speaks the same language as the current
                         // user.
                         baeContent.appendTextProperty("description", "An error occured during upload, in JUpload.", -1);
                         String exceptionClass = null;
                         String exceptionCause = null;
                         String exceptionStackTrace = null;
                         if (exception != null) {
                             exceptionClass = exception.getClass().getName();
                             if (exception.getCause() != null) {
                                 exceptionCause = exception.getCause().getClass().getName();
                             }
                             StackTraceElement[] elements = exception.getStackTrace();
                             ByteArrayEncoderHTTP baeStackTrace = new ByteArrayEncoderHTTP(this, connectionHelper
                                     .getByteArrayEncoder().getBoundary(), connectionHelper.getByteArrayEncoder()
                                     .getEncoding());
                             for (int i = 0; i < elements.length; i += 1) {
                                 baeStackTrace.append(" at ");
                                 baeStackTrace.append(elements[i].getClassName());
                                 baeStackTrace.append(".");
                                 baeStackTrace.append(elements[i].getMethodName());
                                 baeStackTrace.append("() [line ");
                                 baeStackTrace.append(Integer.toString(elements[i].getLineNumber()));
                                 baeStackTrace.append("]\r\n");
                             }
                             baeStackTrace.close();
                             exceptionStackTrace = baeStackTrace.getString();
                         }
                         baeContent.appendTextProperty("exceptionClass", exceptionClass, -1);
                         baeContent.appendTextProperty("exceptionCause", exceptionCause, -1);
                         baeContent.appendTextProperty("exceptionStackTrace", exceptionStackTrace, -1);
 
                         String baeBound = connectionHelper.getByteArrayEncoder().getBoundary();
                         String baeEncoding = connectionHelper.getByteArrayEncoder().getEncoding();
                         ByteArrayEncoder baeDebug = new ByteArrayEncoderHTTP(this, baeBound, baeEncoding);
                         if (this.debugGenerateFile) {
                             // During debug output, we need to make sure that
                             // the debug log is not changed, so we set debugOk
                             // to false temporarily. -> Everything goes to
                             // stdout.
                             action = "flush (debugGenerateFile=true)";
                             synchronized (this) {
                                 this.debugOut.flush();
                                 this.debugOk = false;
                                 // First, calculate the size of the strings we
                                 // will
                                 // send.
                                 action = "read debug file (debugGenerateFile=true)";
                                 BufferedReader debugIn = new BufferedReader(new FileReader(this.debugFile));
                                 while ((line = debugIn.readLine()) != null) {
                                     baeDebug.append(line).append("\r\n");
                                 }
                                 debugIn.close();
 
                                 // We are done with the debug log, so re-enable
                                 // it.
                                 this.debugOk = localDebugOk;
                             }// synchronized(this)
                         }// if (this.debugGenerateFile)
                         else {
                             action = "read debug file (debugGenerateFile=false)";
                             baeDebug.append(this.juploadContext.getLogWindow().getText());
                         }
                         action = "baeDebug.close()";
                         baeDebug.close();
 
                         baeContent.appendTextProperty("debugOutput", baeDebug.getString(), -1);
                         baeContent.appendEndPropertyList();
                         // The content has been built.
                         baeContent.close();
 
                         // byteArrayEncoder
                         // .append("Content-type:
                         // application/x-www-form-urlencoded\r\n");
                         action = "send request";
                         connectionHelper.append("Content-Type: multipart/form-data; boundary=")
                                 .append(connectionHelper.getBoundary().substring(2)).append("\r\n");
                         connectionHelper.append("Content-length: ")
                                 .append(String.valueOf(baeContent.getEncodedLength())).append("\r\n");
 
                         // Let's send the headers (without baeDescription) ...
                         connectionHelper.sendRequest();
                         // Blank line (end of header)
                         connectionHelper.append("\r\n");
                         connectionHelper.append(baeContent);
 
                         action = "connectionHelper.readHttpResponse()";
                         int status = connectionHelper.readHttpResponse();
 
                         displayDebug(
                                 "========================================================================================",
                                 90);
                         displayDebug(
                                 "==================      sendDebugInformation [start]   =================================",
                                 90);
                         displayDebug(
                                 "========================================================================================",
                                 90);
                         displayDebug("[sendDebugInformation] Sent to server: \r\n"
                                 + connectionHelper.getByteArrayEncoder().getString(), 90);
                         displayDebug(
                                 "========================================================================================",
                                 90);
                         displayDebug("[sendDebugInformation] Body received: \r\n" + connectionHelper.getResponseBody(),
                                 90);
                         displayDebug(
                                 "========================================================================================",
                                 90);
                         displayDebug(
                                 "==================      sendDebugInformation [end]     =================================",
                                 90);
                         displayDebug(
                                 "========================================================================================",
                                 90);
 
                         // Is our upload a success ?
                         if (!checkUploadSuccess(status, connectionHelper.getResponseMsg(),
                                 connectionHelper.getResponseBody())) {
                             throw new JUploadExceptionUploadFailed(getLocalizedString("errHttpResponse"));
                         }
 
                         displayInfo("debug information sent correctly");
                     } catch (MalformedURLException e) {
                         throw new JUploadIOException("Malformed URL Exception for " + this.urlToSendErrorTo, e);
                     } catch (Exception e) {
                         this.debugOk = localDebugOk;
                         displayErr(getLocalizedString("errDuringLogManagement") + " (" + action + ")", e);
                     } finally {
                         this.debugOk = localDebugOk;
                     }
                 }
             }
         } catch (JUploadIOException e) {
             displayErr("Could not send debug information", e);
         }
     }// sendDebugInformation
 
     /**
      * This method manages all applet parameters. It allows javascript to update their value, for instance after the
      * user chooses a value in a list ...
      * 
      * @throws JUploadException
      * @see wjhk.jupload2.policies.UploadPolicy#setProperty(java.lang.String, java.lang.String)
      */
     public void setProperty(String prop, String value) throws JUploadException {
 
         displayDebug("[DefaultUploadPolicy] Call of setProperty: " + prop + " => " + value, 30);
 
         if (prop.equals(PROP_AFTER_UPLOAD_URL)) {
             setAfterUploadURL(value);
         } else if (prop.equals(PROP_ALLOW_HTTP_PERSISTENT)) {
             setAllowHttpPersistent(Boolean.parseBoolean(value));
         } else if (prop.equals(PROP_ALLOWED_FILE_EXTENSIONS)) {
             setAllowedFileExtensions(value);
         } else if (prop.equals(PROP_DEBUG_LEVEL)) {
             setDebugLevel(this.juploadContext.parseInt(value, this.debugLevel));
         } else if (prop.equals(PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT)) {
             setFileChooserIconFromFileContent(this.juploadContext.parseInt(value, getFileChooserIconFromFileContent()));
         } else if (prop.equals(PROP_FILE_CHOOSER_ICON_SIZE)) {
             setFileChooserIconSize(this.juploadContext.parseInt(value, getFileChooserIconSize()));
         } else if (prop.equals(PROP_FILE_FILTER_NAME)) {
             setFileFilterName(value);
         } else if (prop.equals(PROP_FILENAME_ENCODING)) {
             setFilenameEncoding(value);
         } else if (prop.equals(PROP_LANG)) {
             setLang(value);
         } else if (prop.equals(PROP_LOOK_AND_FEEL)) {
             setLookAndFeel(value);
         } else if (prop.equals(PROP_MAX_CHUNK_SIZE)) {
             setMaxChunkSize(this.juploadContext.parseLong(value, this.maxChunkSize));
         } else if (prop.equals(PROP_MAX_FILE_SIZE)) {
             setMaxFileSize(this.juploadContext.parseLong(value, this.maxFileSize));
         } else if (prop.equals(PROP_NB_FILES_PER_REQUEST)) {
             setNbFilesPerRequest(this.juploadContext.parseInt(value, this.nbFilesPerRequest));
         } else if (prop.equals(PROP_POST_URL)) {
             setPostURL(value);
         } else if (prop.equals(PROP_SERVER_PROTOCOL)) {
             // No specific action: the computeServerProtocol() is called once everything is initialized,
             // and the applet is ready for the user. This allows to give the 'hand' to the user quicker.
             // HttpProtocolFinderThread.computeServerProtocol(this, value);
         } else if (prop.equals(PROP_STRING_UPLOAD_SUCCESS)) {
             setStringUploadSuccess(value);
         } else if (prop.equals(PROP_SSL_VERIFY_CERT)) {
             setSslVerifyCert(value);
         } else if (prop.equals(PROP_URL_TO_SEND_ERROR_TO)) {
             setUrlToSendErrorTo(value);
         } else {
             displayWarn("Unknown applet parameter: " + prop + " (in DefaultUploadPolicy.setProperty)");
         }
     }
 
     /**
      * This method displays the applet parameter list, according to the current debugLevel. It is called by the
      * {@link #setDebugLevel(int)} method. It should be override by any subclasses, that should display its own
      * parameters, then call <I>super.displayParameterStatus()</I>.
      * 
      * @see UploadPolicy#displayParameterStatus()
      */
     public void displayParameterStatus() {
         displayDebug("=======================================================================", 30);
         displayDebug("======= Parameters managed by DefaultUploadPolicy", 30);
         // /////////////////////////////////////////////////////////////////////////////
         // Let's display some information to the user, about the received
         // parameters.
         displayInfo("JUpload applet, version " + this.juploadContext.getDetailedVersionMessage() + " (compiled: "
                 + this.juploadContext.getBuildDate() + "), available at http://jupload.sourceforge.net/");
         displayDebug("Java version: " + System.getProperty("java.version"), 30);
 
         displayDebug("List of all applet parameters:", 30);
         displayDebug("  language: " + this.resourceBundle.getLocale().getLanguage(), 30);
         displayDebug("  country: " + this.resourceBundle.getLocale().getCountry(), 30);
 
         displayDebug(PROP_AFTER_UPLOAD_URL + ": " + getAfterUploadURL(), 30);
         displayDebug(PROP_ALLOW_HTTP_PERSISTENT + ": " + getAllowHttpPersistent(), 30);
         displayDebug(PROP_ALLOWED_FILE_EXTENSIONS + ": " + getAllowedFileExtensions(), 30);
         displayDebug(PROP_BROWSING_DIRECTORY + " (current value): " + getCurrentBrowsingDirectory(), 30);
         displayDebug(PROP_DEBUG_LEVEL + ": " + this.debugLevel, 1);
         synchronized (this) {
             if (this.debugGenerateFile) {
                 displayDebug("  (debugfile: " + this.debugFile.getAbsolutePath() + ")", 1);
             }
         }
         displayDebug(PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT + ": " + getFileChooserIconFromFileContent(), 30);
         displayDebug(PROP_FILE_CHOOSER_ICON_SIZE + ": " + getFileChooserIconSize(), 30);
         displayDebug(PROP_FILE_FILTER_NAME + ": " + getFileFilterName(), 30);
         displayDebug(PROP_FILE_LIST_VIEW_MODE + ": " + getFileListViewMode(), 30);
         displayDebug(PROP_FILENAME_ENCODING + ": " + getFilenameEncoding(), 30);
         displayDebug(PROP_FORMDATA + ": " + getFormdata(), 30);
         displayDebug(PROP_FTP_CREATE_DIRECTORY_STRUCTURE + ": " + getFtpCreateDirectoryStructure(), 30);
         displayDebug(PROP_FTP_TRANSFERT_BINARY + ": " + getFtpTransfertBinary(), 30);
         displayDebug(PROP_FTP_TRANSFERT_PASSIVE + ": " + getFtpTransfertPassive(), 30);
         displayDebug(PROP_HTTP_UPLOAD_PARAMETER_NAME + ": " + getHttpUploadParameterName(), 30);
         displayDebug(PROP_HTTP_UPLOAD_PARAMETER_TYPE + ": " + getHttpUploadParameterType(), 30);
         displayDebug("lang: " + this.lang, 30);
         displayDebug(PROP_MAX_CHUNK_SIZE + ": " + getMaxChunkSize(), 30);
         if (this.maxFileSize == Long.MAX_VALUE) {
             // If the maxFileSize was not given, we display its value only
             // in debug mode.
             displayDebug(PROP_MAX_FILE_SIZE + ": " + getMaxFileSize(), 30);
         } else {
             // If the maxFileSize was given, we always inform the user.
             displayInfo(PROP_MAX_FILE_SIZE + ": " + getMaxFileSize());
         }
         displayDebug(PROP_NB_FILES_PER_REQUEST + ": " + getNbFilesPerRequest(), 30);
         displayDebug(PROP_POST_URL + ": " + this.postURL, 30);
         displayDebug(PROP_READ_COOKIE_FROM_NAVIGATOR + ": " + this.readCookieFromNavigator, 30);
         displayDebug(PROP_READ_USER_AGENT_FROM_NAVIGATOR + ": " + this.readUserAgentFromNavigator, 30);
         displayDebug(PROP_RETRY_MAX_NUMBER_OF + ": " + this.retryMaxNumberOf, 30);
         displayDebug(PROP_RETRY_NB_SECONDS_BETWEEN + ": " + this.retryNbSecondsBetween, 30);
         displayDebug(PROP_SEND_MD5_SUM + ": " + getSendMD5Sum(), 30);
         displayDebug(PROP_SERVER_PROTOCOL + ": " + getServerProtocol(), 30);
         displayDebug(PROP_SHOW_LOGWINDOW + ": " + getShowLogWindow(), 30);
         displayDebug(PROP_SHOW_STATUSBAR + ": " + this.showStatusbar, 30);
         displayDebug(PROP_SPECIFIC_HEADERS + ": " + getSpecificHeaders(), 30);
 
         displayDebug("Headers that will be added to the POST request: ", 30);
         for (Iterator<String> it = this.headers.iterator(); it.hasNext();) {
             displayDebug(it.next() + "\n", 30);
         }
         displayDebug(PROP_STRING_UPLOAD_ERROR + ": " + getStringUploadError(), 30);
         displayDebug(PROP_STRING_UPLOAD_SUCCESS + ": " + getStringUploadSuccess(), 30);
         displayDebug(PROP_STRING_UPLOAD_WARNING + ": " + getStringUploadWarning(), 30);
         displayDebug(PROP_URL_TO_SEND_ERROR_TO + ": " + getUrlToSendErrorTo(), 30);
         displayDebug("", 30);
     }
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// getters / setters
     // ///////////////////////////////////////////////////
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /** @see UploadPolicy#getAfterUploadURL() */
     public String getAfterUploadURL() {
         return this.afterUploadURL;
     }
 
     /**
      * Set the {@link #afterUploadURL}
      * 
      * @param afterUploadURL The URL to use.
      * @throws JUploadException
      */
     protected void setAfterUploadURL(String afterUploadURL) throws JUploadException {
         if (null == afterUploadURL)
             return;
         if (afterUploadURL.toLowerCase().startsWith("javascript:")) {
             this.afterUploadURL = afterUploadURL;
         } else
             this.afterUploadURL = this.juploadContext.normalizeURL(afterUploadURL);
     }
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#getAllowHttpPersistent()
      */
     public boolean getAllowHttpPersistent() {
         return this.allowHttpPersistent;
     }
 
     /** @see UploadPolicy#getAllowedFileExtensions() */
     public String getAllowedFileExtensions() {
         return this.allowedFileExtensions;
     }
 
     /**
      * @param allowedFileExtensions the allowedFileExtensions to set
      */
     protected void setAllowedFileExtensions(String allowedFileExtensions) {
         if (allowedFileExtensions == null || allowedFileExtensions.equals("")) {
             this.allowedFileExtensions = null;
         } else {
             this.allowedFileExtensions = (allowedFileExtensions.startsWith("/") ? "" : "/")
                     + allowedFileExtensions.toLowerCase() + (allowedFileExtensions.endsWith("/") ? "" : "/");
         }
     }
 
     protected void setAllowHttpPersistent(boolean value) {
         this.allowHttpPersistent = value;
     }
 
     /** @see UploadPolicy#getContext() */
     public JUploadContext getContext() {
         return this.juploadContext;
     }
 
     /** {@inheritDoc} */
     public void setCurrentBrowsingDirectory(File currentBrowsingDirectoryParam) {
         try {
             if (currentBrowsingDirectoryParam.isDirectory()) {
                 this.currentBrowsingDirectory = currentBrowsingDirectoryParam;
             } else {
                 displayWarn("DefaultUploadPolicy.setCurrentBrowsingDirectory(): " + currentBrowsingDirectoryParam
                         + " doesn't exist.");
             }
         } catch (SecurityException se) {
             displayWarn(se.getClass().getName() + " in DefaultUploadPolicy.setCurrentBrowsingDirectory(): "
                     + currentBrowsingDirectoryParam + " is ignored.");
         }
     }
 
     /**
      * @param currentBrowsingDirectoryParam The name of the directory that should be the current one.
      * @see UploadPolicy#setCurrentBrowsingDirectory(String)
      */
     public void setCurrentBrowsingDirectory(String currentBrowsingDirectoryParam) {
         try {
             if (currentBrowsingDirectoryParam == null) {
                 this.currentBrowsingDirectory = null;
             } else {
                 // Apparently, Java deosn't manage path beginning by ~. folder
                 // is actually ... ~!
                 // Let's manager this.
                 if (currentBrowsingDirectoryParam.startsWith("~")) {
                     // Let's keep the part of this path that is after the ~
                     currentBrowsingDirectoryParam = System.getProperty("user.home")
                             + currentBrowsingDirectoryParam.substring(1);
                 }
 
                 this.currentBrowsingDirectory = new File(currentBrowsingDirectoryParam);
 
                 // Let's check that we have a folder.
                 if (this.currentBrowsingDirectory != null && !this.currentBrowsingDirectory.isDirectory()) {
                     displayWarn("DefaultUploadPolicy.setCurrentBrowsingDirectory(): <" + currentBrowsingDirectoryParam
                             + "> doesn't exist or is not a directory.");
                     this.currentBrowsingDirectory = null;
                 }
             }
         } catch (SecurityException se) {
             displayWarn(se.getClass().getName() + " in DefaultUploadPolicy.setCurrentBrowsingDirectory(): "
                     + currentBrowsingDirectoryParam + " is ignored.");
         }
     }
 
     /** @see UploadPolicy#getCurrentBrowsingDirectory() */
     public File getCurrentBrowsingDirectory() {
         return this.currentBrowsingDirectory;
     }
 
     /** @see UploadPolicy#getDateFormat() */
     public String getDateFormat() {
         return UploadPolicy.DEFAULT_DATE_FORMAT;
     }
 
     /** @see UploadPolicy#getDebugLevel() */
     public int getDebugLevel() {
         return this.debugLevel;
     }
 
     /** @see UploadPolicy#setDebugLevel(int) */
     public void setDebugLevel(int debugLevel) {
         setDebugLevel(debugLevel, true);
     }
 
     /**
      * Set the debug level.
      * 
      * @param debugLevel The new debuglevel.
      * @param displayAppletParameterList Flag. If set to true, the applet's parameters are shown.
      */
     public synchronized void setDebugLevel(int debugLevel, boolean displayAppletParameterList) {
         // If the debugLevel was previously set, we inform the user of this
         // change.
         if (this.debugLevel >= 0) {
             displayInfo("Debug level set to " + debugLevel);
             if (this.debugGenerateFile) {
                 displayInfo("Current debug output file: " + this.debugFile.getAbsolutePath());
             }
         }
         this.debugLevel = debugLevel;
 
         // Let's display the current applet parameters.
         if (displayAppletParameterList) {
             displayParameterStatus();
         }
     }
 
     /**
      * Getter for fileChooserIconFromFileContent.
      * 
      * @return Current value for fileChooserIconFromFileContent
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT
      */
     public int getFileChooserIconFromFileContent() {
         return this.fileChooserIconFromFileContent;
     }
 
     /**
      * Setter for fileChooserIconFromFileContent. Current allowed values are: -1, 0, 1. Default value is 0.
      * 
      * @param fileChooserIconFromFileContent Value to be set. If the value is not allowed (not -1, 0 or 1), the current
      *            value is unchangeed.
      * @exception java.lang.IllegalArgumentException When a value not in -1, 0 1 is given.
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_FROM_FILE_CONTENT
      */
     public void setFileChooserIconFromFileContent(int fileChooserIconFromFileContent) {
         if (fileChooserIconFromFileContent != -1 && fileChooserIconFromFileContent != 0
                 && fileChooserIconFromFileContent != 1) {
             throw new java.lang.IllegalArgumentException("fileChooserIconFromFileContent must be one of -1, 0, 1");
         }
         this.fileChooserIconFromFileContent = fileChooserIconFromFileContent;
     }
 
     /**
      * Getter for fileChooserIconSize.
      * 
      * @return Current value for fileChooserIconSize
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_SIZE
      */
     public int getFileChooserIconSize() {
         return this.fileChooserIconSize;
     }
 
     /**
      * Setter for fileChooserIconSize.
      * 
      * @param fileChooserIconSize Value to be set.
      * @exception java.lang.IllegalArgumentException When a negative value is given.
      * @see UploadPolicy#PROP_FILE_CHOOSER_ICON_SIZE
      */
     public void setFileChooserIconSize(int fileChooserIconSize) {
         if (fileChooserIconSize <= 0) {
             throw new java.lang.IllegalArgumentException("fileChooserIconSize must be more than 0");
         }
         this.fileChooserIconSize = fileChooserIconSize;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#setLang(String) */
     public void setLang(String lang) {
         this.lang = lang;
         if (lang == null) {
             displayInfo("lang = null, taking default language");
             locale = Locale.getDefault();
         } else {
             // If we have a 5 characters lang string, then it should look like
             // ll_CC, where ll is the language code
             // and CC is the Country code.
             if (lang.length() == 5 && (lang.substring(2, 3).equals("_") || lang.substring(2, 3).equals("-"))) {
                 String language = lang.substring(0, 2);
                 String country = lang.substring(3, 5);
                 displayDebug("setLang - language read: " + language, 50);
                 displayDebug("setLang - country read: " + country, 50);
                 locale = new Locale(language, country.toUpperCase());
             } else {
                 locale = new Locale(lang);
                 displayDebug("setLang - language read (no country): " + lang, 50);
             }
         }
 
         /*
          * Patch given by Patrick Use of a specific class loader. The standard ResourceBundle checks first for a class
          * that has the name of the resource bundle. Since there is no such class in the jar file, the AppletClassLoader
          * makes a http request to the server, which will end with a 404 since there is no such class either. To avoid
          * this unnecessary lookup we use a class loader that throws directly a ClassNotFoundException. After looking
          * for a class (which is unsuccessful) ResourceBundle looks finally for a properties file. Therefore we delegate
          * that lookup to the original class loader since this is in the jar file.
          */
         this.resourceBundle = ResourceBundle.getBundle("lang.lang", locale,
         // Special class loader, see description above
                 new ClassLoader(this.getClass().getClassLoader()) {
                     /** {@inheritDoc} */
                     @Override
                     public Class<?> loadClass(String name) throws ClassNotFoundException {
                         throw new ClassNotFoundException();
                     }
 
                     /** {@inheritDoc} */
                     @Override
                     public InputStream getResourceAsStream(String name) {
                         return this.getClass().getClassLoader().getResourceAsStream(name);
                     }
                 });
     }
 
     /** {@inheritDoc} */
     public Locale getLocale() {
         return this.locale;
     }
 
     /**
      */
     protected String getLookAndFeel() {
         return this.lookAndFeel;
     }
 
     /**
      * @param lookAndFeel the lookAndFeel to set
      */
     protected void setLookAndFeel(String lookAndFeel) {
         try {
             this.lookAndFeel = lookAndFeel;
             if (lookAndFeel != null && !lookAndFeel.equals("") && !lookAndFeel.equals("java")) {
                 // We try to call the UIManager.setLookAndFeel() method. We
                 // catch
                 // all possible exceptions, to prevent
                 // that the applet is blocked.
                 if (!lookAndFeel.equals("system")) {
                     // Correction given by Fritz. Thanks to him.
                     UIManager.setLookAndFeel(lookAndFeel);
                 } else {
                     UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                 }
             } else {
                 this.lookAndFeel = "java";
                 UIManager.setLookAndFeel(new javax.swing.plaf.metal.MetalLookAndFeel());
             }
         } catch (Exception e) {
             displayErr(e);
             try {
                 this.lookAndFeel = "java";
                 UIManager.setLookAndFeel(new javax.swing.plaf.metal.MetalLookAndFeel());
             } catch (UnsupportedLookAndFeelException e1) {
                 displayErr(e1);
                 // Hum, hum: we should not arrive here... We not a 'dummy' one.
                 this.lookAndFeel = null;
             }
         }
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getMaxChunkSize() */
     public long getMaxChunkSize() {
         return this.maxChunkSize;
     }
 
     /**
      * If the given value is less or equals to 0, it is set back to Long_MAX_VALUE.
      * 
      * @param maxChunkSize the maxChunkSize to set
      */
     protected void setMaxChunkSize(long maxChunkSize) {
         if (maxChunkSize <= 0) {
             displayDebug("maxChunkSize<=0 which is invalid. Switched to the default value (Long.MAX_VALUE)", 1);
             maxChunkSize = Long.MAX_VALUE;
         }
         this.maxChunkSize = maxChunkSize;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getMaxFileSize() */
     public long getMaxFileSize() {
         return this.maxFileSize;
     }
 
     /**
      * @param maxFileSize the maxFileSize to set
      */
     protected void setMaxFileSize(long maxFileSize) {
         if (maxFileSize <= 0) {
             displayDebug("maxFileSize<=0 which is invalid. Switched to the default value (Long.MAX_VALUE)", 1);
             maxFileSize = Long.MAX_VALUE;
         }
         this.maxFileSize = maxFileSize;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getNbFilesPerRequest() */
     public int getNbFilesPerRequest() {
         return this.nbFilesPerRequest;
     }
 
     /**
      * @param nbFilesPerRequest the nbFilesPerRequest to set
      * @throws JUploadException
      */
     protected void setNbFilesPerRequest(int nbFilesPerRequest) throws JUploadException {
         // If httpUploadParameterType is oneFile,
         if (getHttpUploadParameterType().equals(UploadPolicy.HTTPUPLOADPARAMETERTYPE_ONE_FILE)
                 && nbFilesPerRequest != 1) {
             throw new JUploadException("nbFilesPerRequest must be 1, when httpUploadParameterType is oneFile");
         }
 
         if (nbFilesPerRequest < 1) {
             displayDebug("nbFilesPerRequest <1 : switched to the 'unlimited' value (Integer.MAX_VALUE)", 1);
             this.nbFilesPerRequest = Integer.MAX_VALUE;
         } else {
             this.nbFilesPerRequest = nbFilesPerRequest;
         }
     }
 
     /** @see UploadPolicy#getFileListViewMode() */
     public FileListViewMode getFileListViewMode() {
         return fileListViewMode;
     }
 
     /** @see UploadPolicy#getFileListViewMode() */
     public void setFileListViewMode(FileListViewMode fileListViewMode) {
         this.fileListViewMode = fileListViewMode;
     }
 
     /** @see UploadPolicy#getFilenameEncoding() */
     @Deprecated
     public String getFilenameEncoding() {
         return this.filenameEncoding;
     }
 
     /** @see UploadPolicy#getFileFilterName() */
     public String getFileFilterName() {
         return this.fileFilterName;
     }
 
     /**
      * @param fileFilterName The new name for the fileFilter
      * @see UploadPolicy#PROP_FILE_FILTER_NAME
      */
     protected void setFileFilterName(String fileFilterName) {
         this.fileFilterName = fileFilterName;
     }
 
     /**
      * @param filenameEncoding the filenameEncoding to set
      */
     protected void setFilenameEncoding(String filenameEncoding) {
         if (filenameEncoding != null && filenameEncoding.equals("")) {
             filenameEncoding = null;
         }
         if (filenameEncoding != null && !Charset.isSupported(filenameEncoding)) {
             throw new UnsupportedCharsetException("non supported charset (" + filenameEncoding + ")");
         }
         this.filenameEncoding = filenameEncoding;
     }
 
     /** @see UploadPolicy#getFtpCreateDirectoryStructure() */
     public boolean getFtpCreateDirectoryStructure() {
         return this.ftpCreateDirectoryStructure;
     }
 
     /**
      * @param ftpCreateDirectoryStructure the ftpCreateDirectoryStructure to set
      */
     protected void setFtpCreateDirectoryStructure(boolean ftpCreateDirectoryStructure) {
         this.ftpCreateDirectoryStructure = ftpCreateDirectoryStructure;
     }
 
     /** @see UploadPolicy#getFtpTransfertBinary() */
     public boolean getFtpTransfertBinary() {
         return this.ftpTransfertBinary;
     }
 
     /**
      * @param ftpTransfertBinary the ftpTransfertBinary to set
      */
     protected void setFtpTransfertBinary(boolean ftpTransfertBinary) {
         this.ftpTransfertBinary = ftpTransfertBinary;
     }
 
     /** @see UploadPolicy#getFtpTransfertPassive() */
     public boolean getFtpTransfertPassive() {
         return this.ftpTransfertPassive;
     }
 
     /**
      * @param ftpTransfertPassive the ftpTransfertPassive to set
      */
     protected void setFtpTransfertPassive(boolean ftpTransfertPassive) {
         this.ftpTransfertPassive = ftpTransfertPassive;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getPostURL() */
     public String getPostURL() {
         return this.postURL;
     }
 
     /**
      * @throws JUploadException
      * @see wjhk.jupload2.policies.UploadPolicy#setPostURL(String)
      */
     public void setPostURL(String postURL) throws JUploadException {
         // Be more forgiving about postURL:
         // - If none is specified, use the original DocumentBase of the
         // applet.
         // - If a non-absolute URI (an URI without protocol and server) is
         // specified,
         // prefix it with "http://servername"
         // - If a relative URI is specified, prefix it with the DocumentBase's
         // parent
         this.postURL = this.juploadContext.normalizeURL(postURL);
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getReadCookieFromNavigator() */
     public boolean getReadCookieFromNavigator() {
         return this.readCookieFromNavigator;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getReadCookieFromNavigator() */
     protected void setReadCookieFromNavigator(boolean readCookieFromNavigator) {
         this.readCookieFromNavigator = readCookieFromNavigator;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getReadUserAgentFromNavigator() */
     public boolean getReadUserAgentFromNavigator() {
         return this.readUserAgentFromNavigator;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getReadUserAgentFromNavigator() */
     protected void setReadUserAgentFromNavigator(boolean readUserAgentFromNavigator) {
         this.readUserAgentFromNavigator = readUserAgentFromNavigator;
     }
 
     /** @see UploadPolicy#getRetryMaxNumberOf() */
     public int getRetryMaxNumberOf() {
         return this.retryMaxNumberOf;
     }
 
     /**
      * @param retryMaxNumberOf New value to set for the retryMaxNumberOf applet parameter
      * @exception IllegalArgumentException If retryMaxNumberOf is less than 0.
      * @see UploadPolicy#getRetryMaxNumberOf()
      */
     public void setRetryMaxNumberOf(int retryMaxNumberOf) {
         if (retryMaxNumberOf < 0) {
             throw new IllegalArgumentException("retryMaxNumberOf must be 0 or more");
         }
         this.retryMaxNumberOf = retryMaxNumberOf;
     }
 
     /** @see UploadPolicy#getRetryNbSecondsBetween() */
     public int getRetryNbSecondsBetween() {
         return this.retryNbSecondsBetween;
     }
 
     /**
      * @param retryNbSecondsBetween New value to set for the retryNbSecondsBetween applet parameter
      * @exception IllegalArgumentException If retryNbSecondsBetween is less than 0.
      * @see UploadPolicy#getRetryNbSecondsBetween()
      */
     public void setRetryNbSecondsBetween(int retryNbSecondsBetween) {
         if (retryNbSecondsBetween < 0) {
             throw new IllegalArgumentException("retryNbSecondsBetween must be 0 or more");
         }
         this.retryNbSecondsBetween = retryNbSecondsBetween;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getServerProtocol() */
     public String getServerProtocol() {
         if (this.serverProtocol == null) {
             return DEFAULT_SERVER_PROTOCOL;
         } else {
             return this.serverProtocol;
         }
     }
 
     /** @see UploadPolicy#setServerProtocol(String) */
     public void setServerProtocol(String serverProtocol) {
         this.serverProtocol = serverProtocol;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getSendMD5Sum() */
     public boolean getSendMD5Sum() {
         return this.sendMD5Sum;
     }
 
     /** @see UploadPolicy#setSendMD5Sum(boolean) */
     public void setSendMD5Sum(boolean sendMD5Sum) {
         this.sendMD5Sum = sendMD5Sum;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getShowLogWindow() */
     public String getShowLogWindow() {
         return this.showLogWindow;
     }
 
     /** {@inheritDoc} */
     public void setShowLogWindow(String showLogWindow) {
         if (showLogWindow.equals(SHOWLOGWINDOW_TRUE) || showLogWindow.equals(SHOWLOGWINDOW_FALSE)
                 || showLogWindow.equals(SHOWLOGWINDOW_ONERROR)) {
             this.showLogWindow = showLogWindow;
             // The log window may become visible or hidden, depending on this
             // parameter.
             if (this.juploadContext.getUploadPanel() != null) {
                 this.juploadContext.getUploadPanel().showOrHideLogWindow();
             }
         } else {
             displayWarn("[setShowLogWindow] Unallowed value: " + showLogWindow + " (showLogWindow is left unchanged)");
         }
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getSpecificHeaders() */
     public String getSpecificHeaders() {
         return this.specificHeaders;
     }
 
     /**
      * Set all specific headers defined in the specificHeaders applet parameter. This string is splitted, so that each
      * header is added to the headers Vector. These headers are added to the headers list during applet initialization.
      * There is currently no automatic way to remove the headers coming from specificHeaders, after initialization.
      * 
      * @param specificHeaders
      */
     protected void setSpecificHeaders(String specificHeaders) {
         this.specificHeaders = specificHeaders;
         if (specificHeaders != null) {
             // Let's add each header in specificHeaders to the headers list. In
             // specificHeaders, each header is separated by the \n string (two
             // characters: \ then n, not the \n character).
             // The regexp to find the \n string (not the \n character) is: \\n
             // We then double each \ character:
             String[] headerArray = specificHeaders.split("\\\\n");
             for (int x = 0; x < headerArray.length; x++) {
                 addHeader(headerArray[x]);
             }
         }
     }
 
     /**
      * @see wjhk.jupload2.policies.UploadPolicy#getSslVerifyCert()
      */
     public int getSslVerifyCert() {
         return this.sslVerifyCert;
     }
 
     protected void setSslVerifyCert(String mode) throws JUploadException {
         int val = -1;
         if (mode.toLowerCase().equals("none"))
             val = InteractiveTrustManager.NONE;
         if (mode.toLowerCase().equals("server"))
             val = InteractiveTrustManager.SERVER;
         if (mode.toLowerCase().equals("client"))
             val = InteractiveTrustManager.CLIENT;
         if (mode.toLowerCase().equals("strict"))
             val = InteractiveTrustManager.STRICT;
         if (val == -1)
             throw new JUploadException("Invalid parameter sslVerifyCert (" + mode + ")");
         this.sslVerifyCert = val;
     }
 
     /**
      * @param show the new showStatusbar value
      */
     protected void setShowStatusbar(boolean show) {
         this.showStatusbar = show;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getStringUploadError() */
     public String getStringUploadError() {
         return this.stringUploadError;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getStringUploadSuccess() */
     public String getStringUploadSuccess() {
         return this.stringUploadSuccess;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getStringUploadWarning() */
     public String getStringUploadWarning() {
         return this.stringUploadWarning;
     }
 
     /**
      * @param stringUploadError the stringUploadError to set
      * @throws JUploadException
      */
     protected void setStringUploadError(String stringUploadError) throws JUploadException {
         this.stringUploadError = stringUploadError;
         if (stringUploadError != null) {
             try {
                 this.patternError = Pattern.compile(stringUploadError);
             } catch (PatternSyntaxException e) {
                 throw new JUploadException("Invalid regex in parameter stringUploadError");
             }
         }
     }
 
     /**
      * @param stringUploadSuccess the stringUploadSuccess to set
      * @throws JUploadException
      */
     protected void setStringUploadSuccess(String stringUploadSuccess) throws JUploadException {
         this.stringUploadSuccess = stringUploadSuccess;
         if (stringUploadSuccess != null) {
             try {
                 this.patternSuccess = Pattern.compile(stringUploadSuccess);
             } catch (PatternSyntaxException e) {
                 throw new JUploadException("Invalid regex in parameter stringUploadSuccess");
             }
         }
     }
 
     /**
      * @param stringUploadWarning the stringUploadWarning to set
      * @throws JUploadException
      */
     protected void setStringUploadWarning(String stringUploadWarning) throws JUploadException {
         this.stringUploadWarning = stringUploadWarning;
         if (stringUploadWarning != null) {
             try {
                 this.patternWarning = Pattern.compile(stringUploadWarning);
             } catch (PatternSyntaxException e) {
                 throw new JUploadException("Invalid regex in parameter stringUploadWarning");
             }
         }
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getUrlToSendErrorTo() */
     public String getUrlToSendErrorTo() {
         return this.urlToSendErrorTo;
     }
 
     /** {@inheritDoc} */
     public void setUrlToSendErrorTo(String urlToSendErrorTo) throws JUploadException {
         if (null == urlToSendErrorTo)
             return;
         String tmp = this.juploadContext.normalizeURL(urlToSendErrorTo);
         if (tmp.startsWith("ftp://")) {
             throw new JUploadException("urlToSendErrorTo: ftp scheme not supported.");
         }
         this.urlToSendErrorTo = tmp;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getFormdata() */
     public String getFormdata() {
         return this.formData;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getAfterUploadTarget() */
     public String getAfterUploadTarget() {
         return this.afterUploadTarget;
     }
 
     // //////////////////////////////////////////////////////////////////////////////////////////////
     // /////////////////// Internal methods
     // //////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
      * Delete the current log. (called upon applet termination)
      */
     public synchronized void deleteLog() {
         if (this.debugGenerateFile) {
             try {
                 if (null != this.debugOut) {
                     this.debugOut.close();
                     this.debugOut = null;
                 }
                 if (null != this.debugFile) {
                     if (!this.debugFile.delete()) {
                         displayWarn(this.debugFile.getName() + " was not correctly removed!");
                     }
                     this.debugFile = null;
                 }
             } catch (Exception e) {
                 // nothing to do: we mask the exception.
                 displayWarn(e.getClass().getName() + " occured in deleteLog(). Exception ignored.");
             }
         }
     }
 
     /**
      * This methods allows the applet to store all messages (debug, warning, info, errors...) into a StringBuffer. If
      * any problem occurs, the whole output (displayed or not by the displayDebug, for instance) can be stored in a
      * file, or sent to the webmaster. This can help to identify and correct problems that can occurs on the various
      * computer configurations.
      * 
      * @param msg
      */
     protected synchronized void addMsgToDebugLog(String msg) {
         // If uploading lots of chunks, the buffer gets too large, resulting in
         // a OutOfMemoryError on the heap so we now use a temporary file for the
         // debug log.
         if (this.debugGenerateFile && this.debugOk) {
             try {
                 if (null == this.debugOut) {
                     this.juploadContext.registerUnload(this, "deleteLog");
                     this.debugFile = File.createTempFile("jupload_", "_log.txt");
                     this.debugOut = new PrintStream(new FileOutputStream(this.debugFile));
                 }
                 boolean endsLF = msg.endsWith("\n");
                 msg = msg.replaceAll("\n", this.CRLF);
                 if (endsLF) {
                     this.debugOut.print(msg);
                 } else {
                     this.debugOut.println(msg);
                 }
             } catch (IOException e) {
                 this.debugOk = false;
                 System.err.println("IO error on debuglog " + this.debugFile.getPath()
                         + "\nFallback to standard output.");
                 System.out.println(msg);
             }
         } else {
             System.out.println(msg);
         }
     }
 
     /**
      * Displays a message. If the logWindow panel is set, the message is displayed on it. If not, the System.out.println
      * function is used.
      * 
      * @param msg The message to display.
      */
     private void displayMsg(String tag, String msg) {
         String message;
 
         if (this.juploadContext.getLogWindow() == null) {
             message = tag + " - " + msg;
             System.out.println(message);
         } else {
             message = this.juploadContext.getLogWindow().displayMsg(tag, msg);
         }
         // Let's store all text in the debug logfile
         if (this.debugGenerateFile) {
             addMsgToDebugLog(message);
         }
     }
 
     /**
      * Default reaction after a successful drop operation: no action.
      * 
      * @see UploadPolicy#afterFileDropped(DropTargetDropEvent)
      */
     public void afterFileDropped(DropTargetDropEvent dropEvent) {
         // Default: no action.
     }
 
     /**
      * Default implementation for {@link UploadPolicy#createFileChooser()}: just a creation of a
      * {@link JUploadFileChooser}.
      * 
      * @see UploadPolicy#createFileChooser()
      */
     public JUploadFileChooser createFileChooser() {
         return new JUploadFileChooser(this);
     }
 
     /**
      * This method returns the response for the {@link JUploadFileFilter#accept(File)} which just calls this method.
      * This method checks that the file extension corresponds to the allowedFileExtensions applet parameter.
      * 
      * @see UploadPolicy#fileFilterAccept(File)
      */
     public boolean fileFilterAccept(File file) {
         if (file.isDirectory()) {
             return true;
         } else if (this.allowedFileExtensions == null || this.allowedFileExtensions.equals("")) {
             return true;
         } else {
             // Get the file extension
             String extension = DefaultFileData.getExtension(file.getName()).toLowerCase();
             // allowedFileExtensions is :
             // - a list of file extensions,
             // - in lower case,
             // - separated by slash
             // - A slash has been added at the beginning in
             // setAllowedFileExtensions
             // - A slash has been added at the end in setAllowedFileExtensions
             // So, we just look for the /ext/ string in the stored
             // allowedFileExtensions.
             return (this.allowedFileExtensions.indexOf("/" + extension + "/")) >= 0;
         }
     }
 
     /** @see UploadPolicy#fileFilterGetDescription() */
     public String fileFilterGetDescription() {
         if (this.allowedFileExtensions == null || this.allowedFileExtensions.equals("")) {
             return null;
         } else if (getFileFilterName() != null) {
             return getFileFilterName();
         } else {
             return "JUpload file filter (" + this.allowedFileExtensions + ")";
         }
     }
 
     /**
      * Returns null: the default icon is used.
      * 
      * @see UploadPolicy#fileViewGetIcon(File)
      */
     public Icon fileViewGetIcon(File file) {
         return null;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getLastException() */
     public JUploadException getLastException() {
         return this.lastException;
     }
 
     /**
      * Set the last exception.
      * 
      * @param exception The last exception that occurs into the applet.
      */
     public void setLastException(JUploadException exception) {
         this.lastException = exception;
 
         // The log window may become visible.
         if (this.juploadContext.getUploadPanel() != null) {
             this.juploadContext.getUploadPanel().showOrHideLogWindow();
         }
 
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getLastResponseBody() */
     public String getLastResponseBody() {
         return this.lastResponseBody;
     }
 
     /** @see wjhk.jupload2.policies.UploadPolicy#getLastResponseMessage() */
     public String getLastResponseMessage() {
         return (null != this.lastResponseMessage) ? this.lastResponseMessage : "";
     }
 
     /**
      * @return The cursor that was active before setting the new one. Can be used to restore its previous state.
      * @see UploadPolicy#setCursor(Cursor)
      */
     public Cursor setCursor(Cursor cursor) {
         return this.juploadContext.setCursor(cursor);
     }
 
     /**
      * @return The cursor that was active before setting the new one. Can be used to restore its previous state.
      * @see UploadPolicy#setWaitCursor()
      */
     public Cursor setWaitCursor() {
         return this.juploadContext.setWaitCursor();
     }
 
 }