← Back to branch summary

~ubuntu-branches/debian/sid/eclipse-cdt/sid

« back to all changes in this revision

Viewing changes to debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/disassembly/editor/DisassemblyEditorManager.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2011-10-06 21:15:04 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20111006211504-8dutmljjih0zikfv
Tags: 8.0.1-1
* New upstream release.
* Split the JNI packages into a separate architecture dependent
  package and made eclipse-cdt architecture independent.
* Install JNI libraries into multiarch aware location
* Bumped Standards-Version to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/disassembly/editor/DisassemblyEditorManager.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2008 ARM Limited and others.
 
3
 * All rights reserved. This program and the accompanying materials
 
4
 * are made available under the terms of the Eclipse Public License v1.0
 
5
 * which accompanies this distribution, and is available at
 
6
 * http://www.eclipse.org/legal/epl-v10.html
 
7
 *
 
8
 * Contributors:
 
9
 * ARM Limited - Initial API and implementation
 
10
 *******************************************************************************/
 
11
 
 
12
package org.eclipse.cdt.debug.internal.ui.disassembly.editor;
 
13
 
 
14
import java.util.HashMap;
 
15
import java.util.Map;
 
16
 
 
17
import org.eclipse.cdt.debug.core.CDebugCorePlugin;
 
18
import org.eclipse.cdt.debug.core.ICDebugConstants;
 
19
import org.eclipse.cdt.debug.core.disassembly.IDisassemblyContextListener;
 
20
import org.eclipse.cdt.debug.core.disassembly.IDisassemblyContextProvider;
 
21
import org.eclipse.cdt.debug.core.disassembly.IDisassemblyContextService;
 
22
import org.eclipse.cdt.debug.core.model.ISteppingModeTarget;
 
23
import org.eclipse.cdt.debug.internal.ui.IInternalCDebugUIConstants;
 
24
import org.eclipse.cdt.debug.internal.ui.disassembly.viewer.DisassemblyDocumentProvider;
 
25
import org.eclipse.cdt.debug.ui.CDebugUIPlugin;
 
26
import org.eclipse.cdt.debug.ui.ICDebugUIConstants;
 
27
import org.eclipse.core.runtime.IAdaptable;
 
28
import org.eclipse.core.runtime.IProgressMonitor;
 
29
import org.eclipse.core.runtime.IStatus;
 
30
import org.eclipse.core.runtime.Status;
 
31
import org.eclipse.debug.core.DebugException;
 
32
import org.eclipse.debug.ui.ISourcePresentation;
 
33
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
 
34
import org.eclipse.jface.preference.IPreferenceStore;
 
35
import org.eclipse.ui.IEditorInput;
 
36
import org.eclipse.ui.IEditorPart;
 
37
import org.eclipse.ui.IPartListener2;
 
38
import org.eclipse.ui.IWindowListener;
 
39
import org.eclipse.ui.IWorkbenchPage;
 
40
import org.eclipse.ui.IWorkbenchPart;
 
41
import org.eclipse.ui.IWorkbenchPartReference;
 
42
import org.eclipse.ui.IWorkbenchWindow;
 
43
import org.eclipse.ui.PartInitException;
 
44
import org.eclipse.ui.ide.IDE;
 
45
import org.eclipse.ui.progress.UIJob;
 
