489 lines
16 KiB
Java
Executable File
489 lines
16 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2001-2004 Red Hat Inc. All Rights Reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
package com.arsdigita.cms.ui;
|
|
|
|
import com.arsdigita.bebop.ColumnPanel;
|
|
import com.arsdigita.bebop.Container;
|
|
import com.arsdigita.bebop.FormData;
|
|
import com.arsdigita.bebop.FormSection;
|
|
import com.arsdigita.bebop.Label;
|
|
import com.arsdigita.bebop.event.FormSectionEvent;
|
|
import com.arsdigita.bebop.form.FileUpload;
|
|
import com.arsdigita.bebop.form.Option;
|
|
import com.arsdigita.bebop.form.OptionGroup;
|
|
import com.arsdigita.bebop.form.SingleSelect;
|
|
import com.arsdigita.globalization.GlobalizedMessage;
|
|
import com.arsdigita.dispatcher.MultipartHttpServletRequest;
|
|
import java.io.File;
|
|
import javax.activation.MimeType;
|
|
import javax.activation.MimeTypeParseException;
|
|
import javax.activation.MimetypesFileTypeMap;
|
|
import javax.servlet.ServletRequest;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import javax.servlet.http.HttpServletRequestWrapper;
|
|
import org.librecms.CmsConstants;
|
|
|
|
/**
|
|
* A form section with two widgets: a mime-type selection widget and a file
|
|
* upload widget. The section will attempt to automatically guess the mime type
|
|
* from the filename (if necessary), and return the mime type.
|
|
*
|
|
* @author Stanislav Freidin (sfreidin@arsdigita.com)
|
|
* @author <a href="jens.pelzetter@googlemail.com">Jens Pelzetter</a>
|
|
*/
|
|
public class FileUploadSection extends FormSection {
|
|
|
|
private SingleSelect mimeWidget;
|
|
private FileUpload fileWidget;
|
|
private String mimePrefix;
|
|
private String defaultMimeType;
|
|
private String parameterPrefix;
|
|
|
|
/**
|
|
* The mime type widget
|
|
*/
|
|
public static final String MIME_TYPE = "mime_type";
|
|
|
|
/**
|
|
* The file upload widget
|
|
*/
|
|
public static final String FILE_UPLOAD = "file_upload";
|
|
|
|
/**
|
|
* Automatically guess the mime type
|
|
*/
|
|
public static final String GUESS_MIME = "-guess-";
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param panel The panel that is to be used to lay out the components
|
|
*
|
|
*/
|
|
public FileUploadSection(final GlobalizedMessage mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final Container panel) {
|
|
this(mimeLabel, mimePrefix, defaultMimeType, "", panel);
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param panel The panel that is to be used to lay out the components
|
|
*
|
|
* @deprecated use the same constructor but with the GlobalizedMessage for
|
|
* the mimeLabel
|
|
*/
|
|
public FileUploadSection(final String mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final Container panel) {
|
|
// This takes advantage of the fact that the "key" is returned
|
|
// when it is not present in the message bundle
|
|
this(new GlobalizedMessage(mimeLabel),
|
|
mimePrefix,
|
|
defaultMimeType,
|
|
panel);
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param parameterPrefix Prepended to MIME_TYPE and FILE_UPLOAD for
|
|
* parameter names so that more than 1 file upload widgets may be used per
|
|
* form
|
|
*
|
|
* @param panel The panel that is to be used to lay out the components
|
|
*
|
|
* @deprecated use the same constructor but with the GlobalizedMessage for
|
|
* the mimeLabel
|
|
*/
|
|
public FileUploadSection(final String mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final String parameterPrefix,
|
|
final Container panel
|
|
) {
|
|
// This takes advantage of the fact that the "key" is returned
|
|
// when it is not present in the message bundle
|
|
this(new GlobalizedMessage(mimeLabel, CmsConstants.CMS_BUNDLE),
|
|
mimePrefix,
|
|
defaultMimeType,
|
|
parameterPrefix,
|
|
panel);
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param parameterPrefix Prepended to MIME_TYPE and FILE_UPLOAD for
|
|
* parameter names so that more than 1 file upload widgets may be used per
|
|
* form
|
|
*
|
|
* @param panel The panel that is to be used to lay out the components
|
|
*
|
|
*/
|
|
public FileUploadSection(final GlobalizedMessage mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final String parameterPrefix,
|
|
final Container panel) {
|
|
|
|
super(panel);
|
|
|
|
this.mimePrefix = mimePrefix;
|
|
this.defaultMimeType = defaultMimeType;
|
|
if (parameterPrefix == null) {
|
|
this.parameterPrefix = "";
|
|
} else {
|
|
this.parameterPrefix = parameterPrefix;
|
|
}
|
|
|
|
add(new Label(mimeLabel, false));
|
|
mimeWidget = new SingleSelect(getMimeTypeWidgetName());
|
|
addMimeOptions(mimeWidget, mimePrefix);
|
|
mimeWidget
|
|
.addOption(new Option(GUESS_MIME,
|
|
new Label(new GlobalizedMessage(
|
|
"cms.ui.authoring.file_upload.auto_detect",
|
|
CmsConstants.CMS_BUNDLE))));
|
|
|
|
mimeWidget.setDefaultValue(GUESS_MIME);
|
|
add(mimeWidget);
|
|
|
|
add(new Label(new GlobalizedMessage("cms.ui.upload_new_content",
|
|
CmsConstants.CMS_BUNDLE)));
|
|
fileWidget = new FileUpload(getFileUploadWidgetName());
|
|
add(fileWidget);
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param parameterPrefix Prepended to MIME_TYPE and FILE_UPLOAD for
|
|
* parameter names so that more than 1 file upload widgets may be used per
|
|
* form
|
|
*
|
|
*/
|
|
public FileUploadSection(final GlobalizedMessage mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final String parameterPrefix) {
|
|
this(mimeLabel,
|
|
mimePrefix,
|
|
defaultMimeType,
|
|
parameterPrefix,
|
|
new ColumnPanel(2, true));
|
|
final ColumnPanel panel = (ColumnPanel) getPanel();
|
|
panel.setBorder(false);
|
|
panel.setPadColor("#FFFFFF");
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @param parameterPrefix Prepended to MIME_TYPE and FILE_UPLOAD for
|
|
* parameter names so that more than 1 file upload widgets may be used per
|
|
* form
|
|
*
|
|
* @deprecated use the same constructor but with the GlobalizedMessage for
|
|
* the mimeLabel
|
|
*/
|
|
public FileUploadSection(final String mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType,
|
|
final String parameterPrefix) {
|
|
// This takes advantage of the fact that the "key" is returned
|
|
// when it is not present in the message bundle
|
|
this(new GlobalizedMessage(mimeLabel, CmsConstants.CMS_BUNDLE),
|
|
mimePrefix,
|
|
defaultMimeType,
|
|
parameterPrefix);
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The label for the mime type widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
* @deprecated use the same constructor but with the GlobalizedMessage for
|
|
* the mimeLabel
|
|
*/
|
|
public FileUploadSection(final String mimeLabel,
|
|
final String mimePrefix,
|
|
final String defaultMimeType) {
|
|
|
|
// This takes advantage of the fact that the "key" is returned
|
|
// when it is not present in the message bundle
|
|
this(new GlobalizedMessage(mimeLabel, CmsConstants.CMS_BUNDLE),
|
|
mimePrefix,
|
|
defaultMimeType,
|
|
"");
|
|
}
|
|
|
|
/**
|
|
* Construct a new FileUploadSection
|
|
*
|
|
* @param mimeLabel The GlobalizedMessage for the label for the mime type
|
|
* widget
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
* @param defaultMimeType The default mime type that should be assumed if
|
|
* the guessing fails
|
|
*
|
|
*/
|
|
public FileUploadSection(GlobalizedMessage mimeLabel,
|
|
String mimePrefix,
|
|
String defaultMimeType) {
|
|
this(mimeLabel, mimePrefix, defaultMimeType, "");
|
|
}
|
|
|
|
/**
|
|
* Try to guess the mime type from the filename, and return it. The parent
|
|
* form should call this method in its process listener. Note that this
|
|
* method may return null if the mime type could not be guessed.
|
|
*
|
|
* @param event The form section event
|
|
* @return The mime type of the file.
|
|
*/
|
|
public MimeType getMimeType(final FormSectionEvent event) {
|
|
|
|
final FormData data = event.getFormData();
|
|
|
|
final String fileName = (String) data.get(getFileUploadWidgetName());
|
|
final String mimeTypeName = (String) data.get(getMimeTypeWidgetName());
|
|
|
|
// Guess the mime type from the filename
|
|
MimeType mimeType = null;
|
|
if (fileName != null) {
|
|
try {
|
|
if (GUESS_MIME.equals(mimeTypeName)) {
|
|
// Guess the mime type from the file extension
|
|
mimeType = new MimeType(MimetypesFileTypeMap
|
|
.getDefaultFileTypeMap()
|
|
.getContentType(fileName));
|
|
} else {
|
|
mimeType = new MimeType(mimeTypeName);
|
|
}
|
|
} catch (MimeTypeParseException ex) {
|
|
mimeType = null;
|
|
}
|
|
}
|
|
|
|
// Failed to guess it, failed to load it, fall back on the default
|
|
if (mimeType == null) {
|
|
try {
|
|
mimeType = new MimeType(defaultMimeType);
|
|
} catch (MimeTypeParseException ex) {
|
|
mimeType = null;
|
|
}
|
|
}
|
|
|
|
return mimeType;
|
|
}
|
|
|
|
/**
|
|
* Obtain a File object from the file upload widget. The containing form
|
|
* should call this method in its process listener.
|
|
*
|
|
* @param event The form section event
|
|
* @return
|
|
*/
|
|
public File getFile(final FormSectionEvent event) {
|
|
|
|
final String fileName = getFileName(event);
|
|
|
|
if (fileName != null && fileName.length() > 0) {
|
|
return ((MultipartHttpServletRequest) unwrapRequest(event
|
|
.getPageState()
|
|
.getRequest()))
|
|
.getFile(getFileUploadWidgetName());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private ServletRequest unwrapRequest(final HttpServletRequest request) {
|
|
|
|
ServletRequest current = request;
|
|
while (current instanceof HttpServletRequestWrapper) {
|
|
current = ((HttpServletRequestWrapper) current).getRequest();
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
/**
|
|
* Obtain a filename from the file upload widget. The containing form should
|
|
* call this method in its process listener.
|
|
*
|
|
* @param event The form section event
|
|
* @return
|
|
*/
|
|
public String getFileName(final FormSectionEvent event) {
|
|
|
|
return event
|
|
.getFormData()
|
|
.getString(getFileUploadWidgetName());
|
|
}
|
|
|
|
/**
|
|
* Set the value for the mime type widget. The containing form should call
|
|
* this method in its init listener
|
|
*
|
|
* @param event The form section event
|
|
* @param mimeType The mime type to set, such as "text/html" or "img/jpeg"
|
|
*
|
|
*/
|
|
public void setMimeType(final FormSectionEvent event,
|
|
final String mimeType) {
|
|
event
|
|
.getFormData()
|
|
.put(getMimeTypeWidgetName(), mimeType);
|
|
}
|
|
|
|
/**
|
|
* @return the mime type widget
|
|
*/
|
|
public SingleSelect getMimeTypeWidget() {
|
|
return mimeWidget;
|
|
}
|
|
|
|
/**
|
|
* @return the file upload widget
|
|
*/
|
|
public FileUpload getFileUploadWidget() {
|
|
return fileWidget;
|
|
}
|
|
|
|
/**
|
|
* @return the parameter name prefix
|
|
*/
|
|
public String getParameterPrefix() {
|
|
return parameterPrefix;
|
|
}
|
|
|
|
/**
|
|
* @return the file upload parameter name
|
|
*/
|
|
public String getFileUploadWidgetName() {
|
|
return parameterPrefix + FILE_UPLOAD;
|
|
}
|
|
|
|
/**
|
|
* @return the mime typeparameter name
|
|
*/
|
|
public String getMimeTypeWidgetName() {
|
|
return parameterPrefix + MIME_TYPE;
|
|
}
|
|
|
|
/**
|
|
* Add mime-type options to the option group by loading all mime types which
|
|
* match a certain prefix from the database
|
|
*
|
|
* @param mimeTypeOptions The mime type widget to which options should be
|
|
* added
|
|
*
|
|
* @param mimePrefix Populate the mime type widget with all mime types that
|
|
* match the prefix. Some of the possible prefixes are "text", "image",
|
|
* "binary", etc.
|
|
*
|
|
*/
|
|
public static void addMimeOptions(final OptionGroup mimeTypeOptions,
|
|
final String mimePrefix) {
|
|
|
|
// MimeTypeCollection types;
|
|
// if (mimePrefix == null || mimePrefix.equals("")) {
|
|
// types = MimeType.getAllMimeTypes();
|
|
// } else {
|
|
// types = MimeType.searchMimeTypes(mimePrefix + "/");
|
|
// }
|
|
// while (types.next()) {
|
|
// MimeType type = types.getMimeType();
|
|
// mimeTypeOptions.addOption(new Option(type.getMimeType(), type.getLabel()));
|
|
// }
|
|
}
|
|
|
|
}
|