source: trunk/src/org/expeditee/actions/NavigationActions.java@ 67

package org.expeditee.actions;

import java.util.List;

import org.expeditee.gui.DisplayIO;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameGraphics;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.FrameUtils;
import org.expeditee.items.Item;

/**
 * Provides the Navigation related KMS action procedures
 * 
 * @author jdm18
 * 
 */
public class NavigationActions {

        public static void setLastNavigationItem(Item i) {
                _LastItemUsed = i;
                if (i.getParent() != null) {
                        _Parent = i.getParent().getFrameName();
                }
        }

        private static void Default() {
                System.out.println("Not Implemented");
        }

        /**
         * Performs a back operation from the current Frame. If the back-stack is
         * empty, then nothing happens.
         */
        public static void Back() {
                DisplayIO.Back();
        }

        public static void ClearBack(Item i) {
                Default();
        }

        public static void DeleteBack() {
                Default();
        }

        public static void GetBack(String topFrame, int x, int y) {
                Default();
        }

        public static void GetBackList() {
                Default();
        }

        /**
         * Displays the user's home frame
         */
        public static void GotoHome() {
                FrameUtils.DisplayHomeFrame();
        }

        /**
         * Displays the user's profile frame (if there is one)
         */
        public static void GotoProfile() {
                FrameUtils.DisplayProfileFrame();
        }

        /**
         * Loads the Frame with the given FrameName and displays it
         * 
         * @param frameName
         *            The name of the Frame to load
         */
        public static void Goto(String frameName) {
                FrameUtils.DisplayFrame(frameName);
        }

        /**
         * Loads the Frame in the current frameset with the given number and
         * displays it
         * 
         * @param value
         *            The number of the Frame to load
         */
        public static void Goto(Integer value) {
                FrameUtils.DisplayFrame(value.toString());
        }

        /**
         * Loads the Frame linked to by the Item that has this action, if there is
         * one
         * 
         * @param source
         *            The Item that has a link to the Frame to load and display
         */
        public static void GotoLink(Item source) {
                FrameUtils.DisplayFrame(source.getLink());
        }

        /**
         * Turns TwinFrames off if it is on, otherwise does nothing
         */
        public static void Large() {
                if (DisplayIO.isTwinFramesOn())
                        DisplayIO.ToggleTwinFrames();
        }

        /**
         * Navigates to the Frame with the next highest frame number in the current
         * frameset. If the current frame is the last frame in the frameset, nothing
         * happens.
         */
        public static void NextFrame() {
                NextFrame(true);
        }
        
        public static void NextFrame(boolean addToBack) {
                addToBack = adjustAddToBack(addToBack);
                Frame next = FrameIO.LoadNext();
                FrameUtils.DisplayFrame(next, addToBack);
        }
        
        /**
         * Navigates to the last frame in the frameset.
         *
         */
        public static void LastFrame() {
                Frame last = FrameIO.LoadLast();
                FrameUtils.DisplayFrame(last, true);
        }
        
        public static void ZeroFrame() {
                Frame zeroFrame = FrameIO.LoadZero();
                FrameUtils.DisplayFrame(zeroFrame, true);
        }
        

        public static void Next() {
                NextFrame();
        }
        
        public static void Previous() {
                PreviousFrame();
        }
        
        public static void PreviousFrame(boolean addToBack) {
                addToBack = adjustAddToBack(addToBack);
                Frame prev = FrameIO.LoadPrevious();
                FrameUtils.DisplayFrame(prev, addToBack);
        }
        
        public static void PreviousFrame() {
                PreviousFrame(true);
        }

        private static String _Parent = null;

        private static Item _LastItemUsed = null;

