2010-09-10  Jeff Johnston  <jjohnstn@redhat.com>

	* META-INF/MANIFEST.MF: Add dependency on zest plug-ins rather than importing packages
	within them.

2010-06-02  Roland Grunberg  <rgrunber@redhat.com>

	* plugin.properties: Externalize some strings in the Manifest.
	* build.properties: See above
	* META-INF/MANIFEST.MF: See above
	* plugin.xml: See above

2010-03-22  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/graphlisteners/StapGraphMouseListener.java (controlDoubleClick):
		Remove unnecessary return value from this method.

2010-02-23  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Fix markers to work with threads

2010-02-01  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/graphlisteners/StapGraphMouseListener.java: ctrl+double-click go to actual function instead of its parent. Very confusing otherwise.

2010-01-28  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java : Clean up unnecessary code.

2010-01-26  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix miscounting caused by lack of proper escape clause.

2010-01-22  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: removed extra loadData function that is never used.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix miscounting in non-dot-file-node

2010-01-22  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java:
		(createPartControl): Prepare for removal of Error Log window functionality.

2010-01-18  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Add addCalled method, which increments the timesCalled variable on stapData corresponding to the input id.
	Change bounds on radius in radial view.
	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Add multiple identical entries to neighbourMap for collapsed nodes (dot-file)
	Proper error catching for number parsing failures.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Properly attach dot-file nodes with id < 0
	Properly account for collapsed nodes (dot-file)
	Cleanup of TODO's

2010-01-14  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Remove extraneous println

2010-01-13  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Add function parseDotFile() -- all calls to this function assumes non-real-time.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add capacity for parsing .dot files generated by the program

2009-12-24  rgrunber  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java 
		(setGraphOptions): Add save_text so it is disabled when context does not require it. 
	* src/org/eclipse/linuxtools/callgraph/messages.properties:
		Give relevant names to save_text externalized Strings.

2009-12-23  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Properly align nodes in radial mode. No more annoying 'just-off-center'ness!!
	Remove System.out.println hooks.

2009-12-21  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Gentle code cleaning
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix setLimits logic
	Add save as ASCII option -- TODO: Implement a table view in Eclipse.

2009-12-18  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Reorganize menus and externalize.

2009-12-17  rgrunber  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/messages.properties:
		Rename externalized strings to be more descriptive.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java:
	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: 
	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: 

2009-12-15  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Make the project variable non-mandatory. Read and reset buffer to avoid eating an extra line while looking for project name.
	
2009-12-15  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Minor name change to File option.
	* src/org/eclipse/linuxtools/callgraph/treeviewer/StapTreeDoubleClickListener.java: Do not maximize Callgraph View when clicking on list element.

2009-12-15  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Terminate properly if an unknown symbol is encountered. Do not split on the semicolon
	Add extra catch to prevent missing data in the graph.

2009-12-11  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix misgraph error in the writeToDot function. 
	Minor StringBuilder optimization tweak. Create function writeToDot to handle writing to dot, all three actions call this function with different parameters. 
	Add "Save current view as .dot" which will save only the currently visible nodes, in whatever collapse mode they are in. Fix problem where nodes will display parent's timeCalled instead of their own.  
	Add check for nullity when attaching parent nodes.
	Add a missing newline to uncollapsed.
	Do not graph Start Of Program
	
	

2009-12-11  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Do not try to find parent for the root node.

2009-12-11  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Write to .dot in a slightly modified way that will make it easier for users to just delete chunks of data and still graph accurately. (FIX: uncollapse should attach to d.parent, not d.collapsedParent)

2009-12-11  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Reset StringBuilder per iteration as opposed to creating a new one each time.

2009-12-11  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapNode.java: Make numberFormat public.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Create the 'Save as .dot' option.
	Create 'save uncollapsed as .dot' and 'save collapsed as .dot' options in the File menu.
	Remove unused import.
	Rename save_dot, save_col_dot. Add these to the list of actions enabled/disabled by opening a graph.
	Do not label edges in uncollapsed .dot files. Change order of collapsed/uncollapsed .dot's
	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Make the DataMap publically accessible

2009-12-10  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Quit with error message if opening a file encounters an I/O error.

2009-12-09  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java (getFirstUsefulNode): Return 0 if threaded
	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java (parse): Add basic threading capability into parse. Create maps sorted by thread ID for neighbours.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java (loadData): Add basic threading capability into loadData
	Fix faulty marking of threaded nodes.
	(view_radialview): Set StapGraph.threaded if the profiled program contains threads.

2009-12-08  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Return endTime - time if time > 38 years

2009-12-01  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: While collapsing nodes, first check for existing collapsed nodes.

2009-11-20  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java (finishLoad): Set project in the regular load, not just in finishLoad

2009-11-17  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Fix draw() to redraw from the root visible node number rather than the first available node.

2009-11-16  Roland Grunberg  <rgrunber@redhat.com>

	* META-INF/MANIFEST.MF: Add Eclipse to Provider field.

2009-11-12  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapData.java (StapData): Eliminate useless variables, rearrange functions, add javadoc.
	* src/org/eclipse/linuxtools/callgraph/AggregateLayoutAlgorithm.java (postLayoutAlgorithm): Rearrange declarations, update documentation.

2009-11-10  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Up/Down.gif now refer to the correct icons. Remove import of CallgraphCorePlugin
	

2009-11-09  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapData.java: Cleanup
	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Delete unused functions, simplify logic in StapGraph setCollapsedMode.

2009-11-09  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java:  Externalize/Fix Strings
	* src/org/eclipse/linuxtools/callgraph/messages.properties:
	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: 

2009-11-09  Charley Wang  <chwang@redhat.com>

	* META-INF/MANIFEST.MF: Change reference to Activator to reflect name change
	* src/org/eclipse/linuxtools/callgraph/treeviewer/StapTreeLabelProvider.java: Change references to PLUGIN_LOCATION to use getter.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Change references to PLUGIN_LOCATION to use getter.
	* src/org/eclipse/linuxtools/callgraph/CallGraphConstants.java: Change PLUGIN_LOCATION to private, create getter.
	* src/org/eclipse/linuxtools/callgraph/CallgraphPlugin.java: RENAME: Activator --> CallgraphPlugin

2009-11-06  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/AggregateLayoutAlgorithm.java: Improve javadocs
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add better progress monitor use to updateMethod.
	Remove many unused methods. Remove reference to SystemTapView because we can just use 'this' instead.
	 
	

2009-11-05  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Rename loadView --> initializeView
	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Externalize strings.
	* src/org/eclipse/linuxtools/callgraph/messages.properties: Updated UnknownMarkers error message.

2009-11-04  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Make Callgraph draw in space provided regardless of window size or view size.

2009-11-04  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Make nonRealTimeParser work again
	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Fix problem with marked messages not displaying until the methods have closed.
	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Remove unused comments. Minor formatting. Make nonRealTimeParser work again.
	
	

2009-11-03  chwang  <chwang@toto>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Delete unused temporary variable

2009-11-03  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Disable Callgraph View from stealing focus when an update has been made.

2009-11-03  chwang  <chwang@toto>

	* src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix capability to mark nodes.
	* src/org/eclipse/linuxtools/callgraph/StapGraph.java: Enhance capability for collapse nodes by making collapse nodes take a negative ID. 