import org.codehaus.jackson.map.ObjectMapper;
 
public class HttpUtils {
 
        private static final int SERVER_PORT = 80;
        private static final String SERVER_IP = "myapp.appspot.com"; // use 10.0.2.2 for emulator
 
        private static HttpUtils instance = new HttpUtils();
        private DefaultHttpClient client;
        private ResponseHandler<String> responseHandler;
        private ObjectMapper mapper;
 
        private HttpUtils() {
                super();
                client = new DefaultHttpClient();
                HttpConnectionParams.setConnectionTimeout(client.getParams(), 30000);
                responseHandler = new BasicResponseHandler();
                mapper = new ObjectMapper(); // can reuse, share globally
        }
 
        public static HttpUtils getInstance() {
                return instance;
        }
 
        public String doGet(String path) throws IOException {
                return doGet(path, null);
        }
 
        public String doGet(String path, String query) throws IOException {
                try {
                        URI uri;
                        uri = createURI(path, query);
                        HttpGet get = new HttpGet(uri);
                        HttpResponse response = client.execute(get);
                        int statusCode = response.getStatusLine().getStatusCode();
                        if (statusCode == HttpStatus.SC_OK) {
                                return responseHandler.handleResponse(response);
                        } else {
                                throw new IOException("wrong http status: " + statusCode);
                        }
                } catch (URISyntaxException e) {
                        throw new IOException("uri syntax error");
                } catch (ClientProtocolException e) {
                        throw new IOException("protocol error");
                } 
 
        }
 
        private URI createURI(String path, String query) throws URISyntaxException {
                return URIUtils.createURI("http", SERVER_IP, SERVER_PORT, "rest/" + path, query, null);
        }
 
        public boolean doPut(String path, Object object) throws IOException {
                try {
                        String json = mapper.writeValueAsString(object);
                        URI uri = createURI(path, null);
                        HttpPut put = new HttpPut(uri);
                        put.addHeader("Accept", "application/json");
                        put.addHeader("Content-Type", "application/json");
                        StringEntity entity = new StringEntity(json, "UTF-8");
                        entity.setContentType("application/json");
                        put.setEntity(entity);
                        HttpResponse response = client.execute(put);
                        int statusCode = response.getStatusLine().getStatusCode();
                        return statusCode == HttpStatus.SC_OK;
                } catch (URISyntaxException e) {
                        throw new IOException("uri syntax error");
                } catch (ClientProtocolException e) {
                        throw new IOException("protocol error");
                }
        }
 
        public String doPutFile(final String path, final File file) throws URISyntaxException, HttpException,
                        IOException {
                URI uri = createURI(path, null);
                HttpPut put = new HttpPut(uri);
                String mimeType = "binary/octet-stream";
                if(file.getName().matches(".*\\.(jpeg|jpg)"))
                        mimeType = "image/jpeg";
                FileEntity reqEntity = new FileEntity(file, mimeType);
                put.setEntity(reqEntity);
                HttpResponse response = client.execute(put);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode == HttpStatus.SC_OK) {
                        return responseHandler.handleResponse(response);
                } else {
                        throw new IOException("wrong http status: " + statusCode);
                }
        }
 
        public String doPost(final String path, final String POSTText) throws URISyntaxException, HttpException,
                        IOException {
                URI uri = createURI(path, null);
                HttpPost httpPost = new HttpPost(uri);
                StringEntity entity = new StringEntity(POSTText, "UTF-8");
                BasicHeader basicHeader = new BasicHeader(HTTP.CONTENT_TYPE, "application/json");
                httpPost.getParams().setBooleanParameter("http.protocol.expect-continue", false);
                entity.setContentType(basicHeader);
                httpPost.setEntity(entity);
                HttpResponse response = client.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode == HttpStatus.SC_OK) {
                        return responseHandler.handleResponse(response);
                } else {
                        throw new IOException("wrong http status: " + statusCode);
                }
        }
 
        public boolean doDelete(final String path) throws HttpException, IOException, URISyntaxException {
                URI uri = createURI(path, null);
                HttpDelete httpDelete = new HttpDelete(uri);
                httpDelete.addHeader("Accept", "text/html, image/jpeg, *; q=.2, */*; q=.2");
                HttpResponse response = client.execute(httpDelete);
                int statusCode = response.getStatusLine().getStatusCode();
                return statusCode == HttpStatus.SC_OK ? true : false;
        }
 
}

