DesignMenuModel.java

/*******************************************************************************
 * Copyright (c) 2014 Elphel, Inc.
 * Copyright (c) 2006 Elphel, Inc and Excelsior, LLC.
 * This file is a part of VDT plug-in.
 * VDT plug-in is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * VDT plug-in is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 *  Additional permission under GNU GPL version 3 section 7:
 * If you modify this Program, or any covered work, by linking or combining it
 * with Eclipse or Eclipse plugins (or a modified version of those libraries),
 * containing parts covered by the terms of EPL/CPL, the licensors of this
 * Program grant you additional permission to convey the resulting work.
 * {Corresponding Source for a non-source form of such a combination shall
 * include the source code for the parts of Eclipse or Eclipse plugins used
 * as well as that of the covered work.}
 *******************************************************************************/
package com.elphel.vdt.ui.views;

//import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;

import java.io.File;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.atomic.AtomicBoolean;

import org.eclipse.core.resources.IResource;
//import org.eclipse.jface.viewers.TreeViewer;
//import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
//import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;

import com.elphel.vdt.VDT;
import com.elphel.vdt.core.tools.ToolsCore;
import com.elphel.vdt.core.tools.config.Config;
import com.elphel.vdt.core.tools.contexts.PackageContext;
import com.elphel.vdt.core.tools.contexts.ProjectContext;
import com.elphel.vdt.core.tools.menu.DesignMenu;
import com.elphel.vdt.core.tools.menu.DesignMenuItem;
import com.elphel.vdt.core.tools.menu.DesignMenuToolItem;
import com.elphel.vdt.core.tools.params.Tool;
import com.elphel.vdt.core.tools.params.Tool.TOOL_STATE;
import com.elphel.vdt.ui.VDTPluginImages;
import com.elphel.vdt.ui.variables.SelectedResourceManager;

/**
 * Adapter of core design menu for user interface level.
 * 
 * Created: 28.03.2006
 * @author  Lvov Konstantin
 */

public class DesignMenuModel {

    private Config config;
    
    private MenuItem root;
    private final int IMAGE_MARGIN=2;
    public DesignMenuModel(DesignMenu menu) {
        config = ToolsCore.getConfig();
        root = new MenuItem(null, menu);
    }
    
    public Item[] getItems() {
        return root.getChildren();  
    }

    // ------------------------------------------------------------------------
    public abstract class Item {
        private static final String ICON_ID_PREFIX = VDT.ID_VDT + ".DesignMenu.Image.";
        private String imageKey = null;
        
        protected String imageKeyState = null;

        private DesignMenuItem source;
        private Item parent;
        private int animN;
        private Rectangle animBounds=null;
        private ImageData[] imageData=null;
//        private boolean animEn=true; // just testing, fill be  false;
        final private AtomicBoolean animBusy=new AtomicBoolean(false);
        private Timer timer=null;
//        private int updateWidth=16;
        private Item(Item parent, DesignMenuItem source) {
            this.parent = parent;
            this.source = source;
            this.timer=null;

            String image = source.getIcon();
            if (image != null) {
//              imageKey = ICON_ID_PREFIX + source.getName();
                imageKey = ICON_ID_PREFIX + (new File(source.getName())).getName();
                if (VDTPluginImages.getImage(imageKey) == null)
                    VDTPluginImages.addImage(image, imageKey, null/*tool.getLaunchType()*/);
            }
        }

        public boolean isEnabled(IResource resource) {
            return false;
        }
        public boolean isEnabled(String path) {
            return false;
        }

        public Object getParent() {
            return parent;
        }

        public Item[] getChildren() {
            return new Item[0];
        }
        public boolean hasChildren() {
            return false;
        }

        public String toString() {
            String label = source.getLabel();
            return label != null ? label : "Unknown";
        }
        
        public String getLabel() {
            return toString();
        }
        public String getImageKey() {
            return imageKey;
        }
        public void measureItem (Event event){
        	if (imageKeyState==null) return;
        	Image image=VDTPluginImages.getImage(imageKeyState);
        	if (image!=null) event.width+=IMAGE_MARGIN+image.getBounds().width;
        }
        
