* Copyright (c) 2004 Andrei Loskutov. All rights reserved. This program and the

* accompanying materials are made available under the terms of the BSD License which

* accompanies this distribution, and is available at

* http://www.opensource.org/licenses/bsd-license.php Contributor: Andrei Loskutov -

* initial API and implementation

****************************************************************************************/

* This view shows decompiled java bytecode

* @author Andrei

*/

    // orientations

    static final int VIEW_ORIENTATION_VERTICAL = 0;

    static final int VIEW_ORIENTATION_HORIZONTAL = 1;

    static final int VIEW_ORIENTATION_AUTOMATIC = 2;

    /**

     * The current orientation; either <code>VIEW_ORIENTATION_HORIZONTAL</code>

     * <code>VIEW_ORIENTATION_VERTICAL</code>,

     * or <code>VIEW_ORIENTATION_AUTOMATIC</code>.

     */

    int orientation = VIEW_ORIENTATION_AUTOMATIC;

    /**

     * The current orientation; either <code>VIEW_ORIENTATION_HORIZONTAL</code>

     * <code>VIEW_ORIENTATION_VERTICAL</code>.

     */

    private int currentOrientation;

    protected ToggleOrientationAction[] toggleOrientationActions;

    protected BitSet modes;

    protected boolean inputChanged;

    protected boolean bufferIsDirty;

    private boolean isEnabled;

    private boolean isActive;

    private boolean isVisible;

    protected Composite stackComposite;

    protected StyledText textControl;

    protected TextViewer textViewer;

    protected SashForm verifyControl;

    protected SashForm stackAndLvt;

    protected Table tableControl;

    protected TableViewer tableControlViewer;

    protected Table stackTable;

    protected Table lvtTable;

    protected ITextEditor javaEditor;

    private IJavaElement javaInput;

    protected IJavaElement lastChildElement;

    protected ITextSelection currentSelection;

    protected EditorListener editorListener;

    protected Action selectionChangedAction;

    protected Action refreshVarsAndStackAction;

    protected DefaultToggleAction linkWithEditorAction;

    protected DefaultToggleAction showSelectedOnlyAction;

    protected DefaultToggleAction setRawModeAction;

    protected DefaultToggleAction toggleASMifierModeAction;

    protected DefaultToggleAction hideLineInfoAction;

    protected DefaultToggleAction hideLocalsAction;

    protected DefaultToggleAction hideStackMapAction;

    protected DefaultToggleAction showHexValuesAction;

    protected DefaultToggleAction expandStackMapAction;

    protected DefaultToggleAction toggleVerifierAction;

    protected StatusLineManager statusLineManager;

    protected BCOViewSelectionProvider viewSelectionProvider;

    protected Color errorColor;

    private DecompiledClass lastDecompiledResult;

    protected Map globalActions;

    protected List selectionActions;

    private MenuManager contextMenuManager;

    /** global class info, without current selection status */

    protected String currentStatusMessage;

    protected boolean hasAnalyzerError;

    /*

     * I don't know how to update the state of toolbar and menu managers because it seems

     * that if we toggle the action state internally (not by user click) then either the

     * managers or contribution items or whatever holds the old state of checked action.

     * This flag is a workaround and allows us restore the state after internal toggling.

     */

    private boolean restoreVerify;

    private static final String NLS_PREFIX = "BytecodeOutlineView.";

    // updates the find replace action if the document length is > 0

    private ITextListener textListener;

    // see org.eclipse.ui.console.TextConsolePage for the reason to do this ;)

    private ISelectionChangedListener textSelectionListener;

    private Control statusControl;

    // ------------------------------------------------------------------------

    protected void setJavaInput(IJavaElement javaInput) {

        this.javaInput = javaInput;

        inputChanged = true;

    }

    /**

     * The constructor.

     */

    public BytecodeOutlineView() {

        super();

        modes = new BitSet();

        globalActions = new HashMap();

        selectionActions = new ArrayList();

    }

    // ------------------------------------------------------------------------

    /**

     * Is this view state changes depending on editor changes?

     * @return true if linked with editor

     */

    protected boolean isLinkedWithEditor() {

        return modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR);

    }

    /**

     * Are actions on toolbar active?

     * @return Returns the isEnabled.

     */

    private boolean isEnabled() {

        return isEnabled;

    }

    private void setEnabled(boolean on) {

        this.isEnabled = on;

        if (tableControl != null && !tableControl.isDisposed()) {

            tableControl.setEnabled(on);

        }

        if (stackTable != null && !stackTable.isDisposed()) {

            stackTable.setEnabled(on);

        }

        if (lvtTable != null && !lvtTable.isDisposed()) {

            lvtTable.setEnabled(on);

        }

        showSelectedOnlyAction.setEnabled(on);

        // linkWithEditorAction.setEnabled(on);

        selectionChangedAction.setEnabled(on);

        toggleVerifierAction.setEnabled(on);

        hideLocalsAction.setEnabled(on);

        hideLineInfoAction.setEnabled(on);

        hideStackMapAction.setEnabled(on);

        showHexValuesAction.setEnabled(on);

        toggleASMifierModeAction.setEnabled(on);

        expandStackMapAction.setEnabled(on);

        setRawModeAction

            .setEnabled(on && !toggleASMifierModeAction.isChecked());

        boolean showAnalyzer = on && toggleVerifierAction.isChecked();

        for (int i = 0; i < toggleOrientationActions.length; ++i) {

            toggleOrientationActions[i].setEnabled(showAnalyzer);

        }

    }

    /**

     * Is this view monitoring workspace changes?

     * @return Returns the isActive.

     */

    private boolean isActive() {

        return isActive;

    }

    /**

     * @param bufferIsDirty The bufferIsDirty to set.

     */

    private void setBufferIsDirty(boolean bufferIsDirty) {

        this.bufferIsDirty = bufferIsDirty;

    }

    private void setInput(ITextEditor editor) {

        javaEditor = null;

        setJavaInput(null);

        lastDecompiledResult = null;

        if (editor != null) {

            IJavaElement javaElem = EclipseUtils.getJavaInput(editor);

            if (javaElem == null) {

                return;

            }

            setJavaInput(javaElem);

            javaEditor = editor;

            checkVerifyMode();

            updateSelection(EclipseUtils.getSelection(javaEditor

                .getSelectionProvider()));

            setBufferIsDirty(editor.isDirty());

        }

    }

    private void checkVerifyMode() {

        boolean aoi = JdtUtils.isAbstractOrInterface(javaInput);

        if (!toggleVerifierAction.isChecked()) {

            // deactivate verify button, but only if *not* in verify mode

            toggleVerifierAction.setEnabled(!aoi);

            restoreVerify = false;

        } else {

            if (aoi) {

                // swith verify mode off, because it is not applicable to selected element

                inputChanged = true;

                toggleVerifyMode(

                    getViewSite().getActionBars().getMenuManager(), false);

                // remember last state, to match the state of the toolbars and menus

                restoreVerify = true;

            } else {

                if (restoreVerify) {

                    inputChanged = true;

                    toggleVerifierAction.setEnabled(true);

                    toggleVerifyMode(getViewSite().getActionBars()

                        .getMenuManager(), true);

                }

                restoreVerify = false;

            }

        }

    }

    private boolean updateSelection(ITextSelection sel) {

        if (sel != null

            && (sel.equals(currentSelection) || (currentSelection != null

                && sel.getStartLine() == currentSelection.getStartLine() && sel

                .getEndLine() == currentSelection.getEndLine()))) {

            /*

             * getStartLine/getEndLine is probably not sensitive enough - but in case of

             * java classes/methods which fits in one selection but not in the other, then

             * I think we can ignore them here - this is not the 99% of use cases.

             */

            return false;

        }

        currentSelection = sel;

        return true;

    }

    // ------------------------------------------------------------------------

    /**

     * @see org.eclipse.ui.IViewPart#init(org.eclipse.ui.IViewSite)

     */

    public void init(IViewSite site) {

        super.setSite(site);

        if (editorListener == null) {

            editorListener = new EditorListener(this);

            getSite().getWorkbenchWindow().getPartService().addPartListener(

                editorListener);

        }

    }

    /**

     * This is a callback that will allow us to create the viewer and initialize it.

     * @param parent

     */

    public void createPartControl(Composite parent) {

        errorColor = parent.getDisplay().getSystemColor(SWT.COLOR_RED);

        parent.addControlListener(new ControlListener() {

            public void controlMoved(ControlEvent e) {

                //

            }

            public void controlResized(ControlEvent e) {

                computeOrientation();

            }

        });

        GridLayout parentLayout = new GridLayout();

        parentLayout.numColumns = 1;

        parentLayout.marginBottom = -5;

        parentLayout.marginTop = -5;

        parentLayout.marginLeft = -5;

        parentLayout.marginRight = -5;

        parent.setLayout(parentLayout);

        stackComposite = new Composite(parent, SWT.NONE);

        stackComposite.setLayoutData(new GridData(GridData.FILL_BOTH));

        stackComposite.setLayout(new StackLayout());

        statusLineManager = new StatusLineManager();

        statusControl = statusLineManager.createControl(parent, SWT.NONE);

        statusControl.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

        createTextControl();

        createTextContextMenu();

        createVerifyControl();

        initModes();

        if (modes.get(BCOConstants.F_SHOW_ANALYZER)) {

            ((StackLayout) stackComposite.getLayout()).topControl = verifyControl;

        } else {

            ((StackLayout) stackComposite.getLayout()).topControl = textControl;

        }

        createSelectionProvider();

        createToolbarActions();

        setEnabled(false);

    }

    private void initModes() {

        IPreferenceStore store = BytecodeOutlinePlugin.getDefault()

            .getPreferenceStore();

        modes.set(BCOConstants.F_LINK_VIEW_TO_EDITOR, store

            .getBoolean(BCOConstants.LINK_VIEW_TO_EDITOR));

        modes.set(BCOConstants.F_SHOW_ONLY_SELECTED_ELEMENT, store

            .getBoolean(BCOConstants.SHOW_ONLY_SELECTED_ELEMENT));

        modes.set(BCOConstants.F_SHOW_RAW_BYTECODE, store

            .getBoolean(BCOConstants.SHOW_RAW_BYTECODE));

        modes.set(BCOConstants.F_SHOW_LINE_INFO, store

            .getBoolean(BCOConstants.SHOW_LINE_INFO));

        modes.set(BCOConstants.F_SHOW_VARIABLES, store

            .getBoolean(BCOConstants.SHOW_VARIABLES));

        modes.set(BCOConstants.F_SHOW_STACKMAP, store

            .getBoolean(BCOConstants.SHOW_STACKMAP));

        modes.set(BCOConstants.F_EXPAND_STACKMAP, store

            .getBoolean(BCOConstants.EXPAND_STACKMAP));

        modes.set(BCOConstants.F_SHOW_ASMIFIER_CODE, store

            .getBoolean(BCOConstants.SHOW_ASMIFIER_CODE));

        modes.set(BCOConstants.F_SHOW_ANALYZER, store

            .getBoolean(BCOConstants.SHOW_ANALYZER));

        modes.set(BCOConstants.F_SHOW_HEX_VALUES, store

            .getBoolean(BCOConstants.SHOW_HEX_VALUES));

    }

    private void createToolbarActions() {

        createTextActions();

        final IActionBars bars = getViewSite().getActionBars();

        final IToolBarManager tmanager = bars.getToolBarManager();

        final IMenuManager mmanager = bars.getMenuManager();

        selectionChangedAction = new Action() {

            public void run() {

                Point selection = textControl.getSelection();

                setSelectionInJavaEditor(selection);

            }

        };

        refreshVarsAndStackAction = new Action() {

            public void run() {

                int selectionIndex = tableControl.getSelectionIndex();

                TableItem[] items = tableControl.getSelection();

                if(items == null || items.length < 1){

                    return;

                }

                String line = items[0].getText(0);

                if(line == null || "".equals(line)){

                    return;

                }

                Integer valueOf = Integer.valueOf(line);

                if(valueOf != null){

                    updateVerifierControl4insn(valueOf.intValue());

                    tableControl.setSelection(selectionIndex);

                }

            }

        };

        linkWithEditorAction = new DefaultToggleAction(

            BCOConstants.LINK_VIEW_TO_EDITOR) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_LINK_VIEW_TO_EDITOR, newState);

                if (modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

                    showSelectedOnlyAction.setEnabled(true);

                    toggleVerifierAction.setEnabled(true);

                    hideLineInfoAction.setEnabled(true);

                    hideLocalsAction.setEnabled(true);

                    toggleASMifierModeAction.setEnabled(true);

                    if (!toggleASMifierModeAction.isChecked()) {

                        setRawModeAction.setEnabled(true);

                    }

                    activateView();

                    checkOpenEditors(true);

                    inputChanged = true;

                    refreshView();

                }

            }

        };

        showSelectedOnlyAction = new DefaultToggleAction(

            BCOConstants.SHOW_ONLY_SELECTED_ELEMENT) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_ONLY_SELECTED_ELEMENT, newState);

                inputChanged = true;

                refreshView();

            }

        };

        setRawModeAction = new DefaultToggleAction(

            BCOConstants.SHOW_RAW_BYTECODE) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_RAW_BYTECODE, newState);

                inputChanged = true;

                refreshView();

            }

        };

        hideLineInfoAction = new DefaultToggleAction(

            BCOConstants.SHOW_LINE_INFO) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_LINE_INFO, newState);

                inputChanged = true;

                refreshView();

            }

        };

        hideLocalsAction = new DefaultToggleAction(BCOConstants.SHOW_VARIABLES) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_VARIABLES, newState);

                inputChanged = true;

                refreshView();

            }

        };

        hideStackMapAction = new DefaultToggleAction(BCOConstants.SHOW_STACKMAP) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_STACKMAP, newState);

                inputChanged = true;

                refreshView();

            }

        };

        expandStackMapAction = new DefaultToggleAction(

            BCOConstants.EXPAND_STACKMAP) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_EXPAND_STACKMAP, newState);

                inputChanged = true;

                refreshView();

            }

        };

        showHexValuesAction = new DefaultToggleAction(

            BCOConstants.SHOW_HEX_VALUES) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_HEX_VALUES, newState);

                inputChanged = true;

                refreshView();

            }

        };

        toggleASMifierModeAction = new DefaultToggleAction(

            BCOConstants.SHOW_ASMIFIER_CODE) {

            public void run(boolean newState) {

                setMode(BCOConstants.F_SHOW_ASMIFIER_CODE, newState);

                if (newState) {

                    setMode(BCOConstants.F_SHOW_RAW_BYTECODE, true);

                    setRawModeAction.setEnabled(false);

                } else {

                    setRawModeAction.setEnabled(true);

                }

                inputChanged = true;

                refreshView();

            }

        };

        toggleVerifierAction = new DefaultToggleAction(

            BCOConstants.SHOW_ANALYZER) {

            public void run(boolean newState) {

                toggleVerifyMode(mmanager, newState);

                inputChanged = true;

                refreshView();

            }

        };

        mmanager.add(linkWithEditorAction);

        mmanager.add(showSelectedOnlyAction);

        mmanager.add(setRawModeAction);

        mmanager.add(hideLineInfoAction);

        mmanager.add(hideLocalsAction);

        mmanager.add(showHexValuesAction);

        mmanager.add(hideStackMapAction);

        mmanager.add(expandStackMapAction);

        mmanager.add(toggleASMifierModeAction);

        mmanager.add(toggleVerifierAction);

        mmanager.add(new Separator());

        toggleOrientationActions = new ToggleOrientationAction[]{

            new ToggleOrientationAction(this, VIEW_ORIENTATION_VERTICAL),

            new ToggleOrientationAction(this, VIEW_ORIENTATION_HORIZONTAL),

            new ToggleOrientationAction(this, VIEW_ORIENTATION_AUTOMATIC)};

        for (int i = 0; i < toggleOrientationActions.length; ++i) {

            mmanager.add(toggleOrientationActions[i]);

        }

        tmanager.add(linkWithEditorAction);

        tmanager.add(showSelectedOnlyAction);

        tmanager.add(setRawModeAction);

        // tmanager.add(hideLineInfoAction);

        // tmanager.add(hideLocalsAction);

        tmanager.add(toggleASMifierModeAction);

        tmanager.add(toggleVerifierAction);

    }

    private void createVerifyControl() {

        verifyControl = new SashForm(stackComposite, SWT.VERTICAL);

        tableControl = new Table(verifyControl, SWT.SINGLE | SWT.FULL_SELECTION);

        tableControlViewer = new TableViewer(tableControl);

        TableColumn tc = new TableColumn(tableControl, SWT.LEFT);

        tc.setText("#");

        tc.setToolTipText("ASM instruction offset");

        tc = new TableColumn(tableControl, SWT.LEFT);

        tc.setText(BytecodeOutlinePlugin.getResourceString(NLS_PREFIX + "lvt.header"));

        tc.setToolTipText("Local variables");

        tc = new TableColumn(tableControl, SWT.LEFT);

        tc.setText(BytecodeOutlinePlugin.getResourceString(NLS_PREFIX + "stack.header"));

        tc.setToolTipText("Stack content *before* current instruction is executed");

        new TableColumn(tableControl, SWT.LEFT);

        new TableColumn(tableControl, SWT.LEFT);

        tableControl.setLinesVisible(false);

        tableControl.setHeaderVisible(true);

        stackAndLvt = new SashForm(verifyControl, SWT.HORIZONTAL);

        lvtTable = new Table(stackAndLvt, SWT.SINGLE | SWT.FULL_SELECTION);

        lvtTable.setLinesVisible(false);

        lvtTable.setHeaderVisible(true);

        new TableColumn(lvtTable, SWT.LEFT).setText("#");

        new TableColumn(lvtTable, SWT.LEFT).setText("Var Type");

        new TableColumn(lvtTable, SWT.LEFT).setText("Name");

        stackTable = new Table(stackAndLvt, SWT.SINGLE | SWT.FULL_SELECTION);

        stackTable.setLinesVisible(false);

        stackTable.setHeaderVisible(true);

        new TableColumn(stackTable, SWT.LEFT).setText("#");

        new TableColumn(stackTable, SWT.LEFT).setText("Stack Type");

        stackAndLvt.setWeights(new int[]{50, 50});

        verifyControl.setWeights(new int[]{75, 25});

        tableControl.addSelectionListener(new SelectionAdapter() {

            public void widgetSelected(SelectionEvent e) {

                if (modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

                    selectionChangedAction.run();

                }

                refreshVarsAndStackAction.run();

            }

        });

    }

    private void createSelectionProvider() {

        viewSelectionProvider = new BCOViewSelectionProvider();

        viewSelectionProvider.registerSelectionProvider(textViewer);

        viewSelectionProvider.registerSelectionProvider(tableControlViewer);

        if (modes.get(BCOConstants.F_SHOW_ANALYZER)) {

            viewSelectionProvider.setCurrentSelectionProvider(tableControlViewer);

        } else {

            viewSelectionProvider.setCurrentSelectionProvider(textViewer);

        }

        getSite().setSelectionProvider(viewSelectionProvider);

    }

    /**

     * create/register context menu on text control

     */

    private void createTextContextMenu() {

        String id = "de.loskutov.bco.views.BytecodeOutlineView#ContextMenu"; //$NON-NLS-1$

        contextMenuManager = new MenuManager("#ContextMenu", id); //$NON-NLS-1$

        contextMenuManager.setRemoveAllWhenShown(true);

        contextMenuManager.addMenuListener(new IMenuListener() {

            public void menuAboutToShow(IMenuManager m) {

                contextMenuAboutToShow(m);

            }

        });

        Menu menu = contextMenuManager.createContextMenu(textControl);

        textControl.setMenu(menu);

        getSite().registerContextMenu(id, contextMenuManager, textViewer);

    }

    private void createTextControl() {

        textViewer = new TextViewer(stackComposite, SWT.H_SCROLL | SWT.V_SCROLL);

        textViewer.setEditable(false);

        // textViewer.setHoverControlCreator(null)

        textControl = textViewer.getTextWidget();

        IDocument document = new Document("");

        textViewer.setDocument(document);

        textSelectionListener = new ISelectionChangedListener() {

            public void selectionChanged(SelectionChangedEvent event) {

                // Updates selection dependent actions like find/copy.

                Iterator iterator = selectionActions.iterator();

                while (iterator.hasNext()) {

                    updateAction((String) iterator.next());

                }

            }

        };

        textListener = new ITextListener() {

            public void textChanged(TextEvent event) {

                IUpdate findReplace = (IUpdate) globalActions

                    .get(ActionFactory.FIND.getId());

                if (findReplace != null) {

                    findReplace.update();

                }

            }

        };

        textViewer.getSelectionProvider().addSelectionChangedListener(

            textSelectionListener);

        textViewer.addTextListener(textListener);

        textControl.addMouseListener(new MouseAdapter() {

            public void mouseDown(MouseEvent e) {

                if (modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

                    selectionChangedAction.run();

                }

            }

            public void mouseUp(MouseEvent e) {

                if (modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

                    selectionChangedAction.run();

                }

            }

        });

        textControl.addKeyListener(new KeyListener() {

            public void keyPressed(KeyEvent e) {

                // ignored

            }

            public void keyReleased(KeyEvent e) {

                if (modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

                    selectionChangedAction.run();

                }

            }

        });

    }

    /**

     * @see org.eclipse.ui.IWorkbenchPart#dispose()

     */

    public void dispose() {

        deActivateView();

        if (editorListener != null) {

            getSite().getWorkbenchWindow().getPartService().removePartListener(

                editorListener);

            editorListener.dispose();

            editorListener = null;

        }

        if (contextMenuManager != null) {

            contextMenuManager.dispose();

        }

        selectionActions.clear();

        globalActions.clear();

        textViewer.getSelectionProvider().removeSelectionChangedListener(

            textSelectionListener);

        textViewer.removeTextListener(textListener);

        textViewer = null;

        viewSelectionProvider = null;

        if (textControl != null) {

            textControl.dispose();

            textControl = null;

        }

        if (verifyControl != null) {

            verifyControl.dispose();

            verifyControl = null;

            tableControl = null;

            stackTable = null;

            lvtTable = null;

            tableControlViewer = null;

        }

        currentSelection = null;

        javaEditor = null;

        setJavaInput(null);

        lastChildElement = null;

        lastDecompiledResult = null;

        linkWithEditorAction.dispose();

        showSelectedOnlyAction.dispose();

        setRawModeAction.dispose();

        toggleASMifierModeAction.dispose();

        hideLineInfoAction.dispose();

        hideLocalsAction.dispose();

        hideStackMapAction.dispose();

        showHexValuesAction.dispose();

        expandStackMapAction.dispose();

        toggleVerifierAction.dispose();

        linkWithEditorAction = null;

        selectionChangedAction = null;

        refreshVarsAndStackAction = null;

        showSelectedOnlyAction = null;

        setRawModeAction = null;

        toggleASMifierModeAction = null;

        hideLineInfoAction = null;

        hideLocalsAction = null;

        hideStackMapAction = null;

        showHexValuesAction = null;

        expandStackMapAction = null;

        toggleVerifierAction = null;

        super.dispose();

    }

    /**

     * Fill the context menu

     * @param menuManager menu

     */

    protected void contextMenuAboutToShow(IMenuManager menuManager) {

        IDocument doc = textViewer.getDocument();

        if (doc == null) {

            return;

        }

        menuManager

            .add((IAction) globalActions.get(ActionFactory.COPY.getId()));

        menuManager.add((IAction) globalActions.get(ActionFactory.SELECT_ALL

            .getId()));

        menuManager.add(new Separator("FIND")); //$NON-NLS-1$

        menuManager

            .add((IAction) globalActions.get(ActionFactory.FIND.getId()));

        menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));

    }

    // -----------------------------------------------------------------------

    /**

     * Passing the focus request to the viewer's control.

     */

    public void setFocus() {

        if (!modes.get(BCOConstants.F_SHOW_ANALYZER)) {

            if (textViewer != null) {

                textViewer.getTextWidget().setFocus();

            }

        } else {

            if (tableControl != null) {

                tableControl.setFocus();

            }

        }

    }

    protected void handleBufferIsDirty(boolean isDirty) {

        if (!modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR) || !isActive()) {

            return;

        }

        if (isDirty) {

            setBufferIsDirty(isDirty);

        } else {

            if (!bufferIsDirty) {

                // second time calling with same argument -

                // cause new bytecode should be written now

                inputChanged = true;

                refreshView();

            } else {

                // first time - set the flag only - cause

                // bytecode is not yet written

                setBufferIsDirty(false);

            }

        }

    }

    protected void handlePartHidden(IWorkbenchPart part) {

        if (!modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

            return;

        }

        if (this == part) {

            isVisible = false;

            deActivateView();

        } else if (isActive() && (part instanceof IEditorPart)) {

            // check if at least one editor is open

            checkOpenEditors(false);

        }

    }

    protected void handlePartVisible(IWorkbenchPart part) {

        if (!modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR)) {

            if(this == part){

                isVisible = true;

            }

            return;

        }

        if (this == part) {

            if (isVisible) {

                return;

            }

            isVisible = true;

            // check if java editor is already open

            IEditorPart activeEditor = EclipseUtils.getActiveEditor();

            if (!(activeEditor instanceof ITextEditor)) {

                // start monitoring again, even if current editor is not

                // supported - but we at front now

                activateView();

                return;

            }

            part = activeEditor;

            // continue with setting input

        }

        if (isVisible && part instanceof ITextEditor) {

            if (isActive() && part == javaEditor) {

                return;

            }

            activateView();

            setEnabled(true);

            setInput((ITextEditor) part);

            refreshView();

        } else if (part instanceof IEditorPart) {

            if (isActive()) {

                deActivateView();

            }

        }

    }

    protected void handleSelectionChanged(IWorkbenchPart part,

        ISelection selection) {

        if (!modes.get(BCOConstants.F_LINK_VIEW_TO_EDITOR) || !isActive()

            || !isVisible || !(part instanceof IEditorPart)) {

            return;

        }

        if (!(part instanceof ITextEditor)) {

            deActivateView();

            return;

        }

        if (!isEnabled()) {

            setEnabled(true);

        }

        if (part != javaEditor) {

            setInput((ITextEditor) part);

        } else {

            if (!updateSelection((ITextSelection) selection)) {

                return;

            }

        }

        refreshView();

    }

    /**

     * Does nothing if view is already active

     */

    private void activateView() {

        if (isActive()) {

            return;

        }

        isActive = true;

        getSite().getWorkbenchWindow().getSelectionService()

            .addPostSelectionListener(editorListener);

        FileBuffers.getTextFileBufferManager().addFileBufferListener(

            editorListener);

    }

    /**

     * Does nothing if view is already deactivated

     */

    private void deActivateView() {

        if (!isActive()) {

            return;

        }

        setEnabled(false);

        if (editorListener != null) {

            ISelectionService service = getSite().getWorkbenchWindow()

                .getSelectionService();

            if (service != null) {

                service.removePostSelectionListener(editorListener);

            }

            FileBuffers.getTextFileBufferManager().removeFileBufferListener(

                editorListener);

        }

        if (textViewer != null && textViewer.getTextWidget() != null

            && !textViewer.getTextWidget().isDisposed()) {

            IDocument document = new Document("");

            textViewer.setDocument(document);

        }

        if (tableControl != null && !tableControl.isDisposed()) {

            setVerifyTableItems(null);

        }

        /*

         * if(stackControl != null && !stackControl.isDisposed()){

         * stackControl.setText(""); } if(lvtControl != null && !lvtControl.isDisposed()){

         * lvtControl.setText(""); }

         */

        if (stackTable != null && !stackTable.isDisposed()) {

            stackTable.removeAll();

        }

        if (lvtTable != null && !lvtTable.isDisposed()) {

            lvtTable.removeAll();

        }

        if (statusControl != null && !statusControl.isDisposed()) {

            updateStatus(null, -1, -1);

        }

        currentSelection = null;

        lastDecompiledResult = null;

        javaEditor = null;

        setJavaInput(null);

        lastChildElement = null;

        setBufferIsDirty(false);

        isActive = false;

    }

    protected void refreshView() {

        if (!isActive()) {

            return;

        }

        IJavaElement childEl = getCurrentJavaElement();

        if (childEl == null && javaInput == null) {

            setInput(javaEditor);

            childEl = javaInput;

        }

        // after getCurrentJavaElement() call it is possible that java type is disappear

        // because corresponding type is not more exist in model

        if (javaInput == null) {

            deActivateView();

            return;

        }

        boolean clearOutput = false;

        if (inputChanged || isSelectedElementChanged(childEl)) {

            DecompiledClass result = decompileBytecode(childEl);

            if (result == null) {

                clearOutput = true;

            } else {

                if (modes.get(BCOConstants.F_SHOW_ANALYZER)

                    && !result.isAbstractOrInterface()) {

                    refreshVerifyView(result);

                } else {

                    toggleVerifierAction.setEnabled(!result

                        .isAbstractOrInterface());

                    refreshTextView(result);

                }

            }

            lastDecompiledResult = result;

        } else if (childEl == null

            && modes.get(BCOConstants.F_SHOW_ONLY_SELECTED_ELEMENT)) {

            clearOutput = true;

        }

        lastChildElement = childEl;

        if (clearOutput) {

            if (!modes.get(BCOConstants.F_SHOW_ANALYZER)) {

                IDocument document = new Document("");

                textViewer.setDocument(document);

            } else {

                setVerifyTableItems(null);

            }

        }

        setSelectionInBytecodeView();

        inputChanged = false;

    }

    private void refreshTextView(DecompiledClass result) {

        IDocument document = new Document(result.getText());

        textViewer.setDocument(document);

        // we are in verify mode but we can't show content because

        // current element is abstract, so we clean table content

        if (modes.get(BCOConstants.F_SHOW_ANALYZER)) {

            setVerifyTableItems(null);

        }

        hasAnalyzerError = false;

    }

    private void refreshVerifyView(DecompiledClass result) {

        setVerifyTableItems(result.getTextTable());

        List errors = result.getErrorLines();

        if (errors.size() > 0) {

            // TODO this only changes color of status line -

            // but it is possible also to provide useful info here...

            hasAnalyzerError = true;

            // currentErrorMessage = ...

        }

        for (int i = 0; i < errors.size(); ++i) {

            int l = ((Integer) errors.get(i)).intValue();

            tableControl.getItem(l).setForeground(errorColor);

        }

        toggleVerifierAction.setEnabled(true);

    }

    /**

     * @param result

     */

    private void updateStatus(DecompiledClass result, int bytecodeOffsetStart,

        int bytecodeOffsetEnd) {

        // clear error messages, if any

        statusLineManager.setErrorMessage(null);

        if (result != null) {

            currentStatusMessage = "Java:"

                + result.getAttribute("java.version") + " | class size:"

                + result.getAttribute("class.size");

            ClassNode classNode = result.getClassNode();

            if(classNode != null && classNode.name != null) {

                setContentDescription(classNode.name);

            }

        } else {

            currentStatusMessage = "";

            setContentDescription("");

        }

        String selectionInfo = "";

        if (bytecodeOffsetStart >= 0) {

            selectionInfo = " | offset:" + bytecodeOffsetStart;

            if (bytecodeOffsetEnd >= 0) {

                selectionInfo += "-" + bytecodeOffsetEnd;

            }

        }

        if (hasAnalyzerError) {

            statusLineManager.setErrorMessage(currentStatusMessage

                + selectionInfo);

        } else {

            statusLineManager.setMessage(currentStatusMessage + selectionInfo);

        }

    }

    public int getBytecodeInstructionAtLine(int line) {

        if (lastDecompiledResult != null) {

            return lastDecompiledResult.getBytecodeInsn(line);

        }

        return -1;

    }

    /**

     * @return IJavaElement which fits in the current selection in java editor

     */

    private IJavaElement getCurrentJavaElement() {

        IJavaElement childEl = null;

        try {

            childEl = JdtUtils.getElementAtOffset(javaInput, currentSelection);

            if (childEl != null) {

                switch (childEl.getElementType()) {

                    case IJavaElement.METHOD :

                    case IJavaElement.FIELD :

                    case IJavaElement.INITIALIZER :

                    case IJavaElement.TYPE :

                        break;

                    case IJavaElement.LOCAL_VARIABLE :

                        childEl = childEl.getAncestor(IJavaElement.METHOD);

                        break;

                    default :

                        childEl = null;

                        break;

                }

            }

        } catch (JavaModelException e) {

            // the exception is mostly occured if java structure was

            // changed and current element is not more exist in model

            // e.g. on rename/delete/move operation.

            // so it is not an error for user, but info for us

            BytecodeOutlinePlugin.log(e, IStatus.INFO);

            setJavaInput(null);

            lastChildElement = null;

        }

        return childEl;

    }

    private void setSelectionInBytecodeView() {

        if (lastDecompiledResult == null) {

            return;

        }

        if (currentSelection.getStartLine() != currentSelection.getEndLine()) {

            setMultiLineSelectionInBytecodeView(currentSelection);

            return;

        }

        int sourceLine = currentSelection.getStartLine() + 1;

        int decompiledLine = lastDecompiledResult.getDecompiledLine(sourceLine);

        if (decompiledLine < 0

            && !modes.get(BCOConstants.F_SHOW_ONLY_SELECTED_ELEMENT)

            && lastChildElement != null) {

            /*

             * May be this is the selection in outline view, if complete class is shown.

             * Because there are no bytecode instructions/offset for method name, we need

             * to find and select first method line. See cr 306011

             */

            DecompiledMethod match = lastDecompiledResult.getBestDecompiledMatch(sourceLine);

            if(match != null){

                // this is relative to method start

                decompiledLine = match.getBestDecompiledLine(sourceLine);

                if(decompiledLine > 0){

                    // convert to class file relative

                    decompiledLine = lastDecompiledResult.getDecompiledLine(match, decompiledLine);

                }

            }

            if(decompiledLine < 0){

                String methodName = JdtUtils.getMethodSignature(lastChildElement);

                if (methodName != null) {

                    decompiledLine = lastDecompiledResult

                        .getDecompiledLine(methodName) - 1;