File imageFile = new File(new URI(myimgage.getImageURL()));
String url = HttpUtils.getInstance().doPutFile("file/store", imageFile);

public class FileTransformer {
 
	public static final Logger log = Logger.getLogger(FileTransformer.class.getName());
 
	private static final int JPEG_QUALITY = 90;
	private static final int MAX_FILE_SIZE = 1024*1024;
 
	public byte[] transform(byte[] ba, String mediaType) {
		if(mediaType.equalsIgnoreCase("image/jpeg")
				|| mediaType.equalsIgnoreCase("image/jpg")) {
			return imageTransform(ba);
		}
		throw new IllegalArgumentException("Unsupported media type: " + mediaType + " for this transformer");
	}
 
	private byte[] imageTransform(final byte[] ba) {
		byte[] result = ba;
		while(result.length>MAX_FILE_SIZE) {
			final Image origImage = ImagesServiceFactory.makeImage(result);
			final Image newImage = shrinkImage(origImage, 0.9f);
			result = newImage.getImageData();
		}
		return result;
	}
 
	private Image shrinkImage(final Image origImage, final float percent) {
		final ImagesService imagesService = ImagesServiceFactory.getImagesService();
		log.fine("orig dimensions is " + origImage.getWidth() + " X " + origImage.getHeight());
		final OutputSettings settings = new OutputSettings(OutputEncoding.JPEG);
		settings.setQuality(JPEG_QUALITY);
 
		final Transform resize = ImagesServiceFactory.makeResize(Math.round(origImage.getWidth()*percent), Math.round(origImage.getHeight()*percent));
		final Image newImage = imagesService.applyTransform(resize, origImage, settings);
		return newImage;
	}
 
}

if (ba.length > 1024 * 1024) {
    ba = new FileTransformer().transform(ba, mediaType);
}

@Entity
public class FileEntity {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long key;
 
	private Blob content;
	private String mediaType;
 
	public Long getKey() {
		return key;
	}
 
	public Blob getContent() {
		return content;
	}
 
	public void setContent(Blob content) {
		this.content = content;
	}
 
	public String getMediaType() {
		return mediaType;
	}
 
	public void setMediaType(String mediaType) {
		this.mediaType = mediaType;
	}	
}

@Path("/file")
public class FileServerResource {
 
	public static final Logger log = Logger.getLogger(FileServerResource.class.getName());
 
	@Context
	UriInfo uriInfo;
	@Context
	HttpHeaders headers;
	@Context
	HttpServletResponse response;
 
	@PUT
	@Path("/store")
	@Consumes({ MediaType.TEXT_PLAIN, "image/jpeg", "image/png", "image/gif", "application/zip" })
	@Produces({ MediaType.TEXT_PLAIN })
	public String storeFile(final byte[] b) {
		FileEntity file = EMF.doTransaction(new EMF.Closure<FileEntity>() {
			public FileEntity doit(EntityManager em) {
				byte[] ba = b;
				String mediaType = headers.getMediaType().toString();
				FileEntity file = new FileEntity();
				file.setContent(new Blob(ba));
				file.setMediaType(mediaType);
				em.persist(file);
				return file;
			}
		});
		UriBuilder ub = uriInfo.getBaseUriBuilder();
		URI link = ub.path("/file/get/" + file.getKey().toString()).build();
		return link.toString();
	}
 
