Java 类org.eclipse.ui.presentations.IPresentablePart 实例源码

/**
 * Called whenever a property changes for one of the parts in this
 * presentation.
 *
 * @param part
 * @param property
 */
protected void childPropertyChanged(IPresentablePart part, int property) {
    PartTab partTab = getTab(part);

    // If there is no tab for this part, just ignore the property change
    if (partTab == null) {
        return;
    }
    // no additional checks case is for "save all"
    partTab.refresh(property);
    switch (property) {
    case IPresentablePart.PROP_CONTENT_DESCRIPTION:
    case IPresentablePart.PROP_PART_NAME:
    case IPresentablePart.PROP_TITLE:
        setTitleText();
        break;
    default:
        break;
    }
}

private void rememberClosedPart(IPresentablePart oldPart) {
    if (isView()) {
        // XXX not supported yet
        return;
    }
    ClosedPart closedPart = createEmptyClosedPart(oldPart);
    boolean alreadyKnown = closedParts.contains(closedPart);
    if (alreadyKnown) {
        return;
    }
    if (tryToGetInput(closedPart, oldPart)) {
        closedParts.add(0, closedPart);
    } else {
        return;
    }

    Image titleImage = oldPart.getTitleImage();
    if (titleImage != null && !titleImage.isDisposed()) {
        // JFaceResources.getResources().createImageWithDefault(imageDescriptor);
        // The image from closed part will be disposed ASAP, so we need a backup here
        closedPart.image = new Image(getControl().getDisplay(), titleImage
                .getImageData());
    }
}

private boolean tryToGetInput(ClosedPart closedPart, IPresentablePart part) {
    IWorkbenchPartReference partReference = getPartReference(part);
    if(partReference == null){
        partReference = getMatchingPart(closedPart);
    }
    if(!(partReference instanceof IEditorReference)){
        return false;
    }
    // XXX probably this will init editor which is not initialized yet,
    // just before it will be closed....
    try {
        String id = partReference.getId();
        IEditorInput editorInput = ((IEditorReference)partReference).getEditorInput();
        closedPart.setEditorInfo(new EditorInfo(editorInput, id, getPartNumber(part)));
        return closedPart.getEditorInfo().isOpenable();
    } catch (PartInitException e) {
        PresentationPlugin.getDefault().getLog().log(
                new Status(IStatus.ERROR, "VSPresentation", 0,
                        "Could not get editor input for: " + closedPart.name, e));
    }
    return false;
}

public PartTab(final TabArea parent, int style, IPresentablePart part, boolean isView) {
    super(parent, style);
    cacheNoText = new Point(0, 0);
    tabArea = parent;
    this.part = part;
    this.boldSelected = ! isView;
    this.isView = isView;

    setToolTipText(tabArea.getPresentation().getPartTooltip(part));

    addDisposeListener(new DisposeListener() {
        public void widgetDisposed(DisposeEvent e) {
            parent.removeTab(PartTab.this);
        }
    });
    addPaintListener(this);
    themeChanged();
}

protected void saveList() {
    IPresentablePart[] partList = tabArea.getPartList();
    VSStackPresentation presentation = tabArea.getPresentation();
    List/*<EditorInfo>*/ infos = new ArrayList();
    for (int i = 0; i < partList.length; i++) {
        EditorInfo info = presentation.createEditorInfo(partList[i]);
        if(info != null){
            infos.add(info);
        }
    }
    if(infos.isEmpty()){
        // TODO show message
        return;
    }
    IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    InputDialog dialog = new InputDialog(window.getShell(), "Save session",
            "Enter session name", null, new SessionNameValidator(true));
    int result = dialog.open();
    if(result == Window.CANCEL){
        return;
    }
    Sessions.getInstance().createSession(dialog.getValue(), infos);
}

private String getLabel(IPresentablePart presentablePart) {
    if (showFullPath) {
        String text = presentablePart.getTitleToolTip();
        if (text == null || text.length() == 0) {
            text = presentablePart.getName();
        }
        if (presentablePart.isDirty()) {
            return PartTab.DIRTY_PREFIX + text;
        }
        return text;
    }
    if (presentablePart.isDirty()) {
        return PartTab.DIRTY_PREFIX + presentablePart.getName();
    }
    return presentablePart.getName();
}

