org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/widgets/timegraph/widgets/Utils.java

   1 /*****************************************************************************
   2  * Copyright (c) 2007, 2008 Intel Corporation, 2009, 2012 Ericsson.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *   Intel Corporation - Initial API and implementation
  10  *   Ruslan A. Scherbakov, Intel - Initial API and implementation
  11  *   Alvaro Sanchez-Leon - Udpated for TMF
  12  *   Patrick Tasse - Refactoring
  13  *
  14  *****************************************************************************/
  15
  16 package org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets;
  17
  18 import java.text.SimpleDateFormat;
  19 import java.util.Date;
  20 import java.util.Iterator;
  21
  22 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  23 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  24 import org.eclipse.swt.graphics.Color;
  25 import org.eclipse.swt.graphics.Device;
  26 import org.eclipse.swt.graphics.GC;
  27 import org.eclipse.swt.graphics.Point;
  28 import org.eclipse.swt.graphics.Rectangle;
  29 import org.eclipse.swt.widgets.Display;
  30
  31 public class Utils {
  32
  33     public enum TimeFormat {
  34         RELATIVE, ABSOLUTE
  35     };
  36
  37     static public final int IMG_THREAD_RUNNING = 0;
  38     static public final int IMG_THREAD_SUSPENDED = 1;
  39     static public final int IMG_THREAD_STOPPED = 2;
  40     static public final int IMG_METHOD_RUNNING = 3;
  41     static public final int IMG_METHOD = 4;
  42     static public final int IMG_NUM = 5;
  43
  44     static public final Object[] _empty = new Object[0];
  45
  46     public static enum Resolution {
  47         SECONDS, MILLISEC, MICROSEC, NANOSEC
  48     };
  49
  50     static private final SimpleDateFormat stimeformat = new SimpleDateFormat("HH:mm:ss"); //$NON-NLS-1$
  51     static private final SimpleDateFormat sdateformat = new SimpleDateFormat("yyyy-MM-dd"); //$NON-NLS-1$
  52
  53     static Rectangle clone(Rectangle source) {
  54         return new Rectangle(source.x, source.y, source.width, source.height);
  55     }
  56
  57     static public void init(Rectangle rect) {
  58         rect.x = 0;
  59         rect.y = 0;
  60         rect.width = 0;
  61         rect.height = 0;
  62     }
  63
  64     static public void init(Rectangle rect, int x, int y, int width, int height) {
  65         rect.x = x;
  66         rect.y = y;
  67         rect.width = width;
  68         rect.height = height;
  69     }
  70
  71     static public void init(Rectangle rect, Rectangle source) {
  72         rect.x = source.x;
  73         rect.y = source.y;
  74         rect.width = source.width;
  75         rect.height = source.height;
  76     }
  77
  78     static public void deflate(Rectangle rect, int x, int y) {
  79         rect.x += x;
  80         rect.y += y;
  81         rect.width -= x + x;
  82         rect.height -= y + y;
  83     }
  84
  85     static public void inflate(Rectangle rect, int x, int y) {
  86         rect.x -= x;
  87         rect.y -= y;
  88         rect.width += x + x;
  89         rect.height += y + y;
  90     }
  91
  92     static void dispose(Color col) {
  93         if (null != col)
  94             col.dispose();
  95     }
  96
  97     static public Color mixColors(Device display, Color c1, Color c2, int w1,
  98             int w2) {
  99         return new Color(display, (w1 * c1.getRed() + w2 * c2.getRed())
 100                 / (w1 + w2), (w1 * c1.getGreen() + w2 * c2.getGreen())
 101                 / (w1 + w2), (w1 * c1.getBlue() + w2 * c2.getBlue())
 102                 / (w1 + w2));
 103     }
 104
 105     static public Color getSysColor(int id) {
 106         Color col = Display.getCurrent().getSystemColor(id);
 107         return new Color(col.getDevice(), col.getRGB());
 108     }
 109
 110     static public Color mixColors(Color col1, Color col2, int w1, int w2) {
 111         return mixColors(Display.getCurrent(), col1, col2, w1, w2);
 112     }
 113
 114     static public int drawText(GC gc, String text, Rectangle rect, boolean transp) {
 115         Point size = gc.stringExtent(text);
 116         gc.drawText(text, rect.x, rect.y, transp);
 117         return size.x;
 118     }
 119
 120     static public int drawText(GC gc, String text, int x, int y, boolean transp) {
 121         Point size = gc.stringExtent(text);
 122         gc.drawText(text, x, y, transp);
 123         return size.x;
 124     }
 125
 126     /**
 127      * Formats time in format: MM:SS:NNN
 128      *
 129      * @param time time
 130      * @param format  0: MMMM:ss:nnnnnnnnn, 1: HH:MM:ss MMM.mmmm.nnn
 131      * @param resolution the resolution
 132      * @return the formatted time
 133      */
 134     static public String formatTime(long time, TimeFormat format, Resolution resolution) {
 135         // if format is absolute (Calendar)
 136         if (format == TimeFormat.ABSOLUTE) {
 137             return formatTimeAbs(time, resolution);
 138         }
 139
 140         StringBuffer str = new StringBuffer();
 141         boolean neg = time < 0;
 142         if (neg) {
 143             time = -time;
 144             str.append('-');
 145         }
 146
 147         long sec = (long) (time * 1E-9);
 148         // TODO: Expand to make it possible to select the minute, second, nanosecond format
 149         //printing minutes is suppressed just sec and ns
 150         // if (sec / 60 < 10)
 151         // str.append('0');
 152         // str.append(sec / 60);
 153         // str.append(':');
 154         // sec %= 60;
 155         // if (sec < 10)
 156         // str.append('0');
 157         str.append(sec);
 158         String ns = formatNs(time, resolution);
 159         if (!ns.equals("")) { //$NON-NLS-1$
 160             str.append('.');
 161             str.append(ns);
 162         }
 163
 164         return str.toString();
 165     }
 166
 167     /**
 168      * From input time in nanoseconds, convert to Date format YYYY-MM-dd
 169      *
 170      * @param absTime
 171      * @return the formatted date
 172      */
 173     public static String formatDate(long absTime) {
 174         String sdate = sdateformat.format(new Date((long) (absTime * 1E-6)));
 175         return sdate;
 176     }
 177
 178     /**
 179      * Formats time in ns to Calendar format: HH:MM:SS MMM.mmm.nnn
 180      *
 181      * @param time
 182      * @return the formatted time
 183      */
 184     static public String formatTimeAbs(long time, Resolution res) {
 185         StringBuffer str = new StringBuffer();
 186
 187         // format time from nanoseconds to calendar time HH:MM:SS
 188         String stime = stimeformat.format(new Date((long) (time * 1E-6)));
 189         str.append(stime);
 190         str.append('.');
 191         // append the Milliseconds, MicroSeconds and NanoSeconds as specified in
 192         // the Resolution
 193         str.append(formatNs(time, res));
 194         return str.toString();
 195     }
 196
 197     /**
 198      * Obtains the remainder fraction on unit Seconds of the entered value in
 199      * nanoseconds. e.g. input: 1241207054171080214 ns The number of fraction
 200      * seconds can be obtained by removing the last 9 digits: 1241207054 the
 201      * fractional portion of seconds, expressed in ns is: 171080214
 202      *
 203      * @param time
 204      * @param res
 205      * @return the formatted nanosec
 206      */
 207     public static String formatNs(long time, Resolution res) {
 208         StringBuffer str = new StringBuffer();
 209         boolean neg = time < 0;
 210         if (neg) {
 211             time = -time;
 212         }
 213
 214         // The following approach could be used although performance
 215         // decreases in half.
 216         // String strVal = String.format("%09d", time);
 217         // String tmp = strVal.substring(strVal.length() - 9);
 218
 219         long ns = time;
 220         ns %= 1000000000;
 221         if (ns < 10) {
 222             str.append("00000000"); //$NON-NLS-1$
 223         } else if (ns < 100) {
 224             str.append("0000000"); //$NON-NLS-1$
 225         } else if (ns < 1000) {
 226             str.append("000000"); //$NON-NLS-1$
 227         } else if (ns < 10000) {
 228             str.append("00000"); //$NON-NLS-1$
 229         } else if (ns < 100000) {
 230             str.append("0000"); //$NON-NLS-1$
 231         } else if (ns < 1000000) {
 232             str.append("000"); //$NON-NLS-1$
 233         } else if (ns < 10000000) {
 234             str.append("00"); //$NON-NLS-1$
 235         } else if (ns < 100000000) {
 236             str.append("0"); //$NON-NLS-1$
 237         }
 238         str.append(ns);
 239
 240         if (res == Resolution.MILLISEC) {
 241             return str.substring(0, 3);
 242         } else if (res == Resolution.MICROSEC) {
 243             return str.substring(0, 6);
 244         } else if (res == Resolution.NANOSEC) {
 245             return str.substring(0, 9);
 246         }
 247         return ""; //$NON-NLS-1$
 248     }
 249
 250     static public int loadIntOption(String opt, int def, int min, int max) {
 251         // int val =
 252         // TraceUIPlugin.getDefault().getPreferenceStore().getInt(opt);
 253         // if (0 == val)
 254         // val = def;
 255         // if (val < min)
 256         // val = min;
 257         // if (val > max)
 258         // val = max;
 259         return def;
 260     }
 261
 262     static public void saveIntOption(String opt, int val) {
 263         // TraceUIPlugin.getDefault().getPreferenceStore().setValue(opt, val);
 264     }
 265
 266     static ITimeEvent getFirstEvent(ITimeGraphEntry thread) {
 267         if (null == thread)
 268             return null;
 269         Iterator<ITimeEvent> iterator = thread.getTimeEventsIterator();
 270         if (iterator != null && iterator.hasNext()) {
 271             return iterator.next();
 272         } else {
 273             return null;
 274         }
 275     }
 276
 277     /**
 278      * N means: <list> <li>-1: Previous Event</li> <li>0: Current Event</li> <li>
 279      * 1: Next Event</li> <li>2: Previous Event when located in a non Event Area
 280      * </list>
 281      *
 282      * @param thread
 283      * @param time
 284      * @param n
 285      * @return
 286      */
 287     static ITimeEvent findEvent(ITimeGraphEntry thread, long time, int n) {
 288         if (null == thread)
 289             return null;
 290         Iterator<ITimeEvent> iterator = thread.getTimeEventsIterator();
 291         if (iterator == null) {
 292             return null;
 293         }
 294         ITimeEvent nextEvent = null;
 295         ITimeEvent currEvent = null;
 296         ITimeEvent prevEvent = null;
 297
 298         while (iterator.hasNext()) {
 299             nextEvent = (ITimeEvent) iterator.next();
 300             long nextStartTime = nextEvent.getTime();
 301
 302             if (nextStartTime > time) {
 303                 break;
 304             }
 305
 306             if (currEvent == null || currEvent.getTime() != nextStartTime) {
 307                 prevEvent = currEvent;
 308                 currEvent = nextEvent;
 309             }
 310         }
 311
 312         if (n == -1) { //previous
 313             if (currEvent != null && currEvent.getTime() + currEvent.getDuration() >= time) {
 314                 return prevEvent;
 315             } else {
 316                 return currEvent;
 317             }
 318         } else if (n == 0) { //current
 319             if (currEvent != null && currEvent.getTime() + currEvent.getDuration() >= time) {
 320                 return currEvent;
 321             } else {
 322                 return null;
 323             }
 324         } else if (n == 1) { //next
 325             return nextEvent;
 326         } else if (n == 2) { //current or previous when in empty space
 327             return currEvent;
 328         }
 329
 330         return null;
 331     }
 332
 333     static public String fixMethodSignature(String sig) {
 334         int pos = sig.indexOf('(');
 335         if (pos >= 0) {
 336             String ret = sig.substring(0, pos);
 337             sig = sig.substring(pos);
 338             sig = sig + " " + ret; //$NON-NLS-1$
 339         }
 340         return sig;
 341     }
 342
 343     static public String restoreMethodSignature(String sig) {
 344         String ret = ""; //$NON-NLS-1$
 345         int pos = sig.indexOf('(');
 346         if (pos >= 0) {
 347             ret = sig.substring(0, pos);
 348             sig = sig.substring(pos + 1);
 349         }
 350         pos = sig.indexOf(')');
 351         if (pos >= 0) {
 352             sig = sig.substring(0, pos);
 353         }
 354         String args[] = sig.split(","); //$NON-NLS-1$
 355         StringBuffer result = new StringBuffer("("); //$NON-NLS-1$
 356         for (int i = 0; i < args.length; i++) {
 357             String arg = args[i].trim();
 358             if (arg.length() == 0 && args.length == 1)
 359                 break;
 360             result.append(getTypeSignature(arg));
 361         }
 362         result.append(")").append(getTypeSignature(ret)); //$NON-NLS-1$
 363         return result.toString();
 364     }
 365
 366     static public String getTypeSignature(String type) {
 367         int dim = 0;
 368         for (int j = 0; j < type.length(); j++) {
 369             if (type.charAt(j) == '[')
 370                 dim++;
 371         }
 372         int pos = type.indexOf('[');
 373         if (pos >= 0)
 374             type = type.substring(0, pos);
 375         StringBuffer sig = new StringBuffer(""); //$NON-NLS-1$
 376         for (int j = 0; j < dim; j++)
 377             sig.append("[");                 //$NON-NLS-1$
 378         if (type.equals("boolean"))     //$NON-NLS-1$
 379             sig.append("Z");                 //$NON-NLS-1$
 380         else if (type.equals("byte"))   //$NON-NLS-1$
 381             sig.append("B");                 //$NON-NLS-1$
 382         else if (type.equals("char"))   //$NON-NLS-1$
 383             sig.append("C");                 //$NON-NLS-1$
 384         else if (type.equals("short"))  //$NON-NLS-1$
 385             sig.append("S");                 //$NON-NLS-1$
 386         else if (type.equals("int"))    //$NON-NLS-1$
 387             sig.append("I");                 //$NON-NLS-1$
 388         else if (type.equals("long"))   //$NON-NLS-1$
 389             sig.append("J");                 //$NON-NLS-1$
 390         else if (type.equals("float"))  //$NON-NLS-1$
 391             sig.append("F");                 //$NON-NLS-1$
 392         else if (type.equals("double")) //$NON-NLS-1$
 393             sig.append("D");                 //$NON-NLS-1$
 394         else if (type.equals("void"))   //$NON-NLS-1$
 395             sig.append("V");                 //$NON-NLS-1$
 396         else
 397             sig.append("L").append(type.replace('.', '/')).append(";"); //$NON-NLS-1$ //$NON-NLS-2$
 398         return sig.toString();
 399     }
 400
 401     static public int compare(double d1, double d2) {
 402         if (d1 > d2)
 403             return 1;
 404         if (d1 < d2)
 405             return 1;
 406         return 0;
 407     }
 408
 409     static public int compare(String s1, String s2) {
 410         if (s1 != null && s2 != null)
 411             return s1.compareToIgnoreCase(s2);
 412         if (s1 != null)
 413             return 1;
 414         if (s2 != null)
 415             return -1;
 416         return 0;
 417     }
 418 }