entryeditor.java

基于Eclipse RCP开发的管理工具

                ActionFactory.DELETE.getId(), deleteAction);

        // magic to allow us to add popup action extensions in
        // plugin.xml
        MenuManager menuMgr = new MenuManager("#PopupMenu");

        // menuMgr.setRemoveAllWhenShown(false);
        // menuMgr.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));

        menuMgr
                .add(new CopyIdToClipboardAction(getSite().getWorkbenchWindow()));
        menuMgr.add(new CopyPasswordToClipboardAction(getSite()
                .getWorkbenchWindow()));
        menuMgr
                .add(new CopyUrlToClipboardAction(getSite()
                        .getWorkbenchWindow()));
        menuMgr.add(new OpenUrlAction(getSite().getWorkbenchWindow()));
        menuMgr.add(new Separator());

        assignToLabelMenu = new MenuManager("Assign label");
        menuMgr.add(assignToLabelMenu);

        removeLabelMenu = new MenuManager("Remove label(s)");
        menuMgr.add(removeLabelMenu);

        menuMgr.add(new Separator());
        menuMgr.add(new NewPasswordEntryAction(getSite().getWorkbenchWindow()));
        menuMgr.add(new NewLabelAction(getSite().getWorkbenchWindow()));
        menuMgr.add(new Separator());
        menuMgr
                .add(ActionFactory.DELETE
                        .create(getSite().getWorkbenchWindow()));

        Menu menu = menuMgr.createContextMenu(viewer.getControl());
        viewer.getControl().setMenu(menu);
        // getSite().registerContextMenu("myviewer.extensionpoint", menuMgr,
        // viewer);

        Platform.getAdapterManager().registerAdapters(adapterFactory,
                ManagerItem.class);

        managerItems.addObserver(this);
    }

    private void deleteLabel(ItemLabel label)
    {
        if (managerItems.labelInUse(label))
        {
            MessageDialog mb = new MessageDialog(
                    getSite().getShell(),
                    "Label deletion confirmation",
                    null,
                    "The label ("
                            + label.getName()
                            + ") is referenced by"
                            + " password entries. Deleting this label will remove these references. "
                            + " Continue deletion?", MessageDialog.QUESTION,
                    new String[] { IDialogConstants.YES_LABEL,
                            IDialogConstants.NO_LABEL }, 0);
            int ret = mb.open();
            if (ret == Window.OK)
            {
                managerItems.remove(label);
            }
        }
        else
        // label is not in use so just remove it
        {
            managerItems.remove(label);
        }
    }

    private void createTableViewer(Composite parent)
    {
        // FULL_SELECTION: select entire row, not individual column
        viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
                | SWT.V_SCROLL | SWT.FULL_SELECTION);

        final Table table = viewer.getTable();
        table.setHeaderVisible(true);

        Listener sortListener = new Listener()
        {
            public void handleEvent(Event event)
            {
                TableColumn column = (TableColumn) event.widget;
                String columnText = column.getText();
                System.out.println("SortListener: column text = " + columnText);

                int columnIndx = getColumnIdx(table, column);

                EntrySorter sorter = (EntrySorter) viewer.getSorter();

                int direction = SWT.DOWN;

                /*
                 * If the column selected is the column already sorted on, flip
                 * the sort direction.
                 */
                if (sorter != null && columnIndx == sorter.getColumnIndex())
                {
                    direction = (sorter.getDirection() == SWT.DOWN ? SWT.UP
                            : SWT.DOWN);
                }
                else
                {
                    // switch of sort column: always sort down
                }

                viewer.setSorter(new EntrySorter(columnIndx, direction));

                table.setSortDirection(direction);

                table.setSortColumn(column);
            }
        };

        TableColumn nameColumn = createColumn(table, sortListener, NAME_COLUMN,
                140);
        createColumn(table, sortListener, ID_COLUMN, 50);
        createColumn(table, sortListener, PASSWORD_COLUMN, 50);
        createColumn(table, sortListener, DESCRIPTION_COLUMN, 100);
        createColumn(table, sortListener, USAGE_CNT_COLUMN, 40);
        createColumn(table, sortListener, LAST_USED_COLUMN, 120);
        createColumn(table, sortListener, LAST_UPDATED_COLUMN, 120);
        createColumn(table, sortListener, LAST_UPDATED_ON_SITE_COLUMN, 120);
        createColumn(table, sortListener, URL_COLUMN, 120);
        createColumn(table, sortListener, LABELS_COLUMN, 120);

        // default to sorting on the name column
        table.setSortColumn(nameColumn);
        table.setSortDirection(SWT.DOWN);
        viewer.setSorter(new EntrySorter(0, SWT.DOWN));

        viewer.addSelectionChangedListener(new ISelectionChangedListener()
        {
            public void selectionChanged(SelectionChangedEvent event)
            {
                ISelection selection = event.getSelection();
                if (selection != null
                        && selection instanceof IStructuredSelection)
                {
                    updateTablePositionField();

                    updateAssignLabelMenu((IStructuredSelection) selection);
                    updateRemoveLabelMenu((IStructuredSelection) selection);
                }
            }

        });

        viewer.addDoubleClickListener(new IDoubleClickListener()
        {
            public void doubleClick(DoubleClickEvent event)
            {
                ISelection selection = event.getSelection();
                if (selection != null
                        && selection instanceof IStructuredSelection)
                {
                    Object item = ((IStructuredSelection) selection)
                            .getFirstElement();
                    if (item != null)
                    {
                        if (item instanceof PasswordEntry)
                        {
                            editPasswordEntry((PasswordEntry) item);
                        }
                        else if (item instanceof ItemLabel)
                        {
                            editItemLabel((ItemLabel) item);
                        }
                    }
                }

            }

        });

        viewerFilter = new MyViewerFilter();
        viewer.addFilter(viewerFilter);
    }

    protected void editPasswordEntry(final PasswordEntry item)
    {
        // TODO: remove duplication
        DuplicateChecker dupCheck = new DuplicateChecker()
        {
            public boolean exists(String name)
            {
                return managerItems.containsPasswordEntry(name)
                        && !name.equalsIgnoreCase(item.getName());
            }
        };

        // TODO: dialog needs to state edit, not create
        EditPasswordDialog dlg = new EditPasswordDialog(getSite().getShell(),
                dupCheck, DialogType.UPDATE);
        dlg.setEntry(item);
        // Note that the dialog will update the entry on OK so no need to do
        // anything here with the result of open()
        dlg.open();

    }

    protected void editItemLabel(final ItemLabel item)
    {
        // TODO: remove duplication
        DuplicateChecker dupCheck = new DuplicateChecker()
        {
            public boolean exists(String name)
            {
                return managerItems.containsLabel(name)
                        && !name.equalsIgnoreCase(item.getName());
            }
        };

        EditLabelDialog dlg = new EditLabelDialog(getSite().getShell(),
                dupCheck, DialogType.UPDATE);
        dlg.setEntry(item);
        // Note that the dialog will update the entry on OK so no need to do
        // anything here with the result of open()
        dlg.open();
    }

    /**
     * Updates the assign label by adding assign label actions to the popup menu
     * that are applicable to the selected password entries.
     * 
     * @param selection
     */
    protected void updateAssignLabelMenu(IStructuredSelection selection)
    {
        // determine the labels that are applicable to the selected items:
        // applicable labels are labels that are not assigned yet.
        // Since this may involve multiple selections, we need to take the
        // intersection of assigned labels for the selection and remove
        // these from the labels available in the editor.
        // (e.g. if all selected entries have a assignment of the "work" label
        // we can remove it from the assign menu).

        Set<ItemLabel> selectedItemLabelsIntersect = getSelectedLabelsIntersection(selection);

        List<ItemLabel> labels = managerItems.getLabels();
        labels.removeAll(selectedItemLabelsIntersect);

        assignToLabelMenu.removeAll();

        for (ItemLabel label : labels)
        {
            assignToLabelMenu.add(new AssignLabelAction(getSite()
                    .getWorkbenchWindow(), label));
        }
    }

    /**
     * Updates the remove label popup menu with the union of the labels assigned
     * to the selected password entries.
     * 
     * @param selection
     */
    protected void updateRemoveLabelMenu(IStructuredSelection selection)
    {
        Set<ItemLabel> labels = getSelectedLabelsUnion(selection);

        removeLabelMenu.removeAll();
        for (ItemLabel label : labels)
        {
            removeLabelMenu.add(new RemoveLabelAction(getSite()
                    .getWorkbenchWindow(), label));
        }

        // If the labels to select from is > 1, add a shortcut action to
        // remove all labels.
        if (labels.size() > 1)
        {
            removeLabelMenu.add(new RemoveAllLabelsAction(getSite()
                    .getWorkbenchWindow()));
        }
    }

    /**
     * Returns the union of the selected password entries' label references
     * 
     * @param selection
     */
    private Set<ItemLabel> getSelectedLabelsUnion(IStructuredSelection selection)
    {
        Set<ItemLabel> labels = new HashSet<ItemLabel>();

        for (Object item : selection.toArray())
        {
            if (item instanceof PasswordEntry)
            {
                PasswordEntry entry = (PasswordEntry) item;

                for (ItemLabel label : entry.getLabels())
                {
                    labels.add(label);
                }
            }
        }

        return labels;
    }

    private Set<ItemLabel> getSelectedLabelsIntersection(
            IStructuredSelection selection)
    {
        Set<ItemLabel> labelsIntersect = new HashSet<ItemLabel>();

        boolean firstEntry = true;
        for (Object item : selection.toArray())
        {
            if (item instanceof PasswordEntry)
            {
                PasswordEntry entry = (PasswordEntry) item;

                List<ItemLabel> labels = entry.getLabels();

                // start out with the set of labels of the first entry,
                // then keep
                if (firstEntry)
                {
                    labelsIntersect.addAll(labels);
                    firstEntry = false;
                }
                else
                {
                    labelsIntersect.retainAll(labels);
                }
            }

            // optimization to give up after the intersection reaches size 0
            if (labelsIntersect.size() == 0)
            {
                break;
            }
        }

        return labelsIntersect;
    }

    private static int getColumnIdx(Table table, TableColumn column)
    {
        TableColumn[] columns = table.getColumns();
        for (int i = 0; i < columns.length; i++)
        {
            if (columns[i] == column)
            {
                return i;
            }
        }
        throw new IllegalArgumentException("Can't find column: "
                + column.getText());
    }

    private TableColumn createColumn(Table table, Listener sortListener,
            String text, int width)
    {
        TableColumn column = new TableColumn(table, SWT.LEFT);
        column.setText(text);
        column.setWidth(width);
        column.setMoveable(true);

        column.addListener(SWT.Selection, sortListener);

        return column;
    }

    @Override
    public void dispose()
    {
        getSite().getWorkbenchWindow().getPartService().removePartListener(
                activationListener);
    }

    @Override
    public void setFocus()
    {
    }

    /**
     * Reacts to model changes by setting the editor dirty flag to true (making
     * sure changes will be notified to the user when the editor is closed) and
     * updating the table viewer with changes.
     * 
     * @param event
     */
    public void update(UpdateEvent event)
    {
        setDirty(true);

        switch (event.getType())
        {
            case ADD:
            {
                viewer.add(event.getTargetObject());
                break;
            }
            case ADD_ALL:
            {
                viewer.refresh();
                break;
            }
            case EDIT:
            {
                // labels can be used by other entries, so update the entire
                // list (label columns get refreshed to reflect the updated
                // label name
                if (event.getTargetObject() instanceof ItemLabel)