	@GET
	@Path("/get/{id}")
	@Produces("*/*")
	public Response getFile(@PathParam("id") final long id) {
		return EMF.doTransaction(new EMF.Closure<Response>() {
			public Response doit(EntityManager em) {
				FileEntity entity = em.find(FileEntity.class, id);
				if (entity == null)
					throw new WebApplicationException(404);
				return Response.ok(entity.getContent().getBytes(), entity.getMediaType()).build();
			}
		});
	}
}

<init-param>
	<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
	<param-value>true</param-value>
</init-param>

public class StatefulTableColumnModel extends DefaultTableColumnModel {
 
    public enum Mode {
        STANDARD, USERDEFINED;
    }
 
    private int columnMap[];
    private Mode mode = Mode.STANDARD; 
 
    public StatefulTableColumnModel(Mode mode, int[] columnMap) {
        this.columnMap = columnMap;
        if(mode!=null) 
            setMode(mode);
        else
            setMode(Mode.STANDARD);
    }
 
    public void setMode(Mode mode) {
        this.mode = mode;
        refresh();
    }
 
    public Mode getMode() {
        return this.mode;
    }
 
    public int[] getColumnMap() {
        return columnMap;
    }
 
    /* (non-Javadoc)
     * @see javax.swing.table.DefaultTableColumnModel#fireColumnMoved(javax.swing.event.TableColumnModelEvent)
     */
    @Override
    protected void fireColumnMoved(TableColumnModelEvent e) {
        switch(mode) {
        case USERDEFINED:
            // if columns have been moved there might have been Drag'n'Drop operations,
            // so update the state 
            columnMap = getColumnPositions();
            break;
        case STANDARD:
            // in standard mode drag'n'drop operations are not permitted, so reset the order
            resetColumnPositions();
            break;
        }
        super.fireColumnMoved(e);
    }
 
    /**
     * re-order table columns depending on their model index (this resets the original order), don't update view
     */
    private void resetColumnPositions() {
        Collections.sort(tableColumns, new Comparator<TableColumn>() {
            public int compare(TableColumn o1, TableColumn o2) {
                return new Integer(o1.getModelIndex()).compareTo(o2.getModelIndex());
            }
        });
    }
 
    /**
     * set the visible column positions (independent of state), don't update view
     */
    private void setColumnPositions(final int columnMap[]) {
        resetColumnPositions();
        if(columnMap!=null) {
            Vector<TableColumn> newOrder = new Vector<TableColumn>(tableColumns.capacity());
            newOrder.setSize(tableColumns.size());
            int i=0;
            for(TableColumn column: tableColumns) {
                // lookup new position in newOrder
                int newPos = columnMap[i++];
                newOrder.set(newPos, column);
            }
            tableColumns = newOrder;
        }
    }
 
    /**
     * @return the visible column positions (independent of state)
     */
    private int[] getColumnPositions() {
        int result[] = new int[tableColumns.size()];
        int i=0;
        for(TableColumn column: tableColumns) {
            int modelIndex = column.getModelIndex();
            result[modelIndex] = i++;
        }
        return result;
    }
 
    /**
     * 
     */
    public void refresh() {
        switch(mode) {
        case STANDARD:
            // reset position
            resetColumnPositions();
            break;
        case USERDEFINED:
            setColumnPositions(columnMap);
            break;
        }        
        // inform view that column order has changed (seems to be sufficient to just tell 0 has moved to 1)
        super.fireColumnMoved(new TableColumnModelEvent(this, 0, 1));        
    }
 
}

function isInView(node){
            var offsetParent = node.offsetParent;
            var top = offsetParent.scrollTop;
            var height = offsetParent.offsetHeight;
            var y = node.offsetTop;
            return y >= top && y <= (top + height);
}

if(!isInView(element)) {
            element.scrollIntoView();
}

ms.ItemSelector.selectItem(['Bart', 'Lisa', 'Homer', 'Marge', 'Maggie', 'Ned', 'Barney', 'Bob'], function(item){
  alert(item + ' is your favorite character.');
});