Attachment #202827 for bug #353225




openSourceObjectAction.tooltip = Shows the JavaScript source for the selected script element
commandCategory.description = Tooling for debugging JavaScript
commandCategory.name = JavaScript Debug

showFunctionVarAction.label = Show function variables
showFunctionVarAction.tooltip = Show or hide function variables
showThisVarAction.label = Show 'this' variable
showThisVarAction.tooltip = Show or hide the this variable
showProtoVarAction.label = Show proto variables
showProtoVarAction.tooltip = Show or hide proto variables

evaluateAction.label = E&valuate
evaluateCommand.label = Evaluate
evaluateAction.description = Evaluates the selected text in the JavaScript editor
hyperlinkDetector.description = Allows for quickly stepping into functions in JavaScript source using hyper-links
hyperlinkDetector.name = Step Into Selection
debugPrefPage.name = Debug
debugPrefPageKeyword.label = debug,jsdt,javascript,wst,breakpoint,launch,suspend,scripts
hover.description = Shows the value of the selected variable while debugging
hover.label = JavaScript Variable Hover




###############################################################################
# Copyright (c) 2010, 2011 IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################
source.. = src/
output.. = bin/
bin.includes = META-INF/,\

Lines 37-42 Link Here

(-)plugin.xml (-32 / +182 lines)
37	<adapter	37	<adapter
38	type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget">	38	type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget">
39	</adapter>	39	</adapter>
		40	<adapter
		41	type="org.eclipse.debug.ui.actions.IRunToLineTarget">
		42	</adapter>
40	</factory>	43	</factory>
41	<factory	44	<factory
42	adaptableType="org.eclipse.wst.jsdt.core.IFunction"	45	adaptableType="org.eclipse.wst.jsdt.core.IFunction"
Lines 173-179 Link Here
173	class="org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleFunctionBreakpointActionDelegate"	176	class="org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleFunctionBreakpointActionDelegate"
174	enablesFor="+"	177	enablesFor="+"
175	helpContextId="toggle_function_bp_outline"	178	helpContextId="toggle_function_bp_outline"
176	icon="icons/elcl16/brkp_obj.gif"	179	icon="$nl$/icons/elcl16/brkp_obj.gif"
177	id="org.eclipse.wst.jsdt.debug.ui.outline.function.toggle.breakpoint.action"	180	id="org.eclipse.wst.jsdt.debug.ui.outline.function.toggle.breakpoint.action"
178	label="%toggleFunctionBreakpointAction.name"	181	label="%toggleFunctionBreakpointAction.name"
179	menubarPath="additions"	182	menubarPath="additions"
Lines 220-230 Link Here
220	tooltip="%openSourceObjectAction.tooltip">	223	tooltip="%openSourceObjectAction.tooltip">
221	</action>	224	</action>
222	</objectContribution>	225	</objectContribution>
		226	<viewerContribution
		227	id="org.eclipse.wst.jsdt.debug.ui.classfile.editor.actions"
		228	targetID="#ClassFileEditorContext">
		229	<visibility>
		230	<and>
		231	<objectClass
		232	name="org.eclipse.jface.text.ITextSelection">
		233	</objectClass>
		234	<systemProperty
		235	name="org.eclipse.wst.jsdt.debug.ui.jsdebuggerActive"
		236	value="true">
		237	</systemProperty>
		238	</and>
		239	</visibility>
		240	<action
		241	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.EvaluateEditorPopupAction"
		242	definitionId="org.eclipse.wst.jsdt.debug.ui.evaluate.command"
		243	helpContextId="evaluate_jsunit_snippet_action_context"
		244	icon="$nl$/icons/elcl16/jsbook_obj.gif"
		245	id="org.eclipse.wst.jsdt.debug.ui.jsunit.popup.evaluate"
		246	label="%evaluateAction.label"
		247	menubarPath="jsdebug"
		248	tooltip="%evaluateAction.description">
		249	</action>
		250	</viewerContribution>
		251	<viewerContribution
		252	id="org.eclipse.wst.jsdt.debug.ui.jsunit.editor.actions"
		253	targetID="#JavaScriptEditorContext">
		254	<visibility>
		255	<and>
		256	<objectClass
		257	name="org.eclipse.jface.text.ITextSelection">
		258	</objectClass>
		259	<systemProperty
		260	name="org.eclipse.wst.jsdt.debug.ui.jsdebuggerActive"
		261	value="true">
		262	</systemProperty>
		263	</and>
		264	</visibility>
		265	<action
		266	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.EvaluateEditorPopupAction"
		267	definitionId="org.eclipse.wst.jsdt.debug.ui.evaluate.command"
		268	helpContextId="evaluate_jsunit_snippet_action_context"
		269	icon="$nl$/icons/elcl16/jsbook_obj.gif"
		270	id="org.eclipse.wst.jsdt.debug.ui.jsunit.popup.evaluate"
		271	label="%evaluateAction.label"
		272	menubarPath="jsdebug"
		273	tooltip="%evaluateAction.description">
		274	</action>
		275	<menu
		276	id="org.eclipse.wst.jsdt.debug.ui.jsdebug.cu.menu"
		277	label="%javascriptMenu.name"
		278	path="additions">
		279	<groupMarker
		280	name="jsdebug">
		281	</groupMarker>
		282	<separator
		283	name="jsdebug">
		284	</separator>
		285	</menu>
		286	</viewerContribution>
223	</extension>	287	</extension>
224	<extension	288	<extension
225	point="org.eclipse.debug.ui.debugModelPresentations">	289	point="org.eclipse.debug.ui.debugModelPresentations">
226	<debugModelPresentation	290	<debugModelPresentation
227	class="org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptModelPresentation"	291	class="org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptModelPresentation"
		292	detailsViewerConfiguration="org.eclipse.wst.jsdt.debug.internal.ui.display.JavaScriptDebugViewerConfiguration"
228	id="org.eclipse.wst.jsdt.debug.model">	293	id="org.eclipse.wst.jsdt.debug.model">
229	</debugModelPresentation>	294	</debugModelPresentation>
230	</extension>	295	</extension>
Lines 260-265 Link Here
260	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"	325	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
261	sequence="M1+M2+3">	326	sequence="M1+M2+3">
262	</key>	327	</key>
		328	<key
		329	commandId="org.eclipse.wst.jsdt.debug.ui.evaluate.command"
		330	contextId="org.eclipse.wst.jsdt.ui.javaEditorScope"
		331	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
		332	sequence="M3+M2+E">
		333	</key>
263	</extension>	334	</extension>
264	<extension	335	<extension
265	point="org.eclipse.ui.commands">	336	point="org.eclipse.ui.commands">
Lines 282-287 Link Here
282	id="org.eclipse.wst.jsdt.debug.ui.category"	353	id="org.eclipse.wst.jsdt.debug.ui.category"
283	name="%commandCategory.name">	354	name="%commandCategory.name">
284	</category>	355	</category>
		356	<command
		357	categoryId="org.eclipse.wst.jsdt.debug.ui.category"
		358	description="%evaluateAction.description"
		359	helpContextId="evaluate_command_help_context"
		360	id="org.eclipse.wst.jsdt.debug.ui.evaluate.command"
		361	name="%evaluateCommand.label">
		362	</command>
285	</extension>	363	</extension>
286	<extension	364	<extension
287	point="org.eclipse.ui.viewActions">	365	point="org.eclipse.ui.viewActions">
Lines 341-346 Link Here
341	tooltip="%showAllScripts.tooltip">	419	tooltip="%showAllScripts.tooltip">
342	</action>	420	</action>
343	</viewContribution>	421	</viewContribution>
		422	<viewContribution
		423	id="variableViewActions"
		424	targetID="org.eclipse.debug.ui.VariableView">
		425	<menu
		426	id="org.eclipse.wst.jsdt.debug.ui.variableview.menu"
		427	label="%javascriptMenu.name">
		428	<groupMarker
		429	name="js">
		430	</groupMarker>
		431	</menu>
		432	<action
		433	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.FunctionFilterAction"
		434	helpContextId="show_functions_variable_help_context"
		435	id="org.eclipse.wst.jsdt.debug.ui.variableview.show.functions"
		436	label="%showFunctionVarAction.label"
		437	menubarPath="org.eclipse.wst.jsdt.debug.ui.variableview.menu/js"
		438	style="toggle"
		439	tooltip="%showFunctionVarAction.tooltip">
		440	</action>
		441	<action
		442	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.ThisFilterAction"
		443	helpContextId="show_this_variable_help_context"
		444	icon="$nl$/icons/elcl16/this_var.gif"
		445	id="org.eclipse.wst.jsdt.debug.ui.variableview.show.this"
		446	label="%showThisVarAction.label"
		447	menubarPath="org.eclipse.wst.jsdt.debug.ui.variableview.menu/js"
		448	style="toggle"
		449	tooltip="%showThisVarAction.tooltip">
		450	</action>
		451	<action
		452	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.ProtoFilterAction"
		453	helpContextId="show_proto_variables_help_context"
		454	icon="$nl$/icons/elcl16/proto_var.gif"
		455	id="org.eclipse.wst.jsdt.debug.ui.variableview.show.prototypes"
		456	label="%showProtoVarAction.label"
		457	menubarPath="org.eclipse.wst.jsdt.debug.ui.variableview.menu/js"
		458	style="toggle"
		459	tooltip="%showProtoVarAction.tooltip">
		460	</action>
		461	</viewContribution>
344	</extension>	462	</extension>
345	<extension	463	<extension
346	point="org.eclipse.debug.ui.detailPaneFactories">	464	point="org.eclipse.debug.ui.detailPaneFactories">
Lines 370-406 Link Here
370	</detailFactories>	488	</detailFactories>
371	</extension>	489	</extension>
372	<extension	490	<extension
373	point="org.eclipse.debug.ui.launchShortcuts">
374	<shortcut
375	class="org.eclipse.wst.jsdt.debug.internal.ui.launching.JavaScriptLaunchShortcut"
376	description="%javascriptLaunchShortcut.description"
377	helpContextId="javasript_lanch_shortcut"
378	icon="$nl$/icons/elcl16/script.gif"
379	id="org.eclipse.wst.jsdt.debug.ui.launch.shortcut"
380	label="%javascriptLaunchShortcut.label"
381	modes="debug">
382	<configurationType
383	id="org.eclipse.wst.jsdt.debug.core.launchConfigurationType">
384	</configurationType>
385	<contextualLaunch>
386	<enablement>
387	<with
388	variable="selection">
389	<iterate>
390	<and>
391	<adapt
392	type="org.eclipse.wst.jsdt.core.IJavaScriptElement">
393	</adapt>
394	</and></iterate>
395	<count
396	value="1">
397	</count>
398	</with>
399	</enablement>
400	</contextualLaunch>
401	</shortcut>
402	</extension>
403	<extension
404	point="org.eclipse.ui.ide.markerSupport">	491	point="org.eclipse.ui.ide.markerSupport">
405	<markerTypeCategory	492	<markerTypeCategory
406	name="%breakpointMarkerCategory.name">	493	name="%breakpointMarkerCategory.name">
Lines 421-424 Link Here
421	</markerTypeReference>	508	</markerTypeReference>
422	</markerTypeCategory>	509	</markerTypeCategory>
423	</extension>	510	</extension>
		511	<extension
		512	point="org.eclipse.core.runtime.preferences">
		513	<initializer
		514	class="org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPreferenceInitializer">
		515	</initializer>
		516	</extension>
		517	<extension
		518	point="org.eclipse.ui.handlers">
		519	<handler
		520	class="org.eclipse.wst.jsdt.debug.internal.ui.actions.EvaluateEditorPopupAction"
		521	commandId="org.eclipse.wst.jsdt.debug.ui.evaluate.command"
		522	helpContextId="evaluate_command_help_context">
		523	</handler>
		524	</extension>
		525	<extension
		526	point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectors">
		527	<hyperlinkDetector
		528	activate="true"
		529	class="org.eclipse.wst.jsdt.debug.internal.ui.eval.JavaScriptHyperlinkDetector"
		530	description="%hyperlinkDetector.description"
		531	id="org.eclipse.wst.jsdt.debug.ui.hyperlink.detector"
		532	modifierKeys="M1+M3"
		533	name="%hyperlinkDetector.name"
		534	targetId="org.eclipse.wst.jsdt.ui.javaCode">
		535	</hyperlinkDetector>
		536	</extension>
		537	<extension
		538	point="org.eclipse.ui.preferencePages">
		539	<page
		540	category="org.eclipse.wst.jsdt.ui.preferences.JavaBasePreferencePage"
		541	class="org.eclipse.wst.jsdt.debug.internal.ui.preferences.JavaScriptDebugPreferencePage"
		542	id="org.eclipse.wst.jsdt.debug.ui.debug.page"
		543	name="%debugPrefPage.name">
		544	<keywordReference
		545	id="org.eclipse.wst.jsdt.debug.ui.debug.pref.page.keyword">
		546	</keywordReference>
		547	</page>
		548	</extension>
		549	<extension
		550	point="org.eclipse.ui.keywords">
		551	<keyword
		552	id="org.eclipse.wst.jsdt.debug.ui.debug.pref.page.keyword"
		553	label="%debugPrefPageKeyword.label">
		554	</keyword>
		555	</extension>
		556	<extension
		557	point="org.eclipse.wst.jsdt.ui.javaEditorTextHovers">
		558	<hover
		559	class="org.eclipse.wst.jsdt.debug.internal.ui.eval.JavaScriptDebugHover"
		560	description="%hover.description"
		561	id="org.eclipse.wst.jsdt.debug.ui.variable.value.hover"
		562	label="%hover.label">
		563	</hover>
		564	</extension>
		565	<extension
		566	point="org.eclipse.ui.editors.markerUpdaters">
		567	<updater
		568	class="org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.JavaScriptBreakpointUpdater"
		569	id="org.eclipse.wst.jsdt.debug.ui.breakpoint.updater"
		570	markerType="org.eclipse.wst.jsdt.debug.core.breakpoint.marker">
		571	</updater>
		572	</extension>
		573
424	</plugin>	574	</plugin>




/*******************************************************************************
 * Copyright (c) 2008, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui;

/**
 * Constants for the {@link JavaScriptDebugUIPlugin}
 * 
 * @since 1.1
 */
public interface Constants {

	/**
	 * Constant for the preference for showing / hiding functions from the variables view
	 * <br><br>
	 * Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_functions</code>
	 */
	public static final String SHOW_FUNCTIONS = JavaScriptDebugUIPlugin.PLUGIN_ID + ".show_functions"; //$NON-NLS-1$
	/**
	 * Constant for the preference for showing / hiding prototypes from the variables view
	 * <br><br>
	 * Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_protoypes</code>
	 */
	public static final String SHOW_PROTOTYPES = JavaScriptDebugUIPlugin.PLUGIN_ID + ".show_prototypes"; //$NON-NLS-1$
	/**
	 * Constant for the preference for showing / hiding the <code>this</code> variable from the variables view
	 * <br><br>
	 * Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_this</code>
	 */
	public static final String SHOW_THIS = JavaScriptDebugUIPlugin.PLUGIN_ID + "show_this"; //$NON-NLS-1$
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	 * Help constant for the connect tab
	 */
	public static final String CONNECT_TAB = JavaScriptDebugUIPlugin.PLUGIN_ID + ".connect_tab"; //$NON-NLS-1$
	/**
	 * Help constant for the Debug root preference page
	 * @since 1.1
	 */
	public static final String DEBUG_PREFERENCE_PAGE = JavaScriptDebugUIPlugin.PLUGIN_ID + ".debug_pref_page"; //$NON-NLS-1$
	/**
	 * Help constant for the Source tab
	 * @since 1.2
	 */
	public static final String SOURCE_LOOKUP_TAB = JavaScriptDebugUIPlugin.PLUGIN_ID + ".source_lookup_tab"; //$NON-NLS-1$
	/**
	 * Help constant for the Environment tab
	 * @since 1.2
	 */
	public static final String ENVIRONMENT_TAB = JavaScriptDebugUIPlugin.PLUGIN_ID + ".environment_tab"; //$NON-NLS-1$
	/**
	 * Help constant for the Common tab
	 * @since 1.2
	 */
	public static final String COMMON_TAB = JavaScriptDebugUIPlugin.PLUGIN_ID + ".common_tab"; //$NON-NLS-1$
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/JavaScriptDebugUIPlugin.java (-1 / +32 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.	2	* Copyright (c) 2010, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 16-21 Link Here
16	import org.eclipse.core.resources.IProject;	16	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.Status;	18	import org.eclipse.core.runtime.Status;
		19	import org.eclipse.core.runtime.preferences.InstanceScope;
		20	import org.eclipse.jface.preference.IPreferenceStore;
		21	import org.eclipse.swt.widgets.Display;
19	import org.eclipse.ui.IEditorReference;	22	import org.eclipse.ui.IEditorReference;
20	import org.eclipse.ui.IWorkbench;	23	import org.eclipse.ui.IWorkbench;
21	import org.eclipse.ui.IWorkbenchListener;	24	import org.eclipse.ui.IWorkbenchListener;
Lines 25-31 Link Here
25	import org.eclipse.ui.PlatformUI;	28	import org.eclipse.ui.PlatformUI;
26	import org.eclipse.ui.ide.ResourceUtil;	29	import org.eclipse.ui.ide.ResourceUtil;
27	import org.eclipse.ui.plugin.AbstractUIPlugin;	30	import org.eclipse.ui.plugin.AbstractUIPlugin;
		31	import org.eclipse.ui.preferences.ScopedPreferenceStore;
28	import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;	32	import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;
		33	import org.eclipse.wst.jsdt.debug.internal.ui.eval.EvaluationManager;
29	import org.osgi.framework.BundleContext;	34	import org.osgi.framework.BundleContext;
30		35
31	/**	36	/**
Lines 48-53 Link Here
48		53
49	// The shared instance	54	// The shared instance
50	private static JavaScriptDebugUIPlugin plugin;	55	private static JavaScriptDebugUIPlugin plugin;
		56	private static ScopedPreferenceStore corestore = new ScopedPreferenceStore(InstanceScope.INSTANCE, JavaScriptDebugPlugin.PLUGIN_ID);
51		57
52	/*	58	/*
53	* (non-Javadoc)	59	* (non-Javadoc)
Lines 57-62 Link Here
57	super.start(context);	63	super.start(context);
58	plugin = this;	64	plugin = this;
59	PlatformUI.getWorkbench().addWorkbenchListener(this);	65	PlatformUI.getWorkbench().addWorkbenchListener(this);
		66	EvaluationManager.getManager().start();
60	}	67	}
61		68
62	/*	69	/*
Lines 67-72 Link Here
67	try {	74	try {
68	plugin = null;	75	plugin = null;
69	PlatformUI.getWorkbench().removeWorkbenchListener(this);	76	PlatformUI.getWorkbench().removeWorkbenchListener(this);
		77	EvaluationManager.getManager().stop();
70	super.stop(context);	78	super.stop(context);
71	}	79	}
72	finally {	80	finally {
Lines 173-176 Link Here
173	*/	181	*/
174	public void postShutdown(IWorkbench workbench) {	182	public void postShutdown(IWorkbench workbench) {
175	}	183	}
		184
		185	/**
		186	* Returns the standard display to be used. The method first checks, if
		187	* the thread calling this method has an associated display. If so, this
		188	* display is returned. Otherwise the method returns the default display.
		189	*/
		190	public static Display getStandardDisplay() {
		191	Display display;
		192	display = Display.getCurrent();
		193	if (display == null) {
		194	display = Display.getDefault();
		195	}
		196	return display;
		197	}
		198
		199	/**
		200	* Returns an {@link IPreferenceStore} wrapper for the {@link JavaScriptDebugPlugin} core preferences
		201	*
		202	* @return an {@link IPreferenceStore} for the core preferences
		203	*/
		204	public static IPreferenceStore getCorePreferenceStore() {
		205	return corestore;
		206	}
176	}	207	}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui;

import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
import org.eclipse.jface.preference.IPreferenceStore;

/**
 * Initialize common preferences for {@link JavaScriptDebugUIPlugin}
 * 
 * @since 1.1
 */
public class JavaScriptDebugUIPreferenceInitializer extends AbstractPreferenceInitializer {