public Font getFont(Object element) {
    IPresentablePart presentablePart = (IPresentablePart) element;
    PartTab partTab = tabArea.getTab(presentablePart);
    boolean visible = !partTab.isHidden();
    IPresentablePart selectedPart = tabArea.getSelectedPart();
    boolean isSelected = selectedPart == presentablePart;
    boolean showBold = isSelected || (visible && visibleTabsAreBold);

    if (!showBold) {
        return tabArea.getFont();
    }

    if (boldFont == null) {
        Control control = tabArea;
        Font originalFont = control.getFont();
        FontData fontData[] = originalFont.getFontData();
        // Adding the bold attribute
        for (int i = 0; i < fontData.length; i++) {
            fontData[i].setStyle(fontData[i].getStyle() | SWT.BOLD);
        }
        boldFont = new Font(control.getDisplay(), fontData);
    }
    return boldFont;
}

protected void gotoSelectedElement() {
    Object selectedElement = getSelectedElement();
    if (selectedElement == null) {
        if (!isPinned) {
            dispose();
        }
        return;
    }
    IStackPresentationSite stackPresentationSite = tabArea.getPresentation()
    .getSite();
    TabArea tabsArea = tabArea;
    IPresentablePart oldSelectedPart = tabsArea.getSelectedPart();
    IPresentablePart newSelectedPart = (IPresentablePart) selectedElement;
    //close the shell
    if (!isPinned) {
        dispose();
    }
    if (newSelectedPart == oldSelectedPart) {
        // part stack does not fire an event if the part is already selected,
        // but we should notify taberea if the *tab* for this part is not visible
        // and should be now shown
        tabsArea.selectPart(newSelectedPart);
    } else {
        stackPresentationSite.selectPart(newSelectedPart);
    }
}

/**
 * Delete all selected elements.
 *
 * @return <code>true</code> if there are no elements left after deletion.
 */
protected boolean deleteSelectedElements() {
    IStructuredSelection selection = getSelectedElements();
    if (selection != null) {
        ArrayList list = new ArrayList(selection.size());
        for (Iterator iterator = selection.iterator(); iterator.hasNext();) {
            IPresentablePart presentablePart = (IPresentablePart) iterator.next();
            list.add(presentablePart);
        }
        VSStackPresentation presentation = tabArea.getPresentation();
        presentation.close((IPresentablePart[]) list
                .toArray(new IPresentablePart[list.size()]));
        IPresentablePart[] partList = presentation.getSite().getPartList();
        if (partList == null || partList.length == 0) {
            dispose();
        }
        return true;
    }
    return false;
}

public void selectPart(IPresentablePart part) {
    initDone = true;
    if(PresentationPlugin.DEBUG_STATE) {
        System.out.println((presentation.isView()? "view" : "edit") + "Tabs:select part");
    }
    for (int i = 0; i < tabs.size(); i++) {
        PartTab tab = (PartTab) tabs.get(i);
        boolean selected = tab.getPart() == part;
        if (selected) {
            selectedTab = tab;
        }
        tab.setSelected(selected);
    }
    // recompute overall tab width
    computeSize(getParent().getClientArea().width, SWT.DEFAULT, true);
    layoutTabs();
    // now it could happen, that the selected tab is invisible
    if(!isSelectedTabVisible()){
        setSelectedTabVisible();
    }
    //        redraw();
}

public void show(Control parent, Point displayCoordinates, IPresentablePart currentSelection) {
    restore.update();
    move.setTarget(currentSelection);
    move.update();
    minimize.update();
    maximize.update();
    close.setTarget(currentSelection);
    if(isViewMenu()){
        showView.setTarget(currentSelection);
        sortEditorList.update();
    }

    Menu aMenu = menuManager.createContextMenu(parent);
    menuManager.update(true);
    aMenu.setLocation(displayCoordinates.x, displayCoordinates.y);
    aMenu.setVisible(true);
}

public void run() {
    IPresentablePart[] partList = site.getPartList();
    List/*<EditorInfo>*/ infos = new ArrayList();
    for (int i = 0; i < partList.length; i++) {
        EditorInfo info = presentation.createEditorInfo(partList[i]);
        if(info != null){
            infos.add(info);
        }
    }
    if(infos.isEmpty()){
        // TODO show message
        return;
    }
    boolean createNew = sessionName == null;
    if(createNew){
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        InputDialog dialog = new InputDialog(window.getShell(), "Save session",
                "Enter session name", null, new SessionNameValidator(true));
        int result = dialog.open();
        if(result == Window.CANCEL){
            return;
        }
        sessionName = dialog.getValue();
    }
    Sessions.getInstance().createSession(sessionName, infos, !createNew);
}