        public void showStateIcon(Event event, final Tree tree, final TreeItem item){
        	if ((imageKeyState==null) || (item.isDisposed())) return;
        	int x = event.x + event.width + IMAGE_MARGIN;
        	int itemHeight = tree.getItemHeight();
        	imageData=VDTPluginImages.getImageData(imageKeyState);
        	Image frameImage;
        	boolean isAnimation=false;
        	if ((imageData!=null) && (imageData.length>1) && animBusy.compareAndSet(false,true)){
        		isAnimation=true;
        		animN=animN % imageData.length;
        		frameImage = new Image(Display.getDefault(),imageData[animN]);
        	} else {
        		frameImage = VDTPluginImages.getImage(imageKeyState); // do not dispose() !
        	}
        	int imageHeight = frameImage.getBounds().height;
        	int y = event.y + (itemHeight - imageHeight) / 2;
    		event.gc.drawImage(frameImage, x, y);
//    		System.out.println("showStateIcon(): "+imageKeyState);
        	if (isAnimation){
            	animBounds=frameImage.getBounds();
            	frameImage.dispose();
            	final int fDelayTime=imageData[animN].delayTime*10; // ms
            	animN++;
    			// item does not include our animation on the right of it, so we need to store image location
    			// relative to the top right corner of the item (height does not change)
    			Rectangle r=item.getBounds();
            	animBounds.x=x-(r.x+r.width);
            	animBounds.y=y-(r.y);
            	
            	TimerTask timerTask=new TimerTask() {          
            		@Override
            		public void run() {
           				refresh(item, tree); // threw on shutdown - 
            		}
            	};
        	
            	if (timer==null) timer=new Timer();
            	try {
            		timer.schedule(timerTask, fDelayTime);
            	} catch (IllegalStateException e){
            		System.out.println("DesignMenuModel(): Timer was somewhere canceled, recovering");
            		timer.cancel();
            		timer=new Timer();
            		timer.schedule(timerTask, fDelayTime);
            	}

            	
            	
/*            	
            	timer.schedule(new TimerTask() {          
            		@Override
            		public void run() {
           				refresh(item, tree); // threw on shutdown - 
            		}
            	}, fDelayTime);
*/            	
        	}
        }
        
        public void refresh(final TreeItem item, final Tree tree) {
        	Display.getDefault().syncExec(new Runnable() {
        		public void run() {
        			if (item.isDisposed()) {
            			animBusy.compareAndSet(true, false);
        				return;
        			}
        			Rectangle r=item.getBounds();
//        			System.out.println("animBounds="+animBounds.toString()+" item.getBounds()="+item.getBounds().toString());
        			tree.redraw(
        					animBounds.x+r.x+r.width,
        					animBounds.y+r.y,
        					animBounds.width,
        					animBounds.height,true);
        			animBusy.compareAndSet(true, false);
        		}
        	});
        }
        
        public Tool getTool() {
            return null;   
        }

        public Config getConfig() { 
            return null; 
        }

        public PackageContext getPackageContext() { 
            return  null; 
        }

        public ProjectContext getProjectContext() { 
            return  null; 
        }
    } // class Item
    
    // ------------------------------------------------------------------------
    public class ToolItem extends Item {
        private Tool tool;
        
        private ToolItem(Item parent, DesignMenuToolItem source) {
            super(parent, source);
            tool = ToolsCore.getTool(source.getToolName());
        }

        public boolean isEnabled(IResource resource) {
            if (resource == null)
                return false;

            String extensions[] = tool.getExtensions();
            if (extensions == null)
                return true;
            String resourceExt = resource.getFileExtension();
            if (resourceExt == null)
                return false;
            
            for (int i=0; i < extensions.length; i++) {
                if (resourceExt.equalsIgnoreCase(extensions[i]))
                    return true;    
            }
            return false;
        } // isEnabled(IResource)

        public boolean isEnabled(String path) {
            if (path == null)
                return false;

            String extensions[] = tool.getExtensions();
            if (extensions == null)
                return true;
            int index=path.indexOf(".");
            if (index<0) return false;
            String resourceExt = path.substring(index+1);
            for (int i=0; i < extensions.length; i++) {
                if (resourceExt.equalsIgnoreCase(extensions[i]))
                    return true;    
            }
            return false;
        } // isEnabled(String)

        public Tool getTool() {
            return tool;   
        }

        public Config getConfig() { 
            return config; 
        }

        public PackageContext getPackageContext() {
            PackageContext context = tool.getParentPackage();
            if ((context != null) && context.isVisible())
                return context;
            else
                return null;
        }

        public ProjectContext getProjectContext() { 
            ProjectContext context = tool.getParentProject();
            if ((context != null) && context.isVisible())
                return context;
            else
                return null;
        }
        