	/**
	 * Constructor
	 */
	public JavaScriptDebugUIPreferenceInitializer() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()
	 */
	public void initializeDefaultPreferences() {
		IPreferenceStore store = JavaScriptDebugUIPlugin.getDefault().getPreferenceStore();
		store.setDefault(Constants.SHOW_FUNCTIONS, true);
		store.setDefault(Constants.SHOW_PROTOTYPES, true);
		store.setDefault(Constants.SHOW_THIS, true);
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/JavaScriptModelPresentation.java (-36 / +188 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.	2	* Copyright (c) 2009, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-17 Link Here
11	package org.eclipse.wst.jsdt.debug.internal.ui;	11	package org.eclipse.wst.jsdt.debug.internal.ui;
12		12
13	import java.io.File;	13	import java.io.File;
		14	import java.io.UnsupportedEncodingException;
14	import java.net.URISyntaxException;	15	import java.net.URISyntaxException;
		16	import java.net.URLDecoder;
15	import java.util.HashMap;	17	import java.util.HashMap;
16		18
17	import org.eclipse.core.filesystem.EFS;	19	import org.eclipse.core.filesystem.EFS;
Lines 19-32 Link Here
19	import org.eclipse.core.resources.IResource;	21	import org.eclipse.core.resources.IResource;
20	import org.eclipse.core.resources.ResourcesPlugin;	22	import org.eclipse.core.resources.ResourcesPlugin;
21	import org.eclipse.core.runtime.CoreException;	23	import org.eclipse.core.runtime.CoreException;
		24	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.Path;	25	import org.eclipse.core.runtime.Path;
23	import org.eclipse.core.runtime.URIUtil;	26	import org.eclipse.core.runtime.URIUtil;
24	import org.eclipse.debug.core.DebugException;	27	import org.eclipse.debug.core.DebugException;
		28	import org.eclipse.debug.core.model.IBreakpoint;
		29	import org.eclipse.debug.core.model.IDebugElement;
25	import org.eclipse.debug.core.model.IDebugTarget;	30	import org.eclipse.debug.core.model.IDebugTarget;
		31	import org.eclipse.debug.core.model.IDisconnect;
26	import org.eclipse.debug.core.model.IStackFrame;	32	import org.eclipse.debug.core.model.IStackFrame;
		33	import org.eclipse.debug.core.model.ITerminate;
27	import org.eclipse.debug.core.model.IThread;	34	import org.eclipse.debug.core.model.IThread;
28	import org.eclipse.debug.core.model.IValue;	35	import org.eclipse.debug.core.model.IValue;
29	import org.eclipse.debug.core.model.IVariable;	36	import org.eclipse.debug.core.model.IVariable;
		37	import org.eclipse.debug.core.sourcelookup.containers.LocalFileStorage;
30	import org.eclipse.debug.ui.IDebugModelPresentationExtension;	38	import org.eclipse.debug.ui.IDebugModelPresentationExtension;
31	import org.eclipse.debug.ui.IValueDetailListener;	39	import org.eclipse.debug.ui.IValueDetailListener;
32	import org.eclipse.jface.viewers.LabelProvider;	40	import org.eclipse.jface.viewers.LabelProvider;
Lines 43-53 Link Here
43	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptFunctionBreakpoint;	51	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptFunctionBreakpoint;
44	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLineBreakpoint;	52	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLineBreakpoint;
45	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLoadBreakpoint;	53	import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLoadBreakpoint;
		54	import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
		55	import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptThread;
46	import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;	56	import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;
47	import org.eclipse.wst.jsdt.debug.core.model.IScript;	57	import org.eclipse.wst.jsdt.debug.core.model.IScript;
48	import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;	58	import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;
		59	import org.eclipse.wst.jsdt.debug.internal.core.Constants;
		60	import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;
49	import org.eclipse.wst.jsdt.debug.internal.core.TextUtils;	61	import org.eclipse.wst.jsdt.debug.internal.core.TextUtils;
		62	import org.eclipse.wst.jsdt.debug.internal.core.breakpoints.JavaScriptExceptionBreakpoint;
50	import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptValue;	63	import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptValue;
		64	import org.eclipse.wst.jsdt.debug.internal.ui.eval.JavaScriptInspectExpression;
51		65
52	/**	66	/**
53	* Default model presentation for JSDI model elements	67	* Default model presentation for JSDI model elements
Lines 126-177 Link Here
126	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)	140	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
127	*/	141	*/
128	public String getText(Object element) {	142	public String getText(Object element) {
		143	StringBuffer buffer = new StringBuffer();
129	try {	144	try {
130	if(element instanceof IDebugTarget) {	145	if(element instanceof IDebugElement) {
131	return ((IDebugTarget)element).getName();	146	if(element instanceof IDebugTarget) {
		147	buffer.append(((IDebugTarget)element).getName());
		148	}
		149	else if(element instanceof IStackFrame) {
		150	buffer.append(getStackframeText((IJavaScriptStackFrame) element));
		151	}
		152	else if(element instanceof IThread) {
		153	buffer.append(getThreadText((IJavaScriptThread) element));
		154	}
		155	else if(element instanceof IVariable) {
		156	buffer.append(((IVariable)element).getName());
		157	}
		158	else if(element instanceof IValue) {
		159	buffer.append(((IValue)element).getValueString());
		160	}
		161	else if(element instanceof IScriptGroup) {
		162	buffer.append(Messages.scripts);
		163	}
		164	else if(element instanceof IScript) {
		165	buffer.append(getScriptText((IScript) element));
		166	}
132	}	167	}
133	if(element instanceof IStackFrame) {	168	if(element instanceof JavaScriptInspectExpression) {
134	return ((IStackFrame)element).getName();	169	JavaScriptInspectExpression exp = (JavaScriptInspectExpression) element;
		170	return exp.getValue().getReferenceTypeName();
		171	}
		172	if(element instanceof ITerminate) {
		173	if(((ITerminate)element).isTerminated()) {
		174	buffer.insert(0, Messages.terminated);
		175	}
		176	else if(element instanceof IDisconnect) {
		177	if(((IDisconnect)element).isDisconnected()) {
		178	buffer.insert(0, Messages.disconnected);
		179	}
		180	}
135	}	181	}
136	if(element instanceof IThread) {	182	else if(element instanceof IDisconnect) {
137	return ((IThread)element).getName();	183	if(((IDisconnect)element).isDisconnected()) {
		184	buffer.insert(0, Messages.disconnected);
		185	}
138	}	186	}
139	if(element instanceof IVariable) {	187	else if(element instanceof IJavaScriptFunctionBreakpoint) {
140	return ((IVariable)element).getName();	188	buffer.append(getFunctionBreakpointText((IJavaScriptFunctionBreakpoint) element));
141	}	189	}
142	if(element instanceof IValue) {	190	else if(element instanceof IJavaScriptLoadBreakpoint) {
143	return ((IValue)element).getValueString();	191	buffer.append(getScriptLoadBreakpointText((IJavaScriptLoadBreakpoint) element));
144	}	192	}
145	if(element instanceof IJavaScriptFunctionBreakpoint) {	193	else if(element instanceof IJavaScriptLineBreakpoint) {
146	return getFunctionBreakpointText((IJavaScriptFunctionBreakpoint) element);	194	buffer.append(getLineBreakpointText((IJavaScriptLineBreakpoint) element));
147	}	195	}
148	if(element instanceof IJavaScriptLoadBreakpoint) {	196	}
149	return getScriptLoadBreakpointText((IJavaScriptLoadBreakpoint) element);	197	catch(CoreException ce) {
		198	JavaScriptDebugUIPlugin.log(ce);
		199	buffer.append(Messages.unknown);
		200	}
		201	if(buffer.length() < 1) {
		202	return Messages.unknown;
		203	}
		204	return buffer.toString();
		205	}
		206
		207	/**
		208	* Computes the thread name + adornment
		209	*
		210	* @param thread
		211	* @return
		212	* @throws DebugException
		213	*/
		214	String getThreadText(IJavaScriptThread thread) throws DebugException {
		215	String adornment = Messages.unknown_state;
		216	if(thread.isSuspended()) {
		217	IBreakpoint[] bps = thread.getBreakpoints();
		218	if(bps.length > 0) {
		219	try {
		220	IJavaScriptBreakpoint breakpoint = (IJavaScriptBreakpoint) bps[0];
		221	if (breakpoint instanceof IJavaScriptLoadBreakpoint) {
		222	String name = breakpoint.getScriptPath();
		223	if (Constants.EMPTY_STRING.equals(name)) {
		224	name = getSourceName(thread);
		225	}
		226	else {
		227	//decode it
		228	try {
		229	name = URLDecoder.decode(name, Constants.UTF_8);
		230	}
		231	catch(UnsupportedEncodingException uee) {
		232	//ignore
		233	}
		234	}
		235	adornment = NLS.bind(Messages.suspend_loading_script, name);
		236	}
		237	else if(breakpoint instanceof JavaScriptExceptionBreakpoint) {
		238	adornment = NLS.bind(Messages.suspended_on_exception, breakpoint.getMarker().getAttribute(JavaScriptExceptionBreakpoint.MESSAGE));
		239	}
		240	else if (breakpoint instanceof IJavaScriptLineBreakpoint) {
		241	IJavaScriptLineBreakpoint bp = (IJavaScriptLineBreakpoint) breakpoint;
		242	adornment = NLS.bind(Messages.suspended_on_line_breakpoint, new String[] { Integer.toString(bp.getLineNumber()), getSourceName(thread) });
		243	}
		244	else if(breakpoint instanceof IJavaScriptFunctionBreakpoint) {
		245	IJavaScriptFunctionBreakpoint bp = (IJavaScriptFunctionBreakpoint) breakpoint;
		246	adornment = NLS.bind(Messages.suspended_on_func_breakpoint, new String[] {bp.getFunctionName(), getSourceName(thread)});
		247	}
		248	// TODO also need to report stopped at debugger; statement
		249	} catch (CoreException ce) {
		250	JavaScriptDebugPlugin.log(ce);
		251	}
150	}	252	}
151	if(element instanceof IJavaScriptLineBreakpoint) {	253	else {
152	return getLineBreakpointText((IJavaScriptLineBreakpoint) element);	254	adornment = Messages.suspended_state;
153	}	255	}
154	if(element instanceof IScriptGroup) {	256	}
155	return Messages.scripts;	257	else if(thread.isStepping()) {
		258	adornment = Messages.stepping_state;
		259	}
		260	else if(thread.isTerminated()) {
		261	adornment = Messages.terminated_state;
		262	}
		263	else {
		264	adornment = Messages.running_state;
		265	}
		266	return NLS.bind(Messages.thread_name, new String[] {thread.getName(), adornment});
		267	}
		268
		269	/**
		270	* Returns the name of the source from the top stackframe or a default name
		271	* <code><evaluated_source></code>
		272	*
		273	* @return the name for the source
		274	* @throws DebugException
		275	*/
		276	String getSourceName(IJavaScriptThread thread) throws DebugException {
		277	IJavaScriptStackFrame frame = (IJavaScriptStackFrame) thread.getTopStackFrame();
		278	if (frame != null) {
		279	try {
		280	String uri = URLDecoder.decode(frame.getSourceName(), Constants.UTF_8);
		281	return TextUtils.shortenText(uri, 100);
156	}	282	}
157	if(element instanceof IScript) {	283	catch (UnsupportedEncodingException uee) {
158	return getScriptText((IScript) element);	284	//ignore
159	}	285	}
160	}	286	}
161	catch(CoreException ce) {	287	// all else failed say "evaluated_script"
162	JavaScriptDebugUIPlugin.log(ce);	288	return Messages.evald_script;
		289	}
		290
		291	/**
		292	* Returns the display name of the given {@link IJavaScriptStackFrame}
		293	*
		294	* @param frame
		295	* @return the display text or {@link Messages#unknown}
		296	* @throws DebugException
		297	*/
		298	String getStackframeText(IJavaScriptStackFrame frame) throws DebugException {
		299	try {
		300	return TextUtils.shortenText(NLS.bind(Messages.stackframe_name, new String[] {
		301	URLDecoder.decode(frame.getName(), Constants.UTF_8),
		302	Integer.toString(frame.getLineNumber())}), 100);
		303	}
		304	catch (UnsupportedEncodingException uee) {
		305	//ignore
163	}	306	}
164	return element.toString();	307	return Messages.unknown;
165	}	308	}
166		309
167	/**	310	/**
168	* Returns the display text for the given script element	311	* Returns the display text for the given script element
		312	*
169	* @param script	313	* @param script
170	* @return the display text for the given script	314	* @return the display text for the given script or {@link Messages#unknown}
171	*/	315	*/
172	String getScriptText(IScript script) {	316	String getScriptText(IScript script) {
173	String uri = script.sourceURI().toString();	317	String uri;
174	return TextUtils.shortenText(uri, 100);	318	try {
		319	uri = URLDecoder.decode(script.sourceURI().toString(), Constants.UTF_8);
		320	return TextUtils.shortenText(uri, 100);
		321	} catch (UnsupportedEncodingException e) {
		322	//do nothing
		323	}
		324	return Messages.unknown;
175	}	325	}
176		326
177	/**	327	/**
Lines 182-189 Link Here
182	*/	332	*/
183	String getLineBreakpointText(IJavaScriptLineBreakpoint breakpoint) throws CoreException {	333	String getLineBreakpointText(IJavaScriptLineBreakpoint breakpoint) throws CoreException {
184	String path = getElementPath(breakpoint.getScriptPath());	334	String path = getElementPath(breakpoint.getScriptPath());
185	StringBuffer buffer = new StringBuffer();	335	StringBuffer buffer = new StringBuffer(path);
186	buffer.append(path).append(NLS.bind(Messages.bp_line_number, new String[] {Integer.toString(breakpoint.getLineNumber())}));	336	buffer.append(NLS.bind(Messages.bp_line_number, new String[] {Integer.toString(breakpoint.getLineNumber())}));
187	int hitcount = breakpoint.getHitCount();	337	int hitcount = breakpoint.getHitCount();
188	if(hitcount > 0) {	338	if(hitcount > 0) {
189	buffer.append(NLS.bind(Messages.bp_hit_count, new String[] {Integer.toString(hitcount)}));	339	buffer.append(NLS.bind(Messages.bp_hit_count, new String[] {Integer.toString(hitcount)}));
Lines 205-212 Link Here
205	*/	355	*/
206	String getFunctionBreakpointText(IJavaScriptFunctionBreakpoint breakpoint) throws CoreException {	356	String getFunctionBreakpointText(IJavaScriptFunctionBreakpoint breakpoint) throws CoreException {
207	String path = getElementPath(breakpoint.getScriptPath());	357	String path = getElementPath(breakpoint.getScriptPath());
208	StringBuffer buffer = new StringBuffer();	358	StringBuffer buffer = new StringBuffer(path);
209	buffer.append(path);
210	if(breakpoint.isEntry()) {	359	if(breakpoint.isEntry()) {
211	if(breakpoint.isExit()) {	360	if(breakpoint.isExit()) {
212	buffer.append(Messages.bp_entry_and_exit);	361	buffer.append(Messages.bp_entry_and_exit);
Lines 241-248 Link Here
241	*/	390	*/
242	String getScriptLoadBreakpointText(IJavaScriptLoadBreakpoint breakpoint) throws CoreException {	391	String getScriptLoadBreakpointText(IJavaScriptLoadBreakpoint breakpoint) throws CoreException {
243	String path = getElementPath(breakpoint.getScriptPath());	392	String path = getElementPath(breakpoint.getScriptPath());
244	StringBuffer buffer = new StringBuffer();	393	StringBuffer buffer = new StringBuffer(path);
245	buffer.append(path);
246	int hitcount = breakpoint.getHitCount();	394	int hitcount = breakpoint.getHitCount();
247	if(hitcount > 0) {	395	if(hitcount > 0) {
248	buffer.append(NLS.bind(Messages.bp_hit_count, new String[] {Integer.toString(hitcount)}));	396	buffer.append(NLS.bind(Messages.bp_hit_count, new String[] {Integer.toString(hitcount)}));
Lines 259-265 Link Here
259	* @return	407	* @return
260	*/	408	*/
261	String getElementPath(String path) {	409	String getElementPath(String path) {
262	if(! showQualifiedNames()) {	410	if(!showQualifiedNames()) {
263	try {	411	try {
264	return URIUtil.lastSegment(URIUtil.fromString(path));	412	return URIUtil.lastSegment(URIUtil.fromString(path));
265	}	413	}
Lines 370-375 Link Here
370	* @see org.eclipse.debug.ui.ISourcePresentation#getEditorInput(java.lang.Object)	518	* @see org.eclipse.debug.ui.ISourcePresentation#getEditorInput(java.lang.Object)
371	*/	519	*/
372	public IEditorInput getEditorInput(Object element) {	520	public IEditorInput getEditorInput(Object element) {
		521	if(element instanceof LocalFileStorage) {
		522	return getEditorInput(((LocalFileStorage)element).getFile());
		523	}
373	if(element instanceof File) {	524	if(element instanceof File) {
374	return new FileStoreEditorInput(EFS.getLocalFileSystem().fromLocalFile((File) element));	525	return new FileStoreEditorInput(EFS.getLocalFileSystem().fromLocalFile((File) element));
375	}	526	}
Lines 379-386 Link Here
379	if(element instanceof IJavaScriptLoadBreakpoint) {	530	if(element instanceof IJavaScriptLoadBreakpoint) {
380	try {	531	try {
381	IJavaScriptLoadBreakpoint bp = (IJavaScriptLoadBreakpoint) element;	532	IJavaScriptLoadBreakpoint bp = (IJavaScriptLoadBreakpoint) element;
382	IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(bp.getScriptPath()));	533	IPath path = new Path(bp.getScriptPath());
383	if(resource.getType() == IResource.FILE) {	534	IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
		535	if(resource != null && resource.getType() == IResource.FILE) {
384	return new FileEditorInput((IFile) resource);	536	return new FileEditorInput((IFile) resource);
385	}	537	}
386	}	538	}

Lines 31-47 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/Messages.java (+16 lines)
31	public static String connector;	31	public static String connector;
32	public static String connector_properties;	32	public static String connector_properties;
33	public static String creating_script_load_bp;	33	public static String creating_script_load_bp;
		34	public static String disconnected;
34	public static String enable_hit_count;	35	public static String enable_hit_count;
35	public static String enter_new_hit_count;	36	public static String enter_new_hit_count;
		37	public static String evald_script;
36	public static String exception_occurred_setting_bp_properties;	38	public static String exception_occurred_setting_bp_properties;
37	public static String hit_count_must_be_positive;	39	public static String hit_count_must_be_positive;
38	public static String no_description_provided;	40	public static String no_description_provided;
		41	public static String opening_source__0;
		42	public static String running_state;
39	public static String scripts;	43	public static String scripts;
40	public static String select_javascript_file;	44	public static String select_javascript_file;
41	public static String set_bp_hit_count;	45	public static String set_bp_hit_count;
		46	public static String stackframe_name;
		47	public static String stepping_state;
		48	public static String suspend_loading_script;
42	public static String suspend_target;	49	public static String suspend_target;
43	public static String suspend_thread;	50	public static String suspend_thread;
		51	public static String suspended_on_exception;
		52	public static String suspended_on_func_breakpoint;
		53	public static String suspended_on_line_breakpoint;
		54	public static String suspended_state;
		55	public static String terminated;
		56	public static String terminated_state;
44	public static String the_argument_0_is_not_valid;	57	public static String the_argument_0_is_not_valid;
		58	public static String thread_name;
		59	public static String unknown;
		60	public static String unknown_state;
45	static {	61	static {
46	// initialize resource bundle	62	// initialize resource bundle
47	NLS.initializeMessages(BUNDLE_NAME, Messages.class);	63	NLS.initializeMessages(BUNDLE_NAME, Messages.class);




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui;

import org.eclipse.jface.util.IPropertyChangeListener;

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/actions/AddScriptLoadBreakpointAction.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.	2	* Copyright (c) 2010, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 54-60 Link Here
54	if(dialog.open() == IDialogConstants.OK_ID) {	54	if(dialog.open() == IDialogConstants.OK_ID) {
55	final IFile file = (IFile) dialog.getFirstResult();	55	final IFile file = (IFile) dialog.getFirstResult();
56	final String scriptname = file.getName();	56	final String scriptname = file.getName();
57	final String scriptpath = file.getFullPath().makeRelative().toString();	57	final String scriptpath = file.getProjectRelativePath().makeAbsolute().toString();
58		58
59	IJavaScriptLoadBreakpoint breakpoint = findBreakpoint(scriptpath, scriptname);	59	IJavaScriptLoadBreakpoint breakpoint = findBreakpoint(scriptpath, scriptname);
60	if(breakpoint != null) {	60	if(breakpoint != null) {




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;
import org.eclipse.wst.jsdt.debug.internal.ui.eval.EvaluationManager;
import org.eclipse.wst.jsdt.internal.ui.text.JavaWordFinder;

/**
 * Action for evaluating selected source
 * 
 * @since 1.1
 */
public abstract class EvaluateAction implements IEditorActionDelegate, IObjectActionDelegate, IActionDelegate2, IViewActionDelegate, IWorkbenchWindowActionDelegate, IHandler {

	private IRegion region = null;
	private IWorkbenchPart targetpart = null;
	private IWorkbenchWindow window = null;
	private IAction action = null;
	private Object selection = null;
	private IJavaScriptValue value = null;
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate2#dispose()
	 */
	public void dispose() {
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate2#runWithEvent(org.eclipse.jface.action.IAction, org.eclipse.swt.widgets.Event)
	 */
	public void runWithEvent(IAction action, Event event) {
		run(action);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		IJavaScriptStackFrame frame = getStackFrameContext();
		if(frame != null) {
			resolveSelection();
			//XXX hack, if we want to support evaluations from the variables view this will not work
			setValue(frame.evaluate(getSelection().toString()));
			showResult(getValue());
		}
	}
	
	/**
	 * Shows the result of the evaluation to the user. Sub-classes must implement. 
	 * 
	 * @param value the {@link IJavaScriptValue} to show to the user
	 */
	protected abstract void showResult(IJavaScriptValue value);
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {
		setAction(action);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
	 */
	public void init(IAction action) {
		setAction(action);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IViewActionDelegate#init(org.eclipse.ui.IViewPart)
	 */
	public void init(IViewPart view) {
		setTargetpart(view);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void init(IWorkbenchWindow window) {
		IWorkbenchPage page = window.getActivePage();
		if(page != null) {
			setTargetpart(window.getActivePage().getActivePart());
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	 */
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
		setTargetpart(targetPart);
		setAction(action);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IEditorActionDelegate#setActiveEditor(org.eclipse.jface.action.IAction, org.eclipse.ui.IEditorPart)
	 */
	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
		setTargetpart(targetEditor);
		setAction(action);
	}
	
	/**
	 * Resolves the selected object from the target part
	 */
	protected void resolveSelection() {
		ISelection sel = getTargetSelection();
		setRegion(null);
		if(sel instanceof ITextSelection) {
			ITextSelection ts = (ITextSelection)sel;
			String text= ts.getText();
			if (text.trim().length() > 0) {
				setSelection(text);
				setRegion(new Region(ts.getOffset(), ts.getLength()));
			} else if (getTargetPart() instanceof IEditorPart) {
				IEditorPart editor= (IEditorPart)getTargetPart();
				if (editor instanceof ITextEditor) {
					setSelection(resolveText(null, ts, editor));
				}
			}
		}
		else if(sel instanceof IStructuredSelection) {
			
		}
	}
	
	/**
	 * Resolve the word from the given text selection. If no new word infos can be resolved 
	 * the original string is returned.
	 * @param text the text
	 * @param ts the current text selection
	 * @param editor the current editor
	 * @return the new resolved text for the whole word of the selection
	 */
	String resolveText(String text, ITextSelection ts, IEditorPart editor) {
		ITextEditor textEditor= (ITextEditor) editor;
		IDocument doc= textEditor.getDocumentProvider().getDocument(editor.getEditorInput());
		region = JavaWordFinder.findWord(doc, ts.getOffset());
		if (region != null) {
			try {
				return doc.get(region.getOffset(), region.getLength());
			} 
			catch (BadLocationException e) {
				//ignore
			}
		}
		return text;
	}
	
	/**
	 * Returns the select from the {@link IWorkbenchSite} of the {@link #getTargetPart()} {@link IWorkbenchPart}
	 * @return the selection or <code>null</code>
	 */
	protected ISelection getTargetSelection() {
		IWorkbenchPart part = getTargetPart();
		if(part != null) {
			ISelectionProvider provider = part.getSite().getSelectionProvider();
			if (provider != null) {
				return provider.getSelection();
			}
		}
		return null;
	}
	
	/**
	 * Finds the currently selected {@link IJavaScriptStackFrame} in the UI.
	 */
	protected IJavaScriptStackFrame getStackFrameContext() {
		IWorkbenchPart part = getTargetPart();
		IJavaScriptStackFrame frame = null;
		if (part == null) {
			frame = EvaluationManager.getManager().getEvaluationContext(getWindow());
		} else {
			frame = EvaluationManager.getManager().getEvaluationContext(part);
		}		
		return frame;
	}
	
	/**
	 * Allows the result of the evaluation to be set
	 * 
	 * @param value the {@link IJavaScriptValue} of the evaluation
	 */
	protected void setValue(IJavaScriptValue value) {
		this.value = value;
	}
	
	/**
	 * Returns the {@link IJavaScriptValue} result of the evaluation
	 * 
	 * @return the {@link IJavaScriptValue} result or <code>null</code>
	 */
	protected IJavaScriptValue getValue() {
		return value;
	}
	
	/**
	 * Allows the resolved selection to be set
	 * 
	 * @param obj
	 */
	protected void setSelection(Object obj) {
		selection = obj;
	}
	
	/**
	 * Returns the resolved selection or <code>null</code>. If <code>null</code>
	 * is returned attempts can be made to re-resolve the selection using {@link #resolveSelection()}
	 * 
	 * @return the resolved selection or <code>null</code>
	 */
	protected Object getSelection() {
		return selection;
	}
	
	/**
	 * Returns the current target {@link IWorkbenchPart}
	 * @return the {@link IWorkbenchPart} target or <code>null</code>
	 */
	protected IWorkbenchPart getTargetPart() {
		return targetpart;
	}
	
	/**
	 * Allows the target {@link IWorkbenchPart} to be set
	 * @param targetpart the targetpart to set
	 */
	protected void setTargetpart(IWorkbenchPart targetpart) {
		this.targetpart = targetpart;
	}
	
	/**
	 * Returns the current active {@link IWorkbenchWindow}
	 * 
	 * @return the current active {@link IWorkbenchWindow}
	 */
	protected IWorkbenchWindow getWindow() {
		return window;
	}
	
	/**
	 * Allows the current {@link IWorkbenchWindow} context to be set
	 * 
	 * @param window the {@link IWorkbenchWindow} context
	 */
	protected void setWindow(IWorkbenchWindow window) {
		this.window = window;
	}
	
	/**
	 * Returns the selected text {@link IRegion}, or <code>null</code> if none.
	 * 
	 * @return the selected text {@link IRegion} or <code>null</code>
	 */
	protected IRegion getRegion() {
		return region;
	}
	
	/**
	 * Allows the selected {@link IRegion} to be set
	 * 
	 * @param region the {@link IRegion} to set
	 */
	protected void setRegion(IRegion region) {
		this.region = region;
	}
	
	/**
	 * Returns the {@link IAction} context or <code>null</code>
	 * 
	 * @return the backing {@link IAction} or <code>null</code>
	 */
	protected IAction getAction() {
		return action;
	}
	
	/**
	 * Allows the backing {@link IAction} to be set
	 * 
	 * @param action the action to set
	 */
	protected void setAction(IAction action) {
		this.action = action;
	}
	
	/**
	 * Returns the styled text widget associated with the given part
	 * or <code>null</code> if none.
	 * 
	 * @param part workbench part
	 * @return associated style text widget or <code>null</code>
	 */
	protected StyledText getStyledText(IWorkbenchPart part) {
		ITextViewer viewer = (ITextViewer)part.getAdapter(ITextViewer.class);
		StyledText textWidget = null;
		if (viewer == null) {
			Control control = (Control) part.getAdapter(Control.class);
			if (control instanceof StyledText) {
				textWidget = (StyledText) control;
			}
		} else {
			textWidget = viewer.getTextWidget();
		}
		return textWidget;
	}
	
	/**
	 * Returns an anchor point for a popup dialog on top of a styled text
	 * or <code>null</code> if none.
	 * 
	 * @param part or <code>null</code>
	 * @return anchor point or <code>null</code>
	 */
	protected Point getPopupAnchor(StyledText textWidget) {
		if (textWidget != null) {
	        Point docRange = textWidget.getSelectionRange();
	        int midOffset = docRange.x + (docRange.y / 2);
	        Point point = textWidget.getLocationAtOffset(midOffset);
	        point = textWidget.toDisplay(point);
	
	        GC gc = new GC(textWidget);
	        gc.setFont(textWidget.getFont());
	        int height = gc.getFontMetrics().getHeight();
	        gc.dispose();
	        point.y += height;
	        return point;
		}
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandlerListener;
import org.eclipse.debug.ui.InspectPopupDialog;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;
import org.eclipse.wst.jsdt.debug.internal.ui.eval.JavaScriptInspectExpression;


/**
 * Default handler for the {@link EvaluateAction}
 * 
 * @since 1.0
 */
public class EvaluateEditorPopupAction extends EvaluateAction {

	/**
	 * Constructor
	 */
	public EvaluateEditorPopupAction() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
	 */
	public Object execute(ExecutionEvent event) throws ExecutionException {
		run(null);
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.EvaluateAction#showResult(org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue)
	 */
	protected void showResult(IJavaScriptValue value) {
		InspectPopupDialog dialog = new InspectPopupDialog(
				PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), 
				getPopupAnchor(getStyledText(getTargetPart())), 
				null, 
				new JavaScriptInspectExpression(getValue()));
		dialog.open();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#isEnabled()
	 */
	public boolean isEnabled() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		setWindow(window);
		if(window != null) {
			IWorkbenchPage page = window.getActivePage();
			if(page != null) {
				setTargetpart(page.getActivePart());
				return true;
			}
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#isHandled()
	 */
	public boolean isHandled() {
		return true;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#removeHandlerListener(org.eclipse.core.commands.IHandlerListener)
	 */
	public void removeHandlerListener(IHandlerListener handlerListener) {}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#addHandlerListener(org.eclipse.core.commands.IHandlerListener)
	 */
	public void addHandlerListener(IHandlerListener handlerListener) {}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.debug.core.DebugException;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptProperty;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptVariable;
import org.eclipse.wst.jsdt.debug.internal.ui.Constants;


/**
 * Viewer filter action for filtering functions
 * 
 * @since 1.1
 */
public class FunctionFilterAction extends ViewFilterAction {

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceKey()
	 */
	protected String getPreferenceKey() {
		return Constants.SHOW_FUNCTIONS;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if(element instanceof JavaScriptVariable){
			JavaScriptVariable var = (JavaScriptVariable) element;
			try {
				if(IJavaScriptValue.FUNCTION.equals(var.getReferenceTypeName())) {
					return getValue();
				}
			} catch (DebugException e) {
			}
		}
		if(element instanceof JavaScriptProperty){
			JavaScriptProperty prop = (JavaScriptProperty) element;
			try {
				if(IJavaScriptValue.FUNCTION.equals(prop.getReferenceTypeName())) {
					return getValue();
				}
			} catch (DebugException e) {
			}
		}
		return true;
	}
}




import org.eclipse.core.commands.IHandler2;
import org.eclipse.core.commands.IHandlerListener;
import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.sourcelookup.ISourceLookupResult;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;
import org.eclipse.wst.jsdt.debug.core.model.IScript;
import org.eclipse.wst.jsdt.debug.internal.core.model.Script;
import org.eclipse.wst.jsdt.debug.internal.ui.Messages;

/**
 * Context menu action to show the source for a selected {@link IScript}

	 */
	public void run(IAction action) {
		if(script != null) {
			UIJob job = new UIJob(PlatformUI.getWorkbench().getDisplay(), NLS.bind(Messages.opening_source__0, script.sourceURI())) {
				public IStatus runInUIThread(IProgressMonitor monitor) {
					IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
					ISourceLookupResult result = DebugUITools.lookupSource(script, script.getDebugTarget().getLaunch().getSourceLocator());
					DebugUITools.displaySource(result, page);
					return Status.OK_STATUS;
				}
			};
			job.setPriority(Job.INTERACTIVE);
			job.setUser(true);
			job.schedule();
		}
	}





/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptProperty;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptValue;
import org.eclipse.wst.jsdt.debug.internal.ui.Constants;

/**
 * Viewer filter action for <code>proto</code> variables
 * 
 * @since 1.1
 */
public class ProtoFilterAction extends ViewFilterAction {

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceKey()
	 */
	protected String getPreferenceKey() {
		return Constants.SHOW_PROTOTYPES;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if(element instanceof JavaScriptProperty){
			JavaScriptProperty var = (JavaScriptProperty) element;
			if(JavaScriptValue.PROTO.equals(var.getName())) {
				return getValue();
			}
		}
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.debug.ui.IDebugView;




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.jsdt.debug.internal.core.Constants;
import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;

 */
public class SuspendOnAllScriptLoadsAction extends ViewFilterAction {
	
	
	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceKey()
	 */

	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(JavaScriptDebugPlugin.PLUGIN_ID);
		if(prefs != null) {
			prefs.putBoolean(Constants.SUSPEND_ON_ALL_SCRIPT_LOADS, getValue());
			try {

	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceStore()
	 */
	protected IPreferenceStore getPreferenceStore() {
		return JavaScriptDebugUIPlugin.getCorePreferenceStore();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceValue()
	 */
	protected boolean getPreferenceValue() {




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IViewPart;
import org.eclipse.wst.jsdt.debug.internal.core.Constants;
import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

 * 
 * @since 1.1
 */
public class SuspendOnExceptionsAction extends ViewFilterAction {
	
	boolean initialized = false;
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(JavaScriptDebugPlugin.PLUGIN_ID);
		if(prefs != null) {
			prefs.putBoolean(Constants.SUSPEND_ON_THROWN_EXCEPTION, action.isChecked());
			try {
				prefs.flush();
			} catch (BackingStoreException e) {

	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceStore()
	 */
	protected IPreferenceStore getPreferenceStore() {
		return JavaScriptDebugUIPlugin.getCorePreferenceStore();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceValue()
	 */
	protected boolean getPreferenceValue() {
		return Platform.getPreferencesService().getBoolean(
				JavaScriptDebugPlugin.PLUGIN_ID,
				Constants.SUSPEND_ON_THROWN_EXCEPTION, 
				false, 
				null);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceKey()
	 */
	protected String getPreferenceKey() {
		return Constants.SUSPEND_ON_THROWN_EXCEPTION;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.actions;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptValue;
import org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptVariable;
import org.eclipse.wst.jsdt.debug.internal.ui.Constants;

/**
 * Viewer filter action for the <code>this</code> variable
 * 
 * @since 1.1
 */
public class ThisFilterAction extends ViewFilterAction {

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.debug.internal.ui.actions.ViewFilterAction#getPreferenceKey()
	 */
	protected String getPreferenceKey() {
		return Constants.SHOW_THIS;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if(element instanceof JavaScriptVariable){
			JavaScriptVariable var = (JavaScriptVariable) element;
			if(JavaScriptValue.THIS.equals(var.getName())) {
				return getValue();
			}
		}
		return true;
	}
}




			viewer.refresh();
		}
		IPreferenceStore store = getPreferenceStore();
		store.setValue(getPreferenceKey(), action.isChecked());
		store.setValue(key, action.isChecked());
	}

	/* (non-Javadoc)

	 * @return boolean
	 */
	protected boolean getPreferenceValue() {
		String key = getCompositeKey();
		IPreferenceStore store = getPreferenceStore();
		return store.getBoolean(getPreferenceKey());		
		if (store.contains(key)) {
			value = store.getBoolean(key);
		} else {
			value = store.getBoolean(getPreferenceKey());
		}
		return value;		
	}
	
	/**




import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxyFactory2;
import org.eclipse.debug.ui.actions.IRunToLineTarget;
import org.eclipse.debug.ui.actions.IToggleBreakpointsTarget;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.model.IWorkbenchAdapter;

import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleBreakpointAdapter;
import org.eclipse.wst.jsdt.debug.internal.ui.eval.RunToLineAdapter;

/**
 * Adapter factory

	static ToggleBreakpointAdapter tbadapter = null;
	static JavaScriptAsyncContentProvider jscontent = null;
	static JavaScriptModelProxyFactory jsproxyfactory = null;
	static RunToLineAdapter runtoline = null;
	
	/*
	 * (non-Javadoc)

		if(adapterType.equals(IWorkbenchAdapter.class) && adaptableObject instanceof IJavaScriptBreakpoint) {
			return getWorkbenchAdapter();
		}
		if(adapterType.equals(IRunToLineTarget.class)) {
			return getRunToLine();
		}
		if (adapterType.equals(IElementContentProvider.class)) {
			if (adaptableObject instanceof IJavaScriptDebugTarget ||
					adaptableObject instanceof IScriptGroup) {

	 */
	public Class[] getAdapterList() {
		return new Class[] {IToggleBreakpointsTarget.class, 
				IWorkbenchAdapter.class,
				IRunToLineTarget.class,
				IElementContentProvider.class,
				IModelProxyFactory2.class};
	}
	
	/**
	 * @return the singleton {@link RunToLineAdapter}
	 */
	synchronized RunToLineAdapter getRunToLine() {
		if(runtoline == null) {
			runtoline = new RunToLineAdapter();
		}
		return runtoline;
	}
	
	/**
	 * @return the singleton {@link JavaScriptModelProxyFactory}
	 */
	synchronized JavaScriptModelProxyFactory getJSProxyFactory() {




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.adapters;

import java.util.List;




import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptDebugTarget;
import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;
import org.eclipse.wst.jsdt.debug.internal.core.model.ScriptGroup;
import org.eclipse.wst.jsdt.debug.internal.ui.PreferencesManager;

/**
 * Custom handler for JavaScript debug target model proxy events

	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugTargetEventHandler#handleChange(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleChange(DebugEvent event) {
		Object source = event.getSource();
		if(source instanceof IDebugTarget) {
			super.handleChange(event);
		}
		else if(source instanceof IScriptGroup) {
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugTargetEventHandler#handleCreate(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleCreate(DebugEvent event) {
		Object source = event.getSource();
		if(source instanceof IDebugTarget) {
			super.handleCreate(event);
		}
		else if(source instanceof IScriptGroup) {
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugTargetEventHandler#handleResume(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleResume(DebugEvent event) {
		Object source = event.getSource();
		if(source instanceof IDebugTarget) {
			super.handleResume(event);
		}
		else if(source instanceof IScriptGroup) {
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugTargetEventHandler#handleSuspend(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleSuspend(DebugEvent event) {
		Object source = event.getSource();
		if(source instanceof IDebugTarget) {
			super.handleSuspend(event);
		}
		else if(source instanceof IScriptGroup) {
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugTargetEventHandler#handleTerminate(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleTerminate(DebugEvent event) {
		Object source = event.getSource();
		if(source instanceof IDebugTarget) {
			super.handleTerminate(event);
		}
		else if(source instanceof IScriptGroup){
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.update.DebugEventHandler#handleOther(org.eclipse.debug.core.DebugEvent)
	 */
	protected void handleOther(DebugEvent event) {

			super.handleOther(event);
		}
		else if(source instanceof IScriptGroup){
			if(PreferencesManager.getManager().showLoadedScripts()) {
				fireScriptGroupDelta((IScriptGroup) source);
			}
		}
	}
	




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	protected void createLabels(Composite parent) {
		Composite labelComposite = SWTFactory.createComposite(parent, 2, 1, GridData.FILL_HORIZONTAL);
		try {
			IJavaScriptBreakpoint bp = getBreakpoint();
			String name = bp.getTypeName();
			if (name != null) {
				SWTFactory.createLabel(labelComposite, Messages.type_name, 1); 
				Text text = SWTFactory.createText(labelComposite, SWT.READ_ONLY | SWT.SINGLE, 1, GridData.FILL_HORIZONTAL);
				text.setText(name);
				text.setBackground(parent.getBackground());
			}
			name = bp.getScriptPath();
			if(name != null) {
				SWTFactory.createLabel(labelComposite, Messages.script_path, 1);
				Text text = SWTFactory.createText(labelComposite, SWT.READ_ONLY, 1, GridData.FILL_HORIZONTAL);




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.breakpoints;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IBreakpointManager;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.ui.texteditor.IMarkerUpdater;
import org.eclipse.ui.texteditor.MarkerUtilities;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptBreakpoint;
import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLineBreakpoint;
import org.eclipse.wst.jsdt.debug.core.model.JavaScriptDebugModel;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
import org.eclipse.wst.jsdt.internal.ui.javaeditor.ASTProvider;

/**
 * A marker updater for {@link IJavaScriptBreakpoint}s
 * 
 * @since 1.1
 */
public class JavaScriptBreakpointUpdater implements IMarkerUpdater {

	/**
	 * Constructor
	 */
	public JavaScriptBreakpointUpdater() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#getMarkerType()
	 */
	public String getMarkerType() {
		return IJavaScriptBreakpoint.MARKER_ID;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#getAttribute()
	 */
	public String[] getAttribute() {
		return new String[] {IMarker.LINE_NUMBER};
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#updateMarker(org.eclipse.core.resources.IMarker, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.Position)
	 */
	public boolean updateMarker(IMarker marker, IDocument document, Position position) {
		if(position.isDeleted()) {
			return false;
		}
		IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
		IBreakpoint breakpoint = manager.getBreakpoint(marker);
		if(breakpoint == null) {
			return false;
		}
		IJavaScriptUnit unit = JavaScriptCore.createCompilationUnitFrom((IFile) marker.getResource());
		if(unit == null) {
			return false;
		}
		JavaScriptUnit jsunit = JavaScriptPlugin.getDefault().getASTProvider().getAST(unit, ASTProvider.WAIT_YES, null);
		try {
			BreakpointLocationFinder finder = new BreakpointLocationFinder(jsunit, document.getLineOfOffset(position.getOffset())+1, true);
			jsunit.accept(finder);
			if(finder.getLocation() == BreakpointLocationFinder.UNKNOWN) {
				return false;
			}
			int line = finder.getLineNumber();
			if(MarkerUtilities.getLineNumber(marker) == line) {
				//if there exists a breakpoint on the line remove this one
				if(isLineBreakpoint(marker)) {
					ensureRanges(document, marker, line);
					return lineBreakpointExists(marker.getResource(), ((IJavaScriptLineBreakpoint)breakpoint).getScriptPath(), line, marker, true) == null;
				}
				return true;
			}
			if(isLineBreakpoint(marker) & line == -1) {
				return false;
			}
			if(lineBreakpointExists(marker.getResource(), ((IJavaScriptLineBreakpoint)breakpoint).getScriptPath(), line, marker, false) != null) {
				return false;
			}
			MarkerUtilities.setLineNumber(marker, line);
			if(isLineBreakpoint(marker)) {
				ensureRanges(document, marker, line);
			}
			return true;
		}
		catch(BadLocationException ble) {
			JavaScriptDebugUIPlugin.log(ble);
		} catch (CoreException e) {
			JavaScriptDebugUIPlugin.log(e);
		}
		return false;
	}
	
	/**
	 * Returns if the given marker is of the type {@link IJavaScriptLineBreakpoint#MARKER_ID}
	 * @param marker
	 * @return true if the marker is a {@link IJavaScriptLineBreakpoint} marker
	 */
	boolean isLineBreakpoint(IMarker marker) {
		return MarkerUtilities.isMarkerType(marker, IJavaScriptLineBreakpoint.MARKER_ID);
	}
	
	/**
	 * Corrects the {@link IMarker#CHAR_START} and {@link IMarker#CHAR_END} values as needed
	 * 
	 * @param document
	 * @param marker
	 * @param line
	 * @throws BadLocationException
	 */
	void ensureRanges(IDocument document, IMarker marker, int line) throws BadLocationException {
		if(line < 0 || line > document.getNumberOfLines()) {
			return;
		}
		IRegion region = document.getLineInformation(line - 1);
		int charstart = region.getOffset();
		int charend = charstart + region.getLength();
		MarkerUtilities.setCharStart(marker, charstart);
		MarkerUtilities.setCharEnd(marker, charend);
	}
	
	/**
	 * Looks up the {@link IJavaScriptLineBreakpoint} that is associated with the given marker. Returns <code>null</code> if one 
	 * does not exist
	 * 
	 * @param resource
	 * @param typeName
	 * @param lineNumber
	 * @param currentmarker
	 * @param useid if the id of the markers should be compared
	 * @return the {@link IJavaScriptLineBreakpoint} for the given marker or <code>null</code> if one does not exist
	 * @throws CoreException
	 */
	IJavaScriptLineBreakpoint lineBreakpointExists(IResource resource, String typeName, int lineNumber, IMarker currentmarker, boolean useid) throws CoreException {
		String modelId = JavaScriptDebugModel.MODEL_ID;
		IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
		IBreakpoint[] breakpoints = manager.getBreakpoints(modelId);
		for (int i = 0; i < breakpoints.length; i++) {
			if ((breakpoints[i] instanceof IJavaScriptLineBreakpoint)) {
				IJavaScriptLineBreakpoint breakpoint = (IJavaScriptLineBreakpoint) breakpoints[i];
				if(breakpoint.getLineNumber() == lineNumber) {
					IMarker marker = breakpoint.getMarker();
					if (marker != null && 
							marker.exists() && 
							marker.getType().equals(IJavaScriptLineBreakpoint.MARKER_ID) && 
							pathsEqual(breakpoint.getScriptPath(), typeName) &&
							resource.equals(marker.getResource())) {
						if(useid) {
							if(currentmarker.getId() != marker.getId()) {
								return breakpoint;
							}
							return null;
						}
						return breakpoint;
					}
				}
				
			}
		}
		return null;
	}
	
	/**
	 * Returns if n1 equals n2, where both being <code>null</code> is also considered equal
	 * @param n1
	 * @param n2
	 * @return 
	 */
	boolean pathsEqual(String n1, String n2) {
		if(n1 == null) {
			return n2 == null;
		}
		return n1.equals(n2);
	}
}

Lines 27-32 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/breakpoints/Messages.java (+6 lines)
27	public static String enter_condition;	27	public static String enter_condition;
28	public static String entry;	28	public static String entry;
29	public static String exit;	29	public static String exit;
		30	public static String failed_function_bp_no_element;
		31	public static String failed_function_bp_no_resource;
		32	public static String failed_line_bp_no_element;
		33	public static String failed_line_bp_no_resource;
30	public static String failed_to_create_function_bp;	34	public static String failed_to_create_function_bp;
31	public static String failed_to_create_line_bp;	35	public static String failed_to_create_line_bp;
32	public static String fuction;	36	public static String fuction;
Lines 38-43 Link Here
38	public static String line_breakpoint_settings;	42	public static String line_breakpoint_settings;
39	public static String line_number;	43	public static String line_number;
40	public static String member;	44	public static String member;
		45	public static String no_editor_could_be_found;
41	public static String no_valid_location;	46	public static String no_valid_location;
42	public static String script_load_bp;	47	public static String script_load_bp;
43	public static String script_load_breakpoint;	48	public static String script_load_breakpoint;
Lines 47-52 Link Here
47	public static String suspend_when_changed;	52	public static String suspend_when_changed;
48	public static String suspend_when_true;	53	public static String suspend_when_true;
49	public static String type_name;	54	public static String type_name;
		55	public static String type_root_could_not_be_computed;
50	static {	56	static {
51	// initialize resource bundle	57	// initialize resource bundle
52	NLS.initializeMessages(BUNDLE_NAME, Messages.class);	58	NLS.initializeMessages(BUNDLE_NAME, Messages.class);




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import java.util.HashMap;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;

import org.eclipse.wst.jsdt.core.ISourceRange;
import org.eclipse.wst.jsdt.core.IType;
import org.eclipse.wst.jsdt.core.ITypeRoot;
import org.eclipse.wst.jsdt.core.dom.AST;
import org.eclipse.wst.jsdt.core.dom.ASTParser;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptBreakpoint;
import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptFunctionBreakpoint;
import org.eclipse.wst.jsdt.debug.core.breakpoints.IJavaScriptLineBreakpoint;
import org.eclipse.wst.jsdt.debug.core.model.JavaScriptDebugModel;
import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.DebugWCManager;
import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
import org.eclipse.wst.jsdt.internal.ui.javaeditor.ASTProvider;

/**
 * JavaScript adapter for toggling breakpoints in the JSDT editor
 * 
 * @since 1.0
 */

            		ITextEditor editor = getTextEditor(part);
					if(editor != null && part instanceof IEditorPart) {
						if(element == null) {
							reportToStatusLine(part, Messages.failed_line_bp_no_element);
							return Status.CANCEL_STATUS;
						}
						IResource resource = element.getResource();
						if(resource == null) {
							reportToStatusLine(part, NLS.bind(Messages.failed_line_bp_no_resource, element.getElementName()));
							return Status.CANCEL_STATUS;
						}
						IResource resource = getBreakpointResource(element);
						IBreakpoint bp = lineBreakpointExists(resource, linenumber);
						if(bp != null) {
							DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(bp, true);

	 * @return the path to the script 
	 */
	String getScriptPath(IJavaScriptElement element) {
		IPath path = element.getPath();
		return path.makeAbsolute().toString();
			String extpath = (JavaScriptDebugPlugin.getExternalScriptPath(path.removeFirstSegments(1)));
			if(extpath != null) {
				return extpath;
			}
		}
		return path.toString();
	}

	private IPath getElementScriptPath(IJavaScriptElement element) {
		switch (element.getElementType()) {
		case IJavaScriptElement.TYPE: {
			return ((IType) element).getPath();
		}
		case IJavaScriptElement.METHOD:
		case IJavaScriptElement.FIELD: {
			IMember member = (IMember) element;
			IType type = member.getDeclaringType();
			if (type == null) {
				IJavaScriptElement parent = element.getParent();
				switch (parent.getElementType()) {
				case IJavaScriptElement.TYPE: {
					return ((IType) parent).getPath();
				}
				case IJavaScriptElement.JAVASCRIPT_UNIT:
				case IJavaScriptElement.CLASS_FILE: {
					return ((ITypeRoot) parent).getPath();
				}
				}
				return element.getParent().getPath();
			}
			return type.getPath();
		}
		default: {
			return element.getPath();
		}
		}
	}
	
	/**

	 * Delegate for toggling a method breakpoint
	 * @param part
	 * @param element
	 * @param line
	 */
	void toggleMethodBreakpoint(final IWorkbenchPart part, final IJavaScriptElement element, final int line) {
		Job job = new Job("Toggle Function Breakpoints") { //$NON-NLS-1$
            protected IStatus run(IProgressMonitor monitor) {
            	try {
					if(element == null) {
						reportToStatusLine(part, Messages.failed_function_bp_no_element);
						return Status.CANCEL_STATUS;
					}
					if(element.getElementType() == IJavaScriptElement.METHOD) {
						IFunction method = (IFunction) element;
						IResource resource = element.getResource();
						if(resource == null) {
							reportToStatusLine(part, NLS.bind(Messages.failed_function_bp_no_resource, element.getElementName()));
							return Status.CANCEL_STATUS;
						}
						IBreakpoint bp = methodBreakpointExists(resource, method.getElementName(), method.getSignature());
						if(bp != null) {
							DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(bp, true);

						//nothing else we can do
						attributes.put(IJavaScriptBreakpoint.TYPE_NAME, getTypeName(element));
						attributes.put(IJavaScriptBreakpoint.SCRIPT_PATH, getScriptPath(element));
						attributes.put(IMarker.LINE_NUMBER, new Integer(line));
						IJavaScriptFunctionBreakpoint breakpoint = JavaScriptDebugModel.createFunctionBreakpoint(resource, method.getElementName(), method.getSignature(), start, end, attributes, true);
						breakpoint.setJavaScriptElementHandle(element.getHandleIdentifier());
						return Status.OK_STATUS;

		if(selection instanceof ITextSelection) {
			ITextEditor textEditor = getTextEditor(part);
			if(textEditor == null) {
				reportToStatusLine(part, Messages.no_editor_could_be_found);
				return;
			}
			ITypeRoot root = getTypeRoot(textEditor.getEditorInput());

                }
            }
            if(root == null) {
            	reportToStatusLine(part, Messages.type_root_could_not_be_computed);
            	return;
            }
			JavaScriptUnit jsunit = JavaScriptPlugin.getDefault().getASTProvider().getAST(root, ASTProvider.WAIT_YES, null);
			parser.setSource(root);
			JavaScriptUnit jsunit = (JavaScriptUnit) parser.createAST(null);
			BreakpointLocationFinder finder = new BreakpointLocationFinder(jsunit, ((TextSelection)selection).getStartLine()+1, false);
			jsunit.accept(finder);
			switch(finder.getLocation()) {

					return;
				}
				case BreakpointLocationFinder.FUNCTION: {
					toggleMethodBreakpoint(part, root.getElementAt(finder.getOffset()), finder.getLineNumber());
					return;
				}
			}

        	if(o instanceof IMember) {
        		IMember member = (IMember) o;
        		if(member.getElementType() == IJavaScriptElement.METHOD) {
    				toggleMethodBreakpoint(part, member, -1);
    			}
        	}
		}

Lines 18-23 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/breakpoints/messages.properties (+6 lines)
18	enter_condition=Enter a condition	18	enter_condition=Enter a condition
19	entry=E&ntry	19	entry=E&ntry
20	exit=E&xit	20	exit=E&xit
		21	failed_function_bp_no_element=Failed to create Javascript function breakpoint - the JavaScript element could not be computed
		22	failed_function_bp_no_resource=Failed to create Javascript function breakpoint - the resource could no be computed for {0}
		23	failed_line_bp_no_element=Failed to create Javascript line breakpoint - the JavaScript element could not be computed
		24	failed_line_bp_no_resource=Failed to create Javascript line breakpoint - the resource could no be computed for {0}
21	failed_to_create_function_bp=Failed to create Javascript function breakpoint	25	failed_to_create_function_bp=Failed to create Javascript function breakpoint
22	failed_to_create_line_bp=Failed to create Javascript line breakpoint	26	failed_to_create_line_bp=Failed to create Javascript line breakpoint
23	fuction=F&unction	27	fuction=F&unction
Lines 29-34 Link Here
29	line_breakpoint_settings=Line Breakpoint Settings	33	line_breakpoint_settings=Line Breakpoint Settings
30	line_number=&Line Number:	34	line_number=&Line Number:
31	member=&Member:	35	member=&Member:
		36	no_editor_could_be_found=No editor could be found for the associated part
32	no_valid_location=A valid location could not be found for the breakpoint	37	no_valid_location=A valid location could not be found for the breakpoint
33	script_load_bp=Script Load Breakpoint	38	script_load_bp=Script Load Breakpoint
34	script_load_breakpoint=Script Load Breakpoint	39	script_load_breakpoint=Script Load Breakpoint
Lines 38-40 Link Here
38	suspend_when_changed=Suspend &when value changes	43	suspend_when_changed=Suspend &when value changes
39	suspend_when_true=Suspend when 'tr&ue'	44	suspend_when_true=Suspend when 'tr&ue'
40	type_name=&Type Name:	45	type_name=&Type Name:
		46	type_root_could_not_be_computed=The type root could not be computed for the editor




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWindowListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

/**
 * Manager to handle contexts for evaluations
 * 
 * @since 1.0
 */
public class EvaluationManager implements IDebugContextListener, IWindowListener {

	/**
	 * System property used to know if the debugger is active or not
	 */
	public static final String DEBUGGER_ACTIVE = JavaScriptDebugUIPlugin.PLUGIN_ID + ".jsdebuggerActive"; //$NON-NLS-1$
	
	private static EvaluationManager instance = null;
	
	private IWorkbenchWindow activewindow = null;
	private HashMap contextmap = null;
	
	/**
	 * Constructor
	 */
	private EvaluationManager() {
		//no instantiation
		DebugUITools.getDebugContextManager().addDebugContextListener(this);
	}
	
	/**
	 * Returns the singleton instance
	 * 
	 * @return the instance
	 */
	public static synchronized EvaluationManager getManager() {
		if(instance == null) {
			instance = new EvaluationManager();
		}
		return instance;
	}
	
	/**
	 * Start the manager
	 */
	public void start() {
		IWorkbench workbench = PlatformUI.getWorkbench();
		IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
		for (int i = 0; i < windows.length; i++) {
			instance.windowOpened(windows[i]);	
		}
		workbench.addWindowListener(this);
		instance.activewindow = workbench.getActiveWorkbenchWindow();
	}
	
	/**
	 * Stop the manager and un-hook it as listeners
	 */
	public void stop() {
		DebugUITools.getDebugContextManager().removeDebugContextListener(this);
		PlatformUI.getWorkbench().removeWindowListener(this);
	}
	
	/**
	 * Returns the evaluation context for the given window, or <code>null</code> if none.
	 * The evaluation context corresponds to the selected stack frame in the following
	 * priority order:<ol>
	 * <li>stack frame in active page of the window</li>
	 * <li>stack frame in another page of the window</li>
	 * <li>stack frame in active page of another window</li>
	 * <li>stack frame in a page of another window</li>
	 * </ol>
	 * 
	 * @param window the window that the evaluation action was invoked from, or
	 *  <code>null</code> if the current window should be consulted
	 * @return the stack frame that supplies an evaluation context, or <code>null</code>
	 *   if none
	 * @return IJavaStackFrame
	 */
	public IJavaScriptStackFrame getEvaluationContext(IWorkbenchWindow window) {
		List otherwindows = new ArrayList();
		if (window == null) {
			return getEvaluationContext(activewindow, otherwindows);
		}
		return getEvaluationContext(window, otherwindows);
	}
	
	/**
	 * Returns the evaluation context for the given part, or <code>null</code> if none.
	 * The evaluation context corresponds to the selected stack frame in the following
	 * priority order:<ol>
	 * <li>stack frame in the same page</li>
	 * <li>stack frame in the same window</li>
	 * <li>stack frame in active page of other window</li>
	 * <li>stack frame in page of other windows</li>
	 * </ol>
	 * 
	 * @param part the part that the evaluation action was invoked from
	 * @return the stack frame that supplies an evaluation context, or <code>null</code>
	 *   if none
	 */
	public IJavaScriptStackFrame getEvaluationContext(IWorkbenchPart part) {
		IWorkbenchPage page = part.getSite().getPage();
		IJavaScriptStackFrame frame = getContext(page);
		if (frame == null) {
			return getEvaluationContext(page.getWorkbenchWindow());
		}
		return frame;
	}
	
	/**
	 * Looks up the current evaluation context for the given window. Tries all workbench windows
	 * if the active window does not have a context
	 * 
	 * @param window the window to look in
	 * @param otherwindows a listing of all other windows to try if the given window does not have a context
	 * @return the evaluation context or <code>null</code>
	 */
	IJavaScriptStackFrame getEvaluationContext(IWorkbenchWindow window, List otherwindows) {
		IWorkbenchPage activePage = window.getActivePage();
		IJavaScriptStackFrame frame = null;
		if (activePage != null) {
			frame = getContext(activePage);
		}
		if (frame == null) {
			IWorkbenchPage[] pages = window.getPages();
			for (int i = 0; i < pages.length; i++) {
				if (activePage != pages[i]) {
					frame = getContext(pages[i]);
					if (frame != null) {
						return frame;
					}
				}
			}
			otherwindows.add(window);
			IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
			for (int i = 0; i < windows.length; i++) {
				if (!otherwindows.contains(windows[i])) {
					frame = getEvaluationContext(windows[i], otherwindows);
					if (frame != null) {
						return frame;
					}
				}
			}
			return null;
		}
		return frame;
	}
	
	/**
	 * Looks up a context for the given page. Returns <code>null</code> if no mapping is found
	 * or if the context map has not been initialized
	 * 
	 * @param page the page to look up a context for
	 * 
	 * @return the {@link IJavaScriptStackFrame} context for the given page or <code>null</code>
	 */
	IJavaScriptStackFrame getContext(IWorkbenchPage page) {
		if (contextmap != null) {
			return (IJavaScriptStackFrame)contextmap.get(page);
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.contexts.IDebugContextListener#debugContextChanged(org.eclipse.debug.ui.contexts.DebugContextEvent)
	 */
	public void debugContextChanged(DebugContextEvent event) {
		if ((event.getFlags() & DebugContextEvent.ACTIVATED) > 0) {
			IWorkbenchPart part = event.getDebugContextProvider().getPart();
			if (part != null) {
				IWorkbenchPage page = part.getSite().getPage();
				ISelection selection = event.getContext();
				if (selection instanceof IStructuredSelection) {
					IStructuredSelection ss = (IStructuredSelection)selection;
					if (ss.size() == 1) {
						Object element = ss.getFirstElement();
						if (element instanceof IAdaptable) {
							IJavaScriptStackFrame frame = (IJavaScriptStackFrame)((IAdaptable)element).getAdapter(IJavaScriptStackFrame.class);
							if (frame != null) {
								setContext(page, frame);
								return;
							}
						}
					}
				}
				// no context in the given view
				removeContext(page);
			}
		}
	}

	/**
	 * Sets the evaluation context for the given page, and notes that
	 * a valid execution context exists.
	 * 
	 * @param page
	 * @param frame
	 */
	private synchronized void setContext(IWorkbenchPage page, IJavaScriptStackFrame frame) {
		if (contextmap == null) {
			contextmap = new HashMap();
		}
		contextmap.put(page, frame);
		System.setProperty(DEBUGGER_ACTIVE, "true"); //$NON-NLS-1$
	}
	
	/**
	 * Removes an evaluation context for the given page, and determines if
	 * any valid execution context remain.
	 * 
	 * @param page
	 */
	private void removeContext(IWorkbenchPage page) {
		if (contextmap != null) {
			contextmap.remove(page);
			if (contextmap.isEmpty()) {
				System.setProperty(DEBUGGER_ACTIVE, "false"); //$NON-NLS-1$
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWindowListener#windowActivated(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void windowActivated(IWorkbenchWindow window) {
		activewindow = window;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWindowListener#windowDeactivated(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void windowDeactivated(IWorkbenchWindow window) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWindowListener#windowClosed(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void windowClosed(IWorkbenchWindow window) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWindowListener#windowOpened(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void windowOpened(IWorkbenchWindow window) {
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.debug.internal.ui.SWTFactory;
import org.eclipse.debug.internal.ui.model.elements.ElementContentProvider;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdate;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdateListener;
import org.eclipse.debug.internal.ui.viewers.model.provisional.PresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
import org.eclipse.debug.internal.ui.views.variables.details.DefaultDetailPane;
import org.eclipse.debug.internal.ui.views.variables.details.DetailPaneProxy;
import org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer;
import org.eclipse.debug.ui.AbstractDebugView;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.text.AbstractInformationControl;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.IInformationControlExtension2;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

/**
 * Creates an information control to display an expression in a hover control.
 * 
 * @since 1.1
 */
public class ExpressionInformationControlCreator implements IInformationControlCreator {

	class ExpressionInformationControl extends AbstractInformationControl implements IInformationControlExtension2 {

		/**
		 * Dialog setting key for height
		 */
		private static final String HEIGHT = "HEIGHT"; //$NON-NLS-1$

		/**
		 * Dialog setting key for width. 
		 */
		private static final String WIDTH = "WIDTH"; //$NON-NLS-1$

		/**
		 * Dialog setting key for tree sash weight
		 */
		private static final String SASH_WEIGHT_TREE = "SashWeightTree"; //$NON-NLS-1$
		
		/**
		 * Dialog setting key for details sash weight
		 */
		private static final String SASH_WEIGHT_DETAILS = "SashWeightDetails"; //$NON-NLS-1$		
		
		/**
		 * Variable to display.
		 */
		private IVariable fVariable;
		
		private IPresentationContext fContext;
	    private TreeModelViewer fViewer;
	    private SashForm fSashForm;
	    private Composite fDetailPaneComposite;
	    private DetailPaneProxy fDetailPane;
	    private Tree fTree;
		    
		/**
	     * Creates the content for the root element of the tree viewer in the hover
	     */
	    private class TreeRoot extends ElementContentProvider {
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.elements.ElementContentProvider#getChildCount(java.lang.Object, org.eclipse.debug.internal.ui.viewers.provisional.IPresentationContext)
			 */
			protected int getChildCount(Object element, IPresentationContext context, IViewerUpdate monitor) throws CoreException {
				return 1;
			}
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.elements.ElementContentProvider#getChildren(java.lang.Object, int, int, org.eclipse.debug.internal.ui.viewers.provisional.IPresentationContext)
			 */
			protected Object[] getChildren(Object parent, int index, int length, IPresentationContext context, IViewerUpdate monitor) throws CoreException {
				return new Object[] { fVariable };
			}
			
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.elements.ElementContentProvider#supportsContextId(java.lang.String)
			 */
			protected boolean supportsContextId(String id) {
				return true;
			}
	    }
	    
		/**
		 * Inner class implementing IDetailPaneContainer methods.  Handles changes to detail
		 * pane and provides limited access to the detail pane proxy.
		 */
		private class DetailPaneContainer implements IDetailPaneContainer{
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#getCurrentPaneID()
			 */
			public String getCurrentPaneID() {
				return fDetailPane.getCurrentPaneID();
			}
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#getCurrentSelection()
			 */
			public IStructuredSelection getCurrentSelection() {
				return (IStructuredSelection)fViewer.getSelection();
			}
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#refreshDetailPaneContents()
			 */
			public void refreshDetailPaneContents() {		
				fDetailPane.display(getCurrentSelection());
			}
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#getParentComposite()
			 */
			public Composite getParentComposite() {
				return fDetailPaneComposite;
			}
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#getWorkbenchPartSite()
			 */
			public IWorkbenchPartSite getWorkbenchPartSite() {
				return null;
			}
		
			/* (non-Javadoc)
			 * @see org.eclipse.debug.internal.ui.views.variables.details.IDetailPaneContainer#paneChanged(java.lang.String)
			 */
			public void paneChanged(String newPaneID) {
				if (newPaneID.equals(DefaultDetailPane.ID)){
					fDetailPane.getCurrentControl().setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));
				}
			}
		
		}	    

		/**
		 * Constructs a new control in the given shell.
		 * 
		 * @param parentShell shell
		 * @param resize whether resize is supported
		 */
		ExpressionInformationControl(Shell parentShell, boolean resize) {
			super(parentShell, resize);
			create();
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#computeSizeHint()
		 */
		public Point computeSizeHint() {
			IDialogSettings settings = getDialogSettings(false);
			if (settings != null) {
				int x = getIntSetting(settings, WIDTH);
				if (x > 0) {
					int y = getIntSetting(settings, HEIGHT);
					if (y > 0) {
						return new Point(x,y);
					}
				}
			}
			return super.computeSizeHint();
		}

		/**
		 * Returns the dialog settings for this hover or <code>null</code> if none
		 * 
		 * @param create whether to create the settings
		 */
		private IDialogSettings getDialogSettings(boolean create) {
			IDialogSettings settings = JavaScriptDebugUIPlugin.getDefault().getDialogSettings();
			IDialogSettings section = settings.getSection(this.getClass().getName());
			if (section == null & create) {
				section = settings.addNewSection(this.getClass().getName());
			}
			return section;
		}
		
		/**
		 * Returns an integer value in the given dialog settings or -1 if none.
		 * 
		 * @param settings dialog settings
		 * @param key key
		 * @return value or -1 if not present
		 */
		private int getIntSetting(IDialogSettings settings, String key) {
			try {
				return settings.getInt(key);
			} catch (NumberFormatException e) {
				return -1;
			}
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#dispose()
		 */
		public void dispose() {
			persistSettings(getShell());
            fContext.dispose();
			super.dispose();
		}

		/**
		 * Persists dialog settings.
		 * 
		 * @param shell
		 */
		private void persistSettings(Shell shell) {
			if (shell != null && !shell.isDisposed()) {
				if (isResizable()) {
					IDialogSettings settings = getDialogSettings(true);
					Point size = shell.getSize();
					settings.put(WIDTH, size.x);
					settings.put(HEIGHT, size.y);
					int[] weights = fSashForm.getWeights();
					settings.put(SASH_WEIGHT_TREE, weights[0]);
					settings.put(SASH_WEIGHT_DETAILS, weights[1]);
				}
			}
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#setVisible(boolean)
		 */
		public void setVisible(boolean visible) {
			if (!visible) {		
				persistSettings(getShell());
			}
			super.setVisible(visible);
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#createContent(org.eclipse.swt.widgets.Composite)
		 */
		protected void createContent(Composite parent) {

	        fSashForm = new SashForm(parent, parent.getStyle());
	        fSashForm.setOrientation(SWT.VERTICAL);

		    // update presentation context
	        AbstractDebugView view = getViewToEmulate();
	        fContext = new PresentationContext(IDebugUIConstants.ID_VARIABLE_VIEW);
	        if (view != null) {
	        	// copy over properties
	        	IPresentationContext copy = ((TreeModelViewer)view.getViewer()).getPresentationContext();
	        	String[] properties = copy.getProperties();
	        	for (int i = 0; i < properties.length; i++) {
					String key = properties[i];
					fContext.setProperty(key, copy.getProperty(key));
				}
	        }
	       
	        fViewer = new TreeModelViewer(fSashForm, SWT.NO_TRIM | SWT.MULTI | SWT.VIRTUAL, fContext);
	        fViewer.setAutoExpandLevel(1);
	        
	        if (view != null) {
	        	// copy over filters
	        	StructuredViewer structuredViewer = (StructuredViewer) view.getViewer();
	            if (structuredViewer != null) {
	                ViewerFilter[] filters = structuredViewer.getFilters();
	                for (int i = 0; i < filters.length; i++) {
	                    fViewer.addFilter(filters[i]);
	                }
	            }
	        }

	        fDetailPaneComposite = SWTFactory.createComposite(fSashForm, 1, 1, GridData.FILL_BOTH);
	        Layout layout = fDetailPaneComposite.getLayout();
	        if (layout instanceof GridLayout) {
				GridLayout gl = (GridLayout) layout;
				gl.marginHeight = 0;
				gl.marginWidth = 0;
			}
	        
	        fDetailPane = new DetailPaneProxy(new DetailPaneContainer());
	        fDetailPane.display(null); // Bring up the default pane so the user doesn't see an empty composite
	      
	        fTree = fViewer.getTree();
	        fTree.addSelectionListener(new SelectionListener() {
	            public void widgetSelected(SelectionEvent e) {
	            	fDetailPane.display((IStructuredSelection)fViewer.getSelection());
	            }
	            public void widgetDefaultSelected(SelectionEvent e) {}
	        });

	        initSashWeights();
	              
	        // add update listener to auto-select and display details of root expression
	        fViewer.addViewerUpdateListener(new IViewerUpdateListener() {
				public void viewerUpdatesComplete() {
				}		
				public void viewerUpdatesBegin() {
				}
				public void updateStarted(IViewerUpdate update) {
				}
				public void updateComplete(IViewerUpdate update) {
					if (update instanceof IChildrenUpdate) {
						TreeSelection selection = new TreeSelection(new TreePath(new Object[]{fVariable}));
						fViewer.setSelection(selection);
						fDetailPane.display(selection);
						fViewer.removeViewerUpdateListener(this);
					}
				}
			});        
	        
	        setBackgroundColor(getShell().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));
		}
		

		/**
	     * Attempts to find an appropriate view to emulate, this will either be the
	     * variables view or the expressions view.
	     * @return a view to emulate or <code>null</code>
	     */
	    private AbstractDebugView getViewToEmulate() {
	        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
	        AbstractDebugView expressionsView = (AbstractDebugView) page.findView(IDebugUIConstants.ID_EXPRESSION_VIEW);
	        if (expressionsView != null && expressionsView.isVisible()) {
	            return expressionsView;
	        }
	        AbstractDebugView variablesView = (AbstractDebugView) page.findView(IDebugUIConstants.ID_VARIABLE_VIEW);
	        if (variablesView != null && variablesView.isVisible()) {
	            return variablesView;
	        }
	        if (expressionsView != null) {
	            return expressionsView;
	        }
	        return variablesView;
	    }	

		/**
	     * Initializes the sash form weights from the preference store (using default values if 
	     * no sash weights were stored previously).
	     */
	    protected void initSashWeights(){
	    	IDialogSettings settings = getDialogSettings(false);
	    	if (settings != null) {
		    	int tree = getIntSetting(settings, SASH_WEIGHT_TREE);
		    	if (tree > 0) {
		    		int details = getIntSetting(settings, SASH_WEIGHT_DETAILS);
		    		if (details > 0) {
		    			fSashForm.setWeights(new int[]{tree, details});
		    		}
		    	}
	    	}
	    }
	    		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#setBackgroundColor(org.eclipse.swt.graphics.Color)
		 */
		public void setBackgroundColor(Color background) {
			super.setBackgroundColor(background);
			fDetailPaneComposite.setBackground(background);
			fTree.setBackground(background);
		}
	
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#setFocus()
		 */
		public void setFocus() {
			super.setFocus();
			fTree.setFocus();
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.IInformationControlExtension#hasContents()
		 */
		public boolean hasContents() {
			return fVariable != null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.IInformationControlExtension2#setInput(java.lang.Object)
		 */
		public void setInput(Object input) {
			if (input instanceof IVariable) {	        
				fVariable = (IVariable) input;
		        fViewer.setInput(new TreeRoot());
			}
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.AbstractInformationControl#getInformationPresenterControlCreator()
		 */
		public IInformationControlCreator getInformationPresenterControlCreator() {
			return new ExpressionInformationControlCreator() {
				/* (non-Javadoc)
				 * @see org.eclipse.jdt.internal.debug.ui.ExpressionInformationControlCreator#createInformationControl(org.eclipse.swt.widgets.Shell)
				 */
				public IInformationControl createInformationControl(Shell shell) {
					return new ExpressionInformationControl(shell, true);
				}
			};
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IInformationControlCreator#createInformationControl(org.eclipse.swt.widgets.Shell)
	 */
	public IInformationControl createInformationControl(Shell parent) {
		return new ExpressionInformationControl(parent, false);
	}


}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextHoverExtension;
import org.eclipse.jface.text.ITextHoverExtension2;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.ui.IEditorPart;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptModelPresentation;
import org.eclipse.wst.jsdt.internal.ui.text.JavaWordFinder;
import org.eclipse.wst.jsdt.ui.text.java.hover.IJavaEditorTextHover;

/**
 * JavaScript hover to show variables
 * 
 * @since 1.1
 */
public class JavaScriptDebugHover implements IJavaEditorTextHover, ITextHoverExtension, ITextHoverExtension2 {

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.ITextHover#getHoverInfo(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)
	 */
	public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
		Object object = getHoverInfo2(textViewer, hoverRegion);
		if (object instanceof IVariable) {	
			IVariable var = (IVariable) object;
			return getVariableText(var);
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.ITextHover#getHoverRegion(org.eclipse.jface.text.ITextViewer, int)
	 */
	public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
		return JavaWordFinder.findWord(textViewer.getDocument(), offset);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.ITextHoverExtension2#getHoverInfo2(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)
	 */
	public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
		IJavaScriptStackFrame frame = getFrame();
	    if (frame != null) {
	        IDocument document = textViewer.getDocument();
			if (document != null) {
			    try {
                    String variableName = document.get(hoverRegion.getOffset(), hoverRegion.getLength());
                    IVariable var = findLocalVariable(frame, variableName);
                    if(var != null) {
                    	return var;
                    }
                    //might be in 'this'
                    var = frame.getThisObject();
                    try {
	                    IValue val = var.getValue();
	                    if(val != null) {
	                    	IVariable[] vars = val.getVariables();
	                    	for (int i = 0; i < vars.length; i++) {
	                    		if(vars[i].getName().equals(variableName)) {
	                    			return vars[i];
	                    		}
							}
	                    }
                    }
                    catch(DebugException de) {
                    	return null;
                    }
                    	
                } catch (BadLocationException e) {
                    return null;
                }
			}
	    }
	    return null;
	}

	/**
	 * Returns a local variable in the given frame based on the the given name
	 * or <code>null</code> if none.
	 * 
	 * @return local variable or <code>null</code>
	 */
	private IVariable findLocalVariable(IJavaScriptStackFrame frame, String variableName) {
		if (frame != null) {
			try {
				IVariable[] vars = frame.getVariables();
            	for (int i = 0; i < vars.length; i++) {
					if(vars[i].getName().equals(variableName)) {
						return vars[i];
					}
				}
			} catch (DebugException x) {
				JavaScriptDebugUIPlugin.log(x);
			}
		}
		return null;
	}	
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.ITextHoverExtension#getHoverControlCreator()
	 */
	public IInformationControlCreator getHoverControlCreator() {
		return new ExpressionInformationControlCreator();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.ui.text.java.hover.IJavaEditorTextHover#setEditor(org.eclipse.ui.IEditorPart)
	 */
	public void setEditor(IEditorPart editor) {
	}
	
	/**
	 * Returns HTML text for the given variable
	 */
	private static String getVariableText(IVariable variable) {
	    StringBuffer buffer= new StringBuffer();
		JavaScriptModelPresentation modelPresentation = new JavaScriptModelPresentation();
		buffer.append("<p><pre>"); //$NON-NLS-1$
		String variableText= modelPresentation.getText(variable);
		buffer.append(replaceHTMLChars(variableText));
		buffer.append("</pre></p>"); //$NON-NLS-1$
		modelPresentation.dispose();
		if (buffer.length() > 0) {
			return buffer.toString();
		}
		return null;
	}
	
	/**
	 * Replaces reserved HTML characters in the given string with
	 * their escaped equivalents. This is to ensure that variable
	 * values containing reserved characters are correctly displayed.
     */
    private static String replaceHTMLChars(String variableText) {
        StringBuffer buffer = new StringBuffer(variableText.length());
        char[] characters = variableText.toCharArray();
        for (int i = 0; i < characters.length; i++) {
            char character = characters[i];
            switch (character) {
            	case '<':
            	    buffer.append("&lt;"); //$NON-NLS-1$
            	    break;
            	case '>':
            	    buffer.append("&gt;"); //$NON-NLS-1$
            	    break;
            	case '&':
            	    buffer.append("&amp;"); //$NON-NLS-1$
            	    break;
            	case '"':
            	    buffer.append("&quot;"); //$NON-NLS-1$
            	    break;
            	default:
            	    buffer.append(character);
            }
        }
        return buffer.toString();
    }
	
	/**
	 * Returns the stack frame in which to search for variables, or <code>null</code>
	 * if none.
	 * 
	 * @return the stack frame in which to search for variables, or <code>null</code>
	 * if none
	 */
	protected IJavaScriptStackFrame getFrame() {
	    IAdaptable adaptable = DebugUITools.getDebugContext();
		if (adaptable != null) {
			return (IJavaScriptStackFrame)adaptable.getAdapter(IJavaScriptStackFrame.class);
		}
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.hyperlink.AbstractHyperlinkDetector;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.internal.ui.text.JavaWordFinder;

/**
 * Hyper-link detector for stepping into selections in the JavaScript editor
 * 
 * @since 1.0
 */
public class JavaScriptHyperlinkDetector extends AbstractHyperlinkDetector {

	/**
	 * Hyper-link for stepping into the selection
	 */
	class StepIntoSelectionHyperlink implements IHyperlink {
		
		private IRegion fRegion = null;
		
		/**
		 * Constructor
		 * @param region
		 */
		public StepIntoSelectionHyperlink(IRegion region) {
			fRegion = region;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.hyperlink.IHyperlink#getHyperlinkRegion()
		 */
		public IRegion getHyperlinkRegion() {
			return fRegion;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.hyperlink.IHyperlink#getHyperlinkText()
		 */
		public String getHyperlinkText() {
			return Messages.hyperlink_step_into;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.hyperlink.IHyperlink#getTypeLabel()
		 */
		public String getTypeLabel() {
			return null;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jface.text.hyperlink.IHyperlink#open()
		 */
		public void open() {
			StepIntoSelectionActionDelegate delegate = new StepIntoSelectionActionDelegate(fRegion);
			delegate.init(PlatformUI.getWorkbench().getActiveWorkbenchWindow());
			delegate.run(null);
		}
	}
	
	/**
	 * Constructor
	 */
	public JavaScriptHyperlinkDetector() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.hyperlink.IHyperlinkDetector#detectHyperlinks(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion, boolean)
	 */
	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) {
		ITextEditor editor = (ITextEditor) getAdapter(ITextEditor.class);
		if(editor != null) {
			IJavaScriptStackFrame frame = EvaluationManager.getManager().getEvaluationContext(PlatformUI.getWorkbench().getActiveWorkbenchWindow());
			if (frame == null) {
				return null;
			}
			IEditorInput input = editor.getEditorInput();
			IJavaScriptElement element = StepIntoSelectionUtils.getJavaElement(input);
			int offset = region.getOffset();
			if(element != null) {
				try {
					IDocument document = editor.getDocumentProvider().getDocument(editor.getEditorInput());
					if(document != null) {
						IRegion wregion = JavaWordFinder.findWord(document, offset);
						if(wregion != null) {
							IFunction method = StepIntoSelectionUtils.getFunction(new TextSelection(document, wregion.getOffset(), wregion.getLength()), element);
							if (method != null) {
								return new IHyperlink[] {new StepIntoSelectionHyperlink(wregion)};
							}
						}
					}
				}
				catch(JavaScriptModelException jme) {
					JavaScriptDebugUIPlugin.log(jme);
				}
			}
		}
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IExpression;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.debug.core.model.IWatchExpression;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptDebugTarget;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptValue;
import org.eclipse.wst.jsdt.debug.core.model.JavaScriptDebugModel;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

/**
 * Inspect expression for a JavaScript evaluation result
 * 
 * @since 1.0
 */
public class JavaScriptInspectExpression implements IWatchExpression {

	private IJavaScriptValue value = null;
	
	/**
	 * Constructor
	 * 
	 * @param value the value to show
	 */
	public JavaScriptInspectExpression(IJavaScriptValue value) {
		this.value = value;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IDebugElement#getModelIdentifier()
	 */
	public String getModelIdentifier() {
		return JavaScriptDebugModel.MODEL_ID;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
	 */
	public ILaunch getLaunch() {
		return value.getLaunch();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class adapter) {
		if(IJavaScriptValue.class.equals(adapter)) {
			return value;
		}
		if(IExpression.class.equals(adapter)) {
			return this;
		}
		if(IJavaScriptDebugTarget.class.equals(adapter)) {
			return value.getDebugTarget();
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IExpression#getExpressionText()
	 */
	public String getExpressionText() {
		try {
			return value.getValueString();
		}
		catch(DebugException de) {
			JavaScriptDebugUIPlugin.log(de);
			return null;
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IExpression#getValue()
	 */
	public IValue getValue() {
		return value;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IExpression#getDebugTarget()
	 */
	public IDebugTarget getDebugTarget() {
		return value.getDebugTarget();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IExpression#dispose()
	 */
	public void dispose() {
		value = null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IErrorReportingExpression#hasErrors()
	 */
	public boolean hasErrors() {
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IErrorReportingExpression#getErrorMessages()
	 */
	public String[] getErrorMessages() {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#evaluate()
	 */
	public void evaluate() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#setExpressionContext(org.eclipse.debug.core.model.IDebugElement)
	 */
	public void setExpressionContext(IDebugElement context) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#setExpressionText(java.lang.String)
	 */
	public void setExpressionText(String expressionText) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#isPending()
	 */
	public boolean isPending() {
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#isEnabled()
	 */
	public boolean isEnabled() {
		return value != null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IWatchExpression#setEnabled(boolean)
	 */
	public void setEnabled(boolean enabled) {
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.osgi.util.NLS;

/**
 * 
 */
public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.wst.jsdt.debug.internal.ui.eval.messages"; //$NON-NLS-1$
	public static String cannot_find_debug_target;
	public static String cursor_position_not_valid;
	public static String empty_editor;
	public static String exception_running_to_line;
	public static String exe_did_not_enter__0__before_returning;
	public static String hyperlink_step_into;
	public static String missing_doc;
	public static String only_in_the_js_editor;
	public static String selected_line_not_valid;
	public static String step_into_only_top_frame;
	public static String step_into_selection;
	static {
		// initialize resource bundle
		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
	}

	private Messages() {
	}
}




/*******************************************************************************
 *  Copyright (c) 2010 IBM Corporation and others.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 * 
 *  Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.ISuspendResume;
import org.eclipse.debug.ui.actions.IRunToLineTarget;
import org.eclipse.debug.ui.actions.RunToLineHandler;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.jsdt.core.dom.AST;
import org.eclipse.wst.jsdt.core.dom.ASTParser;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptDebugTarget;
import org.eclipse.wst.jsdt.debug.core.model.JavaScriptDebugModel;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.BreakpointLocationFinder;

/**
 * Run to line target for the JavaScript debugger
 * 
 * @since 1.0
 */
public class RunToLineAdapter implements IRunToLineTarget {
	
	/**
	 * Marker attribute used to denote a run to line breakpoint
	 */
	private static final String RUN_TO_LINE =  JavaScriptDebugUIPlugin.PLUGIN_ID + ".run_to_line"; //$NON-NLS-1$
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.actions.IRunToLineTarget#runToLine(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection, org.eclipse.debug.core.model.ISuspendResume)
	 */
	public void runToLine(IWorkbenchPart part, ISelection selection, ISuspendResume target) throws CoreException {
		ITextEditor textEditor = StepIntoSelectionUtils.getTextEditor(part);
		if (textEditor == null) {
			throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.missing_doc, null));
		} 
		IEditorInput input = textEditor.getEditorInput();
		if (input == null) {
			throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.empty_editor, null));
		} 
		final IDocument document= textEditor.getDocumentProvider().getDocument(input);
		if (document == null) {
			throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.missing_doc, null));
		} 
		final int[] validLine = new int[1];
		final String[] typeName = new String[1];
		final int[] lineNumber = new int[1];
		final ITextSelection textSelection = (ITextSelection) selection;
		Runnable r = new Runnable() {
			public void run() {
				lineNumber[0] = textSelection.getStartLine() + 1;
				ASTParser parser = ASTParser.newParser(AST.JLS3);
				parser.setSource(document.get().toCharArray());
				JavaScriptUnit compilationUnit = (JavaScriptUnit)parser.createAST(null);
				BreakpointLocationFinder locator = new BreakpointLocationFinder(compilationUnit, lineNumber[0], false);
				compilationUnit.accept(locator);
				validLine[0] = locator.getLineNumber();		
				typeName[0] = locator.getFunctionName();
			}
		};
		BusyIndicator.showWhile(JavaScriptDebugUIPlugin.getStandardDisplay(), r);
		if (validLine[0] == lineNumber[0]) {
			IBreakpoint breakpoint= null;
			Map attributes = new HashMap(4);
			attributes.put(IBreakpoint.PERSISTED, Boolean.FALSE);
			attributes.put(RUN_TO_LINE, Boolean.TRUE);
			breakpoint = JavaScriptDebugModel.createLineBreakpoint(ResourcesPlugin.getWorkspace().getRoot(), lineNumber[0], -1, -1, attributes, false);
			if (target instanceof IAdaptable) {
				IDebugTarget debugTarget = (IDebugTarget) ((IAdaptable)target).getAdapter(IDebugTarget.class);
				if (debugTarget == null) {
					throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.cannot_find_debug_target, null));
				}
                RunToLineHandler handler = new RunToLineHandler(debugTarget, target, breakpoint);
                handler.run(new NullProgressMonitor());
				return;
			}
		} else {
			// invalid line
			if (textSelection.getLength() > 0) {
				throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.selected_line_not_valid, null));
			} 
			throw new CoreException(new Status(IStatus.ERROR, JavaScriptDebugUIPlugin.PLUGIN_ID, Messages.cursor_position_not_valid, null));
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.actions.IRunToLineTarget#canRunToLine(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection, org.eclipse.debug.core.model.ISuspendResume)
	 */
	public boolean canRunToLine(IWorkbenchPart part, ISelection selection, ISuspendResume target) {
	    if (target instanceof IDebugElement) {
            IDebugElement element = (IDebugElement) target;
            IJavaScriptDebugTarget adapter = (IJavaScriptDebugTarget) element.getDebugTarget().getAdapter(IJavaScriptDebugTarget.class);
            return adapter != null;
        }
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;


import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.Platform;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventSetListener;
import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.ui.actions.IRunToLineTarget;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.texteditor.IEditorStatusLine;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptThread;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

/**
 * Steps into the selected function.
 * 
 * @since 1.0
 */
public class StepIntoSelectionActionDelegate implements IEditorActionDelegate, IWorkbenchWindowActionDelegate {
	
	private IEditorPart editor = null;
	private IWorkbenchWindow window = null;
	private IRegion region = null;
	
	/**
	 * Default constructor
	 */
	public StepIntoSelectionActionDelegate() {}
	
	/**
	 * Constructor
	 * @param region
	 */
	public StepIntoSelectionActionDelegate(IRegion region) {
		this.region = region;
	}

	/**
	 * The line number being "run to."
	 */
	private int line = -1;
	
	/**
	 * The debug event list listener used to know when a run to line has finished.
	 * @see StepIntoSelectionActionDelegate#runToLineBeforeStepIn(ITextSelection, IJavaScriptStackFrame, IFunction)
	 */
	private IDebugEventSetListener listener = null;

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		IJavaScriptStackFrame frame = getStackFrame();
		if (frame == null || !frame.isSuspended()) {
			// no longer suspended - unexpected
			return;
		}
		ITextSelection textSelection = getTextSelection();
		try {
			IEditorPart activeEditor = getActiveEditor();
			IJavaScriptElement javaElement= StepIntoSelectionUtils.getJavaElement(activeEditor.getEditorInput());
			IFunction function = StepIntoSelectionUtils.getFunction(textSelection, javaElement);
			if (function == null) {
				function = StepIntoSelectionUtils.getFirstFunctionOnLine(textSelection.getOffset(), activeEditor, javaElement);
			}
			int lineNumber = frame.getLineNumber();
			if (textSelection.getStartLine() == (lineNumber - 1)) {
                doStepIn(frame, function);
			} else {
				runToLineBeforeStepIn(textSelection, frame.getThread(), function);
				return;
			}
		} 
		catch (DebugException e) {
			showErrorMessage(e.getStatus().getMessage());
			return;
		}
		catch(JavaScriptModelException jme) {
			showErrorMessage(jme.getStatus().getMessage());
			return;
		}
	}
	
	/**
	 * Steps into the given function in the given stack frame
	 * @param frame the frame in which the step should begin
	 * @param function the function to step into
	 * @throws DebugException
	 */
	private void doStepIn(IJavaScriptStackFrame frame, IFunction function) throws DebugException {
		// ensure top stack frame
		IStackFrame tos = frame.getThread().getTopStackFrame();
		if (tos == null) {
			return; 
		}		
		if (!tos.equals(frame)) {
			showErrorMessage(Messages.step_into_only_top_frame); 
			return;
		}
		StepIntoSelectionHandler handler = new StepIntoSelectionHandler((IJavaScriptThread)frame.getThread(), frame, function);
		handler.step();
	}
	
	/**
	 * When the user chooses to "step into selection" on a line other than
	 * the currently executing one, first perform a "run to line" to get to
	 * the desired location, then perform a "step into selection."
	 */
	private void runToLineBeforeStepIn(ITextSelection textSelection, final IThread thread, final IFunction function) {
		line = textSelection.getStartLine() + 1;
		if (line == -1) {
			return;
		}
		// see bug 65489 - get the run-to-line adapter from the editor
		IRunToLineTarget runToLineAction = null;
		IEditorPart ed = getActiveEditor();
		if (ed != null) {
			runToLineAction  = (IRunToLineTarget) ed.getAdapter(IRunToLineTarget.class);
			if (runToLineAction == null) {
				IAdapterManager adapterManager = Platform.getAdapterManager();
				if (adapterManager.hasAdapter(ed, IRunToLineTarget.class.getName())) { 
					runToLineAction = (IRunToLineTarget) adapterManager.loadAdapter(ed,IRunToLineTarget.class.getName()); 
				}
			}
		}	
		// if no adapter exists, use the Java adapter
		if (runToLineAction == null) {
		  runToLineAction = new RunToLineAdapter();
		}
		listener = new IDebugEventSetListener() {

			/* (non-Javadoc)
			 * @see org.eclipse.debug.core.IDebugEventSetListener#handleDebugEvents(org.eclipse.debug.core.DebugEvent[])
			 */
			public void handleDebugEvents(DebugEvent[] events) {
				for (int i = 0; i < events.length; i++) {
					DebugEvent event = events[i];
					switch (event.getKind()) {
						case DebugEvent.SUSPEND :
							handleSuspendEvent(event);
							break;
						case DebugEvent.TERMINATE :
							handleTerminateEvent(event);
							break;
						default :
							break;
					}
				}
			}
			/**
			 * Listen for the completion of the "run to line." When the thread
			 * suspends at the correct location, perform a "step into selection"
			 * 
			 * @param event the debug event
			 */
			private void handleSuspendEvent(DebugEvent event) {
				Object source = event.getSource();
				if (source instanceof IJavaScriptThread) {
					try {
						final IJavaScriptStackFrame frame= (IJavaScriptStackFrame) ((IJavaScriptThread) source).getTopStackFrame();
						if (isExpectedFrame(frame)) {
							DebugPlugin plugin = DebugPlugin.getDefault();
							plugin.removeDebugEventListener(listener);
							plugin.asyncExec(new Runnable() {
								public void run() {
									try {
										doStepIn(frame, function);
									} catch (DebugException e) {
										showErrorMessage(e.getStatus().getMessage());
									}
								}
							});
						}
					} catch (DebugException e) {
						return;
					}
				}
			}
			/**
			 * Returns whether the given frame is the frame that this action is expecting.
			 * This frame is expecting a stack frame for the suspension of the "run to line".
			 * @param frame the given stack frame or <code>null</code>
			 * @return whether the given stack frame is the expected frame
			 * @throws DebugException
			 */
			private boolean isExpectedFrame(IJavaScriptStackFrame frame) throws DebugException {
				return frame != null && line == frame.getLineNumber();
			}
			/**
			 * When the debug target we're listening for terminates, stop listening
			 * to debug events.
			 * @param event the debug event
			 */
			private void handleTerminateEvent(DebugEvent event) {
				Object source = event.getSource();
				if (thread.getDebugTarget() == source) {
					DebugPlugin.getDefault().removeDebugEventListener(listener);
				}
			}
		};
		DebugPlugin.getDefault().addDebugEventListener(listener);
		try {
			runToLineAction.runToLine(getActiveEditor(), textSelection, thread);
		} catch (CoreException e) {
			DebugPlugin.getDefault().removeDebugEventListener(listener);
			showErrorMessage(Messages.exception_running_to_line); 
			JavaScriptDebugUIPlugin.log(e.getStatus());
		}
	}
	
	/**
	 * Gets the current text selection from the currently active editor
	 * @return the current text selection
	 */
	private ITextSelection getTextSelection() {
		IEditorPart part = getActiveEditor();
		if (part instanceof ITextEditor) { 
			ITextEditor editor = (ITextEditor)part;
			if(region != null) {
				IDocument document = editor.getDocumentProvider().getDocument(editor.getEditorInput());
				if(document != null) {
					return new TextSelection(document, region.getOffset(), region.getLength());
				}
			}
			else {
				return (ITextSelection)editor.getSelectionProvider().getSelection();
			}
		}
		showErrorMessage(Messages.only_in_the_js_editor); 
		return null;
	}
	
	/**
	 * Displays an error message in the status area
	 * 
	 * @param message
	 */
	protected void showErrorMessage(String message) {	
		if (getActiveEditor() != null) {
			IEditorStatusLine statusLine= (IEditorStatusLine) getActiveEditor().getAdapter(IEditorStatusLine.class);
			if (statusLine != null) {
				statusLine.setMessage(true, message, null);
			}
		}		
		JavaScriptDebugUIPlugin.getStandardDisplay().beep();		
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IEditorActionDelegate#setActiveEditor(org.eclipse.jface.action.IAction, org.eclipse.ui.IEditorPart)
	 */
	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
		editor = targetEditor;
	}
	
	/**
	 * Returns the active editor or <code>null</code>.
	 * 
	 * @return active editor or <code>null</code>
	 */
	protected IEditorPart getActiveEditor() {
		if (window != null) {
			// global action
			return window.getActivePage().getActiveEditor();
		}
		// pop-up action
		return editor;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {
	}

	/**
	 * Returns the current stack frame context, or <code>null</code> if none.
	 * 
	 * @return the current stack frame context, or <code>null</code> if none
	 */
	protected IJavaScriptStackFrame getStackFrame() {
		return EvaluationManager.getManager().getEvaluationContext(getActiveEditor());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
	 */
	public void dispose() {}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void init(IWorkbenchWindow window) {
		this.window = window;
	}

}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;


import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventFilter;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptDebugTarget;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptStackFrame;
import org.eclipse.wst.jsdt.debug.core.model.IJavaScriptThread;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;

/**
 * Handles stepping into a selected function, for a specific thread.
 * 
 * @since 1.0
 */
public class StepIntoSelectionHandler implements IDebugEventFilter {
	
	/**
	 * The function to step into
	 */
	private IFunction function;
	
	/**
	 * Resolved signature of the function to step into
	 */
	private String signature;
	
	/**
	 * The thread in which to step
	 */
	private IJavaScriptThread thread;

	/**
	 * The initial stack frame
	 */
	private String origname;
	private int origdepth;
	
	/**
	 * Whether this is the first step into.
	 */
	private boolean firststep = true;
	
	/**
	 * Expected event kind
	 */
	private int eventkind = -1;
	
	/**
	 * Expected event detail
	 */
	private int eventdetail = -1;

	/**
	 * Constructs a step handler to step into the given function in the given thread
	 * starting from the given stack frame.
	 * 
	 * @param thread
	 * @param frame
	 * @param func
	 */
	public StepIntoSelectionHandler(IJavaScriptThread thread, IJavaScriptStackFrame frame, IFunction func) {
		function = func;
		this.thread = thread;
		try {
			origname = frame.getName();
			signature = func.getSignature();
		} catch (CoreException e) {
			JavaScriptDebugUIPlugin.log(e);
		}
	}
	
	/**
	 * Returns the target thread for the step.
	 * 
	 * @return the target thread for the step
	 */
	protected IJavaScriptThread getThread() {
		return thread;
	}
	
	protected IJavaScriptDebugTarget getDebugTarget() {
		return (IJavaScriptDebugTarget)getThread().getDebugTarget();
	}
	
	/**
	 * Returns the function to step into
	 * 
	 * @return the function to step into
	 */
	protected IFunction getMethod() {
		return function;
	}
	
	/**
	 * Returns the resolved signature of the function to step into
	 * 
	 * @return the resolved signature of the function to step into
	 */
	protected String getSignature() {
		return signature;
	}	
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.IDebugEventFilter#filterDebugEvents(org.eclipse.debug.core.DebugEvent[])
	 */
	public DebugEvent[] filterDebugEvents(DebugEvent[] events) {
		// we only expect one event from our thread - find the event
		DebugEvent event = null;
		int index = -1;
		int threadEvents = 0;
		for (int i = 0; i < events.length; i++) {
			DebugEvent e = events[i];
			if (isExpectedEvent(e)) {
				event = e;
				index = i;
				threadEvents++;
			} else if (e.getSource() == getThread()) {
				threadEvents++;
			} 
		}
		if (event == null) {
			// nothing to process in this event set
			return events;
		}
		// create filtered event set
		DebugEvent[] filtered = new DebugEvent[events.length - 1];
		if (filtered.length > 0) {
			int j = 0;
			for (int i = 0; i < events.length; i++) {
				if (i != index) {
					filtered[j] = events[i];
					j++;
				}
			}
		}
		// if more than one event in our thread, abort (filtering our event)
		if (threadEvents > 1) {
			cleanup();
			return filtered;
		}
		// we have the one expected event - process it
		switch (event.getKind()) {
			case DebugEvent.RESUME:
				// next, we expect a step end
				setExpectedEvent(DebugEvent.SUSPEND, DebugEvent.STEP_END);
				if (firststep) {
					firststep = false;
					return events; // include the first resume event
				}
				// secondary step - filter the event
				return filtered;			
			case DebugEvent.SUSPEND:
				// compare location to desired location
				try {
					final IJavaScriptStackFrame frame = (IJavaScriptStackFrame)getThread().getTopStackFrame();
					int stackDepth = frame.getThread().getStackFrames().length;
					String name = frame.getName();
					if (name.equals(getMethod().getElementName())) {
						// hit
						cleanup();
						return events;
					}
					// step again
					Runnable r = null;
					if (stackDepth > origdepth) {
						r = new Runnable() {
							public void run() {
								try {
									setExpectedEvent(DebugEvent.RESUME, DebugEvent.STEP_RETURN);
									frame.stepReturn();
								} catch (DebugException e) {
									JavaScriptDebugUIPlugin.log(e);
									cleanup();
									DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[]{new DebugEvent(getDebugTarget(), DebugEvent.CHANGE)});
								}
							}
						};
					} else if (stackDepth == origdepth){
						// we should be back in the original stack frame - if not, abort
						if (!frame.getName().equals(origname)) {
							missed();
							return events;
						}
						r = new Runnable() {
							public void run() {
								try {
									setExpectedEvent(DebugEvent.RESUME, DebugEvent.STEP_INTO);
									frame.stepInto();	
								} catch (DebugException e) {
									JavaScriptDebugUIPlugin.log(e);
									cleanup();
									DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[]{new DebugEvent(getDebugTarget(), DebugEvent.CHANGE)});
								}
							}
						};																
					} else {
						// we returned from the original frame - never hit the desired method
						missed();
						return events;								
					}
					DebugPlugin.getDefault().asyncExec(r);
					// filter the events
						return filtered;
				} catch (CoreException e) {
					// abort
					JavaScriptDebugUIPlugin.log(e);
					cleanup();
					return events;
				}			
		}
		// execution should not reach here
		return events;
		 
	}
	
	/** 
	 * Called when stepping returned from the original frame without entering the desired method.
	 */
	protected void missed() {
		cleanup();
		Runnable r = new Runnable() {
			public void run() {
				String methodName = null;
				try {
					methodName = org.eclipse.wst.jsdt.core.Signature.toString(getMethod().getSignature(), getMethod().getElementName(), getMethod().getParameterNames(), false, false);
				} catch (JavaScriptModelException e) {
					methodName = getMethod().getElementName();
				}
				new MessageDialog(
						PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),  
						Messages.step_into_selection, 
						null, 
						NLS.bind(Messages.exe_did_not_enter__0__before_returning, new String[]{methodName}), 
						MessageDialog.INFORMATION, new String[] {IDialogConstants.OK_LABEL}, 0).open();    
			}
		};
		JavaScriptDebugUIPlugin.getStandardDisplay().asyncExec(r);		
	}

	/**
	 * Performs the step.
	 */
	public void step() {
		// add event filter and turn off step filters
		DebugPlugin.getDefault().addDebugEventFilter(this);
		try {
			origdepth = getThread().getStackFrames().length;
			setExpectedEvent(DebugEvent.RESUME, DebugEvent.STEP_INTO);
			getThread().stepInto();
		} catch (DebugException e) {
			JavaScriptDebugUIPlugin.log(e);
			cleanup();
			DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[]{new DebugEvent(getDebugTarget(), DebugEvent.CHANGE)});			
		}
	}
	
	/**
	 * Cleans up when the step is complete/aborted.
	 */
	protected void cleanup() {
		DebugPlugin.getDefault().removeDebugEventFilter(this);
	}
	
	/**
	 * Sets the expected debug event kind and detail we are waiting for next.
	 * 
	 * @param kind event kind
	 * @param detail event detail
	 */
	private void setExpectedEvent(int kind, int detail) {
		eventkind = kind;
		eventdetail = detail;
	}
	
	/**
	 * Returns whether the given event is what we expected.
	 * 
	 * @param event fire event
	 * @return whether the event is what we expected
	 */
	protected boolean isExpectedEvent(DebugEvent event) {
		return event.getSource().equals(getThread()) &&
			event.getKind() == eventkind &&
			event.getDetail() == eventdetail;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.eval;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.jsdt.core.ICodeAssist;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.core.ToolFactory;
import org.eclipse.wst.jsdt.core.compiler.IScanner;
import org.eclipse.wst.jsdt.core.compiler.ITerminalSymbols;
import org.eclipse.wst.jsdt.core.compiler.InvalidInputException;
import org.eclipse.wst.jsdt.ui.JavaScriptUI;

/**
 * Utility class for aiding step into selection actions and hyper-linking
 * 
 * @since 1.1
 */
public class StepIntoSelectionUtils {

	/**
     * Returns the text editor associated with the given part or <code>null</code>
     * if none. In case of a multi-page editor, this method should be used to retrieve
     * the correct editor to perform the operation on.
     * 
     * @param part workbench part
     * @return text editor part or <code>null</code>
     */
    public static ITextEditor getTextEditor(IWorkbenchPart part) {
    	if (part instanceof ITextEditor) {
    		return (ITextEditor) part;
    	}
    	return (ITextEditor) part.getAdapter(ITextEditor.class);
    }	
	
	/**
     * gets the <code>IJavaScriptElement</code> from the editor input
     * @param input the current editor input
     * @return the corresponding <code>IJavaScriptElement</code>
     */
    public static IJavaScriptElement getJavaElement(IEditorInput input) {
    	IJavaScriptElement je = JavaScriptUI.getEditorInputJavaElement(input);
    	if(je != null) {
    		return je;
    	}
    	return JavaScriptUI.getWorkingCopyManager().getWorkingCopy(input);
    }
    
    /**
     * Returns the <code>IFuntion</code> from the given selection within the given <code>IJavaScriptElement</code>, 
     * or <code>null</code> if the selection does not container or is not an <code>IFunction</code>
     * @param selection
     * @param element
     * @return the corresponding <code>IFunction</code> from the selection within the provided <code>IJavaScriptElement</code>
     * @throws JavaScriptModelException
     */
    public static IFunction getFunction(ITextSelection selection, IJavaScriptElement element) throws JavaScriptModelException {
    	if(element != null && element instanceof ICodeAssist) {
    		return resolveFunction(selection.getOffset(), selection.getLength(), (ICodeAssist)element);
    	}
    	return null;
    }

	/**
	 * @param offset selection offset
	 * @param length selection length
	 * @param codeAssist context
	 * @return the function at the given position, or <code>null</code> if no function could be resolved 
	 * @throws JavaScriptModelException
	 */
	private static IFunction resolveFunction(int offset, int length, ICodeAssist codeAssist) throws JavaScriptModelException {
		IJavaScriptElement[] elements = codeAssist.codeSelect(offset, length);
		for (int i = 0; i < elements.length; i++) {
			if (elements[i] instanceof IFunction) {
				return (IFunction)elements[i];
			}
		}
		return null;
	}
    
	/**
	 * @param offset
	 * @param activeEditor
	 * @param element
	 * @return the first function found at or after <code>offset</code> on the same line
	 * @throws JavaScriptModelException
	 */
	public static IFunction getFirstFunctionOnLine(int offset, IEditorPart activeEditor, IJavaScriptElement element) throws JavaScriptModelException {
		if (! (activeEditor instanceof ITextEditor) || ! (element instanceof ICodeAssist)) {
			return null;
		}
		ITextEditor editor = (ITextEditor)activeEditor;
		IDocumentProvider documentProvider = editor.getDocumentProvider();
		if (documentProvider == null) {
			return null;
		}
		IDocument document = documentProvider.getDocument(editor.getEditorInput());
		if (document == null) {
			return null;
		}
		try {
			IRegion lineInfo = document.getLineInformationOfOffset(offset);
			String line = document.get(lineInfo.getOffset(), lineInfo.getLength());
			IScanner scanner = ToolFactory.createScanner(false, false, false, null, JavaScriptCore.VERSION_1_5);
			scanner.setSource(line.toCharArray());
			scanner.resetTo(offset - lineInfo.getOffset(), lineInfo.getLength());
			int token = scanner.getNextToken();
			while (token != ITerminalSymbols.TokenNameEOF) {
				if (token == ITerminalSymbols.TokenNameIdentifier) {
					int methodStart = scanner.getCurrentTokenStartPosition();
					token = scanner.getNextToken();
					if (token == ITerminalSymbols.TokenNameLPAREN) {
						return resolveFunction(lineInfo.getOffset() + methodStart, 0, (ICodeAssist)element);
					}
				} 
				else {
					token = scanner.getNextToken();
				}
			}
		} 
		catch (BadLocationException e) {
			return null;
		} 
		catch (InvalidInputException e) {
			return null;
		}
		return null;
	}

}




###############################################################################
# Copyright (c) 201o IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################
cannot_find_debug_target=Unable to locate debug target
cursor_position_not_valid=Cursor position is not a valid location to run to
empty_editor=Empty editor
exception_running_to_line=An exception occurred attempting to run to the selected line.
exe_did_not_enter__0__before_returning=Execution did not enter "{0}" before the current function returned.
hyperlink_step_into=Step Into
missing_doc=Missing document
only_in_the_js_editor=Step into selection only available in JavaScript editor.
selected_line_not_valid=Selected line is not a valid location to run to
step_into_only_top_frame=Step into selection only available in top stack frame.
step_into_selection=Step into selection

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/launching/JavaScriptConnectTab.java (-6 / +74 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.	2	* Copyright (c) 2010, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-15 Link Here
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.debug.internal.ui.launching;	11	package org.eclipse.wst.jsdt.debug.internal.ui.launching;
12		12
		13	import java.util.ArrayList;
		14	import java.util.Collections;
		15	import java.util.Comparator;
13	import java.util.HashMap;	16	import java.util.HashMap;
14	import java.util.Iterator;	17	import java.util.Iterator;
15	import java.util.List;	18	import java.util.List;
Lines 62-80 Link Here
62	*/	65	*/
63	public class JavaScriptConnectTab extends AbstractLaunchConfigurationTab implements IPropertyChangeListener {	66	public class JavaScriptConnectTab extends AbstractLaunchConfigurationTab implements IPropertyChangeListener {
64		67
		68	class ArgComparator implements Comparator {
		69	/* (non-Javadoc)
		70	* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
		71	*/
		72	public int compare(Object o1, Object o2) {
		73	if(o1 instanceof Entry && o2 instanceof Entry) {
		74	//String > Integer > List > Boolean
		75	//sort by kind and by label
		76	Object val1 = ((Entry)o1).getValue();
		77	Object val2 = ((Entry)o2).getValue();
		78	if(val1 instanceof StringArgument) {
		79	if(val2 instanceof StringArgument) {
		80	return stripAccel(((Argument)val1).label()).compareTo(stripAccel(((Argument)val2).label()));
		81	}
		82	return -1;
		83	}
		84	else if(val1 instanceof IntegerArgument) {
		85	if(val2 instanceof IntegerArgument) {
		86	return stripAccel(((Argument)val1).label()).compareTo(stripAccel(((Argument)val2).label()));
		87	}
		88	else if(val2 instanceof StringArgument) {
		89	return 1;
		90	}
		91	return -1;
		92	}
		93	else if(val1 instanceof SelectedArgument) {
		94	if(val2 instanceof SelectedArgument) {
		95	return stripAccel(((Argument)val1).label()).compareTo(stripAccel(((Argument)val2).label()));
		96	}
		97	else if(val2 instanceof StringArgument \|\| val2 instanceof IntegerArgument) {
		98	return 1;
		99	}
		100	return -1;
		101	}
		102	else if(val1 instanceof BooleanArgument) {
		103	if(val2 instanceof BooleanArgument) {
		104	return stripAccel(((Argument)val1).label()).compareTo(stripAccel(((Argument)val2).label()));
		105	}
		106	else if(val2 instanceof StringArgument \|\| val2 instanceof IntegerArgument \|\| val2 instanceof SelectedArgument) {
		107	return 1;
		108	}
		109	return -1;
		110	}
		111	}
		112	return o1.equals(o2) ? 0 : -1;
		113	}
		114
		115	String stripAccel(String text) {
		116	return text.replaceAll("\\&", ""); //$NON-NLS-1$ //$NON-NLS-2$
		117	}
		118	}
		119
65	Text description = null;	120	Text description = null;
66	Combo connectorcombo = null;	121	Combo connectorcombo = null;
67	Connector selectedconnector = null;	122	Connector selectedconnector = null;
68	Group argumentsgroup = null;	123	Group argumentsgroup = null;
69	HashMap editormap = new HashMap();	124	HashMap editormap = new HashMap();
		125	Comparator comparator = new ArgComparator();
70		126
71	/* (non-Javadoc)	127	/* (non-Javadoc)
72	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)	128	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)
73	*/	129	*/
74	public void createControl(Composite parent) {	130	public void createControl(Composite parent) {
75	Composite comp = SWTFactory.createComposite(parent, 2, 1, GridData.FILL_HORIZONTAL);	131	Composite comp = SWTFactory.createComposite(parent, 1, 1, GridData.FILL_HORIZONTAL);
76	//connectors combo	132	//connectors combo
77	Group group = SWTFactory.createGroup(comp, Messages.connector, 1, 2, GridData.FILL_HORIZONTAL);	133	Group group = SWTFactory.createGroup(comp, Messages.connector, 1, 1, GridData.FILL_HORIZONTAL);
78	this.connectorcombo = SWTFactory.createCombo(group, SWT.FLAT \| SWT.BORDER \| SWT.READ_ONLY, 1, null);	134	this.connectorcombo = SWTFactory.createCombo(group, SWT.FLAT \| SWT.BORDER \| SWT.READ_ONLY, 1, null);
79	GridData gd = (GridData) this.connectorcombo.getLayoutData();	135	GridData gd = (GridData) this.connectorcombo.getLayoutData();
80	gd.grabExcessHorizontalSpace = true;	136	gd.grabExcessHorizontalSpace = true;
Lines 86-91 Link Here
86	this.description = SWTFactory.createText(group, SWT.WRAP \| SWT.READ_ONLY, 1);	142	this.description = SWTFactory.createText(group, SWT.WRAP \| SWT.READ_ONLY, 1);
87	gd = (GridData) this.description.getLayoutData();	143	gd = (GridData) this.description.getLayoutData();
88	gd.heightHint = 30;	144	gd.heightHint = 30;
		145	//hack to make sure the disabled colour is propagated on *Nix's
		146	this.description.setBackground(group.getBackground());
89	List connectors = JavaScriptDebugPlugin.getConnectionsManager().getConnectors();	147	List connectors = JavaScriptDebugPlugin.getConnectionsManager().getConnectors();
90	Connector connector = null;	148	Connector connector = null;
91	for (int i = 0; i < connectors.size(); i++) {	149	for (int i = 0; i < connectors.size(); i++) {
Lines 94-105 Link Here
94	this.connectorcombo.setData(connector.name(), connector);	152	this.connectorcombo.setData(connector.name(), connector);
95	}	153	}
96		154
97	this.argumentsgroup = SWTFactory.createGroup(comp, Messages.connector_properties, 2, 2, GridData.FILL_HORIZONTAL);	155	this.argumentsgroup = SWTFactory.createGroup(comp, Messages.connector_properties, 2, 1, GridData.FILL_HORIZONTAL);
98	this.argumentsgroup.setVisible(false);	156	this.argumentsgroup.setVisible(false);
99	setControl(comp);
100	PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IHelpContextIds.CONNECT_TAB);	157	PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IHelpContextIds.CONNECT_TAB);
		158	setControl(comp);
101	}	159	}
102		160
		161	/* (non-Javadoc)
		162	* @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#getHelpContextId()
		163	*/
		164	public String getHelpContextId() {
		165	return IHelpContextIds.CONNECT_TAB;
		166	};
		167
103	/**	168	/**
104	* Returns the {@link Connector} based on the selection of the combo	169	* Returns the {@link Connector} based on the selection of the combo
105	* @return the selected combo	170	* @return the selected combo
Lines 142-148 Link Here
142	Argument argument = null;	207	Argument argument = null;
143	FieldEditor editor = null;	208	FieldEditor editor = null;
144	String key = null;	209	String key = null;
145	for (Iterator iter = this.selectedconnector.defaultArguments().entrySet().iterator(); iter.hasNext();) {	210	ArrayList entries = new ArrayList(this.selectedconnector.defaultArguments().entrySet());
		211	Collections.sort(entries, comparator);
		212	for (Iterator iter = entries.iterator(); iter.hasNext();) {
146	entry = (Entry) iter.next();	213	entry = (Entry) iter.next();
147	key = (String) entry.getKey();	214	key = (String) entry.getKey();
148	argument = (Argument) entry.getValue();	215	argument = (Argument) entry.getValue();
Lines 188-193 Link Here
188	GridLayout gd = (GridLayout) this.argumentsgroup.getLayout();	255	GridLayout gd = (GridLayout) this.argumentsgroup.getLayout();
189	gd.marginHeight = 5;	256	gd.marginHeight = 5;
190	gd.marginWidth = 5;	257	gd.marginWidth = 5;
		258	gd.numColumns = 2;
191	this.argumentsgroup.getParent().layout(true);	259	this.argumentsgroup.getParent().layout(true);
192	this.argumentsgroup.setVisible(true);	260	this.argumentsgroup.setVisible(true);
193	this.argumentsgroup.layout(true);	261	this.argumentsgroup.layout(true);




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.launching;

import java.util.Arrays;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.ILaunchGroup;
import org.eclipse.debug.ui.ILaunchShortcut2;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.debug.internal.core.Constants;

/**
 * Default reusable launch shortcut for JavaScript debug consumers
 * @since 1.0
 */
public class JavaScriptLaunchShortcut implements ILaunchShortcut2 {

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.jface.viewers.ISelection)
	 */
	public ILaunchConfiguration[] getLaunchConfigurations(ISelection selection) {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.ui.IEditorPart)
	 */
	public ILaunchConfiguration[] getLaunchConfigurations(IEditorPart editorpart) {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.jface.viewers.ISelection)
	 */
	public IResource getLaunchableResource(ISelection selection) {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.ui.IEditorPart)
	 */
	public IResource getLaunchableResource(IEditorPart editorpart) {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.jface.viewers.ISelection, java.lang.String)
	 */
	public void launch(ISelection selection, String mode) {
		openLaunchDialogOnSelection();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.ui.IEditorPart, java.lang.String)
	 */
	public void launch(IEditorPart editor, String mode) {
		openLaunchDialogOnSelection();
	}

	/**
	 * Default behavior to open the launch configuration dialog on the {@link ILaunchConfigurationType}
	 * for JavaScript
	 */
	void openLaunchDialogOnSelection() {
		DebugUITools.openLaunchConfigurationDialogOnGroup(
				PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), 
				new StructuredSelection(getSelection()), 
				IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP);
	}
	
	/**
	 * Returns the type of the default launch configuration
	 * @return the default item to select when opening the dialog
	 */
	Object getSelection() {
		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
		ILaunchConfigurationType type = manager.getLaunchConfigurationType(Constants.LAUNCH_CONFIG_ID);
		if(type != null) {
			try {
				ILaunchConfiguration[] configs = manager.getLaunchConfigurations(type);
				if(configs != null && configs.length > 0) {
					LaunchConfigurationManager cmanager = DebugUIPlugin.getDefault().getLaunchConfigurationManager();
					ILaunchGroup group = cmanager.getLaunchGroup(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP);
					if(group != null) {
						ILaunchConfiguration config = cmanager.getMRUConfiguration(
								Arrays.asList(configs), 
								group, 
								null);
						if(config != null) {
							return config;
						}
					}
				}
			}
			catch (CoreException ce) {
				//do nothing, just return type
			}
			return type;
		}
		return null;
	}
	
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/launching/JavascriptTabGroup.java (-5 / +12 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.	2	* Copyright (c) 2010, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 16-24 Link Here
16	import org.eclipse.debug.ui.ILaunchConfigurationDialog;	16	import org.eclipse.debug.ui.ILaunchConfigurationDialog;
17	import org.eclipse.debug.ui.ILaunchConfigurationTab;	17	import org.eclipse.debug.ui.ILaunchConfigurationTab;
18	import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;	18	import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
		19	import org.eclipse.wst.jsdt.debug.internal.ui.IHelpContextIds;
19		20
20	/**	21	/**
21	* Default tab group for Javascript debugging	22	* Default tab group for JavaScript debugging
22	*	23	*
23	* @since 1.0	24	* @since 1.0
24	*/	25	*/
Lines 28-38 Link Here
28	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#createTabs(org.eclipse.debug.ui.ILaunchConfigurationDialog, java.lang.String)	29	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#createTabs(org.eclipse.debug.ui.ILaunchConfigurationDialog, java.lang.String)
29	*/	30	*/
30	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {	31	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
		32	SourceLookupTab slt = new SourceLookupTab();
		33	slt.setHelpContextId(IHelpContextIds.SOURCE_LOOKUP_TAB);
		34	EnvironmentTab et = new EnvironmentTab();
		35	et.setHelpContextId(IHelpContextIds.ENVIRONMENT_TAB);
		36	CommonTab ct = new CommonTab();
		37	ct.setHelpContextId(IHelpContextIds.COMMON_TAB);
31	ILaunchConfigurationTab[] tabs = new ILaunchConfigurationTab[] {	38	ILaunchConfigurationTab[] tabs = new ILaunchConfigurationTab[] {
32	new JavaScriptConnectTab(),	39	new JavaScriptConnectTab(),
33	new SourceLookupTab(),	40	slt,
34	new EnvironmentTab(),	41	et,
35	new CommonTab()	42	ct
36	};	43	};
37	setTabs(tabs);	44	setTabs(tabs);
38	}	45	}

Lines 22-35 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/messages.properties (+16 lines)
22	connector=Connector	22	connector=Connector
23	connector_properties=Connector Properties	23	connector_properties=Connector Properties
24	creating_script_load_bp=Creating Script Load Breakpoint...	24	creating_script_load_bp=Creating Script Load Breakpoint...
		25	disconnected=<disconnected>
25	enable_hit_count=Enable &Hit Count	26	enable_hit_count=Enable &Hit Count
26	enter_new_hit_count=&Enter the new hit count for the breakpoint:	27	enter_new_hit_count=&Enter the new hit count for the breakpoint:
		28	evald_script=<evaluated script>
27	exception_occurred_setting_bp_properties=Exceptions occurred attempting to modify breakpoint.	29	exception_occurred_setting_bp_properties=Exceptions occurred attempting to modify breakpoint.
28	hit_count_must_be_positive=Hit count must be a positive integer	30	hit_count_must_be_positive=Hit count must be a positive integer
29	no_description_provided=No description provided.	31	no_description_provided=No description provided.
		32	opening_source__0=Opening Source: {0}
		33	running_state=running
30	scripts=Scripts	34	scripts=Scripts
31	select_javascript_file=Select a JavaScript script file	35	select_javascript_file=Select a JavaScript script file
32	set_bp_hit_count=Set Breakpoint Hit Count	36	set_bp_hit_count=Set Breakpoint Hit Count
		37	stackframe_name={0} - line: {1}
		38	stepping_state=stepping
		39	suspend_loading_script=suspended loading script: {0}
33	suspend_target=&Suspend Target	40	suspend_target=&Suspend Target
34	suspend_thread=&Suspend Thread	41	suspend_thread=&Suspend Thread
		42	suspended_on_exception=suspended on exception: {0}
		43	suspended_on_func_breakpoint=suspended at breakpoint on function {0} in {1}
		44	suspended_on_line_breakpoint=suspended at breakpoint on line {0} in {1}
		45	suspended_state=suspended
		46	terminated=<terminated>
		47	terminated_state=terminated
35	the_argument_0_is_not_valid=The specified argument: {0} is not valid	48	the_argument_0_is_not_valid=The specified argument: {0} is not valid
		49	thread_name=Thread [{0}] ({1})
		50	unknown=<unknown>
		51	unknown_state=<unknown state>




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.preferences;

import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditor;
import org.eclipse.jface.preference.FieldEditorPreferencePage;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.jsdt.debug.internal.core.Constants;
import org.eclipse.wst.jsdt.debug.internal.ui.IHelpContextIds;
import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
import org.eclipse.wst.jsdt.debug.internal.ui.SWTFactory;

/**
 * Default preference page for JavaScript debugging
 * @since 1.1
 */
public class JavaScriptDebugPreferencePage extends FieldEditorPreferencePage implements IWorkbenchPreferencePage {

	public static final String PAGE_ID = "org.eclipse.wst.jsdt.debug.ui.debug.page"; //$NON-NLS-1$
	
	/**
	 * Constructor
	 */
	public JavaScriptDebugPreferencePage() {
		super(GRID);
		setPreferenceStore(JavaScriptDebugUIPlugin.getDefault().getPreferenceStore());
		setDescription(Messages.js_debug_pref_page_desc);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
	 */
	public void init(IWorkbench workbench) {}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		super.createControl(parent);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, IHelpContextIds.DEBUG_PREFERENCE_PAGE);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite comp = SWTFactory.createComposite(parent, parent.getFont(), 1, 1, GridData.FILL_HORIZONTAL, 0, 0);
		//General
		Group group = SWTFactory.createGroup(comp, Messages.general, 1, 1, GridData.FILL_HORIZONTAL);
		BooleanFieldEditor editor = new BooleanFieldEditor(Constants.DELETE_EXT_PROJECT_ON_EXIT, Messages.delete_ext_project_on_exit, group);
		initEditor(editor, JavaScriptDebugUIPlugin.getCorePreferenceStore());
		initGroup(group);
		//Suspend Execution
		group = SWTFactory.createGroup(comp, Messages.suspend_execution, 1, 1, GridData.FILL_HORIZONTAL);
		editor = new BooleanFieldEditor(Constants.SUSPEND_ON_ALL_SCRIPT_LOADS, Messages.suspend_for_all_script_loads, group);
		initEditor(editor, JavaScriptDebugUIPlugin.getCorePreferenceStore());
		editor = new BooleanFieldEditor(Constants.SUSPEND_ON_THROWN_EXCEPTION, Messages.suspend_on_exceptions, group);
		initEditor(editor, JavaScriptDebugUIPlugin.getCorePreferenceStore());
		initGroup(group);
		return comp;
	}

	/**
	 * Refreshes the specified group to re-set the default spacings that have been 
	 * trashed by the field editors
	 * 
	 * @param group
	 */
	void initGroup(Group group) {
		GridData gd = (GridData) group.getLayoutData();
		gd.grabExcessHorizontalSpace = true;
		GridLayout lo = (GridLayout) group.getLayout();
		lo.marginWidth = 5;
		lo.marginHeight = 5;
	}
	
	/**
	 * Initializes and sets up the given editor
	 * 
	 * @param editor
	 * @param store
	 */
	void initEditor(FieldEditor editor, IPreferenceStore store) {
		addField(editor);
		editor.setPage(this);
		editor.setPropertyChangeListener(this);
		editor.setPreferenceStore(store);
		editor.load();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.FieldEditorPreferencePage#createFieldEditors()
	 */
	protected void createFieldEditors() {}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.debug.internal.ui.preferences;

import org.eclipse.osgi.util.NLS;

/**
 *
 */
public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.wst.jsdt.debug.internal.ui.preferences.messages"; //$NON-NLS-1$
	public static String delete_ext_project_on_exit;
	public static String general;
	public static String js_debug_pref_page_desc;
	public static String suspend_execution;
	public static String suspend_for_all_script_loads;
	public static String suspend_on_exceptions;
	static {
		// initialize resource bundle
		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
	}

	private Messages() {
	}
}




general=General
###############################################################################
# Copyright (c) 2010 IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################
delete_ext_project_on_exit=Delete the 'E&xternal JavaScript Source' project on workbench shutdown
js_debug_pref_page_desc=General settings for JavaScript debugging
suspend_execution=Suspend Execution
suspend_for_all_script_loads=Suspend for all script &loads
suspend_on_exceptions=Suspend on JavaScript e&xceptions

Return to bug 353225

Lines 42-44 Link Here

(-)OSGI-INF/l10n/bundle.properties (+17 lines)
42	openSourceObjectAction.tooltip = Shows the JavaScript source for the selected script element	42	openSourceObjectAction.tooltip = Shows the JavaScript source for the selected script element
43	commandCategory.description = Tooling for debugging JavaScript	43	commandCategory.description = Tooling for debugging JavaScript
44	commandCategory.name = JavaScript Debug	44	commandCategory.name = JavaScript Debug
		45
		46	showFunctionVarAction.label = Show function variables
		47	showFunctionVarAction.tooltip = Show or hide function variables
		48	showThisVarAction.label = Show 'this' variable
		49	showThisVarAction.tooltip = Show or hide the this variable
		50	showProtoVarAction.label = Show proto variables
		51	showProtoVarAction.tooltip = Show or hide proto variables
		52
		53	evaluateAction.label = E&valuate
		54	evaluateCommand.label = Evaluate
		55	evaluateAction.description = Evaluates the selected text in the JavaScript editor
		56	hyperlinkDetector.description = Allows for quickly stepping into functions in JavaScript source using hyper-links
		57	hyperlinkDetector.name = Step Into Selection
		58	debugPrefPage.name = Debug
		59	debugPrefPageKeyword.label = debug,jsdt,javascript,wst,breakpoint,launch,suspend,scripts
		60	hover.description = Shows the value of the selected variable while debugging
		61	hover.label = JavaScript Variable Hover

Lines 1-3 Link Here

(-)build.properties (+10 lines)
		1	###############################################################################
		2	# Copyright (c) 2010, 2011 IBM Corporation 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	# IBM Corporation - initial API and implementation
		10	###############################################################################
1	source.. = src/	11	source.. = src/
2	output.. = bin/	12	output.. = bin/
3	bin.includes = META-INF/,\	13	bin.includes = META-INF/,\

Added Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/Constants.java (+38 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008, 2010 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.debug.internal.ui;
12
13	/**
14	* Constants for the {@link JavaScriptDebugUIPlugin}
15	*
16	* @since 1.1
17	*/
18	public interface Constants {
19
20	/**
21	* Constant for the preference for showing / hiding functions from the variables view
22	* <br><br>
23	* Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_functions</code>
24	*/
25	public static final String SHOW_FUNCTIONS = JavaScriptDebugUIPlugin.PLUGIN_ID + ".show_functions"; //$NON-NLS-1$
26	/**
27	* Constant for the preference for showing / hiding prototypes from the variables view
28	* <br><br>
29	* Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_protoypes</code>
30	*/
31	public static final String SHOW_PROTOTYPES = JavaScriptDebugUIPlugin.PLUGIN_ID + ".show_prototypes"; //$NON-NLS-1$
32	/**
33	* Constant for the preference for showing / hiding the <code>this</code> variable from the variables view
34	* <br><br>
35	* Value is: <code>org.eclipse.wst.jsdt.debug.ui.show_this</code>
36	*/
37	public static final String SHOW_THIS = JavaScriptDebugUIPlugin.PLUGIN_ID + "show_this"; //$NON-NLS-1$
38	}

Lines 17-35 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/actions/OpenSourceAction.java (-3 / +18 lines)
17	import org.eclipse.core.commands.IHandler2;	17	import org.eclipse.core.commands.IHandler2;
18	import org.eclipse.core.commands.IHandlerListener;	18	import org.eclipse.core.commands.IHandlerListener;
19	import org.eclipse.core.expressions.EvaluationContext;	19	import org.eclipse.core.expressions.EvaluationContext;
		20	import org.eclipse.core.runtime.IProgressMonitor;
		21	import org.eclipse.core.runtime.IStatus;
		22	import org.eclipse.core.runtime.Status;
		23	import org.eclipse.core.runtime.jobs.Job;
20	import org.eclipse.debug.ui.DebugUITools;	24	import org.eclipse.debug.ui.DebugUITools;
21	import org.eclipse.debug.ui.sourcelookup.ISourceLookupResult;	25	import org.eclipse.debug.ui.sourcelookup.ISourceLookupResult;
22	import org.eclipse.jface.action.IAction;	26	import org.eclipse.jface.action.IAction;
23	import org.eclipse.jface.viewers.ISelection;	27	import org.eclipse.jface.viewers.ISelection;
24	import org.eclipse.jface.viewers.IStructuredSelection;	28	import org.eclipse.jface.viewers.IStructuredSelection;
		29	import org.eclipse.osgi.util.NLS;
25	import org.eclipse.swt.widgets.Event;	30	import org.eclipse.swt.widgets.Event;
26	import org.eclipse.ui.IActionDelegate2;	31	import org.eclipse.ui.IActionDelegate2;
27	import org.eclipse.ui.IObjectActionDelegate;	32	import org.eclipse.ui.IObjectActionDelegate;
28	import org.eclipse.ui.IWorkbenchPage;	33	import org.eclipse.ui.IWorkbenchPage;
29	import org.eclipse.ui.IWorkbenchPart;	34	import org.eclipse.ui.IWorkbenchPart;
30	import org.eclipse.ui.PlatformUI;	35	import org.eclipse.ui.PlatformUI;
		36	import org.eclipse.ui.progress.UIJob;
31	import org.eclipse.wst.jsdt.debug.core.model.IScript;	37	import org.eclipse.wst.jsdt.debug.core.model.IScript;
32	import org.eclipse.wst.jsdt.debug.internal.core.model.Script;	38	import org.eclipse.wst.jsdt.debug.internal.core.model.Script;
		39	import org.eclipse.wst.jsdt.debug.internal.ui.Messages;
33		40
34	/**	41	/**
35	* Context menu action to show the source for a selected {@link IScript}	42	* Context menu action to show the source for a selected {@link IScript}
Lines 50-58 Link Here
50	*/	57	*/
51	public void run(IAction action) {	58	public void run(IAction action) {
52	if(script != null) {	59	if(script != null) {
53	IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();	60	UIJob job = new UIJob(PlatformUI.getWorkbench().getDisplay(), NLS.bind(Messages.opening_source__0, script.sourceURI())) {
54	ISourceLookupResult result = DebugUITools.lookupSource(script, script.getDebugTarget().getLaunch().getSourceLocator());	61	public IStatus runInUIThread(IProgressMonitor monitor) {
55	DebugUITools.displaySource(result, page);	62	IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		63	ISourceLookupResult result = DebugUITools.lookupSource(script, script.getDebugTarget().getLaunch().getSourceLocator());
		64	DebugUITools.displaySource(result, page);
		65	return Status.OK_STATUS;
		66	}
		67	};
		68	job.setPriority(Job.INTERACTIVE);
		69	job.setUser(true);
		70	job.schedule();
56	}	71	}
57	}	72	}
58		73

Lines 107-114 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/actions/ViewFilterAction.java (-10 / +2 lines)
107	viewer.refresh();	107	viewer.refresh();
108	}	108	}
109	IPreferenceStore store = getPreferenceStore();	109	IPreferenceStore store = getPreferenceStore();
110	String key = getView().getSite().getId() + "." + getPreferenceKey(); //$NON-NLS-1$	110	store.setValue(getPreferenceKey(), action.isChecked());
111	store.setValue(key, action.isChecked());
112	}	111	}
113		112
114	/* (non-Javadoc)	113	/* (non-Javadoc)
Lines 132-146 Link Here
132	* @return boolean	131	* @return boolean
133	*/	132	*/
134	protected boolean getPreferenceValue() {	133	protected boolean getPreferenceValue() {
135	String key = getCompositeKey();
136	IPreferenceStore store = getPreferenceStore();	134	IPreferenceStore store = getPreferenceStore();
137	boolean value = false;	135	return store.getBoolean(getPreferenceKey());
138	if (store.contains(key)) {
139	value = store.getBoolean(key);
140	} else {
141	value = store.getBoolean(getPreferenceKey());
142	}
143	return value;
144	}	136	}
145		137
146	/**	138	/**

Lines 14-19 Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/adapters/JavaScriptAdapterFactory.java (-1 / +18 lines)
14	import org.eclipse.core.runtime.IAdapterFactory;	14	import org.eclipse.core.runtime.IAdapterFactory;
15	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;	15	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
16	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxyFactory2;	16	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxyFactory2;
		17	import org.eclipse.debug.ui.actions.IRunToLineTarget;
17	import org.eclipse.debug.ui.actions.IToggleBreakpointsTarget;	18	import org.eclipse.debug.ui.actions.IToggleBreakpointsTarget;
18	import org.eclipse.jface.resource.ImageDescriptor;	19	import org.eclipse.jface.resource.ImageDescriptor;
19	import org.eclipse.ui.model.IWorkbenchAdapter;	20	import org.eclipse.ui.model.IWorkbenchAdapter;
Lines 22-27 Link Here
22	import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;	23	import org.eclipse.wst.jsdt.debug.core.model.IScriptGroup;
23	import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;	24	import org.eclipse.wst.jsdt.debug.internal.ui.JavaScriptDebugUIPlugin;
24	import org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleBreakpointAdapter;	25	import org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleBreakpointAdapter;
		26	import org.eclipse.wst.jsdt.debug.internal.ui.eval.RunToLineAdapter;
25		27
26	/**	28	/**
27	* Adapter factory	29	* Adapter factory
Lines 73-78 Link Here
73	static ToggleBreakpointAdapter tbadapter = null;	75	static ToggleBreakpointAdapter tbadapter = null;
74	static JavaScriptAsyncContentProvider jscontent = null;	76	static JavaScriptAsyncContentProvider jscontent = null;
75	static JavaScriptModelProxyFactory jsproxyfactory = null;	77	static JavaScriptModelProxyFactory jsproxyfactory = null;
		78	static RunToLineAdapter runtoline = null;
76		79
77	/*	80	/*
78	* (non-Javadoc)	81	* (non-Javadoc)
Lines 86-91 Link Here
86	if(adapterType.equals(IWorkbenchAdapter.class) && adaptableObject instanceof IJavaScriptBreakpoint) {	89	if(adapterType.equals(IWorkbenchAdapter.class) && adaptableObject instanceof IJavaScriptBreakpoint) {
87	return getWorkbenchAdapter();	90	return getWorkbenchAdapter();
88	}	91	}
		92	if(adapterType.equals(IRunToLineTarget.class)) {
		93	return getRunToLine();
		94	}
89	if (adapterType.equals(IElementContentProvider.class)) {	95	if (adapterType.equals(IElementContentProvider.class)) {
90	if (adaptableObject instanceof IJavaScriptDebugTarget \|\|	96	if (adaptableObject instanceof IJavaScriptDebugTarget \|\|
91	adaptableObject instanceof IScriptGroup) {	97	adaptableObject instanceof IScriptGroup) {
Lines 105-116 Link Here
105	*/	111	*/
106	public Class[] getAdapterList() {	112	public Class[] getAdapterList() {
107	return new Class[] {IToggleBreakpointsTarget.class,	113	return new Class[] {IToggleBreakpointsTarget.class,
108	IWorkbenchAdapter.class,	114	IWorkbenchAdapter.class,
		115	IRunToLineTarget.class,
109	IElementContentProvider.class,	116	IElementContentProvider.class,
110	IModelProxyFactory2.class};	117	IModelProxyFactory2.class};
111	}	118	}
112		119
113	/**	120	/**
		121	* @return the singleton {@link RunToLineAdapter}
		122	*/
		123	synchronized RunToLineAdapter getRunToLine() {
		124	if(runtoline == null) {
		125	runtoline = new RunToLineAdapter();
		126	}
		127	return runtoline;
		128	}
		129
		130	/**
114	* @return the singleton {@link JavaScriptModelProxyFactory}	131	* @return the singleton {@link JavaScriptModelProxyFactory}
115	*/	132	*/
116	synchronized JavaScriptModelProxyFactory getJSProxyFactory() {	133	synchronized JavaScriptModelProxyFactory getJSProxyFactory() {

Added Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/eval/messages.properties (+21 lines)
1	###############################################################################
2	# Copyright (c) 201o IBM Corporation 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	# IBM Corporation - initial API and implementation
10	###############################################################################
11	cannot_find_debug_target=Unable to locate debug target
12	cursor_position_not_valid=Cursor position is not a valid location to run to
13	empty_editor=Empty editor
14	exception_running_to_line=An exception occurred attempting to run to the selected line.
15	exe_did_not_enter__0__before_returning=Execution did not enter "{0}" before the current function returned.
16	hyperlink_step_into=Step Into
17	missing_doc=Missing document
18	only_in_the_js_editor=Step into selection only available in JavaScript editor.
19	selected_line_not_valid=Selected line is not a valid location to run to
20	step_into_only_top_frame=Step into selection only available in top stack frame.
21	step_into_selection=Step into selection

Added Link Here

(-)src/org/eclipse/wst/jsdt/debug/internal/ui/preferences/messages.properties (+16 lines)
1	general=General
2	###############################################################################
3	# Copyright (c) 2010 IBM Corporation and others.
4	# All rights reserved. This program and the accompanying materials
5	# are made available under the terms of the Eclipse Public License v1.0
6	# which accompanies this distribution, and is available at
7	# http://www.eclipse.org/legal/epl-v10.html
8	#
9	# Contributors:
10	# IBM Corporation - initial API and implementation
11	###############################################################################
12	delete_ext_project_on_exit=Delete the 'E&xternal JavaScript Source' project on workbench shutdown
13	js_debug_pref_page_desc=General settings for JavaScript debugging
14	suspend_execution=Suspend Execution
15	suspend_for_all_script_loads=Suspend for all script &loads
16	suspend_on_exceptions=Suspend on JavaScript e&xceptions