org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/widgets/timegraph/widgets/TimeDataProviderCyclesConverter.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets;
  14
  15 import org.eclipse.jdt.annotation.NonNull;
  16 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  17
  18 /**
  19  * Time Data Provider wrapper that converts nanoseconds to cycles.
  20  *
  21  * The user of the wrapper uses cycles, the wrapped provider uses nanoseconds.
  22  */
  23 public class TimeDataProviderCyclesConverter implements ITimeDataProviderConverter {
  24
  25     private static final long GIGAHERTZ = 1000000000L;
  26
  27     private final @NonNull ITimeDataProvider fProvider;
  28     private final long fFreq;
  29
  30     /**
  31      * Constructor
  32      *
  33      * @param provider
  34      *            the original time data provider
  35      * @param clockFrequency
  36      *            the clock frequency in Hz
  37      */
  38     public TimeDataProviderCyclesConverter(@NonNull ITimeDataProvider provider, long clockFrequency) {
  39         fProvider = provider;
  40         fFreq = clockFrequency;
  41     }
  42
  43     /**
  44      * Convert nanoseconds to cycles
  45      *
  46      * @param nanos
  47      *            time in nanoseconds
  48      * @return time in cycles
  49      */
  50     public long toCycles(long nanos) {
  51         return Math.round(nanos * ((double) fFreq / GIGAHERTZ));
  52     }
  53
  54     /**
  55      * Convert cycles to nanoseconds
  56      *
  57      * @param cycles
  58      *            time in cycles
  59      * @return time in nanoseconds
  60      */
  61     public long toNanos(long cycles) {
  62         return Math.round(cycles * ((double) GIGAHERTZ / fFreq));
  63     }
  64
  65     @Override
  66     public long convertTime(long time) {
  67         return toCycles(time);
  68     }
  69
  70     @Override
  71     public void setSelectionRangeNotify(long beginTime, long endTime) {
  72         fProvider.setSelectionRangeNotify(toNanos(beginTime), toNanos(endTime));
  73     }
  74
  75     @Override
  76     public void setSelectionRange(long beginTime, long endTime) {
  77         fProvider.setSelectionRange(toNanos(beginTime), toNanos(endTime));
  78     }
  79
  80     @Override
  81     public long getSelectionBegin() {
  82         return toCycles(fProvider.getSelectionBegin());
  83     }
  84
  85     @Override
  86     public long getSelectionEnd() {
  87         return toCycles(fProvider.getSelectionEnd());
  88     }
  89
  90     @Override
  91     public long getBeginTime() {
  92         return toCycles(fProvider.getBeginTime());
  93     }
  94
  95     @Override
  96     public long getEndTime() {
  97         return toCycles(fProvider.getEndTime());
  98     }
  99
 100     @Override
 101     public long getMinTime() {
 102         return toCycles(fProvider.getMinTime());
 103     }
 104
 105     @Override
 106     public long getMaxTime() {
 107         return toCycles(fProvider.getMaxTime());
 108     }
 109
 110     @Override
 111     public long getTime0() {
 112         return toCycles(fProvider.getTime0());
 113     }
 114
 115     @Override
 116     public long getTime1() {
 117         return toCycles(fProvider.getTime1());
 118     }
 119
 120     @Override
 121     public long getMinTimeInterval() {
 122         // do not convert: this is in integer units
 123         return fProvider.getMinTimeInterval();
 124     }
 125
 126     @Override
 127     public void setStartFinishTimeNotify(long time0, long time1) {
 128         fProvider.setStartFinishTimeNotify(toNanos(time0), toNanos(time1));
 129     }
 130
 131     @Override
 132     public void setStartFinishTime(long time0, long time1) {
 133         fProvider.setStartFinishTime(toNanos(time0), toNanos(time1));
 134     }
 135
 136     @Override
 137     public void notifyStartFinishTime() {
 138         fProvider.notifyStartFinishTime();
 139     }
 140
 141     @Override
 142     public void setSelectedTimeNotify(long time, boolean ensureVisible) {
 143         fProvider.setSelectedTimeNotify(toNanos(time), ensureVisible);
 144     }
 145
 146     @Override
 147     public void setSelectedTime(long time, boolean ensureVisible) {
 148         fProvider.setSelectedTime(toNanos(time), ensureVisible);
 149     }
 150
 151     @Override
 152     public void resetStartFinishTime() {
 153         fProvider.resetStartFinishTime();
 154     }
 155
 156     @Override
 157     public int getNameSpace() {
 158         return fProvider.getNameSpace();
 159     }
 160
 161     @Override
 162     public void setNameSpace(int width) {
 163         fProvider.setNameSpace(width);
 164     }
 165
 166     @Override
 167     public int getTimeSpace() {
 168         return fProvider.getTimeSpace();
 169     }
 170
 171     @Override
 172     public TimeFormat getTimeFormat() {
 173         return fProvider.getTimeFormat();
 174     }
 175
 176 }