public List/*EditorInfo*/ getEditorInfos() {
    List list = new ArrayList();
    IPresentablePart[] partList = tabArea.getPartList();
    for (int i = 0; i < partList.length; i++) {
        EditorInfo info = createEditorInfo(partList[i]);
        if(info != null){
            info.setNumber(i);
            list.add(info);
        }
    }
    return list;
}

/**
 * Called to actually do the traverse.
 */
private void onPageTraversal(Event event) {
    IPresentablePart selectedPart = getSite().getSelectedPart();
    int index = getPartNumber(selectedPart);
    if (event.detail == SWT.TRAVERSE_PAGE_NEXT){
        index++;
    } else if(event.detail == SWT.TRAVERSE_PAGE_PREVIOUS){
        index--;
    }
    PartTab tab = tabArea.getTab(index);
    if(tab == null){
        return;
    }
    getSite().selectPart(tab.getPart());
}

public Control[] getTabList(IPresentablePart part) {
    List tabList = new ArrayList();
    tabList.add(getControl());
    if (part.getToolBar() != null) {
        tabList.add(part.getToolBar());
    }
    if (part.getControl() != null) {
        tabList.add(part.getControl());
    }
    return (Control[]) tabList.toArray(new Control[tabList.size()]);
}

/**
 * Returns the tab associated with the given part or null if none
 *
 * @param part the part to check for
 * @return the tab associated with the given part or null if none
 */
protected PartTab getTab(IPresentablePart part) {
    if(tabArea == null){
        return null;
    }
    return tabArea.getTab(part);
}

public String getPartTooltip(IPresentablePart part){
    String tooltip;
    if (!isView()) {
        tooltip = part.getTitleToolTip();
    } else {
        if (part.getTitleStatus() == null || part.getTitleStatus().trim().equals("")) {
            tooltip = part.getName();
        } else {
            tooltip = part.getName() + " - " + part.getTitleStatus();
        }
    }
    return tooltip;
}

public void selectPart(IPresentablePart toSelect) {
    if (PresentationPlugin.DEBUG_VIEWS && isView()) {
        System.out.println(getDebugPartName() + ": selectView "
                + (toSelect != null ? toSelect.getName() : "null"));
    }
    if (PresentationPlugin.DEBUG_EDITORS && !isView()) {
        System.out.println(getDebugPartName() + ": selectEditor "
                + (toSelect != null ? toSelect.getName() : "null"));
    }
    if (currentPart != null && currentPart != toSelect) {
        currentPart.setVisible(false);
        if (currentPart.getToolBar() != null) {
            currentPart.getToolBar().setVisible(false);
        }
    }
    lastSelectedPart = currentPart;
    currentPart = toSelect;
    if (toSelect != null) {
        title.setPresentablePart(toSelect);
        setTitleText();
        /*
         * to visible should be after title stuff to prevent null pointer if we computing
         * title text on old (probably already disposed) part
         */
        toSelect.setVisible(true);
    }

    tabArea.selectPart(toSelect);
    // selected tab is already known
    tabWithMenuFocus = null;
    // getPartsCount() == 1 is for detached views - they don't get the "visible" flag from UI
    if (isVisible || isDetached()) {
        isVisible = true;
        layout();
        redraw();
    }
}

private void removeExistingClosedPart(IPresentablePart newPart) {
    if (isView() || closedParts.isEmpty()) {
        // not supported yet
        return;
    }
    ClosedPart closedPart = createEmptyClosedPart(newPart);
    if (closedParts.contains(closedPart)) {
        removeClosedPart(closedPart);
    }
}

public void removePart(IPresentablePart oldPart) {
    if (currentPart == oldPart) {
        currentPart = null;
    }
    if (oldPart == null || !parts.containsKey(oldPart)) {
        return;
    }

    //We must remember that we're closing a part (so, it's added
    //to the list of closed parts). Note that it should pass
    //here when closing any editor through any means.
    rememberClosedPart(oldPart);

    if (PresentationPlugin.DEBUG_STATE) {
        System.out.println(getDebugPartName() + ":removePart " + oldPart.getName());
    }
    oldPart.removePropertyListener(propListener);
    PartTab tab = (PartTab) parts.remove(oldPart);
    if (parts.size() == 0) {
        currentPart = null;
    }
    tabArea.removeTab(tab);
    if (tab != null && !tab.isDisposed()) {
        tab.dispose();
    }

    boolean closing = isClosing();

    if (!closing) {
        oldPart.setVisible(false);
        if (isVisible) {
            layout();
            redraw();
        }
    }
}

