To start with this implementation is not tested in production therefore I do not take any blame whatsoever. Also I do not claim that this is a good solution I wrote this while playing with spring approximately for two hours. Apart from the progress bar it would be nice to implement resume functionality if the upload fails. Again I am not sure if this is a good practice, maybe it should be left to the protocols dedicated for doing it.

So to get the thing running we need to modify the default implementation, store the upload progress in session, write some JavaScript code to query the progress and implement a filter that would return the upload progress if a specific URL is requested.

Let’s start with modifying the default implementation of multipart resolver. In this case we only need to override a single method to attach the progress listener. To be more precise I am talking about the parseRequest method.

package com.wordpress.geekdev101.fileupload;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import org.springframework.web.multipart.MaxUploadSizeExceededException;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

public class ProgressCapableMultipartResolver
	extends CommonsMultipartResolver 
{
	public final static String PROGRESS_PREFIX = "ProgressCapableMultipartResolver:";

	private void initProgressProcessor(HttpServletRequest request) {
		request.getSession().setAttribute(
				PROGRESS_PREFIX + request.getRequestURI(), 
				new ProgressDescriptor());
	}
	
	private void clearProgressProcessor(HttpServletRequest request) { 
		request.getSession().removeAttribute(PROGRESS_PREFIX 
				+ request.getRequestURI());
	}
	
	private void processProgress(long bytesRead, long bytesTotal, 
			HttpServletRequest request) {
		
		request.getSession().setAttribute(
				PROGRESS_PREFIX + request.getRequestURI(), 
				new ProgressDescriptor(bytesRead, bytesTotal));
	}
	
	protected MultipartParsingResult parseRequest(
			final HttpServletRequest request) 
		throws MultipartException 
	{
		String encoding = determineEncoding(request);
		ServletFileUpload fileUpload = (ServletFileUpload)prepareFileUpload(encoding);

		initProgressProcessor(request); 
		fileUpload.setProgressListener(new ProgressListener() {
			@Override
			public void update(
					long pBytesRead, long pContentLength, int pItems) {
				processProgress(pBytesRead, pContentLength, request);
			}
		});
		
		MultipartParsingResult result = null; 
		try {
			result = parseFileItems( 
						fileUpload.parseRequest(request), 
						encoding);
			
		} catch (FileUploadBase.SizeLimitExceededException ex) {
			throw new MaxUploadSizeExceededException(
					fileUpload.getSizeMax(), ex);
			
		} catch (FileUploadException ex) {
			throw new MultipartException("Could not parse " +
					"multipart servlet request", ex);
		}
		
		clearProgressProcessor(request); 
		return result; 
	}
}

package com.wordpress.geekdev101.fileupload;

public class ProgressDescriptor 
{
	public long bytesRead; 
	public long bytesTotal;
	
	public ProgressDescriptor() {
		bytesRead = bytesTotal = 0; 
	}
	
	public ProgressDescriptor(long bytesRead,
			long bytesTotal) 
	{ 
		this.bytesRead = bytesRead; 
		this.bytesTotal = bytesTotal; 
	}
	
	public long getBytesRead() { 
		return bytesRead; 
	}
	
	public long getBytesTotal() { 
		return bytesTotal;
	}
	
	@Override
	public String toString() {
		return bytesRead + "/" + bytesTotal; 
	}
}

Let say the request for progress will always be a URI with “.progress” appended to the request which makes it easy to define our filter in web.xml i.e. by specifying the filter mapping as “*.progress”. Once the filter gets the request we modify the URI to the original state i.e. without the progress tail and look it up in the session.

package com.wordpress.geekdev101.fileupload;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.filter.OncePerRequestFilter;

public class UploadProgressFilter 
	extends OncePerRequestFilter
{
	private final String PROGRESS_TAIL = ".progress"; 
	
	protected void doFilterInternal(HttpServletRequest request,
			HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		String requestUri = request.getRequestURI();
		
		String originalUrl = requestUri.substring(0, 
				requestUri.length() - PROGRESS_TAIL.length());
		
		String attributeName = ProgressCapableMultipartResolver.PROGRESS_PREFIX 
			+ originalUrl;
		
		Object progress = request.getSession().getAttribute(attributeName);
		if (progress != null) {
			ProgressDescriptor descriptor = (ProgressDescriptor)progress; 
			response.getOutputStream().write( 
					descriptor.toString().getBytes() );
		}
	}
}

To avoid writing a lot of JavaScript I am reusing the existing components available on-line. In this case jQuery and jQuery Forms making my code  very simple. Before submit we start polling the server for information. Note there are two options how the progress can be queried either polling or http binding. It is probably better to use binding in this case, but you could argue. For example, assuming that there always be a progress in a second interval. I am using polling because it is easier to implement and is this is just a silly example.