        public void measureItem (Event event){
        	super.measureItem (event);
        	boolean pinned=tool.isPinned() || !SelectedResourceManager.getDefault().isToolsLinked();
        	String iconName,key;
        	if (tool.isRunning()){
        		iconName=VDTPluginImages.ICON_TOOLSTATE_RUNNING;
        		key=     VDTPluginImages.KEY_TOOLSTATE_RUNNING;
        	} else if (tool.isWaiting()){
        		iconName=VDTPluginImages.ICON_TOOLSTATE_WAITING;
        		key=     VDTPluginImages.KEY_TOOLSTATE_WAITING;
        	} else if (tool.isAlmostDone()&& (tool.getState()==TOOL_STATE.SUCCESS )){
        		iconName=VDTPluginImages.ICON_TOOLSTATE_ALMOST_GOOD;
        		key=     VDTPluginImages.KEY_TOOLSTATE_ALMOST_GOOD;
        	} else if (tool.isAlmostDone()&& (tool.getState()==TOOL_STATE.UNKNOWN )){
        		iconName=VDTPluginImages.ICON_TOOLSTATE_ALMOST_WTF;
        		key=     VDTPluginImages.KEY_TOOLSTATE_ALMOST_WTF;
        	} else if (tool.isAlmostDone()){ // restoring state, current state new (erased) or failure
        		iconName=VDTPluginImages.ICON_TOOLSTATE_ALMOST_GOOD;
        		key=     VDTPluginImages.KEY_TOOLSTATE_ALMOST_GOOD;
        	} else {
        		switch (tool.getState()){
        		case NEW:
        			iconName=VDTPluginImages.ICON_TOOLSTATE_NEW;
        			key= VDTPluginImages.KEY_TOOLSTATE_NEW;
        			break;
        		case FAILURE:
        			if (tool.isDirtyOrChanged()){
        				iconName=VDTPluginImages.ICON_TOOLSTATE_BAD_OLD;
        				key= VDTPluginImages.KEY_TOOLSTATE_BAD_OLD;
        			} else {
        				iconName=VDTPluginImages.ICON_TOOLSTATE_BAD;
        				key= VDTPluginImages.KEY_TOOLSTATE_BAD;
        			}
        			break;
        		case SUCCESS:
        			if (pinned){
    					iconName=VDTPluginImages.ICON_TOOLSTATE_PINNED;
    					key= VDTPluginImages.KEY_TOOLSTATE_PINNED;
        			} else {
        				if (tool.isDirtyOrChanged()){
        					iconName=VDTPluginImages.ICON_TOOLSTATE_GOOD_OLD;
        					key= VDTPluginImages.KEY_TOOLSTATE_GOOD_OLD;
        				} else {
        					iconName=VDTPluginImages.ICON_TOOLSTATE_GOOD;
        					key= VDTPluginImages.KEY_TOOLSTATE_GOOD;
        				}
        			}
        			break;
        		case KEPT_OPEN:
        				iconName=VDTPluginImages.ICON_TOOLSTATE_KEPT_OPEN;
        				key= VDTPluginImages.KEY_TOOLSTATE_KEPT_OPEN;
        			break;
        		default:
        			if (tool.isDirtyOrChanged()){
        				iconName=VDTPluginImages.ICON_TOOLSTATE_WTF_OLD;
        				key= VDTPluginImages.KEY_TOOLSTATE_WTF_OLD;
        			} else {
        				iconName=VDTPluginImages.ICON_TOOLSTATE_WTF;
        				key= VDTPluginImages.KEY_TOOLSTATE_WTF;
        			}
        		}
        	}
            key = Item.ICON_ID_PREFIX + key;
            if (VDTPluginImages.getImage(key) == null){
                VDTPluginImages.addImage(iconName, key, null);
        	}
        	super.imageKeyState=key;
//        	System.out.println("iconName="+iconName+", key="+key+" imageKeyState="+super.imageKeyState);
        	/*        	
        */
//TODO: Save tool state in memento        	
        }
    } // class ToolItem

    // ------------------------------------------------------------------------
    public class MenuItem extends Item {
        private Item[] items;
        
        private MenuItem(Item parent, DesignMenu source) {
            super(parent, source);
            
            List<Item> itemList = new ArrayList<Item>();
            
            for(Iterator<DesignMenuItem> i = source.getItems().iterator(); i.hasNext();) {
                DesignMenuItem menuitem = (DesignMenuItem)i.next();

                if(menuitem.isVisible())
                    itemList.add(CreateItem(this, menuitem)); 
            }
        
            items = (Item[])itemList.toArray(new Item[itemList.size()]);
        }    
        
        public Item[] getChildren() {
            return items;
        }
        
        public boolean hasChildren() {
            return items.length > 0;
        }

    } // class MenuItem

    private Item CreateItem(Item parent, DesignMenuItem source) {
        if (source instanceof DesignMenuToolItem)
            return new ToolItem(parent, (DesignMenuToolItem)source);
        else if (source instanceof DesignMenu) 
            return new MenuItem(parent, (DesignMenu)source);
        else
            assert(false);
        return null;
    }
    
} // class DesignMenuModel