13  *

    13  *

    14  * Description:  Definitions for the class AnalyzeToolGraph

    14  * Description:  Definitions for the class AnalyzeToolGraph

    15  *

    15  *

    16  */

    16  */

    17 package com.nokia.s60tools.analyzetool.internal.ui.graph;

    17 package com.nokia.s60tools.analyzetool.internal.ui.graph;

    18 import java.beans.PropertyChangeEvent;

    19 import java.beans.PropertyChangeEvent;

    19 import java.beans.PropertyChangeListener;

    20 import java.beans.PropertyChangeListener;

    20 import java.util.AbstractList;

    21 import java.util.AbstractList;

    21 import java.util.ArrayList;

    22 import java.util.ArrayList;

    22 import java.util.List;

    23 import java.util.List;

    76 import com.nokia.s60tools.analyzetool.internal.ui.util.GraphUtils;

    77 import com.nokia.s60tools.analyzetool.internal.ui.util.GraphUtils;

    77 import com.nokia.s60tools.analyzetool.ui.MainView;

    78 import com.nokia.s60tools.analyzetool.ui.MainView;

    78 import com.nokia.s60tools.analyzetool.ui.ResourceVisitor;

    79 import com.nokia.s60tools.analyzetool.ui.ResourceVisitor;

    79 

    80 

    80 /**

    81 /**

    83  */

    83  */

    85 

    86 

    86 	private static final int BOUNDARY_OFFSET = 3;

    87 	private static final int BOUNDARY_OFFSET = 3;

    87 	/** used for range model listener */

    88 	/** used for range model listener */

    88 	private static final String PROP_MAXIMUM = "maximum"; //$NON-NLS-1$

    89 	private static final String PROP_MAXIMUM = "maximum"; //$NON-NLS-1$

    89 	private static final int X_AXIS_HEIGHT = 50;

    90 	private static final int X_AXIS_HEIGHT = 50;

    90 	/** used for "Don't ask again" dialog */

    91 	/** used for "Don't ask again" dialog */

    91 	private static final String PROMPT_KEY = "GraphOptimisationPrompt";//$NON-NLS-1$

    92 	private static final String PROMPT_KEY = "GraphOptimisationPrompt";//$NON-NLS-1$

    94 	private double scale = 1.0;

    95 	private double scale = 1.0;

    95 

    96 

    96 	/** the model */

    97 	/** the model */

    97 	private IMemoryActivityModel model;

    98 	private IMemoryActivityModel model;

    98 

    99 

   100 	private DotSelectionProvider iDotsSelecProv = new DotSelectionProvider();

   101 	private DotSelectionProvider iDotsSelecProv = new DotSelectionProvider();

   101 	private IWorkbenchPartSite site;

   102 	private IWorkbenchPartSite site;

   103 	/** used when user selects a dot on the graph, and moves with arrow keys */

   104 	/** used when user selects a dot on the graph, and moves with arrow keys */

   104 	private ISelection iCurrentSelectedDot = null;

   105 	private ISelection iCurrentSelectedDot = null;

   106 	/** controls mouse and arrow key movements */

   107 	/** controls mouse and arrow key movements */

   107 	private MouseAndKeyController mc;

   108 	private MouseAndKeyController mc;

   108 	private SymReader iSymReader = null;

   109 	private SymReader iSymReader = null;

   109 	private IProject iCurrentProject = null;

   110 	private IProject iCurrentProject = null;

   110 	/** Contains c++ files info for the current project. */

   111 	/** Contains c++ files info for the current project. */

   111 	private final AbstractList<String> cppFileNames;

   112 	private final AbstractList<String> cppFileNames;

   114 	private Image timeImage;

   115 	private Image timeImage;

   115 	private GraphPartServiceListener iGraphPartServiceListener;

   116 	private GraphPartServiceListener iGraphPartServiceListener;

   116 	private boolean optimisedDrawing;

   117 	private boolean optimisedDrawing;

   117 	private boolean userInformed;

   118 	private boolean userInformed;

   118 

   119 

   119 

   128 

   120 	/**

   129 	/**

   121 	 * Constructor

   130 	 * Constructor

   123 	 */

   134 	 */

   124 	public AnalyzeToolGraph(Composite parent) {

   135 	public AnalyzeToolGraph(Composite parent) {

   125 		super(parent);

   136 		super(parent);

   126 		IPartService partService = PlatformUI.getWorkbench()

   137 		IPartService partService = PlatformUI.getWorkbench()

   127 				.getActiveWorkbenchWindow().getPartService();

   138 				.getActiveWorkbenchWindow().getPartService();

   130 		PlatformUI.getWorkbench().addWindowListener(iGraphPartServiceListener);

   141 		PlatformUI.getWorkbench().addWindowListener(iGraphPartServiceListener);

   131 		cppFileNames = new ArrayList<String>();

   142 		cppFileNames = new ArrayList<String>();

   132 	}

   143 	}

   133 

   144 

   134 	/**

   145 	/**

   136 	 * @param graphics

   148 	 * @param graphics

   137 	 */

   149 	 */

   138 	public void paint(final Graphics graphics) {

   150 	public void paint(final Graphics graphics) {

   140 			userInformed = true;

   152 			userInformed = true;

   141 			IPreferenceStore preferenceStore = Activator.getPreferences();

   153 			IPreferenceStore preferenceStore = Activator.getPreferences();

   155 			Point prevPt = null;

   173 			Point prevPt = null;

   156 			List<Point> dotLocations = new ArrayList<Point>();

   174 			List<Point> dotLocations = new ArrayList<Point>();

   157 			List<Integer> colorDotLocations = new ArrayList<Integer>();

   175 			List<Integer> colorDotLocations = new ArrayList<Integer>();

   158 

   176 

   159 			for (BaseInfo info : model.getSelectedProcess().getAllocsFrees()) {

   177 			for (BaseInfo info : model.getSelectedProcess().getAllocsFrees()) {

   161 				int y_point = yConverter.bytesToY(info.getTotalMem());

   180 				int y_point = yConverter.bytesToY(info.getTotalMem());

   162 

   181 

   163 				if (y_point < 0) {

   182 				if (y_point < 0) {

   164 					y_point = 0;

   183 					y_point = 0;

   165 				}

   184 				}

   166 				if (prevPt != null) {

   185 				if (prevPt != null) {

   167 					pts.addPoint(x_point, prevPt.y);

   186 					pts.addPoint(x_point, prevPt.y);

   168 				}

   187 				}

   169 				Point nextPt = new Point(x_point, y_point);

   188 				Point nextPt = new Point(x_point, y_point);

   173 					dotLocations.add(nextPt);

   196 					dotLocations.add(nextPt);

   174 					colorDotLocations.add(getColorForAllocType(info));

   197 					colorDotLocations.add(getColorForAllocType(info));

   175 				}

   198 				}

   176 				pts.addPoint(nextPt);

   199 				pts.addPoint(nextPt);

   177 				prevPt = nextPt;

   200 				prevPt = nextPt;

   178 			}

   201 			}

   179 

   202 

   181 				graphics.pushState();

   204 				graphics.pushState();

   184 				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 2.0f);

   208 				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 2.0f);

   185 				graphics.drawPolyline(pts);

   209 				graphics.drawPolyline(pts);

   187 				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 1.0f);

   211 				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 1.0f);

   188 				graphics.setAntialias(SWT.ON);

   212 				graphics.setAntialias(SWT.ON);

   191 				int colourCode = SWT.COLOR_RED;

   217 				int colourCode = SWT.COLOR_RED;

   192 				for (int j = 0; j < dotLocations.size(); j++) {

   218 				for (int j = 0; j < dotLocations.size(); j++) {

   193 					Point dotLocation = dotLocations.get(j);

   219 					Point dotLocation = dotLocations.get(j);

   195 						colourCode = colorDotLocations.get(j);

   222 						colourCode = colorDotLocations.get(j);

   197 					}

   225 					}

   198 					// paint the dot

   226 					// paint the dot

   200 					if (!optimisedDrawing && colourCode == SWT.COLOR_RED) {

   229 					if (!optimisedDrawing && colourCode == SWT.COLOR_RED) {

   201 						// draw a red line

   230 						// draw a red line

   203 					}

   233 					}

   204 				}

   234 				}

   205 				graphics.popState();

   235 				graphics.popState();

   206 			}

   236 			}

   207 		}

   237 		}

   208 	}

   238 	}

   214 	 * @param graphics

   274 	 * @param graphics

   215 	 */

   275 	 */

   216 	public void drawBackGroundLines(Graphics graphics) {

   276 	public void drawBackGroundLines(Graphics graphics) {

   218 		graphics.setForegroundColor(ColorUtil.COLOR_100); // middle grey

   279 		graphics.setForegroundColor(ColorUtil.COLOR_100); // middle grey

   219 		graphics.setBackgroundColor(ColorUtil.COLOR_170); // lighter grey

   280 		graphics.setBackgroundColor(ColorUtil.COLOR_170); // lighter grey

   220 

   281 

   221 		int height = getClientArea().height;

   282 		int height = getClientArea().height;

   222 		int width = getClientArea().width;

   283 		int width = getClientArea().width;

   223 

   284 

   225 

   287 

   226 		double visY = height - X_AXIS_HEIGHT;

   288 		double visY = height - X_AXIS_HEIGHT;

   227 

   289 

   228 		int k = 0;

   290 		int k = 0;

   229 		// horizontal lines, height is divided into 10 sections, line is dotted

   291 		// horizontal lines, height is divided into 10 sections, line is dotted

   235 			}

   297 			}

   236 		}

   298 		}

   237 

   299 

   238 		graphics.setForegroundColor(ColorUtil.COLOR_100);

   300 		graphics.setForegroundColor(ColorUtil.COLOR_100);

   239 		graphics.setBackgroundColor(ColorUtil.WHITE);

   301 		graphics.setBackgroundColor(ColorUtil.WHITE);

   242 

   304 

   243 		// vertical lines (one darker, one lighter vertical line in turns every

   305 		// vertical lines (one darker, one lighter vertical line in turns every

   244 		// 50 points in width)

   306 		// 50 points in width)

   245 		if (width > 0) {

   307 		if (width > 0) {

   247 				if (x % 100 == 0)

   309 				if (x % 100 == 0)

   248 					graphics.setForegroundColor(ColorUtil.COLOR_100);

   310 					graphics.setForegroundColor(ColorUtil.COLOR_100);

   249 				else

   311 				else

   250 					graphics.setForegroundColor(ColorUtil.COLOR_200);

   312 					graphics.setForegroundColor(ColorUtil.COLOR_200);

   251 

   313 

   258 

   320 

   259 		graphics.setForegroundColor(ColorUtil.COLOR_100);

   321 		graphics.setForegroundColor(ColorUtil.COLOR_100);

   260 		graphics.setBackgroundColor(ColorUtil.WHITE);

   322 		graphics.setBackgroundColor(ColorUtil.WHITE);

   261 

   323 

   262 		for (int x = alignedLeftEdge; x <= canvasRect.x + canvasRect.width; x += 50) {

   324 		for (int x = alignedLeftEdge; x <= canvasRect.x + canvasRect.width; x += 50) {

   264 			graphics.drawString(timeStringWithUnits, x + 5, height - 13);

   327 			graphics.drawString(timeStringWithUnits, x + 5, height - 13);

   265 		}

   328 		}

   268 		}

   331 		}

   269 		graphics.drawImage(timeImage, width / 2, height - 30);

   332 		graphics.drawImage(timeImage, width / 2, height - 30);

   270 	}

   333 	}

   271 

   334 

   272 	/**

   335 	/**

   273 	 * Returns the content of the tooltip appropriate for the given coordinate

   336 	 * Returns the content of the tooltip appropriate for the given coordinate

   276 	 * @return String containing the content of the tooltip

   342 	 * @return String containing the content of the tooltip

   277 	 */

   343 	 */

   278 	public String getToolTipText(int x, int y) {

   344 	public String getToolTipText(int x, int y) {

   279 		StringBuilder text = new StringBuilder();

   345 		StringBuilder text = new StringBuilder();

   280 		if (model.getSelectedProcess() == null) {

   346 		if (model.getSelectedProcess() == null) {

   285 			return null;

   351 			return null;

   286 		}

   352 		}

   287 

   353 

   288 		double timeInMs = (x * getScale());// x value in milliseconds

   354 		double timeInMs = (x * getScale());// x value in milliseconds

   289 

   355 

   291 		double bytes = yConverter.yToBytes(y); // y value in bytes

   358 		double bytes = yConverter.yToBytes(y); // y value in bytes

   292 

   359 

   297 		if (allocInfo != null) {

   367 		if (allocInfo != null) {

   298 			text.append(String.format("%n%s: %,d B%nTotal: %,d B",

   368 			text.append(String.format("%n%s: %,d B%nTotal: %,d B",

   302 		} else {

   371 		} else {

   303 			text.append(", " + GraphUtils.formatBytes(bytes));

   372 			text.append(", " + GraphUtils.formatBytes(bytes));

   304 		}

   373 		}

   306 		return text.toString();

   374 		return text.toString();

   307 	}

   375 	}

   309 	/**

   377 	/**

   310 	 * Returns a string representation of the type of the given memory operation

   378 	 * Returns a string representation of the type of the given memory operation

   316 	}

   387 	}

   317 

   388 

   318 	/**

   389 	/**

   319 	 * Convenience method for

   390 	 * Convenience method for

   320 	 * {@link #findClosestAlloc(int, int, int, int, int, int)} wrapping

   391 	 * {@link #findClosestAlloc(int, int, int, int, int, int)} wrapping

   329 	private BaseInfo findClosest(int x, int y) {

   400 	private BaseInfo findClosest(int x, int y) {

   330 		if (y > getClientArea().height - X_AXIS_HEIGHT) {

   401 		if (y > getClientArea().height - X_AXIS_HEIGHT) {

   331 			return null;

   402 			return null;

   332 		}

   403 		}

   333 

   404 

   337 	}

   413 	}

   338 

   414 

   339 	/**

   415 	/**

   340 	 * Finds the closest matching BaseInfo in the model. BaseInfo has to fit

   416 	 * Finds the closest matching BaseInfo in the model. BaseInfo has to fit

   341 	 * into the given bounds and be a better match than other BaseInfo in the

   417 	 * into the given bounds and be a better match than other BaseInfo in the

   353 	 *            Left boundary for cumulative memory in bytes

   429 	 *            Left boundary for cumulative memory in bytes

   354 	 * @param bytesBoundRight

   430 	 * @param bytesBoundRight

   355 	 *            Right boundary for cumulative memory in bytes

   431 	 *            Right boundary for cumulative memory in bytes

   356 	 * @return

   432 	 * @return

   357 	 */

   433 	 */

   360 		BaseInfo ret = null;

   437 		BaseInfo ret = null;

   362 			return ret;

   439 			return ret;

   363 		}

   440 		}

   365 		int marginEnd = timeInMsBoundRight;

   442 		int marginEnd = timeInMsBoundRight;

   366 		ProcessInfo process = model.getSelectedProcess();

   443 		ProcessInfo process = model.getSelectedProcess();

   367 		AbstractList<BaseInfo> allocsFrees = process.getAllocsFrees();

   444 		AbstractList<BaseInfo> allocsFrees = process.getAllocsFrees();

   368 		Long firstTime = model.getFirstProcessTime();

   445 		Long firstTime = model.getFirstProcessTime();

   369 

   446 

   370 		for (BaseInfo info : allocsFrees) {

   447 		for (BaseInfo info : allocsFrees) {

   371 			Long infoRelativeTime = info.getTime() - firstTime;

   448 			Long infoRelativeTime = info.getTime() - firstTime;

   372 			// check current alloc info is within given bounds

   449 			// check current alloc info is within given bounds

   374 					&& info.getTotalMem() <= bytesBoundRight) {

   453 					&& info.getTotalMem() <= bytesBoundRight) {

   375 				// check whether current alloc info is a better match than

   454 				// check whether current alloc info is a better match than

   376 				// previously found

   455 				// previously found

   377 				if (ret == null

   456 				if (ret == null

   382 					ret = info;

   463 					ret = info;

   383 				}

   464 				}

   384 			} else if ((info.getTime() - firstTime) > timeInMsBoundRight) {

   465 			} else if ((info.getTime() - firstTime) > timeInMsBoundRight) {

   385 				break;

   466 				break;

   386 			}

   467 			}

   397 	 *         passed object was the last in the model.

   478 	 *         passed object was the last in the model.

   398 	 */

   479 	 */

   399 	private BaseInfo findNextAlloc(BaseInfo allocInfo, boolean forward) {

   480 	private BaseInfo findNextAlloc(BaseInfo allocInfo, boolean forward) {

   400 		BaseInfo ret = null;

   481 		BaseInfo ret = null;

   401 		ProcessInfo processInfo = model.getSelectedProcess();

   482 		ProcessInfo processInfo = model.getSelectedProcess();

   403 			return ret;

   484 			return ret;

   404 		}

   485 		}

   407 		int i = allocsFrees.indexOf(allocInfo);

   488 		int i = allocsFrees.indexOf(allocInfo);

   408 		if (forward) {

   489 		if (forward) {

   409 			if (i < allocsFrees.size() - 1) {

   490 			if (i < allocsFrees.size() - 1) {

   410 				ret = allocsFrees.get(i + 1);

   491 				ret = allocsFrees.get(i + 1);

   411 			}

   492 			}

   432 		setZoomedSize(0);

   513 		setZoomedSize(0);

   433 	}

   514 	}

   434 

   515 

   435 	/**

   516 	/**

   436 	 * Returns the current scaling factor for the graph's width

   517 	 * Returns the current scaling factor for the graph's width

   437 	 * @return Scale

   519 	 * @return Scale

   438 	 */

   520 	 */

   439 	public double getScale() {

   521 	public double getScale() {

   440 		return scale;

   522 		return scale;

   441 	}

   523 	}

   442 

   524 

   443 	/**

   525 	/**

   444 	 * Sets the scaling factor for the graph's width

   526 	 * Sets the scaling factor for the graph's width

   446 	 */

   529 	 */

   447 	public void setScale(double newScale) {

   530 	public void setScale(double newScale) {

   448 		this.scale = newScale;

   531 		this.scale = newScale;

   449 	}

   532 	}

   450 

   533 

   451 	/**

   534 	/**

   452 	 * Returns the highest time value of the current graph in milliseconds

   535 	 * Returns the highest time value of the current graph in milliseconds

   454 	 */

   538 	 */

   455 	public long getLastTimeValueInMilliSeconds() {

   539 	public long getLastTimeValueInMilliSeconds() {

   456 		return model.getLastProcessTime() - model.getFirstProcessTime();

   540 		return model.getLastProcessTime() - model.getFirstProcessTime();

   457 	}

   541 	}

   458 

   542 

   460 	 * Returns the last time value in the model plus 1 per cent.

   544 	 * Returns the last time value in the model plus 1 per cent.

   461 	 * 

   545 	 * 

   462 	 * @return

   546 	 * @return

   463 	 */

   547 	 */

   464 	private long getMaxTimeValueInMilliSeconds() {

   548 	private long getMaxTimeValueInMilliSeconds() {

   471 	 */

   558 	 */

   472 	public void setInput(IMemoryActivityModel newModel) {

   559 	public void setInput(IMemoryActivityModel newModel) {

   474 			this.model.removeListener(this);

   561 			this.model.removeListener(this);

   475 		}

   562 		}

   476 		this.model = newModel;

   564 		this.model = newModel;

   477 		this.model.addListener(this);

   565 		this.model.addListener(this);

   478 	}

   566 	}

   479 

   567 

   480 	/**

   568 	/**

   483 	 */

   571 	 */

   484 	public void createContent() {

   572 	public void createContent() {

   485 		mc = new MouseAndKeyController();

   573 		mc = new MouseAndKeyController();

   486 		Panel panel = new Panel() {

   574 		Panel panel = new Panel() {

   487 			@Override

   575 			@Override

   506 		final org.eclipse.swt.widgets.ScrollBar horizontalBar = getHorizontalBar();

   594 		final org.eclipse.swt.widgets.ScrollBar horizontalBar = getHorizontalBar();

   507 

   595 

   508 		horizontalBar.addSelectionListener(new SelectionListener() {

   596 		horizontalBar.addSelectionListener(new SelectionListener() {

   509 

   597 

   510 			public void widgetDefaultSelected(SelectionEvent arg0) {

   598 			public void widgetDefaultSelected(SelectionEvent arg0) {

   512 			}

   600 			}

   513 

   601 

   514 			public void widgetSelected(SelectionEvent event) {

   602 			public void widgetSelected(SelectionEvent event) {

   515 				AnalyzeToolGraph.this.redraw();

   603 				AnalyzeToolGraph.this.redraw();

   516 			}

   604 			}

   522 			public void controlResized(ControlEvent e) {

   610 			public void controlResized(ControlEvent e) {

   523 				horizontalBar.setPageIncrement(getBounds().width);

   611 				horizontalBar.setPageIncrement(getBounds().width);

   524 				redraw();

   612 				redraw();

   525 			}

   613 			}

   526 		});

   614 		});

   528 	}

   615 	}

   529 

   616 

   530 	/**

   617 	/**

   531 	 * Class containing code to deal with mouse and key events

   618 	 * Class containing code to deal with mouse and key events

   535 

   623 

   536 		protected int mouseButton;

   624 		protected int mouseButton;

   537 		protected Point start;

   625 		protected Point start;

   538 		protected boolean beingDragged;

   626 		protected boolean beingDragged;

   539 		private BaseInfo lastShownAlloc;

   627 		private BaseInfo lastShownAlloc;

   557 			}

   645 			}

   558 		}

   646 		}

   559 

   647 

   560 		public void render(Graphics graphics) {

   648 		public void render(Graphics graphics) {

   561 			graphics.pushState();

   649 			graphics.pushState();

   564 				graphics.setLineWidth(1);

   653 				graphics.setLineWidth(1);

   566 				int dragEnd = lastMouse.x;

   655 				int dragEnd = lastMouse.x;

   575 				FreeInfo freeInfo = null;

   671 				FreeInfo freeInfo = null;

   584 					Point pfree = getLocationOnGraph(yConverter, freeInfo);

   683 					Point pfree = getLocationOnGraph(yConverter, freeInfo);

   590 						}

   693 						}

   591 					}

   694 					}

   592 					for (AllocInfo freedAlloc : freeInfo.getFreedAllocs()) {

   695 					for (AllocInfo freedAlloc : freeInfo.getFreedAllocs()) {

   599 							}

   708 							}

   600 						}

   709 						}

   602 					}

   711 					}

   603 				}

   712 				}

   607 				Point p = getLocationOnGraph(lastShownAlloc);

   717 				Point p = getLocationOnGraph(lastShownAlloc);

   609 				graphics.setLineWidth(1);

   720 				graphics.setLineWidth(1);

   610 				graphics.drawOval(p.x - 2, p.y - 2, 5, 5);

   721 				graphics.drawOval(p.x - 2, p.y - 2, 5, 5);

   613 				}

   725 				}

   614 			}

   726 			}

   615 			graphics.popState();

   727 			graphics.popState();

   616 		}

   728 		}

   617 

   729 

   618 		private Point getLocationOnGraph(BaseInfo alloc) {

   730 		private Point getLocationOnGraph(BaseInfo alloc) {

   620 			return getLocationOnGraph(yConverter, alloc);

   733 			return getLocationOnGraph(yConverter, alloc);

   621 		}

   734 		}

   622 		private Point getLocationOnGraph(YConverter yConverter, BaseInfo alloc) {

   736 		private Point getLocationOnGraph(YConverter yConverter, BaseInfo alloc) {

   623 			int x = (int) ((alloc.getTime() - model.getFirstProcessTime()) / getScale());

   737 			int x = (int) ((alloc.getTime() - model.getFirstProcessTime()) / getScale());

   624 			int y = yConverter.bytesToY(alloc.getTotalMem());

   738 			int y = yConverter.bytesToY(alloc.getTotalMem());

   625 

   739 

   626 			if (y < 0) {

   740 			if (y < 0) {

   635 		 * @see

   749 		 * @see

   636 		 * org.eclipse.draw2d.MouseMotionListener#mouseEntered(org.eclipse.draw2d

   750 		 * org.eclipse.draw2d.MouseMotionListener#mouseEntered(org.eclipse.draw2d

   637 		 * .MouseEvent)

   751 		 * .MouseEvent)

   638 		 */

   752 		 */

   639 		public void mouseEntered(MouseEvent e) {

   753 		public void mouseEntered(MouseEvent e) {

   641 		}

   755 		}

   642 

   756 

   643 		/*

   757 		/*

   644 		 * (non-Javadoc)

   758 		 * (non-Javadoc)

   645 		 * 

   759 		 * 

   646 		 * @see

   760 		 * @see

   647 		 * org.eclipse.draw2d.MouseMotionListener#mouseExited(org.eclipse.draw2d

   761 		 * org.eclipse.draw2d.MouseMotionListener#mouseExited(org.eclipse.draw2d

   648 		 * .MouseEvent)

   762 		 * .MouseEvent)

   649 		 */

   763 		 */

   650 		public void mouseExited(MouseEvent e) {

   764 		public void mouseExited(MouseEvent e) {

   652 		}

   766 		}

   653 

   767 

   654 		/*

   768 		/*

   655 		 * (non-Javadoc)

   769 		 * (non-Javadoc)

   656 		 * 

   770 		 * 

   671 		 * @see

   785 		 * @see

   672 		 * org.eclipse.draw2d.MouseMotionListener#mouseMoved(org.eclipse.draw2d

   786 		 * org.eclipse.draw2d.MouseMotionListener#mouseMoved(org.eclipse.draw2d

   673 		 * .MouseEvent)

   787 		 * .MouseEvent)

   674 		 */

   788 		 */

   675 		public void mouseMoved(MouseEvent e) {

   789 		public void mouseMoved(MouseEvent e) {

   677 		}

   791 		}

   678 

   792 

   679 		/*

   793 		/*

   680 		 * (non-Javadoc)

   794 		 * (non-Javadoc)

   681 		 * 

   795 		 * 

   714 				beingDragged = false;

   828 				beingDragged = false;

   715 				// finished drag - perform zoom in now

   829 				// finished drag - perform zoom in now

   716 

   830 

   717 				// set new scale

   831 				// set new scale

   718 				int dragEnd = me.getLocation().x;

   832 				int dragEnd = me.getLocation().x;

   721 				int dragWindowStartTime = (int) (dragLeftX * getScale());

   841 				int dragWindowStartTime = (int) (dragLeftX * getScale());

   722 

   842 

   724 				int dragWidth = dragRightX - dragLeftX;// drag area width

   843 				int dragWidth = dragRightX - dragLeftX;// drag area width

   726 				double newScale = getScale() * dragWidth / oldVisibleWidth;

   847 				double newScale = getScale() * dragWidth / oldVisibleWidth;

   727 				if (newScale < 1.0) {

   848 				if (newScale < 1.0) {

   728 					// don't allow a scale smaller than 1 millisecond per pixel

   849 					// don't allow a scale smaller than 1 millisecond per pixel

   729 					// TODO: indicate a failed zoom

   850 					// TODO: indicate a failed zoom

   730 					return;

   851 					return;

   734 

   855 

   735 				// set new window location

   856 				// set new window location

   736 				setScale(newScale);

   857 				setScale(newScale);

   737 				setZoomedSize(dragLeftXScaled);

   858 				setZoomedSize(dragLeftXScaled);

   738 

   859 

   741 			} else if (me.button == 3) {

   862 			} else if (me.button == 3) {

   742 				// mouse right click - zoom out

   863 				// mouse right click - zoom out

   743 

   864 

   745 				if (getScale() < maxScale) {

   867 				if (getScale() < maxScale) {

   746 					double newScale = GraphUtils.nextScale(getScale(), true);

   868 					double newScale = GraphUtils.nextScale(getScale(), true);

   747 					if (getScale() != newScale) {

   869 					if (getScale() != newScale) {

   748 						if (newScale > maxScale) {

   870 						if (newScale > maxScale) {

   749 							newScale = maxScale;

   871 							newScale = maxScale;

   750 						}

   872 						}

   751 

   873 

   752 						// get left window edge is ms to be set to after zooming

   874 						// get left window edge is ms to be set to after zooming

   754 						setScale(newScale);

   877 						setScale(newScale);

   755 						setZoomedSize((int) (leftEdgeInMs / newScale));

   878 						setZoomedSize((int) (leftEdgeInMs / newScale));

   756 					}

   879 					}

   757 				}

   880 				}

   758 			} else if (me.button == 1) {

   881 			} else if (me.button == 1) {

   759 				BaseInfo info = findClosest(me.x, me.y);

   882 				BaseInfo info = findClosest(me.x, me.y);

   760 				if (info != null) {

   883 				if (info != null) {

   762 					lastShownAlloc = info;

   891 					lastShownAlloc = info;

   763 				}

   892 				}

   768 

   895 

   769 		public void keyPressed(KeyEvent ke) {

   896 		public void keyPressed(KeyEvent ke) {

   771 		}

   898 		}

   772 

   899 

   773 		public void keyReleased(KeyEvent ke) {

   900 		public void keyReleased(KeyEvent ke) {

   774 			if (ke.keycode == SWT.ARROW_RIGHT || ke.keycode == SWT.ARROW_LEFT) {

   901 			if (ke.keycode == SWT.ARROW_RIGHT || ke.keycode == SWT.ARROW_LEFT) {

   775 				if (lastShownAlloc != null) {

   902 				if (lastShownAlloc != null) {

   777 					if (info != null) {

   905 					if (info != null) {

   779 						lastShownAlloc = info;

   912 						lastShownAlloc = info;

   782 						int x = getLocationOnGraph(info).x;

   916 						int x = getLocationOnGraph(info).x;

   788 							}

   924 							}

   789 							getViewport().getHorizontalRangeModel().setValue(x);

   925 							getViewport().getHorizontalRangeModel().setValue(x);

   791 							x -= (width - 10);

   927 							x -= (width - 10);

   793 						}

   929 						}

   794 						AnalyzeToolGraph.this.redraw();

   930 						AnalyzeToolGraph.this.redraw();

   795 					}

   931 					}

   796 				}

   932 				}

   797 			}

   933 			}

   799 		}

   934 		}

   800 

   935 

   801 		/**

   936 		/**

   803 		 */

   938 		 */

   804 		public void clearState() {

   939 		public void clearState() {

   805 			mouseButton = 0;

   940 			mouseButton = 0;

   806 			start = null;

   941 			start = null;

   807 			beingDragged = false;

   942 			beingDragged = false;

   808 			lastShownAlloc = null;

   943 			lastShownAlloc = null;

   809 			lastMouse = null;

   944 			lastMouse = null;

   823 	 * @return the appropriate SWT system color code

   958 	 * @return the appropriate SWT system color code

   824 	 */

   959 	 */

   826 		int color;

   961 		int color;

   827 		if (info instanceof AllocInfo) {

   962 		if (info instanceof AllocInfo) {

   828 			if (((AllocInfo) info).isFreed()) {

   963 			if (((AllocInfo) info).isFreed()) {

   829 				color = SWT.COLOR_DARK_BLUE;

   964 				color = SWT.COLOR_DARK_BLUE;

   830 			} else {

   965 			} else {

   833 		} else {

   968 		} else {

   834 			color = SWT.COLOR_DARK_GREEN;

   969 			color = SWT.COLOR_DARK_GREEN;

   835 		}

   970 		}

   836 		return color;

   971 		return color;

   837 	}

   972 	}

   844 	 * @return true if leak, false otherwise

   980 	 * @return true if leak, false otherwise

   845 	 */

   981 	 */

   848 	}

   985 	}

   849 

   986 

   850 	/**

   987 	/**

   851 	 * 

   988 	 * 

   852 	 * Converts bytes from/to Y values

   989 	 * Converts bytes from/to Y values

   868 		public double yToBytes(int y) {

  1005 		public double yToBytes(int y) {

   869 			return (visY - y) * multiplier;

  1006 			return (visY - y) * multiplier;

   870 		}

  1007 		}

   871 	}

  1008 	}

   872 

  1009 

   875 	 */

  1016 	 */

   876 	public void onProcessesAdded() {

  1017 	public void onProcessesAdded() {

   878 		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

  1019 		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

   879 			public void run() {

  1020 			public void run() {

   880 				mc.clearState();

  1021 				mc.clearState();

   881 				zoomGraph();

  1022 				zoomGraph();

   882 				redraw();

  1023 				redraw();

   883 			}

  1024 			}

   884 		});

  1025 		});

   885 	}

  1026 	}

   886 

  1027 

   889 	 */

  1035 	 */

   890 	public void onProcessSelected(ProcessInfo p) {

  1036 	public void onProcessSelected(ProcessInfo p) {

   891 		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

  1037 		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

   892 			public void run() {

  1038 			public void run() {

   893 				mc.clearState();

  1039 				mc.clearState();

   895 				userInformed = false;

  1043 				userInformed = false;

   896 				zoomGraph();

  1044 				zoomGraph();

   897 				redraw();

  1045 				redraw();

   898 			}

  1046 			}

   899 		});

  1047 		});

   900 	}

  1048 	}

   902 	@Override

  1050 	@Override

   903 	public void dispose() {

  1051 	public void dispose() {

   905 		site.setSelectionProvider(null);

  1054 		site.setSelectionProvider(null);

   906 		iDotsSelecProv = null;

  1055 		iDotsSelecProv = null;

   908 			timeImage.dispose();

  1057 			timeImage.dispose();

   909 		}

  1058 		}

   910 		IPartService partService = PlatformUI.getWorkbench()

  1059 		IPartService partService = PlatformUI.getWorkbench()

   912 		partService.removePartListener(iGraphPartServiceListener);

  1061 		partService.removePartListener(iGraphPartServiceListener);

   913 		iGraphPartServiceListener = null;

  1062 		iGraphPartServiceListener = null;

   914 		if (iSymReader != null) {

  1063 		if (iSymReader != null) {

   915 			iSymReader.dispose();

  1064 			iSymReader.dispose();

   916 			iSymReader = null;

  1065 			iSymReader = null;

   917 		}

  1066 		}

   918 	}

  1067 	}

   920 	private void setZoomedSize(final int newXLocation) {

  1069 	private void setZoomedSize(final int newXLocation) {

   921 		int prefSize = (int) (getMaxTimeValueInMilliSeconds() / getScale());

  1070 		int prefSize = (int) (getMaxTimeValueInMilliSeconds() / getScale());

   922 

  1071 

   923 		// new width has to propagate to viewport first before we can set

  1072 		// new width has to propagate to viewport first before we can set

   924 		// the new viewport selection

  1073 		// the new viewport selection

   925 		// set newXLocation in listener

  1074 		// set newXLocation in listener

   926 		Panel panel = (Panel) (getContents());

  1075 		Panel panel = (Panel) (getContents());

   927 		panel.setPreferredSize(prefSize, 0);

  1076 		panel.setPreferredSize(prefSize, 0);

   928 

  1077 

   929 		if (prefSize > getClientArea().width) {

  1078 		if (prefSize > getClientArea().width) {

   939 			panel.setSize(prefSize, 0);

  1091 			panel.setSize(prefSize, 0);

   940 

  1092 

   941 		} else {

  1093 		} else {

   953 		private ListenerList iSelectionChangedListeners = new ListenerList();

  1108 		private ListenerList iSelectionChangedListeners = new ListenerList();

   954 

  1109 

   960 			iSelectionChangedListeners.add(listener);

  1120 			iSelectionChangedListeners.add(listener);

   965 		 * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()

  1126 		 * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()

   966 		 */

  1127 		 */

   967 		public ISelection getSelection() {

  1128 		public ISelection getSelection() {

   968 			return iCurrentSelectedDot;

  1129 			return iCurrentSelectedDot;

   969 		}

  1130 		}

   970 

  1131 

   975 			iSelectionChangedListeners.remove(listener);

  1141 			iSelectionChangedListeners.remove(listener);

   981 		 */

  1150 		 */

   982 		public void setSelection(ISelection selection) {

  1151 		public void setSelection(ISelection selection) {

   983 			iCurrentSelectedDot = selection;

  1152 			iCurrentSelectedDot = selection;

   985 			for (final Object listenerObj : iSelectionChangedListeners

  1154 			for (final Object listenerObj : iSelectionChangedListeners

   988 				((ISelectionChangedListener) listenerObj)

  1156 				((ISelectionChangedListener) listenerObj)

   995 		 */

  1168 		 */

   996 		public void widgetDefaultSelected(SelectionEvent event) {

  1169 		public void widgetDefaultSelected(SelectionEvent event) {

   997 			widgetSelected(event);

  1170 			widgetSelected(event);

  1003 		 */

  1179 		 */

  1004 		public void widgetSelected(SelectionEvent arg0) {

  1180 		public void widgetSelected(SelectionEvent arg0) {

  1005 			for (final Object listenerObj : iSelectionChangedListeners

  1181 			for (final Object listenerObj : iSelectionChangedListeners

  1008 				((ISelectionChangedListener) listenerObj)

  1183 				((ISelectionChangedListener) listenerObj)

  1024 

  1199 

  1025 		public void partActivated(IWorkbenchPart part) {

  1200 		public void partActivated(IWorkbenchPart part) {

  1026 			if (part instanceof MainView || part instanceof PropertySheet) {

  1201 			if (part instanceof MainView || part instanceof PropertySheet) {

  1028 				site = part.getSite();

  1203 				site = part.getSite();

  1030 				site.setSelectionProvider(iDotsSelecProv);

  1205 				site.setSelectionProvider(iDotsSelecProv);

  1031 				if (part instanceof MainView && iSymReader != null) {

  1206 				if (part instanceof MainView && iSymReader != null) {

  1032 					iSymReader.reOpenCachedSymbolFiles();

  1207 					iSymReader.reOpenCachedSymbolFiles();

  1033 				}

  1208 				}

  1034 			}

  1209 			}

  1035 		}

  1210 		}

  1036 

  1211 

  1037 		public void partBroughtToTop(IWorkbenchPart part) {

  1212 		public void partBroughtToTop(IWorkbenchPart part) {

  1039 		}

  1214 		}

  1040 

  1215 

  1041 		public void partClosed(IWorkbenchPart part) {

  1216 		public void partClosed(IWorkbenchPart part) {

  1044 				site = part.getSite();

  1219 				site = part.getSite();

  1047 				site.setSelectionProvider(null);

  1222 				site.setSelectionProvider(null);

  1048 			}

  1223 			}

  1049 		}

  1224 		}

  1050 

  1225 

  1051 		public void partDeactivated(IWorkbenchPart part) {

  1226 		public void partDeactivated(IWorkbenchPart part) {

  1053 			if (part instanceof MainView && iSymReader != null) {

  1229 			if (part instanceof MainView && iSymReader != null) {

  1054 				iSymReader.closeCachedSymbolFiles();

  1230 				iSymReader.closeCachedSymbolFiles();

  1055 			}

  1231 			}

  1056 		}

  1232 		}

  1057 

  1233 

  1058 		public void partOpened(IWorkbenchPart part) {

  1234 		public void partOpened(IWorkbenchPart part) {

  1059 			if (part instanceof MainView) {

  1235 			if (part instanceof MainView) {

  1060 				try {

  1236 				try {

  1062 				} catch (PartInitException e) {

  1239 				} catch (PartInitException e) {

  1065 				}

  1243 				}

  1066 			}

  1244 			}

  1067 		}

  1245 		}

  1068 

  1246 

  1069 		public void windowActivated(IWorkbenchWindow window) {

  1247 		public void windowActivated(IWorkbenchWindow window) {

  1071 				iSymReader.reOpenCachedSymbolFiles();

  1250 				iSymReader.reOpenCachedSymbolFiles();

  1073 		}

  1252 		}

  1074 

  1253 

  1075 		public void windowClosed(IWorkbenchWindow window) {

  1254 		public void windowClosed(IWorkbenchWindow window) {

  1078 		}

  1257 		}

  1079 

  1258 

  1080 		public void windowDeactivated(IWorkbenchWindow window) {

  1259 		public void windowDeactivated(IWorkbenchWindow window) {

  1081 			// the user might do a re-build from the command line

  1260 			// the user might do a re-build from the command line

  1082 			if (iSymReader != null) {

  1261 			if (iSymReader != null) {

  1083 				iSymReader.closeCachedSymbolFiles();

  1262 				iSymReader.closeCachedSymbolFiles();

  1085 		}

  1264 		}

  1086 

  1265 

  1087 		public void windowOpened(IWorkbenchWindow window) {

  1266 		public void windowOpened(IWorkbenchWindow window) {

  1092 	/**

  1271 	/**

  1093 	 * set a new project

  1272 	 * set a new project

  1094 	 * @param aProject

  1274 	 * @param aProject

  1095 	 */

  1275 	 */

  1096 	public void setProject(IProject aProject) {

  1276 	public void setProject(IProject aProject) {

  1098 			iCurrentProject = aProject;

  1278 			iCurrentProject = aProject;

  1099 			iSymReader = new SymReader(aProject);

  1279 			iSymReader = new SymReader(aProject);

  1100 			iSymReader.loadProjectTargetsInfo();

  1280 			iSymReader.loadProjectTargetsInfo();

  1101 			ResourceVisitor visitor = new ResourceVisitor(this);

  1281 			ResourceVisitor visitor = new ResourceVisitor(this);

  1102 			try {

  1282 			try {

  1103 				iCurrentProject.accept(visitor);

  1283 				iCurrentProject.accept(visitor);

  1104 			} catch (CoreException ce) {

  1284 			} catch (CoreException ce) {

  1106 				Activator.getDefault().log(IStatus.ERROR, ce.getMessage(), ce);

  1286 				Activator.getDefault().log(IStatus.ERROR, ce.getMessage(), ce);

  1107 			}

  1287 			}

  1108 		}

  1288 		}

  1109 	}

  1289 	}

  1115 	 * @param resource

  1295 	 * @param resource

  1116 	 */

  1296 	 */

  1117 	public final void loadFileInfo(IResource resource) {

  1297 	public final void loadFileInfo(IResource resource) {

  1118 		// get all the cpp file info which are belongs to current project

  1298 		// get all the cpp file info which are belongs to current project

  1119 		String cppFileName = Util.getCPPFileNameAndPath(resource);

  1299 		String cppFileName = Util.getCPPFileNameAndPath(resource);

  1122 		if (cppFileName != null && !cppFileNames.contains(cppFileName)) {

  1302 		if (cppFileName != null && !cppFileNames.contains(cppFileName)) {

  1123 			this.cppFileNames.add(cppFileName);

  1303 			this.cppFileNames.add(cppFileName);

  1124 		}

  1304 		}

  1125 	}

  1305 	}

  1126 

  1306 

  1127 }

  1324 }