Changeset 169

Timestamp:

07/28/08 16:52:25 (16 years ago)

Author:

bjn8

Message:

Improvements for widgets and popups

Location:

trunk/src/org/expeditee/items

Files:

• HeavyDutyInteractiveWidget.java (modified) (17 diffs)
• InteractiveWidget.java (modified) (21 diffs)
• Item.java (modified) (1 diff)
• ItemParentStateChangedEvent.java (modified) (2 diffs)
• WidgetCacheManager.java (added)
• WidgetCorner.java (modified) (2 diffs)
• WidgetEdge.java (modified) (1 diff)

trunk/src/org/expeditee/items/HeavyDutyInteractiveWidget.java

@@ -7 +7 @@
 import java.awt.Rectangle;
 import java.awt.geom.Rectangle2D;
+import java.util.LinkedList;
 
 import javax.swing.JComponent;
 import javax.swing.SwingUtilities;
 
+import org.expeditee.gui.DisplayIO;
 import org.expeditee.gui.FrameGraphics;
+import org.expeditee.gui.FreeItems;
 import org.expeditee.taskmanagement.EntityLoadManager;
 import org.expeditee.taskmanagement.EntitySaveManager;
@@ -34 +37 @@
  * if the widget still belongs to a frame (i.e. is not removed) and is anchored.
  * 
+ * Heavey duty widgets can also have an expiry on how long they should stay cached for. If they do have an 
+ * expiry then it they unload once expired, and will re-load once in view again. Must take care for
+ * unloadable widgets because you must check your unloadable elements to whether they are unloaded or not
+ * every time your widget accessess them.
+ * 
  * @author Brook Novak
  *
@@ -42 +50 @@
         public static final float LOAD_STATE_COMPLETED = 2.0f; 
         
-        /** waiting to load */
+        /** waiting to load. Could have been loaded previously but expired. */
         public static final float LOAD_STATE_PENDING = 3.0f;
         
@@ -51 +59 @@
         public static final float LOAD_STATE_INCOMPLETED = 5.0f; 
         
+        // GUI Stuff
         private static final String DEFAULT_LOAD_MESSAGE = "Loading";
         private static final String PENDING_MESSAGE = "Pending";
         
-        private static final Color LOAD_SCREEN_COLOR = new Color(150,150,250);
-        private static final Color LOAD_SCREEN_COLOR_FREESPACE = new Color(50,50,180, 128);
+        private static final Color LOAD_SCREEN_COLOR = Color.LIGHT_GRAY;
+        private static final Color LOAD_SCREEN_COLOR_FREESPACE = FREESPACE_BACKCOLOR;
         
         private static final Font LOAD_NORMAL_FONT = new Font("Arial", Font.BOLD, 12);
@@ -62 +71 @@
         private static final int BAR_HOROZONTIAL_MARGIN = 20;
         private static final int BAR_HEIGHT = 40;
-
-        private float loadState = LOAD_STATE_PENDING;
+        
+        /** Unifies state transitions to a single thread. */
+        private LoadStateManager stateProccessor = null;
+        private LinkedList<HDWTask> queuedTasks = new LinkedList<HDWTask>();
+        
+        // Model data
+        private float loadState; // handled by constructors and stateProccessor
         private String screenMessage = DEFAULT_LOAD_MESSAGE;
         private boolean hasCancelledBeenRequested;
