tradingsystemview.java

EclipseTrader is a stock exchange analysis system, featuring shares pricing watch, intraday and hi

        public GroupTreeItem(TradingSystemGroup group, Tree parent, int style, int index)
        {
            super(parent, style, index);
            init(group);
        }

        public GroupTreeItem(TradingSystemGroup group, Tree parent, int style)
        {
            super(parent, style);
            init(group);
        }

        public GroupTreeItem(TradingSystemGroup group, TreeItem parentItem, int style, int index)
        {
            super(parentItem, style, index);
            init(group);
        }

        public GroupTreeItem(TradingSystemGroup group, TreeItem parentItem, int style)
        {
            super(parentItem, style);
            init(group);
        }
        
        protected void init(TradingSystemGroup group)
        {
            this.group = group;
            this.group.addObserver(this);
            this.group.getGroups().addCollectionObserver(this);
            this.group.getTradingSystems().addCollectionObserver(this);
            
            addDisposeListener(new DisposeListener() {
                public void widgetDisposed(DisposeEvent e)
                {
                    GroupTreeItem.this.group.deleteObserver(GroupTreeItem.this);
                    GroupTreeItem.this.group.getGroups().removeCollectionObserver(GroupTreeItem.this);
                    GroupTreeItem.this.group.getTradingSystems().removeCollectionObserver(GroupTreeItem.this);
                }
            });
            
            FontData fd = getFont().getFontData()[0];
            Font font = new Font(null, fd.getName(), fd.getHeight(), SWT.BOLD);
            setFont(font);

            setText(0, group.getDescription());

            for (Iterator iter = this.group.getGroups().iterator(); iter.hasNext(); )
                new GroupTreeItem((TradingSystemGroup) iter.next(), this, SWT.NONE);

            for (Iterator iter = this.group.getTradingSystems().iterator(); iter.hasNext(); )
                new TradingSystemItem((TradingSystem) iter.next(), this, SWT.NONE);
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.widgets.TreeItem#checkSubclass()
         */
        protected void checkSubclass()
        {
        }

        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemAdded(java.lang.Object)
         */
        public void itemAdded(Object o)
        {
            if (o instanceof TradingSystem)
                new TradingSystemItem((TradingSystem) o, this, SWT.NONE);
            else if (o instanceof TradingSystemGroup)
                new GroupTreeItem((TradingSystemGroup) o, this, SWT.NONE);
        }

        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemRemoved(java.lang.Object)
         */
        public void itemRemoved(Object o)
        {
            if (o instanceof TradingSystem)
            {
                TradingSystem object = (TradingSystem) o;
                TreeItem[] items = getItems();
                for (int i = 0; i < items.length; i++)
                {
                    if (!(items[i] instanceof TradingSystemItem))
                        continue;
                    if (((TradingSystemItem) items[i]).getSystem().equals(object))
                        items[i].dispose();
                }
            }
            else if (o instanceof TradingSystemGroup)
            {
                TradingSystemGroup object = (TradingSystemGroup) o;
                TreeItem[] items = getItems();
                for (int i = 0; i < items.length; i++)
                {
                    if (!(items[i] instanceof GroupTreeItem))
                        continue;
                    if (((GroupTreeItem) items[i]).getGroup().equals(object))
                        items[i].dispose();
                }
            }
        }

        /* (non-Javadoc)
         * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
         */
        public void update(Observable o, Object arg)
        {
            getDisplay().asyncExec(new Runnable() {
                public void run()
                {
                    if (!isDisposed())
                        setText(0, group.getDescription());
                }
            });
        }

        public TradingSystemGroup getGroup()
        {
            return group;
        }
    }
    
    public class TradingSystemItem extends TreeItem implements Observer
    {
        TradingSystem system;
        TradingSystemPlugin plugin;

        public TradingSystemItem(TradingSystem system, Tree parent, int style, int index)
        {
            super(parent, style, index);
            init(system);
        }

        public TradingSystemItem(TradingSystem system, Tree parent, int style)
        {
            super(parent, style);
            init(system);
        }

        public TradingSystemItem(TradingSystem system, TreeItem parentItem, int style, int index)
        {
            super(parentItem, style, index);
            init(system);
        }

        public TradingSystemItem(TradingSystem system, TreeItem parentItem, int style)
        {
            super(parentItem, style);
            init(system);
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.widgets.TreeItem#checkSubclass()
         */
        protected void checkSubclass()
        {
        }
        
        private void init(TradingSystem system)
        {
            this.system = system;
            this.system.addObserver(this);

            plugin = TradingPlugin.createTradingSystemPlugin(system);
            plugin.addObserver(this);
            
            addDisposeListener(new DisposeListener() {
                public void widgetDisposed(DisposeEvent e)
                {
                    TradingSystemItem.this.system.deleteObserver(TradingSystemItem.this);
                    TradingSystemItem.this.plugin.deleteObserver(TradingSystemItem.this);
                }
            });

            setText(0, system.getSecurity().getDescription());
            setText(1, system.getAccount().getDescription());
            setText(2, String.valueOf(system.getAccount().getPosition(system.getSecurity())));
            if (system.getSignal() == TradingSystem.SIGNAL_BUY)
                setText(3, "Buy");
            else if (system.getSignal() == TradingSystem.SIGNAL_SELL)
                setText(3, "Sell");
            else if (system.getSignal() == TradingSystem.SIGNAL_HOLD)
                setText(3, "Hold");
            else
                setText(3, "");
            setText(4, system.getDate() != null ? dateFormat.format(system.getDate()) : "");
        }

        /* (non-Javadoc)
         * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
         */
        public void update(Observable o, Object arg)
        {
            if (o == plugin)
            {
                system.setDate(Calendar.getInstance().getTime());
                system.setSignal(plugin.getSignal());
            }

            getDisplay().asyncExec(new Runnable() {
                public void run()
                {
                    if (!isDisposed())
                    {
                        setText(0, system.getSecurity().getDescription());
                        setText(1, system.getAccount().getDescription());
                        setText(2, String.valueOf(system.getAccount().getPosition(system.getSecurity())));
                        if (system.getSignal() == TradingSystem.SIGNAL_BUY)
                            setText(3, "Buy");
                        else if (system.getSignal() == TradingSystem.SIGNAL_SELL)
                            setText(3, "Sell");
                        else if (system.getSignal() == TradingSystem.SIGNAL_HOLD)
                            setText(3, "Hold");
                        else
                            setText(3, "");
                        setText(4, system.getDate() != null ? dateFormat.format(system.getDate()) : "");
                    }
                }
            });
        }

        public TradingSystem getSystem()
        {
            return system;
        }
    }

    public class TradingSystemTreeItemTransfer extends ByteArrayTransfer
    {
        private final String TYPENAME = TradingSystemItem.class.getName();
        private final int TYPEID = registerType(TYPENAME);

        private TradingSystemTreeItemTransfer()
        {
        }
        
        /* (non-Javadoc)
         * @see org.eclipse.swt.dnd.Transfer#getTypeNames()
         */
        protected String[] getTypeNames()
        {
            return new String[] { TYPENAME };
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.dnd.Transfer#getTypeIds()
         */
        protected int[] getTypeIds()
        {
            return new int[] { TYPEID };
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.dnd.ByteArrayTransfer#javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData)
         */
        protected void javaToNative(Object object, TransferData transferData)
        {
            if (!checkMyType(object) || !isSupportedType(transferData))
                DND.error(DND.ERROR_INVALID_DATA);

            try
            {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                ObjectOutputStream writeOut = new ObjectOutputStream(out);
                
                if (object instanceof TradingSystemItem)
                {
                    writeOut.writeInt(1);
                    writeOut.writeObject(((TradingSystemItem)object).getSystem().getId());
                }
                else if (object instanceof TradingSystemItem[])
                {
                    TradingSystemItem[] array = (TradingSystemItem[]) object;
                    writeOut.writeInt(array.length);
                    for (int i = 0; i < array.length; i++)
                        writeOut.writeObject(array[i].getSystem().getId());
                }
                
                byte[] buffer = out.toByteArray();
                writeOut.close();
                super.javaToNative(buffer, transferData);
            }
            catch (IOException e) {
                CorePlugin.logException(e);
            }
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.dnd.ByteArrayTransfer#nativeToJava(org.eclipse.swt.dnd.TransferData)
         */
        protected Object nativeToJava(TransferData transferData)
        {
            if (isSupportedType(transferData))
            {
                byte[] buffer = (byte[]) super.nativeToJava(transferData);
                if (buffer == null)
                    return null;

                try
                {
                    ByteArrayInputStream in = new ByteArrayInputStream(buffer);
                    ObjectInputStream readIn = new ObjectInputStream(in);

                    int length = readIn.readInt();
                    Integer[] security = new Integer[length];
                    for (int i = 0; i < length; i++)
                        security[i] = (Integer)readIn.readObject();
                    
                    readIn.close();
                    return security;
                }
                catch (Exception e) {
                    CorePlugin.logException(e);
                }
            }

            return null;
        }

        private boolean checkMyType(Object object)
        {
            return (object instanceof TradingSystemItem || object instanceof TradingSystemItem[]);
        }
    }
}