/**
 * @param part not null
 * @return may return null
 */
public EditorInfo createEditorInfo(IPresentablePart part){
    ClosedPart closedPart = createEmptyClosedPart(part);
    if (tryToGetInput(closedPart, part)){
        EditorInfo editorInfo = closedPart.getEditorInfo();
        if(editorInfo != null && editorInfo.isConsistent()) {
            return editorInfo;
        }
    }
    return null;
}

/**
 * @return "empty" closedPart, which still doesn't contain the editor input.
 */
private ClosedPart createEmptyClosedPart(IPresentablePart presentablePart) {
    ClosedPart closedPart = new ClosedPart();
    closedPart.name = presentablePart.getName();
    closedPart.id = closedPart.name;

    closedPart.tooltip = presentablePart.getTitleToolTip();
    if (closedPart.tooltip == null) {
        closedPart.tooltip = "";
    }
    if (!isView()) {
        closedPart.id += " | " + closedPart.tooltip;
    }
    return closedPart;
}

static IWorkbenchPartReference getPartReference(IPresentablePart part){
    if(!(part instanceof PresentablePart)){
        return null;
    }
    PresentablePart ppart = (PresentablePart) part;
    if(ppart.getPane() != null) {
        return ppart.getPane().getPartReference();
    }
    return  null;
}

public void closeOthers(IPresentablePart current, boolean left) {
    IPresentablePart[] partList = tabArea.getPartList(current, left);
    if(partList == null || partList.length == 0){
        return;
    }
    close(partList);
}

protected void closeOnMiddleClick() {
    IPresentablePart partToClose = currentPart;
    if (tabWithMenuFocus != null) {
        // shouldn't happen...
        partToClose = tabWithMenuFocus.getPart();
    }
    if (partToClose != null
            && getPrefs().getBoolean(ThemeConstants.CLOSE_TAB_ON_MIDDLE_CLICK)) {
        close(new IPresentablePart[] { partToClose });
    }
}

protected void changeSelection(final IPresentablePart partToSelect,
        final PartTab selecedTab) {
    if (getPrefs().getBoolean(ThemeConstants.USE_FAST_TAB_SWITCH)) {
        if (lastSelectedPart != currentPart && lastSelectedPart != null
                && selecedTab.getPart() == currentPart) {
            getSite().selectPart(lastSelectedPart);
        } else {
            getSite().selectPart(partToSelect);
        }
    } else {
        getSite().selectPart(partToSelect);
    }
}

/**
 * @param sourcePart
 * @param propId
 */
protected void childPropertyChanged(IPresentablePart sourcePart, int propId) {
    switch (propId) {
    case IPresentablePart.PROP_TOOLBAR:
        // this one for changes of view if view has a toolbar
        if (isVisible) {
            layout();
            redraw();
        }
        break;
    case IPresentablePart.PROP_CONTENT_DESCRIPTION:
        // this one for changes of status line near the title
    case IPresentablePart.PROP_DIRTY:
    case IPresentablePart.PROP_PART_NAME:
    case IPresentablePart.PROP_TITLE:
        setTitleText();

        PartTab partTab = getTab(sourcePart);
        // If there is no tab for this part, just ignore the property change
        if (partTab != null) {
            // no additional checks case is for "save all"
            partTab.setToolTipText(getPartTooltip(sourcePart));
        }

        if (isVisible) {
            redraw();
        }
        break;
    default:
        break;
    }
}

public void setPresentablePart(IPresentablePart part) {
    if (PresentationPlugin.DEBUG_STATE) {
        System.out.println("title: set part: " + part.getName());
    }
    this.part = part;
    String toolTip = part.getTitleToolTip();
    if(toolTip == null || toolTip.length() == 0){
        toolTip = part.getTitle();
    }
    setToolTipText(toolTip);
}

public Object[] getElements(Object inputElement) {
    if (tabArea == null) {
        return new IPresentablePart[0];
    }
    if (showVisibleTabsToo) {
        // show all tabs
        return tabArea.getPartList();
    }
    return tabArea.getHiddenPartList();
}

public String getText(Object element) {
    IPresentablePart selectedPart = tabArea.getSelectedPart();
    IPresentablePart presentablePart = (IPresentablePart) element;
    boolean isSelected = selectedPart == presentablePart;

    String label = getLabel(presentablePart);
    if (isSelected) {
        label += CURRENT;
    }
    return label;
}