+        private boolean isExpired = false;
+        private int cacheDepth = -1;
 
         /**
          * Constructor.
+         * 
+         * @param source
+         * 
+         * @param component
+         * 
+         * @param minWidth
+         * 
+         * @param maxWidth
+         * 
+         * @param minHeight
+         * 
+         * @param maxHeight
+         * 
+         * @param cacheDepth
+         *              Less or equal to zero for no cache management - i.e. use expeditees frame caching.
+         *              Positive to limit cache; where the widget will be explicity unloaded
+         *              ({@link HeavyDutyInteractiveWidget#unloadWidgetData()}) once the user has traversed
+         *              cacheDepth frames without seeing this instance.
+         *              The general rule is: the more memory your widget may take, the smaller the cache depth.
+         * 
+         * @param skipLoad
+         *              If true, the load state will be set to completed and the widget will not go through 
+         *              the loading proccess. Otherwise if true then the widget will go the loading phase.
+         */
+        protected HeavyDutyInteractiveWidget(Text source, JComponent component,
+                        int minWidth, int maxWidth, int minHeight, int maxHeight, int cacheDepth, boolean skipLoad) {
+                super(source, component, minWidth, maxWidth, minHeight, maxHeight);
+                
+                this.cacheDepth = cacheDepth;
+                
+                if (skipLoad) {
+                        loadState = LOAD_STATE_COMPLETED;
+                } else {
+                        loadState = LOAD_STATE_PENDING;
+                        component.setVisible(false); // not allowed to interact with it yet
+                        component.setEnabled(false);
+                }
+        }
+        
+        /**
+         * Chained constructor.
          * 
          * @param source
@@ -76 +133 @@
          * @param minHeight
          * @param maxHeight
-         * 
-         * @param skipLoad
-         *              If true, the load state will be set to completed and the widget will not go through 
-         *              the loading proccess. Otherwise if true then the widget will go the loading phase.
          */
         protected HeavyDutyInteractiveWidget(Text source, JComponent component,
-                        int minWidth, int maxWidth, int minHeight, int maxHeight, boolean skipLoad) {
-                super(source, component, minWidth, maxWidth, minHeight, maxHeight);
-                
-                if (skipLoad) {
-                        loadState = LOAD_STATE_COMPLETED;
-                } else {
-                        component.setVisible(false); // not allowed to interact with it yet
-                        component.setEnabled(false);
-                }
-        }
-        
-        /**
-         * Chained constructor.
-         * 
-         * @param source
-         * @param component
-         * @param minWidth
-         * @param maxWidth
-         * @param minHeight
-         * @param maxHeight
-         */
-        protected HeavyDutyInteractiveWidget(Text source, JComponent component,
-                        int minWidth, int maxWidth, int minHeight, int maxHeight) {
-                this(source, component, minWidth, maxWidth, minHeight, maxHeight, false);
+                        int minWidth, int maxWidth, int minHeight, int maxHeight, int cacheDepth) {
+                this(source, component, minWidth, maxWidth, minHeight, maxHeight, cacheDepth, false);
         }
         
