tradingsystemview.java

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

        column = new TreeColumn(tree, SWT.LEFT);
        column.setText("Signal");
        layout.addColumnData(new ColumnPixelData(60, true, false));
        column = new TreeColumn(tree, SWT.RIGHT);
        column.setText("Date");
        layout.addColumnData(new ColumnPixelData(60, true, true));

        getSite().setSelectionProvider(new SelectionProvider());

        DragSource dragSource = new DragSource(tree, DND.DROP_COPY|DND.DROP_MOVE);
        dragSource.setTransfer(new Transfer[] { _tradingSystemTreeItemTransfer });
        dragSource.addDragListener(new DragSourceListener() {
            private TreeItem[] selection;

            public void dragStart(DragSourceEvent event)
            {
                selection = tree.getSelection();
                if (selection.length == 0)
                    event.doit = false;
            }

            public void dragSetData(DragSourceEvent event)
            {
                int count = 0;

                for (int i = 0; i < selection.length; i++)
                {
                    if (selection[i] instanceof TradingSystemItem)
                        count++;
                }
                
                TradingSystemItem[] items = new TradingSystemItem[count];
                count = 0;
                for (int i = 0; i < selection.length; i++)
                {
                    if (selection[i] instanceof TradingSystemItem)
                        items[count++] = (TradingSystemItem)selection[i]; 
                }
                event.data = items;
            }

            public void dragFinished(DragSourceEvent event)
            {
            }
        });
        DropTarget target = new DropTarget(parent, DND.DROP_COPY|DND.DROP_MOVE);
        target.setTransfer(new Transfer[] { _tradingSystemTreeItemTransfer });
        target.addDropListener(new DropTargetListener() {
            public void dragEnter(DropTargetEvent event)
            {
                if (event.detail == DND.DROP_DEFAULT)
                    event.detail = DND.DROP_COPY;
            
                event.currentDataType = null;
                
                TransferData[] data = event.dataTypes;
                for (int i = 0; i < data.length; i++)
                {
                    if (_tradingSystemTreeItemTransfer.isSupportedType(data[i]))
                    {
                        event.currentDataType = data[i];
                        break;
                    }
                }
            }

            public void dragOver(DropTargetEvent event)
            {
                event.feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_SCROLL;

                TreeItem treeItem = tree.getItem(tree.toControl(event.x, event.y));
                if (treeItem != null)
                {
                    TreeItem[] selection = { treeItem };
                    tree.setSelection(selection);
                }
            }

            public void dragOperationChanged(DropTargetEvent event)
            {
            }

            public void dragLeave(DropTargetEvent event)
            {
            }

            public void dropAccept(DropTargetEvent event)
            {
            }

            public void drop(DropTargetEvent event)
            {
                if (_tradingSystemTreeItemTransfer.isSupportedType(event.currentDataType))
                {
                    Integer[] items = (Integer[]) event.data;
                    if (items != null)
                    {
                        TradingSystemGroup group = null;
                        TreeItem treeItem = tree.getItem(tree.toControl(event.x, event.y));
                        if (treeItem != null)
                        {
                            if (treeItem instanceof GroupTreeItem)
                                group = ((GroupTreeItem)treeItem).getGroup();
                            else if (treeItem instanceof TradingSystemItem)
                                group = ((TradingSystemItem)treeItem).getSystem().getGroup();
                        }
                        for (int i = 0; i < items.length; i++)
                        {
                            TradingSystem system = (TradingSystem) CorePlugin.getRepository().load(TradingSystem.class, items[i]);
                            CorePlugin.getRepository().delete(system);
                            system.setGroup(group);
                            CorePlugin.getRepository().save(system);
                        }
                    }
                }
            }
        });

        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(new Separator("internal.top")); //$NON-NLS-1$
                menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); //$NON-NLS-1$
                menuManager.add(new Separator("clipboard.top")); //$NON-NLS-1$
                menuManager.add(new Separator("clipboard.bottom")); //$NON-NLS-1$
                menuManager.add(new Separator("bottom")); //$NON-NLS-1$
                menuManager.add(new Separator("internal.bottom")); //$NON-NLS-1$

                menuManager.appendToGroup("internal.top", createGroupAction);
                menuManager.appendToGroup("internal.top", createSystemAction);
                menuManager.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, runTestAction);
                menuManager.appendToGroup("clipboard.bottom", deleteAction);
                menuManager.appendToGroup("internal.bottom", propertiesAction);
            }
        });
        tree.setMenu(menuMgr.createContextMenu(tree));
        getSite().registerContextMenu(menuMgr, getSite().getSelectionProvider());

        IActionBars actionBars = getViewSite().getActionBars();
        actionBars.setGlobalActionHandler("delete", deleteAction);
        actionBars.setGlobalActionHandler("properties", propertiesAction);
        
        IPreferenceStore preferenceStore = TradingPlugin.getDefault().getPreferenceStore();
        String[] values = preferenceStore.getString("TS_VIEW_EXPANDED_ITEMS").split(";");
        for (int i = 0; i < values.length; i++)
            expandMap.put(values[i], new Boolean(true));

        parent.getDisplay().asyncExec(new Runnable() {
            public void run()
            {
                updateView();
                updateSelection();
                CorePlugin.getRepository().getTradingSystemGroups().addCollectionObserver(TradingSystemView.this);
                CorePlugin.getRepository().getTradingSystems().addCollectionObserver(TradingSystemView.this);
            }
        });
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
     */
    public void setFocus()
    {
        tree.getParent().setFocus();
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#dispose()
     */
    public void dispose()
    {
        StringBuffer sb = new StringBuffer();
        for (Iterator iter = expandMap.keySet().iterator(); iter.hasNext(); )
        {
            if (sb.length() != 0)
                sb.append(";");
            sb.append((String)iter.next());
        }
        TradingPlugin.getDefault().getPreferenceStore().setValue("TS_VIEW_EXPANDED_ITEMS", sb.toString());

        CorePlugin.getRepository().getTradingSystemGroups().removeCollectionObserver(this);
        CorePlugin.getRepository().getTradingSystems().removeCollectionObserver(this);
        
        super.dispose();
    }

    private void updateView()
    {
        tree.setRedraw(false);
        tree.removeAll();
        
        for (Iterator iter = CorePlugin.getRepository().getTradingSystemGroups().iterator(); iter.hasNext(); )
        {
            TradingSystemGroup group = (TradingSystemGroup) iter.next();
            if (group.getParent() == null)
                new GroupTreeItem(group, tree, SWT.NONE);
        }
        
        for (Iterator iter = CorePlugin.getRepository().getTradingSystems().iterator(); iter.hasNext(); )
        {
            TradingSystem system = (TradingSystem) iter.next();
            if (system.getGroup() == null)
                new TradingSystemItem(system, tree, SWT.NONE);
        }
        
        tree.setRedraw(true);

        int index = 0;
        TreeItem[] items = tree.getItems();
        for (int i = 0; i < items.length; i++)
            index = updateItemColors(items[i], index);
    }
    
    private void updateSelection()
    {
        TreeItem[] selection = tree.getSelection();
        if (selection != null && selection.length == 1)
        {
            if (selection[0] instanceof TradingSystemItem)
                getSite().getSelectionProvider().setSelection(new TradingSystemSelection(((TradingSystemItem) selection[0]).getSystem()));
            else if (selection[0] instanceof GroupTreeItem)
                getSite().getSelectionProvider().setSelection(new TradingSystemGroupSelection(((GroupTreeItem) selection[0]).getGroup()));
            else
                getSite().getSelectionProvider().setSelection(new NullSelection());
        }
        else
            getSite().getSelectionProvider().setSelection(new NullSelection());
        
        deleteAction.setEnabled(selection.length != 0);
        runTestAction.setEnabled(selection.length == 1);
        propertiesAction.setEnabled(selection.length == 1);
    }

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

    /* (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 = tree.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 = tree.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();
            }
        }
        updateItemColors();
    }
    
    private void updateItemColors()
    {
        tree.getDisplay().asyncExec(new Runnable() {
            public void run()
            {
                if (!tree.isDisposed())
                {
                    int index = 0;
                    TreeItem[] items = tree.getItems();
                    for (int i = 0; i < items.length; i++)
                        index = updateItemColors(items[i], index);
                }
            }
        });
    }
    
    private int updateItemColors(TreeItem treeItem, int index)
    {
        treeItem.setBackground((index & 1) == 0 ? evenBackground : oddBackground);
        treeItem.setForeground((index & 1) == 0 ? evenForeground : oddForeground);
        index++;

        if (treeItem instanceof GroupTreeItem)
        {
            if (expandMap.get(String.valueOf(((GroupTreeItem)treeItem).getGroup().getId())) != null)
                treeItem.setExpanded(true);
        }
        
        if (treeItem.getExpanded())
        {
            TreeItem[] items = treeItem.getItems();
            for (int i = 0; i < items.length; i++)
                index = updateItemColors(items[i], index);
        }
        
        return index;
    }

    public class GroupTreeItem extends TreeItem implements ICollectionObserver, Observer
    {
        TradingSystemGroup group;