        public static void NextChild(Frame source) {
                String back = DisplayIO.peekFromBack(); // ByRob: "peekFromBack" is not
                // an informative term, better to refer to back up stack
                // if there is no parent frame (i.e. the user is on the home frame) //
                // ByRob: this should say "for example, the user ...."
                if (back == null) { // No frame was on the Backup stack
                        FrameGraphics.DisplayMessage("No Parent Frame Found.");
                        _LastItemUsed = null; // ByRob: what is reason for setting
                        // this to null, who is going to use
                        // it????
                        _Parent = null; // ByRob: what is reason for setting this to
                        // null, who is going to use it
                        return;
                }

                /*
                 * if(_Parent == null || !back.equals(_Parent.getFrameName())){ _Parent =
                 * FrameIO.LoadFrame(back); _LastItemUsed = null; }
                 */

                if (_Parent == null || !back.equals(_Parent)) { // ByRob: what the heck
                        // is the code doing?
                        // What is it setting
                        // up???????
                        _Parent = back;
                        _LastItemUsed = null;
                }

                Frame parent = FrameIO.LoadFrame(_Parent); // at this point we have
                // a parent frame (but
                // does LoadFrame access
                // backup stack?

                // find the next item to visit // ByRob: We should NOT be trying to
                // remember state!!! at time of Next, getNameOfCurrentFrame!!!!
                // Actually, no. It could be situation that there is more than one item
                // on frame linked to CurrentFr

                List<Item> items = parent.getItems(); // getItems method gets us the
                // FirstItem on the frame
                int parentItemLinkedToSource = 0; // ByMike: Will be set to the
                // index of the item on the parent which follows the item linked to the
                // child frame we are currently viewing.

                // ByMike: if 'Next' has been clicked previously get the index of the
                // item FOLLOWING the ParentItem linked to the source
                if (_LastItemUsed != null) {
                        parentItemLinkedToSource = items.indexOf(_LastItemUsed);
                }

                // ByMike: If the 'Next' child is being sought for the 1st time...

                String sourceName = source.getFrameName().toLowerCase();

                // ByMike: Find the first occurence of a ParentItem linked to the source
                while (parentItemLinkedToSource < items.size()
                                && (items.get(parentItemLinkedToSource).getAbsoluteLink() == null || !items
                                                .get(parentItemLinkedToSource).getAbsoluteLink().toLowerCase()
                                                .equals(sourceName))) {
                        parentItemLinkedToSource++; // ByRob: this increments to the next
                        // item
                }

                // Find the next ParentItem linked to the next frame to be displayed
                for (int i = parentItemLinkedToSource + 1; i < items.size(); i++) {
                        if (items.get(i).isLinkValid()
                                        && !items.get(i).isAnnotation()
                                        && !items.get(i).getAbsoluteLink().toLowerCase().equals(
                                                        source.getFrameName().toLowerCase())) {
                                _LastItemUsed = items.get(i);
                                FrameUtils.DisplayFrame(_LastItemUsed.getLink(), false);
                                return;
                        } // ByRob: end of if

                } // ByRob: End of For

                FrameGraphics.DisplayMessage("No more child frames found.");
        }

        public static void OtherWindow() {
                Default();
        }

        /**
         * Turns TwinFrames on if it is off, otherwise does nothing
         * 
         */
        // ByRob: Rob doesn't like notion of turning TwinFrames on and off,
        // better to say more explicitly/directly what the mode is!!!!
        public static void Small() {
                if (!DisplayIO.isTwinFramesOn())
                        DisplayIO.ToggleTwinFrames();
        }
        
        // When display frame is called with addToBack set to false multiple
        // times...
        // The first time we add to back but after that we dont
        // This flag stores the state for the addToBack parameter the last time this
        // method was called
        private static boolean _lastAddToBack = true;

        public static void ResetLastAddToBack() {
                _lastAddToBack = true;
        }
        
        private static boolean adjustAddToBack(boolean addToBack) {
                boolean originalAddToBack = addToBack;
                
                if (!addToBack && _lastAddToBack){
                        //This adds the first frame to the backup stack when the user
                        //navigates through a bunch of frames with the keyboard!
                        addToBack = true;
                }
                
                _lastAddToBack = originalAddToBack;
                
                return addToBack;
        }
}