source: other-projects/GlamED/trunk/src/org/honours/gui/HonoursFrameIO.java@ 26588

package org.honours.gui;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;

import org.expeditee.gui.DisplayIO;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.FrameKeyboardActions;
import org.expeditee.gui.MessageBay;
import org.expeditee.gui.UserSettings;
import org.expeditee.items.Item;
import org.expeditee.items.Text;
import org.expeditee.items.widgets.WidgetCorner;
import org.expeditee.stats.Formatter;
import org.honours.collection.CollectionItem;

public class HonoursFrameIO {

    private static Frame _lastCopiedFrame = null;   
    
    public static boolean DISPLAY_TOOLBAR = true;
    public static boolean DISPLAY_LAYERS = true;
    public static boolean DISPLAY_NOTES = false;
    
    public static boolean DISPLAY_TOGGLER = true;
    
    public static String COLLECTIONS_PATH = FrameIO.PARENT_FOLDER +
            "collections" + File.separator;
    
    /**
     * Generate a new frame for a given (existing) 
     * frameset.
     * @param frameNumber - frame number for this next item.
     * @param frameset - frameset to add frame to.
     */
    public static void generateFrame(int frameNumber, String frameset){
        String frameFileName = FrameIO.FRAME_PATH + frameset + File.separator +
                frameNumber + ".exp";
        Frame checkExistingFrame = FrameIO.LoadFrame(frameset + frameNumber);
        
        if(checkExistingFrame == null){
            FileWriter fw;
            BufferedWriter bw;
            
            try{
                fw = new FileWriter(frameFileName);
                bw = new BufferedWriter(fw);
                writeOutFrameHeader(bw);
                FrameIO.WriteINF(FrameIO.FRAME_PATH, frameset, frameset+frameNumber);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    
    /**
     * Writes out a frame header for a new frame.
     * @param bw
     */
    public static void writeOutFrameHeader(BufferedWriter bw){
        try {
            StringBuffer header = new StringBuffer("");
            
            header.append("V 1\n");
            header.append("p 44");
            header.append("U " + UserSettings.UserName + "\n");
            header.append("D " + Formatter.getDateTime() + "\n");   //
            header.append("M " + UserSettings.UserName + "\n");     //last modified by
            header.append("d " + Formatter.getDateTime() + "\n");
            header.append("Z\n\n");
            bw.write(header.toString());
            
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

    public static Frame CopyFrame() {
        _lastCopiedFrame = DisplayIO.getCurrentFrame();
        MessageBay.displayMessage("Item successfully copied.");
        
        return _lastCopiedFrame;
    }

    public static Frame PasteFrame() {
        
        Frame current = DisplayIO.getCurrentFrame();
        if(_lastCopiedFrame != null){
            
            List<Item> list = _lastCopiedFrame.getVisibleItems();
            List<Item> copy = new ArrayList<Item>();
            
            for(Item item : list){
                if(!(item instanceof WidgetCorner))
                    copy.add(item);
            }
            
            current.addAllItems(copy);
            
        }else{
            MessageBay.errorMessage("ERROR: NO FRAME/ITEM TO COPY");
            return null;
        }
        
        return _lastCopiedFrame;

    }
    
    /**
     * Toggles on and off the display of the "Toggle 
     * Toolbar" overlay.
     */
    public static void toggleToggler(){
        if(DISPLAY_TOGGLER){
            swapLinks(Interfaces.TOGGLE_TOOLS_OVERLAY,Interfaces.BLANK_TOGGLER_OVERLAY);
            DISPLAY_TOGGLER = false;
        }else{
            swapLinks(Interfaces.BLANK_TOGGLER_OVERLAY,Interfaces.TOGGLE_TOOLS_OVERLAY);
            DISPLAY_TOGGLER = true;
        }
        FrameKeyboardActions.Refresh();
    }

    public static void ToggleToolbar() {
        if(DISPLAY_TOOLBAR){
            
            swapLinks(Interfaces.NAVIGATION_OVERLAY,Interfaces.BLANK_TOOLBAR_OVERLAY);
            DISPLAY_TOOLBAR = false;
            
        }else{
            //make it reappear.
            swapLinks(Interfaces.BLANK_TOOLBAR_OVERLAY,Interfaces.NAVIGATION_OVERLAY);
            DISPLAY_TOOLBAR = true;
        }
        
        FrameKeyboardActions.Refresh();
    }

    public static void ToggleNotesDisplay(CollectionItem collectItem) {
        
        //get link to the collection item's note frame.
                String noteFrameLink = collectItem.getNoteLayer().getFrame().getName();
                
                if(DISPLAY_NOTES){
                    
                    swapLinks(noteFrameLink,Interfaces.BLANK_HIDE_NOTES_OVERLAY);
                    DISPLAY_NOTES = false;
                
                    
                }else{
                    swapLinks(Interfaces.BLANK_HIDE_NOTES_OVERLAY,noteFrameLink);
                    DISPLAY_NOTES = true;
                }
                FrameKeyboardActions.Refresh();
        
    }
    

    
    /**
     * Used by toggleToolbar() and ToggleLayersDisplay() and ToggleNotesDisplay()
     * to change the overlay annotation links. So if we want
     * the display of these things off, the overlay will just be 
     * a blank frame. Otherwise the overlay will be the appropriate
     * frame displaying the toolbar/layer display.
     * @param oldLink
     * @param newLink
     */
    private static void swapLinks(String oldLink,String newLink){
        
        Frame curr = DisplayIO.getCurrentFrame();
        for(Item item : curr.getItems()){
            
            if(item instanceof Text){
                Text t = (Text)item;
                if(t.getText().equals("@ao:3") || t.getText().equals("@ao:4")){
                    if(t.hasLink()){
                        if(t.getLink().equals(oldLink)){
                            t.setLink(newLink);
                            return;
                        }
                    }
                }
            }
        }
    }


}