@@ -122 +153 @@
          */
         protected final void updateLoadPercentage(float percent) {
-                if (percent > 1.0f) throw new IllegalArgumentException("loadState is larger than 1.0");
-                else if (!isInLoadProgress()) throw new IllegalStateException("Load is not in progress");
-                setLoadState(percent);
-        }
-        
-        /**
-         * @param loadState 
-         *      Can be any of the following values.
-         *      <ul>
-         *              <li>PENDING_STATE if pending.
-         *              <li>COMPLETED_STATE if loaded.
-         *              <li>between 0.0f and 1.0f inclusive if loading: represents progress percent complete.
-         *              <li>FAILED_STATE if failed.
-         *              <li>INCOMPLETED_STATE if load was unable to complete.
-         *      <li>negative if loading but indeterminant.
-         *      </ul>
-         *              
-         */
-        private final void setLoadState(float loadState) {
-                assert (loadState == LOAD_STATE_FAILED || loadState != LOAD_STATE_INCOMPLETED ||
-                                 loadState != LOAD_STATE_PENDING || loadState != LOAD_STATE_COMPLETED ||
-                                loadState < 1.0f) ;
-                
-                this.loadState = loadState;
-                
-                if (this.loadState == LOAD_STATE_COMPLETED) {
-                        // Never use invoke and wait
-                        SwingUtilities.invokeLater(new Runnable() {
-                                public void run() {
-                                        _swingComponent.setVisible(true);
-                                        _swingComponent.setEnabled(true);
-                                }
-                        });
-                }
-                        
-                // Re-render loading state
-                FrameGraphics.invalidateArea(new Rectangle(getX(), getY(), getWidth(), getHeight()));
-                FrameGraphics.requestRefresh(true);
-        }
+                if (percent > 1.0f) 
+                        throw new IllegalArgumentException("loadState is larger than 1.0");
+                
+                else if (!isInLoadProgress() ||
+                                stateProccessor == null ||
+                                !stateProccessor.isAlive()) 
+                        throw new IllegalStateException("Load is not in progress");
+                
+                // Assuming that this is called from stateProccessor.
+                stateProccessor.setLoadState(percent, false);
+        }
+        
         
         /**
@@ -274 +278 @@
         }
         
+        
+        
         /**
          * Invoked by the load queue manager only.
@@ -279 +285 @@
         public final void performLoad() {
                 
-                // Check that not already loaded.
-                if (loadState == LOAD_STATE_COMPLETED ||
-                                loadState == LOAD_STATE_FAILED) return;
-                
-                // Reset flag.
-                hasCancelledBeenRequested = false;
-                
-                // Set the load state as loading... 0%
-                setLoadState(0.0f);
-        
-                float finalState = LOAD_STATE_FAILED;
-                
                 try {
-                        finalState = loadWidgetData();
-                } catch (Exception e) {
+                        doTaskAndWait(HDWTask.Load);
+                } catch (InterruptedException e) {
+                        loadState = LOAD_STATE_INCOMPLETED; // safety
                         e.printStackTrace();
                 }
-                
-                // Safety check for return state
-                try {
-                        if (finalState != LOAD_STATE_COMPLETED
-                                        && finalState != LOAD_STATE_FAILED
-                                        && finalState != LOAD_STATE_INCOMPLETED) {
-                                throw new Exception("ERROR: Bad return state: " + finalState);
-                        }
-                } catch (Exception e) {
-                        e.printStackTrace();
-                        finalState = LOAD_STATE_COMPLETED;
-                }
-                
-                // Set the final state
-                setLoadState(finalState); 
-                
-        }
-
+        }
+
+        /**
+         * Invoked by load manager
+         */
         public final void cancelLoadRequested() {
                 hasCancelledBeenRequested = true;
@@ -325 +307 @@
         protected boolean hasCancelBeenRequested() {
                 return hasCancelledBeenRequested;
+        }
+        
+        /**
+         * 
+         * @return
+         *              True if this widget is in an expired state
+         */
+        protected boolean isExpired() {
+                return isExpired;
+        }
+        
+        protected boolean isLoaded() {
+                return this.loadState == LOAD_STATE_COMPLETED;
         }
 
@@ -364 +359 @@
                         case ItemParentStateChangedEvent.EVENT_TYPE_SHOWN:
                         case ItemParentStateChangedEvent.EVENT_TYPE_SHOWN_VIA_OVERLAY:
+                                
                                 // When anchored to the window, then requeue for loading iff load state 
                                 // is currently pending or incomplete 
@@ -371 +367 @@
                                         EntityLoadManager.getInstance().queue(this, getLoadDelayTime());
                                 } 
+                                
                                 // Ensure that registered for saving at next save point
                                 EntitySaveManager.getInstance().register(this);
+                                
+                                // Ensure is cached 
+                                WidgetCacheManager.cacheWidget(this);
+                                
                         break; 
                         
@@ -379 +380 @@
                         case ItemParentStateChangedEvent.EVENT_TYPE_REMOVED_VIA_OVERLAY:
                         case ItemParentStateChangedEvent.EVENT_TYPE_HIDDEN:
+
                                 // Whenever the widget is not longer in view then cancel current loading proccess
                                 // if currently loading. This must be performed later because this event occurs
@@ -386 +388 @@
                                 // Always unregister from save point.
                                 EntitySaveManager.getInstance().unregister(this);