46
 
 
47
public class DisassemblyEditorManager implements IWindowListener, IDisassemblyContextListener, IPartListener2 {
 
48
 
 
49
    private Map<Object, IEditorPart> fEditorParts;
 
50
    private Map<Object, String> fOpenDisassemblyPolicy;
 
51
    private Map<Object, ISteppingModeTarget> fSteppingModePolicy;
 
52
    private DisassemblyDocumentProvider fDocumentProvider;
 
53
    
 
54
    public DisassemblyEditorManager() {
 
55
        fDocumentProvider = new DisassemblyDocumentProvider();
 
56
        fEditorParts = new HashMap<Object, IEditorPart>();
 
57
        fOpenDisassemblyPolicy = new HashMap<Object, String>();
 
58
        fSteppingModePolicy = new HashMap<Object, ISteppingModeTarget>();
 
59
        CDebugUIPlugin.getDefault().getWorkbench().addWindowListener( this );
 
60
        IWorkbenchWindow window = CDebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
 
61
        if ( window != null ) {
 
62
            window.getPartService().addPartListener( this );
 
63
        }
 
64
        getDisassemblyManager().addDisassemblyContextListener( this );
 
65
    }
 
66
 
 
67
    public void dispose() {
 
68
        getDisassemblyManager().removeDisassemblyContextListener( this );
 
69
        CDebugUIPlugin.getDefault().getWorkbench().removeWindowListener( this );
 
70
        fSteppingModePolicy.clear();
 
71
        fOpenDisassemblyPolicy.clear();
 
72
        fEditorParts.clear();
 
73
        fDocumentProvider.dispose();
 
74
    }
 
75
 
 
76
    public DisassemblyDocumentProvider getDocumentProvider() {
 
77
        return fDocumentProvider;
 
78
    }
 
79
 
 
80
    public void openEditor( IWorkbenchPage page, Object debugContext ) throws DebugException {
 
81
        Object disassemblyContext = getDiassemblyContext( debugContext );
 
82
        if ( disassemblyContext != null ) {
 
83
            IEditorPart editor = fEditorParts.get( disassemblyContext );
 
84
            if ( editor == null ) {
 
85
                ISourcePresentation sp = getSourcePresentation();
 
86
                if ( sp == null ) {
 
87
                    throw new DebugException( new Status( IStatus.ERROR, CDebugUIPlugin.getUniqueIdentifier(), 0, "No disassembly editor found", null ) );
 
88
                }
 
89
                IEditorInput input = sp.getEditorInput( debugContext );
 
90
                try {
 
91
                    editor = IDE.openEditor( page, input, sp.getEditorId( input, disassemblyContext ) );
 
92
                    fEditorParts.put( disassemblyContext, editor );
 
93
                    ISteppingModeTarget steppingModeTarget = getSteppingModeTarget( debugContext );
 
94
                    if ( steppingModeTarget != null ) {
 
95
                        if ( ICDebugConstants.PREF_VALUE_STEP_MODE_CONTEXT.equals( 
 
96
                                CDebugCorePlugin.getDefault().getPluginPreferences().getString( ICDebugConstants.PREF_STEP_MODE ) ) )
 
97
                            steppingModeTarget.enableInstructionStepping( true );
 
98
                        fSteppingModePolicy.put( disassemblyContext, steppingModeTarget );
 
99
                    }
 
100
                }
 
101
                catch( PartInitException e ) {
 
102
                    throw new DebugException( e.getStatus() );
 
103
                }
 
104
            }
 
105
            page.activate( editor );
 
106
        }
 
107
    }
 
108
 
 
109
    public IEditorPart findEditor( IWorkbenchPage page, Object debugContext ) {
 
110
        Object disassemblyContext = getDiassemblyContext( debugContext );
 
111
        return ( disassemblyContext != null ) ? fEditorParts.get( disassemblyContext ) : null;
 
112
    }
 
113
 
 
114
    public String getOpenDisassemblyMode( Object debugContext ) {
 
115
        String mode = MessageDialogWithToggle.NEVER;
 
116
        Object disassemblyContext = getDiassemblyContext( debugContext );
 
117
        if ( disassemblyContext != null ) {
 
118
            // shouldn't happen
 
119
            mode = fOpenDisassemblyPolicy.get( disassemblyContext );
 
120
            if ( mode == null ) {
 
121
                IPreferenceStore prefs = CDebugUIPlugin.getDefault().getPreferenceStore();
 
122
                mode = prefs.getString( IInternalCDebugUIConstants.PREF_OPEN_DISASSEMBLY_MODE );
 
123
                fOpenDisassemblyPolicy.put( disassemblyContext, mode );
 
124
            }
 
125
        }
 
126
        return mode;
 
127
    }
 
128
 
 
129
    public void setOpenDisassemblyMode( Object debugContext, String mode ) {
 
130
        Object disassemblyContext = getDiassemblyContext( debugContext );
 
131
        if ( disassemblyContext == null )
 
132
            return;
 
133
        fOpenDisassemblyPolicy.put( disassemblyContext, mode );
 
134
    }
 
135
 
 
136
    /* (non-Javadoc)
 
137
     * @see org.eclipse.ui.IPartListener2#partActivated(org.eclipse.ui.IWorkbenchPartReference)
 
138
     */
 
139
    public void partActivated( IWorkbenchPartReference partRef ) {
 
140
    }
 
141
 
 
142
    /* (non-Javadoc)
 
143
     * @see org.eclipse.ui.IPartListener2#partBroughtToTop(org.eclipse.ui.IWorkbenchPartReference)
 
144
     */
 
145
    public void partBroughtToTop( IWorkbenchPartReference partRef ) {
 
146
    }
 
147
 
 
148
    /* (non-Javadoc)
 
149
     * @see org.eclipse.ui.IPartListener2#partClosed(org.eclipse.ui.IWorkbenchPartReference)
 
150
     */
 
151
    public void partClosed( IWorkbenchPartReference partRef ) {
 
152
        if ( isDisassemblyEditorPart( partRef ) ) {
 
153
            IWorkbenchPart part = partRef.getPart( false );
 
154
            if ( part instanceof IEditorPart ) {
 
155
                IEditorInput input = ((IEditorPart)part).getEditorInput();
 
156
                if ( input instanceof DisassemblyEditorInput ) {
 
157
                    Object disassemblyContext = ((DisassemblyEditorInput)input).getDisassemblyContext();
 
158
                    fEditorParts.remove( disassemblyContext );
 
159
                    ISteppingModeTarget steppingModeTarget = fSteppingModePolicy.remove( disassemblyContext );
 
160
                    if ( steppingModeTarget != null 
 
161
                         && ICDebugConstants.PREF_VALUE_STEP_MODE_CONTEXT.equals( 
 
162
                                 CDebugCorePlugin.getDefault().getPluginPreferences().getString( ICDebugConstants.PREF_STEP_MODE ) ) )
 
163
                           steppingModeTarget.enableInstructionStepping( false );
 
164
                }
 
165
            }
 
166
        }
 
167
    }
 
168
 
 
169
    /* (non-Javadoc)
 
170
     * @see org.eclipse.ui.IPartListener2#partDeactivated(org.eclipse.ui.IWorkbenchPartReference)
 
171
     */
 
172
    public void partDeactivated( IWorkbenchPartReference partRef ) {
 
173
        // TODO Auto-generated method stub
 
174
        
 
175
    }
 
176
 
 
177
    /* (non-Javadoc)
 
178
     * @see org.eclipse.ui.IPartListener2#partHidden(org.eclipse.ui.IWorkbenchPartReference)
 
179
     */
 
180
    public void partHidden( IWorkbenchPartReference partRef ) {
 
181
        // TODO Auto-generated method stub
 
182
        
 
183
    }
 
184
 
 
185
    /* (non-Javadoc)
 
186
     * @see org.eclipse.ui.IPartListener2#partInputChanged(org.eclipse.ui.IWorkbenchPartReference)
 
187
     */
 
188
    public void partInputChanged( IWorkbenchPartReference partRef ) {
 
189
        // TODO Auto-generated method stub
 
190
        
 
191
    }
 
192
 
 
193
    /* (non-Javadoc)
 
194
     * @see org.eclipse.ui.IPartListener2#partOpened(org.eclipse.ui.IWorkbenchPartReference)
 
195
     */
 
196
    public void partOpened( IWorkbenchPartReference partRef ) {
 
197
        if ( isDisassemblyEditorPart( partRef ) ) {
 
198
            IWorkbenchPart part = partRef.getPart( false );
 
199
            if ( part instanceof IEditorPart ) {
 
200
                IEditorInput input = ((IEditorPart)part).getEditorInput();
 
201
                if ( input instanceof DisassemblyEditorInput ) {
 
202
                    Object disassemblyContext = ((DisassemblyEditorInput)input).getDisassemblyContext();
 
203
                    fEditorParts.put( disassemblyContext, (IEditorPart)part );
 
204
                }
 
205
            }
 
206
        }
 
207
    }
 
208
 
 
209
    /* (non-Javadoc)
 
210
     * @see org.eclipse.ui.IPartListener2#partVisible(org.eclipse.ui.IWorkbenchPartReference)
 
211
     */
 
212
    public void partVisible( IWorkbenchPartReference partRef ) {
 
213
        // TODO Auto-generated method stub
 
214
        
 
215
    }
 
216
 
 
217
    /* (non-Javadoc)
 
218
     * @see org.eclipse.ui.IWindowListener#windowActivated(org.eclipse.ui.IWorkbenchWindow)
 
219
     */
 
220
    public void windowActivated( IWorkbenchWindow window ) {
 
221
    }
 
222
 
 
223
    /* (non-Javadoc)
 
224
     * @see org.eclipse.ui.IWindowListener#windowClosed(org.eclipse.ui.IWorkbenchWindow)
 
225
     */
 
226
    public void windowClosed( IWorkbenchWindow window ) {
 
227
        window.getPartService().removePartListener( this );
 
228
    }
 
229
 
 
230
    /* (non-Javadoc)
 
231
     * @see org.eclipse.ui.IWindowListener#windowDeactivated(org.eclipse.ui.IWorkbenchWindow)
 
232
     */
 
233
    public void windowDeactivated( IWorkbenchWindow window ) {
 
234
        // TODO Auto-generated method stub
 
235
        
 
236
    }
 
237
 
 
238
    /* (non-Javadoc)
 
239
     * @see org.eclipse.ui.IWindowListener#windowOpened(org.eclipse.ui.IWorkbenchWindow)
 
240
     */
 
241
    public void windowOpened( IWorkbenchWindow window ) {
 
242
        window.getPartService().addPartListener( this );
 
243
    }
 
244
 
 
245
    /* (non-Javadoc)
 
246
     * @see org.eclipse.cdt.debug.core.disassembly.IDisassemblyContextListener#contextAdded(java.lang.Object)
 
247
     */
 
248
    public void contextAdded( Object context ) {
 
249
        // TODO Auto-generated method stub
 
250
        
 
251
    }
 
252
 
 
253
    /* (non-Javadoc)
 
254
     * @see org.eclipse.cdt.debug.core.disassembly.IDisassemblyContextListener#contextRemoved(java.lang.Object)
 
255
     */
 
256
    public void contextRemoved( Object context ) {
 
257
        final IEditorPart editor = fEditorParts.remove( context );
 
258
        if ( editor != null ) {
 
259
            UIJob job = new UIJob( editor.getSite().getShell().getDisplay(), "Closing disassembly" ) { //$NON-NLS-1$
 
260
 
 
261
                /* (non-Javadoc)
 
262
                 * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
 
263
                 */
 
264
                @Override
 
265
                public IStatus runInUIThread( IProgressMonitor monitor ) {
 
266
                    editor.getSite().getPage().closeEditor( editor, false );
 
267
                    return Status.OK_STATUS;
 
268
                }
 
269
            };
 
270
            job.setSystem( true );
 
271
            job.schedule();
 
272
        }
 
273
    }
 
274
 
 
275
    private IDisassemblyContextService getDisassemblyManager() {
 
276
        return CDebugCorePlugin.getDefault().getDisassemblyContextService();
 
277
    }
 
278
 
 
279
    private boolean isDisassemblyEditorPart( IWorkbenchPartReference partRef ) {
 
280
        // TODO: check all editors contributed via the extension point
 
281
        return ( partRef.getId().equals( ICDebugUIConstants.ID_DEFAULT_DISASSEMBLY_EDITOR ) );
 
282
    }
 
283
 
 
284
    private ISourcePresentation getSourcePresentation() {
 
285
 
 
286
        return new ISourcePresentation() {
 
287
 
 
288
            public IEditorInput getEditorInput( Object element ) {
 
289
                Object disassemblyContext = getDiassemblyContext( element );
 
290
                return new DisassemblyEditorInput( element, disassemblyContext );
 
291
            }
 
292
 
 
293
            public String getEditorId( IEditorInput input, Object element ) {
 
294
                return ICDebugUIConstants.ID_DEFAULT_DISASSEMBLY_EDITOR;
 
295
            }
 
296
        };
 
297
    }
 
298
 
 
299
    protected Object getDiassemblyContext( Object element ) {
 
300
        IDisassemblyContextProvider adapter = getDisassemblyContextProvider( element );
 
301
        return ( adapter != null ) ? adapter.getDisassemblyContext( element ) : null;
 
302
    }
 
303
 
 
304
    private IDisassemblyContextProvider getDisassemblyContextProvider( Object element ) {
 
305
        IDisassemblyContextProvider adapter = null;
 
306
        if ( element instanceof IDisassemblyContextProvider ) {
 
307
            adapter = (IDisassemblyContextProvider)element;
 
308
        }
 
309
        else if ( element instanceof IAdaptable ) {
 
310
            IAdaptable adaptable = (IAdaptable)element;
 
311
            adapter = (IDisassemblyContextProvider)adaptable.getAdapter( IDisassemblyContextProvider.class );
 
312
        }
 
313
        return adapter;
 
314
    }
 
315
 
 
316
    private ISteppingModeTarget getSteppingModeTarget( Object debugContext ) {
 
317
        if ( debugContext instanceof ISteppingModeTarget )
 
318
            return (ISteppingModeTarget)debugContext;
 
319
        if ( debugContext instanceof IAdaptable )
 
320
            return (ISteppingModeTarget)((IAdaptable)debugContext).getAdapter( ISteppingModeTarget.class );
 
321
        return null;
 
322
    }
 
323
}