var time;        
var elem = $('#progress'); 
var form = $('form').ajaxForm({ 
	beforeSubmit: function() {
		var url = form[0].action;

		var pos = url.indexOf(";"); 
		if (pos != -1) url = url.substring(0, pos); 
		
		time = setInterval(function() {
			 $.get(url + ".progress", function(data) {
				 if (!data) return;
				 data = data.split("/");
				 
				 elem.width( Math.round(data[0] / data[1] * 100) * 2 ); 
			 }); 
		}, 500); 
	}, 
	success: function() {
		clearInterval(time);  
		elem.width(100 * 2); 
	}
});

Anyhow I would much better prefer some sort implementation as below:

BEGIN_VIEW_MAP()
VIEW_ENTRY(1, CMultiviewSDIView )
VIEW_ENTRY(2, CHTMLView )
END_VIEW_MAP()
DEFINE_DEFAULT_VIEW(1);

In order to achieve the implementation it is assumed that each view would implement a common interface with two methods which are HWND Init(HWND hContainer) and PreTranslateMessage (just in case).

Using the approach each view can be implemented in its own class and avoids putting code inside MainFrame implementation. See a stub code for a view implementation:

class CMultiviewSDIView :
   public CWindowImpl<CMultiviewSDIView, CRichEditCtrl>,
   public IManagerViewClient
{
   /* implementation here */ 
}

The MainFrame class would extend CViewManager and call InitViewManager(HWND hContainer) on create event. The container is assumed to be the client area of the document handle. To change a view simply call ChangeView(UINT nID) method also provided by the view manager implementation. The nID is the ID specified inside the view map (defined at the start of this post). That’s it…

Here is the complete implementation of the view manager and the client interface:

#pragma once 
#include "stdafx.h"

#include <atlcoll.h>

interface IManagerViewClient
{
 public:
    virtual HWND Init(HWND hContainer) = 0; 
    virtual BOOL PreTranslateMessage(MSG* pMsg) = 0; 
};

struct _ViewMgrEntry {
   UINT nID;
   IManagerViewClient* _client;
};

struct _ViewMgrData { 
   HWND hClient; 
   const _ViewMgrEntry *_e;
};

#define BEGIN_VIEW_MAP() \
   static const _ViewMgrEntry* GetViewMap() \
   { \
      static const _ViewMgrEntry theMap[] = \
      {

#define VIEW_ENTRY(uid, cl) \
    { uid, new cl },

#define END_VIEW_MAP() \
       { (WORD) - 1, NULL },  \
   }; \

  return theMap; \
};

#define DEFINE_DEFAULT_VIEW(uid) \
static const UINT GetDefaultView() \
{ \
   return uid; \
}; \

template <class T>
class CViewManager {
private:
    _ViewMgrData m_pCurView; 
    ATL::CAtlMap<UINT, _ViewMgrData> m_viewMap; 

public: 
    IManagerViewClient* GetCurrentView() { 
    ATLASSERT(m_pCurView._e != NULL); 
    return m_pCurView._e->_client;
}

void ChangeView(UINT nView) 
{
   ATLASSERT(m_pCurView._e != NULL); 
   ATLASSERT(m_pCurView._e->nID != nView); 
 
   POSITION pos = m_viewMap.GetStartPosition(); 
   while (pos != NULL) {
      UINT nID = m_viewMap.GetKeyAt(pos);
      _ViewMgrData pDat = m_viewMap.GetNextValue(pos); 

      if (nID != nView)  {
        ::ShowWindow(pDat.hClient, SW_HIDE); 
      } else { 
        ::ShowWindow(pDat.hClient, SW_SHOW); 
         T* p = static_cast<T*>(this); 
         p->m_hWndClient = pDat.hClient; 
        m_pCurView = pDat; 
        p->UpdateLayout(); 
     }
  }
}

void InitViewManager(HWND hContainer) {
   T* p = static_cast<T*>(this); 
   const _ViewMgrEntry* theMap = p->GetViewMap(); 

   int nCount; 
   for (nCount = 0; theMap->nID != (WORD)-1; nCount++) {
      HWND _c = theMap->_client->Init(hContainer); 
      const _ViewMgrData pDat = { _c, theMap }; 
      
      if (theMap->nID == p->GetDefaultView()) 
      {
         m_pCurView = pDat;
         p->m_hWndClient = _c; 
      }
   
      m_viewMap.SetAt(theMap->nID, pDat); 
      theMap++; 
    } 
  }
};

P.S. I am not saying that this is a good solution or bad one, it is just an idea.