+                                
+                                // If the widget has been removed then unregister from caching
+                                // So that if deleted then won't hang around in cache
+                                if (e.getEventType() == ItemParentStateChangedEvent.EVENT_TYPE_REMOVED) {
+                                        WidgetCacheManager.uncacheWidget(this);
+                                        // If removed via overlay, then cached frames may still contain overlay with the widget...
+                                }
                                 break;
                 }
@@ -392 +401 @@
         private class DoCancelLoad implements Runnable {
                 public void run() {
-                        if (!isFloating()) {
-                                EntityLoadManager.getInstance().cancel(HeavyDutyInteractiveWidget.this);
-                        }
+                        
+                        for (Item i : getItems()) { // Only cancel if the widget is not floating. Allow loading while in free space
+                                if (FreeItems.getInstance().contains(i))
+                                        return;
+                        }
+                        
+                        // TODO: One problem with loading in free space is that there is no way of cancelling
+                        // if the heavy duty widget is deleted in free space while loading.
+                        // This is just an inefficiency.
+                        EntityLoadManager.getInstance().cancel(HeavyDutyInteractiveWidget.this);
+                        
                 }
         }
@@ -403 +420 @@
         public abstract int getLoadDelayTime();
 
+        /**
+         * Invoked by save manager
+         */
         public final void performSave() {
-                // Only save if still belongs to a frame
-                if (!isFloating() && getParentFrame() != null) {
-                        saveWidgetData();
-                }
-        }
-
+                try {
+                        doTaskAndWait(HDWTask.Save);
+                } catch (InterruptedException e) {
+                        e.printStackTrace();
+                }
+        }
+        
         /**
          * Called by dedicated thread to save data at a save point.
@@ -419 +440 @@
         protected abstract void saveWidgetData();
         
+        /**
+         * Only invoked if has cache expiry and has expired. Only if this is no longer visible.
+         */
+        void expire() {
+                doTaskLater(HDWTask.Unload);
+        }
+        
+        /**
+         * Invoked if this widget has a cache expiry and has been expired.
+         * The protocol is that you should unload anything in memory...
+         * This should be quick, e.g. setting references to null / disposing.
+         * Pupose is to free memory.
+         * 
+         * Important note:
+         * It is possible for a widget to expire before it had a chance to be saved,
+         * or even when saving. Thus must be careful.
+         * A simple approach would be to check the saving flag
+         * 
+         * 
+         */
+        protected abstract void unloadWidgetData();
+
+        /**
+         * The cache depth is measured by how many frames the user can traverse through until
+         * the widget should expire.
+         * 
+         * This is immutable.
+         * 
+         * @return
+         *                      The cache depth for this interactive widget. less or equal to zero for no cache expiry.
+         */
+        public final int getCacheDepth() {
+                return cacheDepth;
+        }
+
+        private synchronized void doTaskAndWait(HDWTask task) throws InterruptedException {
+                queueTask(task);
+                stateProccessor.join();
+        }
+        
+        private void doTaskLater(HDWTask task) {
+                queueTask(task);
+        }
+        
+        private void queueTask(HDWTask task) {
+                
+                synchronized(queuedTasks) {
+                        
+                        if (!queuedTasks.contains(task))
+                                queuedTasks.add(task);
+                
+        
+                        if (stateProccessor == null || !stateProccessor.isAlive()) {
+                                stateProccessor = new LoadStateManager();
+                                stateProccessor.start();
+                        }
+                
+                }
+                
+        }
+        
+        
+        /**
+         * Unified state management. Load states are handled by one thread always.
+         * Only has one instance - per widget instance, of this at any given time,
+         * 
+         * @author Brook
+         *
+         */
+        private class LoadStateManager extends Thread {
+                
+                /**
+                 * @param loadState 
+                 *      Can be any of the following values.
+                 *      <ul>
+                 *              <li>PENDING_STATE if pending.
+                 *              <li>COMPLETED_STATE if loaded.
+                 *              <li>between 0.0f and 1.0f inclusive if loading: represents progress percent complete.
+                 *              <li>FAILED_STATE if failed.
+                 *              <li>INCOMPLETED_STATE if load was unable to complete.
+                 *      <li>negative if loading but indeterminant.
+                 *      </ul>
+                 *              
+                 */
+                private void setLoadState(float state, boolean expired) {
+                        assert (state == LOAD_STATE_FAILED || state != LOAD_STATE_INCOMPLETED ||
+                                        state != LOAD_STATE_PENDING || state != LOAD_STATE_COMPLETED ||
+                                        state < 1.0f) ;
+                        
+                        assert (!expired || 
+                                        (expired && state == LOAD_STATE_PENDING));
+                        
+                        
+                        isExpired = expired;
+                        loadState = state;
+                        
+                        if (loadState == LOAD_STATE_COMPLETED) { // set enabled state - show the swing components
+                                SwingUtilities.invokeLater(new Runnable() {
+                                        public void run() {
+                                                _swingComponent.setVisible(true);
+                                                _swingComponent.setEnabled(true);
+                                        }
+                                });
+                                
+                        } else if(expired) { // disable/hide swing GUI when expires, like a reset
+                                
+                                SwingUtilities.invokeLater(new Runnable() {
+                                        public void run() {
+                                                _swingComponent.setVisible(false);
+                                                _swingComponent.setEnabled(false);
+                                        }
+                                });
+                        }
+
+                        // Re-render loading state - if not expired
+                        if (!expired) {
+                                FrameGraphics.invalidateArea(new Rectangle(getX(), getY(), getWidth(), getHeight()));
+                                FrameGraphics.requestRefresh(true);
+                        }
+                }
+                
+                /**
+                 * All state transitions performed by one thread.
+                 */
+                public void run() {
+                        
+                        while (true) { // keep proccessing tasks
+                                
+                                HDWTask task = null;
+                                
+                                synchronized(queuedTasks) {
+                                        if (queuedTasks.isEmpty()) return;
+                                        task = queuedTasks.remove();
+                                }
+
+                                if (task == HDWTask.Load) {
+                                        doLoad();
+                                } else if (task == HDWTask.Save) {
+                                        doSave(); // does not change state
+                                } else {
+                                        assert(task == HDWTask.Unload);
+                                        doUnload();
+                                }
+                        }
+                }
+                
+                private void doLoad() {
+
+                        // Check that not already loaded.
+                        if (loadState == LOAD_STATE_COMPLETED ||
+                                        loadState == LOAD_STATE_FAILED) return;
+                        
+                        // Only load if in view
+                        if (!isFloating() && getParentFrame() != DisplayIO.getCurrentFrame())
+                                return;
+                        
+                        // Reset flag.
+                        hasCancelledBeenRequested = false;
+                        
+                        // Set the load state as loading... 0%
+                        setLoadState(0.0f, false);
+                
+                        float finalState = LOAD_STATE_FAILED;
+                        
+                        try {
+                                finalState = loadWidgetData();
+                        } catch (Exception e) {
+                                e.printStackTrace();
+                        }
+                        
+                        // Safety check for return state
+                        try {
+                                if (finalState != LOAD_STATE_COMPLETED
+                                                && finalState != LOAD_STATE_FAILED
+                                                && finalState != LOAD_STATE_INCOMPLETED) {
+                                        throw new Exception("ERROR: Bad return state: " + finalState);
+                                }
+                        } catch (Exception e) {
+                                e.printStackTrace();
+                                finalState = LOAD_STATE_COMPLETED;
+                        }
+                        
+                        // Set the final state
+                        setLoadState(finalState, false); 
+                        
+                }
+                
+                private void doSave() {
+
+                        // Only save if still belongs to a frame
+                        if (!isFloating() && getParentFrame() != null) {
+                                saveWidgetData();
+                        }
+
+                }
+                
+                private void doUnload() {
+
+                        // Reset the load state
+                        setLoadState(LOAD_STATE_PENDING, true); 
+                        
+                        // Get rid of memory
+                        unloadWidgetData();
+                        
+                }
+                
+                
+                
+        }
+        
+        private enum HDWTask {
+                Save,
+                Load,
+                Unload
+        }
+        
+        
 }

