Java tutorial
/******************************************************************************* * Copyright (c) 2004, 2007 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package com.aptana.ide.core.ui; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.util.Geometry; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IWorkbenchPreferenceConstants; import org.eclipse.ui.internal.WorkbenchMessages; import org.eclipse.ui.internal.util.PrefUtil; /** * This job creates an animated rectangle that moves from a source rectangle to * a target in a fixed amount of time. To begin the animation, instantiate this * object then call schedule(). * * Previous org.eclipse.ui.internal.RectangleAnimation; removed in Eclipse 3.5. * * @since 3.0 */ public class RectangleAnimation extends Job { private static class AnimationFeedbackFactory { /** * Determines whether or not the system being used is * sufficiently fast to support image animations. * * Assumes that a pixel is ~3 bytes * * For now we use a base limitation of 50MB/sec as a * 'reverse blt' rate so that a 2MB size shell can be * captured in under 1/25th of a sec. */ private static final int IMAGE_ANIMATION_THRESHOLD = 25; // Frame captures / Sec private static final int IMAGE_ANIMATION_TEST_LOOP_COUNT = 20; // test the copy 'n' times //private static double framesPerSec = 0.0; public static double getCaptureSpeed(Shell wb) { // OK, capture Rectangle bb = wb.getBounds(); Image backingStore = new Image(wb.getDisplay(), bb); GC gc = new GC(wb); // Loop 'n' times to average the result long startTime = System.currentTimeMillis(); for (int i = 0; i < IMAGE_ANIMATION_TEST_LOOP_COUNT; i++) gc.copyArea(backingStore, bb.x, bb.y); gc.dispose(); long endTime = System.currentTimeMillis(); // get Frames / Sec double fps = IMAGE_ANIMATION_TEST_LOOP_COUNT / ((endTime - startTime) / 1000.0); double pps = fps * (bb.width * bb.height * 4); // 4 bytes/pixel System.out.println("FPS: " + fps + " Bytes/sec: " + (long) pps); //$NON-NLS-1$ //$NON-NLS-2$ return fps; } public boolean useImageAnimations(Shell wb) { return getCaptureSpeed(wb) >= IMAGE_ANIMATION_THRESHOLD; } public static DefaultAnimationFeedback createAnimationRenderer(Shell parentShell) { // on the first call test the animation threshold to determine // whether to use image animations or not... // if (framesPerSec == 0.0) // framesPerSec = getCaptureSpeed(parentShell); // // IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore(); // boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX); // // if (useNewMinMax && framesPerSec >= IMAGE_ANIMATION_THRESHOLD) { // return new ImageAnimationFeedback(); // } // return new DefaultAnimationFeedback(); } } // Constants public static final int TICK_TIMER = 1; public static final int FRAME_COUNT = 2; // Animation Parameters private Display display; private boolean enableAnimations; private int timingStyle = TICK_TIMER; private int duration; // Control State private DefaultAnimationFeedback feedbackRenderer; private long stepCount; private long frameCount; private long startTime; private long curTime; private long prevTime; // Macros private boolean done() { return amount() >= 1.0; } public static Rectangle interpolate(Rectangle start, Rectangle end, double amount) { double initialWeight = 1.0 - amount; Rectangle result = new Rectangle((int) (start.x * initialWeight + end.x * amount), (int) (start.y * initialWeight + end.y * amount), (int) (start.width * initialWeight + end.width * amount), (int) (start.height * initialWeight + end.height * amount)); return result; } // Animation Step private Runnable animationStep = new Runnable() { public void run() { // Capture time prevTime = curTime; curTime = System.currentTimeMillis(); // Has the system timer 'ticked'? if (curTime != prevTime) { clockTick(); } if (isUpdateStep()) { updateDisplay(); frameCount++; } stepCount++; } }; /** * Creates an animation that will morph the start rectangle to the end rectangle in the * given number of milliseconds. The animation will take the given number of milliseconds to * complete. * * Note that this is a Job, so you must invoke schedule() before the animation will begin * * @param whereToDraw specifies the composite where the animation will be drawn. Note that * although the start and end rectangles can accept any value in display coordinates, the * actual animation will be clipped to the boundaries of this composite. For this reason, * it is good to select a composite that encloses both the start and end rectangles. * @param start initial rectangle (display coordinates) * @param end final rectangle (display coordinates) * @param duration number of milliseconds over which the animation will run */ public RectangleAnimation(Shell parentShell, Rectangle start, Rectangle end, int duration) { super(WorkbenchMessages.RectangleAnimation_Animating_Rectangle); // if animations aren't on this is a NO-OP IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore(); enableAnimations = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS); if (!enableAnimations) { return; } // Capture paraeters display = parentShell.getDisplay(); this.duration = duration; // Don't show the job in monitors setSystem(true); // Pick the renderer (could be a preference...) feedbackRenderer = AnimationFeedbackFactory.createAnimationRenderer(parentShell); // Set it up feedbackRenderer.initialize(parentShell, start, end); // Set the animation's initial state stepCount = 0; //long totalFrames = (long) ((duration / 1000.0) * framesPerSec); curTime = startTime = System.currentTimeMillis(); } public RectangleAnimation(Shell parentShell, Rectangle start, Rectangle end) { this(parentShell, start, end, 400); } public void addStartRect(Rectangle rect) { if (feedbackRenderer != null) feedbackRenderer.addStartRect(rect); } public void addEndRect(Rectangle rect) { if (feedbackRenderer != null) feedbackRenderer.addEndRect(rect); } public void addStartRect(Control ctrl) { Rectangle ctrlBounds = ctrl.getBounds(); Rectangle startRect = Geometry.toDisplay(ctrl.getParent(), ctrlBounds); addStartRect(startRect); } public void addEndRect(Control ctrl) { Rectangle ctrlBounds = ctrl.getBounds(); Rectangle endRect = Geometry.toDisplay(ctrl.getParent(), ctrlBounds); addEndRect(endRect); } /** * */ protected void clockTick() { } /** * @return */ protected boolean isUpdateStep() { switch (timingStyle) { case TICK_TIMER: return prevTime != curTime; case FRAME_COUNT: return true; } return false; } private double amount() { double amount = 0.0; switch (timingStyle) { case TICK_TIMER: amount = (double) (curTime - startTime) / (double) duration; break; case FRAME_COUNT: amount = (double) frameCount / (double) duration; } if (amount > 1.0) amount = 1.0; return amount; } /** * */ protected void updateDisplay() { feedbackRenderer.renderStep(amount()); } /* (non-Javadoc) * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor) */ protected IStatus run(IProgressMonitor monitor) { // We use preference value to indicate that the animation should be skipped on this platform. if (!enableAnimations || feedbackRenderer == null) { return Status.OK_STATUS; } // Do we have anything to animate ? boolean isEmpty = feedbackRenderer.getStartRects().size() == 0; if (isEmpty) { return Status.OK_STATUS; } // We're starting, initialize display.syncExec(new Runnable() { public void run() { feedbackRenderer.jobInit(); } }); // Only start the animation timer -after- we've initialized curTime = startTime = System.currentTimeMillis(); while (!done()) { display.syncExec(animationStep); // Don't pin the CPU Thread.yield(); } //System.out.println("Done: " + (curTime-startTime) + " steps: " + stepCount + " frames:" + frameCount); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$ // We're done, clean up display.syncExec(new Runnable() { public void run() { feedbackRenderer.dispose(); } }); return Status.OK_STATUS; } }