Received by components that need to be notified of a new trace event count.
-=== TmfTimeSynchSignal ===
+=== TmfSelectionRangeUpdatedSignal ===
''Purpose''
Received by any component that needs to be notified of the currently selected time or time range.
-=== TmfRangeSynchSignal ===
+=== TmfWindowRangeUpdatedSignal ===
''Purpose''
import org.eclipse.tracecompass.internal.gdbtrace.core.trace.GdbEventAspects;
import org.eclipse.tracecompass.internal.gdbtrace.core.trace.GdbTrace;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
@Override
@TmfSignalHandler
- public void currentTimeUpdated(final TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
// do not synchronize on time
}
import org.eclipse.tracecompass.analysis.os.linux.ui.views.controlflow.ControlFlowView;
import org.eclipse.tracecompass.analysis.os.linux.ui.views.resources.ResourcesView;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
}
}
HistogramView hv = (HistogramView) vp;
- final TmfTimeSynchSignal signal = new TmfTimeSynchSignal(hv, fDesired1.getTimestamp());
- final TmfTimeSynchSignal signal2 = new TmfTimeSynchSignal(hv, fDesired2.getTimestamp());
+ final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(hv, fDesired1.getTimestamp());
+ final TmfSelectionRangeUpdatedSignal signal2 = new TmfSelectionRangeUpdatedSignal(hv, fDesired2.getTimestamp());
hv.updateTimeRange(100000);
SWTBotUtils.waitForJobs();
- hv.currentTimeUpdated(signal);
+ hv.selectionRangeUpdated(signal);
hv.broadcast(signal);
SWTBotUtils.waitForJobs();
SWTBotUtils.delay(1000);
hv.updateTimeRange(1000000000);
SWTBotUtils.waitForJobs();
- hv.currentTimeUpdated(signal2);
+ hv.selectionRangeUpdated(signal2);
hv.broadcast(signal2);
SWTBotUtils.waitForJobs();
SWTBotUtils.delay(1000);
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009, 2014 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:
- * Francois Chouinard - Initial API and implementation
- * Patrick Tasse - Deprecate current time
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.signal;
-
-import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
-
-/**
- * A new time range has been selected.
- *
- * This is the visible (zoom) time range. To synchronize on the selection range,
- * use {@link TmfTimeSynchSignal}.
- *
- * @author Francois Chouinard
- */
-public class TmfRangeSynchSignal extends TmfSignal {
-
- private final TmfTimeRange fCurrentRange;
-
- /**
- * Constructor
- *
- * @param source
- * Object sending this signal
- * @param range
- * The new time range
- */
- public TmfRangeSynchSignal(Object source, TmfTimeRange range) {
- super(source);
- fCurrentRange = range;
- }
-
- /**
- * @return This signal's time range
- */
- public TmfTimeRange getCurrentRange() {
- return fCurrentRange;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder("TmfRangeSynchSignal [source="); //$NON-NLS-1$
-
- if (getSource() != null) {
- sb.append(getSource().toString());
- } else {
- sb.append("null"); //$NON-NLS-1$
- }
-
- sb.append(", range="); //$NON-NLS-1$
-
- if (fCurrentRange != null) {
- sb.append(fCurrentRange.toString());
- } else {
- sb.append("null"); //$NON-NLS-1$
- }
- sb.append(']');
- return sb.toString();
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 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:
+ * Francois Chouinard - Initial API and implementation
+ * Patrick Tasse - Support selection range
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.signal;
+
+import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
+
+/**
+ * A new time range selection has been made.
+ *
+ * This is the selected time or time range. A single-timestamp selection is
+ * represented by a range where the start time is equal to the end time.
+ *
+ * To update the visible (zoom) range instead, use
+ * {@link TmfWindowRangeUpdatedSignal}.
+ *
+ * @author Francois Chouinard
+ * @since 1.0
+ */
+@NonNullByDefault
+public class TmfSelectionRangeUpdatedSignal extends TmfSignal {
+
+ private final ITmfTimestamp fBeginTime;
+ private final ITmfTimestamp fEndTime;
+
+ /**
+ * Constructor for a single timestamp selection (start and end times will be
+ * the same).
+ *
+ * @param source
+ * Object sending this signal
+ * @param ts
+ * Timestamp of selection
+ */
+ public TmfSelectionRangeUpdatedSignal(@Nullable Object source, ITmfTimestamp ts) {
+ super(source);
+ fBeginTime = ts;
+ fEndTime = ts;
+ }
+
+ /**
+ * Constructor for a time range selection.
+ *
+ * @param source
+ * Object sending this signal
+ * @param begin
+ * Timestamp of begin of selection range
+ * @param end
+ * Timestamp of end of selection range
+ */
+ public TmfSelectionRangeUpdatedSignal(@Nullable Object source, ITmfTimestamp begin, ITmfTimestamp end) {
+ super(source);
+ fBeginTime = begin;
+ fEndTime = end;
+ }
+
+ /**
+ * @return The begin timestamp of selection
+ */
+ public ITmfTimestamp getBeginTime() {
+ return fBeginTime;
+ }
+
+ /**
+ * @return The end timestamp of selection
+ */
+ public ITmfTimestamp getEndTime() {
+ return fEndTime;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(getClass().getSimpleName());
+ sb.append(" ["); //$NON-NLS-1$
+ sb.append(fBeginTime.toString());
+ if (!fBeginTime.equals(fEndTime)) {
+ sb.append('-');
+ sb.append(fEndTime.toString());
+ }
+ sb.append("]"); //$NON-NLS-1$
+ return checkNotNull(sb.toString());
+ }
+
+}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009, 2014 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:
- * Francois Chouinard - Initial API and implementation
- * Patrick Tasse - Support selection range
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.signal;
-
-import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
-
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
-
-/**
- * A new time or time range selection has been made.
- *
- * This is the selected time or time range. To synchronize on the visible
- * (zoom) range, use {@link TmfRangeSynchSignal}.
- *
- * @author Francois Chouinard
-*/
-@NonNullByDefault
-public class TmfTimeSynchSignal extends TmfSignal {
-
- private final ITmfTimestamp fBeginTime;
- private final ITmfTimestamp fEndTime;
-
- /**
- * Constructor
- *
- * @param source
- * Object sending this signal
- * @param ts
- * Timestamp of selection
- */
- public TmfTimeSynchSignal(@Nullable Object source, ITmfTimestamp ts) {
- super(source);
- fBeginTime = ts;
- fEndTime = ts;
- }
-
- /**
- * Constructor
- *
- * @param source
- * Object sending this signal
- * @param begin
- * Timestamp of begin of selection range
- * @param end
- * Timestamp of end of selection range
- */
- public TmfTimeSynchSignal(@Nullable Object source, ITmfTimestamp begin, ITmfTimestamp end) {
- super(source);
- fBeginTime = begin;
- fEndTime = end;
- }
-
- /**
- * @return The begin timestamp of selection
- */
- public ITmfTimestamp getBeginTime() {
- return fBeginTime;
- }
-
- /**
- * @return The end timestamp of selection
- */
- public ITmfTimestamp getEndTime() {
- return fEndTime;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append("[TmfTimeSynchSignal ("); //$NON-NLS-1$
- sb.append(fBeginTime.toString());
- if (!fBeginTime.equals(fEndTime)) {
- sb.append('-');
- sb.append(fEndTime.toString());
- }
- sb.append(")]"); //$NON-NLS-1$
- return checkNotNull(sb.toString());
- }
-
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 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:
+ * Francois Chouinard - Initial API and implementation
+ * Patrick Tasse - Deprecate current time
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.signal;
+
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
+
+/**
+ * A new range has been selected for the visible (zoom) time range.
+ *
+ * To update the selection range instead, use
+ * {@link TmfSelectionRangeUpdatedSignal}.
+ *
+ * @author Francois Chouinard
+ * @since 1.0
+ */
+public class TmfWindowRangeUpdatedSignal extends TmfSignal {
+
+ private final TmfTimeRange fCurrentRange;
+
+ /**
+ * Constructor
+ *
+ * @param source
+ * Object sending this signal
+ * @param range
+ * The new time range
+ */
+ public TmfWindowRangeUpdatedSignal(Object source, TmfTimeRange range) {
+ super(source);
+ fCurrentRange = range;
+ }
+
+ /**
+ * @return This signal's time range
+ */
+ public TmfTimeRange getCurrentRange() {
+ return fCurrentRange;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder(getClass().getSimpleName() + " [source="); //$NON-NLS-1$
+
+ if (getSource() != null) {
+ sb.append(getSource().toString());
+ } else {
+ sb.append("null"); //$NON-NLS-1$
+ }
+
+ sb.append(", range="); //$NON-NLS-1$
+
+ if (fCurrentRange != null) {
+ sb.append(fCurrentRange.toString());
+ } else {
+ sb.append("null"); //$NON-NLS-1$
+ }
+ sb.append(']');
+ return sb.toString();
+ }
+}
import org.eclipse.tracecompass.internal.tmf.core.Activator;
import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
import org.eclipse.tracecompass.tmf.core.signal.TmfEventFilterAppliedSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
}
/**
- * Signal handler for the TmfTimeSynchSignal signal.
+ * Signal handler for the selection range signal.
*
* The current time of *all* traces whose range contains the requested new
* selection time range will be updated.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public synchronized void timeUpdated(final TmfTimeSynchSignal signal) {
+ public synchronized void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
final ITmfTimestamp beginTs = signal.getBeginTime();
final ITmfTimestamp endTs = signal.getEndTime();
}
/**
- * Signal handler for the TmfRangeSynchSignal signal.
+ * Signal handler for the window range signal.
*
* The current window time range of *all* valid traces will be updated to
* the new requested times.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public synchronized void timeRangeUpdated(final TmfRangeSynchSignal signal) {
+ public synchronized void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
for (Map.Entry<ITmfTrace, TmfTraceContext> entry : fTraces.entrySet()) {
final ITmfTrace trace = entry.getKey();
final TmfTraceContext prevCtx = checkNotNull(entry.getValue());
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
ForegroundRequest foreground3 = new ForegroundRequest(TmfTimeRange.ETERNITY);
fixture.sendRequest(foreground3);
- TmfTimeSynchSignal signal3 = new TmfTimeSynchSignal(this, new TmfTimestamp(fForegroundTimeRange.getStartTime()));
+ TmfSelectionRangeUpdatedSignal signal3 = new TmfSelectionRangeUpdatedSignal(this, new TmfTimestamp(fForegroundTimeRange.getStartTime()));
fixture.broadcast(signal3);
try {
public void TestMultiRequest4() {
ForegroundRequest foreground4 = new ForegroundRequest(fForegroundTimeRange);
fixture.sendRequest(foreground4);
- TmfTimeSynchSignal signal4 = new TmfTimeSynchSignal(this, new TmfTimestamp(fStartTime + ((fEndTime - fStartTime) / 8)));
+ TmfSelectionRangeUpdatedSignal signal4 = new TmfSelectionRangeUpdatedSignal(this, new TmfTimestamp(fStartTime + ((fEndTime - fStartTime) / 8)));
fixture.broadcast(signal4);
try {
public void TestMultiRequest5() {
ForegroundRequest foreground5 = new ForegroundRequest(fForegroundTimeRange);
fixture.sendRequest(foreground5);
- TmfTimeSynchSignal signal5 = new TmfTimeSynchSignal(this, new TmfTimestamp(fEndTime - ((fEndTime - fStartTime) / 4)));
+ TmfSelectionRangeUpdatedSignal signal5 = new TmfSelectionRangeUpdatedSignal(this, new TmfTimestamp(fEndTime - ((fEndTime - fStartTime) / 4)));
fixture.broadcast(signal5);
try {
fixture.sendRequest(background6);
fixture.sendRequest(foreground6);
- TmfTimeSynchSignal signal6 = new TmfTimeSynchSignal(this, new TmfTimestamp(fStartTime + ((fEndTime - fStartTime) / 8)));
+ TmfSelectionRangeUpdatedSignal signal6 = new TmfSelectionRangeUpdatedSignal(this, new TmfTimestamp(fStartTime + ((fEndTime - fStartTime) / 8)));
fixture.broadcast(signal6);
try {
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
}
private void selectTimestamp(@NonNull ITmfTimestamp ts) {
- TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(this, ts));
+ TmfSignalManager.dispatchSignal(new TmfSelectionRangeUpdatedSignal(this, ts));
}
private void selectWindowRange(TmfTimeRange tr) {
- TmfSignalManager.dispatchSignal(new TmfRangeSynchSignal(this, tr));
+ TmfSignalManager.dispatchSignal(new TmfWindowRangeUpdatedSignal(this, tr));
}
// ------------------------------------------------------------------------
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
}
}
HistogramView hv = (HistogramView) vp;
- final TmfTimeSynchSignal signal = new TmfTimeSynchSignal(hv, desiredEvent1.getTimestamp());
- final TmfTimeSynchSignal signal2 = new TmfTimeSynchSignal(hv, desiredEvent2.getTimestamp());
+ final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(hv, desiredEvent1.getTimestamp());
+ final TmfSelectionRangeUpdatedSignal signal2 = new TmfSelectionRangeUpdatedSignal(hv, desiredEvent2.getTimestamp());
hv.updateTimeRange(100000);
SWTBotUtils.waitForJobs();
- hv.currentTimeUpdated(signal);
+ hv.selectionRangeUpdated(signal);
hv.broadcast(signal);
SWTBotUtils.waitForJobs();
SWTBotUtils.delay(1000);
hv.updateTimeRange(1000000000);
SWTBotUtils.waitForJobs();
- hv.currentTimeUpdated(signal2);
+ hv.selectionRangeUpdated(signal2);
hv.broadcast(signal2);
SWTBotUtils.waitForJobs();
SWTBotUtils.delay(1000);
import org.eclipse.tracecompass.internal.tmf.pcap.ui.NetworkingPerspectiveFactory;
import org.eclipse.tracecompass.internal.tmf.pcap.ui.stream.StreamListView;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.pcap.core.tests.shared.PcapTmfTestTrace;
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
botView.setFocus();
SWTBotTree botTree = fBot.tree();
assertNotNull(botTree);
- final TmfTimeSynchSignal signal = new TmfTimeSynchSignal(slv, fDesired1.getTimestamp());
+ final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(slv, fDesired1.getTimestamp());
slv.broadcast(signal);
SWTBotUtils.waitForJobs();
// FIXME This is a race condition:
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode;
rangeWindow = (TmfTimestamp) range.getEndTime().getDelta(range.getStartTime());
TmfTimestamp currentTime = new Uml2SDTestTimestamp(9789773782043L);
- fFacility.getTrace().broadcast(new TmfRangeSynchSignal(fFacility, range));
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(fFacility, currentTime));
+ fFacility.getTrace().broadcast(new TmfWindowRangeUpdatedSignal(fFacility, range));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(fFacility, currentTime));
fFacility.delay(IUml2SDTestConstants.BROADCAST_DELAY);
fTmfComponent = new Uml2SDSignalValidator();
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode;
*/
@Test
public void verifySynchToTimeInPage() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TC_001_TIME_VALUE));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TC_001_TIME_VALUE));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_001_PAGE_VALUE, fFacility.getLoader().currentPage());
*/
@Test
public void verifySynchToTimeOutsidePage() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TC_002_TIME_VALUE));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TC_002_TIME_VALUE));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_002_PAGE_VALUE, fFacility.getLoader().currentPage());
public void verifySynchToTimeNonExisting() {
fFacility.getLoader().firstPage();
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TC_003_TIME_VALUE));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TC_003_TIME_VALUE));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", 0, TC_003_TIME_VALUE.compareTo(fFacility.getLoader().getCurrentTime()));
*/
@Test
public void verifySynchToTimeBeforeExpStart() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TmfTimestamp.BIG_BANG));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.BIG_BANG));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_004_PAGE_VALUE, fFacility.getLoader().currentPage());
*/
@Test
public void verifySynchToTimeAfterExpEnd() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TmfTimestamp.BIG_CRUNCH));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.BIG_CRUNCH));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_005_PAGE_VALUE, fFacility.getLoader().currentPage());
*/
@Test
public void verifySynchToTimeEqualsLast() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TC_006_TIME_VALUE));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TC_006_TIME_VALUE));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_006_PAGE_VALUE, fFacility.getLoader().currentPage());
*/
@Test
public void verifySynchToTimeFirst() {
- fFacility.getTrace().broadcast(new TmfTimeSynchSignal(this, TC_007_TIME_VALUE));
+ fFacility.getTrace().broadcast(new TmfSelectionRangeUpdatedSignal(this, TC_007_TIME_VALUE));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTime", TC_007_PAGE_VALUE, fFacility.getLoader().currentPage());
TmfTimeRange range = new TmfTimeRange(TC_008_START_TIME_VALUE, TC_008_END_TIME_VALUE);
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
- fFacility.getTrace().broadcast(new TmfRangeSynchSignal(this, range));
+ fFacility.getTrace().broadcast(new TmfWindowRangeUpdatedSignal(this, range));
assertEquals("synchToTimeRange", TC_008_PAGE_VALUE, fFacility.getLoader().currentPage());
assertNotNull("synchToTimeRange", fFacility.getLoader().getCurrentTime());
assertEquals("synchToTimeRange", 0, TC_008_TIME_VALUE.compareTo(fFacility.getLoader().getCurrentTime()));
@Test
public void verifyTimeRangeDifferentPages() {
TmfTimeRange range = new TmfTimeRange(TC_009_START_TIME_VALUE, TC_009_END_TIME_VALUE);
- fFacility.getTrace().broadcast(new TmfRangeSynchSignal(this, range));
+ fFacility.getTrace().broadcast(new TmfWindowRangeUpdatedSignal(this, range));
fFacility.getLoader().waitForCompletion();
fFacility.delay(IUml2SDTestConstants.GUI_REFESH_DELAY);
assertEquals("synchToTimeRange", TC_009_PAGE_VALUE, fFacility.getLoader().currentPage());
import org.eclipse.tracecompass.tmf.core.component.TmfComponent;
import org.eclipse.tracecompass.tmf.core.signal.TmfEndSynchSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfStartSynchSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
* @param signal the signal to handle.
*/
@TmfSignalHandler
- public void synchToTime(TmfTimeSynchSignal signal) {
+ public void synchToTime(TmfSelectionRangeUpdatedSignal signal) {
// Set results so that it can be validated in the test case
setSignalReceived(true);
setSourceError(getSource() != signal.getSource());
}
/**
- * Signal handler for time range synch signal.
+ * Signal handler for window range signal.
* @param signal the signal to handle.
*/
@TmfSignalHandler
- public void synchToTimeRange(TmfRangeSynchSignal signal) {
+ public void synchToTimeRange(TmfWindowRangeUpdatedSignal signal) {
// Set results so that it can be validated in the test case
setSignalReceived(true);
if (getSource() != null) {
import org.eclipse.tracecompass.tmf.core.signal.TmfEventSelectedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
* the event selected signal
*/
@TmfSignalHandler
- public void timeSelected(final TmfTimeSynchSignal signal) {
+ public void timeSelected(final TmfSelectionRangeUpdatedSignal signal) {
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
package org.eclipse.tracecompass.tmf.ui.viewers;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalThrottler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
final ITmfTimestamp startTimestamp = new TmfTimestamp(getSelectionBeginTime(), ITmfTimestamp.NANOSECOND_SCALE);
final ITmfTimestamp endTimestamp = new TmfTimestamp(getSelectionEndTime(), ITmfTimestamp.NANOSECOND_SCALE);
- TmfTimeSynchSignal signal = new TmfTimeSynchSignal(this, startTimestamp, endTimestamp);
+ TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(this, startTimestamp, endTimestamp);
broadcast(signal);
}
}
new TmfTimestamp(getWindowEndTime(), ITmfTimestamp.NANOSECOND_SCALE));
// Send the signal
- TmfRangeSynchSignal signal = new TmfRangeSynchSignal(this, timeRange);
+ TmfWindowRangeUpdatedSignal signal = new TmfWindowRangeUpdatedSignal(this, timeRange);
fTimeRangeSyncThrottle.queue(signal);
}
}
/**
- * Signal handler for handling of the time synch signal, ie the selected range.
+ * Signal handler for handling of the selected range signal.
*
* @param signal
- * The time synch signal {@link TmfTimeSynchSignal}
+ * The {@link TmfSelectionRangeUpdatedSignal}
+ * @since 1.0
*/
@TmfSignalHandler
- public void selectionRangeUpdated(TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
if ((signal.getSource() != this) && (fTrace != null)) {
ITmfTimestamp selectedTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
ITmfTimestamp selectedEndTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
}
/**
- * Signal handler for handling of the time range synch signal, ie the visible range.
+ * Signal handler for handling of the window range signal.
*
* @param signal
- * The time range synch signal {@link TmfRangeSynchSignal}
+ * The {@link TmfWindowRangeUpdatedSignal}
+ * @since 1.0
*/
@TmfSignalHandler
- public void timeRangeUpdated(TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(TmfWindowRangeUpdatedSignal signal) {
if (fTrace != null) {
// Validate the time range
import org.eclipse.tracecompass.tmf.core.signal.TmfEventSearchAppliedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfEventSelectedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
ITmfTimestamp selectedBeginTimestamp = fSelectedBeginTimestamp;
if (selectedBeginTimestamp != null) {
if (selectedBeginTimestamp.compareTo(ts) <= 0) {
- broadcast(new TmfTimeSynchSignal(TmfEventsTable.this, selectedBeginTimestamp, ts));
+ broadcast(new TmfSelectionRangeUpdatedSignal(TmfEventsTable.this, selectedBeginTimestamp, ts));
if (fTable.getSelectionIndices().length == 2) {
updateStatusLine(ts.getDelta(selectedBeginTimestamp));
}
} else {
- broadcast(new TmfTimeSynchSignal(TmfEventsTable.this, checkNotNull(ts), checkNotNull(fSelectedBeginTimestamp)));
+ broadcast(new TmfSelectionRangeUpdatedSignal(TmfEventsTable.this, checkNotNull(ts), checkNotNull(fSelectedBeginTimestamp)));
updateStatusLine(fSelectedBeginTimestamp.getDelta(ts));
}
}
TableItem item = fTable.getSelection()[0];
final TmfTimestamp ts = (TmfTimestamp) item.getData(Key.TIMESTAMP);
if (ts != null) {
- broadcast(new TmfTimeSynchSignal(TmfEventsTable.this, ts));
+ broadcast(new TmfSelectionRangeUpdatedSignal(TmfEventsTable.this, ts));
}
if (item.getData() instanceof ITmfEvent) {
broadcast(new TmfEventSelectedSignal(TmfEventsTable.this, (ITmfEvent) item.getData()));
fSelectedRank = foundRank;
fRawViewer.selectAndReveal(fSelectedRank);
if (foundTimestamp != null) {
- broadcast(new TmfTimeSynchSignal(TmfEventsTable.this, foundTimestamp));
+ broadcast(new TmfSelectionRangeUpdatedSignal(TmfEventsTable.this, foundTimestamp));
}
fireSelectionChanged(new SelectionChangedEvent(TmfEventsTable.this, getSelection()));
synchronized (fSearchSyncObj) {
}
/**
- * Handler for the time synch signal.
+ * Handler for the selection range signal.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void currentTimeUpdated(final TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
if ((signal.getSource() != this) && (fTrace != null) && (!fTable.isDisposed())) {
// Create a request for one event that will be queued after other ongoing requests. When this request is completed
import org.eclipse.tracecompass.tmf.core.component.TmfComponent;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.statistics.ITmfStatistics;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsEventTypesModule;
*
* @param signal
* Contains the information about the new selected time range.
+ * @since 1.0
*/
@TmfSignalHandler
- public void timeSynchUpdated(TmfTimeSynchSignal signal) {
+ public void timeSynchUpdated(TmfSelectionRangeUpdatedSignal signal) {
if (fTrace == null) {
return;
}
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.ui.viewers.TmfTimeViewer;
* correspond to the selection by the user, not the visible time range.
*
* @param signal
- * The time synch signal {@link TmfTimeSynchSignal}
+ * The time synch signal {@link TmfSelectionRangeUpdatedSignal}
*/
@Override
@TmfSignalHandler
- public void selectionRangeUpdated(TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
super.selectionRangeUpdated(signal);
if ((signal.getSource() != this) && (getTrace() != null)) {
updateContent(this.getSelectionBeginTime(), this.getSelectionEndTime(), true);
}
/**
- * Signal handler for handling of the time range synch signal. This time
- * range is the visible zone of the view.
+ * Signal handler for handling of the window range signal. This time range
+ * is the visible zone of the view.
*
* @param signal
- * The time range synch signal {@link TmfRangeSynchSignal}
+ * The {@link TmfWindowRangeUpdatedSignal}
*/
@Override
@TmfSignalHandler
- public void timeRangeUpdated(TmfRangeSynchSignal signal) {
- super.timeRangeUpdated(signal);
+ public void windowRangeUpdated(TmfWindowRangeUpdatedSignal signal) {
+ super.windowRangeUpdated(signal);
updateContent(this.getWindowStartTime(), this.getWindowEndTime(), false);
}
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTimestampFormatUpdateSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.ui.viewers.TmfTimeViewer;
* Signal handler for handling of the time synch signal.
*
* @param signal
- * The time synch signal {@link TmfTimeSynchSignal}
+ * The time synch signal {@link TmfSelectionRangeUpdatedSignal}
*/
@Override
@TmfSignalHandler
- public void selectionRangeUpdated(TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
super.selectionRangeUpdated(signal);
if ((signal.getSource() != this) && (getTrace() != null)) {
if (fMouseSelectionProvider != null) {
}
/**
- * Signal handler for handling of the time range synch signal.
+ * Signal handler for handling of the window range signal.
*
* @param signal
- * The time range synch signal {@link TmfRangeSynchSignal}
+ * The {@link TmfWindowRangeUpdatedSignal}
*/
@Override
@TmfSignalHandler
- public void timeRangeUpdated(TmfRangeSynchSignal signal) {
- super.timeRangeUpdated(signal);
+ public void windowRangeUpdated(TmfWindowRangeUpdatedSignal signal) {
+ super.windowRangeUpdated(signal);
updateContent();
}
import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue.Type;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
private final Object fSyncObj = new Object();
// The saved time sync. signal used when switching off the pinning of a view
- private TmfTimeSynchSignal fSavedTimeSyncSignal;
+ private TmfSelectionRangeUpdatedSignal fSavedTimeSyncSignal;
- // The saved time range sync. signal used when switching off the pinning of
+ // The saved window range signal used when switching off the pinning of
// a view
- private TmfRangeSynchSignal fSavedRangeSyncSignal;
+ private TmfWindowRangeUpdatedSignal fSavedRangeSyncSignal;
// ------------------------------------------------------------------------
// Classes
long startTime = event.getStartTime();
long endTime = event.getEndTime();
TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(startTime), new TmfNanoTimestamp(endTime));
- broadcast(new TmfRangeSynchSignal(CallStackView.this, range));
+ broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
startZoomThread(startTime, endTime);
}
});
long beginTime = event.getBeginTime();
long endTime = event.getEndTime();
synchingToTime(beginTime);
- broadcast(new TmfTimeSynchSignal(CallStackView.this, new TmfNanoTimestamp(beginTime), new TmfNanoTimestamp(endTime)));
+ broadcast(new TmfSelectionRangeUpdatedSignal(CallStackView.this, new TmfNanoTimestamp(beginTime), new TmfNanoTimestamp(endTime)));
}
});
entryTime -= spacingTime;
exitTime += spacingTime;
TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(entryTime), new TmfNanoTimestamp(exitTime));
- broadcast(new TmfRangeSynchSignal(CallStackView.this, range));
+ broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(entryTime, exitTime);
startZoomThread(entryTime, exitTime);
}
startTime -= spacingTime;
endTime += spacingTime;
TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(startTime), new TmfNanoTimestamp(endTime));
- broadcast(new TmfRangeSynchSignal(CallStackView.this, range));
+ broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(startTime, endTime);
startZoomThread(startTime, endTime);
}
}
/**
- * Handler for the TimeSynch signal
+ * Handler for the selection range signal.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToTime(final TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
- fSavedTimeSyncSignal = isPinned() ? new TmfTimeSynchSignal(signal.getSource(), signal.getBeginTime(), signal.getEndTime()) : null;
+ fSavedTimeSyncSignal = isPinned() ? new TmfSelectionRangeUpdatedSignal(signal.getSource(), signal.getBeginTime(), signal.getEndTime()) : null;
if (signal.getSource() == this || fTrace == null || isPinned()) {
return;
}
/**
- * Handler for the RangeSynch signal
+ * Handler for the window range signal.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToRange(final TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
if (isPinned()) {
fSavedRangeSyncSignal =
- new TmfRangeSynchSignal(signal.getSource(), new TmfTimeRange(signal.getCurrentRange().getStartTime(), signal.getCurrentRange().getEndTime()));
+ new TmfWindowRangeUpdatedSignal(signal.getSource(), new TmfTimeRange(signal.getCurrentRange().getStartTime(), signal.getCurrentRange().getEndTime()));
fSavedTimeSyncSignal = null;
}
public void propertyChange(PropertyChangeEvent event) {
if (IAction.CHECKED.equals(event.getProperty()) && !isPinned()) {
if (fSavedRangeSyncSignal != null) {
- synchToRange(fSavedRangeSyncSignal);
+ windowRangeUpdated(fSavedRangeSyncSignal);
fSavedRangeSyncSignal = null;
}
if (fSavedTimeSyncSignal != null) {
- synchToTime(fSavedTimeSyncSignal);
+ selectionRangeUpdated(fSavedTimeSyncSignal);
fSavedTimeSyncSignal = null;
}
}
import org.eclipse.tracecompass.internal.tmf.ui.ITmfImageConstants;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalThrottler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
updateDisplayedSelectionTime(beginTime, endTime);
TmfTimestamp beginTs = new TmfTimestamp(beginTime, ITmfTimestamp.NANOSECOND_SCALE);
TmfTimestamp endTs = new TmfTimestamp(endTime, ITmfTimestamp.NANOSECOND_SCALE);
- TmfTimeSynchSignal signal = new TmfTimeSynchSignal(this, beginTs, endTs);
+ TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(this, beginTs, endTs);
fTimeSyncThrottle.queue(signal);
}
updateDisplayedTimeRange(startTime, endTime);
// Send the FW signal
- TmfRangeSynchSignal signal = new TmfRangeSynchSignal(this, timeRange);
+ TmfWindowRangeUpdatedSignal signal = new TmfWindowRangeUpdatedSignal(this, timeRange);
fTimeRangeSyncThrottle.queue(signal);
}
}
}
/**
- * Handles the current time updated signal. Sets the current time in the time range
- * histogram as well as the full histogram.
+ * Handles the selection range updated signal. Sets the current time
+ * selection in the time range histogram as well as the full histogram.
*
- * @param signal the signal to process
+ * @param signal
+ * the signal to process
+ * @since 1.0
*/
@TmfSignalHandler
- public void currentTimeUpdated(final TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
if (Display.getCurrent() == null) {
// Make sure the signal is handled in the UI thread
Display.getDefault().asyncExec(new Runnable() {
if (fParent.isDisposed()) {
return;
}
- currentTimeUpdated(signal);
+ selectionRangeUpdated(signal);
}
});
return;
}
/**
- * Updates the current time range in the time range histogram and full range histogram.
- * @param signal the signal to process
+ * Updates the current window time range in the time range histogram and
+ * full range histogram.
+ *
+ * @param signal
+ * the signal to process
+ * @since 1.0
*/
@TmfSignalHandler
- public void timeRangeUpdated(final TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
if (Display.getCurrent() == null) {
// Make sure the signal is handled in the UI thread
Display.getDefault().asyncExec(new Runnable() {
if (fParent.isDisposed()) {
return;
}
- timeRangeUpdated(signal);
+ windowRangeUpdated(signal);
}
});
return;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.signal.TmfEventFilterAppliedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfEventSearchAppliedSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
final ITmfTimestamp startTimestamp = new TmfTimestamp(event.getStartTime(), ITmfTimestamp.NANOSECOND_SCALE);
final ITmfTimestamp endTimestamp = new TmfTimestamp(event.getEndTime(), ITmfTimestamp.NANOSECOND_SCALE);
TmfTimeRange range = new TmfTimeRange(startTimestamp, endTimestamp);
- broadcast(new TmfRangeSynchSignal(this, range));
+ broadcast(new TmfWindowRangeUpdatedSignal(this, range));
}
@Override
@Override
public void timeSelected(TimeGraphTimeEvent event) {
- broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getBeginTime(), TIMESTAMP_SCALE), new TmfTimestamp(event.getEndTime(), TIMESTAMP_SCALE)));
+ broadcast(new TmfSelectionRangeUpdatedSignal(this, new TmfTimestamp(event.getBeginTime(), TIMESTAMP_SCALE), new TmfTimestamp(event.getEndTime(), TIMESTAMP_SCALE)));
}
@Override
}
/**
- * Handler for the Time Synch signal
+ * Handler for the selection range updated signal.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void currentTimeUpdated(TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
final long beginTime = signal.getBeginTime().normalize(0, TIMESTAMP_SCALE).getValue();
final long endTime = signal.getEndTime().normalize(0, TIMESTAMP_SCALE).getValue();
Display.getDefault().asyncExec(new Runnable() {
}
/**
- * Handler for the Time Range Synch signal
+ * Handler for the window range updated signal.
*
* @param signal
* The incoming signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToRange(final TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
if (signal.getSource() == this) {
return;
}
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.TreeColumn;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTimestampFormatUpdateSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
final long startTime = event.getStartTime();
final long endTime = event.getEndTime();
TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(startTime), new TmfNanoTimestamp(endTime));
- broadcast(new TmfRangeSynchSignal(AbstractTimeGraphView.this, range));
+ broadcast(new TmfWindowRangeUpdatedSignal(AbstractTimeGraphView.this, range));
startZoomThread(startTime, endTime);
}
});
public void timeSelected(TimeGraphTimeEvent event) {
TmfNanoTimestamp startTime = new TmfNanoTimestamp(event.getBeginTime());
TmfNanoTimestamp endTime = new TmfNanoTimestamp(event.getEndTime());
- broadcast(new TmfTimeSynchSignal(AbstractTimeGraphView.this, startTime, endTime));
+ broadcast(new TmfSelectionRangeUpdatedSignal(AbstractTimeGraphView.this, startTime, endTime));
}
});
}
/**
- * Handler for the time synch signal
+ * Handler for the selection range signal.
*
* @param signal
* The signal that's received
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToTime(final TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
if (signal.getSource() == this || fTrace == null) {
return;
}
}
/**
- * Handler for the range synch signal
+ * Handler for the window range signal.
*
* @param signal
* The signal that's received
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToRange(final TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
if (signal.getSource() == this || fTrace == null) {
return;
}
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
}
/**
- * Moves to the page that contains the time provided by the signal. The messages will be selected
- * if the provided time is the time of a message.
+ * Moves to the page that contains the time provided by the signal. The
+ * messages will be selected if the provided time is the time of a message.
*
- * @param signal The Time synch signal.
+ * @param signal
+ * The selection range signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToTime(TmfTimeSynchSignal signal) {
+ public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
fLock.lock();
try {
if ((signal.getSource() != this) && (fFrame != null) && (fCheckPoints.size() > 0)) {
}
/**
- * Moves to the page that contains the current time provided by signal.
- * No message will be selected however the focus will be set to the message
- * if the provided time is the time of a message.
+ * Moves to the page that contains the current time provided by signal. No
+ * message will be selected however the focus will be set to the message if
+ * the provided time is the time of a message.
*
- * @param signal The time range sync signal
+ * @param signal
+ * The window range signal
+ * @since 1.0
*/
@TmfSignalHandler
- public void synchToTimeRange(TmfRangeSynchSignal signal) {
+ public void windowRangeUpdated(TmfWindowRangeUpdatedSignal signal) {
fLock.lock();
try {
if ((signal.getSource() != this) && (fFrame != null) && !fIsSignalSent && (fCheckPoints.size() > 0)) {
if (startTime == null) {
startTime = TmfTimestamp.BIG_BANG;
}
- broadcast(new TmfTimeSynchSignal(this, startTime));
+ broadcast(new TmfSelectionRangeUpdatedSignal(this, startTime));
}
}
}
if (notifyAll) {
TmfTimeRange timeRange = getSignalTimeRange(window.getStartTime());
- broadcast(new TmfRangeSynchSignal(this, timeRange));
+ broadcast(new TmfWindowRangeUpdatedSignal(this, timeRange));
}
}
projects / deliverable / tracecompass.git / commitdiff