trunk/src/org/expeditee/items/InteractiveWidget.java

@@ -7 +7 @@
 import java.awt.Graphics;
 import java.awt.Point;
+import java.awt.Rectangle;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
@@ -39 +40 @@
 
         /*
-         * GUIDE: l1 d1-------d2 | | l4 | X | 12 | | d4-------d3 13
+         * GUIDE: l1 d1-------d2 | 
+         * | l4 | X | 12 | | d4-------d3 13
          */
         private List<Item> _expediteeItems; // used for quickly returning item list
@@ -56 +58 @@
         private Text _textRepresentation;
         
-        private final static Color FREESPACE_BACKCOLOR = new Color(100,100,100,128);
+        //private final static Color FREESPACE_BACKCOLOR = new Color(100,100,100,128);
+        protected final static Color FREESPACE_BACKCOLOR = new Color(100,100,100);
 
         // A flag for signifying whether the swing components are ready to paint.
@@ -131 +134 @@
                                         + TAG + ":\"");
 
-                int width = -1, height = -1;
+                float width = -1, height = -1;
 
                 if (tokens.length < 2)
@@ -369 +372 @@
                 int x = source.getX();
                 int y = source.getY();
-                int width = (_minWidth < 0) ? 10 : _minWidth;
-                int height = (_minHeight < 0) ? 10 : _minHeight;
+                int width = (int)((_minWidth < 0) ? 10 : _minWidth);
+                int height = (int)((_minHeight < 0) ? 10 : _minHeight);
 
                 Frame idAllocator = _textRepresentation.getParent();
