protected String groupName = "";
protected String className = "";
protected CompositeType contType = CompositeType.UNKNOWN;
+ protected long next_good_time = -1;
// ========================================================================
// Constructors
this.id = id;
this.name = name;
contType = type;
+ next_good_time = stime;
}
public TimeRangeComposite(Integer id, Long stime, Long etime, String name, String groupName, String className, CompositeType type) {
return ChildEventComposites;
}
+ /**
+ * Represents the time where the next time range can start the drawing i.e.
+ * right after previous time range.
+ *
+ * @return
+ */
+ public long getNext_good_time() {
+ return next_good_time;
+ }
+
+ /**
+ * Represents the time where the next time range can start the drawing i.e.
+ * right after previous time range.
+ *
+ * @param nextGoodTime
+ */
+ public void setNext_good_time(long nextGoodTime) {
+ next_good_time = nextGoodTime;
+ }
+
+ /**
+ * Reset this resource to the construction state except for
+ */
+ public void reset() {
+ getChildEventComposites().clear();
+ getTraceEvents().clear();
+ next_good_time = startTime;
+ }
}
\r
private ResourceTypes type = ResourceTypes.UNKNOWN;\r
private Long resourceId = null;\r
- private long next_good_time = 0;\r
\r
// ========================================================================\r
// Constructor\r
\r
type = newType;\r
resourceId = newResourceId;\r
- next_good_time = newStartTime;\r
}\r
\r
// ========================================================================\r
return returnedValue;\r
}\r
\r
- /**\r
- * Represents the time where the next time range can start the drawing i.e.\r
- * right after previous time range.\r
- * \r
- * @return\r
- */\r
- public long getNext_good_time() {\r
- return next_good_time;\r
- }\r
-\r
- /**\r
- * Represents the time where the next time range can start the drawing i.e.\r
- * right after previous time range.\r
- * \r
- * @param nextGoodTime\r
- */\r
- public void setNext_good_time(long nextGoodTime) {\r
- next_good_time = nextGoodTime;\r
- }\r
-\r
- /**\r
- * Reset this resource to the construction state except for\r
- */\r
- public void reset() {\r
- getChildEventComposites().clear();\r
- getTraceEvents().clear();\r
- next_good_time = startTime;\r
- }\r
- \r
public abstract String getStateMode(LttngTraceState traceState);\r
}\r
import org.eclipse.linuxtools.lttng.state.StateManager;
import org.eclipse.linuxtools.lttng.state.experiment.StateManagerFactory;
import org.eclipse.linuxtools.lttng.ui.TraceDebug;
+import org.eclipse.linuxtools.lttng.ui.views.common.DataRequestState.RequestState;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.ui.views.TmfView;
// ========================================================================
// Data
// ========================================================================
- private DataRequestQueue reqState = UiCommonFactory.getQueue();
+ private DataRequestState reqState = new DataRequestState();
private String viewID = "";
// ========================================================================
public synchronized void processingStarted(RequestStartedSignal signal) {
StateDataRequest request = signal.getRequest();
if (request != null) {
- // update queue with the id of the current request.
- reqState.requestStarted(request);
- // if there was no new request then this one is still on
- // prepare for the reception of new data
-
- waitCursor(true);
-
- StateManager smanager = request.getStateManager();
- // Clear the children on the Processes related to this
- // manager.
- // Leave the GUI in charge of the updated data.
- String traceId = smanager.getEventLog().getName();
-
- // indicate if the data model needs to be cleared e.g. a new
- // experiment is being selected
- boolean clearData = request.isclearDataInd();
- // no new time range for zoom orders
- TmfTimeRange trange = null;
- if (clearData) {
- // Time Range will be used to filter out events which are
- // not visible in one pixel
- trange = StateManagerFactory.getExperimentManager()
- .getExperimentTimeRange();
+ // Check if a newer request is in the queue
+ TmfTimeRange newerReq = reqState.peekQueued();
+ if (newerReq == null) {
+ reqState.setState(DataRequestState.RequestState.BUSY);
+ reqState.setCurrentRequest(request);
+
+ waitCursor(true);
+
+ StateManager smanager = request.getStateManager();
+ // Clear the children on the Processes related to this
+ // manager.
+ // Leave the GUI in charge of the updated data.
+ String traceId = smanager.getEventLog().getName();
+ ModelUpdatePrep(traceId);
+ } else {
+ // clean up any possible pending request
+ request.cancel();
+
+ // Start the new request.
+ StateManagerFactory.getExperimentManager()
+ .readExperimentTimeWindow(newerReq, viewID, this);
}
-
- // Indicate if current data needs to be cleared and if so
- // specify the new experiment time range that applies
- ModelUpdatePrep(traceId, clearData, trange);
}
}
* processingCompleted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
*/
@TmfSignalHandler
- public synchronized void processingCompleted(RequestCompletedSignal signal) {
+ public void processingCompleted(RequestCompletedSignal signal) {
StateDataRequest request = signal.getRequest();
if (request == null) {
return;
} else {
- reqState.requestCompleted(request);
+ synchronized (this) {
+ reqState.setCurrentRequest(null);
+ }
}
- // Update wait cursor
- requestStateUpdate();
// No data refresh actions for cancelled requests.
if (request.isCancelled() || request.isFailed()) {
+
+ requestStateUpdate();
+
if (TraceDebug.isDEBUG()) {
TmfTimeRange trange = request.getRange();
if (request.isCancelled()) {
return;
} else {
ModelUpdateComplete(request);
+ requestStateUpdate();
}
}
* @param trange
*/
public synchronized void dataRequest(TmfTimeRange trange) {
- boolean sent = reqState.processDataRequest(trange, viewID, this);
+ if (trange != null) {
+ // cancelPendingRequests();
+ StateDataRequest currentRequest = reqState.getCurrentRequest();
+ // If a request is ongoing queue the new request
+ if (reqState.getState().equals(RequestState.BUSY)) {
+ reqState.setQueued(trange);
+ currentRequest = reqState.getCurrentRequest();
+ if (currentRequest != null) {
+ currentRequest.cancel();
+ }
+ } else {
+ // Set the state to busy
+ reqState.setState(DataRequestState.RequestState.BUSY);
+ waitCursor(true);
+ // no request is ongoing, proceed with request
+ StateManagerFactory.getExperimentManager()
+ .readExperimentTimeWindow(trange, viewID, this);
- if (sent) {
- waitCursor(true);
+ }
}
}
/**
- * Disable the wait cursor if the state is back to idle
+ * Check for pending request an either send a new request or change the
+ * state to idle
*/
private synchronized void requestStateUpdate() {
- // disable the wait cursor if the state is back to idle
- if (reqState.isIdle()) {
- // no more in the queue
+ // Check if a new time range update is waiting to be processed
+ TmfTimeRange queuedRequest = reqState.popQueued();
+ if (queuedRequest != null) {
+ // Trigger the pending request
+ StateManagerFactory.getExperimentManager()
+ .readExperimentTimeWindow(queuedRequest, viewID, this);
+ } else {
+ // All requests cancelled and no more pending requests
+ reqState.setState(RequestState.IDLE);
waitCursor(false);
}
}
* given traceId
*
* @param traceId
- * @param clearAllData
- * - reset all data e.g when a new experiment is selected
- * @param timeRange
- * - new total time range e.g. Experiment level
*/
- public abstract void ModelUpdatePrep(String traceId, boolean clearAllData,
- TmfTimeRange timeRange);
+ public abstract void ModelUpdatePrep(String traceId);
/**
* Actions taken by the view to refresh its widget(s) with the updated data
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2009 Ericsson
+ *
+ * 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:
+ * Alvaro Sanchez-Leon (alvsan09@gmail.com) - Initial API and implementation
+ *******************************************************************************/
+package org.eclipse.linuxtools.lttng.ui.views.common;
+
+import org.eclipse.linuxtools.lttng.state.StateDataRequest;
+import org.eclipse.linuxtools.lttng.ui.TraceDebug;
+import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
+
+/**
+ * One instance to keep track of the state of data request and a single time
+ * range data request pending in queue
+ *
+ * @author alvaro
+ *
+ */
+public class DataRequestState {
+
+ // ========================================================================
+ // Data
+ // ========================================================================
+ public enum RequestState {
+ IDLE, BUSY
+ }
+
+ private TmfTimeRange queued = null;
+ RequestState state = RequestState.IDLE;
+ private StateDataRequest currentRequest = null;
+
+ // ========================================================================
+ // Methods
+ // ========================================================================
+ /**
+ * @return the data request time range in queue
+ */
+ public synchronized TmfTimeRange peekQueued() {
+ return queued;
+ }
+
+ /**
+ * @return the data request time range in queue and reset it reference to
+ * null to get ready for a new entry in queue
+ */
+ public synchronized TmfTimeRange popQueued() {
+ // Save the reference to current request
+ TmfTimeRange result = queued;
+ // remove from queue
+ queued = null;
+ // Send original reference
+ return result;
+ }
+
+ /**
+ * @param queued
+ * <p>
+ * Set the data request time range to be waiting for processing
+ * </p>
+ * <p>
+ * Only the latest request is preserved
+ * </p>
+ */
+ public synchronized void setQueued(TmfTimeRange nqueued) {
+ if (TraceDebug.isDEBUG()) {
+ if (this.queued != null) {
+ StringBuilder sb = new StringBuilder(
+ "Queued request replaced from: "
+ + queued.getStartTime() + "-"
+ + queued.getEndTime() + "\n\t\t to: "
+ + nqueued.getStartTime() + "-"
+ + nqueued.getEndTime());
+ TraceDebug.debug(sb.toString());
+ }
+ }
+
+ this.queued = nqueued;
+ }
+
+ /**
+ * @return the state
+ */
+ public synchronized RequestState getState() {
+ return state;
+ }
+
+ /**
+ * @param state
+ * the state to set
+ */
+ public synchronized void setState(RequestState state) {
+ this.state = state;
+ }
+
+ public synchronized void setCurrentRequest(StateDataRequest currentRequest) {
+ this.currentRequest = currentRequest;
+ }
+
+ public synchronized StateDataRequest getCurrentRequest() {
+ return currentRequest;
+ }
+
+}
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
-import org.eclipse.linuxtools.lttng.state.IStateDataRequestListener;
-import org.eclipse.linuxtools.lttng.state.RequestCompletedSignal;
-import org.eclipse.linuxtools.lttng.state.RequestStartedSignal;
import org.eclipse.linuxtools.lttng.state.StateDataRequest;
import org.eclipse.linuxtools.lttng.state.StateManager;
import org.eclipse.linuxtools.lttng.state.evProcessor.EventProcessorProxy;
import org.eclipse.linuxtools.lttng.ui.TraceDebug;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeEventProcess;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeViewerProvider;
+import org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView;
import org.eclipse.linuxtools.lttng.ui.views.common.ParamsUpdater;
import org.eclipse.linuxtools.lttng.ui.views.controlflow.evProcessor.FlowTRangeUpdateFactory;
import org.eclipse.linuxtools.lttng.ui.views.controlflow.model.FlowModelFactory;
-import org.eclipse.linuxtools.lttng.ui.views.resources.model.ResourceModelFactory;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.signal.TmfSignalManager;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
-import org.eclipse.linuxtools.tmf.ui.views.TmfView;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.ScrolledComposite;
* <p>
* TODO: Implement me. Please.
*/
-public class ControlFlowView extends TmfView implements
+/**
+ * @author alvaro
+ *
+ */
+public class ControlFlowView extends AbsTimeUpdateView implements
ITmfTimeSelectionListener, ITmfTimeScaleSelectionListener,
- ITmfTimeFilterSelectionListener, IStateDataRequestListener {
+ ITmfTimeFilterSelectionListener {
public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.controlflow";
-
+
// ========================================================================
// Table data
// ========================================================================
// ========================================================================
// Data
// ========================================================================
- private Vector<StateDataRequest> pendingDataRequests = new Vector<StateDataRequest>();
-
private TableViewer tableViewer;
// private int totalNumItems = 0;
// Actions
* The constructor.
*/
public ControlFlowView() {
+ super(ID);
}
/**
tsfviewer.addWidgetSelectionListner(this);
tsfviewer.addWidgetTimeScaleSelectionListner(this);
- // Traces shall not be grouped to allow synchronization
+ // Traces shall not be grouped to allow synchronisation
tsfviewer.groupTraces(false);
tsfviewer.setItemHeight(itemHeight);
tsfviewer.setBorderWidth(borderWidth);
tsfviewer.setAcceptSelectionAPIcalls(true);
// Viewer to notify selection to this class
- // This class will synchronize selections with table.
+ // This class will synchronise selections with table.
tsfviewer.addWidgetSelectionListner(this);
tsfviewer.addFilterSelectionListner(this);
tsfviewer.addWidgetTimeScaleSelectionListner(this);
// action6
prevEvent = new Action() {
- @Override
-public void run() {
+ @Override
+ public void run() {
if (tsfviewer != null) {
tsfviewer.selectPrevEvent();
}
tableViewer.setSelection(sel);
}
- ParamsUpdater paramUpdater = ResourceModelFactory.getParamsUpdater();
+ ParamsUpdater paramUpdater = FlowModelFactory.getParamsUpdater();
Long savedSelTime = paramUpdater.getSelectedTime();
long selTimens = event.getSelectedTime();
}
}
- public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
+ public synchronized void tsfTmProcessTimeScaleEvent(
+ TmfTimeScaleSelectionEvent event) {
// source needed to keep track of source values
Object source = event.getSource();
// Read the updated time window
TmfTimeRange trange = paramUpdater.getTrange();
if (trange != null) {
- StateManagerFactory.getExperimentManager()
- .readExperimentTimeWindow(trange, "flowView", this);
+ // Request new data for specified time range
+ dataRequest(trange);
}
}
}
final Table table = tableViewer.getTable();
Display display = table.getDisplay();
- // Perform the updates on the UI thread
+ // Perform the updates on the UI thread)
display.asyncExec(new Runnable() {
public void run() {
+
tableViewer.setInput(items); // This shall be the minimal
// initial
tableFilter = new ViewProcessFilter(tableViewer);
}
}
- /*
- * (non-Javadoc)
- *
- * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
- * processingCompleted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
- */
- @TmfSignalHandler
- public void processingCompleted(RequestCompletedSignal signal) {
- StateDataRequest request = signal.getRequest();
-
- if (request == null) {
- return;
- } else {
- // Remove from the pending requests record
- pendingDataRequests.remove(request);
- }
-
- // No data refresh actions for cancelled requests.
- if (request.isCancelled() || request.isFailed()) {
- if (TraceDebug.isDEBUG()) {
- TmfTimeRange range = request.getRange();
- TraceDebug.debug("Request cancelled: "
- + range.getStartTime().toString() + " - "
- + range.getEndTime().toString());
- }
-
- return;
- }
-
- long experimentStartTime = -1;
- long experimentEndTime = -1;
- StateManager smanager = request.getStateManager();
- TmfTimeRange experimentTimeRange = smanager.getExperimentTimeWindow();
- if (experimentTimeRange != null) {
- experimentStartTime = experimentTimeRange.getStartTime().getValue();
- experimentEndTime = experimentTimeRange.getEndTime().getValue();
- }
-
- // Obtain the current process list
- Vector<TimeRangeEventProcess> processList = FlowModelFactory
- .getProcContainer().readProcesses();
- // convert it to an Array as expected by the widget
- TimeRangeEventProcess[] processArr = processList
- .toArray(new TimeRangeEventProcess[processList.size()]);
- // Sort the array by pid
- Arrays.sort(processArr);
-
- // Update the view part
- flowModelUpdates(processArr, experimentStartTime, experimentEndTime);
-
- // reselect to original time
- ParamsUpdater paramUpdater = ResourceModelFactory.getParamsUpdater();
- final Long selTime = paramUpdater.getSelectedTime();
- if (selTime != null) {
- Display display = tsfviewer.getControl().getDisplay();
- display.asyncExec(new Runnable() {
- public void run() {
- tsfviewer.setSelectedTime(selTime, false, this);
- }
- });
- }
-
- if (TraceDebug.isDEBUG()) {
- int eventCount = 0;
- Long count = smanager.getEventCount();
- for (TimeRangeEventProcess process : processList) {
- eventCount += process.getTraceEvents().size();
- }
-
- int discarded = FlowModelFactory.getParamsUpdater()
- .getEventsDiscarded();
- int discardedOutofOrder = ResourceModelFactory.getParamsUpdater()
- .getEventsDiscardedWrongOrder();
- TraceDebug
- .debug("Events handled: "
- + count
- + " Events loaded in Control Flow view: "
- + eventCount
- + " Number of events discarded: "
- + discarded
- + "\n\tNumber of events discarded with start time earlier than next good time: "
- + discardedOutofOrder);
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
- * processingStarted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
- */
- @TmfSignalHandler
- public void processingStarted(RequestStartedSignal signal) {
- StateDataRequest request = signal.getRequest();
- cancelPendingRequests();
- if (request != null) {
- // make sure there are no duplicates
- if (!pendingDataRequests.contains(request)) {
- pendingDataRequests.add(request);
- }
- pendingDataRequests.add(request);
- StateManager smanager = request.getStateManager();
- // Clear the children on the Processes related to this manager.
- // Leave the GUI in charge of the updated data.
- String traceId = smanager.getEventLog().getName();
- FlowModelFactory.getProcContainer().clearChildren(traceId);
- // Start over
- FlowModelFactory.getParamsUpdater().setEventsDiscarded(0);
- }
- }
-
- /**
- * Orders cancellation of any pending data requests
- */
- private void cancelPendingRequests() {
- for (StateDataRequest request : pendingDataRequests) {
- request.cancel();
- }
- pendingDataRequests.clear();
- }
-
/**
* @param scrollFrame
* @param wrapper
}
}
-}
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#waitCursor
+ * (boolean)
+ */
+ protected synchronized void waitCursor(final boolean waitInd) {
+ if (tsfviewer != null) {
+ Display display = tsfviewer.getControl().getDisplay();
+
+ // Perform the updates on the UI thread
+ display.asyncExec(new Runnable() {
+ public void run() {
+ tsfviewer.waitCursor(waitInd);
+ }
+ });
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @seeorg.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#
+ * ModelUpdatePrep(java.lang.String)
+ */
+ public void ModelUpdatePrep(String traceId) {
+ FlowModelFactory.getProcContainer().clearChildren(traceId);
+ // Start over
+ FlowModelFactory.getParamsUpdater().setEventsDiscarded(0);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @seeorg.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#
+ * ModelUpdateComplete(org.eclipse.linuxtools.lttng.state.StateDataRequest)
+ */
+ public void ModelUpdateComplete(StateDataRequest request) {
+ long experimentStartTime = -1;
+ long experimentEndTime = -1;
+ StateManager smanager = request.getStateManager();
+ TmfTimeRange experimentTimeRange = smanager.getExperimentTimeWindow();
+ if (experimentTimeRange != null) {
+ experimentStartTime = experimentTimeRange.getStartTime().getValue();
+ experimentEndTime = experimentTimeRange.getEndTime().getValue();
+ }
+ // Obtain the current process list
+ Vector<TimeRangeEventProcess> processList = FlowModelFactory
+ .getProcContainer().readProcesses();
+ // convert it to an Array as expected by the widget
+ TimeRangeEventProcess[] processArr = processList
+ .toArray(new TimeRangeEventProcess[processList.size()]);
+ // Sort the array by pid
+ Arrays.sort(processArr);
+
+ // Update the view part
+ flowModelUpdates(processArr, experimentStartTime, experimentEndTime);
+
+ // reselect to original time
+ ParamsUpdater paramUpdater = FlowModelFactory.getParamsUpdater();
+ final Long selTime = paramUpdater.getSelectedTime();
+ if (selTime != null) {
+ Display display = tsfviewer.getControl().getDisplay();
+ display.asyncExec(new Runnable() {
+ public void run() {
+ tsfviewer.setSelectedTime(selTime, false, this);
+ }
+ });
+ }
+
+ if (TraceDebug.isDEBUG()) {
+ int eventCount = 0;
+ Long count = smanager.getEventCount();
+ for (TimeRangeEventProcess process : processList) {
+ eventCount += process.getTraceEvents().size();
+ }
+
+ int discarded = FlowModelFactory.getParamsUpdater()
+ .getEventsDiscarded();
+ int discardedOutofOrder = FlowModelFactory.getParamsUpdater()
+ .getEventsDiscardedWrongOrder();
+ TmfTimeRange range = request.getRange();
+ StringBuilder sb = new StringBuilder(
+ "Events handled: "
+ + count
+ + " Events loaded in Control Flow view: "
+ + eventCount
+ + " Number of events discarded: "
+ + discarded
+ + "\n\tNumber of events discarded with start time earlier than next good time: "
+ + discardedOutofOrder);
+
+ sb.append("\n\t\tRequested Time Range: " + range.getStartTime()
+ + " - " + range.getEndTime());
+ TraceDebug.debug(sb.toString());
+ }
+ }
+}
\ No newline at end of file
import org.eclipse.linuxtools.lttng.ui.views.common.ParamsUpdater;
import org.eclipse.linuxtools.lttng.ui.views.controlflow.model.FlowModelFactory;
import org.eclipse.linuxtools.lttng.ui.views.controlflow.model.FlowProcessContainer;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
public abstract class AbsFlowTRangeUpdate extends AbsTRangeUpdate implements IEventProcessing {
* @param stateMode
* @return
*/
- protected boolean makeDraw(LttngTraceState traceSt, TmfTimestamp startTime,
- TmfTimestamp endTime, TimeRangeEventProcess localProcess,
+ protected boolean makeDraw(LttngTraceState traceSt, long startTime,
+ long endTime, TimeRangeEventProcess localProcess,
ParamsUpdater params, String stateMode) {
// Determine start and end times to establish duration
- Long stime = startTime.getValue();
- Long etime = endTime.getValue();
+ Long stime = startTime;
+ Long etime = endTime;
if (etime < stime) {
// Validate the sequential order of events
// I'm not sure about it
time_window.setVisible(visible);
localProcess.getTraceEvents().add(time_window);
+ localProcess.setNext_good_time(etime);
// *** VERIFY ***
// Missing checks like this one?
* @param params
* @return
*/
- protected boolean makeDraw(LttngTraceState traceSt, TmfTimestamp evTime,
+ protected boolean makeDraw(LttngTraceState traceSt, long evTime,
LttngProcessState process, TimeRangeEventProcess localProcess,
ParamsUpdater params) {
- TmfTimestamp stime = process.getState().getChange_LttTime();
+ // TmfTimestamp stime = process.getState().getChange_LttTime();
+ long stime = localProcess.getNext_good_time();
String stateMode;
ProcessStatus procStatus = process.getState().getProc_status();
}
// Do the actual drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), stateProcess,
- localProcess, params);
+ makeDraw(traceSt, trcEvent.getTimestamp().getValue(),
+ stateProcess, localProcess, params);
} else {
TraceDebug
.debug("Running process is null! (getStateModesHandler)");
}
// Do the actual drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), process,
+ makeDraw(traceSt, trcEvent.getTimestamp().getValue(),
+ process,
localProcess, params);
} else {
// Process may be null if the process started BEFORE the
}
// Do the actual drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), process,
+ makeDraw(traceSt, trcEvent.getTimestamp().getValue(),
+ process,
localProcess, params);
} else {
.getEndTime().getValue(), traceSt
.getTraceId());
// Call the function that does the actual drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), process,
- localProcess, params);
+ makeDraw(traceSt, trcEvent.getTimestamp()
+ .getValue(), process, localProcess, params);
} else {
TraceDebug
.debug("Pid is null or Pid == PPID! (getProcessExitHandler)");
}
} else {
TraceDebug
- .debug("Running proces is null! (getProcessExitHandler)");
+ .debug("Running process is null! (getProcessExitHandler)");
}
return false;
}
// Perform the drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), process,
+ makeDraw(traceSt, trcEvent.getTimestamp().getValue(),
+ process,
localProcess, params);
}
} else {
if (localProcess != null) {
// Call the function that will does the actual
// drawing
- makeDraw(traceSt, trcEvent.getTimestamp(), process,
- localProcess, params);
+ makeDraw(traceSt, trcEvent.getTimestamp()
+ .getValue(), process, localProcess, params);
} else {
TraceDebug
.debug("localProcess is null! (getStateDumpEndHandler)");
import java.util.Vector;
import org.eclipse.linuxtools.lttng.event.LttngEvent;
-import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
import org.eclipse.linuxtools.lttng.state.StateStrings.Events;
import org.eclipse.linuxtools.lttng.state.evProcessor.IEventProcessing;
import org.eclipse.linuxtools.lttng.state.model.LttngProcessState;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeComponent;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeEvent;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeEventProcess;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
/**
* Creates specific finish state data request
public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
// Draw a last known state to the end of the trace
- TmfTimestamp endReqTime = traceSt.getInputDataRef()
- .getTraceTimeWindow().getEndTime();
+ long endReqTime = traceSt.getInputDataRef().getTraceTimeWindow()
+ .getEndTime().getValue();
TraceDebug.debug("Number of localProcesses: "
+ procContainer.readProcesses().size());
// to identify the process relevant to the traceState
if (prevEvent instanceof TimeRangeEvent) {
TimeRangeEvent prevTimeRange = (TimeRangeEvent) prevEvent;
// calculate the next good time to draw the event
- nextGoodTime = prevTimeRange.getStopTime() + 1;
+ // nextGoodTime = prevTimeRange.getStopTime() + 1;
+ nextGoodTime = localProcess.getNext_good_time();
stateMode = prevTimeRange.getStateMode();
// Draw with the Local information since the current
// request did
// not contain events related to this process
- makeDraw(traceSt, new LttngTimestamp(nextGoodTime),
+ makeDraw(traceSt, nextGoodTime,
endReqTime, localProcess, params, stateMode);
} else {
TraceDebug
for (TimeRangeEventProcess process : processes) {
procTraceId = process.getTraceID();
if (procTraceId.equals(traceId)) {
- process.getTraceEvents().clear();
- process.getChildEventComposites().clear();
+ process.reset();
}
}
}
package org.eclipse.linuxtools.lttng.ui.views.resources;
import java.util.Arrays;
-import java.util.Vector;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
-import org.eclipse.linuxtools.lttng.state.IStateDataRequestListener;
-import org.eclipse.linuxtools.lttng.state.RequestCompletedSignal;
-import org.eclipse.linuxtools.lttng.state.RequestStartedSignal;
import org.eclipse.linuxtools.lttng.state.StateDataRequest;
import org.eclipse.linuxtools.lttng.state.StateManager;
import org.eclipse.linuxtools.lttng.state.evProcessor.EventProcessorProxy;
import org.eclipse.linuxtools.lttng.state.experiment.StateExperimentManager;
import org.eclipse.linuxtools.lttng.state.experiment.StateManagerFactory;
import org.eclipse.linuxtools.lttng.ui.TraceDebug;
-import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeComponent;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeEventResource;
import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeViewerProvider;
+import org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView;
import org.eclipse.linuxtools.lttng.ui.views.common.ParamsUpdater;
import org.eclipse.linuxtools.lttng.ui.views.resources.evProcessor.ResourcesTRangeUpdateFactory;
import org.eclipse.linuxtools.lttng.ui.views.resources.model.ResourceModelFactory;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
-import org.eclipse.linuxtools.tmf.ui.views.TmfView;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
* @author alvaro
*
*/
-public class ResourcesView extends TmfView implements
- ITmfTimeSelectionListener, ITmfTimeScaleSelectionListener,
- IStateDataRequestListener {
+public class ResourcesView extends AbsTimeUpdateView implements
+ ITmfTimeSelectionListener, ITmfTimeScaleSelectionListener {
// ========================================================================
// Data
// ========================================================================
public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.resources";
- private Vector<StateDataRequest> pendingDataRequests = new Vector<StateDataRequest>();
// private int totalNumItems = 0;
// Actions
// private TraceModelImplFactory fact;
// ========================================================================
- // Methods
+ // Constructor
// ========================================================================
/**
* The constructor.
*/
public ResourcesView() {
+ super(ID);
}
+ // ========================================================================
+ // Methods
+ // ========================================================================
+
/**
* This is a callback that will allow us to create the viewer and initialize
* it.
tsfviewer.addWidgetSelectionListner(this);
tsfviewer.addWidgetTimeScaleSelectionListner(this);
- // Traces shall not be grouped to allow synchronization
+ // Traces shall not be grouped to allow synchronisation
tsfviewer.groupTraces(true);
tsfviewer.setAcceptSelectionAPIcalls(true);
// Viewer to notify selection to this class
- // This class will synchronize selections with table.
+ // This class will synchronise selections with table.
tsfviewer.addWidgetSelectionListner(this);
tsfviewer.addWidgetTimeScaleSelectionListner(this);
// FlowParamsUpdater listener = FlowModelFactory.getParamsUpdater();
// tsfviewer.addWidgetTimeScaleSelectionListner(listener);
- // TODO: refactor regitration / notificatio process
+ // TODO: re-factor registration / notification process
// Register this view to receive updates when the model is updated with
// fresh info
// ModelListenFactory.getRegister().addFlowModelUpdatesListener(this);
}
}
+ /*
+ * (non-Javadoc)
+ *
+ * @seeorg.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.
+ * ITmfTimeScaleSelectionListener
+ * #tsfTmProcessTimeScaleEvent(org.eclipse.linuxtools
+ * .tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent)
+ */
public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
// source needed to keep track of source values
Object source = event.getSource();
if (newParams) {
// Read the updated time window
TmfTimeRange trange = paramUpdater.getTrange();
- if (trange != null) {
- StateManagerFactory.getExperimentManager()
- .readExperimentTimeWindow(trange, "resourceView",
- this);
- }
+ // Either send a new request or queue for next opportunity
+ dataRequest(trange);
}
}
}
return strVal.substring(strVal.length() - 9);
}
- // // @Override
- // public void resourceModelUpdates(ModelUpdatesEvent event) {
- // ITmfTimeAnalysisEntry[] items = event.getItems();
- // resourceModelUpdates(items, event.getStartTime(), event.getEndTime());
- // }
-
public void resourceModelUpdates(final ITmfTimeAnalysisEntry[] items,
final long startTime, final long endTime) {
tsfviewer.getControl().getDisplay().asyncExec(new Runnable() {
tsfviewer = null;
}
- /*
- * (non-Javadoc)
+ /**
+ * Trigger time synchronisation to other views this method shall be called
+ * when a check has been performed to note that an actual change of time has
+ * been performed vs a pure re-selection of the same time
*
- * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
- * processingStarted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
+ * @param time
*/
- @TmfSignalHandler
- public void processingStarted(RequestStartedSignal startSignal) {
- StateDataRequest request = startSignal.getRequest();
- cancelPendingRequests();
- if (request != null) {
- // make sure there are no duplicates
- if (!pendingDataRequests.contains(request)) {
- pendingDataRequests.add(request);
- }
-
- StateManager smanager = request.getStateManager();
- // Clear the children on the Processes related to this manager.
- // Leave the GUI in charge of the updated data.
- String traceId = smanager.getEventLog().getName();
- ResourceModelFactory.getResourceContainer().clearChildren(traceId);
- // Start over
- ResourceModelFactory.getParamsUpdater().setEventsDiscarded(0);
+ private void synchTimeNotification(long time) {
+ // if synchronisation selected
+ if (synch.isChecked()) {
+ // Notify other views
+ TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(this,
+ new LttngTimestamp(time)));
}
}
/**
- * Orders cancellation of any pending data requests
+ * Registers as listener of time selection from other tmf views
+ *
+ * @param signal
*/
- private void cancelPendingRequests() {
- for (StateDataRequest request : pendingDataRequests) {
- request.cancel();
+ @TmfSignalHandler
+ public void synchToTime(TmfTimeSynchSignal signal) {
+ if (synch.isChecked()) {
+ Object source = signal.getSource();
+ if (signal != null && source != null && source != this) {
+ // Internal value is expected in nano seconds.
+ long selectedTime = signal.getCurrentTime().getValue();
+ if (tsfviewer != null) {
+ tsfviewer.setSelectedTime(selectedTime, true, source);
+ }
+ }
}
- pendingDataRequests.clear();
}
/*
* (non-Javadoc)
*
- * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
- * processingCompleted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
+ * @see
+ * org.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#waitCursor
+ * (boolean)
*/
- @TmfSignalHandler
- public void processingCompleted(
- RequestCompletedSignal completedSignal) {
- StateDataRequest request = completedSignal.getRequest();
+ protected void waitCursor(final boolean waitInd) {
+ if (tsfviewer != null) {
+ Display display = tsfviewer.getControl().getDisplay();
- if (request == null) {
- return;
- } else {
- // Remove from the pending requests record
- pendingDataRequests.remove(request);
+ // Perform the updates on the UI thread
+ display.asyncExec(new Runnable() {
+ public void run() {
+ tsfviewer.waitCursor(waitInd);
+ }
+ });
}
+ }
- // No data refresh actions for cancelled requests.
- if (request.isCancelled() || request.isFailed()) {
- if (TraceDebug.isDEBUG()) {
- TmfTimeRange range = request.getRange();
- TraceDebug.debug("Request cancelled: "
- + range.getStartTime().toString() + " - "
- + range.getEndTime().toString());
- }
- return;
- }
+ /*
+ * (non-Javadoc)
+ *
+ * @seeorg.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#
+ * ModelUpdatePrep(java.lang.String)
+ */
+ public void ModelUpdatePrep(String traceId) {
+ ResourceModelFactory.getResourceContainer().clearChildren(traceId);
+ // Start over
+ ResourceModelFactory.getParamsUpdater().setEventsDiscarded(0);
+ }
+ /*
+ * (non-Javadoc)
+ *
+ * @seeorg.eclipse.linuxtools.lttng.ui.views.common.LttngTimeUpdateView#
+ * ModelUpdateComplete(org.eclipse.linuxtools.lttng.state.StateDataRequest)
+ */
+ public void ModelUpdateComplete(StateDataRequest request) {
StateManager smanager = request.getStateManager();
long experimentStartTime = -1;
long experimentEndTime = -1;
}
}
-
- public void newTimeRange(TimeRangeComponent trange) {
- // TODO Auto-generated method stub
-
- }
-
- /**
- * Trigger time synchronisation to other views this method shall be called
- * when a check has been performed to note that an actual change of time has
- * been performed vs a pure re-selection of the same time
- *
- * @param time
- */
- private void synchTimeNotification(long time) {
- // if synchronisation selected
- if (synch.isChecked()) {
- // Notify other views
- TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(this,
- new LttngTimestamp(time)));
- }
- }
-
- /**
- * Registers as listener of time selection from other tmf views
- *
- * @param signal
- */
- @TmfSignalHandler
- public void synchToTime(TmfTimeSynchSignal signal) {
- if (synch.isChecked()) {
- Object source = signal.getSource();
- if (signal != null && source != null && source != this) {
- // Internal value is expected in nano seconds.
- long selectedTime = signal.getCurrentTime().getValue();
- if (tsfviewer != null) {
- tsfviewer.setSelectedTime(selectedTime, true, source);
- }
- }
- }
- }
}
\ No newline at end of file
// *** AFTER HOOKS ***
- eventNametoBeforeProcessor.put(
+ eventNametoAfterProcessor.put(
StateStrings.Events.LTT_EVENT_SCHED_SCHEDULE.getInName(),
instantiateAfterHandler.getAfterSchedChangeHandler());
// Methods
// ========================================================================
+ /**
+ *
+ * @param request
+ * @return
+ */
public void processingStarted(RequestStartedSignal request);
+ /**
+ * @param signal
+ */
public void processingCompleted(RequestCompletedSignal signal);
}
* @param broadcast
* true: All views, false: only to registered listeners
*/
- public void startRequestInd(TmfExperiment experiment, boolean broadcast) {
+ public void startRequestInd(TmfExperiment experiment, boolean broadcast,
+ boolean waitForCompletion) {
if (broadcast) {
// Notify all state views.
this.broadcast = broadcast;
}
// trigger the start to process this request
- experiment.processRequest(this, true);
+ experiment.processRequest(this, waitForCompletion);
}
/**
TmfTimeRange allTraceWindow = fEventLog.getTimeRange();
StateDataRequest request = getDataRequestStateSave(allTraceWindow,
null);
- request.startRequestInd(fExperiment, true);
+
+ // Wait for completion
+ request.startRequestInd(fExperiment, true, true);
if (TraceDebug.isDEBUG()) {
List<LttngProcessState> processes = stateIn
// Process request to that point
StateDataRequest request = getDataRequestByTimeRange(trange, listener);
- request.startRequestInd(fExperiment, false);
+ // don't wait for completion i.e. allow cancellations
+ request.startRequestInd(fExperiment, false, true);
if (TraceDebug.isDEBUG()) {
List<LttngProcessState> processes = stateIn.getTraceStateModel()
final TmfEvent[] evt = new TmfEvent[1];
- // ***FIXME***
- // The override of handlePartialResult is exactly the same as the one in
+ // ***TODO***
+ // The override of handlePartialResult is similar to the one in
// getDataRequestByPosition()
- // However, there is no way to override it in only one place to avoid
- // code duplication!
// ***
// Create the new request and override the handlePartialResult function
// Dispatch information for Event processing
stateIn.processEvent(evt[0]);
+ // increment internal and external number of events
+ setNumOfEvents(getNumOfEvents() + 1);
eventCount++;
}
@Override
public void handleCompleted() {
- requestCompleted();
- // notify the associated listener
+ if (isCancelled() || isFailed()) {
+ // No notification to end request handlers
+ } else {
+ // notify the associated end request handlers
+ requestCompleted();
+ }
+
+ // notify listeners
notifyCompletion();
}
};
final TmfEvent[] evt = new TmfEvent[1];
- // ***FIXME***
- // The override of handlePartialResult is exactly the same as the one in
+ // ***TODO***
+ // The override of handlePartialResult is similar to the one in
// getDataRequestByPosition()
- // However, there is no way to override it in only one place to avoid
- // code duplication!
// ***
// Create the new request and override the handlePartialResult function
@Override
public void handleCompleted() {
- requestCompleted();
+ if (isCancelled() || isFailed()) {
+ // No notification to end request handlers
+ } else {
+ // notify the associated end request handlers
+ requestCompleted();
+ }
- // Notify listeners of the completion of this request.
+ // notify listeners
notifyCompletion();
TraceDebug.debug("number of events processed on file opening"
+ getNumOfEvents());
if (child_process == null) {
child_process = create_process(traceSt, cpu, child_pid,
child_tgid, timeStamp);
+ child_process.setPpid(process.getPid(), timeStamp);
} else {
/*
* The process has already been created : due to time
if (process == null) {
parent_process = lttv_state_find_process(traceSt,
ANY_CPU, parent_pid);
+ TmfTimestamp eventTime = trcEvent.getTimestamp();
process = create_process(traceSt, cpu, pid, tgid,
- command, trcEvent.getTimestamp());
+ command, eventTime);
if (parent_process != null) {
- process.setPpid(parent_process.getPid());
+ process.setPpid(parent_process.getPid(), eventTime);
}
/* Keep the stack bottom : a running user mode */
*******************************************************************************/
package org.eclipse.linuxtools.lttng.state.experiment;
-import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
*/
public void readExperimentTimeWindow(TmfTimeRange trange,
String transactionID, IStateDataRequestListener listener) {
- Collection<StateManager> mamangers = managersByID.values();
- for (StateManager manager : mamangers) {
- manager.executeDataRequest(trange, transactionID, listener);
+ if (fExperiment != null) {
+ String id = fExperiment.getExperimentId();
+ StateManager manager = managersByID.get(id);
+ if (manager != null) {
+ // TODO: A loop to request data for each trace needs to be used
+ // here when multiple traces are supported.
+ manager.executeDataRequest(trange, transactionID, listener);
+ }
}
}
// Initialize stack
LttngExecutionState es = new LttngExecutionState();
- es.setExec_mode(ExecutionMode.LTTV_STATE_USER_MODE);
+ es.setExec_mode(ExecutionMode.LTTV_STATE_MODE_UNKNOWN);
es.setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE.getInName());
es.setEntry_Time(this.insertion_time);
es.setChange_Time(this.insertion_time);
es.setCum_cpu_time(0L);
es.setProc_status(ProcessStatus.LTTV_STATE_RUN);
this.execution_stack.push(es);
-
- es = new LttngExecutionState();
- es.setExec_mode(ExecutionMode.LTTV_STATE_SYSCALL);
- es.setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE.getInName());
- es.setEntry_Time(this.insertion_time);
- es.setChange_Time(this.insertion_time);
- es.setCum_cpu_time(0L);
- es.setProc_status(ProcessStatus.LTTV_STATE_WAIT_FORK);
- this.execution_stack.push(es);
+
+ //TODO: This initialisation is present in C, however an entry in waiting fork may
+ //display incorrect states, there is a need for deeper compare of the initialisation phase
+ // es = new LttngExecutionState();
+ // es.setExec_mode(ExecutionMode.LTTV_STATE_SYSCALL);
+ // es.setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE.getInName());
+ // es.setEntry_Time(this.insertion_time);
+ // es.setChange_Time(this.insertion_time);
+ // es.setCum_cpu_time(0L);
+ // es.setProc_status(ProcessStatus.LTTV_STATE_WAIT_FORK);
+ // this.execution_stack.push(es);
// point state to the top of the stack
this.state = es;
import org.eclipse.jface.viewers.ISelection;\r
import org.eclipse.jface.viewers.ISelectionProvider;\r
import org.eclipse.linuxtools.tmf.ui.viewers.ITmfViewer;\r
-import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;\r
+import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;\r
import org.eclipse.swt.events.ControlEvent;\r
import org.eclipse.swt.widgets.Control;\r
\r
public Control getControl();\r
\r
public ISelectionProvider getSelectionProvider();\r
+\r
+ /**\r
+ * <p>\r
+ * Provide the possibility to control the wait cursor externally\r
+ * </p>\r
+ * <p>\r
+ * e.g. data requests in progress\r
+ * </p>\r
+ * \r
+ * @param waitInd\r
+ * - true change to wait cursor\r
+ */\r
+ public void waitCursor(boolean waitInd);\r
+\r
}
\ No newline at end of file
import org.eclipse.jface.viewers.IStructuredSelection;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.dialogs.TmfTimeFilterDialog;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.dialogs.TmfTimeLegend;\r
-import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;\r
+import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.ITimeDataProvider;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TimeScaleCtrl;\r
-import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TmfTimeTipHandler;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TmfTimeStatesCtrl;\r
+import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TmfTimeTipHandler;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.Utils;\r
import org.eclipse.swt.SWT;\r
public ISelectionProvider getSelectionProvider() {\r
return _stateCtrl;\r
}\r
+\r
+ /*\r
+ * (non-Javadoc)\r
+ * \r
+ * @see\r
+ * org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer\r
+ * #waitCursor(boolean)\r
+ */\r
+ public void waitCursor(boolean waitInd) {\r
+ _stateCtrl.waitCursor(waitInd);\r
+ }\r
}\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.ScrollBar;\r
\r
+/**\r
+ * @author alvaro\r
+ * \r
+ */\r
public class TmfTimeStatesCtrl extends TraceCtrl implements FocusListener,\r
KeyListener, MouseMoveListener, MouseListener, MouseWheelListener,\r
ControlListener, SelectionListener, MouseTrackListener,\r
private ITimeDataProvider _timeProvider;\r
private boolean _isInFocus = false;\r
private boolean _isDragCursor3 = false;\r
+ private boolean _isWaitCursor = true;\r
private boolean _mouseHover = false;\r
private int _itemHeightDefault = 18;\r
private int _itemHeight = _itemHeightDefault;\r
private Rectangle _rect0 = new Rectangle(0, 0, 0, 0);\r
private Rectangle _rect1 = new Rectangle(0, 0, 0, 0);\r
private Cursor _dragCursor3;\r
+ private Cursor _WaitCursor;\r
private boolean drawTracesInteraction = false;\r
private boolean drawTraceJoins = DEFAULT_DRAW_THREAD_JOIN;\r
private boolean drawTraceWaits = DEFAULT_DRAW_THREAD_WAIT;\r
}\r
\r
_dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);\r
+ _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);\r
}\r
\r
@Override\r
public void dispose() {\r
super.dispose();\r
_dragCursor3.dispose();\r
+ _WaitCursor.dispose();\r
}\r
\r
public void setTimeProvider(ITimeDataProvider timeProvider) {\r
}\r
}\r
\r
+ /**\r
+ * <p>\r
+ * If the x, y position is over the vertical split line (name to time\r
+ * ranges), then change the cursor to a drag cursor to indicate the user the\r
+ * possibility of resizing\r
+ * </p>\r
+ * \r
+ * @param x\r
+ * @param y\r
+ */\r
void updateCursor(int x, int y) {\r
- int idx = hitSplitTest(x, y);\r
- // No dragcursor is name space is fixed to zero\r
- if (idx > 0 && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {\r
- setCursor(_dragCursor3);\r
- _isDragCursor3 = true;\r
- } else if (idx <= 0 && _isDragCursor3) {\r
+ // if Wait cursor not active, check for the need to change to a drag\r
+ // cursor\r
+ if (_isWaitCursor == false) {\r
+ int idx = hitSplitTest(x, y);\r
+ // No dragcursor is name space is fixed to zero\r
+ if (idx > 0 && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {\r
+ setCursor(_dragCursor3);\r
+ _isDragCursor3 = true;\r
+ } else if (idx <= 0 && _isDragCursor3) {\r
+ setCursor(null);\r
+ _isDragCursor3 = false;\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Provide the possibilty to control the wait cursor externally e.g. data\r
+ * requests in progress\r
+ * \r
+ * @param waitInd\r
+ */\r
+ public void waitCursor(boolean waitInd) {\r
+ // Update cursor as indicated\r
+ if (waitInd) {\r
+ setCursor(_WaitCursor);\r
+ _isWaitCursor = true;\r
+ } else {\r
setCursor(null);\r
- _isDragCursor3 = false;\r
+ _isWaitCursor = false;\r
}\r
+\r
+ // Get ready for next mouse move\r
+ _isDragCursor3 = false;\r
}\r
\r
public void mouseDown(MouseEvent e) {\r
projects / deliverable / tracecompass.git / commitdiff