public Color getForeground(Object element) {
    IPresentablePart presentablePart = (IPresentablePart) element;
    PartTab partTab = tabArea.getTab(presentablePart);
    boolean dirty = partTab.getPart().isDirty();
    if (dirty) {
        return rootControl.getDisplay().getSystemColor(SWT.COLOR_RED);
    }
    return rootControl.getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
}

public Color getBackground(Object element) {
    IPresentablePart presentablePart = (IPresentablePart) element;
    PartTab partTab = tabArea.getTab(presentablePart);
    boolean visible = !partTab.isHidden();
    boolean tabAreaVisible = tabArea.getCurrentTheme().getBoolean(
            ThemeConstants.EDITOR_TAB_AREA_VISIBLE);
    if (!showVisibleTabsToo || visible || !tabAreaVisible) {
        return rootControl.getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
    }
    return rootControl.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW);
}

public int category(Object element) {

            IPresentablePart part = (IPresentablePart) element;
            PartTab tabItem = tabArea.getTab(part);
            if (separateVisibleAndInvisible) {
                if (!tabItem.isHidden()) {
                    return 1; // visible
                }
                return 0; // not visible
            }
            return 0;
        }

public PartTab getTab(IPresentablePart part) {
    for (int i = 0; i < tabs.size(); i++) {
        PartTab tab = (PartTab) tabs.get(i);
        if(tab.getPart() == part){
            return tab;
        }
    }
    return null;
}

/**
 * @return list of parts, connected with tabs
 */
public IPresentablePart[] getPartList() {
    if(tabs == null || tabs.isEmpty()){
        return EMPTY;
    }
    List parts = new ArrayList(tabs.size());
    for (int i = 0; i < tabs.size(); i++) {
        PartTab partTab = (PartTab) tabs.get(i);
        parts.add(partTab.getPart());
    }
    return (IPresentablePart[]) parts.toArray(new IPresentablePart[parts.size()]);
}

public IPresentablePart[] getHiddenPartList() {
    if(tabs == null || tabs.isEmpty()){
        return EMPTY;
    }
    List parts = new ArrayList(tabs.size());
    for (int i = 0; i < tabs.size(); i++) {
        PartTab partTab = (PartTab) tabs.get(i);
        if(partTab.isHidden()) {
            parts.add(partTab.getPart());
        }
    }
    return (IPresentablePart[]) parts.toArray(new IPresentablePart[parts.size()]);
}

public void run() {
    List others = new LinkedList();
    others.addAll(Arrays.asList(site.getPartList()));
    others.remove(current);
    presentation.close((IPresentablePart[]) others
            .toArray(new IPresentablePart[others.size()]));
}

public void fill(Menu menu, int index) {

        // Don't include a part list if there's only one part
        if (others == null || others.size() <= 0
                || presentation.getFlag(VSStackPresentation.F_TAB_AREA_VISIBLE)) {
            return;
        }

        new MenuItem(menu, SWT.SEPARATOR, index++);

        Collections.sort(others, new Comparator() {
            public int compare(Object arg0, Object arg1) {
                IPresentablePart part0 = (IPresentablePart) arg0;
                IPresentablePart part1 = (IPresentablePart) arg1;

                return part0.getName().compareToIgnoreCase(part1.getName());
            }
        });

        for (int i = 0; i < others.size(); i++) {
            IPresentablePart part = (IPresentablePart) others.get(i);

            MenuItem item = new MenuItem(menu, SWT.NONE, index++);
            item.setText(part.getName());
            item.setImage(part.getTitleImage());
            item.addSelectionListener(selectionListener);
            item.setData(DATA_ITEM, part);
        }
    }

public void widgetSelected(SelectionEvent e) {
    MenuItem item = (MenuItem) e.widget;

    IPresentablePart part = (IPresentablePart) item.getData(DATA_ITEM);

    if (part != null) {
        site.selectPart(part);
    }
}

public void show(Control parent, Point displayCoordinates,
        IPresentablePart currentSelection) {
    closeOthers.setTarget(currentSelection);
    closeOthersL.setTarget(currentSelection);
    closeOthersR.setTarget(currentSelection);
    pathToClipboard.setTarget(currentSelection);
    closeAll.update();
    sortEditorList.update();
    showClosedEditorList.update();
    super.show(parent, displayCoordinates, currentSelection);
}