@@ -382 +385 @@
 
                 // create WidgetEdges
-                _l1 = new WidgetEdge(_d1, _d2, idAllocator.getNextItemID());
-                _l2 = new WidgetEdge(_d2, _d3, idAllocator.getNextItemID());
-                _l3 = new WidgetEdge(_d3, _d4, idAllocator.getNextItemID());
-                _l4 = new WidgetEdge(_d4, _d1, idAllocator.getNextItemID());
+                _l1 = new WidgetEdge(_d1, _d2, idAllocator.getNextItemID(), this);
+                _l2 = new WidgetEdge(_d2, _d3, idAllocator.getNextItemID(), this);
+                _l3 = new WidgetEdge(_d3, _d4, idAllocator.getNextItemID(), this);
+                _l4 = new WidgetEdge(_d4, _d1, idAllocator.getNextItemID(), this);
                 
                 Collection<Item> enclist = new ArrayList<Item>(4);
@@ -407 +410 @@
                 _expediteeItems.add(_l4);
         }
-
+        
         /**
          * This can be overrided for creating custom copies. The default implementation
@@ -481 +484 @@
          * @param height
          */
-        public void setSize(int width, int height) {
+        public void setSize(float width, float height) {
 
                 // Clamp
@@ -502 +505 @@
                 _d4.setFloating(true);
 
-                int x = _d1.getX() + width;
-                int y = _d1.getY() + height;
+                float x = _d1.getX() + width;
+                float y = _d1.getY() + height;
+                
                 _d2.setX(x);
                 _d3.setX(x);
@@ -538 +542 @@
                 _d3.setFloating(vfloating[2]);
                 _d4.setFloating(vfloating[3]);
+                
+                onMoved();
 
         }
@@ -551 +557 @@
          * @return False if need to call super.setPosition
          */
-        boolean setPositions(WidgetCorner src, int x, int y) {
+        boolean setPositions(WidgetCorner src, float x, float y) {
 
                 if (_settingPositionFlag)
@@ -560 +566 @@
                 boolean isAllPickedUp = (_d1.isFloating() && _d2.isFloating()
                                 && _d3.isFloating() && _d4.isFloating());
-
-                int newX = x;
-
-                // X Positions
-                if (src == _d1 || src == _d4) {
-
-                        if (src == _d1 && isAllPickedUp)
-                                _d1.setX(newX);
-                        else if (src == _d4 && isAllPickedUp)
-                                _d4.setX(newX);
-                        else {
+                                
+                // If so, then this will be called one by one .. 
+                if (isAllPickedUp) {
+                        src.setPosition(x, y);
+                } else {
+        
+                        float newX = x;
+                        
+                        // Reference:
+                        // D1 D2
+                        // D3 D4
+        
+                        //
+                        // GUIDE: 
+                        //        l1
+                        //    d1-------d2 
+                        //    |        |
+                        // l4 |    X   | 12
+                        //    |        | 
+                        //    d4-------d3 
+                        //        13
+                        //
+                        
+                        // X Positions
+                        if (src == _d1 || src == _d4) {
+        
                                 // Check min X constraint
                                 if (_minWidth >= 0) {
@@ -583 +604 @@
                                         }
                                 }
-
+        
                                 if (!(src == _d4 && _d1.isFloating() && _d4.isFloating()))
                                         _d1.setX(newX);
                                 if (!(src == _d1 && _d4.isFloating() && _d1.isFloating()))
                                         _d4.setX(newX);
-                        }
-
-                } else if (src == _d2 || src == _d3) {
-
-                        if (src == _d2 && isAllPickedUp)
-                                _d2.setX(newX);
-                        else if (src == _d3 && isAllPickedUp)
-                                _d3.setX(newX);
-                        else {
+                                
+                        } else if (src == _d2 || src == _d3) {
+        
+        
                                 // Check min X constraint
                                 if (_minWidth >= 0) {
@@ -609 +625 @@
                                         }
                                 }
-
+        
                                 if (!(src == _d3 && _d2.isFloating() && _d3.isFloating()))
                                         _d2.setX(newX);
@@ -615 +631 @@
                                         _d3.setX(newX);
                         }
-
-                }
-
-                int newY = y;
-
-                // Y Positions
-                if (src == _d1 || src == _d2) {
-
-                        if (src == _d1 && isAllPickedUp)
-                                _d1.setY(newY);
-                        else if (src == _d2 && isAllPickedUp)
-                                _d2.setY(newY);
-                        else {
+        
+                        float newY = y;
+        
+                        // Y Positions
+                        if (src == _d1 || src == _d2) {
+        
                                 // Check min Y constraint
                                 if (_minHeight >= 0) {
@@ -640 +649 @@
                                         }
                                 }
-
+        
                                 if (!(src == _d2 && _d1.isFloating() && _d2.isFloating()))
                                         _d1.setY(newY);
                                 if (!(src == _d1 && _d2.isFloating() && _d1.isFloating()))
                                         _d2.setY(newY);
-
-                        }
-
-                } else if (src == _d3 || src == _d4) {
-
-                        if (src == _d3 && isAllPickedUp)
-                                _d3.setY(newY);
-                        else if (src == _d4 && isAllPickedUp)
-                                _d4.setY(newY);
-                        else {
+        
+                        } else if (src == _d3 || src == _d4) {
+        
+        
                                 // Check min Y constraint
                                 if (_minHeight >= 0) {
@@ -667 +670 @@
                                         }
                                 }
-
+        
                                 if (!(src == _d4 && _d3.isFloating() && _d4.isFloating()))
                                         _d3.setY(newY);
@@ -674 +677 @@
                         }
                 }
-
+                
                 // Update source text position so position is remembered from loading
-                int newTextX = getX();
-                int newTextY = getY();
+                float newTextX = getX();
+                float newTextY = getY();
                 if (_textRepresentation.getX() != newTextX || _textRepresentation.getY() != newTextY)
                         _textRepresentation.setPosition(newTextX, newTextY);
 
                 _settingPositionFlag = false;
+                
+                onMoved();
+                
                 return true;
         }
@@ -694 +700 @@
 
         public int getWidth() {
+                
                 return Math.abs(_d2.getX() - _d1.getX());
         }
@@ -832 +839 @@
         }
         
