| /******************************************************************************* |
| * Copyright (c) 2010, 2016 Ericsson 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: |
| * Ericsson - Initial API and implementation |
| * Dmitry Kozlov (Mentor Graphics) - Trace control view enhancements (Bug 390827) |
| *******************************************************************************/ |
| package org.eclipse.cdt.dsf.gdb.internal.ui.tracepoints; |
| |
| import java.text.DateFormat; |
| import java.util.Date; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin; |
| import org.eclipse.cdt.dsf.gdb.internal.ui.GdbUIPlugin; |
| import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl.ITraceStatusDMData2; |
| import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl.STOP_REASON_ENUM; |
| 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.jface.action.Action; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.SWTException; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.FontData; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Slider; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.ui.handlers.IHandlerService; |
| import org.eclipse.ui.part.ViewPart; |
| import org.eclipse.ui.progress.UIJob; |
| |
| /** |
| * TraceControlView Part |
| * |
| * This view is used to control Tracing. |
| * |
| * @since 2.1 |
| */ |
| public class TraceControlView extends ViewPart implements IViewPart { |
| |
| private static final int ACTION_BUTTON_INDENTATION = 10; |
| private static final String EMPTY_STRING = ""; //$NON-NLS-1$ |
| protected static final int UI_REFRESH_DELAY = 1000; // milliseconds |
| |
| public static class FailedTraceVariableCreationException extends Exception { |
| private static final long serialVersionUID = -3042693455630687285L; |
| |
| FailedTraceVariableCreationException() {} |
| |
| FailedTraceVariableCreationException(String errorMessage) { |
| super(errorMessage); |
| } |
| } |
| |
| /** |
| * Action to refresh the content of the view. |
| */ |
| private final class RefreshViewAction extends Action { |
| public RefreshViewAction() { |
| setText(TracepointsMessages.TraceControlView_action_Refresh_label); |
| setImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Refresh_enabled)); |
| setDisabledImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Refresh_disabled)); |
| } |
| @Override |
| public void run() { |
| fLastRefreshTime = System.currentTimeMillis(); |
| fTraceControlModel.updateContent(); |
| } |
| } |
| |
| /** |
| * Action to automatically refresh the content of the view by polling trace-status. |
| */ |
| protected final class AutoRefreshAction extends Action { |
| public AutoRefreshAction() { |
| super(TracepointsMessages.TraceControlView_auto_refresh_action_label, AS_CHECK_BOX); |
| setImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Refresh_Auto)); |
| } |
| @Override |
| public void run() { |
| if (isChecked()) { |
| // Call to updateContent which starts refreshUI job only if necessary |
| // (when tracing is running) |
| fAutoRefreshEnabled = true; |
| fRefreshViewAction.setEnabled(false); |
| fTraceControlModel.updateContent(); |
| } else { |
| fAutoRefreshEnabled = false; |
| fRefreshViewAction.setEnabled(true); |
| } |
| } |
| } |
| |
| /** |
| * Action to refresh the content of the view. |
| */ |
| protected final class DisconnectedTracingAction extends Action { |
| public DisconnectedTracingAction() { |
| super(TracepointsMessages.TraceControlView_action_Disconnected_tracing_label, AS_CHECK_BOX); |
| setImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Disconnected_Tracing)); |
| } |
| @Override |
| public void run() { |
| fTraceControlModel.setDisconnectedTracing(isChecked()); |
| } |
| } |
| |
| protected final class OpenTraceVarDetailsAction extends Action { |
| public OpenTraceVarDetailsAction() { |
| setText(TracepointsMessages.TraceControlView_action_trace_variable_details); |
| setImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Trace_Variables)); |
| } |
| @Override |
| public void run() { |
| Shell shell = Display.getDefault().getActiveShell(); |
| TraceVarDetailsDialog dialog = new TraceVarDetailsDialog(shell, TraceControlView.this); |
| dialog.open(); |
| } |
| } |
| |
| protected final class ExitVisualizationModeDetailsAction extends Action { |
| public ExitVisualizationModeDetailsAction() { |
| setText(TracepointsMessages.TraceControlView_action_exit_visualization_mode); |
| setImageDescriptor(TracepointImageRegistry.getImageDescriptor(TracepointImageRegistry.ICON_Exit_Visualization)); |
| } |
| @Override |
| public void run() { |
| fTraceControlModel.exitVisualizationMode(); |
| // Content of view will be updated from the event |
| // triggered by this asynchronous operation. |
| } |
| } |
| |
| protected TraceControlModel fTraceControlModel; |
| |
| protected RefreshViewAction fRefreshViewAction; |
| protected boolean fAutoRefreshEnabled; |
| protected DisconnectedTracingAction fDisconnectedTracingAction; |
| protected OpenTraceVarDetailsAction fOpenTraceVarDetails; |
| protected ExitVisualizationModeDetailsAction fExitVisualizationAction; |
| protected AutoRefreshAction fAutoRefreshAction; |
| protected boolean fTraceVisualization; |
| protected Job refreshUIJob; |
| protected Font cachedBold; |
| protected long fLastRefreshTime; |
| protected ITraceStatusDMData2 fLastTraceData; |
| |
| protected Composite fTopComposite; |
| protected Composite fStatusComposite; |
| protected Label fStatusLabel; |
| protected Label fSecondaryStatusLabel; |
| protected Composite fSecondaryStatusComposite; |
| protected FlatButton fActionButton; |
| |
| protected Composite fBufferComposite; |
| protected Label fBufferCollectedFramesLabel; |
| protected FlatRadioButton fSetCircularBufferButton; |
| protected CircularProgress fBufferProgress; |
| |
| protected Composite fFrameComposite; |
| protected Label fFrameLabel; |
| protected Label fFrameNumberLabel; |
| protected Slider fFrameSlider; |
| |
| protected Composite fNotesComposite; |
| protected Label fNotesContentLabel; |
| protected Text fNotesContentText; |
| protected Button fSetNotesButton; |
| |
| |
| public TraceControlView() { |
| } |
| |
| @Override |
| public void init(IViewSite site) throws PartInitException { |
| super.init(site); |
| fTraceControlModel = new TraceControlModel(this); |
| } |
| |
| @Override |
| public void init(IViewSite site, IMemento memento) throws PartInitException { |
| init(site); |
| } |
| |
| @Override |
| public void createPartControl(Composite parent) { |
| |
| createActions(); |
| |
| fTopComposite = new Composite(parent, SWT.NONE); |
| GridLayout topLayout = new GridLayout(1, false); |
| topLayout.marginWidth = 0; |
| topLayout.marginHeight = 0; |
| fTopComposite.setLayout(topLayout); |
| fTopComposite.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE)); |
| |
| // Tracing status line |
| createStatusLine(fTopComposite); |
| |
| // Secondary status: start time, stop time and reason |
| setSecondaryStatusLineVisible(false, null); |
| |
| // Buffer line |
| createBufferLine(fTopComposite); |
| setBufferLineVisible(false, null, false); |
| |
| // Frame line |
| createFrameLine(fTopComposite); |
| setFrameLineVisible(false, null); |
| |
| // Trace notes |
| //createNotesLine(fTopComposite); |
| //setNotesLineVisible(false, null, false); |
| |
| fTraceControlModel.init(); |
| } |
| |
| protected void createStatusLine(Composite parent) { |
| fStatusComposite = new Composite(parent, SWT.NONE); |
| GridData gd = new GridData(SWT.FILL, SWT.CENTER, true, false); |
| gd.horizontalSpan = 2; |
| gd.minimumHeight = 22; |
| fStatusComposite.setLayoutData(gd); |
| GridLayout l = new GridLayout(2,false); |
| l.marginBottom = 0; |
| fStatusComposite.setLayout(l); |
| fStatusComposite.setBackgroundMode(SWT.INHERIT_FORCE); |
| |
| fStatusLabel = new Label(fStatusComposite, SWT.NONE); |
| if (cachedBold == null) { |
| FontData fontData = fStatusLabel.getFont().getFontData()[0]; |
| fontData.setStyle(SWT.BOLD); |
| cachedBold = new Font(fStatusLabel.getDisplay(),fontData); |
| } |
| fStatusLabel.setFont(cachedBold); |
| GridData d = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| fStatusLabel.setLayoutData(d); |
| fStatusLabel.setText(TracepointsMessages.TraceControlView_trace_status_no_debug_session); |
| fStatusLabel.setBackground(parent.getBackground()); |
| |
| fActionButton = new FlatButton(fStatusComposite, SWT.NONE); |
| fActionButton.setText(EMPTY_STRING); |
| GridData acGd = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| acGd.horizontalIndent = ACTION_BUTTON_INDENTATION; |
| fActionButton.setLayoutData(acGd); |
| fActionButton.addSelectionListener(new SelectionAdapter() { |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| // Run action |
| IHandlerService handlerService = getSite().getService(IHandlerService.class); |
| if (handlerService == null) { |
| GdbUIPlugin.log(new Status(IStatus.ERROR, GdbUIPlugin.PLUGIN_ID, "Missing command handler service")); //$NON-NLS-1$ |
| return; |
| } |
| |
| try { |
| String text = ((FlatButton)e.getSource()).getText(); |
| if (TracepointsMessages.TraceControlView_action_start.equals(text) || |
| TracepointsMessages.TraceControlView_action_restart.equals(text)) { |
| handlerService.executeCommand("org.eclipse.cdt.debug.ui.command.startTracing", null); //$NON-NLS-1$ |
| } else if (TracepointsMessages.TraceControlView_action_stop.equals(text)) { |
| handlerService.executeCommand("org.eclipse.cdt.debug.ui.command.stopTracing", null); //$NON-NLS-1$ |
| } else if (TracepointsMessages.TraceControlView_action_finish_visualization.equals(text)) { |
| fTraceControlModel.exitVisualizationMode(); |
| } |
| // Note that the content of the view will be updated due to the event |
| // triggered by the above operations. There is no point in updating the |
| // content ourselves since some of the above calls are asynchronous |
| // and have not completed yet. |
| } catch (Exception ex) { |
| GdbUIPlugin.log(ex); |
| } |
| } |
| |
| }); |
| |
| fSecondaryStatusLabel = new Label(fStatusComposite, SWT.NONE | SWT.WRAP); |
| GridData sslGd = new GridData(SWT.FILL, SWT.TOP, true, false); |
| sslGd.horizontalSpan = 2; |
| fSecondaryStatusLabel.setLayoutData(sslGd); |
| fSecondaryStatusLabel.setBackground(parent.getBackground()); |
| |
| Label separator = new Label(fStatusComposite, SWT.SEPARATOR | SWT.HORIZONTAL); |
| GridData sGd = new GridData(SWT.FILL, SWT.BOTTOM, true, false); |
| //sGd.heightHint = 3; |
| sGd.horizontalSpan = 2; |
| separator.setLayoutData(sGd); |
| } |
| |
| protected void setActionLinkVisible(boolean visible, String text) { |
| fActionButton.setVisible(visible); |
| fActionButton.setText(visible ? text: EMPTY_STRING); |
| } |
| |
| private void setSecondaryStatusLineVisible(boolean visible, ITraceStatusDMData2 tData) { |
| fSecondaryStatusLabel.setVisible(visible); |
| ((GridData)fSecondaryStatusLabel.getLayoutData()).exclude = !visible; |
| |
| if (visible && tData != null) { |
| STOP_REASON_ENUM stopReason = tData.getStopReason(); |
| if (stopReason != null) { |
| fSecondaryStatusLabel.setText(getStopMessage(tData)); |
| } else if (tData.isTracingActive() && tData.getStartTime() != null) { |
| String user = EMPTY_STRING; |
| String lastRefreshed = EMPTY_STRING; |
| // In case autorefresh is disabled, show when view was manually refreshed last time |
| if (!fAutoRefreshEnabled) { |
| lastRefreshed = TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_trace_status_secondary_refresh_time, |
| formatTimeInterval(fLastRefreshTime, System.currentTimeMillis(), true)); |
| } |
| if (tData.getUserName() != null && tData.getUserName().length() > 0) { |
| user = TracepointsMessages.bind(TracepointsMessages.TraceControlView_trace_status_secondary_user, tData.getUserName()); |
| } |
| fSecondaryStatusLabel.setText(TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_trace_status_secondary_running, |
| new Object[] { |
| formatTime(tData.getStartTime()), |
| user, |
| lastRefreshed} |
| )); |
| } else { |
| // Should not happen if usage is correct |
| fSecondaryStatusLabel.setText(EMPTY_STRING); |
| } |
| } else { |
| fSecondaryStatusLabel.setText(EMPTY_STRING); |
| } |
| } |
| |
| protected void createNotesLine(final Composite parent) { |
| // Trace notes: notes text and edit notes button |
| fNotesComposite = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(3, false); |
| layout.marginWidth = 0; |
| layout.marginHeight = 0; |
| fNotesComposite.setLayout(layout); |
| fNotesComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); |
| fNotesComposite.setBackgroundMode(SWT.INHERIT_FORCE); |
| |
| // Separator on the left of whole notes composite |
| Label separator = new Label(fNotesComposite, SWT.SEPARATOR | SWT.VERTICAL); |
| GridData slGd = new GridData(SWT.RIGHT, SWT.FILL, false, true); |
| //slGd.widthHint = 3; |
| slGd.verticalSpan = 4; |
| separator.setLayoutData(slGd); |
| separator.setBackground(fNotesComposite.getBackground()); |
| |
| Label fNotesLabel = new Label(fNotesComposite, SWT.NONE); |
| fNotesLabel.setBackground(parent.getBackground()); |
| fNotesLabel.setText(TracepointsMessages.TraceControlView_trace_notes_label); |
| if (cachedBold != null) { |
| fNotesLabel.setFont(cachedBold); |
| } |
| |
| fSetNotesButton = new Button(fNotesComposite, SWT.TOGGLE); |
| fSetNotesButton.setImage(TracepointImageRegistry.getImageDescriptor( |
| TracepointImageRegistry.ICON_Edit_enabled).createImage()); |
| fSetNotesButton.setSelection(false); |
| fSetNotesButton.setToolTipText(TracepointsMessages.TraceControlView_trace_notes_edit_tooltip); |
| fSetNotesButton.setLayoutData(new GridData(SWT.END, SWT.TOP, false, false)); |
| fSetNotesButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| handleEditNotesButtonPressed(); |
| } |
| }); |
| |
| fNotesContentLabel = new Label(fNotesComposite, SWT.WRAP); |
| fNotesContentLabel.setBackground(parent.getBackground()); |
| fNotesContentLabel.setText(TracepointsMessages.TraceControlView_trace_notes_not_set); |
| GridData nclGd = new GridData(SWT.FILL, SWT.TOP, true, false); |
| nclGd.horizontalSpan = 2; |
| fNotesContentLabel.setLayoutData(nclGd); |
| |
| fNotesContentText = new Text(fNotesComposite, SWT.BORDER); |
| fNotesContentText.setVisible(false); |
| GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false); |
| gd.horizontalSpan = 2; |
| gd.exclude = true; |
| fNotesContentText.setLayoutData(gd); |
| fNotesContentText.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| fSetNotesButton.setSelection(false); |
| handleEditNotesButtonPressed(); |
| } |
| }); |
| fNotesContentText.addKeyListener(new KeyAdapter() { |
| |
| @Override |
| public void keyPressed(KeyEvent e) { |
| if (e.keyCode == 0x1b) { |
| // Esc was pressed, cancel editing |
| fSetNotesButton.setSelection(false); |
| handleEditNotesButtonPressed(true); |
| } |
| } |
| }); |
| |
| } |
| |
| protected void handleEditNotesButtonPressed() { |
| handleEditNotesButtonPressed(false); |
| } |
| |
| protected void handleEditNotesButtonPressed(boolean cancelEditing) { |
| boolean isEditMode = fSetNotesButton.getSelection(); |
| fNotesContentLabel.setVisible(!isEditMode); |
| ((GridData)fNotesContentLabel.getLayoutData()).exclude = isEditMode; |
| |
| fNotesContentText.setVisible(isEditMode); |
| ((GridData)fNotesContentText.getLayoutData()).exclude = !isEditMode; |
| |
| fNotesContentText.setFocus(); |
| |
| if (isEditMode) { |
| String txt = fNotesContentLabel.getText(); |
| txt = TracepointsMessages.TraceControlView_trace_notes_not_set.equals(txt) ? EMPTY_STRING : txt; |
| fNotesContentText.setText(txt); |
| fSetNotesButton.setToolTipText(TracepointsMessages.TraceControlView_trace_notes_save_tooltip); |
| } else { |
| fSetNotesButton.setToolTipText(TracepointsMessages.TraceControlView_trace_notes_edit_tooltip); |
| if (!cancelEditing) { |
| fNotesContentLabel.setText(fNotesContentText.getText()); |
| fNotesContentLabel.getSize(); |
| fTraceControlModel.setTraceNotes(fNotesContentText.getText()); |
| } |
| } |
| fNotesComposite.layout(); |
| fNotesComposite.redraw(); |
| fTraceControlModel.updateContent(); |
| } |
| |
| |
| protected void setNotesLineVisible(boolean visible, ITraceStatusDMData2 tData, boolean readonly) { |
| fNotesComposite.setVisible(visible); |
| ((GridData)fNotesComposite.getLayoutData()).exclude = !visible; |
| |
| if (visible) { |
| if (tData.getNotes() != null && tData.getNotes().length() > 0) { |
| fNotesContentLabel.setText(removeQuotes(tData.getNotes())); |
| } else { |
| fNotesContentLabel.setText(TracepointsMessages.TraceControlView_trace_notes_not_set); |
| } |
| if (tData != null && tData.getStartTime() != null) |
| fSetNotesButton.setEnabled(!readonly); |
| } |
| } |
| |
| protected void createFrameLine(Composite parent) { |
| fFrameComposite = new Composite(parent, SWT.NONE); |
| GridData fcGd = new GridData(SWT.FILL, SWT.TOP, true, false); |
| fcGd.horizontalSpan = 2; |
| fFrameComposite.setLayoutData(fcGd); |
| GridLayout layout = new GridLayout(2, false); |
| layout.marginHeight = 0; |
| fFrameComposite.setLayout(layout); |
| |
| Label separator = new Label(fFrameComposite, SWT.SEPARATOR | SWT.HORIZONTAL); |
| GridData sepGd = new GridData(SWT.FILL, SWT.CENTER, true, false); |
| sepGd.horizontalSpan = 2; |
| sepGd.verticalIndent = 2; |
| separator.setLayoutData(sepGd); |
| |
| fFrameSlider = new Slider(fFrameComposite, SWT.HORIZONTAL | SWT.BORDER); |
| GridData gd2 = new GridData(SWT.FILL, SWT.CENTER, true, false); |
| gd2.horizontalSpan = 2; |
| fFrameSlider.setLayoutData(gd2); |
| fFrameSlider.setValues(0, 0, 100, 1, 1, 10); |
| fFrameSlider.addSelectionListener(new SelectionAdapter() { |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| IHandlerService handlerService = getSite().getService(IHandlerService.class); |
| if (e.detail == SWT.ARROW_DOWN) { |
| try { |
| handlerService.executeCommand("org.eclipse.cdt.dsf.gdb.ui.command.selectNextTraceRecord", null); //$NON-NLS-1$ |
| } catch (Exception ex) { |
| } |
| } else if (e.detail == SWT.ARROW_UP) { |
| try { |
| handlerService.executeCommand("org.eclipse.cdt.dsf.gdb.ui.command.selectPreviousTraceRecord", null); //$NON-NLS-1$ |
| } catch (Exception ex) { |
| } |
| } else if (e.detail == SWT.DRAG) { |
| // We don't want to query gdb while user drags thumb, just update the label instead |
| // but postpone actual gdb query to the time thumb is released (e.detail == SWT.NONE) |
| fFrameNumberLabel.setText(TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_frame_dragging, |
| fFrameSlider.getSelection())); |
| } else { |
| fTraceControlModel.setCurrentTraceRecord(Integer.toString(fFrameSlider.getSelection())); |
| } |
| } |
| |
| }); |
| |
| fFrameLabel = new Label(fFrameComposite, SWT.NONE); |
| fFrameLabel.setText(TracepointsMessages.TraceControlView_frame_label); |
| fFrameLabel.setLayoutData(new GridData()); |
| |
| fFrameNumberLabel = new Label(fFrameComposite, SWT.NONE); |
| fFrameNumberLabel.setText(TracepointsMessages.TraceControlView_frame_not_looking); |
| GridData gd = new GridData(SWT.FILL, SWT.CENTER, true, false); |
| fFrameNumberLabel.setLayoutData(gd); |
| } |
| |
| protected void setFrameLineVisible(boolean visible, ITraceStatusDMData2 traceData) { |
| fFrameComposite.setVisible(visible); |
| ((GridData)fFrameComposite.getLayoutData()).exclude = !visible; |
| |
| if (visible) { |
| fFrameSlider.setMinimum(0); |
| if (traceData.getNumberOfCollectedFrame() == 0) { |
| fFrameSlider.setMaximum(1); |
| } else { |
| fFrameSlider.setMaximum(traceData.getNumberOfCollectedFrame()); |
| } |
| int inc = traceData.getNumberOfCollectedFrame() / 20; |
| fFrameSlider.setPageIncrement(inc <= 1 ? 2 : inc); |
| |
| String fl = EMPTY_STRING; |
| if (traceData.getCurrentTraceFrameId() != null) { |
| fl += TracepointsMessages.bind(TracepointsMessages.TraceControlView_frame_looking, |
| new Object[] { traceData.getCurrentTraceFrameId(), |
| Integer.valueOf(traceData.getTracepointNumberForCurrentTraceFrame())} ); |
| int recId = 0; |
| try { |
| recId = Integer.parseInt(traceData.getCurrentTraceFrameId()); |
| } catch (NumberFormatException e) { |
| } |
| fFrameSlider.setSelection(recId); |
| } else { |
| fl += TracepointsMessages.bind(TracepointsMessages.TraceControlView_frame_not_looking, traceData.getNumberOfCollectedFrame()); |
| fFrameSlider.setSelection(0); |
| } |
| fFrameNumberLabel.setText(fl); |
| } |
| if (traceData != null && traceData != null) { |
| fFrameSlider.setEnabled(traceData.getNumberOfCollectedFrame() != 0); |
| } |
| } |
| |
| protected void createBufferLine(final Composite parent) { |
| |
| fBufferComposite = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(3, false); |
| layout.marginHeight = 0; |
| fBufferComposite.setLayout(layout); |
| GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false); |
| fBufferComposite.setLayoutData(gd); |
| fBufferComposite.setBackgroundMode(SWT.INHERIT_FORCE); |
| |
| Label fBufferLabel = new Label(fBufferComposite, SWT.NONE); |
| fBufferLabel.setText(TracepointsMessages.TraceControlView_buffer_label); |
| if (cachedBold != null) { |
| fBufferLabel.setFont(cachedBold); |
| } |
| GridData gdBL = new GridData(SWT.FILL, SWT.CENTER, true, false); |
| fBufferLabel.setLayoutData(gdBL); |
| fBufferLabel.setBackground(fBufferComposite.getBackground()); |
| |
| fBufferProgress = new CircularProgress(fBufferComposite, SWT.NONE); |
| GridData bpGd = new GridData(SWT.CENTER, SWT.TOP, false, false); |
| bpGd.verticalSpan = 2; |
| fBufferProgress.setLayoutData(bpGd); |
| |
| fSetCircularBufferButton = new FlatRadioButton(fBufferComposite, SWT.NONE); |
| fSetCircularBufferButton.setText(TracepointsMessages.TraceControlView_buffer_circular_button_label); |
| fSetCircularBufferButton.setSelection(false); |
| fSetCircularBufferButton.setEnabled(true); |
| fSetCircularBufferButton.setToolTipText(TracepointsMessages.TraceControlView_buffer_circular_off_tooltip); |
| GridData cbbGd = new GridData(SWT.RIGHT, SWT.CENTER, false, false); |
| cbbGd.horizontalIndent = 20; |
| fSetCircularBufferButton.setLayoutData(cbbGd); |
| fSetCircularBufferButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| fTraceControlModel.setCircularBuffer(fSetCircularBufferButton.getSelection()); |
| fTraceControlModel.updateContent(); |
| } |
| }); |
| |
| fBufferCollectedFramesLabel = new Label(fBufferComposite, SWT.WRAP); |
| fBufferCollectedFramesLabel.setText(TracepointsMessages.TraceControlView_buffer_label); |
| GridData gd3 = new GridData(SWT.FILL, SWT.BOTTOM, true, false); |
| fBufferCollectedFramesLabel.setLayoutData(gd3); |
| } |
| |
| protected void setBufferLineVisible(boolean visible, ITraceStatusDMData2 tData, boolean readonly) { |
| fBufferComposite.setVisible(visible); |
| ((GridData)fBufferComposite.getLayoutData()).exclude = !visible; |
| |
| if (visible && tData != null){ |
| if (tData.getStopReason() != null && tData.getStopReason() == STOP_REASON_ENUM.OVERFLOW){ |
| // Buffer overflowed, it should be 100% full instead of 99% |
| fBufferProgress.setProgress(100); |
| } else if (tData.getStopReason() != null && tData.isCircularBuffer() && tData.getNumberOfCreatedFrames() > tData.getNumberOfCollectedFrame()) { |
| // Buffer is circular and overflowed once, it should be 100% full instead of 99% |
| fBufferProgress.setProgress(100); |
| } else if (tData.isCircularBuffer() && tData.isTracingActive() && |
| tData.getNumberOfCreatedFrames() > tData.getNumberOfCollectedFrame()) { |
| // If we run with Circular buffer and all buffer was filled in once, we continue displaying progress 100% |
| // and showing moving bar that makes a circle every tData.getNumberOfCollectedFrame() because it is buffer size in frames |
| // and actual number of collected frames from the start is tData.getNumberOfCreatedFrames(), but only last |
| // tData.getNumberOfCollectedFrame() are stored in the buffer |
| int p = (tData.getNumberOfCreatedFrames() % tData.getNumberOfCollectedFrame()) * 100 / tData.getNumberOfCollectedFrame(); |
| // 100 is an indicator that buffer is already full and should be showed in different manner |
| fBufferProgress.setProgress(100 + p); |
| } else { |
| fBufferProgress.setProgress((tData.getTotalBufferSize() - tData.getFreeBufferSize()) * 100 / tData.getTotalBufferSize()); |
| } |
| |
| fSetCircularBufferButton.setSelection(tData.isCircularBuffer()); |
| fSetCircularBufferButton.setEnabled(!readonly); |
| fSetCircularBufferButton.setToolTipText(fSetCircularBufferButton.getSelection() ? |
| TracepointsMessages.TraceControlView_buffer_circular_on_tooltip : |
| TracepointsMessages.TraceControlView_buffer_circular_off_tooltip); |
| fSetCircularBufferButton.redraw(); |
| fSetCircularBufferButton.update(); |
| |
| fBufferCollectedFramesLabel.setText(TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_buffer_frames_collected, |
| tData.getNumberOfCollectedFrame(), |
| (tData.getTotalBufferSize() - tData.getFreeBufferSize())/1000)); |
| fBufferProgress.redraw(); |
| fBufferProgress.update(); |
| } |
| } |
| |
| protected void createActions() { |
| IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| window.getActivePage().showActionSet("org.eclipse.cdt.debug.ui.tracepointActionSet"); //$NON-NLS-1$ |
| |
| IActionBars bars = getViewSite().getActionBars(); |
| IToolBarManager manager = bars.getToolBarManager(); |
| |
| // Create the action to refresh the view |
| fRefreshViewAction = new RefreshViewAction(); |
| bars.setGlobalActionHandler(ActionFactory.REFRESH.getId(), fRefreshViewAction); |
| manager.add(fRefreshViewAction); |
| fRefreshViewAction.setEnabled(false); |
| |
| fAutoRefreshAction = new AutoRefreshAction(); |
| manager.add(fAutoRefreshAction); |
| fAutoRefreshAction.setChecked(true); |
| fAutoRefreshAction.setEnabled(true); |
| fAutoRefreshEnabled = true; |
| fLastRefreshTime = System.currentTimeMillis(); |
| |
| fDisconnectedTracingAction = new DisconnectedTracingAction(); |
| manager.add(fDisconnectedTracingAction); |
| fDisconnectedTracingAction.setEnabled(false); |
| |
| // Create the action to open the trace variable details |
| fOpenTraceVarDetails = new OpenTraceVarDetailsAction(); |
| manager.add(fOpenTraceVarDetails); |
| |
| // Create the action to exit visualization mode |
| fExitVisualizationAction = new ExitVisualizationModeDetailsAction(); |
| manager.add(fExitVisualizationAction); |
| |
| bars.updateActionBars(); |
| updateActionEnablement(null); |
| } |
| |
| @Override |
| public void dispose() { |
| fTraceControlModel.dispose(); |
| |
| fStatusLabel = null; // Indicate that we have been disposed |
| if (refreshUIJob != null) { |
| refreshUIJob.cancel(); |
| } |
| |
| if (cachedBold != null) { |
| cachedBold.dispose(); |
| cachedBold = null; |
| } |
| |
| super.dispose(); |
| } |
| |
| protected void updateUI(final String statusMessage) { |
| try { |
| fLastTraceData = null; |
| setSecondaryStatusLineVisible(false, null); |
| //setNotesLineVisible(false, null, false); |
| setFrameLineVisible(false, null); |
| setBufferLineVisible(false, null, false); |
| fStatusLabel.setText(statusMessage); |
| setActionLinkVisible(false, EMPTY_STRING); |
| updateActionEnablement(null); |
| updateLayout(); |
| fDisconnectedTracingAction.setEnabled(false); |
| } catch (SWTException ex) { |
| } |
| } |
| |
| protected void updateUI(final ITraceStatusDMData2 traceData) { |
| fLastTraceData = traceData; |
| if (traceData == null ) { |
| // should not happen, but still process it correctly |
| updateUI(TracepointsMessages.TraceControlView_trace_status_inactive); |
| } else if (!traceData.isTracingSupported()) { |
| updateUI(TracepointsMessages.TraceControlView_trace_status_not_supported); |
| } else if (traceData.isTracingFromFile()) { |
| // Off-line tracing from data file |
| fDisconnectedTracingAction.setEnabled(false); |
| String s = TracepointsMessages.TraceControlView_trace_status_offline; |
| fStatusLabel.setText(s); |
| setActionLinkVisible(false, EMPTY_STRING); |
| |
| // If start and stop time are not available in trace data file, do not show secondary status line |
| if (getTimeMilliseconds(traceData.getStartTime()) != 0 && getTimeMilliseconds(traceData.getStopTime()) != 0) { |
| setSecondaryStatusLineVisible(true, traceData); |
| } else { |
| setSecondaryStatusLineVisible(false, traceData); |
| } |
| //setNotesLineVisible(true, traceData, true); |
| setBufferLineVisible(true, traceData, true); |
| setFrameLineVisible(true, traceData); |
| |
| updateActionEnablement(traceData); |
| updateLayout(); |
| |
| } else if (!traceData.isTracingActive() && traceData.getStopReason() == null){ |
| // Tracing is not started yet |
| fDisconnectedTracingAction.setEnabled(true); |
| fStatusLabel.setText(TracepointsMessages.TraceControlView_trace_status_not_started); |
| setActionLinkVisible(true,TracepointsMessages.TraceControlView_action_start); |
| |
| setSecondaryStatusLineVisible(false, null); |
| //setNotesLineVisible(true, traceData, false); |
| setBufferLineVisible(true, traceData, false); |
| setFrameLineVisible(false, null); |
| |
| updateActionEnablement(traceData); |
| updateLayout(); |
| |
| } else { |
| // Live execution tracing started and running or started and stopped |
| fDisconnectedTracingAction.setEnabled(true); |
| |
| // If stopped, stop reason, time and note. |
| STOP_REASON_ENUM fStopReason = traceData.getStopReason(); |
| if (fStopReason != null) { |
| // Tracing has stopped we need notes, secondary status line, and frames slider |
| setSecondaryStatusLineVisible(true, traceData); |
| //setNotesLineVisible(true, traceData, false); |
| |
| setFrameLineVisible(true, traceData); |
| setBufferLineVisible(true, traceData, false); |
| if (traceData.getCurrentTraceFrameId() != null) { |
| fStatusLabel.setText(TracepointsMessages.TraceControlView_trace_status_visualization); |
| setActionLinkVisible(true, TracepointsMessages.TraceControlView_action_finish_visualization); |
| } else { |
| if (traceData.getNumberOfCollectedFrame() == 0) { |
| fStatusLabel.setText(TracepointsMessages.TraceControlView_trace_status_not_started); |
| } else { |
| fStatusLabel.setText(TracepointsMessages.TraceControlView_trace_status_stopped); |
| } |
| setActionLinkVisible(true, TracepointsMessages.TraceControlView_action_restart); |
| } |
| } else { |
| // Tracing is running, don't show stop reason line, stop notes and frames line. |
| String s = TracepointsMessages.TraceControlView_trace_status_in_progress; |
| fStatusLabel.setText(s); |
| setActionLinkVisible(true, TracepointsMessages.TraceControlView_action_stop); |
| setSecondaryStatusLineVisible(true, traceData); |
| //setNotesLineVisible(true, traceData, false); |
| setFrameLineVisible(false, traceData); |
| setBufferLineVisible(true, traceData, true); |
| startRefreshUIJob(); |
| } |
| |
| updateActionEnablement(traceData); |
| updateLayout(); |
| } |
| } |
| |
| protected void startRefreshUIJob() { |
| if (refreshUIJob == null) { |
| refreshUIJob = new UIJob("Refresh Trace Control view UI") { //$NON-NLS-1$ |
| @Override |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| // Run on the UI thread to avoid synchronization |
| if (fAutoRefreshEnabled) { |
| fTraceControlModel.updateContent(); |
| } else { |
| // Update the UI to simply say how long ago was the last refresh |
| updateUI(fLastTraceData); |
| } |
| |
| return Status.OK_STATUS; |
| } |
| }; |
| } |
| refreshUIJob.schedule(UI_REFRESH_DELAY); |
| } |
| |
| protected String getStopMessage(ITraceStatusDMData2 tData) { |
| String stopMessage; |
| STOP_REASON_ENUM fStopReason = tData.getStopReason(); |
| if (fStopReason == STOP_REASON_ENUM.REQUEST) { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_user_request; |
| } else if (fStopReason == STOP_REASON_ENUM.PASSCOUNT) { |
| if (tData.getStoppingTracepoint() != null) { |
| stopMessage = TracepointsMessages.bind(TracepointsMessages.TraceControlView_tracing_stopped_tracepoint_number, tData.getStoppingTracepoint()); |
| } else { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_passcount; |
| } |
| } else if (fStopReason == STOP_REASON_ENUM.OVERFLOW) { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_buffer_full; |
| } else if (fStopReason == STOP_REASON_ENUM.DISCONNECTION) { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_disconnection; |
| } else if (fStopReason == STOP_REASON_ENUM.ERROR) { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_error; |
| } else { |
| stopMessage = TracepointsMessages.TraceControlView_tracing_stopped_unknown; |
| } |
| |
| String user = EMPTY_STRING; |
| if (tData.getUserName() != null && tData.getUserName().length() > 0) { |
| user = TracepointsMessages.bind(TracepointsMessages.TraceControlView_trace_status_secondary_user, tData.getUserName()); |
| } |
| if (tData.isTracingFromFile()) { |
| stopMessage = TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_trace_status_secondary_offline, |
| new Object[] {formatTime(tData.getStartTime()), |
| user, |
| formatTime(tData.getStopTime()), |
| stopMessage |
| }); |
| } else { |
| stopMessage = TracepointsMessages.bind( |
| TracepointsMessages.TraceControlView_trace_status_secondary_stopped, |
| new Object[] {formatTimeInterval(tData.getStartTime(),tData.getStopTime()), |
| user, |
| formatTime(tData.getStopTime()), |
| stopMessage |
| }); |
| } |
| |
| return stopMessage; |
| } |
| |
| protected void updateActionEnablement(ITraceStatusDMData2 traceData) { |
| fOpenTraceVarDetails.setEnabled(traceData != null && traceData.isTracingSupported()); |
| fExitVisualizationAction.setEnabled(traceData != null && traceData.getCurrentTraceFrameId() != null && |
| !traceData.isTracingFromFile()); |
| fDisconnectedTracingAction.setChecked(traceData != null && traceData.isDisconnectedTracingEnabled()); |
| } |
| |
| @Override |
| public void setFocus() { |
| if (fStatusLabel != null) { |
| fStatusLabel.setFocus(); |
| } |
| } |
| |
| public void updateLayout() { |
| fStatusComposite.layout(true); |
| fTopComposite.layout(true); |
| } |
| |
| protected long getTimeMilliseconds(String time) { |
| long microseconds = 0; |
| try { |
| if (time.length() != 0) { |
| String[] times = time.split("\\."); //$NON-NLS-1$ |
| microseconds += Long.parseLong(times[0]) * 1000000; |
| microseconds += Long.parseLong(times[1]); |
| } |
| } catch (NumberFormatException ex) { |
| GdbPlugin.log(ex); |
| } |
| return microseconds / 1000; |
| } |
| |
| /** |
| * Format time from gdb presentation into user-understandable form |
| * @param time in gd presentation |
| * @return |
| */ |
| protected String formatTime(String time) { |
| long milliseconds = getTimeMilliseconds(time); |
| return formatTime(milliseconds); |
| } |
| |
| /** |
| * Format time from standard milliseconds since Epoch into user-understandable form |
| */ |
| protected String formatTime(long milliseconds) { |
| Date date = new Date(milliseconds); |
| long currentTime = System.currentTimeMillis(); |
| long days = TimeUnit.MILLISECONDS.toDays(currentTime - milliseconds); |
| if (days == 0) { |
| // today |
| return TracepointsMessages.bind(TracepointsMessages.TraceControlView_today, DateFormat.getTimeInstance(DateFormat.SHORT).format(date)); |
| } else if (days == 1) { |
| // yesterday |
| return TracepointsMessages.bind(TracepointsMessages.TraceControlView_yesterday, DateFormat.getTimeInstance(DateFormat.SHORT).format(date)); |
| } |
| |
| return DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(date); |
| } |
| |
| /** |
| * Format time interval returned by trace status command into human-readable |
| */ |
| protected String formatTimeInterval(String startTime, String stopTime) { |
| long startMicroseconds = 0; |
| long stopMicroseconds = 0; |
| try { |
| if (startTime.length() != 0) { |
| String[] times = startTime.split("\\."); //$NON-NLS-1$ |
| startMicroseconds += Long.parseLong(times[0]) * 1000000; |
| startMicroseconds += Long.parseLong(times[1]); |
| } |
| if (stopTime.length() != 0) { |
| String[] times = stopTime.split("\\."); //$NON-NLS-1$ |
| stopMicroseconds += Long.parseLong(times[0]) * 1000000; |
| stopMicroseconds += Long.parseLong(times[1]); |
| } |
| return formatTimeInterval(startMicroseconds/1000, stopMicroseconds/1000, true); |
| } catch (NumberFormatException ex) { |
| GdbPlugin.log(ex); |
| } |
| return EMPTY_STRING; |
| } |
| |
| /** |
| * Format time interval returned by trace status command into human-readable |
| */ |
| protected String formatTimeInterval(long startMilliseconds, long stopMilliseconds, boolean shortForm) { |
| long millis = stopMilliseconds - startMilliseconds; |
| long days = TimeUnit.MILLISECONDS.toDays(millis); |
| millis -= TimeUnit.DAYS.toMillis(days); |
| long hours = TimeUnit.MILLISECONDS.toHours(millis); |
| millis -= TimeUnit.HOURS.toMillis(hours); |
| long minutes = TimeUnit.MILLISECONDS.toMinutes(millis); |
| millis -= TimeUnit.MINUTES.toMillis(minutes); |
| long seconds = TimeUnit.MILLISECONDS.toSeconds(millis); |
| |
| StringBuilder sb = new StringBuilder(64); |
| if (!shortForm) { |
| if (days != 0) sb.append(days).append(TracepointsMessages.TraceControlView_date_days); |
| if (hours != 0) sb.append(hours).append(TracepointsMessages.TraceControlView_date_hours); |
| if (minutes != 0) sb.append(minutes).append(TracepointsMessages.TraceControlView_date_minutes); |
| if (seconds != 0) sb.append(seconds).append(TracepointsMessages.TraceControlView_date_seconds); |
| if (sb.length() == 0) sb.append(TracepointsMessages.TraceControlView_date_zero); |
| } else { |
| if (days != 0) sb.append(days).append(TracepointsMessages.TraceControlView_date_short_days); |
| if (hours != 0) sb.append(hours).append(TracepointsMessages.TraceControlView_date_short_hours); |
| if (minutes != 0) sb.append(minutes).append(TracepointsMessages.TraceControlView_date_short_minutes); |
| if (seconds != 0) sb.append(seconds).append(TracepointsMessages.TraceControlView_date_short_seconds); |
| if (sb.length() == 0) sb.append(TracepointsMessages.TraceControlView_date_short_zero); |
| |
| } |
| return(sb.toString()); |
| } |
| |
| /** |
| * GDB's set trace-user and set trace-notes commands require quotes if argument contains spaces, |
| * but these quotes are returned by trace status, to workaround this we remove quotes on UI side |
| */ |
| protected String removeQuotes(String s) { |
| if (s.startsWith("\"") && s.endsWith("\"")) { //$NON-NLS-1$//$NON-NLS-2$ |
| return s.substring(1, s.length()-1); |
| } else { |
| return s; |
| } |
| } |
| } |
