ordersview.java

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

        
        CTabItem item = tabFolder.getSelection();
        if (item != null)
        {
            Table table = (Table)item.getControl();
            int[] selection = table.getSelectionIndices();
            OrdersTable ordersTable = (OrdersTable)table.getData();
            for (int i = 0; i < selection.length; i++)
                orders.add(ordersTable.list.get(selection[i]));
        }
        
        return (Order[])orders.toArray(new Order[orders.size()]);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
     */
    public void propertyChange(PropertyChangeEvent event)
    {
        if (event.getProperty().equals("ORDERSVIEW_COLUMNS"))
        {
            all.updateTable();
            pending.updateTable();
            filled.updateTable();
            canceled.updateTable();
            rejected.updateTable();
        }
    }

    class OrdersTable implements ICollectionObserver, Observer
    {
        Table table;
        List filter = new ArrayList();
        List list = new ArrayList();
        Comparator comparator = new Comparator() {
            public int compare(Object arg0, Object arg1)
            {
                return ((Order)arg1).getDate().compareTo(((Order)arg0).getDate());
            }
        };

        public OrdersTable(Composite parent, List filter)
        {
            this.filter = filter;

            table = new Table(parent, SWT.MULTI|SWT.FULL_SELECTION);
            table.setHeaderVisible(true);
            table.setLinesVisible(false);
            table.addDisposeListener(new DisposeListener() {
                public void widgetDisposed(DisposeEvent e)
                {
                    CorePlugin.getRepository().allOrders().removeCollectionObserver(OrdersTable.this);
                    for (Iterator iter = list.iterator(); iter.hasNext(); )
                    {
                        Order order = (Order)iter.next();
                        order.deleteObserver(OrdersTable.this);
                    }
                }
            });
            table.addSelectionListener(new SelectionAdapter() {
                public void widgetSelected(SelectionEvent e)
                {
                    updateActionsEnablement();
                }
            });
            table.setData(this);

            MenuManager menuMgr = new MenuManager("#popupMenu", "popupMenu"); //$NON-NLS-1$ //$NON-NLS-2$
            menuMgr.setRemoveAllWhenShown(true);
            menuMgr.addMenuListener(new IMenuListener() {
                public void menuAboutToShow(IMenuManager menuManager)
                {
                    menuManager.add(new Separator("top")); //$NON-NLS-1$
                    menuManager.add(cancelRequest);
                    menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
                    menuManager.add(deleteOrder);
                    menuManager.add(new Separator("bottom")); //$NON-NLS-1$
                }
            });
            table.setMenu(menuMgr.createContextMenu(table));
            getSite().registerContextMenu(menuMgr, getSite().getSelectionProvider());

            list = new ArrayList();
            Order[] orders = (Order[])CorePlugin.getRepository().allOrders().toArray(new Order[0]);
            for (int i = 0; i < orders.length; i++)
            {
                if (filter.size() == 0 || filter.contains(orders[i].getStatus()))
                    list.add(orders[i]);
            }
            Collections.sort(list, comparator);

            updateTable();
            CorePlugin.getRepository().allOrders().addCollectionObserver(this);
        }
        
        public Control getControl()
        {
            return table;
        }
        
        public void updateTable()
        {
            table.removeAll();
            for (int i = table.getColumnCount() - 1; i >= 0; i--)
                table.getColumn(i).dispose();
            
            String value = TradingPlugin.getDefault().getPreferenceStore().getString(PREFS_ORDERS_COLUMNS);
            String[] id = value.split(";");
            for (int i = 0; i < id.length; i++)
            {
                String name = "";
                int style = SWT.LEFT;
                Image image = null;

                ILabelProvider provider = registry.createLabelProvider(id[i]);
                if (provider != null)
                {
                    logger.debug("Adding column [" + id[i] + "]");
                    name = registry.getName(id[i]);
                    style = registry.getOrientation(id[i]);
                    
                    if (provider instanceof ITableLabelProvider)
                    {
                        name = ((ITableLabelProvider)provider).getColumnText(null, i);
                        image = ((ITableLabelProvider)provider).getColumnImage(null, i);
                    }
                }
                else
                    logger.warn("Cannot add column [" + id[i] + "]");

                TableColumn tableColumn = new TableColumn(table, style);
                tableColumn.setText(name);
                tableColumn.setImage(image);
                tableColumn.setData("labelProvider", provider);
                tableColumn.addControlListener(columnControlListener);
                tableColumn.addDisposeListener(new DisposeListener() {
                    public void widgetDisposed(DisposeEvent e)
                    {
                        if (e.widget.getData("labelProvider") != null)
                            ((ILabelProvider)e.widget.getData("labelProvider")).dispose();
                    }
                });
            }
            
            String[] sizes = TradingPlugin.getDefault().getPreferenceStore().getString(PREFS_COLUMNS_SIZE).split(";");
            for (int i = 0; i < table.getColumnCount(); i++)
            {
                if (i < sizes.length && sizes[i].length() != 0)
                    table.getColumn(i).setWidth(Integer.parseInt(sizes[i]));
                else
                    table.getColumn(i).setWidth(75);
            }

            for (Iterator iter = list.iterator(); iter.hasNext(); )
            {
                Order order = (Order)iter.next();
                TableItem tableItem = new TableItem(table, SWT.NONE);
                update(tableItem, order);
                order.addObserver(OrdersTable.this);
            }
            if ("gtk".equals(SWT.getPlatform()))
                table.getColumn(table.getColumnCount() - 1).pack();
        }
        
        public int indexOf(Order order)
        {
            return list.indexOf(order);
        }
        
        void update(TableItem tableItem, Order order)
        {
            for (int i = 0; i < table.getColumnCount(); i++)
            {
                TableColumn tableColumn = table.getColumn(i);
                ILabelProvider label = (ILabelProvider)tableColumn.getData("labelProvider");
                if (label != null)
                {
                    tableItem.setText(i, label.getText(order));
                    Image image = label.getImage(order);
                    if (image != tableItem.getImage(i))
                        tableItem.setImage(image);
                }
            }

            if (filter.size() == 0)
            {
                if (OrderStatus.PARTIAL.equals(order.getStatus()))
                    tableItem.setForeground(partialColor);
                else if (OrderStatus.FILLED.equals(order.getStatus()))
                    tableItem.setForeground(filledColor);
                else if (OrderStatus.CANCELED.equals(order.getStatus()))
                    tableItem.setForeground(canceledColor);
                else if (OrderStatus.REJECTED.equals(order.getStatus()))
                    tableItem.setForeground(rejectedColor);
                else
                    tableItem.setForeground(null);
            }
        }
        
        /* (non-Javadoc)
         * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
         */
        public void update(Observable o, Object arg)
        {
            final Order order = (Order)o;
            table.getDisplay().asyncExec(new Runnable() {
                public void run()
                {
                    int index = indexOf(order);
                    
                    if (index != -1 && !table.isDisposed())
                    {
                        TableItem tableItem = table.getItem(index);
                        if (filter.size() != 0 && !filter.contains(order.getStatus()))
                        {
                            tableItem.dispose();
                            list.remove(order);
                        }
                        else
                            update(tableItem, order);
                    }
                    
                    if (filter.size() == 0)
                    {
                        if (OrderStatus.FILLED.equals(order.getStatus()))
                        {
                            if (filled.list.indexOf(order) == -1)
                                filled.itemAdded(order);
                        }
                        else if (OrderStatus.CANCELED.equals(order.getStatus()))
                        {
                            if (canceled.list.indexOf(order) == -1)
                                canceled.itemAdded(order);
                        }
                        else if (OrderStatus.REJECTED.equals(order.getStatus()))
                        {
                            if (rejected.list.indexOf(order) == -1)
                                rejected.itemAdded(order);
                        }
                        else
                        {
                            if (pending.list.indexOf(order) == -1)
                                pending.itemAdded(order);
                        }
                    }

                    if ("gtk".equals(SWT.getPlatform()))
                        table.getColumn(table.getColumnCount() - 1).pack();
                }
            });
        }
        
        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemAdded(java.lang.Object)
         */
        public void itemAdded(Object o)
        {
            final Order order = (Order)o;

            if (filter.size() == 0 || filter.contains(order.getStatus()))
            {
                list.add(order);
                Collections.sort(list, comparator);
                
                table.getDisplay().asyncExec(new Runnable() {
                    public void run()
                    {
                        if (!table.isDisposed())
                        {
                            TableItem tableItem = new TableItem(table, SWT.NONE, list.indexOf(order));
                            table.showItem(tableItem);

                            update(tableItem, order);
                            order.addObserver(OrdersTable.this);

                            if ("gtk".equals(SWT.getPlatform()))
                                table.getColumn(table.getColumnCount() - 1).pack();
                        }
                    }
                });
            }
        }

        /* (non-Javadoc)
         * @see net.sourceforge.eclipsetrader.core.ICollectionObserver#itemRemoved(java.lang.Object)
         */
        public void itemRemoved(Object o)
        {
            final Order order = (Order)o;
            order.deleteObserver(OrdersTable.this);
            if (list.indexOf(o) != -1)
            {
                table.getDisplay().asyncExec(new Runnable() {
                    public void run()
                    {
                        int index = list.indexOf(order);
                        if (!table.isDisposed() && index != -1)
                        {
                            table.getItem(index).dispose();
                            list.remove(index);
                            if ("gtk".equals(SWT.getPlatform()))
                                table.getColumn(table.getColumnCount() - 1).pack();
                        }
                    }
                });
            }
        }
    }
}