-        public void onBoundsChanged() {
+        final void onBoundsChanged() {
                 if (isFixedSize()) _swingComponent.setBounds(getX(), getY(), _maxWidth, _maxHeight);
                 else _swingComponent.setBounds(getX(), getY(), getWidth(), getHeight());
@@ -978 +985 @@
         }
         
+        protected void invalidateSelf() {
+        Rectangle dirty = new Rectangle((int)getX(), (int)getY(), (int)getWidth(), (int)getHeight());
+        FrameGraphics.invalidateArea(dirty); 
+        FrameGraphics.refresh(true); 
+        }
+        
+        /**
+         * @see ItemUtils#isVisible(Item)
+         * 
+         * @return
+         *              True if this widget is visible from the current frame.
+         *              Considers overlays and vectors.
+         *              
+         */
+        public boolean isVisible() {
+                return ItemUtils.isVisible(_d1);
+        }
+        
+        /**
+         * Invoked whenever the widget have moved.
+         *
+         */
+        protected void onMoved() { }
+        
 }

trunk/src/org/expeditee/items/Item.java

@@ -1739 +1739 @@
         public void onParentStateChanged(ItemParentStateChangedEvent e) {
         }
-
+        
         public void setHighlightMode(HighlightMode mode, Color color) {
                 setHighlightColor(color);

trunk/src/org/expeditee/items/ItemParentStateChangedEvent.java

@@ -6 +6 @@
  * Raised whenever the items parent (Frame) changes - when the frame is no longer in view
  * or becomes in view, or if the item has no parent / has a new parent.
+ * 
  * @author Brook Novak
  *
@@ -22 +23 @@
         public static final int EVENT_TYPE_REMOVED = 6;
         public static final int EVENT_TYPE_REMOVED_VIA_OVERLAY = 7;
+        
         
         public ItemParentStateChangedEvent(Frame src, int eventType) {

trunk/src/org/expeditee/items/WidgetCorner.java

@@ -29 +29 @@
         @Override
         public void setPosition(float x, float y) {
+                
                 invalidateFill();
                 if (_widgetSource != null) { // _widgetSource == null on construction
-                        if (!_widgetSource.setPositions(this,(int)(x+0.5),(int)(y+0.5))) {
+                        if (!_widgetSource.setPositions(this, x, y)) {
                                 super.setPosition(x, y);
                         }
@@ -42 +43 @@
                 invalidateFill();
                 if (_widgetSource != null) { // _widgetSource == null on construction
-                        if (!_widgetSource.setPositions(this,(int)(x+0.5),(int)(y+0.5))) {
+                        if (!_widgetSource.setPositions(this, x, y)) {
                                 super.setXY(x, y);
                         }

trunk/src/org/expeditee/items/WidgetEdge.java

@@ -9 +9 @@
  */
 public class WidgetEdge extends Line {
+        
+        private InteractiveWidget _widgetSource;
           
-        WidgetEdge(WidgetCorner start, WidgetCorner end, int id) {
+        WidgetEdge(WidgetCorner start, WidgetCorner end, int id, InteractiveWidget widgetSource) {
                 super(start, end, id);
                 super.setThickness(2.0f);
                 super.setColor(Color.black);
+                
+                if (widgetSource == null) throw new NullPointerException("widgetSource");
+                _widgetSource = widgetSource;
         }
 
+        public InteractiveWidget getWidgetSource() {
+                return _widgetSource;
+        }
+        
         @Override
         public Item forceMerge(Item merger, int mouseX, int mouseY) {