level2view.java

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

        if (security.getLow() != null)
            low.setText(priceFormatter2.format(security.getLow()));
        info.layout(true, true);
    }
    
    void updateTable()
    {
        int bidLevel = -1, askLevel = -1;
        String bidValue = "", askValue = "";
        Level2TableItem tableItem = null;
        
        List bid = new ArrayList();
        if (security.getLevel2Bid() != null)
        {
            if (groupPrices)
                bid = security.getLevel2Bid().getGrouped();
            else
                bid = security.getLevel2Bid().getList();
        }
        List ask = new ArrayList();
        if (security.getLevel2Ask() != null)
        {
            if (groupPrices)
                ask = security.getLevel2Ask().getGrouped();
            else
                ask = security.getLevel2Ask().getList();
        }

        int total = Math.max(bid.size(), ask.size());
        for (int index = 0; index < total; index++)
        {
            if (index < table.getItemCount())
                tableItem = (Level2TableItem)table.getItem(index);
            else
                tableItem = new Level2TableItem(table, SWT.NONE);
            
            if (index < bid.size())
            {
                Level2.Item item = (Level2.Item)bid.get(index);
                String price = priceFormatter.format(item.price);
                String number = numberFormatter.format(item.number);
                String quantity = numberFormatter.format(item.quantity);
                tableItem.setText(1, number);
                tableItem.setText(2, quantity);
                tableItem.setText(3, price);
                
                if (!tableItem.getText(3).equals(bidValue))
                {
                    bidLevel++;
                    bidValue = tableItem.getText(3);
                }
                if (colorLevels && bidLevel < bandBackground.length)
                {
                    tableItem.setForeground(1, bandForeground[bidLevel]);
                    tableItem.setBackground(1, bandBackground[bidLevel]);
                    tableItem.setForeground(2, bandForeground[bidLevel]);
                    tableItem.setBackground(2, bandBackground[bidLevel]);
                    tableItem.setForeground(3, bandForeground[bidLevel]);
                    tableItem.setBackground(3, bandBackground[bidLevel]);
                }
                else
                {
                    tableItem.setForeground(1, null);
                    tableItem.setBackground(1, background);
                    tableItem.setForeground(2, null);
                    tableItem.setBackground(2, background);
                    tableItem.setForeground(3, null);
                    tableItem.setBackground(3, background);
                }
            }
            else
            {
                tableItem.setText(1, "");
                tableItem.setText(2, "");
                tableItem.setText(3, "");
                tableItem.setBackground(1, emptyBackground);
                tableItem.setBackground(2, emptyBackground);
                tableItem.setBackground(3, emptyBackground);
            }
            
            if (index < ask.size())
            {
                Level2.Item item = (Level2.Item)ask.get(index);
                tableItem.setText(4, priceFormatter.format(item.price));
                tableItem.setText(5, numberFormatter.format(item.quantity));
                tableItem.setText(6, numberFormatter.format(item.number));
                if (!tableItem.getText(4).equals(askValue))
                {
                    askLevel++;
                    askValue = tableItem.getText(4);
                }
                if (colorLevels && askLevel < bandBackground.length)
                {
                    tableItem.setForeground(4, bandForeground[askLevel]);
                    tableItem.setBackground(4, bandBackground[askLevel]);
                    tableItem.setForeground(5, bandForeground[askLevel]);
                    tableItem.setBackground(5, bandBackground[askLevel]);
                    tableItem.setForeground(6, bandForeground[askLevel]);
                    tableItem.setBackground(6, bandBackground[askLevel]);
                }
                else
                {
                    tableItem.setForeground(4, null);
                    tableItem.setBackground(4, background);
                    tableItem.setForeground(5, null);
                    tableItem.setBackground(5, background);
                    tableItem.setForeground(6, null);
                    tableItem.setBackground(6, background);
                }
            }
            else
            {
                tableItem.setText(4, "");
                tableItem.setText(5, "");
                tableItem.setText(6, "");
                tableItem.setBackground(4, emptyBackground);
                tableItem.setBackground(5, emptyBackground);
                tableItem.setBackground(6, emptyBackground);
            }
        }
        
        while(table.getItemCount() > total)
            table.getItem(total).dispose();
        
        if (security.getLevel2Bid() != null && security.getLevel2Ask() != null)
            trendbar.setData(security.getLevel2Bid(), security.getLevel2Ask());

        updateColumnWidth();
    }
    
    /**
     * Adapt the columns width to the extents of the contained text.
     */
    void updateColumnWidth()
    {
        GC gc = new GC(table);
        
        // Get the maximum extent of the column headers
        int c1 = Math.max(gc.textExtent(table.getColumn(1).getText()).x, gc.textExtent(table.getColumn(6).getText()).x);
        int c2 = Math.max(gc.textExtent(table.getColumn(2).getText()).x, gc.textExtent(table.getColumn(5).getText()).x);
        int c3 = Math.max(gc.textExtent(table.getColumn(3).getText()).x, gc.textExtent(table.getColumn(4).getText()).x);

        // Get the maximum extent of all items
        TableItem[] items = table.getItems();
        for (int i = 0; i < items.length; i++)
        {
            c1 = Math.max(c1, Math.max(gc.textExtent(items[i].getText(1)).x, gc.textExtent(items[i].getText(6)).x));
            c2 = Math.max(c2, Math.max(gc.textExtent(items[i].getText(2)).x, gc.textExtent(items[i].getText(5)).x));
            c3 = Math.max(c3, Math.max(gc.textExtent(items[i].getText(3)).x, gc.textExtent(items[i].getText(4)).x));
        }
        
        // Adds a border
        c1 += 12;
        c2 += 12;
        c3 += 12;

        gc.dispose();

        // Calculates the ratio of columns 1 and 2 based on the total width
        double columnsWidth = c1 + c2 + c3;
        double r1 = c1 / columnsWidth;
        double r2 = c2 / columnsWidth;

        // Get the pixel width based on the table size and the columns ratio
        int width = table.getClientArea().width;
        c1 = (int) ((width / 2) * r1);
        c2 = (int) ((width / 2) * r2);
        int c3a = (width / 2) - c1 - c2;
        int c3b = width - (c1 + c2 + c3a + c2 + c1);

        // Set the columns size only if necessary
        if (table.getColumn(1).getWidth() != c1)
            table.getColumn(1).setWidth(c1);
        if (table.getColumn(2).getWidth() != c2)
            table.getColumn(2).setWidth(c2);
        if (table.getColumn(3).getWidth() != c3a)
            table.getColumn(3).setWidth(c3a);
        if (table.getColumn(4).getWidth() != c3b)
            table.getColumn(4).setWidth(c3b);
        if (table.getColumn(5).getWidth() != c2)
            table.getColumn(5).setWidth(c2);
        if (table.getColumn(6).getWidth() != c1)
            table.getColumn(6).setWidth(c1);
    }
    
    public boolean getGroupPrices()
    {
        return groupPrices;
    }
    
    public void setGroupPrices(boolean groupPrices)
    {
        this.groupPrices = groupPrices;
        updateTable();
    }

    public boolean getColorLevels()
    {
        return colorLevels;
    }

    public void setColorLevels(boolean colorLevels)
    {
        this.colorLevels = colorLevels;
        updateTable();
    }

    /* (non-Javadoc)
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void update(Observable o, Object arg)
    {
        if (o == security.getLevel2Monitor())
        {
            if (!tableUpdaterScheduled)
            {
                table.getDisplay().asyncExec(new Runnable() {
                    public void run()
                    {
                        if (!table.isDisposed())
                            table.getDisplay().timerExec(UPDATE_DELAY, tableUpdater);
                    }
                });
                tableUpdaterScheduled = true;
            }
        }
        else
        {
            if (!infoUpdaterScheduled)
            {
                info.getDisplay().asyncExec(infoUpdater);
                infoUpdaterScheduled = true;
            }
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
     */
    public void selectionChanged(IWorkbenchPart part, ISelection selection)
    {
        if (followSelection)
        {
            if (selection instanceof SecuritySelection)
                setSecurity(((SecuritySelection) selection).getSecurity());
        }
    }

    public boolean isFollowSelection()
    {
        return followSelection;
    }

    public void setFollowSelection(boolean followSelection)
    {
        this.followSelection = followSelection;
    }
    
    private class Level2TableItem extends TableItem implements DisposeListener
    {
        private CellTicker ticker;

        public Level2TableItem(Table parent, int style, int index)
        {
            super(parent, style, index);
            ticker = new CellTicker(this, CellTicker.BACKGROUND|CellTicker.FOREGROUND);
            addDisposeListener(this);
        }

        public Level2TableItem(Table parent, int style)
        {
            super(parent, style);
            ticker = new CellTicker(this, CellTicker.BACKGROUND|CellTicker.FOREGROUND);
            addDisposeListener(this);
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.widgets.TableItem#checkSubclass()
         */
        protected void checkSubclass()
        {
        }
        
        public CellTicker getCellTicker()
        {
            return ticker;
        }

        /* (non-Javadoc)
         * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
         */
        public void widgetDisposed(DisposeEvent e)
        {
            ticker.dispose();
        }
    }
}