accountsview.java

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

        }

        public AccountTreeItem(Account account, Tree parent, int style)
        {
            super(parent, style);
            init(account);
        }

        public AccountTreeItem(Account account, TreeItem parentItem, int style, int index)
        {
            super(parentItem, style, index);
            init(account);
        }

        public AccountTreeItem(Account account, TreeItem parentItem, int style)
        {
            super(parentItem, style);
            init(account);
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.widgets.TreeItem#checkSubclass()
         */
        protected void checkSubclass()
        {
        }
        
        private void init(Account account)
        {
            this.account = account;
            
            setText(account.getDescription());
            if (account.getCurrency() != null)
                setText(1, account.getCurrency().getSymbol() + " " + nf.format(account.getBalance()));
            else
                setText(1, nf.format(account.getBalance()));
            setData(account);

            account.addObserver(this);
            addDisposeListener(new DisposeListener() {
                public void widgetDisposed(DisposeEvent e)
                {
                    AccountTreeItem.this.account.deleteObserver(AccountTreeItem.this);
                }
            });
        }
        
        public Account getAccount()
        {
            return account;
        }

        /* (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(account.getDescription());
                        if (account.getCurrency() != null)
                            setText(1, account.getCurrency().getSymbol() + " " + nf.format(account.getBalance()));
                        else
                            setText(1, nf.format(account.getBalance()));
                    }
                }
            });
        }
    }
    
    private class GroupTreeItem extends TreeItem implements ICollectionObserver, Observer
    {
        private AccountGroup group;

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

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

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

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

        /* (non-Javadoc)
         * @see org.eclipse.swt.widgets.TreeItem#checkSubclass()
         */
        protected void checkSubclass()
        {
        }
        
        private void init(AccountGroup group)
        {
            this.group = group;
            
            FontData fd = getFont().getFontData()[0];
            Font font = new Font(null, fd.getName(), fd.getHeight(), SWT.BOLD);
            setFont(font);
            
            setText(group.getDescription());
            setData(group);

            List list = group.getGroups();
            Collections.sort(list, groupComparator);
            for (Iterator iter = list.iterator(); iter.hasNext(); )
            {
                AccountGroup grp = (AccountGroup)iter.next();
                new GroupTreeItem(grp, this, SWT.NONE);
            }

            list = group.getAccounts();
            Collections.sort(list, accountComparator);
            for (Iterator iter = list.iterator(); iter.hasNext(); )
            {
                Account account = (Account)iter.next();
                new AccountTreeItem(account, this, SWT.NONE);
            }
            
            group.addObserver(this);
            group.getGroups().addCollectionObserver(this);
            group.getAccounts().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.getAccounts().removeCollectionObserver(GroupTreeItem.this);
                }
            });
        }
        
        public AccountGroup getGroup()
        {
            return group;
        }

        /* (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(group.getDescription());
                }
            });
        }

        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemAdded(java.lang.Object)
         */
        public void itemAdded(Object o)
        {
            if (o instanceof Account)
            {
                Account account = (Account)o;

                TreeItem items[] = getItems();
                for (int i = 0; i < items.length; i++)
                {
                    if (!(items[i].getData() instanceof Account))
                        continue;
                    Account arg1 = (Account)items[i].getData();
                    if (accountComparator.compare(account, arg1) < 0)
                    {
                        new AccountTreeItem(account, this, SWT.NONE, i);
                        updateItemColors();
                        updateSelection();
                        return;
                    }
                }
                
                new AccountTreeItem(account, this, SWT.NONE);
                updateItemColors();
            }
            else if (o instanceof AccountGroup)
            {
                AccountGroup group = (AccountGroup)o;

                TreeItem items[] = getItems();
                for (int i = 0; i < items.length; i++)
                {
                    if (!(items[i].getData() instanceof AccountGroup))
                    {
                        new GroupTreeItem((AccountGroup)o, this, SWT.NONE, i);
                        return;
                    }
                    AccountGroup arg1 = (AccountGroup)items[i].getData();
                    if (groupComparator.compare(group, arg1) < 0)
                    {
                        new GroupTreeItem(group, this, SWT.NONE, i);
                        updateItemColors();
                        updateSelection();
                        return;
                    }
                }
                
                new GroupTreeItem(group, this, SWT.NONE);
                updateItemColors();
            }
        }

        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemRemoved(java.lang.Object)
         */
        public void itemRemoved(Object o)
        {
            TreeItem[] items = getItems();
            for (int i = 0; i < items.length; i++)
            {
                if (o.equals(items[i].getData()))
                    items[i].dispose();
            }
            updateItemColors();
        }
    }

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

        private AccountTreeItemTransfer()
        {
        }
        
        /* (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 AccountTreeItem)
                {
                    writeOut.writeInt(1);
                    writeOut.writeObject(((AccountTreeItem)object).getAccount().getId());
                }
                else if (object instanceof AccountTreeItem[])
                {
                    AccountTreeItem[] array = (AccountTreeItem[]) object;
                    writeOut.writeInt(array.length);
                    for (int i = 0; i < array.length; i++)
                        writeOut.writeObject(array[i].getAccount().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 AccountTreeItem || object instanceof AccountTreeItem[]);
        }
    }
}